@boxxy/model 0.1.2 → 0.1.3

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;

package/dist/types/registries.d.ts

@@ -1,150 +0,0 @@
-import type { JsonValue } from '@boxxy/content-hash';
-import type { z } from 'zod';
-import type { ConceptPin, ItemKindName, LeverKind, LoadedRecipe, MaxAttemptsByKind, PhaseName, PipelineName, RecipeName, RulesVersion } from './core.ts';
-import type { Admission, FrameItem, Gate, Pool, PropagationLine, Signal, SignalKey, SignalName, View, Waiver } from './planning.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 KindRules {
-    readonly pipeline: Pipeline;
-    readonly recipes: Readonly<Record<PhaseName, RecipeName>>;
-}
-export interface Pipeline {
-    readonly name: PipelineName;
-    readonly steps: readonly PipelineStep[];
-}
-export interface PipelineStep {
-    readonly phase: PhaseName;
-    readonly maxAttempts: number;
-}
-export type ConceptEntry = `${string}@${number}`;
-export type PluginRef = string | Readonly<Record<string, JsonValue>>;
-export type SignalRef = SignalName | Readonly<Record<string, JsonValue>>;
-export interface RulesFile {
-    readonly version: 1;
-    readonly concepts: readonly ConceptEntry[];
-    readonly kinds: Readonly<Record<string, {
-        readonly pipeline: readonly string[] | PipelineName;
-        readonly maxAttempts: Readonly<Record<string, number>>;
-        readonly recipes: Readonly<Record<string, string>>;
-    }>>;
-    readonly pools: readonly {
-        readonly name: string;
-        readonly slots: number;
-        readonly takes: Readonly<Record<string, JsonValue>>;
-        readonly order: readonly SignalRef[];
-    }[];
-    readonly lead: readonly SignalRef[];
-    readonly propagation: readonly {
-        readonly value: string;
-        readonly over: string;
-        readonly toward: 'source' | 'target';
-    }[];
-    readonly recipes: Readonly<Record<string, {
-        readonly agent: string;
-        readonly model: string;
-        readonly effort: string;
-        readonly prompt: string;
-        readonly source: string;
-    }>>;
-}
-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 maxAttemptsByKind: MaxAttemptsByKind;
-    readonly pools: readonly Pool[];
-    readonly propagation: readonly PropagationLine[];
-    readonly recipes: ReadonlyMap<RecipeName, LoadedRecipe>;
-}
-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-link-type';
-    readonly link: 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';
-};
-export type LoadResult = {
-    readonly kind: 'loaded';
-    readonly rules: LoadedRules;
-    readonly warnings: readonly string[];
-} | {
-    readonly kind: 'rejected';
-    readonly rejections: readonly LoadRejection[];
-};

package/src/actor-ref-schema.ts

@@ -1,9 +0,0 @@
-import { z } from 'zod';
-import { brandSchemas } from './brand-schemas.ts';
-
-export const actorRefSchema = z.union([
-  z.literal('boxxy:owner:local'),
-  z.templateLiteral(['boxxy:runner:', brandSchemas.runnerId]),
-  z.templateLiteral(['boxxy:attempt:', brandSchemas.attemptId]),
-  z.templateLiteral(['boxxy:hook:', brandSchemas.attemptId]),
-]);

package/src/build-applied-change.ts

@@ -1,71 +0,0 @@
-import type { AttemptId, PoolName } from './types/core.ts';
-import type { AnyNewFact, RowWrite, StoreChange } from './types/ports.ts';
-
-export interface TakenSlot {
-  readonly holder: AttemptId;
-  readonly pool: PoolName;
-  readonly slot: number;
-  readonly gen: number;
-}
-
-export interface ChangeAssignments {
-  readonly taken: TakenSlot | null;
-
-  // 0 when the store holds no lever
-  readonly lastLeverSeq: number;
-}
-
-export function buildAppliedChange(
-  change: StoreChange,
-  assignments: ChangeAssignments,
-): Pick<StoreChange, 'writes' | 'facts'> {
-  const leverSeqs: number[] = [];
-
-  const writes = change.writes.map((write): RowWrite => {
-    if (write.op !== 'insert') {
-      return write;
-    }
-
-    if (write.table === 'levers') {
-      const seq = assignments.lastLeverSeq + leverSeqs.length + 1;
-
-      leverSeqs.push(seq);
-
-      return { ...write, row: { ...write.row, seq } };
-    }
-
-    if (write.table === 'attempts' && write.row.id === assignments.taken?.holder) {
-      const taken = assignments.taken;
-
-      return { ...write, row: { ...write.row, slot: taken.slot, slotGen: taken.gen } };
-    }
-
-    return write;
-  });
-
-  let leverFacts = 0;
-
-  const facts = change.facts.map((fact): AnyNewFact => {
-    if (fact.type === 'boxxy.lever.recorded') {
-      const seq = leverSeqs[leverFacts];
-
-      leverFacts += 1;
-
-      return seq === undefined ? fact : { ...fact, payload: { ...fact.payload, seq } };
-    }
-
-    if (
-      fact.type === 'boxxy.attempt.claimed' &&
-      assignments.taken !== null &&
-      fact.entity === `boxxy:attempt:${assignments.taken.holder}`
-    ) {
-      const taken = assignments.taken;
-
-      return { ...fact, payload: { ...fact.payload, slot: taken.slot, gen: taken.gen } };
-    }
-
-    return fact;
-  });
-
-  return { writes, facts };
-}