@beignet/cli 0.0.25 → 0.0.27

package/dist/make/shared.js

@@ -0,0 +1,2166 @@
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { clientIndexPath, directoryPath, normalizePath, } from "../config.js";
+import { appendToArrayExpression, appendToNamedArray, arrayInitializerInfo, identifiersFromArrayExpression, insertAfterImports, matchingDelimiterIndex, } from "../registry-edits.js";
+export 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 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]),
+    };
+}
+export 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,
+    ]);
+}
+export function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+export 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",
+    };
+}
+export 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",
+        },
+    ];
+}
+export function paymentsPortWiring(command) {
+    return {
+        command,
+        portKey: "payments",
+        portType: "PaymentsPort",
+        portTypeModule: "@beignet/core/payments",
+        providerFactory: "createMemoryPaymentsProvider",
+        providerModule: "@beignet/core/payments",
+    };
+}
+export 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",
+    };
+}
+export 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.
+ */
+export 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.
+ */
+export 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 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}.`);
+        }
+    }
+}
+export 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}.`);
+    }
+}
+export 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}.`);
+        }
+    }
+}
+export 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}.`);
+        }
+    }
+}
+export 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.`);
+    }
+}
+export 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}.`);
+    }
+}
+export 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}.`);
+        }
+    }
+}
+export 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}.`);
+        }
+    }
+}
+export 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}.`);
+        }
+    }
+}
+export 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.`);
+        }
+    }
+}
+export 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;
+}
+export async function planGeneratedFiles(targetDir, files, options) {
+    const plannedFiles = [];
+    for (const file of files) {
+        plannedFiles.push(await planGeneratedFile(targetDir, file, options));
+    }
+    return plannedFiles;
+}
+export 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" };
+}
+export 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);
+}
+export async function fileExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readOptionalFile(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export 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",
+    },
+};
+export 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;
+}
+export 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>();
+`,
+    };
+}
+export async function missingCapabilityBuilderFiles(targetDir, capability, config) {
+    const file = capabilityBuilderFile(capability, config);
+    if (await fileExists(path.join(targetDir, file.path))) {
+        return [];
+    }
+    return [file];
+}
+export 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;
+}
+export 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;
+}
+export function beignetDependencyVersion(packageJson) {
+    return (packageJson.dependencies?.["@beignet/core"] ??
+        packageJson.dependencies?.["@beignet/next"] ??
+        "*");
+}
+export function tanstackReactQueryDependencyVersion(packageJson) {
+    return packageJson.dependencies?.["@tanstack/react-query"] ?? "^5.100.7";
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+/**
+ * Add port keys to the database provider's `Pick<AppPorts, ...>` provided-port
+ * union. Shared by the payments, tenancy, and inbox generators.
+ */
+export async function updateDatabaseProviderPick(targetDir, config, keys, 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;
+    for (const key of keys) {
+        next = appendPickStringLiteralMember(next, "AppPorts", key);
+    }
+    if (next === original)
+        return false;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
+/**
+ * Add tables to the `tables` array in the database reset entrypoint so
+ * `beignet db reset` truncates generator-owned tables too.
+ */
+export async function updateDatabaseResetTables(targetDir, config, tableNames, 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");
+    const missingTables = tableNames.filter((table) => !new RegExp(`["']${table}["']`).test(original));
+    if (missingTables.length === 0)
+        return false;
+    const tables = arrayInitializerInfo(original, "tables");
+    if (!tables)
+        return false;
+    const nextArray = appendToArrayExpression(tables.text, missingTables.map((table) => `"${table}"`));
+    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;
+}
+/**
+ * Intersect the transaction-ports repositories dependency with
+ * `Pick<AppTransactionPorts, ...>` for generator-owned repository keys, so
+ * transaction-scoped use cases see the new ports.
+ */
+export async function updateTransactionPortsPick(targetDir, config, keys, generator, 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");
+    const firstKey = keys[0];
+    if (firstKey !== undefined &&
+        new RegExp(`Pick<AppTransactionPorts,\\s*["']${firstKey}["']`).test(original)) {
+        return false;
+    }
+    const keyList = keys.join(", ");
+    const repositoryProperty = /repositories:\s*([^;\n]+);/.exec(original);
+    const repositoryType = repositoryProperty?.[1]?.trim();
+    if (!repositoryProperty || !repositoryType) {
+        throw new Error(`Could not find repositories: ... in ${file}. Add ${keyList} to the transaction repository dependency manually, or restore the generated transaction ports file before running ${generator}.`);
+    }
+    const pick = keys.map((key) => `"${key}"`).join(" | ");
+    const next = original.replace(repositoryProperty[0], `repositories: ${repositoryType} & Pick<AppTransactionPorts, ${pick}>;`);
+    if (next === original)
+        return false;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
+/**
+ * Insert missing entries into the app's `defineErrors({ ... })` catalog.
+ * Entries are skipped when their name already appears anywhere in the file.
+ */
+export async function appendSharedErrorEntries(targetDir, config, entries, generator, 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 = entries.filter(({ name }) => !new RegExp(`\\b${name}\\b`).test(original));
+    if (missingEntries.length === 0)
+        return false;
+    const expectedErrorNames = missingEntries
+        .map(({ name }) => name)
+        .join(" and ");
+    const defineErrorsStart = original.indexOf("defineErrors(");
+    const openBrace = defineErrorsStart === -1 ? -1 : original.indexOf("{", defineErrorsStart);
+    if (openBrace === -1) {
+        throw new Error(`Could not find defineErrors({ in ${file}. Add ${expectedErrorNames} manually, or restore the generated shared error catalog before running ${generator}.`);
+    }
+    const closeBrace = matchingDelimiterIndex(original, openBrace, "{", "}");
+    if (closeBrace === -1) {
+        throw new Error(`Could not update ${file} because the error catalog object is malformed. Add ${expectedErrorNames} manually, or restore the generated shared error catalog before running ${generator}.`);
+    }
+    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;
+}
+/**
+ * Register contract exports with an array-literal `createOpenAPIHandler([...])`
+ * route. Apps that pass `contracts` derived from routes pick up new route
+ * groups automatically and need no edit.
+ */
+export async function updateOpenApiRouteContracts(targetDir, config, registration, 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 listedContracts = identifiersFromArrayExpression(firstArg.text);
+    const missingContracts = registration.contractNames.filter((contractName) => !listedContracts.has(contractName));
+    if (missingContracts.length === 0)
+        return false;
+    const importLine = `import { ${registration.contractNames.join(", ")} } from "${registration.contractsModule}";`;
+    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;
+}
+/**
+ * Append a schema module's table exports to the Drizzle schema index. The
+ * guard is the module specifier, so a hand-edited export list still skips.
+ */
+export async function updateDrizzleSchemaIndexExports(targetDir, config, registration, options) {
+    const filePath = path.join(targetDir, drizzleSchemaIndexPath(config));
+    if (!(await fileExists(filePath)))
+        return false;
+    const original = await readFile(filePath, "utf8");
+    if (original.includes(`from "${registration.module}"`))
+        return false;
+    const exportLine = `export { ${registration.exports.join(", ")} } from "${registration.module}";`;
+    const next = `${original.trimEnd()}\n${exportLine}\n`;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
+/**
+ * Detect the React Query client the full starter shell ships. The API-only
+ * starter keeps `client/index.ts` but drops the `rq` helper, so its presence
+ * decides whether a generator emits UI files.
+ */
+export async function detectUiShell(targetDir, config) {
+    const clientIndex = await readOptionalFile(path.join(targetDir, clientIndexPath(config)));
+    return clientIndex !== undefined && /\bexport const rq\b/.test(clientIndex);
+}
+export 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;
+}
+export 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;
+}
+export async function updateOpenApiRoute(targetDir, names, config, options) {
+    return updateOpenApiRouteContracts(targetDir, config, {
+        contractNames: resourceContractNames(names, options.mode),
+        contractsModule: aliasModule(resourceContractFilePath(names, config)),
+    }, options);
+}
+export async function updateSharedErrors(targetDir, names, config, options) {
+    if (options.mode !== "resource")
+        return false;
+    return appendSharedErrorEntries(targetDir, config, [
+        {
+            name: `${names.singularPascal}NotFound`,
+            entry: `${names.singularPascal}NotFound: {
+\t\tcode: "${constantCase(names.singularKebab)}_NOT_FOUND",
+\t\tstatus: 404,
+\t\tmessage: "${names.singularPascal} not found",
+\t},`,
+        },
+        {
+            name: `${names.singularPascal}Conflict`,
+            entry: `${names.singularPascal}Conflict: {
+\t\tcode: "${constantCase(names.singularKebab)}_CONFLICT",
+\t\tstatus: 409,
+\t\tmessage: "${names.singularPascal} was changed by another request",
+\t},`,
+        },
+    ], "make resource", options);
+}
+export 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);
+}
+export 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;
+}
+export function routeGroupIsRegistered(source, routeGroupName) {
+    const firstArg = firstDefineRoutesArgInfo(source);
+    if (!firstArg?.text.startsWith("["))
+        return false;
+    return identifiersFromArrayExpression(firstArg.text).has(routeGroupName);
+}
+export 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);
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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.`);
+    }
+}
+export function firstDefineRoutesArgInfo(source) {
+    const match = /defineRoutes(?:<[^>]+>)?\(/.exec(source);
+    if (!match)
+        return undefined;
+    return firstCallArgInfo(source, match.index + match[0].length);
+}
+export function firstCreateNextServerArgInfo(source) {
+    const match = /createNextServer(?:<[^>]+>)?\(/.exec(source);
+    if (!match)
+        return undefined;
+    return firstCallArgInfo(source, match.index + match[0].length);
+}
+export function firstCreateOpenAPIHandlerArgInfo(source) {
+    const start = source.indexOf("createOpenAPIHandler(");
+    if (start === -1)
+        return undefined;
+    return firstCallArgInfo(source, start + "createOpenAPIHandler(".length);
+}
+export 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;
+}
+export 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,
+    };
+}
+export function replaceRequired(source, searchValue, replaceValue, message) {
+    const next = source.replace(searchValue, replaceValue);
+    if (next === source)
+        throw new Error(message);
+    return next;
+}
+export 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);
+}
+export 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);
+}
+export 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)}`;
+}
+export 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)}`;
+}
+export 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)}`;
+}
+export 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)}`;
+}
+export 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)}`;
+}
+export function insertDefinePortsProperty(source, property, message) {
+    const body = definePortsBodyRange(source);
+    if (!body)
+        throw new Error(message);
+    return insertBeforeClosingBrace(source, body.openBrace, body.closeBrace, property);
+}
+export function insertNoopUnitOfWorkProperty(source, property, message) {
+    const body = noopUnitOfWorkBodyRange(source);
+    if (!body)
+        throw new Error(message);
+    return insertBeforeClosingBrace(source, body.openBrace, body.closeBrace, property);
+}
+export function insertDrizzleTransactionPortsProperty(source, property, message) {
+    const body = drizzleTransactionPortsBodyRange(source);
+    if (!body)
+        throw new Error(message);
+    return insertBeforeClosingBrace(source, body.openBrace, body.closeBrace, property);
+}
+export function insertCreateRepositoriesProperty(source, property, message) {
+    const body = createRepositoriesReturnBodyRange(source);
+    if (!body)
+        throw new Error(message);
+    return insertBeforeClosingBrace(source, body.openBrace, body.closeBrace, property);
+}
+export function noopUnitOfWorkBodySource(source) {
+    const body = noopUnitOfWorkBodyRange(source);
+    if (!body)
+        return undefined;
+    return source.slice(body.openBrace + 1, body.closeBrace);
+}
+export function drizzleTransactionPortsBodySource(source) {
+    const body = drizzleTransactionPortsBodyRange(source);
+    if (!body)
+        return undefined;
+    return source.slice(body.openBrace + 1, body.closeBrace);
+}
+export function createRepositoriesReturnBodySource(source) {
+    const body = createRepositoriesReturnBodyRange(source);
+    if (!body)
+        return undefined;
+    return source.slice(body.openBrace + 1, body.closeBrace);
+}
+export function definePortsBodySource(source) {
+    const body = definePortsBodyRange(source);
+    if (!body)
+        return undefined;
+    return source.slice(body.openBrace + 1, body.closeBrace);
+}
+export 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);
+}
+export 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 };
+}
+export 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.
+ */
+export 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)}`;
+}
+export 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)}`;
+}
+export 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 };
+}
+/**
+ * Whether the named type declares a top-level property, including optional
+ * (`name?:`) properties.
+ */
+export function typeHasTopLevelProperty(source, typeName, propertyName) {
+    const body = typeBodySource(source, typeName);
+    return body !== undefined && hasTopLevelObjectProperty(body, propertyName);
+}
+export 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++;
+        // Optional properties (`name?:`) count as present too.
+        if (source[cursor] === "?") {
+            cursor++;
+            while (/\s/.test(source[cursor] ?? ""))
+                cursor++;
+        }
+        if (source[cursor] === ":" || source[cursor] === ",")
+            return true;
+        index = cursor;
+    }
+    return false;
+}
+export const identifierStartPattern = /[$A-Z_a-z]/;
+export const identifierPartPattern = /[$\w]/;
+export function identifierAt(source, index) {
+    let cursor = index;
+    while (identifierPartPattern.test(source[cursor] ?? "")) {
+        cursor++;
+    }
+    return source.slice(index, cursor);
+}
+export 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 };
+}
+export 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 };
+}
+export 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 };
+}
+export 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 };
+}
+export 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)}`;
+}
+export function detectPropertyIndent(body) {
+    return (body
+        .split("\n")
+        .find((line) => line.trim())
+        ?.match(/^[\t ]*/)?.[0] ?? "\t");
+}
+export function matchingBraceIndex(source, openBrace) {
+    return matchingDelimiterIndex(source, openBrace, "{", "}");
+}
+export function replaceTransactionPortsRequired(source, entry, message) {
+    return insertTypeProperty(source, "AppTransactionPorts", entry.trim(), message);
+}
+export function aliasModule(filePath) {
+    return `@/${modulePath(filePath)}`;
+}
+export 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}`;
+}
+export function modulePath(filePath) {
+    return directoryPath(filePath)
+        .replace(/\.(?:[cm]?[jt]sx?)$/, "")
+        .replace(/\/index$/, "");
+}
+export 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;
+}
+export 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;
+}
+export function featureResourceNames(names) {
+    return resourceNames(names.feature.kebab);
+}
+export function identifierNames(input, label) {
+    const kebab = normalizeName(input, label);
+    return {
+        input,
+        kebab,
+        camel: camelCase(kebab),
+        pascal: pascalCase(kebab),
+    };
+}
+export 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;
+}
+export 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;
+}
+export 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,
+    };
+}
+export 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]];
+}
+export 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},`;
+}
+export function adapterEntry(names) {
+    return `\t${names.camel}: ${names.adapterFactoryName}(),`;
+}
+export function normalizeResourceName(input) {
+    return normalizeName(input, "Resource name");
+}
+export 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;
+}
+export 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.`);
+    }
+}
+export function isValidGeneratedIdentifier(identifier) {
+    return (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier) &&
+        !reservedJavaScriptIdentifiers.has(identifier));
+}
+export 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",
+]);
+export 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;
+}
+export function camelCase(value) {
+    return value.replaceAll(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+export function pascalCase(value) {
+    const camel = camelCase(value);
+    return `${camel.charAt(0).toUpperCase()}${camel.slice(1)}`;
+}
+export function constantCase(value) {
+    return value.replaceAll("-", "_").toUpperCase();
+}
+export function portFilePath(names, config) {
+    return path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
+}
+export function adapterFilePath(names, config) {
+    return path.join(path.dirname(config.paths.infrastructurePorts), names.kebab, `${names.kebab}-adapter.ts`);
+}
+export function infrastructureDir(config) {
+    return path.dirname(config.paths.infrastructurePorts);
+}
+export function drizzleSchemaIndexPath(config) {
+    return path.join(infrastructureDir(config), "db", "schema", "index.ts");
+}
+export function drizzleRepositoriesPath(config) {
+    return path.join(infrastructureDir(config), "db", "repositories.ts");
+}
+export function drizzleResourceRepositoryFilePath(names, config) {
+    return path.join(infrastructureDir(config), names.pluralKebab, `drizzle-${names.singularKebab}-repository.ts`);
+}
+export function resourceSharedErrorsPath(config) {
+    return path.join(config.paths.features, "shared", "errors.ts");
+}
+export 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;
+}
+export async function detectResourcePersistence(targetDir, config) {
+    return (await fileExists(path.join(targetDir, drizzleRepositoriesPath(config))))
+        ? "drizzle"
+        : "memory";
+}
+export 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";
+}
+export function resourceFeatureDir(names, config) {
+    return path.join(config.paths.features, names.pluralKebab);
+}
+export function featureUiDir(names, config) {
+    return path.join(resourceFeatureDir(names, config), "components");
+}
+export function featureUiClientDir(names, config) {
+    return path.join(resourceFeatureDir(names, config), "client");
+}
+export function featureUiClientQueriesFilePath(names, config) {
+    return path.join(featureUiClientDir(names, config), "queries.ts");
+}
+export function featureUiComponentFilePath(names, config) {
+    return path.join(featureUiDir(names, config), `${names.componentFileName}.tsx`);
+}
+export function featureUiIndexFilePath(names, config) {
+    return path.join(featureUiDir(names, config), "index.ts");
+}
+export function usesFeatureOwnedContracts(config) {
+    return (directoryPath(config.paths.contracts) ===
+        directoryPath(config.paths.features));
+}
+export function usesFeatureOwnedUseCases(config) {
+    return (directoryPath(config.paths.useCases) ===
+        directoryPath(config.paths.features));
+}
+export function usesFeatureOwnedPolicies(config) {
+    return (directoryPath(config.paths.policies) ===
+        directoryPath(config.paths.features));
+}
+export function usesFeatureOwnedTests(config) {
+    return (usesFeatureOwnedUseCases(config) &&
+        directoryPath(config.paths.tests) === "tests");
+}
+export function resourceContractFilePath(names, config) {
+    if (usesFeatureOwnedContracts(config)) {
+        return path.join(resourceFeatureDir(names, config), "contracts.ts");
+    }
+    return path.join(config.paths.contracts, `${names.pluralKebab}.ts`);
+}
+export function useCaseFeatureDir(feature, config) {
+    if (usesFeatureOwnedUseCases(config)) {
+        return path.join(config.paths.features, feature, "use-cases");
+    }
+    return path.join(config.paths.useCases, feature);
+}
+export 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`);
+}
+export 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);
+}
+export function eventFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "events", config), `${names.artifact.kebab}.ts`);
+}
+export function jobFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "jobs", config), `${names.artifact.kebab}.ts`);
+}
+export function taskFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "tasks", config), `${names.artifact.kebab}.ts`);
+}
+export function factoryFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "factories", config), `${names.artifact.kebab}.ts`);
+}
+export function seedFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "seeds", config), `${names.artifact.kebab}.ts`);
+}
+export function notificationFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "notifications", config), `${names.artifact.kebab}.ts`);
+}
+export function listenerFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "listeners", config), `${names.artifact.kebab}.ts`);
+}
+export function scheduleFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "schedules", config), `${names.artifact.kebab}.ts`);
+}
+export function uploadFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "uploads", config), `${names.artifact.kebab}.ts`);
+}
+/**
+ * The app-owned seed entrypoint lives beside the server runtime because it
+ * boots the app through `getServer()`; `beignet lint` forbids that import
+ * from `infra/`.
+ */
+export function seedEntrypointPath(config) {
+    return path.join(path.dirname(config.paths.server), "seed.ts");
+}
+export function useCaseFilePath(names, config) {
+    return path.join(useCaseFeatureDir(names.feature.kebab, config), `${names.action.kebab}.ts`);
+}
+export 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,
+    };
+}
+export 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)}`;
+        }
+    }
+    if (next === existing)
+        return "skipped";
+    if (!options.dryRun)
+        await writeFile(destination, next);
+    return "updated";
+}
+export 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";
+}
+export 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,
+    };
+}
+export 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 { getServer } from "${relativeModule(seedEntrypointPath(config), config.paths.server)}";
+
+const seeds = [...${registryName}] as const;
+const server = await getServer();
+
+const ctx = await server.createServiceContext({
+\tactor: createServiceActor("beignet-seed"),
+});
+
+try {
+\tawait runSeeds({ ctx, seeds });
+} finally {
+\tawait server.stop();
+}
+`;
+}
+//# sourceMappingURL=shared.js.map