@mneme-ai/core 2.19.46 → 2.19.47

package/dist/chronosheaf/persistence.js

@@ -0,0 +1,173 @@
+/**
+ * v2.19.47 — CHRONOSHEAF P2-c · persistent homology.
+ *
+ *   Math foundation (Edelsbrunner / Carlsson, ~2002-2008):
+ *
+ *     A filtration is a nested sequence of simplicial complexes
+ *
+ *       ∅ = K_0 ⊆ K_1 ⊆ K_2 ⊆ … ⊆ K_n.
+ *
+ *     For each k, the inclusion K_i ↪ K_j induces a map
+ *     H_k(K_i) → H_k(K_j). A class c ∈ H_k IS BORN at filtration b if
+ *     it appears in K_b but not in K_{b−1}, and DIES at d > b if it
+ *     becomes a boundary in K_d. The persistence pair (b, d) with
+ *     pers(b, d) = d − b measures structural robustness; long-lived
+ *     features survive coarse-graining + noise and represent
+ *     real structure, while short-lived ones are noise.
+ *
+ *     The Persistence Diagram (or Bar Code) PD_k = {(b, d) : (b, d)
+ *     is a persistence pair} is the canonical invariant. It satisfies
+ *     a stability theorem (Cohen-Steiner / Edelsbrunner / Harer 2007):
+ *     bottleneck distance W_∞(PD(f), PD(g)) ≤ ‖f − g‖_∞.
+ *
+ *   AI-memory mapping (PAIN-002 scale-mismatch + PAIN-003 drift-surface):
+ *
+ *     We filter the tool-catalog over releases: K_i = the catalog at
+ *     release v_i, with each tool name as a 0-simplex and each
+ *     "is registered" relation as a 1-simplex. A persistent 0-class
+ *     = a tool present continuously across releases. A 0-class that
+ *     dies = a tool removed/renamed. A 1-class = a co-registration
+ *     pattern.
+ *
+ *     The persistence diagram answers "which facts survived the last
+ *     N releases" in a single picture, and bottleneck distance gives a
+ *     rigorous "how much did the catalog drift" metric for PAIN-003.
+ *
+ *   Implementation: standard column-reduction algorithm (Zomorodian-
+ *   Carlsson 2005), over ℝ coefficients. We implement the 0-dim
+ *   variant (most useful for catalog facts) + a generic kth-dim wrapper.
+ */
+/**
+ * Compute 0-dimensional persistent homology from a vertex filtration.
+ * Algorithm: Union-Find with elder rule (Eldership: when two components
+ * merge, the YOUNGER one dies at the merge filtration value).
+ */
+export function persistentHomology0(filtration) {
+    const pairs = [];
+    const parent = new Map();
+    const birthTime = new Map();
+    let maxFinite = 0;
+    let essential = 0;
+    const find = (x) => {
+        let r = x;
+        while (parent.get(r) !== r)
+            r = parent.get(r);
+        let c = x;
+        while (c !== r) {
+            const n = parent.get(c);
+            parent.set(c, r);
+            c = n;
+        }
+        return r;
+    };
+    for (const step of filtration) {
+        // First add all 0-simplices at this filtration (vertices).
+        for (const simplex of step.add) {
+            if (simplex.length === 1) {
+                const v = simplex[0];
+                if (!parent.has(v)) {
+                    parent.set(v, v);
+                    birthTime.set(v, step.value);
+                }
+            }
+        }
+        // Then process 1-simplices = edges (each merges 0-components or creates a 1-class).
+        for (const simplex of step.add) {
+            if (simplex.length !== 2)
+                continue;
+            const a = simplex[0];
+            const b = simplex[1];
+            // Edge implicitly adds endpoints if missing.
+            for (const v of [a, b]) {
+                if (!parent.has(v)) {
+                    parent.set(v, v);
+                    birthTime.set(v, step.value);
+                }
+            }
+            const ra = find(a);
+            const rb = find(b);
+            if (ra === rb)
+                continue;
+            // Merge components — younger dies (elder rule).
+            const ta = birthTime.get(ra) ?? step.value;
+            const tb = birthTime.get(rb) ?? step.value;
+            const youngerRoot = ta > tb ? ra : rb;
+            const elderRoot = ta > tb ? rb : ra;
+            const deathTime = step.value;
+            const birthValue = Math.max(ta, tb);
+            parent.set(youngerRoot, elderRoot);
+            pairs.push({
+                dim: 0, birth: birthValue, death: deathTime,
+                persistence: deathTime - birthValue,
+                birthSimplex: [youngerRoot], deathSimplex: [a, b],
+            });
+            if (deathTime - birthValue > maxFinite)
+                maxFinite = deathTime - birthValue;
+        }
+    }
+    // Surviving components → essential classes (death = +∞).
+    const roots = new Set();
+    for (const v of parent.keys())
+        roots.add(find(v));
+    for (const r of roots) {
+        essential++;
+        pairs.push({
+            dim: 0, birth: birthTime.get(r) ?? 0, death: Infinity,
+            persistence: Infinity, birthSimplex: [r],
+        });
+    }
+    return {
+        pairs,
+        maxFinitePersistence: maxFinite,
+        essentialByDim: { 0: essential },
+    };
+}
+/**
+ * Bottleneck distance between two persistence diagrams (1D matching).
+ * Uses Wasserstein-∞ approximation via greedy nearest-neighbour matching
+ * (good enough for the AI-memory PAIN-003 drift use case where diagrams
+ * are small). Bottleneck distance W_∞ = max_pair |Δb| ∨ |Δd|.
+ */
+export function bottleneckDistance(a, b) {
+    // Take only finite-persistence pairs for matching; essential classes
+    // count toward the "infinity diagonal".
+    const ap = a.pairs.filter((p) => isFinite(p.persistence));
+    const bp = b.pairs.filter((p) => isFinite(p.persistence));
+    const matched = new Set();
+    let worst = 0;
+    for (const p1 of ap) {
+        let bestIdx = -1;
+        let bestDist = Infinity;
+        for (let i = 0; i < bp.length; i++) {
+            if (matched.has(i))
+                continue;
+            const p2 = bp[i];
+            const d = Math.max(Math.abs(p1.birth - p2.birth), Math.abs(p1.death - p2.death));
+            if (d < bestDist) {
+                bestDist = d;
+                bestIdx = i;
+            }
+        }
+        if (bestIdx >= 0) {
+            matched.add(bestIdx);
+            if (bestDist > worst)
+                worst = bestDist;
+        }
+        else {
+            // Unmatched — distance to diagonal = persistence/2.
+            const diag = p1.persistence / 2;
+            if (diag > worst)
+                worst = diag;
+        }
+    }
+    // Account for unmatched pairs in b.
+    for (let i = 0; i < bp.length; i++) {
+        if (matched.has(i))
+            continue;
+        const diag = bp[i].persistence / 2;
+        if (diag > worst)
+            worst = diag;
+    }
+    return worst;
+}
+//# sourceMappingURL=persistence.js.map

package/dist/chronosheaf/persistence.js.map

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

package/dist/chronosheaf/rg_flow.d.ts

@@ -0,0 +1,81 @@
+/**
+ * v2.19.47 — CHRONOSHEAF P2-b · Renormalization Group flow.
+ *
+ *   Math foundation (Wilson / Kadanoff, 1971):
+ *
+ *     For a scale s ∈ ℝ⁺ and a Hamiltonian (or generic "system state")
+ *     H_s, the RG operator R_b shifts the scale by a factor b:
+ *
+ *       H_{s + log b} = R_b · H_s,   R_b R_{b'} = R_{bb'}.
+ *
+ *     Fixed points H* satisfying R_b H* = H* for some b are
+ *     SCALE-INVARIANT — they survive every coarse-graining step.
+ *     Operators (degrees of freedom) split into RELEVANT (eigenvalue
+ *     |λ| > 1, grow under flow → matter at every scale), MARGINAL
+ *     (|λ| = 1, neither grow nor decay), IRRELEVANT (|λ| < 1, vanish
+ *     under flow → noise that washes out).
+ *
+ *   AI-memory mapping (PAIN-002 scale-mismatch + PAIN-003 drift-surface):
+ *
+ *     A coarse-graining is an aggregation step on tool catalog data:
+ *
+ *       state s_0 = full catalog list (~700 tool names)
+ *       R_2 s_0  = family-grouped (governor/fossil/...) (~20 groups)
+ *       R_2² s_0 = category-grouped (memory/audit/meta...) (9 cats)
+ *       R_2³ s_0 = single "all tools" scalar (1 number)
+ *
+ *     Fixed points of this flow are descriptors that DON'T change as we
+ *     zoom out — they're the right-detail-level for any consumer.
+ *     The skinny capabilities tool from v2.19.41 is a hand-rolled
+ *     RG fixed point at scale 2 (category-grouped); CHRONOSHEAF lets
+ *     callers pick any scale by passing `b`.
+ *
+ *   Implementation: linear coarse-graining on vector-valued states,
+ *   eigendecomposition via power iteration for the relevance classifier.
+ *   Pure-function; no fancy numerics required for the AI-memory use case
+ *   because catalog states are small (≤ 1000 dims).
+ */
+export interface RGState {
+    /** Numeric state vector at scale s. */
+    vector: number[];
+    /** Scale exponent (log_b of physical scale). */
+    scale: number;
+    /** Optional label for human inspection. */
+    label?: string;
+}
+export interface RGStep {
+    /** From-scale → to-scale (factor b). */
+    factor: number;
+    /** Aggregator that merges groups of size `factor` into one component. */
+    aggregator: "mean" | "sum" | "max" | "min";
+}
+/** Apply a single RG step: aggregate groups of `factor` adjacent components. */
+export declare function rgStep(s: RGState, step: RGStep): RGState;
+/** Iterate the RG flow until the state stops changing (fixed point) or N steps. */
+export declare function rgFixedPoint(s0: RGState, step: RGStep, maxIter?: number, tol?: number): {
+    state: RGState;
+    iterations: number;
+    reachedFixedPoint: boolean;
+};
+/**
+ * Classify operators by their behaviour under the linearised RG flow.
+ * We treat the state vector as a perturbation around the fixed point and
+ * estimate the leading eigenvalue via power iteration on (R_b)' (linear
+ * approximation).
+ */
+export type Relevance = "relevant" | "marginal" | "irrelevant";
+export declare function classifyRelevance(s0: RGState, step: RGStep, perturbation: number[], iterations?: number): {
+    eigenvalue: number;
+    class: Relevance;
+};
+/**
+ * AI-memory specific: given a catalog snapshot (one number per tool —
+ * e.g. recent invocation count), find the SMALLEST scale b at which
+ * coarse-graining yields ≤ targetSize components. Used by the skinny-
+ * capabilities surface to pick the right family-grouping automatically.
+ */
+export declare function smallestScaleForBudget(s0: RGState, step: RGStep, targetSize: number, maxIter?: number): {
+    state: RGState;
+    iterations: number;
+};
+//# sourceMappingURL=rg_flow.d.ts.map

package/dist/chronosheaf/rg_flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rg_flow.d.ts","sourceRoot":"","sources":["../../src/chronosheaf/rg_flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,MAAM,WAAW,OAAO;IACtB,uCAAuC;IACvC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,MAAM;IACrB,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;CAC5C;AAED,gFAAgF;AAChF,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAmBxD;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,SAAK,EAAE,GAAG,SAAQ,GAAG;IAClF,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,OAAO,CAAC;CAChE,CAaA;AAQD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,YAAY,CAAC;AAE/D,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,OAAO,EACX,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EAAE,EACtB,UAAU,SAAK,GACd;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,CAwB1C;AAQD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,OAAO,EACX,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,OAAO,SAAK,GACX;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAOxC"}

package/dist/chronosheaf/rg_flow.js

@@ -0,0 +1,146 @@
+/**
+ * v2.19.47 — CHRONOSHEAF P2-b · Renormalization Group flow.
+ *
+ *   Math foundation (Wilson / Kadanoff, 1971):
+ *
+ *     For a scale s ∈ ℝ⁺ and a Hamiltonian (or generic "system state")
+ *     H_s, the RG operator R_b shifts the scale by a factor b:
+ *
+ *       H_{s + log b} = R_b · H_s,   R_b R_{b'} = R_{bb'}.
+ *
+ *     Fixed points H* satisfying R_b H* = H* for some b are
+ *     SCALE-INVARIANT — they survive every coarse-graining step.
+ *     Operators (degrees of freedom) split into RELEVANT (eigenvalue
+ *     |λ| > 1, grow under flow → matter at every scale), MARGINAL
+ *     (|λ| = 1, neither grow nor decay), IRRELEVANT (|λ| < 1, vanish
+ *     under flow → noise that washes out).
+ *
+ *   AI-memory mapping (PAIN-002 scale-mismatch + PAIN-003 drift-surface):
+ *
+ *     A coarse-graining is an aggregation step on tool catalog data:
+ *
+ *       state s_0 = full catalog list (~700 tool names)
+ *       R_2 s_0  = family-grouped (governor/fossil/...) (~20 groups)
+ *       R_2² s_0 = category-grouped (memory/audit/meta...) (9 cats)
+ *       R_2³ s_0 = single "all tools" scalar (1 number)
+ *
+ *     Fixed points of this flow are descriptors that DON'T change as we
+ *     zoom out — they're the right-detail-level for any consumer.
+ *     The skinny capabilities tool from v2.19.41 is a hand-rolled
+ *     RG fixed point at scale 2 (category-grouped); CHRONOSHEAF lets
+ *     callers pick any scale by passing `b`.
+ *
+ *   Implementation: linear coarse-graining on vector-valued states,
+ *   eigendecomposition via power iteration for the relevance classifier.
+ *   Pure-function; no fancy numerics required for the AI-memory use case
+ *   because catalog states are small (≤ 1000 dims).
+ */
+/** Apply a single RG step: aggregate groups of `factor` adjacent components. */
+export function rgStep(s, step) {
+    const b = Math.max(1, Math.floor(step.factor));
+    if (b <= 1)
+        return { ...s, scale: s.scale + 1 };
+    const out = [];
+    for (let i = 0; i < s.vector.length; i += b) {
+        const block = s.vector.slice(i, Math.min(i + b, s.vector.length));
+        let v;
+        switch (step.aggregator) {
+            case "sum":
+                v = block.reduce((a, x) => a + x, 0);
+                break;
+            case "max":
+                v = Math.max(...block);
+                break;
+            case "min":
+                v = Math.min(...block);
+                break;
+            case "mean":
+            default:
+                v = block.reduce((a, x) => a + x, 0) / block.length;
+                break;
+        }
+        out.push(v);
+    }
+    const result = { vector: out, scale: s.scale + Math.log2(b) };
+    if (s.label !== undefined)
+        result.label = s.label;
+    return result;
+}
+/** Iterate the RG flow until the state stops changing (fixed point) or N steps. */
+export function rgFixedPoint(s0, step, maxIter = 50, tol = 1e-12) {
+    let cur = s0;
+    for (let i = 0; i < maxIter; i++) {
+        const next = rgStep(cur, step);
+        if (vecClose(cur.vector, next.vector, tol)) {
+            return { state: next, iterations: i + 1, reachedFixedPoint: true };
+        }
+        if (next.vector.length <= 1) {
+            return { state: next, iterations: i + 1, reachedFixedPoint: true };
+        }
+        cur = next;
+    }
+    return { state: cur, iterations: maxIter, reachedFixedPoint: false };
+}
+function vecClose(a, b, tol) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (Math.abs((a[i] ?? 0) - (b[i] ?? 0)) > tol)
+            return false;
+    return true;
+}
+export function classifyRelevance(s0, step, perturbation, iterations = 20) {
+    // Apply RG `iterations` times to the perturbation only; measure growth.
+    let cur = [...perturbation];
+    let firstNorm = vecNorm(cur);
+    if (firstNorm < 1e-15)
+        return { eigenvalue: 0, class: "irrelevant" };
+    void s0; // RG flow linearised about fixed point — only step shape matters
+    let lastNorm = firstNorm;
+    let lastRatio = 1;
+    for (let k = 0; k < iterations; k++) {
+        const next = rgStep({ vector: cur, scale: 0 }, step).vector;
+        const nNorm = vecNorm(next);
+        if (nNorm < 1e-15) {
+            lastRatio = 0;
+            break;
+        }
+        lastRatio = nNorm / lastNorm;
+        cur = next;
+        lastNorm = nNorm;
+        if (cur.length <= 1)
+            break;
+    }
+    // Eigenvalue λ ≈ growth ratio per iteration.
+    const eigenvalue = lastRatio;
+    let cls;
+    if (eigenvalue > 1 + 1e-3)
+        cls = "relevant";
+    else if (eigenvalue < 1 - 1e-3)
+        cls = "irrelevant";
+    else
+        cls = "marginal";
+    return { eigenvalue, class: cls };
+}
+function vecNorm(v) {
+    let s = 0;
+    for (const x of v)
+        s += x * x;
+    return Math.sqrt(s);
+}
+/**
+ * AI-memory specific: given a catalog snapshot (one number per tool —
+ * e.g. recent invocation count), find the SMALLEST scale b at which
+ * coarse-graining yields ≤ targetSize components. Used by the skinny-
+ * capabilities surface to pick the right family-grouping automatically.
+ */
+export function smallestScaleForBudget(s0, step, targetSize, maxIter = 50) {
+    let cur = s0;
+    for (let i = 0; i < maxIter; i++) {
+        if (cur.vector.length <= targetSize)
+            return { state: cur, iterations: i };
+        cur = rgStep(cur, step);
+    }
+    return { state: cur, iterations: maxIter };
+}
+//# sourceMappingURL=rg_flow.js.map

package/dist/chronosheaf/rg_flow.js.map

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

package/dist/chronosheaf/sheaf.d.ts

@@ -0,0 +1,116 @@
+/**
+ * v2.19.47 — CHRONOSHEAF P2-a · sheaf cohomology over ℝ-valued presheaves.
+ *
+ *   Math foundation (Leray / Grothendieck / Čech):
+ *
+ *     For a base space X (we model as a finite set of "sites"), an open
+ *     cover U = {U₀, U₁, ...}, and a presheaf F : Open(X)ᵒᵖ → Vec_ℝ,
+ *     the Čech complex is
+ *
+ *       Č^p(U, F) = ⊕_{i₀<…<i_p} F(U_{i₀} ∩ … ∩ U_{i_p})
+ *
+ *     with coboundary
+ *
+ *       (δσ)_{i₀…i_{p+1}} = Σ_{k=0}^{p+1} (−1)^k · ρ(σ_{i₀…î_k…i_{p+1}})
+ *
+ *     and the p-th Čech cohomology
+ *
+ *       H^p(U, F) = ker δ^p / im δ^{p−1}.
+ *
+ *     We focus on H¹: dim H¹(U, F) = (number of independent 1-cocycles)
+ *     − (number of independent 1-coboundaries). H¹ ≠ 0 ⟺ there exist
+ *     local sections that agree pairwise on overlaps but cannot be glued
+ *     into a single global section — the canonical "local OK, global
+ *     contradiction" signal CHRONOSHEAF chases.
+ *
+ *   Implementation strategy (performance + accuracy):
+ *
+ *     We restrict to ℝ-valued (scalar) sections per site — sufficient
+ *     for the AI-memory use case where each verifier returns a single
+ *     number per overlap (a "claim value"). For overlaps the restriction
+ *     map is the identity on ℝ.
+ *
+ *     The δ⁰ matrix is the signed incidence of pairs to sites:
+ *
+ *       δ⁰[ij, k] = +1 if k == j,  −1 if k == i,  0 otherwise
+ *
+ *     For overlaps with NO triple overlap (most code-base covers), every
+ *     1-cochain is automatically a cocycle (ker δ¹ = whole space), so
+ *
+ *       dim H¹ = E − rank(δ⁰)
+ *
+ *     where E is the number of pairs and rank(δ⁰) = N − c (vertices N
+ *     minus connected components c of the nerve 1-skeleton). This
+ *     reduces to a graph-theoretic computation that runs in O(N + E).
+ *
+ *     When triple overlaps exist we compute δ¹ explicitly and rank-reduce
+ *     via integer Gaussian elimination (O(min(E,T)² · max(E,T))) — fast
+ *     enough for a Mneme catalog cover of a few hundred sites.
+ *
+ *   Composes with PAIN-001 (time-direction), PAIN-004 (self-reference
+ *   via reflexive cover), PAIN-005 (interface-coherence as global section).
+ */
+export type Site = string;
+export interface SheafCover {
+    /** Sites (open sets) — identified by string keys. */
+    sites: ReadonlyArray<Site>;
+    /** Pairwise overlaps as unordered pairs [i, j] with i < j (by sites index). */
+    overlaps: ReadonlyArray<[Site, Site]>;
+    /** Optional triple overlaps [i, j, k] with i < j < k. */
+    triples?: ReadonlyArray<[Site, Site, Site]>;
+}
+/** Section on each site (the 0-cochain): site → real value. */
+export type Section0 = ReadonlyMap<Site, number>;
+/** Section on each overlap (the 1-cochain): pair-key → real value. */
+export type Section1 = ReadonlyMap<string, number>;
+export interface SheafResult {
+    /** Number of 1-cochains (= |overlaps|). */
+    cochainDim: number;
+    /** rank δ⁰ — dim image of 0→1 coboundary. */
+    rankDelta0: number;
+    /** Estimated dim ker δ¹. With no triples = |overlaps|. */
+    kerDelta1: number;
+    /** dim H¹ = ker δ¹ − im δ⁰. ≥0 by construction. */
+    h1: number;
+    /** True when H¹ > 0 — pairwise OK but globally inconsistent. */
+    hasObstruction: boolean;
+    /** Minimal witnesses: 1-cochains that are cocycles but not coboundaries. */
+    obstructions: Array<{
+        pair: [Site, Site];
+        value: number;
+    }>;
+    /** Connected components of the nerve 1-skeleton (auxiliary). */
+    components: number;
+}
+/**
+ * Compute δ⁰(σ) for a 0-cochain σ — returns 1-cochain on every overlap.
+ *   (δ⁰σ)_{ij} = σ_j − σ_i.
+ */
+export declare function delta0(cover: SheafCover, sigma0: Section0): Section1;
+/**
+ * Compute δ¹(σ) for a 1-cochain σ — returns 2-cochain on every triple.
+ *   (δ¹σ)_{ijk} = σ_{jk} − σ_{ik} + σ_{ij}.
+ */
+export declare function delta1(cover: SheafCover, sigma1: Section1): Map<string, number>;
+/** Check the cocycle condition δ¹σ = 0 on all triples. */
+export declare function isCocycle(cover: SheafCover, sigma1: Section1, tol?: number): boolean;
+/**
+ * Compute dim H¹(U, F) by reducing to graph connectivity when triples
+ * are absent + Gaussian elimination when they're present.
+ */
+export declare function cohomologyH1(cover: SheafCover): SheafResult;
+/**
+ * Given a presheaf assignment (each site → numeric "claim value"), check
+ * whether the implied pairwise differences glue: returns the same
+ * SheafResult plus the gluing-residual vector.
+ *
+ *   residual_{ij} = (claim_j - claim_i) restricted to U_i ∩ U_j
+ *
+ * If H¹ = 0, the residual lies in im δ⁰ → there exists a global section
+ * (effectively the user's claim values are all consistent). If H¹ > 0,
+ * the residual carries a non-trivial cocycle component.
+ */
+export declare function gluingDiagnostic(cover: SheafCover, claimPerSite: Section0): SheafResult & {
+    residual: Section1;
+};
+//# sourceMappingURL=sheaf.d.ts.map

package/dist/chronosheaf/sheaf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheaf.d.ts","sourceRoot":"","sources":["../../src/chronosheaf/sheaf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,MAAM,WAAW,UAAU;IACzB,qDAAqD;IACrD,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IAC3B,+EAA+E;IAC/E,QAAQ,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACtC,yDAAyD;IACzD,OAAO,CAAC,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;CAC7C;AAED,+DAA+D;AAC/D,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAEjD,sEAAsE;AACtE,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;IACX,gEAAgE;IAChE,cAAc,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,YAAY,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,gEAAgE;IAChE,UAAU,EAAE,MAAM,CAAC;CACpB;AAkCD;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,CASpE;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAY/E;AAED,0DAA0D;AAC1D,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,SAAO,GAAG,OAAO,CAKlF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAkD3D;AAiDD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,GAAG,WAAW,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAA;CAAE,CAIhH"}