@dunx/create-app 0.4.0 → 0.5.0

package/dist/chunk-jgd5dmqh.js

@@ -0,0 +1,698 @@
+// @bun
+// src/features.ts
+var CONFIG_GROUPS = Object.freeze({
+  port: {
+    schema: [
+      "PORT: z.coerce.number().int().min(0).max(65535).default(3000),"
+    ],
+    field: "readonly port: number;",
+    map: "port: value.PORT,",
+    env: [{ name: "PORT", value: "3000" }]
+  },
+  appName: {
+    schema: [],
+    field: "readonly appName: string;",
+    map: "appName: '__DUNX_APP_NAME__',",
+    env: []
+  },
+  log: {
+    schema: [
+      "LOG_LEVEL: z.enum(LogLevel).default(LogLevel.INFO),",
+      "/** Unset means console only. Set it to also append JSON to a rotating file. */",
+      "LOG_FILE: z.string().optional(),"
+    ],
+    field: "readonly log: { readonly level: LogLevel; readonly file: string | undefined };",
+    map: "log: { level: value.LOG_LEVEL, file: value.LOG_FILE },",
+    env: [{ name: "LOG_LEVEL", value: "info" }]
+  },
+  corsOrigin: {
+    schema: ["CORS_ORIGIN: z.string().default('https://example.com'),"],
+    field: "readonly corsOrigin: string;",
+    map: "corsOrigin: value.CORS_ORIGIN,",
+    env: [{ name: "CORS_ORIGIN", value: "https://example.com" }]
+  },
+  database: {
+    schema: [
+      "/** `:memory:` needs no server and leaves nothing behind, so restarts are clean. */",
+      "DATABASE_FILE: z.string().default(':memory:'),"
+    ],
+    field: "readonly database: { readonly file: string };",
+    map: "database: { file: value.DATABASE_FILE },",
+    env: [{ name: "DATABASE_FILE", value: ":memory:" }]
+  },
+  redis: {
+    schema: [
+      "/** Absent is fine: the cache routes report themselves degraded instead of failing. */",
+      "REDIS_URL: z.string().optional(),"
+    ],
+    field: "readonly redis: { readonly url: string | undefined };",
+    map: "redis: { url: value.REDIS_URL },",
+    env: [{ name: "REDIS_URL", value: "redis://localhost:6379" }]
+  },
+  images: {
+    schema: [
+      "IMAGE_QUALITY: z.coerce.number().int().min(1).max(100).default(82),"
+    ],
+    field: "readonly images: { readonly quality: number };",
+    map: "images: { quality: value.IMAGE_QUALITY },",
+    env: [{ name: "IMAGE_QUALITY", value: "82" }]
+  },
+  auth: {
+    schema: [
+      "/** better-auth signs session cookies with this. 32 characters is its own minimum. */",
+      "AUTH_SECRET: z.string().min(32).default('dunx-development-secret-not-for-production'),"
+    ],
+    field: "readonly auth: { readonly secret: string };",
+    map: "auth: { secret: value.AUTH_SECRET },",
+    env: [
+      {
+        name: "AUTH_SECRET",
+        value: "change-me-to-at-least-32-characters-long"
+      }
+    ]
+  },
+  seedUsers: {
+    schema: [],
+    field: "readonly seedUsers: readonly string[];",
+    map: "seedUsers: ['ada', 'grace'],",
+    env: []
+  },
+  authorization: {
+    schema: [],
+    field: "readonly authorization: { readonly enabled: boolean };",
+    map: "authorization: { enabled: true },",
+    env: []
+  }
+});
+var BASE_CONFIG = ["appName", "port", "log"];
+var FEATURES = [
+  {
+    name: "notes",
+    source: "notes",
+    summary: "CRUD routes with zod validation. The smallest real feature.",
+    requires: [],
+    module: { klass: "NotesModule", from: "./notes/notes.module.js" },
+    dependencies: ["zod"],
+    config: []
+  },
+  {
+    name: "openapi",
+    source: "docs",
+    summary: "OpenAPI 3.1 from the routes own schemas, plus the explorer page.",
+    requires: [],
+    module: { klass: "DocsModule", from: "./docs/docs.module.js" },
+    dependencies: ["@dunx/openapi", "zod"],
+    config: []
+  },
+  {
+    name: "http",
+    source: "http",
+    summary: "CORS, a request-logging middleware and error mapping.",
+    requires: [],
+    module: { klass: "HttpModule", from: "./http/http.module.js" },
+    dependencies: [],
+    config: ["corsOrigin"]
+  },
+  {
+    name: "guards",
+    source: "guards",
+    summary: "Route guards with @Roles and @Public, and a protected controller.",
+    requires: [],
+    module: { klass: "GuardsModule", from: "./guards/guards.module.js" },
+    dependencies: ["zod"],
+    config: ["authorization"]
+  },
+  {
+    name: "database",
+    source: "database",
+    summary: "drizzle over bun:sqlite, with a schema, seeds and migrations.",
+    requires: [],
+    module: { klass: "DatabaseModule", from: "./database/database.module.js" },
+    dependencies: ["@dunx/infra", "drizzle-orm"],
+    config: ["database"]
+  },
+  {
+    name: "users",
+    source: "users",
+    summary: "A repository, a service and validated routes over the database.",
+    requires: ["database"],
+    module: { klass: "UsersModule", from: "./users/users.module.js" },
+    dependencies: ["@dunx/infra", "drizzle-orm", "zod"],
+    config: ["appName", "seedUsers"]
+  },
+  {
+    name: "auth",
+    source: "auth",
+    summary: "better-auth mounted, with SessionGuard and an audit trail.",
+    requires: ["database"],
+    module: { klass: "AccountsModule", from: "./auth/auth.module.js" },
+    dependencies: ["@dunx/auth", "better-auth", "drizzle-orm"],
+    config: ["auth", "port"]
+  },
+  {
+    name: "cache",
+    source: "cache",
+    summary: "Bun.RedisClient behind a session store, degrading when absent.",
+    requires: [],
+    module: { klass: "CacheModule", from: "./cache/cache.module.js" },
+    dependencies: ["@dunx/infra"],
+    config: ["redis"],
+    service: "Redis or Valkey"
+  },
+  {
+    name: "websockets",
+    source: "chat",
+    summary: "A @Gateway with @OnMessage events, PubSub and a Redis relay.",
+    requires: [],
+    module: { klass: "ChatModule", from: "./chat/chat.module.js" },
+    dependencies: ["@dunx/infra"],
+    config: [],
+    service: "Redis or Valkey, for multi-node fan-out only"
+  },
+  {
+    name: "images",
+    source: "pictures",
+    summary: "Bun.Image resizing and format conversion behind a route.",
+    requires: [],
+    module: { klass: "PicturesModule", from: "./pictures/pictures.module.js" },
+    dependencies: ["@dunx/infra"],
+    config: ["images"]
+  },
+  {
+    name: "files",
+    source: "storage",
+    summary: "Uploads and downloads on Bun.file, with a workspace root.",
+    requires: [],
+    module: { klass: "StorageModule", from: "./storage/storage.module.js" },
+    dependencies: ["@dunx/infra"],
+    config: []
+  },
+  {
+    name: "jobs",
+    source: "jobs",
+    summary: "bullmq queues and a worker, over Bun.RedisClient.",
+    requires: ["images"],
+    module: { klass: "JobsModule", from: "./jobs/jobs.module.js" },
+    dependencies: ["@dunx/infra", "bullmq", "ioredis"],
+    config: ["redis"],
+    service: "Redis or Valkey"
+  },
+  {
+    name: "health",
+    source: "health",
+    summary: "One endpoint reporting which parts are live and which degraded.",
+    requires: ["cache", "database"],
+    module: { klass: "HealthModule", from: "./health/health.module.js" },
+    dependencies: ["@dunx/infra"],
+    config: ["appName"]
+  }
+];
+var featureNames = FEATURES.map((feature) => feature.name);
+var byName = new Map(FEATURES.map((feature) => [feature.name, feature]));
+
+class UnknownFeatureError extends Error {
+  name = "UnknownFeatureError";
+}
+var resolveFeatures = (requested) => {
+  const unknown = requested.filter((name) => !byName.has(name));
+  if (unknown.length > 0) {
+    throw new UnknownFeatureError(`Unknown feature${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")}. ` + `Available: ${featureNames.join(", ")}.`);
+  }
+  const ordered = [];
+  const seen = new Set;
+  const rank = new Map(FEATURES.map((feature, at) => [feature.name, at]));
+  const visit = (name) => {
+    if (seen.has(name))
+      return;
+    seen.add(name);
+    const feature = byName.get(name);
+    if (!feature)
+      return;
+    for (const required of [...feature.requires].sort((left, right) => (rank.get(left) ?? 0) - (rank.get(right) ?? 0))) {
+      visit(required);
+    }
+    ordered.push(feature);
+  };
+  for (const feature of FEATURES) {
+    if (requested.includes(feature.name))
+      visit(feature.name);
+  }
+  return ordered;
+};
+var impliedBy = (requested, resolved) => resolved.map((feature) => feature.name).filter((name) => !requested.includes(name));
+
+// src/scaffold.ts
+import { existsSync, readdirSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+var {Glob } = globalThis.Bun;
+
+// src/generate.ts
+var HEADER = (name) => `// Generated by @dunx/create-app for ${name}. Yours to edit.
+`;
+var uniq = (values) => [...new Set(values)];
+var configGroupsFor = (features) => {
+  const wanted = uniq([
+    ...BASE_CONFIG,
+    ...features.flatMap((feature) => feature.config)
+  ]);
+  return Object.keys(CONFIG_GROUPS).filter((group) => wanted.includes(group));
+};
+var dependenciesFor = (features) => uniq([
+  "@dunx/core",
+  "@dunx/http",
+  "@dunx/transform",
+  "@dunx/infra",
+  ...features.flatMap((feature) => feature.dependencies)
+]).sort();
+var DUNX = /^@dunx\//;
+var manifest = (features) => {
+  const deps = dependenciesFor(features);
+  const dependencies = {};
+  for (const dep of deps) {
+    dependencies[dep] = DUNX.test(dep) ? "__DUNX_VERSION__" : versionOf(dep);
+  }
+  const scripts = {
+    start: "bun src/main.ts",
+    test: "bun test",
+    typecheck: "tsc --noEmit"
+  };
+  if (features.some((feature) => feature.name === "jobs")) {
+    scripts["worker"] = "bun src/worker.ts";
+  }
+  return `${JSON.stringify({
+    name: "__DUNX_APP_NAME__",
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts,
+    dependencies,
+    devDependencies: {
+      "@dunx/testing": "__DUNX_VERSION__",
+      "@types/bun": ">=1.3.0",
+      typescript: "^5.7.0"
+    },
+    engines: { bun: ">=1.3.0" }
+  }, null, 2)}
+`;
+};
+var THIRD_PARTY = Object.freeze({
+  zod: "^4.4.3",
+  "drizzle-orm": "^0.45.2",
+  "better-auth": "^1.6.25",
+  bullmq: "^6.0.5",
+  ioredis: "^6.0.0"
+});
+var versionOf = (dep) => THIRD_PARTY[dep] ?? "latest";
+var appModule = (name, features) => {
+  const needsLogger = true;
+  const imports = [
+    "import { ConfigModule, Module } from '@dunx/core';",
+    ...needsLogger ? ["import { LoggerModule } from '@dunx/infra/logger';"] : [],
+    "import { AppConfigService, validate } from './config.js';",
+    ...features.map((feature) => `import { ${feature.module.klass} } from '${feature.module.from}';`)
+  ];
+  const moduleImports = [
+    "ConfigModule.forRoot({ validate, as: AppConfigService }),",
+    "// The level comes from the validated config, which is the one thing a",
+    "// zero-argument `forRoot` function cannot reach.",
+    "LoggerModule.forRootAsync(",
+    "  {",
+    "    useFactory: (config: AppConfigService) => ({",
+    "      name: config.get('appName'),",
+    "      level: config.get('log').level,",
+    "    }),",
+    "    inject: [AppConfigService] as const,",
+    "  },",
+    "  { captureGlobalErrors: true },",
+    "),",
+    ...features.map((feature) => `${feature.module.klass},`)
+  ];
+  return `${HEADER(name)}${imports.join(`
+`)}
+
+/**
+ * Import order is construction order, and shutdown runs in reverse - so config and
+ * the logger are built first and torn down last, and anything a feature depends on
+ * outlives it.
+ */
+@Module({
+  imports: [
+${moduleImports.map((line) => `    ${line}`).join(`
+`)}
+  ],
+})
+export class AppModule {}
+`;
+};
+var config = (name, groups) => {
+  const chosen = groups.map((group) => [group, CONFIG_GROUPS[group]]).filter((entry) => entry[1] !== undefined);
+  const schema = chosen.flatMap(([, group]) => group.schema);
+  const needsLogLevel = groups.includes("log");
+  return `${HEADER(name)}import { ConfigService, type ConfigSource${needsLogLevel ? ", LogLevel" : ""} } from '@dunx/core';
+import { z } from 'zod';
+
+/**
+ * One validation function, which is the whole \`ConfigModule\` contract. dunx does
+ * not pick the library - this is zod because the routes already use it, and a
+ * hand-written function that throws would work identically.
+ *
+ * \`.default()\` is where a value comes from when the variable is unset, so a clean
+ * checkout boots with no \`.env\` at all. Bun loads \`.env\` and \`.env.local\` itself,
+ * so there is nothing here that reads a file.
+ */
+const envSchema = z.object({
+${schema.map((line) => `  ${line}`).join(`
+`)}
+});
+
+export interface AppConfig {
+${chosen.map(([, group]) => `  ${group.field}`).join(`
+`)}
+}
+
+/**
+ * One name for the typed config everywhere. A subclass rather than
+ * \`ConfigService<AppConfig>\` at each site because a factory's \`inject: [...]\`
+ * carries no type argument - the class does, and it is a real runtime value, so it
+ * is both a precise token and a usable constructor annotation.
+ */
+export class AppConfigService extends ConfigService<AppConfig> {}
+
+/** The one broker channel the websocket relay carries every topic on. */
+export const RELAY_CHANNEL = '__DUNX_APP_NAME__:ws';
+
+/** Flat variables in, a shaped object out. Nothing downstream reads \`Bun.env\`. */
+export const validate = (env: ConfigSource): AppConfig => {
+  const parsed = envSchema.safeParse(env);
+  if (!parsed.success) {
+    const issues = parsed.error.issues
+      .map((issue) => \`\${issue.path.join('.') || '(root)'}: \${issue.message}\`)
+      .join('\\n - ');
+    throw new Error(\`Configuration is invalid:\\n - \${issues}\`);
+  }
+  const value = parsed.data;
+
+  return {
+${chosen.map(([, group]) => `    ${group.map}`).join(`
+`)}
+  };
+};
+`;
+};
+var has = (features, name) => features.some((feature) => feature.name === name);
+var bootstrap = (name, features) => {
+  const openapi = has(features, "openapi");
+  const websockets = has(features, "websockets");
+  const http = has(features, "http");
+  const imports = [
+    `import { HttpFactory${websockets ? ", RedisRelay" : ""}, type HttpApp } from '@dunx/http';`,
+    ...openapi ? ["import { OpenApiModule } from '@dunx/openapi';"] : [],
+    "import { AppModule } from './app.module.js';",
+    `import { ${[
+      ...http ? ["AppConfigService"] : [],
+      ...websockets ? ["RELAY_CHANNEL"] : []
+    ].join(", ")} } from './config.js';`,
+    ...http ? ["import { RequestLoggerMiddleware } from './http/request-log.js';"] : []
+  ].filter((line) => !line.includes("{  }"));
+  const root = openapi ? `OpenApiModule.forRoot({
+      title: '__DUNX_APP_NAME__',
+      version: '0.1.0',
+      root: AppModule,
+    })` : "AppModule";
+  const options = websockets ? [
+    "// Multi-node websocket fan-out on `Bun.RedisClient`, so it costs no",
+    "// dependency. With no Redis running this degrades to single-process",
+    "// behaviour, logs one warning, and the app still boots.",
+    "websocket: { idleTimeout: 30 },",
+    "relay: new RedisRelay({ connectionTimeout: 500 }),",
+    "relayChannel: RELAY_CHANNEL,"
+  ] : [];
+  const shaping = [
+    "app.setGlobalPrefix('api');",
+    ...http ? [
+      "app.use(RequestLoggerMiddleware);",
+      "app.set('trust proxy', true);",
+      "app.enableCors({",
+      "  origin: app.get(AppConfigService).get('corsOrigin'),",
+      "  credentials: true,",
+      "  maxAge: 600,",
+      "});"
+    ] : []
+  ];
+  return `${HEADER(name)}${imports.join(`
+`)}
+
+/**
+ * One app, built the same way for \`bun start\` and for the tests - so what the
+ * tests exercise is what actually serves.
+ *
+ * \`create()\` boots the container and discovers routes and gateways; \`listen()\` is
+ * what builds the \`Bun.serve\` route table. Everything between the two still gets to
+ * shape it, and after \`listen()\` every one of those throws.
+ */
+export const createApp = async (): Promise<HttpApp> => {
+  const app = await HttpFactory.create(
+    ${root}${options.length === 0 ? `,
+` : `,
+    {
+${options.map((line) => `      ${line}`).join(`
+`)}
+    },
+`}  );
+
+${shaping.map((line) => `  ${line}`).join(`
+`)}
+
+  return app;
+};
+`;
+};
+var main = (name, features) => {
+  const health = has(features, "health");
+  const openapi = has(features, "openapi");
+  const lines = [
+    ...openapi ? [
+      "logger.info(`docs    ${new URL('api/docs', url).href}`);",
+      "logger.info(`openapi ${new URL('api/openapi.json', url).href}`);"
+    ] : [],
+    ...health ? ["logger.info(`health  ${new URL('api/health', url).href}`);"] : []
+  ];
+  return `${HEADER(name)}import { Logger } from '@dunx/core';
+import { createApp } from './bootstrap.js';
+import { AppConfigService } from './config.js';
+
+async function bootstrap(): Promise<void> {
+  const app = await createApp();
+  app.enableShutdownHooks();
+
+  const config = app.get(AppConfigService);
+  const logger = app.get(Logger);
+  const url = await app.listen(config.get('port'));
+
+  logger.info(\`listening on \${url}\`);
+${lines.map((line) => `  ${line}`).join(`
+`)}${lines.length > 0 ? `
+` : ""}
+  // Nothing else to do: the server holds the process open, and the shutdown hooks
+  // resolve this once a signal arrives.
+  await app.closed;
+}
+
+bootstrap().catch((error: unknown) => {
+  console.error('failed to start', error);
+  process.exit(1);
+});
+`;
+};
+var worker = (name) => `${HEADER(name)}import { AppFactory } from '@dunx/core';
+import { AppModule } from './app.module.js';
+
+/**
+ * A queue needs a process to drain it, and it is deliberately not the web one: a
+ * worker that shares the server's event loop competes with request handling.
+ */
+const app = await AppFactory.create(AppModule);
+app.enableShutdownHooks();
+await app.closed;
+`;
+var envExample = (groups) => {
+  const lines = groups.flatMap((group) => CONFIG_GROUPS[group]?.env ?? []).map((entry) => `${entry.name}=${entry.value}`);
+  return lines.length === 0 ? `# Every variable has a default, so this file is optional.
+` : `# Every variable here has a default, so the app boots with no .env at all.
+${lines.join(`
+`)}
+`;
+};
+var readme = (name, features) => {
+  const services = features.filter((feature) => feature.service !== undefined);
+  return `# ${name}
+
+Scaffolded with \`bunx @dunx/create-app\`.
+
+\`\`\`bash
+bun install
+bun run start
+\`\`\`
+
+## What is wired up
+
+${features.length === 0 ? "Nothing beyond the base app." : features.map((feature) => `- **${feature.name}** - ${feature.summary}`).join(`
+`)}
+
+${services.length === 0 ? "" : `## Services
+
+These features need something running. Each one degrades rather than failing the
+boot, so the app still starts without them.
+
+${services.map((feature) => `- **${feature.name}** needs ${feature.service}`).join(`
+`)}
+
+`}## Layout
+
+- \`src/main.ts\` - the entry point
+- \`src/bootstrap.ts\` - builds the app; shared by \`start\` and the tests
+- \`src/app.module.ts\` - the root module, importing every feature
+- \`src/config.ts\` - one validation function, flat env in and a shaped object out
+${features.map((feature) => `- \`src/${feature.source}/\` - ${feature.name}`).join(`
+`)}
+
+\`main.ts\`, \`bootstrap.ts\`, \`app.module.ts\` and \`config.ts\` were generated for the
+features you chose; everything else is copied from dunx's \`examples/full\`, which is
+run and toured in CI on every push. The \`*.demo.ts\` files are that example's
+scripted walkthroughs - delete one and its \`providers\` entry when you do not want it.
+
+## Constructor injection
+
+\`bunfig.toml\` preloads \`@dunx/transform\`, which records each class's constructor
+parameter types so the container can resolve them. Without that line providers are
+built with no arguments and boot fails saying so.
+`;
+};
+
+// src/scaffold.ts
+var TEMPLATES = Object.freeze(["minimal"]);
+var VERSION_PLACEHOLDER = "__DUNX_VERSION__";
+var RENAMED = Object.freeze({
+  _gitignore: ".gitignore",
+  "_bunfig.toml": "bunfig.toml"
+});
+var IGNORED_WHEN_EMPTY = new Set([
+  ".DS_Store",
+  ".git",
+  ".gitkeep",
+  "LICENSE"
+]);
+
+class ScaffoldError extends Error {
+  name = "ScaffoldError";
+}
+var templatesRoot = () => resolve(dirname(fileURLToPath(import.meta.url)), "..", "templates");
+var isValidPackageName = (name) => /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name);
+var readPackageVersion = async () => {
+  const file = Bun.file(join(templatesRoot(), "..", "package.json"));
+  const json = await file.json();
+  return json.version ?? "0.0.0";
+};
+var fill = (contents, name, version) => contents.replaceAll(VERSION_PLACEHOLDER, version).replaceAll("__DUNX_APP_NAME__", name);
+var generated = (name, features) => {
+  const groups = configGroupsFor(features);
+  const files = {
+    "package.json": manifest(features),
+    "README.md": readme(name, features),
+    ".env.example": envExample(groups),
+    "src/main.ts": main(name, features),
+    "src/bootstrap.ts": bootstrap(name, features),
+    "src/app.module.ts": appModule(name, features),
+    "src/config.ts": config(name, groups)
+  };
+  if (features.some((feature) => feature.name === "jobs")) {
+    files["src/worker.ts"] = worker(name);
+  }
+  return files;
+};
+var scaffold = async (options) => {
+  const template = options.template ?? "minimal";
+  if (!TEMPLATES.includes(template)) {
+    throw new ScaffoldError(`Unknown template "${template}". Available: ${TEMPLATES.join(", ")}.`);
+  }
+  const requested = options.features ?? [];
+  let features = [];
+  try {
+    features = resolveFeatures(requested);
+  } catch (error) {
+    throw new ScaffoldError(error instanceof Error ? error.message : String(error));
+  }
+  const composing = features.length > 0;
+  const directory = resolve(options.cwd ?? process.cwd(), options.target);
+  const name = options.name ?? basename(directory);
+  if (!isValidPackageName(name)) {
+    throw new ScaffoldError(`"${name}" is not a usable package name. Pass --name to choose one.`);
+  }
+  if (existsSync(directory) && options.force !== true) {
+    const blocking = readdirSync(directory).filter((entry) => !IGNORED_WHEN_EMPTY.has(entry));
+    if (blocking.length > 0) {
+      const shown = blocking.sort().slice(0, 3).join(", ");
+      const rest = blocking.length > 3 ? `, +${blocking.length - 3} more` : "";
+      throw new ScaffoldError(`${directory} is not empty (${shown}${rest}). ` + `Pass --force to write into it anyway.`);
+    }
+  }
+  const version = options.version ?? `^${await readPackageVersion()}`;
+  const written = [];
+  const copyTree = async (from, into) => {
+    for await (const relative of new Glob("**/*").scan({
+      cwd: from,
+      dot: true,
+      onlyFiles: true
+    })) {
+      const base2 = relative.split("/").at(-1) ?? relative;
+      const renamed = RENAMED[base2];
+      const target = join(into, renamed === undefined ? relative : join(dirname(relative), renamed));
+      const contents = await Bun.file(join(from, relative)).text();
+      await Bun.write(join(directory, target), fill(contents, name, version));
+      written.push(target);
+    }
+  };
+  if (!composing) {
+    const source = join(templatesRoot(), template);
+    if (!existsSync(source)) {
+      throw new ScaffoldError(`Template "${template}" is missing from ${source}.`);
+    }
+    await copyTree(source, ".");
+    return {
+      directory,
+      name,
+      template,
+      features: [],
+      files: written.sort()
+    };
+  }
+  const base = join(templatesRoot(), "base");
+  if (!existsSync(base)) {
+    throw new ScaffoldError(`The base template is missing from ${base}. Run \`bun run sync:templates\`.`);
+  }
+  await copyTree(base, ".");
+  for (const feature of features) {
+    const from = join(templatesRoot(), "features", feature.source);
+    if (!existsSync(from)) {
+      throw new ScaffoldError(`Feature "${feature.name}" is missing from ${from}. ` + "Run `bun run sync:templates`.");
+    }
+    await copyTree(from, join("src", feature.source));
+  }
+  for (const [target, contents] of Object.entries(generated(name, features))) {
+    await Bun.write(join(directory, target), fill(contents, name, version));
+    written.push(target);
+  }
+  return {
+    directory,
+    name,
+    template: "composed",
+    features: features.map((feature) => feature.name),
+    files: written.sort()
+  };
+};
+
+export { FEATURES, featureNames, impliedBy, TEMPLATES, VERSION_PLACEHOLDER, ScaffoldError, scaffold };
+
+//# debugId=ABE556EA5FD94D1364756E2164756E21
+//# sourceMappingURL=chunk-jgd5dmqh.js.map