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

package/dist/cjs/SelectionStore.js

@@ -0,0 +1,229 @@
+"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 SelectionStore_exports = {};
+__export(SelectionStore_exports, {
+  SelectionStore: () => SelectionStore,
+  SelectionStoreError: () => SelectionStoreError,
+  SelectionStoreErrorCode: () => SelectionStoreErrorCode,
+  TrainingObservation: () => TrainingObservation,
+  TrainingOutcome: () => TrainingOutcome,
+  layer: () => layer,
+  make: () => make,
+  maxEvidenceEntries: () => maxEvidenceEntries
+});
+module.exports = __toCommonJS(SelectionStore_exports);
+var import_DurableWriter = require("@smthrs/database/DurableWriter");
+var Clock = __toESM(require("effect/Clock"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+var Selection = __toESM(require("./Selection.js"), 1);
+const TrainingOutcome = Schema.Literals(["hit", "miss"]);
+const TrainingObservation = Schema.Struct({
+  scope: Schema.NonEmptyString,
+  affects: Schema.NonEmptyString,
+  outcome: TrainingOutcome
+});
+const SelectionStoreErrorCode = Schema.Literals([
+  "invalid_input",
+  "decode_failed",
+  "persistence_failed"
+]);
+class SelectionStoreError extends Schema.TaggedError()(
+  "@smthrs/engine-store/SelectionStoreError",
+  {
+    code: SelectionStoreErrorCode,
+    message: Schema.String,
+    scope: Schema.optional(Schema.String),
+    affects: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Unknown)
+  }
+) {
+}
+class SelectionStore extends Context.Service()(
+  "@smthrs/engine-store/SelectionStore"
+) {
+}
+const EvidenceListFromJsonString = Schema.fromJsonString(Schema.Array(Schema.String));
+const EdgeRow = Schema.Struct({
+  scope: Schema.NonEmptyString,
+  affects: Schema.NonEmptyString,
+  confidence: Schema.Number,
+  validFromMs: Selection.NonNegativeSafeInt,
+  evidenceJson: Schema.String
+});
+const invalidInput = (message, cause) => new SelectionStoreError({ code: "invalid_input", message, cause });
+const persistenceFailed = (message, cause) => cause instanceof SelectionStoreError ? cause : new SelectionStoreError({ code: "persistence_failed", message, cause });
+const decodeObservation = (input) => Schema.decodeUnknownEffect(TrainingObservation)(input).pipe(
+  Effect.mapError((cause) => invalidInput("a training observation is invalid", cause))
+);
+const decodeEdge = (input) => Schema.decodeUnknownEffect(Selection.SuspectedEdge)(input).pipe(
+  Effect.mapError((cause) => invalidInput("a suspected edge is invalid", cause))
+);
+const encodeEvidence = (evidence) => Effect.succeed(JSON.stringify(evidence));
+const decodeEvidence = (evidenceJson, row) => Schema.decodeUnknownEffect(EvidenceListFromJsonString)(evidenceJson).pipe(
+  Effect.mapError(
+    (cause) => new SelectionStoreError({
+      code: "decode_failed",
+      message: `stored edge ${row.scope} -> ${row.affects} has invalid evidence`,
+      scope: row.scope,
+      affects: row.affects,
+      cause
+    })
+  )
+);
+const decodeRow = (input) => Schema.decodeUnknownEffect(EdgeRow)(input).pipe(
+  Effect.mapError(
+    (cause) => new SelectionStoreError({
+      code: "decode_failed",
+      message: "a stored selection edge row is invalid",
+      cause
+    })
+  ),
+  Effect.flatMap(
+    (row) => decodeEvidence(row.evidenceJson, row).pipe(
+      Effect.flatMap(
+        (evidence) => Schema.decodeUnknownEffect(Selection.SuspectedEdge)({
+          scope: row.scope,
+          affects: row.affects,
+          confidence: row.confidence,
+          validFromMs: row.validFromMs,
+          evidence
+        }).pipe(Effect.mapError(
+          (cause) => new SelectionStoreError({
+            code: "decode_failed",
+            message: `stored edge ${row.scope} -> ${row.affects} is invalid`,
+            scope: row.scope,
+            affects: row.affects,
+            cause
+          })
+        ))
+      )
+    )
+  )
+);
+const trainConfidence = (confidence, outcome) => outcome === "hit" ? confidence + 0.05 * (1 - confidence) : confidence * 0.5;
+const maxEvidenceEntries = 128;
+const make = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  const writer = yield* import_DurableWriter.DurableWriter;
+  const selectEdge = (observation) => sql`
+      SELECT
+        scope,
+        affects,
+        confidence,
+        valid_from_ms AS "validFromMs",
+        evidence_json AS "evidenceJson"
+      FROM flows_selection_suspected_edges
+      WHERE scope = ${observation.scope}
+        AND affects = ${observation.affects}
+    `;
+  const writeEdge = (edge) => Effect.gen(function* () {
+    const evidenceJson = yield* encodeEvidence(edge.evidence);
+    yield* sql`
+        INSERT INTO flows_selection_suspected_edges (
+          scope, affects, confidence, valid_from_ms, evidence_json
+        ) VALUES (
+          ${edge.scope}, ${edge.affects}, ${edge.confidence}, ${edge.validFromMs}, ${evidenceJson}
+        ) ON CONFLICT (scope, affects) DO UPDATE SET
+          confidence = excluded.confidence,
+          valid_from_ms = excluded.valid_from_ms,
+          evidence_json = excluded.evidence_json
+      `.pipe(Effect.mapError(
+      (cause) => persistenceFailed(
+        `could not persist edge ${edge.scope} -> ${edge.affects}`,
+        cause
+      )
+    ));
+  });
+  const upsert = Effect.fn("SelectionStore.upsert")(
+    (edges) => Effect.gen(function* () {
+      const decoded = yield* Effect.forEach(edges, decodeEdge);
+      yield* writer.write(Effect.forEach(decoded, writeEdge, { discard: true })).pipe(
+        Effect.mapError((cause) => persistenceFailed("could not persist suspected edges", cause))
+      );
+    })
+  );
+  const list = Effect.fn("SelectionStore.list")(
+    () => Effect.gen(function* () {
+      const rows = yield* sql`
+        SELECT
+          scope,
+          affects,
+          confidence,
+          valid_from_ms AS "validFromMs",
+          evidence_json AS "evidenceJson"
+        FROM flows_selection_suspected_edges
+        ORDER BY scope, affects
+      `.pipe(Effect.mapError((cause) => persistenceFailed("could not list suspected edges", cause)));
+      return yield* Effect.forEach(rows, decodeRow);
+    })
+  );
+  const snapshot = Effect.fn("SelectionStore.snapshot")(
+    () => Effect.gen(function* () {
+      const pinnedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor));
+      const edges = yield* list();
+      return { pinnedAtMs, edges };
+    })
+  );
+  const train = Effect.fn("SelectionStore.train")(
+    (observations) => Effect.gen(function* () {
+      const decoded = yield* Effect.forEach(observations, decodeObservation);
+      yield* writer.write(Effect.forEach(
+        decoded,
+        (observation) => Effect.gen(function* () {
+          const rows = yield* selectEdge(observation).pipe(
+            Effect.mapError(
+              (cause) => persistenceFailed(
+                `could not read edge ${observation.scope} -> ${observation.affects}`,
+                cause
+              )
+            )
+          );
+          const row = rows[0];
+          if (row === void 0) return;
+          const edge = yield* decodeRow(row);
+          yield* writeEdge({
+            ...edge,
+            confidence: trainConfidence(edge.confidence, observation.outcome),
+            evidence: [...edge.evidence, JSON.stringify(observation)].slice(-maxEvidenceEntries)
+          });
+        }),
+        { discard: true }
+      )).pipe(Effect.mapError((cause) => persistenceFailed("could not train suspected edges", cause)));
+    })
+  );
+  return { upsert, list, snapshot, train };
+});
+const layer = Layer.effect(
+  SelectionStore
+)(make);
+//# sourceMappingURL=SelectionStore.js.map

package/dist/cjs/SelectionStore.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/SelectionStore.ts"],
+  "sourcesContent": ["/**\n * Durable suspected-edge storage for probabilistic selection.\n *\n * The store persists advisory beliefs only: training moves edge confidence and\n * appends evidence, but it never writes scheduler journal records, step keys,\n * or cache rows (law 5). The edge and snapshot schemas are `Selection`'s own \u2014\n * one source of truth, so a stored edge is by construction what\n * `Selection.select` consumes. Evidence entries stay strings: training appends\n * the observation JSON-encoded, so audits can replay the asymmetric rule\n * without the schema forking from `Selection.SuspectedEdge`.\n *\n * Model-backed selection, CLI verbs, approval routing, auto-appending\n * proposals, and scheduled recertification cadence are deliberately out of\n * scope here: `engine-store` must not grow a model dependency, no selection\n * CLI verbs are exposed yet, approval routing belongs to\n * `@smthrs/control`, proposal admission still needs human product review, and\n * cadence belongs to a system-flow/product layer rather than the primitive\n * store.\n *\n * @since 0.1.0\n */\n\nimport { DurableWriter } from \"@smthrs/database/DurableWriter\"\nimport * as Clock from \"effect/Clock\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as Schema from \"effect/Schema\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\nimport * as Selection from \"./Selection.ts\"\n\n/**\n * Training outcomes for a suspected edge: a `hit` is a recertified deferral\n * that passed, a `miss` is one that failed \u2014 the guess was confidently wrong.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const TrainingOutcome = Schema.Literals([\"hit\", \"miss\"])\n\n/**\n * Training outcomes for a suspected edge.\n *\n * @category models\n * @since 0.1.0\n */\nexport type TrainingOutcome = typeof TrainingOutcome.Type\n\n/**\n * One observed result for a stored suspected edge.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const TrainingObservation = Schema.Struct({\n  scope: Schema.NonEmptyString,\n  affects: Schema.NonEmptyString,\n  outcome: TrainingOutcome\n})\n\n/**\n * One observed result for a stored suspected edge.\n *\n * @category models\n * @since 0.1.0\n */\nexport type TrainingObservation = typeof TrainingObservation.Type\n\n/**\n * Stable selection-store failure codes.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const SelectionStoreErrorCode = Schema.Literals([\n  \"invalid_input\",\n  \"decode_failed\",\n  \"persistence_failed\"\n])\n\n/**\n * Stable selection-store failure codes.\n *\n * @category models\n * @since 1.0.0\n */\nexport type SelectionStoreErrorCode = typeof SelectionStoreErrorCode.Type\n\n/**\n * A rejected public value, corrupt stored row, or unavailable database.\n *\n * @category errors\n * @since 1.0.0\n */\nexport class SelectionStoreError extends Schema.TaggedError<SelectionStoreError>()(\n  \"@smthrs/engine-store/SelectionStoreError\",\n  {\n    code: SelectionStoreErrorCode,\n    message: Schema.String,\n    scope: Schema.optional(Schema.String),\n    affects: Schema.optional(Schema.String),\n    cause: Schema.optional(Schema.Unknown)\n  }\n) {}\n\n/**\n * Durable suspected-edge persistence operations. `snapshot` pins the injected\n * clock's now, never `Date.now()`; `train` applies the asymmetric rule \u2014 a\n * hit gains five percent of the remaining headroom, a miss halves \u2014 to\n * matching stored edges only, ignoring unknown pairs rather than creating\n * them. Training retains at most {@link maxEvidenceEntries} newest evidence\n * entries per edge.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Service {\n  readonly upsert: (\n    edges: ReadonlyArray<Selection.SuspectedEdge>\n  ) => Effect.Effect<void, SelectionStoreError>\n  readonly list: () => Effect.Effect<ReadonlyArray<Selection.SuspectedEdge>, SelectionStoreError>\n  readonly snapshot: () => Effect.Effect<Selection.BeliefSnapshot, SelectionStoreError>\n  readonly train: (\n    observations: ReadonlyArray<TrainingObservation>\n  ) => Effect.Effect<void, SelectionStoreError>\n}\n\n/**\n * Service tag for the durable suspected-edge store.\n *\n * @category services\n * @since 0.1.0\n */\nexport class SelectionStore extends Context.Service<SelectionStore, Service>()(\n  \"@smthrs/engine-store/SelectionStore\"\n) {}\n\nconst EvidenceListFromJsonString = Schema.fromJsonString(Schema.Array(Schema.String))\n\nconst EdgeRow = Schema.Struct({\n  scope: Schema.NonEmptyString,\n  affects: Schema.NonEmptyString,\n  confidence: Schema.Number,\n  validFromMs: Selection.NonNegativeSafeInt,\n  evidenceJson: Schema.String\n})\n\ntype EdgeRow = typeof EdgeRow.Type\n\nconst invalidInput = (message: string, cause: unknown): SelectionStoreError =>\n  new SelectionStoreError({ code: \"invalid_input\", message, cause })\n\nconst persistenceFailed = (message: string, cause: unknown): SelectionStoreError =>\n  cause instanceof SelectionStoreError\n    ? cause\n    : new SelectionStoreError({ code: \"persistence_failed\", message, cause })\n\nconst decodeObservation = (input: unknown): Effect.Effect<TrainingObservation, SelectionStoreError> =>\n  Schema.decodeUnknownEffect(TrainingObservation)(input).pipe(\n    Effect.mapError((cause) => invalidInput(\"a training observation is invalid\", cause))\n  )\n\nconst decodeEdge = (input: unknown): Effect.Effect<Selection.SuspectedEdge, SelectionStoreError> =>\n  Schema.decodeUnknownEffect(Selection.SuspectedEdge)(input).pipe(\n    Effect.mapError((cause) => invalidInput(\"a suspected edge is invalid\", cause))\n  )\n\n// `decodeEdge` has already copied and validated this as an array of strings.\n// JSON encoding that closed value cannot fail, so retaining a fictitious\n// schema-error branch here only obscures the actual persistence failures.\nconst encodeEvidence = (evidence: ReadonlyArray<string>): Effect.Effect<string> =>\n  Effect.succeed(JSON.stringify(evidence))\n\nconst decodeEvidence = (\n  evidenceJson: string,\n  row: Pick<EdgeRow, \"scope\" | \"affects\">\n): Effect.Effect<ReadonlyArray<string>, SelectionStoreError> =>\n  Schema.decodeUnknownEffect(EvidenceListFromJsonString)(evidenceJson).pipe(\n    Effect.mapError((cause) =>\n      new SelectionStoreError({\n        code: \"decode_failed\",\n        message: `stored edge ${row.scope} -> ${row.affects} has invalid evidence`,\n        scope: row.scope,\n        affects: row.affects,\n        cause\n      })\n    )\n  )\n\nconst decodeRow = (input: unknown): Effect.Effect<Selection.SuspectedEdge, SelectionStoreError> =>\n  Schema.decodeUnknownEffect(EdgeRow)(input).pipe(\n    Effect.mapError((cause) =>\n      new SelectionStoreError({\n        code: \"decode_failed\",\n        message: \"a stored selection edge row is invalid\",\n        cause\n      })\n    ),\n    Effect.flatMap((row) =>\n      decodeEvidence(row.evidenceJson, row).pipe(\n        Effect.flatMap((evidence) =>\n          Schema.decodeUnknownEffect(Selection.SuspectedEdge)({\n            scope: row.scope,\n            affects: row.affects,\n            confidence: row.confidence,\n            validFromMs: row.validFromMs,\n            evidence\n          }).pipe(Effect.mapError((cause) =>\n            new SelectionStoreError({\n              code: \"decode_failed\",\n              message: `stored edge ${row.scope} -> ${row.affects} is invalid`,\n              scope: row.scope,\n              affects: row.affects,\n              cause\n            })\n          ))\n        )\n      )\n    )\n  )\n\nconst trainConfidence = (confidence: number, outcome: TrainingOutcome): number =>\n  outcome === \"hit\"\n    ? confidence + 0.05 * (1 - confidence)\n    : confidence * 0.5\n\n/**\n * Maximum evidence entries retained for one suspected edge. Training drops\n * the oldest entries after this bound and preserves the newest entries in\n * observation order.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const maxEvidenceEntries = 128\n\n/**\n * Builds the SQL-backed suspected-edge store.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make: Effect.Effect<Service, never, DurableWriter | SqlClient.SqlClient> = Effect.gen(function*() {\n  const sql = yield* SqlClient.SqlClient\n  const writer = yield* DurableWriter\n\n  const selectEdge = (observation: TrainingObservation) =>\n    sql<EdgeRow>`\n      SELECT\n        scope,\n        affects,\n        confidence,\n        valid_from_ms AS \"validFromMs\",\n        evidence_json AS \"evidenceJson\"\n      FROM flows_selection_suspected_edges\n      WHERE scope = ${observation.scope}\n        AND affects = ${observation.affects}\n    `\n\n  const writeEdge = (edge: Selection.SuspectedEdge): Effect.Effect<void, SelectionStoreError> =>\n    Effect.gen(function*() {\n      const evidenceJson = yield* encodeEvidence(edge.evidence)\n      yield* sql`\n        INSERT INTO flows_selection_suspected_edges (\n          scope, affects, confidence, valid_from_ms, evidence_json\n        ) VALUES (\n          ${edge.scope}, ${edge.affects}, ${edge.confidence}, ${edge.validFromMs}, ${evidenceJson}\n        ) ON CONFLICT (scope, affects) DO UPDATE SET\n          confidence = excluded.confidence,\n          valid_from_ms = excluded.valid_from_ms,\n          evidence_json = excluded.evidence_json\n      `.pipe(Effect.mapError((cause) =>\n        persistenceFailed(\n          `could not persist edge ${edge.scope} -> ${edge.affects}`,\n          cause\n        )\n      ))\n    })\n\n  const upsert: Service[\"upsert\"] = Effect.fn(\"SelectionStore.upsert\")((edges) =>\n    Effect.gen(function*() {\n      const decoded = yield* Effect.forEach(edges, decodeEdge)\n      yield* writer.write(Effect.forEach(decoded, writeEdge, { discard: true })).pipe(\n        Effect.mapError((cause) => persistenceFailed(\"could not persist suspected edges\", cause))\n      )\n    })\n  )\n\n  const list: Service[\"list\"] = Effect.fn(\"SelectionStore.list\")(() =>\n    Effect.gen(function*() {\n      const rows = yield* sql<EdgeRow>`\n        SELECT\n          scope,\n          affects,\n          confidence,\n          valid_from_ms AS \"validFromMs\",\n          evidence_json AS \"evidenceJson\"\n        FROM flows_selection_suspected_edges\n        ORDER BY scope, affects\n      `.pipe(Effect.mapError((cause) => persistenceFailed(\"could not list suspected edges\", cause)))\n      return yield* Effect.forEach(rows, decodeRow)\n    })\n  )\n\n  const snapshot: Service[\"snapshot\"] = Effect.fn(\"SelectionStore.snapshot\")(() =>\n    Effect.gen(function*() {\n      const pinnedAtMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor))\n      const edges = yield* list()\n      return { pinnedAtMs, edges }\n    })\n  )\n\n  const train: Service[\"train\"] = Effect.fn(\"SelectionStore.train\")((observations) =>\n    Effect.gen(function*() {\n      const decoded = yield* Effect.forEach(observations, decodeObservation)\n      yield* writer.write(Effect.forEach(\n        decoded,\n        (observation) =>\n          Effect.gen(function*() {\n            const rows = yield* selectEdge(observation).pipe(\n              Effect.mapError((cause) =>\n                persistenceFailed(\n                  `could not read edge ${observation.scope} -> ${observation.affects}`,\n                  cause\n                )\n              )\n            )\n            const row = rows[0]\n            if (row === undefined) return\n            const edge = yield* decodeRow(row)\n            yield* writeEdge({\n              ...edge,\n              confidence: trainConfidence(edge.confidence, observation.outcome),\n              evidence: [...edge.evidence, JSON.stringify(observation)].slice(-maxEvidenceEntries)\n            })\n          }),\n        { discard: true }\n      )).pipe(Effect.mapError((cause) => persistenceFailed(\"could not train suspected edges\", cause)))\n    })\n  )\n\n  return { upsert, list, snapshot, train }\n})\n\n/**\n * Provides the SQL-backed suspected-edge store.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<SelectionStore, never, DurableWriter | SqlClient.SqlClient> = Layer.effect(\n  SelectionStore\n)(make)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,2BAA8B;AAC9B,YAAuB;AACvB,cAAyB;AACzB,aAAwB;AACxB,YAAuB;AACvB,aAAwB;AACxB,gBAA2B;AAC3B,gBAA2B;AASpB,MAAM,kBAAkB,OAAO,SAAS,CAAC,OAAO,MAAM,CAAC;AAgBvD,MAAM,sBAAsB,OAAO,OAAO;AAAA,EAC/C,OAAO,OAAO;AAAA,EACd,SAAS,OAAO;AAAA,EAChB,SAAS;AACX,CAAC;AAgBM,MAAM,0BAA0B,OAAO,SAAS;AAAA,EACrD;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAgBM,MAAM,4BAA4B,OAAO,YAAiC;AAAA,EAC/E;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,SAAS,OAAO;AAAA,IAChB,OAAO,OAAO,SAAS,OAAO,MAAM;AAAA,IACpC,SAAS,OAAO,SAAS,OAAO,MAAM;AAAA,IACtC,OAAO,OAAO,SAAS,OAAO,OAAO;AAAA,EACvC;AACF,EAAE;AAAC;AA8BI,MAAM,uBAAuB,QAAQ,QAAiC;AAAA,EAC3E;AACF,EAAE;AAAC;AAEH,MAAM,6BAA6B,OAAO,eAAe,OAAO,MAAM,OAAO,MAAM,CAAC;AAEpF,MAAM,UAAU,OAAO,OAAO;AAAA,EAC5B,OAAO,OAAO;AAAA,EACd,SAAS,OAAO;AAAA,EAChB,YAAY,OAAO;AAAA,EACnB,aAAa,UAAU;AAAA,EACvB,cAAc,OAAO;AACvB,CAAC;AAID,MAAM,eAAe,CAAC,SAAiB,UACrC,IAAI,oBAAoB,EAAE,MAAM,iBAAiB,SAAS,MAAM,CAAC;AAEnE,MAAM,oBAAoB,CAAC,SAAiB,UAC1C,iBAAiB,sBACb,QACA,IAAI,oBAAoB,EAAE,MAAM,sBAAsB,SAAS,MAAM,CAAC;AAE5E,MAAM,oBAAoB,CAAC,UACzB,OAAO,oBAAoB,mBAAmB,EAAE,KAAK,EAAE;AAAA,EACrD,OAAO,SAAS,CAAC,UAAU,aAAa,qCAAqC,KAAK,CAAC;AACrF;AAEF,MAAM,aAAa,CAAC,UAClB,OAAO,oBAAoB,UAAU,aAAa,EAAE,KAAK,EAAE;AAAA,EACzD,OAAO,SAAS,CAAC,UAAU,aAAa,+BAA+B,KAAK,CAAC;AAC/E;AAKF,MAAM,iBAAiB,CAAC,aACtB,OAAO,QAAQ,KAAK,UAAU,QAAQ,CAAC;AAEzC,MAAM,iBAAiB,CACrB,cACA,QAEA,OAAO,oBAAoB,0BAA0B,EAAE,YAAY,EAAE;AAAA,EACnE,OAAO;AAAA,IAAS,CAAC,UACf,IAAI,oBAAoB;AAAA,MACtB,MAAM;AAAA,MACN,SAAS,eAAe,IAAI,KAAK,OAAO,IAAI,OAAO;AAAA,MACnD,OAAO,IAAI;AAAA,MACX,SAAS,IAAI;AAAA,MACb;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEF,MAAM,YAAY,CAAC,UACjB,OAAO,oBAAoB,OAAO,EAAE,KAAK,EAAE;AAAA,EACzC,OAAO;AAAA,IAAS,CAAC,UACf,IAAI,oBAAoB;AAAA,MACtB,MAAM;AAAA,MACN,SAAS;AAAA,MACT;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EACA,OAAO;AAAA,IAAQ,CAAC,QACd,eAAe,IAAI,cAAc,GAAG,EAAE;AAAA,MACpC,OAAO;AAAA,QAAQ,CAAC,aACd,OAAO,oBAAoB,UAAU,aAAa,EAAE;AAAA,UAClD,OAAO,IAAI;AAAA,UACX,SAAS,IAAI;AAAA,UACb,YAAY,IAAI;AAAA,UAChB,aAAa,IAAI;AAAA,UACjB;AAAA,QACF,CAAC,EAAE,KAAK,OAAO;AAAA,UAAS,CAAC,UACvB,IAAI,oBAAoB;AAAA,YACtB,MAAM;AAAA,YACN,SAAS,eAAe,IAAI,KAAK,OAAO,IAAI,OAAO;AAAA,YACnD,OAAO,IAAI;AAAA,YACX,SAAS,IAAI;AAAA,YACb;AAAA,UACF,CAAC;AAAA,QACH,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AACF;AAEF,MAAM,kBAAkB,CAAC,YAAoB,YAC3C,YAAY,QACR,aAAa,QAAQ,IAAI,cACzB,aAAa;AAUZ,MAAM,qBAAqB;AAQ3B,MAAM,OAA2E,OAAO,IAAI,aAAY;AAC7G,QAAM,MAAM,OAAO,UAAU;AAC7B,QAAM,SAAS,OAAO;AAEtB,QAAM,aAAa,CAAC,gBAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAQkB,YAAY,KAAK;AAAA,wBACf,YAAY,OAAO;AAAA;AAGzC,QAAM,YAAY,CAAC,SACjB,OAAO,IAAI,aAAY;AACrB,UAAM,eAAe,OAAO,eAAe,KAAK,QAAQ;AACxD,WAAO;AAAA;AAAA;AAAA;AAAA,YAID,KAAK,KAAK,KAAK,KAAK,OAAO,KAAK,KAAK,UAAU,KAAK,KAAK,WAAW,KAAK,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA,QAKzF,KAAK,OAAO;AAAA,MAAS,CAAC,UACtB;AAAA,QACE,0BAA0B,KAAK,KAAK,OAAO,KAAK,OAAO;AAAA,QACvD;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAEH,QAAM,SAA4B,OAAO,GAAG,uBAAuB;AAAA,IAAE,CAAC,UACpE,OAAO,IAAI,aAAY;AACrB,YAAM,UAAU,OAAO,OAAO,QAAQ,OAAO,UAAU;AACvD,aAAO,OAAO,MAAM,OAAO,QAAQ,SAAS,WAAW,EAAE,SAAS,KAAK,CAAC,CAAC,EAAE;AAAA,QACzE,OAAO,SAAS,CAAC,UAAU,kBAAkB,qCAAqC,KAAK,CAAC;AAAA,MAC1F;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,OAAwB,OAAO,GAAG,qBAAqB;AAAA,IAAE,MAC7D,OAAO,IAAI,aAAY;AACrB,YAAM,OAAO,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QASlB,KAAK,OAAO,SAAS,CAAC,UAAU,kBAAkB,kCAAkC,KAAK,CAAC,CAAC;AAC7F,aAAO,OAAO,OAAO,QAAQ,MAAM,SAAS;AAAA,IAC9C,CAAC;AAAA,EACH;AAEA,QAAM,WAAgC,OAAO,GAAG,yBAAyB;AAAA,IAAE,MACzE,OAAO,IAAI,aAAY;AACrB,YAAM,aAAa,OAAO,MAAM,kBAAkB,KAAK,OAAO,IAAI,KAAK,KAAK,CAAC;AAC7E,YAAM,QAAQ,OAAO,KAAK;AAC1B,aAAO,EAAE,YAAY,MAAM;AAAA,IAC7B,CAAC;AAAA,EACH;AAEA,QAAM,QAA0B,OAAO,GAAG,sBAAsB;AAAA,IAAE,CAAC,iBACjE,OAAO,IAAI,aAAY;AACrB,YAAM,UAAU,OAAO,OAAO,QAAQ,cAAc,iBAAiB;AACrE,aAAO,OAAO,MAAM,OAAO;AAAA,QACzB;AAAA,QACA,CAAC,gBACC,OAAO,IAAI,aAAY;AACrB,gBAAM,OAAO,OAAO,WAAW,WAAW,EAAE;AAAA,YAC1C,OAAO;AAAA,cAAS,CAAC,UACf;AAAA,gBACE,uBAAuB,YAAY,KAAK,OAAO,YAAY,OAAO;AAAA,gBAClE;AAAA,cACF;AAAA,YACF;AAAA,UACF;AACA,gBAAM,MAAM,KAAK,CAAC;AAClB,cAAI,QAAQ,OAAW;AACvB,gBAAM,OAAO,OAAO,UAAU,GAAG;AACjC,iBAAO,UAAU;AAAA,YACf,GAAG;AAAA,YACH,YAAY,gBAAgB,KAAK,YAAY,YAAY,OAAO;AAAA,YAChE,UAAU,CAAC,GAAG,KAAK,UAAU,KAAK,UAAU,WAAW,CAAC,EAAE,MAAM,CAAC,kBAAkB;AAAA,UACrF,CAAC;AAAA,QACH,CAAC;AAAA,QACH,EAAE,SAAS,KAAK;AAAA,MAClB,CAAC,EAAE,KAAK,OAAO,SAAS,CAAC,UAAU,kBAAkB,mCAAmC,KAAK,CAAC,CAAC;AAAA,IACjG,CAAC;AAAA,EACH;AAEA,SAAO,EAAE,QAAQ,MAAM,UAAU,MAAM;AACzC,CAAC;AAQM,MAAM,QAAiF,MAAM;AAAA,EAClG;AACF,EAAE,IAAI;",
+  "names": []
+}