@mailwoman/bdc 8.3.0

package/out/sdk/plausibility.d.ts

@@ -0,0 +1,256 @@
+/**
+ * @copyright Sister Software.
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `plausibilityCheck` (2b task 5, spec §3.2/§4) — the heart of the BDC plausibility vertical. Composes
+ *   `filingLandscape` (2a) + `nearestInfrastructure` (2b task 4) into ONE evidence bundle over a single
+ *   broadband-service claim, under the registry-backed doctrine's positive-evidence-only invariant (spec
+ *   §4): a BDC filing or a nearby infrastructure hit can RAISE confidence; their absence can only ever
+ *   read as "unknown" or "no supporting evidence found, coverage permitting" — NEVER as "implausible."
+ *   The four §7-2b acceptance gates land in Task 6 as their own test file; this module is designed for
+ *   them but doesn't assert them itself.
+ *
+ *   **Claim resolution (decision 4).** A claim's spatial key resolves two INDEPENDENT ways:
+ *
+ *   - **Filing evidence's spatial key**: `claim.geoid` wins outright when present — `filingLandscape({
+ *     geoids: [claim.geoid] })` is the NATIVE, exact path (no h3 approximation needed), so
+ *     `block_resolution` is `"geoid"`. Otherwise a coordinate is required (`claim.point` directly, or
+ *     `claim.address` geocoded via `deps.geocode`) and filing evidence goes through
+ *     `filingLandscape({ h3Cells: [cell] })` — this is the UNSOUND h3-cell approximation decision 4
+ *     pins (a claim's own res-9 cell can differ from its true block centroid's cell), so
+ *     `block_resolution` is `"h3_cell_approximation"`. Only one of the two is ever emitted — the union
+ *     type is deliberately NOT `("geoid" | "h3_cell_approximation")[]`.
+ *   - **Physical evidence's search center**: independent of the above — `claim.point` (or the geocoded
+ *     `claim.address`) directly, whenever available. A GEOID-ONLY claim (no point, no address) has NO
+ *     coordinate to search from: bdc.db stores no public geoid→centroid resolver (deriving one would
+ *     need the same Fabric-adjacent block-centroid machinery the vertical explicitly keeps out of reach
+ *     — §2.2's boundary), so physical evidence is skipped entirely for that shape of claim. This is a
+ *     genuine, documented capability gap, not a missing-layer abstain: `coverage_confidence` still
+ *     degrades honestly (see below), but no `PlausibilityEvidence` abstain variant fits "no coordinate
+ *     available," so none is fabricated.
+ *
+ *   **Tech → physical-category mapping (decision 8's "reuse, never re-derive" extended to this table).**
+ *   {@link PLAUSIBILITY_TECH_PHYSICAL_CATEGORIES}: fiber (`OpticalCarrierFiber`, code 50) implies
+ *   `telecom_exchange`/`telecom_cabinet`/`data_center`; the three fixed-wireless codes (70/71/72) imply
+ *   `tower_comms`; every other code (DSL, cable, satellite, power-line, other) maps to `[]` — no physical
+ *   falsifier is claimed for those technologies, because OSM/Overture carry no plant category that
+ *   physically falsifies them. A `[]` mapping means the physical-evidence step is skipped as
+ *   NOT-APPLICABLE (distinct from "layer missing" — see `coverage_confidence` below).
+ *
+ *   **Filing evidence.** Every `ProviderFilingSummary` row `filingLandscape` returns for the resolved
+ *   block becomes its own `{ type: "filing" }` evidence entry (ANY provider filing there is positive
+ *   evidence a market exists, informative regardless of tech match — spec §3.2 step 2's "a filing that
+ *   contradicts it… weak signal, not disproof"). `corroborates` is true only when the filing's
+ *   `technology_code` matches the claim AND its `speed_bucket` ranks at or above the claimed download
+ *   speed's own bucket (via the exported {@link speedBucketForDownloadSpeed} + the four bucket consts —
+ *   decision 8: reused, never re-derived). A same-tech LESSER filing, or a different-tech filing, is
+ *   still emitted with `corroborates: false` — never treated as disproof of anything.
+ *
+ *   - bdc.db absent entirely → one `{ type: "abstain", reason: "requires_bdc_layer" }` entry (decision
+ *     6); `vintage` stays `null` — the ONLY case it does (per the produced type's own doc comment).
+ *   - bdc.db present but the resolved block/cell itself carries no survey evidence (`unknown_block_count`
+ *     > 0 for the one queried unit) → `{ type: "abstain", reason: "insufficient_survey_data", layer:
+ *     "bdc" }`. `vintage` IS still populated here — the LAYER didn't abstain, only this one cell lacks
+ *     coverage.
+ *   - bdc.db present, block surveyed, zero filings → the spec's POSITIVE meaning-of-zero case ("a
+ *     genuine 'surveyed, zero providers here' result" — `filing-landscape.ts`'s own docstring). No
+ *     `filing` evidence entries are pushed (there's nothing to report), but the filing layer still
+ *     counts as COVERED for `coverage_confidence` — the absence is informative, not unknown.
+ *
+ *   **Physical evidence.** Symmetric to the above, over `nearestInfrastructure`'s hits — every hit
+ *   becomes its own `{ type: "physical_plant" }` entry, nearest-first, whatever `nearestInfrastructure`'s
+ *   own ring/limit budget returns.
+ *
+ *   - The tech maps to `[]` categories (no physical falsifier claimed) → the step is skipped outright;
+ *     no evidence entry, no abstain, and this axis is excluded from `coverage_confidence` (see below).
+ *   - The tech implies categories but `deps.poi` is absent → `{ type: "abstain", reason:
+ *     "requires_build_local_layer", layer: "poi" }` (decision 6 — the poi-executor abstain precedent).
+ *   - The tech implies categories, `deps.poi` is present, but no coordinate is resolvable (a geoid-only
+ *     claim) → no evidence entry, no abstain (see the claim-resolution note above); the axis degrades to
+ *     UNKNOWN for `coverage_confidence` purposes.
+ *   - Otherwise → `nearestInfrastructure` runs; each hit is emitted, and the searched point's OWN res-6
+ *     coverage cell (independent of whether any hit was found — a covered-but-empty cell is real
+ *     evidence the area was surveyed) is read directly via `readLayerCoverage` to determine the layer's
+ *     coverage state for this claim.
+ *
+ *   **`coverage_confidence` — survey completeness, NOT evidence-found.** This is deliberately orthogonal
+ *   to whether any evidence was actually found (spec §4 rule 4: "coverage_confidence is mandatory on
+ *   every answer… the product's honesty is this refusal to guess" — a refusal that has to hold even when
+ *   the answer turns out to be "nothing found"). Each layer contributes one of `"covered"` / `"unknown"`
+ *   / `"not_applicable"` (the last only for the physical axis, when the tech maps to no category), and
+ *   the pair combines per the brief's literal formula: both covered → `"high"`; either UNKNOWN → degrade
+ *   to `"low"`; both absent/unknown → `"insufficient_survey_data"`.
+ *
+ *   The `"not_applicable"` extension (not literally spelled out in the brief, since the brief's formula
+ *   assumes a real pair) is this module's own documented decision, deliberately CONSERVATIVE: a tech with
+ *   no physical falsifier (DSL, cable, satellite, power-line) can never reach `"high"` confidence from
+ *   filing coverage alone — it degrades to filing-covered → `"low"`, filing-unknown/absent →
+ *   `"insufficient_survey_data"`. Rationale: spec §4 frames physical co-presence as the vertical's
+ *   distinguishing "falsifier that only fires positively" and reserves `"high"` for genuine two-channel
+ *   corroboration (Gate 2 in Task 6: "matching filing + nearby plant in covered cells… high"); a tech
+ *   that structurally can never offer a second channel should not be able to claim the same top
+ *   confidence a fiber claim earns by actually having one available. This reading is more conservative
+ *   than the alternative (treating the missing axis as inert and reporting `"high"` off filing alone) —
+ *   flagged here for review since Task 6's four gates don't exercise a no-physical-falsifier tech code.
+ *
+ *   **Ledger note (task 4 review; extended task 5 fix round 1, finding 2) — the per-layer coverage-resolution sanity
+ *   check.** Neither bdc.db's nor poi.db's `layer_manifest` records the COVERAGE-cell h3 resolution (6) that
+ *   `res9ShortCellToRes6Parent` hardcodes on both sides — only each layer's ROW-spine resolution (9,
+ *   `spineKeys.h3.resolution`) is ever recorded. A real fix needs a layer-contract schema addition (out
+ *   of scope for this task; the same follow-up task 4's report already ticketed). What IS practical and
+ *   cheap: each manifest is a single-row table already read at most once per call here, so whenever a layer is
+ *   WIRED — `bdcDB`, `poi`, or both, checked independently — {@link assertLayerSpineResolution} compares that one
+ *   layer's recorded `spineKeys.h3.resolution` directly against the `BDC_H3_RESOLUTION` constant `pointCell` is
+ *   actually derived from, and throws on a mismatch, catching a layer built at a different spine resolution before it
+ *   silently mis-joins a coverage cell. This is TWO-SIDED, not gated on both layers being present together: a
+ *   poi-only call still checks poi's own recorded resolution, since `readLayerCoverage`'s poi-side join key (below)
+ *   is derived from `BDC_H3_RESOLUTION` regardless of whether `bdcDB` is wired at all (the original one-sided version
+ *   compared the two manifests to each other, so it silently skipped poi entirely whenever `bdcDB` was absent). It
+ *   can NOT catch a layer whose row spine is 9 but whose COVERAGE cells were derived at some OTHER resolution than 6
+ *   — that gap needs the schema addition, not a runtime assertion.
+ */
+import type { DatabaseClient } from "@mailwoman/core/kysley/client";
+import { type LayerContractDatabase } from "@mailwoman/core/layers";
+import type { POILookup } from "@mailwoman/resolver-wof-sqlite/poi-lookup";
+import { type PointLiteral } from "@mailwoman/spatial";
+import { type BDCDatabase } from "../schema.ts";
+import { type ProviderFilingSummary } from "./filing-landscape.ts";
+import { type InfrastructureHit } from "./nearest-infrastructure.ts";
+/**
+ * One claimed broadband-service assertion to check. Exactly one spatial field is expected in practice (`geoid` wins if
+ * present — see the module docstring's claim-resolution note); `plausibilityCheck` throws if NONE of
+ * `geoid`/`point`/`address` resolves to something usable.
+ */
+export interface PlausibilityClaim {
+    address?: string;
+    point?: PointLiteral;
+    geoid?: string;
+    technologyCode: number;
+    claimedDownloadMbps: number;
+}
+/**
+ * Reasons `plausibilityCheck` can abstain on one evidence channel — decision 6, the poi-executor abstain precedent
+ * (`mailwoman/poi-executor.ts`), extended with the bdc-layer-absent case and the survey-gap-for-this-cell case.
+ */
+export type PlausibilityAbstainReason = "requires_build_local_layer" | "requires_bdc_layer" | "insufficient_survey_data";
+export type PlausibilityEvidence = {
+    type: "filing";
+    filing: ProviderFilingSummary;
+    vintage: string;
+    corroborates: boolean;
+} | {
+    type: "physical_plant";
+    hit: InfrastructureHit;
+} | {
+    type: "abstain";
+    reason: PlausibilityAbstainReason;
+    layer?: string;
+};
+/**
+ * One evidence channel's survey-completeness state for THIS claim, WITH the reason a non-`"covered"` state applies —
+ * task 5 fix round 1 (review finding 1): `coverage_confidence` alone folds several genuinely different situations into
+ * the same `"low"`/`"insufficient_survey_data"` verdict (a tech with no physical falsifier at all vs. a real poi survey
+ * gap vs. a geoid-only claim with no coordinate to search from), and Task 6's gates need to attribute WHICH one
+ * applies. `"not_applicable"` and `"no_coordinate"` are only ever produced for the physical axis; the filing axis only
+ * ever reaches `"covered"`, `"layer_missing"`, or `"cell_unsurveyed"`.
+ */
+export type PlausibilityCoverageAxisState = "covered"
+/**
+ * The required dependency (`deps.bdcDB` for filing, `deps.poi` for physical) was never wired at all — the
+ * `requires_bdc_layer` / `requires_build_local_layer` abstain precedent.
+ */
+ | "layer_missing"
+/**
+ * The dependency IS wired, but the specific queried block/cell carries no survey coverage of its own — the
+ * `insufficient_survey_data` abstain precedent (filing), or an absent `readLayerCoverage` read (physical).
+ */
+ | "cell_unsurveyed"
+/**
+ * Physical axis only: the claim resolved no coordinate (a geoid-only claim — see the module docstring's
+ * claim-resolution note), so no physical-evidence search point exists. A genuine capability gap, not a missing layer
+ * — distinct from `"layer_missing"` even though both degrade `coverage_confidence` the same way.
+ */
+ | "no_coordinate"
+/**
+ * Physical axis only: the claimed technology maps to no physical-plant category at all (see
+ * {@link PLAUSIBILITY_TECH_PHYSICAL_CATEGORIES}) — there is no applicable second channel for this tech, ever,
+ * regardless of layer availability. Distinct from every other state: this claim can never earn `"high"`.
+ */
+ | "not_applicable";
+/**
+ * Per-axis attribution for {@link PlausibilityBundle.coverage_confidence} — see {@link PlausibilityCoverageAxisState}.
+ * Added alongside `coverage_confidence` (kept as-is for compatibility) rather than replacing it.
+ */
+export interface PlausibilityCoverageDetail {
+    filing: PlausibilityCoverageAxisState;
+    physical: PlausibilityCoverageAxisState;
+}
+export interface PlausibilityBundle {
+    claim: PlausibilityClaim;
+    evidence_found: PlausibilityEvidence[];
+    coverage_confidence: "high" | "low" | "insufficient_survey_data";
+    /**
+     * Per-axis WHY behind `coverage_confidence` — task 5 fix round 1 (finding 1). ALWAYS present, mirroring
+     * `block_resolution`'s always-present discipline.
+     */
+    coverage_detail: PlausibilityCoverageDetail;
+    /**
+     * `"geoid"` when `claim.geoid` drove the filing-evidence lookup (the exact, native path); otherwise
+     * `"h3_cell_approximation"` (decision 4 — the point/address path's unsound-but-flagged h3 cell). ALWAYS present on
+     * every returned bundle.
+     */
+    block_resolution: "geoid" | "h3_cell_approximation";
+    /**
+     * `null` ONLY when the bdc layer itself abstained (`deps.bdcDB` absent). Populated in every other case, including
+     * when the specific queried block/cell is itself unsurveyed.
+     */
+    vintage: string | null;
+}
+/**
+ * Structural mirror of `mailwoman/geocode-core.ts`'s `GeocodeResult` — `@mailwoman/bdc` MUST NOT import from the
+ * `mailwoman` workspace (`mailwoman/package.json` already depends on `@mailwoman/bdc`; the reverse edge would be
+ * circular). Only the two fields this scorer actually consumes are typed here; a real `GeocodeResult` is structurally
+ * assignable to this type without any adapter, so a caller wiring `deps.geocode` at the CLI/MCP layer can pass a thin
+ * wrapper over `geocodeAddress` directly.
+ */
+export interface GeocodeLike {
+    lat: number | null;
+    lon: number | null;
+}
+/**
+ * The already-open infra layer this scorer composes against Task 4's `nearestInfrastructure`. The caller owns BOTH
+ * handles' open/dispose lifecycle (mirrors `nearestInfrastructure`'s own `using poiLookup = new POILookup(...)`
+ * precedent). `contractDB` is used two ways: passed straight through to `nearestInfrastructure` (per-hit coverage), and
+ * read directly here (the whole-cell coverage check this module needs for `coverage_confidence`, independent of whether
+ * any hit was actually found).
+ */
+export interface PlausibilityPOIDeps {
+    lookup: POILookup;
+    contractDB: DatabaseClient<LayerContractDatabase>;
+}
+export interface PlausibilityDeps {
+    bdcDB?: DatabaseClient<BDCDatabase>;
+    poi?: PlausibilityPOIDeps;
+    geocode?: (address: string) => Promise<GeocodeLike>;
+}
+/**
+ * Tech → physical-plant category mapping (exported per the task brief). Fiber implies the three
+ * infrastructure-extension categories a fiber network plausibly touches; the three fixed-wireless codes imply a comms
+ * tower; every other code maps to `[]` — no physical falsifier is claimed for it (see
+ * {@link physicalCategoriesForTechnology}).
+ */
+export declare const PLAUSIBILITY_TECH_PHYSICAL_CATEGORIES: Readonly<Record<number, readonly string[]>>;
+/**
+ * The poi-taxonomy category ids a physical-plant search should probe for a given BDC technology code, or `[]` when that
+ * technology has no physical falsifier in this vertical (see {@link PLAUSIBILITY_TECH_PHYSICAL_CATEGORIES}).
+ */
+export declare function physicalCategoriesForTechnology(technologyCode: number): readonly string[];
+/**
+ * Compose filing evidence + physical evidence into one `{ claim, evidence_found, coverage_confidence }` bundle — see
+ * the module docstring for the full composition rules. Never emits anything expressible as "implausible": absence of a
+ * filing or of nearby plant only ever surfaces as an abstain, an omitted evidence entry, or a degraded
+ * `coverage_confidence` — never a negative verdict.
+ */
+export declare function plausibilityCheck(claim: PlausibilityClaim, deps: PlausibilityDeps): Promise<PlausibilityBundle>;
+//# sourceMappingURL=plausibility.d.ts.map

package/out/sdk/plausibility.d.ts.map

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

package/out/sdk/plausibility.js

@@ -0,0 +1,334 @@
+/**
+ * @copyright Sister Software.
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   `plausibilityCheck` (2b task 5, spec §3.2/§4) — the heart of the BDC plausibility vertical. Composes
+ *   `filingLandscape` (2a) + `nearestInfrastructure` (2b task 4) into ONE evidence bundle over a single
+ *   broadband-service claim, under the registry-backed doctrine's positive-evidence-only invariant (spec
+ *   §4): a BDC filing or a nearby infrastructure hit can RAISE confidence; their absence can only ever
+ *   read as "unknown" or "no supporting evidence found, coverage permitting" — NEVER as "implausible."
+ *   The four §7-2b acceptance gates land in Task 6 as their own test file; this module is designed for
+ *   them but doesn't assert them itself.
+ *
+ *   **Claim resolution (decision 4).** A claim's spatial key resolves two INDEPENDENT ways:
+ *
+ *   - **Filing evidence's spatial key**: `claim.geoid` wins outright when present — `filingLandscape({
+ *     geoids: [claim.geoid] })` is the NATIVE, exact path (no h3 approximation needed), so
+ *     `block_resolution` is `"geoid"`. Otherwise a coordinate is required (`claim.point` directly, or
+ *     `claim.address` geocoded via `deps.geocode`) and filing evidence goes through
+ *     `filingLandscape({ h3Cells: [cell] })` — this is the UNSOUND h3-cell approximation decision 4
+ *     pins (a claim's own res-9 cell can differ from its true block centroid's cell), so
+ *     `block_resolution` is `"h3_cell_approximation"`. Only one of the two is ever emitted — the union
+ *     type is deliberately NOT `("geoid" | "h3_cell_approximation")[]`.
+ *   - **Physical evidence's search center**: independent of the above — `claim.point` (or the geocoded
+ *     `claim.address`) directly, whenever available. A GEOID-ONLY claim (no point, no address) has NO
+ *     coordinate to search from: bdc.db stores no public geoid→centroid resolver (deriving one would
+ *     need the same Fabric-adjacent block-centroid machinery the vertical explicitly keeps out of reach
+ *     — §2.2's boundary), so physical evidence is skipped entirely for that shape of claim. This is a
+ *     genuine, documented capability gap, not a missing-layer abstain: `coverage_confidence` still
+ *     degrades honestly (see below), but no `PlausibilityEvidence` abstain variant fits "no coordinate
+ *     available," so none is fabricated.
+ *
+ *   **Tech → physical-category mapping (decision 8's "reuse, never re-derive" extended to this table).**
+ *   {@link PLAUSIBILITY_TECH_PHYSICAL_CATEGORIES}: fiber (`OpticalCarrierFiber`, code 50) implies
+ *   `telecom_exchange`/`telecom_cabinet`/`data_center`; the three fixed-wireless codes (70/71/72) imply
+ *   `tower_comms`; every other code (DSL, cable, satellite, power-line, other) maps to `[]` — no physical
+ *   falsifier is claimed for those technologies, because OSM/Overture carry no plant category that
+ *   physically falsifies them. A `[]` mapping means the physical-evidence step is skipped as
+ *   NOT-APPLICABLE (distinct from "layer missing" — see `coverage_confidence` below).
+ *
+ *   **Filing evidence.** Every `ProviderFilingSummary` row `filingLandscape` returns for the resolved
+ *   block becomes its own `{ type: "filing" }` evidence entry (ANY provider filing there is positive
+ *   evidence a market exists, informative regardless of tech match — spec §3.2 step 2's "a filing that
+ *   contradicts it… weak signal, not disproof"). `corroborates` is true only when the filing's
+ *   `technology_code` matches the claim AND its `speed_bucket` ranks at or above the claimed download
+ *   speed's own bucket (via the exported {@link speedBucketForDownloadSpeed} + the four bucket consts —
+ *   decision 8: reused, never re-derived). A same-tech LESSER filing, or a different-tech filing, is
+ *   still emitted with `corroborates: false` — never treated as disproof of anything.
+ *
+ *   - bdc.db absent entirely → one `{ type: "abstain", reason: "requires_bdc_layer" }` entry (decision
+ *     6); `vintage` stays `null` — the ONLY case it does (per the produced type's own doc comment).
+ *   - bdc.db present but the resolved block/cell itself carries no survey evidence (`unknown_block_count`
+ *     > 0 for the one queried unit) → `{ type: "abstain", reason: "insufficient_survey_data", layer:
+ *     "bdc" }`. `vintage` IS still populated here — the LAYER didn't abstain, only this one cell lacks
+ *     coverage.
+ *   - bdc.db present, block surveyed, zero filings → the spec's POSITIVE meaning-of-zero case ("a
+ *     genuine 'surveyed, zero providers here' result" — `filing-landscape.ts`'s own docstring). No
+ *     `filing` evidence entries are pushed (there's nothing to report), but the filing layer still
+ *     counts as COVERED for `coverage_confidence` — the absence is informative, not unknown.
+ *
+ *   **Physical evidence.** Symmetric to the above, over `nearestInfrastructure`'s hits — every hit
+ *   becomes its own `{ type: "physical_plant" }` entry, nearest-first, whatever `nearestInfrastructure`'s
+ *   own ring/limit budget returns.
+ *
+ *   - The tech maps to `[]` categories (no physical falsifier claimed) → the step is skipped outright;
+ *     no evidence entry, no abstain, and this axis is excluded from `coverage_confidence` (see below).
+ *   - The tech implies categories but `deps.poi` is absent → `{ type: "abstain", reason:
+ *     "requires_build_local_layer", layer: "poi" }` (decision 6 — the poi-executor abstain precedent).
+ *   - The tech implies categories, `deps.poi` is present, but no coordinate is resolvable (a geoid-only
+ *     claim) → no evidence entry, no abstain (see the claim-resolution note above); the axis degrades to
+ *     UNKNOWN for `coverage_confidence` purposes.
+ *   - Otherwise → `nearestInfrastructure` runs; each hit is emitted, and the searched point's OWN res-6
+ *     coverage cell (independent of whether any hit was found — a covered-but-empty cell is real
+ *     evidence the area was surveyed) is read directly via `readLayerCoverage` to determine the layer's
+ *     coverage state for this claim.
+ *
+ *   **`coverage_confidence` — survey completeness, NOT evidence-found.** This is deliberately orthogonal
+ *   to whether any evidence was actually found (spec §4 rule 4: "coverage_confidence is mandatory on
+ *   every answer… the product's honesty is this refusal to guess" — a refusal that has to hold even when
+ *   the answer turns out to be "nothing found"). Each layer contributes one of `"covered"` / `"unknown"`
+ *   / `"not_applicable"` (the last only for the physical axis, when the tech maps to no category), and
+ *   the pair combines per the brief's literal formula: both covered → `"high"`; either UNKNOWN → degrade
+ *   to `"low"`; both absent/unknown → `"insufficient_survey_data"`.
+ *
+ *   The `"not_applicable"` extension (not literally spelled out in the brief, since the brief's formula
+ *   assumes a real pair) is this module's own documented decision, deliberately CONSERVATIVE: a tech with
+ *   no physical falsifier (DSL, cable, satellite, power-line) can never reach `"high"` confidence from
+ *   filing coverage alone — it degrades to filing-covered → `"low"`, filing-unknown/absent →
+ *   `"insufficient_survey_data"`. Rationale: spec §4 frames physical co-presence as the vertical's
+ *   distinguishing "falsifier that only fires positively" and reserves `"high"` for genuine two-channel
+ *   corroboration (Gate 2 in Task 6: "matching filing + nearby plant in covered cells… high"); a tech
+ *   that structurally can never offer a second channel should not be able to claim the same top
+ *   confidence a fiber claim earns by actually having one available. This reading is more conservative
+ *   than the alternative (treating the missing axis as inert and reporting `"high"` off filing alone) —
+ *   flagged here for review since Task 6's four gates don't exercise a no-physical-falsifier tech code.
+ *
+ *   **Ledger note (task 4 review; extended task 5 fix round 1, finding 2) — the per-layer coverage-resolution sanity
+ *   check.** Neither bdc.db's nor poi.db's `layer_manifest` records the COVERAGE-cell h3 resolution (6) that
+ *   `res9ShortCellToRes6Parent` hardcodes on both sides — only each layer's ROW-spine resolution (9,
+ *   `spineKeys.h3.resolution`) is ever recorded. A real fix needs a layer-contract schema addition (out
+ *   of scope for this task; the same follow-up task 4's report already ticketed). What IS practical and
+ *   cheap: each manifest is a single-row table already read at most once per call here, so whenever a layer is
+ *   WIRED — `bdcDB`, `poi`, or both, checked independently — {@link assertLayerSpineResolution} compares that one
+ *   layer's recorded `spineKeys.h3.resolution` directly against the `BDC_H3_RESOLUTION` constant `pointCell` is
+ *   actually derived from, and throws on a mismatch, catching a layer built at a different spine resolution before it
+ *   silently mis-joins a coverage cell. This is TWO-SIDED, not gated on both layers being present together: a
+ *   poi-only call still checks poi's own recorded resolution, since `readLayerCoverage`'s poi-side join key (below)
+ *   is derived from `BDC_H3_RESOLUTION` regardless of whether `bdcDB` is wired at all (the original one-sided version
+ *   compared the two manifests to each other, so it silently skipped poi entirely whenever `bdcDB` was absent). It
+ *   can NOT catch a layer whose row spine is 9 but whose COVERAGE cells were derived at some OTHER resolution than 6
+ *   — that gap needs the schema addition, not a runtime assertion.
+ */
+import { readLayerCoverage, readLayerManifest } from "@mailwoman/core/layers";
+import { shortCellToInt } from "@mailwoman/spatial";
+import { latLngToCell } from "h3-js";
+import { BDC_H3_RESOLUTION } from "../schema.js";
+import { BDC_SPEED_BUCKET_100_1000, BDC_SPEED_BUCKET_25_100, BDC_SPEED_BUCKET_GIGABIT, BDC_SPEED_BUCKET_UNDER_25, filingLandscape, res9ShortCellToRes6Parent, speedBucketForDownloadSpeed, } from "./filing-landscape.js";
+import { nearestInfrastructure } from "./nearest-infrastructure.js";
+import { BroadbandTechnologyCategory, BroadbandTechnologyCategoryToCodeSet, BroadbandTechnologyCode, } from "./technologies.js";
+/**
+ * The three fixed-wireless codes (unlicensed/licensed/licensed-by-rule), read off
+ * {@link BroadbandTechnologyCategoryToCodeSet} (decision 8: reuse, never re-derive) rather than hand-enumerated here a
+ * second time — an FCC code addition to the `FixedWireless` category in `technologies.ts` now flows straight through to
+ * {@link PLAUSIBILITY_TECH_PHYSICAL_CATEGORIES} instead of silently missing this table.
+ */
+const FIXED_WIRELESS_CODES = BroadbandTechnologyCategoryToCodeSet[BroadbandTechnologyCategory.FixedWireless];
+/**
+ * Tech → physical-plant category mapping (exported per the task brief). Fiber implies the three
+ * infrastructure-extension categories a fiber network plausibly touches; the three fixed-wireless codes imply a comms
+ * tower; every other code maps to `[]` — no physical falsifier is claimed for it (see
+ * {@link physicalCategoriesForTechnology}).
+ */
+export const PLAUSIBILITY_TECH_PHYSICAL_CATEGORIES = {
+    [BroadbandTechnologyCode.OpticalCarrierFiber]: ["telecom_exchange", "telecom_cabinet", "data_center"],
+    ...Object.fromEntries([...FIXED_WIRELESS_CODES].map((code) => [code, ["tower_comms"]])),
+};
+/**
+ * The poi-taxonomy category ids a physical-plant search should probe for a given BDC technology code, or `[]` when that
+ * technology has no physical falsifier in this vertical (see {@link PLAUSIBILITY_TECH_PHYSICAL_CATEGORIES}).
+ */
+export function physicalCategoriesForTechnology(technologyCode) {
+    return PLAUSIBILITY_TECH_PHYSICAL_CATEGORIES[technologyCode] ?? [];
+}
+/**
+ * Ordinal rank of each `speed_bucket` label, so "at or above claimed speed" is a numeric comparison rather than a
+ * string one. Mirrors the bucket ORDER `filing-landscape.ts` defines (never re-derived — decision 8).
+ */
+const SPEED_BUCKET_RANK = {
+    [BDC_SPEED_BUCKET_UNDER_25]: 0,
+    [BDC_SPEED_BUCKET_25_100]: 1,
+    [BDC_SPEED_BUCKET_100_1000]: 2,
+    [BDC_SPEED_BUCKET_GIGABIT]: 3,
+};
+/**
+ * `BDCDatabase extends LayerContractDatabase` structurally, but Kysely's `transaction()` makes `Kysely<DB>` INVARIANT
+ * in `DB` — same cast idiom as `filing-landscape.ts`'s own private `asContractDB` (decision 8: reuse, never re-derive;
+ * copied rather than imported since the original is module-private).
+ */
+function asContractDB(kdb) {
+    return kdb;
+}
+/**
+ * `true` when `filing` corroborates the claim: same `technology_code`, AND `filing.speed_bucket` ranks at or above the
+ * claimed download speed's own bucket. A different tech, or a same-tech but LESSER filing, is `false` — never disproof,
+ * just non-corroborating (spec §3.2 step 2).
+ */
+function filingCorroborates(filing, claim) {
+    if (filing.technology_code !== claim.technologyCode)
+        return false;
+    const filingRank = SPEED_BUCKET_RANK[filing.speed_bucket];
+    // An unrecognized speed_bucket (a corrupted/foreign row) can't corroborate — never guess a rank for it.
+    if (filingRank === undefined)
+        return false;
+    const claimedRank = SPEED_BUCKET_RANK[speedBucketForDownloadSpeed(claim.claimedDownloadMbps)];
+    return filingRank >= claimedRank;
+}
+/**
+ * Collapse the fine-grained {@link PlausibilityCoverageAxisState} down to the 3-value space `combineCoverage` actually
+ * reasons over: `"layer_missing"` and `"cell_unsurveyed"` are both simply UNKNOWN for confidence-combination purposes
+ * (the distinction only matters for `coverage_detail`'s attribution, not for the confidence math itself).
+ */
+function confidenceStateForAxis(state) {
+    if (state === "covered")
+        return "covered";
+    if (state === "not_applicable")
+        return "not_applicable";
+    return "unknown";
+}
+/**
+ * Combine the two layers' coverage states into the bundle's `coverage_confidence` — see the module docstring for the
+ * `"not_applicable"` extension's reasoning (deliberately conservative: never `"high"` without a real, applicable
+ * two-channel opportunity).
+ */
+function combineCoverage(filingState, physicalState) {
+    const filing = confidenceStateForAxis(filingState);
+    const physical = confidenceStateForAxis(physicalState);
+    if (physical === "not_applicable") {
+        return filing === "covered" ? "low" : "insufficient_survey_data";
+    }
+    if (filing === "covered" && physical === "covered")
+        return "high";
+    if (filing === "unknown" && physical === "unknown")
+        return "insufficient_survey_data";
+    return "low";
+}
+/**
+ * See the module docstring's "ledger note" section. Throws when a WIRED layer's manifest disagrees with
+ * `BDC_H3_RESOLUTION` — the single constant `plausibilityCheck` actually uses at runtime to derive both the
+ * filing-lookup cell (bdc side, via `pointCell`) and the coverage-cell join key `readLayerCoverage` is read against
+ * (poi side, via `res9ShortCellToRes6Parent(pointCell)`).
+ *
+ * Task 5 fix round 1 (review finding 2): checked independently PER LAYER, whenever THAT layer is wired, rather than
+ * only when both `bdcDB` and `poi` are wired together. The original one-sided assertion compared the two manifests to
+ * EACH OTHER, which meant a poi-only call (no `bdcDB`) never checked poi's recorded resolution at all — even though
+ * `pointCell` (computed unconditionally from `BDC_H3_RESOLUTION`) still drives the poi coverage-cell read below.
+ * Comparing each layer directly against the constant is also strictly stronger than the retired manifest-vs-manifest
+ * check: it catches a layer built under a since-changed `BDC_H3_RESOLUTION` even when the OTHER layer is absent
+ * entirely, not just a disagreement between two present layers.
+ */
+async function assertLayerSpineResolution(layer, contractDB, expectedResolution) {
+    const manifest = await readLayerManifest(contractDB);
+    const resolution = manifest.spineKeys.h3?.resolution;
+    if (resolution === undefined || resolution !== expectedResolution) {
+        throw new Error(`plausibilityCheck: ${layer}.db's recorded h3 spine resolution (${String(resolution)}) does not match ` +
+            `BDC_H3_RESOLUTION (${expectedResolution}) — the res-9→res-6 coverage-cell reconstruction this scorer ` +
+            `relies on assumes they match; refusing to compose evidence against a mismatched layer rather than ` +
+            `silently mis-joining a coverage cell.`);
+    }
+}
+/**
+ * Compose filing evidence + physical evidence into one `{ claim, evidence_found, coverage_confidence }` bundle — see
+ * the module docstring for the full composition rules. Never emits anything expressible as "implausible": absence of a
+ * filing or of nearby plant only ever surfaces as an abstain, an omitted evidence entry, or a degraded
+ * `coverage_confidence` — never a negative verdict.
+ */
+export async function plausibilityCheck(claim, deps) {
+    // 1. Resolve a coordinate for physical-evidence search (independent of the filing-evidence spatial key below) —
+    // claim.point directly, or claim.address geocoded via deps.geocode.
+    let point = claim.point;
+    if (!point && claim.address) {
+        if (!deps.geocode) {
+            throw new Error("plausibilityCheck: claim.address requires deps.geocode");
+        }
+        const geocoded = await deps.geocode(claim.address);
+        if (geocoded.lat == null || geocoded.lon == null) {
+            throw new Error(`plausibilityCheck: geocode could not resolve a coordinate for ${JSON.stringify(claim.address)}`);
+        }
+        point = { type: "Point", coordinates: [geocoded.lon, geocoded.lat] };
+    }
+    if (!claim.geoid && !point) {
+        throw new Error("plausibilityCheck: claim must supply one of `geoid`, `point`, or a resolvable `address`");
+    }
+    // decision 4: geoid wins outright — the exact, native filing-evidence path. Otherwise the resolved point's own
+    // res-9 cell is the (flagged, unsound) approximation.
+    const blockResolution = claim.geoid ? "geoid" : "h3_cell_approximation";
+    const pointCell = point
+        ? shortCellToInt(latLngToCell(point.coordinates[1], point.coordinates[0], BDC_H3_RESOLUTION))
+        : undefined;
+    // Ledger note (task 4 review; task 5 fix round 1 finding 2): cheap, one-time per-layer sanity check — see the
+    // module docstring. Runs independently per WIRED layer, not only when both are present — a poi-only call still
+    // joins poi's coverage table against a BDC_H3_RESOLUTION-derived cell (below) and must not do so unchecked.
+    if (deps.bdcDB) {
+        await assertLayerSpineResolution("bdc", asContractDB(deps.bdcDB), BDC_H3_RESOLUTION);
+    }
+    if (deps.poi) {
+        await assertLayerSpineResolution("poi", deps.poi.contractDB, BDC_H3_RESOLUTION);
+    }
+    const evidence = [];
+    let vintage = null;
+    let filingCoverage = "layer_missing";
+    if (!deps.bdcDB) {
+        evidence.push({ type: "abstain", reason: "requires_bdc_layer", layer: "bdc" });
+    }
+    else {
+        // blockResolution === "geoid" iff claim.geoid is set (see above), so exactly one of these two branches ever
+        // runs, and the `pointCell!` assertion below is safe: blockResolution === "h3_cell_approximation" only when
+        // claim.geoid is absent, which (per the throw above) means `point` — and therefore `pointCell` — is defined.
+        const landscape = blockResolution === "geoid"
+            ? await filingLandscape(deps.bdcDB, { geoids: [claim.geoid] })
+            : await filingLandscape(deps.bdcDB, { h3Cells: [pointCell] });
+        vintage = landscape.vintage;
+        if (landscape.surveyed_block_count > 0) {
+            filingCoverage = "covered";
+            for (const filing of landscape.filings) {
+                evidence.push({
+                    type: "filing",
+                    filing,
+                    vintage: landscape.vintage,
+                    corroborates: filingCorroborates(filing, claim),
+                });
+            }
+        }
+        else {
+            filingCoverage = "cell_unsurveyed";
+            evidence.push({ type: "abstain", reason: "insufficient_survey_data", layer: "bdc" });
+        }
+    }
+    const physicalCategories = physicalCategoriesForTechnology(claim.technologyCode);
+    let physicalCoverage = "not_applicable";
+    if (physicalCategories.length) {
+        if (!deps.poi) {
+            physicalCoverage = "layer_missing";
+            evidence.push({ type: "abstain", reason: "requires_build_local_layer", layer: "poi" });
+        }
+        else if (!point) {
+            // Geoid-only claim, no coordinate resolvable — see the module docstring's claim-resolution note. A real
+            // capability gap, not a missing-layer abstain: no evidence entry is fabricated, but the axis still
+            // degrades honestly for coverage_confidence (and now names ITS OWN reason in `coverage_detail`, distinct
+            // from `"layer_missing"`, rather than folding into the same generic "unknown" — task 5 fix round 1
+            // finding 1).
+            physicalCoverage = "no_coordinate";
+        }
+        else {
+            const hits = await nearestInfrastructure(deps.poi.lookup, deps.poi.contractDB, {
+                center: point,
+                categoryIDs: [...physicalCategories],
+            });
+            for (const hit of hits) {
+                evidence.push({ type: "physical_plant", hit });
+            }
+            const coverageCell = await readLayerCoverage(deps.poi.contractDB, res9ShortCellToRes6Parent(pointCell));
+            physicalCoverage = coverageCell ? "covered" : "cell_unsurveyed";
+        }
+    }
+    return {
+        claim,
+        evidence_found: evidence,
+        coverage_confidence: combineCoverage(filingCoverage, physicalCoverage),
+        coverage_detail: { filing: filingCoverage, physical: physicalCoverage },
+        block_resolution: blockResolution,
+        vintage,
+    };
+}
+//# sourceMappingURL=plausibility.js.map

package/out/sdk/plausibility.js.map

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