@atolis-hq/wake 0.3.77 → 0.3.78

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

@@ -4,7 +4,7 @@ import { correlationId, EventActorKind } from '../kernel/index.js';
 import { ApiCommandStatus, presentRun } from '../surfaces/index.js';
 import { projectionMeta, sampledMeta } from './surface-api-metadata.js';
 import { projectionPage } from './surface-api-projection-pages.js';
-import { withWorkflowContext } from './surface-api-run-context.js';
+import { enrichRun } from './surface-api-run-context.js';
 import { readWorkTranscript } from './surface-api-transcripts.js';
 export function createExecutionApplications(root, now) {
     return {
@@ -43,7 +43,7 @@ export function createExecutionApplications(root, now) {
             });
             return {
                 ...page,
-                items: await Promise.all(page.items.map((item) => withWorkflowContext(root, item))),
+                items: await Promise.all(page.items.map((item) => enrichRun(root, item))),
             };
         },
         async get(runId) {
@@ -51,7 +51,7 @@ export function createExecutionApplications(root, now) {
             if (stored?.value.view == null)
                 return undefined;
             return {
-                data: await withWorkflowContext(root, presentRun(stored.value.view)),
+                data: await enrichRun(root, presentRun(stored.value.view)),
                 meta: await projectionMeta(root.journal, [stored], now()),
             };
         },

package/dist/src/bootstrap/surface-api-run-context.js

@@ -1,5 +1,49 @@
+import { ActivityOutcomeKind } from '../activities/index.js';
+import { DeliveryState, IntegrationStreamKind, } from '../integrations/index.js';
 import { workflowInstanceId } from '../orchestration/index.js';
 export async function withWorkflowContext(root, run) {
     const instance = await root.orchestration.get(workflowInstanceId(run.workflowInstanceId));
     return instance === null ? run : { ...run, workflowName: instance.workflowName };
 }
+const deliveryResolutionSentinels = {
+    [DeliveryState.Confirmed]: 'DONE',
+    [DeliveryState.Failed]: 'FAILED',
+    [DeliveryState.Ambiguous]: 'AMBIGUOUS',
+};
+/**
+ * A run whose own outcome was `waiting` on a delivery is frozen at that
+ * sentinel forever (the run itself never re-fires once terminal). Join it
+ * against the delivery intent it named to surface how that delivery has
+ * since resolved, without rewriting the run's own history.
+ */
+export async function withDeliveryResolution(root, run) {
+    const intentEventId = waitingDeliveryIntentEventId(run);
+    if (intentEventId === undefined)
+        return run;
+    const stored = await root.projections.read(IntegrationStreamKind.Delivery, intentEventId);
+    const delivery = stored?.value;
+    if (delivery === undefined || delivery.resolvedAt === undefined)
+        return run;
+    const sentinel = deliveryResolutionSentinels[delivery.state];
+    return sentinel === undefined
+        ? run
+        : { ...run, resolution: { sentinel, resolvedAt: delivery.resolvedAt } };
+}
+/** Full read-time enrichment applied to every presented run. */
+export async function enrichRun(root, run) {
+    return withDeliveryResolution(root, await withWorkflowContext(root, run));
+}
+function waitingDeliveryIntentEventId(run) {
+    if (typeof run.outcome !== 'object' || run.outcome === null)
+        return undefined;
+    if (Reflect.get(run.outcome, 'kind') !== ActivityOutcomeKind.Waiting)
+        return undefined;
+    const data = Reflect.get(run.outcome, 'data');
+    if (typeof data !== 'object' || data === null)
+        return undefined;
+    const intentEventId = Reflect.get(data, 'intentEventId');
+    const signalKind = Reflect.get(data, 'signalKind');
+    return typeof intentEventId === 'string' && signalKind === 'delivery-result'
+        ? intentEventId
+        : undefined;
+}

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

@@ -8,7 +8,7 @@ import { workItemId, WorkStatus } from '../work/index.js';
 import { primaryExternalRef } from './external-ref.js';
 import { projectionMeta } from './surface-api-metadata.js';
 import { projectionPage } from './surface-api-projection-pages.js';
-import { withWorkflowContext } from './surface-api-run-context.js';
+import { enrichRun } from './surface-api-run-context.js';
 import { readWorkTranscript, transcriptGroups } from './surface-api-transcripts.js';
 export function createSurfaceWorkApplications(root, now) {
     return {
@@ -115,7 +115,7 @@ async function workDetail(root, key, now) {
                 .map(presentWorkflowInstance),
         },
         execution: {
-            runs: await Promise.all(runs.map((run) => withWorkflowContext(root, presentRun(run)))),
+            runs: await Promise.all(runs.map((run) => enrichRun(root, presentRun(run)))),
             transcriptGroups: await transcriptGroups(root.transcriptStore, id, runs),
         },
         activities: presentPullRequest(pullRequest?.value),

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 = "gd101844";
+export const wakeVersion = "g8656e9f";

package/dist/src/integrations/delivery/application/delivery-projector.js

@@ -161,20 +161,26 @@ function foldDeliveryFact(previous, delivery) {
         case DeliveryEventType.AttemptStarted:
             return { ...current, attempts: current.attempts + 1 };
         case DeliveryEventType.Confirmed:
-            return { ...current, state: DeliveryState.Confirmed };
+            return { ...current, state: DeliveryState.Confirmed, resolvedAt: delivery.occurredAt };
         case DeliveryEventType.Failed:
-            return { ...current, state: DeliveryState.Failed };
+            return { ...current, state: DeliveryState.Failed, resolvedAt: delivery.occurredAt };
         case DeliveryEventType.Ambiguous:
             return {
                 ...current,
                 state: DeliveryState.Ambiguous,
+                resolvedAt: delivery.occurredAt,
                 reconciliationKey: delivery.payload.reconciliationKey,
             };
         case DeliveryEventType.Escalated:
             return { ...current, escalation: { reason: delivery.payload.reason } };
         case DeliveryEventType.Reconciled:
             if (delivery.payload.result === DeliveryResultKind.Confirmed)
-                return { ...current, state: DeliveryState.Confirmed, escalation: undefined };
+                return {
+                    ...current,
+                    state: DeliveryState.Confirmed,
+                    resolvedAt: delivery.occurredAt,
+                    escalation: undefined,
+                };
             return delivery.payload.result === DeliveryResultKind.Unknown
                 ? { ...current, reconciliationAttempts: (current.reconciliationAttempts ?? 0) + 1 }
                 : current;