@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/processes/sandbox-state.ts

@@ -9,6 +9,7 @@
  * orphaned environment.
  */
 import type { RepositoryEvent } from '../events/repository'
+import { defineReducer, type IncrementalReducer } from '../kernel/incremental'
 
 export type SandboxEnvironmentState = 'live' | 'stopped' | 'released'
 
@@ -22,6 +23,12 @@ export interface SandboxEnvironmentSnapshot {
    * `[orchestrator].sandbox.idleMinutes`. */
   lastEvidenceTs: string
   sessionId?: string
+  /** The base branch head the fresh provision selected; carried forward
+   * through later lifecycle facts (the base head cannot change without a
+   * fresh provision, which overwrites it) — the publication precondition's
+   * reference point, read by the publish operation. Absent on snapshots
+   * provisioned before this field existed. */
+  baseSha?: string
 }
 
 type MutableSnapshot = {
@@ -31,6 +38,7 @@ type MutableSnapshot = {
   state: SandboxEnvironmentState
   lastEvidenceTs: string
   sessionId?: string
+  baseSha?: string
 }
 
 /** Per-environment sandbox state, keyed deterministically by
@@ -38,7 +46,18 @@ type MutableSnapshot = {
  * derived from both). Latest fact wins; `released` environments stay in the
  * result with their closing evidence so callers can distinguish them. */
 export function sandboxStates(events: readonly RepositoryEvent[]): SandboxEnvironmentSnapshot[] {
-  const byEnvironment = new Map<string, MutableSnapshot>()
+  return sandboxStatesReducer.reduce(events)
+}
+
+/** The carried accumulator: environments in `Map` insertion order (a re-set
+ * of an existing id keeps its position). */
+export type SandboxStatesAcc = MutableSnapshot[]
+
+/** Bump when `SandboxStatesAcc`'s shape or fold semantics change. */
+export const SANDBOX_STATES_REDUCER_VERSION = 1
+
+function foldSandboxStates(acc: SandboxStatesAcc, events: readonly RepositoryEvent[]): void {
+  const byEnvironment = new Map<string, MutableSnapshot>(acc.map((s) => [s.environmentId, s]))
   for (const event of events) {
     const ts = event.ts
     if (event.type === 'orchestrator.sandbox.provisioned') {
@@ -49,6 +68,7 @@ export function sandboxStates(events: readonly RepositoryEvent[]): SandboxEnviro
         state: 'live',
         lastEvidenceTs: ts,
         ...(event.payload.sessionId !== undefined ? { sessionId: event.payload.sessionId } : {}),
+        ...(event.payload.baseSha !== undefined ? { baseSha: event.payload.baseSha } : {}),
       })
     } else if (event.type === 'orchestrator.sandbox.resumed') {
       const previous = byEnvironment.get(event.payload.environmentId)
@@ -63,6 +83,7 @@ export function sandboxStates(events: readonly RepositoryEvent[]): SandboxEnviro
           : previous?.sessionId !== undefined
             ? { sessionId: previous.sessionId }
             : {}),
+        ...(previous?.baseSha !== undefined ? { baseSha: previous.baseSha } : {}),
       })
     } else if (event.type === 'orchestrator.sandbox.activity') {
       const current = byEnvironment.get(event.payload.environmentId)
@@ -94,8 +115,21 @@ export function sandboxStates(events: readonly RepositoryEvent[]): SandboxEnviro
         state: 'released',
         lastEvidenceTs: ts,
         ...(existing?.sessionId !== undefined ? { sessionId: existing.sessionId } : {}),
+        ...(existing?.baseSha !== undefined ? { baseSha: existing.baseSha } : {}),
       })
     }
   }
-  return [...byEnvironment.values()]
+  acc.length = 0
+  acc.push(...byEnvironment.values())
 }
+
+export const sandboxStatesReducer: IncrementalReducer<
+  SandboxStatesAcc,
+  RepositoryEvent,
+  SandboxEnvironmentSnapshot[]
+> = defineReducer({
+  version: SANDBOX_STATES_REDUCER_VERSION,
+  initial: (): SandboxStatesAcc => [],
+  fold: foldSandboxStates,
+  finish: (acc) => acc.map((s) => ({ ...s })),
+})

package/packages/core/src/processes/tick-state.ts

@@ -0,0 +1,33 @@
+import type { RepositoryEvent } from '../events/repository'
+import { defineReducer } from '../kernel/incremental'
+
+export const OPEN_TICK_REDUCER_VERSION = 1
+
+/** Whether the dispatcher run's latest tick boundary (started, completed or
+ * failed) is a `dispatcher.tick-started`. A factory because the run id is a
+ * parameter of the projection; the accumulator holds only the last boundary
+ * type seen for that run. */
+export function openTickReducer(run: string) {
+  return defineReducer<{ boundary?: string }, RepositoryEvent, boolean>({
+    version: OPEN_TICK_REDUCER_VERSION,
+    initial: () => ({}),
+    fold(acc, events) {
+      for (const event of events) {
+        if (
+          'run' in event.payload &&
+          event.payload.run === run &&
+          (event.type === 'dispatcher.tick-started' ||
+            event.type === 'dispatcher.tick-completed' ||
+            event.type === 'dispatcher.tick-failed')
+        ) {
+          acc.boundary = event.type
+        }
+      }
+    },
+    finish: (acc) => acc.boundary === 'dispatcher.tick-started',
+  })
+}
+
+export function hasOpenTick(events: readonly RepositoryEvent[], run: string): boolean {
+  return openTickReducer(run).reduce(events)
+}

package/packages/core/src/store/adapter.ts

@@ -16,8 +16,39 @@ export type {
   SessionEventType,
   SessionEventWrite,
 } from '../events/sessions'
+export {
+  DEFAULT_TICKET_ASSET_LIMITS,
+  effectiveTicketAssetLimits,
+  loadTicketAsset,
+  resolvePinnedAsset,
+  storeTicketAssetBlobs,
+  summarizeTicketAsset,
+  TICKET_ASSET_MAX_BYTES,
+  TICKET_ASSET_MAX_ENTRIES,
+  TicketAssetValidationError,
+  validateTicketAssetInput,
+} from './ticket-assets'
+export type {
+  TicketAsset,
+  TicketAssetContentEntry,
+  TicketAssetEntry,
+  TicketAssetEntryInput,
+  TicketAssetInput,
+  TicketAssetLayout,
+  TicketAssetLimits,
+  TicketAssetMeta,
+  TicketAssetSummary,
+} from './ticket-assets'
+export { validateCreatedEvent } from './new-build'
 export { createBuildScopedStore } from './build-scope'
 export { createSessionScopedStore } from './session-handle'
+export { DIGEST_EVENT_TYPES, type DigestEventRow, reduceBuildDigest } from './digest'
+export {
+  projectRepositoryStateEvents,
+  REPOSITORY_RUN_SCOPED_EVENT_TYPES,
+  REPOSITORY_STATE_EVENT_TYPES,
+  readRepoStateEventsWithAnchorRecheck,
+} from './repo-state-events'
 export {
   DEFAULT_ARTIFACT_RETENTION_MAX_REVISIONS,
   DISPATCHER_RETENTION_BUILD_KINDS,
@@ -61,6 +92,7 @@ export type {
   ArtifactInput,
   ArtifactMeta,
   BlobStore,
+  BuildDigest,
   BuildRecord,
   BuildScopedStore,
   BuildStore,
@@ -78,3 +110,12 @@ export type {
   Unsubscribe,
 } from './types'
 export { normalizeOperator } from './types'
+export {
+  loadReducerSnapshot,
+  persistReducerSnapshot,
+  reducerSnapshotWireSchema,
+  SNAPSHOT_REDUCER_NAME,
+  snapshotScopeKey,
+  snapshotSupersedes,
+} from './snapshots'
+export type { ReducerSnapshot, SnapshotScope } from './snapshots'

package/packages/core/src/store/build-scope.ts

@@ -1,3 +1,4 @@
+import type { ReducerSnapshot, SnapshotScope } from './snapshots'
 import type { EventType } from '../events/payloads'
 import type { EventWrite } from '../events/catalog'
 import type { RepositoryEventType, RepositoryEventWrite } from '../events/repository'
@@ -13,6 +14,7 @@ import type {
   Artifact,
   ArtifactInput,
   ArtifactMeta,
+  BuildDigest,
   BuildRecord,
   BuildScopedStore,
   BuildStore,
@@ -25,6 +27,13 @@ import type {
   SubscribeOptions,
   Unsubscribe,
 } from './types'
+import type {
+  TicketAsset,
+  TicketAssetInput,
+  TicketAssetLimits,
+  TicketAssetMeta,
+  TicketAssetSummary,
+} from './ticket-assets'
 import type {
   StreamChunk,
   StreamOutcome,
@@ -179,6 +188,37 @@ export function createBuildScopedStore(store: BuildStore, scope: string): BuildS
     getRepoEvents(repo: string, _sinceSeq?: number): Promise<RepositoryEvent[]> {
       return Promise.reject(new BuildScopeError(scope, 'getRepoEvents', repo))
     },
+    getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
+      return Promise.reject(new BuildScopeError(scope, 'getRepoStateEvents', repo))
+    },
+    getRepoHighWater(repo: string): Promise<number> {
+      return Promise.reject(new BuildScopeError(scope, 'getRepoHighWater', repo))
+    },
+    async getReducerSnapshot(
+      target: SnapshotScope,
+      reducer: string,
+      version: number,
+    ): Promise<ReducerSnapshot | null> {
+      if (target.kind !== 'build') {
+        throw new BuildScopeError(scope, 'getReducerSnapshot', target.repo)
+      }
+      own('getReducerSnapshot', target.slug)
+      return store.getReducerSnapshot(target, reducer, version)
+    },
+    async putReducerSnapshot(
+      target: SnapshotScope,
+      reducer: string,
+      snapshot: ReducerSnapshot,
+    ): Promise<boolean> {
+      if (target.kind !== 'build') {
+        throw new BuildScopeError(scope, 'putReducerSnapshot', target.repo)
+      }
+      own('putReducerSnapshot', target.slug)
+      return store.putReducerSnapshot(target, reducer, snapshot)
+    },
+    getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
+      return Promise.reject(new BuildScopeError(scope, 'getRepoBuildDigests', repo))
+    },
     putRepoArtifact(repo: string, _artifact: ArtifactInput): Promise<RepositoryArtifactMeta> {
       return Promise.reject(new BuildScopeError(scope, 'putRepoArtifact', repo))
     },
@@ -192,6 +232,49 @@ export function createBuildScopedStore(store: BuildStore, scope: string): BuildS
     listRepoArtifacts(repo: string, _kind?: string): Promise<RepositoryArtifactMeta[]> {
       return Promise.reject(new BuildScopeError(scope, 'listRepoArtifacts', repo))
     },
+    ticketAssetLimits(repo: string): Promise<TicketAssetLimits> {
+      return Promise.reject(new BuildScopeError(scope, 'ticketAssetLimits', repo))
+    },
+    putTicketAsset(
+      repo: string,
+      _ticketId: string,
+      _asset: TicketAssetInput,
+    ): Promise<TicketAssetMeta> {
+      return Promise.reject(new BuildScopeError(scope, 'putTicketAsset', repo))
+    },
+    getTicketAsset(
+      repo: string,
+      _ticketId: string,
+      _kind: string,
+      _name: string,
+      _rev?: number,
+    ): Promise<TicketAsset | null> {
+      return Promise.reject(new BuildScopeError(scope, 'getTicketAsset', repo))
+    },
+    async getPinnedTicketAsset(
+      slug: string,
+      kind: string,
+      name: string,
+      rev?: number,
+    ): Promise<TicketAsset | null> {
+      own('getPinnedTicketAsset', slug)
+      return store.getPinnedTicketAsset(slug, kind, name, rev)
+    },
+    listTicketAssets(
+      repo: string,
+      _ticketId: string,
+      _opts?: { revisions?: boolean },
+    ): Promise<TicketAssetSummary[]> {
+      return Promise.reject(new BuildScopeError(scope, 'listTicketAssets', repo))
+    },
+    removeTicketAsset(
+      repo: string,
+      _ticketId: string,
+      _kind: string,
+      _name: string,
+    ): Promise<TicketAssetMeta | null> {
+      return Promise.reject(new BuildScopeError(scope, 'removeTicketAsset', repo))
+    },
     claimRepoLease(repo: string, _holder: string, _ttlMs: number): Promise<boolean> {
       return Promise.reject(new BuildScopeError(scope, 'claimRepoLease', repo))
     },
@@ -216,6 +299,13 @@ export function createBuildScopedStore(store: BuildStore, scope: string): BuildS
     ): Promise<SessionEventEnvelope<T>> {
       return Promise.reject(new BuildScopeError(scope, 'appendSessionEvent', id))
     },
+    appendSessionEventIfCurrent<T extends SessionEventType>(
+      id: string,
+      _expectedSeq: number,
+      _event: SessionEventWrite<T>,
+    ): Promise<SessionEventEnvelope<T> | null> {
+      return Promise.reject(new BuildScopeError(scope, 'appendSessionEventIfCurrent', id))
+    },
     getSessionEvents(id: string, _sinceSeq?: number): Promise<SessionEvent[]> {
       return Promise.reject(new BuildScopeError(scope, 'getSessionEvents', id))
     },