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

package/dist/cjs/RunChangeFeed.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/RunChangeFeed.ts"],
+  "sourcesContent": ["/**\n * Coalesced execution catch-up with permanent deletion evidence.\n *\n * @since 1.0.0\n */\n\nimport { RunStoreError } from \"@smthrs/run-store/RunStore\"\nimport { Context, Effect, Layer, Schema } from \"effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\nimport type { Position } from \"./ExecutionSnapshot.ts\"\nimport * as Read from \"./internal/ExecutionSnapshotRead.ts\"\n\n/**\n * A live-row change or retained tombstone.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Change extends Position {\n  readonly runId: string\n  readonly deleted: boolean\n}\n/**\n * One catch-up page at an engine watermark.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Page extends Position {\n  readonly changes: ReadonlyArray<Change>\n  /** Resume here, including across gaps from coalesced changes. */\n  readonly nextRevision: number\n  readonly hasMore: boolean\n}\n/**\n * Bounded state-feed operations.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Service {\n  readonly current: Effect.Effect<Position, RunStoreError>\n  readonly changesSince: (options: Position & { readonly limit: number }) => Effect.Effect<Page, RunStoreError>\n}\n/**\n * Durable change-feed service.\n *\n * @category services\n * @since 1.0.0\n */\nexport class RunChangeFeed extends Context.Service<RunChangeFeed, Service>()(\"@smthrs/engine-store/RunChangeFeed\") {}\n/**\n * Maximum change-feed page size.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const maximumPageSize = 1000\nconst Options = Schema.Struct({\n  source: Read.Source,\n  revision: Read.Natural,\n  limit: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: maximumPageSize }))\n})\nconst ChangeRow = Schema.Struct({ run_id: Read.Identifier, revision: Read.Natural, deleted: Schema.Literals([0, 1]) })\n\n/**\n * Constructs the feed without polling or retention timers.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (): Effect.Effect<Service, never, SqlClient.SqlClient> =>\n  Effect.gen(function*() {\n    const sql = yield* SqlClient.SqlClient\n    return {\n      current: Read.boundary(\"RunChangeFeed.current\", Read.position(sql)),\n      changesSince: (options) =>\n        Read.boundary(\n          \"RunChangeFeed.changesSince\",\n          Effect.gen(function*() {\n            const input = yield* Read.decode(Options, options)\n            return yield* Read.transaction(\n              sql,\n              Effect.gen(function*() {\n                const at = yield* Read.position(sql)\n                if (input.source !== at.source || input.revision > at.revision) {\n                  return yield* Effect.fail(\n                    new RunStoreError({\n                      method: \"RunChangeFeed.changesSince\",\n                      code: \"invalid_run\",\n                      message: \"change cursor requires an explicit source rebuild\",\n                      cause: { requested: input, observed: at }\n                    })\n                  )\n                }\n                const rows = yield* sql`SELECT run_id, revision, deleted FROM flows_run_changes\n          WHERE revision > ${input.revision} AND revision <= ${at.revision}\n          ORDER BY revision LIMIT ${input.limit + 1}`\n                const decoded = yield* Effect.forEach(rows, (row) => Read.decode(ChangeRow, row))\n                const changes = decoded.slice(0, input.limit).map((row) => ({\n                  runId: row.run_id,\n                  source: at.source,\n                  revision: row.revision,\n                  deleted: row.deleted === 1\n                }))\n                const hasMore = decoded.length > input.limit\n                return {\n                  ...at,\n                  changes,\n                  hasMore,\n                  nextRevision: hasMore ? changes[changes.length - 1]!.revision : at.revision\n                }\n              })\n            )\n          })\n        )\n    }\n  })\n/**\n * Provides the SQL feed.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layer: Layer.Layer<RunChangeFeed, never, SqlClient.SqlClient> = Layer.effect(RunChangeFeed)(make())\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,sBAA8B;AAC9B,oBAA+C;AAC/C,gBAA2B;AAE3B,WAAsB;AAwCf,MAAM,sBAAsB,sBAAQ,QAAgC,EAAE,oCAAoC,EAAE;AAAC;AAO7G,MAAM,kBAAkB;AAC/B,MAAM,UAAU,qBAAO,OAAO;AAAA,EAC5B,QAAQ,KAAK;AAAA,EACb,UAAU,KAAK;AAAA,EACf,OAAO,qBAAO,IAAI,MAAM,qBAAO,UAAU,EAAE,SAAS,GAAG,SAAS,gBAAgB,CAAC,CAAC;AACpF,CAAC;AACD,MAAM,YAAY,qBAAO,OAAO,EAAE,QAAQ,KAAK,YAAY,UAAU,KAAK,SAAS,SAAS,qBAAO,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;AAQ9G,MAAM,OAAO,MAClB,qBAAO,IAAI,aAAY;AACrB,QAAM,MAAM,OAAO,UAAU;AAC7B,SAAO;AAAA,IACL,SAAS,KAAK,SAAS,yBAAyB,KAAK,SAAS,GAAG,CAAC;AAAA,IAClE,cAAc,CAAC,YACb,KAAK;AAAA,MACH;AAAA,MACA,qBAAO,IAAI,aAAY;AACrB,cAAM,QAAQ,OAAO,KAAK,OAAO,SAAS,OAAO;AACjD,eAAO,OAAO,KAAK;AAAA,UACjB;AAAA,UACA,qBAAO,IAAI,aAAY;AACrB,kBAAM,KAAK,OAAO,KAAK,SAAS,GAAG;AACnC,gBAAI,MAAM,WAAW,GAAG,UAAU,MAAM,WAAW,GAAG,UAAU;AAC9D,qBAAO,OAAO,qBAAO;AAAA,gBACnB,IAAI,8BAAc;AAAA,kBAChB,QAAQ;AAAA,kBACR,MAAM;AAAA,kBACN,SAAS;AAAA,kBACT,OAAO,EAAE,WAAW,OAAO,UAAU,GAAG;AAAA,gBAC1C,CAAC;AAAA,cACH;AAAA,YACF;AACA,kBAAM,OAAO,OAAO;AAAA,6BACP,MAAM,QAAQ,oBAAoB,GAAG,QAAQ;AAAA,oCACtC,MAAM,QAAQ,CAAC;AACnC,kBAAM,UAAU,OAAO,qBAAO,QAAQ,MAAM,CAAC,QAAQ,KAAK,OAAO,WAAW,GAAG,CAAC;AAChF,kBAAM,UAAU,QAAQ,MAAM,GAAG,MAAM,KAAK,EAAE,IAAI,CAAC,SAAS;AAAA,cAC1D,OAAO,IAAI;AAAA,cACX,QAAQ,GAAG;AAAA,cACX,UAAU,IAAI;AAAA,cACd,SAAS,IAAI,YAAY;AAAA,YAC3B,EAAE;AACF,kBAAM,UAAU,QAAQ,SAAS,MAAM;AACvC,mBAAO;AAAA,cACL,GAAG;AAAA,cACH;AAAA,cACA;AAAA,cACA,cAAc,UAAU,QAAQ,QAAQ,SAAS,CAAC,EAAG,WAAW,GAAG;AAAA,YACrE;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACJ;AACF,CAAC;AAOI,MAAM,QAAgE,oBAAM,OAAO,aAAa,EAAE,KAAK,CAAC;",
+  "names": []
+}

package/dist/cjs/RunState.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The envelope a durable run's state is persisted inside.
+ *
+ * The engine never stores a flow's payload bare — it wraps it in a versioned
+ * struct, so a store row written by an older build decodes under a known
+ * shape instead of being guessed at. `version` is a literal rather than a
+ * number for exactly that reason: a future revision adds a new literal and
+ * both remain decodable.
+ *
+ * Time travel reads these rows too, deriving the state AT a frame by
+ * replaying run-decision records rather than trusting the row's latest value.
+ *
+ * @since 0.1.0
+ */
+import { CapabilityPattern } from "@smthrs/capability/Capability";
+import * as Schema from "effect/Schema";
+/**
+ * What a linked child does when the run that spawned it ends.
+ *
+ * `cancel` is the default and the shape a `.child()` boundary takes: the
+ * parent is waiting on this child, so a parent that stops waiting — because it
+ * completed, failed, or was cancelled — leaves nothing behind. `detach` is the
+ * shape a fire-and-forget spawn takes: the parent deliberately did not wait,
+ * so the child outlives it and keeps its own claim and its own journal.
+ *
+ * The policy is recorded on the CHILD rather than on the edge because it is a
+ * property of how the child was started, and because a child with two parents
+ * (the diamond `flows_run_parents` permits) must answer the question once.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const OnParentExit: Schema.Literals<readonly ["cancel", "detach"]>;
+/**
+ * The value form of {@link OnParentExit}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type OnParentExit = typeof OnParentExit.Type;
+/**
+ * The versioned state stored for a durable flow run: which flow it is, the
+ * encoded `payload` it was started with, and — as they arrive — its
+ * `result` and its cancellation timestamp.
+ *
+ * `parentExecutionId` is present only on a child run, and is what makes a
+ * spawned subflow reachable from the run that spawned it. `onParentExit`
+ * travels with it: it is what the parent's terminal transition reads to decide
+ * whether this child ends with it.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const RunState: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly flowName: Schema.NonEmptyString;
+    readonly payload: Schema.Unknown;
+    readonly capabilityCeilings: Schema.optionalKey<Schema.$Array<Schema.$Array<typeof CapabilityPattern>>>;
+    readonly forkKeyRunIds: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly parentExecutionId: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly onParentExit: Schema.optionalKey<Schema.Literals<readonly ["cancel", "detach"]>>;
+    readonly maxRounds: Schema.optionalKey<Schema.Int>;
+    readonly deadline: Schema.optionalKey<Schema.Struct<{
+        readonly startedAtMs: Schema.Number;
+        readonly deadlineMs: Schema.Number;
+    }>>;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+    readonly cancellation: Schema.optionalKey<Schema.Struct<{
+        readonly interruptedAtMs: Schema.Number;
+    }>>;
+}>;
+/**
+ * The value form of {@link RunState}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type RunState = typeof RunState.Type;
+/**
+ * Why a driver released a run it still owned, recorded on its
+ * `interrupt-released` run decision.
+ *
+ * `lease-lapsed` means the host went `unconfirmedMs` without confirming its
+ * run lease (a stalled or overloaded host), so the heartbeat loop stopped the
+ * run's work before a peer could take it. `interrupted` is any other
+ * interruption that was not a cancellation, usually a host shutdown.
+ *
+ * Decisions written before this field existed carry no cause; read them with
+ * {@link releaseCauseOf}, which answers `undefined` for them.
+ *
+ * @since 1.0.0
+ * @category schemas
+ */
+export declare const ReleaseCause: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"lease-lapsed">;
+    readonly unconfirmedMs: Schema.Int;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"interrupted">;
+}>]>;
+/**
+ * The value form of {@link ReleaseCause}.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type ReleaseCause = typeof ReleaseCause.Type;
+/**
+ * The release cause a run decision payload records, or `undefined` for a
+ * decision that is not `interrupt-released`, one written before causes were
+ * recorded, or one whose cause does not decode.
+ *
+ * @since 1.0.0
+ * @category decoding
+ */
+export declare const releaseCauseOf: (decision: unknown) => ReleaseCause | undefined;
+//# sourceMappingURL=RunState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RunState.d.ts","sourceRoot":"","sources":["../../src/RunState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AAEjE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,gDAAwC,CAAA;AAEjE;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;EAkBnB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY;;;;;IAMvB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAInD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,OAAO,KAAG,YAAY,GAAG,SAMjE,CAAA"}

package/dist/cjs/RunState.js

@@ -0,0 +1,76 @@
+"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 RunState_exports = {};
+__export(RunState_exports, {
+  OnParentExit: () => OnParentExit,
+  ReleaseCause: () => ReleaseCause,
+  RunState: () => RunState,
+  releaseCauseOf: () => releaseCauseOf
+});
+module.exports = __toCommonJS(RunState_exports);
+var import_Capability = require("@smthrs/capability/Capability");
+var import_flow = require("@smthrs/flow");
+var Schema = __toESM(require("effect/Schema"), 1);
+const PositiveSafeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+const OnParentExit = Schema.Literals(["cancel", "detach"]);
+const RunState = Schema.Struct({
+  version: Schema.Literal(1),
+  flowName: Schema.NonEmptyString,
+  payload: Schema.Unknown,
+  capabilityCeilings: Schema.optionalKey(Schema.Array(Schema.Array(import_Capability.CapabilityPattern))),
+  // Key origins are immutable fork metadata, independent of the chosen frame.
+  // Copied attempts, not ancestry alone, authorize reuse of an origin's key.
+  forkKeyRunIds: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+  parentExecutionId: Schema.optionalKey(Schema.NonEmptyString),
+  onParentExit: Schema.optionalKey(OnParentExit),
+  maxRounds: Schema.optionalKey(PositiveSafeInt),
+  // The lineage deadline a round after a handoff runs under, copied from the
+  // `Flow.Handoff` that opened it.
+  deadline: Schema.optionalKey(import_flow.Flow.LineageDeadline),
+  result: Schema.optionalKey(Schema.Unknown),
+  cancellation: Schema.optionalKey(Schema.Struct({
+    interruptedAtMs: Schema.Number.check(Schema.isGreaterThanOrEqualTo(0))
+  }))
+});
+const ReleaseCause = Schema.Union([
+  Schema.Struct({
+    kind: Schema.Literal("lease-lapsed"),
+    unconfirmedMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+  }),
+  Schema.Struct({ kind: Schema.Literal("interrupted") })
+]);
+const decodeReleaseCause = Schema.decodeUnknownOption(ReleaseCause);
+const releaseCauseOf = (decision) => {
+  if (decision === null || typeof decision !== "object") return void 0;
+  const record = decision;
+  if (record.decision !== "interrupt-released") return void 0;
+  const decoded = decodeReleaseCause(record.cause);
+  return decoded._tag === "Some" ? decoded.value : void 0;
+};
+//# sourceMappingURL=RunState.js.map

package/dist/cjs/RunState.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/RunState.ts"],
+  "sourcesContent": ["/**\n * The envelope a durable run's state is persisted inside.\n *\n * The engine never stores a flow's payload bare \u2014 it wraps it in a versioned\n * struct, so a store row written by an older build decodes under a known\n * shape instead of being guessed at. `version` is a literal rather than a\n * number for exactly that reason: a future revision adds a new literal and\n * both remain decodable.\n *\n * Time travel reads these rows too, deriving the state AT a frame by\n * replaying run-decision records rather than trusting the row's latest value.\n *\n * @since 0.1.0\n */\n\nimport { CapabilityPattern } from \"@smthrs/capability/Capability\"\nimport { Flow } from \"@smthrs/flow\"\nimport * as Schema from \"effect/Schema\"\n\n/** @private */\nconst PositiveSafeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))\n\n/**\n * What a linked child does when the run that spawned it ends.\n *\n * `cancel` is the default and the shape a `.child()` boundary takes: the\n * parent is waiting on this child, so a parent that stops waiting \u2014 because it\n * completed, failed, or was cancelled \u2014 leaves nothing behind. `detach` is the\n * shape a fire-and-forget spawn takes: the parent deliberately did not wait,\n * so the child outlives it and keeps its own claim and its own journal.\n *\n * The policy is recorded on the CHILD rather than on the edge because it is a\n * property of how the child was started, and because a child with two parents\n * (the diamond `flows_run_parents` permits) must answer the question once.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const OnParentExit = Schema.Literals([\"cancel\", \"detach\"])\n\n/**\n * The value form of {@link OnParentExit}.\n *\n * @since 0.1.0\n * @category models\n */\nexport type OnParentExit = typeof OnParentExit.Type\n\n/**\n * The versioned state stored for a durable flow run: which flow it is, the\n * encoded `payload` it was started with, and \u2014 as they arrive \u2014 its\n * `result` and its cancellation timestamp.\n *\n * `parentExecutionId` is present only on a child run, and is what makes a\n * spawned subflow reachable from the run that spawned it. `onParentExit`\n * travels with it: it is what the parent's terminal transition reads to decide\n * whether this child ends with it.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const RunState = Schema.Struct({\n  version: Schema.Literal(1),\n  flowName: Schema.NonEmptyString,\n  payload: Schema.Unknown,\n  capabilityCeilings: Schema.optionalKey(Schema.Array(Schema.Array(CapabilityPattern))),\n  // Key origins are immutable fork metadata, independent of the chosen frame.\n  // Copied attempts, not ancestry alone, authorize reuse of an origin's key.\n  forkKeyRunIds: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),\n  parentExecutionId: Schema.optionalKey(Schema.NonEmptyString),\n  onParentExit: Schema.optionalKey(OnParentExit),\n  maxRounds: Schema.optionalKey(PositiveSafeInt),\n  // The lineage deadline a round after a handoff runs under, copied from the\n  // `Flow.Handoff` that opened it.\n  deadline: Schema.optionalKey(Flow.LineageDeadline),\n  result: Schema.optionalKey(Schema.Unknown),\n  cancellation: Schema.optionalKey(Schema.Struct({\n    interruptedAtMs: Schema.Number.check(Schema.isGreaterThanOrEqualTo(0))\n  }))\n})\n\n/**\n * The value form of {@link RunState}.\n *\n * @since 0.1.0\n * @category models\n */\nexport type RunState = typeof RunState.Type\n\n/**\n * Why a driver released a run it still owned, recorded on its\n * `interrupt-released` run decision.\n *\n * `lease-lapsed` means the host went `unconfirmedMs` without confirming its\n * run lease (a stalled or overloaded host), so the heartbeat loop stopped the\n * run's work before a peer could take it. `interrupted` is any other\n * interruption that was not a cancellation, usually a host shutdown.\n *\n * Decisions written before this field existed carry no cause; read them with\n * {@link releaseCauseOf}, which answers `undefined` for them.\n *\n * @since 1.0.0\n * @category schemas\n */\nexport const ReleaseCause = Schema.Union([\n  Schema.Struct({\n    kind: Schema.Literal(\"lease-lapsed\"),\n    unconfirmedMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))\n  }),\n  Schema.Struct({ kind: Schema.Literal(\"interrupted\") })\n])\n\n/**\n * The value form of {@link ReleaseCause}.\n *\n * @since 1.0.0\n * @category models\n */\nexport type ReleaseCause = typeof ReleaseCause.Type\n\nconst decodeReleaseCause = Schema.decodeUnknownOption(ReleaseCause)\n\n/**\n * The release cause a run decision payload records, or `undefined` for a\n * decision that is not `interrupt-released`, one written before causes were\n * recorded, or one whose cause does not decode.\n *\n * @since 1.0.0\n * @category decoding\n */\nexport const releaseCauseOf = (decision: unknown): ReleaseCause | undefined => {\n  if (decision === null || typeof decision !== \"object\") return undefined\n  const record = decision as { readonly decision?: unknown; readonly cause?: unknown }\n  if (record.decision !== \"interrupt-released\") return undefined\n  const decoded = decodeReleaseCause(record.cause)\n  return decoded._tag === \"Some\" ? decoded.value : undefined\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,wBAAkC;AAClC,kBAAqB;AACrB,aAAwB;AAGxB,MAAM,kBAAkB,OAAO,IAAI,MAAM,OAAO,uBAAuB,CAAC,CAAC;AAkBlE,MAAM,eAAe,OAAO,SAAS,CAAC,UAAU,QAAQ,CAAC;AAuBzD,MAAM,WAAW,OAAO,OAAO;AAAA,EACpC,SAAS,OAAO,QAAQ,CAAC;AAAA,EACzB,UAAU,OAAO;AAAA,EACjB,SAAS,OAAO;AAAA,EAChB,oBAAoB,OAAO,YAAY,OAAO,MAAM,OAAO,MAAM,mCAAiB,CAAC,CAAC;AAAA;AAAA;AAAA,EAGpF,eAAe,OAAO,YAAY,OAAO,MAAM,OAAO,cAAc,CAAC;AAAA,EACrE,mBAAmB,OAAO,YAAY,OAAO,cAAc;AAAA,EAC3D,cAAc,OAAO,YAAY,YAAY;AAAA,EAC7C,WAAW,OAAO,YAAY,eAAe;AAAA;AAAA;AAAA,EAG7C,UAAU,OAAO,YAAY,iBAAK,eAAe;AAAA,EACjD,QAAQ,OAAO,YAAY,OAAO,OAAO;AAAA,EACzC,cAAc,OAAO,YAAY,OAAO,OAAO;AAAA,IAC7C,iBAAiB,OAAO,OAAO,MAAM,OAAO,uBAAuB,CAAC,CAAC;AAAA,EACvE,CAAC,CAAC;AACJ,CAAC;AAyBM,MAAM,eAAe,OAAO,MAAM;AAAA,EACvC,OAAO,OAAO;AAAA,IACZ,MAAM,OAAO,QAAQ,cAAc;AAAA,IACnC,eAAe,OAAO,IAAI,MAAM,OAAO,uBAAuB,CAAC,CAAC;AAAA,EAClE,CAAC;AAAA,EACD,OAAO,OAAO,EAAE,MAAM,OAAO,QAAQ,aAAa,EAAE,CAAC;AACvD,CAAC;AAUD,MAAM,qBAAqB,OAAO,oBAAoB,YAAY;AAU3D,MAAM,iBAAiB,CAAC,aAAgD;AAC7E,MAAI,aAAa,QAAQ,OAAO,aAAa,SAAU,QAAO;AAC9D,QAAM,SAAS;AACf,MAAI,OAAO,aAAa,qBAAsB,QAAO;AACrD,QAAM,UAAU,mBAAmB,OAAO,KAAK;AAC/C,SAAO,QAAQ,SAAS,SAAS,QAAQ,QAAQ;AACnD;",
+  "names": []
+}