@amalgm/live 0.1.0

package/dist/detection/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/detection/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,QAAQ,GAAG,aAAa,GAAG,WAAW,CAAC;AAEnD,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAgB,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,gBAAgB,GAAG,QAAQ,CAEnE"}

package/dist/detection/classify.js

@@ -0,0 +1,28 @@
+/**
+ * Amalgm's file-type policy: which physical type a piece of file ground
+ * takes. Ratified by entity-model.md ("Formats live underneath the file
+ * types"; text versus binary is an adapter difference, never an
+ * identity difference).
+ *
+ * Classification is an INJECTED policy everywhere it is used — the
+ * registration boundary and its lenses refuse to construct without one
+ * — so it lives in its own file with no other job: one definition,
+ * replaceable whole.
+ *
+ * The rule is the oldest one there is: bytes holding a NUL are not
+ * text. What matters is WHERE that fact comes from. It is not read
+ * here. Detect's single read of a file produces its fingerprint and
+ * this report together, and this policy only names the type that report
+ * implies.
+ *
+ * That is the whole law: A FILE'S HASH AND ITS TYPE DESCRIBE THE SAME
+ * OBSERVED BYTES. A policy that opened the ground itself would be a
+ * second look — and a second look can meet different bytes, or none at
+ * all, leaving a record whose type contradicts the payload beside it.
+ * So this function takes evidence, never a path; it is total, and it
+ * cannot fail.
+ */
+export function classifyFile({ binary }) {
+    return binary ? 'file.binary' : 'file.text';
+}
+//# sourceMappingURL=classify.js.map

package/dist/detection/classify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/detection/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AASH,MAAM,UAAU,YAAY,CAAC,EAAE,MAAM,EAAoB;IACvD,OAAO,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC;AAC9C,CAAC"}

package/dist/detection/continuity.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Root continuity verdicts: what a root's WITNESSED physical identity
+ * is, whether its recorded address still holds its ground, and whether
+ * a piece of ground rescues a moved root. Ratified by entity-model.md
+ * ("Ground that moves is rescued by continuity" — the directory law
+ * lifted to roots; "the follow rides witnessed continuity, never
+ * clairvoyance").
+ *
+ * Pure verdicts over injected answers — the host supplies the one look
+ * at an address (`statAt`) and the store's witnessed channel row
+ * (`channelIdentity`); the ACTIONS a verdict triggers (rebind, presence
+ * transitions, the undecided-address decision) stay in the host's
+ * wiring, because they re-aim watchers and scans.
+ */
+import type { PhysicalIdentity } from './diff.js';
+import type { RootKind } from './coverage.js';
+/** What one look at an address found standing there. */
+export type GroundKind = 'file' | 'dir' | 'link' | 'other';
+export interface GroundStat extends PhysicalIdentity {
+    readonly kind: GroundKind;
+}
+export interface ContinuityRoot {
+    readonly rootId: string;
+    readonly path: string;
+    readonly kind: RootKind;
+    /** Directory roots: the root's own witnessed identity; null/absent when unwitnessed. */
+    readonly device?: number | null;
+    readonly inode?: number | null;
+}
+export interface ContinuityPorts {
+    /**
+     * One look at an address: the ground's physical identity and kind, or
+     * null when the look did not return ground. ANY failed look answers
+     * null here — at the evidence horizon's edge, "could not look" and
+     * "not there" both leave the address undecided, so this seam never
+     * needs the absent/unsettled split.
+     */
+    readonly statAt: (path: string) => GroundStat | null;
+    /**
+     * A single-ground root's one channel row identity — current as of the
+     * last completed scan — or null when unwitnessed. The file laws
+     * absorb atomic-save and retarget churn each time a scan witnesses
+     * the ground, and continuity can only ever claim what a scan has
+     * witnessed.
+     */
+    readonly channelIdentity: (rootId: string) => PhysicalIdentity | null;
+}
+export interface ContinuityVerdicts {
+    readonly rootIdentity: (root: ContinuityRoot) => PhysicalIdentity | null;
+    readonly findMovedRoot: (stat: GroundStat, roots: readonly ContinuityRoot[]) => ContinuityRoot | null;
+    readonly addressUndecided: (root: ContinuityRoot) => boolean;
+}
+export declare function createContinuity({ statAt, channelIdentity }: ContinuityPorts): ContinuityVerdicts;
+//# sourceMappingURL=continuity.d.ts.map

package/dist/detection/continuity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"continuity.d.ts","sourceRoot":"","sources":["../../src/detection/continuity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,wDAAwD;AACxD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,UAAW,SAAQ,gBAAgB;IAClD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,GAAG,IAAI,CAAC;IACrD;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,gBAAgB,GAAG,IAAI,CAAC;CACvE;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,gBAAgB,GAAG,IAAI,CAAC;IACzE,QAAQ,CAAC,aAAa,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,KAAK,cAAc,GAAG,IAAI,CAAC;IACtG,QAAQ,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,CAAC;CAC9D;AAED,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,eAAe,EAAE,EAAE,eAAe,GAAG,kBAAkB,CAmEjG"}

package/dist/detection/continuity.js

@@ -0,0 +1,85 @@
+/**
+ * Root continuity verdicts: what a root's WITNESSED physical identity
+ * is, whether its recorded address still holds its ground, and whether
+ * a piece of ground rescues a moved root. Ratified by entity-model.md
+ * ("Ground that moves is rescued by continuity" — the directory law
+ * lifted to roots; "the follow rides witnessed continuity, never
+ * clairvoyance").
+ *
+ * Pure verdicts over injected answers — the host supplies the one look
+ * at an address (`statAt`) and the store's witnessed channel row
+ * (`channelIdentity`); the ACTIONS a verdict triggers (rebind, presence
+ * transitions, the undecided-address decision) stay in the host's
+ * wiring, because they re-aim watchers and scans.
+ */
+export function createContinuity({ statAt, channelIdentity }) {
+    /**
+     * A root's WITNESSED physical identity, for continuity rescue.
+     * Directory roots carry their own device:inode (nothing replaces a
+     * directory's inode in place). A single-ground root's identity lives
+     * in its one channel row. Ground that changed inodes inside a
+     * still-open settle window is unwitnessed — no evidence, no claim.
+     */
+    function rootIdentity(root) {
+        if (root.kind !== 'file') {
+            const { device, inode } = root;
+            return device == null || inode == null ? null : { device, inode };
+        }
+        return channelIdentity(root.rootId);
+    }
+    /** Orphaned means the recorded address no longer holds this ground. */
+    function orphanedAtAddress(root) {
+        const identity = rootIdentity(root);
+        if (!identity)
+            return false;
+        const stat = statAt(root.path);
+        if (!stat)
+            return true;
+        return stat.device !== identity.device || stat.inode !== identity.inode;
+    }
+    /**
+     * Continuity claims a root exactly like it claims the directories
+     * inside one: unique device:inode match, exactly one candidate, and
+     * only for a path-orphan — a root whose recorded address still holds
+     * its ground is never stolen by a lookalike.
+     */
+    function findMovedRoot(stat, roots) {
+        const wantDir = stat.kind === 'dir';
+        const matches = roots.filter((root) => {
+            if (wantDir !== (root.kind !== 'file'))
+                return false;
+            const identity = rootIdentity(root);
+            return identity !== null && identity.device === stat.device && identity.inode === stat.inode;
+        });
+        const only = matches.length === 1 ? matches[0] : null;
+        return only && orphanedAtAddress(only) ? only : null;
+    }
+    /**
+     * A scan's evidence horizon is the root's ground; the root's own
+     * address is the horizon's edge. Ground missing there — or a
+     * directory root's address wearing a different physical identity — is
+     * UNDECIDABLE from here: moved away, deleted, or replaced by a
+     * lookalike all present the same address, and concluding "deleted"
+     * would end every channel a rescue could have saved. So the scan
+     * concludes nothing: beliefs freeze, the referee convicts the
+     * divergence, and the next enrollment moment decides — naming the new
+     * address rescues, re-naming this one adopts, and explicit removal is
+     * the only deletion (an external filesystem change is never
+     * permission to end identity). A single-ground root's address
+     * lawfully churns inodes (atomic saves, retargets), so only absence —
+     * or foreign directory ground — freezes it; presence is the file
+     * laws' business.
+     */
+    function addressUndecided(root) {
+        const stat = statAt(root.path);
+        if (!stat)
+            return true;
+        if (root.kind === 'file')
+            return stat.kind !== 'file' && stat.kind !== 'link';
+        if (stat.kind !== 'dir')
+            return true;
+        return root.device != null && (stat.device !== root.device || stat.inode !== root.inode);
+    }
+    return { rootIdentity, findMovedRoot, addressUndecided };
+}
+//# sourceMappingURL=continuity.js.map

package/dist/detection/continuity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"continuity.js","sourceRoot":"","sources":["../../src/detection/continuity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA8CH,MAAM,UAAU,gBAAgB,CAAC,EAAE,MAAM,EAAE,eAAe,EAAmB;IAC3E;;;;;;OAMG;IACH,SAAS,YAAY,CAAC,IAAoB;QACxC,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YACzB,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;YAC/B,OAAO,MAAM,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;QACpE,CAAC;QACD,OAAO,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAED,uEAAuE;IACvE,SAAS,iBAAiB,CAAC,IAAoB;QAC7C,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,QAAQ;YAAE,OAAO,KAAK,CAAC;QAC5B,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,OAAO,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK,CAAC;IAC1E,CAAC;IAED;;;;;OAKG;IACH,SAAS,aAAa,CAAC,IAAgB,EAAE,KAAgC;QACvE,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC;QACpC,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;YACpC,IAAI,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC;gBAAE,OAAO,KAAK,CAAC;YACrD,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;YACpC,OAAO,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC;QAC/F,CAAC,CAAC,CAAC;QACH,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACvD,OAAO,IAAI,IAAI,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IACvD,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,SAAS,gBAAgB,CAAC,IAAoB;QAC5C,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC;QAC9E,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK;YAAE,OAAO,IAAI,CAAC;QACrC,OAAO,IAAI,CAAC,MAAM,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3F,CAAC;IAED,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,CAAC;AAC3D,CAAC"}

package/dist/detection/coverage.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The coverage law: one OS watcher per outermost tree. Ratified by
+ * entity-model.md (enclosed-ground coverage) and
+ * entity-implementation.md (the doorbell matrix).
+ *
+ * A recursive watcher on a directory hears every event beneath it, at
+ * any depth — so a root enclosed by watched ground already has its
+ * content observed, exactly as its ADDRESS is already observed. Opening
+ * a second watcher over enclosed ground buys nothing on any platform
+ * and, on Linux — where a recursive watch is silently one inotify slot
+ * PER DIRECTORY against a small kernel budget — exhausts the kernel.
+ * Doorbells are shared; what a root DOES with its dings (files
+ * channels, repo Card+Checkpoint) stays its own type's business.
+ *
+ * Pure functions over root rows — no handles, no state. The host owns
+ * opening and closing; this module only answers "who guards whom".
+ * Addresses are absolute '/'-separated paths with no trailing
+ * separator, as the enrollment boundary records them.
+ */
+/** The three root kinds; only 'file' changes a doorbell's ground. */
+export type RootKind = 'file' | 'files' | 'repo';
+export interface WatchRoot {
+    readonly rootId: string;
+    readonly path: string;
+    readonly kind: RootKind;
+}
+/**
+ * The ground a root's doorbell must cover: a directory root guards
+ * itself; a single-file root's bell lives on its parent directory (the
+ * file's own inode goes deaf on atomic saves).
+ */
+export declare function doorbellGround(root: WatchRoot): string;
+/**
+ * The root whose OS watcher covers `root`'s doorbell ground, or null
+ * when `root` guards itself. The OUTERMOST enclosing directory root
+ * wins: with A ⊃ B ⊃ C only A holds a handle, and every deeper root —
+ * B, C, nested repos, single files — rides it. A file root can never
+ * cover anything.
+ */
+export declare function watchOwnerOf(root: WatchRoot, roots: readonly WatchRoot[]): WatchRoot | null;
+/** Every live root covered by `owner` (owner excluded). */
+export declare function coveredRoots(owner: WatchRoot, roots: readonly WatchRoot[]): WatchRoot[];
+//# sourceMappingURL=coverage.d.ts.map

package/dist/detection/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/detection/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,qEAAqE;AACrE,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAEjD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB;AASD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAEtD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,CAS3F;AAED,2DAA2D;AAC3D,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAGvF"}

package/dist/detection/coverage.js

@@ -0,0 +1,60 @@
+/**
+ * The coverage law: one OS watcher per outermost tree. Ratified by
+ * entity-model.md (enclosed-ground coverage) and
+ * entity-implementation.md (the doorbell matrix).
+ *
+ * A recursive watcher on a directory hears every event beneath it, at
+ * any depth — so a root enclosed by watched ground already has its
+ * content observed, exactly as its ADDRESS is already observed. Opening
+ * a second watcher over enclosed ground buys nothing on any platform
+ * and, on Linux — where a recursive watch is silently one inotify slot
+ * PER DIRECTORY against a small kernel budget — exhausts the kernel.
+ * Doorbells are shared; what a root DOES with its dings (files
+ * channels, repo Card+Checkpoint) stays its own type's business.
+ *
+ * Pure functions over root rows — no handles, no state. The host owns
+ * opening and closing; this module only answers "who guards whom".
+ * Addresses are absolute '/'-separated paths with no trailing
+ * separator, as the enrollment boundary records them.
+ */
+/** '/a/b' → '/a'; '/a' → '/'; a bare name → '.'. */
+const parentDirOf = (path) => {
+    const cut = path.lastIndexOf('/');
+    if (cut < 0)
+        return '.';
+    return cut === 0 ? '/' : path.slice(0, cut);
+};
+/**
+ * The ground a root's doorbell must cover: a directory root guards
+ * itself; a single-file root's bell lives on its parent directory (the
+ * file's own inode goes deaf on atomic saves).
+ */
+export function doorbellGround(root) {
+    return root.kind === 'file' ? parentDirOf(root.path) : root.path;
+}
+/**
+ * The root whose OS watcher covers `root`'s doorbell ground, or null
+ * when `root` guards itself. The OUTERMOST enclosing directory root
+ * wins: with A ⊃ B ⊃ C only A holds a handle, and every deeper root —
+ * B, C, nested repos, single files — rides it. A file root can never
+ * cover anything.
+ */
+export function watchOwnerOf(root, roots) {
+    const ground = doorbellGround(root);
+    let owner = null;
+    for (const other of roots) {
+        if (other.rootId === root.rootId || other.kind === 'file')
+            continue;
+        if (ground !== other.path && !ground.startsWith(`${other.path}/`))
+            continue;
+        if (!owner || other.path.length < owner.path.length)
+            owner = other;
+    }
+    return owner;
+}
+/** Every live root covered by `owner` (owner excluded). */
+export function coveredRoots(owner, roots) {
+    return roots.filter((root) => root.rootId !== owner.rootId
+        && watchOwnerOf(root, roots)?.rootId === owner.rootId);
+}
+//# sourceMappingURL=coverage.js.map

package/dist/detection/coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.js","sourceRoot":"","sources":["../../src/detection/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAWH,oDAAoD;AACpD,MAAM,WAAW,GAAG,CAAC,IAAY,EAAU,EAAE;IAC3C,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAClC,IAAI,GAAG,GAAG,CAAC;QAAE,OAAO,GAAG,CAAC;IACxB,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC9C,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,IAAe;IAC5C,OAAO,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;AACnE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,IAAe,EAAE,KAA2B;IACvE,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,KAAK,GAAqB,IAAI,CAAC;IACnC,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;QAC1B,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM;YAAE,SAAS;QACpE,IAAI,MAAM,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,KAAK,CAAC,IAAI,GAAG,CAAC;YAAE,SAAS;QAC5E,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM;YAAE,KAAK,GAAG,KAAK,CAAC;IACrE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,YAAY,CAAC,KAAgB,EAAE,KAA2B;IACxE,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;WACrD,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC;AAC3D,CAAC"}

package/dist/detection/diff.d.ts

@@ -0,0 +1,144 @@
+/**
+ * The compare core of detection: rows (store memory) + entries (disk
+ * truth) in, actions out. Pure — the walk that produces entries and the
+ * hashing that settles `checks` are the host's; only the identity
+ * verdicts live here. Ratified by entity-model.md ("Address and
+ * physical continuity are the two identity witnesses, never content").
+ *
+ * Three kinds of channel, three orderings of the same two witnesses:
+ *
+ *  - Files: path claims first; the inode rescues path-orphans. An
+ *    atomic save replaces a file's inode in place, so the address must
+ *    absorb that churn.
+ *  - Directories: physical continuity claims first; the address claims
+ *    what no inode claims. Nothing replaces a directory's inode in
+ *    place, so a known inode at a new address IS the directory, moved.
+ *  - Links: the FILE rules, for the file reason — retarget is unlink +
+ *    recreate, so the inode churns exactly like an atomic save.
+ */
+/** One piece of ground's physical identity: device:inode. */
+export interface PhysicalIdentity {
+    readonly device: number;
+    readonly inode: number;
+}
+/** A row and an entry the compare has bound to one channel. */
+export interface Match<Row, Entry> {
+    readonly row: Row;
+    readonly entry: Entry;
+}
+/** Disk truth for one file, as the walk reported it. */
+export interface FileEntry extends PhysicalIdentity {
+    readonly relPath: string;
+    readonly size: number;
+    readonly mtimeMs: number;
+}
+/** Store memory for one file channel. `hashedAtMs` is the instant the bytes were last read. */
+export interface FileRow extends PhysicalIdentity {
+    readonly fileId: string;
+    readonly relPath: string;
+    readonly size: number;
+    readonly mtimeMs: number;
+    readonly hashedAtMs?: number | null;
+}
+export interface DirEntry extends PhysicalIdentity {
+    readonly relPath: string;
+}
+export interface DirRow extends PhysicalIdentity {
+    readonly dirId: string;
+    readonly relPath: string;
+}
+/** Disk truth for one symlink: the written target text, read at walk time, never followed. */
+export interface LinkEntry extends PhysicalIdentity {
+    readonly relPath: string;
+    readonly target: string;
+}
+export interface LinkRow extends PhysicalIdentity {
+    readonly linkId: string;
+    readonly relPath: string;
+    readonly target: string;
+}
+/**
+ * Physical continuity, shared by every compare function: a row and an
+ * entry sharing one device:inode, exactly one match on both sides → the
+ * same physical thing. Anything else is never guessed. For files this
+ * rescues path-orphans (rule 2); for directories it IS rule 1.
+ */
+export declare function matchByInode<Row extends PhysicalIdentity, Entry extends PhysicalIdentity>(rows: readonly Row[], entries: readonly Entry[]): Array<Match<Row, Entry>>;
+export interface DirDiff {
+    readonly renames: Array<Match<DirRow, DirEntry>>;
+    readonly retags: Array<Match<DirRow, DirEntry>>;
+    readonly creates: DirEntry[];
+    readonly deletes: DirRow[];
+}
+/**
+ * The compare function for directory channels — the file identity rules
+ * in the OPPOSITE order, for the mirror reason. A file's inode is
+ * replaced in place on every atomic save, so for files the path must
+ * absorb that churn (path claims first). Nothing replaces a directory's
+ * inode in place: a known inode at a new address IS the directory,
+ * moved — even when its old address was reoccupied in the same interval
+ * (two directories exchanging names cross by inode, exactly like the
+ * files inside them). So:
+ *  1. Physical continuity claims the channel: unique device:inode,
+ *     whole sets, same path = continued, new path = rename.
+ *  2. The address claims what no inode claims — recreation under an old
+ *     name is the same channel wearing a never-seen inode (`retags`,
+ *     silent).
+ *  3. Leftover entries are creates; leftover rows are deletes.
+ * No content: a directory's membership is derived state upstream, so
+ * there is nothing to hash or check.
+ */
+export declare function diffDirState(rows: readonly DirRow[], entries: readonly DirEntry[]): DirDiff;
+export interface LinkDiff {
+    readonly changes: Array<Match<LinkRow, LinkEntry>>;
+    readonly retags: Array<Match<LinkRow, LinkEntry>>;
+    readonly renames: Array<Match<LinkRow, LinkEntry>>;
+    readonly creates: LinkEntry[];
+    readonly deletes: LinkRow[];
+}
+/**
+ * The compare function for link channels — the FILE identity rules, for
+ * the file reason: a symlink cannot be retargeted in place (retarget is
+ * unlink + recreate, so the inode churns exactly like an atomic save),
+ * so the path absorbs that churn and claims first; the inode rescues
+ * path-orphans (`mv` preserves a symlink's inode). The payload is the
+ * target string, already read at walk time. A consequence worth naming:
+ * two links exchanging names read as two retargets (path-first),
+ * because a link's meaning IS its written address.
+ *  1. Path claims the channel: same target = continued (a new inode
+ *     under an old name with an old target is silent recreation),
+ *     different target = changed.
+ *  2. Inode rescues path-orphans: renames.
+ *  3. Leftover entries are creates; leftover rows are deletes.
+ */
+export declare function diffLinkState(rows: readonly LinkRow[], entries: readonly LinkEntry[]): LinkDiff;
+export interface RootDiff {
+    /** Files whose content must be read before an event may be claimed. */
+    readonly checks: Array<Match<FileRow, FileEntry>>;
+    readonly renames: Array<Match<FileRow, FileEntry>>;
+    readonly creates: FileEntry[];
+    readonly deletes: FileRow[];
+    readonly unchanged: number;
+}
+/**
+ * The compare function for file channels — doorbells and rescans both
+ * end here. Hashing is deferred — `checks` name the files whose content
+ * must be read before an event may be claimed.
+ *
+ * Identity rules, in order:
+ *  1. Path claims the channel. Same rel_path = same file_id, even when
+ *     the inode changed (atomic saves replace the inode on every
+ *     write).
+ *  2. Inode rescues path-orphans (matchByInode above).
+ *  3. Leftover entries are creates; leftover rows are deletes.
+ *
+ * The single stat-shortcut this layer allows itself: a (size, mtime,
+ * inode) triple identical to the stored one is skipped as unchanged —
+ * but only when the mtime is strictly older than the moment we last
+ * read the bytes (git's "racily clean" rule), and only when nothing
+ * pointed at the file. A path named in `mustCheck` (the doorbell said
+ * so) is always hashed: timestamps can lie, a delivered watcher event
+ * cannot be un-delivered.
+ */
+export declare function diffRootState(rows: readonly FileRow[], entries: readonly FileEntry[], mustCheck?: ReadonlySet<string> | null): RootDiff;
+//# sourceMappingURL=diff.d.ts.map

package/dist/detection/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/detection/diff.ts"],"names":[],"mappings":"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"}

package/dist/detection/diff.js

@@ -0,0 +1,187 @@
+/**
+ * The compare core of detection: rows (store memory) + entries (disk
+ * truth) in, actions out. Pure — the walk that produces entries and the
+ * hashing that settles `checks` are the host's; only the identity
+ * verdicts live here. Ratified by entity-model.md ("Address and
+ * physical continuity are the two identity witnesses, never content").
+ *
+ * Three kinds of channel, three orderings of the same two witnesses:
+ *
+ *  - Files: path claims first; the inode rescues path-orphans. An
+ *    atomic save replaces a file's inode in place, so the address must
+ *    absorb that churn.
+ *  - Directories: physical continuity claims first; the address claims
+ *    what no inode claims. Nothing replaces a directory's inode in
+ *    place, so a known inode at a new address IS the directory, moved.
+ *  - Links: the FILE rules, for the file reason — retarget is unlink +
+ *    recreate, so the inode churns exactly like an atomic save.
+ */
+/**
+ * Physical continuity, shared by every compare function: a row and an
+ * entry sharing one device:inode, exactly one match on both sides → the
+ * same physical thing. Anything else is never guessed. For files this
+ * rescues path-orphans (rule 2); for directories it IS rule 1.
+ */
+export function matchByInode(rows, entries) {
+    const one = (map, key, value) => map.set(key, map.has(key) ? 'many' : value);
+    const rowsByInode = new Map();
+    for (const row of rows)
+        one(rowsByInode, `${row.device}:${row.inode}`, row);
+    const entriesByInode = new Map();
+    for (const entry of entries)
+        one(entriesByInode, `${entry.device}:${entry.inode}`, entry);
+    const matched = [];
+    for (const [key, entry] of entriesByInode) {
+        const row = rowsByInode.get(key);
+        if (entry === 'many' || !row || row === 'many')
+            continue;
+        matched.push({ row, entry });
+    }
+    return matched;
+}
+/**
+ * The compare function for directory channels — the file identity rules
+ * in the OPPOSITE order, for the mirror reason. A file's inode is
+ * replaced in place on every atomic save, so for files the path must
+ * absorb that churn (path claims first). Nothing replaces a directory's
+ * inode in place: a known inode at a new address IS the directory,
+ * moved — even when its old address was reoccupied in the same interval
+ * (two directories exchanging names cross by inode, exactly like the
+ * files inside them). So:
+ *  1. Physical continuity claims the channel: unique device:inode,
+ *     whole sets, same path = continued, new path = rename.
+ *  2. The address claims what no inode claims — recreation under an old
+ *     name is the same channel wearing a never-seen inode (`retags`,
+ *     silent).
+ *  3. Leftover entries are creates; leftover rows are deletes.
+ * No content: a directory's membership is derived state upstream, so
+ * there is nothing to hash or check.
+ */
+export function diffDirState(rows, entries) {
+    const matched = matchByInode(rows, entries);
+    const matchedRowIds = new Set(matched.map((pair) => pair.row.dirId));
+    const matchedEntries = new Set(matched.map((pair) => pair.entry));
+    const rowsByPath = new Map(rows.filter((row) => !matchedRowIds.has(row.dirId))
+        .map((row) => [row.relPath, row]));
+    const retags = [];
+    const creates = [];
+    for (const entry of entries) {
+        if (matchedEntries.has(entry))
+            continue;
+        const row = rowsByPath.get(entry.relPath);
+        if (row) {
+            rowsByPath.delete(entry.relPath);
+            retags.push({ row, entry });
+        }
+        else {
+            creates.push(entry);
+        }
+    }
+    return {
+        renames: matched.filter((pair) => pair.row.relPath !== pair.entry.relPath),
+        retags,
+        creates,
+        deletes: [...rowsByPath.values()],
+    };
+}
+/**
+ * The compare function for link channels — the FILE identity rules, for
+ * the file reason: a symlink cannot be retargeted in place (retarget is
+ * unlink + recreate, so the inode churns exactly like an atomic save),
+ * so the path absorbs that churn and claims first; the inode rescues
+ * path-orphans (`mv` preserves a symlink's inode). The payload is the
+ * target string, already read at walk time. A consequence worth naming:
+ * two links exchanging names read as two retargets (path-first),
+ * because a link's meaning IS its written address.
+ *  1. Path claims the channel: same target = continued (a new inode
+ *     under an old name with an old target is silent recreation),
+ *     different target = changed.
+ *  2. Inode rescues path-orphans: renames.
+ *  3. Leftover entries are creates; leftover rows are deletes.
+ */
+export function diffLinkState(rows, entries) {
+    const changes = [];
+    const retags = [];
+    const rowsByPath = new Map(rows.map((row) => [row.relPath, row]));
+    const claimedRowIds = new Set();
+    const orphanEntries = [];
+    for (const entry of entries) {
+        const row = rowsByPath.get(entry.relPath);
+        if (!row) {
+            orphanEntries.push(entry);
+            continue;
+        }
+        claimedRowIds.add(row.linkId);
+        if (row.target !== entry.target)
+            changes.push({ row, entry });
+        else if (row.device !== entry.device || row.inode !== entry.inode)
+            retags.push({ row, entry });
+    }
+    const orphanRows = rows.filter((row) => !claimedRowIds.has(row.linkId));
+    const renames = matchByInode(orphanRows, orphanEntries);
+    const renamedRowIds = new Set(renames.map((pair) => pair.row.linkId));
+    const renamedEntries = new Set(renames.map((pair) => pair.entry));
+    return {
+        changes,
+        retags,
+        renames,
+        creates: orphanEntries.filter((entry) => !renamedEntries.has(entry)),
+        deletes: orphanRows.filter((row) => !renamedRowIds.has(row.linkId)),
+    };
+}
+/**
+ * The compare function for file channels — doorbells and rescans both
+ * end here. Hashing is deferred — `checks` name the files whose content
+ * must be read before an event may be claimed.
+ *
+ * Identity rules, in order:
+ *  1. Path claims the channel. Same rel_path = same file_id, even when
+ *     the inode changed (atomic saves replace the inode on every
+ *     write).
+ *  2. Inode rescues path-orphans (matchByInode above).
+ *  3. Leftover entries are creates; leftover rows are deletes.
+ *
+ * The single stat-shortcut this layer allows itself: a (size, mtime,
+ * inode) triple identical to the stored one is skipped as unchanged —
+ * but only when the mtime is strictly older than the moment we last
+ * read the bytes (git's "racily clean" rule), and only when nothing
+ * pointed at the file. A path named in `mustCheck` (the doorbell said
+ * so) is always hashed: timestamps can lie, a delivered watcher event
+ * cannot be un-delivered.
+ */
+export function diffRootState(rows, entries, mustCheck = null) {
+    const checks = [];
+    let unchanged = 0;
+    const rowsByPath = new Map(rows.map((row) => [row.relPath, row]));
+    const claimedRowIds = new Set();
+    const orphanEntries = [];
+    for (const entry of entries) {
+        const row = rowsByPath.get(entry.relPath);
+        if (!row) {
+            orphanEntries.push(entry);
+            continue;
+        }
+        claimedRowIds.add(row.fileId);
+        const statsMatch = row.size === entry.size && row.mtimeMs === entry.mtimeMs && row.inode === entry.inode;
+        const provablyBeforeLastRead = typeof row.hashedAtMs === 'number' && entry.mtimeMs < row.hashedAtMs;
+        const named = mustCheck !== null && mustCheck.has(entry.relPath);
+        if (statsMatch && provablyBeforeLastRead && !named) {
+            unchanged += 1;
+        }
+        else {
+            checks.push({ row, entry });
+        }
+    }
+    const orphanRows = rows.filter((row) => !claimedRowIds.has(row.fileId));
+    const renames = matchByInode(orphanRows, orphanEntries);
+    const renamedRowIds = new Set(renames.map((pair) => pair.row.fileId));
+    const renamedEntries = new Set(renames.map((pair) => pair.entry));
+    return {
+        checks,
+        renames,
+        creates: orphanEntries.filter((entry) => !renamedEntries.has(entry)),
+        deletes: orphanRows.filter((row) => !renamedRowIds.has(row.fileId)),
+        unchanged,
+    };
+}
+//# sourceMappingURL=diff.js.map

package/dist/detection/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../src/detection/diff.ts"],"names":[],"mappings":"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"}