@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/bootstrap/composition-root.js

@@ -0,0 +1,382 @@
+import { ActivityRegistry, agentActivityDefinition, createAgentActivity, createPullRequestApproveActivity, createPullRequestMergeActivity, createPullRequestService, } from '../activities/index.js';
+import { ControlStreamKind, DispatchPolicy, ScheduleService, createAdvanceOnce, createControlPlaneService, createIntakePipeline, createRunnerControlService, createRunnerPipeline, createWorkCancellationPolicy, ineligibleRunners, } from '../control-plane/index.js';
+import { ExternalExecutionState, GitWorkspaceProvider, RecoveryService, RunRepository, TranscriptStore, createExecutionService, loadPromptTemplate, renderPromptTemplate, } from '../execution/index.js';
+import { AgentRunPublicationReactor, ArtifactRegistrationReactor, DeliveryOutcomeReactor, DeliveryService, IntegrationStreamKind, PollService, ProviderRegistry, fakeProviderDefinition, } from '../integrations/index.js';
+import { EventActorKind, SystemClock, UlidIdGenerator, } from '../kernel/index.js';
+import { compileWorkflow, compileWorkflowSelectors, createOrchestrationService, createWatchReactor, selectWorkflow, workflowName, } from '../orchestration/index.js';
+import { FileCheckpointStore, FileEventJournal, FileProjectionStore, } from '../persistence/index.js';
+import { createResourceLookup, createResourceService, resourceId, } from '../resources/index.js';
+// The shared Integration barrel must not re-export a provider namespace
+// (see provider-locality); composition-root is the exempt production
+// composition point that is allowed to name it directly.
+import { createGitHubAgentContextReader, gitHubProviderDefinition, resolveGitHubResourceUrl, } from '../integrations/github/index.js';
+import { WorkStatus, createWorkService } from '../work/index.js';
+import { loadConfig } from './config/load-config.js';
+import { hydrateFakeProviderEvidence } from './fake-provider-files.js';
+import { loadFakeScenarios } from './fake-scenarios.js';
+import { resolveWakePaths } from './paths.js';
+import { createRuntimeProjectionRunner } from './projection-runtime.js';
+import { createRunnerQuotaReporter } from './runner-quota-reporter.js';
+import { createRunnerRegistry } from './runner-registry.js';
+import { FileScheduleCheckpointStore } from './schedule-checkpoint-store.js';
+import { createStatusPublishActivity } from './status-publish-activity.js';
+import { createUpdateMaintenanceLease, } from './update-maintenance-lease.js';
+const resourceLinkResolvers = {
+    github: resolveGitHubResourceUrl,
+};
+function resolveResourceLink(externalKey) {
+    return resourceLinkResolvers[externalKey.adapter]?.(externalKey) ?? null;
+}
+// Composition is deliberately the one place that assembles every module.
+// eslint-disable-next-line complexity
+export async function createCompositionRoot(wakeRoot, options = {}) {
+    const config = options.config ?? (await loadConfig(wakeRoot));
+    const fakeScenarios = await loadFakeScenarios(wakeRoot);
+    const paths = resolveWakePaths(wakeRoot);
+    const maintenance = createUpdateMaintenanceLease(paths.wakeRoot);
+    const clock = options.clock ?? new SystemClock();
+    const ids = new UlidIdGenerator();
+    const { journal, projections, checkpoints } = composePersistence(paths, clock, options);
+    const work = createWorkService(journal);
+    const lookup = createResourceLookup({ journal, projections });
+    const resources = createResourceService(journal, lookup);
+    const pullRequests = createPullRequestService(journal, work, resources);
+    const activities = options.activities ?? createBuiltInActivityRegistry(journal, pullRequests, resources, wakeRoot);
+    const definitions = Object.fromEntries(Object.entries(config.orchestration.workflows).map(([name, definition]) => [
+        name,
+        compileWorkflow(name, definition, activities, Object.keys(config.orchestration.workflows)),
+    ]));
+    const orchestration = createOrchestrationService(journal, work, definitions);
+    const workspaces = new GitWorkspaceProvider(paths.workspacesRoot, {
+        async cloneLocator(id) {
+            const resource = await resources.get(resourceId(id));
+            const match = resource === null ? null : /^([^/]+\/[^#]+)#\d+$/.exec(resource.externalKey.key);
+            if (match === null)
+                throw new Error('Workspace resource ' + id + ' does not identify a GitHub repository');
+            return 'https://github.com/' + match[1] + '.git';
+        },
+    });
+    const transcriptStore = config.transcripts.enabled
+        ? (options.transcriptStore ?? new TranscriptStore(paths.transcriptsRoot))
+        : undefined;
+    const execution = createExecutionService(journal, activities, config.execution, {
+        clock,
+        ids,
+        runners: createRunnerRegistry(config.execution, fakeScenarios, options.decorateRunner),
+        reportRunnerQuota: createRunnerQuotaReporter(journal, clock, ids),
+        ...(transcriptStore !== undefined
+            ? {
+                transcriptRecorder: transcriptStore,
+                logOperationalError(error) {
+                    console.error('Transcript capture failed', error);
+                },
+            }
+            : {}),
+        workspaces,
+    });
+    const recovery = new RecoveryService(journal, clock, {
+        async inspect() {
+            // Runner adapters do not yet expose a portable process-inspection API.
+            // Preserve safety on restart: unknown external work is reconciled through
+            // the existing ambiguity path rather than being guessed as absent.
+            return {
+                kind: ExternalExecutionState.Unknown,
+                reason: 'External execution inspection is not configured for this runtime',
+            };
+        },
+    }, activities, config.execution, orchestration);
+    const controlPlane = createControlPlaneService({ journal, clock, ids });
+    const isRuntimePaused = async () => (await controlPlane.isPaused()) || (await maintenanceBlocksRuntime(maintenance));
+    const runnerControls = createRunnerControlService({
+        journal,
+        clock,
+        ids,
+        runners: new Set(Object.values(config.execution.runnerPools).flat()),
+    });
+    const advanceOnce = createAdvanceOnce(orchestration, {
+        ...execution,
+        recoverActive: (owner) => recovery.recoverActive(owner, execution.isLocallyActive),
+    }, resources, clock, {
+        ids,
+        dispatchPolicy: new DispatchPolicy({ maxDispatches: config.controlPlane.maxDispatches }),
+        isDispatchPaused: isRuntimePaused,
+        workspaceRecovery: workspaces,
+        work,
+        ...(transcriptStore === undefined
+            ? {}
+            : {
+                transcriptRetention: {
+                    async markClosedWorkItem(workItemId) {
+                        try {
+                            await transcriptStore.markWorkItemCleaned(workItemId, config.transcripts.retentionMs, clock.now().toISOString());
+                            return true;
+                        }
+                        catch (error) {
+                            console.error('Transcript retention failed', error);
+                            return false;
+                        }
+                    },
+                    async sweep() {
+                        try {
+                            await transcriptStore.sweepExpired(config.transcripts.retentionMs, clock.now().toISOString(), (_workItemId, error) => console.error('Transcript retention failed', error));
+                        }
+                        catch (error) {
+                            console.error('Transcript retention failed', error);
+                        }
+                    },
+                },
+                closedWorkItemIds: () => closedWorkItemIds(projections),
+            }),
+        runnerIneligibility: async () => {
+            const stored = await projections.read(ControlStreamKind.Global, 'global');
+            return stored === null
+                ? new Set()
+                : ineligibleRunners(stored.value, clock.now().toISOString());
+        },
+    });
+    const runtime = await composeIntegrationRuntime({
+        config,
+        journal,
+        projections,
+        checkpoints,
+        resources,
+        lookup,
+        pullRequests,
+        orchestration,
+        execution,
+        ...(transcriptStore === undefined ? {} : { transcriptStore }),
+        advanceOnce,
+        controlPlane,
+        isPaused: isRuntimePaused,
+        clock,
+        work,
+        ids,
+        wakeRoot,
+        scheduleCheckpoints: options.scheduleCheckpoints ?? new FileScheduleCheckpointStore(paths.dataRoot),
+        ...(options.decorateDeliveryAdapter === undefined
+            ? {}
+            : { decorateDeliveryAdapter: options.decorateDeliveryAdapter }),
+        ...(options.fakeDeliveryProvider === undefined
+            ? {}
+            : { fakeDeliveryProvider: options.fakeDeliveryProvider }),
+    });
+    return {
+        config,
+        fakeScenarios,
+        paths,
+        maintenance,
+        journal,
+        projections,
+        checkpoints,
+        activities,
+        work,
+        resources,
+        lookup,
+        orchestration,
+        execution,
+        ...(transcriptStore === undefined ? {} : { transcriptStore }),
+        runnerControls,
+        controlPlane,
+        isPaused: isRuntimePaused,
+        advanceOnce,
+        resolveResourceLink,
+        ...runtime,
+    };
+}
+async function maintenanceBlocksRuntime(maintenance) {
+    return (await maintenance.read()) !== null;
+}
+async function closedWorkItemIds(projections) {
+    return (await projections.list('work')).flatMap(({ value }) => value?.state === WorkStatus.Closed ? [value.workItemId] : []);
+}
+function serializeRunRegisteredOnce(runner) {
+    let queue = Promise.resolve();
+    const runRegisteredOnce = runner.runRegisteredOnce.bind(runner);
+    runner.runRegisteredOnce = (limit) => {
+        const result = queue.then(() => runRegisteredOnce(limit));
+        queue = result.catch(() => { });
+        return result;
+    };
+    return runner;
+}
+async function composeIntegrationRuntime(input) {
+    const registry = new ProviderRegistry();
+    registry.register(fakeProviderDefinition);
+    registry.register(gitHubProviderDefinition);
+    const { instances, failures: providerFailures } = registry.compose(await hydrateFakeProviderEvidence(input.wakeRoot, input.config.integrations), {
+        work: input.work,
+        resources: input.resources,
+        resourceLookup: input.lookup,
+        pullRequests: input.pullRequests,
+        runs: new RunRepository(input.journal),
+        orchestration: input.orchestration,
+        ids: input.ids,
+        clock: input.clock,
+        journal: input.journal,
+        checkpoints: input.checkpoints,
+        routing: createWorkflowRouter(input.config.orchestration),
+        conclusion: createWorkCancellationPolicy(input.work, input.orchestration, input.execution, input.clock, input.ids),
+    });
+    const composedProviders = input.fakeDeliveryProvider === undefined
+        ? instances
+        : instances.map((provider) => provider.adapter === 'fake'
+            ? { ...provider, delivery: input.fakeDeliveryProvider }
+            : provider);
+    const providers = input.decorateDeliveryAdapter
+        ? composedProviders.map((provider) => ({
+            ...provider,
+            delivery: input.decorateDeliveryAdapter(provider.delivery, provider),
+        }))
+        : composedProviders;
+    // FileCheckpointStore.save throws on any regression (persistence/filesystem/
+    // file-checkpoint-store.ts), so two concurrent runRegisteredOnce calls that
+    // interleave can race a slower caller's stale checkpoint save against a
+    // faster one that already advanced past it. Every caller (the tick
+    // pipeline's own catchUpProjections, the API's manual tick, and the
+    // resident's standalone projection pump) shares this one instance, so
+    // serializing it here in-process covers all of them without a file lock.
+    const projectionRunner = serializeRunRegisteredOnce(createRuntimeProjectionRunner(input.journal, input.projections, input.checkpoints));
+    const delivery = new DeliveryService({
+        journal: input.journal,
+        intents: async () => (await input.projections.list(IntegrationStreamKind.Delivery)).map(({ value }) => value),
+        resource: async (id) => {
+            const resource = await input.resources.get(resourceId(id));
+            return resource === null
+                ? null
+                : { resourceId: resource.resourceId, adapter: resource.externalKey.adapter };
+        },
+        adapter: (name) => {
+            const provider = providers.find((candidate) => candidate.adapter === name);
+            if (provider === undefined)
+                throw new Error(`Delivery provider ${name} is not configured`);
+            return provider.delivery;
+        },
+        now: () => input.clock.now().toISOString(),
+    });
+    const schedules = new ScheduleService({
+        checkpoint: input.scheduleCheckpoints,
+        ids: input.ids,
+        work: input.work,
+        orchestration: input.orchestration,
+        now: () => input.clock.now().toISOString(),
+    });
+    const artifacts = new ArtifactRegistrationReactor({
+        journal: input.journal,
+        checkpoints: input.checkpoints,
+        resources: input.resources,
+        ids: input.ids,
+        providers,
+        runs: input.execution,
+    });
+    const runs = new RunRepository(input.journal);
+    const agentRunPublications = new AgentRunPublicationReactor({
+        journal: input.journal,
+        checkpoints: input.checkpoints,
+        runs,
+        resources: input.resources,
+        orchestration: input.orchestration,
+    });
+    const watch = createWatchReactor(input.orchestration, input.journal, input.checkpoints, runs);
+    const outcomes = new DeliveryOutcomeReactor(input.journal, input.checkpoints, input.orchestration);
+    const catchUpProjections = async () => {
+        await projectionRunner.runRegisteredOnce();
+    };
+    // Only poll hits a rate-limited external API, so only this half of the
+    // tick needs a backing-off host — see bootstrap/surface-cli-applications.ts.
+    const intakePipeline = createIntakePipeline({
+        isPaused: input.isPaused,
+        catchUpProjections,
+        poll: async (signal) => {
+            let appended = 0;
+            for (const provider of providers)
+                appended += await new PollService(input.journal, provider).pollOnce(signal);
+            return appended;
+        },
+        translateInbound: async () => {
+            let translated = 0;
+            for (const provider of providers)
+                translated += await provider.inbound.runOnce();
+            return translated;
+        },
+    });
+    const runnerPipeline = createRunnerPipeline({
+        isPaused: input.isPaused,
+        catchUpProjections,
+        runSchedules: async () => {
+            for (const schedule of input.config.controlPlane.schedules)
+                await schedules.run(schedule, {
+                    commandId: input.ids.next('command'),
+                    correlationId: 'schedule-tick',
+                    occurredAt: input.clock.now().toISOString(),
+                    actor: { kind: EventActorKind.System, id: ControlStreamKind.Global },
+                });
+        },
+        react: async () => {
+            await watch.runOnce();
+            await artifacts.runOnce();
+            await outcomes.runOnce();
+            for (const provider of providers)
+                await provider.maintenance?.runOnce();
+        },
+        advance: input.advanceOnce,
+        publishAgentRuns: async () => {
+            await agentRunPublications.runOnce();
+        },
+        deliver: async (signal) => {
+            await delivery.deliverNext(signal);
+        },
+    });
+    return {
+        projectionRunner,
+        providers,
+        providerFailures,
+        delivery,
+        intakePipeline,
+        runnerPipeline,
+    };
+}
+function identity(value) {
+    return value;
+}
+function composePersistence(paths, clock, options) {
+    return {
+        journal: (options.decorateJournal ?? identity)(options.journal ?? new FileEventJournal(paths.dataRoot, clock)),
+        projections: (options.decorateProjections ?? identity)(options.projections ?? new FileProjectionStore(paths.dataRoot)),
+        checkpoints: (options.decorateCheckpoints ?? identity)(options.checkpoints ?? new FileCheckpointStore(paths.dataRoot)),
+    };
+}
+function createBuiltInActivityRegistry(journal, pullRequests, resources, wakeRoot) {
+    const activities = new ActivityRegistry();
+    const contextReader = createGitHubAgentContextReader(journal, resources);
+    activities.register({
+        ...agentActivityDefinition,
+        handler: createAgentActivity({
+            async render(name, context) {
+                const template = await loadPromptTemplate(wakeRoot, name);
+                return {
+                    prompt: renderPromptTemplate(template, context),
+                    ...(template.frontmatter.model === undefined || template.frontmatter.model === null
+                        ? {}
+                        : { model: template.frontmatter.model }),
+                    ...(template.frontmatter.allowedTools === undefined ||
+                        template.frontmatter.allowedTools === null
+                        ? {}
+                        : { allowedTools: template.frontmatter.allowedTools }),
+                    ...(template.frontmatter.maxTurns === undefined
+                        ? {}
+                        : { maxTurns: template.frontmatter.maxTurns }),
+                };
+            },
+        }, contextReader),
+    });
+    activities.register(createStatusPublishActivity(journal));
+    activities.register(createPullRequestApproveActivity(journal, pullRequests));
+    activities.register(createPullRequestMergeActivity(journal, pullRequests));
+    return activities;
+}
+// Configuration is the only routing authority: adapters ask, they never propose.
+function createWorkflowRouter(orchestration) {
+    const selectors = compileWorkflowSelectors(orchestration.workflowSelectors);
+    const fallback = workflowName(orchestration.default);
+    return { select: (candidate) => selectWorkflow(candidate, selectors, fallback) };
+}

package/dist/src/bootstrap/config/load-config.js

@@ -0,0 +1,51 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import YAML from 'yaml';
+import { parseRootConfig } from './root-schema.js';
+export async function loadConfig(wakeRoot) {
+    const main = await readYaml(join(wakeRoot, 'config.yaml'));
+    const workflows = await readYamlIfPresent(join(wakeRoot, 'config.workflows.yaml'));
+    const merged = merge(main, workflows === undefined ? {} : normalizeWorkflowFile(workflows));
+    try {
+        return parseRootConfig(merged);
+    }
+    catch (error) {
+        if (error instanceof Error && 'issues' in error) {
+            const issues = error.issues;
+            throw new Error(`Configuration validation failed: ${issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`).join('; ')}`, { cause: error });
+        }
+        throw error;
+    }
+}
+async function readYaml(path) {
+    return YAML.parse(await readFile(path, 'utf8')) ?? {};
+}
+async function readYamlIfPresent(path) {
+    try {
+        return await readYaml(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+function normalizeWorkflowFile(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return value;
+    const record = value;
+    return 'workflows' in record
+        ? { orchestration: record }
+        : { orchestration: { workflows: record } };
+}
+function merge(left, right) {
+    if (!isRecord(left) || !isRecord(right))
+        return right;
+    const result = { ...left };
+    for (const [key, value] of Object.entries(right))
+        result[key] = key in result ? merge(result[key], value) : value;
+    return result;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/src/bootstrap/config/root-schema.js

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import { activitiesConfigSchema } from '../../activities/index.js';
+import { controlPlaneConfigSchema } from '../../control-plane/index.js';
+import { executionConfigSchema } from '../../execution/index.js';
+import { integrationsConfigSchema } from '../../integrations/index.js';
+import { workflowDefinitionConfigSchema, workflowSelectorConfigSchema, } from '../../orchestration/index.js';
+import { resourcesConfigSchema } from '../../resources/index.js';
+import { surfacesConfigSchema } from '../../surfaces/index.js';
+import { workConfigSchema } from '../../work/index.js';
+const orchestrationConfigSchema = z
+    .object({
+    workflows: z.record(z.string().trim().min(1), workflowDefinitionConfigSchema).default({}),
+    workflowSelectors: z.array(workflowSelectorConfigSchema).readonly().default([]),
+    default: z.string().trim().min(1).default('default'),
+})
+    .strict()
+    // Routing may only name a workflow that exists; a root with no workflows configured
+    // routes nothing, so its unused fallback is not an error.
+    .superRefine((value, ctx) => {
+    const configured = new Set(Object.keys(value.workflows));
+    if (configured.size > 0 && !configured.has(value.default)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['default'],
+            message: `default workflow "${value.default}" is not configured in orchestration.workflows`,
+        });
+    }
+    for (const [index, selector] of value.workflowSelectors.entries()) {
+        if (configured.has(selector.workflow))
+            continue;
+        ctx.addIssue({
+            code: 'custom',
+            path: ['workflowSelectors', index, 'workflow'],
+            message: `selector workflow "${selector.workflow}" is not configured in orchestration.workflows`,
+        });
+    }
+})
+    .default({ workflows: {}, workflowSelectors: [], default: 'default' });
+const transcriptsConfigSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+    retentionMs: z.number().int().nonnegative().default(86_400_000),
+})
+    .strict()
+    .default({ enabled: false, retentionMs: 86_400_000 });
+const hostConfigSchema = z
+    .object({
+    sandbox: z
+        .object({
+        image: z.string().trim().min(1).default('wake-sandbox'),
+        imageRepository: z.string().trim().min(1).default('wake-sandbox'),
+        containerName: z.string().trim().min(1).default('wake-sandbox'),
+        wakeMountPath: z.string().trim().min(1).default('/wake'),
+        containerHomeMountPath: z.string().trim().min(1).default('/home/wake'),
+        start: z
+            .object({ enabled: z.boolean().default(true) })
+            .strict()
+            .default({ enabled: true }),
+        extraMounts: z
+            .array(z
+            .object({
+            source: z.string().trim().min(1),
+            target: z.string().trim().min(1),
+            readOnly: z.boolean().optional(),
+        })
+            .strict())
+            .readonly()
+            .default([]),
+    })
+        .strict()
+        .default({
+        image: 'wake-sandbox',
+        imageRepository: 'wake-sandbox',
+        containerName: 'wake-sandbox',
+        wakeMountPath: '/wake',
+        containerHomeMountPath: '/home/wake',
+        start: { enabled: true },
+        extraMounts: [],
+    }),
+    development: z
+        .object({
+        repoRoot: z.string().trim().min(1).optional(),
+        mode: z.enum(['source', 'packaged']).optional(),
+    })
+        .strict()
+        .default({}),
+    selfUpdate: z
+        .object({
+        drainTimeoutMs: z.number().int().positive().default(30_000),
+        cancellationTimeoutMs: z.number().int().positive().default(30_000),
+    })
+        .strict()
+        .default({ drainTimeoutMs: 30_000, cancellationTimeoutMs: 30_000 }),
+})
+    .strict()
+    .default({
+    sandbox: {
+        image: 'wake-sandbox',
+        imageRepository: 'wake-sandbox',
+        containerName: 'wake-sandbox',
+        wakeMountPath: '/wake',
+        containerHomeMountPath: '/home/wake',
+        start: { enabled: true },
+        extraMounts: [],
+    },
+    development: {},
+    selfUpdate: { drainTimeoutMs: 30_000, cancellationTimeoutMs: 30_000 },
+})
+    .superRefine((value, context) => {
+    if (value.development.mode === 'source' && value.development.repoRoot === undefined)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['development', 'repoRoot'],
+            message: 'source host development requires repoRoot',
+        });
+});
+export const rootConfigSchema = z
+    .object({
+    schemaVersion: z.literal(1).default(1),
+    work: workConfigSchema.default({}),
+    resources: resourcesConfigSchema.default({}),
+    activities: activitiesConfigSchema.default({}),
+    orchestration: orchestrationConfigSchema,
+    transcripts: transcriptsConfigSchema,
+    execution: executionConfigSchema,
+    controlPlane: controlPlaneConfigSchema,
+    integrations: integrationsConfigSchema,
+    surfaces: surfacesConfigSchema,
+    host: hostConfigSchema,
+})
+    .strict();
+export function parseRootConfig(input) {
+    return rootConfigSchema.parse(input);
+}

package/dist/src/bootstrap/external-ref.js

@@ -0,0 +1,12 @@
+import { ResourceCorrelationRole } from '../resources/index.js';
+import { workItemId } from '../work/index.js';
+// Work items never embed a provider/repo/issue number (see docs/adrs/0001); this joins
+// the primary correlated resource's adapter-formatted key at the presentation layer only.
+export async function primaryExternalRef(root, rawWorkItemId) {
+    const correlations = await root.resources.correlationsForWork(workItemId(rawWorkItemId));
+    const primary = correlations.find((value) => value.role === ResourceCorrelationRole.Primary);
+    if (primary === undefined)
+        return undefined;
+    const resource = await root.resources.get(primary.resourceId);
+    return resource?.externalKey.key;
+}

package/dist/src/bootstrap/fake-provider-files.js

@@ -0,0 +1,44 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+const fakeFileConfigSchema = z
+    .object({
+    provider: z.literal('fake'),
+    evidenceFile: z.string().min(1),
+    effectsFile: z.string().min(1).optional(),
+})
+    .passthrough();
+/** Resolves fake-provider evidence files before providers are composed. */
+export async function hydrateFakeProviderEvidence(wakeRoot, integrations) {
+    const entries = await Promise.all(Object.entries(integrations).map(async ([name, entry]) => {
+        const parsed = fakeFileConfigSchema.safeParse(entry);
+        if (!parsed.success)
+            return [name, entry];
+        const events = JSON.parse(await readFile(join(wakeRoot, parsed.data.evidenceFile), 'utf8'));
+        const effectsPath = parsed.data.effectsFile === undefined ? undefined : join(wakeRoot, parsed.data.effectsFile);
+        const deliveryEffects = effectsPath === undefined ? {} : await readEffectsFile(effectsPath);
+        return [
+            name,
+            {
+                ...entry,
+                events,
+                deliveryEffects,
+                ...(effectsPath === undefined ? {} : { effectsFile: effectsPath }),
+            },
+        ];
+    }));
+    return Object.fromEntries(entries);
+}
+async function readEffectsFile(path) {
+    try {
+        return z.record(z.string(), z.string()).parse(JSON.parse(await readFile(path, 'utf8')));
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return {};
+        throw error;
+    }
+}
+function isMissingFile(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}

package/dist/src/bootstrap/fake-scenarios.js

@@ -0,0 +1,22 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import YAML from 'yaml';
+import { emptyFakeScenarios, parseFakeScenarios, } from '../execution/index.js';
+export async function loadFakeScenarios(wakeRoot) {
+    const path = join(wakeRoot, 'fake-scenarios.yaml');
+    let source;
+    try {
+        source = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return emptyFakeScenarios;
+        throw error;
+    }
+    try {
+        return parseFakeScenarios(YAML.parse(source) ?? {});
+    }
+    catch (error) {
+        throw new Error(`Fake scenario configuration validation failed in fake-scenarios.yaml: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+}