@beignet/cli 0.0.14 → 0.0.16

package/dist/make.js

@@ -218,6 +218,13 @@ async function makeFeatureAddon(addon, feature, options) {
     if (addon === "policy") {
         return makePolicy({ ...shared, name: feature });
     }
+    if (addon === "factory") {
+        return makeFactory({
+            ...shared,
+            name: `${feature}/${singularize(feature)}`,
+            skipPersistenceAssert: true,
+        });
+    }
     if (addon === "task") {
         return makeTask({ ...shared, name: `${feature}/backfill` });
     }
@@ -227,9 +234,27 @@ async function makeFeatureAddon(addon, feature, options) {
     if (addon === "job") {
         return makeJob({ ...shared, name: `${feature}/process` });
     }
+    if (addon === "listener") {
+        return makeListener({
+            ...shared,
+            name: `${feature}/handle-created`,
+            event: `${feature}/created`,
+            skipEventAssert: true,
+        });
+    }
     if (addon === "notification") {
         return makeNotification({ ...shared, name: `${feature}/created` });
     }
+    if (addon === "schedule") {
+        return makeSchedule({ ...shared, name: `${feature}/daily-summary` });
+    }
+    if (addon === "seed") {
+        return makeSeed({
+            ...shared,
+            name: `${feature}/demo-${feature}`,
+            skipPersistenceAssert: true,
+        });
+    }
     if (addon === "ui") {
         return makeFeatureUi({ ...shared, name: feature });
     }
@@ -238,16 +263,30 @@ async function makeFeatureAddon(addon, feature, options) {
 function normalizeMakeFeatureAddons(addons) {
     const normalized = new Set();
     for (const addon of addons) {
-        if (addon === "events")
+        if (addon === "factories")
+            normalized.add("factory");
+        else if (addon === "events")
+            normalized.add("event");
+        else if (addon === "listeners") {
             normalized.add("event");
+            normalized.add("listener");
+        }
         else if (addon === "tasks")
             normalized.add("task");
         else if (addon === "jobs")
             normalized.add("job");
         else if (addon === "notifications")
             normalized.add("notification");
+        else if (addon === "schedules")
+            normalized.add("schedule");
+        else if (addon === "seeds")
+            normalized.add("seed");
         else if (addon === "uploads")
             normalized.add("upload");
+        else if (addon === "listener") {
+            normalized.add("event");
+            normalized.add("listener");
+        }
         else
             normalized.add(addon);
     }
@@ -255,10 +294,14 @@ function normalizeMakeFeatureAddons(addons) {
 }
 const featureAddonOrder = [
     "policy",
+    "factory",
     "task",
     "event",
     "job",
+    "listener",
     "notification",
+    "schedule",
+    "seed",
     "ui",
     "upload",
 ];
@@ -271,6 +314,21 @@ function mergeMakeResults(left, right) {
         skippedFiles: uniqueStrings([...left.skippedFiles, ...right.skippedFiles]),
     };
 }
+function mergeMakeResultInto(target, source) {
+    target.files = uniqueStrings([...target.files, ...source.files]);
+    target.createdFiles = uniqueStrings([
+        ...target.createdFiles,
+        ...source.createdFiles,
+    ]);
+    target.updatedFiles = uniqueStrings([
+        ...target.updatedFiles,
+        ...source.updatedFiles,
+    ]);
+    target.skippedFiles = uniqueStrings([
+        ...target.skippedFiles,
+        ...source.skippedFiles,
+    ]);
+}
 function uniqueStrings(values) {
     return [...new Set(values)];
 }
@@ -522,6 +580,8 @@ export async function makeEvent(options) {
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
     await assertFeatureArtifactApp(targetDir, config, "event");
+    await assertServerRuntimeApp(targetDir, config, "event");
+    await updateOutboxPortWiring(targetDir, config, { dryRun: true });
     // Events are published through ctx.ports.eventBus, so the generator wires
     // the port and an in-memory dev provider when the app has no bus yet. Plan
     // the wiring before writing any files so an anchor miss aborts the
@@ -530,6 +590,9 @@ export async function makeEvent(options) {
     await wirePortProviders(targetDir, config, eventBusWirings, {
         dryRun: true,
     });
+    const outboxDrainPlan = await planOutboxDrainWiring(targetDir, config, {
+        force: Boolean(options.force),
+    });
     const result = await makeFeatureArtifact({
         targetDir,
         config,
@@ -545,6 +608,12 @@ export async function makeEvent(options) {
     await applyOutboxRegistryUpdate(result, targetDir, names, "events", config, {
         dryRun: Boolean(options.dryRun),
     });
+    await applyOutboxDrainWiring(result, targetDir, outboxDrainPlan, {
+        dryRun: Boolean(options.dryRun),
+    });
+    await applyOutboxPortWiring(result, targetDir, config, {
+        dryRun: Boolean(options.dryRun),
+    });
     await applyPortProviderWiring(result, targetDir, config, eventBusWirings, {
         dryRun: Boolean(options.dryRun),
     });
@@ -557,6 +626,11 @@ export async function makeJob(options) {
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
     await assertFeatureArtifactApp(targetDir, config, "job");
+    await assertServerRuntimeApp(targetDir, config, "job");
+    await updateOutboxPortWiring(targetDir, config, { dryRun: true });
+    const outboxDrainPlan = await planOutboxDrainWiring(targetDir, config, {
+        force: Boolean(options.force),
+    });
     const result = await makeFeatureArtifact({
         targetDir,
         config,
@@ -575,6 +649,12 @@ export async function makeJob(options) {
     await applyOutboxRegistryUpdate(result, targetDir, names, "jobs", config, {
         dryRun: Boolean(options.dryRun),
     });
+    await applyOutboxDrainWiring(result, targetDir, outboxDrainPlan, {
+        dryRun: Boolean(options.dryRun),
+    });
+    await applyOutboxPortWiring(result, targetDir, config, {
+        dryRun: Boolean(options.dryRun),
+    });
     return result;
 }
 export async function makeTask(options) {
@@ -619,7 +699,9 @@ export async function makeFactory(options) {
     const config = options.config
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
-    await assertPersistenceArtifactApp(targetDir, names, config, "factory");
+    if (!options.skipPersistenceAssert) {
+        await assertPersistenceArtifactApp(targetDir, names, config, "factory");
+    }
     return makeFeatureArtifact({
         targetDir,
         config,
@@ -639,8 +721,10 @@ export async function makeSeed(options) {
     const config = options.config
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
-    await assertPersistenceArtifactApp(targetDir, names, config, "seed");
-    return makeFeatureArtifact({
+    if (!options.skipPersistenceAssert) {
+        await assertPersistenceArtifactApp(targetDir, names, config, "seed");
+    }
+    const result = await makeFeatureArtifact({
         targetDir,
         config,
         force: Boolean(options.force),
@@ -652,6 +736,38 @@ export async function makeSeed(options) {
             "@beignet/core": beignetDependencyVersion,
         },
     });
+    const factoryNamesForSeed = defaultFactoryNamesForSeed(names);
+    if (!(await fileExists(path.join(targetDir, factoryFilePath(factoryNamesForSeed, config))))) {
+        const factoryResult = await makeFeatureArtifact({
+            targetDir,
+            config,
+            force: Boolean(options.force),
+            dryRun: Boolean(options.dryRun),
+            name: `${factoryNamesForSeed.feature.kebab}/${factoryNamesForSeed.artifact.kebab}`,
+            files: factoryFiles(factoryNamesForSeed, config),
+            index: featureArtifactIndexFile("factory", factoryNamesForSeed, config),
+            dependencies: {
+                "@beignet/core": beignetDependencyVersion,
+            },
+        });
+        mergeMakeResultInto(result, factoryResult);
+    }
+    const seedEntrypointResult = await updateSeedEntrypoint(targetDir, names, config, { dryRun: Boolean(options.dryRun) });
+    if (seedEntrypointResult === "created")
+        result.createdFiles.push(seedEntrypointPath(config));
+    if (seedEntrypointResult === "updated")
+        result.updatedFiles.push(seedEntrypointPath(config));
+    if (seedEntrypointResult === "skipped")
+        result.skippedFiles.push(seedEntrypointPath(config));
+    if (!result.files.includes(seedEntrypointPath(config))) {
+        result.files.push(seedEntrypointPath(config));
+    }
+    if (await updatePackageScripts(targetDir, { "db:seed": `bun ${seedEntrypointPath(config)}` }, { dryRun: Boolean(options.dryRun) })) {
+        result.updatedFiles.push("package.json");
+        if (!result.files.includes("package.json"))
+            result.files.push("package.json");
+    }
+    return result;
 }
 export async function makeNotification(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
@@ -696,7 +812,9 @@ export async function makeListener(options) {
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
     await assertFeatureArtifactApp(targetDir, config, "listener");
-    await assertListenerEventExists(targetDir, names.event, config);
+    if (!options.skipEventAssert) {
+        await assertListenerEventExists(targetDir, names.event, config);
+    }
     return makeFeatureArtifact({
         targetDir,
         config,
@@ -850,6 +968,164 @@ async function applyCronSecretWiring(targetDir, plan, options) {
         skippedFiles: plan.skippedFiles,
     };
 }
+async function planOutboxDrainWiring(targetDir, config, options) {
+    if (await fileExists(path.join(targetDir, outboxDrainRoutePath(config)))) {
+        return undefined;
+    }
+    const route = await planGeneratedFile(targetDir, {
+        path: outboxDrainRoutePath(config),
+        content: outboxDrainRouteFile(config),
+    }, { force: options.force });
+    return {
+        route,
+        cronSecret: await planCronSecretWiring(targetDir),
+    };
+}
+async function updateOutboxPortWiring(targetDir, config, options) {
+    const updated = new Set();
+    if (await updateOutboxPorts(targetDir, config, options)) {
+        updated.add(config.paths.ports);
+    }
+    if (await updateOutboxInfrastructurePorts(targetDir, config, options)) {
+        updated.add(config.paths.infrastructurePorts);
+    }
+    if (await updateOutboxDatabaseProvider(targetDir, config, options)) {
+        updated.add(path.join(infrastructureDir(config), "db/provider.ts"));
+    }
+    if (await updateOutboxRepositoriesReturnType(targetDir, config, options)) {
+        updated.add(drizzleRepositoriesPath(config));
+    }
+    return [...updated];
+}
+async function applyOutboxPortWiring(result, targetDir, config, options) {
+    const updatedFiles = await updateOutboxPortWiring(targetDir, config, options);
+    for (const file of updatedFiles) {
+        if (!result.updatedFiles.includes(file))
+            result.updatedFiles.push(file);
+        if (!result.files.includes(file))
+            result.files.push(file);
+    }
+}
+async function updateOutboxPorts(targetDir, config, options) {
+    const filePath = path.join(targetDir, config.paths.ports);
+    const original = await readFile(filePath, "utf8");
+    let next = addNamedTypeImport(original, "OutboxPort", "@beignet/core/outbox");
+    if (!typeHasTopLevelProperty(next, "AppPorts", "outbox")) {
+        next = insertTypeProperty(next, "AppPorts", "outbox: OutboxPort;", `Could not find AppPorts in ${config.paths.ports}. Add outbox: OutboxPort; manually, or restore the generated ports file before running make outbox.`);
+    }
+    if (!typeHasTopLevelProperty(next, "AppTransactionPorts", "outbox")) {
+        next = insertTypeProperty(next, "AppTransactionPorts", "outbox: OutboxPort;", `Could not find AppTransactionPorts in ${config.paths.ports}. Add outbox: OutboxPort; manually, or restore the generated ports file before running make outbox.`);
+    }
+    if (next === original)
+        return false;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
+async function updateOutboxInfrastructurePorts(targetDir, config, options) {
+    const filePath = path.join(targetDir, config.paths.infrastructurePorts);
+    const original = await readFile(filePath, "utf8");
+    const next = appendDeferredPortKey(original, "outbox");
+    if (next === original)
+        return false;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
+async function updateOutboxDatabaseProvider(targetDir, config, options) {
+    const file = path.join(infrastructureDir(config), "db/provider.ts");
+    const filePath = path.join(targetDir, file);
+    if (!(await fileExists(filePath)))
+        return false;
+    const database = await detectResourceDatabase(targetDir, config);
+    const factoryName = drizzleOutboxPortFactoryName(database);
+    const original = await readFile(filePath, "utf8");
+    let next = addNamedImport(original, factoryName, `@beignet/provider-db-drizzle/${database}`);
+    next = appendPickStringLiteralMember(next, "AppPorts", "outbox");
+    if (!/\bconst\s+outbox\s*=/.test(next)) {
+        const beforeOutboxConst = next;
+        next = beforeOutboxConst.replace(/(\n\s*const idempotency = createDrizzle[A-Za-z]+IdempotencyPort\(dbPort\.db\);)/, `$1\n\t\tconst outbox = ${factoryName}(dbPort.db);`);
+        if (next === beforeOutboxConst) {
+            throw new Error(`Could not find the idempotency port in ${file}. Add const outbox = ${factoryName}(dbPort.db) manually, or restore the generated database provider before running make outbox.`);
+        }
+    }
+    if (!/\boutbox\s*,/.test(next)) {
+        const withOutboxPort = next.replace(/(\n\s*idempotency,\n)/, `$1\t\t\toutbox,\n`);
+        if (withOutboxPort === next) {
+            throw new Error(`Could not find idempotency in providedPorts in ${file}. Add outbox to providedPorts manually, or restore the generated database provider before running make outbox.`);
+        }
+        next = withOutboxPort;
+    }
+    if (!new RegExp(`outbox:\\s*${factoryName}\\(tx\\)`).test(next)) {
+        const withTransactionOutbox = next.replace(/(\n\s*idempotency: createDrizzle[A-Za-z]+IdempotencyPort\(tx\),\n)/, `$1\t\t\t\t\toutbox: ${factoryName}(tx),\n`);
+        if (withTransactionOutbox === next) {
+            throw new Error(`Could not find transaction idempotency wiring in ${file}. Add outbox: ${factoryName}(tx) manually, or restore the generated database provider before running make outbox.`);
+        }
+        next = withTransactionOutbox;
+    }
+    if (next === original)
+        return false;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
+async function updateOutboxRepositoriesReturnType(targetDir, config, options) {
+    const file = drizzleRepositoriesPath(config);
+    const filePath = path.join(targetDir, file);
+    if (!(await fileExists(filePath)))
+        return false;
+    const original = await readFile(filePath, "utf8");
+    const next = original.replace(/Omit<AppTransactionPorts,\s*"idempotency"\s*>/g, 'Omit<AppTransactionPorts, "idempotency" | "outbox">');
+    if (next === original)
+        return false;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
+function drizzleOutboxPortFactoryName(database) {
+    if (database === "postgres")
+        return "createDrizzlePostgresOutboxPort";
+    if (database === "mysql")
+        return "createDrizzleMysqlOutboxPort";
+    return "createDrizzleSqliteOutboxPort";
+}
+async function applyOutboxDrainWiring(result, targetDir, plan, options) {
+    if (!plan)
+        return;
+    if (!options.dryRun) {
+        await writePlannedGeneratedFile(targetDir, plan.route);
+    }
+    if (plan.route.result === "created") {
+        result.createdFiles.push(plan.route.path);
+    }
+    if (plan.route.result === "updated") {
+        result.updatedFiles.push(plan.route.path);
+    }
+    if (plan.route.result === "skipped") {
+        result.skippedFiles.push(plan.route.path);
+    }
+    if (!result.files.includes(plan.route.path)) {
+        result.files.push(plan.route.path);
+    }
+    const cronSecretResult = await applyCronSecretWiring(targetDir, plan.cronSecret, options);
+    result.createdFiles = uniqueStrings([
+        ...result.createdFiles,
+        ...cronSecretResult.createdFiles,
+    ]);
+    result.updatedFiles = uniqueStrings([
+        ...result.updatedFiles,
+        ...cronSecretResult.updatedFiles,
+    ]);
+    result.skippedFiles = uniqueStrings([
+        ...result.skippedFiles,
+        ...cronSecretResult.skippedFiles,
+    ]);
+    result.files = uniqueStrings([
+        ...result.files,
+        ...plan.cronSecret.files.map((file) => file.path),
+        ...plan.cronSecret.skippedFiles,
+    ]);
+}
 function eventBusPortWiring(command) {
     return {
         command,
@@ -891,6 +1167,17 @@ function paymentsPortWiring(command) {
         providerModule: "@beignet/core/payments",
     };
 }
+function storagePortWiring(command) {
+    return {
+        command,
+        portKey: "storage",
+        portType: "StoragePort",
+        portTypeModule: "@beignet/core/ports",
+        providerFactory: "createLocalStorageProvider",
+        providerModule: "@beignet/provider-storage-local",
+        dependency: "@beignet/provider-storage-local",
+    };
+}
 function providersFilePath(config) {
     return `${directoryPath(path.dirname(config.paths.server))}/providers.ts`;
 }
@@ -1011,7 +1298,10 @@ export async function makeUpload(options) {
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir);
     await assertFeatureArtifactApp(targetDir, config, "upload");
-    return makeFeatureArtifact({
+    await wirePortProviders(targetDir, config, [storagePortWiring("make upload")], {
+        dryRun: true,
+    });
+    const result = await makeFeatureArtifact({
         targetDir,
         config,
         force: Boolean(options.force),
@@ -1023,6 +1313,72 @@ export async function makeUpload(options) {
             "@beignet/core": beignetDependencyVersion,
         },
     });
+    await applyPortProviderWiring(result, targetDir, config, [storagePortWiring("make upload")], { dryRun: Boolean(options.dryRun) });
+    const uploadRouteResult = await updateUploadRoute(targetDir, names, config, {
+        dryRun: Boolean(options.dryRun),
+    });
+    if (uploadRouteResult === "created")
+        result.createdFiles.push(uploadRoutePath(config));
+    if (uploadRouteResult === "updated")
+        result.updatedFiles.push(uploadRoutePath(config));
+    if (uploadRouteResult === "skipped")
+        result.skippedFiles.push(uploadRoutePath(config));
+    if (!result.files.includes(uploadRoutePath(config))) {
+        result.files.push(uploadRoutePath(config));
+    }
+    return result;
+}
+export async function makeOutbox(options = {}) {
+    const targetDir = path.resolve(options.cwd ?? process.cwd());
+    const config = options.config
+        ? resolveConfig(options.config)
+        : await loadBeignetConfig(targetDir);
+    await assertServerRuntimeApp(targetDir, config, "outbox");
+    await updateOutboxPortWiring(targetDir, config, { dryRun: true });
+    const cronSecretPlan = await planCronSecretWiring(targetDir);
+    const files = outboxFiles(config);
+    const plannedFiles = await planGeneratedFiles(targetDir, files, {
+        force: Boolean(options.force),
+    });
+    const createdFiles = plannedFiles
+        .filter((file) => file.result === "created")
+        .map((file) => file.path);
+    const updatedFiles = plannedFiles
+        .filter((file) => file.result === "updated")
+        .map((file) => file.path);
+    const skippedFiles = plannedFiles
+        .filter((file) => file.result === "skipped")
+        .map((file) => file.path);
+    if (!options.dryRun) {
+        for (const file of plannedFiles) {
+            await writePlannedGeneratedFile(targetDir, file);
+        }
+    }
+    const cronSecretResult = await applyCronSecretWiring(targetDir, cronSecretPlan, { dryRun: Boolean(options.dryRun) });
+    createdFiles.push(...cronSecretResult.createdFiles);
+    updatedFiles.push(...cronSecretResult.updatedFiles);
+    skippedFiles.push(...cronSecretResult.skippedFiles);
+    updatedFiles.push(...(await updateOutboxPortWiring(targetDir, config, {
+        dryRun: Boolean(options.dryRun),
+    })));
+    return {
+        schemaVersion: 1,
+        name: "outbox",
+        targetDir,
+        dryRun: Boolean(options.dryRun),
+        files: [
+            ...files.map((file) => file.path),
+            ...cronSecretPlan.files.map((file) => file.path),
+            ...cronSecretPlan.skippedFiles,
+            config.paths.ports,
+            config.paths.infrastructurePorts,
+            path.join(infrastructureDir(config), "db/provider.ts"),
+            drizzleRepositoriesPath(config),
+        ],
+        createdFiles: uniqueStrings(createdFiles),
+        updatedFiles: uniqueStrings(updatedFiles),
+        skippedFiles: uniqueStrings(skippedFiles),
+    };
 }
 async function makeFeatureUi(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
@@ -1180,6 +1536,21 @@ async function assertFeatureUiApp(targetDir, config) {
         }
     }
 }
+async function assertServerRuntimeApp(targetDir, config, artifact) {
+    const requiredFiles = [
+        config.paths.appContext,
+        config.paths.server,
+        config.paths.infrastructurePorts,
+    ];
+    for (const file of requiredFiles) {
+        try {
+            await stat(path.join(targetDir, file));
+        }
+        catch {
+            throw new Error(`beignet make ${artifact} expects a standard Beignet app with a server runtime. Missing ${file}.`);
+        }
+    }
+}
 async function assertPersistenceArtifactApp(targetDir, names, config, artifact) {
     const requiredFiles = [
         config.paths.appContext,
@@ -1358,6 +1729,21 @@ async function updatePackageDependencies(targetDir, dependencies, options) {
         await writeFile(filePath, next);
     return true;
 }
+async function updatePackageScripts(targetDir, scripts, options) {
+    const filePath = path.join(targetDir, "package.json");
+    const original = await readFile(filePath, "utf8");
+    const packageJson = JSON.parse(original);
+    packageJson.scripts = packageJson.scripts ?? {};
+    for (const [name, command] of Object.entries(scripts)) {
+        packageJson.scripts[name] ??= command;
+    }
+    const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
+    if (next === original)
+        return false;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
 function beignetDependencyVersion(packageJson) {
     return (packageJson.dependencies?.["@beignet/core"] ??
         packageJson.dependencies?.["@beignet/next"] ??
@@ -2239,6 +2625,10 @@ function typeBodySource(source, typeName) {
         return undefined;
     return source.slice(openBrace + 1, closeBrace);
 }
+function typeHasTopLevelProperty(source, typeName, propertyName) {
+    const body = typeBodySource(source, typeName);
+    return body !== undefined && hasTopLevelObjectProperty(body, propertyName);
+}
 function appendUnionTypeMember(source, typeName, member) {
     const match = new RegExp(`(export\\s+type\\s+${typeName}\\s*=)([\\s\\S]*?);`).exec(source);
     if (!match)
@@ -2429,6 +2819,30 @@ function addNamedTypeImport(source, name, moduleName) {
         : `import type { ${names.join(", ")} } from "${moduleName}";`;
     return `${source.slice(0, match.index)}${replacement}${source.slice(match.index + match[0].length)}`;
 }
+function addNamedImport(source, name, moduleName) {
+    const escapedModule = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const importPattern = new RegExp(`import \\{([^}]*)\\} from "${escapedModule}";`);
+    const match = importPattern.exec(source);
+    if (!match) {
+        return insertAfterImports(source, `import { ${name} } from "${moduleName}";`);
+    }
+    const names = match[1]
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    if (names.includes(name))
+        return source;
+    const insertIndex = names.findIndex((existing) => existing.localeCompare(name) > 0);
+    if (insertIndex === -1)
+        names.push(name);
+    else
+        names.splice(insertIndex, 0, name);
+    const indent = match[1].match(/\n([\t ]+)/)?.[1] ?? "\t";
+    const replacement = match[1].includes("\n")
+        ? `import {\n${indent}${names.join(`,\n${indent}`)},\n} from "${moduleName}";`
+        : `import { ${names.join(", ")} } from "${moduleName}";`;
+    return `${source.slice(0, match.index)}${replacement}${source.slice(match.index + match[0].length)}`;
+}
 function topLevelBoundObjectRange(source, openBrace, closeBrace) {
     const body = source.slice(openBrace + 1, closeBrace);
     if (!hasTopLevelObjectProperty(body, "bound"))
@@ -2798,6 +3212,9 @@ function seedNames(input) {
         seedExportName,
     };
 }
+function defaultFactoryNamesForSeed(names) {
+    return factoryNames(`${names.feature.kebab}/${names.featureSingularKebab}`);
+}
 function notificationNames(input) {
     const names = featureArtifactNames(input, "Notification");
     const notificationExportName = `${names.featureSingularPascal}${names.artifact.pascal}Notification`;
@@ -3266,6 +3683,18 @@ function uploadFiles(names, config) {
         },
     ];
 }
+function outboxFiles(config) {
+    return [
+        {
+            path: config.paths.outbox,
+            content: outboxRegistryFile(config),
+        },
+        {
+            path: outboxDrainRoutePath(config),
+            content: outboxDrainRouteFile(config),
+        },
+    ];
+}
 function portFilePath(names, config) {
     return path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
 }
@@ -3450,6 +3879,15 @@ function scheduleFilePath(names, config) {
 function uploadFilePath(names, config) {
     return path.join(featureArtifactDir(names, "uploads", config), `${names.artifact.kebab}.ts`);
 }
+function seedEntrypointPath(config) {
+    return path.join(infrastructureDir(config), "db", "seed.ts");
+}
+function uploadRoutePath(config) {
+    return path.join(config.paths.routes, "uploads", "[uploadName]", "[action]", "route.ts");
+}
+function outboxDrainRoutePath(config) {
+    return path.join(config.paths.routes, "cron", "outbox", "drain", "route.ts");
+}
 function scheduleRouteFilePath(names, config) {
     return path.join(config.paths.routes, "cron", names.feature.kebab, names.artifact.kebab, "route.ts");
 }
@@ -3755,19 +4193,87 @@ export async function stopScheduleContext(): Promise<void> {
         await writeFile(destination, next);
     return "updated";
 }
+async function updateSeedEntrypoint(targetDir, names, config, options) {
+    const file = seedEntrypointPath(config);
+    const destination = path.join(targetDir, file);
+    const existing = await readOptionalFile(destination);
+    const registryName = `${names.featureSingularCamel}Seeds`;
+    const importLine = `import { ${registryName} } from "${aliasModule(path.join(featureArtifactDir(names, "seeds", config), "index.ts"))}";`;
+    const registryEntry = `...${registryName}`;
+    if (existing === undefined) {
+        const content = seedEntrypointFile(names, config);
+        if (!options.dryRun) {
+            await mkdir(path.dirname(destination), { recursive: true });
+            await writeFile(destination, content);
+        }
+        return "created";
+    }
+    let next = existing;
+    if (!next.includes(importLine)) {
+        next = insertAfterImports(next, importLine);
+    }
+    const registry = arrayInitializerInfo(next, "seeds");
+    if (!registry) {
+        next = `${next.trimEnd()}\n\nconst seeds = [${registryEntry}] as const;\n`;
+    }
+    else if (!identifiersFromArrayExpression(registry.text).has(registryName)) {
+        const nextArray = appendToArrayExpression(registry.text, [registryEntry]);
+        next = `${next.slice(0, registry.start)}${nextArray}${next.slice(registry.end)}`;
+    }
+    if (next === existing)
+        return "skipped";
+    if (!options.dryRun)
+        await writeFile(destination, next);
+    return "updated";
+}
+async function updateUploadRoute(targetDir, names, config, options) {
+    const file = uploadRoutePath(config);
+    const destination = path.join(targetDir, file);
+    const existing = await readOptionalFile(destination);
+    const registryName = `${names.featureSingularCamel}Uploads`;
+    const registryKey = names.featureSingularCamel;
+    const importLine = `import { ${registryName} } from "${aliasModule(path.join(featureArtifactDir(names, "uploads", config), "index.ts"))}";`;
+    if (existing === undefined) {
+        const content = uploadRouteFile(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 = defineUploadsInitializerInfo(next, "uploadRegistry");
+    if (!registry) {
+        return "skipped";
+    }
+    if (!new RegExp(`\\b${registryKey}\\s*:`).test(registry.text)) {
+        next = `${next.slice(0, registry.end)}\t${registryKey}: ${registryName},\n${next.slice(registry.end)}`;
+    }
+    if (next === existing)
+        return "skipped";
+    if (!options.dryRun)
+        await writeFile(destination, next);
+    return "updated";
+}
 /**
  * Append a feature event or job registry to `server/outbox.ts`.
- *
- * The outbox registry is opt-in, so this never creates the file; it returns
- * `undefined` when the app has no outbox module. It also bails to "skipped"
- * instead of writing when the `defineOutboxRegistry({...})` anchor is missing
- * or the matching array is not editable.
+ * Creates the registry when missing so event/job generators produce a complete
+ * drainable path instead of leaving durable delivery as manual wiring.
  */
 async function updateOutboxRegistry(targetDir, names, kind, config, options) {
     const destination = path.join(targetDir, config.paths.outbox);
     const existing = await readOptionalFile(destination);
-    if (existing === undefined)
-        return undefined;
+    if (existing === undefined) {
+        const content = outboxRegistryFile(config, { names, kind });
+        if (!options.dryRun) {
+            await mkdir(path.dirname(destination), { recursive: true });
+            await writeFile(destination, content);
+        }
+        return "created";
+    }
     const featureIndexPath = path.join(featureArtifactDir(names, kind, config), "index.ts");
     const registryName = `${names.featureSingularCamel}${kind === "events" ? "Events" : "Jobs"}`;
     const importLine = `import { ${registryName} } from "${aliasModule(featureIndexPath)}";`;
@@ -3786,8 +4292,8 @@ async function updateOutboxRegistry(targetDir, names, kind, config, options) {
  */
 async function applyOutboxRegistryUpdate(result, targetDir, names, kind, config, options) {
     const registryResult = await updateOutboxRegistry(targetDir, names, kind, config, options);
-    if (registryResult === undefined)
-        return;
+    if (registryResult === "created")
+        result.createdFiles.push(config.paths.outbox);
     if (registryResult === "updated")
         result.updatedFiles.push(config.paths.outbox);
     if (registryResult === "skipped")
@@ -5144,6 +5650,105 @@ export const ${names.uploadExportName} = defineUpload<
 });
 `;
 }
+function seedEntrypointFile(names, config) {
+    const registryName = `${names.featureSingularCamel}Seeds`;
+    return `import { createServiceActor } from "@beignet/core/ports";
+import { runSeeds } from "@beignet/core/testing";
+import { ${registryName} } from "${aliasModule(path.join(featureArtifactDir(names, "seeds", config), "index.ts"))}";
+import { server } from "${aliasModule(config.paths.server)}";
+
+const seeds = [...${registryName}] as const;
+
+const ctx = await server.createServiceContext({
+\tactor: createServiceActor("beignet-seed"),
+});
+
+try {
+\tawait runSeeds({ ctx, seeds });
+} finally {
+\tawait server.stop();
+}
+`;
+}
+function uploadRouteFile(names, config) {
+    const registryName = `${names.featureSingularCamel}Uploads`;
+    return `import {
+\tcreateUploadRouter,
+\tdefineUploads,
+\tuploadsFromRegistry,
+} from "@beignet/core/uploads";
+import { createUploadRoute } from "@beignet/next";
+import { ${registryName} } from "${aliasModule(path.join(featureArtifactDir(names, "uploads", config), "index.ts"))}";
+import { server } from "${aliasModule(config.paths.server)}";
+
+const uploadRegistry = defineUploads({
+\t${names.featureSingularCamel}: ${registryName},
+});
+
+const uploadRouter = createUploadRouter({
+\tuploads: uploadsFromRegistry(uploadRegistry),
+\tctx: () => server.createContextFromNext(),
+\tstorage: server.ports.storage,
+});
+
+export const { POST } = createUploadRoute(uploadRouter);
+`;
+}
+function outboxRegistryFile(config, registration) {
+    const featureRegistry = registration
+        ? outboxFeatureRegistry(registration.names, registration.kind, config)
+        : undefined;
+    const eventEntry = featureRegistry?.kind === "events" ? `...${featureRegistry.name}` : "";
+    const jobEntry = featureRegistry?.kind === "jobs" ? `...${featureRegistry.name}` : "";
+    const featureImport = featureRegistry
+        ? `${featureRegistry.importLine}\n`
+        : "";
+    return `import { defineOutboxRegistry } from "@beignet/core/outbox";
+import { createServiceActor } from "@beignet/core/ports";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+${featureImport}import { server } from "${relativeModule(config.paths.outbox, config.paths.server)}";
+
+export const outboxRegistry = defineOutboxRegistry({
+\tevents: [${eventEntry}],
+\tjobs: [${jobEntry}],
+});
+
+export async function createOutboxDrainContext(): Promise<AppContext> {
+\treturn server.createServiceContext({
+\t\tactor: createServiceActor("beignet-outbox"),
+\t});
+}
+
+export async function stopOutboxDrainContext(): Promise<void> {
+\tawait server.stop();
+}
+`;
+}
+function outboxDrainRouteFile(config) {
+    return `import { createOutboxDrainRoute } from "@beignet/next";
+import { env } from "@/lib/env";
+import { server } from "${aliasModule(config.paths.server)}";
+import { outboxRegistry } from "${aliasModule(config.paths.outbox)}";
+
+export const runtime = "nodejs";
+
+export const { GET, POST } = createOutboxDrainRoute({
+\tserver,
+\tregistry: outboxRegistry,
+\tsecret: env.CRON_SECRET,
+\tbatchSize: 100,
+});
+`;
+}
+function outboxFeatureRegistry(names, kind, config) {
+    const featureIndexPath = path.join(featureArtifactDir(names, kind, config), "index.ts");
+    const name = `${names.featureSingularCamel}${kind === "events" ? "Events" : "Jobs"}`;
+    return {
+        kind,
+        name,
+        importLine: `import { ${name} } from "${aliasModule(featureIndexPath)}";`,
+    };
+}
 function billingSchemasFile() {
     return `import { z } from "zod";
 
@@ -5832,7 +6437,7 @@ import type { AppContext } from "${relativeModule(routeFilePath, config.paths.ap
 import * as billingContracts from "@/features/billing/contracts";
 import * as billingUseCases from "@/features/billing/use-cases";
 
-export const billingRoutes = defineRouteGroup<AppContext>({
+export const billingRoutes = defineRouteGroup<AppContext>()({
 \tname: "billing",
 \troutes: [
 \t\t{
@@ -6480,7 +7085,7 @@ import {
 ${mode === "resource" ? `	delete${names.singularPascal}UseCase,\n	get${names.singularPascal}UseCase,\n` : ""}	list${names.pluralPascal}UseCase,
 ${mode === "resource" ? `	update${names.singularPascal}UseCase,\n` : ""}} from "${relativeModule(routeFilePath, useCasesPath)}";
 
-export const ${names.singularCamel}Routes = defineRouteGroup<AppContext>({
+export const ${names.singularCamel}Routes = defineRouteGroup<AppContext>()({
 	name: "${names.pluralKebab}",
 	routes: [
 		{ contract: list${names.pluralPascal}, useCase: list${names.pluralPascal}UseCase },