import { z } from "zod"; import { VENDO_APP_FORMAT } from "./formats.js"; import type { AutomationId } from "./automation.js"; import { type AppId, type ApprovalId, type IsoDateTime, type Json } from "./ids.js"; /** * The seat's contents — what one entry of {@link AppDocument.components} holds. * * A bundle has exactly two origins and both live INSIDE the document, so * nothing is attached at open time by hash-matching a baseline the fork may * have drifted from. * * It is declared HERE, beside the field it types, for the same reason * `appDocumentSchema` is: core's own store conformance kit parses a stored app * row with that schema, and core may not reach up into `@vendoai/vendo/apps`. The * format door (`@vendoai/vendo/core/apps`) re-exports these names rather than * re-declaring them, so consumers still read one place. */ export interface ComponentBundle { source: string; /** Sub-modules the entry imports, keyed by the specifier that names them. */ modules?: Record; styles?: string; /** The rehearsal seed a preview renders with, spread onto the props. */ sampleProps?: Record; /** `"authored"` — a generated island. `"seeded"` — captured from a host * component the person forked. */ origin: "authored" | "seeded"; /** * What the JAIL needs to run a seeded entry: the import table the captured * source resolves against, and the module bodies it reaches. * * These travel in the bundle rather than being looked up per open, which is * the whole point of the seat holding its own contents. They used to be * hash-matched against the live host baseline at open time, so the moment the * host component changed the match failed and a seeded app rendered with no * imports, no styles and no sub-modules at all — silently. */ sourceImports?: Record; subSources?: Record; }>; /** Inert host stylesheet snapshots, in captured order. */ styleSheets?: Array<{ path: string; css: string; }>; } /** 01-core §9 */ export declare const componentBundleSchema: z.ZodObject<{ source: z.ZodString; modules: z.ZodOptional>; styles: z.ZodOptional; sampleProps: z.ZodOptional>; origin: z.ZodEnum<["authored", "seeded"]>; sourceImports: z.ZodOptional>; subSources: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ source: z.ZodString; imports: z.ZodRecord; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ source: z.ZodString; imports: z.ZodRecord; }, z.ZodTypeAny, "passthrough">>>>; styleSheets: z.ZodOptional, z.objectInputType<{ path: z.ZodString; css: z.ZodString; }, z.ZodTypeAny, "passthrough">>, "many">>; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ source: z.ZodString; modules: z.ZodOptional>; styles: z.ZodOptional; sampleProps: z.ZodOptional>; origin: z.ZodEnum<["authored", "seeded"]>; sourceImports: z.ZodOptional>; subSources: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ source: z.ZodString; imports: z.ZodRecord; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ source: z.ZodString; imports: z.ZodRecord; }, z.ZodTypeAny, "passthrough">>>>; styleSheets: z.ZodOptional, z.objectInputType<{ path: z.ZodString; css: z.ZodString; }, z.ZodTypeAny, "passthrough">>, "many">>; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ source: z.ZodString; modules: z.ZodOptional>; styles: z.ZodOptional; sampleProps: z.ZodOptional>; origin: z.ZodEnum<["authored", "seeded"]>; sourceImports: z.ZodOptional>; subSources: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ source: z.ZodString; imports: z.ZodRecord; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ source: z.ZodString; imports: z.ZodRecord; }, z.ZodTypeAny, "passthrough">>>>; styleSheets: z.ZodOptional, z.objectInputType<{ path: z.ZodString; css: z.ZodString; }, z.ZodTypeAny, "passthrough">>, "many">>; }, z.ZodTypeAny, "passthrough">>; /** * Backward compatible by construction: a stored `components` value is either * the legacy bare source string every app written before bundles carries, or a * bundle. Nothing migrates — every reader goes through {@link bundleOf}. */ export type ComponentEntry = string | ComponentBundle; /** 01-core §9 */ export declare const componentEntrySchema: z.ZodType; /** The one reader. A bare source string reads as an authored bundle. */ export declare const bundleOf: (entry: ComponentEntry) => ComponentBundle; /** * A terminal build failure recorded by the runtime when app generation threw * (model error, quota exhaustion, timeout). SERVER-WRITTEN ONLY: the model * never authors it — the runtime persists it on the create catch path so * open() can surface `{kind:"failed"}` and the embed resolves PROMPTLY with the * reason instead of spinning to the client build deadline. `reason` is a short, * honest, non-leaky line (never a raw provider stack). */ export interface AppBuildFailure { reason: string; retryable?: boolean; at: IsoDateTime; /** The create prompt that failed, persisted so a retry affordance can * re-issue the EXACT create (the record's name is a capped collapse of it, * too lossy to replay). Absent on records from before this field. */ prompt?: string; } /** * One file of an app's own code, at rest in the document (contract §3.2). * * Today an app's code lives in three places — island TSX in `components`, the * wire surface in workspace file rows, and the whole served app only inside the * E2B snapshot behind `machine.snapshotRef`. Lose the snapshot and the customer's * app is gone, because the store never had it. This is the one home: the row * becomes the truth and a workspace becomes a working copy of it. * * `hash` is the CAS base a checkout stamps and a commit diffs against, so a * commit lands exactly the paths that changed. `text` and `blobRef` are exclusive: * inline up to {@link WORKSPACE_INLINE_MAX_BYTES}, and past it the same blob seam * the workspace rows already spill to — never a second spill mechanism. */ export interface AppSourceFile { /** `"sha256:"` of the bytes. */ hash: string; bytes: number; /** Inline iff `bytes <= WORKSPACE_INLINE_MAX_BYTES`. */ text?: string; /** Else: the key in the app's blob namespace. */ blobRef?: string; } /** Contract §3.2 */ export declare const appSourceFileSchema: z.ZodObject<{ hash: z.ZodString; bytes: z.ZodNumber; text: z.ZodOptional; blobRef: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ hash: z.ZodString; bytes: z.ZodNumber; text: z.ZodOptional; blobRef: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ hash: z.ZodString; bytes: z.ZodNumber; text: z.ZodOptional; blobRef: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>; /** * The app's own memory — what it was asked for, and what was decided. * * A screen or build run is STATELESS; the artifact is what carries the context * forward. Without this, every editor after the first reads a document with no * idea why it looks the way it does, and quietly undoes a deliberate choice * ("filtered to 2 accounts — the ask was trip-only") because nothing recorded * that it was one. * * SERVER-WRITTEN, like {@link AppBuildFailure}: `asks` is recorded by the front * door and `decisions` by the agent's own save hand, both through the runtime's * one memory door. A model-authored `memory` on a generated document is stripped * before persist. * * Deliberately NOT a log. Reasoning traces, transcripts and tool outputs are not * here and must not be added: this is the smallest thing the next editor needs, * and an append-only history of everything is how dead context gets read as * current fact. */ export interface AppMemory { /** * Every `vendo_make` request that touched this app, VERBATIM and in order, * the create ask first. Never a paraphrase — a paraphrase drifts the intent * it was written to preserve. Capped at the write site (oldest dropped). */ asks: string[]; /** * A few lines the agent chose to record: choices made, constraints found, * things ruled out. REPLACED on every run that writes one, never appended — * a stale decision presented as current is worse than no memory at all. * Byte-capped at the write site. */ decisions?: string; } /** 01-core §9 */ export declare const appMemorySchema: z.ZodObject<{ asks: z.ZodArray; decisions: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ asks: z.ZodArray; decisions: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ asks: z.ZodArray; decisions: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>; /** * 01-core §9 — remix provenance: "this app was created from host component X at * baseline hash H". * * ONE seed, not a list of pins. A remix is an app created from something that * already existed, so the provenance is a property of the app, not a row set: * the thing it was seeded from, and the version of that thing it started at. * `slot` is the placement the ✦ gesture came from (a convenience for the chrome, * never the location of record — that is a placement ROW). * * `wishes` is every change that LANDED on this remix, VERBATIM and in order, the * ✦ gesture's own first. There are no bare forks — the gesture collects the * first wish before it fires — and a re-seed replays the WHOLE list against the * host's new baseline, so a wish missing here is an edit the person silently * loses, and a wish here that never reached their screen is one the Update * silently invents. That is why the list is what the person GOT and * {@link AppMemory.asks} beside it is everything they asked: one ask refused * three times is three asks and no wishes. Unlike `asks`, a capped working set, * this list is never trimmed: it IS the remix. */ export interface AppSeed { component: string; baseline: string; wishes: string[]; /** * The key in {@link AppDocument.components} holding the PORT — the host * component re-split against `baseline` for this remix to build its wishes on. * Absent until a re-split has run. */ port?: string; /** Wishes the last re-seed could not land on the new baseline. Still in * `wishes` — kept and reported, never dropped. */ unapplied?: string[]; /** * The LIVE props of the host instance this remix stands in for — couriered by * the `` wrapper on mount and on every change, and the values a * ported screen is painted on. * * The alternative is the baseline's captured `sampleProps`, which is what the * floor falls back to and which is frozen the day `vendo sync` ran: a remix of * a balance card painted the sync-time number forever while the host's own * component, two inches away, painted today's. A port renders from its props * and no prop is in any source it could read, so this is the only route the * page's own state has into it. * * Filtered at the door to the captured baseline's own declared prop names, so * a prop the host component never declared is dropped before it is stored. * JSON only, by the same law as every value that crosses into the VM. */ props?: Record; slot?: string; } /** 01-core §9 */ export declare const appSeedSchema: z.ZodEffects>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>, { wishes: string[]; component: string; baseline: string; port?: string | undefined; unapplied?: string[] | undefined; props?: Record | undefined; slot?: string | undefined; }, z.objectInputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>; /** * The stable generated-component name a seeded app's copy of the host component * ships under — a pure function of {@link AppSeed}'s component, so it belongs * beside the seed. * * It lives in core because BOTH sides of the seam need the same answer and * `ui → apps` is not an edge layering allows (dependency-guard): the runtime * writes the node under this name, and the client's in-place mount finds it by * this name. */ export declare const seedComponentName: (slot: string) => string; /** * A SEALED bundle — the app's built client code, frozen as content-addressed * blobs. Every hash BELOW is a blob key, and a blob is only ever stored under * its own hash, never under a path (`assets` is keyed by path because that is * how the entry names its imports — the path is a lookup, never a location): * the entry hash IS the version and the blob key, so a reseal can never * overwrite the bytes an open tab is still rendering, and the loser of a * concurrent seal stays readable as a history version. * * Brand tokens and fonts are injected AT RENDER and are deliberately not baked * in, so one seal follows a host's palette instead of pinning the palette it * was built under. */ export interface AppBundle { /** sha256 hex of the entry module's bytes. */ entry: string; /** The modules the entry reaches: path it names them by -> sha256 hex. */ assets?: Record; bytes: number; sealedAt: IsoDateTime; } /** 01-core §9 */ export declare const appBundleSchema: z.ZodObject<{ entry: z.ZodString; assets: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ entry: z.ZodString; assets: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ entry: z.ZodString; assets: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, z.ZodTypeAny, "passthrough">>; /** * A build the person has been ASKED about and has not answered yet. Written * when the make tool raises the standing approval card, cleared the moment the * decision lands either way — so its presence IS the awaiting-consent state, * and while it is there no box has been claimed and nothing has been spent. * * `prompt` is verbatim because the build brief is replayed from it whenever the * yes arrives, which may be long after the turn that asked is gone; the app's * name is a capped collapse of it and too lossy to build from. */ export interface AppBuildProposal { approvalId: ApprovalId; prompt: string; /** The screen agent's own line for why a screen was not enough. */ why: string; at: IsoDateTime; } /** 01-core §9 */ export declare const appBuildProposalSchema: z.ZodObject<{ approvalId: z.ZodString; prompt: z.ZodString; why: z.ZodString; at: z.ZodString; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ approvalId: z.ZodString; prompt: z.ZodString; why: z.ZodString; at: z.ZodString; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ approvalId: z.ZodString; prompt: z.ZodString; why: z.ZodString; at: z.ZodString; }, z.ZodTypeAny, "passthrough">>; /** 01-core §9 */ export interface AppDocument { format: typeof VENDO_APP_FORMAT; id: AppId; name: string; description?: string; ui?: "tree" | "bundle"; components?: Record; /** * Contract §3.2 — the app's own code, at rest. Keys are POSIX-relative paths * inside the app directory ("src/App.tsx", "vendo.json"), the app's own * screen (`app.tsx`) included. * * This is what a RESEAL starts from: a bundle is rebuilt from here in a fresh * box, so no sealed artifact is ever the only copy of an app's own code. */ source?: Record; /** The seal a `ui: "bundle"` app renders — the one field that says which * bytes this app IS right now. */ bundle?: AppBundle; /** * The app's automations, by id — maintained by the APPS layer ONLY * (`vendo_make`'s compound flow, the manifest fold-in), and resolved on read * so a dead id simply drops out. * * A pointer, never the automation: an {@link AutomationRecord} carries no app * reference at all, so the automations engine never sees this field and an * app that is deleted takes nothing down with it. */ automations?: AutomationId[]; /** Remix provenance ONLY (drift, ship-diff, re-seed). "Show this app in that * slot" is a placement ROW, never a document field — see * `@vendoai/vendo/apps` `placements.ts`. */ seed?: AppSeed; forkedFrom?: AppId; /** * A terminal build failure. Present only on a record the runtime persisted * when generation threw; open() reads it to answer `{kind:"failed"}`. * Server-written — stripped from a successful create/edit like the other * server-authoritative fields. */ buildFailed?: AppBuildFailure; /** * A build still WRITING this app — the time its first painting save landed. * `buildFailed`'s live half: a screen saves as it goes, so its row exists * tens of seconds before the mandatory reviewer pass and its repair round * finish, and mounting on the row alone showed people a draft the build was * about to correct. `open()` answers not-found until it clears, which the * wire's build window already turns into the `{kind:"pending"}` every embed * waits on. Server-written; cleared when the assembler returns. */ building?: IsoDateTime; /** * The one line the build lane last said about itself, in the person's terms. * A LABEL, never a log: the latest replaces the previous, because progress is * chat status lines and the only reader is the pending poll's answer. Written * only while `building` is set, and cleared with it. */ buildStatus?: string; /** * `building`'s half-step back: a build that has been OFFERED and not yet * answered. Server-written by the propose path and cleared by the decision, * so a document can never carry both this and `building`. */ proposal?: AppBuildProposal; /** * What this app remembers about itself. Server-written — stripped from a * generated document before persist and pinned from the stored row on every * edit, so only the memory door ever changes it. */ memory?: AppMemory; } /** * 01-core §9 — structural shape only. Like every core schema, this parses the * SHAPE (passthrough for forward compatibility); the cross-field business * rules (component limits, fn:-requires-machine, reserved `state` collection, * ref/pin formats, non-empty names) live in {@link validateAppDocument}, which * is the normative gate. A `parse()` alone can accept a semantically invalid * document. */ export declare const appDocumentSchema: z.ZodObject<{ format: z.ZodLiteral<"vendo/app@1">; id: z.ZodString; name: z.ZodString; description: z.ZodOptional; ui: z.ZodOptional>; components: z.ZodOptional>>; source: z.ZodOptional; blobRef: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ hash: z.ZodString; bytes: z.ZodNumber; text: z.ZodOptional; blobRef: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ hash: z.ZodString; bytes: z.ZodNumber; text: z.ZodOptional; blobRef: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>>; bundle: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ entry: z.ZodString; assets: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ entry: z.ZodString; assets: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, z.ZodTypeAny, "passthrough">>>; automations: z.ZodOptional>; seed: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>, { wishes: string[]; component: string; baseline: string; port?: string | undefined; unapplied?: string[] | undefined; props?: Record | undefined; slot?: string | undefined; }, z.objectInputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>; forkedFrom: z.ZodOptional; buildFailed: z.ZodOptional; at: z.ZodString; prompt: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ reason: z.ZodString; retryable: z.ZodOptional; at: z.ZodString; prompt: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ reason: z.ZodString; retryable: z.ZodOptional; at: z.ZodString; prompt: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>; building: z.ZodOptional; buildStatus: z.ZodOptional; proposal: z.ZodOptional, z.objectInputType<{ approvalId: z.ZodString; prompt: z.ZodString; why: z.ZodString; at: z.ZodString; }, z.ZodTypeAny, "passthrough">>>; memory: z.ZodOptional; decisions: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ asks: z.ZodArray; decisions: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ asks: z.ZodArray; decisions: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ format: z.ZodLiteral<"vendo/app@1">; id: z.ZodString; name: z.ZodString; description: z.ZodOptional; ui: z.ZodOptional>; components: z.ZodOptional>>; source: z.ZodOptional; blobRef: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ hash: z.ZodString; bytes: z.ZodNumber; text: z.ZodOptional; blobRef: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ hash: z.ZodString; bytes: z.ZodNumber; text: z.ZodOptional; blobRef: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>>; bundle: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ entry: z.ZodString; assets: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ entry: z.ZodString; assets: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, z.ZodTypeAny, "passthrough">>>; automations: z.ZodOptional>; seed: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>, { wishes: string[]; component: string; baseline: string; port?: string | undefined; unapplied?: string[] | undefined; props?: Record | undefined; slot?: string | undefined; }, z.objectInputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>; forkedFrom: z.ZodOptional; buildFailed: z.ZodOptional; at: z.ZodString; prompt: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ reason: z.ZodString; retryable: z.ZodOptional; at: z.ZodString; prompt: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ reason: z.ZodString; retryable: z.ZodOptional; at: z.ZodString; prompt: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>; building: z.ZodOptional; buildStatus: z.ZodOptional; proposal: z.ZodOptional, z.objectInputType<{ approvalId: z.ZodString; prompt: z.ZodString; why: z.ZodString; at: z.ZodString; }, z.ZodTypeAny, "passthrough">>>; memory: z.ZodOptional; decisions: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ asks: z.ZodArray; decisions: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ asks: z.ZodArray; decisions: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ format: z.ZodLiteral<"vendo/app@1">; id: z.ZodString; name: z.ZodString; description: z.ZodOptional; ui: z.ZodOptional>; components: z.ZodOptional>>; source: z.ZodOptional; blobRef: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ hash: z.ZodString; bytes: z.ZodNumber; text: z.ZodOptional; blobRef: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ hash: z.ZodString; bytes: z.ZodNumber; text: z.ZodOptional; blobRef: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>>; bundle: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ entry: z.ZodString; assets: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ entry: z.ZodString; assets: z.ZodOptional>; bytes: z.ZodNumber; sealedAt: z.ZodString; }, z.ZodTypeAny, "passthrough">>>; automations: z.ZodOptional>; seed: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>, { wishes: string[]; component: string; baseline: string; port?: string | undefined; unapplied?: string[] | undefined; props?: Record | undefined; slot?: string | undefined; }, z.objectInputType<{ component: z.ZodString; baseline: z.ZodString; wishes: z.ZodOptional>; instruction: z.ZodOptional; port: z.ZodOptional; unapplied: z.ZodOptional>; props: z.ZodOptional>; slot: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>; forkedFrom: z.ZodOptional; buildFailed: z.ZodOptional; at: z.ZodString; prompt: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ reason: z.ZodString; retryable: z.ZodOptional; at: z.ZodString; prompt: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ reason: z.ZodString; retryable: z.ZodOptional; at: z.ZodString; prompt: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>; building: z.ZodOptional; buildStatus: z.ZodOptional; proposal: z.ZodOptional, z.objectInputType<{ approvalId: z.ZodString; prompt: z.ZodString; why: z.ZodString; at: z.ZodString; }, z.ZodTypeAny, "passthrough">>>; memory: z.ZodOptional; decisions: z.ZodOptional; }, "passthrough", z.ZodTypeAny, z.objectOutputType<{ asks: z.ZodArray; decisions: z.ZodOptional; }, z.ZodTypeAny, "passthrough">, z.objectInputType<{ asks: z.ZodArray; decisions: z.ZodOptional; }, z.ZodTypeAny, "passthrough">>>; }, z.ZodTypeAny, "passthrough">>;