autotel-eventcatalog 26.0.0 → 27.0.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 27.0.0
+
+### Minor Changes
+
+- 3926832: Draw the event catalog by what the runtime actually did, and bridge Effect logs.
+
+  **`autotel-eventcatalog`** gains a `map` command that renders the catalog topology as one self-contained HTML file, with every edge labelled by the evidence behind it:
+
+  ```bash
+  autotel-eventcatalog map --snapshot snap.json --catalog ./catalog --output map.html
+  ```
+
+  - **observed** — a real `track()` call crossed it, stroke weight scaled to volume
+  - **declared, never seen** — the catalog says it happens and this run never saw it
+  - **ran, not in the catalog** — it happened and nobody wrote it down
+  - **consumer asserted** — the event fired; its delivery is a claim from the catalog
+
+  Three modes: `static` (commit it and read it in a PR), `replay` (markers move at a rate drawn from observed counts), and `live` (`--live-url`, and a marker crosses an edge the moment that event fires). Motion is reserved for evidence, so a declared-but-never-seen edge stays still in every mode.
+
+  The map and the drift report pair a rename together as one finding, while still listing both sides. `buildLiveMap()` and `renderLiveMapHtml()` are exported for building your own view, and `normaliseEventId()` is now public so callers can match dotted `track()` names to PascalCase catalog ids the same way the drift report does. The live page is covered by browser tests (`pnpm test:browser`) driving the real artifact in Chromium.
+
+  **`autotel-subscribers`**: `ArchitectureSnapshotSubscriber` now records `sources` on each observation — one entry per distinct `(producer, channel)` pair, with that pair's own count and first/last-seen — so two services publishing the same event name each keep their own traffic. Additive and sorted, so existing readers are unaffected and a committed snapshot stays byte-stable.
+
+  **`autotel-effect`**: `layer()` now bridges logs as well as spans, from the same single call.
+
+  ```typescript
+  const AutotelEffect = layer({ serviceName: 'my-api' }); // spans + logs
+  ```
+
+  `Effect.log*` is emitted as an OpenTelemetry log record — reaching any OTLP log backend, autotel-devtools included — plus a trace-correlated structured line on stdout, so a log written inside `Effect.withSpan` carries that span's trace and span ids. `Effect.annotateLogs` values become attributes, and an `Error` or `Cause` is reported as `err` with its stack.
+
+  **Breaking:** `Effect.log*` previously went to Effect's console logger and stayed there. Pass `logs: false` to keep `layer()` bridging spans only, or an options object (`level`, `pretty`, `mergeWithExisting`, `console`) to configure the logger. `loggerLayer()` is exported for the case where something else owns the tracer.
+
+### Patch Changes
+
+- Updated dependencies [3926832]
+  - autotel-subscribers@56.1.0
+
 ## 26.0.0
 
 ### Patch Changes

package/README.md

@@ -13,13 +13,14 @@ the code actually does at runtime.
 > on what channel. This package reads that snapshot and compares it to
 > your catalog.
 
-Three tools:
+Four tools:
 
 | Command        | Mode      | What it does                                                                                                                                                                              |
 | -------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | **`drift`**    | read-only | Diffs the catalog against a snapshot. Reports findings as Markdown, JSON, or plain text. The PR check that catches "you added an event but forgot to document it."                        |
 | **`generate`** | write     | Scaffolds EventCatalog resources from a snapshot: services, events, channels, inferred JSON Schemas, and producer↔event↔channel relationships.                                            |
 | **`stamp`**    | write     | Writes a runtime evidence block (counts, last-seen, field paths) into each event's `index.mdx` between idempotent markers. Keeps the static catalog page reflecting production behaviour. |
+| **`map`**      | write     | Renders the catalog topology as one self-contained HTML file where every arrow says whether the runtime actually crossed it. Static, replay, or live.                                     |
 
 Both share inputs: an autotel snapshot JSON file and an EventCatalog
 directory. Both ship a versioned JSON summary you can gate CI on. The
@@ -34,7 +35,9 @@ To keep the scope tight:
   [`autotel-subscribers`'s `ArchitectureSnapshotSubscriber`](../autotel-subscribers).
   This package only consumes them.
 - **Does not run any web server or dashboard.** Live dashboards live in
-  example apps. This package is a CLI plus library plus action.
+  example apps. This package is a CLI plus library plus action. `map --mode live`
+  emits a page that _connects to_ an SSE endpoint you already serve; it does not
+  serve one.
 - **Does not infer drift contracts from payload samples during `drift`.**
   Field-path drift is set-difference on dotted paths. Type/value drift is
   checked only against declared schema constraints. (`generate` can scaffold
@@ -44,6 +47,106 @@ To keep the scope tight:
   the `stamp` command writes is between `<!-- autotel:stamp-start -->`
   and `<!-- autotel:stamp-end -->`. Outside those markers is yours.
 
+## `map`: the diagram that knows what ran
+
+A catalog diagram draws every arrow the same way. A relationship four teams
+believe in and one that has not carried a message since March look identical,
+and no amount of reading the picture tells you which is which.
+
+`map` renders the same topology with the snapshot joined in:
+
+```bash
+autotel-eventcatalog map \
+  --snapshot ./services/test/snapshot.json \
+  --catalog ./catalog \
+  --output ./catalog-map.html
+```
+
+```
+13 observed, 2 declared-but-never-seen, 2 undocumented, 5 asserted (mode: static)
+```
+
+One self-contained HTML file — no build step, no CDN, no dependencies — where:
+
+- **observed** — a real `track()` call crossed this edge. Stroke weight scales
+  with volume.
+- **declared, never seen** — the catalog says this happens; this run never saw
+  it. Drawn dashed and grey, and it never moves in any mode. **The stillness is
+  the finding.**
+- **ran, not in the catalog** — it happened and nobody wrote it down.
+- **consumer asserted** — see below.
+
+### Three modes, because motion is a claim
+
+| `--mode` | What moves                                                           | Use for                           |
+| -------- | -------------------------------------------------------------------- | --------------------------------- |
+| `static` | Nothing. Weight and dash carry the message.                          | Commit it; read it in a PR        |
+| `replay` | Markers cross observed edges at a rate drawn from the snapshot count | A file that shows relative volume |
+| `live`   | A marker crosses an edge when that event actually fires              | A wall screen, a demo             |
+
+```bash
+autotel-eventcatalog map --snapshot snap.json --catalog ./catalog \
+  --output map.html --mode live --live-url /events --live-event track
+```
+
+Live mode subscribes to an SSE endpoint you serve and keys each frame's `name`
+against the edges it belongs to. `--live-event` names the SSE event to listen
+for; the default is `message`, so a server that writes `event: track` needs it
+set or the page sits silently claiming to be live.
+
+### Telling a rename from two problems
+
+`normaliseEventId` absorbs case and `._-`, so `payment.succeeded` does not match
+a catalog `PaymentCaptured`. The drift report then shows two findings — one
+event observed but undocumented, one documented but never observed — that are
+really one event under two names. Reporting a rename as two unrelated problems
+is the fastest way for a team to stop believing the tool.
+
+`map` and `drift` both pair them up and say so:
+
+```
+## Possible renames
+
+- `recommendation.created` is probably `RecommendationGenerated` renamed
+  (83% similar) — rename one side, or document it as a new event.
+```
+
+Both findings stay listed. A suggestion is a question for a human, not a fact
+about the system: on the day a rename is _not_ what happened, one of those two
+findings is a real removal, and collapsing them would hide it.
+
+### Testing the live page
+
+`pnpm test` covers the model and the generated artifact. The page's own
+behaviour is covered separately, in Chromium:
+
+```bash
+pnpm test:browser
+```
+
+Those tests install a controllable `EventSource` before the page script runs,
+deliver exact frames, and read the resulting DOM — what a frame credits, what an
+unknown producer does to the counters, whether a never-seen edge stays still.
+Asserting on the emitted JavaScript instead would only prove the lines were
+typed, which is what let every live defect through.
+
+### The honesty rule
+
+Two things are kept apart on purpose:
+
+- **liveness** — catalog vs snapshot presence.
+- **evidence** — whether the runtime _could_ have seen it. A producer writes the
+  event, so `produces` and `publishes-to` edges carry `observed` evidence. **A
+  consumer edge is always `asserted`**, however busy the event is: a producer's
+  telemetry proves an event fired and can never prove anyone received it.
+  Asserted edges move with a _hollow_ marker.
+
+Collapsing those into one axis is how a diagram ends up implying it watched
+something it only read. `map` will not do that, and a unit test holds the line.
+
+Consumption becomes observable once consumers are instrumented too; until then
+the picture says which half it knows.
+
 ## Install
 
 ```bash

package/dist/cli.cjs

@@ -1,7 +1,8 @@
 
-const require_generate = require('./generate-C1vYn-_M.cjs');
+const require_map_html = require('./map-html-AxfF9V_g.cjs');
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
+node_path = require_map_html.__toESM(node_path, 1);
 let node_url = require("node:url");
 
 //#region src/cli.ts
@@ -29,7 +30,7 @@ function isRenderer(value) {
 	return typeof r.name === "string" && typeof r.description === "string" && typeof r.renderReport === "function" && typeof r.renderDelta === "function";
 }
 async function loadRendererModule(modulePath) {
-	const resolved = (0, node_path.resolve)(process.cwd(), modulePath);
+	const resolved = node_path.default.resolve(process.cwd(), modulePath);
 	let mod;
 	try {
 		mod = await import((0, node_url.pathToFileURL)(resolved).href);
@@ -43,7 +44,7 @@ async function loadRendererModule(modulePath) {
 		process.exit(2);
 	}
 	try {
-		require_generate.registerRenderer(candidate);
+		require_map_html.registerRenderer(candidate);
 	} catch (error) {
 		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
 		process.exit(2);
@@ -76,10 +77,11 @@ async function processRegisterRendererFlags(argv) {
 }
 function parseArgs(argv) {
 	const [command, ...rest] = argv;
-	if (command !== "drift" && command !== "stamp" && command !== "generate") {
+	if (command !== "drift" && command !== "stamp" && command !== "generate" && command !== "map") {
 		usage();
 		process.exit(2);
 	}
+	if (command === "map") return parseMapArgs(rest);
 	if (command === "generate") return parseGenerateArgs(rest);
 	if (command === "stamp") return parseStampArgs(rest);
 	return parseDriftArgs(rest);
@@ -125,8 +127,8 @@ function parseDriftArgs(rest) {
 			}
 			case "--format": {
 				const value = requireValue(rest, ++i, "--format");
-				if (!require_generate.getRenderer(value)) {
-					process.stderr.write(`Invalid --format value: ${value}. Available renderers: ${require_generate.listRendererNames().join(", ")}.\n`);
+				if (!require_map_html.getRenderer(value)) {
+					process.stderr.write(`Invalid --format value: ${value}. Available renderers: ${require_map_html.listRendererNames().join(", ")}.\n`);
 					process.exit(2);
 				}
 				format = value;
@@ -154,11 +156,11 @@ function parseDriftArgs(rest) {
 	}
 	return {
 		command: "drift",
-		snapshot: (0, node_path.resolve)(snapshot),
-		baseSnapshot: baseSnapshot ? (0, node_path.resolve)(baseSnapshot) : void 0,
-		catalog: (0, node_path.resolve)(catalog),
-		output: output ? (0, node_path.resolve)(output) : void 0,
-		summaryOutput: summaryOutput ? (0, node_path.resolve)(summaryOutput) : void 0,
+		snapshot: node_path.default.resolve(snapshot),
+		baseSnapshot: baseSnapshot ? node_path.default.resolve(baseSnapshot) : void 0,
+		catalog: node_path.default.resolve(catalog),
+		output: output ? node_path.default.resolve(output) : void 0,
+		summaryOutput: summaryOutput ? node_path.default.resolve(summaryOutput) : void 0,
 		failOnDrift,
 		policy,
 		format
@@ -206,11 +208,11 @@ function parseStampArgs(rest) {
 	}
 	return {
 		command: "stamp",
-		snapshot: (0, node_path.resolve)(snapshot),
-		catalog: (0, node_path.resolve)(catalog),
+		snapshot: node_path.default.resolve(snapshot),
+		catalog: node_path.default.resolve(catalog),
 		dryRun,
 		format,
-		summaryOutput: summaryOutput ? (0, node_path.resolve)(summaryOutput) : void 0
+		summaryOutput: summaryOutput ? node_path.default.resolve(summaryOutput) : void 0
 	};
 }
 function parseGenerateArgs(rest) {
@@ -263,13 +265,86 @@ function parseGenerateArgs(rest) {
 	}
 	return {
 		command: "generate",
-		snapshot: (0, node_path.resolve)(snapshot),
-		catalog: (0, node_path.resolve)(catalog),
+		snapshot: node_path.default.resolve(snapshot),
+		catalog: node_path.default.resolve(catalog),
 		dryRun,
 		edgesOnly,
 		version,
 		format,
-		summaryOutput: summaryOutput ? (0, node_path.resolve)(summaryOutput) : void 0
+		summaryOutput: summaryOutput ? node_path.default.resolve(summaryOutput) : void 0
+	};
+}
+function parseMapMode(value) {
+	if (value === "static" || value === "replay" || value === "live") return value;
+	process.stderr.write(`Invalid --mode: ${value}. Expected 'static' | 'replay' | 'live'.\n`);
+	process.exit(2);
+}
+function parseMapArgs(rest) {
+	let snapshot;
+	let catalog;
+	let output;
+	let mode = "static";
+	let liveUrl;
+	let liveEventName;
+	let title;
+	let summaryOutput;
+	for (let i = 0; i < rest.length; i++) {
+		const arg = rest[i];
+		switch (arg) {
+			case "--snapshot":
+				snapshot = requireValue(rest, ++i, "--snapshot");
+				break;
+			case "--catalog":
+				catalog = requireValue(rest, ++i, "--catalog");
+				break;
+			case "--output":
+				output = requireValue(rest, ++i, "--output");
+				break;
+			case "--mode":
+				mode = parseMapMode(requireValue(rest, ++i, "--mode"));
+				break;
+			case "--live-url":
+				liveUrl = requireValue(rest, ++i, "--live-url");
+				break;
+			case "--live-event":
+				liveEventName = requireValue(rest, ++i, "--live-event");
+				break;
+			case "--title":
+				title = requireValue(rest, ++i, "--title");
+				break;
+			case "--summary-output":
+				summaryOutput = requireValue(rest, ++i, "--summary-output");
+				break;
+			case "-h":
+			case "--help":
+				usage();
+				process.exit(0);
+				break;
+			default:
+				process.stderr.write(`Unknown argument: ${arg}\n`);
+				usage();
+				process.exit(2);
+		}
+	}
+	if (!snapshot || !catalog || !output) {
+		process.stderr.write("All of --snapshot, --catalog and --output are required for map.\n");
+		usage();
+		process.exit(2);
+	}
+	if (mode === "live" && !liveUrl) {
+		process.stderr.write("--mode live requires --live-url <sse endpoint>.\n");
+		process.exit(2);
+	}
+	return {
+		command: "map",
+		snapshot: node_path.default.resolve(snapshot),
+		catalog: node_path.default.resolve(catalog),
+		output: node_path.default.resolve(output),
+		mode,
+		liveUrl,
+		liveEventName,
+		title,
+		summaryOutput: summaryOutput ? node_path.default.resolve(summaryOutput) : void 0
 	};
 }
 function usage() {
@@ -278,6 +353,7 @@ function usage() {
 		"  autotel-eventcatalog drift --snapshot <path> --catalog <path> [options]",
 		"  autotel-eventcatalog stamp --snapshot <path> --catalog <path> [--dry-run]",
 		"  autotel-eventcatalog generate --snapshot <path> --catalog <path> [options]",
+		"  autotel-eventcatalog map --snapshot <path> --catalog <path> --output <path.html>",
 		"",
 		"Global options (any command):",
 		"  --register-renderer <module>  Dynamically import a Renderer (default export",
@@ -292,7 +368,7 @@ function usage() {
 		"  --output <path>          Write the report to this file",
 		"  --summary-output <path>  Write a machine-readable drift summary JSON file",
 		"  --policy <mode>          Drift fail policy: 'all' | 'new-only'",
-		`  --format <kind>          Output format: ${require_generate.listRendererNames().join(" | ")}`,
+		`  --format <kind>          Output format: ${require_map_html.listRendererNames().join(" | ")}`,
 		"  --fail-on-drift          Exit non-zero when policy marks drift as failing",
 		"",
 		"stamp options:",
@@ -311,24 +387,34 @@ function usage() {
 		"  --format <kind>          Output format: 'text' (default) | 'json'",
 		"  --summary-output <path>  Write a machine-readable generate summary JSON file",
 		"",
+		"map options:",
+		"  --snapshot <path>        Architecture snapshot JSON",
+		"  --catalog <path>         EventCatalog root",
+		"  --output <path>          Write the self-contained HTML map here",
+		"  --mode <kind>            'static' (default) | 'replay' | 'live'",
+		"  --live-url <url>         SSE endpoint of live events (required for live)",
+		"  --live-event <name>      SSE event name to listen for (default: 'message')",
+		"  --title <text>           Override the page title",
+		"  --summary-output <path>  Write the machine-readable live map JSON",
+		"",
 		"  -h, --help               Show this help",
 		""
 	].join("\n"));
 }
 async function runDrift(args) {
-	const headSnapshot = await require_generate.loadSnapshot(args.snapshot);
-	const catalog = await require_generate.readCatalogState(args.catalog);
-	const headReport = require_generate.diffCatalogAgainstSnapshot(headSnapshot, catalog);
-	const delta = args.baseSnapshot ? require_generate.compareDriftReports(require_generate.diffCatalogAgainstSnapshot(await require_generate.loadSnapshot(args.baseSnapshot), catalog), headReport) : void 0;
+	const headSnapshot = await require_map_html.loadSnapshot(args.snapshot);
+	const catalog = await require_map_html.readCatalogState(args.catalog);
+	const headReport = require_map_html.diffCatalogAgainstSnapshot(headSnapshot, catalog);
+	const delta = args.baseSnapshot ? require_map_html.compareDriftReports(require_map_html.diffCatalogAgainstSnapshot(await require_map_html.loadSnapshot(args.baseSnapshot), catalog), headReport) : void 0;
 	const effectivePolicy = args.policy ?? (delta ? "new-only" : "all");
-	const policyResult = effectivePolicy === "new-only" && delta ? require_generate.evaluatePolicy({
+	const policyResult = effectivePolicy === "new-only" && delta ? require_map_html.evaluatePolicy({
 		mode: "new-only",
 		delta
-	}) : require_generate.evaluatePolicy({
+	}) : require_map_html.evaluatePolicy({
 		mode: "all",
 		report: headReport
 	});
-	const renderer = require_generate.getRenderer(args.format);
+	const renderer = require_map_html.getRenderer(args.format);
 	if (!renderer) {
 		process.stderr.write(`Unknown renderer: ${args.format}\n`);
 		process.exit(2);
@@ -337,13 +423,13 @@ async function runDrift(args) {
 	process.stdout.write(output);
 	if (!output.endsWith("\n")) process.stdout.write("\n");
 	if (args.output) {
-		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(args.output), { recursive: true });
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(args.output), { recursive: true });
 		await (0, node_fs_promises.writeFile)(args.output, output, "utf8");
 		process.stderr.write(`\nWrote drift report: ${args.output}\n`);
 	}
 	const summary = buildSummary(effectivePolicy, headReport, delta, policyResult);
 	if (args.summaryOutput) {
-		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(args.summaryOutput), { recursive: true });
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(args.summaryOutput), { recursive: true });
 		await (0, node_fs_promises.writeFile)(args.summaryOutput, JSON.stringify(summary, null, 2), "utf8");
 		process.stderr.write(`Wrote drift summary: ${args.summaryOutput}\n`);
 	}
@@ -352,7 +438,7 @@ async function runDrift(args) {
 }
 const DRIFT_SUMMARY_SPEC = "autotel-eventcatalog-drift-summary/v0.2.0";
 function buildSummary(mode, headReport, delta, policyResult) {
-	const counts = mode === "new-only" && delta ? require_generate.countDriftEntries(delta.introduced) : require_generate.countDriftReport(headReport);
+	const counts = mode === "new-only" && delta ? require_map_html.countDriftEntries(delta.introduced) : require_map_html.countDriftReport(headReport);
 	return {
 		spec: DRIFT_SUMMARY_SPEC,
 		mode,
@@ -362,12 +448,12 @@ function buildSummary(mode, headReport, delta, policyResult) {
 	};
 }
 async function runStamp(args) {
-	const result = await require_generate.stampCatalog({
-		snapshot: await require_generate.loadSnapshot(args.snapshot),
+	const result = await require_map_html.stampCatalog({
+		snapshot: await require_map_html.loadSnapshot(args.snapshot),
 		catalogPath: args.catalog,
 		dryRun: args.dryRun
 	});
-	const summary = require_generate.buildStampSummary(result, args.dryRun);
+	const summary = require_map_html.buildStampSummary(result, args.dryRun);
 	if (args.format === "json") process.stdout.write(JSON.stringify({
 		summary,
 		updates: result.updates,
@@ -382,20 +468,20 @@ async function runStamp(args) {
 		process.stderr.write(`\n${summary.changedFiles} changed, ${summary.replaces} replaces, ${summary.inserts} inserts, ${summary.skipped} skipped${args.dryRun ? " (dry run)" : ""}\n`);
 	}
 	if (args.summaryOutput) {
-		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(args.summaryOutput), { recursive: true });
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(args.summaryOutput), { recursive: true });
 		await (0, node_fs_promises.writeFile)(args.summaryOutput, JSON.stringify(summary, null, 2), "utf8");
 		process.stderr.write(`Wrote stamp summary: ${args.summaryOutput}\n`);
 	}
 }
 async function runGenerate(args) {
-	const result = await require_generate.generateCatalogFromSnapshot({
-		snapshot: await require_generate.loadSnapshot(args.snapshot),
+	const result = await require_map_html.generateCatalogFromSnapshot({
+		snapshot: await require_map_html.loadSnapshot(args.snapshot),
 		catalogPath: args.catalog,
 		dryRun: args.dryRun,
 		edgesOnly: args.edgesOnly,
 		version: args.version
 	});
-	const summary = require_generate.buildGenerateSummary(result, {
+	const summary = require_map_html.buildGenerateSummary(result, {
 		dryRun: args.dryRun,
 		edgesOnly: args.edgesOnly
 	});
@@ -411,11 +497,29 @@ async function runGenerate(args) {
 		if (result.operations.length === 0) process.stdout.write("No generation operations needed.\n");
 	}
 	if (args.summaryOutput) {
-		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(args.summaryOutput), { recursive: true });
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(args.summaryOutput), { recursive: true });
 		await (0, node_fs_promises.writeFile)(args.summaryOutput, JSON.stringify(summary, null, 2), "utf8");
 		process.stderr.write(`Wrote generate summary: ${args.summaryOutput}\n`);
 	}
 }
+async function runMap(args) {
+	const [snapshot, catalog] = await Promise.all([require_map_html.loadSnapshot(args.snapshot), require_map_html.readCatalogState(args.catalog)]);
+	const map = require_map_html.buildLiveMap(snapshot, catalog);
+	const html = require_map_html.renderLiveMapHtml(map, {
+		mode: args.mode,
+		...args.liveUrl && { liveUrl: args.liveUrl },
+		...args.liveEventName && { liveEventName: args.liveEventName },
+		...args.title && { title: args.title }
+	});
+	await (0, node_fs_promises.mkdir)(node_path.default.dirname(args.output), { recursive: true });
+	await (0, node_fs_promises.writeFile)(args.output, html, "utf8");
+	if (args.summaryOutput) {
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(args.summaryOutput), { recursive: true });
+		await (0, node_fs_promises.writeFile)(args.summaryOutput, `${JSON.stringify(map, null, 2)}\n`, "utf8");
+	}
+	const s = map.summary;
+	process.stdout.write(`${args.output}\n${s.observedEdges} observed, ${s.declaredOnlyEdges} declared-but-never-seen, ${s.undocumentedEdges} undocumented, ${s.assertedEdges} asserted (mode: ${args.mode})\n`);
+}
 async function main() {
 	const args = parseArgs(await processRegisterRendererFlags(process.argv.slice(2)));
 	if (args.command === "stamp") {
@@ -426,6 +530,10 @@ async function main() {
 		await runGenerate(args);
 		return;
 	}
+	if (args.command === "map") {
+		await runMap(args);
+		return;
+	}
 	await runDrift(args);
 }
 main().catch((error) => {