knitting 0.1.56 → 0.1.60

package/src/connections/process-shared-buffer.js

@@ -1,10 +1,8 @@
-import { getNodeBuiltinModule } from "../common/node-compat.js";
 import { FileDescriptor, } from "./file-descriptor.js";
 import { RUNTIME } from "../common/runtime.js";
 import { createBunConnectionPrimitives } from "./bun.js";
 import { createDenoConnectionPrimitives } from "./deno.js";
-import { loadNodeNativeAddon } from "./node-addons.js";
-import { expectFd, expectPositiveSize, readCreateMode, readCreateName, readRequiredCreateName, readCreateSize, } from "./types.js";
+import { createNodeConnectionPrimitives } from "./node.js";
 export const PROCESS_SHARED_BUFFER_BRAND = Symbol.for("knitting.processSharedBuffer");
 export const PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER = Symbol.for("knitting.processSharedBuffer.numericTransfer");
 const EXTERNAL_PAYLOAD_BRAND = Symbol.for("knitting.payloadCodec");
@@ -39,51 +37,15 @@ const decodeKind = (value) => {
     }
 };
 let defaultPrimitives;
-const fromDefaultNodeNativeMapping = (mapped) => {
-    const mapping = {
-        runtime: "node",
-        fd: mapped.fd,
-        size: mapped.size,
-        byteLength: mapped.sab.byteLength,
-        buffer: mapped.sab,
-        kind: "shared-array-buffer",
-        sab: mapped.sab,
-        baseAddressMod64: mapped.baseAddressMod64,
-    };
-    if (mapped.name !== undefined && mapped.name.length > 0) {
-        mapping.name = mapped.name;
-    }
-    return mapping;
-};
-const createDefaultNodePrimitives = () => {
-    const nodeModule = getNodeBuiltinModule("node:module");
-    if (nodeModule === undefined) {
-        throw new TypeError("ProcessSharedBuffer needs connection primitives in this runtime");
-    }
-    const require = nodeModule.createRequire(import.meta.url);
-    const addon = loadNodeNativeAddon(require, "knitting_shared_memory");
-    return {
-        createSharedMemory: (options) => {
-            const size = expectPositiveSize(readCreateSize(options));
-            const mode = readCreateMode(options);
-            const name = mode === "anonymous"
-                ? readCreateName(options, "knitting_shared_memory")
-                : readRequiredCreateName(options);
-            return fromDefaultNodeNativeMapping(addon.createSharedMemory(size, name, mode));
-        },
-        mapSharedMemory: (options) => {
-            const fd = expectFd(options.fd);
-            const size = expectPositiveSize(options.size);
-            return fromDefaultNodeNativeMapping(addon.mapSharedMemory(fd, size, options.name));
-        },
-    };
-};
+const processSharedBufferInstances = new WeakSet();
 const createDefaultPrimitives = () => {
     if (RUNTIME === "bun")
         return createBunConnectionPrimitives();
     if (RUNTIME === "deno")
         return createDenoConnectionPrimitives();
-    return createDefaultNodePrimitives();
+    if (RUNTIME === "node")
+        return createNodeConnectionPrimitives();
+    throw new TypeError("ProcessSharedBuffer needs connection primitives in this runtime");
 };
 export const setDefaultProcessSharedBufferPrimitives = (primitives) => {
     defaultPrimitives = primitives;
@@ -136,6 +98,7 @@ export class ProcessSharedBuffer {
         this.descriptor = descriptor;
         this.byteOffset = byteOffset;
         this.byteLength = byteLength;
+        processSharedBufferInstances.add(this);
     }
     static create(options, creator = getDefaultProcessSharedBufferPrimitives()) {
         return ProcessSharedBuffer.fromMapping(creator.createSharedMemory(options));
@@ -251,6 +214,9 @@ export class ProcessSharedBuffer {
         return this.stringify();
     }
 }
+export const isProcessSharedBufferValue = (value) => value !== null &&
+    typeof value === "object" &&
+    processSharedBufferInstances.has(value);
 export const parseProcessSharedBufferMetadata = (input) => {
     const value = typeof input === "string" ? JSON.parse(input) : input;
     if (!isRecord(value)) {
@@ -271,8 +237,8 @@ export const parseProcessSharedBufferMetadata = (input) => {
     };
 };
 const processSharedBufferGlobal = globalThis;
-const codecs = processSharedBufferGlobal.__KNITTING_PAYLOAD_CODECS__ ??=
-    Object.create(null);
+const codecs = processSharedBufferGlobal.__KNITTING_PAYLOAD_CODECS__ ??= Object
+    .create(null);
 codecs[PROCESS_SHARED_BUFFER_CODEC_ID] = {
     decode: (metadata) => ProcessSharedBuffer.fromMetadata(metadata),
     decodeNumeric: (metadata) => ProcessSharedBuffer[PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata),

package/src/connections/types.d.ts

@@ -31,6 +31,10 @@ export type MapSharedMemoryOptions = {
     fd: number;
     name?: string;
     size: number;
+    /**
+     * When false, map the supplied descriptor directly. Ownership transfers to
+     * the returned mapping only after mapping succeeds; failures leave it open.
+     */
     duplicateFd?: boolean;
 };
 export type SharedMemoryConnectionPrimitives<Mapping extends SharedMemoryMapping = SharedMemoryMapping> = {

package/src/connections/windows.d.ts

@@ -1,28 +1,37 @@
+import { type NodeFfiLibrary } from "./node-ffi-api.js";
 import { type CreateSharedMemoryOptions, type MapSharedMemoryOptions, type SharedMemoryConnectionPrimitives, type SharedMemoryMapping } from "./types.js";
+declare const WINDOWS_CREATE_SHARED_MEMORY = "knitting_windows_create_shared_memory";
+declare const WINDOWS_MAP_SHARED_MEMORY = "knitting_windows_map_shared_memory";
+declare const WINDOWS_CLOSE_SHARED_MEMORY = "knitting_windows_close_shared_memory";
+type WindowsSharedMemorySymbols = {
+    [WINDOWS_CREATE_SHARED_MEMORY]: (size: bigint, name: Uint16Array, mode: number, out: Uint8Array) => number;
+    [WINDOWS_MAP_SHARED_MEMORY]: (handle: bigint, size: bigint, name: Uint16Array, out: Uint8Array) => number;
+    [WINDOWS_CLOSE_SHARED_MEMORY]: (mapping: Uint8Array) => number;
+};
 type DenoWindowsLibrary = {
-    symbols: {
-        knitting_windows_create_shared_memory: (size: bigint, name: Uint16Array, mode: number, out: Uint8Array) => number;
-        knitting_windows_map_shared_memory: (handle: bigint, size: bigint, name: Uint16Array, out: Uint8Array) => number;
-        knitting_windows_close_shared_memory: (mapping: Uint8Array) => number;
-    };
+    symbols: WindowsSharedMemorySymbols;
     close: () => void;
 };
 type BunWindowsLibrary = {
-    symbols: {
-        knitting_windows_create_shared_memory: (size: bigint, name: Uint16Array, mode: number, out: Uint8Array) => number;
-        knitting_windows_map_shared_memory: (handle: bigint, size: bigint, name: Uint16Array, out: Uint8Array) => number;
-        knitting_windows_close_shared_memory: (mapping: Uint8Array) => number;
-    };
+    symbols: WindowsSharedMemorySymbols;
+};
+type NodeWindowsLibrary = {
+    functions: WindowsSharedMemorySymbols;
+    lib: NodeFfiLibrary;
 };
 export declare const isWindowsRuntime: () => boolean;
 export declare const windowsSharedMemoryPrebuildPath: () => string;
 export declare const makeWindowsAnonymousSharedMemoryName: (runtime: string) => string;
 export declare const openDenoWindowsSharedMemoryLibrary: () => DenoWindowsLibrary;
 export declare const openBunWindowsSharedMemoryLibrary: () => BunWindowsLibrary;
+export declare const openNodeWindowsSharedMemoryLibrary: () => NodeWindowsLibrary;
 export declare const createDenoWindowsSharedMemory: (options: number | CreateSharedMemoryOptions, lib?: DenoWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
 export declare const mapDenoWindowsSharedMemory: (options: MapSharedMemoryOptions, lib?: DenoWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
 export declare const createDenoWindowsConnectionPrimitives: (lib?: DenoWindowsLibrary) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
 export declare const createBunWindowsSharedMemory: (options: number | CreateSharedMemoryOptions, lib?: BunWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
 export declare const mapBunWindowsSharedMemory: (options: MapSharedMemoryOptions, lib?: BunWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
 export declare const createBunWindowsConnectionPrimitives: (lib?: BunWindowsLibrary) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
+export declare const createNodeWindowsSharedMemory: (options: number | CreateSharedMemoryOptions, lib?: NodeWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
+export declare const mapNodeWindowsSharedMemory: (options: MapSharedMemoryOptions, lib?: NodeWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
+export declare const createNodeWindowsConnectionPrimitives: (lib?: NodeWindowsLibrary) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
 export {};

package/src/connections/windows.js

@@ -1,4 +1,6 @@
 import { resolveKnittingPackageAsset } from "./package-assets.js";
+import { requireDetachedExternalArrayBuffer } from "./external-array-buffer.js";
+import { getNodeFfi, } from "./node-ffi-api.js";
 import { expectFd, expectPositiveSize, readCreateMode, readCreateSize, readRequiredCreateName, } from "./types.js";
 const WINDOWS_CREATE_MODE_CREATE = 1;
 const WINDOWS_CREATE_MODE_OPEN = 2;
@@ -7,6 +9,9 @@ const POINTER_OFFSET = 0;
 const HANDLE_OFFSET = 8;
 const SIZE_OFFSET = 16;
 const BASE_ADDRESS_MOD_64_OFFSET = 24;
+const WINDOWS_CREATE_SHARED_MEMORY = "knitting_windows_create_shared_memory";
+const WINDOWS_MAP_SHARED_MEMORY = "knitting_windows_map_shared_memory";
+const WINDOWS_CLOSE_SHARED_MEMORY = "knitting_windows_close_shared_memory";
 const FFIType = {
     i32: 5,
     u32: 6,
@@ -105,34 +110,59 @@ const checkWindowsResult = (result, message) => {
     }
 };
 const createRecord = () => new Uint8Array(WINDOWS_MAPPING_RECORD_BYTES);
-export const openDenoWindowsSharedMemoryLibrary = () => getDeno().dlopen(windowsSharedMemoryPrebuildPath(), {
-    knitting_windows_create_shared_memory: {
+const DENO_WINDOWS_SYMBOLS = {
+    [WINDOWS_CREATE_SHARED_MEMORY]: {
         parameters: ["u64", "buffer", "u32", "buffer"],
         result: "i32",
     },
-    knitting_windows_map_shared_memory: {
+    [WINDOWS_MAP_SHARED_MEMORY]: {
         parameters: ["u64", "u64", "buffer", "buffer"],
         result: "i32",
     },
-    knitting_windows_close_shared_memory: {
+    [WINDOWS_CLOSE_SHARED_MEMORY]: {
         parameters: ["buffer"],
         result: "i32",
     },
-});
-export const openBunWindowsSharedMemoryLibrary = () => getBunFFI().dlopen(windowsSharedMemoryPrebuildPath(), {
-    knitting_windows_create_shared_memory: {
+};
+const BUN_WINDOWS_SYMBOLS = {
+    [WINDOWS_CREATE_SHARED_MEMORY]: {
         args: [FFIType.i64, FFIType.ptr, FFIType.u32, FFIType.ptr],
         returns: FFIType.i32,
     },
-    knitting_windows_map_shared_memory: {
+    [WINDOWS_MAP_SHARED_MEMORY]: {
         args: [FFIType.i64, FFIType.i64, FFIType.ptr, FFIType.ptr],
         returns: FFIType.i32,
     },
-    knitting_windows_close_shared_memory: {
+    [WINDOWS_CLOSE_SHARED_MEMORY]: {
         args: [FFIType.ptr],
         returns: FFIType.i32,
     },
-});
+};
+const NODE_WINDOWS_SYMBOLS = {
+    [WINDOWS_CREATE_SHARED_MEMORY]: {
+        arguments: ["u64", "pointer", "u32", "pointer"],
+        return: "i32",
+    },
+    [WINDOWS_MAP_SHARED_MEMORY]: {
+        arguments: ["u64", "u64", "pointer", "pointer"],
+        return: "i32",
+    },
+    [WINDOWS_CLOSE_SHARED_MEMORY]: {
+        arguments: ["pointer"],
+        return: "i32",
+    },
+};
+export const openDenoWindowsSharedMemoryLibrary = () => getDeno().dlopen(windowsSharedMemoryPrebuildPath(), DENO_WINDOWS_SYMBOLS);
+export const openBunWindowsSharedMemoryLibrary = () => getBunFFI().dlopen(windowsSharedMemoryPrebuildPath(), BUN_WINDOWS_SYMBOLS);
+let cachedNodeWindowsLibrary;
+export const openNodeWindowsSharedMemoryLibrary = () => {
+    if (cachedNodeWindowsLibrary !== undefined) {
+        return cachedNodeWindowsLibrary;
+    }
+    const opened = getNodeFfi().dlopen(windowsSharedMemoryPrebuildPath(), NODE_WINDOWS_SYMBOLS);
+    cachedNodeWindowsLibrary = opened;
+    return opened;
+};
 const closeWindowsMapping = (record, closeSharedMemory) => {
     let closed = false;
     return () => {
@@ -142,6 +172,19 @@ const closeWindowsMapping = (record, closeSharedMemory) => {
         checkWindowsResult(closeSharedMemory(record), "knitting_windows_close_shared_memory");
     };
 };
+const makeWindowsMapping = (runtime, mapping, name, arrayBuffer, unsafePointer, close) => ({
+    runtime,
+    fd: fdFromHandle(mapping.handle),
+    name,
+    size: mapping.size,
+    byteLength: arrayBuffer.byteLength,
+    buffer: arrayBuffer,
+    kind: "external-array-buffer",
+    arrayBuffer,
+    unsafePointer,
+    baseAddressMod64: mapping.baseAddressMod64,
+    close,
+});
 const fromDenoWindowsRecord = (record, name, lib) => {
     const mapping = readWindowsNativeMapping(record);
     const pointer = getDeno().UnsafePointer?.create(mapping.address);
@@ -150,19 +193,7 @@ const fromDenoWindowsRecord = (record, name, lib) => {
     }
     const arrayBuffer = new (getDeno().UnsafePointerView)(pointer)
         .getArrayBuffer(mapping.size);
-    return {
-        runtime: "deno",
-        fd: fdFromHandle(mapping.handle),
-        name,
-        size: mapping.size,
-        byteLength: arrayBuffer.byteLength,
-        buffer: arrayBuffer,
-        kind: "external-array-buffer",
-        arrayBuffer,
-        unsafePointer: pointer,
-        baseAddressMod64: mapping.baseAddressMod64,
-        close: closeWindowsMapping(record, lib.symbols.knitting_windows_close_shared_memory),
-    };
+    return makeWindowsMapping("deno", mapping, name, arrayBuffer, pointer, closeWindowsMapping(record, lib.symbols[WINDOWS_CLOSE_SHARED_MEMORY]));
 };
 const fromBunWindowsRecord = (record, name, lib) => {
     const mapping = readWindowsNativeMapping(record);
@@ -170,55 +201,45 @@ const fromBunWindowsRecord = (record, name, lib) => {
         throw new RangeError("Windows mapping pointer is too large for Bun FFI");
     }
     const arrayBuffer = getBunFFI().toArrayBuffer(Number(mapping.address), 0, mapping.size);
-    return {
-        runtime: "bun",
-        fd: fdFromHandle(mapping.handle),
-        name,
-        size: mapping.size,
-        byteLength: arrayBuffer.byteLength,
-        buffer: arrayBuffer,
-        kind: "external-array-buffer",
-        arrayBuffer,
-        unsafePointer: Number(mapping.address),
-        baseAddressMod64: mapping.baseAddressMod64,
-        close: closeWindowsMapping(record, lib.symbols.knitting_windows_close_shared_memory),
-    };
-};
-export const createDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => {
-    const size = expectPositiveSize(readCreateSize(options));
-    const { mode, name } = readWindowsCreate(options, "deno");
-    const record = createRecord();
-    checkWindowsResult(lib.symbols.knitting_windows_create_shared_memory(BigInt(size), encodeWideCString(name), mode, record), "knitting_windows_create_shared_memory");
-    return fromDenoWindowsRecord(record, name, lib);
+    return makeWindowsMapping("bun", mapping, name, arrayBuffer, Number(mapping.address), closeWindowsMapping(record, lib.symbols[WINDOWS_CLOSE_SHARED_MEMORY]));
 };
-export const mapDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => {
-    const fd = expectFd(options.fd);
-    const size = expectPositiveSize(options.size);
-    const record = createRecord();
-    checkWindowsResult(lib.symbols.knitting_windows_map_shared_memory(BigInt(fd), BigInt(size), encodeWideCString(options.name), record), "knitting_windows_map_shared_memory");
-    return fromDenoWindowsRecord(record, options.name, lib);
+const fromNodeWindowsRecord = (record, name, lib) => {
+    const mapping = readWindowsNativeMapping(record);
+    const arrayBuffer = getNodeFfi().toArrayBuffer(mapping.address, mapping.size, false);
+    let closed = false;
+    return makeWindowsMapping("node", mapping, name, arrayBuffer, mapping.address, () => {
+        if (closed)
+            return;
+        requireDetachedExternalArrayBuffer(arrayBuffer);
+        checkWindowsResult(lib.functions[WINDOWS_CLOSE_SHARED_MEMORY](record), WINDOWS_CLOSE_SHARED_MEMORY);
+        closed = true;
+    });
 };
-export const createDenoWindowsConnectionPrimitives = (lib = openDenoWindowsSharedMemoryLibrary()) => ({
-    runtime: "deno",
-    createSharedMemory: (options) => createDenoWindowsSharedMemory(options, lib),
-    mapSharedMemory: (options) => mapDenoWindowsSharedMemory(options, lib),
-});
-export const createBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => {
+const createWindowsSharedMemory = (options, runtime, lib, createSharedMemory, fromRecord) => {
     const size = expectPositiveSize(readCreateSize(options));
-    const { mode, name } = readWindowsCreate(options, "bun");
+    const { mode, name } = readWindowsCreate(options, runtime);
     const record = createRecord();
-    checkWindowsResult(lib.symbols.knitting_windows_create_shared_memory(BigInt(size), encodeWideCString(name), mode, record), "knitting_windows_create_shared_memory");
-    return fromBunWindowsRecord(record, name, lib);
+    checkWindowsResult(createSharedMemory(BigInt(size), encodeWideCString(name), mode, record), WINDOWS_CREATE_SHARED_MEMORY);
+    return fromRecord(record, name, lib);
 };
-export const mapBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => {
+const mapWindowsSharedMemory = (options, lib, mapSharedMemory, fromRecord) => {
     const fd = expectFd(options.fd);
     const size = expectPositiveSize(options.size);
     const record = createRecord();
-    checkWindowsResult(lib.symbols.knitting_windows_map_shared_memory(BigInt(fd), BigInt(size), encodeWideCString(options.name), record), "knitting_windows_map_shared_memory");
-    return fromBunWindowsRecord(record, options.name, lib);
-};
-export const createBunWindowsConnectionPrimitives = (lib = openBunWindowsSharedMemoryLibrary()) => ({
-    runtime: "bun",
-    createSharedMemory: (options) => createBunWindowsSharedMemory(options, lib),
-    mapSharedMemory: (options) => mapBunWindowsSharedMemory(options, lib),
+    checkWindowsResult(mapSharedMemory(BigInt(fd), BigInt(size), encodeWideCString(options.name), record), WINDOWS_MAP_SHARED_MEMORY);
+    return fromRecord(record, options.name, lib);
+};
+export const createDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => createWindowsSharedMemory(options, "deno", lib, lib.symbols[WINDOWS_CREATE_SHARED_MEMORY], fromDenoWindowsRecord);
+export const mapDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => mapWindowsSharedMemory(options, lib, lib.symbols[WINDOWS_MAP_SHARED_MEMORY], fromDenoWindowsRecord);
+const createWindowsConnectionPrimitives = (runtime, lib, createSharedMemory, mapSharedMemory) => ({
+    runtime,
+    createSharedMemory: (options) => createSharedMemory(options, lib),
+    mapSharedMemory: (options) => mapSharedMemory(options, lib),
 });
+export const createDenoWindowsConnectionPrimitives = (lib = openDenoWindowsSharedMemoryLibrary()) => createWindowsConnectionPrimitives("deno", lib, createDenoWindowsSharedMemory, mapDenoWindowsSharedMemory);
+export const createBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => createWindowsSharedMemory(options, "bun", lib, lib.symbols[WINDOWS_CREATE_SHARED_MEMORY], fromBunWindowsRecord);
+export const mapBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => mapWindowsSharedMemory(options, lib, lib.symbols[WINDOWS_MAP_SHARED_MEMORY], fromBunWindowsRecord);
+export const createBunWindowsConnectionPrimitives = (lib = openBunWindowsSharedMemoryLibrary()) => createWindowsConnectionPrimitives("bun", lib, createBunWindowsSharedMemory, mapBunWindowsSharedMemory);
+export const createNodeWindowsSharedMemory = (options, lib = openNodeWindowsSharedMemoryLibrary()) => createWindowsSharedMemory(options, "node", lib, lib.functions[WINDOWS_CREATE_SHARED_MEMORY], fromNodeWindowsRecord);
+export const mapNodeWindowsSharedMemory = (options, lib = openNodeWindowsSharedMemoryLibrary()) => mapWindowsSharedMemory(options, lib, lib.functions[WINDOWS_MAP_SHARED_MEMORY], fromNodeWindowsRecord);
+export const createNodeWindowsConnectionPrimitives = (lib = openNodeWindowsSharedMemoryLibrary()) => createWindowsConnectionPrimitives("node", lib, createNodeWindowsSharedMemory, mapNodeWindowsSharedMemory);

package/src/error.d.ts

@@ -1,10 +1,11 @@
 import { type PromisePayloadHandler, type Task } from "./memory/lock.js";
-export declare enum ErrorKnitting {
-    Function = 0,
-    Symbol = 1,
-    Json = 2,
-    Serializable = 3
-}
+export declare const ErrorKnitting: {
+    readonly Function: 0;
+    readonly Symbol: 1;
+    readonly Json: 2;
+    readonly Serializable: 3;
+};
+export type ErrorKnitting = typeof ErrorKnitting[keyof typeof ErrorKnitting];
 export declare const encoderError: ({ task, type, onPromise, detail, }: {
     task: Task;
     type: ErrorKnitting;

package/src/error.js

@@ -1,12 +1,13 @@
 import { beginPromisePayload, finishPromisePayload, TaskFlag, TaskIndex, } from "./memory/lock.js";
 import { RUNTIME_IS_MAIN_THREAD } from "./common/worker-runtime.js";
-export var ErrorKnitting;
-(function (ErrorKnitting) {
-    ErrorKnitting[ErrorKnitting["Function"] = 0] = "Function";
-    ErrorKnitting[ErrorKnitting["Symbol"] = 1] = "Symbol";
-    ErrorKnitting[ErrorKnitting["Json"] = 2] = "Json";
-    ErrorKnitting[ErrorKnitting["Serializable"] = 3] = "Serializable";
-})(ErrorKnitting || (ErrorKnitting = {}));
+// const object, not `enum`: Andromeda's Nova engine can't parse `enum`. Same
+// value access and emit on Node/Deno/Bun.
+export const ErrorKnitting = {
+    Function: 0,
+    Symbol: 1,
+    Json: 2,
+    Serializable: 3,
+};
 const reasonFrom = (task, type, detail) => {
     switch (type) {
         case ErrorKnitting.Function: {

package/src/memory/lock.d.ts

@@ -1,70 +1,77 @@
 import RingQueue from "../ipc/tools/ring-queue.js";
+type EncodePayloadFactory = typeof import("./payloadCodec.js").encodePayload;
+type DecodePayloadFactory = typeof import("./payloadCodec.js").decodePayload;
+export declare const registerLockPayloadCodec: (encode: EncodePayloadFactory, decode: DecodePayloadFactory) => void;
 import { type SharedBufferSource } from "../common/shared-buffer-region.js";
 import { type LockBufferTextCompat } from "../common/shared-buffer-text.js";
 import { type PayloadBufferOptions } from "./payload-config.js";
 /**
  * TODO: Compose all the instance where the array is passed as argument
  */
-export declare enum PayloadSignal {
-    UNREACHABLE = 0,
-    BigInt = 2,
-    True = 3,
-    False = 4,
-    Undefined = 5,
-    NaN = 6,
-    Float64 = 9,
-    Null = 10
-}
-export declare enum PayloadBuffer {
-    BORDER_SIGNAL_BUFFER = 11,
-    String = 11,
-    Json = 12,
-    StaticString = 15,
-    StaticJson = 16,
-    Binary = 17,
-    StaticBinary = 18,
-    Int32Array = 19,
-    Float64Array = 20,
-    BigInt64Array = 21,
-    BigUint64Array = 22,
-    DataView = 23,
-    Error = 24,
-    Date = 25,
-    Symbol = 26,
-    StaticSymbol = 27,
-    BigInt = 28,
-    StaticBigInt = 29,
-    StaticInt32Array = 31,
-    StaticFloat64Array = 32,
-    StaticBigInt64Array = 33,
-    StaticBigUint64Array = 34,
-    StaticDataView = 35,
-    ArrayBuffer = 36,
-    StaticArrayBuffer = 37,
-    Buffer = 38,
-    StaticBuffer = 39,
-    EnvelopeStaticHeader = 40,
-    EnvelopeDynamicHeader = 41,
-    EnvelopeStaticHeaderString = 42,
-    EnvelopeDynamicHeaderString = 43,
-    ExternalPayload = 44,
-    StaticExternalPayload = 45,
-    ProcessSharedBuffer = 46,
-    BufferReference = 47,
-    SharedArrayBuffer = 48,
-    EnvelopeStaticHeaderExternal = 49,
-    EnvelopeDynamicHeaderExternal = 50,
-    EnvelopeStaticHeaderStringExternal = 51,
-    EnvelopeDynamicHeaderStringExternal = 52,
-    NumericArray = 53,
-    StaticNumericArray = 54
-}
-export declare enum LockBound {
-    paddingLock = 0,
-    padding = 0,
-    slots = 32,
-    header = 0
-}
+export declare const PayloadSignal: {
+    readonly UNREACHABLE: 0;
+    readonly BigInt: 2;
+    readonly True: 3;
+    readonly False: 4;
+    readonly Undefined: 5;
+    readonly NaN: 6;
+    readonly Float64: 9;
+    readonly Null: 10;
+};
+export type PayloadSignal = typeof PayloadSignal[keyof typeof PayloadSignal];
+export declare const PayloadBuffer: {
+    readonly BORDER_SIGNAL_BUFFER: 11;
+    readonly String: 11;
+    readonly Json: 12;
+    readonly StaticString: 15;
+    readonly StaticJson: 16;
+    readonly Binary: 17;
+    readonly StaticBinary: 18;
+    readonly Int32Array: 19;
+    readonly Float64Array: 20;
+    readonly BigInt64Array: 21;
+    readonly BigUint64Array: 22;
+    readonly DataView: 23;
+    readonly Error: 24;
+    readonly Date: 25;
+    readonly Symbol: 26;
+    readonly StaticSymbol: 27;
+    readonly BigInt: 28;
+    readonly StaticBigInt: 29;
+    readonly StaticInt32Array: 31;
+    readonly StaticFloat64Array: 32;
+    readonly StaticBigInt64Array: 33;
+    readonly StaticBigUint64Array: 34;
+    readonly StaticDataView: 35;
+    readonly ArrayBuffer: 36;
+    readonly StaticArrayBuffer: 37;
+    readonly Buffer: 38;
+    readonly StaticBuffer: 39;
+    readonly EnvelopeStaticHeader: 40;
+    readonly EnvelopeDynamicHeader: 41;
+    readonly EnvelopeStaticHeaderString: 42;
+    readonly EnvelopeDynamicHeaderString: 43;
+    readonly ExternalPayload: 44;
+    readonly StaticExternalPayload: 45;
+    readonly ProcessSharedBuffer: 46;
+    readonly BufferReference: 47;
+    readonly SharedArrayBuffer: 48;
+    readonly EnvelopeStaticHeaderExternal: 49;
+    readonly EnvelopeDynamicHeaderExternal: 50;
+    readonly EnvelopeStaticHeaderStringExternal: 51;
+    readonly EnvelopeDynamicHeaderStringExternal: 52;
+    readonly NumericArray: 53;
+    readonly StaticNumericArray: 54;
+};
+export type PayloadBuffer = typeof PayloadBuffer[keyof typeof PayloadBuffer];
+export declare const payloadBufferName: (value: number) => string;
+export declare const LockBound: {
+    readonly paddingLock: 0;
+    readonly padding: 0;
+    readonly slots: 32;
+    readonly header: 0;
+};
+export type LockBound = typeof LockBound[keyof typeof LockBound];
 export declare const LOCK_CACHE_LINE_BYTES = 64;
 export declare const LOCK_SECTOR_BYTES = 256;
 export type Task = [
@@ -92,33 +99,34 @@ export declare const resetTaskLocalFlags: (task: Task) => void;
 export declare const addTaskFinalizer: (task: Task, finalizer: () => void) => void;
 export declare const attachPayloadTransportFinalizer: (task: Task, value: unknown) => void;
 export declare const runTaskFinalizers: (task: Task) => void;
-export declare enum TaskIndex {
+export declare const TaskIndex: {
     /**
      * Worker -> host response flags word.
      */
-    FlagsToHost = 0,
+    readonly FlagsToHost: 0;
     /**
      * Host -> worker request function id (low 16 bits).
      * High 16 bits are reserved for caller metadata on request path.
      * NOTE: shares the same storage word as `FlagsToHost`.
      */
-    FunctionID = 0,
-    ID = 1,
-    Type = 2,
-    Start = 3,
-    End = 4,
-    PayloadLen = 5,
+    readonly FunctionID: 0;
+    readonly ID: 1;
+    readonly Type: 2;
+    readonly Start: 3;
+    readonly End: 4;
+    readonly PayloadLen: 5;
     /**
      * Low 5 bits: region slot index (0..31).
      * High 27 bits: reserved for caller metadata (e.g. enqueue timing).
      */
-    slotBuffer = 6,
-    Size = 8,
+    readonly slotBuffer: 6;
+    readonly Size: 8;
     /**
      * Total slot length in Uint32 words, including the task header.
      */
-    TotalBuff = 144
-}
+    readonly TotalBuff: 144;
+};
+export type TaskIndex = typeof TaskIndex[keyof typeof TaskIndex];
 export declare const TASK_SLOT_INDEX_BITS = 5;
 export declare const TASK_SLOT_INDEX_MASK: number;
 export declare const TASK_SLOT_META_BITS: number;
@@ -135,11 +143,12 @@ export declare const getTaskSlotIndex: (task: ArrayLike<number>) => number;
 export declare const setTaskSlotIndex: (task: Task, slotIndex: number) => void;
 export declare const getTaskSlotMeta: (task: ArrayLike<number>) => number;
 export declare const setTaskSlotMeta: (task: Task, value: number) => void;
-export declare enum TaskFlag {
-    Reject = 1
-}
+export declare const TaskFlag: {
+    readonly Reject: 1;
+};
+export type TaskFlag = typeof TaskFlag[keyof typeof TaskFlag];
 export declare const LOCK_WORD_BYTES: number;
-export declare const LOCK_HOST_BITS_OFFSET_BYTES = LockBound.paddingLock;
+export declare const LOCK_HOST_BITS_OFFSET_BYTES: 0;
 export declare const LOCK_WORKER_BITS_OFFSET_BYTES = 64;
 export declare const LOCK_SECTOR_BYTE_LENGTH = 256;
 export declare const PAYLOAD_LOCK_HOST_BITS_OFFSET_BYTES: number;
@@ -168,7 +177,7 @@ type ResolveHostOptions = {
  *  - encode/decode are not re-entrant; payload codec uses a shared scratch buffer.
  */
 export type Lock2 = ReturnType<typeof lock2>;
-export declare const lock2: ({ headers, headerSlotStrideU32, LockBoundSector, payload, payloadConfig, payloadSector, textCompat, resultList, toSentList, recycleList, }: {
+export declare const lock2: ({ headers, headerSlotStrideU32, LockBoundSector, payload, payloadConfig, payloadSector, textCompat, resultList, toSentList, recycleList, processBoundary, }: {
     headers?: SharedBufferSource;
     headerSlotStrideU32?: number;
     LockBoundSector?: SharedBufferSource;
@@ -179,6 +188,7 @@ export declare const lock2: ({ headers, headerSlotStrideU32, LockBoundSector, pa
     toSentList?: RingQueue<Task>;
     resultList?: RingQueue<Task>;
     recycleList?: RingQueue<Task>;
+    processBoundary?: boolean;
 }) => {
     enlist: (task: Task) => true;
     encode: (task: Task, state?: number) => boolean;