@mostra/protocol 0.0.0-stage → 0.1.0

package/dist/revision.d.ts

@@ -0,0 +1,43 @@
+import { Diagnostic } from "./diagnostics/diagnostic.js";
+import { CreateDiagnosticOptions } from "./diagnostics/codes/index.js";
+import * as z from "zod";
+//#region src/revision.d.ts
+/** A protocol revision: a calendar date in `YYYY-MM-DD` form. */
+export type Revision = string & {
+  readonly __mostraRevision: true;
+};
+/** Protocol revisions. */
+export declare const Revision: {
+  /** The textual form. `is` and `parse` also reject impossible dates such as `2026-02-30`. */
+  readonly pattern: RegExp;
+  readonly schema: z.ZodType<Revision, string>;
+  is(value: unknown): value is Revision;
+  /** @throws TypeError when `value` is not a real calendar date in `YYYY-MM-DD` form. */
+  parse(value: string): Revision;
+  /** Orders revisions by date: negative when `a` is older than `b`. */
+  compare(a: Revision, b: Revision): number;
+};
+/**
+ * The host protocol revisions this package's schemas describe, newest first. A runtime built on
+ * this package supports exactly these.
+ */
+export declare const HOST_PROTOCOL_REVISIONS: readonly Revision[];
+/** The outcome of {@link negotiateRevision}. */
+export type RevisionNegotiation = {
+  readonly ok: true;
+  readonly revision: Revision;
+} | {
+  readonly ok: false;
+  readonly diagnostic: Diagnostic;
+};
+/**
+ * Picks the newest host protocol revision that both sides support. When there is none, returns
+ * the refusal diagnostic `MOSTRA_HOST_REVISION_UNSUPPORTED`, which the instance sends back as the
+ * error of `mostra/initialize`.
+ *
+ * Offered entries that are not revisions never match, and the message lists only well-formed
+ * ones, so a malformed offer can't inject text into the diagnostic.
+ */
+export declare function negotiateRevision(offered: readonly string[], supported?: readonly Revision[], options?: CreateDiagnosticOptions): RevisionNegotiation;
+//#endregion
+//# sourceMappingURL=revision.d.ts.map

package/dist/revision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision.d.ts","names":[],"sources":["../src/revision.ts"],"mappings":";;;;;YAaY;WAA+B;;;qBAW9B;;WAEF,SAAS;WACT,QAAQ,EAAE,QAAQ;EAC3B,GAAG,iBAAiB,SAAS;;EAE7B,MAAM,gBAAgB;;EAEtB,QAAQ,GAAG,UAAU,GAAG;;;;;;qBAuBb,kCAAkC;;YAGnC;WACG;WAAmB,UAAU;;WAC7B;WAAoB,YAAY;;;;;;;;;;wBAiB/B,kBACd,4BACA,qBAAoB,YACpB,UAAS,0BACR"}

package/dist/revision.js

@@ -0,0 +1,69 @@
+import { wireRegistry } from "./wire-registry.js";
+import { createDiagnostic } from "./diagnostics/codes/index.js";
+import * as z from "zod";
+//#region src/revision.ts
+/**
+* Dated protocol revisions and their negotiation (INTERFACES §1, STANDARDS versioning, D59).
+*
+* The host protocol and the browser protocol each carry a revision named by a date
+* (`2026-10-10`). A revision only changes additively. A breaking change needs a new revision, and
+* the old one stays supported for at least 12 months.
+*/
+const PATTERN = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+function isRevision(value) {
+	if (typeof value !== "string" || !PATTERN.test(value)) return false;
+	const date = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+	return !Number.isNaN(date.getTime()) && date.toISOString().startsWith(value);
+}
+/** Protocol revisions. */
+const Revision = {
+	pattern: PATTERN,
+	schema: z.iso.date().register(wireRegistry, {
+		id: "Revision",
+		description: "Protocol revision: a calendar date in YYYY-MM-DD form."
+	}),
+	is: isRevision,
+	parse(value) {
+		if (isRevision(value)) return value;
+		throw new TypeError("Expected a protocol revision: a calendar date in YYYY-MM-DD form.");
+	},
+	compare(a, b) {
+		return a < b ? -1 : a > b ? 1 : 0;
+	}
+};
+/**
+* The host protocol revisions this package's schemas describe, newest first. A runtime built on
+* this package supports exactly these.
+*/
+const HOST_PROTOCOL_REVISIONS = [Revision.parse("2026-10-10")];
+const LISTED = 8;
+function list(revisions) {
+	const shown = revisions.slice(0, LISTED).join(", ");
+	return revisions.length > LISTED ? `${shown} and ${revisions.length - LISTED} more` : shown;
+}
+/**
+* Picks the newest host protocol revision that both sides support. When there is none, returns
+* the refusal diagnostic `MOSTRA_HOST_REVISION_UNSUPPORTED`, which the instance sends back as the
+* error of `mostra/initialize`.
+*
+* Offered entries that are not revisions never match, and the message lists only well-formed
+* ones, so a malformed offer can't inject text into the diagnostic.
+*/
+function negotiateRevision(offered, supported = HOST_PROTOCOL_REVISIONS, options = {}) {
+	const offeredRevisions = [...new Set(offered.filter(isRevision))].sort(Revision.compare);
+	const newest = offeredRevisions.filter((revision) => supported.includes(revision)).at(-1);
+	if (newest !== void 0) return {
+		ok: true,
+		revision: newest
+	};
+	const supportedList = [...supported].sort(Revision.compare).reverse();
+	const offeredText = offeredRevisions.length > 0 ? `The client offered host protocol revisions ${list(offeredRevisions.reverse())}` : "The client offered no valid host protocol revision";
+	return {
+		ok: false,
+		diagnostic: createDiagnostic("MOSTRA_HOST_REVISION_UNSUPPORTED", { message: `${offeredText}; this instance supports ${list(supportedList)}.` }, options)
+	};
+}
+//#endregion
+export { HOST_PROTOCOL_REVISIONS, Revision, negotiateRevision };
+
+//# sourceMappingURL=revision.js.map

package/dist/revision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision.js","names":[],"sources":["../src/revision.ts"],"sourcesContent":["/**\n * Dated protocol revisions and their negotiation (INTERFACES §1, STANDARDS versioning, D59).\n *\n * The host protocol and the browser protocol each carry a revision named by a date\n * (`2026-10-10`). A revision only changes additively. A breaking change needs a new revision, and\n * the old one stays supported for at least 12 months.\n */\nimport * as z from \"zod\";\nimport { type CreateDiagnosticOptions, createDiagnostic } from \"./diagnostics/codes/index.ts\";\nimport type { Diagnostic } from \"./diagnostics/diagnostic.ts\";\nimport { wireRegistry } from \"./wire-registry.ts\";\n\n/** A protocol revision: a calendar date in `YYYY-MM-DD` form. */\nexport type Revision = string & { readonly __mostraRevision: true };\n\nconst PATTERN = /^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$/;\n\nfunction isRevision(value: unknown): value is Revision {\n  if (typeof value !== \"string\" || !PATTERN.test(value)) return false;\n  const date = new Date(`${value}T00:00:00Z`);\n  return !Number.isNaN(date.getTime()) && date.toISOString().startsWith(value);\n}\n\n/** Protocol revisions. */\nexport const Revision: {\n  /** The textual form. `is` and `parse` also reject impossible dates such as `2026-02-30`. */\n  readonly pattern: RegExp;\n  readonly schema: z.ZodType<Revision, string>;\n  is(value: unknown): value is Revision;\n  /** @throws TypeError when `value` is not a real calendar date in `YYYY-MM-DD` form. */\n  parse(value: string): Revision;\n  /** Orders revisions by date: negative when `a` is older than `b`. */\n  compare(a: Revision, b: Revision): number;\n} = {\n  pattern: PATTERN,\n  // z.iso.date() checks calendar validity in its emitted pattern, so the published JSON Schema\n  // rejects 2026-02-30 just as `parse` does.\n  schema: z.iso.date().register(wireRegistry, {\n    id: \"Revision\",\n    description: \"Protocol revision: a calendar date in YYYY-MM-DD form.\",\n  }) as unknown as z.ZodType<Revision, string>,\n  is: isRevision,\n  parse(value: string): Revision {\n    if (isRevision(value)) return value;\n    throw new TypeError(\"Expected a protocol revision: a calendar date in YYYY-MM-DD form.\");\n  },\n  compare(a: Revision, b: Revision): number {\n    return a < b ? -1 : a > b ? 1 : 0;\n  },\n};\n\n/**\n * The host protocol revisions this package's schemas describe, newest first. A runtime built on\n * this package supports exactly these.\n */\nexport const HOST_PROTOCOL_REVISIONS: readonly Revision[] = [Revision.parse(\"2026-10-10\")];\n\n/** The outcome of {@link negotiateRevision}. */\nexport type RevisionNegotiation =\n  | { readonly ok: true; readonly revision: Revision }\n  | { readonly ok: false; readonly diagnostic: Diagnostic };\n\nconst LISTED = 8;\n\nfunction list(revisions: readonly string[]): string {\n  const shown = revisions.slice(0, LISTED).join(\", \");\n  return revisions.length > LISTED ? `${shown} and ${revisions.length - LISTED} more` : shown;\n}\n\n/**\n * Picks the newest host protocol revision that both sides support. When there is none, returns\n * the refusal diagnostic `MOSTRA_HOST_REVISION_UNSUPPORTED`, which the instance sends back as the\n * error of `mostra/initialize`.\n *\n * Offered entries that are not revisions never match, and the message lists only well-formed\n * ones, so a malformed offer can't inject text into the diagnostic.\n */\nexport function negotiateRevision(\n  offered: readonly string[],\n  supported: readonly Revision[] = HOST_PROTOCOL_REVISIONS,\n  options: CreateDiagnosticOptions = {},\n): RevisionNegotiation {\n  const offeredRevisions = [...new Set(offered.filter(isRevision))].sort(Revision.compare);\n  const common = offeredRevisions.filter((revision) => supported.includes(revision));\n  const newest = common.at(-1);\n  if (newest !== undefined) return { ok: true, revision: newest };\n\n  const supportedList = [...supported].sort(Revision.compare).reverse();\n  const offeredText =\n    offeredRevisions.length > 0\n      ? `The client offered host protocol revisions ${list(offeredRevisions.reverse())}`\n      : \"The client offered no valid host protocol revision\";\n  return {\n    ok: false,\n    diagnostic: createDiagnostic(\n      \"MOSTRA_HOST_REVISION_UNSUPPORTED\",\n      { message: `${offeredText}; this instance supports ${list(supportedList)}.` },\n      options,\n    ),\n  };\n}\n"],"mappings":";;;;;;;;;;;AAeA,MAAM,UAAU;AAEhB,SAAS,WAAW,OAAmC;CACrD,IAAI,OAAO,UAAU,YAAY,CAAC,QAAQ,KAAK,KAAK,GAAG,OAAO;CAC9D,MAAM,uBAAO,IAAI,KAAK,GAAG,MAAM,WAAW;CAC1C,OAAO,CAAC,OAAO,MAAM,KAAK,QAAQ,CAAC,KAAK,KAAK,YAAY,CAAC,CAAC,WAAW,KAAK;AAC7E;;AAGA,MAAa,WAST;CACF,SAAS;CAGT,QAAQ,EAAE,IAAI,KAAK,CAAC,CAAC,SAAS,cAAc;EAC1C,IAAI;EACJ,aAAa;CACf,CAAC;CACD,IAAI;CACJ,MAAM,OAAyB;EAC7B,IAAI,WAAW,KAAK,GAAG,OAAO;EAC9B,MAAM,IAAI,UAAU,mEAAmE;CACzF;CACA,QAAQ,GAAa,GAAqB;EACxC,OAAO,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI;CAClC;AACF;;;;;AAMA,MAAa,0BAA+C,CAAC,SAAS,MAAM,YAAY,CAAC;AAOzF,MAAM,SAAS;AAEf,SAAS,KAAK,WAAsC;CAClD,MAAM,QAAQ,UAAU,MAAM,GAAG,MAAM,CAAC,CAAC,KAAK,IAAI;CAClD,OAAO,UAAU,SAAS,SAAS,GAAG,MAAM,OAAO,UAAU,SAAS,OAAO,SAAS;AACxF;;;;;;;;;AAUA,SAAgB,kBACd,SACA,YAAiC,yBACjC,UAAmC,CAAC,GACf;CACrB,MAAM,mBAAmB,CAAC,GAAG,IAAI,IAAI,QAAQ,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,OAAO;CAEvF,MAAM,SADS,iBAAiB,QAAQ,aAAa,UAAU,SAAS,QAAQ,CAC5D,CAAC,CAAC,GAAG,EAAE;CAC3B,IAAI,WAAW,KAAA,GAAW,OAAO;EAAE,IAAI;EAAM,UAAU;CAAO;CAE9D,MAAM,gBAAgB,CAAC,GAAG,SAAS,CAAC,CAAC,KAAK,SAAS,OAAO,CAAC,CAAC,QAAQ;CACpE,MAAM,cACJ,iBAAiB,SAAS,IACtB,8CAA8C,KAAK,iBAAiB,QAAQ,CAAC,MAC7E;CACN,OAAO;EACL,IAAI;EACJ,YAAY,iBACV,oCACA,EAAE,SAAS,GAAG,YAAY,2BAA2B,KAAK,aAAa,EAAE,GAAG,GAC5E,OACF;CACF;AACF"}

package/dist/rpc/error.d.ts

@@ -0,0 +1,47 @@
+import { Diagnostic } from "../diagnostics/diagnostic.js";
+import "../diagnostics/spec.js";
+import "../diagnostics/codes/host.js";
+import { JsonRpcErrorObject } from "./messages.js";
+//#region src/rpc/error.d.ts
+/** The JSON-RPC 2.0 error codes Mostra uses (INTERFACES §6). */
+export declare const JSON_RPC_ERROR_CODES: {
+  /** The line wasn't valid JSON. */
+  readonly parseError: -32700;
+  /** The message wasn't a valid request, or was a batch. */
+  readonly invalidRequest: -32600;
+  /** The method doesn't exist on this side. */
+  readonly methodNotFound: -32601;
+  /** The params failed the method's schema. */
+  readonly invalidParams: -32602;
+  /** An unexpected failure. */
+  readonly internalError: -32603;
+  /** Every other diagnostic. */
+  readonly diagnostic: -32000;
+};
+/**
+ * An error that crosses a connection as a JSON-RPC error. Throw it from a request handler to
+ * answer with this diagnostic; a request's promise rejects with it when the other side answers
+ * with an error, the connection closes or the request times out.
+ *
+ * ```ts
+ * throw new RpcError(
+ *   createDiagnostic("MOSTRA_HOME_MISMATCH", { message: "This instance serves /a, not /b." }),
+ * );
+ * ```
+ */
+export declare class RpcError extends Error {
+  /** The JSON-RPC error code. */
+  readonly code: number;
+  /** The diagnostic: what happened and what to do. */
+  readonly diagnostic: Diagnostic;
+  constructor(diagnostic: Diagnostic, code?: number);
+  /** The JSON-RPC error object for a response. */
+  toErrorObject(): JsonRpcErrorObject;
+  /**
+   * Reads a received error object. When its `data` isn't a diagnostic (a peer that isn't Mostra),
+   * the result is a `MOSTRA_HOST_MALFORMED` diagnostic that keeps the peer's message.
+   */
+  static fromErrorObject(error: JsonRpcErrorObject, docsBase?: string): RpcError;
+}
+//#endregion
+//# sourceMappingURL=error.d.ts.map

package/dist/rpc/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","names":[],"sources":["../../src/rpc/error.ts"],"mappings":";;;;;;qBAUa;;WAEF;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;;;;;;;qBAoCE,iBAAiB;;WAEnB;;WAEA,YAAY;EAErB,YAAY,YAAY,YAAY;;EAQpC,iBAAiB;;;;;SAQV,gBAAgB,OAAO,oBAAoB,oBAAoB"}

package/dist/rpc/error.js

@@ -0,0 +1,77 @@
+import { hostDiagnostics } from "../diagnostics/codes/host.js";
+import { Diagnostic } from "../diagnostics/diagnostic.js";
+import { buildDiagnostic } from "../diagnostics/spec.js";
+//#region src/rpc/error.ts
+/**
+* Errors on a JSON-RPC connection. Every error carries a diagnostic (INTERFACES §1, §6): the
+* JSON-RPC `error.code` says which kind of failure it is, and `error.data` is the diagnostic.
+*/
+/** The JSON-RPC 2.0 error codes Mostra uses (INTERFACES §6). */
+const JSON_RPC_ERROR_CODES = {
+	parseError: -32700,
+	invalidRequest: -32600,
+	methodNotFound: -32601,
+	invalidParams: -32602,
+	internalError: -32603,
+	diagnostic: -32e3
+};
+function codeFor(diagnostic) {
+	switch (diagnostic.code) {
+		case "MOSTRA_HOST_MALFORMED": return JSON_RPC_ERROR_CODES.invalidRequest;
+		case "MOSTRA_HOST_METHOD_UNKNOWN": return JSON_RPC_ERROR_CODES.methodNotFound;
+		case "MOSTRA_HOST_INVALID_PARAMS": return JSON_RPC_ERROR_CODES.invalidParams;
+		case "MOSTRA_HOST_INTERNAL_ERROR": return JSON_RPC_ERROR_CODES.internalError;
+		default: return JSON_RPC_ERROR_CODES.diagnostic;
+	}
+}
+/**
+* An error that crosses a connection as a JSON-RPC error. Throw it from a request handler to
+* answer with this diagnostic; a request's promise rejects with it when the other side answers
+* with an error, the connection closes or the request times out.
+*
+* ```ts
+* throw new RpcError(
+*   createDiagnostic("MOSTRA_HOME_MISMATCH", { message: "This instance serves /a, not /b." }),
+* );
+* ```
+*/
+var RpcError = class RpcError extends Error {
+	/** The JSON-RPC error code. */
+	code;
+	/** The diagnostic: what happened and what to do. */
+	diagnostic;
+	constructor(diagnostic, code = codeFor(diagnostic)) {
+		super(diagnostic.message);
+		this.name = "RpcError";
+		this.code = code;
+		this.diagnostic = diagnostic;
+	}
+	/** The JSON-RPC error object for a response. */
+	toErrorObject() {
+		return {
+			code: this.code,
+			message: this.diagnostic.message,
+			data: this.diagnostic
+		};
+	}
+	/**
+	* Reads a received error object. When its `data` isn't a diagnostic (a peer that isn't Mostra),
+	* the result is a `MOSTRA_HOST_MALFORMED` diagnostic that keeps the peer's message.
+	*/
+	static fromErrorObject(error, docsBase) {
+		const parsed = Diagnostic.safeParse(error.data);
+		if (parsed.success) return new RpcError(parsed.data, error.code);
+		return new RpcError(hostDiagnostic("MOSTRA_HOST_MALFORMED", { message: `The other side answered with error ${error.code} without a diagnostic: ${error.message.slice(0, 200)}` }, docsBase), error.code);
+	}
+};
+/**
+* Builds a HOST-area diagnostic from that area's catalog alone, so the JSON-RPC core doesn't pull
+* every area's text into browser bundles (D83).
+*/
+function hostDiagnostic(code, details, docsBase) {
+	return buildDiagnostic(code, hostDiagnostics[code], details, docsBase);
+}
+//#endregion
+export { JSON_RPC_ERROR_CODES, RpcError, hostDiagnostic };
+
+//# sourceMappingURL=error.js.map

package/dist/rpc/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","names":[],"sources":["../../src/rpc/error.ts"],"sourcesContent":["/**\n * Errors on a JSON-RPC connection. Every error carries a diagnostic (INTERFACES §1, §6): the\n * JSON-RPC `error.code` says which kind of failure it is, and `error.data` is the diagnostic.\n */\nimport { type HostDiagnosticCode, hostDiagnostics } from \"../diagnostics/codes/host.ts\";\nimport { Diagnostic } from \"../diagnostics/diagnostic.ts\";\nimport { buildDiagnostic, type DiagnosticDetails } from \"../diagnostics/spec.ts\";\nimport type { JsonRpcErrorObject } from \"./messages.ts\";\n\n/** The JSON-RPC 2.0 error codes Mostra uses (INTERFACES §6). */\nexport const JSON_RPC_ERROR_CODES: {\n  /** The line wasn't valid JSON. */\n  readonly parseError: -32700;\n  /** The message wasn't a valid request, or was a batch. */\n  readonly invalidRequest: -32600;\n  /** The method doesn't exist on this side. */\n  readonly methodNotFound: -32601;\n  /** The params failed the method's schema. */\n  readonly invalidParams: -32602;\n  /** An unexpected failure. */\n  readonly internalError: -32603;\n  /** Every other diagnostic. */\n  readonly diagnostic: -32000;\n} = {\n  parseError: -32700,\n  invalidRequest: -32600,\n  methodNotFound: -32601,\n  invalidParams: -32602,\n  internalError: -32603,\n  diagnostic: -32000,\n};\n\nfunction codeFor(diagnostic: Diagnostic): number {\n  switch (diagnostic.code) {\n    case \"MOSTRA_HOST_MALFORMED\":\n      return JSON_RPC_ERROR_CODES.invalidRequest;\n    case \"MOSTRA_HOST_METHOD_UNKNOWN\":\n      return JSON_RPC_ERROR_CODES.methodNotFound;\n    case \"MOSTRA_HOST_INVALID_PARAMS\":\n      return JSON_RPC_ERROR_CODES.invalidParams;\n    case \"MOSTRA_HOST_INTERNAL_ERROR\":\n      return JSON_RPC_ERROR_CODES.internalError;\n    default:\n      return JSON_RPC_ERROR_CODES.diagnostic;\n  }\n}\n\n/**\n * An error that crosses a connection as a JSON-RPC error. Throw it from a request handler to\n * answer with this diagnostic; a request's promise rejects with it when the other side answers\n * with an error, the connection closes or the request times out.\n *\n * ```ts\n * throw new RpcError(\n *   createDiagnostic(\"MOSTRA_HOME_MISMATCH\", { message: \"This instance serves /a, not /b.\" }),\n * );\n * ```\n */\nexport class RpcError extends Error {\n  /** The JSON-RPC error code. */\n  readonly code: number;\n  /** The diagnostic: what happened and what to do. */\n  readonly diagnostic: Diagnostic;\n\n  constructor(diagnostic: Diagnostic, code: number = codeFor(diagnostic)) {\n    super(diagnostic.message);\n    this.name = \"RpcError\";\n    this.code = code;\n    this.diagnostic = diagnostic;\n  }\n\n  /** The JSON-RPC error object for a response. */\n  toErrorObject(): JsonRpcErrorObject {\n    return { code: this.code, message: this.diagnostic.message, data: this.diagnostic };\n  }\n\n  /**\n   * Reads a received error object. When its `data` isn't a diagnostic (a peer that isn't Mostra),\n   * the result is a `MOSTRA_HOST_MALFORMED` diagnostic that keeps the peer's message.\n   */\n  static fromErrorObject(error: JsonRpcErrorObject, docsBase?: string): RpcError {\n    const parsed = Diagnostic.safeParse(error.data);\n    if (parsed.success) return new RpcError(parsed.data, error.code);\n    return new RpcError(\n      hostDiagnostic(\n        \"MOSTRA_HOST_MALFORMED\",\n        {\n          message: `The other side answered with error ${error.code} without a diagnostic: ${error.message.slice(0, 200)}`,\n        },\n        docsBase,\n      ),\n      error.code,\n    );\n  }\n}\n\n/**\n * Builds a HOST-area diagnostic from that area's catalog alone, so the JSON-RPC core doesn't pull\n * every area's text into browser bundles (D83).\n */\nexport function hostDiagnostic(\n  code: HostDiagnosticCode,\n  details: DiagnosticDetails,\n  docsBase?: string,\n): Diagnostic {\n  return buildDiagnostic(code, hostDiagnostics[code], details, docsBase);\n}\n"],"mappings":";;;;;;;;;AAUA,MAAa,uBAaT;CACF,YAAY;CACZ,gBAAgB;CAChB,gBAAgB;CAChB,eAAe;CACf,eAAe;CACf,YAAY;AACd;AAEA,SAAS,QAAQ,YAAgC;CAC/C,QAAQ,WAAW,MAAnB;EACE,KAAK,yBACH,OAAO,qBAAqB;EAC9B,KAAK,8BACH,OAAO,qBAAqB;EAC9B,KAAK,8BACH,OAAO,qBAAqB;EAC9B,KAAK,8BACH,OAAO,qBAAqB;EAC9B,SACE,OAAO,qBAAqB;CAChC;AACF;;;;;;;;;;;;AAaA,IAAa,WAAb,MAAa,iBAAiB,MAAM;;CAElC;;CAEA;CAEA,YAAY,YAAwB,OAAe,QAAQ,UAAU,GAAG;EACtE,MAAM,WAAW,OAAO;EACxB,KAAK,OAAO;EACZ,KAAK,OAAO;EACZ,KAAK,aAAa;CACpB;;CAGA,gBAAoC;EAClC,OAAO;GAAE,MAAM,KAAK;GAAM,SAAS,KAAK,WAAW;GAAS,MAAM,KAAK;EAAW;CACpF;;;;;CAMA,OAAO,gBAAgB,OAA2B,UAA6B;EAC7E,MAAM,SAAS,WAAW,UAAU,MAAM,IAAI;EAC9C,IAAI,OAAO,SAAS,OAAO,IAAI,SAAS,OAAO,MAAM,MAAM,IAAI;EAC/D,OAAO,IAAI,SACT,eACE,yBACA,EACE,SAAS,sCAAsC,MAAM,KAAK,yBAAyB,MAAM,QAAQ,MAAM,GAAG,GAAG,IAC/G,GACA,QACF,GACA,MAAM,IACR;CACF;AACF;;;;;AAMA,SAAgB,eACd,MACA,SACA,UACY;CACZ,OAAO,gBAAgB,MAAM,gBAAgB,OAAO,SAAS,QAAQ;AACvE"}

package/dist/rpc/lines.d.ts

@@ -0,0 +1,30 @@
+import { JsonRpcMessage } from "./messages.js";
+//#region src/rpc/lines.d.ts
+/**
+ * The longest line, in UTF-16 code units, either side of a newline-delimited connection accepts:
+ * 64 Mi. Writers check it too, so a message that couldn't be read is never sent.
+ */
+export declare const MAX_LINE_LENGTH: number;
+/** Serializes one message as a line, newline included. */
+export declare function encodeLine(message: JsonRpcMessage): string;
+/**
+ * Splits decoded text into lines. Feed it chunks as they arrive; it returns the complete lines
+ * and keeps the unfinished rest. A line longer than `maxLineLength` characters throws a
+ * `RangeError`, so a peer can't make the other side buffer without bound: the transport then
+ * answers with `MOSTRA_HOST_MALFORMED` and closes the connection.
+ */
+export declare class LineSplitter {
+  #private;
+  /** @param maxLineLength - The longest line accepted, in UTF-16 code units. Default 64 Mi. */
+  constructor(maxLineLength?: number);
+  /**
+   * Returns the lines completed by `chunk`, without their newlines (and without a trailing `\r`).
+   * Only `chunk` is searched for newlines, so a long line costs time in proportion to its length,
+   * however many chunks bring it.
+   */
+  push(chunk: string): string[];
+  /** The unfinished text after the last newline. A stream that ends with it holds a cut-off message. */
+  get rest(): string;
+}
+//#endregion
+//# sourceMappingURL=lines.d.ts.map

package/dist/rpc/lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lines.d.ts","names":[],"sources":["../../src/rpc/lines.ts"],"mappings":";;;;;;qBAUa;;wBAGG,WAAW,SAAS;;;;;;;qBAUvB;;;EAOX,YAAY;;;;;;EASZ,KAAK;;MAqBD"}

package/dist/rpc/lines.js

@@ -0,0 +1,63 @@
+//#region src/rpc/lines.ts
+/**
+* The longest line, in UTF-16 code units, either side of a newline-delimited connection accepts:
+* 64 Mi. Writers check it too, so a message that couldn't be read is never sent.
+*/
+const MAX_LINE_LENGTH = 67108864;
+/** Serializes one message as a line, newline included. */
+function encodeLine(message) {
+	return `${JSON.stringify(message)}\n`;
+}
+/**
+* Splits decoded text into lines. Feed it chunks as they arrive; it returns the complete lines
+* and keeps the unfinished rest. A line longer than `maxLineLength` characters throws a
+* `RangeError`, so a peer can't make the other side buffer without bound: the transport then
+* answers with `MOSTRA_HOST_MALFORMED` and closes the connection.
+*/
+var LineSplitter = class {
+	#maxLineLength;
+	/** The unfinished line, in the pieces it arrived in: joined only once its newline comes. */
+	#pending = [];
+	#pendingLength = 0;
+	/** @param maxLineLength - The longest line accepted, in UTF-16 code units. Default 64 Mi. */
+	constructor(maxLineLength = MAX_LINE_LENGTH) {
+		this.#maxLineLength = maxLineLength;
+	}
+	/**
+	* Returns the lines completed by `chunk`, without their newlines (and without a trailing `\r`).
+	* Only `chunk` is searched for newlines, so a long line costs time in proportion to its length,
+	* however many chunks bring it.
+	*/
+	push(chunk) {
+		const lines = [];
+		let start = 0;
+		for (let index = chunk.indexOf("\n"); index >= 0; index = chunk.indexOf("\n", start)) {
+			if (this.#pendingLength + index - start > this.#maxLineLength) this.#overflow();
+			this.#pending.push(chunk.slice(start, index));
+			const line = this.#pending.join("");
+			this.#pending = [];
+			this.#pendingLength = 0;
+			lines.push(line.endsWith("\r") ? line.slice(0, -1) : line);
+			start = index + 1;
+		}
+		if (start < chunk.length) {
+			this.#pendingLength += chunk.length - start;
+			if (this.#pendingLength > this.#maxLineLength) this.#overflow();
+			this.#pending.push(chunk.slice(start));
+		}
+		return lines;
+	}
+	/** The unfinished text after the last newline. A stream that ends with it holds a cut-off message. */
+	get rest() {
+		return this.#pending.join("");
+	}
+	#overflow() {
+		this.#pending = [];
+		this.#pendingLength = 0;
+		throw new RangeError(`A message is longer than ${this.#maxLineLength} characters.`);
+	}
+};
+//#endregion
+export { LineSplitter, MAX_LINE_LENGTH, encodeLine };
+
+//# sourceMappingURL=lines.js.map

package/dist/rpc/lines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lines.js","names":[],"sources":["../../src/rpc/lines.ts"],"sourcesContent":["/**\n * Newline-delimited JSON framing for byte streams (stdio, Unix sockets): one message per line.\n * JSON text never contains a raw newline, so a newline always ends a message.\n */\nimport type { JsonRpcMessage } from \"./messages.ts\";\n\n/**\n * The longest line, in UTF-16 code units, either side of a newline-delimited connection accepts:\n * 64 Mi. Writers check it too, so a message that couldn't be read is never sent.\n */\nexport const MAX_LINE_LENGTH: number = 64 * 1024 * 1024;\n\n/** Serializes one message as a line, newline included. */\nexport function encodeLine(message: JsonRpcMessage): string {\n  return `${JSON.stringify(message)}\\n`;\n}\n\n/**\n * Splits decoded text into lines. Feed it chunks as they arrive; it returns the complete lines\n * and keeps the unfinished rest. A line longer than `maxLineLength` characters throws a\n * `RangeError`, so a peer can't make the other side buffer without bound: the transport then\n * answers with `MOSTRA_HOST_MALFORMED` and closes the connection.\n */\nexport class LineSplitter {\n  readonly #maxLineLength: number;\n  /** The unfinished line, in the pieces it arrived in: joined only once its newline comes. */\n  #pending: string[] = [];\n  #pendingLength = 0;\n\n  /** @param maxLineLength - The longest line accepted, in UTF-16 code units. Default 64 Mi. */\n  constructor(maxLineLength: number = MAX_LINE_LENGTH) {\n    this.#maxLineLength = maxLineLength;\n  }\n\n  /**\n   * Returns the lines completed by `chunk`, without their newlines (and without a trailing `\\r`).\n   * Only `chunk` is searched for newlines, so a long line costs time in proportion to its length,\n   * however many chunks bring it.\n   */\n  push(chunk: string): string[] {\n    const lines: string[] = [];\n    let start = 0;\n    for (let index = chunk.indexOf(\"\\n\"); index >= 0; index = chunk.indexOf(\"\\n\", start)) {\n      if (this.#pendingLength + index - start > this.#maxLineLength) this.#overflow();\n      this.#pending.push(chunk.slice(start, index));\n      const line = this.#pending.join(\"\");\n      this.#pending = [];\n      this.#pendingLength = 0;\n      lines.push(line.endsWith(\"\\r\") ? line.slice(0, -1) : line);\n      start = index + 1;\n    }\n    if (start < chunk.length) {\n      this.#pendingLength += chunk.length - start;\n      if (this.#pendingLength > this.#maxLineLength) this.#overflow();\n      this.#pending.push(chunk.slice(start));\n    }\n    return lines;\n  }\n\n  /** The unfinished text after the last newline. A stream that ends with it holds a cut-off message. */\n  get rest(): string {\n    return this.#pending.join(\"\");\n  }\n\n  #overflow(): never {\n    this.#pending = [];\n    this.#pendingLength = 0;\n    throw new RangeError(`A message is longer than ${this.#maxLineLength} characters.`);\n  }\n}\n"],"mappings":";;;;;AAUA,MAAa,kBAA0B;;AAGvC,SAAgB,WAAW,SAAiC;CAC1D,OAAO,GAAG,KAAK,UAAU,OAAO,EAAE;AACpC;;;;;;;AAQA,IAAa,eAAb,MAA0B;CACxB;;CAEA,WAAqB,CAAC;CACtB,iBAAiB;;CAGjB,YAAY,gBAAwB,iBAAiB;EACnD,KAAK,iBAAiB;CACxB;;;;;;CAOA,KAAK,OAAyB;EAC5B,MAAM,QAAkB,CAAC;EACzB,IAAI,QAAQ;EACZ,KAAK,IAAI,QAAQ,MAAM,QAAQ,IAAI,GAAG,SAAS,GAAG,QAAQ,MAAM,QAAQ,MAAM,KAAK,GAAG;GACpF,IAAI,KAAK,iBAAiB,QAAQ,QAAQ,KAAK,gBAAgB,KAAK,UAAU;GAC9E,KAAK,SAAS,KAAK,MAAM,MAAM,OAAO,KAAK,CAAC;GAC5C,MAAM,OAAO,KAAK,SAAS,KAAK,EAAE;GAClC,KAAK,WAAW,CAAC;GACjB,KAAK,iBAAiB;GACtB,MAAM,KAAK,KAAK,SAAS,IAAI,IAAI,KAAK,MAAM,GAAG,EAAE,IAAI,IAAI;GACzD,QAAQ,QAAQ;EAClB;EACA,IAAI,QAAQ,MAAM,QAAQ;GACxB,KAAK,kBAAkB,MAAM,SAAS;GACtC,IAAI,KAAK,iBAAiB,KAAK,gBAAgB,KAAK,UAAU;GAC9D,KAAK,SAAS,KAAK,MAAM,MAAM,KAAK,CAAC;EACvC;EACA,OAAO;CACT;;CAGA,IAAI,OAAe;EACjB,OAAO,KAAK,SAAS,KAAK,EAAE;CAC9B;CAEA,YAAmB;EACjB,KAAK,WAAW,CAAC;EACjB,KAAK,iBAAiB;EACtB,MAAM,IAAI,WAAW,4BAA4B,KAAK,eAAe,aAAa;CACpF;AACF"}

package/dist/rpc/messages.d.ts

@@ -0,0 +1,92 @@
+import * as z from "zod";
+//#region src/rpc/messages.d.ts
+/** A request ID: a string or a number, chosen by the sender and echoed in the response. */
+export type JsonRpcId = string | number;
+/** Request params: a JSON object (Mostra always uses objects) or an array. */
+export type JsonRpcParams = Readonly<Record<string, unknown>> | readonly unknown[];
+/** A request: the receiver answers with a response carrying the same `id`. */
+export interface JsonRpcRequest {
+  /** Always `"2.0"`. */
+  readonly jsonrpc: "2.0";
+  /** Chosen by the sender; the response carries the same ID. */
+  readonly id: JsonRpcId;
+  /** The method name, `group/name` or a bare name. */
+  readonly method: string;
+  /** The method's params. */
+  readonly params?: JsonRpcParams;
+}
+/** A notification: a request without an `id`, which is never answered. */
+export interface JsonRpcNotification {
+  /** Always `"2.0"`. */
+  readonly jsonrpc: "2.0";
+  /** The notification's method name. */
+  readonly method: string;
+  /** The notification's params. */
+  readonly params?: JsonRpcParams;
+}
+/** The error member of a failed response. Mostra puts the diagnostic in `data`. */
+export interface JsonRpcErrorObject {
+  /** The JSON-RPC error code (INTERFACES §6). */
+  readonly code: number;
+  /** A short description; clients switch on `data.code`, never on this text. */
+  readonly message: string;
+  /** The diagnostic (INTERFACES §13). */
+  readonly data?: unknown;
+}
+/** A successful response. */
+export interface JsonRpcSuccess {
+  /** Always `"2.0"`. */
+  readonly jsonrpc: "2.0";
+  /** The ID of the request this answers. */
+  readonly id: JsonRpcId;
+  /** The method's result. */
+  readonly result: unknown;
+}
+/** A failed response. `id` is `null` when the request's ID couldn't be read. */
+export interface JsonRpcFailure {
+  /** Always `"2.0"`. */
+  readonly jsonrpc: "2.0";
+  /** The ID of the request this answers, or `null` when it couldn't be read. */
+  readonly id: JsonRpcId | null;
+  /** What went wrong. */
+  readonly error: JsonRpcErrorObject;
+}
+/** A response to a request. */
+export type JsonRpcResponse = JsonRpcSuccess | JsonRpcFailure;
+/** Any message on a Mostra connection. */
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+/** The Zod schema of the `JsonRpcRequest` type. */
+export declare const JsonRpcRequest: z.ZodType<JsonRpcRequest>;
+/** The Zod schema of the `JsonRpcNotification` type. */
+export declare const JsonRpcNotification: z.ZodType<JsonRpcNotification>;
+/** The Zod schema of the `JsonRpcErrorObject` type. */
+export declare const JsonRpcErrorObject: z.ZodType<JsonRpcErrorObject>;
+/** The Zod schema of the `JsonRpcSuccess` type. */
+export declare const JsonRpcSuccess: z.ZodType<JsonRpcSuccess>;
+/** The Zod schema of the `JsonRpcFailure` type. */
+export declare const JsonRpcFailure: z.ZodType<JsonRpcFailure>;
+/** A message sorted by kind, or the reason it isn't a valid message. */
+export type ClassifiedMessage = {
+  readonly kind: "request";
+  readonly message: JsonRpcRequest;
+} | {
+  readonly kind: "notification";
+  readonly message: JsonRpcNotification;
+} | {
+  readonly kind: "success";
+  readonly message: JsonRpcSuccess;
+} | {
+  readonly kind: "failure";
+  readonly message: JsonRpcFailure;
+} | {
+  readonly kind: "invalid";
+  readonly reason: string;
+  readonly id: JsonRpcId | null;
+};
+/**
+ * Sorts a parsed JSON value into a request, notification, success or failure, or explains why it
+ * is none of them. A JSON array (a batch) is invalid in revision `2026-10-10` (D83).
+ */
+export declare function classifyMessage(value: unknown): ClassifiedMessage;
+//#endregion
+//# sourceMappingURL=messages.d.ts.map

package/dist/rpc/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","names":[],"sources":["../../src/rpc/messages.ts"],"mappings":";;;YASY;;YAGA,gBAAgB,SAAS;;iBAGpB;;WAEN;;WAEA,IAAI;;WAEJ;;WAEA,SAAS;;;iBAIH;;WAEN;;WAEA;;WAEA,SAAS;;;iBAIH;;WAEN;;WAEA;;WAEA;;;iBAIM;;WAEN;;WAEA,IAAI;;WAEJ;;;iBAIM;;WAEN;;WAEA,IAAI;;WAEJ,OAAO;;;YAIN,kBAAkB,iBAAiB;;YAGnC,iBAAiB,iBAAiB,sBAAsB;;qBAUvD,gBAAgB,EAAE,QAAQ;;qBAQ1B,qBAAqB,EAAE,QAAQ;;qBAQ/B,oBAAoB,EAAE,QAAQ;;qBAQ9B,gBAAgB,EAAE,QAAQ;;qBAQ1B,gBAAgB,EAAE,QAAQ;;YAQ3B;WACG;WAA0B,SAAS;;WACnC;WAA+B,SAAS;;WACxC;WAA0B,SAAS;;WACnC;WAA0B,SAAS;;WACnC;WAA0B;WAAyB,IAAI;;;;;;wBAStD,gBAAgB,iBAAiB"}

package/dist/rpc/messages.js

@@ -0,0 +1,133 @@
+import { wireRegistry } from "../wire-registry.js";
+import * as z from "zod";
+//#region src/rpc/messages.ts
+/**
+* JSON-RPC 2.0 message shapes (D59, D83). Every Mostra connection carries these: the host protocol
+* over stdio or the home socket, child-process messaging and the shell bridge. Revision
+* `2026-10-10` has no batches.
+*/
+const version = z.literal("2.0");
+const id = z.union([z.string(), z.number()]);
+const params = z.union([z.record(z.string(), z.unknown()), z.array(z.unknown()).readonly()]);
+/** The Zod schema of the `JsonRpcRequest` type. */
+const JsonRpcRequest = z.object({
+	jsonrpc: version,
+	id,
+	method: z.string(),
+	params: params.exactOptional()
+}).register(wireRegistry, {
+	id: "JsonRpcRequest",
+	description: "A JSON-RPC 2.0 request: answered by a response with the same id."
+});
+/** The Zod schema of the `JsonRpcNotification` type. */
+const JsonRpcNotification = z.object({
+	jsonrpc: version,
+	method: z.string(),
+	params: params.exactOptional()
+}).register(wireRegistry, {
+	id: "JsonRpcNotification",
+	description: "A JSON-RPC 2.0 notification: a request without an id, never answered."
+});
+/** The Zod schema of the `JsonRpcErrorObject` type. */
+const JsonRpcErrorObject = z.object({
+	code: z.int(),
+	message: z.string(),
+	data: z.unknown().exactOptional()
+}).register(wireRegistry, {
+	id: "JsonRpcErrorObject",
+	description: "The error of a failed JSON-RPC 2.0 response; Mostra puts the diagnostic in data."
+});
+/** The Zod schema of the `JsonRpcSuccess` type. */
+const JsonRpcSuccess = z.object({
+	jsonrpc: version,
+	id,
+	result: z.unknown()
+}).register(wireRegistry, {
+	id: "JsonRpcSuccess",
+	description: "A successful JSON-RPC 2.0 response."
+});
+/** The Zod schema of the `JsonRpcFailure` type. */
+const JsonRpcFailure = z.object({
+	jsonrpc: version,
+	id: id.nullable(),
+	error: JsonRpcErrorObject
+}).register(wireRegistry, {
+	id: "JsonRpcFailure",
+	description: "A failed JSON-RPC 2.0 response; id is null when the request's id was unreadable."
+});
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Sorts a parsed JSON value into a request, notification, success or failure, or explains why it
+* is none of them. A JSON array (a batch) is invalid in revision `2026-10-10` (D83).
+*/
+function classifyMessage(value) {
+	if (Array.isArray(value)) return {
+		kind: "invalid",
+		reason: "Batches (JSON arrays) aren't supported in host protocol revision 2026-10-10.",
+		id: null
+	};
+	if (!isObject(value)) return {
+		kind: "invalid",
+		reason: "A message must be a JSON object.",
+		id: null
+	};
+	const rawId = value["id"];
+	const readableId = typeof rawId === "string" || typeof rawId === "number" ? rawId : null;
+	if (value["jsonrpc"] !== "2.0") return {
+		kind: "invalid",
+		reason: "A message must have \"jsonrpc\": \"2.0\".",
+		id: readableId
+	};
+	if ("method" in value) {
+		if ("id" in value) {
+			const parsed = JsonRpcRequest.safeParse(value);
+			return parsed.success ? {
+				kind: "request",
+				message: parsed.data
+			} : {
+				kind: "invalid",
+				reason: describeRequestProblem(value),
+				id: readableId
+			};
+		}
+		const parsed = JsonRpcNotification.safeParse(value);
+		return parsed.success ? {
+			kind: "notification",
+			message: parsed.data
+		} : {
+			kind: "invalid",
+			reason: describeRequestProblem(value),
+			id: null
+		};
+	}
+	const hasResult = "result" in value;
+	if (hasResult !== "error" in value && "id" in value) {
+		if (hasResult) {
+			const parsed = JsonRpcSuccess.safeParse(value);
+			if (parsed.success) return {
+				kind: "success",
+				message: parsed.data
+			};
+		} else {
+			const parsed = JsonRpcFailure.safeParse(value);
+			if (parsed.success) return {
+				kind: "failure",
+				message: parsed.data
+			};
+		}
+	}
+	return {
+		kind: "invalid",
+		reason: "A message must be a request (with \"method\") or a response (with \"id\" and exactly one of \"result\" and \"error\").",
+		id: readableId
+	};
+}
+function describeRequestProblem(value) {
+	if (typeof value["method"] !== "string") return "A request's \"method\" must be a string.";
+	if ("id" in value && typeof value["id"] !== "string" && typeof value["id"] !== "number") return "A request's \"id\" must be a string or a number.";
+	return "A request's \"params\" must be an object or an array.";
+}
+//#endregion
+export { JsonRpcErrorObject, JsonRpcFailure, JsonRpcNotification, JsonRpcRequest, JsonRpcSuccess, classifyMessage };
+
+//# sourceMappingURL=messages.js.map

package/dist/rpc/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","names":[],"sources":["../../src/rpc/messages.ts"],"sourcesContent":["/**\n * JSON-RPC 2.0 message shapes (D59, D83). Every Mostra connection carries these: the host protocol\n * over stdio or the home socket, child-process messaging and the shell bridge. Revision\n * `2026-10-10` has no batches.\n */\nimport * as z from \"zod\";\nimport { wireRegistry } from \"../wire-registry.ts\";\n\n/** A request ID: a string or a number, chosen by the sender and echoed in the response. */\nexport type JsonRpcId = string | number;\n\n/** Request params: a JSON object (Mostra always uses objects) or an array. */\nexport type JsonRpcParams = Readonly<Record<string, unknown>> | readonly unknown[];\n\n/** A request: the receiver answers with a response carrying the same `id`. */\nexport interface JsonRpcRequest {\n  /** Always `\"2.0\"`. */\n  readonly jsonrpc: \"2.0\";\n  /** Chosen by the sender; the response carries the same ID. */\n  readonly id: JsonRpcId;\n  /** The method name, `group/name` or a bare name. */\n  readonly method: string;\n  /** The method's params. */\n  readonly params?: JsonRpcParams;\n}\n\n/** A notification: a request without an `id`, which is never answered. */\nexport interface JsonRpcNotification {\n  /** Always `\"2.0\"`. */\n  readonly jsonrpc: \"2.0\";\n  /** The notification's method name. */\n  readonly method: string;\n  /** The notification's params. */\n  readonly params?: JsonRpcParams;\n}\n\n/** The error member of a failed response. Mostra puts the diagnostic in `data`. */\nexport interface JsonRpcErrorObject {\n  /** The JSON-RPC error code (INTERFACES §6). */\n  readonly code: number;\n  /** A short description; clients switch on `data.code`, never on this text. */\n  readonly message: string;\n  /** The diagnostic (INTERFACES §13). */\n  readonly data?: unknown;\n}\n\n/** A successful response. */\nexport interface JsonRpcSuccess {\n  /** Always `\"2.0\"`. */\n  readonly jsonrpc: \"2.0\";\n  /** The ID of the request this answers. */\n  readonly id: JsonRpcId;\n  /** The method's result. */\n  readonly result: unknown;\n}\n\n/** A failed response. `id` is `null` when the request's ID couldn't be read. */\nexport interface JsonRpcFailure {\n  /** Always `\"2.0\"`. */\n  readonly jsonrpc: \"2.0\";\n  /** The ID of the request this answers, or `null` when it couldn't be read. */\n  readonly id: JsonRpcId | null;\n  /** What went wrong. */\n  readonly error: JsonRpcErrorObject;\n}\n\n/** A response to a request. */\nexport type JsonRpcResponse = JsonRpcSuccess | JsonRpcFailure;\n\n/** Any message on a Mostra connection. */\nexport type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;\n\nconst version = z.literal(\"2.0\");\nconst id: z.ZodType<JsonRpcId> = z.union([z.string(), z.number()]);\nconst params: z.ZodType<JsonRpcParams> = z.union([\n  z.record(z.string(), z.unknown()),\n  z.array(z.unknown()).readonly(),\n]);\n\n/** The Zod schema of the `JsonRpcRequest` type. */\nexport const JsonRpcRequest: z.ZodType<JsonRpcRequest> = z\n  .object({ jsonrpc: version, id, method: z.string(), params: params.exactOptional() })\n  .register(wireRegistry, {\n    id: \"JsonRpcRequest\",\n    description: \"A JSON-RPC 2.0 request: answered by a response with the same id.\",\n  });\n\n/** The Zod schema of the `JsonRpcNotification` type. */\nexport const JsonRpcNotification: z.ZodType<JsonRpcNotification> = z\n  .object({ jsonrpc: version, method: z.string(), params: params.exactOptional() })\n  .register(wireRegistry, {\n    id: \"JsonRpcNotification\",\n    description: \"A JSON-RPC 2.0 notification: a request without an id, never answered.\",\n  });\n\n/** The Zod schema of the `JsonRpcErrorObject` type. */\nexport const JsonRpcErrorObject: z.ZodType<JsonRpcErrorObject> = z\n  .object({ code: z.int(), message: z.string(), data: z.unknown().exactOptional() })\n  .register(wireRegistry, {\n    id: \"JsonRpcErrorObject\",\n    description: \"The error of a failed JSON-RPC 2.0 response; Mostra puts the diagnostic in data.\",\n  });\n\n/** The Zod schema of the `JsonRpcSuccess` type. */\nexport const JsonRpcSuccess: z.ZodType<JsonRpcSuccess> = z\n  .object({ jsonrpc: version, id, result: z.unknown() })\n  .register(wireRegistry, {\n    id: \"JsonRpcSuccess\",\n    description: \"A successful JSON-RPC 2.0 response.\",\n  });\n\n/** The Zod schema of the `JsonRpcFailure` type. */\nexport const JsonRpcFailure: z.ZodType<JsonRpcFailure> = z\n  .object({ jsonrpc: version, id: id.nullable(), error: JsonRpcErrorObject })\n  .register(wireRegistry, {\n    id: \"JsonRpcFailure\",\n    description: \"A failed JSON-RPC 2.0 response; id is null when the request's id was unreadable.\",\n  });\n\n/** A message sorted by kind, or the reason it isn't a valid message. */\nexport type ClassifiedMessage =\n  | { readonly kind: \"request\"; readonly message: JsonRpcRequest }\n  | { readonly kind: \"notification\"; readonly message: JsonRpcNotification }\n  | { readonly kind: \"success\"; readonly message: JsonRpcSuccess }\n  | { readonly kind: \"failure\"; readonly message: JsonRpcFailure }\n  | { readonly kind: \"invalid\"; readonly reason: string; readonly id: JsonRpcId | null };\n\nconst isObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\n/**\n * Sorts a parsed JSON value into a request, notification, success or failure, or explains why it\n * is none of them. A JSON array (a batch) is invalid in revision `2026-10-10` (D83).\n */\nexport function classifyMessage(value: unknown): ClassifiedMessage {\n  if (Array.isArray(value)) {\n    return {\n      kind: \"invalid\",\n      reason: \"Batches (JSON arrays) aren't supported in host protocol revision 2026-10-10.\",\n      id: null,\n    };\n  }\n  if (!isObject(value)) {\n    return { kind: \"invalid\", reason: \"A message must be a JSON object.\", id: null };\n  }\n  const rawId = value[\"id\"];\n  const readableId = typeof rawId === \"string\" || typeof rawId === \"number\" ? rawId : null;\n  if (value[\"jsonrpc\"] !== \"2.0\") {\n    return { kind: \"invalid\", reason: 'A message must have \"jsonrpc\": \"2.0\".', id: readableId };\n  }\n  if (\"method\" in value) {\n    if (\"id\" in value) {\n      const parsed = JsonRpcRequest.safeParse(value);\n      return parsed.success\n        ? { kind: \"request\", message: parsed.data }\n        : { kind: \"invalid\", reason: describeRequestProblem(value), id: readableId };\n    }\n    const parsed = JsonRpcNotification.safeParse(value);\n    return parsed.success\n      ? { kind: \"notification\", message: parsed.data }\n      : { kind: \"invalid\", reason: describeRequestProblem(value), id: null };\n  }\n  const hasResult = \"result\" in value;\n  const hasError = \"error\" in value;\n  if (hasResult !== hasError && \"id\" in value) {\n    if (hasResult) {\n      const parsed = JsonRpcSuccess.safeParse(value);\n      if (parsed.success) return { kind: \"success\", message: parsed.data };\n    } else {\n      const parsed = JsonRpcFailure.safeParse(value);\n      if (parsed.success) return { kind: \"failure\", message: parsed.data };\n    }\n  }\n  return {\n    kind: \"invalid\",\n    reason:\n      'A message must be a request (with \"method\") or a response (with \"id\" and exactly one of \"result\" and \"error\").',\n    id: readableId,\n  };\n}\n\nfunction describeRequestProblem(value: Record<string, unknown>): string {\n  if (typeof value[\"method\"] !== \"string\") return 'A request\\'s \"method\" must be a string.';\n  if (\"id\" in value && typeof value[\"id\"] !== \"string\" && typeof value[\"id\"] !== \"number\") {\n    return 'A request\\'s \"id\" must be a string or a number.';\n  }\n  return 'A request\\'s \"params\" must be an object or an array.';\n}\n"],"mappings":"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"}