@llblab/pi-kit 0.18.1 → 0.19.0

package/node_modules/@llblab/pi-state-flow/dist/lib/runtime.d.ts

@@ -1,132 +1,69 @@
 import { type SessionAddress } from "./durable.ts";
 import { type ArtifactProvenance, type ArtifactProvenanceRegistry } from "./artifact.ts";
-import { publishTemporalStateToGit } from "./git.ts";
+import { publishTemporalStateToFiles } from "./storage.ts";
 import { type AcceptedTransition, type RecentTransitionWindow } from "./history.ts";
-import { type Snapshot } from "./snapshot.ts";
+import { type RetainedBoundaryCheckpoint, type RetainedPiCheckpoint, type Snapshot } from "./snapshot.ts";
 import { type MaterializedState, type ScopedStates, type StateScope } from "./state.ts";
-import { type ScopeStream, type TemporalState } from "./temporal.ts";
-export type RuntimePublication = ReturnType<typeof publishTemporalStateToGit> & {
-    revision?: string;
-};
+import { type TemporalState } from "./temporal.ts";
+export type RuntimePublication = ReturnType<typeof publishTemporalStateToFiles>;
 /** A targeted removed scope was deliberately adopted as empty before refusing the stale semantic patch. */
 export declare class SharedScopeRemovalConflictError extends Error {
     readonly scopes: readonly StateScope[];
     constructor(scopes: readonly StateScope[]);
 }
-export declare class MissingSessionRuntimeError extends Error {
-    constructor();
-}
-/** Immutable target validation is independent of acquiring the live publication basis. */
-export declare function inspectRuntimeRevision(cwd: string, sessionId: string, root: string, revision: string, sessionKey?: string): {
-    runtime: {
-        document: import("./snapshot.ts").SessionRuntime;
-        revision: string;
-    };
-    resolved: {
-        snapshot: Snapshot;
-        lineage: import("./temporal.ts").TransitionBoundary[];
-        publicationTarget: string;
-        artifacts: ArtifactProvenanceRegistry;
-    };
-    view: {
-        lineage: import("./temporal.ts").TransitionBoundary[];
-        scopes: {
-            global: ScopeStream;
-            cwd: ScopeStream;
-            session: ScopeStream;
-        };
-    };
-    provenance: Record<StateScope, ArtifactProvenanceRegistry>;
-};
-/** Validate one supported immutable target before any live migration/publication. */
-export declare function inspectSnapshotRevision(cwd: string, sessionId: string, root: string, revision: string, _legacySnapshot?: Snapshot, sessionKey?: string): {
-    snapshot: import("./snapshot.ts").StateFlowSnapshot;
-    file: {
-        runtime: import("./snapshot.ts").SessionRuntime;
-        view: {
-            scopes: Record<StateScope, ScopeStream>;
-            lineage: import("./temporal.ts").TransitionBoundary[];
-        };
-        provenance: Record<StateScope, ArtifactProvenanceRegistry>;
-        base: {
-            files: import("./durable.ts").DurableFileBase[];
-        };
-        revision: `file:${string}`;
-    };
-    temporal?: undefined;
-} | {
-    file?: undefined;
-    snapshot: import("./snapshot.ts").StateFlowSnapshot;
-    temporal: {
-        runtime: {
-            document: import("./snapshot.ts").SessionRuntime;
-            revision: string;
-        };
-        resolved: {
-            snapshot: Snapshot;
-            lineage: import("./temporal.ts").TransitionBoundary[];
-            publicationTarget: string;
-            artifacts: ArtifactProvenanceRegistry;
-        };
-        view: {
-            lineage: import("./temporal.ts").TransitionBoundary[];
-            scopes: {
-                global: ScopeStream;
-                cwd: ScopeStream;
-                session: ScopeStream;
-            };
-        };
-        provenance: Record<StateScope, ArtifactProvenanceRegistry>;
-    };
-};
 /** Cached branch-selected temporal state and publication basis; excludes Pi event policy. */
 export declare class TemporalRuntime {
     view: TemporalState | undefined;
     private base;
     private semanticRevision;
     private savedRuntime;
-    private backend;
+    private restoredOriginPending;
     private provenanceByScope;
     /** Shared scopes whose wholly absent live basis was accepted after one stale-target refusal. */
     private readonly absentSharedScopes;
     readonly cwd: string;
     private readonly session;
     readonly root: string;
-    constructor(cwd: string, session: string | SessionAddress, root: string, sessionKey?: string);
+    readonly historyLimit: number;
+    constructor(cwd: string, session: string | SessionAddress, root: string, sessionKey?: string, historyLimit?: number);
     get sessionId(): string;
     get sessionKey(): string;
-    /** Runtime-owned artifact freshness evidence for one scope; never model-visible state. */
+    /** Runtime-owned artifact compilation evidence for one scope; never model-visible state. */
     artifactProvenance(scope: StateScope): ArtifactProvenanceRegistry;
     /** Read canonical shared memory without creating, migrating, or publishing storage. */
     loadPassive(): boolean;
-    /** Explicit start owns directory/repository creation; reads never call this. */
+    /** Select canonical file acceptance even when Git is available; backup remains a later concern. */
+    prepareCanonical(): void;
+    /** Canonical preparation is the default; Git backup is a later independent concern. */
     prepare(): void;
-    /** Explicit start migrates a predecessor envelope even when passive restore already populated the cache. */
-    migrateLegacyStorage(): void;
-    /** Explicit start can upgrade a proven file cohort; failed adoption leaves the cache in file mode. */
-    promote(snapshot: Snapshot): RuntimePublication | undefined;
     read(offset?: number, scope?: StateScope): MaterializedState;
     states(): ScopedStates;
     causalBasis(): string;
+    /** Encode Pi lifecycle state against the current retained semantic boundary. */
+    retainedCheckpoint(snapshot: Snapshot): RetainedPiCheckpoint;
+    usesCanonicalFiles(): boolean;
     recent(): RecentTransitionWindow;
-    /** Validate selection without installing state; only a matching immutable Git inspection is reusable. */
-    prepareRestore(revision: string, legacySnapshot?: Snapshot): {
+    /** Prepare a retained session boundary from current canonical files; shared scopes remain live. */
+    prepareBoundaryRestore(checkpoint: RetainedBoundaryCheckpoint): {
         snapshot: Snapshot;
         restore: () => Snapshot;
     };
-    /** Copy only a proven source session stream; shared streams come from the child's fresh live basis. */
-    prepareFork(source: SessionAddress, revision: string): {
+    /** Restore and canonically accept one retained boundary as a single lifecycle operation. */
+    restoreBoundary(checkpoint: RetainedBoundaryCheckpoint): {
+        snapshot: Snapshot;
+        publication: RuntimePublication;
+    };
+    /** Copy one retained source-session boundary over the child's current shared scopes. */
+    prepareBoundaryFork(source: SessionAddress, checkpoint: RetainedBoundaryCheckpoint): {
         snapshot: Snapshot;
         fork: () => {
             snapshot: Snapshot;
             publication: RuntimePublication;
         };
     };
-    restore(revision: string, legacySnapshot?: Snapshot): Snapshot;
-    private restoreInspected;
     initialize(snapshot: Snapshot, allowCreateCwd: boolean, expectedShared?: Pick<ScopedStates, "global" | "cwd">, newSessionOrigin?: boolean): RuntimePublication | undefined;
     private initializeOrigin;
-    /** Initial copy owns only the new session files, without pruning or rewriting shared provenance. */
+    /** Copy the private origin and apply configured retention folding, preserving live shared values/provenance. */
     private publishForkOrigin;
     /**
      * Reconcile untouched shared-scope drift against the current proven live basis.
@@ -137,8 +74,9 @@ export declare class TemporalRuntime {
      * session or runtime files also fails closed under the existing race rule.
      */
     private reconcileSharedDrift;
+    /** Canonically accept a prepared retained-boundary origin before lifecycle-only persistence. */
+    acceptRestoredOrigin(snapshot: Snapshot): RuntimePublication;
     publish(snapshot: Snapshot, semantic?: boolean, accepted?: AcceptedTransition, options?: {
-        pushRemote?: boolean;
         provenance?: Partial<Record<StateScope, Record<string, ArtifactProvenance>>>;
     }): RuntimePublication | undefined;
 }