@emeryld/rrroutes-export 1.1.1 → 1.1.2

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,33 +29,66 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   DEFAULT_VIEWER_TEMPLATE: () => DEFAULT_VIEWER_TEMPLATE,
+  RRROUTES_BAKED_PAYLOAD_MARKER: () => RRROUTES_BAKED_PAYLOAD_MARKER,
   __private: () => __private,
+  applyChangeSetRetention: () => applyChangeSetRetention,
+  applyCheckpointRetention: () => applyCheckpointRetention,
   buildFinalizedLeavesViewerBundle: () => buildFinalizedLeavesViewerBundle,
+  buildRRRoutesSnapshot: () => buildRRRoutesSnapshot,
+  canonicalSnapshotStructure: () => canonicalSnapshotStructure,
+  canonicalizeJson: () => canonicalizeJson,
   clearSchemaIntrospectionHandlers: () => clearSchemaIntrospectionHandlers,
+  createBakedInspectorPayload: () => createBakedInspectorPayload,
+  createCheckpointService: () => createCheckpointService,
+  createExpressRouter: () => createExpressRouter,
+  createFileSystemInspectionStorage: () => createFileSystemInspectionStorage,
+  createInspectorHttpHandler: () => createInspectorHttpHandler,
+  createMemoryInspectionStorage: () => createMemoryInspectionStorage,
+  createRRRoutesExportRuntime: () => createRRRoutesExportRuntime,
+  createSQLiteInspectionStorage: () => createSQLiteInspectionStorage,
   createSchemaIntrospector: () => createSchemaIntrospector,
+  createSnapshotChangeSet: () => createSnapshotChangeSet,
+  diffRRRoutesSnapshots: () => diffRRRoutesSnapshots,
+  escapeBakedPayload: () => escapeBakedPayload,
   exportFinalizedLeaves: () => exportFinalizedLeaves,
   exportFinalizedLeavesChangelog: () => exportFinalizedLeavesChangelog,
   extractLeafSourceByAst: () => extractLeafSourceByAst,
   flattenLeafSchemas: () => flattenLeafSchemas,
   flattenSerializableSchema: () => flattenSerializableSchema,
+  hashCanonicalValue: () => hashCanonicalValue,
+  hashRRRoutesSnapshot: () => hashRRRoutesSnapshot,
+  injectBakedInspectorPayload: () => injectBakedInspectorPayload,
   introspectSchema: () => introspectSchema,
+  loadExportRuntime: () => loadExportRuntime,
   loadFinalizedLeavesInput: () => loadFinalizedLeavesInput,
+  parseCliFlags: () => parseCliFlags,
   parseFinalizedLeavesChangelogCliArgs: () => parseFinalizedLeavesChangelogCliArgs,
   parseFinalizedLeavesCliArgs: () => parseFinalizedLeavesCliArgs,
   registerSchemaIntrospectionHandler: () => registerSchemaIntrospectionHandler,
+  requiredFlag: () => requiredFlag,
+  runChangesCli: () => runChangesCli,
+  runCheckpointCli: () => runCheckpointCli,
   runExportFinalizedLeavesChangelogCli: () => runExportFinalizedLeavesChangelogCli,
   runExportFinalizedLeavesCli: () => runExportFinalizedLeavesCli,
+  runInspectorServeCli: () => runInspectorServeCli,
+  runSnapshotCli: () => runSnapshotCli,
   serializableSchemaKinds: () => serializableSchemaKinds,
   serializeLeafContract: () => serializeLeafContract,
   serializeLeavesContract: () => serializeLeavesContract,
+  stableStringify: () => stableStringify,
   writeFinalizedLeavesChangelogExport: () => writeFinalizedLeavesChangelogExport,
   writeFinalizedLeavesExport: () => writeFinalizedLeavesExport,
-  writeFinalizedLeavesViewerBundle: () => writeFinalizedLeavesViewerBundle
+  writeFinalizedLeavesViewerBundle: () => writeFinalizedLeavesViewerBundle,
+  writeRRRoutesChangeSet: () => writeRRRoutesChangeSet,
+  writeRRRoutesSnapshot: () => writeRRRoutesSnapshot
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -283,6 +319,7 @@ function serializeLeafContract(leaf, options = {}) {
   const cfg = leaf.cfg;
   return {
     key: `${leaf.method.toUpperCase()} ${leaf.path}`,
+    id: cfg.id,
     method: leaf.method,
     path: leaf.path,
     cfg: {
@@ -355,46 +392,46 @@ function normalizeType(schema) {
       return "unknown";
   }
 }
-function isNonEmptyPath(path7) {
-  return typeof path7 === "string" && path7.length > 0;
+function isNonEmptyPath(path12) {
+  return typeof path12 === "string" && path12.length > 0;
 }
-function setNode(out, path7, schema, inherited) {
-  if (!isNonEmptyPath(path7)) return;
-  out[path7] = {
+function setNode(out, path12, schema, inherited) {
+  if (!isNonEmptyPath(path12)) return;
+  out[path12] = {
     type: normalizeType(schema),
     nullable: inherited.nullable || Boolean(schema.nullable),
     optional: inherited.optional || Boolean(schema.optional),
     literal: schema.kind === "literal" ? schema.literal : void 0
   };
 }
-function flattenInto(out, schema, path7, inherited) {
-  if (!schema || !isNonEmptyPath(path7)) return;
+function flattenInto(out, schema, path12, inherited) {
+  if (!schema || !isNonEmptyPath(path12)) return;
   const nextInherited = {
     optional: inherited.optional || Boolean(schema.optional),
     nullable: inherited.nullable || Boolean(schema.nullable)
   };
   if (schema.kind === "union" && Array.isArray(schema.union) && schema.union.length > 0) {
     schema.union.forEach((option, index) => {
-      const optionPath = `${path7}-${index + 1}`;
+      const optionPath = `${path12}-${index + 1}`;
       flattenInto(out, option, optionPath, inherited);
     });
     return;
   }
-  setNode(out, path7, schema, inherited);
+  setNode(out, path12, schema, inherited);
   if (schema.kind === "object" && schema.properties) {
     for (const [key, child] of Object.entries(schema.properties)) {
-      const childPath = `${path7}.${key}`;
+      const childPath = `${path12}.${key}`;
       flattenInto(out, child, childPath, nextInherited);
     }
     return;
   }
   if (schema.kind === "array" && schema.element) {
-    flattenInto(out, schema.element, `${path7}[]`, nextInherited);
+    flattenInto(out, schema.element, `${path12}[]`, nextInherited);
   }
 }
-function flattenSerializableSchema(schema, path7) {
+function flattenSerializableSchema(schema, path12) {
   const out = {};
-  flattenInto(out, schema, path7, { optional: false, nullable: false });
+  flattenInto(out, schema, path12, { optional: false, nullable: false });
   return out;
 }
 function isSerializedLeaf(value) {
@@ -1118,6 +1155,33 @@ function extractLeafSourceByAst({
   };
 }
 
+// src/files/baked-payload.ts
+var RRROUTES_BAKED_PAYLOAD_MARKER = "<!--__RRROUTES_INSPECTOR_BAKED_PAYLOAD__-->";
+function createBakedInspectorPayload(args) {
+  return {
+    kind: "rrroutes-inspector-baked",
+    snapshot: args.snapshot,
+    checkpoints: args.checkpoints ?? [],
+    changeSets: args.changeSets ?? []
+  };
+}
+function escapeBakedPayload(payload) {
+  return JSON.stringify(payload).replace(/<\//g, "<\\/").replace(/<!--/g, "<\\!--").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function injectBakedInspectorPayload(html, payload, options = {}) {
+  const marker = options.marker ?? RRROUTES_BAKED_PAYLOAD_MARKER;
+  const globalName = options.globalName ?? "__RRROUTES_INSPECTOR_PAYLOAD";
+  const scriptId = options.scriptId ?? "rrroutes-inspector-baked-payload";
+  const script = `${marker}
+<script id="${scriptId}">window.${globalName} = ${escapeBakedPayload(payload)};</script>`;
+  if (html.includes(marker)) return html.replace(marker, script);
+  if (html.includes("</body>"))
+    return html.replace("</body>", `${script}
+</body>`);
+  return `${script}
+${html}`;
+}
+
 // src/exportFinalizedLeaves.ts
 function isRegistry(value) {
   return typeof value === "object" && value !== null && "all" in value && "byKey" in value;
@@ -1131,7 +1195,7 @@ function buildMeta(sourceExtraction) {
     description: "Finalized RRRoutes leaves export with serialized schemas and flattened schema paths for downstream processing.",
     sourceExtraction,
     fieldCatalog: {
-      leaf: ["key", "method", "path", "cfg"],
+      leaf: ["key", "id?", "method", "path", "cfg"],
       cfg: [
         "description?",
         "summary?",
@@ -1165,25 +1229,6 @@ function buildMeta(sourceExtraction) {
     }
   };
 }
-var BAKED_PAYLOAD_MARKER = "<!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->";
-function escapePayloadForInlineScript(payload) {
-  return JSON.stringify(payload).replace(/<\//g, "<\\/").replace(/<!--/g, "<\\!--");
-}
-function injectPayloadIntoViewerHtml(htmlTemplate, payload) {
-  const payloadScript = `${BAKED_PAYLOAD_MARKER}
-<script id="finalized-leaves-baked-payload">window.__FINALIZED_LEAVES_PAYLOAD = ${escapePayloadForInlineScript(
-    payload
-  )};</script>`;
-  if (htmlTemplate.includes(BAKED_PAYLOAD_MARKER)) {
-    return htmlTemplate.replace(BAKED_PAYLOAD_MARKER, payloadScript);
-  }
-  if (htmlTemplate.includes("</body>")) {
-    return htmlTemplate.replace("</body>", `${payloadScript}
-</body>`);
-  }
-  return `${payloadScript}
-${htmlTemplate}`;
-}
 async function resolveViewerTemplatePath(viewerTemplateFile) {
   if (viewerTemplateFile) {
     const resolved = import_node_path2.default.resolve(viewerTemplateFile);
@@ -1195,10 +1240,7 @@ async function resolveViewerTemplatePath(viewerTemplateFile) {
       process.cwd(),
       "node_modules/@emeryld/rrroutes-export/tools/finalized-leaves-viewer.html"
     ),
-    import_node_path2.default.resolve(
-      process.cwd(),
-      "tools/finalized-leaves-viewer.html"
-    ),
+    import_node_path2.default.resolve(process.cwd(), "tools/finalized-leaves-viewer.html"),
     import_node_path2.default.resolve(
       process.cwd(),
       "packages/export/tools/finalized-leaves-viewer.html"
@@ -1223,7 +1265,11 @@ async function writeJsonExport(payload, outFile) {
 async function writeBakedHtmlExport(payload, htmlFile, viewerTemplateFile) {
   const templatePath = await resolveViewerTemplatePath(viewerTemplateFile);
   const template = templatePath ? await import_promises.default.readFile(templatePath, "utf8") : DEFAULT_VIEWER_TEMPLATE;
-  const baked = injectPayloadIntoViewerHtml(template, payload);
+  const baked = injectBakedInspectorPayload(template, payload, {
+    marker: "<!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->",
+    globalName: "__FINALIZED_LEAVES_PAYLOAD",
+    scriptId: "finalized-leaves-baked-payload"
+  });
   const resolved = import_node_path2.default.resolve(htmlFile);
   await import_promises.default.mkdir(import_node_path2.default.dirname(resolved), { recursive: true });
   await import_promises.default.writeFile(resolved, baked, "utf8");
@@ -1399,11 +1445,874 @@ async function runExportFinalizedLeavesCli(argv) {
 var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
-var import_node_crypto = __toESM(require("crypto"), 1);
+var import_node_crypto2 = __toESM(require("crypto"), 1);
 var import_node_child_process2 = require("child_process");
 var import_node_util = require("util");
 var import_node_url2 = require("url");
 var import_typescript2 = __toESM(require("typescript"), 1);
+
+// src/snapshot/canonicalize.ts
+function compareJson(left, right) {
+  return JSON.stringify(left).localeCompare(JSON.stringify(right));
+}
+function canonicalizeValue(value, key) {
+  if (value === void 0 || typeof value === "function" || typeof value === "symbol") {
+    return void 0;
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "bigint") return String(value);
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) {
+    const array = value.map((item) => canonicalizeValue(item)).filter((item) => item !== void 0);
+    if (key === "tags" || key === "events" || key === "eventNames") {
+      return array.slice().sort(compareJson);
+    }
+    return array;
+  }
+  if (typeof value !== "object") return void 0;
+  const out = {};
+  for (const property of Object.keys(value).sort()) {
+    const child = canonicalizeValue(
+      value[property],
+      property
+    );
+    if (child !== void 0) out[property] = child;
+  }
+  return out;
+}
+function canonicalizeJson(value) {
+  return canonicalizeValue(value) ?? null;
+}
+function canonicalSnapshotStructure(snapshot, options = {}) {
+  const sockets = Object.fromEntries(
+    Object.entries(snapshot.sockets).map(([identity, socket]) => [
+      identity,
+      options.includeLive ? socket : { ...socket, live: void 0 }
+    ])
+  );
+  return canonicalizeJson({
+    ...snapshot,
+    meta: {
+      ...snapshot.meta,
+      capturedAt: void 0,
+      snapshotHash: void 0
+    },
+    capabilities: {
+      ...snapshot.capabilities,
+      live: false
+    },
+    sockets
+  });
+}
+function stableStringify(value) {
+  return JSON.stringify(canonicalizeJson(value));
+}
+
+// src/snapshot/hash.ts
+var import_node_crypto = require("crypto");
+function hashCanonicalValue(value) {
+  return (0, import_node_crypto.createHash)("sha256").update(stableStringify(value)).digest("hex");
+}
+function hashRRRoutesSnapshot(snapshot, options = {}) {
+  return hashCanonicalValue(canonicalSnapshotStructure(snapshot, options));
+}
+
+// src/diff/diff-snapshots.ts
+function same(left, right) {
+  return stableStringify(left) === stableStringify(right);
+}
+function severityFor(type) {
+  switch (type) {
+    case "route_removed":
+    case "client_binding_removed":
+    case "client_resource_removed":
+    case "server_controller_unregistered":
+    case "server_endpoint_disabled":
+    case "socket_runtime_removed":
+    case "socket_contract_event_removed":
+      return "breaking";
+    case "schema_changed":
+    case "cfg_changed":
+    case "client_binding_target_changed":
+    case "client_build_options_changed":
+    case "client_augment_changed":
+    case "client_augment_reordered":
+    case "client_socket_connection_changed":
+    case "server_controller_changed":
+    case "server_middleware_changed":
+    case "server_middleware_reordered":
+    case "server_output_validation_changed":
+    case "socket_payload_schema_changed":
+    case "socket_binding_changed":
+    case "socket_room_strategy_changed":
+    case "socket_cache_reducer_changed":
+    case "socket_heartbeat_configuration_changed":
+      return "behavioral";
+    case "route_added":
+    case "client_resource_added":
+    case "client_binding_added":
+    case "client_binding_enabled":
+    case "client_augment_added":
+    case "client_socket_connection_added":
+    case "server_controller_registered":
+    case "server_endpoint_enabled":
+    case "server_middleware_added":
+    case "socket_runtime_added":
+    case "socket_contract_event_added":
+    case "socket_handler_added":
+      return "non-breaking";
+    case "route_id_changed":
+    case "description_changed":
+    case "files_changed":
+    case "source_changed":
+    case "client_binding_disabled":
+    case "client_augment_removed":
+    case "client_socket_connection_removed":
+    case "server_middleware_removed":
+    case "socket_handler_removed":
+      return "informational";
+  }
+}
+function makeChange(input) {
+  const before = input.before === void 0 ? void 0 : canonicalizeJson(input.before);
+  const after = input.after === void 0 ? void 0 : canonicalizeJson(input.after);
+  const base = {
+    ...input,
+    before,
+    after,
+    severity: input.severity ?? severityFor(input.type)
+  };
+  return {
+    ...base,
+    id: hashCanonicalValue(base)
+  };
+}
+function fieldChanges(before, after, fields) {
+  return fields.flatMap(
+    (field) => same(before[field], after[field]) ? [] : [
+      {
+        field,
+        before: canonicalizeJson(before[field]),
+        after: canonicalizeJson(after[field])
+      }
+    ]
+  );
+}
+function diffContract(before, after) {
+  const changes = [];
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(before.routes),
+    ...Object.keys(after.routes)
+  ]);
+  for (const routeKey of Array.from(keys).sort()) {
+    const previous = before.routes[routeKey];
+    const next = after.routes[routeKey];
+    if (!previous && next) {
+      changes.push(
+        makeChange({
+          layer: "contract",
+          type: "route_added",
+          routeKey,
+          entityId: routeKey,
+          after: next.contract.serializedLeaf
+        })
+      );
+      continue;
+    }
+    if (previous && !next) {
+      changes.push(
+        makeChange({
+          layer: "contract",
+          type: "route_removed",
+          routeKey,
+          entityId: routeKey,
+          before: previous.contract.serializedLeaf
+        })
+      );
+      continue;
+    }
+    if (!previous || !next) continue;
+    if (previous.id !== next.id) {
+      changes.push(
+        makeChange({
+          layer: "contract",
+          type: "route_id_changed",
+          routeKey,
+          entityId: routeKey,
+          before: previous.id,
+          after: next.id
+        })
+      );
+    }
+    if (!same(previous.contract.schemaFlat, next.contract.schemaFlat)) {
+      changes.push(
+        makeChange({
+          layer: "contract",
+          type: "schema_changed",
+          routeKey,
+          entityId: routeKey,
+          before: previous.contract.schemaFlat,
+          after: next.contract.schemaFlat
+        })
+      );
+    }
+    const previousCfg = previous.contract.serializedLeaf.cfg;
+    const nextCfg = next.contract.serializedLeaf.cfg;
+    if (previousCfg.description !== nextCfg.description) {
+      changes.push(
+        makeChange({
+          layer: "contract",
+          type: "description_changed",
+          routeKey,
+          entityId: routeKey,
+          before: previousCfg.description,
+          after: nextCfg.description
+        })
+      );
+    }
+    if (!same(previousCfg.bodyFiles, nextCfg.bodyFiles)) {
+      changes.push(
+        makeChange({
+          layer: "contract",
+          type: "files_changed",
+          routeKey,
+          entityId: routeKey,
+          before: previousCfg.bodyFiles,
+          after: nextCfg.bodyFiles
+        })
+      );
+    }
+    const cfgFields = [
+      "summary",
+      "docsGroup",
+      "tags",
+      "deprecated",
+      "stability",
+      "docsHidden",
+      "docsMeta",
+      "feed"
+    ];
+    const fields = fieldChanges(
+      previousCfg,
+      nextCfg,
+      cfgFields
+    );
+    if (fields.length > 0) {
+      changes.push(
+        makeChange({
+          layer: "contract",
+          type: "cfg_changed",
+          routeKey,
+          entityId: routeKey,
+          before: previousCfg,
+          after: nextCfg,
+          changedFields: fields
+        })
+      );
+    }
+    if (!same(previous.contract.source, next.contract.source)) {
+      changes.push(
+        makeChange({
+          layer: "contract",
+          type: "source_changed",
+          routeKey,
+          entityId: routeKey,
+          before: previous.contract.source,
+          after: next.contract.source
+        })
+      );
+    }
+  }
+  return changes;
+}
+function diffOrderedEntities(args) {
+  const changes = [];
+  const previous = new Map(args.before.map((item) => [item.identity, item]));
+  const next = new Map(args.after.map((item) => [item.identity, item]));
+  const identities = /* @__PURE__ */ new Set([...previous.keys(), ...next.keys()]);
+  for (const identity of Array.from(identities).sort()) {
+    const left = previous.get(identity);
+    const right = next.get(identity);
+    if (!left && right) {
+      changes.push(
+        makeChange({
+          layer: args.layer,
+          type: args.added,
+          routeKey: args.routeKey,
+          entityId: identity,
+          after: right
+        })
+      );
+    } else if (left && !right) {
+      changes.push(
+        makeChange({
+          layer: args.layer,
+          type: args.removed,
+          routeKey: args.routeKey,
+          entityId: identity,
+          before: left
+        })
+      );
+    } else if (left && right) {
+      const leftWithoutOrder = { ...left, order: void 0 };
+      const rightWithoutOrder = { ...right, order: void 0 };
+      if (!same(leftWithoutOrder, rightWithoutOrder)) {
+        changes.push(
+          makeChange({
+            layer: args.layer,
+            type: args.changed,
+            routeKey: args.routeKey,
+            entityId: identity,
+            before: left,
+            after: right
+          })
+        );
+      } else if (left.order !== right.order) {
+        changes.push(
+          makeChange({
+            layer: args.layer,
+            type: args.reordered,
+            routeKey: args.routeKey,
+            entityId: identity,
+            before: left.order,
+            after: right.order
+          })
+        );
+      }
+    }
+  }
+  return changes;
+}
+function allBindings(snapshot) {
+  const map = /* @__PURE__ */ new Map();
+  for (const client of Object.values(snapshot.clients)) {
+    for (const binding of client.bindings)
+      map.set(binding.bindingIdentity, binding);
+  }
+  return map;
+}
+function diffClientSocketConnections(args) {
+  const changes = [];
+  const previous = new Map(args.before.map((item) => [item.identity, item]));
+  const next = new Map(args.after.map((item) => [item.identity, item]));
+  const identities = /* @__PURE__ */ new Set([...previous.keys(), ...next.keys()]);
+  for (const identity of Array.from(identities).sort()) {
+    const left = previous.get(identity);
+    const right = next.get(identity);
+    if (!left && right) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: "client_socket_connection_added",
+          routeKey: args.routeKey,
+          entityId: identity,
+          after: right
+        })
+      );
+      continue;
+    }
+    if (left && !right) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: "client_socket_connection_removed",
+          routeKey: args.routeKey,
+          entityId: identity,
+          before: left
+        })
+      );
+      continue;
+    }
+    if (!left || !right) continue;
+    const leftConnection = {
+      id: left.id,
+      name: left.name,
+      events: left.events,
+      order: left.order,
+      identityStability: left.identityStability
+    };
+    const rightConnection = {
+      id: right.id,
+      name: right.name,
+      events: right.events,
+      order: right.order,
+      identityStability: right.identityStability
+    };
+    if (!same(leftConnection, rightConnection)) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: "client_socket_connection_changed",
+          routeKey: args.routeKey,
+          entityId: identity,
+          before: leftConnection,
+          after: rightConnection
+        })
+      );
+    }
+    if (!same(left.roomStrategy, right.roomStrategy)) {
+      changes.push(
+        makeChange({
+          layer: "socket",
+          type: "socket_room_strategy_changed",
+          routeKey: args.routeKey,
+          entityId: identity,
+          before: left.roomStrategy,
+          after: right.roomStrategy
+        })
+      );
+    }
+    if (!same(left.cacheReducers, right.cacheReducers)) {
+      changes.push(
+        makeChange({
+          layer: "socket",
+          type: "socket_cache_reducer_changed",
+          routeKey: args.routeKey,
+          entityId: identity,
+          before: left.cacheReducers,
+          after: right.cacheReducers
+        })
+      );
+    }
+  }
+  return changes;
+}
+function diffClients(before, after) {
+  const changes = [];
+  const resourceIds = /* @__PURE__ */ new Set([
+    ...Object.keys(before.clients),
+    ...Object.keys(after.clients)
+  ]);
+  for (const identity of Array.from(resourceIds).sort()) {
+    if (!before.clients[identity] && after.clients[identity]) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: "client_resource_added",
+          entityId: identity,
+          after: after.clients[identity]
+        })
+      );
+    } else if (before.clients[identity] && !after.clients[identity]) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: "client_resource_removed",
+          entityId: identity,
+          before: before.clients[identity]
+        })
+      );
+    }
+  }
+  const previous = allBindings(before);
+  const next = allBindings(after);
+  const identities = /* @__PURE__ */ new Set([...previous.keys(), ...next.keys()]);
+  for (const identity of Array.from(identities).sort()) {
+    const left = previous.get(identity);
+    const right = next.get(identity);
+    if (!left && right) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: "client_binding_added",
+          routeKey: right.routeKey,
+          entityId: identity,
+          after: right
+        })
+      );
+      continue;
+    }
+    if (left && !right) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: "client_binding_removed",
+          routeKey: left.routeKey,
+          entityId: identity,
+          before: left
+        })
+      );
+      continue;
+    }
+    if (!left || !right) continue;
+    if (left.routeKey !== right.routeKey) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: "client_binding_target_changed",
+          routeKey: right.routeKey,
+          entityId: identity,
+          before: left.routeKey,
+          after: right.routeKey
+        })
+      );
+    }
+    if (left.enabled !== right.enabled) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: right.enabled ? "client_binding_enabled" : "client_binding_disabled",
+          routeKey: right.routeKey,
+          entityId: identity,
+          before: left.enabled,
+          after: right.enabled
+        })
+      );
+    }
+    if (!same(left.build, right.build)) {
+      changes.push(
+        makeChange({
+          layer: "client",
+          type: "client_build_options_changed",
+          routeKey: right.routeKey,
+          entityId: identity,
+          before: left.build,
+          after: right.build
+        })
+      );
+    }
+    changes.push(
+      ...diffOrderedEntities({
+        before: left.augments,
+        after: right.augments,
+        layer: "client",
+        routeKey: right.routeKey,
+        added: "client_augment_added",
+        removed: "client_augment_removed",
+        changed: "client_augment_changed",
+        reordered: "client_augment_reordered"
+      })
+    );
+    changes.push(
+      ...diffClientSocketConnections({
+        before: left.socketConnections,
+        after: right.socketConnections,
+        routeKey: right.routeKey
+      })
+    );
+  }
+  return changes;
+}
+function routeServerMap(snapshot) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [routeKey, route] of Object.entries(snapshot.routes)) {
+    if (route.server) map.set(routeKey, route.server);
+  }
+  return map;
+}
+function diffServers(before, after) {
+  const changes = [];
+  const previous = routeServerMap(before);
+  const next = routeServerMap(after);
+  const keys = /* @__PURE__ */ new Set([...previous.keys(), ...next.keys()]);
+  for (const routeKey of Array.from(keys).sort()) {
+    const left = previous.get(routeKey);
+    const right = next.get(routeKey);
+    if ((!left || !left.registered) && right?.registered) {
+      changes.push(
+        makeChange({
+          layer: "server",
+          type: "server_controller_registered",
+          routeKey,
+          entityId: right.controllerId ?? routeKey,
+          after: right
+        })
+      );
+      continue;
+    }
+    if (left?.registered && (!right || !right.registered)) {
+      changes.push(
+        makeChange({
+          layer: "server",
+          type: "server_controller_unregistered",
+          routeKey,
+          entityId: left.controllerId ?? routeKey,
+          before: left
+        })
+      );
+      continue;
+    }
+    if (!left || !right || !left.registered || !right.registered) continue;
+    if (left.enabled !== right.enabled) {
+      changes.push(
+        makeChange({
+          layer: "server",
+          type: right.enabled ? "server_endpoint_enabled" : "server_endpoint_disabled",
+          routeKey,
+          entityId: right.controllerId ?? routeKey,
+          before: left.enabled,
+          after: right.enabled
+        })
+      );
+    }
+    if (left.controllerId !== right.controllerId || left.controllerName !== right.controllerName) {
+      changes.push(
+        makeChange({
+          layer: "server",
+          type: "server_controller_changed",
+          routeKey,
+          entityId: right.controllerId ?? routeKey,
+          before: {
+            id: left.controllerId ?? null,
+            name: left.controllerName ?? null
+          },
+          after: {
+            id: right.controllerId ?? null,
+            name: right.controllerName ?? null
+          }
+        })
+      );
+    }
+    changes.push(
+      ...diffOrderedEntities({
+        before: left.before,
+        after: right.before,
+        layer: "server",
+        routeKey,
+        added: "server_middleware_added",
+        removed: "server_middleware_removed",
+        changed: "server_middleware_changed",
+        reordered: "server_middleware_reordered"
+      })
+    );
+    if (left.validateOutput !== right.validateOutput) {
+      changes.push(
+        makeChange({
+          layer: "server",
+          type: "server_output_validation_changed",
+          routeKey,
+          entityId: right.controllerId ?? routeKey,
+          before: left.validateOutput,
+          after: right.validateOutput
+        })
+      );
+    }
+  }
+  return changes;
+}
+function diffSockets(before, after) {
+  const changes = [];
+  const identities = /* @__PURE__ */ new Set([
+    ...Object.keys(before.sockets),
+    ...Object.keys(after.sockets)
+  ]);
+  for (const identity of Array.from(identities).sort()) {
+    const left = before.sockets[identity];
+    const right = after.sockets[identity];
+    if (!left && right) {
+      changes.push(
+        makeChange({
+          layer: "socket",
+          type: "socket_runtime_added",
+          entityId: identity,
+          after: right
+        })
+      );
+      continue;
+    }
+    if (left && !right) {
+      changes.push(
+        makeChange({
+          layer: "socket",
+          type: "socket_runtime_removed",
+          entityId: identity,
+          before: left
+        })
+      );
+      continue;
+    }
+    if (!left || !right) continue;
+    const eventNames = /* @__PURE__ */ new Set([
+      ...Object.keys(left.contract.events),
+      ...Object.keys(right.contract.events)
+    ]);
+    for (const eventName of Array.from(eventNames).sort()) {
+      const previousEvent = left.contract.events[eventName];
+      const nextEvent = right.contract.events[eventName];
+      const eventIdentity = `${identity}:event:${eventName}`;
+      if (!previousEvent && nextEvent) {
+        changes.push(
+          makeChange({
+            layer: "socket",
+            type: "socket_contract_event_added",
+            entityId: eventIdentity,
+            after: nextEvent
+          })
+        );
+      } else if (previousEvent && !nextEvent) {
+        changes.push(
+          makeChange({
+            layer: "socket",
+            type: "socket_contract_event_removed",
+            entityId: eventIdentity,
+            before: previousEvent
+          })
+        );
+      } else if (previousEvent && nextEvent && !same(previousEvent.schema, nextEvent.schema)) {
+        changes.push(
+          makeChange({
+            layer: "socket",
+            type: "socket_payload_schema_changed",
+            entityId: eventIdentity,
+            before: previousEvent.schema,
+            after: nextEvent.schema
+          })
+        );
+      }
+    }
+    if (!same(left.configuration.heartbeat, right.configuration.heartbeat)) {
+      changes.push(
+        makeChange({
+          layer: "socket",
+          type: "socket_heartbeat_configuration_changed",
+          entityId: identity,
+          before: left.configuration.heartbeat,
+          after: right.configuration.heartbeat
+        })
+      );
+    }
+    const previousHandlers = new Map(
+      left.configuration.handlers.map((handler) => [handler.identity, handler])
+    );
+    const nextHandlers = new Map(
+      right.configuration.handlers.map((handler) => [handler.identity, handler])
+    );
+    for (const handlerIdentity of Array.from(
+      /* @__PURE__ */ new Set([...previousHandlers.keys(), ...nextHandlers.keys()])
+    ).sort()) {
+      const previousHandler = previousHandlers.get(handlerIdentity);
+      const nextHandler = nextHandlers.get(handlerIdentity);
+      if (!previousHandler && nextHandler) {
+        changes.push(
+          makeChange({
+            layer: "socket",
+            type: "socket_handler_added",
+            entityId: handlerIdentity,
+            after: nextHandler
+          })
+        );
+      } else if (previousHandler && !nextHandler) {
+        changes.push(
+          makeChange({
+            layer: "socket",
+            type: "socket_handler_removed",
+            entityId: handlerIdentity,
+            before: previousHandler
+          })
+        );
+      } else if (previousHandler && nextHandler && !same(previousHandler, nextHandler)) {
+        changes.push(
+          makeChange({
+            layer: "socket",
+            type: "socket_handler_removed",
+            entityId: handlerIdentity,
+            before: previousHandler
+          }),
+          makeChange({
+            layer: "socket",
+            type: "socket_handler_added",
+            entityId: handlerIdentity,
+            after: nextHandler
+          })
+        );
+      }
+    }
+    const previousBindings = new Map(
+      left.bindings.map((binding) => [binding.identity, binding])
+    );
+    const nextBindings = new Map(
+      right.bindings.map((binding) => [binding.identity, binding])
+    );
+    for (const bindingIdentity of Array.from(
+      /* @__PURE__ */ new Set([...previousBindings.keys(), ...nextBindings.keys()])
+    ).sort()) {
+      const previousBinding = previousBindings.get(bindingIdentity);
+      const nextBinding = nextBindings.get(bindingIdentity);
+      if (!same(previousBinding, nextBinding)) {
+        changes.push(
+          makeChange({
+            layer: "socket",
+            type: "socket_binding_changed",
+            routeKey: nextBinding?.routeKey ?? previousBinding?.routeKey,
+            entityId: bindingIdentity,
+            before: previousBinding,
+            after: nextBinding
+          })
+        );
+      }
+    }
+  }
+  return changes;
+}
+function summarize(changes) {
+  const byLayer = {
+    contract: 0,
+    client: 0,
+    server: 0,
+    socket: 0
+  };
+  const bySeverity = {
+    breaking: 0,
+    behavioral: 0,
+    "non-breaking": 0,
+    informational: 0
+  };
+  const byType = {};
+  for (const change of changes) {
+    byLayer[change.layer] += 1;
+    bySeverity[change.severity] += 1;
+    byType[change.type] = (byType[change.type] ?? 0) + 1;
+  }
+  return { total: changes.length, byLayer, bySeverity, byType };
+}
+function diffRRRoutesSnapshots(before, after, options = {}) {
+  const changes = [
+    ...diffContract(before, after),
+    ...diffClients(before, after),
+    ...diffServers(before, after),
+    ...diffSockets(before, after)
+  ].sort((left, right) => {
+    const route = (left.routeKey ?? "").localeCompare(right.routeKey ?? "");
+    if (route !== 0) return route;
+    const layer = left.layer.localeCompare(right.layer);
+    if (layer !== 0) return layer;
+    const type = left.type.localeCompare(right.type);
+    return type !== 0 ? type : left.entityId.localeCompare(right.entityId);
+  });
+  const scope = options.scope ?? "default";
+  const trigger = options.trigger ?? { type: "manual" };
+  const transition = {
+    scope,
+    from: before.meta.snapshotHash,
+    to: after.meta.snapshotHash
+  };
+  return {
+    id: hashCanonicalValue(transition),
+    scope,
+    createdAt: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    from: {
+      snapshotHash: before.meta.snapshotHash,
+      capturedAt: before.meta.capturedAt,
+      checkpointId: options.fromCheckpointId
+    },
+    to: {
+      snapshotHash: after.meta.snapshotHash,
+      capturedAt: after.meta.capturedAt,
+      checkpointId: options.toCheckpointId
+    },
+    trigger,
+    summary: summarize(changes),
+    changes
+  };
+}
+var createSnapshotChangeSet = diffRRRoutesSnapshots;
+
+// src/exportFinalizedLeaves.changelog.ts
 var execFile = (0, import_node_util.promisify)(import_node_child_process2.execFile);
 var CHANGESET_CFG_FIELDS = [
   "summary",
@@ -1416,7 +2325,15 @@ var CHANGESET_CFG_FIELDS = [
   "feed"
 ];
 var SCHEMA_SECTIONS = ["params", "query", "body", "output"];
-var MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+var MODULE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".mjs",
+  ".cjs"
+];
 var COMPILE_CACHE_VERSION = "v2";
 var SOURCE_KEY_BY_SECTION = {
   params: "paramsSchema",
@@ -1427,7 +2344,7 @@ var SOURCE_KEY_BY_SECTION = {
 function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
-function stableStringify(value) {
+function stableStringify2(value) {
   return JSON.stringify(value, (_key, v) => {
     if (v && typeof v === "object" && !Array.isArray(v)) {
       const sorted = Object.entries(v).sort(([a], [b]) => a.localeCompare(b)).reduce((acc, [k, inner]) => {
@@ -1456,7 +2373,7 @@ function toCfgSubset(cfg) {
   return out;
 }
 function entrySignature(entry) {
-  return stableStringify({
+  return stableStringify2({
     type: entry.type,
     nullable: Boolean(entry.nullable),
     optional: Boolean(entry.optional),
@@ -1464,7 +2381,9 @@ function entrySignature(entry) {
   });
 }
 function semverToTuple(tag) {
-  const match = tag.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  const match = tag.match(
+    /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/
+  );
   if (!match) return null;
   return {
     major: Number(match[1]),
@@ -1510,7 +2429,9 @@ async function findDefaultFromCommit(cwd, toCommit) {
   const root = await runGit(cwd, ["rev-list", "--max-parents=0", toCommit]);
   const rootCommit = root.split("\n").map((item) => item.trim()).filter(Boolean)[0];
   if (!rootCommit) {
-    throw new Error("Failed to resolve a baseline commit for changelog generation.");
+    throw new Error(
+      "Failed to resolve a baseline commit for changelog generation."
+    );
   }
   return rootCommit;
 }
@@ -1629,11 +2550,15 @@ async function commitTouchedRelevantPaths(cwd, commit, moduleCandidates, tsconfi
   ]);
   const changedFiles = changed.split("\n").map((item) => normalizePath(item.trim()).replace(/^\/+/, "")).filter(Boolean);
   const moduleFiles = Array.from(
-    new Set(moduleCandidates.map((item) => normalizePath(item).replace(/^\/+/, "")))
+    new Set(
+      moduleCandidates.map((item) => normalizePath(item).replace(/^\/+/, ""))
+    )
   );
   const moduleDirs = Array.from(
     new Set(
-      moduleFiles.map((item) => normalizePath(import_node_path4.default.posix.dirname(item)).replace(/^\/+/, "")).filter((item) => item && item !== ".")
+      moduleFiles.map(
+        (item) => normalizePath(import_node_path4.default.posix.dirname(item)).replace(/^\/+/, "")
+      ).filter((item) => item && item !== ".")
     )
   );
   const tsconfigFile = tsconfigRel ? normalizePath(tsconfigRel).replace(/^\/+/, "") : void 0;
@@ -1656,7 +2581,12 @@ async function filterCommits(cwd, commits, moduleCandidates, tsconfigRel) {
   const keep = [commits[0]];
   for (let i = 1; i < commits.length; i += 1) {
     const commit = commits[i];
-    if (await commitTouchedRelevantPaths(cwd, commit, moduleCandidates, tsconfigRel)) {
+    if (await commitTouchedRelevantPaths(
+      cwd,
+      commit,
+      moduleCandidates,
+      tsconfigRel
+    )) {
       keep.push(commit);
     }
   }
@@ -1667,7 +2597,12 @@ async function filterCommits(cwd, commits, moduleCandidates, tsconfigRel) {
   return keep;
 }
 async function getCommitMetadata(cwd, commit) {
-  const out = await runGit(cwd, ["show", "-s", "--format=%H%x1f%aI%x1f%an%x1f%s", commit]);
+  const out = await runGit(cwd, [
+    "show",
+    "-s",
+    "--format=%H%x1f%aI%x1f%an%x1f%s",
+    commit
+  ]);
   const [sha, authorDate, authorName, subject] = out.split("");
   if (!sha || !authorDate || !authorName) {
     throw new Error(`Unable to read commit metadata for ${commit}`);
@@ -1810,7 +2745,7 @@ function diffRouteCfg(before, after) {
   for (const field of CHANGESET_CFG_FIELDS) {
     const prev = before[field];
     const next = after[field];
-    if (stableStringify(prev) !== stableStringify(next)) {
+    if (stableStringify2(prev) !== stableStringify2(next)) {
       out.push({
         field,
         before: prev,
@@ -1872,7 +2807,7 @@ function diffSourceSchemas(before, after) {
       continue;
     }
     if (!prevSignatures || !nextSignatures) continue;
-    if (stableStringify(prevSignatures) !== stableStringify(nextSignatures)) {
+    if (stableStringify2(prevSignatures) !== stableStringify2(nextSignatures)) {
       out.push({
         section,
         path: schemaPath,
@@ -2013,7 +2948,7 @@ function toEmittedModulePath(moduleRel) {
   return normalized;
 }
 function buildCompileCacheKey(commitSha, moduleRel, tsconfigKeyPath) {
-  return import_node_crypto.default.createHash("sha1").update(COMPILE_CACHE_VERSION).update("\n").update(commitSha).update("\n").update(normalizePath(moduleRel)).update("\n").update(normalizePath(tsconfigKeyPath)).digest("hex");
+  return import_node_crypto2.default.createHash("sha1").update(COMPILE_CACHE_VERSION).update("\n").update(commitSha).update("\n").update(normalizePath(moduleRel)).update("\n").update(normalizePath(tsconfigKeyPath)).digest("hex");
 }
 async function collectFilesRecursive(rootDir) {
   const files = [];
@@ -2086,13 +3021,16 @@ async function compileSnapshotEntry(options) {
   log(
     `[changelog] compile cache ${options.noCache ? "disabled" : "miss"}: ${options.commitSha.slice(0, 12)}`
   );
-  await import_promises2.default.rm(import_node_path4.default.join(options.cacheRoot, cacheKey), { recursive: true, force: true }).catch(
-    () => void 0
-  );
+  await import_promises2.default.rm(import_node_path4.default.join(options.cacheRoot, cacheKey), {
+    recursive: true,
+    force: true
+  }).catch(() => void 0);
   await import_promises2.default.mkdir(emitRoot, { recursive: true });
   const readResult = import_typescript2.default.readConfigFile(options.tsconfigPath, import_typescript2.default.sys.readFile);
   if (readResult.error) {
-    throw new Error(import_typescript2.default.flattenDiagnosticMessageText(readResult.error.messageText, "\n"));
+    throw new Error(
+      import_typescript2.default.flattenDiagnosticMessageText(readResult.error.messageText, "\n")
+    );
   }
   const parsed = import_typescript2.default.parseJsonConfigFileContent(
     readResult.config,
@@ -2121,7 +3059,10 @@ async function compileSnapshotEntry(options) {
       getCurrentDirectory: () => options.worktreeDir,
       getNewLine: () => "\n"
     };
-    const message = import_typescript2.default.formatDiagnosticsWithColorAndContext(diagnostics.slice(0, 20), host);
+    const message = import_typescript2.default.formatDiagnosticsWithColorAndContext(
+      diagnostics.slice(0, 20),
+      host
+    );
     throw new Error(
       `TypeScript snapshot compile failed for ${options.moduleRel} at ${options.commitSha.slice(0, 12)}:
 ${message}`
@@ -2141,7 +3082,13 @@ async function loadSnapshotExport(options) {
 }
 async function createSnapshot(repoRoot, moduleCandidates, exportName, commit, tempRoot, tsconfigRel, exportOptions, log) {
   const worktreeDir = import_node_path4.default.join(tempRoot, `wt-${commit.sha.slice(0, 12)}`);
-  await runGit(repoRoot, ["worktree", "add", "--detach", worktreeDir, commit.sha]);
+  await runGit(repoRoot, [
+    "worktree",
+    "add",
+    "--detach",
+    worktreeDir,
+    commit.sha
+  ]);
   try {
     try {
       await ensureWorktreeDependencies(repoRoot, worktreeDir);
@@ -2226,13 +3173,94 @@ async function createSnapshot(repoRoot, moduleCandidates, exportName, commit, te
       };
     }
   } finally {
-    await runGit(repoRoot, ["worktree", "remove", "--force", worktreeDir]).catch(() => void 0);
+    await runGit(repoRoot, [
+      "worktree",
+      "remove",
+      "--force",
+      worktreeDir
+    ]).catch(() => void 0);
     await import_promises2.default.rm(worktreeDir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
+function toCanonicalGitSnapshot(snapshot) {
+  const routes = Object.fromEntries(
+    Object.entries(snapshot.routesByKey).map(([routeKey, route]) => [
+      routeKey,
+      {
+        routeKey,
+        method: route.method,
+        path: route.path,
+        contract: {
+          serializedLeaf: {
+            key: routeKey,
+            method: route.method.toLowerCase(),
+            path: route.path,
+            cfg: { ...route.cfg, schemas: {} }
+          },
+          schemaFlat: route.flatSchema,
+          source: route.sourceBySection,
+          fingerprint: hashCanonicalValue({
+            cfg: route.cfg,
+            schema: route.flatSchema
+          })
+        },
+        clients: [],
+        sockets: [],
+        status: {
+          client: "unbound",
+          server: "unavailable",
+          socket: "none"
+        }
+      }
+    ])
+  );
+  const snapshotHash = hashCanonicalValue(routes);
+  return {
+    schemaVersion: 1,
+    meta: {
+      capturedAt: snapshot.commit.authorDate,
+      snapshotHash,
+      commit: snapshot.commit.sha,
+      packageVersions: {}
+    },
+    capabilities: {
+      contract: true,
+      client: false,
+      server: false,
+      socket: false,
+      live: false,
+      source: true
+    },
+    routes,
+    clients: {},
+    servers: {},
+    sockets: {},
+    diagnostics: []
+  };
+}
 function diffSnapshots(previous, current) {
   const routeEvents = [];
   const sourceEvents = [];
+  const changeSet = diffRRRoutesSnapshots(
+    toCanonicalGitSnapshot(previous),
+    toCanonicalGitSnapshot(current),
+    {
+      scope: "git",
+      trigger: {
+        type: "git",
+        externalId: current.commit.sha,
+        label: current.commit.subject
+      },
+      createdAt: current.commit.authorDate
+    }
+  );
+  const canonicalRouteTypes = /* @__PURE__ */ new Map();
+  for (const change of changeSet.changes) {
+    if (change.layer !== "contract" || !change.routeKey) continue;
+    const types = canonicalRouteTypes.get(change.routeKey) ?? /* @__PURE__ */ new Set();
+    types.add(change.type);
+    canonicalRouteTypes.set(change.routeKey, types);
+  }
   const routeKeys = /* @__PURE__ */ new Set([
     ...Object.keys(previous.routesByKey),
     ...Object.keys(current.routesByKey)
@@ -2240,7 +3268,8 @@ function diffSnapshots(previous, current) {
   for (const routeKey of Array.from(routeKeys).sort()) {
     const prevRoute = previous.routesByKey[routeKey];
     const nextRoute = current.routesByKey[routeKey];
-    if (!prevRoute && nextRoute) {
+    const canonicalTypes = canonicalRouteTypes.get(routeKey) ?? /* @__PURE__ */ new Set();
+    if (!prevRoute && nextRoute && canonicalTypes.has("route_added")) {
       const schemaDiff2 = diffRouteSchemas({}, nextRoute.flatSchema);
       routeEvents.push({
         type: "route_added",
@@ -2252,7 +3281,7 @@ function diffSnapshots(previous, current) {
       });
       continue;
     }
-    if (prevRoute && !nextRoute) {
+    if (prevRoute && !nextRoute && canonicalTypes.has("route_removed")) {
       routeEvents.push({
         type: "route_removed",
         commitSha: current.commit.sha,
@@ -2263,8 +3292,11 @@ function diffSnapshots(previous, current) {
       continue;
     }
     if (!prevRoute || !nextRoute) continue;
-    const schemaDiff = diffRouteSchemas(prevRoute.flatSchema, nextRoute.flatSchema);
-    if (schemaDiff.length > 0) {
+    const schemaDiff = diffRouteSchemas(
+      prevRoute.flatSchema,
+      nextRoute.flatSchema
+    );
+    if (schemaDiff.length > 0 && canonicalTypes.has("schema_changed")) {
       routeEvents.push({
         type: "schema_changed",
         commitSha: current.commit.sha,
@@ -2275,7 +3307,9 @@ function diffSnapshots(previous, current) {
       });
     }
     const cfgDiff = diffRouteCfg(prevRoute.cfg, nextRoute.cfg);
-    if (cfgDiff.length > 0) {
+    if (cfgDiff.length > 0 && ["cfg_changed", "description_changed", "files_changed"].some(
+      (type) => canonicalTypes.has(type)
+    )) {
       routeEvents.push({
         type: "cfg_changed",
         commitSha: current.commit.sha,
@@ -2322,8 +3356,12 @@ function diffSnapshots(previous, current) {
     const schemaDiff = diffSourceSchemas(prevSource, nextSource);
     const prevRoutes = new Set(prevSource.routeKeys);
     const nextRoutes = new Set(nextSource.routeKeys);
-    const routeAdded = Array.from(nextRoutes).filter((routeKey) => !prevRoutes.has(routeKey));
-    const routeRemoved = Array.from(prevRoutes).filter((routeKey) => !nextRoutes.has(routeKey));
+    const routeAdded = Array.from(nextRoutes).filter(
+      (routeKey) => !prevRoutes.has(routeKey)
+    );
+    const routeRemoved = Array.from(prevRoutes).filter(
+      (routeKey) => !nextRoutes.has(routeKey)
+    );
     if (schemaDiff.length > 0 || routeAdded.length > 0 || routeRemoved.length > 0) {
       sourceEvents.push({
         type: "source_schema_changed",
@@ -2339,28 +3377,10 @@ function diffSnapshots(previous, current) {
   }
   return {
     routeEvents,
-    sourceEvents
+    sourceEvents,
+    changeSet
   };
 }
-var BAKED_PAYLOAD_MARKER2 = "<!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->";
-function escapePayloadForInlineScript2(payload) {
-  return JSON.stringify(payload).replace(/<\//g, "<\\/").replace(/<!--/g, "<\\!--");
-}
-function injectPayloadIntoViewerHtml2(htmlTemplate, payload) {
-  const payloadScript = `${BAKED_PAYLOAD_MARKER2}
-<script id="finalized-leaves-baked-payload">window.__FINALIZED_LEAVES_PAYLOAD = ${escapePayloadForInlineScript2(
-    payload
-  )};</script>`;
-  if (htmlTemplate.includes(BAKED_PAYLOAD_MARKER2)) {
-    return htmlTemplate.replace(BAKED_PAYLOAD_MARKER2, payloadScript);
-  }
-  if (htmlTemplate.includes("</body>")) {
-    return htmlTemplate.replace("</body>", `${payloadScript}
-</body>`);
-  }
-  return `${payloadScript}
-${htmlTemplate}`;
-}
 async function resolveViewerTemplatePath2(viewerTemplateFile) {
   if (viewerTemplateFile) {
     const resolved = import_node_path4.default.resolve(viewerTemplateFile);
@@ -2373,7 +3393,10 @@ async function resolveViewerTemplatePath2(viewerTemplateFile) {
       "node_modules/@emeryld/rrroutes-export/tools/finalized-leaves-viewer.html"
     ),
     import_node_path4.default.resolve(process.cwd(), "tools/finalized-leaves-viewer.html"),
-    import_node_path4.default.resolve(process.cwd(), "packages/export/tools/finalized-leaves-viewer.html")
+    import_node_path4.default.resolve(
+      process.cwd(),
+      "packages/export/tools/finalized-leaves-viewer.html"
+    )
   ];
   for (const candidate of candidates) {
     try {
@@ -2394,7 +3417,11 @@ async function writeJsonExport2(payload, outFile) {
 async function writeBakedHtmlExport2(payload, htmlFile, viewerTemplateFile) {
   const templatePath = await resolveViewerTemplatePath2(viewerTemplateFile);
   const template = templatePath ? await import_promises2.default.readFile(templatePath, "utf8") : DEFAULT_VIEWER_TEMPLATE;
-  const baked = injectPayloadIntoViewerHtml2(template, payload);
+  const baked = injectBakedInspectorPayload(template, payload, {
+    marker: "<!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->",
+    globalName: "__FINALIZED_LEAVES_PAYLOAD",
+    scriptId: "finalized-leaves-baked-payload"
+  });
   const resolved = import_node_path4.default.resolve(htmlFile);
   await import_promises2.default.mkdir(import_node_path4.default.dirname(resolved), { recursive: true });
   await import_promises2.default.writeFile(resolved, baked, "utf8");
@@ -2445,7 +3472,9 @@ async function exportFinalizedLeavesChangelog(options) {
   log(`[changelog] resolving repository root from ${cwd}`);
   const repoRoot = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
   const modulePathAbsolute = import_node_path4.default.resolve(cwd, options.modulePath);
-  const modulePathRelative = normalizePath(import_node_path4.default.relative(repoRoot, modulePathAbsolute));
+  const modulePathRelative = normalizePath(
+    import_node_path4.default.relative(repoRoot, modulePathAbsolute)
+  );
   if (modulePathRelative.startsWith("..")) {
     throw new Error("modulePath must resolve inside the git repository root.");
   }
@@ -2457,7 +3486,9 @@ async function exportFinalizedLeavesChangelog(options) {
   const exportName = options.exportName ?? "leaves";
   log("[changelog] resolving commit window");
   const window = await resolveCommitWindow(repoRoot, options.from, options.to);
-  log(`[changelog] window: ${window.from.slice(0, 12)}..${window.to.slice(0, 12)}`);
+  log(
+    `[changelog] window: ${window.from.slice(0, 12)}..${window.to.slice(0, 12)}`
+  );
   const moduleCandidates = await buildModulePathCandidates(
     repoRoot,
     window.to,
@@ -2482,7 +3513,9 @@ async function exportFinalizedLeavesChangelog(options) {
   for (const commit of selectedCommitShas) {
     commits.push(await getCommitMetadata(repoRoot, commit));
   }
-  const tempRoot = await import_promises2.default.mkdtemp(import_node_path4.default.join(import_node_os.default.tmpdir(), "rrroutes-export-changelog-"));
+  const tempRoot = await import_promises2.default.mkdtemp(
+    import_node_path4.default.join(import_node_os.default.tmpdir(), "rrroutes-export-changelog-")
+  );
   log(`[changelog] temp workspace: ${tempRoot}`);
   try {
     const snapshots = [];
@@ -2519,6 +3552,7 @@ async function exportFinalizedLeavesChangelog(options) {
     }
     const routeEvents = [];
     const sourceEvents = [];
+    const changeSets = [];
     log("[changelog] diffing successful snapshots");
     let previousSnapshot;
     for (const snapshot of snapshots) {
@@ -2529,12 +3563,14 @@ async function exportFinalizedLeavesChangelog(options) {
         previousSnapshot = snapshot;
         continue;
       }
-      const { routeEvents: nextRouteEvents, sourceEvents: nextSourceEvents } = diffSnapshots(
-        previousSnapshot,
-        snapshot
-      );
+      const {
+        routeEvents: nextRouteEvents,
+        sourceEvents: nextSourceEvents,
+        changeSet
+      } = diffSnapshots(previousSnapshot, snapshot);
       routeEvents.push(...nextRouteEvents);
       sourceEvents.push(...nextSourceEvents);
+      changeSets.push(changeSet);
       previousSnapshot = snapshot;
     }
     log(
@@ -2556,7 +3592,8 @@ async function exportFinalizedLeavesChangelog(options) {
       commits,
       byRoute: routeRecordByKey(routeEvents),
       bySourceObject: sourceRecordById(sourceEvents),
-      rollups: buildRollups(routeEvents, sourceEvents, commits)
+      rollups: buildRollups(routeEvents, sourceEvents, commits),
+      changeSets
     };
     if (options.outFile || options.htmlFile) {
       log("[changelog] writing output artifacts");
@@ -2663,25 +3700,6 @@ async function runExportFinalizedLeavesChangelogCli(argv) {
 var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 var import_node_child_process3 = require("child_process");
-var BAKED_PAYLOAD_MARKER3 = "<!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->";
-function escapePayloadForInlineScript3(payload) {
-  return JSON.stringify(payload).replace(/<\//g, "<\\/").replace(/<!--/g, "<\\!--");
-}
-function injectPayloadIntoViewerHtml3(htmlTemplate, payload) {
-  const payloadScript = `${BAKED_PAYLOAD_MARKER3}
-<script id="finalized-leaves-baked-payload">window.__FINALIZED_LEAVES_PAYLOAD = ${escapePayloadForInlineScript3(
-    payload
-  )};</script>`;
-  if (htmlTemplate.includes(BAKED_PAYLOAD_MARKER3)) {
-    return htmlTemplate.replace(BAKED_PAYLOAD_MARKER3, payloadScript);
-  }
-  if (htmlTemplate.includes("</body>")) {
-    return htmlTemplate.replace("</body>", `${payloadScript}
-</body>`);
-  }
-  return `${payloadScript}
-${htmlTemplate}`;
-}
 async function resolveViewerTemplatePath3(viewerTemplateFile) {
   if (viewerTemplateFile) {
     const resolved = import_node_path6.default.resolve(viewerTemplateFile);
@@ -2694,7 +3712,10 @@ async function resolveViewerTemplatePath3(viewerTemplateFile) {
       "node_modules/@emeryld/rrroutes-export/tools/finalized-leaves-viewer.html"
     ),
     import_node_path6.default.resolve(process.cwd(), "tools/finalized-leaves-viewer.html"),
-    import_node_path6.default.resolve(process.cwd(), "packages/export/tools/finalized-leaves-viewer.html")
+    import_node_path6.default.resolve(
+      process.cwd(),
+      "packages/export/tools/finalized-leaves-viewer.html"
+    )
   ];
   for (const candidate of candidates) {
     try {
@@ -2715,7 +3736,11 @@ async function writeJsonExport3(payload, outFile) {
 async function writeBakedHtmlExport3(payload, htmlFile, viewerTemplateFile) {
   const templatePath = await resolveViewerTemplatePath3(viewerTemplateFile);
   const template = templatePath ? await import_promises3.default.readFile(templatePath, "utf8") : DEFAULT_VIEWER_TEMPLATE;
-  const baked = injectPayloadIntoViewerHtml3(template, payload);
+  const baked = injectBakedInspectorPayload(template, payload, {
+    marker: "<!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->",
+    globalName: "__FINALIZED_LEAVES_PAYLOAD",
+    scriptId: "finalized-leaves-baked-payload"
+  });
   const resolved = import_node_path6.default.resolve(htmlFile);
   await import_promises3.default.mkdir(import_node_path6.default.dirname(resolved), { recursive: true });
   await import_promises3.default.writeFile(resolved, baked, "utf8");
@@ -2771,30 +3796,1981 @@ async function writeFinalizedLeavesViewerBundle(payload, outFileOrOptions) {
   }
   return written;
 }
+
+// src/snapshot/build.ts
+var import_rrroutes_contract5 = require("@emeryld/rrroutes-contract");
+
+// src/inspection/diagnostics.ts
+var _items;
+var InspectionDiagnostics = class {
+  constructor() {
+    __privateAdd(this, _items, []);
+  }
+  add(diagnostic) {
+    __privateGet(this, _items).push(diagnostic);
+  }
+  list(options = {}) {
+    const items = options.includeInfo === false ? __privateGet(this, _items).filter((item) => item.severity !== "info") : __privateGet(this, _items);
+    return items.slice().sort((left, right) => {
+      const byCode = left.code.localeCompare(right.code);
+      if (byCode !== 0) return byCode;
+      return JSON.stringify(left.entity ?? {}).localeCompare(
+        JSON.stringify(right.entity ?? {})
+      );
+    });
+  }
+};
+_items = new WeakMap();
+
+// src/inspection/inspect-clients.ts
+var import_rrroutes_contract3 = require("@emeryld/rrroutes-contract");
+
+// src/inspection/native.ts
+var import_rrroutes_contract2 = require("@emeryld/rrroutes-contract");
+function asRecord2(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function readNativeInspection(value) {
+  const record = asRecord2(value);
+  if (!record) return void 0;
+  const inspect = record[import_rrroutes_contract2.RRROUTES_INSPECTION];
+  if (typeof inspect !== "function") return void 0;
+  try {
+    return asRecord2(inspect.call(value));
+  } catch {
+    return void 0;
+  }
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+
+// src/inspection/normalize-clients.ts
+function normalizeClientsInput(endpointClient, allClients) {
+  const out = [];
+  if (endpointClient) {
+    out.push({
+      value: endpointClient,
+      registeredName: "endpointClient",
+      index: 0
+    });
+  }
+  if (!allClients) return out;
+  if (Array.isArray(allClients)) {
+    const offset2 = out.length;
+    allClients.forEach(
+      (value, index) => out.push({ value, index: offset2 + index })
+    );
+    return out;
+  }
+  const offset = out.length;
+  Object.entries(allClients).forEach(([registeredName, value], index) => {
+    out.push({ value, registeredName, index: offset + index });
+  });
+  return out;
+}
+function looksLikeClientEndpoint(value) {
+  const native = readNativeInspection(value);
+  if (native?.kind === "client-endpoint") return true;
+  return Boolean(
+    value && typeof value === "object" && "leaf" in value && value.leaf
+  );
+}
+
+// src/inspection/serializable.ts
+var MAX_METADATA_DEPTH = 8;
+function serializeSelectedMetadata(value, depth = 0) {
+  if (depth > MAX_METADATA_DEPTH || value === void 0) return void 0;
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "bigint") return String(value);
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeSelectedMetadata(item, depth + 1)).filter((item) => item !== void 0);
+  }
+  if (typeof value !== "object") return void 0;
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    const child = serializeSelectedMetadata(
+      value[key],
+      depth + 1
+    );
+    if (child !== void 0) out[key] = child;
+  }
+  return out;
+}
+var CLIENT_BUILD_OPTION_FIELDS = [
+  "enabled",
+  "staleTime",
+  "gcTime",
+  "retry",
+  "retryDelay",
+  "refetchInterval",
+  "refetchOnMount",
+  "refetchOnWindowFocus",
+  "refetchOnReconnect",
+  "singleton",
+  "splitPageSize",
+  "splitPageSizeParam",
+  "pagination",
+  "feed",
+  "many"
+];
+function serializeClientBuildOptions(value) {
+  if (!value || typeof value !== "object") return {};
+  const source = value;
+  const out = {};
+  for (const field of CLIENT_BUILD_OPTION_FIELDS) {
+    const selected = serializeSelectedMetadata(source[field]);
+    if (selected !== void 0) out[field] = selected;
+  }
+  return out;
+}
+
+// src/inspection/inspect-clients.ts
+function isLeaf(value) {
+  const record = asRecord2(value);
+  return Boolean(
+    record && typeof record.method === "string" && typeof record.path === "string" && record.cfg && typeof record.cfg === "object"
+  );
+}
+function endpointFrom(value) {
+  const descriptor = readNativeInspection(value);
+  if (descriptor?.kind === "client-endpoint" && isLeaf(descriptor.leaf)) {
+    return {
+      leaf: descriptor.leaf,
+      id: optionalString(descriptor.id),
+      name: optionalString(descriptor.name),
+      enabled: optionalBoolean(descriptor.enabled) ?? true,
+      built: optionalBoolean(descriptor.built) ?? true,
+      buildOptions: descriptor.buildOptions,
+      augments: Array.isArray(descriptor.augments) ? descriptor.augments.map(asRecord2).filter(
+        (item) => Boolean(item)
+      ) : [],
+      socketConnections: Array.isArray(descriptor.socketConnections) ? descriptor.socketConnections.map(asRecord2).filter(
+        (item) => Boolean(item)
+      ) : [],
+      complete: true
+    };
+  }
+  const record = asRecord2(value);
+  if (!record || !isLeaf(record.leaf)) return void 0;
+  return {
+    leaf: record.leaf,
+    enabled: true,
+    built: true,
+    augments: [],
+    socketConnections: [],
+    complete: false
+  };
+}
+function bindingsFromDescriptor(descriptor) {
+  if (descriptor.kind === "client-resource") {
+    const bindings = Array.isArray(descriptor.bindings) ? descriptor.bindings.flatMap((value, index) => {
+      const binding = asRecord2(value);
+      const endpoint = endpointFromInspectionRecord(binding?.endpoint) ?? endpointFrom(binding?.endpoint);
+      if (!binding || !endpoint) return [];
+      return [
+        {
+          id: optionalString(binding.id),
+          publicName: optionalString(binding.publicName) ?? endpoint.name ?? `endpoint-${index}`,
+          enabled: optionalBoolean(binding.enabled),
+          endpoint
+        }
+      ];
+    }) : [];
+    return {
+      id: optionalString(descriptor.id),
+      name: optionalString(descriptor.name),
+      bindings
+    };
+  }
+  if (descriptor.kind === "endpoint-client") {
+    const endpoints = Array.isArray(descriptor.endpoints) ? descriptor.endpoints : [];
+    return {
+      name: "Endpoint client",
+      bindings: endpoints.flatMap((value, index) => {
+        const endpoint = endpointFromInspectionRecord(value);
+        if (!endpoint) return [];
+        return [
+          {
+            id: endpoint.id,
+            publicName: endpoint.name ?? endpoint.id ?? (0, import_rrroutes_contract3.routeKeyOf)(endpoint.leaf.method, endpoint.leaf.path),
+            enabled: endpoint.enabled,
+            endpoint
+          }
+        ];
+      })
+    };
+  }
+  return void 0;
+}
+function endpointFromInspectionRecord(value) {
+  const record = asRecord2(value);
+  if (!record || record.kind !== "client-endpoint" || !isLeaf(record.leaf)) {
+    return void 0;
+  }
+  return {
+    leaf: record.leaf,
+    id: optionalString(record.id),
+    name: optionalString(record.name),
+    enabled: optionalBoolean(record.enabled) ?? true,
+    built: optionalBoolean(record.built) ?? true,
+    buildOptions: record.buildOptions,
+    augments: Array.isArray(record.augments) ? record.augments.map(asRecord2).filter((item) => Boolean(item)) : [],
+    socketConnections: Array.isArray(record.socketConnections) ? record.socketConnections.map(asRecord2).filter((item) => Boolean(item)) : [],
+    complete: true
+  };
+}
+function resourceFrom(input) {
+  const descriptor = readNativeInspection(input.value);
+  const native = descriptor ? bindingsFromDescriptor(descriptor) : void 0;
+  if (native) return native;
+  if (looksLikeClientEndpoint(input.value)) {
+    const endpoint = endpointFrom(input.value);
+    return {
+      bindings: endpoint ? [
+        {
+          id: endpoint.id,
+          publicName: endpoint.name ?? endpoint.id ?? "endpoint",
+          enabled: endpoint.enabled,
+          endpoint
+        }
+      ] : []
+    };
+  }
+  return {
+    bindings: Object.entries(input.value).flatMap(
+      ([publicName, value]) => {
+        const endpoint = endpointFrom(value);
+        return endpoint ? [{ publicName, endpoint }] : [];
+      }
+    )
+  };
+}
+function inspectAugments(descriptors, bindingIdentity) {
+  return descriptors.map((descriptor, index) => {
+    const id = optionalString(descriptor.id);
+    return {
+      identity: id ?? `${bindingIdentity}:augment:${index}`,
+      id,
+      name: optionalString(descriptor.name),
+      kind: optionalString(descriptor.kind),
+      options: serializeSelectedMetadata(descriptor.options),
+      order: index,
+      identityStability: id ? "stable" : "positional"
+    };
+  });
+}
+function inspectSocketConnections(descriptors, bindingIdentity) {
+  return descriptors.map((descriptor, index) => {
+    const id = optionalString(descriptor.id);
+    return {
+      identity: id ?? `${bindingIdentity}:socket:${index}`,
+      id,
+      name: optionalString(descriptor.name),
+      events: Array.isArray(descriptor.events) ? descriptor.events.filter((item) => typeof item === "string").sort() : [],
+      roomStrategy: serializeSelectedMetadata(descriptor.roomStrategy),
+      cacheReducers: Array.isArray(descriptor.cacheReducers) ? descriptor.cacheReducers.map((item) => serializeSelectedMetadata(item)).filter(
+        (item) => item !== void 0
+      ) : [],
+      order: index,
+      identityStability: id ? "stable" : "positional"
+    };
+  });
+}
+function inspectClients(inputs, diagnostics) {
+  const clients = {};
+  const byRoute = {};
+  for (const input of inputs) {
+    const resource = resourceFrom(input);
+    const identity = resource.id ?? input.registeredName ?? `client-${input.index}`;
+    const resourceStability = resource.id || input.registeredName ? "stable" : "positional";
+    const seenPublicNames = /* @__PURE__ */ new Map();
+    const bindings = resource.bindings.map((binding, index) => {
+      const routeKey = (0, import_rrroutes_contract3.routeKeyOf)(
+        binding.endpoint.leaf.method,
+        binding.endpoint.leaf.path
+      );
+      const seen = seenPublicNames.get(binding.publicName) ?? 0;
+      seenPublicNames.set(binding.publicName, seen + 1);
+      const publicName = seen === 0 ? binding.publicName : `${binding.publicName}-${index}`;
+      const bindingIdentity = binding.id ?? `${identity}:${publicName}`;
+      const buildOptions = serializeClientBuildOptions(
+        binding.endpoint.buildOptions
+      );
+      const pagination = buildOptions.pagination;
+      const inspected = {
+        clientId: identity,
+        clientName: resource.name ?? input.registeredName,
+        bindingId: binding.id,
+        bindingIdentity,
+        publicName,
+        routeKey,
+        enabled: binding.enabled ?? binding.endpoint.enabled,
+        built: binding.endpoint.built,
+        build: {
+          feed: Boolean(binding.endpoint.leaf.cfg.feed),
+          singleton: buildOptions.singleton === true,
+          many: Boolean(buildOptions.many),
+          pagination,
+          options: buildOptions
+        },
+        augments: inspectAugments(binding.endpoint.augments, bindingIdentity),
+        socketConnections: inspectSocketConnections(
+          binding.endpoint.socketConnections,
+          bindingIdentity
+        ),
+        identityStability: binding.id || seen === 0 ? "stable" : "positional"
+      };
+      if (!binding.endpoint.complete) {
+        diagnostics.add({
+          code: "CLIENT_AUGMENT_DETAILS_UNAVAILABLE",
+          severity: "info",
+          entity: { routeKey, client: identity },
+          message: "The endpoint was detected, but augment descriptors were not exposed."
+        });
+      }
+      byRoute[routeKey] ?? (byRoute[routeKey] = []);
+      byRoute[routeKey].push(inspected);
+      return inspected;
+    });
+    clients[identity] = {
+      identity,
+      id: resource.id,
+      name: resource.name ?? input.registeredName,
+      identityStability: resourceStability,
+      bindings
+    };
+    if (resourceStability === "positional") {
+      diagnostics.add({
+        code: "CLIENT_IDENTITY_POSITIONAL",
+        severity: "info",
+        entity: { client: identity },
+        message: "Client identity uses its array position and may change after reordering."
+      });
+    }
+  }
+  for (const bindings of Object.values(byRoute)) {
+    bindings.sort(
+      (left, right) => left.bindingIdentity.localeCompare(right.bindingIdentity)
+    );
+  }
+  return { clients, byRoute };
+}
+
+// src/inspection/inspect-contract.ts
+var import_rrroutes_contract4 = require("@emeryld/rrroutes-contract");
+async function inspectContractRoutes(leaves, source, includeSource) {
+  const exported = await exportFinalizedLeaves(leaves, {
+    includeSource: includeSource && (source?.include ?? true),
+    sourceModulePath: source?.modulePath,
+    sourceExportName: source?.exportName,
+    tsconfigPath: source?.tsconfigPath
+  });
+  const routes = {};
+  for (const serializedLeaf of exported.leaves) {
+    const routeKey = (0, import_rrroutes_contract4.routeKeyOf)(serializedLeaf.method, serializedLeaf.path);
+    const schemaFlat = exported.schemaFlatByLeaf[routeKey] ?? {};
+    routes[routeKey] = {
+      serializedLeaf,
+      schemaFlat,
+      source: exported.sourceByLeaf?.[routeKey],
+      fingerprint: hashCanonicalValue({ serializedLeaf, schemaFlat })
+    };
+  }
+  return {
+    routes,
+    sourceExtraction: exported._meta.sourceExtraction
+  };
+}
+
+// src/inspection/inspect-server.ts
+function isLeaf2(value) {
+  const record = asRecord2(value);
+  return Boolean(
+    record && typeof record.method === "string" && typeof record.path === "string" && record.cfg && typeof record.cfg === "object"
+  );
+}
+function inspectServer(input, diagnostics) {
+  if (!input)
+    return {
+      servers: {},
+      byRoute: {}
+    };
+  const descriptor = readNativeInspection(input);
+  if (!descriptor || descriptor.kind !== "server-runtime") {
+    diagnostics.add({
+      code: "SERVER_REGISTRATION_DETAILS_UNAVAILABLE",
+      severity: "warning",
+      entity: { server: "server" },
+      message: "A server runtime was supplied, but it did not expose the RRRoutes inspection protocol."
+    });
+    return {
+      servers: {
+        server: {
+          identity: "server",
+          identityStability: "stable",
+          controllers: {},
+          middleware: { sanitizerCount: 0, preCtxCount: 0, postCtxCount: 0 },
+          validateOutput: false
+        }
+      },
+      byRoute: {}
+    };
+  }
+  const id = optionalString(descriptor.id);
+  const name = optionalString(descriptor.name);
+  const identity = id ?? name ?? "server";
+  const nativeMiddleware = asRecord2(descriptor.middleware);
+  const middleware = {
+    sanitizerCount: typeof nativeMiddleware?.sanitizerCount === "number" ? nativeMiddleware.sanitizerCount : 0,
+    preCtxCount: typeof nativeMiddleware?.preCtxCount === "number" ? nativeMiddleware.preCtxCount : 0,
+    postCtxCount: typeof nativeMiddleware?.postCtxCount === "number" ? nativeMiddleware.postCtxCount : 0
+  };
+  const validateOutput = optionalBoolean(descriptor.validateOutput) ?? false;
+  const controllers = {};
+  for (const nativeValue of Array.isArray(descriptor.controllers) ? descriptor.controllers : []) {
+    const native = asRecord2(nativeValue);
+    const routeKey = optionalString(native?.routeKey);
+    if (!native || !routeKey || !isLeaf2(native.leaf)) continue;
+    const controllerId = optionalString(native.id);
+    const before = (Array.isArray(native.before) ? native.before : []).flatMap((middlewareValue, index) => {
+      const item = asRecord2(middlewareValue);
+      if (!item) return [];
+      const middlewareId = optionalString(item.id);
+      return [
+        {
+          identity: middlewareId ?? `${routeKey}:before:${index}`,
+          id: middlewareId,
+          name: optionalString(item.name),
+          order: index,
+          identityStability: middlewareId ? "stable" : "positional"
+        }
+      ];
+    });
+    controllers[routeKey] = {
+      routeKey,
+      registered: true,
+      enabled: optionalBoolean(native.enabled) ?? true,
+      controllerId,
+      controllerName: optionalString(native.name),
+      before,
+      middleware: {
+        ...middleware,
+        beforeCount: before.length
+      },
+      validateOutput,
+      multipart: Boolean(native.leaf.cfg.bodyFiles?.length),
+      identityStability: "stable"
+    };
+    for (const item of before) {
+      if (item.identityStability === "positional") {
+        diagnostics.add({
+          code: "SERVER_MIDDLEWARE_IDENTITY_POSITIONAL",
+          severity: "info",
+          entity: { routeKey, server: identity },
+          message: "Middleware identity uses its route-local position and may change after reordering."
+        });
+      }
+    }
+  }
+  return {
+    servers: {
+      [identity]: {
+        identity,
+        id,
+        name,
+        identityStability: "stable",
+        controllers,
+        middleware,
+        validateOutput
+      }
+    },
+    byRoute: controllers
+  };
+}
+
+// src/inspection/inspect-sockets.ts
+function toLiveInspection(value) {
+  const live = asRecord2(value);
+  if (!live) return void 0;
+  const routeSubscriptions = Array.isArray(live.leaves) ? live.leaves.flatMap(
+    (leafValue) => {
+      const leaf = asRecord2(leafValue);
+      const routeKey = optionalString(leaf?.leaf);
+      if (!leaf || !routeKey) return [];
+      return [
+        {
+          routeKey,
+          rooms: Array.isArray(leaf.rooms) ? leaf.rooms.flatMap((roomValue) => {
+            const room = asRecord2(roomValue);
+            return room && typeof room.room === "string" && typeof room.count === "number" ? [{ room: room.room, count: room.count }] : [];
+          }) : [],
+          handlers: Array.isArray(leaf.handlers) ? leaf.handlers.flatMap((handlerValue) => {
+            const handler = asRecord2(handlerValue);
+            return handler && typeof handler.event === "string" && typeof handler.handlers === "number" ? [{ event: handler.event, handlers: handler.handlers }] : [];
+          }) : []
+        }
+      ];
+    }
+  ) : void 0;
+  return {
+    connected: optionalBoolean(live.connected) ?? false,
+    socketId: optionalString(live.socketId),
+    namespace: optionalString(live.nsp),
+    roomsCount: typeof live.roomsCount === "number" ? live.roomsCount : void 0,
+    totalHandlers: typeof live.totalHandlers === "number" ? live.totalHandlers : void 0,
+    rooms: Array.isArray(live.rooms) ? live.rooms.flatMap((roomValue) => {
+      const room = asRecord2(roomValue);
+      return room && typeof room.room === "string" && typeof room.count === "number" ? [{ room: room.room, count: room.count }] : [];
+    }) : void 0,
+    handlers: Array.isArray(live.handlers) ? live.handlers.flatMap((handlerValue) => {
+      const handler = asRecord2(handlerValue);
+      return handler && typeof handler.event === "string" && typeof handler.handlers === "number" ? [{ event: handler.event, handlers: handler.handlers }] : [];
+    }) : void 0,
+    routeSubscriptions
+  };
+}
+function inspectSockets(inputs, includeLive, diagnostics) {
+  const sockets = {};
+  for (const input of inputs) {
+    const descriptor = readNativeInspection(input.value);
+    const id = optionalString(descriptor?.id);
+    const name = optionalString(descriptor?.name);
+    const identity = id ?? input.registeredName ?? name ?? `socket-${input.index}`;
+    const stability = id || input.registeredName || name ? "stable" : "positional";
+    const events = asRecord2(descriptor?.events);
+    const contractEvents = {};
+    const handlers = (Array.isArray(descriptor?.handlers) ? descriptor.handlers : []).flatMap((handlerValue, index) => {
+      const handler = asRecord2(handlerValue);
+      const event = optionalString(handler?.event);
+      if (!handler || !event) return [];
+      return [
+        {
+          identity: `${identity}:handler:${event}:${index}`,
+          event,
+          name: optionalString(handler.name),
+          order: typeof handler.order === "number" ? handler.order : index,
+          identityStability: "positional"
+        }
+      ];
+    });
+    const bindings = (Array.isArray(descriptor?.bindings) ? descriptor.bindings : []).flatMap((bindingValue, index) => {
+      const binding = asRecord2(bindingValue);
+      const routeKey = optionalString(binding?.routeKey);
+      if (!binding || !routeKey) return [];
+      return [
+        {
+          identity: `${identity}:binding:${routeKey}`,
+          routeKey,
+          eventNames: Array.isArray(binding.events) ? binding.events.filter((event) => typeof event === "string").sort() : [],
+          identityStability: "stable"
+        }
+      ];
+    });
+    for (const eventName of Object.keys(events ?? {}).sort()) {
+      const event = asRecord2(events?.[eventName]);
+      const message = event?.message;
+      contractEvents[eventName] = {
+        identity: `${identity}:event:${eventName}`,
+        name: eventName,
+        schema: message && typeof message === "object" ? introspectSchema(message) : void 0
+      };
+    }
+    if (!descriptor || descriptor.kind !== "socket-runtime") {
+      diagnostics.add({
+        code: "SOCKET_DETAILS_UNAVAILABLE",
+        severity: "info",
+        entity: { socket: identity },
+        message: "A socket runtime was supplied, but it did not expose the RRRoutes inspection protocol."
+      });
+    }
+    if (stability === "positional") {
+      diagnostics.add({
+        code: "SOCKET_IDENTITY_POSITIONAL",
+        severity: "info",
+        entity: { socket: identity },
+        message: "Socket identity uses its array position and may change after reordering."
+      });
+    }
+    sockets[identity] = {
+      identity,
+      id,
+      name: name ?? input.registeredName,
+      identityStability: stability,
+      contract: { events: contractEvents },
+      configuration: {
+        heartbeat: serializeSelectedMetadata(descriptor?.heartbeat),
+        reconnection: serializeSelectedMetadata(descriptor?.reconnection),
+        system: serializeSelectedMetadata(descriptor?.config),
+        handlers
+      },
+      bindings,
+      live: includeLive ? toLiveInspection(
+        descriptor?.live ?? asRecord2(input.value)?.statsSnapshot
+      ) : void 0
+    };
+  }
+  return sockets;
+}
+
+// src/inspection/join-routes.ts
+function joinRouteInspections(args) {
+  const routes = {};
+  const serverRuntime = Object.values(args.servers)[0];
+  for (const routeKey of Object.keys(args.contract).sort()) {
+    const contract = args.contract[routeKey];
+    const clients = (args.clients[routeKey] ?? []).slice();
+    const registeredServer = args.server[routeKey];
+    const server = registeredServer ?? (args.serverSupplied ? {
+      routeKey,
+      registered: false,
+      enabled: false,
+      before: [],
+      middleware: {
+        sanitizerCount: serverRuntime?.middleware.sanitizerCount ?? 0,
+        preCtxCount: serverRuntime?.middleware.preCtxCount ?? 0,
+        postCtxCount: serverRuntime?.middleware.postCtxCount ?? 0,
+        beforeCount: 0
+      },
+      validateOutput: serverRuntime?.validateOutput ?? false,
+      multipart: Boolean(contract.serializedLeaf.cfg.bodyFiles?.length),
+      identityStability: "stable"
+    } : void 0);
+    const sockets = clients.flatMap(
+      (client) => client.socketConnections.map((connection) => ({
+        identity: connection.identity,
+        clientBindingIdentity: client.bindingIdentity,
+        events: connection.events,
+        roomStrategy: connection.roomStrategy,
+        cacheReducers: connection.cacheReducers,
+        identityStability: connection.identityStability
+      }))
+    );
+    routes[routeKey] = {
+      routeKey,
+      id: contract.serializedLeaf.id,
+      method: contract.serializedLeaf.method.toUpperCase(),
+      path: contract.serializedLeaf.path,
+      contract,
+      clients,
+      server,
+      sockets,
+      status: {
+        client: clients.length === 0 ? "unbound" : clients.some((client) => client.enabled) ? "bound" : "disabled",
+        server: !args.serverSupplied ? "unavailable" : !server?.registered ? "missing" : server.enabled ? "enabled" : "disabled",
+        socket: sockets.length > 0 ? "configured" : "none"
+      }
+    };
+  }
+  for (const routeKey of Object.keys(args.clients)) {
+    if (args.contract[routeKey]) continue;
+    args.diagnostics.push({
+      code: "CLIENT_ROUTE_NOT_IN_CONTRACT_INPUT",
+      severity: "warning",
+      entity: { routeKey },
+      message: "A client binding targets a route that was not present in allRoutes."
+    });
+  }
+  for (const routeKey of Object.keys(args.server)) {
+    if (args.contract[routeKey]) continue;
+    args.diagnostics.push({
+      code: "SERVER_ROUTE_NOT_IN_CONTRACT_INPUT",
+      severity: "warning",
+      entity: { routeKey },
+      message: "A server controller targets a route that was not present in allRoutes."
+    });
+  }
+  return routes;
+}
+
+// src/inspection/normalize-routes.ts
+function hasAll(value) {
+  return Boolean(
+    value && typeof value === "object" && "all" in value && Array.isArray(value.all)
+  );
+}
+function normalizeRoutesInput(input) {
+  if (Array.isArray(input)) return input;
+  if (hasAll(input)) return input.all;
+  throw new TypeError(
+    "allRoutes must be a finalized registry, RouteResource, or readonly leaf array."
+  );
+}
+
+// src/inspection/normalize-sockets.ts
+function normalizeSocketsInput(input) {
+  if (!input) return [];
+  if (Array.isArray(input)) {
+    return input.map((value, index) => ({ value, index }));
+  }
+  if (readNativeInspection(input)?.kind === "socket-runtime") {
+    return [{ value: input, index: 0 }];
+  }
+  if ("statsSnapshot" in input || "on" in input && typeof input.on === "function") {
+    return [{ value: input, index: 0 }];
+  }
+  return Object.entries(input).map(([registeredName, value], index) => ({
+    value,
+    registeredName,
+    index
+  }));
+}
+
+// src/snapshot/build.ts
+async function buildRRRoutesSnapshot(options, inspectOptions = {}) {
+  const diagnostics = new InspectionDiagnostics();
+  const leaves = normalizeRoutesInput(options.allRoutes);
+  const seen = /* @__PURE__ */ new Set();
+  for (const leaf of leaves) {
+    const routeKey = (0, import_rrroutes_contract5.routeKeyOf)(leaf.method, leaf.path);
+    if (seen.has(routeKey)) {
+      diagnostics.add({
+        code: "DUPLICATE_ROUTE_KEY",
+        severity: "error",
+        entity: { routeKey },
+        message: "Multiple contract leaves resolve to the same canonical method + path identity."
+      });
+    }
+    seen.add(routeKey);
+  }
+  const includeSource = inspectOptions.includeSource ?? options.source?.include ?? false;
+  const includeLive = inspectOptions.includeLive ?? false;
+  const [contract, clients, server, sockets] = await Promise.all([
+    inspectContractRoutes(leaves, options.source, includeSource),
+    Promise.resolve(
+      inspectClients(
+        normalizeClientsInput(options.endpointClient, options.allClients),
+        diagnostics
+      )
+    ),
+    Promise.resolve(inspectServer(options.server, diagnostics)),
+    Promise.resolve(
+      inspectSockets(
+        normalizeSocketsInput(options.sockets),
+        includeLive,
+        diagnostics
+      )
+    )
+  ]);
+  const diagnosticItems = diagnostics.list({
+    includeInfo: options.diagnostics?.includeInfo
+  });
+  const routes = joinRouteInspections({
+    contract: contract.routes,
+    clients: clients.byRoute,
+    server: server.byRoute,
+    servers: server.servers,
+    serverSupplied: Boolean(options.server),
+    diagnostics: diagnosticItems
+  });
+  diagnosticItems.sort((left, right) => left.code.localeCompare(right.code));
+  const snapshot = {
+    schemaVersion: 1,
+    meta: {
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      snapshotHash: "",
+      ...options.meta,
+      packageVersions: {},
+      sourceExtraction: contract.sourceExtraction
+    },
+    capabilities: {
+      contract: true,
+      client: Boolean(options.endpointClient || options.allClients),
+      server: Boolean(options.server),
+      socket: Boolean(options.sockets),
+      live: includeLive,
+      source: includeSource
+    },
+    routes,
+    clients: clients.clients,
+    servers: server.servers,
+    sockets,
+    diagnostics: diagnosticItems
+  };
+  snapshot.meta.snapshotHash = hashRRRoutesSnapshot(snapshot);
+  return snapshot;
+}
+
+// src/storage/memory.ts
+function clone(value) {
+  return structuredClone(value);
+}
+function createMemoryInspectionStorage() {
+  const checkpoints = /* @__PURE__ */ new Map();
+  const activeByScope = /* @__PURE__ */ new Map();
+  const changes = /* @__PURE__ */ new Map();
+  return {
+    checkpoints: {
+      async get(id) {
+        const value = checkpoints.get(id);
+        return value ? clone(value) : void 0;
+      },
+      async getActive(scope) {
+        const id = activeByScope.get(scope);
+        const value = id ? checkpoints.get(id) : void 0;
+        return value ? clone(value) : void 0;
+      },
+      async list(scope) {
+        return Array.from(checkpoints.values()).filter((checkpoint) => !scope || checkpoint.scope === scope).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).map(
+          (checkpoint) => ({
+            id: checkpoint.id,
+            scope: checkpoint.scope,
+            createdAt: checkpoint.createdAt,
+            updatedAt: checkpoint.updatedAt,
+            snapshotHash: checkpoint.snapshotHash,
+            trigger: clone(checkpoint.trigger),
+            expiresAt: checkpoint.expiresAt,
+            active: activeByScope.get(checkpoint.scope) === checkpoint.id
+          })
+        );
+      },
+      async save(checkpoint) {
+        checkpoints.set(checkpoint.id, clone(checkpoint));
+      },
+      async setActive(scope, checkpointId) {
+        const checkpoint = checkpoints.get(checkpointId);
+        if (!checkpoint || checkpoint.scope !== scope) {
+          throw new Error(
+            `Checkpoint ${checkpointId} does not belong to scope ${scope}.`
+          );
+        }
+        activeByScope.set(scope, checkpointId);
+      },
+      async delete(id) {
+        checkpoints.delete(id);
+        for (const [scope, activeId] of activeByScope) {
+          if (activeId === id) activeByScope.delete(scope);
+        }
+      }
+    },
+    changes: {
+      async get(id) {
+        const value = changes.get(id);
+        return value ? clone(value) : void 0;
+      },
+      async findByTransition(scope, fromHash, toHash) {
+        const value = Array.from(changes.values()).find(
+          (changeSet) => changeSet.scope === scope && changeSet.from.snapshotHash === fromHash && changeSet.to.snapshotHash === toHash
+        );
+        return value ? clone(value) : void 0;
+      },
+      async list(query = {}) {
+        const values = Array.from(changes.values()).filter(
+          (changeSet) => !query.scope || changeSet.scope === query.scope
+        ).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+        const selected = query.limit ? values.slice(0, query.limit) : values;
+        return selected.map((changeSet) => {
+          const { changes: _changes, ...summary } = changeSet;
+          return clone(summary);
+        });
+      },
+      async save(changeSet) {
+        changes.set(changeSet.id, clone(changeSet));
+      },
+      async delete(id) {
+        changes.delete(id);
+      }
+    }
+  };
+}
+
+// src/checkpoint/lock.ts
+var _tails;
+var ScopeLock = class {
+  constructor() {
+    __privateAdd(this, _tails, /* @__PURE__ */ new Map());
+  }
+  async run(scope, action) {
+    const previous = __privateGet(this, _tails).get(scope) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    __privateGet(this, _tails).set(scope, current);
+    await previous;
+    try {
+      return await action();
+    } finally {
+      release();
+      if (__privateGet(this, _tails).get(scope) === current) __privateGet(this, _tails).delete(scope);
+    }
+  }
+};
+_tails = new WeakMap();
+
+// src/checkpoint/retention.ts
+async function applyCheckpointRetention(args) {
+  if (!args.retention) return;
+  const summaries = await args.storage.checkpoints.list(args.scope);
+  const now = args.now ?? Date.now();
+  const deletions = /* @__PURE__ */ new Set();
+  if (args.retention.type === "duration" || args.retention.type === "combined") {
+    for (const checkpoint of summaries) {
+      if (checkpoint.id !== args.activeId && now - Date.parse(checkpoint.updatedAt) > args.retention.maximumAgeMs) {
+        deletions.add(checkpoint.id);
+      }
+    }
+  }
+  if (args.retention.type === "count" || args.retention.type === "combined") {
+    const retained = summaries.filter((item) => !deletions.has(item.id));
+    for (const checkpoint of retained.slice(args.retention.maximum)) {
+      if (checkpoint.id !== args.activeId) deletions.add(checkpoint.id);
+    }
+  }
+  await Promise.all(
+    Array.from(deletions).map((id) => args.storage.checkpoints.delete(id))
+  );
+}
+async function applyChangeSetRetention(args) {
+  if (args.retention.type === "forever" || !args.storage.changes.delete) return;
+  const summaries = await args.storage.changes.list({ scope: args.scope });
+  const now = args.now ?? Date.now();
+  const deletions = args.retention.type === "count" ? summaries.slice(args.retention.maximum) : (() => {
+    const maximumAgeMs = args.retention.maximumAgeMs;
+    return summaries.filter(
+      (item) => now - Date.parse(item.createdAt) > maximumAgeMs
+    );
+  })();
+  await Promise.all(
+    deletions.map((item) => args.storage.changes.delete(item.id))
+  );
+}
+
+// src/checkpoint/service.ts
+function createCheckpointService(options) {
+  const storage = options.storage ?? createMemoryInspectionStorage();
+  const lock = new ScopeLock();
+  const defaultScope = options.scope ?? "default";
+  const transaction = (operation) => storage.transaction ? storage.transaction(operation) : operation();
+  const createRecord = (scope, snapshot, trigger) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: hashCanonicalValue({
+        scope,
+        snapshotHash: snapshot.meta.snapshotHash,
+        now
+      }),
+      scope,
+      createdAt: now,
+      updatedAt: now,
+      snapshotHash: snapshot.meta.snapshotHash,
+      snapshot,
+      trigger
+    };
+  };
+  const service = {
+    async advance(input = {}) {
+      const scope = input.scope ?? defaultScope;
+      const trigger = input.trigger ?? { type: "manual" };
+      return lock.run(scope, () => transaction(async () => {
+        if (trigger.externalId) {
+          const priorSummary = (await storage.checkpoints.list(scope)).find(
+            (checkpoint2) => checkpoint2.trigger.externalId === trigger.externalId
+          );
+          if (priorSummary) {
+            const checkpoint2 = await storage.checkpoints.get(priorSummary.id);
+            if (checkpoint2) {
+              const changeSummary = (await storage.changes.list({ scope })).find(
+                (changeSet3) => changeSet3.trigger.externalId === trigger.externalId
+              );
+              const changeSet2 = changeSummary ? await storage.changes.get(changeSummary.id) : void 0;
+              return {
+                status: "idempotent_replay",
+                checkpoint: checkpoint2,
+                changeSet: changeSet2
+              };
+            }
+          }
+        }
+        const current = await options.inspect();
+        const active = await storage.checkpoints.getActive(scope);
+        if (!active) {
+          const checkpoint2 = createRecord(scope, current, trigger);
+          await storage.checkpoints.save(checkpoint2);
+          await storage.checkpoints.setActive(scope, checkpoint2.id);
+          return { status: "baseline_created", checkpoint: checkpoint2 };
+        }
+        if (active.snapshotHash === current.meta.snapshotHash) {
+          return { status: "no_changes", checkpoint: active };
+        }
+        const duplicate = await storage.changes.findByTransition(
+          scope,
+          active.snapshotHash,
+          current.meta.snapshotHash
+        );
+        const checkpoint = createRecord(scope, current, trigger);
+        const changeSet = duplicate ?? diffRRRoutesSnapshots(active.snapshot, current, {
+          scope,
+          trigger,
+          fromCheckpointId: active.id,
+          toCheckpointId: checkpoint.id
+        });
+        if (!duplicate) await storage.changes.save(changeSet);
+        await storage.checkpoints.save(checkpoint);
+        await storage.checkpoints.setActive(scope, checkpoint.id);
+        await applyCheckpointRetention({
+          storage,
+          scope,
+          activeId: checkpoint.id,
+          retention: options.retention
+        });
+        await applyChangeSetRetention({
+          storage,
+          scope,
+          retention: options.changeSetRetention ?? { type: "forever" }
+        });
+        return { status: "advanced", checkpoint, changeSet };
+      }));
+    },
+    async create(input = {}) {
+      const scope = input.scope ?? defaultScope;
+      const trigger = input.trigger ?? { type: "manual" };
+      return lock.run(scope, () => transaction(async () => {
+        const checkpoint = createRecord(scope, await options.inspect(), trigger);
+        await storage.checkpoints.save(checkpoint);
+        await storage.checkpoints.setActive(scope, checkpoint.id);
+        await applyCheckpointRetention({
+          storage,
+          scope,
+          activeId: checkpoint.id,
+          retention: options.retention
+        });
+        return checkpoint;
+      }));
+    },
+    get: (id) => storage.checkpoints.get(id),
+    getActive: (scope = defaultScope) => storage.checkpoints.getActive(scope),
+    list: (scope) => storage.checkpoints.list(scope),
+    async delete(id) {
+      const checkpoint = await storage.checkpoints.get(id);
+      if (!checkpoint) return;
+      const active = await storage.checkpoints.getActive(checkpoint.scope);
+      if (active?.id === id) {
+        throw new Error("The active checkpoint cannot be deleted.");
+      }
+      await storage.checkpoints.delete(id);
+    },
+    listChangeSets: (scope) => storage.changes.list({ scope }),
+    getChangeSet: (id) => storage.changes.get(id)
+  };
+  return service;
+}
+
+// src/storage/filesystem.ts
+var import_node_crypto3 = require("crypto");
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+function encodeSegment(value) {
+  return Buffer.from(value, "utf8").toString("base64url");
+}
+async function exists(file) {
+  try {
+    await import_promises4.default.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function atomicWriteJson(file, value) {
+  const directory = import_node_path7.default.dirname(file);
+  await import_promises4.default.mkdir(directory, { recursive: true });
+  const temporary = import_node_path7.default.join(
+    directory,
+    `.${import_node_path7.default.basename(file)}.${(0, import_node_crypto3.randomUUID)()}.tmp`
+  );
+  const handle = await import_promises4.default.open(temporary, "wx");
+  try {
+    await handle.writeFile(`${JSON.stringify(value, null, 2)}
+`, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await import_promises4.default.rename(temporary, file);
+  try {
+    const directoryHandle = await import_promises4.default.open(directory, "r");
+    try {
+      await directoryHandle.sync();
+    } finally {
+      await directoryHandle.close();
+    }
+  } catch {
+  }
+}
+async function readJson(file) {
+  try {
+    return JSON.parse(await import_promises4.default.readFile(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function listJsonFiles(directory) {
+  if (!await exists(directory)) return [];
+  const out = [];
+  const visit = async (current) => {
+    for (const entry of await import_promises4.default.readdir(current, { withFileTypes: true })) {
+      const resolved = import_node_path7.default.join(current, entry.name);
+      if (entry.isDirectory()) await visit(resolved);
+      else if (entry.isFile() && entry.name.endsWith(".json"))
+        out.push(resolved);
+    }
+  };
+  await visit(directory);
+  return out.sort();
+}
+function createFileSystemInspectionStorage(options) {
+  const root = import_node_path7.default.resolve(options.directory);
+  const checkpointRoot = import_node_path7.default.join(root, "checkpoints");
+  const changeRoot = import_node_path7.default.join(root, "changes");
+  const checkpointFile = (scope, id) => import_node_path7.default.join(
+    checkpointRoot,
+    encodeSegment(scope),
+    `checkpoint-${encodeSegment(id)}.json`
+  );
+  const activeFile = (scope) => import_node_path7.default.join(checkpointRoot, encodeSegment(scope), "active.json");
+  const changeFile = (changeSet) => {
+    const date = new Date(changeSet.createdAt);
+    const year = String(date.getUTCFullYear()).padStart(4, "0");
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    return import_node_path7.default.join(
+      changeRoot,
+      encodeSegment(changeSet.scope),
+      year,
+      month,
+      `${encodeSegment(changeSet.id)}.json`
+    );
+  };
+  const findCheckpoint = async (id) => {
+    const files = (await listJsonFiles(checkpointRoot)).filter(
+      (file) => import_node_path7.default.basename(file) !== "active.json"
+    );
+    for (const file of files) {
+      const checkpoint = await readJson(file);
+      if (checkpoint?.id === id) return checkpoint;
+    }
+    return void 0;
+  };
+  const findChangeSet = async (id) => {
+    for (const file of await listJsonFiles(changeRoot)) {
+      const changeSet = await readJson(file);
+      if (changeSet?.id === id) return changeSet;
+    }
+    return void 0;
+  };
+  return {
+    checkpoints: {
+      get: findCheckpoint,
+      async getActive(scope) {
+        const pointer = await readJson(
+          activeFile(scope)
+        );
+        return pointer ? findCheckpoint(pointer.checkpointId) : void 0;
+      },
+      async list(scope) {
+        const files = (await listJsonFiles(checkpointRoot)).filter(
+          (file) => import_node_path7.default.basename(file) !== "active.json"
+        );
+        const activeIds = /* @__PURE__ */ new Map();
+        const values = [];
+        for (const file of files) {
+          const checkpoint = await readJson(file);
+          if (!checkpoint || scope && checkpoint.scope !== scope) continue;
+          values.push(checkpoint);
+          if (!activeIds.has(checkpoint.scope)) {
+            const pointer = await readJson(
+              activeFile(checkpoint.scope)
+            );
+            if (pointer) activeIds.set(checkpoint.scope, pointer.checkpointId);
+          }
+        }
+        return values.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).map((checkpoint) => {
+          const { snapshot: _snapshot, ...summary } = checkpoint;
+          return {
+            ...summary,
+            active: activeIds.get(checkpoint.scope) === checkpoint.id
+          };
+        });
+      },
+      async save(checkpoint) {
+        await atomicWriteJson(
+          checkpointFile(checkpoint.scope, checkpoint.id),
+          checkpoint
+        );
+      },
+      async setActive(scope, checkpointId) {
+        const checkpoint = await findCheckpoint(checkpointId);
+        if (!checkpoint || checkpoint.scope !== scope) {
+          throw new Error(
+            `Checkpoint ${checkpointId} does not belong to scope ${scope}.`
+          );
+        }
+        await atomicWriteJson(activeFile(scope), { checkpointId });
+      },
+      async delete(id) {
+        const checkpoint = await findCheckpoint(id);
+        if (!checkpoint) return;
+        const file = checkpointFile(checkpoint.scope, checkpoint.id);
+        await import_promises4.default.unlink(file).catch((error) => {
+          if (error.code !== "ENOENT") throw error;
+        });
+      }
+    },
+    changes: {
+      get: findChangeSet,
+      async findByTransition(scope, fromHash, toHash) {
+        for (const file of await listJsonFiles(
+          import_node_path7.default.join(changeRoot, encodeSegment(scope))
+        )) {
+          const changeSet = await readJson(file);
+          if (changeSet?.scope === scope && changeSet.from.snapshotHash === fromHash && changeSet.to.snapshotHash === toHash) {
+            return changeSet;
+          }
+        }
+        return void 0;
+      },
+      async list(query = {}) {
+        const directory = query.scope ? import_node_path7.default.join(changeRoot, encodeSegment(query.scope)) : changeRoot;
+        const values = [];
+        for (const file of await listJsonFiles(directory)) {
+          const changeSet = await readJson(file);
+          if (changeSet && (!query.scope || changeSet.scope === query.scope)) {
+            values.push(changeSet);
+          }
+        }
+        const selected = values.sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, query.limit ?? values.length);
+        return selected.map((changeSet) => {
+          const { changes: _changes, ...summary } = changeSet;
+          return summary;
+        });
+      },
+      async save(changeSet) {
+        const existing = await this.findByTransition(
+          changeSet.scope,
+          changeSet.from.snapshotHash,
+          changeSet.to.snapshotHash
+        );
+        if (existing) return;
+        await atomicWriteJson(changeFile(changeSet), changeSet);
+      },
+      async delete(id) {
+        const changeSet = await findChangeSet(id);
+        if (!changeSet) return;
+        await import_promises4.default.unlink(changeFile(changeSet)).catch((error) => {
+          if (error.code !== "ENOENT") throw error;
+        });
+      }
+    }
+  };
+}
+
+// src/storage/sqlite.ts
+function readRow(row) {
+  if (!row || typeof row !== "object" || typeof row.json !== "string") {
+    return void 0;
+  }
+  return JSON.parse(row.json);
+}
+function readRows(rows) {
+  return Array.isArray(rows) ? rows.flatMap((row) => {
+    const value = readRow(row);
+    return value ? [value] : [];
+  }) : [];
+}
+function createSQLiteInspectionStorage(options) {
+  const database = options.database;
+  database.exec(`
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE IF NOT EXISTS rrroutes_checkpoints (
+      id TEXT PRIMARY KEY,
+      scope TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      json TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS rrroutes_checkpoints_scope_updated
+      ON rrroutes_checkpoints(scope, updated_at DESC);
+    CREATE TABLE IF NOT EXISTS rrroutes_active_checkpoints (
+      scope TEXT PRIMARY KEY,
+      checkpoint_id TEXT NOT NULL REFERENCES rrroutes_checkpoints(id)
+    );
+    CREATE TABLE IF NOT EXISTS rrroutes_change_sets (
+      id TEXT PRIMARY KEY,
+      scope TEXT NOT NULL,
+      from_hash TEXT NOT NULL,
+      to_hash TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      json TEXT NOT NULL,
+      UNIQUE(scope, from_hash, to_hash)
+    );
+    CREATE INDEX IF NOT EXISTS rrroutes_changes_scope_created
+      ON rrroutes_change_sets(scope, created_at DESC);
+  `);
+  const getCheckpoint = database.prepare(
+    "SELECT json FROM rrroutes_checkpoints WHERE id = ?"
+  );
+  const storage = {
+    async transaction(operation) {
+      database.exec("BEGIN IMMEDIATE");
+      try {
+        const result = await operation();
+        database.exec("COMMIT");
+        return result;
+      } catch (error) {
+        database.exec("ROLLBACK");
+        throw error;
+      }
+    },
+    checkpoints: {
+      async get(id) {
+        return readRow(getCheckpoint.get(id));
+      },
+      async getActive(scope) {
+        const statement = database.prepare(`
+          SELECT checkpoint.json AS json
+          FROM rrroutes_active_checkpoints active
+          JOIN rrroutes_checkpoints checkpoint ON checkpoint.id = active.checkpoint_id
+          WHERE active.scope = ?
+        `);
+        return readRow(statement.get(scope));
+      },
+      async list(scope) {
+        const rows = scope ? database.prepare(
+          "SELECT json FROM rrroutes_checkpoints WHERE scope = ? ORDER BY updated_at DESC"
+        ).all(scope) : database.prepare(
+          "SELECT json FROM rrroutes_checkpoints ORDER BY updated_at DESC"
+        ).all();
+        const activeRows = database.prepare(
+          "SELECT scope, checkpoint_id FROM rrroutes_active_checkpoints"
+        ).all();
+        const active = new Map(
+          Array.isArray(activeRows) ? activeRows.map((row) => [row.scope, row.checkpoint_id]) : []
+        );
+        return readRows(rows).map(
+          (checkpoint) => {
+            const { snapshot: _snapshot, ...summary } = checkpoint;
+            return {
+              ...summary,
+              active: active.get(checkpoint.scope) === checkpoint.id
+            };
+          }
+        );
+      },
+      async save(checkpoint) {
+        database.prepare(
+          `
+          INSERT INTO rrroutes_checkpoints(id, scope, updated_at, json)
+          VALUES (?, ?, ?, ?)
+          ON CONFLICT(id) DO UPDATE SET
+            scope = excluded.scope,
+            updated_at = excluded.updated_at,
+            json = excluded.json
+        `
+        ).run(
+          checkpoint.id,
+          checkpoint.scope,
+          checkpoint.updatedAt,
+          JSON.stringify(checkpoint)
+        );
+      },
+      async setActive(scope, checkpointId) {
+        const checkpoint = readRow(
+          getCheckpoint.get(checkpointId)
+        );
+        if (!checkpoint || checkpoint.scope !== scope) {
+          throw new Error(
+            `Checkpoint ${checkpointId} does not belong to scope ${scope}.`
+          );
+        }
+        database.prepare(
+          `
+          INSERT INTO rrroutes_active_checkpoints(scope, checkpoint_id)
+          VALUES (?, ?)
+          ON CONFLICT(scope) DO UPDATE SET checkpoint_id = excluded.checkpoint_id
+        `
+        ).run(scope, checkpointId);
+      },
+      async delete(id) {
+        database.prepare("DELETE FROM rrroutes_checkpoints WHERE id = ?").run(id);
+      }
+    },
+    changes: {
+      async get(id) {
+        return readRow(
+          database.prepare("SELECT json FROM rrroutes_change_sets WHERE id = ?").get(id)
+        );
+      },
+      async findByTransition(scope, fromHash, toHash) {
+        return readRow(
+          database.prepare(
+            `
+            SELECT json FROM rrroutes_change_sets
+            WHERE scope = ? AND from_hash = ? AND to_hash = ?
+          `
+          ).get(scope, fromHash, toHash)
+        );
+      },
+      async list(query = {}) {
+        const rows = query.scope ? database.prepare(
+          `
+              SELECT json FROM rrroutes_change_sets
+              WHERE scope = ? ORDER BY created_at DESC LIMIT ?
+            `
+        ).all(query.scope, query.limit ?? -1) : database.prepare(
+          `
+              SELECT json FROM rrroutes_change_sets
+              ORDER BY created_at DESC LIMIT ?
+            `
+        ).all(query.limit ?? -1);
+        return readRows(rows).map(
+          (changeSet) => {
+            const { changes: _changes, ...summary } = changeSet;
+            return summary;
+          }
+        );
+      },
+      async save(changeSet) {
+        database.prepare(
+          `
+          INSERT OR IGNORE INTO rrroutes_change_sets(
+            id, scope, from_hash, to_hash, created_at, json
+          ) VALUES (?, ?, ?, ?, ?, ?)
+        `
+        ).run(
+          changeSet.id,
+          changeSet.scope,
+          changeSet.from.snapshotHash,
+          changeSet.to.snapshotHash,
+          changeSet.createdAt,
+          JSON.stringify(changeSet)
+        );
+      },
+      async delete(id) {
+        database.prepare("DELETE FROM rrroutes_change_sets WHERE id = ?").run(id);
+      }
+    }
+  };
+  return storage;
+}
+
+// src/http/handler.ts
+function json(value, status = 200) {
+  return Response.json(value, {
+    status,
+    headers: {
+      "cache-control": "no-store, max-age=0",
+      "content-type": "application/json; charset=utf-8",
+      "x-content-type-options": "nosniff"
+    }
+  });
+}
+async function overview(snapshot, runtime) {
+  const routes = Object.values(snapshot.routes);
+  const clientBindings = Object.values(snapshot.clients).flatMap(
+    (client) => client.bindings
+  );
+  const [activeCheckpoint, latestChangeSet] = await Promise.all([
+    runtime.checkpoints.getActive(),
+    runtime.checkpoints.listChangeSets().then((items) => items[0])
+  ]);
+  return {
+    totalRoutes: routes.length,
+    contractOnlyRoutes: routes.filter(
+      (route) => route.clients.length === 0 && route.status.server !== "enabled"
+    ).length,
+    clientBoundRoutes: routes.filter((route) => route.clients.length > 0).length,
+    serverRegisteredRoutes: routes.filter((route) => route.server?.registered).length,
+    disabledServerRoutes: routes.filter(
+      (route) => route.server?.registered && !route.server.enabled
+    ).length,
+    routesMissingServerController: routes.filter(
+      (route) => route.status.server === "missing"
+    ).length,
+    clientBindings: clientBindings.length,
+    augments: clientBindings.reduce(
+      (total, binding) => total + binding.augments.length,
+      0
+    ),
+    routeSocketConnections: clientBindings.reduce(
+      (total, binding) => total + binding.socketConnections.length,
+      0
+    ),
+    socketContractEvents: Object.values(snapshot.sockets).reduce(
+      (total, socket) => total + Object.keys(socket.contract.events).length,
+      0
+    ),
+    serverBeforeMiddleware: routes.reduce(
+      (total, route) => total + (route.server?.before.length ?? 0),
+      0
+    ),
+    activeCheckpoint: activeCheckpoint ? {
+      id: activeCheckpoint.id,
+      scope: activeCheckpoint.scope,
+      snapshotHash: activeCheckpoint.snapshotHash,
+      updatedAt: activeCheckpoint.updatedAt
+    } : void 0,
+    latestChangeSet,
+    diagnostics: snapshot.diagnostics.length
+  };
+}
+async function readMutationBody(request, maximum) {
+  const contentLength = Number(request.headers.get("content-length") ?? "0");
+  if (contentLength > maximum) throw new Error("REQUEST_BODY_TOO_LARGE");
+  const text = await request.text();
+  if (new TextEncoder().encode(text).byteLength > maximum) {
+    throw new Error("REQUEST_BODY_TOO_LARGE");
+  }
+  if (!text) return {};
+  const value = JSON.parse(text);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("REQUEST_BODY_INVALID");
+  }
+  return value;
+}
+function createInspectorHttpHandler(runtime, options = {}) {
+  const mutationOptions = options.mutations;
+  const authorizeRead = async (request) => !options.authorize || await options.authorize({ request, action: "read" });
+  const authorizeMutation = async (request, action) => mutationOptions !== false && mutationOptions?.enabled === true && (!mutationOptions.authorize || await mutationOptions.authorize({ request, action }));
+  return async (request) => {
+    try {
+      if (!await authorizeRead(request)) {
+        return json(
+          { error: { code: "FORBIDDEN", message: "Access denied." } },
+          403
+        );
+      }
+      const url = new URL(request.url);
+      const pathname = url.pathname.replace(/\/$/, "") || "/";
+      const method = request.method.toUpperCase();
+      const snapshot = async () => runtime.inspect({ includeLive: options.includeLive ?? false });
+      if (method === "GET" && pathname === "/api/meta") {
+        const value = await snapshot();
+        return json({ meta: value.meta, capabilities: value.capabilities });
+      }
+      if (method === "GET" && pathname === "/api/snapshot")
+        return json(await snapshot());
+      if (method === "GET" && pathname === "/api/overview")
+        return json(await overview(await snapshot(), runtime));
+      if (method === "GET" && pathname === "/api/routes") {
+        return json(Object.values((await snapshot()).routes));
+      }
+      if (method === "GET" && pathname.startsWith("/api/routes/")) {
+        const routeKey = decodeURIComponent(
+          pathname.slice("/api/routes/".length)
+        );
+        const route = (await snapshot()).routes[routeKey];
+        return route ? json(route) : json(
+          { error: { code: "NOT_FOUND", message: "Route not found." } },
+          404
+        );
+      }
+      if (method === "GET" && pathname === "/api/clients") {
+        return json((await snapshot()).clients);
+      }
+      if (method === "GET" && pathname.startsWith("/api/clients/")) {
+        const id = decodeURIComponent(pathname.slice("/api/clients/".length));
+        const client = (await snapshot()).clients[id];
+        return client ? json(client) : json(
+          { error: { code: "NOT_FOUND", message: "Client not found." } },
+          404
+        );
+      }
+      if (method === "GET" && pathname === "/api/servers")
+        return json((await snapshot()).servers);
+      if (method === "GET" && pathname === "/api/sockets")
+        return json((await snapshot()).sockets);
+      if (method === "GET" && pathname === "/api/checkpoints")
+        return json(await runtime.checkpoints.list());
+      if (method === "GET" && pathname === "/api/changes")
+        return json(await runtime.checkpoints.listChangeSets());
+      if (method === "GET" && pathname.startsWith("/api/changes/")) {
+        const id = decodeURIComponent(pathname.slice("/api/changes/".length));
+        const changeSet = await runtime.checkpoints.getChangeSet(id);
+        return changeSet ? json(changeSet) : json(
+          {
+            error: { code: "NOT_FOUND", message: "Change set not found." }
+          },
+          404
+        );
+      }
+      if (method === "POST" && pathname === "/api/checkpoints") {
+        if (!await authorizeMutation(request, "checkpoint.create")) {
+          return json(
+            {
+              error: {
+                code: "MUTATIONS_DISABLED",
+                message: "Inspector mutations are disabled."
+              }
+            },
+            403
+          );
+        }
+        const body = await readMutationBody(
+          request,
+          options.maxMutationBodyBytes ?? 16384
+        );
+        return json(
+          await runtime.checkpoints.create({
+            scope: typeof body.scope === "string" ? body.scope : void 0,
+            trigger: body.trigger
+          }),
+          201
+        );
+      }
+      if (method === "POST" && pathname === "/api/checkpoints/advance") {
+        if (!await authorizeMutation(request, "checkpoint.advance")) {
+          return json(
+            {
+              error: {
+                code: "MUTATIONS_DISABLED",
+                message: "Inspector mutations are disabled."
+              }
+            },
+            403
+          );
+        }
+        const body = await readMutationBody(
+          request,
+          options.maxMutationBodyBytes ?? 16384
+        );
+        const idempotencyKey = request.headers.get("idempotency-key") ?? void 0;
+        const trigger = body.trigger && typeof body.trigger === "object" ? {
+          ...body.trigger,
+          externalId: body.trigger.externalId ?? idempotencyKey
+        } : { type: "api", externalId: idempotencyKey };
+        return json(
+          await runtime.checkpoints.advance({
+            scope: typeof body.scope === "string" ? body.scope : void 0,
+            trigger
+          })
+        );
+      }
+      if (method === "DELETE" && pathname.startsWith("/api/checkpoints/")) {
+        if (!await authorizeMutation(request, "checkpoint.delete")) {
+          return json(
+            {
+              error: {
+                code: "MUTATIONS_DISABLED",
+                message: "Inspector mutations are disabled."
+              }
+            },
+            403
+          );
+        }
+        const id = decodeURIComponent(
+          pathname.slice("/api/checkpoints/".length)
+        );
+        await runtime.checkpoints.delete(id);
+        return new Response(null, {
+          status: 204,
+          headers: { "cache-control": "no-store" }
+        });
+      }
+      return json(
+        {
+          error: {
+            code: "NOT_FOUND",
+            message: "Inspector endpoint not found."
+          }
+        },
+        404
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message === "REQUEST_BODY_TOO_LARGE") {
+        return json(
+          {
+            error: {
+              code: message,
+              message: "Mutation body exceeds the configured limit."
+            }
+          },
+          413
+        );
+      }
+      if (message === "REQUEST_BODY_INVALID" || error instanceof SyntaxError) {
+        return json(
+          {
+            error: {
+              code: "REQUEST_BODY_INVALID",
+              message: "Mutation body must be a JSON object."
+            }
+          },
+          400
+        );
+      }
+      return json({ error: { code: "INSPECTOR_ERROR", message } }, 500);
+    }
+  };
+}
+
+// src/adapters/express.ts
+var import_node_module = require("module");
+function loadExpress() {
+  const require2 = (0, import_node_module.createRequire)(`${process.cwd()}/package.json`);
+  const loaded = require2("express");
+  return "default" in loaded ? loaded.default : loaded;
+}
+function createExpressRouter(options) {
+  const express = loadExpress();
+  const router = express.Router();
+  const limit = options.maxMutationBodyBytes ?? 16384;
+  router.use(express.json({ limit }));
+  const handler = createInspectorHttpHandler(options.runtime, options);
+  const bridge = async (req, res, next) => {
+    try {
+      const headers = new Headers();
+      for (const [name, raw] of Object.entries(req.headers)) {
+        if (Array.isArray(raw))
+          raw.forEach((value) => headers.append(name, value));
+        else if (raw !== void 0) headers.set(name, raw);
+      }
+      const method = req.method.toUpperCase();
+      const body = method === "GET" || method === "HEAD" || req.body === void 0 ? void 0 : JSON.stringify(req.body);
+      const request = new Request(`http://rrroutes.local${req.url}`, {
+        method,
+        headers,
+        body
+      });
+      const response = await handler(request);
+      response.headers.forEach((value, name) => res.setHeader(name, value));
+      res.status(response.status);
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      res.send(Buffer.from(bytes));
+    } catch (error) {
+      next(error);
+    }
+  };
+  router.use(bridge);
+  return router;
+}
+
+// src/files/write.ts
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+async function writeJson(file, value) {
+  const resolved = import_node_path8.default.resolve(file);
+  await import_promises5.default.mkdir(import_node_path8.default.dirname(resolved), { recursive: true });
+  await import_promises5.default.writeFile(resolved, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function writeRRRoutesSnapshot(snapshot, options) {
+  await writeJson(options.outFile, snapshot);
+}
+async function writeRRRoutesChangeSet(changeSet, options) {
+  await writeJson(options.outFile, changeSet);
+}
+
+// src/runtime.ts
+function createRRRoutesExportRuntime(options) {
+  const inspect = (inspectOptions) => buildRRRoutesSnapshot(options, inspectOptions);
+  const checkpoints = createCheckpointService({
+    inspect: () => inspect({ includeLive: false }),
+    storage: options.storage,
+    scope: options.checkpoints?.scope,
+    retention: options.checkpoints?.retention,
+    changeSetRetention: options.checkpoints?.changeSetRetention
+  });
+  const runtime = {
+    inspect,
+    async diff(before, after, diffOptions) {
+      return diffRRRoutesSnapshots(
+        before,
+        after ?? await inspect(),
+        diffOptions
+      );
+    },
+    checkpoints,
+    createHttpHandler(httpOptions) {
+      return createInspectorHttpHandler(runtime, httpOptions);
+    },
+    createExpressRouter(expressOptions = {}) {
+      return createExpressRouter({ runtime, ...expressOptions });
+    },
+    async writeSnapshot(writeOptions) {
+      const snapshot = await inspect();
+      await writeRRRoutesSnapshot(snapshot, writeOptions);
+      return snapshot;
+    },
+    writeChangeSet
+  };
+  return runtime;
+}
+async function writeChangeSet(changeSet, writeOptions) {
+  await writeRRRoutesChangeSet(changeSet, writeOptions);
+}
+
+// src/cli/runtime.ts
+var import_node_path9 = __toESM(require("path"), 1);
+var import_node_url3 = require("url");
+function parseCliFlags(argv) {
+  const flags = /* @__PURE__ */ new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const flag = argv[index];
+    if (!flag?.startsWith("--")) continue;
+    const value = argv[index + 1];
+    if (!value || value.startsWith("--")) {
+      flags.set(flag, "true");
+      continue;
+    }
+    flags.set(flag, value);
+    index += 1;
+  }
+  return flags;
+}
+async function loadExportRuntime(args) {
+  const resolved = import_node_path9.default.resolve(args.modulePath);
+  const module2 = await import((0, import_node_url3.pathToFileURL)(resolved).href);
+  const exportName = args.exportName ?? "rrroutesExport";
+  const value = module2[exportName] ?? module2.default?.[exportName];
+  if (!value || typeof value.inspect !== "function" || !value.checkpoints) {
+    throw new Error(
+      `Export "${exportName}" in ${resolved} is not an RRRoutes export runtime.`
+    );
+  }
+  return value;
+}
+function requiredFlag(flags, name) {
+  const value = flags.get(name);
+  if (!value || value === "true")
+    throw new Error(`Missing required ${name} argument.`);
+  return value;
+}
+
+// src/cli/snapshot.ts
+var import_node_path10 = __toESM(require("path"), 1);
+async function runSnapshotCli(argv) {
+  const flags = parseCliFlags(argv);
+  const runtime = await loadExportRuntime({
+    modulePath: requiredFlag(flags, "--module"),
+    exportName: flags.get("--export")
+  });
+  const outFile = flags.get("--out") ?? "rrroutes.snapshot.json";
+  const snapshot = await runtime.writeSnapshot({ outFile });
+  return { snapshot, outFile: import_node_path10.default.resolve(outFile) };
+}
+
+// src/cli/changes.ts
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+async function runChangesCli(argv) {
+  const flags = parseCliFlags(argv);
+  const runtime = await loadExportRuntime({
+    modulePath: requiredFlag(flags, "--module"),
+    exportName: flags.get("--export")
+  });
+  const beforeFile = requiredFlag(flags, "--before");
+  const before = JSON.parse(
+    await import_promises6.default.readFile(import_node_path11.default.resolve(beforeFile), "utf8")
+  );
+  const changeSet = await runtime.diff(before, void 0, {
+    scope: flags.get("--scope"),
+    trigger: { type: "cli" }
+  });
+  const outFile = flags.get("--out") ?? "rrroutes.changes.json";
+  await runtime.writeChangeSet(changeSet, { outFile });
+  return { changeSet, outFile: import_node_path11.default.resolve(outFile) };
+}
+
+// src/cli/checkpoint.ts
+async function runCheckpointCli(argv) {
+  const [action = "advance", ...rest] = argv;
+  const flags = parseCliFlags(rest);
+  const runtime = await loadExportRuntime({
+    modulePath: requiredFlag(flags, "--module"),
+    exportName: flags.get("--export")
+  });
+  const scope = flags.get("--scope");
+  if (action === "advance") {
+    return runtime.checkpoints.advance({ scope, trigger: { type: "cli" } });
+  }
+  if (action === "create") {
+    return runtime.checkpoints.create({ scope, trigger: { type: "cli" } });
+  }
+  throw new Error(`Unsupported checkpoint action: ${action}`);
+}
+
+// src/cli/serve.ts
+var import_node_module2 = require("module");
+async function runInspectorServeCli(argv) {
+  const loaded = (0, import_node_module2.createRequire)(`${process.cwd()}/package.json`)("express");
+  const express = "default" in loaded ? loaded.default : loaded;
+  const flags = parseCliFlags(argv);
+  const runtime = await loadExportRuntime({
+    modulePath: requiredFlag(flags, "--module"),
+    exportName: flags.get("--export")
+  });
+  const port = Number(flags.get("--port") ?? "4310");
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("--port must be an integer between 1 and 65535.");
+  }
+  const app = express();
+  app.use("/", runtime.createExpressRouter());
+  const server = await new Promise((resolve) => {
+    const listening = app.listen(port, () => resolve(listening));
+  });
+  return { app, server, port };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_VIEWER_TEMPLATE,
+  RRROUTES_BAKED_PAYLOAD_MARKER,
   __private,
+  applyChangeSetRetention,
+  applyCheckpointRetention,
   buildFinalizedLeavesViewerBundle,
+  buildRRRoutesSnapshot,
+  canonicalSnapshotStructure,
+  canonicalizeJson,
   clearSchemaIntrospectionHandlers,
+  createBakedInspectorPayload,
+  createCheckpointService,
+  createExpressRouter,
+  createFileSystemInspectionStorage,
+  createInspectorHttpHandler,
+  createMemoryInspectionStorage,
+  createRRRoutesExportRuntime,
+  createSQLiteInspectionStorage,
   createSchemaIntrospector,
+  createSnapshotChangeSet,
+  diffRRRoutesSnapshots,
+  escapeBakedPayload,
   exportFinalizedLeaves,
   exportFinalizedLeavesChangelog,
   extractLeafSourceByAst,
   flattenLeafSchemas,
   flattenSerializableSchema,
+  hashCanonicalValue,
+  hashRRRoutesSnapshot,
+  injectBakedInspectorPayload,
   introspectSchema,
+  loadExportRuntime,
   loadFinalizedLeavesInput,
+  parseCliFlags,
   parseFinalizedLeavesChangelogCliArgs,
   parseFinalizedLeavesCliArgs,
   registerSchemaIntrospectionHandler,
+  requiredFlag,
+  runChangesCli,
+  runCheckpointCli,
   runExportFinalizedLeavesChangelogCli,
   runExportFinalizedLeavesCli,
+  runInspectorServeCli,
+  runSnapshotCli,
   serializableSchemaKinds,
   serializeLeafContract,
   serializeLeavesContract,
+  stableStringify,
   writeFinalizedLeavesChangelogExport,
   writeFinalizedLeavesExport,
-  writeFinalizedLeavesViewerBundle
+  writeFinalizedLeavesViewerBundle,
+  writeRRRoutesChangeSet,
+  writeRRRoutesSnapshot
 });
 //# sourceMappingURL=index.cjs.map