@mostra/react 0.0.0-stage → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,412 @@
+import { ArtifactManifest, ArtifactManifest as ArtifactManifest$1, Bridge, DeliveryTarget, FieldScope, RunProgress, RunStatus, SubmissionSummary, SubmissionSummary as SubmissionSummary$1, SubmitBlocker, SubmitBlocker as SubmitBlocker$1, UiInitializeResult, Viewer } from "@mostra/protocol";
+import { ComponentType, ReactNode } from "react";
+//#region src/runtime/store.d.ts
+/** The submission state `useSubmit` reports (INTERFACES §2.3). */
+type SubmitState = "open" | "submitting" | "submitted" | "delivered" | "pending-delivery" | "undeliverable" | "closed";
+//#endregion
+//#region src/hooks.d.ts
+/** Where the artifact runs (D111): Mostra's gateway, a static export, an MCP App, or `verify`. */
+type ArtifactMode = "live" | "static" | "mcp-app" | "verify";
+/**
+ * A Standard Schema validator (`~standard`), such as a Zod 4 schema: what `validate` takes besides
+ * a function.
+ */
+interface StandardSchema<T> {
+  /** The Standard Schema interface (version 1). */
+  readonly "~standard": {
+    /** Checks a value: issues when it is invalid. */
+    validate(value: unknown): {
+      readonly issues?: readonly {
+        readonly message: string;
+      }[];
+    } | Promise<unknown>;
+    /** The type the schema accepts. */
+    readonly types?: {
+      readonly input: T;
+      readonly output: T;
+    } | undefined;
+  };
+}
+/** Options of {@link useField} (D52). */
+interface FieldOptions<T> {
+  /** The label people see in results and the shell's list of missing answers. */
+  readonly label?: string;
+  /** A submit needs a value: the shell and `useSubmit` list it until it has one. */
+  readonly required?: boolean;
+  /** Kept in the submission, left out of events and logs. */
+  readonly sensitive?: boolean;
+  /** A Zod (or any Standard Schema) schema, or a function returning a message for a bad value. */
+  readonly validate?: StandardSchema<T> | ((value: T) => string | undefined);
+  /** `viewer` (default): the viewer's draft. `artifact`: shared state every viewer sees (D63). */
+  readonly scope?: FieldScope;
+}
+/** What a field is doing (INTERFACES §2.3). */
+interface FieldMeta<T> {
+  /**
+   * `saved`; `saving`; `offline` (not saved yet: no connection, or the gateway refused it, with
+   * `error`); `conflict` (another writer changed it: see `conflict`); `readonly` (submitted under
+   * `once`, a view-only link, or a copy of the page without a Mostra server).
+   */
+  readonly save: "saved" | "saving" | "offline" | "conflict" | "readonly";
+  /** The validation message for the current value, or why the gateway refused it. */
+  readonly error?: string;
+  /** Another writer changed the field since the viewer's edit: keep theirs or mine. */
+  readonly conflict?: {
+    readonly theirs: T;
+    keepMine(): void;
+    takeTheirs(): void;
+  };
+  /** Who last wrote the field (artifact scope, D63). */
+  readonly updatedBy?: {
+    readonly kind: "viewer" | "agent" | "host";
+    readonly name?: string;
+  };
+}
+/**
+ * A persisted value with a stable field ID (D52). It behaves like `useState`: the value the viewer
+ * sees, a setter, and what the field is doing. Edits save to Mostra as the viewer works, survive
+ * reloads, closed tabs and other devices, reach other tabs, and carry over to newer versions by
+ * ID. Dotted IDs (`reply.m1`) nest in results.
+ *
+ * ```tsx
+ * const [layout, setLayout, meta] = useField("layout", "a", { label: "Layout", required: true });
+ * ```
+ */
+export declare function useField<T>(id: string, initial: T, options?: FieldOptions<NoInfer<T>>): [T, (next: T | ((previous: T) => T)) => void, FieldMeta<T>];
+/** What `useSubmit` returns (INTERFACES §2.3). */
+interface SubmitHandle {
+  /**
+   * Submits the viewer's draft through the artifact's own code (D40). Rejects with
+   * `MOSTRA_SUBMIT_CHANNEL_DENIED` where the host takes the shell's trusted Submit only,
+   * `MOSTRA_SUBMIT_BLOCKED` while a field blocks, `MOSTRA_SUBMIT_ALREADY` under a closed `once`.
+   */
+  submit(): Promise<SubmissionSummary$1>;
+  /** Whether `submit()` can work here: the host allows the artifact channel and the draft is open. */
+  readonly allowed: boolean;
+  /** What blocks a submit now. */
+  readonly blockers: readonly SubmitBlocker$1[];
+  /** Where the submission stands (IN-13). */
+  readonly state: SubmitState;
+  /** The viewer's submission, once made. */
+  readonly submission?: {
+    readonly id: string;
+    readonly at: string;
+  };
+}
+/** The artifact channel's submit, the blockers and the submission's state (D40, IN-13). */
+export declare function useSubmit(): SubmitHandle;
+/**
+ * Relabels the shell's trusted Submit while mounted, and asks the shell to confirm with `confirm`
+ * first (D06, SH-02). The artifact asks; the shell renders the control in its own origin, where
+ * the artifact can't reach it.
+ */
+export declare function useSubmitControl(options: {
+  readonly label?: string;
+  readonly confirm?: string;
+}): void;
+/** A named signal for the host's attention (IN-09), such as "Ping the agent". */
+export declare function useSignal(name: string): {
+  send(payload?: unknown): Promise<void>;
+};
+/** A review set's candidate, as the trusted Choose names it. */
+interface ChoiceCandidate {
+  /** The candidate's ID: the choice's value. */
+  readonly id: string;
+  /** The name the trusted Choose shows ("Choose Dense"), and results label it with. */
+  readonly label?: string;
+}
+/**
+ * A review set's choice (D65, D113): the field `review.<reviewSetId>.choice`. With `candidates`,
+ * the shell renders a trusted Choose for the candidate the page shows (`current`); `choose()`
+ * chooses from inside the page where the host allows the artifact channel (D40), else rejects
+ * with `MOSTRA_SUBMIT_CHANNEL_DENIED`.
+ */
+export declare function useChoice(reviewSetId: string, options?: {
+  readonly candidates?: readonly ChoiceCandidate[];
+  readonly current?: string;
+}): {
+  readonly choice?: string;
+  choose(candidateId: string): Promise<void>;
+};
+/** Who the page acts as (D104): the home's local user, a tailnet user, or a link's person. */
+export declare function useViewer(): {
+  readonly id: string;
+  readonly name?: string;
+  readonly source: "local" | "tailnet" | "token" | "host";
+};
+/** The artifact, the version and the view the page shows, and where it runs (D104, D111). */
+export declare function useArtifact(): {
+  readonly id: string;
+  readonly versionId: string;
+  readonly version: number;
+  readonly viewId: string;
+  readonly mode: ArtifactMode;
+};
+//#endregion
+//#region src/shell-bridge.d.ts
+/** The shell connection of this page, once it is established. */
+interface ShellConnection {
+  /** The shell's origin. */
+  readonly shellOrigin: string;
+  /** What the shell said about where the page is shown, and the view (`host.mostra`). */
+  readonly host: UiInitializeResult;
+  /** The bridge, for the client runtime's messages. */
+  readonly bridge: Bridge;
+  /**
+   * The frame session's facts: its CSRF token, the link's scopes (D97, D98) and, from gateways
+   * since WP-07, the viewer it acts as.
+   */
+  readonly session: {
+    readonly csrf: string;
+    readonly scopes: readonly string[];
+    readonly viewer?: Viewer;
+  };
+}
+/**
+ * Connects this page to the shell that frames it, once; later calls return the same connection.
+ * Resolves `undefined` when the page isn't framed by a Mostra shell. The client runtime calls it;
+ * artifact code doesn't need to.
+ */
+export declare function connectShell(): Promise<ShellConnection | undefined>;
+/**
+ * Tells the shell the page has rendered (`mostra/ready`), after the next frame paints. The
+ * client runtime calls it right after mounting the page.
+ */
+export declare function reportReady(): void;
+/**
+ * Opens `url` for the viewer in a new tab. Inside Mostra's shell the frame can't navigate the
+ * viewer's tab (D98 item 7), so the shell opens it (`ui/open-link`, MCP Apps); on a page of its
+ * own, the browser does. Only `http:`, `https:`, `mailto:` and `tel:` URLs open. Resolves `true`
+ * when the URL was handed to the browser.
+ */
+export declare function openLink(url: string): Promise<boolean>;
+//#endregion
+//#region src/mount.d.ts
+/**
+ * Mounts a single-page artifact: the generated entry calls it with the entry's default export.
+ * Artifact code doesn't need to.
+ */
+export declare function mountArtifact(options: {
+  readonly page: ComponentType;
+}): Promise<void>;
+//#endregion
+//#region src/runtime/errors.d.ts
+/**
+ * Errors the client runtime throws: each carries the stable diagnostic code an artifact can switch
+ * on (INTERFACES §13), and the diagnostic itself when the gateway sent one.
+ */
+/** A diagnostic as the gateway sends it; only the fields the runtime reads. */
+interface DiagnosticLike {
+  /** The stable diagnostic code, such as `MOSTRA_FIELD_TOO_LARGE`. */
+  readonly code: string;
+  /** What is wrong. */
+  readonly message: string;
+  /** What to do about it. */
+  readonly hint?: string;
+  /** The code's documentation page. */
+  readonly docs?: string;
+}
+/** An error with a Mostra diagnostic code, such as `MOSTRA_SUBMIT_CHANNEL_DENIED`. */
+export declare class MostraError extends Error {
+  /** The stable diagnostic code. */
+  readonly code: string;
+  /** The HTTP status the gateway answered with, when the error came from it. */
+  readonly status: number | undefined;
+  /** The diagnostic, when the gateway sent one. */
+  readonly diagnostic: DiagnosticLike | undefined;
+  /** Extra data the refusal carried, such as the existing submission of `MOSTRA_SUBMIT_ALREADY`. */
+  readonly body: Readonly<Record<string, unknown>> | undefined;
+  constructor(code: string, message: string, options?: {
+    readonly status?: number;
+    readonly diagnostic?: DiagnosticLike;
+    readonly body?: Readonly<Record<string, unknown>>;
+  });
+}
+//#endregion
+//#region src/server-hooks.d.ts
+/** What `useAction` shows of its run (INTERFACES §2.3). */
+interface ActionHandle<A extends unknown[], R> {
+  /**
+   * Runs the action: a durable run (D24) whose result this resolves with, or whose failure it
+   * rejects with as a `MostraError`. While this hook's run is in flight, another call joins it; with
+   * a `key`, every call anywhere joins the one run of that key, so it happens at most once.
+   */
+  run(...args: A): Promise<R>;
+  /**
+   * `idle` before any run, then the run's state. `waiting` is reserved for a run waiting for its
+   * owner's instance (a hosted artifact, WP-28).
+   */
+  readonly status: "idle" | RunStatus;
+  /** Whether a run is starting or in flight. */
+  readonly isPending: boolean;
+  /** The result, once the run succeeded. */
+  readonly data?: R;
+  /** Why the run failed, was cancelled or couldn't start. */
+  readonly error?: {
+    readonly code: string;
+    readonly message: string;
+  };
+  /** The run's latest progress (`progress()` in the action). */
+  readonly progress?: RunProgress;
+  /** The run's log lines (`log()` and the console in the action), capped at 1 MB. */
+  readonly log: readonly string[];
+  /** For an action that returns an async iterable: the items it yielded so far. */
+  readonly partial: readonly (R extends AsyncIterable<infer T> ? T : unknown)[];
+  /** Cancels the run: the action's `abortSignal` fires (AC-04). */
+  cancel(): void;
+  /** The run's `run_` ID, once it has one. */
+  readonly runId?: string;
+}
+/**
+ * Runs a `"use server"` function as durable action runs (D24, D54): each call is recorded before
+ * it runs, streams progress, log lines and partial results, survives the tab closing, and is
+ * found again after a reload. Without a `key`, a call while this hook's run is in flight joins it,
+ * so a double click runs once; with a `key`, the run of that key happens at most once across
+ * clicks, tabs, reloads and devices, and a page that opens later shows it.
+ *
+ * ```tsx
+ * const send = useAction(sendReply, { key: `send.${message.id}` });
+ * <button disabled={send.isPending || send.status === "succeeded"} onClick={() => send.run(message.id, reply)}>
+ *   {send.status === "succeeded" ? "Sent" : (send.progress?.message ?? "Send")}
+ * </button>
+ * ```
+ */
+export declare function useAction<A extends unknown[], R>(fn: (...args: A) => Promise<R>, options?: {
+  readonly key?: string;
+}): ActionHandle<A, Awaited<R>>;
+/**
+ * The live sources of the artifact, by key, with their value types. A generated declaration
+ * (`mostra-env.d.ts`, written by `mostra new`) fills it from `live.ts`:
+ *
+ * ```ts
+ * declare module "@mostra/react" {
+ *   interface LiveSources extends LiveValuesOf<typeof import("./live")> {}
+ * }
+ * ```
+ */
+interface LiveSources {}
+/** The value types of a `live.ts` module's sources, by export name (D56). */
+type LiveValuesOf<M> = { [K in keyof M as M[K] extends {
+  readonly "~mostra.live": unknown;
+} ? K : never]: M[K] extends {
+  readonly __value?: infer T;
+} ? T : never; };
+/** A live source's key: one of `LiveSources`, or any string before the declaration exists. */
+type LiveKey = [keyof LiveSources] extends [never] ? string : keyof LiveSources & string;
+/** A live source's value type. */
+type LiveValue<K extends string> = K extends keyof LiveSources ? LiveSources[K] : unknown;
+/** What `useLive` shows (INTERFACES §2.3). */
+interface LiveResult<T> {
+  /** The latest value; in append mode, the values kept, oldest first. */
+  readonly data: T | undefined;
+  /** Whether no value has arrived yet. */
+  readonly isLoading: boolean;
+  /** The producer's last failure; the last good value stays in `data` (FAILURE_MODEL §6). */
+  readonly error?: Error;
+  /** Asks the producer to load again now. */
+  refresh(): void;
+  /** The value's revision, which only grows. */
+  readonly revision?: string;
+  /** When the value was produced. */
+  readonly at?: string;
+}
+/**
+ * Reads a live source of `live.ts`, or one an agent or host pushes to (D56): the latest value, or
+ * in append mode the recent values for a high-rate chart. The value is shared by every component
+ * that shows it and updates without a reload; nothing of it is a durable event (D63).
+ *
+ * ```tsx
+ * const { data, isLoading, error } = useLive("inbox");
+ * const { data: points } = useLive("cpu", { mode: "append", window: 600 });
+ * ```
+ */
+export declare function useLive<K extends LiveKey>(key: K, options: {
+  readonly mode: "append";
+  readonly window?: number;
+}): LiveResult<LiveValue<K>[]>;
+/** Reads a live source's latest value (D56). See the first signature. */
+export declare function useLive<K extends LiveKey>(key: K, options?: {
+  readonly mode?: "latest";
+  readonly window?: number;
+}): LiveResult<LiveValue<K>>;
+//#endregion
+//#region src/server-reference.d.ts
+/**
+ * The client side of `"use server"` functions (D19 seam 2, D54). The builder compiles every export
+ * of a `"use server"` module in client code into a server reference: a function that carries the
+ * server function's ID and hands the call to the page's runtime, as React's own server references
+ * hand theirs to the callback `setServerCallback` installs. The runtime calls Mostra (a plain
+ * call: no record, the result streamed back); where there is no Mostra server, such as a static
+ * export, the call rejects with `MOSTRA_TARGET_UNAVAILABLE`.
+ */
+/** A `"use server"` function as client code sees it. */
+interface ServerReference<A extends unknown[] = unknown[], R = unknown> {
+  /** Calls the server function with `args`; resolves with its result. */
+  (...args: A): Promise<R>;
+  /** The server function's ID: its module path, `#` and its export name (`actions.ts#sendReply`). */
+  readonly mostraServerFunctionId: string;
+}
+/** How the page's runtime calls a server function. */
+type CallServer = (id: string, args: unknown[]) => Promise<unknown>;
+/**
+ * Installs how server references call the server: the runtime does it when the page starts (a
+ * live page calls Mostra; a static export keeps the default, which rejects). Returns the function
+ * that restores the previous one.
+ */
+export declare function setServerCallback(callback: CallServer): () => void;
+/**
+ * Creates the client stub of one server function. The builder emits these calls; artifact code
+ * imports the server module as usual and never calls this itself.
+ */
+export declare function createServerReference(id: string): ServerReference;
+//#endregion
+//#region src/storage.d.ts
+/** What `get` and `set` resolve with. */
+interface StorageEntry {
+  /** The key. */
+  readonly key: string;
+  /** Its value: any JSON value. */
+  readonly value: unknown;
+  /** Whether it is shared by every viewer (artifact state) or the viewer's own. */
+  readonly shared: boolean;
+}
+/** The storage API of Claude artifacts, backed by Mostra fields (D53). */
+interface ClaudeCompatibleStorage {
+  /** The value of `key`, or `null` when it has none. */
+  get(key: string, shared?: boolean): Promise<StorageEntry | null>;
+  /** Stores `value` under `key`; resolves once Mostra saved it. */
+  set(key: string, value: unknown, shared?: boolean): Promise<StorageEntry>;
+  /** Removes `key`; resolves once Mostra saved that. */
+  delete(key: string, shared?: boolean): Promise<{
+    readonly key: string;
+    readonly deleted: true;
+    readonly shared: boolean;
+  }>;
+  /** The keys stored, those starting with `prefix` when it is given. */
+  list(prefix?: string, shared?: boolean): Promise<{
+    readonly keys: string[];
+    readonly prefix?: string;
+    readonly shared: boolean;
+  }>;
+}
+declare global {
+  interface Window {
+    /** Claude-compatible persistent storage, backed by Mostra fields (D53). */
+    storage: ClaudeCompatibleStorage;
+  }
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Declares an artifact's manifest (INTERFACES §2.2, D51). Mostra reads the object statically
+ * without running the page, so write every value as a literal: strings, numbers, booleans, arrays
+ * and objects. At run time it returns its argument unchanged.
+ *
+ * ```ts
+ * export const artifact = defineArtifact({ title: "Q3 plan", family: "proposal" });
+ * ```
+ */
+export declare function defineArtifact<const M extends ArtifactManifest$1>(manifest: M): M;
+//#endregion
+export type { ActionHandle, ArtifactManifest, ArtifactMode, CallServer, ChoiceCandidate, ClaudeCompatibleStorage, DiagnosticLike, FieldMeta, FieldOptions, LiveKey, LiveResult, LiveSources, LiveValue, LiveValuesOf, ServerReference, ShellConnection, StandardSchema, StorageEntry, SubmissionSummary, SubmitBlocker, SubmitHandle, SubmitState };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["SubmissionSummary","SubmitBlocker","ArtifactManifest"],"sources":["../src/runtime/store.ts","../src/hooks.ts","../src/shell-bridge.ts","../src/mount.ts","../src/runtime/errors.ts","../src/server-hooks.ts","../src/server-reference.ts","../src/storage.ts","../src/index.ts"],"mappings":";;;;KAmGY;;;;KCjEA;;;;;UAsDK,eAAe;;WAErB;;IAEP,SACE;eACY;iBAA6B;;QAAwB;;aAE1D;eAAmB,OAAO;eAAY,QAAQ;;;;;UAK1C,aAAa;;WAEnB;;WAEA;;WAEA;;WAEA,WAAW,eAAe,OAAO,OAAO;;WAExC,QAAQ;;;UAIF,UAAU;;;;;;WAMhB;;WAEA;;WAEA;aAAsB,QAAQ;IAAG;IAAkB;;;WAEnD;aAAuB;aAA4C;;;;;;;;;;;;;wBAgD9D,SAAS,GACvB,YACA,SAAS,GAGT,UAAS,aAAa,QAAQ,OAC5B,IAAI,MAAM,MAAM,UAAU,MAAM,aAAa,UAAU;;UAoI1C;;;;;;EAMf,UAAU,QAAQA;;WAET;;WAEA,mBAAmBC;;WAEnB,OAAO;;WAEP;aAAwB;aAAqB;;;;wBAIxC,aAAa;;;;;;wBA0Db,iBAAiB;WACtB;WACA;;;wBAeK,UAAU;EAAiB,KAAK,oBAAoB;;;UAWnD;;WAEN;;WAEA;;;;;;;;wBASK,UACd,qBACA;WAAqB,sBAAsB;WAA4B;;WAC3D;EAAiB,OAAO,sBAAsB;;;wBA8D5C;WACL;WACA;WACA;;;wBAeK;WACL;WACA;WACA;WACA;WACA,MAAM;;;;;UC7dA;;WAEN;;WAEA,MAAM;;WAEN,QAAQ;;;;;WAKR;aACE;aACA;aACA,SAAS;;;;;;;;wBAkCN,gBAAgB,QAAQ;;;;;wBA0FxB;;;;;;;wBAaM,SAAS,cAAc;;;;;;;wBCvHvB,cAAc;WAAoB,MAAM;IAAkB;;;;;;;;UCnE/D;;WAEN;;WAEA;;WAEA;;WAEA;;;qBAIE,oBAAoB;;WAEtB;;WAEA;;WAEA,YAAY;;WAEZ,MAAM,SAAS;EAExB,YACE,cACA,iBACA;aACW;aACA,aAAa;aACb,OAAO,SAAS;;;;;;UCjBd,aAAa,qBAAqB;;;;;;EAMjD,OAAO,MAAM,IAAI,QAAQ;;;;;WAKhB,iBAAiB;;WAEjB;;WAEA,OAAO;;WAEP;aAAmB;aAAuB;;;WAE1C,WAAW;;WAEX;;WAEA,mBAAmB,UAAU,oBAAoB,KAAK;;EAE/D;;WAES;;;;;;;;;;;;;;;;wBA6BK,UAAU,qBAAqB,GAC7C,QAAQ,MAAM,MAAM,QAAQ,IAC5B;WAAqB;IACpB,aAAa,GAAG,QAAQ;;;;;;;;;;;UA6HV;;KAGL,aAAa,QACtB,WAAW,KAAK,EAAE;WAAsB;IAA4B,YAAY,EAAE;WACxE,gBAAgB;IAEvB;;KAKM,iBAAiB,8CAA8C;;KAG/D,UAAU,oBAAoB,gBAAgB,cAAc,YAAY;;UAGnE,WAAW;;WAEjB,MAAM;;WAEN;;WAEA,QAAQ;;EAEjB;;WAES;;WAEA;;;;;;;;;;;;wBAgBK,QAAQ,UAAU,SAChC,KAAK,GACL;WAAoB;WAAyB;IAC5C,WAAW,UAAU;;wBAER,QAAQ,UAAU,SAChC,KAAK,GACL;WAAqB;WAA0B;IAC9C,WAAW,UAAU;;;;;;;;;;;;UCnPP,gBAAgB,iCAAiC;;MAE5D,MAAM,IAAI,QAAQ;;WAEb;;;KAIC,cAAc,YAAY,oBAAoB;;;;;;wBAiB1C,kBAAkB,UAAU;;;;;wBAY5B,sBAAsB,aAAa;;;;UC/BlC;;WAEN;;WAEA;;WAEA;;;UAIM;;EAEf,IAAI,aAAa,mBAAmB,QAAQ;;EAE5C,IAAI,aAAa,gBAAgB,mBAAmB,QAAQ;;EAE5D,OACE,aACA,mBACC;aAAmB;aAAsB;aAAwB;;;EAEpE,KACE,iBACA,mBACC;aAAmB;aAAyB;aAA0B;;;QA0G5D;YACH;;IAER,SAAS;;;;;;;;;;;;;;wBC/EG,qBAAqB,UAAUC,oBAAkB,UAAU,IAAI"}

package/dist/index.js

@@ -0,0 +1,199 @@
+"use client";
+import { _ as serverFunctionId, a as useSignal, c as useSubmitControl, d as connectShell, i as useField, l as useViewer, m as reportReady, n as useArtifact, o as useStore, p as openLink, r as useChoice, s as useSubmit, x as MostraError } from "./hooks-Dh_l8KqJ.js";
+import { a as createServerReference, o as setServerCallback, t as mountArtifact } from "./mount-Bpg0M5ln.js";
+import { isFinalRunStatus } from "@mostra/protocol";
+import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+//#region src/server-hooks.ts
+/**
+* Server functions and live data in the page (INTERFACES §2.3, D54, D56): `useAction` turns calls
+* of a `"use server"` function into durable action runs, and `useLive` reads a live source. Both
+* share the page's runtime, its view and its event stream, so a run started in one tab or before a
+* reload is followed the same way, and every component showing one source shares one value.
+*/
+const NO_LOG = [];
+const IDLE = { starting: false };
+const NO_STATES = /* @__PURE__ */ new Map();
+/**
+* Runs a `"use server"` function as durable action runs (D24, D54): each call is recorded before
+* it runs, streams progress, log lines and partial results, survives the tab closing, and is
+* found again after a reload. Without a `key`, a call while this hook's run is in flight joins it,
+* so a double click runs once; with a `key`, the run of that key happens at most once across
+* clicks, tabs, reloads and devices, and a page that opens later shows it.
+*
+* ```tsx
+* const send = useAction(sendReply, { key: `send.${message.id}` });
+* <button disabled={send.isPending || send.status === "succeeded"} onClick={() => send.run(message.id, reply)}>
+*   {send.status === "succeeded" ? "Sent" : (send.progress?.message ?? "Send")}
+* </button>
+* ```
+*/
+function useAction(fn, options) {
+	const store = useStore();
+	const server = store.server;
+	const fnId = serverFunctionId(fn);
+	const key = options?.key;
+	const identity = `${fnId ?? ""}\u0000${key ?? ""}`;
+	const [states, setStates] = useState(NO_STATES);
+	const { runId, starting, startError } = states.get(identity) ?? IDLE;
+	const update = useCallback((of, patch) => {
+		setStates((previous) => {
+			const next = new Map(previous);
+			next.set(of, {
+				...previous.get(of) ?? IDLE,
+				...patch
+			});
+			return next;
+		});
+	}, []);
+	const inFlight = useRef(/* @__PURE__ */ new Map());
+	useSyncExternalStore(server.subscribe, server.version, server.version);
+	useEffect(() => {
+		if (key === void 0 || fnId === void 0 || store.mode !== "live") return;
+		let active = true;
+		server.attach({ keyed: [{
+			fnId,
+			key
+		}] }).then((runs) => {
+			const [found] = runs;
+			if (active && found) update(identity, { runId: found.runId });
+		}, () => {});
+		return () => {
+			active = false;
+		};
+	}, [
+		server,
+		store.mode,
+		fnId,
+		key,
+		identity,
+		update
+	]);
+	const view = runId === void 0 ? void 0 : server.run(runId);
+	const run = useCallback((...args) => {
+		if (fnId === void 0) return Promise.reject(/* @__PURE__ */ new TypeError("useAction needs a server function: import it from a module that starts with \"use server\"."));
+		const joined = inFlight.current.get(identity);
+		if (joined) return joined;
+		update(identity, {
+			starting: true,
+			startError: void 0
+		});
+		const started = (async () => {
+			let state;
+			try {
+				state = await server.startRun(fnId, args, key);
+			} catch (error) {
+				update(identity, {
+					starting: false,
+					startError: error instanceof MostraError ? {
+						code: error.code,
+						message: error.message
+					} : {
+						code: "MOSTRA_ACTION_THREW",
+						message: error.message
+					}
+				});
+				throw error;
+			}
+			update(identity, {
+				starting: false,
+				runId: state.runId
+			});
+			return server.settled(state.runId);
+		})();
+		inFlight.current.set(identity, started);
+		const settle = () => {
+			if (inFlight.current.get(identity) === started) inFlight.current.delete(identity);
+		};
+		started.then(settle, settle);
+		return started;
+	}, [
+		server,
+		fnId,
+		key,
+		identity,
+		update
+	]);
+	const cancel = useCallback(() => {
+		if (runId === void 0) return;
+		const current = server.run(runId);
+		if (current && !isFinalRunStatus(current.status)) server.cancel(runId).catch(() => {});
+	}, [server, runId]);
+	return useMemo(() => {
+		const status = view?.status ?? "idle";
+		const error = view?.error && (view.status === "failed" || view.status === "cancelled") ? {
+			code: view.error.code ?? "MOSTRA_ACTION_THREW",
+			message: view.error.message
+		} : view?.status === "cancelled" ? {
+			code: "MOSTRA_ACTION_CANCELLED",
+			message: "The run was cancelled."
+		} : startError;
+		return {
+			run,
+			cancel,
+			status,
+			isPending: starting || status === "queued" || status === "running" || status === "waiting",
+			...view?.status === "succeeded" && view.data !== void 0 ? { data: view.data } : {},
+			...error ? { error } : {},
+			...view?.progress ? { progress: view.progress } : {},
+			log: view?.log ?? NO_LOG,
+			partial: view?.partial ?? [],
+			...runId !== void 0 ? { runId } : {}
+		};
+	}, [
+		run,
+		cancel,
+		view,
+		starting,
+		startError,
+		runId
+	]);
+}
+/** How long append mode keeps values without a `window`. */
+const DEFAULT_WINDOW = 1024;
+function useLive(key, options) {
+	const server = useStore().server;
+	const append = options?.mode === "append";
+	const window = append ? options?.window ?? DEFAULT_WINDOW : void 0;
+	useSyncExternalStore(server.subscribe, server.version, server.version);
+	useEffect(() => server.watchLive(key, window), [
+		server,
+		key,
+		window
+	]);
+	const view = server.liveView(key);
+	const refresh = useCallback(() => server.refreshLive(key), [server, key]);
+	return useMemo(() => {
+		const data = append ? view?.ring.length ? view.ring.slice(-(window ?? 0)) : void 0 : view?.data;
+		return {
+			data,
+			isLoading: data === void 0 && (view?.loading ?? true),
+			...view?.error ? { error: new MostraError(view.error.code ?? "MOSTRA_LIVE_SOURCE_FAILED", view.error.message) } : {},
+			refresh,
+			...view?.revision !== void 0 ? { revision: view.revision } : {},
+			...view?.at !== void 0 ? { at: view.at } : {}
+		};
+	}, [
+		view,
+		append,
+		window,
+		refresh
+	]);
+}
+//#endregion
+//#region src/index.ts
+/**
+* Declares an artifact's manifest (INTERFACES §2.2, D51). Mostra reads the object statically
+* without running the page, so write every value as a literal: strings, numbers, booleans, arrays
+* and objects. At run time it returns its argument unchanged.
+*
+* ```ts
+* export const artifact = defineArtifact({ title: "Q3 plan", family: "proposal" });
+* ```
+*/
+function defineArtifact(manifest) {
+	return manifest;
+}
+//#endregion
+export { MostraError, connectShell, createServerReference, defineArtifact, mountArtifact, openLink, reportReady, setServerCallback, useAction, useArtifact, useChoice, useField, useLive, useSignal, useSubmit, useSubmitControl, useViewer };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/server-hooks.ts","../src/index.ts"],"sourcesContent":["\"use client\";\n\n/**\n * Server functions and live data in the page (INTERFACES §2.3, D54, D56): `useAction` turns calls\n * of a `\"use server\"` function into durable action runs, and `useLive` reads a live source. Both\n * share the page's runtime, its view and its event stream, so a run started in one tab or before a\n * reload is followed the same way, and every component showing one source shares one value.\n */\nimport { isFinalRunStatus, type RunProgress, type RunStatus } from \"@mostra/protocol\";\nimport { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from \"react\";\nimport { useStore } from \"./hooks.ts\";\nimport { MostraError } from \"./runtime/errors.ts\";\nimport { serverFunctionId } from \"./runtime/server-client.ts\";\n\n// ── useAction ─────────────────────────────────────────────────────────────────────────────\n\n/** What `useAction` shows of its run (INTERFACES §2.3). */\nexport interface ActionHandle<A extends unknown[], R> {\n  /**\n   * Runs the action: a durable run (D24) whose result this resolves with, or whose failure it\n   * rejects with as a `MostraError`. While this hook's run is in flight, another call joins it; with\n   * a `key`, every call anywhere joins the one run of that key, so it happens at most once.\n   */\n  run(...args: A): Promise<R>;\n  /**\n   * `idle` before any run, then the run's state. `waiting` is reserved for a run waiting for its\n   * owner's instance (a hosted artifact, WP-28).\n   */\n  readonly status: \"idle\" | RunStatus;\n  /** Whether a run is starting or in flight. */\n  readonly isPending: boolean;\n  /** The result, once the run succeeded. */\n  readonly data?: R;\n  /** Why the run failed, was cancelled or couldn't start. */\n  readonly error?: { readonly code: string; readonly message: string };\n  /** The run's latest progress (`progress()` in the action). */\n  readonly progress?: RunProgress;\n  /** The run's log lines (`log()` and the console in the action), capped at 1 MB. */\n  readonly log: readonly string[];\n  /** For an action that returns an async iterable: the items it yielded so far. */\n  readonly partial: readonly (R extends AsyncIterable<infer T> ? T : unknown)[];\n  /** Cancels the run: the action's `abortSignal` fires (AC-04). */\n  cancel(): void;\n  /** The run's `run_` ID, once it has one. */\n  readonly runId?: string;\n}\n\nconst NO_LOG: readonly string[] = [];\n\n/** What `useAction` knows of one function and key. */\ninterface IdentityState {\n  readonly runId?: string | undefined;\n  readonly starting: boolean;\n  readonly startError?: { code: string; message: string } | undefined;\n}\n\nconst IDLE: IdentityState = { starting: false };\nconst NO_STATES: ReadonlyMap<string, IdentityState> = new Map();\n\n/**\n * Runs a `\"use server\"` function as durable action runs (D24, D54): each call is recorded before\n * it runs, streams progress, log lines and partial results, survives the tab closing, and is\n * found again after a reload. Without a `key`, a call while this hook's run is in flight joins it,\n * so a double click runs once; with a `key`, the run of that key happens at most once across\n * clicks, tabs, reloads and devices, and a page that opens later shows it.\n *\n * ```tsx\n * const send = useAction(sendReply, { key: `send.${message.id}` });\n * <button disabled={send.isPending || send.status === \"succeeded\"} onClick={() => send.run(message.id, reply)}>\n *   {send.status === \"succeeded\" ? \"Sent\" : (send.progress?.message ?? \"Send\")}\n * </button>\n * ```\n */\nexport function useAction<A extends unknown[], R>(\n  fn: (...args: A) => Promise<R>,\n  options?: { readonly key?: string },\n): ActionHandle<A, Awaited<R>> {\n  const store = useStore();\n  const server = store.server;\n  const fnId = serverFunctionId(fn);\n  const key = options?.key;\n  // Everything the hook knows belongs to one function and key: a component that changes either\n  // shows the new one's run, never the old one's, and a late answer for the old one lands under\n  // the old identity, where the hook no longer looks.\n  const identity = `${fnId ?? \"\"}\\u0000${key ?? \"\"}`;\n  const [states, setStates] = useState<ReadonlyMap<string, IdentityState>>(NO_STATES);\n  const current = states.get(identity) ?? IDLE;\n  const { runId, starting, startError } = current;\n  const update = useCallback((of: string, patch: Partial<IdentityState>): void => {\n    setStates((previous) => {\n      const next = new Map(previous);\n      next.set(of, { ...(previous.get(of) ?? IDLE), ...patch });\n      return next;\n    });\n  }, []);\n  const inFlight = useRef(new Map<string, Promise<unknown>>());\n  useSyncExternalStore(server.subscribe, server.version, server.version);\n\n  // A keyed run started earlier, in another tab or before a reload, is shown again (AC-02).\n  useEffect(() => {\n    if (key === undefined || fnId === undefined || store.mode !== \"live\") return;\n    let active = true;\n    server.attach({ keyed: [{ fnId, key }] }).then(\n      (runs) => {\n        const [found] = runs;\n        if (active && found) update(identity, { runId: found.runId });\n      },\n      () => {},\n    );\n    return () => {\n      active = false;\n    };\n  }, [server, store.mode, fnId, key, identity, update]);\n\n  const view = runId === undefined ? undefined : server.run(runId);\n\n  const run = useCallback(\n    (...args: A): Promise<Awaited<R>> => {\n      if (fnId === undefined) {\n        return Promise.reject(\n          new TypeError(\n            'useAction needs a server function: import it from a module that starts with \"use server\".',\n          ),\n        );\n      }\n      // One run in flight per hook instance and function and key (D54): a second click joins it.\n      const joined = inFlight.current.get(identity);\n      if (joined) return joined as Promise<Awaited<R>>;\n      update(identity, { starting: true, startError: undefined });\n      const started = (async () => {\n        let state: Awaited<ReturnType<typeof server.startRun>>;\n        try {\n          state = await server.startRun(fnId, args, key);\n        } catch (error) {\n          // The run never started (a refused link, a parked worker, the network): say why.\n          update(identity, {\n            starting: false,\n            startError:\n              error instanceof MostraError\n                ? { code: error.code, message: error.message }\n                : { code: \"MOSTRA_ACTION_THREW\", message: (error as Error).message },\n          });\n          throw error;\n        }\n        update(identity, { starting: false, runId: state.runId });\n        return server.settled(state.runId);\n      })();\n      inFlight.current.set(identity, started);\n      const settle = (): void => {\n        if (inFlight.current.get(identity) === started) inFlight.current.delete(identity);\n      };\n      started.then(settle, settle);\n      return started as Promise<Awaited<R>>;\n    },\n    [server, fnId, key, identity, update],\n  );\n\n  const cancel = useCallback(() => {\n    if (runId === undefined) return;\n    const current = server.run(runId);\n    if (current && !isFinalRunStatus(current.status)) void server.cancel(runId).catch(() => {});\n  }, [server, runId]);\n\n  return useMemo(() => {\n    const status: ActionHandle<A, Awaited<R>>[\"status\"] = view?.status ?? \"idle\";\n    const error =\n      view?.error && (view.status === \"failed\" || view.status === \"cancelled\")\n        ? { code: view.error.code ?? \"MOSTRA_ACTION_THREW\", message: view.error.message }\n        : view?.status === \"cancelled\"\n          ? { code: \"MOSTRA_ACTION_CANCELLED\", message: \"The run was cancelled.\" }\n          : startError;\n    return {\n      run,\n      cancel,\n      status,\n      isPending: starting || status === \"queued\" || status === \"running\" || status === \"waiting\",\n      ...(view?.status === \"succeeded\" && view.data !== undefined\n        ? { data: view.data as Awaited<R> }\n        : {}),\n      ...(error ? { error } : {}),\n      ...(view?.progress ? { progress: view.progress } : {}),\n      log: view?.log ?? NO_LOG,\n      partial: (view?.partial ?? []) as ActionHandle<A, Awaited<R>>[\"partial\"],\n      ...(runId !== undefined ? { runId } : {}),\n    };\n  }, [run, cancel, view, starting, startError, runId]);\n}\n\n// ── useLive ───────────────────────────────────────────────────────────────────────────────\n\n/**\n * The live sources of the artifact, by key, with their value types. A generated declaration\n * (`mostra-env.d.ts`, written by `mostra new`) fills it from `live.ts`:\n *\n * ```ts\n * declare module \"@mostra/react\" {\n *   interface LiveSources extends LiveValuesOf<typeof import(\"./live\")> {}\n * }\n * ```\n */\n// biome-ignore lint/suspicious/noEmptyInterface: augmented by each artifact's declaration.\nexport interface LiveSources {}\n\n/** The value types of a `live.ts` module's sources, by export name (D56). */\nexport type LiveValuesOf<M> = {\n  [K in keyof M as M[K] extends { readonly \"~mostra.live\": unknown } ? K : never]: M[K] extends {\n    readonly __value?: infer T;\n  }\n    ? T\n    : never;\n};\n\n/** A live source's key: one of `LiveSources`, or any string before the declaration exists. */\nexport type LiveKey = [keyof LiveSources] extends [never] ? string : keyof LiveSources & string;\n\n/** A live source's value type. */\nexport type LiveValue<K extends string> = K extends keyof LiveSources ? LiveSources[K] : unknown;\n\n/** What `useLive` shows (INTERFACES §2.3). */\nexport interface LiveResult<T> {\n  /** The latest value; in append mode, the values kept, oldest first. */\n  readonly data: T | undefined;\n  /** Whether no value has arrived yet. */\n  readonly isLoading: boolean;\n  /** The producer's last failure; the last good value stays in `data` (FAILURE_MODEL §6). */\n  readonly error?: Error;\n  /** Asks the producer to load again now. */\n  refresh(): void;\n  /** The value's revision, which only grows. */\n  readonly revision?: string;\n  /** When the value was produced. */\n  readonly at?: string;\n}\n\n/** How long append mode keeps values without a `window`. */\nconst DEFAULT_WINDOW = 1024;\n\n/**\n * Reads a live source of `live.ts`, or one an agent or host pushes to (D56): the latest value, or\n * in append mode the recent values for a high-rate chart. The value is shared by every component\n * that shows it and updates without a reload; nothing of it is a durable event (D63).\n *\n * ```tsx\n * const { data, isLoading, error } = useLive(\"inbox\");\n * const { data: points } = useLive(\"cpu\", { mode: \"append\", window: 600 });\n * ```\n */\nexport function useLive<K extends LiveKey>(\n  key: K,\n  options: { readonly mode: \"append\"; readonly window?: number },\n): LiveResult<LiveValue<K>[]>;\n/** Reads a live source's latest value (D56). See the first signature. */\nexport function useLive<K extends LiveKey>(\n  key: K,\n  options?: { readonly mode?: \"latest\"; readonly window?: number },\n): LiveResult<LiveValue<K>>;\nexport function useLive<K extends LiveKey>(\n  key: K,\n  options?: { readonly mode?: \"latest\" | \"append\"; readonly window?: number },\n): LiveResult<unknown> {\n  const store = useStore();\n  const server = store.server;\n  const append = options?.mode === \"append\";\n  const window = append ? (options?.window ?? DEFAULT_WINDOW) : undefined;\n  useSyncExternalStore(server.subscribe, server.version, server.version);\n  useEffect(() => server.watchLive(key, window), [server, key, window]);\n  const view = server.liveView(key);\n  const refresh = useCallback(() => server.refreshLive(key), [server, key]);\n  return useMemo(() => {\n    const data = append\n      ? view?.ring.length\n        ? view.ring.slice(-(window ?? 0))\n        : undefined\n      : view?.data;\n    return {\n      data,\n      isLoading: data === undefined && (view?.loading ?? true),\n      ...(view?.error\n        ? {\n            error: new MostraError(\n              view.error.code ?? \"MOSTRA_LIVE_SOURCE_FAILED\",\n              view.error.message,\n            ),\n          }\n        : {}),\n      refresh,\n      ...(view?.revision !== undefined ? { revision: view.revision } : {}),\n      ...(view?.at !== undefined ? { at: view.at } : {}),\n    };\n  }, [view, append, window, refresh]);\n}\n","\"use client\";\n\n/**\n * `@mostra/react`: the client runtime artifact authors import (INTERFACES §2.3). Fields that behave\n * like `useState` with a stable ID and persist as the viewer works, the artifact channel's\n * submit, the shell's trusted Submit label, signals, review-set choices, the viewer and the\n * artifact, a Claude-compatible `window.storage`, and the manifest helper. `@mostra/react/form`\n * adapts react-hook-form; `@mostra/react/router` mounts `pages/` artifacts.\n *\n * ```tsx\n * import { defineArtifact, useField, useSubmitControl } from \"@mostra/react\";\n *\n * export const artifact = defineArtifact({ title: \"Sidebar options\", family: \"review\" });\n *\n * export default function Page() {\n *   const [layout, setLayout] = useField(\"layout\", \"left\", { label: \"Layout\", required: true });\n *   useSubmitControl({ label: \"Send my choice\" });\n *   return <select value={layout} onChange={(e) => setLayout(e.target.value)}>…</select>;\n * }\n * ```\n *\n * @packageDocumentation\n */\nimport type { ArtifactManifest } from \"@mostra/protocol\";\n\nexport type { ArtifactManifest, SubmissionSummary, SubmitBlocker } from \"@mostra/protocol\";\nexport {\n  type ArtifactMode,\n  type ChoiceCandidate,\n  type FieldMeta,\n  type FieldOptions,\n  type StandardSchema,\n  type SubmitHandle,\n  useArtifact,\n  useChoice,\n  useField,\n  useSignal,\n  useSubmit,\n  useSubmitControl,\n  useViewer,\n} from \"./hooks.ts\";\nexport { mountArtifact } from \"./mount.ts\";\nexport { type DiagnosticLike, MostraError } from \"./runtime/errors.ts\";\nexport type { SubmitState } from \"./runtime/store.ts\";\nexport {\n  type ActionHandle,\n  type LiveKey,\n  type LiveResult,\n  type LiveSources,\n  type LiveValue,\n  type LiveValuesOf,\n  useAction,\n  useLive,\n} from \"./server-hooks.ts\";\nexport {\n  type CallServer,\n  createServerReference,\n  type ServerReference,\n  setServerCallback,\n} from \"./server-reference.ts\";\nexport { connectShell, openLink, reportReady, type ShellConnection } from \"./shell-bridge.ts\";\nexport type { ClaudeCompatibleStorage, StorageEntry } from \"./storage.ts\";\n\n/**\n * Declares an artifact's manifest (INTERFACES §2.2, D51). Mostra reads the object statically\n * without running the page, so write every value as a literal: strings, numbers, booleans, arrays\n * and objects. At run time it returns its argument unchanged.\n *\n * ```ts\n * export const artifact = defineArtifact({ title: \"Q3 plan\", family: \"proposal\" });\n * ```\n */\nexport function defineArtifact<const M extends ArtifactManifest>(manifest: M): M {\n  return manifest;\n}\n"],"mappings":"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"}