@mailwoman/core 4.9.0 → 4.11.0

package/README.md

@@ -0,0 +1,90 @@
+# @mailwoman/core
+
+**The foundation of the Mailwoman address parser** — types, tokenization,
+classification primitives, solver, decoder, and the staged pipeline coordinator.
+Ships ~9 MB of provenance-tracked reference dictionaries (libpostal, Who's On
+First, chromium-i18n) consumed by the resolver and classifiers.
+
+```ts
+import { createRuntimePipeline, AddressParser, ComponentTag, Classification, Span } from "@mailwoman/core"
+
+const pipeline = createRuntimePipeline({ locale: "en-US" })
+const result = pipeline.parse("1600 Amphitheatre Parkway, Mountain View, CA 94043")
+```
+
+## What's inside
+
+| Module                | Purpose                                                                                                                                 |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| **`types/`**          | Core type system: `ComponentTag`, `Span`, `Classification`, `ClassificationMap`, `LocaleTag`                                            |
+| **`tokenization/`**   | Tokenizer primitives, whitespace/punctuation rules, token classification                                                                |
+| **`classification/`** | `Classification` data structure, `ClassificationMap`, span overlap resolution                                                           |
+| **`decoder/`**        | Span proposal → tree projection, BIO decoding, reconcile/merge strategies, confidence calibration                                       |
+| **`pipeline/`**       | `createRuntimePipeline` — the staged pipeline coordinator that wires normalize → query-shape → locale-gate → ... → classifier → decoder |
+| **`solver/`**         | Rule-based solver (the v0 rules engine), `Solution`, `Solver`                                                                           |
+| **`parser/`**         | `AddressParser` — high-level parse entry point (consumed by `mailwoman` CLI)                                                            |
+| **`resources/`**      | ~9 MB of shipped reference data: libpostal dictionaries, WOF place data, chromium-i18n address formats                                  |
+
+## Key exports
+
+```ts
+// Types
+export type { ComponentTag, Span, Classification, ClassificationMap, LocaleTag }
+
+// Pipeline
+export { createRuntimePipeline, type RuntimePipeline, type PipelineOpts }
+
+// Classification
+export { Classification, ClassificationMap }
+export { treeToClassification, classificationToTree }
+
+// Decoder
+export { decodeBioSpans, viterbiDecode, reconcileSpans }
+export { createCalibrator, type Calibrator } // isotonic confidence calibration
+
+// Solver (v0 rules)
+export { Solver, Solution }
+
+// Tokenization
+export { tokenize, Token, TokenClass }
+
+// Resources
+export { loadDictionary, getAvailableLanguages }
+```
+
+## Pipeline architecture
+
+Mailwoman's runtime pipeline is a staged coordinator that chains pure-function
+stages with typed handoffs:
+
+```
+normalize → query-shape → locale-gate → kind-classifier → phrase-grouper → classifier → decoder
+```
+
+Each stage is published as its own `@mailwoman/*` package and wired together by
+the pipeline coordinator in this package. The design ensures every stage is
+independently testable, benchmarkable, and replaceable.
+
+## Reference data
+
+This package ships immutable, provenance-tracked dictionaries consumed by the
+resolver and rule-based classifiers:
+
+- **libpostal** — multilingual street types, place names, directional/ordinal tokens
+- **Who's On First** — place hierarchy and geography
+- **chromium-i18n** — per-country address format templates
+
+The dictionaries are ~9 MB total and are loaded lazily.
+
+## Related
+
+- [`mailwoman`](../mailwoman) — the user-facing CLI + `AddressParser`
+- [`@mailwoman/normalize`](../normalize) — Stage 1 of the pipeline
+- [`@mailwoman/neural`](../neural) — neural classifier (ONNX runtime)
+- [`@mailwoman/classifiers`](../classifiers) — rule-based classifiers
+- [What Mailwoman Is](https://mailwoman.sister.software/articles/concepts/what-mailwoman-is/)
+- [Staged Pipeline Contract](https://mailwoman.sister.software/articles/plan/reference/STAGES/)
+
+## License
+
+[AGPL-3.0-only](https://www.gnu.org/licenses/agpl-3.0.html)

package/data/coarse-placer/meta.json

@@ -1,49 +1,18 @@
 {
-  "classes": [
-    "US",
-    "FR",
-    "GB",
-    "CN",
-    "NL",
-    "IT",
-    "DE",
-    "JP",
-    "ES",
-    "KR",
-    "TW",
-    "OTHER"
-  ],
-  "featureDim": 65536,
-  "temperature": 1.2,
-  "bias": [
-    -2.534797191619873,
-    -2.1968510150909424,
-    -1.1691420078277588,
-    -0.1516338437795639,
-    -1.0911738872528076,
-    0.4597792327404022,
-    1.1227235794067383,
-    0.8241579532623291,
-    1.009660005569458,
-    0.47969329357147217,
-    0.34428685903549194,
-    3.046959161758423
-  ],
-  "trainedAt": null,
-  "trainRows": 612888,
-  "quantization": "int8-per-row",
-  "scales": [
-    0.01638676988796925,
-    0.018822564853457954,
-    0.024230125382190614,
-    0.0221641082463302,
-    0.04191271714338168,
-    0.019635750552800698,
-    0.022043046050184353,
-    0.02781985688397265,
-    0.02106240227466493,
-    0.022867627031221166,
-    0.029368993804210753,
-    0.04316849220456101
-  ]
-}
+	"classes": ["US", "FR", "GB", "CN", "NL", "IT", "DE", "JP", "ES", "KR", "TW", "OTHER"],
+	"featureDim": 65536,
+	"temperature": 1.2,
+	"bias": [
+		-2.534797191619873, -2.1968510150909424, -1.1691420078277588, -0.1516338437795639, -1.0911738872528076,
+		0.4597792327404022, 1.1227235794067383, 0.8241579532623291, 1.009660005569458, 0.47969329357147217,
+		0.34428685903549194, 3.046959161758423
+	],
+	"trainedAt": null,
+	"trainRows": 612888,
+	"quantization": "int8-per-row",
+	"scales": [
+		0.01638676988796925, 0.018822564853457954, 0.024230125382190614, 0.0221641082463302, 0.04191271714338168,
+		0.019635750552800698, 0.022043046050184353, 0.02781985688397265, 0.02106240227466493, 0.022867627031221166,
+		0.029368993804210753, 0.04316849220456101
+	]
+}

package/out/decoder/arbitrate-tree.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Containment-preserving arbitration (#478 inc 3, fix-v1).
+ *
+ *   The first arbitration implementation flattened the neural parse to proposals, unioned the solved
+ *   v0 proposals, filtered per-component, resolved span overlaps, and rebuilt a FLAT tree. That
+ *   lost containment two ways (diagnosed in `2026-06-17-478-arbitration-arena-gate.md`): the
+ *   overlap pass evicted a `street` for the `street_suffix` sitting inside it (street dropped on
+ *   42% of rows), and the flat tree lost the region→locality structure the resolver needs
+ *   (wrong-state namesakes, coord p50 3.3 km → 1069 km).
+ *
+ *   This applies arbitration as **edits on the nested neural argmax tree** — never flattening, never
+ *   restructuring — so the neural tree's containment is preserved by construction. Used only on the
+ *   `rule_preferred` route; `neural_preferred` / `abstain` pass the neural tree through untouched.
+ *
+ *   The edits (DeepSeek-coordinated, 2026-06-17):
+ *
+ *   1. **Relabel** — when a rule proposal covers the EXACT span of a neural node but assigns a different
+ *        tag, take the rule's tag (the genuine same-span disagreement; rule wins under
+ *        `rule_preferred`). Structure unchanged — only the node's tag/provenance.
+ *   2. **Add missing tags** — a rule proposal whose tag is absent from the neural tree AND whose span
+ *        doesn't overlap any neural node is added as a new root (a component neural missed
+ *        entirely).
+ *
+ *   What it deliberately does NOT do: replace a neural node with a differently-spanned rule node,
+ *   drop neural's sub-component decomposition (`street_suffix`/`street_prefix`), or add an
+ *   overlapping rule node. So a clean address — where neural and v0 agree on tags+spans and differ
+ *   only in street decomposition — is a **no-op**. The cost is losing pure-decomposition wins (low
+ *   value); the gate re-run is the arbiter.
+ */
+import type { ClassificationProposal } from "../types/index.js";
+import type { AddressTree } from "./types.js";
+/**
+ * Edit the nested neural argmax tree with the solved v0 (rule) parse under the `rule_preferred`
+ * route — relabel same-span tag disagreements toward rule, add rule-only non-overlapping missing
+ * tags. Containment-preserving (no flatten, no restructure). Input is not mutated.
+ *
+ * @param tree The neural argmax `AddressTree`.
+ * @param ruleProposals Proposals from the solved v0 parse (`solutionToProposals`).
+ */
+export declare function applyRuleArbitration(tree: AddressTree, ruleProposals: readonly ClassificationProposal[]): AddressTree;
+//# sourceMappingURL=arbitrate-tree.d.ts.map

package/out/decoder/arbitrate-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arbitrate-tree.d.ts","sourceRoot":"","sources":["../../decoder/arbitrate-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC/D,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,YAAY,CAAA;AAU1D;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE,SAAS,sBAAsB,EAAE,GAAG,WAAW,CAgDrH"}

package/out/decoder/arbitrate-tree.js

@@ -0,0 +1,97 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Containment-preserving arbitration (#478 inc 3, fix-v1).
+ *
+ *   The first arbitration implementation flattened the neural parse to proposals, unioned the solved
+ *   v0 proposals, filtered per-component, resolved span overlaps, and rebuilt a FLAT tree. That
+ *   lost containment two ways (diagnosed in `2026-06-17-478-arbitration-arena-gate.md`): the
+ *   overlap pass evicted a `street` for the `street_suffix` sitting inside it (street dropped on
+ *   42% of rows), and the flat tree lost the region→locality structure the resolver needs
+ *   (wrong-state namesakes, coord p50 3.3 km → 1069 km).
+ *
+ *   This applies arbitration as **edits on the nested neural argmax tree** — never flattening, never
+ *   restructuring — so the neural tree's containment is preserved by construction. Used only on the
+ *   `rule_preferred` route; `neural_preferred` / `abstain` pass the neural tree through untouched.
+ *
+ *   The edits (DeepSeek-coordinated, 2026-06-17):
+ *
+ *   1. **Relabel** — when a rule proposal covers the EXACT span of a neural node but assigns a different
+ *        tag, take the rule's tag (the genuine same-span disagreement; rule wins under
+ *        `rule_preferred`). Structure unchanged — only the node's tag/provenance.
+ *   2. **Add missing tags** — a rule proposal whose tag is absent from the neural tree AND whose span
+ *        doesn't overlap any neural node is added as a new root (a component neural missed
+ *        entirely).
+ *
+ *   What it deliberately does NOT do: replace a neural node with a differently-spanned rule node,
+ *   drop neural's sub-component decomposition (`street_suffix`/`street_prefix`), or add an
+ *   overlapping rule node. So a clean address — where neural and v0 agree on tags+spans and differ
+ *   only in street decomposition — is a **no-op**. The cost is losing pure-decomposition wins (low
+ *   value); the gate re-run is the arbiter.
+ */
+function cloneNode(node) {
+    return { ...node, children: node.children.map(cloneNode) };
+}
+function spansOverlap(aStart, aEnd, bStart, bEnd) {
+    return aStart < bEnd && bStart < aEnd;
+}
+/**
+ * Edit the nested neural argmax tree with the solved v0 (rule) parse under the `rule_preferred`
+ * route — relabel same-span tag disagreements toward rule, add rule-only non-overlapping missing
+ * tags. Containment-preserving (no flatten, no restructure). Input is not mutated.
+ *
+ * @param tree The neural argmax `AddressTree`.
+ * @param ruleProposals Proposals from the solved v0 parse (`solutionToProposals`).
+ */
+export function applyRuleArbitration(tree, ruleProposals) {
+    const roots = tree.roots.map(cloneNode);
+    // 1. Relabel: a rule proposal on the EXACT span of a neural node, but a different tag → rule's tag.
+    const relabel = (node) => {
+        const hit = ruleProposals.find((p) => p.span.start === node.start && p.span.end === node.end && p.component !== node.tag);
+        if (hit) {
+            node.tag = hit.component;
+            node.source = "rule";
+            node.confidence = hit.confidence;
+            node.sourceId = hit.source_id;
+        }
+        for (const child of node.children)
+            relabel(child);
+    };
+    for (const root of roots)
+        relabel(root);
+    // Post-relabel inventory: which tags exist, and every node span (for the overlap guard).
+    const neuralTags = new Set();
+    const neuralSpans = [];
+    const collect = (node) => {
+        neuralTags.add(node.tag);
+        neuralSpans.push({ start: node.start, end: node.end });
+        for (const child of node.children)
+            collect(child);
+    };
+    for (const root of roots)
+        collect(root);
+    // 2. Add: a rule tag the neural tree lacks entirely, on a span that overlaps no neural node.
+    for (const p of ruleProposals) {
+        if (neuralTags.has(p.component))
+            continue;
+        if (neuralSpans.some((s) => spansOverlap(s.start, s.end, p.span.start, p.span.end)))
+            continue;
+        roots.push({
+            tag: p.component,
+            value: p.span.body,
+            start: p.span.start,
+            end: p.span.end,
+            confidence: p.confidence,
+            children: [],
+            source: p.source,
+            sourceId: p.source_id,
+        });
+        neuralTags.add(p.component); // a tag is added at most once
+        neuralSpans.push({ start: p.span.start, end: p.span.end });
+    }
+    roots.sort((a, b) => a.start - b.start);
+    return { ...tree, roots };
+}
+//# sourceMappingURL=arbitrate-tree.js.map

package/out/decoder/arbitrate-tree.js.map

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

package/out/decoder/index.d.ts

@@ -3,10 +3,12 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  */
+export * from "./arbitrate-tree.js";
 export * from "./build-tree.js";
 export * from "./calibration.js";
 export * from "./containment.js";
 export * from "./proposals-to-tree.js";
+export * from "./resolve-proposal-overlaps.js";
 export * from "./serialize-json.js";
 export * from "./serialize-tuples.js";
 export * from "./serialize-xml.js";

package/out/decoder/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../decoder/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../decoder/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA"}

package/out/decoder/index.js

@@ -3,10 +3,12 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  */
+export * from "./arbitrate-tree.js";
 export * from "./build-tree.js";
 export * from "./calibration.js";
 export * from "./containment.js";
 export * from "./proposals-to-tree.js";
+export * from "./resolve-proposal-overlaps.js";
 export * from "./serialize-json.js";
 export * from "./serialize-tuples.js";
 export * from "./serialize-xml.js";

package/out/decoder/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../decoder/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../decoder/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA"}

package/out/decoder/proposals-to-tree.d.ts

@@ -13,7 +13,26 @@
  *   For consumers that need containment back, re-tokenize the input and run the full decoder
  *   pipeline.
  */
-import type { ClassificationProposal } from "../types/index.js";
+import type { ClassificationProposal, ClassificationProposalSource, ComponentTag } from "../types/index.js";
 import type { AddressTree } from "./types.js";
 export declare function proposalsToTree(raw: string, proposals: readonly ClassificationProposal[]): AddressTree;
+/**
+ * The inverse of {@link proposalsToTree}: walk an `AddressTree` into a flat list of
+ * `ClassificationProposal`s (one per node, depth-first), tagged with the given `source` (#478
+ * increment 3). Used to bring the whole-text neural parse into the arbitration layer's proposal
+ * currency so it can be unioned with rule proposals and filtered by the policy registry.
+ *
+ * The spans are structural (`{ start, end, body }`) — we intentionally avoid `Span.from(...)`
+ * (which forces the tokenization module's filesystem-bound init); downstream proposal consumers
+ * read only `start` / `end` / `body`. Same convention as the neural proposal-classifier adapter.
+ *
+ * @param tree The parsed tree (e.g. the neural argmax tree).
+ * @param source Provenance stamped on every emitted proposal (`"neural"` here).
+ * @param opts.sourceId Optional stable id surfaced as `source_id`.
+ * @param opts.emits Optional tag allow-list; when set, only nodes with these tags are emitted.
+ */
+export declare function treeToProposals(tree: AddressTree, source: ClassificationProposalSource, opts?: {
+    sourceId?: string;
+    emits?: ReadonlySet<ComponentTag>;
+}): ClassificationProposal[];
 //# sourceMappingURL=proposals-to-tree.d.ts.map

package/out/decoder/proposals-to-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proposals-to-tree.d.ts","sourceRoot":"","sources":["../../decoder/proposals-to-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAgB,MAAM,mBAAmB,CAAA;AAC7E,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,YAAY,CAAA;AAE1D,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,sBAAsB,EAAE,GAAG,WAAW,CAatG"}
+{"version":3,"file":"proposals-to-tree.d.ts","sourceRoot":"","sources":["../../decoder/proposals-to-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAC3G,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,YAAY,CAAA;AAE1D,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,sBAAsB,EAAE,GAAG,WAAW,CAatG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,4BAA4B,EACpC,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAC,YAAY,CAAC,CAAA;CAAO,GACjE,sBAAsB,EAAE,CAqB1B"}

package/out/decoder/proposals-to-tree.js

@@ -27,4 +27,41 @@ export function proposalsToTree(raw, proposals) {
     roots.sort((a, b) => a.start - b.start);
     return { raw, roots };
 }
+/**
+ * The inverse of {@link proposalsToTree}: walk an `AddressTree` into a flat list of
+ * `ClassificationProposal`s (one per node, depth-first), tagged with the given `source` (#478
+ * increment 3). Used to bring the whole-text neural parse into the arbitration layer's proposal
+ * currency so it can be unioned with rule proposals and filtered by the policy registry.
+ *
+ * The spans are structural (`{ start, end, body }`) — we intentionally avoid `Span.from(...)`
+ * (which forces the tokenization module's filesystem-bound init); downstream proposal consumers
+ * read only `start` / `end` / `body`. Same convention as the neural proposal-classifier adapter.
+ *
+ * @param tree The parsed tree (e.g. the neural argmax tree).
+ * @param source Provenance stamped on every emitted proposal (`"neural"` here).
+ * @param opts.sourceId Optional stable id surfaced as `source_id`.
+ * @param opts.emits Optional tag allow-list; when set, only nodes with these tags are emitted.
+ */
+export function treeToProposals(tree, source, opts = {}) {
+    const proposals = [];
+    const { sourceId, emits } = opts;
+    const visit = (node) => {
+        if (!emits || emits.has(node.tag)) {
+            const span = { start: node.start, end: node.end, body: node.value };
+            proposals.push({
+                span,
+                component: node.tag,
+                confidence: node.confidence,
+                source,
+                source_id: sourceId ?? node.sourceId ?? source,
+                penalty: 0,
+            });
+        }
+        for (const child of node.children)
+            visit(child);
+    };
+    for (const root of tree.roots)
+        visit(root);
+    return proposals;
+}
 //# sourceMappingURL=proposals-to-tree.js.map

package/out/decoder/proposals-to-tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"proposals-to-tree.js","sourceRoot":"","sources":["../../decoder/proposals-to-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,MAAM,UAAU,eAAe,CAAC,GAAW,EAAE,SAA4C;IACxF,MAAM,KAAK,GAAkB,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAClD,GAAG,EAAE,CAAC,CAAC,SAAyB;QAChC,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI;QAClB,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK;QACnB,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG;QACf,UAAU,EAAE,CAAC,CAAC,UAAU;QACxB,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,QAAQ,EAAE,CAAC,CAAC,SAAS;KACrB,CAAC,CAAC,CAAA;IACH,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAA;IACvC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,CAAA;AACtB,CAAC"}
+{"version":3,"file":"proposals-to-tree.js","sourceRoot":"","sources":["../../decoder/proposals-to-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,MAAM,UAAU,eAAe,CAAC,GAAW,EAAE,SAA4C;IACxF,MAAM,KAAK,GAAkB,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAClD,GAAG,EAAE,CAAC,CAAC,SAAyB;QAChC,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI;QAClB,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK;QACnB,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG;QACf,UAAU,EAAE,CAAC,CAAC,UAAU;QACxB,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,QAAQ,EAAE,CAAC,CAAC,SAAS;KACrB,CAAC,CAAC,CAAA;IACH,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAA;IACvC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,CAAA;AACtB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,eAAe,CAC9B,IAAiB,EACjB,MAAoC,EACpC,OAAiE,EAAE;IAEnE,MAAM,SAAS,GAA6B,EAAE,CAAA;IAC9C,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,IAAI,CAAA;IAEhC,MAAM,KAAK,GAAG,CAAC,IAAiB,EAAQ,EAAE;QACzC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAqB,CAAA;YACtF,SAAS,CAAC,IAAI,CAAC;gBACd,IAAI;gBACJ,SAAS,EAAE,IAAI,CAAC,GAAG;gBACnB,UAAU,EAAE,IAAI,CAAC,UAAU;gBAC3B,MAAM;gBACN,SAAS,EAAE,QAAQ,IAAI,IAAI,CAAC,QAAQ,IAAI,MAAM;gBAC9C,OAAO,EAAE,CAAC;aACV,CAAC,CAAA;QACH,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ;YAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IAChD,CAAC,CAAA;IAED,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK;QAAE,KAAK,CAAC,IAAI,CAAC,CAAA;IAC1C,OAAO,SAAS,CAAA;AACjB,CAAC"}

package/out/decoder/resolve-proposal-overlaps.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Coherence pass for arbitrated proposals (#478 increment 3).
+ *
+ *   The arbitration layer unions proposals from multiple sources (whole-text `neural`, per-section
+ *   `rule`) and filters them per-component via the policy registry. That per-_tag_ filter is blind
+ *   to cross-_tag_ span overlap: a `neural` street span `[0,11]` ("350 5th Ave") and a `rule`
+ *   house_number `[0,3]` ("350") can both survive — different tags, overlapping spans. Fed straight
+ *   into {@link proposalsToTree} (which emits one flat root node per proposal, no overlap handling)
+ *   that yields an incoherent tree with overlapping nodes, which degrades or breaks the resolver.
+ *
+ *   This pass guarantees the invariant {@link proposalsToTree} needs: **no two surviving proposals
+ *   have overlapping spans.** It is a greedy interval selection — accept proposals in priority
+ *   order, skip any that overlap an already-accepted span.
+ *
+ *   ## The selection policy (the gate-tunable lever)
+ *
+ *   Priority is **confidence desc, then shorter span first, then earlier start**:
+ *
+ *   - _Confidence primary_ respects the arbitration that already happened — a source the registry kept
+ *       at high confidence wins its span.
+ *   - _Shorter-span-first on ties_ preserves finer decompositions: given equal-confidence
+ *       `street[0,11]` vs `{house_number[0,3], street[4,11]}`, the two finer spans are accepted and
+ *       the coarse subsuming span is dropped — keeping the street+house_number precondition intact
+ *       (the thing #566 broke). The neural argmax path labels per-token, so it normally emits the
+ *       finer decomposition itself; this tiebreak is the safety net when a coarse rule span
+ *       competes.
+ *
+ *   This policy is deliberately simple and deterministic. It is the lever the inc-3 assembled gate
+ *   validates: if it drops too many house numbers (precondition regression) the comparator is where
+ *   to look. (An alternative — earliest-end-first maximal-tiling, ignoring confidence — maximizes
+ *   the _count_ of non-overlapping spans but can let a spurious tiny span evict a correct large
+ *   one; confidence-primary guards against that.)
+ *
+ *   Pure module: reads only `span.{start,end}` + `confidence`. Safe to import anywhere.
+ */
+import type { ClassificationProposal } from "../types/index.js";
+/**
+ * Reduce a set of (possibly overlapping) arbitrated proposals to a coherent, non-overlapping set
+ * via greedy interval selection. The output is sorted by span start (the order
+ * {@link proposalsToTree} expects). Input is not mutated.
+ *
+ * @param proposals Arbitrated proposals (post policy-registry filter), any source, possibly
+ *   overlapping.
+ *
+ * @returns A subset with no two spans overlapping, in span-start order.
+ */
+export declare function resolveProposalOverlaps(proposals: readonly ClassificationProposal[]): ClassificationProposal[];
+//# sourceMappingURL=resolve-proposal-overlaps.d.ts.map

package/out/decoder/resolve-proposal-overlaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-proposal-overlaps.d.ts","sourceRoot":"","sources":["../../decoder/resolve-proposal-overlaps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAO/D;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,sBAAsB,EAAE,GAAG,sBAAsB,EAAE,CAmB9G"}

package/out/decoder/resolve-proposal-overlaps.js

@@ -0,0 +1,74 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Coherence pass for arbitrated proposals (#478 increment 3).
+ *
+ *   The arbitration layer unions proposals from multiple sources (whole-text `neural`, per-section
+ *   `rule`) and filters them per-component via the policy registry. That per-_tag_ filter is blind
+ *   to cross-_tag_ span overlap: a `neural` street span `[0,11]` ("350 5th Ave") and a `rule`
+ *   house_number `[0,3]` ("350") can both survive — different tags, overlapping spans. Fed straight
+ *   into {@link proposalsToTree} (which emits one flat root node per proposal, no overlap handling)
+ *   that yields an incoherent tree with overlapping nodes, which degrades or breaks the resolver.
+ *
+ *   This pass guarantees the invariant {@link proposalsToTree} needs: **no two surviving proposals
+ *   have overlapping spans.** It is a greedy interval selection — accept proposals in priority
+ *   order, skip any that overlap an already-accepted span.
+ *
+ *   ## The selection policy (the gate-tunable lever)
+ *
+ *   Priority is **confidence desc, then shorter span first, then earlier start**:
+ *
+ *   - _Confidence primary_ respects the arbitration that already happened — a source the registry kept
+ *       at high confidence wins its span.
+ *   - _Shorter-span-first on ties_ preserves finer decompositions: given equal-confidence
+ *       `street[0,11]` vs `{house_number[0,3], street[4,11]}`, the two finer spans are accepted and
+ *       the coarse subsuming span is dropped — keeping the street+house_number precondition intact
+ *       (the thing #566 broke). The neural argmax path labels per-token, so it normally emits the
+ *       finer decomposition itself; this tiebreak is the safety net when a coarse rule span
+ *       competes.
+ *
+ *   This policy is deliberately simple and deterministic. It is the lever the inc-3 assembled gate
+ *   validates: if it drops too many house numbers (precondition regression) the comparator is where
+ *   to look. (An alternative — earliest-end-first maximal-tiling, ignoring confidence — maximizes
+ *   the _count_ of non-overlapping spans but can let a spurious tiny span evict a correct large
+ *   one; confidence-primary guards against that.)
+ *
+ *   Pure module: reads only `span.{start,end}` + `confidence`. Safe to import anywhere.
+ */
+/** Half-open interval overlap: `[aStart,aEnd)` and `[bStart,bEnd)` share at least one position. */
+function spansOverlap(a, b) {
+    return a.start < b.end && b.start < a.end;
+}
+/**
+ * Reduce a set of (possibly overlapping) arbitrated proposals to a coherent, non-overlapping set
+ * via greedy interval selection. The output is sorted by span start (the order
+ * {@link proposalsToTree} expects). Input is not mutated.
+ *
+ * @param proposals Arbitrated proposals (post policy-registry filter), any source, possibly
+ *   overlapping.
+ *
+ * @returns A subset with no two spans overlapping, in span-start order.
+ */
+export function resolveProposalOverlaps(proposals) {
+    if (proposals.length <= 1)
+        return [...proposals];
+    const ranked = [...proposals].sort((a, b) => {
+        if (b.confidence !== a.confidence)
+            return b.confidence - a.confidence; // higher confidence first
+        const lenA = a.span.end - a.span.start;
+        const lenB = b.span.end - b.span.start;
+        if (lenA !== lenB)
+            return lenA - lenB; // shorter (finer) span first — preserve decompositions
+        return a.span.start - b.span.start; // earlier start first — stable, deterministic
+    });
+    const kept = [];
+    for (const proposal of ranked) {
+        if (kept.every((k) => !spansOverlap(k.span, proposal.span))) {
+            kept.push(proposal);
+        }
+    }
+    return kept.sort((a, b) => a.span.start - b.span.start);
+}
+//# sourceMappingURL=resolve-proposal-overlaps.js.map

package/out/decoder/resolve-proposal-overlaps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-proposal-overlaps.js","sourceRoot":"","sources":["../../decoder/resolve-proposal-overlaps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAIH,mGAAmG;AACnG,SAAS,YAAY,CAAC,CAAiC,EAAE,CAAiC;IACzF,OAAO,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,CAAA;AAC1C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,uBAAuB,CAAC,SAA4C;IACnF,IAAI,SAAS,CAAC,MAAM,IAAI,CAAC;QAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAAA;IAEhD,MAAM,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QAC3C,IAAI,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,UAAU;YAAE,OAAO,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,CAAA,CAAC,0BAA0B;QAChG,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAA;QACtC,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAA;QACtC,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,IAAI,GAAG,IAAI,CAAA,CAAC,uDAAuD;QAC7F,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAA,CAAC,8CAA8C;IAClF,CAAC,CAAC,CAAA;IAEF,MAAM,IAAI,GAA6B,EAAE,CAAA;IACzC,KAAK,MAAM,QAAQ,IAAI,MAAM,EAAE,CAAC;QAC/B,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAC7D,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACpB,CAAC;IACF,CAAC;IAED,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACxD,CAAC"}

package/out/parser/index.d.ts

@@ -5,4 +5,5 @@
  */
 export * from "./AddressParser.js";
 export * from "./proposal-pipeline.js";
+export * from "./solution-to-proposals.js";
 //# sourceMappingURL=index.d.ts.map

package/out/parser/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../parser/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../parser/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA;AACtC,cAAc,4BAA4B,CAAA"}

package/out/parser/index.js

@@ -5,4 +5,5 @@
  */
 export * from "./AddressParser.js";
 export * from "./proposal-pipeline.js";
+export * from "./solution-to-proposals.js";
 //# sourceMappingURL=index.js.map

package/out/parser/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../parser/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../parser/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA;AACtC,cAAc,4BAA4B,CAAA"}

package/out/parser/proposal-pipeline.d.ts

@@ -14,6 +14,7 @@
  *
  *   Pure module: no resource imports, no top-level await. Safe to import from anywhere.
  */
+import type { InputShapeRoute } from "../policy/input-shape-router.js";
 import type { PolicyRegistry } from "../policy/policy.js";
 import type { Span, TokenContext } from "../tokenization/index.js";
 import { type ClassificationProposal, type ClassifierContext, type ProposalClassifier } from "../types/index.js";
@@ -26,10 +27,20 @@ import { type ClassificationProposal, type ClassifierContext, type ProposalClass
  */
 export declare function collectProposals(sections: readonly Span[], classifiers: readonly ProposalClassifier[], context?: ClassifierContext): Promise<ClassificationProposal[]>;
 /**
- * Optional policy filter. Returns the input unchanged when `policy` is undefined, otherwise
- * delegates to `PolicyRegistry.apply`.
+ * Optional policy filter.
+ *
+ * Resolution order:
+ *
+ * 1. An explicit `policy` registry is authoritative (the operator's config wins entirely).
+ * 2. Otherwise, when an input-shape `routerPrior` is supplied (#478 increment 2), build a registry
+ *    whose default mode is the routed prior and apply that.
+ * 3. Otherwise return the input unchanged.
+ *
+ * Increment 2 ships with no production caller passing `routerPrior` (the production `runPipeline`
+ * does not yet feed live signals — that is increment 3), so this stays byte-stable by default. The
+ * seam is exercised by the router/proposal-pipeline tests.
  */
-export declare function filterByPolicy(proposals: readonly ClassificationProposal[], policy: PolicyRegistry | undefined, locale: string | undefined): ClassificationProposal[];
+export declare function filterByPolicy(proposals: readonly ClassificationProposal[], policy: PolicyRegistry | undefined, locale: string | undefined, routerPrior?: InputShapeRoute): ClassificationProposal[];
 /**
  * Locate the context Span whose [start, end] best matches the given char range.
  *
@@ -60,6 +71,8 @@ export declare function runProposalPipeline(context: TokenContext, classifiers:
     policy?: PolicyRegistry;
     locale?: string;
     classifierContext?: ClassifierContext;
+    /** Input-shape routed prior (#478 increment 2). Applied only when `policy` is absent. */
+    routerPrior?: InputShapeRoute;
 }): Promise<{
     proposals: ClassificationProposal[];
     writeback: WritebackResult;