@instruments/taxonomy 1.1.6 → 1.3.0

package/dist/axes/space.d.ts

@@ -0,0 +1,61 @@
+import type { Sector } from "../authoring.js";
+import type { Term } from "../term.js";
+/**
+ * A sector of the SPACE axis: a group of rooms that answer the same programme question.
+ *
+ * NOT THE SECTOR AXIS, despite the shared word, and the collision is old rather than chosen:
+ * these are PROGRAMME groups (where you sleep, wash, eat), while `sector.*` is the market a
+ * project serves. The market claim lives on individual terms as `serves` edges - see
+ * `marketsServed` below and the register in `space/market-neutral.ts` - and this grouping makes
+ * no market claim at all: the "healthcare" file holds `clean_room`, which serves no single
+ * market, and the "domestic" file is a programme word, not `sector.residential`.
+ *
+ * NOT A FACET, and not part of a term's identifier. `space.scullery` is the id whatever sector the
+ * scullery is filed under, and re-filing a room must never move its URI. This is a browse
+ * structure, and it exists because 197 rooms sorted alphabetically put Operating Room next to
+ * Orangery - which is a list you can search and not a list you can read.
+ *
+ * NOR IS IT `broaderSlug`. A scullery is not a kind of "Dining", so an ISA edge would be false;
+ * ADR 0001's relation rule is explicit that subsumption means every instance of the narrower term
+ * is an instance of the broader one. Sector is a filing decision about the vocabulary, which is a
+ * different kind of claim from a fact about the world, and conflating the two is how hierarchies
+ * fill up with things that are not parents.
+ */
+export interface SpaceSector {
+    slug: string;
+    /** The reader's word for the sector. */
+    label: string;
+    terms: readonly Term[];
+}
+/**
+ * The seventeen sectors, in the order a browse page should show them.
+ *
+ * Ordered by programme rather than alphabetically or by size: where you arrive, where you move,
+ * where you sleep, wash, eat, gather, and so on out to the specialised sectors and the unclassified
+ * tail. A reader looking for their own corner of the built environment finds it by walking through
+ * a building, which is the order this list is in.
+ *
+ * `SPACE_TERMS` is DERIVED from this, so the flat list and the grouped one cannot disagree. It was
+ * previously the other way round - seventeen spreads into one array, with the grouping expressed
+ * only by which file a term happened to sit in, where nothing outside the package could read it.
+ */
+export declare const SPACE_SECTORS: readonly SpaceSector[];
+export declare const SPACE_TERMS: readonly Term[];
+/**
+ * The markets a space exists to serve, resolved through its ISA chain, or null where no market is
+ * part of the room's identity.
+ *
+ * THE ACCESSOR EXISTS SO THE INHERITANCE IS NOT REINVENTED. A `serves` edge restricts every
+ * descendant - each suite is a hotel room, so each suite serves hospitality - and a consumer
+ * reading raw edges would see `suite` carrying none and read it as unrestricted. The walk stops at
+ * the NEAREST edge-bearing ancestor, because a child's own edges are a narrower claim that
+ * replaces the inherited one rather than adding to it (`training_room` serves workplace inside a
+ * neutral `classroom`).
+ *
+ * Null is a reviewed claim, not a gap: the term serves whatever market its project serves. The
+ * register in `space/market-neutral.ts` is what makes that true, and the disposition test in
+ * `axes.test.ts` is what keeps it true. Answering "what belongs in a residential scheme" is
+ * therefore: every term whose result is null or includes "residential" - the neutral majority
+ * spans all sectors, and excluding it would fail closed.
+ */
+export declare const marketsServed: (termSlug: string) => readonly Sector[] | null;

package/dist/axes/style-anchors.d.ts

@@ -0,0 +1,7 @@
+import { STYLE_TERMS } from "./style.js";
+export type StyleSlug = (typeof STYLE_TERMS)[number]["slug"];
+/** At least one anchor, so a key cannot be added and left empty. */
+export type Anchors = readonly [string, ...string[]];
+export declare const STYLE_ANCHORS: Readonly<Record<string, Anchors>>;
+/** The anchors for a style term, or undefined when the id names no style. */
+export declare const anchorsFor: (styleId: string) => Anchors | undefined;

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 a materials-retrieval system'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.
+ *
+ * A project-materials database'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: a materials-retrieval system 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/crossover-sources.d.ts

@@ -0,0 +1,52 @@
+export declare const RETRIEVAL_LEXICON_SOURCE = "colour-material lexicon in a materials-retrieval system (src-05)";
+export declare const COLORSCOPE_CROSSOVER_SOURCE = "materialinstruments/colorscope@c0662caabe7cd8604241a8a7b2608fa5bc71de51:packages/core/data/reference/v1/taxonomy.json";
+export declare const BRASS_MATERIAL_SOURCE = "https://archive.copper.org/applications/industrial/DesignGuide/terms.php";
+export declare const BRASS_FINISH_SOURCE = "https://nickelinstitute.org/media/lxxh1zwr/2023-nickelplatinghandbooka5_printablepdf.pdf section 5";
+export declare const NICKEL_MATERIAL_SOURCE = "https://nickelinstitute.org/en/nickel-applications/";
+export declare const NICKEL_FINISH_SOURCE = "https://nickelinstitute.org/en/nickel-applications/plating";
+export declare const CROSSOVER_DEFINITION_SOURCES: {
+    readonly alabaster: "https://webapps.bgs.ac.uk/memoirs/docs/B06070.html";
+    readonly brass: "https://archive.copper.org/applications/industrial/DesignGuide/terms.php; https://nickelinstitute.org/media/lxxh1zwr/2023-nickelplatinghandbooka5_printablepdf.pdf section 5";
+    readonly bronze: "https://archive.copper.org/applications/industrial/DesignGuide/terms.php; https://archive.copper.org/applications/architecture/arch_dhb/technical-discussion/copper_alloys/";
+    readonly cherry: "https://research.fs.usda.gov/download/treesearch/37440.pdf";
+    readonly chestnut: "https://research.fs.usda.gov/download/treesearch/37440.pdf";
+    readonly chrome: "ISO 1456:2009, https://www.iso.org/standard/50237.html; ISO 6158:2018, https://www.iso.org/standard/72269.html";
+    readonly clay: "https://pubs.usgs.gov/info/clays/";
+    readonly concrete: "https://www.concrete.org/frequentlyaskedquestions.aspx?faqid=640";
+    readonly copper: "https://archive.copper.org/applications/industrial/DesignGuide/selection/elect02.php";
+    readonly cork: "https://apcor.pt/en/what-it-is";
+    readonly cotton: "https://www.fao.org/docrep/pdf/012/i0987e/i0987e00.pdf";
+    readonly denim: "https://cottonworks.com/encyclopedia-item/denim/";
+    readonly ebony: "https://research.fs.usda.gov/download/treesearch/37440.pdf";
+    readonly gold: "https://www.usgs.gov/centers/national-minerals-information-center/gold-statistics-and-information";
+    readonly gunmetal: "https://live.copper.org/applications/marine/cuni/alloys/pub-206-copper-alloys-for-marine-environments.pdf";
+    readonly iron: "https://www.usgs.gov/centers/national-minerals-information-center/iron-and-steel-statistics-and-information";
+    readonly jade: "https://www.gia.edu/jade-description";
+    readonly jute: "https://www.fao.org/markets-and-trade/commodities-overview/fibres/jute-and-hard-fibres/";
+    readonly leather: "ISO 15115, https://www.iso.org/obp/ui?_escaped_fragment_=iso%3Astd%3Aiso%3A15115%3Aed-1%3Av1%3Aen";
+    readonly limestone: "https://pubs.usgs.gov/fs/2008/3089/";
+    readonly linen: "https://allianceflaxlinenhemp.eu/en/document_resources/35/download";
+    readonly mahogany: "https://research.fs.usda.gov/download/treesearch/37440.pdf";
+    readonly marble: "https://www.naturalstoneinstitute.org/designprofessionals/varieties/definition/; ASTM C503 via https://www.naturalstoneinstitute.org/stoneprofessionals/astm/";
+    readonly nickel: "https://nickelinstitute.org/en/nickel-applications/; https://nickelinstitute.org/en/nickel-applications/plating";
+    readonly oak: "https://research.fs.usda.gov/download/treesearch/37440.pdf";
+    readonly obsidian: "https://www.usgs.gov/glossary/volcano-hazards-program-glossary";
+    readonly onyx: "https://www.naturalstoneinstitute.org/consumers/varieties/marble/";
+    readonly pewter: "Getty AAT 300010979, https://www.getty.edu/vow/AATFullDisplay?find=&logic=AND&note=&page=1&subjectid=300010979";
+    readonly platinum: "https://www.usgs.gov/centers/national-minerals-information-center/platinum-group-metals-statistics-and-information";
+    readonly rosewood: "https://research.fs.usda.gov/download/treesearch/37440.pdf";
+    readonly silver: "https://silverinstitute.org/silver-element-essentials/";
+    readonly sisal: "https://www.fao.org/docrep/pdf/012/i0987e/i0987e00.pdf";
+    readonly slate: "ASTM C629 via https://www.naturalstoneinstitute.org/stoneprofessionals/astm/";
+    readonly steel: "https://worldsteel.org/about-steel/what-is-steel/";
+    readonly stone: "https://www.naturalstoneinstitute.org/about/sponsorship-and-advertising/sponsored-content-guidelines/";
+    readonly suede: "ISO 15115, https://www.iso.org/obp/ui?_escaped_fragment_=iso%3Astd%3Aiso%3A15115%3Aed-1%3Av1%3Aen";
+    readonly teak: "https://research.fs.usda.gov/download/treesearch/37440.pdf";
+    readonly terracotta: "Getty AAT 300047296, https://www.getty.edu/vow/AATFullDisplay?find=building&logic=AND&note=&subjectid=300047296";
+    readonly travertine: "https://www.naturalstoneinstitute.org/about/sponsorship-and-advertising/sponsored-content-guidelines/";
+    readonly walnut: "https://research.fs.usda.gov/treesearch/32210";
+    readonly wood: "https://research.fs.usda.gov/download/treesearch/37440.pdf";
+    readonly wool: "https://www.fao.org/docrep/pdf/012/i0987e/i0987e00.pdf";
+};
+export type CrossoverPhrase = keyof typeof CROSSOVER_DEFINITION_SOURCES;
+export declare const crossoverSource: (phrase: CrossoverPhrase) => string;

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/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/estate/concepts.d.ts

@@ -0,0 +1,117 @@
+import type { Row } from "./decomposition.js";
+export declare const ESTATE_REPOS: readonly ["rendering-pipeline", "architecture-projects", "editorial-imagery", "furnishings-retailer", "materials-retrieval", "paint-samples"];
+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 the paint-sample
+     * retailer joined the census. Its 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: the paint-sample retailer'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 a furnishings retailer's room schemes 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 `ROOM_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 { ARCHITECTURE_PROJECTS_STYLES, EDITORIAL_STYLE_ANCHORS, RETAIL_PRODUCT_STYLES, ROOM_SCHEME_STYLE_COUNTS, ROOM_SCHEME_STYLES, ESTATE_VOCABULARIES, type EstateVocabulary, RENDERING_INTENT_KEYWORDS, RENDERING_SCENE_MOOD, RETRIEVAL_MS_CHARACTER, RETRIEVAL_MS_MOOD, RETRIEVAL_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 the materials-retrieval system, colorscope and the
+     * architecture-projects platform, 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/architecture-projects.d.ts

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

package/dist/estate/rows/editorial-imagery.d.ts

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

package/dist/estate/rows/furnishings-retailer.d.ts

@@ -0,0 +1,2 @@
+import type { Row } from "../decomposition.js";
+export declare const RETAILER_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/materials-retrieval.d.ts

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

package/dist/estate/rows/paint-samples.d.ts

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

package/dist/estate/rows/rendering-pipeline.d.ts

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

package/dist/estate/sources.d.ts

@@ -0,0 +1,106 @@
+export interface CitedSource {
+    /** Stable and opaque. Never reassigned, never a name, and never decoded here. */
+    id: string;
+    /** How the source is written in prose, article included. */
+    name: string;
+    /** The same source as one token: a column key, a repository key, a vocabulary id prefix. */
+    slug: string;
+    /** The same source as a column heading, without the article. */
+    label: string;
+}
+export declare const CITED_SOURCES: {
+    readonly ARCHITECTURE_PROJECTS: {
+        readonly id: "src-01";
+        readonly label: "architecture-projects platform";
+        readonly name: "an architecture-projects platform";
+        readonly slug: "architecture-projects";
+    };
+    readonly EDITORIAL_IMAGERY: {
+        readonly id: "src-02";
+        readonly label: "editorial image library";
+        readonly name: "an editorial image library";
+        readonly slug: "editorial-imagery";
+    };
+    readonly FURNISHINGS_RETAILER: {
+        readonly id: "src-03";
+        readonly label: "furnishings retailer";
+        readonly name: "a furnishings retailer";
+        readonly slug: "furnishings-retailer";
+    };
+    readonly MARKETPLACE_CATALOGUE: {
+        readonly id: "src-04";
+        readonly label: "materials-marketplace catalogue";
+        readonly name: "a materials-marketplace catalogue";
+        readonly slug: "materials-marketplace";
+    };
+    readonly MATERIALS_RETRIEVAL: {
+        readonly id: "src-05";
+        readonly label: "materials-retrieval system";
+        readonly name: "a materials-retrieval system";
+        readonly slug: "materials-retrieval";
+    };
+    readonly PAINT_SAMPLES: {
+        readonly id: "src-06";
+        readonly label: "paint-sample retailer";
+        readonly name: "a paint-sample retailer";
+        readonly slug: "paint-samples";
+    };
+    readonly PROJECT_MATERIALS: {
+        readonly id: "src-07";
+        readonly label: "project-materials database";
+        readonly name: "a project-materials database";
+        readonly slug: "project-materials";
+    };
+    readonly RENDERING_PIPELINE: {
+        readonly id: "src-08";
+        readonly label: "rendering pipeline";
+        readonly name: "a rendering pipeline";
+        readonly slug: "rendering-pipeline";
+    };
+};
+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;
+    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 RENDERING_SCENE_MOOD: EstateVocabulary;
+export declare const RENDERING_INTENT_KEYWORDS: EstateVocabulary;
+export declare const ARCHITECTURE_PROJECTS_STYLES: EstateVocabulary;
+export declare const EDITORIAL_STYLE_ANCHORS: EstateVocabulary;
+export declare const ROOM_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 ROOM_SCHEME_STYLE_COUNTS: Readonly<Record<string, number>>;
+export declare const RETAIL_PRODUCT_STYLES: EstateVocabulary;
+export declare const RETRIEVAL_MS_STYLE: EstateVocabulary;
+export declare const RETRIEVAL_MS_MOOD: EstateVocabulary;
+export declare const RETRIEVAL_MS_CHARACTER: EstateVocabulary;
+export declare const PAINT_SAMPLE_COLOUR_COLLECTIONS: EstateVocabulary;
+/**
+ * A standing fact, visible in this capture rather than asserted.
+ *
+ * THE PAINT-SAMPLE RETAILER 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 the
+ * retailer as the maker of a colour, the query is wrong and this is the evidence.
+ */
+export declare const PAINT_SAMPLE_MAKER_COLLECTIONS: readonly ["benjamin-moore", "sherwin-williams", "behr"];
+export declare const ESTATE_VOCABULARIES: readonly EstateVocabulary[];