@atolis-hq/wake 0.4.43 → 0.4.45

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

@@ -1,5 +1,4 @@
 import { FileCheckpointStore, FileEventJournal, FileProcessorStateStore, FileProjectionStore, createFileProcessorRunSerialiser, } from '@atolis-hq/eventing-filesystem';
-import { DeliveryOutcomeProcessorConsumer } from '../integrations/index.js';
 function identity(value) {
     return value;
 }
@@ -27,10 +26,7 @@ export function composePersistence(paths, clock, options) {
     const subscriptionRunSerialiser = options.subscriptionRunSerialiser ?? createFileProcessorRunSerialiser(paths.dataRoot);
     return {
         journal: serializeJournalAppends((options.decorateJournal ?? identity)(options.journal ?? new FileEventJournal(paths.dataRoot, clock))),
-        projections: (options.decorateProjections ?? identity)(options.projections ??
-            new FileProjectionStore(paths.dataRoot, {
-                protectedProcessorStateConsumers: [DeliveryOutcomeProcessorConsumer],
-            })),
+        projections: (options.decorateProjections ?? identity)(options.projections ?? new FileProjectionStore(paths.dataRoot)),
         checkpoints: (options.decorateCheckpoints ?? identity)(options.checkpoints ?? new FileCheckpointStore(paths.dataRoot)),
         processorState: options.processorState ?? new FileProcessorStateStore(paths.dataRoot),
         subscriptionRunSerialiser,

package/dist/src/bootstrap/self-update-application.d.ts

@@ -16,6 +16,7 @@ export interface SourceUpdatePort {
  * non-sandbox self-updates.
  */
 export interface SelfUpdateRolloutPort {
+    prepare(tag: string): Promise<void>;
     deploy(tag: string): Promise<void>;
     rollback(tag: string): Promise<void>;
     recordFailure(tag: string, error: unknown): Promise<void>;
@@ -27,6 +28,7 @@ export interface SelfUpdateRolloutPort {
  * durably record every supplied Run's maintenance request.
  */
 export interface SelfUpdateQuiescePort {
+    read?(): Promise<UpdateMaintenanceState | null>;
     acquire(tag: string, retryFailed?: boolean): Promise<UpdateMaintenanceState>;
     exclusive?<Value>(tag: string, retryFailed: boolean, operation: (state: UpdateMaintenanceState) => Promise<Value>): Promise<Value>;
     activeRuns(): Promise<readonly {

package/dist/src/bootstrap/self-update-application.js

@@ -59,6 +59,11 @@ async function currentTag(input) {
     return (await input.source.currentTag?.()) ?? (await input.ledger.read());
 }
 async function startUpdateAttempt(input, tag, force) {
+    const existing = await input.quiesce?.read?.();
+    if (existing === null ||
+        existing === undefined ||
+        existing.phase === UpdateMaintenancePhase.Failed)
+        await prepareCandidate(input, tag);
     if (input.quiesce?.exclusive !== undefined)
         return input.quiesce.exclusive(tag, force, (lease) => updateAttempt(input, tag, force, lease));
     return updateAttempt(input, tag, force, await input.quiesce?.acquire(tag, force));
@@ -66,24 +71,30 @@ async function startUpdateAttempt(input, tag, force) {
 async function updateAttempt(input, tag, force, lease) {
     const maintenanceTag = lease?.tag ?? tag;
     const attemptId = lease?.attemptId;
-    const context = {};
+    const context = {
+        activationStarted: false,
+        rollbackSucceeded: false,
+        recoveryRequired: false,
+        recoveryVerified: false,
+    };
     try {
         return await performUpdateAttempt(input, tag, force, lease, context);
     }
     catch (error) {
-        await recordUpdateFailure(input, maintenanceTag, attemptId, context.deployError ?? error, error);
+        await recordUpdateFailure(input, maintenanceTag, attemptId, context.deployError ?? error, error, context);
         throw error;
     }
 }
 async function performUpdateAttempt(input, tag, force, lease, context) {
     if (lease !== undefined && requiresMaintenanceRecovery(lease)) {
+        context.recoveryRequired = true;
         await resumePendingMaintenance(input, lease);
         return false;
     }
     if (!isStartableMaintenanceLease(lease, tag))
         return false;
     await quiesceForUpdate(input);
-    await recoverPendingUpdate(input.ledger, input.source);
+    await recoverPendingUpdate(input.ledger, input.source, context);
     if (!force && (await input.ledger.read()) === tag) {
         await input.quiesce?.clear(lease?.attemptId);
         return false;
@@ -116,13 +127,18 @@ async function runForwardUpdate(input, tag, attemptId, context) {
             readLedger: input.ledger.read,
             writeLedger: input.ledger.write,
             update: async (nextTag) => {
-                await input.source.checkout(nextTag);
+                if (input.rollout === undefined)
+                    await input.source.checkout(nextTag);
+                context.activationStarted = true;
                 context.deployError = await deployRollout(input.rollout, nextTag);
             },
             health: async () => context.deployError === undefined && input.source.healthy(),
             rollback: async (priorTag) => {
                 await rollbackUpdate(input, priorTag, attemptId);
+                if (!(await input.source.healthy()))
+                    throw new Error(`Self-update rollback could not verify the prior tag ${priorTag}`);
                 rollbackSucceeded = true;
+                context.rollbackSucceeded = true;
             },
         });
     }
@@ -162,7 +178,18 @@ async function rollbackUpdate(input, priorTag, attemptId) {
     await input.source.checkout(priorTag);
     await input.rollout?.rollback(priorTag);
 }
-async function recordUpdateFailure(input, tag, attemptId, rolloutError, originalError) {
+async function recordUpdateFailure(input, tag, attemptId, rolloutError, originalError, context) {
+    if (context.rollbackSucceeded ||
+        (!context.activationStarted && (!context.recoveryRequired || context.recoveryVerified))) {
+        try {
+            await recordRolloutFailure(input.rollout, tag, rolloutError);
+            await input.ledger.recordBad(tag);
+        }
+        finally {
+            await input.quiesce?.clear(attemptId);
+        }
+        return;
+    }
     try {
         await input.quiesce?.fail(originalError, attemptId);
     }
@@ -184,6 +211,24 @@ async function recordRolloutFailure(rollout, tag, error) {
         // Best-effort: a failure-log write must never mask the original update failure.
     }
 }
+async function prepareCandidate(input, tag) {
+    if (!(await input.source.isClean()))
+        throw new Error('Self-update requires a clean source checkout');
+    if (input.rollout === undefined)
+        return;
+    const priorTag = await input.ledger.read();
+    try {
+        await input.source.checkout(tag);
+        await input.rollout.prepare(tag);
+    }
+    catch (error) {
+        if (priorTag !== null)
+            await input.source.checkout(priorTag);
+        await recordRolloutFailure(input.rollout, tag, error);
+        await input.ledger.recordBad(tag);
+        throw new UpdateCandidateFailure(error);
+    }
+}
 /**
  * A restart must never repeat a forward deploy. The persisted phase tells us
  * that source/rollout work may already have begun, so recover the prior
@@ -210,11 +255,13 @@ async function quiesceActiveRuns(quiesce) {
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }
-async function recoverPendingUpdate(ledger, source) {
+async function recoverPendingUpdate(ledger, source, context) {
     const priorTag = await ledger.recover();
     if (priorTag === null)
         return;
+    context.recoveryRequired = true;
     await source.checkout(priorTag);
     if (!(await source.healthy()))
         throw new Error(`Self-update recovery could not verify the prior tag ${priorTag}`);
+    context.recoveryVerified = true;
 }

package/dist/src/bootstrap/surface-cli-applications.js

@@ -400,6 +400,7 @@ async function activeExecutionRunIds(root) {
 /** The production maintenance boundary shared by the CLI update application. */
 export function createSelfUpdateQuiescePort(root) {
     return {
+        read: () => root.maintenance.read(),
         acquire: (tag, retryFailed) => root.maintenance.acquire(tag, retryFailed),
         exclusive: (tag, retryFailed, operation) => root.maintenance.runExclusive(tag, retryFailed, operation),
         activeRuns: () => activeExecutionRuns(root),
@@ -433,18 +434,20 @@ function createSandboxRuntimeApplications(root) {
     };
 }
 /**
- * Builds a running self-update on the sandbox container onto a specific
- * image tag: rebuild the image, swap the container onto it, and confirm the
- * resident `wake start` process actually came back up. Reused for both the
- * forward deploy and a same-shaped rollback to a previously-built tag.
+ * Builds a candidate image before the maintenance window. A failed build
+ * cannot affect the running sandbox.
  */
-async function deploySandboxTag(root, docker, tag, image, overrides) {
+async function buildSandboxTag(root, docker, image, overrides) {
     const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image, ...overrides }));
-    const wakeInvocation = overrides?.development?.mode === 'source'
+    await port.build();
+}
+/** Swaps the already-built candidate image and verifies the resident host. */
+async function deploySandboxTag(root, docker, tag, image, development) {
+    const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image, development }));
+    const wakeInvocation = development?.mode === 'source'
         ? ['node', '/app/dist/src/main.js']
         : sandboxWakeInvocation(root);
     const healthcheckRoot = `/tmp/wake-self-update-healthcheck-${tag}`;
-    await port.build();
     try {
         await port.update();
     }
@@ -541,15 +544,14 @@ function createOperationalApplications(root) {
                 ledger: createUpdateLedger(root.paths.wakeRoot),
                 source: updatePort,
                 rollout: {
-                    async deploy(deployTag) {
-                        await waitForActiveRuns({
-                            activeRunIds: () => activeExecutionRunIds(root),
-                            sleep: async (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
-                        });
-                        await deploySandboxTag(root, dockerCli, deployTag, `${imageRepository}:${deployTag}`, {
+                    async prepare(prepareTag) {
+                        await buildSandboxTag(root, dockerCli, `${imageRepository}:${prepareTag}`, {
                             development: updateDevelopment,
-                            buildVersion: deployTag,
+                            buildVersion: prepareTag,
                         });
+                    },
+                    async deploy(deployTag) {
+                        await deploySandboxTag(root, dockerCli, deployTag, `${imageRepository}:${deployTag}`, updateDevelopment);
                         // A later deploy succeeding after a prior rollback clears the stale warning.
                         await failureLog.clear();
                     },

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.43";
+export const wakeVersion = "v0.4.45";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/control-plane/application/activation-scheduler-ports.d.ts

@@ -12,6 +12,7 @@ export interface OrchestrationPort {
         activation: ActivityActivationView;
     }[]>;
     listWaiting(): Promise<readonly (WorkflowInstanceView | null)[]>;
+    get?(workflowInstanceId: string): Promise<WorkflowInstanceView | null>;
     expireTimedOutWaits?(context: CommandContext): Promise<readonly WorkflowInstanceView[]>;
     listAll?(): Promise<readonly WorkflowInstanceView[]>;
     validateActivationDispatch?(workflowInstanceId: string, context: CommandContext): Promise<boolean>;
@@ -32,6 +33,7 @@ export interface OrchestrationPort {
         readonly message: string;
     }, context: CommandContext): Promise<WorkflowInstanceView | null>;
     markActivationStarted(workflowInstanceId: string, activationId: string, context: CommandContext): Promise<WorkflowInstanceView | null>;
+    block?(workflowInstanceId: string, reason: string, context: CommandContext): Promise<WorkflowInstanceView | null>;
 }
 export interface ExecutionPort {
     recoverActive?(owner: string): Promise<readonly RunView[]>;

package/dist/src/control-plane/application/activation-scheduler.js

@@ -5,7 +5,7 @@ import { isAmbiguityResolutionBlock, WorkflowStatus, } from '../../orchestration
 import { WorkStatus } from '../../work/index.js';
 import { ControlStreamKind } from '../contracts/streams.js';
 import { DispatchPolicy } from '../domain/dispatch-policy.js';
-import { isRunnerQuotaOutcome, reportUnappliedRunnerQuotaRetry, runDispatchLoop, runnerQuotaMessage, } from './advance-once-dispatch.js';
+import { advancementWasDurablyApplied, blockIsolatedWorkflow, isRunnerQuotaOutcome, reportUnappliedRunnerQuotaRetry, runDispatchLoop, runnerQuotaMessage, } from './advance-once-dispatch.js';
 import { findUnresolvedSucceededTerminal, findUnresolvedTerminal, } from './execution-reconciliation.js';
 export function createActivationScheduler(orchestration, execution, resources, clock, dependencies) {
     const runnerIneligibility = dependencies.runnerIneligibility ?? (async () => new Set());
@@ -106,43 +106,68 @@ export function createActivationScheduler(orchestration, execution, resources, c
         if (recovery !== undefined) {
             if (await isDispatchPaused())
                 return { kind: 'paused' };
-            if (recovery.run.status === RunStatus.Succeeded) {
-                if (isRunnerQuotaOutcome(recovery.run.outcome)) {
-                    const retried = await orchestration.retryRunnerQuotaFailure?.(recovery.item.workflow.workflowInstanceId, {
-                        activationId: recovery.item.activation.activationId,
-                        runId: recovery.run.runId,
-                        runnerName: recovery.run.runner?.name ?? 'unknown-runner',
-                        message: runnerQuotaMessage(recovery.run.outcome),
-                    }, context(recovery.run.runId));
-                    reportUnappliedRunnerQuotaRetry(retried, {
-                        activationId: recovery.item.activation.activationId,
-                        runId: recovery.run.runId,
-                    });
-                }
-                else {
-                    await orchestration.acceptOutcome({
-                        workflowInstanceId: recovery.item.workflow.workflowInstanceId,
-                        activationId: recovery.item.activation.activationId,
-                        outcome: recovery.run.outcome,
-                    }, context(recovery.run.runId));
+            try {
+                if (recovery.run.status === RunStatus.Succeeded) {
+                    if (isRunnerQuotaOutcome(recovery.run.outcome)) {
+                        const retried = await orchestration.retryRunnerQuotaFailure?.(recovery.item.workflow.workflowInstanceId, {
+                            activationId: recovery.item.activation.activationId,
+                            runId: recovery.run.runId,
+                            runnerName: recovery.run.runner?.name ?? 'unknown-runner',
+                            message: runnerQuotaMessage(recovery.run.outcome),
+                        }, context(recovery.run.runId));
+                        reportUnappliedRunnerQuotaRetry(retried, {
+                            activationId: recovery.item.activation.activationId,
+                            runId: recovery.run.runId,
+                        });
+                    }
+                    else {
+                        await orchestration.acceptOutcome({
+                            workflowInstanceId: recovery.item.workflow.workflowInstanceId,
+                            activationId: recovery.item.activation.activationId,
+                            outcome: recovery.run.outcome,
+                        }, context(recovery.run.runId));
+                    }
+                    return {
+                        kind: 'progressed',
+                        dispatched: [
+                            { activationId: recovery.item.activation.activationId, runId: recovery.run.runId },
+                        ],
+                    };
                 }
+                await orchestration.resolveExecutionFailure?.(recovery.item.workflow.workflowInstanceId, {
+                    activationId: recovery.item.activation.activationId,
+                    runId: recovery.run.runId,
+                    reason: recovery.run.failure?.message ?? 'execution failed',
+                }, context(recovery.run.runId));
                 return {
-                    kind: 'progressed',
-                    dispatched: [
-                        { activationId: recovery.item.activation.activationId, runId: recovery.run.runId },
-                    ],
+                    kind: WorkflowStatus.Blocked,
+                    workflowInstanceId: recovery.item.workflow.workflowInstanceId,
+                    reason: recovery.run.failure?.message ?? 'execution failed',
                 };
             }
-            await orchestration.resolveExecutionFailure?.(recovery.item.workflow.workflowInstanceId, {
-                activationId: recovery.item.activation.activationId,
-                runId: recovery.run.runId,
-                reason: recovery.run.failure?.message ?? 'execution failed',
-            }, context(recovery.run.runId));
-            return {
-                kind: WorkflowStatus.Blocked,
-                workflowInstanceId: recovery.item.workflow.workflowInstanceId,
-                reason: recovery.run.failure?.message ?? 'execution failed',
-            };
+            catch (error) {
+                if (await advancementWasDurablyApplied(orchestration, recovery.item.workflow.workflowInstanceId, recovery.item.activation.activationId))
+                    throw error;
+                const reason = await blockIsolatedWorkflow(orchestration, recovery.item.workflow.workflowInstanceId, error, context(recovery.run.runId));
+                const result = await runDispatchLoop(pending.filter((item) => item.workflow.workflowInstanceId !== recovery.item.workflow.workflowInstanceId), {
+                    orchestration,
+                    execution,
+                    resources,
+                    dispatchPolicy,
+                    maxConcurrentRuns,
+                    maxDispatches,
+                    runnerIneligibility,
+                    isDispatchPaused,
+                    commandContext: context,
+                });
+                return result.kind === 'progressed'
+                    ? result
+                    : {
+                        kind: WorkflowStatus.Blocked,
+                        workflowInstanceId: recovery.item.workflow.workflowInstanceId,
+                        reason,
+                    };
+            }
         }
         const result = await runDispatchLoop(pending, {
             orchestration,

package/dist/src/control-plane/application/advance-once-dispatch.d.ts

@@ -20,6 +20,9 @@ interface PendingActivation {
     readonly workflow: WorkflowInstanceView;
     readonly activation: ActivityActivationView;
 }
+export declare function advancementWasDurablyApplied(orchestration: OrchestrationPort, workflowInstanceId: WorkflowInstanceView['workflowInstanceId'], activationId: ActivityActivationView['activationId']): Promise<boolean>;
+export declare function isolatedWorkflowReason(error: unknown): string;
+export declare function blockIsolatedWorkflow(orchestration: OrchestrationPort, workflowInstanceId: string, error: unknown, context: CommandContext): Promise<string>;
 export declare function isRunnerQuotaOutcome(outcome: ActivityOutcome): boolean;
 export declare function runnerQuotaMessage(outcome: ActivityOutcome): string;
 /**

package/dist/src/control-plane/application/advance-once-dispatch.js

@@ -2,6 +2,24 @@ import { ActivityFailureCode, ActivityOutcomeKind, } from '../../activities/inde
 import { ActivationClaimConflictError, isActiveRunStatus, NoEligibleRunnerError, RunStatus, WorkspaceMode, } from '../../execution/index.js';
 import { WorkflowStatus } from '../../orchestration/index.js';
 import { isExecutionFailureTerminal } from './execution-reconciliation.js';
+export async function advancementWasDurablyApplied(orchestration, workflowInstanceId, activationId) {
+    const current = await orchestration.get?.(workflowInstanceId);
+    return (current !== undefined && current !== null && current.acceptedOutcomes.includes(activationId));
+}
+const maximumIsolationReasonLength = 2_000;
+export function isolatedWorkflowReason(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `workflow advancement failed: ${message}`.slice(0, maximumIsolationReasonLength);
+}
+export async function blockIsolatedWorkflow(orchestration, workflowInstanceId, error, context) {
+    const reason = isolatedWorkflowReason(error);
+    if (orchestration.block === undefined)
+        throw new Error('Orchestration port cannot durably block an isolated workflow', {
+            cause: error,
+        });
+    await orchestration.block(workflowInstanceId, reason, context);
+    return reason;
+}
 export function isRunnerQuotaOutcome(outcome) {
     return (outcome.kind === ActivityOutcomeKind.Failed &&
         typeof outcome.data === 'object' &&
@@ -37,6 +55,8 @@ export function reportUnappliedRunnerQuotaRetry(result, input) {
 export async function runDispatchLoop(pending, ctx) {
     const dispatched = [];
     const dispatchedIds = new Set();
+    const isolatedIds = new Set();
+    let isolated;
     let stopReason;
     while (dispatched.length < ctx.maxDispatches) {
         const allRuns = await ctx.execution.list();
@@ -48,7 +68,9 @@ export async function runDispatchLoop(pending, ctx) {
             stopReason = { kind: 'no-work' };
             break;
         }
-        const selectedCandidate = ctx.dispatchPolicy.select(await Promise.all(pending.map(async (item, requestedPosition) => ({
+        const selectedCandidate = ctx.dispatchPolicy.select(pending
+            .filter((item) => !isolatedIds.has(item.workflow.workflowInstanceId))
+            .map((item, requestedPosition) => ({
             workItemId: item.workflow.workItemId,
             activationId: item.activation.activationId,
             requestedPosition,
@@ -56,7 +78,7 @@ export async function runDispatchLoop(pending, ctx) {
                 activeActivationIds.has(item.activation.activationId) ||
                 branchActiveWorkflowIds.has(item.workflow.workflowInstanceId),
             cancelled: false,
-        }))))[0];
+        })))[0];
         const selected = selectedCandidate === undefined
             ? undefined
             : pending.find((item) => item.activation.activationId === selectedCandidate.activationId);
@@ -73,17 +95,16 @@ export async function runDispatchLoop(pending, ctx) {
             stopReason = { kind: 'paused' };
             break;
         }
-        if ((await ctx.orchestration.validateActivationDispatch?.(selected.workflow.workflowInstanceId, ctx.commandContext(selected.activation.activationId))) === false) {
-            stopReason = { kind: 'no-work' };
-            break;
-        }
-        await ctx.orchestration.markActivationStarted(selected.workflow.workflowInstanceId, selected.activation.activationId, ctx.commandContext(selected.activation.activationId));
-        const correlated = await ctx.resources.correlationsForWork(selected.workflow.workItemId);
-        const resourceViews = (await Promise.all(correlated.map((entry) => ctx.resources.get(entry.resourceId)))).filter((resource) => resource !== null);
         const ineligible = await ctx.runnerIneligibility();
-        let run;
         try {
-            run = await ctx.execution.attempt(selected.activation, {
+            if ((await ctx.orchestration.validateActivationDispatch?.(selected.workflow.workflowInstanceId, ctx.commandContext(selected.activation.activationId))) === false) {
+                stopReason = { kind: 'no-work' };
+                break;
+            }
+            await ctx.orchestration.markActivationStarted(selected.workflow.workflowInstanceId, selected.activation.activationId, ctx.commandContext(selected.activation.activationId));
+            const correlated = await ctx.resources.correlationsForWork(selected.workflow.workItemId);
+            const resourceViews = (await Promise.all(correlated.map((entry) => ctx.resources.get(entry.resourceId)))).filter((resource) => resource !== null);
+            const run = await ctx.execution.attempt(selected.activation, {
                 workItemId: selected.workflow.workItemId,
                 workflowInstanceId: selected.workflow.workflowInstanceId,
                 orchestrationGroupId: selected.workflow.orchestrationGroupId,
@@ -95,20 +116,9 @@ export async function runDispatchLoop(pending, ctx) {
                 awaitImmediateCompletion: true,
                 ...(ineligible.size === 0 ? {} : { ineligibleRunners: ineligible }),
             });
-        }
-        catch (error) {
-            if (error instanceof ActivationClaimConflictError) {
-                stopReason = { kind: 'no-work' };
-                break;
-            }
-            if (error instanceof NoEligibleRunnerError) {
-                stopReason = { kind: 'no-work' };
-                break;
-            }
-            throw error;
-        }
-        if (run.status === RunStatus.Succeeded && run.outcome !== undefined) {
-            if (isRunnerQuotaOutcome(run.outcome)) {
+            if (run.status === RunStatus.Succeeded &&
+                run.outcome !== undefined &&
+                isRunnerQuotaOutcome(run.outcome)) {
                 // No isDispatchPaused check here: a quota retry re-requests the same
                 // stage's activity without publishing an outcome or consuming retry
                 // budget, so it must not be held behind maintenance pause the way an
@@ -124,7 +134,7 @@ export async function runDispatchLoop(pending, ctx) {
                     runId: run.runId,
                 });
             }
-            else {
+            else if (run.status === RunStatus.Succeeded && run.outcome !== undefined) {
                 if (await ctx.isDispatchPaused()) {
                     stopReason = { kind: 'paused' };
                     break;
@@ -135,25 +145,45 @@ export async function runDispatchLoop(pending, ctx) {
                     outcome: run.outcome,
                 }, ctx.commandContext(run.runId));
             }
+            if (isExecutionFailureTerminal(run.status))
+                await ctx.orchestration.resolveExecutionFailure?.(selected.workflow.workflowInstanceId, {
+                    activationId: selected.activation.activationId,
+                    runId: run.runId,
+                    reason: run.failure?.message ?? 'execution failed',
+                }, ctx.commandContext(run.runId));
+            if (run.status !== RunStatus.Succeeded && !isActiveRunStatus(run.status)) {
+                stopReason = {
+                    kind: WorkflowStatus.Blocked,
+                    workflowInstanceId: selected.workflow.workflowInstanceId,
+                    reason: run.failure?.message ?? 'execution failed',
+                };
+                break;
+            }
+            dispatched.push({ activationId: selected.activation.activationId, runId: run.runId });
+            dispatchedIds.add(selected.activation.activationId);
         }
-        if (isExecutionFailureTerminal(run.status))
-            await ctx.orchestration.resolveExecutionFailure?.(selected.workflow.workflowInstanceId, {
-                activationId: selected.activation.activationId,
-                runId: run.runId,
-                reason: run.failure?.message ?? 'execution failed',
-            }, ctx.commandContext(run.runId));
-        if (run.status !== RunStatus.Succeeded && !isActiveRunStatus(run.status)) {
-            stopReason = {
+        catch (error) {
+            if (error instanceof ActivationClaimConflictError) {
+                stopReason = { kind: 'no-work' };
+                break;
+            }
+            if (error instanceof NoEligibleRunnerError) {
+                stopReason = { kind: 'no-work' };
+                break;
+            }
+            if (await advancementWasDurablyApplied(ctx.orchestration, selected.workflow.workflowInstanceId, selected.activation.activationId))
+                throw error;
+            const reason = await blockIsolatedWorkflow(ctx.orchestration, selected.workflow.workflowInstanceId, error, ctx.commandContext(selected.activation.activationId));
+            isolatedIds.add(selected.workflow.workflowInstanceId);
+            isolated = {
                 kind: WorkflowStatus.Blocked,
                 workflowInstanceId: selected.workflow.workflowInstanceId,
-                reason: run.failure?.message ?? 'execution failed',
+                reason,
             };
-            break;
+            continue;
         }
-        dispatched.push({ activationId: selected.activation.activationId, runId: run.runId });
-        dispatchedIds.add(selected.activation.activationId);
     }
     return dispatched.length > 0
         ? { kind: 'progressed', dispatched }
-        : (stopReason ?? { kind: 'no-work' });
+        : (stopReason ?? isolated ?? { kind: 'no-work' });
 }

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/README.md

@@ -18,23 +18,19 @@ durable flat JSONL segment format, while checkpoints, processor state,
 projections, locks, and processor serialisation use compatible atomic
 filesystem operations.
 
-`FileProjectionStore` is exclusively for rebuildable Eventing read models.
-`FileProcessorStateStore` persists processor-owned recovery state separately.
-When processor state uses established compatible paths beneath `projections/`,
-pass each state consumer to `FileProjectionStore` so a projection rebuild
-reserves its current, legacy, and collision-isolated directories:
+`FileProjectionStore` is exclusively for rebuildable Eventing read models and
+`FileProcessorStateStore` persists processor-owned recovery state separately:
 
 ```ts
-const projections = new FileProjectionStore(dataRoot, {
-  protectedProcessorStateConsumers: ['reactor:delivery-outcomes'],
-});
+const projections = new FileProjectionStore(dataRoot);
 const processorState = new FileProcessorStateStore(dataRoot);
 ```
 
-This is structural path ownership; projection clearing never infers state from
-record contents. Wake Bootstrap supplies its known processor consumers.
-The adapter reads established Wake-home records without a data migration, but
-does not supply a legacy source import, a compatibility package, or a second
-runtime path. All supported imports come from
-`@atolis-hq/eventing-filesystem`; internal codecs and storage helpers are not
-public API.
+Projection records are stored at
+`projections/projection/<namespace-sha256>/<key-sha256>.json`; processor state
+is stored at `projections/processor-state/<consumer-sha256>/<key-sha256>.json`.
+`FileProjectionStore.clear()` removes only the rebuildable `projection` subtree
+and never infers processor state from record contents. This is a fresh-storage
+format: the adapter does not read, migrate, or write prior projection paths.
+All supported imports come from `@atolis-hq/eventing-filesystem`; internal
+codecs and storage helpers are not public API.

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/file-processor-state-store.d.ts

@@ -6,7 +6,7 @@ export declare class FileProcessorStateStore implements ProcessorStateStore {
     write<Value>(state: StoredProcessorState<Value>): Promise<void>;
     delete(consumer: string, key: string): Promise<void>;
     private paths;
-    private withStateLocks;
-    private readCandidates;
+    private withStateLock;
+    private readState;
 }
 //# sourceMappingURL=file-processor-state-store.d.ts.map

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/file-processor-state-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-processor-state-store.d.ts","sourceRoot":"","sources":["../src/file-processor-state-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAcrF,qBAAa,uBAAwB,YAAW,mBAAmB;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,MAAM;IAEnC,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAWvF,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,oBAAoB,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB/D,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU1D,OAAO,CAAC,KAAK;YAIC,cAAc;YAOd,cAAc;CAY7B"}
+{"version":3,"file":"file-processor-state-store.d.ts","sourceRoot":"","sources":["../src/file-processor-state-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAarF,qBAAa,uBAAwB,YAAW,mBAAmB;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,MAAM;IAEnC,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAQvF,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,oBAAoB,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAY/D,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS1D,OAAO,CAAC,KAAK;YAIC,aAAa;YAIb,SAAS;CAQxB"}

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/file-processor-state-store.js

@@ -5,7 +5,6 @@ import { withFileLock } from './file-lock.js';
 import { atomicJson } from './file-projection-store.js';
 import { processorStatePaths } from './processor-state-paths.js';
 import { isCompatibleProcessorStateRecord, } from './processor-state-record.js';
-import { encodeLegacyStorageName } from './storage-name.js';
 export class FileProcessorStateStore {
     root;
     constructor(root) {
@@ -13,69 +12,46 @@ export class FileProcessorStateStore {
     }
     async read(consumer, key) {
         const paths = this.paths(consumer, key);
-        const candidates = await this.readCandidates(paths);
-        const stored = candidates.find(({ state }) => matchesStateIdentity(state, paths.namespace, key))?.state;
-        if (stored !== undefined && stored !== null)
+        const stored = await this.readState(paths);
+        if (stored !== null && matchesStateIdentity(stored, paths.namespace, key))
             return { consumer, key, value: stored.value };
         return null;
     }
     async write(state) {
         const paths = this.paths(state.consumer, state.key);
-        await this.withStateLocks(candidatePaths(paths), async () => {
-            const candidates = await this.readCandidates(paths);
-            const current = candidateState(candidates, paths.current);
+        await this.withStateLock(paths.current, async () => {
+            const current = await this.readState(paths);
             if (matchesStateIdentity(current, paths.namespace, state.key))
                 return atomicJson(paths.current, compatibleRecord(paths.namespace, state));
-            const isolated = candidateState(candidates, paths.isolated);
-            if (matchesStateIdentity(isolated, paths.namespace, state.key))
-                return atomicJson(paths.isolated, compatibleRecord(paths.namespace, state));
             if (current === null)
                 return atomicJson(paths.current, compatibleRecord(paths.namespace, state));
-            if (isolated === null)
-                return atomicJson(paths.isolated, compatibleRecord(paths.namespace, state));
             throw new Error(`Processor state paths are occupied for ${state.consumer}:${state.key}`);
         });
     }
     async delete(consumer, key) {
         const paths = this.paths(consumer, key);
-        await this.withStateLocks(candidatePaths(paths), async () => {
-            const candidates = await this.readCandidates(paths);
-            for (const { path, state } of candidates) {
-                if (matchesStateIdentity(state, paths.namespace, key))
-                    await rm(path, { force: true });
-            }
+        await this.withStateLock(paths.current, async () => {
+            const state = await this.readState(paths);
+            if (matchesStateIdentity(state, paths.namespace, key))
+                await rm(paths.current, { force: true });
         });
     }
     paths(consumer, key) {
         return processorStatePaths(this.root, consumer, key);
     }
-    async withStateLocks(paths, operation) {
-        const locks = uniquePaths(paths)
-            .map((path) => processorStateLockPath(this.root, path))
-            .sort();
-        return withLocks(locks, operation);
+    async withStateLock(path, operation) {
+        return withFileLock(processorStateLockPath(this.root, path), operation, { waitMs: 5_000 });
     }
-    async readCandidates(paths) {
-        const candidates = await Promise.all(candidatePaths(paths).map(async (path) => ({ path, state: await readCompatibleState(path) })));
-        for (const { path, state } of candidates) {
-            if (state !== null)
-                assertCandidateProvenance(this.root, path, state, paths.namespace, paths.key);
-        }
-        return candidates;
+    async readState(paths) {
+        const state = await readCompatibleState(paths.current);
+        if (state !== null && !matchesStateIdentity(state, paths.namespace, paths.key))
+            throw invalidProcessorStateRecord(paths.current);
+        return state;
     }
 }
-function legacyProcessorStatePath(root, namespace, key) {
-    return join(root, 'projections', encodeLegacyStorageName(namespace), `${encodeLegacyStorageName(key)}.json`);
-}
 function processorStateLockPath(root, path) {
     return join(root, 'locks', 'processor-state', `${createHash('sha256').update(path).digest('hex')}.lock`);
 }
-async function withLocks(paths, operation) {
-    const [path, ...rest] = paths;
-    if (path === undefined)
-        return operation();
-    return withFileLock(path, () => withLocks(rest, operation), { waitMs: 5_000 });
-}
 async function readCompatibleState(path) {
     let raw;
     try {
@@ -103,25 +79,6 @@ function invalidProcessorStateRecord(path, cause) {
 function matchesStateIdentity(stored, namespace, key) {
     return stored?.namespace === namespace && stored.key === key;
 }
-function assertCandidateProvenance(root, path, stored, namespace, key) {
-    if (matchesStateIdentity(stored, namespace, key))
-        return;
-    if (legacyProcessorStatePath(root, stored.namespace, stored.key) === path)
-        return;
-    throw invalidProcessorStateRecord(path);
-}
 function compatibleRecord(namespace, state) {
     return { namespace, key: state.key, lastGlobalPosition: 0, value: state.value };
 }
-function uniquePaths(paths) {
-    return [...new Set(paths)];
-}
-function candidatePaths(paths) {
-    return uniquePaths([paths.current, paths.isolated, paths.legacy]);
-}
-function candidateState(candidates, path) {
-    const candidate = candidates.find((value) => value.path === path);
-    if (candidate === undefined)
-        throw new Error(`Missing processor state candidate for ${path}`);
-    return candidate.state;
-}

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/file-projection-store.d.ts

@@ -1,11 +1,7 @@
 import type { ProjectionStore, StoredProjection } from '@atolis-hq/eventing';
-export interface FileProjectionStoreOptions {
-    readonly protectedProcessorStateConsumers?: readonly string[];
-}
 export declare class FileProjectionStore implements ProjectionStore {
     private readonly root;
-    private readonly protectedDirectories;
-    constructor(root: string, options?: FileProjectionStoreOptions);
+    constructor(root: string);
     private readonly listCache;
     read<Value>(namespace: string, key: string): Promise<StoredProjection<Value> | null>;
     write<Value>(projection: StoredProjection<Value>): Promise<void>;
@@ -14,6 +10,5 @@ export declare class FileProjectionStore implements ProjectionStore {
     private clearProjectionNamespace;
     private clearAllProjectionDirectories;
 }
-export declare function encode(value: string): string;
 export declare function atomicJson(path: string, value: unknown): Promise<void>;
 //# sourceMappingURL=file-projection-store.d.ts.map

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/file-projection-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-projection-store.d.ts","sourceRoot":"","sources":["../src/file-projection-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAQ7E,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,gCAAgC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/D;AAED,qBAAa,mBAAoB,YAAW,eAAe;IAIvD,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHvB,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAsB;gBAGxC,IAAI,EAAE,MAAM,EAC7B,OAAO,GAAE,0BAA+B;IAO1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgD;IAEpE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAapF,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA2ChE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;IAoB3E,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAOhC,wBAAwB;YAaxB,6BAA6B;CAiB5C;AAwJD,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5E"}
+{"version":3,"file":"file-projection-store.d.ts","sourceRoot":"","sources":["../src/file-projection-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAO7E,qBAAa,mBAAoB,YAAW,eAAe;IAC7C,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,MAAM;IAEzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgD;IAEpE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAUpF,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA2ChE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;IAoB3E,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAOhC,wBAAwB;YAIxB,6BAA6B;CAG5C;AAgID,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5E"}

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/file-projection-store.js

@@ -1,22 +1,17 @@
 import { readFile, readdir, rm, stat } from 'node:fs/promises';
-import { basename, dirname, join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { writeFileAtomically } from './atomic-write.js';
-import { processorStateDirectoryNames } from './processor-state-paths.js';
-import { encodeLegacyStorageName, encodeStorageName } from './storage-name.js';
+import { projectionStorageAddress } from './storage-name.js';
 export class FileProjectionStore {
     root;
-    protectedDirectories;
-    constructor(root, options = {}) {
+    constructor(root) {
         this.root = root;
-        this.protectedDirectories = new Set((options.protectedProcessorStateConsumers ?? []).flatMap(processorStateDirectoryNames));
     }
     listCache = new Map();
     async read(namespace, key) {
-        for (const path of projectionPaths(this.root, namespace, key).candidates) {
-            const projection = await readProjection(path);
-            if (matchesProjection(projection, namespace, key))
-                return projection;
-        }
+        const projection = await readProjection(projectionPaths(this.root, namespace, key).current);
+        if (matchesProjection(projection, namespace, key))
+            return projection;
         return null;
     }
     // Patches the cached entry in place rather than invalidating the whole
@@ -92,57 +87,21 @@ export class FileProjectionStore {
             this.listCache.delete(namespace);
     }
     async clearProjectionNamespace(namespace) {
-        const [currentDirectory, ...legacyDirectories] = projectionDirectories(this.root, namespace);
-        // The versioned directory belongs exclusively to this namespace, unlike a
-        // legacy directory that can collide with another namespace's spelling.
-        await rm(currentDirectory, { recursive: true, force: true });
-        await Promise.all(legacyDirectories.map(async (directory) => {
-            if (this.protectedDirectories.has(directoryName(directory)))
-                return;
-            await clearProjectionDirectory(directory, namespace);
-        }));
+        await rm(projectionDirectories(this.root, namespace)[0], { recursive: true, force: true });
     }
     async clearAllProjectionDirectories() {
-        const root = join(this.root, 'projections');
-        let namespaces;
-        try {
-            namespaces = await readdir(root);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return;
-            throw error;
-        }
-        await Promise.all(namespaces.map(async (namespace) => {
-            const directory = join(root, namespace);
-            if (this.protectedDirectories.has(namespace))
-                return;
-            await rm(directory, { recursive: true, force: true });
-        }));
+        await rm(join(this.root, 'projections', 'projection'), { recursive: true, force: true });
     }
 }
 function directoryRevision(info) {
     return `${info.mtimeMs}:${info.ctimeMs}`;
 }
 function projectionPaths(root, namespace, key) {
-    const currentNamespace = encode(namespace);
-    const currentKey = encode(key);
-    const legacyNamespace = encodeLegacyStorageName(namespace);
-    const legacyKey = encodeLegacyStorageName(key);
-    const current = projectionPath(root, `%projection-${currentNamespace}`, `%projection-${currentKey}`);
-    const legacy = projectionPath(root, legacyNamespace, legacyKey);
-    return {
-        current,
-        legacy,
-        candidates: uniquePaths([current, legacy]),
-    };
+    const current = projectionPath(root, join('projection', projectionStorageAddress(namespace)), projectionStorageAddress(key));
+    return { current };
 }
 function projectionDirectories(root, namespace) {
-    const currentNamespace = encode(namespace);
-    return uniquePaths([
-        join(root, 'projections', `%projection-${currentNamespace}`),
-        join(root, 'projections', encodeLegacyStorageName(namespace)),
-    ]);
+    return [join(root, 'projections', 'projection', projectionStorageAddress(namespace))];
 }
 function projectionPath(root, namespace, key) {
     return join(root, 'projections', namespace, `${key}.json`);
@@ -197,22 +156,15 @@ function sameDirectoryRevisions(left, right) {
         left.every((entry, index) => entry.directory === right[index].directory && entry.value === right[index].value));
 }
 function compareCachedProjectionFiles(left, right) {
-    return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
-}
-async function clearProjectionDirectory(directory, namespace) {
-    const entries = await readProjectionDirectory(directory);
-    await Promise.all(entries
-        .filter((entry) => matchesProjection(entry.value, namespace))
-        .map((entry) => rm(entry.path, { force: true })));
-}
-function uniquePaths(paths) {
-    return [...new Set(paths)];
-}
-function directoryName(path) {
-    return basename(path);
-}
-export function encode(value) {
-    return encodeStorageName(value);
+    return left.value.key < right.value.key
+        ? -1
+        : left.value.key > right.value.key
+            ? 1
+            : left.path < right.path
+                ? -1
+                : left.path > right.path
+                    ? 1
+                    : 0;
 }
 export async function atomicJson(path, value) {
     await writeFileAtomically(path, `${JSON.stringify(value)}\n`);

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/index.d.ts

@@ -3,5 +3,5 @@ export { FileEventJournal, type FileEventJournalOptions, type FileEventJournalWa
 export { acquireFileLock, withFileLock, type FileLockMetadata, type FileLockOptions, type WithFileLockOptions, } from './file-lock.js';
 export { createFileProcessorRunSerialiser } from './file-processor-run-serialiser.js';
 export { FileProcessorStateStore } from './file-processor-state-store.js';
-export { FileProjectionStore, type FileProjectionStoreOptions } from './file-projection-store.js';
+export { FileProjectionStore } from './file-projection-store.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,8BAA8B,GACpC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,eAAe,EACf,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AAEtF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,EAAE,mBAAmB,EAAE,KAAK,0BAA0B,EAAE,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,8BAA8B,GACpC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,eAAe,EACf,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AAEtF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/processor-state-paths.d.ts

@@ -2,9 +2,6 @@ export interface ProcessorStatePaths {
     readonly key: string;
     readonly namespace: string;
     readonly current: string;
-    readonly isolated: string;
-    readonly legacy: string;
 }
 export declare function processorStatePaths(root: string, consumer: string, key: string): ProcessorStatePaths;
-export declare function processorStateDirectoryNames(consumer: string): readonly string[];
 //# sourceMappingURL=processor-state-paths.d.ts.map

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/processor-state-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processor-state-paths.d.ts","sourceRoot":"","sources":["../src/processor-state-paths.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,GACV,mBAAmB,CAmBrB;AAED,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAIhF"}
+{"version":3,"file":"processor-state-paths.d.ts","sourceRoot":"","sources":["../src/processor-state-paths.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,GACV,mBAAmB,CAcrB"}

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/processor-state-paths.js

@@ -1,27 +1,12 @@
 import { join } from 'node:path';
-import { assertStorageName, encodeLegacyStorageName, encodeStorageName } from './storage-name.js';
+import { assertStorageName, projectionStorageAddress } from './storage-name.js';
 const pendingNamespaceSuffix = ':pending';
 export function processorStatePaths(root, consumer, key) {
-    const namespace = processorStateNamespace(consumer);
-    const currentNamespace = encodeStorageName(namespace);
-    const currentKey = encodeStorageName(key);
+    assertStorageName(consumer);
+    assertStorageName(key);
     return {
         key,
-        namespace,
-        current: processorStatePath(root, currentNamespace, currentKey),
-        isolated: processorStatePath(root, `%processor-state-${currentNamespace}`, `%processor-state-${currentKey}`),
-        legacy: processorStatePath(root, encodeLegacyStorageName(namespace), encodeLegacyStorageName(key)),
+        namespace: `${consumer}${pendingNamespaceSuffix}`,
+        current: join(root, 'projections', 'processor-state', projectionStorageAddress(consumer), `${projectionStorageAddress(key)}.json`),
     };
 }
-export function processorStateDirectoryNames(consumer) {
-    const namespace = processorStateNamespace(consumer);
-    const current = encodeStorageName(namespace);
-    return [...new Set([current, `%processor-state-${current}`, encodeLegacyStorageName(namespace)])];
-}
-function processorStateNamespace(consumer) {
-    assertStorageName(consumer);
-    return `${consumer}${pendingNamespaceSuffix}`;
-}
-function processorStatePath(root, namespace, key) {
-    return join(root, 'projections', namespace, `${key}.json`);
-}

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/storage-name.d.ts

@@ -1,6 +1,6 @@
 export declare function assertWellFormedUtf16(value: string, label: string): void;
 export declare function assertStorageName(value: string): void;
-export declare function encodeStorageName(value: string): string;
 export declare function encodeLegacyStorageName(value: string): string;
 export declare function encodeCheckpointStorageName(consumer: string): string;
+export declare function projectionStorageAddress(value: string): string;
 //# sourceMappingURL=storage-name.d.ts.map

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/storage-name.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-name.d.ts","sourceRoot":"","sources":["../src/storage-name.ts"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAYxE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAIrD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMvD;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGpE"}
+{"version":3,"file":"storage-name.d.ts","sourceRoot":"","sources":["../src/storage-name.ts"],"names":[],"mappings":"AAEA,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAYxE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAIrD;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG9D"}

package/dist/src/node_modules/@atolis-hq/eventing-filesystem/dist/storage-name.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 export function assertWellFormedUtf16(value, label) {
     for (let index = 0; index < value.length; index += 1) {
         const codeUnit = value.charCodeAt(index);
@@ -17,13 +18,6 @@ export function assertStorageName(value) {
     if (value.length === 0 || /[\\/]/.test(value))
         throw new Error('Storage name must not contain path separators');
 }
-export function encodeStorageName(value) {
-    assertStorageName(value);
-    return encodeURIComponent(value)
-        .replace(/~/g, '%7E')
-        .replace(/%(?!7E)/g, '~')
-        .replace(/\./g, '~2E');
-}
 export function encodeLegacyStorageName(value) {
     assertStorageName(value);
     return encodeURIComponent(value).replace(/%/g, '~').replace(/\./g, '~2E');
@@ -32,3 +26,7 @@ export function encodeCheckpointStorageName(consumer) {
     assertStorageName(consumer);
     return Buffer.from(consumer, 'utf8').toString('base64url');
 }
+export function projectionStorageAddress(value) {
+    assertStorageName(value);
+    return createHash('sha256').update(value, 'utf8').digest('base64url');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.4.43",
+  "version": "0.4.45",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {