@ricsam/isolate 0.0.1 → 0.1.1

package/dist/mjs/internal/protocol/framing.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/protocol/framing.ts"],
+  "sourcesContent": [
+    "/**\n * Frame parser and builder for the isolate protocol.\n *\n * Frame format:\n * ┌──────────┬──────────┬─────────────────┐\n * │ Length   │ Type     │ Payload         │\n * │ (4 bytes)│ (1 byte) │ (MessagePack)   │\n * └──────────┴──────────┴─────────────────┘\n *\n * - Length: uint32 BE, size of Type + Payload (excludes the length field itself)\n * - Type: uint8, message type from MessageType enum\n * - Payload: MessagePack encoded message body\n */\n\nimport { MessageType, MessageTypeName, type Message } from \"./types.mjs\";\nimport { encodeMessage, decodeMessage } from \"./codec.mjs\";\n\n/** Header size: 4 bytes for length + 1 byte for type */\nexport const HEADER_SIZE = 5;\n\n/** Maximum frame size (10MB) */\nexport const MAX_FRAME_SIZE = 10 * 1024 * 1024;\n\n/** Threshold above which bodies should be streamed (1MB) */\nexport const STREAM_THRESHOLD = 1 * 1024 * 1024;\n\n/** Default chunk size for streaming (256KB) */\nexport const STREAM_CHUNK_SIZE = 256 * 1024;\n\n/** Default credit for backpressure (1MB) */\nexport const STREAM_DEFAULT_CREDIT = 1 * 1024 * 1024;\n\n// ============================================================================\n// Frame Building\n// ============================================================================\n\n/**\n * Build a frame from a message.\n *\n * @param message - The message to encode\n * @returns Complete frame as Uint8Array\n */\nexport function buildFrame(message: Message): Uint8Array {\n  // Encode the message payload (without the type field for the payload)\n  const payloadWithoutType = { ...message };\n  delete (payloadWithoutType as Record<string, unknown>).type;\n\n  const payload = encodeMessage(payloadWithoutType as Message);\n  const messageType = message.type;\n\n  // Total size: 1 byte type + payload length\n  const frameBodySize = 1 + payload.length;\n\n  // Build frame: 4 bytes length + 1 byte type + payload\n  const frame = new Uint8Array(4 + frameBodySize);\n  const view = new DataView(frame.buffer);\n\n  // Write length (big-endian)\n  view.setUint32(0, frameBodySize, false);\n\n  // Write message type\n  frame[4] = messageType;\n\n  // Write payload\n  frame.set(payload, 5);\n\n  return frame;\n}\n\n/**\n * Build multiple frames from messages.\n *\n * @param messages - Messages to encode\n * @returns Combined frames as single Uint8Array\n */\nexport function buildFrames(messages: Message[]): Uint8Array {\n  const frames = messages.map(buildFrame);\n  const totalLength = frames.reduce((sum, f) => sum + f.length, 0);\n\n  const combined = new Uint8Array(totalLength);\n  let offset = 0;\n\n  for (const frame of frames) {\n    combined.set(frame, offset);\n    offset += frame.length;\n  }\n\n  return combined;\n}\n\n// ============================================================================\n// Frame Parsing\n// ============================================================================\n\n/**\n * Parse result from the frame parser.\n */\nexport interface ParsedFrame {\n  type: MessageType;\n  message: Message;\n}\n\n/**\n * Incremental frame parser for streaming data.\n *\n * Usage:\n * ```ts\n * const parser = createFrameParser();\n * socket.on('data', (chunk) => {\n *   for (const frame of parser.feed(chunk)) {\n *     handleMessage(frame.message);\n *   }\n * });\n * ```\n */\nexport interface FrameParser {\n  /**\n   * Feed data to the parser and yield complete frames.\n   * @param chunk - Incoming data chunk\n   */\n  feed(chunk: Uint8Array): Generator<ParsedFrame>;\n\n  /**\n   * Get the number of bytes currently buffered.\n   */\n  bufferedBytes(): number;\n\n  /**\n   * Reset the parser state.\n   */\n  reset(): void;\n}\n\n/**\n * Create a new frame parser.\n */\nexport function createFrameParser(): FrameParser {\n  let buffer: Uint8Array = new Uint8Array(0);\n\n  function* feed(chunk: Uint8Array): Generator<ParsedFrame> {\n    // Append chunk to buffer\n    const newBuffer = new Uint8Array(buffer.length + chunk.length);\n    newBuffer.set(buffer);\n    newBuffer.set(chunk, buffer.length);\n    buffer = newBuffer;\n\n    // Try to parse frames\n    while (buffer.length >= 4) {\n      // Read length\n      const view = new DataView(\n        buffer.buffer,\n        buffer.byteOffset,\n        buffer.byteLength\n      );\n      const frameBodySize = view.getUint32(0, false);\n\n      // Validate frame size\n      if (frameBodySize > MAX_FRAME_SIZE) {\n        throw new Error(\n          `Frame size ${frameBodySize} exceeds maximum ${MAX_FRAME_SIZE}`\n        );\n      }\n\n      // Check if we have the complete frame\n      const totalFrameSize = 4 + frameBodySize;\n      if (buffer.length < totalFrameSize) {\n        break; // Wait for more data\n      }\n\n      // Extract frame\n      const messageType = buffer[4] as MessageType;\n      const payload = buffer.slice(5, totalFrameSize);\n\n      // Decode payload\n      const decodedPayload = decodeMessage(payload);\n      const message = { ...decodedPayload, type: messageType } as Message;\n\n      yield { type: messageType, message };\n\n      // Remove processed frame from buffer\n      buffer = buffer.slice(totalFrameSize);\n    }\n  }\n\n  function bufferedBytes(): number {\n    return buffer.length;\n  }\n\n  function reset(): void {\n    buffer = new Uint8Array(0);\n  }\n\n  return { feed, bufferedBytes, reset };\n}\n\n// ============================================================================\n// Single Frame Parsing (for testing/debugging)\n// ============================================================================\n\n/**\n * Parse a single complete frame.\n *\n * @param data - Complete frame data\n * @returns Parsed frame or null if incomplete\n * @throws Error if frame is invalid\n */\nexport function parseFrame(data: Uint8Array): ParsedFrame | null {\n  if (data.length < 4) {\n    return null;\n  }\n\n  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n  const frameBodySize = view.getUint32(0, false);\n\n  if (frameBodySize > MAX_FRAME_SIZE) {\n    throw new Error(\n      `Frame size ${frameBodySize} exceeds maximum ${MAX_FRAME_SIZE}`\n    );\n  }\n\n  const totalFrameSize = 4 + frameBodySize;\n  if (data.length < totalFrameSize) {\n    return null;\n  }\n\n  const messageType = data[4] as MessageType;\n  const payload = data.slice(5, totalFrameSize);\n\n  const decodedPayload = decodeMessage(payload);\n  const message = { ...decodedPayload, type: messageType } as Message;\n\n  return { type: messageType, message };\n}\n\n/**\n * Get the message type name for debugging.\n */\nexport function getMessageTypeName(type: MessageType): string {\n  return MessageTypeName[type] ?? `Unknown(${type})`;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "0159BD96C0953E1264756E2164756E21",
+  "names": []
+}

package/dist/mjs/internal/protocol/index.mjs

@@ -0,0 +1,98 @@
+// src/internal/protocol/index.ts
+export * from "./types.mjs";
+import {
+  encodeMessage,
+  decodeMessage,
+  encodeValue,
+  decodeValue,
+  createIsolateRef,
+  createCallbackRef,
+  createStreamRef,
+  createErrorRef,
+  createBlobRef,
+  createDateRef,
+  createRegExpRef,
+  createUndefinedRef,
+  createBigIntRef,
+  createRequestRef,
+  createResponseRef,
+  createHeadersRef,
+  createFileRef,
+  createFormDataRef,
+  createURLRef,
+  createPromiseRef,
+  createAsyncIteratorRef,
+  ExtType
+} from "./codec.mjs";
+import {
+  marshalValue,
+  marshalValueSync,
+  unmarshalValue,
+  MarshalError,
+  isPromiseRef,
+  isAsyncIteratorRef
+} from "./marshalValue.mjs";
+import {
+  serializeRequest,
+  serializeResponse,
+  deserializeRequest,
+  deserializeResponse
+} from "./serialization.mjs";
+import {
+  buildFrame,
+  buildFrames,
+  createFrameParser,
+  parseFrame,
+  getMessageTypeName,
+  HEADER_SIZE,
+  MAX_FRAME_SIZE,
+  STREAM_THRESHOLD,
+  STREAM_CHUNK_SIZE,
+  STREAM_DEFAULT_CREDIT
+} from "./framing.mjs";
+export {
+  unmarshalValue,
+  serializeResponse,
+  serializeRequest,
+  parseFrame,
+  marshalValueSync,
+  marshalValue,
+  isPromiseRef,
+  isAsyncIteratorRef,
+  getMessageTypeName,
+  encodeValue,
+  encodeMessage,
+  deserializeResponse,
+  deserializeRequest,
+  decodeValue,
+  decodeMessage,
+  createUndefinedRef,
+  createURLRef,
+  createStreamRef,
+  createResponseRef,
+  createRequestRef,
+  createRegExpRef,
+  createPromiseRef,
+  createIsolateRef,
+  createHeadersRef,
+  createFrameParser,
+  createFormDataRef,
+  createFileRef,
+  createErrorRef,
+  createDateRef,
+  createCallbackRef,
+  createBlobRef,
+  createBigIntRef,
+  createAsyncIteratorRef,
+  buildFrames,
+  buildFrame,
+  STREAM_THRESHOLD,
+  STREAM_DEFAULT_CREDIT,
+  STREAM_CHUNK_SIZE,
+  MarshalError,
+  MAX_FRAME_SIZE,
+  HEADER_SIZE,
+  ExtType
+};
+
+//# debugId=856F6F1774D4093364756E2164756E21

package/dist/mjs/internal/protocol/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/protocol/index.ts"],
+  "sourcesContent": [
+    "/**\n * ./index.ts\n *\n * Protocol definitions, codec, and framing for the isolate daemon.\n */\n\n// Types and utilities\nexport * from \"./types.mjs\";\n\n// Codec\nexport {\n  encodeMessage,\n  decodeMessage,\n  encodeValue,\n  decodeValue,\n  createIsolateRef,\n  createCallbackRef,\n  createStreamRef,\n  createErrorRef,\n  createBlobRef,\n  createDateRef,\n  createRegExpRef,\n  createUndefinedRef,\n  createBigIntRef,\n  createRequestRef,\n  createResponseRef,\n  createHeadersRef,\n  createFileRef,\n  createFormDataRef,\n  createURLRef,\n  createPromiseRef,\n  createAsyncIteratorRef,\n  ExtType,\n  type IsolateRef,\n  type CallbackRef,\n  type StreamRef,\n  type ErrorRef,\n  type BlobRef,\n  type DateRef,\n  type RegExpRef,\n  type UndefinedRef,\n  type BigIntRef,\n  type RequestRef,\n  type ResponseRef,\n  type HeadersRef,\n  type FileRef,\n  type FormDataRef,\n  type URLRef,\n  type PromiseRef,\n  type AsyncIteratorRef,\n  type ExtensionType,\n} from \"./codec.mjs\";\n\n// Value marshalling\nexport {\n  marshalValue,\n  marshalValueSync,\n  unmarshalValue,\n  MarshalError,\n  isPromiseRef,\n  isAsyncIteratorRef,\n  type MarshalContext,\n  type UnmarshalContext,\n} from \"./marshalValue.mjs\";\n\n// Request/Response serialization\nexport {\n  serializeRequest,\n  serializeResponse,\n  deserializeRequest,\n  deserializeResponse,\n} from \"./serialization.mjs\";\n\n// Framing\nexport {\n  buildFrame,\n  buildFrames,\n  createFrameParser,\n  parseFrame,\n  getMessageTypeName,\n  HEADER_SIZE,\n  MAX_FRAME_SIZE,\n  STREAM_THRESHOLD,\n  STREAM_CHUNK_SIZE,\n  STREAM_DEFAULT_CREDIT,\n  type ParsedFrame,\n  type FrameParser,\n} from \"./framing.mjs\";\n"
+  ],
+  "mappings": ";AAOA;AAGA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4CA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "debugId": "856F6F1774D4093364756E2164756E21",
+  "names": []
+}

package/dist/mjs/internal/protocol/marshalValue.mjs

@@ -0,0 +1,494 @@
+// src/internal/protocol/marshalValue.ts
+import {
+  createCallbackRef,
+  createDateRef,
+  createRegExpRef,
+  createUndefinedRef,
+  createBigIntRef,
+  createUint8ArrayRef,
+  createRequestRef,
+  createResponseRef,
+  createHeadersRef,
+  createFileRef,
+  createFormDataRef,
+  createURLRef,
+  createPromiseRef,
+  createAsyncIteratorRef,
+  createBlobRef
+} from "./codec.mjs";
+
+class MarshalError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MarshalError";
+  }
+}
+function isPromiseRef(value) {
+  return typeof value === "object" && value !== null && value.__type === "PromiseRef";
+}
+function isAsyncIteratorRef(value) {
+  return typeof value === "object" && value !== null && value.__type === "AsyncIteratorRef";
+}
+var SUPPORTED_CLASSES = new Set([
+  "Date",
+  "RegExp",
+  "Request",
+  "Response",
+  "Headers",
+  "File",
+  "Blob",
+  "FormData",
+  "URL",
+  "Uint8Array",
+  "Int8Array",
+  "Uint16Array",
+  "Int16Array",
+  "Uint32Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "ArrayBuffer",
+  "DataView"
+]);
+function isTypedArray(value) {
+  return value instanceof Uint8Array || value instanceof Int8Array || value instanceof Uint16Array || value instanceof Int16Array || value instanceof Uint32Array || value instanceof Int32Array || value instanceof Float32Array || value instanceof Float64Array || value instanceof BigInt64Array || value instanceof BigUint64Array || value instanceof DataView;
+}
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+var MAX_DEPTH = 100;
+async function marshalValue(value, ctx, depth = 0, seen = new WeakSet) {
+  if (depth > MAX_DEPTH) {
+    throw new MarshalError(`Maximum marshalling depth (${MAX_DEPTH}) exceeded. Possible circular reference.`);
+  }
+  if (value === null) {
+    return null;
+  }
+  if (value === undefined) {
+    return createUndefinedRef();
+  }
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean") {
+    return value;
+  }
+  if (type === "bigint") {
+    return createBigIntRef(value.toString());
+  }
+  if (type === "function") {
+    if (!ctx?.registerCallback) {
+      throw new MarshalError("Cannot marshal function: no registerCallback provided in context");
+    }
+    const callbackId = ctx.registerCallback(value);
+    return createCallbackRef(callbackId);
+  }
+  if (type === "object") {
+    const obj = value;
+    if (seen.has(obj)) {
+      throw new MarshalError("Cannot marshal value: circular reference detected");
+    }
+    if (obj instanceof Date) {
+      return createDateRef(obj.getTime());
+    }
+    if (obj instanceof RegExp) {
+      return createRegExpRef(obj.source, obj.flags);
+    }
+    if (obj instanceof URL) {
+      return createURLRef(obj.href);
+    }
+    if (typeof Headers !== "undefined" && obj instanceof Headers) {
+      const pairs = [];
+      obj.forEach((value2, key) => {
+        pairs.push([key, value2]);
+      });
+      return createHeadersRef(pairs);
+    }
+    if (obj instanceof Uint8Array) {
+      return createUint8ArrayRef(Array.from(obj));
+    }
+    if (obj instanceof ArrayBuffer) {
+      return createUint8ArrayRef(Array.from(new Uint8Array(obj)));
+    }
+    if (isTypedArray(obj)) {
+      const u8 = new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength);
+      return createUint8ArrayRef(Array.from(u8));
+    }
+    if (obj instanceof Promise) {
+      if (!ctx?.registerPromise) {
+        throw new MarshalError("Cannot marshal Promise: no registerPromise provided in context");
+      }
+      const promiseId = ctx.registerPromise(obj);
+      return createPromiseRef(promiseId);
+    }
+    if (isAsyncIterable(obj)) {
+      if (!ctx?.registerIterator) {
+        throw new MarshalError("Cannot marshal AsyncIterable: no registerIterator provided in context");
+      }
+      const iterator = obj[Symbol.asyncIterator]();
+      const iteratorId = ctx.registerIterator(iterator);
+      return createAsyncIteratorRef(iteratorId);
+    }
+    seen.add(obj);
+    if (typeof Request !== "undefined" && obj instanceof Request) {
+      const req = obj;
+      const headers = [];
+      req.headers.forEach((value2, key) => {
+        headers.push([key, value2]);
+      });
+      let body = null;
+      if (req.body) {
+        const cloned = req.clone();
+        body = Array.from(new Uint8Array(await cloned.arrayBuffer()));
+      }
+      return createRequestRef(req.url, req.method, headers, body, {
+        mode: req.mode,
+        credentials: req.credentials,
+        cache: req.cache,
+        redirect: req.redirect,
+        referrer: req.referrer,
+        referrerPolicy: req.referrerPolicy,
+        integrity: req.integrity
+      });
+    }
+    if (typeof Response !== "undefined" && obj instanceof Response) {
+      const res = obj;
+      const headers = [];
+      res.headers.forEach((value2, key) => {
+        headers.push([key, value2]);
+      });
+      let body = null;
+      if (res.body) {
+        const cloned = res.clone();
+        body = Array.from(new Uint8Array(await cloned.arrayBuffer()));
+      }
+      return createResponseRef(res.status, res.statusText, headers, body);
+    }
+    if (typeof File !== "undefined" && obj instanceof File) {
+      const file = obj;
+      const data = Array.from(new Uint8Array(await file.arrayBuffer()));
+      return createFileRef(file.name, file.type, file.lastModified, data);
+    }
+    if (typeof Blob !== "undefined" && obj instanceof Blob) {
+      const blob = obj;
+      if (ctx?.registerBlob) {
+        const blobId = ctx.registerBlob(blob);
+        return createBlobRef(blobId, blob.size, blob.type);
+      }
+      const data = Array.from(new Uint8Array(await blob.arrayBuffer()));
+      return createFileRef("", blob.type, Date.now(), data);
+    }
+    if (typeof FormData !== "undefined" && obj instanceof FormData) {
+      const fd = obj;
+      const entries = [];
+      for (const [key, value2] of fd.entries()) {
+        if (typeof value2 === "string") {
+          entries.push([key, value2]);
+        } else {
+          const file = value2;
+          const data = Array.from(new Uint8Array(await file.arrayBuffer()));
+          const fileRef = createFileRef(file.name ?? "", file.type, file.lastModified ?? Date.now(), data);
+          entries.push([key, fileRef]);
+        }
+      }
+      return createFormDataRef(entries);
+    }
+    if (Array.isArray(obj)) {
+      const result2 = [];
+      for (const item of obj) {
+        result2.push(await marshalValue(item, ctx, depth + 1, seen));
+      }
+      return result2;
+    }
+    const constructorName = obj.constructor?.name;
+    if (constructorName && constructorName !== "Object") {
+      if (!SUPPORTED_CLASSES.has(constructorName)) {
+        throw new MarshalError(`Cannot marshal class instance of type "${constructorName}". ` + `Only plain objects and supported classes are allowed.`);
+      }
+    }
+    const result = {};
+    for (const key of Object.keys(obj)) {
+      result[key] = await marshalValue(obj[key], ctx, depth + 1, seen);
+    }
+    return result;
+  }
+  if (type === "symbol") {
+    throw new MarshalError("Cannot marshal Symbol values");
+  }
+  throw new MarshalError(`Cannot marshal value of type "${type}"`);
+}
+function marshalValueSync(value, ctx, depth = 0, seen = new WeakSet) {
+  if (depth > MAX_DEPTH) {
+    throw new MarshalError(`Maximum marshalling depth (${MAX_DEPTH}) exceeded. Possible circular reference.`);
+  }
+  if (value === null) {
+    return null;
+  }
+  if (value === undefined) {
+    return createUndefinedRef();
+  }
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean") {
+    return value;
+  }
+  if (type === "bigint") {
+    return createBigIntRef(value.toString());
+  }
+  if (type === "function") {
+    if (!ctx?.registerCallback) {
+      throw new MarshalError("Cannot marshal function: no registerCallback provided in context");
+    }
+    const callbackId = ctx.registerCallback(value);
+    return createCallbackRef(callbackId);
+  }
+  if (type === "object") {
+    const obj = value;
+    if (seen.has(obj)) {
+      throw new MarshalError("Cannot marshal value: circular reference detected");
+    }
+    if (obj instanceof Date) {
+      return createDateRef(obj.getTime());
+    }
+    if (obj instanceof RegExp) {
+      return createRegExpRef(obj.source, obj.flags);
+    }
+    if (obj instanceof URL) {
+      return createURLRef(obj.href);
+    }
+    if (typeof Headers !== "undefined" && obj instanceof Headers) {
+      const pairs = [];
+      obj.forEach((value2, key) => {
+        pairs.push([key, value2]);
+      });
+      return createHeadersRef(pairs);
+    }
+    if (obj instanceof Uint8Array) {
+      return createUint8ArrayRef(Array.from(obj));
+    }
+    if (obj instanceof ArrayBuffer) {
+      return createUint8ArrayRef(Array.from(new Uint8Array(obj)));
+    }
+    if (isTypedArray(obj)) {
+      const u8 = new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength);
+      return createUint8ArrayRef(Array.from(u8));
+    }
+    if (obj instanceof Promise) {
+      if (!ctx?.registerPromise) {
+        throw new MarshalError("Cannot marshal Promise: no registerPromise provided in context");
+      }
+      const promiseId = ctx.registerPromise(obj);
+      return createPromiseRef(promiseId);
+    }
+    if (isAsyncIterable(obj)) {
+      if (!ctx?.registerIterator) {
+        throw new MarshalError("Cannot marshal AsyncIterable: no registerIterator provided in context");
+      }
+      const iterator = obj[Symbol.asyncIterator]();
+      const iteratorId = ctx.registerIterator(iterator);
+      return createAsyncIteratorRef(iteratorId);
+    }
+    seen.add(obj);
+    if (typeof Request !== "undefined" && obj instanceof Request) {
+      throw new MarshalError("Cannot marshal Request synchronously. Use marshalValue() instead.");
+    }
+    if (typeof Response !== "undefined" && obj instanceof Response) {
+      throw new MarshalError("Cannot marshal Response synchronously. Use marshalValue() instead.");
+    }
+    if (typeof File !== "undefined" && obj instanceof File) {
+      throw new MarshalError("Cannot marshal File synchronously. Use marshalValue() instead.");
+    }
+    if (typeof Blob !== "undefined" && obj instanceof Blob) {
+      throw new MarshalError("Cannot marshal Blob synchronously. Use marshalValue() instead.");
+    }
+    if (typeof FormData !== "undefined" && obj instanceof FormData) {
+      throw new MarshalError("Cannot marshal FormData synchronously. Use marshalValue() instead.");
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => marshalValueSync(item, ctx, depth + 1, seen));
+    }
+    const constructorName = obj.constructor?.name;
+    if (constructorName && constructorName !== "Object") {
+      if (!SUPPORTED_CLASSES.has(constructorName)) {
+        throw new MarshalError(`Cannot marshal class instance of type "${constructorName}". ` + `Only plain objects and supported classes are allowed.`);
+      }
+    }
+    const result = {};
+    for (const key of Object.keys(obj)) {
+      result[key] = marshalValueSync(obj[key], ctx, depth + 1, seen);
+    }
+    return result;
+  }
+  if (type === "symbol") {
+    throw new MarshalError("Cannot marshal Symbol values");
+  }
+  throw new MarshalError(`Cannot marshal value of type "${type}"`);
+}
+function isRef(value) {
+  return typeof value === "object" && value !== null && "__type" in value && typeof value.__type === "string";
+}
+function unmarshalValue(value, ctx, depth = 0) {
+  if (depth > MAX_DEPTH) {
+    throw new MarshalError(`Maximum unmarshalling depth (${MAX_DEPTH}) exceeded.`);
+  }
+  if (value === null) {
+    return null;
+  }
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean") {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (type === "object") {
+    if (isRef(value)) {
+      const refType = value.__type;
+      switch (refType) {
+        case "UndefinedRef":
+          return;
+        case "DateRef": {
+          const ref = value;
+          return new Date(ref.timestamp);
+        }
+        case "RegExpRef": {
+          const ref = value;
+          return new RegExp(ref.source, ref.flags);
+        }
+        case "BigIntRef": {
+          const ref = value;
+          return BigInt(ref.value);
+        }
+        case "Uint8ArrayRef": {
+          const ref = value;
+          return new Uint8Array(ref.data);
+        }
+        case "URLRef": {
+          const ref = value;
+          return new URL(ref.href);
+        }
+        case "HeadersRef": {
+          const ref = value;
+          return new Headers(ref.pairs);
+        }
+        case "RequestRef": {
+          const ref = value;
+          const body = ref.body ? new Uint8Array(ref.body) : null;
+          const init = {
+            method: ref.method,
+            headers: ref.headers,
+            body
+          };
+          if (ref.mode)
+            init.mode = ref.mode;
+          if (ref.credentials)
+            init.credentials = ref.credentials;
+          if (ref.cache)
+            init.cache = ref.cache;
+          if (ref.redirect)
+            init.redirect = ref.redirect;
+          if (ref.referrer)
+            init.referrer = ref.referrer;
+          if (ref.referrerPolicy)
+            init.referrerPolicy = ref.referrerPolicy;
+          if (ref.integrity)
+            init.integrity = ref.integrity;
+          return new Request(ref.url, init);
+        }
+        case "ResponseRef": {
+          const ref = value;
+          const body = ref.body ? new Uint8Array(ref.body) : null;
+          return new Response(body, {
+            status: ref.status,
+            statusText: ref.statusText,
+            headers: ref.headers
+          });
+        }
+        case "FileRef": {
+          const ref = value;
+          const data = new Uint8Array(ref.data);
+          if (!ref.name) {
+            return new Blob([data], { type: ref.type });
+          }
+          return new File([data], ref.name, {
+            type: ref.type,
+            lastModified: ref.lastModified
+          });
+        }
+        case "BlobRef": {
+          const ref = value;
+          if (ctx?.getBlob) {
+            const blob = ctx.getBlob(ref.blobId);
+            if (blob)
+              return blob;
+          }
+          throw new MarshalError(`Cannot unmarshal BlobRef: no getBlob provided or blob not found`);
+        }
+        case "FormDataRef": {
+          const ref = value;
+          const fd = new FormData;
+          for (const [key, entry] of ref.entries) {
+            if (typeof entry === "string") {
+              fd.append(key, entry);
+            } else {
+              const file = unmarshalValue(entry, ctx, depth + 1);
+              fd.append(key, file);
+            }
+          }
+          return fd;
+        }
+        case "CallbackRef": {
+          const ref = value;
+          if (!ctx?.getCallback) {
+            throw new MarshalError(`Cannot unmarshal CallbackRef: no getCallback provided`);
+          }
+          const callback = ctx.getCallback(ref.callbackId);
+          if (!callback) {
+            throw new MarshalError(`Cannot unmarshal CallbackRef: callback ${ref.callbackId} not found`);
+          }
+          return callback;
+        }
+        case "PromiseRef": {
+          const ref = value;
+          if (!ctx?.createPromiseProxy) {
+            throw new MarshalError(`Cannot unmarshal PromiseRef: no createPromiseProxy provided`);
+          }
+          return ctx.createPromiseProxy(ref.promiseId);
+        }
+        case "AsyncIteratorRef": {
+          const ref = value;
+          if (!ctx?.createIteratorProxy) {
+            throw new MarshalError(`Cannot unmarshal AsyncIteratorRef: no createIteratorProxy provided`);
+          }
+          const iterator = ctx.createIteratorProxy(ref.iteratorId);
+          return {
+            [Symbol.asyncIterator]() {
+              return iterator;
+            }
+          };
+        }
+        default:
+          return value;
+      }
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => unmarshalValue(item, ctx, depth + 1));
+    }
+    const obj = value;
+    const result = {};
+    for (const key of Object.keys(obj)) {
+      result[key] = unmarshalValue(obj[key], ctx, depth + 1);
+    }
+    return result;
+  }
+  return value;
+}
+export {
+  unmarshalValue,
+  marshalValueSync,
+  marshalValue,
+  isPromiseRef,
+  isAsyncIteratorRef,
+  MarshalError
+};
+
+//# debugId=EB3F328D0F10369764756E2164756E21