knitting 0.1.54 → 0.1.55

package/utils.d.ts

@@ -1 +1,31 @@
-export { type BufferLike, bufferToBytes, bufferToJson, bufferToNumbers, bufferToString, bytesToBuffer, jsonToBuffer, type NumberBufferOptions, type NumberFormat, numbersToBuffer, stringToBuffer, } from "./src/utils/http.js";
+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;
+
+export {};

package/utils.js

@@ -1 +1,116 @@
-export { bufferToBytes, bufferToJson, bufferToNumbers, bufferToString, bytesToBuffer, jsonToBuffer, numbersToBuffer, stringToBuffer, } from "./src/utils/http.js";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/utils/http.ts
+var nodeBuffer = globalThis.Buffer;
+var hasNodeBuffer = typeof nodeBuffer?.from === "function" && typeof nodeBuffer?.byteLength === "function";
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder;
+var hasSharedArrayBuffer = typeof SharedArrayBuffer === "function";
+var isSharedArrayBuffer = (value) => hasSharedArrayBuffer && value instanceof SharedArrayBuffer;
+var BYTES_PER_ELEMENT = {
+  f64: 8,
+  f32: 4,
+  i32: 4
+};
+var 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.");
+};
+var bufferToBytes = (source) => toBytes(source);
+var bytesToBuffer = (source) => {
+  const bytes = toBytes(source);
+  const sab = new SharedArrayBuffer(bytes.byteLength);
+  new Uint8Array(sab).set(bytes);
+  return sab;
+};
+var 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);
+  }
+};
+var bufferToString = (source) => {
+  const bytes = toBytes(source);
+  if (hasNodeBuffer) {
+    return nodeBuffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("utf8");
+  }
+  return textDecoder.decode(bytes);
+};
+var stringToBuffer = (text) => {
+  if (typeof text !== "string") {
+    throw new TypeError("stringToBuffer expects a string.");
+  }
+  if (hasNodeBuffer) {
+    const byteLength = nodeBuffer.byteLength(text, "utf8");
+    const sab2 = new SharedArrayBuffer(byteLength);
+    nodeBuffer.from(sab2).write(text, "utf8");
+    return sab2;
+  }
+  const encoded = textEncoder.encode(text);
+  const sab = new SharedArrayBuffer(encoded.byteLength);
+  new Uint8Array(sab).set(encoded);
+  return sab;
+};
+var bufferToJson = (source) => JSON.parse(bufferToString(source));
+var 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);
+};
+var 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;
+};
+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);
+}
+export {
+  stringToBuffer,
+  numbersToBuffer,
+  jsonToBuffer,
+  bytesToBuffer,
+  bufferToString,
+  bufferToNumbers,
+  bufferToJson,
+  bufferToBytes
+};

package/process-shared-buffer.d.ts

@@ -1 +0,0 @@
-export { getDefaultProcessSharedBufferPrimitives, parseProcessSharedBufferMetadata, PROCESS_SHARED_BUFFER_BRAND, ProcessSharedBuffer, setDefaultProcessSharedBufferPrimitives, type ProcessSharedBufferCreator, type ProcessSharedBufferMapper, type ProcessSharedBufferMetadata, type ProcessSharedBufferPrimitives, type ProcessSharedBufferRange, type ProcessSharedBufferView, type ProcessSharedBufferViewConstructor, } from "./src/connections/process-shared-buffer.js";

package/process-shared-buffer.js

@@ -1 +0,0 @@
-export { getDefaultProcessSharedBufferPrimitives, parseProcessSharedBufferMetadata, PROCESS_SHARED_BUFFER_BRAND, ProcessSharedBuffer, setDefaultProcessSharedBufferPrimitives, } from "./src/connections/process-shared-buffer.js";

package/src/api.d.ts

@@ -1,69 +0,0 @@
-import { endpointSymbol } from "./common/task-symbol.js";
-import type { AbortSignalConfig, AbortSignalOption, AbortSignalToolkit, Args, ComposedWithKey, CreatePool, FixPoint, ImportTaskOptions, MaybePromise, Pool, ReturnFixed, TaskInput, tasks, TaskTimeout } from "./types.js";
-type ToListAndIds = {
-    list: string[];
-    ids: number[];
-    names: string[];
-    at: number[];
-};
-type ToListAndIdsFn = (args: ComposedWithKey[]) => ToListAndIds;
-type CreatePoolFactory = (options: CreatePool) => <T extends tasks>(tasks: T) => Pool<T>;
-type InferredTaskFunction = (...args: any[]) => MaybePromise<Args>;
-type InferredTaskInput<F extends InferredTaskFunction, AS extends AbortSignalOption> = Parameters<F> extends [] ? void : AS extends undefined ? Parameters<F> extends [infer A] ? A extends TaskInput ? A : never : never : Parameters<F> extends [infer A] ? A extends TaskInput ? A : never : Parameters<F> extends [infer A, AbortSignalToolkit<AS>] ? A extends TaskInput ? A : never : never;
-type InferredTaskOutput<F extends InferredTaskFunction> = Awaited<ReturnType<F>> extends infer R ? R extends Blob ? never : R extends Args ? R : never : never;
-type InferredTaskShape<F extends InferredTaskFunction, AS extends AbortSignalOption> = [InferredTaskInput<F, AS>] extends [never] ? never : [InferredTaskOutput<F>] extends [never] ? never : {
-    readonly f: F;
-    readonly timeout?: TaskTimeout;
-} & (AS extends undefined ? {
-    readonly abortSignal?: undefined;
-} : {
-    readonly abortSignal: AS;
-});
-export declare const isMain: boolean;
-export { endpointSymbol as endpointSymbol };
-/**
- * Reconstructs stable task order from top-level exports before names are bound.
- */
-export declare const toListAndIds: ToListAndIdsFn;
-/**
- * Create a typed worker pool from module-scope exported tasks/functions.
- *
- * Install/import as `knitting` on npm or `@vixeny/knitting` on JSR. Requires
- * Node 22+, Deno 2+, or Bun 1+.
- *
- * Use `createPool(options)({ taskA })`, call `await pool.call.taskA(arg)`, and
- * clean up with `using pool = ...` or `await pool.shutdown()`.
- *
- * Guard host-only pool setup with `isMain`: workers re-import task modules, and
- * top-level imports in those modules run in every worker. Keep task modules
- * lean and separate from server/framework setup. Each task receives one
- * argument; use an object or tuple for multiple values.
- */
-export declare const createPool: CreatePoolFactory;
-/**
- * Define a worker task with options.
- *
- * Pass raw module-scope exported functions to `createPool` directly when you do
- * not need options. Use `task({ f })` for timeouts, abort signals, or the
- * single-task `.createPool()` shorthand.
- *
- * The function receives one argument; use a tuple/object for multiple values.
- * Inputs may be direct values or native Promises, so `request.arrayBuffer()` can
- * be forwarded without awaiting on the host.
- */
-export declare function task<F extends InferredTaskFunction>(I: InferredTaskShape<F, undefined>): ReturnFixed<InferredTaskInput<F, undefined>, InferredTaskOutput<F>, undefined>;
-export declare function task<F extends InferredTaskFunction>(I: InferredTaskShape<F, true>): ReturnFixed<InferredTaskInput<F, true>, InferredTaskOutput<F>, true>;
-export declare function task<AS extends AbortSignalConfig, F extends InferredTaskFunction>(I: InferredTaskShape<F, AS>): ReturnFixed<InferredTaskInput<F, AS>, InferredTaskOutput<F>, AS>;
-export declare function task<A extends TaskInput = void, B extends Args = void>(I: FixPoint<A, B, true>): ReturnFixed<A, B, true>;
-export declare function task<A extends TaskInput = void, B extends Args = void, AS extends AbortSignalConfig = AbortSignalConfig>(I: FixPoint<A, B, AS>): ReturnFixed<A, B, AS>;
-export declare function task<A extends TaskInput = void, B extends Args = void>(I: FixPoint<A, B, undefined>): ReturnFixed<A, B, undefined>;
-/**
- * Define a task whose worker-side code is imported only by workers.
- *
- * Use this for untrusted or security-sensitive code: the host keeps a typed
- * wrapper and does not import/evaluate `href`. The target export must be a
- * plain function, not a `task()` wrapper.
- */
-export declare function importTask<A extends TaskInput = void, B extends Args = void>(options: ImportTaskOptions<A, B, true>): ReturnFixed<A, B, true>;
-export declare function importTask<A extends TaskInput = void, B extends Args = void, AS extends AbortSignalConfig = AbortSignalConfig>(options: ImportTaskOptions<A, B, AS>): ReturnFixed<A, B, AS>;
-export declare function importTask<A extends TaskInput = void, B extends Args = void>(options: ImportTaskOptions<A, B, undefined>): ReturnFixed<A, B, undefined>;