@beignet/cli 0.0.1 → 0.0.4

package/dist/make.js

@@ -1,20 +1,53 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
+export { makeFeatureAddonChoices } from "./choices.js";
 export async function makeResource(options) {
+    return makeResourceSlice(options, "resource");
+}
+export async function makeFeature(options) {
+    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) {
+    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, mode) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     const names = resourceNames(options.name);
     const config = options.config
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
     await assertStandardApp(targetDir, config);
+    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),
     });
     const plannedWiringUpdates = await updateResourceWiring(targetDir, names, config, persistence, {
         dryRun: true,
+        mode,
+        generationOptions,
     });
     const createdFiles = plannedFiles
         .filter((file) => file.result === "created")
@@ -35,9 +68,12 @@ export async function makeResource(options) {
         updatedFiles.push(...(await updateResourceWiring(targetDir, names, config, {
             persistence,
             dryRun: false,
+            mode,
+            generationOptions,
         })));
     }
     return {
+        schemaVersion: 1,
         name: names.pluralKebab,
         targetDir,
         dryRun: Boolean(options.dryRun),
@@ -47,6 +83,90 @@ export async function makeResource(options) {
         skippedFiles,
     };
 }
+function resourceGenerationOptions(options, mode) {
+    if (mode !== "resource") {
+        return { auth: false, tenant: false, events: false, softDelete: false };
+    }
+    return {
+        auth: Boolean(options.auth),
+        tenant: Boolean(options.tenant),
+        events: Boolean(options.events),
+        softDelete: Boolean(options.softDelete),
+    };
+}
+async function makeFeatureSlice(options, addons) {
+    let result = await makeFeatureResource(options);
+    for (const addon of addons) {
+        result = mergeMakeResults(result, await makeFeatureAddon(addon, result.name, options));
+    }
+    return result;
+}
+async function makeFeatureAddon(addon, feature, options) {
+    const shared = {
+        cwd: options.cwd,
+        force: options.force,
+        dryRun: options.dryRun,
+        config: options.config,
+    };
+    if (addon === "policy") {
+        return makePolicy({ ...shared, name: feature });
+    }
+    if (addon === "task") {
+        return makeTask({ ...shared, name: `${feature}/backfill` });
+    }
+    if (addon === "event") {
+        return makeEvent({ ...shared, name: `${feature}/created` });
+    }
+    if (addon === "job") {
+        return makeJob({ ...shared, name: `${feature}/process` });
+    }
+    if (addon === "notification") {
+        return makeNotification({ ...shared, name: `${feature}/created` });
+    }
+    if (addon === "ui") {
+        return makeFeatureUi({ ...shared, name: feature });
+    }
+    return makeUpload({ ...shared, name: `${feature}/attachment` });
+}
+function normalizeMakeFeatureAddons(addons) {
+    const normalized = new Set();
+    for (const addon of addons) {
+        if (addon === "events")
+            normalized.add("event");
+        else if (addon === "tasks")
+            normalized.add("task");
+        else if (addon === "jobs")
+            normalized.add("job");
+        else if (addon === "notifications")
+            normalized.add("notification");
+        else if (addon === "uploads")
+            normalized.add("upload");
+        else
+            normalized.add(addon);
+    }
+    return featureAddonOrder.filter((addon) => normalized.has(addon));
+}
+const featureAddonOrder = [
+    "policy",
+    "task",
+    "event",
+    "job",
+    "notification",
+    "ui",
+    "upload",
+];
+function mergeMakeResults(left, right) {
+    return {
+        ...left,
+        files: uniqueStrings([...left.files, ...right.files]),
+        createdFiles: uniqueStrings([...left.createdFiles, ...right.createdFiles]),
+        updatedFiles: uniqueStrings([...left.updatedFiles, ...right.updatedFiles]),
+        skippedFiles: uniqueStrings([...left.skippedFiles, ...right.skippedFiles]),
+    };
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
 export async function makeContract(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     const names = resourceNames(options.name);
@@ -70,6 +190,7 @@ export async function makeContract(options) {
             skippedFiles.push(file.path);
     }
     return {
+        schemaVersion: 1,
         name: names.pluralKebab,
         targetDir,
         dryRun: Boolean(options.dryRun),
@@ -113,6 +234,7 @@ export async function makeUseCase(options) {
     if (indexResult === "skipped")
         skippedFiles.push(indexFile.path);
     return {
+        schemaVersion: 1,
         name: `${names.feature.kebab}/${names.action.kebab}`,
         targetDir,
         dryRun: Boolean(options.dryRun),
@@ -145,10 +267,13 @@ export async function makeTest(options) {
         if (result === "skipped")
             skippedFiles.push(file.path);
     }
-    if (await updatePackageJson(targetDir, { dryRun: Boolean(options.dryRun) })) {
+    if (await updatePackageJson(targetDir, {
+        dryRun: Boolean(options.dryRun),
+    })) {
         updatedFiles.push("package.json");
     }
     return {
+        schemaVersion: 1,
         name: `${names.feature.kebab}/${names.action.kebab}`,
         targetDir,
         dryRun: Boolean(options.dryRun),
@@ -200,6 +325,7 @@ export async function makePort(options) {
         updatedFiles.push(config.paths.infrastructurePorts);
     }
     return {
+        schemaVersion: 1,
         name: names.kebab,
         targetDir,
         dryRun: Boolean(options.dryRun),
@@ -238,6 +364,7 @@ export async function makeAdapter(options) {
         updatedFiles.push(config.paths.infrastructurePorts);
     }
     return {
+        schemaVersion: 1,
         name: names.kebab,
         targetDir,
         dryRun: Boolean(options.dryRun),
@@ -271,6 +398,7 @@ export async function makePolicy(options) {
             skippedFiles.push(file.path);
     }
     return {
+        schemaVersion: 1,
         name: names.kebab,
         targetDir,
         dryRun: Boolean(options.dryRun),
@@ -313,13 +441,115 @@ export async function makeJob(options) {
         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,
         },
     });
 }
+export async function makeTask(options) {
+    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) {
+    const targetDir = path.resolve(options.cwd ?? process.cwd());
+    const names = factoryNames(options.name);
+    const config = options.config
+        ? resolveConfig(options.config)
+        : await loadBeignetConfig(targetDir);
+    await assertPersistenceArtifactApp(targetDir, names, config, "factory");
+    return makeFeatureArtifact({
+        targetDir,
+        config,
+        force: Boolean(options.force),
+        dryRun: Boolean(options.dryRun),
+        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        files: factoryFiles(names, config),
+        index: featureArtifactIndexFile("factory", names, config),
+        dependencies: {
+            "@beignet/core": beignetDependencyVersion,
+        },
+    });
+}
+export async function makeSeed(options) {
+    const targetDir = path.resolve(options.cwd ?? process.cwd());
+    const names = seedNames(options.name);
+    const config = options.config
+        ? resolveConfig(options.config)
+        : await loadBeignetConfig(targetDir);
+    await assertPersistenceArtifactApp(targetDir, names, config, "seed");
+    return makeFeatureArtifact({
+        targetDir,
+        config,
+        force: Boolean(options.force),
+        dryRun: Boolean(options.dryRun),
+        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        files: seedFiles(names, config),
+        index: featureArtifactIndexFile("seed", names, config),
+        dependencies: {
+            "@beignet/core": beignetDependencyVersion,
+        },
+    });
+}
+export async function makeNotification(options) {
+    const targetDir = path.resolve(options.cwd ?? process.cwd());
+    const names = notificationNames(options.name);
+    const config = options.config
+        ? resolveConfig(options.config)
+        : await loadBeignetConfig(targetDir);
+    await assertFeatureArtifactApp(targetDir, config, "notification");
+    return makeFeatureArtifact({
+        targetDir,
+        config,
+        force: Boolean(options.force),
+        dryRun: Boolean(options.dryRun),
+        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        files: [
+            ...(await missingCapabilityBuilderFiles(targetDir, "notifications", config)),
+            ...notificationFiles(names, config),
+        ],
+        index: featureArtifactIndexFile("notification", names, config),
+        dependencies: {
+            "@beignet/core": beignetDependencyVersion,
+        },
+    });
+}
 export async function makeListener(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     const names = listenerNames(options.name, options.event);
@@ -334,7 +564,10 @@ export async function makeListener(options) {
         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,
@@ -362,7 +595,10 @@ export async function makeSchedule(options) {
     await assertFeatureArtifactApp(targetDir, config, "schedule", {
         requireServer: Boolean(options.route),
     });
-    const files = scheduleFiles(names, config, { route: Boolean(options.route) });
+    const files = [
+        ...(await missingCapabilityBuilderFiles(targetDir, "schedules", config)),
+        ...scheduleFiles(names, config, { route: Boolean(options.route) }),
+    ];
     return makeFeatureArtifact({
         targetDir,
         config,
@@ -376,6 +612,78 @@ export async function makeSchedule(options) {
         },
     });
 }
+export async function makeUpload(options) {
+    const targetDir = path.resolve(options.cwd ?? process.cwd());
+    const names = uploadNames(options.name);
+    const config = options.config
+        ? resolveConfig(options.config)
+        : await loadBeignetConfig(targetDir);
+    await assertFeatureArtifactApp(targetDir, config, "upload");
+    return makeFeatureArtifact({
+        targetDir,
+        config,
+        force: Boolean(options.force),
+        dryRun: Boolean(options.dryRun),
+        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        files: uploadFiles(names, config),
+        index: featureArtifactIndexFile("upload", names, config),
+        dependencies: {
+            "@beignet/core": beignetDependencyVersion,
+        },
+    });
+}
+async function makeFeatureUi(options) {
+    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, config) {
     const requiredFiles = [
         config.paths.appContext,
@@ -468,6 +776,33 @@ async function assertFeatureArtifactApp(targetDir, config, artifact, options = {
         }
     }
 }
+async function assertFeatureUiApp(targetDir, config) {
+    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, names, config, artifact) {
+    const requiredFiles = [
+        config.paths.appContext,
+        config.paths.ports,
+        resourcePortFilePath(featureResourceNames(names), config),
+    ];
+    for (const file of requiredFiles) {
+        try {
+            await stat(path.join(targetDir, file));
+        }
+        catch {
+            throw new Error(`beignet make ${artifact} expects a feature with a repository port. Missing ${file}. Run beignet make feature ${names.feature.kebab} first, or add the repository port before generating ${artifact}s.`);
+        }
+    }
+}
 async function writeGeneratedFile(targetDir, file, options) {
     const plannedFile = await planGeneratedFile(targetDir, file, {
         force: options.force,
@@ -519,6 +854,62 @@ async function readOptionalFile(filePath) {
         return undefined;
     }
 }
+const capabilityBuilders = {
+    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, config) {
+    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, config) {
+    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, capability, config) {
+    const file = capabilityBuilderFile(capability, config);
+    if (await fileExists(path.join(targetDir, file.path))) {
+        return [];
+    }
+    return [file];
+}
 async function makeFeatureArtifact(options) {
     const plannedFiles = await planGeneratedFiles(options.targetDir, options.files, {
         force: options.force,
@@ -550,6 +941,7 @@ async function makeFeatureArtifact(options) {
         updatedFiles.push("package.json");
     }
     return {
+        schemaVersion: 1,
         name: options.name,
         targetDir: options.targetDir,
         dryRun: options.dryRun,
@@ -579,6 +971,9 @@ function beignetDependencyVersion(packageJson) {
         packageJson.dependencies?.["@beignet/next"] ??
         "*");
 }
+function tanstackReactQueryDependencyVersion(packageJson) {
+    return packageJson.dependencies?.["@tanstack/react-query"] ?? "^5.100.7";
+}
 async function updateResourceWiring(targetDir, names, config, persistenceOrOptions, maybeOptions) {
     const persistence = typeof persistenceOrOptions === "string"
         ? persistenceOrOptions
@@ -586,13 +981,37 @@ async function updateResourceWiring(targetDir, names, config, persistenceOrOptio
     const options = typeof persistenceOrOptions === "string"
         ? maybeOptions
         : 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();
-    if (await updatePackageJson(targetDir, options))
+    if (await updatePackageJson(targetDir, {
+        ...options,
+        webTestingDependency: true,
+    })) {
         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 (await updateInfrastructurePorts(targetDir, names, config, options)) {
+    if (persistence === "memory" &&
+        (await updateInfrastructurePorts(targetDir, names, config, options))) {
+        updated.add(config.paths.infrastructurePorts);
+    }
+    if (generationOptions.auth &&
+        (await updateInfrastructureGatePolicies(targetDir, names, config, options))) {
+        updated.add(config.paths.infrastructurePorts);
+    }
+    if (persistence === "drizzle" &&
+        (await updateInfrastructureDeferredPorts(targetDir, names, config, options))) {
         updated.add(config.paths.infrastructurePorts);
     }
     if (persistence === "drizzle" &&
@@ -607,7 +1026,10 @@ async function updateResourceWiring(targetDir, names, config, persistenceOrOptio
         (await updateServerTransactionPorts(targetDir, names, config, options))) {
         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(targetDir, names, config, options);
@@ -620,9 +1042,14 @@ async function updatePackageJson(targetDir, options) {
     const original = await readFile(filePath, "utf8");
     const packageJson = JSON.parse(original);
     packageJson.scripts = packageJson.scripts ?? {};
-    if (packageJson.scripts.test)
-        return false;
-    packageJson.scripts.test = "bun test";
+    packageJson.scripts.test ??= "bun test";
+    if (options.webTestingDependency) {
+        packageJson.devDependencies = packageJson.devDependencies ?? {};
+        packageJson.devDependencies["@beignet/web"] ??=
+            packageJson.dependencies?.["@beignet/core"] ??
+                packageJson.dependencies?.["@beignet/next"] ??
+                "*";
+    }
     const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
     if (!options.dryRun)
         await writeFile(filePath, next);
@@ -637,6 +1064,16 @@ async function updatePortsIndex(targetDir, names, config, options) {
     if (!next.includes(importLine)) {
         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(next, "AppPorts", entry.trim(), `Could not find AppPorts in ${config.paths.ports}. Add ${entry.trim()} manually, or restore the generated ports file before running make resource.`);
@@ -731,7 +1168,7 @@ async function updateInfrastructurePorts(targetDir, names, config, options) {
     }
     const repositoryConst = `const ${names.pluralCamel} = createInMemory${names.singularPascal}Repository();`;
     if (!next.includes(repositoryConst)) {
-        next = replaceRequired(next, /(\nexport const appPorts = definePorts(?:<[^>]+>)?\(\{)/, `\n${repositoryConst}\n$1`, `Could not find definePorts({ in ${config.paths.infrastructurePorts}. Add ${repositoryConst} manually, or restore the generated infrastructure ports file before running make resource.`);
+        next = replaceRequired(next, /(\nexport const appPorts = definePorts(?:<[^>]+>)?\((?:\)\()?\{)/, `\n${repositoryConst}\n$1`, `Could not find definePorts({ in ${config.paths.infrastructurePorts}. Add ${repositoryConst} manually, or restore the generated infrastructure ports file before running make resource.`);
     }
     const entry = `\t${names.pluralCamel},`;
     const definePortsBody = definePortsBodySource(next);
@@ -751,6 +1188,22 @@ async function updateInfrastructurePorts(targetDir, names, config, options) {
         await writeFile(filePath, next);
     return true;
 }
+async function updateInfrastructureGatePolicies(targetDir, names, config, options) {
+    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, names, config, options) {
     const filePath = path.join(targetDir, drizzleSchemaIndexPath(config));
     if (!(await fileExists(filePath)))
@@ -789,6 +1242,19 @@ async function updateDrizzleRepositories(targetDir, names, config, options) {
         await writeFile(filePath, next);
     return true;
 }
+async function updateInfrastructureDeferredPorts(targetDir, names, config, options) {
+    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, names, config, options) {
     const filePath = path.join(targetDir, config.paths.server);
     const original = await readFile(filePath, "utf8");
@@ -817,13 +1283,12 @@ async function updateOpenApiRoute(targetDir, names, config, options) {
     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((contractName) => !listedContracts.has(contractName));
+    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)}`;
     if (!next.includes(importLine)) {
@@ -835,6 +1300,53 @@ async function updateOpenApiRoute(targetDir, names, config, options) {
         await writeFile(filePath, next);
     return true;
 }
+async function updateSharedErrors(targetDir, names, config, options) {
+    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, names, config, options) {
     const filePath = path.join(targetDir, config.paths.server);
     const original = await readFile(filePath, "utf8");
@@ -1096,6 +1608,67 @@ function typeBodySource(source, typeName) {
         return undefined;
     return source.slice(openBrace + 1, closeBrace);
 }
+function appendUnionTypeMember(source, typeName, member) {
+    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, typeName, member) {
+    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, member) {
+    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, policy, failureMessage) {
+    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, property, message) {
     const body = definePortsBodyRange(source);
     if (!body)
@@ -1145,7 +1718,15 @@ function definePortsBodySource(source) {
     return source.slice(body.openBrace + 1, body.closeBrace);
 }
 function definePortsBodyRange(source) {
-    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) {
+    const match = /definePorts(?:<[^>]+>)?\(\s*(?:\)\s*\(\s*)?\{/.exec(source);
     if (!match)
         return undefined;
     const openBrace = source.indexOf("{", match.index);
@@ -1154,6 +1735,39 @@ function definePortsBodyRange(source) {
         return undefined;
     return { openBrace, closeBrace };
 }
+function appendDeferredPortKey(source, portKey) {
+    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, openBrace, closeBrace) {
+    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, propertyName) {
     let depth = 0;
     let inString;
@@ -1383,6 +1997,21 @@ function resourceNames(input) {
     ]);
     return names;
 }
+function featureUiNames(input) {
+    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) {
+    return resourceNames(names.feature.kebab);
+}
 function useCaseNames(input) {
     const parts = input
         .trim()
@@ -1497,14 +2126,60 @@ function jobNames(input) {
         payloadTypeName: `${jobExportName}Payload`,
     };
 }
-function listenerNames(input, eventInput) {
-    const names = featureArtifactNames(input, "Listener");
-    const listenerExportName = names.artifact.camel;
-    assertGeneratedIdentifiers(input, "Listener name", [listenerExportName]);
+function taskNames(input) {
+    const names = featureArtifactNames(input, "Task");
+    const taskExportName = `${names.artifact.camel}Task`;
+    assertGeneratedIdentifiers(input, "Task name", [taskExportName]);
     return {
         ...names,
-        listenerName: names.stableName,
-        listenerExportName,
+        taskName: names.stableName,
+        taskExportName,
+        inputSchemaName: `${names.artifact.pascal}TaskInputSchema`,
+        inputTypeName: `${names.artifact.pascal}TaskInput`,
+    };
+}
+function factoryNames(input) {
+    const names = featureArtifactNames(input, "Factory");
+    const factoryExportName = `${names.artifact.camel}Factory`;
+    assertGeneratedIdentifiers(input, "Factory name", [factoryExportName]);
+    return {
+        ...names,
+        factoryName: names.stableName,
+        factoryExportName,
+    };
+}
+function seedNames(input) {
+    const names = featureArtifactNames(input, "Seed");
+    const seedExportName = `${names.artifact.camel}Seed`;
+    assertGeneratedIdentifiers(input, "Seed name", [seedExportName]);
+    return {
+        ...names,
+        seedName: names.stableName,
+        seedExportName,
+    };
+}
+function notificationNames(input) {
+    const names = featureArtifactNames(input, "Notification");
+    const notificationExportName = `${names.featureSingularPascal}${names.artifact.pascal}Notification`;
+    assertGeneratedIdentifiers(input, "Notification name", [
+        notificationExportName,
+    ]);
+    return {
+        ...names,
+        notificationName: names.stableName,
+        notificationExportName,
+        payloadSchemaName: `${notificationExportName}PayloadSchema`,
+        payloadTypeName: `${notificationExportName}Payload`,
+    };
+}
+function listenerNames(input, eventInput) {
+    const names = featureArtifactNames(input, "Listener");
+    const listenerExportName = names.artifact.camel;
+    assertGeneratedIdentifiers(input, "Listener name", [listenerExportName]);
+    return {
+        ...names,
+        listenerName: names.stableName,
+        listenerExportName,
         event: eventNames(eventInput),
     };
 }
@@ -1522,6 +2197,18 @@ function scheduleNames(input, options) {
         timezone: options.timezone?.trim() || undefined,
     };
 }
+function uploadNames(input) {
+    const names = featureArtifactNames(input, "Upload");
+    const uploadExportName = `${names.artifact.pascal}Upload`;
+    assertGeneratedIdentifiers(input, "Upload name", [uploadExportName]);
+    return {
+        ...names,
+        uploadName: names.stableName,
+        uploadExportName,
+        metadataSchemaName: `${uploadExportName}MetadataSchema`,
+        metadataTypeName: `${uploadExportName}Metadata`,
+    };
+}
 function normalizeEventReference(input) {
     const trimmed = input.trim();
     if (trimmed.includes("/"))
@@ -1649,59 +2336,119 @@ function pascalCase(value) {
     const camel = camelCase(value);
     return `${camel.charAt(0).toUpperCase()}${camel.slice(1)}`;
 }
-function resourceFiles(names, config, persistence = "memory") {
+function constantCase(value) {
+    return value.replaceAll("-", "_").toUpperCase();
+}
+function resourceFiles(names, config, persistence = "memory", mode = "feature", options = {
+    auth: false,
+    tenant: false,
+    events: false,
+    softDelete: false,
+}) {
     const useCaseDir = resourceUseCaseDir(names, config);
     const infraDir = infrastructureDir(config);
     const featureDir = resourceFeatureDir(names, config);
     const files = [
         {
             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(infraDir, 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),
         },
     ];
     if (persistence === "drizzle") {
         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),
         });
     }
     return files;
 }
+function featureUiComponentFiles(names, config) {
+    const componentPath = featureUiComponentFilePath(names, config);
+    return [
+        {
+            path: componentPath,
+            content: featureUiComponentFile(names, config),
+        },
+    ];
+}
+function featureUiIndexFile(names, config) {
+    return {
+        path: featureUiIndexFilePath(names, config),
+        content: `export { ${names.componentExportName} } from "./${names.componentFileName}";
+`,
+    };
+}
 function contractFiles(names, config) {
     return [
         {
@@ -1767,6 +2514,38 @@ function jobFiles(names, config) {
         },
     ];
 }
+function taskFiles(names, config) {
+    return [
+        {
+            path: taskFilePath(names, config),
+            content: taskFile(names, config),
+        },
+    ];
+}
+function notificationFiles(names, config) {
+    return [
+        {
+            path: notificationFilePath(names, config),
+            content: notificationFile(names, config),
+        },
+    ];
+}
+function factoryFiles(names, config) {
+    return [
+        {
+            path: factoryFilePath(names, config),
+            content: factoryFile(names, config),
+        },
+    ];
+}
+function seedFiles(names, config) {
+    return [
+        {
+            path: seedFilePath(names, config),
+            content: seedFile(names, config),
+        },
+    ];
+}
 function listenerFiles(names, config) {
     return [
         {
@@ -1790,6 +2569,14 @@ function scheduleFiles(names, config, options) {
     }
     return files;
 }
+function uploadFiles(names, config) {
+    return [
+        {
+            path: uploadFilePath(names, config),
+            content: uploadFile(names, config),
+        },
+    ];
+}
 function portFilePath(names, config) {
     return path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
 }
@@ -1811,6 +2598,19 @@ function drizzleResourceSchemaFilePath(names, config) {
 function drizzleResourceRepositoryFilePath(names, config) {
     return path.join(infrastructureDir(config), names.pluralKebab, `drizzle-${names.singularKebab}-repository.ts`);
 }
+function resourceSharedErrorsPath(config) {
+    return path.join(config.paths.features, "shared", "errors.ts");
+}
+function resourceContractNames(names, mode) {
+    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, config) {
     return (await fileExists(path.join(targetDir, drizzleRepositoriesPath(config))))
         ? "drizzle"
@@ -1819,6 +2619,19 @@ async function detectResourcePersistence(targetDir, config) {
 function resourceFeatureDir(names, config) {
     return path.join(config.paths.features, names.pluralKebab);
 }
+function featureUiDir(names, config) {
+    return path.join(resourceFeatureDir(names, config), "components");
+}
+function featureUiComponentFilePath(names, config) {
+    return path.join(featureUiDir(names, config), `${names.componentFileName}.tsx`);
+}
+function featureUiIndexFilePath(names, config) {
+    return path.join(featureUiDir(names, config), "index.ts");
+}
+function clientIndexPath(config) {
+    const appRoot = path.posix.dirname(config.paths.appContext);
+    return path.join(appRoot === "." ? "" : appRoot, "client/index.ts");
+}
 function usesFeatureOwnedContracts(config) {
     return (directoryPath(config.paths.contracts) ===
         directoryPath(config.paths.features));
@@ -1853,6 +2666,9 @@ function resourceUseCaseDir(names, config) {
 function resourceUseCaseIndexPath(names, config) {
     return path.join(resourceUseCaseDir(names, config), "index.ts");
 }
+function resourceSchemaFilePath(names, config) {
+    return path.join(resourceFeatureDir(names, config), "schemas.ts");
+}
 function resourcePortFilePath(names, config) {
     if (usesFeatureOwnedContracts(config)) {
         return path.join(resourceFeatureDir(names, config), "ports.ts");
@@ -1882,6 +2698,9 @@ function featureArtifactDir(names, kind, config) {
     if (kind === "events") {
         return path.join(featureDir, "domain", "events");
     }
+    if (kind === "factories") {
+        return path.join(featureDir, "tests", "factories");
+    }
     return path.join(featureDir, kind);
 }
 function eventFilePath(names, config) {
@@ -1890,12 +2709,27 @@ function eventFilePath(names, config) {
 function jobFilePath(names, config) {
     return path.join(featureArtifactDir(names, "jobs", config), `${names.artifact.kebab}.ts`);
 }
+function taskFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "tasks", config), `${names.artifact.kebab}.ts`);
+}
+function factoryFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "factories", config), `${names.artifact.kebab}.ts`);
+}
+function seedFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "seeds", config), `${names.artifact.kebab}.ts`);
+}
+function notificationFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "notifications", config), `${names.artifact.kebab}.ts`);
+}
 function listenerFilePath(names, config) {
     return path.join(featureArtifactDir(names, "listeners", config), `${names.artifact.kebab}.ts`);
 }
 function scheduleFilePath(names, config) {
     return path.join(featureArtifactDir(names, "schedules", config), `${names.artifact.kebab}.ts`);
 }
+function uploadFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "uploads", config), `${names.artifact.kebab}.ts`);
+}
 function scheduleRouteFilePath(names, config) {
     return path.join(config.paths.routes, "cron", names.feature.kebab, names.artifact.kebab, "route.ts");
 }
@@ -1927,33 +2761,83 @@ async function updateUseCaseIndex(targetDir, file, options) {
         await writeFile(destination, next);
     return "updated";
 }
+async function updateFeatureUiIndex(targetDir, file, options) {
+    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";
+}
 function featureArtifactIndexFile(kind, names, config) {
     const artifactPath = kind === "event"
         ? eventFilePath(names, config)
         : kind === "job"
             ? jobFilePath(names, config)
-            : kind === "listener"
-                ? listenerFilePath(names, config)
-                : scheduleFilePath(names, config);
+            : kind === "task"
+                ? taskFilePath(names, config)
+                : kind === "factory"
+                    ? factoryFilePath(names, config)
+                    : kind === "seed"
+                        ? seedFilePath(names, config)
+                        : kind === "notification"
+                            ? notificationFilePath(names, config)
+                            : kind === "listener"
+                                ? listenerFilePath(names, config)
+                                : kind === "schedule"
+                                    ? scheduleFilePath(names, config)
+                                    : uploadFilePath(names, config);
     const registrySuffix = kind === "event"
         ? "Events"
         : kind === "job"
             ? "Jobs"
-            : kind === "listener"
-                ? "Listeners"
-                : "Schedules";
+            : kind === "task"
+                ? "Tasks"
+                : kind === "factory"
+                    ? "Factories"
+                    : kind === "seed"
+                        ? "Seeds"
+                        : kind === "notification"
+                            ? "Notifications"
+                            : kind === "listener"
+                                ? "Listeners"
+                                : kind === "schedule"
+                                    ? "Schedules"
+                                    : "Uploads";
     const importName = kind === "event"
         ? names.eventExportName
         : kind === "job"
             ? names.jobExportName
-            : kind === "listener"
-                ? names.listenerExportName
-                : names.scheduleExportName;
+            : kind === "task"
+                ? names.taskExportName
+                : kind === "factory"
+                    ? names.factoryExportName
+                    : kind === "seed"
+                        ? names.seedExportName
+                        : kind === "notification"
+                            ? names.notificationExportName
+                            : kind === "listener"
+                                ? names.listenerExportName
+                                : kind === "schedule"
+                                    ? names.scheduleExportName
+                                    : names.uploadExportName;
     return {
         path: path.join(path.dirname(artifactPath), "index.ts"),
+        kind,
         importName,
         artifactPath,
         registryName: `${names.featureSingularCamel}${registrySuffix}`,
+        registryEntryName: names.artifact.camel,
     };
 }
 async function updateFeatureArtifactIndex(targetDir, file, options) {
@@ -1961,9 +2845,20 @@ async function updateFeatureArtifactIndex(targetDir, file, options) {
     const existing = await readOptionalFile(destination);
     const specifier = relativeModule(file.path, file.artifactPath);
     const importLine = `import { ${file.importName} } from "${specifier}";`;
+    const defineUploadsImport = `import { defineUploads } from "@beignet/core/uploads";`;
     const exportLine = `export { ${file.importName} } from "${specifier}";`;
     if (existing === undefined) {
-        const content = `${importLine}
+        const content = file.kind === "upload"
+            ? `${defineUploadsImport}
+${importLine}
+
+${exportLine}
+
+export const ${file.registryName} = defineUploads({
+\t${file.registryEntryName}: ${file.importName},
+});
+`
+            : `${importLine}
 
 ${exportLine}
 
@@ -1985,12 +2880,101 @@ export const ${file.registryName} = [${file.importName}] as const;
             ? `${next.slice(0, registryExport.index).trimEnd()}\n${exportLine}\n\n${next.slice(registryExport.index)}`
             : `${next.trimEnd()}\n${exportLine}\n`;
     }
-    const registry = arrayInitializerInfo(next, file.registryName);
+    if (file.kind === "upload") {
+        const registry = defineUploadsInitializerInfo(next, file.registryName);
+        const arrayRegistry = arrayInitializerInfo(next, file.registryName);
+        if (registry) {
+            if (!next.includes(defineUploadsImport)) {
+                next = insertAfterImports(next, defineUploadsImport);
+            }
+            if (!registry.text.includes(`${file.registryEntryName}:`)) {
+                next = `${next.slice(0, registry.end)}\t${file.registryEntryName}: ${file.importName},\n${next.slice(registry.end)}`;
+            }
+        }
+        else if (arrayRegistry) {
+            if (!identifiersFromArrayExpression(arrayRegistry.text).has(file.importName)) {
+                const nextArray = appendToArrayExpression(arrayRegistry.text, [
+                    file.importName,
+                ]);
+                next = `${next.slice(0, arrayRegistry.start)}${nextArray}${next.slice(arrayRegistry.end)}`;
+            }
+        }
+        else {
+            if (!next.includes(defineUploadsImport)) {
+                next = insertAfterImports(next, defineUploadsImport);
+            }
+            next = `${next.trimEnd()}\n\nexport const ${file.registryName} = defineUploads({\n\t${file.registryEntryName}: ${file.importName},\n});\n`;
+        }
+    }
+    else {
+        const registry = arrayInitializerInfo(next, file.registryName);
+        if (!registry) {
+            next = `${next.trimEnd()}\n\nexport const ${file.registryName} = [${file.importName}] as const;\n`;
+        }
+        else if (!identifiersFromArrayExpression(registry.text).has(file.importName)) {
+            const nextArray = appendToArrayExpression(registry.text, [
+                file.importName,
+            ]);
+            next = `${next.slice(0, registry.start)}${nextArray}${next.slice(registry.end)}`;
+        }
+    }
+    if (next === existing)
+        return "skipped";
+    if (!options.dryRun)
+        await writeFile(destination, next);
+    return "updated";
+}
+async function updateTaskRegistry(targetDir, names, config, options) {
+    const destination = path.join(targetDir, config.paths.tasks);
+    const existing = await readOptionalFile(destination);
+    const featureTasksPath = path.join(featureArtifactDir(names, "tasks", config), "index.ts");
+    const registryName = `${names.featureSingularCamel}Tasks`;
+    const importLine = `import { ${registryName} } from "${relativeModule(config.paths.tasks, featureTasksPath)}";`;
+    const defineTasksImport = `import { defineTasks } from "@beignet/core/tasks";`;
+    const serviceActorImport = `import { createServiceActor } from "@beignet/core/ports";`;
+    const appContextImport = `import type { AppContext } from "${aliasModule(config.paths.appContext)}";`;
+    const serverImport = `import { server } from "${relativeModule(config.paths.tasks, config.paths.server)}";`;
+    const registryEntry = `...${registryName}`;
+    if (existing === undefined) {
+        const content = `${defineTasksImport}
+${serviceActorImport}
+${appContextImport}
+${importLine}
+${serverImport}
+
+export const tasks = defineTasks([
+\t${registryEntry},
+] as const);
+
+export async function createTaskContext(): Promise<AppContext> {
+\treturn server.createServiceContext({
+\t\tactor: createServiceActor("beignet-cli"),
+\t});
+}
+
+export async function stopTaskContext(): Promise<void> {
+\tawait server.stop();
+}
+`;
+        if (!options.dryRun) {
+            await mkdir(path.dirname(destination), { recursive: true });
+            await writeFile(destination, content);
+        }
+        return "created";
+    }
+    let next = existing;
+    if (!next.includes(defineTasksImport)) {
+        next = insertAfterImports(next, defineTasksImport);
+    }
+    if (!next.includes(importLine)) {
+        next = insertAfterImports(next, importLine);
+    }
+    const registry = arrayInitializerInfo(next, "tasks");
     if (!registry) {
-        next = `${next.trimEnd()}\n\nexport const ${file.registryName} = [${file.importName}] as const;\n`;
+        next = `${next.trimEnd()}\n\nexport const tasks = defineTasks([\n\t${registryEntry},\n] as const);\n`;
     }
-    else if (!identifiersFromArrayExpression(registry.text).has(file.importName)) {
-        const nextArray = appendToArrayExpression(registry.text, [file.importName]);
+    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)
@@ -2015,172 +2999,557 @@ function arrayInitializerInfo(source, constName) {
         end: closeBracket + 1,
     };
 }
-function schemasFile(names) {
+function defineUploadsInitializerInfo(source, constName) {
+    const match = new RegExp(`\\bconst\\s+${constName}\\s*=\\s*defineUploads\\s*\\(`).exec(source);
+    if (!match)
+        return undefined;
+    const openBrace = source.indexOf("{", match.index);
+    if (openBrace === -1)
+        return undefined;
+    const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
+    if (closeBrace === -1)
+        return undefined;
+    return {
+        text: source.slice(openBrace, closeBrace + 1),
+        start: openBrace,
+        end: closeBrace,
+    };
+}
+function schemasFile(names, mode, options) {
     return `import { z } from "zod";
 
 export const ${names.singularPascal}Schema = z.object({
 	id: z.string().uuid(),
-	name: z.string().min(1),
+${options.tenant ? `\ttenantId: z.string().min(1),\n` : ""}	name: z.string().min(1),
+	version: z.number().int().min(1),
 	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime(),
 });
 
-export const List${names.pluralPascal}InputSchema = z.object({
-	limit: z.coerce.number().int().min(1).max(100).default(20),
-	offset: z.coerce.number().int().min(0).default(0),
+export const ${names.singularPascal}SortBySchema = z.enum(["createdAt", "name"]);
+export const ${names.singularPascal}SortDirectionSchema = z.enum(["asc", "desc"]);
+
+const ${names.singularPascal}CursorPayloadSchema = z.object({
+	sortBy: ${names.singularPascal}SortBySchema,
+	sortDirection: ${names.singularPascal}SortDirectionSchema,
+	sortValue: z.string(),
+	id: z.string().uuid(),
 });
 
+export type ${names.singularPascal}SortBy = z.infer<
+	typeof ${names.singularPascal}SortBySchema
+>;
+export type ${names.singularPascal}SortDirection = z.infer<
+	typeof ${names.singularPascal}SortDirectionSchema
+>;
+export type ${names.singularPascal}Cursor = z.infer<
+	typeof ${names.singularPascal}CursorPayloadSchema
+>;
+
+function encodeBase64Url(value: string): string {
+	const bytes = new TextEncoder().encode(value);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+
+	return btoa(binary)
+		.replaceAll("+", "-")
+		.replaceAll("/", "_")
+		.replaceAll("=", "");
+}
+
+function decodeBase64Url(value: string): string {
+	const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
+	const padding = "=".repeat((4 - (base64.length % 4)) % 4);
+	const binary = atob(base64 + padding);
+	const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+
+	return new TextDecoder().decode(bytes);
+}
+
+export function encode${names.singularPascal}Cursor(cursor: ${names.singularPascal}Cursor): string {
+	return encodeBase64Url(JSON.stringify(cursor));
+}
+
+export function decode${names.singularPascal}Cursor(cursor: string): ${names.singularPascal}Cursor {
+	return ${names.singularPascal}CursorPayloadSchema.parse(
+		JSON.parse(decodeBase64Url(cursor)),
+	);
+}
+
+export const List${names.pluralPascal}InputSchema = z
+	.object({
+		limit: z.coerce.number().int().min(1).max(100).default(20),
+		cursor: z.string().nullable().default(null),
+		name: z.string().trim().min(1).max(120).optional(),
+		sortBy: ${names.singularPascal}SortBySchema.default("createdAt"),
+		sortDirection: ${names.singularPascal}SortDirectionSchema.default("desc"),
+	})
+	.superRefine((input, ctx) => {
+		if (!input.cursor) return;
+
+		try {
+			const cursor = decode${names.singularPascal}Cursor(input.cursor);
+			if (
+				cursor.sortBy !== input.sortBy ||
+				cursor.sortDirection !== input.sortDirection
+			) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "cursor does not match the requested sort.",
+					path: ["cursor"],
+				});
+			}
+		} catch {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "cursor is invalid.",
+				path: ["cursor"],
+			});
+		}
+	});
+
 export const List${names.pluralPascal}OutputSchema = z.object({
-	${names.pluralCamel}: z.array(${names.singularPascal}Schema),
-	total: z.number().int().min(0),
-	limit: z.number().int().min(1),
-	offset: z.number().int().min(0),
+	items: z.array(${names.singularPascal}Schema),
+	page: z.object({
+		kind: z.literal("cursor"),
+		limit: z.number().int().min(1),
+		cursor: z.string().nullable(),
+		nextCursor: z.string().nullable(),
+		hasMore: z.boolean(),
+	}),
 });
 
 export const Create${names.singularPascal}InputSchema = z.object({
 	name: z.string().min(1).max(120),
 });
+${mode === "resource"
+        ? `
+export const ${names.singularPascal}IdInputSchema = z.object({
+	id: z.string().uuid(),
+});
 
+export const Update${names.singularPascal}BodySchema = z.object({
+	name: z.string().min(1).max(120),
+	version: z.number().int().min(1),
+});
+
+export const Update${names.singularPascal}InputSchema =
+	${names.singularPascal}IdInputSchema.merge(Update${names.singularPascal}BodySchema);
+`
+        : ""}
 export type ${names.singularPascal} = z.infer<typeof ${names.singularPascal}Schema>;
 export type Create${names.singularPascal}Input = z.infer<
 	typeof Create${names.singularPascal}InputSchema
 >;
+${mode === "resource"
+        ? `
+export type ${names.singularPascal}IdInput = z.infer<
+	typeof ${names.singularPascal}IdInputSchema
+>;
+export type Update${names.singularPascal}Body = z.infer<
+	typeof Update${names.singularPascal}BodySchema
+>;
+export type Update${names.singularPascal}Input = z.infer<
+	typeof Update${names.singularPascal}InputSchema
+>;
+`
+        : ""}
 export type List${names.pluralPascal}Input = z.infer<
 	typeof List${names.pluralPascal}InputSchema
 >;
 `;
 }
-function listUseCaseFile(names, config) {
+function listUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `list-${names.pluralKebab}.ts`);
-    return `import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { normalizeCursorPage } from "@beignet/core/pagination";
+import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
+	decode${names.singularPascal}Cursor,
 	List${names.pluralPascal}InputSchema,
 	List${names.pluralPascal}OutputSchema,
-} from "./schemas";
+} from "../schemas";
 
 export const list${names.pluralPascal}UseCase = useCase
 	.query("${names.pluralCamel}.list")
 	.input(List${names.pluralPascal}InputSchema)
 	.output(List${names.pluralPascal}OutputSchema)
 	.run(async ({ ctx, input }) => {
-		const result = await ctx.ports.${names.pluralCamel}.list(input);
-		return {
-			${names.pluralCamel}: result.${names.pluralCamel},
-			total: result.total,
-			limit: input.limit,
-			offset: input.offset,
-		};
+${options.tenant ? `\t\tconst tenantId = ctx.tenant?.id;\n\t\tif (!tenantId) {\n\t\t\tthrow new Error("Tenant is required to list ${names.pluralKebab}.");\n\t\t}\n\n` : ""}		const page = normalizeCursorPage(input, {
+			defaultLimit: 20,
+			maxLimit: 100,
+		});
+
+		return ctx.ports.${names.pluralCamel}.list({
+			page,
+			cursor: page.cursor ? decode${names.singularPascal}Cursor(page.cursor) : null,
+			name: input.name,
+			sortBy: input.sortBy,
+			sortDirection: input.sortDirection,
+${options.tenant ? `\t\t\ttenantId,\n` : ""}		});
 	});
 `;
 }
-function createUseCaseFile(names, config) {
+function createUseCaseFile(names, config, options) {
     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 useCasesIndexFile(names) {
+function getUseCaseFile(names, config, options) {
+    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, config, options) {
+    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, config, options) {
+    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, mode) {
     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, config) {
+function repositoryPortFile(names, config, mode, options) {
     return `import type {
+	CursorPage,
+	CursorPageInfo,
+	PageResult,
+	SortDirection,
+} from "@beignet/core/pagination";
+import type {
 	Create${names.singularPascal}Input,
-	List${names.pluralPascal}Input,
-	${names.singularPascal},
-} from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
+	${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 = {
-	${names.pluralCamel}: ${names.singularPascal}[];
-	total: number;
-};
+export type List${names.pluralPascal}Result = PageResult<${names.singularPascal}, CursorPageInfo>;
+export type List${names.pluralPascal}Query = {
+	page: CursorPage;
+	cursor: ${names.singularPascal}Cursor | null;
+	name?: string;
+	sortBy: ${names.singularPascal}SortBy;
+	sortDirection: SortDirection;
+${options.tenant ? `\ttenantId: string;\n` : ""}};
+${options.tenant ? `export type ${names.singularPascal}TenantFilter = { tenantId: string };\nexport type Create${names.singularPascal}RepositoryInput = Create${names.singularPascal}Input & ${names.singularPascal}TenantFilter;\n${mode === "resource" ? `export type Update${names.singularPascal}RepositoryInput = Update${names.singularPascal}Input & ${names.singularPascal}TenantFilter;\n` : ""}` : ""}
 
 export interface ${names.singularPascal}Repository {
-	list(input: List${names.pluralPascal}Input): Promise<List${names.pluralPascal}Result>;
-	create(input: Create${names.singularPascal}Input): Promise<${names.singularPascal}>;
-}
+	list(query: List${names.pluralPascal}Query): Promise<List${names.pluralPascal}Result>;
+	create(input: ${options.tenant ? `Create${names.singularPascal}RepositoryInput` : `Create${names.singularPascal}Input`}): Promise<${names.singularPascal}>;
+${mode === "resource" ? `	findById(id: string${options.tenant ? `, filter: ${names.singularPascal}TenantFilter` : ""}): Promise<${names.singularPascal} | null>;\n	update(input: ${options.tenant ? `Update${names.singularPascal}RepositoryInput` : `Update${names.singularPascal}Input`}): Promise<${names.singularPascal} | null>;\n	delete(id: string${options.tenant ? `, filter: ${names.singularPascal}TenantFilter` : ""}): Promise<boolean>;\n` : ""}}
 `;
 }
-function inMemoryRepositoryFile(names, config) {
+function inMemoryRepositoryFile(names, config, mode, options) {
     const repositoryPortPath = resourcePortFilePath(names, config);
-    return `import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+    const recordType = options.softDelete
+        ? `type ${names.singularPascal}Record = ${names.singularPascal} & {
+\tdeletedAt: string | null;
+};
+
+`
+        : "";
+    const mapValueType = options.softDelete
+        ? `${names.singularPascal}Record`
+        : names.singularPascal;
+    const activeFilter = options.softDelete
+        ? `\t\t\t\t.filter((${names.singularCamel}) => ${names.singularCamel}.deletedAt === null)\n`
+        : "";
+    const newDeletedAtField = options.softDelete
+        ? `\t\t\t\tdeletedAt: null,\n`
+        : "";
+    const findDeletedGuard = options.softDelete
+        ? `\t\t\tif (${names.singularCamel}?.deletedAt !== null) return null;\n`
+        : "";
+    const updateDeletedGuard = options.softDelete
+        ? " || existing.deletedAt !== null"
+        : "";
+    const deleteImplementation = options.softDelete
+        ? `${options.tenant ? `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (!existing || existing.tenantId !== filter.tenantId || existing.deletedAt !== null) return false;\n` : `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (!existing || existing.deletedAt !== null) return false;\n`}			const now = new Date().toISOString();
+			${names.pluralCamel}.set(id, { ...existing, deletedAt: now, updatedAt: now });
+			return true;`
+        : `${options.tenant ? `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (existing?.tenantId !== filter.tenantId) return false;\n` : ""}			return ${names.pluralCamel}.delete(id);`;
+    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { cursorPageResult } from "@beignet/core/pagination";
+import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+import { encode${names.singularPascal}Cursor } from "${aliasModule(resourceSchemaFilePath(names, config))}";
 import type {
 	Create${names.singularPascal}Input,
-	List${names.pluralPascal}Input,
-	${names.singularPascal},
-} from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
+${mode === "resource" ? `	Update${names.singularPascal}Input,\n` : ""}	${names.singularPascal},
+} from "${aliasModule(resourceSchemaFilePath(names, config))}";
+
+${recordType}function to${names.singularPascal}(${names.singularCamel}: ${mapValueType}): ${names.singularPascal} {
+	return {
+		id: ${names.singularCamel}.id,
+${options.tenant ? `\t\ttenantId: ${names.singularCamel}.tenantId,\n` : ""}		name: ${names.singularCamel}.name,
+		version: ${names.singularCamel}.version,
+		createdAt: ${names.singularCamel}.createdAt,
+		updatedAt: ${names.singularCamel}.updatedAt,
+	};
+}
+
+function compare${names.pluralPascal}(
+	left: ${mapValueType},
+	right: ${mapValueType},
+	query: Parameters<${names.singularPascal}Repository["list"]>[0],
+): number {
+	const leftValue = left[query.sortBy];
+	const rightValue = right[query.sortBy];
+	const fieldComparison =
+		leftValue === rightValue ? left.id.localeCompare(right.id) : leftValue.localeCompare(rightValue);
+
+	return query.sortDirection === "asc" ? fieldComparison : -fieldComparison;
+}
+
+function isAfter${names.singularPascal}Cursor(
+	${names.singularCamel}: ${mapValueType},
+	query: Parameters<${names.singularPascal}Repository["list"]>[0],
+): boolean {
+	if (!query.cursor) return true;
+
+	const sortValue = ${names.singularCamel}[query.sortBy];
+	const fieldComparison =
+		sortValue === query.cursor.sortValue
+			? ${names.singularCamel}.id.localeCompare(query.cursor.id)
+			: sortValue.localeCompare(query.cursor.sortValue);
+
+	return query.sortDirection === "asc" ? fieldComparison > 0 : fieldComparison < 0;
+}
+
+function cursorFor${names.singularPascal}(
+	${names.singularCamel}: ${mapValueType},
+	query: Parameters<${names.singularPascal}Repository["list"]>[0],
+): string {
+	return encode${names.singularPascal}Cursor({
+		sortBy: query.sortBy,
+		sortDirection: query.sortDirection,
+		sortValue: ${names.singularCamel}[query.sortBy],
+		id: ${names.singularCamel}.id,
+	});
+}
 
 export function createInMemory${names.singularPascal}Repository(
 	seed: ${names.singularPascal}[] = [],
 ): ${names.singularPascal}Repository {
-	const ${names.pluralCamel} = new Map(seed.map((${names.singularCamel}) => [${names.singularCamel}.id, ${names.singularCamel}]));
+	const ${names.pluralCamel} = new Map<string, ${mapValueType}>(
+		seed.map((${names.singularCamel}) => [
+			${names.singularCamel}.id,
+			{ ...${names.singularCamel}${options.softDelete ? ", deletedAt: null" : ""} },
+		]),
+	);
 
 	return {
-		async list(input: List${names.pluralPascal}Input) {
-			const all${names.pluralPascal} = Array.from(${names.pluralCamel}.values()).sort(
-				(left, right) => right.createdAt.localeCompare(left.createdAt),
-			);
+		async list(query) {
+			const name = query.name?.toLocaleLowerCase();
+			const all${names.pluralPascal} = Array.from(${names.pluralCamel}.values())
+${activeFilter}${options.tenant ? `\t\t\t\t.filter((${names.singularCamel}) => ${names.singularCamel}.tenantId === query.tenantId)\n` : ""}				.filter((${names.singularCamel}) => !name || ${names.singularCamel}.name.toLocaleLowerCase().includes(name))
+				.sort((left, right) => compare${names.pluralPascal}(left, right, query))
+				.filter((${names.singularCamel}) => isAfter${names.singularPascal}Cursor(${names.singularCamel}, query));
+			const pageItems = all${names.pluralPascal}.slice(0, query.page.limit);
+			const nextCursor =
+				all${names.pluralPascal}.length > query.page.limit && pageItems.length > 0
+					? cursorFor${names.singularPascal}(pageItems[pageItems.length - 1]!, query)
+					: null;
 
-			return {
-				${names.pluralCamel}: all${names.pluralPascal}.slice(
-					input.offset,
-					input.offset + input.limit,
-				),
-				total: all${names.pluralPascal}.length,
-			};
+			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) {
-    return `import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+function drizzleSchemaFile(names, options) {
+    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 drizzleRepositoryFile(names, config) {
+function drizzleResourceWhere(names, options, predicates) {
+    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, config, mode, options) {
     const repositoryPortPath = resourcePortFilePath(names, config);
     const schemaPath = drizzleSchemaIndexPath(config);
-    return `import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
-import { count, desc } from "drizzle-orm";
+    const findWhere = drizzleResourceWhere(names, options, [
+        `eq(schema.${names.pluralCamel}.id, id)`,
+        ...(options.tenant
+            ? [`eq(schema.${names.pluralCamel}.tenantId, filter.tenantId)`]
+            : []),
+    ]);
+    const updateWhere = drizzleResourceWhere(names, options, [
+        `eq(schema.${names.pluralCamel}.id, input.id)`,
+        `eq(schema.${names.pluralCamel}.version, input.version)`,
+        ...(options.tenant
+            ? [`eq(schema.${names.pluralCamel}.tenantId, input.tenantId)`]
+            : []),
+    ]);
+    const deleteWhere = drizzleResourceWhere(names, options, [
+        `eq(schema.${names.pluralCamel}.id, id)`,
+        ...(options.tenant
+            ? [`eq(schema.${names.pluralCamel}.tenantId, filter.tenantId)`]
+            : []),
+    ]);
+    const drizzleImports = [
+        "and",
+        "asc",
+        "desc",
+        "eq",
+        "gt",
+        options.softDelete ? "isNull" : undefined,
+        "lt",
+        "or",
+        "sql",
+        "type SQL",
+    ].filter((name) => Boolean(name));
+    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { cursorPageResult } from "@beignet/core/pagination";
+import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
+import { ${drizzleImports.join(", ")} } from "drizzle-orm";
 import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+import { encode${names.singularPascal}Cursor } from "${aliasModule(resourceSchemaFilePath(names, config))}";
 import type {
 	Create${names.singularPascal}Input,
-	List${names.pluralPascal}Input,
-	${names.singularPascal},
-} from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
+${mode === "resource" ? `	Update${names.singularPascal}Input,\n` : ""}	${names.singularPascal},
+} from "${aliasModule(resourceSchemaFilePath(names, config))}";
 import * as schema from "${aliasModule(schemaPath)}";
 
 type ${names.singularPascal}Row = typeof schema.${names.pluralCamel}.$inferSelect;
@@ -2188,38 +3557,104 @@ type ${names.singularPascal}Row = typeof schema.${names.pluralCamel}.$inferSelec
 function to${names.singularPascal}(row: ${names.singularPascal}Row): ${names.singularPascal} {
 	return {
 		id: row.id,
-		name: row.name,
+${options.tenant ? `\t\ttenantId: row.tenantId,\n` : ""}		name: row.name,
+		version: row.version,
 		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
 	};
 }
 
+type List${names.pluralPascal}Query = Parameters<${names.singularPascal}Repository["list"]>[0];
+
+function ${names.singularCamel}SortColumn(query: List${names.pluralPascal}Query) {
+	return query.sortBy === "name" ? schema.${names.pluralCamel}.name : schema.${names.pluralCamel}.createdAt;
+}
+
+function ${names.singularCamel}CursorFilter(
+	query: List${names.pluralPascal}Query,
+): SQL<unknown> | undefined {
+	if (!query.cursor) return undefined;
+
+	const column = ${names.singularCamel}SortColumn(query);
+	const compare = query.sortDirection === "asc" ? gt : lt;
+
+	return or(
+		compare(column, query.cursor.sortValue),
+		and(
+			eq(column, query.cursor.sortValue),
+			compare(schema.${names.pluralCamel}.id, query.cursor.id),
+		),
+	) as SQL<unknown>;
+}
+
+function ${names.singularCamel}ListWhere(
+	query: List${names.pluralPascal}Query,
+): SQL<unknown> | undefined {
+	const filters: SQL<unknown>[] = [
+${options.tenant ? `\t\teq(schema.${names.pluralCamel}.tenantId, query.tenantId),\n` : ""}${options.softDelete ? `\t\tisNull(schema.${names.pluralCamel}.deletedAt),\n` : ""}	];
+	const cursor = ${names.singularCamel}CursorFilter(query);
+
+	if (query.name) {
+		const pattern = \`%\${query.name.toLocaleLowerCase()}%\`;
+		filters.push(sql\`lower(\${schema.${names.pluralCamel}.name}) like \${pattern}\`);
+	}
+	if (cursor) filters.push(cursor);
+
+	return filters.length > 0 ? and(...filters) : undefined;
+}
+
+function ${names.singularCamel}OrderBy(query: List${names.pluralPascal}Query) {
+	const order = query.sortDirection === "asc" ? asc : desc;
+
+	return [order(${names.singularCamel}SortColumn(query)), order(schema.${names.pluralCamel}.id)] as const;
+}
+
+function cursorFor${names.singularPascal}(
+	row: ${names.singularPascal}Row,
+	query: List${names.pluralPascal}Query,
+): string {
+	return encode${names.singularPascal}Cursor({
+		sortBy: query.sortBy,
+		sortDirection: query.sortDirection,
+		sortValue: row[query.sortBy],
+		id: row.id,
+	});
+}
+
 export function createDrizzle${names.singularPascal}Repository(
 	db: DrizzleTursoDatabase<typeof schema>,
 ): ${names.singularPascal}Repository {
 	return {
-		async list(input: List${names.pluralPascal}Input) {
+		async list(query) {
+			const where = ${names.singularCamel}ListWhere(query);
 			const rows = await db
 				.select()
 				.from(schema.${names.pluralCamel})
-				.orderBy(desc(schema.${names.pluralCamel}.createdAt))
-				.limit(input.limit)
-				.offset(input.offset);
-			const [{ total }] = await db
-				.select({ total: count() })
-				.from(schema.${names.pluralCamel});
-
-			return {
-				${names.pluralCamel}: rows.map(to${names.singularPascal}),
-				total,
-			};
+				.where(where)
+				.orderBy(...${names.singularCamel}OrderBy(query))
+				.limit(query.page.limit + 1);
+			const pageRows = rows.slice(0, query.page.limit);
+			const nextCursor =
+				rows.length > query.page.limit && pageRows.length > 0
+					? cursorFor${names.singularPascal}(pageRows[pageRows.length - 1]!, query)
+					: null;
+
+			return cursorPageResult(
+				pageRows.map(to${names.singularPascal}),
+				query.page,
+				nextCursor,
+			);
 		},
-		async create(input: Create${names.singularPascal}Input) {
+		async create(input) {
+			const now = new Date().toISOString();
 			const [row] = await db
 				.insert(schema.${names.pluralCamel})
 				.values({
 					id: crypto.randomUUID(),
-					name: input.name,
-					createdAt: new Date().toISOString(),
+${options.tenant ? `\t\t\t\t\ttenantId: input.tenantId,\n` : ""}					name: input.name,
+					version: 1,
+					createdAt: now,
+					updatedAt: now,
 				})
 				.returning();
 
@@ -2229,17 +3664,20 @@ 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` : ""}
 	};
 }
 `;
 }
-function contractFile(names, config) {
-    return `import { createContractGroup } from "@beignet/core/contracts";
+function contractFile(names, config, mode, options) {
+    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(),
@@ -2247,7 +3685,7 @@ const ErrorResponseSchema = z.object({
 	requestId: z.string().optional(),
 });
 
-const ${names.pluralCamel} = createContractGroup()
+const ${names.pluralCamel} = defineContractGroup()
 	.namespace("${names.pluralCamel}")
 	.responses({
 		500: ErrorResponseSchema,
@@ -2255,21 +3693,49 @@ const ${names.pluralCamel} = createContractGroup()
 
 export const list${names.pluralPascal} = ${names.pluralCamel}
 	.get("/api/${names.pluralKebab}")
-	.query(list${names.pluralPascal}UseCase.inputSchema)
+	.query(List${names.pluralPascal}InputSchema)
 	.responses({
-		200: list${names.pluralPascal}UseCase.outputSchema,
+		200: List${names.pluralPascal}OutputSchema,
 	});
 
 export const create${names.singularPascal} = ${names.pluralCamel}
 	.post("/api/${names.pluralKebab}")
-	.body(create${names.singularPascal}UseCase.inputSchema)
+	.body(Create${names.singularPascal}InputSchema)
+${options.auth ? `	.meta({\n		auth: "required",\n		authorization: { ability: "${names.pluralCamel}.create" },\n	})\n	.errors({ Unauthorized: errors.Unauthorized, Forbidden: errors.Forbidden })\n` : ""}	.responses({
+		201: ${names.singularPascal}Schema,
+	});
+${mode === "resource"
+        ? `
+export const get${names.singularPascal} = ${names.pluralCamel}
+	.get("/api/${names.pluralKebab}/:id")
+	.pathParams(${names.singularPascal}IdInputSchema)
+	.errors({ ${names.singularPascal}NotFound: errors.${names.singularPascal}NotFound })
+	.responses({
+		200: ${names.singularPascal}Schema,
+	});
+
+export const update${names.singularPascal} = ${names.pluralCamel}
+	.patch("/api/${names.pluralKebab}/:id")
+	.pathParams(${names.singularPascal}IdInputSchema)
+	.body(Update${names.singularPascal}BodySchema)
+${options.auth ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization: { ability: "${names.pluralCamel}.update" },\n\t})\n` : ""}	.errors({${options.auth ? " Unauthorized: errors.Unauthorized, Forbidden: errors.Forbidden," : ""} ${names.singularPascal}NotFound: errors.${names.singularPascal}NotFound, ${names.singularPascal}Conflict: errors.${names.singularPascal}Conflict })
 	.responses({
-		201: create${names.singularPascal}UseCase.outputSchema,
+		200: ${names.singularPascal}Schema,
 	});
+
+export const delete${names.singularPascal} = ${names.pluralCamel}
+	.delete("/api/${names.pluralKebab}/:id")
+	.pathParams(${names.singularPascal}IdInputSchema)
+${options.auth ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization: { ability: "${names.pluralCamel}.delete" },\n\t})\n` : ""}	.errors({${options.auth ? " Unauthorized: errors.Unauthorized, Forbidden: errors.Forbidden," : ""} ${names.singularPascal}NotFound: errors.${names.singularPascal}NotFound })
+	.responses({
+		204: null,
+	});
+`
+        : ""}
 `;
 }
 function standaloneContractFile(names) {
-    return `import { createContractGroup } from "@beignet/core/contracts";
+    return `import { defineContractGroup } from "@beignet/core/contracts";
 import { z } from "zod";
 
 const ErrorResponseSchema = z.object({
@@ -2278,7 +3744,7 @@ const ErrorResponseSchema = z.object({
 	requestId: z.string().optional(),
 });
 
-const ${names.pluralCamel} = createContractGroup()
+const ${names.pluralCamel} = defineContractGroup()
 	.namespace("${names.pluralCamel}")
 	.responses({
 		500: ErrorResponseSchema,
@@ -2299,10 +3765,14 @@ export const list${names.pluralPascal} = ${names.pluralCamel}
 	)
 	.responses({
 		200: z.object({
-			${names.pluralCamel}: z.array(${names.singularCamel}Schema),
-			total: z.number().int().min(0),
-			limit: z.number().int().min(1),
-			offset: z.number().int().min(0),
+			items: z.array(${names.singularCamel}Schema),
+			page: z.object({
+				kind: z.literal("offset"),
+				limit: z.number().int().min(1),
+				offset: z.number().int().min(0),
+				total: z.number().int().min(0),
+				hasMore: z.boolean(),
+			}),
 		}),
 	});
 
@@ -2310,7 +3780,8 @@ export const ${names.pluralCamel}Contracts = [list${names.pluralPascal}];
 `;
 }
 function standaloneUseCaseFile(names, config, filePath) {
-    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({});
@@ -2338,29 +3809,27 @@ function useCaseTestFile(names, config) {
     return `import { describe, expect, it } from "bun:test";
 import { createUseCaseTester } from "@beignet/core/application";
 import { createInMemoryDevtools } from "@beignet/devtools";
-import { createAnonymousActor, createMemoryStorage, createNoopUnitOfWork } from "@beignet/core/ports";
+import { createTestContextFactory, createTestPorts } from "@beignet/core/testing";
+import { createTestAnonymousActor } from "@beignet/core/ports/testing";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
 import { appPorts } from "${aliasModule(config.paths.infrastructurePorts)}";
 import { ${names.exportName} } from "${relativeModule(filePath, useCaseFilePath(names, config))}";
 
 describe("${names.exportName}", () => {
 	it("runs ${names.action.camel}", async () => {
-		const testPorts = {
-			...appPorts,
-			uow: createNoopUnitOfWork(
-				() => appPorts as unknown as AppContext["ports"],
-			) as AppContext["ports"]["uow"],
-			devtools: createInMemoryDevtools(),
-			storage: createMemoryStorage(),
-		} as AppContext["ports"];
-		const actor = createAnonymousActor();
-		const tester = createUseCaseTester<AppContext>(() => ({
-			requestId: "test-request",
-			actor,
-			auth: null,
-			gate: testPorts.gate.bind({ actor, auth: null }),
-			ports: testPorts,
-		}));
+		const testFixture = createTestPorts<AppContext["ports"]>({
+			base: appPorts,
+			overrides: {
+				gate: appPorts.gate,
+				devtools: createInMemoryDevtools(),
+			},
+		});
+		const createTestContext = createTestContextFactory<AppContext, AppContext["ports"]>({
+			ports: testFixture.ports,
+			actor: createTestAnonymousActor(),
+			tenant: null,
+		});
+		const tester = createUseCaseTester<AppContext>(createTestContext);
 
 		const result = await tester.run(${names.exportName}, {});
 
@@ -2421,6 +3890,134 @@ export const ${names.policyName} = definePolicy({
 });
 `;
 }
+function resourcePolicyFile(names, _config, options) {
+    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) {
+    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, options) {
+    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) {
     return `import { defineEvent } from "@beignet/core/events";
 import { z } from "zod";
@@ -2437,11 +4034,9 @@ export const ${names.eventExportName} = defineEvent("${names.eventName}", {
 `;
 }
 function jobFile(names, config) {
-    return `import { createJobHandlers } from "@beignet/core/jobs";
+    return `import { retry } from "@beignet/core/jobs";
 import { z } from "zod";
-import type { AppContext } from "${aliasModule(config.paths.appContext)}";
-
-const jobs = createJobHandlers<AppContext>();
+import { defineJob } from "${aliasModule(config.paths.jobsBuilder)}";
 
 export const ${names.payloadSchemaName} = z.object({
 \tid: z.string().uuid(),
@@ -2449,11 +4044,13 @@ export const ${names.payloadSchemaName} = z.object({
 
 export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
 
-export const ${names.jobExportName} = jobs.defineJob("${names.jobName}", {
+export const ${names.jobExportName} = defineJob("${names.jobName}", {
 \tpayload: ${names.payloadSchemaName},
-\tretry: {
+\tretry: retry.exponential({
 \t\tattempts: 3,
-\t},
+\t\tinitialDelay: "1s",
+\t\tmaxDelay: "1m",
+\t}),
 \tasync handle({ payload, ctx }) {
 \t\tctx.ports.logger.info("Job handled", {
 \t\t\tjobName: "${names.jobName}",
@@ -2463,15 +4060,94 @@ export const ${names.jobExportName} = jobs.defineJob("${names.jobName}", {
 });
 `;
 }
+function taskFile(names, config) {
+    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, config) {
+    const resource = featureResourceNames(names);
+    return `import { createFactory } from "@beignet/core/testing";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+export const ${names.factoryExportName} = createFactory("${names.factoryName}", {
+\tdefaults: ({ sequence }) => ({
+\t\tname: "${resource.singularPascal} " + sequence,
+\t}),
+\tpersist: (ctx: AppContext, input) => ctx.ports.${resource.pluralCamel}.create(input),
+});
+`;
+}
+function seedFile(names, config) {
+    const resource = featureResourceNames(names);
+    return `import { defineSeed } from "@beignet/core/testing";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+export const ${names.seedExportName} = defineSeed("${names.seedName}", {
+\tdescription: "Creates starter ${names.feature.kebab} data.",
+\trun: async (ctx: AppContext) => {
+\t\tawait ctx.ports.${resource.pluralCamel}.create({
+\t\t\tname: "Demo ${resource.singularPascal}",
+\t\t});
+\t},
+});
+`;
+}
+function notificationFile(names, config) {
+    return `import { defineMailNotificationChannel } from "@beignet/core/notifications";
+import { z } from "zod";
+import { defineNotification } from "${aliasModule(config.paths.notificationsBuilder)}";
+
+export const ${names.payloadSchemaName} = z.object({
+\tid: z.string().uuid(),
+\tsubject: z.string(),
+\trecipientEmail: z.string().email(),
+});
+
+export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
+
+export const ${names.notificationExportName} = defineNotification(
+\t"${names.notificationName}",
+\t{
+\t\tpayload: ${names.payloadSchemaName},
+\t\tchannels: {
+\t\t\temail: defineMailNotificationChannel(({ payload }) => ({
+\t\t\t\tto: payload.recipientEmail,
+\t\t\t\tsubject: payload.subject,
+\t\t\t\ttext: \`${names.notificationName} notification for \${payload.id}.\`,
+\t\t\t})),
+\t\t},
+\t},
+);
+`;
+}
 function listenerFile(names, config) {
     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", {
@@ -2483,11 +4159,8 @@ export const ${names.listenerExportName} = events.defineListener(${names.event.e
 `;
 }
 function scheduleFile(names, config) {
-    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(),
@@ -2495,7 +4168,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}",
@@ -2517,108 +4190,164 @@ ${names.timezone ? `\t\ttimezone: "${names.timezone}",\n` : ""}\t\tpayload: ${na
 );
 `;
 }
-function scheduleRouteFile(names, config) {
-    return `import { createInlineScheduleRunner } from "@beignet/core/schedules";
+function uploadFile(names, config) {
+    return `import { defineUpload } from "@beignet/core/uploads";
+import { z } from "zod";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
-import { ${names.scheduleExportName} } from "${aliasModule(scheduleFilePath(names, config))}";
-import { env } from "@/lib/env";
-import { server } from "${aliasModule(config.paths.server)}";
 
-async function run${names.artifact.pascal}(request: Request) {
-\tconst cronSecret = env.CRON_SECRET;
+export const ${names.metadataSchemaName} = z.object({
+\tresourceId: z.string().min(1),
+});
 
-\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});
+export type ${names.metadataTypeName} = z.infer<typeof ${names.metadataSchemaName}>;
 
-\ttry {
-\t\tawait runner.run(${names.scheduleExportName}, {
-\t\t\tsource: "cron-route",
+export const ${names.uploadExportName} = defineUpload<
+\t"${names.uploadName}",
+\ttypeof ${names.metadataSchemaName},
+\tAppContext,
+\t{ objectKeys: string[] }
+>("${names.uploadName}", {
+\tmetadata: ${names.metadataSchemaName},
+\tfile: {
+\t\tcontentTypes: ["application/pdf", "text/plain"],
+\t\tmaxSizeBytes: 5 * 1024 * 1024,
+\t\tmaxFiles: 1,
+\t\tvisibility: "private",
+\t\tcacheControl: "private, max-age=0",
+\t},
+\tauthorize({ ctx }) {
+\t\treturn ctx.actor.type === "user";
+\t},
+\tkey({ ctx, metadata, uploadId, file }) {
+\t\tconst tenantId = ctx.tenant?.id ?? "default";
+\t\tconst extension = file.name.includes(".") ? file.name.split(".").pop() : undefined;
+\t\tconst suffix = extension ? \`.\${extension}\` : "";
+\t\treturn "${names.feature.kebab}/" + tenantId + "/" + metadata.resourceId + "/" + uploadId + suffix;
+\t},
+\tstorageMetadata({ ctx, metadata }) {
+\t\treturn {
+\t\t\ttenantId: ctx.tenant?.id ?? "default",
+\t\t\tresourceId: metadata.resourceId,
+\t\t};
+\t},
+\tasync onComplete({ ctx, metadata, files }) {
+\t\tctx.ports.logger.info("Upload completed", {
+\t\t\tuploadName: "${names.uploadName}",
+\t\t\tresourceId: metadata.resourceId,
+\t\t\tobjectKeys: files.map((file) => file.key),
 \t\t});
-\t} catch {
-\t\treturn Response.json({ error: "Schedule failed" }, { status: 500 });
-\t}
 
-\treturn Response.json({ ok: true });
+\t\treturn {
+\t\t\tobjectKeys: files.map((file) => file.key),
+\t\t};
+\t},
+});
+`;
 }
+function featureUiComponentFile(names, config) {
+    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);
 
-export const GET = run${names.artifact.pascal};
-export const POST = run${names.artifact.pascal};
+\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, config) {
+    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)}";
+
+export const runtime = "nodejs";
+
+export const { GET, POST } = createScheduleRoute({
+\tserver,
+\tschedules: [${names.scheduleExportName}],
+\tschedule: ${names.scheduleExportName}.name,
+\tsecret: env.CRON_SECRET,
+\tsource: "cron-route",
+});
 `;
 }
 function useCaseIndexExport(names) {
@@ -2631,73 +4360,138 @@ function useCaseIndexExport(names) {
 } from "./${names.action.kebab}";
 `;
 }
-function routeGroupFile(names, config) {
-    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))}";
+function routeGroupFile(names, config, mode, _options) {
+    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, config) {
+function testFile(names, config, mode, options) {
     const repositoryPath = path.join(path.dirname(config.paths.infrastructurePorts), names.pluralKebab, `in-memory-${names.singularKebab}-repository.ts`);
+    const serverContextPath = path.join(path.dirname(config.paths.server), "context.ts");
+    const requestTarget = options.tenant ? "requester" : "app";
     return `import { describe, expect, it } from "bun:test";
 import { createUseCaseTester } from "@beignet/core/application";
+${mode === "resource" ? `import { isAppError } from "@beignet/core/errors";\n` : ""}import { defineRoutes } from "@beignet/web";
+import { createTestApp${options.tenant ? ", createTestRequester" : ""} } from "@beignet/web/testing";
 import { createInMemoryDevtools } from "@beignet/devtools";
-import { createAnonymousActor, createMemoryStorage, createNoopUnitOfWork } from "@beignet/core/ports";
+import { createTestContextFactory, createTestPorts } from "@beignet/core/testing";
+import { ${options.auth ? "createTestUserActor" : "createTestAnonymousActor"}${options.tenant ? ", createTestTenant" : ""} } from "@beignet/core/ports/testing";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
 import { appPorts } from "${aliasModule(config.paths.infrastructurePorts)}";
+import { appContext } from "${aliasModule(serverContextPath)}";
+import {
+	create${names.singularPascal},
+${mode === "resource" ? `	delete${names.singularPascal},\n	get${names.singularPascal},\n` : ""}	list${names.pluralPascal},
+${mode === "resource" ? `	update${names.singularPascal},\n` : ""}} from "${aliasModule(resourceContractFilePath(names, config))}";
 import { createInMemory${names.singularPascal}Repository } from "${aliasModule(repositoryPath)}";
+import { ${names.singularCamel}Routes } from "${aliasModule(path.join(resourceFeatureDir(names, config), "routes.ts"))}";
 import {
 	create${names.singularPascal}UseCase,
-	list${names.pluralPascal}UseCase,
-} from "${aliasModule(resourceUseCaseIndexPath(names, config))}";
+${mode === "resource" ? `	delete${names.singularPascal}UseCase,\n	get${names.singularPascal}UseCase,\n` : ""}	list${names.pluralPascal}UseCase,
+${mode === "resource" ? `	update${names.singularPascal}UseCase,\n` : ""}} from "${aliasModule(resourceUseCaseIndexPath(names, config))}";
 
 describe("${names.pluralCamel} resource", () => {
-	it("creates and lists ${names.pluralCamel}", async () => {
-		const ${names.pluralCamel} = createInMemory${names.singularPascal}Repository();
-		const testPorts = {
-			...appPorts,
-			${names.pluralCamel},
-			uow: createNoopUnitOfWork(() => ({
-				...(appPorts as unknown as AppContext["ports"]),
+	it("${mode === "resource" ? `exercises ${names.pluralCamel} CRUD` : `creates and lists ${names.pluralCamel}`}", async () => {
+		const seed${names.pluralPascal} = [
+			{
+				id: "00000000-0000-4000-8000-000000000101",
+${options.tenant ? `\t\t\t\ttenantId: "tenant_test",\n` : ""}				name: "Alpha ${names.singularPascal}",
+				version: 1,
+				createdAt: "2024-01-01T00:00:00.000Z",
+				updatedAt: "2024-01-01T00:00:00.000Z",
+			},
+			{
+				id: "00000000-0000-4000-8000-000000000102",
+${options.tenant ? `\t\t\t\ttenantId: "tenant_test",\n` : ""}				name: "Beta ${names.singularPascal}",
+				version: 1,
+				createdAt: "2024-01-02T00:00:00.000Z",
+				updatedAt: "2024-01-02T00:00:00.000Z",
+			},
+			{
+				id: "00000000-0000-4000-8000-000000000103",
+${options.tenant ? `\t\t\t\ttenantId: "tenant_test",\n` : ""}				name: "Gamma ${names.singularPascal}",
+				version: 1,
+				createdAt: "2024-01-03T00:00:00.000Z",
+				updatedAt: "2024-01-03T00:00:00.000Z",
+			},
+${options.tenant ? `\t\t\t{\n\t\t\t\tid: "00000000-0000-4000-8000-000000000104",\n\t\t\t\ttenantId: "tenant_other",\n\t\t\t\tname: "Other Tenant ${names.singularPascal}",\n\t\t\t\tversion: 1,\n\t\t\t\tcreatedAt: "2024-01-04T00:00:00.000Z",\n\t\t\t\tupdatedAt: "2024-01-04T00:00:00.000Z",\n\t\t\t},\n` : ""}		];
+		const ${names.pluralCamel} = createInMemory${names.singularPascal}Repository(seed${names.pluralPascal});
+		const testFixture = createTestPorts<AppContext["ports"]>({
+			base: appPorts,
+			overrides: {
 				${names.pluralCamel},
-			})) as AppContext["ports"]["uow"],
-			devtools: createInMemoryDevtools(),
-			storage: createMemoryStorage(),
-		} as AppContext["ports"];
-		const actor = createAnonymousActor();
-		const tester = createUseCaseTester<AppContext>(() => ({
-			requestId: "test-request",
-			actor,
-			auth: null,
-			gate: testPorts.gate.bind({ actor, auth: null }),
-			ports: testPorts,
-		}));
+${options.auth
+        ? `\t\t\t\tauth: {
+					getSession: async () => ({
+						user: { id: "user_test", name: "Test User" },
+					}),
+				},
+				gate: appPorts.gate,\n`
+        : `\t\t\t\tauth: {
+					getSession: async () => null,
+				},\n`}				devtools: createInMemoryDevtools(),
+			},
+			transaction: {
+				ports: (ports) => ({
+					...ports,
+					${names.pluralCamel},
+				}),
+			},
+		});
+		const createTestContext = createTestContextFactory<AppContext, AppContext["ports"]>({
+			ports: testFixture.ports,
+			actor: ${options.auth ? `createTestUserActor("user_test")` : "createTestAnonymousActor()"},
+			tenant: ${options.tenant ? `createTestTenant("tenant_test")` : "null"},
+		});
+		const tester = createUseCaseTester<AppContext>(createTestContext);
 
 		const ctx = await tester.ctx();
+		const defaultPage = await tester.run(list${names.pluralPascal}UseCase, {}, { ctx });
+		const filteredPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ name: "alp" },
+			{ ctx },
+		);
+		const firstPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ limit: 2 },
+			{ ctx },
+		);
+		const secondPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ limit: 2, cursor: firstPage.page.nextCursor },
+			{ ctx },
+		);
+		const nameAscendingPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ sortBy: "name", sortDirection: "asc" },
+			{ ctx },
+		);
+		const nameDescendingPage = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ sortBy: "name", sortDirection: "desc" },
+			{ ctx },
+		);
 		const created = await tester.run(
 			create${names.singularPascal}UseCase,
 			{ name: "First ${names.singularPascal}" },
@@ -2705,13 +4499,111 @@ describe("${names.pluralCamel} resource", () => {
 		);
 		const result = await tester.run(
 			list${names.pluralPascal}UseCase,
-			{ limit: 20, offset: 0 },
+			{ name: "First" },
 			{ ctx },
 		);
 
+		expect(defaultPage.page).toMatchObject({
+			kind: "cursor",
+			limit: 20,
+			cursor: null,
+			nextCursor: null,
+			hasMore: false,
+		});
+		expect(defaultPage.items.map((item) => item.name)).toEqual([
+			"Gamma ${names.singularPascal}",
+			"Beta ${names.singularPascal}",
+			"Alpha ${names.singularPascal}",
+		]);
+		expect(filteredPage.items.map((item) => item.name)).toEqual([
+			"Alpha ${names.singularPascal}",
+		]);
+		expect(firstPage.items.map((item) => item.name)).toEqual([
+			"Gamma ${names.singularPascal}",
+			"Beta ${names.singularPascal}",
+		]);
+		expect(firstPage.page.nextCursor).toEqual(expect.any(String));
+		expect(secondPage.items.map((item) => item.name)).toEqual([
+			"Alpha ${names.singularPascal}",
+		]);
+		expect(secondPage.page.nextCursor).toBeNull();
+		expect(nameAscendingPage.items.map((item) => item.name)).toEqual([
+			"Alpha ${names.singularPascal}",
+			"Beta ${names.singularPascal}",
+			"Gamma ${names.singularPascal}",
+		]);
+		expect(nameDescendingPage.items.map((item) => item.name)).toEqual([
+			"Gamma ${names.singularPascal}",
+			"Beta ${names.singularPascal}",
+			"Alpha ${names.singularPascal}",
+		]);
 		expect(created.name).toBe("First ${names.singularPascal}");
-		expect(result.total).toBe(1);
-		expect(result.${names.pluralCamel}).toEqual([created]);
+		expect(result.items).toEqual([created]);
+${mode === "resource"
+        ? `
+		const fetched = await tester.run(
+			get${names.singularPascal}UseCase,
+			{ id: created.id },
+			{ ctx },
+		);
+		const updated = await tester.run(
+			update${names.singularPascal}UseCase,
+			{ id: created.id, name: "Updated ${names.singularPascal}", version: fetched.version },
+			{ ctx },
+		);
+		try {
+			await tester.run(
+				update${names.singularPascal}UseCase,
+				{ id: created.id, name: "Stale ${names.singularPascal}", version: fetched.version },
+				{ ctx },
+			);
+			throw new Error("Expected ${names.singularPascal}Conflict");
+		} catch (error) {
+			expect(isAppError(error)).toBe(true);
+			if (isAppError(error)) {
+				expect(error.code).toBe("${constantCase(names.singularKebab)}_CONFLICT");
+			}
+		}
+		await tester.run(delete${names.singularPascal}UseCase, { id: created.id }, { ctx });
+		const afterDelete = await tester.run(
+			list${names.pluralPascal}UseCase,
+			{ name: "Updated" },
+			{ ctx },
+		);
+
+		expect(fetched).toEqual(created);
+		expect(updated.name).toBe("Updated ${names.singularPascal}");
+		expect(updated.version).toBe(fetched.version + 1);
+		expect(afterDelete.items).toEqual([]);
+
+		try {
+			await tester.run(get${names.singularPascal}UseCase, { id: created.id }, { ctx });
+			throw new Error("Expected ${names.singularPascal}NotFound");
+		} catch (error) {
+			expect(isAppError(error)).toBe(true);
+			if (isAppError(error)) {
+				expect(error.code).toBe("${constantCase(names.singularKebab)}_NOT_FOUND");
+			}
+		}
+`
+        : ""}
+
+		const app = await createTestApp({
+			ports: testFixture.ports,
+			routes: defineRoutes<AppContext>([${names.singularCamel}Routes]),
+			context: appContext,
+		});
+${options.tenant ? `\t\tconst requester = createTestRequester(app, {\n\t\t\theaders: { "x-tenant-id": "tenant_test" },\n\t\t});\n` : ""}
+		const createdViaRoute = await ${requestTarget}.request(create${names.singularPascal}, {
+			body: { name: "Second ${names.singularPascal}" },
+		});
+${mode === "resource" ? `		const fetchedViaRoute = await ${requestTarget}.request(get${names.singularPascal}, {\n			path: { id: createdViaRoute.id },\n		});\n		const updatedViaRoute = await ${requestTarget}.request(update${names.singularPascal}, {\n			path: { id: createdViaRoute.id },\n			body: { name: "Updated via route", version: fetchedViaRoute.version },\n		});\n` : ""}		const listedViaRoute = await ${requestTarget}.request(list${names.pluralPascal}, {
+			query: { name: "${mode === "resource" ? "Updated via route" : "Second"}" },
+		});
+${mode === "resource" ? `		const deletedViaRoute = await ${requestTarget}.request(delete${names.singularPascal}, {\n			path: { id: createdViaRoute.id },\n		});\n		const listedAfterDeleteViaRoute = await ${requestTarget}.request(list${names.pluralPascal}, {\n			query: { name: "Updated via route" },\n		});\n` : ""}		await app.stop();
+
+		expect(createdViaRoute.name).toBe("Second ${names.singularPascal}");
+${mode === "resource" ? `		expect(fetchedViaRoute).toEqual(createdViaRoute);\n		expect(updatedViaRoute.name).toBe("Updated via route");\n		expect(updatedViaRoute.version).toBe(fetchedViaRoute.version + 1);\n		expect(deletedViaRoute).toBeUndefined();\n		expect(listedViaRoute.items).toContainEqual(updatedViaRoute);\n		expect(listedAfterDeleteViaRoute.items).toEqual([]);\n` : `		expect(listedViaRoute.items).toContainEqual(createdViaRoute);\n`}
 	});
 });
 `;