@scriptc/compiler 0.0.32 → 0.0.34

package/dist/backend/library-identity.js

@@ -0,0 +1,103 @@
+export const C_LIBRARY_IDENTITY_BEGIN = "/* scriptc-library-identity: begin */";
+export const C_LIBRARY_IDENTITY_END = "/* scriptc-library-identity: end */";
+export const LLVM_LIBRARY_IDENTITY_BEGIN = "; scriptc-library-identity: begin";
+export const LLVM_LIBRARY_IDENTITY_END = "; scriptc-library-identity: end";
+function identityMarkers(emission) {
+    return emission === "c"
+        ? { begin: C_LIBRARY_IDENTITY_BEGIN, end: C_LIBRARY_IDENTITY_END }
+        : { begin: LLVM_LIBRARY_IDENTITY_BEGIN, end: LLVM_LIBRARY_IDENTITY_END };
+}
+export function emitLibraryIdentityLines(emission, identity, llvmFunctionAttrs = "#0") {
+    if (!/^[0-9a-f]{16}$/.test(identity.buildId)) {
+        throw new Error("library build id must be exactly 16 lowercase hex digits");
+    }
+    if (emission === "c") {
+        return [
+            C_LIBRARY_IDENTITY_BEGIN,
+            `uint64_t ${identity.buildIdSymbol}(void) {`,
+            `  return UINT64_C(0x${identity.buildId});`,
+            `}`,
+            ``,
+            `uint32_t ${identity.abiVersionSymbol}(void) {`,
+            `  return ${identity.abiVersion}u;`,
+            `}`,
+            ``,
+            C_LIBRARY_IDENTITY_END,
+        ];
+    }
+    const signedBuildId = BigInt.asIntN(64, BigInt(`0x${identity.buildId}`)).toString();
+    return [
+        LLVM_LIBRARY_IDENTITY_BEGIN,
+        `define i64 @${identity.buildIdSymbol}() ${llvmFunctionAttrs} { ; identity getter build_id 0x${identity.buildId}`,
+        `entry:`,
+        `  ret i64 ${signedBuildId}`,
+        `}`,
+        ``,
+        `define i32 @${identity.abiVersionSymbol}() ${llvmFunctionAttrs} { ; identity getter abi_version`,
+        `entry:`,
+        `  ret i32 ${identity.abiVersion}`,
+        `}`,
+        ``,
+        LLVM_LIBRARY_IDENTITY_END,
+    ];
+}
+function identityOffsets(source, emission) {
+    const { begin, end } = identityMarkers(emission);
+    const start = source.indexOf(`${begin}\n`);
+    if (start < 0)
+        return null;
+    if (source.indexOf(begin, start + begin.length) >= 0) {
+        throw new Error("generated library TU contains multiple identity regions");
+    }
+    const endStart = source.indexOf(end, start + begin.length);
+    if (endStart < 0)
+        throw new Error("generated library TU has an unterminated identity region");
+    return { start, end: endStart + end.length };
+}
+/** Refresh only the volatile identity block in a cached public TU. */
+export function replaceLibraryIdentity(source, emission, identity) {
+    const offsets = identityOffsets(source, emission);
+    if (offsets === null)
+        throw new Error("generated public library TU has no identity region");
+    const replacement = emitLibraryIdentityLines(emission, identity).join("\n");
+    return source.slice(0, offsets.start) + replacement + source.slice(offsets.end);
+}
+function escapedRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function sourceCommentPattern(sourceFile) {
+    // Emission appends these comments at physical line ends. Requiring that
+    // boundary prevents source-looking text inside a generated C string from
+    // being mistaken for an annotation and changing program semantics. An
+    // uninitialized reference declaration appends its own `/* let ... */`
+    // explanation after the location, so admit that one generated suffix too.
+    return new RegExp(` /\\* ${escapedRegExp(sourceFile)}:(\\d+) \\*/` +
+        `(?= /\\* let [^\\r\\n]*; \\*/(?=\\r?\\n|$)|\\r?\\n|$)`, "g");
+}
+/** Refresh the source-line annotations retained in a caller-visible C TU. */
+export function rebaseLibrarySourceComments(source, sourceFile, rebaseLine) {
+    return source.replace(sourceCommentPattern(sourceFile), (_match, line) => ` /* ${sourceFile}:${rebaseLine(Number(line))} */`);
+}
+/** Remove C-only debugging annotations from the private native-cache input. */
+export function stripLibrarySourceComments(source, sourceFile) {
+    return source.replace(sourceCommentPattern(sourceFile), "");
+}
+/** Remove the generated identity region from a complete caller-visible
+ * library TU. Archive assembly compiles this stable projection beside the
+ * small volatile identity C object, while the public TU remains complete. */
+export function stripLibraryIdentity(source, emission) {
+    const offsets = identityOffsets(source, emission);
+    if (offsets === null)
+        return source;
+    const endOffset = offsets.end;
+    const suffix = source[endOffset] === "\n" ? endOffset + 1 : endOffset;
+    let prefix = source.slice(0, offsets.start);
+    // An omitted final region leaves the emitter's preceding empty array entry
+    // as one trailing newline; a marked final region has material after that
+    // entry and therefore renders it as two. Restore the omitted form exactly.
+    if (suffix === source.length && prefix.endsWith("\n\n")) {
+        prefix = prefix.slice(0, -1);
+    }
+    return prefix + source.slice(suffix);
+}
+//# sourceMappingURL=library-identity.js.map

package/dist/backend/library-identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-identity.js","sourceRoot":"","sources":["../../src/backend/library-identity.ts"],"names":[],"mappings":"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"}

package/dist/backend/llvm/emitter.d.ts

@@ -5,5 +5,8 @@ export interface LlvmTargetOptions {
     pointerBits?: 32 | 64;
     /** Select the WASI libc entry-point convention. */
     wasi?: boolean;
+    /** Library archive assembly may move the volatile identity getters into a
+     * separate translation unit. Public/direct emission keeps them by default. */
+    emitLibraryIdentity?: boolean;
 }
 export declare function emitLlvmModule(mod: IrModule, options?: LlvmTargetOptions): string;

package/dist/backend/llvm/emitter.js

@@ -61,11 +61,12 @@
  * lazy-inflate representation as the C debugging backend.
  */
 import { deflateRawSync } from "node:zlib";
-import { canMarshalFuncIntoIsland, CAUGHT, DYN, F64, ffiCallbackType, islandCallbackRet, islandPromisePayloadTag, isFfiCallbackParam, isFfiContextParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesNodeTest, moduleUsesProcessEvents, moduleUsesStream, moduleUsesTls, moduleUsesTlsCa, NPM_COMPRESS_MIN, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.js";
+import { emitLibraryIdentityLines } from "../library-identity.js";
+import { canMarshalFuncIntoIsland, CAUGHT, DYN, F64, ffiCallbackType, islandCallbackRet, islandPromisePayloadTag, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesNodeTest, moduleUsesProcessEvents, moduleUsesStream, moduleUsesTls, moduleUsesTlsCa, NPM_COMPRESS_MIN, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, typeEquals, typeKey, VOID } from "../../ir/nodes.js";
 import { matchIntegerBytesForLoop } from "../../ir/integer-loops.js";
-import { allocateFfiCallbackAdapters } from "../ffi-callbacks.js";
+import { allocateFfiCallbackAdapters, collectFfiRetainedOps, hasForeignFfiCallback, hasRetainedFfiCallback, parseFfiCallbackKey } from "../ffi-callbacks.js";
 import { computeMayThrow } from "../emission/may-throw.js";
-import { mangleArgPack, mangleAsyncSpawn, mangleClassNew, mangleClassObj, mangleClassRetain, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenResThunk, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordNew, mangleRecordStruct, mangleResolveThunk, mangleTrampoline, mangleVtStruct, mangleWrapper } from "../mangle.js";
+import { mangleArgPack, mangleAsyncSpawn, mangleClassNew, mangleClassObj, mangleClassRetain, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenResThunk, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordClone, mangleRecordNew, mangleRecordStruct, mangleResolveThunk, mangleTrampoline, mangleVtStruct, mangleWrapper } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { buildClassGraph, classFieldIndex, classStructSym, emitClassObjDefs, emitClassShapes, } from "./classes.js";
 import { DK, LlDyn } from "./dyn.js";
@@ -81,6 +82,8 @@ function ffiNativeTypeLl(cls) {
         case "u32":
         case "i32":
             return "i32";
+        case "cstring":
+            return "ptr";
         case "string":
         case "bytes":
             throw new Error(`llvm emitter bug: span class '${cls}' has no scalar LLVM type`);
@@ -874,6 +877,7 @@ class LlEmitter {
     sizeType;
     cycleColorOffset;
     wasi;
+    emitLibraryIdentity;
     /** Interned string literals: UTF-8 text → { symbol, byte length } —
      * first-use order, the C emitter's determinism discipline. */
     literals = new Map();
@@ -917,6 +921,12 @@ class LlEmitter {
     /** C-ABI callback trampolines and (for raw/no-userdata callbacks) their
      * distinct call-scoped TLS closure slots. */
     ffiCallbackAdapters;
+    /** Module-level constant consulted per ffiCall: with a retained
+     * descriptor anywhere in the manifest, every native call is a
+     * pending-exception checkpoint (may-throw derives the same fact from
+     * the same helper). */
+    ffiHasRetainedCallback;
+    ffiHasForeignCallback;
     globalTypes = new Map();
     /** May-throw analysis (the C emitter's computeMayThrow, shared): pending
      * checks are emitted only after calls that can actually raise. */
@@ -943,6 +953,7 @@ class LlEmitter {
     dynPromiseAdapters = new Map();
     unionsById = new Map();
     recordsById = new Map();
+    recordCloneShapes = new Set();
     tracedShapes;
     tracedUnions;
     /** The class graph (buildClassGraph): preorder numbering, hierarchy
@@ -1014,11 +1025,14 @@ class LlEmitter {
         this.mod = mod;
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
         this.wasi = options.wasi === true;
+        this.emitLibraryIdentity = options.emitLibraryIdentity !== false;
         // ScrCycHdr is { ptr trace; ptr free; i32 color; i16 buffered;
         // i16 gen; size_t buf_index }. The object follows it, so color is 12
         // bytes behind a wasm32 object and 16 bytes behind a 64-bit object.
         this.cycleColorOffset = options.pointerBits === 32 ? 12 : 16;
         this.ffiCallbackAdapters = allocateFfiCallbackAdapters(mod.ffiImports ?? []);
+        this.ffiHasRetainedCallback = hasRetainedFfiCallback(mod.ffiImports ?? []);
+        this.ffiHasForeignCallback = hasForeignFfiCallback(mod.ffiImports ?? []);
         for (const fn of mod.functions)
             this.fnByName.set(fn.name, fn);
         for (const entry of mod.ffiImports ?? []) {
@@ -1172,13 +1186,129 @@ class LlEmitter {
         this.declare(`declare zeroext i1 @scr_exc_pending()`);
         this.declare(`declare void @scr_trap(ptr)`);
         const expired = this.cstr("scriptc: native callback invoked outside its call-scoped lifetime\n");
+        const released = this.cstr("scriptc: native callback invoked outside its retained lifetime\n");
         for (const adapter of this.ffiCallbackAdapters.values()) {
             const cb = adapter.callback;
             if (adapter.tls !== null)
                 globals.push(`@${adapter.tls} = internal thread_local global ptr null`);
-            const params = cb.params.map((param, i) => isFfiContextParam(param) ? `ptr %ctx` : `${ffiNativeTypeLl(param)} %a${i}`);
+            if (adapter.global !== null)
+                globals.push(`@${adapter.global} = internal global ptr null`);
+            if (adapter.table !== null) {
+                globals.push(`@${adapter.table} = internal global %ScrFfiTable zeroinitializer`);
+            }
+            const params = cb.params.flatMap((param, i) => {
+                if (isFfiContextParam(param))
+                    return [`ptr %ctx`];
+                if (param === "string" || param === "bytes") {
+                    return [`ptr %a${i}`, `${this.sizeType} %a${i}_len`];
+                }
+                return [`${ffiNativeTypeLl(param)} %a${i}`];
+            });
             const ret = ffiNativeTypeLl(cb.returns);
-            defs.push(`define internal ${ret} @${adapter.symbol}(${params.join(", ")}) ${FN_ATTRS} {`, `entry:`, adapter.tls === null ? `  %cb = getelementptr inbounds i8, ptr %ctx, i64 0` : `  %cb = load ptr, ptr @${adapter.tls}`, `  %missing = icmp eq ptr %cb, null`, `  br i1 %missing, label %expired, label %ready`, `expired:`, `  call void @scr_trap(ptr ${expired})`, `  unreachable`, `ready:`, `  %pending = call zeroext i1 @scr_exc_pending()`, `  br i1 %pending, label %skip, label %invoke`, `skip:`, `  ret ${ffiCallbackDummyLl(cb)}`, `invoke:`, `  %fnp = getelementptr inbounds %ScrClosure, ptr %cb, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`);
+            if (cb.invoke === "foreign") {
+                if (adapter.table === null || !cb.params.some(isFfiContextParam) || cb.returns !== "void") {
+                    throw new Error("llvm emitter bug: invalid foreign FFI callback descriptor");
+                }
+                const dispatch = `${adapter.symbol}_dispatch`;
+                const scriptArgs = [];
+                const dispatchBody = [
+                    `define internal void @${dispatch}(ptr %cb, ptr %call) ${FN_ATTRS} {`,
+                    `entry:`,
+                    `  %fnp = getelementptr inbounds %ScrClosure, ptr %cb, i64 0, i32 1`,
+                    `  %fn = load ptr, ptr %fnp`,
+                ];
+                for (let i = 0; i < cb.params.length; i++) {
+                    const param = cb.params[i];
+                    if (isFfiContextParam(param))
+                        continue;
+                    switch (param) {
+                        case "f64":
+                            this.declare(`declare double @scr_ffi_call_get_f64(ptr, ${this.sizeType})`);
+                            dispatchBody.push(`  %s${i} = call double @scr_ffi_call_get_f64(ptr %call, ${this.sizeType} ${i})`);
+                            scriptArgs.push(`double %s${i}`);
+                            break;
+                        case "bool":
+                            this.declare(`declare zeroext i1 @scr_ffi_call_get_bool(ptr, ${this.sizeType})`);
+                            dispatchBody.push(`  %s${i} = call zeroext i1 @scr_ffi_call_get_bool(ptr %call, ${this.sizeType} ${i})`);
+                            scriptArgs.push(`i1 %s${i}`);
+                            break;
+                        case "u8":
+                        case "u32":
+                        case "i32":
+                            this.declare(`declare double @scr_ffi_call_get_${param}(ptr, ${this.sizeType})`);
+                            dispatchBody.push(`  %s${i} = call double @scr_ffi_call_get_${param}(ptr %call, ${this.sizeType} ${i})`);
+                            scriptArgs.push(`double %s${i}`);
+                            break;
+                        case "cstring":
+                        case "string":
+                        case "bytes": {
+                            this.declare(`declare ptr @scr_ffi_call_get_data(ptr, ${this.sizeType})`);
+                            this.declare(`declare ${this.sizeType} @scr_ffi_call_get_len(ptr, ${this.sizeType})`);
+                            dispatchBody.push(`  %data${i} = call ptr @scr_ffi_call_get_data(ptr %call, ${this.sizeType} ${i})`, `  %len${i} = call ${this.sizeType} @scr_ffi_call_get_len(ptr %call, ${this.sizeType} ${i})`);
+                            if (param === "bytes") {
+                                this.declare(`declare ptr @scr_bytes_from_data(ptr, ${this.sizeType})`);
+                                dispatchBody.push(`  %s${i} = call ptr @scr_bytes_from_data(ptr %data${i}, ${this.sizeType} %len${i})`);
+                            }
+                            else {
+                                this.declare(`declare ptr @scr_str_from_utf8_lossy(ptr, ${this.sizeType})`);
+                                dispatchBody.push(`  %s${i} = call ptr @scr_str_from_utf8_lossy(ptr %data${i}, ${this.sizeType} %len${i})`);
+                            }
+                            scriptArgs.push(`ptr %s${i}`);
+                            break;
+                        }
+                    }
+                }
+                dispatchBody.push(`  call void %fn(${[`ptr %cb`, ...scriptArgs].join(", ")})`, `  ret void`, `}`, ``);
+                defs.push(...dispatchBody);
+                this.declare(`declare ptr @scr_ffi_call_new(ptr, ptr, ptr, ${this.sizeType})`);
+                this.declare(`declare void @scr_ffi_post(ptr)`);
+                defs.push(`define internal void @${adapter.symbol}(${params.join(", ")}) ${FN_ATTRS} {`, `entry:`, `  %cb = getelementptr inbounds i8, ptr %ctx, i64 0`, `  %call = call ptr @scr_ffi_call_new(ptr @${adapter.table}, ptr %cb, ptr @${dispatch}, ${this.sizeType} ${cb.params.length})`);
+                for (let i = 0; i < cb.params.length; i++) {
+                    const param = cb.params[i];
+                    if (isFfiContextParam(param))
+                        continue;
+                    if (param === "cstring") {
+                        this.declare(`declare void @scr_ffi_call_copy_cstring(ptr, ${this.sizeType}, ptr)`);
+                        defs.push(`  call void @scr_ffi_call_copy_cstring(ptr %call, ${this.sizeType} ${i}, ptr %a${i})`);
+                    }
+                    else if (param === "string" || param === "bytes") {
+                        this.declare(`declare void @scr_ffi_call_copy_${param}(ptr, ${this.sizeType}, ptr, ${this.sizeType})`);
+                        defs.push(`  call void @scr_ffi_call_copy_${param}(ptr %call, ${this.sizeType} ${i}, ptr %a${i}, ${this.sizeType} %a${i}_len)`);
+                    }
+                    else {
+                        const nativeTy = ffiNativeTypeLl(param);
+                        this.declare(`declare void @scr_ffi_call_set_${param}(ptr, ${this.sizeType}, ${nativeTy})`);
+                        defs.push(`  call void @scr_ffi_call_set_${param}(ptr %call, ${this.sizeType} ${i}, ${nativeTy} %a${i})`);
+                    }
+                }
+                defs.push(`  call void @scr_ffi_post(ptr %call)`, `  ret void`, `}`, ``);
+                continue;
+            }
+            defs.push(`define internal ${ret} @${adapter.symbol}(${params.join(", ")}) ${FN_ATTRS} {`, `entry:`, adapter.tls !== null
+                ? `  %cb = load ptr, ptr @${adapter.tls}`
+                : adapter.global !== null
+                    ? `  %cb = load ptr, ptr @${adapter.global}`
+                    : `  %cb = getelementptr inbounds i8, ptr %ctx, i64 0`, `  %missing = icmp eq ptr %cb, null`, `  br i1 %missing, label %expired, label %ready`, `expired:`, `  call void @scr_trap(ptr ${adapter.callback.lifetime === "call" ? expired : released})`, `  unreachable`, `ready:`, `  %pending = call zeroext i1 @scr_exc_pending()`, `  br i1 %pending, label %skip, label %invoke`, `skip:`, `  ret ${ffiCallbackDummyLl(cb)}`, `invoke:`);
+            // Validate every native pointer before allocating any copy-in value.
+            // A later bad slot therefore cannot leak an earlier materialization.
+            for (let i = 0; i < cb.params.length; i++) {
+                const param = cb.params[i];
+                if (param !== "cstring" && param !== "string" && param !== "bytes")
+                    continue;
+                const invalid = `%invalid${i}`;
+                defs.push(`  %null${i} = icmp eq ptr %a${i}, null`);
+                if (param === "cstring") {
+                    defs.push(`  ${invalid} = or i1 %null${i}, false`);
+                }
+                else {
+                    defs.push(`  %nonempty${i} = icmp ne ${this.sizeType} %a${i}_len, 0`, `  ${invalid} = and i1 %null${i}, %nonempty${i}`);
+                }
+                const message = param === "cstring"
+                    ? "scriptc: native callback passed a NULL cstring\n"
+                    : `scriptc: native callback passed a NULL ${param} span with nonzero length\n`;
+                defs.push(`  br i1 ${invalid}, label %invalid_param${i}, label %param_ok${i}`, `invalid_param${i}:`, `  call void @scr_trap(ptr ${this.cstr(message)})`, `  unreachable`, `param_ok${i}:`);
+            }
+            defs.push(`  %fnp = getelementptr inbounds %ScrClosure, ptr %cb, i64 0, i32 1`, `  %fn = load ptr, ptr %fnp`);
             const scriptArgs = [];
             for (let i = 0; i < cb.params.length; i++) {
                 const param = cb.params[i];
@@ -1204,16 +1334,40 @@ class LlEmitter {
                         defs.push(`  %s${i} = sitofp i32 %a${i} to double`);
                         scriptArgs.push(`double %s${i}`);
                         break;
+                    case "cstring":
+                        this.declare(`declare ${this.sizeType} @strlen(ptr)`);
+                        this.declare(`declare ptr @scr_str_from_utf8_lossy(ptr, ${this.sizeType})`);
+                        defs.push(`  %len${i} = call ${this.sizeType} @strlen(ptr %a${i})`, `  %s${i} = call ptr @scr_str_from_utf8_lossy(ptr %a${i}, ${this.sizeType} %len${i})`);
+                        scriptArgs.push(`ptr %s${i}`);
+                        break;
+                    case "string":
+                        this.declare(`declare ptr @scr_str_from_utf8_lossy(ptr, ${this.sizeType})`);
+                        defs.push(`  %s${i} = call ptr @scr_str_from_utf8_lossy(ptr %a${i}, ${this.sizeType} %a${i}_len)`);
+                        scriptArgs.push(`ptr %s${i}`);
+                        break;
+                    case "bytes":
+                        this.declare(`declare ptr @scr_bytes_from_data(ptr, ${this.sizeType})`);
+                        defs.push(`  %s${i} = call ptr @scr_bytes_from_data(ptr %a${i}, ${this.sizeType} %a${i}_len)`);
+                        scriptArgs.push(`ptr %s${i}`);
+                        break;
                 }
             }
             const ft = ffiCallbackType(cb);
             const internalRet = this.llType(ft.ret);
             const callArgs = [`ptr %cb`, ...scriptArgs].join(", ");
+            if (cb.lifetime === "retained") {
+                this.declare(`declare ptr @scr_closure_retain_v(ptr)`);
+                this.declare(`declare void @scr_closure_release_v(ptr)`);
+                defs.push(`  %invoke_pin = call ptr @scr_closure_retain_v(ptr %cb)`);
+            }
             if (cb.returns === "void") {
-                defs.push(`  call void %fn(${callArgs})`, `  ret void`, `}`, ``);
+                defs.push(`  call void %fn(${callArgs})`, ...(cb.lifetime === "retained" ? [`  call void @scr_closure_release_v(ptr %invoke_pin)`] : []), `  ret void`, `}`, ``);
                 continue;
             }
             defs.push(`  %result = call ${internalRet} %fn(${callArgs})`);
+            if (cb.lifetime === "retained") {
+                defs.push(`  call void @scr_closure_release_v(ptr %invoke_pin)`);
+            }
             switch (cb.returns) {
                 case "f64":
                     defs.push(`  ret double %result`);
@@ -1253,6 +1407,7 @@ class LlEmitter {
         const wrappers = this.emitFnValueDefs();
         const asyncDefs = this.emitAsyncScaffolding();
         const ffiCallbacks = this.emitFfiCallbackDefs();
+        const hasNoInlineRecordClone = [...this.recordCloneShapes].some((shapeId) => (this.recordsById.get(shapeId)?.fields.length ?? 0) >= 16);
         const embedded = this.mod.embedded;
         const usesIsland = embedded !== undefined && embedded.modules.length > 0;
         const storeNpmText = (text) => {
@@ -1337,7 +1492,6 @@ class LlEmitter {
         const snapshotsTlsCa = moduleUsesTls(this.mod) || moduleUsesTlsCa(this.mod) ||
             moduleEmbedsBuiltin(this.mod, "node:https") ||
             moduleEmbedsBuiltin(this.mod, "node:tls");
-        const hasRefGlobals = globals.some((g) => isRefCounted(g.type)) || fnValueProps.length > 0;
         // The process verdict has the same precedence as the C reference
         // emitter: node:test owns the final status when present; otherwise an
         // embedded process.exitCode owns it; ordinary programs return zero.
@@ -1348,6 +1502,8 @@ class LlEmitter {
             this.declare(`declare void @scr_events_install()`);
         if (usesFsWatch)
             this.declare(`declare void @scr_watch_install()`);
+        if (this.ffiHasForeignCallback)
+            this.declare(`declare void @scr_ffi_install()`);
         if (usesStream)
             this.declare(`declare void @scr_stream_install()`);
         if (usesNet) {
@@ -1375,12 +1531,21 @@ class LlEmitter {
         if (snapshotsTlsCa) {
             this.declare(`declare void @scr_tls_ca_install()`);
         }
-        if (usesEvents && hasRefGlobals) {
+        // Inline exit listeners run when something they must beat exists:
+        // the refcounted-global releases, or the retained-FFI atexit ledger
+        // sweep (a listener may legitimately release or pump a registration,
+        // and only the inline call orders ahead of every atexit handler —
+        // the C emitter's runExitListeners stance). Plain event programs
+        // with neither keep the atexit path, so their listener timing is
+        // unchanged.
+        const hasRefGlobals = globals.some((g) => isRefCounted(g.type)) || fnValueProps.length > 0;
+        const inlineExitListeners = usesEvents && (hasRefGlobals || this.ffiHasRetainedCallback);
+        if (inlineExitListeners) {
             this.declare(`declare void @scr_run_exit_listeners(double)`);
             this.declare(`declare i32 @scr_exit_code_hint_get()`);
         }
         const exitListenerLines = (prefix) => {
-            if (!usesEvents || !hasRefGlobals)
+            if (!inlineExitListeners)
                 return [];
             return [
                 `  %${prefix}h = call i32 @scr_exit_code_hint_get()`,
@@ -1399,6 +1564,7 @@ class LlEmitter {
         // async loop-exhaustion story.
         const runsLoop = this.usesTimers ||
             usesIsland ||
+            this.ffiHasForeignCallback ||
             this.mod.functions.some((f) => f.async === true || f.generator !== undefined);
         const uncaughtReleases = entryMayThrow && !asyncEntry ? globalReleaseLines("gu") : [];
         const loopReleasesU = runsLoop ? globalReleaseLines("gl") : [];
@@ -1421,7 +1587,7 @@ class LlEmitter {
             this.declare(`declare void @scr_promise_rethrow_top_level(ptr)`);
             this.declare(`declare void @scr_promise_release(ptr)`);
             this.declare(`declare void @scr_exit_code_note(i32)`);
-            if (programExitUsesIsland && usesEvents && hasRefGlobals) {
+            if (programExitUsesIsland && inlineExitListeners) {
                 this.declare(`declare ${this.sizeType} @scr_island_exit_code_version()`);
             }
         }
@@ -1439,7 +1605,7 @@ class LlEmitter {
                 lines.push(`  %tla_program_exit_zero = icmp eq i32 %tla_program_exit, 0`, `  %tla_exit_status = select i1 %tla_program_exit_zero, i32 %tla_status, i32 %tla_program_exit`);
             }
             const exitStatus = usesNodeTest || usesIsland ? "%tla_exit_status" : "%tla_status";
-            const tracksIslandExit = programExitUsesIsland && usesEvents && hasRefGlobals;
+            const tracksIslandExit = programExitUsesIsland && inlineExitListeners;
             if (tracksIslandExit) {
                 lines.push(`  %tla_exit_version = call ${this.sizeType} @scr_island_exit_code_version()`);
             }
@@ -1508,6 +1674,7 @@ class LlEmitter {
             `%ScrVt = type { ${this.sizeType}, ${this.sizeType}, ptr }`,
             `%ScrUnion = type { ${this.sizeType}, i32, ptr, ptr, ptr, i64 }`,
             `%ScrClosure = type { ${this.sizeType}, ptr, ${this.sizeType}, ptr }`,
+            `%ScrFfiTable = type { ptr, ${this.sizeType}, ${this.sizeType}, ptr, i8, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`,
             `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr }`,
             // ScrArr mirror { rc, len, cap, elem(i32+pad), elem_retain,
             // elem_release, elem_trace, data } — the immortal tagged-template
@@ -1708,6 +1875,8 @@ class LlEmitter {
             out.push(`attributes #0 = { sanitize_address }`);
             if (this.wasi)
                 out.push(`attributes #1 = { sanitize_address presplitcoroutine }`);
+            if (hasNoInlineRecordClone)
+                out.push(`attributes #2 = { noinline sanitize_address }`);
             out.push(``);
             return out.join("\n");
         }
@@ -1718,7 +1887,7 @@ class LlEmitter {
         ...(usesEvents ? [`  call void @scr_events_install()`] : []), 
         // fs.watch programs fill the loop's watch hooks the same way —
         // scr_watch.c links only when this line is emitted.
-        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(embedsZlib ? [`  call void @scr_zlib_island_install()`] : []), ...(embedsNet ? [`  call void @scr_net_island_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(usesIsland
+        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(embedsZlib ? [`  call void @scr_zlib_island_install()`] : []), ...(embedsNet ? [`  call void @scr_net_island_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(usesIsland
             ? [
                 ...(moduleEmbedsCompressedNpm(this.mod)
                     ? [`  call void @scr_island_set_inflate(ptr @scr_zlib_inflate_exact)`]
@@ -1810,7 +1979,7 @@ class LlEmitter {
         // sanitize_address is inert under the plain pipeline; the sanitized
         // lane's -fsanitize=address link activates instrumentation over the
         // emitted functions too (the runtime TUs get theirs from clang).
-        `attributes #0 = { sanitize_address }`, ...(this.wasi ? [`attributes #1 = { sanitize_address presplitcoroutine }`] : []), ``);
+        `attributes #0 = { sanitize_address }`, ...(this.wasi ? [`attributes #1 = { sanitize_address presplitcoroutine }`] : []), ...(hasNoInlineRecordClone ? [`attributes #2 = { noinline sanitize_address }`] : []), ``);
         return out.join("\n");
     }
     /** LIBRARY mode: the profile-declared external definitions — the
@@ -1891,14 +2060,13 @@ class LlEmitter {
             });
             out.push(`miss:`, `  ret i32 -1`, `}`, ``);
         }
-        if (lib.identity !== undefined) {
+        if (lib.identity !== undefined && this.emitLibraryIdentity) {
             // Profile-declared identity getters (the ask-2 sidecar's boot-time
             // pairing fence): pure data returns with NO entry prologue — exempt
             // from the poisoned guard and every runtime touch (ratified), so a
             // host can read them before init and after a trap. The u64 rides
             // i64 two's-complement (LLVM integer constants are signed).
-            const buildId = BigInt.asIntN(64, BigInt(`0x${lib.identity.buildId}`)).toString();
-            out.push(`define i64 @${lib.identity.buildIdSymbol}() ${FN_ATTRS} { ; identity getter build_id 0x${lib.identity.buildId}`, `entry:`, `  ret i64 ${buildId}`, `}`, ``, `define i32 @${lib.identity.abiVersionSymbol}() ${FN_ATTRS} { ; identity getter abi_version`, `entry:`, `  ret i32 ${lib.identity.abiVersion}`, `}`, ``);
+            out.push(...emitLibraryIdentityLines("llvm", lib.identity, FN_ATTRS));
         }
         if (lib.resultResetSymbol !== null) {
             out.push(`define void @${lib.resultResetSymbol}() ${FN_ATTRS} {`, `entry:`, `  call void @scr_library_entry(i1 zeroext false, ptr ${symConst(lib.resultResetSymbol)})`, `  call void @scr_library_arena_reset()`, `  ret void`, `}`, ``);
@@ -4729,6 +4897,30 @@ class LlEmitter {
                 }
                 return out;
             }
+            case "recordClone": {
+                if (e.type.kind !== "record")
+                    throw new Error("llvm emitter bug: recordClone of non-record type");
+                this.recordCloneShapes.add(e.type.shapeId);
+                const source = this.emitExpr(e.source);
+                const rec = B.tmp();
+                B.line(`${rec} = call ptr @${mangleRecordClone(e.type.shapeId)}(ptr ${source.name})`);
+                const out = this.own({ name: rec, type: e.type });
+                for (const f of e.overrides) {
+                    const v = this.emitExpr(f.value);
+                    const { ptr, type } = this.recordFieldPtr(rec, e.type.shapeId, f.name);
+                    if (isRefCounted(type)) {
+                        this.moveTemp(v);
+                        const old = B.tmp();
+                        B.line(`${old} = load ptr, ptr ${ptr}`);
+                        this.storeField(ptr, type, v.name);
+                        this.releaseValue(old, type);
+                    }
+                    else {
+                        this.storeField(ptr, type, v.name);
+                    }
+                }
+                return out;
+            }
             case "recordGet": {
                 const obj = this.emitExpr(e.obj);
                 const { ptr, type } = this.recordFieldPtr(obj.name, e.shapeId, e.field);
@@ -5605,7 +5797,48 @@ class LlEmitter {
                     sourceArgs.set(abiIndex, arg);
                     if (isFfiCallbackParam(param))
                         callbackArgs.set(param.callback.id, arg);
+                    if (isFfiReleaseParam(param))
+                        callbackArgs.set(param.callback.release, arg);
                 });
+                const { registrations: retainedRegistrations, releases: retainedReleases } = collectFfiRetainedOps(entry, callbackArgs, (binding, id) => this.ffiCallbackAdapter(binding, id));
+                if (retainedRegistrations.length > 0) {
+                    this.declare(`declare void @scr_ffi_retain(ptr, ptr)`);
+                    if (retainedRegistrations.some((registration) => registration.global !== null)) {
+                        this.declare(`declare void @scr_ffi_retain_slot(ptr, ptr, ptr)`);
+                        this.declare(`declare void @scr_ffi_commit_slot(ptr, ptr)`);
+                    }
+                }
+                if (retainedReleases.length > 0) {
+                    this.declare(`declare void @scr_ffi_require(ptr, ptr)`);
+                    if (retainedReleases.some((release) => release.foreign)) {
+                        this.declare(`declare void @scr_ffi_require_foreign(ptr, ptr)`);
+                    }
+                }
+                // Pin before registration. Raw retained descriptors are native
+                // singletons: the incoming closure is pinned (and an EMPTY slot
+                // armed) before the native set call, but a replaced registration
+                // stays live and dispatching until the call returns — a native
+                // setter may flush the outgoing callback one last time mid-replace.
+                // scr_ffi_commit_slot below repoints the slot and retires the
+                // superseded pins after the call.
+                for (const registration of retainedRegistrations) {
+                    if (registration.global !== null) {
+                        B.line(`call void @scr_ffi_retain_slot(ptr @${registration.table}, ptr @${registration.global}, ptr ${registration.callback.name})`);
+                    }
+                    else if (registration.foreign) {
+                        this.declare(`declare void @scr_ffi_retain_foreign(ptr, ptr)`);
+                        B.line(`call void @scr_ffi_retain_foreign(ptr @${registration.table}, ptr ${registration.callback.name})`);
+                    }
+                    else {
+                        B.line(`call void @scr_ffi_retain(ptr @${registration.table}, ptr ${registration.callback.name})`);
+                    }
+                }
+                // Validate releases BEFORE the native removal call runs: a bogus
+                // release traps without native code observing any side effect. The
+                // registration itself is unpinned only after the call returns.
+                for (const release of retainedReleases) {
+                    B.line(`call void @scr_ffi_require${release.foreign ? "_foreign" : ""}(ptr @${release.table}, ptr ${release.callback.name})`);
+                }
                 const rawContexts = [];
                 for (const param of entry.params) {
                     if (!isFfiCallbackParam(param))
@@ -5628,6 +5861,13 @@ class LlEmitter {
                         nativeArgs.push(`ptr @${adapter.symbol}`);
                         return;
                     }
+                    if (isFfiReleaseParam(param)) {
+                        const { binding, id } = parseFfiCallbackKey(param.callback.release);
+                        const adapter = this.ffiCallbackAdapter(binding, id);
+                        nativeParamTypes.push("ptr");
+                        nativeArgs.push(`ptr @${adapter.symbol}`);
+                        return;
+                    }
                     if (isFfiContextParam(param)) {
                         const callback = callbackArgs.get(param.context);
                         if (!callback)
@@ -5713,10 +5953,30 @@ class LlEmitter {
                         B.line(`store ptr ${saved.previous}, ptr @${saved.tls}`);
                     }
                 };
-                const callbacksMayThrow = callbackArgs.size > 0;
+                const finishRetainedReleases = () => {
+                    // Commit raw replacements first (repoint the slot, retire the
+                    // superseded pins), then unpin explicit releases — the runtime
+                    // disarms the slot itself when the released closure holds it.
+                    for (const registration of retainedRegistrations) {
+                        if (registration.global !== null) {
+                            B.line(`call void @scr_ffi_commit_slot(ptr @${registration.table}, ptr ${registration.callback.name})`);
+                        }
+                    }
+                    if (retainedReleases.some((release) => !release.foreign)) {
+                        this.declare(`declare void @scr_ffi_release(ptr, ptr)`);
+                    }
+                    if (retainedReleases.some((release) => release.foreign)) {
+                        this.declare(`declare void @scr_ffi_release_foreign(ptr, ptr)`);
+                    }
+                    for (const release of retainedReleases) {
+                        B.line(`call void @scr_ffi_release${release.foreign ? "_foreign" : ""}(ptr @${release.table}, ptr ${release.callback.name})`);
+                    }
+                };
+                const callbacksMayThrow = callbackArgs.size > 0 || this.ffiHasRetainedCallback;
                 if (entry.returns === "void") {
                     B.line(call);
                     restoreRawContexts();
+                    finishRetainedReleases();
                     if (callbacksMayThrow)
                         this.emitPendingCheck();
                     return { name: "", type: e.type };
@@ -5724,6 +5984,7 @@ class LlEmitter {
                 const raw = B.tmp();
                 B.line(`${raw} = ${call}`);
                 restoreRawContexts();
+                finishRetainedReleases();
                 if (entry.returns === "f64") {
                     const result = { name: raw, type: e.type };
                     if (callbacksMayThrow)