@instruments/taxonomy 1.1.5 → 1.2.0

package/dist/assertions.d.ts

@@ -0,0 +1,70 @@
+import type { RelationPredicate, Term } from "./term.js";
+/** The relation predicates, at runtime. TypeScript cannot enumerate a union, so this is by hand. */
+export declare const RELATION_PREDICATES: readonly ["blend-of", "evokes", "influenced-by", "part-of", "reads-as", "related-to", "serves", "suitable-for", "typically-in"];
+type AssertNever<T extends never> = T;
+/**
+ * The totality guard, and it is load-bearing rather than decorative: a predicate added to `term.ts`
+ * and not listed above would otherwise fail to parse here in silence, and every assertion using it
+ * would read as unknown. This makes that a compile error instead - the type below is `never` while
+ * the list is complete, and stops being assignable the moment it is not.
+ */
+export type UnlistedRelationPredicate = AssertNever<Exclude<RelationPredicate, (typeof RELATION_PREDICATES)[number]>>;
+/** Where a canonical term lives, and what it is called in the one spelling that counts. */
+export interface TermLocation {
+    axisSlug: string;
+    facetSlug: string;
+    termSlug: string;
+    /** `<axis>.<term>`, or `<axis>.<facet>.<term>` on a faceted axis. ADR 0001's target form. */
+    qualifiedReference: string;
+    term: Term;
+}
+/** A parsed assertion: an optional relation predicate wrapping a term reference. */
+export interface ParsedAssertion {
+    predicate?: RelationPredicate;
+    /** The term reference, verbatim and unfolded. */
+    target: string;
+}
+export interface ResolvedAssertion extends ParsedAssertion {
+    location: TermLocation;
+    /** The spelling the matcher compares on: `predicate(qualifiedReference)` or a bare `qualifiedReference`. */
+    canonical: string;
+    /** True when the named term is deprecated. Resolves anyway; a published URI must keep resolving. */
+    deprecated: boolean;
+    /** The term that replaced it, when deprecated. */
+    supersededByReference?: string;
+}
+/**
+ * Split `evokes(place.region.nordic)` into its predicate and target. A bare term reference parses
+ * to a target and no predicate. An unrecognised predicate does NOT parse: `foo(bar)` is not an
+ * assertion with an exotic predicate, it is a string nobody has defined.
+ */
+export declare const parseAssertion: (assertion: string) => ParsedAssertion | undefined;
+/** Every canonical term, with the qualified id that names it. */
+export declare const AUTHORING_LOCATIONS: readonly TermLocation[];
+/** Every accepted spelling of every term, folded. Exported so a consumer can size the vocabulary. */
+export declare const ASSERTION_KEYS: ReadonlySet<string>;
+/** Resolve any published spelling of a term to the one location it names. */
+export declare const resolveReference: (reference: string) => TermLocation | undefined;
+/**
+ * Resolve a whole assertion, predicate included. Returns undefined when the predicate is not one
+ * `term.ts` defines, or when the target names no canonical term.
+ */
+export declare const resolveAssertion: (assertion: string) => ResolvedAssertion | undefined;
+/**
+ * The spelling the matcher compares on.
+ *
+ * An assertion this package cannot resolve folds to ITSELF rather than to nothing. That is the
+ * difference between a matcher and a gate: a consumer's private tag must still match its own
+ * counterpart on the other side, and only the canon's own artefacts are held to resolving.
+ */
+export declare const canonicalAssertion: (assertion: string) => string;
+/** True when this package can resolve the assertion to a canonical term. */
+export declare const isCanonicalAssertion: (assertion: string) => boolean;
+/** The assertions this package cannot resolve, in input order. The failure message IS the work item. */
+export declare const unknownAssertions: (assertions: Iterable<string>) => readonly string[];
+/** Assertions naming a term that still resolves but has been superseded, with its successor. */
+export declare const deprecatedAssertions: (assertions: Iterable<string>) => readonly {
+    assertion: string;
+    supersededByReference: string;
+}[];
+export {};

package/dist/authoring.d.ts

@@ -0,0 +1,33 @@
+import type { Term } from "./term.js";
+/**
+ * The published term shape. Widened in 0.2.0 from the original three fields to the full `Term` in
+ * `./term`, which adds external mappings, provenance, usage bands, supersession and typed
+ * relations. Every added field is optional, so this is a backward-compatible minor exactly as the
+ * banner above planned: "adding them later is a backward-compatible minor".
+ */
+export type TaxonomyTerm = Term;
+export type { ExternalMapping, ExternalScheme, MatchStrength, PeriodSpan, RelationPredicate, RelationRole, SearchedWithout, SourceBasis, StyleKind, Term, TermProvenance, TermRelation, TermStatus, TermUsage, UsageBand, UsageWithheld, } from "./term.js";
+export { type AlternativeReason, type AlternativesMatch, type BundleMatch, type BundleMember, type BundleMemberInput, type BundleRole, type BundleSearch, type CandidateAnnotations, type CanonicalAlternatives, type CanonicalBundle, DEFAULT_BUNDLE_ROLE, defineAlternatives, defineBundle, MATCH_TEST_VECTORS, MATCH_WEIGHTS, type MatchTestCandidate, type MatchTestVector, type MatchTier, matchAlternatives, matchBundle, type RankedCandidate, searchBundle, type SearchOptions, } from "./match.js";
+export { ASSERTION_KEYS, canonicalAssertion, deprecatedAssertions, isCanonicalAssertion, type ParsedAssertion, parseAssertion, RELATION_PREDICATES, type ResolvedAssertion, resolveAssertion, resolveReference, type TermLocation, AUTHORING_LOCATIONS, unknownAssertions, } from "./assertions.js";
+export { isInterchangeable, MATCH_STRENGTHS, SKOS_MATCH_PREDICATE, } from "./crosswalks/strength.js";
+export { ambiguous as ambiguousMapping, approximates as approximateMapping, constitutive as constitutiveMapping, type CrosswalkMapping, declined as declinedMapping, resolved as resolvedMapping, } from "./crosswalks/mapping.js";
+export { AXES, AXIS_SLUGS, type Axis, type AxisFacet, type AxisSlug, axisBySlug, axisTerms, CONSTRUCTION_TERMS, ELEMENT_TERMS, FINISH_TERMS, FORMAT_TERMS, INSTALLATION_LAYOUT_TERMS, MATERIAL_TERMS, MOOD_TERMS, PALETTE_CHARACTER_TERMS, PALETTE_FACETS, PALETTE_HUE_TERMS, PALETTE_TEMPERATURE_TERMS, PATTERN_TERMS, type PaletteFacet, PERIOD_TERMS, periodAt, periodsAt, PLACE_FACETS, PLACE_LANDSCAPE_TERMS, PLACE_REGION_TERMS, PRODUCT_CATEGORY_TERMS, REQUIREMENT_TERMS, type PlaceFacet, MARKET_NEUTRAL_SPACES, marketsServed, MOOD_ANCHORS, moodAnchorsFor, PERIOD_ANCHORS, periodAnchorsFor, PLACE_ANCHORS, placeAnchorsFor, SPACE_ANCHORS, spaceAnchorsFor, SPACE_SECTORS, SPACE_TERMS, type SpaceSector, type Anchors, anchorsFor, STYLE_ANCHORS, type StyleSlug, STYLE_TERMS, TYPOLOGY_TERMS, UNIT_SHAPE_TERMS, } from "./axes/index.js";
+export { assertionMeaningFrom, type AmbiguousCanonicalisation, type CanonicalisationInput, type CanonicalisationVerdict, type DeclinedCanonicalisation, type ResolvedCanonicalisation, type UnresolvedCanonicalisation, } from "./canonicalisation.js";
+export { type AmbiguousAssertionMeaning, type AssertionAuthority, type AssertionMeaning, type AssertionPolarity, type AssertionProvenance, type AssertionRole, type AssertionScope, type PortableAssertionTestVector, type PortableTasteAssertion, PORTABLE_ASSERTION_TEST_VECTORS, type ProjectContextAssertion, type RequirementAssertion, type RequirementConstraint, type RequirementOperator, type ResolvedAssertionMeaning, TAXONOMY_SNAPSHOT_VERSION, TASTE_ASSERTION_CONTRACT_VERSION, type TasteAssertion, type UnresolvedAssertionMeaning, } from "./taste-assertion.js";
+export { APPLICATION_TERMS, MATERIAL_FAMILY_TERMS, SECTOR_TERMS, } from "./dictionaries.js";
+export declare const PROVENANCE: {
+    readonly snapshot: "2026-07-08";
+    readonly source: "materialgraph packages/schema/src/registry/value-dictionaries.ts";
+};
+export { KNOWLEDGE_GRAPH, LEXICAL_ENTRIES, TAXONOMY_BASE_URI, type AxisNode, type CanonicalConceptUri, type ColorScopeTarget, type ConceptNode, type ExternalReference, type FacetNode, type GraphPredicate, type KnowledgeGraph, type KnowledgeGraphEdge, type KnowledgeGraphNode, type LexicalEntry, type LexicalContext, type LexicalTarget, type Lifecycle, type Governance, TAXONOMY_SNAPSHOT, type TaxonomyTarget, } from "./v1.js";
+export declare const MATERIAL_FAMILIES: readonly ["paint", "wall-finish", "wallcovering", "textile", "upholstery", "carpet", "wood", "stone", "tile", "terrazzo", "metal", "glass", "resilient-flooring", "composite", "concrete", "leather", "other"];
+export type MaterialFamily = (typeof MATERIAL_FAMILIES)[number];
+export declare const isMaterialFamily: (value: string) => value is MaterialFamily;
+export declare const SECTORS: readonly ["hospitality", "healthcare", "workplace", "residential", "retail", "education", "civic", "mixed-use", "transportation", "other"];
+export type Sector = (typeof SECTORS)[number];
+export declare const isSector: (value: string) => value is Sector;
+export declare const APPLICATIONS: readonly ["wall", "flooring", "ceiling", "bath", "kitchen", "furniture", "lighting", "door", "window", "facade", "countertop", "fireplace", "stair-elevator", "bedding", "decor", "vertically-hanging", "transportation", "pool-fountain", "paving-deck", "partition", "millwork", "cabinetry", "masonry", "roof", "garage", "bar", "awning-umbrella", "recreation-sport", "ornamentation", "aquatic-environments", "upholstery", "trim", "wall-backsplash", "wall-upholstered", "wall-wet-shower", "flooring-wet-area", "flooring-entrance", "flooring-radiant-heat", "flooring-or-lab", "flooring-anti-fatigue", "flooring-esd", "flooring-safety-slip", "flooring-raised-access", "flooring-rigid-core", "flooring-dining-area", "flooring-subject-oil", "flooring-walk-in-freezer", "flooring-ramps-inclines", "furniture-seating", "furniture-headboard", "furniture-slipcover", "furniture-systems", "furniture-tackboard", "furniture-throw-pillow", "fireplace-firebox", "fireplace-hearth", "fireplace-mantel", "fireplace-surround", "bedding-bed-scarf", "bedding-sheets", "bedding-skirt", "bedding-bedspread", "bedding-box-spring-cover", "stair-riser", "stair-tread", "stair-railing", "stair-elevator-cladding", "vh-drapery", "vh-privacy-curtain", "vh-shower-curtain", "vh-theatrical-curtain", "vh-window-shade", "transportation-automotive", "transportation-aviation", "transportation-marine", "pool-coping", "pool-decking", "pool-lining", "paving-covered-areas", "paving-patio", "partition-toilet", "masonry-structural", "masonry-veneer", "recreation-gymnasium", "recreation-playground", "recreation-weightlifting", "awning", "tensile-structure", "umbrella", "countertop-chemical-resistant"];
+export type Application = (typeof APPLICATIONS)[number];
+export declare const isApplication: (value: string) => value is Application;
+export declare const APPLICATION_PARENTS: Readonly<Partial<Record<Application, Application>>>;
+export declare const applicationTopLevelOf: (application: Application) => Application;

package/dist/axes/construction.d.ts

@@ -0,0 +1,3 @@
+import type { Term } from "../term.js";
+/** How a product or material is made; never a claim about its style or visible motif. */
+export declare const CONSTRUCTION_TERMS: readonly Term[];

package/dist/axes/element-fabric.d.ts

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

package/dist/axes/element-fitout.d.ts

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

package/dist/axes/element-shared.d.ts

@@ -0,0 +1,13 @@
+import type { ExternalMapping, MatchStrength, TermProvenance, TermRelation } from "../term.js";
+export declare const aat: (slug: string, label: string, match: MatchStrength) => ExternalMapping;
+export declare const uniclass: (slug: string, label: string, match: MatchStrength) => ExternalMapping;
+export declare const AUTHORED: TermProvenance;
+export declare const BALUSTRADE = "balustrade";
+export declare const DOOR = "door";
+export declare const INTERNAL_WALL = "internal-wall";
+export declare const ROOF = "roof";
+export declare const STAIR = "stair";
+export declare const WINDOW = "window";
+export declare const EF_EXTERNAL_WALLS = "External walls";
+export declare const EF_FRAMED_STRUCTURES = "Framed structures";
+export declare const partOf: (elementId: string) => TermRelation;

package/dist/axes/element.d.ts

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

package/dist/axes/finish.d.ts

@@ -0,0 +1,9 @@
+import type { Term } from "../term.js";
+/** How the exposed surface was produced. Unordered. */
+export declare const FINISH_TREATMENT_TERMS: readonly Term[];
+/** How much the surface reflects, least to most. Ordered; see the header. */
+export declare const FINISH_SHEEN_TERMS: readonly Term[];
+/** What the surface feels like, or reads as under a raking light. Unordered. */
+export declare const FINISH_TEXTURE_TERMS: readonly Term[];
+/** Kept for consumers importing the axis as one list; prefer the facets. */
+export declare const FINISH_TERMS: readonly Term[];

package/dist/axes/format.d.ts

@@ -0,0 +1,3 @@
+import type { Term } from "../term.js";
+/** The supplied physical unit or delivery form, independent of material, outline and layout. */
+export declare const FORMAT_TERMS: readonly Term[];

package/dist/axes/index.d.ts

@@ -0,0 +1,62 @@
+import type { Term } from "../term.js";
+export declare const AXIS_SLUGS: readonly ["material-family", "product-category", "material", "pattern", "finish", "format", "unit-shape", "installation-layout", "construction", "requirement", "sector", "application", "space", "element", "typology", "style", "period", "mood", "palette", "place", "tier", "procurement", "strategy", "form", "density"];
+export type AxisSlug = (typeof AXIS_SLUGS)[number];
+export interface AxisGovernance {
+    introducedAt: string;
+    provenance: NonNullable<Term["provenance"]>;
+    reviewedAt: string;
+}
+export interface AxisFacet {
+    governance?: AxisGovernance;
+    label: string;
+    slug: string;
+    terms: readonly Term[];
+}
+export interface Axis {
+    slug: AxisSlug;
+    label: string;
+    /** The question the axis answers, in a reader's words. One line. */
+    question: string;
+    /**
+     * Where this axis ends and its nearest neighbour begins, with the criterion that decides it.
+     * Rendered verbatim on the axis page, because a boundary nobody can read is a boundary that gets
+     * re-litigated.
+     */
+    boundary: string;
+    /** `authored` ships terms. `declared` is a real question with no terms yet, and says so. */
+    status: "authored" | "declared";
+    /** Lifecycle and provenance for the axis identity itself. Old axes omit this and use V1 baseline governance. */
+    governance?: AxisGovernance;
+    /** Single-dictionary axes carry one facet named for the axis. */
+    facets: readonly AxisFacet[];
+    /** Why the axis has no terms yet. Present only when status is "declared". */
+    gap?: string;
+}
+export declare const AXES: readonly Axis[];
+export declare const axisBySlug: (slug: AxisSlug) => Axis | undefined;
+/** Every term on an axis, across all its facets. */
+export declare const axisTerms: (axis: Axis) => readonly Term[];
+export { ELEMENT_TERMS } from "./element.js";
+export { CONSTRUCTION_TERMS } from "./construction.js";
+export { FINISH_TERMS } from "./finish.js";
+export { FORMAT_TERMS } from "./format.js";
+export { INSTALLATION_LAYOUT_TERMS } from "./installation-layout.js";
+export { MATERIAL_TERMS } from "./material.js";
+export { MOOD_TERMS } from "./mood.js";
+export { PATTERN_TERMS } from "./pattern.js";
+export { PRODUCT_CATEGORY_TERMS } from "./product-category.js";
+export { REQUIREMENT_TERMS } from "./requirement.js";
+export { PALETTE_CHARACTER_TERMS, PALETTE_FACETS, PALETTE_HUE_TERMS, PALETTE_TEMPERATURE_TERMS, type PaletteFacet, } from "./palette.js";
+export { PERIOD_TERMS, periodAt, periodsAt } from "./period.js";
+export { PLACE_FACETS, PLACE_LANDSCAPE_TERMS, PLACE_REGION_TERMS, type PlaceFacet, } from "./place.js";
+export { MOOD_ANCHORS, moodAnchorsFor } from "./mood-anchors.js";
+export { PERIOD_ANCHORS, periodAnchorsFor } from "./period-anchors.js";
+export { PLACE_ANCHORS, placeAnchorsFor } from "./place-anchors.js";
+export { SPACE_ANCHORS, spaceAnchorsFor, type Anchors as SpaceAnchorSet, } from "./space-anchors.js";
+export { marketsServed, SPACE_SECTORS, SPACE_TERMS, type SpaceSector, } from "./space.js";
+export { MARKET_NEUTRAL_SPACES } from "./space/market-neutral.js";
+export { anchorsFor, type Anchors, STYLE_ANCHORS, type StyleSlug, } from "./style-anchors.js";
+export { STYLE_TERMS } from "./style.js";
+export { oneRungDown, TIER_CHAIN_SCALE_TERMS, TIER_FACETS, TIER_MARKET_TERMS, TIER_PRICE_BAND_TERMS, type TierFacet, } from "./tier.js";
+export { TYPOLOGY_TERMS } from "./typology.js";
+export { UNIT_SHAPE_TERMS } from "./unit-shape.js";

package/dist/axes/installation-layout.d.ts

@@ -0,0 +1,3 @@
+import type { Term } from "../term.js";
+/** Persistent spatial relationships among discrete units or real joints in a finished surface. */
+export declare const INSTALLATION_LAYOUT_TERMS: readonly Term[];

package/dist/axes/material.d.ts

@@ -0,0 +1,3 @@
+import type { Term } from "../term.js";
+/** Specific substance or material system; narrower than the retrieval-oriented material family. */
+export declare const MATERIAL_TERMS: readonly Term[];

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

@@ -0,0 +1,4 @@
+import type { Anchors } from "./style-anchors.js";
+export declare const MOOD_ANCHORS: Readonly<Record<string, Anchors>>;
+/** The anchors for a mood term, or undefined when the id names no mood. */
+export declare const moodAnchorsFor: (moodId: string) => Anchors | undefined;

package/dist/axes/mood.d.ts

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

package/dist/axes/palette.d.ts

@@ -0,0 +1,7 @@
+import type { Term } from "../term.js";
+export declare const PALETTE_HUE_TERMS: readonly Term[];
+export declare const PALETTE_TEMPERATURE_TERMS: readonly Term[];
+export declare const PALETTE_CHARACTER_TERMS: readonly Term[];
+/** The three palette facets, each a closed dictionary in its own right. */
+export declare const PALETTE_FACETS: readonly ["hue", "temperature", "character"];
+export type PaletteFacet = (typeof PALETTE_FACETS)[number];

package/dist/axes/pattern.d.ts

@@ -0,0 +1,13 @@
+import type { Term } from "../term.js";
+/** The motif itself. Unordered: a damask is not more than a stripe. */
+export declare const PATTERN_TYPE_TERMS: readonly Term[];
+/** How big the repeat is. Ordered, micro to oversized. */
+export declare const PATTERN_SCALE_TERMS: readonly Term[];
+/** How much of the field the motif occupies. Ordered, none to dense. */
+export declare const PATTERN_DENSITY_TERMS: readonly Term[];
+/** How strictly the repeat is governed. Ordered, uniform to organic. */
+export declare const PATTERN_REGULARITY_TERMS: readonly Term[];
+/** Which way the pattern runs. Unordered: see the header on why this is not a ladder. */
+export declare const PATTERN_DIRECTIONALITY_TERMS: readonly Term[];
+/** Kept for consumers importing the axis as one list; prefer the facets. */
+export declare const PATTERN_TERMS: readonly Term[];

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

@@ -0,0 +1,4 @@
+import type { Anchors } from "./style-anchors.js";
+export declare const PERIOD_ANCHORS: Readonly<Record<string, Anchors>>;
+/** The anchors for a period term, or undefined when the id names no period. */
+export declare const periodAnchorsFor: (periodId: string) => Anchors | undefined;

package/dist/axes/period.d.ts

@@ -0,0 +1,29 @@
+import type { Term } from "../term.js";
+export declare const PERIOD_TERMS: readonly Term[];
+/**
+ * The periods a year could belong to, best match first.
+ *
+ * Sibling spans overlap on purpose - Georgian and Regency genuinely do - so "what period is 1800?"
+ * has no single answer in the data. Resolving it lives here rather than in each consumer, because
+ * a tie-break reinvented five times is five different answers to one question.
+ *
+ * THE RANKING, and it is not quite the one TAX-10 proposed. That ticket said prefer the narrowest
+ * match, then the un-hedged one. Narrowest-first alone gets 1800 wrong: it returns Regency, whose
+ * core is 1811-1820, over Georgian, whose core contains 1800 outright. So the first key is whether
+ * the year falls in the period's UNCONTROVERSIAL CORE at all:
+ *
+ *   1. a core match beats an edge match          1800 is Georgian, only arguably Regency
+ *   2. then narrowest core                       1815 is Regency, not merely Georgian
+ *   3. then `circa: false`                       dated boundaries beat conventional ones
+ *   4. among edge matches, least far outside     1832 is late Georgian, not late Regency
+ *
+ * `strict` drops the edge matches entirely, which is the difference between "give me a canonical
+ * period for this year" and "could this year defensibly be called that".
+ */
+export declare const periodsAt: (year: number, { strict }?: {
+    strict?: boolean | undefined;
+}) => readonly Term[];
+/** The single best period for a year, or undefined when none covers it. */
+export declare const periodAt: (year: number, options?: {
+    strict?: boolean;
+}) => Term | undefined;

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

@@ -0,0 +1,4 @@
+import type { Anchors } from "./style-anchors.js";
+export declare const PLACE_ANCHORS: Readonly<Record<string, Anchors>>;
+/** The anchors for a place term, or undefined when the id names no place. */
+export declare const placeAnchorsFor: (placeId: string) => Anchors | undefined;

package/dist/axes/place.d.ts

@@ -0,0 +1,5 @@
+import type { Term } from "../term.js";
+export declare const PLACE_REGION_TERMS: readonly Term[];
+export declare const PLACE_LANDSCAPE_TERMS: readonly Term[];
+export declare const PLACE_FACETS: readonly ["region", "landscape"];
+export type PlaceFacet = (typeof PLACE_FACETS)[number];

package/dist/axes/product-category.d.ts

@@ -0,0 +1,3 @@
+import type { Term } from "../term.js";
+/** What kind of purchasable or specifiable thing the record describes, independent of substance. */
+export declare const PRODUCT_CATEGORY_TERMS: readonly Term[];

package/dist/axes/requirement.d.ts

@@ -0,0 +1,3 @@
+import type { Term } from "../term.js";
+/** A dimension on which a project can impose a constraint; the assertion carries its operator/value. */
+export declare const REQUIREMENT_TERMS: readonly Term[];

package/dist/axes/space/arrival.d.ts

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

package/dist/axes/space/circulation.d.ts

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

package/dist/axes/space/civic.d.ts

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

package/dist/axes/space/culture.d.ts

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

package/dist/axes/space/dining.d.ts

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

package/dist/axes/space/domestic.d.ts

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

package/dist/axes/space/fitness.d.ts

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

package/dist/axes/space/gathering.d.ts

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

package/dist/axes/space/healthcare.d.ts

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

package/dist/axes/space/learning.d.ts

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

package/dist/axes/space/market-neutral.d.ts

@@ -0,0 +1 @@
+export declare const MARKET_NEUTRAL_SPACES: ReadonlySet<string>;

package/dist/axes/space/other.d.ts

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

package/dist/axes/space/outdoor.d.ts

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

package/dist/axes/space/retail.d.ts

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

package/dist/axes/space/sanitary.d.ts

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

package/dist/axes/space/service.d.ts

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

package/dist/axes/space/shared.d.ts

@@ -0,0 +1,30 @@
+import type { Sector } from "../../authoring.js";
+import type { ExternalMapping, MatchStrength, TermProvenance, TermRelation, TermUsage, UsageBand } from "../../term.js";
+export declare const VENDORED_SNAPSHOT = "2026-08-21";
+export declare const DESIGNSHOP_SNAPSHOT = "2026-08-18";
+export declare const DESIGNSHOP_CORPUS = "designshop room schemes";
+export declare const aat: (slug: string, label: string, match: MatchStrength) => ExternalMapping;
+/** The governed commercial dictionary the 0.2 draft was built from, kept for its consumed ids. */
+export declare const MS_ROOM: TermProvenance;
+/** Both dictionaries name this room. The ms_room id wins; both upstreams are recorded. */
+export declare const MS_ROOM_MIU: TermProvenance;
+export declare const AUTHORED: TermProvenance;
+export declare const EVIDENCED: TermProvenance;
+export declare const designshopUsage: (band: UsageBand) => TermUsage;
+/** The spine. 172 snake_case values, flat, read from taxonomy-values-core.ts. */
+export declare const MIU: TermProvenance;
+/**
+ * Association with no stronger claim available. Named because several terms carry one and the
+ * predicate has to read the same on all of them.
+ */
+export declare const relatedTo: (target: string) => TermRelation;
+/**
+ * The market this space exists to serve, wherever the building that contains it stands.
+ *
+ * Authored ONLY where the term's own published definition or note names the market in words that
+ * map one-to-one onto SECTOR terms - "dwelling" to residential, "hotel" to hospitality, "clinical"
+ * to healthcare, and so on. The criterion, and the register of terms reviewed and found to carry
+ * no market, are in `market-neutral.ts`. The parameter is typed to the SECTOR union so a typo
+ * fails to compile rather than dangling at test time.
+ */
+export declare const serves: (market: Sector) => TermRelation;

package/dist/axes/space/sleeping.d.ts

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

package/dist/axes/space/working.d.ts

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

package/dist/axes/space-anchors/arrival.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the arrival spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const ARRIVAL_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/circulation.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the circulation spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const CIRCULATION_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/civic.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the civic spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const CIVIC_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/culture.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the culture spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const CULTURE_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/dining.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the dining spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const DINING_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/domestic.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the domestic spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const DOMESTIC_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/fitness.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the fitness spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const FITNESS_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/gathering.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the gathering spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const GATHERING_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/healthcare.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the healthcare spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const HEALTHCARE_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/learning.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the learning spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const LEARNING_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/other.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the other spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const OTHER_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/outdoor.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the outdoor spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const OUTDOOR_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/retail.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the retail spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const RETAIL_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/sanitary.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the sanitary spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const SANITARY_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/service.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the service spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const SERVICE_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/sleeping.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the sleeping spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const SLEEPING_ANCHORS: Readonly<Record<string, Anchors>>;

package/dist/axes/space-anchors/working.d.ts

@@ -0,0 +1,3 @@
+import type { Anchors } from "../space-anchors.js";
+/** Retrieval anchors for the working spaces. One line each, written to the rule in `space-anchors.ts`. */
+export declare const WORKING_ANCHORS: Readonly<Record<string, Anchors>>;

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

@@ -0,0 +1,8 @@
+export type Anchors = readonly [string, ...string[]];
+/**
+ * Every space anchor, one file per sector so each stays inside the line budget and reads
+ * alphabetically within its own group.
+ */
+export declare const SPACE_ANCHORS: Readonly<Record<string, Anchors>>;
+/** The anchors for a space term, or undefined when the id names no space. */
+export declare const spaceAnchorsFor: (spaceId: string) => Anchors | undefined;

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;