@independo/inderun-web 0.4.0 → 0.5.0-rc.2

package/dist/core/artifacts.d.ts

@@ -0,0 +1,110 @@
+import type { ArtifactReadRequest, MediaArtifact } from "@independo/inderun-contracts";
+/**
+ * Size limits of an engine's artifact store (ADR 017). Every limit is in bytes.
+ */
+export interface ArtifactLimits {
+    /** Largest single artifact a provider may write. Default 16 MiB. */
+    maxArtifactBytes?: number;
+    /** Most bytes the store holds across all undisposed artifacts. Default 64 MiB. */
+    maxStoreBytes?: number;
+    /** Most bytes one `readArtifact` call returns. Default 1 MiB. */
+    maxReadBytes?: number;
+}
+export declare const DEFAULT_ARTIFACT_LIMITS: Required<ArtifactLimits>;
+/**
+ * One range of an artifact's bytes, as `IndeRun.readArtifact` returns it.
+ */
+export interface ArtifactChunk {
+    /** The artifact the bytes belong to. */
+    artifactId: string;
+    /** Byte offset of `bytes` within the artifact. */
+    offset: number;
+    /** The bytes of this range; empty when `offset` is the artifact's end. */
+    bytes: Uint8Array;
+    /** Size of the whole artifact in bytes. */
+    totalBytes: number;
+    /** Whether this range reaches the end of the artifact. */
+    done: boolean;
+}
+/** What a provider declares when it starts writing an artifact. */
+export interface ArtifactSpec {
+    /** IANA media type of the bytes, e.g. `audio/wav`; parameters ride on it. */
+    mediaType: string;
+    /** Duration of time-based media in milliseconds, where the provider knows it. */
+    durationMs?: number;
+}
+/**
+ * Writes one artifact into the engine's store. `finish()` hands it over: it commits the run
+ * to the provider and returns the reference the provider puts in its output. A provider that
+ * fails or stops before `finish()` calls `abort()`; the engine also discards any writer an
+ * attempt left open.
+ */
+export interface ArtifactWriter {
+    /**
+     * Appends bytes. Throws `Unavailable` (`details.code: "artifact_too_large"`) once the
+     * artifact would exceed the engine's per-artifact limit; the attempt has not committed, so
+     * the run may fall back.
+     */
+    write(bytes: Uint8Array): void;
+    /**
+     * Hands the finished artifact to the engine and commits the run. Throws `Unavailable`
+     * (`artifact_store_full`) when the store has no room, and `Unavailable`
+     * (`run_not_active`) when the run was cancelled or has ended -- in both cases before
+     * committing.
+     */
+    finish(): MediaArtifact;
+    /** Discards everything written. Idempotent. */
+    abort(): void;
+}
+/** Where a provider creates artifacts: `RunContext.artifacts`. */
+export interface ArtifactSink {
+    create(spec: ArtifactSpec): ArtifactWriter;
+}
+/**
+ * The engine-owned, in-memory artifact store (ADR 017): one per `IndeRun` instance. It holds
+ * every finished artifact until the application disposes it; there are no temporary files,
+ * so nothing outlives the process. Reads are ranged and bounded by `maxReadBytes`.
+ */
+export declare class ArtifactStore {
+    private readonly limits;
+    private readonly artifacts;
+    private storedBytes;
+    constructor(limits?: ArtifactLimits);
+    /**
+     * Opens the artifacts of one attempt. `commit` is the attempt's commit hook; a writer's
+     * `finish()` calls it, and refuses the handoff when it returns `false`.
+     */
+    attempt(commit: () => boolean): AttemptArtifacts;
+    /** Reads one range. See `IndeRunApi.readArtifact` for the contract. */
+    read(request: ArtifactReadRequest): ArtifactChunk;
+    /** Releases an artifact's bytes. Idempotent; unknown ids are ignored. */
+    dispose(artifactId: string): void;
+    /** The stored reference for `artifactId`, or `undefined` once it was disposed. */
+    reference(artifactId: string): MediaArtifact | undefined;
+    /** @internal Registers a finished artifact. */
+    store(spec: ArtifactSpec, bytes: Uint8Array): MediaArtifact;
+    /** @internal The whole artifact, for writing it to an application destination. */
+    bytes(artifactId: string): Uint8Array | undefined;
+    /** @internal */
+    get maxArtifactBytes(): number;
+}
+/**
+ * The artifacts one attempt created. The engine keeps the one the attempt returned and
+ * releases the rest: everything from an attempt that failed, was cancelled or lost to
+ * fallback, and anything a winning attempt finished but did not return. A returned artifact
+ * is never released behind the application's back.
+ */
+export declare class AttemptArtifacts implements ArtifactSink {
+    private readonly store;
+    private readonly commit;
+    private readonly finished;
+    private readonly open;
+    private released;
+    constructor(store: ArtifactStore, commit: () => boolean);
+    create(spec: ArtifactSpec): ArtifactWriter;
+    /** Whether `artifactId` was finished by this attempt and is still held. */
+    owns(artifactId: string): boolean;
+    /** Releases every artifact of this attempt except `keep`, and closes open writers. */
+    release(keep?: string): void;
+}
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/core/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../src/core/artifacts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAGvF;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oEAAoE;IACpE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kFAAkF;IAClF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,cAAc,CAI5D,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,KAAK,EAAE,UAAU,CAAC;IAClB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,IAAI,EAAE,OAAO,CAAC;CACf;AAED,mEAAmE;AACnE,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAC/B;;;;;OAKG;IACH,MAAM,IAAI,aAAa,CAAC;IACxB,+CAA+C;IAC/C,KAAK,IAAI,IAAI,CAAC;CACf;AAED,kEAAkE;AAClE,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,cAAc,CAAC;CAC5C;AAOD;;;;GAIG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqC;IAC/D,OAAO,CAAC,WAAW,CAAK;gBAEZ,MAAM,GAAE,cAAmB;IAIvC;;;OAGG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,OAAO,GAAG,gBAAgB;IAIhD,uEAAuE;IACvE,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,aAAa;IAkCjD,yEAAyE;IACzE,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAOjC,kFAAkF;IAClF,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIxD,+CAA+C;IAC/C,KAAK,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,aAAa;IAsB3D,kFAAkF;IAClF,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIjD,gBAAgB;IAChB,IAAI,gBAAgB,IAAI,MAAM,CAE7B;CACF;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IAMjD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA6B;IAClD,OAAO,CAAC,QAAQ,CAAS;gBAGN,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,MAAM,OAAO;IAGxC,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,cAAc;IAkD1C,2EAA2E;IAC3E,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAIjC,sFAAsF;IACtF,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;CAQ7B"}

package/dist/core/artifacts.js

@@ -0,0 +1,190 @@
+import { createInternal, createUnavailable } from "./errors.js";
+export const DEFAULT_ARTIFACT_LIMITS = {
+    maxArtifactBytes: 16 * 1024 * 1024,
+    maxStoreBytes: 64 * 1024 * 1024,
+    maxReadBytes: 1024 * 1024
+};
+/**
+ * The engine-owned, in-memory artifact store (ADR 017): one per `IndeRun` instance. It holds
+ * every finished artifact until the application disposes it; there are no temporary files,
+ * so nothing outlives the process. Reads are ranged and bounded by `maxReadBytes`.
+ */
+export class ArtifactStore {
+    limits;
+    artifacts = new Map();
+    storedBytes = 0;
+    constructor(limits = {}) {
+        this.limits = { ...DEFAULT_ARTIFACT_LIMITS, ...limits };
+    }
+    /**
+     * Opens the artifacts of one attempt. `commit` is the attempt's commit hook; a writer's
+     * `finish()` calls it, and refuses the handoff when it returns `false`.
+     */
+    attempt(commit) {
+        return new AttemptArtifacts(this, commit);
+    }
+    /** Reads one range. See `IndeRunApi.readArtifact` for the contract. */
+    read(request) {
+        const stored = this.artifacts.get(request.artifactId);
+        if (stored === undefined) {
+            throw createUnavailable(`Artifact '${request.artifactId}' is not held by this engine.`, {
+                retryable: false,
+                details: { code: "artifact_not_found" }
+            });
+        }
+        const totalBytes = stored.bytes.byteLength;
+        const offset = request.offset ?? 0;
+        if (offset > totalBytes) {
+            const validationIssues = [
+                {
+                    path: "/offset",
+                    message: `offset ${offset} is beyond the artifact's ${totalBytes} bytes`
+                }
+            ];
+            throw createInternal(`Validation failed for ArtifactReadRequest: /offset - ${validationIssues[0].message}`, { details: { validationIssues } });
+        }
+        const length = Math.min(request.maxBytes ?? this.limits.maxReadBytes, this.limits.maxReadBytes);
+        const end = Math.min(offset + length, totalBytes);
+        return {
+            artifactId: request.artifactId,
+            offset,
+            // A copy: the caller may keep or mutate it without touching the stored bytes.
+            bytes: stored.bytes.slice(offset, end),
+            totalBytes,
+            done: end === totalBytes
+        };
+    }
+    /** Releases an artifact's bytes. Idempotent; unknown ids are ignored. */
+    dispose(artifactId) {
+        const stored = this.artifacts.get(artifactId);
+        if (stored === undefined)
+            return;
+        this.artifacts.delete(artifactId);
+        this.storedBytes -= stored.bytes.byteLength;
+    }
+    /** The stored reference for `artifactId`, or `undefined` once it was disposed. */
+    reference(artifactId) {
+        return this.artifacts.get(artifactId)?.reference;
+    }
+    /** @internal Registers a finished artifact. */
+    store(spec, bytes) {
+        if (this.storedBytes + bytes.byteLength > this.limits.maxStoreBytes) {
+            throw createUnavailable("The engine's artifact store is full; dispose artifacts to free it.", {
+                details: { code: "artifact_store_full" }
+            });
+        }
+        const reference = {
+            id: `art_${randomId()}`,
+            mediaType: spec.mediaType,
+            owner: "engine",
+            lifetime: "until_disposed",
+            byteLength: bytes.byteLength,
+            ...(spec.durationMs !== undefined ? { durationMs: spec.durationMs } : {})
+        };
+        this.artifacts.set(reference.id, { reference, bytes });
+        this.storedBytes += bytes.byteLength;
+        return reference;
+    }
+    /** @internal The whole artifact, for writing it to an application destination. */
+    bytes(artifactId) {
+        return this.artifacts.get(artifactId)?.bytes;
+    }
+    /** @internal */
+    get maxArtifactBytes() {
+        return this.limits.maxArtifactBytes;
+    }
+}
+/**
+ * The artifacts one attempt created. The engine keeps the one the attempt returned and
+ * releases the rest: everything from an attempt that failed, was cancelled or lost to
+ * fallback, and anything a winning attempt finished but did not return. A returned artifact
+ * is never released behind the application's back.
+ */
+export class AttemptArtifacts {
+    store;
+    commit;
+    finished = new Set();
+    open = new Set();
+    released = false;
+    constructor(store, commit) {
+        this.store = store;
+        this.commit = commit;
+    }
+    create(spec) {
+        const chunks = [];
+        let size = 0;
+        let closed = false;
+        const writer = {
+            write: (bytes) => {
+                if (closed)
+                    throw createInternal("The artifact writer is already closed.");
+                if (size + bytes.byteLength > this.store.maxArtifactBytes) {
+                    writer.abort();
+                    throw createUnavailable(`The artifact exceeds the engine's ${this.store.maxArtifactBytes}-byte limit.`, { details: { code: "artifact_too_large" } });
+                }
+                chunks.push(bytes.slice());
+                size += bytes.byteLength;
+            },
+            finish: () => {
+                if (closed)
+                    throw createInternal("The artifact writer is already closed.");
+                const bytes = concat(chunks, size);
+                writer.abort();
+                // A provider that keeps working after its attempt ended (a late callback, say) must
+                // not leave an artifact behind that nobody owns.
+                if (this.released) {
+                    throw createUnavailable("The attempt has ended; the artifact was discarded.", {
+                        details: { code: "run_not_active" }
+                    });
+                }
+                // Stored before the commit so a full store fails the attempt pre-commit; dropped
+                // again when the run refuses the commit.
+                const reference = this.store.store(spec, bytes);
+                if (!this.commit()) {
+                    this.store.dispose(reference.id);
+                    throw createUnavailable("The run is no longer active; the artifact was discarded.", {
+                        details: { code: "run_not_active" }
+                    });
+                }
+                this.finished.add(reference.id);
+                return reference;
+            },
+            abort: () => {
+                closed = true;
+                chunks.length = 0;
+                this.open.delete(writer);
+            }
+        };
+        this.open.add(writer);
+        return writer;
+    }
+    /** Whether `artifactId` was finished by this attempt and is still held. */
+    owns(artifactId) {
+        return this.finished.has(artifactId) && this.store.reference(artifactId) !== undefined;
+    }
+    /** Releases every artifact of this attempt except `keep`, and closes open writers. */
+    release(keep) {
+        this.released = true;
+        for (const writer of [...this.open])
+            writer.abort();
+        for (const id of this.finished) {
+            if (id !== keep)
+                this.store.dispose(id);
+        }
+        this.finished.clear();
+    }
+}
+function concat(chunks, size) {
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+function randomId() {
+    const random = new Uint8Array(12);
+    globalThis.crypto.getRandomValues(random);
+    return Array.from(random, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}

package/dist/core/engine.d.ts

@@ -1,10 +1,11 @@
-import { type TaskRequest, type TaskResult } from "@independo/inderun-contracts";
+import { type ArtifactReadRequest, type MediaArtifact, type TaskRequest, type TaskResult } from "@independo/inderun-contracts";
 import type { HostServices } from "./host.js";
 import type { ProviderCapabilitySnapshot, StreamRun } from "./provider.js";
 import type { IndeRunApi } from "./generated/inderun-api.js";
 import { ProviderRegistry } from "./registry.js";
 import { type TelemetryService } from "./telemetry.js";
 import { type ModelProfiles } from "./model-profiles.js";
+import { type ArtifactChunk, type ArtifactLimits } from "./artifacts.js";
 /**
  * @deprecated Renamed to `StreamRun`, which is the name the generated
  * `IndeRunApi` surface and the Swift/Kotlin SDKs use. Kept as an alias so the
@@ -25,6 +26,11 @@ export interface IndeRunOptions {
      * `"auto"` is built in and cannot be redefined. See `docs/architecture/api-layering.md`.
      */
     modelProfiles?: ModelProfiles;
+    /**
+     * Size limits of the engine's in-memory artifact store (ADR 017). Defaults: 16 MiB per
+     * artifact, 64 MiB in total, 1 MiB per `readArtifact` call.
+     */
+    artifacts?: ArtifactLimits;
 }
 /**
  * Main orchestrator SDK entrypoint class.
@@ -35,6 +41,7 @@ export declare class IndeRun implements IndeRunApi {
     private registry;
     private hostServices;
     private router;
+    private readonly artifacts;
     private telemetryService;
     private modelProfiles;
     /**
@@ -104,6 +111,26 @@ export declare class IndeRun implements IndeRunApi {
      * Reports each registered provider's static descriptor and current dynamic capability check,
      * without executing a task. Useful for UI that shows live provider availability before a run.
      */
+    readArtifact(request: ArtifactReadRequest): Promise<ArtifactChunk>;
+    disposeArtifact(artifact: MediaArtifact): Promise<void>;
+    /**
+     * Refuses, before routing, an artifact request whose `destinationRef` this host cannot
+     * write to: there is no point running a provider whose result has nowhere to go.
+     */
+    private checkDestination;
+    /**
+     * Writes a finished artifact to the request's application destination, if it names one,
+     * and drops the engine's copy: the result's artifact is then application-owned. The run
+     * has committed by now, so a failed write is the run's failure, never a fallback.
+     */
+    private deliverToDestination;
+    /**
+     * Checks that an artifact in a provider's output is one this attempt produced, swaps in the
+     * reference the store holds, and only then checks the output against the requested delivery:
+     * the artifact's media type, size and ownership are the engine's record rather than the
+     * provider's claim.
+     */
+    private normalizeOutput;
     checkCapabilities(): Promise<ProviderCapabilitySnapshot[]>;
 }
 //# sourceMappingURL=engine.d.ts.map

package/dist/core/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAmB,0BAA0B,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAQjD,OAAO,EAAuB,KAAK,gBAAgB,EAAwB,MAAM,gBAAgB,CAAC;AAElG,OAAO,EAEL,KAAK,aAAa,EAInB,MAAM,qBAAqB,CAAC;AAG7B;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;;;GAIG;AACH,qBAAa,OAAQ,YAAW,UAAU;IAatC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,YAAY;IAbtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,aAAa,CAAgB;IAErC;;;;;;OAMG;gBAEO,QAAQ,EAAE,gBAAgB,EAC1B,YAAY,EAAE,YAAY,EAClC,OAAO,GAAE,cAAmB;IAS9B;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAkBvB;;;OAGG;IACH,OAAO,CAAC,GAAG;IAIX;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAShB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;;;OAOG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IA4HpD;;;;;;;;;;;;;;;;;OAiBG;IACG,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IAoRtD;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC;CASjE"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EAGxB,KAAK,aAAa,EAKlB,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAmB,0BAA0B,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAQjD,OAAO,EAAuB,KAAK,gBAAgB,EAAwB,MAAM,gBAAgB,CAAC;AAElG,OAAO,EAEL,KAAK,aAAa,EAInB,MAAM,qBAAqB,CAAC;AAQ7B,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,cAAc,EAGpB,MAAM,gBAAgB,CAAC;AAExB;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;OAGG;IACH,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B;AAED;;;;GAIG;AACH,qBAAa,OAAQ,YAAW,UAAU;IActC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,YAAY;IAdtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAC1C,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,aAAa,CAAgB;IAErC;;;;;;OAMG;gBAEO,QAAQ,EAAE,gBAAgB,EAC1B,YAAY,EAAE,YAAY,EAClC,OAAO,GAAE,cAAmB;IAU9B;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAwBvB;;;OAGG;IACH,OAAO,CAAC,GAAG;IAIX;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAShB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;;;OAOG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAoKpD;;;;;;;;;;;;;;;;;OAiBG;IACG,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IAsWtD;;;OAGG;IACG,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC;IAWlE,eAAe,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAM7D;;;OAGG;YACW,gBAAgB;IAkB9B;;;;OAIG;YACW,oBAAoB;IA0BlC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAsBjB,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC;CASjE"}