anhedral 0.10.0 → 0.11.0

package/dist/ship.js

@@ -0,0 +1,211 @@
+import { existsSync, realpathSync, writeFileSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { defaultRunner } from './project-state.js';
+import { withLifecycleOperation } from './lifecycle.js';
+import { planDelivery, shipApplication } from './delivery.js';
+import { planProvisioning, provisionApplication } from './provision.js';
+import { planProviderProvisioning, provisionSelectedProviders } from './providers/provision.js';
+import { applicationRuntime, configuredRuntime, runtimeTargets, RUNTIME_KEYS, } from './providers/runtime.js';
+import { CREDENTIALS } from './providers/api.js';
+import { readApplication } from './project-state.js';
+import { planVercelDelivery, configureVercelEnvironment, shipVercelApplication } from './vercel.js';
+/** Provisioning can change tracked binding IDs; never silently commit that change. */
+async function executeCloudflareApplication(root, dryRun = false, run = defaultRunner, request, send = fetch, providerEnvironment = process.env, session) {
+    root = realpathSync(root);
+    const deployment = planDelivery(root, true);
+    const provisioning = planProvisioning(root);
+    const integrations = planProviderProvisioning(root);
+    if (dryRun)
+        return { ...deployment, provisioning, integrations, mutation: false };
+    if (deployment.project.audience === 'unconfigured' || !deployment.project.accountId)
+        throw new Error('Connect the intended account and audience before shipping.');
+    const environment = runtimeEnvironment(providerEnvironment);
+    const providerRun = (command, args, cwd, env) => run(command, args, cwd, runtimeEnvironment(env));
+    if (realpathSync((await run('git', ['rev-parse', '--show-toplevel'], root, environment)).trim()) !==
+        root ||
+        (await run('git', ['status', '--porcelain'], root, environment)).trim())
+        throw new Error('Shipping requires a clean application repository before provisioning.');
+    const commit = (await run('git', ['rev-parse', 'HEAD'], root, environment)).trim();
+    const application = await phase(session, 'application-runtime', () => applicationRuntime(root, providerRun));
+    await phase(session, 'checks', () => run('pnpm', ['run', 'check'], root, environment));
+    if ((await run('git', ['status', '--porcelain'], root, environment)).trim() ||
+        (await run('git', ['rev-parse', 'HEAD'], root, environment)).trim() !== commit)
+        throw new Error('Source changed during checks; provisioning was not started.');
+    const configured = await phase(session, 'integrations', () => provisionSelectedProviders(root, false, providerRun, send, providerEnvironment));
+    if (!configured.ready)
+        return { state: 'provider-configuration-required', deployed: false, integrations: configured };
+    if ((await run('git', ['status', '--porcelain'], root, environment)).trim() ||
+        (await run('git', ['rev-parse', 'HEAD'], root, environment)).trim() !== commit)
+        throw new Error('Source changed during provider configuration; provisioning was stopped.');
+    const resources = await phase(session, 'resources', () => provisionApplication(root, false, providerRun, request));
+    if ((await run('git', ['status', '--porcelain'], root, environment)).trim()) {
+        return {
+            state: 'configuration-required',
+            resources,
+            deployed: false,
+            nextAction: 'Review and commit the resolved resource bindings, then run anhedral ship again. No source commit or deployment was performed automatically.',
+        };
+    }
+    if ((await run('git', ['rev-parse', 'HEAD'], root, environment)).trim() !== commit)
+        throw new Error('Source changed during provider configuration; deployment was not started.');
+    const runtime = configuredRuntime(root);
+    const environments = mergeRuntimeTargets(runtimeTargets(root, runtime), application);
+    const buildRunner = async (command, args, cwd, env) => {
+        const values = environments[`${path.relative(root, cwd).split(path.sep).join('/')}/.dev.vars`];
+        const environment = runtimeEnvironment(env, values);
+        if (command !== 'pnpm' ||
+            args.join(' ') !== 'run deploy' ||
+            !values ||
+            !Object.keys(values).length)
+            return run(command, args, cwd, environment);
+        const file = path.join(tmpdir(), `anhedral-secrets-${randomUUID()}.json`);
+        try {
+            writeFileSync(file, JSON.stringify(values), { mode: 0o600, flag: 'wx' });
+            return await run(command, [...args, '--secrets-file', file], cwd, environment);
+        }
+        finally {
+            rmSync(file, { force: true });
+        }
+    };
+    return phase(session, 'deployment', () => shipApplication(root, buildRunner, request));
+}
+async function executeVercelApplication(root, dryRun = false, run = defaultRunner, send = fetch, providerEnvironment = process.env, session) {
+    const deployment = planVercelDelivery(root);
+    const integrations = planProviderProvisioning(root);
+    if (dryRun)
+        return { ...deployment, integrations, mutation: false };
+    if (!deployment.project.projectId ||
+        !deployment.project.teamId ||
+        deployment.project.audience === 'unconfigured')
+        throw new Error('Connect the intended Vercel account, plan and audience before shipping.');
+    const env = runtimeEnvironment(providerEnvironment);
+    const providerRun = (command, args, cwd, env) => run(command, args, cwd, runtimeEnvironment(env));
+    if (realpathSync((await run('git', ['rev-parse', '--show-toplevel'], root, env)).trim()) !==
+        realpathSync(root) ||
+        (await run('git', ['status', '--porcelain'], root, env)).trim())
+        throw new Error('Shipping requires a clean application repository before provisioning.');
+    const commit = (await run('git', ['rev-parse', 'HEAD'], root, env)).trim();
+    const application = await phase(session, 'application-runtime', () => applicationRuntime(root, providerRun));
+    await phase(session, 'checks', () => run('pnpm', ['run', 'check'], root, env));
+    if ((await run('git', ['status', '--porcelain'], root, env)).trim() ||
+        (await run('git', ['rev-parse', 'HEAD'], root, env)).trim() !== commit)
+        throw new Error('Source changed during checks; provisioning was not started.');
+    const configured = await phase(session, 'integrations', () => provisionSelectedProviders(root, false, providerRun, send, providerEnvironment));
+    if (!configured.ready)
+        return { state: 'provider-configuration-required', deployed: false, integrations: configured };
+    const runtime = configuredRuntime(root);
+    if ((await run('git', ['status', '--porcelain'], root, env)).trim() ||
+        (await run('git', ['rev-parse', 'HEAD'], root, env)).trim() !== commit)
+        throw new Error('Source changed during provider configuration; deployment was not started.');
+    const environments = mergeRuntimeTargets(runtimeTargets(root, runtime), application);
+    const values = environments['apps/web/.env.local'] ?? {};
+    await phase(session, 'runtime', () => configureVercelEnvironment(root, values, providerRun));
+    const buildRunner = (command, args, cwd, env) => run(command, args, cwd, runtimeEnvironment(env, values));
+    return phase(session, 'deployment', () => shipVercelApplication(root, buildRunner));
+}
+function phase(session, name, action) {
+    return session ? session.phase(name, action) : action();
+}
+export async function shipCloudflareApplication(root, dryRun = false, run = defaultRunner, request, send = fetch, providerEnvironment = process.env) {
+    if (dryRun)
+        return executeCloudflareApplication(root, true, run, request, send, providerEnvironment);
+    return withLifecycleOperation(root, 'cloudflare', run, (session) => executeCloudflareApplication(root, false, run, request, send, providerEnvironment, session));
+}
+export async function shipSelectedVercelApplication(root, dryRun = false, run = defaultRunner, send = fetch, providerEnvironment = process.env) {
+    if (dryRun)
+        return executeVercelApplication(root, true, run, send, providerEnvironment);
+    return withLifecycleOperation(root, 'vercel', run, (session) => executeVercelApplication(root, false, run, send, providerEnvironment, session));
+}
+function runtimeEnvironment(base, values = {}) {
+    const environment = { ...base, CI: '1', NO_COLOR: '1' };
+    for (const name of Object.values(CREDENTIALS))
+        delete environment[name];
+    for (const name of RUNTIME_KEYS)
+        if (!name.startsWith('NEXT_PUBLIC_') && !name.startsWith('EXPO_PUBLIC_'))
+            delete environment[name];
+    return { ...environment, ...values };
+}
+function mergeRuntimeTargets(providers, application) {
+    const targets = { ...providers };
+    for (const [file, values] of Object.entries(application))
+        targets[file] = { ...targets[file], ...values };
+    return targets;
+}
+/** Each mixed target keeps its own release receipt; this is not a provider transaction. */
+export async function shipSelectedStack(root, dryRun = false, run = defaultRunner, request, send = fetch, providerEnvironment = process.env) {
+    root = realpathSync(root);
+    const mixed = existsSync(path.join(root, 'anhedral.web.json')) &&
+        existsSync(path.join(root, 'anhedral.project.json')) &&
+        readApplication(root).targets.length > 0;
+    if (!mixed)
+        return existsSync(path.join(root, 'anhedral.web.json'))
+            ? shipSelectedVercelApplication(root, dryRun, run, send, providerEnvironment)
+            : shipCloudflareApplication(root, dryRun, run, request, send, providerEnvironment);
+    const cloudflare = planDelivery(root, true);
+    const vercel = planVercelDelivery(root);
+    if (dryRun)
+        return {
+            mutation: false,
+            dependencies: [
+                { target: 'cloudflare', after: [] },
+                { target: 'vercel', after: ['cloudflare'] },
+            ],
+            targets: [
+                { provider: 'cloudflare', ...cloudflare },
+                { provider: 'vercel', ...vercel },
+            ],
+            integrations: planProviderProvisioning(root),
+        };
+    if (!cloudflare.project.accountId ||
+        cloudflare.project.audience === 'unconfigured' ||
+        !vercel.project.projectId ||
+        !vercel.project.teamId ||
+        vercel.project.audience === 'unconfigured')
+        throw new Error('Connect both intended hosting accounts and audiences before mixed delivery.');
+    return withLifecycleOperation(root, 'mixed', run, async (session) => {
+        const scoped = (prefix) => ({
+            phase: (name, action) => session.phase(`${prefix}-${name}`, action),
+        });
+        const services = await executeCloudflareApplication(root, false, run, request, send, providerEnvironment, scoped('cloudflare'));
+        if ('state' in services &&
+            ['configuration-required', 'provider-configuration-required'].includes(services.state))
+            return {
+                state: services.state,
+                deployed: false,
+                targets: [{ provider: 'cloudflare', result: services }],
+                nextAction: 'Resolve Cloudflare setup and review source changes, then repeat ship. Vercel was not deployed.',
+            };
+        try {
+            const web = await executeVercelApplication(root, false, run, send, providerEnvironment, scoped('vercel'));
+            const blocked = 'state' in web && web.state === 'provider-configuration-required';
+            return {
+                state: blocked ? 'partial' : 'deployed',
+                deployed: !blocked,
+                targets: [
+                    { provider: 'cloudflare', result: services },
+                    { provider: 'vercel', result: web },
+                ],
+                productVerification: 'required',
+                ...(blocked
+                    ? {
+                        nextAction: 'Cloudflare completed. Resolve Vercel prerequisites and repeat ship; no resource or data rollback was attempted.',
+                    }
+                    : {}),
+            };
+        }
+        catch {
+            return {
+                state: 'partial',
+                deployed: false,
+                targets: [
+                    { provider: 'cloudflare', result: services },
+                    { provider: 'vercel', state: 'failed' },
+                ],
+                productVerification: 'required',
+                nextAction: 'Cloudflare completed; Vercel stopped. Inspect hosting status and the failed operation phase, then repeat the deployment plan. No resource or data rollback was attempted.',
+            };
+        }
+    });
+}

package/dist/stack-registry.d.ts

@@ -30,7 +30,7 @@ declare const PRODUCT_ITEMS: {
     styling: ItemDefinition;
 };
 export type StandardProduct = keyof typeof PRODUCT_ITEMS;
-export declare const STANDARD_PRODUCTS: readonly ("realtime" | "electron" | "wxt" | "expo" | "next" | "vinext" | "hono" | "neon" | "better-auth" | "queues" | "workflows" | "d1" | "local-data" | "clerk" | "r2" | "kv" | "cron" | "openai" | "ai-sdk" | "workers-ai" | "resend" | "stripe" | "revenuecat" | "sentry" | "basin" | "posthog" | "styling")[];
+export declare const STANDARD_PRODUCTS: readonly ("realtime" | "d1" | "r2" | "kv" | "queues" | "workflows" | "electron" | "wxt" | "expo" | "vinext" | "next" | "styling" | "hono" | "neon" | "local-data" | "clerk" | "better-auth" | "cron" | "openai" | "ai-sdk" | "workers-ai" | "resend" | "stripe" | "revenuecat" | "sentry" | "basin" | "posthog")[];
 declare const DEFINITIONS: {
     vinext: ItemDefinition;
     next: ItemDefinition;
@@ -67,7 +67,7 @@ declare const DEFINITIONS: {
 export type StackItemId = keyof typeof DEFINITIONS;
 export declare function getStackDefinition(name: string): ItemDefinition;
 export declare function getStackItem(name: string): StackRegistryItem;
-export declare const STACK_ITEMS: Record<"realtime" | "electron" | "eslint" | "typescript" | "wxt" | "expo" | "next" | "vinext" | "hono" | "neon" | "better-auth" | "queues" | "workflows" | "workspace" | "ui" | "d1" | "local-data" | "clerk" | "r2" | "kv" | "cron" | "openai" | "ai-sdk" | "workers-ai" | "resend" | "stripe" | "revenuecat" | "sentry" | "basin" | "posthog" | "styling", StackRegistryItem>;
+export declare const STACK_ITEMS: Record<"realtime" | "d1" | "r2" | "kv" | "queues" | "workflows" | "electron" | "eslint" | "typescript" | "wxt" | "expo" | "vinext" | "next" | "ui" | "workspace" | "styling" | "hono" | "neon" | "local-data" | "clerk" | "better-auth" | "cron" | "openai" | "ai-sdk" | "workers-ai" | "resend" | "stripe" | "revenuecat" | "sentry" | "basin" | "posthog", StackRegistryItem>;
 export declare const STACK_REGISTRY: {
     schemaVersion: number;
     name: string;

package/dist/stack-registry.js

@@ -1,3 +1,5 @@
+import { scaffoldStyling } from './scaffold/styling.js';
+import { resourceName } from './render.js';
 import { STACK_DEPENDENCIES } from './dependencies.js';
 import { dependencyOrder } from './dependency-order.js';
 import { GENERATOR_VERSION } from './version.js';
@@ -55,7 +57,7 @@ const PRODUCT_ITEMS = defineItems({
         type: 'application',
         description: 'Expo mobile application with native UI',
         targets: ['apps/mobile'],
-        registryDependencies: ['workspace', 'typescript', 'eslint'],
+        registryDependencies: ['workspace', 'typescript', 'eslint', 'styling'],
         setup: requirements('Mobile application', ['Expo/EAS CLI', 'Xcode or Android SDK'], ['Client-owned Apple/Google developer accounts for store delivery'], ['Platform signing credentials; EAS access when used'], ['Expo app; native adapters, signing, store configuration'], ['Native simulator/device flows and signed native build; web export alone is insufficient']),
         install: scaffoldExpo,
     },
@@ -71,7 +73,7 @@ const PRODUCT_ITEMS = defineItems({
         type: 'application',
         description: 'WXT browser side-panel extension',
         targets: ['apps/extension'],
-        registryDependencies: ['workspace', 'typescript', 'eslint'],
+        registryDependencies: ['workspace', 'typescript', 'eslint', 'styling'],
         setup: requirements('Chrome side-panel extension', ['Chrome', 'WXT'], ['Extension store publisher access for distribution'], ['Store publishing credentials when required'], ['Extension app; minimal browser permissions and store package'], ['Installed side panel, background/content messaging and permission behavior']),
         install: scaffoldWxt,
     },
@@ -106,7 +108,7 @@ const PRODUCT_ITEMS = defineItems({
             d1_databases: [
                 {
                     binding: 'DB',
-                    database_name: `${options.name}-db`,
+                    database_name: resourceName(options.name, 'db'),
                     database_id: 'REPLACE_WITH_D1_ID',
                     migrations_dir: '../../packages/db/migrations',
                 },
@@ -120,7 +122,12 @@ const PRODUCT_ITEMS = defineItems({
         targets: ['packages/local-data'],
         registryDependencies: ['workspace', 'typescript', 'eslint'],
         setup: requirements('Device-local SQLite and files', ['Selected platform database/filesystem tooling'], [], [], ['Integration boundary; implement platform adapters and explicit synchronization if needed'], ['Persistence, offline writes and recovery on the selected device']),
-        package: packageSource('local-data', '// Device-local SQLite and filesystem need platform-specific adapters.\nexport interface LocalDataStore { read(key: string): Promise<string | null>; write(key: string, value: string): Promise<void>; }\n', {}),
+        package: packageSource('local-data', `// Device-local SQLite and filesystem need platform-specific adapters.
+export interface LocalDataStore {
+  read(key: string): Promise<string | null>;
+  write(key: string, value: string): Promise<void>;
+}
+`, {}),
     },
     clerk: {
         type: 'integration',
@@ -130,7 +137,17 @@ const PRODUCT_ITEMS = defineItems({
         registryDependencies: ['workspace', 'typescript', 'eslint'],
         setup: requirements('Managed identity', ['Clerk integration or dashboard'], ['Client-owned Clerk project access'], ['Clerk publishable key; server secret key; webhook secret when used'], ['Identity project, allowed URLs, SDK setup and protected routes'], ['Sign-in/out, session expiry, resource authorization and selected native client flows']),
         install: scaffoldClerk,
-        environment: ['NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY', 'CLERK_SECRET_KEY'],
+        environment: [
+            'NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY',
+            'EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY',
+            'CLERK_PUBLISHABLE_KEY',
+            'CLERK_SECRET_KEY',
+        ],
+        resolveEnvironment: ({ has }) => [
+            'CLERK_SECRET_KEY',
+            ...(has('vinext') || has('next') ? ['NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY'] : []),
+            ...(has('hono') ? ['CLERK_PUBLISHABLE_KEY'] : []),
+        ],
         runtime: 'server',
         resolveDependencies: ({ has }) => ['vinext', 'next', 'hono'].filter((id) => has(id)),
         resolveTargets: ({ has }) => [
@@ -162,7 +179,7 @@ const PRODUCT_ITEMS = defineItems({
         ]),
         install: scaffoldPrivateFiles,
         configure: ({ options }) => ({
-            r2_buckets: [{ binding: 'FILES', bucket_name: `${options.name}-private-files` }],
+            r2_buckets: [{ binding: 'FILES', bucket_name: resourceName(options.name, 'private-files') }],
         }),
         runtime: 'worker',
         resolveTargets: ({ runtimeApp }) => [`apps/${runtimeApp}/private-files.md`],
@@ -194,7 +211,7 @@ const PRODUCT_ITEMS = defineItems({
         setup: requirements('Deferred jobs', ['Wrangler'], ['Cloudflare Queues configuration access'], [], ['Queue, producer/consumer bindings and failure handling'], ['Retries, idempotency, concurrency and dead-letter recovery']),
         install: scaffoldQueues,
         configure: ({ options }) => ({
-            queues: { producers: [{ binding: 'JOBS', queue: `${options.name}-jobs` }] },
+            queues: { producers: [{ binding: 'JOBS', queue: resourceName(options.name, 'jobs') }] },
         }),
         runtime: 'optional-worker',
         resolveTargets: ({ runtimeApp, has }) => [
@@ -277,6 +294,7 @@ const PRODUCT_ITEMS = defineItems({
         registryDependencies: ['stripe'],
         setup: requirements('Cross-store subscription entitlements alongside Stripe', ['RevenueCat integration or API', 'Selected mobile store tooling'], ['RevenueCat project; App Store/Play Store product access'], ['Platform public SDK keys; server API/webhook credentials as required'], ['Integration guidance only; install platform SDKs and configure offerings/store products'], ['Sandbox purchase/restore, verified webhooks and entitlement reconciliation']),
         install: scaffoldRevenueCat,
+        environment: ['EXPO_PUBLIC_REVENUECAT_IOS_API_KEY', 'EXPO_PUBLIC_REVENUECAT_ANDROID_API_KEY'],
     },
     sentry: {
         type: 'package',
@@ -298,7 +316,9 @@ const PRODUCT_ITEMS = defineItems({
             'Basin dataset/stream, ANALYTICS binding, optional private R2 sink and authorized sink writes',
         ], ['Private ingestion, event delivery, query results and archive retrieval when selected']),
         package: packageSource('analytics', `export interface EventStream { send(events: Record<string, unknown>[]): Promise<void> }
-export async function recordEvents(stream: EventStream, events: Record<string, unknown>[]) { await stream.send(events); }
+export async function recordEvents(stream: EventStream, events: Record<string, unknown>[]) {
+  await stream.send(events);
+}
 `, {}),
         resolvePackage: ({ has }, recipe) => ({
             ...recipe,
@@ -325,8 +345,21 @@ export async function recordEvents(stream: EventStream, events: Record<string, u
         description: 'Shared platform-independent styling tokens',
         targets: ['packages/styling'],
         registryDependencies: ['workspace', 'typescript', 'eslint'],
-        setup: requirements('Shared styling definitions', [], [], [], ['Styling package; implement actual shared colors, typography, spacing and themes'], ['Consistency across selected interfaces; preserve platform-specific components']),
-        package: packageSource('styling', "export const styling = { colors: { foreground: '#171717', background: '#ffffff' }, spacing: { small: 4, medium: 8, large: 16 } } as const;\n", {}),
+        setup: requirements('Shared styling definitions', [], [], [], [
+            'Shared light/dark tokens and Tailwind v3 preset for Expo/WXT; adapt platform typography and components',
+        ], ['Consistency across selected interfaces; preserve platform-specific components']),
+        package: packageSource('styling', `import { light, dark, spacing } from './tokens.cjs';
+
+export const styling = {
+  colors: {
+    foreground: 'hsl(' + light['--foreground'] + ')',
+    background: 'hsl(' + light['--background'] + ')',
+  },
+  spacing,
+  themes: { light, dark },
+};
+`, {}),
+        install: scaffoldStyling,
     },
 });
 export const STANDARD_PRODUCTS = Object.freeze(Object.keys(PRODUCT_ITEMS));
@@ -366,7 +399,7 @@ function freeze(value) {
 }
 const DEFINITIONS = freeze({ ...FOUNDATION_ITEMS, ...PRODUCT_ITEMS });
 function describe(definition) {
-    const { install: _install, configure: _configure, resolveTargets: _targets, resolveDependencies: _dependencies, resolvePackage: _package, fallbackDependency: _fallback, ...metadata } = definition;
+    const { install: _install, configure: _configure, resolveTargets: _targets, resolveEnvironment: _environment, resolveDependencies: _dependencies, resolvePackage: _package, fallbackDependency: _fallback, ...metadata } = definition;
     return structuredClone(metadata);
 }
 export function getStackDefinition(name) {

package/dist/standard.d.ts

@@ -1,7 +1,8 @@
 import { parseStandardOptions } from './registry/options.js';
 import { STANDARD_USAGE } from './registry/usage.js';
 import type { StandardOptions, StandardRunner } from './registry/types.js';
+import { type OutputOptions } from './cli-output.js';
 export { parseStandardOptions, STANDARD_USAGE };
 export { STANDARD_PRODUCTS } from './stack-registry.js';
 export type { StandardOptions, StandardProduct, StandardRunner } from './registry/types.js';
-export declare function scaffoldStandardProject(options: StandardOptions, run?: StandardRunner): Promise<void>;
+export declare function scaffoldStandardProject(options: StandardOptions, run?: StandardRunner, output?: OutputOptions): Promise<void>;

package/dist/standard.js

@@ -8,19 +8,22 @@ import { registerVercelApplication } from './vercel.js';
 import { registerApplication } from './delivery.js';
 import { runStagedTransaction } from './transaction.js';
 import { createSetupPlan } from './capabilities.js';
-import { bootstrapWorkspace, assertBootstrapPlatform } from './scaffold/bootstrap.js';
+import { bootstrapWorkspace, assertBootstrapPlatform, assertWorkspaceRuntime, } from './scaffold/bootstrap.js';
 import { composeStack } from './scaffold/compose.js';
 import { parseStandardOptions } from './registry/options.js';
 import { STANDARD_USAGE } from './registry/usage.js';
+import { printProgress, printResult } from './cli-output.js';
 export { parseStandardOptions, STANDARD_USAGE };
 export { STANDARD_PRODUCTS } from './stack-registry.js';
-export async function scaffoldStandardProject(options, run = execFile) {
+export async function scaffoldStandardProject(options, run = execFile, output = {}) {
     const plan = createSetupPlan(options);
+    const display = { ...output, json: options.json };
     if (options.dryRun) {
-        console.log(options.json ? JSON.stringify(plan, null, 2) : JSON.stringify(plan));
+        printResult('init', plan, { ...output, json: options.json });
         return;
     }
     assertBootstrapPlatform(run);
+    assertWorkspaceRuntime(run);
     const root = options.root;
     const previousQuiet = process.env.ANHEDRAL_QUIET;
     if (options.json)
@@ -46,12 +49,15 @@ export async function scaffoldStandardProject(options, run = execFile) {
                     throw new Error('Destination changed before generation.');
             },
             build: async (stageRoot) => {
+                printProgress('Creating the shadcn/Turborepo workspace…', display);
                 bootstrapWorkspace(stageRoot, options.name, run);
+                printProgress('Composing the selected stack…', display);
                 await composeStack(stageRoot, options, plan.registry);
                 if (options.products.includes('next') && options.hosting === 'vercel')
                     registerVercelApplication(stageRoot);
                 if (readdirSync(path.join(stageRoot, 'apps')).some((app) => existsSync(path.join(stageRoot, 'apps', app, 'wrangler.jsonc'))))
                     registerApplication(stageRoot);
+                printProgress('Resolving pinned dependencies…', display);
                 run('pnpm', ['install', '--lockfile-only', '--no-frozen-lockfile'], stageRoot);
                 if (configureSecurityBackports(stageRoot))
                     run('pnpm', ['install', '--lockfile-only', '--no-frozen-lockfile'], stageRoot);
@@ -67,18 +73,13 @@ export async function scaffoldStandardProject(options, run = execFile) {
                     if (checkout.status !== 0 || realpathSync(checkout.stdout.trim()) !== realpathSync(root))
                         run('git', ['init'], root);
                 }
-                if (!options.skipInstall)
+                if (!options.skipInstall) {
+                    printProgress('Installing workspace dependencies…', display);
                     run('pnpm', ['install', '--frozen-lockfile'], root);
+                }
             },
         });
-        console.log(options.json
-            ? JSON.stringify({ ...plan, generated: true })
-            : `Created ${root}. Next: cd ${JSON.stringify(root)}, then pnpm dev. Implement the product flows, configure selected resources using README.md and anhedral.setup.json, and run pnpm check. Record stack decisions in docs/architecture.md and exercised acceptance criteria in docs/verification.md.`);
-        if (!options.json) {
-            console.log('\nHelp keep Anhedral Init free and open source.');
-            console.log('Sponsor ongoing development, maintenance, and documentation.');
-            console.log('Become a sponsor: https://github.com/anhedral/anhedral-init/blob/main/docs/sponsorships.md');
-        }
+        printResult('init', { ...plan, generated: true }, { ...output, json: options.json });
     }
     finally {
         if (created && existsSync(root) && readdirSync(root).length === 0)

package/dist/vercel.d.ts

@@ -1,5 +1,5 @@
 import { type DeliveryRunner } from './project-state.js';
-interface WebProject {
+export interface WebProject {
     schemaVersion: 1;
     id: string;
     name: string;
@@ -17,7 +17,7 @@ interface WebProject {
         productionBranch?: string;
     };
 }
-interface WebRelease {
+export interface WebRelease {
     id: string;
     commit: string;
     operation: 'ship' | 'rollback' | 'adopt' | 'recover';
@@ -73,6 +73,7 @@ export declare function vercelApplicationStatus(root: string, refresh?: boolean,
     productVerification: string;
     management: string | null;
 }>;
+export declare function configureVercelEnvironment(root: string, values: Record<string, string>, run?: DeliveryRunner): Promise<void>;
 export declare function shipVercelApplication(root: string, run?: DeliveryRunner): Promise<{
     projectId: string;
     release: WebRelease;
@@ -95,4 +96,3 @@ export declare function rollbackVercelApplication(root: string, releaseId: strin
     nextAction: string;
 }>;
 export declare function writeVercelOverview(root: string, snapshot: Awaited<ReturnType<typeof vercelApplicationStatus>>): string;
-export {};

package/dist/vercel.js

@@ -544,7 +544,7 @@ export function planVercelDelivery(root) {
         checks: ['pnpm run check'],
         deployment: ['pnpm', ...cli, 'deploy', '--prod', '--yes'],
         cloudflareServices: existsSync(path.join(root, 'anhedral.project.json'))
-            ? 'Deploy and verify separately with --provider cloudflare before shipping the web app.'
+            ? 'Default ship deploys Cloudflare services first. Explicit --provider vercel ships only the web app; verify its service dependencies separately.'
             : 'none',
         mutation: false,
     };
@@ -575,6 +575,32 @@ export async function vercelApplicationStatus(root, refresh = false, run = defau
         management: project.scope ? `https://vercel.com/${project.scope}/${project.name}` : null,
     };
 }
+export async function configureVercelEnvironment(root, values, run = defaultRunner) {
+    const project = readWeb(root);
+    if (!project.projectId || !project.teamId)
+        throw new Error('Connect Vercel before configuring environment variables.');
+    context(root, project);
+    await inspect(root, project, run);
+    if (!Object.keys(values).length)
+        return;
+    const response = await api(root, run, `/v10/projects/${project.projectId}/env?upsert=true`, project.teamId, Object.entries(values).map(([key, value]) => ({
+        key,
+        value,
+        type: 'encrypted',
+        target: ['production'],
+    })));
+    const created = Array.isArray(response.created)
+        ? response.created
+        : response.created
+            ? [response.created]
+            : [];
+    if (!Array.isArray(response.failed) ||
+        response.failed.length ||
+        Object.keys(values).some((key) => !created.some((entry) => entry.key === key &&
+            (entry.target === 'production' ||
+                (Array.isArray(entry.target) && entry.target.includes('production'))))))
+        throw new Error('Vercel did not confirm all selected production environment variables; deployment was not started.');
+}
 export async function shipVercelApplication(root, run = defaultRunner) {
     root = realpathSync(root);
     const result = await withApplicationLock(root, async () => {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const GENERATOR_VERSION = "0.10.0";
+export declare const GENERATOR_VERSION = "0.11.0";

package/dist/version.js

@@ -1 +1 @@
-export const GENERATOR_VERSION = '0.10.0';
+export const GENERATOR_VERSION = '0.11.0';

package/dist/vinext.js

@@ -1,3 +1,4 @@
+import { VINEXT_DEPENDENCIES } from './dependencies.js';
 import { existsSync, readFileSync, rmSync } from 'node:fs';
 import path from 'node:path';
 import { writeFile } from './util.js';
@@ -8,28 +9,14 @@ export function configureVinext(root, workerName, bindings) {
     const pkg = JSON.parse(readFileSync(path.join(root, 'apps/web/package.json'), 'utf8'));
     delete pkg.dependencies?.['@opennextjs/cloudflare'];
     pkg.type = 'module';
-    pkg.dependencies = {
-        ...pkg.dependencies,
-        vinext: '1.1.0',
-        next: '16.4.0',
-        react: '19.2.8',
-        'react-dom': '19.2.8',
-        'react-server-dom-webpack': '19.2.8',
-    };
-    pkg.devDependencies = {
-        ...pkg.devDependencies,
-        vite: '8.3.4',
-        '@cloudflare/vite-plugin': '1.63.1',
-        '@vitejs/plugin-rsc': '0.5.36',
-        '@vitejs/plugin-react': '6.1.2',
-        wrangler: '4.149.0',
-    };
+    pkg.dependencies = { ...pkg.dependencies, ...VINEXT_DEPENDENCIES.dependencies };
+    pkg.devDependencies = { ...pkg.devDependencies, ...VINEXT_DEPENDENCIES.devDependencies };
     pkg.scripts = {
         ...pkg.scripts,
         dev: 'vite dev --host 127.0.0.1 --port 3000',
         build: 'vite build',
         start: 'vinext start',
-        preview: 'wrangler dev --config dist/server/wrangler.json --persist-to .wrangler/state',
+        preview: 'wrangler dev --config dist/server/wrangler.json --port 3000 --persist-to .wrangler/state',
         deploy: 'vite build && wrangler deploy --config dist/server/wrangler.json',
         'build:worker': 'vite build',
         typecheck: 'wrangler types --env-interface CloudflareEnv cloudflare-env.d.ts && tsc --noEmit',
@@ -77,7 +64,11 @@ export default config;
     const uiFile = path.join(root, 'packages/ui/package.json');
     if (existsSync(uiFile)) {
         const ui = JSON.parse(readFileSync(uiFile, 'utf8'));
-        ui.dependencies = { ...ui.dependencies, react: '19.2.8', 'react-dom': '19.2.8' };
+        ui.dependencies = {
+            ...ui.dependencies,
+            react: VINEXT_DEPENDENCIES.dependencies.react,
+            'react-dom': VINEXT_DEPENDENCIES.dependencies['react-dom'],
+        };
         writeFile(uiFile, JSON.stringify(ui, null, 2) + '\n');
     }
 }

package/dist/workspace-graph.js

@@ -1,4 +1,5 @@
-import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { readBoundedFile, MAX_PROJECT_JSON_BYTES } from './bounded-file.js';
+import { existsSync, lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
 import { dependencyOrder } from './dependency-order.js';
 const dependencyFields = [
@@ -12,7 +13,7 @@ function readManifest(file, directory) {
         throw new Error(`Workspace manifest missing: ${directory}.`);
     if (lstatSync(file).isSymbolicLink())
         throw new Error(`Workspace symlinks are unsupported: ${directory}/package.json.`);
-    const value = JSON.parse(readFileSync(file, 'utf8'));
+    const value = JSON.parse(readBoundedFile(file, MAX_PROJECT_JSON_BYTES).toString('utf8'));
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new Error(`Invalid workspace manifest: ${directory}.`);
     const manifest = value;