@instruments/taxonomy 1.1.6 → 1.2.0

package/dist/axes/style.d.ts

@@ -0,0 +1,2 @@
+import type { Term } from "../term.js";
+export declare const STYLE_TERMS: readonly Term[];

package/dist/axes/tier.d.ts

@@ -0,0 +1,42 @@
+import type { Term } from "../term.js";
+/**
+ * The positioning ladder. Where a maker, a product line or a project sits in the market, as a
+ * judgement anyone in the trade would recognise.
+ *
+ * The five values materialgraph's brand extractor is instructed to choose between, minus
+ * `trade-only`, which is a channel and already has its own dictionary there. `evidenced` rather
+ * than `vendored`, because the list is not a dictionary anywhere upstream - it exists in a prompt
+ * string and a column comment, and writing it down as a vocabulary is the point of this facet.
+ *
+ * materialsinuse's budget bands are the same ladder under other names, so its `budget` and
+ * `mid_market` sit in `seenAs` on the rungs they mean rather than becoming extra terms.
+ *
+ * `seenAs` HERE CARRIES ONLY FORMS ACTUALLY FOUND UPSTREAM. The trade uses a dozen words for each
+ * of these rungs and it would be easy to list them, but `seenAs` is an evidence claim - it says a
+ * corpus was seen to use this word for this term - and filling it from plausibility would make the
+ * crosswalk unusable for the one job it has. Editorial synonyms go in `altLabels`, where they are
+ * a judgement rather than an observation.
+ */
+export declare const TIER_MARKET_TERMS: readonly Term[];
+/**
+ * Hospitality chain scale. The industry's own six-rung classification of a hotel's market segment.
+ *
+ * AUTHORED HERE, and the only facet on this axis with nothing upstream to reconcile against: a
+ * search of eight repositories for chain scale, star rating or hotel class returned zero hits.
+ * The rungs are the segmentation the sector actually uses in development briefs and performance
+ * reporting, so they are named as the trade names them rather than mapped onto the market ladder,
+ * which has four rungs and different boundaries.
+ */
+export declare const TIER_CHAIN_SCALE_TERMS: readonly Term[];
+export declare const TIER_PRICE_BAND_TERMS: readonly Term[];
+export declare const TIER_FACETS: readonly ["market", "chain-scale", "price-band"];
+export type TierFacet = (typeof TIER_FACETS)[number];
+/**
+ * The next rung down on a term's own ladder, or undefined at the bottom.
+ *
+ * Exists because the question is asked: materialgraph ships a `cheaperTier()` that walks its price
+ * ladder to answer "show me this, but less expensive". Answering it here means one implementation
+ * of the step rather than one per consumer, and it refuses at the bottom rather than clamping,
+ * because a bottom rung with nothing below it is a real answer.
+ */
+export declare const oneRungDown: (terms: readonly Term[], slug: string) => Term | undefined;

package/dist/axes/typology.d.ts

@@ -0,0 +1,2 @@
+import type { Term } from "../term.js";
+export declare const TYPOLOGY_TERMS: readonly Term[];

package/dist/axes/unit-shape.d.ts

@@ -0,0 +1,3 @@
+import type { Term } from "../term.js";
+/** The visible outline of one discrete physical unit, independent of supply and arrangement. */
+export declare const UNIT_SHAPE_TERMS: readonly Term[];

package/dist/canonicalisation.d.ts

@@ -0,0 +1,44 @@
+import type { CanonicalAlternatives, CanonicalBundle } from "./match.js";
+import type { AssertionMeaning, AssertionProvenance } from "./taste-assertion.js";
+import type { MatchStrength } from "./term.js";
+export interface CanonicalisationInput {
+    sourceSystem: string;
+    sourceField: string;
+    sourceValue: string;
+    provenance: AssertionProvenance;
+}
+interface CanonicalisationBase extends CanonicalisationInput {
+    crosswalkVersion: string;
+    taxonomySnapshotVersion: string;
+}
+export interface ResolvedCanonicalisation extends CanonicalisationBase {
+    status: "resolved";
+    canonical: CanonicalBundle;
+    /**
+     * How strongly the canonical bundle stands for the source value, in SKOS's own vocabulary. A
+     * consumer may treat `exact` as an identity and must treat everything else as an approximation
+     * it has been told about. See `crosswalks/strength.ts` for the direction convention.
+     */
+    match: MatchStrength;
+    /** Why the row is not exact. Present whenever `match` is not `exact`. */
+    note?: string;
+}
+export interface AmbiguousCanonicalisation extends CanonicalisationBase {
+    status: "ambiguous";
+    alternatives: CanonicalAlternatives;
+    /** How strongly each alternative would stand for the source value, were it the right reading. */
+    match: MatchStrength;
+    note?: string;
+}
+export interface UnresolvedCanonicalisation extends CanonicalisationBase {
+    status: "unresolved";
+}
+export interface DeclinedCanonicalisation extends CanonicalisationBase {
+    status: "declined";
+    reason: string;
+}
+/** Four honest outcomes: absence of a mapping is never silently treated as a decline or a match. */
+export type CanonicalisationVerdict = ResolvedCanonicalisation | AmbiguousCanonicalisation | UnresolvedCanonicalisation | DeclinedCanonicalisation;
+/** Convert a usable verdict to assertion meaning; a declined value does not assert anything. */
+export declare const assertionMeaningFrom: (verdict: CanonicalisationVerdict) => AssertionMeaning | null;
+export {};

package/dist/crosswalks/designshop.d.ts

@@ -0,0 +1,30 @@
+import type { CanonicalisationInput, CanonicalisationVerdict } from "../canonicalisation.js";
+import type { CrosswalkMapping } from "./mapping.js";
+export declare const DESIGNSHOP_CROSSWALK_VERSION: "designshop-2026-08-31.1";
+export declare const DESIGNSHOP_SOURCE_SYSTEM: "designshop";
+export declare const DESIGNSHOP_SOURCE_FIELDS: readonly ["product_category", "material", "pattern", "finish", "format", "construction", "scheme_style", "product_style", "mood", "space", "requirement"];
+export type DesignShopSourceField = (typeof DESIGNSHOP_SOURCE_FIELDS)[number];
+type Mapping = CrosswalkMapping;
+/**
+ * Source-specific rows. Source fields are deliberately retained: DesignShop's `material:Mosaic`
+ * resolves to a format, and pretending the source field was already canonical would preserve its
+ * category error instead of its evidence.
+ */
+export declare const DESIGNSHOP_CROSSWALK: Readonly<Record<DesignShopSourceField, Readonly<Record<string, Mapping>>>>;
+export interface DesignShopCanonicalisationInput extends Omit<CanonicalisationInput, "sourceSystem" | "sourceField"> {
+    sourceField: DesignShopSourceField;
+}
+/** Unknown values are unresolved, never declined. Declines require an explicit curated row. */
+export declare const canonicaliseDesignShop: (input: DesignShopCanonicalisationInput) => CanonicalisationVerdict;
+export interface DesignShopAppearanceTestVector {
+    expectedAssertions: readonly string[];
+    facets: readonly {
+        sourceField: DesignShopSourceField;
+        sourceValue: string;
+    }[];
+    id: string;
+    market: "residential" | "commercial";
+}
+/** Shared fixtures prove axes compose instead of welding material identity to appearance. */
+export declare const DESIGNSHOP_APPEARANCE_TEST_VECTORS: readonly DesignShopAppearanceTestVector[];
+export {};

package/dist/crosswalks/mapping.d.ts

@@ -0,0 +1,29 @@
+import type { BundleMemberInput } from "../match.js";
+import type { MatchStrength } from "../term.js";
+export type CrosswalkMapping = {
+    status: "resolved";
+    assertions: readonly BundleMemberInput[];
+    match: MatchStrength;
+    note?: string;
+} | {
+    status: "ambiguous";
+    alternatives: readonly (readonly BundleMemberInput[])[];
+    match: MatchStrength;
+    note?: string;
+} | {
+    status: "declined";
+    reason: string;
+};
+/** A compound row: the source value is fully carried by the assertions together. */
+export declare const resolved: (...assertions: readonly string[]) => CrosswalkMapping;
+/** One canonical term, interchangeable with the source value in retrieval. */
+export declare const constitutive: (assertion: string) => CrosswalkMapping;
+/**
+ * A row that is not an identity. The strength says how it falls short and the note says why, both
+ * required: an approximation nobody had to justify is how a close match ships as an exact one.
+ */
+export declare const approximates: (match: Exclude<MatchStrength, "exact">, note: string, ...assertions: readonly string[]) => CrosswalkMapping;
+/** The source is known to mean one of these and never recorded which. `match` grades each reading. */
+export declare const ambiguous: (match: MatchStrength, ...assertions: readonly string[]) => CrosswalkMapping;
+/** A curated refusal. Distinct from an absent row, which means nobody has looked. */
+export declare const declined: (reason: string) => CrosswalkMapping;

package/dist/crosswalks/materialgraph.d.ts

@@ -0,0 +1,38 @@
+import type { CanonicalisationInput, CanonicalisationVerdict } from "../canonicalisation.js";
+import type { BundleRole } from "../match.js";
+import type { CrosswalkMapping } from "./mapping.js";
+export declare const MATERIALGRAPH_CROSSWALK_VERSION: "materialgraph-2026-08-27.1";
+export declare const MATERIALGRAPH_SOURCE_SYSTEM: "materialgraph";
+export declare const MATERIALGRAPH_SNAPSHOT: "2026-08-27";
+/**
+ * The two dictionaries this crosswalk covers. Both were `ms_`-prefixed until MaterialGraph renamed
+ * them on 2026-08-27; the bare names are the current ones.
+ */
+export declare const MATERIALGRAPH_SOURCE_FIELDS: readonly ["role", "character"];
+export type MaterialGraphSourceField = (typeof MATERIALGRAPH_SOURCE_FIELDS)[number];
+/**
+ * Two `role` values that are not product properties at all, and where they actually go.
+ *
+ * A role IN A SCHEME is what `match.ts` already calls a `BundleRole`: `accent` means present and
+ * deliberate but the scheme survives without it, `constitutive` means remove it and the thing stops
+ * being what it is. A feature surface is the second by definition. Publishing these as a mapping to
+ * the bundle role rather than as terms is what stops the same slab being permanently labelled a
+ * feature surface because one scheme once used it as one.
+ */
+export declare const MATERIALGRAPH_COMPOSITIONAL_ROLES: Readonly<Record<string, BundleRole>>;
+export declare const MATERIALGRAPH_CROSSWALK: Readonly<Record<MaterialGraphSourceField, Readonly<Record<string, CrosswalkMapping>>>>;
+export interface MaterialGraphCanonicalisationInput extends Omit<CanonicalisationInput, "sourceSystem" | "sourceField"> {
+    sourceField: MaterialGraphSourceField;
+}
+/** Unknown values are unresolved, never declined. Declines require an explicit curated row. */
+export declare const canonicaliseMaterialGraph: (input: MaterialGraphCanonicalisationInput) => CanonicalisationVerdict;
+/**
+ * The upstream dictionaries, vendored as id tuples so this file can be checked against them.
+ *
+ * Verbatim from materialgraph packages/schema/src/registry/value-dictionaries — `role` in
+ * `material-semantics-core.ts`, `character` in `material-semantics-aesthetics.ts`, both at the
+ * 2026-08-27 snapshot, after the rename that dropped their `ms_` prefixes.
+ */
+export declare const MATERIALGRAPH_ROLE_VALUES: readonly ["wall_finish", "flooring", "ceiling", "joinery", "upholstery", "drapery", "accent", "worksurface", "casegoods", "feature_surface", "trim", "other"];
+export declare const MATERIALGRAPH_CHARACTER_VALUES: readonly ["quiet", "expressive", "restrained", "bold", "rustic", "crafted", "refined", "formal", "casual", "natural_reading", "synthetic_reading", "soft_reading", "hard_reading"];
+export declare const MATERIALGRAPH_SOURCE_VALUES: Readonly<Record<MaterialGraphSourceField, readonly string[]>>;

package/dist/crosswalks/miu.d.ts

@@ -0,0 +1,13 @@
+import type { Application, MaterialFamily, Sector } from "../authoring.js";
+export declare const MIU_MATERIAL_FAMILIES: readonly ["wood", "wood_veneer", "engineered_wood", "bamboo", "cork", "natural_stone", "terrazzo", "ceramic_porcelain", "glass", "metal", "concrete", "plaster", "clay", "brick", "paint_coating", "wallcovering", "laminate", "solid_surface", "mineral_composite", "resin", "linoleum", "vinyl", "rubber", "carpet", "rug", "textile", "leather", "acoustic_felt", "acoustic_composite", "recycled_composite", "paper_cardboard", "biobased_composite", "greenery_planting", "lighting", "hardware", "digital_media", "water_feature", "mixed_material", "color_palette_only", "unknown"];
+export type MiuMaterialFamily = (typeof MIU_MATERIAL_FAMILIES)[number];
+export declare const MIU_FAMILY_TO_CANONICAL: Readonly<Record<MiuMaterialFamily, MaterialFamily | null>>;
+export declare const MIU_PROJECT_SECTORS: readonly ["hospitality", "food_and_beverage", "workplace", "residential", "multifamily", "retail_and_showroom", "healthcare", "wellness", "education", "civic", "cultural", "community", "sports_recreation", "entertainment", "industrial", "logistics", "maker", "transportation", "landscape_public_realm", "mixed_use", "master_planning", "temporary_exhibition", "religious", "senior_living", "student_housing", "unknown"];
+export type MiuProjectSector = (typeof MIU_PROJECT_SECTORS)[number];
+export declare const MIU_SECTOR_TO_CANONICAL: Readonly<Record<MiuProjectSector, Sector | null>>;
+export declare const MIU_SURFACE_APPLICATIONS: readonly ["flooring", "floor_inlay", "stair_tread", "stair_riser", "wall_finish", "wall_panel", "wainscot", "baseboard", "trim", "ceiling_finish", "ceiling_cloud", "column_wrap", "door_finish", "frame_finish", "shower_wall", "shower_floor", "backsplash", "vanity_top", "toilet_partition", "commercial_kitchen_floor", "kitchen_wall", "food_service_counter", "laundry_floor", "pool_deck_surface", "reception_desk", "bar_front", "bar_top", "back_bar", "banquette_base", "cabinet_front", "shelving", "display_fixture", "closet_system", "workstation_casework", "checkout_counter", "upholstery", "loose_furniture", "built_in_seating", "banquette_upholstery", "drapery", "window_treatment", "rug", "carpet_tile", "bedding", "privacy_curtain", "acoustic_fabric_panel", "lighting_fixture", "acoustic_treatment", "partition", "operable_wall", "signage", "wayfinding", "hardware", "plumbing_fixture", "decorative_screen", "art_installation", "green_wall", "facade_cladding", "soffit", "exterior_screen", "paving", "decking", "outdoor_furniture", "planter", "pool_coping", "shade_structure", "railing", "fence_screen", "unknown"];
+export type MiuSurfaceApplication = (typeof MIU_SURFACE_APPLICATIONS)[number];
+export declare const MIU_SURFACE_APPLICATION_TO_CANONICAL: Readonly<Record<MiuSurfaceApplication, Application | null>>;
+export declare const miuFamilyToCanonical: (value: string) => MaterialFamily | null;
+export declare const miuSectorToCanonical: (value: string) => Sector | null;
+export declare const miuSurfaceApplicationToCanonical: (value: string) => Application | null;

package/dist/crosswalks/strength.d.ts

@@ -0,0 +1,19 @@
+import type { MatchStrength } from "../term.js";
+export type { MatchStrength } from "../term.js";
+/**
+ * The SKOS property each strength renders to.
+ *
+ * `skos:relatedMatch`, not `skos:related`: the target sits in another scheme, and SKOS reserves the
+ * unqualified property for associations inside one scheme.
+ */
+export declare const SKOS_MATCH_PREDICATE: Readonly<Record<MatchStrength, string>>;
+/** The strengths, at runtime. TypeScript cannot enumerate a union, so this is by hand. */
+export declare const MATCH_STRENGTHS: readonly ["broad", "close", "exact", "narrow", "related"];
+type AssertNever<T extends never> = T;
+/** Totality guard: a strength added to `term.ts` and not listed above becomes a compile error. */
+export type UnlistedMatchStrength = AssertNever<Exclude<MatchStrength, (typeof MATCH_STRENGTHS)[number]>>;
+/**
+ * True when the row asserts the two concepts are interchangeable. The only strength a consumer may
+ * treat as an identity; everything else is an approximation it has been told about.
+ */
+export declare const isInterchangeable: (strength: MatchStrength) => boolean;

package/dist/dictionaries.d.ts

@@ -0,0 +1,4 @@
+import type { Term } from "./term.js";
+export declare const MATERIAL_FAMILY_TERMS: readonly Term[];
+export declare const SECTOR_TERMS: readonly Term[];
+export declare const APPLICATION_TERMS: readonly Term[];

package/dist/downstream-check-policy.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Whether a cross-repository check may skip, or must fail for want of its subject.
+ *
+ * A check that no-ops when it cannot find what it inspects reads green forever, and this
+ * one has already rotted that way once: the materialgraph sync test asserted nothing for
+ * twelve days after a file split, unnoticed, because it only ran where a sibling checkout
+ * happened to exist and never in CI.
+ *
+ * Blanket-failing is not the fix either. CI legitimately has no sibling repo, so a hard
+ * requirement would break every run for a condition nobody can satisfy there.
+ *
+ * So the strictness is opt-in and explicit. By default an absent checkout skips, which is
+ * honest about what CI can see. A context that is *meant* to be able to run the check —
+ * a release gate, a verification pass, a developer who wants to know — sets the
+ * environment variable, and then a missing checkout is a failure rather than a shrug.
+ */
+export declare const REQUIRE_DOWNSTREAM_CHECK_ENV = "TAXONOMY_REQUIRE_DOWNSTREAM_CHECKS";
+export type DownstreamCheckDecision = {
+    kind: "run";
+} | {
+    kind: "skip";
+    reason: string;
+} | {
+    kind: "fail";
+    reason: string;
+};
+export declare const decideDownstreamCheck: (input: {
+    /** Whether the thing being inspected is actually on disk. */
+    subjectPresent: boolean;
+    /** What is being looked for, named in the failure so it is actionable. */
+    subjectLabel: string;
+    /** The raw environment value; any non-empty value other than "0"/"false" means strict. */
+    requireFlag: string | undefined;
+}) => DownstreamCheckDecision;

package/dist/env.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether cross-repository checks must fail rather than skip when their subject is
+ * missing. Undefined in almost every context, including CI — see
+ * `downstream-check-policy` for why that default is the honest one.
+ */
+export declare const readRequireDownstreamChecks: () => string | undefined;

package/dist/estate/concepts.d.ts

@@ -0,0 +1,116 @@
+import type { Row } from "./decomposition.js";
+export declare const ESTATE_REPOS: readonly ["materia", "architizer", "designround", "designshop", "materialgraph", "samplize"];
+export type EstateRepo = (typeof ESTATE_REPOS)[number];
+export interface ConceptCell {
+    source: string;
+    repo: EstateRepo;
+    /** The source's own spelling, verbatim. This is the thing the page exists to show. */
+    term: string;
+    row: Row;
+}
+/**
+ * Fold a source term to its word-form: case, separators and joining punctuation removed.
+ *
+ * `rustic`, `Rustic` and `RUSTIC` are one wording. `Rustic & Artisan` is a different one. This is
+ * the line between a spelling difference and a disagreement, and it needs drawing because a matrix
+ * of verbatim strings flatters the disagreement: three casings of one word LOOK like three
+ * vocabularies falling out, and they are one vocabulary written three ways.
+ */
+export declare const wordForm: (term: string) => string;
+export interface Concept {
+    /** The canonical head term, fully qualified. `evokes(...)` wrappers are stripped. */
+    canonical: string;
+    /** True when the canon reaches this concept by a relation rather than by assertion. */
+    viaEvokes: boolean;
+    /** Distinct repositories carrying a term that heads here. The row's sort key. */
+    reach: number;
+    /**
+     * How many repositories could plausibly have reached this concept: those carrying any vocabulary
+     * on the same axis.
+     *
+     * NOT the repository count, and the difference started mattering the moment samplize joined the
+     * census. Samplize's vocabulary is colour and nothing else, so it can never reach `style.rustic`
+     * and counting it against that row would report a disagreement where there is only a different
+     * subject. Six repositories, but only five of them have anything to say about style, and only
+     * three about colour.
+     */
+    couldReach: number;
+    cells: readonly ConceptCell[];
+    /** Rows whose crosswalk declines, and rows carried as anchors. The page marks both. */
+    declines: number;
+    anchors: number;
+    /**
+     * How many distinct WORDINGS the sources use, after folding case and separators.
+     *
+     * The number that says whether a row is a real disagreement. `reach` of 5 with one wording means
+     * five repositories writing the same word five ways, which a crosswalk fixes trivially. `reach`
+     * of 5 with five wordings means five different ideas about what to call the thing, which it does
+     * not. Measured across the whole corpus, only one of the twenty shared concepts is spelling-only,
+     * so casing turns out to be a rounding error rather than the story - but a reader looking at
+     * `rustic / Rustic / Rustic & Artisan` cannot tell that without being told.
+     */
+    wordings: number;
+}
+export declare const concepts: () => readonly Concept[];
+/** One axis's worth of the matrix: its concepts, and only the repositories that speak about it. */
+export interface AxisDisagreement {
+    axis: string;
+    concepts: readonly Concept[];
+    repos: readonly EstateRepo[];
+    /** Concepts on this axis that more than one repository reaches. */
+    shared: number;
+}
+/**
+ * The disagreement matrix, split one table per axis.
+ *
+ * ONE TABLE MIXING AXES IS SPARSE BY CONSTRUCTION, and the sparseness is not a finding. Each
+ * repository speaks about some axes and not others: samplize's vocabulary is colour and nothing
+ * else, so against every style concept it is a column of dashes. Rendered as one table that reads
+ * as six repositories disagreeing when it is really six repositories talking about different
+ * subjects, and it costs enough width to break the canonical identifiers across three lines.
+ *
+ * Split by axis, every table is dense and each makes its own point. Style is the argument, at five
+ * repositories and twenty-three concepts. Place is the sharpest, because every repository reaches
+ * it and every concept on it is shared - which is the axis the design review said was the gap.
+ *
+ * An axis is only worth a table if more than one repository speaks about it and there is more than
+ * a handful to show; the rest are reported as a count rather than drawn.
+ */
+export declare const disagreementsByAxis: ({ minConcepts, }?: {
+    minConcepts?: number;
+}) => readonly AxisDisagreement[];
+/** The dictionaries as columns, in the order the matrix renders them. */
+export declare const MATRIX_COLUMNS: readonly {
+    id: string;
+    repo: EstateRepo;
+    label: string;
+}[];
+/** The headline the disagreement page opens with, computed rather than asserted. */
+export declare const agreementSummary: () => {
+    concepts: number;
+    reachedByAll: number;
+    reachedByFourOrMore: number;
+    distinctSpellings: number;
+    exactStringMatchesAcrossRepos: number;
+    /** Concepts more than one repository reaches. */
+    shared: number;
+    /** Repositories in the census. Not every one speaks about every axis. */
+    repos: number;
+    /** Of those, the ones where every source uses the same word and differs only in spelling. */
+    spellingOnly: number;
+};
+/**
+ * The share of the DesignShop corpus the two ambiguous style values account for, as a percentage.
+ *
+ * A SHARE AND NOT A COUNT, and the distinction is the whole reason this function exists rather than
+ * a consumer reading `DESIGNSHOP_SCHEME_STYLE_COUNTS` directly. The underlying figures are a third
+ * party's catalogue volumes and are not ours to publish. The claim anything downstream actually
+ * needs is that `Modern` and `Contemporary` sit at comparable volume and together account for a
+ * large slice of the corpus - which a percentage carries exactly as well and a count carries no
+ * better.
+ *
+ * Exported so no page has to hand-type the number. A figure typed by hand is a figure that drifts
+ * from its data, and one derived from counts nobody may publish is the same disclosure a layer
+ * down.
+ */
+export declare const ambiguousStyleShare: () => number;

package/dist/estate/decomposition.d.ts

@@ -0,0 +1,40 @@
+import type { CanonicalAlternatives } from "../match.js";
+export type Verdict = 
+/** Maps faithfully onto one or more canonical terms. Nothing is lost. */
+"decomposed"
+/** Decomposes, but the compound carries meaning the parts do not. Needs an anchor as well. */
+ | "lossy"
+/** The canon can express both readings; the source cannot be safely mapped to one. Declines. */
+ | "ambiguous"
+/** A real term, but answering a question outside the interiors aesthetic axes. */
+ | "out-of-axis"
+/** Resists decomposition. Must be carried as an anchor, not a concept. */
+ | "residue";
+/** Why an `out-of-axis` term is out of axis. */
+export type OutOfAxisReason = 
+/** Describes a material, not a room. Belongs on the material half of the canon. */
+"material-property"
+/** A query-router marker with no descriptive content at all. */
+ | "query-marker"
+/** Answers an axis that already exists here (sector, space, typology). */
+ | "other-canonical-axis"
+/** A real question no axis here answers yet, and the gap is declared rather than absorbed. */
+ | "axis-not-authored";
+export interface Row {
+    /** The vocabulary id from `./sources.ts`. */
+    source: string;
+    /** The source term, verbatim. */
+    term: string;
+    verdict: Verdict;
+    /** Canonical targets asserted together. `evokes(...)` marks a relation rather than a term. */
+    onto: readonly string[];
+    /** Typed disjunction when the source is known to mean one of several bundles but cannot say which. */
+    alternatives?: CanonicalAlternatives;
+    /** Canonical terms that had to be minted on an EXISTING axis to hold this source term. */
+    mintedTerm?: readonly string[];
+    /** Canonical terms that only exist because a WHOLE AXIS had to be created. */
+    mintedAxis?: readonly string[];
+    reason?: OutOfAxisReason;
+    note?: string;
+}
+export { DECOMPOSITION } from "./rows/index.js";

package/dist/estate/index.d.ts

@@ -0,0 +1,4 @@
+export { agreementSummary, ambiguousStyleShare, concepts, type AxisDisagreement, disagreementsByAxis, type Concept, type ConceptCell, ESTATE_REPOS, type EstateRepo, MATRIX_COLUMNS, } from "./concepts.js";
+export { DECOMPOSITION, type OutOfAxisReason, type Row, type Verdict, } from "./decomposition.js";
+export { declaredGaps, mintingDemand, rateBySource, type ResidueReport, residueReport, unresolved, } from "./residue-report.js";
+export { ARCHITIZER_STYLES, DESIGNROUND_STYLE_ANCHORS, DESIGNSHOP_PRODUCT_STYLES, DESIGNSHOP_SCHEME_STYLE_COUNTS, DESIGNSHOP_SCHEME_STYLES, ESTATE_VOCABULARIES, type EstateVocabulary, MATERIA_INTENT_KEYWORDS, MATERIA_SCENE_MOOD, MATERIALGRAPH_MS_CHARACTER, MATERIALGRAPH_MS_MOOD, MATERIALGRAPH_MS_STYLE, type VocabularyKind, } from "./sources.js";

package/dist/estate/residue-report.d.ts

@@ -0,0 +1,45 @@
+import type { Row } from "./decomposition.js";
+export interface ResidueReport {
+    /** Every term across all seven estate vocabularies. */
+    total: number;
+    /** Terms that were never aesthetic vocabulary: query markers and material properties. */
+    excluded: number;
+    /** The denominator the headline is quoted against. */
+    aesthetic: number;
+    decomposed: number;
+    lossy: number;
+    ambiguous: number;
+    /** Terms that resist decomposition entirely and can only be carried as anchors. */
+    residue: number;
+    outOfAxis: number;
+    /** `decomposed` as a share of `aesthetic`. TAX-14's threshold was 80 per cent. */
+    cleanRate: number;
+    /**
+     * The circularity guard. The axes here were authored after reading these terms, so the headline
+     * rate is partly fitted to its own inputs. This is the share that decomposes onto canon that
+     * existed BEFORE the test - vendored from materialgraph, colorscope and architizer, or already
+     * published in this package. It is the floor the design would have reached with no new authoring
+     * at all, and it is the number to argue with.
+     */
+    preExistingRate: number;
+    preExisting: number;
+    /** Source terms that needed a term minted on an axis that already existed. */
+    neededMintedTerm: number;
+    /** Source terms that needed a whole axis that did not exist. */
+    neededMintedAxis: number;
+}
+export declare const residueReport: () => ResidueReport;
+export declare const mintingDemand: () => {
+    onExistingAxes: readonly (readonly [string, number])[];
+    onNewAxes: readonly (readonly [string, number])[];
+};
+/** Per-source decomposition rate, over the aesthetic subset. */
+export declare const rateBySource: () => readonly {
+    source: string;
+    decomposed: number;
+    terms: number;
+}[];
+/** Every row the canon could not take cleanly. The site publishes this list in full. */
+export declare const unresolved: () => readonly Row[];
+/** Real questions the estate asks that no axis here answers yet. Declared, never absorbed. */
+export declare const declaredGaps: () => readonly Row[];

package/dist/estate/rows/architizer.d.ts

@@ -0,0 +1,2 @@
+import type { Row } from "../decomposition.js";
+export declare const ARCHITIZER_ROWS: readonly Row[];

package/dist/estate/rows/designround.d.ts

@@ -0,0 +1,2 @@
+import type { Row } from "../decomposition.js";
+export declare const DESIGNROUND_ROWS: readonly Row[];

package/dist/estate/rows/designshop.d.ts

@@ -0,0 +1,2 @@
+import type { Row } from "../decomposition.js";
+export declare const DESIGNSHOP_ROWS: readonly Row[];

package/dist/estate/rows/index.d.ts

@@ -0,0 +1,2 @@
+import type { Row } from "../decomposition.js";
+export declare const DECOMPOSITION: readonly Row[];

package/dist/estate/rows/materia.d.ts

@@ -0,0 +1,2 @@
+import type { Row } from "../decomposition.js";
+export declare const MATERIA_ROWS: readonly Row[];

package/dist/estate/rows/materialgraph.d.ts

@@ -0,0 +1,2 @@
+import type { Row } from "../decomposition.js";
+export declare const MATERIALGRAPH_ROWS: readonly Row[];

package/dist/estate/rows/samplize.d.ts

@@ -0,0 +1,2 @@
+import type { Row } from "../decomposition.js";
+export declare const SAMPLIZE_ROWS: readonly Row[];

package/dist/estate/sources.d.ts

@@ -0,0 +1,47 @@
+export type VocabularyKind = 
+/** A closed enum a writer must choose from. */
+"enum"
+/** A keyword set matched against free text. */
+ | "keyword-set"
+/** Free-text prose used as an embedding anchor; the label is a handle, not a value. */
+ | "embedding-anchor"
+/** Uncontrolled free text captured from a third party's index. */
+ | "captured-free-text";
+export interface EstateVocabulary {
+    id: string;
+    name: string;
+    repo: string;
+    file: string;
+    snapshot: string;
+    kind: VocabularyKind;
+    /** What question the vocabulary was built to answer, in the authors' own framing. */
+    purpose: string;
+    terms: readonly string[];
+}
+export declare const MATERIA_SCENE_MOOD: EstateVocabulary;
+export declare const MATERIA_INTENT_KEYWORDS: EstateVocabulary;
+export declare const ARCHITIZER_STYLES: EstateVocabulary;
+export declare const DESIGNROUND_STYLE_ANCHORS: EstateVocabulary;
+export declare const DESIGNSHOP_SCHEME_STYLES: EstateVocabulary;
+/**
+ * Scheme counts over the 1,922 schemes carrying at least one product. Bands, not counts, are what
+ * gets published (see `Term.usage`); the raw figures live here because the decomposition test has
+ * to weight by usage and cannot do that from a band.
+ */
+export declare const DESIGNSHOP_SCHEME_STYLE_COUNTS: Readonly<Record<string, number>>;
+export declare const DESIGNSHOP_PRODUCT_STYLES: EstateVocabulary;
+export declare const MATERIALGRAPH_MS_STYLE: EstateVocabulary;
+export declare const MATERIALGRAPH_MS_MOOD: EstateVocabulary;
+export declare const MATERIALGRAPH_MS_CHARACTER: EstateVocabulary;
+export declare const SAMPLIZE_COLOUR_COLLECTIONS: EstateVocabulary;
+/**
+ * A standing fact, visible in this capture rather than asserted.
+ *
+ * SAMPLIZE IS A SAMPLING CHANNEL, NOT A PAINT BRAND. It prints peel-and-stick sheets of other
+ * manufacturers' colours and manufactures nothing. Its own product index groups by maker, and every
+ * maker is somebody else: the largest share of the catalogue sits in a `benjamin-moore` collection,
+ * then `sherwin-williams`, then `behr`. If a query ever returns Samplize as the maker of a colour,
+ * the query is wrong and this is the evidence.
+ */
+export declare const SAMPLIZE_MAKER_COLLECTIONS: readonly ["benjamin-moore", "sherwin-williams", "behr"];
+export declare const ESTATE_VOCABULARIES: readonly EstateVocabulary[];