@smthrs/gateway 0.35.0 → 1.0.0-rc.4

package/dist/cjs/HostBranchPresence.js

@@ -0,0 +1,82 @@
+"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 HostBranchPresence_exports = {};
+__export(HostBranchPresence_exports, {
+  layer: () => layer
+});
+module.exports = __toCommonJS(HostBranchPresence_exports);
+var BranchPresence = __toESM(require("@smthrs/sync/BranchPresence"), 1);
+var import_BranchRpcs = require("@smthrs/sync/BranchRpcs");
+var BranchShare = __toESM(require("@smthrs/sync/BranchShare"), 1);
+var import_SyncError = require("@smthrs/sync/SyncError");
+var import_SyncRpcs = require("@smthrs/sync/SyncRpcs");
+var import_effect = require("effect");
+var import_rpc = require("effect/unstable/rpc");
+const layer = (config) => import_effect.Layer.unwrap(import_effect.Effect.gen(function* () {
+  const share = yield* BranchShare.makeHmac({
+    activeKid: "host",
+    keys: [{ kid: "host", secret: import_effect.Redacted.make(crypto.randomUUID() + crypto.randomUUID()) }]
+  });
+  const presence = yield* BranchPresence.makeMemory({
+    sourcesReady: () => import_effect.Effect.succeed(true)
+  }).pipe(import_effect.Effect.provideService(BranchShare.BranchShare, share));
+  const authorize = (request, actor = "roster") => share.mint({
+    branchId: request.branchId,
+    capabilityId: actor,
+    access: "write",
+    ttlMs: 6e4
+  }).pipe(import_effect.Effect.map((capability) => ({ ...request, capability })));
+  const unsupported = new import_SyncError.SyncError({ code: "unsupported", message: "This mount serves presence only" });
+  const handlers = import_BranchRpcs.BranchRpcs.toLayer(import_effect.Effect.succeed(import_BranchRpcs.BranchRpcs.of({
+    "Branch.CreateBranch": () => import_effect.Effect.fail(unsupported),
+    "Branch.MintShare": () => import_effect.Effect.fail(unsupported),
+    "Branch.Submit": () => import_effect.Effect.fail(unsupported),
+    "Branch.Announce": (request) => authorize(request, request.participantId).pipe(import_effect.Effect.flatMap(presence.announce)),
+    "Branch.Leave": (request) => authorize(request, request.participantId).pipe(import_effect.Effect.flatMap(presence.leave), import_effect.Effect.as(null)),
+    "Branch.Roster": (request) => authorize(request).pipe(import_effect.Effect.flatMap(presence.list)),
+    "Branch.PresenceOn": (request) => authorize(request).pipe(import_effect.Effect.flatMap(
+      (authorized) => request.sourcesReady === true ? presence.presenceOn(authorized) : import_effect.Effect.succeed("unknown")
+    )),
+    "Branch.WatchRoster": () => import_effect.Stream.fail(unsupported)
+  })));
+  const auth = import_effect.Layer.succeed(import_SyncRpcs.SyncAuth)(
+    (effect, options) => import_effect.Effect.gen(function* () {
+      yield* config.authenticate(options.headers).pipe(
+        import_effect.Effect.mapError(() => new import_SyncError.SyncError({ code: "unauthorized", message: "Host authentication required" }))
+      );
+      return yield* effect;
+    })
+  );
+  return import_rpc.RpcServer.layer(import_BranchRpcs.BranchRpcs, { disableFatalDefects: true }).pipe(
+    import_effect.Layer.provide(handlers),
+    import_effect.Layer.provide(auth),
+    import_effect.Layer.provideMerge(import_rpc.RpcServer.layerProtocolHttp({ path: "/branch" }))
+  );
+}));
+//# sourceMappingURL=HostBranchPresence.js.map

package/dist/cjs/HostBranchPresence.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/HostBranchPresence.ts"],
+  "sourcesContent": ["/**\n * Host-only adapter of the existing branch protocol and lease roster.\n * The Go authorizer resolves branch, actor and socket session before forwarding.\n * The runtime bearer is required on every RPC; participant IDs confer no rights.\n *\n * @since 1.0.0\n */\n\nimport * as BranchPresence from \"@smthrs/sync/BranchPresence\"\nimport type { Announcement, LeaveRequest, RosterRequest } from \"@smthrs/sync/BranchProtocol\"\nimport { BranchRpcs } from \"@smthrs/sync/BranchRpcs\"\nimport * as BranchShare from \"@smthrs/sync/BranchShare\"\nimport { SyncError } from \"@smthrs/sync/SyncError\"\nimport { SyncAuth } from \"@smthrs/sync/SyncRpcs\"\nimport { Effect, Layer, Redacted, Stream } from \"effect\"\nimport { RpcServer } from \"effect/unstable/rpc\"\nimport type { Config } from \"./RuntimeBridge.ts\"\n\n/**\n * Mount only on authenticated native runtime hosts, never anonymous gateways.\n *\n * @category layers\n * @since 1.0.0-rc.1\n */\nexport const layer = (config: Config) =>\n  Layer.unwrap(Effect.gen(function*() {\n    const share = yield* BranchShare.makeHmac({\n      activeKid: \"host\",\n      keys: [{ kid: \"host\", secret: Redacted.make(crypto.randomUUID() + crypto.randomUUID()) }]\n    })\n    // The authorizing Go host re-checks all source readiness on every health\n    // call. The handler below refuses missing assertions before the lease\n    // registry, whose own startup window still applies. No readiness cache.\n    const presence = yield* BranchPresence.makeMemory({\n      sourcesReady: () => Effect.succeed(true)\n    }).pipe(Effect.provideService(BranchShare.BranchShare, share))\n    // Capability fields on this host-only mount are transport metadata, replaced\n    // with an internal signed capability after the runtime bearer is verified.\n    const authorize = <A extends RosterRequest>(request: A, actor = \"roster\") =>\n      share.mint({\n        branchId: request.branchId,\n        capabilityId: actor,\n        access: \"write\",\n        ttlMs: 60_000\n      }).pipe(Effect.map((capability) => ({ ...request, capability })))\n    const unsupported = new SyncError({ code: \"unsupported\", message: \"This mount serves presence only\" })\n    const handlers = BranchRpcs.toLayer(Effect.succeed(BranchRpcs.of({\n      \"Branch.CreateBranch\": () => Effect.fail(unsupported),\n      \"Branch.MintShare\": () => Effect.fail(unsupported),\n      \"Branch.Submit\": () => Effect.fail(unsupported),\n      \"Branch.Announce\": (request: Announcement) =>\n        authorize(request, request.participantId).pipe(Effect.flatMap(presence.announce)),\n      \"Branch.Leave\": (request: LeaveRequest) =>\n        authorize(request, request.participantId).pipe(Effect.flatMap(presence.leave), Effect.as(null)),\n      \"Branch.Roster\": (request) => authorize(request).pipe(Effect.flatMap(presence.list)),\n      \"Branch.PresenceOn\": (request) =>\n        authorize(request).pipe(Effect.flatMap((authorized) =>\n          request.sourcesReady === true ? presence.presenceOn(authorized) : Effect.succeed(\"unknown\" as const)\n        )),\n      \"Branch.WatchRoster\": () =>\n        Stream.fail(unsupported)\n    })))\n    const auth = Layer.succeed(SyncAuth)((effect, options) =>\n      Effect.gen(function*() {\n        yield* config.authenticate(options.headers).pipe(\n          Effect.mapError(() => new SyncError({ code: \"unauthorized\", message: \"Host authentication required\" }))\n        )\n        return yield* effect\n      })\n    )\n    return RpcServer.layer(BranchRpcs, { disableFatalDefects: true }).pipe(\n      Layer.provide(handlers),\n      Layer.provide(auth),\n      Layer.provideMerge(RpcServer.layerProtocolHttp({ path: \"/branch\" }))\n    )\n  }))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,qBAAgC;AAEhC,wBAA2B;AAC3B,kBAA6B;AAC7B,uBAA0B;AAC1B,sBAAyB;AACzB,oBAAgD;AAChD,iBAA0B;AASnB,MAAM,QAAQ,CAAC,WACpB,oBAAM,OAAO,qBAAO,IAAI,aAAY;AAClC,QAAM,QAAQ,OAAO,YAAY,SAAS;AAAA,IACxC,WAAW;AAAA,IACX,MAAM,CAAC,EAAE,KAAK,QAAQ,QAAQ,uBAAS,KAAK,OAAO,WAAW,IAAI,OAAO,WAAW,CAAC,EAAE,CAAC;AAAA,EAC1F,CAAC;AAID,QAAM,WAAW,OAAO,eAAe,WAAW;AAAA,IAChD,cAAc,MAAM,qBAAO,QAAQ,IAAI;AAAA,EACzC,CAAC,EAAE,KAAK,qBAAO,eAAe,YAAY,aAAa,KAAK,CAAC;AAG7D,QAAM,YAAY,CAA0B,SAAY,QAAQ,aAC9D,MAAM,KAAK;AAAA,IACT,UAAU,QAAQ;AAAA,IAClB,cAAc;AAAA,IACd,QAAQ;AAAA,IACR,OAAO;AAAA,EACT,CAAC,EAAE,KAAK,qBAAO,IAAI,CAAC,gBAAgB,EAAE,GAAG,SAAS,WAAW,EAAE,CAAC;AAClE,QAAM,cAAc,IAAI,2BAAU,EAAE,MAAM,eAAe,SAAS,kCAAkC,CAAC;AACrG,QAAM,WAAW,6BAAW,QAAQ,qBAAO,QAAQ,6BAAW,GAAG;AAAA,IAC/D,uBAAuB,MAAM,qBAAO,KAAK,WAAW;AAAA,IACpD,oBAAoB,MAAM,qBAAO,KAAK,WAAW;AAAA,IACjD,iBAAiB,MAAM,qBAAO,KAAK,WAAW;AAAA,IAC9C,mBAAmB,CAAC,YAClB,UAAU,SAAS,QAAQ,aAAa,EAAE,KAAK,qBAAO,QAAQ,SAAS,QAAQ,CAAC;AAAA,IAClF,gBAAgB,CAAC,YACf,UAAU,SAAS,QAAQ,aAAa,EAAE,KAAK,qBAAO,QAAQ,SAAS,KAAK,GAAG,qBAAO,GAAG,IAAI,CAAC;AAAA,IAChG,iBAAiB,CAAC,YAAY,UAAU,OAAO,EAAE,KAAK,qBAAO,QAAQ,SAAS,IAAI,CAAC;AAAA,IACnF,qBAAqB,CAAC,YACpB,UAAU,OAAO,EAAE,KAAK,qBAAO;AAAA,MAAQ,CAAC,eACtC,QAAQ,iBAAiB,OAAO,SAAS,WAAW,UAAU,IAAI,qBAAO,QAAQ,SAAkB;AAAA,IACrG,CAAC;AAAA,IACH,sBAAsB,MACpB,qBAAO,KAAK,WAAW;AAAA,EAC3B,CAAC,CAAC,CAAC;AACH,QAAM,OAAO,oBAAM,QAAQ,wBAAQ;AAAA,IAAE,CAAC,QAAQ,YAC5C,qBAAO,IAAI,aAAY;AACrB,aAAO,OAAO,aAAa,QAAQ,OAAO,EAAE;AAAA,QAC1C,qBAAO,SAAS,MAAM,IAAI,2BAAU,EAAE,MAAM,gBAAgB,SAAS,+BAA+B,CAAC,CAAC;AAAA,MACxG;AACA,aAAO,OAAO;AAAA,IAChB,CAAC;AAAA,EACH;AACA,SAAO,qBAAU,MAAM,8BAAY,EAAE,qBAAqB,KAAK,CAAC,EAAE;AAAA,IAChE,oBAAM,QAAQ,QAAQ;AAAA,IACtB,oBAAM,QAAQ,IAAI;AAAA,IAClB,oBAAM,aAAa,qBAAU,kBAAkB,EAAE,MAAM,UAAU,CAAC,CAAC;AAAA,EACrE;AACF,CAAC,CAAC;",
+  "names": []
+}

package/dist/cjs/Projections.d.ts

@@ -0,0 +1,209 @@
+/**
+ * The gateway read path: served projections computed from the control plane.
+ *
+ * Every projection here is a fold over facts `@smthrs/control` already
+ * publishes: `Control.list` for run and flow listings, `Control.watch` for a
+ * run's ordered events. The gateway never opens the engine database, so a
+ * projection served to a browser through a relay is the same projection a
+ * local reader computes, and a projection cannot drift from the control plane
+ * by reading a column the control plane does not expose.
+ *
+ * A snapshot brackets its journal read with run-summary reads and retries
+ * when the summary changes. Rows and cursor share the resulting event buffer,
+ * so a completion cannot be acknowledged with the preceding run status.
+ *
+ * A subscription is a snapshot followed by deltas. A delta recomputes the
+ * selector's rows from the accumulated events rather than patching them: a
+ * projection is a reproducible fold (`@smthrs/journal` `Projection`), and
+ * recomputation is the only delta that cannot disagree with a fresh snapshot.
+ * `run-events` appends immutable rows. `transcript` normally appends too, but
+ * sends an existing snapshot reset when a committed native call fact upgrades
+ * previously delivered telemetry. Events accumulate in the stream, so each delta
+ * folds without re-reading history. Resuming a historical run summary first
+ * rebuilds its compacted health prefix once through durable follow replay.
+ *
+ * A workspace subscription follows every journal partition without a cursor.
+ * The follower stores each retained run's last position and drops replay
+ * through that cutoff. Sources and exclusion verdicts share the snapshot's
+ * run ceiling; eviction discards a verdict together with its cursor state.
+ * Events are gathered for a short window and folded into one frame, and each
+ * run's rows are cached so a burst refolds only the runs whose journals grew.
+ *
+ * @since 1.0.0
+ */
+import type { Service as ControlService } from "@smthrs/control/Control";
+import { Control } from "@smthrs/control/Control";
+import { Context, Effect, Layer, Stream } from "effect";
+import { GatewayError } from "./GatewayError.ts";
+import * as GatewaySchema from "./GatewaySchema.ts";
+/**
+ * How often an idle subscription emits a keepalive frame.
+ *
+ * The Smithers Cloud relay cuts an idle tunnel at 600 s (the deployed relay behavior), so a
+ * quiet run must produce a frame well inside that window or the connection is
+ * dropped and every follower reconnects. Thirty seconds leaves twenty
+ * heartbeats of margin.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const heartbeatIntervalMillis = 30000;
+/**
+ * The most runs one workspace projection folds, newest first.
+ *
+ * A workspace projection reads one full journal per run, so the number of
+ * runs it folds is bounded on purpose. This is the gateway's own ceiling, not
+ * the control plane's default page size. It is 500 because that equals
+ * `ControlSchema.maxPageSize`, letting the control plane satisfy the whole
+ * gateway allowance in one page when it can.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const maxWorkspaceRuns = 500;
+/**
+ * The most journal events one run projection retains in its window.
+ *
+ * This is a retention ceiling, not a refusal. A run that journals more keeps
+ * its most recent {@link maxEventsPerRun} events and folds everything older
+ * into the carried digest that {@link maxProjectionBytes} describes.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const maxEventsPerRun = 10000;
+/**
+ * The most journal events one run projection reads before it stops reading.
+ *
+ * The window ceiling bounds memory; this bounds work. A projection folds every
+ * event it reads, so a run with a million of them would cost a million decodes
+ * on every snapshot however few it kept. Ten times the window is the honest
+ * compromise: every real run is far inside it, and a runaway one still answers
+ * rather than running the reader out of time.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const maxEventsScanned = 100000;
+/**
+ * The most events one `run-events` snapshot page carries.
+ *
+ * `run-events` is the one selector whose rows are the journal itself, so it is
+ * the one selector a client must page rather than fold. A snapshot answers at
+ * most this many events and a cursor to ask for the next page from, so reading
+ * a long run costs one bounded response per page instead of one response the
+ * size of the whole run.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const maxEventsPerPage = 1000;
+/**
+ * The most terminal runs of one flow a duration fold measures.
+ *
+ * A prediction wants recent history, not all of it: an old run measured a
+ * different declaration on a different machine. The newest finished runs are
+ * the ones whose durations still describe what the flow does now, and the
+ * bound is what keeps a snapshot from reading every journal a flow ever wrote.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const maxDurationRuns = 20;
+/**
+ * The largest encoded event window or projected row set one run admits.
+ *
+ * The row budget is a refusal: rows go on the wire, and a frame larger than
+ * this is one no client asked for. The window budget is retention: events
+ * older than the newest {@link maxProjectionBytes} are folded into a carried
+ * digest instead of being held. Its compact identity contributions share this
+ * budget; if they cannot fit, the read refuses instead of reporting inexact
+ * counters or retaining an unbounded identity set.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const maxProjectionBytes: number;
+/**
+ * The largest encoded form one retained journal event may take.
+ *
+ * A model request body, a response transcript, and a tool's captured output
+ * are all journaled inline, and any one of them can be megabytes. Nothing a
+ * projection reads out of a payload is long: a seat name, a flow name, an
+ * outcome, a token count, a first line. A retained event is therefore clipped
+ * to this budget rather than held whole, which is what keeps one wiki refresh
+ * that retried a model call nine times from costing a run card its whole
+ * history. `run-events` pages preserve native engine evidence because clients
+ * decode its complete contracts to offer actions. Other large bodies remain
+ * clipped; their full content belongs in run artifacts.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const maxEventBytes: number;
+/**
+ * Read-path operations served by the gateway.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Service {
+    /**
+     * Current rows, or only run-events rows after an issued cursor.
+     *
+     * A literal selector keeps its own row type, so an approvals reader reads
+     * `requestId` and a run-tree reader reads `nodeId` without an assertion. A
+     * selector chosen at runtime still answers with the snapshot union.
+     */
+    readonly snapshot: <S extends GatewaySchema.ProjectionSelector>(selector: S, after?: GatewaySchema.ProjectionCursor | undefined) => Effect.Effect<GatewaySchema.SnapshotOf<S>, GatewayError>;
+    /**
+     * A snapshot followed by recomputed deltas and keepalive frames, or, when
+     * `after` names a cursor this selector issued, the deltas after it alone.
+     *
+     * The row and delta frames are the selector's own, on the same rule as
+     * `snapshot`.
+     */
+    readonly subscribe: <S extends GatewaySchema.ProjectionSelector>(selector: S, after?: GatewaySchema.ProjectionCursor | undefined) => Stream.Stream<GatewaySchema.FrameOf<S>, GatewayError>;
+}
+declare const Projections_base: Context.ServiceClass<Projections, "@smthrs/gateway/Projections", Service>;
+/**
+ * The gateway read path.
+ *
+ * @since 1.0.0
+ * @category services
+ */
+export declare class Projections extends Projections_base {
+}
+/**
+ * Builds the read path over a control plane.
+ *
+ * Invalid keepalive settings are returned as typed `bind_failed` failures;
+ * construction never throws synchronously.
+ *
+ * @param control the control service to read through
+ * @param options the keepalive cadence to use
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const make: (control: ControlService, options?: {
+    readonly heartbeatMillis?: number | undefined;
+}) => Effect.Effect<Service, GatewayError>;
+/**
+ * Provides the gateway read path over the ambient control plane.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layer: Layer.Layer<Projections, GatewayError, Control>;
+/**
+ * Provides the gateway read path under an explicit keepalive cadence.
+ *
+ * @param options the keepalive cadence to use
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layerWith: (options: {
+    readonly heartbeatMillis?: number | undefined;
+}) => Layer.Layer<Projections, GatewayError, Control>;
+export {};
+//# sourceMappingURL=Projections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Projections.d.ts","sourceRoot":"","sources":["../../src/Projections.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAA;AACxE,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AAGjD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/D,OAAO,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAA;AAEhE,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAKnD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAA;AAE7C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAMnC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,QAAS,CAAA;AAErC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,SAAU,CAAA;AAEvC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,OAAQ,CAAA;AAErC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,KAAK,CAAA;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,QAAkB,CAAA;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,QAAY,CAAA;AAuBtC;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,SAAS,aAAa,CAAC,kBAAkB,EAC5D,QAAQ,EAAE,CAAC,EACX,KAAK,CAAC,EAAE,aAAa,CAAC,gBAAgB,GAAG,SAAS,KAC/C,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAA;IAC7D;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,aAAa,CAAC,kBAAkB,EAC7D,QAAQ,EAAE,CAAC,EACX,KAAK,CAAC,EAAE,aAAa,CAAC,gBAAgB,GAAG,SAAS,KAC/C,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAA;CAC3D;;AAED;;;;;GAKG;AACH,qBAAa,WAAY,SAAQ,gBAAsE;CAAG;AAs7C1G;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,GACf,SAAS,cAAc,EACvB,UAAS;IAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAO,KAC9D,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,CAclC,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,EAAE,YAAY,EAAE,OAAO,CAEjE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GACpB,SAAS;IAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,KACzD,KAAK,CAAC,KAAK,CAAC,WAAW,EAAE,YAAY,EAAE,OAAO,CACwC,CAAA"}