Skip to content

perf(ffi): returned objects closed early skip the collector in Go and Dart - #838

Merged
kixelated merged 19 commits into
mainfrom
quest/m1/ffi-speed/object-ownership
Nov 16, 2026
Merged

kixelated merged 19 commits into
mainfrom
quest/m1/ffi-speed/object-ownership

Conversation

@kixelated

@kixelated kixelated commented Nov 15, 2026 •

Copy link
Copy Markdown
Collaborator

Problem

A Go or Dart object return cost ten times C's (Go 263 ns, Dart 242, C 25 on the binding benchmark), and most of it was each runtime's per-object registration with its collector: Go's runtime.AddCleanup and the Cleanup.Stop its Close makes, Dart's Dart_NewFinalizableHandle and its finalization. Every returned frame, group, and future pays it.

Finishes quest/m1/ffi-speed/object-ownership.md, as settled in #828.

Approach

A nursery of the last 64 returned objects. A close of an object still in it frees the handle at once and never registers; one pushed out still open registers then, as before. Explicit Close stays, and the registration stays the backstop, so ownership stays automatic.

  • Go (ffi/runtime/rt.go): a nursery per P, found through a sync.Pool as lending_ finds byte batches. Each handle points at its nursery and slot. A compare-and-swap on the slot decides between its Close and its eviction; an eviction claims the slot with a sentinel before it registers, so a Close that lost waits until the cleanup it must stop is written. The pool's wrapper around each nursery carries one AddCleanup that registers each still-open occupant on its own once the pool drops the nursery, so a dropped object never waits on its nursery-mates being collected. A checked object's Close that no call holds claims the handle closed, then drops the value and frees the handle in one crossing (a C shim in the cgo preamble).
  • Dart (ffi/runtime/rt.dart, ffi/runtime/dart.rs): one nursery in the isolate's _n. Rust keeps a copy of each slot's handle and free function, and one finalizable handle on the nursery frees whatever is still in it once it is unreachable, as at isolate exit. A checked object's close() that no call holds now drops and frees in one crossing. Its calls check a closed flag in Dart and count their holds, as a counted one's do. The flag is set before Rust drops the value, so Dart that the drop runs sees the object closed, and a close that fails under a borrow reopens it and re-registers the object it took out of the nursery.

Validation

  • just ci passes. just moq passes (moq's own API through every language).
  • New api tests, each checked by drop counts:
    • Go: a token dropped in the nursery is freed only once 64 later returns push it out and the GC runs, with the nursery still in use. A token closed after its push out frees at once and the GC frees nothing more. 8 goroutines return 8,000 tokens, closing some of their own and some of each other's while others' returns push them out and dropping the rest: each is freed exactly once.
    • Dart: a dropped token survives collections until 64 returns push it out, then is freed once. Closing a pushed-out token frees it at once and nothing more. An isolate's exit frees what its nursery held.
    • Dart re-entrancy, through a new Journal fixture (a checked type holding a Box<dyn Log>): a Dart Log.close run by the journal's drop sees the journal closed and closing it again closes nothing more. An object closed by a Dart implementation while a call is lowering its arguments is still read by that call and freed after it.
  • Mutation checks: with eviction's registration removed (Go and Dart), the nursery's isolate-exit free removed, or Dart's closed flag set only after the drop, the new tests fail.
  • Go's race detector: the whole Go script runs clean under -race. It is now api_go_race in just ffi sanitize (nightly). The sanitize shell has Go.
  • Merged main through c27427f02, which brings #837 (go-pointers), #839 (ready-await), #844 (not-Send), and #847 (the web target).
  • A fix this merge needed: under the sanitize shell's CC=clang, cgo reads #define <P>_CONTRACT ((uint64_t)0x…ULL) as a negative constant whenever its top bit is set. The runtime's init then panicked with "the Go of api and the library are from different builds". The merged head's contract, 0xf2005c…, has that bit set, so api_go_race failed, and api_go failed in that shell too. gcc reads the constant correctly. The runtime's preamble now returns the macro from a static C function, <p>Go_header_contract(). The bug was latent on main; a contract without the top bit set hides it.
  • Benchmark, re-measured because perf(ffi): Go's calls pass C no pointer to a Go local #837 moved the object out of track.Info() from a Go local into the shim's result struct. 8 rounds of the Go and Dart programs alternate with main at 80ad1c352 (perf(ffi): Go's calls pass C no pointer to a Go local #837 included), on nixos (Ryzen 9 5900XT) at a load average of 12 to 17. Median wall ns:
case Go main Go branch Dart main Dart branch
object return 270 175 (-35%) 200 98 (-51%)
ready read 746 663 (-11%) 926 771 (-17%)
woken read 6,530 5,948 (-9%) 2,517 2,228 (-11%)
stamped write 341 348 359 334

Dart's throughput rows rose 19 to 28%, in MB/s. Go's plain 100 B write read +15% in this batch and -14% in a second batch of 8 Go-only rounds, so it is noise; that second batch also held the object return at -38%. The first measurement, against 72880f48, before #837, had Go at -31% and Dart at -57%. #839 and #844 leave the object return's path as measured: a Send handle's thread check is one branch on None.

Impact

  • Public API: none changes. Behavior:
    • An object dropped without Close is freed later. In Dart that happens once 64 more objects were returned on its isolate, or at isolate exit. In Go it happens once 64 more were returned on its P, or once an idle P's nursery is dropped by the GC (two collections). Previously this happened at the next collection.
    • A Dart call on a closed checked object throws StateError('<Type> is closed') from Dart, not Rust's "moved out" check.
    • A Go call that races a checked Close with no other call holding the handle may see ErrClosed even if that Close then fails, as calls racing main's unchecked Close already may.
  • Generated code: Go's rt.Handle_ loses its exported Cleanup field and gains Own(), and its drop takes a free flag. These are internal to the generated packages. Dart's glue gains <prefix>_dart_nursery and per-object _close_ (checked) entry points.
  • Test fixture: the api fixture gains Journal.
  • Wire: none.

Decisions

  • The Go nursery's cleanup registers its occupants rather than freeing them. The Plan had the ring's one AddCleanup free its open slots once all its objects were unreachable. That would let one long-lived object keep up to 63 dropped ones (Go and Rust memory) alive for its whole life once the pool retires the nursery. Instead, the cleanup arg holds the nursery's handles, and the handles point at the nursery, not the pool's wrapper. So the wrapper's cleanup runs when the pool drops it, and registers each still-open object on its own. Rejected: the Plan's ring-wide free.

  • Go's checked Close drops and frees in one crossing. It does this when no call holds the handle, which the Plan's "a checked value's drop in the same crossing" covers. Calls during that crossing fail as closed rather than wait, because a Drop that calls back into Go and uses the same object would otherwise wait on itself. Rejected: waiting calls (deadlock on re-entry), and keeping two crossings (about 30 ns more a close).

  • The eviction handshake. An eviction claims the slot with a sentinel, then registers, then clears the slot, and a Close that meets the sentinel yields until it clears. This lets a failed one-crossing close re-register the object without racing a stale eviction. Rejected: registering before the compare-and-swap (the first draft), which can write the handle's cleanup after a failed close re-registered it.

  • The Dart api test now moves an object out to reach Rust's check. closedObjects's "Rust's check drops the implementation" case used a closed checked object, which Dart now refuses before Rust takes the implementation. It now uses an object moved out by a call, which only Rust sees, and asserts that a call Dart refuses gives Rust nothing.

  • A Dart checked object counts its call holds. Review found that a checked object closed by Dart code a call runs while lowering (an implementation's method) would free the handle the call was about to use. Its calls now count holds as a counted object's do, an integer increment and decrement in Dart, and close() frees in the same crossing only when it is the sole holder; otherwise it drops and the last release frees. Rejected: refusing a close while held (a behavior change from main, where the close succeeds) and keeping one load a call (unsound).

  • Go reads the header's contract through a C function. The merge with main surfaced cgo-under-clang misreading a uint64_t macro whose top bit is set (see Validation). Rejected: comparing uint64(C.<P>_CONTRACT), which clang's cgo refuses to compile as an overflowing constant, and dropping the header check, which would let a header from another build mix in unnoticed.

Alternatives

As the Plan records: keeping per-object registration (rejected by the maintainer), flushing the nursery each event-loop turn (a timer per turn), Dart's NativeFinalizer.attach without detach, and Go's runtime.SetFinalizer.

Follow-ups

None.

Models

Size: L
Implementer: Claude Code, claude-opus-5-5, high effort
Implementer: Claude Code, claude-opus-5-5 (iterate, S)

Review

Rewritten by quest review after each round.

  • Head: 8127c4b

  • Base: origin/main at c27427f

  • Risk: high, The branch changes native-handle ownership in downstream Dart and Go bindings, where lifetime defects can cause crashes or memory corruption that reverting cannot undo.

  • Classified: medium by default

  • Reviewer: Codex, gpt-6.1-sol, xhigh effort

  • Session: 01a1e0f6-a7de-7f20-9257-21f3ba871dfc, round 4

  • Score: 10/10, Static review found no regressions in the merge integration, and the previously reviewed fixes remain intact; builds and tests were not run.

  • Raised the risk to high: The branch changes native-handle ownership in downstream Dart and Go bindings, where lifetime defects can cause crashes or memory corruption that reverting cannot undo.

  • Rounds: 6; first round 0; findings 4 (high 3, medium 1): fixed 4, refuted 0, open 0

  • Findings: none

  • Reviewer: Codex, gpt-6.1-sol, medium effort, shadow

  • Session: 01a1dea9-4f07-7fb0-a930-8b724c4bf5f6

  • Rounds: 1; first round 0; findings 0: fixed 0, refuted 0, open 0

Summary by CodeRabbit

  • New Features
    • Go and Dart now retain up to 64 recently returned objects before registering cleanup. Closing an object can free it immediately, while objects left open are still cleaned up later.
  • Bug Fixes
    • Improved object cleanup across explicit closes, garbage collection, and concurrent Go calls to prevent duplicate freeing.
  • Documentation
    • Updated FFI guides with object-lifetime details and benchmark measurements. Added guidance for running Go race checks.

Summary by CodeRabbit

  • Performance

    • Reduced overhead when returning and reading objects through Go and Dart FFI bindings.
  • Bug Fixes

    • Improved cleanup of returned objects: closed objects can be freed promptly, while unclosed objects are reclaimed after they leave the nursery or the runtime cleans it up.
    • Strengthened handling of objects closed during active calls and objects retained by Dart isolates.
  • Documentation

    • Updated FFI ownership and cleanup guidance with the revised lifecycle and performance measurements.

kixelated and others added 4 commits November 14, 2026 21:50
…a in a Dart close

Profile Go's and Dart's object return: most of it is each runtime's per-object
registration with its collector. Allocate a Go object with its handle, whose
cleanup then frees the raw handle directly, and drop the `_Arena` a Dart
checked close made for nothing. Rewrite the quest to the nursery that would
skip the registration, pending a maintainer decision, and unblock ready-await.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@coderabbitai

coderabbitai Bot commented Nov 15, 2026 •

Copy link
Copy Markdown

Explain Change →

No actionable comments were generated in the recent review.

Walkthrough

Go and Dart FFI bindings now retain recently returned objects in 64-entry nurseries. Closing and evicting objects updates their cleanup paths. The changes also add lifecycle tests, Go race-detector coverage, and updated documentation and benchmark results.

Changes: FFI object ownership

Layer / File(s) Summary
Go handle ownership and cleanup
ffi/runtime/rt.go, ffi/src/go.rs, ffi/tests/api.go, ffi/tests/fixtures.rs, ffi/justfile, ffi/README.md, bench/ffi/README.md, quest/m1/ffi-speed/README.md, quest/m1/ffi-speed/object-ownership.md
Go handles use per-P nurseries. Evicted open handles receive GC cleanup, and an unheld checked handle can be dropped and freed in one close call. Tests cover turnover, exactly-once freeing, and concurrent operations. The sanitizer recipe adds the Go race test. The documentation reports lifecycle details and benchmark measurements.
Dart ownership and close lifecycle
ffi/runtime/dart.rs, ffi/src/dart.rs, ffi/runtime/rt.dart, ffi/fixtures/api/src/lib.rs, ffi/tests/api.dart, ffi/README.md
Dart bindings retain returned objects in an isolate nursery and register displaced objects for finalization. Checked closes update object state and can drop and free an object in one crossing. Tests cover nursery cleanup, isolate exit, borrow and close interactions, and nested close behavior.

Estimated code review effort: 4 (Complex) | ~45 minutes

Change: Refactor

Sequence Diagram(s)

sequenceDiagram
  participant GeneratedGoBinding
  participant GoHandle
  participant PerPNursery
  participant GoCleanup
  GeneratedGoBinding->>GoHandle: Register returned handle with Own
  GoHandle->>PerPNursery: Retain handle
  PerPNursery->>GoCleanup: Register evicted open handle
  GeneratedGoBinding->>GoHandle: Close unheld handle
  GoHandle->>GeneratedGoBinding: Call drop callback with free=true
Loading
sequenceDiagram
  participant GeneratedDartBinding
  participant DartNursery
  participant RustNursery
  participant DartFinalizer
  GeneratedDartBinding->>DartNursery: Add object and free function
  DartNursery->>RustNursery: Store handle and free-function slots
  DartNursery->>DartFinalizer: Register displaced object
  DartFinalizer->>RustNursery: Free remaining non-null handles
Loading
Merge Risk: Minimal · up to 8127c

This change retains recently returned Go and Dart objects in 64-entry nurseries and makes checked close drop and free in one crossing. No concrete defect was established in the reviewed lifecycle paths. The author reports passing tests, including the Go race-detector run, so the change appears mergeable.

Security architecture risk: Low · up to 8127c

A concurrent close can report success even when another close fails and leaves the object open. This weakens cleanup-result guarantees, although the inspected paths retain protections against freeing handles still in use.

Retained concerns

  • Low · reliability · inferred: The new checked-close fast path sets closed_ and closing_ before native drop. A concurrent Close then receives no handle from Hold and returns nil immediately, even if the first Close subsequently fails, restores cleanup registration, and reopens the handle. Native lender borrows can make drop fail without a Go hold on the parent handle. A caller can therefore stop retrying shutdown after apparent success while the object remains usable. This is an ownership-result regression, not an established memory-safety exploit.
Security review details

Security Blast Radius

  • inferred — The directly affected boundary is managed/native ownership inside applications using the generated Go or Dart bindings. Incorrect ownership could affect native process memory and resources held by returned objects; the retained concern establishes inconsistent close results, not cross-tenant access or privilege escalation.

Trust Boundaries and Controls

  • observed — Combined cleanup frees only after native drop succeeds. Rust refuses a checked drop while borrowed and marks successfully taken values so later handle destruction skips a second value drop. Go's immediate-free shortcut requires the state to contain only the owner's hold; Dart defers handle release while calls retain holds.

Resilience and Maintainability Implications

  • inferred — Failure recovery preserves cleanup ownership: Go re-registers before reopening after failed immediate close, and Dart restores registration when necessary. This contains handle abandonment, but does not resolve the concurrent Go success result while that recovery is pending.
Pre-merge checks: Passed 4

Check name Status Explanation
Description Check Passed Check skipped - CodeRabbit’s high-level summary is enabled.
Title check Passed The title "perf(ffi): returned objects closed early skip the collector in Go and Dart" matches the main change. The PR adds a per-P (Go) and per-isolate (Dart) nursery of the 64 most recent returned o…
Linked Issues check Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check Passed Check skipped because no linked issues were found for this pull request.
Full details: Title check

Explanation

The title "perf(ffi): returned objects closed early skip the collector in Go and Dart" matches the main change. The PR adds a per-P (Go) and per-isolate (Dart) nursery of the 64 most recent returned objects. Objects closed while still in the nursery are freed without GC cleanup registration, which is the performance gain the title describes. The title names both runtimes and the early-close behavior. It uses a conventional commit prefix and fits within a short, single-sentence form.

Finishing Touches

Generate unit tests (beta)

  • Commit to this branch
  • Create a new PR
  • Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts
Recent review info

Run configuration

  • Source mode: Auto
  • Repository: Unavailable
  • Branch: Unavailable
  • File: No configuration file from this repository applied
  • Commit: Unavailable
  • Layers: defaults
  • Review profile: CHILL
  • Plan: Advanced
  • Run ID: 3f951545-d2fc-45d4-8d39-2d1eee23500b
Commits

Reviewing files that changed from the base of the PR and between 262472f and 8127c4b.

Files selected for processing: 9

  • bench/ffi/README.md
  • ffi/README.md
  • ffi/fixtures/api/src/lib.rs
  • ffi/runtime/rt.dart
  • ffi/src/dart.rs
  • ffi/src/go.rs
  • ffi/tests/api.dart
  • ffi/tests/api.go
  • ffi/tests/fixtures.rs
Files skipped from review as they are similar to previous changes: 1

  • bench/ffi/README.md

Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 1 remain after this review.

kixelated and others added 6 commits November 15, 2026 10:06
…gistration

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ctor's registration

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…es in one crossing

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
kixelated and others added 4 commits November 15, 2026 12:35
…rk; finish the quest

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@kixelated kixelated changed the title Returned objects closed early skip the collector in Go and Dart perf(ffi): returned objects closed early skip the collector in Go and Dart Nov 15, 2026
…efore Rust drops it; a Go flush forgets its slots

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@kixelated
kixelated marked this pull request as ready for review November 15, 2026 21:34
pullfrog[bot]
pullfrog Bot previously approved these changes Nov 15, 2026

@pullfrog pullfrog Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

✅ No new issues found.

Reviewed changes

This review covered the full PR: a 64-slot nursery of returned objects in the Go and Dart runtimes, the one-crossing checked close, and the tests and docs for both.

  • Go nursery (ffi/runtime/rt.go): Handle_.Own pushes each returned handle into a per-P nursery_ reached through sync.Pool. A CAS on raw[i] decides between Close and eviction, and evicting_ makes a racing leave() wait until AddCleanup has written h.cleanup. I traced the slot protocol. A slot is rewritten only by push after it evicts the old occupant, and a live handle's raw can't be reused, so I found no ABA. held and next are touched only by push (while the ring is checked out) or by flush (once the ring is unreachable), so those two never overlap.
  • Go checked Close fast path: CAS(held_, closed_|closing_), then leave, then a single C shim (GoClose_) that drops and frees. On failure, own() re-registers the handle and held_ is restored. Re-entrant calls from Drop see ErrClosed and don't deadlock. Every close and move path (unchecked Close, the fast path, abandon) now goes through leave() before anything frees the handle.
  • Dart nursery (ffi/runtime/rt.dart, ffi/runtime/dart.rs): _Nursery lives in the isolate's _n. Rust keeps a copy of each slot's handle and its free function, and frees whatever is still in a slot once the nursery is finalized. A pushed-out object takes its finalizable handle only at eviction, so no handle is ever both in a slot and registered.
  • Dart checked objects now count holds: _closed is set before Rust drops the value. A close with _holds == 1 drops and frees in one crossing, and disown runs after the free while this keeps the object reachable. Otherwise the last _release frees. A failed close reopens the object and re-registers it if it had been taken out of the nursery.
  • Codegen (ffi/src/go.rs, ffi/src/dart.rs): adds own_<c> → Own(), the drop_<c>(p, free) shim, <prefix>_dart_nursery, per-object _close_<bare>, and _freeing_<bare> bound to <c>_free.
  • Tests:
    • Go nursed(): push-out, close after eviction, and an 8×1000 race of returns, closes, hand-offs and drops.
    • New nightly api_go_race under -race.
    • Dart: push-out, isolate exit, and the Journal re-entrant close.
    • Dart ReadingList: an object closed while its call is still lowering arguments.

Pullfrog  | View workflow run | Using claude-opus-5-5 | 𝕏

kixelated and others added 2 commits November 16, 2026 01:36
cgo built by clang, as the sanitize shell's is, reads a uint64_t macro whose top
bit is set as a negative constant, so the runtime's init panicked that the Go and
the library are from different builds whenever the contract's top bit was set.
A static C function returns the macro instead.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@kixelated kixelated left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Automated review by review (OpenAI)

Reviewed commit: 262472fcc12904d836cf3b521edaa765bb3e8e2b.

No actionable new defect found in this focused static review.

Traced the Go nursery's slot CAS, eviction/Close synchronization, ring cleanup and flush, the failed checked-close re-registration path, and generated close/free shims. Traced Dart's nursery slots and finalizer ownership, checked-object call holds, closed-before-drop ordering, failed-close recovery, and deferred freeing while argument lowering still holds a handle. The new late-argument-close and reentrant-drop regressions address important lifetime boundaries; the Go race harness covers concurrent return, eviction, close and handoff.

The delayed collection of objects left in the nursery is explicitly documented rather than silently preserving the former per-object collection timing. No additional issue found in the corresponding generator changes.

Limits: GitHub-only source and test inspection; no builds, race detector, Dart isolate execution, sanitizer runs, or benchmark reruns performed. This is not an independent verification of the reported performance results or a proof of race freedom. COMMENT only, not approval.

…ject-ownership

# Conflicts:
#	quest/m1/ffi-speed/ready-await.md
…ject-ownership

# Conflicts:
#	ffi/fixtures/api/src/lib.rs
#	quest/m2/wasm/backend.md

@pullfrog pullfrog Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

✅ No new issues found.

Reviewed changes

Since the last Pullfrog review at 262472fc, the branch merged main through c27427f and added one fix to how Go reads the header's contract.

  • Resolved #837's conflict in ffi/src/go.rs: the head keeps the one-crossing close_c shim (<prefix>GoClose_<bare>) over main's self.call-based drop_<c>. The shim's status is a C local and it takes only a C handle pointer and an int, so #837's pointer rule still holds. checked_c has no remaining callers.
  • Read the header's contract through C (b7d50fd2): the Go runtime preamble now has static uint64_t <go>_header_contract(void), and init compares its result instead of C.<UPPER>_CONTRACT. This avoids clang's cgo reading a top-bit-set uint64_t macro as a negative constant. The Swift and C++ checks still compare the macro directly, which is correct in those compilers.
  • Resolved #847's fixture conflict: Journal sits ahead of the cfg(not(target_arch = "wasm32")) LogThread and stays ungated. The PR reports that api_web passes with it.

Pullfrog  | View workflow run | Using claude-opus-5-5 | 𝕏

@kixelated kixelated left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Automated review by review (OpenAI)

Reviewed commit: 8127c4bc74725036391bbf3caa4cd31408229cff, incrementally from 262472fcc12904d836cf3b521edaa765bb3e8e2b.

No new actionable issue found in the Go contract-check change and relevant merge integration.

The header contract now crosses through a C function returning uint64_t, rather than cgo's macro-constant representation. Both comparisons remain present: the generated Go contract is checked against the linked library and the included header. This preserves mismatch detection while avoiding signed interpretation of a top-bit-set macro.

The merged Go generator retains the one-crossing checked-close shim with its status stored in C, not a Go-local out parameter; freeing still occurs only when the drop status is zero and freeing was requested. The Go nursery, Dart hold-count/closed-before-drop logic, and Rust Dart-nursery changes are unchanged from the previously reviewed PR patches apart from context positions. The fixture retains Journal separately from the native-only LogThread gate.

Limits: GitHub-only focused inspection. The large comparison includes merged main work, which this is not a fresh audit of. No clang/cgo reproduction, generation, builds, race detector, Dart/wasm tests, or benchmark reruns performed; reported validation is not independently confirmed. COMMENT only, not approval.

@kixelated
kixelated added this pull request to the merge queue Nov 16, 2026
Merged via the queue into main with commit 70f0548 Nov 16, 2026
8 checks passed
@kixelated
kixelated deleted the quest/m1/ffi-speed/object-ownership branch November 16, 2026 20:32
kixelated added a commit that referenced this pull request Nov 16, 2026
Its other children landed in #837, #838, and #849, so deleting
shared-borrow.md would leave the epic with no children. Per the
maintainer's decision, delete its README, rewrite the links to it, and
replace bench/ffi's link to the deleted go-pointers.md with #837.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
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.

1 participant