@beignet/cli 0.0.1 → 0.0.4

package/src/make.ts

@@ -1,5 +1,6 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
+import type { MakeFeatureAddon } from "./choices.js";
 import {
   type BeignetConfig,
   directoryPath,
@@ -15,6 +16,26 @@ type MakeResourceOptions = {
   force?: boolean;
   dryRun?: boolean;
   config?: BeignetConfig;
+  auth?: boolean;
+  tenant?: boolean;
+  events?: boolean;
+  softDelete?: boolean;
+};
+
+export type { MakeFeatureAddon } from "./choices.js";
+export { makeFeatureAddonChoices } from "./choices.js";
+
+type NormalizedMakeFeatureAddon =
+  | "policy"
+  | "task"
+  | "event"
+  | "job"
+  | "notification"
+  | "ui"
+  | "upload";
+
+type MakeFeatureOptions = MakeResourceOptions & {
+  with?: readonly MakeFeatureAddon[];
 };
 
 type MakeContractOptions = {
@@ -33,6 +54,14 @@ type MakeUseCaseOptions = {
   config?: BeignetConfig;
 };
 
+type MakeTaskOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
 type MakeTestOptions = {
   name: string;
   cwd?: string;
@@ -81,6 +110,30 @@ type MakeJobOptions = {
   config?: BeignetConfig;
 };
 
+type MakeFactoryOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeSeedOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeNotificationOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
 type MakeListenerOptions = {
   name: string;
   event: string;
@@ -101,7 +154,16 @@ type MakeScheduleOptions = {
   route?: boolean;
 };
 
+type MakeUploadOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
 type MakeResult = {
+  schemaVersion: 1;
   name: string;
   targetDir: string;
   dryRun: boolean;
@@ -111,17 +173,74 @@ type MakeResult = {
   skippedFiles: string[];
 };
 
+/**
+ * Result returned by `beignet make resource`.
+ */
 export type MakeResourceResult = MakeResult;
+/**
+ * Result returned by `beignet make feature`.
+ */
+export type MakeFeatureResult = MakeResult;
+/**
+ * Result returned by `beignet make contract`.
+ */
 export type MakeContractResult = MakeResult;
+/**
+ * Result returned by `beignet make use-case`.
+ */
 export type MakeUseCaseResult = MakeResult;
+/**
+ * Result returned by `beignet make task`.
+ */
+export type MakeTaskResult = MakeResult;
+/**
+ * Result returned by `beignet make test`.
+ */
 export type MakeTestResult = MakeResult;
+/**
+ * Result returned by `beignet make port`.
+ */
 export type MakePortResult = MakeResult;
+/**
+ * Result returned by `beignet make adapter`.
+ */
 export type MakeAdapterResult = MakeResult;
+/**
+ * Result returned by `beignet make policy`.
+ */
 export type MakePolicyResult = MakeResult;
+/**
+ * Result returned by `beignet make event`.
+ */
 export type MakeEventResult = MakeResult;
+/**
+ * Result returned by `beignet make job`.
+ */
 export type MakeJobResult = MakeResult;
+/**
+ * Result returned by `beignet make factory`.
+ */
+export type MakeFactoryResult = MakeResult;
+/**
+ * Result returned by `beignet make seed`.
+ */
+export type MakeSeedResult = MakeResult;
+/**
+ * Result returned by `beignet make notification`.
+ */
+export type MakeNotificationResult = MakeResult;
+/**
+ * Result returned by `beignet make listener`.
+ */
 export type MakeListenerResult = MakeResult;
+/**
+ * Result returned by `beignet make schedule`.
+ */
 export type MakeScheduleResult = MakeResult;
+/**
+ * Result returned by `beignet make upload`.
+ */
+export type MakeUploadResult = MakeResult;
 
 type ResourceNames = {
   input: string;
@@ -133,6 +252,15 @@ type ResourceNames = {
   pluralPascal: string;
 };
 
+type ResourceGenerationMode = "feature" | "resource";
+
+type ResourceGenerationOptions = {
+  auth: boolean;
+  tenant: boolean;
+  events: boolean;
+  softDelete: boolean;
+};
+
 type GeneratedFile = {
   path: string;
   content: string;
@@ -190,6 +318,30 @@ type JobNames = FeatureArtifactNames & {
   payloadTypeName: string;
 };
 
+type TaskNames = FeatureArtifactNames & {
+  taskName: string;
+  taskExportName: string;
+  inputSchemaName: string;
+  inputTypeName: string;
+};
+
+type FactoryNames = FeatureArtifactNames & {
+  factoryName: string;
+  factoryExportName: string;
+};
+
+type SeedNames = FeatureArtifactNames & {
+  seedName: string;
+  seedExportName: string;
+};
+
+type NotificationNames = FeatureArtifactNames & {
+  notificationName: string;
+  notificationExportName: string;
+  payloadSchemaName: string;
+  payloadTypeName: string;
+};
+
 type ListenerNames = FeatureArtifactNames & {
   listenerName: string;
   listenerExportName: string;
@@ -205,8 +357,58 @@ type ScheduleNames = FeatureArtifactNames & {
   timezone?: string;
 };
 
+type UploadNames = FeatureArtifactNames & {
+  uploadName: string;
+  uploadExportName: string;
+  metadataSchemaName: string;
+  metadataTypeName: string;
+};
+
+type FeatureUiNames = ResourceNames & {
+  componentExportName: string;
+  componentFileName: string;
+};
+
 export async function makeResource(
   options: MakeResourceOptions,
+): Promise<MakeResourceResult> {
+  return makeResourceSlice(options, "resource");
+}
+
+export async function makeFeature(
+  options: MakeFeatureOptions,
+): Promise<MakeFeatureResult> {
+  const addons = normalizeMakeFeatureAddons(options.with ?? []);
+  if (addons.length === 0) {
+    return makeFeatureResource(options);
+  }
+
+  if (options.dryRun) {
+    return makeFeatureSlice(options, addons);
+  }
+
+  await makeFeatureSlice({ ...options, dryRun: true }, addons);
+  return makeFeatureSlice(options, addons);
+}
+
+async function makeFeatureResource(
+  options: MakeResourceOptions,
+): Promise<MakeResourceResult> {
+  try {
+    return await makeResourceSlice(options, "feature");
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("make resource")) {
+      throw new Error(
+        error.message.replaceAll("make resource", "make feature"),
+      );
+    }
+    throw error;
+  }
+}
+
+async function makeResourceSlice(
+  options: MakeResourceOptions,
+  mode: ResourceGenerationMode,
 ): Promise<MakeResourceResult> {
   const targetDir = path.resolve(options.cwd ?? process.cwd());
   const names = resourceNames(options.name);
@@ -215,9 +417,24 @@ export async function makeResource(
     : await loadBeignetConfig(targetDir);
 
   await assertStandardApp(targetDir, config);
+  if (
+    mode === "resource" &&
+    !(await fileExists(path.join(targetDir, resourceSharedErrorsPath(config))))
+  ) {
+    throw new Error(
+      `beignet make resource expects an app error catalog. Missing ${resourceSharedErrorsPath(config)}.`,
+    );
+  }
 
   const persistence = await detectResourcePersistence(targetDir, config);
-  const generatedFiles = resourceFiles(names, config, persistence);
+  const generationOptions = resourceGenerationOptions(options, mode);
+  const generatedFiles = resourceFiles(
+    names,
+    config,
+    persistence,
+    mode,
+    generationOptions,
+  );
   const plannedFiles = await planGeneratedFiles(targetDir, generatedFiles, {
     force: Boolean(options.force),
   });
@@ -228,6 +445,8 @@ export async function makeResource(
     persistence,
     {
       dryRun: true,
+      mode,
+      generationOptions,
     },
   );
   const createdFiles = plannedFiles
@@ -251,11 +470,14 @@ export async function makeResource(
       ...(await updateResourceWiring(targetDir, names, config, {
         persistence,
         dryRun: false,
+        mode,
+        generationOptions,
       })),
     );
   }
 
   return {
+    schemaVersion: 1,
     name: names.pluralKebab,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -266,6 +488,113 @@ export async function makeResource(
   };
 }
 
+function resourceGenerationOptions(
+  options: MakeResourceOptions,
+  mode: ResourceGenerationMode,
+): ResourceGenerationOptions {
+  if (mode !== "resource") {
+    return { auth: false, tenant: false, events: false, softDelete: false };
+  }
+
+  return {
+    auth: Boolean(options.auth),
+    tenant: Boolean(options.tenant),
+    events: Boolean(options.events),
+    softDelete: Boolean(options.softDelete),
+  };
+}
+
+async function makeFeatureSlice(
+  options: MakeFeatureOptions,
+  addons: readonly NormalizedMakeFeatureAddon[],
+): Promise<MakeFeatureResult> {
+  let result = await makeFeatureResource(options);
+
+  for (const addon of addons) {
+    result = mergeMakeResults(
+      result,
+      await makeFeatureAddon(addon, result.name, options),
+    );
+  }
+
+  return result;
+}
+
+async function makeFeatureAddon(
+  addon: NormalizedMakeFeatureAddon,
+  feature: string,
+  options: MakeFeatureOptions,
+): Promise<MakeResult> {
+  const shared = {
+    cwd: options.cwd,
+    force: options.force,
+    dryRun: options.dryRun,
+    config: options.config,
+  };
+
+  if (addon === "policy") {
+    return makePolicy({ ...shared, name: feature });
+  }
+  if (addon === "task") {
+    return makeTask({ ...shared, name: `${feature}/backfill` });
+  }
+  if (addon === "event") {
+    return makeEvent({ ...shared, name: `${feature}/created` });
+  }
+  if (addon === "job") {
+    return makeJob({ ...shared, name: `${feature}/process` });
+  }
+  if (addon === "notification") {
+    return makeNotification({ ...shared, name: `${feature}/created` });
+  }
+  if (addon === "ui") {
+    return makeFeatureUi({ ...shared, name: feature });
+  }
+
+  return makeUpload({ ...shared, name: `${feature}/attachment` });
+}
+
+function normalizeMakeFeatureAddons(
+  addons: readonly MakeFeatureAddon[],
+): NormalizedMakeFeatureAddon[] {
+  const normalized = new Set<NormalizedMakeFeatureAddon>();
+
+  for (const addon of addons) {
+    if (addon === "events") normalized.add("event");
+    else if (addon === "tasks") normalized.add("task");
+    else if (addon === "jobs") normalized.add("job");
+    else if (addon === "notifications") normalized.add("notification");
+    else if (addon === "uploads") normalized.add("upload");
+    else normalized.add(addon);
+  }
+
+  return featureAddonOrder.filter((addon) => normalized.has(addon));
+}
+
+const featureAddonOrder: readonly NormalizedMakeFeatureAddon[] = [
+  "policy",
+  "task",
+  "event",
+  "job",
+  "notification",
+  "ui",
+  "upload",
+];
+
+function mergeMakeResults(left: MakeResult, right: MakeResult): MakeResult {
+  return {
+    ...left,
+    files: uniqueStrings([...left.files, ...right.files]),
+    createdFiles: uniqueStrings([...left.createdFiles, ...right.createdFiles]),
+    updatedFiles: uniqueStrings([...left.updatedFiles, ...right.updatedFiles]),
+    skippedFiles: uniqueStrings([...left.skippedFiles, ...right.skippedFiles]),
+  };
+}
+
+function uniqueStrings(values: readonly string[]): string[] {
+  return [...new Set(values)];
+}
+
 export async function makeContract(
   options: MakeContractOptions,
 ): Promise<MakeContractResult> {
@@ -290,6 +619,7 @@ export async function makeContract(
   }
 
   return {
+    schemaVersion: 1,
     name: names.pluralKebab,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -335,6 +665,7 @@ export async function makeUseCase(
   if (indexResult === "skipped") skippedFiles.push(indexFile.path);
 
   return {
+    schemaVersion: 1,
     name: `${names.feature.kebab}/${names.action.kebab}`,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -371,11 +702,16 @@ export async function makeTest(
     if (result === "skipped") skippedFiles.push(file.path);
   }
 
-  if (await updatePackageJson(targetDir, { dryRun: Boolean(options.dryRun) })) {
+  if (
+    await updatePackageJson(targetDir, {
+      dryRun: Boolean(options.dryRun),
+    })
+  ) {
     updatedFiles.push("package.json");
   }
 
   return {
+    schemaVersion: 1,
     name: `${names.feature.kebab}/${names.action.kebab}`,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -438,6 +774,7 @@ export async function makePort(
   }
 
   return {
+    schemaVersion: 1,
     name: names.kebab,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -483,6 +820,7 @@ export async function makeAdapter(
   }
 
   return {
+    schemaVersion: 1,
     name: names.kebab,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -520,6 +858,7 @@ export async function makePolicy(
   }
 
   return {
+    schemaVersion: 1,
     name: names.kebab,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -570,7 +909,10 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
     force: Boolean(options.force),
     dryRun: Boolean(options.dryRun),
     name: `${names.feature.kebab}/${names.artifact.kebab}`,
-    files: jobFiles(names, config),
+    files: [
+      ...(await missingCapabilityBuilderFiles(targetDir, "jobs", config)),
+      ...jobFiles(names, config),
+    ],
     index: featureArtifactIndexFile("job", names, config),
     dependencies: {
       "@beignet/core": beignetDependencyVersion,
@@ -578,6 +920,131 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   });
 }
 
+export async function makeTask(
+  options: MakeTaskOptions,
+): Promise<MakeTaskResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = taskNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertFeatureArtifactApp(targetDir, config, "task");
+
+  const result = await makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: [
+      ...(await missingCapabilityBuilderFiles(targetDir, "tasks", config)),
+      ...taskFiles(names, config),
+    ],
+    index: featureArtifactIndexFile("task", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+
+  const registryResult = await updateTaskRegistry(targetDir, names, config, {
+    dryRun: Boolean(options.dryRun),
+  });
+  if (registryResult === "created")
+    result.createdFiles.push(config.paths.tasks);
+  if (registryResult === "updated")
+    result.updatedFiles.push(config.paths.tasks);
+  if (registryResult === "skipped")
+    result.skippedFiles.push(config.paths.tasks);
+  if (!result.files.includes(config.paths.tasks)) {
+    result.files.push(config.paths.tasks);
+  }
+
+  return result;
+}
+
+export async function makeFactory(
+  options: MakeFactoryOptions,
+): Promise<MakeFactoryResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = factoryNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertPersistenceArtifactApp(targetDir, names, config, "factory");
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: factoryFiles(names, config),
+    index: featureArtifactIndexFile("factory", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
+export async function makeSeed(
+  options: MakeSeedOptions,
+): Promise<MakeSeedResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = seedNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertPersistenceArtifactApp(targetDir, names, config, "seed");
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: seedFiles(names, config),
+    index: featureArtifactIndexFile("seed", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
+export async function makeNotification(
+  options: MakeNotificationOptions,
+): Promise<MakeNotificationResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = notificationNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertFeatureArtifactApp(targetDir, config, "notification");
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: [
+      ...(await missingCapabilityBuilderFiles(
+        targetDir,
+        "notifications",
+        config,
+      )),
+      ...notificationFiles(names, config),
+    ],
+    index: featureArtifactIndexFile("notification", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
 export async function makeListener(
   options: MakeListenerOptions,
 ): Promise<MakeListenerResult> {
@@ -596,7 +1063,10 @@ export async function makeListener(
     force: Boolean(options.force),
     dryRun: Boolean(options.dryRun),
     name: `${names.feature.kebab}/${names.artifact.kebab}`,
-    files: listenerFiles(names, config),
+    files: [
+      ...(await missingCapabilityBuilderFiles(targetDir, "listeners", config)),
+      ...listenerFiles(names, config),
+    ],
     index: featureArtifactIndexFile("listener", names, config),
     dependencies: {
       "@beignet/core": beignetDependencyVersion,
@@ -636,7 +1106,10 @@ export async function makeSchedule(
     requireServer: Boolean(options.route),
   });
 
-  const files = scheduleFiles(names, config, { route: Boolean(options.route) });
+  const files = [
+    ...(await missingCapabilityBuilderFiles(targetDir, "schedules", config)),
+    ...scheduleFiles(names, config, { route: Boolean(options.route) }),
+  ];
 
   return makeFeatureArtifact({
     targetDir,
@@ -652,47 +1125,136 @@ export async function makeSchedule(
   });
 }
 
-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,
-  ];
+export async function makeUpload(
+  options: MakeUploadOptions,
+): Promise<MakeUploadResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = uploadNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
 
-  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}.`,
-      );
-    }
-  }
-}
+  await assertFeatureArtifactApp(targetDir, config, "upload");
 
-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}.`,
-    );
-  }
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: uploadFiles(names, config),
+    index: featureArtifactIndexFile("upload", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
 }
 
-async function assertTestApp(
-  targetDir: string,
-  names: UseCaseNames,
-  config: ResolvedBeignetConfig,
-): Promise<void> {
+async function makeFeatureUi(
+  options: MakeResourceOptions,
+): Promise<MakeResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = featureUiNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertFeatureUiApp(targetDir, config);
+
+  const componentFiles = featureUiComponentFiles(names, config);
+  const indexFile = featureUiIndexFile(names, config);
+  const plannedFiles = await planGeneratedFiles(targetDir, componentFiles, {
+    force: Boolean(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(targetDir, file);
+    }
+  }
+
+  const indexResult = await updateFeatureUiIndex(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);
+
+  if (
+    await updatePackageDependencies(
+      targetDir,
+      {
+        "@beignet/react-query": beignetDependencyVersion,
+        "@tanstack/react-query": tanstackReactQueryDependencyVersion,
+      },
+      { dryRun: Boolean(options.dryRun) },
+    )
+  ) {
+    updatedFiles.push("package.json");
+  }
+
+  return {
+    schemaVersion: 1,
+    name: names.pluralKebab,
+    targetDir,
+    dryRun: Boolean(options.dryRun),
+    files: [...componentFiles.map((file) => file.path), indexFile.path],
+    createdFiles,
+    updatedFiles,
+    skippedFiles,
+  };
+}
+
+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,
@@ -777,7 +1339,14 @@ async function assertPolicyApp(
 async function assertFeatureArtifactApp(
   targetDir: string,
   config: ResolvedBeignetConfig,
-  artifact: "event" | "job" | "listener" | "schedule",
+  artifact:
+    | "event"
+    | "job"
+    | "task"
+    | "notification"
+    | "listener"
+    | "schedule"
+    | "upload",
   options: { requireServer?: boolean } = {},
 ): Promise<void> {
   const requiredFiles = [
@@ -796,6 +1365,47 @@ async function assertFeatureArtifactApp(
   }
 }
 
+async function assertFeatureUiApp(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<void> {
+  const clientPath = clientIndexPath(config);
+  const requiredFiles = [config.paths.appContext, clientPath];
+
+  for (const file of requiredFiles) {
+    try {
+      await stat(path.join(targetDir, file));
+    } catch {
+      throw new Error(
+        `beignet make feature --with ui expects a standard Beignet app with React Query client helpers. Missing ${file}.`,
+      );
+    }
+  }
+}
+
+async function assertPersistenceArtifactApp(
+  targetDir: string,
+  names: FactoryNames | SeedNames,
+  config: ResolvedBeignetConfig,
+  artifact: "factory" | "seed",
+): Promise<void> {
+  const requiredFiles = [
+    config.paths.appContext,
+    config.paths.ports,
+    resourcePortFilePath(featureResourceNames(names), config),
+  ];
+
+  for (const file of requiredFiles) {
+    try {
+      await stat(path.join(targetDir, file));
+    } catch {
+      throw new Error(
+        `beignet make ${artifact} expects a feature with a repository port. Missing ${file}. Run beignet make feature ${names.feature.kebab} first, or add the repository port before generating ${artifact}s.`,
+      );
+    }
+  }
+}
+
 type WriteGeneratedFileOptions = {
   force: boolean;
   dryRun: boolean;
@@ -884,6 +1494,83 @@ async function readOptionalFile(filePath: string): Promise<string | undefined> {
   }
 }
 
+type CapabilityBuilder =
+  | "listeners"
+  | "jobs"
+  | "schedules"
+  | "notifications"
+  | "tasks";
+
+const capabilityBuilders: Record<
+  CapabilityBuilder,
+  { factoryName: string; defineName: string; module: string }
+> = {
+  listeners: {
+    factoryName: "createListeners",
+    defineName: "defineListener",
+    module: "@beignet/core/events",
+  },
+  jobs: {
+    factoryName: "createJobs",
+    defineName: "defineJob",
+    module: "@beignet/core/jobs",
+  },
+  schedules: {
+    factoryName: "createSchedules",
+    defineName: "defineSchedule",
+    module: "@beignet/core/schedules",
+  },
+  notifications: {
+    factoryName: "createNotifications",
+    defineName: "defineNotification",
+    module: "@beignet/core/notifications",
+  },
+  tasks: {
+    factoryName: "createTasks",
+    defineName: "defineTask",
+    module: "@beignet/core/tasks",
+  },
+};
+
+function capabilityBuilderPath(
+  capability: CapabilityBuilder,
+  config: ResolvedBeignetConfig,
+): string {
+  if (capability === "listeners") return config.paths.listenersBuilder;
+  if (capability === "jobs") return config.paths.jobsBuilder;
+  if (capability === "schedules") return config.paths.schedulesBuilder;
+  if (capability === "notifications") return config.paths.notificationsBuilder;
+  return config.paths.tasksBuilder;
+}
+
+function capabilityBuilderFile(
+  capability: CapabilityBuilder,
+  config: ResolvedBeignetConfig,
+): GeneratedFile {
+  const builder = capabilityBuilders[capability];
+
+  return {
+    path: capabilityBuilderPath(capability, config),
+    content: `import { ${builder.factoryName} } from "${builder.module}";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+export const { ${builder.defineName} } = ${builder.factoryName}<AppContext>();
+`,
+  };
+}
+
+async function missingCapabilityBuilderFiles(
+  targetDir: string,
+  capability: CapabilityBuilder,
+  config: ResolvedBeignetConfig,
+): Promise<GeneratedFile[]> {
+  const file = capabilityBuilderFile(capability, config);
+  if (await fileExists(path.join(targetDir, file.path))) {
+    return [];
+  }
+  return [file];
+}
+
 async function makeFeatureArtifact(options: {
   targetDir: string;
   config: ResolvedBeignetConfig;
@@ -935,6 +1622,7 @@ async function makeFeatureArtifact(options: {
   }
 
   return {
+    schemaVersion: 1,
     name: options.name,
     targetDir: options.targetDir,
     dryRun: options.dryRun,
@@ -978,14 +1666,29 @@ function beignetDependencyVersion(packageJson: PackageJsonLike): string {
   );
 }
 
+function tanstackReactQueryDependencyVersion(
+  packageJson: PackageJsonLike,
+): string {
+  return packageJson.dependencies?.["@tanstack/react-query"] ?? "^5.100.7";
+}
+
 async function updateResourceWiring(
   targetDir: string,
   names: ResourceNames,
   config: ResolvedBeignetConfig,
   persistenceOrOptions:
     | ResourcePersistence
-    | { dryRun: boolean; persistence?: ResourcePersistence },
-  maybeOptions?: { dryRun: boolean },
+    | {
+        dryRun: boolean;
+        persistence?: ResourcePersistence;
+        mode?: ResourceGenerationMode;
+        generationOptions?: ResourceGenerationOptions;
+      },
+  maybeOptions?: {
+    dryRun: boolean;
+    mode?: ResourceGenerationMode;
+    generationOptions?: ResourceGenerationOptions;
+  },
 ): Promise<string[]> {
   const persistence =
     typeof persistenceOrOptions === "string"
@@ -995,12 +1698,49 @@ async function updateResourceWiring(
     typeof persistenceOrOptions === "string"
       ? (maybeOptions as { dryRun: boolean })
       : persistenceOrOptions;
+  const mode =
+    typeof persistenceOrOptions === "string"
+      ? (maybeOptions?.mode ?? "feature")
+      : (persistenceOrOptions.mode ?? "feature");
+  const generationOptions =
+    typeof persistenceOrOptions === "string"
+      ? (maybeOptions?.generationOptions ??
+        resourceGenerationOptions({ name: names.pluralKebab }, mode))
+      : (persistenceOrOptions.generationOptions ??
+        resourceGenerationOptions({ name: names.pluralKebab }, mode));
   const updated = new Set<string>();
-  if (await updatePackageJson(targetDir, options)) updated.add("package.json");
-  if (await updatePortsIndex(targetDir, names, config, options)) {
+  if (
+    await updatePackageJson(targetDir, {
+      ...options,
+      webTestingDependency: true,
+    })
+  ) {
+    updated.add("package.json");
+  }
+  if (
+    await updatePortsIndex(targetDir, names, config, {
+      ...options,
+      generationOptions,
+    })
+  ) {
     updated.add(config.paths.ports);
   }
-  if (await updateInfrastructurePorts(targetDir, names, config, options)) {
+  if (
+    persistence === "memory" &&
+    (await updateInfrastructurePorts(targetDir, names, config, options))
+  ) {
+    updated.add(config.paths.infrastructurePorts);
+  }
+  if (
+    generationOptions.auth &&
+    (await updateInfrastructureGatePolicies(targetDir, names, config, options))
+  ) {
+    updated.add(config.paths.infrastructurePorts);
+  }
+  if (
+    persistence === "drizzle" &&
+    (await updateInfrastructureDeferredPorts(targetDir, names, config, options))
+  ) {
     updated.add(config.paths.infrastructurePorts);
   }
   if (
@@ -1021,7 +1761,14 @@ async function updateResourceWiring(
   ) {
     updated.add(config.paths.server);
   }
-  if (await updateOpenApiRoute(targetDir, names, config, options)) {
+  if (
+    await updateSharedErrors(targetDir, names, config, { ...options, mode })
+  ) {
+    updated.add(resourceSharedErrorsPath(config));
+  }
+  if (
+    await updateOpenApiRoute(targetDir, names, config, { ...options, mode })
+  ) {
     updated.add(config.paths.openapiRoute);
   }
   const routesFile = await updateServerRoutes(
@@ -1037,17 +1784,27 @@ async function updateResourceWiring(
 
 async function updatePackageJson(
   targetDir: string,
-  options: { dryRun: boolean },
+  options: { dryRun: boolean; webTestingDependency?: 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>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
   };
   packageJson.scripts = packageJson.scripts ?? {};
-  if (packageJson.scripts.test) return false;
 
-  packageJson.scripts.test = "bun test";
+  packageJson.scripts.test ??= "bun test";
+
+  if (options.webTestingDependency) {
+    packageJson.devDependencies = packageJson.devDependencies ?? {};
+    packageJson.devDependencies["@beignet/web"] ??=
+      packageJson.dependencies?.["@beignet/core"] ??
+      packageJson.dependencies?.["@beignet/next"] ??
+      "*";
+  }
+
   const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
   if (!options.dryRun) await writeFile(filePath, next);
   return next !== original;
@@ -1057,7 +1814,7 @@ async function updatePortsIndex(
   targetDir: string,
   names: ResourceNames,
   config: ResolvedBeignetConfig,
-  options: { dryRun: boolean },
+  options: { dryRun: boolean; generationOptions?: ResourceGenerationOptions },
 ): Promise<boolean> {
   const filePath = path.join(targetDir, config.paths.ports);
   const original = await readFile(filePath, "utf8");
@@ -1069,6 +1826,30 @@ async function updatePortsIndex(
     next = insertAfterImports(next, importLine);
   }
 
+  if (options.generationOptions?.auth) {
+    const policyPath = path.join(
+      config.paths.features,
+      names.pluralKebab,
+      "policy.ts",
+    );
+    const policyImportLine = `import type { AuthorizationContext as ${names.singularPascal}AuthorizationContext, ${names.singularCamel}Policy } from "${relativeModule(config.paths.ports, policyPath)}";`;
+    if (!next.includes(policyImportLine)) {
+      next = insertAfterImports(next, policyImportLine);
+    }
+
+    next = appendUnionTypeMember(
+      next,
+      "AppAuthorizationContext",
+      `${names.singularPascal}AuthorizationContext`,
+    );
+    next = appendTupleTypeMember(
+      next,
+      "AppGate",
+      `typeof ${names.singularCamel}Policy`,
+    );
+    next = appendGatePolicyMember(next, `typeof ${names.singularCamel}Policy`);
+  }
+
   const entry = `\t${names.pluralCamel}: ${names.singularPascal}Repository;`;
   if (!next.includes(entry.trim())) {
     next = insertTypeProperty(
@@ -1225,7 +2006,7 @@ async function updateInfrastructurePorts(
   if (!next.includes(repositoryConst)) {
     next = replaceRequired(
       next,
-      /(\nexport const appPorts = definePorts(?:<[^>]+>)?\(\{)/,
+      /(\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.`,
     );
@@ -1262,6 +2043,37 @@ async function updateInfrastructurePorts(
   return true;
 }
 
+async function updateInfrastructureGatePolicies(
+  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 policyPath = path.join(
+    config.paths.features,
+    names.pluralKebab,
+    "policy.ts",
+  );
+  const importLine = `import { ${names.singularCamel}Policy } from "${relativeModule(config.paths.infrastructurePorts, policyPath)}";`;
+
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  next = appendCreateGatePolicy(
+    next,
+    `${names.singularCamel}Policy`,
+    `Could not find createGate({ policies: [...] }) in ${config.paths.infrastructurePorts}. Add ${names.singularCamel}Policy to the gate policies manually, or restore the generated infrastructure ports file before running make resource --auth.`,
+  );
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
 async function updateDrizzleSchemaIndex(
   targetDir: string,
   names: ResourceNames,
@@ -1319,6 +2131,24 @@ async function updateDrizzleRepositories(
   return true;
 }
 
+async function updateInfrastructureDeferredPorts(
+  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");
+  // Drizzle resources are provided by the app database provider at startup,
+  // so deferred-form ports files defer the new repository key. Identity-form
+  // ports files are left untouched.
+  const next = appendDeferredPortKey(original, names.pluralCamel);
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
 async function updateServerTransactionPorts(
   targetDir: string,
   names: ResourceNames,
@@ -1359,7 +2189,7 @@ async function updateOpenApiRoute(
   targetDir: string,
   names: ResourceNames,
   config: ResolvedBeignetConfig,
-  options: { dryRun: boolean },
+  options: { dryRun: boolean; mode: ResourceGenerationMode },
 ): Promise<boolean> {
   const filePath = path.join(targetDir, config.paths.openapiRoute);
   if (!(await fileExists(filePath))) return false;
@@ -1368,15 +2198,14 @@ async function updateOpenApiRoute(
   const firstArg = firstCreateOpenAPIHandlerArgInfo(original);
   if (!firstArg?.text.startsWith("[")) return false;
 
-  const listName = `list${names.pluralPascal}`;
-  const createName = `create${names.singularPascal}`;
+  const contractNames = resourceContractNames(names, options.mode);
   const listedContracts = identifiersFromArrayExpression(firstArg.text);
-  const missingContracts = [listName, createName].filter(
+  const missingContracts = contractNames.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 importLine = `import { ${contractNames.join(", ")} } from "${aliasModule(resourceContractFilePath(names, config))}";`;
   const nextArray = appendToArrayExpression(firstArg.text, missingContracts);
   let next = `${original.slice(0, firstArg.start)}${nextArray}${original.slice(
     firstArg.end,
@@ -1391,38 +2220,106 @@ async function updateOpenApiRoute(
   return true;
 }
 
-async function updateServerRoutes(
+async function updateSharedErrors(
   targetDir: string,
   names: ResourceNames,
   config: ResolvedBeignetConfig,
-  options: { dryRun: boolean },
-): Promise<string | undefined> {
-  const filePath = path.join(targetDir, config.paths.server);
+  options: { dryRun: boolean; mode: ResourceGenerationMode },
+): Promise<boolean> {
+  if (options.mode !== "resource") return false;
+
+  const filePath = path.join(targetDir, resourceSharedErrorsPath(config));
+  if (!(await fileExists(filePath))) return false;
+
   const original = await readFile(filePath, "utf8");
-  const routeRegistryPath = routeRegistryFileFromServerSource(
-    original,
-    config.paths.server,
+  const notFoundErrorName = `${names.singularPascal}NotFound`;
+  const conflictErrorName = `${names.singularPascal}Conflict`;
+  const missingErrorNames = [notFoundErrorName, conflictErrorName].filter(
+    (errorName) => !new RegExp(`\\b${errorName}\\b`).test(original),
   );
+  if (missingErrorNames.length === 0) return false;
+  const expectedErrorNames = missingErrorNames.join(" and ");
 
-  if (routeRegistryPath) {
-    await assertImportedRoutesFileExists(targetDir, routeRegistryPath);
-    return updateDefineRoutesFile(
-      targetDir,
-      routeRegistryPath,
-      names,
-      config,
-      options,
+  const defineErrorsStart = original.indexOf("defineErrors(");
+  if (defineErrorsStart === -1) {
+    throw new Error(
+      `Could not find defineErrors({ in ${resourceSharedErrorsPath(config)}. Add ${expectedErrorNames} manually, or restore the generated shared error catalog before running make resource.`,
     );
   }
 
-  return updateDefineRoutesFile(
-    targetDir,
-    config.paths.server,
-    names,
-    config,
-    options,
-  );
-}
+  const openBrace = original.indexOf("{", defineErrorsStart);
+  if (openBrace === -1) {
+    throw new Error(
+      `Could not find defineErrors({ in ${resourceSharedErrorsPath(config)}. Add ${expectedErrorNames} manually, or restore the generated shared error catalog before running make resource.`,
+    );
+  }
+
+  const closeBrace = matchingDelimiterIndex(original, openBrace, "{", "}");
+  if (closeBrace === -1) {
+    throw new Error(
+      `Could not update ${resourceSharedErrorsPath(config)} because the error catalog object is malformed. Add ${expectedErrorNames} manually, or restore the generated shared error catalog before running make resource.`,
+    );
+  }
+
+  const entries = [];
+  if (missingErrorNames.includes(notFoundErrorName)) {
+    entries.push(`${notFoundErrorName}: {
+\t\tcode: "${constantCase(names.singularKebab)}_NOT_FOUND",
+\t\tstatus: 404,
+\t\tmessage: "${names.singularPascal} not found",
+\t},`);
+  }
+  if (missingErrorNames.includes(conflictErrorName)) {
+    entries.push(`${conflictErrorName}: {
+\t\tcode: "${constantCase(names.singularKebab)}_CONFLICT",
+\t\tstatus: 409,
+\t\tmessage: "${names.singularPascal} was changed by another request",
+\t},`);
+  }
+  const next = insertBeforeClosingBrace(
+    original,
+    openBrace,
+    closeBrace,
+    entries.join("\n"),
+  );
+
+  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,
@@ -1784,6 +2681,98 @@ function typeBodySource(source: string, typeName: string): string | undefined {
   return source.slice(openBrace + 1, closeBrace);
 }
 
+function appendUnionTypeMember(
+  source: string,
+  typeName: string,
+  member: string,
+): string {
+  const match = new RegExp(
+    `(export\\s+type\\s+${typeName}\\s*=)([\\s\\S]*?);`,
+  ).exec(source);
+  if (!match) return source;
+
+  const declaration = match[0];
+  if (new RegExp(`\\b${member}\\b`).test(declaration)) return source;
+
+  const nextDeclaration = declaration.replace(/;\s*$/, ` | ${member};`);
+  return `${source.slice(0, match.index)}${nextDeclaration}${source.slice(
+    match.index + declaration.length,
+  )}`;
+}
+
+function appendTupleTypeMember(
+  source: string,
+  typeName: string,
+  member: string,
+): string {
+  const match = new RegExp(`export\\s+type\\s+${typeName}\\s*=\\s*`).exec(
+    source,
+  );
+  if (!match) return source;
+
+  const tupleStart = source.indexOf("[", match.index);
+  if (tupleStart === -1) return source;
+
+  const tupleEnd = matchingDelimiterIndex(source, tupleStart, "[", "]");
+  if (tupleEnd === -1) return source;
+
+  const tuple = source.slice(tupleStart, tupleEnd + 1);
+  if (tuple.includes(member)) return source;
+
+  const nextTuple = appendToArrayExpression(tuple, [member]);
+  return `${source.slice(0, tupleStart)}${nextTuple}${source.slice(
+    tupleEnd + 1,
+  )}`;
+}
+
+function appendGatePolicyMember(source: string, member: string): string {
+  const gateMatch = /\bGatePort\s*</.exec(source);
+  if (!gateMatch) return source;
+
+  const tupleStart = source.indexOf("[", gateMatch.index);
+  if (tupleStart === -1) return source;
+
+  const tupleEnd = matchingDelimiterIndex(source, tupleStart, "[", "]");
+  if (tupleEnd === -1) return source;
+
+  const tuple = source.slice(tupleStart, tupleEnd + 1);
+  if (tuple.includes(member)) return source;
+
+  const nextTuple = appendToArrayExpression(tuple, [member]);
+  return `${source.slice(0, tupleStart)}${nextTuple}${source.slice(
+    tupleEnd + 1,
+  )}`;
+}
+
+function appendCreateGatePolicy(
+  source: string,
+  policy: string,
+  failureMessage: string,
+): string {
+  const policyMatch = /\bpolicies\s*:\s*\[/.exec(source);
+  if (!policyMatch) {
+    throw new Error(failureMessage);
+  }
+
+  const arrayStart = source.indexOf("[", policyMatch.index);
+  if (arrayStart === -1) {
+    throw new Error(failureMessage);
+  }
+
+  const arrayEnd = matchingDelimiterIndex(source, arrayStart, "[", "]");
+  if (arrayEnd === -1) {
+    throw new Error(failureMessage);
+  }
+
+  const policies = source.slice(arrayStart, arrayEnd + 1);
+  if (policies.includes(policy)) return source;
+
+  const nextPolicies = appendToArrayExpression(policies, [policy]);
+  return `${source.slice(0, arrayStart)}${nextPolicies}${source.slice(
+    arrayEnd + 1,
+  )}`;
+}
+
 function insertDefinePortsProperty(
   source: string,
   property: string,
@@ -1881,7 +2870,20 @@ function definePortsBodySource(source: string): string | undefined {
 function definePortsBodyRange(
   source: string,
 ): { openBrace: number; closeBrace: number } | undefined {
-  const match = /definePorts(?:<[^>]+>)?\(\s*\{/.exec(source);
+  const outer = definePortsOuterBodyRange(source);
+  if (!outer) return undefined;
+
+  // The curried `definePorts<AppPorts>()({ bound, deferred })` form binds app
+  // ports inside `bound`; generated bindings belong there.
+  return (
+    topLevelBoundObjectRange(source, outer.openBrace, outer.closeBrace) ?? outer
+  );
+}
+
+function definePortsOuterBodyRange(
+  source: string,
+): { openBrace: number; closeBrace: number } | undefined {
+  const match = /definePorts(?:<[^>]+>)?\(\s*(?:\)\s*\(\s*)?\{/.exec(source);
   if (!match) return undefined;
 
   const openBrace = source.indexOf("{", match.index);
@@ -1891,6 +2893,50 @@ function definePortsBodyRange(
   return { openBrace, closeBrace };
 }
 
+function appendDeferredPortKey(source: string, portKey: string): string {
+  const outer = definePortsOuterBodyRange(source);
+  if (!outer) return source;
+
+  const body = source.slice(outer.openBrace + 1, outer.closeBrace);
+  if (!hasTopLevelObjectProperty(body, "deferred")) return source;
+
+  const deferredMatch = /\bdeferred\s*:\s*\[/.exec(body);
+  if (!deferredMatch) return source;
+
+  const arrayStart = source.indexOf(
+    "[",
+    outer.openBrace + 1 + deferredMatch.index,
+  );
+  const arrayEnd = matchingDelimiterIndex(source, arrayStart, "[", "]");
+  if (arrayEnd === -1) return source;
+
+  const tuple = source.slice(arrayStart, arrayEnd + 1);
+  if (new RegExp(`["']${portKey}["']`).test(tuple)) return source;
+
+  const nextTuple = appendToArrayExpression(tuple, [`"${portKey}"`]);
+  return `${source.slice(0, arrayStart)}${nextTuple}${source.slice(
+    arrayEnd + 1,
+  )}`;
+}
+
+function topLevelBoundObjectRange(
+  source: string,
+  openBrace: number,
+  closeBrace: number,
+): { openBrace: number; closeBrace: number } | undefined {
+  const body = source.slice(openBrace + 1, closeBrace);
+  if (!hasTopLevelObjectProperty(body, "bound")) return undefined;
+
+  const boundMatch = /\bbound\s*:\s*\{/.exec(body);
+  if (!boundMatch) return undefined;
+
+  const boundOpen = source.indexOf("{", openBrace + 1 + boundMatch.index);
+  const boundClose = matchingBraceIndex(source, boundOpen);
+  if (boundClose === -1) return undefined;
+
+  return { openBrace: boundOpen, closeBrace: boundClose };
+}
+
 function hasTopLevelObjectProperty(
   source: string,
   propertyName: string,
@@ -2193,6 +3239,25 @@ function resourceNames(input: string): ResourceNames {
   return names;
 }
 
+function featureUiNames(input: string): FeatureUiNames {
+  const names = resourceNames(input);
+  const resolvedNames = {
+    ...names,
+    componentExportName: `${names.pluralPascal}Panel`,
+    componentFileName: `${names.pluralKebab}-panel`,
+  };
+
+  assertGeneratedIdentifiers(input, "Feature UI name", [
+    resolvedNames.componentExportName,
+  ]);
+
+  return resolvedNames;
+}
+
+function featureResourceNames(names: FeatureArtifactNames): ResourceNames {
+  return resourceNames(names.feature.kebab);
+}
+
 function useCaseNames(input: string): UseCaseNames {
   const parts = input
     .trim()
@@ -2333,6 +3398,64 @@ function jobNames(input: string): JobNames {
   };
 }
 
+function taskNames(input: string): TaskNames {
+  const names = featureArtifactNames(input, "Task");
+  const taskExportName = `${names.artifact.camel}Task`;
+
+  assertGeneratedIdentifiers(input, "Task name", [taskExportName]);
+
+  return {
+    ...names,
+    taskName: names.stableName,
+    taskExportName,
+    inputSchemaName: `${names.artifact.pascal}TaskInputSchema`,
+    inputTypeName: `${names.artifact.pascal}TaskInput`,
+  };
+}
+
+function factoryNames(input: string): FactoryNames {
+  const names = featureArtifactNames(input, "Factory");
+  const factoryExportName = `${names.artifact.camel}Factory`;
+
+  assertGeneratedIdentifiers(input, "Factory name", [factoryExportName]);
+
+  return {
+    ...names,
+    factoryName: names.stableName,
+    factoryExportName,
+  };
+}
+
+function seedNames(input: string): SeedNames {
+  const names = featureArtifactNames(input, "Seed");
+  const seedExportName = `${names.artifact.camel}Seed`;
+
+  assertGeneratedIdentifiers(input, "Seed name", [seedExportName]);
+
+  return {
+    ...names,
+    seedName: names.stableName,
+    seedExportName,
+  };
+}
+
+function notificationNames(input: string): NotificationNames {
+  const names = featureArtifactNames(input, "Notification");
+  const notificationExportName = `${names.featureSingularPascal}${names.artifact.pascal}Notification`;
+
+  assertGeneratedIdentifiers(input, "Notification name", [
+    notificationExportName,
+  ]);
+
+  return {
+    ...names,
+    notificationName: names.stableName,
+    notificationExportName,
+    payloadSchemaName: `${notificationExportName}PayloadSchema`,
+    payloadTypeName: `${notificationExportName}Payload`,
+  };
+}
+
 function listenerNames(input: string, eventInput: string): ListenerNames {
   const names = featureArtifactNames(input, "Listener");
   const listenerExportName = names.artifact.camel;
@@ -2367,6 +3490,21 @@ function scheduleNames(
   };
 }
 
+function uploadNames(input: string): UploadNames {
+  const names = featureArtifactNames(input, "Upload");
+  const uploadExportName = `${names.artifact.pascal}Upload`;
+
+  assertGeneratedIdentifiers(input, "Upload name", [uploadExportName]);
+
+  return {
+    ...names,
+    uploadName: names.stableName,
+    uploadExportName,
+    metadataSchemaName: `${uploadExportName}MetadataSchema`,
+    metadataTypeName: `${uploadExportName}Metadata`,
+  };
+}
+
 function normalizeEventReference(input: string): string {
   const trimmed = input.trim();
   if (trimmed.includes("/")) return trimmed;
@@ -2524,10 +3662,21 @@ function pascalCase(value: string): string {
   return `${camel.charAt(0).toUpperCase()}${camel.slice(1)}`;
 }
 
+function constantCase(value: string): string {
+  return value.replaceAll("-", "_").toUpperCase();
+}
+
 function resourceFiles(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
   persistence: ResourcePersistence = "memory",
+  mode: ResourceGenerationMode = "feature",
+  options: ResourceGenerationOptions = {
+    auth: false,
+    tenant: false,
+    events: false,
+    softDelete: false,
+  },
 ): GeneratedFile[] {
   const useCaseDir = resourceUseCaseDir(names, config);
   const infraDir = infrastructureDir(config);
@@ -2535,27 +3684,63 @@ function resourceFiles(
   const files: GeneratedFile[] = [
     {
       path: resourceContractFilePath(names, config),
-      content: contractFile(names, config),
+      content: contractFile(names, config, mode, options),
     },
     {
-      path: path.join(useCaseDir, "schemas.ts"),
-      content: schemasFile(names),
+      path: path.join(featureDir, "schemas.ts"),
+      content: schemasFile(names, mode, options),
     },
     {
       path: path.join(useCaseDir, `list-${names.pluralKebab}.ts`),
-      content: listUseCaseFile(names, config),
+      content: listUseCaseFile(names, config, options),
     },
     {
       path: path.join(useCaseDir, `create-${names.singularKebab}.ts`),
-      content: createUseCaseFile(names, config),
+      content: createUseCaseFile(names, config, options),
     },
+    ...(mode === "resource"
+      ? [
+          {
+            path: path.join(useCaseDir, `get-${names.singularKebab}.ts`),
+            content: getUseCaseFile(names, config, options),
+          },
+          {
+            path: path.join(useCaseDir, `update-${names.singularKebab}.ts`),
+            content: updateUseCaseFile(names, config, options),
+          },
+          {
+            path: path.join(useCaseDir, `delete-${names.singularKebab}.ts`),
+            content: deleteUseCaseFile(names, config, options),
+          },
+          {
+            path: path.join(featureDir, "policy.ts"),
+            content: resourcePolicyFile(names, config, options),
+          },
+        ]
+      : []),
+    ...(mode === "resource" && options.events
+      ? [
+          {
+            path: path.join(featureDir, "domain/events/index.ts"),
+            content: resourceEventsFile(names),
+          },
+        ]
+      : []),
+    ...(mode === "resource" && options.auth
+      ? [
+          {
+            path: path.join(featureDir, "tests/policy.test.ts"),
+            content: resourcePolicyTestFile(names, options),
+          },
+        ]
+      : []),
     {
       path: path.join(useCaseDir, "index.ts"),
-      content: useCasesIndexFile(names),
+      content: useCasesIndexFile(names, mode),
     },
     {
       path: resourcePortFilePath(names, config),
-      content: repositoryPortFile(names, config),
+      content: repositoryPortFile(names, config, mode, options),
     },
     {
       path: path.join(
@@ -2563,15 +3748,15 @@ function resourceFiles(
         names.pluralKebab,
         `in-memory-${names.singularKebab}-repository.ts`,
       ),
-      content: inMemoryRepositoryFile(names, config),
+      content: inMemoryRepositoryFile(names, config, mode, options),
     },
     {
       path: path.join(featureDir, "routes.ts"),
-      content: routeGroupFile(names, config),
+      content: routeGroupFile(names, config, mode, options),
     },
     {
       path: resourceTestFilePath(names, config),
-      content: testFile(names, config),
+      content: testFile(names, config, mode, options),
     },
   ];
 
@@ -2579,11 +3764,11 @@ function resourceFiles(
     files.push(
       {
         path: drizzleResourceSchemaFilePath(names, config),
-        content: drizzleSchemaFile(names),
+        content: drizzleSchemaFile(names, options),
       },
       {
         path: drizzleResourceRepositoryFilePath(names, config),
-        content: drizzleRepositoryFile(names, config),
+        content: drizzleRepositoryFile(names, config, mode, options),
       },
     );
   }
@@ -2591,6 +3776,31 @@ function resourceFiles(
   return files;
 }
 
+function featureUiComponentFiles(
+  names: FeatureUiNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  const componentPath = featureUiComponentFilePath(names, config);
+
+  return [
+    {
+      path: componentPath,
+      content: featureUiComponentFile(names, config),
+    },
+  ];
+}
+
+function featureUiIndexFile(
+  names: FeatureUiNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile {
+  return {
+    path: featureUiIndexFilePath(names, config),
+    content: `export { ${names.componentExportName} } from "./${names.componentFileName}";
+`,
+  };
+}
+
 function contractFiles(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
@@ -2689,6 +3899,54 @@ function jobFiles(
   ];
 }
 
+function taskFiles(
+  names: TaskNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: taskFilePath(names, config),
+      content: taskFile(names, config),
+    },
+  ];
+}
+
+function notificationFiles(
+  names: NotificationNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: notificationFilePath(names, config),
+      content: notificationFile(names, config),
+    },
+  ];
+}
+
+function factoryFiles(
+  names: FactoryNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: factoryFilePath(names, config),
+      content: factoryFile(names, config),
+    },
+  ];
+}
+
+function seedFiles(
+  names: SeedNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: seedFilePath(names, config),
+      content: seedFile(names, config),
+    },
+  ];
+}
+
 function listenerFiles(
   names: ListenerNames,
   config: ResolvedBeignetConfig,
@@ -2723,6 +3981,18 @@ function scheduleFiles(
   return files;
 }
 
+function uploadFiles(
+  names: UploadNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: uploadFilePath(names, config),
+      content: uploadFile(names, config),
+    },
+  ];
+}
+
 function portFilePath(names: PortNames, config: ResolvedBeignetConfig): string {
   return path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
 }
@@ -2773,6 +4043,30 @@ function drizzleResourceRepositoryFilePath(
   );
 }
 
+function resourceSharedErrorsPath(config: ResolvedBeignetConfig): string {
+  return path.join(config.paths.features, "shared", "errors.ts");
+}
+
+function resourceContractNames(
+  names: ResourceNames,
+  mode: ResourceGenerationMode,
+): string[] {
+  const contractNames = [
+    `list${names.pluralPascal}`,
+    `create${names.singularPascal}`,
+  ];
+
+  if (mode === "resource") {
+    contractNames.push(
+      `get${names.singularPascal}`,
+      `update${names.singularPascal}`,
+      `delete${names.singularPascal}`,
+    );
+  }
+
+  return contractNames;
+}
+
 async function detectResourcePersistence(
   targetDir: string,
   config: ResolvedBeignetConfig,
@@ -2791,6 +4085,36 @@ function resourceFeatureDir(
   return path.join(config.paths.features, names.pluralKebab);
 }
 
+function featureUiDir(
+  names: FeatureUiNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(resourceFeatureDir(names, config), "components");
+}
+
+function featureUiComponentFilePath(
+  names: FeatureUiNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureUiDir(names, config),
+    `${names.componentFileName}.tsx`,
+  );
+}
+
+function featureUiIndexFilePath(
+  names: FeatureUiNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(featureUiDir(names, config), "index.ts");
+}
+
+function clientIndexPath(config: ResolvedBeignetConfig): string {
+  const appRoot = path.posix.dirname(config.paths.appContext);
+
+  return path.join(appRoot === "." ? "" : appRoot, "client/index.ts");
+}
+
 function usesFeatureOwnedContracts(config: ResolvedBeignetConfig): boolean {
   return (
     directoryPath(config.paths.contracts) ===
@@ -2855,6 +4179,13 @@ function resourceUseCaseIndexPath(
   return path.join(resourceUseCaseDir(names, config), "index.ts");
 }
 
+function resourceSchemaFilePath(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(resourceFeatureDir(names, config), "schemas.ts");
+}
+
 function resourcePortFilePath(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
@@ -2917,7 +4248,16 @@ function policyFilePath(
 
 function featureArtifactDir(
   names: FeatureArtifactNames,
-  kind: "events" | "jobs" | "listeners" | "schedules",
+  kind:
+    | "events"
+    | "factories"
+    | "tasks"
+    | "jobs"
+    | "notifications"
+    | "listeners"
+    | "seeds"
+    | "schedules"
+    | "uploads",
   config: ResolvedBeignetConfig,
 ): string {
   const featureDir = path.join(config.paths.features, names.feature.kebab);
@@ -2925,6 +4265,9 @@ function featureArtifactDir(
   if (kind === "events") {
     return path.join(featureDir, "domain", "events");
   }
+  if (kind === "factories") {
+    return path.join(featureDir, "tests", "factories");
+  }
 
   return path.join(featureDir, kind);
 }
@@ -2946,10 +4289,44 @@ function jobFilePath(names: JobNames, config: ResolvedBeignetConfig): string {
   );
 }
 
-function listenerFilePath(
-  names: ListenerNames,
-  config: ResolvedBeignetConfig,
-): string {
+function taskFilePath(names: TaskNames, config: ResolvedBeignetConfig): string {
+  return path.join(
+    featureArtifactDir(names, "tasks", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function factoryFilePath(
+  names: FactoryNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureArtifactDir(names, "factories", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function seedFilePath(names: SeedNames, config: ResolvedBeignetConfig): string {
+  return path.join(
+    featureArtifactDir(names, "seeds", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function notificationFilePath(
+  names: NotificationNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureArtifactDir(names, "notifications", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function listenerFilePath(
+  names: ListenerNames,
+  config: ResolvedBeignetConfig,
+): string {
   return path.join(
     featureArtifactDir(names, "listeners", config),
     `${names.artifact.kebab}.ts`,
@@ -2966,6 +4343,16 @@ function scheduleFilePath(
   );
 }
 
+function uploadFilePath(
+  names: UploadNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureArtifactDir(names, "uploads", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
 function scheduleRouteFilePath(
   names: ScheduleNames,
   config: ResolvedBeignetConfig,
@@ -3027,16 +4414,69 @@ async function updateUseCaseIndex(
   return "updated";
 }
 
+async function updateFeatureUiIndex(
+  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;
+  kind:
+    | "event"
+    | "job"
+    | "task"
+    | "factory"
+    | "seed"
+    | "notification"
+    | "listener"
+    | "schedule"
+    | "upload";
   importName: string;
   artifactPath: string;
   registryName: string;
+  registryEntryName: string;
 };
 
 function featureArtifactIndexFile(
-  kind: "event" | "job" | "listener" | "schedule",
-  names: EventNames | JobNames | ListenerNames | ScheduleNames,
+  kind:
+    | "event"
+    | "job"
+    | "task"
+    | "factory"
+    | "seed"
+    | "notification"
+    | "listener"
+    | "schedule"
+    | "upload",
+  names:
+    | EventNames
+    | JobNames
+    | TaskNames
+    | FactoryNames
+    | SeedNames
+    | NotificationNames
+    | ListenerNames
+    | ScheduleNames
+    | UploadNames,
   config: ResolvedBeignetConfig,
 ): FeatureArtifactIndexFile {
   const artifactPath =
@@ -3044,31 +4484,63 @@ function featureArtifactIndexFile(
       ? eventFilePath(names as EventNames, config)
       : kind === "job"
         ? jobFilePath(names as JobNames, config)
-        : kind === "listener"
-          ? listenerFilePath(names as ListenerNames, config)
-          : scheduleFilePath(names as ScheduleNames, config);
+        : kind === "task"
+          ? taskFilePath(names as TaskNames, config)
+          : kind === "factory"
+            ? factoryFilePath(names as FactoryNames, config)
+            : kind === "seed"
+              ? seedFilePath(names as SeedNames, config)
+              : kind === "notification"
+                ? notificationFilePath(names as NotificationNames, config)
+                : kind === "listener"
+                  ? listenerFilePath(names as ListenerNames, config)
+                  : kind === "schedule"
+                    ? scheduleFilePath(names as ScheduleNames, config)
+                    : uploadFilePath(names as UploadNames, config);
   const registrySuffix =
     kind === "event"
       ? "Events"
       : kind === "job"
         ? "Jobs"
-        : kind === "listener"
-          ? "Listeners"
-          : "Schedules";
+        : kind === "task"
+          ? "Tasks"
+          : kind === "factory"
+            ? "Factories"
+            : kind === "seed"
+              ? "Seeds"
+              : kind === "notification"
+                ? "Notifications"
+                : kind === "listener"
+                  ? "Listeners"
+                  : kind === "schedule"
+                    ? "Schedules"
+                    : "Uploads";
   const importName =
     kind === "event"
       ? (names as EventNames).eventExportName
       : kind === "job"
         ? (names as JobNames).jobExportName
-        : kind === "listener"
-          ? (names as ListenerNames).listenerExportName
-          : (names as ScheduleNames).scheduleExportName;
+        : kind === "task"
+          ? (names as TaskNames).taskExportName
+          : kind === "factory"
+            ? (names as FactoryNames).factoryExportName
+            : kind === "seed"
+              ? (names as SeedNames).seedExportName
+              : kind === "notification"
+                ? (names as NotificationNames).notificationExportName
+                : kind === "listener"
+                  ? (names as ListenerNames).listenerExportName
+                  : kind === "schedule"
+                    ? (names as ScheduleNames).scheduleExportName
+                    : (names as UploadNames).uploadExportName;
 
   return {
     path: path.join(path.dirname(artifactPath), "index.ts"),
+    kind,
     importName,
     artifactPath,
     registryName: `${names.featureSingularCamel}${registrySuffix}`,
+    registryEntryName: names.artifact.camel,
   };
 }
 
@@ -3081,10 +4553,22 @@ async function updateFeatureArtifactIndex(
   const existing = await readOptionalFile(destination);
   const specifier = relativeModule(file.path, file.artifactPath);
   const importLine = `import { ${file.importName} } from "${specifier}";`;
+  const defineUploadsImport = `import { defineUploads } from "@beignet/core/uploads";`;
   const exportLine = `export { ${file.importName} } from "${specifier}";`;
 
   if (existing === undefined) {
-    const content = `${importLine}
+    const content =
+      file.kind === "upload"
+        ? `${defineUploadsImport}
+${importLine}
+
+${exportLine}
+
+export const ${file.registryName} = defineUploads({
+\t${file.registryEntryName}: ${file.importName},
+});
+`
+        : `${importLine}
 
 ${exportLine}
 
@@ -3114,13 +4598,123 @@ export const ${file.registryName} = [${file.importName}] as const;
       : `${next.trimEnd()}\n${exportLine}\n`;
   }
 
-  const registry = arrayInitializerInfo(next, file.registryName);
+  if (file.kind === "upload") {
+    const registry = defineUploadsInitializerInfo(next, file.registryName);
+    const arrayRegistry = arrayInitializerInfo(next, file.registryName);
+    if (registry) {
+      if (!next.includes(defineUploadsImport)) {
+        next = insertAfterImports(next, defineUploadsImport);
+      }
+      if (!registry.text.includes(`${file.registryEntryName}:`)) {
+        next = `${next.slice(0, registry.end)}\t${file.registryEntryName}: ${file.importName},\n${next.slice(
+          registry.end,
+        )}`;
+      }
+    } else if (arrayRegistry) {
+      if (
+        !identifiersFromArrayExpression(arrayRegistry.text).has(file.importName)
+      ) {
+        const nextArray = appendToArrayExpression(arrayRegistry.text, [
+          file.importName,
+        ]);
+        next = `${next.slice(0, arrayRegistry.start)}${nextArray}${next.slice(
+          arrayRegistry.end,
+        )}`;
+      }
+    } else {
+      if (!next.includes(defineUploadsImport)) {
+        next = insertAfterImports(next, defineUploadsImport);
+      }
+      next = `${next.trimEnd()}\n\nexport const ${file.registryName} = defineUploads({\n\t${file.registryEntryName}: ${file.importName},\n});\n`;
+    }
+  } else {
+    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";
+}
+
+async function updateTaskRegistry(
+  targetDir: string,
+  names: TaskNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<WriteGeneratedFileResult> {
+  const destination = path.join(targetDir, config.paths.tasks);
+  const existing = await readOptionalFile(destination);
+  const featureTasksPath = path.join(
+    featureArtifactDir(names, "tasks", config),
+    "index.ts",
+  );
+  const registryName = `${names.featureSingularCamel}Tasks`;
+  const importLine = `import { ${registryName} } from "${relativeModule(
+    config.paths.tasks,
+    featureTasksPath,
+  )}";`;
+  const defineTasksImport = `import { defineTasks } from "@beignet/core/tasks";`;
+  const serviceActorImport = `import { createServiceActor } from "@beignet/core/ports";`;
+  const appContextImport = `import type { AppContext } from "${aliasModule(config.paths.appContext)}";`;
+  const serverImport = `import { server } from "${relativeModule(
+    config.paths.tasks,
+    config.paths.server,
+  )}";`;
+  const registryEntry = `...${registryName}`;
+
+  if (existing === undefined) {
+    const content = `${defineTasksImport}
+${serviceActorImport}
+${appContextImport}
+${importLine}
+${serverImport}
+
+export const tasks = defineTasks([
+\t${registryEntry},
+] as const);
+
+export async function createTaskContext(): Promise<AppContext> {
+\treturn server.createServiceContext({
+\t\tactor: createServiceActor("beignet-cli"),
+\t});
+}
+
+export async function stopTaskContext(): Promise<void> {
+\tawait server.stop();
+}
+`;
+    if (!options.dryRun) {
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, content);
+    }
+    return "created";
+  }
+
+  let next = existing;
+  if (!next.includes(defineTasksImport)) {
+    next = insertAfterImports(next, defineTasksImport);
+  }
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  const registry = arrayInitializerInfo(next, "tasks");
   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.trimEnd()}\n\nexport const tasks = defineTasks([\n\t${registryEntry},\n] as const);\n`;
+  } else if (!identifiersFromArrayExpression(registry.text).has(registryName)) {
+    const nextArray = appendToArrayExpression(registry.text, [registryEntry]);
     next = `${next.slice(0, registry.start)}${nextArray}${next.slice(
       registry.end,
     )}`;
@@ -3151,35 +4745,175 @@ function arrayInitializerInfo(
   };
 }
 
-function schemasFile(names: ResourceNames): string {
+function defineUploadsInitializerInfo(
+  source: string,
+  constName: string,
+): { text: string; start: number; end: number } | undefined {
+  const match = new RegExp(
+    `\\bconst\\s+${constName}\\s*=\\s*defineUploads\\s*\\(`,
+  ).exec(source);
+  if (!match) return undefined;
+
+  const openBrace = source.indexOf("{", match.index);
+  if (openBrace === -1) return undefined;
+
+  const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
+  if (closeBrace === -1) return undefined;
+
+  return {
+    text: source.slice(openBrace, closeBrace + 1),
+    start: openBrace,
+    end: closeBrace,
+  };
+}
+
+function schemasFile(
+  names: ResourceNames,
+  mode: ResourceGenerationMode,
+  options: ResourceGenerationOptions,
+): string {
   return `import { z } from "zod";
 
 export const ${names.singularPascal}Schema = z.object({
 	id: z.string().uuid(),
-	name: z.string().min(1),
+${options.tenant ? `\ttenantId: z.string().min(1),\n` : ""}	name: z.string().min(1),
+	version: z.number().int().min(1),
 	createdAt: z.string().datetime(),
+	updatedAt: 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 ${names.singularPascal}SortBySchema = z.enum(["createdAt", "name"]);
+export const ${names.singularPascal}SortDirectionSchema = z.enum(["asc", "desc"]);
+
+const ${names.singularPascal}CursorPayloadSchema = z.object({
+	sortBy: ${names.singularPascal}SortBySchema,
+	sortDirection: ${names.singularPascal}SortDirectionSchema,
+	sortValue: z.string(),
+	id: z.string().uuid(),
 });
 
+export type ${names.singularPascal}SortBy = z.infer<
+	typeof ${names.singularPascal}SortBySchema
+>;
+export type ${names.singularPascal}SortDirection = z.infer<
+	typeof ${names.singularPascal}SortDirectionSchema
+>;
+export type ${names.singularPascal}Cursor = z.infer<
+	typeof ${names.singularPascal}CursorPayloadSchema
+>;
+
+function encodeBase64Url(value: string): string {
+	const bytes = new TextEncoder().encode(value);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+
+	return btoa(binary)
+		.replaceAll("+", "-")
+		.replaceAll("/", "_")
+		.replaceAll("=", "");
+}
+
+function decodeBase64Url(value: string): string {
+	const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
+	const padding = "=".repeat((4 - (base64.length % 4)) % 4);
+	const binary = atob(base64 + padding);
+	const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+
+	return new TextDecoder().decode(bytes);
+}
+
+export function encode${names.singularPascal}Cursor(cursor: ${names.singularPascal}Cursor): string {
+	return encodeBase64Url(JSON.stringify(cursor));
+}
+
+export function decode${names.singularPascal}Cursor(cursor: string): ${names.singularPascal}Cursor {
+	return ${names.singularPascal}CursorPayloadSchema.parse(
+		JSON.parse(decodeBase64Url(cursor)),
+	);
+}
+
+export const List${names.pluralPascal}InputSchema = z
+	.object({
+		limit: z.coerce.number().int().min(1).max(100).default(20),
+		cursor: z.string().nullable().default(null),
+		name: z.string().trim().min(1).max(120).optional(),
+		sortBy: ${names.singularPascal}SortBySchema.default("createdAt"),
+		sortDirection: ${names.singularPascal}SortDirectionSchema.default("desc"),
+	})
+	.superRefine((input, ctx) => {
+		if (!input.cursor) return;
+
+		try {
+			const cursor = decode${names.singularPascal}Cursor(input.cursor);
+			if (
+				cursor.sortBy !== input.sortBy ||
+				cursor.sortDirection !== input.sortDirection
+			) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "cursor does not match the requested sort.",
+					path: ["cursor"],
+				});
+			}
+		} catch {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "cursor is invalid.",
+				path: ["cursor"],
+			});
+		}
+	});
+
 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),
+	items: z.array(${names.singularPascal}Schema),
+	page: z.object({
+		kind: z.literal("cursor"),
+		limit: z.number().int().min(1),
+		cursor: z.string().nullable(),
+		nextCursor: z.string().nullable(),
+		hasMore: z.boolean(),
+	}),
 });
 
 export const Create${names.singularPascal}InputSchema = z.object({
 	name: z.string().min(1).max(120),
 });
+${
+  mode === "resource"
+    ? `
+export const ${names.singularPascal}IdInputSchema = z.object({
+	id: z.string().uuid(),
+});
+
+export const Update${names.singularPascal}BodySchema = z.object({
+	name: z.string().min(1).max(120),
+	version: z.number().int().min(1),
+});
 
+export const Update${names.singularPascal}InputSchema =
+	${names.singularPascal}IdInputSchema.merge(Update${names.singularPascal}BodySchema);
+`
+    : ""
+}
 export type ${names.singularPascal} = z.infer<typeof ${names.singularPascal}Schema>;
 export type Create${names.singularPascal}Input = z.infer<
 	typeof Create${names.singularPascal}InputSchema
 >;
+${
+  mode === "resource"
+    ? `
+export type ${names.singularPascal}IdInput = z.infer<
+	typeof ${names.singularPascal}IdInputSchema
+>;
+export type Update${names.singularPascal}Body = z.infer<
+	typeof Update${names.singularPascal}BodySchema
+>;
+export type Update${names.singularPascal}Input = z.infer<
+	typeof Update${names.singularPascal}InputSchema
+>;
+`
+    : ""
+}
 export type List${names.pluralPascal}Input = z.infer<
 	typeof List${names.pluralPascal}InputSchema
 >;
@@ -3189,30 +4923,39 @@ export type List${names.pluralPascal}Input = z.infer<
 function listUseCaseFile(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
+  options: ResourceGenerationOptions,
 ): string {
   const filePath = path.join(
     resourceUseCaseDir(names, config),
     `list-${names.pluralKebab}.ts`,
   );
 
-  return `import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { normalizeCursorPage } from "@beignet/core/pagination";
+import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
+	decode${names.singularPascal}Cursor,
 	List${names.pluralPascal}InputSchema,
 	List${names.pluralPascal}OutputSchema,
-} from "./schemas";
+} 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,
-		};
+${options.tenant ? `\t\tconst tenantId = ctx.tenant?.id;\n\t\tif (!tenantId) {\n\t\t\tthrow new Error("Tenant is required to list ${names.pluralKebab}.");\n\t\t}\n\n` : ""}		const page = normalizeCursorPage(input, {
+			defaultLimit: 20,
+			maxLimit: 100,
+		});
+
+		return ctx.ports.${names.pluralCamel}.list({
+			page,
+			cursor: page.cursor ? decode${names.singularPascal}Cursor(page.cursor) : null,
+			name: input.name,
+			sortBy: input.sortBy,
+			sortDirection: input.sortDirection,
+${options.tenant ? `\t\t\ttenantId,\n` : ""}		});
 	});
 `;
 }
@@ -3220,135 +4963,430 @@ export const list${names.pluralPascal}UseCase = useCase
 function createUseCaseFile(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
+  options: ResourceGenerationOptions,
 ): string {
   const filePath = path.join(
     resourceUseCaseDir(names, config),
     `create-${names.singularKebab}.ts`,
   );
 
-  return `import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
 	Create${names.singularPascal}InputSchema,
 	${names.singularPascal}Schema,
-} from "./schemas";
+} from "../schemas";
+${options.events ? `import { ${names.singularPascal}Created } from "../domain/events";\n` : ""}
 
 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));
+	.run(async ({ ctx, input }) => {
+${options.tenant ? `\t\tconst tenantId = ctx.tenant?.id;\n\t\tif (!tenantId) {\n\t\t\tthrow new Error("Tenant is required to create ${names.singularKebab}.");\n\t\t}\n\n` : ""}${options.auth ? `\t\tawait ctx.gate.authorize("${names.pluralCamel}.create");\n\n` : ""}		const ${names.singularCamel} = await ctx.ports.${names.pluralCamel}.create({
+			...input,
+${options.tenant ? `\t\t\ttenantId,\n` : ""}		});
+${options.events ? `\n\t\tawait ctx.ports.eventBus.publish(${names.singularPascal}Created, {\n\t\t\tid: ${names.singularCamel}.id,\n\t\t});\n` : ""}
+		return ${names.singularCamel};
+	});
+`;
+}
+
+function getUseCaseFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: ResourceGenerationOptions,
+): string {
+  const filePath = path.join(
+    resourceUseCaseDir(names, config),
+    `get-${names.singularKebab}.ts`,
+  );
+
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
+import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+import {
+	${names.singularPascal}IdInputSchema,
+	${names.singularPascal}Schema,
+} from "../schemas";
+
+export const get${names.singularPascal}UseCase = useCase
+	.query("${names.pluralCamel}.get")
+	.input(${names.singularPascal}IdInputSchema)
+	.output(${names.singularPascal}Schema)
+	.run(async ({ ctx, input }) => {
+${options.tenant ? `\t\tconst tenantId = ctx.tenant?.id;\n\t\tif (!tenantId) {\n\t\t\tthrow new Error("Tenant is required to get ${names.singularKebab}.");\n\t\t}\n\n` : ""}		const ${names.singularCamel} = await ctx.ports.${names.pluralCamel}.findById(input.id${options.tenant ? ", { tenantId }" : ""});
+		if (!${names.singularCamel}) {
+			throw appError("${names.singularPascal}NotFound", {
+				details: { id: input.id },
+			});
+		}
+
+		return ${names.singularCamel};
+	});
+`;
+}
+
+function updateUseCaseFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: ResourceGenerationOptions,
+): string {
+  const filePath = path.join(
+    resourceUseCaseDir(names, config),
+    `update-${names.singularKebab}.ts`,
+  );
+
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
+import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+${options.events ? `import { ${names.singularPascal}Updated } from "../domain/events";\n` : ""}import {
+	Update${names.singularPascal}InputSchema,
+	${names.singularPascal}Schema,
+} from "../schemas";
+
+export const update${names.singularPascal}UseCase = useCase
+	.command("${names.pluralCamel}.update")
+	.input(Update${names.singularPascal}InputSchema)
+	.output(${names.singularPascal}Schema)
+	.run(async ({ ctx, input }) => {
+${options.tenant ? `\t\tconst tenantId = ctx.tenant?.id;\n\t\tif (!tenantId) {\n\t\t\tthrow new Error("Tenant is required to update ${names.singularKebab}.");\n\t\t}\n\n` : ""}		const existing = await ctx.ports.${names.pluralCamel}.findById(input.id${options.tenant ? ", { tenantId }" : ""});
+		if (!existing) {
+			throw appError("${names.singularPascal}NotFound", {
+				details: { id: input.id },
+			});
+		}
+${options.auth ? `\t\tawait ctx.gate.authorize("${names.pluralCamel}.update", existing);\n\n` : ""}		if (existing.version !== input.version) {
+			throw appError("${names.singularPascal}Conflict", {
+				details: { id: input.id, expectedVersion: existing.version },
+			});
+		}
+
+		const ${names.singularCamel} = await ctx.ports.${names.pluralCamel}.update({
+			...input,
+${options.tenant ? `\t\t\ttenantId,\n` : ""}		});
+		if (!${names.singularCamel}) {
+			throw appError("${names.singularPascal}Conflict", {
+				details: { id: input.id, expectedVersion: existing.version },
+			});
+		}
+${options.events ? `\n\t\tawait ctx.ports.eventBus.publish(${names.singularPascal}Updated, {\n\t\t\tid: ${names.singularCamel}.id,\n\t\t});\n` : ""}
+		return ${names.singularCamel};
+	});
+`;
+}
+
+function deleteUseCaseFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  options: ResourceGenerationOptions,
+): string {
+  const filePath = path.join(
+    resourceUseCaseDir(names, config),
+    `delete-${names.singularKebab}.ts`,
+  );
+
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { z } from "zod";
+import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
+import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+${options.events ? `import { ${names.singularPascal}Deleted } from "../domain/events";\n` : ""}import { ${names.singularPascal}IdInputSchema } from "../schemas";
+
+export const delete${names.singularPascal}UseCase = useCase
+	.command("${names.pluralCamel}.delete")
+	.input(${names.singularPascal}IdInputSchema)
+	.output(z.void())
+	.run(async ({ ctx, input }) => {
+${options.tenant ? `\t\tconst tenantId = ctx.tenant?.id;\n\t\tif (!tenantId) {\n\t\t\tthrow new Error("Tenant is required to delete ${names.singularKebab}.");\n\t\t}\n\n` : ""}${options.auth ? `\t\tconst existing = await ctx.ports.${names.pluralCamel}.findById(input.id${options.tenant ? ", { tenantId }" : ""});\n\t\tif (!existing) {\n\t\t\tthrow appError("${names.singularPascal}NotFound", {\n\t\t\t\tdetails: { id: input.id },\n\t\t\t});\n\t\t}\n\t\tawait ctx.gate.authorize("${names.pluralCamel}.delete", existing);\n\n` : ""}		const deleted = await ctx.ports.${names.pluralCamel}.delete(input.id${options.tenant ? ", { tenantId }" : ""});
+		if (!deleted) {
+			throw appError("${names.singularPascal}NotFound", {
+				details: { id: input.id },
+			});
+		}
+${options.events ? `\n\t\tawait ctx.ports.eventBus.publish(${names.singularPascal}Deleted, {\n\t\t\tid: input.id,\n\t\t});\n` : ""}	});
 `;
 }
 
-function useCasesIndexFile(names: ResourceNames): string {
+function useCasesIndexFile(
+  names: ResourceNames,
+  mode: ResourceGenerationMode,
+): string {
   return `export { create${names.singularPascal}UseCase } from "./create-${names.singularKebab}";
-export { list${names.pluralPascal}UseCase } from "./list-${names.pluralKebab}";
-export {
+${mode === "resource" ? `export { delete${names.singularPascal}UseCase } from "./delete-${names.singularKebab}";\nexport { get${names.singularPascal}UseCase } from "./get-${names.singularKebab}";\n` : ""}export { list${names.pluralPascal}UseCase } from "./list-${names.pluralKebab}";
+${mode === "resource" ? `export { update${names.singularPascal}UseCase } from "./update-${names.singularKebab}";\n` : ""}export {
 	Create${names.singularPascal}InputSchema,
-	List${names.pluralPascal}InputSchema,
+${mode === "resource" ? `	${names.singularPascal}IdInputSchema,\n` : ""}	List${names.pluralPascal}InputSchema,
 	List${names.pluralPascal}OutputSchema,
-	${names.singularPascal}Schema,
+${mode === "resource" ? `	Update${names.singularPascal}BodySchema,\n	Update${names.singularPascal}InputSchema,\n` : ""}	${names.singularPascal}Schema,
 	type Create${names.singularPascal}Input,
-	type List${names.pluralPascal}Input,
+${mode === "resource" ? `	type ${names.singularPascal}IdInput,\n	type Update${names.singularPascal}Body,\n	type Update${names.singularPascal}Input,\n` : ""}	type List${names.pluralPascal}Input,
 	type ${names.singularPascal},
-} from "./schemas";
+} from "../schemas";
 `;
 }
 
 function repositoryPortFile(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
+  mode: ResourceGenerationMode,
+  options: ResourceGenerationOptions,
 ): string {
   return `import type {
+	CursorPage,
+	CursorPageInfo,
+	PageResult,
+	SortDirection,
+} from "@beignet/core/pagination";
+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;
-};
+	${names.singularPascal}Cursor,
+	${names.singularPascal}SortBy,
+${mode === "resource" ? `	Update${names.singularPascal}Input,\n` : ""}	${names.singularPascal},
+} from "${aliasModule(resourceSchemaFilePath(names, config))}";
+
+export type List${names.pluralPascal}Result = PageResult<${names.singularPascal}, CursorPageInfo>;
+export type List${names.pluralPascal}Query = {
+	page: CursorPage;
+	cursor: ${names.singularPascal}Cursor | null;
+	name?: string;
+	sortBy: ${names.singularPascal}SortBy;
+	sortDirection: SortDirection;
+${options.tenant ? `\ttenantId: string;\n` : ""}};
+${options.tenant ? `export type ${names.singularPascal}TenantFilter = { tenantId: string };\nexport type Create${names.singularPascal}RepositoryInput = Create${names.singularPascal}Input & ${names.singularPascal}TenantFilter;\n${mode === "resource" ? `export type Update${names.singularPascal}RepositoryInput = Update${names.singularPascal}Input & ${names.singularPascal}TenantFilter;\n` : ""}` : ""}
 
 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}>;
-}
+	list(query: List${names.pluralPascal}Query): Promise<List${names.pluralPascal}Result>;
+	create(input: ${options.tenant ? `Create${names.singularPascal}RepositoryInput` : `Create${names.singularPascal}Input`}): Promise<${names.singularPascal}>;
+${mode === "resource" ? `	findById(id: string${options.tenant ? `, filter: ${names.singularPascal}TenantFilter` : ""}): Promise<${names.singularPascal} | null>;\n	update(input: ${options.tenant ? `Update${names.singularPascal}RepositoryInput` : `Update${names.singularPascal}Input`}): Promise<${names.singularPascal} | null>;\n	delete(id: string${options.tenant ? `, filter: ${names.singularPascal}TenantFilter` : ""}): Promise<boolean>;\n` : ""}}
 `;
 }
 
 function inMemoryRepositoryFile(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
+  mode: ResourceGenerationMode,
+  options: ResourceGenerationOptions,
 ): string {
   const repositoryPortPath = resourcePortFilePath(names, config);
+  const recordType = options.softDelete
+    ? `type ${names.singularPascal}Record = ${names.singularPascal} & {
+\tdeletedAt: string | null;
+};
 
-  return `import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+`
+    : "";
+  const mapValueType = options.softDelete
+    ? `${names.singularPascal}Record`
+    : names.singularPascal;
+  const activeFilter = options.softDelete
+    ? `\t\t\t\t.filter((${names.singularCamel}) => ${names.singularCamel}.deletedAt === null)\n`
+    : "";
+  const newDeletedAtField = options.softDelete
+    ? `\t\t\t\tdeletedAt: null,\n`
+    : "";
+  const findDeletedGuard = options.softDelete
+    ? `\t\t\tif (${names.singularCamel}?.deletedAt !== null) return null;\n`
+    : "";
+  const updateDeletedGuard = options.softDelete
+    ? " || existing.deletedAt !== null"
+    : "";
+  const deleteImplementation = options.softDelete
+    ? `${options.tenant ? `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (!existing || existing.tenantId !== filter.tenantId || existing.deletedAt !== null) return false;\n` : `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (!existing || existing.deletedAt !== null) return false;\n`}			const now = new Date().toISOString();
+			${names.pluralCamel}.set(id, { ...existing, deletedAt: now, updatedAt: now });
+			return true;`
+    : `${options.tenant ? `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (existing?.tenantId !== filter.tenantId) return false;\n` : ""}			return ${names.pluralCamel}.delete(id);`;
+
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { cursorPageResult } from "@beignet/core/pagination";
+import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+import { encode${names.singularPascal}Cursor } from "${aliasModule(resourceSchemaFilePath(names, config))}";
 import type {
 	Create${names.singularPascal}Input,
-	List${names.pluralPascal}Input,
-	${names.singularPascal},
-} from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
+${mode === "resource" ? `	Update${names.singularPascal}Input,\n` : ""}	${names.singularPascal},
+} from "${aliasModule(resourceSchemaFilePath(names, config))}";
+
+${recordType}function to${names.singularPascal}(${names.singularCamel}: ${mapValueType}): ${names.singularPascal} {
+	return {
+		id: ${names.singularCamel}.id,
+${options.tenant ? `\t\ttenantId: ${names.singularCamel}.tenantId,\n` : ""}		name: ${names.singularCamel}.name,
+		version: ${names.singularCamel}.version,
+		createdAt: ${names.singularCamel}.createdAt,
+		updatedAt: ${names.singularCamel}.updatedAt,
+	};
+}
+
+function compare${names.pluralPascal}(
+	left: ${mapValueType},
+	right: ${mapValueType},
+	query: Parameters<${names.singularPascal}Repository["list"]>[0],
+): number {
+	const leftValue = left[query.sortBy];
+	const rightValue = right[query.sortBy];
+	const fieldComparison =
+		leftValue === rightValue ? left.id.localeCompare(right.id) : leftValue.localeCompare(rightValue);
+
+	return query.sortDirection === "asc" ? fieldComparison : -fieldComparison;
+}
+
+function isAfter${names.singularPascal}Cursor(
+	${names.singularCamel}: ${mapValueType},
+	query: Parameters<${names.singularPascal}Repository["list"]>[0],
+): boolean {
+	if (!query.cursor) return true;
+
+	const sortValue = ${names.singularCamel}[query.sortBy];
+	const fieldComparison =
+		sortValue === query.cursor.sortValue
+			? ${names.singularCamel}.id.localeCompare(query.cursor.id)
+			: sortValue.localeCompare(query.cursor.sortValue);
+
+	return query.sortDirection === "asc" ? fieldComparison > 0 : fieldComparison < 0;
+}
+
+function cursorFor${names.singularPascal}(
+	${names.singularCamel}: ${mapValueType},
+	query: Parameters<${names.singularPascal}Repository["list"]>[0],
+): string {
+	return encode${names.singularPascal}Cursor({
+		sortBy: query.sortBy,
+		sortDirection: query.sortDirection,
+		sortValue: ${names.singularCamel}[query.sortBy],
+		id: ${names.singularCamel}.id,
+	});
+}
 
 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}]));
+	const ${names.pluralCamel} = new Map<string, ${mapValueType}>(
+		seed.map((${names.singularCamel}) => [
+			${names.singularCamel}.id,
+			{ ...${names.singularCamel}${options.softDelete ? ", deletedAt: null" : ""} },
+		]),
+	);
 
 	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),
+		async list(query) {
+			const name = query.name?.toLocaleLowerCase();
+			const all${names.pluralPascal} = Array.from(${names.pluralCamel}.values())
+${activeFilter}${options.tenant ? `\t\t\t\t.filter((${names.singularCamel}) => ${names.singularCamel}.tenantId === query.tenantId)\n` : ""}				.filter((${names.singularCamel}) => !name || ${names.singularCamel}.name.toLocaleLowerCase().includes(name))
+				.sort((left, right) => compare${names.pluralPascal}(left, right, query))
+				.filter((${names.singularCamel}) => isAfter${names.singularPascal}Cursor(${names.singularCamel}, query));
+			const pageItems = all${names.pluralPascal}.slice(0, query.page.limit);
+			const nextCursor =
+				all${names.pluralPascal}.length > query.page.limit && pageItems.length > 0
+					? cursorFor${names.singularPascal}(pageItems[pageItems.length - 1]!, query)
+					: null;
+
+			return cursorPageResult(
+				pageItems.map(to${names.singularPascal}),
+				query.page,
+				nextCursor,
 			);
-
-			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) {
+		async create(input) {
+			const now = new Date().toISOString();
 			const ${names.singularCamel}: ${names.singularPascal} = {
 				id: crypto.randomUUID(),
-				name: input.name,
-				createdAt: new Date().toISOString(),
+${options.tenant ? `\t\t\t\ttenantId: input.tenantId,\n` : ""}				name: input.name,
+				version: 1,
+				createdAt: now,
+				updatedAt: now,
 			};
-			${names.pluralCamel}.set(${names.singularCamel}.id, ${names.singularCamel});
+			${names.pluralCamel}.set(${names.singularCamel}.id, {
+				...${names.singularCamel},
+${newDeletedAtField}			});
 			return ${names.singularCamel};
 		},
+${mode === "resource" ? `		async findById(id: string${options.tenant ? ", filter" : ""}) {\n			const ${names.singularCamel} = ${names.pluralCamel}.get(id) ?? null;\n${options.tenant ? `\t\t\tif (${names.singularCamel}?.tenantId !== filter.tenantId) return null;\n` : ""}${findDeletedGuard}			return ${names.singularCamel} ? to${names.singularPascal}(${names.singularCamel}) : null;\n		},\n		async update(input) {\n			const existing = ${names.pluralCamel}.get(input.id);\n			if (!existing${options.tenant ? " || existing.tenantId !== input.tenantId" : ""}${updateDeletedGuard} || existing.version !== input.version) return null;\n\n			const next: ${mapValueType} = {\n				...existing,\n				name: input.name,\n				version: existing.version + 1,\n				updatedAt: new Date().toISOString(),\n			};\n			${names.pluralCamel}.set(input.id, next);\n			return to${names.singularPascal}(next);\n		},\n		async delete(id: string${options.tenant ? ", filter" : ""}) {\n${deleteImplementation}\n		},\n` : ""}
 	};
 }
 `;
 }
 
-function drizzleSchemaFile(names: ResourceNames): string {
-  return `import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+function drizzleSchemaFile(
+  names: ResourceNames,
+  options: ResourceGenerationOptions,
+): string {
+  return `import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
 export const ${names.pluralCamel} = sqliteTable("${names.pluralKebab.replaceAll("-", "_")}", {
 	id: text("id").primaryKey(),
-	name: text("name").notNull(),
+${options.tenant ? `\ttenantId: text("tenant_id").notNull(),\n` : ""}	name: text("name").notNull(),
+	version: integer("version").notNull(),
 	createdAt: text("created_at").notNull(),
-});
+	updatedAt: text("updated_at").notNull(),
+${options.softDelete ? `\tdeletedAt: text("deleted_at"),\n` : ""}});
 `;
 }
 
+function drizzleResourceWhere(
+  names: ResourceNames,
+  options: ResourceGenerationOptions,
+  predicates: readonly string[],
+): string {
+  const allPredicates = [
+    ...predicates,
+    ...(options.softDelete
+      ? [`isNull(schema.${names.pluralCamel}.deletedAt)`]
+      : []),
+  ];
+
+  if (allPredicates.length === 0) return "";
+  if (allPredicates.length === 1) return allPredicates[0] ?? "";
+  return `and(${allPredicates.join(", ")})`;
+}
+
 function drizzleRepositoryFile(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
+  mode: ResourceGenerationMode,
+  options: ResourceGenerationOptions,
 ): 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";
+  const findWhere = drizzleResourceWhere(names, options, [
+    `eq(schema.${names.pluralCamel}.id, id)`,
+    ...(options.tenant
+      ? [`eq(schema.${names.pluralCamel}.tenantId, filter.tenantId)`]
+      : []),
+  ]);
+  const updateWhere = drizzleResourceWhere(names, options, [
+    `eq(schema.${names.pluralCamel}.id, input.id)`,
+    `eq(schema.${names.pluralCamel}.version, input.version)`,
+    ...(options.tenant
+      ? [`eq(schema.${names.pluralCamel}.tenantId, input.tenantId)`]
+      : []),
+  ]);
+  const deleteWhere = drizzleResourceWhere(names, options, [
+    `eq(schema.${names.pluralCamel}.id, id)`,
+    ...(options.tenant
+      ? [`eq(schema.${names.pluralCamel}.tenantId, filter.tenantId)`]
+      : []),
+  ]);
+  const drizzleImports = [
+    "and",
+    "asc",
+    "desc",
+    "eq",
+    "gt",
+    options.softDelete ? "isNull" : undefined,
+    "lt",
+    "or",
+    "sql",
+    "type SQL",
+  ].filter((name): name is string => Boolean(name));
+
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { cursorPageResult } from "@beignet/core/pagination";
+import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
+import { ${drizzleImports.join(", ")} } from "drizzle-orm";
 import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+import { encode${names.singularPascal}Cursor } from "${aliasModule(resourceSchemaFilePath(names, config))}";
 import type {
 	Create${names.singularPascal}Input,
-	List${names.pluralPascal}Input,
-	${names.singularPascal},
-} from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
+${mode === "resource" ? `	Update${names.singularPascal}Input,\n` : ""}	${names.singularPascal},
+} from "${aliasModule(resourceSchemaFilePath(names, config))}";
 import * as schema from "${aliasModule(schemaPath)}";
 
 type ${names.singularPascal}Row = typeof schema.${names.pluralCamel}.$inferSelect;
@@ -3356,38 +5394,104 @@ type ${names.singularPascal}Row = typeof schema.${names.pluralCamel}.$inferSelec
 function to${names.singularPascal}(row: ${names.singularPascal}Row): ${names.singularPascal} {
 	return {
 		id: row.id,
-		name: row.name,
+${options.tenant ? `\t\ttenantId: row.tenantId,\n` : ""}		name: row.name,
+		version: row.version,
 		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
 	};
 }
 
+type List${names.pluralPascal}Query = Parameters<${names.singularPascal}Repository["list"]>[0];
+
+function ${names.singularCamel}SortColumn(query: List${names.pluralPascal}Query) {
+	return query.sortBy === "name" ? schema.${names.pluralCamel}.name : schema.${names.pluralCamel}.createdAt;
+}
+
+function ${names.singularCamel}CursorFilter(
+	query: List${names.pluralPascal}Query,
+): SQL<unknown> | undefined {
+	if (!query.cursor) return undefined;
+
+	const column = ${names.singularCamel}SortColumn(query);
+	const compare = query.sortDirection === "asc" ? gt : lt;
+
+	return or(
+		compare(column, query.cursor.sortValue),
+		and(
+			eq(column, query.cursor.sortValue),
+			compare(schema.${names.pluralCamel}.id, query.cursor.id),
+		),
+	) as SQL<unknown>;
+}
+
+function ${names.singularCamel}ListWhere(
+	query: List${names.pluralPascal}Query,
+): SQL<unknown> | undefined {
+	const filters: SQL<unknown>[] = [
+${options.tenant ? `\t\teq(schema.${names.pluralCamel}.tenantId, query.tenantId),\n` : ""}${options.softDelete ? `\t\tisNull(schema.${names.pluralCamel}.deletedAt),\n` : ""}	];
+	const cursor = ${names.singularCamel}CursorFilter(query);
+
+	if (query.name) {
+		const pattern = \`%\${query.name.toLocaleLowerCase()}%\`;
+		filters.push(sql\`lower(\${schema.${names.pluralCamel}.name}) like \${pattern}\`);
+	}
+	if (cursor) filters.push(cursor);
+
+	return filters.length > 0 ? and(...filters) : undefined;
+}
+
+function ${names.singularCamel}OrderBy(query: List${names.pluralPascal}Query) {
+	const order = query.sortDirection === "asc" ? asc : desc;
+
+	return [order(${names.singularCamel}SortColumn(query)), order(schema.${names.pluralCamel}.id)] as const;
+}
+
+function cursorFor${names.singularPascal}(
+	row: ${names.singularPascal}Row,
+	query: List${names.pluralPascal}Query,
+): string {
+	return encode${names.singularPascal}Cursor({
+		sortBy: query.sortBy,
+		sortDirection: query.sortDirection,
+		sortValue: row[query.sortBy],
+		id: row.id,
+	});
+}
+
 export function createDrizzle${names.singularPascal}Repository(
 	db: DrizzleTursoDatabase<typeof schema>,
 ): ${names.singularPascal}Repository {
 	return {
-		async list(input: List${names.pluralPascal}Input) {
+		async list(query) {
+			const where = ${names.singularCamel}ListWhere(query);
 			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,
-			};
+				.where(where)
+				.orderBy(...${names.singularCamel}OrderBy(query))
+				.limit(query.page.limit + 1);
+			const pageRows = rows.slice(0, query.page.limit);
+			const nextCursor =
+				rows.length > query.page.limit && pageRows.length > 0
+					? cursorFor${names.singularPascal}(pageRows[pageRows.length - 1]!, query)
+					: null;
+
+			return cursorPageResult(
+				pageRows.map(to${names.singularPascal}),
+				query.page,
+				nextCursor,
+			);
 		},
-		async create(input: Create${names.singularPascal}Input) {
+		async create(input) {
+			const now = new Date().toISOString();
 			const [row] = await db
 				.insert(schema.${names.pluralCamel})
 				.values({
 					id: crypto.randomUUID(),
-					name: input.name,
-					createdAt: new Date().toISOString(),
+${options.tenant ? `\t\t\t\t\ttenantId: input.tenantId,\n` : ""}					name: input.name,
+					version: 1,
+					createdAt: now,
+					updatedAt: now,
 				})
 				.returning();
 
@@ -3397,6 +5501,7 @@ export function createDrizzle${names.singularPascal}Repository(
 
 			return to${names.singularPascal}(row);
 		},
+${mode === "resource" ? `		async findById(id: string${options.tenant ? ", filter" : ""}) {\n			const [row] = await db\n				.select()\n				.from(schema.${names.pluralCamel})\n				.where(${findWhere})\n				.limit(1);\n\n			return row ? to${names.singularPascal}(row) : null;\n		},\n		async update(input) {\n			const [row] = await db\n				.update(schema.${names.pluralCamel})\n				.set({\n					name: input.name,\n					version: input.version + 1,\n					updatedAt: new Date().toISOString(),\n				})\n				.where(${updateWhere})\n				.returning();\n\n			return row ? to${names.singularPascal}(row) : null;\n		},\n		async delete(id: string${options.tenant ? ", filter" : ""}) {\n${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst rows = await db\n\t\t\t\t.update(schema.${names.pluralCamel})\n\t\t\t\t.set({ deletedAt: now, updatedAt: now })\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n` : `\t\t\tconst rows = await db\n\t\t\t\t.delete(schema.${names.pluralCamel})\n\t\t\t\t.where(${deleteWhere})\n\t\t\t\t.returning({ id: schema.${names.pluralCamel}.id });\n`}\n			return rows.length > 0;\n		},\n` : ""}
 	};
 }
 `;
@@ -3405,13 +5510,17 @@ export function createDrizzle${names.singularPascal}Repository(
 function contractFile(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
+  mode: ResourceGenerationMode,
+  options: ResourceGenerationOptions,
 ): string {
-  return `import { createContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup } from "@beignet/core/contracts";
 import { z } from "zod";
-import {
-	create${names.singularPascal}UseCase,
-	list${names.pluralPascal}UseCase,
-} from "${aliasModule(resourceUseCaseIndexPath(names, config))}";
+${mode === "resource" ? `import { errors } from "${aliasModule(resourceSharedErrorsPath(config))}";\n` : ""}import {
+	Create${names.singularPascal}InputSchema,
+	List${names.pluralPascal}InputSchema,
+	List${names.pluralPascal}OutputSchema,
+	${names.singularPascal}Schema,
+${mode === "resource" ? `	${names.singularPascal}IdInputSchema,\n	Update${names.singularPascal}BodySchema,\n` : ""}} from "${aliasModule(resourceSchemaFilePath(names, config))}";
 
 const ErrorResponseSchema = z.object({
 	code: z.string(),
@@ -3419,7 +5528,7 @@ const ErrorResponseSchema = z.object({
 	requestId: z.string().optional(),
 });
 
-const ${names.pluralCamel} = createContractGroup()
+const ${names.pluralCamel} = defineContractGroup()
 	.namespace("${names.pluralCamel}")
 	.responses({
 		500: ErrorResponseSchema,
@@ -3427,22 +5536,52 @@ const ${names.pluralCamel} = createContractGroup()
 
 export const list${names.pluralPascal} = ${names.pluralCamel}
 	.get("/api/${names.pluralKebab}")
-	.query(list${names.pluralPascal}UseCase.inputSchema)
+	.query(List${names.pluralPascal}InputSchema)
 	.responses({
-		200: list${names.pluralPascal}UseCase.outputSchema,
+		200: List${names.pluralPascal}OutputSchema,
 	});
 
 export const create${names.singularPascal} = ${names.pluralCamel}
 	.post("/api/${names.pluralKebab}")
-	.body(create${names.singularPascal}UseCase.inputSchema)
+	.body(Create${names.singularPascal}InputSchema)
+${options.auth ? `	.meta({\n		auth: "required",\n		authorization: { ability: "${names.pluralCamel}.create" },\n	})\n	.errors({ Unauthorized: errors.Unauthorized, Forbidden: errors.Forbidden })\n` : ""}	.responses({
+		201: ${names.singularPascal}Schema,
+	});
+${
+  mode === "resource"
+    ? `
+export const get${names.singularPascal} = ${names.pluralCamel}
+	.get("/api/${names.pluralKebab}/:id")
+	.pathParams(${names.singularPascal}IdInputSchema)
+	.errors({ ${names.singularPascal}NotFound: errors.${names.singularPascal}NotFound })
+	.responses({
+		200: ${names.singularPascal}Schema,
+	});
+
+export const update${names.singularPascal} = ${names.pluralCamel}
+	.patch("/api/${names.pluralKebab}/:id")
+	.pathParams(${names.singularPascal}IdInputSchema)
+	.body(Update${names.singularPascal}BodySchema)
+${options.auth ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization: { ability: "${names.pluralCamel}.update" },\n\t})\n` : ""}	.errors({${options.auth ? " Unauthorized: errors.Unauthorized, Forbidden: errors.Forbidden," : ""} ${names.singularPascal}NotFound: errors.${names.singularPascal}NotFound, ${names.singularPascal}Conflict: errors.${names.singularPascal}Conflict })
 	.responses({
-		201: create${names.singularPascal}UseCase.outputSchema,
+		200: ${names.singularPascal}Schema,
 	});
+
+export const delete${names.singularPascal} = ${names.pluralCamel}
+	.delete("/api/${names.pluralKebab}/:id")
+	.pathParams(${names.singularPascal}IdInputSchema)
+${options.auth ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization: { ability: "${names.pluralCamel}.delete" },\n\t})\n` : ""}	.errors({${options.auth ? " Unauthorized: errors.Unauthorized, Forbidden: errors.Forbidden," : ""} ${names.singularPascal}NotFound: errors.${names.singularPascal}NotFound })
+	.responses({
+		204: null,
+	});
+`
+    : ""
+}
 `;
 }
 
 function standaloneContractFile(names: ResourceNames): string {
-  return `import { createContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup } from "@beignet/core/contracts";
 import { z } from "zod";
 
 const ErrorResponseSchema = z.object({
@@ -3451,7 +5590,7 @@ const ErrorResponseSchema = z.object({
 	requestId: z.string().optional(),
 });
 
-const ${names.pluralCamel} = createContractGroup()
+const ${names.pluralCamel} = defineContractGroup()
 	.namespace("${names.pluralCamel}")
 	.responses({
 		500: ErrorResponseSchema,
@@ -3472,10 +5611,14 @@ export const list${names.pluralPascal} = ${names.pluralCamel}
 	)
 	.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),
+			items: z.array(${names.singularCamel}Schema),
+			page: z.object({
+				kind: z.literal("offset"),
+				limit: z.number().int().min(1),
+				offset: z.number().int().min(0),
+				total: z.number().int().min(0),
+				hasMore: z.boolean(),
+			}),
 		}),
 	});
 
@@ -3488,7 +5631,8 @@ function standaloneUseCaseFile(
   config: ResolvedBeignetConfig,
   filePath: string,
 ): string {
-  return `import { z } from "zod";
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { z } from "zod";
 import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 
 export const ${names.action.pascal}InputSchema = z.object({});
@@ -3521,29 +5665,27 @@ function useCaseTestFile(
   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 { createTestContextFactory, createTestPorts } from "@beignet/core/testing";
+import { createTestAnonymousActor } from "@beignet/core/ports/testing";
 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 testFixture = createTestPorts<AppContext["ports"]>({
+			base: appPorts,
+			overrides: {
+				gate: appPorts.gate,
+				devtools: createInMemoryDevtools(),
+			},
+		});
+		const createTestContext = createTestContextFactory<AppContext, AppContext["ports"]>({
+			ports: testFixture.ports,
+			actor: createTestAnonymousActor(),
+			tenant: null,
+		});
+		const tester = createUseCaseTester<AppContext>(createTestContext);
 
 		const result = await tester.run(${names.exportName}, {});
 
@@ -3609,6 +5751,144 @@ export const ${names.policyName} = definePolicy({
 `;
 }
 
+function resourcePolicyFile(
+  names: ResourceNames,
+  _config: ResolvedBeignetConfig,
+  options: ResourceGenerationOptions,
+): string {
+  return `import type { ActivityActor, ActivityTenant } from "@beignet/core/ports";
+import { definePolicy, deny } from "@beignet/core/ports";
+
+export type AuthorizationContext = {
+	actor: ActivityActor;
+	tenant?: ActivityTenant;
+};
+
+type ${names.singularPascal}PolicyResource = {
+	id: string;
+	tenantId?: string;
+};
+
+function isAuthenticated(ctx: AuthorizationContext) {
+	return ctx.actor.type === "user" && Boolean(ctx.actor.id);
+}
+
+function canWrite(ctx: AuthorizationContext) {
+	if (!isAuthenticated(ctx)) return deny("You must be signed in.");
+${options.tenant ? `\tif (!ctx.tenant?.id) return deny("A tenant is required.");\n` : ""}	return true;
+}
+
+export const ${names.singularCamel}Policy = definePolicy({
+	"${names.pluralCamel}.view": (_ctx: AuthorizationContext) => true,
+	"${names.pluralCamel}.create": (ctx: AuthorizationContext) =>
+		canWrite(ctx),
+	"${names.pluralCamel}.update": (ctx: AuthorizationContext, ${names.singularCamel}: ${names.singularPascal}PolicyResource) => {
+		const decision = canWrite(ctx);
+		if (decision !== true) return decision;
+${options.tenant ? `\t\tif (${names.singularCamel}.tenantId !== ctx.tenant?.id) {\n\t\t\treturn deny("You cannot update a ${names.singularKebab} from another tenant.");\n\t\t}\n` : ""}
+		return true;
+	},
+	"${names.pluralCamel}.delete": (ctx: AuthorizationContext, ${names.singularCamel}: ${names.singularPascal}PolicyResource) => {
+		const decision = canWrite(ctx);
+		if (decision !== true) return decision;
+${options.tenant ? `\t\tif (${names.singularCamel}.tenantId !== ctx.tenant?.id) {\n\t\t\treturn deny("You cannot delete a ${names.singularKebab} from another tenant.");\n\t\t}\n` : ""}
+		return true;
+	},
+	"${names.pluralCamel}.manage": (_ctx: AuthorizationContext) =>
+		deny("You are not allowed to manage this ${names.singularKebab}."),
+});
+`;
+}
+
+function resourceEventsFile(names: ResourceNames): string {
+  return `import { defineEvent } from "@beignet/core/events";
+import { z } from "zod";
+
+export const ${names.singularPascal}Created = defineEvent("${names.pluralCamel}.created", {
+	payload: z.object({
+		id: z.string().uuid(),
+	}),
+});
+
+export const ${names.singularPascal}Updated = defineEvent("${names.pluralCamel}.updated", {
+	payload: z.object({
+		id: z.string().uuid(),
+	}),
+});
+
+export const ${names.singularPascal}Deleted = defineEvent("${names.pluralCamel}.deleted", {
+	payload: z.object({
+		id: z.string().uuid(),
+	}),
+});
+
+export const ${names.singularCamel}Events = [
+	${names.singularPascal}Created,
+	${names.singularPascal}Updated,
+	${names.singularPascal}Deleted,
+] as const;
+`;
+}
+
+function resourcePolicyTestFile(
+  names: ResourceNames,
+  options: ResourceGenerationOptions,
+): string {
+  return `import { describe, expect, it } from "bun:test";
+import { createPolicyTester } from "@beignet/core/ports/testing";
+import { ${names.singularCamel}Policy } from "../policy";
+import type { ${names.singularPascal} } from "../schemas";
+
+function create${names.singularPascal}(): ${names.singularPascal} {
+	const now = new Date().toISOString();
+	return {
+		id: "00000000-0000-4000-8000-000000000001",
+${options.tenant ? `\t\ttenantId: "tenant_test",\n` : ""}		name: "Test ${names.singularPascal}",
+		version: 1,
+		createdAt: now,
+		updatedAt: now,
+	};
+}
+
+describe("${names.singularCamel}Policy", () => {
+	it("documents generated ${names.pluralKebab} authorization rules", async () => {
+		const tester = createPolicyTester({
+			policies: [${names.singularCamel}Policy],
+		});
+		const ${names.singularCamel} = create${names.singularPascal}();
+		const ctx = {
+			actor: { type: "user" as const, id: "user_test" },
+${options.tenant ? `\t\t\ttenant: { id: "tenant_test" },\n` : ""}		};
+
+		await expect(
+			tester.assertMatrix([
+				{
+					name: "authenticated actor can create ${names.singularKebab}",
+					ctx,
+					ability: "${names.pluralCamel}.create",
+					expected: "allow",
+				},
+				{
+					name: "authenticated actor can update ${names.singularKebab}",
+					ctx,
+					ability: "${names.pluralCamel}.update",
+					subject: ${names.singularCamel},
+					expected: "allow",
+				},
+				{
+					name: "authenticated actor can delete ${names.singularKebab}",
+					ctx,
+					ability: "${names.pluralCamel}.delete",
+					subject: ${names.singularCamel},
+					expected: "allow",
+				},
+			]),
+		).resolves.toBeUndefined();
+	});
+});
+`;
+}
+
 function eventFile(names: EventNames): string {
   return `import { defineEvent } from "@beignet/core/events";
 import { z } from "zod";
@@ -3626,11 +5906,9 @@ export const ${names.eventExportName} = defineEvent("${names.eventName}", {
 }
 
 function jobFile(names: JobNames, config: ResolvedBeignetConfig): string {
-  return `import { createJobHandlers } from "@beignet/core/jobs";
+  return `import { retry } from "@beignet/core/jobs";
 import { z } from "zod";
-import type { AppContext } from "${aliasModule(config.paths.appContext)}";
-
-const jobs = createJobHandlers<AppContext>();
+import { defineJob } from "${aliasModule(config.paths.jobsBuilder)}";
 
 export const ${names.payloadSchemaName} = z.object({
 \tid: z.string().uuid(),
@@ -3638,11 +5916,13 @@ export const ${names.payloadSchemaName} = z.object({
 
 export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
 
-export const ${names.jobExportName} = jobs.defineJob("${names.jobName}", {
+export const ${names.jobExportName} = defineJob("${names.jobName}", {
 \tpayload: ${names.payloadSchemaName},
-\tretry: {
+\tretry: retry.exponential({
 \t\tattempts: 3,
-\t},
+\t\tinitialDelay: "1s",
+\t\tmaxDelay: "1m",
+\t}),
 \tasync handle({ payload, ctx }) {
 \t\tctx.ports.logger.info("Job handled", {
 \t\t\tjobName: "${names.jobName}",
@@ -3653,19 +5933,110 @@ export const ${names.jobExportName} = jobs.defineJob("${names.jobName}", {
 `;
 }
 
+function taskFile(names: TaskNames, config: ResolvedBeignetConfig): string {
+  return `import { z } from "zod";
+import { defineTask } from "${aliasModule(config.paths.tasksBuilder)}";
+
+export const ${names.inputSchemaName} = z.object({
+\tdryRun: z.boolean().default(true),
+});
+
+export type ${names.inputTypeName} = z.infer<typeof ${names.inputSchemaName}>;
+
+export const ${names.taskExportName} = defineTask("${names.taskName}", {
+\tinput: ${names.inputSchemaName},
+\tdescription: "Operational ${names.feature.kebab} ${names.artifact.kebab} task.",
+\tasync handle({ input, ctx }) {
+\t\tctx.ports.logger.info("Task handled", {
+\t\t\ttaskName: "${names.taskName}",
+\t\t\tdryRun: input.dryRun,
+\t\t});
+
+\t\treturn {
+\t\t\tdryRun: input.dryRun,
+\t\t};
+\t},
+});
+`;
+}
+
+function factoryFile(
+  names: FactoryNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const resource = featureResourceNames(names);
+
+  return `import { createFactory } from "@beignet/core/testing";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+export const ${names.factoryExportName} = createFactory("${names.factoryName}", {
+\tdefaults: ({ sequence }) => ({
+\t\tname: "${resource.singularPascal} " + sequence,
+\t}),
+\tpersist: (ctx: AppContext, input) => ctx.ports.${resource.pluralCamel}.create(input),
+});
+`;
+}
+
+function seedFile(names: SeedNames, config: ResolvedBeignetConfig): string {
+  const resource = featureResourceNames(names);
+
+  return `import { defineSeed } from "@beignet/core/testing";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+export const ${names.seedExportName} = defineSeed("${names.seedName}", {
+\tdescription: "Creates starter ${names.feature.kebab} data.",
+\trun: async (ctx: AppContext) => {
+\t\tawait ctx.ports.${resource.pluralCamel}.create({
+\t\t\tname: "Demo ${resource.singularPascal}",
+\t\t});
+\t},
+});
+`;
+}
+
+function notificationFile(
+  names: NotificationNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return `import { defineMailNotificationChannel } from "@beignet/core/notifications";
+import { z } from "zod";
+import { defineNotification } from "${aliasModule(config.paths.notificationsBuilder)}";
+
+export const ${names.payloadSchemaName} = z.object({
+\tid: z.string().uuid(),
+\tsubject: z.string(),
+\trecipientEmail: z.string().email(),
+});
+
+export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
+
+export const ${names.notificationExportName} = defineNotification(
+\t"${names.notificationName}",
+\t{
+\t\tpayload: ${names.payloadSchemaName},
+\t\tchannels: {
+\t\t\temail: defineMailNotificationChannel(({ payload }) => ({
+\t\t\t\tto: payload.recipientEmail,
+\t\t\t\tsubject: payload.subject,
+\t\t\t\ttext: \`${names.notificationName} notification for \${payload.id}.\`,
+\t\t\t})),
+\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)}";
+  return `import { defineListener } from "${aliasModule(config.paths.listenersBuilder)}";
 import { ${names.event.eventExportName} } from "${relativeModule(filePath, eventFilePath(names.event, config))}";
 
-const events = createEventHandlers<AppContext>();
-
-export const ${names.listenerExportName} = events.defineListener(${names.event.eventExportName}, {
+export const ${names.listenerExportName} = defineListener(${names.event.eventExportName}, {
 \tname: "${names.listenerName}",
 \tasync handle({ payload, ctx }) {
 \t\tctx.ports.logger.info("Listener handled", {
@@ -3681,11 +6052,8 @@ 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>();
+  return `import { z } from "zod";
+import { defineSchedule } from "${aliasModule(config.paths.schedulesBuilder)}";
 
 export const ${names.payloadSchemaName} = z.object({
 \tdate: z.string(),
@@ -3693,7 +6061,7 @@ export const ${names.payloadSchemaName} = z.object({
 
 export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
 
-export const ${names.scheduleExportName} = schedules.defineSchedule(
+export const ${names.scheduleExportName} = defineSchedule(
 \t"${names.scheduleName}",
 \t{
 \t\tcron: "${names.cron}",
@@ -3716,111 +6084,174 @@ ${names.timezone ? `\t\ttimezone: "${names.timezone}",\n` : ""}\t\tpayload: ${na
 `;
 }
 
+function uploadFile(names: UploadNames, config: ResolvedBeignetConfig): string {
+  return `import { defineUpload } from "@beignet/core/uploads";
+import { z } from "zod";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+export const ${names.metadataSchemaName} = z.object({
+\tresourceId: z.string().min(1),
+});
+
+export type ${names.metadataTypeName} = z.infer<typeof ${names.metadataSchemaName}>;
+
+export const ${names.uploadExportName} = defineUpload<
+\t"${names.uploadName}",
+\ttypeof ${names.metadataSchemaName},
+\tAppContext,
+\t{ objectKeys: string[] }
+>("${names.uploadName}", {
+\tmetadata: ${names.metadataSchemaName},
+\tfile: {
+\t\tcontentTypes: ["application/pdf", "text/plain"],
+\t\tmaxSizeBytes: 5 * 1024 * 1024,
+\t\tmaxFiles: 1,
+\t\tvisibility: "private",
+\t\tcacheControl: "private, max-age=0",
+\t},
+\tauthorize({ ctx }) {
+\t\treturn ctx.actor.type === "user";
+\t},
+\tkey({ ctx, metadata, uploadId, file }) {
+\t\tconst tenantId = ctx.tenant?.id ?? "default";
+\t\tconst extension = file.name.includes(".") ? file.name.split(".").pop() : undefined;
+\t\tconst suffix = extension ? \`.\${extension}\` : "";
+\t\treturn "${names.feature.kebab}/" + tenantId + "/" + metadata.resourceId + "/" + uploadId + suffix;
+\t},
+\tstorageMetadata({ ctx, metadata }) {
+\t\treturn {
+\t\t\ttenantId: ctx.tenant?.id ?? "default",
+\t\t\tresourceId: metadata.resourceId,
+\t\t};
+\t},
+\tasync onComplete({ ctx, metadata, files }) {
+\t\tctx.ports.logger.info("Upload completed", {
+\t\t\tuploadName: "${names.uploadName}",
+\t\t\tresourceId: metadata.resourceId,
+\t\t\tobjectKeys: files.map((file) => file.key),
+\t\t});
+
+\t\treturn {
+\t\t\tobjectKeys: files.map((file) => file.key),
+\t\t};
+\t},
+});
+`;
+}
+
+function featureUiComponentFile(
+  names: FeatureUiNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return `"use client";
+
+import { contractErrorMessage } from "@beignet/core/client";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useState } from "react";
+import { rq } from "${aliasModule(clientIndexPath(config))}";
+import { create${names.singularPascal}, list${names.pluralPascal} } from "${aliasModule(
+    resourceContractFilePath(names, config),
+  )}";
+
+export function ${names.componentExportName}() {
+\tconst [name, setName] = useState("");
+\tconst queryClient = useQueryClient();
+\tconst ${names.pluralCamel}Query = useQuery(
+\t\trq(list${names.pluralPascal}).queryOptions({ query: {} }),
+\t);
+\tconst create${names.singularPascal}Mutation = useMutation(
+\t\trq(create${names.singularPascal}).mutationOptions({
+\t\t\tonSuccess: async () => {
+\t\t\t\tsetName("");
+\t\t\t\tawait rq(list${names.pluralPascal}).invalidate(queryClient);
+\t\t\t},
+\t\t}),
+\t);
+
+\treturn (
+\t\t<section className="${names.pluralKebab}-panel">
+\t\t\t<form
+\t\t\t\tclassName="${names.pluralKebab}-composer"
+\t\t\t\tonSubmit={(event) => {
+\t\t\t\t\tevent.preventDefault();
+\t\t\t\t\tconst trimmedName = name.trim();
+\t\t\t\t\tif (!trimmedName) return;
+\t\t\t\t\tcreate${names.singularPascal}Mutation.reset();
+\t\t\t\t\tcreate${names.singularPascal}Mutation.mutate({
+\t\t\t\t\t\tbody: { name: trimmedName },
+\t\t\t\t\t});
+\t\t\t\t}}
+\t\t\t>
+\t\t\t\t<label htmlFor="${names.singularKebab}-name">New ${names.singularKebab}</label>
+\t\t\t\t<div className="${names.pluralKebab}-composer-row">
+\t\t\t\t\t<input
+\t\t\t\t\t\tid="${names.singularKebab}-name"
+\t\t\t\t\t\tvalue={name}
+\t\t\t\t\t\tonChange={(event) => setName(event.currentTarget.value)}
+\t\t\t\t\t\tplaceholder="Name"
+\t\t\t\t\t/>
+\t\t\t\t\t<button
+\t\t\t\t\t\ttype="submit"
+\t\t\t\t\t\tdisabled={!name.trim() || create${names.singularPascal}Mutation.isPending}
+\t\t\t\t\t>
+\t\t\t\t\t\t{create${names.singularPascal}Mutation.isPending ? "Creating" : "Create"}
+\t\t\t\t\t</button>
+\t\t\t\t</div>
+\t\t\t\t{create${names.singularPascal}Mutation.isError ? (
+\t\t\t\t\t<p role="alert">
+\t\t\t\t\t\t{contractErrorMessage(
+\t\t\t\t\t\t\tcreate${names.singularPascal}Mutation.error,
+\t\t\t\t\t\t\t"Could not create ${names.singularKebab}.",
+\t\t\t\t\t\t)}
+\t\t\t\t\t</p>
+\t\t\t\t) : null}
+\t\t\t</form>
+
+\t\t\t<div className="${names.pluralKebab}-list">
+\t\t\t\t<div className="${names.pluralKebab}-list-heading">
+\t\t\t\t\t<h2>${names.pluralPascal}</h2>
+\t\t\t\t\t<span>{${names.pluralCamel}Query.data?.items.length ?? 0} shown</span>
+\t\t\t\t</div>
+\t\t\t\t{${names.pluralCamel}Query.isLoading ? <p>Loading...</p> : null}
+\t\t\t\t{${names.pluralCamel}Query.isError ? (
+\t\t\t\t\t<p role="alert">Could not load ${names.pluralKebab}.</p>
+\t\t\t\t) : null}
+\t\t\t\t{${names.pluralCamel}Query.data?.items.length === 0 ? (
+\t\t\t\t\t<p>No ${names.pluralKebab} yet.</p>
+\t\t\t\t) : null}
+\t\t\t\t<ul>
+\t\t\t\t\t{${names.pluralCamel}Query.data?.items.map((${names.singularCamel}) => (
+\t\t\t\t\t\t<li key={${names.singularCamel}.id}>
+\t\t\t\t\t\t\t<strong>{${names.singularCamel}.name}</strong>
+\t\t\t\t\t\t\t<small>{new Date(${names.singularCamel}.createdAt).toLocaleDateString()}</small>
+\t\t\t\t\t\t</li>
+\t\t\t\t\t))}
+\t\t\t\t</ul>
+\t\t\t</div>
+\t\t</section>
+\t);
+}
+`;
+}
+
 function scheduleRouteFile(
   names: ScheduleNames,
   config: ResolvedBeignetConfig,
 ): string {
-  return `import { createInlineScheduleRunner } from "@beignet/core/schedules";
-import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+  return `import { createScheduleRoute } from "@beignet/next";
 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;
+export const runtime = "nodejs";
 
-\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};
+export const { GET, POST } = createScheduleRoute({
+\tserver,
+\tschedules: [${names.scheduleExportName}],
+\tschedule: ${names.scheduleExportName}.name,
+\tsecret: env.CRON_SECRET,
+\tsource: "cron-route",
+});
 `;
 }
 
@@ -3838,79 +6269,161 @@ function useCaseIndexExport(names: UseCaseNames): string {
 function routeGroupFile(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
+  mode: ResourceGenerationMode,
+  _options: ResourceGenerationOptions,
 ): 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))}";
+  const routeFilePath = path.join(
+    config.paths.features,
+    names.pluralKebab,
+    "routes.ts",
+  );
+  const contractsPath = resourceContractFilePath(names, config);
+  const useCasesPath = resourceUseCaseIndexPath(names, config);
+
+  return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { defineRouteGroup } from "@beignet/next";
+import type { AppContext } from "${relativeModule(routeFilePath, config.paths.appContext)}";
+import {
+	create${names.singularPascal},
+${mode === "resource" ? `	delete${names.singularPascal},\n	get${names.singularPascal},\n` : ""}	list${names.pluralPascal},
+${mode === "resource" ? `	update${names.singularPascal},\n` : ""}} from "${relativeModule(routeFilePath, contractsPath)}";
 import {
 	create${names.singularPascal}UseCase,
-	list${names.pluralPascal}UseCase,
-} from "${relativeModule(path.join(config.paths.features, names.pluralKebab, "routes.ts"), resourceUseCaseIndexPath(names, config))}";
+${mode === "resource" ? `	delete${names.singularPascal}UseCase,\n	get${names.singularPascal}UseCase,\n` : ""}	list${names.pluralPascal}UseCase,
+${mode === "resource" ? `	update${names.singularPascal}UseCase,\n` : ""}} from "${relativeModule(routeFilePath, useCasesPath)}";
 
 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 }),
-			}),
-		},
-	],
+		{ contract: list${names.pluralPascal}, useCase: list${names.pluralPascal}UseCase },
+		{ contract: create${names.singularPascal}, useCase: create${names.singularPascal}UseCase },
+${mode === "resource" ? `		{ contract: get${names.singularPascal}, useCase: get${names.singularPascal}UseCase },\n		{ contract: update${names.singularPascal}, useCase: update${names.singularPascal}UseCase },\n		{ contract: delete${names.singularPascal}, useCase: delete${names.singularPascal}UseCase },\n` : ""}	],
 });
 `;
 }
 
-function testFile(names: ResourceNames, config: ResolvedBeignetConfig): string {
+function testFile(
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  mode: ResourceGenerationMode,
+  options: ResourceGenerationOptions,
+): string {
   const repositoryPath = path.join(
     path.dirname(config.paths.infrastructurePorts),
     names.pluralKebab,
     `in-memory-${names.singularKebab}-repository.ts`,
   );
+  const serverContextPath = path.join(
+    path.dirname(config.paths.server),
+    "context.ts",
+  );
+  const requestTarget = options.tenant ? "requester" : "app";
 
   return `import { describe, expect, it } from "bun:test";
 import { createUseCaseTester } from "@beignet/core/application";
+${mode === "resource" ? `import { isAppError } from "@beignet/core/errors";\n` : ""}import { defineRoutes } from "@beignet/web";
+import { createTestApp${options.tenant ? ", createTestRequester" : ""} } from "@beignet/web/testing";
 import { createInMemoryDevtools } from "@beignet/devtools";
-import { createAnonymousActor, createMemoryStorage, createNoopUnitOfWork } from "@beignet/core/ports";
+import { createTestContextFactory, createTestPorts } from "@beignet/core/testing";
+import { ${options.auth ? "createTestUserActor" : "createTestAnonymousActor"}${options.tenant ? ", createTestTenant" : ""} } from "@beignet/core/ports/testing";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
 import { appPorts } from "${aliasModule(config.paths.infrastructurePorts)}";
+import { appContext } from "${aliasModule(serverContextPath)}";
+import {
+	create${names.singularPascal},
+${mode === "resource" ? `	delete${names.singularPascal},\n	get${names.singularPascal},\n` : ""}	list${names.pluralPascal},
+${mode === "resource" ? `	update${names.singularPascal},\n` : ""}} from "${aliasModule(resourceContractFilePath(names, config))}";
 import { createInMemory${names.singularPascal}Repository } from "${aliasModule(repositoryPath)}";
+import { ${names.singularCamel}Routes } from "${aliasModule(path.join(resourceFeatureDir(names, config), "routes.ts"))}";
 import {
 	create${names.singularPascal}UseCase,
-	list${names.pluralPascal}UseCase,
-} from "${aliasModule(resourceUseCaseIndexPath(names, config))}";
+${mode === "resource" ? `	delete${names.singularPascal}UseCase,\n	get${names.singularPascal}UseCase,\n` : ""}	list${names.pluralPascal}UseCase,
+${mode === "resource" ? `	update${names.singularPascal}UseCase,\n` : ""}} 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"]),
+	it("${mode === "resource" ? `exercises ${names.pluralCamel} CRUD` : `creates and lists ${names.pluralCamel}`}", async () => {
+		const seed${names.pluralPascal} = [
+			{
+				id: "00000000-0000-4000-8000-000000000101",
+${options.tenant ? `\t\t\t\ttenantId: "tenant_test",\n` : ""}				name: "Alpha ${names.singularPascal}",
+				version: 1,
+				createdAt: "2024-01-01T00:00:00.000Z",
+				updatedAt: "2024-01-01T00:00:00.000Z",
+			},
+			{
+				id: "00000000-0000-4000-8000-000000000102",
+${options.tenant ? `\t\t\t\ttenantId: "tenant_test",\n` : ""}				name: "Beta ${names.singularPascal}",
+				version: 1,
+				createdAt: "2024-01-02T00:00:00.000Z",
+				updatedAt: "2024-01-02T00:00:00.000Z",
+			},
+			{
+				id: "00000000-0000-4000-8000-000000000103",
+${options.tenant ? `\t\t\t\ttenantId: "tenant_test",\n` : ""}				name: "Gamma ${names.singularPascal}",
+				version: 1,
+				createdAt: "2024-01-03T00:00:00.000Z",
+				updatedAt: "2024-01-03T00:00:00.000Z",
+			},
+${options.tenant ? `\t\t\t{\n\t\t\t\tid: "00000000-0000-4000-8000-000000000104",\n\t\t\t\ttenantId: "tenant_other",\n\t\t\t\tname: "Other Tenant ${names.singularPascal}",\n\t\t\t\tversion: 1,\n\t\t\t\tcreatedAt: "2024-01-04T00:00:00.000Z",\n\t\t\t\tupdatedAt: "2024-01-04T00:00:00.000Z",\n\t\t\t},\n` : ""}		];
+		const ${names.pluralCamel} = createInMemory${names.singularPascal}Repository(seed${names.pluralPascal});
+		const testFixture = createTestPorts<AppContext["ports"]>({
+			base: appPorts,
+			overrides: {
 				${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,
-		}));
+${
+  options.auth
+    ? `\t\t\t\tauth: {
+					getSession: async () => ({
+						user: { id: "user_test", name: "Test User" },
+					}),
+				},
+				gate: appPorts.gate,\n`
+    : `\t\t\t\tauth: {
+					getSession: async () => null,
+				},\n`
+}				devtools: createInMemoryDevtools(),
+			},
+			transaction: {
+				ports: (ports) => ({
+					...ports,
+					${names.pluralCamel},
+				}),
+			},
+		});
+		const createTestContext = createTestContextFactory<AppContext, AppContext["ports"]>({
+			ports: testFixture.ports,
+			actor: ${options.auth ? `createTestUserActor("user_test")` : "createTestAnonymousActor()"},
+			tenant: ${options.tenant ? `createTestTenant("tenant_test")` : "null"},
+		});
+		const tester = createUseCaseTester<AppContext>(createTestContext);
 
 		const ctx = await tester.ctx();
+		const defaultPage = await tester.run(list${names.pluralPascal}UseCase, {}, { ctx });
+		const filteredPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ name: "alp" },
+			{ ctx },
+		);
+		const firstPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ limit: 2 },
+			{ ctx },
+		);
+		const secondPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ limit: 2, cursor: firstPage.page.nextCursor },
+			{ ctx },
+		);
+		const nameAscendingPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ sortBy: "name", sortDirection: "asc" },
+			{ ctx },
+		);
+		const nameDescendingPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ sortBy: "name", sortDirection: "desc" },
+			{ ctx },
+		);
 		const created = await tester.run(
 			create${names.singularPascal}UseCase,
 			{ name: "First ${names.singularPascal}" },
@@ -3918,13 +6431,113 @@ describe("${names.pluralCamel} resource", () => {
 		);
 		const result = await tester.run(
 			list${names.pluralPascal}UseCase,
-			{ limit: 20, offset: 0 },
+			{ name: "First" },
 			{ ctx },
 		);
 
+		expect(defaultPage.page).toMatchObject({
+			kind: "cursor",
+			limit: 20,
+			cursor: null,
+			nextCursor: null,
+			hasMore: false,
+		});
+		expect(defaultPage.items.map((item) => item.name)).toEqual([
+			"Gamma ${names.singularPascal}",
+			"Beta ${names.singularPascal}",
+			"Alpha ${names.singularPascal}",
+		]);
+		expect(filteredPage.items.map((item) => item.name)).toEqual([
+			"Alpha ${names.singularPascal}",
+		]);
+		expect(firstPage.items.map((item) => item.name)).toEqual([
+			"Gamma ${names.singularPascal}",
+			"Beta ${names.singularPascal}",
+		]);
+		expect(firstPage.page.nextCursor).toEqual(expect.any(String));
+		expect(secondPage.items.map((item) => item.name)).toEqual([
+			"Alpha ${names.singularPascal}",
+		]);
+		expect(secondPage.page.nextCursor).toBeNull();
+		expect(nameAscendingPage.items.map((item) => item.name)).toEqual([
+			"Alpha ${names.singularPascal}",
+			"Beta ${names.singularPascal}",
+			"Gamma ${names.singularPascal}",
+		]);
+		expect(nameDescendingPage.items.map((item) => item.name)).toEqual([
+			"Gamma ${names.singularPascal}",
+			"Beta ${names.singularPascal}",
+			"Alpha ${names.singularPascal}",
+		]);
 		expect(created.name).toBe("First ${names.singularPascal}");
-		expect(result.total).toBe(1);
-		expect(result.${names.pluralCamel}).toEqual([created]);
+		expect(result.items).toEqual([created]);
+${
+  mode === "resource"
+    ? `
+		const fetched = await tester.run(
+			get${names.singularPascal}UseCase,
+			{ id: created.id },
+			{ ctx },
+		);
+		const updated = await tester.run(
+			update${names.singularPascal}UseCase,
+			{ id: created.id, name: "Updated ${names.singularPascal}", version: fetched.version },
+			{ ctx },
+		);
+		try {
+			await tester.run(
+				update${names.singularPascal}UseCase,
+				{ id: created.id, name: "Stale ${names.singularPascal}", version: fetched.version },
+				{ ctx },
+			);
+			throw new Error("Expected ${names.singularPascal}Conflict");
+		} catch (error) {
+			expect(isAppError(error)).toBe(true);
+			if (isAppError(error)) {
+				expect(error.code).toBe("${constantCase(names.singularKebab)}_CONFLICT");
+			}
+		}
+		await tester.run(delete${names.singularPascal}UseCase, { id: created.id }, { ctx });
+		const afterDelete = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ name: "Updated" },
+			{ ctx },
+		);
+
+		expect(fetched).toEqual(created);
+		expect(updated.name).toBe("Updated ${names.singularPascal}");
+		expect(updated.version).toBe(fetched.version + 1);
+		expect(afterDelete.items).toEqual([]);
+
+		try {
+			await tester.run(get${names.singularPascal}UseCase, { id: created.id }, { ctx });
+			throw new Error("Expected ${names.singularPascal}NotFound");
+		} catch (error) {
+			expect(isAppError(error)).toBe(true);
+			if (isAppError(error)) {
+				expect(error.code).toBe("${constantCase(names.singularKebab)}_NOT_FOUND");
+			}
+		}
+`
+    : ""
+}
+
+		const app = await createTestApp({
+			ports: testFixture.ports,
+			routes: defineRoutes<AppContext>([${names.singularCamel}Routes]),
+			context: appContext,
+		});
+${options.tenant ? `\t\tconst requester = createTestRequester(app, {\n\t\t\theaders: { "x-tenant-id": "tenant_test" },\n\t\t});\n` : ""}
+		const createdViaRoute = await ${requestTarget}.request(create${names.singularPascal}, {
+			body: { name: "Second ${names.singularPascal}" },
+		});
+${mode === "resource" ? `		const fetchedViaRoute = await ${requestTarget}.request(get${names.singularPascal}, {\n			path: { id: createdViaRoute.id },\n		});\n		const updatedViaRoute = await ${requestTarget}.request(update${names.singularPascal}, {\n			path: { id: createdViaRoute.id },\n			body: { name: "Updated via route", version: fetchedViaRoute.version },\n		});\n` : ""}		const listedViaRoute = await ${requestTarget}.request(list${names.pluralPascal}, {
+			query: { name: "${mode === "resource" ? "Updated via route" : "Second"}" },
+		});
+${mode === "resource" ? `		const deletedViaRoute = await ${requestTarget}.request(delete${names.singularPascal}, {\n			path: { id: createdViaRoute.id },\n		});\n		const listedAfterDeleteViaRoute = await ${requestTarget}.request(list${names.pluralPascal}, {\n			query: { name: "Updated via route" },\n		});\n` : ""}		await app.stop();
+
+		expect(createdViaRoute.name).toBe("Second ${names.singularPascal}");
+${mode === "resource" ? `		expect(fetchedViaRoute).toEqual(createdViaRoute);\n		expect(updatedViaRoute.name).toBe("Updated via route");\n		expect(updatedViaRoute.version).toBe(fetchedViaRoute.version + 1);\n		expect(deletedViaRoute).toBeUndefined();\n		expect(listedViaRoute.items).toContainEqual(updatedViaRoute);\n		expect(listedAfterDeleteViaRoute.items).toEqual([]);\n` : `		expect(listedViaRoute.items).toContainEqual(createdViaRoute);\n`}
 	});
 });
 `;