@hypercarrier/pi-team-durable 0.0.0-stage → 0.1.0-rc.2

package/dist/authority/incremental-graph-control.d.ts

@@ -0,0 +1,156 @@
+import { type GraphVersionRef, type GraphApplyInput, type GraphTaskTransitionInput, type GraphTaskState, type GraphTaskView, type GraphAttemptView, type GraphRevision, type GraphControlEvent, type GraphApplyResult, type GraphTransitionResult, type GraphControlSnapshot } from "./graph-control.ts";
+type StoredTaskDefinition = GraphRevision["tasks"][number];
+type StoredReceipt = GraphControlSnapshot["receipts"][number];
+type EventOf<K extends GraphControlEvent["kind"]> = Extract<GraphControlEvent, {
+    kind: K;
+}>;
+type AttemptStartedEvent = EventOf<"attempt_started">;
+type AttemptBlockedEvent = EventOf<"attempt_blocked">;
+type AttemptResumedEvent = EventOf<"attempt_resumed">;
+type AttemptCompletedEvent = EventOf<"attempt_completed">;
+type AttemptSupersededEvent = EventOf<"attempt_superseded">;
+type TaskCancelledEvent = EventOf<"task_cancelled">;
+type FailureEdgeExhaustedEvent = EventOf<"failure_edge_exhausted">;
+interface AttemptFold {
+    started: AttemptStartedEvent;
+    blocked?: AttemptBlockedEvent;
+    resumed?: AttemptResumedEvent;
+    completed?: AttemptCompletedEvent;
+    superseded?: AttemptSupersededEvent;
+    cancellation?: TaskCancelledEvent;
+    exhausted?: FailureEdgeExhaustedEvent;
+    endedAt?: string;
+    endedSequence?: number;
+}
+interface DerivedTask {
+    definition: StoredTaskDefinition;
+    state: GraphTaskState;
+    activationKey?: string;
+    inputAttemptIds: Record<string, string>;
+    acceptedAttemptId?: string;
+    attemptsStarted: number;
+}
+declare function digest(value: unknown): string;
+interface TaskNode {
+    definition: StoredTaskDefinition;
+    cancellation?: TaskCancelledEvent;
+    currentContext?: string;
+    demand: number;
+    traversals: number;
+    activations: Map<string, AttemptFold>;
+    derived?: DerivedTask;
+    view?: GraphTaskView;
+}
+/** Current-state representation. History and replay receipts have separate owners. */
+export interface GraphMaterializedHead {
+    sequence: number;
+    revision?: Omit<GraphRevision, "tasks">;
+    topology: Array<{
+        key: string;
+        needs: string[];
+    }>;
+    projections: Record<string, string>;
+    ready: Record<string, string[]>;
+    occupied: Record<string, string[]>;
+}
+export interface GraphMaterializedTask {
+    id: string;
+    attemptsStarted: number;
+    node?: Omit<TaskNode, "activations">;
+    attempts: AttemptFold[];
+}
+export declare class GraphTaskRequired extends Error {
+    readonly ids: string[];
+    constructor(ids: string[]);
+}
+export declare class IncrementalGraphTaskController {
+    private readonly graphRevisions;
+    private readonly events;
+    private readonly receipts;
+    private readonly attempts;
+    private readonly attemptCounts;
+    private readonly activeAttempts;
+    private nodes;
+    private dependents;
+    private ranks;
+    private readonly dirty;
+    private readonly ready;
+    private readonly occupied;
+    private sequence;
+    private projections;
+    private readonly changed;
+    private restoredRevisionCount;
+    private structuralTasks;
+    private commandRecordedAt?;
+    private readonly clock;
+    constructor(clock?: () => Date);
+    /** Migration only. The caller validates the source with the reference controller. */
+    static fromSnapshot(snapshot: GraphControlSnapshot, clock?: () => Date): IncrementalGraphTaskController;
+    static restore(head: GraphMaterializedHead, records: ReadonlyMap<string, GraphMaterializedTask>, clock?: () => Date): IncrementalGraphTaskController;
+    headUpdate(): {
+        sequence: number;
+        projections: {
+            [k: string]: string;
+        };
+        ready: {
+            [k: string]: string[];
+        };
+        occupied: {
+            [k: string]: string[];
+        };
+    };
+    materializedHead(): GraphMaterializedHead;
+    materializedTask(id: string): GraphMaterializedTask;
+    changes(): {
+        taskIds: string[];
+        revisions: GraphRevision[];
+        events: GraphControlEvent[];
+        receipts: import("./graph-control.ts").StoredReceipt[];
+    };
+    restoreReceipt(receipt: StoredReceipt): void;
+    snapshot(): GraphControlSnapshot;
+    currentGraphVersion(): GraphVersionRef | undefined;
+    hasOperationReceipt(operationId: string): boolean;
+    applyGraph(input: GraphApplyInput): GraphApplyResult & {
+        replayed: boolean;
+    };
+    transition(input: GraphTaskTransitionInput): GraphTransitionResult & {
+        replayed: boolean;
+    };
+    readTask(taskId: string): GraphTaskView;
+    readTasks(): GraphTaskView[];
+    attemptStartedSequence(id: string): number;
+    readAttempts(taskId?: string): GraphAttemptView[];
+    selectReadyFrontier(): GraphTaskView[];
+    trace(): {
+        graphRevisions: GraphRevision[];
+        tasks: GraphTaskView[];
+        attempts: GraphAttemptView[];
+        events: GraphControlEvent[];
+    };
+    private claim;
+    private block;
+    private resume;
+    private complete;
+    private cancel;
+    private assertWorker;
+    private invalid;
+    private command;
+    private append;
+    private nextSequence;
+    private currentRevision;
+    private definition;
+    private installGraph;
+    private fold;
+    private rebuild;
+    private flush;
+    private indexView;
+    private readyIds;
+    private occupiedTask;
+    private activeAttemptIds;
+    private attemptsToSupersede;
+    private deriveNode;
+    private toView;
+}
+export declare function prerequisiteProjection(task: DerivedTask | undefined): string;
+export { digest as graphControlFingerprint };