@smthrs/harness 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/Plan.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Local structural plan nodes used at the harness-to-engine boundary.
+ *
+ * These values project the canonical registry metadata defined by
+ * `@smthrs/registry`'s `Descriptor` and consumed at the splice boundary
+ * described in `../docs/concepts.md#child-plans-and-the-splice-boundary`. Source order is retained
+ * only for result correlation; graph dependencies are the sole sequencing
+ * signal.
+ *
+ * @since 0.1.0
+ */
+import * as ModelRequest from "@smthrs/model/ModelRequest";
+import { Schema } from "effect";
+declare const Child_base: Schema.Class<Child, Schema.Struct<{
+    readonly flowName: Schema.String;
+    readonly callId: Schema.String;
+    readonly args: Schema.Unknown;
+    readonly capabilities: Schema.$Array<Schema.String>;
+    readonly effects: Schema.Struct<{
+        readonly reads: Schema.$Array<Schema.String>;
+        readonly writes: Schema.$Array<Schema.String>;
+        readonly mode: Schema.Literals<readonly ["hermetic", "expected"]>;
+        readonly onConflict: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+        readonly tier: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+    }>;
+    readonly placement: Schema.Option<Schema.Literals<readonly ["client", "local", "sandbox", "remote"]>>;
+}>, {}>;
+/**
+ * One flow invocation elaborated from a model tool call.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class Child extends Child_base {
+}
+declare const Batch_base: Schema.Class<Batch, Schema.Struct<{
+    readonly children: Schema.$Array<typeof Child>;
+}>, {}>;
+/**
+ * The children passed through to the engine.
+ *
+ * The harness preserves model-call order for correlation but never schedules
+ * or serializes a child itself.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class Batch extends Batch_base {
+}
+declare const ChildResult_base: Schema.Class<ChildResult, Schema.Struct<{
+    readonly callId: Schema.String;
+    readonly outcome: Schema.Literals<readonly ["success", "error", "aborted"]>;
+    readonly result: Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly toolCallId: Schema.String;
+        readonly content: Schema.String;
+        readonly addedToolNames: Schema.$Array<Schema.String>;
+    }> & {
+        make: (input: {
+            readonly toolCallId: string;
+            readonly content: string;
+            readonly addedToolNames?: ReadonlyArray<string> | undefined;
+        }) => ModelRequest.ToolResultPart;
+    };
+}>, {}>;
+/**
+ * A settled child outcome suitable for transcript projection.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class ChildResult extends ChildResult_base {
+}
+declare const ChildProgress_base: Schema.Class<ChildProgress, Schema.TaggedStruct<"progress", {
+    readonly callId: Schema.String;
+    readonly message: Schema.String;
+}>, {}>;
+/**
+ * One harness-owned progress update emitted while a child call is executing.
+ *
+ * Progress is intentionally separate from {@link ChildResult}: it is
+ * transient execution telemetry, while a result is the durable transcript
+ * settlement for the call.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class ChildProgress extends ChildProgress_base {
+}
+declare const ChildSettled_base: Schema.Class<ChildSettled, Schema.TaggedStruct<"settled", {
+    readonly result: typeof ChildResult;
+}>, {}>;
+/**
+ * One settled child result in the streaming splice protocol.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare class ChildSettled extends ChildSettled_base {
+}
+/**
+ * Streaming output of one engine splice.
+ *
+ * Engines may publish any number of progress updates before exactly one
+ * settlement for each call. The harness publishes progress immediately and
+ * restores final settlements to model-call order.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export declare const SpliceEvent: Schema.toTaggedUnion<"_tag", readonly [typeof ChildProgress, typeof ChildSettled]>;
+/**
+ * Streaming output of one engine splice.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type SpliceEvent = typeof SpliceEvent.Type;
+export {};
+//# sourceMappingURL=Plan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Plan.d.ts","sourceRoot":"","sources":["../../src/Plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,YAAY,MAAM,4BAA4B,CAAA;AAE1D,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;;;;;;;;;;;;;;;AAE/B;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,UAOzB;CAAG;;;;AAEL;;;;;;;;;GASG;AACH,qBAAa,KAAM,SAAQ,UAEzB;CAAG;;;;;;;;;;;;;mCAqE8gD,CAAC;;;;AAnEphD;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,gBAI/B;CAAG;;;;;AAEL;;;;;;;;;;GAUG;AACH,qBAAa,aAAc,SAAQ,kBAKjC;CAAG;;;;AAEL;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,iBAIhC;CAAG;AAEL;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,oFAEvB,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA"}

package/dist/cjs/Plan.js

@@ -0,0 +1,77 @@
+"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 Plan_exports = {};
+__export(Plan_exports, {
+  Batch: () => Batch,
+  Child: () => Child,
+  ChildProgress: () => ChildProgress,
+  ChildResult: () => ChildResult,
+  ChildSettled: () => ChildSettled,
+  SpliceEvent: () => SpliceEvent
+});
+module.exports = __toCommonJS(Plan_exports);
+var ModelRequest = __toESM(require("@smthrs/model/ModelRequest"), 1);
+var Descriptor = __toESM(require("@smthrs/registry/Descriptor"), 1);
+var import_effect = require("effect");
+class Child extends import_effect.Schema.Class("flows/harness/Plan/Child")({
+  flowName: import_effect.Schema.String,
+  callId: import_effect.Schema.String,
+  args: import_effect.Schema.Unknown,
+  capabilities: import_effect.Schema.Array(import_effect.Schema.String),
+  effects: Descriptor.EffectDeclaration,
+  placement: import_effect.Schema.Option(Descriptor.Placement)
+}) {
+}
+class Batch extends import_effect.Schema.Class("flows/harness/Plan/Batch")({
+  children: import_effect.Schema.Array(Child)
+}) {
+}
+class ChildResult extends import_effect.Schema.Class("flows/harness/Plan/ChildResult")({
+  callId: import_effect.Schema.String,
+  outcome: import_effect.Schema.Literals(["success", "error", "aborted"]),
+  result: ModelRequest.ToolResultPart
+}) {
+}
+class ChildProgress extends import_effect.Schema.TaggedClass(
+  "flows/harness/Plan/ChildProgress"
+)("progress", {
+  callId: import_effect.Schema.String,
+  message: import_effect.Schema.String
+}) {
+}
+class ChildSettled extends import_effect.Schema.TaggedClass(
+  "flows/harness/Plan/ChildSettled"
+)("settled", {
+  result: ChildResult
+}) {
+}
+const SpliceEvent = import_effect.Schema.Union([ChildProgress, ChildSettled]).pipe(
+  import_effect.Schema.toTaggedUnion("_tag")
+);
+//# sourceMappingURL=Plan.js.map

package/dist/cjs/Plan.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Plan.ts"],
+  "sourcesContent": ["/**\n * Local structural plan nodes used at the harness-to-engine boundary.\n *\n * These values project the canonical registry metadata defined by\n * `@smthrs/registry`'s `Descriptor` and consumed at the splice boundary\n * described in `../docs/concepts.md#child-plans-and-the-splice-boundary`. Source order is retained\n * only for result correlation; graph dependencies are the sole sequencing\n * signal.\n *\n * @since 0.1.0\n */\n\nimport * as ModelRequest from \"@smthrs/model/ModelRequest\"\nimport * as Descriptor from \"@smthrs/registry/Descriptor\"\nimport { Schema } from \"effect\"\n\n/**\n * One flow invocation elaborated from a model tool call.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Child extends Schema.Class<Child>(\"flows/harness/Plan/Child\")({\n  flowName: Schema.String,\n  callId: Schema.String,\n  args: Schema.Unknown,\n  capabilities: Schema.Array(Schema.String),\n  effects: Descriptor.EffectDeclaration,\n  placement: Schema.Option(Descriptor.Placement)\n}) {}\n\n/**\n * The children passed through to the engine.\n *\n * The harness preserves model-call order for correlation but never schedules\n * or serializes a child itself.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Batch extends Schema.Class<Batch>(\"flows/harness/Plan/Batch\")({\n  children: Schema.Array(Child)\n}) {}\n\n/**\n * A settled child outcome suitable for transcript projection.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class ChildResult extends Schema.Class<ChildResult>(\"flows/harness/Plan/ChildResult\")({\n  callId: Schema.String,\n  outcome: Schema.Literals([\"success\", \"error\", \"aborted\"]),\n  result: ModelRequest.ToolResultPart\n}) {}\n\n/**\n * One harness-owned progress update emitted while a child call is executing.\n *\n * Progress is intentionally separate from {@link ChildResult}: it is\n * transient execution telemetry, while a result is the durable transcript\n * settlement for the call.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class ChildProgress extends Schema.TaggedClass<ChildProgress>(\n  \"flows/harness/Plan/ChildProgress\"\n)(\"progress\", {\n  callId: Schema.String,\n  message: Schema.String\n}) {}\n\n/**\n * One settled child result in the streaming splice protocol.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class ChildSettled extends Schema.TaggedClass<ChildSettled>(\n  \"flows/harness/Plan/ChildSettled\"\n)(\"settled\", {\n  result: ChildResult\n}) {}\n\n/**\n * Streaming output of one engine splice.\n *\n * Engines may publish any number of progress updates before exactly one\n * settlement for each call. The harness publishes progress immediately and\n * restores final settlements to model-call order.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport const SpliceEvent = Schema.Union([ChildProgress, ChildSettled]).pipe(\n  Schema.toTaggedUnion(\"_tag\")\n)\n\n/**\n * Streaming output of one engine splice.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type SpliceEvent = typeof SpliceEvent.Type\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,mBAA8B;AAC9B,iBAA4B;AAC5B,oBAAuB;AAShB,MAAM,cAAc,qBAAO,MAAa,0BAA0B,EAAE;AAAA,EACzE,UAAU,qBAAO;AAAA,EACjB,QAAQ,qBAAO;AAAA,EACf,MAAM,qBAAO;AAAA,EACb,cAAc,qBAAO,MAAM,qBAAO,MAAM;AAAA,EACxC,SAAS,WAAW;AAAA,EACpB,WAAW,qBAAO,OAAO,WAAW,SAAS;AAC/C,CAAC,EAAE;AAAC;AAYG,MAAM,cAAc,qBAAO,MAAa,0BAA0B,EAAE;AAAA,EACzE,UAAU,qBAAO,MAAM,KAAK;AAC9B,CAAC,EAAE;AAAC;AASG,MAAM,oBAAoB,qBAAO,MAAmB,gCAAgC,EAAE;AAAA,EAC3F,QAAQ,qBAAO;AAAA,EACf,SAAS,qBAAO,SAAS,CAAC,WAAW,SAAS,SAAS,CAAC;AAAA,EACxD,QAAQ,aAAa;AACvB,CAAC,EAAE;AAAC;AAaG,MAAM,sBAAsB,qBAAO;AAAA,EACxC;AACF,EAAE,YAAY;AAAA,EACZ,QAAQ,qBAAO;AAAA,EACf,SAAS,qBAAO;AAClB,CAAC,EAAE;AAAC;AASG,MAAM,qBAAqB,qBAAO;AAAA,EACvC;AACF,EAAE,WAAW;AAAA,EACX,QAAQ;AACV,CAAC,EAAE;AAAC;AAaG,MAAM,cAAc,qBAAO,MAAM,CAAC,eAAe,YAAY,CAAC,EAAE;AAAA,EACrE,qBAAO,cAAc,MAAM;AAC7B;",
+  "names": []
+}

package/dist/cjs/QuickJSSandbox.d.ts

@@ -0,0 +1,151 @@
+/**
+ * The QuickJS-WASM sandbox binding.
+ *
+ * This is the production `Sandbox`: the cell runs inside a QuickJS interpreter
+ * compiled to WebAssembly, which is a genuinely separate JavaScript realm with
+ * no reference to the host's globals, prototypes, or module loader. The same
+ * single-file variant runs unmodified on Node and in a browser, so a browser
+ * host provides this layer and calls the identical harness.
+ *
+ * What the cell can reach is exactly `ctx`: `ctx.call` bridges to the host's
+ * durable flow boundary, `ctx.flows` is a frozen catalog projection. The
+ * prelude removes `Date` and `Math.random` from the realm, because a replayed
+ * cell must reach the same calls in the same order, and `Proxy`, because a
+ * value that answers reflection from a handler cannot be weighed against the
+ * run's memory ceiling. There is no filesystem, no network, no process, and no
+ * module loader to reach in the first place.
+ *
+ * Teardown is scope finalization and cancellation is fiber interruption: an
+ * interrupted frame disposes the runtime, which is the only thing holding the
+ * cell alive.
+ *
+ * Which QuickJS build is compiled is a seam. The default compiles the
+ * single-file build from bytes, which is what Node and a browser want. A host
+ * whose runtime forbids compiling WebAssembly from bytes at runtime, such as
+ * Cloudflare's workerd, provides {@link Variant} instead and names a build
+ * whose module came from its toolchain.
+ *
+ * @since 0.1.0
+ */
+import { Context, Effect, Layer } from "effect";
+import type { QuickJSSyncVariant, QuickJSWASMModule } from "quickjs-emscripten-core";
+import * as Sandbox from "./Sandbox.ts";
+/**
+ * Caches only a successful asynchronous load; a rejection may be retried.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const cacheSuccessful: <A>(load: () => Promise<A>) => () => Promise<A>;
+/**
+ * The QuickJS build the sandbox compiles.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface VariantService {
+    readonly variant: QuickJSSyncVariant;
+}
+declare const Variant_base: Context.ServiceClass<Variant, "@smthrs/harness/QuickJSSandbox/Variant", VariantService>;
+/**
+ * The QuickJS build the sandbox compiles.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class Variant extends Variant_base {
+}
+/**
+ * Provides the single-file build, which Node and a browser both compile.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerVariantLive: Layer.Layer<Variant>;
+/**
+ * Provides a build the host names.
+ *
+ * A workerd host builds one with `newVariant(baseVariant, { wasmModule })` from
+ * a `.wasm` module import, because that runtime instantiates a module the
+ * toolchain compiled and refuses to compile one from bytes.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerVariant: (variant: QuickJSSyncVariant) => Layer.Layer<Variant>;
+/**
+ * Synchronous monotonic-enough clock required by QuickJS's interrupt callback.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface ComputeClockService {
+    readonly now: () => number;
+}
+declare const ComputeClock_base: Context.ServiceClass<ComputeClock, "@smthrs/harness/QuickJSSandbox/ComputeClock", ComputeClockService>;
+/**
+ * Synchronous monotonic-enough clock required by QuickJS's interrupt callback.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class ComputeClock extends ComputeClock_base {
+}
+/**
+ * Provides the browser-safe host clock behind the QuickJS clock seam.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerClockLive: Layer.Layer<ComputeClock>;
+/**
+ * Loads a QuickJS module through the sandbox's typed failure boundary.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const loadModule: (loader: () => Promise<QuickJSWASMModule>) => Effect.Effect<QuickJSWASMModule, Sandbox.SandboxError>;
+/**
+ * Constructs the QuickJS sandbox over the build the host names, compiling the
+ * WebAssembly module once.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeWithVariant: Effect.Effect<Sandbox.Sandbox, Sandbox.SandboxError, ComputeClock | Variant>;
+/**
+ * Constructs the QuickJS sandbox over the single-file build.
+ *
+ * The build is fixed here rather than left in the requirements, so the clock
+ * stays the only seam this constructor asks its caller to fill. A host that
+ * names its own build uses {@link makeWithVariant}.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const makeWithClock: Effect.Effect<Sandbox.Sandbox, Sandbox.SandboxError, ComputeClock>;
+/**
+ * Constructs the QuickJS sandbox with the live clock layer.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: Effect.Effect<Sandbox.Sandbox, Sandbox.SandboxError>;
+/**
+ * Provides the QuickJS sandbox over the build the host names.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerWithVariant: Layer.Layer<Sandbox.Sandbox, Sandbox.SandboxError, Variant>;
+/**
+ * Provides the QuickJS sandbox over the single-file build.
+ *
+ * @category layers
+ * @since 0.1.0
+ * @slop
+ */
+export declare const layer: Layer.Layer<Sandbox.Sandbox, Sandbox.SandboxError>;
+export {};
+//# sourceMappingURL=QuickJSSandbox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"QuickJSSandbox.d.ts","sourceRoot":"","sources":["../../src/QuickJSSandbox.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EAAE,OAAO,EAAY,MAAM,EAAE,KAAK,EAA8B,MAAM,QAAQ,CAAA;AACrF,OAAO,KAAK,EAIV,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,yBAAyB,CAAA;AAQhC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAgWvC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,MAAM,MAAM,OAAO,CAAC,CAAC,CAAC,KAAG,MAAM,OAAO,CAAC,CAAC,CAY1E,CAAA;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;CACrC;;AAED;;;;;GAKG;AACH,qBAAa,OAAQ,SAAQ,YAE5B;CAAG;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAmD,CAAA;AAErG;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,kBAAkB,KAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAwC,CAAA;AAkBtH;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAA;CAC3B;;AAED;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,iBAEjC;CAAG;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,KAAK,CAAC,YAAY,CAA0D,CAAA;AAi9B/G;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,MAAM,OAAO,CAAC,iBAAiB,CAAC,KACvC,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,OAAO,CAAC,YAAY,CASpD,CAAA;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CASrG,CAAA;AAEJ;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,EAAE,YAAY,CAE5F,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAErE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,EAAE,OAAO,CAElC,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAuC,CAAA"}