@mostra/protocol 0.0.0-stage → 0.1.0

package/dist/worker.d.ts

@@ -0,0 +1,249 @@
+import { Frame, WireError } from "./serializer.js";
+import { ActionError, Batches, RunProgress } from "./actions.js";
+import { DocumentRevision, FieldOp, MutationResult } from "./interaction.js";
+import * as z from "zod";
+//#region src/worker.d.ts
+/** The worker channel's revision, which a worker states in its `worker/start` answer. */
+export declare const WORKER_CHANNEL_REVISION = "2026-10-16";
+/** The limits a worker runs under (D62): stability, never security. */
+export interface WorkerLimits {
+  /** The V8 old-space heap, in MiB (default 1024). */
+  readonly heapMb: number;
+  /** How long the event loop may be blocked before the worker is stopped, in ms (default 10 000). */
+  readonly watchdogMs: number;
+  /** Idle minutes before the worker is evicted (default 10). */
+  readonly idleMinutes: number;
+}
+/** The default limits (D62). */
+export declare const DEFAULT_WORKER_LIMITS: WorkerLimits;
+/**
+ * Names a version for a launcher (D124): its ID, the digest of its build output, and where its
+ * portable bundle is. A local launcher resolves a `home:` locator to the version's directory in
+ * its home; a remote one fetches the bundle and checks the digest. Never a directory path.
+ */
+export interface WorkerVersionRef {
+  /** The version. */
+  readonly versionId: string;
+  /** The SHA-256 of the version's build output (DATA_MODEL §2). */
+  readonly outputDigest: string;
+  /** `home:versions/<versionId>` for the home's own store; other schemes for other launchers. */
+  readonly locator: string;
+}
+/** The Zod schema of the `WorkerVersionRef` type. */
+export declare const WorkerVersionRef: z.ZodType<WorkerVersionRef>;
+/** Who a call runs for, as `@mostra/server` exposes it (`viewer()`, `dryRun()`). */
+export interface CallContext {
+  /** `call`: a plain call. `run`: an action run. */
+  readonly kind: "call" | "run";
+  /** The run's `run_` ID. */
+  readonly runId?: string;
+  /** The view the page was opened as (D104). */
+  readonly viewId?: string;
+  /** The viewer, when there is one. */
+  readonly viewer?: {
+    readonly id: string;
+    readonly name?: string;
+  };
+  /** True only during `verify`'s smoke test (D55). */
+  readonly dryRun: boolean;
+}
+/** How a live source produces values, as the worker found it in `live.ts`. */
+export interface LiveSourceInfo {
+  /** The live source's key. */
+  readonly key: string;
+  /** Whether it has a `load` function. */
+  readonly load: boolean;
+  /** The refresh interval, in ms. */
+  readonly refreshMs?: number;
+  /** The globs it watches. */
+  readonly watch?: readonly string[];
+  /** Whether it has a `stream` function. */
+  readonly stream: boolean;
+  /** Whether it runs without viewers (D63). */
+  readonly always: boolean;
+  /** How many values it keeps for append mode. */
+  readonly ring?: number;
+}
+/** `worker/start`: the first request; the worker loads the version's server bundle. */
+export interface WorkerStartParams {
+  /** The artifact. */
+  readonly artifactId: string;
+  /** The version to load. */
+  readonly version: WorkerVersionRef;
+  /** The server bundle to load, relative to the version (the render mode's `serverEntry`, D19). */
+  readonly entry: string;
+  /** The limits it runs under. */
+  readonly limits: WorkerLimits;
+}
+/** What a started worker serves. */
+export interface WorkerStartResult {
+  /** The value's revision. */
+  readonly revision: string;
+  /** The server function IDs of the version. */
+  readonly functions: readonly string[];
+  /** The live sources of `live.ts`. */
+  readonly live: readonly LiveSourceInfo[];
+}
+/** The Zod schema of the `WorkerStartResult` type (the supervisor checks the worker's answer). */
+export declare const WorkerStartResult: z.ZodType<WorkerStartResult>;
+/** The Zod schema of the `WorkerStartParams` type. */
+export declare const WorkerStartParams: z.ZodType<WorkerStartParams>;
+/**
+ * `worker/call`: runs a server function. Its result streams as `worker/batch` notifications
+ * before the answer, which says how it ended.
+ */
+export interface WorkerCallParams {
+  /** Unique on this channel; batches, cancellation and server requests name it. */
+  readonly callId: string;
+  /** The server function: `<module path>#<export>`. */
+  readonly fnId: string;
+  /** The arguments, serialized as one array value. */
+  readonly args: Batches;
+  /** Who the call runs for. */
+  readonly context: CallContext;
+}
+/** The Zod schema of the `WorkerCallParams` type. */
+export declare const WorkerCallParams: z.ZodType<WorkerCallParams>;
+/** How a call ended. */
+export type WorkerCallOutcome = {
+  readonly status: "succeeded";
+} | {
+  readonly status: "cancelled";
+} | {
+  readonly status: "failed";
+  readonly error: ActionError;
+};
+/** The Zod schema of the `WorkerCallOutcome` type. */
+export declare const WorkerCallOutcome: z.ZodType<WorkerCallOutcome>;
+/** `worker/cancel` (notification): aborts a call's `abortSignal`. */
+export interface WorkerCancelParams {
+  /** The call to cancel. */
+  readonly callId: string;
+  /** Why, for the run's log. */
+  readonly reason?: string;
+}
+/** `worker/ping`: the watchdog's question. */
+export interface WorkerPingResult {
+  /** How long the worker's event loop has gone without a turn, in ms. */
+  readonly blockedMs: number;
+  /** Whether it is blocked on purpose, waiting for a secret (`secret()` is synchronous). */
+  readonly waitingForSecret: boolean;
+  /** The V8 heap in use, in bytes. */
+  readonly heapUsed: number;
+}
+/** The Zod schema of the `WorkerPingResult` type. */
+export declare const WorkerPingResult: z.ZodType<WorkerPingResult>;
+/** `worker/live.start` and `worker/live.stop` (requests), `worker/live.refresh` (notification). */
+export interface WorkerLiveParams {
+  /** The live source's key. */
+  readonly key: string;
+}
+/** `worker/batch` (notification): a batch of a call's result. */
+export interface WorkerBatchParams {
+  /** The call it belongs to. */
+  readonly callId: string;
+  /** One batch of the result. */
+  readonly batch: readonly Frame[];
+}
+/** The Zod schema of the `WorkerBatchParams` type. */
+export declare const WorkerBatchParams: z.ZodType<WorkerBatchParams>;
+/** `server/progress` (notification). */
+export interface ServerProgressParams extends RunProgress {
+  /** The call it belongs to. */
+  readonly callId: string;
+}
+/** The Zod schema of the `ServerProgressParams` type. */
+export declare const ServerProgressParams: z.ZodType<ServerProgressParams>;
+/** `server/log` (notification): a line of a run's log, or of the worker's own log. */
+export interface ServerLogParams {
+  /** The call it belongs to. */
+  readonly callId?: string;
+  /** One line. */
+  readonly line: string;
+}
+/** The Zod schema of the `ServerLogParams` type. */
+export declare const ServerLogParams: z.ZodType<ServerLogParams>;
+/** `server/secret`: a secret by name (D44); `MOSTRA_SECRET_MISSING` when no store has it. */
+export interface ServerSecretParams {
+  /** The secret's name. */
+  readonly name: string;
+}
+/** The Zod schema of the `ServerSecretParams` type. */
+export declare const ServerSecretParams: z.ZodType<ServerSecretParams>;
+/** `server/signal`: raises `signal.raised` with `source: "action"` (AC-05). */
+export interface ServerSignalParams {
+  /** The call it belongs to. */
+  readonly callId?: string;
+  /** The signal's name. */
+  readonly name: string;
+  /** Any JSON, at most 64 KiB. */
+  readonly payload?: unknown;
+}
+/** The Zod schema of the `ServerSignalParams` type. */
+export declare const ServerSignalParams: z.ZodType<ServerSignalParams>;
+/** `server/emit`: appends a `host.<name>` event (AC-05). */
+export interface ServerEmitParams {
+  /** The call it belongs to. */
+  readonly callId?: string;
+  /** `host.<name>`. */
+  readonly type: string;
+  /** Any JSON, at most 64 KiB. */
+  readonly payload?: unknown;
+}
+/** The Zod schema of the `ServerEmitParams` type. */
+export declare const ServerEmitParams: z.ZodType<ServerEmitParams>;
+/** `server/state.get`: reads the artifact's shared state. */
+export interface ServerStateGetParams {
+  /** The fields to read; absent: all. */
+  readonly ids?: readonly string[];
+}
+/** The Zod schema of the `ServerStateGetParams` type. */
+export declare const ServerStateGetParams: z.ZodType<ServerStateGetParams>;
+/** `server/state.patch`: writes the artifact's shared state as the agent (D63). */
+export interface ServerStatePatchParams {
+  /** The call it belongs to. */
+  readonly callId?: string;
+  /** The field changes. */
+  readonly ops: readonly FieldOp[];
+  /** The change's ID, for idempotent retries. */
+  readonly mutationId?: string;
+  /** The state revision read; fields changed after it conflict. */
+  readonly baseRevision?: DocumentRevision;
+}
+/** The Zod schema of the `ServerStatePatchParams` type. */
+export declare const ServerStatePatchParams: z.ZodType<ServerStatePatchParams>;
+/** The answer of `server/state.patch`. */
+export type ServerStatePatchResult = MutationResult;
+/** `server/live.value` (notification): a producer's new value, or its failure. */
+export interface ServerLiveValueParams {
+  /** The live source's key. */
+  readonly key: string;
+  /** The value, serialized. */
+  readonly value?: Batches;
+  /** What went wrong. */
+  readonly error?: WireError;
+}
+/** The Zod schema of the `ServerLiveValueParams` type. */
+export declare const ServerLiveValueParams: z.ZodType<ServerLiveValueParams>;
+/** The channel's method names. */
+export declare const WORKER_METHODS: {
+  readonly start: "worker/start";
+  readonly call: "worker/call";
+  readonly cancel: "worker/cancel";
+  readonly ping: "worker/ping";
+  readonly liveStart: "worker/live.start";
+  readonly liveStop: "worker/live.stop";
+  readonly liveRefresh: "worker/live.refresh";
+  readonly stop: "worker/stop";
+  readonly batch: "worker/batch";
+  readonly progress: "server/progress";
+  readonly log: "server/log";
+  readonly secret: "server/secret";
+  readonly signal: "server/signal";
+  readonly emit: "server/emit";
+  readonly stateGet: "server/state.get";
+  readonly statePatch: "server/state.patch";
+  readonly liveValue: "server/live.value";
+};
+//#endregion
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","names":[],"sources":["../src/worker.ts"],"mappings":";;;;;;qBAiBa;;iBAGI;;WAEN;;WAEA;;WAEA;;;qBAIE,uBAAuB;;;;;;iBAWnB;;WAEN;;WAEA;;WAEA;;;qBAIE,kBAAkB,EAAE,QAAQ;;iBAOxB;;WAEN;;WAEA;;WAEA;;WAEA;aAAoB;aAAqB;;;WAEzC;;;iBAYM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;;iBAgBM;;WAEN;;WAEA,SAAS;;WAET;;WAEA,QAAQ;;;iBAIF;;WAEN;;WAEA;;WAEA,eAAe;;;qBAIb,mBAAmB,EAAE,QAAQ;;qBAO7B,mBAAmB,EAAE,QAAQ;;;;;iBAezB;;WAEN;;WAEA;;WAEA,MAAM;;WAEN,SAAS;;;qBAIP,kBAAkB,EAAE,QAAQ;;YAQ7B;WACG;;WACA;;WACA;WAA2B,OAAO;;;qBAGpC,mBAAmB,EAAE,QAAQ;;iBAOzB;;WAEN;;WAEA;;;iBAIM;;WAEN;;WAEA;;WAEA;;;qBAIE,kBAAkB,EAAE,QAAQ;;iBAOxB;;WAEN;;;iBAMM;;WAEN;;WAEA,gBAAgB;;;qBAId,mBAAmB,EAAE,QAAQ;;iBAMzB,6BAA6B;;WAEnC;;;qBAIE,sBAAsB,EAAE,QAAQ;;iBAO5B;;WAEN;;WAEA;;;qBAIE,iBAAiB,EAAE,QAAQ;;iBAMvB;;WAEN;;;qBAIE,oBAAoB,EAAE,QAAQ;;iBAG1B;;WAEN;;WAEA;;WAEA;;;qBAIE,oBAAoB,EAAE,QAAQ;;iBAO1B;;WAEN;;WAEA;;WAEA;;;qBAIE,kBAAkB,EAAE,QAAQ;;iBAOxB;;WAEN;;;qBAIE,sBAAsB,EAAE,QAAQ;;iBAK5B;;WAEN;;WAEA,cAAc;;WAEd;;WAEA,eAAe;;;qBAIb,wBAAwB,EAAE,QAAQ;;YAQnC,yBAAyB;;iBAGpB;;WAEN;;WAEA,QAAQ;;WAER,QAAQ;;;qBAIN,uBAAuB,EAAE,QAAQ;;qBAOjC;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA"}

package/dist/worker.js

@@ -0,0 +1,158 @@
+import { ActionError, Batches, LIVE_KEY_PATTERN } from "./actions.js";
+import { DocumentRevision, FieldOp } from "./interaction.js";
+import * as z from "zod";
+//#region src/worker.ts
+/**
+* The worker channel (D124, ARCHITECTURE §7): JSON-RPC 2.0 between the supervisor and an artifact
+* version's worker, over whatever the `WorkerLauncher` connects (a pipe for the local launcher, a
+* socket for a launcher whose worker runs elsewhere). Every message is serializable, so a worker
+* that runs as a separate process, or on another machine, fits without a change. Secrets reach a
+* worker only as answers to its own `server/secret` requests, never through its environment.
+*
+* The supervisor validates everything a worker sends: a worker runs agent-authored code with full
+* capability (D05), and a malformed message must never take the supervisor down.
+*/
+/** The worker channel's revision, which a worker states in its `worker/start` answer. */
+const WORKER_CHANNEL_REVISION = "2026-10-16";
+/** The default limits (D62). */
+const DEFAULT_WORKER_LIMITS = {
+	heapMb: 1024,
+	watchdogMs: 1e4,
+	idleMinutes: 10
+};
+/** The Zod schema of the `WorkerVersionRef` type. */
+const WorkerVersionRef = z.object({
+	versionId: z.string(),
+	outputDigest: z.string().regex(/^[0-9a-f]{64}$/),
+	locator: z.string().min(1)
+});
+const CallContextSchema = z.object({
+	kind: z.enum(["call", "run"]),
+	runId: z.string().exactOptional(),
+	viewId: z.string().exactOptional(),
+	viewer: z.object({
+		id: z.string(),
+		name: z.string().exactOptional()
+	}).exactOptional(),
+	dryRun: z.boolean()
+});
+const LiveSourceInfoSchema = z.object({
+	key: z.string().regex(LIVE_KEY_PATTERN),
+	load: z.boolean(),
+	refreshMs: z.int().min(1).exactOptional(),
+	watch: z.array(z.string()).readonly().exactOptional(),
+	stream: z.boolean(),
+	always: z.boolean(),
+	ring: z.int().min(1).exactOptional()
+});
+/** The Zod schema of the `WorkerStartResult` type (the supervisor checks the worker's answer). */
+const WorkerStartResult = z.object({
+	revision: z.string(),
+	functions: z.array(z.string()).readonly(),
+	live: z.array(LiveSourceInfoSchema).readonly()
+});
+/** The Zod schema of the `WorkerStartParams` type. */
+const WorkerStartParams = z.object({
+	artifactId: z.string(),
+	version: WorkerVersionRef,
+	entry: z.string().min(1),
+	limits: z.object({
+		heapMb: z.int().min(16),
+		watchdogMs: z.int().min(100),
+		idleMinutes: z.number().min(0)
+	})
+});
+/** The Zod schema of the `WorkerCallParams` type. */
+const WorkerCallParams = z.object({
+	callId: z.string().min(1).max(64),
+	fnId: z.string().min(1),
+	args: Batches,
+	context: CallContextSchema
+});
+/** The Zod schema of the `WorkerCallOutcome` type. */
+const WorkerCallOutcome = z.union([
+	z.object({ status: z.literal("succeeded") }),
+	z.object({ status: z.literal("cancelled") }),
+	z.object({
+		status: z.literal("failed"),
+		error: ActionError
+	})
+]);
+/** The Zod schema of the `WorkerPingResult` type. */
+const WorkerPingResult = z.object({
+	blockedMs: z.number().min(0),
+	waitingForSecret: z.boolean(),
+	heapUsed: z.number().min(0)
+});
+/** The Zod schema of the `WorkerBatchParams` type. */
+const WorkerBatchParams = z.object({
+	callId: z.string(),
+	batch: z.array(z.record(z.string(), z.unknown())).readonly()
+});
+/** The Zod schema of the `ServerProgressParams` type. */
+const ServerProgressParams = z.object({
+	callId: z.string(),
+	fraction: z.number().min(0).max(1).exactOptional(),
+	message: z.string().max(1e3).exactOptional()
+});
+/** The Zod schema of the `ServerLogParams` type. */
+const ServerLogParams = z.object({
+	callId: z.string().exactOptional(),
+	line: z.string()
+});
+/** The Zod schema of the `ServerSecretParams` type. */
+const ServerSecretParams = z.object({ name: z.string() });
+/** The Zod schema of the `ServerSignalParams` type. */
+const ServerSignalParams = z.object({
+	callId: z.string().exactOptional(),
+	name: z.string(),
+	payload: z.unknown().exactOptional()
+});
+/** The Zod schema of the `ServerEmitParams` type. */
+const ServerEmitParams = z.object({
+	callId: z.string().exactOptional(),
+	type: z.string(),
+	payload: z.unknown().exactOptional()
+});
+/** The Zod schema of the `ServerStateGetParams` type. */
+const ServerStateGetParams = z.object({ ids: z.array(z.string()).readonly().exactOptional() });
+/** The Zod schema of the `ServerStatePatchParams` type. */
+const ServerStatePatchParams = z.object({
+	callId: z.string().exactOptional(),
+	ops: z.array(FieldOp).min(1).max(1e3).readonly(),
+	mutationId: z.string().exactOptional(),
+	baseRevision: DocumentRevision.exactOptional()
+});
+/** The Zod schema of the `ServerLiveValueParams` type. */
+const ServerLiveValueParams = z.object({
+	key: z.string().regex(LIVE_KEY_PATTERN),
+	value: Batches.exactOptional(),
+	error: z.object({
+		message: z.string(),
+		code: z.string().exactOptional()
+	}).exactOptional()
+});
+/** The channel's method names. */
+const WORKER_METHODS = {
+	start: "worker/start",
+	call: "worker/call",
+	cancel: "worker/cancel",
+	ping: "worker/ping",
+	liveStart: "worker/live.start",
+	liveStop: "worker/live.stop",
+	liveRefresh: "worker/live.refresh",
+	stop: "worker/stop",
+	batch: "worker/batch",
+	progress: "server/progress",
+	log: "server/log",
+	secret: "server/secret",
+	signal: "server/signal",
+	emit: "server/emit",
+	stateGet: "server/state.get",
+	statePatch: "server/state.patch",
+	liveValue: "server/live.value"
+};
+//#endregion
+export { DEFAULT_WORKER_LIMITS, ServerEmitParams, ServerLiveValueParams, ServerLogParams, ServerProgressParams, ServerSecretParams, ServerSignalParams, ServerStateGetParams, ServerStatePatchParams, WORKER_CHANNEL_REVISION, WORKER_METHODS, WorkerBatchParams, WorkerCallOutcome, WorkerCallParams, WorkerPingResult, WorkerStartParams, WorkerStartResult, WorkerVersionRef };
+
+//# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","names":[],"sources":["../src/worker.ts"],"sourcesContent":["/**\n * The worker channel (D124, ARCHITECTURE §7): JSON-RPC 2.0 between the supervisor and an artifact\n * version's worker, over whatever the `WorkerLauncher` connects (a pipe for the local launcher, a\n * socket for a launcher whose worker runs elsewhere). Every message is serializable, so a worker\n * that runs as a separate process, or on another machine, fits without a change. Secrets reach a\n * worker only as answers to its own `server/secret` requests, never through its environment.\n *\n * The supervisor validates everything a worker sends: a worker runs agent-authored code with full\n * capability (D05), and a malformed message must never take the supervisor down.\n */\nimport * as z from \"zod\";\nimport { ActionError, Batches, LIVE_KEY_PATTERN, type RunProgress } from \"./actions.ts\";\nimport type { MutationResult } from \"./interaction.ts\";\nimport { DocumentRevision, FieldOp } from \"./interaction.ts\";\nimport type { Frame, WireError } from \"./serializer.ts\";\n\n/** The worker channel's revision, which a worker states in its `worker/start` answer. */\nexport const WORKER_CHANNEL_REVISION = \"2026-10-16\";\n\n/** The limits a worker runs under (D62): stability, never security. */\nexport interface WorkerLimits {\n  /** The V8 old-space heap, in MiB (default 1024). */\n  readonly heapMb: number;\n  /** How long the event loop may be blocked before the worker is stopped, in ms (default 10 000). */\n  readonly watchdogMs: number;\n  /** Idle minutes before the worker is evicted (default 10). */\n  readonly idleMinutes: number;\n}\n\n/** The default limits (D62). */\nexport const DEFAULT_WORKER_LIMITS: WorkerLimits = {\n  heapMb: 1024,\n  watchdogMs: 10_000,\n  idleMinutes: 10,\n};\n\n/**\n * Names a version for a launcher (D124): its ID, the digest of its build output, and where its\n * portable bundle is. A local launcher resolves a `home:` locator to the version's directory in\n * its home; a remote one fetches the bundle and checks the digest. Never a directory path.\n */\nexport interface WorkerVersionRef {\n  /** The version. */\n  readonly versionId: string;\n  /** The SHA-256 of the version's build output (DATA_MODEL §2). */\n  readonly outputDigest: string;\n  /** `home:versions/<versionId>` for the home's own store; other schemes for other launchers. */\n  readonly locator: string;\n}\n\n/** The Zod schema of the `WorkerVersionRef` type. */\nexport const WorkerVersionRef: z.ZodType<WorkerVersionRef> = z.object({\n  versionId: z.string(),\n  outputDigest: z.string().regex(/^[0-9a-f]{64}$/),\n  locator: z.string().min(1),\n});\n\n/** Who a call runs for, as `@mostra/server` exposes it (`viewer()`, `dryRun()`). */\nexport interface CallContext {\n  /** `call`: a plain call. `run`: an action run. */\n  readonly kind: \"call\" | \"run\";\n  /** The run's `run_` ID. */\n  readonly runId?: string;\n  /** The view the page was opened as (D104). */\n  readonly viewId?: string;\n  /** The viewer, when there is one. */\n  readonly viewer?: { readonly id: string; readonly name?: string };\n  /** True only during `verify`'s smoke test (D55). */\n  readonly dryRun: boolean;\n}\n\nconst CallContextSchema: z.ZodType<CallContext> = z.object({\n  kind: z.enum([\"call\", \"run\"]),\n  runId: z.string().exactOptional(),\n  viewId: z.string().exactOptional(),\n  viewer: z.object({ id: z.string(), name: z.string().exactOptional() }).exactOptional(),\n  dryRun: z.boolean(),\n});\n\n/** How a live source produces values, as the worker found it in `live.ts`. */\nexport interface LiveSourceInfo {\n  /** The live source's key. */\n  readonly key: string;\n  /** Whether it has a `load` function. */\n  readonly load: boolean;\n  /** The refresh interval, in ms. */\n  readonly refreshMs?: number;\n  /** The globs it watches. */\n  readonly watch?: readonly string[];\n  /** Whether it has a `stream` function. */\n  readonly stream: boolean;\n  /** Whether it runs without viewers (D63). */\n  readonly always: boolean;\n  /** How many values it keeps for append mode. */\n  readonly ring?: number;\n}\n\nconst LiveSourceInfoSchema: z.ZodType<LiveSourceInfo> = z.object({\n  key: z.string().regex(LIVE_KEY_PATTERN),\n  load: z.boolean(),\n  refreshMs: z.int().min(1).exactOptional(),\n  watch: z.array(z.string()).readonly().exactOptional(),\n  stream: z.boolean(),\n  always: z.boolean(),\n  ring: z.int().min(1).exactOptional(),\n});\n\n// ── Supervisor → worker ────────────────────────────────────────────────────────────────────\n\n/** `worker/start`: the first request; the worker loads the version's server bundle. */\nexport interface WorkerStartParams {\n  /** The artifact. */\n  readonly artifactId: string;\n  /** The version to load. */\n  readonly version: WorkerVersionRef;\n  /** The server bundle to load, relative to the version (the render mode's `serverEntry`, D19). */\n  readonly entry: string;\n  /** The limits it runs under. */\n  readonly limits: WorkerLimits;\n}\n\n/** What a started worker serves. */\nexport interface WorkerStartResult {\n  /** The value's revision. */\n  readonly revision: string;\n  /** The server function IDs of the version. */\n  readonly functions: readonly string[];\n  /** The live sources of `live.ts`. */\n  readonly live: readonly LiveSourceInfo[];\n}\n\n/** The Zod schema of the `WorkerStartResult` type (the supervisor checks the worker's answer). */\nexport const WorkerStartResult: z.ZodType<WorkerStartResult> = z.object({\n  revision: z.string(),\n  functions: z.array(z.string()).readonly(),\n  live: z.array(LiveSourceInfoSchema).readonly(),\n});\n\n/** The Zod schema of the `WorkerStartParams` type. */\nexport const WorkerStartParams: z.ZodType<WorkerStartParams> = z.object({\n  artifactId: z.string(),\n  version: WorkerVersionRef,\n  entry: z.string().min(1),\n  limits: z.object({\n    heapMb: z.int().min(16),\n    watchdogMs: z.int().min(100),\n    idleMinutes: z.number().min(0),\n  }),\n});\n\n/**\n * `worker/call`: runs a server function. Its result streams as `worker/batch` notifications\n * before the answer, which says how it ended.\n */\nexport interface WorkerCallParams {\n  /** Unique on this channel; batches, cancellation and server requests name it. */\n  readonly callId: string;\n  /** The server function: `<module path>#<export>`. */\n  readonly fnId: string;\n  /** The arguments, serialized as one array value. */\n  readonly args: Batches;\n  /** Who the call runs for. */\n  readonly context: CallContext;\n}\n\n/** The Zod schema of the `WorkerCallParams` type. */\nexport const WorkerCallParams: z.ZodType<WorkerCallParams> = z.object({\n  callId: z.string().min(1).max(64),\n  fnId: z.string().min(1),\n  args: Batches,\n  context: CallContextSchema,\n});\n\n/** How a call ended. */\nexport type WorkerCallOutcome =\n  | { readonly status: \"succeeded\" }\n  | { readonly status: \"cancelled\" }\n  | { readonly status: \"failed\"; readonly error: ActionError };\n\n/** The Zod schema of the `WorkerCallOutcome` type. */\nexport const WorkerCallOutcome: z.ZodType<WorkerCallOutcome> = z.union([\n  z.object({ status: z.literal(\"succeeded\") }),\n  z.object({ status: z.literal(\"cancelled\") }),\n  z.object({ status: z.literal(\"failed\"), error: ActionError }),\n]);\n\n/** `worker/cancel` (notification): aborts a call's `abortSignal`. */\nexport interface WorkerCancelParams {\n  /** The call to cancel. */\n  readonly callId: string;\n  /** Why, for the run's log. */\n  readonly reason?: string;\n}\n\n/** `worker/ping`: the watchdog's question. */\nexport interface WorkerPingResult {\n  /** How long the worker's event loop has gone without a turn, in ms. */\n  readonly blockedMs: number;\n  /** Whether it is blocked on purpose, waiting for a secret (`secret()` is synchronous). */\n  readonly waitingForSecret: boolean;\n  /** The V8 heap in use, in bytes. */\n  readonly heapUsed: number;\n}\n\n/** The Zod schema of the `WorkerPingResult` type. */\nexport const WorkerPingResult: z.ZodType<WorkerPingResult> = z.object({\n  blockedMs: z.number().min(0),\n  waitingForSecret: z.boolean(),\n  heapUsed: z.number().min(0),\n});\n\n/** `worker/live.start` and `worker/live.stop` (requests), `worker/live.refresh` (notification). */\nexport interface WorkerLiveParams {\n  /** The live source's key. */\n  readonly key: string;\n}\n\n// ── Worker → supervisor ────────────────────────────────────────────────────────────────────\n\n/** `worker/batch` (notification): a batch of a call's result. */\nexport interface WorkerBatchParams {\n  /** The call it belongs to. */\n  readonly callId: string;\n  /** One batch of the result. */\n  readonly batch: readonly Frame[];\n}\n\n/** The Zod schema of the `WorkerBatchParams` type. */\nexport const WorkerBatchParams: z.ZodType<WorkerBatchParams> = z.object({\n  callId: z.string(),\n  batch: z.array(z.record(z.string(), z.unknown())).readonly(),\n}) as unknown as z.ZodType<WorkerBatchParams>;\n\n/** `server/progress` (notification). */\nexport interface ServerProgressParams extends RunProgress {\n  /** The call it belongs to. */\n  readonly callId: string;\n}\n\n/** The Zod schema of the `ServerProgressParams` type. */\nexport const ServerProgressParams: z.ZodType<ServerProgressParams> = z.object({\n  callId: z.string(),\n  fraction: z.number().min(0).max(1).exactOptional(),\n  message: z.string().max(1000).exactOptional(),\n});\n\n/** `server/log` (notification): a line of a run's log, or of the worker's own log. */\nexport interface ServerLogParams {\n  /** The call it belongs to. */\n  readonly callId?: string;\n  /** One line. */\n  readonly line: string;\n}\n\n/** The Zod schema of the `ServerLogParams` type. */\nexport const ServerLogParams: z.ZodType<ServerLogParams> = z.object({\n  callId: z.string().exactOptional(),\n  line: z.string(),\n});\n\n/** `server/secret`: a secret by name (D44); `MOSTRA_SECRET_MISSING` when no store has it. */\nexport interface ServerSecretParams {\n  /** The secret's name. */\n  readonly name: string;\n}\n\n/** The Zod schema of the `ServerSecretParams` type. */\nexport const ServerSecretParams: z.ZodType<ServerSecretParams> = z.object({ name: z.string() });\n\n/** `server/signal`: raises `signal.raised` with `source: \"action\"` (AC-05). */\nexport interface ServerSignalParams {\n  /** The call it belongs to. */\n  readonly callId?: string;\n  /** The signal's name. */\n  readonly name: string;\n  /** Any JSON, at most 64 KiB. */\n  readonly payload?: unknown;\n}\n\n/** The Zod schema of the `ServerSignalParams` type. */\nexport const ServerSignalParams: z.ZodType<ServerSignalParams> = z.object({\n  callId: z.string().exactOptional(),\n  name: z.string(),\n  payload: z.unknown().exactOptional(),\n}) as z.ZodType<ServerSignalParams>;\n\n/** `server/emit`: appends a `host.<name>` event (AC-05). */\nexport interface ServerEmitParams {\n  /** The call it belongs to. */\n  readonly callId?: string;\n  /** `host.<name>`. */\n  readonly type: string;\n  /** Any JSON, at most 64 KiB. */\n  readonly payload?: unknown;\n}\n\n/** The Zod schema of the `ServerEmitParams` type. */\nexport const ServerEmitParams: z.ZodType<ServerEmitParams> = z.object({\n  callId: z.string().exactOptional(),\n  type: z.string(),\n  payload: z.unknown().exactOptional(),\n}) as z.ZodType<ServerEmitParams>;\n\n/** `server/state.get`: reads the artifact's shared state. */\nexport interface ServerStateGetParams {\n  /** The fields to read; absent: all. */\n  readonly ids?: readonly string[];\n}\n\n/** The Zod schema of the `ServerStateGetParams` type. */\nexport const ServerStateGetParams: z.ZodType<ServerStateGetParams> = z.object({\n  ids: z.array(z.string()).readonly().exactOptional(),\n});\n\n/** `server/state.patch`: writes the artifact's shared state as the agent (D63). */\nexport interface ServerStatePatchParams {\n  /** The call it belongs to. */\n  readonly callId?: string;\n  /** The field changes. */\n  readonly ops: readonly FieldOp[];\n  /** The change's ID, for idempotent retries. */\n  readonly mutationId?: string;\n  /** The state revision read; fields changed after it conflict. */\n  readonly baseRevision?: DocumentRevision;\n}\n\n/** The Zod schema of the `ServerStatePatchParams` type. */\nexport const ServerStatePatchParams: z.ZodType<ServerStatePatchParams> = z.object({\n  callId: z.string().exactOptional(),\n  ops: z.array(FieldOp).min(1).max(1000).readonly(),\n  mutationId: z.string().exactOptional(),\n  baseRevision: DocumentRevision.exactOptional(),\n});\n\n/** The answer of `server/state.patch`. */\nexport type ServerStatePatchResult = MutationResult;\n\n/** `server/live.value` (notification): a producer's new value, or its failure. */\nexport interface ServerLiveValueParams {\n  /** The live source's key. */\n  readonly key: string;\n  /** The value, serialized. */\n  readonly value?: Batches;\n  /** What went wrong. */\n  readonly error?: WireError;\n}\n\n/** The Zod schema of the `ServerLiveValueParams` type. */\nexport const ServerLiveValueParams: z.ZodType<ServerLiveValueParams> = z.object({\n  key: z.string().regex(LIVE_KEY_PATTERN),\n  value: Batches.exactOptional(),\n  error: z.object({ message: z.string(), code: z.string().exactOptional() }).exactOptional(),\n});\n\n/** The channel's method names. */\nexport const WORKER_METHODS = {\n  start: \"worker/start\",\n  call: \"worker/call\",\n  cancel: \"worker/cancel\",\n  ping: \"worker/ping\",\n  liveStart: \"worker/live.start\",\n  liveStop: \"worker/live.stop\",\n  liveRefresh: \"worker/live.refresh\",\n  stop: \"worker/stop\",\n  batch: \"worker/batch\",\n  progress: \"server/progress\",\n  log: \"server/log\",\n  secret: \"server/secret\",\n  signal: \"server/signal\",\n  emit: \"server/emit\",\n  stateGet: \"server/state.get\",\n  statePatch: \"server/state.patch\",\n  liveValue: \"server/live.value\",\n} as const;\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,117 @@
 {
   "name": "@mostra/protocol",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Mostra's shared protocol vocabulary: IDs, dated revisions and diagnostics, with Zod schemas and generated JSON Schema.",
+  "license": "Apache-2.0",
+  "author": "The Mostra Authors",
+  "homepage": "https://github.com/mostra-dev/mostra/tree/main/packages/protocol#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mostra-dev/mostra.git",
+    "directory": "packages/protocol"
+  },
+  "bugs": "https://github.com/mostra-dev/mostra/issues",
+  "keywords": [
+    "mostra",
+    "agent",
+    "artifact",
+    "protocol",
+    "json-schema"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "@mostra/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./schemas/*": "./schemas/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "schemas",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "zod": "4.6.5"
+  },
+  "devDependencies": {
+    "@mostra/tools": "0.0.0",
+    "@size-limit/preset-small-lib": "14.1.0",
+    "@types/node": "24.19.1",
+    "fast-check": "4.10.2",
+    "react": "19.3.0",
+    "react-dom": "19.3.0",
+    "react-server-dom-parcel": "19.3.0",
+    "size-limit": "14.1.0",
+    "tsdown": "0.23.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.3"
+  },
+  "size-limit": [
+    {
+      "name": "@mostra/protocol whole entry (zod excluded)",
+      "path": "dist/index.js",
+      "import": "*",
+      "ignore": [
+        "zod"
+      ],
+      "limit": "48 kB"
+    },
+    {
+      "name": "@mostra/protocol JSON-RPC core (D83, zod excluded)",
+      "path": "dist/index.js",
+      "import": "{ RpcPeer, RpcError, encodeLine, LineSplitter }",
+      "ignore": [
+        "zod"
+      ],
+      "limit": "6 kB"
+    },
+    {
+      "name": "@mostra/protocol IDs alone (zod excluded)",
+      "path": "dist/index.js",
+      "import": "{ ArtifactId, VersionId, Cursor }",
+      "ignore": [
+        "zod"
+      ],
+      "limit": "1.5 kB"
+    },
+    {
+      "name": "@mostra/protocol bridge (SH-04, zod excluded)",
+      "path": "dist/index.js",
+      "import": "{ connectBridge, uiInitialize, uiInitialized, mostraReady }",
+      "ignore": [
+        "zod"
+      ],
+      "limit": "8.5 kB"
+    },
+    {
+      "name": "@mostra/protocol server-function serializer (D54)",
+      "path": "dist/index.js",
+      "import": "{ ValueWriter, ValueReader, serializeAll, deserializeAll }",
+      "ignore": [
+        "zod"
+      ],
+      "limit": "5 kB"
+    }
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -b",
+    "test": "vitest run",
+    "api": "mostra-tools api",
+    "size": "size-limit",
+    "schemas": "mostra-tools schemas check",
+    "gen:schemas": "mostra-tools schemas write"
+  }
 }