Skip to content

Edit: seams reach the settle point in a paragraph's last line - #519

Merged
DongyuZhao merged 300 commits into
mainfrom
claude/project-thread-raxrtq
Nov 16, 2026
Merged

DongyuZhao merged 300 commits into
mainfrom
claude/project-thread-raxrtq

Conversation

@DongyuZhao

Copy link
Copy Markdown
Contributor

Second step of the no-flush plan (edits as cheap as appends). After this step, an edit at a paragraph's end parses inline content from as late as a snapshot does. Before, it started from a seam at least two lines back.

Changes

  • Seam margin 0. S_seam_pick takes seams up to the rest line's start. A line the reading reads can leave the content short of the picked seam: a table delimiter row takes its head, a setext underline, or an edited line interrupts the paragraph. In that case the new S_seam_shrink falls back to the last seam the content still reaches past. Before, the margin of two lines existed to avoid the only fallback there was, which reread the whole paragraph.
  • Inner seams. Settle starts inside the content's last line become seams too (inner, plus base, their distance from the line start).
    • They stand only for an edit that starts where the old content ended, and only while the new content keeps all of the old content (S_seam_holds). This is the same condition the snapshot's settle point relies on.
    • S_seam_pick drops them for any other edit, and S_seam_end drops those of a line that is no longer last.
    • Place reads resume from the inner seam's line start.
  • Fix of an existing bug. The table element sets TABLE_VISITED on a paragraph whose delimiter-like line found no matching header. An edit that rested inside such a paragraph kept the flag that the old reading had set on a later line. So editing that line into a valid delimiter row made no table. Repro on main: flush x\na | b\n| - |, then insert - at the end. Now a paragraph with any element flag set does not leap (markdown_core_parser_leaps), and the edit reads it from its start.

Numbers

Typing at a document's end in 1–12 byte edits on a flushed session. Local gcc 13 release build; Ir per edit call:

Shape Before (main) After Append
100-line paragraph, emphasis 75.6k 22.9k 14k
200-line paragraph, emphasis 75.9k 23.1k 14k
100-line paragraph, plain 25.9k 19.5k n/a
Single-line paragraphs 48.6k 48.6k 30.5k

The 8 benchmark documents barely move, because their blocks are short. For short blocks, the remaining gap has other causes, and those are the next step:

  • The rest point steps back to the previous sibling.
  • A paragraph of fewer than three lines cannot be rested in.

Testing

  • New api test session_typed_paragraph_end_matches_a_parse:
    • 8 texts typed at their end with steps of 1–7 bytes, and 5 texts written a line at a time. Covered cases: tables, setext underlines of both kinds, hard breaks, a code span across lines, a later definition, a list, and CRLF.
    • After every edit, the session's document is compared with a full parse.
    • Before the leap fix, the test failed on main.
  • Full debug suite: 151/151 passed. The asan api_test passed.

Generated by Claude Code

claude added 30 commits October 29, 2026 11:17
The FINAL prefix's edit check made GCC 15 stop inlining
publish_relation_begin into publish_matched, a per-step cost on the
stream session path. It is always inlined now, as its neighbours are.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
The widths and the reread range are made at a session's first edit, so a
session that is only streamed keeps the size it had: the 32 bytes they
added moved the session into another malloc size class, and the heap's
layout after it, which cost some stream windows 3%.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
…, stage 1)

## What

Before this change, an edit inside a list item, callout or footnote
reread the whole root child that held it: one edit near the end of a
long list read the entire list again. Now the reading starts at a rest
point inside that container, at any depth. It reopens the chain of
containers from the root's child down to the rest point. Then it reads
on from there until the top-level resync (E1a) takes the old blocks
back.

Plan: `e1b-nested.md`, stage E1b-1. Resync and splice at depth is the
next stage.

## How

- **Nested rest point** (`session_rest_in`, session.c). The search
  descends while the held child is a container whose element sets
  `reopens` and the edited line is past its first line. At each level it
  picks the last child that:
  - begins after a blank (or prefix-only) line;
  - has a gap before its previous sibling, so no lazy line or split
    reference paragraph runs into it;
  - has no reading that started before the chain spanning its start.
  Child windows come from `markdown_core_node_window`.
- **Reopen the chain** (`S_reopen_chain`, blocks.c). Each chain node
  goes OPEN again, and its kept children are folded again. The new
  `reopen_block` hook lets an element undo what its close decided. Here
  that is the list's looseness. The engine still names no kinds: the
  hook and the `reopens` flag come from the elements. Elements opt in
  with `reopens`: list, callout, footnote and specimen. Tables are left
  out.
- **The blank state before the rest point** (`markdown_core_parser_rest_blank`).
  It tells each chain level whether the line before the rest point was
  blank to it, so the deepest node's last-line-blank flag matches a
  fresh parse.
- **The reach log.** It keeps each entry's raw end and builds a separate
  prefix maximum (`furthest`) for the span queries. This lets the root
  chain node's own close entry be found and dropped at reopen (it closes
  again where the reading closes it). `markdown_core_parser_spanned_inside`
  finds readings that start inside the chain.
- **Publish** (ast.c). Each chain node is recorded as open under its
  owner, with its kept children FINAL. Definitions in a chain node keep
  their place in the table (`publish_chain_rank`), so nested footnotes
  list in source order.

Hot paths are unchanged. Everything new runs at edit time or behind
`edit->depth`.

## Results

- The differential fuzz compares against a fresh `Document.parse`:
  20,000 container-heavy documents × 20 edits, plus 10,000 mixed ones.
  All match. The rest points it hit were at depths 1 to 4.
- Bytes reread per edit over `specs/incremental`, before → after:
  - list-ascii-16k: 11,694 → 5,833.
  - list-utf8-16k: 12,125 → 6,196.
  - Every other family is the same or lower. The whole set averages
    10,719 → 10,466.
- The incremental oracle suites and the api_incremental tests pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
- A container with one child (a one-item list, a quote holding one list)
  is now descended too: the search needs a child to go into, not two.
- A reopened root child closed by its own end condition (a directive's
  closer) notes its close at its last line, as one the input's end
  closes does, so that entry is the chain's own close too.
- Definition lists and directives reopen (`reopens`), as the plan's
  E1b-1 lists them. A definition's body is not published and has no
  window, so no rest point is looked for below one.

Bytes reread per edit over specs/incremental: quote-16k 15.9k -> 10.8k,
opener-directive-16k 16.3k -> 10.3k, nameless-directives 213 -> 164; the
whole set 10,466 -> 9,891 (main: 10,719).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
…pth (step E1b, stage 2)

A reading reopened inside a container now resyncs at the child the chain
let go, at any level, and splices the rest of the old children back: each
block of the chain closes as it closed before, with the flags its children
fold refolded. Lists whose items abut (`abuts`) rest and resync between
adjacent items and at their first item. `trailed` becomes per-kind
(`trailed_kinds`), so list items no longer block a resync. The `hard`
incremental family now runs on the session subject.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
The engine names no element kinds: the lookahead that tells the line
leaves the block open inside the chain block asks for a child of the kind
that block already holds, not for a paragraph.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
The reopen kept the content marks whose source fell before the rest
point, but marks read inside a nested block hold sources relative to that
block, so they never compared past it: a nested list read again on every
edit grew line_marks without bound (22 MB after 2000 edits of the 16k
list fixture, 11x a fresh parse). Every map the flush made is complete, so
the reopen now truncates to the identity run.

The fuzz runner reads each input twice: once as appends, as before, and
once switching to edits at the first head byte with the high bit set, so
the edit oracle sees random inputs too. Edits whose ends fall after a
continuation byte at a line start are skipped, since such positions are
ambiguous in UTF-16.

An api test makes a thousand edits to a small nested list and checks the
session holds no more than after the first hundred; it fails without the
fix (4x growth).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
… part 2)

The compaction of plan 12.4 (E-D4). The pool keeps the slots each reading
lets go for the next, so it holds what the most text the session held
needed. The session keeps that peak, and an edit that leaves less than
half of it reads the whole text: it drops the pool's released slots and
slab first, so the new nodes take new slabs, and again after, so the old
slabs go with the old nodes. The input's lines, the content marks, the
line facts and the edit's scratch then shrink to the text
(markdown_core_parser_compact, markdown_core_array_shrink). Ids stay, as
for any whole reading.

On the 16k list fixture an edit that deletes 90% of the text now leaves
1.35x the storage of a fresh parse, down from 7.6x. An api test checks
2x after such an edit, and fails without the compaction.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Three cases where a snapshot settled what a longer input reads otherwise,
found by the edit-aware fuzz runner (4.6, then 4.1 at the flush):

- A `$` pair whose body a code span begins makes no formula, but the
  pairing still took the delimiters between its two away, so a reading
  from a settle point between them paired a `*` the whole reading drops.
  The rejected pair now holds the run undecided from its opener
  (markdown_core_inline_state_undecide).
- An attribute block whose quote the input's end leaves open, or closes
  at the very end, reads that quote as an unquoted value's byte; the
  input going on undoes it. The recogniser now says it ran out
  (`ran_out`), and the run reports the end read as it does for a block
  that does not close.
- A topic's name reads the character after it whole, up to four bytes,
  but reported an end read only within three of the end. It now reports
  within four, and five after a `/`.

Each case is a source of session_flush_matches_a_parse, which fails
without its fix.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
…t openers

A formula scanner asks how many `$` openers are unmatched to read a `$` as
a closer. An opener that an emphasis pair around it takes away still counted
at those scans, so a reading from past the emphasis, without the opener,
could read a later `$` as an opener instead. The core now notes the rules
whose scanners ask that count, and the start of a removed opener of such a
rule is an undecided start.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
The wire's markdown_core_wire_session_edit answers an edit's document as a
step's message. Swift's MarkdownSession.edit(from:to:with:), and Kotlin's
and ECMAScript's edit(start, end, text), replace the text between two
cursors in the session's unit and return the parse of the new text. An edit
before the flush throws the new code sessionStreaming (SESSION_STREAMING);
one out of bounds or backwards throws outOfBounds and leaves the context.

Each binding sweeps an insertion and its undo over every cursor of a text
and checks each document against a fresh parse, and checks that a node the
edit did not reach is the old node.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Document.content holds existential markup, which == cannot compare.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
…step E3)

didOpen parses the text into the document's session and flushes it, each
didChange content change is one session edit, and completion locates the
session at its cursor. The server holds no copy of the text: the new
markdown_core_session_source lends the session's. A change whose scope is
backwards is refused before any edit applies; an edit that cannot allocate
closes the document. The sync oracle now compares the session's document
with a fresh parse of its text after every change.

Reading the session's exact-sized text showed a context query reading one
byte past the text at a destination the text's end opens, such as `[a](`;
it now reads only the text, with a facade test on an exact-sized buffer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
…p 4b)

MarkdownCoreLSP.Server wraps markdown-core-lsp: initialize, shutdown,
phase, open, update, close and complete, with the protocol's Position,
Scope and Change, Capabilities, Completions and ServerError. The C engine
builds from source as the MarkdownCoreLSPC target. The conformance tests
replay specs/lsp/transcripts through the server, bundled by the resource
plugin, and the release manifest, source archive and product build carry
the second product.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Kotlin's com.nouprax.markdown.core.lsp.Server and the ECMAScript entry
point @nouprax/es-markdown-core/lsp join MarkdownCoreLSP.Server: one
method per protocol method of markdown-core-lsp, with Position, Scope,
Edit, Capabilities, Completions and an error carrying the protocol's
code. Kotlin's JNI library and cinterop definition link the engine, whose
natives register on the parser's JNI holder; the WebAssembly module
compiles and exports it. A content change is now an Edit in Swift too,
by the naming rule.

Each binding's tests replay specs/lsp/transcripts in process: Kotlin
from a generated common-test source, ECMAScript from the bundled
conformance fixtures. The source-list and public-surface audits, the
JVM surface record, the ABI dumps and the npm packaging test know the
new sources and entry point.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
…ader refuse

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
…names as bytes

The measure is now a polynomial in a generator G of the residues modulo
2^61 - 1, read through byte tables, so no repeating pattern of byte changes
cancels; the Codex family of colliding headings no longer shares a measure.
The committed naming pass, which reads every base whole, files names under a
byte hash read in parts (markdown_core_key_stream), so a base's hash is read
once for all its suffixes; edits keep the measure. Holders whose bases are of
the name's base size are compared by suffix and one comparison of bases.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
…enerator

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
…er for every heading

Swapping the projection's storage into the node left the pass a buffer to
grow again from nothing for the next heading, several reallocations per
heading; a copy is one allocation, as the joined anchor was before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
core/tree.{h,c} is one B+ tree of fixed-size entries (leaves of 64,
fanout 16) with a focus that splits it into a front in new text terms
and a back in old text terms, pending shifts, optional end measures
(tree_past), key ordering for label trees, and handles kept current by
a `moved` callback. It replaces the zipper and every hand-rolled index:

- input lines (facts dropped as lines move to the back), reach, uses
- committed tables (listed entries by id -> handle) and their labels
- roster places (record id -> handle)
- headings and heading-name stems
- session child widths
- the label key tree (map.c)

core/zipper.h is gone. Document reads use the pure tree_peek and
tree_seek, so concurrent read-only access stays safe.

The stream driver keeps its per-line cost within the stage gate: leaves
are not zeroed, the next line's start is read from the terminator, an
edit's line insert is a cold path, properties walk lines in runs
(tree_run), and a new child takes its offset from the line at hand.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
An edit's splice cut, shifted and unlabeled one table at a time, so a
reference definition whose label fell to a later heading looked the
heading up in old-text terms and lost the label. Take and shift every
table first, then move the labels on. A sweep of whole-line edits over
texts whose labels cross tables checks the trees and tables against a
fresh parse.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Headings prepare runs its loop only when a heading waits, a tree of one
leaf erases in that leaf, and an erase of nothing returns inline.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
An insertion that joins the front at the end appends in place, a cut of
the last leaf's tail leaves the leaf and lowers only the counts above it,
a one-leaf tree inserts in its leaf, a label table looks a label up once,
and headings in order are read from their stretch of storage.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
The first leaf of a tree starts at eight entries and doubles to a full
leaf while it is the only one, taken anew and copied so small blocks come
from the allocator's caches. Definition tables search the leaf of the
front's last entry directly, the uses flush walks runs, and withdraw skips
tables whose front ends before the root.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
A first leaf that grows from eight entries costs every small document
its growth in the parse stage; the leaf is taken at its full size, as
before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Line places, the dropped facts and a leap's places step through the line
records leaf by leaf, forward with markdown_core_tree_run and back with
the new markdown_core_tree_back, instead of finding each line by rank.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
The snapshot and the locate's look begin, read and end through the same
S_look_begin, S_look_read and S_look_end.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
record_nest records the nodes of a reopened definition's old bodies, and
each record owns its node from then on; the body itself was never
released. Two edits of a definition list that drop a body (a blank line
removed before a term, then put back) left its node, and its slab, alive
past the session's close.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
A session that still streams, and a document, locate through a session of
their whole text, flushed, whose look reads at the cursor (THE LOOK OF A
TEXT AS A WHOLE): the parse of the text before the cursor, with labels
seeded from the whole document, is gone, and context_at always has a
locus. A flushed session with an empty root reads its look with no window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
An edit on the line right after a paragraph's last line -- typing the
first character of a new line at the paragraph's end -- rested at the
paragraph's start and read it again whole, so every new line of a long
paragraph cost as much as the paragraph. The edit now rests in the
paragraph from its last line (THE LEAP), as an edit of one of its own
lines does, and the reading decides whether the edited line goes on with
it. Typing at the end of a 200-line paragraph: 180k -> 76k Ir per edit,
the same as at 100 lines.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
An edit at a paragraph's end now parses its inline content from as late
as a snapshot does, instead of from a seam two lines back.

- The seam margin is 0: a seam may lie at the rest line's start. When the
  content no longer reaches past the picked seam (a delimiter row took
  its head, an underline, an interrupting line), S_seam_shrink falls back
  to the last seam the content still reaches past instead of reading the
  paragraph whole.
- Settle starts inside the content's last line are INNER seams. They
  stand only for an edit from where the old content ended on, and only
  while the new content keeps all of the old (S_seam_holds), the same
  condition the snapshot's settle point relies on.
- A paragraph carrying an element flag (a table's TABLE_VISITED) no
  longer leaps: its reopened node kept the flag the old reading set on a
  later line, so a line edited into a valid delimiter row made no table.
  This was wrong on main too.

Test: a paragraph typed at its end, and lines written at its end, dump
as a full parse after every edit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AvzArumvqU8RFP8mWYPXpj
@DongyuZhao
DongyuZhao requested a review from a team November 16, 2026 16:39
@chatgpt-codex-connector

chatgpt-codex-connector Bot commented Nov 16, 2026 •

Copy link
Copy Markdown
Codex Review Summary: ✅ Completed

This comment shows the latest Codex review activity on this pull request.

Review Status Commit Review trigger
📝 Code Review ✅ Completed 2026-11-16T16:48:52.983625Z c224560 PR opened
ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

@github-actions

github-actions Bot commented Nov 16, 2026 •

Copy link
Copy Markdown

Benchmark

Commit: c22456016b231547b5b257c2361cdf1472b00278 · CI run · CI status: failure

Run and full reports.

Benchmark is required when CI inputs require execution. This ordinary PR comment does not create a review thread to resolve.

Parse stages

Result unavailable. See the run logs and artifacts.

Attribute grammar

Result unavailable. See the run logs and artifacts.

Streams

Result unavailable. See the run logs and artifacts.

Completion latency

Result unavailable. See the run logs and artifacts.

Copy link
Copy Markdown
Contributor Author

CI is red only because of macOS runner availability, not because of this diff. On the first attempt, "Build - Swift / macOS 26" got no runner within 15 minutes and was cancelled. After one rerun of the failed jobs, "Build Test - C / macOS · Clang · Shared" was cancelled the same way. Every downstream test job was skipped, so "Tests - Ready" and "Required gates" fail. All Linux, Windows, iOS and sanitizer builds, the benchmark gates (stage budget 1,584/1,584) and the release dry run passed. I am not rerunning again. The failed jobs can be rerun once macOS runners are available.


Generated by Claude Code

@DongyuZhao
DongyuZhao merged commit 1de5df9 into main Nov 16, 2026
166 of 173 checks passed
DongyuZhao pushed a commit that referenced this pull request Nov 17, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants