@defrex/autobuild 0.9.0 → 0.10.1

package/packages/core/src/kernel/auto-merge-default.ts

@@ -26,6 +26,7 @@
  * precedent `bulk-control.ts` set for the pause/resume walk.
  */
 import type { RepositoryEvent } from '../events/repository'
+import { defineReducer } from './incremental'
 import { discardInFlight, type BuildState } from './reducer'
 
 /** One `dispatcher.auto-merge-default-set` fact, resolved. `actor` is the
@@ -49,16 +50,49 @@ export function latestAutoMergeDefault(
   events: RepositoryEvent[],
   enabled?: boolean,
 ): AutoMergeDefaultFact | undefined {
-  for (let index = events.length - 1; index >= 0; index -= 1) {
-    const event = events[index]
-    if (
-      event?.type === 'dispatcher.auto-merge-default-set' &&
-      (enabled === undefined || event.payload.enabled === enabled)
-    ) {
-      return { enabled: event.payload.enabled, seq: event.seq, actor: event.actor }
+  return pickAutoMergeDefault(autoMergeDefaultReducer.reduce(events), enabled)
+}
+
+export const AUTO_MERGE_DEFAULT_REDUCER_VERSION = 1
+
+/** The newest `dispatcher.auto-merge-default-set` fact in array order, overall
+ * and per value — `latestAutoMergeDefault(events, enabled)` is a lookup in
+ * this state, exact for any array order. */
+export interface AutoMergeDefaultFacts {
+  latest?: AutoMergeDefaultFact
+  latestEnabled?: AutoMergeDefaultFact
+  latestDisabled?: AutoMergeDefaultFact
+}
+
+export const autoMergeDefaultReducer = defineReducer<
+  AutoMergeDefaultFacts,
+  RepositoryEvent,
+  AutoMergeDefaultFacts
+>({
+  version: AUTO_MERGE_DEFAULT_REDUCER_VERSION,
+  initial: () => ({}),
+  fold(acc, events) {
+    for (const event of events) {
+      if (event.type !== 'dispatcher.auto-merge-default-set') continue
+      const fact: AutoMergeDefaultFact = {
+        enabled: event.payload.enabled,
+        seq: event.seq,
+        actor: event.actor,
+      }
+      acc.latest = fact
+      if (fact.enabled) acc.latestEnabled = fact
+      else acc.latestDisabled = fact
     }
-  }
-  return undefined
+  },
+  finish: (acc) => ({ ...acc }),
+})
+
+export function pickAutoMergeDefault(
+  facts: AutoMergeDefaultFacts,
+  enabled?: boolean,
+): AutoMergeDefaultFact | undefined {
+  if (enabled === undefined) return facts.latest
+  return enabled ? facts.latestEnabled : facts.latestDisabled
 }
 
 /**

package/packages/core/src/kernel/auto-merge.ts

@@ -2,6 +2,7 @@ import type { AbEvent, EventEnvelope, EventWrite } from '../events/catalog'
 import { KERNEL } from '../events/envelope'
 import { autoMergeDeferralClasses, type AutoMergeDeferralReason } from '../ports/types'
 import type { BuildStore } from '../store/types'
+import { defineReducer } from './incremental'
 import type { BuildState } from './reducer'
 
 /** The complete GitHub `mergeStateStatus` enum. Keeping this list closed is a
@@ -133,36 +134,104 @@ export function currentDeferralObservation(
   events: AbEvent[],
   prNumber: number,
   commandSeq: number,
-): Extract<AbEvent, { type: 'observation.recorded' }> | undefined {
+): DeferralObservation | undefined {
+  return deferralObservationFrom(
+    currentDeferralObservationReducer.reduce(events),
+    prNumber,
+    commandSeq,
+  )
+}
+
+type DeferralObservation = Extract<AbEvent, { type: 'observation.recorded' }>
+
+const DEFERRAL_REF_PREFIX = 'auto-merge-gate:pr:'
+
+/** One array-order ledger entry. Only the facts the currency predicate reads
+ * are kept, with every maximal run of other events collapsed to a barrier
+ * carrying the run's max seq: the head scan stops at the first event (of ANY
+ * type) with `seq >= observation.seq`, so an unrelated event must still be able
+ * to end it. */
+type DeferralLedgerEntry =
+  | { t: 'barrier'; seq: number }
+  | { t: 'observation'; event: DeferralObservation }
+  | { t: 'finalized'; seq: number; headSha: string }
+  | { t: 'terminal'; seq: number }
+  | { t: 'reconciled'; seq: number }
+
+export const CURRENT_DEFERRAL_OBSERVATION_REDUCER_VERSION = 1
+
+export interface DeferralLedger {
+  entries: DeferralLedgerEntry[]
+}
+
+export const currentDeferralObservationReducer = defineReducer<
+  DeferralLedger,
+  AbEvent,
+  DeferralLedger
+>({
+  version: CURRENT_DEFERRAL_OBSERVATION_REDUCER_VERSION,
+  initial: () => ({ entries: [] }),
+  fold(acc, events) {
+    for (const event of events) {
+      let entry: DeferralLedgerEntry | undefined
+      if (
+        event.type === 'observation.recorded' &&
+        event.payload.refs?.some((ref) => ref.startsWith(DEFERRAL_REF_PREFIX)) === true
+      ) {
+        entry = { t: 'observation', event }
+      } else if (event.type === 'finalize.completed') {
+        entry = { t: 'finalized', seq: event.seq, headSha: event.payload.pr.headSha }
+      } else if (event.type === 'pr.merged' || event.type === 'pr.closed') {
+        entry = { t: 'terminal', seq: event.seq }
+      } else if (event.type === 'reconcile.completed') {
+        entry = { t: 'reconciled', seq: event.seq }
+      }
+      if (entry !== undefined) {
+        acc.entries.push(entry)
+        continue
+      }
+      const last = acc.entries.at(-1)
+      if (last?.t === 'barrier') last.seq = Math.max(last.seq, event.seq)
+      else acc.entries.push({ t: 'barrier', seq: event.seq })
+    }
+  },
+  finish: (acc) => ({ entries: acc.entries.slice() }),
+})
+
+function deferralEntrySeq(entry: DeferralLedgerEntry): number {
+  return entry.t === 'observation' ? entry.event.seq : entry.seq
+}
+
+/** The current deferral observation for a PR/command over a reduced ledger. */
+export function deferralObservationFrom(
+  ledger: DeferralLedger,
+  prNumber: number,
+  commandSeq: number,
+): DeferralObservation | undefined {
   const marker = autoMergeDeferralRef(prNumber, commandSeq)
-  let observation: Extract<AbEvent, { type: 'observation.recorded' }> | undefined
-  for (let index = events.length - 1; index >= 0; index -= 1) {
-    const event = events[index]
-    if (
-      event !== undefined &&
-      event.type === 'observation.recorded' &&
-      event.payload.refs?.includes(marker) === true
-    ) {
-      observation = event
+  const { entries } = ledger
+  let observation: DeferralObservation | undefined
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index]
+    if (entry?.t === 'observation' && entry.event.payload.refs?.includes(marker) === true) {
+      observation = entry.event
       break
     }
   }
   if (observation === undefined) return undefined
 
   let headAtObservation: string | undefined
-  for (const event of events) {
-    if (event.seq >= observation.seq) break
-    if (event.type === 'finalize.completed') headAtObservation = event.payload.pr.headSha
+  for (const entry of entries) {
+    if (deferralEntrySeq(entry) >= observation.seq) break
+    if (entry.t === 'finalized') headAtObservation = entry.headSha
   }
 
-  for (const event of events) {
-    if (event.seq <= observation.seq) continue
-    if (event.type === 'pr.merged' || event.type === 'pr.closed') return undefined
-    if (event.type === 'reconcile.completed') return undefined
-    if (event.type === 'finalize.completed') {
-      if (headAtObservation === undefined) headAtObservation = event.payload.pr.headSha
-      else if (event.payload.pr.headSha !== headAtObservation) return undefined
-    }
+  for (const entry of entries) {
+    if (entry.t === 'observation' || entry.t === 'barrier') continue
+    if (entry.seq <= observation.seq) continue
+    if (entry.t === 'terminal' || entry.t === 'reconciled') return undefined
+    if (headAtObservation === undefined) headAtObservation = entry.headSha
+    else if (entry.headSha !== headAtObservation) return undefined
   }
   return observation
 }
@@ -186,10 +255,18 @@ export function hasAutoMergeDeferralObservation(
 export function currentAutoMergeDeferral(
   events: AbEvent[],
   state: Pick<BuildState, 'autoMerge' | 'pr'>,
+): string | undefined {
+  return currentAutoMergeDeferralFrom(currentDeferralObservationReducer.reduce(events), state)
+}
+
+/** `currentAutoMergeDeferral` over an already-reduced ledger. */
+export function currentAutoMergeDeferralFrom(
+  ledger: DeferralLedger,
+  state: Pick<BuildState, 'autoMerge' | 'pr'>,
 ): string | undefined {
   const pending = pendingAutoMerge(state)
   if (pending?.enabled !== true || state.pr === undefined) return undefined
-  return currentDeferralObservation(events, state.pr.number, pending.commandSeq)?.payload.summary
+  return deferralObservationFrom(ledger, state.pr.number, pending.commandSeq)?.payload.summary
 }
 
 const DEFERRAL_SUMMARIES = {

package/packages/core/src/kernel/dispatch-settings.ts

@@ -4,6 +4,7 @@
  * is authoritative; fresh repositories retain the historical process defaults.
  */
 import type { RepositoryEvent } from '../events/repository'
+import { defineReducer, type IncrementalReducer } from './incremental'
 
 export const DEFAULT_DISPATCH_INTAKE = true
 export const DEFAULT_DISPATCH_PAUSED = false
@@ -21,32 +22,36 @@ export interface DispatchSettings {
   defaultAutoMerge: boolean
 }
 
-export function reduceDispatchSettings(events: RepositoryEvent[]): DispatchSettings {
-  let intake = DEFAULT_DISPATCH_INTAKE
-  let paused = DEFAULT_DISPATCH_PAUSED
-  let defaultAutoMerge = DEFAULT_DISPATCH_AUTO_MERGE
-  let intakeSeq = 0
-  let pausedSeq = 0
-  let autoMergeSeq = 0
+/** The carried accumulator: the settings plus the seq of the fact that set
+ * each, which decides last-writer-wins independent of array order. */
+export interface DispatchSettingsAcc extends DispatchSettings {
+  intakeSeq: number
+  pausedSeq: number
+  autoMergeSeq: number
+}
+
+/** Bump when `DispatchSettingsAcc`'s shape or fold semantics change. */
+export const DISPATCH_SETTINGS_REDUCER_VERSION = 1
 
+function foldDispatchSettings(acc: DispatchSettingsAcc, events: readonly RepositoryEvent[]): void {
   for (const event of events) {
     switch (event.type) {
       case 'dispatcher.intake-set':
-        if (event.seq > intakeSeq) {
-          intake = event.payload.enabled
-          intakeSeq = event.seq
+        if (event.seq > acc.intakeSeq) {
+          acc.intake = event.payload.enabled
+          acc.intakeSeq = event.seq
         }
         break
       case 'dispatcher.pause-set':
-        if (event.seq > pausedSeq) {
-          paused = event.payload.enabled
-          pausedSeq = event.seq
+        if (event.seq > acc.pausedSeq) {
+          acc.paused = event.payload.enabled
+          acc.pausedSeq = event.seq
         }
         break
       case 'dispatcher.auto-merge-default-set':
-        if (event.seq > autoMergeSeq) {
-          defaultAutoMerge = event.payload.enabled
-          autoMergeSeq = event.seq
+        if (event.seq > acc.autoMergeSeq) {
+          acc.defaultAutoMerge = event.payload.enabled
+          acc.autoMergeSeq = event.seq
         }
         break
       default:
@@ -55,6 +60,26 @@ export function reduceDispatchSettings(events: RepositoryEvent[]): DispatchSetti
         break
     }
   }
+}
+
+export const dispatchSettingsReducer: IncrementalReducer<
+  DispatchSettingsAcc,
+  RepositoryEvent,
+  DispatchSettings
+> = defineReducer({
+  version: DISPATCH_SETTINGS_REDUCER_VERSION,
+  initial: () => ({
+    intake: DEFAULT_DISPATCH_INTAKE,
+    paused: DEFAULT_DISPATCH_PAUSED,
+    defaultAutoMerge: DEFAULT_DISPATCH_AUTO_MERGE,
+    intakeSeq: 0,
+    pausedSeq: 0,
+    autoMergeSeq: 0,
+  }),
+  fold: foldDispatchSettings,
+  finish: ({ intake, paused, defaultAutoMerge }) => ({ intake, paused, defaultAutoMerge }),
+})
 
-  return { intake, paused, defaultAutoMerge }
+export function reduceDispatchSettings(events: RepositoryEvent[]): DispatchSettings {
+  return dispatchSettingsReducer.reduce(events)
 }

package/packages/core/src/kernel/dispatch-status.ts

@@ -1,5 +1,6 @@
 import type { RepositoryEvent } from '../events/repository'
 import type { ArtifactRef } from '../ontology'
+import type { IncrementalReducer } from './incremental'
 
 export type DispatchHealth = 'starting' | 'running' | 'stopped' | 'failed'
 
@@ -139,3 +140,25 @@ export function reduceDispatchStatus(
   }
   return state
 }
+
+/** Bump when `DispatchStatus`'s shape or fold semantics change (it is its own
+ * accumulator: `lastSeq` makes the fold skip already-seen events). */
+export const DISPATCH_STATUS_REDUCER_VERSION = 1
+
+/** The incremental form of `reduceDispatchStatus` for one run. The run is a
+ * parameter, so this is a factory. */
+export function dispatchStatusReducer(
+  run: string,
+): IncrementalReducer<DispatchStatus, RepositoryEvent, DispatchStatus> {
+  return {
+    version: DISPATCH_STATUS_REDUCER_VERSION,
+    initial: () => ({ run, health: 'starting', roleWarnings: [], diagnostics: [], lastSeq: 0 }),
+    advance: (acc, events) => reduceDispatchStatus(events, run, acc),
+    finish: (acc) => ({
+      ...acc,
+      roleWarnings: [...acc.roleWarnings],
+      diagnostics: [...acc.diagnostics],
+    }),
+    reduce: (events) => reduceDispatchStatus(events, run),
+  }
+}