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

package/dist/cjs/StepBoundary.d.ts

@@ -0,0 +1,501 @@
+/**
+ * Hermetic step boundary contracts, the filesystem-backed production
+ * implementation, and the deterministic test implementation.
+ *
+ * @since 0.1.0
+ */
+import * as ArtifactStore from "@smthrs/artifacts/ArtifactStore";
+import { FileBoundary } from "@smthrs/flow/FileBoundary";
+import { FileInput } from "@smthrs/flow/FileInput";
+import * as Context from "effect/Context";
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+/**
+ * A file boundary that has been measured but not yet run: the caller's
+ * declaration, paired with what the host actually found on disk for it.
+ *
+ * `prepare` produces one of these before a step executes and `settle` consumes
+ * it afterwards, which is what lets the boundary say whether the world moved
+ * underneath the declaration. Check it with {@link readSetMatches}.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const PreparedBoundary: Schema.Struct<{
+    readonly descriptor: Schema.Struct<{
+        readonly readSet: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly path: Schema.NonEmptyString;
+            readonly digest: Schema.NonEmptyString;
+        }>, Schema.TaggedStruct<"Glob", {
+            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        }>]>>;
+        readonly writeSet: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        }>, Schema.TaggedStruct<"TreeArtifact", {
+            readonly path: Schema.NonEmptyString;
+        }>]>>;
+        readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+    }>;
+    /**
+     * What the host actually measured for the declared read set at prepare
+     * time. The declared digests are caller metadata folded into the step key;
+     * this is the evidence that they still describe reality, and a sealed
+     * cache hit is refused when the two disagree (issue #90).
+     */
+    readonly readSnapshot: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly digest: Schema.NonEmptyString;
+    }>>;
+}>;
+/**
+ * The value form of {@link PreparedBoundary}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PreparedBoundary = typeof PreparedBoundary.Type;
+/**
+ * Exact read inputs from a boundary after ignoring declarations that still need expansion.
+ *
+ * @category accessors
+ * @since 0.1.0
+ */
+export declare const exactReads: (descriptor: FileBoundary) => ReadonlyArray<FileInput>;
+/**
+ * Whether every declared read still matches what the host measured.
+ *
+ * Reads the host reports but the declaration never claimed are ignored: the
+ * declaration is the dependency edge set, and an incidental extra read is not
+ * one of its edges. A declared path missing from the measurement counts as a
+ * mismatch — its value is unknown, so reuse cannot be justified.
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+export declare const readSetMatches: (prepared: PreparedBoundary) => boolean;
+/**
+ * The paths a step wrote that its `expected` write set did not name, together
+ * with the diff identity they were observed under.
+ *
+ * An expected-mode boundary reports these rather than failing: the declaration
+ * is a prediction, and a wrong prediction is evidence to journal, not an
+ * error. A hard-mode boundary raises {@link UndeclaredWrite} for the same
+ * observation.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const ExpectedSetDeviation: Schema.TaggedStruct<"ExpectedSetDeviation", {
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly diffIdentity: Schema.NonEmptyString;
+}>;
+/**
+ * Declared writes an expected-mode step did not produce, and did not declare
+ * as removals.
+ *
+ * The absence itself is the defect: recording it as valid evidence caches the
+ * claim "this file should not exist", which `replayOutputs` then acts on by
+ * deleting the path on a workspace that never ran the step. A hard-mode
+ * boundary raises {@link MissingDeclaredOutput} for the same observation.
+ *
+ * Expected mode records it rather than failing because the declaration there is
+ * a prediction — and because a deviation of any variant already bars the
+ * evidence from the shared cache (`ActionPersistence` gates `recordCache` on
+ * `deviation === undefined`), so an unexplained absence never reaches another
+ * host either way.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const MissingOutputDeviation: Schema.TaggedStruct<"MissingDeclaredOutput", {
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly diffIdentity: Schema.NonEmptyString;
+}>;
+/**
+ * Declared removals an expected-mode step left in place.
+ *
+ * The dual of {@link MissingOutputDeviation}: a removal is a promise about the
+ * post-state exactly as a write is. A path that was promised absent but is
+ * still present — possibly mutated — must not settle as valid evidence, or
+ * the mutation is cached under a declaration that disclaimed it and replay
+ * materializes it everywhere. A hard-mode boundary raises
+ * {@link SurvivingDeclaredRemoval} for the same observation.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const SurvivingRemovalDeviation: Schema.TaggedStruct<"SurvivingDeclaredRemoval", {
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly diffIdentity: Schema.NonEmptyString;
+}>;
+/**
+ * What a settled boundary observed that its declaration did not predict.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const BoundaryDeviation: Schema.Union<readonly [Schema.TaggedStruct<"ExpectedSetDeviation", {
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly diffIdentity: Schema.NonEmptyString;
+}>, Schema.TaggedStruct<"MissingDeclaredOutput", {
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly diffIdentity: Schema.NonEmptyString;
+}>, Schema.TaggedStruct<"SurvivingDeclaredRemoval", {
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly diffIdentity: Schema.NonEmptyString;
+}>]>;
+/**
+ * The value form of {@link BoundaryDeviation}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type BoundaryDeviation = typeof BoundaryDeviation.Type;
+/**
+ * What a settled boundary proved about a step's writes — the record the
+ * journal keeps and a later cache hit is justified against.
+ *
+ * `diffIdentity` names the post-state the step produced; `declaredOutputs`
+ * carries whatever the implementation needs to reproduce it on a workspace
+ * that never ran the step. The two optional fields are the honest gaps:
+ * `wholeTreeWritesVerified` is present only when the boundary could observe
+ * the entire execution tree, and `deviation` only when it saw writes the
+ * declaration did not predict.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const BoundaryEvidence: Schema.Struct<{
+    readonly declaredOutputs: Schema.Unknown;
+    readonly diffIdentity: Schema.NonEmptyString;
+    /**
+     * The boundary observed the whole execution tree and proved that every
+     * write was covered by the descriptor's write set. Only evidence carrying
+     * this explicit proof may enter the cross-run cache. Older evidence and
+     * boundaries that can inspect declared paths only omit it.
+     */
+    readonly wholeTreeWritesVerified: Schema.optional<Schema.Literal<true>>;
+    /** The body could observe only declared filesystem inputs. */
+    readonly hermeticReadsVerified: Schema.optional<Schema.Literal<true>>;
+    readonly deviation: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"ExpectedSetDeviation", {
+        readonly paths: Schema.$Array<Schema.String>;
+        readonly diffIdentity: Schema.NonEmptyString;
+    }>, Schema.TaggedStruct<"MissingDeclaredOutput", {
+        readonly paths: Schema.$Array<Schema.String>;
+        readonly diffIdentity: Schema.NonEmptyString;
+    }>, Schema.TaggedStruct<"SurvivingDeclaredRemoval", {
+        readonly paths: Schema.$Array<Schema.String>;
+        readonly diffIdentity: Schema.NonEmptyString;
+    }>]>>;
+}>;
+/**
+ * The value form of {@link BoundaryEvidence}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type BoundaryEvidence = typeof BoundaryEvidence.Type;
+declare const UndeclaredWrite_base: Schema.Class<UndeclaredWrite, Schema.TaggedStruct<"@smthrs/engine-store/UndeclaredWrite", {
+    readonly code: Schema.Literal<"undeclared_write">;
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly diffIdentity: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A hard-mode step wrote outside its declared write set.
+ *
+ * Hard mode treats the declaration as a contract, so this is a refusal, not a
+ * report: the step's evidence is never journaled and never becomes a cache
+ * entry. An expected-mode boundary records the same observation as a
+ * {@link BoundaryDeviation} instead.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class UndeclaredWrite extends UndeclaredWrite_base {
+}
+declare const MissingDeclaredOutput_base: Schema.Class<MissingDeclaredOutput, Schema.TaggedStruct<"@smthrs/engine-store/MissingDeclaredOutput", {
+    readonly code: Schema.Literal<"missing_declared_output">;
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly diffIdentity: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A step finished without producing a path its write set declared, and did not
+ * declare that path as a removal.
+ *
+ * Bazel hard-fails the same observation — `SkyframeActionExecutor.checkOutputs`
+ * reports "output was not created" — and for the same reason: the alternative
+ * is to record `digest: null` as valid evidence, which caches the claim "this
+ * file should not exist" and makes every later replay delete the path. A step
+ * that crashed after declaring its writes would poison the cache with an
+ * eraser.
+ *
+ * Declaring the path in {@link FileBoundary}'s `removes` is how a deliberate
+ * deletion says so, and it is the only thing that makes the absence legitimate.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class MissingDeclaredOutput extends MissingDeclaredOutput_base {
+}
+declare const SurvivingDeclaredRemoval_base: Schema.Class<SurvivingDeclaredRemoval, Schema.TaggedStruct<"@smthrs/engine-store/SurvivingDeclaredRemoval", {
+    readonly code: Schema.Literal<"surviving_declared_removal">;
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly diffIdentity: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A hard-mode step left a declared removal in place.
+ *
+ * The dual of {@link MissingDeclaredOutput}: `removes` promises the path is
+ * absent afterwards, and a path that survived — or was quietly rewritten —
+ * is a post-state the declaration disclaimed. Settling it as evidence would
+ * cache the surviving bytes under a removal and hand them to every replay.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class SurvivingDeclaredRemoval extends SurvivingDeclaredRemoval_base {
+}
+declare const UnsupportedBoundary_base: Schema.Class<UnsupportedBoundary, Schema.TaggedStruct<"@smthrs/engine-store/UnsupportedBoundary", {
+    readonly code: Schema.Literal<"unsupported_boundary">;
+    readonly message: Schema.String;
+    /**
+     * The refusing host or artifact-store failure, carried whole rather than
+     * flattened into the message (`PlatformError`'s own convention), so the
+     * journal record and a live debugger both see the original error.
+     */
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The host could not honour the boundary at all — a filesystem that cannot be
+ * measured, a path that cannot be read, a transient I/O failure.
+ *
+ * It is the catch-all host refusal, deliberately kept distinct from the two
+ * refusals a caller can act on: {@link BoundaryCorruption} (the bytes changed
+ * under a recorded digest) and {@link MissingArtifact} (the bytes might be
+ * fetchable from a shared tier).
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class UnsupportedBoundary extends UnsupportedBoundary_base {
+}
+declare const BoundaryCorruption_base: Schema.Class<BoundaryCorruption, Schema.TaggedStruct<"@smthrs/engine-store/BoundaryCorruption", {
+    readonly code: Schema.Literal<"boundary_corruption">;
+    readonly path: Schema.String;
+    readonly recordedDigest: Schema.String;
+    readonly measuredDigest: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Recorded boundary evidence whose bytes no longer match their recorded
+ * digest — an integrity violation of the store's strongest invariant, as
+ * opposed to a transient host failure (issue #150). The two classes were
+ * previously conflated under one `UnsupportedBoundary` tag, so a failing
+ * disk corrupting many blobs journalled identically to a one-off EIO.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class BoundaryCorruption extends BoundaryCorruption_base {
+}
+declare const MissingArtifact_base: Schema.Class<MissingArtifact, Schema.TaggedStruct<"@smthrs/engine-store/MissingArtifact", {
+    readonly code: Schema.Literal<"missing_artifact">;
+    readonly path: Schema.String;
+    readonly digest: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Recorded evidence references an artifact this host's store does not hold
+ * (issue #172). Distinct from {@link UnsupportedBoundary} because it is the one
+ * replay refusal a *shared artifact tier* can repair: the caller fetches the
+ * blob from the remote store, writes it back locally, and retries the replay
+ * once before falling through to a real execution. Every other host refusal
+ * says nothing about where the bytes might be.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class MissingArtifact extends MissingArtifact_base {
+}
+/**
+ * The three-call lifecycle of a hermetic step boundary.
+ *
+ * `prepare` measures the declared read set before the step runs; `settle`
+ * measures the writes afterwards and turns them into {@link BoundaryEvidence};
+ * `replayOutputs` reproduces a previous step's outputs from that evidence, so
+ * a cache hit can materialize results on a workspace that never executed
+ * anything.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+export interface Service {
+    readonly prepare: (descriptor: FileBoundary) => Effect.Effect<PreparedBoundary, UnsupportedBoundary, Crypto.Crypto>;
+    readonly settle: (prepared: PreparedBoundary) => Effect.Effect<BoundaryEvidence, UndeclaredWrite | MissingDeclaredOutput | SurvivingDeclaredRemoval | UnsupportedBoundary | BoundaryCorruption, Crypto.Crypto>;
+    readonly replayOutputs: (evidence: BoundaryEvidence) => Effect.Effect<void, UnsupportedBoundary | BoundaryCorruption | MissingArtifact, Crypto.Crypto>;
+}
+/**
+ * The service key for a {@link Service}. Provide it with `layer` for
+ * a real workspace or `layerTest` for a deterministic in-memory one.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+export declare const StepBoundary: Context.Service<Service, Service>;
+/**
+ * Brands a {@link Service} implementation as a `StepBoundary`, so a new
+ * boundary backend is type-checked where it is written rather than where it is
+ * provided.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: (service: Service) => Service;
+/**
+ * The two size bounds that decide when a settled output is inlined into
+ * boundary evidence and when it is spilled to the `ArtifactStore` by digest.
+ *
+ * Both default to values that keep an evidence row small enough to journal;
+ * raise them only when the workspace's outputs are known to be small and the
+ * extra artifact round-trip is measurably costing something.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface FileSystemOptions {
+    /**
+     * The largest output (in bytes) inlined into the boundary evidence
+     * itself. Anything larger is handed to the `ArtifactStore` and recorded by
+     * digest reference only (issue #113). Defaults to 1 MiB.
+     */
+    readonly maxInlineBytes?: number | undefined;
+    /**
+     * The largest *aggregate* inline payload (in bytes) a single settle may
+     * fold into its boundary evidence (issue #122). A per-output bound alone
+     * still let a wide write set multiply many individually-small payloads
+     * into an unbounded evidence row; once an output would push the running
+     * total past this bound it is spilled to the `ArtifactStore` and
+     * recorded by digest reference only, even though it individually fits
+     * {@link maxInlineBytes}. Defaults to 8 MiB.
+     */
+    readonly maxTotalInlineBytes?: number | undefined;
+    /**
+     * The workspace root cache replay confines its writes, removals, and prune
+     * walk to. A filesystem already confined to a root (the kernel-guarded
+     * layer's service, or a `confined` view) keeps its own root and ignores
+     * this. Otherwise it defaults to the process working directory, the root a
+     * path-based host resolves `prepare` and `settle` against. {@link layer}
+     * passes the kernel `Workspace` root when one is in context.
+     */
+    readonly root?: string | undefined;
+}
+/**
+ * The digests this evidence references rather than inlines — the set that must
+ * be durable in a shared artifact tier before the evidence's cache entry
+ * becomes observable there, and the set a replay on a fresh host has to fetch.
+ *
+ * Evidence recorded by a foreign boundary implementation references nothing
+ * this store can name, so it yields the empty list rather than failing: the
+ * caller's replay path already refuses such evidence with
+ * {@link UnsupportedBoundary}.
+ *
+ * @since 0.1.0
+ * @category accessors
+ */
+export declare const referencedDigests: (evidence: BoundaryEvidence) => ReadonlyArray<ArtifactStore.Digest>;
+/**
+ * Builds the filesystem-backed boundary service.
+ *
+ * The blob mechanics — content addressing, atomic publication, digest
+ * verification, dedupe — belong to `artifacts` and were extracted into
+ * `@smthrs/artifacts` (`packages/smithers/flows/artifacts/docs/api.md`). What stays here
+ * is the *policy* that decides which outputs become blobs at all: the
+ * inline-versus-spill budgets are a property of how large an evidence row may
+ * get, not of how bytes are stored.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const makeFileSystem: (fs: FileSystem.FileSystem, platformPath: Path.Path, artifacts: ArtifactStore.Service, options?: FileSystemOptions) => Service;
+/**
+ * Provides the filesystem-backed production boundary: `prepare` measures the
+ * declared read set for real, `settle` detects reads mutated outside the
+ * declared write set and captures the write set's post-state, and
+ * `replayOutputs` re-materializes those outputs on cache-hit replay.
+ *
+ * Host access arrives through Effect's `FileSystem` tag, which the capability
+ * kernel decorates in place — the same seam every host implementation (node,
+ * bun, browser, sandbox) already provides. Blob storage arrives through
+ * `@smthrs/artifacts`, so the same boundary runs over a purely local store or
+ * over a local-plus-shared composition without knowing which it got.
+ *
+ * Replay confines its own mutations rather than trusting the composition:
+ * they run through `@smthrs/kernel/FileSystem`'s `confined` view, rooted at
+ * the kernel `Workspace` when one is in context. A symlink on a replayed path
+ * (a parent, the final component, or a member of a replayed tree) and a host
+ * with no descriptor-relative executor or isolation attestation both refuse
+ * with {@link UnsupportedBoundary}, which the caller journals as
+ * `replay_failed` before executing the step for real.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export declare const layer: Layer.Layer<Service, never, FileSystem.FileSystem | Path.Path | ArtifactStore.ArtifactStore>;
+/**
+ * What the deterministic test boundary should pretend the host observed.
+ *
+ * Every field is a fixture, not a classification rule: a test supplies settlement
+ * evidence or failure, the read snapshot, and whether the host claims
+ * to support the boundary at all — then asserts on the resulting evidence or
+ * refusal. Defaults describe a well-behaved, fully-supported host.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface TestOptions {
+    /** A settlement failure supplied verbatim by an integration fixture. */
+    readonly failure?: UndeclaredWrite | MissingDeclaredOutput | SurvivingDeclaredRemoval | undefined;
+    /** Settlement evidence supplied verbatim; classification belongs to the real layer. */
+    readonly deviation?: BoundaryDeviation | undefined;
+    /**
+     * What `prepare` reports as measured for the declared read set. Defaults
+     * to the declaration itself; a test supplies a different snapshot to stand
+     * for a file whose content moved out from under a stale declaration
+     * (issue #90).
+     */
+    readonly readSnapshot?: ReadonlyArray<FileInput> | undefined;
+    /** The opaque replay payload recorded in the evidence. */
+    readonly declaredOutputs?: unknown;
+    /** The post-state identity the evidence names. Defaults to a fixed string. */
+    readonly diffIdentity?: string | undefined;
+    /** When false, every call fails with {@link UnsupportedBoundary}. Defaults to true. */
+    readonly supported?: boolean | undefined;
+    /** Whether the fixture attests a whole-tree observation. Defaults to true. */
+    readonly wholeTreeWriteDetection?: boolean | undefined;
+    /** Whether the fixture models an isolated read surface. Defaults to true. */
+    readonly hermeticReadDetection?: boolean | undefined;
+    /** Observes each `replayOutputs` call, so a test can assert replay happened. */
+    readonly onReplay?: (evidence: BoundaryEvidence) => void;
+}
+/**
+ * Deterministic in-memory boundary suitable only for tests. Production
+ * wiring uses {@link layer}, the filesystem-backed implementation.
+ *
+ * Whole-tree change detection is supplied by sandboxed settlement, not by any
+ * boundary layer: an isolated execution's transaction IS the tree, so
+ * `ActionPersistence` compares its diff against the declared sets and sets
+ * `wholeTreeWritesVerified` structurally (the retired piece-6 limitation).
+ * {@link layer} still detects mutations within the declared read set only,
+ * which is why unsandboxed evidence stays run-local.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export declare const layerTest: (options?: TestOptions) => Layer.Layer<Service>;
+export {};
+//# sourceMappingURL=StepBoundary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StepBoundary.d.ts","sourceRoot":"","sources":["../../src/StepBoundary.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,aAAa,MAAM,iCAAiC,CAAA;AAEhE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAKlD,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AAEnC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;IAE3B;;;;;OAKG;;;;;EAEH,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,YAAY,YAAY,KAAG,aAAa,CAAC,SAAS,CACK,CAAA;AAElF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,gBAAgB,KAAG,OAW3D,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;EAG/B,CAAA;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,sBAAsB;;;EAGjC,CAAA;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB;;;EAGpC,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;IAA0F,CAAA;AAExH;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAE7D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;IAG3B;;;;;OAKG;;IAEH,8DAA8D;;;;;;;;;;;;EAG9D,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;;;;;;AAE3D;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,SAAQ,oBAOpC;CAAG;;;;;;AAEJ;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,qBAAsB,SAAQ,0BAO1C;CAAG;;;;;;AAEJ;;;;;;;;;;GAUG;AACH,qBAAa,wBAAyB,SAAQ,6BAO7C;CAAG;;;;IAmBA;;;;OAIG;;;AArBP;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAoB,SAAQ,wBAYxC;CAAG;;;;;;;AAEJ;;;;;;;;;GASG;AACH,qBAAa,kBAAmB,SAAQ,uBAQvC;CAAG;;;;;;AAEJ;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,SAAQ,oBAOpC;CAAG;AAEJ;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,OAAO,EAAE,CAChB,UAAU,EAAE,YAAY,KACrB,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACxE,QAAQ,CAAC,MAAM,EAAE,CACf,QAAQ,EAAE,gBAAgB,KACvB,MAAM,CAAC,MAAM,CAChB,gBAAgB,EAChB,eAAe,GAAG,qBAAqB,GAAG,wBAAwB,GAAG,mBAAmB,GAAG,kBAAkB,EAC7G,MAAM,CAAC,MAAM,CACd,CAAA;IACD,QAAQ,CAAC,aAAa,EAAE,CACtB,QAAQ,EAAE,gBAAgB,KACvB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,mBAAmB,GAAG,kBAAkB,GAAG,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;CACpG;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAE1D,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS,OAAO,KAAG,OAAmC,CAAA;AAwF3E;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5C;;;;;;;;OAQG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACjD;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACnC;AAiBD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,gBAAgB,KAAG,aAAa,CAAC,aAAa,CAAC,MAAM,CAShG,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,GACzB,IAAI,UAAU,CAAC,UAAU,EACzB,cAAc,IAAI,CAAC,IAAI,EACvB,WAAW,aAAa,CAAC,OAAO,EAChC,UAAS,iBAAsB,KAC9B,OAydF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAC7B,OAAO,EACP,KAAK,EACL,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC,aAAa,CAUhE,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,qBAAqB,GAAG,wBAAwB,GAAG,SAAS,CAAA;IACjG,uFAAuF;IACvF,QAAQ,CAAC,SAAS,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAA;IAClD;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,SAAS,CAAA;IAC5D,0DAA0D;IAC1D,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAA;IAClC,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1C,uFAAuF;IACvF,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACxC,8EAA8E;IAC9E,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACtD,6EAA6E;IAC7E,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACpD,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAA;CACzD;AAQD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,GAAI,UAAS,WAAgB,KAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CA6BxE,CAAA"}