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

package/dist/cjs/StepSandbox.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/StepSandbox.ts"],
+  "sourcesContent": ["/**\n * Injectable, scope-safe step sandboxing over the workspace transaction.\n *\n * @since 0.1.0\n */\n\nimport type * as ArtifactStore from \"@smthrs/artifacts/ArtifactStore\"\nimport type * as KernelWorkspace from \"@smthrs/kernel/Workspace\"\nimport * as Context from \"effect/Context\"\nimport type * as Crypto from \"effect/Crypto\"\nimport * as Effect from \"effect/Effect\"\nimport type * as FileSystem from \"effect/FileSystem\"\nimport * as Layer from \"effect/Layer\"\nimport type * as Path from \"effect/Path\"\nimport * as Schema from \"effect/Schema\"\nimport * as StepBoundary from \"./StepBoundary.ts\"\nimport * as WorkspaceSandbox from \"./WorkspaceSandbox.ts\"\n\n/**\n * A hermetic body attempted to read a path outside its declared read set.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class UndeclaredRead extends Schema.TaggedError<UndeclaredRead>()(\n  \"@smthrs/engine-store/UndeclaredRead\",\n  {\n    code: Schema.Literal(\"undeclared_read\"),\n    paths: Schema.Array(Schema.String),\n    diffIdentity: Schema.NonEmptyString\n  }\n) {}\n\n/**\n * A sandbox that can acquire an isolated workspace for one step.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Service {\n  readonly open: Effect.Effect<WorkspaceSandbox.Service, StepBoundary.UnsupportedBoundary>\n}\n\n/**\n * Injectable step-sandbox service.\n *\n * @category services\n * @since 0.1.0\n */\nexport const StepSandbox: Context.Service<Service, Service> = Context.Service<Service>(\n  \"@smthrs/engine-store/StepSandbox\"\n)\n\n/**\n * Constructs a step sandbox around a workspace transaction backend.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (workspace: WorkspaceSandbox.Service): Service =>\n  StepSandbox.of({\n    open: Effect.succeed(workspace)\n  })\n\n/**\n * Filesystem-backed sandbox layer. The workspace transaction seeds only the\n * declared reads, exposes its scoped FileSystem to the body, observes every\n * mutation, and performs atomic copy-back on release. Built from\n * `WorkspaceSandbox.layerFileSystem`, so it refuses a path-based host the same way.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<\n  Service,\n  WorkspaceSandbox.WorkspaceError,\n  FileSystem.FileSystem | Path.Path | ArtifactStore.ArtifactStore | KernelWorkspace.Workspace\n> = Layer.effect(\n  StepSandbox,\n  Effect.map(WorkspaceSandbox.WorkspaceSandbox, make)\n).pipe(Layer.provide(WorkspaceSandbox.layerFileSystem()))\n\n/**\n * Deterministic in-memory sandbox layer for tests.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerTest = (\n  initialFiles: WorkspaceSandbox.InitialFiles = {}\n): Layer.Layer<Service, WorkspaceSandbox.WorkspaceError, Crypto.Crypto> =>\n  Layer.effect(StepSandbox, Effect.map(WorkspaceSandbox.makeMemory(initialFiles), (sandbox) => make(sandbox.service)))\n\nconst unsupported = new StepBoundary.UnsupportedBoundary({\n  code: \"unsupported_boundary\",\n  message: \"this host cannot provide a hermetic step sandbox\"\n})\n\n/**\n * Fail-closed host layer for environments that cannot sandbox (for example browsers).\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop: Layer.Layer<Service> = Layer.succeed(\n  StepSandbox,\n  StepSandbox.of({\n    open: Effect.fail(unsupported)\n  })\n)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,cAAyB;AAEzB,aAAwB;AAExB,YAAuB;AAEvB,aAAwB;AACxB,mBAA8B;AAC9B,uBAAkC;AAQ3B,MAAM,uBAAuB,OAAO,YAA4B;AAAA,EACrE;AAAA,EACA;AAAA,IACE,MAAM,OAAO,QAAQ,iBAAiB;AAAA,IACtC,OAAO,OAAO,MAAM,OAAO,MAAM;AAAA,IACjC,cAAc,OAAO;AAAA,EACvB;AACF,EAAE;AAAC;AAkBI,MAAM,cAAiD,QAAQ;AAAA,EACpE;AACF;AAQO,MAAM,OAAO,CAAC,cACnB,YAAY,GAAG;AAAA,EACb,MAAM,OAAO,QAAQ,SAAS;AAChC,CAAC;AAWI,MAAM,QAIT,MAAM;AAAA,EACR;AAAA,EACA,OAAO,IAAI,iBAAiB,kBAAkB,IAAI;AACpD,EAAE,KAAK,MAAM,QAAQ,iBAAiB,gBAAgB,CAAC,CAAC;AAQjD,MAAM,YAAY,CACvB,eAA8C,CAAC,MAE/C,MAAM,OAAO,aAAa,OAAO,IAAI,iBAAiB,WAAW,YAAY,GAAG,CAAC,YAAY,KAAK,QAAQ,OAAO,CAAC,CAAC;AAErH,MAAM,cAAc,IAAI,aAAa,oBAAoB;AAAA,EACvD,MAAM;AAAA,EACN,SAAS;AACX,CAAC;AAQM,MAAM,YAAkC,MAAM;AAAA,EACnD;AAAA,EACA,YAAY,GAAG;AAAA,IACb,MAAM,OAAO,KAAK,WAAW;AAAA,EAC/B,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/WakeBus.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The in-process wake bus: durable writes that make a run runnable — a
+ * deferred completed, a durable clock fired, an operator resume — announce
+ * the run id here, and in-process waiters parked on that run resume
+ * immediately instead of waiting out a poll tick.
+ *
+ * The bus is EDGE-TRIGGERED and MISS-TOLERANT by design. A wake published
+ * while nobody waits is dropped, not queued: durable state already records
+ * that the run is runnable, and the engine's suspension polling schedule
+ * (`suspendedRetryPolicy`) remains the bounded fallback that re-drives any
+ * run whose wake the bus missed. Temporal's scheduled task queue takes the
+ * same position — `NotifyNewTasks` is a coalesced, non-blocking channel send
+ * and `MaxPollInterval` bounds the polling fallback (`reference/temporal`
+ * `service/history/queues/queue_scheduled.go`) — because a lossless bus
+ * would have to be durable, and the durable record already exists. Waiter
+ * registration follows opencode's in-process job registry: one `Deferred`
+ * per waiter, succeeded on completion, removed when the waiter's own scope
+ * closes (`reference/opencode` `packages/smithers/flows/core/src/background-job.ts`).
+ *
+ * Cross-process wakes never reach this bus: another process's deferred
+ * completion is observed through the store, on the polling schedule and the
+ * heartbeat sweeps. That split is deliberate v1 scope — an event-driven
+ * cross-process wake needs a committed journal subscription, which is a
+ * separate seam.
+ *
+ * The bus holds no host access at all — a `Map` of `Deferred`s — so it is
+ * browser-safe without a platform layer.
+ *
+ * @since 0.1.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * Wake bus operations.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Service {
+    /**
+     * Announces that a durable write made the run runnable. Every waiter
+     * currently parked on `executionId` resumes; with no waiters the wake is
+     * dropped and the polling fallback covers the run.
+     */
+    readonly wake: (executionId: string) => Effect.Effect<void>;
+    /**
+     * Parks until the next {@link wake} for `executionId`. Registration is
+     * removed when the waiting fiber is interrupted — including scope closure
+     * and losing a race against the polling sleep — so an abandoned wait
+     * leaks nothing.
+     *
+     * The wait is keyed by execution id alone: execution ids are unique
+     * across flows, so the flow tag adds no discrimination.
+     */
+    readonly awaitWake: (executionId: string) => Effect.Effect<void>;
+    /**
+     * How many waiters are currently parked on `executionId`. This is
+     * observability for tests and diagnostics, not a coordination primitive:
+     * a count observed now says nothing about a moment later.
+     */
+    readonly waiters: (executionId: string) => Effect.Effect<number>;
+}
+declare const WakeBus_base: Context.ServiceClass<WakeBus, "@smthrs/engine-store/WakeBus", Service>;
+/**
+ * Service tag for the in-process wake bus.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class WakeBus extends WakeBus_base {
+}
+/**
+ * Constructs a wake bus. Registration and delivery are plain in-memory
+ * operations on the constructing process; nothing is durable.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeUnsafe: () => Service;
+/**
+ * Constructs a wake bus effectfully. Prefer this in compositions;
+ * {@link makeUnsafe} exists for construction outside a fiber.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: Effect.Effect<Service>;
+/**
+ * A bus that never delivers: wakes are dropped and waiters park forever.
+ * With it in place every resume travels the polling fallback — which is
+ * exactly what a test asserting the fallback provides it for.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeNoop: (overrides?: Partial<Service>) => Service;
+/**
+ * Provides a fresh wake bus. An engine composition resolves the bus
+ * optionally, so providing this layer is how a host shares one bus between
+ * the engine and its own wake sources; a composition given none builds a
+ * private bus.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<WakeBus>;
+/**
+ * Provides {@link makeNoop}.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerNoop: (overrides?: Partial<Service>) => Layer.Layer<WakeBus>;
+export {};
+//# sourceMappingURL=WakeBus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WakeBus.d.ts","sourceRoot":"","sources":["../../src/WakeBus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAEzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC3D;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAChE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;CACjE;;AAED;;;;;GAKG;AACH,qBAAa,OAAQ,SAAQ,YAAmE;CAAG;AAEnG;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,QAAO,OAuC7B,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAA2B,CAAA;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,YAAY,OAAO,CAAC,OAAO,CAAC,KAAG,OAMpD,CAAA;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAmC,CAAA;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,YAAY,OAAO,CAAC,OAAO,CAAC,KAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAC5B,CAAA"}

package/dist/cjs/WakeBus.js

@@ -0,0 +1,89 @@
+"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 WakeBus_exports = {};
+__export(WakeBus_exports, {
+  WakeBus: () => WakeBus,
+  layer: () => layer,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeNoop: () => makeNoop,
+  makeUnsafe: () => makeUnsafe
+});
+module.exports = __toCommonJS(WakeBus_exports);
+var Context = __toESM(require("effect/Context"), 1);
+var Deferred = __toESM(require("effect/Deferred"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+class WakeBus extends Context.Service()("@smthrs/engine-store/WakeBus") {
+}
+const makeUnsafe = () => {
+  const parked = /* @__PURE__ */ new Map();
+  return WakeBus.of({
+    wake: (executionId) => Effect.suspend(() => {
+      const waiters = parked.get(executionId);
+      if (waiters === void 0) return Effect.void;
+      return Effect.forEach(
+        Array.from(waiters),
+        (waiter) => Deferred.succeed(waiter, void 0),
+        { discard: true }
+      );
+    }),
+    awaitWake: (executionId) => Effect.acquireUseRelease(
+      Effect.sync(() => {
+        const waiter = Deferred.makeUnsafe();
+        let waiters = parked.get(executionId);
+        if (waiters === void 0) {
+          waiters = /* @__PURE__ */ new Set();
+          parked.set(executionId, waiters);
+        }
+        waiters.add(waiter);
+        return { waiter, waiters };
+      }),
+      ({ waiter }) => Deferred.await(waiter),
+      // The registration's own set is closed over rather than re-fetched:
+      // the map entry can only be deleted by the release that empties it,
+      // so the set this waiter joined is the set it must leave.
+      ({ waiter, waiters }) => Effect.sync(() => {
+        waiters.delete(waiter);
+        if (waiters.size === 0) parked.delete(executionId);
+      })
+    ),
+    waiters: (executionId) => Effect.sync(() => parked.get(executionId)?.size ?? 0)
+  });
+};
+const make = Effect.sync(makeUnsafe);
+const makeNoop = (overrides) => WakeBus.of({
+  wake: () => Effect.void,
+  awaitWake: () => Effect.never,
+  waiters: () => Effect.succeed(0),
+  ...overrides
+});
+const layer = Layer.sync(WakeBus)(makeUnsafe);
+const layerNoop = (overrides) => Layer.sync(WakeBus)(() => makeNoop(overrides));
+//# sourceMappingURL=WakeBus.js.map

package/dist/cjs/WakeBus.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/WakeBus.ts"],
+  "sourcesContent": ["/**\n * The in-process wake bus: durable writes that make a run runnable \u2014 a\n * deferred completed, a durable clock fired, an operator resume \u2014 announce\n * the run id here, and in-process waiters parked on that run resume\n * immediately instead of waiting out a poll tick.\n *\n * The bus is EDGE-TRIGGERED and MISS-TOLERANT by design. A wake published\n * while nobody waits is dropped, not queued: durable state already records\n * that the run is runnable, and the engine's suspension polling schedule\n * (`suspendedRetryPolicy`) remains the bounded fallback that re-drives any\n * run whose wake the bus missed. Temporal's scheduled task queue takes the\n * same position \u2014 `NotifyNewTasks` is a coalesced, non-blocking channel send\n * and `MaxPollInterval` bounds the polling fallback (`reference/temporal`\n * `service/history/queues/queue_scheduled.go`) \u2014 because a lossless bus\n * would have to be durable, and the durable record already exists. Waiter\n * registration follows opencode's in-process job registry: one `Deferred`\n * per waiter, succeeded on completion, removed when the waiter's own scope\n * closes (`reference/opencode` `packages/smithers/flows/core/src/background-job.ts`).\n *\n * Cross-process wakes never reach this bus: another process's deferred\n * completion is observed through the store, on the polling schedule and the\n * heartbeat sweeps. That split is deliberate v1 scope \u2014 an event-driven\n * cross-process wake needs a committed journal subscription, which is a\n * separate seam.\n *\n * The bus holds no host access at all \u2014 a `Map` of `Deferred`s \u2014 so it is\n * browser-safe without a platform layer.\n *\n * @since 0.1.0\n */\n\nimport * as Context from \"effect/Context\"\nimport * as Deferred from \"effect/Deferred\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\n\n/**\n * Wake bus operations.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Service {\n  /**\n   * Announces that a durable write made the run runnable. Every waiter\n   * currently parked on `executionId` resumes; with no waiters the wake is\n   * dropped and the polling fallback covers the run.\n   */\n  readonly wake: (executionId: string) => Effect.Effect<void>\n  /**\n   * Parks until the next {@link wake} for `executionId`. Registration is\n   * removed when the waiting fiber is interrupted \u2014 including scope closure\n   * and losing a race against the polling sleep \u2014 so an abandoned wait\n   * leaks nothing.\n   *\n   * The wait is keyed by execution id alone: execution ids are unique\n   * across flows, so the flow tag adds no discrimination.\n   */\n  readonly awaitWake: (executionId: string) => Effect.Effect<void>\n  /**\n   * How many waiters are currently parked on `executionId`. This is\n   * observability for tests and diagnostics, not a coordination primitive:\n   * a count observed now says nothing about a moment later.\n   */\n  readonly waiters: (executionId: string) => Effect.Effect<number>\n}\n\n/**\n * Service tag for the in-process wake bus.\n *\n * @category services\n * @since 0.1.0\n */\nexport class WakeBus extends Context.Service<WakeBus, Service>()(\"@smthrs/engine-store/WakeBus\") {}\n\n/**\n * Constructs a wake bus. Registration and delivery are plain in-memory\n * operations on the constructing process; nothing is durable.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const makeUnsafe = (): Service => {\n  const parked = new Map<string, Set<Deferred.Deferred<void>>>()\n  return WakeBus.of({\n    wake: (executionId) =>\n      Effect.suspend(() => {\n        const waiters = parked.get(executionId)\n        if (waiters === undefined) return Effect.void\n        // Snapshot before succeeding: each woken waiter's release removes it\n        // from the live set, and delivery must not observe that mutation.\n        return Effect.forEach(\n          Array.from(waiters),\n          (waiter) => Deferred.succeed(waiter, undefined),\n          { discard: true }\n        )\n      }),\n    awaitWake: (executionId) =>\n      Effect.acquireUseRelease(\n        Effect.sync(() => {\n          const waiter = Deferred.makeUnsafe<void>()\n          let waiters = parked.get(executionId)\n          if (waiters === undefined) {\n            waiters = new Set()\n            parked.set(executionId, waiters)\n          }\n          waiters.add(waiter)\n          return { waiter, waiters }\n        }),\n        ({ waiter }) => Deferred.await(waiter),\n        // The registration's own set is closed over rather than re-fetched:\n        // the map entry can only be deleted by the release that empties it,\n        // so the set this waiter joined is the set it must leave.\n        ({ waiter, waiters }) =>\n          Effect.sync(() => {\n            waiters.delete(waiter)\n            if (waiters.size === 0) parked.delete(executionId)\n          })\n      ),\n    waiters: (executionId) => Effect.sync(() => parked.get(executionId)?.size ?? 0)\n  })\n}\n\n/**\n * Constructs a wake bus effectfully. Prefer this in compositions;\n * {@link makeUnsafe} exists for construction outside a fiber.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make: Effect.Effect<Service> = Effect.sync(makeUnsafe)\n\n/**\n * A bus that never delivers: wakes are dropped and waiters park forever.\n * With it in place every resume travels the polling fallback \u2014 which is\n * exactly what a test asserting the fallback provides it for.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const makeNoop = (overrides?: Partial<Service>): Service =>\n  WakeBus.of({\n    wake: () => Effect.void,\n    awaitWake: () => Effect.never,\n    waiters: () => Effect.succeed(0),\n    ...overrides\n  })\n\n/**\n * Provides a fresh wake bus. An engine composition resolves the bus\n * optionally, so providing this layer is how a host shares one bus between\n * the engine and its own wake sources; a composition given none builds a\n * private bus.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<WakeBus> = Layer.sync(WakeBus)(makeUnsafe)\n\n/**\n * Provides {@link makeNoop}.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop = (overrides?: Partial<Service>): Layer.Layer<WakeBus> =>\n  Layer.sync(WakeBus)(() => makeNoop(overrides))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BA,cAAyB;AACzB,eAA0B;AAC1B,aAAwB;AACxB,YAAuB;AAuChB,MAAM,gBAAgB,QAAQ,QAA0B,EAAE,8BAA8B,EAAE;AAAC;AAS3F,MAAM,aAAa,MAAe;AACvC,QAAM,SAAS,oBAAI,IAA0C;AAC7D,SAAO,QAAQ,GAAG;AAAA,IAChB,MAAM,CAAC,gBACL,OAAO,QAAQ,MAAM;AACnB,YAAM,UAAU,OAAO,IAAI,WAAW;AACtC,UAAI,YAAY,OAAW,QAAO,OAAO;AAGzC,aAAO,OAAO;AAAA,QACZ,MAAM,KAAK,OAAO;AAAA,QAClB,CAAC,WAAW,SAAS,QAAQ,QAAQ,MAAS;AAAA,QAC9C,EAAE,SAAS,KAAK;AAAA,MAClB;AAAA,IACF,CAAC;AAAA,IACH,WAAW,CAAC,gBACV,OAAO;AAAA,MACL,OAAO,KAAK,MAAM;AAChB,cAAM,SAAS,SAAS,WAAiB;AACzC,YAAI,UAAU,OAAO,IAAI,WAAW;AACpC,YAAI,YAAY,QAAW;AACzB,oBAAU,oBAAI,IAAI;AAClB,iBAAO,IAAI,aAAa,OAAO;AAAA,QACjC;AACA,gBAAQ,IAAI,MAAM;AAClB,eAAO,EAAE,QAAQ,QAAQ;AAAA,MAC3B,CAAC;AAAA,MACD,CAAC,EAAE,OAAO,MAAM,SAAS,MAAM,MAAM;AAAA;AAAA;AAAA;AAAA,MAIrC,CAAC,EAAE,QAAQ,QAAQ,MACjB,OAAO,KAAK,MAAM;AAChB,gBAAQ,OAAO,MAAM;AACrB,YAAI,QAAQ,SAAS,EAAG,QAAO,OAAO,WAAW;AAAA,MACnD,CAAC;AAAA,IACL;AAAA,IACF,SAAS,CAAC,gBAAgB,OAAO,KAAK,MAAM,OAAO,IAAI,WAAW,GAAG,QAAQ,CAAC;AAAA,EAChF,CAAC;AACH;AASO,MAAM,OAA+B,OAAO,KAAK,UAAU;AAU3D,MAAM,WAAW,CAAC,cACvB,QAAQ,GAAG;AAAA,EACT,MAAM,MAAM,OAAO;AAAA,EACnB,WAAW,MAAM,OAAO;AAAA,EACxB,SAAS,MAAM,OAAO,QAAQ,CAAC;AAAA,EAC/B,GAAG;AACL,CAAC;AAWI,MAAM,QAA8B,MAAM,KAAK,OAAO,EAAE,UAAU;AAQlE,MAAM,YAAY,CAAC,cACxB,MAAM,KAAK,OAAO,EAAE,MAAM,SAAS,SAAS,CAAC;",
+  "names": []
+}