@fnndsc/menu 0.3.1

package/dist/messages.d.ts

@@ -0,0 +1,2402 @@
+/**
+ * @file The wire-contract message schemas.
+ *
+ * Two discriminated unions, one per direction, keyed on a `type` tag:
+ * {@link clientMessageSchema} (surface → daemon) and
+ * {@link serverMessageSchema} (daemon → surface). Every request carries a
+ * correlation `id` so its reply and any streamed output can be matched to
+ * it, and output events carry the sink channel they belong to. These schemas
+ * are the single source of truth for the protocol; the human-readable
+ * description in `docs/calypso.adoc` is checked against them.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import { commandEnvelopeSchema } from './envelope.js';
+/** The sink channel an output event belongs to. */
+export declare const channelSchema: z.ZodEnum<["data", "err", "status"]>;
+/**
+ * Capabilities an attaching surface can safely execute on its own machine.
+ *
+ * Optional throughout, and absent means false: a surface built against an older
+ * contract simply declares less, and the daemon refuses what it did not claim
+ * rather than assuming.
+ */
+export declare const surfaceCapabilitiesMessageSchema: z.ZodObject<{
+    shellCommands: z.ZodBoolean;
+    hiddenInput: z.ZodOptional<z.ZodBoolean>;
+    /** Can put a file where its operator can reach it. */
+    fileDelivery: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Has a filesystem of its own, so it can receive many files as a directory
+     * structure. A browser cannot, and needs a directory archived into one file
+     * before it can be handed over.
+     */
+    localFilesystem: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    shellCommands: boolean;
+    hiddenInput?: boolean | undefined;
+    fileDelivery?: boolean | undefined;
+    localFilesystem?: boolean | undefined;
+}, {
+    shellCommands: boolean;
+    hiddenInput?: boolean | undefined;
+    fileDelivery?: boolean | undefined;
+    localFilesystem?: boolean | undefined;
+}>;
+/** Attach to a session: declares the contract version, token, and surface capabilities. */
+export declare const attachMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"attach">;
+    protocolVersion: z.ZodNumber;
+    token: z.ZodString;
+    session: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        shellCommands: z.ZodBoolean;
+        hiddenInput: z.ZodOptional<z.ZodBoolean>;
+        /** Can put a file where its operator can reach it. */
+        fileDelivery: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Has a filesystem of its own, so it can receive many files as a directory
+         * structure. A browser cannot, and needs a directory archived into one file
+         * before it can be handed over.
+         */
+        localFilesystem: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        shellCommands: boolean;
+        hiddenInput?: boolean | undefined;
+        fileDelivery?: boolean | undefined;
+        localFilesystem?: boolean | undefined;
+    }, {
+        shellCommands: boolean;
+        hiddenInput?: boolean | undefined;
+        fileDelivery?: boolean | undefined;
+        localFilesystem?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "attach";
+    protocolVersion: number;
+    token: string;
+    session?: string | undefined;
+    capabilities?: {
+        shellCommands: boolean;
+        hiddenInput?: boolean | undefined;
+        fileDelivery?: boolean | undefined;
+        localFilesystem?: boolean | undefined;
+    } | undefined;
+}, {
+    type: "attach";
+    protocolVersion: number;
+    token: string;
+    session?: string | undefined;
+    capabilities?: {
+        shellCommands: boolean;
+        hiddenInput?: boolean | undefined;
+        fileDelivery?: boolean | undefined;
+        localFilesystem?: boolean | undefined;
+    } | undefined;
+}>;
+/**
+ * Execute one input line, correlated by `id`.
+ *
+ * `instrument` marks surface-internal traffic (a panel's silent refresh, an
+ * ambient cycler) rather than something the operator said: the daemon runs
+ * it normally but keeps it off the session bus and out of scrollback, so
+ * sibling surfaces and reattach replays carry only operator activity.
+ */
+export declare const executeMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"execute">;
+    id: z.ZodString;
+    line: z.ZodString;
+    instrument: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "execute";
+    line: string;
+    instrument?: boolean | undefined;
+}, {
+    id: string;
+    type: "execute";
+    line: string;
+    instrument?: boolean | undefined;
+}>;
+/** Requests cancellation of the caller's currently executing command. */
+export declare const cancelMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"cancel">;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "cancel";
+}, {
+    id: string;
+    type: "cancel";
+}>;
+/** Request completion candidates for a partial line, correlated by `id`. */
+export declare const completeRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"complete">;
+    id: z.ZodString;
+    prefix: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "complete";
+    prefix: string;
+}, {
+    id: string;
+    type: "complete";
+    prefix: string;
+}>;
+/** Answers a prompt the daemon requested during a command, correlated by `promptId`. */
+export declare const promptAnswerMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"promptAnswer">;
+    promptId: z.ZodString;
+    answer: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "promptAnswer";
+    promptId: string;
+    answer: string;
+}, {
+    type: "promptAnswer";
+    promptId: string;
+    answer: string;
+}>;
+/** Reports a prompt failure to the daemon (surface cannot or did not answer), correlated by `promptId`. */
+export declare const promptErrorMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"promptError">;
+    promptId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "promptError";
+    promptId: string;
+    reason: string;
+}, {
+    type: "promptError";
+    promptId: string;
+    reason: string;
+}>;
+/** Returns the output of a pipeline segment the daemon asked the surface to run, correlated by `pipeId`. */
+export declare const pipeResultMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pipeResult">;
+    pipeId: z.ZodString;
+    output: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "pipeResult";
+    pipeId: string;
+    output: string;
+}, {
+    type: "pipeResult";
+    pipeId: string;
+    output: string;
+}>;
+/** Returns a pipeline-segment failure to the daemon, correlated by `pipeId`. */
+export declare const pipeErrorMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pipeError">;
+    pipeId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "pipeError";
+    reason: string;
+    pipeId: string;
+}, {
+    type: "pipeError";
+    reason: string;
+    pipeId: string;
+}>;
+/** Returns the exit code of a shell command the daemon asked the surface to run. */
+export declare const shellResultMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"shellResult">;
+    shellId: z.ZodString;
+    exitCode: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "shellResult";
+    shellId: string;
+    exitCode: number;
+}, {
+    type: "shellResult";
+    shellId: string;
+    exitCode: number;
+}>;
+/** Returns a surface shell-launch failure to the daemon, correlated by `shellId`. */
+export declare const shellErrorMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"shellError">;
+    shellId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "shellError";
+    reason: string;
+    shellId: string;
+}, {
+    type: "shellError";
+    reason: string;
+    shellId: string;
+}>;
+/** Returns the edited content from a local-edit the daemon requested, correlated by `editId`. */
+export declare const editResultMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"editResult">;
+    editId: z.ZodString;
+    content: z.ZodString;
+    changed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: "editResult";
+    editId: string;
+    content: string;
+    changed: boolean;
+}, {
+    type: "editResult";
+    editId: string;
+    content: string;
+    changed: boolean;
+}>;
+/** Reports a local-edit failure to the daemon, correlated by `editId`. */
+export declare const editErrorMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"editError">;
+    editId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "editError";
+    reason: string;
+    editId: string;
+}, {
+    type: "editError";
+    reason: string;
+    editId: string;
+}>;
+/**
+ * Reports a completed file delivery, correlated by `deliverId`.
+ *
+ * `location` is wherever the surface can honestly say the file went — an
+ * absolute path for a filesystem, a bare filename for a browser that handed it
+ * to the download manager.
+ */
+export declare const deliverResultMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"deliverResult">;
+    deliverId: z.ZodString;
+    location: z.ZodString;
+    bytes: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "deliverResult";
+    bytes: number;
+    deliverId: string;
+    location: string;
+}, {
+    type: "deliverResult";
+    bytes: number;
+    deliverId: string;
+    location: string;
+}>;
+/** Reports a failed file delivery to the daemon, correlated by `deliverId`. */
+export declare const deliverErrorMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"deliverError">;
+    deliverId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "deliverError";
+    reason: string;
+    deliverId: string;
+}, {
+    type: "deliverError";
+    reason: string;
+    deliverId: string;
+}>;
+/**
+ * The operator's regard: the addressable thing most recently indicated on a
+ * surface — a file clicked in a browser, a DAG node selected.
+ *
+ * The value is an address in the namespace (plus the model kind it was
+ * indicated through), never view-space coordinates: what has no address is
+ * view state and stays surface-side. `groupId` and `paneId` are provenance —
+ * which link group and pane the indication happened in — so session-level
+ * consumers know where regard came from without the surface's geometry ever
+ * crossing the wire.
+ */
+export declare const regardSchema: z.ZodObject<{
+    address: z.ZodString;
+    modelKind: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodString;
+    paneId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    groupId: string;
+    paneId: string;
+    modelKind?: string | undefined;
+}, {
+    address: string;
+    groupId: string;
+    paneId: string;
+    modelKind?: string | undefined;
+}>;
+/** The session's retained regard value. */
+export type Regard = z.infer<typeof regardSchema>;
+/**
+ * A regard write, travelling both directions under one shape: a surface
+ * reports an indication to the daemon, and the daemon pushes the retained
+ * session regard to every surface (last write wins; a late attacher receives
+ * the retained value on attach).
+ */
+export declare const regardMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"regard">;
+    regard: z.ZodObject<{
+        address: z.ZodString;
+        modelKind: z.ZodOptional<z.ZodString>;
+        groupId: z.ZodString;
+        paneId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    }, {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "regard";
+    regard: {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    };
+}, {
+    type: "regard";
+    regard: {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    };
+}>;
+/**
+ * A liveness subscription: the surface asks the session to keep one subject
+ * fresh while the surface is looking at it. The subject is an address in
+ * the namespace (`/proc/jobs/feed_N`), never a view. Regard is what the
+ * operator indicates; a watch is what a surface keeps open — a different
+ * noun, so it has its own message. Watches are owned per surface and
+ * released when the surface detaches.
+ */
+export declare const watchMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"watch">;
+    subject: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "watch";
+    subject: string;
+}, {
+    type: "watch";
+    subject: string;
+}>;
+/** Ends a surface's liveness subscription for one subject. */
+export declare const unwatchMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"unwatch">;
+    subject: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "unwatch";
+    subject: string;
+}, {
+    type: "unwatch";
+    subject: string;
+}>;
+/** What a watched subject is doing: sampled live, settled for good, or last sample failed. */
+export declare const WATCH_STATES: readonly ["live", "settled", "stale"];
+export declare const watchStateSchema: z.ZodEnum<["live", "settled", "stale"]>;
+export type WatchState = z.infer<typeof watchStateSchema>;
+/**
+ * The daemon's report on a watched subject's liveness, pushed to every
+ * surface whenever it changes (a subject settling is news to all of them).
+ */
+export declare const watchedMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"watched">;
+    subject: z.ZodString;
+    state: z.ZodEnum<["live", "settled", "stale"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "watched";
+    subject: string;
+    state: "live" | "settled" | "stale";
+}, {
+    type: "watched";
+    subject: string;
+    state: "live" | "settled" | "stale";
+}>;
+export type WatchedMessage = z.infer<typeof watchedMessageSchema>;
+/**
+ * An event the engine originates on its own — a sampler's refreshed model,
+ * a watch changing state — rather than in answer to a command. The daemon
+ * relays it to every surface; it never enters scrollback.
+ */
+export type AmbientEvent = {
+    kind: 'envelope';
+    envelope: z.infer<typeof commandEnvelopeSchema>;
+} | {
+    kind: 'watched';
+    subject: string;
+    state: WatchState;
+};
+/** Any message a surface may send to the daemon. */
+export declare const clientMessageSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"attach">;
+    protocolVersion: z.ZodNumber;
+    token: z.ZodString;
+    session: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        shellCommands: z.ZodBoolean;
+        hiddenInput: z.ZodOptional<z.ZodBoolean>;
+        /** Can put a file where its operator can reach it. */
+        fileDelivery: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Has a filesystem of its own, so it can receive many files as a directory
+         * structure. A browser cannot, and needs a directory archived into one file
+         * before it can be handed over.
+         */
+        localFilesystem: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        shellCommands: boolean;
+        hiddenInput?: boolean | undefined;
+        fileDelivery?: boolean | undefined;
+        localFilesystem?: boolean | undefined;
+    }, {
+        shellCommands: boolean;
+        hiddenInput?: boolean | undefined;
+        fileDelivery?: boolean | undefined;
+        localFilesystem?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "attach";
+    protocolVersion: number;
+    token: string;
+    session?: string | undefined;
+    capabilities?: {
+        shellCommands: boolean;
+        hiddenInput?: boolean | undefined;
+        fileDelivery?: boolean | undefined;
+        localFilesystem?: boolean | undefined;
+    } | undefined;
+}, {
+    type: "attach";
+    protocolVersion: number;
+    token: string;
+    session?: string | undefined;
+    capabilities?: {
+        shellCommands: boolean;
+        hiddenInput?: boolean | undefined;
+        fileDelivery?: boolean | undefined;
+        localFilesystem?: boolean | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"execute">;
+    id: z.ZodString;
+    line: z.ZodString;
+    instrument: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "execute";
+    line: string;
+    instrument?: boolean | undefined;
+}, {
+    id: string;
+    type: "execute";
+    line: string;
+    instrument?: boolean | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"cancel">;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "cancel";
+}, {
+    id: string;
+    type: "cancel";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"complete">;
+    id: z.ZodString;
+    prefix: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "complete";
+    prefix: string;
+}, {
+    id: string;
+    type: "complete";
+    prefix: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"promptAnswer">;
+    promptId: z.ZodString;
+    answer: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "promptAnswer";
+    promptId: string;
+    answer: string;
+}, {
+    type: "promptAnswer";
+    promptId: string;
+    answer: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"promptError">;
+    promptId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "promptError";
+    promptId: string;
+    reason: string;
+}, {
+    type: "promptError";
+    promptId: string;
+    reason: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"pipeResult">;
+    pipeId: z.ZodString;
+    output: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "pipeResult";
+    pipeId: string;
+    output: string;
+}, {
+    type: "pipeResult";
+    pipeId: string;
+    output: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"pipeError">;
+    pipeId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "pipeError";
+    reason: string;
+    pipeId: string;
+}, {
+    type: "pipeError";
+    reason: string;
+    pipeId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"shellResult">;
+    shellId: z.ZodString;
+    exitCode: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "shellResult";
+    shellId: string;
+    exitCode: number;
+}, {
+    type: "shellResult";
+    shellId: string;
+    exitCode: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"shellError">;
+    shellId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "shellError";
+    reason: string;
+    shellId: string;
+}, {
+    type: "shellError";
+    reason: string;
+    shellId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"editResult">;
+    editId: z.ZodString;
+    content: z.ZodString;
+    changed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: "editResult";
+    editId: string;
+    content: string;
+    changed: boolean;
+}, {
+    type: "editResult";
+    editId: string;
+    content: string;
+    changed: boolean;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"editError">;
+    editId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "editError";
+    reason: string;
+    editId: string;
+}, {
+    type: "editError";
+    reason: string;
+    editId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"deliverResult">;
+    deliverId: z.ZodString;
+    location: z.ZodString;
+    bytes: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "deliverResult";
+    bytes: number;
+    deliverId: string;
+    location: string;
+}, {
+    type: "deliverResult";
+    bytes: number;
+    deliverId: string;
+    location: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"deliverError">;
+    deliverId: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "deliverError";
+    reason: string;
+    deliverId: string;
+}, {
+    type: "deliverError";
+    reason: string;
+    deliverId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"regard">;
+    regard: z.ZodObject<{
+        address: z.ZodString;
+        modelKind: z.ZodOptional<z.ZodString>;
+        groupId: z.ZodString;
+        paneId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    }, {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "regard";
+    regard: {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    };
+}, {
+    type: "regard";
+    regard: {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"watch">;
+    subject: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "watch";
+    subject: string;
+}, {
+    type: "watch";
+    subject: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"unwatch">;
+    subject: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "unwatch";
+    subject: string;
+}, {
+    type: "unwatch";
+    subject: string;
+}>]>;
+/** A message a surface sends to the daemon. */
+export type ClientMessage = z.infer<typeof clientMessageSchema>;
+/**
+ * Acknowledges a successful attach. The optional `stack` block reports the
+ * daemon's own installed versions and build hash, so a remote surface can
+ * greet with the truth of the process it attached to rather than whatever is
+ * installed client-side; older daemons simply omit it.
+ */
+export declare const attachedMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"attached">;
+    session: z.ZodString;
+    protocolVersion: z.ZodNumber;
+    stack: z.ZodOptional<z.ZodObject<{
+        chell: z.ZodString;
+        calypso: z.ZodString;
+        build: z.ZodString;
+        brasa: z.ZodOptional<z.ZodString>;
+        chili: z.ZodOptional<z.ZodString>;
+        salsa: z.ZodOptional<z.ZodString>;
+        cumin: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chell: string;
+        calypso: string;
+        build: string;
+        brasa?: string | undefined;
+        chili?: string | undefined;
+        salsa?: string | undefined;
+        cumin?: string | undefined;
+    }, {
+        chell: string;
+        calypso: string;
+        build: string;
+        brasa?: string | undefined;
+        chili?: string | undefined;
+        salsa?: string | undefined;
+        cumin?: string | undefined;
+    }>>;
+    /** The host-control tiers the daemon declared (`shell`, `files`, `pipes`); empty or absent when off. */
+    hostControl: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "attached";
+    protocolVersion: number;
+    session: string;
+    stack?: {
+        chell: string;
+        calypso: string;
+        build: string;
+        brasa?: string | undefined;
+        chili?: string | undefined;
+        salsa?: string | undefined;
+        cumin?: string | undefined;
+    } | undefined;
+    hostControl?: string[] | undefined;
+}, {
+    type: "attached";
+    protocolVersion: number;
+    session: string;
+    stack?: {
+        chell: string;
+        calypso: string;
+        build: string;
+        brasa?: string | undefined;
+        chili?: string | undefined;
+        salsa?: string | undefined;
+        cumin?: string | undefined;
+    } | undefined;
+    hostControl?: string[] | undefined;
+}>;
+/** The final result of one executed line: one envelope per command. */
+export declare const resultMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    id: z.ZodString;
+    envelopes: z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<["ok", "error"]>;
+        rendered: z.ZodString;
+        renderedErr: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodString;
+            data: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            kind: string;
+            data?: unknown;
+        }, {
+            kind: string;
+            data?: unknown;
+        }>>;
+        errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["error", "warning"]>;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            type: "error" | "warning";
+        }, {
+            message: string;
+            type: "error" | "warning";
+        }>, "many">>;
+        trace: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            proposed: z.ZodString;
+            validated: z.ZodBoolean;
+            executed: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        }, {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }, {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "result";
+    envelopes: {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }[];
+}, {
+    id: string;
+    type: "result";
+    envelopes: {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }[];
+}>;
+/** The reply to a completion request. */
+export declare const completeReplySchema: z.ZodObject<{
+    type: z.ZodLiteral<"complete">;
+    id: z.ZodString;
+    prefix: z.ZodString;
+    candidates: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "complete";
+    prefix: string;
+    candidates: string[];
+}, {
+    id: string;
+    type: "complete";
+    prefix: string;
+    candidates: string[];
+}>;
+/** A streamed output event on one channel, correlated to its command. */
+export declare const outputMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"output">;
+    id: z.ZodString;
+    channel: z.ZodEnum<["data", "err", "status"]>;
+    chunk: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "output";
+    channel: "status" | "data" | "err";
+    chunk: string;
+}, {
+    id: string;
+    type: "output";
+    channel: "status" | "data" | "err";
+    chunk: string;
+}>;
+/**
+ * The operation producing structured progress.
+ *
+ * Within a major, the contract promises additive change only, which is a
+ * promise a bare enum cannot keep: an unknown value fails the whole message,
+ * and a failed parse drops it. An operation a peer names but this build does
+ * not know is therefore read as `task` — none of the above — so the work still
+ * shows, generically, instead of vanishing.
+ */
+export declare const progressOperationSchema: z.ZodCatch<z.ZodEnum<["upload", "download", "pull", "workflow", "pipeline", "group", "task"]>>;
+/**
+ * Broad class of progress producer.
+ *
+ * Optional, so an unknown class degrades to absent: the event still renders
+ * from its operation and phase, one axis poorer.
+ */
+export declare const progressKindSchema: z.ZodCatch<z.ZodEnum<["transfer", "retrieve", "workflow", "inspection"]>>;
+/**
+ * Lifecycle phase of a progress operation.
+ *
+ * An unknown phase degrades to `working` for the reason given on
+ * {@link progressOperationSchema}: an unrecognised phase still means work is
+ * under way, and that much is worth showing. `complete` and `failed` are
+ * terminal and will not be inferred, so a surface that cannot read a newer
+ * peer's terminal phase leaves the announcement open rather than closing it
+ * wrongly.
+ */
+export declare const progressPhaseSchema: z.ZodCatch<z.ZodEnum<["scanning", "transferring", "watching", "retrying", "reading", "working", "complete", "failed"]>>;
+/**
+ * Unit used by the primary progress counter.
+ *
+ * Optional, so an unknown unit degrades to absent and the counter renders
+ * unqualified — 3/10 rather than nothing at all.
+ */
+export declare const progressUnitSchema: z.ZodCatch<z.ZodEnum<["files", "bytes", "series", "jobs", "nodes"]>>;
+/**
+ * State of the operation or item being reported.
+ *
+ * An unknown state degrades to `unknown`, which the vocabulary already carries
+ * for precisely this: a state that cannot be named is still a state.
+ */
+export declare const progressStatusSchema: z.ZodCatch<z.ZodEnum<["running", "done", "unconfirmed", "stalled", "timeout", "error", "unknown"]>>;
+/** A structured progress event correlated to a command. */
+export declare const progressMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"progress">;
+    id: z.ZodString;
+    operation: z.ZodCatch<z.ZodEnum<["upload", "download", "pull", "workflow", "pipeline", "group", "task"]>>;
+    kind: z.ZodOptional<z.ZodCatch<z.ZodEnum<["transfer", "retrieve", "workflow", "inspection"]>>>;
+    phase: z.ZodCatch<z.ZodEnum<["scanning", "transferring", "watching", "retrying", "reading", "working", "complete", "failed"]>>;
+    label: z.ZodOptional<z.ZodString>;
+    itemId: z.ZodOptional<z.ZodString>;
+    current: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodOptional<z.ZodNumber>;
+    percent: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodCatch<z.ZodEnum<["files", "bytes", "series", "jobs", "nodes"]>>>;
+    status: z.ZodOptional<z.ZodCatch<z.ZodEnum<["running", "done", "unconfirmed", "stalled", "timeout", "error", "unknown"]>>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "progress";
+    operation: "upload" | "download" | "pull" | "workflow" | "pipeline" | "group" | "task";
+    phase: "failed" | "scanning" | "transferring" | "watching" | "retrying" | "reading" | "working" | "complete";
+    label?: string | undefined;
+    status?: "unknown" | "done" | "error" | "running" | "unconfirmed" | "stalled" | "timeout" | undefined;
+    kind?: "workflow" | "transfer" | "retrieve" | "inspection" | undefined;
+    itemId?: string | undefined;
+    current?: number | undefined;
+    total?: number | undefined;
+    percent?: number | undefined;
+    unit?: "nodes" | "files" | "bytes" | "series" | "jobs" | undefined;
+}, {
+    id: string;
+    type: "progress";
+    label?: string | undefined;
+    status?: unknown;
+    kind?: unknown;
+    operation?: unknown;
+    phase?: unknown;
+    itemId?: string | undefined;
+    current?: number | undefined;
+    total?: number | undefined;
+    percent?: number | undefined;
+    unit?: unknown;
+}>;
+/** A progress event as it appears on the wire, correlated to its command. */
+export type ProgressMessage = z.infer<typeof progressMessageSchema>;
+/** The progress payload before command correlation is added by the daemon. */
+export type ProgressEvent = Omit<ProgressMessage, 'type' | 'id'>;
+/** A session-bus broadcast: an envelope tagged with its originating surface. */
+export declare const sessionMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"session">;
+    surface: z.ZodString;
+    envelope: z.ZodObject<{
+        status: z.ZodEnum<["ok", "error"]>;
+        rendered: z.ZodString;
+        renderedErr: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodString;
+            data: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            kind: string;
+            data?: unknown;
+        }, {
+            kind: string;
+            data?: unknown;
+        }>>;
+        errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["error", "warning"]>;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            type: "error" | "warning";
+        }, {
+            message: string;
+            type: "error" | "warning";
+        }>, "many">>;
+        trace: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            proposed: z.ZodString;
+            validated: z.ZodBoolean;
+            executed: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        }, {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }, {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "session";
+    envelope: {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    };
+    surface: string;
+}, {
+    type: "session";
+    envelope: {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    };
+    surface: string;
+}>;
+/** A boundary error: a refused attach, a malformed message, correlated when possible. */
+export declare const errorMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    id: z.ZodOptional<z.ZodString>;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "error";
+    reason: string;
+    id?: string | undefined;
+}, {
+    type: "error";
+    reason: string;
+    id?: string | undefined;
+}>;
+/**
+ * A prompt request the daemon raises during a command: the surface that
+ * submitted the command must answer it (with `promptAnswer`) before the
+ * command can proceed. `hidden` requests no-echo entry (password).
+ */
+export declare const promptMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"prompt">;
+    promptId: z.ZodString;
+    message: z.ZodString;
+    hidden: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "prompt";
+    promptId: string;
+    hidden: boolean;
+}, {
+    message: string;
+    type: "prompt";
+    promptId: string;
+    hidden: boolean;
+}>;
+/**
+ * The engine-known facts a prompt reflects, independent of any theme.
+ *
+ * The daemon knows the session context but not how a given surface renders it,
+ * so it ships these facts and each surface themes them with its own settings.
+ * Rendering inputs a surface owns (theme, segments, terminal width) are not
+ * carried here.
+ */
+export declare const promptContextSchema: z.ZodObject<{
+    user: z.ZodString;
+    uri: z.ZodString;
+    cwd: z.ZodString;
+    pacsserver: z.ZodNullable<z.ZodString>;
+    physicalMode: z.ZodBoolean;
+    lastExitCode: z.ZodNumber;
+    lastCommandDurationMs: z.ZodNumber;
+    procWarmup: z.ZodOptional<z.ZodObject<{
+        loaded: z.ZodNumber;
+        total: z.ZodOptional<z.ZodNumber>;
+        restored: z.ZodOptional<z.ZodBoolean>;
+        state: z.ZodOptional<z.ZodEnum<["cold", "cached", "failed"]>>;
+        sweeping: z.ZodOptional<z.ZodBoolean>;
+        feed: z.ZodOptional<z.ZodObject<{
+            id: z.ZodNumber;
+            loaded: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            id: number;
+            total: number;
+            loaded: number;
+        }, {
+            id: number;
+            total: number;
+            loaded: number;
+        }>>;
+        arrived: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        loaded: number;
+        state?: "cold" | "cached" | "failed" | undefined;
+        total?: number | undefined;
+        restored?: boolean | undefined;
+        sweeping?: boolean | undefined;
+        feed?: {
+            id: number;
+            total: number;
+            loaded: number;
+        } | undefined;
+        arrived?: number[] | undefined;
+    }, {
+        loaded: number;
+        state?: "cold" | "cached" | "failed" | undefined;
+        total?: number | undefined;
+        restored?: boolean | undefined;
+        sweeping?: boolean | undefined;
+        feed?: {
+            id: number;
+            total: number;
+            loaded: number;
+        } | undefined;
+        arrived?: number[] | undefined;
+    }>>;
+    procIndex: z.ZodOptional<z.ZodObject<{
+        jobs: z.ZodNumber;
+        feeds: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        feeds: number;
+        jobs: number;
+    }, {
+        feeds: number;
+        jobs: number;
+    }>>;
+    /**
+     * Warm-up steps that failed behind the prompt and have not since
+     * succeeded. Optional, so an older daemon still parses here.
+     */
+    warmupFailures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        message: string;
+    }, {
+        label: string;
+        message: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    user: string;
+    uri: string;
+    cwd: string;
+    pacsserver: string | null;
+    physicalMode: boolean;
+    lastExitCode: number;
+    lastCommandDurationMs: number;
+    procWarmup?: {
+        loaded: number;
+        state?: "cold" | "cached" | "failed" | undefined;
+        total?: number | undefined;
+        restored?: boolean | undefined;
+        sweeping?: boolean | undefined;
+        feed?: {
+            id: number;
+            total: number;
+            loaded: number;
+        } | undefined;
+        arrived?: number[] | undefined;
+    } | undefined;
+    procIndex?: {
+        feeds: number;
+        jobs: number;
+    } | undefined;
+    warmupFailures?: {
+        label: string;
+        message: string;
+    }[] | undefined;
+}, {
+    user: string;
+    uri: string;
+    cwd: string;
+    pacsserver: string | null;
+    physicalMode: boolean;
+    lastExitCode: number;
+    lastCommandDurationMs: number;
+    procWarmup?: {
+        loaded: number;
+        state?: "cold" | "cached" | "failed" | undefined;
+        total?: number | undefined;
+        restored?: boolean | undefined;
+        sweeping?: boolean | undefined;
+        feed?: {
+            id: number;
+            total: number;
+            loaded: number;
+        } | undefined;
+        arrived?: number[] | undefined;
+    } | undefined;
+    procIndex?: {
+        feeds: number;
+        jobs: number;
+    } | undefined;
+    warmupFailures?: {
+        label: string;
+        message: string;
+    }[] | undefined;
+}>;
+export type PromptContext = z.infer<typeof promptContextSchema>;
+/**
+ * The prompt context, pushed by the daemon with each result and on any context
+ * change. The daemon knows the session context; each surface renders it with
+ * its own theme, so prompt themes are a per-surface choice rather than the
+ * daemon's.
+ */
+export declare const promptLineMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"promptline">;
+    context: z.ZodObject<{
+        user: z.ZodString;
+        uri: z.ZodString;
+        cwd: z.ZodString;
+        pacsserver: z.ZodNullable<z.ZodString>;
+        physicalMode: z.ZodBoolean;
+        lastExitCode: z.ZodNumber;
+        lastCommandDurationMs: z.ZodNumber;
+        procWarmup: z.ZodOptional<z.ZodObject<{
+            loaded: z.ZodNumber;
+            total: z.ZodOptional<z.ZodNumber>;
+            restored: z.ZodOptional<z.ZodBoolean>;
+            state: z.ZodOptional<z.ZodEnum<["cold", "cached", "failed"]>>;
+            sweeping: z.ZodOptional<z.ZodBoolean>;
+            feed: z.ZodOptional<z.ZodObject<{
+                id: z.ZodNumber;
+                loaded: z.ZodNumber;
+                total: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                id: number;
+                total: number;
+                loaded: number;
+            }, {
+                id: number;
+                total: number;
+                loaded: number;
+            }>>;
+            arrived: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        }, {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        }>>;
+        procIndex: z.ZodOptional<z.ZodObject<{
+            jobs: z.ZodNumber;
+            feeds: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            feeds: number;
+            jobs: number;
+        }, {
+            feeds: number;
+            jobs: number;
+        }>>;
+        /**
+         * Warm-up steps that failed behind the prompt and have not since
+         * succeeded. Optional, so an older daemon still parses here.
+         */
+        warmupFailures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            message: string;
+        }, {
+            label: string;
+            message: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        user: string;
+        uri: string;
+        cwd: string;
+        pacsserver: string | null;
+        physicalMode: boolean;
+        lastExitCode: number;
+        lastCommandDurationMs: number;
+        procWarmup?: {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        } | undefined;
+        procIndex?: {
+            feeds: number;
+            jobs: number;
+        } | undefined;
+        warmupFailures?: {
+            label: string;
+            message: string;
+        }[] | undefined;
+    }, {
+        user: string;
+        uri: string;
+        cwd: string;
+        pacsserver: string | null;
+        physicalMode: boolean;
+        lastExitCode: number;
+        lastCommandDurationMs: number;
+        procWarmup?: {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        } | undefined;
+        procIndex?: {
+            feeds: number;
+            jobs: number;
+        } | undefined;
+        warmupFailures?: {
+            label: string;
+            message: string;
+        }[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "promptline";
+    context: {
+        user: string;
+        uri: string;
+        cwd: string;
+        pacsserver: string | null;
+        physicalMode: boolean;
+        lastExitCode: number;
+        lastCommandDurationMs: number;
+        procWarmup?: {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        } | undefined;
+        procIndex?: {
+            feeds: number;
+            jobs: number;
+        } | undefined;
+        warmupFailures?: {
+            label: string;
+            message: string;
+        }[] | undefined;
+    };
+}, {
+    type: "promptline";
+    context: {
+        user: string;
+        uri: string;
+        cwd: string;
+        pacsserver: string | null;
+        physicalMode: boolean;
+        lastExitCode: number;
+        lastCommandDurationMs: number;
+        procWarmup?: {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        } | undefined;
+        procIndex?: {
+            feeds: number;
+            jobs: number;
+        } | undefined;
+        warmupFailures?: {
+            label: string;
+            message: string;
+        }[] | undefined;
+    };
+}>;
+/**
+ * Asks the surface to run a pipeline segment on its own machine (never on the
+ * daemon host) and return the output. `input` and the reply's `output` are
+ * base64, since segment data is arbitrary bytes.
+ */
+export declare const pipeMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pipe">;
+    pipeId: z.ZodString;
+    command: z.ZodString;
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "pipe";
+    input: string;
+    pipeId: string;
+    command: string;
+}, {
+    type: "pipe";
+    input: string;
+    pipeId: string;
+    command: string;
+}>;
+/** Asks the surface to run a shell command on its own machine, never on the daemon host. */
+export declare const shellMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"shell">;
+    shellId: z.ZodString;
+    command: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "shell";
+    shellId: string;
+    command: string;
+}, {
+    type: "shell";
+    shellId: string;
+    command: string;
+}>;
+/**
+ * Asks the surface to open content in its local editor (never on the daemon
+ * host) and return the edited result.
+ */
+export declare const editMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"edit">;
+    editId: z.ZodString;
+    content: z.ZodString;
+    extension: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "edit";
+    editId: string;
+    content: string;
+    extension?: string | undefined;
+}, {
+    type: "edit";
+    editId: string;
+    content: string;
+    extension?: string | undefined;
+}>;
+/**
+ * Asks the surface running the current command to place a file where its
+ * operator can reach it.
+ *
+ * The message names what to deliver, never the bytes. A surface fetches those
+ * itself from the daemon's token-gated byte route, so a large file does not
+ * cross the session bus base64-encoded — the intent travels through the
+ * vocabulary and the bytes travel through the byte route.
+ */
+export declare const deliverMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"deliver">;
+    deliverId: z.ZodString;
+    path: z.ZodString;
+    filename: z.ZodString;
+    destination: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+    contentType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "deliver";
+    deliverId: string;
+    filename: string;
+    destination?: string | undefined;
+    size?: number | undefined;
+    contentType?: string | undefined;
+}, {
+    path: string;
+    type: "deliver";
+    deliverId: string;
+    filename: string;
+    destination?: string | undefined;
+    size?: number | undefined;
+    contentType?: string | undefined;
+}>;
+/** What to deliver, before the daemon adds the correlation id. */
+export type FileDeliverRequest = Omit<z.infer<typeof deliverMessageSchema>, 'type' | 'deliverId'>;
+/** Where a delivered file landed, as the surface reports it. */
+export type FileDeliverResult = Omit<z.infer<typeof deliverResultMessageSchema>, 'type' | 'deliverId'>;
+/**
+ * The daemon's heartbeat, pushed roughly once a second while any surface is
+ * attached: the live process-index counts. Event-driven facts (progress,
+ * command latency) travel on their own messages; this carries only what
+ * changes without a command.
+ */
+export declare const telemetryMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"telemetry">;
+    index: z.ZodObject<{
+        jobs: z.ZodNumber;
+        feeds: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        feeds: number;
+        jobs: number;
+    }, {
+        feeds: number;
+        jobs: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "telemetry";
+    index: {
+        feeds: number;
+        jobs: number;
+    };
+}, {
+    type: "telemetry";
+    index: {
+        feeds: number;
+        jobs: number;
+    };
+}>;
+/** Any message the daemon may send to a surface. */
+export declare const serverMessageSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"attached">;
+    session: z.ZodString;
+    protocolVersion: z.ZodNumber;
+    stack: z.ZodOptional<z.ZodObject<{
+        chell: z.ZodString;
+        calypso: z.ZodString;
+        build: z.ZodString;
+        brasa: z.ZodOptional<z.ZodString>;
+        chili: z.ZodOptional<z.ZodString>;
+        salsa: z.ZodOptional<z.ZodString>;
+        cumin: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chell: string;
+        calypso: string;
+        build: string;
+        brasa?: string | undefined;
+        chili?: string | undefined;
+        salsa?: string | undefined;
+        cumin?: string | undefined;
+    }, {
+        chell: string;
+        calypso: string;
+        build: string;
+        brasa?: string | undefined;
+        chili?: string | undefined;
+        salsa?: string | undefined;
+        cumin?: string | undefined;
+    }>>;
+    /** The host-control tiers the daemon declared (`shell`, `files`, `pipes`); empty or absent when off. */
+    hostControl: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "attached";
+    protocolVersion: number;
+    session: string;
+    stack?: {
+        chell: string;
+        calypso: string;
+        build: string;
+        brasa?: string | undefined;
+        chili?: string | undefined;
+        salsa?: string | undefined;
+        cumin?: string | undefined;
+    } | undefined;
+    hostControl?: string[] | undefined;
+}, {
+    type: "attached";
+    protocolVersion: number;
+    session: string;
+    stack?: {
+        chell: string;
+        calypso: string;
+        build: string;
+        brasa?: string | undefined;
+        chili?: string | undefined;
+        salsa?: string | undefined;
+        cumin?: string | undefined;
+    } | undefined;
+    hostControl?: string[] | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    id: z.ZodString;
+    envelopes: z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<["ok", "error"]>;
+        rendered: z.ZodString;
+        renderedErr: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodString;
+            data: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            kind: string;
+            data?: unknown;
+        }, {
+            kind: string;
+            data?: unknown;
+        }>>;
+        errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["error", "warning"]>;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            type: "error" | "warning";
+        }, {
+            message: string;
+            type: "error" | "warning";
+        }>, "many">>;
+        trace: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            proposed: z.ZodString;
+            validated: z.ZodBoolean;
+            executed: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        }, {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }, {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "result";
+    envelopes: {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }[];
+}, {
+    id: string;
+    type: "result";
+    envelopes: {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }[];
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"complete">;
+    id: z.ZodString;
+    prefix: z.ZodString;
+    candidates: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "complete";
+    prefix: string;
+    candidates: string[];
+}, {
+    id: string;
+    type: "complete";
+    prefix: string;
+    candidates: string[];
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"output">;
+    id: z.ZodString;
+    channel: z.ZodEnum<["data", "err", "status"]>;
+    chunk: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "output";
+    channel: "status" | "data" | "err";
+    chunk: string;
+}, {
+    id: string;
+    type: "output";
+    channel: "status" | "data" | "err";
+    chunk: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"progress">;
+    id: z.ZodString;
+    operation: z.ZodCatch<z.ZodEnum<["upload", "download", "pull", "workflow", "pipeline", "group", "task"]>>;
+    kind: z.ZodOptional<z.ZodCatch<z.ZodEnum<["transfer", "retrieve", "workflow", "inspection"]>>>;
+    phase: z.ZodCatch<z.ZodEnum<["scanning", "transferring", "watching", "retrying", "reading", "working", "complete", "failed"]>>;
+    label: z.ZodOptional<z.ZodString>;
+    itemId: z.ZodOptional<z.ZodString>;
+    current: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodOptional<z.ZodNumber>;
+    percent: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodCatch<z.ZodEnum<["files", "bytes", "series", "jobs", "nodes"]>>>;
+    status: z.ZodOptional<z.ZodCatch<z.ZodEnum<["running", "done", "unconfirmed", "stalled", "timeout", "error", "unknown"]>>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "progress";
+    operation: "upload" | "download" | "pull" | "workflow" | "pipeline" | "group" | "task";
+    phase: "failed" | "scanning" | "transferring" | "watching" | "retrying" | "reading" | "working" | "complete";
+    label?: string | undefined;
+    status?: "unknown" | "done" | "error" | "running" | "unconfirmed" | "stalled" | "timeout" | undefined;
+    kind?: "workflow" | "transfer" | "retrieve" | "inspection" | undefined;
+    itemId?: string | undefined;
+    current?: number | undefined;
+    total?: number | undefined;
+    percent?: number | undefined;
+    unit?: "nodes" | "files" | "bytes" | "series" | "jobs" | undefined;
+}, {
+    id: string;
+    type: "progress";
+    label?: string | undefined;
+    status?: unknown;
+    kind?: unknown;
+    operation?: unknown;
+    phase?: unknown;
+    itemId?: string | undefined;
+    current?: number | undefined;
+    total?: number | undefined;
+    percent?: number | undefined;
+    unit?: unknown;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"session">;
+    surface: z.ZodString;
+    envelope: z.ZodObject<{
+        status: z.ZodEnum<["ok", "error"]>;
+        rendered: z.ZodString;
+        renderedErr: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodString;
+            data: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            kind: string;
+            data?: unknown;
+        }, {
+            kind: string;
+            data?: unknown;
+        }>>;
+        errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["error", "warning"]>;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            type: "error" | "warning";
+        }, {
+            message: string;
+            type: "error" | "warning";
+        }>, "many">>;
+        trace: z.ZodOptional<z.ZodObject<{
+            input: z.ZodString;
+            proposed: z.ZodString;
+            validated: z.ZodBoolean;
+            executed: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        }, {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }, {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "session";
+    envelope: {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    };
+    surface: string;
+}, {
+    type: "session";
+    envelope: {
+        status: "error" | "ok";
+        rendered: string;
+        renderedErr?: string | undefined;
+        model?: {
+            kind: string;
+            data?: unknown;
+        } | undefined;
+        errors?: {
+            message: string;
+            type: "error" | "warning";
+        }[] | undefined;
+        trace?: {
+            input: string;
+            proposed: string;
+            validated: boolean;
+            executed?: string | undefined;
+        } | undefined;
+    };
+    surface: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    id: z.ZodOptional<z.ZodString>;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "error";
+    reason: string;
+    id?: string | undefined;
+}, {
+    type: "error";
+    reason: string;
+    id?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"prompt">;
+    promptId: z.ZodString;
+    message: z.ZodString;
+    hidden: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "prompt";
+    promptId: string;
+    hidden: boolean;
+}, {
+    message: string;
+    type: "prompt";
+    promptId: string;
+    hidden: boolean;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"promptline">;
+    context: z.ZodObject<{
+        user: z.ZodString;
+        uri: z.ZodString;
+        cwd: z.ZodString;
+        pacsserver: z.ZodNullable<z.ZodString>;
+        physicalMode: z.ZodBoolean;
+        lastExitCode: z.ZodNumber;
+        lastCommandDurationMs: z.ZodNumber;
+        procWarmup: z.ZodOptional<z.ZodObject<{
+            loaded: z.ZodNumber;
+            total: z.ZodOptional<z.ZodNumber>;
+            restored: z.ZodOptional<z.ZodBoolean>;
+            state: z.ZodOptional<z.ZodEnum<["cold", "cached", "failed"]>>;
+            sweeping: z.ZodOptional<z.ZodBoolean>;
+            feed: z.ZodOptional<z.ZodObject<{
+                id: z.ZodNumber;
+                loaded: z.ZodNumber;
+                total: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                id: number;
+                total: number;
+                loaded: number;
+            }, {
+                id: number;
+                total: number;
+                loaded: number;
+            }>>;
+            arrived: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        }, {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        }>>;
+        procIndex: z.ZodOptional<z.ZodObject<{
+            jobs: z.ZodNumber;
+            feeds: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            feeds: number;
+            jobs: number;
+        }, {
+            feeds: number;
+            jobs: number;
+        }>>;
+        /**
+         * Warm-up steps that failed behind the prompt and have not since
+         * succeeded. Optional, so an older daemon still parses here.
+         */
+        warmupFailures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            message: string;
+        }, {
+            label: string;
+            message: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        user: string;
+        uri: string;
+        cwd: string;
+        pacsserver: string | null;
+        physicalMode: boolean;
+        lastExitCode: number;
+        lastCommandDurationMs: number;
+        procWarmup?: {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        } | undefined;
+        procIndex?: {
+            feeds: number;
+            jobs: number;
+        } | undefined;
+        warmupFailures?: {
+            label: string;
+            message: string;
+        }[] | undefined;
+    }, {
+        user: string;
+        uri: string;
+        cwd: string;
+        pacsserver: string | null;
+        physicalMode: boolean;
+        lastExitCode: number;
+        lastCommandDurationMs: number;
+        procWarmup?: {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        } | undefined;
+        procIndex?: {
+            feeds: number;
+            jobs: number;
+        } | undefined;
+        warmupFailures?: {
+            label: string;
+            message: string;
+        }[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "promptline";
+    context: {
+        user: string;
+        uri: string;
+        cwd: string;
+        pacsserver: string | null;
+        physicalMode: boolean;
+        lastExitCode: number;
+        lastCommandDurationMs: number;
+        procWarmup?: {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        } | undefined;
+        procIndex?: {
+            feeds: number;
+            jobs: number;
+        } | undefined;
+        warmupFailures?: {
+            label: string;
+            message: string;
+        }[] | undefined;
+    };
+}, {
+    type: "promptline";
+    context: {
+        user: string;
+        uri: string;
+        cwd: string;
+        pacsserver: string | null;
+        physicalMode: boolean;
+        lastExitCode: number;
+        lastCommandDurationMs: number;
+        procWarmup?: {
+            loaded: number;
+            state?: "cold" | "cached" | "failed" | undefined;
+            total?: number | undefined;
+            restored?: boolean | undefined;
+            sweeping?: boolean | undefined;
+            feed?: {
+                id: number;
+                total: number;
+                loaded: number;
+            } | undefined;
+            arrived?: number[] | undefined;
+        } | undefined;
+        procIndex?: {
+            feeds: number;
+            jobs: number;
+        } | undefined;
+        warmupFailures?: {
+            label: string;
+            message: string;
+        }[] | undefined;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"telemetry">;
+    index: z.ZodObject<{
+        jobs: z.ZodNumber;
+        feeds: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        feeds: number;
+        jobs: number;
+    }, {
+        feeds: number;
+        jobs: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "telemetry";
+    index: {
+        feeds: number;
+        jobs: number;
+    };
+}, {
+    type: "telemetry";
+    index: {
+        feeds: number;
+        jobs: number;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"pipe">;
+    pipeId: z.ZodString;
+    command: z.ZodString;
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "pipe";
+    input: string;
+    pipeId: string;
+    command: string;
+}, {
+    type: "pipe";
+    input: string;
+    pipeId: string;
+    command: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"shell">;
+    shellId: z.ZodString;
+    command: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "shell";
+    shellId: string;
+    command: string;
+}, {
+    type: "shell";
+    shellId: string;
+    command: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"edit">;
+    editId: z.ZodString;
+    content: z.ZodString;
+    extension: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "edit";
+    editId: string;
+    content: string;
+    extension?: string | undefined;
+}, {
+    type: "edit";
+    editId: string;
+    content: string;
+    extension?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"deliver">;
+    deliverId: z.ZodString;
+    path: z.ZodString;
+    filename: z.ZodString;
+    destination: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+    contentType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "deliver";
+    deliverId: string;
+    filename: string;
+    destination?: string | undefined;
+    size?: number | undefined;
+    contentType?: string | undefined;
+}, {
+    path: string;
+    type: "deliver";
+    deliverId: string;
+    filename: string;
+    destination?: string | undefined;
+    size?: number | undefined;
+    contentType?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"regard">;
+    regard: z.ZodObject<{
+        address: z.ZodString;
+        modelKind: z.ZodOptional<z.ZodString>;
+        groupId: z.ZodString;
+        paneId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    }, {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "regard";
+    regard: {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    };
+}, {
+    type: "regard";
+    regard: {
+        address: string;
+        groupId: string;
+        paneId: string;
+        modelKind?: string | undefined;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"watched">;
+    subject: z.ZodString;
+    state: z.ZodEnum<["live", "settled", "stale"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "watched";
+    subject: string;
+    state: "live" | "settled" | "stale";
+}, {
+    type: "watched";
+    subject: string;
+    state: "live" | "settled" | "stale";
+}>]>;
+/** A message the daemon sends to a surface. */
+export type ServerMessage = z.infer<typeof serverMessageSchema>;
+/**
+ * The message types this contract build knows. A surface receiving a typed
+ * message outside this set is talking to a newer daemon: the open-world rule
+ * is to skip it quietly, not to warn on every arrival.
+ */
+export declare const SERVER_MESSAGE_TYPES: ReadonlySet<string>;