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

package/dist/authority/state.d.ts

@@ -109,6 +109,10 @@ export interface Event {
     text?: string;
     entryId?: EntryId;
 }
+export type JournalRef = Event | {
+    seq: number;
+    entryId: EntryId;
+};
 export interface JournalState {
     seq: number;
     events: Event[];
@@ -136,15 +140,26 @@ export declare const GraphDoc: import("@earendil-works/pi-durable").SessionDocTo
 export declare const JournalDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
 export declare const OutboxDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
 export declare const ReceiptDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
-export declare function open(tx: Tx): Promise<{
+export declare function hasLegacyFence(value: object): boolean;
+/** Keep the v2 address occupied so an old reader cannot create a v1 incarnation. */
+export declare function fenceLegacyDoc(value: object): void;
+export interface State {
     team: TeamState;
     graph: GraphState;
     journal: JournalState;
     outbox: OutboxState;
     receipts: ReceiptState;
-}>;
-export type State = Awaited<ReturnType<typeof open>>;
+}
+/** Full historical inspection. Runtime commands use openAuthority's indexed state. */
+export declare function open(tx: Tx): Promise<State>;
 export declare const plain: <T>(value: T) => T;
 export declare const JOURNAL_RESIDENT_LIMIT = 100;
 /** History is append-only storage; the document contains a bounded recent projection. */
-export declare function event(tx: Tx, s: State, actor: string, kind: string, extra?: Pick<Event, 'taskId' | 'taskIds' | 'worker' | 'at' | 'text'>): Promise<void>;
+export declare function event(tx: Tx, s: {
+    team: TeamState;
+    journal: {
+        seq: number;
+        events: JournalRef[];
+    };
+    flush?: () => void;
+}, actor: string, kind: string, extra?: Pick<Event, 'taskId' | 'taskIds' | 'worker' | 'at' | 'text'>): Promise<void>;

package/dist/authority/state.js

@@ -1,18 +1,21 @@
 import { defineDoc } from '@earendil-works/pi-durable';
-const doc = (kind, initial) => defineDoc({ kind, version: 1, scope: 'session', checkpointWhen: () => false, initial });
+const doc = (kind, initial) => defineDoc({ kind, version: 2, migrate: value => value, scope: 'session', checkpointWhen: () => true, initial });
 export const TeamDoc = doc('ptb.team', () => ({ history: [], stops: {} }));
 export const GraphDoc = doc('ptb.graph', () => ({}));
-export const JournalDoc = defineDoc({ kind: 'ptb.journal', version: 1, scope: 'session', initial: () => ({ seq: 0, events: [], acknowledged: 0 }), checkpointWhen: (_value, _ops, info) => info.deltasSinceBase >= 31 });
+export const JournalDoc = doc('ptb.journal', () => ({ seq: 0, events: [], acknowledged: 0 }));
 export const OutboxDoc = doc('ptb.outbox', () => ({ alerts: {}, obligations: {} }));
 export const ReceiptDoc = doc('ptb.receipts', () => ({ calls: {} }));
+const fenceMarker = 'ptb-authority-v2';
+export function hasLegacyFence(value) { return value.fence === fenceMarker; }
+/** Keep the v2 address occupied so an old reader cannot create a v1 incarnation. */
+export function fenceLegacyDoc(value) {
+    for (const key of Object.keys(value))
+        Reflect.deleteProperty(value, key);
+    Object.assign(value, { fence: fenceMarker });
+}
+/** Full historical inspection. Runtime commands use openAuthority's indexed state. */
 export async function open(tx) {
-    return {
-        team: await tx.doc(TeamDoc),
-        graph: await tx.doc(GraphDoc),
-        journal: await tx.doc(JournalDoc),
-        outbox: await tx.doc(OutboxDoc),
-        receipts: await tx.doc(ReceiptDoc),
-    };
+    return (await import("./store.js")).inspectAuthority(tx);
 }
 export const plain = (value) => JSON.parse(JSON.stringify(value));
 export const JOURNAL_RESIDENT_LIMIT = 100;
@@ -20,7 +23,6 @@ export const JOURNAL_RESIDENT_LIMIT = 100;
 export async function event(tx, s, actor, kind, extra = {}) {
     const value = { seq: ++s.journal.seq, epoch: s.team.current.epoch, actor, kind, ...extra };
     const entry = await tx.appendEntry(s.team.current.lead, { kind: 'ptb.event', data: value });
-    s.journal.events.push({ ...value, entryId: entry.id });
-    if (s.journal.events.length > JOURNAL_RESIDENT_LIMIT)
-        s.journal.events.splice(0, s.journal.events.length - JOURNAL_RESIDENT_LIMIT);
+    s.journal.events = [...s.journal.events, { ...value, entryId: entry.id }].slice(-JOURNAL_RESIDENT_LIMIT);
+    s.flush?.();
 }

package/dist/authority/store.d.ts

@@ -0,0 +1,144 @@
+import { type Tx, type JsonObject, type ConversationId, type TaskId } from '@earendil-works/pi-durable';
+import { type GraphControlSnapshot, type GraphApplyInput, type GraphTaskTransitionInput } from './graph-control.ts';
+import { type GraphMaterializedHead, type GraphMaterializedTask } from './incremental-graph-control.ts';
+import type { GraphTaskCard } from './card-types.ts';
+import { type TeamState, type JournalState, type JournalRef, type Event, type Alert, type Obligation, type Receipt, type State } from './state.ts';
+type GraphHead = Omit<GraphMaterializedHead, 'topology' | 'projections'>;
+export interface AuthorityHead {
+    initialized: boolean;
+    legacyFenced?: boolean;
+    epoch?: string;
+    graph?: GraphHead;
+    taskCount: number;
+    log?: ConversationId;
+    journal: Omit<JournalState, 'events'> & {
+        events: string;
+    };
+    pendingBuckets: Record<string, true>;
+    unscheduledBuckets: Record<string, true>;
+    obligationSequence: number;
+    recentObligations: string[];
+    recentAlerts: string[];
+    leadAlerts: string[];
+    leadAlertCount: number;
+    obligationTail?: string;
+    alertTail?: string;
+    callTail?: string;
+    attention: Record<string, 'blocked' | 'failed'>;
+    frontier: Record<string, {
+        id: string;
+        version: string;
+        generation: number;
+    }>;
+    taskObligations: Record<string, string[]>;
+    workerBindings: Record<string, string>;
+    stopRefresh?: boolean;
+}
+export declare const HeadDoc: import("@earendil-works/pi-durable").SessionDocToken<JsonObject>;
+export declare const TaskDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const GraphIndexDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const WorkerIndexDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const OrdinalDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const OperationDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const ObligationDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const EligibilityDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const AlertDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const DirectCallDoc: import("@earendil-works/pi-durable").SessionDocFamilyToken<JsonObject, null>;
+export declare const CallDoc: import("@earendil-works/pi-durable").TaskDocToken<JsonObject>;
+export declare const taskAddress: (epoch: string, id: string) => string;
+export interface OperatorTask {
+    key: string;
+    title: string;
+    goal: string;
+    assignee: string;
+    needs: string[];
+    version: string;
+    current_context: string;
+    attempts: {
+        id: string;
+        ordinal: number;
+        startedAt?: number;
+        endedAt?: number;
+        outcome?: string;
+        evidence?: string;
+    }[];
+    derived: string;
+    status: string;
+    derivedReason?: string;
+    evidence?: string;
+}
+export interface TaskRecord {
+    materialized: GraphMaterializedTask;
+    card: GraphTaskCard;
+    operator: OperatorTask;
+}
+interface StoredCall {
+    fingerprint?: string;
+    result?: string;
+    stops?: string[];
+    epoch?: string;
+    previous?: string;
+}
+type CurrentJournal = Omit<JournalState, 'events'> & {
+    events: JournalRef[];
+};
+interface Eligibility {
+    doc: JsonObject;
+    pending: Record<string, number>;
+    unscheduled: Record<string, number>;
+}
+export interface Authority {
+    tx: Tx;
+    team: TeamState;
+    head: AuthorityHead;
+    journal: CurrentJournal;
+    headDoc: JsonObject;
+    deferFlush: boolean;
+    flush: () => void;
+    records: Map<string, TaskRecord | undefined>;
+    obligations: Map<string, Obligation>;
+    eligibility: Map<string, Eligibility>;
+    newObligations: Set<string>;
+    calls: Map<number, {
+        doc: StoredCall;
+        native: boolean;
+    }>;
+    workerIndexes: Map<string, string[]>;
+    migratedHistory?: Map<string, GraphControlSnapshot>;
+}
+export declare function recentEvents(s: Authority, refs?: JournalRef[]): Promise<Event[]>;
+export declare function flushAuthority(s: Authority): void;
+export declare function openAuthority(tx: Tx): Promise<Authority>;
+export declare function startEpoch(s: Authority, epoch: string): Promise<void>;
+export declare function taskIds(s: Authority): Promise<string[]>;
+export declare function taskRecord(s: Authority, id: string): Promise<TaskRecord | undefined>;
+export declare function taskCards(s: Authority, ids?: string[]): Promise<GraphTaskCard[]>;
+export declare function unfinished(s: Authority, worker?: string): Promise<string[]>;
+export declare function obligation(s: Authority, key: string): Promise<Obligation | undefined>;
+export declare function markScheduled(s: Authority, key: string): Promise<void>;
+export declare function unscheduledObligations(s: Authority): Promise<Obligation[]>;
+export declare function addObligation(s: Authority, value: Obligation): Promise<void>;
+export declare function setObligationState(s: Authority, value: Obligation, state: Obligation['state']): Promise<void>;
+export declare function allObligations(s: Authority): Promise<Obligation[]>;
+export declare function pendingObligations(s: Authority): Promise<Obligation[]>;
+export declare function alertRecord(s: Authority, id: string): Promise<Alert | undefined>;
+export declare function addAlert(s: Authority, value: Alert): Promise<void>;
+export declare function callReceipt(s: Authority, id: TaskId, native?: boolean): Promise<StoredCall>;
+export declare function saveCall(s: Authority, id: TaskId, receipt: Receipt): Promise<void>;
+export declare function hasOperation(s: Authority, operationId: string): Promise<boolean>;
+export declare function graphCommand(s: Authority, command: {
+    kind: 'apply';
+    input: GraphApplyInput;
+} | {
+    kind: 'transition';
+    input: GraphTaskTransitionInput;
+}, now: () => number): Promise<(import("./graph-control.ts").GraphApplyResult & {
+    replayed: boolean;
+}) | (import("./graph-control.ts").GraphTransitionResult & {
+    replayed: boolean;
+})>;
+/** History materialization for diagnostics, migration checks, and generation reconciliation. */
+export declare function readGraphHistory(s: Authority, epoch?: string): Promise<GraphControlSnapshot>;
+/** Legacy-shaped, full inspection for diagnostics and existing recovery tests. */
+export declare function inspectAuthority(tx: Tx): Promise<State>;
+export {};