@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/internal/ExecutionSnapshotRelations.js

@@ -0,0 +1,105 @@
+"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 ExecutionSnapshotRelations_exports = {};
+__export(ExecutionSnapshotRelations_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(ExecutionSnapshotRelations_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+var import_RunStore = require("@smthrs/run-store/RunStore");
+var import_effect = require("effect");
+var Read = __toESM(require("./ExecutionSnapshotRead.js"), 1);
+const Kind = import_effect.Schema.Literals(["children", "rounds"]);
+const Options = import_effect.Schema.Struct({
+  runId: Read.Identifier,
+  kind: Kind,
+  cursor: import_effect.Schema.optionalKey(import_effect.Schema.String.check(import_effect.Schema.isMaxLength(32768))),
+  limit: import_effect.Schema.optionalKey(import_effect.Schema.Int.check(import_effect.Schema.isBetween({ minimum: 1, maximum: 200 })))
+});
+const Cursor = import_effect.Schema.fromJsonString(import_effect.Schema.Struct({
+  version: import_effect.Schema.Literal(1),
+  source: Read.Source,
+  runId: Read.Identifier,
+  kind: Kind,
+  ordinal: Read.Natural,
+  lastRunId: Read.Identifier
+}));
+const Relation = import_effect.Schema.Struct({ run_id: Read.Identifier, ordinal: Read.Natural });
+const make = (sql, read) => (options) => Read.boundary(
+  "ExecutionSnapshot.related",
+  import_effect.Effect.gen(function* () {
+    const input = yield* Read.decode(Options, options);
+    const cursor = input.cursor === void 0 ? null : yield* Read.decode(Cursor, input.cursor);
+    return yield* Read.transaction(
+      sql,
+      import_effect.Effect.gen(function* () {
+        const at = yield* Read.position(sql);
+        if (cursor !== null && (cursor.source !== at.source || cursor.runId !== input.runId || cursor.kind !== input.kind)) {
+          return yield* import_effect.Effect.fail(
+            new import_RunStore.RunStoreError({
+              method: "ExecutionSnapshot.related",
+              code: "invalid_run",
+              message: "relation cursor belongs to another query or source",
+              cause: cursor
+            })
+          );
+        }
+        const anchor = (yield* read([input.runId])).snapshots[0];
+        const limit = input.limit ?? 100;
+        const values = [input.runId];
+        const columns = input.kind === "children" ? ["seq", "child_id"] : ["COALESCE(round_ordinal, 0)", "run_id"];
+        const after = cursor === null ? "" : `AND (${columns.join(", ")}) > (?, ?)`;
+        if (cursor !== null) values.push(cursor.ordinal, cursor.lastRunId);
+        values.push(limit + 1);
+        const query = input.kind === "children" ? `SELECT child_id AS run_id, seq AS ordinal FROM flows_run_parents
+         WHERE parent_id = ? ${after} ORDER BY seq, child_id LIMIT ?` : `SELECT run_id, COALESCE(round_ordinal, 0) AS ordinal FROM flows_runs
+         WHERE execution_lineage = (SELECT execution_lineage FROM flows_runs WHERE run_id = ?)
+         ${after} ORDER BY COALESCE(round_ordinal, 0), run_id LIMIT ?`;
+        const rows = yield* Dialect.query(sql, query, values);
+        const decoded = yield* import_effect.Effect.forEach(rows, (row) => Read.decode(Relation, row));
+        const selected = decoded.slice(0, limit);
+        const batch = yield* read(selected.map((row) => row.run_id));
+        const last = selected[selected.length - 1];
+        return {
+          ...batch,
+          anchor,
+          cursor: decoded.length > limit ? JSON.stringify({
+            version: 1,
+            source: at.source,
+            runId: input.runId,
+            kind: input.kind,
+            ordinal: last.ordinal,
+            lastRunId: last.run_id
+          }) : null
+        };
+      })
+    );
+  })
+);
+//# sourceMappingURL=ExecutionSnapshotRelations.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/ExecutionSnapshotRelations.ts"],
+  "sourcesContent": ["/**\n * Page-scoped durable child and round enumeration.\n *\n * @since 1.0.0\n */\n\nimport * as Dialect from \"@smthrs/database/Dialect\"\nimport { RunStoreError } from \"@smthrs/run-store/RunStore\"\nimport { Effect, Schema } from \"effect\"\nimport type * as SqlClient from \"effect/unstable/sql/SqlClient\"\nimport type { Batch, Snapshot } from \"../ExecutionSnapshot.ts\"\nimport * as Read from \"./ExecutionSnapshotRead.ts\"\n\n/**\n * Child edges and trampoline rounds are different relations.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface RelatedOptions {\n  readonly runId: string\n  readonly kind: \"children\" | \"rounds\"\n  readonly cursor?: string\n  readonly limit?: number\n}\n/**\n * A requested anchor and its page, observed in one transaction.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface RelatedPage extends Batch {\n  readonly anchor: Snapshot\n  readonly cursor: string | null\n}\nconst Kind = Schema.Literals([\"children\", \"rounds\"])\nconst Options = Schema.Struct({\n  runId: Read.Identifier,\n  kind: Kind,\n  cursor: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(32768))),\n  limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 200 })))\n})\nconst Cursor = Schema.fromJsonString(Schema.Struct({\n  version: Schema.Literal(1),\n  source: Read.Source,\n  runId: Read.Identifier,\n  kind: Kind,\n  ordinal: Read.Natural,\n  lastRunId: Read.Identifier\n}))\nconst Relation = Schema.Struct({ run_id: Read.Identifier, ordinal: Read.Natural })\n\n/**\n * Builds a bounded relation reader over the shared snapshot port.\n *\n * @private\n * @since 1.0.0\n */\nexport const make = (\n  sql: SqlClient.SqlClient,\n  read: (ids: ReadonlyArray<string>) => Effect.Effect<Batch, RunStoreError>\n) =>\n(options: RelatedOptions): Effect.Effect<RelatedPage, RunStoreError> =>\n  Read.boundary(\n    \"ExecutionSnapshot.related\",\n    Effect.gen(function*() {\n      const input = yield* Read.decode(Options, options)\n      const cursor = input.cursor === undefined ? null : yield* Read.decode(Cursor, input.cursor)\n      return yield* Read.transaction(\n        sql,\n        Effect.gen(function*() {\n          const at = yield* Read.position(sql)\n          if (\n            cursor !== null &&\n            (cursor.source !== at.source || cursor.runId !== input.runId || cursor.kind !== input.kind)\n          ) {\n            return yield* Effect.fail(\n              new RunStoreError({\n                method: \"ExecutionSnapshot.related\",\n                code: \"invalid_run\",\n                message: \"relation cursor belongs to another query or source\",\n                cause: cursor\n              })\n            )\n          }\n          const anchor = (yield* read([input.runId])).snapshots[0]!\n          const limit = input.limit ?? 100\n          const values: Array<string | number | null> = [input.runId]\n          const columns = input.kind === \"children\" ? [\"seq\", \"child_id\"] : [\"COALESCE(round_ordinal, 0)\", \"run_id\"]\n          const after = cursor === null ? \"\" : `AND (${columns.join(\", \")}) > (?, ?)`\n          if (cursor !== null) values.push(cursor.ordinal, cursor.lastRunId)\n          values.push(limit + 1)\n          const query = input.kind === \"children\"\n            ? `SELECT child_id AS run_id, seq AS ordinal FROM flows_run_parents\n         WHERE parent_id = ? ${after} ORDER BY seq, child_id LIMIT ?`\n            : `SELECT run_id, COALESCE(round_ordinal, 0) AS ordinal FROM flows_runs\n         WHERE execution_lineage = (SELECT execution_lineage FROM flows_runs WHERE run_id = ?)\n         ${after} ORDER BY COALESCE(round_ordinal, 0), run_id LIMIT ?`\n          const rows = yield* Dialect.query(sql, query, values)\n          const decoded = yield* Effect.forEach(rows, (row) => Read.decode(Relation, row))\n          const selected = decoded.slice(0, limit)\n          const batch = yield* read(selected.map((row) => row.run_id))\n          const last = selected[selected.length - 1]\n          return {\n            ...batch,\n            anchor,\n            cursor: decoded.length > limit ?\n              JSON.stringify({\n                version: 1,\n                source: at.source,\n                runId: input.runId,\n                kind: input.kind,\n                ordinal: last!.ordinal,\n                lastRunId: last!.run_id\n              }) :\n              null\n          }\n        })\n      )\n    })\n  )\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,180 @@
+/**
+ * Encoding a round's settlement so a terminal transition can never be lost.
+ *
+ * A run row leaves `running` only when the driver has bytes to write into
+ * `state_json`, and those bytes come from the flow's OWN codec:
+ * `Flow.Result({ success: flow.successSchema, error: flow.errorSchema })`.
+ * A flow that declares `Schema.Unknown` for either channel — which is what
+ * `@smthrs/agent`'s `agent/run` declares, because an agent run carries
+ * whatever its body failed with — encodes that channel through `Schema.Json`,
+ * and `Schema.Json` rejects every class instance: `SchemaAST.isJson` walks the
+ * prototype chain and refuses anything that is not a plain object or an array.
+ * Every `Data.TaggedError` in this repository is therefore unencodable through
+ * such a flow, `HarnessError` and `ModelError` included.
+ *
+ * Guarding the terminal transition with `Effect.orDie` around that encode made
+ * an unencodable failure fatal for the drain instead of terminal for the run.
+ * The release validation caught the whole chain: `engine-store: coordinated
+ * drain failed for run-1 SchemaError: Expected JSON value at
+ * ["exit"]["cause"][0]["error"]`, `engine.db` `flows_runs` left at `running`
+ * with a dead owner pid while `control.db` said `failed`, and 86 seconds later
+ * the next process's stale-running sweep stole the row, opened a second turn,
+ * and billed the provider seat again for a run the control plane had closed.
+ *
+ * So the encode fails CLOSED here rather than open. The ordinary path is the
+ * flow's own codec, unchanged. When that codec rejects the value, the result
+ * is still written — as a JSON projection of what could not be encoded (tag,
+ * code, message, a stack summary, and nested causes) inside a `Die` reason —
+ * and the caller is told, through {@link EncodedResult.note}, that it must
+ * settle the run `failed`. A settled run is never re-executed, which is the
+ * durability promise the release policy states as one terminal write.
+ *
+ * The projection is built as plain JSON rather than re-encoded through a
+ * schema, so nothing in this module can raise. Its top-level object carries no
+ * `message` key on purpose: `Schema.Defect` revives any JSON object that has a
+ * string `message` as an `Error`, and a projection has to come back out of the
+ * row as the structured record it went in as.
+ *
+ * @since 0.1.0
+ */
+import { Flow } from "@smthrs/flow";
+import type * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+/**
+ * The `_tag` every projection carries, so a reader of `state_json` can tell a
+ * projected settlement from an encoded one without guessing.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const projectionTag = "flows/engine-store/UnencodableResult";
+/**
+ * How many `cause` links a value projection follows before it stops.
+ *
+ * A provider failure nests two or three deep (`HarnessError` over
+ * `ModelError` over the transport error); the bound exists so a self-linking
+ * cause chain cannot make the projection unbounded.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const maxCauseDepth = 4;
+/**
+ * How many leading stack lines a value projection keeps.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const maxStackLines = 4;
+/**
+ * How many characters any single projected string keeps.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const maxTextLength = 1024;
+/**
+ * Maximum cause reasons retained by the terminal fallback.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const maxReasonCount = 32;
+/**
+ * Maximum serialized bytes retained by one fallback projection.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const maxProjectionBytes: number;
+/**
+ * A JSON-safe summary of one unencodable value.
+ *
+ * `type` is the constructor name for an object and the `typeof` for anything
+ * else, so `ModelError` and `"boom"` are distinguishable in the row.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ValueProjection {
+    readonly type: string;
+    readonly message: string;
+    readonly tag?: string;
+    readonly code?: string;
+    readonly stack?: string;
+    readonly cause?: ValueProjection;
+}
+/**
+ * A JSON-safe summary of one `Cause` reason.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ReasonProjection {
+    readonly _tag: "Fail" | "Die" | "Interrupt";
+    readonly error?: ValueProjection;
+    readonly fiberId?: number;
+}
+/**
+ * The record written in place of a settlement the flow's codec rejected.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ResultProjection {
+    readonly _tag: typeof projectionTag;
+    readonly result: "Complete" | "Suspended" | "Handoff";
+    readonly note: string;
+    readonly reasons: ReadonlyArray<ReasonProjection>;
+    readonly value: ValueProjection | null;
+}
+/**
+ * What {@link encode} produces: the bytes to persist, and — only when the
+ * flow's codec rejected the settlement — the note describing why.
+ *
+ * A present `note` is an instruction to the caller, not decoration: the run
+ * must reach a terminal `failed` row, because the alternative is the row this
+ * lane exists to abolish, a `running` row whose owner is gone.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface EncodedResult {
+    readonly encoded: unknown;
+    readonly note: string | undefined;
+}
+/**
+ * Projects one value — a typed error, a defect, a success value, a handoff
+ * payload — into JSON.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare const projectValue: (value: unknown, depth?: number, seen?: WeakSet<object>) => ValueProjection;
+/**
+ * Projects every reason of a cause, in order. An absent cause — a
+ * `Flow.Suspended` that carries none — projects to no reasons.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare const projectCause: (cause: Cause.Cause<unknown> | undefined) => ReadonlyArray<ReasonProjection>;
+/**
+ * Projects a settlement the flow's codec rejected.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare const projectResult: (result: Flow.Result<unknown, unknown>, note: string) => ResultProjection;
+/**
+ * Encodes a round's settlement through the flow's own codec, and — when that
+ * codec rejects it — through a JSON projection instead.
+ *
+ * The returned effect has no error channel and dies for nothing: a caller on
+ * the terminal-transition path can always write the row it holds.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare const encode: (flow: Flow.Any, result: Flow.Result<unknown, unknown>) => Effect.Effect<EncodedResult>;
+//# sourceMappingURL=ExitEncoding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ExitEncoding.d.ts","sourceRoot":"","sources":["../../../src/internal/ExitEncoding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAEnC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAcvC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,yCAAyC,CAAA;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,IAAI,CAAA;AAE9B;;;;;GAKG;AACH,eAAO,MAAM,aAAa,IAAI,CAAA;AAE9B;;;;;GAKG;AACH,eAAO,MAAM,aAAa,OAAO,CAAA;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,KAAK,CAAA;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAAY,CAAA;AAE3C;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAA;CACjC;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,CAAA;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAA;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,aAAa,CAAA;IACnC,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,GAAG,SAAS,CAAA;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAA;IACjD,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAA;CACvC;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CAClC;AAwDD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,EAAE,cAAS,EAAE,sBAA4B,KAAG,eAgDtF,CAAA;AAeD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,SAAS,KACtC,aAAa,CAAC,gBAAgB,CAmBhC,CAAA;AAoBD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GACxB,QAAQ,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,MAAM,MAAM,KACX,gBAgDF,CAAA;AAuBD;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GACjB,MAAM,IAAI,CAAC,GAAG,EACd,QAAQ,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,KACpC,MAAM,CAAC,MAAM,CAAC,aAAa,CAiBK,CAAA"}

package/dist/cjs/internal/ExitEncoding.js

@@ -0,0 +1,236 @@
+"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 ExitEncoding_exports = {};
+__export(ExitEncoding_exports, {
+  encode: () => encode,
+  maxCauseDepth: () => maxCauseDepth,
+  maxProjectionBytes: () => maxProjectionBytes,
+  maxReasonCount: () => maxReasonCount,
+  maxStackLines: () => maxStackLines,
+  maxTextLength: () => maxTextLength,
+  projectCause: () => projectCause,
+  projectResult: () => projectResult,
+  projectValue: () => projectValue,
+  projectionTag: () => projectionTag
+});
+module.exports = __toCommonJS(ExitEncoding_exports);
+var import_flow = require("@smthrs/flow");
+var import_journal = require("@smthrs/journal");
+var Effect = __toESM(require("effect/Effect"), 1);
+var Exit = __toESM(require("effect/Exit"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var HostReflection = __toESM(require("./HostReflection.js"), 1);
+const { isNativeError, isProxy } = HostReflection.host;
+const projectionTag = "flows/engine-store/UnencodableResult";
+const maxCauseDepth = 4;
+const maxStackLines = 4;
+const maxTextLength = 1024;
+const maxReasonCount = 32;
+const maxProjectionBytes = 64 * 1024;
+const truncate = (value, limit) => value.length <= limit ? value : `${value.slice(0, limit)}\u2026`;
+const redactedText = (value) => truncate(import_journal.Redaction.redact(value), maxTextLength);
+const text = (value) => {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+      return Number.isFinite(value) ? `${value}` : `[number]`;
+    case "boolean":
+      return value ? "true" : "false";
+    case "bigint":
+      return `[bigint]`;
+    case "undefined":
+    case "symbol":
+    case "function":
+      return `[${typeof value}]`;
+    case "object":
+      return value === null ? "null" : Array.isArray(value) ? "[array]" : "[object]";
+  }
+};
+const minimalValue = () => ({ type: "object", message: "[unrepresentable]" });
+const ownData = (value, name) => {
+  const descriptor = Object.getOwnPropertyDescriptor(value, name);
+  return descriptor !== void 0 && "value" in descriptor ? descriptor.value : void 0;
+};
+const successExitPrototype = Object.getPrototypeOf(Exit.succeed(void 0));
+const failureExitPrototype = Object.getPrototypeOf(Exit.fail(void 0));
+const exitArguments = "~effect/Effect/args";
+const projectValue = (value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) => {
+  if (value === null || typeof value !== "object") {
+    return {
+      type: value === null ? "null" : typeof value,
+      message: redactedText(text(value))
+    };
+  }
+  if (isProxy(value) || seen.has(value)) return minimalValue();
+  seen.add(value);
+  try {
+    const message = ownData(value, "message");
+    const tag = ownData(value, "_tag");
+    const code = ownData(value, "code");
+    const stack = ownData(value, "stack");
+    const cause = ownData(value, "cause");
+    const projection = {
+      type: typeof tag === "string" && tag.length > 0 ? truncate(tag, maxTextLength) : isNativeError(value) ? "Error" : Array.isArray(value) ? "Array" : "object",
+      message: redactedText(typeof message === "string" ? message : text(value))
+    };
+    if (typeof tag === "string") projection.tag = truncate(tag, maxTextLength);
+    if (typeof code === "string") projection.code = truncate(code, maxTextLength);
+    if (typeof stack === "string") {
+      projection.stack = redactedText(stack.split("\n").slice(0, maxStackLines).join("\n"));
+    }
+    if (cause !== void 0 && depth < maxCauseDepth) {
+      projection.cause = projectValue(cause, depth + 1, seen);
+    }
+    return projection;
+  } catch {
+    return minimalValue();
+  }
+};
+const projectReason = (reason) => {
+  if (isProxy(reason)) return { _tag: "Die", error: minimalValue() };
+  try {
+    const tag = ownData(reason, "_tag");
+    if (tag === "Fail") return { _tag: "Fail", error: projectValue(ownData(reason, "error")) };
+    if (tag === "Die") return { _tag: "Die", error: projectValue(ownData(reason, "defect")) };
+    const fiberId = ownData(reason, "fiberId");
+    return typeof fiberId === "number" ? { _tag: "Interrupt", fiberId } : { _tag: "Interrupt" };
+  } catch {
+    return { _tag: "Die", error: minimalValue() };
+  }
+};
+const projectCause = (cause) => {
+  if (cause === void 0) return [];
+  if (isProxy(cause)) return [{ _tag: "Die", error: minimalValue() }];
+  try {
+    const reasons = ownData(cause, "reasons");
+    if (!Array.isArray(reasons) || isProxy(reasons)) {
+      return [{ _tag: "Die", error: minimalValue() }];
+    }
+    const projected = reasons.slice(0, maxReasonCount).map(projectReason);
+    if (reasons.length > maxReasonCount) {
+      projected.push({
+        _tag: "Die",
+        error: { type: "truncated", message: `[${reasons.length - maxReasonCount} reasons omitted]` }
+      });
+    }
+    return projected;
+  } catch {
+    return [{ _tag: "Die", error: minimalValue() }];
+  }
+};
+const minimalResult = (note) => ({
+  _tag: projectionTag,
+  result: "Complete",
+  note,
+  reasons: [{ _tag: "Die", error: minimalValue() }],
+  value: null
+});
+const withinBudget = (projection) => {
+  try {
+    return new TextEncoder().encode(JSON.stringify(projection)).length <= maxProjectionBytes ? projection : minimalResult("the rejected settlement exceeded the diagnostic projection bound");
+  } catch {
+    return minimalResult("the rejected settlement could not be projected");
+  }
+};
+const projectResult = (result, note) => {
+  note = truncate(note, maxTextLength);
+  if (isProxy(result)) return minimalResult(note);
+  try {
+    const tag = ownData(result, "_tag");
+    if (tag === "Suspended") {
+      return withinBudget({
+        _tag: projectionTag,
+        result: "Suspended",
+        note,
+        reasons: projectCause(ownData(result, "cause")),
+        value: null
+      });
+    }
+    if (tag === "Handoff") {
+      return withinBudget({
+        _tag: projectionTag,
+        result: "Handoff",
+        note,
+        reasons: [],
+        value: projectValue(ownData(result, "payload"))
+      });
+    }
+    const exit = ownData(result, "exit");
+    if (typeof exit !== "object" || exit === null || isProxy(exit)) return minimalResult(note);
+    const prototype = Object.getPrototypeOf(exit);
+    const argument = ownData(exit, exitArguments);
+    if (prototype !== successExitPrototype && prototype !== failureExitPrototype) return minimalResult(note);
+    return withinBudget(
+      prototype === successExitPrototype ? {
+        _tag: projectionTag,
+        result: "Complete",
+        note,
+        reasons: [],
+        value: projectValue(argument)
+      } : {
+        _tag: projectionTag,
+        result: "Complete",
+        note,
+        reasons: projectCause(argument),
+        value: null
+      }
+    );
+  } catch {
+    return minimalResult(note);
+  }
+};
+const degrade = (result, projection) => {
+  try {
+    if (!isProxy(result) && ownData(result, "_tag") === "Handoff") {
+      const flow = ownData(result, "flow");
+      if (typeof flow === "string") return { _tag: "Handoff", flow, payload: projection, capabilityCeilings: [[]] };
+    }
+  } catch {
+  }
+  return { _tag: "Complete", exit: { _tag: "Failure", cause: [{ _tag: "Die", defect: projection }] } };
+};
+const encode = (flow, result) => Schema.encodeEffect(
+  Schema.toCodecJson(import_flow.Flow.Result({
+    success: flow.successSchema,
+    error: flow.errorSchema
+  }))
+)(result).pipe(
+  Effect.map((encoded) => ({ encoded, note: void 0 })),
+  Effect.catchCause((_cause) => {
+    const note = "the flow result codec rejected the settlement";
+    return Effect.as(
+      Effect.logWarning(
+        `engine-store: the settlement of ${flow._tag} could not be encoded through its own codec; persisting a JSON projection so the run still settles`
+      ),
+      { encoded: degrade(result, projectResult(result, note)), note }
+    );
+  })
+);
+//# sourceMappingURL=ExitEncoding.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/ExitEncoding.ts"],
+  "sourcesContent": ["/**\n * Encoding a round's settlement so a terminal transition can never be lost.\n *\n * A run row leaves `running` only when the driver has bytes to write into\n * `state_json`, and those bytes come from the flow's OWN codec:\n * `Flow.Result({ success: flow.successSchema, error: flow.errorSchema })`.\n * A flow that declares `Schema.Unknown` for either channel \u2014 which is what\n * `@smthrs/agent`'s `agent/run` declares, because an agent run carries\n * whatever its body failed with \u2014 encodes that channel through `Schema.Json`,\n * and `Schema.Json` rejects every class instance: `SchemaAST.isJson` walks the\n * prototype chain and refuses anything that is not a plain object or an array.\n * Every `Data.TaggedError` in this repository is therefore unencodable through\n * such a flow, `HarnessError` and `ModelError` included.\n *\n * Guarding the terminal transition with `Effect.orDie` around that encode made\n * an unencodable failure fatal for the drain instead of terminal for the run.\n * The release validation caught the whole chain: `engine-store: coordinated\n * drain failed for run-1 SchemaError: Expected JSON value at\n * [\"exit\"][\"cause\"][0][\"error\"]`, `engine.db` `flows_runs` left at `running`\n * with a dead owner pid while `control.db` said `failed`, and 86 seconds later\n * the next process's stale-running sweep stole the row, opened a second turn,\n * and billed the provider seat again for a run the control plane had closed.\n *\n * So the encode fails CLOSED here rather than open. The ordinary path is the\n * flow's own codec, unchanged. When that codec rejects the value, the result\n * is still written \u2014 as a JSON projection of what could not be encoded (tag,\n * code, message, a stack summary, and nested causes) inside a `Die` reason \u2014\n * and the caller is told, through {@link EncodedResult.note}, that it must\n * settle the run `failed`. A settled run is never re-executed, which is the\n * durability promise the release policy states as one terminal write.\n *\n * The projection is built as plain JSON rather than re-encoded through a\n * schema, so nothing in this module can raise. Its top-level object carries no\n * `message` key on purpose: `Schema.Defect` revives any JSON object that has a\n * string `message` as an `Error`, and a projection has to come back out of the\n * row as the structured record it went in as.\n *\n * @since 0.1.0\n */\n\nimport { Flow } from \"@smthrs/flow\"\nimport { Redaction } from \"@smthrs/journal\"\nimport type * as Cause from \"effect/Cause\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport * as Schema from \"effect/Schema\"\nimport * as HostReflection from \"./HostReflection.ts\"\n\n/**\n * Proxy and native-error detection, taken from the host that can answer them.\n *\n * `./HostReflection.ts` states why these are host predicates rather than a\n * `node:util/types` import: the module has to bundle for a browser, and only\n * some hosts can name a proxy at all.\n */\nconst { isNativeError, isProxy } = HostReflection.host\n\n/**\n * The `_tag` every projection carries, so a reader of `state_json` can tell a\n * projected settlement from an encoded one without guessing.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const projectionTag = \"flows/engine-store/UnencodableResult\"\n\n/**\n * How many `cause` links a value projection follows before it stops.\n *\n * A provider failure nests two or three deep (`HarnessError` over\n * `ModelError` over the transport error); the bound exists so a self-linking\n * cause chain cannot make the projection unbounded.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const maxCauseDepth = 4\n\n/**\n * How many leading stack lines a value projection keeps.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const maxStackLines = 4\n\n/**\n * How many characters any single projected string keeps.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const maxTextLength = 1024\n\n/**\n * Maximum cause reasons retained by the terminal fallback.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const maxReasonCount = 32\n\n/**\n * Maximum serialized bytes retained by one fallback projection.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const maxProjectionBytes = 64 * 1024\n\n/**\n * A JSON-safe summary of one unencodable value.\n *\n * `type` is the constructor name for an object and the `typeof` for anything\n * else, so `ModelError` and `\"boom\"` are distinguishable in the row.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ValueProjection {\n  readonly type: string\n  readonly message: string\n  readonly tag?: string\n  readonly code?: string\n  readonly stack?: string\n  readonly cause?: ValueProjection\n}\n\n/**\n * A JSON-safe summary of one `Cause` reason.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ReasonProjection {\n  readonly _tag: \"Fail\" | \"Die\" | \"Interrupt\"\n  readonly error?: ValueProjection\n  readonly fiberId?: number\n}\n\n/**\n * The record written in place of a settlement the flow's codec rejected.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ResultProjection {\n  readonly _tag: typeof projectionTag\n  readonly result: \"Complete\" | \"Suspended\" | \"Handoff\"\n  readonly note: string\n  readonly reasons: ReadonlyArray<ReasonProjection>\n  readonly value: ValueProjection | null\n}\n\n/**\n * What {@link encode} produces: the bytes to persist, and \u2014 only when the\n * flow's codec rejected the settlement \u2014 the note describing why.\n *\n * A present `note` is an instruction to the caller, not decoration: the run\n * must reach a terminal `failed` row, because the alternative is the row this\n * lane exists to abolish, a `running` row whose owner is gone.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface EncodedResult {\n  readonly encoded: unknown\n  readonly note: string | undefined\n}\n\nconst truncate = (value: string, limit: number): string => value.length <= limit ? value : `${value.slice(0, limit)}\u2026`\n\n/**\n * Bounds one projected message or stack after the journal's redaction rules.\n *\n * The projection is observability text in `flows_runs.state_json`, and a git or\n * HTTP failure message embeds its remote URL, credentials included. Redaction\n * runs before truncation so a cut cannot leave half a credential the rules no\n * longer match.\n */\nconst redactedText = (value: string): string => truncate(Redaction.redact(value) as string, maxTextLength)\n\n/**\n * Renders any value as a bounded string without raising.\n *\n * `JSON.stringify` answers `undefined` for a function, a symbol, and\n * `undefined` itself, and throws on a circular structure; both are answered\n * with a shape marker rather than propagated, because this module runs on the\n * path that must never fail.\n */\nconst text = (value: unknown): string => {\n  switch (typeof value) {\n    case \"string\":\n      return JSON.stringify(value)\n    case \"number\":\n      return Number.isFinite(value) ? `${value}` : `[number]`\n    case \"boolean\":\n      return value ? \"true\" : \"false\"\n    case \"bigint\":\n      return `[bigint]`\n    case \"undefined\":\n    case \"symbol\":\n    case \"function\":\n      return `[${typeof value}]`\n    case \"object\":\n      return value === null ? \"null\" : Array.isArray(value) ? \"[array]\" : \"[object]\"\n  }\n}\n\nconst minimalValue = (): ValueProjection => ({ type: \"object\", message: \"[unrepresentable]\" })\n\n/** Reads only an own data property; accessors are deliberately inert. */\nconst ownData = (value: object, name: PropertyKey): unknown => {\n  const descriptor = Object.getOwnPropertyDescriptor(value, name)\n  return descriptor !== undefined && \"value\" in descriptor ? descriptor.value : undefined\n}\n\n// Effect exits store their value/cause in one own data slot. Pinning the two\n// library prototypes lets projection read that slot without invoking the\n// public `value` / `cause` accessors or trusting a lookalike object.\nconst successExitPrototype = Object.getPrototypeOf(Exit.succeed(undefined))\nconst failureExitPrototype = Object.getPrototypeOf(Exit.fail(undefined))\nconst exitArguments = \"~effect/Effect/args\"\n\n/**\n * Projects one value \u2014 a typed error, a defect, a success value, a handoff\n * payload \u2014 into JSON.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const projectValue = (value: unknown, depth = 0, seen = new WeakSet<object>()): ValueProjection => {\n  if (value === null || typeof value !== \"object\") {\n    return {\n      type: value === null ? \"null\" : typeof value,\n      message: redactedText(text(value))\n    }\n  }\n  // Generic Proxy introspection is observable user code. A host that can name\n  // a proxy from its internal slot rejects it without invoking a trap.\n  if (isProxy(value) || seen.has(value)) return minimalValue()\n  seen.add(value)\n  try {\n    const message = ownData(value, \"message\")\n    const tag = ownData(value, \"_tag\")\n    const code = ownData(value, \"code\")\n    const stack = ownData(value, \"stack\")\n    const cause = ownData(value, \"cause\")\n    const projection: {\n      type: string\n      message: string\n      tag?: string\n      code?: string\n      stack?: string\n      cause?: ValueProjection\n    } = {\n      type: typeof tag === \"string\" && tag.length > 0\n        ? truncate(tag, maxTextLength)\n        : isNativeError(value)\n        ? \"Error\"\n        : Array.isArray(value)\n        ? \"Array\"\n        : \"object\",\n      message: redactedText(typeof message === \"string\" ? message : text(value))\n    }\n    if (typeof tag === \"string\") projection.tag = truncate(tag, maxTextLength)\n    if (typeof code === \"string\") projection.code = truncate(code, maxTextLength)\n    // Native Error stacks are commonly accessors. They remain deliberately\n    // unread; only an already-materialized own data string is retained.\n    if (typeof stack === \"string\") {\n      projection.stack = redactedText(stack.split(\"\\n\").slice(0, maxStackLines).join(\"\\n\"))\n    }\n    if (cause !== undefined && depth < maxCauseDepth) {\n      projection.cause = projectValue(cause, depth + 1, seen)\n    }\n    return projection\n  } catch {\n    return minimalValue()\n  }\n}\n\nconst projectReason = (reason: Cause.Reason<unknown>): ReasonProjection => {\n  if (isProxy(reason)) return { _tag: \"Die\", error: minimalValue() }\n  try {\n    const tag = ownData(reason, \"_tag\")\n    if (tag === \"Fail\") return { _tag: \"Fail\", error: projectValue(ownData(reason, \"error\")) }\n    if (tag === \"Die\") return { _tag: \"Die\", error: projectValue(ownData(reason, \"defect\")) }\n    const fiberId = ownData(reason, \"fiberId\")\n    return typeof fiberId === \"number\" ? { _tag: \"Interrupt\", fiberId } : { _tag: \"Interrupt\" }\n  } catch {\n    return { _tag: \"Die\", error: minimalValue() }\n  }\n}\n\n/**\n * Projects every reason of a cause, in order. An absent cause \u2014 a\n * `Flow.Suspended` that carries none \u2014 projects to no reasons.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const projectCause = (\n  cause: Cause.Cause<unknown> | undefined\n): ReadonlyArray<ReasonProjection> => {\n  if (cause === undefined) return []\n  if (isProxy(cause)) return [{ _tag: \"Die\", error: minimalValue() }]\n  try {\n    const reasons = ownData(cause, \"reasons\")\n    if (!Array.isArray(reasons) || isProxy(reasons)) {\n      return [{ _tag: \"Die\", error: minimalValue() }]\n    }\n    const projected = reasons.slice(0, maxReasonCount).map(projectReason)\n    if (reasons.length > maxReasonCount) {\n      projected.push({\n        _tag: \"Die\",\n        error: { type: \"truncated\", message: `[${reasons.length - maxReasonCount} reasons omitted]` }\n      })\n    }\n    return projected\n  } catch {\n    return [{ _tag: \"Die\", error: minimalValue() }]\n  }\n}\n\nconst minimalResult = (note: string): ResultProjection => ({\n  _tag: projectionTag,\n  result: \"Complete\",\n  note,\n  reasons: [{ _tag: \"Die\", error: minimalValue() }],\n  value: null\n})\n\nconst withinBudget = (projection: ResultProjection): ResultProjection => {\n  try {\n    return new TextEncoder().encode(JSON.stringify(projection)).length <= maxProjectionBytes\n      ? projection\n      : minimalResult(\"the rejected settlement exceeded the diagnostic projection bound\")\n  } catch {\n    return minimalResult(\"the rejected settlement could not be projected\")\n  }\n}\n\n/**\n * Projects a settlement the flow's codec rejected.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const projectResult = (\n  result: Flow.Result<unknown, unknown>,\n  note: string\n): ResultProjection => {\n  note = truncate(note, maxTextLength)\n  if (isProxy(result)) return minimalResult(note)\n  try {\n    const tag = ownData(result, \"_tag\")\n    if (tag === \"Suspended\") {\n      return withinBudget({\n        _tag: projectionTag,\n        result: \"Suspended\",\n        note,\n        reasons: projectCause(ownData(result, \"cause\") as Cause.Cause<unknown> | undefined),\n        value: null\n      })\n    }\n    if (tag === \"Handoff\") {\n      return withinBudget({\n        _tag: projectionTag,\n        result: \"Handoff\",\n        note,\n        reasons: [],\n        value: projectValue(ownData(result, \"payload\"))\n      })\n    }\n    const exit = ownData(result, \"exit\")\n    if (typeof exit !== \"object\" || exit === null || isProxy(exit)) return minimalResult(note)\n    const prototype = Object.getPrototypeOf(exit)\n    const argument = ownData(exit, exitArguments)\n    if (prototype !== successExitPrototype && prototype !== failureExitPrototype) return minimalResult(note)\n    return withinBudget(\n      prototype === successExitPrototype\n        ? {\n          _tag: projectionTag,\n          result: \"Complete\",\n          note,\n          reasons: [],\n          value: projectValue(argument)\n        }\n        : {\n          _tag: projectionTag,\n          result: \"Complete\",\n          note,\n          reasons: projectCause(argument as Cause.Cause<unknown> | undefined),\n          value: null\n        }\n    )\n  } catch {\n    return minimalResult(note)\n  }\n}\n\n/**\n * The encoded settlement written in place of one the codec rejected.\n *\n * A `Handoff` keeps its own shape, because its round settles `completed` with\n * a successor already created and the lineage has to stay readable. Everything\n * else becomes a failed `Complete`: a settlement whose bytes the codec refuses\n * is not resumable and not answerable, so the only honest durable record is\n * that the round failed, with the projection as its defect.\n */\nconst degrade = (result: Flow.Result<unknown, unknown>, projection: ResultProjection): unknown => {\n  try {\n    if (!isProxy(result) && ownData(result, \"_tag\") === \"Handoff\") {\n      const flow = ownData(result, \"flow\")\n      if (typeof flow === \"string\") return { _tag: \"Handoff\", flow, payload: projection, capabilityCeilings: [[]] }\n    }\n  } catch {\n    // The terminal Complete below is the fail-closed representation.\n  }\n  return { _tag: \"Complete\", exit: { _tag: \"Failure\", cause: [{ _tag: \"Die\", defect: projection }] } }\n}\n\n/**\n * Encodes a round's settlement through the flow's own codec, and \u2014 when that\n * codec rejects it \u2014 through a JSON projection instead.\n *\n * The returned effect has no error channel and dies for nothing: a caller on\n * the terminal-transition path can always write the row it holds.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const encode = (\n  flow: Flow.Any,\n  result: Flow.Result<unknown, unknown>\n): Effect.Effect<EncodedResult> =>\n  Schema.encodeEffect(\n    Schema.toCodecJson(Flow.Result({\n      success: flow.successSchema,\n      error: flow.errorSchema\n    }))\n  )(result).pipe(\n    Effect.map((encoded): EncodedResult => ({ encoded, note: undefined })),\n    Effect.catchCause((_cause) => {\n      const note = \"the flow result codec rejected the settlement\"\n      return Effect.as(\n        Effect.logWarning(\n          `engine-store: the settlement of ${flow._tag} could not be encoded through its own codec; persisting a JSON projection so the run still settles`\n        ),\n        { encoded: degrade(result, projectResult(result, note)), note } satisfies EncodedResult\n      )\n    })\n  ) as Effect.Effect<EncodedResult>\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Immutable snapshots of filesystem declarations crossing an async boundary.
+ *
+ * @since 1.0.0
+ */
+import type { FileBoundary } from "@smthrs/flow/FileBoundary";
+/**
+ * Copies and freezes every mutable member of a boundary declaration.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: (boundary: FileBoundary) => FileBoundary;
+//# sourceMappingURL=FileBoundarySnapshot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileBoundarySnapshot.d.ts","sourceRoot":"","sources":["../../../src/internal/FileBoundarySnapshot.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAY7D;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,UAAU,YAAY,KAAG,YAc1C,CAAA"}