@amalgm/shell 0.1.164-preview.36072132286 → 0.1.164-preview.36809057014

package/dist/detection/runtime.d.ts

@@ -1,89 +1,156 @@
-/**
- * The named Detect lane.
- *
- * A watcher path that still names enrolled, non-repository ground does not
- * justify a workspace walk. This runtime holds one SQLite connection,
- * resolves indexed paths, widens only to a named new folder's subtree, and
- * commits exact Live proposals plus local truth in one transaction. Evidence
- * it cannot prove is declined before mutation and goes to reconciliation in
- * the owning host.
- */
 import { type LocalEntityRecord, type SuspicionSnapshot } from "@amalgm/live";
+import { type GroundWriteEvidence, type GroundTransition } from "../ground-store.js";
+import { type GroundBasis } from "../ground-basis.js";
+import { type GroundLease } from "../ground-coordination.js";
+import { type RepositoryRoutes } from "./repository-routes.js";
+import { type ApplyOwnershipBlocker } from "./apply-ownership.js";
+import { type ReadyCollection } from "./dispositions.js";
 export interface NamedObservation {
     readonly directory: string;
     readonly suspicion: SuspicionSnapshot;
 }
 export interface NamedDetectEvidence {
     readonly directory: string;
-    readonly paths: number;
     readonly metadataReads: number;
+    /** Leaves whose exact metadata permitted content reuse in this capture. */
+    readonly metadataReused: number;
     readonly contentReads: number;
     readonly gitInspections: number;
     readonly repositoryCaptures: number;
     readonly plannedRows: number;
     readonly records: number;
+    /** Results Build settled against an exact accepted result: no record. */
+    readonly settled: number;
     readonly recordBytes: number;
     readonly durationMs: number;
 }
-export interface NamedDetectResult {
-    readonly handled: boolean;
+export interface NamedGitTimings {
+    /** Waiting for bindings still being discovered. */
+    readonly discoveryWaitMs: number;
+    /** Routing notice paths, consumed-binding checks included. */
+    readonly routeMs: number;
+    /** Asking Git again for consumed answers its witnesses cannot close. */
+    readonly semanticMs: number;
+}
+/** One named attempt's phases, in order: reader and ownership snapshot,
+ * repository membership, Git routing and directory proofs, address checks
+ * and byte reads, cache durability, the semantic close, the in-process ready
+ * registration, the admission transaction, and what a changed policy newly
+ * includes. */
+declare const NAMED_PHASES: readonly ["open", "members", "route", "collect", "durable", "close", "ready", "admit", "include"];
+export type NamedPhase = typeof NAMED_PHASES[number];
+export interface NamedTimings {
+    /** Milliseconds per reached phase, each since the previous reached mark. */
+    readonly phases: Readonly<Partial<Record<NamedPhase, number>>>;
+    readonly git: NamedGitTimings | null;
+}
+/** The proof a named notice lacked, which decides the wider scope it needs. */
+export type NamedWidenProof = 
+/** Git storage was named: routing changed. */
+"structural-path"
+/** The Watch root, or a named path, has no indexed active identity. */
+ | "unindexed-root" | "unindexed-path"
+/** The named ground is gone: absence needs the complete membership. */
+ | "absent-path"
+/** The notice names a root itself, which only reconciliation observes. */
+ | "root-path"
+/** A leaf inside repository territory changes that repository's state. */
+ | "repository-enclosed"
+/** The named ground's kind or sharing state differs from its row. */
+ | "kind-changed" | "unshared-leaf"
+/** A leaf's identity depends on ground beyond its scoped closure. */
+ | "identity-unproved"
+/** The leaf's address or its ancestor spine changed. */
+ | "address-changed"
+/** Selecting the leaves would change sharing outside them. */
+ | "scope-exceeded"
+/** The directory spine could not bind the name to one identity. */
+ | "named-directory"
+/** A Git storage notice has consumers in other roots. */
+ | "git-notice-consumer"
+/** A link reaching a workspace binding is a managed reference, which the
+ * complete lane reconciles with the declaration that owns it. */
+ | "managed-reference"
+/** Named ground exists but could not be read; reconciliation records the gap. */
+ | "unreadable";
+/** One explicit answer per named examination. Every non-settling answer keeps
+ * the Watch generation pending; a fault is thrown, never reported as one of
+ * these. Partial progress (committed groups) rides every answer. */
+export type NamedDetectOutcome = {
     readonly evidence: readonly NamedDetectEvidence[];
-    /** Roots whose named disappearance cannot distinguish delete from move. */
-    readonly widenedRoots?: readonly string[];
-    /** Named control ground still exists and cannot yet prove settled truth. */
-    readonly unsettled?: boolean;
+    /** Successfully observed identities, including local-only ground. */
+    readonly observedEntityIds: readonly string[];
+    /** Other addresses a committed examination found changed but did not
+     * examine; each still owes its own examination. */
+    readonly examine?: readonly string[];
+    /** Where this attempt spent its time. */
+    readonly timings?: NamedTimings;
+} & (
+/** Committed: at least one Record, no Record, or only policy-excluded leaves. */
+{
+    readonly kind: "recorded" | "unchanged" | "excluded";
+}
+/** The source moved during observation or admission. Re-read on a new
+ * basis: once the crossing effect releases, or after the racy-source timer. */
+ | {
+    readonly kind: "retry";
+    readonly reason: string;
+    readonly after: "ground-release" | "timer";
 }
+/** Apply owns part of this ground; no protected observation may settle. */
+ | {
+    readonly kind: "deferred";
+    readonly owners: readonly ApplyOwnershipBlocker[];
+}
+/** Named evidence cannot prove this. `roots` is the destination scope. */
+ | {
+    readonly kind: "widen";
+    readonly proof: NamedWidenProof;
+    readonly detail?: string;
+    readonly roots: readonly string[] | "domain";
+});
 export interface NamedRecordCommitEvidence {
+    readonly ground?: GroundWriteEvidence;
     readonly durationMs: number;
     readonly records: readonly LocalEntityRecord[];
 }
-/** One persistent, prepared Detect store. It owns no Watch or Send behavior. */
+/** Passive evidence of one successful outer Record commit, including B-only
+ * projection changes. It is not another product journal or admission input. */
+export interface DetectCommitEvidence {
+    readonly changes: readonly GroundTransition[];
+    /** Exact strings inserted into Outbox, detached from mutable proposals. */
+    readonly records: readonly string[];
+}
+/** One persistent, prepared Detect store. It owns no Watch or Send behavior;
+ * attempts on different roots run concurrently, each with its own state. */
 export declare class NamedDetectRuntime {
-    private readonly database;
-    private readonly cacheDir;
-    private readonly userRoot;
-    private readonly rootAtDirectory;
-    private readonly rowAtPath;
-    private readonly rowAtUuid;
-    private readonly rowsUnderPath;
-    private readonly rowsAtPhysicalIdentity;
-    private readonly notebookChildren;
-    private readonly materializedSiblings;
-    /** One frozen sibling snapshot per Detect pass: collision-derived names
-     * are computed once per parent, never once per captured file. */
-    private readonly slotNamesByParent;
-    private readonly materializedByUuid;
-    private readonly writeEntity;
-    private readonly writeNotebook;
-    private readonly appendRecord;
-    private readonly receivedThrough;
-    private readonly acceptedInbox;
-    private readonly onRecordCommit?;
-    private userPolicy;
-    private walkedEntries;
-    constructor(databaseFile: string, cacheDir: string, userRoot: string, onRecordCommit?: (evidence: NamedRecordCommitEvidence) => void);
+    private readonly store;
+    constructor(databaseFile: string, cacheDir: string, bindingDir: string, onRecordCommit?: (evidence: NamedRecordCommitEvidence) => void, measureGround?: () => boolean, onDetectCommit?: (evidence: DetectCommitEvidence) => void, 
+    /** Rings a checkout whose Git binding was refreshed after its witness moved. */
+    rebound?: (checkout: string) => void);
+    /** Startup discovery binds every enrolled repository in the background, so
+     * no first notice pays for all of them. */
+    discover(): void;
     close(): void;
-    refreshEnrollmentPolicy(): void;
-    detect(observations: readonly NamedObservation[]): Promise<NamedDetectResult>;
-    /** A known leaf edit inside one repository is still named evidence. It
-     * updates that leaf's local identity proof, then records one nearest-repo
-     * Card + Checkpoint transition. Ambiguous structure and rail changes widen
-     * to reconciliation before this method mutates SQLite. */
-    private detectRepository;
-    private repositoryAtPath;
-    private previewRecordJson;
-    private appendOutboxRecord;
-    private entityReceivedThrough;
-    /** Derived collision names are local addresses, not portable renames. A
-     * same-parent observation at either the portable name or the exact address
-     * derived from the current sibling set keeps the stored portable name. A
-     * different parent, or any third basename, is real move/rename evidence. */
-    private capturedName;
-    private captureFile;
-    private captureDirectory;
-    private captureLink;
-    private enclosedByRepository;
-    private readUserPolicy;
-    private uniqueMovedBase;
-    private replayFor;
+    /** The repositories escalated names reach, by this runtime's Git bindings. */
+    repositoryRoutes(directory: string, paths: readonly string[]): Promise<RepositoryRoutes>;
+    /** Named names split by the lane that proves them. A name in Git storage or
+     * inside an indexed repository belongs to its repository's examination;
+     * every other name is proved as a named leaf. The index is only a routing
+     * hint: each lane re-reads the real routes, and a wrong hint widens. */
+    repositoryNames(directory: string, paths: readonly string[]): {
+        readonly leaves: readonly string[];
+        readonly repositories: readonly string[];
+    };
+    /** A blocked batch does not own unrelated named leaves. Retry its independent
+     * names without settling the original Watch generation. */
+    detectAvailable(observation: NamedObservation, register: (unit: string, basis: GroundBasis) => ReadyCollection, lease: GroundLease): Promise<NamedDetectOutcome>;
+    /** The physical footprint a lane's proof of these paths reads: each path's
+     * subtree, or its nearest indexed repository's whole root and any Git
+     * storage kept outside it, plus the root's enrollment policy. Ancestors
+     * need no lease of their own: an effect on any ancestor overlaps these
+     * cones. An index that changes before admission fails the ground basis
+     * there; storage the observed binding names must lie inside the lease. */
+    footprint(directory: string, paths: readonly string[]): string[];
 }
+export {};