@nodetool-ai/websocket 0.7.0-rc.23 → 0.8.2

package/dist/lib/app-session-scope.js

@@ -0,0 +1,91 @@
+/**
+ * What a websocket connection opened by a deployed app's visitor may do.
+ *
+ * The connection authenticates as the app's owner (see the `nda_` token in
+ * `@nodetool-ai/auth`), so on the wire it looks like any other session. It is
+ * not one: the person holding it was given a link to one app, and the account
+ * behind it is a stranger's. Everything below is written as an allowlist for
+ * that reason — a command added to the runner later is refused here until
+ * someone decides it belongs, rather than reaching a stranger's account
+ * because nobody remembered this file.
+ *
+ * Two rules, and they are separate on purpose. Which *commands* are allowed is
+ * a fixed set. Which *graph* a run executes is not a matter of trust at all:
+ * the client's graph is discarded and the release's pinned graph is
+ * substituted, so a visitor who edits the payload runs the same thing as one
+ * who does not.
+ */
+/**
+ * The commands a deployed app needs: start a run, feed it, stop it, and see
+ * where it got to. Everything else the runner answers — chat, inference,
+ * asset and workflow listings, node metadata writes, model management — reads
+ * or spends the owner's account beyond the one app, so none of it is here.
+ *
+ * `reconnect_job` is included because a reload mid-run is ordinary use, and it
+ * only replays a job this connection's user owns.
+ */
+export const APP_SESSION_COMMANDS = new Set([
+    "run_job",
+    "reconnect_job",
+    "cancel_job",
+    "stream_input",
+    "end_input_stream",
+    "get_status"
+]);
+export function isAppSessionCommandAllowed(command) {
+    return APP_SESSION_COMMANDS.has(command);
+}
+export function isRunRefusal(result) {
+    return "refused" in result;
+}
+/**
+ * Rewrite a visitor's run request into the only run it is allowed to make.
+ *
+ * Built field by field rather than by spreading the request, for the same
+ * reason the command set is an allowlist: a field added to `RunJobRequest`
+ * later must not reach a stranger's account because nobody remembered this
+ * file. What a visitor gets to say is what an app *is* — which operation to
+ * run, and what to run it on:
+ *
+ *   `params`        the inputs. Supplying them is the whole point.
+ *   `operation_id`  which published workflow operation to run.
+ *
+ * Everything else the wire carries is the server's. `job_id` names the run so
+ * the client can follow it, and the runner refuses one that is already taken.
+ * `workflow_id`, `job_name`, and `application_id` come
+ * from the signed session and `application_version` from the release, so a
+ * visitor cannot bill a run to another app or file it under a version that
+ * never shipped. `graph` comes from the release, so what runs is what the
+ * owner published — a client that sends a wider graph, or one with an
+ * exfiltrating node in it, gets the published graph instead. `supervise` is
+ * dropped because it puts a second model on the owner's bill;
+ * `execution_options`, `concurrent`, `auth_token` and `user_id` are dropped
+ * because none of them is a visitor's to set.
+ */
+export function confineRunRequest(req, scope, release) {
+    const operationId = req.operation_id;
+    if (!operationId) {
+        return { refused: "This app run did not name an operation" };
+    }
+    const operation = release.document.operations.find((entry) => entry.id === operationId);
+    if (!operation) {
+        return { refused: "This app does not publish that operation" };
+    }
+    if (operation.target?.kind === "script" || !operation.workflowId) {
+        return { refused: "This app operation is not a workflow" };
+    }
+    const pinned = release.workflows.find((entry) => entry.workflowId === operation.workflowId);
+    if (!pinned?.graph) {
+        return { refused: "This app does not publish that workflow" };
+    }
+    return {
+        workflow_id: operation.workflowId,
+        job_name: operation.name,
+        params: req.params,
+        operation_id: operation.id,
+        application_id: scope.applicationId,
+        application_version: release.version,
+        graph: pinned.graph
+    };
+}
+//# sourceMappingURL=app-session-scope.js.map

package/dist/lib/app-session-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-session-scope.js","sourceRoot":"","sources":["../../src/lib/app-session-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAuCH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAwB,IAAI,GAAG,CAAC;IAC/D,SAAS;IACT,eAAe;IACf,YAAY;IACZ,cAAc;IACd,kBAAkB;IAClB,YAAY;CACb,CAAC,CAAC;AAEH,MAAM,UAAU,0BAA0B,CAAC,OAAe;IACxD,OAAO,oBAAoB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AAC3C,CAAC;AAOD,MAAM,UAAU,YAAY,CAC1B,MAA4C;IAE5C,OAAO,SAAS,IAAI,MAAM,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,GAAkB,EAClB,KAAsB,EACtB,OAAwB;IAExB,MAAM,WAAW,GAAG,GAAG,CAAC,YAAY,CAAC;IACrC,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,EAAE,OAAO,EAAE,wCAAwC,EAAE,CAAC;IAC/D,CAAC;IACD,MAAM,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAChD,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,WAAW,CACpC,CAAC;IACF,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO,EAAE,OAAO,EAAE,0CAA0C,EAAE,CAAC;IACjE,CAAC;IACD,IAAI,SAAS,CAAC,MAAM,EAAE,IAAI,KAAK,QAAQ,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;QACjE,OAAO,EAAE,OAAO,EAAE,sCAAsC,EAAE,CAAC;IAC7D,CAAC;IACD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CACnC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,KAAK,SAAS,CAAC,UAAU,CACrD,CAAC;IACF,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;QACnB,OAAO,EAAE,OAAO,EAAE,yCAAyC,EAAE,CAAC;IAChE,CAAC;IACD,OAAO;QACL,WAAW,EAAE,SAAS,CAAC,UAAU;QACjC,QAAQ,EAAE,SAAS,CAAC,IAAI;QACxB,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,YAAY,EAAE,SAAS,CAAC,EAAE;QAC1B,cAAc,EAAE,KAAK,CAAC,aAAa;QACnC,mBAAmB,EAAE,OAAO,CAAC,OAAO;QACpC,KAAK,EAAE,MAAM,CAAC,KAAK;KACpB,CAAC;AACJ,CAAC"}

package/dist/lib/applications-service.d.ts

@@ -0,0 +1,354 @@
+/**
+ * Application service — the business logic behind both transports.
+ *
+ * The tRPC `applications` router and the `/api/applications` REST routes are
+ * two doors onto these functions, so an app looks the same whichever one a
+ * client comes through. Errors are raised with `throwApiError`, which the REST
+ * layer maps back to a status code.
+ */
+import { z } from "zod";
+import { type ApplicationDocument } from "@nodetool-ai/app-runtime";
+import { Application, Workflow } from "@nodetool-ai/models";
+import { type ApplicationBundleSchema, type ApplicationListItem, type ApplicationReleaseResponse, type ApplicationResponse, type CreateApplicationInput, type ImportApplicationBundleInput } from "@nodetool-ai/protocol/api-schemas/applications.js";
+export declare const listApplicationsInput: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    workflowId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const applicationIdInput: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const updateApplicationInput: z.ZodIntersection<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    document: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodNumber;
+        ui: z.ZodObject<{
+            root: z.ZodObject<{
+                props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>;
+            content: z.ZodArray<z.ZodUnknown>;
+            zones: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+        }, z.core.$loose>;
+        operations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            workflowId: z.ZodString;
+            workflowVersion: z.ZodOptional<z.ZodNumber>;
+            target: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"workflow">;
+                workflowId: z.ZodString;
+                workflowVersion: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"script">;
+                scriptId: z.ZodString;
+                scriptVersion: z.ZodNumber;
+            }, z.core.$strip>]>>;
+            inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                from: z.ZodLiteral<"widget">;
+            }, z.core.$strip>, z.ZodObject<{
+                from: z.ZodLiteral<"variable">;
+                variableId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                from: z.ZodLiteral<"constant">;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                from: z.ZodLiteral<"resource">;
+                resourceBindingId: z.ZodString;
+            }, z.core.$strip>]>>>;
+            outputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                to: z.ZodLiteral<"display">;
+            }, z.core.$strip>, z.ZodObject<{
+                to: z.ZodLiteral<"variable">;
+                variableId: z.ZodString;
+            }, z.core.$strip>]>>>;
+            policy: z.ZodDefault<z.ZodEnum<{
+                parallel: "parallel";
+                queue: "queue";
+                replace: "replace";
+            }>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        resources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                asset: "asset";
+                sketch: "sketch";
+                storyboard: "storyboard";
+                timeline: "timeline";
+            }>;
+            scope: z.ZodObject<{
+                projectId: z.ZodOptional<z.ZodString>;
+                fixedId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            operations: z.ZodArray<z.ZodEnum<{
+                create: "create";
+                delete: "delete";
+                read: "read";
+                update: "update";
+            }>>;
+        }, z.core.$strip>>>;
+        variables: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                type: z.ZodString;
+                optional: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            scope: z.ZodEnum<{
+                instance: "instance";
+                user: "user";
+            }>;
+            persist: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        theme: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        recipe: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            slug: z.ZodString;
+            category: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            inputs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    asset: "asset";
+                    audio: "audio";
+                    boolean: "boolean";
+                    color: "color";
+                    entity: "entity";
+                    image: "image";
+                    number: "number";
+                    storyboard: "storyboard";
+                    text: "text";
+                    timeline: "timeline";
+                    video: "video";
+                }>;
+                required: z.ZodBoolean;
+                description: z.ZodOptional<z.ZodString>;
+                choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    title: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    image: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            creativeStrategy: z.ZodOptional<z.ZodObject<{
+                objective: z.ZodOptional<z.ZodString>;
+                structure: z.ZodOptional<z.ZodString>;
+                direction: z.ZodOptional<z.ZodString>;
+                aspectRatio: z.ZodOptional<z.ZodEnum<{
+                    "16:9": "16:9";
+                    "1:1": "1:1";
+                    "4:5": "4:5";
+                    "9:16": "9:16";
+                }>>;
+                shots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    title: z.ZodString;
+                    durationSeconds: z.ZodNumber;
+                    elements: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        inputId: z.ZodOptional<z.ZodString>;
+                        kind: z.ZodEnum<{
+                            asset: "asset";
+                            shape: "shape";
+                            text: "text";
+                        }>;
+                        role: z.ZodEnum<{
+                            cta: "cta";
+                            decorative: "decorative";
+                            headline: "headline";
+                            logo: "logo";
+                            price: "price";
+                            product: "product";
+                        }>;
+                        direction: z.ZodOptional<z.ZodString>;
+                        frame: z.ZodOptional<z.ZodObject<{
+                            box: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                            fit: z.ZodOptional<z.ZodEnum<{
+                                contain: "contain";
+                                cover: "cover";
+                            }>>;
+                            align: z.ZodOptional<z.ZodObject<{
+                                x: z.ZodOptional<z.ZodEnum<{
+                                    center: "center";
+                                    end: "end";
+                                    start: "start";
+                                }>>;
+                                y: z.ZodOptional<z.ZodEnum<{
+                                    center: "center";
+                                    end: "end";
+                                    start: "start";
+                                }>>;
+                            }, z.core.$strip>>;
+                            clip: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>>;
+                        typography: z.ZodOptional<z.ZodObject<{
+                            size: z.ZodOptional<z.ZodNumber>;
+                            weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>, z.ZodLiteral<600>, z.ZodLiteral<700>]>>;
+                            align: z.ZodOptional<z.ZodEnum<{
+                                center: "center";
+                                left: "left";
+                                right: "right";
+                            }>>;
+                            maxLines: z.ZodOptional<z.ZodNumber>;
+                        }, z.core.$strip>>;
+                        lock: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                            crop: "crop";
+                            position: "position";
+                            scale: "scale";
+                        }>>>;
+                        limits: z.ZodOptional<z.ZodObject<{
+                            x: z.ZodOptional<z.ZodNumber>;
+                            y: z.ZodOptional<z.ZodNumber>;
+                            scale: z.ZodOptional<z.ZodNumber>;
+                        }, z.core.$strip>>;
+                        style: z.ZodOptional<z.ZodObject<{
+                            fill: z.ZodOptional<z.ZodString>;
+                            stroke: z.ZodOptional<z.ZodString>;
+                            strokeWidth: z.ZodOptional<z.ZodNumber>;
+                            cornerRadius: z.ZodOptional<z.ZodNumber>;
+                        }, z.core.$strip>>;
+                        fallback: z.ZodOptional<z.ZodObject<{
+                            prompt: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    reviewRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                reviewRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            preservationRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                inputId: z.ZodString;
+                policy: z.ZodEnum<{
+                    exact_asset: "exact_asset";
+                    exact_color: "exact_color";
+                    exact_text: "exact_text";
+                }>;
+                allowedTransformations: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    composite: "composite";
+                    crop: "crop";
+                    mask: "mask";
+                    opacity: "opacity";
+                    position: "position";
+                    rotate: "rotate";
+                    scale: "scale";
+                }>>>;
+            }, z.core.$strip>>>;
+            mediaPolicy: z.ZodOptional<z.ZodObject<{
+                defaultStrategy: z.ZodOptional<z.ZodEnum<{
+                    generated_video: "generated_video";
+                    hybrid: "hybrid";
+                    still_motion_graphics: "still_motion_graphics";
+                }>>;
+                allowGeneratedVideo: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            operations: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                bindingId: z.ZodString;
+                intent: z.ZodString;
+                version: z.ZodOptional<z.ZodNumber>;
+                strategy: z.ZodOptional<z.ZodEnum<{
+                    agentic: "agentic";
+                    deterministic: "deterministic";
+                }>>;
+                model: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodString;
+                    id: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            outputs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    asset: "asset";
+                    storyboard: "storyboard";
+                    timeline: "timeline";
+                    value: "value";
+                }>;
+                binding: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            presentation: z.ZodOptional<z.ZodObject<{
+                layout: z.ZodOptional<z.ZodString>;
+                groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    title: z.ZodString;
+                    inputIds: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>>>;
+                advancedInputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            marketing: z.ZodOptional<z.ZodObject<{
+                shortDescription: z.ZodOptional<z.ZodString>;
+                thumbnailAssetId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    baseUpdatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export type UpdateApplicationInput = z.infer<typeof updateApplicationInput>;
+export declare function toListItem(app: Application): ApplicationListItem;
+export declare function loadOwnedApplication(userId: string | null, id: string): Promise<Application>;
+/**
+ * Build a small, deterministic first screen for workflows that predate the
+ * standalone application document. The widgets intentionally bind by node ID
+ * and let the shared runtime derive their type and defaults from the graph.
+ * That keeps this service independent of the web editor's input-kind catalog
+ * while making the result runnable as soon as it is opened.
+ */
+export declare function scaffoldDocumentFromWorkflow(workflowId: string, workflow: Workflow): ApplicationDocument;
+export declare function listApplications(userId: string, projectId?: string, workflowId?: string): Promise<ApplicationListItem[]>;
+export declare function getApplication(userId: string, id: string): Promise<ApplicationResponse>;
+export declare function createApplication(userId: string, input: CreateApplicationInput): Promise<ApplicationResponse>;
+export declare function updateApplication(userId: string, input: UpdateApplicationInput): Promise<ApplicationResponse>;
+/**
+ * Delete the app together with its versions, ledger and budget.
+ *
+ * `Application.delete` is the cascade: the child tables carry no owner check
+ * of their own, so leaving a row behind hands it to whoever next claims this
+ * id — an id a client is free to name.
+ */
+export declare function deleteApplication(userId: string, id: string): Promise<{
+    ok: true;
+}>;
+/**
+ * Export an app as an {@link ApplicationBundle}: the document plus the full
+ * graph of every workflow its operations bind, with the operations rewritten
+ * to bundle-local keys.
+ *
+ * With `released`, the bundle carries the released snapshot and the graphs the
+ * release pinned, so a published app exports reproducibly; otherwise it carries
+ * the draft and the workflows' live graphs. A workflow an operation binds but
+ * that no longer exists is left out — the operation keeps its raw id, so the
+ * broken link stays visible instead of silently disappearing.
+ */
+export declare function exportApplicationBundle(userId: string, id: string, options?: {
+    released?: boolean;
+}): Promise<ApplicationBundleSchema>;
+/**
+ * Import an {@link ApplicationBundle}: create a workflow row per carried
+ * workflow, then the application with its operations pointing at the new ids.
+ *
+ * Workflows are written first so the app never references a row that does not
+ * exist yet.
+ *
+ * **Dedupe rule.** A carried workflow that declares a `sourceId` gets a row id
+ * derived from that source and the importing user, so importing the same
+ * source twice lands on the same row: the second import reuses what the first
+ * created rather than duplicating it. That is what keeps two example apps
+ * binding the same template — Photo Studio and Concept Studio both bind Image
+ * Enhance — down to one workflow. A workflow with no `sourceId` (a
+ * hand-exported bundle) always gets a fresh id, so importing a colleague's app
+ * never silently attaches to a workflow you already have.
+ */
+export declare function importApplicationBundle(userId: string, input: ImportApplicationBundleInput): Promise<ApplicationResponse>;
+/**
+ * What a published app should run: the released snapshot's document, its
+ * version number and capabilities, plus the graph each operation is pinned to.
+ */
+export declare function releasedApplicationDocument(userId: string, id: string): Promise<ApplicationReleaseResponse | null>;
+//# sourceMappingURL=applications-service.d.ts.map

package/dist/lib/applications-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applications-service.d.ts","sourceRoot":"","sources":["../../src/lib/applications-service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAQL,KAAK,mBAAmB,EAGzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,WAAW,EAKX,QAAQ,EAMT,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAKL,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EAClC,MAAM,mDAAmD,CAAC;AAK3D,eAAO,MAAM,qBAAqB;;;iBAIhC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;iBAA+B,CAAC;AAE/D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAElC,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,wBAAgB,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG,mBAAmB,CAahE;AAOD,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,WAAW,CAAC,CAOtB;AA6DD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,QAAQ,GACjB,mBAAmB,CAqJrB;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAYhC;AAED,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,mBAAmB,CAAC,CAG9B;AAkCD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,sBAAsB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAkC9B;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,sBAAsB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAqC9B;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,GACT,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC,CAIvB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,GACnC,OAAO,CAAC,uBAAuB,CAAC,CA+DlC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,mBAAmB,CAAC,CAmE9B;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAI5C"}