@atolis-hq/wake 0.4.44 → 0.4.46

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/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.44";
+export const wakeVersion = "v0.4.46";
 /** 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"}