@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/dist/cli-hzqmgcm2.js

@@ -1,3066 +0,0 @@
-import {
-  buildScriptCredentialBindingsWithFailures,
-  getScriptApiConnectionDescriptors,
-  getScriptById,
-  getScriptMcpConnectionDescriptors,
-  listScriptConnections,
-  restoreScratchScriptLastUsedIfUnchanged,
-  runScript,
-  touchScratchScriptLastUsed
-} from "./cli-svbrpf5q.js";
-import {
-  defaultAssetKey,
-  getDbClient,
-  getLeadAgent,
-  init_db,
-  init_key
-} from "./cli-qgd4sqz5.js";
-import {
-  init_zod
-} from "./cli-sd0mxa3c.js";
-import {
-  _enum,
-  array,
-  boolean,
-  discriminatedUnion,
-  literal,
-  never,
-  number,
-  object,
-  record,
-  string,
-  union,
-  unknown
-} from "./cli-w5e1d1vv.js";
-
-// src/be/scripts/run-saved.ts
-function getSavedScriptOwnerAgentId(script) {
-  return script.scopeId ?? script.createdByAgentId;
-}
-async function runSavedScriptAsAgent(args) {
-  const runStartTouch = args.script.isScratch ? await touchScratchScriptLastUsed(args.script.id) : null;
-  const credentials = await buildScriptCredentialBindingsWithFailures({
-    agentId: args.agentId
-  });
-  const output = await runScript({
-    source: args.script.source,
-    args: args.input,
-    fsMode: args.script.fsMode,
-    agentId: args.agentId,
-    egressSecrets: credentials.egressSecrets,
-    failedBindings: credentials.failedBindings,
-    apiConnections: getScriptApiConnectionDescriptors({ agentId: args.agentId }),
-    mcpConnections: getScriptMcpConnectionDescriptors({ agentId: args.agentId })
-  });
-  if (output.exitCode === 0 && !output.error && !output.runtimeError) {
-    await touchScratchScriptLastUsed(args.script.id);
-  } else if (runStartTouch) {
-    await restoreScratchScriptLastUsedIfUnchanged(args.script.id, args.script.updatedAt, runStartTouch);
-  }
-  return output;
-}
-
-// src/apps/definition.ts
-init_zod();
-// src/apps/catalog.generated.json
-var catalog_generated_default = {
-  $comment: "GENERATED by apps/ui/scripts/generate-catalog-schema.ts — do not hand-edit. Regenerate with `cd apps/ui && bun run generate:catalog-schema`.",
-  componentTypes: [
-    "Stack",
-    "Grid",
-    "Split",
-    "Divider",
-    "Tabs",
-    "Container",
-    "Card",
-    "Heading",
-    "Text",
-    "Markdown",
-    "SearchInput",
-    "Select",
-    "Button",
-    "Metric",
-    "Alert",
-    "Badge",
-    "Table",
-    "Form",
-    "Drawer",
-    "DetailList",
-    "ElementRef",
-    "ElementSlot"
-  ],
-  actionTypes: [
-    "swarm.sdk",
-    "swarm.call",
-    "app.mutate",
-    "app.refresh",
-    "app.action",
-    "app.navigate"
-  ],
-  components: {
-    Stack: {
-      description: "THE primary layout primitive — a flex column (default) or row of its children. `gap`/`padding` use the shared spacing scale (none|xs|sm|md|lg|xl, default gap md); `align` is the cross axis, `justify` the main axis, `wrap` lets a row reflow. For rows, set `collapseBelow` (sm|md|lg) so the row stacks vertically on narrow viewports — filter bars should always set it. Use this as the page root and for every section; `Container` is the legacy 2-prop alias kept for older pages.",
-      slots: ["default"],
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          direction: {
-            type: "string",
-            enum: ["column", "row"]
-          },
-          gap: {
-            type: "string",
-            enum: ["none", "xs", "sm", "md", "lg", "xl"]
-          },
-          align: {
-            type: "string",
-            enum: ["start", "center", "end", "stretch"]
-          },
-          justify: {
-            type: "string",
-            enum: ["start", "center", "end", "between"]
-          },
-          wrap: {
-            type: "boolean"
-          },
-          padding: {
-            type: "string",
-            enum: ["none", "xs", "sm", "md", "lg", "xl"]
-          },
-          collapseBelow: {
-            type: "string",
-            enum: ["sm", "md", "lg"]
-          }
-        },
-        additionalProperties: false
-      }
-    },
-    Grid: {
-      description: "Responsive grid of equal-width cells, one per child. `columns` is either a single count (1-6) — responsive shorthand: 1 column on phones, 2 from `sm`, the count from `md` up — or a per-breakpoint object `{ base, sm, md, lg }` (default `{ base: 1, md: 2, lg: 3 }`). Prefer this over a wrapping Stack for card strips and metric tiles.",
-      slots: ["default"],
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          columns: {
-            anyOf: [
-              {
-                type: "integer",
-                minimum: 1,
-                maximum: 6
-              },
-              {
-                type: "object",
-                properties: {
-                  base: {
-                    type: "integer",
-                    minimum: 1,
-                    maximum: 6
-                  },
-                  sm: {
-                    type: "integer",
-                    minimum: 1,
-                    maximum: 6
-                  },
-                  md: {
-                    type: "integer",
-                    minimum: 1,
-                    maximum: 6
-                  },
-                  lg: {
-                    type: "integer",
-                    minimum: 1,
-                    maximum: 6
-                  }
-                },
-                additionalProperties: false
-              }
-            ]
-          },
-          gap: {
-            type: "string",
-            enum: ["none", "xs", "sm", "md", "lg", "xl"]
-          },
-          padding: {
-            type: "string",
-            enum: ["none", "xs", "sm", "md", "lg", "xl"]
-          }
-        },
-        additionalProperties: false
-      }
-    },
-    Split: {
-      description: "Two-pane layout. POSITIONAL children: the FIRST child is the left pane, the SECOND is the right pane, and any further children stack inside the right pane. `ratio` sizes them (1-1|1-2|2-1|1-3|3-1, default 2-1 = wide left). Below `collapseBelow` (sm|md|lg, default md) the panes stack vertically; `reverse` only flips that stacked order (right pane first on narrow screens).",
-      slots: ["default"],
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          ratio: {
-            type: "string",
-            enum: ["1-1", "1-2", "2-1", "1-3", "3-1"]
-          },
-          gap: {
-            type: "string",
-            enum: ["none", "xs", "sm", "md", "lg", "xl"]
-          },
-          collapseBelow: {
-            type: "string",
-            enum: ["sm", "md", "lg"]
-          },
-          reverse: {
-            type: "boolean"
-          },
-          padding: {
-            type: "string",
-            enum: ["none", "xs", "sm", "md", "lg", "xl"]
-          }
-        },
-        additionalProperties: false
-      }
-    },
-    Divider: {
-      description: 'Horizontal rule between sections, optionally with a centered `label` (e.g. `"Filters"`).',
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          label: {
-            type: "string"
-          }
-        },
-        additionalProperties: false
-      }
-    },
-    Tabs: {
-      description: 'Tabbed sections. POSITIONAL children: children[i] is the body of tabs[i], so declare exactly as many children as tabs, in the same order. Only the active tab is visible but every child stays mounted, so polled Tables in background tabs keep their data warm. The active key is mirrored into state at `/ui/<id>/tab`, so other components can bind `{ "$state": "/ui/<id>/tab" }`. `defaultTab` picks the initial key (defaults to the first tab).',
-      slots: ["default"],
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          id: {
-            type: "string"
-          },
-          tabs: {
-            minItems: 1,
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                key: {
-                  type: "string"
-                },
-                label: {
-                  type: "string"
-                }
-              },
-              required: ["key"],
-              additionalProperties: false
-            }
-          },
-          defaultTab: {
-            type: "string"
-          }
-        },
-        required: ["id", "tabs"],
-        additionalProperties: false
-      }
-    },
-    Container: {
-      description: "Legacy flex container (row/column + gap). Prefer `Stack`, which supports the full spacing scale plus alignment, wrapping and padding.",
-      slots: ["default"],
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          direction: {
-            type: "string",
-            enum: ["row", "column"]
-          },
-          gap: {
-            type: "string",
-            enum: ["none", "sm", "md", "lg"]
-          }
-        },
-        additionalProperties: false
-      }
-    },
-    Card: {
-      description: "Bordered card with optional title and description.",
-      slots: ["default"],
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          title: {
-            type: "string"
-          },
-          description: {
-            type: "string"
-          }
-        },
-        additionalProperties: false
-      }
-    },
-    Heading: {
-      description: "Text heading (h1/h2/h3).",
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          text: {
-            type: "string"
-          },
-          level: {
-            type: "string",
-            enum: ["h1", "h2", "h3"]
-          }
-        },
-        required: ["text"],
-        additionalProperties: false
-      }
-    },
-    Text: {
-      description: "Paragraph text.",
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          content: {
-            type: "string"
-          },
-          tone: {
-            type: "string",
-            enum: ["default", "muted"]
-          }
-        },
-        required: ["content"],
-        additionalProperties: false
-      }
-    },
-    Markdown: {
-      description: "Rendered markdown block — headings, lists, links, tables, fenced code. Use it for prose (about/help sections, instructions); use `Text` for a single plain paragraph.",
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          content: {
-            type: "string"
-          }
-        },
-        required: ["content"],
-        additionalProperties: false
-      }
-    },
-    SearchInput: {
-      description: 'Free-text search box. Writes the debounced (~200ms) query into state at `/ui/<id>/value`; bind it into a Table with `"search": { "$state": "/ui/<id>/value" }`. Purely client-side — it filters rows the page already polled, it does not re-run the query.',
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          id: {
-            type: "string"
-          },
-          placeholder: {
-            type: "string"
-          },
-          label: {
-            type: "string"
-          }
-        },
-        required: ["id"],
-        additionalProperties: false
-      }
-    },
-    Select: {
-      description: 'Dropdown filter/picker. `options` are plain strings or `{ value, label }` objects. Writes the chosen value into state at `/ui/<id>/value` (clearing writes `null`); bind it into a Table with `"filters": { "<column>": { "$state": "/ui/<id>/value" } }`. `clearable` (default true) shows a clear button.',
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          id: {
-            type: "string"
-          },
-          options: {
-            minItems: 1,
-            type: "array",
-            items: {
-              anyOf: [
-                {
-                  type: "string"
-                },
-                {
-                  type: "object",
-                  properties: {
-                    value: {
-                      type: "string"
-                    },
-                    label: {
-                      type: "string"
-                    }
-                  },
-                  required: ["value"],
-                  additionalProperties: false
-                }
-              ]
-            }
-          },
-          placeholder: {
-            type: "string"
-          },
-          label: {
-            type: "string"
-          },
-          clearable: {
-            type: "boolean"
-          }
-        },
-        required: ["id", "options"],
-        additionalProperties: false
-      }
-    },
-    Button: {
-      description: 'Interactive button. Wire to actions via `on.press`. `variant: "destructive-outline"` is the canonical red-outlined destructive look (standalone deletes should use it, not solid red). `disabled` accepts a constant or a bound boolean; `busyWith: "<actionName>"` disables the button and shows a spinner while that custom action is running.',
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          label: {
-            type: "string"
-          },
-          variant: {
-            type: "string",
-            enum: [
-              "default",
-              "secondary",
-              "outline",
-              "ghost",
-              "destructive",
-              "destructive-outline"
-            ]
-          },
-          disabled: {
-            type: "boolean"
-          },
-          busyWith: {
-            type: "string"
-          }
-        },
-        required: ["label"],
-        additionalProperties: false
-      }
-    },
-    Metric: {
-      description: 'Single label/value tile for status pages. Bind `loading` to the backing query (`{ "$state": "/queries/<name>/loading" }`) to show a skeleton instead of a blank value while it loads.',
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          label: {
-            type: "string"
-          },
-          value: {
-            anyOf: [
-              {
-                type: "string"
-              },
-              {
-                type: "number"
-              }
-            ]
-          },
-          loading: {
-            type: "boolean"
-          }
-        },
-        required: ["label", "value"],
-        additionalProperties: false
-      }
-    },
-    Alert: {
-      description: "Status-toned inline alert.",
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          message: {
-            type: "string"
-          },
-          tone: {
-            type: "string",
-            enum: ["info", "success", "warning", "error"]
-          },
-          title: {
-            type: "string"
-          }
-        },
-        required: ["message"],
-        additionalProperties: false
-      }
-    },
-    Badge: {
-      description: "Status pill (uppercase tag chip) with a semantic tone.",
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          text: {
-            anyOf: [
-              {
-                type: "string"
-              },
-              {
-                type: "number"
-              }
-            ]
-          },
-          tone: {
-            type: "string",
-            enum: [
-              "neutral",
-              "success",
-              "active",
-              "error",
-              "info",
-              "pending",
-              "warning",
-              "paused"
-            ]
-          }
-        },
-        required: ["text"],
-        additionalProperties: false
-      }
-    },
-    Table: {
-      description: 'Data table. Bind `data`/`loading`/`error` to a named query (`/queries/<name>/...`). `rowActions` chains receive `{ "$row": "<col>" }` (or `{ "$row": "" }` for the whole row) and `{ "$rowIndex": true }`. Destructive row actions always confirm via a dialog; override the copy with `confirm: { title, description, confirmLabel }`. `search` (case-insensitive substring across every listed column) and `filters` (per-column equality, `null`/`""` disables one) narrow the polled rows client-side — bind them to a `SearchInput` / `Select` via `/ui/<id>/value`, or pin a constant (e.g. `"filters": { "pinned": true }`). Columns take `pinned: "left"|"right"` to survive horizontal scroll; `pagination` pages large row sets (auto past 200 rows); `density: "compact"` tightens row height.',
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          data: {
-            type: "array",
-            items: {
-              type: "object",
-              propertyNames: {
-                type: "string"
-              },
-              additionalProperties: {}
-            }
-          },
-          columns: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                key: {
-                  type: "string"
-                },
-                label: {
-                  type: "string"
-                },
-                kind: {
-                  type: "string",
-                  enum: ["text", "string", "number", "boolean", "date", "badge", "enum"]
-                },
-                tones: {
-                  type: "object",
-                  propertyNames: {
-                    type: "string"
-                  },
-                  additionalProperties: {
-                    type: "string",
-                    enum: [
-                      "neutral",
-                      "success",
-                      "active",
-                      "error",
-                      "info",
-                      "pending",
-                      "warning",
-                      "paused"
-                    ]
-                  }
-                },
-                width: {
-                  type: "number"
-                },
-                pinned: {
-                  type: "string",
-                  enum: ["left", "right"]
-                }
-              },
-              required: ["key"],
-              additionalProperties: false
-            }
-          },
-          rowActions: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                label: {
-                  type: "string"
-                },
-                variant: {
-                  type: "string",
-                  enum: [
-                    "default",
-                    "secondary",
-                    "outline",
-                    "ghost",
-                    "destructive",
-                    "destructive-outline"
-                  ]
-                },
-                confirm: {
-                  anyOf: [
-                    {
-                      type: "boolean"
-                    },
-                    {
-                      type: "object",
-                      properties: {
-                        title: {
-                          type: "string"
-                        },
-                        description: {
-                          type: "string"
-                        },
-                        confirmLabel: {
-                          type: "string"
-                        }
-                      },
-                      additionalProperties: false
-                    },
-                    {
-                      type: "string"
-                    }
-                  ]
-                },
-                actions: {
-                  type: "array",
-                  items: {
-                    type: "object",
-                    properties: {
-                      action: {
-                        type: "string"
-                      },
-                      params: {
-                        type: "object",
-                        propertyNames: {
-                          type: "string"
-                        },
-                        additionalProperties: {}
-                      }
-                    },
-                    required: ["action"],
-                    additionalProperties: false
-                  }
-                }
-              },
-              required: ["label", "actions"],
-              additionalProperties: false
-            }
-          },
-          loading: {
-            type: "boolean"
-          },
-          error: {
-            anyOf: [
-              {
-                type: "string"
-              },
-              {
-                type: "null"
-              }
-            ]
-          },
-          emptyMessage: {
-            type: "string"
-          },
-          search: {
-            type: "string"
-          },
-          filters: {
-            type: "object",
-            propertyNames: {
-              type: "string"
-            },
-            additionalProperties: {
-              anyOf: [
-                {
-                  anyOf: [
-                    {
-                      type: "string"
-                    },
-                    {
-                      type: "number"
-                    },
-                    {
-                      type: "boolean"
-                    }
-                  ]
-                },
-                {
-                  type: "null"
-                }
-              ]
-            }
-          },
-          pagination: {
-            type: "boolean"
-          },
-          density: {
-            type: "string",
-            enum: ["comfortable", "compact"]
-          }
-        },
-        required: ["columns"],
-        additionalProperties: false
-      }
-    },
-    Form: {
-      description: 'Field form. Values live in state under `/forms/<id>/<field>`; `onSubmit` chains receive `$form` (all collected values) and `$form: "<field>"` for one. `app.mutate` failures in the chain surface inline under the fields (not the page banner), and the submit button shows a pending spinner while the chain runs.',
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          id: {
-            type: "string"
-          },
-          title: {
-            type: "string"
-          },
-          fields: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                name: {
-                  type: "string",
-                  pattern: "^[^$]"
-                },
-                label: {
-                  type: "string"
-                },
-                kind: {
-                  type: "string",
-                  enum: ["string", "text", "number", "boolean", "date", "enum"]
-                },
-                options: {
-                  type: "array",
-                  items: {
-                    type: "string"
-                  }
-                },
-                placeholder: {
-                  type: "string"
-                },
-                required: {
-                  type: "boolean"
-                }
-              },
-              required: ["name"],
-              additionalProperties: false
-            }
-          },
-          submitLabel: {
-            type: "string"
-          },
-          onSubmit: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                action: {
-                  type: "string"
-                },
-                params: {
-                  type: "object",
-                  propertyNames: {
-                    type: "string"
-                  },
-                  additionalProperties: {}
-                }
-              },
-              required: ["action"],
-              additionalProperties: false
-            }
-          }
-        },
-        required: ["id", "fields", "onSubmit"],
-        additionalProperties: false
-      }
-    },
-    Drawer: {
-      description: 'Route-driven slide-in side panel (sheet). Open exactly when the route param named by `param` is set — open it with `app.navigate` (e.g. a rowAction setting `{ "panel": { "$row": "id" } }`), and the URL stays shareable: a deep link with the param renders the drawer open, and closing it clears the param. Children mount only while open (a Table inside does NOT stay warm when closed — unlike Tabs). `side` right (default) or left; `size` sm|md|lg|xl width.',
-      slots: ["default"],
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          param: {
-            type: "string"
-          },
-          title: {
-            type: "string"
-          },
-          description: {
-            type: "string"
-          },
-          side: {
-            type: "string",
-            enum: ["right", "left"]
-          },
-          size: {
-            type: "string",
-            enum: ["sm", "md", "lg", "xl"]
-          }
-        },
-        required: ["param"],
-        additionalProperties: false
-      }
-    },
-    DetailList: {
-      description: 'Read-only label/value detail view for ONE record. Bind `data` to a single row — usually `{ "$state": "/queries/<name>/data/0" }` with a `$param`-filtered query. `fields` pick and format properties with the same kinds as Table columns (badge tones, relative dates) plus `code` for raw/JSON values. Bind `loading` to the query (`/queries/<name>/loading`) for skeleton fields while it loads; `emptyMessage` shows when the record is genuinely missing.',
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          data: {
-            anyOf: [
-              {
-                type: "object",
-                propertyNames: {
-                  type: "string"
-                },
-                additionalProperties: {}
-              },
-              {
-                type: "null"
-              }
-            ]
-          },
-          fields: {
-            minItems: 1,
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                key: {
-                  type: "string"
-                },
-                label: {
-                  type: "string"
-                },
-                kind: {
-                  type: "string",
-                  enum: ["text", "string", "number", "boolean", "date", "badge", "enum", "code"]
-                },
-                tones: {
-                  type: "object",
-                  propertyNames: {
-                    type: "string"
-                  },
-                  additionalProperties: {
-                    type: "string",
-                    enum: [
-                      "neutral",
-                      "success",
-                      "active",
-                      "error",
-                      "info",
-                      "pending",
-                      "warning",
-                      "paused"
-                    ]
-                  }
-                }
-              },
-              required: ["key"],
-              additionalProperties: false
-            }
-          },
-          emptyMessage: {
-            type: "string"
-          },
-          columns: {
-            anyOf: [
-              {
-                type: "number",
-                const: 1
-              },
-              {
-                type: "number",
-                const: 2
-              }
-            ]
-          },
-          loading: {
-            type: "boolean"
-          }
-        },
-        required: ["fields"],
-        additionalProperties: false
-      }
-    },
-    ElementRef: {
-      description: "Reference a reusable element from this app or an exported element from another app. Consumer children are inserted at the target's ElementSlot.",
-      slots: ["default"],
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          app: {
-            type: "string"
-          },
-          element: {
-            type: "string"
-          },
-          props: {
-            type: "object",
-            propertyNames: {
-              type: "string"
-            },
-            additionalProperties: {}
-          },
-          instanceKey: {
-            type: "string"
-          }
-        },
-        required: ["element"],
-        additionalProperties: false
-      }
-    },
-    ElementSlot: {
-      description: "Leaf insertion point for children supplied by an ElementRef consumer.",
-      props: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {},
-        additionalProperties: false
-      }
-    }
-  },
-  actions: {
-    "swarm.sdk": {
-      description: "Invoke a method on the in-SPA Swarm SDK with the viewer's bearer.",
-      params: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          sdk: {
-            type: "string",
-            enum: [
-              "tasks.create",
-              "tasks.list",
-              "tasks.get",
-              "tasks.storeProgress",
-              "agents.list",
-              "agents.get",
-              "events.create",
-              "events.list",
-              "events.batch",
-              "events.counts",
-              "memory.search",
-              "memory.list",
-              "memory.get",
-              "memory.rate",
-              "repos.list",
-              "repos.get",
-              "repos.create",
-              "repos.update",
-              "repos.delete",
-              "schedules.list",
-              "schedules.get",
-              "schedules.create",
-              "schedules.update",
-              "schedules.delete",
-              "schedules.run",
-              "approvalRequests.list",
-              "approvalRequests.get",
-              "approvalRequests.create",
-              "approvalRequests.respond",
-              "assets.list",
-              "assets.audit",
-              "assets.registerMapping",
-              "assets.move"
-            ]
-          },
-          args: {
-            type: "object",
-            propertyNames: {
-              type: "string"
-            },
-            additionalProperties: {}
-          }
-        },
-        required: ["sdk"],
-        additionalProperties: false
-      }
-    },
-    "swarm.call": {
-      description: "Raw HTTP call to a swarm `/api/*` endpoint with the viewer's bearer.",
-      params: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          method: {
-            type: "string",
-            enum: ["GET", "POST", "PUT", "DELETE", "PATCH"]
-          },
-          endpoint: {
-            type: "string"
-          },
-          body: {
-            type: "object",
-            propertyNames: {
-              type: "string"
-            },
-            additionalProperties: {}
-          }
-        },
-        required: ["method", "endpoint"],
-        additionalProperties: false
-      }
-    },
-    "app.mutate": {
-      description: "Create / update / delete a swarm-app row, then refetch every named query on the same model.",
-      params: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          model: {
-            type: "string"
-          },
-          op: {
-            type: "string",
-            enum: ["create", "update", "delete"]
-          },
-          rowId: {
-            type: "string"
-          },
-          values: {
-            type: "object",
-            propertyNames: {
-              type: "string"
-            },
-            additionalProperties: {}
-          },
-          formId: {
-            type: "string"
-          }
-        },
-        required: ["model", "op"],
-        additionalProperties: false
-      }
-    },
-    "app.refresh": {
-      description: "Refetch one named swarm-app query, or all of them when `query` is omitted.",
-      params: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          query: {
-            type: "string"
-          }
-        },
-        additionalProperties: false
-      }
-    },
-    "app.action": {
-      description: "Invoke a named custom action from the app definition's `actions` map (script- or task-backed). Result lands in state at `/actions/<name>`.",
-      params: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          name: {
-            type: "string"
-          },
-          input: {
-            type: "object",
-            propertyNames: {
-              type: "string"
-            },
-            additionalProperties: {}
-          }
-        },
-        required: ["name"],
-        additionalProperties: false
-      }
-    },
-    "app.navigate": {
-      description: "Navigate to another page of this app (`/apps/:id/p/<page>?<params>`). `params` replace the current route params wholesale and may use `$row` / `$form` sentinels. Pushes a history entry (browser Back returns). The current route is mirrored into state at `/route` as `{ page, params }`.",
-      params: {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        type: "object",
-        properties: {
-          page: {
-            type: "string"
-          },
-          params: {
-            type: "object",
-            propertyNames: {
-              type: "string"
-            },
-            additionalProperties: {
-              anyOf: [
-                {
-                  type: "string"
-                },
-                {
-                  type: "number"
-                },
-                {
-                  type: "boolean"
-                }
-              ]
-            }
-          }
-        },
-        required: ["page"],
-        additionalProperties: false
-      }
-    }
-  }
-};
-
-// src/apps/page-validator.ts
-var ELEMENT_KEYS = new Set([
-  "type",
-  "props",
-  "children",
-  "on",
-  "visible",
-  "repeat",
-  "watch"
-]);
-var UI_STATE_COMPONENTS = new Set(["SearchInput", "Select", "Tabs"]);
-var CONDITION_KEYS = new Set(["eq", "neq", "gt", "gte", "lt", "lte", "not"]);
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function isStateBinding(value) {
-  return isPlainObject(value) && Object.keys(value).length === 1 && typeof value.$state === "string";
-}
-function isStateCondition(value) {
-  return isPlainObject(value) && typeof value.$state === "string" && Object.keys(value).some((key) => CONDITION_KEYS.has(key));
-}
-function isParamBinding(value) {
-  return isPlainObject(value) && Object.keys(value).length === 1 && typeof value.$param === "string";
-}
-function isRepeatBinding(value) {
-  if (!isPlainObject(value))
-    return false;
-  const keys = Object.keys(value);
-  if (keys.length !== 1)
-    return false;
-  if (keys[0] === "$item")
-    return typeof value.$item === "string";
-  return keys[0] === "$index" && value.$index === true;
-}
-function collectRepeatBindingPaths(value, path, paths) {
-  if (isRepeatBinding(value)) {
-    paths.push(path);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const [index, child] of value.entries()) {
-      collectRepeatBindingPaths(child, appendPath(path, index), paths);
-    }
-    return;
-  }
-  if (!isPlainObject(value))
-    return;
-  for (const [key, child] of Object.entries(value)) {
-    collectRepeatBindingPaths(child, appendPath(path, key), paths);
-  }
-}
-function isActionSentinel(value) {
-  if (!isPlainObject(value) || Object.keys(value).length !== 1)
-    return false;
-  if (typeof value.$row === "string")
-    return true;
-  if (value.$rowIndex === true)
-    return true;
-  return typeof value.$form === "string";
-}
-function appendPath(path, part) {
-  return path ? `${path}.${part}` : String(part);
-}
-function issue(path, message) {
-  return { path, message };
-}
-function dedupeIssues(issues) {
-  const seen = new Set;
-  return issues.filter(({ path, message }) => {
-    const key = `${path}\x00${message}`;
-    if (seen.has(key))
-      return false;
-    seen.add(key);
-    return true;
-  });
-}
-function typeMatches(value, type) {
-  switch (type) {
-    case "null":
-      return value === null;
-    case "object":
-      return isPlainObject(value);
-    case "array":
-      return Array.isArray(value);
-    case "string":
-      return typeof value === "string";
-    case "number":
-      return typeof value === "number" && Number.isFinite(value);
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value);
-    case "boolean":
-      return typeof value === "boolean";
-    default:
-      return true;
-  }
-}
-function equalJsonValue(left, right) {
-  if (Object.is(left, right))
-    return true;
-  if (Array.isArray(left) && Array.isArray(right) || isPlainObject(left) && isPlainObject(right)) {
-    return JSON.stringify(left) === JSON.stringify(right);
-  }
-  return false;
-}
-function validateSchema(value, schema, path, allowActionSentinels, skipPath) {
-  if (isStateBinding(value)) {
-    return { issues: [], stateRefs: [{ path, value: value.$state }] };
-  }
-  if (isRepeatBinding(value))
-    return { issues: [], stateRefs: [] };
-  if (isActionSentinel(value)) {
-    return allowActionSentinels ? { issues: [], stateRefs: [] } : {
-      issues: [
-        issue(path, "$row, $rowIndex, and $form bindings are only allowed in action params")
-      ],
-      stateRefs: []
-    };
-  }
-  if (schema.anyOf) {
-    for (const candidate of schema.anyOf) {
-      const result2 = validateSchema(value, candidate, path, allowActionSentinels);
-      if (result2.issues.length === 0)
-        return result2;
-    }
-    return { issues: [issue(path, "must match one of the allowed schemas")], stateRefs: [] };
-  }
-  if (schema.const !== undefined && !equalJsonValue(value, schema.const)) {
-    return { issues: [issue(path, `must equal ${JSON.stringify(schema.const)}`)], stateRefs: [] };
-  }
-  if (schema.enum && !schema.enum.some((candidate) => equalJsonValue(value, candidate))) {
-    return {
-      issues: [issue(path, `must be one of ${schema.enum.map(String).join(", ")}`)],
-      stateRefs: []
-    };
-  }
-  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
-  if (types.length > 0 && !types.some((type) => typeMatches(value, type))) {
-    return { issues: [issue(path, `must be ${types.join(" or ")}`)], stateRefs: [] };
-  }
-  const result = { issues: [], stateRefs: [] };
-  if (isPlainObject(value)) {
-    const properties = schema.properties ?? {};
-    for (const required of schema.required ?? []) {
-      if (!Object.hasOwn(value, required)) {
-        result.issues.push(issue(appendPath(path, required), "is required"));
-      }
-    }
-    for (const [key, child] of Object.entries(value)) {
-      const childPath = appendPath(path, key);
-      if (skipPath?.(childPath))
-        continue;
-      const propertySchema = properties[key];
-      if (propertySchema) {
-        const childAllowsActionSentinels = allowActionSentinels || key === "params" && Object.hasOwn(properties, "action") && (schema.required ?? []).includes("action");
-        const childResult = validateSchema(child, propertySchema, childPath, childAllowsActionSentinels, skipPath);
-        result.issues.push(...childResult.issues);
-        result.stateRefs.push(...childResult.stateRefs);
-      } else if (schema.additionalProperties === false) {
-        result.issues.push(issue(childPath, "unknown property"));
-      } else if (isPlainObject(schema.additionalProperties)) {
-        const childResult = validateSchema(child, schema.additionalProperties, childPath, allowActionSentinels, skipPath);
-        result.issues.push(...childResult.issues);
-        result.stateRefs.push(...childResult.stateRefs);
-      } else {
-        const childResult = validateSchema(child, {}, childPath, allowActionSentinels, skipPath);
-        result.issues.push(...childResult.issues);
-        result.stateRefs.push(...childResult.stateRefs);
-      }
-    }
-  } else if (Array.isArray(value)) {
-    for (const [index, child] of value.entries()) {
-      const childResult = validateSchema(child, schema.items ?? {}, appendPath(path, index), allowActionSentinels, skipPath);
-      result.issues.push(...childResult.issues);
-      result.stateRefs.push(...childResult.stateRefs);
-    }
-  }
-  return result;
-}
-function actionParams(step, path, definition, catalog, validateNavigation = false) {
-  const result = { issues: [], stateRefs: [] };
-  if (typeof step.action !== "string") {
-    result.issues.push(issue(appendPath(path, "action"), "must be a string"));
-    return result;
-  }
-  if (validateNavigation) {
-    if (step.action !== "app.navigate")
-      return result;
-    const paramsPath2 = appendPath(path, "params");
-    const params2 = step.params ?? {};
-    if (!isPlainObject(params2))
-      return result;
-    const targetPage = params2.page;
-    if (typeof targetPage !== "string") {
-      if (isActionSentinel(targetPage) || isStateBinding(targetPage)) {
-        result.issues.push(issue(appendPath(paramsPath2, "page"), "must be a literal page name"));
-      }
-      return result;
-    }
-    const target = Object.hasOwn(definition.pages, targetPage) ? definition.pages[targetPage] : undefined;
-    if (!target) {
-      result.issues.push(issue(appendPath(paramsPath2, "page"), `unknown page "${targetPage}"`));
-      return result;
-    }
-    const suppliedParams = isPlainObject(params2.params) && !isActionSentinel(params2.params) && !isStateBinding(params2.params) ? params2.params : {};
-    const declaredParams = target.params ?? {};
-    for (const name of Object.keys(suppliedParams)) {
-      if (!Object.hasOwn(declaredParams, name)) {
-        result.issues.push(issue(appendPath(appendPath(paramsPath2, "params"), name), `param "${name}" is not declared by target page "${targetPage}"`));
-      }
-    }
-    for (const [name, parameter] of Object.entries(declaredParams)) {
-      if (parameter.required === true && !Object.hasOwn(suppliedParams, name)) {
-        result.issues.push(issue(appendPath(appendPath(paramsPath2, "params"), name), `required param "${name}" is missing for target page "${targetPage}"`));
-      }
-    }
-    return result;
-  }
-  const actionDefinition = catalog.actions[step.action];
-  if (!catalog.actionTypes.includes(step.action) || !actionDefinition) {
-    result.issues.push(issue(appendPath(path, "action"), `unknown action type "${step.action}"`));
-    return result;
-  }
-  const paramsPath = appendPath(path, "params");
-  const params = step.params ?? {};
-  const schemaResult = validateSchema(params, actionDefinition.params, paramsPath, true);
-  result.issues.push(...schemaResult.issues);
-  result.stateRefs.push(...schemaResult.stateRefs);
-  if (!isPlainObject(params))
-    return result;
-  if (step.action === "app.mutate") {
-    const model = params.model;
-    if (typeof model !== "string" || !Object.hasOwn(definition.models, model)) {
-      result.issues.push(issue(appendPath(paramsPath, "model"), `unknown model "${String(model)}"`));
-      return result;
-    }
-    const op = params.op;
-    if (op !== "create" && op !== "update" && op !== "delete") {
-      result.issues.push(issue(appendPath(paramsPath, "op"), "must be create, update, or delete"));
-    }
-    if (op === "update" || op === "delete") {
-      const rowId = params.rowId;
-      const validRowId = typeof rowId === "string" || isPlainObject(rowId) && typeof rowId.$row === "string" && Object.keys(rowId).length === 1;
-      if (!validRowId) {
-        result.issues.push(issue(appendPath(paramsPath, "rowId"), "is required for update and delete and must be a string or $row binding"));
-      }
-    }
-    if (isPlainObject(params.values) && !isActionSentinel(params.values) && !isStateBinding(params.values)) {
-      for (const column of Object.keys(params.values)) {
-        const columnDefinition = definition.models[model].columns[column];
-        if (!columnDefinition || columnDefinition.hidden === true) {
-          result.issues.push(issue(appendPath(appendPath(paramsPath, "values"), column), `unknown or hidden column "${column}"`));
-        }
-      }
-    }
-  } else if (step.action === "app.refresh") {
-    if (typeof params.query === "string" && !Object.hasOwn(definition.queries ?? {}, params.query)) {
-      result.issues.push(issue(appendPath(paramsPath, "query"), `unknown query "${params.query}"`));
-    }
-  } else if (step.action === "app.action") {
-    if (typeof params.name !== "string" || !Object.hasOwn(definition.actions ?? {}, params.name)) {
-      result.issues.push(issue(appendPath(paramsPath, "name"), `unknown app action "${String(params.name)}"`));
-    }
-  }
-  return result;
-}
-function validateActionChain(chain, path, definition, catalog) {
-  const result = { issues: [], stateRefs: [] };
-  if (!Array.isArray(chain)) {
-    result.issues.push(issue(path, "must be an action array"));
-    return result;
-  }
-  for (const [index, step] of chain.entries()) {
-    const stepPath = appendPath(path, index);
-    if (!isPlainObject(step)) {
-      result.issues.push(issue(stepPath, "must be an action object"));
-      continue;
-    }
-    const stepResult = actionParams(step, stepPath, definition, catalog);
-    result.issues.push(...stepResult.issues);
-    result.stateRefs.push(...stepResult.stateRefs);
-  }
-  return result;
-}
-function validateActionMap(value, path, definition, catalog, allowSingle) {
-  const result = { issues: [], stateRefs: [] };
-  if (!isPlainObject(value)) {
-    result.issues.push(issue(path, "must be an object of action chains"));
-    return result;
-  }
-  for (const [event, chain] of Object.entries(value)) {
-    const eventPath = appendPath(path, event);
-    const normalized = allowSingle && isPlainObject(chain) ? [chain] : chain;
-    const chainResult = validateActionChain(normalized, eventPath, definition, catalog);
-    result.issues.push(...chainResult.issues);
-    result.stateRefs.push(...chainResult.stateRefs);
-  }
-  return result;
-}
-function validateStateRef(ref, definition, formIds, uiIds, pageParams) {
-  if (ref.value === "/route/page")
-    return null;
-  const routeParam = /^\/route\/params\/([^/]+)$/.exec(ref.value);
-  if (routeParam) {
-    const name2 = routeParam[1];
-    return Object.hasOwn(pageParams, name2) ? null : issue(ref.path, `state reference targets unknown route param "${name2}"`);
-  }
-  const userConfigMatch = /^\/user\/([^/]+)(\/.*)?$/.exec(ref.value);
-  if (userConfigMatch) {
-    const [, name2, suffix] = userConfigMatch;
-    if (suffix) {
-      return issue(ref.path, `userConfig state reference "${ref.value}" must target exactly /user/<field>; nested paths are not supported`);
-    }
-    if (Object.hasOwn(definition.userConfig ?? {}, name2))
-      return null;
-    const declared = Object.keys(definition.userConfig ?? {}).sort();
-    return issue(ref.path, `state reference targets unknown userConfig field "${name2}"; declared fields: ${declared.length > 0 ? declared.join(", ") : "none"}`);
-  }
-  const match = /^\/(queries|forms|actions|ui)\/([^/]+)(?:\/.*)?$/.exec(ref.value);
-  if (!match)
-    return issue(ref.path, `invalid state reference "${ref.value}"`);
-  const [, namespace, name] = match;
-  const exists = namespace === "queries" && Object.hasOwn(definition.queries ?? {}, name) || namespace === "forms" && formIds.has(name) || namespace === "actions" && Object.hasOwn(definition.actions ?? {}, name) || namespace === "ui" && uiIds.has(name);
-  const targetKind = namespace === "queries" ? "query" : namespace === "forms" ? "form" : namespace === "actions" ? "action" : "UI control";
-  if (!exists)
-    return issue(ref.path, `state reference targets unknown ${targetKind} "${name}"`);
-  if (namespace === "queries") {
-    const dataMatch = /^\/queries\/[^/]+\/data(?:\/(.*))?$/.exec(ref.value);
-    const segments = dataMatch?.[1]?.split("/").filter(Boolean) ?? [];
-    if (/^\d+$/.test(segments[0] ?? ""))
-      segments.shift();
-    const columnName = segments[0];
-    const query = definition.queries?.[name];
-    if (columnName && query && Object.hasOwn(definition.models, query.model)) {
-      return fieldBindingIssue(query.model, definition.models[query.model], columnName, ref.path);
-    }
-  }
-  return null;
-}
-var COMPARISON_KEYS = ["eq", "neq", "gt", "gte", "lt", "lte"];
-function visibleConditionIssues(value, path) {
-  if (typeof value === "boolean")
-    return [];
-  if (!isPlainObject(value)) {
-    return [issue(path, "visible must be a boolean, a { $state } binding, or a condition object")];
-  }
-  for (const logical of ["$and", "$or"]) {
-    if (!Object.hasOwn(value, logical))
-      continue;
-    const children = value[logical];
-    if (!Array.isArray(children)) {
-      return [issue(appendPath(path, logical), "must be an array of conditions")];
-    }
-    return children.flatMap((child, index) => visibleConditionIssues(child, appendPath(appendPath(path, logical), index)));
-  }
-  if (typeof value.$state !== "string") {
-    return [
-      issue(path, 'a visible condition must bind "$state" (or combine conditions with "$and"/"$or") — a wrapper like {"not": {…}} is not evaluated by the renderer')
-    ];
-  }
-  const found = [];
-  const comparisons = COMPARISON_KEYS.filter((key) => value[key] !== undefined);
-  if (comparisons.length > 1) {
-    found.push(issue(path, `use exactly one comparison key per condition (found ${comparisons.join(", ")}); combine conditions with "$and"/"$or"`));
-  }
-  if (Object.hasOwn(value, "not") && value.not !== true) {
-    found.push(issue(appendPath(path, "not"), '"not" is a negation flag and must be exactly true (e.g. { "$state": "/queries/q/data/0/id", "not": true } shows the element when the value is absent/falsy)'));
-  }
-  return found;
-}
-function collectStateRefs(value, path, refs) {
-  if (isStateBinding(value) || isStateCondition(value)) {
-    refs.push({ path, value: value.$state });
-  }
-  if (Array.isArray(value)) {
-    for (const [index, child] of value.entries()) {
-      collectStateRefs(child, appendPath(path, index), refs);
-    }
-    return;
-  }
-  if (!isPlainObject(value))
-    return;
-  for (const [key, child] of Object.entries(value)) {
-    if (key !== "$state")
-      collectStateRefs(child, appendPath(path, key), refs);
-  }
-}
-function queryModelFromDataBinding(definition, value) {
-  if (!isStateBinding(value))
-    return null;
-  const match = /^\/queries\/([^/]+)\/data(?:\/\d+)?$/.exec(value.$state);
-  if (!match)
-    return null;
-  const queryName = match[1];
-  const query = Object.hasOwn(definition.queries ?? {}, queryName) ? definition.queries?.[queryName] : undefined;
-  if (!query || !Object.hasOwn(definition.models, query.model))
-    return null;
-  return { modelName: query.model, model: definition.models[query.model] };
-}
-function fieldBindingIssue(modelName, model, columnName, path, allowSystemField = true) {
-  if (columnName === "")
-    return null;
-  const column = Object.hasOwn(model.columns, columnName) ? model.columns[columnName] : undefined;
-  if (column && column.hidden !== true)
-    return null;
-  if (allowSystemField && Object.hasOwn(SYSTEM_COLUMN_KINDS, columnName))
-    return null;
-  return issue(path, `unknown or hidden column "${columnName}" on model "${modelName}"`);
-}
-function collectRowFieldIssues(value, path, modelName, model, issues) {
-  if (isPlainObject(value) && typeof value.$row === "string") {
-    const found = fieldBindingIssue(modelName, model, value.$row, appendPath(path, "$row"));
-    if (found)
-      issues.push(found);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const [index, child] of value.entries()) {
-      collectRowFieldIssues(child, appendPath(path, index), modelName, model, issues);
-    }
-    return;
-  }
-  if (!isPlainObject(value))
-    return;
-  for (const [key, child] of Object.entries(value)) {
-    collectRowFieldIssues(child, appendPath(path, key), modelName, model, issues);
-  }
-}
-function literalMutateModel(definition, chain) {
-  if (!Array.isArray(chain))
-    return null;
-  const names = new Set;
-  for (const step of chain) {
-    if (isPlainObject(step) && step.action === "app.mutate" && isPlainObject(step.params) && typeof step.params.model === "string") {
-      names.add(step.params.model);
-    }
-  }
-  if (names.size !== 1)
-    return null;
-  const modelName = [...names][0];
-  return Object.hasOwn(definition.models, modelName) ? { modelName, model: definition.models[modelName] } : null;
-}
-function visitActionChain(chain, path, visit, allowSingle) {
-  const normalized = allowSingle && isPlainObject(chain) ? [chain] : chain;
-  if (!Array.isArray(normalized))
-    return;
-  for (const [index, step] of normalized.entries()) {
-    if (isPlainObject(step))
-      visit(step, appendPath(path, index));
-  }
-}
-function visitPageActionSteps(page, pagePath, visit) {
-  if (!isPlainObject(page.elements))
-    return;
-  for (const [elementId, rawElement] of Object.entries(page.elements)) {
-    if (!isPlainObject(rawElement))
-      continue;
-    const elementPath = `${pagePath}.elements.${elementId}`;
-    for (const key of ["on", "watch"]) {
-      const actionMap = rawElement[key];
-      if (!isPlainObject(actionMap))
-        continue;
-      for (const [event, chain] of Object.entries(actionMap)) {
-        visitActionChain(chain, `${elementPath}.${key}.${event}`, visit, true);
-      }
-    }
-    if (!isPlainObject(rawElement.props))
-      continue;
-    if (rawElement.type === "Table" && Array.isArray(rawElement.props.rowActions)) {
-      for (const [index, rowAction] of rawElement.props.rowActions.entries()) {
-        if (!isPlainObject(rowAction))
-          continue;
-        visitActionChain(rowAction.actions, `${elementPath}.props.rowActions.${index}.actions`, visit, false);
-      }
-    }
-    if (rawElement.type === "Form") {
-      visitActionChain(rawElement.props.onSubmit, `${elementPath}.props.onSubmit`, visit, false);
-    }
-  }
-}
-function crossPageDefinitionIssues(definition, catalog) {
-  const issues = [];
-  if (!Object.hasOwn(definition.pages, definition.defaultPage)) {
-    issues.push(issue("defaultPage", `default page "${definition.defaultPage}" not found`));
-  }
-  for (const [pageName, page] of Object.entries(definition.pages)) {
-    const pagePath = appendPath("pages", pageName);
-    const declaredParams = page.params ?? {};
-    visitPageActionSteps(page, pagePath, (step, path) => {
-      const result = actionParams(step, path, definition, catalog, true);
-      issues.push(...result.issues);
-    });
-    if (!isPlainObject(page.elements))
-      continue;
-    for (const [elementId, rawElement] of Object.entries(page.elements)) {
-      if (!isPlainObject(rawElement))
-        continue;
-      const elementPath = `${pagePath}.elements.${elementId}`;
-      if (rawElement.type === "Drawer" && isPlainObject(rawElement.props)) {
-        const paramPath = `${elementPath}.props.param`;
-        if (Object.hasOwn(rawElement.props, "param") && typeof rawElement.props.param !== "string") {
-          issues.push(issue(paramPath, "Drawer param must be a literal route param name (not a binding)"));
-        } else if (typeof rawElement.props.param === "string" && !Object.hasOwn(declaredParams, rawElement.props.param)) {
-          issues.push(issue(paramPath, `param "${rawElement.props.param}" is not declared on page "${pageName}"`));
-        }
-      }
-    }
-    const refs = [];
-    collectStateRefs(page, pagePath, refs);
-    for (const ref of refs) {
-      const queryMatch = /^\/queries\/([^/]+)(?:\/.*)?$/.exec(ref.value);
-      if (!queryMatch)
-        continue;
-      const queryName = queryMatch[1];
-      const query = definition.queries?.[queryName];
-      if (!query)
-        continue;
-      for (const value of Object.values(query.filter ?? {})) {
-        if (!isParamBinding(value) || Object.hasOwn(declaredParams, value.$param))
-          continue;
-        issues.push(issue(ref.path, `query "${queryName}" requires undeclared page param "${value.$param}"`));
-      }
-    }
-  }
-  return dedupeIssues(issues);
-}
-var MAX_ELEMENT_REF_DEPTH = 5;
-var MAX_ELEMENT_REF_EXPANSION_WORK = 100;
-var MAX_ELEMENT_REF_EXPANSION_ISSUES = 100;
-function collectElementRefs(elements, elementsPath) {
-  const refs = [];
-  for (const [elementId, rawElement] of Object.entries(elements)) {
-    if (!isPlainObject(rawElement) || rawElement.type !== "ElementRef")
-      continue;
-    refs.push({ path: appendPath(elementsPath, elementId), node: rawElement });
-  }
-  return refs;
-}
-function reusableElementHasSlot(element) {
-  return Object.values(element.elements).some((node) => isPlainObject(node) && node.type === "ElementSlot");
-}
-function isElementPropBinding(value) {
-  return isStateBinding(value) || isRepeatBinding(value);
-}
-function elementPropAccepts(prop, value) {
-  if (isElementPropBinding(value))
-    return true;
-  if (prop.kind === "string")
-    return typeof value === "string";
-  if (prop.kind === "enum") {
-    return typeof value === "string" && Boolean(prop.enum?.includes(value));
-  }
-  if (prop.kind === "number")
-    return typeof value === "number" && Number.isFinite(value);
-  if (prop.kind === "boolean")
-    return typeof value === "boolean";
-  return typeof value === "string" && isIso8601Date(value);
-}
-async function elementReferenceIssues(definition, context) {
-  const issues = [];
-  const rootAppId = context.currentAppId ?? "$self";
-  const cleanTargetDepths = new Map;
-  let expansionWork = 0;
-  let expansionIssueCount = 0;
-  let expansionStopped = false;
-  const stopExpansion = (path) => {
-    if (expansionStopped)
-      return;
-    expansionStopped = true;
-    issues.push(issue(path, "element reference expansion exceeded budget — simplify the reference graph"));
-  };
-  const pushExpansionIssue = (found) => {
-    if (expansionStopped)
-      return;
-    if (expansionIssueCount >= MAX_ELEMENT_REF_EXPANSION_ISSUES) {
-      stopExpansion(found.path);
-      return;
-    }
-    expansionIssueCount += 1;
-    issues.push(found);
-  };
-  const consumeExpansionWork = (path) => {
-    if (expansionStopped)
-      return false;
-    if (expansionWork >= MAX_ELEMENT_REF_EXPANSION_WORK) {
-      stopExpansion(path);
-      return false;
-    }
-    expansionWork += 1;
-    return true;
-  };
-  const resolvedApps = new Map;
-  const resolveTarget = async (appId) => {
-    if (appId === rootAppId)
-      return { appId, definition };
-    if (resolvedApps.has(appId))
-      return resolvedApps.get(appId);
-    const resolved = await context.resolveApp?.(appId);
-    const target = resolved ? {
-      appId,
-      name: resolved.name,
-      definition: resolved.definition,
-      unparseable: resolved.definitionError !== undefined
-    } : null;
-    resolvedApps.set(appId, target);
-    return target;
-  };
-  const describeTargetApp = (target) => target.appId === rootAppId && !target.name ? "this app" : `app "${target.name ?? target.appId}"`;
-  const validateReference = async (ref, ownerDefinition, ownerAppId, depth, stack) => {
-    if (expansionStopped)
-      return false;
-    if (!isPlainObject(ref.node.props))
-      return false;
-    let referenceClean = true;
-    const elementName = ref.node.props.element;
-    if (typeof elementName !== "string") {
-      pushExpansionIssue(issue(appendPath(ref.path, "props.element"), "element and app must be literal strings — dynamic references are not supported"));
-      return false;
-    }
-    const explicitAppId = ref.node.props.app;
-    if (explicitAppId !== undefined && typeof explicitAppId !== "string") {
-      pushExpansionIssue(issue(appendPath(ref.path, "props.app"), "element and app must be literal strings — dynamic references are not supported"));
-      return false;
-    }
-    const targetAppId = explicitAppId ?? ownerAppId;
-    if (depth > MAX_ELEMENT_REF_DEPTH) {
-      pushExpansionIssue(issue(appendPath(ref.path, "props.element"), `element reference expansion exceeds the maximum depth of ${MAX_ELEMENT_REF_DEPTH}`));
-      return false;
-    }
-    const targetApp = targetAppId === ownerAppId ? { appId: ownerAppId, definition: ownerDefinition } : await resolveTarget(targetAppId);
-    if (!targetApp) {
-      if (context.skipExternalTargetResolution && targetAppId !== ownerAppId)
-        return true;
-      pushExpansionIssue(issue(appendPath(ref.path, "props.app"), `referenced app "${targetAppId}" not found`));
-      return false;
-    }
-    if (targetApp.unparseable) {
-      pushExpansionIssue(issue(appendPath(ref.path, "props.app"), `referenced app "${targetApp.name ?? targetAppId}" has an invalid definition and cannot supply elements`));
-      return false;
-    }
-    const target = targetApp.definition.elements?.[elementName];
-    if (!target) {
-      const targetLocation = targetAppId === rootAppId ? "" : ` in ${describeTargetApp(targetApp)}`;
-      pushExpansionIssue(issue(appendPath(ref.path, "props.element"), `element "${elementName}" not found${targetLocation}`));
-      return false;
-    }
-    if (targetAppId !== ownerAppId && target.export !== true) {
-      referenceClean = false;
-      pushExpansionIssue(issue(appendPath(ref.path, "props.element"), `element "${elementName}" in ${describeTargetApp(targetApp)} is private; set export: true before referencing it from another app`));
-    }
-    const suppliedProps = isPlainObject(ref.node.props.props) ? ref.node.props.props : {};
-    const declaredProps = target.props ?? {};
-    for (const propName of Object.keys(suppliedProps)) {
-      const declared = declaredProps[propName];
-      if (!declared) {
-        referenceClean = false;
-        pushExpansionIssue(issue(`${ref.path}.props.props.${propName}`, `prop "${propName}" is not declared by element "${elementName}"`));
-      } else if (!elementPropAccepts(declared, suppliedProps[propName])) {
-        referenceClean = false;
-        pushExpansionIssue(issue(`${ref.path}.props.props.${propName}`, `prop "${propName}" must be a ${declared.kind} value or a binding`));
-      }
-    }
-    for (const [propName, declared] of Object.entries(declaredProps)) {
-      if (declared.required === true && declared.default === undefined && !Object.hasOwn(suppliedProps, propName)) {
-        referenceClean = false;
-        pushExpansionIssue(issue(`${ref.path}.props.props.${propName}`, `required prop "${propName}" is missing for element "${elementName}"`));
-      }
-    }
-    if (Array.isArray(ref.node.children) && ref.node.children.length > 0 && !reusableElementHasSlot(target)) {
-      referenceClean = false;
-      pushExpansionIssue(issue(appendPath(ref.path, "children"), `element "${elementName}" has no ElementSlot and cannot accept children`));
-    }
-    const targetKey = `${targetAppId}\x00${elementName}`;
-    if (stack.has(targetKey)) {
-      const targetLocation = targetAppId === rootAppId ? "" : ` in ${describeTargetApp(targetApp)}`;
-      pushExpansionIssue(issue(appendPath(ref.path, "props.element"), `recursive element reference cycle reaches "${elementName}"${targetLocation}`));
-      return false;
-    }
-    const cleanAtDepth = cleanTargetDepths.get(targetKey);
-    if (cleanAtDepth !== undefined && depth <= cleanAtDepth)
-      return referenceClean;
-    if (!consumeExpansionWork(appendPath(ref.path, "props.element")))
-      return false;
-    const nextStack = new Set(stack).add(targetKey);
-    let targetClean = true;
-    for (const nested of collectElementRefs(target.elements, `${ref.path}.target.${elementName}.elements`)) {
-      if (!await validateReference(nested, targetApp.definition, targetAppId, depth + 1, nextStack)) {
-        targetClean = false;
-      }
-      if (expansionStopped)
-        break;
-    }
-    if (targetClean && !expansionStopped) {
-      cleanTargetDepths.set(targetKey, Math.max(cleanAtDepth ?? 0, depth));
-    }
-    return referenceClean && targetClean;
-  };
-  for (const [pageName, page] of Object.entries(definition.pages)) {
-    if (expansionStopped)
-      break;
-    for (const ref of collectElementRefs(page.elements, `pages.${pageName}.elements`)) {
-      await validateReference(ref, definition, rootAppId, 1, new Set);
-      if (expansionStopped)
-        break;
-    }
-  }
-  for (const [elementName, element] of Object.entries(definition.elements ?? {})) {
-    if (expansionStopped)
-      break;
-    const stack = new Set([`${rootAppId}\x00${elementName}`]);
-    for (const ref of collectElementRefs(element.elements, `elements.${elementName}.elements`)) {
-      await validateReference(ref, definition, rootAppId, 1, stack);
-      if (expansionStopped)
-        break;
-    }
-  }
-  return issues;
-}
-async function elementDefinitionIssues(definition, catalog, context = {}) {
-  const issues = [];
-  for (const [elementName, element] of Object.entries(definition.elements ?? {})) {
-    const elementPath = `elements.${elementName}`;
-    issues.push(...validatePage(definition, catalog, {
-      tree: element,
-      path: elementPath,
-      elementMode: element.mode,
-      elementProps: element.props
-    }));
-    const slots = Object.entries(element.elements).filter(([, node]) => isPlainObject(node) && node.type === "ElementSlot");
-    if (element.mode === "pure" && slots.length > 1) {
-      for (const [slotId] of slots.slice(1)) {
-        issues.push(issue(`${elementPath}.elements.${slotId}`, "pure elements may contain at most one ElementSlot"));
-      }
-    }
-    visitPageActionSteps(element, elementPath, (step, path) => {
-      const navigation = actionParams(step, path, definition, catalog, true);
-      issues.push(...navigation.issues);
-      if (element.mode === "pure") {
-        issues.push(issue(appendPath(path, "action"), "pure elements cannot invoke actions — use a bound element"));
-      } else if (element.export === true && step.action === "app.navigate") {
-        issues.push(issue(appendPath(path, "action"), "exported bound elements cannot use app.navigate; keep navigation in the consuming app or make the element private"));
-      }
-    });
-  }
-  for (const referenceIssue of await elementReferenceIssues(definition, context)) {
-    issues.push(referenceIssue);
-  }
-  return dedupeIssues(issues);
-}
-function validatePage(definition, catalog, target) {
-  const issues = [];
-  const stateRefs = [];
-  const formIds = new Set;
-  const uiIds = new Set;
-  const pageName = typeof target === "string" ? target : undefined;
-  const options = typeof target === "string" ? undefined : target;
-  const page = options?.tree ?? definition.pages[pageName];
-  const pagePath = options?.path ?? appendPath("pages", pageName);
-  const pageParams = pageName ? definition.pages[pageName]?.params ?? {} : {};
-  const elementsPath = appendPath(pagePath, "elements");
-  const root = page.root;
-  const elements = page.elements;
-  if (typeof root !== "string")
-    issues.push(issue(appendPath(pagePath, "root"), "must be a string"));
-  if (!isPlainObject(elements)) {
-    issues.push(issue(elementsPath, "must be a non-empty object"));
-    return issues;
-  }
-  const elementEntries = Object.entries(elements);
-  if (elementEntries.length === 0) {
-    issues.push(issue(elementsPath, "must be a non-empty object"));
-    return issues;
-  }
-  if (typeof root === "string" && !Object.hasOwn(elements, root)) {
-    issues.push(issue(appendPath(pagePath, "root"), `root element "${root}" not found`));
-  }
-  for (const [elementId, rawElement] of elementEntries) {
-    const elementPath = appendPath(elementsPath, elementId);
-    if (!isPlainObject(rawElement)) {
-      issues.push(issue(elementPath, "must be an element object"));
-      continue;
-    }
-    for (const key of Object.keys(rawElement)) {
-      if (!ELEMENT_KEYS.has(key))
-        issues.push(issue(appendPath(elementPath, key), "unknown element key"));
-    }
-    const type = rawElement.type;
-    const component = typeof type === "string" ? catalog.components[type] : undefined;
-    if (typeof type !== "string") {
-      issues.push(issue(appendPath(elementPath, "type"), "must be a string"));
-    } else if (!catalog.componentTypes.includes(type) || !component) {
-      issues.push(issue(appendPath(elementPath, "type"), `unknown component type "${type}"`));
-    }
-    if (type === "ElementSlot") {
-      if (options?.elementMode !== "pure") {
-        issues.push(issue(appendPath(elementPath, "type"), "ElementSlot is only allowed inside a pure reusable element"));
-      }
-      if (Object.hasOwn(rawElement, "children") && (!Array.isArray(rawElement.children) || rawElement.children.length > 0)) {
-        issues.push(issue(appendPath(elementPath, "children"), "ElementSlot must be a leaf"));
-      }
-    }
-    if (component) {
-      const propsPath = appendPath(elementPath, "props");
-      const actionChainPath = (path) => type === "Form" && path === `${propsPath}.onSubmit` || type === "Table" && /^.+\.rowActions\.\d+\.actions$/.test(path);
-      const propsResult = validateSchema(Object.hasOwn(rawElement, "props") ? rawElement.props : {}, component.props, propsPath, false, actionChainPath);
-      issues.push(...propsResult.issues);
-      stateRefs.push(...propsResult.stateRefs);
-      if (type === "Form" && isPlainObject(rawElement.props) && typeof rawElement.props.id === "string") {
-        formIds.add(rawElement.props.id);
-      }
-      if (typeof type === "string" && UI_STATE_COMPONENTS.has(type) && isPlainObject(rawElement.props) && typeof rawElement.props.id === "string") {
-        uiIds.add(rawElement.props.id);
-      }
-    } else if (!Object.hasOwn(rawElement, "props")) {
-      issues.push(issue(appendPath(elementPath, "props"), "is required"));
-    }
-    if (isPlainObject(rawElement.props)) {
-      if (typeof rawElement.props.busyWith === "string" && !Object.hasOwn(definition.actions ?? {}, rawElement.props.busyWith)) {
-        issues.push(issue(`${elementPath}.props.busyWith`, `unknown app action "${rawElement.props.busyWith}"`));
-      }
-      if (type === "Table") {
-        const queryModel = queryModelFromDataBinding(definition, rawElement.props.data);
-        if (queryModel) {
-          if (Array.isArray(rawElement.props.columns)) {
-            for (const [index, field] of rawElement.props.columns.entries()) {
-              if (!isPlainObject(field) || typeof field.key !== "string")
-                continue;
-              const found = fieldBindingIssue(queryModel.modelName, queryModel.model, field.key, `${elementPath}.props.columns.${index}.key`);
-              if (found)
-                issues.push(found);
-            }
-          }
-          if (isPlainObject(rawElement.props.filters) && !isStateBinding(rawElement.props.filters)) {
-            for (const columnName of Object.keys(rawElement.props.filters)) {
-              const found = fieldBindingIssue(queryModel.modelName, queryModel.model, columnName, `${elementPath}.props.filters.${columnName}`);
-              if (found)
-                issues.push(found);
-            }
-          }
-          collectRowFieldIssues(rawElement.props.rowActions, `${elementPath}.props.rowActions`, queryModel.modelName, queryModel.model, issues);
-        }
-      } else if (type === "DetailList") {
-        const queryModel = queryModelFromDataBinding(definition, rawElement.props.data);
-        if (queryModel && Array.isArray(rawElement.props.fields)) {
-          for (const [index, field] of rawElement.props.fields.entries()) {
-            if (!isPlainObject(field) || typeof field.key !== "string")
-              continue;
-            const found = fieldBindingIssue(queryModel.modelName, queryModel.model, field.key, `${elementPath}.props.fields.${index}.key`);
-            if (found)
-              issues.push(found);
-          }
-        }
-      } else if (type === "Form") {
-        if (Array.isArray(rawElement.props.fields)) {
-          for (const [index, field] of rawElement.props.fields.entries()) {
-            if (!isPlainObject(field) || typeof field.name !== "string")
-              continue;
-            if (field.name.startsWith("$")) {
-              issues.push(issue(`${elementPath}.props.fields.${index}.name`, "field names must not start with '$' (reserved form slots)"));
-            }
-          }
-        }
-        const mutateModel = literalMutateModel(definition, rawElement.props.onSubmit);
-        if (mutateModel && Array.isArray(rawElement.props.fields)) {
-          for (const [index, field] of rawElement.props.fields.entries()) {
-            if (!isPlainObject(field) || typeof field.name !== "string")
-              continue;
-            const found = fieldBindingIssue(mutateModel.modelName, mutateModel.model, field.name, `${elementPath}.props.fields.${index}.name`, false);
-            if (found)
-              issues.push(found);
-          }
-        }
-      }
-    }
-    if (Object.hasOwn(rawElement, "children") && type !== "ElementSlot") {
-      if (!Array.isArray(rawElement.children)) {
-        issues.push(issue(appendPath(elementPath, "children"), "must be an array of element ids"));
-      } else {
-        for (const [index, child] of rawElement.children.entries()) {
-          if (typeof child !== "string") {
-            issues.push(issue(appendPath(appendPath(elementPath, "children"), index), "must be a string"));
-          }
-        }
-      }
-      if (component && !component.slots) {
-        issues.push(issue(appendPath(elementPath, "children"), `component "${type}" does not accept children`));
-      }
-    }
-    if (Object.hasOwn(rawElement, "on")) {
-      const onResult = validateActionMap(rawElement.on, appendPath(elementPath, "on"), definition, catalog, true);
-      issues.push(...onResult.issues);
-      stateRefs.push(...onResult.stateRefs);
-    }
-    if (Object.hasOwn(rawElement, "watch")) {
-      const watchResult = validateActionMap(rawElement.watch, appendPath(elementPath, "watch"), definition, catalog, true);
-      issues.push(...watchResult.issues);
-      stateRefs.push(...watchResult.stateRefs);
-    }
-    for (const key of ["visible", "repeat"]) {
-      if (!Object.hasOwn(rawElement, key))
-        continue;
-      const bindingPath = appendPath(elementPath, key);
-      const bindingResult = validateSchema(rawElement[key], {}, bindingPath, false);
-      issues.push(...bindingResult.issues);
-      stateRefs.push(...bindingResult.stateRefs);
-      if (key === "visible") {
-        collectStateRefs(rawElement[key], bindingPath, stateRefs);
-        issues.push(...visibleConditionIssues(rawElement[key], bindingPath));
-      }
-    }
-    if (type === "Table" && isPlainObject(rawElement.props) && Array.isArray(rawElement.props.rowActions)) {
-      for (const [rowActionIndex, rowAction] of rawElement.props.rowActions.entries()) {
-        if (!isPlainObject(rowAction) || !Object.hasOwn(rowAction, "actions"))
-          continue;
-        const chainResult = validateActionChain(rowAction.actions, `${elementPath}.props.rowActions.${rowActionIndex}.actions`, definition, catalog);
-        issues.push(...chainResult.issues);
-        stateRefs.push(...chainResult.stateRefs);
-      }
-    }
-    if (type === "Form" && isPlainObject(rawElement.props) && Object.hasOwn(rawElement.props, "onSubmit")) {
-      const chainResult = validateActionChain(rawElement.props.onSubmit, `${elementPath}.props.onSubmit`, definition, catalog);
-      issues.push(...chainResult.issues);
-      stateRefs.push(...chainResult.stateRefs);
-    }
-  }
-  const parentByChild = new Map;
-  for (const [elementId, rawElement] of elementEntries) {
-    if (!isPlainObject(rawElement) || !Array.isArray(rawElement.children))
-      continue;
-    for (const [index, child] of rawElement.children.entries()) {
-      if (typeof child !== "string")
-        continue;
-      const childPath = `${elementsPath}.${elementId}.children.${index}`;
-      if (!Object.hasOwn(elements, child)) {
-        issues.push(issue(childPath, `child element "${child}" not found`));
-        continue;
-      }
-      const previousParent = parentByChild.get(child);
-      if (previousParent && previousParent !== elementId) {
-        issues.push(issue(childPath, `element "${child}" is already a child of "${previousParent}"`));
-      } else {
-        parentByChild.set(child, elementId);
-      }
-    }
-  }
-  if (options?.elementMode) {
-    for (const [elementId, rawElement] of elementEntries) {
-      if (!isPlainObject(rawElement))
-        continue;
-      const repeatBindingPaths = [];
-      collectRepeatBindingPaths(rawElement, `${elementsPath}.${elementId}`, repeatBindingPaths);
-      if (repeatBindingPaths.length === 0)
-        continue;
-      let repeatedScope = Object.hasOwn(rawElement, "repeat");
-      let parentId = parentByChild.get(elementId);
-      const visitedParents = new Set;
-      while (!repeatedScope && parentId && !visitedParents.has(parentId)) {
-        visitedParents.add(parentId);
-        const parent = elements[parentId];
-        repeatedScope = isPlainObject(parent) && Object.hasOwn(parent, "repeat");
-        parentId = parentByChild.get(parentId);
-      }
-      if (!repeatedScope) {
-        for (const bindingPath of repeatBindingPaths) {
-          issues.push(issue(bindingPath, "$item and $index bindings are only allowed inside a repeated element"));
-        }
-      }
-    }
-  }
-  const visited = new Set;
-  const visiting = new Set;
-  const visit = (elementId) => {
-    if (visited.has(elementId))
-      return;
-    visiting.add(elementId);
-    const rawElement = elements[elementId];
-    if (isPlainObject(rawElement) && Array.isArray(rawElement.children)) {
-      for (const [index, child] of rawElement.children.entries()) {
-        if (typeof child !== "string" || !Object.hasOwn(elements, child))
-          continue;
-        if (visiting.has(child)) {
-          issues.push(issue(`${elementsPath}.${elementId}.children.${index}`, `cycle references element "${child}"`));
-          continue;
-        }
-        visit(child);
-      }
-    }
-    visiting.delete(elementId);
-    visited.add(elementId);
-  };
-  for (const elementId of Object.keys(elements))
-    visit(elementId);
-  const reachable = new Set;
-  const markReachable = (elementId) => {
-    if (reachable.has(elementId) || !Object.hasOwn(elements, elementId))
-      return;
-    reachable.add(elementId);
-    const rawElement = elements[elementId];
-    if (!isPlainObject(rawElement) || !Array.isArray(rawElement.children))
-      return;
-    for (const child of rawElement.children) {
-      if (typeof child === "string")
-        markReachable(child);
-    }
-  };
-  if (typeof root === "string")
-    markReachable(root);
-  for (const elementId of Object.keys(elements)) {
-    if (!reachable.has(elementId)) {
-      issues.push(issue(`${elementsPath}.${elementId}`, "element is not reachable from root"));
-    }
-  }
-  for (const ref of stateRefs) {
-    const propMatch = /^\/props\/([^/]+)(?:\/.*)?$/.exec(ref.value);
-    const userConfigRef = ref.value === "/user" || ref.value.startsWith("/user/");
-    let stateIssue;
-    if (options?.elementMode && userConfigRef) {
-      stateIssue = issue(ref.path, `${options.elementMode} elements cannot read /user state; read userConfig via a prop or bind it at page level`);
-    } else if (options?.elementMode && propMatch) {
-      stateIssue = Object.hasOwn(options.elementProps ?? {}, propMatch[1]) ? null : issue(ref.path, `state reference targets unknown element prop "${propMatch[1]}"`);
-    } else if (options?.elementMode === "pure") {
-      stateIssue = issue(ref.path, `pure element state reference "${ref.value}" escapes /props/<declared>; use a declared prop or switch the element to bound mode`);
-    } else {
-      stateIssue = validateStateRef(ref, definition, formIds, uiIds, pageParams);
-    }
-    if (stateIssue)
-      issues.push(stateIssue);
-  }
-  return dedupeIssues(issues);
-}
-
-// src/apps/sync-run-as.ts
-init_db();
-async function resolveSyncRunAs(script) {
-  return getSavedScriptOwnerAgentId(script) ?? (await getLeadAgent())?.id ?? "app-sync";
-}
-
-// src/apps/definition.ts
-var AppNameSchema = string().regex(/^[a-z][a-zA-Z0-9_]{0,39}$/, {
-  message: "must start with a lowercase letter and contain only letters, numbers, or underscores"
-});
-var ColumnKindSchema = _enum(["string", "number", "boolean", "date", "enum"]);
-var ISO_8601_PREFIX = /^\d{4}-\d{2}-\d{2}(?:T.*)?$/;
-function isIso8601Date(value) {
-  return ISO_8601_PREFIX.test(value) && !Number.isNaN(Date.parse(value));
-}
-var SourceTransformSchema = _enum(["slug", "lower", "upper", "cents", "date-parse"]);
-var TRANSFORM_COLUMN_KIND = {
-  slug: "string",
-  lower: "string",
-  upper: "string",
-  cents: "number",
-  "date-parse": "date"
-};
-var ColumnSourceBindingSchema = object({
-  of: AppNameSchema,
-  field: string().min(1),
-  transform: SourceTransformSchema.optional()
-}).strict();
-var ColumnDefSchema = object({
-  kind: ColumnKindSchema,
-  required: boolean().optional(),
-  enum: array(string()).optional(),
-  index: boolean().optional(),
-  default: union([string(), number(), boolean()]).optional(),
-  hidden: boolean().optional(),
-  source: ColumnSourceBindingSchema.optional()
-}).superRefine((column, ctx) => {
-  if (column.kind === "enum") {
-    if (!column.enum || column.enum.length === 0) {
-      ctx.addIssue({ code: "custom", path: ["enum"], message: "enum values are required" });
-    } else if (column.enum.some((value) => value.length === 0)) {
-      ctx.addIssue({ code: "custom", path: ["enum"], message: "enum values must be non-empty" });
-    } else if (new Set(column.enum).size !== column.enum.length) {
-      ctx.addIssue({ code: "custom", path: ["enum"], message: "enum values must be unique" });
-    }
-  } else if (column.enum !== undefined) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["enum"],
-      message: "enum values are only allowed for enum columns"
-    });
-  }
-  if (column.default === undefined)
-    return;
-  const valid = column.kind === "string" && typeof column.default === "string" || column.kind === "number" && typeof column.default === "number" && Number.isFinite(column.default) || column.kind === "boolean" && typeof column.default === "boolean" || column.kind === "date" && typeof column.default === "string" && isIso8601Date(column.default) || column.kind === "enum" && typeof column.default === "string" && Boolean(column.enum?.includes(column.default));
-  if (!valid) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["default"],
-      message: `default must be a valid ${column.kind} value`
-    });
-  }
-});
-var UserConfigFieldSchema = object({
-  kind: ColumnKindSchema,
-  default: union([string(), number(), boolean()]).optional(),
-  enum: array(string()).optional(),
-  label: string().optional(),
-  required: never().optional()
-}).strict().superRefine((field, ctx) => {
-  if (field.kind === "enum") {
-    if (!field.enum || field.enum.length === 0) {
-      ctx.addIssue({ code: "custom", path: ["enum"], message: "enum values are required" });
-    } else if (field.enum.some((value) => value.length === 0)) {
-      ctx.addIssue({ code: "custom", path: ["enum"], message: "enum values must be non-empty" });
-    } else if (new Set(field.enum).size !== field.enum.length) {
-      ctx.addIssue({ code: "custom", path: ["enum"], message: "enum values must be unique" });
-    }
-  } else if (field.enum !== undefined) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["enum"],
-      message: "enum values are only allowed for enum fields"
-    });
-  }
-  if (field.default === undefined)
-    return;
-  const valid = field.kind === "string" && typeof field.default === "string" || field.kind === "number" && typeof field.default === "number" && Number.isFinite(field.default) || field.kind === "boolean" && typeof field.default === "boolean" || field.kind === "date" && typeof field.default === "string" && isIso8601Date(field.default) || field.kind === "enum" && typeof field.default === "string" && Boolean(field.enum?.includes(field.default));
-  if (!valid) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["default"],
-      message: `default must be a valid ${field.kind} value`
-    });
-  }
-});
-var UserConfigSchema = record(AppNameSchema, UserConfigFieldSchema);
-var SourceDefSchema = discriminatedUnion("connector", [
-  object({
-    connector: literal("script"),
-    scriptId: string().uuid(),
-    joinKey: AppNameSchema,
-    args: record(string(), unknown()).optional(),
-    connection: string().min(1).optional()
-  }).strict(),
-  object({
-    connector: literal("swarm-tasks"),
-    joinKey: AppNameSchema,
-    config: record(string(), union([string(), number(), boolean()])).optional()
-  }).strict()
-]);
-var ModelDefSchema = object({
-  columns: record(AppNameSchema, ColumnDefSchema),
-  sources: record(AppNameSchema, SourceDefSchema).optional()
-}).superRefine((model, ctx) => {
-  const count = Object.keys(model.columns).length;
-  if (count < 1 || count > 40) {
-    ctx.addIssue({ code: "custom", path: ["columns"], message: "must define 1 to 40 columns" });
-  }
-  for (const name of Object.keys(model.columns)) {
-    if (Object.hasOwn(SYSTEM_COLUMN_KINDS, name)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["columns", name],
-        message: "reserved column name"
-      });
-    }
-  }
-  if (Object.keys(model.sources ?? {}).length > 4) {
-    ctx.addIssue({ code: "custom", path: ["sources"], message: "must define at most 4 sources" });
-  }
-});
-var AppQueryParamRefSchema = object({
-  $param: AppNameSchema
-}).strict();
-var SYSTEM_COLUMN_KINDS = {
-  id: "string",
-  createdAt: "date",
-  updatedAt: "date",
-  createdBy: "string",
-  updatedBy: "string",
-  source: "string",
-  syncedAt: "date",
-  stale: "boolean"
-};
-var SORTABLE_SYSTEM_DATE_COLUMNS = new Set(["createdAt", "updatedAt", "syncedAt"]);
-var AppQueryDefSchema = object({
-  model: AppNameSchema,
-  filter: record(string(), union([string(), number(), boolean(), AppQueryParamRefSchema])).optional(),
-  sort: object({
-    column: string(),
-    dir: _enum(["asc", "desc"])
-  }).optional(),
-  limit: number().int().positive().max(1000).optional()
-});
-var AppActionDefSchema = discriminatedUnion("kind", [
-  object({
-    kind: literal("script"),
-    scriptId: string().uuid(),
-    args: record(string(), unknown()).optional()
-  }),
-  object({
-    kind: literal("task"),
-    prompt: string().min(1),
-    agentId: string().min(1).optional()
-  }),
-  object({
-    kind: literal("sync"),
-    model: AppNameSchema.optional(),
-    source: AppNameSchema.optional()
-  })
-]);
-var AppPageParamSchema = object({
-  kind: _enum(["string", "number", "boolean"]).optional(),
-  required: boolean().optional()
-}).strict();
-var RESERVED_PAGE_PARAM_NAMES = new Set(["mode", "apiUrl", "apiKey", "email", "name"]);
-var AppPageSchema = object({
-  root: string(),
-  elements: record(string(), unknown()),
-  title: string().optional(),
-  params: record(AppNameSchema, AppPageParamSchema).optional()
-}).strict();
-var ElementPropDefSchema = object({
-  kind: ColumnKindSchema,
-  required: boolean().optional(),
-  enum: array(string()).min(1).optional(),
-  default: union([string(), number(), boolean()]).optional()
-}).strict().superRefine((prop, ctx) => {
-  if (prop.kind === "enum") {
-    if (!prop.enum) {
-      ctx.addIssue({ code: "custom", path: ["enum"], message: "enum values are required" });
-    }
-  } else if (prop.enum !== undefined) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["enum"],
-      message: "enum values are only allowed for enum props"
-    });
-  }
-  if (prop.default === undefined)
-    return;
-  const valid = prop.kind === "string" && typeof prop.default === "string" || prop.kind === "number" && typeof prop.default === "number" && Number.isFinite(prop.default) || prop.kind === "boolean" && typeof prop.default === "boolean" || prop.kind === "date" && typeof prop.default === "string" && isIso8601Date(prop.default) || prop.kind === "enum" && typeof prop.default === "string" && Boolean(prop.enum?.includes(prop.default));
-  if (!valid) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["default"],
-      message: `default must be a valid ${prop.kind} value`
-    });
-  }
-});
-var AppElementSchema = object({
-  mode: _enum(["pure", "bound"]),
-  export: boolean().optional(),
-  props: record(AppNameSchema, ElementPropDefSchema).optional(),
-  root: string(),
-  elements: record(string(), unknown())
-}).strict().superRefine((element, ctx) => {
-  if (Object.keys(element.elements).length > 150) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["elements"],
-      message: "must contain at most 150 nodes"
-    });
-  }
-});
-var AppElementsSchema = record(AppNameSchema, AppElementSchema);
-var AppThemeIdSchema = string().regex(/^[a-z][a-z0-9-]{0,39}$/, {
-  message: "must be a lowercase slug (letters, digits, dashes)"
-});
-var AppDefinitionSchema = object({
-  models: record(AppNameSchema, ModelDefSchema),
-  queries: record(AppNameSchema, AppQueryDefSchema).optional(),
-  actions: record(AppNameSchema, AppActionDefSchema).optional(),
-  elements: AppElementsSchema.optional(),
-  userConfig: UserConfigSchema.optional(),
-  pages: record(AppNameSchema, AppPageSchema),
-  defaultPage: AppNameSchema,
-  theme: AppThemeIdSchema.optional()
-}).superRefine((definition, ctx) => {
-  if (!Object.hasOwn(definition.pages, definition.defaultPage)) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["defaultPage"],
-      message: `unknown page "${definition.defaultPage}"`
-    });
-  }
-  for (const [pageName, page] of Object.entries(definition.pages)) {
-    for (const paramName of Object.keys(page.params ?? {})) {
-      if (RESERVED_PAGE_PARAM_NAMES.has(paramName)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["pages", pageName, "params", paramName],
-          message: "reserved param name"
-        });
-      }
-    }
-  }
-  const modelCount = Object.keys(definition.models).length;
-  if (modelCount > 10) {
-    ctx.addIssue({ code: "custom", path: ["models"], message: "must define at most 10 models" });
-  }
-  const actionCount = Object.keys(definition.actions ?? {}).length;
-  if (actionCount > 20) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["actions"],
-      message: "must define at most 20 actions"
-    });
-  }
-  const userConfigCount = Object.keys(definition.userConfig ?? {}).length;
-  if (userConfigCount > 20) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["userConfig"],
-      message: "must define at most 20 fields"
-    });
-  }
-  const elementCount = Object.keys(definition.elements ?? {}).length;
-  if (elementCount > 20) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["elements"],
-      message: "must define at most 20 reusable elements"
-    });
-  }
-  for (const [queryName, query] of Object.entries(definition.queries ?? {})) {
-    if (!Object.hasOwn(definition.models, query.model)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["queries", queryName, "model"],
-        message: `unknown model "${query.model}"`
-      });
-      continue;
-    }
-    const model = definition.models[query.model];
-    for (const [column, value] of Object.entries(query.filter ?? {})) {
-      const columnDefinition = Object.hasOwn(model.columns, column) ? model.columns[column] : Object.hasOwn(SYSTEM_COLUMN_KINDS, column) ? { kind: SYSTEM_COLUMN_KINDS[column] } : undefined;
-      if (!columnDefinition || "hidden" in columnDefinition && columnDefinition.hidden === true) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["queries", queryName, "filter", column],
-          message: `unknown or hidden column "${column}"`
-        });
-        continue;
-      }
-      if (typeof value === "object")
-        continue;
-      const valid = columnDefinition.kind === "string" && typeof value === "string" || columnDefinition.kind === "number" && typeof value === "number" && Number.isFinite(value) || columnDefinition.kind === "boolean" && typeof value === "boolean" || columnDefinition.kind === "date" && typeof value === "string" && isIso8601Date(value) || columnDefinition.kind === "enum" && typeof value === "string" && Boolean(columnDefinition.enum?.includes(value));
-      if (!valid) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["queries", queryName, "filter", column],
-          message: `filter must be a valid ${columnDefinition.kind} value`
-        });
-      }
-    }
-    const sortColumn = query.sort?.column;
-    if (sortColumn && !SORTABLE_SYSTEM_DATE_COLUMNS.has(sortColumn) && (!Object.hasOwn(model.columns, sortColumn) || model.columns[sortColumn].hidden === true)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["queries", queryName, "sort", "column"],
-        message: `unknown or hidden column "${sortColumn}"`
-      });
-    }
-  }
-});
-var APP_DEFINITION_TOP_LEVEL_KEYS = new Set([
-  "models",
-  "queries",
-  "actions",
-  "elements",
-  "userConfig",
-  "pages",
-  "defaultPage",
-  "schemaVersion",
-  "theme"
-]);
-var TOP_LEVEL_KEY_SUGGESTIONS = {
-  element: "elements",
-  userconfig: "userConfig",
-  themes: "theme",
-  appearance: "theme",
-  styling: "theme"
-};
-function flattenIssue(issue2, prefix = []) {
-  const path = [...prefix, ...issue2.path];
-  if (issue2.code === "invalid_key" && issue2.issues.length > 0) {
-    return issue2.issues.flatMap((nestedIssue) => flattenIssue(nestedIssue, path));
-  }
-  return [{ path: path.join("."), message: issue2.message }];
-}
-function appDefinitionIssues(error) {
-  return error.issues.flatMap((issue2) => flattenIssue(issue2));
-}
-function collectScriptReferences(definition) {
-  const references = new Map;
-  const add = (scriptId, path) => {
-    if (typeof scriptId !== "string" || scriptId.length === 0)
-      return;
-    const paths = references.get(scriptId);
-    if (paths)
-      paths.push(path);
-    else
-      references.set(scriptId, [path]);
-  };
-  if (!isMergePatchObject(definition))
-    return references;
-  const actions = definition.actions;
-  if (isMergePatchObject(actions)) {
-    for (const [actionName, action] of Object.entries(actions)) {
-      if (isMergePatchObject(action))
-        add(action.scriptId, `actions.${actionName}`);
-    }
-  }
-  const models = definition.models;
-  if (isMergePatchObject(models)) {
-    for (const [modelName, model] of Object.entries(models)) {
-      if (!isMergePatchObject(model) || !isMergePatchObject(model.sources))
-        continue;
-      for (const [sourceName, source] of Object.entries(model.sources)) {
-        if (isMergePatchObject(source)) {
-          add(source.scriptId, `models.${modelName}.sources.${sourceName}`);
-        }
-      }
-    }
-  }
-  return references;
-}
-function foreignScriptForWriter(context, script) {
-  if (script.scope !== "agent")
-    return false;
-  if (context.writerIsUser === true)
-    return true;
-  if (!context.writerAgentId)
-    return false;
-  return getSavedScriptOwnerAgentId(script) !== context.writerAgentId;
-}
-function scriptRefKey(scriptId, args, connection) {
-  if (typeof scriptId !== "string" || scriptId.length === 0)
-    return null;
-  return JSON.stringify({ scriptId, args: args ?? null, connection: connection ?? null });
-}
-function collectScriptReferencePathMap(definition) {
-  const byPath = new Map;
-  if (!isMergePatchObject(definition))
-    return byPath;
-  const actions = definition.actions;
-  if (isMergePatchObject(actions)) {
-    for (const [actionName, action] of Object.entries(actions)) {
-      if (!isMergePatchObject(action))
-        continue;
-      const key = scriptRefKey(action.scriptId, action.args, undefined);
-      if (key)
-        byPath.set(`actions.${actionName}`, key);
-    }
-  }
-  const models = definition.models;
-  if (isMergePatchObject(models)) {
-    for (const [modelName, model] of Object.entries(models)) {
-      if (!isMergePatchObject(model) || !isMergePatchObject(model.sources))
-        continue;
-      for (const [sourceName, source] of Object.entries(model.sources)) {
-        if (!isMergePatchObject(source))
-          continue;
-        const key = scriptRefKey(source.scriptId, source.args, source.connection);
-        if (key)
-          byPath.set(`models.${modelName}.sources.${sourceName}`, key);
-      }
-    }
-  }
-  return byPath;
-}
-async function modelSourceIssues(modelName, model, context, grandfatheredScriptRefs) {
-  const issues = [];
-  const sources = model.sources ?? {};
-  const sourceNames = new Set(Object.keys(sources));
-  for (const [sourceName, source] of Object.entries(sources)) {
-    const path = `models.${modelName}.sources.${sourceName}`;
-    const joinColumn = Object.hasOwn(model.columns, source.joinKey) ? model.columns[source.joinKey] : undefined;
-    if (!joinColumn || joinColumn.hidden === true) {
-      issues.push({
-        path: `${path}.joinKey`,
-        message: `unknown or hidden column "${source.joinKey}"`
-      });
-    } else if (joinColumn.kind !== "string") {
-      issues.push({
-        path: `${path}.joinKey`,
-        message: `join key column "${source.joinKey}" must be a string column`
-      });
-    } else {
-      if (joinColumn.source) {
-        issues.push({
-          path: `${path}.joinKey`,
-          message: `join key column "${source.joinKey}" must not be bound to a source`
-        });
-      }
-      if (joinColumn.required === true) {
-        issues.push({
-          path: `${path}.joinKey`,
-          message: `join key column "${source.joinKey}" must not be required`
-        });
-      }
-      if (joinColumn.default !== undefined) {
-        issues.push({
-          path: `${path}.joinKey`,
-          message: `join key column "${source.joinKey}" must not declare a default`
-        });
-      }
-    }
-    if (source.connector !== "script")
-      continue;
-    const script = await getScriptById(source.scriptId);
-    if (!script) {
-      issues.push({ path: `${path}.scriptId`, message: `script "${source.scriptId}" not found` });
-      continue;
-    }
-    const runAs = await resolveSyncRunAs(script);
-    const grandfatheredRef = grandfatheredScriptRefs.get(path) === scriptRefKey(source.scriptId, source.args, source.connection);
-    if (foreignScriptForWriter(context, script) && !grandfatheredRef) {
-      issues.push({
-        path: `${path}.scriptId`,
-        message: `script "${source.scriptId}" is agent-scoped to another agent — reference a script you own or a global script`
-      });
-    } else if (script.scope !== "agent" && (context.writerIsUser === true || typeof context.writerAgentId === "string") && context.writerAgentId !== runAs && !grandfatheredRef) {
-      issues.push({
-        path: `${path}.scriptId`,
-        message: `script "${source.scriptId}" syncs with agent "${runAs}"'s credentials — only that agent or the operator may wire or alter this source`
-      });
-    }
-    if (source.connection !== undefined) {
-      const reachable = listScriptConnections({ agentId: runAs });
-      if (!reachable.some((connection) => connection.slug === source.connection)) {
-        issues.push({
-          path: `${path}.connection`,
-          message: `connection "${source.connection}" not found or disabled for the sync run-as identity`
-        });
-      }
-    }
-  }
-  for (const [columnName, column] of Object.entries(model.columns)) {
-    const path = `models.${modelName}.columns.${columnName}`;
-    if (!column.source) {
-      if (sourceNames.size > 0 && column.required === true && column.hidden !== true && column.default === undefined) {
-        issues.push({
-          path,
-          message: "required column on a model with sources must declare a default — sync-created rows cannot supply it"
-        });
-      }
-      continue;
-    }
-    if (!sourceNames.has(column.source.of)) {
-      issues.push({ path: `${path}.source.of`, message: `unknown source "${column.source.of}"` });
-    }
-    const transform = column.source.transform;
-    if (transform && TRANSFORM_COLUMN_KIND[transform] !== column.kind) {
-      issues.push({
-        path: `${path}.source.transform`,
-        message: `transform "${transform}" requires a ${TRANSFORM_COLUMN_KIND[transform]} column`
-      });
-    }
-    if (column.required === true) {
-      issues.push({
-        path: `${path}.required`,
-        message: "source-bound column must not be required"
-      });
-    }
-    if (column.default !== undefined) {
-      issues.push({
-        path: `${path}.default`,
-        message: "source-bound column must not declare a default"
-      });
-    }
-  }
-  return issues;
-}
-function syncActionIssues(name, action, models) {
-  if (action.model !== undefined && !Object.hasOwn(models, action.model)) {
-    return [{ path: `actions.${name}.model`, message: `unknown model "${action.model}"` }];
-  }
-  const candidates = action.model !== undefined ? [action.model] : Object.keys(models);
-  const pairs = candidates.flatMap((modelName) => Object.keys(models[modelName]?.sources ?? {}).filter((sourceName) => action.source === undefined || sourceName === action.source));
-  if (pairs.length > 0)
-    return [];
-  if (action.source !== undefined) {
-    return [
-      {
-        path: `actions.${name}.source`,
-        message: action.model !== undefined ? `unknown source "${action.source}" on model "${action.model}"` : `unknown source "${action.source}" — no model declares it`
-      }
-    ];
-  }
-  if (action.model !== undefined) {
-    return [
-      { path: `actions.${name}.model`, message: `model "${action.model}" declares no sources` }
-    ];
-  }
-  return [{ path: `actions.${name}`, message: "no model declares a source to sync" }];
-}
-async function parseAppDefinition(input, elementContext = {}) {
-  if (isMergePatchObject(input) && Object.hasOwn(input, "page")) {
-    return {
-      success: false,
-      issues: [
-        {
-          path: "page",
-          message: "legacy singular page is no longer supported — define pages plus defaultPage"
-        }
-      ]
-    };
-  }
-  if (isMergePatchObject(input)) {
-    const unknownKeys = Object.keys(input).filter((key) => !APP_DEFINITION_TOP_LEVEL_KEYS.has(key));
-    if (unknownKeys.length > 0) {
-      return {
-        success: false,
-        issues: unknownKeys.map((key) => ({
-          path: key,
-          message: `unknown top-level key "${key}"${TOP_LEVEL_KEY_SUGGESTIONS[key] ? ` — did you mean "${TOP_LEVEL_KEY_SUGGESTIONS[key]}"?` : ""}`
-        }))
-      };
-    }
-  }
-  const parsedInput = isMergePatchObject(input) ? { ...input } : input;
-  if (isMergePatchObject(parsedInput))
-    delete parsedInput.schemaVersion;
-  const parsed = AppDefinitionSchema.safeParse(parsedInput);
-  if (!parsed.success)
-    return { success: false, issues: appDefinitionIssues(parsed.error) };
-  const issues = [
-    ...Object.keys(parsed.data.pages).flatMap((pageName) => validatePage(parsed.data, catalog_generated_default, pageName)),
-    ...crossPageDefinitionIssues(parsed.data, catalog_generated_default),
-    ...await elementDefinitionIssues(parsed.data, catalog_generated_default, elementContext)
-  ];
-  const grandfatheredScriptRefs = collectScriptReferencePathMap(elementContext.existingDefinition);
-  for (const [modelName, model] of Object.entries(parsed.data.models)) {
-    issues.push(...await modelSourceIssues(modelName, model, elementContext, grandfatheredScriptRefs));
-  }
-  for (const [name, action] of Object.entries(parsed.data.actions ?? {})) {
-    if (action.kind === "sync") {
-      issues.push(...syncActionIssues(name, action, parsed.data.models));
-      continue;
-    }
-    if (action.kind !== "script")
-      continue;
-    const script = await getScriptById(action.scriptId);
-    if (!script) {
-      issues.push({
-        path: `actions.${name}.scriptId`,
-        message: `script "${action.scriptId}" not found`
-      });
-      continue;
-    }
-    if (foreignScriptForWriter(elementContext, script) && grandfatheredScriptRefs.get(`actions.${name}`) !== scriptRefKey(action.scriptId, action.args, undefined)) {
-      issues.push({
-        path: `actions.${name}.scriptId`,
-        message: `script "${action.scriptId}" is agent-scoped to another agent — reference a script you own or a global script`
-      });
-    }
-  }
-  if (issues.length > 0)
-    return { success: false, issues };
-  return { success: true, definition: parsed.data };
-}
-function isMergePatchObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function defineMergePatchValue(target, key, value) {
-  Object.defineProperty(target, key, {
-    value,
-    configurable: true,
-    enumerable: true,
-    writable: true
-  });
-}
-var DANGEROUS_PATCH_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-function dangerousPatchKeyIssues(value, path = []) {
-  if (!isMergePatchObject(value))
-    return [];
-  const issues = [];
-  for (const [key, child] of Object.entries(value)) {
-    const childPath = [...path, key];
-    if (DANGEROUS_PATCH_KEYS.has(key)) {
-      issues.push({
-        path: childPath.join("."),
-        message: `unsafe merge patch key "${key}" is not allowed`
-      });
-      continue;
-    }
-    issues.push(...dangerousPatchKeyIssues(child, childPath));
-  }
-  return issues;
-}
-function definitionPatchIssues(stored, patch) {
-  if (!isMergePatchObject(patch))
-    return [];
-  const issues = dangerousPatchKeyIssues(patch);
-  if (Object.hasOwn(patch, "page")) {
-    issues.push({
-      path: "page",
-      message: "definitions are normalized to the pages map — patch pages.<name> instead"
-    });
-  }
-  if (isMergePatchObject(patch.pages)) {
-    const effectiveDefaultPage = typeof patch.defaultPage === "string" ? patch.defaultPage : stored.defaultPage;
-    if (patch.pages[effectiveDefaultPage] === null) {
-      issues.push({
-        path: `pages.${effectiveDefaultPage}`,
-        message: "cannot delete the default page"
-      });
-    }
-  }
-  if (isMergePatchObject(patch.elements)) {
-    for (const [elementName, elementPatch] of Object.entries(patch.elements)) {
-      if (!isMergePatchObject(elementPatch))
-        continue;
-      const replacesWholeElement = Object.keys(elementPatch).some((key) => key !== "elements");
-      if (!replacesWholeElement || !isMergePatchObject(elementPatch.elements))
-        continue;
-      for (const [nodeId, nodePatch] of Object.entries(elementPatch.elements)) {
-        if (nodePatch !== null)
-          continue;
-        issues.push({
-          path: `elements.${elementName}.elements.${nodeId}`,
-          message: "null node in a full element replace — to delete a node use elements.<name>.elements.<id> = null"
-        });
-      }
-    }
-  }
-  return issues;
-}
-function withoutSchemaVersion(patch) {
-  if (!isMergePatchObject(patch))
-    return patch;
-  const normalized = { ...patch };
-  delete normalized.schemaVersion;
-  return normalized;
-}
-function applyMergePatch(target, patch, path) {
-  if (!isMergePatchObject(patch))
-    return patch;
-  const result = isMergePatchObject(target) ? { ...target } : {};
-  const entriesAreAtomic = path.length === 1 && path[0] === "actions" || path.length === 1 && path[0] === "elements" || path.length === 1 && path[0] === "userConfig" || path.length === 3 && path[0] === "models" && path[2] === "columns" || path.length === 3 && path[0] === "models" && path[2] === "sources" || path.length === 3 && path[0] === "elements" && path[2] === "elements" || path.length === 3 && path[0] === "pages" && (path[2] === "elements" || path[2] === "params");
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === null) {
-      delete result[key];
-      continue;
-    }
-    defineMergePatchValue(result, key, entriesAreAtomic && !(path.length === 1 && path[0] === "elements" && isMergePatchObject(value) && Object.keys(value).length === 1 && isMergePatchObject(value.elements)) ? value : applyMergePatch(result[key], value, [...path, key]));
-  }
-  return result;
-}
-function applyAppDefinitionPatch(stored, patch) {
-  const normalizedPatch = withoutSchemaVersion(patch);
-  const issues = definitionPatchIssues(stored, normalizedPatch);
-  if (issues.length > 0)
-    return { success: false, issues };
-  const merged = applyMergePatch(structuredClone(stored), normalizedPatch, []);
-  return { success: true, definition: structuredClone(merged) };
-}
-
-// src/apps/store.ts
-init_key();
-init_db();
-
-// src/apps/format-upgrades.ts
-var CURRENT_APP_SCHEMA_VERSION = 1;
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function upgradeFrom0(raw) {
-  const upgraded = { ...raw };
-  if (isRecord(upgraded.page) && !Object.hasOwn(upgraded, "pages")) {
-    upgraded.pages = { main: upgraded.page };
-    upgraded.defaultPage = "main";
-  }
-  delete upgraded.page;
-  if (isRecord(upgraded.models)) {
-    upgraded.models = Object.fromEntries(Object.entries(upgraded.models).map(([modelName, model]) => {
-      if (!isRecord(model))
-        return [modelName, model];
-      const upgradedModel = { ...model };
-      delete upgradedModel.sources;
-      if (isRecord(upgradedModel.columns)) {
-        upgradedModel.columns = Object.fromEntries(Object.entries(upgradedModel.columns).map(([columnName, column]) => {
-          if (!isRecord(column))
-            return [columnName, column];
-          const upgradedColumn = { ...column };
-          delete upgradedColumn.source;
-          return [columnName, upgradedColumn];
-        }));
-      }
-      return [modelName, upgradedModel];
-    }));
-  }
-  upgraded.schemaVersion = 1;
-  return upgraded;
-}
-var APP_FORMAT_UPGRADES = [{ from: 0, to: 1, upgrade: upgradeFrom0 }];
-function schemaVersionOf(raw) {
-  if (!isRecord(raw) || typeof raw.schemaVersion !== "number" || !Number.isInteger(raw.schemaVersion)) {
-    return 0;
-  }
-  return raw.schemaVersion;
-}
-function upgradeAppDefinition(raw) {
-  if (!isRecord(raw))
-    return raw;
-  let upgraded = raw;
-  let version = schemaVersionOf(upgraded);
-  while (version < CURRENT_APP_SCHEMA_VERSION) {
-    const next = APP_FORMAT_UPGRADES.find((upgrade) => upgrade.from === version);
-    if (!next)
-      break;
-    upgraded = next.upgrade(upgraded);
-    version = next.to;
-  }
-  return upgraded;
-}
-function stampAppDefinition(definition) {
-  return { ...definition, schemaVersion: CURRENT_APP_SCHEMA_VERSION };
-}
-
-// src/apps/store.ts
-function invalidJsonIssue(error) {
-  return {
-    path: "definition",
-    message: `invalid stored JSON${error instanceof Error ? `: ${error.message}` : ""}`
-  };
-}
-function decodeAppDefinition(raw) {
-  const upgraded = upgradeAppDefinition(raw);
-  const parsed = AppDefinitionSchema.safeParse(upgraded);
-  if (!parsed.success) {
-    return {
-      definition: raw,
-      definitionError: appDefinitionIssues(parsed.error)
-    };
-  }
-  return {
-    definition: {
-      ...parsed.data,
-      schemaVersion: CURRENT_APP_SCHEMA_VERSION
-    }
-  };
-}
-function decodeApp(row) {
-  let rawDefinition;
-  try {
-    rawDefinition = JSON.parse(row.definition);
-  } catch (error) {
-    return {
-      id: row.id,
-      name: row.name,
-      ...row.description === null ? {} : { description: row.description },
-      definition: row.definition,
-      definitionError: [invalidJsonIssue(error)],
-      createdAt: row.created_at,
-      updatedAt: row.updated_at
-    };
-  }
-  const decoded = decodeAppDefinition(rawDefinition);
-  return {
-    id: row.id,
-    name: row.name,
-    ...row.description === null ? {} : { description: row.description },
-    definition: decoded.definition,
-    ...decoded.definitionError ? { definitionError: decoded.definitionError } : {},
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  };
-}
-function appDefinitionNeedsRepair(app) {
-  return app.definitionError !== undefined;
-}
-function encodeDefinition(definition) {
-  return JSON.stringify(stampAppDefinition(definition));
-}
-function nextTimestamp(previous) {
-  const now = Date.now();
-  const previousMs = previous ? Date.parse(previous) : Number.NEGATIVE_INFINITY;
-  return new Date(Math.max(now, previousMs + 1)).toISOString();
-}
-async function createApp(input) {
-  const id = input.id ?? crypto.randomUUID();
-  const now = nextTimestamp();
-  const row = await getDbClient().get(`INSERT INTO apps (id, name, description, definition, created_at, updated_at, "key")
-     VALUES (?, ?, ?, ?, ?, ?, ?)
-     RETURNING id, name, description, definition, created_at, updated_at`, [
-    id,
-    input.name,
-    input.description ?? null,
-    encodeDefinition(input.definition),
-    now,
-    now,
-    defaultAssetKey("app", id)
-  ]);
-  if (!row)
-    throw new Error("Failed to create app");
-  return decodeApp(row);
-}
-async function getApp(id) {
-  const row = await getDbClient().get(`SELECT id, name, description, definition, created_at, updated_at FROM apps WHERE id = ?`, [id]);
-  return row ? decodeApp(row) : null;
-}
-async function listApps() {
-  const rows = await getDbClient().query(`SELECT id, name, description, definition, created_at, updated_at
-     FROM apps ORDER BY created_at DESC, id`);
-  return rows.map((row) => ({
-    id: row.id,
-    name: row.name,
-    ...row.description === null ? {} : { description: row.description },
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  }));
-}
-async function listAppRecords() {
-  const rows = await getDbClient().query(`SELECT id, name, description, definition, created_at, updated_at
-     FROM apps ORDER BY created_at ASC, id ASC`);
-  return rows.map(decodeApp);
-}
-async function updateApp(id, patch) {
-  const existing = await getApp(id);
-  if (!existing)
-    return null;
-  const updatedAt = nextTimestamp(existing.updatedAt);
-  const row = await getDbClient().get(`UPDATE apps
-     SET name = ?, description = ?, definition = ?, updated_at = ?
-     WHERE id = ?
-     RETURNING id, name, description, definition, created_at, updated_at`, [
-    patch.name ?? existing.name,
-    patch.description === undefined ? existing.description ?? null : patch.description,
-    encodeDefinition(patch.definition ?? existing.definition),
-    updatedAt,
-    id
-  ]);
-  return row ? decodeApp(row) : null;
-}
-async function deleteApp(id) {
-  return (await getDbClient().run("DELETE FROM apps WHERE id = ?", [id])).changes > 0;
-}
-
-export { getSavedScriptOwnerAgentId, runSavedScriptAsAgent, resolveSyncRunAs, AppNameSchema, ColumnKindSchema, isIso8601Date, SYSTEM_COLUMN_KINDS, SORTABLE_SYSTEM_DATE_COLUMNS, AppElementsSchema, AppDefinitionSchema, collectScriptReferences, parseAppDefinition, applyAppDefinitionPatch, upgradeAppDefinition, decodeAppDefinition, appDefinitionNeedsRepair, createApp, getApp, listApps, listAppRecords, updateApp, deleteApp };