@beignet/cli 0.0.3 → 0.0.5

package/src/make.ts

@@ -1,5 +1,7 @@
+import { randomBytes } from "node:crypto";
 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,27 +17,22 @@ type MakeResourceOptions = {
   force?: boolean;
   dryRun?: boolean;
   config?: BeignetConfig;
+  auth?: boolean;
+  tenant?: boolean;
+  events?: boolean;
+  softDelete?: boolean;
 };
 
-export const makeFeatureAddonChoices = [
-  "policy",
-  "event",
-  "events",
-  "job",
-  "jobs",
-  "notification",
-  "notifications",
-  "upload",
-  "uploads",
-] as const;
-
-export type MakeFeatureAddon = (typeof makeFeatureAddonChoices)[number];
+export type { MakeFeatureAddon } from "./choices.js";
+export { makeFeatureAddonChoices } from "./choices.js";
 
 type NormalizedMakeFeatureAddon =
   | "policy"
+  | "task"
   | "event"
   | "job"
   | "notification"
+  | "ui"
   | "upload";
 
 type MakeFeatureOptions = MakeResourceOptions & {
@@ -58,6 +55,14 @@ type MakeUseCaseOptions = {
   config?: BeignetConfig;
 };
 
+type MakeTaskOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
 type MakeTestOptions = {
   name: string;
   cwd?: string;
@@ -159,6 +164,7 @@ type MakeUploadOptions = {
 };
 
 type MakeResult = {
+  schemaVersion: 1;
   name: string;
   targetDir: string;
   dryRun: boolean;
@@ -184,6 +190,10 @@ 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`.
  */
@@ -243,6 +253,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;
@@ -300,6 +319,13 @@ type JobNames = FeatureArtifactNames & {
   payloadTypeName: string;
 };
 
+type TaskNames = FeatureArtifactNames & {
+  taskName: string;
+  taskExportName: string;
+  inputSchemaName: string;
+  inputTypeName: string;
+};
+
 type FactoryNames = FeatureArtifactNames & {
   factoryName: string;
   factoryExportName: string;
@@ -339,8 +365,51 @@ type UploadNames = FeatureArtifactNames & {
   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);
@@ -349,9 +418,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),
   });
@@ -362,6 +446,8 @@ export async function makeResource(
     persistence,
     {
       dryRun: true,
+      mode,
+      generationOptions,
     },
   );
   const createdFiles = plannedFiles
@@ -385,11 +471,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),
@@ -400,35 +489,20 @@ export async function makeResource(
   };
 }
 
-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(
+function resourceGenerationOptions(
   options: MakeResourceOptions,
-): Promise<MakeResourceResult> {
-  try {
-    return await makeResource(options);
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("make resource")) {
-      throw new Error(
-        error.message.replaceAll("make resource", "make feature"),
-      );
-    }
-    throw error;
+  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(
@@ -462,6 +536,9 @@ async function makeFeatureAddon(
   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` });
   }
@@ -471,6 +548,9 @@ async function makeFeatureAddon(
   if (addon === "notification") {
     return makeNotification({ ...shared, name: `${feature}/created` });
   }
+  if (addon === "ui") {
+    return makeFeatureUi({ ...shared, name: feature });
+  }
 
   return makeUpload({ ...shared, name: `${feature}/attachment` });
 }
@@ -482,6 +562,7 @@ function normalizeMakeFeatureAddons(
 
   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");
@@ -493,9 +574,11 @@ function normalizeMakeFeatureAddons(
 
 const featureAddonOrder: readonly NormalizedMakeFeatureAddon[] = [
   "policy",
+  "task",
   "event",
   "job",
   "notification",
+  "ui",
   "upload",
 ];
 
@@ -537,6 +620,7 @@ export async function makeContract(
   }
 
   return {
+    schemaVersion: 1,
     name: names.pluralKebab,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -582,6 +666,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),
@@ -627,6 +712,7 @@ export async function makeTest(
   }
 
   return {
+    schemaVersion: 1,
     name: `${names.feature.kebab}/${names.action.kebab}`,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -689,6 +775,7 @@ export async function makePort(
   }
 
   return {
+    schemaVersion: 1,
     name: names.kebab,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -734,6 +821,7 @@ export async function makeAdapter(
   }
 
   return {
+    schemaVersion: 1,
     name: names.kebab,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -771,6 +859,7 @@ export async function makePolicy(
   }
 
   return {
+    schemaVersion: 1,
     name: names.kebab,
     targetDir,
     dryRun: Boolean(options.dryRun),
@@ -821,7 +910,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,
@@ -829,6 +921,49 @@ 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> {
@@ -896,7 +1031,14 @@ export async function makeNotification(
     force: Boolean(options.force),
     dryRun: Boolean(options.dryRun),
     name: `${names.feature.kebab}/${names.artifact.kebab}`,
-    files: notificationFiles(names, config),
+    files: [
+      ...(await missingCapabilityBuilderFiles(
+        targetDir,
+        "notifications",
+        config,
+      )),
+      ...notificationFiles(names, config),
+    ],
     index: featureArtifactIndexFile("notification", names, config),
     dependencies: {
       "@beignet/core": beignetDependencyVersion,
@@ -922,7 +1064,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,
@@ -962,9 +1107,18 @@ export async function makeSchedule(
     requireServer: Boolean(options.route),
   });
 
-  const files = scheduleFiles(names, config, { route: Boolean(options.route) });
+  // Plan the CRON_SECRET wiring before writing any files so an anchor miss
+  // in lib/env.ts aborts the generator without leaving partial output.
+  const cronSecretPlan = options.route
+    ? await planCronSecretWiring(targetDir)
+    : undefined;
 
-  return makeFeatureArtifact({
+  const files = [
+    ...(await missingCapabilityBuilderFiles(targetDir, "schedules", config)),
+    ...scheduleFiles(names, config, { route: Boolean(options.route) }),
+  ];
+
+  const result = await makeFeatureArtifact({
     targetDir,
     config,
     force: Boolean(options.force),
@@ -976,6 +1130,139 @@ export async function makeSchedule(
       "@beignet/core": beignetDependencyVersion,
     },
   });
+
+  const registryResult = await updateScheduleRegistry(
+    targetDir,
+    names,
+    config,
+    { dryRun: Boolean(options.dryRun) },
+  );
+  if (registryResult === "created")
+    result.createdFiles.push(config.paths.schedules);
+  if (registryResult === "updated")
+    result.updatedFiles.push(config.paths.schedules);
+  if (registryResult === "skipped")
+    result.skippedFiles.push(config.paths.schedules);
+  if (!result.files.includes(config.paths.schedules)) {
+    result.files.push(config.paths.schedules);
+  }
+
+  if (cronSecretPlan) {
+    const applied = await applyCronSecretWiring(targetDir, cronSecretPlan, {
+      dryRun: Boolean(options.dryRun),
+    });
+    result.createdFiles.push(...applied.createdFiles);
+    result.updatedFiles.push(...applied.updatedFiles);
+    result.skippedFiles.push(...applied.skippedFiles);
+  }
+
+  return result;
+}
+
+const cronSecretEnvFile = "lib/env.ts";
+const cronSecretEnvEntry = `\t\tCRON_SECRET: z.string().min(1).optional(),`;
+// The literal APP_URL line every generated lib/env.ts ships with. CRON_SECRET
+// slots in directly below it, matching the documented env shape.
+const cronSecretEnvAnchor = `\t\tAPP_URL: z.string().url().default("http://localhost:3000"),`;
+
+type CronSecretWiringPlan = {
+  files: Array<GeneratedFile & { result: "created" | "updated" }>;
+  skippedFiles: string[];
+};
+
+async function planCronSecretWiring(
+  targetDir: string,
+): Promise<CronSecretWiringPlan> {
+  const plan: CronSecretWiringPlan = { files: [], skippedFiles: [] };
+  const manualInstruction = `Add ${cronSecretEnvEntry.trim()} to the createEnv server block in ${cronSecretEnvFile} manually, or restore the generated env file before running make schedule --route.`;
+
+  const envSource = await readOptionalFile(
+    path.join(targetDir, cronSecretEnvFile),
+  );
+  if (envSource === undefined) {
+    throw new Error(
+      `Could not find the generated env file ${cronSecretEnvFile}. ${manualInstruction}`,
+    );
+  }
+
+  if (/\bCRON_SECRET\b/.test(envSource)) {
+    plan.skippedFiles.push(cronSecretEnvFile);
+  } else if (!envSource.includes(cronSecretEnvAnchor)) {
+    throw new Error(
+      `Could not find the generated APP_URL server entry in ${cronSecretEnvFile}. ${manualInstruction}`,
+    );
+  } else {
+    plan.files.push({
+      path: cronSecretEnvFile,
+      content: envSource.replace(
+        cronSecretEnvAnchor,
+        `${cronSecretEnvAnchor}\n${cronSecretEnvEntry}`,
+      ),
+      result: "updated",
+    });
+  }
+
+  const secretLine = `CRON_SECRET=${randomBytes(16).toString("hex")}`;
+
+  const envExample = await readOptionalFile(
+    path.join(targetDir, ".env.example"),
+  );
+  if (envExample === undefined) {
+    plan.files.push({
+      path: ".env.example",
+      content: `${secretLine}\n`,
+      result: "created",
+    });
+  } else if (/^CRON_SECRET=/m.test(envExample)) {
+    plan.skippedFiles.push(".env.example");
+  } else {
+    plan.files.push({
+      path: ".env.example",
+      content: `${envExample.replace(/\n*$/, "\n")}${secretLine}\n`,
+      result: "updated",
+    });
+  }
+
+  const envLocal = await readOptionalFile(path.join(targetDir, ".env.local"));
+  if (envLocal !== undefined) {
+    if (/^CRON_SECRET=/m.test(envLocal)) {
+      plan.skippedFiles.push(".env.local");
+    } else {
+      plan.files.push({
+        path: ".env.local",
+        content: `${envLocal.replace(/\n*$/, "\n")}${secretLine}\n`,
+        result: "updated",
+      });
+    }
+  }
+
+  return plan;
+}
+
+async function applyCronSecretWiring(
+  targetDir: string,
+  plan: CronSecretWiringPlan,
+  options: { dryRun: boolean },
+): Promise<{
+  createdFiles: string[];
+  updatedFiles: string[];
+  skippedFiles: string[];
+}> {
+  if (!options.dryRun) {
+    for (const file of plan.files) {
+      await writeFile(path.join(targetDir, file.path), file.content);
+    }
+  }
+
+  return {
+    createdFiles: plan.files
+      .filter((file) => file.result === "created")
+      .map((file) => file.path),
+    updatedFiles: plan.files
+      .filter((file) => file.result === "updated")
+      .map((file) => file.path),
+    skippedFiles: plan.skippedFiles,
+  };
 }
 
 export async function makeUpload(
@@ -1003,6 +1290,70 @@ export async function makeUpload(
   });
 }
 
+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,
@@ -1131,6 +1482,7 @@ async function assertFeatureArtifactApp(
   artifact:
     | "event"
     | "job"
+    | "task"
     | "notification"
     | "listener"
     | "schedule"
@@ -1153,6 +1505,24 @@ 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,
@@ -1264,18 +1634,95 @@ async function readOptionalFile(filePath: string): Promise<string | undefined> {
   }
 }
 
-async function makeFeatureArtifact(options: {
-  targetDir: string;
-  config: ResolvedBeignetConfig;
-  force: boolean;
-  dryRun: boolean;
-  name: string;
-  files: GeneratedFile[];
-  index: FeatureArtifactIndexFile;
-  dependencies: Record<string, (packageJson: PackageJsonLike) => string>;
-}): Promise<MakeResult> {
-  const plannedFiles = await planGeneratedFiles(
-    options.targetDir,
+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;
+  force: boolean;
+  dryRun: boolean;
+  name: string;
+  files: GeneratedFile[];
+  index: FeatureArtifactIndexFile;
+  dependencies: Record<string, (packageJson: PackageJsonLike) => string>;
+}): Promise<MakeResult> {
+  const plannedFiles = await planGeneratedFiles(
+    options.targetDir,
     options.files,
     {
       force: options.force,
@@ -1315,6 +1762,7 @@ async function makeFeatureArtifact(options: {
   }
 
   return {
+    schemaVersion: 1,
     name: options.name,
     targetDir: options.targetDir,
     dryRun: options.dryRun,
@@ -1358,14 +1806,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"
@@ -1375,6 +1838,16 @@ 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, {
@@ -1384,7 +1857,12 @@ async function updateResourceWiring(
   ) {
     updated.add("package.json");
   }
-  if (await updatePortsIndex(targetDir, names, config, options)) {
+  if (
+    await updatePortsIndex(targetDir, names, config, {
+      ...options,
+      generationOptions,
+    })
+  ) {
     updated.add(config.paths.ports);
   }
   if (
@@ -1393,6 +1871,18 @@ async function updateResourceWiring(
   ) {
     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 (
     persistence === "drizzle" &&
     (await updateDrizzleSchemaIndex(targetDir, names, config, options))
@@ -1411,7 +1901,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(
@@ -1457,7 +1954,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");
@@ -1469,6 +1966,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(
@@ -1625,7 +2146,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.`,
     );
@@ -1662,6 +2183,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,
@@ -1719,6 +2271,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,
@@ -1759,7 +2329,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;
@@ -1768,15 +2338,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,
@@ -1791,6 +2360,74 @@ async function updateOpenApiRoute(
   return true;
 }
 
+async function updateSharedErrors(
+  targetDir: string,
+  names: ResourceNames,
+  config: ResolvedBeignetConfig,
+  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 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 ");
+
+  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.`,
+    );
+  }
+
+  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,
@@ -2184,6 +2821,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,
@@ -2281,7 +3010,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);
@@ -2291,6 +3033,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,
@@ -2593,6 +3379,21 @@ 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);
 }
@@ -2737,6 +3538,21 @@ 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`;
@@ -2986,10 +3802,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);
@@ -2997,27 +3824,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(
@@ -3025,15 +3888,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),
     },
   ];
 
@@ -3041,11 +3904,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),
       },
     );
   }
@@ -3053,6 +3916,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,
@@ -3151,6 +4039,18 @@ function jobFiles(
   ];
 }
 
+function taskFiles(
+  names: TaskNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: taskFilePath(names, config),
+      content: taskFile(names, config),
+    },
+  ];
+}
+
 function notificationFiles(
   names: NotificationNames,
   config: ResolvedBeignetConfig,
@@ -3283,14 +4183,38 @@ function drizzleResourceRepositoryFilePath(
   );
 }
 
-async function detectResourcePersistence(
-  targetDir: string,
-  config: ResolvedBeignetConfig,
-): Promise<ResourcePersistence> {
-  return (await fileExists(
-    path.join(targetDir, drizzleRepositoriesPath(config)),
-  ))
-    ? "drizzle"
+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,
+): Promise<ResourcePersistence> {
+  return (await fileExists(
+    path.join(targetDir, drizzleRepositoriesPath(config)),
+  ))
+    ? "drizzle"
     : "memory";
 }
 
@@ -3301,6 +4225,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) ===
@@ -3365,6 +4319,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,
@@ -3430,6 +4391,7 @@ function featureArtifactDir(
   kind:
     | "events"
     | "factories"
+    | "tasks"
     | "jobs"
     | "notifications"
     | "listeners"
@@ -3467,6 +4429,13 @@ function jobFilePath(names: JobNames, 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,
@@ -3585,11 +4554,36 @@ 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"
@@ -3606,6 +4600,7 @@ function featureArtifactIndexFile(
   kind:
     | "event"
     | "job"
+    | "task"
     | "factory"
     | "seed"
     | "notification"
@@ -3615,6 +4610,7 @@ function featureArtifactIndexFile(
   names:
     | EventNames
     | JobNames
+    | TaskNames
     | FactoryNames
     | SeedNames
     | NotificationNames
@@ -3628,49 +4624,55 @@ function featureArtifactIndexFile(
       ? eventFilePath(names as EventNames, config)
       : kind === "job"
         ? jobFilePath(names as JobNames, 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);
+        : 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 === "factory"
-          ? "Factories"
-          : kind === "seed"
-            ? "Seeds"
-            : kind === "notification"
-              ? "Notifications"
-              : kind === "listener"
-                ? "Listeners"
-                : kind === "schedule"
-                  ? "Schedules"
-                  : "Uploads";
+        : 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 === "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;
+        : 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"),
@@ -3786,6 +4788,150 @@ export const ${file.registryName} = [${file.importName}] as const;
   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 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,
+    )}`;
+  }
+
+  if (next === existing) return "skipped";
+  if (!options.dryRun) await writeFile(destination, next);
+  return "updated";
+}
+
+async function updateScheduleRegistry(
+  targetDir: string,
+  names: ScheduleNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<WriteGeneratedFileResult> {
+  const destination = path.join(targetDir, config.paths.schedules);
+  const existing = await readOptionalFile(destination);
+  const featureSchedulesPath = path.join(
+    featureArtifactDir(names, "schedules", config),
+    "index.ts",
+  );
+  const registryName = `${names.featureSingularCamel}Schedules`;
+  const importLine = `import { ${registryName} } from "${aliasModule(featureSchedulesPath)}";`;
+  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.schedules,
+    config.paths.server,
+  )}";`;
+  const registryEntry = `...${registryName}`;
+
+  if (existing === undefined) {
+    const content = `${serviceActorImport}
+${appContextImport}
+${importLine}
+${serverImport}
+
+export const schedules = [${registryEntry}] as const;
+
+export async function createScheduleContext(): Promise<AppContext> {
+\treturn server.createServiceContext({
+\t\tactor: createServiceActor("beignet-schedule"),
+\t});
+}
+
+export async function stopScheduleContext(): 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(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  const registry = arrayInitializerInfo(next, "schedules");
+  if (!registry) {
+    next = `${next.trimEnd()}\n\nexport const schedules = [${registryEntry}] 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,
+    )}`;
+  }
+
+  if (next === existing) return "skipped";
+  if (!options.dryRun) await writeFile(destination, next);
+  return "updated";
+}
+
 function arrayInitializerInfo(
   source: string,
   constName: string,
@@ -3828,27 +4974,110 @@ function defineUploadsInitializerInfo(
   };
 }
 
-function schemasFile(names: ResourceNames): string {
+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({
 	items: z.array(${names.singularPascal}Schema),
 	page: z.object({
-		kind: z.literal("offset"),
+		kind: z.literal("cursor"),
 		limit: z.number().int().min(1),
-		offset: z.number().int().min(0),
-		total: z.number().int().min(0),
+		cursor: z.string().nullable(),
+		nextCursor: z.string().nullable(),
 		hasMore: z.boolean(),
 	}),
 });
@@ -3856,11 +5085,42 @@ export const List${names.pluralPascal}OutputSchema = z.object({
 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
 >;
@@ -3870,30 +5130,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 { normalizeOffsetPage } from "@beignet/core/pagination";
+  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 page = normalizeOffsetPage(input, {
+${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);
+		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` : ""}		});
 	});
 `;
 }
@@ -3901,134 +5170,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 {
-	OffsetPage,
-	OffsetPageInfo,
+	CursorPage,
+	CursorPageInfo,
 	PageResult,
+	SortDirection,
 } from "@beignet/core/pagination";
 import type {
 	Create${names.singularPascal}Input,
-	${names.singularPascal},
-} from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
-
-export type List${names.pluralPascal}Result = PageResult<${names.singularPascal}, OffsetPageInfo>;
+	${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(page: OffsetPage): 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 { offsetPageResult } from "@beignet/core/pagination";
+`
+    : "";
+  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,
-	${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(page) {
-			const all${names.pluralPascal} = Array.from(${names.pluralCamel}.values()).sort(
-				(left, right) => right.createdAt.localeCompare(left.createdAt),
-			);
-
-			return offsetPageResult(
-				all${names.pluralPascal}.slice(page.offset, page.offset + page.limit),
-				page,
-				all${names.pluralPascal}.length,
+		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,
 			);
 		},
-		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 { offsetPageResult } from "@beignet/core/pagination";
+  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 { count, desc } from "drizzle-orm";
+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,
-	${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;
@@ -4036,35 +5601,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(page) {
+		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(page.limit)
-				.offset(page.offset);
-			const [{ total }] = await db
-				.select({ total: count() })
-				.from(schema.${names.pluralCamel});
-
-			return offsetPageResult(rows.map(to${names.singularPascal}), page, 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();
 
@@ -4074,6 +5708,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` : ""}
 	};
 }
 `;
@@ -4082,13 +5717,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(),
@@ -4096,7 +5735,7 @@ const ErrorResponseSchema = z.object({
 	requestId: z.string().optional(),
 });
 
-const ${names.pluralCamel} = createContractGroup()
+const ${names.pluralCamel} = defineContractGroup()
 	.namespace("${names.pluralCamel}")
 	.responses({
 		500: ErrorResponseSchema,
@@ -4104,22 +5743,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({
-		201: create${names.singularPascal}UseCase.outputSchema,
+		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({
+		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({
@@ -4128,7 +5797,7 @@ const ErrorResponseSchema = z.object({
 	requestId: z.string().optional(),
 });
 
-const ${names.pluralCamel} = createContractGroup()
+const ${names.pluralCamel} = defineContractGroup()
 	.namespace("${names.pluralCamel}")
 	.responses({
 		500: ErrorResponseSchema,
@@ -4169,7 +5838,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({});
@@ -4202,29 +5872,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 unknown 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}, {});
 
@@ -4290,6 +5958,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";
@@ -4307,11 +6113,9 @@ export const ${names.eventExportName} = defineEvent("${names.eventName}", {
 }
 
 function jobFile(names: JobNames, config: ResolvedBeignetConfig): string {
-  return `import { createJobHandlers, retry } 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(),
@@ -4319,7 +6123,7 @@ 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: retry.exponential({
 \t\tattempts: 3,
@@ -4336,16 +6140,43 @@ 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 { defineFactory } from "@beignet/core/testing";
+  return `import { createFactory } from "@beignet/core/testing";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
 
-export const ${names.factoryExportName} = defineFactory("${names.factoryName}", {
+export const ${names.factoryExportName} = createFactory("${names.factoryName}", {
 \tdefaults: ({ sequence }) => ({
 \t\tname: "${resource.singularPascal} " + sequence,
 \t}),
@@ -4375,14 +6206,9 @@ function notificationFile(
   names: NotificationNames,
   config: ResolvedBeignetConfig,
 ): string {
-  return `import {
-\tcreateNotificationHandlers,
-\tdefineMailNotificationChannel,
-} from "@beignet/core/notifications";
+  return `import { defineMailNotificationChannel } from "@beignet/core/notifications";
 import { z } from "zod";
-import type { AppContext } from "${aliasModule(config.paths.appContext)}";
-
-const notifications = createNotificationHandlers<AppContext>();
+import { defineNotification } from "${aliasModule(config.paths.notificationsBuilder)}";
 
 export const ${names.payloadSchemaName} = z.object({
 \tid: z.string().uuid(),
@@ -4392,7 +6218,7 @@ export const ${names.payloadSchemaName} = z.object({
 
 export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
 
-export const ${names.notificationExportName} = notifications.defineNotification(
+export const ${names.notificationExportName} = defineNotification(
 \t"${names.notificationName}",
 \t{
 \t\tpayload: ${names.payloadSchemaName},
@@ -4414,13 +6240,10 @@ function listenerFile(
 ): 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", {
@@ -4436,11 +6259,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(),
@@ -4448,7 +6268,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}",
@@ -4526,111 +6346,119 @@ export const ${names.uploadExportName} = defineUpload<
 `;
 }
 
+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",
+});
 `;
 }
 
@@ -4648,84 +6476,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";
-import { defineRoutes } from "@beignet/web";
-import { createTestApp } from "@beignet/web/testing";
+${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 { create${names.singularPascal}, list${names.pluralPascal} } from "${aliasModule(resourceContractFilePath(names, config))}";
+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 unknown as AppContext["ports"]["uow"],
-			devtools: createInMemoryDevtools(),
-			storage: createMemoryStorage(),
-		} as AppContext["ports"];
-		const actor = createAnonymousActor();
-		const createTestContext = () => ({
-			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}" },
@@ -4733,35 +6638,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.page.total).toBe(1);
 		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 },
+		);
 
-		const app = await createTestApp<AppContext, AppContext["ports"]>({
-			ports: testPorts,
+		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]),
-			createContext: async () => createTestContext(),
-			mapUnhandledError: () => ({
-				status: 500,
-				body: { code: "INTERNAL_SERVER_ERROR", message: "Internal server error" },
-			}),
+			context: appContext,
 		});
-
-		const createdViaRoute = await app.request(create${names.singularPascal}, {
+${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}" },
 		});
-		const listedViaRoute = await app.request(list${names.pluralPascal}, {
-			query: { limit: 20, offset: 0 },
+${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"}" },
 		});
-		await app.stop();
+${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}");
-		expect(listedViaRoute.page.total).toBe(2);
-		expect(listedViaRoute.items).toContainEqual(createdViaRoute);
+${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`}
 	});
 });
 `;