@smthrs/plan 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/internal/node.d.ts

@@ -0,0 +1,526 @@
+/**
+ * The node AST, and the side tables the functions hang off.
+ *
+ * Two invariants shape every declaration here. The AST is **closure-free**
+ * and keeps payloads as inert JSON mirrors, so a valid plan can be shipped,
+ * stored, diffed, and rendered without the process that built it; control flow is
+ * **structure**, so a branch stores both arms as ASTs rather than a function
+ * that would have to be run to find out what comes next.
+ *
+ * The functions an author does write — a mapper, a continuation, a branch
+ * predicate — live in `WeakMap`s keyed by the AST node they belong to, and the
+ * AST keeps only a {@link FunctionIdentity} digest of their source. The digest
+ * is what enters content identity (https://smithers.sh/docs/concepts/content-addressing); the
+ * `WeakMap` is what the run reaches for when it has the real value in hand, and
+ * it drops with the AST it is keyed by.
+ *
+ * Adapted from `@smthrs/core` (`packages/smithers/flows/core`)
+ * `internal/node.ts`. `Dynamic` does not come across — a model call is an
+ * ordinary action here — and neither do annotations, which are `Context`
+ * values and would break serializability. Scheduling priority is the one thing that does cross, as
+ * the plain JSON field {@link Scheduled.priority} rather than as an
+ * annotation, because the scheduler has to read it out of a stored plan.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+import type { Node } from "../Node.ts";
+/**
+ * The runtime type identifier every node carries.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const TypeId: "~@smthrs/plan/Node";
+/**
+ * The type-level form of {@link TypeId}.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export type TypeId = typeof TypeId;
+/**
+ * What every AST variant carries besides its own shape: an optional scheduling
+ * priority.
+ *
+ * A priority is JSON, not a `Context` annotation, which is why it can live in
+ * the AST at all: the whole point of dropping core's annotations was to keep a
+ * plan shippable, storable, and diffable. It is a scheduling HINT — the plan
+ * compiler copies it onto the node draft and the scheduler orders ready work by
+ * it, while key material never reads it, so raising a priority reorders work
+ * without re-keying a single step.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface Scheduled {
+    readonly priority?: number | undefined;
+}
+/**
+ * A constant, known before anything runs.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface Succeed extends Scheduled {
+    readonly _tag: "Succeed";
+    readonly value: unknown;
+}
+/**
+ * A constant typed failure, known before anything runs.
+ *
+ * The error is an inert JSON mirror for the same reason {@link Succeed.value}
+ * is: a stored plan has to carry what the node produces without the process
+ * that built it.
+ *
+ * @since 1.0.0
+ * @private
+ * @slop
+ */
+export interface Fail extends Scheduled {
+    readonly _tag: "Fail";
+    readonly error: unknown;
+}
+/**
+ * Independent children, combined by name. Width is fixed here, at plan time:
+ * there is no dynamic fan-out.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface All extends Scheduled {
+    readonly _tag: "All";
+    readonly nodes: Readonly<Record<string, NodeAst>>;
+}
+/**
+ * How a {@link Race} settles: `race` on the first member to settle, `any` on
+ * the first member to succeed, and `quorum` once `count` members succeed.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export type RaceMode = "race" | "any" | "quorum";
+/**
+ * Independent children that settle early: the join decides as soon as its
+ * {@link RaceMode} can, and the members it did not wait for are interrupted.
+ * `count` is the successes a quorum needs, and 1 for `race` and `any`.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export interface Race extends Scheduled {
+    readonly _tag: "Race";
+    readonly mode: RaceMode;
+    readonly count: number;
+    readonly nodes: Readonly<Record<string, NodeAst>>;
+}
+/**
+ * A deferred pure transformation of an upstream result. `map` transforms; it
+ * never decides.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface Map extends Scheduled {
+    readonly _tag: "Map";
+    readonly first: NodeAst;
+    readonly mapper: FunctionIdentity;
+}
+/**
+ * A continuation after an upstream node. `next` is present when the author
+ * supplied a node directly instead of a builder, in which case the topology is
+ * already known and nothing has to be evaluated to reveal it.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface AndThen extends Scheduled {
+    readonly _tag: "AndThen";
+    readonly first: NodeAst;
+    readonly continuation: FunctionIdentity;
+    readonly next?: NodeAst | undefined;
+}
+/**
+ * A decision whose arms are static topology. The predicate runs at run time on
+ * the real value; both arms are already ASTs, so the exit condition and the
+ * handoff site are visible before anything runs.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface Branch extends Scheduled {
+    readonly _tag: "Branch";
+    readonly subject: string;
+    readonly first: NodeAst;
+    readonly predicate: FunctionIdentity;
+    readonly then: NodeAst;
+    readonly else: NodeAst;
+}
+/**
+ * A protected graph and its statically planned typed-failure continuation.
+ *
+ * The symbolic error `subject` is minted per catch node rather than shared,
+ * mirroring {@link Branch}. Failure arms are built before the graph assigns
+ * ids, so a nested arm that captured an outer error would resolve it to the
+ * inner catch's protected node under one shared token.
+ *
+ * An absent filter catches the entire typed error channel, while a present
+ * schema catches only values it accepts. This mirrors Effect's typed-error
+ * boundary and keeps defects outside normal recovery. The serializable AST carries the schema identity; the live schema
+ * remains in a side table beside the AST.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface Catch extends Scheduled {
+    readonly _tag: "Catch";
+    readonly subject: string;
+    readonly protected: NodeAst;
+    readonly failure: NodeAst;
+    readonly filter?: unknown | undefined;
+    readonly filterIdentity?: FunctionIdentity | undefined;
+}
+/**
+ * How a flow call joins the caller's plan: `inline` splices the callee's body
+ * in, `boundary` makes it one child execution, and `handoff` names the next
+ * trampoline round. Why the child call is a mode rather than a second AST tag
+ * is in `docs/concepts/authoring-ast.md`.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const CallMode: Schema.Literals<readonly ["inline", "boundary", "handoff"]>;
+/**
+ * How a flow call joins the caller's plan.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export type CallMode = typeof CallMode.Type;
+/**
+ * A call to another flow. The AST keeps the callee's tag and the payload;
+ * the declaration itself is in the side table, because a flow value carries
+ * schemas and a body and is not JSON.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface FlowCall extends Scheduled {
+    readonly _tag: "FlowCall";
+    readonly flow: string;
+    readonly mode: CallMode;
+    readonly payload: unknown;
+}
+/**
+ * A call to an action: the atom that does work. Same split as
+ * {@link FlowCall}, and no mode — an action is always one node.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface ActionCall extends Scheduled {
+    readonly _tag: "ActionCall";
+    readonly action: string;
+    readonly payload: unknown;
+}
+/**
+ * The algorithms a {@link FunctionIdentity} may name. The tag is versioned so a
+ * change to identity semantics re-keys everything derived from one, rather than
+ * colliding with it.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const IdentityAlgorithm: Schema.Literals<readonly ["sha256-source-ephemeral/v4", "sha256-source-captures/v5", "static-node/v1"]>;
+/**
+ * The algorithms a {@link FunctionIdentity} may name.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export type IdentityAlgorithm = typeof IdentityAlgorithm.Type;
+/**
+ * The serializable stand-in for a function. Captured functions digest their
+ * exact source and declared inert captures. Unannotated functions additionally
+ * carry process-local, per-object entropy so indistinguishable closure sources
+ * fail closed instead of sharing a cache key. The tag it names is
+ * {@link IdentityAlgorithm}.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface FunctionIdentity {
+    readonly _tag: "FunctionIdentity";
+    readonly algorithm: IdentityAlgorithm;
+    readonly digest: string;
+}
+/**
+ * Brands an operation with every inert value it closes over, so its identity
+ * covers what it computes with and not only its source.
+ *
+ * `@smthrs/crypto` owns the captures, nested metadata, and freezing contract.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const capture: <C extends Readonly<Record<string, unknown>>, Args extends ReadonlyArray<unknown>, A>(captures: C, operation: (this: Readonly<C>, ...args: Args) => A) => (...args: Args) => A;
+/**
+ * The serializable form of a planned value embedded in an AST value or
+ * payload. The strict proxy itself cannot enter the AST because serializing it
+ * is deliberately a build error.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface PlannedReference {
+    readonly _tag: "PlannedReference";
+    readonly node: string;
+    readonly path: ReadonlyArray<string>;
+}
+/**
+ * Reads an AST-owned planned reference without trusting its public data shape.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const plannedReference: (value: unknown) => PlannedReference | undefined;
+/**
+ * Every AST variant.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export type NodeAst = Succeed | Fail | All | Race | Map | AndThen | Branch | Catch | FlowCall | ActionCall;
+type Operation = (value: unknown) => unknown;
+type Predicate = (value: unknown) => boolean;
+/**
+ * Digests a function's exact source as UTF-8 with SHA-256. Exact source matters:
+ * whitespace inside a string literal is behavior, and normalizing it before
+ * hashing can make different functions share an identity. Unless its inert
+ * captures were declared with {@link capture}, the digest also includes
+ * process-local, per-function entropy: JavaScript cannot inspect a closure, so
+ * source-only identity would permit incorrect cache hits.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const functionIdentity: (operation: unknown) => FunctionIdentity;
+/**
+ * The prototype every node shares, so `pipe` is one function rather than one
+ * closure per node.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const NodeProto: {
+    "~@smthrs/plan/Node": {
+        _A: <A>(a: A) => A;
+        _E: <A>(a: A) => A;
+        _R: <A>(a: A) => A;
+    };
+    pipe(): unknown;
+};
+/**
+ * Whether `count` is a successes target a {@link Race} of `members` can reach:
+ * a quorum needs between one and every member, and the other modes need one.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const isRaceCount: (mode: RaceMode, count: unknown, members: number) => boolean;
+/**
+ * Checks whether a value has the shape of a {@link NodeAst}: what a JSON round
+ * trip of a genuine AST produces, and nothing looser. Every variant's own
+ * fields are checked, and every child is walked. The walk is an explicit stack
+ * rather than recursion, so an arbitrarily deep AST cannot overflow the native
+ * stack, and it tracks the ancestors of the position it has reached, so a
+ * cyclic object is refused rather than walked forever while a shared sub-AST
+ * still passes.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const isNodeAst: (value: unknown) => value is NodeAst;
+/**
+ * Checks whether a value is a node.
+ *
+ * A node this module built is recognized by registration. A node that crossed
+ * a serialization boundary, an object whose prototype is {@link NodeProto} and
+ * whose own `ast` data property passes {@link isNodeAst}, is recognized by that
+ * shape: `@smthrs/flow` hands a rehydrated AST back as a node, and the side
+ * tables are all a round trip loses. The {@link TypeId} marker is an exported
+ * string any object can carry, so it counts for nothing on its own, and an
+ * `ast` that is missing, malformed, cyclic, or an accessor is refused because
+ * every combinator reads it as trusted topology. A proxy is judged by the
+ * shape it forwards.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const isNode: (value: unknown) => value is Node<unknown, unknown, any>;
+/**
+ * Wraps an AST as a node.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const makeNode: <A = unknown, E = never, R = never>(ast: NodeAst) => Node<A, E, R>;
+/**
+ * Constructs a {@link Succeed}.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const succeed: (input: unknown) => Succeed;
+/**
+ * Constructs a {@link Fail}.
+ *
+ * @since 1.0.0
+ * @private
+ * @slop
+ */
+export declare const fail: (error: unknown) => Fail;
+/**
+ * Constructs an {@link All}.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const all: (nodes: Readonly<Record<string, NodeAst>>) => All;
+/**
+ * Constructs a {@link Race}.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const race: (mode: RaceMode, count: number, nodes: Readonly<Record<string, NodeAst>>) => Race;
+/**
+ * Constructs a {@link Map}, filing the mapper under the AST it belongs to.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const map: (first: NodeAst, operation: Operation, source: unknown) => Map;
+/**
+ * Constructs an {@link AndThen} from a builder. The builder is evaluated once
+ * against a planned value when the graph is built, never here.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const andThen: (first: NodeAst, operation: Operation, source: unknown) => AndThen;
+/**
+ * Constructs an {@link AndThen} from a node the author supplied directly. There
+ * is no function to digest, so the continuation carries a fixed marker.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const andThenNode: (first: NodeAst, next: NodeAst) => AndThen;
+/**
+ * Constructs a {@link Branch}. Both arms arrive already evaluated, because a
+ * branch that had to be run to reveal its topology would not be a plan.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const branch: (subject: string, first: NodeAst, predicate: Predicate, source: unknown, then: NodeAst, otherwise: NodeAst) => Branch;
+/**
+ * Constructs a {@link Catch} whose failure topology is already evaluated.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const catch_: (subject: string, protectedAst: NodeAst, failure: NodeAst, filter?: Schema.Top) => Catch;
+/**
+ * Constructs a {@link FlowCall}, filing the flow declaration beside it.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const flowCall: (declaration: unknown, flow: string, mode: CallMode, payload: unknown) => FlowCall;
+/**
+ * Constructs an {@link ActionCall}, filing the action declaration beside
+ * it.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const actionCall: (declaration: unknown, action: string, payload: unknown) => ActionCall;
+/**
+ * The deferred function of a map or a continuation.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const operation: (ast: AndThen | Map) => Operation | undefined;
+/**
+ * The run-time predicate of a branch.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const predicate: (ast: Branch) => Predicate | undefined;
+/**
+ * The optional error schema filter of a catch node.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const filter: (ast: Catch) => Schema.Top | undefined;
+/**
+ * The flow or action declaration a call node names.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const declaration: (ast: ActionCall | FlowCall) => unknown;
+/**
+ * Copies an AST with a scheduling priority attached.
+ *
+ * The copy is shallow and the side tables are re-filed against it, because a
+ * function, a predicate, a filter schema, and a declaration are keyed by the
+ * exact AST object they belong to: a copy that left them behind would silently
+ * lose the continuation the graph walk has to evaluate.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const withPriority: (ast: NodeAst, priority: number) => NodeAst;
+export {};
+//# sourceMappingURL=node.d.ts.map

package/dist/cjs/internal/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/internal/node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAOH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAItC;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAG,oBAA6B,CAAA;AAEnD;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAA;AAElC;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACvC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,IAAK,SAAQ,SAAS;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,GAAI,SAAQ,SAAS;IACpC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD;AAED;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAA;AAEhD;;;;;;;GAOG;AACH,MAAM,WAAW,IAAK,SAAQ,SAAS;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,GAAI,SAAQ,SAAS;IACpC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAA;CAClC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAA;IACvC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CACpC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAO,SAAQ,SAAS;IACvC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAA;IACpC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,KAAM,SAAQ,SAAS;IACtC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACrC,QAAQ,CAAC,cAAc,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAA;CACvD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,6DAAqD,CAAA;AAE1E;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,UAAW,SAAQ,SAAS;IAC3C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,yGAI5B,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,oIA4LX,GAAI,sBAAqB,GAAG,gBA5LE,CAAA;AAEvC;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACrC;AAqCD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,gBAAgB,GAAG,SAGtD,CAAA;AAEf;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,UAAU,CAAA;AAE1G,KAAK,SAAS,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;AAE5C,KAAK,SAAS,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;AAgB5C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,gBAA4C,CAAA;AAEnG;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS;;;;;;;CAUrB,CAAA;AAiBD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,QAAQ,EAAE,OAAO,OAAO,EAAE,SAAS,MAAM,KAAG,OAEc,CAAA;AAU5F;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OAqEnD,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,CAM1E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EAAE,KAAK,OAAO,KAAG,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAItF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,OAA6D,CAAA;AAEtG;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,OAAO,KAAG,IAAuD,CAAA;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,GAAI,OAAO,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAG,GAA+B,CAAA;AAE9F;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,QAAQ,EAAE,OAAO,MAAM,EAAE,OAAO,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAG,IAK7F,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,EAAE,WAAW,SAAS,EAAE,QAAQ,OAAO,KAAG,GAI3E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,EAAE,WAAW,SAAS,EAAE,QAAQ,OAAO,KAAG,OAI/E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,EAAE,MAAM,OAAO,KAAG,OAK1D,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GACjB,SAAS,MAAM,EACf,OAAO,OAAO,EACd,WAAW,SAAS,EACpB,QAAQ,OAAO,EACf,MAAM,OAAO,EACb,WAAW,OAAO,KACjB,MAWF,CAAA;AAwCD;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,MAAM,EAAE,cAAc,OAAO,EAAE,SAAS,OAAO,EAAE,SAAS,MAAM,CAAC,GAAG,KAAG,KAetG,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,aAAa,OAAO,EAAE,MAAM,MAAM,EAAE,MAAM,QAAQ,EAAE,SAAS,OAAO,KAAG,QAI/F,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GAAI,aAAa,OAAO,EAAE,QAAQ,MAAM,EAAE,SAAS,OAAO,KAAG,UAInF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,OAAO,GAAG,GAAG,KAAG,SAAS,GAAG,SAAgC,CAAA;AAE3F;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,KAAG,SAAS,GAAG,SAAgC,CAAA;AAEpF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,KAAK,KAAG,MAAM,CAAC,GAAG,GAAG,SAA6B,CAAA;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,UAAU,GAAG,QAAQ,KAAG,OAAgC,CAAA;AAEzF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,OAAO,EAAE,UAAU,MAAM,KAAG,OAmB7D,CAAA"}