zudojs-cli 0.1.2 → 1.0.0

package/dist/src/templates/monolith/monolith.template.js

@@ -24,6 +24,7 @@
  * │   ├── loggers/
  * │   ├── middlewares/
  * │   ├── models/
+ * │   ├── modules/
  * │   ├── repositories/
  * │   ├── routes/
  * │   ├── services/
@@ -37,16 +38,16 @@
  * └── README.md
  * ```
  */
+import { ZUDOJS_PACKAGES_VERSION } from "../../constants/index.js";
+import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
+import { RUNTIME_APP_DEPENDENCIES, moduleSpec, renderAppFile, renderModuleFile, renderServerFile, renderServiceFile, renderZudojsConfig, } from "../shared/index.js";
 export function generateMonolithFiles(options) {
     const name = options.projectName;
     const nameSlug = name.replace(/[^a-z0-9-]+/gi, "-").toLowerCase();
     const deps = [
-        "@zudojs/core",
-        "@zudojs/container",
+        ...RUNTIME_APP_DEPENDENCIES,
         "@zudojs/config",
-        "@zudojs/logger",
         "@zudojs/errors",
-        "@zudojs/constants",
         "@zudojs/types",
         "@zudojs/validation",
         "@zudojs/schema",
@@ -67,7 +68,12 @@ export function generateMonolithFiles(options) {
     if (options.enableOpenAPI) {
         deps.push("@zudojs/openapi");
     }
-    const devDeps = ["tsx", "typescript", "@types/node", "vitest"];
+    const devDeps = {
+        tsx: "^4.7.0",
+        typescript: "^5.7.0",
+        "@types/node": "^24.0.0",
+        vitest: "^3.0.0",
+    };
     const files = {};
     // Root files
     files["package.json"] =
@@ -77,16 +83,21 @@ export function generateMonolithFiles(options) {
             private: true,
             type: "module",
             license: "MIT",
+            zudojs: {
+                projectType: "backend",
+                architecture: "monolith",
+                features: [],
+            },
             scripts: {
-                dev: "node --import tsx watch src/server.ts",
+                dev: "tsx watch src/server.ts",
                 start: "node dist/server.js",
                 build: "tsc",
                 typecheck: "tsc --noEmit",
                 test: "vitest run",
                 lint: "tsc --noEmit",
             },
-            dependencies: Object.fromEntries([...new Set(deps)].map((d) => [d, "workspace:*"])),
-            devDependencies: Object.fromEntries(devDeps.map((d) => [d, "^1.0.0"])),
+            dependencies: Object.fromEntries([...new Set(deps)].map((d) => [d, ZUDOJS_PACKAGES_VERSION])),
+            devDependencies: devDeps,
         }, null, 2) + "\n";
     // tsconfig
     files["tsconfig.json"] = `{
@@ -94,9 +105,9 @@ export function generateMonolithFiles(options) {
     "target": "ES2024",
     "module": "Node16",
     "moduleResolution": "Node16",
-    "allowImportingTsExtensions": true,
+    "outDir": "dist",
+    "rootDir": "src",
     "strict": true,
-    "noEmit": true,
     "skipLibCheck": true,
     "esModuleInterop": true,
     "resolveJsonModule": true,
@@ -107,6 +118,11 @@ export function generateMonolithFiles(options) {
   "exclude": ["node_modules", "dist", "**/*.test.ts"]
 }
 `;
+    files["zudojs.config.ts"] = renderZudojsConfig({
+        projectName: nameSlug,
+        projectType: "backend",
+        architecture: "monolith",
+    });
     // Environment
     files[".env.example"] = `NODE_ENV=development
 PORT=3000
@@ -127,7 +143,7 @@ A Zudojs framework application.
 ## Getting Started
 
 \`\`\`bash
-${options.packageManager === "npm" ? "<SECRET_3ff5e0e0> run dev" : options.packageManager === "yarn" ? "yarn dev" : options.packageManager === "bun" ? "bun run dev" : "pnpm run dev"}
+${options.packageManager === "npm" ? "npm run dev" : options.packageManager === "yarn" ? "yarn dev" : options.packageManager === "bun" ? "bun run dev" : "pnpm run dev"}
 \`\`\`
 
 ## Structure
@@ -150,6 +166,7 @@ src/
 ├── loggers/         # Logger configuration
 ├── middlewares/     # HTTP middleware
 ├── models/          # Data models
+├── modules/         # Runtime modules
 ├── repositories/    # Data repositories
 ├── routes/          # HTTP routes
 ├── services/        # Application services
@@ -165,47 +182,24 @@ MIT
     // src/ entry points
     files["src/index.ts"] = `export { createApp } from "./app.js";
 `;
-    files["src/server.ts"] = `import { createApp } from "./app.js";
-import { createRuntime } from "@zudojs/runtime";
-import { logger } from "@zudojs/logger";
-
-const app = await createApp();
-
-const runtime = createRuntime({
-  onShutdown: async () => {
-    await app.stop();
-  },
-});
-
-await runtime.start();
-
-const server = await app.listen();
-
-process.on("SIGTERM", async () => {
-  await runtime.stop();
-  process.exit(0);
-});
-`;
-    files["src/app.ts"] = `import { logger } from "@zudojs/logger";
-import { createContainer } from "@zudojs/container";
-
-export async function createApp() {
-  const log = logger.child({ service: "app" });
-  const container = createContainer();
-
-  log.info("${nameSlug} v0.1.0 starting...");
-
-  return {
-    container,
-    listen: async () => {
-      log.info("Server started");
-    },
-    stop: async () => {
-      log.info("Shutting down...");
-    },
-  };
-}
-`;
+    files["src/server.ts"] = renderServerFile();
+    // Normalized: the name becomes a file path segment and a class name.
+    const moduleName = normalizeName(options.services[0] ?? "app") || "app";
+    const serviceClassName = `${toPascalCase(moduleName)}Service`;
+    const appModule = moduleSpec(moduleName, "./modules/index.js");
+    files["src/app.ts"] = renderAppFile({
+        applicationName: nameSlug,
+        modules: [appModule],
+    });
+    files[`src/modules/${moduleName}.module.ts`] = renderModuleFile({
+        module: appModule,
+        service: {
+            className: serviceClassName,
+            importPath: "../services/index.js",
+        },
+    });
+    files["src/modules/index.ts"] =
+        `export { ${appModule.className} } from "./${moduleName}.module.js";\n`;
     // Shared directories with empty index.ts
     const sharedDirs = [
         "configs",
@@ -232,23 +226,9 @@ export async function createApp() {
         files[`src/${dir}/index.ts`] = "";
     }
     // Services
-    const serviceName = options.services[0] ?? "app";
-    const serviceNamePascal = serviceName
-        .replace(/-([a-z])/g, (_m, c) => c.toUpperCase())
-        .replace(/^./, (c) => c.toUpperCase());
-    files[`src/services/${serviceName}.service.ts`] = `import { createLogger } from "@zudojs/logger";
-
-export class ${serviceNamePascal}Service {
-  private readonly logger = createLogger({ service: "${serviceName}" });
-
-  async initialize(): Promise<void> {
-    this.logger.info("${serviceName} service initialized");
-  }
-}
-`;
+    files[`src/services/${moduleName}.service.ts`] = renderServiceFile(moduleName);
     files["src/services/index.ts"] =
-        `export { ${serviceNamePascal}Service } from "./${serviceName}.service.js";
-`;
+        `export { ${serviceClassName} } from "./${moduleName}.service.js";\n`;
     // Controllers
     files["src/controllers/health.controller.ts"] =
         `export class HealthController {

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

@@ -0,0 +1,71 @@
+/**
+ * zudojs-cli — Shared Runtime App Templates
+ *
+ * Every architecture template assembles the same four framework pieces:
+ * a logger, a container, an event bus and a set of modules, handed to
+ * `createRuntime(dependencies, options)`.
+ *
+ * The emitted source is kept here rather than duplicated per architecture
+ * so it can be verified against the real `@zudojs/*` packages in one place.
+ * `tests/generatedProject.typecheck.test.ts` type-checks the output of every
+ * template against `packages/<name>/src/index.ts`, so any drift between these
+ * snippets and the framework API fails the CLI test suite.
+ */
+/** Packages every generated runtime entry point imports from. */
+export declare const RUNTIME_APP_DEPENDENCIES: readonly ["@zudojs/core", "@zudojs/runtime", "@zudojs/container", "@zudojs/events", "@zudojs/logger", "@zudojs/constants"];
+/** A module registered with the runtime by the generated `createApp`. */
+export interface RuntimeModuleSpec {
+    /** Slug used for the module id, file name and log messages. */
+    readonly name: string;
+    /** PascalCase class name. */
+    readonly className: string;
+    /** Import specifier the module class is imported from, relative to app.ts. */
+    readonly importPath: string;
+}
+/** Builds a module spec from a raw name. */
+export declare function moduleSpec(name: string, importPath: string): RuntimeModuleSpec;
+/**
+ * Renders `zudojs.config.ts`.
+ *
+ * The shape matches what the fullstack composer writes and what
+ * `zudojs generate` parses to detect the project architecture.
+ */
+export declare function renderZudojsConfig(options: {
+    readonly projectName: string;
+    readonly projectType: string;
+    readonly architecture: string;
+}): string;
+/**
+ * Renders `src/app.ts`: assembles the runtime dependencies and returns a
+ * started-on-demand `Runtime`.
+ */
+export declare function renderAppFile(options: {
+    readonly applicationName: string;
+    readonly modules: readonly RuntimeModuleSpec[];
+    /**
+     * Port this app is deployed on. Recorded as runtime metadata so the value
+     * in docker-compose.yml and the Dockerfile is also visible from the app.
+     */
+    readonly port?: number;
+}): string;
+/**
+ * Renders `src/server.ts`: the process entry point. Starts the runtime and
+ * stops it cleanly on SIGINT/SIGTERM.
+ */
+export declare function renderServerFile(appImportPath?: string): string;
+/**
+ * Renders a module class extending `BaseModule`.
+ *
+ * `BaseModule`'s constructor is protected, so the generated class declares a
+ * public constructor — without one the class cannot be instantiated.
+ */
+export declare function renderModuleFile(options: {
+    readonly module: RuntimeModuleSpec;
+    readonly service?: {
+        readonly className: string;
+        readonly importPath: string;
+    };
+}): string;
+/** Renders a service class using the real `createLogger` factory. */
+export declare function renderServiceFile(name: string): string;
+//# sourceMappingURL=appRuntime.template.d.ts.map

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

@@ -0,0 +1,209 @@
+/**
+ * zudojs-cli — Shared Runtime App Templates
+ *
+ * Every architecture template assembles the same four framework pieces:
+ * a logger, a container, an event bus and a set of modules, handed to
+ * `createRuntime(dependencies, options)`.
+ *
+ * The emitted source is kept here rather than duplicated per architecture
+ * so it can be verified against the real `@zudojs/*` packages in one place.
+ * `tests/generatedProject.typecheck.test.ts` type-checks the output of every
+ * template against `packages/<name>/src/index.ts`, so any drift between these
+ * snippets and the framework API fails the CLI test suite.
+ */
+import { toPascalCase } from "../../utils/utils.name.js";
+/** Packages every generated runtime entry point imports from. */
+export const RUNTIME_APP_DEPENDENCIES = [
+    "@zudojs/core",
+    "@zudojs/runtime",
+    "@zudojs/container",
+    "@zudojs/events",
+    "@zudojs/logger",
+    "@zudojs/constants",
+];
+/** Builds a module spec from a raw name. */
+export function moduleSpec(name, importPath) {
+    return {
+        name,
+        className: `${toPascalCase(name)}Module`,
+        importPath,
+    };
+}
+/** Emits a string as a TypeScript string literal that cannot break out. */
+function literal(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Renders `zudojs.config.ts`.
+ *
+ * The shape matches what the fullstack composer writes and what
+ * `zudojs generate` parses to detect the project architecture.
+ */
+export function renderZudojsConfig(options) {
+    return `/**
+ * Zudojs project configuration.
+ *
+ * Read by the \`zudojs\` CLI to detect this project's architecture.
+ */
+
+export default {
+  name: ${literal(options.projectName)},
+  projectType: ${literal(options.projectType)},
+  architecture: ${literal(options.architecture)},
+};
+`;
+}
+/**
+ * Renders `src/app.ts`: assembles the runtime dependencies and returns a
+ * started-on-demand `Runtime`.
+ */
+export function renderAppFile(options) {
+    const imports = [...options.modules]
+        .map((m) => `import { ${m.className} } from ${literal(m.importPath)};`)
+        .join("\n");
+    // An empty array literal would make the loop variable `never`, so the
+    // registration loop is only emitted when there is at least one module.
+    const registration = options.modules.length > 0
+        ? `  for (const module of [
+${options.modules.map((m) => `    new ${m.className}(),`).join("\n")}
+  ]) {
+    modules.set(module.id, module);
+  }
+`
+        : "";
+    const metadata = options.port === undefined
+        ? ""
+        : `\n      metadata: { port: ${options.port} },`;
+    return `import type { Environment } from "@zudojs/constants";
+import { createContainer } from "@zudojs/container";
+import type { Module } from "@zudojs/core";
+import { createEventBus } from "@zudojs/events";
+import { createLogger } from "@zudojs/logger";
+import { createRuntime, type Runtime } from "@zudojs/runtime";
+${imports}
+
+const ENVIRONMENTS: readonly Environment[] = [
+  "development",
+  "test",
+  "staging",
+  "production",
+];
+
+/** Narrows NODE_ENV to a framework Environment without an unchecked cast. */
+function resolveEnvironment(): Environment {
+  const value = process.env["NODE_ENV"];
+  return ENVIRONMENTS.find((candidate) => candidate === value) ?? "development";
+}
+
+/**
+ * Assembles the application runtime.
+ *
+ * \`createRuntime\` takes two arguments: the dependencies the runtime and its
+ * modules share, and the options describing this application.
+ */
+export function createApp(): Runtime {
+  const logger = createLogger({ name: ${literal(options.applicationName)} });
+  const container = createContainer();
+  const eventBus = createEventBus();
+
+  const modules = new Map<string, Module>();
+${registration}
+  const runtime = createRuntime(
+    { modules, logger, container, eventBus },
+    {
+      applicationName: ${literal(options.applicationName)},
+      applicationVersion: "0.1.0",
+      environment: resolveEnvironment(),
+      // Signals are handled explicitly in server.ts.
+      handleSignals: false,${metadata}
+    },
+  );
+
+  runtime.registerReadinessCheck("modules", () => runtime.state === "running");
+
+  return runtime;
+}
+`;
+}
+/**
+ * Renders `src/server.ts`: the process entry point. Starts the runtime and
+ * stops it cleanly on SIGINT/SIGTERM.
+ */
+export function renderServerFile(appImportPath = "./app.js") {
+    return `import { createApp } from ${literal(appImportPath)};
+
+const runtime = createApp();
+
+await runtime.start();
+
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.once(signal, () => {
+    void runtime
+      .stop()
+      .then(() => {
+        process.exit(0);
+      })
+      .catch((error: unknown) => {
+        console.error(error);
+        process.exit(1);
+      });
+  });
+}
+`;
+}
+/**
+ * Renders a module class extending `BaseModule`.
+ *
+ * `BaseModule`'s constructor is protected, so the generated class declares a
+ * public constructor — without one the class cannot be instantiated.
+ */
+export function renderModuleFile(options) {
+    const { module, service } = options;
+    const serviceImport = service
+        ? `import { ${service.className} } from ${literal(service.importPath)};\n`
+        : "";
+    const serviceField = service
+        ? `  private readonly service = new ${service.className}();\n\n`
+        : "";
+    const serviceInit = service ? "    await this.service.initialize();\n" : "";
+    return `import { BaseModule, type ModuleContext } from "@zudojs/core";
+${serviceImport}
+/**
+ * ${module.name} module.
+ *
+ * Registered with the runtime in app.ts. The runtime calls onInitialize
+ * during start and onShutdown during stop.
+ */
+export class ${module.className} extends BaseModule {
+  public readonly id = ${literal(module.name)};
+  public readonly name = ${literal(module.name)};
+
+${serviceField}  public constructor() {
+    super({ version: "0.1.0" });
+  }
+
+  public override async onInitialize(context: ModuleContext): Promise<void> {
+${serviceInit}    context.logger.info(${literal(`${module.name} module initialized`)});
+  }
+
+  public override async onShutdown(context: ModuleContext): Promise<void> {
+    context.logger.info(${literal(`${module.name} module stopped`)});
+  }
+}
+`;
+}
+/** Renders a service class using the real `createLogger` factory. */
+export function renderServiceFile(name) {
+    const className = `${toPascalCase(name)}Service`;
+    return `import { createLogger } from "@zudojs/logger";
+
+export class ${className} {
+  private readonly logger = createLogger({ name: ${literal(`${name}-service`)} });
+
+  public async initialize(): Promise<void> {
+    this.logger.info(${literal(`${name} service initialized`)});
+  }
+}
+`;
+}
+//# sourceMappingURL=appRuntime.template.js.map

package/dist/src/templates/shared/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * zudojs-cli — Shared Template Fragments
+ */
+export * from "./appRuntime.template.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/templates/shared/index.js

@@ -0,0 +1,5 @@
+/**
+ * zudojs-cli — Shared Template Fragments
+ */
+export * from "./appRuntime.template.js";
+//# sourceMappingURL=index.js.map

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

@@ -3,8 +3,8 @@
  *
  * Shared utility functions for the CLI scaffolding system.
  */
-export { writeFile, writeFileTree } from "./utils.fileSystem.js";
-export { normalizeName } from "./utils.name.js";
+export { writeFile, writeFileTree, mergeBarrelExport, } from "./utils.fileSystem.js";
+export { normalizeName, toPascalCase, toCamelCase } from "./utils.name.js";
 export { detectArchitecture } from "./utils.detect.js";
-export { execCommand } from "./utils.exec.js";
+export { execCommand, runStreaming } from "./utils.exec.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/utils/index.js

@@ -3,8 +3,8 @@
  *
  * Shared utility functions for the CLI scaffolding system.
  */
-export { writeFile, writeFileTree } from "./utils.fileSystem.js";
-export { normalizeName } from "./utils.name.js";
+export { writeFile, writeFileTree, mergeBarrelExport, } from "./utils.fileSystem.js";
+export { normalizeName, toPascalCase, toCamelCase } from "./utils.name.js";
 export { detectArchitecture } from "./utils.detect.js";
-export { execCommand } from "./utils.exec.js";
+export { execCommand, runStreaming } from "./utils.exec.js";
 //# sourceMappingURL=index.js.map

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

@@ -2,5 +2,23 @@ export interface ExecResult {
     readonly stdout: string;
     readonly stderr: string;
 }
-export declare function execCommand(file: string, args: readonly string[], cwd: string): Promise<ExecResult>;
+export interface ExecOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly timeout?: number;
+}
+/**
+ * Runs a short-lived command and buffers its output.
+ *
+ * Suitable for quick probes (version checks, git commands). Do NOT use this
+ * for long-running processes such as dev servers or dependency installs —
+ * use {@link runStreaming} instead.
+ */
+export declare function execCommand(file: string, args: readonly string[], cwd: string, options?: ExecOptions): Promise<ExecResult>;
+/**
+ * Runs a command with inherited stdio and no timeout.
+ *
+ * Use for long-running processes (dev servers) and for dependency installs
+ * so output streams to the user and slow commands are not killed.
+ */
+export declare function runStreaming(file: string, args: readonly string[], cwd: string, options?: ExecOptions): Promise<void>;
 //# sourceMappingURL=utils.exec.d.ts.map

package/dist/src/utils/utils.exec.js

@@ -1,11 +1,45 @@
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
-export async function execCommand(file, args, cwd) {
+/**
+ * Runs a short-lived command and buffers its output.
+ *
+ * Suitable for quick probes (version checks, git commands). Do NOT use this
+ * for long-running processes such as dev servers or dependency installs —
+ * use {@link runStreaming} instead.
+ */
+export async function execCommand(file, args, cwd, options = {}) {
     const { stdout, stderr } = await execFileAsync(file, args, {
         cwd,
-        timeout: 120000,
+        timeout: options.timeout ?? 120000,
+        ...(options.env ? { env: options.env } : {}),
     });
     return { stdout, stderr };
 }
+/**
+ * Runs a command with inherited stdio and no timeout.
+ *
+ * Use for long-running processes (dev servers) and for dependency installs
+ * so output streams to the user and slow commands are not killed.
+ */
+export function runStreaming(file, args, cwd, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(file, Array.from(args), {
+            cwd,
+            stdio: "inherit",
+            ...(options.env ? { env: options.env } : {}),
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("exit", (code, signal) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command "${file} ${args.join(" ")}" exited with ${signal ? `signal ${signal}` : `code ${code}`}`));
+            }
+        });
+    });
+}
 //# sourceMappingURL=utils.exec.js.map

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

@@ -1,3 +1,9 @@
 export declare function writeFile(basePath: string, filePath: string, content: string): Promise<void>;
 export declare function writeFileTree(basePath: string, files: Readonly<Record<string, string>>): Promise<void>;
+/**
+ * Returns the content of a barrel index file with `exportLine` appended,
+ * preserving any existing exports. If the line is already present, the
+ * existing content is returned unchanged.
+ */
+export declare function mergeBarrelExport(basePath: string, indexPath: string, exportLine: string): string;
 //# sourceMappingURL=utils.fileSystem.d.ts.map

package/dist/src/utils/utils.fileSystem.js

@@ -1,3 +1,4 @@
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, writeFile as writeFileAsync } from "node:fs/promises";
 import { dirname, join, relative } from "node:path";
 function assertSafePath(basePath, filePath) {
@@ -18,4 +19,22 @@ export async function writeFileTree(basePath, files) {
         await writeFile(basePath, filePath, content);
     }
 }
+/**
+ * Returns the content of a barrel index file with `exportLine` appended,
+ * preserving any existing exports. If the line is already present, the
+ * existing content is returned unchanged.
+ */
+export function mergeBarrelExport(basePath, indexPath, exportLine) {
+    const fullPath = join(basePath, indexPath);
+    const line = exportLine.trim();
+    let existing = "";
+    if (existsSync(fullPath)) {
+        existing = readFileSync(fullPath, "utf-8");
+    }
+    if (existing.includes(line)) {
+        return existing;
+    }
+    const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    return existing + separator + line + "\n";
+}
 //# sourceMappingURL=utils.fileSystem.js.map

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

@@ -1,2 +1,28 @@
 export declare function normalizeName(name: string): string;
+/** Converts an arbitrary name to PascalCase (safe as a TS identifier). */
+export declare function toPascalCase(name: string): string;
+/** Converts an arbitrary name to camelCase (safe as a TS identifier). */
+export declare function toCamelCase(name: string): string;
+/**
+ * Pattern for names that may be used verbatim as a path segment
+ * (`--service`, `--module`, manifest service entries).
+ */
+export declare const SAFE_PATH_SEGMENT: RegExp;
+/**
+ * Validates a name that a generator will normalize into file paths and
+ * identifiers.
+ *
+ * `normalizeName` strips everything outside `[a-z0-9-]`, so a name such as
+ * `"..."` or `"!!!"` collapses to the empty string and the generator writes
+ * `src//.event.ts` with an anonymous exported class. Reject it up front.
+ */
+export declare function assertGeneratableName(name: string, kind?: string): string;
+/**
+ * Validates a value that is interpolated verbatim into a generated file path.
+ *
+ * Unlike {@link assertGeneratableName} this does not normalize: the value is
+ * used as-is, so `..` or a path separator here would let a generator write
+ * outside its base path.
+ */
+export declare function assertSafePathSegment(value: string, kind?: string): string;
 //# sourceMappingURL=utils.name.d.ts.map