@boxxy/model 0.1.1 → 0.1.3

package/src/index.ts

@@ -1,14 +1,57 @@
 export type { ContentHash, JsonValue } from '@boxxy/content-hash';
-export { brandSchemas } from './brand-schemas.ts';
-export { buildCloseOutSchema } from './build-close-out-schema.ts';
-export { defineAdmission } from './define-admission.ts';
-export { defineGate } from './define-gate.ts';
-export { defineSignal } from './define-signal.ts';
-export { deriveItemState } from './derive-item-state.ts';
-export { factSchemas } from './fact-schemas.ts';
-export { frictionSchema } from './friction-schema.ts';
-export { liveLevers } from './live-levers.ts';
-export { signalKey } from './signal-key.ts';
+export { brandSchemas } from './rows/brand-schemas.ts';
+export { buildAppliedChange, type ChangeAssignments } from './dispatch/build-applied-change.ts';
+export { advance } from './pipeline/advance.ts';
+export { attemptRowSchema } from './rows/attempt-row-schema.ts';
+export { attemptSessionRowSchema } from './rows/attempt-session-row-schema.ts';
+export { buildCloseOutSchema } from './closeouts/build-close-out-schema.ts';
+export { buildItemViews } from './items/build-item-views.ts';
+export { collectRetries } from './items/collect-retries.ts';
+export { collectSettled } from './items/collect-settled.ts';
+export { closeOutAnswerSchema } from './closeouts/close-out-answer-schema.ts';
+export { callerIdentitySchema } from './rows/caller-identity-schema.ts';
+export { closeOutSchema } from './closeouts/close-out-schema.ts';
+export { collectSeatSync, type SeatSync } from './dispatch/collect-seat-sync.ts';
+export { costToLandSchema } from './reports/cost-to-land-schema.ts';
+export { criterionSchema } from './rows/criterion-schema.ts';
+export { decisionRowSchema } from './rows/decision-row-schema.ts';
+export { defineAdmission } from './planning/define-admission.ts';
+export { defineGate } from './planning/define-gate.ts';
+export { definePhase } from './rules/define-phase.ts';
+export { defineSignal } from './planning/define-signal.ts';
+export { buildPhase, deriveItemState } from './items/derive-item-state.ts';
+export { designCloseOutSchema } from './closeouts/design-close-out-schema.ts';
+export { evidenceRowSchema } from './rows/evidence-row-schema.ts';
+export { findPosition } from './pipeline/find-position.ts';
+export { formatKeyPath } from './utils/format-key-path.ts';
+export { frictionSchema } from './closeouts/friction-schema.ts';
+export { isFilterMatch } from './planning/is-filter-match.ts';
+export { itemRowSchema } from './rows/item-row-schema.ts';
+export { itemViewSchema } from './rows/item-view-schema.ts';
+export { leverRowSchema } from './rows/lever-row-schema.ts';
+export { limitFillSchema } from './planning/limit-fill-schema.ts';
+export { limitSchema } from './rows/limit-schema.ts';
+export { limitSeatRowSchema } from './rows/limit-seat-row-schema.ts';
+export { loadRejectionSchema } from './rules/load-rejection-schema.ts';
+export { liveLevers } from './items/live-levers.ts';
+export { noteRowSchema } from './rows/note-row-schema.ts';
+export { noticeRowSchema } from './rows/notice-row-schema.ts';
+export { outboxFactSchema } from './facts/outbox-fact-schema.ts';
+export { positionSchema } from './pipeline/position-schema.ts';
+export { parseNewFact } from './facts/parse-new-fact.ts';
+export { pickSeatTake, type SeatTakeAnswer } from './dispatch/pick-seat-take.ts';
+export { pullRequestRowSchema } from './rows/pull-request-row-schema.ts';
+export { relationRowSchema } from './rows/relation-row-schema.ts';
+export { reviewCloseOutSchema } from './closeouts/review-close-out-schema.ts';
+export { rowSchemas } from './rows/row-schemas.ts';
+export { signalKey } from './planning/signal-key.ts';
+export { spawnRequestSchema } from './rows/spawn-request-schema.ts';
+export { stageTimeSchema } from './reports/stage-time-schema.ts';
+export { toJSONValue } from './utils/to-json-value.ts';
+export { triageCloseOutSchema } from './closeouts/triage-close-out-schema.ts';
+export { workFactSchemas } from './facts/work-fact-schemas.ts';
+export { costBases, phaseSteps, stageSteps } from './reports/constants.ts';
+export { engineHoldReasons, engineOutcomes } from './pipeline/constants.ts';
 
 export type {
   Actor,
@@ -19,6 +62,8 @@ export type {
   AttemptRow,
   AttemptSessionRow,
   AttemptState,
+  CallerIdentity,
+  ClosingCause,
   CommitSha,
   ConceptPin,
   Criterion,
@@ -26,81 +71,109 @@ export type {
   DecisionId,
   DecisionRow,
   DerivedState,
+  DesignMode,
   Effort,
+  EngineOutcome,
   EvidenceKind,
   EvidenceRow,
   EvidenceSource,
   FactId,
   FaultRecord,
+  FieldValues,
   ForcedFailure,
   Instant,
+  ItemFields,
   ItemId,
   ItemKindName,
   ItemRow,
-  ItemRows,
   ItemState,
   ItemView,
-  ItemWithLevers,
+  KeptSession,
   KnownFailure,
   LeaseRow,
   LeverKind,
   LeverRow,
-  LinkRow,
-  LinkTypeName,
+  LimitCount,
+  LimitName,
+  LimitSeatRow,
   LiveAttemptState,
-  LoadedRecipe,
-  MaxAttemptsByKind,
   Minutes,
+  NoteRow,
+  NoticeRow,
   ObservationBoundary,
+  OutcomeName,
   PhaseName,
   PipelineName,
   PoolName,
-  PoolSlotRow,
+  Product,
   PullRequestRef,
   PullRequestRow,
   Recipe,
   RecipeHash,
   RecipeMaterial,
   RecipeName,
+  RelationRow,
+  RelationTypeName,
   RepoName,
   ResolvedRecipe,
   RulesVersion,
   RunnerId,
   RunnerRow,
+  SessionMode,
   SnapshotHash,
   SourceName,
   StreamName,
   WaitingReason,
   WorkerKindName,
-} from './types/core.ts';
+} from './types.ts';
 
 export type {
-  Claim,
+  HoldReason,
+  Position,
+  RetryLever,
+  RulesHoldReason,
+  Settled,
+} from './pipeline/types.ts';
+
+export type {
+  AcceptanceInput,
+  BuildCloseOut,
+  BuildInput,
+  CloseOut,
+  CloseOutAnswer,
   CloseOutContext,
   CloseOutParse,
   CloseOutParser,
   CloseOutProblem,
-  ReconcileAction,
-  ReconcileTable,
-  SettleInput,
-  Settlement,
-  SettleRule,
-  SpawnContext,
-} from './types/dispatch.ts';
+  CloseOutWorld,
+  CriterionText,
+  DesignCloseOut,
+  DesignRef,
+  Effect,
+  Finding,
+  Friction,
+  FrictionTargetKind,
+  NoslopSummary,
+  OpenItem,
+  PullRequestLink,
+  RelationDraft,
+  ReviewCloseOut,
+  ReviewInput,
+  TriageCloseOut,
+} from './closeouts/types.ts';
+
+export type { Claim } from './dispatch/types.ts';
 
 export type {
-  BuildCloseOut,
+  AnyNewFact,
   EntityRef,
   FactEnvelope,
   FactType,
-  Friction,
-  FrictionTargetKind,
-  LinkPayload,
   NewFact,
-  OpenItem,
   OutboxFact,
-  SliceOneFacts,
-} from './types/facts.ts';
+  RelationPayload,
+  WorkFacts,
+} from './facts/types.ts';
 
 export type {
   Admission,
@@ -108,6 +181,7 @@ export type {
   AdmissionName,
   Decision,
   Fault,
+  Filter,
   Frame,
   FrameItem,
   FrameValues,
@@ -115,52 +189,78 @@ export type {
   GateName,
   Hold,
   Lift,
+  Limit,
+  LimitFill,
   Pick,
   PlanContext,
   Pool,
   PropagationLine,
+  SeatRef,
+  SeatRelease,
+  SeatTake,
   Signal,
   SignalKey,
   SignalName,
   Snapshot,
+  StartPick,
   View,
   ViewName,
+  Wait,
+  WaitReason,
   Waiver,
   WaiverName,
-} from './types/planning.ts';
+  Wake,
+  WakePick,
+} from './planning/types.ts';
 
 export type {
-  AnyNewFact,
   ApplyResult,
+  Attention,
+  CallerProof,
+  CapacityBackoff,
   ClaimStore,
   Clock,
-  CostReader,
-  CostToLandInput,
-  CostToLandRow,
   FactSink,
+  ForgetOutcome,
   Forge,
+  HoldNotice,
   ItemDetailRows,
   ItemFilter,
   NewId,
+  NoticeOutcome,
+  Notifier,
+  OutboxReader,
+  PepysAnswer,
+  PepysReader,
+  SinkAnswer,
   PullRequestReading,
   RowWrite,
   SessionFault,
   SessionReading,
   SpawnRequest,
   StartOutcome,
+  StopOutcome,
   StoreChange,
   StoreReader,
   StoreTx,
+  SuspendOutcome,
   TableName,
   Tables,
+  WakeSource,
   WorkerKind,
-} from './types/ports.ts';
+} from './ports/types.ts';
+
+export type { CostToLand, StageTime } from './reports/types.ts';
+export type { OutboxStatus } from './reports/outbox-status.ts';
+export type { ItemSetRows, ItemWithLevers } from './items/types.ts';
 
 export type {
   Concept,
   ConceptEntry,
   ConceptName,
+  Edge,
   FilterField,
+  ItemRules,
   KindRules,
   LoadedRules,
   LoadRejection,
@@ -168,6 +268,8 @@ export type {
   LoadResult,
   ParamKindName,
   ParamKinds,
+  PhaseInputContext,
+  PhaseKind,
   Pipeline,
   PipelineStep,
   PlainKinds,
@@ -175,8 +277,12 @@ export type {
   PluginRef,
   Registered,
   Registry,
+  RelationType,
   Resolved,
-  RulesFile,
   Schema,
+  SettleInput,
+  Settlement,
   SignalRef,
-} from './types/registries.ts';
+  SkillsPin,
+  SleepRules,
+} from './rules/types.ts';

package/src/items/build-item-views.ts

@@ -0,0 +1,146 @@
+import { findPosition } from '../pipeline/find-position.ts';
+import type { Position } from '../pipeline/types.ts';
+import type { ItemRules } from '../rules/types.ts';
+import type {
+  AttemptId,
+  AttemptRow,
+  DerivedState,
+  Instant,
+  ItemId,
+  ItemRow,
+  ItemState,
+  LeaseRow,
+  LeverRow,
+  PullRequestRow,
+  RelationRow,
+} from '../types.ts';
+import { collectRetries } from './collect-retries.ts';
+import { collectSettled } from './collect-settled.ts';
+import { deriveItemState } from './derive-item-state.ts';
+import { liveLevers } from './live-levers.ts';
+import type { ItemSetRows, ItemWithLevers } from './types.ts';
+
+export function buildItemViews(
+  rows: ItemSetRows,
+  now: Instant,
+  rules: ItemRules,
+): ItemWithLevers[] {
+  const groups = collectItemGroups(rows, rules);
+
+  // A blocking source counts only when it is done or archived, and no relation makes an item either,
+  // so each source's state derived without its relations settles its targets.
+  const ownStates = new Map<ItemId, ItemState>(
+    groups.map((group) => [
+      group.item.id,
+      deriveGroupState(group, rules, { relations: [], blockerStates: new Map() }).state,
+    ]),
+  );
+
+  return groups.map((group) =>
+    buildItemWithLevers(
+      group,
+      deriveGroupState(group, rules, { relations: group.relations, blockerStates: ownStates }),
+      now,
+    ),
+  );
+}
+
+interface ItemGroup {
+  readonly item: ItemRow;
+  readonly relations: RelationRow[];
+  readonly attempts: AttemptRow[];
+  readonly pullRequests: PullRequestRow[];
+  readonly levers: LeverRow[];
+  liveLease: LeaseRow | null;
+  position: Position;
+}
+
+// in the order of `rows.items`
+function collectItemGroups(rows: ItemSetRows, rules: ItemRules): ItemGroup[] {
+  const groups = new Map<ItemId, ItemGroup>(
+    rows.items.map((item) => [
+      item.id,
+      {
+        item,
+        relations: [],
+        attempts: [],
+        pullRequests: [],
+        levers: [],
+        liveLease: null,
+        position: { kind: 'end', reason: 'no-pipeline' },
+      },
+    ]),
+  );
+
+  const attemptItems = new Map<AttemptId, ItemId>();
+
+  for (const relation of rows.relations) {
+    groups.get(relation.target)?.relations.push(relation);
+  }
+
+  for (const attempt of rows.attempts) {
+    attemptItems.set(attempt.id, attempt.item);
+    groups.get(attempt.item)?.attempts.push(attempt);
+  }
+
+  for (const pullRequest of rows.pullRequests) {
+    const item = attemptItems.get(pullRequest.attempt);
+
+    if (item !== undefined) {
+      groups.get(item)?.pullRequests.push(pullRequest);
+    }
+  }
+
+  for (const lever of rows.levers) {
+    groups.get(lever.item)?.levers.push(lever);
+  }
+
+  for (const lease of rows.liveLeases) {
+    const group = groups.get(lease.item);
+
+    if (group !== undefined) {
+      group.liveLease = lease;
+    }
+  }
+
+  for (const group of groups.values()) {
+    group.position = findPosition({
+      pipeline: rules.kinds.get(group.item.kind)?.pipeline ?? null,
+      attempts: collectSettled(group.attempts),
+      retries: collectRetries(group.levers),
+    });
+  }
+
+  return [...groups.values()];
+}
+
+interface Blocking {
+  // the live relations whose target is the item
+  readonly relations: readonly RelationRow[];
+  readonly blockerStates: ReadonlyMap<ItemId, ItemState>;
+}
+
+function deriveGroupState(group: ItemGroup, rules: ItemRules, blocking: Blocking): DerivedState {
+  return deriveItemState({
+    ...blocking,
+    item: group.item,
+    position: group.position,
+    liveLease: group.liveLease,
+    phases: rules.phases,
+    attempts: group.attempts,
+    pullRequests: group.pullRequests,
+  });
+}
+
+function buildItemWithLevers(
+  group: ItemGroup,
+  derived: DerivedState,
+  now: Instant,
+): ItemWithLevers {
+  return {
+    ...group.item,
+    derived,
+    position: group.position,
+    levers: liveLevers(group.levers, now),
+  };
+}

package/src/items/collect-retries.ts

@@ -0,0 +1,12 @@
+import type { RetryLever } from '../pipeline/types.ts';
+import type { LeverRow } from '../types.ts';
+
+const retryKind = 'item.retry';
+
+// every `item.retry` lever the item ever had, so the position never depends on the read's time
+export function collectRetries(levers: readonly LeverRow[]): RetryLever[] {
+  return levers
+    .filter((lever) => lever.kind === retryKind)
+    .map((lever) => ({ at: lever.at, phase: lever.phase }))
+    .toSorted((first, second) => first.at - second.at);
+}

package/src/items/collect-settled.ts

@@ -0,0 +1,20 @@
+import type { Settled } from '../pipeline/types.ts';
+import type { AttemptRow } from '../types.ts';
+
+// the settled attempts, oldest end first
+export function collectSettled(attempts: readonly AttemptRow[]): Settled[] {
+  const settled = attempts.flatMap((attempt) =>
+    attempt.endedAt === null || attempt.outcome === null
+      ? []
+      : [
+          {
+            phase: attempt.phase,
+            outcome: attempt.outcome,
+            endedAt: attempt.endedAt,
+            failure: attempt.failure,
+          },
+        ],
+  );
+
+  return settled.toSorted((first, second) => first.endedAt - second.endedAt);
+}

package/src/items/derive-item-state.ts

@@ -0,0 +1,95 @@
+import type { Position } from '../pipeline/types.ts';
+import type {
+  AttemptRow,
+  DerivedState,
+  ItemId,
+  ItemRow,
+  ItemState,
+  LeaseRow,
+  PhaseName,
+  PullRequestRow,
+  RelationRow,
+} from '../types.ts';
+
+interface DeriveItemStateInput {
+  readonly item: ItemRow;
+  readonly position: Position;
+
+  // the item's live item-phase lease, a sleeping or closing attempt's included
+  readonly liveLease: LeaseRow | null;
+
+  // the phase kinds loaded now, by name
+  readonly phases: ReadonlyMap<PhaseName, { readonly needsAcceptance: boolean }>;
+  readonly attempts: readonly AttemptRow[];
+  readonly pullRequests: readonly PullRequestRow[];
+
+  // the live relations whose target is the item
+  readonly relations: readonly RelationRow[];
+  readonly blockerStates: ReadonlyMap<ItemId, ItemState>;
+}
+
+// The table of section G of the engine sketch; the first match wins.
+export function deriveItemState(input: DeriveItemStateInput): DerivedState {
+  const item = input.item;
+  const position = input.position;
+
+  if (item.closedAt !== null) {
+    return { state: 'archived' };
+  }
+
+  if (input.liveLease !== null) {
+    return { state: 'running' };
+  }
+
+  if (position.kind === 'hold') {
+    return { state: 'waiting', reason: position.reason };
+  }
+
+  if (position.kind === 'end') {
+    return deriveEndedState(collectBuildPullRequests(input.attempts, input.pullRequests));
+  }
+
+  if (item.acceptance.length === 0 && input.phases.get(position.phase)?.needsAcceptance === true) {
+    return { state: 'idea' };
+  }
+
+  return hasOpenBlocker(input) ? { state: 'blocked' } : { state: 'ready' };
+}
+
+function deriveEndedState(linked: readonly PullRequestRow[]): DerivedState {
+  if (linked.some((pullRequest) => pullRequest.state === 'merged')) {
+    return { state: 'done' };
+  }
+
+  if (linked.some((pullRequest) => pullRequest.state === 'open')) {
+    return { state: 'waiting', reason: 'pull request open' };
+  }
+
+  return linked.length === 0
+    ? { state: 'waiting', reason: 'no pull request linked' }
+    : { state: 'waiting', reason: 'pull request closed unmerged' };
+}
+
+export const buildPhase = 'build';
+
+// the pull requests linked to a succeeded build attempt
+function collectBuildPullRequests(
+  attempts: readonly AttemptRow[],
+  pullRequests: readonly PullRequestRow[],
+): PullRequestRow[] {
+  const succeededBuilds = new Set(
+    attempts
+      .filter((attempt) => attempt.phase === buildPhase && attempt.state === 'succeeded')
+      .map((attempt) => attempt.id),
+  );
+
+  return pullRequests.filter((pullRequest) => succeededBuilds.has(pullRequest.attempt));
+}
+
+function hasOpenBlocker(input: DeriveItemStateInput): boolean {
+  return input.relations.some((relation) => {
+    const blockerState = input.blockerStates.get(relation.source);
+
+    return relation.type === 'blocks' && blockerState !== 'done' && blockerState !== 'archived';
+  });
+}

package/src/{live-levers.ts → items/live-levers.ts}

@@ -1,4 +1,4 @@
-import type { Instant, LeverKind, LeverRow } from './types/core.ts';
+import type { Instant, LeverKind, LeverRow } from '../types.ts';
 
 export function liveLevers(levers: readonly LeverRow[], now: Instant): LeverRow[] {
   return levers.filter((lever) => !isExpired(lever, now) && !isUndone(lever, levers));

package/src/items/types.ts

@@ -0,0 +1,26 @@
+import type {
+  AttemptRow,
+  ItemRow,
+  ItemView,
+  LeaseRow,
+  LeverRow,
+  PullRequestRow,
+  RelationRow,
+} from '../types.ts';
+
+// the rows a store reads to derive a set of items, with each blocking source item
+export interface ItemSetRows {
+  readonly items: readonly ItemRow[];
+
+  // live relations only
+  readonly relations: readonly RelationRow[];
+  readonly levers: readonly LeverRow[];
+  readonly attempts: readonly AttemptRow[];
+  readonly liveLeases: readonly LeaseRow[];
+  readonly pullRequests: readonly PullRequestRow[];
+}
+
+export interface ItemWithLevers extends ItemView {
+  // the live levers only
+  readonly levers: readonly LeverRow[];
+}