@beignet/cli 0.0.38 → 0.0.40

package/dist/make.js

@@ -1,9 +1,12 @@
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { clientIndexPath, loadBeignetConfig, resolveConfig, } from "./config.js";
+import ts from "typescript";
+import { clientFormsPath, clientIndexPath, loadBeignetConfig, resolveConfig, } from "./config.js";
+import { assertNextFramework } from "./framework.js";
 import { adapterFilePath, addNamedImport, addNamedTypeImport, aliasModule, appendDeferredPortKey, appendPickStringLiteralMember, applyPortProviderWiring, assertAdapterApp, assertFeatureArtifactApp, assertFeatureUiApp, assertGeneratedIdentifiers, assertPersistenceArtifactApp, assertPolicyApp, assertPortApp, assertServerRuntimeApp, assertStandardApp, assertTestApp, assertUseCaseApp, beignetDependencyVersion, constantCase, createListenersRegistrySource, defineUploadsInitializerInfo, detectResourceDatabase, detectResourcePersistence, drizzleDialects, drizzleRepositoriesPath, drizzleResourceRepositoryFilePath, drizzleSchemaIndexPath, eventBusPortWiring, eventFilePath, factoryFilePath, featureArtifactDir, featureArtifactIndexFile, featureArtifactNames, featureResourceNames, featureUiClientQueriesFilePath, featureUiComponentFilePath, featureUiIndexFilePath, featureUiNames, fileExists, hasTopLevelObjectProperty, identifierNames, infrastructureDir, insertTypeProperty, jobFilePath, listenerFilePath, listenersFilePath, mergeMakeResultInto, mergeMakeResults, missingCapabilityBuilderFiles, notificationFilePath, notificationPortWirings, planGeneratedFile, planGeneratedFiles, portFilePath, portNames, providersFilePath, readOptionalFile, relativeModule, resourceContractFilePath, resourceFeatureDir, resourceNames, resourcePortFilePath, resourceSharedErrorsPath, scheduleFilePath, seedEntrypointPath, seedFilePath, seedNames, singularize, storagePortWiring, tanstackReactQueryDependencyVersion, taskFilePath, typeBodySource, uniqueStrings, updateDrizzleRepositories, updateDrizzleSchemaIndex, updateFeatureArtifactIndex, updateInfrastructureAdapterWiring, updateInfrastructureDeferredPorts, updateInfrastructureGatePolicies, updateInfrastructurePortStub, updateInfrastructurePorts, updateListenersRegistrySource, updateOpenApiRoute, updatePackageDependencies, updatePackageJson, updatePackageScripts, updatePortIndex, updatePortsIndex, updateSeedEntrypoint, updateServerRoutes, updateServerTransactionPorts, updateSharedErrors, uploadFilePath, useCaseFeatureDir, useCaseFilePath, usesFeatureOwnedPolicies, usesFeatureOwnedTests, wireListenersProviderSource, wirePortProviders, writeGeneratedFile, writePlannedGeneratedFile, } from "./make/shared.js";
-import { appendToArrayExpression, appendToOutboxRegistryArray, arrayInitializerInfo, identifiersFromArrayExpression, insertAfterImports, } from "./registry-edits.js";
+import { appendToArrayExpression, appendToNamedArray, appendToOutboxRegistryArray, arrayInitializerInfo, identifiersFromArrayExpression, insertAfterImports, } from "./registry-edits.js";
+import { externalVersions } from "./templates/shared.js";
 import { testSupportTemplateFiles } from "./templates/testing.js";
 export { makeFeatureAddonChoices, makeFeatureRecipeChoices, } from "./choices.js";
 export * from "./make/inbox.js";
@@ -17,7 +20,7 @@ export async function makeFeature(options) {
     const addons = normalizeMakeFeatureAddons([
         ...makeFeatureRecipeAddons(options.recipe),
         ...(options.with ?? []),
-        ...(options.events ? ["events"] : []),
+        ...(options.events ? ["event"] : []),
     ]);
     const featureOptions = {
         ...options,
@@ -122,30 +125,36 @@ async function makeResourceSlice(options, mode) {
 function resourceGenerationOptions(options, mode) {
     if (mode === "feature") {
         return {
-            auth: false,
-            tenant: false,
+            authorization: false,
+            tenantScoped: false,
             events: Boolean(options.events),
             softDelete: false,
         };
     }
     if (mode !== "resource") {
-        return { auth: false, tenant: false, events: false, softDelete: false };
+        return {
+            authorization: false,
+            tenantScoped: false,
+            events: false,
+            softDelete: false,
+        };
     }
     return {
-        auth: Boolean(options.auth),
-        tenant: Boolean(options.tenant),
+        authorization: Boolean(options.authorization),
+        tenantScoped: Boolean(options.tenantScoped),
         events: Boolean(options.events),
         softDelete: Boolean(options.softDelete),
     };
 }
 async function makeFeatureSlice(options, addons) {
     let result = await makeFeatureResource(options);
+    const includeUploadUi = addons.includes("ui") && addons.includes("upload");
     for (const addon of addons) {
-        result = mergeMakeResults(result, await makeFeatureAddon(addon, result.name, options));
+        result = mergeMakeResults(result, await makeFeatureAddon(addon, result.name, options, includeUploadUi));
     }
     return result;
 }
-async function makeFeatureAddon(addon, feature, options) {
+async function makeFeatureAddon(addon, feature, options, includeUploadUi) {
     const shared = {
         cwd: options.cwd,
         force: options.force,
@@ -158,69 +167,53 @@ async function makeFeatureAddon(addon, feature, options) {
     if (addon === "factory") {
         return makeFactory({
             ...shared,
-            name: `${feature}/${singularize(feature)}`,
+            name: `${feature}.${singularize(feature)}`,
             skipPersistenceAssert: true,
         });
     }
     if (addon === "task") {
-        return makeTask({ ...shared, name: `${feature}/backfill` });
+        return makeTask({ ...shared, name: `${feature}.backfill` });
     }
     if (addon === "event") {
-        return makeEvent({ ...shared, name: `${feature}/created` });
+        return makeEvent({ ...shared, name: `${feature}.created` });
     }
     if (addon === "job") {
-        return makeJob({ ...shared, name: `${feature}/process` });
+        return makeJob({ ...shared, name: `${feature}.process` });
     }
     if (addon === "listener") {
         return makeListener({
             ...shared,
-            name: `${feature}/handle-created`,
-            event: `${feature}/created`,
+            name: `${feature}.handle-created`,
+            event: `${feature}.created`,
             skipEventAssert: true,
         });
     }
     if (addon === "notification") {
-        return makeNotification({ ...shared, name: `${feature}/created` });
+        return makeNotification({ ...shared, name: `${feature}.created` });
     }
     if (addon === "schedule") {
-        return makeSchedule({ ...shared, name: `${feature}/daily-summary` });
+        return makeSchedule({ ...shared, name: `${feature}.daily-summary` });
     }
     if (addon === "seed") {
         return makeSeed({
             ...shared,
-            name: `${feature}/demo-${feature}`,
+            name: `${feature}.demo-${feature}`,
             skipPersistenceAssert: true,
         });
     }
     if (addon === "ui") {
         return makeFeatureUi({ ...shared, name: feature });
     }
-    return makeUpload({ ...shared, name: `${feature}/attachment` });
+    return makeUpload({
+        ...shared,
+        name: `${feature}.attachment`,
+        ui: includeUploadUi,
+    });
 }
 function normalizeMakeFeatureAddons(addons) {
     const normalized = new Set();
     for (const addon of addons) {
-        if (addon === "factories")
-            normalized.add("factory");
-        else if (addon === "events")
-            normalized.add("event");
-        else if (addon === "listeners") {
-            normalized.add("event");
-            normalized.add("listener");
-        }
-        else if (addon === "tasks")
-            normalized.add("task");
-        else if (addon === "jobs")
-            normalized.add("job");
-        else if (addon === "notifications")
-            normalized.add("notification");
-        else if (addon === "schedules")
-            normalized.add("schedule");
-        else if (addon === "seeds")
-            normalized.add("seed");
-        else if (addon === "uploads")
-            normalized.add("upload");
-        else if (addon === "listener") {
+        if (addon === "listener") {
             normalized.add("event");
             normalized.add("listener");
         }
@@ -233,16 +226,16 @@ function makeFeatureRecipeAddons(recipe) {
     if (recipe === "full-slice") {
         return [
             "policy",
-            "factories",
-            "seeds",
-            "tasks",
-            "events",
-            "listeners",
-            "jobs",
-            "notifications",
-            "schedules",
+            "factory",
+            "seed",
+            "task",
+            "event",
+            "listener",
+            "job",
+            "notification",
+            "schedule",
             "ui",
-            "uploads",
+            "upload",
         ];
     }
     return [];
@@ -328,7 +321,7 @@ export async function makeUseCase(options) {
         skippedFiles.push(indexFile.path);
     return {
         schemaVersion: 1,
-        name: `${names.feature.kebab}/${names.action.kebab}`,
+        name: `${names.feature.kebab}.${names.action.kebab}`,
         targetDir,
         dryRun: Boolean(options.dryRun),
         files: [...generatedFiles.map((file) => file.path), indexFile.path],
@@ -367,7 +360,7 @@ export async function makeTest(options) {
     }
     return {
         schemaVersion: 1,
-        name: `${names.feature.kebab}/${names.action.kebab}`,
+        name: `${names.feature.kebab}.${names.action.kebab}`,
         targetDir,
         dryRun: Boolean(options.dryRun),
         files: generatedFiles.map((file) => file.path),
@@ -529,7 +522,7 @@ export async function makeEvent(options) {
         config,
         force: Boolean(options.force),
         dryRun: Boolean(options.dryRun),
-        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        name: names.stableName,
         files: eventFiles(names, config),
         index: featureArtifactIndexFile("event", names, config),
         dependencies: {
@@ -570,7 +563,7 @@ export async function makeJob(options) {
         config,
         force: Boolean(options.force),
         dryRun: Boolean(options.dryRun),
-        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        name: names.stableName,
         files: [
             ...(await missingCapabilityBuilderFiles(targetDir, "jobs", config)),
             ...jobFiles(names, config),
@@ -603,7 +596,7 @@ export async function makeTask(options) {
         config,
         force: Boolean(options.force),
         dryRun: Boolean(options.dryRun),
-        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        name: names.stableName,
         files: [
             ...(await missingCapabilityBuilderFiles(targetDir, "tasks", config)),
             ...taskFiles(names, config),
@@ -641,7 +634,7 @@ export async function makeFactory(options) {
         config,
         force: Boolean(options.force),
         dryRun: Boolean(options.dryRun),
-        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        name: names.stableName,
         files: factoryFiles(names, config),
         index: featureArtifactIndexFile("factory", names, config),
         dependencies: {
@@ -663,7 +656,7 @@ export async function makeSeed(options) {
         config,
         force: Boolean(options.force),
         dryRun: Boolean(options.dryRun),
-        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        name: names.stableName,
         files: seedFiles(names, config),
         index: featureArtifactIndexFile("seed", names, config),
         dependencies: {
@@ -677,7 +670,7 @@ export async function makeSeed(options) {
             config,
             force: Boolean(options.force),
             dryRun: Boolean(options.dryRun),
-            name: `${factoryNamesForSeed.feature.kebab}/${factoryNamesForSeed.artifact.kebab}`,
+            name: factoryNamesForSeed.stableName,
             files: factoryFiles(factoryNamesForSeed, config),
             index: featureArtifactIndexFile("factory", factoryNamesForSeed, config),
             dependencies: {
@@ -714,7 +707,7 @@ export async function makeNotification(options) {
     // notifications uses ctx.ports.notifications, so the generator wires both
     // ports with dev-default providers. Each port is wired independently and
     // skipped when the app already has it, for example when the resend
-    // integration contributed the mailer. Plan the wiring before writing any
+    // provider contributed the mailer. Plan the wiring before writing any
     // files so an anchor miss aborts the generator without leaving partial
     // output.
     const notificationWirings = notificationPortWirings("make notification");
@@ -726,7 +719,7 @@ export async function makeNotification(options) {
         config,
         force: Boolean(options.force),
         dryRun: Boolean(options.dryRun),
-        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        name: names.stableName,
         files: [
             ...(await missingCapabilityBuilderFiles(targetDir, "notifications", config)),
             ...notificationFiles(names, config),
@@ -760,7 +753,7 @@ export async function makeListener(options) {
         config,
         force: Boolean(options.force),
         dryRun: Boolean(options.dryRun),
-        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        name: names.stableName,
         files: [
             ...(await missingCapabilityBuilderFiles(targetDir, "listeners", config)),
             ...listenerFiles(names, config),
@@ -832,7 +825,7 @@ async function assertListenerEventExists(targetDir, names, config) {
         await stat(path.join(targetDir, file));
     }
     catch {
-        throw new Error(`beignet make listener expected event ${names.eventName} at ${file}. Run beignet make event ${names.feature.kebab}/${names.artifact.kebab} first, or pass an event that exists.`);
+        throw new Error(`beignet make listener expected event ${names.eventName} at ${file}. Run beignet make event ${names.eventName} first, or pass an event that exists.`);
     }
 }
 async function updateListenerProviderWiring(targetDir, names, config, options) {
@@ -867,6 +860,9 @@ export async function makeSchedule(options) {
     const config = options.config
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
+    if (options.route) {
+        assertNextFramework(config, "beignet make schedule --route", "a Next.js App Router cron handler");
+    }
     await assertFeatureArtifactApp(targetDir, config, "schedule", {
         requireServer: Boolean(options.route),
     });
@@ -884,7 +880,7 @@ export async function makeSchedule(options) {
         config,
         force: Boolean(options.force),
         dryRun: Boolean(options.dryRun),
-        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        name: names.stableName,
         files,
         index: featureArtifactIndexFile("schedule", names, config),
         dependencies: {
@@ -1014,6 +1010,9 @@ async function updateOutboxPortWiring(targetDir, config, options) {
     if (await updateOutboxDatabaseProvider(targetDir, config, options)) {
         changes.updatedFiles.push(path.join(infrastructureDir(config), "db/provider.ts"));
     }
+    if (await updateOutboxDrainProvider(targetDir, config, options)) {
+        changes.updatedFiles.push(providersFilePath(config));
+    }
     if (await updateOutboxRepositoriesReturnType(targetDir, config, options)) {
         changes.updatedFiles.push(drizzleRepositoriesPath(config));
     }
@@ -1091,6 +1090,25 @@ async function updateOutboxInfrastructurePorts(targetDir, config, options) {
         await writeFile(filePath, next);
     return true;
 }
+async function projectSupportsNextAfter(targetDir) {
+    const packageJson = JSON.parse(await readFile(path.join(targetDir, "package.json"), "utf8"));
+    const version = packageJson.dependencies?.next ?? packageJson.devDependencies?.next;
+    if (!version)
+        return false;
+    return version.split("||").every((range) => {
+        const lowerBound = /^\s*(\^|~|>=|>|=|<=|<)?\s*v?(\d+)(?:\.(\d+|x|\*))?(?:\.(\d+|x|\*))?([+-][0-9A-Za-z.-]+)?(?=\s|$)/.exec(range);
+        if (!lowerBound)
+            return false;
+        const operator = lowerBound[1];
+        if (operator === "<" || operator === "<=")
+            return false;
+        if (lowerBound[5]?.startsWith("-"))
+            return false;
+        const major = Number(lowerBound[2]);
+        const minor = /^\d+$/.test(lowerBound[3] ?? "") ? Number(lowerBound[3]) : 0;
+        return major > 15 || (major === 15 && minor >= 1);
+    });
+}
 async function updateOutboxDatabaseProvider(targetDir, config, options) {
     const file = path.join(infrastructureDir(config), "db/provider.ts");
     const filePath = path.join(targetDir, file);
@@ -1145,6 +1163,68 @@ async function updateOutboxDatabaseProvider(targetDir, config, options) {
         await writeFile(filePath, next);
     return true;
 }
+async function updateOutboxDrainProvider(targetDir, config, options) {
+    if (!(await projectSupportsNextAfter(targetDir)))
+        return false;
+    const file = providersFilePath(config);
+    const filePath = path.join(targetDir, file);
+    const original = await readOptionalFile(filePath);
+    if (original === undefined) {
+        throw new Error(`Could not find the generated providers file ${file}. Register the outbox drain trigger manually, or restore the generated providers file before running make outbox.`);
+    }
+    let next = addNamedImport(original, "createObservedUnitOfWork", "@beignet/core/ports");
+    next = addNamedImport(next, "createProvider", "@beignet/core/providers");
+    next = addNamedImport(next, "createNextOutboxDrainTrigger", "@beignet/next");
+    next = addNamedImport(next, "after", "next/server");
+    next = addNamedTypeImport(next, "AppContext", aliasModule(config.paths.appContext));
+    next = addNamedTypeImport(next, "AppPorts", aliasModule(config.paths.ports));
+    next = addNamedTypeImport(next, "AppServiceContextInput", aliasModule(path.join(path.dirname(config.paths.server), "context.ts")));
+    const providerName = "outboxDrainProvider";
+    if (!new RegExp(`\\bconst\\s+${providerName}\\b`).test(next)) {
+        const outboxModule = aliasModule(config.paths.outbox);
+        const providerDefinition = `const ${providerName} = createProvider<
+\tPick<AppPorts, "uow">,
+\tAppContext,
+\tAppServiceContextInput
+>()({
+\tname: "outbox-drain-trigger",
+\tsetup({ ports, createServiceContext }): { ports: Pick<AppPorts, "uow"> } {
+\t\tconst triggerOutboxDrain: () => void = createNextOutboxDrainTrigger({
+\t\t\tdefer: after,
+\t\t\tcreateContext: () => createServiceContext(undefined),
+\t\t\tregistry: async () => (await import("${outboxModule}")).outboxRegistry,
+\t\t\tbatchSize: 100,
+\t\t});
+
+\t\treturn {
+\t\t\tports: {
+\t\t\t\tuow: createObservedUnitOfWork({
+\t\t\t\t\tunitOfWork: ports.uow,
+\t\t\t\t\tafterCommit: triggerOutboxDrain,
+\t\t\t\t}),
+\t\t\t},
+\t\t};
+\t},
+});
+`;
+        const withProvider = next.replace(/\nexport const providers = \[/, `\n${providerDefinition}\nexport const providers = [`);
+        if (withProvider === next) {
+            throw new Error(`Could not find the exported providers array in ${file}. Register outboxDrainProvider manually, or restore the generated providers file before running make outbox.`);
+        }
+        next = withProvider;
+    }
+    const appended = appendToNamedArray(next, "providers", providerName);
+    if (appended.kind === "missing") {
+        throw new Error(`Could not find the exported providers array in ${file}. Register outboxDrainProvider manually, or restore the generated providers file before running make outbox.`);
+    }
+    if (appended.kind === "updated")
+        next = appended.source;
+    if (next === original)
+        return false;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
 async function updateOutboxRepositoriesReturnType(targetDir, config, options) {
     const file = drizzleRepositoriesPath(config);
     const filePath = path.join(targetDir, file);
@@ -1251,7 +1331,11 @@ export async function makeUpload(options) {
     const config = options.config
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
+    assertNextFramework(config, "beignet make upload", "a Next.js App Router upload handler");
     await assertFeatureArtifactApp(targetDir, config, "upload");
+    if (options.ui) {
+        await assertUploadUiApp(targetDir, config);
+    }
     await wirePortProviders(targetDir, config, [storagePortWiring("make upload")], {
         dryRun: true,
     });
@@ -1260,10 +1344,10 @@ export async function makeUpload(options) {
         config,
         force: Boolean(options.force),
         dryRun: Boolean(options.dryRun),
-        name: `${names.feature.kebab}/${names.artifact.kebab}`,
+        name: names.stableName,
         files: [
             ...(await missingCapabilityBuilderFiles(targetDir, "uploads", config)),
-            ...uploadFiles(names, config),
+            ...uploadFiles(names, config, { ui: Boolean(options.ui) }),
         ],
         index: featureArtifactIndexFile("upload", names, config),
         dependencies: {
@@ -1283,6 +1367,31 @@ export async function makeUpload(options) {
     if (!result.files.includes(uploadRoutePath(config))) {
         result.files.push(uploadRoutePath(config));
     }
+    if (options.ui) {
+        const componentIndex = uploadUiComponentIndexFile(names, config);
+        const componentIndexResult = await updateFeatureUiIndex(targetDir, componentIndex, { dryRun: Boolean(options.dryRun) });
+        if (componentIndexResult === "created") {
+            result.createdFiles.push(componentIndex.path);
+        }
+        if (componentIndexResult === "updated") {
+            result.updatedFiles.push(componentIndex.path);
+        }
+        if (componentIndexResult === "skipped") {
+            result.skippedFiles.push(componentIndex.path);
+        }
+        if (!result.files.includes(componentIndex.path)) {
+            result.files.push(componentIndex.path);
+        }
+        if (await updatePackageDependencies(targetDir, { "@beignet/react-uploads": beignetDependencyVersion }, { dryRun: Boolean(options.dryRun) })) {
+            result.updatedFiles.push("package.json");
+            if (!result.files.includes("package.json")) {
+                result.files.push("package.json");
+            }
+        }
+    }
+    result.createdFiles = uniqueStrings(result.createdFiles);
+    result.updatedFiles = uniqueStrings(result.updatedFiles);
+    result.skippedFiles = uniqueStrings(result.skippedFiles);
     return result;
 }
 export async function makeOutbox(options = {}) {
@@ -1290,6 +1399,7 @@ export async function makeOutbox(options = {}) {
     const config = options.config
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
+    assertNextFramework(config, "beignet make outbox", "a Next.js App Router recovery drain handler");
     await assertServerRuntimeApp(targetDir, config, "outbox");
     await updateOutboxPortWiring(targetDir, config, { dryRun: true });
     const cronSecretPlan = await planCronSecretWiring(targetDir);
@@ -1333,6 +1443,9 @@ export async function makeOutbox(options = {}) {
             config.paths.ports,
             config.paths.portWiring,
             path.join(infrastructureDir(config), "db/provider.ts"),
+            ...((await projectSupportsNextAfter(targetDir))
+                ? [providersFilePath(config)]
+                : []),
             drizzleRepositoriesPath(config),
             outboxDrizzleSchemaFilePath(config),
             drizzleSchemaIndexPath(config),
@@ -1349,7 +1462,10 @@ async function makeFeatureUi(options) {
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
     await assertFeatureUiApp(targetDir, config);
-    const componentFiles = featureUiComponentFiles(names, config);
+    const componentFiles = [
+        ...(await missingFeatureUiFormsFiles(targetDir, config)),
+        ...featureUiComponentFiles(names, config),
+    ];
     const indexFile = featureUiIndexFile(names, config);
     const plannedFiles = await planGeneratedFiles(targetDir, componentFiles, {
         force: Boolean(options.force),
@@ -1378,8 +1494,13 @@ async function makeFeatureUi(options) {
     if (indexResult === "skipped")
         skippedFiles.push(indexFile.path);
     if (await updatePackageDependencies(targetDir, {
+        "@beignet/react-hook-form": beignetDependencyVersion,
         "@beignet/react-query": beignetDependencyVersion,
+        "@hookform/resolvers": (packageJson) => packageJson.dependencies?.["@hookform/resolvers"] ??
+            externalVersions.hookformResolvers,
         "@tanstack/react-query": tanstackReactQueryDependencyVersion,
+        "react-hook-form": (packageJson) => packageJson.dependencies?.["react-hook-form"] ??
+            externalVersions.reactHookForm,
     }, { dryRun: Boolean(options.dryRun) })) {
         updatedFiles.push("package.json");
     }
@@ -1467,7 +1588,7 @@ async function updateResourceWiring(targetDir, names, config, persistenceOrOptio
         (await updateInfrastructurePorts(targetDir, names, config, options))) {
         updated.add(config.paths.portWiring);
     }
-    if (generationOptions.auth &&
+    if (generationOptions.authorization &&
         (await updateInfrastructureGatePolicies(targetDir, names, config, options))) {
         updated.add(config.paths.portWiring);
     }
@@ -1505,11 +1626,10 @@ function typeHasTopLevelProperty(source, typeName, propertyName) {
 function useCaseNames(input) {
     const parts = input
         .trim()
-        .split("/")
-        .map((part) => part.trim())
-        .filter(Boolean);
-    if (parts.length !== 2) {
-        throw new Error("Use case name must use feature/action format, for example projects/archive-project.");
+        .split(".")
+        .map((part) => part.trim());
+    if (parts.length !== 2 || parts.some((part) => part.length === 0)) {
+        throw new Error("Use case name must use feature.action format, for example projects.archive-project.");
     }
     const feature = identifierNames(parts[0], "Use case feature");
     const action = identifierNames(parts[1], "Use case action");
@@ -1541,7 +1661,7 @@ function policyNames(input) {
     return resolvedNames;
 }
 function eventNames(input) {
-    const names = featureArtifactNames(normalizeEventReference(input), "Event");
+    const names = featureArtifactNames(input, "Event");
     const eventExportName = `${names.featureSingularPascal}${names.artifact.pascal}`;
     assertGeneratedIdentifiers(input, "Event name", [eventExportName]);
     return {
@@ -1587,7 +1707,7 @@ function factoryNames(input) {
     };
 }
 function defaultFactoryNamesForSeed(names) {
-    return factoryNames(`${names.feature.kebab}/${names.featureSingularKebab}`);
+    return factoryNames(`${names.feature.kebab}.${names.featureSingularKebab}`);
 }
 function notificationNames(input) {
     const names = featureArtifactNames(input, "Notification");
@@ -1631,24 +1751,26 @@ function scheduleNames(input, options) {
 function uploadNames(input) {
     const names = featureArtifactNames(input, "Upload");
     const uploadExportName = `${names.artifact.pascal}Upload`;
-    assertGeneratedIdentifiers(input, "Upload name", [uploadExportName]);
+    const componentExportName = `${names.artifact.pascal}Uploader`;
+    assertGeneratedIdentifiers(input, "Upload name", [
+        uploadExportName,
+        componentExportName,
+    ]);
     return {
         ...names,
         uploadName: names.stableName,
         uploadExportName,
         metadataSchemaName: `${uploadExportName}MetadataSchema`,
         metadataTypeName: `${uploadExportName}Metadata`,
+        fileConstraintsExportName: `${names.artifact.camel}UploadFile`,
+        manifestExportName: `${names.artifact.camel}UploadManifest`,
+        manifestFileName: `${names.artifact.kebab}-upload-manifest`,
+        reactUploadsExportName: `${names.artifact.camel}ReactUploads`,
+        clientFileName: `${names.artifact.kebab}-upload`,
+        componentExportName,
+        componentFileName: `${names.artifact.kebab}-uploader`,
     };
 }
-function normalizeEventReference(input) {
-    const trimmed = input.trim();
-    if (trimmed.includes("/"))
-        return trimmed;
-    const dotIndex = trimmed.indexOf(".");
-    if (dotIndex === -1)
-        return trimmed;
-    return `${trimmed.slice(0, dotIndex)}/${trimmed.slice(dotIndex + 1)}`;
-}
 function inferUseCaseKind(action) {
     if (/^(count|find|get|list|search)-/.test(`${action}-`)) {
         return "query";
@@ -1656,8 +1778,8 @@ function inferUseCaseKind(action) {
     return "command";
 }
 function resourceFiles(names, config, persistence = "memory", mode = "feature", options = {
-    auth: false,
-    tenant: false,
+    authorization: false,
+    tenantScoped: false,
     events: false,
     softDelete: false,
 }, database = "sqlite") {
@@ -1710,7 +1832,7 @@ function resourceFiles(names, config, persistence = "memory", mode = "feature",
                 },
             ]
             : []),
-        ...(mode === "resource" && options.auth
+        ...(mode === "resource" && options.authorization
             ? [
                 {
                     path: path.join(featureDir, "tests/policy.test.ts"),
@@ -1765,6 +1887,59 @@ function featureUiComponentFiles(names, config) {
         },
     ];
 }
+async function missingFeatureUiFormsFiles(targetDir, config) {
+    const formsPath = clientFormsPath(config);
+    const existing = await readOptionalFile(path.join(targetDir, formsPath));
+    if (existing === undefined) {
+        return [
+            {
+                path: formsPath,
+                content: `import { createReactHookForm } from "@beignet/react-hook-form";
+
+export const rhf = createReactHookForm();
+`,
+            },
+        ];
+    }
+    if (!sourceExportsValue(existing, "rhf")) {
+        throw new Error(`beignet make feature --with ui expects ${formsPath} to export rhf. Add \`export const rhf = createReactHookForm();\` from @beignet/react-hook-form, or move the existing helper before generating UI.`);
+    }
+    return [];
+}
+async function assertUploadUiApp(targetDir, config) {
+    const clientPath = clientIndexPath(config);
+    const clientSource = await readOptionalFile(path.join(targetDir, clientPath));
+    if (!clientSource || !sourceExportsValue(clientSource, "rq")) {
+        throw new Error(`beignet make upload --ui expects a full-stack Beignet app with ${clientPath} exporting rq. API-only apps stay backend-only; omit --ui or add the full-stack client setup first.`);
+    }
+}
+function sourceExportsValue(source, name) {
+    const sourceFile = ts.createSourceFile("client-forms.ts", source, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+    for (const statement of sourceFile.statements) {
+        const exported = ts.canHaveModifiers(statement) &&
+            ts
+                .getModifiers(statement)
+                ?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+        if (exported && ts.isVariableStatement(statement)) {
+            if (statement.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === name)) {
+                return true;
+            }
+        }
+        if (exported &&
+            ts.isFunctionDeclaration(statement) &&
+            statement.name?.text === name) {
+            return true;
+        }
+        if (ts.isExportDeclaration(statement) &&
+            !statement.isTypeOnly &&
+            statement.exportClause &&
+            ts.isNamedExports(statement.exportClause) &&
+            statement.exportClause.elements.some((element) => !element.isTypeOnly && element.name.text === name)) {
+            return true;
+        }
+    }
+    return false;
+}
 function featureUiIndexFile(names, config) {
     return {
         path: featureUiIndexFilePath(names, config),
@@ -1893,12 +2068,54 @@ function scheduleFiles(names, config, options) {
     }
     return files;
 }
-function uploadFiles(names, config) {
+function uploadFiles(names, config, options) {
     return [
+        {
+            path: uploadManifestFilePath(names, config),
+            content: uploadManifestFile(names),
+        },
         {
             path: uploadFilePath(names, config),
             content: uploadFile(names, config),
         },
+        ...(options.ui ? uploadUiFiles(names, config) : []),
+    ];
+}
+function uploadFeatureDir(names, config) {
+    return path.join(config.paths.features, names.feature.kebab);
+}
+function uploadManifestFilePath(names, config) {
+    return path.join(uploadFeatureDir(names, config), `${names.manifestFileName}.ts`);
+}
+function uploadUiClientFilePath(names, config) {
+    return path.join(uploadFeatureDir(names, config), "client", `${names.clientFileName}.ts`);
+}
+function uploadUiComponentFilePath(names, config) {
+    return path.join(uploadFeatureDir(names, config), "components", `${names.componentFileName}.tsx`);
+}
+function uploadUiComponentTestFilePath(names, config) {
+    return path.join(uploadFeatureDir(names, config), "tests", `${names.componentFileName}.test.tsx`);
+}
+function uploadUiComponentIndexFile(names, config) {
+    return {
+        path: path.join(uploadFeatureDir(names, config), "components", "index.ts"),
+        content: `export { ${names.componentExportName} } from "./${names.componentFileName}";\n`,
+    };
+}
+function uploadUiFiles(names, config) {
+    return [
+        {
+            path: uploadUiClientFilePath(names, config),
+            content: uploadUiClientFile(names, config),
+        },
+        {
+            path: uploadUiComponentFilePath(names, config),
+            content: uploadUiComponentFile(names, config),
+        },
+        {
+            path: uploadUiComponentTestFilePath(names, config),
+            content: uploadUiComponentTestFile(names, config),
+        },
     ];
 }
 function outboxFiles(config) {
@@ -2204,7 +2421,7 @@ function schemasFile(names, mode, options) {
 
 export const ${names.singularPascal}Schema = z.object({
 	id: z.string().uuid(),
-${options.tenant ? `\ttenantId: z.string().min(1),\n` : ""}	name: z.string().min(1),
+${options.tenantScoped ? `\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(),
@@ -2304,7 +2521,7 @@ export const List${names.pluralPascal}OutputSchema = z.object({
 });
 
 export const Create${names.singularPascal}InputSchema = z.object({
-	name: z.string().min(1).max(120),
+	name: z.string().trim().min(1).max(120),
 });
 ${mode === "resource"
         ? `
@@ -2313,7 +2530,7 @@ export const ${names.singularPascal}IdInputSchema = z.object({
 });
 
 export const Update${names.singularPascal}BodySchema = z.object({
-	name: z.string().min(1).max(120),
+	name: z.string().trim().min(1).max(120),
 	version: z.number().int().min(1),
 });
 
@@ -2347,7 +2564,7 @@ function listUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `list-${names.pluralKebab}.ts`);
     return `import "@beignet/core/server-only";
 import { normalizeCursorPage } from "@beignet/core/pagination";
-${options.tenant ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+${options.tenantScoped ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
 	decode${names.singularPascal}Cursor,
 	List${names.pluralPascal}InputSchema,
@@ -2359,7 +2576,7 @@ export const list${names.pluralPascal}UseCase = useCase
 	.input(List${names.pluralPascal}InputSchema)
 	.output(List${names.pluralPascal}OutputSchema)
 	.run(async ({ ctx, input }) => {
-${options.tenant ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}		const page = normalizeCursorPage(input, {
+${options.tenantScoped ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}		const page = normalizeCursorPage(input, {
 			defaultLimit: 20,
 			maxLimit: 100,
 		});
@@ -2370,14 +2587,14 @@ ${options.tenant ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}		const
 			name: input.name,
 			sortBy: input.sortBy,
 			sortDirection: input.sortDirection,
-		}${options.tenant ? ", scope" : ""});
+		}${options.tenantScoped ? ", scope" : ""});
 	});
 `;
 }
 function createUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `create-${names.singularKebab}.ts`);
     return `import "@beignet/core/server-only";
-${options.tenant ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+${options.tenantScoped ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
 	Create${names.singularPascal}InputSchema,
 	${names.singularPascal}Schema,
@@ -2389,7 +2606,7 @@ export const create${names.singularPascal}UseCase = useCase
 	.input(Create${names.singularPascal}InputSchema)
 	.output(${names.singularPascal}Schema)
 	.run(async ({ ctx, input }) => {
-${options.tenant ? `\t\tconst scope = requireTenantScope(ctx);\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 ? ", scope" : ""});
+${options.tenantScoped ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}${options.authorization ? `\t\tawait ctx.gate.authorize("${names.pluralCamel}.create");\n\n` : ""}		const ${names.singularCamel} = await ctx.ports.${names.pluralCamel}.create(input${options.tenantScoped ? ", scope" : ""});
 ${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};
 	});
@@ -2398,7 +2615,7 @@ ${options.events ? `\n\t\tawait ctx.ports.eventBus.publish(${names.singularPasca
 function getUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `get-${names.singularKebab}.ts`);
     return `import "@beignet/core/server-only";
-${options.tenant ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
+${options.tenantScoped ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
 import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
 	${names.singularPascal}IdInputSchema,
@@ -2410,7 +2627,7 @@ export const get${names.singularPascal}UseCase = useCase
 	.input(${names.singularPascal}IdInputSchema)
 	.output(${names.singularPascal}Schema)
 	.run(async ({ ctx, input }) => {
-${options.tenant ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}		const ${names.singularCamel} = await ctx.ports.${names.pluralCamel}.findById(input.id${options.tenant ? ", scope" : ""});
+${options.tenantScoped ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}		const ${names.singularCamel} = await ctx.ports.${names.pluralCamel}.findById(input.id${options.tenantScoped ? ", scope" : ""});
 		if (!${names.singularCamel}) {
 			throw appError("${names.singularPascal}NotFound", {
 				details: { id: input.id },
@@ -2424,7 +2641,7 @@ ${options.tenant ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}		const
 function updateUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `update-${names.singularKebab}.ts`);
     return `import "@beignet/core/server-only";
-${options.tenant ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
+${options.tenantScoped ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}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,
@@ -2436,13 +2653,13 @@ export const update${names.singularPascal}UseCase = useCase
 	.input(Update${names.singularPascal}InputSchema)
 	.output(${names.singularPascal}Schema)
 	.run(async ({ ctx, input }) => {
-${options.tenant ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}		const existing = await ctx.ports.${names.pluralCamel}.findById(input.id${options.tenant ? ", scope" : ""});
+${options.tenantScoped ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}		const existing = await ctx.ports.${names.pluralCamel}.findById(input.id${options.tenantScoped ? ", scope" : ""});
 		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) {
+${options.authorization ? `\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 },
 			});
@@ -2450,7 +2667,7 @@ ${options.auth ? `\t\tawait ctx.gate.authorize("${names.pluralCamel}.update", ex
 
 		const ${names.singularCamel} = await ctx.ports.${names.pluralCamel}.update({
 			...input,
-		}${options.tenant ? ", scope" : ""});
+		}${options.tenantScoped ? ", scope" : ""});
 		if (!${names.singularCamel}) {
 			throw appError("${names.singularPascal}Conflict", {
 				details: { id: input.id, expectedVersion: existing.version },
@@ -2465,7 +2682,7 @@ function deleteUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `delete-${names.singularKebab}.ts`);
     return `import "@beignet/core/server-only";
 import { z } from "zod";
-${options.tenant ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
+${options.tenantScoped ? `import { requireTenantScope } from "@beignet/core/tenancy";\n` : ""}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";
 
@@ -2474,7 +2691,7 @@ export const delete${names.singularPascal}UseCase = useCase
 	.input(${names.singularPascal}IdInputSchema)
 	.output(z.void())
 	.run(async ({ ctx, input }) => {
-${options.tenant ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}${options.auth ? `\t\tconst existing = await ctx.ports.${names.pluralCamel}.findById(input.id${options.tenant ? ", scope" : ""});\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 ? ", scope" : ""});
+${options.tenantScoped ? `\t\tconst scope = requireTenantScope(ctx);\n\n` : ""}${options.authorization ? `\t\tconst existing = await ctx.ports.${names.pluralCamel}.findById(input.id${options.tenantScoped ? ", scope" : ""});\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.tenantScoped ? ", scope" : ""});
 		if (!deleted) {
 			throw appError("${names.singularPascal}NotFound", {
 				details: { id: input.id },
@@ -2504,7 +2721,7 @@ function repositoryPortFile(names, config, mode, options) {
 	PageResult,
 	SortDirection,
 } from "@beignet/core/pagination";
-${options.tenant ? `import type { TenantScope } from "@beignet/core/tenancy";\n` : ""}import type {
+${options.tenantScoped ? `import type { TenantScope } from "@beignet/core/tenancy";\n` : ""}import type {
 	Create${names.singularPascal}Input,
 	${names.singularPascal}Cursor,
 	${names.singularPascal}SortBy,
@@ -2521,9 +2738,9 @@ export type List${names.pluralPascal}Query = {
 };
 
 export interface ${names.singularPascal}Repository {
-	list(query: List${names.pluralPascal}Query${options.tenant ? ", scope: TenantScope" : ""}): Promise<List${names.pluralPascal}Result>;
-	create(input: Create${names.singularPascal}Input${options.tenant ? ", scope: TenantScope" : ""}): Promise<${names.singularPascal}>;
-${mode === "resource" ? `	findById(id: string${options.tenant ? ", scope: TenantScope" : ""}): Promise<${names.singularPascal} | null>;\n	update(input: Update${names.singularPascal}Input${options.tenant ? ", scope: TenantScope" : ""}): Promise<${names.singularPascal} | null>;\n	delete(id: string${options.tenant ? ", scope: TenantScope" : ""}): Promise<boolean>;\n` : ""}}
+	list(query: List${names.pluralPascal}Query${options.tenantScoped ? ", scope: TenantScope" : ""}): Promise<List${names.pluralPascal}Result>;
+	create(input: Create${names.singularPascal}Input${options.tenantScoped ? ", scope: TenantScope" : ""}): Promise<${names.singularPascal}>;
+${mode === "resource" ? `	findById(id: string${options.tenantScoped ? ", scope: TenantScope" : ""}): Promise<${names.singularPascal} | null>;\n	update(input: Update${names.singularPascal}Input${options.tenantScoped ? ", scope: TenantScope" : ""}): Promise<${names.singularPascal} | null>;\n	delete(id: string${options.tenantScoped ? ", scope: TenantScope" : ""}): Promise<boolean>;\n` : ""}}
 `;
 }
 function inMemoryRepositoryFile(names, config, mode, options) {
@@ -2551,13 +2768,13 @@ function inMemoryRepositoryFile(names, config, mode, options) {
         ? " || existing.deletedAt !== null"
         : "";
     const deleteImplementation = options.softDelete
-        ? `${options.tenant ? `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (!existing || existing.tenantId !== 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();
+        ? `${options.tenantScoped ? `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (!existing || existing.tenantId !== 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 !== tenantId) return false;\n` : ""}			return ${names.pluralCamel}.delete(id);`;
+        : `${options.tenantScoped ? `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (existing?.tenantId !== tenantId) return false;\n` : ""}			return ${names.pluralCamel}.delete(id);`;
     return `import "@beignet/core/server-only";
 import { cursorPageResult } from "@beignet/core/pagination";
-${options.tenant ? `import { tenantScopeId } from "@beignet/core/tenancy";\n` : ""}import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+${options.tenantScoped ? `import { tenantScopeId } from "@beignet/core/tenancy";\n` : ""}import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
 import { encode${names.singularPascal}Cursor } from "${aliasModule(resourceSchemaFilePath(names, config))}";
 import type {
 	Create${names.singularPascal}Input,
@@ -2567,7 +2784,7 @@ ${mode === "resource" ? `	Update${names.singularPascal}Input,\n` : ""}	${names.s
 ${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,
+${options.tenantScoped ? `\t\ttenantId: ${names.singularCamel}.tenantId,\n` : ""}		name: ${names.singularCamel}.name,
 		version: ${names.singularCamel}.version,
 		createdAt: ${names.singularCamel}.createdAt,
 		updatedAt: ${names.singularCamel}.updatedAt,
@@ -2625,10 +2842,10 @@ export function createInMemory${names.singularPascal}Repository(
 	);
 
 	return {
-		async list(query${options.tenant ? ", scope" : ""}) {
+		async list(query${options.tenantScoped ? ", scope" : ""}) {
 			const name = query.name?.toLocaleLowerCase();
-${options.tenant ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}			const all${names.pluralPascal} = Array.from(${names.pluralCamel}.values())
-${activeFilter}${options.tenant ? `\t\t\t\t.filter((${names.singularCamel}) => ${names.singularCamel}.tenantId === tenantId)\n` : ""}				.filter((${names.singularCamel}) => !name || ${names.singularCamel}.name.toLocaleLowerCase().includes(name))
+${options.tenantScoped ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}			const all${names.pluralPascal} = Array.from(${names.pluralCamel}.values())
+${activeFilter}${options.tenantScoped ? `\t\t\t\t.filter((${names.singularCamel}) => ${names.singularCamel}.tenantId === 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);
@@ -2643,11 +2860,11 @@ ${activeFilter}${options.tenant ? `\t\t\t\t.filter((${names.singularCamel}) => $
 				nextCursor,
 			);
 		},
-		async create(input${options.tenant ? ", scope" : ""}) {
+		async create(input${options.tenantScoped ? ", scope" : ""}) {
 			const now = new Date().toISOString();
-${options.tenant ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}			const ${names.singularCamel}: ${names.singularPascal} = {
+${options.tenantScoped ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}			const ${names.singularCamel}: ${names.singularPascal} = {
 				id: crypto.randomUUID(),
-${options.tenant ? `\t\t\t\ttenantId,\n` : ""}				name: input.name,
+${options.tenantScoped ? `\t\t\t\ttenantId,\n` : ""}				name: input.name,
 				version: 1,
 				createdAt: now,
 				updatedAt: now,
@@ -2657,7 +2874,7 @@ ${options.tenant ? `\t\t\t\ttenantId,\n` : ""}				name: input.name,
 ${newDeletedAtField}			});
 			return ${names.singularCamel};
 		},
-${mode === "resource" ? `		async findById(id: string${options.tenant ? ", scope" : ""}) {\n${options.tenant ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}			const ${names.singularCamel} = ${names.pluralCamel}.get(id) ?? null;\n${options.tenant ? `\t\t\tif (${names.singularCamel}?.tenantId !== tenantId) return null;\n` : ""}${findDeletedGuard}			return ${names.singularCamel} ? to${names.singularPascal}(${names.singularCamel}) : null;\n		},\n		async update(input${options.tenant ? ", scope" : ""}) {\n${options.tenant ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}			const existing = ${names.pluralCamel}.get(input.id);\n			if (!existing${options.tenant ? " || existing.tenantId !== 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 ? ", scope" : ""}) {\n${options.tenant ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}${deleteImplementation}\n		},\n` : ""}
+${mode === "resource" ? `		async findById(id: string${options.tenantScoped ? ", scope" : ""}) {\n${options.tenantScoped ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}			const ${names.singularCamel} = ${names.pluralCamel}.get(id) ?? null;\n${options.tenantScoped ? `\t\t\tif (${names.singularCamel}?.tenantId !== tenantId) return null;\n` : ""}${findDeletedGuard}			return ${names.singularCamel} ? to${names.singularPascal}(${names.singularCamel}) : null;\n		},\n		async update(input${options.tenantScoped ? ", scope" : ""}) {\n${options.tenantScoped ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}			const existing = ${names.pluralCamel}.get(input.id);\n			if (!existing${options.tenantScoped ? " || existing.tenantId !== 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.tenantScoped ? ", scope" : ""}) {\n${options.tenantScoped ? `\t\t\tconst tenantId = tenantScopeId(scope);\n` : ""}${deleteImplementation}\n		},\n` : ""}
 	};
 }
 `;
@@ -2667,7 +2884,7 @@ function drizzleSchemaFile(names, options, dialect) {
 
 export const ${names.pluralCamel} = ${dialect.tableFunction}("${names.pluralKebab.replaceAll("-", "_")}", {
 	id: ${dialect.idColumn("id")}.primaryKey(),
-${options.tenant ? `\ttenantId: ${dialect.idColumn("tenant_id")}.notNull(),\n` : ""}	name: text("name").notNull(),
+${options.tenantScoped ? `\ttenantId: ${dialect.idColumn("tenant_id")}.notNull(),\n` : ""}	name: text("name").notNull(),
 	version: ${dialect.integerColumn("version")}.notNull(),
 	createdAt: ${dialect.timestampColumn("created_at")}.notNull(),
 	updatedAt: ${dialect.timestampColumn("updated_at")}.notNull(),
@@ -2764,20 +2981,20 @@ function drizzleRepositoryFile(names, config, mode, options, dialect) {
     const schemaPath = drizzleSchemaIndexPath(config);
     const findWhere = drizzleResourceWhere(names, options, [
         `eq(schema.${names.pluralCamel}.id, id)`,
-        ...(options.tenant
+        ...(options.tenantScoped
             ? [`eq(schema.${names.pluralCamel}.tenantId, tenantScopeId(scope))`]
             : []),
     ]);
     const updateWhere = drizzleResourceWhere(names, options, [
         `eq(schema.${names.pluralCamel}.id, input.id)`,
         `eq(schema.${names.pluralCamel}.version, input.version)`,
-        ...(options.tenant
+        ...(options.tenantScoped
             ? [`eq(schema.${names.pluralCamel}.tenantId, tenantScopeId(scope))`]
             : []),
     ]);
     const deleteWhere = drizzleResourceWhere(names, options, [
         `eq(schema.${names.pluralCamel}.id, id)`,
-        ...(options.tenant
+        ...(options.tenantScoped
             ? [`eq(schema.${names.pluralCamel}.tenantId, tenantScopeId(scope))`]
             : []),
     ]);
@@ -2795,7 +3012,7 @@ function drizzleRepositoryFile(names, config, mode, options, dialect) {
     ].filter((name) => Boolean(name));
     // After a version-guarded update succeeds, re-select by identity only —
     // matching what `.returning()` yields on the dialects that support it.
-    const updateReselectWhere = options.tenant
+    const updateReselectWhere = options.tenantScoped
         ? `and(eq(schema.${names.pluralCamel}.id, input.id), eq(schema.${names.pluralCamel}.tenantId, tenantScopeId(scope)))`
         : `eq(schema.${names.pluralCamel}.id, input.id)`;
     // drizzle-orm/mysql2 has no `.returning(...)`; mutations resolve to a
@@ -2817,13 +3034,13 @@ function affectedRows(result: unknown): number {
 `
         : "";
     const createMethod = dialect.supportsReturning
-        ? `		async create(input${options.tenant ? ", scope" : ""}) {
+        ? `		async create(input${options.tenantScoped ? ", scope" : ""}) {
 			const now = new Date().toISOString();
 			const [row] = await db
 				.insert(schema.${names.pluralCamel})
 				.values({
 					id: crypto.randomUUID(),
-${options.tenant ? `\t\t\t\t\ttenantId: tenantScopeId(scope),\n` : ""}					name: input.name,
+${options.tenantScoped ? `\t\t\t\t\ttenantId: tenantScopeId(scope),\n` : ""}					name: input.name,
 					version: 1,
 					createdAt: now,
 					updatedAt: now,
@@ -2837,11 +3054,11 @@ ${options.tenant ? `\t\t\t\t\ttenantId: tenantScopeId(scope),\n` : ""}					name:
 			return to${names.singularPascal}(row);
 		},
 `
-        : `		async create(input${options.tenant ? ", scope" : ""}) {
+        : `		async create(input${options.tenantScoped ? ", scope" : ""}) {
 			const now = new Date().toISOString();
 			const ${names.singularCamel}: ${names.singularPascal} = {
 				id: crypto.randomUUID(),
-${options.tenant ? `\t\t\t\ttenantId: tenantScopeId(scope),\n` : ""}				name: input.name,
+${options.tenantScoped ? `\t\t\t\ttenantId: tenantScopeId(scope),\n` : ""}				name: input.name,
 				version: 1,
 				createdAt: now,
 				updatedAt: now,
@@ -2854,7 +3071,7 @@ ${options.tenant ? `\t\t\t\ttenantId: tenantScopeId(scope),\n` : ""}				name: in
     const resourceMethods = mode !== "resource"
         ? ""
         : dialect.supportsReturning
-            ? `		async findById(id: string${options.tenant ? ", scope" : ""}) {
+            ? `		async findById(id: string${options.tenantScoped ? ", scope" : ""}) {
 			const [row] = await db
 				.select()
 				.from(schema.${names.pluralCamel})
@@ -2863,7 +3080,7 @@ ${options.tenant ? `\t\t\t\ttenantId: tenantScopeId(scope),\n` : ""}				name: in
 
 			return row ? to${names.singularPascal}(row) : null;
 		},
-		async update(input${options.tenant ? ", scope" : ""}) {
+		async update(input${options.tenantScoped ? ", scope" : ""}) {
 			const [row] = await db
 				.update(schema.${names.pluralCamel})
 				.set({
@@ -2876,12 +3093,12 @@ ${options.tenant ? `\t\t\t\ttenantId: tenantScopeId(scope),\n` : ""}				name: in
 
 			return row ? to${names.singularPascal}(row) : null;
 		},
-		async delete(id: string${options.tenant ? ", scope" : ""}) {
+		async delete(id: string${options.tenantScoped ? ", scope" : ""}) {
 ${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`}
 			return rows.length > 0;
 		},
 `
-            : `		async findById(id: string${options.tenant ? ", scope" : ""}) {
+            : `		async findById(id: string${options.tenantScoped ? ", scope" : ""}) {
 			const [row] = await db
 				.select()
 				.from(schema.${names.pluralCamel})
@@ -2890,7 +3107,7 @@ ${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst
 
 			return row ? to${names.singularPascal}(row) : null;
 		},
-		async update(input${options.tenant ? ", scope" : ""}) {
+		async update(input${options.tenantScoped ? ", scope" : ""}) {
 			const result = await db
 				.update(schema.${names.pluralCamel})
 				.set({
@@ -2910,14 +3127,14 @@ ${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst
 
 			return row ? to${names.singularPascal}(row) : null;
 		},
-		async delete(id: string${options.tenant ? ", scope" : ""}) {
+		async delete(id: string${options.tenantScoped ? ", scope" : ""}) {
 ${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst result = 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\tconst result = await db\n\t\t\t\t.delete(schema.${names.pluralCamel})\n\t\t\t\t.where(${deleteWhere});\n`}
 			return affectedRows(result) > 0;
 		},
 `;
     return `import "@beignet/core/server-only";
 import { cursorPageResult } from "@beignet/core/pagination";
-${options.tenant ? `import { tenantScopeId } from "@beignet/core/tenancy";\n` : ""}import type { ${dialect.dbTypeName} } from "@beignet/provider-db-drizzle/${dialect.subpath}";
+${options.tenantScoped ? `import { tenantScopeId } from "@beignet/core/tenancy";\n` : ""}import type { ${dialect.dbTypeName} } from "@beignet/provider-db-drizzle/${dialect.subpath}";
 import { ${drizzleImports.join(", ")} } from "drizzle-orm";
 import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
 import { encode${names.singularPascal}Cursor } from "${aliasModule(resourceSchemaFilePath(names, config))}";
@@ -2932,7 +3149,7 @@ type ${names.singularPascal}Row = typeof schema.${names.pluralCamel}.$inferSelec
 function to${names.singularPascal}(row: ${names.singularPascal}Row): ${names.singularPascal} {
 	return {
 		id: row.id,
-${options.tenant ? `\t\ttenantId: row.tenantId,\n` : ""}		name: row.name,
+${options.tenantScoped ? `\t\ttenantId: row.tenantId,\n` : ""}		name: row.name,
 		version: row.version,
 		createdAt: row.createdAt,
 		updatedAt: row.updatedAt,
@@ -2964,9 +3181,9 @@ function ${names.singularCamel}CursorFilter(
 
 function ${names.singularCamel}ListWhere(
 	query: List${names.pluralPascal}Query,
-${options.tenant ? `\tscope: Parameters<${names.singularPascal}Repository["list"]>[1],\n` : ""}): SQL<unknown> | undefined {
+${options.tenantScoped ? `\tscope: Parameters<${names.singularPascal}Repository["list"]>[1],\n` : ""}): SQL<unknown> | undefined {
 	const filters: SQL<unknown>[] = [
-${options.tenant ? `\t\teq(schema.${names.pluralCamel}.tenantId, tenantScopeId(scope)),\n` : ""}${options.softDelete ? `\t\tisNull(schema.${names.pluralCamel}.deletedAt),\n` : ""}	];
+${options.tenantScoped ? `\t\teq(schema.${names.pluralCamel}.tenantId, tenantScopeId(scope)),\n` : ""}${options.softDelete ? `\t\tisNull(schema.${names.pluralCamel}.deletedAt),\n` : ""}	];
 	const cursor = ${names.singularCamel}CursorFilter(query);
 
 	if (query.name) {
@@ -3000,8 +3217,8 @@ export function createDrizzle${names.singularPascal}Repository(
 	db: ${dialect.dbTypeName}<typeof schema>,
 ): ${names.singularPascal}Repository {
 	return {
-		async list(query${options.tenant ? ", scope" : ""}) {
-			const where = ${names.singularCamel}ListWhere(query${options.tenant ? ", scope" : ""});
+		async list(query${options.tenantScoped ? ", scope" : ""}) {
+			const where = ${names.singularCamel}ListWhere(query${options.tenantScoped ? ", scope" : ""});
 			const rows = await db
 				.select()
 				.from(schema.${names.pluralCamel})
@@ -3057,7 +3274,7 @@ export const list${names.pluralPascal} = ${names.pluralCamel}
 export const create${names.singularPascal} = ${names.pluralCamel}
 	.post("/api/${names.pluralKebab}")
 	.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({
+${options.authorization ? `	.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"
@@ -3074,7 +3291,7 @@ 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 })
+${options.authorization ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization: { ability: "${names.pluralCamel}.update" },\n\t})\n` : ""}	.errors({${options.authorization ? " Unauthorized: errors.Unauthorized, Forbidden: errors.Forbidden," : ""} ${names.singularPascal}NotFound: errors.${names.singularPascal}NotFound, ${names.singularPascal}Conflict: errors.${names.singularPascal}Conflict })
 	.responses({
 		200: ${names.singularPascal}Schema,
 	});
@@ -3082,7 +3299,7 @@ ${options.auth ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization: { ability
 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 })
+${options.authorization ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization: { ability: "${names.pluralCamel}.delete" },\n\t})\n` : ""}	.errors({${options.authorization ? " Unauthorized: errors.Unauthorized, Forbidden: errors.Forbidden," : ""} ${names.singularPascal}NotFound: errors.${names.singularPascal}NotFound })
 	.responses({
 		204: null,
 	});
@@ -3266,7 +3483,7 @@ function isAuthenticated(ctx: AuthorizationContext) {
 
 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;
+${options.tenantScoped ? `\tif (!ctx.tenant?.id) return deny("A tenant is required.");\n` : ""}	return true;
 }
 
 export const ${names.singularCamel}Policy = definePolicy({
@@ -3276,13 +3493,13 @@ export const ${names.singularCamel}Policy = definePolicy({
 	"${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` : ""}
+${options.tenantScoped ? `\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` : ""}
+${options.tenantScoped ? `\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) =>
@@ -3329,7 +3546,7 @@ 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}",
+${options.tenantScoped ? `\t\ttenantId: "tenant_test",\n` : ""}		name: "Test ${names.singularPascal}",
 		version: 1,
 		createdAt: now,
 		updatedAt: now,
@@ -3344,7 +3561,7 @@ describe("${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` : ""}		};
+${options.tenantScoped ? `\t\t\ttenant: { id: "tenant_test" },\n` : ""}		};
 
 		await expect(
 			tester.assertMatrix([
@@ -3546,8 +3763,32 @@ ${names.timezone ? `\t\ttimezone: "${names.timezone}",\n` : ""}\t\tpayload: ${na
 );
 `;
 }
+function uploadManifestFile(names) {
+    return `import type {
+\tUploadFileConstraints,
+\tUploadManifestEntry,
+} from "@beignet/core/uploads";
+
+export const ${names.fileConstraintsExportName} = {
+\tcontentTypes: ["application/pdf", "text/plain"],
+\tmaxSizeBytes: 5 * 1024 * 1024,
+\tmaxFiles: 1,
+\tvisibility: "private",
+\tcacheControl: "private, max-age=0",
+} satisfies UploadFileConstraints;
+
+export const ${names.manifestExportName} = [
+\t{
+\t\tname: "${names.uploadName}",
+\t\tdescription: "${names.artifact.pascal} upload",
+\t\tfile: ${names.fileConstraintsExportName},
+\t},
+] satisfies readonly UploadManifestEntry[];
+`;
+}
 function uploadFile(names, config) {
     return `import { z } from "zod";
+import { ${names.fileConstraintsExportName} } from "${relativeModule(uploadFilePath(names, config), uploadManifestFilePath(names, config))}";
 import { defineUpload } from "${aliasModule(config.paths.uploadsBuilder)}";
 
 export const ${names.metadataSchemaName} = z.object({
@@ -3558,13 +3799,7 @@ export type ${names.metadataTypeName} = z.infer<typeof ${names.metadataSchemaNam
 
 export const ${names.uploadExportName} = defineUpload("${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},
+\tfile: ${names.fileConstraintsExportName},
 \tauthorize({ ctx }) {
 \t\treturn ctx.actor.type === "user";
 \t},
@@ -3594,6 +3829,127 @@ export const ${names.uploadExportName} = defineUpload("${names.uploadName}", {
 });
 `;
 }
+function uploadUiClientFile(names, config) {
+    const clientPath = uploadUiClientFilePath(names, config);
+    const registryPath = path.join(featureArtifactDir(names, "uploads", config), "index.ts");
+    return `import { createUploadClient } from "@beignet/core/uploads/client";
+import { createReactUploads } from "@beignet/react-uploads";
+import { ${names.manifestExportName} } from "${relativeModule(clientPath, uploadManifestFilePath(names, config))}";
+import type { ${names.featureSingularCamel}Uploads } from "${relativeModule(clientPath, registryPath)}";
+
+const ${names.artifact.camel}UploadClient = createUploadClient<typeof ${names.featureSingularCamel}Uploads>({
+\tbaseUrl: "/api/uploads",
+\tmanifest: ${names.manifestExportName},
+});
+
+export const ${names.reactUploadsExportName} = createReactUploads({
+\tuploads: ${names.artifact.camel}UploadClient,
+});
+`;
+}
+function uploadUiComponentFile(names, config) {
+    const componentPath = uploadUiComponentFilePath(names, config);
+    return `"use client";
+
+import { useId } from "react";
+import { ${names.reactUploadsExportName} } from "${relativeModule(componentPath, uploadUiClientFilePath(names, config))}";
+
+export type ${names.componentExportName}Props = {
+\tresourceId: string;
+\tdisabled?: boolean;
+\tonComplete?(objectKeys: readonly string[]): void | Promise<void>;
+};
+
+export function ${names.componentExportName}({
+\tresourceId,
+\tdisabled = false,
+\tonComplete,
+}: ${names.componentExportName}Props) {
+\tconst inputId = useId();
+\tconst upload = ${names.reactUploadsExportName}.useUpload("${names.uploadName}", {
+\t\tonSuccess({ result }) {
+\t\t\treturn onComplete?.(result.objectKeys);
+\t\t},
+\t});
+\tconst maxSizeMb = upload.constraints?.maxSizeBytes
+\t\t? Math.round(upload.constraints.maxSizeBytes / 1024 / 1024)
+\t\t: undefined;
+
+\treturn (
+\t\t<section className="${names.artifact.kebab}-uploader">
+\t\t\t<label htmlFor={inputId}>${names.artifact.pascal}</label>
+\t\t\t<input
+\t\t\t\tid={inputId}
+\t\t\t\ttype="file"
+\t\t\t\taccept={upload.accept}
+\t\t\t\tdisabled={disabled || upload.isUploading}
+\t\t\t\tonChange={(event) => {
+\t\t\t\t\tconst file = event.currentTarget.files?.[0];
+\t\t\t\t\tevent.currentTarget.value = "";
+\t\t\t\t\tif (!file) return;
+
+\t\t\t\t\tupload.uploadFile(file, {
+\t\t\t\t\t\tmetadata: { resourceId },
+\t\t\t\t\t});
+\t\t\t\t}}
+\t\t\t/>
+\t\t\t<p>
+\t\t\t\tPDF or plain text{maxSizeMb ? <> up to {maxSizeMb} MB</> : null}.
+\t\t\t</p>
+
+\t\t\t{upload.files[0] ? <p>{upload.files[0].fileName}</p> : null}
+\t\t\t{upload.isUploading ? (
+\t\t\t\t<div aria-live="polite">
+\t\t\t\t\t<progress
+\t\t\t\t\t\taria-label="Upload progress"
+\t\t\t\t\t\tmax={100}
+\t\t\t\t\t\tvalue={upload.progress}
+\t\t\t\t\t/>
+\t\t\t\t\t<span>{Math.round(upload.progress)}%</span>
+\t\t\t\t\t<button type="button" onClick={upload.abort}>
+\t\t\t\t\t\tCancel upload
+\t\t\t\t\t</button>
+\t\t\t\t</div>
+\t\t\t) : null}
+\t\t\t{upload.isError ? (
+\t\t\t\t<p role="alert">{uploadErrorMessage(upload.error)}</p>
+\t\t\t) : null}
+\t\t\t{upload.isSuccess ? <p role="status">Upload complete.</p> : null}
+\t\t\t{upload.isError || upload.isSuccess ? (
+\t\t\t\t<button type="button" onClick={upload.reset}>
+\t\t\t\t\tReset upload
+\t\t\t\t</button>
+\t\t\t) : null}
+\t\t</section>
+\t);
+}
+
+function uploadErrorMessage(error: unknown): string {
+\treturn error instanceof Error ? error.message : "Upload failed.";
+}
+`;
+}
+function uploadUiComponentTestFile(names, config) {
+    const testPath = uploadUiComponentTestFilePath(names, config);
+    const testHelperPath = path.join(path.dirname(config.paths.useCaseBuilder), "beignet-test.ts");
+    return `import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, test } from "${relativeModule(testPath, testHelperPath)}";
+import { ${names.manifestExportName} } from "${relativeModule(testPath, uploadManifestFilePath(names, config))}";
+import { ${names.componentExportName} } from "${relativeModule(testPath, uploadUiComponentFilePath(names, config))}";
+
+describe("${names.componentExportName}", () => {
+\ttest("renders the generated upload constraints", () => {
+\t\tconst markup = renderToStaticMarkup(
+\t\t\t<${names.componentExportName} resourceId="resource-1" />,
+\t\t);
+
+\t\texpect(${names.manifestExportName}[0]?.file.maxSizeBytes).toBe(5 * 1024 * 1024);
+\t\texpect(markup).toContain('accept="application/pdf,text/plain"');
+\t\texpect(markup).toContain("PDF or plain text");
+\t});
+});
+`;
+}
 function uploadRouteFile(names, config) {
     const registryName = `${names.featureSingularCamel}Uploads`;
     return `import {
@@ -3682,63 +4038,70 @@ function featureUiComponentFile(names, config) {
     const clientQueriesPath = featureUiClientQueriesFilePath(names, config);
     return `"use client";
 
-import { contractErrorMessage } from "@beignet/core/client";
+import { rootFormError } from "@beignet/react-hook-form";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { useState } from "react";
+import { rhf } from "${aliasModule(clientFormsPath(config))}";
+import { create${names.singularPascal} } from "${relativeModule(componentPath, resourceContractFilePath(names, config))}";
 import {
 \tcreate${names.singularPascal}MutationOptions,
 \tinvalidate${names.pluralPascal},
 \tlist${names.pluralPascal}QueryOptions,
 } from "${relativeModule(componentPath, clientQueriesPath)}";
 
+const create${names.singularPascal}Form = rhf(create${names.singularPascal});
+
 export function ${names.componentExportName}() {
-\tconst [name, setName] = useState("");
 \tconst queryClient = useQueryClient();
 \tconst ${names.pluralCamel}Query = useQuery(list${names.pluralPascal}QueryOptions());
+\tconst form = create${names.singularPascal}Form.useForm({
+\t\tdefaultValues: { name: "" },
+\t});
+\tconst name = form.watch("name");
 \tconst create${names.singularPascal}Mutation = useMutation({
 \t\t...create${names.singularPascal}MutationOptions(),
 \t\tonSuccess: async () => {
-\t\t\tsetName("");
+\t\t\tform.reset({ name: "" });
 \t\t\tawait invalidate${names.pluralPascal}(queryClient);
 \t\t},
+\t\tonError: (error) => {
+\t\t\tform.setError(
+\t\t\t\t"root",
+\t\t\t\trootFormError(error, "Could not create ${names.singularKebab}."),
+\t\t\t);
+\t\t},
 \t});
 
 \treturn (
 \t\t<section className="${names.pluralKebab}-panel">
 \t\t\t<form
 \t\t\t\tclassName="${names.pluralKebab}-composer"
-\t\t\t\tonSubmit={(event) => {
-\t\t\t\t\tevent.preventDefault();
-\t\t\t\t\tconst trimmedName = name.trim();
-\t\t\t\t\tif (!trimmedName) return;
+\t\t\t\tonSubmit={form.handleSubmit((values) => {
+\t\t\t\t\tform.clearErrors("root");
 \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\tbody: values,
 \t\t\t\t\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\t{...form.register("name")}
 \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\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{form.formState.errors.name ? (
+\t\t\t\t\t<p role="alert">{form.formState.errors.name.message}</p>
+\t\t\t\t) : null}
+\t\t\t\t{form.formState.errors.root ? (
+\t\t\t\t\t<p role="alert">{form.formState.errors.root.message}</p>
 \t\t\t\t) : null}
 \t\t\t</form>
 
@@ -3852,7 +4215,7 @@ ${mode === "resource" ? `import { isAppError } from "@beignet/core/errors";\n` :
 import { createTestApp } from "@beignet/web/testing";
 import { createInMemoryDevtools } from "@beignet/devtools";
 import { createTestContextFactory, createTestPorts } from "@beignet/core/testing";
-import { ${options.auth ? "createTestUserActor" : "createTestAnonymousActor"}${options.tenant ? ", createTestTenant" : ""} } from "@beignet/core/testing";
+import { ${options.authorization ? "createTestUserActor" : "createTestAnonymousActor"}${options.tenantScoped ? ", createTestTenant" : ""} } from "@beignet/core/testing";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
 import { initialPorts } from "${aliasModule(config.paths.portWiring)}";
 import { appContext } from "${aliasModule(serverContextPath)}";
@@ -3872,39 +4235,39 @@ describe("${names.pluralCamel} resource", () => {
 		const seed${names.pluralPascal} = [
 			{
 				id: "00000000-0000-4000-8000-000000000101",
-${options.tenant ? `\t\t\t\ttenantId: "tenant_test",\n` : ""}				name: "Alpha ${names.singularPascal}",
+${options.tenantScoped ? `\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}",
+${options.tenantScoped ? `\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}",
+${options.tenantScoped ? `\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` : ""}		];
+${options.tenantScoped ? `\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: initialPorts,
 			overrides: {
 				${names.pluralCamel},
-${options.auth || options.tenant
+${options.authorization || options.tenantScoped
         ? `\t\t\t\tauth: {
 					getSession: async () => ({
-						user: { id: "user_test", name: "Test User"${options.tenant ? `, tenantId: "tenant_test"` : ""} },
-${options.tenant ? `\t\t\t\t\t\tsession: { tenantId: "tenant_test" },\n` : ""}
+						user: { id: "user_test", name: "Test User"${options.tenantScoped ? `, tenantId: "tenant_test"` : ""} },
+${options.tenantScoped ? `\t\t\t\t\t\tsession: { tenantId: "tenant_test" },\n` : ""}
 					}),
 				},
-${options.auth ? `\t\t\t\tgate: initialPorts.gate,\n` : ""}
+${options.authorization ? `\t\t\t\tgate: initialPorts.gate,\n` : ""}
 `
         : `\t\t\t\tauth: {
 					getSession: async () => null,
@@ -3919,8 +4282,8 @@ ${options.auth ? `\t\t\t\tgate: initialPorts.gate,\n` : ""}
 		});
 		const createTestContext = createTestContextFactory<AppContext, AppContext["ports"]>({
 			ports: testFixture.ports,
-			actor: ${options.auth ? `createTestUserActor("user_test")` : "createTestAnonymousActor()"},
-			tenant: ${options.tenant ? `createTestTenant("tenant_test")` : "null"},
+			actor: ${options.authorization ? `createTestUserActor("user_test")` : "createTestAnonymousActor()"},
+			tenant: ${options.tenantScoped ? `createTestTenant("tenant_test")` : "null"},
 		});
 		const tester = createUseCaseTester<AppContext>(createTestContext);