@izagood/avcs 0.1.0

package/dist/query/diff.d.ts

@@ -0,0 +1,16 @@
+import type { ReductionResult } from "../reducer/reducer.ts";
+export interface TreeDiff {
+    added: string[];
+    removed: string[];
+    modified: string[];
+}
+export declare function diffTrees(a: ReductionResult, b: ReductionResult): TreeDiff;
+export interface OpSetDiff {
+    /** Accepted in b but not a. */
+    added: string[];
+    /** Accepted in a but not b. */
+    removed: string[];
+}
+/** Symmetric difference of the accepted operation sets of two reductions. */
+export declare function diffAcceptedOps(a: ReductionResult, b: ReductionResult): OpSetDiff;
+//# sourceMappingURL=diff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/query/diff.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,QAAQ,CAU1E;AAED,MAAM,WAAW,SAAS;IACxB,+BAA+B;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,6EAA6E;AAC7E,wBAAgB,eAAe,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,SAAS,CASjF"}

package/dist/query/diff.js

@@ -0,0 +1,32 @@
+// Phase 10: diffing two materialized states.
+//
+// Tree entries are content-addressed (put_file blob oids and synth oids are both
+// content-derived), so a path whose oid is unchanged is unchanged — diffing is just
+// a map comparison. The AVCS-only axis is a *policy diff*: reduce the same ops under
+// two policies and diff the trees to see what the policy change alone did.
+export function diffTrees(a, b) {
+    const added = [];
+    const removed = [];
+    const modified = [];
+    for (const [path, oid] of b.tree) {
+        if (!a.tree.has(path))
+            added.push(path);
+        else if (a.tree.get(path) !== oid)
+            modified.push(path);
+    }
+    for (const path of a.tree.keys())
+        if (!b.tree.has(path))
+            removed.push(path);
+    return { added: added.sort(), removed: removed.sort(), modified: modified.sort() };
+}
+/** Symmetric difference of the accepted operation sets of two reductions. */
+export function diffAcceptedOps(a, b) {
+    const accepted = (r) => new Set([...r.statuses].filter(([, s]) => s === "accepted").map(([oid]) => oid));
+    const sa = accepted(a);
+    const sb = accepted(b);
+    return {
+        added: [...sb].filter((o) => !sa.has(o)).sort(),
+        removed: [...sa].filter((o) => !sb.has(o)).sort(),
+    };
+}
+//# sourceMappingURL=diff.js.map

package/dist/query/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../src/query/diff.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,EAAE;AACF,iFAAiF;AACjF,oFAAoF;AACpF,qFAAqF;AACrF,2EAA2E;AAU3E,MAAM,UAAU,SAAS,CAAC,CAAkB,EAAE,CAAkB;IAC9D,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;QACjC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACnC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG;YAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzD,CAAC;IACD,KAAK,MAAM,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE;QAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5E,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;AACrF,CAAC;AASD,6EAA6E;AAC7E,MAAM,UAAU,eAAe,CAAC,CAAkB,EAAE,CAAkB;IACpE,MAAM,QAAQ,GAAG,CAAC,CAAkB,EAAE,EAAE,CACtC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACnF,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACvB,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACvB,OAAO;QACL,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;QAC/C,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;KAClD,CAAC;AACJ,CAAC"}

package/dist/reducer/incremental.d.ts

@@ -0,0 +1,2 @@
+export { reduceIncremental, snapshotReduce, NonIncrementalError, serializeSnapshot, deserializeSnapshot, type ReduceSnapshot, type PerKeyDecision, type IncrementalStats, } from "./reducer.ts";
+//# sourceMappingURL=incremental.d.ts.map

package/dist/reducer/incremental.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental.d.ts","sourceRoot":"","sources":["../../src/reducer/incremental.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC"}

package/dist/reducer/incremental.js

@@ -0,0 +1,14 @@
+// Incremental reduce (docs/11 Track A, stage A0).
+//
+// Public entry points for O(Δ) re-reduce. The implementation lives in reducer.ts so it
+// can reuse the file-private decision/materialization helpers without widening the
+// module's API surface (determinism-critical code stays encapsulated). This module is
+// the stable boundary the rest of the system imports.
+//
+// Contract: `reduceIncremental(snapshotReduce(base), next)` is structurally identical to
+// `reduce(next)` whenever `next` is an append-superset of `base` (same policy/authority/
+// materializeStatuses). The differential property harness (test/incremental-equivalence)
+// enforces this. When the preconditions don't hold it throws NonIncrementalError and the
+// caller falls back to a full reduce — never a silent divergence.
+export { reduceIncremental, snapshotReduce, NonIncrementalError, serializeSnapshot, deserializeSnapshot, } from "./reducer.js";
+//# sourceMappingURL=incremental.js.map

package/dist/reducer/incremental.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental.js","sourceRoot":"","sources":["../../src/reducer/incremental.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,EAAE;AACF,uFAAuF;AACvF,mFAAmF;AACnF,sFAAsF;AACtF,sDAAsD;AACtD,EAAE;AACF,yFAAyF;AACzF,yFAAyF;AACzF,yFAAyF;AACzF,yFAAyF;AACzF,kEAAkE;AAClE,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,mBAAmB,GAIpB,MAAM,cAAc,CAAC"}

package/dist/reducer/policy.d.ts

@@ -0,0 +1,17 @@
+import type { Evidence, Operation, Policy } from "../objects/types.ts";
+export declare const MATERIALIZER_VERSION = "avcs-text-mvp/0.0.1";
+/** A sane built-in policy used when a repo has not authored its own. */
+export declare function defaultPolicy(): Policy;
+export interface OpEvaluation {
+    blocked: boolean;
+    blockedReason?: string;
+    requiresHuman: boolean;
+    score: number;
+    notes: string[];
+}
+/**
+ * Evaluate one operation under a policy, given the evidence attached to it and
+ * whether it is currently contended.
+ */
+export declare function evaluateOp(policy: Policy, op: Operation, evidenceForOp: Evidence[], inConflict: boolean, intentConstraintsSatisfied: boolean, reliabilityBonus?: number): OpEvaluation;
+//# sourceMappingURL=policy.d.ts.map

package/dist/reducer/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/reducer/policy.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAEV,QAAQ,EACR,SAAS,EACT,MAAM,EAEP,MAAM,qBAAqB,CAAC;AAE7B,eAAO,MAAM,oBAAoB,wBAAwB,CAAC;AAE1D,wEAAwE;AACxE,wBAAgB,aAAa,IAAI,MAAM,CAiCtC;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAkBD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,SAAS,EACb,aAAa,EAAE,QAAQ,EAAE,EACzB,UAAU,EAAE,OAAO,EACnB,0BAA0B,EAAE,OAAO,EACnC,gBAAgB,SAAI,GACnB,YAAY,CAqEd"}

package/dist/reducer/policy.js

@@ -0,0 +1,143 @@
+// Policy engine.
+//
+// AVCS never defaults to last-write-wins for code. When concurrent operations
+// contend for the same entity, a *policy* decides — deterministically and with a
+// recorded rationale — using this ladder (highest first):
+//
+//   1. safety/security              (rule-driven)
+//   2. explicit human decision      (a Decision object; handled in the reducer)
+//   3. code-owner / human actor      (actorTrust + prefer_actor)
+//   4. intent constraints satisfied  (declared effects vs intent constraints)
+//   5. verified by evidence          (require_evidence gating + bonus)
+//   6. actor trust level             (actorTrust ladder)
+//   7. smaller blast radius          (advisory)
+//   8. recency (Lamport)             (final tie-break — applied in the reducer's
+//                                     ranking comparator, NOT added to the score;
+//                                     adding it lets time overwhelm the ladder)
+//
+// Evidence trust: an operation's own author cannot vouch for it. require_evidence
+// gates and the passing-test bonus only count evidence produced by a non-authoring
+// trusted actor (ci_bot / human). Self-reported ai_agent evidence is ignored until
+// signing lands (Phase 3). See docs/04-policy.md.
+export const MATERIALIZER_VERSION = "avcs-text-mvp/0.0.1";
+/** A sane built-in policy used when a repo has not authored its own. */
+export function defaultPolicy() {
+    return {
+        type: "policy",
+        version: "default/2026.06",
+        actorTrust: ["ai_agent", "ci_bot", "human"], // human most trusted
+        rules: [
+            // A change that alters runtime behavior must carry a passing test.
+            {
+                name: "behavior_change_requires_test",
+                when: { changesBehavior: true },
+                effect: { type: "require_evidence", evidence: "unit_test", result: "pass" },
+            },
+            // Breaking the public API is never auto-merged — a human must decide.
+            {
+                name: "public_api_break_requires_human",
+                when: { breaksPublicApi: true },
+                effect: { type: "require_human" },
+            },
+            // Pure formatting loses every contest.
+            {
+                name: "formatting_low_priority",
+                when: { opKind: "note" },
+                effect: { type: "priority", weight: -50 },
+            },
+            // On any conflict, prefer the human's operation.
+            {
+                name: "human_wins_conflicts",
+                when: { onConflict: true },
+                effect: { type: "prefer_actor", kind: "human" },
+            },
+        ],
+        createdAt: new Date().toISOString(),
+    };
+}
+function actorTrustScore(policy, actor) {
+    const idx = policy.actorTrust.indexOf(actor.kind);
+    return (idx < 0 ? 0 : idx + 1) * 100;
+}
+function ruleMatches(rule, op, inConflict) {
+    const w = rule.when;
+    if (w.opKind !== undefined && op.body.kind !== w.opKind)
+        return false;
+    if (w.breaksPublicApi !== undefined && !!op.effects?.breaksPublicApi !== w.breaksPublicApi)
+        return false;
+    if (w.changesBehavior !== undefined && !!op.effects?.changesBehavior !== w.changesBehavior)
+        return false;
+    if (w.onConflict !== undefined && w.onConflict !== inConflict)
+        return false;
+    return true;
+}
+/**
+ * Evaluate one operation under a policy, given the evidence attached to it and
+ * whether it is currently contended.
+ */
+export function evaluateOp(policy, op, evidenceForOp, inConflict, intentConstraintsSatisfied, reliabilityBonus = 0) {
+    const ev = {
+        blocked: false,
+        requiresHuman: false,
+        score: actorTrustScore(policy, op.actor),
+        notes: [],
+    };
+    // Phase 5: learned trust nudge (bounded; cannot overpower the ladder — cf. C1).
+    if (reliabilityBonus !== 0) {
+        ev.score += reliabilityBonus * 30;
+        ev.notes.push(`reliability ${reliabilityBonus > 0 ? "+" : ""}${reliabilityBonus}`);
+    }
+    // Only evidence the operation's own author did NOT produce can vouch for it, and
+    // evidence from an untrusted (outsider-CI) runner never counts until re-run (Phase 11).
+    const trusted = evidenceForOp.filter((e) => !e.fromUntrustedRunner &&
+        (e.producedBy.kind !== "ai_agent" || e.producedBy.id !== op.actor.id));
+    const ignored = evidenceForOp.length - trusted.length;
+    if (ignored > 0)
+        ev.notes.push(`${ignored} self-reported evidence ignored`);
+    // Base signals.
+    if (intentConstraintsSatisfied) {
+        ev.score += 200;
+    }
+    else {
+        ev.score -= 200;
+        ev.notes.push("violates intent constraints");
+    }
+    // A passing test is worth more than self-reported confidence.
+    if (trusted.some((e) => e.result === "pass" && e.kind.endsWith("test"))) {
+        ev.score += 150;
+        ev.notes.push("has passing tests");
+    }
+    for (const rule of policy.rules) {
+        if (!ruleMatches(rule, op, inConflict))
+            continue;
+        const e = rule.effect;
+        switch (e.type) {
+            case "require_human":
+                ev.requiresHuman = true;
+                ev.notes.push(`rule ${rule.name}: requires human decision`);
+                break;
+            case "require_evidence": {
+                const ok = trusted.some((x) => x.kind === e.evidence && x.result === e.result);
+                if (!ok) {
+                    ev.blocked = true;
+                    ev.blockedReason = `rule ${rule.name}: missing trusted ${e.evidence}=${e.result}`;
+                    ev.notes.push(ev.blockedReason);
+                }
+                break;
+            }
+            case "priority":
+                ev.score += e.weight;
+                break;
+            case "prefer_actor":
+                if (op.actor.kind === e.kind) {
+                    ev.score += 500;
+                    ev.notes.push(`rule ${rule.name}: preferred actor ${e.kind}`);
+                }
+                break;
+        }
+    }
+    // NOTE: lamport is deliberately NOT added here. Recency is a tie-break only,
+    // applied by the reducer when scores are equal.
+    return ev;
+}
+//# sourceMappingURL=policy.js.map

package/dist/reducer/policy.js.map

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

package/dist/reducer/reducer.d.ts

@@ -0,0 +1,155 @@
+import type { Decision, Evidence, Intent, Operation, OperationStatus, Policy } from "../objects/types.ts";
+export interface ConflictOption {
+    opOid: string;
+    actor: string;
+    purpose: string;
+    evidence: string[];
+    score: number;
+    blocked: boolean;
+    requiresHuman: boolean;
+}
+export interface Conflict {
+    id: string;
+    key: string;
+    kind: "concurrent_write" | "needs_human";
+    options: ConflictOption[];
+    /** Policy's provisional recommendation (never set when a human is required). */
+    recommendedOp: string | null;
+    reason: string;
+    /** Actor ids that own this scope and should make the call (Phase 5). */
+    requiredOwners?: string[];
+}
+/**
+ * A merge that is text-clean but meaning-broken: one op changed a public contract
+ * while another depends on the old one. Detected (and escalated) by the repo's
+ * semantic pass, not the core grouping.
+ */
+export interface SemanticConflict {
+    kind: "contract_break";
+    symbol: string;
+    breakingOp: string;
+    dependentOps: string[];
+    reason: string;
+}
+/** A contest the policy resolved by itself — recorded so auto-merges are auditable. */
+export interface AutoDecision {
+    key: string;
+    conflictId: string;
+    chosenOp: string;
+    rejectedOps: string[];
+    reason: string;
+    policyVersion: string;
+}
+export interface ReductionResult {
+    /** path → blobOid */
+    tree: Map<string, string>;
+    treeHash: string;
+    statuses: Map<string, OperationStatus>;
+    conflicts: Conflict[];
+    autoDecisions: AutoDecision[];
+    /** Text-clean but meaning-broken merges, escalated by the repo's semantic pass. */
+    semanticConflicts: SemanticConflict[];
+    /** Frontier op ids: accepted ops that no other accepted op descends from. */
+    headOps: string[];
+    /**
+     * Content for blob oids synthesized during reduction (symbol-level merges produce
+     * file content that is not any single stored blob). oid → content. The caller
+     * persists or writes these directly. Synthetic oids are content-derived, so the
+     * treeHash that references them stays deterministic.
+     */
+    synthBlobs: Map<string, string>;
+}
+export interface ReduceInput {
+    ops: Operation[];
+    evidence: Evidence[];
+    decisions: Decision[];
+    intents: Map<string, Intent>;
+    policy: Policy;
+    /** Which statuses get projected into the tree. Default: accepted only. */
+    materializeStatuses?: OperationStatus[];
+    /** blob oid → content, for ops that need file text (set_symbol). */
+    blobContent?: Map<string, string>;
+    /** actorId → bounded reliability nudge (Phase 5 trust learning). */
+    reliability?: Map<string, number>;
+    /** deciderId → role weight; resolves contradictory decisions by authority (docs/08 §4). */
+    authority?: Map<string, number>;
+}
+/**
+ * The contended keys an op occupies. A rename reads its source and writes its
+ * destination, so it contends on BOTH — otherwise a concurrent write to either
+ * path would slip through unmerged. note ops contend on nothing.
+ */
+export declare function keysOf(op: Operation): string[];
+export declare function conflictIdFor(key: string): string;
+export interface CrossConflict {
+    file: string;
+    ops: string[];
+}
+/**
+ * A whole-file op (put_file/delete/rename) and a set_symbol on the SAME file are keyed
+ * differently (file:… vs symbol:…#…), so the reducer's grouping never makes them
+ * contend. When they are CONCURRENT (neither a causal ancestor of the other), letting
+ * both apply makes the result depend on kahnOrder's lamport (authoring-order) tie-break
+ * — non-deterministic. This finds those pairs among ACCEPTED ops so the repo can hold
+ * them back (re-reduce) and surface a conflict. Ancestor relations (scaffold→edit) are
+ * intentionally not flagged.
+ */
+export declare function detectCrossGranularity(ops: Operation[], result: ReductionResult): CrossConflict[];
+/** A single group's locally-decided statuses + the conflicts/autoDecisions it emitted. */
+export interface PerKeyDecision {
+    local: Map<string, OperationStatus>;
+    conflicts: Conflict[];
+    autoDecisions: AutoDecision[];
+}
+/** Observability for an incremental re-reduce: how much work the dirty-set skipped.
+ *  Does not affect the result; purely for benchmarks/metrics (docs/11 A1). */
+export interface IncrementalStats {
+    groupsTotal: number;
+    groupsRecomputed: number;
+    groupsReused: number;
+    dirtyKeys: number;
+}
+/**
+ * A full reduce plus the per-group bookkeeping an incremental re-reduce needs to reuse
+ * clean groups (see incremental.ts / docs/11). The `result` is exactly `reduce(input)`.
+ */
+export interface ReduceSnapshot {
+    input: ReduceInput;
+    result: ReductionResult;
+    perKey: Map<string, PerKeyDecision>;
+    groupOrder: string[];
+    groupMembers: Map<string, string[]>;
+    /** Set by `reduceIncremental` (a full `snapshotReduce` recomputes every group). */
+    stats: IncrementalStats;
+}
+export declare function reduce(input: ReduceInput): ReductionResult;
+export declare function snapshotReduce(input: ReduceInput): ReduceSnapshot;
+/** Thrown when an incremental re-reduce's preconditions don't hold; the caller must
+ *  fall back to a full `reduce`. Never indicates a correctness failure — only that the
+ *  fast path doesn't apply (policy/authority/materializeStatuses changed, or `next` is
+ *  not an append-superset of the snapshot's input). */
+export declare class NonIncrementalError extends Error {
+    constructor(reason: string);
+}
+/**
+ * Incremental re-reduce (docs/11 Track A). Given a prior `snapshotReduce` and a `next`
+ * input that is an APPEND-SUPERSET of the snapshot's input (same policy/authority/
+ * materializeStatuses; ops/decisions/evidence only added), recompute only the groups
+ * whose decision could have changed (the "dirty set") and reuse every clean group's
+ * cached decision verbatim. The returned result is structurally identical to
+ * `reduce(next)` — this is the invariant the differential harness enforces.
+ *
+ * Dirty keys (see docs/11): keys of new ops; keys of ops targeted by new decisions or
+ * new evidence (these can flip blocked/accept regardless of contention); keys whose
+ * group membership changed or are brand new; and the keys of any op whose actor's
+ * reliability changed (a needs_human conflict embeds the op's reliability-derived score,
+ * so reliability changes are not gated by contention here — A1 may tighten this).
+ *
+ * Throws {@link NonIncrementalError} when the preconditions don't hold; the caller then
+ * falls back to a full reduce. tree/headOps are rebuilt fully (cheap, in-memory) in A0;
+ * A3 will make the tree update incremental too.
+ */
+export declare function reduceIncremental(snap: ReduceSnapshot, next: ReduceInput): ReduceSnapshot;
+export declare function serializeSnapshot(snap: ReduceSnapshot): unknown;
+export declare function deserializeSnapshot(raw: unknown): ReduceSnapshot;
+//# sourceMappingURL=reducer.d.ts.map

package/dist/reducer/reducer.d.ts.map

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