@boxxy/model 0.1.1 → 0.1.3

package/src/utils/format-key-path.ts

@@ -0,0 +1,19 @@
+export function formatKeyPath(segments: readonly PropertyKey[]): string {
+  return segments.map((segment, index) => formatSegment(segment, index === 0)).join('');
+}
+
+const plainKeyPattern = /^[A-Za-z_][\w-]*$/u;
+
+function formatSegment(segment: PropertyKey, isFirst: boolean): string {
+  if (typeof segment === 'number') {
+    return `[${segment}]`;
+  }
+
+  const key = String(segment);
+
+  if (!plainKeyPattern.test(key)) {
+    return `[${JSON.stringify(key)}]`;
+  }
+
+  return isFirst ? key : `.${key}`;
+}

package/src/utils/to-json-value.ts

@@ -0,0 +1,25 @@
+import type { JsonValue } from '@boxxy/content-hash';
+import invariant from 'tiny-invariant';
+
+export function toJSONValue(value: unknown): JsonValue {
+  if (
+    value === null ||
+    typeof value === 'boolean' ||
+    typeof value === 'number' ||
+    typeof value === 'string'
+  ) {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((entry: unknown) => toJSONValue(entry));
+  }
+
+  invariant(typeof value === 'object', `a ${typeof value} has no JSON form`);
+
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(([, entry]: [string, unknown]) => entry !== undefined)
+      .map(([key, entry]: [string, unknown]) => [key, toJSONValue(entry)]),
+  );
+}

package/dist/build-close-out-schema.d.ts

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

package/dist/define-admission.d.ts

@@ -1,3 +0,0 @@
-import type { Admission } from './types/planning.ts';
-import type { Registered } from './types/registries.ts';
-export declare function defineAdmission<P>(admission: Admission<P>): Registered<'admission'>;

package/dist/define-gate.d.ts

@@ -1,3 +0,0 @@
-import type { Gate } from './types/planning.ts';
-import type { Registered } from './types/registries.ts';
-export declare function defineGate<P>(gate: Gate<P>): Registered<'gate'>;

package/dist/define-signal.d.ts

@@ -1,3 +0,0 @@
-import type { Signal } from './types/planning.ts';
-import type { Registered } from './types/registries.ts';
-export declare function defineSignal<P>(signal: Signal<P>): Registered<'signal'>;

package/dist/derive-item-state.d.ts

@@ -1,2 +0,0 @@
-import type { DerivedState, ItemRow, ItemRows } from './types/core.ts';
-export declare function deriveItemState(item: ItemRow, rows: ItemRows): DerivedState;

package/dist/fact-schemas.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { FactType, SliceOneFacts } from './types/facts.ts';
-export declare const factSchemas: {
-    readonly [T in FactType]: z.ZodType<SliceOneFacts[T]>;
-};

package/dist/friction-schema.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/types/dispatch.d.ts

@@ -1,82 +0,0 @@
-import type { ContentHash } from '@boxxy/content-hash';
-import type { AttemptId, AttemptRow, CriterionId, EvidenceRow, FactId, ForcedFailure, Instant, ItemView, KnownFailure, LiveAttemptState, Minutes, RecipeName, RepoName } from './core.ts';
-import type { Friction, OpenItem } from './facts.ts';
-import type { SessionReading, SpawnRequest } from './ports.ts';
-export interface SpawnContext {
-    readonly repoPaths: ReadonlyMap<RepoName, string>;
-    readonly pluginFolder: {
-        readonly path: string;
-        readonly hash: ContentHash;
-    };
-    readonly promptTemplates: ReadonlyMap<RecipeName, string>;
-}
-export interface Claim {
-    readonly attempt: AttemptRow;
-    readonly spawn: SpawnRequest;
-}
-export type ReconcileAction = {
-    readonly kind: 'move-to-running';
-    readonly fact: 'boxxy.attempt.started' | 'boxxy.attempt.reconciled';
-} | {
-    readonly kind: 'bind-session';
-} | {
-    readonly kind: 'settle';
-} | {
-    readonly kind: 'fail';
-    readonly failure: Extract<KnownFailure, 'session-lost'>;
-} | {
-    readonly kind: 'respawn';
-    readonly giveUpAfter: Minutes;
-    readonly then: Extract<KnownFailure, 'spawn-lost'>;
-};
-export type ReconcileTable = Readonly<Record<SessionReading['kind'], Readonly<Record<LiveAttemptState, ReconcileAction>>>>;
-export interface Settlement {
-    readonly state: 'succeeded' | 'failed';
-    readonly failure: string | null;
-    readonly openItems: readonly OpenItem[];
-    readonly criteria: readonly {
-        readonly criterion: CriterionId;
-        readonly evidence: readonly FactId[];
-    }[];
-    readonly friction: readonly Friction[];
-    readonly frictionDropped: number;
-}
-export interface SettleRule<Out = unknown> {
-    settle: (input: SettleInput<Out>) => Settlement;
-}
-export interface SettleInput<Out> {
-    readonly attempt: AttemptRow;
-    readonly item: ItemView;
-    readonly closeOut: CloseOutParse<Out> | null;
-    readonly forced: ForcedFailure | null;
-    readonly now: Instant;
-}
-export interface CloseOutContext {
-    readonly item: ItemView;
-    readonly attempt: AttemptId;
-    readonly evidence: readonly EvidenceRow[];
-}
-export type CloseOutProblem = {
-    readonly kind: 'schema';
-    readonly path: string;
-    readonly message: string;
-} | {
-    readonly kind: 'unknown-criterion';
-    readonly criterion: CriterionId;
-} | {
-    readonly kind: 'foreign-evidence';
-    readonly evidence: FactId;
-} | {
-    readonly kind: 'built-without-evidence';
-    readonly criteria: readonly CriterionId[];
-};
-export type CloseOutParse<Out> = {
-    readonly kind: 'valid';
-    readonly closeOut: Out;
-} | {
-    readonly kind: 'invalid';
-    readonly problems: readonly CloseOutProblem[];
-};
-export interface CloseOutParser<Out> {
-    parse: (raw: unknown, ctx: CloseOutContext) => CloseOutParse<Out>;
-}

package/dist/types/facts.d.ts

@@ -1,154 +0,0 @@
-import type { JsonValue } from '@boxxy/content-hash';
-import type { ActorRef, AgentSessionId, AtcSessionId, CommitSha, Criterion, CriterionId, DecisionRow, EvidenceKind, FactId, Instant, ItemId, ItemRow, LeverRow, LinkTypeName, PhaseName, PoolName, RecipeHash, RepoName, RulesVersion, RunnerId } from './core.ts';
-export interface BuildCloseOut {
-    readonly result: {
-        readonly kind: 'built';
-    } | {
-        readonly kind: 'blocked';
-        readonly reason: string;
-    } | {
-        readonly kind: 'abandoned';
-        readonly reason: string;
-    };
-    readonly criteria: readonly {
-        readonly criterion: CriterionId;
-        readonly evidence: FactId;
-    }[];
-    readonly openItems: readonly OpenItem[];
-    readonly friction: readonly Friction[];
-    readonly frictionDropped: number;
-}
-export interface OpenItem {
-    readonly kind: 'core.issue';
-    readonly title: string;
-    readonly body: string;
-}
-export type FrictionTargetKind = 'skill' | 'rule' | 'lint' | 'agents-md' | 'tool';
-export interface Friction {
-    readonly target: {
-        readonly kind: FrictionTargetKind;
-        readonly name: string;
-    };
-    readonly change: string;
-}
-export type EntityRef = `boxxy:item:${string}` | `boxxy:link:${string}:${string}:${string}` | `boxxy:attempt:${string}` | `boxxy:decision:${string}` | `boxxy:runner:${string}`;
-export interface FactEnvelope<M extends object = SliceOneFacts, T extends keyof M & string = keyof M & string> {
-    readonly id: FactId;
-    readonly type: T;
-    readonly v: 1;
-    readonly api: 'boxxy/1';
-    readonly entity: EntityRef;
-    readonly actor: ActorRef;
-    readonly at: Instant;
-    readonly payload: M[T] & {
-        readonly storeVersion: number;
-    };
-}
-export interface NewFact<T extends keyof M & string, M extends object = SliceOneFacts> {
-    readonly id: FactId;
-    readonly type: T;
-    readonly entity: EntityRef;
-    readonly actor: ActorRef;
-    readonly payload: M[T];
-}
-export interface OutboxFact {
-    readonly seq: number;
-    readonly factId: FactId;
-    readonly type: string;
-    readonly entity: EntityRef;
-    readonly actor: ActorRef;
-    readonly at: Instant;
-    readonly payload: JsonValue;
-    readonly sentAt: Instant | null;
-}
-export type FactType = keyof SliceOneFacts;
-export interface LinkPayload {
-    readonly source: ItemId;
-    readonly target: ItemId;
-    readonly type: LinkTypeName;
-}
-export interface SliceOneFacts {
-    'boxxy.item.filed': ItemRow;
-    'boxxy.item.edited': {
-        readonly title?: string;
-        readonly outcome?: string;
-        readonly acceptance?: readonly Criterion[];
-    };
-    'boxxy.item.closed': {
-        readonly reason: string;
-    };
-    'boxxy.link.added': LinkPayload;
-    'boxxy.link.removed': LinkPayload;
-    'boxxy.lever.recorded': LeverRow;
-    'boxxy.attempt.claimed': {
-        readonly item: ItemId;
-        readonly phase: PhaseName;
-        readonly number: number;
-        readonly pool: PoolName;
-        readonly slot: number;
-        readonly gen: number;
-        readonly recipeHash: RecipeHash;
-        readonly rulesVersion: RulesVersion;
-    };
-    'boxxy.decision.recorded': DecisionRow;
-    'boxxy.attempt.started': {
-        readonly atcSession: AtcSessionId;
-    };
-    'boxxy.attempt.reconciling': {
-        readonly reason: string;
-    };
-    'boxxy.attempt.reconciled': {
-        readonly atcSession: AtcSessionId;
-    };
-    'boxxy.attempt.session_bound': {
-        readonly atcSession: AtcSessionId;
-        readonly agentSession: AgentSessionId;
-        readonly seenAt: Instant;
-    };
-    'boxxy.attempt.closed_out': {
-        readonly closeOut: BuildCloseOut;
-    };
-    'boxxy.attempt.settled': {
-        readonly state: 'succeeded' | 'failed';
-        readonly failure: string | null;
-        readonly endedAt: Instant;
-        readonly criteria: readonly {
-            readonly criterion: CriterionId;
-            readonly evidence: readonly FactId[];
-        }[];
-        readonly matched: readonly ItemId[];
-        readonly frictionDropped: number;
-    };
-    'boxxy.evidence.recorded': {
-        readonly kind: EvidenceKind;
-        readonly ref: string;
-        readonly observed: string | null;
-    };
-    'boxxy.evidence.pr_linked': {
-        readonly repo: RepoName;
-        readonly number: number;
-        readonly url: string;
-    };
-    'boxxy.evidence.commit_linked': {
-        readonly repo: RepoName;
-        readonly sha: CommitSha;
-        readonly pr: number;
-    };
-    'boxxy.pr.merged': {
-        readonly repo: RepoName;
-        readonly number: number;
-        readonly mergedAt: Instant;
-        readonly mergeCommit: CommitSha;
-    };
-    'boxxy.pr.closed': {
-        readonly repo: RepoName;
-        readonly number: number;
-    };
-    'boxxy.proposal.recorded': Friction;
-    'boxxy.runner.paused': {
-        readonly runner: RunnerId;
-    };
-    'boxxy.runner.resumed': {
-        readonly runner: RunnerId;
-    };
-}

package/dist/types/planning.d.ts

@@ -1,94 +0,0 @@
-import type { FaultRecord, Instant, ItemId, ItemView, LeverRow, LinkRow, LinkTypeName, PhaseName, PoolName } from './core.ts';
-import type { Schema } from './registries.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 interface Snapshot {
-    storeVersion: number;
-    items: ItemView[];
-    links: LinkRow[];
-    levers: LeverRow[];
-    freeSlots: Record<PoolName, number>;
-}
-export interface FrameItem extends ItemView {
-    readonly phase: PhaseName;
-}
-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 Decision {
-    picks: Pick[];
-}
-export interface Pick {
-    item: ItemId;
-    phase: PhaseName;
-    pool: PoolName;
-}
-export interface Pool {
-    readonly name: PoolName;
-    readonly slots: number;
-    readonly takes: Readonly<Record<string, readonly string[]>>;
-    readonly order: readonly SignalKey[];
-}
-export interface PlanContext {
-    now: Instant;
-    levers: LeverRow[];
-    links: LinkRow[];
-    values: FrameValues;
-}
-export interface Signal<P> {
-    name: SignalName;
-    params: Schema<P>;
-    value: (item: FrameItem, 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: LinkTypeName;
-    readonly toward: 'source' | 'target';
-}

package/dist/types/ports.d.ts

@@ -1,218 +0,0 @@
-import type { JsonValue } from '@boxxy/content-hash';
-import type { AgentSessionId, AtcSessionId, AttemptId, AttemptRow, AttemptSessionRow, CommitSha, DecisionRow, Effort, EvidenceRow, FactId, Instant, ItemId, ItemRow, ItemState, ItemView, ItemWithLevers, LeaseRow, LeverRow, LinkRow, MaxAttemptsByKind, PhaseName, PoolName, PoolSlotRow, PullRequestRef, PullRequestRow, RepoName, RunnerId, RunnerRow } from './core.ts';
-import type { FactType, NewFact, OutboxFact } from './facts.ts';
-import type { Snapshot } from './planning.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 {
-    readSnapshot: (now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<Snapshot>;
-    readItem: (id: ItemId, now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<ItemView | null>;
-    readItemDetail: (id: ItemId, now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<ItemDetailRows | null>;
-    listItems: (filter: ItemFilter, now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<ItemWithLevers[]>;
-    listOpenIssues: (repo: RepoName, now: Instant, maxAttemptsByKind: MaxAttemptsByKind) => Promise<ItemView[]>;
-    readLastLeaseGen: (item: ItemId, phase: PhaseName) => Promise<number>;
-    readAttempt: (id: AttemptId) => Promise<AttemptRow | null>;
-    listEvidence: (attempt: AttemptId) => Promise<EvidenceRow[]>;
-    listLiveAttempts: () => Promise<AttemptRow[]>;
-    listSucceededAttemptsWithoutPr: () => Promise<AttemptRow[]>;
-    findAttemptBySession: (session: AtcSessionId) => Promise<AttemptRow | null>;
-    findAttemptByAgentSession: (session: AgentSessionId) => Promise<AttemptId | null>;
-    listWatchedPullRequests: () => Promise<PullRequestRow[]>;
-    listPoolSlots: () => Promise<PoolSlotRow[]>;
-    readUnsentFacts: (limit: number) => Promise<OutboxFact[]>;
-    readOutboxLag: () => Promise<{
-        readonly unsent: number;
-        readonly oldestUnsentAt: Instant | null;
-    }>;
-    readRunner: (id: RunnerId) => Promise<RunnerRow | null>;
-}
-export interface ItemDetailRows {
-    readonly item: ItemWithLevers;
-    readonly attempts: readonly AttemptRow[];
-    readonly links: readonly LinkRow[];
-    readonly evidence: readonly EvidenceRow[];
-    readonly pullRequests: readonly PullRequestRow[];
-}
-export interface StoreTx extends StoreReader {
-    applyChange: (change: StoreChange) => Promise<ApplyResult>;
-    markFactsSent: (ids: FactId[], at: Instant) => Promise<void>;
-    writeHeartbeat: (runner: RunnerId, at: Instant) => Promise<void>;
-    syncPoolSlots: (pools: readonly {
-        readonly name: PoolName;
-        readonly slots: number;
-    }[]) => Promise<void>;
-    markPullRequestChecked: (ref: PullRequestRef, at: Instant) => Promise<void>;
-}
-export interface StoreChange {
-    at: Instant;
-    under?: {
-        item: ItemId;
-        phase: PhaseName;
-        gen: number;
-        slot?: {
-            pool: PoolName;
-            slot: number;
-            gen: number;
-        };
-    };
-    writes: RowWrite[];
-    facts: AnyNewFact[];
-}
-export type ApplyResult = {
-    kind: 'applied';
-    slot: {
-        pool: PoolName;
-        slot: number;
-        gen: number;
-    } | null;
-} | {
-    kind: 'stale-generation';
-} | {
-    kind: 'lease-held';
-} | {
-    kind: 'no-free-slot';
-} | {
-    kind: 'guard-mismatch';
-    table: TableName;
-    key: JsonValue;
-};
-export interface ItemFilter {
-    readonly state?: ItemState;
-    readonly repo?: RepoName;
-}
-export interface Tables {
-    items: ItemRow;
-    links: LinkRow;
-    levers: LeverRow;
-    attempts: AttemptRow;
-    attempt_sessions: AttemptSessionRow;
-    leases: LeaseRow;
-    pool_slots: PoolSlotRow;
-    decisions: DecisionRow;
-    evidence: EvidenceRow;
-    pull_requests: PullRequestRow;
-    runners: RunnerRow;
-}
-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-slot';
-    readonly pool: PoolName;
-    readonly holder: AttemptId;
-} | {
-    readonly op: 'release-slot';
-    readonly pool: PoolName;
-    readonly slot: number;
-    readonly holder: AttemptId;
-};
-export type AnyNewFact = {
-    [T in FactType]: NewFact<T>;
-}[FactType];
-export interface WorkerKind {
-    start: (request: SpawnRequest) => Promise<StartOutcome>;
-    reconcile: (attempt: AttemptRow) => Promise<SessionReading>;
-}
-export type StartOutcome = {
-    kind: 'started';
-    atcSession: AtcSessionId;
-    agentSession: AgentSessionId | null;
-} | {
-    kind: 'refused';
-    reason: string;
-} | {
-    kind: 'unknown';
-    reason: string;
-};
-export type SessionReading = {
-    kind: 'running';
-    atcSession: AtcSessionId;
-    agentSession: AgentSessionId | null;
-} | {
-    kind: 'ended';
-    atcSession: AtcSessionId;
-    agentSession: AgentSessionId | null;
-} | {
-    kind: 'absent';
-};
-export interface SpawnRequest {
-    readonly cwd: string;
-    readonly prompt: string;
-    readonly agent: string;
-    readonly model: string;
-    readonly effort: Effort;
-    readonly pluginDirs: readonly string[];
-    readonly name: `boxxy/${string}`;
-    readonly idempotencyKey: AttemptId;
-}
-export interface SessionFault {
-    readonly kind: 'fault';
-    readonly fault: 'agent-session-owned';
-    readonly agentSession: AgentSessionId;
-    readonly attempt: AttemptId;
-    readonly holder: AttemptId;
-}
-export interface FactSink {
-    append: (facts: OutboxFact[]) => Promise<'accepted' | {
-        kind: 'unknown';
-        reason: string;
-    } | {
-        kind: 'rejected';
-        error: string;
-    }>;
-}
-export interface CostToLandRow {
-    readonly item: ItemId;
-    readonly title: string;
-    readonly repo: RepoName;
-    readonly landedAt: Instant;
-    readonly model: string;
-    readonly attempts: number;
-    readonly requests: number;
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-    readonly cacheReadTokens: number;
-    readonly cacheCreationTokens: number;
-    readonly totalInputTokens: number;
-    readonly costUsd: number;
-}
-export interface CostToLandInput {
-    readonly repo?: string;
-    readonly landedFrom?: string;
-    readonly landedTo?: string;
-}
-export interface CostReader {
-    costToLand: (input: CostToLandInput) => Promise<CostToLandRow[]>;
-}
-export interface Forge {
-    readPullRequest: (ref: PullRequestRef) => Promise<PullRequestReading | 'not-found'>;
-    listOpenPullRequests: (repo: RepoName) => Promise<PullRequestRef[]>;
-}
-export interface PullRequestReading {
-    url: string;
-    state: 'open' | 'closed' | 'merged';
-    mergedAt: Instant | null;
-    mergeCommit: CommitSha | null;
-    commits: {
-        sha: CommitSha;
-        message: string;
-    }[];
-}
-export interface Clock {
-    now: () => Instant;
-}
-export type NewId = () => string;