knitting 0.1.55 → 0.1.56

package/src/utils/http.d.ts

@@ -0,0 +1,29 @@
+export type BufferLike = ArrayBuffer | SharedArrayBuffer | ArrayBufferView;
+export type NumberFormat = "f64" | "f32" | "i32";
+export type NumberBufferOptions = {
+    format?: NumberFormat;
+};
+/** View ArrayBuffer/SharedArrayBuffer/typed-array bytes as Uint8Array. */
+export declare const bufferToBytes: (source: BufferLike) => Uint8Array;
+/** Copy bytes into a SharedArrayBuffer for zero-copy worker inputs. */
+export declare const bytesToBuffer: (source: BufferLike) => SharedArrayBuffer;
+/** Decode UTF-8 bytes from ArrayBuffer/SharedArrayBuffer/typed-array input. */
+export declare const bufferToString: (source: BufferLike) => string;
+/** Encode UTF-8 text into a SharedArrayBuffer. */
+export declare const stringToBuffer: (text: string) => SharedArrayBuffer;
+/** Decode JSON from UTF-8 bytes. */
+export declare const bufferToJson: <T = unknown>(source: BufferLike) => T;
+/** Encode JSON into a SharedArrayBuffer. */
+export declare const jsonToBuffer: (value: unknown) => SharedArrayBuffer;
+/** Encode numbers into a SharedArrayBuffer (`f64` by default). */
+export declare const numbersToBuffer: (numbers: ArrayLike<number>, options?: NumberBufferOptions) => SharedArrayBuffer;
+/** Decode numeric typed-array views from worker-friendly byte buffers. */
+export declare function bufferToNumbers(source: BufferLike, options?: {
+    format?: "f64";
+}): Float64Array;
+export declare function bufferToNumbers(source: BufferLike, options: {
+    format: "f32";
+}): Float32Array;
+export declare function bufferToNumbers(source: BufferLike, options: {
+    format: "i32";
+}): Int32Array;

package/src/utils/http.js

@@ -0,0 +1,100 @@
+const nodeBuffer = globalThis.Buffer;
+const hasNodeBuffer = typeof nodeBuffer?.from === "function" &&
+    typeof nodeBuffer?.byteLength === "function";
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const hasSharedArrayBuffer = typeof SharedArrayBuffer === "function";
+const isSharedArrayBuffer = (value) => hasSharedArrayBuffer && value instanceof SharedArrayBuffer;
+const BYTES_PER_ELEMENT = {
+    f64: 8,
+    f32: 4,
+    i32: 4,
+};
+const toBytes = (source) => {
+    if (source instanceof Uint8Array)
+        return source;
+    if (ArrayBuffer.isView(source)) {
+        return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    }
+    if (source instanceof ArrayBuffer || isSharedArrayBuffer(source)) {
+        return new Uint8Array(source);
+    }
+    throw new TypeError("Expected an ArrayBuffer, SharedArrayBuffer, or typed-array view.");
+};
+/** View ArrayBuffer/SharedArrayBuffer/typed-array bytes as Uint8Array. */
+export const bufferToBytes = (source) => toBytes(source);
+/** Copy bytes into a SharedArrayBuffer for zero-copy worker inputs. */
+export const bytesToBuffer = (source) => {
+    const bytes = toBytes(source);
+    const sab = new SharedArrayBuffer(bytes.byteLength);
+    new Uint8Array(sab).set(bytes);
+    return sab;
+};
+const makeNumberView = (format, buffer, byteOffset, length) => {
+    switch (format) {
+        case "f64":
+            return new Float64Array(buffer, byteOffset, length);
+        case "f32":
+            return new Float32Array(buffer, byteOffset, length);
+        case "i32":
+            return new Int32Array(buffer, byteOffset, length);
+    }
+};
+/** Decode UTF-8 bytes from ArrayBuffer/SharedArrayBuffer/typed-array input. */
+export const bufferToString = (source) => {
+    const bytes = toBytes(source);
+    if (hasNodeBuffer) {
+        return nodeBuffer
+            .from(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+            .toString("utf8");
+    }
+    return textDecoder.decode(bytes);
+};
+/** Encode UTF-8 text into a SharedArrayBuffer. */
+export const stringToBuffer = (text) => {
+    if (typeof text !== "string") {
+        throw new TypeError("stringToBuffer expects a string.");
+    }
+    if (hasNodeBuffer) {
+        const byteLength = nodeBuffer.byteLength(text, "utf8");
+        const sab = new SharedArrayBuffer(byteLength);
+        nodeBuffer.from(sab).write(text, "utf8");
+        return sab;
+    }
+    const encoded = textEncoder.encode(text);
+    const sab = new SharedArrayBuffer(encoded.byteLength);
+    new Uint8Array(sab).set(encoded);
+    return sab;
+};
+/** Decode JSON from UTF-8 bytes. */
+export const bufferToJson = (source) => JSON.parse(bufferToString(source));
+/** Encode JSON into a SharedArrayBuffer. */
+export const jsonToBuffer = (value) => {
+    const text = JSON.stringify(value);
+    if (typeof text !== "string") {
+        throw new TypeError("jsonToBuffer: value is not JSON-serializable (stringify returned undefined).");
+    }
+    return stringToBuffer(text);
+};
+/** Encode numbers into a SharedArrayBuffer (`f64` by default). */
+export const numbersToBuffer = (numbers, options) => {
+    const format = options?.format ?? "f64";
+    const sab = new SharedArrayBuffer(numbers.length * BYTES_PER_ELEMENT[format]);
+    makeNumberView(format, sab, 0, numbers.length).set(numbers);
+    return sab;
+};
+export function bufferToNumbers(source, options) {
+    const format = options?.format ?? "f64";
+    const bytesPer = BYTES_PER_ELEMENT[format];
+    const bytes = toBytes(source);
+    if (bytes.byteLength % bytesPer !== 0) {
+        throw new RangeError(`bufferToNumbers: byte length ${bytes.byteLength} is not a multiple of ` +
+            `${bytesPer} for format "${format}".`);
+    }
+    const length = bytes.byteLength / bytesPer;
+    if (bytes.byteOffset % bytesPer === 0) {
+        return makeNumberView(format, bytes.buffer, bytes.byteOffset, length);
+    }
+    const copy = bytes.slice();
+    return makeNumberView(format, copy.buffer, 0, length);
+}

package/src/worker/bootstrap.d.ts

@@ -0,0 +1,5 @@
+export declare const runWorkerBootstrap: ({ bootstrap, thread, totalNumberOfThread, }: {
+    bootstrap: unknown;
+    thread: number;
+    totalNumberOfThread: number;
+}) => Promise<void>;

package/src/worker/bootstrap.js

@@ -0,0 +1,78 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { RUNTIME } from "../common/runtime.js";
+import { toModuleUrl } from "../common/module-url.js";
+import { ProcessSharedBuffer } from "../connections/process-shared-buffer.js";
+const DEFAULT_BOOTSTRAP_EXPORT_NAME = "default";
+const isWorkerBootstrapOptions = (value) => {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return typeof candidate.href === "string" &&
+        candidate.href.length > 0 &&
+        (candidate.name === undefined ||
+            (typeof candidate.name === "string" && candidate.name.length > 0));
+};
+const isProcessSharedBufferMetadata = (value) => {
+    try {
+        ProcessSharedBuffer.fromMetadata(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const reviveWorkerBootstrapValue = (value, seen = new WeakMap()) => {
+    if (isProcessSharedBufferMetadata(value)) {
+        return ProcessSharedBuffer.fromMetadata(value);
+    }
+    if (value === null || typeof value !== "object")
+        return value;
+    const existing = seen.get(value);
+    if (existing !== undefined)
+        return existing;
+    if (Array.isArray(value)) {
+        const out = [];
+        seen.set(value, out);
+        for (const item of value) {
+            out.push(reviveWorkerBootstrapValue(item, seen));
+        }
+        return out;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return value;
+    const out = {};
+    seen.set(value, out);
+    for (const [key, item] of Object.entries(value)) {
+        out[key] = reviveWorkerBootstrapValue(item, seen);
+    }
+    return out;
+};
+export const runWorkerBootstrap = async ({ bootstrap, thread, totalNumberOfThread, }) => {
+    if (bootstrap === undefined)
+        return;
+    if (!isWorkerBootstrapOptions(bootstrap)) {
+        throw new TypeError("worker.bootstrap must include a non-empty href");
+    }
+    const module = await import(__rewriteRelativeImportExtension(toModuleUrl(bootstrap.href)));
+    const name = bootstrap.name ?? DEFAULT_BOOTSTRAP_EXPORT_NAME;
+    const selected = module[name];
+    if (typeof selected !== "function") {
+        const available = Object.keys(module).join(", ");
+        throw new TypeError(`worker.bootstrap expected export "${name}" from "${bootstrap.href}" to be a function.` +
+            ` Available exports: ${available || "(none)"}`);
+    }
+    const context = Object.freeze({
+        thread,
+        totalNumberOfThread,
+        runtime: RUNTIME,
+    });
+    await selected(reviveWorkerBootstrapValue(bootstrap.data), context);
+};

package/src/worker/composable-runners.d.ts

@@ -0,0 +1,12 @@
+import { type Task } from "../memory/lock.js";
+import type { TimeoutSpec } from "./task-loader.js";
+type WorkerJob = (args: unknown, abortToolkit?: unknown) => unknown;
+type SlotRunner = (slot: Task) => unknown;
+type HasAborted = (signal: number) => boolean;
+export declare const composeWorkerRunner: ({ job, timeout, hasAborted, now, }: {
+    job: WorkerJob;
+    timeout?: TimeoutSpec;
+    hasAborted?: HasAborted;
+    now?: () => number;
+}) => SlotRunner;
+export {};

package/src/worker/composable-runners.js

@@ -0,0 +1,97 @@
+import { getTaskFunctionMeta, getTaskSlotMeta, TASK_SLOT_META_VALUE_MASK, } from "../memory/lock.js";
+const ABORT_SIGNAL_META_OFFSET = 1;
+const TIMEOUT_KIND_RESOLVE = 1;
+const p_now = performance.now.bind(performance);
+const raceTimeout = (promise, ms, resolveOnTimeout, timeoutValue) => new Promise((resolve, reject) => {
+    let done = false;
+    const timer = setTimeout(() => {
+        if (done)
+            return;
+        done = true;
+        if (resolveOnTimeout)
+            resolve(timeoutValue);
+        else
+            reject(timeoutValue);
+    }, ms);
+    promise.then((value) => {
+        if (done)
+            return;
+        done = true;
+        clearTimeout(timer);
+        resolve(value);
+    }, (err) => {
+        if (done)
+            return;
+        done = true;
+        clearTimeout(timer);
+        reject(err);
+    });
+});
+const nowStamp = (now) => (Math.floor(now()) & TASK_SLOT_META_VALUE_MASK) >>> 0;
+const applyTimeoutBudget = (promise, slot, spec, now) => {
+    const elapsed = (nowStamp(now) - getTaskSlotMeta(slot)) & TASK_SLOT_META_VALUE_MASK;
+    const remaining = spec.ms - elapsed;
+    if (!(remaining > 0)) {
+        // Prevent late unhandled rejections from the original promise.
+        promise.then(() => { }, () => { });
+        return spec.kind === TIMEOUT_KIND_RESOLVE
+            ? Promise.resolve(spec.value)
+            : Promise.reject(spec.value);
+    }
+    const timeoutMs = Math.max(1, Math.floor(remaining));
+    return raceTimeout(promise, timeoutMs, spec.kind === TIMEOUT_KIND_RESOLVE, spec.value);
+};
+const NO_ABORT_SIGNAL = -1;
+const readSignal = (slot) => {
+    const encodedSignal = getTaskFunctionMeta(slot);
+    if (encodedSignal === 0)
+        return NO_ABORT_SIGNAL;
+    const signal = (encodedSignal - ABORT_SIGNAL_META_OFFSET) | 0;
+    return signal >= 0 ? signal : NO_ABORT_SIGNAL;
+};
+const makeToolkitCache = (hasAborted) => {
+    const bySignal = [];
+    return (signal) => {
+        let toolkit = bySignal[signal];
+        if (toolkit)
+            return toolkit;
+        const hasAbortedMethod = () => hasAborted(signal);
+        toolkit = {
+            hasAborted: hasAbortedMethod,
+        };
+        bySignal[signal] = toolkit;
+        return toolkit;
+    };
+};
+export const composeWorkerRunner = ({ job, timeout, hasAborted, now, }) => {
+    const nowTime = now ?? p_now;
+    if (!hasAborted) {
+        if (!timeout) {
+            return (slot) => job(slot.value);
+        }
+        return (slot) => {
+            const result = job(slot.value);
+            if (!(result instanceof Promise))
+                return result;
+            return applyTimeoutBudget(result, slot, timeout, nowTime);
+        };
+    }
+    const getToolkit = makeToolkitCache(hasAborted);
+    if (!timeout) {
+        return (slot) => {
+            const signal = readSignal(slot);
+            if (signal === NO_ABORT_SIGNAL)
+                return job(slot.value);
+            return job(slot.value, getToolkit(signal));
+        };
+    }
+    return (slot) => {
+        const signal = readSignal(slot);
+        const result = signal === NO_ABORT_SIGNAL
+            ? job(slot.value)
+            : job(slot.value, getToolkit(signal));
+        if (!(result instanceof Promise))
+            return result;
+        return applyTimeoutBudget(result, slot, timeout, nowTime);
+    };
+};

package/src/worker/loop.d.ts

@@ -0,0 +1,2 @@
+import type { WorkerData } from "../types.js";
+export declare const workerMainLoop: (startupData: WorkerData) => Promise<void>;