@atolis-hq/wake 0.3.50 → 0.3.52

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

@@ -12,6 +12,7 @@ import { loadFakeScenarios } from './fake-scenarios.js';
 import { composeIntegrationRuntime } from './integration-runtime.js';
 import { resolveWakePaths } from './paths.js';
 import { composePersistence } from './persistence-composition.js';
+import { createFileProjectionRunSerialiser, } from './projection-runtime.js';
 import { createRunnerQuotaReporter } from './runner-quota-reporter.js';
 import { createRunnerRegistry } from './runner-registry.js';
 import { FileScheduleCheckpointStore } from './schedule-checkpoint-store.js';
@@ -130,6 +131,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         work,
         ids,
         wakeRoot,
+        projectionRunSerialiser: createFileProjectionRunSerialiser(paths.dataRoot),
         scheduleCheckpoints: options.scheduleCheckpoints ?? new FileScheduleCheckpointStore(paths.dataRoot),
         ...(options.decorateDeliveryAdapter === undefined
             ? {}

package/dist/src/bootstrap/integration-runtime.js

@@ -55,7 +55,7 @@ export async function composeIntegrationRuntime(input) {
     // 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 projectionRunner = serializeRunRegisteredOnce(createRuntimeProjectionRunner(input.journal, input.projections, input.checkpoints, input.projectionRunSerialiser));
     const delivery = new DeliveryService({
         journal: input.journal,
         intents: async () => (await input.projections.list(IntegrationStreamKind.Delivery)).map(({ value }) => value),

package/dist/src/bootstrap/projection-runtime.js

@@ -1,9 +1,10 @@
+import { join } from 'node:path';
 import { activityProjectionDefinitions } from '../activities/index.js';
 import { controlPlaneProjectionDefinitions } from '../control-plane/index.js';
 import { executionProjection, runsByWorkflowInstanceProjection } from '../execution/index.js';
 import { deliveryProjectionDefinitions } from '../integrations/index.js';
 import { orchestrationProjection, workflowDefinitionsProjection, workflowsByWorkItemProjection, } from '../orchestration/index.js';
-import { ProjectionRunner } from '../persistence/index.js';
+import { acquireFileLock, ProjectionRunner, } from '../persistence/index.js';
 import { resourceCorrelationProjection, resourceProjection, resourcesByExternalKeyProjection, workCorrelationsProjection, } from '../resources/index.js';
 import { workProjection } from '../work/index.js';
 import { analyticsProjection } from './analytics-projection.js';
@@ -25,6 +26,26 @@ export const runtimeProjectionDefinitions = [
     boardProjection,
     analyticsProjection,
 ];
-export function createRuntimeProjectionRunner(journal, projections, checkpoints) {
-    return new ProjectionRunner(journal, projections, checkpoints, runtimeProjectionDefinitions);
+export function createRuntimeProjectionRunner(journal, projections, checkpoints, serialiseRun) {
+    return new ProjectionRunner(journal, projections, checkpoints, runtimeProjectionDefinitions, serialiseRun);
+}
+export function createFileProjectionRunSerialiser(dataRoot) {
+    const path = join(dataRoot, 'locks', 'projection-runner.lock');
+    return async (operation) => {
+        while (true) {
+            const lock = await acquireFileLock(path, {
+                staleAfterMs: 60_000,
+                staleRequiresDeadProcess: true,
+            });
+            if (lock.acquired) {
+                try {
+                    return await operation();
+                }
+                finally {
+                    await lock.release();
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    };
 }

package/dist/src/bootstrap/version.js

@@ -108,4 +108,4 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "g562f222";
+export const wakeVersion = "gecabe68";

package/dist/src/persistence/application/projection-runner.js

@@ -1,14 +1,19 @@
+async function runImmediately(operation) {
+    return operation();
+}
 export class ProjectionRunner {
     journal;
     projections;
     checkpoints;
     registered;
+    serialiseRun;
     caughtUpToGlobalPosition;
-    constructor(journal, projections, checkpoints, registered = []) {
+    constructor(journal, projections, checkpoints, registered = [], serialiseRun = runImmediately) {
         this.journal = journal;
         this.projections = projections;
         this.checkpoints = checkpoints;
         this.registered = registered;
+        this.serialiseRun = serialiseRun;
     }
     // One shared journal read for every registered definition, not one per
     // definition: readAll ultimately re-derives its content-fingerprint via
@@ -26,6 +31,9 @@ export class ProjectionRunner {
     // batch — otherwise a backlog bigger than `limit` would get marked caught
     // up after its first (partial) batch and never finish draining.
     async runRegisteredOnce(limit = 100) {
+        return this.serialiseRun(() => this.runRegisteredOnceUnlocked(limit));
+    }
+    async runRegisteredOnceUnlocked(limit) {
         const allEvents = await this.journal.readAll(0);
         const latestGlobalPosition = allEvents.at(-1)?.globalPosition ?? 0;
         if (this.caughtUpToGlobalPosition !== undefined &&
@@ -37,6 +45,9 @@ export class ProjectionRunner {
         return counts.reduce((total, count) => total + count, 0);
     }
     async runOnce(definition, limit = 100) {
+        return this.serialiseRun(() => this.runOnceUnlocked(definition, limit));
+    }
+    async runOnceUnlocked(definition, limit) {
         const consumer = `projection:${definition.name}`;
         const events = await this.journal.readAll(await this.checkpoints.load(consumer), limit);
         return this.apply(definition, consumer, events);
@@ -66,11 +77,14 @@ export class ProjectionRunner {
         return events.length;
     }
     async rebuild(definition) {
+        return this.serialiseRun(() => this.rebuildUnlocked(definition));
+    }
+    async rebuildUnlocked(definition) {
         await this.projections.clear(definition.name);
         await this.checkpoints.reset(`projection:${definition.name}`);
         let total = 0;
         while (true) {
-            const count = await this.runOnce(definition);
+            const count = await this.runOnceUnlocked(definition, 100);
             total += count;
             if (count < 100)
                 return total;

package/dist/src/surfaces/cli/main.js

@@ -13,7 +13,7 @@ export function parseWakeCommand(arguments_) {
                 workItemId: requiredArgument(second, 'correlate work item'),
             };
         case 'validate-state':
-            return parseValidateState(first, second);
+            return parseValidateState(arguments_.slice(1));
         case 'api':
         case 'ui':
             return { kind: command, ...parseHostOptions(arguments_.slice(1)) };
@@ -33,11 +33,27 @@ export function parseWakeCommand(arguments_) {
             throw new Error(`Unknown wake command: ${command ?? ''}`);
     }
 }
-function parseValidateState(first, second) {
-    const allowed = first === undefined || first === '--rebuild-projections';
-    if (!allowed || second !== undefined)
-        throw new Error('validate-state accepts only --rebuild-projections');
-    return { kind: 'validate-state', rebuildProjections: first === '--rebuild-projections' };
+function parseValidateState(arguments_) {
+    let rebuildProjections = false;
+    let wakeRoot;
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === '--rebuild-projections' && !rebuildProjections) {
+            rebuildProjections = true;
+            continue;
+        }
+        if (argument === '--wake-root') {
+            wakeRoot = requiredArgument(arguments_[index + 1], 'value for --wake-root');
+            index += 1;
+            continue;
+        }
+        throw new Error('validate-state accepts only --rebuild-projections and --wake-root <path>');
+    }
+    return {
+        kind: 'validate-state',
+        rebuildProjections,
+        ...(wakeRoot === undefined ? {} : { wakeRoot }),
+    };
 }
 function parseResidentCommand(kind, arguments_) {
     const options = parseHostOptions(arguments_, false);

package/package.json

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