@oevery/rsp 4.0.0 → 4.2.0

package/dist/chunk-AUZYUJ46.mjs

@@ -0,0 +1,418 @@
+#!/usr/bin/env node
+import {
+  readCurrentDocument
+} from "./chunk-LGDCIQYL.mjs";
+import {
+  PKG_ROOT,
+  RSP_DIR,
+  getVersion,
+  inspectManagedDirectory,
+  inspectManagedFile,
+  inspectRspConfig,
+  markdownText,
+  parseMarkdown,
+  walkMarkdown
+} from "./chunk-P3KO3GZW.mjs";
+
+// src/architecture/model.ts
+import { createHash } from "crypto";
+import { realpath } from "fs/promises";
+import { isAbsolute, relative, resolve } from "path";
+
+// src/architecture/selection.ts
+function selectArchitecture(model, selection) {
+  const view = selection.kind === "view" ? model.views.find((view2) => view2.id === selection.id) : void 0;
+  const selected = new Set(model.nodes.map((node) => node.id));
+  if (selection.kind === "focus") {
+    if (!selected.has(selection.id))
+      throw new Error(`Unknown architecture node: ${selection.id}`);
+    selected.clear();
+    selected.add(selection.id);
+  }
+  if (selection.kind === "node") {
+    if (!selected.has(selection.id))
+      throw new Error(`Unknown architecture node: ${selection.id}`);
+    selected.clear();
+    selected.add(selection.id);
+    let added = true;
+    while (added) {
+      added = false;
+      for (const node of model.nodes) {
+        if (node.parent && selected.has(node.parent) && !selected.has(node.id)) {
+          selected.add(node.id);
+          added = true;
+        }
+      }
+    }
+  }
+  if (selection.kind === "view") {
+    if (!view)
+      throw new Error(`Unknown architecture view: ${selection.id}`);
+    selected.clear();
+    view.include.forEach((id) => selected.add(id));
+  }
+  const relations = view?.scenario ? [] : model.relations.filter(
+    (edge) => (selected.has(edge.source) || selected.has(edge.target)) && (view?.boundary !== "exclude" || selected.has(edge.source) && selected.has(edge.target)) && (!view?.relationTypes || view.relationTypes.includes(edge.type)) && (!view?.relationIds || view.relationIds.includes(edge.id))
+  );
+  const visible = /* @__PURE__ */ new Set([...selected, ...relations.flatMap((edge) => [edge.source, edge.target])]);
+  return { selected, visible, relations };
+}
+
+// src/architecture/model.ts
+var ARCHITECTURE_FILE = ".rsp/architecture.json";
+var MAX_CONTENT_BYTES = 16 * 1024 * 1024;
+var digest = (value) => createHash("sha256").update(value).digest("hex");
+function projectPath(file) {
+  if (!file || isAbsolute(file) || file.includes("\\") || file.split("/").some((part) => !part || part === "." || part === "..") || file.includes("\0"))
+    throw new Error(`Unsafe project-relative path: ${file}`);
+  if (file.split("/").some((part) => part === ".git" || part === "node_modules"))
+    throw new Error(`Private/runtime path is not readable: ${file}`);
+  return file;
+}
+async function readProjectFile(root, file) {
+  projectPath(file);
+  return (await readCurrentDocument(resolve(root, file), root, file, MAX_CONTENT_BYTES)).content;
+}
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Architecture entries must be objects");
+  return value;
+}
+function text(value, field) {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`Architecture ${field} must be a non-empty string`);
+  return value;
+}
+function strings(value, field) {
+  if (!Array.isArray(value))
+    throw new Error(`Architecture ${field} must be an array`);
+  return value.map((item) => text(item, field));
+}
+function collection(value, field) {
+  if (!Array.isArray(value))
+    throw new Error(`Architecture ${field} must be an array`);
+  return value.map(object);
+}
+function unique(items, field) {
+  if (new Set(items.map((item) => item.id)).size !== items.length)
+    throw new Error(`Duplicate architecture ${field} identity`);
+}
+function parseArchitecture(content) {
+  const value = object(JSON.parse(content));
+  if (value.schemaVersion !== 1)
+    throw new Error(`Unsupported architecture schemaVersion: ${String(value.schemaVersion)}`);
+  const nodes = collection(value.nodes, "nodes").map((node) => ({ id: text(node.id, "node.id"), title: text(node.title, "node.title"), description: text(node.description, "node.description"), ...node.parent === void 0 ? {} : { parent: text(node.parent, "node.parent") } }));
+  const relations = collection(value.relations, "relations").map((edge) => ({ id: text(edge.id, "relation.id"), source: text(edge.source, "relation.source"), target: text(edge.target, "relation.target"), type: text(edge.type, "relation.type"), ...edge.label === void 0 ? {} : { label: text(edge.label, "relation.label") }, description: text(edge.description, "relation.description") }));
+  const views = collection(value.views, "views").map((view) => {
+    if (view.boundary !== void 0 && view.boundary !== "include" && view.boundary !== "exclude")
+      throw new Error("Architecture view.boundary must be include or exclude");
+    const result = {
+      id: text(view.id, "view.id"),
+      title: text(view.title, "view.title"),
+      node: text(view.node, "view.node"),
+      include: view.scenario === void 0 ? strings(view.include, "view.include") : [],
+      ...view.relationTypes === void 0 ? {} : { relationTypes: strings(view.relationTypes, "view.relationTypes") },
+      ...view.relationIds === void 0 ? {} : { relationIds: strings(view.relationIds, "view.relationIds") },
+      ...view.boundary === void 0 ? {} : { boundary: view.boundary }
+    };
+    if (view.scenario !== void 0) {
+      if (view.include !== void 0 || view.relationTypes !== void 0 || view.relationIds !== void 0 || view.boundary !== void 0)
+        throw new Error("Scenario views use participants instead of structural selectors");
+      const scenario = object(view.scenario);
+      const participants = collection(scenario.participants, "scenario.participants").map((participant) => ({
+        id: text(participant.id, "participant.id"),
+        node: text(participant.node, "participant.node"),
+        ...participant.title === void 0 ? {} : { title: text(participant.title, "participant.title") }
+      }));
+      const steps = collection(scenario.steps, "scenario.steps").map((step) => {
+        if (!["call", "return", "event"].includes(String(step.type)))
+          throw new Error("Scenario step.type must be call, return or event");
+        return {
+          id: text(step.id, "step.id"),
+          source: text(step.source, "step.source"),
+          target: text(step.target, "step.target"),
+          type: step.type,
+          label: text(step.label, "step.label"),
+          ...step.description === void 0 ? {} : { description: text(step.description, "step.description") },
+          ...step.replyTo === void 0 ? {} : { replyTo: text(step.replyTo, "step.replyTo") }
+        };
+      });
+      unique(participants, "participant");
+      unique(steps, "step");
+      if (!participants.length || !steps.length)
+        throw new Error("Scenarios require participants and steps");
+      const participantIds = new Set(participants.map((participant) => participant.id));
+      steps.forEach((step, index) => {
+        if (!participantIds.has(step.source) || !participantIds.has(step.target))
+          throw new Error(`Missing scenario participant in step: ${step.id}`);
+        if (step.replyTo !== void 0) {
+          const call = steps.slice(0, index).find((candidate) => candidate.id === step.replyTo);
+          if (step.type !== "return" || call?.type !== "call" || call.source !== step.target || call.target !== step.source)
+            throw new Error(`Invalid earlier call reference in step: ${step.id}`);
+        }
+      });
+      result.scenario = { participants, steps };
+      result.include = [...new Set(participants.map((participant) => participant.node))];
+    }
+    return result;
+  });
+  const bindings = collection(value.bindings, "bindings").map((binding) => {
+    const file = projectPath(text(binding.file, "binding.file"));
+    if (!/\.md$/i.test(file))
+      throw new Error("Architecture bindings must reference Markdown files");
+    const scope = binding.scope ?? "node";
+    if (scope !== "node" && scope !== "subtree")
+      throw new Error("Architecture binding.scope must be node or subtree");
+    const headings = binding.headings === void 0 ? void 0 : strings(binding.headings, "binding.headings");
+    if (headings?.length === 0)
+      throw new Error("Omit headings for a whole-file binding");
+    return { node: text(binding.node, "binding.node"), file, ...headings ? { headings } : {}, scope };
+  });
+  unique(nodes, "node");
+  unique(relations, "relation");
+  unique(views, "view");
+  const ids = new Set(nodes.map((node) => node.id));
+  const requireNode = (id) => {
+    if (!ids.has(id))
+      throw new Error(`Missing architecture node: ${id}`);
+  };
+  for (const node of nodes) {
+    const visited = /* @__PURE__ */ new Set([node.id]);
+    let parent = node.parent;
+    while (parent !== void 0) {
+      requireNode(parent);
+      if (visited.has(parent))
+        throw new Error(`Architecture hierarchy cycle: ${parent}`);
+      visited.add(parent);
+      parent = nodes.find((node2) => node2.id === parent).parent;
+    }
+  }
+  relations.forEach((edge) => {
+    requireNode(edge.source);
+    requireNode(edge.target);
+  });
+  views.forEach((view) => {
+    requireNode(view.node);
+    view.include.forEach(requireNode);
+    view.relationIds?.forEach((id) => {
+      if (!relations.some((edge) => edge.id === id))
+        throw new Error(`Missing architecture relation: ${id}`);
+    });
+  });
+  bindings.forEach((binding) => requireNode(binding.node));
+  return { schemaVersion: 1, nodes, relations, views, bindings };
+}
+function documentHeadings(content) {
+  const result = [];
+  const stack = [];
+  const counts = /* @__PURE__ */ new Map();
+  const anchors = /* @__PURE__ */ new Set();
+  walkMarkdown(parseMarkdown(content).root, (node) => {
+    if (node.type !== "heading")
+      return;
+    const title = markdownText(node);
+    while (stack.length && stack.at(-1).depth >= node.depth) stack.pop();
+    stack.push({ title, depth: node.depth });
+    const base = title.toLowerCase().replace(/[^\p{L}\p{N}\s_-]/gu, "").replace(/\s/g, "-") || "section";
+    let count = counts.get(base) ?? 0;
+    let anchor = count ? `${base}-${count}` : base;
+    while (anchors.has(anchor)) anchor = `${base}-${++count}`;
+    counts.set(base, count + 1);
+    anchors.add(anchor);
+    result.push({ title, depth: node.depth, anchor, hierarchy: stack.map((item) => item.title) });
+  });
+  return result;
+}
+function resolveHeading(headings, hierarchy) {
+  const matches = headings.filter((heading) => hierarchy.length <= heading.hierarchy.length && hierarchy.every((title, i) => title === heading.hierarchy[heading.hierarchy.length - hierarchy.length + i]));
+  if (matches.length !== 1)
+    throw new Error(`${matches.length ? "Ambiguous" : "Missing"} chapter: ${hierarchy.join(" > ")}`);
+  return matches[0];
+}
+async function queryArchitecture(options = {}) {
+  if (options.node !== void 0 && !options.node.trim())
+    throw new Error("--node requires a non-empty ID");
+  if (options.view !== void 0 && !options.view.trim())
+    throw new Error("--view requires a non-empty ID");
+  if (options.node && options.view)
+    throw new Error("--node and --view are mutually exclusive");
+  const root = await realpath(resolve(options.root ?? process.cwd()));
+  const config = await inspectRspConfig(root);
+  if (config.issues.length)
+    throw new Error(config.issues.join("; "));
+  let content;
+  try {
+    content = await readProjectFile(root, ARCHITECTURE_FILE);
+  } catch (error) {
+    const { lstat } = await import("fs/promises");
+    try {
+      await lstat(resolve(root, ARCHITECTURE_FILE));
+    } catch (missing) {
+      if (missing.code === "ENOENT")
+        return { configured: false, source: { root, file: ARCHITECTURE_FILE, revision: "" }, selection: { kind: "full" }, nodes: [], relations: [], views: [], documents: [], diagnostics: [{ code: "not_configured", message: `Architecture is not configured: ${ARCHITECTURE_FILE}` }] };
+    }
+    throw error;
+  }
+  const model = parseArchitecture(content);
+  const selection = options.node ? { kind: "node", id: options.node } : options.view ? { kind: "view", id: options.view } : { kind: "full" };
+  const { selected, visible, relations } = selectArchitecture(model, selection);
+  const diagnostics = [];
+  const chapterMaps = /* @__PURE__ */ new Map();
+  const sourceInputs = [content, JSON.stringify(config.config)];
+  for (const file of new Set(model.bindings.map((binding) => binding.file))) {
+    try {
+      const body = await readProjectFile(root, file);
+      chapterMaps.set(file, documentHeadings(body));
+      sourceInputs.push(file, body);
+    } catch (error) {
+      diagnostics.push({ code: "document_unavailable", file, message: error.message });
+    }
+  }
+  const nodes = model.nodes.filter((node) => visible.has(node.id)).map((node) => {
+    const ancestors = /* @__PURE__ */ new Set();
+    let parent = node.parent;
+    while (parent) {
+      ancestors.add(parent);
+      parent = model.nodes.find((node2) => node2.id === parent)?.parent;
+    }
+    const bindings = model.bindings.filter((binding) => binding.node === node.id || binding.scope === "subtree" && ancestors.has(binding.node)).map((binding) => {
+      const reference = { ...binding, origin: binding.node, inherited: binding.node !== node.id };
+      if (!binding.headings || !chapterMaps.has(binding.file))
+        return reference;
+      try {
+        return { ...reference, anchor: resolveHeading(chapterMaps.get(binding.file), binding.headings).anchor };
+      } catch (error) {
+        diagnostics.push({ code: "chapter_unresolved", file: binding.file, message: error.message });
+        return reference;
+      }
+    });
+    return { ...node, boundary: !selected.has(node.id), bindings };
+  });
+  return { configured: true, source: { root, file: ARCHITECTURE_FILE, revision: digest(sourceInputs.join("\0")) }, selection, nodes, relations, views: model.views.filter((view) => selection.kind === "full" || view.id === options.view || selected.has(view.node)), documents: [...new Set(nodes.flatMap((node) => node.bindings.map((binding) => binding.file)))], diagnostics };
+}
+function isWithin(root, target) {
+  const path = relative(root, target);
+  return path !== ".." && !path.startsWith("../") && !isAbsolute(path);
+}
+
+// src/core/project-version.ts
+import { readFile, realpath as realpath2 } from "fs/promises";
+import { join } from "path";
+var PROJECT_VERSION_PATH = ".rsp/version";
+var PROJECT_SOURCE_PATH = ".rsp/source";
+var SOURCE_INVOCATION = "mise exec -- node dist/cli.mjs";
+function isExactVersion(value) {
+  return /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[a-z-][\da-z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-z-][\da-z-]*))*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?$/i.test(value);
+}
+function exactInvocation(version) {
+  if (!isExactVersion(version))
+    throw new Error(`Invalid exact RSP version: ${version}`);
+  return `npx -y @oevery/rsp@${version}`;
+}
+async function readProjectVersion(projectRoot = ".") {
+  const directory = inspectManagedDirectory(join(projectRoot, RSP_DIR), "RSP root", { allowMissing: true });
+  if (directory.issue)
+    throw directory.issue;
+  if (!directory.exists)
+    return null;
+  const path = join(projectRoot, PROJECT_VERSION_PATH);
+  const inspection = inspectManagedFile(path, "project CLI version", { allowMissing: true });
+  if (inspection.issue)
+    throw inspection.issue;
+  if (!inspection.exists)
+    return null;
+  const version = (await readFile(path, "utf8")).trim();
+  if (!isExactVersion(version))
+    throw new Error(`${PROJECT_VERSION_PATH} must contain one exact package version, not a tag or range`);
+  return version;
+}
+async function readProjectRuntime(projectRoot = ".") {
+  const version = await readProjectVersion(projectRoot);
+  const source = inspectManagedFile(join(projectRoot, PROJECT_SOURCE_PATH), "project source selection", { allowMissing: true });
+  if (source.issue)
+    throw source.issue;
+  if (!source.exists)
+    return { mode: "package", version };
+  if (version !== null)
+    throw new Error(`${PROJECT_SOURCE_PATH} and ${PROJECT_VERSION_PATH} are mutually exclusive; explicitly select one runtime.`);
+  if ((await readFile(join(projectRoot, PROJECT_SOURCE_PATH), "utf8")).trim() !== ".")
+    throw new Error(`${PROJECT_SOURCE_PATH} must contain . to select this RSP source checkout.`);
+  if (await realpath2(projectRoot) !== await realpath2(PKG_ROOT))
+    throw new Error(`Source mode requires this checkout's local CLI. Build here, then use ${SOURCE_INVOCATION} <command>; a registry package or another checkout cannot substitute.`);
+  const sourceDirectory = inspectManagedDirectory(join(projectRoot, "src"), "RSP source directory");
+  const sourceEntry = inspectManagedFile(join(projectRoot, "src/cli.ts"), "RSP source entry");
+  if (sourceDirectory.issue || sourceEntry.issue)
+    throw sourceDirectory.issue ?? sourceEntry.issue;
+  return { mode: "source" };
+}
+async function selectProjectRuntime(operation = "ordinary") {
+  const version = await getVersion();
+  exactInvocation(version);
+  const selected = await readProjectRuntime();
+  if (selected.mode === "source")
+    return { mode: "source", version };
+  if (selected.version && selected.version !== version && operation !== "update") {
+    throw new Error(`Project pins RSP ${selected.version}; running CLI is ${version}. Use ${exactInvocation(selected.version)} <command>. To migrate deliberately, inspect the target version and run ${exactInvocation(version)} update.`);
+  }
+  if (selected.version && operation === "update" && compareVersions(version, selected.version) < 0)
+    throw new Error(`Downgrading RSP from ${selected.version} to ${version} is unsupported. Use ${exactInvocation(selected.version)} <command>.`);
+  return { mode: "package", version };
+}
+function compareVersions(left, right) {
+  const parts = (value) => {
+    const [core, ...pre] = value.split("+", 1)[0].split("-");
+    return { core: core.split(".").map(BigInt), pre: pre.length ? pre.join("-").split(".") : [] };
+  };
+  const a = parts(left);
+  const b = parts(right);
+  for (let i = 0; i < 3; i++) {
+    if (a.core[i] !== b.core[i])
+      return a.core[i] > b.core[i] ? 1 : -1;
+  }
+  if (!a.pre.length || !b.pre.length)
+    return Number(!a.pre.length) - Number(!b.pre.length);
+  for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i++) {
+    const x = a.pre[i];
+    const y = b.pre[i];
+    if (x === y)
+      continue;
+    if (x === void 0 || y === void 0)
+      return x === void 0 ? -1 : 1;
+    const nx = /^\d+$/.test(x);
+    const ny = /^\d+$/.test(y);
+    if (nx && ny)
+      return BigInt(x) > BigInt(y) ? 1 : -1;
+    if (nx !== ny)
+      return nx ? -1 : 1;
+    return x > y ? 1 : -1;
+  }
+  return 0;
+}
+async function guardProjectVersion(rawArgs) {
+  if (rawArgs.some((arg) => ["--help", "-h"].includes(arg)) || rawArgs.length === 1 && ["--version", "-v"].includes(rawArgs[0]))
+    return;
+  if (["doctor", "config", "update"].includes(rawArgs[0] ?? ""))
+    return;
+  await selectProjectRuntime();
+}
+
+export {
+  selectArchitecture,
+  ARCHITECTURE_FILE,
+  MAX_CONTENT_BYTES,
+  digest,
+  projectPath,
+  readProjectFile,
+  documentHeadings,
+  queryArchitecture,
+  isWithin,
+  PROJECT_VERSION_PATH,
+  SOURCE_INVOCATION,
+  isExactVersion,
+  exactInvocation,
+  readProjectVersion,
+  readProjectRuntime,
+  selectProjectRuntime,
+  compareVersions,
+  guardProjectVersion
+};

package/dist/chunk-DNRGBQS7.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import {
+  PKG_ROOT
+} from "./chunk-P3KO3GZW.mjs";
+
+// src/viewer/build-assets.mjs
+import { createHash } from "crypto";
+import { lstat, readdir, readFile } from "fs/promises";
+import { join, sep } from "path";
+var viewerEntries = { app: "app.js", style: "app.css", mermaid: "mermaid.js" };
+var mismatch = () => new Error("Viewer assets do not match the startup build; rebuild or reinstall and retry");
+function validateAssetPaths(paths) {
+  if (!Array.isArray(paths) || paths.some((path) => typeof path !== "string" || !/^(?:[\w-]+\/)*[\w-]+\.(?:js|css)$/.test(path)) || new Set(paths).size !== paths.length || Object.values(viewerEntries).some((path) => !paths.includes(path))) {
+    throw mismatch();
+  }
+  return (
+    /** @type {string[]} */
+    paths
+  );
+}
+function parseBuildManifest(source) {
+  const manifest = JSON.parse(source);
+  if (!manifest || typeof manifest.identity !== "string" || !/^[a-f0-9]{64}$/.test(manifest.identity))
+    throw mismatch();
+  return { identity: (
+    /** @type {string} */
+    manifest.identity
+  ), assets: validateAssetPaths(manifest.assets) };
+}
+async function readBuildSnapshot(root, paths) {
+  const allowed = new Set(validateAssetPaths(paths));
+  const hash = createHash("sha256");
+  const assets = /* @__PURE__ */ new Map();
+  const directory = join(root, "dist");
+  for (const file of (await readdir(directory, { recursive: true })).map((file2) => file2.split(sep).join("/")).sort()) {
+    if (!/\.(?:mjs|js|css)$/.test(file))
+      continue;
+    const path = join(directory, file);
+    if (!(await lstat(path)).isFile())
+      throw mismatch();
+    const content = await readFile(path);
+    hash.update(file).update(content);
+    if (file.startsWith("viewer/") && allowed.has(file.slice("viewer/".length))) {
+      assets.set(`/${file.slice("viewer/".length)}`, {
+        content,
+        type: file.endsWith(".css") ? "text/css" : "text/javascript"
+      });
+    }
+  }
+  if (assets.size !== allowed.size)
+    throw mismatch();
+  return { identity: hash.digest("hex"), assets };
+}
+
+// src/viewer/runtime.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile2, realpath } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var VIEWER_PROTOCOL = 1;
+async function viewerRuntime(installation = PKG_ROOT) {
+  const root = await realpath(installation);
+  const { version } = JSON.parse(await readFile2(join2(root, "package.json"), "utf8"));
+  const build = (await readFile2(join2(root, "dist/viewer-build.json"), "utf8")).trim();
+  const identity = createHash2("sha256").update(JSON.stringify({ root, version, build, protocol: VIEWER_PROTOCOL })).digest("hex");
+  const directory = join2(homedir(), ".cache", "rsp", "viewer");
+  return { root, version, build, identity, directory, recordPath: join2(directory, `${identity}.json`), lockPath: join2(directory, `${identity}.lock`) };
+}
+async function snapshotViewerRuntime(root, identity) {
+  const runtime = await viewerRuntime(root);
+  if (runtime.identity !== identity)
+    throw new Error("Viewer build changed during startup; retry");
+  const manifest = parseBuildManifest(runtime.build);
+  const snapshot = await readBuildSnapshot(root, manifest.assets);
+  if (snapshot.identity !== manifest.identity || (await viewerRuntime(root)).identity !== identity) {
+    throw new Error("Viewer assets do not match the startup build; rebuild or reinstall and retry");
+  }
+  return { version: runtime.version, assets: snapshot.assets };
+}
+async function serviceRequest(record, path, body, timeoutMs = 2500) {
+  const response = await fetch(`http://127.0.0.1:${record.port}${path}`, { method: body === void 0 ? "GET" : "POST", headers: { Authorization: `Bearer ${record.adminToken}`, ...body === void 0 ? {} : { "Content-Type": "application/json" } }, ...body === void 0 ? {} : { body: JSON.stringify(body) }, signal: AbortSignal.timeout(timeoutMs) });
+  if (!response.ok)
+    throw new Error(await response.text());
+  const result = await response.json();
+  if (result.identity !== record.identity || result.protocol !== VIEWER_PROTOCOL)
+    throw new Error("Viewer identity/protocol mismatch");
+  return result;
+}
+async function discoverService(path, identity) {
+  try {
+    const record = JSON.parse(await readFile2(path, "utf8"));
+    if (record.identity !== identity || record.protocol !== VIEWER_PROTOCOL || !Number.isInteger(record.port) || record.port < 1 || record.port > 65535 || typeof record.adminToken !== "string")
+      return null;
+    await serviceRequest(record, "/control/status");
+    return record;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  viewerEntries,
+  VIEWER_PROTOCOL,
+  viewerRuntime,
+  snapshotViewerRuntime,
+  serviceRequest,
+  discoverService
+};