@fnndsc/menu 0.3.1

package/README.md

@@ -0,0 +1,59 @@
+# @fnndsc/menu
+
+The mise wire contract: what a command returns, what a session exchanges, and
+the vocabularies both narrow to.
+
+A menu declares what may be ordered and what arrives. A surface can ask for
+anything on it and nothing off it, which is the architectural claim this
+package exists to make structural: no capability exists outside the kernel and
+the wire, while every surface is free to compose and present as it likes above
+that line.
+
+## What's in it
+
+| Module | Contents |
+| --- | --- |
+| `envelope.ts` | `CommandEnvelope` and its parts — status, typed model slot, error stack, resolution trace |
+| `messages.ts` | The session protocol: attach, execute, complete, output, progress, prompt, pipe, shell, edit |
+| `validate.ts` | Boundary parsing that never throws — a `ParseResult`, so a caller can answer rather than crash |
+| `version.ts` | `CONTRACT_VERSION` and its exact-major compatibility rule |
+| `progress.ts` | The structured-progress vocabulary |
+| `proc.ts` | Prompt-facing process-index state |
+
+## Why it is its own package
+
+A surface author depends on the contract, not on the daemon that happens to
+serve it. Before this package the contract was a subpath of `@fnndsc/calypso`,
+which meant a third-party surface took a dependency on the session host to
+learn the shape of a result.
+
+It imports nothing from the stack — `zod` and nothing else — and sits below
+`cumin`, so both the engine that produces envelopes and the browser that renders
+them can load it.
+
+## Rules that hold here
+
+**Open world.** An envelope's `model.kind` is a free string: a surface narrows
+what it recognises and falls back to `rendered` for the rest. Unknown enum
+values degrade rather than reject — an unknown progress operation reads as
+`task`, an unknown phase as `working` — because a dropped message is invisible
+and a generic indicator is not.
+
+**Never `.strict()`.** A plain `z.object()` strips unknown keys, so a field
+added by a newer peer is ignored rather than fatal. `.strict()` looks like
+rigour and is a compatibility break.
+
+**A new enum value ships with a fallback.** `safeParse` fails a whole message on
+one unknown value. When you add to an enum on the wire, give it a `.catch()` in
+the same change if it has none.
+
+**Types are inferred, never declared twice.** Payload types come from
+`z.infer<typeof schema>`. The envelope and the wire once carried separate
+declarations held together by a compile-time assertion; one inferred type makes
+that drift impossible rather than detected.
+
+## See also
+
+- `docs/menu.adoc` — the design record and the plan this package is part of
+- `docs/principles.adoc` — the normative architecture
+- `docs/structured-progress.md` — the progress contract in detail

package/dist/dag.d.ts

@@ -0,0 +1,629 @@
+/**
+ * @file The DAG model vocabulary: compute graphs as typed envelope payloads.
+ *
+ * ChRIS is a data-state machine and the execution DAG is its central object:
+ * nodes are plugin (instances), edges are data states flowing between their
+ * directories. Two commands project that object onto the wire — a registered
+ * pipeline's authored template (`pipeline.diagram`) and a feed's live
+ * instance graph (`feed.dag`) — and both share one structural core so a
+ * renderer owns a single traversal and layout path.
+ *
+ * Models carry topology, addresses, status, and metrics — never layout.
+ * How a graph is drawn (ranked tiers, a force-settled molecule, a header
+ * miniature) is a surface concern; the model must serve them all.
+ *
+ * @module
+ */
+import { z } from 'zod';
+/**
+ * The structural core every DAG node shares: identity, a label, and its
+ * incoming edges. `parentIds` carries the primary data-flow edges;
+ * `joinParentIds` carries additional (topological join) edges, drawn
+ * differently but traversed the same.
+ */
+export declare const dagNodeCoreSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    parentIds: z.ZodArray<z.ZodString, "many">;
+    joinParentIds: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: string;
+    parentIds: string[];
+    joinParentIds: string[];
+}, {
+    id: string;
+    label: string;
+    parentIds: string[];
+    joinParentIds: string[];
+}>;
+/** One stored default argument on an authored pipeline node. */
+export declare const dagArgumentSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    value?: unknown;
+}, {
+    name: string;
+    value?: unknown;
+}>;
+/** A node in a registered pipeline's authored template. */
+export declare const pipelineDiagramNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    parentIds: z.ZodArray<z.ZodString, "many">;
+    joinParentIds: z.ZodArray<z.ZodString, "many">;
+} & {
+    pluginName: z.ZodString;
+    pluginVersion: z.ZodOptional<z.ZodString>;
+    arguments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        value?: unknown;
+    }, {
+        name: string;
+        value?: unknown;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: string;
+    parentIds: string[];
+    joinParentIds: string[];
+    pluginName: string;
+    pluginVersion?: string | undefined;
+    arguments?: {
+        name: string;
+        value?: unknown;
+    }[] | undefined;
+}, {
+    id: string;
+    label: string;
+    parentIds: string[];
+    joinParentIds: string[];
+    pluginName: string;
+    pluginVersion?: string | undefined;
+    arguments?: {
+        name: string;
+        value?: unknown;
+    }[] | undefined;
+}>;
+/**
+ * The `pipeline.diagram` model: a registered pipeline's authored DAG.
+ * Static — it describes what would run, not anything running.
+ */
+export declare const pipelineDiagramModelSchema: z.ZodObject<{
+    name: z.ZodString;
+    pipelineId: z.ZodOptional<z.ZodNumber>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        parentIds: z.ZodArray<z.ZodString, "many">;
+        joinParentIds: z.ZodArray<z.ZodString, "many">;
+    } & {
+        pluginName: z.ZodString;
+        pluginVersion: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            value?: unknown;
+        }, {
+            name: string;
+            value?: unknown;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        parentIds: string[];
+        joinParentIds: string[];
+        pluginName: string;
+        pluginVersion?: string | undefined;
+        arguments?: {
+            name: string;
+            value?: unknown;
+        }[] | undefined;
+    }, {
+        id: string;
+        label: string;
+        parentIds: string[];
+        joinParentIds: string[];
+        pluginName: string;
+        pluginVersion?: string | undefined;
+        arguments?: {
+            name: string;
+            value?: unknown;
+        }[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    nodes: {
+        id: string;
+        label: string;
+        parentIds: string[];
+        joinParentIds: string[];
+        pluginName: string;
+        pluginVersion?: string | undefined;
+        arguments?: {
+            name: string;
+            value?: unknown;
+        }[] | undefined;
+    }[];
+    pipelineId?: number | undefined;
+}, {
+    name: string;
+    nodes: {
+        id: string;
+        label: string;
+        parentIds: string[];
+        joinParentIds: string[];
+        pluginName: string;
+        pluginVersion?: string | undefined;
+        arguments?: {
+            name: string;
+            value?: unknown;
+        }[] | undefined;
+    }[];
+    pipelineId?: number | undefined;
+}>;
+/**
+ * A live node's execution state. Open-world: an unrecognized status from a
+ * newer daemon degrades to 'unknown' rather than failing the parse.
+ */
+export declare const DAG_NODE_STATUSES: readonly ["created", "waiting", "scheduled", "started", "registeringFiles", "finishedSuccessfully", "finishedWithError", "cancelled", "unknown"];
+export declare const dagNodeStatusSchema: z.ZodCatch<z.ZodEnum<["created", "waiting", "scheduled", "started", "registeringFiles", "finishedSuccessfully", "finishedWithError", "cancelled", "unknown"]>>;
+/**
+ * Roll-up of an isomorphic ×N group collapsed behind one rendered node.
+ * Present only when `count > 1`; error visibility is not optional — a group
+ * carrying failures lists its first anomalous members for jump-to-error.
+ */
+export declare const dagNodeTallySchema: z.ZodObject<{
+    count: z.ZodNumber;
+    done: z.ZodNumber;
+    error: z.ZodNumber;
+    running: z.ZodNumber;
+    other: z.ZodNumber;
+    anomalies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodCatch<z.ZodEnum<["created", "waiting", "scheduled", "started", "registeringFiles", "finishedSuccessfully", "finishedWithError", "cancelled", "unknown"]>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+    }, {
+        id: string;
+        status?: unknown;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    count: number;
+    done: number;
+    error: number;
+    running: number;
+    other: number;
+    anomalies?: {
+        id: string;
+        status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+    }[] | undefined;
+}, {
+    count: number;
+    done: number;
+    error: number;
+    running: number;
+    other: number;
+    anomalies?: {
+        id: string;
+        status?: unknown;
+    }[] | undefined;
+}>;
+export type DagNodeTally = z.infer<typeof dagNodeTallySchema>;
+/** Per-node measurables that scale a molecule rendering. */
+export declare const dagNodeMetricsSchema: z.ZodObject<{
+    computeSeconds: z.ZodOptional<z.ZodNumber>;
+    dataBytes: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    computeSeconds?: number | undefined;
+    dataBytes?: number | undefined;
+}, {
+    computeSeconds?: number | undefined;
+    dataBytes?: number | undefined;
+}>;
+/**
+ * A node in a feed's live instance graph. `vfsPath` is the node's data
+ * space — the same address the terminal and the files panel navigate, which
+ * is what makes "fly into a node" a `cd` rather than a new machine.
+ */
+export declare const feedDagNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    parentIds: z.ZodArray<z.ZodString, "many">;
+    joinParentIds: z.ZodArray<z.ZodString, "many">;
+} & {
+    instanceId: z.ZodNumber;
+    pluginName: z.ZodString;
+    pluginVersion: z.ZodOptional<z.ZodString>;
+    status: z.ZodCatch<z.ZodEnum<["created", "waiting", "scheduled", "started", "registeringFiles", "finishedSuccessfully", "finishedWithError", "cancelled", "unknown"]>>;
+    vfsPath: z.ZodString;
+    metrics: z.ZodOptional<z.ZodObject<{
+        computeSeconds: z.ZodOptional<z.ZodNumber>;
+        dataBytes: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        computeSeconds?: number | undefined;
+        dataBytes?: number | undefined;
+    }, {
+        computeSeconds?: number | undefined;
+        dataBytes?: number | undefined;
+    }>>;
+    tally: z.ZodOptional<z.ZodObject<{
+        count: z.ZodNumber;
+        done: z.ZodNumber;
+        error: z.ZodNumber;
+        running: z.ZodNumber;
+        other: z.ZodNumber;
+        anomalies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodCatch<z.ZodEnum<["created", "waiting", "scheduled", "started", "registeringFiles", "finishedSuccessfully", "finishedWithError", "cancelled", "unknown"]>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+        }, {
+            id: string;
+            status?: unknown;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        count: number;
+        done: number;
+        error: number;
+        running: number;
+        other: number;
+        anomalies?: {
+            id: string;
+            status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+        }[] | undefined;
+    }, {
+        count: number;
+        done: number;
+        error: number;
+        running: number;
+        other: number;
+        anomalies?: {
+            id: string;
+            status?: unknown;
+        }[] | undefined;
+    }>>;
+    /** Where the job ran; `mixed` for a group whose members ran on different resources. */
+    computeResource: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: string;
+    parentIds: string[];
+    status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+    joinParentIds: string[];
+    pluginName: string;
+    instanceId: number;
+    vfsPath: string;
+    pluginVersion?: string | undefined;
+    metrics?: {
+        computeSeconds?: number | undefined;
+        dataBytes?: number | undefined;
+    } | undefined;
+    tally?: {
+        count: number;
+        done: number;
+        error: number;
+        running: number;
+        other: number;
+        anomalies?: {
+            id: string;
+            status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+        }[] | undefined;
+    } | undefined;
+    computeResource?: string | undefined;
+}, {
+    id: string;
+    label: string;
+    parentIds: string[];
+    joinParentIds: string[];
+    pluginName: string;
+    instanceId: number;
+    vfsPath: string;
+    status?: unknown;
+    pluginVersion?: string | undefined;
+    metrics?: {
+        computeSeconds?: number | undefined;
+        dataBytes?: number | undefined;
+    } | undefined;
+    tally?: {
+        count: number;
+        done: number;
+        error: number;
+        running: number;
+        other: number;
+        anomalies?: {
+            id: string;
+            status?: unknown;
+        }[] | undefined;
+    } | undefined;
+    computeResource?: string | undefined;
+}>;
+/**
+ * The `feed.dag` model: one feed's live execution graph. Topology arrives
+ * once on the command envelope; status changes ride the typed progress
+ * channel rather than re-sending the graph.
+ */
+export declare const feedDagModelSchema: z.ZodObject<{
+    feedId: z.ZodNumber;
+    feedName: z.ZodString;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        parentIds: z.ZodArray<z.ZodString, "many">;
+        joinParentIds: z.ZodArray<z.ZodString, "many">;
+    } & {
+        instanceId: z.ZodNumber;
+        pluginName: z.ZodString;
+        pluginVersion: z.ZodOptional<z.ZodString>;
+        status: z.ZodCatch<z.ZodEnum<["created", "waiting", "scheduled", "started", "registeringFiles", "finishedSuccessfully", "finishedWithError", "cancelled", "unknown"]>>;
+        vfsPath: z.ZodString;
+        metrics: z.ZodOptional<z.ZodObject<{
+            computeSeconds: z.ZodOptional<z.ZodNumber>;
+            dataBytes: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            computeSeconds?: number | undefined;
+            dataBytes?: number | undefined;
+        }, {
+            computeSeconds?: number | undefined;
+            dataBytes?: number | undefined;
+        }>>;
+        tally: z.ZodOptional<z.ZodObject<{
+            count: z.ZodNumber;
+            done: z.ZodNumber;
+            error: z.ZodNumber;
+            running: z.ZodNumber;
+            other: z.ZodNumber;
+            anomalies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                status: z.ZodCatch<z.ZodEnum<["created", "waiting", "scheduled", "started", "registeringFiles", "finishedSuccessfully", "finishedWithError", "cancelled", "unknown"]>>;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+            }, {
+                id: string;
+                status?: unknown;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            count: number;
+            done: number;
+            error: number;
+            running: number;
+            other: number;
+            anomalies?: {
+                id: string;
+                status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+            }[] | undefined;
+        }, {
+            count: number;
+            done: number;
+            error: number;
+            running: number;
+            other: number;
+            anomalies?: {
+                id: string;
+                status?: unknown;
+            }[] | undefined;
+        }>>;
+        /** Where the job ran; `mixed` for a group whose members ran on different resources. */
+        computeResource: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        parentIds: string[];
+        status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+        joinParentIds: string[];
+        pluginName: string;
+        instanceId: number;
+        vfsPath: string;
+        pluginVersion?: string | undefined;
+        metrics?: {
+            computeSeconds?: number | undefined;
+            dataBytes?: number | undefined;
+        } | undefined;
+        tally?: {
+            count: number;
+            done: number;
+            error: number;
+            running: number;
+            other: number;
+            anomalies?: {
+                id: string;
+                status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+            }[] | undefined;
+        } | undefined;
+        computeResource?: string | undefined;
+    }, {
+        id: string;
+        label: string;
+        parentIds: string[];
+        joinParentIds: string[];
+        pluginName: string;
+        instanceId: number;
+        vfsPath: string;
+        status?: unknown;
+        pluginVersion?: string | undefined;
+        metrics?: {
+            computeSeconds?: number | undefined;
+            dataBytes?: number | undefined;
+        } | undefined;
+        tally?: {
+            count: number;
+            done: number;
+            error: number;
+            running: number;
+            other: number;
+            anomalies?: {
+                id: string;
+                status?: unknown;
+            }[] | undefined;
+        } | undefined;
+        computeResource?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    nodes: {
+        id: string;
+        label: string;
+        parentIds: string[];
+        status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+        joinParentIds: string[];
+        pluginName: string;
+        instanceId: number;
+        vfsPath: string;
+        pluginVersion?: string | undefined;
+        metrics?: {
+            computeSeconds?: number | undefined;
+            dataBytes?: number | undefined;
+        } | undefined;
+        tally?: {
+            count: number;
+            done: number;
+            error: number;
+            running: number;
+            other: number;
+            anomalies?: {
+                id: string;
+                status: "unknown" | "created" | "waiting" | "scheduled" | "started" | "registeringFiles" | "finishedSuccessfully" | "finishedWithError" | "cancelled";
+            }[] | undefined;
+        } | undefined;
+        computeResource?: string | undefined;
+    }[];
+    feedId: number;
+    feedName: string;
+}, {
+    nodes: {
+        id: string;
+        label: string;
+        parentIds: string[];
+        joinParentIds: string[];
+        pluginName: string;
+        instanceId: number;
+        vfsPath: string;
+        status?: unknown;
+        pluginVersion?: string | undefined;
+        metrics?: {
+            computeSeconds?: number | undefined;
+            dataBytes?: number | undefined;
+        } | undefined;
+        tally?: {
+            count: number;
+            done: number;
+            error: number;
+            running: number;
+            other: number;
+            anomalies?: {
+                id: string;
+                status?: unknown;
+            }[] | undefined;
+        } | undefined;
+        computeResource?: string | undefined;
+    }[];
+    feedId: number;
+    feedName: string;
+}>;
+export type DagNodeCore = z.infer<typeof dagNodeCoreSchema>;
+export type PipelineDiagramNode = z.infer<typeof pipelineDiagramNodeSchema>;
+export type PipelineDiagramModel = z.infer<typeof pipelineDiagramModelSchema>;
+export type DagNodeStatus = z.infer<typeof dagNodeStatusSchema>;
+export type DagNodeMetrics = z.infer<typeof dagNodeMetricsSchema>;
+export type FeedDagNode = z.infer<typeof feedDagNodeSchema>;
+export type FeedDagModel = z.infer<typeof feedDagModelSchema>;
+/** The envelope model kinds this vocabulary defines. */
+export declare const DAG_MODEL_KINDS: {
+    readonly pipelineDiagram: "pipeline.diagram";
+    readonly feedDag: "feed.dag";
+};
+/** One feed in the titled chooser list, from the process cache. */
+export declare const feedListEntrySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodString;
+    owner: z.ZodString;
+    status: z.ZodString;
+    createdAt: z.ZodString;
+    /** Total output bytes across the feed's nodes; absent until its topology is resident. */
+    sizeBytes: z.ZodOptional<z.ZodNumber>;
+    /** Wall span in seconds, first node start to last node end (or now, while running); absent until resident. */
+    wallSeconds: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    status: string;
+    title: string;
+    owner: string;
+    createdAt: string;
+    sizeBytes?: number | undefined;
+    wallSeconds?: number | undefined;
+}, {
+    id: number;
+    status: string;
+    title: string;
+    owner: string;
+    createdAt: string;
+    sizeBytes?: number | undefined;
+    wallSeconds?: number | undefined;
+}>;
+/**
+ * The `feed.list` model: the cache-resident feed roster — id, title, and
+ * derived status, with no CUBE round-trip. The DAG pane's chooser reads it;
+ * the terminal reads the same command's rendered lines.
+ */
+export declare const feedListModelSchema: z.ZodObject<{
+    feeds: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodString;
+        owner: z.ZodString;
+        status: z.ZodString;
+        createdAt: z.ZodString;
+        /** Total output bytes across the feed's nodes; absent until its topology is resident. */
+        sizeBytes: z.ZodOptional<z.ZodNumber>;
+        /** Wall span in seconds, first node start to last node end (or now, while running); absent until resident. */
+        wallSeconds: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        status: string;
+        title: string;
+        owner: string;
+        createdAt: string;
+        sizeBytes?: number | undefined;
+        wallSeconds?: number | undefined;
+    }, {
+        id: number;
+        status: string;
+        title: string;
+        owner: string;
+        createdAt: string;
+        sizeBytes?: number | undefined;
+        wallSeconds?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    feeds: {
+        id: number;
+        status: string;
+        title: string;
+        owner: string;
+        createdAt: string;
+        sizeBytes?: number | undefined;
+        wallSeconds?: number | undefined;
+    }[];
+}, {
+    feeds: {
+        id: number;
+        status: string;
+        title: string;
+        owner: string;
+        createdAt: string;
+        sizeBytes?: number | undefined;
+        wallSeconds?: number | undefined;
+    }[];
+}>;
+export type FeedListEntry = z.infer<typeof feedListEntrySchema>;
+export type FeedListModel = z.infer<typeof feedListModelSchema>;
+/** The chooser model's envelope kind. */
+export declare const FEED_LIST_MODEL_KIND: "feed.list";