@boxxy/model 0.1.2 → 0.1.4

package/dist/rows/limit-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { Limit } from '../planning/types.ts';
+export declare const limitSchema: z.ZodType<Limit>;

package/dist/rows/limit-seat-row-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { LimitSeatRow } from '../types.ts';
+export declare const limitSeatRowSchema: z.ZodType<LimitSeatRow>;

package/dist/rows/note-row-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { NoteRow } from '../types.ts';
+export declare const noteRowSchema: z.ZodType<NoteRow>;

package/dist/rows/notice-row-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { NoticeRow } from '../types.ts';
+export declare const noticeRowSchema: z.ZodType<NoticeRow>;

package/dist/rows/pull-request-row-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { PullRequestRow } from '../types.ts';
+export declare const pullRequestRowSchema: z.ZodType<PullRequestRow>;

package/dist/rows/relation-row-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { RelationRow } from '../types.ts';
+export declare const relationRowSchema: z.ZodType<RelationRow>;

package/dist/{row-schemas.d.ts → rows/row-schemas.d.ts}

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-import type { TableName, Tables } from './types/ports.ts';
+import type { z } from 'zod';
+import type { TableName, Tables } from '../ports/types.ts';
 export declare const rowSchemas: {
     readonly [T in TableName]: z.ZodType<Tables[T]>;
 };

package/dist/rows/runner-row-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { RunnerRow } from '../types.ts';
+export declare const runnerRowSchema: z.ZodType<RunnerRow>;

package/dist/rows/spawn-request-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { SpawnRequest } from '../ports/types.ts';
+export declare const spawnRequestSchema: z.ZodType<SpawnRequest>;

package/dist/rules/define-phase.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from '@boxxy/content-hash';
+import type { PhaseKind } from './types.ts';
+export declare function definePhase<Body, Input extends JsonValue, const Outcomes extends readonly string[]>(phase: PhaseKind<Body, Input, Outcomes>): PhaseKind;

package/dist/rules/load-rejection-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { LoadRejection } from './types.ts';
+export declare const loadRejectionSchema: z.ZodType<LoadRejection>;

package/dist/rules/types.d.ts

@@ -0,0 +1,244 @@
+import type { JsonValue } from '@boxxy/content-hash';
+import type { z } from 'zod';
+import type { CloseOutParser, Effect } from '../closeouts/types.ts';
+import type { RulesHoldReason } from '../pipeline/types.ts';
+import type { Admission, FrameItem, Gate, Limit, Pool, PropagationLine, Signal, SignalKey, SignalName, View, Waiver } from '../planning/types.ts';
+import type { AttemptRow, CommitSha, ConceptPin, EngineOutcome, Instant, ItemKindName, ItemView, LeverKind, Minutes, PhaseName, PipelineName, PullRequestRow, RecipeMaterial, RecipeName, RelationTypeName, RulesVersion, SessionMode, WorkerKindName } from '../types.ts';
+export type Schema<T> = z.ZodType<T>;
+export interface ParamKinds<P> {
+    signal: Signal<P>;
+    gate: Gate<P>;
+    admission: Admission<P>;
+}
+export type ParamKindName = keyof ParamKinds<unknown>;
+export interface Registered<K extends ParamKindName> {
+    readonly kind: K;
+    readonly name: string;
+    open: <R>(use: <P>(plugin: ParamKinds<P>[K]) => R) => R;
+}
+export interface Resolved<K extends ParamKindName> {
+    readonly kind: K;
+    readonly name: string;
+    readonly key: string;
+    open: <R>(use: <P>(plugin: ParamKinds<P>[K], params: P) => R) => R;
+}
+export type ConceptName = string;
+export interface Concept {
+    name: ConceptName;
+    version: number;
+    signals?: Registered<'signal'>[];
+    gates?: Registered<'gate'>[];
+    waivers?: Waiver[];
+    levers?: LeverKind[];
+    filterFields?: FilterField[];
+}
+export interface FilterField {
+    name: string;
+    value: (item: FrameItem) => string | readonly string[] | null;
+}
+export interface PlainKinds {
+    waiver: Waiver;
+    'filter-field': FilterField;
+    lever: {
+        readonly kind: LeverKind;
+    };
+    view: View;
+}
+export type PluginKindName = ParamKindName | keyof PlainKinds;
+export type Registry = {
+    readonly [K in ParamKindName]: ReadonlyMap<string, Registered<K>>;
+} & {
+    readonly [K in keyof PlainKinds]: ReadonlyMap<string, PlainKinds[K]>;
+} & {
+    readonly pins: readonly ConceptPin[];
+};
+export interface PhaseKind<Body = unknown, Input extends JsonValue = JsonValue, Outcomes extends readonly string[] = readonly string[]> {
+    readonly name: PhaseName;
+    readonly version: number;
+    readonly worker: WorkerKindName;
+    readonly outcomes: Outcomes;
+    readonly needsAcceptance: boolean;
+    readonly mode?: (item: ItemView) => SessionMode;
+    readonly input: (ctx: PhaseInputContext) => Input;
+    readonly closeOut: CloseOutParser<Body>;
+    readonly settle: BivariantSettle<Body, Outcomes[number]>['settle'];
+}
+interface BivariantSettle<Body, Outcome extends string> {
+    settle(input: SettleInput<Body>): Settlement<Outcome>;
+}
+export interface PhaseInputContext {
+    readonly item: ItemView;
+    readonly history: readonly AttemptRow[];
+    readonly pullRequests: readonly PullRequestRow[];
+}
+export interface SettleInput<Body> {
+    readonly attempt: AttemptRow;
+    readonly item: ItemView;
+    readonly closeOut: Body;
+    readonly now: Instant;
+}
+export interface Settlement<Outcome extends string = string> {
+    readonly state: 'succeeded' | 'failed';
+    readonly failure: string | null;
+    readonly outcome: Outcome;
+    readonly effects: readonly Effect[];
+    readonly frictionDropped: number;
+}
+export interface KindRules {
+    readonly pipeline: Pipeline;
+    readonly recipes: Readonly<Record<string, RecipeName>>;
+}
+export interface Pipeline {
+    readonly name: PipelineName;
+    readonly steps: readonly PipelineStep[];
+}
+export interface PipelineStep {
+    readonly phase: PhaseName;
+    readonly maxAttempts: number;
+    readonly timeoutMinutes: Minutes;
+    readonly on: Readonly<Record<string, Edge>>;
+}
+export type Edge = 'next' | 'again' | {
+    readonly to: PhaseName;
+    readonly max?: number;
+    readonly resume?: boolean;
+} | {
+    readonly end: string;
+} | {
+    readonly hold: RulesHoldReason;
+};
+export interface SkillsPin {
+    readonly source: string;
+    readonly ref: CommitSha;
+}
+export interface RelationType {
+    readonly name: RelationTypeName;
+}
+export interface SleepRules {
+    readonly afterIdleMinutes: Minutes;
+    readonly afterQuietMinutes: Minutes;
+    readonly afterUnattendedMinutes: Minutes;
+}
+export type ConceptEntry = `${string}@${number}`;
+export type PluginRef = string | Readonly<Record<string, JsonValue>>;
+export type SignalRef = SignalName | Readonly<Record<string, JsonValue>>;
+export interface ItemRules {
+    readonly kinds: ReadonlyMap<ItemKindName, {
+        readonly pipeline: Pipeline;
+    }>;
+    readonly phases: ReadonlyMap<PhaseName, {
+        readonly needsAcceptance: boolean;
+    }>;
+}
+export interface LoadedRules {
+    readonly version: RulesVersion;
+    readonly commit: string;
+    readonly registry: Registry;
+    readonly signals: ReadonlyMap<SignalKey, Resolved<'signal'>>;
+    readonly gates: readonly Resolved<'gate'>[];
+    readonly kinds: ReadonlyMap<ItemKindName, KindRules>;
+    readonly phases: ReadonlyMap<PhaseName, PhaseKind>;
+    readonly limits: readonly Limit[];
+    readonly pools: readonly Pool[];
+    readonly propagation: readonly PropagationLine[];
+    readonly recipes: ReadonlyMap<RecipeName, RecipeMaterial>;
+    readonly sleep: SleepRules;
+    readonly skills: SkillsPin | null;
+    readonly relationTypes: ReadonlyMap<RelationTypeName, RelationType>;
+}
+export interface LoadRejection {
+    readonly file: string;
+    readonly path: string;
+    readonly reason: LoadRejectionReason;
+}
+export type LoadRejectionReason = {
+    readonly kind: 'invalid';
+    readonly message: string;
+} | {
+    readonly kind: 'unknown-concept';
+    readonly ref: string;
+} | {
+    readonly kind: 'unknown-signal';
+    readonly signal: string;
+} | {
+    readonly kind: 'bad-plugin-params';
+    readonly pluginKind: ParamKindName;
+    readonly name: string;
+    readonly message: string;
+} | {
+    readonly kind: 'unknown-relation-type';
+    readonly relation: string;
+} | {
+    readonly kind: 'signal-without-combine';
+    readonly signal: string;
+} | {
+    readonly kind: 'missing-recipe';
+    readonly itemKind: string;
+    readonly phase: string;
+} | {
+    readonly kind: 'missing-prompt';
+    readonly path: string;
+} | {
+    readonly kind: 'uncommitted-changes';
+} | {
+    readonly kind: 'unknown-filter-field';
+    readonly field: string;
+} | {
+    readonly kind: 'pool-without-limit';
+    readonly pool: string;
+} | {
+    readonly kind: 'unknown-phase';
+    readonly phase: string;
+} | {
+    readonly kind: 'unmapped-outcome';
+    readonly phase: PhaseName;
+    readonly outcome: string;
+} | {
+    readonly kind: 'unknown-outcome';
+    readonly phase: PhaseName;
+    readonly outcome: string;
+} | {
+    readonly kind: 'open-loop';
+    readonly phase: PhaseName;
+    readonly outcome: string;
+} | {
+    readonly kind: 'edge-to-unknown-phase';
+    readonly phase: PhaseName;
+    readonly to: string;
+} | {
+    readonly kind: 'step-without-recipe';
+    readonly itemKind: ItemKindName;
+    readonly phase: PhaseName;
+} | {
+    readonly kind: 'step-without-timeout';
+    readonly phase: PhaseName;
+} | {
+    readonly kind: 'quiet-below-idle';
+} | {
+    readonly kind: 'unattended-below-quiet';
+} | {
+    readonly kind: 'engine-outcome-listed';
+    readonly phase: PhaseName;
+    readonly outcome: EngineOutcome;
+} | {
+    readonly kind: 'skills-without-pin';
+    readonly recipe: string;
+} | {
+    readonly kind: 'resume-on-forward-edge';
+    readonly phase: PhaseName;
+    readonly outcome: string;
+} | {
+    readonly kind: 'engine-hold-reason';
+    readonly phase: PhaseName;
+    readonly outcome: string;
+    readonly reason: string;
+};
+export type LoadResult = {
+    readonly kind: 'loaded';
+    readonly rules: LoadedRules;
+    readonly warnings: readonly string[];
+} | {
+    readonly kind: 'rejected';
+    readonly rejections: readonly LoadRejection[];
+};
+export {};

package/dist/test-utils/build-mock-cost-to-land.d.ts

@@ -0,0 +1,2 @@
+import type { CostToLand } from '../reports/types.ts';
+export declare function buildMockCostToLand(overrides?: Partial<CostToLand>): CostToLand;

package/dist/test-utils/build-mock-evidence-row.d.ts

@@ -1,2 +1,2 @@
-import type { EvidenceRow } from '../types/core.ts';
+import type { EvidenceRow } from '../types.ts';
 export declare function buildMockEvidenceRow(overrides?: Partial<EvidenceRow>): EvidenceRow;

package/dist/test-utils/build-mock-fact-id.d.ts

@@ -1,2 +1,2 @@
-import type { FactId } from '../types/core.ts';
+import type { FactId } from '../types.ts';
 export declare function buildMockFactId(): FactId;

package/dist/test-utils/build-mock-frame-item.d.ts

@@ -1,2 +1,2 @@
-import type { FrameItem } from '../types/planning.ts';
+import type { FrameItem } from '../planning/types.ts';
 export declare function buildMockFrameItem(overrides?: Partial<FrameItem>): FrameItem;

package/dist/test-utils/build-mock-frame.d.ts

@@ -0,0 +1,2 @@
+import type { Frame } from '../planning/types.ts';
+export declare function buildMockFrame(overrides?: Partial<Frame>): Frame;

package/dist/test-utils/build-mock-item-rules.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRules } from '../rules/types.ts';
+export declare function buildMockItemRules(overrides?: Partial<ItemRules>): ItemRules;

package/dist/test-utils/build-mock-lease-row.d.ts

@@ -1,2 +1,2 @@
-import type { LeaseRow } from '../types/core.ts';
+import type { LeaseRow } from '../types.ts';
 export declare function buildMockLeaseRow(overrides?: Partial<LeaseRow>): LeaseRow;

package/dist/test-utils/build-mock-outbox-fact.d.ts

@@ -0,0 +1,2 @@
+import type { OutboxFact } from '../facts/types.ts';
+export declare function buildMockOutboxFact(overrides?: Partial<OutboxFact>): OutboxFact;

package/dist/test-utils/build-mock-phase-kind.d.ts

@@ -0,0 +1,7 @@
+import type { PhaseKind } from '../rules/types.ts';
+interface MockPhaseKindInput {
+    readonly name: string;
+    readonly outcomes: readonly string[];
+}
+export declare function buildMockPhaseKind(input: MockPhaseKindInput): PhaseKind;
+export {};

package/dist/test-utils/build-mock-pipeline.d.ts

@@ -0,0 +1,7 @@
+import type { Pipeline, PipelineStep } from '../rules/types.ts';
+interface MockPipelineInput {
+    readonly phases?: readonly string[];
+    readonly steps?: Readonly<Record<string, Partial<PipelineStep>>>;
+}
+export declare function buildMockPipeline(input?: MockPipelineInput): Pipeline;
+export {};

package/dist/test-utils/build-mock-relation-row.d.ts

@@ -0,0 +1,2 @@
+import type { RelationRow } from '../types.ts';
+export declare function buildMockRelationRow(overrides?: Partial<RelationRow>): RelationRow;

package/dist/test-utils/build-mock-settled.d.ts

@@ -0,0 +1,9 @@
+import type { Settled } from '../pipeline/types.ts';
+interface MockSettledInput {
+    readonly phase: string;
+    readonly outcome: string;
+    readonly endedAt: number;
+    readonly failure?: string | null;
+}
+export declare function buildMockSettled(input: MockSettledInput): Settled;
+export {};

package/dist/test-utils/build-mock-snapshot.d.ts

@@ -1,2 +1,2 @@
-import type { Snapshot } from '../types/planning.ts';
+import type { Snapshot } from '../planning/types.ts';
 export declare function buildMockSnapshot(overrides?: Partial<Snapshot>): Snapshot;

package/dist/test-utils/build-mock-v1-attempt-row.d.ts

@@ -0,0 +1,2 @@
+import type { AttemptRow } from '../types.ts';
+export declare function buildMockV1AttemptRow(overrides?: Partial<AttemptRow>): AttemptRow;

package/dist/test-utils/build-mock-v1-item-row.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRow } from '../types.ts';
+export declare function buildMockV1ItemRow(overrides?: Partial<ItemRow>): ItemRow;

package/dist/test-utils/build-mock-v1-item-view.d.ts

@@ -0,0 +1,2 @@
+import type { ItemView } from '../types.ts';
+export declare function buildMockV1ItemView(overrides?: Partial<ItemView>): ItemView;

package/dist/test-utils/build-mock-v1-lever-row.d.ts

@@ -0,0 +1,2 @@
+import type { LeverRow } from '../types.ts';
+export declare function buildMockV1LeverRow(overrides?: Partial<LeverRow>): LeverRow;

package/dist/test-utils/build-mock-v1-pull-request-row.d.ts

@@ -0,0 +1,2 @@
+import type { PullRequestRow } from '../types.ts';
+export declare function buildMockV1PullRequestRow(overrides?: Partial<PullRequestRow>): PullRequestRow;

package/dist/test-utils/build-mock-work-fact.d.ts

@@ -0,0 +1,12 @@
+import type { EntityRef, OutboxFact, WorkFacts } from '../facts/types.ts';
+export type MockedFactType = 'boxxy.item.filed' | 'boxxy.item.edited' | 'boxxy.item.closed' | 'boxxy.attempt.claimed' | 'boxxy.attempt.started' | 'boxxy.attempt.reconciled' | 'boxxy.attempt.resumed' | 'boxxy.attempt.session_bound' | 'boxxy.attempt.slept' | 'boxxy.attempt.woken' | 'boxxy.attempt.closed_out' | 'boxxy.attempt.settled' | 'boxxy.pull_request.linked';
+interface WorkFactOverrides<Type extends MockedFactType> {
+    readonly payload?: {
+        readonly [Key in keyof WorkFacts[Type]]?: unknown;
+    };
+    readonly at?: number;
+    readonly entity?: EntityRef;
+    readonly seq?: number;
+}
+export declare function buildMockWorkFact<Type extends MockedFactType>(type: Type, overrides?: WorkFactOverrides<Type>): OutboxFact;
+export {};

package/dist/test-utils/create-fake-notifier.d.ts

@@ -0,0 +1,9 @@
+import type { HoldNotice, Notifier } from '../ports/types.ts';
+export interface FakeNotifier extends Notifier {
+    readonly told: readonly HoldNotice[];
+    readonly calls: () => number;
+    failNext: (reason: string) => void;
+    failAlways: (reason: string) => void;
+    recover: () => void;
+}
+export declare function createFakeNotifier(): FakeNotifier;

package/dist/test-utils/create-fake-pepys-reader.d.ts

@@ -0,0 +1,13 @@
+import type { PepysReader } from '../ports/types.ts';
+import type { CostToLand, StageTime } from '../reports/types.ts';
+import type { ItemId } from '../types.ts';
+interface FakeValues {
+    readonly cost?: CostToLand;
+    readonly stageTime?: StageTime;
+}
+export interface FakePepysReader extends PepysReader {
+    set: (item: ItemId, values: FakeValues) => void;
+    failNext: (reason: string) => void;
+}
+export declare function createFakePepysReader(environment?: string): FakePepysReader;
+export {};

package/dist/test-utils/fact-sink-contract.d.ts

@@ -0,0 +1,14 @@
+import type { FactId, FactSink, OutboxFact } from '@boxxy/model';
+export interface FactSinkHarness {
+    readonly sink: FactSink;
+    readStored: () => Promise<readonly FactId[]>;
+    corrupt: (fact: OutboxFact) => OutboxFact;
+}
+export type FactSinkCase = readonly [
+    title: string,
+    check: (harness: FactSinkHarness) => Promise<{
+        received: unknown;
+        expected: unknown;
+    }>
+];
+export declare const factSinkContract: readonly FactSinkCase[];

package/dist/test-utils/pepys-reader-contract.d.ts

@@ -0,0 +1,17 @@
+import type { PepysReader } from '../ports/types.ts';
+import type { CostToLand } from '../reports/types.ts';
+import type { ItemId } from '../types.ts';
+export interface PepysReaderHarness {
+    readonly reader: PepysReader;
+    readonly environment: string;
+    writeCost: (item: ItemId, cost: CostToLand) => Promise<void>;
+    takeDown: () => Promise<void>;
+}
+export type PepysReaderCase = readonly [
+    title: string,
+    check: (harness: PepysReaderHarness) => Promise<{
+        received: unknown;
+        expected: unknown;
+    }>
+];
+export declare const pepysReaderContract: readonly PepysReaderCase[];