@smthrs/flow 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/WaitFor.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The system wait point, as an ordinary declared action.
+ *
+ * `docs/concepts/flows-and-actions.md` names wait-for-event the
+ * other half of the timer gap and says how to close it: ship it over the
+ * existing `DurableDeferred`, so an external signal is a visible, keyed plan
+ * node. That is this module. {@link action} is a plain `Action.make`
+ * declaration — catalogable, `.call()`-able, one node in the built plan — and
+ * {@link layer} is the implementation.
+ *
+ * Nothing about resolution is new. The wait is a `DurableDeferred`, so whoever
+ * satisfies it completes it the way every other durable deferred is completed:
+ * a token, and `DurableDeferred.succeed`, `fail`, `failCause`, or `done`.
+ * {@link deferred} is how a resolver names the same wait point the action
+ * awaits. The park is declared through the ordinary waiting vocabulary
+ * ({@link module:WaitingAnnotation.annotateWaiting}) under `event`, carrying
+ * that token as the compare-and-swap material a wake handler matches. Replay is
+ * the deferred's: once a result is recorded, a re-driven round reads it and
+ * runs through instead of parking again.
+ *
+ * @since 0.1.0
+ */
+import type * as Crypto from "effect/Crypto";
+import type * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Action from "./Action/index.ts";
+import * as DurableDeferred from "./DurableDeferred.ts";
+import type { FlowRuntime } from "./FlowRuntime/FlowRuntime.ts";
+declare const WaitForRequestInvalid_base: Schema.Class<WaitForRequestInvalid, Schema.TaggedStruct<"@smthrs/flow/WaitForRequestInvalid", {
+    readonly code: Schema.Literals<readonly ["missing_target", "ambiguous_target", "malformed_token", "foreign_execution"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A wait whose payload does not name exactly one reachable wait point.
+ *
+ * A payload names the wait point by `name`, relative to the running execution,
+ * or by an absolute `token`. Naming both, or neither, leaves nothing to await;
+ * a token that does not parse names nothing either; and a token addressed to a
+ * different flow or a different execution names a wait point this execution
+ * cannot observe, because a durable deferred result is recorded against the
+ * flow and execution that own it.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class WaitForRequestInvalid extends WaitForRequestInvalid_base {
+}
+/**
+ * The tag the wait declaration is catalogued and resolved under.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const tag = "system/wait-for";
+/**
+ * The durable deferred a named wait point resolves through.
+ *
+ * This is the resolver's half of {@link action}: the value to hand
+ * `DurableDeferred.tokenFromExecutionId` and `DurableDeferred.succeed`, so a
+ * wait that a body declared by name is completed through the existing deferred
+ * completion path rather than a second one.
+ *
+ * ```ts
+ * const gate = WaitFor.deferred("approval")
+ * const token = DurableDeferred.tokenFromExecutionId(gate, { flow, executionId })
+ * yield* DurableDeferred.succeed(gate, { token, value: { approved: true } })
+ * ```
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const deferred: (name: string) => DurableDeferred.DurableDeferred<typeof Schema.Json>;
+/**
+ * The declared wait action: a wait point named by `name` or by `token`.
+ *
+ * **When to use**
+ *
+ * Use it in a body wherever a round has to wait for something outside the run —
+ * an approval, a webhook, a human — `WaitFor.action.call({ name: "approval"
+ * })`. The node settles with whatever value resolved the wait, so downstream
+ * steps read it the way they read any other step result.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const action: Action.Declared<typeof tag, Schema.Struct<{
+    readonly token: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+}>, typeof Schema.Json, typeof WaitForRequestInvalid, never>;
+/**
+ * The wait implementation: park under `event` with the wake token, and settle
+ * with the value that resolved the wait.
+ *
+ * Provide it beside the other action implementation layers a body calls, over
+ * the {@link module:Implementations.layerImplementations} table they file
+ * themselves in:
+ *
+ * ```ts
+ * Layer.mergeAll(WaitFor.layer, Interpreter.layer(Pipeline)).pipe(
+ *   Layer.provideMerge(Action.layerImplementations)
+ * )
+ * ```
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<never, never, Crypto.Crypto | FlowRuntime>;
+export {};
+//# sourceMappingURL=WaitFor.d.ts.map

package/dist/cjs/WaitFor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitFor.d.ts","sourceRoot":"","sources":["../../src/WaitFor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;;;;;AAG/D;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAsB,SAAQ,0BAW1C;CAAG;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,GAAG,oBAAoB,CAAA;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,eAAe,CAAC,eAAe,CAAC,OAAO,MAAM,CAAC,IAAI,CACvB,CAAA;AAEnE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,QAAQ,CAClC,OAAO,GAAG,EACV,MAAM,CAAC,MAAM,CAAC;IACZ,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;CAC9C,CAAC,EACF,OAAO,MAAM,CAAC,IAAI,EAClB,OAAO,qBAAqB,EAC5B,KAAK,CASL,CAAA;AAkFF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,GAAG,WAAW,CAWxE,CAAA"}

package/dist/cjs/WaitFor.js

@@ -0,0 +1,117 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target2, all) => {
+  for (var name in all)
+    __defProp(target2, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WaitFor_exports = {};
+__export(WaitFor_exports, {
+  WaitForRequestInvalid: () => WaitForRequestInvalid,
+  action: () => action,
+  deferred: () => deferred,
+  layer: () => layer,
+  tag: () => tag
+});
+module.exports = __toCommonJS(WaitFor_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Action = __toESM(require("./Action/index.js"), 1);
+var DurableDeferred = __toESM(require("./DurableDeferred.js"), 1);
+var import_FlowInstance = require("./FlowRuntime/FlowInstance.js");
+var import_WaitingAnnotation = require("./FlowRuntime/WaitingAnnotation.js");
+class WaitForRequestInvalid extends Schema.TaggedError()(
+  "@smthrs/flow/WaitForRequestInvalid",
+  {
+    code: Schema.Literals([
+      "missing_target",
+      "ambiguous_target",
+      "malformed_token",
+      "foreign_execution"
+    ]),
+    message: Schema.String
+  }
+) {
+}
+const tag = "system/wait-for";
+const deferred = (name) => DurableDeferred.make(`WaitFor/${name}`, { success: Schema.Json });
+const action = Action.makeSystem(tag, {
+  payload: {
+    token: Schema.optional(Schema.String),
+    name: Schema.optional(Schema.String)
+  },
+  success: Schema.Json,
+  error: WaitForRequestInvalid,
+  tier: "sealed"
+});
+const parseToken = (token) => Effect.mapError(
+  DurableDeferred.TokenParsed.parse(token),
+  (error) => new WaitForRequestInvalid({
+    code: "malformed_token",
+    message: `${tag} was called with a token that is not a durable deferred token. ${error.message}`
+  })
+);
+const target = (payload, flowName, executionId) => {
+  if (payload.token !== void 0 && payload.name !== void 0) {
+    return Effect.fail(
+      new WaitForRequestInvalid({
+        code: "ambiguous_target",
+        message: `${tag} was called with both "token" and "name". A wait names one wait point: a name relative to this execution, or an absolute token.`
+      })
+    );
+  }
+  if (payload.name !== void 0) return Effect.succeed(deferred(payload.name));
+  if (payload.token !== void 0) {
+    return Effect.flatMap(
+      parseToken(payload.token),
+      (parsed) => parsed.flowName !== flowName || parsed.executionId !== executionId ? Effect.fail(
+        new WaitForRequestInvalid({
+          code: "foreign_execution",
+          message: `${tag} was called with a token addressed to flow "${parsed.flowName}" in execution "${parsed.executionId}", but it is running as flow "${flowName}" in execution "${executionId}". A durable deferred result is recorded against the execution that owns it, so only that execution can await it.`
+        })
+      ) : Effect.succeed(
+        DurableDeferred.make(parsed.deferredName, { success: Schema.Json })
+      )
+    );
+  }
+  return Effect.fail(
+    new WaitForRequestInvalid({
+      code: "missing_target",
+      message: `${tag} was called with neither "token" nor "name", so there is no wait point to await.`
+    })
+  );
+};
+const layer = action.toLayer(
+  (payload) => Effect.gen(function* () {
+    const instance = yield* import_FlowInstance.FlowInstance;
+    const waitPoint = yield* target(payload, instance.flow._tag, instance.executionId);
+    const token = DurableDeferred.tokenFromExecutionId(waitPoint, {
+      flow: instance.flow,
+      executionId: instance.executionId
+    });
+    yield* (0, import_WaitingAnnotation.annotateWaiting)({ reason: "event", token });
+    return yield* DurableDeferred.await(waitPoint);
+  })
+);
+//# sourceMappingURL=WaitFor.js.map

package/dist/cjs/WaitFor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/WaitFor.ts"],
+  "sourcesContent": ["/**\n * The system wait point, as an ordinary declared action.\n *\n * `docs/concepts/flows-and-actions.md` names wait-for-event the\n * other half of the timer gap and says how to close it: ship it over the\n * existing `DurableDeferred`, so an external signal is a visible, keyed plan\n * node. That is this module. {@link action} is a plain `Action.make`\n * declaration \u2014 catalogable, `.call()`-able, one node in the built plan \u2014 and\n * {@link layer} is the implementation.\n *\n * Nothing about resolution is new. The wait is a `DurableDeferred`, so whoever\n * satisfies it completes it the way every other durable deferred is completed:\n * a token, and `DurableDeferred.succeed`, `fail`, `failCause`, or `done`.\n * {@link deferred} is how a resolver names the same wait point the action\n * awaits. The park is declared through the ordinary waiting vocabulary\n * ({@link module:WaitingAnnotation.annotateWaiting}) under `event`, carrying\n * that token as the compare-and-swap material a wake handler matches. Replay is\n * the deferred's: once a result is recorded, a re-driven round reads it and\n * runs through instead of parking again.\n *\n * @since 0.1.0\n */\n\nimport type * as Crypto from \"effect/Crypto\"\nimport * as Effect from \"effect/Effect\"\nimport type * as Layer from \"effect/Layer\"\nimport * as Schema from \"effect/Schema\"\nimport * as Action from \"./Action/index.ts\"\nimport * as DurableDeferred from \"./DurableDeferred.ts\"\nimport { FlowInstance } from \"./FlowRuntime/FlowInstance.ts\"\nimport type { FlowRuntime } from \"./FlowRuntime/FlowRuntime.ts\"\nimport { annotateWaiting } from \"./FlowRuntime/WaitingAnnotation.ts\"\n\n/**\n * A wait whose payload does not name exactly one reachable wait point.\n *\n * A payload names the wait point by `name`, relative to the running execution,\n * or by an absolute `token`. Naming both, or neither, leaves nothing to await;\n * a token that does not parse names nothing either; and a token addressed to a\n * different flow or a different execution names a wait point this execution\n * cannot observe, because a durable deferred result is recorded against the\n * flow and execution that own it.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class WaitForRequestInvalid extends Schema.TaggedError<WaitForRequestInvalid>()(\n  \"@smthrs/flow/WaitForRequestInvalid\",\n  {\n    code: Schema.Literals([\n      \"missing_target\",\n      \"ambiguous_target\",\n      \"malformed_token\",\n      \"foreign_execution\"\n    ]),\n    message: Schema.String\n  }\n) {}\n\n/**\n * The tag the wait declaration is catalogued and resolved under.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const tag = \"system/wait-for\"\n\n/**\n * The durable deferred a named wait point resolves through.\n *\n * This is the resolver's half of {@link action}: the value to hand\n * `DurableDeferred.tokenFromExecutionId` and `DurableDeferred.succeed`, so a\n * wait that a body declared by name is completed through the existing deferred\n * completion path rather than a second one.\n *\n * ```ts\n * const gate = WaitFor.deferred(\"approval\")\n * const token = DurableDeferred.tokenFromExecutionId(gate, { flow, executionId })\n * yield* DurableDeferred.succeed(gate, { token, value: { approved: true } })\n * ```\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const deferred = (name: string): DurableDeferred.DurableDeferred<typeof Schema.Json> =>\n  DurableDeferred.make(`WaitFor/${name}`, { success: Schema.Json })\n\n/**\n * The declared wait action: a wait point named by `name` or by `token`.\n *\n * **When to use**\n *\n * Use it in a body wherever a round has to wait for something outside the run \u2014\n * an approval, a webhook, a human \u2014 `WaitFor.action.call({ name: \"approval\"\n * })`. The node settles with whatever value resolved the wait, so downstream\n * steps read it the way they read any other step result.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const action: Action.Declared<\n  typeof tag,\n  Schema.Struct<{\n    readonly token: Schema.optional<Schema.String>\n    readonly name: Schema.optional<Schema.String>\n  }>,\n  typeof Schema.Json,\n  typeof WaitForRequestInvalid,\n  never\n> = Action.makeSystem(tag, {\n  payload: {\n    token: Schema.optional(Schema.String),\n    name: Schema.optional(Schema.String)\n  },\n  success: Schema.Json,\n  error: WaitForRequestInvalid,\n  tier: \"sealed\"\n})\n\n/**\n * The deferred name a token addresses, refused when the token does not parse.\n *\n * @private\n */\nconst parseToken = (token: string): Effect.Effect<DurableDeferred.TokenParsed, WaitForRequestInvalid> =>\n  Effect.mapError(\n    DurableDeferred.TokenParsed.parse(token),\n    (error) =>\n      new WaitForRequestInvalid({\n        code: \"malformed_token\",\n        message: `${tag} was called with a token that is not a durable deferred token. ${error.message}`\n      })\n  )\n\n/**\n * The wait point a payload names, resolved against the running execution.\n *\n * DECIDED: a payload names EXACTLY one of `name`\n * and `token`, and a token must address the execution that is waiting. A\n * deferred result is recorded against (flow name, execution id, deferred name)\n * and read back the same way, so awaiting a foreign token would park forever\n * while the value it names was recorded elsewhere; refusing it names the\n * mistake instead. BOTH halves of the owning execution's identity are compared:\n * a token carries its own flow name, so a same-execution token minted for\n * another flow completes under that flow while this one reads under its own,\n * which is the same permanent park by a different route.\n *\n * DECIDED: a wait point is addressed by the\n * PAYLOAD, and the per-dispatch identity {@link module:Sleep} derives its clock\n * from is deliberately NOT applied here. A wait is a rendezvous with something\n * outside the run, and a resolver has to name the same wait point to complete\n * it, so the name is the author's and two calls naming one wait point await one\n * fact \u2014 which is the intended reading, not an aliasing bug. A sleep has no\n * counterpart to agree with, which is why it takes its identity from the node.\n *\n * @private\n */\nconst target = (\n  payload: { readonly token?: string | undefined; readonly name?: string | undefined },\n  flowName: string,\n  executionId: string\n): Effect.Effect<DurableDeferred.DurableDeferred<typeof Schema.Json>, WaitForRequestInvalid> => {\n  if (payload.token !== undefined && payload.name !== undefined) {\n    return Effect.fail(\n      new WaitForRequestInvalid({\n        code: \"ambiguous_target\",\n        message: `${tag} was called with both \"token\" and \"name\". A wait names one wait point: ` +\n          \"a name relative to this execution, or an absolute token.\"\n      })\n    )\n  }\n  if (payload.name !== undefined) return Effect.succeed(deferred(payload.name))\n  if (payload.token !== undefined) {\n    return Effect.flatMap(\n      parseToken(payload.token),\n      (parsed) =>\n        parsed.flowName !== flowName || parsed.executionId !== executionId\n          ? Effect.fail(\n            new WaitForRequestInvalid({\n              code: \"foreign_execution\",\n              message: `${tag} was called with a token addressed to flow \"${parsed.flowName}\" in execution ` +\n                `\"${parsed.executionId}\", but it is running as flow \"${flowName}\" in execution ` +\n                `\"${executionId}\". A durable deferred result is recorded against the execution that owns it, ` +\n                \"so only that execution can await it.\"\n            })\n          )\n          : Effect.succeed(\n            DurableDeferred.make(parsed.deferredName, { success: Schema.Json })\n          )\n    )\n  }\n  return Effect.fail(\n    new WaitForRequestInvalid({\n      code: \"missing_target\",\n      message: `${tag} was called with neither \"token\" nor \"name\", so there is no wait point to await.`\n    })\n  )\n}\n\n/**\n * The wait implementation: park under `event` with the wake token, and settle\n * with the value that resolved the wait.\n *\n * Provide it beside the other action implementation layers a body calls, over\n * the {@link module:Implementations.layerImplementations} table they file\n * themselves in:\n *\n * ```ts\n * Layer.mergeAll(WaitFor.layer, Interpreter.layer(Pipeline)).pipe(\n *   Layer.provideMerge(Action.layerImplementations)\n * )\n * ```\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<never, never, Crypto.Crypto | FlowRuntime> = action.toLayer((payload) =>\n  Effect.gen(function*() {\n    const instance = yield* FlowInstance\n    const waitPoint = yield* target(payload, instance.flow._tag, instance.executionId)\n    const token = DurableDeferred.tokenFromExecutionId(waitPoint, {\n      flow: instance.flow,\n      executionId: instance.executionId\n    })\n    yield* annotateWaiting({ reason: \"event\", token })\n    return yield* DurableDeferred.await(waitPoint)\n  })\n)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBA,aAAwB;AAExB,aAAwB;AACxB,aAAwB;AACxB,sBAAiC;AACjC,0BAA6B;AAE7B,+BAAgC;AAezB,MAAM,8BAA8B,OAAO,YAAmC;AAAA,EACnF;AAAA,EACA;AAAA,IACE,MAAM,OAAO,SAAS;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,IACD,SAAS,OAAO;AAAA,EAClB;AACF,EAAE;AAAC;AAQI,MAAM,MAAM;AAmBZ,MAAM,WAAW,CAAC,SACvB,gBAAgB,KAAK,WAAW,IAAI,IAAI,EAAE,SAAS,OAAO,KAAK,CAAC;AAe3D,MAAM,SAST,OAAO,WAAW,KAAK;AAAA,EACzB,SAAS;AAAA,IACP,OAAO,OAAO,SAAS,OAAO,MAAM;AAAA,IACpC,MAAM,OAAO,SAAS,OAAO,MAAM;AAAA,EACrC;AAAA,EACA,SAAS,OAAO;AAAA,EAChB,OAAO;AAAA,EACP,MAAM;AACR,CAAC;AAOD,MAAM,aAAa,CAAC,UAClB,OAAO;AAAA,EACL,gBAAgB,YAAY,MAAM,KAAK;AAAA,EACvC,CAAC,UACC,IAAI,sBAAsB;AAAA,IACxB,MAAM;AAAA,IACN,SAAS,GAAG,GAAG,kEAAkE,MAAM,OAAO;AAAA,EAChG,CAAC;AACL;AAyBF,MAAM,SAAS,CACb,SACA,UACA,gBAC8F;AAC9F,MAAI,QAAQ,UAAU,UAAa,QAAQ,SAAS,QAAW;AAC7D,WAAO,OAAO;AAAA,MACZ,IAAI,sBAAsB;AAAA,QACxB,MAAM;AAAA,QACN,SAAS,GAAG,GAAG;AAAA,MAEjB,CAAC;AAAA,IACH;AAAA,EACF;AACA,MAAI,QAAQ,SAAS,OAAW,QAAO,OAAO,QAAQ,SAAS,QAAQ,IAAI,CAAC;AAC5E,MAAI,QAAQ,UAAU,QAAW;AAC/B,WAAO,OAAO;AAAA,MACZ,WAAW,QAAQ,KAAK;AAAA,MACxB,CAAC,WACC,OAAO,aAAa,YAAY,OAAO,gBAAgB,cACnD,OAAO;AAAA,QACP,IAAI,sBAAsB;AAAA,UACxB,MAAM;AAAA,UACN,SAAS,GAAG,GAAG,+CAA+C,OAAO,QAAQ,mBACvE,OAAO,WAAW,iCAAiC,QAAQ,mBAC3D,WAAW;AAAA,QAEnB,CAAC;AAAA,MACH,IACE,OAAO;AAAA,QACP,gBAAgB,KAAK,OAAO,cAAc,EAAE,SAAS,OAAO,KAAK,CAAC;AAAA,MACpE;AAAA,IACN;AAAA,EACF;AACA,SAAO,OAAO;AAAA,IACZ,IAAI,sBAAsB;AAAA,MACxB,MAAM;AAAA,MACN,SAAS,GAAG,GAAG;AAAA,IACjB,CAAC;AAAA,EACH;AACF;AAmBO,MAAM,QAAgE,OAAO;AAAA,EAAQ,CAAC,YAC3F,OAAO,IAAI,aAAY;AACrB,UAAM,WAAW,OAAO;AACxB,UAAM,YAAY,OAAO,OAAO,SAAS,SAAS,KAAK,MAAM,SAAS,WAAW;AACjF,UAAM,QAAQ,gBAAgB,qBAAqB,WAAW;AAAA,MAC5D,MAAM,SAAS;AAAA,MACf,aAAa,SAAS;AAAA,IACxB,CAAC;AACD,eAAO,0CAAgB,EAAE,QAAQ,SAAS,MAAM,CAAC;AACjD,WAAO,OAAO,gBAAgB,MAAM,SAAS;AAAA,EAC/C,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @since 0.1.0
+ */
+/**
+ * Durable action definitions and combinators.
+ *
+ * @since 0.1.0
+ */
+export * as Action from "./Action/index.ts";
+/**
+ * Durable clock and timer services.
+ *
+ * @since 0.1.0
+ */
+export * as Deadline from "./Deadline.ts";
+export * as DurableClock from "./DurableClock.ts";
+/**
+ * Durable deferred values.
+ *
+ * @since 0.1.0
+ */
+export * as DurableDeferred from "./DurableDeferred.ts";
+/**
+ * Durable queues.
+ *
+ * @since 0.1.0
+ */
+export * as DurableQueue from "./DurableQueue.ts";
+/**
+ * Durable flow definitions.
+ *
+ * @since 0.1.0
+ */
+export * as Flow from "./Flow/index.ts";
+/**
+ * The execution contract flow authoring APIs are written against.
+ *
+ * @since 0.1.0
+ */
+export * as FlowRuntime from "./FlowRuntime/index.ts";
+/**
+ * One typed fault for every failure, and the response table that reads it.
+ *
+ * @since 1.0.0
+ */
+export * as Fault from "./Fault.ts";
+/**
+ * External workers observed through durable actions and timers.
+ *
+ * @since 1.0.0
+ */
+export * as ExternalJob from "./ExternalJob.ts";
+/**
+ * Plan-time graph building from flow declarations.
+ *
+ * @since 0.1.0
+ */
+export * as Graph from "./Graph.ts";
+/**
+ * Asking a person something: typed answers, re-asking, and a deadline.
+ *
+ * @since 0.1.0
+ */
+export * as HumanTask from "./HumanTask.ts";
+/**
+ * Execution of a flow body, and the layer that registers it.
+ *
+ * @since 0.1.0
+ */
+export * as Interpreter from "./Interpreter.ts";
+/**
+ * The durable poller: attempts as rounds, waits as durable timers.
+ *
+ * @since 0.1.0
+ */
+export * as Poll from "./Poll.ts";
+/**
+ * The stall breaker: rounds whose tree, failing checks, or output held still.
+ *
+ * @since 1.0.0
+ */
+export * as Stall from "./Stall.ts";
+/**
+ * Retry policy models and constructors.
+ *
+ * @since 0.1.0
+ */
+export * as RetryPolicy from "./RetryPolicy.ts";
+/**
+ * The system timer action and its implementation layer.
+ *
+ * @since 0.1.0
+ */
+export * as Sleep from "./Sleep.ts";
+/**
+ * Stable step identity construction.
+ *
+ * @since 0.1.0
+ */
+export * as StepIdentity from "./Action/StepIdentity.ts";
+/**
+ * The system wait-point action and its implementation layer.
+ *
+ * @since 0.1.0
+ */
+export * as WaitFor from "./WaitFor.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;GAIG;AACH,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAE3C;;;;GAIG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;;GAIG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD;;;;GAIG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;;GAIG;AACH,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAA;AAEvC;;;;GAIG;AACH,OAAO,KAAK,WAAW,MAAM,wBAAwB,CAAA;AAErD;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;GAIG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;GAIG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;GAIG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;;GAIG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;GAIG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;GAIG;AACH,OAAO,KAAK,YAAY,MAAM,0BAA0B,CAAA;AAExD;;;;GAIG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  Action: () => Action,
+  Deadline: () => Deadline,
+  DurableClock: () => DurableClock,
+  DurableDeferred: () => DurableDeferred,
+  DurableQueue: () => DurableQueue,
+  ExternalJob: () => ExternalJob,
+  Fault: () => Fault,
+  Flow: () => Flow,
+  FlowRuntime: () => FlowRuntime,
+  Graph: () => Graph,
+  HumanTask: () => HumanTask,
+  Interpreter: () => Interpreter,
+  Poll: () => Poll,
+  RetryPolicy: () => RetryPolicy,
+  Sleep: () => Sleep,
+  Stall: () => Stall,
+  StepIdentity: () => StepIdentity,
+  WaitFor: () => WaitFor
+});
+module.exports = __toCommonJS(index_exports);
+var Action = __toESM(require("./Action/index.js"), 1);
+var Deadline = __toESM(require("./Deadline.js"), 1);
+var DurableClock = __toESM(require("./DurableClock.js"), 1);
+var DurableDeferred = __toESM(require("./DurableDeferred.js"), 1);
+var DurableQueue = __toESM(require("./DurableQueue.js"), 1);
+var Flow = __toESM(require("./Flow/index.js"), 1);
+var FlowRuntime = __toESM(require("./FlowRuntime/index.js"), 1);
+var Fault = __toESM(require("./Fault.js"), 1);
+var ExternalJob = __toESM(require("./ExternalJob.js"), 1);
+var Graph = __toESM(require("./Graph.js"), 1);
+var HumanTask = __toESM(require("./HumanTask.js"), 1);
+var Interpreter = __toESM(require("./Interpreter.js"), 1);
+var Poll = __toESM(require("./Poll.js"), 1);
+var Stall = __toESM(require("./Stall.js"), 1);
+var RetryPolicy = __toESM(require("./RetryPolicy.js"), 1);
+var Sleep = __toESM(require("./Sleep.js"), 1);
+var StepIdentity = __toESM(require("./Action/StepIdentity.js"), 1);
+var WaitFor = __toESM(require("./WaitFor.js"), 1);
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * @since 0.1.0\n */\n\n/**\n * Durable action definitions and combinators.\n *\n * @since 0.1.0\n */\nexport * as Action from \"./Action/index.ts\"\n\n/**\n * Durable clock and timer services.\n *\n * @since 0.1.0\n */\nexport * as Deadline from \"./Deadline.ts\"\nexport * as DurableClock from \"./DurableClock.ts\"\n\n/**\n * Durable deferred values.\n *\n * @since 0.1.0\n */\nexport * as DurableDeferred from \"./DurableDeferred.ts\"\n\n/**\n * Durable queues.\n *\n * @since 0.1.0\n */\nexport * as DurableQueue from \"./DurableQueue.ts\"\n\n/**\n * Durable flow definitions.\n *\n * @since 0.1.0\n */\nexport * as Flow from \"./Flow/index.ts\"\n\n/**\n * The execution contract flow authoring APIs are written against.\n *\n * @since 0.1.0\n */\nexport * as FlowRuntime from \"./FlowRuntime/index.ts\"\n\n/**\n * One typed fault for every failure, and the response table that reads it.\n *\n * @since 1.0.0\n */\nexport * as Fault from \"./Fault.ts\"\n\n/**\n * External workers observed through durable actions and timers.\n *\n * @since 1.0.0\n */\nexport * as ExternalJob from \"./ExternalJob.ts\"\n\n/**\n * Plan-time graph building from flow declarations.\n *\n * @since 0.1.0\n */\nexport * as Graph from \"./Graph.ts\"\n\n/**\n * Asking a person something: typed answers, re-asking, and a deadline.\n *\n * @since 0.1.0\n */\nexport * as HumanTask from \"./HumanTask.ts\"\n\n/**\n * Execution of a flow body, and the layer that registers it.\n *\n * @since 0.1.0\n */\nexport * as Interpreter from \"./Interpreter.ts\"\n\n/**\n * The durable poller: attempts as rounds, waits as durable timers.\n *\n * @since 0.1.0\n */\nexport * as Poll from \"./Poll.ts\"\n\n/**\n * The stall breaker: rounds whose tree, failing checks, or output held still.\n *\n * @since 1.0.0\n */\nexport * as Stall from \"./Stall.ts\"\n\n/**\n * Retry policy models and constructors.\n *\n * @since 0.1.0\n */\nexport * as RetryPolicy from \"./RetryPolicy.ts\"\n\n/**\n * The system timer action and its implementation layer.\n *\n * @since 0.1.0\n */\nexport * as Sleep from \"./Sleep.ts\"\n\n/**\n * Stable step identity construction.\n *\n * @since 0.1.0\n */\nexport * as StepIdentity from \"./Action/StepIdentity.ts\"\n\n/**\n * The system wait-point action and its implementation layer.\n *\n * @since 0.1.0\n */\nexport * as WaitFor from \"./WaitFor.ts\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,aAAwB;AAOxB,eAA0B;AAC1B,mBAA8B;AAO9B,sBAAiC;AAOjC,mBAA8B;AAO9B,WAAsB;AAOtB,kBAA6B;AAO7B,YAAuB;AAOvB,kBAA6B;AAO7B,YAAuB;AAOvB,gBAA2B;AAO3B,kBAA6B;AAO7B,WAAsB;AAOtB,YAAuB;AAOvB,kBAA6B;AAO7B,YAAuB;AAOvB,mBAA8B;AAO9B,cAAyB;",
+  "names": []
+}

package/dist/cjs/internal/BoundedJson.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Human-task diagnostics over the shared inert JSON boundary.
+ * @since 1.0.0
+ */
+import * as BoundedJson from "@smthrs/canonical/BoundedJson";
+/** Resource limits for one human-task value.
+ * @private
+ * @since 1.0.0
+ */
+export type Limits = Required<Omit<BoundedJson.Limits, "maxTotalMembers">>;
+/** Encoded JSON bytes, without allocating an encoded copy.
+ * @private
+ * @since 1.0.0
+ */
+export declare const encodedStringBytes: (value: string, maximum?: number) => number | undefined;
+/** Whether text is well-formed and fits its encoded byte budget.
+ * @private
+ * @since 1.0.0
+ */
+export declare const textFits: (value: string, maximum: number) => boolean;
+/** Admits a detached snapshot and gives failures a bounded field path.
+ * @private
+ * @since 1.0.0
+ */
+export declare const admit: (input: unknown, limits: Limits) => {
+    ok: true;
+    value: BoundedJson.Json;
+    complaint?: never;
+} | {
+    ok: false;
+    complaint: string;
+    value?: never;
+};
+/**
+ * Returns a Unicode-scalar-safe bounded prefix.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare function scalarPrefix(value: string, maximumCodeUnits: number): string;
+/**
+ * Renders an untrusted value without invoking its code or allocating from its full size.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const render: (value: unknown, maximumCodeUnits: number) => string;
+//# sourceMappingURL=BoundedJson.d.ts.map

package/dist/cjs/internal/BoundedJson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedJson.d.ts","sourceRoot":"","sources":["../../../src/internal/BoundedJson.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,WAAW,MAAM,+BAA+B,CAAA;AAE5D;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAA;AAE1E;;;GAGG;AACH,eAAO,MAAM,kBAAkB,yDAAiC,CAAA;AAEhE;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,EAAE,SAAS,MAAM,KAAG,OAA2D,CAAA;AAErH;;;GAGG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,OAAO,EAAE,QAAQ,MAAM;;;;;;;;CAYnD,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAwB5E;AAED;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,EAAE,kBAAkB,MAAM,KAAG,MA2BjE,CAAA"}

package/dist/cjs/internal/BoundedJson.js

@@ -0,0 +1,96 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var BoundedJson_exports = {};
+__export(BoundedJson_exports, {
+  admit: () => admit,
+  encodedStringBytes: () => encodedStringBytes,
+  render: () => render,
+  scalarPrefix: () => scalarPrefix,
+  textFits: () => textFits
+});
+module.exports = __toCommonJS(BoundedJson_exports);
+var BoundedJson = __toESM(require("@smthrs/canonical/BoundedJson"), 1);
+const encodedStringBytes = BoundedJson.encodedStringBytes;
+const textFits = (value, maximum) => encodedStringBytes(value, maximum) !== void 0;
+const admit = (input, limits) => {
+  const result = BoundedJson.admit(input, limits);
+  if (result.ok) return { ok: true, value: result.value };
+  const at = result.path.length === 0 ? "the value" : `"${result.path.map((segment) => scalarPrefix(segment, 64)).join(".")}"`;
+  const complaint = result.code === "string" ? `is not well-formed text within ${limits.maxStringBytes} encoded bytes` : result.code === "nodes" ? `makes the value too large to check: it contains more than ${limits.maxNodes} JSON values` : result.complaint;
+  return { ok: false, complaint: `${at} ${complaint}.` };
+};
+function scalarPrefix(value, maximumCodeUnits) {
+  let output = "";
+  for (let index = 0; index < value.length; ) {
+    const unit = value.charCodeAt(index);
+    let next;
+    let width = 1;
+    if (unit >= 55296 && unit <= 56319) {
+      const low = value.charCodeAt(index + 1);
+      if (low >= 56320 && low <= 57343) {
+        next = value.slice(index, index + 2);
+        width = 2;
+      } else {
+        next = "\uFFFD";
+      }
+    } else if (unit >= 56320 && unit <= 57343) {
+      next = "\uFFFD";
+    } else {
+      next = value[index];
+    }
+    if (output.length + next.length > maximumCodeUnits) break;
+    output += next;
+    index += width;
+  }
+  return output;
+}
+const render = (value, maximumCodeUnits) => {
+  if (typeof value === "string") {
+    const prefix2 = scalarPrefix(value, Math.max(0, maximumCodeUnits - 2));
+    const quoted = JSON.stringify(prefix2);
+    return prefix2.length < value.length ? `${quoted} [${value.length - prefix2.length} characters dropped]` : quoted;
+  }
+  if (typeof value === "bigint") return scalarPrefix(`${value}n`, maximumCodeUnits);
+  if (typeof value === "symbol") return "[symbol]";
+  if (typeof value === "function") return "[function]";
+  if (value === void 0) return "[undefined]";
+  const admitted = admit(value, {
+    maxNodes: 64,
+    maxDepth: 6,
+    maxBytes: Math.max(64, maximumCodeUnits * 4),
+    maxStringBytes: Math.max(64, maximumCodeUnits * 4),
+    maxKeyBytes: Math.max(32, maximumCodeUnits * 2),
+    maxMembers: 32
+  });
+  if (!admitted.ok) return scalarPrefix(`[${admitted.complaint}]`, maximumCodeUnits);
+  const rendered = JSON.stringify(admitted.value);
+  const prefix = scalarPrefix(rendered, maximumCodeUnits);
+  return prefix.length < rendered.length ? `${prefix} [${rendered.length - prefix.length} characters dropped]` : prefix;
+};
+//# sourceMappingURL=BoundedJson.js.map

package/dist/cjs/internal/BoundedJson.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/BoundedJson.ts"],
+  "sourcesContent": ["/**\n * Human-task diagnostics over the shared inert JSON boundary.\n * @since 1.0.0\n */\n\nimport * as BoundedJson from \"@smthrs/canonical/BoundedJson\"\n\n/** Resource limits for one human-task value.\n * @private\n * @since 1.0.0\n */\nexport type Limits = Required<Omit<BoundedJson.Limits, \"maxTotalMembers\">>\n\n/** Encoded JSON bytes, without allocating an encoded copy.\n * @private\n * @since 1.0.0\n */\nexport const encodedStringBytes = BoundedJson.encodedStringBytes\n\n/** Whether text is well-formed and fits its encoded byte budget.\n * @private\n * @since 1.0.0\n */\nexport const textFits = (value: string, maximum: number): boolean => encodedStringBytes(value, maximum) !== undefined\n\n/** Admits a detached snapshot and gives failures a bounded field path.\n * @private\n * @since 1.0.0\n */\nexport const admit = (input: unknown, limits: Limits) => {\n  const result = BoundedJson.admit(input, limits)\n  if (result.ok) return { ok: true as const, value: result.value }\n  const at = result.path.length === 0\n    ? \"the value\"\n    : `\"${result.path.map((segment) => scalarPrefix(segment, 64)).join(\".\")}\"`\n  const complaint = result.code === \"string\"\n    ? `is not well-formed text within ${limits.maxStringBytes} encoded bytes`\n    : result.code === \"nodes\"\n    ? `makes the value too large to check: it contains more than ${limits.maxNodes} JSON values`\n    : result.complaint\n  return { ok: false as const, complaint: `${at} ${complaint}.` }\n}\n\n/**\n * Returns a Unicode-scalar-safe bounded prefix.\n *\n * @private\n * @since 1.0.0\n */\nexport function scalarPrefix(value: string, maximumCodeUnits: number): string {\n  let output = \"\"\n  for (let index = 0; index < value.length;) {\n    const unit = value.charCodeAt(index)\n    let next: string\n    let width = 1\n    if (unit >= 0xd800 && unit <= 0xdbff) {\n      const low = value.charCodeAt(index + 1)\n      if (low >= 0xdc00 && low <= 0xdfff) {\n        next = value.slice(index, index + 2)\n        width = 2\n      } else {\n        next = \"\\ufffd\"\n      }\n    } else if (unit >= 0xdc00 && unit <= 0xdfff) {\n      next = \"\\ufffd\"\n    } else {\n      next = value[index]!\n    }\n    if (output.length + next.length > maximumCodeUnits) break\n    output += next\n    index += width\n  }\n  return output\n}\n\n/**\n * Renders an untrusted value without invoking its code or allocating from its full size.\n *\n * @private\n * @since 1.0.0\n */\nexport const render = (value: unknown, maximumCodeUnits: number): string => {\n  if (typeof value === \"string\") {\n    const prefix = scalarPrefix(value, Math.max(0, maximumCodeUnits - 2))\n    const quoted = JSON.stringify(prefix)\n    return prefix.length < value.length\n      ? `${quoted} [${value.length - prefix.length} characters dropped]`\n      : quoted\n  }\n  if (typeof value === \"bigint\") return scalarPrefix(`${value}n`, maximumCodeUnits)\n  if (typeof value === \"symbol\") return \"[symbol]\"\n  if (typeof value === \"function\") return \"[function]\"\n  if (value === undefined) return \"[undefined]\"\n\n  const admitted = admit(value, {\n    maxNodes: 64,\n    maxDepth: 6,\n    maxBytes: Math.max(64, maximumCodeUnits * 4),\n    maxStringBytes: Math.max(64, maximumCodeUnits * 4),\n    maxKeyBytes: Math.max(32, maximumCodeUnits * 2),\n    maxMembers: 32\n  })\n  if (!admitted.ok) return scalarPrefix(`[${admitted.complaint}]`, maximumCodeUnits)\n  const rendered = JSON.stringify(admitted.value)\n  const prefix = scalarPrefix(rendered, maximumCodeUnits)\n  return prefix.length < rendered.length\n    ? `${prefix} [${rendered.length - prefix.length} characters dropped]`\n    : prefix\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,kBAA6B;AAYtB,MAAM,qBAAqB,YAAY;AAMvC,MAAM,WAAW,CAAC,OAAe,YAA6B,mBAAmB,OAAO,OAAO,MAAM;AAMrG,MAAM,QAAQ,CAAC,OAAgB,WAAmB;AACvD,QAAM,SAAS,YAAY,MAAM,OAAO,MAAM;AAC9C,MAAI,OAAO,GAAI,QAAO,EAAE,IAAI,MAAe,OAAO,OAAO,MAAM;AAC/D,QAAM,KAAK,OAAO,KAAK,WAAW,IAC9B,cACA,IAAI,OAAO,KAAK,IAAI,CAAC,YAAY,aAAa,SAAS,EAAE,CAAC,EAAE,KAAK,GAAG,CAAC;AACzE,QAAM,YAAY,OAAO,SAAS,WAC9B,kCAAkC,OAAO,cAAc,mBACvD,OAAO,SAAS,UAChB,6DAA6D,OAAO,QAAQ,iBAC5E,OAAO;AACX,SAAO,EAAE,IAAI,OAAgB,WAAW,GAAG,EAAE,IAAI,SAAS,IAAI;AAChE;AAQO,SAAS,aAAa,OAAe,kBAAkC;AAC5E,MAAI,SAAS;AACb,WAAS,QAAQ,GAAG,QAAQ,MAAM,UAAS;AACzC,UAAM,OAAO,MAAM,WAAW,KAAK;AACnC,QAAI;AACJ,QAAI,QAAQ;AACZ,QAAI,QAAQ,SAAU,QAAQ,OAAQ;AACpC,YAAM,MAAM,MAAM,WAAW,QAAQ,CAAC;AACtC,UAAI,OAAO,SAAU,OAAO,OAAQ;AAClC,eAAO,MAAM,MAAM,OAAO,QAAQ,CAAC;AACnC,gBAAQ;AAAA,MACV,OAAO;AACL,eAAO;AAAA,MACT;AAAA,IACF,WAAW,QAAQ,SAAU,QAAQ,OAAQ;AAC3C,aAAO;AAAA,IACT,OAAO;AACL,aAAO,MAAM,KAAK;AAAA,IACpB;AACA,QAAI,OAAO,SAAS,KAAK,SAAS,iBAAkB;AACpD,cAAU;AACV,aAAS;AAAA,EACX;AACA,SAAO;AACT;AAQO,MAAM,SAAS,CAAC,OAAgB,qBAAqC;AAC1E,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAMA,UAAS,aAAa,OAAO,KAAK,IAAI,GAAG,mBAAmB,CAAC,CAAC;AACpE,UAAM,SAAS,KAAK,UAAUA,OAAM;AACpC,WAAOA,QAAO,SAAS,MAAM,SACzB,GAAG,MAAM,KAAK,MAAM,SAASA,QAAO,MAAM,yBAC1C;AAAA,EACN;AACA,MAAI,OAAO,UAAU,SAAU,QAAO,aAAa,GAAG,KAAK,KAAK,gBAAgB;AAChF,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,MAAI,OAAO,UAAU,WAAY,QAAO;AACxC,MAAI,UAAU,OAAW,QAAO;AAEhC,QAAM,WAAW,MAAM,OAAO;AAAA,IAC5B,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU,KAAK,IAAI,IAAI,mBAAmB,CAAC;AAAA,IAC3C,gBAAgB,KAAK,IAAI,IAAI,mBAAmB,CAAC;AAAA,IACjD,aAAa,KAAK,IAAI,IAAI,mBAAmB,CAAC;AAAA,IAC9C,YAAY;AAAA,EACd,CAAC;AACD,MAAI,CAAC,SAAS,GAAI,QAAO,aAAa,IAAI,SAAS,SAAS,KAAK,gBAAgB;AACjF,QAAM,WAAW,KAAK,UAAU,SAAS,KAAK;AAC9C,QAAM,SAAS,aAAa,UAAU,gBAAgB;AACtD,SAAO,OAAO,SAAS,SAAS,SAC5B,GAAG,MAAM,KAAK,SAAS,SAAS,OAAO,MAAM,yBAC7C;AACN;",
+  "names": ["prefix"]
+}