knitting 0.1.46

package/src/memory/payload-config.d.ts

@@ -0,0 +1,22 @@
+import { type SharedBufferSource } from "../common/shared-buffer-region.js";
+export declare const PAYLOAD_DEFAULT_MAX_BYTE_LENGTH: number;
+export declare const PAYLOAD_DEFAULT_INITIAL_BYTES: number;
+export type PayloadBufferMode = "growable" | "fixed";
+export type PayloadBufferOptions = {
+    mode?: PayloadBufferMode;
+    payloadInitialBytes?: number;
+    payloadMaxByteLength?: number;
+    maxPayloadBytes?: number;
+};
+export type ResolvedPayloadBufferOptions = {
+    mode: PayloadBufferMode;
+    payloadInitialBytes: number;
+    payloadMaxByteLength: number;
+    maxPayloadBytes: number;
+};
+type PayloadBackingBuffer = SharedArrayBuffer | ArrayBuffer;
+export declare const resolvePayloadBufferOptions: ({ options, sab, }: {
+    options?: PayloadBufferOptions;
+    sab?: PayloadBackingBuffer | SharedBufferSource;
+}) => ResolvedPayloadBufferOptions;
+export {};

package/src/memory/payload-config.js

@@ -0,0 +1,67 @@
+import { HAS_SAB_GROW, isGrowableSharedArrayBuffer, sharedArrayBufferMaxByteLength, } from "../common/runtime.js";
+import { toSharedBufferRegion, } from "../common/shared-buffer-region.js";
+export const PAYLOAD_DEFAULT_MAX_BYTE_LENGTH = 64 * 1024 * 1024;
+export const PAYLOAD_DEFAULT_INITIAL_BYTES = 4 * 1024 * 1024;
+const toPositiveInteger = (value) => {
+    if (!Number.isFinite(value))
+        return undefined;
+    const int = Math.floor(value);
+    return int > 0 ? int : undefined;
+};
+const canGrowSharedBuffer = (sab) => {
+    if (sab == null)
+        return false;
+    return sab instanceof SharedArrayBuffer &&
+        HAS_SAB_GROW &&
+        isGrowableSharedArrayBuffer(sab);
+};
+const sharedBufferMaxByteLength = (sab) => {
+    if (sab == null)
+        return undefined;
+    if (sab instanceof SharedArrayBuffer) {
+        return toPositiveInteger(sharedArrayBufferMaxByteLength(sab));
+    }
+    return toPositiveInteger(sab.byteLength);
+};
+export const resolvePayloadBufferOptions = ({ options, sab, }) => {
+    const sabRegion = sab === undefined ? undefined : toSharedBufferRegion(sab);
+    const backing = sabRegion?.sab;
+    const requestedMode = options?.mode;
+    const modeDefault = HAS_SAB_GROW ? "growable" : "fixed";
+    let mode = requestedMode ?? modeDefault;
+    if (mode === "growable" && backing != null && !canGrowSharedBuffer(backing)) {
+        mode = "fixed";
+    }
+    if (mode === "growable" && !HAS_SAB_GROW) {
+        mode = "fixed";
+    }
+    const payloadMaxByteLength = toPositiveInteger(options?.payloadMaxByteLength) ??
+        toPositiveInteger(sabRegion?.byteLength) ??
+        sharedBufferMaxByteLength(backing) ??
+        PAYLOAD_DEFAULT_MAX_BYTE_LENGTH;
+    const requestedInitialBytes = toPositiveInteger(options?.payloadInitialBytes);
+    const payloadInitialBytes = mode === "fixed"
+        ? payloadMaxByteLength
+        : Math.min(requestedInitialBytes ?? PAYLOAD_DEFAULT_INITIAL_BYTES, payloadMaxByteLength);
+    const maxPayloadCeiling = payloadMaxByteLength >> 3;
+    if (maxPayloadCeiling <= 0) {
+        throw new RangeError("payloadMaxByteLength is too small; must be at least 8 bytes.");
+    }
+    const rawMaxPayloadBytes = options?.maxPayloadBytes;
+    if (rawMaxPayloadBytes !== undefined) {
+        const normalized = Math.floor(rawMaxPayloadBytes);
+        if (!Number.isFinite(normalized) || normalized <= 0) {
+            throw new RangeError(`maxPayloadBytes must be > 0 and <= ${maxPayloadCeiling}.`);
+        }
+    }
+    const maxPayloadBytes = toPositiveInteger(rawMaxPayloadBytes) ?? maxPayloadCeiling;
+    if (maxPayloadBytes <= 0 || maxPayloadBytes > maxPayloadCeiling) {
+        throw new RangeError(`maxPayloadBytes must be > 0 and <= ${maxPayloadCeiling}.`);
+    }
+    return {
+        mode,
+        payloadInitialBytes,
+        payloadMaxByteLength,
+        maxPayloadBytes,
+    };
+};

package/src/memory/payloadCodec.d.ts

@@ -0,0 +1,46 @@
+import { type PromisePayloadHandler, type Task } from "./lock.js";
+import type { LockBufferTextCompat } from "../common/shared-buffer-text.js";
+import { type PayloadBufferOptions } from "./payload-config.js";
+import type { SharedBufferSource } from "../common/shared-buffer-region.js";
+/**
+ * Returns `true` when the payload is encoded successfully.
+ * Returns `false` when dynamic payload space could not be reserved.
+ */
+export declare const encodePayload: ({ lockSector, payload, sab, payloadConfig, headersBuffer, headerSlotStrideU32, textCompat, onPromise, }: {
+    lockSector?: SharedBufferSource;
+    payload?: {
+        sab?: SharedBufferSource;
+        config?: PayloadBufferOptions;
+    };
+    /**
+     * @deprecated Use `payload.sab`.
+     */
+    sab?: SharedBufferSource;
+    /**
+     * @deprecated Use `payload.config`.
+     */
+    payloadConfig?: PayloadBufferOptions;
+    headersBuffer: Uint32Array;
+    headerSlotStrideU32?: number;
+    textCompat?: LockBufferTextCompat;
+    onPromise?: PromisePayloadHandler;
+}) => (task: Task, slotIndex: number) => boolean;
+export declare const decodePayload: ({ lockSector, payload, sab, payloadConfig, headersBuffer, headerSlotStrideU32, textCompat, host, }: {
+    lockSector?: SharedBufferSource;
+    payload?: {
+        sab?: SharedBufferSource;
+        config?: PayloadBufferOptions;
+    };
+    /**
+     * @deprecated Use `payload.sab`.
+     */
+    sab?: SharedBufferSource;
+    /**
+     * @deprecated Use `payload.config`.
+     */
+    payloadConfig?: PayloadBufferOptions;
+    headersBuffer: Uint32Array;
+    headerSlotStrideU32?: number;
+    textCompat?: LockBufferTextCompat;
+    host?: true;
+}) => (task: Task, slotIndex: number, specialFlags?: number) => void;