@beignet/cli 0.0.1

package/src/make.ts

@@ -0,0 +1,3931 @@
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import {
+  type BeignetConfig,
+  directoryPath,
+  loadBeignetConfig,
+  normalizePath,
+  type ResolvedBeignetConfig,
+  resolveConfig,
+} from "./config.js";
+
+type MakeResourceOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeContractOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeUseCaseOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeTestOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakePortOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeAdapterOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakePolicyOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeEventOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeJobOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeListenerOptions = {
+  name: string;
+  event: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeScheduleOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+  cron?: string;
+  timezone?: string;
+  route?: boolean;
+};
+
+type MakeResult = {
+  name: string;
+  targetDir: string;
+  dryRun: boolean;
+  files: string[];
+  createdFiles: string[];
+  updatedFiles: string[];
+  skippedFiles: string[];
+};
+
+export type MakeResourceResult = MakeResult;
+export type MakeContractResult = MakeResult;
+export type MakeUseCaseResult = MakeResult;
+export type MakeTestResult = MakeResult;
+export type MakePortResult = MakeResult;
+export type MakeAdapterResult = MakeResult;
+export type MakePolicyResult = MakeResult;
+export type MakeEventResult = MakeResult;
+export type MakeJobResult = MakeResult;
+export type MakeListenerResult = MakeResult;
+export type MakeScheduleResult = MakeResult;
+
+type ResourceNames = {
+  input: string;
+  pluralKebab: string;
+  singularKebab: string;
+  pluralCamel: string;
+  singularCamel: string;
+  singularPascal: string;
+  pluralPascal: string;
+};
+
+type GeneratedFile = {
+  path: string;
+  content: string;
+};
+
+type ResourcePersistence = "memory" | "drizzle";
+
+type IdentifierNames = {
+  input: string;
+  kebab: string;
+  camel: string;
+  pascal: string;
+};
+
+type UseCaseNames = {
+  input: string;
+  feature: IdentifierNames;
+  action: IdentifierNames;
+  exportName: string;
+  operationName: string;
+  kind: "command" | "query";
+};
+
+type PortNames = IdentifierNames & {
+  interfaceName: string;
+  inputName: string;
+  adapterFactoryName: string;
+};
+
+type PolicyNames = IdentifierNames & {
+  policyName: string;
+};
+
+type FeatureArtifactNames = {
+  input: string;
+  feature: IdentifierNames;
+  featureSingularKebab: string;
+  featureSingularCamel: string;
+  featureSingularPascal: string;
+  artifact: IdentifierNames;
+  stableName: string;
+};
+
+type EventNames = FeatureArtifactNames & {
+  eventName: string;
+  eventExportName: string;
+  payloadSchemaName: string;
+  payloadTypeName: string;
+};
+
+type JobNames = FeatureArtifactNames & {
+  jobName: string;
+  jobExportName: string;
+  payloadSchemaName: string;
+  payloadTypeName: string;
+};
+
+type ListenerNames = FeatureArtifactNames & {
+  listenerName: string;
+  listenerExportName: string;
+  event: EventNames;
+};
+
+type ScheduleNames = FeatureArtifactNames & {
+  scheduleName: string;
+  scheduleExportName: string;
+  payloadSchemaName: string;
+  payloadTypeName: string;
+  cron: string;
+  timezone?: string;
+};
+
+export async function makeResource(
+  options: MakeResourceOptions,
+): Promise<MakeResourceResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = resourceNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertStandardApp(targetDir, config);
+
+  const persistence = await detectResourcePersistence(targetDir, config);
+  const generatedFiles = resourceFiles(names, config, persistence);
+  const plannedFiles = await planGeneratedFiles(targetDir, generatedFiles, {
+    force: Boolean(options.force),
+  });
+  const plannedWiringUpdates = await updateResourceWiring(
+    targetDir,
+    names,
+    config,
+    persistence,
+    {
+      dryRun: true,
+    },
+  );
+  const createdFiles = plannedFiles
+    .filter((file) => file.result === "created")
+    .map((file) => file.path);
+  const updatedFiles = plannedFiles
+    .filter((file) => file.result === "updated")
+    .map((file) => file.path);
+  const skippedFiles = plannedFiles
+    .filter((file) => file.result === "skipped")
+    .map((file) => file.path);
+
+  if (options.dryRun) {
+    updatedFiles.push(...plannedWiringUpdates);
+  } else {
+    for (const file of plannedFiles) {
+      await writePlannedGeneratedFile(targetDir, file);
+    }
+
+    updatedFiles.push(
+      ...(await updateResourceWiring(targetDir, names, config, {
+        persistence,
+        dryRun: false,
+      })),
+    );
+  }
+
+  return {
+    name: names.pluralKebab,
+    targetDir,
+    dryRun: Boolean(options.dryRun),
+    files: generatedFiles.map((file) => file.path),
+    createdFiles,
+    updatedFiles,
+    skippedFiles,
+  };
+}
+
+export async function makeContract(
+  options: MakeContractOptions,
+): Promise<MakeContractResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = resourceNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+  const generatedFiles = contractFiles(names, config);
+  const createdFiles: string[] = [];
+  const updatedFiles: string[] = [];
+  const skippedFiles: string[] = [];
+
+  for (const file of generatedFiles) {
+    const result = await writeGeneratedFile(targetDir, file, {
+      force: Boolean(options.force),
+      dryRun: Boolean(options.dryRun),
+    });
+    if (result === "created") createdFiles.push(file.path);
+    if (result === "updated") updatedFiles.push(file.path);
+    if (result === "skipped") skippedFiles.push(file.path);
+  }
+
+  return {
+    name: names.pluralKebab,
+    targetDir,
+    dryRun: Boolean(options.dryRun),
+    files: generatedFiles.map((file) => file.path),
+    createdFiles,
+    updatedFiles,
+    skippedFiles,
+  };
+}
+
+export async function makeUseCase(
+  options: MakeUseCaseOptions,
+): Promise<MakeUseCaseResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = useCaseNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertUseCaseApp(targetDir, config);
+
+  const generatedFiles = useCaseFiles(names, config);
+  const createdFiles: string[] = [];
+  const updatedFiles: string[] = [];
+  const skippedFiles: string[] = [];
+
+  for (const file of generatedFiles) {
+    const result = await writeGeneratedFile(targetDir, file, {
+      force: Boolean(options.force),
+      dryRun: Boolean(options.dryRun),
+    });
+    if (result === "created") createdFiles.push(file.path);
+    if (result === "updated") updatedFiles.push(file.path);
+    if (result === "skipped") skippedFiles.push(file.path);
+  }
+
+  const indexFile = useCaseIndexFile(names, config);
+  const indexResult = await updateUseCaseIndex(targetDir, indexFile, {
+    dryRun: Boolean(options.dryRun),
+  });
+  if (indexResult === "created") createdFiles.push(indexFile.path);
+  if (indexResult === "updated") updatedFiles.push(indexFile.path);
+  if (indexResult === "skipped") skippedFiles.push(indexFile.path);
+
+  return {
+    name: `${names.feature.kebab}/${names.action.kebab}`,
+    targetDir,
+    dryRun: Boolean(options.dryRun),
+    files: [...generatedFiles.map((file) => file.path), indexFile.path],
+    createdFiles,
+    updatedFiles,
+    skippedFiles,
+  };
+}
+
+export async function makeTest(
+  options: MakeTestOptions,
+): Promise<MakeTestResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = useCaseNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertTestApp(targetDir, names, config);
+
+  const generatedFiles = testFiles(names, config);
+  const createdFiles: string[] = [];
+  const updatedFiles: string[] = [];
+  const skippedFiles: string[] = [];
+
+  for (const file of generatedFiles) {
+    const result = await writeGeneratedFile(targetDir, file, {
+      force: Boolean(options.force),
+      dryRun: Boolean(options.dryRun),
+    });
+    if (result === "created") createdFiles.push(file.path);
+    if (result === "updated") updatedFiles.push(file.path);
+    if (result === "skipped") skippedFiles.push(file.path);
+  }
+
+  if (await updatePackageJson(targetDir, { dryRun: Boolean(options.dryRun) })) {
+    updatedFiles.push("package.json");
+  }
+
+  return {
+    name: `${names.feature.kebab}/${names.action.kebab}`,
+    targetDir,
+    dryRun: Boolean(options.dryRun),
+    files: generatedFiles.map((file) => file.path),
+    createdFiles,
+    updatedFiles,
+    skippedFiles,
+  };
+}
+
+export async function makePort(
+  options: MakePortOptions,
+): Promise<MakePortResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = portNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertPortApp(targetDir, config);
+
+  const generatedFiles = portFiles(names, config);
+  const plannedFiles = await planGeneratedFiles(targetDir, generatedFiles, {
+    force: Boolean(options.force),
+  });
+  const createdFiles: string[] = [];
+  const updatedFiles: string[] = [];
+  const skippedFiles: string[] = [];
+
+  for (const file of plannedFiles) {
+    if (file.result === "created") createdFiles.push(file.path);
+    if (file.result === "updated") updatedFiles.push(file.path);
+    if (file.result === "skipped") skippedFiles.push(file.path);
+  }
+
+  await updatePortIndex(targetDir, names, config, { dryRun: true });
+  await updateInfrastructurePortStub(targetDir, names, config, {
+    dryRun: true,
+  });
+
+  if (!options.dryRun) {
+    for (const file of plannedFiles) {
+      await writePlannedGeneratedFile(targetDir, file);
+    }
+  }
+
+  if (
+    await updatePortIndex(targetDir, names, config, {
+      dryRun: Boolean(options.dryRun),
+    })
+  ) {
+    updatedFiles.push(config.paths.ports);
+  }
+  if (
+    await updateInfrastructurePortStub(targetDir, names, config, {
+      dryRun: Boolean(options.dryRun),
+    })
+  ) {
+    updatedFiles.push(config.paths.infrastructurePorts);
+  }
+
+  return {
+    name: names.kebab,
+    targetDir,
+    dryRun: Boolean(options.dryRun),
+    files: generatedFiles.map((file) => file.path),
+    createdFiles,
+    updatedFiles,
+    skippedFiles,
+  };
+}
+
+export async function makeAdapter(
+  options: MakeAdapterOptions,
+): Promise<MakeAdapterResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = portNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertAdapterApp(targetDir, names, config);
+
+  const generatedFiles = adapterFiles(names, config);
+  const createdFiles: string[] = [];
+  const updatedFiles: string[] = [];
+  const skippedFiles: string[] = [];
+
+  for (const file of generatedFiles) {
+    const result = await writeGeneratedFile(targetDir, file, {
+      force: Boolean(options.force),
+      dryRun: Boolean(options.dryRun),
+    });
+    if (result === "created") createdFiles.push(file.path);
+    if (result === "updated") updatedFiles.push(file.path);
+    if (result === "skipped") skippedFiles.push(file.path);
+  }
+
+  if (
+    await updateInfrastructureAdapterWiring(targetDir, names, config, {
+      dryRun: Boolean(options.dryRun),
+    })
+  ) {
+    updatedFiles.push(config.paths.infrastructurePorts);
+  }
+
+  return {
+    name: names.kebab,
+    targetDir,
+    dryRun: Boolean(options.dryRun),
+    files: generatedFiles.map((file) => file.path),
+    createdFiles,
+    updatedFiles,
+    skippedFiles,
+  };
+}
+
+export async function makePolicy(
+  options: MakePolicyOptions,
+): Promise<MakePolicyResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = policyNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertPolicyApp(targetDir, config);
+
+  const generatedFiles = policyFiles(names, config);
+  const createdFiles: string[] = [];
+  const updatedFiles: string[] = [];
+  const skippedFiles: string[] = [];
+
+  for (const file of generatedFiles) {
+    const result = await writeGeneratedFile(targetDir, file, {
+      force: Boolean(options.force),
+      dryRun: Boolean(options.dryRun),
+    });
+    if (result === "created") createdFiles.push(file.path);
+    if (result === "updated") updatedFiles.push(file.path);
+    if (result === "skipped") skippedFiles.push(file.path);
+  }
+
+  return {
+    name: names.kebab,
+    targetDir,
+    dryRun: Boolean(options.dryRun),
+    files: generatedFiles.map((file) => file.path),
+    createdFiles,
+    updatedFiles,
+    skippedFiles,
+  };
+}
+
+export async function makeEvent(
+  options: MakeEventOptions,
+): Promise<MakeEventResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = eventNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertFeatureArtifactApp(targetDir, config, "event");
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: eventFiles(names, config),
+    index: featureArtifactIndexFile("event", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
+export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = jobNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertFeatureArtifactApp(targetDir, config, "job");
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: jobFiles(names, config),
+    index: featureArtifactIndexFile("job", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
+export async function makeListener(
+  options: MakeListenerOptions,
+): Promise<MakeListenerResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = listenerNames(options.name, options.event);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertFeatureArtifactApp(targetDir, config, "listener");
+  await assertListenerEventExists(targetDir, names.event, config);
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: listenerFiles(names, config),
+    index: featureArtifactIndexFile("listener", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
+async function assertListenerEventExists(
+  targetDir: string,
+  names: EventNames,
+  config: ResolvedBeignetConfig,
+): Promise<void> {
+  const file = eventFilePath(names, config);
+
+  try {
+    await stat(path.join(targetDir, file));
+  } catch {
+    throw new Error(
+      `beignet make listener expected event ${names.eventName} at ${file}. Run beignet make event ${names.feature.kebab}/${names.artifact.kebab} first, or pass an event that exists.`,
+    );
+  }
+}
+
+export async function makeSchedule(
+  options: MakeScheduleOptions,
+): Promise<MakeScheduleResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = scheduleNames(options.name, {
+    cron: options.cron,
+    timezone: options.timezone,
+  });
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertFeatureArtifactApp(targetDir, config, "schedule", {
+    requireServer: Boolean(options.route),
+  });
+
+  const files = scheduleFiles(names, config, { route: Boolean(options.route) });
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files,
+    index: featureArtifactIndexFile("schedule", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
+async function assertStandardApp(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<void> {
+  const requiredFiles = [
+    config.paths.appContext,
+    config.paths.infrastructurePorts,
+    config.paths.ports,
+    config.paths.server,
+    config.paths.useCaseBuilder,
+  ];
+
+  for (const file of requiredFiles) {
+    try {
+      await stat(path.join(targetDir, file));
+    } catch {
+      throw new Error(
+        `beignet make resource expects a standard Beignet app. Missing ${file}.`,
+      );
+    }
+  }
+}
+
+async function assertUseCaseApp(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<void> {
+  try {
+    await stat(path.join(targetDir, config.paths.useCaseBuilder));
+  } catch {
+    throw new Error(
+      `beignet make use-case expects a standard Beignet app. Missing ${config.paths.useCaseBuilder}.`,
+    );
+  }
+}
+
+async function assertTestApp(
+  targetDir: string,
+  names: UseCaseNames,
+  config: ResolvedBeignetConfig,
+): Promise<void> {
+  const requiredFiles = [
+    config.paths.appContext,
+    config.paths.infrastructurePorts,
+    useCaseFilePath(names, config),
+  ];
+
+  for (const file of requiredFiles) {
+    try {
+      await stat(path.join(targetDir, file));
+    } catch {
+      throw new Error(
+        `beignet make test expects a standard Beignet app with the target use case. Missing ${file}.`,
+      );
+    }
+  }
+}
+
+async function assertPortApp(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<void> {
+  const requiredFiles = [config.paths.ports, config.paths.infrastructurePorts];
+
+  for (const file of requiredFiles) {
+    try {
+      await stat(path.join(targetDir, file));
+    } catch {
+      throw new Error(
+        `beignet make port expects a standard Beignet app. Missing ${file}.`,
+      );
+    }
+  }
+}
+
+async function assertAdapterApp(
+  targetDir: string,
+  names: PortNames,
+  config: ResolvedBeignetConfig,
+): Promise<void> {
+  const requiredFiles = [
+    config.paths.infrastructurePorts,
+    portFilePath(names, config),
+  ];
+
+  for (const file of requiredFiles) {
+    try {
+      await stat(path.join(targetDir, file));
+    } catch {
+      throw new Error(
+        `beignet make adapter expects an existing port in a standard Beignet app. Missing ${file}.`,
+      );
+    }
+  }
+
+  const infrastructurePorts = await readFile(
+    path.join(targetDir, config.paths.infrastructurePorts),
+    "utf8",
+  );
+  if (
+    !infrastructurePorts.includes(portStubEntry(names)) &&
+    !infrastructurePorts.includes(adapterEntry(names))
+  ) {
+    throw new Error(
+      `Could not find the generated ${names.interfaceName} infrastructure stub in ${config.paths.infrastructurePorts}. Wire ${names.adapterFactoryName}() manually or restore the generated stub before running make adapter.`,
+    );
+  }
+}
+
+async function assertPolicyApp(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<void> {
+  try {
+    await stat(path.join(targetDir, config.paths.appContext));
+  } catch {
+    throw new Error(
+      `beignet make policy expects a standard Beignet app. Missing ${config.paths.appContext}.`,
+    );
+  }
+}
+
+async function assertFeatureArtifactApp(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  artifact: "event" | "job" | "listener" | "schedule",
+  options: { requireServer?: boolean } = {},
+): Promise<void> {
+  const requiredFiles = [
+    config.paths.appContext,
+    ...(options.requireServer ? [config.paths.server] : []),
+  ];
+
+  for (const file of requiredFiles) {
+    try {
+      await stat(path.join(targetDir, file));
+    } catch {
+      throw new Error(
+        `beignet make ${artifact} expects a standard Beignet app. Missing ${file}.`,
+      );
+    }
+  }
+}
+
+type WriteGeneratedFileOptions = {
+  force: boolean;
+  dryRun: boolean;
+};
+
+type WriteGeneratedFileResult = "created" | "updated" | "skipped";
+
+type PlannedGeneratedFile = GeneratedFile & {
+  result: WriteGeneratedFileResult;
+};
+
+async function writeGeneratedFile(
+  targetDir: string,
+  file: GeneratedFile,
+  options: WriteGeneratedFileOptions,
+): Promise<WriteGeneratedFileResult> {
+  const plannedFile = await planGeneratedFile(targetDir, file, {
+    force: options.force,
+  });
+
+  if (!options.dryRun) {
+    await writePlannedGeneratedFile(targetDir, plannedFile);
+  }
+
+  return plannedFile.result;
+}
+
+async function planGeneratedFiles(
+  targetDir: string,
+  files: GeneratedFile[],
+  options: { force: boolean },
+): Promise<PlannedGeneratedFile[]> {
+  const plannedFiles: PlannedGeneratedFile[] = [];
+
+  for (const file of files) {
+    plannedFiles.push(await planGeneratedFile(targetDir, file, options));
+  }
+
+  return plannedFiles;
+}
+
+async function planGeneratedFile(
+  targetDir: string,
+  file: GeneratedFile,
+  options: { force: boolean },
+): Promise<PlannedGeneratedFile> {
+  const destination = path.join(targetDir, file.path);
+  const existing = await readOptionalFile(destination);
+  if (existing === file.content) {
+    return { ...file, result: "skipped" };
+  }
+  if (existing !== undefined && !options.force) {
+    throw new Error(
+      `File ${file.path} already exists with different content. Pass --force to overwrite it.`,
+    );
+  }
+
+  return { ...file, result: existing === undefined ? "created" : "updated" };
+}
+
+async function writePlannedGeneratedFile(
+  targetDir: string,
+  file: PlannedGeneratedFile,
+): Promise<void> {
+  if (file.result === "skipped") return;
+
+  const destination = path.join(targetDir, file.path);
+  await mkdir(path.dirname(destination), { recursive: true });
+  await writeFile(destination, file.content);
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readOptionalFile(filePath: string): Promise<string | undefined> {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
+async function makeFeatureArtifact(options: {
+  targetDir: string;
+  config: ResolvedBeignetConfig;
+  force: boolean;
+  dryRun: boolean;
+  name: string;
+  files: GeneratedFile[];
+  index: FeatureArtifactIndexFile;
+  dependencies: Record<string, (packageJson: PackageJsonLike) => string>;
+}): Promise<MakeResult> {
+  const plannedFiles = await planGeneratedFiles(
+    options.targetDir,
+    options.files,
+    {
+      force: options.force,
+    },
+  );
+  const createdFiles = plannedFiles
+    .filter((file) => file.result === "created")
+    .map((file) => file.path);
+  const updatedFiles = plannedFiles
+    .filter((file) => file.result === "updated")
+    .map((file) => file.path);
+  const skippedFiles = plannedFiles
+    .filter((file) => file.result === "skipped")
+    .map((file) => file.path);
+
+  if (!options.dryRun) {
+    for (const file of plannedFiles) {
+      await writePlannedGeneratedFile(options.targetDir, file);
+    }
+  }
+
+  const indexResult = await updateFeatureArtifactIndex(
+    options.targetDir,
+    options.index,
+    { dryRun: options.dryRun },
+  );
+  if (indexResult === "created") createdFiles.push(options.index.path);
+  if (indexResult === "updated") updatedFiles.push(options.index.path);
+  if (indexResult === "skipped") skippedFiles.push(options.index.path);
+
+  if (
+    await updatePackageDependencies(options.targetDir, options.dependencies, {
+      dryRun: options.dryRun,
+    })
+  ) {
+    updatedFiles.push("package.json");
+  }
+
+  return {
+    name: options.name,
+    targetDir: options.targetDir,
+    dryRun: options.dryRun,
+    files: [...options.files.map((file) => file.path), options.index.path],
+    createdFiles,
+    updatedFiles,
+    skippedFiles,
+  };
+}
+
+type PackageJsonLike = {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+};
+
+async function updatePackageDependencies(
+  targetDir: string,
+  dependencies: Record<string, (packageJson: PackageJsonLike) => string>,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, "package.json");
+  const original = await readFile(filePath, "utf8");
+  const packageJson = JSON.parse(original) as PackageJsonLike;
+  packageJson.dependencies = packageJson.dependencies ?? {};
+
+  for (const [name, version] of Object.entries(dependencies)) {
+    packageJson.dependencies[name] ??= version(packageJson);
+  }
+
+  const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+function beignetDependencyVersion(packageJson: PackageJsonLike): string {
+  return (
+    packageJson.dependencies?.["@beignet/core"] ??
+    packageJson.dependencies?.["@beignet/next"] ??
+    "*"
+  );
+}
+
+async function updateResourceWiring(
+  targetDir: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  persistenceOrOptions:
+    | ResourcePersistence
+    | { dryRun: boolean; persistence?: ResourcePersistence },
+  maybeOptions?: { dryRun: boolean },
+): Promise<string[]> {
+  const persistence =
+    typeof persistenceOrOptions === "string"
+      ? persistenceOrOptions
+      : (persistenceOrOptions.persistence ?? "memory");
+  const options =
+    typeof persistenceOrOptions === "string"
+      ? (maybeOptions as { dryRun: boolean })
+      : persistenceOrOptions;
+  const updated = new Set<string>();
+  if (await updatePackageJson(targetDir, options)) updated.add("package.json");
+  if (await updatePortsIndex(targetDir, names, config, options)) {
+    updated.add(config.paths.ports);
+  }
+  if (await updateInfrastructurePorts(targetDir, names, config, options)) {
+    updated.add(config.paths.infrastructurePorts);
+  }
+  if (
+    persistence === "drizzle" &&
+    (await updateDrizzleSchemaIndex(targetDir, names, config, options))
+  ) {
+    updated.add(drizzleSchemaIndexPath(config));
+  }
+  if (
+    persistence === "drizzle" &&
+    (await updateDrizzleRepositories(targetDir, names, config, options))
+  ) {
+    updated.add(drizzleRepositoriesPath(config));
+  }
+  if (
+    persistence === "memory" &&
+    (await updateServerTransactionPorts(targetDir, names, config, options))
+  ) {
+    updated.add(config.paths.server);
+  }
+  if (await updateOpenApiRoute(targetDir, names, config, options)) {
+    updated.add(config.paths.openapiRoute);
+  }
+  const routesFile = await updateServerRoutes(
+    targetDir,
+    names,
+    config,
+    options,
+  );
+  if (routesFile) updated.add(routesFile);
+
+  return [...updated];
+}
+
+async function updatePackageJson(
+  targetDir: string,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, "package.json");
+  const original = await readFile(filePath, "utf8");
+  const packageJson = JSON.parse(original) as {
+    scripts?: Record<string, string>;
+  };
+  packageJson.scripts = packageJson.scripts ?? {};
+  if (packageJson.scripts.test) return false;
+
+  packageJson.scripts.test = "bun test";
+  const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return next !== original;
+}
+
+async function updatePortsIndex(
+  targetDir: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, config.paths.ports);
+  const original = await readFile(filePath, "utf8");
+  let next = original;
+  const repositoryPath = resourcePortFilePath(names, config);
+  const importLine = `import type { ${names.singularPascal}Repository } from "${relativeModule(config.paths.ports, repositoryPath)}";`;
+
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  const entry = `\t${names.pluralCamel}: ${names.singularPascal}Repository;`;
+  if (!next.includes(entry.trim())) {
+    next = insertTypeProperty(
+      next,
+      "AppPorts",
+      entry.trim(),
+      `Could not find AppPorts in ${config.paths.ports}. Add ${entry.trim()} manually, or restore the generated ports file before running make resource.`,
+    );
+  }
+
+  const transactionPorts = typeBodySource(next, "AppTransactionPorts");
+  if (
+    transactionPorts !== undefined &&
+    !transactionPorts.includes(entry.trim())
+  ) {
+    next = replaceTransactionPortsRequired(
+      next,
+      entry,
+      `Could not find AppTransactionPorts in ${config.paths.ports}. Add ${entry.trim()} manually, or restore the generated ports file before running make resource.`,
+    );
+  }
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updatePortIndex(
+  targetDir: string,
+  names: PortNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, config.paths.ports);
+  const original = await readFile(filePath, "utf8");
+  let next = original;
+  const portPath = path.join(
+    path.dirname(config.paths.ports),
+    `${names.kebab}.ts`,
+  );
+  const importLine = `import type { ${names.interfaceName} } from "${relativeModule(config.paths.ports, portPath)}";`;
+
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  const entry = `\t${names.camel}: ${names.interfaceName};`;
+  if (!next.includes(entry.trim())) {
+    next = insertTypeProperty(
+      next,
+      "AppPorts",
+      entry.trim(),
+      `Could not find AppPorts in ${config.paths.ports}. Add ${entry.trim()} manually, or restore the generated ports file before running make port.`,
+    );
+  }
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateInfrastructurePortStub(
+  targetDir: string,
+  names: PortNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, config.paths.infrastructurePorts);
+  const original = await readFile(filePath, "utf8");
+  let next = original;
+  const portPath = portFilePath(names, config);
+  const importLine = `import type { ${names.interfaceName} } from "${relativeModule(config.paths.infrastructurePorts, portPath)}";`;
+
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  const entry = portStubEntry(names);
+  const definePortsBody = definePortsBodySource(next);
+  if (
+    definePortsBody === undefined ||
+    !hasTopLevelObjectProperty(definePortsBody, names.camel)
+  ) {
+    next = insertDefinePortsProperty(
+      next,
+      entry.trim(),
+      `Could not find definePorts({ in ${config.paths.infrastructurePorts}. Add the ${names.interfaceName} stub manually, or restore the generated infrastructure ports file before running make port.`,
+    );
+  }
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateInfrastructureAdapterWiring(
+  targetDir: string,
+  names: PortNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, config.paths.infrastructurePorts);
+  const original = await readFile(filePath, "utf8");
+  let next = original;
+  const adapterPath = adapterFilePath(names, config);
+  const adapterImportLine = `import { ${names.adapterFactoryName} } from "${relativeModule(config.paths.infrastructurePorts, adapterPath)}";`;
+
+  if (!next.includes(adapterImportLine)) {
+    next = insertAfterImports(next, adapterImportLine);
+  }
+
+  const portPath = portFilePath(names, config);
+  const portImportLine = `import type { ${names.interfaceName} } from "${relativeModule(config.paths.infrastructurePorts, portPath)}";`;
+  if (next.includes(portImportLine)) {
+    next = next.replace(`${portImportLine}\n`, "");
+  }
+
+  const adapter = adapterEntry(names);
+  const stub = portStubEntry(names);
+  if (next.includes(stub)) {
+    next = next.replace(stub, adapter);
+  } else if (!next.includes(adapter)) {
+    throw new Error(
+      `Could not find the generated ${names.interfaceName} infrastructure stub in ${config.paths.infrastructurePorts}. Wire ${names.adapterFactoryName}() manually or restore the generated stub before running make adapter.`,
+    );
+  }
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateInfrastructurePorts(
+  targetDir: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, config.paths.infrastructurePorts);
+  const original = await readFile(filePath, "utf8");
+  let next = original;
+  const repositoryPath = path.join(
+    path.dirname(config.paths.infrastructurePorts),
+    names.pluralKebab,
+    `in-memory-${names.singularKebab}-repository.ts`,
+  );
+  const importLine = `import { createInMemory${names.singularPascal}Repository } from "${relativeModule(config.paths.infrastructurePorts, repositoryPath)}";`;
+
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  const repositoryConst = `const ${names.pluralCamel} = createInMemory${names.singularPascal}Repository();`;
+  if (!next.includes(repositoryConst)) {
+    next = replaceRequired(
+      next,
+      /(\nexport const appPorts = definePorts(?:<[^>]+>)?\(\{)/,
+      `\n${repositoryConst}\n$1`,
+      `Could not find definePorts({ in ${config.paths.infrastructurePorts}. Add ${repositoryConst} manually, or restore the generated infrastructure ports file before running make resource.`,
+    );
+  }
+
+  const entry = `\t${names.pluralCamel},`;
+  const definePortsBody = definePortsBodySource(next);
+  if (
+    definePortsBody === undefined ||
+    !hasTopLevelObjectProperty(definePortsBody, names.pluralCamel)
+  ) {
+    next = insertDefinePortsProperty(
+      next,
+      entry.trim(),
+      `Could not find definePorts({ in ${config.paths.infrastructurePorts}. Add ${entry.trim()} to appPorts manually, or restore the generated infrastructure ports file before running make resource.`,
+    );
+  }
+
+  const transactionEntry = `\t\t${names.pluralCamel},`;
+  const uowBody = noopUnitOfWorkBodySource(next);
+  if (
+    uowBody !== undefined &&
+    !new RegExp(`\\b${names.pluralCamel}\\b\\s*,`).test(uowBody)
+  ) {
+    next = insertNoopUnitOfWorkProperty(
+      next,
+      transactionEntry.trim(),
+      `Could not find the generated Unit of Work port list in ${config.paths.infrastructurePorts}. Add ${transactionEntry.trim()} manually, or restore the generated infrastructure ports file before running make resource.`,
+    );
+  }
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateDrizzleSchemaIndex(
+  targetDir: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, drizzleSchemaIndexPath(config));
+  if (!(await fileExists(filePath))) return false;
+
+  const original = await readFile(filePath, "utf8");
+  const exportLine = `export { ${names.pluralCamel} } from "./${names.pluralKebab}";`;
+  if (original.includes(exportLine)) return false;
+
+  const next = `${original.trimEnd()}\n${exportLine}\n`;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateDrizzleRepositories(
+  targetDir: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, drizzleRepositoriesPath(config));
+  if (!(await fileExists(filePath))) return false;
+
+  const original = await readFile(filePath, "utf8");
+  let next = original;
+  const repositoryPath = drizzleResourceRepositoryFilePath(names, config);
+  const importLine = `import { createDrizzle${names.singularPascal}Repository } from "${relativeModule(drizzleRepositoriesPath(config), repositoryPath)}";`;
+  const repositoriesBody = createRepositoriesReturnBodySource(next);
+  const entry = `\t\t${names.pluralCamel}: createDrizzle${names.singularPascal}Repository(db),`;
+
+  if (repositoriesBody === undefined) {
+    throw new Error(
+      `Could not find return { in createRepositories in ${drizzleRepositoriesPath(config)}. Add ${entry.trim()} manually, or restore the generated repositories file before running make resource.`,
+    );
+  }
+
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  if (!hasTopLevelObjectProperty(repositoriesBody, names.pluralCamel)) {
+    next = insertCreateRepositoriesProperty(
+      next,
+      entry.trim(),
+      `Could not find return { in createRepositories in ${drizzleRepositoriesPath(config)}. Add ${entry.trim()} manually, or restore the generated repositories file before running make resource.`,
+    );
+  }
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateServerTransactionPorts(
+  targetDir: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, config.paths.server);
+  const original = await readFile(filePath, "utf8");
+  let next = original;
+  const transactionPortsBody = drizzleTransactionPortsBodySource(next);
+
+  if (
+    transactionPortsBody === undefined ||
+    hasTopLevelObjectProperty(transactionPortsBody, names.pluralCamel)
+  ) {
+    return false;
+  }
+
+  if (!/\bappPorts\b/.test(next)) {
+    throw new Error(
+      `Could not find appPorts in ${config.paths.server}. Add ${names.pluralCamel}: appPorts.${names.pluralCamel} to createTransactionPorts manually, or restore the generated server file before running make resource.`,
+    );
+  }
+
+  const entry = `\t\t\t\t\t\t${names.pluralCamel}: appPorts.${names.pluralCamel},`;
+  next = insertDrizzleTransactionPortsProperty(
+    next,
+    entry.trim(),
+    `Could not find createTransactionPorts({ in ${config.paths.server}. Add ${entry.trim()} manually, or restore the generated server file before running make resource.`,
+  );
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateOpenApiRoute(
+  targetDir: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, config.paths.openapiRoute);
+  if (!(await fileExists(filePath))) return false;
+
+  const original = await readFile(filePath, "utf8");
+  const firstArg = firstCreateOpenAPIHandlerArgInfo(original);
+  if (!firstArg?.text.startsWith("[")) return false;
+
+  const listName = `list${names.pluralPascal}`;
+  const createName = `create${names.singularPascal}`;
+  const listedContracts = identifiersFromArrayExpression(firstArg.text);
+  const missingContracts = [listName, createName].filter(
+    (contractName) => !listedContracts.has(contractName),
+  );
+  if (missingContracts.length === 0) return false;
+
+  const importLine = `import { create${names.singularPascal}, list${names.pluralPascal} } from "${aliasModule(resourceContractFilePath(names, config))}";`;
+  const nextArray = appendToArrayExpression(firstArg.text, missingContracts);
+  let next = `${original.slice(0, firstArg.start)}${nextArray}${original.slice(
+    firstArg.end,
+  )}`;
+
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateServerRoutes(
+  targetDir: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<string | undefined> {
+  const filePath = path.join(targetDir, config.paths.server);
+  const original = await readFile(filePath, "utf8");
+  const routeRegistryPath = routeRegistryFileFromServerSource(
+    original,
+    config.paths.server,
+  );
+
+  if (routeRegistryPath) {
+    await assertImportedRoutesFileExists(targetDir, routeRegistryPath);
+    return updateDefineRoutesFile(
+      targetDir,
+      routeRegistryPath,
+      names,
+      config,
+      options,
+    );
+  }
+
+  return updateDefineRoutesFile(
+    targetDir,
+    config.paths.server,
+    names,
+    config,
+    options,
+  );
+}
+
+async function updateDefineRoutesFile(
+  targetDir: string,
+  file: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<string | undefined> {
+  const filePath = path.join(targetDir, file);
+  const original = await readFile(filePath, "utf8");
+  let next = original;
+  const routeGroupName = `${names.singularCamel}Routes`;
+  const routeGroupPath = path.join(
+    config.paths.features,
+    names.pluralKebab,
+    "routes.ts",
+  );
+  const importLine = `import { ${routeGroupName} } from "${relativeModule(file, routeGroupPath)}";`;
+
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  if (!routeGroupIsRegistered(next, routeGroupName)) {
+    const firstArg = firstDefineRoutesArgInfo(next);
+    if (!firstArg?.text.startsWith("[")) {
+      throw new Error(
+        `Could not find a central defineRoutes([...]) registration in ${file}. Import ${routeGroupName} and add it to defineRoutes manually.`,
+      );
+    }
+
+    const nextArray = appendToArrayExpression(firstArg.text, [routeGroupName]);
+    next = `${next.slice(0, firstArg.start)}${nextArray}${next.slice(
+      firstArg.end,
+    )}`;
+  }
+
+  if (!routeGroupIsRegistered(next, routeGroupName)) {
+    throw new Error(
+      `Could not find a central defineRoutes([...]) registration in ${file}. Import ${routeGroupName} and add it to defineRoutes manually.`,
+    );
+  }
+
+  if (next === original) return undefined;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return file;
+}
+
+function routeGroupIsRegistered(
+  source: string,
+  routeGroupName: string,
+): boolean {
+  const firstArg = firstDefineRoutesArgInfo(source);
+  if (!firstArg?.text.startsWith("[")) return false;
+
+  return identifiersFromArrayExpression(firstArg.text).has(routeGroupName);
+}
+
+function routeRegistryFileFromServerSource(
+  source: string,
+  serverFile: string,
+): string | undefined {
+  const serverOptions = firstCreateNextServerArgInfo(source);
+  if (!serverOptions) return undefined;
+
+  const routeIdentifier = routeOptionIdentifier(serverOptions.text);
+  if (!routeIdentifier) return undefined;
+
+  const imported = parseNamedImportSources(source).get(routeIdentifier);
+  if (!imported) return undefined;
+
+  return resolveImportFile(imported.sourcePath, serverFile);
+}
+
+function routeOptionIdentifier(source: string): string | undefined {
+  const explicitMatch = /(?:^|[,{])\s*routes\s*:\s*([A-Za-z_$][\w$]*)/m.exec(
+    source,
+  );
+  if (explicitMatch) return explicitMatch[1];
+
+  if (/(?:^|[,{])\s*routes\s*(?:[,}])/m.test(source)) {
+    return "routes";
+  }
+
+  return undefined;
+}
+
+function parseNamedImportSources(
+  source: string,
+): Map<string, { importedName: string; sourcePath: string }> {
+  const imports = new Map<
+    string,
+    { importedName: string; sourcePath: string }
+  >();
+  const importRegex = /import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
+
+  for (const match of source.matchAll(importRegex)) {
+    for (const member of match[1].split(",")) {
+      const parsed = parseImportMember(member);
+      if (!parsed) continue;
+      imports.set(parsed.localName, {
+        importedName: parsed.importedName,
+        sourcePath: match[2],
+      });
+    }
+  }
+
+  return imports;
+}
+
+function parseImportMember(
+  member: string,
+): { importedName: string; localName: string } | undefined {
+  const trimmed = member.trim();
+  if (!trimmed) return undefined;
+
+  const aliasMatch = /^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/.exec(
+    trimmed,
+  );
+  if (aliasMatch) {
+    return {
+      importedName: aliasMatch[1],
+      localName: aliasMatch[2],
+    };
+  }
+
+  if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+    return {
+      importedName: trimmed,
+      localName: trimmed,
+    };
+  }
+
+  return undefined;
+}
+
+function resolveImportFile(
+  sourcePath: string,
+  importerFile: string,
+): string | undefined {
+  if (sourcePath.startsWith("@/")) {
+    return `${sourcePath.slice(2)}.ts`;
+  }
+
+  if (sourcePath.startsWith(".")) {
+    return `${normalizePath(path.join(path.dirname(importerFile), sourcePath))}.ts`;
+  }
+
+  return undefined;
+}
+
+async function assertImportedRoutesFileExists(
+  targetDir: string,
+  file: string,
+): Promise<void> {
+  try {
+    await stat(path.join(targetDir, file));
+  } catch {
+    throw new Error(
+      `Could not find the route registry ${file}. Restore the imported routes file or add the new route group manually.`,
+    );
+  }
+}
+
+function firstDefineRoutesArgInfo(
+  source: string,
+): { text: string; start: number; end: number } | undefined {
+  const match = /defineRoutes(?:<[^>]+>)?\(/.exec(source);
+  if (!match) return undefined;
+
+  return firstCallArgInfo(source, match.index + match[0].length);
+}
+
+function firstCreateNextServerArgInfo(
+  source: string,
+): { text: string; start: number; end: number } | undefined {
+  const match = /createNextServer(?:<[^>]+>)?\(/.exec(source);
+  if (!match) return undefined;
+
+  return firstCallArgInfo(source, match.index + match[0].length);
+}
+
+function firstCreateOpenAPIHandlerArgInfo(
+  source: string,
+): { text: string; start: number; end: number } | undefined {
+  const start = source.indexOf("createOpenAPIHandler(");
+  if (start === -1) return undefined;
+
+  return firstCallArgInfo(source, start + "createOpenAPIHandler(".length);
+}
+
+function firstCallArgInfo(
+  source: string,
+  argStart: number,
+): { text: string; start: number; end: number } | undefined {
+  let depth = 0;
+  let inString: string | undefined;
+  let escaped = false;
+
+  for (let index = argStart; index < source.length; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === inString) {
+        inString = undefined;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      continue;
+    }
+
+    if (char === "[" || char === "(" || char === "{") {
+      depth++;
+      continue;
+    }
+
+    if (char === "]" || char === ")" || char === "}") {
+      if (depth === 0) {
+        return trimmedSlice(source, argStart, index);
+      }
+      depth--;
+      continue;
+    }
+
+    if (char === "," && depth === 0) {
+      return trimmedSlice(source, argStart, index);
+    }
+  }
+
+  return undefined;
+}
+
+function trimmedSlice(
+  source: string,
+  start: number,
+  end: number,
+): { text: string; start: number; end: number } {
+  let trimmedStart = start;
+  let trimmedEnd = end;
+
+  while (trimmedStart < trimmedEnd && /\s/.test(source[trimmedStart])) {
+    trimmedStart++;
+  }
+  while (trimmedEnd > trimmedStart && /\s/.test(source[trimmedEnd - 1])) {
+    trimmedEnd--;
+  }
+
+  return {
+    text: source.slice(trimmedStart, trimmedEnd),
+    start: trimmedStart,
+    end: trimmedEnd,
+  };
+}
+
+function identifiersFromArrayExpression(expression: string): Set<string> {
+  const withoutBrackets = expression.replace(/^\[/, "").replace(/\]$/, "");
+
+  return new Set(
+    Array.from(
+      withoutBrackets.matchAll(/\b[A-Za-z_$][\w$]*\b/g),
+      ([name]) => name,
+    ),
+  );
+}
+
+function appendToArrayExpression(expression: string, names: string[]): string {
+  const closingBracket = /\]\s*$/.exec(expression);
+  if (!closingBracket) return expression;
+
+  const beforeClosingBracket = expression.slice(0, closingBracket.index);
+  const closingBracketText = expression.slice(closingBracket.index);
+  const inner = beforeClosingBracket.replace(/^\[/, "");
+  if (!inner.trim()) return `[${names.join(", ")}]`;
+
+  if (!expression.includes("\n")) {
+    const separator = /,\s*$/.test(inner) ? " " : ", ";
+    return `${beforeClosingBracket}${separator}${names.join(", ")}${closingBracketText}`;
+  }
+
+  const itemIndent =
+    inner
+      .split("\n")
+      .find((line) => line.trim())
+      ?.match(/^[\t ]*/)?.[0] ?? "\t";
+  const closingIndent = inner.match(/\n([\t ]*)$/)?.[1] ?? "";
+  const trimmedBeforeClosingBracket = beforeClosingBracket.replace(/\s*$/, "");
+  const appendedNames = names.join(`,\n${itemIndent}`);
+
+  if (/,\s*$/.test(inner)) {
+    return `${trimmedBeforeClosingBracket}\n${itemIndent}${appendedNames},\n${closingIndent}${closingBracketText}`;
+  }
+
+  return `${trimmedBeforeClosingBracket},\n${itemIndent}${appendedNames}${closingBracketText}`;
+}
+
+function insertAfterImports(source: string, line: string): string {
+  const lines = source.split("\n");
+  let lastImportIndex = -1;
+
+  for (let index = 0; index < lines.length; index++) {
+    if (lines[index].startsWith("import ")) {
+      lastImportIndex = index;
+    }
+  }
+
+  if (lastImportIndex === -1) {
+    return `${line}\n${source}`;
+  }
+
+  lines.splice(lastImportIndex + 1, 0, line);
+  return lines.join("\n");
+}
+
+function replaceRequired(
+  source: string,
+  searchValue: RegExp,
+  replaceValue: string,
+  message: string,
+): string {
+  const next = source.replace(searchValue, replaceValue);
+  if (next === source) throw new Error(message);
+  return next;
+}
+
+function insertTypeProperty(
+  source: string,
+  typeName: string,
+  property: string,
+  message: string,
+): string {
+  const match = new RegExp(`export\\s+type\\s+${typeName}\\b`).exec(source);
+  if (!match) throw new Error(message);
+
+  const openBrace = source.indexOf("{", match.index);
+  if (openBrace === -1) throw new Error(message);
+
+  const closeBrace = matchingBraceIndex(source, openBrace);
+  if (closeBrace === -1) throw new Error(message);
+
+  return insertBeforeClosingBrace(source, openBrace, closeBrace, property);
+}
+
+function typeBodySource(source: string, typeName: string): string | undefined {
+  const match = new RegExp(`export\\s+type\\s+${typeName}\\b`).exec(source);
+  if (!match) return undefined;
+
+  const openBrace = source.indexOf("{", match.index);
+  if (openBrace === -1) return undefined;
+
+  const closeBrace = matchingBraceIndex(source, openBrace);
+  if (closeBrace === -1) return undefined;
+
+  return source.slice(openBrace + 1, closeBrace);
+}
+
+function insertDefinePortsProperty(
+  source: string,
+  property: string,
+  message: string,
+): string {
+  const body = definePortsBodyRange(source);
+  if (!body) throw new Error(message);
+
+  return insertBeforeClosingBrace(
+    source,
+    body.openBrace,
+    body.closeBrace,
+    property,
+  );
+}
+
+function insertNoopUnitOfWorkProperty(
+  source: string,
+  property: string,
+  message: string,
+): string {
+  const body = noopUnitOfWorkBodyRange(source);
+  if (!body) throw new Error(message);
+
+  return insertBeforeClosingBrace(
+    source,
+    body.openBrace,
+    body.closeBrace,
+    property,
+  );
+}
+
+function insertDrizzleTransactionPortsProperty(
+  source: string,
+  property: string,
+  message: string,
+): string {
+  const body = drizzleTransactionPortsBodyRange(source);
+  if (!body) throw new Error(message);
+
+  return insertBeforeClosingBrace(
+    source,
+    body.openBrace,
+    body.closeBrace,
+    property,
+  );
+}
+
+function insertCreateRepositoriesProperty(
+  source: string,
+  property: string,
+  message: string,
+): string {
+  const body = createRepositoriesReturnBodyRange(source);
+  if (!body) throw new Error(message);
+
+  return insertBeforeClosingBrace(
+    source,
+    body.openBrace,
+    body.closeBrace,
+    property,
+  );
+}
+
+function noopUnitOfWorkBodySource(source: string): string | undefined {
+  const body = noopUnitOfWorkBodyRange(source);
+  if (!body) return undefined;
+
+  return source.slice(body.openBrace + 1, body.closeBrace);
+}
+
+function drizzleTransactionPortsBodySource(source: string): string | undefined {
+  const body = drizzleTransactionPortsBodyRange(source);
+  if (!body) return undefined;
+
+  return source.slice(body.openBrace + 1, body.closeBrace);
+}
+
+function createRepositoriesReturnBodySource(
+  source: string,
+): string | undefined {
+  const body = createRepositoriesReturnBodyRange(source);
+  if (!body) return undefined;
+
+  return source.slice(body.openBrace + 1, body.closeBrace);
+}
+
+function definePortsBodySource(source: string): string | undefined {
+  const body = definePortsBodyRange(source);
+  if (!body) return undefined;
+
+  return source.slice(body.openBrace + 1, body.closeBrace);
+}
+
+function definePortsBodyRange(
+  source: string,
+): { openBrace: number; closeBrace: number } | undefined {
+  const match = /definePorts(?:<[^>]+>)?\(\s*\{/.exec(source);
+  if (!match) return undefined;
+
+  const openBrace = source.indexOf("{", match.index);
+  const closeBrace = matchingBraceIndex(source, openBrace);
+  if (closeBrace === -1) return undefined;
+
+  return { openBrace, closeBrace };
+}
+
+function hasTopLevelObjectProperty(
+  source: string,
+  propertyName: string,
+): boolean {
+  let depth = 0;
+  let inString: string | undefined;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index];
+    const next = source[index + 1];
+
+    if (lineComment) {
+      if (char === "\n") lineComment = false;
+      continue;
+    }
+
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        index++;
+      }
+      continue;
+    }
+
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === inString) {
+        inString = undefined;
+      }
+      continue;
+    }
+
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      index++;
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      index++;
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      continue;
+    }
+
+    if (char === "{" || char === "[" || char === "(") {
+      depth++;
+      continue;
+    }
+
+    if (char === "}" || char === "]" || char === ")") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+
+    if (depth !== 0 || !identifierStartPattern.test(char)) {
+      continue;
+    }
+
+    const property = identifierAt(source, index);
+    if (property !== propertyName) {
+      index += property.length - 1;
+      continue;
+    }
+
+    let cursor = index + property.length;
+    while (/\s/.test(source[cursor] ?? "")) cursor++;
+    if (source[cursor] === ":" || source[cursor] === ",") return true;
+    index = cursor;
+  }
+
+  return false;
+}
+
+const identifierStartPattern = /[$A-Z_a-z]/;
+const identifierPartPattern = /[$\w]/;
+
+function identifierAt(source: string, index: number): string {
+  let cursor = index;
+  while (identifierPartPattern.test(source[cursor] ?? "")) {
+    cursor++;
+  }
+
+  return source.slice(index, cursor);
+}
+
+function noopUnitOfWorkBodyRange(
+  source: string,
+): { openBrace: number; closeBrace: number } | undefined {
+  const match = /createNoopUnitOfWork\(\s*\(\)\s*=>\s*\(\s*\{/.exec(source);
+  if (!match) return undefined;
+
+  const openBrace = source.indexOf("{", match.index);
+  const closeBrace = matchingBraceIndex(source, openBrace);
+  if (closeBrace === -1) return undefined;
+
+  return { openBrace, closeBrace };
+}
+
+function drizzleTransactionPortsBodyRange(
+  source: string,
+): { openBrace: number; closeBrace: number } | undefined {
+  const match = /createTransactionPorts\s*:\s*\([^)]*\)\s*=>\s*\(\s*\{/.exec(
+    source,
+  );
+  if (!match) return undefined;
+
+  const openBrace = source.indexOf("{", match.index);
+  const closeBrace = matchingBraceIndex(source, openBrace);
+  if (closeBrace === -1) return undefined;
+
+  return { openBrace, closeBrace };
+}
+
+function createRepositoriesReturnBodyRange(
+  source: string,
+): { openBrace: number; closeBrace: number } | undefined {
+  const functionBody = createRepositoriesFunctionBodyRange(source);
+  if (!functionBody) return undefined;
+
+  const functionSource = source.slice(
+    functionBody.openBrace + 1,
+    functionBody.closeBrace,
+  );
+  const match = /return\s*\{\s*/.exec(functionSource);
+  if (!match) return undefined;
+
+  const openBrace = source.indexOf(
+    "{",
+    functionBody.openBrace + 1 + match.index,
+  );
+  if (openBrace === -1) return undefined;
+  const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
+  if (closeBrace === -1 || closeBrace > functionBody.closeBrace) {
+    return undefined;
+  }
+
+  return { openBrace, closeBrace };
+}
+
+function createRepositoriesFunctionBodyRange(
+  source: string,
+): { openBrace: number; closeBrace: number } | undefined {
+  const match = /(?:export\s+)?function\s+createRepositories\b/.exec(source);
+  if (!match) return undefined;
+
+  const openParen = source.indexOf("(", match.index);
+  if (openParen === -1) return undefined;
+  const closeParen = matchingDelimiterIndex(source, openParen, "(", ")");
+  if (closeParen === -1) return undefined;
+
+  const bodyMatch = /(?:\s*:[^{]+)?\s*\{/.exec(source.slice(closeParen + 1));
+  if (!bodyMatch) return undefined;
+
+  const openBrace =
+    closeParen + 1 + bodyMatch.index + bodyMatch[0].lastIndexOf("{");
+  const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
+  if (closeBrace === -1) return undefined;
+
+  return { openBrace, closeBrace };
+}
+
+function insertBeforeClosingBrace(
+  source: string,
+  openBrace: number,
+  closeBrace: number,
+  property: string,
+): string {
+  const body = source.slice(openBrace + 1, closeBrace);
+  const propertyIndent = detectPropertyIndent(body);
+  const closingIndent =
+    source.slice(0, closeBrace).match(/\n([\t ]*)$/)?.[1] ?? "";
+  const trimmedBody = body.replace(/\s*$/, "");
+  const nextBody = `${trimmedBody}\n${propertyIndent}${property}\n${closingIndent}`;
+
+  return `${source.slice(0, openBrace + 1)}${nextBody}${source.slice(
+    closeBrace,
+  )}`;
+}
+
+function detectPropertyIndent(body: string): string {
+  return (
+    body
+      .split("\n")
+      .find((line) => line.trim())
+      ?.match(/^[\t ]*/)?.[0] ?? "\t"
+  );
+}
+
+function matchingBraceIndex(source: string, openBrace: number): number {
+  return matchingDelimiterIndex(source, openBrace, "{", "}");
+}
+
+function matchingDelimiterIndex(
+  source: string,
+  openIndex: number,
+  open: string,
+  close: string,
+): number {
+  let depth = 0;
+  let inString: string | undefined;
+  let escaped = false;
+
+  for (let index = openIndex; index < source.length; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === inString) {
+        inString = undefined;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      continue;
+    }
+
+    if (char === open) {
+      depth++;
+      continue;
+    }
+
+    if (char === close) {
+      depth--;
+      if (depth === 0) return index;
+    }
+  }
+
+  return -1;
+}
+
+function replaceTransactionPortsRequired(
+  source: string,
+  entry: string,
+  message: string,
+): string {
+  return insertTypeProperty(
+    source,
+    "AppTransactionPorts",
+    entry.trim(),
+    message,
+  );
+}
+
+function aliasModule(filePath: string): string {
+  return `@/${modulePath(filePath)}`;
+}
+
+function relativeModule(fromFile: string, toFile: string): string {
+  const fromDir = path.posix.dirname(normalizePath(fromFile));
+  const relative = path.posix.relative(fromDir, normalizePath(toFile));
+  const specifier = modulePath(relative);
+
+  if (specifier.startsWith("../")) return specifier;
+  if (specifier === "..") return specifier;
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+
+function modulePath(filePath: string): string {
+  return directoryPath(filePath)
+    .replace(/\.(?:[cm]?[jt]sx?)$/, "")
+    .replace(/\/index$/, "");
+}
+
+function resourceNames(input: string): ResourceNames {
+  const pluralKebab = normalizeResourceName(input);
+  const singularKebab = singularize(pluralKebab);
+
+  const names = {
+    input,
+    pluralKebab,
+    singularKebab,
+    pluralCamel: camelCase(pluralKebab),
+    singularCamel: camelCase(singularKebab),
+    singularPascal: pascalCase(singularKebab),
+    pluralPascal: pascalCase(pluralKebab),
+  };
+
+  assertGeneratedIdentifiers(input, "Resource name", [
+    names.pluralCamel,
+    names.singularCamel,
+    names.singularPascal,
+    names.pluralPascal,
+  ]);
+
+  return names;
+}
+
+function useCaseNames(input: string): UseCaseNames {
+  const parts = input
+    .trim()
+    .split("/")
+    .map((part) => part.trim())
+    .filter(Boolean);
+
+  if (parts.length !== 2) {
+    throw new Error(
+      "Use case name must use feature/action format, for example projects/archive-project.",
+    );
+  }
+
+  const feature = identifierNames(parts[0], "Use case feature");
+  const action = identifierNames(parts[1], "Use case action");
+  const exportName = `${action.camel}UseCase`;
+
+  assertGeneratedIdentifiers(parts[0], "Use case feature", [
+    feature.camel,
+    feature.pascal,
+  ]);
+  assertGeneratedIdentifiers(parts[1], "Use case action", [
+    action.pascal,
+    exportName,
+  ]);
+
+  return {
+    input,
+    feature,
+    action,
+    exportName,
+    operationName: `${feature.camel}.${action.camel}`,
+    kind: inferUseCaseKind(action.kebab),
+  };
+}
+
+function identifierNames(input: string, label: string): IdentifierNames {
+  const kebab = normalizeName(input, label);
+  return {
+    input,
+    kebab,
+    camel: camelCase(kebab),
+    pascal: pascalCase(kebab),
+  };
+}
+
+function portNames(input: string): PortNames {
+  const names = identifierNames(input, "Port name");
+  const resolvedNames = {
+    ...names,
+    interfaceName: `${names.pascal}Port`,
+    inputName: `Execute${names.pascal}Input`,
+    adapterFactoryName: `create${names.pascal}Adapter`,
+  };
+
+  assertGeneratedIdentifiers(input, "Port name", [
+    resolvedNames.camel,
+    resolvedNames.pascal,
+    resolvedNames.interfaceName,
+    resolvedNames.inputName,
+    resolvedNames.adapterFactoryName,
+  ]);
+
+  return resolvedNames;
+}
+
+function policyNames(input: string): PolicyNames {
+  const names = identifierNames(input, "Policy name");
+  const resolvedNames = {
+    ...names,
+    policyName: `${names.camel}Policy`,
+  };
+
+  assertGeneratedIdentifiers(input, "Policy name", [resolvedNames.policyName]);
+
+  return resolvedNames;
+}
+
+function featureArtifactNames(
+  input: string,
+  label: string,
+): FeatureArtifactNames {
+  const parts = artifactNameParts(input, label);
+  const feature = identifierNames(parts[0], `${label} feature`);
+  const artifact = identifierNames(parts[1], `${label} name`);
+  const featureSingularKebab = singularize(feature.kebab);
+  const names = {
+    input,
+    feature,
+    featureSingularKebab,
+    featureSingularCamel: camelCase(featureSingularKebab),
+    featureSingularPascal: pascalCase(featureSingularKebab),
+    artifact,
+    stableName: `${feature.kebab}.${artifact.kebab}`,
+  };
+
+  assertGeneratedIdentifiers(parts[0], `${label} feature`, [
+    names.feature.camel,
+    names.feature.pascal,
+    names.featureSingularCamel,
+    names.featureSingularPascal,
+  ]);
+  assertGeneratedIdentifiers(parts[1], `${label} name`, [
+    names.artifact.camel,
+    names.artifact.pascal,
+  ]);
+
+  return names;
+}
+
+function eventNames(input: string): EventNames {
+  const names = featureArtifactNames(normalizeEventReference(input), "Event");
+  const eventExportName = `${names.featureSingularPascal}${names.artifact.pascal}`;
+
+  assertGeneratedIdentifiers(input, "Event name", [eventExportName]);
+
+  return {
+    ...names,
+    eventName: names.stableName,
+    eventExportName,
+    payloadSchemaName: `${eventExportName}PayloadSchema`,
+    payloadTypeName: `${eventExportName}Payload`,
+  };
+}
+
+function jobNames(input: string): JobNames {
+  const names = featureArtifactNames(input, "Job");
+  const jobExportName = `${names.artifact.pascal}Job`;
+
+  assertGeneratedIdentifiers(input, "Job name", [jobExportName]);
+
+  return {
+    ...names,
+    jobName: names.stableName,
+    jobExportName,
+    payloadSchemaName: `${jobExportName}PayloadSchema`,
+    payloadTypeName: `${jobExportName}Payload`,
+  };
+}
+
+function listenerNames(input: string, eventInput: string): ListenerNames {
+  const names = featureArtifactNames(input, "Listener");
+  const listenerExportName = names.artifact.camel;
+
+  assertGeneratedIdentifiers(input, "Listener name", [listenerExportName]);
+
+  return {
+    ...names,
+    listenerName: names.stableName,
+    listenerExportName,
+    event: eventNames(eventInput),
+  };
+}
+
+function scheduleNames(
+  input: string,
+  options: { cron?: string; timezone?: string },
+): ScheduleNames {
+  const names = featureArtifactNames(input, "Schedule");
+  const scheduleExportName = `${names.artifact.pascal}Schedule`;
+
+  assertGeneratedIdentifiers(input, "Schedule name", [scheduleExportName]);
+
+  return {
+    ...names,
+    scheduleName: names.stableName,
+    scheduleExportName,
+    payloadSchemaName: `${scheduleExportName}PayloadSchema`,
+    payloadTypeName: `${scheduleExportName}Payload`,
+    cron: options.cron?.trim() || "0 9 * * *",
+    timezone: options.timezone?.trim() || undefined,
+  };
+}
+
+function normalizeEventReference(input: string): string {
+  const trimmed = input.trim();
+  if (trimmed.includes("/")) return trimmed;
+
+  const dotIndex = trimmed.indexOf(".");
+  if (dotIndex === -1) return trimmed;
+
+  return `${trimmed.slice(0, dotIndex)}/${trimmed.slice(dotIndex + 1)}`;
+}
+
+function artifactNameParts(input: string, label: string): [string, string] {
+  const parts = input
+    .trim()
+    .split("/")
+    .map((part) => part.trim())
+    .filter(Boolean);
+
+  if (parts.length !== 2) {
+    throw new Error(
+      `${label} name must use feature/name format, for example posts/published.`,
+    );
+  }
+
+  return [parts[0], parts[1]];
+}
+
+function portStubEntry(names: PortNames): string {
+  return `\t${names.camel}: {\n\t\tasync execute() {\n\t\t\tthrow new Error("${names.interfaceName} is not implemented.");\n\t\t},\n\t} satisfies ${names.interfaceName},`;
+}
+
+function adapterEntry(names: PortNames): string {
+  return `\t${names.camel}: ${names.adapterFactoryName}(),`;
+}
+
+function normalizeResourceName(input: string): string {
+  return normalizeName(input, "Resource name");
+}
+
+function normalizeName(input: string, label: string): string {
+  const normalized = input
+    .trim()
+    .toLowerCase()
+    .replaceAll(/[^a-z0-9]+/g, "-")
+    .replaceAll(/^-+|-+$/g, "");
+
+  if (!normalized) {
+    throw new Error(`${label} is required.`);
+  }
+
+  return normalized;
+}
+
+function assertGeneratedIdentifiers(
+  input: string,
+  label: string,
+  identifiers: readonly string[],
+): void {
+  for (const identifier of new Set(identifiers)) {
+    if (isValidGeneratedIdentifier(identifier)) {
+      continue;
+    }
+
+    throw new Error(
+      `${label} "${input}" generates invalid JavaScript identifier "${identifier}". Use a name that starts with a letter and is not a reserved word.`,
+    );
+  }
+}
+
+function isValidGeneratedIdentifier(identifier: string): boolean {
+  return (
+    /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier) &&
+    !reservedJavaScriptIdentifiers.has(identifier)
+  );
+}
+
+const reservedJavaScriptIdentifiers = new Set([
+  "arguments",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "interface",
+  "let",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+]);
+
+function inferUseCaseKind(action: string): "command" | "query" {
+  if (/^(count|find|get|list|search)-/.test(`${action}-`)) {
+    return "query";
+  }
+  return "command";
+}
+
+function singularize(value: string): string {
+  if (value.endsWith("ies") && value.length > 3) {
+    return `${value.slice(0, -3)}y`;
+  }
+  if (value.endsWith("ses") && value.length > 3) {
+    return value.slice(0, -2);
+  }
+  if (value.endsWith("s") && value.length > 1) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
+
+function camelCase(value: string): string {
+  return value.replaceAll(/-([a-z0-9])/g, (_, char: string) =>
+    char.toUpperCase(),
+  );
+}
+
+function pascalCase(value: string): string {
+  const camel = camelCase(value);
+  return `${camel.charAt(0).toUpperCase()}${camel.slice(1)}`;
+}
+
+function resourceFiles(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  persistence: ResourcePersistence = "memory",
+): GeneratedFile[] {
+  const useCaseDir = resourceUseCaseDir(names, config);
+  const infraDir = infrastructureDir(config);
+  const featureDir = resourceFeatureDir(names, config);
+  const files: GeneratedFile[] = [
+    {
+      path: resourceContractFilePath(names, config),
+      content: contractFile(names, config),
+    },
+    {
+      path: path.join(useCaseDir, "schemas.ts"),
+      content: schemasFile(names),
+    },
+    {
+      path: path.join(useCaseDir, `list-${names.pluralKebab}.ts`),
+      content: listUseCaseFile(names, config),
+    },
+    {
+      path: path.join(useCaseDir, `create-${names.singularKebab}.ts`),
+      content: createUseCaseFile(names, config),
+    },
+    {
+      path: path.join(useCaseDir, "index.ts"),
+      content: useCasesIndexFile(names),
+    },
+    {
+      path: resourcePortFilePath(names, config),
+      content: repositoryPortFile(names, config),
+    },
+    {
+      path: path.join(
+        infraDir,
+        names.pluralKebab,
+        `in-memory-${names.singularKebab}-repository.ts`,
+      ),
+      content: inMemoryRepositoryFile(names, config),
+    },
+    {
+      path: path.join(featureDir, "routes.ts"),
+      content: routeGroupFile(names, config),
+    },
+    {
+      path: resourceTestFilePath(names, config),
+      content: testFile(names, config),
+    },
+  ];
+
+  if (persistence === "drizzle") {
+    files.push(
+      {
+        path: drizzleResourceSchemaFilePath(names, config),
+        content: drizzleSchemaFile(names),
+      },
+      {
+        path: drizzleResourceRepositoryFilePath(names, config),
+        content: drizzleRepositoryFile(names, config),
+      },
+    );
+  }
+
+  return files;
+}
+
+function contractFiles(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: resourceContractFilePath(names, config),
+      content: standaloneContractFile(names),
+    },
+  ];
+}
+
+function useCaseFiles(
+  names: UseCaseNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  const filePath = useCaseFilePath(names, config);
+
+  return [
+    {
+      path: filePath,
+      content: standaloneUseCaseFile(names, config, filePath),
+    },
+  ];
+}
+
+function testFiles(
+  names: UseCaseNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: useCaseTestFilePath(names, config),
+      content: useCaseTestFile(names, config),
+    },
+  ];
+}
+
+function portFiles(
+  names: PortNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: portFilePath(names, config),
+      content: portFile(names),
+    },
+  ];
+}
+
+function adapterFiles(
+  names: PortNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: adapterFilePath(names, config),
+      content: adapterFile(names, config),
+    },
+  ];
+}
+
+function policyFiles(
+  names: PolicyNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: policyFilePath(names, config),
+      content: policyFile(names, config),
+    },
+  ];
+}
+
+function eventFiles(
+  names: EventNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: eventFilePath(names, config),
+      content: eventFile(names),
+    },
+  ];
+}
+
+function jobFiles(
+  names: JobNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: jobFilePath(names, config),
+      content: jobFile(names, config),
+    },
+  ];
+}
+
+function listenerFiles(
+  names: ListenerNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: listenerFilePath(names, config),
+      content: listenerFile(names, config),
+    },
+  ];
+}
+
+function scheduleFiles(
+  names: ScheduleNames,
+  config: ResolvedBeignetConfig,
+  options: { route: boolean },
+): GeneratedFile[] {
+  const files: GeneratedFile[] = [
+    {
+      path: scheduleFilePath(names, config),
+      content: scheduleFile(names, config),
+    },
+  ];
+
+  if (options.route) {
+    files.push({
+      path: scheduleRouteFilePath(names, config),
+      content: scheduleRouteFile(names, config),
+    });
+  }
+
+  return files;
+}
+
+function portFilePath(names: PortNames, config: ResolvedBeignetConfig): string {
+  return path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
+}
+
+function adapterFilePath(
+  names: PortNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    path.dirname(config.paths.infrastructurePorts),
+    names.kebab,
+    `${names.kebab}-adapter.ts`,
+  );
+}
+
+function infrastructureDir(config: ResolvedBeignetConfig): string {
+  return path.dirname(config.paths.infrastructurePorts);
+}
+
+function drizzleSchemaIndexPath(config: ResolvedBeignetConfig): string {
+  return path.join(infrastructureDir(config), "db", "schema", "index.ts");
+}
+
+function drizzleRepositoriesPath(config: ResolvedBeignetConfig): string {
+  return path.join(infrastructureDir(config), "db", "repositories.ts");
+}
+
+function drizzleResourceSchemaFilePath(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    infrastructureDir(config),
+    "db",
+    "schema",
+    `${names.pluralKebab}.ts`,
+  );
+}
+
+function drizzleResourceRepositoryFilePath(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    infrastructureDir(config),
+    names.pluralKebab,
+    `drizzle-${names.singularKebab}-repository.ts`,
+  );
+}
+
+async function detectResourcePersistence(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<ResourcePersistence> {
+  return (await fileExists(
+    path.join(targetDir, drizzleRepositoriesPath(config)),
+  ))
+    ? "drizzle"
+    : "memory";
+}
+
+function resourceFeatureDir(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(config.paths.features, names.pluralKebab);
+}
+
+function usesFeatureOwnedContracts(config: ResolvedBeignetConfig): boolean {
+  return (
+    directoryPath(config.paths.contracts) ===
+    directoryPath(config.paths.features)
+  );
+}
+
+function usesFeatureOwnedUseCases(config: ResolvedBeignetConfig): boolean {
+  return (
+    directoryPath(config.paths.useCases) ===
+    directoryPath(config.paths.features)
+  );
+}
+
+function usesFeatureOwnedPolicies(config: ResolvedBeignetConfig): boolean {
+  return (
+    directoryPath(config.paths.policies) ===
+    directoryPath(config.paths.features)
+  );
+}
+
+function usesFeatureOwnedTests(config: ResolvedBeignetConfig): boolean {
+  return (
+    usesFeatureOwnedUseCases(config) &&
+    directoryPath(config.paths.tests) === "tests"
+  );
+}
+
+function resourceContractFilePath(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  if (usesFeatureOwnedContracts(config)) {
+    return path.join(resourceFeatureDir(names, config), "contracts.ts");
+  }
+
+  return path.join(config.paths.contracts, `${names.pluralKebab}.ts`);
+}
+
+function useCaseFeatureDir(
+  feature: string,
+  config: ResolvedBeignetConfig,
+): string {
+  if (usesFeatureOwnedUseCases(config)) {
+    return path.join(config.paths.features, feature, "use-cases");
+  }
+
+  return path.join(config.paths.useCases, feature);
+}
+
+function resourceUseCaseDir(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return useCaseFeatureDir(names.pluralKebab, config);
+}
+
+function resourceUseCaseIndexPath(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(resourceUseCaseDir(names, config), "index.ts");
+}
+
+function resourcePortFilePath(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  if (usesFeatureOwnedContracts(config)) {
+    return path.join(resourceFeatureDir(names, config), "ports.ts");
+  }
+
+  return path.join(
+    path.dirname(config.paths.ports),
+    `${names.singularKebab}-repository.ts`,
+  );
+}
+
+function resourceTestFilePath(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  if (usesFeatureOwnedTests(config)) {
+    return path.join(
+      resourceFeatureDir(names, config),
+      "tests",
+      `${names.pluralKebab}.test.ts`,
+    );
+  }
+
+  return path.join(config.paths.tests, `${names.pluralKebab}.test.ts`);
+}
+
+function useCaseTestFilePath(
+  names: UseCaseNames,
+  config: ResolvedBeignetConfig,
+): string {
+  if (usesFeatureOwnedTests(config)) {
+    return path.join(
+      config.paths.features,
+      names.feature.kebab,
+      "tests",
+      `${names.action.kebab}.test.ts`,
+    );
+  }
+
+  return path.join(
+    config.paths.tests,
+    names.feature.kebab,
+    `${names.action.kebab}.test.ts`,
+  );
+}
+
+function policyFilePath(
+  names: PolicyNames,
+  config: ResolvedBeignetConfig,
+): string {
+  if (usesFeatureOwnedPolicies(config)) {
+    return path.join(config.paths.features, names.kebab, "policy.ts");
+  }
+
+  return path.join(config.paths.policies, `${names.kebab}.ts`);
+}
+
+function featureArtifactDir(
+  names: FeatureArtifactNames,
+  kind: "events" | "jobs" | "listeners" | "schedules",
+  config: ResolvedBeignetConfig,
+): string {
+  const featureDir = path.join(config.paths.features, names.feature.kebab);
+
+  if (kind === "events") {
+    return path.join(featureDir, "domain", "events");
+  }
+
+  return path.join(featureDir, kind);
+}
+
+function eventFilePath(
+  names: EventNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureArtifactDir(names, "events", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function jobFilePath(names: JobNames, config: ResolvedBeignetConfig): string {
+  return path.join(
+    featureArtifactDir(names, "jobs", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function listenerFilePath(
+  names: ListenerNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureArtifactDir(names, "listeners", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function scheduleFilePath(
+  names: ScheduleNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureArtifactDir(names, "schedules", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function scheduleRouteFilePath(
+  names: ScheduleNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    config.paths.routes,
+    "cron",
+    names.feature.kebab,
+    names.artifact.kebab,
+    "route.ts",
+  );
+}
+
+function useCaseFilePath(
+  names: UseCaseNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    useCaseFeatureDir(names.feature.kebab, config),
+    `${names.action.kebab}.ts`,
+  );
+}
+
+function useCaseIndexFile(
+  names: UseCaseNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile {
+  const filePath = path.join(
+    useCaseFeatureDir(names.feature.kebab, config),
+    "index.ts",
+  );
+  return {
+    path: filePath,
+    content: useCaseIndexExport(names),
+  };
+}
+
+async function updateUseCaseIndex(
+  targetDir: string,
+  file: GeneratedFile,
+  options: { dryRun: boolean },
+): Promise<WriteGeneratedFileResult> {
+  const destination = path.join(targetDir, file.path);
+  const existing = await readOptionalFile(destination);
+  if (existing === undefined) {
+    if (!options.dryRun) {
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, file.content);
+    }
+    return "created";
+  }
+
+  if (existing.includes(file.content.trim())) {
+    return "skipped";
+  }
+
+  const next = `${existing.trimEnd()}\n${file.content}`;
+  if (!options.dryRun) await writeFile(destination, next);
+  return "updated";
+}
+
+type FeatureArtifactIndexFile = {
+  path: string;
+  importName: string;
+  artifactPath: string;
+  registryName: string;
+};
+
+function featureArtifactIndexFile(
+  kind: "event" | "job" | "listener" | "schedule",
+  names: EventNames | JobNames | ListenerNames | ScheduleNames,
+  config: ResolvedBeignetConfig,
+): FeatureArtifactIndexFile {
+  const artifactPath =
+    kind === "event"
+      ? eventFilePath(names as EventNames, config)
+      : kind === "job"
+        ? jobFilePath(names as JobNames, config)
+        : kind === "listener"
+          ? listenerFilePath(names as ListenerNames, config)
+          : scheduleFilePath(names as ScheduleNames, config);
+  const registrySuffix =
+    kind === "event"
+      ? "Events"
+      : kind === "job"
+        ? "Jobs"
+        : kind === "listener"
+          ? "Listeners"
+          : "Schedules";
+  const importName =
+    kind === "event"
+      ? (names as EventNames).eventExportName
+      : kind === "job"
+        ? (names as JobNames).jobExportName
+        : kind === "listener"
+          ? (names as ListenerNames).listenerExportName
+          : (names as ScheduleNames).scheduleExportName;
+
+  return {
+    path: path.join(path.dirname(artifactPath), "index.ts"),
+    importName,
+    artifactPath,
+    registryName: `${names.featureSingularCamel}${registrySuffix}`,
+  };
+}
+
+async function updateFeatureArtifactIndex(
+  targetDir: string,
+  file: FeatureArtifactIndexFile,
+  options: { dryRun: boolean },
+): Promise<WriteGeneratedFileResult> {
+  const destination = path.join(targetDir, file.path);
+  const existing = await readOptionalFile(destination);
+  const specifier = relativeModule(file.path, file.artifactPath);
+  const importLine = `import { ${file.importName} } from "${specifier}";`;
+  const exportLine = `export { ${file.importName} } from "${specifier}";`;
+
+  if (existing === undefined) {
+    const content = `${importLine}
+
+${exportLine}
+
+export const ${file.registryName} = [${file.importName}] as const;
+`;
+    if (!options.dryRun) {
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, content);
+    }
+    return "created";
+  }
+
+  let next = existing;
+
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  if (!next.includes(exportLine)) {
+    const registryExport = new RegExp(
+      `export\\s+const\\s+${file.registryName}\\b`,
+    ).exec(next);
+    next = registryExport
+      ? `${next.slice(0, registryExport.index).trimEnd()}\n${exportLine}\n\n${next.slice(
+          registryExport.index,
+        )}`
+      : `${next.trimEnd()}\n${exportLine}\n`;
+  }
+
+  const registry = arrayInitializerInfo(next, file.registryName);
+  if (!registry) {
+    next = `${next.trimEnd()}\n\nexport const ${file.registryName} = [${file.importName}] as const;\n`;
+  } else if (
+    !identifiersFromArrayExpression(registry.text).has(file.importName)
+  ) {
+    const nextArray = appendToArrayExpression(registry.text, [file.importName]);
+    next = `${next.slice(0, registry.start)}${nextArray}${next.slice(
+      registry.end,
+    )}`;
+  }
+
+  if (next === existing) return "skipped";
+  if (!options.dryRun) await writeFile(destination, next);
+  return "updated";
+}
+
+function arrayInitializerInfo(
+  source: string,
+  constName: string,
+): { text: string; start: number; end: number } | undefined {
+  const match = new RegExp(`\\bconst\\s+${constName}\\s*=`).exec(source);
+  if (!match) return undefined;
+
+  const openBracket = source.indexOf("[", match.index);
+  if (openBracket === -1) return undefined;
+
+  const closeBracket = matchingDelimiterIndex(source, openBracket, "[", "]");
+  if (closeBracket === -1) return undefined;
+
+  return {
+    text: source.slice(openBracket, closeBracket + 1),
+    start: openBracket,
+    end: closeBracket + 1,
+  };
+}
+
+function schemasFile(names: ResourceNames): string {
+  return `import { z } from "zod";
+
+export const ${names.singularPascal}Schema = z.object({
+	id: z.string().uuid(),
+	name: z.string().min(1),
+	createdAt: z.string().datetime(),
+});
+
+export const List${names.pluralPascal}InputSchema = z.object({
+	limit: z.coerce.number().int().min(1).max(100).default(20),
+	offset: z.coerce.number().int().min(0).default(0),
+});
+
+export const List${names.pluralPascal}OutputSchema = z.object({
+	${names.pluralCamel}: z.array(${names.singularPascal}Schema),
+	total: z.number().int().min(0),
+	limit: z.number().int().min(1),
+	offset: z.number().int().min(0),
+});
+
+export const Create${names.singularPascal}InputSchema = z.object({
+	name: z.string().min(1).max(120),
+});
+
+export type ${names.singularPascal} = z.infer<typeof ${names.singularPascal}Schema>;
+export type Create${names.singularPascal}Input = z.infer<
+	typeof Create${names.singularPascal}InputSchema
+>;
+export type List${names.pluralPascal}Input = z.infer<
+	typeof List${names.pluralPascal}InputSchema
+>;
+`;
+}
+
+function listUseCaseFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const filePath = path.join(
+    resourceUseCaseDir(names, config),
+    `list-${names.pluralKebab}.ts`,
+  );
+
+  return `import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+import {
+	List${names.pluralPascal}InputSchema,
+	List${names.pluralPascal}OutputSchema,
+} from "./schemas";
+
+export const list${names.pluralPascal}UseCase = useCase
+	.query("${names.pluralCamel}.list")
+	.input(List${names.pluralPascal}InputSchema)
+	.output(List${names.pluralPascal}OutputSchema)
+	.run(async ({ ctx, input }) => {
+		const result = await ctx.ports.${names.pluralCamel}.list(input);
+		return {
+			${names.pluralCamel}: result.${names.pluralCamel},
+			total: result.total,
+			limit: input.limit,
+			offset: input.offset,
+		};
+	});
+`;
+}
+
+function createUseCaseFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const filePath = path.join(
+    resourceUseCaseDir(names, config),
+    `create-${names.singularKebab}.ts`,
+  );
+
+  return `import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+import {
+	Create${names.singularPascal}InputSchema,
+	${names.singularPascal}Schema,
+} from "./schemas";
+
+export const create${names.singularPascal}UseCase = useCase
+	.command("${names.pluralCamel}.create")
+	.input(Create${names.singularPascal}InputSchema)
+	.output(${names.singularPascal}Schema)
+	.run(async ({ ctx, input }) => ctx.ports.${names.pluralCamel}.create(input));
+`;
+}
+
+function useCasesIndexFile(names: ResourceNames): string {
+  return `export { create${names.singularPascal}UseCase } from "./create-${names.singularKebab}";
+export { list${names.pluralPascal}UseCase } from "./list-${names.pluralKebab}";
+export {
+	Create${names.singularPascal}InputSchema,
+	List${names.pluralPascal}InputSchema,
+	List${names.pluralPascal}OutputSchema,
+	${names.singularPascal}Schema,
+	type Create${names.singularPascal}Input,
+	type List${names.pluralPascal}Input,
+	type ${names.singularPascal},
+} from "./schemas";
+`;
+}
+
+function repositoryPortFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return `import type {
+	Create${names.singularPascal}Input,
+	List${names.pluralPascal}Input,
+	${names.singularPascal},
+} from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
+
+export type List${names.pluralPascal}Result = {
+	${names.pluralCamel}: ${names.singularPascal}[];
+	total: number;
+};
+
+export interface ${names.singularPascal}Repository {
+	list(input: List${names.pluralPascal}Input): Promise<List${names.pluralPascal}Result>;
+	create(input: Create${names.singularPascal}Input): Promise<${names.singularPascal}>;
+}
+`;
+}
+
+function inMemoryRepositoryFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const repositoryPortPath = resourcePortFilePath(names, config);
+
+  return `import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+import type {
+	Create${names.singularPascal}Input,
+	List${names.pluralPascal}Input,
+	${names.singularPascal},
+} from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
+
+export function createInMemory${names.singularPascal}Repository(
+	seed: ${names.singularPascal}[] = [],
+): ${names.singularPascal}Repository {
+	const ${names.pluralCamel} = new Map(seed.map((${names.singularCamel}) => [${names.singularCamel}.id, ${names.singularCamel}]));
+
+	return {
+		async list(input: List${names.pluralPascal}Input) {
+			const all${names.pluralPascal} = Array.from(${names.pluralCamel}.values()).sort(
+				(left, right) => right.createdAt.localeCompare(left.createdAt),
+			);
+
+			return {
+				${names.pluralCamel}: all${names.pluralPascal}.slice(
+					input.offset,
+					input.offset + input.limit,
+				),
+				total: all${names.pluralPascal}.length,
+			};
+		},
+		async create(input: Create${names.singularPascal}Input) {
+			const ${names.singularCamel}: ${names.singularPascal} = {
+				id: crypto.randomUUID(),
+				name: input.name,
+				createdAt: new Date().toISOString(),
+			};
+			${names.pluralCamel}.set(${names.singularCamel}.id, ${names.singularCamel});
+			return ${names.singularCamel};
+		},
+	};
+}
+`;
+}
+
+function drizzleSchemaFile(names: ResourceNames): string {
+  return `import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const ${names.pluralCamel} = sqliteTable("${names.pluralKebab.replaceAll("-", "_")}", {
+	id: text("id").primaryKey(),
+	name: text("name").notNull(),
+	createdAt: text("created_at").notNull(),
+});
+`;
+}
+
+function drizzleRepositoryFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const repositoryPortPath = resourcePortFilePath(names, config);
+  const schemaPath = drizzleSchemaIndexPath(config);
+
+  return `import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
+import { count, desc } from "drizzle-orm";
+import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+import type {
+	Create${names.singularPascal}Input,
+	List${names.pluralPascal}Input,
+	${names.singularPascal},
+} from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
+import * as schema from "${aliasModule(schemaPath)}";
+
+type ${names.singularPascal}Row = typeof schema.${names.pluralCamel}.$inferSelect;
+
+function to${names.singularPascal}(row: ${names.singularPascal}Row): ${names.singularPascal} {
+	return {
+		id: row.id,
+		name: row.name,
+		createdAt: row.createdAt,
+	};
+}
+
+export function createDrizzle${names.singularPascal}Repository(
+	db: DrizzleTursoDatabase<typeof schema>,
+): ${names.singularPascal}Repository {
+	return {
+		async list(input: List${names.pluralPascal}Input) {
+			const rows = await db
+				.select()
+				.from(schema.${names.pluralCamel})
+				.orderBy(desc(schema.${names.pluralCamel}.createdAt))
+				.limit(input.limit)
+				.offset(input.offset);
+			const [{ total }] = await db
+				.select({ total: count() })
+				.from(schema.${names.pluralCamel});
+
+			return {
+				${names.pluralCamel}: rows.map(to${names.singularPascal}),
+				total,
+			};
+		},
+		async create(input: Create${names.singularPascal}Input) {
+			const [row] = await db
+				.insert(schema.${names.pluralCamel})
+				.values({
+					id: crypto.randomUUID(),
+					name: input.name,
+					createdAt: new Date().toISOString(),
+				})
+				.returning();
+
+			if (!row) {
+				throw new Error("Failed to create ${names.singularKebab}.");
+			}
+
+			return to${names.singularPascal}(row);
+		},
+	};
+}
+`;
+}
+
+function contractFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return `import { createContractGroup } from "@beignet/core/contracts";
+import { z } from "zod";
+import {
+	create${names.singularPascal}UseCase,
+	list${names.pluralPascal}UseCase,
+} from "${aliasModule(resourceUseCaseIndexPath(names, config))}";
+
+const ErrorResponseSchema = z.object({
+	code: z.string(),
+	message: z.string(),
+	requestId: z.string().optional(),
+});
+
+const ${names.pluralCamel} = createContractGroup()
+	.namespace("${names.pluralCamel}")
+	.responses({
+		500: ErrorResponseSchema,
+	});
+
+export const list${names.pluralPascal} = ${names.pluralCamel}
+	.get("/api/${names.pluralKebab}")
+	.query(list${names.pluralPascal}UseCase.inputSchema)
+	.responses({
+		200: list${names.pluralPascal}UseCase.outputSchema,
+	});
+
+export const create${names.singularPascal} = ${names.pluralCamel}
+	.post("/api/${names.pluralKebab}")
+	.body(create${names.singularPascal}UseCase.inputSchema)
+	.responses({
+		201: create${names.singularPascal}UseCase.outputSchema,
+	});
+`;
+}
+
+function standaloneContractFile(names: ResourceNames): string {
+  return `import { createContractGroup } from "@beignet/core/contracts";
+import { z } from "zod";
+
+const ErrorResponseSchema = z.object({
+	code: z.string(),
+	message: z.string(),
+	requestId: z.string().optional(),
+});
+
+const ${names.pluralCamel} = createContractGroup()
+	.namespace("${names.pluralCamel}")
+	.responses({
+		500: ErrorResponseSchema,
+	});
+
+export const ${names.singularCamel}Schema = z.object({
+	id: z.string().uuid(),
+	name: z.string().min(1),
+});
+
+export const list${names.pluralPascal} = ${names.pluralCamel}
+	.get("/api/${names.pluralKebab}")
+	.query(
+		z.object({
+			limit: z.coerce.number().int().min(1).max(100).default(20),
+			offset: z.coerce.number().int().min(0).default(0),
+		}),
+	)
+	.responses({
+		200: z.object({
+			${names.pluralCamel}: z.array(${names.singularCamel}Schema),
+			total: z.number().int().min(0),
+			limit: z.number().int().min(1),
+			offset: z.number().int().min(0),
+		}),
+	});
+
+export const ${names.pluralCamel}Contracts = [list${names.pluralPascal}];
+`;
+}
+
+function standaloneUseCaseFile(
+  names: UseCaseNames,
+  config: ResolvedBeignetConfig,
+  filePath: string,
+): string {
+  return `import { z } from "zod";
+import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+
+export const ${names.action.pascal}InputSchema = z.object({});
+
+export const ${names.action.pascal}OutputSchema = z.object({
+	ok: z.literal(true),
+});
+
+export type ${names.action.pascal}Input = z.infer<
+	typeof ${names.action.pascal}InputSchema
+>;
+export type ${names.action.pascal}Output = z.infer<
+	typeof ${names.action.pascal}OutputSchema
+>;
+
+export const ${names.exportName} = useCase
+	.${names.kind}("${names.operationName}")
+	.input(${names.action.pascal}InputSchema)
+	.output(${names.action.pascal}OutputSchema)
+	.run(async () => ({ ok: true }));
+`;
+}
+
+function useCaseTestFile(
+  names: UseCaseNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const filePath = useCaseTestFilePath(names, config);
+
+  return `import { describe, expect, it } from "bun:test";
+import { createUseCaseTester } from "@beignet/core/application";
+import { createInMemoryDevtools } from "@beignet/devtools";
+import { createAnonymousActor, createMemoryStorage, createNoopUnitOfWork } from "@beignet/core/ports";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+import { appPorts } from "${aliasModule(config.paths.infrastructurePorts)}";
+import { ${names.exportName} } from "${relativeModule(filePath, useCaseFilePath(names, config))}";
+
+describe("${names.exportName}", () => {
+	it("runs ${names.action.camel}", async () => {
+		const testPorts = {
+			...appPorts,
+			uow: createNoopUnitOfWork(
+				() => appPorts as unknown as AppContext["ports"],
+			) as AppContext["ports"]["uow"],
+			devtools: createInMemoryDevtools(),
+			storage: createMemoryStorage(),
+		} as AppContext["ports"];
+		const actor = createAnonymousActor();
+		const tester = createUseCaseTester<AppContext>(() => ({
+			requestId: "test-request",
+			actor,
+			auth: null,
+			gate: testPorts.gate.bind({ actor, auth: null }),
+			ports: testPorts,
+		}));
+
+		const result = await tester.run(${names.exportName}, {});
+
+		expect(result).toEqual({ ok: true });
+	});
+});
+`;
+}
+
+function portFile(names: PortNames): string {
+  return `export type ${names.inputName} = Record<string, unknown>;
+
+export interface ${names.interfaceName} {
+	execute(input: ${names.inputName}): Promise<void>;
+}
+
+export type Fake${names.pascal}Call = {
+	input: ${names.inputName};
+};
+
+export interface Fake${names.interfaceName} extends ${names.interfaceName} {
+	calls: Fake${names.pascal}Call[];
+}
+
+export function createFake${names.pascal}Port(): Fake${names.interfaceName} {
+	const calls: Fake${names.pascal}Call[] = [];
+
+	return {
+		calls,
+		async execute(input) {
+			calls.push({ input });
+		},
+	};
+}
+`;
+}
+
+function adapterFile(names: PortNames, config: ResolvedBeignetConfig): string {
+  const filePath = adapterFilePath(names, config);
+  return `import type { ${names.interfaceName} } from "${relativeModule(filePath, portFilePath(names, config))}";
+
+export function ${names.adapterFactoryName}(): ${names.interfaceName} {
+	return {
+		async execute() {
+			throw new Error("${names.interfaceName} is not implemented.");
+		},
+	};
+}
+`;
+}
+
+function policyFile(names: PolicyNames, config: ResolvedBeignetConfig): string {
+  const filePath = policyFilePath(names, config);
+
+  return `import { definePolicy, deny } from "@beignet/core/ports";
+import type { AppContext } from "${relativeModule(filePath, config.paths.appContext)}";
+
+export const ${names.policyName} = definePolicy({
+	"${names.camel}.view": (_ctx: AppContext) => true,
+	"${names.camel}.manage": (_ctx: AppContext) =>
+		deny("You are not allowed to manage this ${names.kebab}."),
+});
+`;
+}
+
+function eventFile(names: EventNames): string {
+  return `import { defineEvent } from "@beignet/core/events";
+import { z } from "zod";
+
+export const ${names.payloadSchemaName} = z.object({
+\tid: z.string().uuid(),
+});
+
+export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
+
+export const ${names.eventExportName} = defineEvent("${names.eventName}", {
+\tpayload: ${names.payloadSchemaName},
+});
+`;
+}
+
+function jobFile(names: JobNames, config: ResolvedBeignetConfig): string {
+  return `import { createJobHandlers } from "@beignet/core/jobs";
+import { z } from "zod";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+const jobs = createJobHandlers<AppContext>();
+
+export const ${names.payloadSchemaName} = z.object({
+\tid: z.string().uuid(),
+});
+
+export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
+
+export const ${names.jobExportName} = jobs.defineJob("${names.jobName}", {
+\tpayload: ${names.payloadSchemaName},
+\tretry: {
+\t\tattempts: 3,
+\t},
+\tasync handle({ payload, ctx }) {
+\t\tctx.ports.logger.info("Job handled", {
+\t\t\tjobName: "${names.jobName}",
+\t\t\tpayload,
+\t\t});
+\t},
+});
+`;
+}
+
+function listenerFile(
+  names: ListenerNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const filePath = listenerFilePath(names, config);
+
+  return `import { createEventHandlers } from "@beignet/core/events";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+import { ${names.event.eventExportName} } from "${relativeModule(filePath, eventFilePath(names.event, config))}";
+
+const events = createEventHandlers<AppContext>();
+
+export const ${names.listenerExportName} = events.defineListener(${names.event.eventExportName}, {
+\tname: "${names.listenerName}",
+\tasync handle({ payload, ctx }) {
+\t\tctx.ports.logger.info("Listener handled", {
+\t\t\tlistenerName: "${names.listenerName}",
+\t\t\tpayload,
+\t\t});
+\t},
+});
+`;
+}
+
+function scheduleFile(
+  names: ScheduleNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return `import { createScheduleHandlers } from "@beignet/core/schedules";
+import { z } from "zod";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+const schedules = createScheduleHandlers<AppContext>();
+
+export const ${names.payloadSchemaName} = z.object({
+\tdate: z.string(),
+});
+
+export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
+
+export const ${names.scheduleExportName} = schedules.defineSchedule(
+\t"${names.scheduleName}",
+\t{
+\t\tcron: "${names.cron}",
+${names.timezone ? `\t\ttimezone: "${names.timezone}",\n` : ""}\t\tpayload: ${names.payloadSchemaName},
+\t\tcreatePayload({ run }) {
+\t\t\tconst date = run.scheduledAt ?? run.triggeredAt;
+
+\t\t\treturn {
+\t\t\t\tdate: date.toISOString().slice(0, 10),
+\t\t\t};
+\t\t},
+\t\tasync handle({ payload, ctx }) {
+\t\t\tctx.ports.logger.info("Schedule handled", {
+\t\t\t\tscheduleName: "${names.scheduleName}",
+\t\t\t\tdate: payload.date,
+\t\t\t});
+\t\t},
+\t},
+);
+`;
+}
+
+function scheduleRouteFile(
+  names: ScheduleNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return `import { createInlineScheduleRunner } from "@beignet/core/schedules";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+import { ${names.scheduleExportName} } from "${aliasModule(scheduleFilePath(names, config))}";
+import { env } from "@/lib/env";
+import { server } from "${aliasModule(config.paths.server)}";
+
+async function run${names.artifact.pascal}(request: Request) {
+\tconst cronSecret = env.CRON_SECRET;
+
+\tif (!cronSecret) {
+\t\treturn Response.json(
+\t\t\t{
+\t\t\t\tok: false,
+\t\t\t\terror: "CRON_SECRET is not configured.",
+\t\t\t\tscheduleName: ${names.scheduleExportName}.name,
+\t\t\t},
+\t\t\t{ status: 500 },
+\t\t);
+\t}
+
+\tif (
+\t\trequest.headers.get("authorization") !== \`Bearer \${cronSecret}\`
+\t) {
+\t\treturn Response.json({ error: "Unauthorized" }, { status: 401 });
+\t}
+
+\tconst ctx = await server.createContextFromNext();
+\tconst runner = createInlineScheduleRunner<AppContext>({
+\t\tctx,
+\t\tonStart({ run, schedule }) {
+\t\t\tctx.ports.devtools.record({
+\t\t\t\ttype: "schedule",
+\t\t\t\twatcher: "schedules",
+\t\t\t\trequestId: ctx.requestId,
+\t\t\t\tscheduleName: schedule.name,
+\t\t\t\tstatus: "started",
+\t\t\t\tcron: schedule.cron,
+\t\t\t\ttimezone: schedule.timezone,
+\t\t\t\tdetails: {
+\t\t\t\t\tsource: run.source,
+\t\t\t\t\tscheduledAt: run.scheduledAt?.toISOString(),
+\t\t\t\t},
+\t\t\t});
+\t\t},
+\t\tonSuccess({ run, schedule }) {
+\t\t\tctx.ports.devtools.record({
+\t\t\t\ttype: "schedule",
+\t\t\t\twatcher: "schedules",
+\t\t\t\trequestId: ctx.requestId,
+\t\t\t\tscheduleName: schedule.name,
+\t\t\t\tstatus: "completed",
+\t\t\t\tcron: schedule.cron,
+\t\t\t\ttimezone: schedule.timezone,
+\t\t\t\tdetails: {
+\t\t\t\t\tsource: run.source,
+\t\t\t\t\tscheduledAt: run.scheduledAt?.toISOString(),
+\t\t\t\t},
+\t\t\t});
+\t\t},
+\t\tonError({ error, run, schedule }) {
+\t\t\tctx.ports.devtools.record({
+\t\t\t\ttype: "schedule",
+\t\t\t\twatcher: "schedules",
+\t\t\t\trequestId: ctx.requestId,
+\t\t\t\tscheduleName: schedule.name,
+\t\t\t\tstatus: "failed",
+\t\t\t\tcron: schedule.cron,
+\t\t\t\ttimezone: schedule.timezone,
+\t\t\t\tdetails: {
+\t\t\t\t\terror,
+\t\t\t\t\tsource: run.source,
+\t\t\t\t\tscheduledAt: run.scheduledAt?.toISOString(),
+\t\t\t\t},
+\t\t\t});
+\t\t\tctx.ports.logger.error("Schedule failed", {
+\t\t\t\terror,
+\t\t\t\tscheduleName: schedule.name,
+\t\t\t});
+\t\t},
+\t\tonHookError({ error, hook, schedule }) {
+\t\t\tctx.ports.logger.warn("Schedule lifecycle hook failed", {
+\t\t\t\terror,
+\t\t\t\thook,
+\t\t\t\tscheduleName: schedule.name,
+\t\t\t});
+\t\t},
+\t});
+
+\ttry {
+\t\tawait runner.run(${names.scheduleExportName}, {
+\t\t\tsource: "cron-route",
+\t\t});
+\t} catch {
+\t\treturn Response.json({ error: "Schedule failed" }, { status: 500 });
+\t}
+
+\treturn Response.json({ ok: true });
+}
+
+export const GET = run${names.artifact.pascal};
+export const POST = run${names.artifact.pascal};
+`;
+}
+
+function useCaseIndexExport(names: UseCaseNames): string {
+  return `export {
+	${names.action.pascal}InputSchema,
+	${names.action.pascal}OutputSchema,
+	${names.exportName},
+	type ${names.action.pascal}Input,
+	type ${names.action.pascal}Output,
+} from "./${names.action.kebab}";
+`;
+}
+
+function routeGroupFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return `import { defineRouteGroup } from "@beignet/next";
+import type { AppContext } from "${relativeModule(path.join(config.paths.features, names.pluralKebab, "routes.ts"), config.paths.appContext)}";
+import { create${names.singularPascal}, list${names.pluralPascal} } from "${relativeModule(path.join(config.paths.features, names.pluralKebab, "routes.ts"), resourceContractFilePath(names, config))}";
+import {
+	create${names.singularPascal}UseCase,
+	list${names.pluralPascal}UseCase,
+} from "${relativeModule(path.join(config.paths.features, names.pluralKebab, "routes.ts"), resourceUseCaseIndexPath(names, config))}";
+
+export const ${names.singularCamel}Routes = defineRouteGroup<AppContext>({
+	name: "${names.pluralKebab}",
+	routes: [
+		{
+			contract: list${names.pluralPascal},
+			handle: async ({ ctx, query }) => ({
+				status: 200,
+				body: await list${names.pluralPascal}UseCase.run({ ctx, input: query }),
+			}),
+		},
+		{
+			contract: create${names.singularPascal},
+			handle: async ({ ctx, body }) => ({
+				status: 201,
+				body: await create${names.singularPascal}UseCase.run({ ctx, input: body }),
+			}),
+		},
+	],
+});
+`;
+}
+
+function testFile(names: ResourceNames, config: ResolvedBeignetConfig): string {
+  const repositoryPath = path.join(
+    path.dirname(config.paths.infrastructurePorts),
+    names.pluralKebab,
+    `in-memory-${names.singularKebab}-repository.ts`,
+  );
+
+  return `import { describe, expect, it } from "bun:test";
+import { createUseCaseTester } from "@beignet/core/application";
+import { createInMemoryDevtools } from "@beignet/devtools";
+import { createAnonymousActor, createMemoryStorage, createNoopUnitOfWork } from "@beignet/core/ports";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+import { appPorts } from "${aliasModule(config.paths.infrastructurePorts)}";
+import { createInMemory${names.singularPascal}Repository } from "${aliasModule(repositoryPath)}";
+import {
+	create${names.singularPascal}UseCase,
+	list${names.pluralPascal}UseCase,
+} from "${aliasModule(resourceUseCaseIndexPath(names, config))}";
+
+describe("${names.pluralCamel} resource", () => {
+	it("creates and lists ${names.pluralCamel}", async () => {
+		const ${names.pluralCamel} = createInMemory${names.singularPascal}Repository();
+		const testPorts = {
+			...appPorts,
+			${names.pluralCamel},
+			uow: createNoopUnitOfWork(() => ({
+				...(appPorts as unknown as AppContext["ports"]),
+				${names.pluralCamel},
+			})) as AppContext["ports"]["uow"],
+			devtools: createInMemoryDevtools(),
+			storage: createMemoryStorage(),
+		} as AppContext["ports"];
+		const actor = createAnonymousActor();
+		const tester = createUseCaseTester<AppContext>(() => ({
+			requestId: "test-request",
+			actor,
+			auth: null,
+			gate: testPorts.gate.bind({ actor, auth: null }),
+			ports: testPorts,
+		}));
+
+		const ctx = await tester.ctx();
+		const created = await tester.run(
+			create${names.singularPascal}UseCase,
+			{ name: "First ${names.singularPascal}" },
+			{ ctx },
+		);
+		const result = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ limit: 20, offset: 0 },
+			{ ctx },
+		);
+
+		expect(created.name).toBe("First ${names.singularPascal}");
+		expect(result.total).toBe(1);
+		expect(result.${names.pluralCamel}).toEqual([created]);
+	});
+});
+`;
+}