@workflow/core 5.0.0-beta.38 → 5.0.0-beta.39

package/dist/serialization/codec-devalue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codec-devalue.d.ts","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAmC,MAAM,YAAY,CAAC;AAwFzE,eAAO,MAAM,YAAY,EAAE,KA2C1B,CAAC"}
+{"version":3,"file":"codec-devalue.d.ts","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAmC,MAAM,YAAY,CAAC;AAyFzE,eAAO,MAAM,YAAY,EAAE,KAmD1B,CAAC"}

package/dist/serialization/codec-devalue.js

@@ -10,6 +10,7 @@
  * typed arrays, Map, Set natively).
  */
 import { parse, stringify, unflatten } from 'devalue';
+import { hardenedStringifyOperations, withGuestCodeStats } from './hardened.js';
 import { getClassReducers, getClassRevivers } from './reducers/class.js';
 import { getCommonReducers, getCommonRevivers } from './reducers/common.js';
 import { getStepFunctionReducer, getStepFunctionReviver, } from './reducers/step-function.js';
@@ -82,7 +83,13 @@ export const devalueCodec = {
     formatPrefix: SerializationFormat.DEVALUE_V1,
     serialize(value, mode, options) {
         const reducers = getReducersForMode(mode, options?.global, options?.extraReducers);
-        const str = stringify(value, reducers);
+        // Hardened operations: devalue's own introspection (classification,
+        // built-in extraction, property reads) goes through captured host
+        // intrinsics and descriptor reads, so serializing a value constructed
+        // inside a workflow VM cannot execute sandbox code behind our back.
+        // Where workflow code must run (getters, proxies, custom serializers),
+        // the execution is recorded into `options.guestCodeStats`.
+        const str = withGuestCodeStats(options?.guestCodeStats, () => stringify(value, reducers, { operations: hardenedStringifyOperations }));
         return encoder.encode(str);
     },
     deserialize(data, mode, options) {
@@ -95,4 +102,4 @@ export const devalueCodec = {
         return unflatten(data, revivers);
     },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codec-devalue.js","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Devalue codec implementation.\n *\n * Uses the `devalue` library for serialization. Handles custom types via\n * reducers (serialize) and revivers (deserialize) which are composed\n * internally based on the serialization mode.\n *\n * The reducer/reviver pattern is specific to devalue — other codecs\n * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,\n * typed arrays, Map, Set natively).\n */\n\nimport { parse, stringify, unflatten } from 'devalue';\nimport type { Codec, CodecOptions, SerializationMode } from './codec.js';\nimport { getClassReducers, getClassRevivers } from './reducers/class.js';\nimport { getCommonReducers, getCommonRevivers } from './reducers/common.js';\nimport {\n  getStepFunctionReducer,\n  getStepFunctionReviver,\n} from './reducers/step-function.js';\nimport { type Reducers, type Revivers, SerializationFormat } from './types.js';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\n// ---- Reducer/Reviver composition per mode ----\n\nfunction getReducersForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraReducers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Reducers>;\n  switch (mode) {\n    case 'workflow':\n      // Class/Instance MUST come before common (first-match-wins for Error subclasses)\n      base = {\n        ...getClassReducers(),\n        ...getStepFunctionReducer(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n  }\n  if (extraReducers) {\n    return { ...base, ...extraReducers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\nfunction getReviversForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraRevivers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Revivers>;\n  switch (mode) {\n    case 'workflow':\n      base = {\n        ...getClassRevivers(global),\n        ...getStepFunctionReviver(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n        StepFunction: () => {\n          throw new Error(\n            'Step functions cannot be deserialized in client context.'\n          );\n        },\n      };\n      break;\n  }\n  if (extraRevivers) {\n    return { ...base, ...extraRevivers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\n// ---- Codec implementation ----\n\nexport const devalueCodec: Codec = {\n  formatPrefix: SerializationFormat.DEVALUE_V1,\n\n  serialize(\n    value: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): Uint8Array {\n    const reducers = getReducersForMode(\n      mode,\n      options?.global,\n      options?.extraReducers\n    );\n    const str = stringify(value, reducers);\n    return encoder.encode(str);\n  },\n\n  deserialize(\n    data: Uint8Array,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    const str = decoder.decode(data);\n    return parse(str, revivers);\n  },\n\n  deserializeLegacy(\n    data: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    return unflatten(data as any[], revivers);\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codec-devalue.js","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Devalue codec implementation.\n *\n * Uses the `devalue` library for serialization. Handles custom types via\n * reducers (serialize) and revivers (deserialize) which are composed\n * internally based on the serialization mode.\n *\n * The reducer/reviver pattern is specific to devalue — other codecs\n * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,\n * typed arrays, Map, Set natively).\n */\n\nimport { parse, stringify, unflatten } from 'devalue';\nimport type { Codec, CodecOptions, SerializationMode } from './codec.js';\nimport { hardenedStringifyOperations, withGuestCodeStats } from './hardened.js';\nimport { getClassReducers, getClassRevivers } from './reducers/class.js';\nimport { getCommonReducers, getCommonRevivers } from './reducers/common.js';\nimport {\n  getStepFunctionReducer,\n  getStepFunctionReviver,\n} from './reducers/step-function.js';\nimport { type Reducers, type Revivers, SerializationFormat } from './types.js';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\n// ---- Reducer/Reviver composition per mode ----\n\nfunction getReducersForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraReducers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Reducers>;\n  switch (mode) {\n    case 'workflow':\n      // Class/Instance MUST come before common (first-match-wins for Error subclasses)\n      base = {\n        ...getClassReducers(),\n        ...getStepFunctionReducer(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n  }\n  if (extraReducers) {\n    return { ...base, ...extraReducers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\nfunction getReviversForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraRevivers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Revivers>;\n  switch (mode) {\n    case 'workflow':\n      base = {\n        ...getClassRevivers(global),\n        ...getStepFunctionReviver(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n        StepFunction: () => {\n          throw new Error(\n            'Step functions cannot be deserialized in client context.'\n          );\n        },\n      };\n      break;\n  }\n  if (extraRevivers) {\n    return { ...base, ...extraRevivers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\n// ---- Codec implementation ----\n\nexport const devalueCodec: Codec = {\n  formatPrefix: SerializationFormat.DEVALUE_V1,\n\n  serialize(\n    value: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): Uint8Array {\n    const reducers = getReducersForMode(\n      mode,\n      options?.global,\n      options?.extraReducers\n    );\n    // Hardened operations: devalue's own introspection (classification,\n    // built-in extraction, property reads) goes through captured host\n    // intrinsics and descriptor reads, so serializing a value constructed\n    // inside a workflow VM cannot execute sandbox code behind our back.\n    // Where workflow code must run (getters, proxies, custom serializers),\n    // the execution is recorded into `options.guestCodeStats`.\n    const str = withGuestCodeStats(options?.guestCodeStats, () =>\n      stringify(value, reducers, { operations: hardenedStringifyOperations })\n    );\n    return encoder.encode(str);\n  },\n\n  deserialize(\n    data: Uint8Array,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    const str = decoder.decode(data);\n    return parse(str, revivers);\n  },\n\n  deserializeLegacy(\n    data: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    return unflatten(data as any[], revivers);\n  },\n};\n"]}

package/dist/serialization/codec.d.ts

@@ -14,6 +14,7 @@
  *   plain objects). No Date, Map, Set, typed arrays, etc.
  */
 import type { CompressionStats } from './compression.js';
+import type { GuestCodeStats } from './hardened.js';
 import type { FormatPrefix } from './types.js';
 /**
  * The serialization mode determines which types are supported and how
@@ -67,6 +68,22 @@ export interface CodecOptions {
      * Used by the dehydrate/hydrate wrappers to emit OTel span attributes.
      */
     compressionStats?: CompressionStats;
+    /**
+     * Optional sink populated by the hardened serializer with every
+     * workflow (guest) code execution that serialization could not avoid —
+     * getters, proxies, and custom `[WORKFLOW_SERIALIZE]` methods. A non-empty
+     * `executions` array means serialization may have perturbed VM state
+     * (it runs exactly once per payload and is never replayed, so any side
+     * effect it triggers diverges from replay).
+     *
+     * Every dehydrate path already reports this as span attributes. Passing a
+     * sink is for callers that need the executions *programmatically* — a
+     * retained-VM gate deciding whether the VM is still reusable. No caller
+     * does that yet, so nothing in the runtime currently passes one.
+     *
+     * Serialize side only.
+     */
+    guestCodeStats?: GuestCodeStats;
 }
 export interface Codec {
     /** The 4-character format prefix identifier (e.g. "devl", "cbor", "json") */

package/dist/serialization/codec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/serialization/codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE7B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAEpD;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAEpD;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAED,MAAM,WAAW,KAAK;IACpB,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IAEpC;;;;;;;;;OASG;IACH,SAAS,CACP,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAAC;IAEd;;;;;;;;;OASG;IACH,WAAW,CACT,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;IAEX;;;;;;;;;OASG;IACH,iBAAiB,CAAC,CAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;CACZ"}
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/serialization/codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE7B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAEpD;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAEpD;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAEpC;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,WAAW,KAAK;IACpB,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IAEpC;;;;;;;;;OASG;IACH,SAAS,CACP,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAAC;IAEd;;;;;;;;;OASG;IACH,WAAW,CACT,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;IAEX;;;;;;;;;OASG;IACH,iBAAiB,CAAC,CAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;CACZ"}

package/dist/serialization/codec.js

@@ -14,4 +14,4 @@
  *   plain objects). No Date, Map, Set, typed arrays, etc.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/hardened.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Hardened introspection for serializing values that may originate inside a
+ * workflow VM (`node:vm`) sandbox realm.
+ *
+ * Serialization runs on the host, but the values it inspects were
+ * constructed by workflow code — so a naive dynamic operation like
+ * `value.toISOString()`, `Array.from(map)`, or `Object.prototype.toString`
+ * dispatches into the sandbox realm and executes workflow code (patched
+ * prototype methods, getters, proxy traps, `Symbol.toStringTag` accessors).
+ * That is a determinism hazard: serialization happens exactly once per
+ * payload (never again on replay), so any workflow-visible side effect it
+ * triggers exists only on the live execution path and diverges from replay.
+ *
+ * This module makes serialization side-effect free wherever the data allows
+ * it, and *observable* where it does not:
+ *
+ * - **Classification** uses engine-level brand checks (`node:util` `types`,
+ *   internal-slot probes) instead of `instanceof` / `Object.prototype.toString`
+ *   — immune to `Symbol.hasInstance`, `Symbol.toStringTag`, and reassigned
+ *   globals.
+ * - **Extraction** goes through intrinsics captured at module load (host
+ *   boot, before any workflow code runs). Internal slots are realm-agnostic,
+ *   so host intrinsics read VM-realm objects without touching the sandbox's
+ *   (patchable) prototypes.
+ * - **Property access** reads through descriptors, so plain data never
+ *   invokes anything. Where workflow code *must* run because the data itself
+ *   lives behind it — getters, proxies, custom `[WORKFLOW_SERIALIZE]`
+ *   methods, `toString()` on toStringTag-branded objects (e.g. Temporal
+ *   polyfills) — the execution is preserved for compatibility and recorded
+ *   in the active {@link GuestCodeStats} sink, so callers (e.g. a retained-VM
+ *   gate) can react.
+ *
+ * **Recording is not prevention.** For the recorded cases the determinism
+ * hazard is still live: a getter that calls `Math.random()` advances the
+ * run's seeded PRNG during serialization, and because serialization happens
+ * exactly once and is never replayed, every subsequent draw — including the
+ * correlation ids derived from that stream — shifts relative to replay. The
+ * report is the only trace of that; acting on it (warning, demoting a
+ * retained VM to replay) is left to the caller.
+ *
+ * The recorder is ambient module state, set for the duration of a
+ * synchronous `stringify` call via {@link withGuestCodeStats}. devalue's
+ * `stringify` is fully synchronous, so this is safe without async context.
+ */
+import type { StringifyOperations } from 'devalue';
+/**
+ * A single instance of workflow (guest) code executing during serialization.
+ */
+export interface GuestCodeExecution {
+    /**
+     * What forced the execution:
+     * - `getter`: an accessor property was invoked to read data
+     * - `proxy`: a proxy was introspected, firing its traps. Note this also
+     *   implies a **shape change**: brand checks answer "not that type" for a
+     *   proxy, so a proxied `Map` serializes as a plain object rather than as a
+     *   `Map`, and this report is the only evidence of it. (Such values were
+     *   never serializable before — the internal-slot reads in the previous
+     *   implementation threw on them — so the shape change replaces a crash,
+     *   but it is silent.)
+     * - `method`: a workflow-defined function was invoked (e.g. a custom
+     *   `[WORKFLOW_SERIALIZE]` serializer, `toString()` on a
+     *   `Symbol.toStringTag`-branded object, a duck-typed `getTime()`, or a
+     *   `__closureVarsFn` this package did not generate)
+     */
+    kind: 'getter' | 'proxy' | 'method';
+    /** Best-effort context: the property key, method name, or tag involved. */
+    detail?: string;
+}
+/**
+ * Mutable sink recording every workflow-code execution serialization could
+ * not avoid. Pass via `CodecOptions.guestCodeStats`; consumers that retain
+ * the VM across steps can use a non-empty `executions` array as a signal
+ * that the VM state may have been perturbed by serialization.
+ */
+export interface GuestCodeStats {
+    executions: GuestCodeExecution[];
+}
+/**
+ * Runs `fn` (synchronously) with `stats` as the active guest-code sink.
+ * Nested calls stack correctly; a `null`/`undefined` sink disables
+ * recording without disabling hardening.
+ */
+export declare function withGuestCodeStats<T>(stats: GuestCodeStats | undefined, fn: () => T): T;
+/** Marks a function as having been passed to `useStep`. */
+export declare function markUseStepClosureFn<T extends object>(fn: T): T;
+/** Whether `fn` was marked by {@link markUseStepClosureFn}. */
+export declare function isUseStepClosureFn(fn: unknown): boolean;
+export declare function recordGuestCode(kind: GuestCodeExecution['kind'], detail?: string): void;
+/** `Date.prototype.getDate`, for invalid-date checks. */
+export declare const dateGetDate: (thisArg: unknown) => number;
+/** `Date.prototype.getTime`. */
+export declare const dateGetTime: (thisArg: unknown) => number;
+/** `Date.prototype.toISOString`. */
+export declare const dateToISOString: (thisArg: unknown) => string;
+/** `RegExp.prototype.source` getter. */
+export declare const regExpSource: (value: unknown) => string;
+/** `RegExp.prototype.flags` getter. */
+export declare const regExpFlags: (value: unknown) => string;
+/** `ArrayBuffer.prototype.byteLength` getter (internal slot read). */
+export declare const arrayBufferByteLength: (value: unknown) => number;
+/**
+ * Reads `value[key]` with `[[Get]]` semantics, but through descriptors:
+ * plain data properties never invoke anything; accessor properties are
+ * invoked (the data lives behind them) and recorded; proxies fall back to
+ * a plain read (their traps are the only access path) and are recorded.
+ */
+export declare function readProperty(value: unknown, key: PropertyKey): unknown;
+/**
+ * `key in value` semantics without firing proxy traps for ordinary
+ * objects. Proxies fall back to the `in` operator and are recorded.
+ */
+export declare function hasProperty(value: unknown, key: PropertyKey): boolean;
+/**
+ * `value instanceof C` semantics for a known `C.prototype`, without
+ * consulting `Symbol.hasInstance` (which workflow code can define). Used
+ * for host classes that are injected into the sandbox (Headers, URL,
+ * URLSearchParams, DOMException), where the instances — from any realm the
+ * host handed the class to — carry the host prototype in their chain.
+ *
+ * Proxies are walked rather than rejected: `Reflect.getPrototypeOf` fires
+ * the proxy's `getPrototypeOf` trap, matching `instanceof` semantics, and
+ * real values depend on that — Next.js hands the runtime a proxied
+ * `NextRequest`, and answering "not a Request" for it would silently break
+ * webhooks. The traps are guest-observable, so the proxy is recorded.
+ */
+export declare function isInstanceOfPrototype(value: unknown, prototype: object | undefined): boolean;
+/** `URL.prototype.href` getter. */
+export declare function urlHref(value: URL): string;
+/** `URLSearchParams.prototype.toString` — returns `''` iff empty. */
+export declare function urlSearchParamsToString(value: URLSearchParams): string;
+/**
+ * Iterates a Headers instance through the captured host iterator, so the
+ * iterator object — and its `next` — are host-realm.
+ */
+export declare function headersToEntries(value: Headers): [string, string][];
+/**
+ * Iterates a genuine Map's entries entirely through host intrinsics: the
+ * iterator object is created by the host `Map.prototype.entries`, so its
+ * realm — and therefore its `next` — is the host's, not the sandbox's.
+ */
+export declare function mapToEntries(value: Map<unknown, unknown>): [unknown, unknown][];
+/** See {@link mapToEntries}. */
+export declare function setToValues(value: Set<unknown>): unknown[];
+/**
+ * The bytes of an `ArrayBufferView`, read via internal-slot getters —
+ * own-property shadowing and prototype patches cannot change which bytes
+ * are serialized.
+ */
+export declare function viewInfo(value: ArrayBufferView): {
+    buffer: ArrayBufferLike;
+    byteOffset: number;
+    byteLength: number;
+};
+export declare const hardenedStringifyOperations: Partial<StringifyOperations>;
+//# sourceMappingURL=hardened.d.ts.map

package/dist/serialization/hardened.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hardened.d.ts","sourceRoot":"","sources":["../../src/serialization/hardened.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAKnD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;;;OAcG;IACH,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpC,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,kBAAkB,EAAE,CAAC;CAClC;AAKD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,cAAc,GAAG,SAAS,EACjC,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAWH;AAkBD,2DAA2D;AAC3D,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAG/D;AAED,+DAA+D;AAC/D,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAEvD;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,EAChC,MAAM,CAAC,EAAE,MAAM,GACd,IAAI,CAKN;AAwCD,yDAAyD;AACzD,eAAO,MAAM,WAAW,8BAAsC,CAAC;AAC/D,gCAAgC;AAChC,eAAO,MAAM,WAAW,8BAAsC,CAAC;AAC/D,oCAAoC;AACpC,eAAO,MAAM,eAAe,8BAA0C,CAAC;AACvE,wCAAwC;AACxC,eAAO,MAAM,YAAY,UAlBd,OAAO,WAkByD,CAAC;AAC5E,uCAAuC;AACvC,eAAO,MAAM,WAAW,UApBb,OAAO,WAoBuD,CAAC;AAC1E,sEAAsE;AACtE,eAAO,MAAM,qBAAqB,UAtBvB,OAAO,WAyBjB,CAAC;AAiGF;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAiCtE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAsBrE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,OAAO,CAWT;AASD,mCAAmC;AACnC,wBAAgB,OAAO,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAM1C;AAED,qEAAqE;AACrE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAMtE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAMnE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,GAC3B,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAEtB;AAED,gCAAgC;AAChC,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,OAAO,EAAE,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG;IAChD,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAaA;AAyFD,eAAO,MAAM,2BAA2B,EAAE,OAAO,CAAC,mBAAmB,CAgFpE,CAAC"}