@theruntime/protocol 0.0.0 → 0.0.1

package/src/operations/list-subscriptions.ts

@@ -0,0 +1,98 @@
+import { PROTOCOL_VERSION, type ProtocolVersion } from "../version";
+import {
+  asRecord,
+  optionalPositiveInteger,
+  optionalString,
+  requireNonNegativeInteger,
+  requireOperation,
+  requireProtocol,
+  requireString,
+} from "./parse-helpers";
+
+const NOUN = "a listSubscriptions input";
+
+export interface ListSubscriptionsInput {
+  readonly operation: "listSubscriptions";
+  readonly protocol: ProtocolVersion;
+  /** The claimed subject of the read: the session the caller is asking about. The daemon does
+   * not verify it. A caller states which session it means, and gets that session's rows. */
+  readonly sid: string;
+  readonly limit?: number;
+}
+
+export function parseListSubscriptionsInput(value: unknown): ListSubscriptionsInput {
+  const record = asRecord(value, NOUN);
+  requireOperation(record, "listSubscriptions", NOUN);
+  requireProtocol(record, NOUN);
+  const sid = requireString(record, "sid", NOUN);
+  const limit = optionalPositiveInteger(record, "limit", NOUN);
+  return {
+    operation: "listSubscriptions",
+    protocol: PROTOCOL_VERSION,
+    sid,
+    ...(limit !== undefined ? { limit } : {}),
+  };
+}
+
+export function serializeListSubscriptionsInput(input: ListSubscriptionsInput): string {
+  return JSON.stringify(input);
+}
+
+const SUMMARY_NOUN = "a subscription summary";
+
+export interface SubscriptionSummary {
+  readonly name: string;
+  readonly url: string;
+  readonly dir: string;
+  readonly updatedAt: string;
+}
+
+function parseSubscriptionSummary(value: unknown): SubscriptionSummary {
+  const record = asRecord(value, SUMMARY_NOUN);
+  return {
+    name: requireString(record, "name", SUMMARY_NOUN),
+    url: requireString(record, "url", SUMMARY_NOUN),
+    dir: requireString(record, "dir", SUMMARY_NOUN),
+    updatedAt: requireString(record, "updatedAt", SUMMARY_NOUN),
+  };
+}
+
+const RESULT_NOUN = "a listSubscriptions result";
+
+export interface ListSubscriptionsResult {
+  readonly sid: string;
+  readonly subscriptions: readonly SubscriptionSummary[];
+  /** True when the limit cut rows the session holds. What was cut was touched longer ago than
+   * what was returned. */
+  readonly truncated: boolean;
+  /** Rows naming a route the store no longer holds. unregisterRoute keeps a session's rows, so
+   * a subscription outlives its route. Such a row carries no url and is counted, not returned. */
+  readonly unregistered: number;
+  /** The key the daemon's own resolver produced for this connection, when it produced one and it
+   * differs from sid. The read still answers for sid. */
+  readonly observed?: string;
+}
+
+export function parseListSubscriptionsResult(value: unknown): ListSubscriptionsResult {
+  const record = asRecord(value, RESULT_NOUN);
+  const sid = requireString(record, "sid", RESULT_NOUN);
+  if (!Array.isArray(record.subscriptions)) {
+    throw new Error(`${RESULT_NOUN} carries an array of subscriptions`);
+  }
+  if (typeof record.truncated !== "boolean") {
+    throw new Error(`${RESULT_NOUN} says whether rows were cut`);
+  }
+  const unregistered = requireNonNegativeInteger(record, "unregistered", RESULT_NOUN);
+  const observed = optionalString(record, "observed", RESULT_NOUN);
+  return {
+    sid,
+    subscriptions: record.subscriptions.map(parseSubscriptionSummary),
+    truncated: record.truncated,
+    unregistered,
+    ...(observed !== undefined ? { observed } : {}),
+  };
+}
+
+export function serializeListSubscriptionsResult(result: ListSubscriptionsResult): string {
+  return JSON.stringify(result);
+}

package/src/operations/list-templates.ts

@@ -0,0 +1,71 @@
+import { PROTOCOL_VERSION, type ProtocolVersion } from "../version";
+import { asRecord, requireOperation, requireProtocol, requireString } from "./parse-helpers";
+
+const NOUN = "a listTemplates input";
+
+export interface ListTemplatesInput {
+  readonly operation: "listTemplates";
+  readonly protocol: ProtocolVersion;
+}
+
+export function parseListTemplatesInput(value: unknown): ListTemplatesInput {
+  const record = asRecord(value, NOUN);
+  requireOperation(record, "listTemplates", NOUN);
+  requireProtocol(record, NOUN);
+  return { operation: "listTemplates", protocol: PROTOCOL_VERSION };
+}
+
+export function serializeListTemplatesInput(input: ListTemplatesInput): string {
+  return JSON.stringify(input);
+}
+
+/**
+ * One template's whole metadata file, field for field. A template directory carries exactly this
+ * shape, so a bundle that ships a register later carries it too and needs no second parser.
+ * `preview` is a path relative to the template's own directory, or null where none is drawn yet.
+ */
+export interface TemplateSummary {
+  readonly id: string;
+  readonly title: string;
+  readonly description: string;
+  readonly purpose: string;
+  readonly preview: string | null;
+  readonly version: string;
+}
+
+const SUMMARY = "a template summary";
+
+export function parseTemplateSummary(value: unknown): TemplateSummary {
+  const record = asRecord(value, SUMMARY);
+  if (record.preview !== null && typeof record.preview !== "string") {
+    throw new Error(`${SUMMARY}'s preview is a path or null`);
+  }
+  return {
+    id: requireString(record, "id", SUMMARY),
+    title: requireString(record, "title", SUMMARY),
+    description: requireString(record, "description", SUMMARY),
+    purpose: requireString(record, "purpose", SUMMARY),
+    preview: record.preview,
+    version: requireString(record, "version", SUMMARY),
+  };
+}
+
+export function serializeTemplateSummary(summary: TemplateSummary): string {
+  return JSON.stringify(summary);
+}
+
+export interface ListTemplatesResult {
+  readonly templates: readonly TemplateSummary[];
+}
+
+export function parseListTemplatesResult(value: unknown): ListTemplatesResult {
+  const record = asRecord(value, "a listTemplates result");
+  if (!Array.isArray(record.templates)) {
+    throw new Error("a listTemplates result carries an array of templates");
+  }
+  return { templates: record.templates.map(parseTemplateSummary) };
+}
+
+export function serializeListTemplatesResult(result: ListTemplatesResult): string {
+  return JSON.stringify(result);
+}

package/src/operations/log-line.ts

@@ -0,0 +1,222 @@
+/** The shape of one line in a log: what the daemon writes, and what a log read returns. */
+import { asRecord, optionalPositiveInteger, optionalString, requireString } from "./parse-helpers";
+
+export const LOG_LEVELS = ["debug", "info", "warn", "error"] as const;
+export type LogLevel = (typeof LOG_LEVELS)[number];
+
+/**
+ * Every tag a line may carry. A tag is what a reader counts, so renaming one breaks every
+ * comparison against a log written before the rename. A tag is added here, never edited.
+ */
+export const LOG_TAGS = [
+  "daemon.start",
+  "daemon.stop",
+  "daemon.stop_error",
+  "daemon.stop_deadline",
+  "daemon.port_fallback",
+  "daemon.sessions_contract",
+  "daemon.chrome_assets",
+  "daemon.subscriptions_swept",
+  "daemon.events_pruned",
+  "daemon.processes_unreadable",
+  "daemon.data_dir_owned",
+  "session.identity_conflict",
+  "socket.frame_error",
+  "socket.connection_error",
+  "mcp.session_close_error",
+  "register.theme_unresolved",
+  "register.theme_scheme_missing",
+  "register.no_tokens",
+  "toolchain.unresolved",
+  "toolchain.manifest_unparsed",
+  "toolchain.package_install",
+  "toolchain.shadowed",
+  "toolchain.two_copies",
+  "toolchain.host_packages_cut",
+  "toolchain.host_copy",
+  "toolchain.react_unresolved",
+  "toolchain.react_major",
+  "route.spawn",
+  "route.ready",
+  "route.painted",
+  "route.exit",
+  "route.crash_restart",
+  "route.crash_refused",
+  "route.reap",
+  "route.capacity_held",
+  "route.cpu_kill",
+  "route.entry_dropped",
+  "route.orphan_reaped",
+  "route.record_unremovable",
+  "route.second_tailwind_root",
+  "route.no_tailwind_root",
+  "route.unresolved_names",
+  "route.source_missing",
+  "route.stdout",
+  "route.stderr",
+  "vite.info",
+  "vite.warn",
+  "vite.error",
+  "vite.unresolved_import",
+  "vite.optimize_start",
+  "vite.optimize_done",
+  "vite.optimized_deps",
+  "vite.reoptimize",
+  "vite.full_reload",
+  "vite.hot_update",
+  "browser.error",
+  "browser.console",
+  "proxy.window",
+  "proxy.non_2xx",
+  "proxy.outdated_dep",
+  "proxy.outdated_dep_run",
+  "proxy.unreachable",
+  "log.dropped",
+  "log.swept",
+] as const;
+export type LogTag = (typeof LOG_TAGS)[number];
+
+/** What a field beside the five may hold. A number is a number, never a number inside msg. */
+export type LogValue = string | number | boolean;
+
+/** A line before the sink stamps its timestamp. */
+export interface LogEntry {
+  readonly level: LogLevel;
+  readonly tag: LogTag;
+  readonly route?: string;
+  readonly msg: string;
+  readonly [field: string]: LogValue | undefined;
+}
+
+export interface LogLine extends LogEntry {
+  readonly t: string;
+}
+
+export const LOG_READ_LIMIT = 200;
+export const LOG_READ_LIMIT_MAX = 1000;
+
+export function isLogLevel(value: string): value is LogLevel {
+  const levels: readonly string[] = LOG_LEVELS;
+  return levels.includes(value);
+}
+
+export function isLogTag(value: string): value is LogTag {
+  const tags: readonly string[] = LOG_TAGS;
+  return tags.includes(value);
+}
+
+/** Whether a line at `level` passes a read asking for `minimum` and above. */
+export function meetsLevel(level: LogLevel, minimum: LogLevel): boolean {
+  return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(minimum);
+}
+
+const NOUN = "a log line";
+const RESERVED = new Set(["t", "level", "tag", "route", "msg"]);
+
+function logValue(value: unknown): LogValue | undefined {
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return undefined;
+}
+
+export function parseLogLine(value: unknown): LogLine {
+  const record = asRecord(value, NOUN);
+  const t = requireString(record, "t", NOUN);
+  const level = requireString(record, "level", NOUN);
+  if (!isLogLevel(level)) throw new Error(`${NOUN} carries one of the four levels`);
+  const tag = requireString(record, "tag", NOUN);
+  if (!isLogTag(tag)) throw new Error(`${NOUN} carries a tag the protocol defines`);
+  const route = optionalString(record, "route", NOUN);
+  const msg = requireString(record, "msg", NOUN);
+  const fields: Record<string, LogValue> = {};
+  for (const [field, raw] of Object.entries(record)) {
+    if (RESERVED.has(field)) continue;
+    const scalar = logValue(raw);
+    if (scalar === undefined) throw new Error(`${NOUN}'s ${field} is a flat scalar`);
+    fields[field] = scalar;
+  }
+  return { t, level, tag, ...(route !== undefined ? { route } : {}), msg, ...fields };
+}
+
+export function serializeLogLine(line: LogLine): string {
+  const { t, level, tag, route, msg, ...fields } = line;
+  return JSON.stringify({
+    t,
+    level,
+    tag,
+    ...(route !== undefined ? { route } : {}),
+    msg,
+    ...fields,
+  });
+}
+
+export interface LogReadResult {
+  readonly lines: readonly LogLine[];
+  /** True when the limit cut lines the filter had matched. The read is a tail, so what was cut
+   * is older than what was returned. */
+  readonly truncated: boolean;
+  readonly from?: string;
+  readonly to?: string;
+}
+
+export function parseLogReadResult(value: unknown): LogReadResult {
+  const record = asRecord(value, "a log read result");
+  if (!Array.isArray(record.lines)) throw new Error("a log read result carries an array of lines");
+  if (typeof record.truncated !== "boolean")
+    throw new Error("a log read result says whether lines were cut");
+  const from = optionalString(record, "from", "a log read result");
+  const to = optionalString(record, "to", "a log read result");
+  return {
+    lines: record.lines.map(parseLogLine),
+    truncated: record.truncated,
+    ...(from !== undefined ? { from } : {}),
+    ...(to !== undefined ? { to } : {}),
+  };
+}
+
+export function serializeLogReadResult(result: LogReadResult): string {
+  return JSON.stringify({
+    lines: result.lines.map((line): unknown => JSON.parse(serializeLogLine(line))),
+    truncated: result.truncated,
+    ...(result.from !== undefined ? { from: result.from } : {}),
+    ...(result.to !== undefined ? { to: result.to } : {}),
+  });
+}
+
+/** The filter every log read shares. `limit` and `level` are resolved to their defaults here. */
+export interface LogReadFilter {
+  readonly limit: number;
+  readonly level: LogLevel;
+  readonly since?: string;
+  readonly tag?: LogTag;
+}
+
+export function parseLogReadFilter(record: Record<string, unknown>, noun: string): LogReadFilter {
+  const limit = optionalPositiveInteger(record, "limit", noun);
+  if (limit !== undefined && limit > LOG_READ_LIMIT_MAX)
+    throw new Error(`${noun}'s limit is at most ${LOG_READ_LIMIT_MAX}`);
+  const since = optionalString(record, "since", noun);
+  if (since !== undefined && Number.isNaN(Date.parse(since)))
+    throw new Error(`${noun}'s since is an ISO timestamp`);
+  const level = optionalString(record, "level", noun);
+  if (level !== undefined && !isLogLevel(level))
+    throw new Error(`${noun}'s level is one of the four`);
+  const tag = optionalString(record, "tag", noun);
+  if (tag !== undefined && !isLogTag(tag))
+    throw new Error(`${noun}'s tag is one the protocol defines`);
+  return {
+    limit: limit ?? LOG_READ_LIMIT,
+    level: level ?? "info",
+    ...(since !== undefined ? { since } : {}),
+    ...(tag !== undefined ? { tag } : {}),
+  };
+}
+
+export function serializeLogReadFilter(filter: LogReadFilter): Record<string, unknown> {
+  return {
+    ...(filter.limit !== LOG_READ_LIMIT ? { limit: filter.limit } : {}),
+    ...(filter.since !== undefined ? { since: filter.since } : {}),
+    ...(filter.level !== "info" ? { level: filter.level } : {}),
+    ...(filter.tag !== undefined ? { tag: filter.tag } : {}),
+  };
+}

package/src/operations/parse-helpers.ts

@@ -0,0 +1,136 @@
+import { PROTOCOL_VERSION } from "../version";
+
+export function asRecord(value: unknown, noun: string): Record<string, unknown> {
+  if (!isRecord(value)) throw new Error(`${noun} is an object`);
+  return value;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+export function requireOperation(
+  record: Record<string, unknown>,
+  operation: string,
+  noun: string,
+): void {
+  if (record.operation !== operation) throw new Error(`${noun} names the ${operation} operation`);
+}
+
+export function requireProtocol(record: Record<string, unknown>, noun: string): void {
+  if (record.protocol !== PROTOCOL_VERSION)
+    throw new Error(`${noun} carries protocol ${PROTOCOL_VERSION}`);
+}
+
+export function requireNotification(
+  record: Record<string, unknown>,
+  notification: string,
+  noun: string,
+): void {
+  if (record.notification !== notification)
+    throw new Error(`${noun} names the ${notification} notification`);
+}
+
+export function requireString(
+  record: Record<string, unknown>,
+  field: string,
+  noun: string,
+): string {
+  const value = record[field];
+  if (typeof value !== "string" || value.trim().length === 0)
+    throw new Error(`${noun} names a ${field}`);
+  return value;
+}
+
+export function optionalString(
+  record: Record<string, unknown>,
+  field: string,
+  noun: string,
+  max?: number,
+): string | undefined {
+  if (!(field in record) || record[field] === undefined) return undefined;
+  const value = record[field];
+  if (typeof value !== "string") throw new Error(`${noun}'s ${field} is a string`);
+  if (max !== undefined && value.length > max)
+    throw new Error(`${noun}'s ${field} is at most ${max} characters`);
+  return value;
+}
+
+export function optionalBoolean(
+  record: Record<string, unknown>,
+  field: string,
+  noun: string,
+): boolean | undefined {
+  if (!(field in record) || record[field] === undefined) return undefined;
+  const value = record[field];
+  if (typeof value !== "boolean") throw new Error(`${noun}'s ${field} is a boolean`);
+  return value;
+}
+
+export function optionalStringArray(
+  record: Record<string, unknown>,
+  field: string,
+  noun: string,
+  max: number,
+): string[] | undefined {
+  if (!(field in record) || record[field] === undefined) return undefined;
+  const value = record[field];
+  if (
+    !Array.isArray(value) ||
+    !value.every((item): item is string => typeof item === "string" && item.trim().length > 0)
+  ) {
+    throw new Error(`${noun}'s ${field} is an array of non-empty strings`);
+  }
+  if (value.length > max) throw new Error(`${noun}'s ${field} carries at most ${max} entries`);
+  return value;
+}
+
+export function requirePositiveInteger(
+  record: Record<string, unknown>,
+  field: string,
+  noun: string,
+): number {
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new Error(`${noun} names a positive integer ${field}`);
+  }
+  return value;
+}
+
+export function optionalPositiveInteger(
+  record: Record<string, unknown>,
+  field: string,
+  noun: string,
+): number | undefined {
+  if (!(field in record) || record[field] === undefined) return undefined;
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new Error(`${noun}'s ${field} is a positive integer`);
+  }
+  return value;
+}
+
+export function requireNonNegativeInteger(
+  record: Record<string, unknown>,
+  field: string,
+  noun: string,
+): number {
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${noun} names a non-negative integer ${field}`);
+  }
+  return value;
+}
+
+export function optionalNonNegativeInteger(
+  record: Record<string, unknown>,
+  field: string,
+  noun: string,
+): number | undefined {
+  if (!(field in record) || record[field] === undefined) return undefined;
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${noun}'s ${field} is a non-negative integer`);
+  }
+  return value;
+}

package/src/operations/query-selection.ts

@@ -0,0 +1,44 @@
+import { PROTOCOL_VERSION, type ProtocolVersion } from "../version";
+import { asRecord, requireOperation, requireProtocol, requireString } from "./parse-helpers";
+
+const NOUN = "a querySelection input";
+
+export interface QuerySelectionInput {
+  readonly operation: "querySelection";
+  readonly protocol: ProtocolVersion;
+  readonly name: string;
+}
+
+export function parseQuerySelectionInput(value: unknown): QuerySelectionInput {
+  const record = asRecord(value, NOUN);
+  requireOperation(record, "querySelection", NOUN);
+  requireProtocol(record, NOUN);
+  const name = requireString(record, "name", NOUN);
+  return { operation: "querySelection", protocol: PROTOCOL_VERSION, name };
+}
+
+export function serializeQuerySelectionInput(input: QuerySelectionInput): string {
+  return JSON.stringify(input);
+}
+
+export interface QuerySelectionResult {
+  readonly name: string;
+  // Absent when the route's selection has never been set; an empty array when it was set and
+  // then explicitly cleared. The two are distinct states, not the same "nothing" spelled two
+  // ways: a fresh route was never armed, a cleared one was armed and then let go.
+  readonly elements?: readonly unknown[];
+}
+
+export function parseQuerySelectionResult(value: unknown): QuerySelectionResult {
+  const record = asRecord(value, "a querySelection result");
+  const name = requireString(record, "name", "a querySelection result");
+  if (!("elements" in record) || record.elements === undefined) return { name };
+  if (!Array.isArray(record.elements)) {
+    throw new Error("a querySelection result's elements is an array when present");
+  }
+  return { name, elements: record.elements };
+}
+
+export function serializeQuerySelectionResult(result: QuerySelectionResult): string {
+  return JSON.stringify(result);
+}

package/src/operations/read-daemon-log.ts

@@ -0,0 +1,29 @@
+import { PROTOCOL_VERSION, type ProtocolVersion } from "../version";
+import { parseLogReadFilter, serializeLogReadFilter, type LogReadFilter } from "./log-line";
+import { asRecord, requireOperation, requireProtocol } from "./parse-helpers";
+
+const NOUN = "a readDaemonLog input";
+
+export interface ReadDaemonLogInput extends LogReadFilter {
+  readonly operation: "readDaemonLog";
+  readonly protocol: ProtocolVersion;
+}
+
+export function parseReadDaemonLogInput(value: unknown): ReadDaemonLogInput {
+  const record = asRecord(value, NOUN);
+  requireOperation(record, "readDaemonLog", NOUN);
+  requireProtocol(record, NOUN);
+  return {
+    operation: "readDaemonLog",
+    protocol: PROTOCOL_VERSION,
+    ...parseLogReadFilter(record, NOUN),
+  };
+}
+
+export function serializeReadDaemonLogInput(input: ReadDaemonLogInput): string {
+  return JSON.stringify({
+    operation: input.operation,
+    protocol: input.protocol,
+    ...serializeLogReadFilter(input),
+  });
+}

package/src/operations/read-route-log.ts

@@ -0,0 +1,39 @@
+import { PROTOCOL_VERSION, type ProtocolVersion } from "../version";
+import { parseLogReadFilter, serializeLogReadFilter, type LogReadFilter } from "./log-line";
+import { asRecord, requireOperation, requireProtocol, requireString } from "./parse-helpers";
+
+const NOUN = "a readRouteLog input";
+
+/** The alphabet a route name is normalized into. A name outside it would put a read of one
+ * route's log somewhere else in the file system. */
+const ROUTE_LABEL = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export interface ReadRouteLogInput extends LogReadFilter {
+  readonly operation: "readRouteLog";
+  readonly protocol: ProtocolVersion;
+  readonly name: string;
+}
+
+export function parseReadRouteLogInput(value: unknown): ReadRouteLogInput {
+  const record = asRecord(value, NOUN);
+  requireOperation(record, "readRouteLog", NOUN);
+  requireProtocol(record, NOUN);
+  const name = requireString(record, "name", NOUN);
+  if (!ROUTE_LABEL.test(name))
+    throw new Error(`${NOUN}'s name is a route label: lowercase letters, digits, and hyphens`);
+  return {
+    operation: "readRouteLog",
+    protocol: PROTOCOL_VERSION,
+    name,
+    ...parseLogReadFilter(record, NOUN),
+  };
+}
+
+export function serializeReadRouteLogInput(input: ReadRouteLogInput): string {
+  return JSON.stringify({
+    operation: input.operation,
+    protocol: input.protocol,
+    name: input.name,
+    ...serializeLogReadFilter(input),
+  });
+}

package/src/operations/reboot-route.ts

@@ -0,0 +1,45 @@
+import { PROTOCOL_VERSION, type ProtocolVersion } from "../version";
+import {
+  asRecord,
+  optionalBoolean,
+  requireOperation,
+  requireProtocol,
+  requireString,
+} from "./parse-helpers";
+
+const NOUN = "a rebootRoute input";
+
+export interface RebootRouteInput {
+  readonly operation: "rebootRoute";
+  readonly protocol: ProtocolVersion;
+  readonly name: string;
+  // Defaults to true, as in the previous engine's reboot_route tool (`args.forceDirtyCache !== false`).
+  readonly forceDirtyCache: boolean;
+}
+
+export function parseRebootRouteInput(value: unknown): RebootRouteInput {
+  const record = asRecord(value, NOUN);
+  requireOperation(record, "rebootRoute", NOUN);
+  requireProtocol(record, NOUN);
+  const name = requireString(record, "name", NOUN);
+  const forceDirtyCache = optionalBoolean(record, "forceDirtyCache", NOUN) ?? true;
+  return { operation: "rebootRoute", protocol: PROTOCOL_VERSION, name, forceDirtyCache };
+}
+
+export function serializeRebootRouteInput(input: RebootRouteInput): string {
+  return JSON.stringify(input);
+}
+
+export interface RebootRouteResult {
+  readonly name: string;
+}
+
+export function parseRebootRouteResult(value: unknown): RebootRouteResult {
+  const record = asRecord(value, "a rebootRoute result");
+  const name = requireString(record, "name", "a rebootRoute result");
+  return { name };
+}
+
+export function serializeRebootRouteResult(result: RebootRouteResult): string {
+  return JSON.stringify(result);
+}