anhedral 0.10.1 → 0.11.0

package/dist/capability-contract.d.ts

@@ -0,0 +1,47 @@
+import type { StackSelection, StandardProduct } from './registry/types.js';
+export type CapabilitySupport = 'implemented' | 'scaffold-only' | 'unsupported' | 'not-applicable';
+export type CapabilityEvidence = 'local-contract' | 'unverified';
+export interface CapabilityStage {
+    support: CapabilitySupport;
+    evidence: CapabilityEvidence;
+    scope: string;
+}
+export interface ProductCapability {
+    id: StandardProduct;
+    description: string;
+    targets: readonly string[];
+    registryDependencies: readonly string[];
+    selection: StackSelection;
+    scaffold: CapabilityStage;
+    provisioning: CapabilityStage;
+    delivery: CapabilityStage;
+    limits: readonly string[];
+}
+/** Advertises implemented scope and the evidence level separately. This catalog is
+ * pure metadata; consulting it never authenticates, provisions, or verifies a live account. */
+export declare const CAPABILITY_CONTRACT: {
+    schemaVersion: number;
+    cliVersion: string;
+    mutation: boolean;
+    liveAcceptance: "unverified";
+    products: ProductCapability[];
+    providers: {
+        id: string;
+        managementCredential: "RESEND_API_KEY" | "STRIPE_SECRET_KEY" | "NEON_API_KEY" | "CLERK_PLATFORM_API_KEY" | "RC_API_KEY" | "SENTRY_AUTH_TOKEN" | "POSTHOG_PERSONAL_API_KEY" | "OPENAI_ADMIN_KEY";
+        resources: readonly ["project", "database connection"] | readonly ["application", "environment keys"] | readonly ["domain", "sending key"] | readonly ["account verification", "webhook"] | readonly ["project", "application", "SDK keys"] | readonly ["project", "DSN"] | readonly ["project", "ingestion configuration"] | readonly ["project", "service account", "runtime key"];
+        provisioning: CapabilityStage;
+        liveAcceptance: "unverified";
+        ownerSteps: readonly ["Choose an organization and region; approve any provider billing requirements."] | readonly ["Obtain Platform API access; configure production domains, DNS, and OAuth credentials."] | readonly ["Publish domain verification DNS records and wait for verification."] | readonly ["Complete account activation; define products, prices, and purchase behavior."] | readonly ["Configure store credentials or Stripe, products, offerings, and entitlements; verify purchases."] | readonly ["Choose organization and team access; configure source maps and application instrumentation."] | readonly ["Choose organization and region; define analytics events and consent behavior."] | readonly ["Obtain organization administration access; configure billing and application usage limits."];
+    }[];
+    hosts: {
+        id: string;
+        delivery: CapabilityStage;
+        liveAcceptance: "unverified";
+    }[];
+    plugin: {
+        id: string;
+        capability: CapabilityStage;
+    }[];
+    limits: string[];
+};
+export declare function formatCapabilityContract(): string;

package/dist/capability-contract.js

@@ -0,0 +1,136 @@
+import { STANDARD_PRODUCTS, getStackItem } from './stack-registry.js';
+import { PROVIDER_DEFINITIONS } from './providers/definitions.js';
+import { GENERATOR_VERSION } from './version.js';
+const stage = (support, scope, evidence = 'local-contract') => ({ support, evidence, scope });
+const none = (scope) => stage('not-applicable', scope, 'unverified');
+const cloudflareResources = ['d1', 'r2', 'kv', 'queues', 'basin'];
+const deploymentBindings = ['realtime', 'cron', 'workflows', 'workers-ai'];
+function integration(id) {
+    const provider = id === 'ai-sdk' ? 'openai' : id;
+    return Object.hasOwn(PROVIDER_DEFINITIONS, provider)
+        ? provider
+        : undefined;
+}
+function productCapability(id) {
+    const item = getStackItem(id);
+    const provider = integration(id);
+    let provisioning = none('No separately provisioned resource.');
+    let delivery = none('Delivered as part of the selected application.');
+    const limits = [
+        'Generated primitives require application feature development and acceptance checks.',
+    ];
+    if (provider) {
+        provisioning = stage('implemented', `Selected ${PROVIDER_DEFINITIONS[provider].resources.join(', ')} through provider APIs.`);
+        limits.push(...PROVIDER_DEFINITIONS[provider].ownerSteps, 'Live account permissions and provider behavior require authorized acceptance.');
+    }
+    if (cloudflareResources.includes(id)) {
+        provisioning = stage('implemented', id === 'basin'
+            ? 'Private Cloudflare stream and Worker binding.'
+            : 'Selected Cloudflare resource and checked Worker binding.');
+        limits.push('Account eligibility, quotas, and live runtime behavior require authorized acceptance.');
+        if (id === 'basin')
+            limits.push('Pipeline transforms and sinks are outside automated provisioning.');
+    }
+    if (deploymentBindings.includes(id)) {
+        provisioning = stage('implemented', 'Worker deployment configures the selected binding or trigger.');
+        limits.push('Configured bindings and triggers do not establish application behavior or execution success.');
+    }
+    if (['vinext', 'next', 'hono'].includes(id))
+        delivery = stage('implemented', id === 'next'
+            ? 'Selected Cloudflare or Vercel deployment with provider identity and source checks.'
+            : 'Cloudflare Worker deployment with provider identity and source checks.');
+    if (id === 'expo') {
+        delivery = stage('implemented', 'EAS build request, build receipt verification, and artifact link.');
+        limits.push('No store submission; signing, enrollment, device testing, and store distribution remain developer responsibilities.');
+    }
+    if (id === 'electron' || id === 'wxt') {
+        delivery = stage('scaffold-only', 'Generated application and local build tooling; automated distribution is unavailable.');
+        limits.push(id === 'electron'
+            ? 'Signing, notarization, installers, updates, and distribution require a separate delivery workflow.'
+            : 'Extension signing, store submission, review, and distribution require a separate delivery workflow.');
+    }
+    if (id === 'better-auth')
+        limits.push('Configure private authentication secret and public origin; apply and verify database migrations and authorization rules.');
+    return {
+        id,
+        description: item.description,
+        targets: item.targets,
+        registryDependencies: item.registryDependencies,
+        selection: item.selection,
+        scaffold: stage('implemented', 'Bundled source recipe and stack composition.'),
+        provisioning,
+        delivery,
+        limits,
+    };
+}
+/** Advertises implemented scope and the evidence level separately. This catalog is
+ * pure metadata; consulting it never authenticates, provisions, or verifies a live account. */
+export const CAPABILITY_CONTRACT = {
+    schemaVersion: 1,
+    cliVersion: GENERATOR_VERSION,
+    mutation: false,
+    liveAcceptance: 'unverified',
+    products: STANDARD_PRODUCTS.map(productCapability),
+    providers: Object.entries(PROVIDER_DEFINITIONS).map(([id, definition]) => ({
+        id,
+        managementCredential: definition.credential,
+        resources: definition.resources,
+        provisioning: stage('implemented', 'Selected resources through provider APIs; fixture-tested local contracts.'),
+        liveAcceptance: 'unverified',
+        ownerSteps: definition.ownerSteps,
+    })),
+    hosts: [
+        {
+            id: 'cloudflare',
+            delivery: stage('implemented', 'Provision selected resources, configure bindings/secrets, deploy Workers, inspect provider identity and source receipts.'),
+            liveAcceptance: 'unverified',
+        },
+        {
+            id: 'vercel',
+            delivery: stage('implemented', 'Configure the selected project environment, deploy the web app, inspect provider identity and source receipts.'),
+            liveAcceptance: 'unverified',
+        },
+    ],
+    plugin: [
+        {
+            id: 'project-inspection',
+            capability: stage('implemented', 'Offline versioned stack, setup prerequisites and target-specific recorded delivery evidence, shared by CLI and optional UI.'),
+        },
+        {
+            id: 'project-catalog',
+            capability: stage('implemented', 'Local projects, configuration, and recorded delivery receipts.'),
+        },
+        {
+            id: 'native-host-installation',
+            capability: stage('implemented', 'Packaged plugin and host integration.', 'unverified'),
+        },
+        ...['live-analytics', 'live-database-reader', 'schedule-execution', 'live-provider-health'].map((id) => ({
+            id,
+            capability: stage('unsupported', 'Configuration and recorded state only; no live reader or execution evidence.', 'unverified'),
+        })),
+    ],
+    limits: [
+        'Local contract tests are separate from live provider acceptance and completed application verification.',
+        'Account selection, enrollment, billing approval, DNS ownership, and signing can require owner action.',
+        'Mixed hosting is sequential; no atomic cross-provider rollback or cached phase skipping is promised.',
+        'The CLI scaffolds supported primitives; customer application features remain development work.',
+    ],
+};
+export function formatCapabilityContract() {
+    return [
+        `Anhedral ${CAPABILITY_CONTRACT.cliVersion} capabilities`,
+        'Evidence: local contracts; live provider acceptance remains unverified.',
+        '',
+        'Product             Provisioning        Delivery',
+        ...CAPABILITY_CONTRACT.products.map((product) => `${product.id.padEnd(20)}${product.provisioning.support.padEnd(20)}${product.delivery.support}`),
+        '',
+        'Providers: ' + CAPABILITY_CONTRACT.providers.map((provider) => provider.id).join(', '),
+        'Expo delivery returns EAS artifacts; it does not submit to stores.',
+        'Electron and WXT distribution: scaffold only.',
+        'Plugin live analytics, database readers, schedule execution, and provider health: unavailable.',
+        '',
+        ...CAPABILITY_CONTRACT.limits,
+        '',
+        'Use --json for scope, owner steps, and evidence for every capability.',
+    ].join('\n');
+}

package/dist/cli-arguments.d.ts

@@ -0,0 +1,16 @@
+export declare class CliArgumentError extends Error {
+    readonly nextAction: string;
+    readonly code: string;
+    constructor(message: string, nextAction: string, code?: string);
+}
+/** Bound typo matching so arbitrary CLI input cannot create quadratic work. */
+export declare function suggest(input: string, choices: readonly string[]): string | undefined;
+export declare function globalArguments(input: readonly string[]): {
+    args: string[];
+    cwd: string | undefined;
+    quiet: boolean;
+    verbose: boolean;
+    json: boolean;
+};
+export declare function validateCommand(command: string | undefined, args: readonly string[]): void;
+export declare function inlineArguments(command: string | undefined, args: readonly string[]): string[];

package/dist/cli-arguments.js

@@ -0,0 +1,115 @@
+import { COMMANDS, GLOBAL_OPTIONS, commandDefinition } from './command-schema.js';
+export class CliArgumentError extends Error {
+    nextAction;
+    code;
+    constructor(message, nextAction, code = 'INVALID_ARGUMENT') {
+        super(message);
+        this.nextAction = nextAction;
+        this.code = code;
+    }
+}
+/** Bound typo matching so arbitrary CLI input cannot create quadratic work. */
+export function suggest(input, choices) {
+    if (!input || input.length > 64)
+        return undefined;
+    const distance = (a, b) => {
+        let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+        for (let row = 1; row <= a.length; row++) {
+            const current = [row];
+            for (let column = 1; column <= b.length; column++)
+                current[column] = Math.min(current[column - 1] + 1, previous[column] + 1, previous[column - 1] + (a[row - 1] === b[column - 1] ? 0 : 1));
+            previous = current;
+        }
+        return previous[b.length];
+    };
+    const matches = choices
+        .map((choice) => ({ choice, distance: distance(input, choice) }))
+        .sort((a, b) => a.distance - b.distance || a.choice.localeCompare(b.choice));
+    const best = matches[0];
+    if (best &&
+        best.distance <= (input.length > 5 ? 2 : 1) &&
+        (!matches[1] || best.distance < matches[1].distance))
+        return best.choice;
+    return undefined;
+}
+export function globalArguments(input) {
+    const args = [];
+    let cwd;
+    let quiet = false;
+    let verbose = false;
+    let json = false;
+    for (let index = 0; index < input.length; index++) {
+        const arg = input[index];
+        if (arg === '-c' || arg === '--cwd' || arg.startsWith('--cwd=')) {
+            const value = arg.startsWith('--cwd=') ? arg.slice(6) : input[++index];
+            if (!value || value.startsWith('-') || cwd !== undefined)
+                throw new CliArgumentError('Specify one working directory with --cwd <directory>.', 'Run anhedral --help.');
+            cwd = value;
+        }
+        else if (arg === '--json')
+            json = true;
+        else if (arg === '--quiet' || arg === '-q')
+            quiet = true;
+        else if (arg === '--verbose')
+            verbose = true;
+        else
+            args.push(arg);
+    }
+    return { args, cwd, quiet, verbose, json };
+}
+export function validateCommand(command, args) {
+    if (!command || ['--help', '-h', '--version', '-v', 'help'].includes(command))
+        return;
+    const definition = commandDefinition(command);
+    if (!definition) {
+        const recommendation = suggest(command, [...Object.keys(COMMANDS), 'new', 'help']);
+        const name = /^[a-z-]{1,32}$/.test(command) ? `: ${command}` : '';
+        throw new CliArgumentError(`Unknown command${name}.${recommendation ? ` Did you mean ${recommendation}?` : ''}`, 'Run anhedral --help.', 'UNKNOWN_COMMAND');
+    }
+    const options = [...definition.options, ...GLOBAL_OPTIONS];
+    const flags = options.flatMap((option) => [option.flag, ...(option.aliases ?? [])]);
+    const seen = new Set();
+    for (let index = 0; index < args.length; index++) {
+        const argument = args[index];
+        if (!argument.startsWith('-'))
+            continue;
+        const separator = argument.indexOf('=');
+        const flag = separator < 0 ? argument : argument.slice(0, separator);
+        const option = options.find((entry) => entry.flag === flag || entry.aliases?.includes(flag));
+        if (!option) {
+            const recommendation = suggest(flag, flags);
+            const display = /^--?[a-z-]{1,64}$/.test(flag) ? `: ${flag}` : '';
+            throw new CliArgumentError(`Unknown ${command} option${display}.${recommendation ? ` Did you mean ${recommendation}?` : ''}`, `Run anhedral ${command} --help.`);
+        }
+        if (seen.has(option.flag) && !option.repeatable)
+            throw new CliArgumentError(`Specify ${option.flag} once.`, `Run anhedral ${command} --help.`);
+        seen.add(option.flag);
+        if (separator >= 0 && !option.arity)
+            throw new CliArgumentError('This option does not accept an inline value.', `Run anhedral ${command} --help.`);
+        if (option.arity) {
+            const value = separator >= 0 ? argument.slice(separator + 1) : args[index + 1];
+            if (!value || value.startsWith('-')) {
+                if (option.arity === 'required' || separator >= 0)
+                    throw new CliArgumentError(`Supply a value for ${option.flag}.`, `Run anhedral ${command} --help.`);
+            }
+            else if (separator < 0)
+                index++;
+        }
+    }
+}
+export function inlineArguments(command, args) {
+    const definition = commandDefinition(command);
+    const flags = new Set(definition?.options
+        .filter((option) => option.arity)
+        .flatMap((option) => [option.flag, ...(option.aliases ?? [])]) ?? []);
+    return args.flatMap((argument) => {
+        const separator = argument.indexOf('=');
+        if (separator < 0 || !flags.has(argument.slice(0, separator)))
+            return [argument];
+        const flag = argument.slice(0, separator);
+        const value = argument.slice(separator + 1);
+        if (!value || value.startsWith('-'))
+            throw new CliArgumentError(`Supply a value for ${flag}.`, `Run anhedral ${command} --help.`);
+        return [flag, value];
+    });
+}

package/dist/cli-output.d.ts

@@ -0,0 +1,8 @@
+export interface OutputOptions {
+    json?: boolean;
+    quiet?: boolean;
+}
+/** Human output is an explicit summary, never a recursive dump of provider payloads. */
+export declare function formatResult(command: string, value: unknown): string;
+export declare function printResult(command: string, value: unknown, options?: OutputOptions): void;
+export declare function printProgress(message: string, options?: OutputOptions): void;

package/dist/cli-output.js

@@ -0,0 +1,211 @@
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+const entries = (value) => (Array.isArray(value) ? value.map(record) : []);
+const string = (value) => typeof value === 'string' ? value.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '') : '';
+const names = (value) => Array.isArray(value)
+    ? value
+        .filter((entry) => typeof entry === 'string')
+        .map(string)
+        .join(', ')
+    : '';
+/** Human output is an explicit summary, never a recursive dump of provider payloads. */
+export function formatResult(command, value) {
+    const data = record(value);
+    const lines = [];
+    const next = (action) => {
+        if (string(action))
+            lines.push(`Next: ${string(action)}`);
+    };
+    if (command === 'init' || command === 'new') {
+        lines.push(data.generated ? `Created ${string(data.root)}.` : `Stack preview for ${string(data.root)}.`, `Stack: ${names(data.products)}.`, `Hosting: ${string(data.hosting)}.`, '');
+        if (data.generated)
+            lines.push('Review the generated source and anhedral.providers.json.', 'In the project directory, start development with pnpm dev. Run pnpm check before delivery.', 'Next: anhedral auth, then connect the intended hosting account and preview anhedral ship --dry-run.');
+        else
+            lines.push('No files, provider resources or deployments were created.');
+    }
+    else if (command === 'add') {
+        lines.push(data.dryRun ? 'Addition preview.' : 'Stack parts added.', names(data.items) ? `Parts: ${names(data.items)}.` : 'No new stack parts.', `Project: ${string(data.root)}.`);
+        const files = Array.isArray(data.files) ? data.files : [];
+        if (files.length)
+            lines.push('', ...files.map((file) => `  ${string(file)}`));
+        if (data.filesChecked === false)
+            lines.push('Source files were not checked: this selection needs the networked web bootstrap.');
+        if (names(data.conflicts))
+            lines.push(`Conflicts: ${names(data.conflicts)}.`);
+        for (const preview of entries(data.previews))
+            lines.push('', string(preview.path), string(preview.unavailable ?? preview.diff ?? preview.content));
+        if (data.dryRun)
+            lines.push('', 'No application files were changed.');
+        else
+            next('Run anhedral doctor and review the selected services’ setup requirements.');
+    }
+    else if (command === 'inspect') {
+        lines.push(`Project: ${string(data.name) || 'Name unavailable'}.`, 'Local recorded evidence; authentication and live provider status are not checked.');
+        const selection = record(record(data.selection).data);
+        lines.push(`Stack: ${names(selection.products) || 'Unavailable'}.`);
+        for (const target of entries(record(data.targets).data)) {
+            const latest = record(target.latestAttempt), successful = record(target.lastSuccessful);
+            lines.push(`  ${string(target.application)} — ${string(target.provider)} (${string(target.delivery)})`);
+            if (string(latest.state))
+                lines.push(`    Latest recorded target result: ${string(latest.state)}.`);
+            if (string(latest.operationState))
+                lines.push(`    Overall attempt: ${string(latest.operationState)}.`);
+            if (string(successful.id))
+                lines.push(`    Last recorded success: ${string(successful.id)}.`);
+            if (string(target.error))
+                lines.push(`    ${string(target.error)}`);
+        }
+        for (const check of entries(record(record(data.readiness).data).checks))
+            lines.push(`  ${check.ok ? 'pass' : 'fail'}  ${string(check.id)} — ${string(check.detail)}`);
+        for (const key of [
+            'selection',
+            'workspaces',
+            'configuration',
+            'targets',
+            'setupProviders',
+            'integrations',
+            'cloudflareResources',
+            'readiness',
+            'operation',
+        ]) {
+            const section = record(data[key]);
+            if (section.state === 'unavailable')
+                lines.push(`${key}: ${string(section.error) || 'Unavailable'}.`);
+        }
+        next('Use --json for target-specific records. Review local checks, then explicitly run auth or ship when intended.');
+    }
+    else if (command === 'auth') {
+        const checks = entries(data.checks);
+        lines.push(checks.length ? 'Provider authentication' : 'This stack requires no provider authentication.');
+        for (const check of checks) {
+            lines.push(`  ${string(check.provider).padEnd(12)}${string(check.state)}${string(check.access) && check.access !== 'none' ? ` (${string(check.access)} access)` : ''}`);
+            if (check.state !== 'verified' || check.access === 'runtime')
+                next(check.nextAction);
+        }
+        if (checks.length && string(data.note))
+            lines.push(string(data.note));
+        if (checks.length)
+            next(data.authenticated
+                ? 'Complete provider settings, connect the intended hosting account, then run anhedral ship --dry-run.'
+                : 'Resolve the reported access checks, then repeat anhedral auth --status.');
+    }
+    else if (command === 'integrations') {
+        lines.push(data.recovered
+            ? 'Integration resource reconciled.'
+            : 'Integration receipts (recorded locally).');
+        for (const provider of entries(data.providers)) {
+            lines.push(`  ${string(provider.provider)}`);
+            for (const operation of entries(provider.operations))
+                lines.push(`    ${string(operation.operation)}: ${string(operation.status)}`);
+        }
+        if (string(data.operation))
+            lines.push(`Operation: ${string(data.operation)}`);
+        next(data.nextAction ??
+            'Use --json to inspect the resource IDs and safe recovery descriptors. Unknown operations must be verified before retrying.');
+    }
+    else if (command === 'registry') {
+        lines.push(`${string(data.name)} (${string(data.type)})`, string(data.description));
+        if (names(data.targets))
+            lines.push(`Files: ${names(data.targets)}`);
+        if (names(data.registryDependencies))
+            lines.push(`Requires: ${names(data.registryDependencies)}`);
+        const setup = record(data.setup);
+        for (const key of ['access', 'credentials', 'resources', 'verify'])
+            if (names(setup[key]))
+                lines.push(`${key}: ${names(setup[key])}`);
+        next(`Inspect anhedral add ${string(data.name)} --dry-run in your project.`);
+    }
+    else if (command === 'doctor') {
+        const local = record(data.local);
+        const checks = entries(data.checks ?? local.checks);
+        lines.push(data.localReady ? 'Local project checks passed.' : 'Local project checks need attention.');
+        for (const check of checks) {
+            lines.push(`  ${check.ok ? 'pass' : 'fail'}  ${string(check.id)}${string(check.detail) ? ` — ${string(check.detail)}` : ''}`);
+            if (check.ok === false)
+                next(check.nextAction);
+        }
+        if (data.providerVerification)
+            lines.push(`Provider evidence: ${string(data.providerVerification)}.`);
+        for (const check of entries(data.prerequisiteChecks)) {
+            lines.push(`  ${check.ok ? 'pass' : 'fail'}  ${string(check.id)} — ${string(check.detail)}`);
+            if (check.ok === false)
+                next(check.nextAction);
+        }
+        lines.push('Local readiness does not certify production behavior.');
+    }
+    else {
+        const project = record(data.project);
+        const release = record(data.release);
+        const state = string(data.state ?? release.state);
+        lines.push(data.mutation === false
+            ? `${command}: preview only.`
+            : `${command}${state ? `: ${state}` : ': completed'}.`);
+        if (string(project.name))
+            lines.push(`Project: ${string(project.name)} (${string(project.provider)}).`);
+        if (string(release.id))
+            lines.push(`Release: ${string(release.id)}`);
+        if (string(data.buildId))
+            lines.push(`Build: ${string(data.buildId)} (${string(data.platform)}, ${string(data.profile)}).`);
+        if (string(data.evidence))
+            lines.push(`Evidence: ${string(data.evidence)}.`);
+        if (typeof data.activeRecordedVersion === 'boolean')
+            lines.push(`Recorded production version: ${data.activeRecordedVersion ? 'active' : 'not confirmed'}.`);
+        for (const target of entries(data.provider))
+            lines.push(`  ${string(target.target)}: ${target.activeRecordedVersion === true ? 'recorded version active' : 'recorded version not confirmed'}`);
+        const repository = record(data.repository);
+        if (string(repository.nameWithOwner))
+            lines.push(`Repository: ${string(repository.nameWithOwner)}`);
+        if (string(data.branch))
+            lines.push(`Branch: ${string(data.branch)}`);
+        for (const resource of entries(record(data.provisioning ?? data).resources))
+            lines.push(`  ${string(resource.kind)}  ${string(resource.name)}${string(resource.target) ? ` (${string(resource.target)})` : ''}`);
+        for (const key of ['downloadUrl', 'buildPageUrl', 'managementFile', 'file'])
+            if (string(data[key]))
+                lines.push(`${key}: ${string(data[key])}`);
+        if (string(release.url))
+            lines.push(`URL: ${string(release.url)}`);
+        const integration = record(data.integrations);
+        for (const provider of entries(integration.providers)) {
+            lines.push(`  ${string(provider.provider)}${names(provider.missing) ? `: missing ${names(provider.missing)}` : ': configuration selected'}`);
+        }
+        for (const provider of entries(integration.results)) {
+            lines.push(`  ${string(provider.provider)}: ${provider.ready ? 'configured' : 'setup pending'}`);
+            for (const action of Array.isArray(provider.nextActions) ? provider.nextActions : [])
+                next(action);
+        }
+        if (data.productVerification)
+            lines.push(`Product verification: ${string(data.productVerification)}.`);
+        const operation = record(data.operation);
+        if (string(operation.state)) {
+            lines.push(`Operation: ${string(operation.state)} (recorded locally).`);
+            for (const phase of entries(operation.phases))
+                lines.push(`  ${string(phase.name)}: ${string(phase.state)}`);
+        }
+        for (const target of entries(data.targets)) {
+            if (string(target.provider)) {
+                const result = record(target.result);
+                const release = record(result.release);
+                lines.push(`  ${string(target.provider)}: ${string(target.state ?? result.state ?? release.state) || 'planned'}`);
+            }
+        }
+        next(data.nextAction);
+        if (data.mutation === false)
+            lines.push('No provider resources or deployments were changed.');
+        else if (!data.nextAction && command === 'ship' && state === 'deployed')
+            next('Run anhedral verify to exercise the application’s configured acceptance checks.');
+        else if (!data.nextAction && command === 'connect')
+            next('Review and commit the connection manifest, then run anhedral ship --dry-run.');
+        if (!state && !data.nextAction && !Object.keys(project).length)
+            lines.push('Use --json for the complete recorded evidence.');
+    }
+    return lines.join('\n').trimEnd();
+}
+export function printResult(command, value, options = {}) {
+    if (options.json)
+        console.log(JSON.stringify(value, null, 2));
+    else if (!options.quiet)
+        console.log(formatResult(command, value));
+}
+export function printProgress(message, options = {}) {
+    if (process.stderr.isTTY && !options.json && !options.quiet)
+        console.error(message);
+}

package/dist/cloudflare.d.ts

@@ -9,6 +9,11 @@ export interface CloudflareResponse {
     };
 }
 export type CloudflareRequest = (method: 'GET' | 'POST', endpoint: string, body?: unknown) => Promise<CloudflareResponse>;
-/** Credentials stay in this closure, never in returned receipts, arguments or files. */
-export declare function cloudflareRequest(project: ApplicationProject, directory: string, run: DeliveryRunner, env: NodeJS.ProcessEnv): Promise<CloudflareRequest>;
+export interface CloudflareRequestOptions {
+    send?: typeof fetch;
+    timeoutMs?: number;
+}
+/** Credentials stay in this closure. Fixed account paths, bounded response reads and
+ * a whole-request deadline apply to reads and mutations; mutations never retry. */
+export declare function cloudflareRequest(project: ApplicationProject, directory: string, run: DeliveryRunner, env: NodeJS.ProcessEnv, options?: CloudflareRequestOptions): Promise<CloudflareRequest>;
 export declare function listCloudflare(request: CloudflareRequest, endpoint: string): Promise<Record<string, unknown>[]>;