@atolis-hq/wake 0.3.43 → 0.3.45

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

@@ -49,6 +49,7 @@ function projectWork(view, event, occurredAt) {
             condition: BoardCondition.Ready,
             dwellSince: occurredAt,
             runCount: 0,
+            activeRuns: {},
             totalTokens: 0,
             inputTokens: 0,
             outputTokens: 0,
@@ -246,9 +247,11 @@ function projectRun(view, event, _occurredAt) {
 }
 function projectRunTerminal(view, event, workId, card) {
     const finishedAt = terminalFinishedAt(event);
-    const runDurationMs = card.activeRun === undefined || finishedAt === undefined
+    const activeRuns = activeRunsFor(view, card, workId);
+    const activeRun = activeRuns[event.stream.id];
+    const runDurationMs = activeRun === undefined || finishedAt === undefined
         ? 0
-        : Date.parse(finishedAt) - Date.parse(card.activeRun.startedAt);
+        : Date.parse(finishedAt) - Date.parse(activeRun.startedAt);
     const terminal = terminalRunFields(event);
     // Same legacy-checkpoint tolerance as the `children` guard above: a
     // checkpoint persisted before `childRuns` was added round-trips without
@@ -259,7 +262,8 @@ function projectRunTerminal(view, event, workId, card) {
         cards: {
             ...view.cards,
             [workId]: {
-                ...withoutActiveRun(card),
+                ...withoutLegacyActiveRun(card),
+                activeRuns: withoutActiveRun(activeRuns, event.stream.id),
                 ...(terminal === undefined ? {} : { lastRunOutcome: terminal.lastRunOutcome }),
                 ...(terminal === undefined || isChildRun || terminal.condition === undefined
                     ? {}
@@ -279,6 +283,7 @@ function projectRunStarted(view, event) {
     // that guard, so a checkpoint predating `children` must not crash here either.
     const childAction = view.children?.[event.payload.workflowInstanceId];
     const isChildRun = childAction !== undefined;
+    const activeRuns = activeRunsFor(view, card, workId);
     return {
         ...view,
         runs: { ...view.runs, [event.stream.id]: workId },
@@ -286,16 +291,21 @@ function projectRunStarted(view, event) {
         cards: {
             ...view.cards,
             [workId]: {
-                ...(isChildRun ? card : withoutLastRunOutcome(withoutAwaitingApproval(card))),
+                ...(isChildRun
+                    ? withoutLegacyActiveRun(card)
+                    : withoutLegacyActiveRun(withoutLastRunOutcome(withoutAwaitingApproval(card)))),
                 runCount: card.runCount + 1,
                 ...(isChildRun ? {} : { condition: BoardCondition.Active }),
                 lastRunAt: event.payload.startedAt,
-                activeRun: {
-                    action: childAction ?? card.stage ?? event.payload.activity,
-                    startedAt: event.payload.startedAt,
-                    ...(event.payload.runner?.name === undefined
-                        ? {}
-                        : { runnerName: event.payload.runner.name }),
+                activeRuns: {
+                    ...activeRuns,
+                    [event.stream.id]: {
+                        action: childAction ?? card.stage ?? event.payload.activity,
+                        startedAt: event.payload.startedAt,
+                        ...(event.payload.runner?.name === undefined
+                            ? {}
+                            : { runnerName: event.payload.runner.name }),
+                    },
                 },
             },
         },
@@ -327,7 +337,21 @@ function withoutAwaitingApproval(card) {
     const { awaitingApproval: _awaitingApproval, ...withoutApproval } = card;
     return withoutApproval;
 }
-function withoutActiveRun(card) {
+function activeRunsFor(view, card, workId) {
+    if (card.activeRuns !== undefined)
+        return card.activeRuns;
+    if (card.activeRun === undefined)
+        return {};
+    const legacyRunId = Object.entries(view.runs)
+        .reverse()
+        .find(([, runWorkId]) => runWorkId === workId)?.[0];
+    return legacyRunId === undefined ? {} : { [legacyRunId]: card.activeRun };
+}
+function withoutActiveRun(activeRuns, runId) {
+    const { [runId]: _completed, ...remaining } = activeRuns;
+    return remaining;
+}
+function withoutLegacyActiveRun(card) {
     const { activeRun: _activeRun, ...withoutRun } = card;
     return withoutRun;
 }

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

@@ -29,39 +29,47 @@ function createBoardApplications(root, now) {
         async list(query) {
             const nowMs = Date.parse(now());
             const stored = await root.projections.read(boardProjection.name, 'global');
-            const cards = Object.values(stored?.value.cards ?? {}).sort((left, right) => cardRecency(right).localeCompare(cardRecency(left)));
+            const board = stored?.value ?? boardProjection.initial('global');
+            const cards = Object.values(board.cards).sort((left, right) => cardRecency(right).localeCompare(cardRecency(left)));
             const offset = query.cursor?.position ?? 0;
             const page = cards.slice(offset, offset + query.limit);
             const items = await Promise.all(page.map(async (card) => {
                 const externalRef = await primaryExternalRef(root, card.workItemId);
-                const { activeRun, ...withoutActiveRun } = card;
+                const { activeRun: _legacyActiveRun, activeRuns: _activeRuns, ...withoutActiveRuns } = card;
+                const activeRuns = activeBoardRuns(board, card);
                 return presentBoardCard({
-                    ...withoutActiveRun,
+                    ...withoutActiveRuns,
                     totalDurationMs: card.totalDurationMs ?? 0,
+                    activeRuns: Object.fromEntries(Object.entries(activeRuns).map(([runId, activeRun]) => [
+                        runId,
+                        { ...activeRun, elapsedMs: elapsedSince(activeRun.startedAt, nowMs) },
+                    ])),
                     ...(externalRef === undefined ? {} : { externalRef }),
                     ...(card.lastRunAt === undefined
                         ? {}
                         : { lastRunAgeMs: elapsedSince(card.lastRunAt, nowMs) }),
-                    ...(activeRun === undefined
-                        ? {}
-                        : {
-                            activeRun: {
-                                ...activeRun,
-                                elapsedMs: elapsedSince(activeRun.startedAt, nowMs),
-                            },
-                        }),
                 });
             }));
             return {
                 items,
                 total: cards.length,
                 ...(offset + query.limit < cards.length ? { nextPosition: offset + query.limit } : {}),
-                conditionCounts: boardConditionCounts(stored?.value ?? boardProjection.initial('global')),
+                conditionCounts: boardConditionCounts(board),
                 meta: await projectionMeta(root.journal, stored === null ? [] : [stored], now()),
             };
         },
     };
 }
+function activeBoardRuns(board, card) {
+    if (card.activeRuns !== undefined)
+        return card.activeRuns;
+    if (card.activeRun === undefined)
+        return {};
+    const legacyRunId = Object.entries(board.runs)
+        .reverse()
+        .find(([, workItemId]) => workItemId === card.workItemId)?.[0];
+    return legacyRunId === undefined ? {} : { [legacyRunId]: card.activeRun };
+}
 function createStatusApplications(root, now) {
     return {
         async get() {

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 = "g7b49dab";
+export const wakeVersion = "g8f84f8d";

package/dist/src/persistence/filesystem/file-lock.js

@@ -15,6 +15,16 @@ export async function acquireFileLock(path, options) {
         : acquireLegacyFileLock(path, metadata, options);
 }
 async function acquireStrictFileLock(path, metadata, options) {
+    try {
+        return await acquireStrictFileLockOnce(path, metadata, options);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        return acquireStrictFileLockOnce(path, metadata, options);
+    }
+}
+async function acquireStrictFileLockOnce(path, metadata, options) {
     const ownersPath = `${path}.owners`;
     await mkdir(ownersPath, { recursive: true });
     const legacy = await inspectLegacyOwner(path, ownersPath, options);