@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/design-canvas/schema.d.ts

@@ -0,0 +1,558 @@
+/**
+ * Drizzle schema factory for design-canvas tables. The product owns the
+ * workspace/user tables; the factory wires design-canvas foreign keys into
+ * them so the whole graph lives in one drizzle schema with real cascade
+ * semantics. Column names and conventions mirror the sequences schema so
+ * products with both surfaces share a DDL style.
+ *
+ * The `document` column persists the full SceneDocument as JSON. Rev starts
+ * at 1 on insert and increments atomically on every successful saveDocument —
+ * optimistic concurrency without merge machinery.
+ *
+ * `isTemplate` marks documents that serve as fill-in-slots templates; the
+ * index on (workspaceId, isTemplate) makes template browsing fast.
+ */
+import type { AnySQLiteColumn, AnySQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { SceneDocument } from './model';
+/** A product table referenced by FK — only the `id` column is touched. */
+export type DesignCanvasParentTable = AnySQLiteTable & {
+    id: AnySQLiteColumn;
+};
+/** Define options for creating design canvas tables including workspace and user table configurations */
+export interface CreateDesignCanvasTablesOptions {
+    workspaceTable: DesignCanvasParentTable;
+    userTable: DesignCanvasParentTable;
+}
+/** Build SQLite tables for design documents with workspace and user references */
+export declare function createDesignCanvasTables(opts: CreateDesignCanvasTablesOptions): {
+    designDocuments: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "design_document";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "design_document";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            workspaceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "workspace_id";
+                tableName: "design_document";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            title: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "title";
+                tableName: "design_document";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            document: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "document";
+                tableName: "design_document";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: SceneDocument;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: SceneDocument;
+            }>;
+            rev: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "rev";
+                tableName: "design_document";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            isTemplate: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "is_template";
+                tableName: "design_document";
+                dataType: "boolean";
+                columnType: "SQLiteBoolean";
+                data: boolean;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdBy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_by";
+                tableName: "design_document";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_at";
+                tableName: "design_document";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "updated_at";
+                tableName: "design_document";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
+    designDecisions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "design_decision";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "design_decision";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            documentId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "document_id";
+                tableName: "design_decision";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            workspaceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "workspace_id";
+                tableName: "design_decision";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            kind: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "kind";
+                tableName: "design_decision";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: "note" | "human_edit" | "agent_edit" | "agent_proposal" | "export";
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: ["human_edit", "agent_edit", "agent_proposal", "export", "note"];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            instruction: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "instruction";
+                tableName: "design_decision";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            reasoningSummary: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "reasoning_summary";
+                tableName: "design_decision";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            metadata: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "metadata";
+                tableName: "design_decision";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: Record<string, unknown>;
+                driverParam: string;
+                notNull: false;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+            createdBy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_by";
+                tableName: "design_decision";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_at";
+                tableName: "design_decision";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
+    designExports: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "design_export";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "design_export";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            documentId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "document_id";
+                tableName: "design_export";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            workspaceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "workspace_id";
+                tableName: "design_export";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            format: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "format";
+                tableName: "design_export";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: "json" | "png" | "jpeg";
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: ["png", "jpeg", "json"];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "status";
+                tableName: "design_export";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: "completed" | "queued" | "failed" | "processing";
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: ["queued", "processing", "completed", "failed"];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            resultUrl: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "result_url";
+                tableName: "design_export";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            metadata: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "metadata";
+                tableName: "design_export";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: Record<string, unknown>;
+                driverParam: string;
+                notNull: false;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+            createdBy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_by";
+                tableName: "design_export";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_at";
+                tableName: "design_export";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
+};
+/** Resolve the structure and data of design canvas tables for rendering and manipulation */
+export type DesignCanvasTables = ReturnType<typeof createDesignCanvasTables>;
+/** Resolve the selected structure of a design document row from design canvas tables */
+export type DesignDocumentRow = DesignCanvasTables['designDocuments']['$inferSelect'];
+/** Resolve a design decision row from the design decisions table selection */
+export type DesignDecisionRow = DesignCanvasTables['designDecisions']['$inferSelect'];
+/** Resolve the selected fields of designExports from DesignCanvasTables */
+export type DesignExportRow = DesignCanvasTables['designExports']['$inferSelect'];

package/dist/{store-CqfDtnPQ.d.ts → design-canvas/store.d.ts}

@@ -1,5 +1,3 @@
-import { c as SceneDocument } from './model-DnfO_PdJ.js';
-
 /**
  * Storage contract for design-canvas documents. Unlike sequences (row per
  * clip), a scene document persists as ONE JSON value with a monotonic
@@ -13,15 +11,15 @@ import { c as SceneDocument } from './model-DnfO_PdJ.js';
  * Every method throws on failure; the MCP dispatcher converts throws into
  * structured tool errors.
  */
-
+import type { SceneDocument } from './model';
 /** Represent a scene document with its current revision number for version tracking */
-interface SceneDocumentRecord {
+export interface SceneDocumentRecord {
     document: SceneDocument;
     /** Monotonic revision; increments on every successful save. */
     rev: number;
 }
 /** Define the structure for decisions made within a scene including type, instructions, and metadata */
-interface SceneDecision {
+export interface SceneDecision {
     id: string;
     kind: 'human_edit' | 'agent_edit' | 'agent_proposal' | 'export' | 'note';
     instruction: string;
@@ -30,16 +28,16 @@ interface SceneDecision {
     createdAt: Date;
 }
 /** Define the structure for decisions related to creating a new scene with instructions and optional details */
-interface NewSceneDecision {
+export interface NewSceneDecision {
     kind: SceneDecision['kind'];
     instruction: string;
     reasoningSummary?: string | null;
     metadata?: Record<string, unknown>;
 }
 /** Define supported formats for exporting a scene including image and JSON options */
-type SceneExportFormat = 'png' | 'jpeg' | 'json';
+export type SceneExportFormat = 'png' | 'jpeg' | 'json';
 /** Describe a scene export with its status, format, metadata, and result information */
-interface SceneExportRecord {
+export interface SceneExportRecord {
     id: string;
     format: SceneExportFormat;
     status: 'queued' | 'processing' | 'completed' | 'failed';
@@ -48,7 +46,7 @@ interface SceneExportRecord {
     createdAt: Date;
 }
 /** Manage scene documents, decisions, and exports with atomic save and revision control */
-interface SceneStore {
+export interface SceneStore {
     /** Current document + revision. */
     getDocument(): Promise<SceneDocumentRecord>;
     /** Atomic full-document save. Throws when `expectedRev` is stale — the
@@ -61,10 +59,8 @@ interface SceneStore {
 }
 /** Per-request scope a product binds at store construction; decision and
  *  export rows attribute to the acting user — never trusted from tool args. */
-interface SceneStoreScope {
+export interface SceneStoreScope {
     workspaceId: string;
     documentId: string;
     userId: string;
 }
-
-export type { NewSceneDecision as N, SceneStoreScope as S, SceneStore as a, SceneDocumentRecord as b, SceneDecision as c, SceneExportFormat as d, SceneExportRecord as e };

package/dist/design-canvas/templates.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Template helpers for design-canvas documents. A template is any document
+ * whose elements carry `slot` names — those slots define the fillable surface
+ * that data sources and agents target. The helpers here are pure (no store,
+ * no Konva) so they run server-side, in MCP tools, or in tests without a DOM.
+ *
+ * Binding semantics (shared with `apply_data` operation):
+ *   - text elements: binding value replaces `element.text`
+ *   - image/video elements: binding value replaces `element.src`
+ *   - rect/ellipse elements with a slot: binding value replaces `element.fill`
+ *     (color-slot convention — background swatch templates)
+ *   - line/group slots are reserved; binding them throws a loud error
+ * Unknown binding keys (no matching slot) throw — callers must preflight with
+ * `validateBindings` or accept that the throw is the signal to fix their data.
+ */
+import { type SceneDocument, type SceneElementKind } from './model';
+/** Define allowed string literals representing different slot fill kinds */
+export type SlotFillKind = 'text' | 'src' | 'color';
+/** Define a slot template specifying its name, page, element, and fill characteristics */
+export interface TemplateSlot {
+    name: string;
+    pageId: string;
+    elementId: string;
+    elementKind: SceneElementKind;
+    fillKind: SlotFillKind;
+}
+/**
+ * Wraps `collectSlots` with kind-aware fill typing so callers know WHAT to
+ * put in each slot without inspecting the element tree themselves.
+ * Throws when duplicate slot names exist (propagated from collectSlots).
+ */
+export declare function listTemplateSlots(document: SceneDocument): TemplateSlot[];
+/**
+ * Preflight check: every key in `bindings` must name a slot in the document.
+ * Returns a list of problems; an empty array means the bindings are clean.
+ * Does NOT throw — designed to run before `instantiateTemplate` so callers
+ * can surface a structured error instead of catching.
+ */
+export declare function validateBindings(document: SceneDocument, bindings: Record<string, string>): string[];
+/** Define options for instantiating a document with title, optional bindings, and custom id minting */
+export interface InstantiateOptions {
+    /** Human-readable title for the new document. */
+    title: string;
+    /** Slot bindings to apply after id re-minting. Partial application allowed. */
+    bindings?: Record<string, string>;
+    /**
+     * Caller-supplied id factory — every page/element id in the source document
+     * is replaced with a fresh value from this callback. The callback receives
+     * the source id so implementations can build stable deterministic ids (e.g.
+     * `crypto.randomUUID()` or `nanoid()` from the host).
+     */
+    mintId(sourceId: string): string;
+}
+/**
+ * Produces a new `SceneDocument` from a template:
+ * 1. Re-mints every page and element id via `options.mintId` (slot *names* are
+ *    preserved so apply_data still targets them by name).
+ * 2. Applies `options.bindings` with the same semantics as `apply_data`.
+ * 3. Stamps `metadata.templateSourceId` with the source document's title so
+ *    the lineage is traceable without storing separate template provenance rows.
+ *
+ * Throws when bindings reference unknown slots (validated via `validateBindings`
+ * before mutation so no partial state is possible).
+ */
+export declare function instantiateTemplate(document: SceneDocument, options: InstantiateOptions): SceneDocument;
+/**
+ * Applies slot bindings to a document in place (mutates a deep copy produced
+ * by the caller). Unknown slot names throw — the preflight in `instantiateTemplate`
+ * guarantees this is unreachable there; exported so the `apply_data` operation
+ * handler can reuse it without duplicating the switch.
+ */
+export declare function applyBindingsToDocument(document: SceneDocument, bindings: Record<string, string>): SceneDocument;