@defrex/autobuild 0.9.0 → 0.10.0

package/packages/core/src/kernel/pr-attachments.ts

@@ -1,42 +1,146 @@
 import type { AbEvent } from '../events/catalog'
 import type { PrImageHostTarget } from '../ontology'
+import { defineReducer, type IncrementalReducer } from './incremental'
 
 export type PrAttachmentDesignationEvent = Extract<AbEvent, { type: 'pr-attachment.designated' }>
 export type PrAttachmentHostedEvent = Extract<AbEvent, { type: 'pr-attachment.hosted' }>
 
+/** The host consent frozen into the build at claim time: the lowest-seq
+ * `build.created` seen so far (first in array order on a tie). */
+export interface FrozenPrImageHostAcc {
+  created?: { seq: number; imageHost?: PrImageHostTarget }
+}
+
+/** Bump when `FrozenPrImageHostAcc` or its fold changes. */
+export const FROZEN_PR_IMAGE_HOST_REDUCER_VERSION = 1
+
+export const frozenPrImageHostReducer: IncrementalReducer<
+  FrozenPrImageHostAcc,
+  AbEvent,
+  PrImageHostTarget | undefined
+> = defineReducer<FrozenPrImageHostAcc, AbEvent, PrImageHostTarget | undefined>({
+  version: FROZEN_PR_IMAGE_HOST_REDUCER_VERSION,
+  initial: () => ({}),
+  fold(acc, events) {
+    for (const event of events) {
+      if (
+        event.type === 'build.created' &&
+        (acc.created === undefined || event.seq < acc.created.seq)
+      ) {
+        const imageHost = event.payload.pr?.imageHost
+        acc.created = imageHost === undefined ? { seq: event.seq } : { seq: event.seq, imageHost }
+      }
+    }
+  },
+  finish: (acc) => acc.created?.imageHost,
+})
+
 /** The host consent frozen into the build at claim time. */
 export function frozenPrImageHost(events: readonly AbEvent[]): PrImageHostTarget | undefined {
-  let created: Extract<AbEvent, { type: 'build.created' }> | undefined
-  for (const event of events) {
-    if (event.type === 'build.created' && (created === undefined || event.seq < created.seq)) {
-      created = event
-    }
+  return frozenPrImageHostReducer.reduce(events)
+}
+
+/** Designation state shared by the current and hosted projections: the
+ * restart fence plus the highest-seq designation per artifact kind (first in
+ * array order on a tie). Keeping only the latest per kind is exact: if it is
+ * at or below the restart, every earlier one is too. */
+interface DesignationAcc {
+  restartSeq: number
+  byKind: Record<string, PrAttachmentDesignationEvent>
+}
+
+function initialDesignations(): DesignationAcc {
+  return { restartSeq: 0, byKind: {} }
+}
+
+function foldDesignations(acc: DesignationAcc, event: AbEvent): void {
+  if (event.type === 'spec.revised') {
+    acc.restartSeq = Math.max(acc.restartSeq, event.seq)
+  } else if (event.type === 'pr-attachment.designated') {
+    const kind = event.payload.artifact.kind
+    const previous = Object.hasOwn(acc.byKind, kind) ? acc.byKind[kind] : undefined
+    if (previous === undefined || event.seq > previous.seq) acc.byKind[kind] = event
   }
-  return created?.payload.pr?.imageHost
 }
 
+function finishDesignations(acc: DesignationAcc): PrAttachmentDesignationEvent[] {
+  return Object.values(acc.byKind)
+    .filter((event) => event.seq > acc.restartSeq)
+    .sort((left, right) => left.seq - right.seq)
+}
+
+export type CurrentPrAttachmentsAcc = DesignationAcc
+
+/** Bump when `CurrentPrAttachmentsAcc` or its fold changes. */
+export const CURRENT_PR_ATTACHMENTS_REDUCER_VERSION = 1
+
+export const currentPrAttachmentsReducer: IncrementalReducer<
+  CurrentPrAttachmentsAcc,
+  AbEvent,
+  PrAttachmentDesignationEvent[]
+> = defineReducer<CurrentPrAttachmentsAcc, AbEvent, PrAttachmentDesignationEvent[]>({
+  version: CURRENT_PR_ATTACHMENTS_REDUCER_VERSION,
+  initial: initialDesignations,
+  fold(acc, events) {
+    for (const event of events) foldDesignations(acc, event)
+  },
+  finish: finishDesignations,
+})
+
 /**
  * Current PR attachments are explicit designations after the latest spec
  * restart, with the newest exact revision replacing earlier designations of
  * the same artifact kind. Distinct kinds remain distinct attachments.
  */
 export function currentPrAttachments(events: readonly AbEvent[]): PrAttachmentDesignationEvent[] {
-  let restartSeq = 0
-  for (const event of events) {
-    if (event.type === 'spec.revised') restartSeq = Math.max(restartSeq, event.seq)
+  return currentPrAttachmentsReducer.reduce(events)
+}
+
+/** The designation state plus the highest-seq hosted copy per designation seq
+ * (first in array order on a tie). If the highest fails the `seq >
+ * designation.seq` check, every lower one does too. */
+export interface HostedPrAttachmentsAcc extends DesignationAcc {
+  hostedByDesignation: Record<string, PrAttachmentHostedEvent>
+}
+
+/** Bump when `HostedPrAttachmentsAcc` or its fold changes. */
+export const HOSTED_PR_ATTACHMENTS_REDUCER_VERSION = 1
+
+function finishHosted(
+  acc: HostedPrAttachmentsAcc,
+  designations: readonly PrAttachmentDesignationEvent[],
+): Map<number, PrAttachmentHostedEvent> {
+  const hosted = new Map<number, PrAttachmentHostedEvent>()
+  for (const designation of designations) {
+    const event = Object.hasOwn(acc.hostedByDesignation, designation.seq)
+      ? acc.hostedByDesignation[designation.seq]
+      : undefined
+    if (event !== undefined && event.seq > designation.seq) hosted.set(designation.seq, event)
   }
+  return hosted
+}
+
+export const hostedPrAttachmentsReducer: IncrementalReducer<
+  HostedPrAttachmentsAcc,
+  AbEvent,
+  Map<number, PrAttachmentHostedEvent>
+> = defineReducer<HostedPrAttachmentsAcc, AbEvent, Map<number, PrAttachmentHostedEvent>>({
+  version: HOSTED_PR_ATTACHMENTS_REDUCER_VERSION,
+  initial: () => ({ ...initialDesignations(), hostedByDesignation: {} }),
+  fold: foldHosted,
+  finish: (acc) => finishHosted(acc, finishDesignations(acc)),
+})
 
-  const byKind = new Map<string, PrAttachmentDesignationEvent>()
+function foldHosted(acc: HostedPrAttachmentsAcc, events: readonly AbEvent[]): void {
   for (const event of events) {
-    if (event.type !== 'pr-attachment.designated' || event.seq <= restartSeq) {
-      continue
-    }
-    const previous = byKind.get(event.payload.artifact.kind)
-    if (previous === undefined || event.seq > previous.seq) {
-      byKind.set(event.payload.artifact.kind, event)
-    }
+    foldDesignations(acc, event)
+    if (event.type !== 'pr-attachment.hosted') continue
+    const key = String(event.payload.designationSeq)
+    const previous = Object.hasOwn(acc.hostedByDesignation, key)
+      ? acc.hostedByDesignation[key]
+      : undefined
+    if (previous === undefined || event.seq > previous.seq) acc.hostedByDesignation[key] = event
   }
-  return [...byKind.values()].sort((left, right) => left.seq - right.seq)
 }
 
 /**
@@ -46,37 +150,51 @@ export function currentPrAttachments(events: readonly AbEvent[]): PrAttachmentDe
  */
 export function hostedPrAttachments(
   events: readonly AbEvent[],
-  designations = currentPrAttachments(events),
+  designations?: readonly PrAttachmentDesignationEvent[],
 ): Map<number, PrAttachmentHostedEvent> {
-  const designationBySeq = new Map(designations.map((event) => [event.seq, event]))
-  const hosted = new Map<number, PrAttachmentHostedEvent>()
-  for (const event of events) {
-    if (event.type !== 'pr-attachment.hosted') continue
-    const designation = designationBySeq.get(event.payload.designationSeq)
-    if (designation === undefined || event.seq <= designation.seq) continue
-    const previous = hosted.get(designation.seq)
-    if (previous === undefined || event.seq > previous.seq) {
-      hosted.set(designation.seq, event)
-    }
-  }
-  return hosted
+  const acc = hostedPrAttachmentsReducer.initial()
+  foldHosted(acc, events)
+  return finishHosted(acc, designations ?? finishDesignations(acc))
 }
 
+/** Every hosted copy plus the highest-seq reclaim fact per hosted seq. A
+ * reclaim may precede its hosted event in array order, so both are kept and
+ * correlated in `finish`. */
+export interface PendingPrAttachmentReclaimsAcc {
+  hosted: PrAttachmentHostedEvent[]
+  reclaimedAt: Record<string, number>
+}
+
+/** Bump when `PendingPrAttachmentReclaimsAcc` or its fold changes. */
+export const PENDING_PR_ATTACHMENT_RECLAIMS_REDUCER_VERSION = 1
+
+export const pendingPrAttachmentReclaimsReducer: IncrementalReducer<
+  PendingPrAttachmentReclaimsAcc,
+  AbEvent,
+  PrAttachmentHostedEvent[]
+> = defineReducer<PendingPrAttachmentReclaimsAcc, AbEvent, PrAttachmentHostedEvent[]>({
+  version: PENDING_PR_ATTACHMENT_RECLAIMS_REDUCER_VERSION,
+  initial: () => ({ hosted: [], reclaimedAt: {} }),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type === 'pr-attachment.hosted') acc.hosted.push(event)
+      else if (event.type === 'pr-attachment.reclaimed') {
+        const key = String(event.payload.hostedSeq)
+        const previous = Object.hasOwn(acc.reclaimedAt, key) ? acc.reclaimedAt[key] : undefined
+        if (previous === undefined || event.seq > previous) acc.reclaimedAt[key] = event.seq
+      }
+    }
+  },
+  finish(acc) {
+    const hosted = [...acc.hosted].sort((left, right) => left.seq - right.seq)
+    return hosted.filter((event) => {
+      const at = Object.hasOwn(acc.reclaimedAt, event.seq) ? acc.reclaimedAt[event.seq] : undefined
+      return !(at !== undefined && at > event.seq)
+    })
+  },
+})
+
 /** Every durable hosted copy that has not yet received a later reclaim fact. */
 export function pendingPrAttachmentReclaims(events: readonly AbEvent[]): PrAttachmentHostedEvent[] {
-  const hosted = events
-    .filter((event): event is PrAttachmentHostedEvent => event.type === 'pr-attachment.hosted')
-    .sort((left, right) => left.seq - right.seq)
-  const hostedSeqs = new Set(hosted.map((event) => event.seq))
-  const reclaimed = new Set<number>()
-  for (const event of events) {
-    if (
-      event.type === 'pr-attachment.reclaimed' &&
-      hostedSeqs.has(event.payload.hostedSeq) &&
-      event.seq > event.payload.hostedSeq
-    ) {
-      reclaimed.add(event.payload.hostedSeq)
-    }
-  }
-  return hosted.filter((event) => !reclaimed.has(event.seq))
+  return pendingPrAttachmentReclaimsReducer.reduce(events)
 }

package/packages/core/src/kernel/reducer-registry.ts

@@ -0,0 +1,164 @@
+/**
+ * Every incremental reducer, with its published version and the whole-array
+ * functions it backs. `reducer-registry.test.ts` snapshots the versions and
+ * the accumulator shapes, and scans `kernel/`, `store/` and `processes/` so a
+ * new event-array projection must be registered here or excluded with a reason.
+ */
+import { recordedBaseShaReducer } from '../config/pipeline-source'
+import { openWorkspaceReducer } from '../processes/build-execution-state'
+import {
+  phaseFailuresReducer,
+  publishedBranchHeadReducer,
+  setupStreakReducer,
+  verifyDiffBaseReducer,
+} from '../processes/build-runner'
+import {
+  baseBranchReducer,
+  openBuildWorkspaceReducer,
+  provisionMarkerReducer,
+  recoveryCheckpointReducer,
+} from '../processes/dispatcher-selectors'
+import {
+  lastExecutionOutcomeReducer,
+  openExecutionReducer,
+} from '../processes/execution-settlement'
+import { openHarvestExecutionsReducer } from '../processes/harvest-execution-state'
+import { infrastructureFailureResetReducer } from '../processes/infrastructure-failure-budget'
+import { publicationStateReducer } from '../processes/publication-state'
+import { sandboxStatesReducer } from '../processes/sandbox-state'
+import { openTickReducer } from '../processes/tick-state'
+import { dashboardFactsReducer } from '../cli/dashboard/facts'
+import { buildDigestReducer } from '../store/digest'
+import { journalViewReducer, repositoryStateEventsReducer } from '../store/repo-state-events'
+import { sessionReducer } from '../store/session-reducer'
+import { pinnedAssetsReducer } from '../store/ticket-assets'
+import { autoMergeDefaultReducer } from './auto-merge-default'
+import { currentDeferralObservationReducer } from './auto-merge'
+import { dispatchSettingsReducer } from './dispatch-settings'
+import { dispatchStatusReducer } from './dispatch-status'
+import { harvestReducer } from './harvest'
+import type { IncrementalReducer } from './incremental'
+import { logIndexReducer } from './log-index'
+import {
+  currentPrAttachmentsReducer,
+  frozenPrImageHostReducer,
+  hostedPrAttachmentsReducer,
+  pendingPrAttachmentReclaimsReducer,
+} from './pr-attachments'
+import { buildReducer } from './reducer'
+
+export interface RegisteredReducer {
+  // biome-ignore lint/suspicious/noExplicitAny: the registry is heterogeneous
+  reducer: IncrementalReducer<any, any, any>
+  /** The whole-array functions (or private methods) this reducer backs. */
+  covers: readonly string[]
+}
+
+/** Parameterized reducers are registered with representative arguments; the
+ * accumulator shape does not depend on them. */
+export const REDUCERS: Record<string, RegisteredReducer> = {
+  build: { reducer: buildReducer, covers: ['reduceBuild'] },
+  harvest: { reducer: harvestReducer, covers: ['reduceHarvest'] },
+  dispatchSettings: { reducer: dispatchSettingsReducer, covers: ['reduceDispatchSettings'] },
+  dispatchStatus: { reducer: dispatchStatusReducer('run-a'), covers: ['reduceDispatchStatus'] },
+  session: { reducer: sessionReducer, covers: ['reduceSession'] },
+  buildDigest: { reducer: buildDigestReducer, covers: ['reduceBuildDigest'] },
+  sandboxStates: { reducer: sandboxStatesReducer, covers: ['sandboxStates'] },
+  logIndex: { reducer: logIndexReducer, covers: ['indexLog'] },
+  frozenPrImageHost: { reducer: frozenPrImageHostReducer, covers: ['frozenPrImageHost'] },
+  currentPrAttachments: { reducer: currentPrAttachmentsReducer, covers: ['currentPrAttachments'] },
+  hostedPrAttachments: { reducer: hostedPrAttachmentsReducer, covers: ['hostedPrAttachments'] },
+  pendingPrAttachmentReclaims: {
+    reducer: pendingPrAttachmentReclaimsReducer,
+    covers: ['pendingPrAttachmentReclaims'],
+  },
+  publicationState: {
+    reducer: publicationStateReducer,
+    covers: [
+      'publicationRequestCompleted',
+      'publicationRequestSettled',
+      'latestUncompletedPublicationRequest',
+      'publicationLostRecorded',
+      'abandonedPublicationPending',
+      'publicationPending',
+    ],
+  },
+  repositoryStateEvents: {
+    reducer: repositoryStateEventsReducer,
+    covers: ['projectRepositoryStateEvents'],
+  },
+  journalView: { reducer: journalViewReducer, covers: [] },
+  openExecution: { reducer: openExecutionReducer, covers: ['openExecution'] },
+  lastExecutionOutcome: { reducer: lastExecutionOutcomeReducer, covers: ['lastExecutionOutcome'] },
+  openHarvestExecutions: {
+    reducer: openHarvestExecutionsReducer,
+    covers: ['openHarvestExecutions'],
+  },
+  openTick: { reducer: openTickReducer('run-a'), covers: ['hasOpenTick'] },
+  infrastructureFailureReset: {
+    reducer: infrastructureFailureResetReducer,
+    covers: ['infrastructureFailureResetSeq'],
+  },
+  openWorkspace: { reducer: openWorkspaceReducer, covers: ['selectOpenWorkspace'] },
+  publishedBranchHead: {
+    reducer: publishedBranchHeadReducer,
+    covers: ['selectPublishedBranchHead'],
+  },
+  verifyDiffBase: { reducer: verifyDiffBaseReducer, covers: ['selectVerifyDiffBase'] },
+  recordedBaseSha: { reducer: recordedBaseShaReducer, covers: [] },
+  setupStreak: { reducer: setupStreakReducer, covers: ['setupStreak'] },
+  phaseFailures: { reducer: phaseFailuresReducer('plan', 1), covers: ['phaseFailures'] },
+  openBuildWorkspace: {
+    reducer: openBuildWorkspaceReducer,
+    covers: ['openBuildWorkspace', 'openWorkspace', 'forgeWorkspacePath'],
+  },
+  baseBranch: { reducer: baseBranchReducer, covers: ['baseBranchOf'] },
+  provisionMarker: { reducer: provisionMarkerReducer, covers: ['openProvisionMarker'] },
+  recoveryCheckpoint: { reducer: recoveryCheckpointReducer, covers: ['recoveryCheckpoint'] },
+  currentDeferralObservation: {
+    reducer: currentDeferralObservationReducer,
+    covers: [
+      'currentDeferralObservation',
+      'hasAutoMergeDeferralObservation',
+      'currentAutoMergeDeferral',
+    ],
+  },
+  dashboardFacts: {
+    reducer: dashboardFactsReducer,
+    covers: ['phaseIntervals', 'projectSessions'],
+  },
+  autoMergeDefault: { reducer: autoMergeDefaultReducer, covers: ['latestAutoMergeDefault'] },
+  pinnedAssets: { reducer: pinnedAssetsReducer, covers: ['findPinnedRevision'] },
+}
+
+/** Event-array functions that are deliberately not reducers, each with the
+ * concrete reason. */
+export const EXCLUDED: Record<string, string> = {
+  decideNext: 'a decision function over config; returns a Decision, not a state',
+  harvestCreationsDuringReadyScan:
+    'a derived query over two reduceHarvest states (before/after), which is already incremental',
+  classifyHarvestOutcome: 'a decision over reduceHarvest state plus an input; returns a result',
+  collectUnclaimedObservations:
+    'composes reduceBuild/reduceHarvest over a store-shaped per-build map',
+  unclaimedObservationCount: 'composes digests and reduceHarvest over store-shaped input',
+  evaluateHarvestPressureFromDigests: 'a decision over digests and reduceHarvest state',
+  evaluateHarvestPressureFromStore: 'async; reads the store',
+  settleExecution: 'async; writes the store',
+  settlePublicationBeforeRelease: 'async; writes the store',
+  recordInfrastructureFailure: 'async; writes the store',
+  ensureProvisionContinuation: 'async; reads and writes the store and provider',
+  cleanupAborted: 'async; reads and writes the store and provider',
+  cleanupDiscarded: 'async; reads and writes the store and provider',
+  checkPr: 'async; forge and store',
+  reapStaleWorkspace: 'async; provider and store',
+  reclaimPrAttachments: 'async; forge and store',
+  releaseWorkspace: 'async; provider and store',
+  checkReconcileProgress: 'async; git and store',
+  evaluateVerify: 'async; runs verify steps',
+  reclaimSessionsAndAttach: 'async; store',
+  refreshReconcileBase: 'async; git and store',
+  repairEscalateGap: 'async; store',
+  runAgentVerify: 'async; runs an agent',
+  runFinalizeStep: 'async; runs a step',
+  runPhase: 'async; runs an agent phase',
+}