@nwire/scan 0.9.2 → 0.10.1

package/dist/scan.js

@@ -1,36 +1,52 @@
 /**
- * `@nwire/scan` — walks `AppDefinition[]` and produces the `.nwire/` cache.
+ * `@nwire/scan` — produces the `.nwire/` cache by inspecting booted apps.
  *
- * The framework's static-reflection layer: every action/event/actor/
- * projection/query/route plus the cross-module event graph emitted as
- * JSON. Studio reads it; the CLI reads it; codegen reads it. Rebuilt
- * from scratch on each invocation (a few ms for hundreds of definitions).
+ * Each input must be a `ForgeApp` (or any object exposing `appName`,
+ * `dispatcher()`, `container`, `runtime`). The scanner walks the
+ * dispatcher metadata maps to collect actions, actors, projections,
+ * queries, workflows, and external calls, and reads `container.list()`
+ * for DI bindings + `runtime.listHooks()` for hooks.
  *
- * See: architecture-sketch.html §05 (Tooling).
+ * Callers are responsible for booting their apps before scanning — the
+ * forge plugin populates the dispatcher during `app.start()`.
  */
-import { mkdir, writeFile } from "node:fs/promises";
-import { listHooks } from "@nwire/hooks";
+import { writeFile, mkdir } from "node:fs/promises";
 import { resolve } from "node:path";
-import { zodToJsonSchema } from "./zod-to-json.js";
-/**
- * Normalize an input that may be either the bare definition (with a
- * `$kind` discriminator) or a `{ definition, app?, module?, where? }`
- * attribution wrapper. Returns the latter shape uniformly so the
- * collector loops don't fork on every iteration.
- */
-function unwrapInput(input) {
-    if ("definition" in input) {
-        return {
-            definition: input.definition,
-            app: input.app,
-            module: input.module,
-            where: input.where,
-        };
+// Pull the ForgeDispatcher off an App in either 0.9 or 0.10 shape. Returns
+// undefined when the App doesn't have forge wired (plain HTTP-only App) —
+// the scanner skips forge-specific collection in that case.
+function resolveDispatcher(app) {
+    if (typeof app.dispatcher === "function") {
+        try {
+            const d = app.dispatcher();
+            if (d)
+                return d;
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    if (typeof app.container?.resolve === "function") {
+        try {
+            const d = app.container.resolve("forge.dispatcher");
+            if (d)
+                return d;
+        }
+        catch {
+            /* not bound — plain app, no forge */
+        }
     }
-    return { definition: input };
+    return undefined;
+}
+function sourceOf(value) {
+    return value?.$source;
+}
+function safeMap(map) {
+    return map ?? new Map();
 }
 export function buildCache(apps, options = {}) {
     const out = {
+        generatedAt: new Date().toISOString(),
         apps: [],
         modules: [],
         actions: [],
@@ -47,490 +63,161 @@ export function buildCache(apps, options = {}) {
         inboxes: [],
         crons: [],
         commands: [],
+        hooks: [],
         plugins: [],
         bindings: [],
         resources: [],
         errors: [],
         middleware: [],
+        graph: { events: [] },
     };
-    const mounts = options.mounts ?? [];
+    const eventNamesSeen = new Set();
     for (const app of apps) {
-        out.apps.push({
-            name: app.name,
-            description: app.description,
-            modules: app.modules.map((m) => m.name),
-            tenantModel: app.tenantModel,
-            tenantKey: app.tenantKey,
-        });
-        // Capture plugin + module-as-plugin entries. Modules participate in
-        // the same lifecycle as plugins (PluginRegistered { kind: "module" }
-        // etc.); we tag them so Studio can render the right affordance.
-        for (const module of app.modules) {
-            out.plugins.push({
-                name: module.name,
-                kind: "module",
-                app: app.name,
-                source: module.$source,
-            });
+        out.apps.push({ name: app.appName, modules: [] });
+        const dispatcher = resolveDispatcher(app);
+        if (!dispatcher) {
+            // Plain HTTP App with no forge — the scanner has nothing to
+            // collect from the runtime side. Continue to the next App.
+            continue;
         }
-        for (const plugin of app.plugins ?? []) {
-            out.plugins.push({
-                name: plugin.name,
-                kind: "plugin",
-                app: app.name,
-                source: plugin.$source,
+        // ── Actions (via handlers) ──────────────────────────────────────
+        const handlers = safeMap(dispatcher.handlers);
+        for (const [name, handler] of handlers) {
+            const action = handler.action ?? {};
+            out.actions.push({
+                name,
+                app: app.appName,
+                public: Boolean(action.$public),
+                inputSchema: action.schema,
+                source: sourceOf(action),
             });
-        }
-        // DI bindings — walk the app's container if it exposes the optional
-        // introspection contract from `@nwire/container`. Apps may carry their
-        // container on `.container` (runnable `App` from `createApp`) or on
-        // `.runtime.container` (older `defineApp` shape). Either is fine; we
-        // duck-type to stay forwards-compatible.
-        const ctn = app.container ??
-            app.runtime
-                ?.container;
-        if (ctn?.list) {
-            try {
-                for (const b of ctn.list()) {
-                    out.bindings.push({
-                        name: b.name,
-                        kind: b.kind,
-                        app: app.name,
-                        source: b.source,
+            for (const ev of (action.emits ?? [])) {
+                if (ev?.name && !eventNamesSeen.has(ev.name)) {
+                    eventNamesSeen.add(ev.name);
+                    out.events.push({
+                        name: ev.name,
+                        app: app.appName,
+                        public: Boolean(ev.$public),
+                        source: sourceOf(ev),
                     });
                 }
-            }
-            catch {
-                // Defensive: a misbehaving custom container should never break the cache.
-            }
-        }
-        // Commands ride on the AppDefinition opt-in: modules don't have them
-        // (operator scripts aren't domain intent), but apps MAY carry a
-        // `commands: CommandDefinition[]` field. Read defensively — most apps
-        // won't populate it, and we never want missing-property to crash scan.
-        const appCommands = app.commands ?? [];
-        for (const command of appCommands) {
-            out.commands.push({
-                name: command.name,
-                describe: command.describe,
-                app: app.name,
-                hasArgsSchema: command.args !== undefined,
-                source: command.$source,
-            });
-        }
-        // Resolvers as a concept were removed — operations now ship as
-        // RouteBinding values wired on `httpInterface`. Scan reads them
-        // from the http builder's manifest at boot, not from the app.
-        //
-        // `mounts` stays as a parameter so callers can still pass route
-        // metadata explicitly; it's just no longer derived from
-        // `app.resolvers`.
-        void mounts;
-        void zodToJsonSchema;
-        for (const module of app.modules) {
-            const m = module.manifest;
-            const provides = {
-                events: (m.events ?? []).map((e) => e.name),
-                actions: (m.actions ?? []).map((a) => a.name),
-            };
-            const needs = {
-                events: (m.needs?.events ?? []).map((e) => e.name),
-                externalEvents: (m.needs?.externalEvents ?? []).map((e) => e.name),
-                actions: (m.needs?.actions ?? []).map((a) => a.name),
-            };
-            out.modules.push({
-                name: module.name,
-                app: app.name,
-                provides,
-                needs,
-                counts: {
-                    actions: (m.actions ?? []).length,
-                    actors: (m.actors ?? []).length,
-                    projections: (m.projections ?? []).length,
-                    queries: (m.queries ?? []).length,
-                    workflows: (m.workflows ?? []).length,
-                    events: (m.events ?? []).length,
-                    // routes are app-level (httpInterface().wire()); not module-owned.
-                    routes: 0,
-                },
-                description: m.description,
-                owners: m.owners,
-                journey: m.journey,
-                source: module.$source,
-            });
-            for (const action of m.actions ?? []) {
-                out.actions.push({
-                    name: action.name,
-                    description: action.description,
-                    module: module.name,
-                    app: app.name,
-                    schema: zodToJsonSchema(action.schema),
-                    retry: action.retry,
-                    policy: action.policy,
-                    hasInlineHandler: Boolean(action.handler),
-                    emits: (action.emits ?? []).map((e) => e.name),
-                    public: module.publicSurface.actions.has(action.name),
-                    persona: action.persona,
-                    journeyStep: action.journeyStep,
-                    capability: action.capability,
-                    slo: action.slo,
-                    tags: action.tags,
-                    source: action.$source,
-                });
-            }
-            for (const event of m.events ?? []) {
-                out.events.push({
-                    name: event.name,
-                    description: event.description,
-                    module: module.name,
-                    app: app.name,
-                    visibility: event.visibility ?? "public",
-                    public: module.publicSurface.events.has(event.name),
-                    schema: zodToJsonSchema(event.schema),
-                    outcome: event.outcome,
-                    businessWeight: event.businessWeight,
-                    audience: event.audience,
-                    source: event.$source,
-                });
-            }
-            for (const actor of m.actors ?? []) {
-                out.actors.push({
-                    name: actor.name,
-                    module: module.name,
-                    app: app.name,
-                    key: actor.key,
-                    initial: actor.initial,
-                    states: Object.entries(actor.states).map(([stateName, cfg]) => ({
-                        name: stateName,
-                        final: cfg.final,
-                        on: Object.entries(cfg.on ?? {}).map(([eventName, reaction]) => ({
-                            eventName,
-                            target: reaction.target,
-                        })),
-                        after: Object.entries(cfg.after ?? {}).map(([timerName, spec]) => ({
-                            timerName,
-                            action: typeof spec === "string" ? spec : spec.action,
-                            delay: typeof spec === "string" ? timerName : spec.delay,
-                        })),
-                    })),
-                    methods: Object.keys(actor.methods ?? {}),
-                    schema: zodToJsonSchema(actor.schema),
-                    stuckThresholds: actor.stuckThresholds,
-                    slas: actor.slas,
-                    source: actor.$source,
-                });
-            }
-            for (const projection of m.projections ?? []) {
-                out.projections.push({
-                    name: projection.name,
-                    module: module.name,
-                    app: app.name,
-                    listens: (projection.listens ?? []).map((e) => e.name),
-                    description: projection.description,
-                    freshness: projection.freshness,
-                    source: projection.$source,
-                });
-            }
-            for (const query of m.queries ?? []) {
-                out.queries.push({
-                    name: query.name,
-                    description: query.description,
-                    module: module.name,
-                    app: app.name,
-                    projection: query.projection?.name,
-                    schema: zodToJsonSchema(query.schema),
-                    public: module.publicSurface.queries.has(query.name),
-                    slo: query.slo,
-                    cacheable: query.cacheable,
-                    source: query.$source,
-                });
-            }
-            // Routes are no longer module-owned. The interface layer (httpInterface
-            // builders + .wire() bindings) lives in the app composition; route
-            // emission walks the running wire's introspection mount.
-            for (const call of m.externalCalls ?? []) {
-                out.externalCalls.push({
-                    name: call.name,
-                    description: call.description,
-                    module: module.name,
-                    app: app.name,
-                    target: call.target,
-                    request: zodToJsonSchema(call.request),
-                    response: call.response ? zodToJsonSchema(call.response) : undefined,
-                    hasIdempotencyKey: call.hasIdempotencyKey,
-                    slo: call.slo,
-                    retry: call.retry ? { max: call.retry.max, backoff: call.retry.backoff } : undefined,
-                    tags: call.tags,
-                });
-            }
-            for (const wh of m.inboundWebhooks ?? []) {
-                const routes = {};
-                for (const [discValue, action] of Object.entries(wh.routes)) {
-                    routes[discValue] = action.name;
+                if (ev?.name) {
+                    out.graph.events.push({ from: name, to: ev.name, via: "emits" });
                 }
-                out.inboundWebhooks.push({
-                    name: wh.name,
-                    description: wh.description,
-                    module: module.name,
-                    app: app.name,
-                    source: wh.source,
-                    path: wh.path,
-                    hasSignatureVerifier: !!wh.verifySignature,
-                    dedupe: wh.dedupe ? { window: wh.dedupe.window } : undefined,
-                    discriminator: wh.discriminator,
-                    routes,
-                    tags: wh.tags,
-                });
-            }
-            for (const ob of m.outboxes ?? []) {
-                out.outboxes.push({
-                    name: ob.name,
-                    description: ob.description,
-                    module: module.name,
-                    app: app.name,
-                    publishes: ob.publishes.map((e) => e.name),
-                    flushIntervalMs: ob.flushIntervalMs,
-                    maxBatch: ob.maxBatch,
-                    tags: ob.tags,
-                });
-            }
-            for (const ib of m.inboxes ?? []) {
-                out.inboxes.push({
-                    name: ib.name,
-                    description: ib.description,
-                    module: module.name,
-                    app: app.name,
-                    window: ib.window,
-                    on: ib.on.map((a) => a.name),
-                    tags: ib.tags,
-                });
-            }
-            for (const cron of m.crons ?? []) {
-                out.crons.push({
-                    name: cron.name,
-                    description: cron.description,
-                    module: module.name,
-                    app: app.name,
-                    schedule: cron.schedule,
-                    dispatches: cron.dispatches.name,
-                    timezone: cron.timezone,
-                    tags: cron.tags,
-                });
             }
         }
-    }
-    // Build event graph: producer (module that emits) → consumers (modules
-    // that listen via reaction or have it in needs).
-    const eventOwners = new Map();
-    for (const ev of out.events) {
-        eventOwners.set(ev.name, { app: ev.app, module: ev.module });
-    }
-    const edges = new Map();
-    const seed = (eventName) => {
-        const owner = eventOwners.get(eventName);
-        if (!owner)
-            return null;
-        let e = edges.get(eventName);
-        if (!e) {
-            e = { event: eventName, producer: owner, consumers: [] };
-            edges.set(eventName, e);
+        // ── Actors ──────────────────────────────────────────────────────
+        const actors = safeMap(dispatcher.actors);
+        for (const [name, def] of actors) {
+            out.actors.push({ name, app: app.appName, source: sourceOf(def) });
         }
-        return e;
-    };
-    // Workflows = explicit cross-cutting subscribers. Studio reads one
-    // .nwire/workflows.json and renders every reaction-style handler on
-    // the same node type.
-    for (const app of apps) {
-        for (const module of app.modules) {
-            for (const workflow of module.manifest.workflows ?? []) {
-                out.workflows.push({
-                    name: workflow.name,
-                    module: module.name,
-                    app: app.name,
-                    description: workflow.description,
-                    subscribesTo: [...workflow.subscribedEvents],
-                    dispatches: [...workflow.dispatchedActions],
-                    public: module.publicSurface.workflows.has(workflow.name),
-                    source: workflow.$source,
-                });
-                for (const eventName of workflow.subscribedEvents) {
-                    const edge = seed(eventName);
-                    if (!edge)
-                        continue;
-                    edge.consumers.push({
-                        app: app.name,
-                        module: module.name,
-                        via: "workflow",
+        // ── Projections + listened events ──────────────────────────────
+        const projections = safeMap(dispatcher.projections);
+        for (const [name, def] of projections) {
+            out.projections.push({ name, app: app.appName, source: sourceOf(def) });
+            for (const ev of (def.listens ?? [])) {
+                if (ev?.name && !eventNamesSeen.has(ev.name)) {
+                    eventNamesSeen.add(ev.name);
+                    out.events.push({
+                        name: ev.name,
+                        app: app.appName,
+                        public: Boolean(ev.$public),
+                        source: sourceOf(ev),
                     });
                 }
-            }
-            // Actor reactions = state-machine reactions
-            for (const actor of module.manifest.actors ?? []) {
-                for (const [stateName, cfg] of Object.entries(actor.states)) {
-                    for (const eventName of Object.keys(cfg.on ?? {})) {
-                        const edge = seed(eventName);
-                        if (!edge)
-                            continue;
-                        edge.consumers.push({
-                            app: app.name,
-                            module: module.name,
-                            via: "actor",
-                        });
-                    }
+                if (ev?.name) {
+                    out.graph.events.push({ from: ev.name, to: name, via: "folds" });
                 }
             }
-            // Projection listens
-            for (const projection of module.manifest.projections ?? []) {
-                for (const ev of projection.listens ?? []) {
-                    const edge = seed(ev.name);
-                    if (!edge)
-                        continue;
-                    edge.consumers.push({
-                        app: app.name,
-                        module: module.name,
-                        via: "projection",
-                    });
-                }
+        }
+        // ── Queries ─────────────────────────────────────────────────────
+        const queries = safeMap(dispatcher.queries);
+        for (const [name, def] of queries) {
+            out.queries.push({
+                name,
+                app: app.appName,
+                public: Boolean(def.$public),
+                source: sourceOf(def),
+            });
+        }
+        // ── Workflows + subscribed/dispatched edges ────────────────────
+        const workflowDefs = dispatcher.listWorkflows?.() ?? [];
+        for (const def of workflowDefs) {
+            const name = String(def.name);
+            out.workflows.push({
+                name,
+                app: app.appName,
+                public: Boolean(def.$public),
+                source: sourceOf(def),
+            });
+            for (const evName of (def.subscribedEvents ?? new Set())) {
+                out.graph.events.push({ from: evName, to: name, via: "subscribes" });
             }
-            // External event needs = cross-service consumers
-            for (const ev of module.manifest.needs?.externalEvents ?? []) {
-                const edge = seed(ev.name);
-                if (!edge)
-                    continue;
-                edge.consumers.push({
-                    app: app.name,
-                    module: module.name,
-                    via: "external",
-                });
+            for (const actName of (def.dispatchedActions ?? new Set())) {
+                out.graph.events.push({ from: name, to: actName, via: "dispatches" });
             }
         }
+        // ── External calls ─────────────────────────────────────────────
+        const externalCalls = safeMap(dispatcher.externalCalls);
+        for (const [name, def] of externalCalls) {
+            out.externalCalls.push({ name, app: app.appName, source: sourceOf(def) });
+        }
+        // ── DI bindings ────────────────────────────────────────────────
+        const bindings = app.container.list?.() ?? [];
+        for (const b of bindings) {
+            out.bindings.push({
+                name: b.name,
+                kind: (b.kind === "singleton" || b.kind === "transient" ? b.kind : "singleton"),
+                app: app.appName,
+                source: b.source,
+            });
+        }
+        // ── Hooks ──────────────────────────────────────────────────────
+        const hooks = app.runtime?.listHooks?.() ?? [];
+        for (const h of hooks) {
+            out.hooks.push({
+                id: h.id,
+                name: h.name,
+                chain: h.chain,
+                listeners: h.listeners,
+                source: h.source,
+            });
+        }
     }
-    // Resources / errors / middleware — passed in via options because these
-    // primitives live at the interface layer (handlers/resolvers import them),
-    // not on module manifests. Each input may be either the bare definition
-    // OR a tagged `{ definition, app?, module? }` wrapper carrying
-    // attribution. Same shape, three different `$kind` discriminators.
-    for (const input of options.resources ?? []) {
-        const tagged = unwrapInput(input);
-        const d = tagged.definition;
-        out.resources.push({
-            name: d.name,
-            summary: d.summary,
-            description: d.description,
-            app: tagged.app,
-            module: tagged.module,
-            public: d.public ?? [],
-            schema: d.schema ? zodToJsonSchema(d.schema) : {},
-            exampleVariants: Object.keys(d.examples ?? {}),
-            audience: d.audience,
-            source: d.$source,
-        });
+    // ── Routes (from passed-in interfaces) ────────────────────────────
+    for (const iface of options.interfaces ?? []) {
+        for (const r of iface.listRoutes?.() ?? []) {
+            out.routes.push({ method: r.method, path: r.path, action: r.action });
+        }
     }
-    for (const input of options.errors ?? []) {
-        const tagged = unwrapInput(input);
-        const d = tagged.definition;
-        out.errors.push({
-            code: d.code,
-            status: d.status,
-            summary: d.summary,
-            description: d.description,
-            app: tagged.app,
-            module: tagged.module,
-            tags: d.tags,
-            source: d.$source,
-        });
+    // ── Resolver mounts (operator-supplied) ──────────────────────────
+    for (const m of options.mounts ?? []) {
+        out.resolvers.push({ name: m.resolverName, app: "" });
     }
-    for (const input of options.middleware ?? []) {
-        const tagged = unwrapInput(input);
-        const d = tagged.definition;
-        out.middleware.push({
-            // Anonymous middleware (no name supplied) shows up as "anonymous"
-            // — matches what `pipe()` does at run time so Studio + telemetry
-            // stay consistent across the static + live views.
-            name: d.name ?? "anonymous",
-            app: tagged.app,
-            module: tagged.module,
-            where: tagged.where,
-            source: d.$source,
-        });
+    // ── Resources / errors / middleware (operator-supplied) ──────────
+    for (const r of options.resources ?? []) {
+        if ("definition" in r) {
+            const def = r.definition;
+            out.resources.push({ name: String(def?.name ?? ""), app: r.app, module: r.module, source: sourceOf(def) });
+        }
     }
-    // Routes from passed-in `RouteSource`s (typically `httpInterface()` from
-    // `@nwire/http`). The `.from(source)` label declared on each binding is
-    // emitted to `routes.json` so Studio can group by trigger source.
-    for (const iface of options.interfaces ?? []) {
-        for (const r of iface.listRoutes()) {
-            out.routes.push({
-                method: r.verb.toUpperCase(),
-                path: r.path,
-                source: r.source,
-            });
+    for (const e of options.errors ?? []) {
+        if ("definition" in e) {
+            const def = e.definition;
+            out.errors.push({ code: String(def?.code ?? ""), app: e.app, module: e.module, source: sourceOf(def) });
         }
     }
-    return {
-        generatedAt: new Date().toISOString(),
-        apps: out.apps,
-        modules: out.modules,
-        actions: out.actions,
-        events: out.events,
-        actors: out.actors,
-        projections: out.projections,
-        queries: out.queries,
-        resolvers: out.resolvers,
-        routes: out.routes,
-        workflows: out.workflows,
-        externalCalls: out.externalCalls,
-        inboundWebhooks: out.inboundWebhooks,
-        outboxes: out.outboxes,
-        inboxes: out.inboxes,
-        crons: out.crons,
-        commands: out.commands,
-        plugins: out.plugins,
-        // Snapshot every hook registered up to this point. `listHooks` walks
-        // the @nwire/hooks process-wide registry; runtime construction +
-        // plugin register + module wiring all run during the caller's
-        // `import(apps)`, so the snapshot is comprehensive at scan time.
-        hooks: listHooks().map((h) => ({
-            id: h.id,
-            name: h.name,
-            chain: h.chain,
-            listeners: h.listeners,
-            source: h.source,
-        })),
-        bindings: out.bindings,
-        resources: out.resources,
-        errors: out.errors,
-        middleware: out.middleware,
-        graph: { events: Array.from(edges.values()) },
-    };
+    for (const m of options.middleware ?? []) {
+        if ("definition" in m) {
+            out.middleware.push({ name: m.definition.name, where: m.where });
+        }
+        else {
+            out.middleware.push({ name: m.name });
+        }
+    }
+    return out;
 }
 export async function writeCache(cache, dir) {
     await mkdir(dir, { recursive: true });
-    await Promise.all([
-        writeFile(resolve(dir, "manifest.json"), JSON.stringify(cache, null, 2)),
-        writeFile(resolve(dir, "actions.json"), JSON.stringify(cache.actions, null, 2)),
-        writeFile(resolve(dir, "events.json"), JSON.stringify(cache.events, null, 2)),
-        writeFile(resolve(dir, "actors.json"), JSON.stringify(cache.actors, null, 2)),
-        writeFile(resolve(dir, "projections.json"), JSON.stringify(cache.projections, null, 2)),
-        writeFile(resolve(dir, "queries.json"), JSON.stringify(cache.queries, null, 2)),
-        writeFile(resolve(dir, "modules.json"), JSON.stringify(cache.modules, null, 2)),
-        writeFile(resolve(dir, "apps.json"), JSON.stringify(cache.apps, null, 2)),
-        writeFile(resolve(dir, "resolvers.json"), JSON.stringify(cache.resolvers, null, 2)),
-        writeFile(resolve(dir, "routes.json"), JSON.stringify(cache.routes, null, 2)),
-        writeFile(resolve(dir, "workflows.json"), JSON.stringify(cache.workflows, null, 2)),
-        writeFile(resolve(dir, "external-calls.json"), JSON.stringify(cache.externalCalls, null, 2)),
-        writeFile(resolve(dir, "inbound-webhooks.json"), JSON.stringify(cache.inboundWebhooks, null, 2)),
-        writeFile(resolve(dir, "outboxes.json"), JSON.stringify(cache.outboxes, null, 2)),
-        writeFile(resolve(dir, "inboxes.json"), JSON.stringify(cache.inboxes, null, 2)),
-        writeFile(resolve(dir, "crons.json"), JSON.stringify(cache.crons, null, 2)),
-        writeFile(resolve(dir, "commands.json"), JSON.stringify(cache.commands, null, 2)),
-        writeFile(resolve(dir, "hooks.json"), JSON.stringify(cache.hooks, null, 2)),
-        writeFile(resolve(dir, "plugins.json"), JSON.stringify(cache.plugins, null, 2)),
-        writeFile(resolve(dir, "di.json"), JSON.stringify(cache.bindings, null, 2)),
-        writeFile(resolve(dir, "models.json"), JSON.stringify(cache.resources, null, 2)),
-        writeFile(resolve(dir, "errors.json"), JSON.stringify(cache.errors, null, 2)),
-        writeFile(resolve(dir, "middleware.json"), JSON.stringify(cache.middleware, null, 2)),
-        writeFile(resolve(dir, "graph.json"), JSON.stringify(cache.graph, null, 2)),
-    ]);
+    await writeFile(resolve(dir, "manifest.json"), JSON.stringify(cache, null, 2));
 }
-export { zodToJsonSchema };
-//# sourceMappingURL=scan.js.map