@boxxy/model 0.1.2 → 0.1.4

package/dist/planning/types.d.ts

@@ -0,0 +1,155 @@
+import type { Schema } from '../rules/types.ts';
+import type { AttemptId, FaultRecord, FieldValues, Instant, ItemId, ItemView, LeverRow, LimitName, PhaseName, PoolName, RelationRow, RelationTypeName } from '../types.ts';
+export type SignalName = string;
+export type GateName = string;
+export type WaiverName = string;
+export type AdmissionName = string;
+export type ViewName = string;
+export type SignalKey = `${SignalName}#${string}`;
+export type Filter = Readonly<Record<string, readonly string[]>>;
+export interface Limit {
+    readonly name: LimitName;
+    readonly max: number;
+    readonly counts: Filter;
+}
+export interface LimitFill extends Limit {
+    readonly held: number;
+}
+export interface Pool {
+    readonly name: PoolName;
+    readonly takes: Filter;
+    readonly order: readonly SignalKey[];
+}
+export interface Snapshot {
+    readonly storeVersion: number;
+    readonly items: readonly ItemView[];
+    readonly relations: readonly RelationRow[];
+    readonly levers: readonly LeverRow[];
+    readonly limits: readonly LimitFill[];
+    readonly wakes: readonly Wake[];
+}
+export interface Wake {
+    readonly attempt: AttemptId;
+    readonly item: ItemId;
+    readonly phase: PhaseName;
+    readonly pool: PoolName;
+    readonly fields: FieldValues;
+    readonly requestedAt: Instant;
+}
+export type Pick = StartPick | WakePick;
+export interface StartPick {
+    readonly kind: 'start';
+    readonly item: ItemId;
+    readonly phase: PhaseName;
+    readonly round: number;
+    readonly pool: PoolName;
+    readonly fields: FieldValues;
+    readonly limits: readonly LimitName[];
+}
+export interface WakePick {
+    readonly kind: 'wake';
+    readonly attempt: AttemptId;
+    readonly limits: readonly LimitName[];
+}
+export interface Wait {
+    readonly subject: {
+        readonly kind: 'item';
+        readonly item: ItemId;
+    } | {
+        readonly kind: 'wake';
+        readonly attempt: AttemptId;
+    };
+    readonly reason: WaitReason;
+}
+export type WaitReason = {
+    readonly kind: 'limit-full';
+    readonly limit: LimitName;
+} | {
+    readonly kind: 'backoff';
+    readonly pool: PoolName;
+} | {
+    readonly kind: 'no-pool';
+};
+export interface Decision {
+    readonly picks: readonly Pick[];
+    readonly waits: readonly Wait[];
+}
+export interface SeatRef {
+    readonly limit: LimitName;
+}
+export interface SeatTake {
+    readonly limits: readonly LimitName[];
+    readonly attempt: AttemptId;
+    readonly holdGen: number;
+    readonly overCap: boolean;
+}
+export interface SeatRelease {
+    readonly attempt: AttemptId;
+    readonly holdGen: number;
+}
+export interface FrameItem extends ItemView {
+    readonly phase: PhaseName;
+    readonly round: number;
+}
+export interface Frame {
+    candidates: FrameItem[];
+    fields: Map<ItemId, Readonly<Record<string, readonly string[]>>>;
+    values: Map<SignalKey, Map<ItemId, number>>;
+    holds: Map<ItemId, Hold[]>;
+    lifted: Map<ItemId, Lift[]>;
+    faults: Fault[];
+}
+export type FrameValues = ReadonlyMap<SignalKey, ReadonlyMap<ItemId, number>>;
+export interface Hold {
+    readonly gate: GateName;
+    readonly reason: string;
+    readonly until?: Instant;
+}
+export interface Lift {
+    readonly waiver: WaiverName;
+    readonly gate: GateName;
+    readonly reason: string;
+}
+export type Fault = FaultRecord;
+export interface PlanContext {
+    now: Instant;
+    levers: readonly LeverRow[];
+    relations: readonly RelationRow[];
+    values: FrameValues;
+}
+export interface Signal<P> {
+    name: SignalName;
+    params: Schema<P>;
+    value: (item: ItemView, ctx: PlanContext, params: P) => number | null;
+    combine?: (left: number, right: number) => number;
+}
+export interface Gate<P> {
+    name: GateName;
+    liftable: boolean;
+    params: Schema<P>;
+    hold: (item: FrameItem, ctx: PlanContext, params: P) => Hold | null;
+}
+export interface Waiver {
+    name: WaiverName;
+    lifts: GateName;
+    lift: (item: FrameItem, hold: Hold, ctx: PlanContext) => Lift | null;
+}
+export interface Admission<P> {
+    name: AdmissionName;
+    params: Schema<P>;
+    admit: (item: FrameItem, ctx: PlanContext, params: P) => AdmissionGrant | null;
+}
+export interface AdmissionGrant {
+    readonly admission: AdmissionName;
+    readonly pools: readonly PoolName[] | 'any';
+    readonly reason: string;
+}
+export interface View<I = unknown, O = unknown> {
+    name: ViewName;
+    render: (frame: Frame, input: I) => O;
+}
+export interface PropagationLine {
+    readonly value: SignalName;
+    readonly over: RelationTypeName;
+    readonly toward: 'source' | 'target';
+}

package/dist/ports/types.d.ts

@@ -0,0 +1,289 @@
+import type { JsonValue } from '@boxxy/content-hash';
+import type { AnyNewFact, OutboxFact } from '../facts/types.ts';
+import type { ItemWithLevers } from '../items/types.ts';
+import type { HoldReason } from '../pipeline/types.ts';
+import type { Limit, LimitFill, SeatRelease, SeatTake, Snapshot } from '../planning/types.ts';
+import type { CostToLand, StageTime } from '../reports/types.ts';
+import type { ItemRules } from '../rules/types.ts';
+import type { AgentSessionId, AtcSessionId, AttemptId, AttemptRow, AttemptSessionRow, CallerIdentity, CommitSha, DecisionRow, Effort, EvidenceRow, FactId, Instant, ItemId, ItemRow, ItemState, ItemView, KeptSession, LeaseRow, LeverRow, LimitName, LimitSeatRow, NoteRow, NoticeRow, PhaseName, PoolName, PullRequestRef, PullRequestRow, RelationRow, RepoName, RunnerId, RunnerRow } from '../types.ts';
+export interface ClaimStore {
+    exclusive: <T>(work: (tx: StoreTx) => Promise<T>) => Promise<T>;
+    read: <T>(work: (tx: StoreReader) => Promise<T>) => Promise<T>;
+}
+export interface StoreReader extends OutboxReader {
+    readSnapshot: (now: Instant, rules: ItemRules) => Promise<Snapshot>;
+    readItem: (id: ItemId, now: Instant, rules: ItemRules) => Promise<ItemView | null>;
+    readItemDetail: (id: ItemId, now: Instant, rules: ItemRules) => Promise<ItemDetailRows | null>;
+    listItems: (filter: ItemFilter, now: Instant, rules: ItemRules) => Promise<ItemWithLevers[]>;
+    listOpenIssues: (repo: RepoName, now: Instant, rules: ItemRules) => Promise<ItemView[]>;
+    readLastLeaseGen: (item: ItemId, phase: PhaseName) => Promise<number>;
+    readAttempt: (id: AttemptId) => Promise<AttemptRow | null>;
+    listEvidence: (attempt: AttemptId) => Promise<EvidenceRow[]>;
+    listItemAttempts: (item: ItemId) => Promise<AttemptRow[]>;
+    listLiveAttempts: () => Promise<AttemptRow[]>;
+    listStrayAttempts: (since: Instant) => Promise<AttemptRow[]>;
+    listSucceededAttemptsWithoutPullRequest: () => Promise<AttemptRow[]>;
+    findAttemptBySession: (session: AtcSessionId) => Promise<AttemptRow | null>;
+    findAttemptByAgentSession: (session: AgentSessionId) => Promise<AttemptId | null>;
+    findSessionByCaller: (caller: CallerIdentity) => Promise<AtcSessionId | 'ambiguous' | null>;
+    readPullRequestRow: (ref: PullRequestRef) => Promise<PullRequestRow | null>;
+    listWatchedPullRequests: () => Promise<PullRequestRow[]>;
+    listLimits: () => Promise<LimitFill[]>;
+    listLimitSeats: () => Promise<LimitSeatRow[]>;
+    listItemNotes: (item: ItemId) => Promise<NoteRow[]>;
+    listUnsentNotices: (limit: number) => Promise<NoticeRow[]>;
+    listKeptSessions: () => Promise<{
+        readonly item: ItemId;
+        readonly kept: KeptSession;
+    }[]>;
+    listSessionsToForget: (failedEndedBefore: Instant) => Promise<AttemptRow[]>;
+    readRunner: (id: RunnerId) => Promise<RunnerRow | null>;
+}
+export interface OutboxReader {
+    readUnsentFacts: (limit: number) => Promise<OutboxFact[]>;
+    readOutboxCounts: () => Promise<{
+        readonly unsent: number;
+        readonly parked: number;
+        readonly oldestUnsentAt: Instant | null;
+    }>;
+    readItemBehind: (item: ItemId) => Promise<{
+        readonly facts: number;
+        readonly oldestAt: Instant | null;
+    }>;
+}
+export interface ItemDetailRows {
+    readonly item: ItemWithLevers;
+    readonly attempts: readonly AttemptRow[];
+    readonly relations: readonly RelationRow[];
+    readonly evidence: readonly EvidenceRow[];
+    readonly pullRequests: readonly PullRequestRow[];
+    readonly notes: readonly NoteRow[];
+}
+export interface StoreTx extends StoreReader {
+    applyChange: (change: StoreChange) => Promise<ApplyResult>;
+    markFactsSent: (ids: readonly FactId[], at: Instant) => Promise<void>;
+    parkFacts: (ids: readonly FactId[], reason: string, at: Instant) => Promise<void>;
+    unparkFacts: () => Promise<number>;
+    writeHeartbeat: (runner: RunnerId, at: Instant) => Promise<void>;
+    syncLimits: (limits: readonly Limit[], at: Instant) => Promise<void>;
+    markPullRequestChecked: (ref: PullRequestRef, at: Instant) => Promise<void>;
+    markNoticeTried: (id: number, at: Instant, sent: boolean) => Promise<void>;
+}
+export interface StoreChange {
+    readonly at: Instant;
+    readonly under?: {
+        readonly item: ItemId;
+        readonly phase: PhaseName;
+        readonly gen: number;
+        readonly holdGen?: number;
+    } | null;
+    readonly writes: readonly RowWrite[];
+    readonly facts: readonly AnyNewFact[];
+}
+export type ApplyResult = {
+    readonly kind: 'applied';
+} | {
+    readonly kind: 'stale-generation';
+} | {
+    readonly kind: 'lease-held';
+} | {
+    readonly kind: 'limit-full';
+    readonly limit: LimitName;
+} | {
+    readonly kind: 'unknown-limit';
+    readonly limit: LimitName;
+} | {
+    readonly kind: 'guard-mismatch';
+    readonly table: TableName;
+    readonly key: JsonValue;
+};
+export interface ItemFilter {
+    readonly state?: ItemState;
+    readonly repo?: RepoName;
+}
+export interface Tables {
+    items: ItemRow;
+    relations: RelationRow;
+    levers: LeverRow;
+    attempts: AttemptRow;
+    attempt_sessions: AttemptSessionRow;
+    leases: LeaseRow;
+    decisions: DecisionRow;
+    evidence: EvidenceRow;
+    pull_requests: PullRequestRow;
+    runners: RunnerRow;
+    notes: NoteRow;
+    notices: NoticeRow;
+}
+export type TableName = keyof Tables;
+export type RowWrite = {
+    [T in TableName]: {
+        readonly op: 'insert';
+        readonly table: T;
+        readonly row: Tables[T];
+    };
+}[TableName] | {
+    [T in TableName]: {
+        readonly op: 'update';
+        readonly table: T;
+        readonly key: Partial<Tables[T]>;
+        readonly expect: Partial<Tables[T]>;
+        readonly set: Partial<Tables[T]>;
+    };
+}[TableName] | {
+    readonly op: 'take-seats';
+    readonly take: SeatTake;
+} | {
+    readonly op: 'release-seats';
+    readonly release: SeatRelease;
+};
+export interface WorkerKind {
+    start: (request: SpawnRequest) => Promise<StartOutcome>;
+    reconcile: (attempt: AttemptRow) => Promise<SessionReading>;
+    suspend: (attempt: AttemptRow, ifIdleSince: Instant | null) => Promise<SuspendOutcome>;
+    resume: (attempt: AttemptRow) => Promise<StartOutcome>;
+    stop: (attempt: AttemptRow) => Promise<StopOutcome>;
+    forget: (session: AtcSessionId) => Promise<ForgetOutcome>;
+    resumeKept: (kept: KeptSession, request: SpawnRequest) => Promise<StartOutcome>;
+}
+export type StartOutcome = {
+    readonly kind: 'started';
+    readonly atcSession: AtcSessionId;
+    readonly agentSession: AgentSessionId | null;
+    readonly caller: CallerIdentity | null;
+} | {
+    readonly kind: 'refused';
+    readonly cause: 'capacity' | 'other';
+    readonly reason: string;
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string;
+};
+export type SuspendOutcome = {
+    readonly kind: 'suspended';
+} | {
+    readonly kind: 'active';
+} | {
+    readonly kind: 'refused' | 'unknown';
+    readonly reason: string;
+};
+export type StopOutcome = {
+    readonly kind: 'stopped' | 'absent';
+} | {
+    readonly kind: 'refused' | 'unknown';
+    readonly reason: string;
+};
+export type ForgetOutcome = {
+    readonly kind: 'forgotten' | 'absent';
+} | {
+    readonly kind: 'refused' | 'unknown';
+    readonly reason: string;
+};
+export type SessionReading = {
+    readonly kind: 'running';
+    readonly atcSession: AtcSessionId;
+    readonly agentSession: AgentSessionId | null;
+    readonly caller: CallerIdentity | null;
+    readonly attention: Attention;
+    readonly lastActivityAt: Instant;
+    readonly lastOwnerAt: Instant;
+    readonly usageLimitResetsAt: Instant | null;
+} | {
+    readonly kind: 'suspended';
+    readonly atcSession: AtcSessionId;
+    readonly agentSession: AgentSessionId | null;
+    readonly asked: boolean;
+} | {
+    readonly kind: 'ended';
+    readonly atcSession: AtcSessionId;
+    readonly agentSession: AgentSessionId | null;
+} | {
+    readonly kind: 'absent';
+};
+export type Attention = 'working' | 'needs-input' | 'turn-ended';
+export interface SpawnRequest {
+    readonly target: string;
+    readonly cwd: string;
+    readonly prompt: string;
+    readonly agent: string;
+    readonly model: string;
+    readonly effort: Effort;
+    readonly name: `boxxy/${string}`;
+    readonly idempotencyKey: AttemptId;
+}
+export type WakeSource = 'command' | 'session-ran' | 'host-slept-unasked';
+export interface Notifier {
+    tellHold: (notice: HoldNotice) => Promise<NoticeOutcome>;
+}
+export interface HoldNotice {
+    readonly item: ItemId;
+    readonly reason: HoldReason;
+    readonly at: Instant;
+}
+export type NoticeOutcome = {
+    readonly kind: 'sent';
+} | {
+    readonly kind: 'failed';
+    readonly reason: string;
+};
+export interface CallerProof {
+    prove: (request: Request) => Promise<CallerIdentity | null>;
+}
+export interface CapacityBackoff {
+    hold: (pool: PoolName, until: Instant) => void;
+    listHeld: (now: Instant) => readonly PoolName[];
+}
+export interface SessionFault {
+    readonly kind: 'fault';
+    readonly fault: 'agent-session-owned';
+    readonly agentSession: AgentSessionId;
+    readonly attempt: AttemptId;
+    readonly holder: AttemptId;
+}
+export type SinkAnswer = {
+    readonly kind: 'stored';
+} | {
+    readonly kind: 'retry';
+    readonly reason: string;
+} | {
+    readonly kind: 'refused-batch';
+    readonly status: 400 | 413 | 422;
+    readonly reason: string;
+} | {
+    readonly kind: 'refused-sink';
+    readonly status: number;
+    readonly reason: string;
+};
+export interface FactSink {
+    send: (facts: readonly OutboxFact[]) => Promise<SinkAnswer>;
+}
+export interface PepysReader {
+    readCostToLand: (item: ItemId) => Promise<PepysAnswer<CostToLand>>;
+    readStageTime: (item: ItemId) => Promise<PepysAnswer<StageTime>>;
+}
+export type PepysAnswer<Value> = {
+    readonly kind: 'value';
+    readonly value: Value;
+} | {
+    readonly kind: 'unavailable';
+    readonly reason: string;
+};
+export interface Forge {
+    readPullRequest: (ref: PullRequestRef) => Promise<PullRequestReading | 'not-found'>;
+    listOpenPullRequests: (repo: RepoName) => Promise<PullRequestRef[]>;
+}
+export interface PullRequestReading {
+    readonly url: string;
+    readonly githubId: number;
+    readonly state: 'open' | 'closed' | 'merged';
+    readonly mergedAt: Instant | null;
+    readonly mergeCommit: CommitSha | null;
+    readonly commits: readonly {
+        readonly sha: CommitSha;
+        readonly message: string;
+    }[];
+}
+export interface Clock {
+    now: () => Instant;
+}
+export type NewId = () => string;

package/dist/reports/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const phaseSteps: readonly ['triage', 'design', 'build', 'review'];
+export declare const stageSteps: readonly ["triage", "design", "build", "review", "merge", "release", "deploy"];
+export declare const costBases: readonly ['reported', 'turn', 'none'];

package/dist/reports/cost-to-land-schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const costToLandSchema: z.ZodObject<{
+    item: z.ZodString;
+    landedAt: z.ZodNullable<z.ZodString>;
+    attempts: z.ZodNumber;
+    lines: z.ZodArray<z.ZodObject<{
+        phase: z.ZodString;
+        rework: z.ZodBoolean;
+        product: z.ZodString;
+        model: z.ZodNullable<z.ZodString>;
+        requests: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheCreationTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        costBasis: z.ZodEnum<{
+            none: "none";
+            reported: "reported";
+            turn: "turn";
+        }>;
+    }, z.core.$strip>>;
+    totals: z.ZodObject<{
+        requests: z.ZodNumber;
+        costUSD: z.ZodNumber;
+        reworkCostUSD: z.ZodNumber;
+        requestsWithoutCost: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/reports/outbox-status.d.ts

@@ -0,0 +1,16 @@
+export interface OutboxStatus {
+    sink: 'pepys' | 'none';
+    state: 'idle' | 'sending' | 'backing-off' | 'blocked' | 'off';
+    unsent: number;
+    parked: number;
+    lag: number | null;
+    failingSince: number | null;
+    nextTryAt: number | null;
+    lastError: {
+        kind: 'retry' | 'refused-batch' | 'refused-sink';
+        status: number | null;
+        message: string;
+        at: number;
+    } | null;
+    lastStoredAt: number | null;
+}

package/dist/reports/stage-time-schema.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const stageTimeSchema: z.ZodObject<{
+    item: z.ZodString;
+    environment: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        step: z.ZodEnum<{
+            build: "build";
+            deploy: "deploy";
+            design: "design";
+            merge: "merge";
+            release: "release";
+            review: "review";
+            triage: "triage";
+        }>;
+        minutes: z.ZodNullable<z.ZodNumber>;
+        endedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    rework: z.ZodObject<{
+        count: z.ZodNumber;
+        minutes: z.ZodNumber;
+    }, z.core.$strip>;
+    reviewWaitMinutes: z.ZodNullable<z.ZodNumber>;
+    sleepMinutes: z.ZodNumber;
+    pullRequests: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;

package/dist/reports/types.d.ts

@@ -0,0 +1,5 @@
+import type { z } from 'zod';
+import type { costToLandSchema } from './cost-to-land-schema.ts';
+import type { stageTimeSchema } from './stage-time-schema.ts';
+export type CostToLand = z.output<typeof costToLandSchema>;
+export type StageTime = z.output<typeof stageTimeSchema>;

package/dist/rows/actor-ref-schema.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const actorRefSchema: z.ZodUnion<readonly [z.ZodLiteral<"boxxy:owner:local">, z.ZodTemplateLiteral<`boxxy:runner:${string}`>, z.ZodTemplateLiteral<`boxxy:attempt:${string}`>, z.ZodTemplateLiteral<`boxxy:hook:${string}`>]>;

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

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

package/dist/rows/attempt-session-row-schema.d.ts

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

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

@@ -4,7 +4,7 @@ export declare const brandSchemas: {
     itemId: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
     attemptId: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
     decisionId: z.core.$ZodBranded<z.ZodString, "DecisionId", "out">;
-    factId: z.core.$ZodBranded<z.ZodTemplateLiteral<`manual:${string}`>, "FactId", "out">;
+    factId: z.core.$ZodBranded<z.ZodString, "FactId", "out">;
     runnerId: z.core.$ZodBranded<z.ZodString, "RunnerId", "out">;
     atcSessionId: z.core.$ZodBranded<z.ZodString, "AtcSessionId", "out">;
     agentSessionId: z.core.$ZodBranded<z.ZodString, "AgentSessionId", "out">;
@@ -12,10 +12,13 @@ export declare const brandSchemas: {
     repoName: z.core.$ZodBranded<z.ZodString, "RepoName", "out">;
     criterionId: z.core.$ZodBranded<z.ZodString, "CriterionId", "out">;
     itemKindName: z.core.$ZodBranded<z.ZodString, "ItemKindName", "out">;
-    linkTypeName: z.core.$ZodBranded<z.ZodString, "LinkTypeName", "out">;
+    relationTypeName: z.core.$ZodBranded<z.ZodString, "RelationTypeName", "out">;
     phaseName: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
     pipelineName: z.core.$ZodBranded<z.ZodString, "PipelineName", "out">;
     poolName: z.core.$ZodBranded<z.ZodString, "PoolName", "out">;
+    limitName: z.core.$ZodBranded<z.ZodString, "LimitName", "out">;
+    outcomeName: z.core.$ZodBranded<z.ZodString, "OutcomeName", "out">;
+    rulesHoldReason: z.core.$ZodBranded<z.ZodString, "RulesHoldReason", "out">;
     recipeName: z.core.$ZodBranded<z.ZodString, "RecipeName", "out">;
     workerKindName: z.core.$ZodBranded<z.ZodString, "WorkerKindName", "out">;
     sourceName: z.core.$ZodBranded<z.ZodString, "SourceName", "out">;

package/dist/rows/caller-identity-schema.d.ts

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

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

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

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

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export declare const decisionRowSchema: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "DecisionId", "out">;
+    attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+    item: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+    kind: z.ZodEnum<{
+        start: "start";
+        wake: "wake";
+    }>;
+    pool: z.core.$ZodBranded<z.ZodString, "PoolName", "out">;
+    rulesVersion: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "ContentHash", "out">, "RulesVersion", "out">;
+    snapshotHash: z.core.$ZodBranded<z.core.$ZodBranded<z.ZodString, "ContentHash", "out">, "SnapshotHash", "out">;
+    storeVersion: z.ZodNumber;
+    pepysOffsets: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "StreamName", "out">, z.ZodNumber>;
+    faults: z.ZodArray<z.ZodObject<{
+        plugin: z.ZodString;
+        kind: z.ZodEnum<{
+            admission: "admission";
+            "filter-field": "filter-field";
+            gate: "gate";
+            propagation: "propagation";
+            signal: "signal";
+            waiver: "waiver";
+        }>;
+        item: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ItemId", "out">>;
+        error: z.ZodString;
+    }, z.core.$strip>>;
+    limits: z.ZodArray<z.ZodObject<{
+        limit: z.core.$ZodBranded<z.ZodString, "LimitName", "out">;
+        held: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strip>>;
+    at: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+}, z.core.$strip>;

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

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

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

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const itemRowSchema: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+    kind: z.core.$ZodBranded<z.ZodString, "ItemKindName", "out">;
+    repo: z.core.$ZodBranded<z.ZodString, "RepoName", "out">;
+    title: z.ZodString;
+    outcome: z.ZodString;
+    acceptance: z.ZodArray<z.ZodType<import("../types.ts").Criterion, unknown, z.core.$ZodTypeInternals<import("../types.ts").Criterion, unknown>>>;
+    fields: z.ZodObject<{
+        designMode: z.ZodExactOptional<z.ZodEnum<{
+            agent: "agent";
+            attended: "attended";
+        }>>;
+    }, z.core.$strip>;
+    labels: z.ZodArray<z.ZodString>;
+    foundInAttempt: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "AttemptId", "out">>;
+    filedBy: z.ZodUnion<readonly [z.ZodLiteral<"boxxy:owner:local">, z.ZodTemplateLiteral<`boxxy:runner:${string}`>, z.ZodTemplateLiteral<`boxxy:attempt:${string}`>, z.ZodTemplateLiteral<`boxxy:hook:${string}`>]>;
+    filedAt: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+    closedAt: z.ZodNullable<z.core.$ZodBranded<z.ZodNumber, "Instant", "out">>;
+    closeReason: z.ZodNullable<z.ZodString>;
+    keptSession: z.ZodNullable<z.ZodObject<{
+        atcSession: z.core.$ZodBranded<z.ZodString, "AtcSessionId", "out">;
+        target: z.ZodString;
+        attempt: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+        keptAt: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+        caller: z.ZodNullable<z.ZodType<import("../types.ts").CallerIdentity, unknown, z.core.$ZodTypeInternals<import("../types.ts").CallerIdentity, unknown>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/rows/item-view-schema.d.ts

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

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

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

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const leverRowSchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    kind: z.ZodTemplateLiteral<`${string}.${string}`>;
+    item: z.core.$ZodBranded<z.ZodString, "ItemId", "out">;
+    until: z.ZodNullable<z.core.$ZodBranded<z.ZodNumber, "Instant", "out">>;
+    expiresAt: z.ZodNullable<z.core.$ZodBranded<z.ZodNumber, "Instant", "out">>;
+    reason: z.ZodNullable<z.ZodString>;
+    phase: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "PhaseName", "out">>;
+    actor: z.ZodUnion<readonly [z.ZodLiteral<"boxxy:owner:local">, z.ZodTemplateLiteral<`boxxy:runner:${string}`>, z.ZodTemplateLiteral<`boxxy:attempt:${string}`>, z.ZodTemplateLiteral<`boxxy:hook:${string}`>]>;
+    at: z.core.$ZodBranded<z.ZodNumber, "Instant", "out">;
+}, z.core.$strip>;