@agent-surface/cli 0.15.0 → 0.16.0

package/README.md

@@ -1,187 +1,11 @@
-# @agent-surface/cli
+# `@agent-surface/cli`
 
-The agent surface your app exposes — from a terminal, and in CI. It answers three questions: *what can an agent do here right now*, *did that change without anyone noticing*, and *did we author something no scenario ever reaches*. Part of [agent-surface](https://github.com/Wiseair-srl/agent-surface).
-
-It is a developer tool: nothing it prints ever reaches a model.
-
-Docs: https://agent-surface-docs.vercel.app/20-cli
-
-## Install
+Compiles, snapshots and diffs the production capability contract.
 
 ```bash
-pnpm add -D @agent-surface/cli
-```
-
-## Configure
-
-A presentation surface only exists once components mount — it is a projection of *what is mounted × route × host context × consumer × policy × live `when()`*. So there is nothing static to read, and the CLI mounts your app. It does not re-implement it: the config points at the composition root you already have.
-
-```tsx
-// agent-surface.config.tsx
-import { defineSurface } from "@agent-surface/cli";
-import { agentManifest, createApp } from "./src/agent/setup.js";   // already exists
-import { App } from "./src/app/App.js";             // already exists
-
-export default defineSurface({
-  manifest: agentManifest,
-  mount: ({ user }) => {
-    const app = createApp({ environment: "test", user });
-    return { registry: app.registry, ui: <App app={app} />, app };
-  },
-  scenarios: {
-    admin:     { user: { id: "u_admin", permissions: ["devices:write"] } },
-    anonymous: { user: null },
-  },
-});
-```
-
-Loading goes through vite-node on your own `vite.config.*`, so your aliases, plugins and TSX resolve exactly as they do in dev.
-
-## Use
-
-```bash
-agent-surface init                  # read the codebase, then scaffold a config
-agent-surface inspect [scenario]    # what an agent can reach, and what it cannot
-agent-surface snapshot [scenario]   # write/refresh the committed baseline
-agent-surface check [scenario]      # fail drift, gaps, rejections, stale scenarios
-```
-
-Every command covers all scenarios in the config unless you name one. `inspect` prints each in turn:
-
-```text
-SURFACE INSPECT
-Config      agent-surface.config.tsx
-Depth       full — the source is read and every scenario is mounted
-Scope       whole surface — no component-type prefix filter
-Scenarios   1 of 2 — admin
-
-SURFACE SUMMARY
-Reach       11/11 authored capabilities reached
-Callable    9/11 mounted capabilities are callable in at least one scenario · 2 never callable
-Risk        1 destructive · 1 confirmation-gated · 1 with bound input
-Domain      1 capability reached against the authoritative oRPC manifest
-Catalog     every call site read
-Scenarios   1 mounted
-Verdict     every authored capability is reached by a scenario
-
-STATIC CATALOG
-STATUS        COMPLETE — every capability identity resolved
-Capabilities  11 authored (upper bound) · 10 resolved call sites
-Program       21 files analyzed · 40 agent-surface implementation files excluded
-Metadata      5 call sites partially read · identity remains resolved
-Domain        1 manifest capability
-
-scenario admin  route /devices
-9 callable, 2 visible-disabled, 0 hidden  ·  1 destructive, 1 confirmation-gated
-
-CAPABILITY                KIND         EFFECT       STATE     FLAGS
-app.navigation.goTo       action       navigation   callable  reversible
-devices.drawer.open       action       local-state  callable  reversible
-devices.drawer.close      action       local-state  disabled  reversible
-    ⤷ The drawer is not open
-devices.table.sort        action       local-state  callable  idempotent · reversible
-devices.disable           procedure    destructive  disabled  confirmation:required · deviceIds bound+locked
-    ⤷ Select at least one device first
+agent-surface inspect
+agent-surface snapshot
+agent-surface check --base origin/main --format github
 ```
 
-Summaries first, details after. The run header states what every number below it is relative to — the config, the depth, the scope, the scenarios — and prints before the mounts it will spend its time on. Each scenario's own table repeats the qualifier that is local to it: a surface is a projection of one mounted context, never "the app".
-
-`--detail` shows full capability, origin, and diagnostic detail; `--explain` and `--schemas` imply it.
-
-### Depth
-
-A presentation surface has two sources of truth, and `--depth` says how much of each to compute:
-
-| | reads the TypeScript program | mounts the scenarios | answers |
-|---|---|---|---|
-| `--depth static` | ✔ | — | what this codebase authors |
-| `--depth runtime` | — | ✔ | what a mounted scenario surfaces |
-| `--depth full` *(default)* | ✔ | ✔ | both, **and the difference between them** |
-
-`full` is the default because a tool that has to be asked for the complete answer mostly gives the incomplete one. `static` needs no scenarios and survives an app that will not mount; `runtime` skips the program boot on a repository wide enough to feel it.
-
-### Why is my capability missing?
-
-`snapshot()` bakes policy outcomes: a `hide` removes the capability *and* the reason, because the existence of a hidden capability is itself information. Correct at the agent boundary, useless when you are the developer. `--explain` answers it:
-
-```bash
-agent-surface inspect anonymous --explain
-```
-
-```text
-scenario anonymous  route /devices
-0 callable, 0 visible-disabled, 11 hidden
-
-hidden by policy (absent from the snapshot)  (11)
-  - set  [devices.filters@default]
-      Update one or both filters; omitted fields are unchanged.
-      policy authenticated (registry, discovery/authorize): hide
-```
-
-The hidden capabilities themselves print without the flag — signed out, that scenario shows eleven rows marked `hidden` rather than a bare `0 callable`. `--explain` adds the attribution: every policy in the chain, in the order it runs, with its own vote, the layer it came from, and whether its `onDiscovery` threw. Availability is reported apart from the policy votes — *authority hides, state discloses*, and the two failures must never look alike.
-
-### What did we author that no scenario reaches?
-
-A route nobody visits never registers, so it is in no snapshot and drifts against no baseline — invisible to a mount by construction. The static half reads the TypeScript program instead, and the difference is a first-class finding in **every** command:
-
-```text
-UNREACHED — authored, and no scenario mounts it  (1)
-CAPABILITY                ORIGIN
-view:cov.unmounted.toCsv  Unmounted.tsx:26
-  → add a scenario that mounts them, delete the dead component, or record the decision in
-    .agent-surface/coverage-allow.json
-```
-
-`check` says the same thing as a report — a verdict, the health matrix behind it, one row per scenario, then the findings and the commands that clear them:
-
-```text
-SURFACE CHECK  FAIL
-Config             agent-surface.config.tsx
-Depth              full — the source is read and every scenario is mounted
-Scope              whole surface — no component-type prefix filter
-
-Coverage    FAIL   2/3 authored capabilities reached · 1 unreached
-Catalog     PASS   all static sites resolved
-Domain      PASS   1 manifest capability reached
-Baselines   FAIL   1/2 scenario baselines current
-Runtime     PASS   2 scenarios mounted
-
-SCENARIOS  (2)
-SCENARIO   ROUTE     CALLABLE  DISABLED  HIDDEN  REJECTED  BASELINE
-admin      /devices  9         2         0       —         drift (1)
-anonymous  /devices  0         0         11      —         current
-```
-
-`inspect` reports it and `snapshot` reports it; **`check` fails on it**. It also fails on an unread call site, because the catalog is `unreached`'s denominator and holes in it make that count a floor rather than an answer — pass `--allow-unresolved` to accept that knowingly, which still prints the gap. Adoption ratchets through a committed `.agent-surface/coverage-allow.json`, whose stale entries fail the command.
-
-If any scenario fails to mount there is **no verdict at all**: that scenario reached nothing, so everything it would have surfaced would read as unreached. The failed scenarios are named instead, and the static half still prints.
-
-### Exit codes
-
-**0** clean · **1** a finding · **2** the command could not run.
-
-`inspect` never exits `1` — it reports, and `check` gates. CI has to be able to tell "the surface changed" from "the tool never loaded the app", because the second one passing silently is how a gate rots.
-
-> Upgrading from 0.10? `capabilities` is now `inspect --depth static`, and `coverage` is folded into `inspect` and `check`. Both were removed rather than aliased; naming either still prints where its answer went.
-
-### The scenarios are not a fixture
-
-The same definitions drive your test suite, so "admin on /devices" exists once rather than twice:
-
-```ts
-import config from "../agent-surface.config.js";
-import { mountScenario } from "@agent-surface/cli/vitest";
-
-const { surface, app } = await mountScenario(config, "admin");
-expect(surface).toExpose("view:devices.filters.set");
-```
-
-## Notes
-
-Requires `@testing-library/react` and `react-dom` (peers) — anything that mounts does so in jsdom, so anything needing a real browser is out of reach by construction. `--depth static` and `init` mount nothing at all, and install no DOM.
-
-Output falls back to plain text when piped, or under `--plain`, `CI` and `NO_COLOR`. stdout carries the command's output and nothing else; diagnostics go to stderr.
-
-Full specification: [docs/20](https://github.com/Wiseair-srl/agent-surface/blob/main/docs/20-cli.md).
-
-MIT © Wiseair S.r.l.
+No scenarios, app mounts, static heuristics or allowlists. See [CLI docs](../../docs/20-cli.md).

package/dist/bin.js

@@ -1,99 +1,167 @@
 #!/usr/bin/env node
 import {
-  DEPTHS,
-  findConfig,
-  isDepth,
-  renderReportPlain,
-  write,
-  writeError
-} from "./chunk-GYYWHZPM.js";
-import "./chunk-NFK3XWWH.js";
+  DEFAULT_SNAPSHOT,
+  readBaseManifest,
+  readManifest,
+  renderReport,
+  writeManifest
+} from "./chunk-X6RGGBQ4.js";
+import {
+  diffContracts
+} from "./chunk-IA7FUP4R.js";
 
 // src/bin.ts
 import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
 import { parseArgs } from "util";
 
-// src/dom.ts
-import { JSDOM } from "jsdom";
-var DOM_EVENT_GLOBALS = ["Event", "CustomEvent"];
-function alignEventRealm(globals, window) {
-  for (const key of DOM_EVENT_GLOBALS) {
-    if (typeof window[key] !== "function") continue;
-    Object.defineProperty(globals, key, {
-      value: window[key],
-      writable: true,
-      configurable: true
-    });
+// src/commands.ts
+import { resolve } from "path";
+import {
+  compileCapabilityContract,
+  computeManifestHash
+} from "@agent-surface/compiler";
+function mergeManifests(manifests) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    for (const entry of manifest.capabilities) {
+      const key = `${entry.declarationId}\0${entry.capabilityId}`;
+      const existing = entries.get(key);
+      if (!existing) entries.set(key, { ...entry, targets: [...entry.targets] });
+      else {
+        if (existing.contractHash !== entry.contractHash) {
+          throw new Error(`contract ${entry.declarationId} / ${entry.capabilityId} differs across targets`);
+        }
+        existing.targets = [.../* @__PURE__ */ new Set([...existing.targets, ...entry.targets])].sort();
+      }
+    }
   }
+  const payload = {
+    formatVersion: 3,
+    compilerVersion: manifests[0]?.compilerVersion ?? "unknown",
+    targets: [...new Set(manifests.flatMap((manifest) => manifest.targets))].sort(),
+    capabilities: [...entries.values()].sort(
+      (a, b) => `${a.declarationId}\0${a.capabilityId}`.localeCompare(`${b.declarationId}\0${b.capabilityId}`)
+    ),
+    externalContracts: manifests.flatMap((manifest) => manifest.externalContracts).filter((entry, index, all) => all.findIndex((candidate) => candidate.digest === entry.digest) === index).sort((a, b) => a.source.localeCompare(b.source)),
+    completeness: { status: "proven" }
+  };
+  return { ...payload, hash: computeManifestHash(payload) };
 }
-function installDom(url = "http://localhost/") {
-  const globals = globalThis;
-  if (typeof globals["document"] !== "undefined") {
-    const installedWindow = globals["window"];
-    if (installedWindow && typeof installedWindow === "object") {
-      alignEventRealm(globals, installedWindow);
-    }
+async function compile(options) {
+  const targets = options.targets.length > 0 ? options.targets : ["web-production"];
+  const manifests = await Promise.all(
+    targets.map(
+      (target) => compileCapabilityContract({
+        root: options.root,
+        ...options.configFile ? { configFile: options.configFile } : {},
+        target
+      })
+    )
+  );
+  return mergeManifests(manifests);
+}
+function shouldFail(policy, changes) {
+  if (policy === "none") return false;
+  if (policy === "all") return changes.length > 0;
+  return changes.some((change) => change.classification === policy);
+}
+async function present(report, options) {
+  const interactive = options.format === "human" && !options.plain && process.stdout.isTTY === true && !process.env["CI"] && !process.env["NO_COLOR"];
+  if (interactive) {
+    const { renderInk } = await import("./ink-E6DATMUQ.js");
+    await renderInk(report);
     return;
   }
-  const dom = new JSDOM("<!doctype html><html><body></body></html>", {
-    url,
-    pretendToBeVisual: true
-  });
-  const { window } = dom;
-  for (const key of Object.getOwnPropertyNames(window)) {
-    if (key.startsWith("_")) continue;
-    if (key in globals) continue;
-    const descriptor = Object.getOwnPropertyDescriptor(window, key);
-    if (!descriptor) continue;
-    Object.defineProperty(globals, key, descriptor);
-  }
-  for (const key of ["window", "document", "navigator"]) {
-    if (!(key in globals)) {
-      Object.defineProperty(globals, key, { value: window[key], configurable: true });
-    }
-  }
-  alignEventRealm(globals, window);
+  process.stdout.write(renderReport(report, options.format));
+}
+async function runInspect(options) {
+  const manifest = await compile(options);
+  const snapshotPath = resolve(options.root, options.snapshot ?? DEFAULT_SNAPSHOT);
+  const snapshot = readManifest(snapshotPath);
+  const integrityChanges = diffContracts(snapshot, manifest);
+  const report = {
+    command: "inspect",
+    status: "view",
+    manifest,
+    snapshotPath,
+    integrity: {
+      status: !snapshot ? "missing" : snapshot.hash === manifest.hash ? "current" : "stale",
+      changes: integrityChanges
+    },
+    ...options.base ? {
+      pullRequest: {
+        base: options.base,
+        changes: diffContracts(readBaseManifest(options.base, snapshotPath, options.root), manifest)
+      }
+    } : {}
+  };
+  await present(report, options);
+  return 0;
+}
+async function runSnapshot(options) {
+  const manifest = await compile(options);
+  const snapshotPath = resolve(options.root, options.snapshot ?? DEFAULT_SNAPSHOT);
+  writeManifest(snapshotPath, manifest);
+  await present({ command: "snapshot", status: "written", manifest, snapshotPath }, options);
+  return 0;
+}
+async function runCheck(options) {
+  const manifest = await compile(options);
+  const snapshotPath = resolve(options.root, options.snapshot ?? DEFAULT_SNAPSHOT);
+  const snapshot = readManifest(snapshotPath);
+  const integrityChanges = diffContracts(snapshot, manifest);
+  const integrityCurrent = snapshot?.hash === manifest.hash;
+  const pr = options.base ? {
+    base: options.base,
+    changes: diffContracts(readBaseManifest(options.base, snapshotPath, options.root), snapshot ?? manifest)
+  } : void 0;
+  const failed = !integrityCurrent || (pr ? shouldFail(options.policy, pr.changes) : false);
+  const report = {
+    command: "check",
+    status: failed ? "fail" : "pass",
+    manifest,
+    snapshotPath,
+    integrity: {
+      status: !snapshot ? "missing" : integrityCurrent ? "current" : "stale",
+      changes: integrityChanges
+    },
+    ...pr ? { pullRequest: pr } : {}
+  };
+  await present(report, options);
+  return failed ? 1 : 0;
 }
 
 // src/bin.ts
-var USAGE = `agent-surface \u2014 the agent surface your app exposes
+var USAGE = `agent-surface \u2014 compiled production capability contract
 
 Usage
-  agent-surface init                     read the codebase, then scaffold a config
-  agent-surface inspect    [scenario]    what an agent can reach, and what it cannot
-  agent-surface snapshot   [scenario]    write/refresh the committed baseline
-  agent-surface check      [scenario]    fail on drift, or on a capability no scenario reaches
-
-Every command covers all scenarios in the config unless you name one.
-
-Depth
-  --depth full          read the source AND mount the scenarios, and report the gap (default)
-  --depth static        read the source only \u2014 no Vite, no jsdom, no mount, no scenarios needed
-  --depth runtime       mount only \u2014 skip the TypeScript program on a repo wide enough to feel it
+  agent-surface inspect
+  agent-surface snapshot
+  agent-surface check --base origin/main --format github
 
 Options
-  --config <path>       path to agent-surface.config.* (default: nearest, searching upward)
-  --baseline-dir        where baselines live (default: .agent-surface next to the config)
-  --scope <prefix>      restrict to a component-type prefix (repeatable)
-  --detail              full capability, origin, and diagnostic detail
-  --explain             name the policies behind every decision (implies --detail)
-  --schemas             include input/output JSON Schemas (implies --detail)
-  --tsconfig <path>     tsconfig the source read uses (default: nearest to the config)
-  --allow-unresolved    check: do not fail on a call site that could not be read
-  --yes                 init: write without asking
-  --json                emit data instead of a rendered view
-  --plain               force plain text (implied when piped, or under CI / NO_COLOR)
-  -h, --help            show this
-  -v, --version         print the version
+  --root <path>       application root (default: cwd)
+  --config <path>     Vite config, relative to root
+  --snapshot <path>   committed contract (default: .agent-surface/contract.json)
+  --target <name>     production build target; repeatable
+  --base <git-ref>    render committed PR drift against Git base
+  --policy <mode>     all | widening | narrowing | neutral | none (default: all)
+  --format <format>   human | json | github | markdown (default: human)
+  --json              alias for --format json
+  --plain             disable Ink terminal rendering
+  -h, --help
+  -v, --version
 
-Exit codes are the contract: 0 clean, 1 a finding, 2 the command could not run.
+Exit: 0 clean/viewed, 1 deterministic drift/policy finding, 2 completeness failure.
 `;
-var COMMANDS = ["init", "inspect", "snapshot", "check"];
-var RETIRED = {
-  capabilities: "agent-surface inspect --depth static",
-  coverage: "agent-surface inspect (or `check`, which now fails on the gap)"
-};
+var COMMANDS = /* @__PURE__ */ new Set(["inspect", "snapshot", "check"]);
+var FORMATS = /* @__PURE__ */ new Set(["human", "json", "github", "markdown"]);
+var POLICIES = /* @__PURE__ */ new Set(["all", "widening", "narrowing", "neutral", "none"]);
+function write(text, error = false) {
+  (error ? process.stderr : process.stdout).write(text.endsWith("\n") ? text : `${text}
+`);
+}
 async function main(argv = process.argv.slice(2)) {
   let parsed;
   try {
@@ -101,16 +169,13 @@ async function main(argv = process.argv.slice(2)) {
       args: argv,
       allowPositionals: true,
       options: {
+        root: { type: "string", default: process.cwd() },
         config: { type: "string" },
-        "baseline-dir": { type: "string" },
-        scope: { type: "string", multiple: true },
-        depth: { type: "string", default: "full" },
-        detail: { type: "boolean", default: false },
-        explain: { type: "boolean", default: false },
-        schemas: { type: "boolean", default: false },
-        tsconfig: { type: "string" },
-        "allow-unresolved": { type: "boolean", default: false },
-        yes: { type: "boolean", default: false },
+        snapshot: { type: "string" },
+        target: { type: "string", multiple: true },
+        base: { type: "string" },
+        policy: { type: "string", default: "all" },
+        format: { type: "string", default: "human" },
         json: { type: "boolean", default: false },
         plain: { type: "boolean", default: false },
         help: { type: "boolean", short: "h", default: false },
@@ -118,8 +183,8 @@ async function main(argv = process.argv.slice(2)) {
       }
     });
   } catch (error) {
-    writeError(error instanceof Error ? error.message : String(error));
-    writeError(USAGE);
+    write(error instanceof Error ? error.message : String(error), true);
+    write(USAGE, true);
     return 2;
   }
   const { values, positionals } = parsed;
@@ -131,87 +196,47 @@ async function main(argv = process.argv.slice(2)) {
     write(await readVersion());
     return 0;
   }
-  const [command, scenario] = positionals;
-  if (!command) {
-    write(USAGE);
+  const [command, ...extra] = positionals;
+  if (!command || !COMMANDS.has(command) || extra.length > 0) {
+    write(command === "init" ? "init removed: configure the Vite compiler plugin" : `invalid command ${command ?? ""}`, true);
+    write(USAGE, true);
     return 2;
   }
-  if (!COMMANDS.includes(command)) {
-    const moved = RETIRED[command];
-    writeError(
-      moved ? `"${command}" was removed in 0.11 \u2014 its answer is now \`${moved}\`. The static catalog and the live projection are one command, so the gap between them is reported rather than left for whoever remembers to look.` : `unknown command "${command}"`
-    );
-    if (!moved) writeError(USAGE);
+  const format = values.json ? "json" : values.format;
+  if (!FORMATS.has(format)) {
+    write(`--format must be human, json, github, or markdown`, true);
     return 2;
   }
-  if (!isDepth(values.depth)) {
-    writeError(`--depth must be one of ${DEPTHS.join(", ")} \u2014 got "${values.depth}"`);
+  if (!POLICIES.has(values.policy)) {
+    write(`--policy must be all, widening, narrowing, neutral, or none`, true);
     return 2;
   }
-  const depth = values.depth;
+  const options = {
+    root: values.root,
+    ...values.config ? { configFile: values.config } : {},
+    ...values.snapshot ? { snapshot: values.snapshot } : {},
+    targets: values.target ?? [],
+    ...values.base ? { base: values.base } : {},
+    format,
+    policy: values.policy,
+    ...values.plain ? { plain: true } : {}
+  };
   try {
-    if (command === "init") {
-      const { runInit } = await import("./init-BVZR6CRS.js");
-      return await runInit({
-        cwd: process.cwd(),
-        ...values.tsconfig ? { tsconfig: values.tsconfig } : {},
-        ...values.yes ? { yes: true } : {},
-        ...values.plain ? { plain: true } : {}
-      });
-    }
-    const configPath = values.config ?? findConfig();
-    if (!configPath) {
-      writeError(
-        "no agent-surface.config.* found (searched upward from the working directory).\nRun `agent-surface init`, or see https://agent-surface-docs.vercel.app/20-cli"
-      );
-      return 2;
-    }
-    if (depth !== "static") installDom();
-    const shared = {
-      configPath,
-      depth,
-      ...scenario ? { scenario } : {},
-      ...values.scope ? { scope: values.scope } : {},
-      ...values.tsconfig ? { tsconfig: values.tsconfig } : {},
-      ...values.json ? { json: true } : {},
-      ...values.plain ? { plain: true } : {},
-      ...values["baseline-dir"] ? { baselineDir: values["baseline-dir"] } : {}
-    };
-    if (command === "inspect") {
-      const { runInspect } = await import("./inspect-3YFPCYQJ.js");
-      return await runInspect({
-        ...shared,
-        ...values.detail ? { detail: true } : {},
-        ...values.explain ? { explain: true } : {},
-        ...values.schemas ? { schemas: true } : {}
-      });
-    }
-    if (command === "snapshot") {
-      const { runSnapshot } = await import("./snapshot-5QKLZKZI.js");
-      return await runSnapshot(shared);
-    }
-    const { runCheck } = await import("./check-VWRYNYLN.js");
-    return await runCheck({
-      ...shared,
-      ...values.detail ? { detail: true } : {},
-      ...values["allow-unresolved"] ? { allowUnresolved: true } : {}
-    });
+    if (command === "inspect") return await runInspect(options);
+    if (command === "snapshot") return await runSnapshot(options);
+    return await runCheck(options);
   } catch (error) {
-    writeError(error instanceof Error ? error.message : String(error));
+    write(error instanceof Error ? error.message : String(error), true);
     if (error instanceof Error && error.stack && process.env["AGENT_SURFACE_DEBUG"]) {
-      writeError(error.stack);
+      write(error.stack, true);
     }
     return 2;
   }
 }
 async function readVersion() {
-  try {
-    const { readFileSync } = await import("fs");
-    const path = fileURLToPath(new URL("../package.json", import.meta.url));
-    return JSON.parse(readFileSync(path, "utf8")).version;
-  } catch {
-    return "unknown";
-  }
+  const { readFileSync } = await import("fs");
+  const path = fileURLToPath(new URL("../package.json", import.meta.url));
+  return JSON.parse(readFileSync(path, "utf8")).version;
 }
 function invokedAsBinary() {
   const entry = process.argv[1];
@@ -222,61 +247,10 @@ function invokedAsBinary() {
     return false;
   }
 }
-var GRACE_MS = 1e3;
-var OWN_STDIO = /* @__PURE__ */ new Set(["TTYWrap", "PipeWrap", "FileWrap"]);
-function heldHandles() {
-  const active = process.getActiveResourcesInfo?.() ?? [];
-  return active.filter((resource) => !OWN_STDIO.has(resource));
-}
-async function flushOutput() {
-  const drained = Promise.all(
-    [process.stdout, process.stderr].map(
-      (stream) => new Promise((resolve) => {
-        if (stream.writableLength === 0) resolve();
-        else stream.write("", () => resolve());
-      })
-    )
-  );
-  const deadline = new Promise((resolve) => {
-    setTimeout(resolve, 2e3).unref();
-  });
-  await Promise.race([drained, deadline]);
-}
-function exitWhenWedged(code) {
-  process.exitCode = code;
-  setTimeout(() => {
-    const held = heldHandles();
-    if (held.length > 0) {
-      const kinds = [...new Set(held)].sort().join(", ");
-      writeError(
-        `
-${renderReportPlain([
-          {
-            title: "PROCESS CLEANUP  WARN",
-            rows: [
-              { label: "Open handles", text: `${held.length} (${kinds})` },
-              { label: "Impact", text: "report complete; exit code unchanged; process exit forced" },
-              {
-                label: "Likely cause",
-                text: "polling, websocket, or a cache timer created during mount"
-              },
-              { label: "Exit", text: String(code) }
-            ]
-          }
-        ])}`
-      );
-    }
-    void flushOutput().then(() => process.exit(code));
-  }, GRACE_MS).unref();
-}
 if (invokedAsBinary()) {
-  main().then(
-    (code) => exitWhenWedged(code),
-    (error) => {
-      writeError(error instanceof Error ? error.message : String(error));
-      exitWhenWedged(1);
-    }
-  );
+  void main().then((code) => {
+    process.exitCode = code;
+  });
 }
 export {
   main