@beignet/cli 0.0.26 → 0.0.28

package/dist/make.js

@@ -1,44 +1,14 @@
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { clientIndexPath, directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
-import { appendToArrayExpression, appendToNamedArray, appendToOutboxRegistryArray, arrayInitializerInfo, identifiersFromArrayExpression, insertAfterImports, matchingDelimiterIndex, } from "./registry-edits.js";
+import { clientIndexPath, loadBeignetConfig, resolveConfig, } from "./config.js";
+import { adapterFilePath, addNamedImport, addNamedTypeImport, aliasModule, appendDeferredPortKey, appendPickStringLiteralMember, applyPortProviderWiring, assertAdapterApp, assertFeatureArtifactApp, assertFeatureUiApp, assertGeneratedIdentifiers, assertPersistenceArtifactApp, assertPolicyApp, assertPortApp, assertServerRuntimeApp, assertStandardApp, assertTestApp, assertUseCaseApp, beignetDependencyVersion, constantCase, 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, 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, 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";
 export { makeFeatureAddonChoices, makeFeatureRecipeChoices, } from "./choices.js";
-const drizzleDialects = {
-    sqlite: {
-        subpath: "sqlite",
-        dbTypeName: "DrizzleSqliteDatabase",
-        columnModule: "drizzle-orm/sqlite-core",
-        tableFunction: "sqliteTable",
-        schemaImports: ["integer", "sqliteTable", "text"],
-        supportsReturning: true,
-        idColumn: (columnName) => `text("${columnName}")`,
-        timestampColumn: (columnName) => `text("${columnName}")`,
-        integerColumn: (columnName) => `integer("${columnName}")`,
-    },
-    postgres: {
-        subpath: "postgres",
-        dbTypeName: "DrizzlePostgresDatabase",
-        columnModule: "drizzle-orm/pg-core",
-        tableFunction: "pgTable",
-        schemaImports: ["integer", "pgTable", "text"],
-        supportsReturning: true,
-        idColumn: (columnName) => `text("${columnName}")`,
-        timestampColumn: (columnName) => `text("${columnName}")`,
-        integerColumn: (columnName) => `integer("${columnName}")`,
-    },
-    mysql: {
-        subpath: "mysql",
-        dbTypeName: "DrizzleMysqlDatabase",
-        columnModule: "drizzle-orm/mysql-core",
-        tableFunction: "mysqlTable",
-        schemaImports: ["int", "mysqlTable", "text", "varchar"],
-        supportsReturning: false,
-        idColumn: (columnName) => `varchar("${columnName}", { length: 36 })`,
-        timestampColumn: (columnName) => `varchar("${columnName}", { length: 32 })`,
-        integerColumn: (columnName) => `int("${columnName}")`,
-    },
-};
+export * from "./make/inbox.js";
+export * from "./make/payments.js";
+export * from "./make/shared.js";
+export * from "./make/tenancy.js";
 export async function makeResource(options) {
     return makeResourceSlice(options, "resource");
 }
@@ -61,56 +31,6 @@ export async function makeFeature(options) {
     await makeFeatureSlice({ ...featureOptions, dryRun: true }, addons);
     return makeFeatureSlice(featureOptions, addons);
 }
-export async function makePayments(options) {
-    const targetDir = path.resolve(options.cwd ?? process.cwd());
-    const config = options.config
-        ? resolveConfig(options.config)
-        : await loadBeignetConfig(targetDir);
-    await assertStandardApp(targetDir, config);
-    const persistence = await detectResourcePersistence(targetDir, config);
-    if (persistence !== "drizzle") {
-        throw new Error("beignet make payments expects a Drizzle-backed Beignet app because billing state must be durable. Add a database provider first, then run make payments again.");
-    }
-    const database = await detectResourceDatabase(targetDir, config);
-    const generatedFiles = paymentsFiles(config, database);
-    const plannedFiles = await planGeneratedFiles(targetDir, generatedFiles, {
-        force: Boolean(options.force),
-    });
-    const billingNames = resourceNames("billing");
-    const plannedBillingUpdates = await updatePaymentsWiring(targetDir, billingNames, config, { dryRun: true });
-    const plannedPaymentsUpdates = (await wirePortProviders(targetDir, config, [paymentsPortWiring("make payments")], { dryRun: true })).updatedFiles;
-    const createdFiles = plannedFiles
-        .filter((file) => file.result === "created")
-        .map((file) => file.path);
-    const updatedFiles = plannedFiles
-        .filter((file) => file.result === "updated")
-        .map((file) => file.path);
-    const skippedFiles = plannedFiles
-        .filter((file) => file.result === "skipped")
-        .map((file) => file.path);
-    if (options.dryRun) {
-        updatedFiles.push(...plannedBillingUpdates, ...plannedPaymentsUpdates);
-    }
-    else {
-        for (const file of plannedFiles) {
-            await writePlannedGeneratedFile(targetDir, file);
-        }
-        updatedFiles.push(...(await updatePaymentsWiring(targetDir, billingNames, config, {
-            dryRun: false,
-        })));
-        updatedFiles.push(...(await wirePortProviders(targetDir, config, [paymentsPortWiring("make payments")], { dryRun: false })).updatedFiles);
-    }
-    return {
-        schemaVersion: 1,
-        name: "payments",
-        targetDir,
-        dryRun: Boolean(options.dryRun),
-        files: generatedFiles.map((file) => file.path),
-        createdFiles,
-        updatedFiles: uniqueStrings(updatedFiles),
-        skippedFiles,
-    };
-}
 async function makeFeatureResource(options) {
     try {
         return await makeResourceSlice(options, "feature");
@@ -339,33 +259,6 @@ const featureAddonOrder = [
     "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 mergeMakeResultInto(target, source) {
-    target.files = uniqueStrings([...target.files, ...source.files]);
-    target.createdFiles = uniqueStrings([
-        ...target.createdFiles,
-        ...source.createdFiles,
-    ]);
-    target.updatedFiles = uniqueStrings([
-        ...target.updatedFiles,
-        ...source.updatedFiles,
-    ]);
-    target.skippedFiles = uniqueStrings([
-        ...target.skippedFiles,
-        ...source.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);
@@ -898,63 +791,19 @@ async function updateListenerProviderWiring(targetDir, names, config, options) {
         throw new Error(`Could not find the generated providers file ${providersFile}. Register listeners manually with registerListeners(...), or restore the generated providers file before running make listener.`);
     }
     const listenerIndex = featureArtifactIndexFile("listener", names, config);
-    const providerName = `${names.featureSingularCamel}ListenersProvider`;
-    let next = original;
-    next = addNamedImport(next, "registerListeners", "@beignet/core/events");
-    next = addNamedImport(next, "createServiceActor", "@beignet/core/ports");
-    next = addNamedImport(next, "createProvider", "@beignet/core/providers");
-    next = addNamedTypeImport(next, "AppContext", aliasModule(config.paths.appContext));
-    next = addNamedTypeImport(next, "AppServiceContextInput", aliasModule(path.join(path.dirname(config.paths.server), "context.ts")));
-    next = addNamedTypeImport(next, "AppPorts", aliasModule(config.paths.ports));
-    const listenerImport = `import { ${listenerIndex.registryName} } from "${aliasModule(listenerIndex.path)}";`;
-    if (!next.includes(listenerImport)) {
-        next = insertAfterImports(next, listenerImport);
-    }
-    if (!new RegExp(`\\bconst\\s+${providerName}\\b`).test(next)) {
-        const providerDefinition = `const ${providerName} = createProvider<
-\tPick<AppPorts, "eventBus" | "logger">,
-\tAppContext,
-\tAppServiceContextInput
->()({
-\tname: "${names.feature.kebab}-listeners",
-\tsetup({ ports, createServiceContext }) {
-\t\tconst unregister = registerListeners(ports.eventBus, ${listenerIndex.registryName}, {
-\t\t\tctx: () =>
-\t\t\t\tcreateServiceContext({
-\t\t\t\t\tactor: createServiceActor("beignet-listener"),
-\t\t\t\t}),
-\t\t\tonError(error, listener) {
-\t\t\t\tports.logger.error("Event listener failed", {
-\t\t\t\t\terror,
-\t\t\t\t\tlistenerName: listener.name,
-\t\t\t\t});
-\t\t\t},
-\t\t});
-
-\t\treturn {
-\t\t\tstop() {
-\t\t\t\tunregister();
-\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 ${providersFile}. Register ${listenerIndex.registryName} manually with registerListeners(...), or restore the generated providers file before running make listener.`);
-        }
-        next = withProvider;
-    }
-    const appended = appendToNamedArray(next, "providers", providerName);
-    if (appended.kind === "missing") {
+    const result = wireListenersProviderSource(original, {
+        registryName: listenerIndex.registryName,
+        featureKebab: names.feature.kebab,
+        listenerModule: aliasModule(listenerIndex.path),
+        config,
+    });
+    if (result.kind === "missing") {
         throw new Error(`Could not find the exported providers array in ${providersFile}. Register ${listenerIndex.registryName} manually with registerListeners(...), or restore the generated providers file before running make listener.`);
     }
-    if (appended.kind === "updated")
-        next = appended.source;
-    if (next === original)
+    if (result.kind === "unchanged")
         return "skipped";
     if (!options.dryRun)
-        await writeFile(filePath, next);
+        await writeFile(filePath, result.source);
     return "updated";
 }
 export async function makeSchedule(options) {
@@ -1315,171 +1164,6 @@ async function applyOutboxDrainWiring(result, targetDir, plan, options) {
         ...plan.cronSecret.skippedFiles,
     ]);
 }
-function eventBusPortWiring(command) {
-    return {
-        command,
-        portKey: "eventBus",
-        portType: "EventBusPort",
-        portTypeModule: "@beignet/core/ports",
-        providerFactory: "createInMemoryEventBusProvider",
-        providerModule: "@beignet/provider-event-bus-memory",
-        dependency: "@beignet/provider-event-bus-memory",
-    };
-}
-function notificationPortWirings(command) {
-    return [
-        {
-            command,
-            portKey: "mailer",
-            portType: "MailerPort",
-            portTypeModule: "@beignet/core/mail",
-            providerFactory: "createMemoryMailerProvider",
-            providerModule: "@beignet/core/mail",
-        },
-        {
-            command,
-            portKey: "notifications",
-            portType: "NotificationPort",
-            portTypeModule: "@beignet/core/notifications",
-            providerFactory: "createInlineNotificationsProvider",
-            providerModule: "@beignet/core/notifications",
-        },
-    ];
-}
-function paymentsPortWiring(command) {
-    return {
-        command,
-        portKey: "payments",
-        portType: "PaymentsPort",
-        portTypeModule: "@beignet/core/payments",
-        providerFactory: "createMemoryPaymentsProvider",
-        providerModule: "@beignet/core/payments",
-    };
-}
-function storagePortWiring(command) {
-    return {
-        command,
-        portKey: "storage",
-        portType: "StoragePort",
-        portTypeModule: "@beignet/core/ports",
-        providerFactory: "createLocalStorageProvider",
-        providerModule: "@beignet/provider-storage-local",
-        dependency: "@beignet/provider-storage-local",
-    };
-}
-function providersFilePath(config) {
-    return `${directoryPath(path.dirname(config.paths.server))}/providers.ts`;
-}
-/**
- * Wire provider-backed app ports a generator depends on.
- *
- * Each wiring is independent and skipped silently when its port key already
- * appears in the ports file, so apps that wired their own adapter (or scaffolds
- * whose integrations already contribute the port) are left untouched. All
- * anchors are computed before any file is written; an anchor miss aborts with a
- * copy-pasteable manual instruction so the generator never leaves partial
- * wiring behind. Callers validate anchors with `dryRun: true` before writing
- * artifact files.
- */
-async function wirePortProviders(targetDir, config, wirings, options) {
-    const portsFile = config.paths.ports;
-    const infrastructureFile = config.paths.infrastructurePorts;
-    const providersFile = providersFilePath(config);
-    const manualFor = (wiring) => `Wire the ${wiring.portKey} port manually: add ${wiring.portKey}: ${wiring.portType}; to AppPorts in ${portsFile}, defer "${wiring.portKey}" in ${infrastructureFile}, and register ${wiring.providerFactory}() from ${wiring.providerModule} in ${providersFile}.`;
-    const portsOriginal = await readOptionalFile(path.join(targetDir, portsFile));
-    if (portsOriginal === undefined) {
-        if (wirings.length === 0)
-            return { updatedFiles: [] };
-        throw new Error(`Could not find the generated ports file ${portsFile}. ${manualFor(wirings[0])}`);
-    }
-    // A port key that already appears in the ports file means the app wired its
-    // own adapter or an integration already contributes the port.
-    const active = wirings.filter((wiring) => !new RegExp(`\\b${wiring.portKey}\\b`).test(portsOriginal));
-    if (active.length === 0)
-        return { updatedFiles: [] };
-    let portsNext = portsOriginal;
-    for (const wiring of active) {
-        portsNext = addNamedTypeImport(portsNext, wiring.portType, wiring.portTypeModule);
-        portsNext = insertTypeProperty(portsNext, "AppPorts", `${wiring.portKey}: ${wiring.portType};`, `Could not find AppPorts in ${portsFile}. ${manualFor(wiring)} Or restore the generated ports file before running beignet ${wiring.command}.`);
-    }
-    const infrastructureOriginal = await readOptionalFile(path.join(targetDir, infrastructureFile));
-    if (infrastructureOriginal === undefined) {
-        throw new Error(`Could not find the generated infrastructure ports file ${infrastructureFile}. ${manualFor(active[0])}`);
-    }
-    let infrastructureNext = infrastructureOriginal;
-    for (const wiring of active) {
-        const appended = appendDeferredPortKey(infrastructureNext, wiring.portKey);
-        if (appended === infrastructureNext &&
-            !new RegExp(`["']${wiring.portKey}["']`).test(infrastructureNext)) {
-            throw new Error(`Could not find the deferred port list in ${infrastructureFile}. ${manualFor(wiring)} Or restore the generated infrastructure ports file before running beignet ${wiring.command}.`);
-        }
-        infrastructureNext = appended;
-    }
-    const providersOriginal = await readOptionalFile(path.join(targetDir, providersFile));
-    if (providersOriginal === undefined) {
-        throw new Error(`Could not find the generated providers file ${providersFile}. ${manualFor(active[0])}`);
-    }
-    let providersNext = providersOriginal;
-    for (const wiring of active) {
-        if (new RegExp(`\\b${wiring.providerFactory}\\b`).test(providersNext)) {
-            continue;
-        }
-        const appended = appendToNamedArray(providersNext, "providers", `${wiring.providerFactory}()`, `import { ${wiring.providerFactory} } from "${wiring.providerModule}";`);
-        if (appended.kind === "missing") {
-            throw new Error(`Could not find the exported providers array in ${providersFile}. ${manualFor(wiring)} Or restore the generated providers file before running beignet ${wiring.command}.`);
-        }
-        if (appended.kind === "updated")
-            providersNext = appended.source;
-    }
-    const dependencies = active.filter((wiring) => wiring.dependency !== undefined);
-    let packageJsonNext;
-    if (dependencies.length > 0) {
-        const packageJsonOriginal = await readFile(path.join(targetDir, "package.json"), "utf8");
-        const packageJson = JSON.parse(packageJsonOriginal);
-        packageJson.dependencies = packageJson.dependencies ?? {};
-        for (const wiring of dependencies) {
-            packageJson.dependencies[wiring.dependency] ??=
-                beignetDependencyVersion(packageJson);
-        }
-        const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
-        if (next !== packageJsonOriginal)
-            packageJsonNext = next;
-    }
-    const plannedFiles = [];
-    if (portsNext !== portsOriginal) {
-        plannedFiles.push({ path: portsFile, content: portsNext });
-    }
-    if (infrastructureNext !== infrastructureOriginal) {
-        plannedFiles.push({
-            path: infrastructureFile,
-            content: infrastructureNext,
-        });
-    }
-    if (providersNext !== providersOriginal) {
-        plannedFiles.push({ path: providersFile, content: providersNext });
-    }
-    if (packageJsonNext !== undefined) {
-        plannedFiles.push({ path: "package.json", content: packageJsonNext });
-    }
-    if (!options.dryRun) {
-        for (const file of plannedFiles) {
-            await writeFile(path.join(targetDir, file.path), file.content);
-        }
-    }
-    return { updatedFiles: plannedFiles.map((file) => file.path) };
-}
-/**
- * Record port provider wiring updates on a make result.
- */
-async function applyPortProviderWiring(result, targetDir, config, wirings, options) {
-    const wired = await wirePortProviders(targetDir, config, wirings, options);
-    for (const file of wired.updatedFiles) {
-        if (!result.updatedFiles.includes(file))
-            result.updatedFiles.push(file);
-        if (!result.files.includes(file))
-            result.files.push(file);
-    }
-}
 export async function makeUpload(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     const names = uploadNames(options.name);
@@ -1626,247 +1310,6 @@ async function makeFeatureUi(options) {
         skippedFiles,
     };
 }
-async function assertStandardApp(targetDir, config) {
-    const requiredFiles = [
-        config.paths.appContext,
-        config.paths.infrastructurePorts,
-        config.paths.ports,
-        config.paths.server,
-        config.paths.useCaseBuilder,
-    ];
-    for (const file of requiredFiles) {
-        try {
-            await stat(path.join(targetDir, file));
-        }
-        catch {
-            throw new Error(`beignet make resource expects a standard Beignet app. Missing ${file}.`);
-        }
-    }
-}
-async function assertUseCaseApp(targetDir, config) {
-    try {
-        await stat(path.join(targetDir, config.paths.useCaseBuilder));
-    }
-    catch {
-        throw new Error(`beignet make use-case expects a standard Beignet app. Missing ${config.paths.useCaseBuilder}.`);
-    }
-}
-async function assertTestApp(targetDir, names, config) {
-    const requiredFiles = [
-        config.paths.appContext,
-        config.paths.infrastructurePorts,
-        useCaseFilePath(names, config),
-    ];
-    for (const file of requiredFiles) {
-        try {
-            await stat(path.join(targetDir, file));
-        }
-        catch {
-            throw new Error(`beignet make test expects a standard Beignet app with the target use case. Missing ${file}.`);
-        }
-    }
-}
-async function assertPortApp(targetDir, config) {
-    const requiredFiles = [config.paths.ports, config.paths.infrastructurePorts];
-    for (const file of requiredFiles) {
-        try {
-            await stat(path.join(targetDir, file));
-        }
-        catch {
-            throw new Error(`beignet make port expects a standard Beignet app. Missing ${file}.`);
-        }
-    }
-}
-async function assertAdapterApp(targetDir, names, config) {
-    const requiredFiles = [
-        config.paths.infrastructurePorts,
-        portFilePath(names, config),
-    ];
-    for (const file of requiredFiles) {
-        try {
-            await stat(path.join(targetDir, file));
-        }
-        catch {
-            throw new Error(`beignet make adapter expects an existing port in a standard Beignet app. Missing ${file}.`);
-        }
-    }
-    const infrastructurePorts = await readFile(path.join(targetDir, config.paths.infrastructurePorts), "utf8");
-    if (!infrastructurePorts.includes(portStubEntry(names)) &&
-        !infrastructurePorts.includes(adapterEntry(names))) {
-        throw new Error(`Could not find the generated ${names.interfaceName} infrastructure stub in ${config.paths.infrastructurePorts}. Wire ${names.adapterFactoryName}() manually or restore the generated stub before running make adapter.`);
-    }
-}
-async function assertPolicyApp(targetDir, config) {
-    try {
-        await stat(path.join(targetDir, config.paths.appContext));
-    }
-    catch {
-        throw new Error(`beignet make policy expects a standard Beignet app. Missing ${config.paths.appContext}.`);
-    }
-}
-async function assertFeatureArtifactApp(targetDir, config, artifact, options = {}) {
-    const requiredFiles = [
-        config.paths.appContext,
-        ...(options.requireServer ? [config.paths.server] : []),
-    ];
-    for (const file of requiredFiles) {
-        try {
-            await stat(path.join(targetDir, file));
-        }
-        catch {
-            throw new Error(`beignet make ${artifact} expects a standard Beignet app. Missing ${file}.`);
-        }
-    }
-}
-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 assertServerRuntimeApp(targetDir, config, artifact) {
-    const requiredFiles = [
-        config.paths.appContext,
-        config.paths.server,
-        config.paths.infrastructurePorts,
-    ];
-    for (const file of requiredFiles) {
-        try {
-            await stat(path.join(targetDir, file));
-        }
-        catch {
-            throw new Error(`beignet make ${artifact} expects a standard Beignet app with a server runtime. 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,
-    });
-    if (!options.dryRun) {
-        await writePlannedGeneratedFile(targetDir, plannedFile);
-    }
-    return plannedFile.result;
-}
-async function planGeneratedFiles(targetDir, files, options) {
-    const plannedFiles = [];
-    for (const file of files) {
-        plannedFiles.push(await planGeneratedFile(targetDir, file, options));
-    }
-    return plannedFiles;
-}
-async function planGeneratedFile(targetDir, file, options) {
-    const destination = path.join(targetDir, file.path);
-    const existing = await readOptionalFile(destination);
-    if (existing === file.content) {
-        return { ...file, result: "skipped" };
-    }
-    if (existing !== undefined && !options.force) {
-        throw new Error(`File ${file.path} already exists with different content. Pass --force to overwrite it.`);
-    }
-    return { ...file, result: existing === undefined ? "created" : "updated" };
-}
-async function writePlannedGeneratedFile(targetDir, file) {
-    if (file.result === "skipped")
-        return;
-    const destination = path.join(targetDir, file.path);
-    await mkdir(path.dirname(destination), { recursive: true });
-    await writeFile(destination, file.content);
-}
-async function fileExists(filePath) {
-    try {
-        await stat(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function readOptionalFile(filePath) {
-    try {
-        return await readFile(filePath, "utf8");
-    }
-    catch {
-        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,
@@ -1908,44 +1351,6 @@ async function makeFeatureArtifact(options) {
         skippedFiles,
     };
 }
-async function updatePackageDependencies(targetDir, dependencies, options) {
-    const filePath = path.join(targetDir, "package.json");
-    const original = await readFile(filePath, "utf8");
-    const packageJson = JSON.parse(original);
-    packageJson.dependencies = packageJson.dependencies ?? {};
-    for (const [name, version] of Object.entries(dependencies)) {
-        packageJson.dependencies[name] ??= version(packageJson);
-    }
-    const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updatePackageScripts(targetDir, scripts, options) {
-    const filePath = path.join(targetDir, "package.json");
-    const original = await readFile(filePath, "utf8");
-    const packageJson = JSON.parse(original);
-    packageJson.scripts = packageJson.scripts ?? {};
-    for (const [name, command] of Object.entries(scripts)) {
-        packageJson.scripts[name] ??= command;
-    }
-    const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-function beignetDependencyVersion(packageJson) {
-    return (packageJson.dependencies?.["@beignet/core"] ??
-        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
@@ -2009,1256 +1414,9 @@ async function updateResourceWiring(targetDir, names, config, persistenceOrOptio
         updated.add(routesFile);
     return [...updated];
 }
-async function updatePaymentsWiring(targetDir, billingNames, config, options) {
-    const updated = new Set();
-    if (await updatePackageJson(targetDir, options)) {
-        updated.add("package.json");
-    }
-    if (await updatePortsIndex(targetDir, billingNames, config, {
-        ...options,
-        generationOptions: {
-            auth: false,
-            tenant: false,
-            events: false,
-            softDelete: false,
-        },
-    })) {
-        updated.add(config.paths.ports);
-    }
-    if (await updatePaymentsEntitlementsPort(targetDir, config, options)) {
-        updated.add(config.paths.ports);
-        updated.add(config.paths.infrastructurePorts);
-    }
-    if (await updateInfrastructureDeferredPorts(targetDir, billingNames, config, options)) {
-        updated.add(config.paths.infrastructurePorts);
-    }
-    if (await updateBillingDrizzleSchemaIndex(targetDir, config, options)) {
-        updated.add(drizzleSchemaIndexPath(config));
-    }
-    if (await updateDrizzleRepositories(targetDir, billingNames, config, options)) {
-        updated.add(drizzleRepositoriesPath(config));
-    }
-    if (await updateDatabaseProviderPick(targetDir, config, options)) {
-        updated.add(path.join(infrastructureDir(config), "db/provider.ts"));
-    }
-    if (await updateDatabaseProviderEntitlements(targetDir, config, options)) {
-        updated.add(path.join(infrastructureDir(config), "db/provider.ts"));
-    }
-    if (await updateBillingTransactionPorts(targetDir, config, options)) {
-        updated.add(path.join(infrastructureDir(config), "db/transaction-ports.ts"));
-    }
-    if (await updateDatabaseResetTables(targetDir, config, options)) {
-        updated.add(path.join(infrastructureDir(config), "db/reset.ts"));
-    }
-    if (await updateBillingSharedErrors(targetDir, config, options)) {
-        updated.add(resourceSharedErrorsPath(config));
-    }
-    if (await updateBillingEnv(targetDir, options)) {
-        updated.add("lib/env.ts");
-    }
-    if (await updateBillingEnvExample(targetDir, options)) {
-        updated.add(".env.example");
-    }
-    const routesFile = await updateServerRoutes(targetDir, billingNames, config, options);
-    if (routesFile)
-        updated.add(routesFile);
-    return [...updated];
-}
-async function updatePackageJson(targetDir, options) {
-    const filePath = path.join(targetDir, "package.json");
-    const original = await readFile(filePath, "utf8");
-    const packageJson = JSON.parse(original);
-    packageJson.scripts = packageJson.scripts ?? {};
-    packageJson.scripts.test ??= "bun test";
-    if (options.webTestingDependency) {
-        packageJson.devDependencies = packageJson.devDependencies ?? {};
-        packageJson.devDependencies["@beignet/web"] ??=
-            packageJson.dependencies?.["@beignet/core"] ??
-                packageJson.dependencies?.["@beignet/next"] ??
-                "*";
-    }
-    const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return next !== original;
-}
-async function updatePortsIndex(targetDir, names, config, options) {
-    const filePath = path.join(targetDir, config.paths.ports);
-    const original = await readFile(filePath, "utf8");
-    let next = original;
-    const repositoryPath = resourcePortFilePath(names, config);
-    const importLine = `import type { ${names.singularPascal}Repository } from "${relativeModule(config.paths.ports, repositoryPath)}";`;
-    if (!next.includes(importLine)) {
-        next = insertAfterImports(next, importLine);
-    }
-    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.`);
-    }
-    const transactionPorts = typeBodySource(next, "AppTransactionPorts");
-    if (transactionPorts !== undefined &&
-        !transactionPorts.includes(entry.trim())) {
-        next = replaceTransactionPortsRequired(next, entry, `Could not find AppTransactionPorts in ${config.paths.ports}. Add ${entry.trim()} manually, or restore the generated ports file before running make resource.`);
-    }
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updatePortIndex(targetDir, names, config, options) {
-    const filePath = path.join(targetDir, config.paths.ports);
-    const original = await readFile(filePath, "utf8");
-    let next = original;
-    const portPath = path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
-    const importLine = `import type { ${names.interfaceName} } from "${relativeModule(config.paths.ports, portPath)}";`;
-    if (!next.includes(importLine)) {
-        next = insertAfterImports(next, importLine);
-    }
-    const entry = `\t${names.camel}: ${names.interfaceName};`;
-    if (!next.includes(entry.trim())) {
-        next = insertTypeProperty(next, "AppPorts", entry.trim(), `Could not find AppPorts in ${config.paths.ports}. Add ${entry.trim()} manually, or restore the generated ports file before running make port.`);
-    }
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updatePaymentsEntitlementsPort(targetDir, config, options) {
-    let changed = false;
-    const portsFilePath = path.join(targetDir, config.paths.ports);
-    const portsOriginal = await readFile(portsFilePath, "utf8");
-    let portsNext = addNamedTypeImport(portsOriginal, "EntitlementsPort", "@beignet/core/entitlements");
-    if (!/\bentitlements\s*:/.test(portsNext)) {
-        portsNext = insertTypeProperty(portsNext, "AppPorts", "entitlements: EntitlementsPort;", `Could not find AppPorts in ${config.paths.ports}. Add entitlements: EntitlementsPort; manually, or restore the generated ports file before running make payments.`);
-    }
-    if (portsNext !== portsOriginal) {
-        changed = true;
-        if (!options.dryRun)
-            await writeFile(portsFilePath, portsNext);
-    }
-    const infrastructureFilePath = path.join(targetDir, config.paths.infrastructurePorts);
-    const infrastructureOriginal = await readFile(infrastructureFilePath, "utf8");
-    const infrastructureNext = appendDeferredPortKey(infrastructureOriginal, "entitlements");
-    if (infrastructureNext === infrastructureOriginal &&
-        !/["']entitlements["']/.test(infrastructureOriginal)) {
-        throw new Error(`Could not find the deferred port list in ${config.paths.infrastructurePorts}. Add "entitlements" manually, or restore the generated infrastructure ports file before running make payments.`);
-    }
-    if (infrastructureNext !== infrastructureOriginal) {
-        changed = true;
-        if (!options.dryRun) {
-            await writeFile(infrastructureFilePath, infrastructureNext);
-        }
-    }
-    return changed;
-}
-async function updateInfrastructurePortStub(targetDir, names, config, options) {
-    const filePath = path.join(targetDir, config.paths.infrastructurePorts);
-    const original = await readFile(filePath, "utf8");
-    let next = original;
-    const portPath = portFilePath(names, config);
-    const importLine = `import type { ${names.interfaceName} } from "${relativeModule(config.paths.infrastructurePorts, portPath)}";`;
-    if (!next.includes(importLine)) {
-        next = insertAfterImports(next, importLine);
-    }
-    const entry = portStubEntry(names);
-    const definePortsBody = definePortsBodySource(next);
-    if (definePortsBody === undefined ||
-        !hasTopLevelObjectProperty(definePortsBody, names.camel)) {
-        next = insertDefinePortsProperty(next, entry.trim(), `Could not find definePorts({ in ${config.paths.infrastructurePorts}. Add the ${names.interfaceName} stub manually, or restore the generated infrastructure ports file before running make port.`);
-    }
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateInfrastructureAdapterWiring(targetDir, names, config, options) {
-    const filePath = path.join(targetDir, config.paths.infrastructurePorts);
-    const original = await readFile(filePath, "utf8");
-    let next = original;
-    const adapterPath = adapterFilePath(names, config);
-    const adapterImportLine = `import { ${names.adapterFactoryName} } from "${relativeModule(config.paths.infrastructurePorts, adapterPath)}";`;
-    if (!next.includes(adapterImportLine)) {
-        next = insertAfterImports(next, adapterImportLine);
-    }
-    const portPath = portFilePath(names, config);
-    const portImportLine = `import type { ${names.interfaceName} } from "${relativeModule(config.paths.infrastructurePorts, portPath)}";`;
-    if (next.includes(portImportLine)) {
-        next = next.replace(`${portImportLine}\n`, "");
-    }
-    const adapter = adapterEntry(names);
-    const stub = portStubEntry(names);
-    if (next.includes(stub)) {
-        next = next.replace(stub, adapter);
-    }
-    else if (!next.includes(adapter)) {
-        throw new Error(`Could not find the generated ${names.interfaceName} infrastructure stub in ${config.paths.infrastructurePorts}. Wire ${names.adapterFactoryName}() manually or restore the generated stub before running make adapter.`);
-    }
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateInfrastructurePorts(targetDir, names, config, options) {
-    const filePath = path.join(targetDir, config.paths.infrastructurePorts);
-    const original = await readFile(filePath, "utf8");
-    let next = original;
-    const repositoryPath = path.join(path.dirname(config.paths.infrastructurePorts), names.pluralKebab, `in-memory-${names.singularKebab}-repository.ts`);
-    const importLine = `import { createInMemory${names.singularPascal}Repository } from "${relativeModule(config.paths.infrastructurePorts, repositoryPath)}";`;
-    if (!next.includes(importLine)) {
-        next = insertAfterImports(next, importLine);
-    }
-    const repositoryConst = `const ${names.pluralCamel} = createInMemory${names.singularPascal}Repository();`;
-    if (!next.includes(repositoryConst)) {
-        next = replaceRequired(next, /(\nexport const appPorts = definePorts(?:<[^>]+>)?\((?:\)\()?\{)/, `\n${repositoryConst}\n$1`, `Could not find definePorts({ in ${config.paths.infrastructurePorts}. Add ${repositoryConst} manually, or restore the generated infrastructure ports file before running make resource.`);
-    }
-    const entry = `\t${names.pluralCamel},`;
-    const definePortsBody = definePortsBodySource(next);
-    if (definePortsBody === undefined ||
-        !hasTopLevelObjectProperty(definePortsBody, names.pluralCamel)) {
-        next = insertDefinePortsProperty(next, entry.trim(), `Could not find definePorts({ in ${config.paths.infrastructurePorts}. Add ${entry.trim()} to appPorts manually, or restore the generated infrastructure ports file before running make resource.`);
-    }
-    const transactionEntry = `\t\t${names.pluralCamel},`;
-    const uowBody = noopUnitOfWorkBodySource(next);
-    if (uowBody !== undefined &&
-        !new RegExp(`\\b${names.pluralCamel}\\b\\s*,`).test(uowBody)) {
-        next = insertNoopUnitOfWorkProperty(next, transactionEntry.trim(), `Could not find the generated Unit of Work port list in ${config.paths.infrastructurePorts}. Add ${transactionEntry.trim()} manually, or restore the generated infrastructure ports file before running make resource.`);
-    }
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function 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)))
-        return false;
-    const original = await readFile(filePath, "utf8");
-    const exportLine = `export { ${names.pluralCamel} } from "./${names.pluralKebab}";`;
-    if (original.includes(exportLine))
-        return false;
-    const next = `${original.trimEnd()}\n${exportLine}\n`;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateBillingDrizzleSchemaIndex(targetDir, config, options) {
-    const filePath = path.join(targetDir, drizzleSchemaIndexPath(config));
-    if (!(await fileExists(filePath)))
-        return false;
-    const original = await readFile(filePath, "utf8");
-    const exportLine = 'export { billingAccounts } from "./billing";';
-    if (original.includes(exportLine))
-        return false;
-    const next = `${original.trimEnd()}\n${exportLine}\n`;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateDrizzleRepositories(targetDir, names, config, options) {
-    const filePath = path.join(targetDir, drizzleRepositoriesPath(config));
-    if (!(await fileExists(filePath)))
-        return false;
-    const original = await readFile(filePath, "utf8");
-    let next = original;
-    const repositoryPath = drizzleResourceRepositoryFilePath(names, config);
-    const importLine = `import { createDrizzle${names.singularPascal}Repository } from "${relativeModule(drizzleRepositoriesPath(config), repositoryPath)}";`;
-    const repositoriesBody = createRepositoriesReturnBodySource(next);
-    const entry = `\t\t${names.pluralCamel}: createDrizzle${names.singularPascal}Repository(db),`;
-    if (repositoriesBody === undefined) {
-        throw new Error(`Could not find return { in createRepositories in ${drizzleRepositoriesPath(config)}. Add ${entry.trim()} manually, or restore the generated repositories file before running make resource.`);
-    }
-    if (!next.includes(importLine)) {
-        next = insertAfterImports(next, importLine);
-    }
-    if (!hasTopLevelObjectProperty(repositoriesBody, names.pluralCamel)) {
-        next = insertCreateRepositoriesProperty(next, entry.trim(), `Could not find return { in createRepositories in ${drizzleRepositoriesPath(config)}. Add ${entry.trim()} manually, or restore the generated repositories file before running make resource.`);
-    }
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateDatabaseProviderPick(targetDir, config, options) {
-    const file = path.join(infrastructureDir(config), "db/provider.ts");
-    const filePath = path.join(targetDir, file);
-    if (!(await fileExists(filePath)))
-        return false;
-    const original = await readFile(filePath, "utf8");
-    const next = appendPickStringLiteralMember(original, "AppPorts", "billing");
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateDatabaseProviderEntitlements(targetDir, config, options) {
-    const file = path.join(infrastructureDir(config), "db/provider.ts");
-    const filePath = path.join(targetDir, file);
-    if (!(await fileExists(filePath)))
-        return false;
-    const original = await readFile(filePath, "utf8");
-    let next = original;
-    const importLine = 'import { createBillingEntitlements } from "@/features/billing/entitlements";';
-    if (!next.includes(importLine)) {
-        next = insertAfterImports(next, importLine);
-    }
-    next = appendPickStringLiteralMember(next, "AppPorts", "entitlements");
-    if (!/\bconst\s+entitlements\s*=/.test(next)) {
-        const withEntitlementsConst = next.replace(/(\n\s*const repositories = createRepositories\(dbPort\.(?:drizzle|db)\);)/, `$1\n\t\tconst entitlements = createBillingEntitlements(repositories.billing);`);
-        if (withEntitlementsConst === next) {
-            throw new Error(`Could not find createRepositories(dbPort.drizzle) in ${file}. Add const entitlements = createBillingEntitlements(repositories.billing) manually, or restore the generated database provider before running make payments.`);
-        }
-        next = withEntitlementsConst;
-    }
-    if (!/\bentitlements\s*,/.test(next)) {
-        const withEntitlementsPort = next.replace(/(\n\s*\.\.\.repositories,\n)/, `$1\t\t\tentitlements,\n`);
-        if (withEntitlementsPort === next) {
-            throw new Error(`Could not find the repository spread in ${file}. Add entitlements to providedPorts manually, or restore the generated database provider before running make payments.`);
-        }
-        next = withEntitlementsPort;
-    }
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateBillingTransactionPorts(targetDir, config, options) {
-    const file = path.join(infrastructureDir(config), "db/transaction-ports.ts");
-    const filePath = path.join(targetDir, file);
-    if (!(await fileExists(filePath)))
-        return false;
-    const original = await readFile(filePath, "utf8");
-    if (/Pick<AppTransactionPorts,\s*["']billing["']>/.test(original)) {
-        return false;
-    }
-    const repositoryProperty = /repositories:\s*([^;\n]+);/.exec(original);
-    if (!repositoryProperty) {
-        throw new Error(`Could not find repositories: ... in ${file}. Add billing to the transaction repository dependency manually, or restore the generated transaction ports file before running make payments.`);
-    }
-    const repositoryType = repositoryProperty[1]?.trim();
-    if (!repositoryType) {
-        throw new Error(`Could not update repositories in ${file}. Add billing to the transaction repository dependency manually, or restore the generated transaction ports file before running make payments.`);
-    }
-    const next = original.replace(repositoryProperty[0], `repositories: ${repositoryType} & Pick<AppTransactionPorts, "billing">;`);
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateDatabaseResetTables(targetDir, config, options) {
-    const file = path.join(infrastructureDir(config), "db/reset.ts");
-    const filePath = path.join(targetDir, file);
-    if (!(await fileExists(filePath)))
-        return false;
-    const original = await readFile(filePath, "utf8");
-    if (/["']billing_accounts["']/.test(original))
-        return false;
-    const tables = arrayInitializerInfo(original, "tables");
-    if (!tables)
-        return false;
-    const nextArray = appendToArrayExpression(tables.text, [
-        '"billing_accounts"',
-    ]);
-    const next = `${original.slice(0, tables.start)}${nextArray}${original.slice(tables.end)}`;
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        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");
-    let next = original;
-    const transactionPortsBody = drizzleTransactionPortsBodySource(next);
-    if (transactionPortsBody === undefined ||
-        hasTopLevelObjectProperty(transactionPortsBody, names.pluralCamel)) {
-        return false;
-    }
-    if (!/\bappPorts\b/.test(next)) {
-        throw new Error(`Could not find appPorts in ${config.paths.server}. Add ${names.pluralCamel}: appPorts.${names.pluralCamel} to createTransactionPorts manually, or restore the generated server file before running make resource.`);
-    }
-    const entry = `\t\t\t\t\t\t${names.pluralCamel}: appPorts.${names.pluralCamel},`;
-    next = insertDrizzleTransactionPortsProperty(next, entry.trim(), `Could not find createTransactionPorts({ in ${config.paths.server}. Add ${entry.trim()} manually, or restore the generated server file before running make resource.`);
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateOpenApiRoute(targetDir, names, config, options) {
-    const filePath = path.join(targetDir, config.paths.openapiRoute);
-    if (!(await fileExists(filePath)))
-        return false;
-    const original = await readFile(filePath, "utf8");
-    const firstArg = firstCreateOpenAPIHandlerArgInfo(original);
-    if (!firstArg?.text.startsWith("["))
-        return false;
-    const contractNames = resourceContractNames(names, options.mode);
-    const listedContracts = identifiersFromArrayExpression(firstArg.text);
-    const missingContracts = contractNames.filter((contractName) => !listedContracts.has(contractName));
-    if (missingContracts.length === 0)
-        return false;
-    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)) {
-        next = insertAfterImports(next, importLine);
-    }
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        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 updateBillingSharedErrors(targetDir, config, options) {
-    const file = resourceSharedErrorsPath(config);
-    const filePath = path.join(targetDir, file);
-    if (!(await fileExists(filePath)))
-        return false;
-    const original = await readFile(filePath, "utf8");
-    const missingEntries = [
-        {
-            name: "BillingAccountNotFound",
-            entry: `BillingAccountNotFound: {
-\t\tcode: "BILLING_ACCOUNT_NOT_FOUND",
-\t\tstatus: 404,
-\t\tmessage: "Billing account not found",
-\t},`,
-        },
-        {
-            name: "IdempotencyConflict",
-            entry: `IdempotencyConflict: {
-\t\tcode: "IDEMPOTENCY_CONFLICT",
-\t\tstatus: 409,
-\t\tmessage: "Idempotency key was already used with a different request",
-\t},`,
-        },
-        {
-            name: "IdempotencyInProgress",
-            entry: `IdempotencyInProgress: {
-\t\tcode: "IDEMPOTENCY_IN_PROGRESS",
-\t\tstatus: 409,
-\t\tmessage: "Idempotency key is already being processed",
-\t},`,
-        },
-        {
-            name: "BillingCheckoutUnavailable",
-            entry: `BillingCheckoutUnavailable: {
-\t\tcode: "BILLING_CHECKOUT_UNAVAILABLE",
-\t\tstatus: 502,
-\t\tmessage: "Billing checkout is unavailable",
-\t},`,
-        },
-    ].filter(({ name }) => !new RegExp(`\\b${name}\\b`).test(original));
-    if (missingEntries.length === 0)
-        return false;
-    const defineErrorsStart = original.indexOf("defineErrors(");
-    if (defineErrorsStart === -1) {
-        throw new Error(`Could not find defineErrors({ in ${file}. Add BillingAccountNotFound and BillingCheckoutUnavailable manually, or restore the generated shared error catalog before running make payments.`);
-    }
-    const openBrace = original.indexOf("{", defineErrorsStart);
-    if (openBrace === -1) {
-        throw new Error(`Could not find defineErrors({ in ${file}. Add BillingAccountNotFound and BillingCheckoutUnavailable manually, or restore the generated shared error catalog before running make payments.`);
-    }
-    const closeBrace = matchingDelimiterIndex(original, openBrace, "{", "}");
-    if (closeBrace === -1) {
-        throw new Error(`Could not update ${file} because the error catalog object is malformed. Add BillingAccountNotFound and BillingCheckoutUnavailable manually, or restore the generated shared error catalog before running make payments.`);
-    }
-    const next = insertBeforeClosingBrace(original, openBrace, closeBrace, missingEntries.map(({ entry }) => entry).join("\n"));
-    if (next === original)
-        return false;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateBillingEnv(targetDir, options) {
-    const file = "lib/env.ts";
-    const filePath = path.join(targetDir, file);
-    const original = await readOptionalFile(filePath);
-    if (original === undefined) {
-        throw new Error(`Could not find ${file}. Add BILLING_TEAM_PRICE_ID to your env schema manually, or restore the generated env file before running make payments.`);
-    }
-    if (/\bBILLING_TEAM_PRICE_ID\b/.test(original))
-        return false;
-    const match = /\n([\t ]*)LOG_LEVEL:/.exec(original);
-    if (!match) {
-        throw new Error(`Could not find LOG_LEVEL in ${file}. Add BILLING_TEAM_PRICE_ID: z.string().min(1).default("price_team_example") to the createEnv server block manually, or restore the generated env file before running make payments.`);
-    }
-    const entry = `\n${match[1]}BILLING_TEAM_PRICE_ID: z.string().min(1).default("price_team_example"),`;
-    const next = `${original.slice(0, match.index)}${entry}${original.slice(match.index)}`;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return true;
-}
-async function updateBillingEnvExample(targetDir, options) {
-    const file = ".env.example";
-    const filePath = path.join(targetDir, file);
-    const original = await readOptionalFile(filePath);
-    if (original === undefined)
-        return false;
-    if (/^BILLING_TEAM_PRICE_ID=/m.test(original))
-        return false;
-    const match = /\nLOG_LEVEL=/.exec(original);
-    const next = match
-        ? `${original.slice(0, match.index)}\nBILLING_TEAM_PRICE_ID=price_team_example${original.slice(match.index)}`
-        : `${original.trimEnd()}\nBILLING_TEAM_PRICE_ID=price_team_example\n`;
-    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");
-    const routeRegistryPath = routeRegistryFileFromServerSource(original, config.paths.server);
-    if (routeRegistryPath) {
-        await assertImportedRoutesFileExists(targetDir, routeRegistryPath);
-        return updateDefineRoutesFile(targetDir, routeRegistryPath, names, config, options);
-    }
-    return updateDefineRoutesFile(targetDir, config.paths.server, names, config, options);
-}
-async function updateDefineRoutesFile(targetDir, file, names, config, options) {
-    const filePath = path.join(targetDir, file);
-    const original = await readFile(filePath, "utf8");
-    let next = original;
-    const routeGroupName = `${names.singularCamel}Routes`;
-    const routeGroupPath = path.join(config.paths.features, names.pluralKebab, "routes.ts");
-    const importLine = `import { ${routeGroupName} } from "${relativeModule(file, routeGroupPath)}";`;
-    if (!next.includes(importLine)) {
-        next = insertAfterImports(next, importLine);
-    }
-    if (!routeGroupIsRegistered(next, routeGroupName)) {
-        const firstArg = firstDefineRoutesArgInfo(next);
-        if (!firstArg?.text.startsWith("[")) {
-            throw new Error(`Could not find a central defineRoutes([...]) registration in ${file}. Import ${routeGroupName} and add it to defineRoutes manually.`);
-        }
-        const nextArray = appendToArrayExpression(firstArg.text, [routeGroupName]);
-        next = `${next.slice(0, firstArg.start)}${nextArray}${next.slice(firstArg.end)}`;
-    }
-    if (!routeGroupIsRegistered(next, routeGroupName)) {
-        throw new Error(`Could not find a central defineRoutes([...]) registration in ${file}. Import ${routeGroupName} and add it to defineRoutes manually.`);
-    }
-    if (next === original)
-        return undefined;
-    if (!options.dryRun)
-        await writeFile(filePath, next);
-    return file;
-}
-function routeGroupIsRegistered(source, routeGroupName) {
-    const firstArg = firstDefineRoutesArgInfo(source);
-    if (!firstArg?.text.startsWith("["))
-        return false;
-    return identifiersFromArrayExpression(firstArg.text).has(routeGroupName);
-}
-function routeRegistryFileFromServerSource(source, serverFile) {
-    const serverOptions = firstCreateNextServerArgInfo(source);
-    if (!serverOptions)
-        return undefined;
-    const routeIdentifier = routeOptionIdentifier(serverOptions.text);
-    if (!routeIdentifier)
-        return undefined;
-    const imported = parseNamedImportSources(source).get(routeIdentifier);
-    if (!imported)
-        return undefined;
-    return resolveImportFile(imported.sourcePath, serverFile);
-}
-function routeOptionIdentifier(source) {
-    const explicitMatch = /(?:^|[,{])\s*routes\s*:\s*([A-Za-z_$][\w$]*)/m.exec(source);
-    if (explicitMatch)
-        return explicitMatch[1];
-    if (/(?:^|[,{])\s*routes\s*(?:[,}])/m.test(source)) {
-        return "routes";
-    }
-    return undefined;
-}
-function parseNamedImportSources(source) {
-    const imports = new Map();
-    const importRegex = /import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
-    for (const match of source.matchAll(importRegex)) {
-        for (const member of match[1].split(",")) {
-            const parsed = parseImportMember(member);
-            if (!parsed)
-                continue;
-            imports.set(parsed.localName, {
-                importedName: parsed.importedName,
-                sourcePath: match[2],
-            });
-        }
-    }
-    return imports;
-}
-function parseImportMember(member) {
-    const trimmed = member.trim();
-    if (!trimmed)
-        return undefined;
-    const aliasMatch = /^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/.exec(trimmed);
-    if (aliasMatch) {
-        return {
-            importedName: aliasMatch[1],
-            localName: aliasMatch[2],
-        };
-    }
-    if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
-        return {
-            importedName: trimmed,
-            localName: trimmed,
-        };
-    }
-    return undefined;
-}
-function resolveImportFile(sourcePath, importerFile) {
-    if (sourcePath.startsWith("@/")) {
-        return `${sourcePath.slice(2)}.ts`;
-    }
-    if (sourcePath.startsWith(".")) {
-        return `${normalizePath(path.join(path.dirname(importerFile), sourcePath))}.ts`;
-    }
-    return undefined;
-}
-async function assertImportedRoutesFileExists(targetDir, file) {
-    try {
-        await stat(path.join(targetDir, file));
-    }
-    catch {
-        throw new Error(`Could not find the route registry ${file}. Restore the imported routes file or add the new route group manually.`);
-    }
-}
-function firstDefineRoutesArgInfo(source) {
-    const match = /defineRoutes(?:<[^>]+>)?\(/.exec(source);
-    if (!match)
-        return undefined;
-    return firstCallArgInfo(source, match.index + match[0].length);
-}
-function firstCreateNextServerArgInfo(source) {
-    const match = /createNextServer(?:<[^>]+>)?\(/.exec(source);
-    if (!match)
-        return undefined;
-    return firstCallArgInfo(source, match.index + match[0].length);
-}
-function firstCreateOpenAPIHandlerArgInfo(source) {
-    const start = source.indexOf("createOpenAPIHandler(");
-    if (start === -1)
-        return undefined;
-    return firstCallArgInfo(source, start + "createOpenAPIHandler(".length);
-}
-function firstCallArgInfo(source, argStart) {
-    let depth = 0;
-    let inString;
-    let escaped = false;
-    for (let index = argStart; index < source.length; index++) {
-        const char = source[index];
-        if (inString) {
-            if (escaped) {
-                escaped = false;
-            }
-            else if (char === "\\") {
-                escaped = true;
-            }
-            else if (char === inString) {
-                inString = undefined;
-            }
-            continue;
-        }
-        if (char === '"' || char === "'" || char === "`") {
-            inString = char;
-            continue;
-        }
-        if (char === "[" || char === "(" || char === "{") {
-            depth++;
-            continue;
-        }
-        if (char === "]" || char === ")" || char === "}") {
-            if (depth === 0) {
-                return trimmedSlice(source, argStart, index);
-            }
-            depth--;
-            continue;
-        }
-        if (char === "," && depth === 0) {
-            return trimmedSlice(source, argStart, index);
-        }
-    }
-    return undefined;
-}
-function trimmedSlice(source, start, end) {
-    let trimmedStart = start;
-    let trimmedEnd = end;
-    while (trimmedStart < trimmedEnd && /\s/.test(source[trimmedStart])) {
-        trimmedStart++;
-    }
-    while (trimmedEnd > trimmedStart && /\s/.test(source[trimmedEnd - 1])) {
-        trimmedEnd--;
-    }
-    return {
-        text: source.slice(trimmedStart, trimmedEnd),
-        start: trimmedStart,
-        end: trimmedEnd,
-    };
-}
-function replaceRequired(source, searchValue, replaceValue, message) {
-    const next = source.replace(searchValue, replaceValue);
-    if (next === source)
-        throw new Error(message);
-    return next;
-}
-function insertTypeProperty(source, typeName, property, message) {
-    const match = new RegExp(`export\\s+type\\s+${typeName}\\b`).exec(source);
-    if (!match)
-        throw new Error(message);
-    const openBrace = source.indexOf("{", match.index);
-    if (openBrace === -1)
-        throw new Error(message);
-    const closeBrace = matchingBraceIndex(source, openBrace);
-    if (closeBrace === -1)
-        throw new Error(message);
-    return insertBeforeClosingBrace(source, openBrace, closeBrace, property);
-}
-function typeBodySource(source, typeName) {
-    const match = new RegExp(`export\\s+type\\s+${typeName}\\b`).exec(source);
-    if (!match)
-        return undefined;
-    const openBrace = source.indexOf("{", match.index);
-    if (openBrace === -1)
-        return undefined;
-    const closeBrace = matchingBraceIndex(source, openBrace);
-    if (closeBrace === -1)
-        return undefined;
-    return source.slice(openBrace + 1, closeBrace);
-}
-function typeHasTopLevelProperty(source, typeName, propertyName) {
-    const body = typeBodySource(source, typeName);
-    return body !== undefined && hasTopLevelObjectProperty(body, propertyName);
-}
-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 appendPickStringLiteralMember(source, typeName, member) {
-    const match = new RegExp(`Pick<\\s*${typeName}\\s*,([\\s\\S]*?)>`).exec(source);
-    if (!match)
-        return source;
-    const literal = `"${member}"`;
-    if (match[1].includes(literal))
-        return source;
-    const union = match[1];
-    const indent = union.match(/\n([\t ]*)\|/)?.[1] ?? "\t";
-    const nextUnion = union.includes("\n")
-        ? `${union.replace(/\s*$/, "")}\n${indent}| ${literal}\n`
-        : `${union.trimEnd()} | ${literal}`;
-    return `${source.slice(0, match.index)}Pick<${typeName},${nextUnion}>${source.slice(match.index + match[0].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)
-        throw new Error(message);
-    return insertBeforeClosingBrace(source, body.openBrace, body.closeBrace, property);
-}
-function insertNoopUnitOfWorkProperty(source, property, message) {
-    const body = noopUnitOfWorkBodyRange(source);
-    if (!body)
-        throw new Error(message);
-    return insertBeforeClosingBrace(source, body.openBrace, body.closeBrace, property);
-}
-function insertDrizzleTransactionPortsProperty(source, property, message) {
-    const body = drizzleTransactionPortsBodyRange(source);
-    if (!body)
-        throw new Error(message);
-    return insertBeforeClosingBrace(source, body.openBrace, body.closeBrace, property);
-}
-function insertCreateRepositoriesProperty(source, property, message) {
-    const body = createRepositoriesReturnBodyRange(source);
-    if (!body)
-        throw new Error(message);
-    return insertBeforeClosingBrace(source, body.openBrace, body.closeBrace, property);
-}
-function noopUnitOfWorkBodySource(source) {
-    const body = noopUnitOfWorkBodyRange(source);
-    if (!body)
-        return undefined;
-    return source.slice(body.openBrace + 1, body.closeBrace);
-}
-function drizzleTransactionPortsBodySource(source) {
-    const body = drizzleTransactionPortsBodyRange(source);
-    if (!body)
-        return undefined;
-    return source.slice(body.openBrace + 1, body.closeBrace);
-}
-function createRepositoriesReturnBodySource(source) {
-    const body = createRepositoriesReturnBodyRange(source);
-    if (!body)
-        return undefined;
-    return source.slice(body.openBrace + 1, body.closeBrace);
-}
-function definePortsBodySource(source) {
-    const body = definePortsBodyRange(source);
-    if (!body)
-        return undefined;
-    return source.slice(body.openBrace + 1, body.closeBrace);
-}
-function definePortsBodyRange(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);
-    const closeBrace = matchingBraceIndex(source, openBrace);
-    if (closeBrace === -1)
-        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)}`;
-}
-/**
- * Add a name to an `import type { ... } from "<module>";` statement, creating
- * the import when the module is not imported yet. Names are inserted in sorted
- * position and single-line versus multiline formatting is preserved.
- */
-function addNamedTypeImport(source, name, moduleName) {
-    const escapedModule = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const importPattern = new RegExp(`import type \\{([^}]*)\\} from "${escapedModule}";`);
-    const match = importPattern.exec(source);
-    if (!match) {
-        return insertAfterImports(source, `import type { ${name} } from "${moduleName}";`);
-    }
-    const names = match[1]
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-    if (names.includes(name))
-        return source;
-    const insertIndex = names.findIndex((existing) => existing.localeCompare(name) > 0);
-    if (insertIndex === -1)
-        names.push(name);
-    else
-        names.splice(insertIndex, 0, name);
-    const indent = match[1].match(/\n([\t ]+)/)?.[1] ?? "\t";
-    const replacement = match[1].includes("\n")
-        ? `import type {\n${indent}${names.join(`,\n${indent}`)},\n} from "${moduleName}";`
-        : `import type { ${names.join(", ")} } from "${moduleName}";`;
-    return `${source.slice(0, match.index)}${replacement}${source.slice(match.index + match[0].length)}`;
-}
-function addNamedImport(source, name, moduleName) {
-    const escapedModule = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const importPattern = new RegExp(`import \\{([^}]*)\\} from "${escapedModule}";`);
-    const match = importPattern.exec(source);
-    if (!match) {
-        return insertAfterImports(source, `import { ${name} } from "${moduleName}";`);
-    }
-    const names = match[1]
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-    if (names.includes(name))
-        return source;
-    const insertIndex = names.findIndex((existing) => existing.localeCompare(name) > 0);
-    if (insertIndex === -1)
-        names.push(name);
-    else
-        names.splice(insertIndex, 0, name);
-    const indent = match[1].match(/\n([\t ]+)/)?.[1] ?? "\t";
-    const replacement = match[1].includes("\n")
-        ? `import {\n${indent}${names.join(`,\n${indent}`)},\n} from "${moduleName}";`
-        : `import { ${names.join(", ")} } from "${moduleName}";`;
-    return `${source.slice(0, match.index)}${replacement}${source.slice(match.index + match[0].length)}`;
-}
-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;
-    let escaped = false;
-    let lineComment = false;
-    let blockComment = false;
-    for (let index = 0; index < source.length; index++) {
-        const char = source[index];
-        const next = source[index + 1];
-        if (lineComment) {
-            if (char === "\n")
-                lineComment = false;
-            continue;
-        }
-        if (blockComment) {
-            if (char === "*" && next === "/") {
-                blockComment = false;
-                index++;
-            }
-            continue;
-        }
-        if (inString) {
-            if (escaped) {
-                escaped = false;
-            }
-            else if (char === "\\") {
-                escaped = true;
-            }
-            else if (char === inString) {
-                inString = undefined;
-            }
-            continue;
-        }
-        if (char === "/" && next === "/") {
-            lineComment = true;
-            index++;
-            continue;
-        }
-        if (char === "/" && next === "*") {
-            blockComment = true;
-            index++;
-            continue;
-        }
-        if (char === '"' || char === "'" || char === "`") {
-            inString = char;
-            continue;
-        }
-        if (char === "{" || char === "[" || char === "(") {
-            depth++;
-            continue;
-        }
-        if (char === "}" || char === "]" || char === ")") {
-            depth = Math.max(0, depth - 1);
-            continue;
-        }
-        if (depth !== 0 || !identifierStartPattern.test(char)) {
-            continue;
-        }
-        const property = identifierAt(source, index);
-        if (property !== propertyName) {
-            index += property.length - 1;
-            continue;
-        }
-        let cursor = index + property.length;
-        while (/\s/.test(source[cursor] ?? ""))
-            cursor++;
-        if (source[cursor] === ":" || source[cursor] === ",")
-            return true;
-        index = cursor;
-    }
-    return false;
-}
-const identifierStartPattern = /[$A-Z_a-z]/;
-const identifierPartPattern = /[$\w]/;
-function identifierAt(source, index) {
-    let cursor = index;
-    while (identifierPartPattern.test(source[cursor] ?? "")) {
-        cursor++;
-    }
-    return source.slice(index, cursor);
-}
-function noopUnitOfWorkBodyRange(source) {
-    const match = /createNoopUnitOfWork\(\s*\(\)\s*=>\s*\(\s*\{/.exec(source);
-    if (!match)
-        return undefined;
-    const openBrace = source.indexOf("{", match.index);
-    const closeBrace = matchingBraceIndex(source, openBrace);
-    if (closeBrace === -1)
-        return undefined;
-    return { openBrace, closeBrace };
-}
-function drizzleTransactionPortsBodyRange(source) {
-    const match = /createTransactionPorts\s*:\s*\([^)]*\)\s*=>\s*\(\s*\{/.exec(source);
-    if (!match)
-        return undefined;
-    const openBrace = source.indexOf("{", match.index);
-    const closeBrace = matchingBraceIndex(source, openBrace);
-    if (closeBrace === -1)
-        return undefined;
-    return { openBrace, closeBrace };
-}
-function createRepositoriesReturnBodyRange(source) {
-    const functionBody = createRepositoriesFunctionBodyRange(source);
-    if (!functionBody)
-        return undefined;
-    const functionSource = source.slice(functionBody.openBrace + 1, functionBody.closeBrace);
-    const match = /return\s*\{\s*/.exec(functionSource);
-    if (!match)
-        return undefined;
-    const openBrace = source.indexOf("{", functionBody.openBrace + 1 + match.index);
-    if (openBrace === -1)
-        return undefined;
-    const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
-    if (closeBrace === -1 || closeBrace > functionBody.closeBrace) {
-        return undefined;
-    }
-    return { openBrace, closeBrace };
-}
-function createRepositoriesFunctionBodyRange(source) {
-    const match = /(?:export\s+)?function\s+createRepositories\b/.exec(source);
-    if (!match)
-        return undefined;
-    const openParen = source.indexOf("(", match.index);
-    if (openParen === -1)
-        return undefined;
-    const closeParen = matchingDelimiterIndex(source, openParen, "(", ")");
-    if (closeParen === -1)
-        return undefined;
-    const bodyMatch = /(?:\s*:[^{]+)?\s*\{/.exec(source.slice(closeParen + 1));
-    if (!bodyMatch)
-        return undefined;
-    const openBrace = closeParen + 1 + bodyMatch.index + bodyMatch[0].lastIndexOf("{");
-    const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
-    if (closeBrace === -1)
-        return undefined;
-    return { openBrace, closeBrace };
-}
-function insertBeforeClosingBrace(source, openBrace, closeBrace, property) {
-    const body = source.slice(openBrace + 1, closeBrace);
-    const propertyIndent = detectPropertyIndent(body);
-    const closingIndent = source.slice(0, closeBrace).match(/\n([\t ]*)$/)?.[1] ?? "";
-    const trimmedBody = body.replace(/\s*$/, "");
-    const nextBody = `${trimmedBody}\n${propertyIndent}${property}\n${closingIndent}`;
-    return `${source.slice(0, openBrace + 1)}${nextBody}${source.slice(closeBrace)}`;
-}
-function detectPropertyIndent(body) {
-    return (body
-        .split("\n")
-        .find((line) => line.trim())
-        ?.match(/^[\t ]*/)?.[0] ?? "\t");
-}
-function matchingBraceIndex(source, openBrace) {
-    return matchingDelimiterIndex(source, openBrace, "{", "}");
-}
-function replaceTransactionPortsRequired(source, entry, message) {
-    return insertTypeProperty(source, "AppTransactionPorts", entry.trim(), message);
-}
-function aliasModule(filePath) {
-    return `@/${modulePath(filePath)}`;
-}
-function relativeModule(fromFile, toFile) {
-    const fromDir = path.posix.dirname(normalizePath(fromFile));
-    const relative = path.posix.relative(fromDir, normalizePath(toFile));
-    const specifier = modulePath(relative);
-    if (specifier.startsWith("../"))
-        return specifier;
-    if (specifier === "..")
-        return specifier;
-    return specifier.startsWith(".") ? specifier : `./${specifier}`;
-}
-function modulePath(filePath) {
-    return directoryPath(filePath)
-        .replace(/\.(?:[cm]?[jt]sx?)$/, "")
-        .replace(/\/index$/, "");
-}
-function resourceNames(input) {
-    const pluralKebab = normalizeResourceName(input);
-    const singularKebab = singularize(pluralKebab);
-    const names = {
-        input,
-        pluralKebab,
-        singularKebab,
-        pluralCamel: camelCase(pluralKebab),
-        singularCamel: camelCase(singularKebab),
-        singularPascal: pascalCase(singularKebab),
-        pluralPascal: pascalCase(pluralKebab),
-    };
-    assertGeneratedIdentifiers(input, "Resource name", [
-        names.pluralCamel,
-        names.singularCamel,
-        names.singularPascal,
-        names.pluralPascal,
-    ]);
-    return names;
-}
-function 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 typeHasTopLevelProperty(source, typeName, propertyName) {
+    const body = typeBodySource(source, typeName);
+    return body !== undefined && hasTopLevelObjectProperty(body, propertyName);
 }
 function useCaseNames(input) {
     const parts = input
@@ -3289,32 +1447,6 @@ function useCaseNames(input) {
         kind: inferUseCaseKind(action.kebab),
     };
 }
-function identifierNames(input, label) {
-    const kebab = normalizeName(input, label);
-    return {
-        input,
-        kebab,
-        camel: camelCase(kebab),
-        pascal: pascalCase(kebab),
-    };
-}
-function portNames(input) {
-    const names = identifierNames(input, "Port name");
-    const resolvedNames = {
-        ...names,
-        interfaceName: `${names.pascal}Port`,
-        inputName: `Execute${names.pascal}Input`,
-        adapterFactoryName: `create${names.pascal}Adapter`,
-    };
-    assertGeneratedIdentifiers(input, "Port name", [
-        resolvedNames.camel,
-        resolvedNames.pascal,
-        resolvedNames.interfaceName,
-        resolvedNames.inputName,
-        resolvedNames.adapterFactoryName,
-    ]);
-    return resolvedNames;
-}
 function policyNames(input) {
     const names = identifierNames(input, "Policy name");
     const resolvedNames = {
@@ -3324,32 +1456,6 @@ function policyNames(input) {
     assertGeneratedIdentifiers(input, "Policy name", [resolvedNames.policyName]);
     return resolvedNames;
 }
-function featureArtifactNames(input, label) {
-    const parts = artifactNameParts(input, label);
-    const feature = identifierNames(parts[0], `${label} feature`);
-    const artifact = identifierNames(parts[1], `${label} name`);
-    const featureSingularKebab = singularize(feature.kebab);
-    const names = {
-        input,
-        feature,
-        featureSingularKebab,
-        featureSingularCamel: camelCase(featureSingularKebab),
-        featureSingularPascal: pascalCase(featureSingularKebab),
-        artifact,
-        stableName: `${feature.kebab}.${artifact.kebab}`,
-    };
-    assertGeneratedIdentifiers(parts[0], `${label} feature`, [
-        names.feature.camel,
-        names.feature.pascal,
-        names.featureSingularCamel,
-        names.featureSingularPascal,
-    ]);
-    assertGeneratedIdentifiers(parts[1], `${label} name`, [
-        names.artifact.camel,
-        names.artifact.pascal,
-    ]);
-    return names;
-}
 function eventNames(input) {
     const names = featureArtifactNames(normalizeEventReference(input), "Event");
     const eventExportName = `${names.featureSingularPascal}${names.artifact.pascal}`;
@@ -3396,16 +1502,6 @@ function factoryNames(input) {
         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 defaultFactoryNamesForSeed(names) {
     return factoryNames(`${names.feature.kebab}/${names.featureSingularKebab}`);
 }
@@ -3469,127 +1565,12 @@ function normalizeEventReference(input) {
         return trimmed;
     return `${trimmed.slice(0, dotIndex)}/${trimmed.slice(dotIndex + 1)}`;
 }
-function artifactNameParts(input, label) {
-    const parts = input
-        .trim()
-        .split("/")
-        .map((part) => part.trim())
-        .filter(Boolean);
-    if (parts.length !== 2) {
-        throw new Error(`${label} name must use feature/name format, for example posts/published.`);
-    }
-    return [parts[0], parts[1]];
-}
-function portStubEntry(names) {
-    return `\t${names.camel}: {\n\t\tasync execute() {\n\t\t\tthrow new Error("${names.interfaceName} is not implemented.");\n\t\t},\n\t} satisfies ${names.interfaceName},`;
-}
-function adapterEntry(names) {
-    return `\t${names.camel}: ${names.adapterFactoryName}(),`;
-}
-function normalizeResourceName(input) {
-    return normalizeName(input, "Resource name");
-}
-function normalizeName(input, label) {
-    const normalized = input
-        .trim()
-        .toLowerCase()
-        .replaceAll(/[^a-z0-9]+/g, "-")
-        .replaceAll(/^-+|-+$/g, "");
-    if (!normalized) {
-        throw new Error(`${label} is required.`);
-    }
-    return normalized;
-}
-function assertGeneratedIdentifiers(input, label, identifiers) {
-    for (const identifier of new Set(identifiers)) {
-        if (isValidGeneratedIdentifier(identifier)) {
-            continue;
-        }
-        throw new Error(`${label} "${input}" generates invalid JavaScript identifier "${identifier}". Use a name that starts with a letter and is not a reserved word.`);
-    }
-}
-function isValidGeneratedIdentifier(identifier) {
-    return (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier) &&
-        !reservedJavaScriptIdentifiers.has(identifier));
-}
-const reservedJavaScriptIdentifiers = new Set([
-    "arguments",
-    "await",
-    "break",
-    "case",
-    "catch",
-    "class",
-    "const",
-    "continue",
-    "debugger",
-    "default",
-    "delete",
-    "do",
-    "else",
-    "enum",
-    "eval",
-    "export",
-    "extends",
-    "false",
-    "finally",
-    "for",
-    "function",
-    "if",
-    "implements",
-    "import",
-    "in",
-    "instanceof",
-    "interface",
-    "let",
-    "new",
-    "null",
-    "package",
-    "private",
-    "protected",
-    "public",
-    "return",
-    "static",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-    "yield",
-]);
 function inferUseCaseKind(action) {
     if (/^(count|find|get|list|search)-/.test(`${action}-`)) {
         return "query";
     }
     return "command";
 }
-function singularize(value) {
-    if (value.endsWith("ies") && value.length > 3) {
-        return `${value.slice(0, -3)}y`;
-    }
-    if (value.endsWith("ses") && value.length > 3) {
-        return value.slice(0, -2);
-    }
-    if (value.endsWith("s") && value.length > 1) {
-        return value.slice(0, -1);
-    }
-    return value;
-}
-function camelCase(value) {
-    return value.replaceAll(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
-}
-function pascalCase(value) {
-    const camel = camelCase(value);
-    return `${camel.charAt(0).toUpperCase()}${camel.slice(1)}`;
-}
-function constantCase(value) {
-    return value.replaceAll("-", "_").toUpperCase();
-}
 function resourceFiles(names, config, persistence = "memory", mode = "feature", options = {
     auth: false,
     tenant: false,
@@ -3685,54 +1666,6 @@ function resourceFiles(names, config, persistence = "memory", mode = "feature",
     }
     return files;
 }
-function paymentsFiles(config, database) {
-    return [
-        {
-            path: path.join(config.paths.features, "billing/schemas.ts"),
-            content: billingSchemasFile(),
-        },
-        {
-            path: path.join(config.paths.features, "billing/pricing.ts"),
-            content: billingPricingFile(),
-        },
-        {
-            path: path.join(config.paths.features, "billing/entitlements.ts"),
-            content: billingEntitlementsFile(),
-        },
-        {
-            path: path.join(config.paths.features, "billing/ports.ts"),
-            content: billingPortsFile(),
-        },
-        {
-            path: path.join(config.paths.features, "billing/contracts.ts"),
-            content: billingContractsFile(),
-        },
-        {
-            path: path.join(config.paths.features, "billing/use-cases/index.ts"),
-            content: billingUseCasesFile(config),
-        },
-        {
-            path: path.join(config.paths.features, "billing/routes.ts"),
-            content: billingRoutesFile(config),
-        },
-        {
-            path: path.join(config.paths.features, "billing/tests/billing.test.ts"),
-            content: billingTestFile(config),
-        },
-        {
-            path: path.join(infrastructureDir(config), "billing/drizzle-billing-repository.ts"),
-            content: billingDrizzleRepositoryFile(config, database),
-        },
-        {
-            path: path.join(infrastructureDir(config), "db/schema/billing.ts"),
-            content: billingDrizzleSchemaFile(database),
-        },
-        {
-            path: "app/api/webhooks/payments/route.ts",
-            content: billingWebhookRouteFile(),
-        },
-    ];
-}
 function featureUiComponentFiles(names, config) {
     const clientQueriesPath = featureUiClientQueriesFilePath(names, config);
     const componentPath = featureUiComponentFilePath(names, config);
@@ -3894,125 +1827,12 @@ function outboxFiles(config) {
         },
     ];
 }
-function portFilePath(names, config) {
-    return path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
-}
-function adapterFilePath(names, config) {
-    return path.join(path.dirname(config.paths.infrastructurePorts), names.kebab, `${names.kebab}-adapter.ts`);
-}
-function infrastructureDir(config) {
-    return path.dirname(config.paths.infrastructurePorts);
-}
-function drizzleSchemaIndexPath(config) {
-    return path.join(infrastructureDir(config), "db", "schema", "index.ts");
-}
-function drizzleRepositoriesPath(config) {
-    return path.join(infrastructureDir(config), "db", "repositories.ts");
-}
 function drizzleResourceSchemaFilePath(names, config) {
     return path.join(infrastructureDir(config), "db", "schema", `${names.pluralKebab}.ts`);
 }
 function outboxDrizzleSchemaFilePath(config) {
     return path.join(infrastructureDir(config), "db", "schema", "outbox-messages.ts");
 }
-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"
-        : "memory";
-}
-const databaseNames = ["sqlite", "postgres", "mysql"];
-/**
- * Detect the SQL dialect of a Drizzle app from its generated wiring.
- *
- * Precedence:
- * 1. The provider import in the Drizzle repositories file
- *    (`@beignet/provider-db-drizzle/<dialect>`), resolved through the
- *    configured infrastructure paths so custom layouts keep working.
- * 2. The provider registration tokens in `server/providers.ts`
- *    (`drizzle<Dialect>Provider` / `createDrizzle<Dialect>Provider`).
- * 3. `"sqlite"`, the starter default.
- *
- * Self-healing by design: there is no config field to drift, the detector
- * reads the same files the app boots from.
- */
-export async function detectResourceDatabase(targetDir, config) {
-    const repositories = await readOptionalFile(path.join(targetDir, drizzleRepositoriesPath(config)));
-    const providerImport = repositories?.match(/from\s+["']@beignet\/provider-db-drizzle\/(sqlite|postgres|mysql)["']/);
-    if (providerImport)
-        return providerImport[1];
-    const providers = await readOptionalFile(path.join(targetDir, providersFilePath(config)));
-    if (providers !== undefined) {
-        for (const database of databaseNames) {
-            const dialectPascal = database.charAt(0).toUpperCase() + database.slice(1);
-            const tokens = new RegExp(`\\b(?:drizzle${dialectPascal}Provider|createDrizzle${dialectPascal}Provider)\\b`);
-            if (tokens.test(providers))
-                return database;
-        }
-    }
-    return "sqlite";
-}
-function resourceFeatureDir(names, config) {
-    return path.join(config.paths.features, names.pluralKebab);
-}
-function featureUiDir(names, config) {
-    return path.join(resourceFeatureDir(names, config), "components");
-}
-function featureUiClientDir(names, config) {
-    return path.join(resourceFeatureDir(names, config), "client");
-}
-function featureUiClientQueriesFilePath(names, config) {
-    return path.join(featureUiClientDir(names, config), "queries.ts");
-}
-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 usesFeatureOwnedContracts(config) {
-    return (directoryPath(config.paths.contracts) ===
-        directoryPath(config.paths.features));
-}
-function usesFeatureOwnedUseCases(config) {
-    return (directoryPath(config.paths.useCases) ===
-        directoryPath(config.paths.features));
-}
-function usesFeatureOwnedPolicies(config) {
-    return (directoryPath(config.paths.policies) ===
-        directoryPath(config.paths.features));
-}
-function usesFeatureOwnedTests(config) {
-    return (usesFeatureOwnedUseCases(config) &&
-        directoryPath(config.paths.tests) === "tests");
-}
-function resourceContractFilePath(names, config) {
-    if (usesFeatureOwnedContracts(config)) {
-        return path.join(resourceFeatureDir(names, config), "contracts.ts");
-    }
-    return path.join(config.paths.contracts, `${names.pluralKebab}.ts`);
-}
-function useCaseFeatureDir(feature, config) {
-    if (usesFeatureOwnedUseCases(config)) {
-        return path.join(config.paths.features, feature, "use-cases");
-    }
-    return path.join(config.paths.useCases, feature);
-}
 function resourceUseCaseDir(names, config) {
     return useCaseFeatureDir(names.pluralKebab, config);
 }
@@ -4022,12 +1842,6 @@ function resourceUseCaseIndexPath(names, config) {
 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");
-    }
-    return path.join(path.dirname(config.paths.ports), `${names.singularKebab}-repository.ts`);
-}
 function resourceTestFilePath(names, config) {
     if (usesFeatureOwnedTests(config)) {
         return path.join(resourceFeatureDir(names, config), "tests", `${names.pluralKebab}.test.ts`);
@@ -4046,46 +1860,6 @@ function policyFilePath(names, config) {
     }
     return path.join(config.paths.policies, `${names.kebab}.ts`);
 }
-function featureArtifactDir(names, kind, config) {
-    const featureDir = path.join(config.paths.features, names.feature.kebab);
-    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) {
-    return path.join(featureArtifactDir(names, "events", config), `${names.artifact.kebab}.ts`);
-}
-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 seedEntrypointPath(config) {
-    return path.join(infrastructureDir(config), "db", "seed.ts");
-}
 function uploadRoutePath(config) {
     return path.join(config.paths.routes, "uploads", "[uploadName]", "[action]", "route.ts");
 }
@@ -4095,9 +1869,6 @@ function outboxDrainRoutePath(config) {
 function scheduleRouteFilePath(names, config) {
     return path.join(config.paths.routes, "cron", names.feature.kebab, names.artifact.kebab, "route.ts");
 }
-function useCaseFilePath(names, config) {
-    return path.join(useCaseFeatureDir(names.feature.kebab, config), `${names.action.kebab}.ts`);
-}
 function useCaseIndexFile(names, config) {
     const filePath = path.join(useCaseFeatureDir(names.feature.kebab, config), "index.ts");
     return {
@@ -4128,160 +1899,15 @@ async function updateFeatureUiIndex(targetDir, file, options) {
     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 === "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 === "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 === "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) {
-    const destination = path.join(targetDir, file.path);
-    const existing = await readOptionalFile(destination);
-    const specifier = relativeModule(file.path, file.artifactPath);
-    const importLine = `import { ${file.importName} } from "${specifier}";`;
-    const defineUploadsImport = `import { defineUploads } from "@beignet/core/uploads";`;
-    const exportLine = `export { ${file.importName} } from "${specifier}";`;
-    if (existing === undefined) {
-        const content = file.kind === "upload"
-            ? `${defineUploadsImport}
-${importLine}
-
-${exportLine}
-
-export const ${file.registryName} = defineUploads({
-\t${file.registryEntryName}: ${file.importName},
-});
-`
-            : `${importLine}
-
-${exportLine}
-
-export const ${file.registryName} = [${file.importName}] as const;
-`;
-        if (!options.dryRun) {
-            await mkdir(path.dirname(destination), { recursive: true });
-            await writeFile(destination, content);
-        }
-        return "created";
-    }
-    let next = existing;
-    if (!next.includes(importLine)) {
-        next = insertAfterImports(next, importLine);
-    }
-    if (!next.includes(exportLine)) {
-        const registryExport = new RegExp(`export\\s+const\\s+${file.registryName}\\b`).exec(next);
-        next = registryExport
-            ? `${next.slice(0, registryExport.index).trimEnd()}\n${exportLine}\n\n${next.slice(registryExport.index)}`
-            : `${next.trimEnd()}\n${exportLine}\n`;
-    }
-    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)}`;
+            await mkdir(path.dirname(destination), { recursive: true });
+            await writeFile(destination, file.content);
         }
+        return "created";
     }
-    if (next === existing)
+    if (existing.includes(file.content.trim())) {
         return "skipped";
+    }
+    const next = `${existing.trimEnd()}\n${file.content}`;
     if (!options.dryRun)
         await writeFile(destination, next);
     return "updated";
@@ -4292,10 +1918,10 @@ async function updateTaskRegistry(targetDir, names, config, options) {
     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 defineTasksImport = `import { defineTasks, type TaskRunContextArgs } 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 serverImport = `import { getServer } from "${relativeModule(config.paths.tasks, config.paths.server)}";`;
     const registryEntry = `...${registryName}`;
     if (existing === undefined) {
         const content = `${defineTasksImport}
@@ -4308,13 +1934,20 @@ export const tasks = defineTasks([
 \t${registryEntry},
 ] as const);
 
-export async function createTaskContext(): Promise<AppContext> {
+export async function createTaskContext(
+\targs?: TaskRunContextArgs,
+): Promise<AppContext> {
+\tconst server = await getServer();
 \treturn server.createServiceContext({
+\t\t// \`--tenant\` flows through TaskRunContextArgs; the starter has no tenant
+\t\t// lookup, so the raw value scopes the service context directly.
+\t\ttenantId: args?.tenant,
 \t\tactor: createServiceActor("beignet-cli"),
 \t});
 }
 
 export async function stopTaskContext(): Promise<void> {
+\tconst server = await getServer();
 \tawait server.stop();
 }
 `;
@@ -4325,7 +1958,9 @@ export async function stopTaskContext(): Promise<void> {
         return "created";
     }
     let next = existing;
-    if (!next.includes(defineTasksImport)) {
+    // Match any `defineTasks` import shape so registries that also import
+    // `TaskRunContextArgs` (or predate it) are not given a duplicate import.
+    if (!(next.includes("defineTasks") && next.includes('"@beignet/core/tasks"'))) {
         next = insertAfterImports(next, defineTasksImport);
     }
     if (!next.includes(importLine)) {
@@ -4353,7 +1988,7 @@ async function updateScheduleRegistry(targetDir, names, config, options) {
     const importLine = `import { ${registryName} } from "${aliasModule(featureSchedulesPath)}";`;
     const serviceActorImport = `import { createServiceActor } from "@beignet/core/ports";`;
     const appContextImport = `import type { AppContext } from "${aliasModule(config.paths.appContext)}";`;
-    const serverImport = `import { server } from "${relativeModule(config.paths.schedules, config.paths.server)}";`;
+    const serverImport = `import { getServer } from "${relativeModule(config.paths.schedules, config.paths.server)}";`;
     const registryEntry = `...${registryName}`;
     if (existing === undefined) {
         const content = `${serviceActorImport}
@@ -4364,12 +1999,14 @@ ${serverImport}
 export const schedules = [${registryEntry}] as const;
 
 export async function createScheduleContext(): Promise<AppContext> {
+\tconst server = await getServer();
 \treturn server.createServiceContext({
 \t\tactor: createServiceActor("beignet-schedule"),
 \t});
 }
 
 export async function stopScheduleContext(): Promise<void> {
+\tconst server = await getServer();
 \tawait server.stop();
 }
 `;
@@ -4397,39 +2034,6 @@ export async function stopScheduleContext(): Promise<void> {
         await writeFile(destination, next);
     return "updated";
 }
-async function updateSeedEntrypoint(targetDir, names, config, options) {
-    const file = seedEntrypointPath(config);
-    const destination = path.join(targetDir, file);
-    const existing = await readOptionalFile(destination);
-    const registryName = `${names.featureSingularCamel}Seeds`;
-    const importLine = `import { ${registryName} } from "${aliasModule(path.join(featureArtifactDir(names, "seeds", config), "index.ts"))}";`;
-    const registryEntry = `...${registryName}`;
-    if (existing === undefined) {
-        const content = seedEntrypointFile(names, config);
-        if (!options.dryRun) {
-            await mkdir(path.dirname(destination), { recursive: true });
-            await writeFile(destination, content);
-        }
-        return "created";
-    }
-    let next = existing;
-    if (!next.includes(importLine)) {
-        next = insertAfterImports(next, importLine);
-    }
-    const registry = arrayInitializerInfo(next, "seeds");
-    if (!registry) {
-        next = `${next.trimEnd()}\n\nconst seeds = [${registryEntry}] as const;\n`;
-    }
-    else if (!identifiersFromArrayExpression(registry.text).has(registryName)) {
-        const nextArray = appendToArrayExpression(registry.text, [registryEntry]);
-        next = `${next.slice(0, registry.start)}${nextArray}${next.slice(registry.end)}`;
-    }
-    if (next === existing)
-        return "skipped";
-    if (!options.dryRun)
-        await writeFile(destination, next);
-    return "updated";
-}
 async function updateUploadRoute(targetDir, names, config, options) {
     const file = uploadRoutePath(config);
     const destination = path.join(targetDir, file);
@@ -4506,22 +2110,6 @@ async function applyOutboxRegistryUpdate(result, targetDir, names, kind, config,
         result.files.push(config.paths.outbox);
     }
 }
-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";
 
@@ -5924,26 +3512,6 @@ export const ${names.uploadExportName} = defineUpload<
 });
 `;
 }
-function seedEntrypointFile(names, config) {
-    const registryName = `${names.featureSingularCamel}Seeds`;
-    return `import { createServiceActor } from "@beignet/core/ports";
-import { runSeeds } from "@beignet/core/testing";
-import { ${registryName} } from "${aliasModule(path.join(featureArtifactDir(names, "seeds", config), "index.ts"))}";
-import { server } from "${aliasModule(config.paths.server)}";
-
-const seeds = [...${registryName}] as const;
-
-const ctx = await server.createServiceContext({
-\tactor: createServiceActor("beignet-seed"),
-});
-
-try {
-\tawait runSeeds({ ctx, seeds });
-} finally {
-\tawait server.stop();
-}
-`;
-}
 function uploadRouteFile(names, config) {
     const registryName = `${names.featureSingularCamel}Uploads`;
     return `import {
@@ -5953,19 +3521,21 @@ function uploadRouteFile(names, config) {
 } from "@beignet/core/uploads";
 import { createUploadRoute } from "@beignet/next";
 import { ${registryName} } from "${aliasModule(path.join(featureArtifactDir(names, "uploads", config), "index.ts"))}";
-import { server } from "${aliasModule(config.paths.server)}";
+import { getServer } from "${aliasModule(config.paths.server)}";
 
 const uploadRegistry = defineUploads({
 \t${names.featureSingularCamel}: ${registryName},
 });
 
-const uploadRouter = createUploadRouter({
-\tuploads: uploadsFromRegistry(uploadRegistry),
-\tctx: () => server.createContextFromNext(),
-\tstorage: server.ports.storage,
-});
+export const { POST } = createUploadRoute(async () => {
+\tconst server = await getServer();
 
-export const { POST } = createUploadRoute(uploadRouter);
+\treturn createUploadRouter({
+\t\tuploads: uploadsFromRegistry(uploadRegistry),
+\t\tctx: () => server.createContextFromNext(),
+\t\tstorage: server.ports.storage,
+\t});
+});
 `;
 }
 function outboxRegistryFile(config, registration) {
@@ -5980,7 +3550,7 @@ function outboxRegistryFile(config, registration) {
     return `import { defineOutboxRegistry } from "@beignet/core/outbox";
 import { createServiceActor } from "@beignet/core/ports";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
-${featureImport}import { server } from "${relativeModule(config.paths.outbox, config.paths.server)}";
+${featureImport}import { getServer } from "${relativeModule(config.paths.outbox, config.paths.server)}";
 
 export const outboxRegistry = defineOutboxRegistry({
 \tevents: [${eventEntry}],
@@ -5988,12 +3558,14 @@ export const outboxRegistry = defineOutboxRegistry({
 });
 
 export async function createOutboxDrainContext(): Promise<AppContext> {
+\tconst server = await getServer();
 \treturn server.createServiceContext({
 \t\tactor: createServiceActor("beignet-outbox"),
 \t});
 }
 
 export async function stopOutboxDrainContext(): Promise<void> {
+\tconst server = await getServer();
 \tawait server.stop();
 }
 `;
@@ -6001,13 +3573,13 @@ export async function stopOutboxDrainContext(): Promise<void> {
 function outboxDrainRouteFile(config) {
     return `import { createOutboxDrainRoute } from "@beignet/next";
 import { env } from "@/lib/env";
-import { server } from "${aliasModule(config.paths.server)}";
+import { getServer } from "${aliasModule(config.paths.server)}";
 import { outboxRegistry } from "${aliasModule(config.paths.outbox)}";
 
 export const runtime = "nodejs";
 
 export const { GET, POST } = createOutboxDrainRoute({
-\tserver,
+\tserver: getServer,
 \tregistry: outboxRegistry,
 \tsecret: env.CRON_SECRET,
 \tbatchSize: 100,
@@ -6023,1210 +3595,6 @@ function outboxFeatureRegistry(names, kind, config) {
         importLine: `import { ${name} } from "${aliasModule(featureIndexPath)}";`,
     };
 }
-function billingSchemasFile() {
-    return `import { z } from "zod";
-
-export const billingPlanSchema = z.enum(["team"]);
-
-export const billingStatusSchema = z.enum([
-\t"inactive",
-\t"trialing",
-\t"active",
-\t"past_due",
-\t"canceled",
-]);
-
-export const createCheckoutSessionInputSchema = z.object({
-\tplan: billingPlanSchema,
-});
-
-export const createCheckoutSessionOutputSchema = z.object({
-\tsessionId: z.string(),
-\turl: z.string().url(),
-});
-
-export const createBillingPortalSessionOutputSchema = z.object({
-\turl: z.string().url(),
-});
-
-export const billingStatusOutputSchema = z.object({
-\ttenantId: z.string(),
-\tplan: billingPlanSchema,
-\tstatus: billingStatusSchema,
-\tactive: z.boolean(),
-\tprovider: z.string().optional(),
-\tcustomerId: z.string().optional(),
-\tsubscriptionId: z.string().optional(),
-\tcurrentPeriodEnd: z.string().optional(),
-\tcancelAtPeriodEnd: z.boolean().optional(),
-\tcheckoutSessionId: z.string().optional(),
-\tlastEventId: z.string().optional(),
-\tupdatedAt: z.string().optional(),
-});
-
-export type BillingPlan = z.infer<typeof billingPlanSchema>;
-export type BillingStatus = z.infer<typeof billingStatusSchema>;
-export type BillingStatusOutput = z.infer<typeof billingStatusOutputSchema>;
-`;
-}
-function billingPricingFile() {
-    return `import type {
-\tPaymentCheckoutLineItem,
-\tPaymentCheckoutMode,
-} from "@beignet/core/payments";
-import { env } from "@/lib/env";
-import type { BillingPlan } from "./schemas";
-
-export type BillingEntitlement = "todos.create";
-
-export type BillingPlanDefinition = {
-\tid: BillingPlan;
-\tlabel: string;
-\tmode: PaymentCheckoutMode;
-\tlineItems: readonly PaymentCheckoutLineItem[];
-\tentitlements: readonly BillingEntitlement[];
-};
-
-export const billingPlans = {
-\tteam: {
-\t\tid: "team",
-\t\tlabel: "Team",
-\t\tmode: "subscription",
-\t\tlineItems: [{ priceId: env.BILLING_TEAM_PRICE_ID, quantity: 1 }],
-\t\tentitlements: ["todos.create"],
-\t},
-} as const satisfies Record<BillingPlan, BillingPlanDefinition>;
-
-export function getBillingPlan(plan: BillingPlan): BillingPlanDefinition {
-\treturn billingPlans[plan];
-}
-
-export function billingPlanIncludesEntitlement(
-\tplan: BillingPlan,
-\tentitlement: string,
-): entitlement is BillingEntitlement {
-\treturn getBillingPlan(plan).entitlements.includes(
-\t\tentitlement as BillingEntitlement,
-\t);
-}
-`;
-}
-function billingEntitlementsFile() {
-    return `import {
-\tcreateEntitlements,
-\tdenyEntitlement,
-} from "@beignet/core/entitlements";
-import { billingPlanIncludesEntitlement } from "./pricing";
-import { isBillingAccountActive, type BillingRepository } from "./ports";
-
-export function createBillingEntitlements(billing: BillingRepository) {
-\treturn createEntitlements({
-\t\tasync inspect(input) {
-\t\t\tif (input.subject.type !== "tenant") {
-\t\t\t\treturn denyEntitlement({
-\t\t\t\t\treason: "Billing entitlements require a tenant subject.",
-\t\t\t\t\tcode: "ENTITLEMENT_SUBJECT_UNSUPPORTED",
-\t\t\t\t\tdetails: { subject: input.subject },
-\t\t\t\t});
-\t\t\t}
-
-\t\t\tconst account = await billing.findByTenantId(input.subject.id);
-\t\t\tif (!isBillingAccountActive(account)) {
-\t\t\t\treturn denyEntitlement({
-\t\t\t\t\treason: "An active billing plan is required for this action.",
-\t\t\t\t\tcode: "BILLING_INACTIVE",
-\t\t\t\t\tdetails: {
-\t\t\t\t\t\tentitlement: input.entitlement,
-\t\t\t\t\t\tstatus: account?.status ?? "inactive",
-\t\t\t\t\t\tsubject: input.subject,
-\t\t\t\t\t},
-\t\t\t\t});
-\t\t\t}
-
-\t\t\tif (!billingPlanIncludesEntitlement(account.plan, input.entitlement)) {
-\t\t\t\treturn denyEntitlement({
-\t\t\t\t\treason:
-\t\t\t\t\t\t"The current billing plan does not include this entitlement.",
-\t\t\t\t\tcode: "ENTITLEMENT_NOT_INCLUDED",
-\t\t\t\t\tdetails: {
-\t\t\t\t\t\tentitlement: input.entitlement,
-\t\t\t\t\t\tplan: account.plan,
-\t\t\t\t\t\tsubject: input.subject,
-\t\t\t\t\t},
-\t\t\t\t});
-\t\t\t}
-
-\t\t\treturn true;
-\t\t},
-\t});
-}
-`;
-}
-function billingPortsFile() {
-    return `import type { BillingPlan, BillingStatus } from "./schemas";
-
-export type BillingAccount = {
-\ttenantId: string;
-\tplan: BillingPlan;
-\tstatus: BillingStatus;
-\tprovider: string;
-\tcustomerId?: string;
-\tsubscriptionId?: string;
-\tcurrentPeriodEnd?: string;
-\tcancelAtPeriodEnd?: boolean;
-\tcheckoutSessionId?: string;
-\tlastEventId?: string;
-\tupdatedAt: string;
-};
-
-export type SaveBillingAccountInput = BillingAccount;
-
-export interface BillingRepository {
-\tfindByTenantId(tenantId: string): Promise<BillingAccount | null>;
-\tfindByCustomerId(
-\t\tcustomerId: string,
-\t\tprovider: string,
-\t): Promise<BillingAccount | null>;
-\tsave(input: SaveBillingAccountInput): Promise<BillingAccount>;
-}
-
-export function isBillingAccountActive(
-\taccount: BillingAccount | null,
-): account is BillingAccount & { status: "active" | "trialing" } {
-\treturn account?.status === "active" || account?.status === "trialing";
-}
-`;
-}
-function billingContractsFile() {
-    return `import { defineContractGroup } from "@beignet/core/contracts";
-import { z } from "zod";
-import {
-\tbillingStatusOutputSchema,
-\tcreateBillingPortalSessionOutputSchema,
-\tcreateCheckoutSessionInputSchema,
-\tcreateCheckoutSessionOutputSchema,
-} from "@/features/billing/schemas";
-import { errors } from "@/features/shared/errors";
-
-const billing = defineContractGroup()
-\t.namespace("billing")
-\t.prefix("/api/billing");
-const checkoutHeadersSchema = z.object({
-\t"idempotency-key": z.string().min(1),
-});
-const checkoutBilling = billing.headers(checkoutHeadersSchema);
-
-export const getBillingStatus = billing
-\t.get("/")
-\t.query(z.object({}))
-\t.meta({ auth: "required" })
-\t.errors({ Unauthorized: errors.Unauthorized })
-\t.responses({
-\t\t200: billingStatusOutputSchema,
-\t})
-\t.openapi({ summary: "Get billing status", tags: ["billing"] });
-
-export const createCheckoutSession = checkoutBilling
-\t.post("/checkout")
-\t.body(createCheckoutSessionInputSchema)
-\t.meta({
-\t\tauth: "required",
-\t\tidempotency: {
-\t\t\trequired: true,
-\t\t\theader: "idempotency-key",
-\t\t\tscope: "actor-tenant",
-\t\t\tttlSec: 86_400,
-\t\t},
-\t})
-\t.errors({
-\t\tUnauthorized: errors.Unauthorized,
-\t\tIdempotencyConflict: errors.IdempotencyConflict,
-\t\tIdempotencyInProgress: errors.IdempotencyInProgress,
-\t\tBillingCheckoutUnavailable: errors.BillingCheckoutUnavailable,
-\t})
-\t.responses({
-\t\t201: createCheckoutSessionOutputSchema,
-\t})
-\t.openapi({ summary: "Create a checkout session", tags: ["billing"] });
-
-export const createBillingPortalSession = billing
-\t.post("/portal")
-\t.body(z.object({}))
-\t.meta({ auth: "required" })
-\t.errors({
-\t\tUnauthorized: errors.Unauthorized,
-\t\tBillingAccountNotFound: errors.BillingAccountNotFound,
-\t})
-\t.responses({
-\t\t200: createBillingPortalSessionOutputSchema,
-\t})
-\t.openapi({ summary: "Create a billing portal session", tags: ["billing"] });
-
-export const billingContracts = [
-\tgetBillingStatus,
-\tcreateCheckoutSession,
-\tcreateBillingPortalSession,
-];
-`;
-}
-function billingUseCasesFile(config) {
-    return `import {
-\tcreateIdempotencyFingerprint,
-\trunIdempotently,
-} from "@beignet/core/idempotency";
-import type { PaymentWebhookEvent } from "@beignet/core/payments";
-import { requireUser } from "@beignet/core/ports";
-import { z } from "zod";
-import type { AppContext } from "${aliasModule(config.paths.appContext)}";
-import { appError } from "@/features/shared/errors";
-import { env } from "@/lib/env";
-import { useCase } from "@/lib/use-case";
-import { getBillingPlan } from "../pricing";
-import type { BillingAccount } from "../ports";
-import { isBillingAccountActive } from "../ports";
-import {
-\ttype BillingPlan,
-\ttype BillingStatus,
-\tbillingStatusOutputSchema,
-\tcreateBillingPortalSessionOutputSchema,
-\tcreateCheckoutSessionInputSchema,
-\tcreateCheckoutSessionOutputSchema,
-} from "../schemas";
-
-type ProviderPayload = Record<string, unknown>;
-
-const paymentWebhookEventSchema = z.custom<PaymentWebhookEvent>(
-\t(value): value is PaymentWebhookEvent =>
-\t\ttypeof value === "object" &&
-\t\tvalue !== null &&
-\t\ttypeof (value as PaymentWebhookEvent).id === "string" &&
-\t\ttypeof (value as PaymentWebhookEvent).type === "string" &&
-\t\ttypeof (value as PaymentWebhookEvent).provider === "string",
-);
-const paymentWebhookOutputSchema = z.object({
-\treceived: z.boolean(),
-\taccountUpdated: z.boolean(),
-});
-
-function nowIso(): string {
-\treturn new Date().toISOString();
-}
-
-function record(value: unknown): ProviderPayload {
-\treturn value && typeof value === "object" && !Array.isArray(value)
-\t\t? (value as ProviderPayload)
-\t\t: {};
-}
-
-function stringValue(value: unknown): string | undefined {
-\treturn typeof value === "string" && value.length > 0 ? value : undefined;
-}
-
-function providerId(value: unknown): string | undefined {
-\tif (typeof value === "string") return stringValue(value);
-\tconst payload = record(value);
-\treturn stringValue(payload.id);
-}
-
-function metadataValue(data: ProviderPayload, key: string): string | undefined {
-\treturn stringValue(record(data.metadata)[key]);
-}
-
-function tenantIdFromPayload(data: ProviderPayload): string | undefined {
-\treturn (
-\t\tstringValue(data.client_reference_id) ??
-\t\tmetadataValue(data, "tenantId") ??
-\t\tmetadataValue(data, "tenant_id")
-\t);
-}
-
-function planFromPayload(data: ProviderPayload): BillingPlan {
-\tconst plan = metadataValue(data, "plan");
-\treturn plan === "team" ? plan : "team";
-}
-
-function statusFromPayload(
-\tdata: ProviderPayload,
-\tfallback: BillingStatus,
-): BillingStatus {
-\tconst status = stringValue(data.status);
-\tswitch (status) {
-\t\tcase "active":
-\t\tcase "trialing":
-\t\tcase "past_due":
-\t\tcase "canceled":
-\t\tcase "inactive":
-\t\t\treturn status;
-\t\tcase "unpaid":
-\t\t\treturn "past_due";
-\t\tcase "incomplete":
-\t\t\treturn "inactive";
-\t\tcase "incomplete_expired":
-\t\t\treturn "canceled";
-\t\tcase "paused":
-\t\t\treturn "inactive";
-\t\tdefault:
-\t\t\treturn fallback;
-\t}
-}
-
-function periodEndFromPayload(data: ProviderPayload): string | undefined {
-\tconst value = data.current_period_end;
-\treturn typeof value === "number"
-\t\t? new Date(value * 1000).toISOString()
-\t\t: stringValue(value);
-}
-
-function cancelAtPeriodEndFromPayload(
-\tdata: ProviderPayload,
-): boolean | undefined {
-\treturn typeof data.cancel_at_period_end === "boolean"
-\t\t? data.cancel_at_period_end
-\t\t: undefined;
-}
-
-function billingTenantId(ctx: AppContext): string {
-\tconst user = requireUser(ctx);
-\treturn ctx.tenant?.id ?? user.id;
-}
-
-function billingStatusOutput(tenantId: string, account: BillingAccount | null) {
-\treturn {
-\t\ttenantId,
-\t\tplan: account?.plan ?? "team",
-\t\tstatus: account?.status ?? "inactive",
-\t\tactive: isBillingAccountActive(account),
-\t\t...(account?.provider ? { provider: account.provider } : {}),
-\t\t...(account?.customerId ? { customerId: account.customerId } : {}),
-\t\t...(account?.subscriptionId
-\t\t\t? { subscriptionId: account.subscriptionId }
-\t\t\t: {}),
-\t\t...(account?.currentPeriodEnd
-\t\t\t? { currentPeriodEnd: account.currentPeriodEnd }
-\t\t\t: {}),
-\t\t...(account?.cancelAtPeriodEnd !== undefined
-\t\t\t? { cancelAtPeriodEnd: account.cancelAtPeriodEnd }
-\t\t\t: {}),
-\t\t...(account?.checkoutSessionId
-\t\t\t? { checkoutSessionId: account.checkoutSessionId }
-\t\t\t: {}),
-\t\t...(account?.lastEventId ? { lastEventId: account.lastEventId } : {}),
-\t\t...(account?.updatedAt ? { updatedAt: account.updatedAt } : {}),
-\t};
-}
-
-async function saveBillingAccount(args: {
-\texisting: BillingAccount | null;
-\ttenantId: string;
-\tprovider: string;
-\tplan?: BillingPlan;
-\tstatus?: BillingStatus;
-\tcustomerId?: string;
-\tsubscriptionId?: string;
-\tcurrentPeriodEnd?: string;
-\tcancelAtPeriodEnd?: boolean;
-\tcheckoutSessionId?: string;
-\tlastEventId?: string;
-\tsave: (account: BillingAccount) => Promise<BillingAccount>;
-}) {
-\treturn args.save({
-\t\ttenantId: args.tenantId,
-\t\tprovider: args.provider,
-\t\tplan: args.plan ?? args.existing?.plan ?? "team",
-\t\tstatus: args.status ?? args.existing?.status ?? "inactive",
-\t\tcustomerId: args.customerId ?? args.existing?.customerId,
-\t\tsubscriptionId: args.subscriptionId ?? args.existing?.subscriptionId,
-\t\tcurrentPeriodEnd:
-\t\t\targs.currentPeriodEnd ?? args.existing?.currentPeriodEnd,
-\t\tcancelAtPeriodEnd:
-\t\t\targs.cancelAtPeriodEnd ?? args.existing?.cancelAtPeriodEnd,
-\t\tcheckoutSessionId:
-\t\t\targs.checkoutSessionId ?? args.existing?.checkoutSessionId,
-\t\tlastEventId: args.lastEventId ?? args.existing?.lastEventId,
-\t\tupdatedAt: nowIso(),
-\t});
-}
-
-async function applyCheckoutCompleted(
-\tevent: PaymentWebhookEvent,
-\tsave: (account: BillingAccount) => Promise<BillingAccount>,
-\tfindByTenantId: (tenantId: string) => Promise<BillingAccount | null>,
-) {
-\tconst data = record(event.data);
-\tconst tenantId = tenantIdFromPayload(data);
-\tif (!tenantId) return null;
-
-\tconst existing = await findByTenantId(tenantId);
-\treturn saveBillingAccount({
-\t\texisting,
-\t\ttenantId,
-\t\tprovider: event.provider,
-\t\tplan: planFromPayload(data),
-\t\tstatus: "active",
-\t\tcustomerId: providerId(data.customer),
-\t\tsubscriptionId: providerId(data.subscription),
-\t\tcheckoutSessionId: stringValue(data.id),
-\t\tlastEventId: event.id,
-\t\tsave,
-\t});
-}
-
-async function applySubscriptionEvent(
-\tevent: PaymentWebhookEvent,
-\tsave: (account: BillingAccount) => Promise<BillingAccount>,
-\tfindByCustomerId: (
-\t\tcustomerId: string,
-\t\tprovider: string,
-\t) => Promise<BillingAccount | null>,
-\tfindByTenantId: (tenantId: string) => Promise<BillingAccount | null>,
-) {
-\tconst data = record(event.data);
-\tconst customerId = providerId(data.customer);
-\tconst explicitTenantId = tenantIdFromPayload(data);
-\tconst existing = explicitTenantId
-\t\t? await findByTenantId(explicitTenantId)
-\t\t: customerId
-\t\t\t? await findByCustomerId(customerId, event.provider)
-\t\t\t: null;
-\tconst tenantId = explicitTenantId ?? existing?.tenantId;
-\tif (!tenantId) return null;
-
-\treturn saveBillingAccount({
-\t\texisting,
-\t\ttenantId,
-\t\tprovider: event.provider,
-\t\tplan: planFromPayload(data),
-\t\tstatus:
-\t\t\tevent.type === "customer.subscription.deleted"
-\t\t\t\t? "canceled"
-\t\t\t\t: statusFromPayload(data, existing?.status ?? "active"),
-\t\tcustomerId,
-\t\tsubscriptionId: providerId(data.id) ?? existing?.subscriptionId,
-\t\tcurrentPeriodEnd: periodEndFromPayload(data),
-\t\tcancelAtPeriodEnd:
-\t\t\tevent.type === "customer.subscription.deleted"
-\t\t\t\t? false
-\t\t\t\t: cancelAtPeriodEndFromPayload(data),
-\t\tlastEventId: event.id,
-\t\tsave,
-\t});
-}
-
-async function applyInvoiceSucceeded(
-\tevent: PaymentWebhookEvent,
-\tsave: (account: BillingAccount) => Promise<BillingAccount>,
-\tfindByCustomerId: (
-\t\tcustomerId: string,
-\t\tprovider: string,
-\t) => Promise<BillingAccount | null>,
-) {
-\tconst data = record(event.data);
-\tconst customerId = providerId(data.customer);
-\tif (!customerId) return null;
-
-\tconst existing = await findByCustomerId(customerId, event.provider);
-\tif (!existing) return null;
-\tif (existing.status === "canceled") return null;
-
-\treturn saveBillingAccount({
-\t\texisting,
-\t\ttenantId: existing.tenantId,
-\t\tprovider: event.provider,
-\t\tstatus: "active",
-\t\tcustomerId,
-\t\tsubscriptionId: providerId(data.subscription),
-\t\tcancelAtPeriodEnd: cancelAtPeriodEndFromPayload(data),
-\t\tlastEventId: event.id,
-\t\tsave,
-\t});
-}
-
-async function applyInvoiceFailed(
-\tevent: PaymentWebhookEvent,
-\tsave: (account: BillingAccount) => Promise<BillingAccount>,
-\tfindByCustomerId: (
-\t\tcustomerId: string,
-\t\tprovider: string,
-\t) => Promise<BillingAccount | null>,
-) {
-\tconst data = record(event.data);
-\tconst customerId = providerId(data.customer);
-\tif (!customerId) return null;
-
-\tconst existing = await findByCustomerId(customerId, event.provider);
-\tif (!existing) return null;
-\tif (existing.status === "canceled") return null;
-
-\treturn saveBillingAccount({
-\t\texisting,
-\t\ttenantId: existing.tenantId,
-\t\tprovider: event.provider,
-\t\tstatus: "past_due",
-\t\tcustomerId,
-\t\tsubscriptionId: providerId(data.subscription),
-\t\tlastEventId: event.id,
-\t\tsave,
-\t});
-}
-
-export const getBillingStatusUseCase = useCase
-\t.query("billing.getStatus")
-\t.input(z.object({}))
-\t.output(billingStatusOutputSchema)
-\t.run(async ({ ctx }) => {
-\t\tconst tenantId = billingTenantId(ctx);
-\t\tconst account = await ctx.ports.billing.findByTenantId(tenantId);
-\t\treturn billingStatusOutput(tenantId, account);
-\t});
-
-export const createCheckoutSessionUseCase = useCase
-\t.command("billing.createCheckoutSession")
-\t.input(createCheckoutSessionInputSchema)
-\t.output(createCheckoutSessionOutputSchema)
-\t.run(async ({ ctx, input }) => {
-\t\tconst tenantId = billingTenantId(ctx);
-\t\tconst account = await ctx.ports.billing.findByTenantId(tenantId);
-\t\tconst plan = getBillingPlan(input.plan);
-\t\tconst session = await ctx.ports.payments.createCheckoutSession({
-\t\t\tmode: plan.mode,
-\t\t\tlineItems: plan.lineItems,
-\t\t\tsuccessUrl: \`\${env.APP_URL}/billing?checkout=success\`,
-\t\t\tcancelUrl: \`\${env.APP_URL}/billing?checkout=cancelled\`,
-\t\t\tcustomerId: account?.customerId,
-\t\t\tclientReferenceId: tenantId,
-\t\t\tmetadata: {
-\t\t\t\ttenantId,
-\t\t\t\tplan: input.plan,
-\t\t\t},
-\t\t});
-
-\t\tif (!session.url) {
-\t\t\tthrow appError("BillingCheckoutUnavailable", {
-\t\t\t\tdetails: { provider: session.provider, sessionId: session.id },
-\t\t\t});
-\t\t}
-
-\t\tawait ctx.ports.billing.save({
-\t\t\ttenantId,
-\t\t\tprovider: session.provider,
-\t\t\tplan: input.plan,
-\t\t\tstatus: account?.status ?? "inactive",
-\t\t\tcustomerId: session.customerId ?? account?.customerId,
-\t\t\tsubscriptionId: account?.subscriptionId,
-\t\t\tcurrentPeriodEnd: account?.currentPeriodEnd,
-\t\t\tcancelAtPeriodEnd: account?.cancelAtPeriodEnd,
-\t\t\tcheckoutSessionId: session.id,
-\t\t\tlastEventId: account?.lastEventId,
-\t\t\tupdatedAt: nowIso(),
-\t\t});
-
-\t\treturn {
-\t\t\tsessionId: session.id,
-\t\t\turl: session.url,
-\t\t};
-\t});
-
-export const createBillingPortalSessionUseCase = useCase
-\t.command("billing.createPortalSession")
-\t.input(z.object({}))
-\t.output(createBillingPortalSessionOutputSchema)
-\t.run(async ({ ctx }) => {
-\t\tconst tenantId = billingTenantId(ctx);
-\t\tconst account = await ctx.ports.billing.findByTenantId(tenantId);
-
-\t\tif (!account?.customerId) {
-\t\t\tthrow appError("BillingAccountNotFound", {
-\t\t\t\tdetails: { tenantId },
-\t\t\t});
-\t\t}
-
-\t\tconst session = await ctx.ports.payments.createBillingPortalSession({
-\t\t\tcustomerId: account.customerId,
-\t\t\treturnUrl: \`\${env.APP_URL}/billing\`,
-\t\t});
-
-\t\treturn { url: session.url };
-\t});
-
-export const handlePaymentWebhookUseCase = useCase
-\t.command("billing.handlePaymentWebhook")
-\t.input(paymentWebhookEventSchema)
-\t.output(paymentWebhookOutputSchema)
-\t.run(async ({ ctx, input }) => {
-\t\tconst fingerprint = await createIdempotencyFingerprint({
-\t\t\ttype: input.type,
-\t\t\tdata: input.data,
-\t\t});
-
-\t\treturn runIdempotently(ctx.ports.idempotency, {
-\t\t\tnamespace: "webhooks.payments",
-\t\t\tkey: input.id,
-\t\t\tscope: { provider: input.provider },
-\t\t\tfingerprint,
-\t\t\tttlSec: 60 * 60 * 24 * 30,
-\t\t\trun: () =>
-\t\t\t\tctx.ports.uow.transaction(async (tx) => {
-\t\t\t\t\tlet account: BillingAccount | null = null;
-
-\t\t\t\t\tif (input.type === "checkout.session.completed") {
-\t\t\t\t\t\taccount = await applyCheckoutCompleted(
-\t\t\t\t\t\t\tinput,
-\t\t\t\t\t\t\ttx.billing.save,
-\t\t\t\t\t\t\ttx.billing.findByTenantId,
-\t\t\t\t\t\t);
-\t\t\t\t\t} else if (input.type.startsWith("customer.subscription.")) {
-\t\t\t\t\t\taccount = await applySubscriptionEvent(
-\t\t\t\t\t\t\tinput,
-\t\t\t\t\t\t\ttx.billing.save,
-\t\t\t\t\t\t\ttx.billing.findByCustomerId,
-\t\t\t\t\t\t\ttx.billing.findByTenantId,
-\t\t\t\t\t\t);
-\t\t\t\t\t} else if (input.type === "invoice.payment_succeeded") {
-\t\t\t\t\t\taccount = await applyInvoiceSucceeded(
-\t\t\t\t\t\t\tinput,
-\t\t\t\t\t\t\ttx.billing.save,
-\t\t\t\t\t\t\ttx.billing.findByCustomerId,
-\t\t\t\t\t\t);
-\t\t\t\t\t} else if (input.type === "invoice.payment_failed") {
-\t\t\t\t\t\taccount = await applyInvoiceFailed(
-\t\t\t\t\t\t\tinput,
-\t\t\t\t\t\t\ttx.billing.save,
-\t\t\t\t\t\t\ttx.billing.findByCustomerId,
-\t\t\t\t\t\t);
-\t\t\t\t\t}
-
-\t\t\t\t\treturn {
-\t\t\t\t\t\treceived: true,
-\t\t\t\t\t\taccountUpdated: Boolean(account),
-\t\t\t\t\t};
-\t\t\t\t}),
-\t\t});
-\t});
-`;
-}
-function billingRoutesFile(config) {
-    const routeFilePath = path.join(config.paths.features, "billing/routes.ts");
-    return `import { defineRouteGroup } from "@beignet/next";
-import type { AppContext } from "${relativeModule(routeFilePath, config.paths.appContext)}";
-import * as billingContracts from "@/features/billing/contracts";
-import * as billingUseCases from "@/features/billing/use-cases";
-
-export const billingRoutes = defineRouteGroup<AppContext>()({
-\tname: "billing",
-\troutes: [
-\t\t{
-\t\t\tcontract: billingContracts.getBillingStatus,
-\t\t\tuseCase: billingUseCases.getBillingStatusUseCase,
-\t\t},
-\t\t{
-\t\t\tcontract: billingContracts.createCheckoutSession,
-\t\t\tuseCase: billingUseCases.createCheckoutSessionUseCase,
-\t\t},
-\t\t{
-\t\t\tcontract: billingContracts.createBillingPortalSession,
-\t\t\tuseCase: billingUseCases.createBillingPortalSessionUseCase,
-\t\t},
-\t],
-});
-`;
-}
-function billingTestFile(config) {
-    return `import { describe, expect, it } from "bun:test";
-import { createUseCaseTester } from "@beignet/core/application";
-import { createAnonymousActor } from "@beignet/core/ports";
-import { createTestUserActor } from "@beignet/core/ports/testing";
-import {
-\tcreateTestContextFactory,
-\tcreateTestPorts,
-} from "@beignet/core/testing";
-import type { AppContext } from "${aliasModule(config.paths.appContext)}";
-import { appPorts } from "@/infra/app-ports";
-import type { AppTransactionPorts } from "@/ports";
-import { createBillingEntitlements } from "../entitlements";
-import type { BillingAccount, BillingRepository } from "../ports";
-import {
-\tcreateBillingPortalSessionUseCase,
-\tcreateCheckoutSessionUseCase,
-\tgetBillingStatusUseCase,
-\thandlePaymentWebhookUseCase,
-} from "../use-cases";
-
-function createMemoryBillingRepository(): BillingRepository {
-\tconst accounts = new Map<string, BillingAccount>();
-
-\treturn {
-\t\tasync findByTenantId(tenantId) {
-\t\t\treturn accounts.get(tenantId) ?? null;
-\t\t},
-
-\t\tasync findByCustomerId(customerId, provider) {
-\t\t\treturn (
-\t\t\t\t[...accounts.values()].find(
-\t\t\t\t\t(account) =>
-\t\t\t\t\t\taccount.customerId === customerId &&
-\t\t\t\t\t\taccount.provider === provider,
-\t\t\t\t) ?? null
-\t\t\t);
-\t\t},
-
-\t\tasync save(input) {
-\t\t\taccounts.set(input.tenantId, { ...input });
-\t\t\treturn input;
-\t\t},
-\t};
-}
-
-function createHarness(options: { actor?: AppContext["actor"] } = {}) {
-\tconst billing = createMemoryBillingRepository();
-\tconst actor = options.actor ?? createTestUserActor("user_test");
-\tconst fixture = createTestPorts<AppContext["ports"], AppTransactionPorts>({
-\t\tbase: appPorts,
-\t\toverrides: {
-\t\t\tbilling,
-\t\t\tentitlements: createBillingEntitlements(billing),
-\t\t\tgate: appPorts.gate,
-\t\t},
-\t});
-\tconst createContext = createTestContextFactory<
-\t\tAppContext,
-\t\tAppContext["ports"]
-\t>({
-\t\tports: fixture.ports,
-\t\tactor,
-\t\tauth:
-\t\t\tactor.type === "user" && actor.id
-\t\t\t\t? { user: { id: actor.id }, session: { id: "session_test" } }
-\t\t\t\t: null,
-\t\trequestId: "test-request",
-\t\ttraceId: "test-trace",
-\t\ttenant: { id: "tenant_example" },
-\t});
-
-\treturn {
-\t\tbilling,
-\t\tentitlements: fixture.ports.entitlements,
-\t\tpayments: fixture.payments,
-\t\ttester: createUseCaseTester<AppContext>(createContext),
-\t};
-}
-
-describe("billing use cases", () => {
-\tit("requires an authenticated user to read billing status", async () => {
-\t\tconst harness = createHarness({ actor: createAnonymousActor() });
-
-\t\tawait expect(
-\t\t\tharness.tester.run(getBillingStatusUseCase, {}),
-\t\t).rejects.toMatchObject({
-\t\t\tcode: "UNAUTHORIZED",
-\t\t});
-\t});
-
-\tit("creates checkout sessions through the payments port and records billing state", async () => {
-\t\tconst harness = createHarness();
-
-\t\tconst checkout = await harness.tester.run(createCheckoutSessionUseCase, {
-\t\t\tplan: "team",
-\t\t});
-
-\t\texpect(checkout.sessionId).toMatch(/^checkout_/);
-\t\texpect(checkout.url).toContain("/checkout/");
-\t\texpect(harness.payments.checkoutSessions).toHaveLength(1);
-\t\texpect(harness.payments.checkoutSessions[0]?.input).toMatchObject({
-\t\t\tmode: "subscription",
-\t\t\tlineItems: [{ priceId: "price_team_example", quantity: 1 }],
-\t\t\tclientReferenceId: "tenant_example",
-\t\t\tmetadata: {
-\t\t\t\ttenantId: "tenant_example",
-\t\t\t\tplan: "team",
-\t\t\t},
-\t\t});
-\t\texpect(
-\t\t\tharness.payments.checkoutSessions[0]?.input.idempotencyKey,
-\t\t).toBe(undefined);
-\t\tawait expect(
-\t\t\tharness.billing.findByTenantId("tenant_example"),
-\t\t).resolves.toMatchObject({
-\t\t\tcheckoutSessionId: checkout.sessionId,
-\t\t\tplan: "team",
-\t\t\tstatus: "inactive",
-\t\t});
-\t});
-
-\tit("creates billing portal sessions for tenants with provider customers", async () => {
-\t\tconst harness = createHarness();
-\t\tawait harness.billing.save({
-\t\t\ttenantId: "tenant_example",
-\t\t\tprovider: "memory",
-\t\t\tplan: "team",
-\t\t\tstatus: "active",
-\t\t\tcustomerId: "cus_123",
-\t\t\tupdatedAt: new Date(0).toISOString(),
-\t\t});
-
-\t\tconst portal = await harness.tester.run(
-\t\t\tcreateBillingPortalSessionUseCase,
-\t\t\t{},
-\t\t);
-
-\t\texpect(portal.url).toContain("/portal/");
-\t\texpect(harness.payments.billingPortalSessions).toHaveLength(1);
-\t\texpect(harness.payments.billingPortalSessions[0]?.input.customerId).toBe(
-\t\t\t"cus_123",
-\t\t);
-\t});
-
-\tit.each(["active", "trialing"] as const)(
-\t\t"grants billing entitlements for %s accounts",
-\t\tasync (status) => {
-\t\t\tconst harness = createHarness();
-\t\t\tawait harness.billing.save({
-\t\t\t\ttenantId: "tenant_example",
-\t\t\t\tprovider: "stripe",
-\t\t\t\tplan: "team",
-\t\t\t\tstatus,
-\t\t\t\tupdatedAt: new Date(0).toISOString(),
-\t\t\t});
-
-\t\t\tawait expect(
-\t\t\t\tharness.entitlements.can({
-\t\t\t\t\tentitlement: "todos.create",
-\t\t\t\t\tsubject: { type: "tenant", id: "tenant_example" },
-\t\t\t\t}),
-\t\t\t).resolves.toBe(true);
-\t\t},
-\t);
-
-\tit.each(["inactive", "past_due", "canceled"] as const)(
-\t\t"denies billing entitlements for %s accounts",
-\t\tasync (status) => {
-\t\t\tconst harness = createHarness();
-\t\t\tawait harness.billing.save({
-\t\t\t\ttenantId: "tenant_example",
-\t\t\t\tprovider: "stripe",
-\t\t\t\tplan: "team",
-\t\t\t\tstatus,
-\t\t\t\tupdatedAt: new Date(0).toISOString(),
-\t\t\t});
-
-\t\t\tawait expect(
-\t\t\t\tharness.entitlements.inspect({
-\t\t\t\t\tentitlement: "todos.create",
-\t\t\t\t\tsubject: { type: "tenant", id: "tenant_example" },
-\t\t\t\t}),
-\t\t\t).resolves.toMatchObject({
-\t\t\t\tallowed: false,
-\t\t\t\tcode: "BILLING_INACTIVE",
-\t\t\t});
-\t\t},
-\t);
-
-\tit("handles checkout and subscription webhooks idempotently", async () => {
-\t\tconst harness = createHarness();
-\t\tconst checkoutEvent = {
-\t\t\tid: "evt_checkout_completed",
-\t\t\ttype: "checkout.session.completed",
-\t\t\tprovider: "stripe",
-\t\t\tdata: {
-\t\t\t\tid: "cs_123",
-\t\t\t\tclient_reference_id: "tenant_example",
-\t\t\t\tcustomer: "cus_123",
-\t\t\t\tsubscription: "sub_123",
-\t\t\t\tmetadata: {
-\t\t\t\t\ttenantId: "tenant_example",
-\t\t\t\t\tplan: "team",
-\t\t\t\t},
-\t\t\t},
-\t\t};
-\t\tconst subscriptionEvent = {
-\t\t\tid: "evt_subscription_updated",
-\t\t\ttype: "customer.subscription.updated",
-\t\t\tprovider: "stripe",
-\t\t\tdata: {
-\t\t\t\tid: "sub_123",
-\t\t\t\tcustomer: "cus_123",
-\t\t\t\tstatus: "active",
-\t\t\t\tcurrent_period_end: 1_799_798_400,
-\t\t\t\tcancel_at_period_end: true,
-\t\t\t},
-\t\t};
-
-\t\tawait expect(
-\t\t\tharness.tester.run(handlePaymentWebhookUseCase, checkoutEvent),
-\t\t).resolves.toEqual({ received: true, accountUpdated: true });
-\t\tawait expect(
-\t\t\tharness.tester.run(handlePaymentWebhookUseCase, checkoutEvent),
-\t\t).resolves.toEqual({ received: true, accountUpdated: true });
-\t\tawait expect(
-\t\t\tharness.tester.run(handlePaymentWebhookUseCase, subscriptionEvent),
-\t\t).resolves.toEqual({ received: true, accountUpdated: true });
-\t\tawait expect(
-\t\t\tharness.tester.run(getBillingStatusUseCase, {}),
-\t\t).resolves.toMatchObject({
-\t\t\ttenantId: "tenant_example",
-\t\t\tactive: true,
-\t\t\tstatus: "active",
-\t\t\tcustomerId: "cus_123",
-\t\t\tsubscriptionId: "sub_123",
-\t\t\tcurrentPeriodEnd: "2027-01-13T00:00:00.000Z",
-\t\t\tcancelAtPeriodEnd: true,
-\t\t\tcheckoutSessionId: "cs_123",
-\t\t\tlastEventId: "evt_subscription_updated",
-\t\t});
-\t});
-
-\tit("marks active subscriptions as past due when invoice payment fails", async () => {
-\t\tconst harness = createHarness();
-\t\tawait harness.billing.save({
-\t\t\ttenantId: "tenant_example",
-\t\t\tprovider: "stripe",
-\t\t\tplan: "team",
-\t\t\tstatus: "active",
-\t\t\tcustomerId: "cus_123",
-\t\t\tsubscriptionId: "sub_123",
-\t\t\tupdatedAt: new Date(0).toISOString(),
-\t\t});
-
-\t\tawait expect(
-\t\t\tharness.tester.run(handlePaymentWebhookUseCase, {
-\t\t\t\tid: "evt_invoice_failed",
-\t\t\t\ttype: "invoice.payment_failed",
-\t\t\t\tprovider: "stripe",
-\t\t\t\tdata: {
-\t\t\t\t\tcustomer: "cus_123",
-\t\t\t\t\tsubscription: "sub_123",
-\t\t\t\t},
-\t\t\t}),
-\t\t).resolves.toEqual({ received: true, accountUpdated: true });
-\t\tawait expect(
-\t\t\tharness.billing.findByTenantId("tenant_example"),
-\t\t).resolves.toMatchObject({
-\t\t\tstatus: "past_due",
-\t\t\tlastEventId: "evt_invoice_failed",
-\t\t});
-\t});
-
-\tit("preserves pending cancellation when an invoice succeeds", async () => {
-\t\tconst harness = createHarness();
-\t\tawait harness.billing.save({
-\t\t\ttenantId: "tenant_example",
-\t\t\tprovider: "stripe",
-\t\t\tplan: "team",
-\t\t\tstatus: "active",
-\t\t\tcustomerId: "cus_123",
-\t\t\tsubscriptionId: "sub_123",
-\t\t\tcancelAtPeriodEnd: true,
-\t\t\tupdatedAt: new Date(0).toISOString(),
-\t\t});
-
-\t\tawait expect(
-\t\t\tharness.tester.run(handlePaymentWebhookUseCase, {
-\t\t\t\tid: "evt_invoice_succeeded",
-\t\t\t\ttype: "invoice.payment_succeeded",
-\t\t\t\tprovider: "stripe",
-\t\t\t\tdata: {
-\t\t\t\t\tcustomer: "cus_123",
-\t\t\t\t\tsubscription: "sub_123",
-\t\t\t\t},
-\t\t\t}),
-\t\t).resolves.toEqual({ received: true, accountUpdated: true });
-\t\tawait expect(
-\t\t\tharness.billing.findByTenantId("tenant_example"),
-\t\t).resolves.toMatchObject({
-\t\t\tstatus: "active",
-\t\t\tcancelAtPeriodEnd: true,
-\t\t\tlastEventId: "evt_invoice_succeeded",
-\t\t});
-\t});
-});
-`;
-}
-function billingDrizzleSchemaFile(database) {
-    const dialect = drizzleDialects[database];
-    const idColumn = database === "mysql"
-        ? (columnName) => `varchar("${columnName}", { length: 255 })`
-        : (columnName) => `text("${columnName}")`;
-    const imports = database === "mysql"
-        ? "mysqlTable, uniqueIndex, varchar"
-        : `${dialect.tableFunction}, text, uniqueIndex`;
-    return `import type { BillingPlan, BillingStatus } from "@/features/billing/schemas";
-import { ${imports} } from "${dialect.columnModule}";
-
-export const billingAccounts = ${dialect.tableFunction}(
-\t"billing_accounts",
-\t{
-\t\ttenantId: ${idColumn("tenant_id")}.primaryKey(),
-\t\tplan: ${idColumn("plan")}.$type<BillingPlan>().notNull(),
-\t\tstatus: ${idColumn("status")}.$type<BillingStatus>().notNull(),
-\t\tprovider: ${idColumn("provider")}.notNull(),
-\t\tcustomerId: ${idColumn("customer_id")},
-\t\tsubscriptionId: ${idColumn("subscription_id")},
-\t\tcurrentPeriodEnd: ${idColumn("current_period_end")},
-\t\tcancelAtPeriodEnd: ${idColumn("cancel_at_period_end")}.$type<"true" | "false">(),
-\t\tcheckoutSessionId: ${idColumn("checkout_session_id")},
-\t\tlastEventId: ${idColumn("last_event_id")},
-\t\tupdatedAt: ${idColumn("updated_at")}.notNull(),
-\t},
-\t(table) => ({
-\t\tproviderCustomerUnique: uniqueIndex(
-\t\t\t"billing_accounts_provider_customer_unique",
-\t\t).on(table.provider, table.customerId),
-\t\tproviderSubscriptionUnique: uniqueIndex(
-\t\t\t"billing_accounts_provider_subscription_unique",
-\t\t).on(table.provider, table.subscriptionId),
-\t}),
-);
-`;
-}
-function billingDrizzleRepositoryFile(config, database) {
-    const dialect = drizzleDialects[database];
-    const billingPortPath = path.join(config.paths.features, "billing/ports.ts");
-    const upsert = database === "mysql"
-        ? `\t\t\tconst row = toRow(input);
-\t\t\tawait db
-\t\t\t\t.insert(schema.billingAccounts)
-\t\t\t\t.values(row)
-\t\t\t\t.onDuplicateKeyUpdate({ set: row });
-
-\t\t\tconst [saved] = await db
-\t\t\t\t.select()
-\t\t\t\t.from(schema.billingAccounts)
-\t\t\t\t.where(eq(schema.billingAccounts.tenantId, input.tenantId))
-\t\t\t\t.limit(1);
-
-\t\t\tif (!saved) {
-\t\t\t\tthrow new Error("Billing account save did not return a row.");
-\t\t\t}
-
-\t\t\treturn toBillingAccount(saved);`
-        : `\t\t\tconst [row] = await db
-\t\t\t\t.insert(schema.billingAccounts)
-\t\t\t\t.values(toRow(input))
-\t\t\t\t.onConflictDoUpdate({
-\t\t\t\t\ttarget: schema.billingAccounts.tenantId,
-\t\t\t\t\tset: toRow(input),
-\t\t\t\t})
-\t\t\t\t.returning();
-
-\t\t\tif (!row) {
-\t\t\t\tthrow new Error("Billing account save did not return a row.");
-\t\t\t}
-
-\t\t\treturn toBillingAccount(row);`;
-    return `import type { ${dialect.dbTypeName} } from "@beignet/provider-db-drizzle/${dialect.subpath}";
-import { and, eq } from "drizzle-orm";
-import type {
-\tBillingAccount,
-\tBillingRepository,
-\tSaveBillingAccountInput,
-} from "${aliasModule(billingPortPath)}";
-import * as schema from "@/infra/db/schema";
-
-type BillingAccountRow = typeof schema.billingAccounts.$inferSelect;
-
-function toBillingAccount(row: BillingAccountRow): BillingAccount {
-\treturn {
-\t\ttenantId: row.tenantId,
-\t\tplan: row.plan,
-\t\tstatus: row.status,
-\t\tprovider: row.provider,
-\t\t...(row.customerId ? { customerId: row.customerId } : {}),
-\t\t...(row.subscriptionId ? { subscriptionId: row.subscriptionId } : {}),
-\t\t...(row.currentPeriodEnd ? { currentPeriodEnd: row.currentPeriodEnd } : {}),
-\t\t...(row.cancelAtPeriodEnd
-\t\t\t? { cancelAtPeriodEnd: row.cancelAtPeriodEnd === "true" }
-\t\t\t: {}),
-\t\t...(row.checkoutSessionId
-\t\t\t? { checkoutSessionId: row.checkoutSessionId }
-\t\t\t: {}),
-\t\t...(row.lastEventId ? { lastEventId: row.lastEventId } : {}),
-\t\tupdatedAt: row.updatedAt,
-\t};
-}
-
-function toRow(input: SaveBillingAccountInput) {
-\treturn {
-\t\ttenantId: input.tenantId,
-\t\tplan: input.plan,
-\t\tstatus: input.status,
-\t\tprovider: input.provider,
-\t\tcustomerId: input.customerId ?? null,
-\t\tsubscriptionId: input.subscriptionId ?? null,
-\t\tcurrentPeriodEnd: input.currentPeriodEnd ?? null,
-\t\tcancelAtPeriodEnd:
-\t\t\tinput.cancelAtPeriodEnd === undefined
-\t\t\t\t? null
-\t\t\t\t: input.cancelAtPeriodEnd
-\t\t\t\t\t? ("true" as const)
-\t\t\t\t\t: ("false" as const),
-\t\tcheckoutSessionId: input.checkoutSessionId ?? null,
-\t\tlastEventId: input.lastEventId ?? null,
-\t\tupdatedAt: input.updatedAt,
-\t};
-}
-
-export function createDrizzleBillingRepository(
-\tdb: ${dialect.dbTypeName}<typeof schema>,
-): BillingRepository {
-\treturn {
-\t\tasync findByTenantId(tenantId) {
-\t\t\tconst [row] = await db
-\t\t\t\t.select()
-\t\t\t\t.from(schema.billingAccounts)
-\t\t\t\t.where(eq(schema.billingAccounts.tenantId, tenantId))
-\t\t\t\t.limit(1);
-
-\t\t\treturn row ? toBillingAccount(row) : null;
-\t\t},
-
-\t\tasync findByCustomerId(customerId, provider) {
-\t\t\tconst rows = await db
-\t\t\t\t.select()
-\t\t\t\t.from(schema.billingAccounts)
-\t\t\t\t.where(
-\t\t\t\t\tand(
-\t\t\t\t\t\teq(schema.billingAccounts.customerId, customerId),
-\t\t\t\t\t\teq(schema.billingAccounts.provider, provider),
-\t\t\t\t\t),
-\t\t\t\t)
-\t\t\t\t.limit(2);
-
-\t\t\tif (rows.length > 1) {
-\t\t\t\tthrow new Error(
-\t\t\t\t\t\`Multiple billing accounts found for provider "\${provider}" customer "\${customerId}".\`,
-\t\t\t\t);
-\t\t\t}
-
-\t\t\treturn rows[0] ? toBillingAccount(rows[0]) : null;
-\t\t},
-
-\t\tasync save(input) {
-${upsert}
-\t\t},
-\t};
-}
-`;
-}
-function billingWebhookRouteFile() {
-    return `import { createPaymentWebhookRoute } from "@beignet/next";
-import { handlePaymentWebhookUseCase } from "@/features/billing/use-cases";
-import { server } from "@/server";
-
-export const runtime = "nodejs";
-
-export const { POST } = createPaymentWebhookRoute({
-\tserver,
-\thandle: async ({ ctx, event }) => {
-\t\tawait handlePaymentWebhookUseCase.run({ ctx, input: event });
-\t\treturn {
-\t\t\tstatus: 200,
-\t\t\tbody: {
-\t\t\t\treceived: true,
-\t\t\t},
-\t\t};
-\t},
-});
-`;
-}
 function featureUiComponentFile(names, config) {
     const componentPath = featureUiComponentFilePath(names, config);
     const clientQueriesPath = featureUiClientQueriesFilePath(names, config);
@@ -7345,12 +3713,12 @@ 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)}";
+import { getServer } from "${aliasModule(config.paths.server)}";
 
 export const runtime = "nodejs";
 
 export const { GET, POST } = createScheduleRoute({
-\tserver,
+\tserver: getServer,
 \tschedules: [${names.scheduleExportName}],
 \tschedule: ${names.scheduleExportName}.name,
 \tsecret: env.CRON_SECRET,