knitting 0.1.53 → 0.1.55

package/unsafe.d.ts

@@ -1 +1,71 @@
-export { BUFFER_REFERENCE_CODEC_ID, BUFFER_REFERENCE_KIND, BufferReference, type BufferReferenceMetadata, BufferReferenceReturn, type BufferReferenceRuntime, isBufferReferenceMetadata, } from "./src/connections/buffer-reference.js";
+export type BufferReferenceRuntime = "node" | "deno" | "bun";
+export declare const BUFFER_REFERENCE_KIND: "knitting.bufferReference";
+/** Named values for the `unsafe.BufferReferenceReturn` pool option. */
+export declare const BufferReferenceReturn: {
+	/** Safe default: Deno/Bun copy the returned bytes so they outlive the worker. */
+	readonly Copy: "copy";
+	/** Zero-copy: borrow the worker's backing store until the reference is released. */
+	readonly Borrow: "borrow";
+};
+export type BufferReferenceReturn = (typeof BufferReferenceReturn)[keyof typeof BufferReferenceReturn];
+declare const BUFFER_REFERENCE_NUMERIC_TRANSFER: unique symbol;
+declare const EXTERNAL_PAYLOAD_BRAND: unique symbol;
+export declare const BUFFER_REFERENCE_CODEC_ID: "knitting.bufferReference";
+type BufferReferenceNumericMetadata = readonly [
+	pointerLow: number,
+	pointerHigh: number,
+	tokenLow: number,
+	tokenHigh: number,
+	byteOffset: number,
+	byteLength: number,
+	runtime: number,
+	originPid: number
+];
+export type BufferReferenceMetadata = {
+	readonly kind: typeof BUFFER_REFERENCE_KIND;
+	readonly origin: string;
+	readonly runtime: BufferReferenceRuntime;
+	readonly pointer: string;
+	/** Producer-side release handle (process-local). */
+	readonly token: string;
+	readonly byteOffset: number;
+	readonly byteLength: number;
+};
+type BufferReferenceReturnReleaser = (token: bigint) => void;
+type BufferSource$1 = ArrayBufferView | ArrayBuffer;
+declare const PAYLOAD_TRANSPORT_FINALIZER: unique symbol;
+export declare const isBufferReferenceMetadata: (value: unknown) => value is BufferReferenceMetadata;
+/**
+ * Zero-copy handle for moving ArrayBuffer bytes to/from **thread** workers.
+ *
+ * Construction detaches the source. Consumers materialize the moved region in
+ * their isolate: owning on Node, alias/copy on Deno/Bun. Return a
+ * `BufferReference` for large binary results to avoid copying back through the
+ * transport. Use `ProcessSharedBuffer` across process boundaries.
+ */
+export declare class BufferReference {
+	#private;
+	readonly [EXTERNAL_PAYLOAD_BRAND]: "knitting.bufferReference";
+	readonly runtime: BufferReferenceRuntime;
+	readonly origin: string;
+	readonly pointer: bigint;
+	readonly byteOffset: number;
+	readonly byteLength: number;
+	constructor(source: BufferSource$1);
+	constructor(source: BufferSource$1 | undefined, meta: BufferReferenceMetadata);
+	static fromMetadata(meta: BufferReferenceMetadata): BufferReference;
+	toMetadata(): BufferReferenceMetadata;
+	[BUFFER_REFERENCE_NUMERIC_TRANSFER](): BufferReferenceNumericMetadata | undefined;
+	get isLocal(): boolean;
+	/** Prepare a returned reference before the worker-side producer hold drains. */
+	claimOwnership(releaser?: BufferReferenceReturnReleaser): this;
+	toArrayBuffer(): ArrayBuffer;
+	toUint8Array(): Uint8Array;
+	/** The source is moved on construction, so it is never retained here. */
+	get source(): undefined;
+	release(): void;
+	[Symbol.dispose](): void;
+	[PAYLOAD_TRANSPORT_FINALIZER](): (() => void) | undefined;
+}
+
+export {};