zudojs-cli 2.0.1 → 2.1.1

package/dist/src/templates/shared/dockerfile.template.d.ts

@@ -1,19 +1,27 @@
 /**
  * zudojs-cli — Generated Dockerfiles.
  *
- * Shared by the microservice template and the InfrastructureGenerator so the
- * fullstack microservice project and the standalone one build the same way.
+ * Shared by the microservice template, the InfrastructureGenerator and
+ * `zudojs add docker`. Every image is multi-stage on Node 24: a build stage
+ * installs, compiles and prunes dev dependencies; the runtime stage copies
+ * only `dist`, production `node_modules` and `package.json`, runs as the
+ * unprivileged `node` user and declares a /health HEALTHCHECK. The images
+ * used to run as root and ship the whole dev toolchain.
  */
 /** The dependency install command for a package manager inside a Dockerfile. */
 export declare function dockerInstallCommand(packageManager: string): string;
 /**
- * A self-contained Dockerfile for one app of a microservice project. The
- * build context is the project root; only `appPath` is copied in.
+ * A self-contained Dockerfile for one app package. The build context is the
+ * project root; `appPath` is the app's directory (`.` for a single-app
+ * project). pnpm's `pnpm-workspace.yaml` is copied for its build-script
+ * allow-list, without which pnpm 11 refuses to install.
  */
 export declare function renderAppPackageDockerfile(options: {
     readonly appPath: string;
     readonly port: number;
     readonly packageManager: string;
+    /** The app has Prisma: copy the schema and config before installing. */
+    readonly prisma?: boolean;
 }): string;
 /**
  * A Dockerfile for a workspace whose server lives in `appDirectory`. The whole

package/dist/src/templates/shared/dockerfile.template.js

@@ -1,8 +1,12 @@
 /**
  * zudojs-cli — Generated Dockerfiles.
  *
- * Shared by the microservice template and the InfrastructureGenerator so the
- * fullstack microservice project and the standalone one build the same way.
+ * Shared by the microservice template, the InfrastructureGenerator and
+ * `zudojs add docker`. Every image is multi-stage on Node 24: a build stage
+ * installs, compiles and prunes dev dependencies; the runtime stage copies
+ * only `dist`, production `node_modules` and `package.json`, runs as the
+ * unprivileged `node` user and declares a /health HEALTHCHECK. The images
+ * used to run as root and ship the whole dev toolchain.
  */
 /** The dependency install command for a package manager inside a Dockerfile. */
 export function dockerInstallCommand(packageManager) {
@@ -17,29 +21,61 @@ export function dockerInstallCommand(packageManager) {
             return "npm install";
     }
 }
-/**
- * A self-contained Dockerfile for one app of a microservice project. The
- * build context is the project root; only `appPath` is copied in.
- */
-export function renderAppPackageDockerfile(options) {
-    const { appPath, port } = options;
-    return `FROM node:24-alpine AS builder
-WORKDIR /app
-COPY ${appPath}/package.json ./
-RUN ${dockerInstallCommand(options.packageManager)}
-COPY ${appPath}/tsconfig.json ./
-COPY ${appPath}/src ./src
-RUN npx tsc
-
-FROM node:24-alpine AS runtime
+/** Removes dev dependencies after the build (scripts off: prisma is a dev tool). */
+function dockerPruneCommand(packageManager) {
+    switch (packageManager) {
+        case "pnpm":
+            return "pnpm prune --prod --ignore-scripts";
+        case "yarn":
+            return undefined;
+        default:
+            return "npm prune --omit=dev --ignore-scripts";
+    }
+}
+function runnerFor(packageManager) {
+    return packageManager === "npm" || packageManager === "bun" ? "npm" : packageManager;
+}
+/** The runtime stage of a single-package image. */
+function runtimeStage(port, dist, from) {
+    return `FROM node:24-alpine AS runtime
+ENV NODE_ENV=production
 WORKDIR /app
-COPY --from=builder /app/dist ./dist
-COPY --from=builder /app/node_modules ./node_modules
-COPY --from=builder /app/package.json ./
+COPY --from=build --chown=node:node ${from}/package.json ./
+COPY --from=build --chown=node:node ${from}/node_modules ./node_modules
+COPY --from=build --chown=node:node ${from}/${dist} ./${dist}
+USER node
 EXPOSE ${port}
-CMD ["node", "dist/server.js"]
+HEALTHCHECK --interval=30s --timeout=5s --start-period=15s CMD ["node", "-e", "fetch('http://127.0.0.1:${port}/health').then((r) => process.exit(r.ok ? 0 : 1), () => process.exit(1))"]
+CMD ["node", "${dist}/server.js"]
 `;
 }
+/**
+ * A self-contained Dockerfile for one app package. The build context is the
+ * project root; `appPath` is the app's directory (`.` for a single-app
+ * project). pnpm's `pnpm-workspace.yaml` is copied for its build-script
+ * allow-list, without which pnpm 11 refuses to install.
+ */
+export function renderAppPackageDockerfile(options) {
+    const app = options.appPath.replace(/^\.\/?/, "").replace(/\/$/, "");
+    const at = (file) => (app === "" ? file : `${app}/${file}`);
+    const pm = options.packageManager;
+    const prune = dockerPruneCommand(pm);
+    const lines = [
+        "# syntax=docker/dockerfile:1",
+        "FROM node:24-alpine AS build",
+        "WORKDIR /app",
+        `COPY ${at("package.json")} ./`,
+        ...(pm === "pnpm" ? ["COPY pnpm-workspace.yaml ./"] : []),
+        ...(options.prisma ? [`COPY ${at("prisma.config.ts")} ./`, `COPY ${at("prisma")} ./prisma`] : []),
+        `RUN ${dockerInstallCommand(pm)}`,
+        `COPY ${at("tsconfig.json")} ./`,
+        `COPY ${at("src")} ./src`,
+        `RUN ${runnerFor(pm)} run build`,
+        ...(prune === undefined ? [] : [`RUN ${prune}`]),
+        "",
+    ];
+    return `${lines.join("\n")}\n${runtimeStage(options.port, "dist", "/app")}`;
+}
 /**
  * A Dockerfile for a workspace whose server lives in `appDirectory`. The whole
  * workspace is installed, then only that app is built and started: the root
@@ -47,22 +83,25 @@ CMD ["node", "dist/server.js"]
  */
 export function renderWorkspaceAppDockerfile(options) {
     const dir = options.appDirectory.replace(/^\.\/?/, "").replace(/\/$/, "");
-    const install = dockerInstallCommand(options.packageManager);
-    const runner = options.packageManager === "npm" || options.packageManager === "bun"
-        ? "npm"
-        : options.packageManager;
+    const runner = runnerFor(options.packageManager);
     const build = dir === "" ? `${runner} run build` : `cd ${dir} && ${runner} run build`;
     const dist = dir === "" ? "dist" : `${dir}/dist`;
-    return `FROM node:24-alpine AS builder
+    // pnpm links workspace dependencies through the root node_modules, so
+    // the runtime stage takes the whole built workspace.
+    return `# syntax=docker/dockerfile:1
+FROM node:24-alpine AS build
 WORKDIR /app
 COPY . .
-RUN ${install}
+RUN ${dockerInstallCommand(options.packageManager)}
 RUN ${build}
 
-FROM node:24-alpine
+FROM node:24-alpine AS runtime
+ENV NODE_ENV=production
 WORKDIR /app
-COPY --from=builder /app /app
+COPY --from=build --chown=node:node /app /app
+USER node
 EXPOSE ${options.port}
+HEALTHCHECK --interval=30s --timeout=5s --start-period=15s CMD ["node", "-e", "fetch('http://127.0.0.1:${options.port}/health').then((r) => process.exit(r.ok ? 0 : 1), () => process.exit(1))"]
 CMD ["node", "${dist}/server.js"]
 `;
 }

package/dist/src/templates/shared/pnpm.template.d.ts

@@ -14,8 +14,14 @@
  *
  * @module templates/shared/pnpm
  */
-/** Dependencies whose install scripts a generated project allows. */
-export declare const PNPM_ALLOWED_BUILD_SCRIPTS: readonly ["esbuild", "@swc/core", "sharp", "@parcel/watcher", "@tailwindcss/oxide", "unrs-resolver"];
+/**
+ * Dependencies whose install scripts a generated project allows.
+ *
+ * `lmdb` and `msgpackr-extract` come in through `@angular/build` (its
+ * persistent build cache); without them `pnpm install` in an Angular 22
+ * project fails with `ERR_PNPM_IGNORED_BUILDS`.
+ */
+export declare const PNPM_ALLOWED_BUILD_SCRIPTS: readonly ["esbuild", "@swc/core", "sharp", "@parcel/watcher", "@tailwindcss/oxide", "unrs-resolver", "lmdb", "msgpackr-extract"];
 /**
  * Renders `pnpm-workspace.yaml`.
  *

package/dist/src/templates/shared/pnpm.template.js

@@ -14,7 +14,13 @@
  *
  * @module templates/shared/pnpm
  */
-/** Dependencies whose install scripts a generated project allows. */
+/**
+ * Dependencies whose install scripts a generated project allows.
+ *
+ * `lmdb` and `msgpackr-extract` come in through `@angular/build` (its
+ * persistent build cache); without them `pnpm install` in an Angular 22
+ * project fails with `ERR_PNPM_IGNORED_BUILDS`.
+ */
 export const PNPM_ALLOWED_BUILD_SCRIPTS = [
     "esbuild",
     "@swc/core",
@@ -22,6 +28,8 @@ export const PNPM_ALLOWED_BUILD_SCRIPTS = [
     "@parcel/watcher",
     "@tailwindcss/oxide",
     "unrs-resolver",
+    "lmdb",
+    "msgpackr-extract",
 ];
 /**
  * Renders `pnpm-workspace.yaml`.

package/dist/src/templates/shared/server.template.d.ts

@@ -1,31 +1,32 @@
 /**
  * zudojs-cli — Generated `src/server.ts`
  *
- * The entry point used to call `runtime.start()` and nothing else. The
- * runtime creates no HTTP server, so `pnpm dev` logged "ready" and exited
- * with 0 even though `.env.example` set `PORT`, the Dockerfile exposed it
- * and the fullstack frontend called it.
+ * The entry point loads the configuration, builds a router with
+ * `createRouter()`, registers every route through `registerRoutes` (from
+ * the composition root in `container.ts`), mounts the OpenAPI document and
+ * `/docs` page when the `openapi` capability is on, and serves the router
+ * with `createHttpServer` + `createNodeHttpAdapter`.
  *
- * The emitted server starts the runtime, then serves HTTP with
- * `@zudojs/http` (`createHttpServer` + `createNodeHttpAdapter`) on `PORT`,
- * answers `GET /health`, and keeps the process alive until SIGINT/SIGTERM,
- * when it stops the HTTP server and then the runtime. `tests/
- * generatedProject.typecheck.test.ts` type-checks this output against the
- * current `@zudojs/*` sources.
+ * Every response passes through the @zudojs/security default headers, a
+ * CORS policy that allows only `CORS_ORIGINS` (none by default) and a
+ * per-client rate limit (`RATE_LIMIT_MAX` per `RATE_LIMIT_WINDOW_MS`). Exposed
+ * 4xx errors are answered with their status; anything else is a generic
+ * 500. On SIGINT/SIGTERM integrations drain, HTTP stops, then the runtime
+ * stops. `tests/generatedProject.typecheck.test.ts` type-checks the output
+ * against the current `@zudojs/*` sources.
  */
 /** Options for {@link renderServerFile}. */
 export interface ServerFileOptions {
-    /** Port used when `PORT` is unset. Defaults to 3000. */
-    readonly defaultPort?: number;
-    /**
-     * Import path of a `HealthController` whose `check()` answers `/health`,
-     * relative to server.ts. When omitted, `/health` is answered inline.
-     */
-    readonly healthControllerImport?: string;
+    /** Title of the OpenAPI document. */
+    readonly title: string;
+    /** Whether `/openapi.json` and `/docs` are mounted. */
+    readonly openapi: boolean;
 }
-/**
- * Renders `src/server.ts`: starts the runtime, serves HTTP on `PORT` with a
- * `/health` route, and shuts both down cleanly on SIGINT/SIGTERM.
- */
-export declare function renderServerFile(appImportPath?: string, options?: ServerFileOptions): string;
+/** The lines `zudojs add openapi` (or `create`) puts in server.ts. */
+export declare function openApiServerLines(title: string): {
+    readonly importLine: string;
+    readonly mountLine: string;
+};
+/** Renders `src/server.ts`. */
+export declare function renderServerFile(options: ServerFileOptions): string;
 //# sourceMappingURL=server.template.d.ts.map

package/dist/src/templates/shared/server.template.js

@@ -1,86 +1,112 @@
 /**
  * zudojs-cli — Generated `src/server.ts`
  *
- * The entry point used to call `runtime.start()` and nothing else. The
- * runtime creates no HTTP server, so `pnpm dev` logged "ready" and exited
- * with 0 even though `.env.example` set `PORT`, the Dockerfile exposed it
- * and the fullstack frontend called it.
+ * The entry point loads the configuration, builds a router with
+ * `createRouter()`, registers every route through `registerRoutes` (from
+ * the composition root in `container.ts`), mounts the OpenAPI document and
+ * `/docs` page when the `openapi` capability is on, and serves the router
+ * with `createHttpServer` + `createNodeHttpAdapter`.
  *
- * The emitted server starts the runtime, then serves HTTP with
- * `@zudojs/http` (`createHttpServer` + `createNodeHttpAdapter`) on `PORT`,
- * answers `GET /health`, and keeps the process alive until SIGINT/SIGTERM,
- * when it stops the HTTP server and then the runtime. `tests/
- * generatedProject.typecheck.test.ts` type-checks this output against the
- * current `@zudojs/*` sources.
+ * Every response passes through the @zudojs/security default headers, a
+ * CORS policy that allows only `CORS_ORIGINS` (none by default) and a
+ * per-client rate limit (`RATE_LIMIT_MAX` per `RATE_LIMIT_WINDOW_MS`). Exposed
+ * 4xx errors are answered with their status; anything else is a generic
+ * 500. On SIGINT/SIGTERM integrations drain, HTTP stops, then the runtime
+ * stops. `tests/generatedProject.typecheck.test.ts` type-checks the output
+ * against the current `@zudojs/*` sources.
  */
+import { MARKERS, renderMarkerBlock } from "../../wiring/index.js";
 /** Emits a string as a TypeScript string literal that cannot break out. */
 function literal(value) {
     return JSON.stringify(value);
 }
-/**
- * Renders `src/server.ts`: starts the runtime, serves HTTP on `PORT` with a
- * `/health` route, and shuts both down cleanly on SIGINT/SIGTERM.
- */
-export function renderServerFile(appImportPath = "./app.js", options = {}) {
-    const defaultPort = options.defaultPort ?? 3000;
-    const controller = options.healthControllerImport;
-    const controllerImport = controller
-        ? `import { HealthController } from ${literal(controller)};\n`
-        : "";
-    const healthBody = controller
-        ? "new HealthController().check()"
-        : `{ status: "ok", timestamp: new Date().toISOString() }`;
-    return `import {
+/** The lines `zudojs add openapi` (or `create`) puts in server.ts. */
+export function openApiServerLines(title) {
+    return {
+        importLine: `import { mountOpenAPI } from "@zudojs/http";`,
+        mountLine: `mountOpenAPI(router, { info: { title: ${literal(title)}, version: "0.1.0" } });`,
+    };
+}
+/** Renders `src/server.ts`. */
+export function renderServerFile(options) {
+    const openapi = openApiServerLines(options.title);
+    return `import { createServer } from "node:http";
+
+import {
+  HttpMiddlewarePipeline,
+  createCorsMiddleware,
   createHttpServer,
   createNodeHttpAdapter,
+  createRateLimitMiddleware,
   createResponseContext,
+  createRouter,
+  type HttpMiddleware,
   type HttpRequestContext,
 } from "@zudojs/http";
+${renderMarkerBlock(MARKERS.serverImports, options.openapi ? [openapi.importLine] : [])}
+
+import { createApp } from "./app.js";
+import { loadConfig } from "./configs/index.js";
+import { createDependencies } from "./container.js";
+import { checkIntegrations, drainIntegrations, integrations } from "./integrations/index.js";
+import { registerRoutes } from "./routes/index.js";
+import { errorResponse, securityHeaders } from "./utils/http.js";
 
-import { createApp } from ${literal(appImportPath)};
-${controllerImport}
-const DEFAULT_PORT = ${defaultPort};
+const config = await loadConfig();
+const httpServer = createServer();
+const runtime = createApp({ config, httpServer });
 
-/** Reads PORT, refusing values that are not a TCP port. */
-function resolvePort(): number {
-  const raw = process.env["PORT"];
-  if (raw === undefined || raw.trim() === "") return DEFAULT_PORT;
-  const port = Number(raw);
-  if (!Number.isInteger(port) || port < 0 || port > 65535) {
-    throw new Error(\`PORT must be an integer between 0 and 65535, got "\${raw}".\`);
+const router = createRouter();
+registerRoutes(
+  router,
+  createDependencies({
+    health: async () => {
+      const checks = await checkIntegrations(integrations);
+      const ready =
+        runtime.state === "running" && Object.values(checks).every((check) => check === "up");
+      return { ready, checks };
+    },
+  }),
+);
+${renderMarkerBlock(MARKERS.serverMounts, options.openapi ? [openapi.mountLine] : [])}
+
+const dispatch: HttpMiddleware = async (context) => {
+  try {
+    return (await router.dispatch(context.request, { signal: context.signal })).response;
+  } catch (error) {
+    const response = errorResponse(error);
+    if (response === undefined) throw error;
+    return response;
   }
-  return port;
-}
+};
+
+const pipeline = new HttpMiddlewarePipeline({
+  middlewares: [
+    securityHeaders(),
+    createCorsMiddleware({ allowOrigin: config.corsOrigins }),
+    createRateLimitMiddleware({ windowMs: config.rateLimit.windowMs, max: config.rateLimit.max }),
+${renderMarkerBlock(MARKERS.serverMiddleware, [], "    ")}
+    dispatch,
+  ],
+});
 
-const runtime = createApp();
 await runtime.start();
 
 const server = createHttpServer({
-  adapter: createNodeHttpAdapter({
-    host: process.env["HOST"] ?? "0.0.0.0",
-    port: resolvePort(),
-  }),
-  handler: (request: HttpRequestContext) => {
-    if (request.path === "/health") {
-      if (runtime.state !== "running") {
-        return createResponseContext({ status: 503 }).json({ status: "unavailable" });
-      }
-      return ${healthBody};
-    }
-    return createResponseContext({ status: 404 }).json({ error: "Not Found" });
-  },
+  adapter: createNodeHttpAdapter({ server: httpServer, host: config.host, port: config.port }),
+  handler: (request: HttpRequestContext) => pipeline.execute(request, createResponseContext()),
 });
 
 await server.start();
-console.log(\`Listening on port \${server.address?.port ?? resolvePort()}\`);
+console.log(\`Listening on http://\${config.host}:\${server.address?.port ?? config.port}\`);
 
 let stopping = false;
 for (const signal of ["SIGINT", "SIGTERM"] as const) {
   process.once(signal, () => {
     if (stopping) return;
     stopping = true;
-    void server
-      .stop()
+    void drainIntegrations(integrations)
+      .then(() => server.stop())
       .then(() => runtime.stop())
       .then(() => {
         process.exit(0);

package/dist/src/types/scaffold.type.d.ts

@@ -35,6 +35,12 @@ export interface ScaffoldOptions {
     readonly enableOpenAPI: boolean;
     readonly enableDatabase: boolean;
     readonly enableQueue: boolean;
+    /**
+     * Every capability id that was selected, including those without an
+     * `enable*` flag of their own (`events`, `security`). Read through
+     * `resolveProjectCapabilities`, never directly.
+     */
+    readonly capabilities?: readonly string[];
     readonly enableDocker: boolean;
     readonly installDeps: boolean;
     readonly initGit: boolean;

package/dist/src/types/scaffold.type.js

@@ -1,6 +1,7 @@
 /**
  * Type definitions for the Zudojs CLI scaffolding system.
  */
+import { resolveProjectCapabilities } from "../templates/shared/capability.template.js";
 /**
  * Converts ScaffoldOptions to ProjectConfiguration for runtime use.
  */
@@ -26,7 +27,7 @@ export function toProjectConfiguration(options) {
         workspace: {
             packageManager: options.packageManager,
         },
-        features: options.services,
+        features: resolveProjectCapabilities(options),
     };
 }
 //# sourceMappingURL=scaffold.type.js.map

package/dist/src/utils/utils.name.js

@@ -2,6 +2,12 @@ import { CLIValidationError } from "../errors/index.js";
 export function normalizeName(name) {
     return name
         .trim()
+        // Split camelCase and acronym boundaries before lowercasing, so
+        // `createBook` becomes `create-book` (class `CreateBookCommand`) rather
+        // than `createbook` (`CreatebookCommand`), and `HTTPServer` becomes
+        // `http-server`.
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
         .toLowerCase()
         .replace(/[^a-z0-9-]+/g, "-")
         // Trim leading/trailing dashes without the quadratic `-+$` scan: the

package/dist/src/utils/utils.writeGuard.d.ts

@@ -10,6 +10,11 @@
  * barrel merge done by `mergeBarrelExport`); anything else is a conflict
  * unless `--force` is passed.
  */
+/**
+ * Records that `fullPath` is edited in place on purpose (see
+ * {@link intendedEdits}). A no-op outside `captureWrites`.
+ */
+export declare function recordIntendedEdit(fullPath: string): void;
 /** The capture map of the current `captureWrites` call, if any. */
 export declare function activeWriteCapture(): Map<string, string> | undefined;
 /**

package/dist/src/utils/utils.writeGuard.js

@@ -14,6 +14,24 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync, readFileSync } from "node:fs";
 import { relative } from "node:path";
 const captured = new AsyncLocalStorage();
+/**
+ * Files a capture is allowed to change in place: marker insertions into
+ * `routes/index.ts`, `container.ts` and friends. They are edits by design,
+ * not overwrites, so the conflict check does not report them.
+ */
+const intendedEdits = new WeakMap();
+/**
+ * Records that `fullPath` is edited in place on purpose (see
+ * {@link intendedEdits}). A no-op outside `captureWrites`.
+ */
+export function recordIntendedEdit(fullPath) {
+    const capture = captured.getStore();
+    if (!capture)
+        return;
+    const edits = intendedEdits.get(capture) ?? new Set();
+    edits.add(fullPath);
+    intendedEdits.set(capture, edits);
+}
 /** The capture map of the current `captureWrites` call, if any. */
 export function activeWriteCapture() {
     return captured.getStore();
@@ -33,7 +51,12 @@ export async function captureWrites(run) {
  */
 export function findWriteConflicts(cwd, files) {
     const conflicts = [];
+    const edits = files instanceof Map
+        ? intendedEdits.get(files)
+        : undefined;
     for (const [path, content] of files) {
+        if (edits?.has(path))
+            continue;
         if (!existsSync(path))
             continue;
         const existing = readFileSync(path, "utf-8");

package/dist/src/wiring/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * zudojs-cli — Wiring
+ *
+ * Marker comments in generated projects and the edits `generate` and `add`
+ * make between them, and the dependencies generated code needs.
+ */
+export * from "./wiring.markers.js";
+export * from "./wiring.edits.js";
+export * from "./wiring.dependencies.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/wiring/index.js

@@ -0,0 +1,10 @@
+/**
+ * zudojs-cli — Wiring
+ *
+ * Marker comments in generated projects and the edits `generate` and `add`
+ * make between them, and the dependencies generated code needs.
+ */
+export * from "./wiring.markers.js";
+export * from "./wiring.edits.js";
+export * from "./wiring.dependencies.js";
+//# sourceMappingURL=index.js.map

package/dist/src/wiring/wiring.dependencies.d.ts

@@ -0,0 +1,29 @@
+/**
+ * zudojs-cli — Dependencies of generated code
+ *
+ * `generate command` and `generate query` wrote files importing
+ * `@zudojs/cqrs` into projects created without the cqrs capability, so the
+ * project stopped compiling (TS2307) and nothing said why. After a schematic
+ * writes its files, every `@zudojs/*` package they import is added to the
+ * nearest package.json that lacks it.
+ */
+/** One package.json edited by {@link ensureZudojsDependencies}. */
+export interface AddedDependencies {
+    /** package.json path, relative to the project root. */
+    readonly packageJson: string;
+    /** `@zudojs/*` names added to its dependencies. */
+    readonly added: readonly string[];
+}
+/** `@zudojs/*` package names imported by `source`. */
+export declare function importedZudojsPackages(source: string): string[];
+/**
+ * Adds every `@zudojs/*` package imported by `files` (paths relative to
+ * `root`, or absolute) to the dependencies of the package.json that owns
+ * each file, when it is missing. Existing entries are never changed.
+ */
+export declare function ensureZudojsDependencies(root: string, files: readonly string[]): AddedDependencies[];
+/** Human-readable lines describing {@link ensureZudojsDependencies} edits. */
+export declare function describeAddedDependencies(edits: readonly AddedDependencies[]): string[];
+/** "1 file" / "3 files". */
+export declare function fileCount(count: number): string;
+//# sourceMappingURL=wiring.dependencies.d.ts.map