knitting 0.1.55 → 0.1.60

package/src/ipc/tools/ring-queue.js

@@ -0,0 +1,159 @@
+;
+export default class RingQueue {
+    #buf;
+    #mask;
+    #head = 0;
+    #tail = 0;
+    #size = 0;
+    constructor(capacity = 512) {
+        let cap = 2;
+        while (cap < capacity)
+            cap <<= 1;
+        // Keep the array packed (avoid holey elements in hot queue paths).
+        this.#buf = new Array(cap).fill(null);
+        this.#mask = cap - 1;
+    }
+    get size() {
+        return this.#size;
+    }
+    get isEmpty() {
+        return this.#size === 0;
+    }
+    get capacity() {
+        return this.#mask + 1;
+    }
+    clear() {
+        // Keep buffer allocated; reset pointers (fast)
+        // (optional) also drop references to help GC if you want:
+        // for (let i = 0; i < this.#size; i++) this.#buf[(this.#head + i) & this.#mask] = null;
+        this.#head = 0;
+        this.#tail = 0;
+        this.#size = 0;
+    }
+    peek() {
+        return this.#size === 0 ? undefined : this.#buf[this.#head];
+    }
+    /** Ensure internal capacity >= requested (rounds up to next power of two). */
+    reserve(minCapacity) {
+        if (minCapacity <= this.capacity)
+            return;
+        let cap = this.capacity;
+        while (cap < minCapacity)
+            cap <<= 1;
+        this.#growTo(cap);
+    }
+    // --- hot path internal ---
+    #growIfFull() {
+        if (this.#size !== (this.#mask + 1))
+            return;
+        this.#growTo((this.#mask + 1) << 1);
+    }
+    #growTo(newCap) {
+        const oldBuf = this.#buf;
+        const oldCap = this.#mask + 1;
+        const n = this.#size;
+        const next = new Array(newCap).fill(null);
+        const head = this.#head;
+        const firstLen = Math.min(n, oldCap - head);
+        // copy [head..end)
+        for (let i = 0; i < firstLen; i++) {
+            next[i] = oldBuf[head + i];
+        }
+        // copy [0..remaining)
+        for (let i = firstLen; i < n; i++) {
+            next[i] = oldBuf[i - firstLen];
+        }
+        this.#buf = next;
+        this.#mask = newCap - 1;
+        this.#head = 0;
+        this.#tail = n;
+    }
+    /**
+     * Push to back
+     * Always succeeds (grows if full)
+     */
+    push(value) {
+        this.#growIfFull();
+        const buf = this.#buf;
+        const mask = this.#mask;
+        const tail = this.#tail;
+        buf[tail] = value;
+        this.#tail = (tail + 1) & mask;
+        this.#size++;
+        return true;
+    }
+    /**
+     * Push to front (unshift)
+     * Always succeeds (grows if full)
+     */
+    unshift(value) {
+        this.#growIfFull();
+        const buf = this.#buf;
+        const mask = this.#mask;
+        const head = (this.#head - 1) & mask;
+        this.#head = head;
+        buf[head] = value;
+        this.#size++;
+        return true;
+    }
+    /**
+     * Pop from front (shift)
+     */
+    shift() {
+        const size = this.#size;
+        if (size === 0)
+            return undefined;
+        const head = this.#head;
+        const buf = this.#buf;
+        const v = buf[head];
+        buf[head] = null; // help GC while keeping packed elements
+        this.#head = (head + 1) & this.#mask;
+        this.#size = size - 1;
+        return v;
+    }
+    /**
+     * Pop from front (shift) without clearing the slot.
+     * Use only for internal pooled-object queues where retaining references is acceptable.
+     */
+    shiftNoClear() {
+        const size = this.#size;
+        if (size === 0)
+            return undefined;
+        const head = this.#head;
+        const v = this.#buf[head];
+        this.#head = (head + 1) & this.#mask;
+        this.#size = size - 1;
+        return v;
+    }
+    *[Symbol.iterator]() {
+        const buf = this.#buf;
+        const mask = this.#mask;
+        let idx = this.#head;
+        let i = 0;
+        const n = this.#size;
+        while (i < n) {
+            // values should never be null inside active range, but keep it safe
+            const v = buf[idx];
+            if (v !== null)
+                yield v;
+            idx = (idx + 1) & mask;
+            i++;
+        }
+    }
+    toArray() {
+        // faster than Array.from(this) in some cases because it avoids iterator overhead,
+        // but keep iterator version if you prefer simplicity.
+        const out = new Array(this.#size);
+        const buf = this.#buf;
+        const mask = this.#mask;
+        let idx = this.#head;
+        for (let i = 0; i < out.length; i++) {
+            out[i] = buf[idx];
+            idx = (idx + 1) & mask;
+        }
+        return out;
+    }
+    get [Symbol.toStringTag]() {
+        return `RingQueue(size=${this.#size}, cap=${this.capacity})`;
+    }
+}

package/src/ipc/transport/shared-memory.d.ts

@@ -0,0 +1,23 @@
+export type SignalArguments = ReturnType<typeof createSharedMemoryTransport>;
+import { type SharedBufferSource } from "../../common/shared-buffer-region.js";
+export declare const TRANSPORT_SIGNAL_BYTES: number;
+export type Sab = {
+    size?: number;
+    sharedSab?: SharedBufferSource;
+};
+type SignalForWorker = {
+    sabObject?: Sab;
+    isMain: boolean;
+    thread: number;
+    startTime?: number;
+};
+export declare const createSharedMemoryTransport: ({ sabObject, isMain, startTime }: SignalForWorker) => {
+    sab: import("../../common/shared-buffer-region.js").SharedBufferRegion;
+    op: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
+    startAt: number;
+    opView: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
+    rxStatus: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
+    txStatus: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
+};
+export type MainSignal = Pick<SignalArguments, "opView" | "startAt" | "rxStatus" | "txStatus">;
+export {};

package/src/ipc/transport/shared-memory.js

@@ -0,0 +1,35 @@
+import { createSharedArrayBuffer } from "../../common/runtime.js";
+import { toSharedBufferRegion, } from "../../common/shared-buffer-region.js";
+const page = 1024 * 4;
+const CACHE_LINE_BYTES = 64;
+// Keep hot signals on separate cache lines to avoid false sharing.
+const SIGNAL_OFFSETS = {
+    op: 0,
+    rxStatus: CACHE_LINE_BYTES,
+    txStatus: CACHE_LINE_BYTES * 2,
+};
+export const TRANSPORT_SIGNAL_BYTES = CACHE_LINE_BYTES * 3;
+const a_store = Atomics.store;
+export const createSharedMemoryTransport = ({ sabObject, isMain, startTime }) => {
+    const toGrow = sabObject?.size ?? page;
+    const roundedSize = toGrow + ((page - (toGrow % page)) % page);
+    const signalRegion = toSharedBufferRegion(sabObject?.sharedSab
+        ? sabObject.sharedSab
+        : createSharedArrayBuffer(roundedSize, page * page));
+    const sab = signalRegion.sab;
+    const baseByteOffset = signalRegion.byteOffset;
+    const startAt = startTime ?? performance.now();
+    const opView = new Int32Array(sab, baseByteOffset + SIGNAL_OFFSETS.op, 1);
+    if (isMain)
+        a_store(opView, 0, 0);
+    const rxStatus = new Int32Array(sab, baseByteOffset + SIGNAL_OFFSETS.rxStatus, 1);
+    a_store(rxStatus, 0, 1);
+    return {
+        sab: signalRegion,
+        op: opView,
+        startAt,
+        opView,
+        rxStatus,
+        txStatus: new Int32Array(sab, baseByteOffset + SIGNAL_OFFSETS.txStatus, 1),
+    };
+};

package/src/memory/byte-carpet.d.ts

@@ -0,0 +1,73 @@
+import type { SharedBuffer, SharedBufferRegion } from "../common/shared-buffer-region.js";
+export declare const BYTE_CARPET_ALIGN_BYTES = 64;
+export declare const alignBytes: (value: number, alignment?: number) => number;
+export declare const makeSharedBufferRegion: (sab: SharedBuffer, byteOffset: number, byteLength: number) => SharedBufferRegion;
+export type ByteCarpetSlice = {
+    name: string;
+    byteOffset: number;
+    byteLength: number;
+    reservedByteLength: number;
+};
+export declare const createByteCarpet: ({ alignTo, startByteOffset, }?: {
+    alignTo?: number;
+    startByteOffset?: number;
+}) => {
+    slices: ByteCarpetSlice[];
+    take: (name: string, byteLength: number, { alignTo: sliceAlignment, reserveByteLength, }?: {
+        alignTo?: number;
+        reserveByteLength?: number;
+    }) => ByteCarpetSlice;
+    byteLength: () => number;
+    bind: (sab: SharedBuffer, slice: ByteCarpetSlice) => SharedBufferRegion;
+};
+export declare const getStridedSlotOffsetU32: ({ slotIndex, slotStrideU32, baseU32, extraU32, }: {
+    slotIndex: number;
+    slotStrideU32: number;
+    baseU32?: number;
+    extraU32?: number;
+}) => number;
+export declare const getStridedSlotByteOffset: ({ slotIndex, slotStrideU32, baseByteOffset, baseU32, extraU32, }: {
+    slotIndex: number;
+    slotStrideU32: number;
+    baseByteOffset?: number;
+    baseU32?: number;
+    extraU32?: number;
+}) => number;
+export declare const getStridedRegionSpanBytes: ({ slotCount, slotStrideU32, slotLengthU32, baseU32, }: {
+    slotCount: number;
+    slotStrideU32: number;
+    slotLengthU32: number;
+    baseU32?: number;
+}) => number;
+export declare const getInterleavedSlotStrideU32: (slotStrideU32: number) => number;
+export declare const getHeaderBlockByteLength: ({ slotCount, slotStrideU32, queues, alignTo, }: {
+    slotCount: number;
+    slotStrideU32: number;
+    queues?: number;
+    alignTo?: number;
+}) => number;
+export type HeaderLayoutMode = "split" | "interleaved";
+export type QueueControlByteLayout = {
+    headers: SharedBufferRegion;
+    headerSlotStrideU32: number;
+    lockSector: SharedBufferRegion;
+    payloadSector: SharedBufferRegion;
+};
+export type LockControlCarpet = {
+    controlSAB: SharedBuffer;
+    signals: SharedBufferRegion;
+    abortSignals: SharedBufferRegion;
+    lock: QueueControlByteLayout;
+    returnLock: QueueControlByteLayout;
+    slices: readonly ByteCarpetSlice[];
+};
+export declare const createLockControlCarpet: ({ signalBytes, abortBytes, lockSectorBytes, headerSlotStrideU32, slotCount, headerLayout, alignTo, createBuffer, }: {
+    signalBytes: number;
+    abortBytes: number;
+    lockSectorBytes: number;
+    headerSlotStrideU32: number;
+    slotCount: number;
+    headerLayout?: HeaderLayoutMode;
+    alignTo?: number;
+    createBuffer?: (byteLength: number) => SharedBuffer;
+}) => LockControlCarpet;

package/src/memory/byte-carpet.js

@@ -0,0 +1,157 @@
+export const BYTE_CARPET_ALIGN_BYTES = 64;
+const U32_BYTES = Uint32Array.BYTES_PER_ELEMENT;
+const toNonNegativeInteger = (value, label) => {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new RangeError(`${label} must be a non-negative integer`);
+    }
+    return value;
+};
+export const alignBytes = (value, alignment = BYTE_CARPET_ALIGN_BYTES) => {
+    const safeValue = toNonNegativeInteger(value, "value");
+    const safeAlignment = toNonNegativeInteger(alignment, "alignment");
+    if (safeAlignment === 0) {
+        throw new RangeError("alignment must be greater than zero");
+    }
+    return Math.ceil(safeValue / safeAlignment) * safeAlignment;
+};
+export const makeSharedBufferRegion = (sab, byteOffset, byteLength) => ({
+    sab,
+    byteOffset: toNonNegativeInteger(byteOffset, "byteOffset"),
+    byteLength: toNonNegativeInteger(byteLength, "byteLength"),
+});
+export const createByteCarpet = ({ alignTo = BYTE_CARPET_ALIGN_BYTES, startByteOffset = 0, } = {}) => {
+    const defaultAlignment = toNonNegativeInteger(alignTo, "alignTo");
+    if (defaultAlignment === 0) {
+        throw new RangeError("alignTo must be greater than zero");
+    }
+    let cursor = toNonNegativeInteger(startByteOffset, "startByteOffset");
+    const slices = [];
+    const take = (name, byteLength, { alignTo: sliceAlignment = defaultAlignment, reserveByteLength, } = {}) => {
+        const logicalByteLength = toNonNegativeInteger(byteLength, `${name} byteLength`);
+        const safeSliceAlignment = toNonNegativeInteger(sliceAlignment, `${name} alignTo`);
+        if (safeSliceAlignment === 0) {
+            throw new RangeError(`${name} alignTo must be greater than zero`);
+        }
+        const reserved = reserveByteLength == null
+            ? alignBytes(logicalByteLength, safeSliceAlignment)
+            : toNonNegativeInteger(reserveByteLength, `${name} reserveByteLength`);
+        if (reserved < logicalByteLength) {
+            throw new RangeError(`${name} reserveByteLength must cover byteLength`);
+        }
+        const byteOffset = alignBytes(cursor, safeSliceAlignment);
+        const slice = {
+            name,
+            byteOffset,
+            byteLength: logicalByteLength,
+            reservedByteLength: reserved,
+        };
+        slices.push(slice);
+        cursor = byteOffset + reserved;
+        return slice;
+    };
+    return {
+        slices,
+        take,
+        byteLength: () => cursor,
+        bind: (sab, slice) => makeSharedBufferRegion(sab, slice.byteOffset, slice.byteLength),
+    };
+};
+export const getStridedSlotOffsetU32 = ({ slotIndex, slotStrideU32, baseU32 = 0, extraU32 = 0, }) => (slotIndex * slotStrideU32) + baseU32 + extraU32;
+export const getStridedSlotByteOffset = ({ slotIndex, slotStrideU32, baseByteOffset = 0, baseU32 = 0, extraU32 = 0, }) => baseByteOffset +
+    (getStridedSlotOffsetU32({
+        slotIndex,
+        slotStrideU32,
+        baseU32,
+        extraU32,
+    }) * U32_BYTES);
+export const getStridedRegionSpanBytes = ({ slotCount, slotStrideU32, slotLengthU32, baseU32 = 0, }) => {
+    const safeSlotCount = toNonNegativeInteger(slotCount, "slotCount");
+    if (safeSlotCount === 0)
+        return 0;
+    return (getStridedSlotOffsetU32({
+        slotIndex: safeSlotCount - 1,
+        slotStrideU32,
+        baseU32,
+    }) + slotLengthU32) * U32_BYTES;
+};
+export const getInterleavedSlotStrideU32 = (slotStrideU32) => slotStrideU32 * 2;
+export const getHeaderBlockByteLength = ({ slotCount, slotStrideU32, queues = 1, alignTo = BYTE_CARPET_ALIGN_BYTES, }) => alignBytes(slotCount * slotStrideU32 * U32_BYTES * queues, alignTo);
+const createInterleavedHeaderPair = ({ sab, byteOffset, slotCount, slotStrideU32, }) => {
+    const headerSlotStrideU32 = getInterleavedSlotStrideU32(slotStrideU32);
+    const slotBytes = slotStrideU32 * U32_BYTES;
+    const spanBytes = getStridedRegionSpanBytes({
+        slotCount,
+        slotStrideU32: headerSlotStrideU32,
+        slotLengthU32: slotStrideU32,
+    });
+    return {
+        headerSlotStrideU32,
+        requestHeaders: makeSharedBufferRegion(sab, byteOffset, spanBytes),
+        returnHeaders: makeSharedBufferRegion(sab, byteOffset + slotBytes, spanBytes),
+    };
+};
+export const createLockControlCarpet = ({ signalBytes, abortBytes, lockSectorBytes, headerSlotStrideU32, slotCount, headerLayout = "interleaved", alignTo = BYTE_CARPET_ALIGN_BYTES, createBuffer = (byteLength) => new SharedArrayBuffer(byteLength), }) => {
+    const carpet = createByteCarpet({ alignTo });
+    const signalsSlice = carpet.take("signals", signalBytes);
+    const requestLockSlice = carpet.take("requestLockSector", lockSectorBytes);
+    const returnLockSlice = carpet.take("returnLockSector", lockSectorBytes);
+    let requestHeadersSlice;
+    let returnHeadersSlice;
+    let interleavedHeadersSlice;
+    if (headerLayout === "interleaved") {
+        interleavedHeadersSlice = carpet.take("interleavedHeaders", getHeaderBlockByteLength({
+            slotCount,
+            slotStrideU32: headerSlotStrideU32,
+            queues: 2,
+            alignTo,
+        }));
+    }
+    else {
+        requestHeadersSlice = carpet.take("requestHeaders", getHeaderBlockByteLength({
+            slotCount,
+            slotStrideU32: headerSlotStrideU32,
+            alignTo,
+        }));
+        returnHeadersSlice = carpet.take("returnHeaders", getHeaderBlockByteLength({
+            slotCount,
+            slotStrideU32: headerSlotStrideU32,
+            alignTo,
+        }));
+    }
+    const abortSignalsSlice = carpet.take("abortSignals", abortBytes);
+    const controlSAB = createBuffer(carpet.byteLength());
+    const signals = carpet.bind(controlSAB, signalsSlice);
+    const abortSignals = carpet.bind(controlSAB, abortSignalsSlice);
+    const requestLockSector = carpet.bind(controlSAB, requestLockSlice);
+    const returnLockSector = carpet.bind(controlSAB, returnLockSlice);
+    const headerPair = headerLayout === "interleaved"
+        ? createInterleavedHeaderPair({
+            sab: controlSAB,
+            byteOffset: interleavedHeadersSlice.byteOffset,
+            slotCount,
+            slotStrideU32: headerSlotStrideU32,
+        })
+        : {
+            headerSlotStrideU32,
+            requestHeaders: carpet.bind(controlSAB, requestHeadersSlice),
+            returnHeaders: carpet.bind(controlSAB, returnHeadersSlice),
+        };
+    return {
+        controlSAB,
+        signals,
+        abortSignals,
+        lock: {
+            headers: headerPair.requestHeaders,
+            headerSlotStrideU32: headerPair.headerSlotStrideU32,
+            lockSector: requestLockSector,
+            payloadSector: requestLockSector,
+        },
+        returnLock: {
+            headers: headerPair.returnHeaders,
+            headerSlotStrideU32: headerPair.headerSlotStrideU32,
+            lockSector: returnLockSector,
+            payloadSector: returnLockSector,
+        },
+        slices: carpet.slices,
+    };
+};

package/src/memory/lock.d.ts

@@ -0,0 +1,213 @@
+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 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 = [
+    number,
+    number,
+    PayloadSignal | PayloadBuffer,
+    number,
+    number,
+    number,
+    number,
+    number
+] & {
+    value: unknown;
+    finalize?: (() => void) | undefined;
+    resolve: (value?: unknown) => void;
+    reject: (reason?: unknown) => void;
+};
+export declare const PayloadTransportFinalizer: unique symbol;
+export declare const PromisePayloadMarker: unique symbol;
+export type PromisePayloadHandler = (task: Task, isRejected: boolean, value: unknown) => void;
+export declare const beginPromisePayload: (task: Task) => boolean;
+export declare const finishPromisePayload: (task: Task) => void;
+export declare const isPromisePayloadPending: (task: Task) => boolean;
+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 const TaskIndex: {
+    /**
+     * Worker -> host response flags word.
+     */
+    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`.
+     */
+    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).
+     */
+    readonly slotBuffer: 6;
+    readonly Size: 8;
+    /**
+     * Total slot length in Uint32 words, including the task header.
+     */
+    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;
+export declare const TASK_SLOT_META_VALUE_MASK: number;
+export declare const TASK_FUNCTION_ID_BITS = 16;
+export declare const TASK_FUNCTION_ID_MASK: number;
+export declare const TASK_FUNCTION_META_BITS: number;
+export declare const TASK_FUNCTION_META_VALUE_MASK: number;
+export declare const getTaskFunctionID: (task: ArrayLike<number>) => number;
+export declare const setTaskFunctionID: (task: Task, functionID: number) => void;
+export declare const getTaskFunctionMeta: (task: ArrayLike<number>) => number;
+export declare const setTaskFunctionMeta: (task: Task, value: number) => void;
+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 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: 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;
+export declare const PAYLOAD_LOCK_WORKER_BITS_OFFSET_BYTES: number;
+export declare const PAYLOAD_LOCK_SECTOR_BYTE_LENGTH = 256;
+export declare const HEADER_SLOT_STRIDE_U32: number;
+export declare const HEADER_SLOT_STRIDE_BYTES: number;
+export declare const HEADER_TASK_LINE_U32: number;
+export declare const HEADER_STATIC_PAYLOAD_U32: number;
+export declare const HEADER_TASK_OFFSET_IN_SLOT_U32: number;
+export declare const HEADER_U32_LENGTH: number;
+export declare const HEADER_BYTE_LENGTH: number;
+export declare const makeTask: () => Task;
+type ResolveHostOptions = {
+    queue: Task[];
+    onResolved?: (task: Task) => void;
+    shouldSettle?: (task: Task) => boolean;
+    activeRejectPlaceholder?: Task["reject"];
+};
+/**
+ * Complexity: 7 / 10
+ *
+ * SAFETY:
+ *  - Single producer/consumer; do not call encode/decode concurrently.
+ *  - Shared buffers must be the same between host/worker.
+ *  - 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, processBoundary, }: {
+    headers?: SharedBufferSource;
+    headerSlotStrideU32?: number;
+    LockBoundSector?: SharedBufferSource;
+    payload?: SharedBufferSource;
+    payloadConfig?: PayloadBufferOptions;
+    payloadSector?: SharedBufferSource;
+    textCompat?: LockBufferTextCompat;
+    toSentList?: RingQueue<Task>;
+    resultList?: RingQueue<Task>;
+    recycleList?: RingQueue<Task>;
+    processBoundary?: boolean;
+}) => {
+    enlist: (task: Task) => true;
+    encode: (task: Task, state?: number) => boolean;
+    encodeManyFrom: (list: RingQueue<Task>) => number;
+    encodeAll: () => boolean;
+    publish: (task: Task) => boolean;
+    flushPending: () => boolean;
+    decode: () => boolean;
+    hasSpace: () => boolean;
+    resolved: RingQueue<Task>;
+    hostBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+    workerBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+    recyclecList: RingQueue<Task>;
+    resolveHost: ({ queue, onResolved, shouldSettle, activeRejectPlaceholder, }: ResolveHostOptions) => () => number;
+    hasPendingFrames: () => boolean;
+    getPendingFrameCount: () => number;
+    getPendingPromiseCount: () => number;
+    resetPendingState: () => void;
+    takeDeferredCount: () => number;
+    setPromiseHandler: (handler?: PromisePayloadHandler) => void;
+};
+export {};