@lostgradient/weft 0.2.0

package/dist/core/checkpoint/comparison.js

@@ -0,0 +1,137 @@
+export function compareValues(original, deserialized, path, divergences) {
+  if (original === deserialized)
+    return;
+  comparisonHandlers.find((candidate) => candidate.matches(original, deserialized))?.compare(original, deserialized, path, divergences);
+}
+function checkpointPath(path) {
+  return path || "(root)";
+}
+function recordDivergence(divergences, path, original, deserialized, suggestion) {
+  divergences.push({
+    path: checkpointPath(path),
+    original,
+    deserialized,
+    suggestion
+  });
+}
+function compareNullishValues(original, deserialized, path, divergences) {
+  recordDivergence(divergences, path, original, deserialized, "Value changed during serialization round-trip.");
+}
+function compareDateValues(original, deserialized, path, divergences) {
+  if (original.getTime() !== deserialized.getTime())
+    recordDivergence(divergences, path, original, deserialized, "Date value changed during round-trip.");
+}
+function compareRegExpValues(original, deserialized, path, divergences) {
+  if (original.source !== deserialized.source || original.flags !== deserialized.flags)
+    recordDivergence(divergences, path, original, deserialized, "RegExp value changed during round-trip.");
+}
+function compareMapValues(original, deserialized, path, divergences) {
+  for (const [key] of original) {
+    const keyPath = path ? `${path}.Map(${String(key)})` : `Map(${String(key)})`;
+    if (!deserialized.has(key)) {
+      recordDivergence(divergences, keyPath, original.get(key), void 0, "Map key missing after round-trip.");
+      continue;
+    }
+    compareValues(original.get(key), deserialized.get(key), keyPath, divergences);
+  }
+  for (const [key] of deserialized) {
+    if (original.has(key))
+      continue;
+    const keyPath = path ? `${path}.Map(${String(key)})` : `Map(${String(key)})`;
+    recordDivergence(divergences, keyPath, void 0, deserialized.get(key), "Extra Map key appeared after round-trip.");
+  }
+}
+function compareSetValues(original, deserialized, path, divergences) {
+  const originalValues = [...original.values()], deserializedValues = [...deserialized.values()];
+  if (originalValues.length !== deserializedValues.length) {
+    recordDivergence(divergences, path, original, deserialized, "Set size changed during round-trip.");
+    return;
+  }
+  for (let index = 0;index < originalValues.length; index++) {
+    const elementPath = path ? `${path}.Set[${index}]` : `Set[${index}]`;
+    compareValues(originalValues[index], deserializedValues[index], elementPath, divergences);
+  }
+}
+function compareTypeMismatch(original, deserialized, path, divergences) {
+  recordDivergence(divergences, path, original, deserialized, `Type changed from ${typeof original} to ${typeof deserialized} during round-trip.`);
+}
+function comparePrimitiveValues(original, deserialized, path, divergences) {
+  recordDivergence(divergences, path, original, deserialized, "Primitive value changed during round-trip.");
+}
+function compareArrayValues(original, deserialized, path, divergences) {
+  const maxLength = Math.max(original.length, deserialized.length);
+  for (let index = 0;index < maxLength; index++) {
+    const elementPath = path ? `${path}[${index}]` : `[${index}]`;
+    if (index >= original.length) {
+      recordDivergence(divergences, elementPath, void 0, deserialized[index], "Extra array element appeared after round-trip.");
+      continue;
+    }
+    if (index >= deserialized.length) {
+      recordDivergence(divergences, elementPath, original[index], void 0, "Array element missing after round-trip.");
+      continue;
+    }
+    compareValues(original[index], deserialized[index], elementPath, divergences);
+  }
+}
+function compareRecordValues(original, deserialized, path, divergences) {
+  const allKeys = new Set([...Object.keys(original), ...Object.keys(deserialized)]);
+  for (const key of allKeys) {
+    const propertyPath = path ? `${path}.${key}` : key;
+    if (!(key in original)) {
+      recordDivergence(divergences, propertyPath, void 0, deserialized[key], "Extra key appeared in deserialized object.");
+      continue;
+    }
+    if (!(key in deserialized)) {
+      recordDivergence(divergences, propertyPath, original[key], void 0, "Key missing from deserialized object.");
+      continue;
+    }
+    compareValues(original[key], deserialized[key], propertyPath, divergences);
+  }
+}
+function isNullishPair(original, deserialized) {
+  return original === null || original === void 0 || deserialized === null || deserialized === void 0;
+}
+function isTypeMismatch(original, deserialized) {
+  return typeof original !== typeof deserialized;
+}
+function isPrimitivePair(original) {
+  return typeof original !== "object";
+}
+const comparisonHandlers = [
+  {
+    matches: isNullishPair,
+    compare: compareNullishValues
+  },
+  {
+    matches: (original, deserialized) => original instanceof Date && deserialized instanceof Date,
+    compare: (original, deserialized, path, divergences) => compareDateValues(original, deserialized, path, divergences)
+  },
+  {
+    matches: (original, deserialized) => original instanceof RegExp && deserialized instanceof RegExp,
+    compare: (original, deserialized, path, divergences) => compareRegExpValues(original, deserialized, path, divergences)
+  },
+  {
+    matches: (original, deserialized) => original instanceof Map && deserialized instanceof Map,
+    compare: (original, deserialized, path, divergences) => compareMapValues(original, deserialized, path, divergences)
+  },
+  {
+    matches: (original, deserialized) => original instanceof Set && deserialized instanceof Set,
+    compare: (original, deserialized, path, divergences) => compareSetValues(original, deserialized, path, divergences)
+  },
+  {
+    matches: isTypeMismatch,
+    compare: compareTypeMismatch
+  },
+  {
+    matches: isPrimitivePair,
+    compare: comparePrimitiveValues
+  },
+  {
+    matches: (original, deserialized) => Array.isArray(original) && Array.isArray(deserialized),
+    compare: (original, deserialized, path, divergences) => compareArrayValues(original, deserialized, path, divergences)
+  },
+  {
+    matches: () => !0,
+    compare: (original, deserialized, path, divergences) => compareRecordValues(original, deserialized, path, divergences)
+  }
+];

package/dist/core/checkpoint/index.d.ts

@@ -0,0 +1,4 @@
+export type { CheckpointDivergence, CheckpointValidationResult } from './interfaces.ts';
+export { advanceCheckpoint, checkpointSizeBytes, createCheckpoint } from './lifecycle.ts';
+export { deserializeCheckpoint, serializeCheckpoint } from './serialization.ts';
+export { validateCheckpointRoundTrip } from './validation.ts';

package/dist/core/checkpoint/index.js

@@ -0,0 +1,3 @@
+export { advanceCheckpoint, checkpointSizeBytes, createCheckpoint } from "./lifecycle.js";
+export { deserializeCheckpoint, serializeCheckpoint } from "./serialization.js";
+export { validateCheckpointRoundTrip } from "./validation.js";

package/dist/core/checkpoint/interfaces.d.ts

@@ -0,0 +1,11 @@
+export interface CheckpointValidationResult {
+    valid: boolean;
+    divergences: CheckpointDivergence[];
+    sizeBytes: number;
+}
+export interface CheckpointDivergence {
+    path: string;
+    original: unknown;
+    deserialized: unknown;
+    suggestion: string;
+}

package/dist/core/checkpoint/lifecycle.d.ts

@@ -0,0 +1,49 @@
+import type { Checkpoint, SearchAttributeValue, Serializer, WorkflowId } from '../types.ts';
+/**
+ * Create a fresh checkpoint for a new workflow.
+ *
+ * @example
+ * ```ts
+ * import { createCheckpoint } from '@lostgradient/weft';
+ *
+ * const checkpoint = createCheckpoint('wf-789', '1.0.0');
+ * console.log(checkpoint.workflowId); // 'wf-789'
+ * console.log(checkpoint.step);       // 0
+ * console.log(checkpoint.version);    // '1.0.0'
+ * ```
+ */
+export declare function createCheckpoint(workflowId: WorkflowId, version: string, now?: number): Checkpoint;
+/**
+ * Advance a checkpoint to the next step with new locals.
+ *
+ * @example
+ * ```ts
+ * import { createCheckpoint, advanceCheckpoint } from '@lostgradient/weft';
+ *
+ * const checkpoint = createCheckpoint('wf-abc', '1.0.0');
+ * const next = advanceCheckpoint(checkpoint, { userId: 'u-1', status: 'active' });
+ * console.log(next.step);            // 1
+ * console.log(next.locals['userId']);   // 'u-1'
+ * ```
+ */
+export declare function advanceCheckpoint(checkpoint: Checkpoint, locals: Record<string, unknown>, options?: {
+    searchAttributes?: Record<string, SearchAttributeValue>;
+    accumulatedResults?: Array<[number, unknown]>;
+    now?: number;
+}): Checkpoint;
+/**
+ * Get the serialized size of a checkpoint in bytes.
+ *
+ * @example
+ * ```ts
+ * import { createCheckpoint, advanceCheckpoint, checkpointSizeBytes } from '@lostgradient/weft';
+ *
+ * const cp = advanceCheckpoint(
+ *   createCheckpoint('wf-size', '1.0.0'),
+ *   { items: Array.from({ length: 100 }, (_, i) => i) },
+ * );
+ * const bytes = checkpointSizeBytes(cp);
+ * console.log(bytes > 0); // true
+ * ```
+ */
+export declare function checkpointSizeBytes(checkpoint: Checkpoint, serializer?: Serializer): number;

package/dist/core/checkpoint/lifecycle.js

@@ -0,0 +1,36 @@
+import { CURRENT_CHECKPOINT_SCHEMA_VERSION } from "../types/checkpoint.js";
+import { serializeCheckpoint } from "./serialization.js";
+export function createCheckpoint(workflowId, version, now) {
+  return {
+    workflowId,
+    step: 0,
+    locals: {},
+    accumulatedResults: [],
+    pendingSignals: [],
+    searchAttributes: {},
+    version,
+    schemaVersion: CURRENT_CHECKPOINT_SCHEMA_VERSION,
+    createdAt: now ?? Date.now()
+  };
+}
+export function advanceCheckpoint(checkpoint, locals, options) {
+  return {
+    workflowId: checkpoint.workflowId,
+    step: checkpoint.step + 1,
+    locals,
+    accumulatedResults: options?.accumulatedResults ?? checkpoint.accumulatedResults,
+    ...checkpoint.workerReplaySignatures === void 0 ? {} : { workerReplaySignatures: checkpoint.workerReplaySignatures },
+    ...checkpoint.workerReplayFailures === void 0 ? {} : { workerReplayFailures: checkpoint.workerReplayFailures },
+    pendingSignals: checkpoint.pendingSignals,
+    searchAttributes: {
+      ...checkpoint.searchAttributes,
+      ...options?.searchAttributes
+    },
+    version: checkpoint.version,
+    schemaVersion: checkpoint.schemaVersion,
+    createdAt: options?.now ?? Date.now()
+  };
+}
+export function checkpointSizeBytes(checkpoint, serializer) {
+  return serializeCheckpoint(checkpoint, serializer).byteLength;
+}

package/dist/core/checkpoint/serialization.d.ts

@@ -0,0 +1,31 @@
+import type { Checkpoint, Serializer } from '../types.ts';
+/**
+ * Serialize a Checkpoint to bytes.
+ *
+ * @example
+ * ```ts
+ * import { createCheckpoint, serializeCheckpoint } from '@lostgradient/weft';
+ *
+ * const checkpoint = createCheckpoint('wf-123', '1.0.0');
+ * const bytes = serializeCheckpoint(checkpoint);
+ * console.log(bytes instanceof Uint8Array); // true
+ * console.log(bytes.byteLength > 0);        // true
+ * ```
+ */
+export declare function serializeCheckpoint(checkpoint: Checkpoint, serializer?: Serializer): Uint8Array;
+/**
+ * Deserialize bytes to a Checkpoint. Throws if invalid.
+ *
+ * @example
+ * ```ts
+ * import { createCheckpoint, serializeCheckpoint, deserializeCheckpoint } from '@lostgradient/weft';
+ *
+ * const checkpoint = createCheckpoint('wf-456', '1.0.0');
+ * const bytes = serializeCheckpoint(checkpoint);
+ * const restored = deserializeCheckpoint(bytes);
+ * console.log(restored.workflowId); // 'wf-456'
+ * console.log(restored.step);       // 0
+ * ```
+ */
+export declare function deserializeCheckpoint(bytes: Uint8Array, serializer?: Serializer): Checkpoint;
+export declare function validateCheckpointShape(value: unknown): asserts value is Checkpoint;

package/dist/core/checkpoint/serialization.js

@@ -0,0 +1,155 @@
+import { decode, encode } from "../codec.js";
+import { validateSessionStateLocals } from "../session-state.js";
+import {
+  CURRENT_CHECKPOINT_SCHEMA_VERSION,
+  CheckpointSchemaVersionError,
+  WORKER_REPLAY_SIGNATURE_FORMAT
+} from "../types/checkpoint.js";
+export function serializeCheckpoint(checkpoint, serializer) {
+  if (serializer)
+    return serializer.serialize(checkpoint);
+  return encode(checkpoint);
+}
+export function deserializeCheckpoint(bytes, serializer) {
+  let decoded;
+  if (serializer)
+    decoded = serializer.deserialize(bytes);
+  else
+    decoded = decode(bytes);
+  validateCheckpointShape(decoded);
+  return decoded;
+}
+export function validateCheckpointShape(value) {
+  const record = assertCheckpointRecord(value);
+  assertStringField(record, "workflowId");
+  assertNumberField(record, "step");
+  assertRecordField(record, "locals");
+  validateSessionStateLocals(record.locals);
+  normalizeAccumulatedResults(record);
+  validateWorkerReplaySignatures(record);
+  validateWorkerReplayFailures(record);
+  assertArrayField(record, "pendingSignals");
+  assertRecordField(record, "searchAttributes");
+  assertStringField(record, "version");
+  assertNumberField(record, "createdAt");
+  assertCurrentSchemaVersion(record);
+}
+function validateWorkerReplaySignatures(record) {
+  if (!("workerReplaySignatures" in record) || record.workerReplaySignatures === void 0)
+    return;
+  const signatures = record.workerReplaySignatures;
+  if (!Array.isArray(signatures))
+    throw Error('Invalid checkpoint: invalid "workerReplaySignatures" (expected array)');
+  for (const entry of signatures)
+    validateWorkerReplaySignatureEntry(entry);
+}
+function validateWorkerReplaySignatureEntry(value) {
+  if (!Array.isArray(value) || value.length !== 2)
+    throw Error('Invalid checkpoint: invalid "workerReplaySignatures" entry');
+  const [step, signature] = value;
+  validateWorkerReplaySignatureStep(step);
+  validateWorkerReplaySignatureRecord(assertWorkerReplaySignatureRecord(signature));
+}
+function validateWorkerReplaySignatureStep(step) {
+  if (typeof step !== "number" || !Number.isSafeInteger(step) || step < 0)
+    throw Error('Invalid checkpoint: invalid "workerReplaySignatures" step');
+}
+function assertWorkerReplaySignatureRecord(signature) {
+  if (typeof signature !== "object" || signature === null)
+    throw Error('Invalid checkpoint: invalid "workerReplaySignatures" signature');
+  return signature;
+}
+function validateWorkerReplaySignatureRecord(record) {
+  if (record.format !== WORKER_REPLAY_SIGNATURE_FORMAT)
+    throw Error('Invalid checkpoint: invalid "workerReplaySignatures" format');
+  if (typeof record.operationType !== "string")
+    throw Error('Invalid checkpoint: invalid "workerReplaySignatures" operationType');
+  if (typeof record.stableFieldsDigest !== "string")
+    throw Error('Invalid checkpoint: invalid "workerReplaySignatures" stableFieldsDigest');
+  validateWorkerReplaySignatureByteLength(record.stableFieldsByteLength);
+}
+function validateWorkerReplaySignatureByteLength(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+    throw Error('Invalid checkpoint: invalid "workerReplaySignatures" stableFieldsByteLength');
+}
+function validateWorkerReplayFailures(record) {
+  if (!("workerReplayFailures" in record) || record.workerReplayFailures === void 0)
+    return;
+  const failures = record.workerReplayFailures;
+  if (!Array.isArray(failures))
+    throw Error('Invalid checkpoint: invalid "workerReplayFailures" (expected array)');
+  for (const entry of failures)
+    validateWorkerReplayFailureEntry(entry);
+}
+function validateWorkerReplayFailureEntry(value) {
+  if (!Array.isArray(value) || value.length !== 2)
+    throw Error('Invalid checkpoint: invalid "workerReplayFailures" entry');
+  const [step, outcome] = value;
+  validateWorkerReplaySignatureStep(step);
+  validateWorkerReplayFailureOutcome(assertWorkerReplayFailureRecord(outcome));
+}
+function assertWorkerReplayFailureRecord(outcome) {
+  if (typeof outcome !== "object" || outcome === null)
+    throw Error('Invalid checkpoint: invalid "workerReplayFailures" outcome');
+  return outcome;
+}
+function validateWorkerReplayFailureOutcome(record) {
+  if (record.status !== "failed")
+    throw Error('Invalid checkpoint: invalid "workerReplayFailures" status');
+  if (typeof record.error !== "string")
+    throw Error('Invalid checkpoint: invalid "workerReplayFailures" error');
+  if (record.errorName !== void 0 && typeof record.errorName !== "string")
+    throw Error('Invalid checkpoint: invalid "workerReplayFailures" errorName');
+  if (record.failureCategory !== void 0 && !isFailureCategory(record.failureCategory))
+    throw Error('Invalid checkpoint: invalid "workerReplayFailures" failureCategory');
+}
+function isFailureCategory(value) {
+  switch (value) {
+    case "application":
+    case "cancellation":
+    case "resource":
+    case "system":
+    case "timeout":
+      return !0;
+    default:
+      return !1;
+  }
+}
+function assertCheckpointRecord(value) {
+  if (typeof value !== "object" || value === null)
+    throw Error("Invalid checkpoint: expected an object");
+  return value;
+}
+function assertStringField(record, field) {
+  if (typeof record[field] !== "string")
+    throw Error(`Invalid checkpoint: missing or invalid "${field}" (expected string)`);
+}
+function assertNumberField(record, field) {
+  if (typeof record[field] !== "number")
+    throw Error(`Invalid checkpoint: missing or invalid "${field}" (expected number)`);
+}
+function assertRecordField(record, field) {
+  if (typeof record[field] !== "object" || record[field] === null)
+    throw Error(`Invalid checkpoint: missing or invalid "${field}" (expected object)`);
+}
+function assertArrayField(record, field) {
+  if (!Array.isArray(record[field]))
+    throw Error(`Invalid checkpoint: missing or invalid "${field}" (expected array)`);
+}
+function normalizeAccumulatedResults(record) {
+  if (!("accumulatedResults" in record)) {
+    record.accumulatedResults = [];
+    return;
+  }
+  if (!Array.isArray(record.accumulatedResults))
+    throw Error('Invalid checkpoint: invalid "accumulatedResults" (expected array)');
+}
+function assertCurrentSchemaVersion(record) {
+  const schemaVersion = record.schemaVersion;
+  if (schemaVersion === void 0)
+    throw new CheckpointSchemaVersionError("pre-versioned", CURRENT_CHECKPOINT_SCHEMA_VERSION);
+  if (typeof schemaVersion !== "number" || !Number.isSafeInteger(schemaVersion))
+    throw Error('Invalid checkpoint: missing or invalid "schemaVersion" (expected integer number)');
+  if (schemaVersion !== CURRENT_CHECKPOINT_SCHEMA_VERSION)
+    throw new CheckpointSchemaVersionError(schemaVersion, CURRENT_CHECKPOINT_SCHEMA_VERSION);
+}

package/dist/core/checkpoint/validation.d.ts

@@ -0,0 +1,4 @@
+import type { Checkpoint, Serializer } from '../types.ts';
+import type { CheckpointValidationResult } from './interfaces.ts';
+/** Development mode: validate checkpoint round-trips cleanly through serialization. */
+export declare function validateCheckpointRoundTrip(checkpoint: Checkpoint, serializer?: Serializer): CheckpointValidationResult;

package/dist/core/checkpoint/validation.js

@@ -0,0 +1,26 @@
+import { validateCloneable } from "../codec.js";
+import { compareValues } from "./comparison.js";
+import { deserializeCheckpoint, serializeCheckpoint } from "./serialization.js";
+export function validateCheckpointRoundTrip(checkpoint, serializer) {
+  const cloneResult = validateCloneable(checkpoint);
+  if (!cloneResult.valid) {
+    const divergences = cloneResult.errors.map((error) => ({
+      path: error.path,
+      original: error.value,
+      deserialized: void 0,
+      suggestion: error.suggestion
+    }));
+    let sizeBytes = 0;
+    try {
+      sizeBytes = serializeCheckpoint(checkpoint, serializer).byteLength;
+    } catch {}
+    return { valid: !1, divergences, sizeBytes };
+  }
+  const bytes = serializeCheckpoint(checkpoint, serializer), restored = deserializeCheckpoint(bytes, serializer), divergences = [];
+  compareValues(checkpoint, restored, "", divergences);
+  return {
+    valid: divergences.length === 0,
+    divergences,
+    sizeBytes: bytes.byteLength
+  };
+}

package/dist/core/checkpoint.d.ts

@@ -0,0 +1 @@
+export * from './checkpoint/index.ts';

package/dist/core/checkpoint.js

@@ -0,0 +1 @@
+export * from "./checkpoint/index.js";

package/dist/core/codec/api.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Encode a value to MessagePack bytes with structuredClone semantics.
+ *
+ * @example
+ * ```ts
+ * import { encode, decode } from '@lostgradient/weft';
+ *
+ * const data = { name: 'Alice', createdAt: new Date(), tags: new Set(['admin']) };
+ * const bytes = encode(data);
+ * console.log(bytes instanceof Uint8Array); // true
+ *
+ * const restored = decode(bytes) as typeof data;
+ * console.log(restored.name);          // 'Alice'
+ * console.log(restored.tags instanceof Set); // true
+ * ```
+ */
+export declare function encode(value: unknown): Uint8Array;
+/**
+ * Decode MessagePack bytes back to a value.
+ *
+ * @example
+ * ```ts
+ * import { encode, decode } from '@lostgradient/weft';
+ *
+ * const original = { id: 42, labels: new Map([['env', 'prod']]) };
+ * const bytes = encode(original);
+ * const result = decode(bytes) as typeof original;
+ * console.log(result.id);                      // 42
+ * console.log(result.labels.get('env'));        // 'prod'
+ * ```
+ */
+export declare function decode(bytes: Uint8Array): unknown;

package/dist/core/codec/api.js

@@ -0,0 +1,9 @@
+import { decode as msgpackDecode, encode as msgpackEncode } from "@msgpack/msgpack";
+import { extensionCodec, replaceUndefined } from "./extension-codec.js";
+export function encode(value) {
+  const preprocessed = replaceUndefined(value, new Set);
+  return msgpackEncode(preprocessed, { extensionCodec });
+}
+export function decode(bytes) {
+  return msgpackDecode(bytes, { extensionCodec });
+}

package/dist/core/codec/extension-codec.d.ts

@@ -0,0 +1,7 @@
+import { ExtensionCodec } from '@msgpack/msgpack';
+export declare const extensionCodec: ExtensionCodec<undefined>;
+/**
+ * Recursively replace `undefined` with the sentinel so msgpack's encoder
+ * routes it through the extension codec instead of encoding it as null.
+ */
+export declare function replaceUndefined(value: unknown, visited: Set<object>): unknown;

package/dist/core/codec/extension-codec.js

@@ -0,0 +1,145 @@
+import { ExtensionCodec, decode as msgpackDecode, encode as msgpackEncode } from "@msgpack/msgpack";
+import {
+  coerceCodecArray,
+  coerceCodecRecord,
+  decodeCodecDate,
+  encodeCodecDate
+} from "../codec-helpers.js";
+const EXTENSION_TYPE_DATE = 1, EXTENSION_TYPE_REGEXP = 2, EXTENSION_TYPE_MAP = 3, EXTENSION_TYPE_SET = 4, EXTENSION_TYPE_UNDEFINED = 5, EXTENSION_TYPE_ERROR = 6;
+export const extensionCodec = new ExtensionCodec;
+extensionCodec.register({
+  type: EXTENSION_TYPE_DATE,
+  encode: encodeCodecDate,
+  decode: decodeCodecDate
+});
+extensionCodec.register({
+  type: EXTENSION_TYPE_REGEXP,
+  encode(value) {
+    if (value instanceof RegExp)
+      return msgpackEncode({ source: value.source, flags: value.flags });
+    return null;
+  },
+  decode(data) {
+    const decoded = coerceCodecRecord(msgpackDecode(data)), source = typeof decoded.source === "string" ? decoded.source : "", flags = typeof decoded.flags === "string" ? decoded.flags : "";
+    return new RegExp(source, flags);
+  }
+});
+extensionCodec.register({
+  type: EXTENSION_TYPE_MAP,
+  encode(value) {
+    if (value instanceof Map) {
+      const entries = [...value.entries()];
+      return msgpackEncode(entries, { extensionCodec });
+    }
+    return null;
+  },
+  decode(data) {
+    const entries = coerceCodecArray(msgpackDecode(data, { extensionCodec })).map((entry) => {
+      const pair = coerceCodecArray(entry);
+      return [pair[0], pair[1]];
+    });
+    return new Map(entries);
+  }
+});
+extensionCodec.register({
+  type: EXTENSION_TYPE_SET,
+  encode(value) {
+    if (value instanceof Set) {
+      const elements = [...value.values()];
+      return msgpackEncode(elements, { extensionCodec });
+    }
+    return null;
+  },
+  decode(data) {
+    const elements = coerceCodecArray(msgpackDecode(data, { extensionCodec }));
+    return new Set(elements);
+  }
+});
+const UNDEFINED_SENTINEL_TAG = Symbol("UndefinedSentinel"), undefinedSentinel = Object.freeze({
+  __tag: UNDEFINED_SENTINEL_TAG
+});
+function isUndefinedSentinel(value) {
+  return typeof value === "object" && value !== null && "__tag" in value && value.__tag === UNDEFINED_SENTINEL_TAG;
+}
+extensionCodec.register({
+  type: EXTENSION_TYPE_UNDEFINED,
+  encode(value) {
+    if (isUndefinedSentinel(value))
+      return new Uint8Array(0);
+    return null;
+  },
+  decode() {
+    return;
+  }
+});
+extensionCodec.register({
+  type: EXTENSION_TYPE_ERROR,
+  encode(value) {
+    if (value instanceof Error)
+      return msgpackEncode({
+        name: value.name,
+        message: value.message,
+        stack: value.stack
+      });
+    return null;
+  },
+  decode(data) {
+    const decoded = coerceCodecRecord(msgpackDecode(data)), name = typeof decoded.name === "string" ? decoded.name : "Error", message = typeof decoded.message === "string" ? decoded.message : "", stack = typeof decoded.stack === "string" ? decoded.stack : void 0, error = Error(message);
+    error.name = name;
+    if (stack !== void 0)
+      error.stack = stack;
+    return error;
+  }
+});
+export function replaceUndefined(value, visited) {
+  if (value === void 0)
+    return undefinedSentinel;
+  if (value === null || typeof value !== "object")
+    return value;
+  if (visited.has(value))
+    return value;
+  visited.add(value);
+  try {
+    return replaceObjectUndefined(value, visited);
+  } finally {
+    visited.delete(value);
+  }
+}
+function replaceObjectUndefined(value, visited) {
+  if (Array.isArray(value))
+    return replaceArrayUndefined(value, visited);
+  if (value instanceof Map)
+    return replaceMapUndefined(value, visited);
+  if (value instanceof Set)
+    return replaceSetUndefined(value, visited);
+  if (isNestedValueFree(value))
+    return value;
+  return replaceRecordUndefined(value, visited);
+}
+function replaceArrayUndefined(value, visited) {
+  const result = Array.from({ length: value.length });
+  for (let index = 0;index < value.length; index++)
+    result[index] = replaceUndefined(value[index], visited);
+  return result;
+}
+function replaceMapUndefined(value, visited) {
+  const result = new Map;
+  for (const [key, mapValue] of value)
+    result.set(replaceUndefined(key, visited), replaceUndefined(mapValue, visited));
+  return result;
+}
+function replaceSetUndefined(value, visited) {
+  const result = new Set;
+  for (const setValue of value)
+    result.add(replaceUndefined(setValue, visited));
+  return result;
+}
+function isNestedValueFree(value) {
+  return value instanceof Date || value instanceof RegExp || value instanceof Error || value instanceof Uint8Array || value instanceof ArrayBuffer;
+}
+function replaceRecordUndefined(value, visited) {
+  const record = value, result = {};
+  for (const key of Object.keys(record))
+    result[key] = replaceUndefined(record[key], visited);
+  return result;
+}