@instruments/taxonomy 1.1.6 → 1.3.0

package/dist/match.d.ts

@@ -0,0 +1,107 @@
+import type { RelationRole } from "./term.js";
+/** The role an assertion plays inside a compound expression. */
+export type BundleRole = RelationRole;
+export interface BundleMemberInput {
+    /** A qualified canonical term or typed relation, e.g. `style.minimalism`. */
+    assertion: string;
+    /** Defaults to accent: an unspecified role is evidence of presence, not necessity. */
+    role?: BundleRole;
+}
+export interface BundleMember {
+    assertion: string;
+    role: BundleRole;
+}
+export interface CanonicalBundle {
+    kind: "all-of";
+    /** Stable, reversible identity derived from the canonical serialization. */
+    id: string;
+    members: readonly BundleMember[];
+    serialization: string;
+}
+export type AlternativeReason = "query-alternative" | "source-ambiguous";
+export interface CanonicalAlternatives {
+    kind: "any-of";
+    /** Stable, reversible identity derived from the sorted alternative bundle identities. */
+    id: string;
+    alternatives: readonly CanonicalBundle[];
+    reason: AlternativeReason;
+    serialization: string;
+}
+export declare const MATCH_WEIGHTS: Readonly<Record<RelationRole, number>>;
+export declare const DEFAULT_BUNDLE_ROLE: BundleRole;
+/**
+ * Give a bundle one canonical spelling. Duplicate assertions collapse; constitutive wins when the
+ * same assertion was supplied in both roles because removing it would otherwise change identity.
+ */
+export declare const defineBundle: (inputs: readonly BundleMemberInput[]) => CanonicalBundle;
+export declare const defineAlternatives: (inputs: readonly (CanonicalBundle | readonly BundleMemberInput[])[], reason: AlternativeReason) => CanonicalAlternatives;
+export interface BundleMatch {
+    eligible: boolean;
+    matched: readonly string[];
+    missingAccents: readonly string[];
+    missingConstitutive: readonly string[];
+    /** Fixed-weight score in [0, 1]. Ineligible matches always score zero. */
+    score: number;
+}
+/**
+ * Match without penalising extra candidate annotations. Richer annotation should not make an
+ * otherwise identical subject rank lower.
+ */
+export declare const matchBundle: (bundle: CanonicalBundle, candidateAssertions: Iterable<string>) => BundleMatch;
+export interface AlternativesMatch {
+    alternative: CanonicalBundle;
+    match: BundleMatch;
+}
+/** The strongest eligible reading wins; bundle identity makes ties deterministic. */
+export declare const matchAlternatives: (alternatives: CanonicalAlternatives, candidateAssertions: Iterable<string>) => AlternativesMatch;
+/** How well a candidate answered the query. `exact` matched every member, accents included. */
+export type MatchTier = "exact" | "eligible" | "relaxed";
+/** A subject to rank: an opaque id and the assertions annotating it. */
+export interface CandidateAnnotations {
+    id: string;
+    assertions: readonly string[];
+}
+export interface RankedCandidate {
+    id: string;
+    tier: MatchTier;
+    match: BundleMatch;
+}
+export interface BundleSearch {
+    /** The strongest tier present. Absent when no candidate carried even one member. */
+    tier?: MatchTier;
+    results: readonly RankedCandidate[];
+    /** True when nothing was eligible and the relaxed tier was served in its place. */
+    relaxed: boolean;
+    /**
+     * Constitutive members NO candidate in this corpus carries. Populated only when nothing was
+     * eligible, because that is when it is the answer: these are the conjuncts the corpus cannot
+     * satisfy, and naming them is what turns an empty result into a usable one.
+     */
+    blocking: readonly string[];
+}
+export interface SearchOptions {
+    /** Refuse the relaxed tier: return nothing rather than a labelled partial answer. */
+    strict?: boolean;
+    /** Truncate the ranked list. Applied after ordering, so it never changes which result is first. */
+    limit?: number;
+}
+/**
+ * Rank a corpus against a bundle under the published rule. Deterministic: the same corpus in any
+ * input order returns the same list.
+ */
+export declare const searchBundle: (bundle: CanonicalBundle, candidates: Iterable<CandidateAnnotations>, options?: SearchOptions) => BundleSearch;
+export interface MatchTestCandidate {
+    assertions: readonly string[];
+    id: string;
+}
+export interface MatchTestVector {
+    candidates: readonly MatchTestCandidate[];
+    expectedEligibleOrder: readonly string[];
+    id: string;
+    query: CanonicalBundle;
+}
+/**
+ * Executable test vectors published for consumers implementing the same rule in another language.
+ * One is residential, one commercial; the matcher itself has no market branch.
+ */
+export declare const MATCH_TEST_VECTORS: readonly MatchTestVector[];

package/dist/search-corpus-source.d.ts

@@ -0,0 +1,6 @@
+export declare const SEARCH_CORPUS_SNAPSHOT: "2026-07-31";
+/**
+ * The fixture evidences searched language and admission need. Taxonomy authors the concept boundary;
+ * neither an individual phrase nor the 244-query fixture as a whole is treated as that definition.
+ */
+export declare const searchCorpusEvidence: (phrases: string) => string;

package/dist/taste-assertion.d.ts

@@ -0,0 +1,112 @@
+import type { CanonicalAlternatives, CanonicalBundle } from "./match.js";
+export declare const TASTE_ASSERTION_CONTRACT_VERSION: "1.0.0";
+export declare const TAXONOMY_SNAPSHOT_VERSION: "2026-08-31";
+export type AssertionRole = "taste" | "project_context" | "requirement";
+export type AssertionAuthority = "explicit" | "behavioral" | "inferred";
+export type AssertionPolarity = "positive" | "negative" | "never";
+export type AssertionScope = {
+    kind: "person";
+} | {
+    kind: "household";
+    householdId: string;
+} | {
+    kind: "project";
+    projectId: string;
+} | {
+    kind: "room_type";
+    roomTypeId: string;
+} | {
+    kind: "room";
+    roomId: string;
+} | {
+    kind: "surface";
+    roomId: string;
+    surfaceId: string;
+};
+export interface AssertionProvenance {
+    /** The application, import or instrument that produced the observation. */
+    sourceSystem: string;
+    /** Version of the source data, prompt, fixture or export used when the evidence was observed. */
+    sourceSnapshotVersion: string;
+    sourceRecordId?: string;
+    sourceUrl?: string;
+    /** Optional id for the observation from which this assertion was proposed. */
+    observationId?: string;
+}
+interface SourceMeaning {
+    /** Source vocabulary field, before canonicalisation. */
+    sourceField: string;
+    /** Verbatim source value; never replaced by the canonical label. */
+    sourceValue: string;
+    /** Version of the source-specific mapping policy. */
+    crosswalkVersion: string;
+    /** Version of the canonical vocabulary against which mapping ran. */
+    taxonomySnapshotVersion: string;
+}
+export interface ResolvedAssertionMeaning extends SourceMeaning {
+    kind: "resolved";
+    canonical: CanonicalBundle;
+}
+export interface AmbiguousAssertionMeaning extends SourceMeaning {
+    kind: "ambiguous";
+    alternatives: CanonicalAlternatives;
+}
+export interface UnresolvedAssertionMeaning extends SourceMeaning {
+    kind: "unresolved";
+}
+export type AssertionMeaning = ResolvedAssertionMeaning | AmbiguousAssertionMeaning | UnresolvedAssertionMeaning;
+interface PortableAssertionBase {
+    /** Stable application-owned identifier for this assertion event. */
+    id: string;
+    contractVersion: typeof TASTE_ASSERTION_CONTRACT_VERSION;
+    actorId: string;
+    /** Whose taste or project view the assertion describes; never inferred from actorId. */
+    subjectId: string;
+    /** Project context is explicit even when the assertion's scope is durable and personal. */
+    projectId: string;
+    authority: AssertionAuthority;
+    polarity: AssertionPolarity;
+    scope: AssertionScope;
+    meaning: AssertionMeaning;
+    provenance: AssertionProvenance;
+    observedAt: string;
+    confirmedAt?: string;
+    validFrom?: string;
+    validUntil?: string;
+    /** Logical withdrawal is append-only; physical privacy deletion is an application concern. */
+    retractedAt?: string;
+    supersedesAssertionId?: string;
+}
+export interface TasteAssertion extends PortableAssertionBase {
+    role: "taste";
+}
+export interface ProjectContextAssertion extends PortableAssertionBase {
+    role: "project_context";
+}
+export type RequirementOperator = "equals" | "not_equals" | "at_least" | "at_most" | "includes" | "excludes";
+export interface RequirementConstraint {
+    operator: RequirementOperator;
+    value: boolean | number | string;
+    unit?: string;
+}
+export interface RequirementAssertion extends PortableAssertionBase {
+    role: "requirement";
+    /** The dimension is canonical meaning; the source-owned required value remains typed here. */
+    constraint: RequirementConstraint;
+}
+/** Portable evidence semantics only. Ranking weights and serving policy belong to each consumer. */
+export type PortableTasteAssertion = TasteAssertion | ProjectContextAssertion | RequirementAssertion;
+export interface PortableAssertionTestVector {
+    assertion: PortableTasteAssertion;
+    id: string;
+    expected: {
+        actorId: string;
+        subjectId: string;
+        projectId: string;
+        role: AssertionRole;
+        meaningKind: AssertionMeaning["kind"];
+    };
+}
+/** Executable fixtures for consumers serialising the portable envelope in another repository. */
+export declare const PORTABLE_ASSERTION_TEST_VECTORS: readonly PortableAssertionTestVector[];
+export {};

package/dist/taste.d.ts

@@ -0,0 +1,2 @@
+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";

package/dist/term.d.ts

@@ -0,0 +1,352 @@
+/** An external vocabulary this package crosswalks out to. */
+export type ExternalScheme = 
+/** Getty Art & Architecture Thesaurus. ODC-By 1.0 - redistributable with attribution. */
+"aat"
+/** Uniclass 2015 (NBS). CC BY-ND 4.0 - referenced by code, never adapted. */
+ | "uniclass"
+/** Wikidata Q-items. CC0. */
+ | "wikidata";
+/**
+ * SKOS mapping strength, using SKOS's own vocabulary so the published RDF is a direct rendering
+ * rather than a translation. `exact` asserts the two terms are interchangeable in retrieval;
+ * `close` asserts they are near enough to substitute in most contexts but not all; `broad` and
+ * `narrow` assert containment in the named direction; `related` asserts association only.
+ */
+export type MatchStrength = "exact" | "close" | "broad" | "narrow" | "related";
+export interface ExternalMapping {
+    scheme: ExternalScheme;
+    /** The external identifier, verbatim: an AAT subject id, a Uniclass code, a Wikidata Q-number. */
+    identifier: string;
+    /** The external vocabulary's own label for that identifier, verbatim and unedited. */
+    label: string;
+    match: MatchStrength;
+}
+/**
+ * Where a term's content came from, and when. Ranks the SOURCE, never the accuracy: a term lifted
+ * verbatim from an upstream dictionary is `vendored` whether or not the upstream got it right.
+ * Using this field as a proxy for correctness is how confident wrong answers get made.
+ */
+export type SourceBasis = 
+/** Copied unedited from a named upstream dictionary at a stated snapshot. */
+"vendored"
+/** Written here, from scratch, by a named editor. */
+ | "authored"
+/** Written here, but derived from measured usage in a named corpus. */
+ | "evidenced"
+/** Written here from one or more named authoritative references, without adopting their term. */
+ | "referenced"
+/** Adopted from a published external standard, with its identifier carried. */
+ | "standard";
+export interface TermProvenance {
+    basis: SourceBasis;
+    /**
+     * The upstream standard, reference or source. A public standard or vocabulary is named outright
+     * and can be re-read by anyone. A private source is written as its kind and an opaque id, e.g.
+     * "PRICE_TIERS in a materials-retrieval system (src-05)": the id is stable, so every term citing
+     * one source can be shown to cite the same thing, and re-reading it means the steward resolving
+     * the id at the `snapshot` date. The date lives in `snapshot` and is never repeated here.
+     */
+    source: string;
+    /** ISO date the source was read. Absent only for `authored`. */
+    snapshot?: string;
+}
+/**
+ * A canonical identity governed by ColorScope rather than Taxonomy.
+ *
+ * This is authored data, not an inference from provenance prose. A vendored source explains where
+ * a row came from; it does not by itself decide which package owns the durable identifier.
+ */
+export interface ColorScopeAuthority {
+    authority: "colorscope";
+    authorityUri: "https://colorscope.materialinstruments.com";
+    identifier: string;
+    referenceKind: keyof ColorScopeReferenceKinds;
+}
+interface ColorScopeReferenceKinds {
+    "chroma-level": true;
+    "color-family": true;
+    "lightness-level": true;
+    "named-color": true;
+    "palette-mood": true;
+    "temperature-level": true;
+}
+/**
+ * A DATED NEGATIVE RESULT: a scheme that was searched for this term and did not have it.
+ *
+ * This is the field that makes the gap publishable. ADR 0001 section 8 softens the planned
+ * invariant "every STYLE and PERIOD term carries an AAT mapping" to "carries a mapping OR carries
+ * one of these", because AAT has no consumer interiors coverage at all - a live search for
+ * *japandi* returns nothing, and *farmhouse*, *transitional* and *coastal* are absent as interior
+ * idioms. Without this field an unmapped term is indistinguishable from an unchecked one, and the
+ * two are opposites: one is evidence and the other is a to-do.
+ *
+ * A dated negative against the best art-and-architecture thesaurus in the world is the clearest
+ * available statement of why this vocabulary needs to exist.
+ */
+export interface SearchedWithout {
+    scheme: ExternalScheme;
+    /** ISO date the search was run. */
+    date: string;
+    /** What was searched, so a reader can repeat it. */
+    query: string;
+    /** Where the search was run, e.g. the SPARQL endpoint. */
+    via: string;
+}
+export type TermStatus = "active" | "deprecated";
+/**
+ * A band, never a count.
+ *
+ * THE SCALE, stated once so every axis uses the same one. Measured against the corpus named on the
+ * term: `dominant` is the top decile of values by frequency, `common` the next, `occasional` a
+ * value that appears regularly, `rare` one that barely does, and `unattested` a value the corpus
+ * never uses. Set `usage` only where the named corpus can actually speak to the term: omitting it
+ * says "not measured here", which is honest, whereas `unattested` against an unrelated corpus
+ * would read as a claim about the term rather than about the corpus. The usage figures behind these
+ * derive from a materials-marketplace catalogue and a furnishings retailer's room schemes; publishing a raw
+ * number would publish a figure from someone else's business. The band carries the signal a reader actually needs - is this term common or rare  -
+ * and nothing more.
+ */
+export type UsageBand = "dominant" | "common" | "occasional" | "rare" | "unattested";
+export interface TermUsage {
+    band: UsageBand;
+    /** The corpus the band was measured against, and when. */
+    corpus: string;
+    snapshot: string;
+}
+/**
+ * Why a term carries no usage band when the corpus plainly has something to say about it.
+ *
+ * The distinguishing case is `style.modernism`. A furnishings retailer tags a dominant share of
+ * its schemes `Modern`, but that is the crosswalk row that DECLINES: `Modern` reads as either
+ * `style.modernism` or `style.contemporary` and the source never recorded which. Attributing the
+ * usage would smuggle in the guess the crosswalk refused to make.
+ *
+ * Without this field, a reader sees "not measured" and cannot tell that apart from "nobody looked",
+ * and those are opposite claims. Same reasoning as `searchedWithout`: an absence somebody reasoned
+ * their way to is evidence, and an absence nobody has examined is a to-do.
+ */
+export interface UsageWithheld {
+    reason: string;
+    /** The corpus that would otherwise have supplied a band. */
+    corpus: string;
+}
+/**
+ * A period's extent, as four numbers rather than two.
+ *
+ * Two dates cannot answer the questions consumers actually ask. "Is 1832 Georgian?" wants the
+ * outer edge; "give me a canonical date for Georgian" wants the core. So each period carries a
+ * fuzzy interval: `earliest` and `latest` bound what could defensibly be called this period,
+ * `start` and `end` bound what uncontroversially is.
+ *
+ * `end` and `latest` are NULLABLE, and that is load-bearing rather than tidy. An open-ended period
+ * closed with the current year needs an arbitrary edit at every release, and the edit is a lie in
+ * between: `contemporary` does not end in 2026, it has not ended.
+ *
+ * SIBLING SPANS ARE ALLOWED TO OVERLAP, deliberately. Georgian and Regency genuinely do. Resolving
+ * "what period is 1800?" is therefore an accessor's job, not the data's - see `periodAt`, which
+ * prefers the narrowest match and then the un-hedged one. Leaving that to each consumer would get
+ * it reinvented differently every time.
+ */
+export interface PeriodSpan {
+    /** The earliest year anyone would defensibly call this period. */
+    earliest: number;
+    /** The first year it uncontroversially is this period. */
+    start: number;
+    /** The last year it uncontroversially is. Null when the period has not ended. */
+    end: number | null;
+    /** The last year anyone would defensibly call it this. Null when the period has not ended. */
+    latest: number | null;
+    /** True when the boundaries are conventional rather than evidenced by an event. */
+    circa: boolean;
+    /**
+     * Where these dates apply, as ISO 3166-1 alpha-2, or `global`. Regional variance beyond this
+     * belongs in NARROWER TERMS with their own spans, never in a region-to-span map on one term: a
+     * map invites partial coverage, and a narrower term is something a relation can point at.
+     */
+    regions: readonly string[];
+}
+/**
+ * What KIND of thing a style term is, because the three kinds have different truth conditions and
+ * conflating them is most of why style vocabularies rot.
+ *
+ * A `movement` has an art-historical literature, dates and adherents, and its boundaries are
+ * arguable in the way a scholarly claim is arguable. A `tradition` is a body of regional or
+ * vernacular practice, defined by what is done rather than by what was declared. A `market-idiom`
+ * is a prototype category the trade converged on, defined by resemblance to central cases and by
+ * nothing else - it has no manifesto to appeal to, and asking for necessary and sufficient
+ * conditions misunderstands it.
+ *
+ * Publishing the kind does two things. It tells a reader what sort of disagreement to expect: a
+ * dispute about Brutalism is a dispute about the record, a dispute about Farmhouse is a dispute
+ * about a prototype, and neither settles like the other. And it is the grouping a browse page needs
+ * once STYLE passes about fifty terms, when a flat alphabetical list stops being navigable.
+ */
+export type StyleKind = "movement" | "tradition" | "market-idiom";
+/**
+ * How a decorator treats this element: the habit a surface is handled by when a scheme is applied
+ * to it. A decorating habit, and nothing else.
+ *
+ * It is NOT part-of composition, which `related` already carries and which cuts across this: a
+ * cornice is part of the wall and is painted with the ceiling, so its part-of edge and its
+ * placement disagree on purpose. It is NOT compositional role either - whether a surface is the
+ * field, the accent or the thing left alone is a decision a scheme makes about one room, and it
+ * changes from room to room, while placement is a property of the element itself.
+ *
+ * `field` is the broad plane a scheme's main colour lands on. `joinery` is shop-made woodwork
+ * handled as one body with its own colour. `trim` is the run of profile and opening frame a
+ * decorator cuts in by hand. `overhead` and `underfoot` are the two planes a room is bounded by
+ * above and below, each with its own conventions. `unpainted` is an element a decorator masks or
+ * works around rather than coats - glass, light fittings, sanitaryware and electrical accessories.
+ *
+ * `feature` is RESERVED and no element carries it. A feature wall is a scheme's decision about one
+ * room, not a fact about walls, so assigning it here would be authoring taste as canon. The value
+ * exists because consumers need a name for that decision in their own data; taxonomy supplies the
+ * word without ever asserting it.
+ */
+export type ElementPlacement = "field" | "joinery" | "trim" | "overhead" | "underfoot" | "feature" | "unpainted";
+export interface Term {
+    /** Lowercase kebab-case path segment used only inside this concept's canonical URI. */
+    slug: string;
+    label: string;
+    /** Present when another package, currently ColorScope, owns this term's canonical identity. */
+    canonicalAuthority?: ColorScopeAuthority;
+    /**
+     * Parent term id. Carries TAXONOMIC SUBSUMPTION ONLY - every instance of this term must be an
+     * instance of the parent. Part-of, used-in, typically-found-in and evokes are relations, and
+     * belong in `related`, never here. See ADR 0001.
+     */
+    broaderSlug?: string;
+    /** One sentence, stating the boundary rather than restating the label. */
+    definition?: string;
+    /** Other correct names for this term. */
+    altLabels?: readonly string[];
+    /**
+     * Labels observed in the wild that mean this term but are not correct names for it: upstream
+     * spellings, typos, and off-canon coinages. Published, because a crosswalk that hides the wrong
+     * forms cannot be used to clean anyone's data.
+     */
+    seenAs?: readonly string[];
+    /** Non-taxonomic relations to other canonical terms, by predicate. */
+    related?: readonly TermRelation[];
+    external?: readonly ExternalMapping[];
+    /**
+     * Schemes searched for this term that did not have it. An absent `external` means nobody looked;
+     * a `searchedWithout` entry means somebody looked and the term is not there. Published, dated,
+     * and repeatable.
+     */
+    searchedWithout?: readonly SearchedWithout[];
+    provenance?: TermProvenance;
+    /** ISO date this term first entered the published Taxonomy corpus; internal authoring metadata. */
+    introducedAt?: string;
+    /** ISO date this term's governed content was last reviewed; internal authoring metadata. */
+    reviewedAt?: string;
+    /**
+     * Position on this term's own ordered scale, low to high. Present only on ordinal axes.
+     *
+     * MOST AXES HERE ARE UNORDERED SETS and must stay that way: `style.brutalism` is not greater
+     * than `style.rustic`, and a consumer that sorted them would be inventing a claim. TIER is
+     * different - value really is below premium, and "one rung cheaper" is a question people ask of
+     * it - so the order is data rather than an accident of array position.
+     *
+     * Ranks are NOT comparable across facets. `tier.market.premium` and `tier.chain-scale.upscale`
+     * both sit at 3 on their own ladders and are not the same claim about the world; the ladders
+     * have different lengths and different subjects. Compare within a facet or not at all.
+     *
+     * Dense from 1 within a facet, and either present on every term there or on none - both checked
+     * in `axes.test.ts`, because a half-ranked facet silently drops its unranked half from any sort.
+     */
+    rank?: number;
+    /** Present on PERIOD terms only. */
+    span?: PeriodSpan;
+    /** Present on STYLE terms only. */
+    styleKind?: StyleKind;
+    /** Present on ELEMENT terms only, and on every one of them. */
+    placement?: ElementPlacement;
+    usage?: TermUsage;
+    /**
+     * Set instead of `usage` when a corpus has evidence but it cannot honestly be attributed to this
+     * term. Never set alongside `usage`.
+     */
+    usageWithheld?: UsageWithheld;
+    status?: TermStatus;
+    /** The term that replaced this one. Required when status is "deprecated". */
+    supersededByReference?: string;
+    /** Why the term is deprecated, or any other governance note a reader needs. */
+    note?: string;
+}
+/**
+ * The named predicates a term may carry to another canonical term. Everything that is not ISA
+ * lives here, so `broaderSlug` never silently becomes a bag of loose associations.
+ */
+export type RelationPredicate = 
+/** This element is physically a component of that element. */
+"part-of"
+/** This application or element is typically found in that space. */
+ | "typically-in"
+/** This term is a material-suitability claim about that space. */
+ | "suitable-for"
+/**
+ * The subject exists to serve that sector's market, wherever the building that contains it
+ * stands: a hotel room in a mixed-use tower still serves hospitality, an operating room serves
+ * healthcare whoever the landlord is. An IDENTITY claim, never an occurrence claim - "occurs
+ * only in that sector" is false for almost any room (a multifamily amenity floor holds
+ * restrooms, a commercial kitchen and a gym inside `sector.residential`), which is why most
+ * rooms rightly carry no edge.
+ *
+ * ABSENCE IS A CLAIM, NOT A GAP. A SPACE term carrying no serves edge and inheriting none
+ * through `broaderSlug` asserts that no market is part of its identity: it serves whatever
+ * market its project serves, and a consumer must read it as unrestricted - fail-open - never as
+ * a restriction nobody wrote down. What makes that reading safe is `MARKET_NEUTRAL_SPACES`
+ * (`axes/space/market-neutral.ts`, with the authoring criterion): every SPACE term either
+ * carries an edge or is registered there as reviewed-neutral, and the build fails naming any
+ * term that is neither. A reviewed absence and an unreviewed one cannot be confused - the same
+ * move `searchedWithout` and `usageWithheld` make.
+ *
+ * Authored on SPACE only, and pinned there by test. The claim's shape would generalise, but
+ * TYPOLOGY must never carry it: sector moves when the tenant moves and typology does not, so a
+ * typology-to-sector edge dies on conversion - ADR 0001's converted warehouse full of flats is
+ * the standing counterexample.
+ */
+ | "serves"
+/** This style, idiom or scheme draws on that place idiom, period, building typology or season. */
+ | "evokes"
+/** This style descends from that style. */
+ | "influenced-by"
+/** This style is a deliberate blend of two or more named styles, and is defined by being so. */
+ | "blend-of"
+/** This surface reads as a material it is not made of. */
+ | "reads-as"
+/** Association with no stronger claim available. */
+ | "related-to";
+/**
+ * How much of the thing a relation accounts for.
+ *
+ * Without this, a room whose whole scheme is built on a Japanese reference and a room with one
+ * rattan pendant both carry `evokes(place.region.japanese)`, and retrieval cannot tell the theme
+ * from the garnish. It matters more as annotation density rises than it does today, which is why
+ * it is optional: an edge with no role stated is a claim about presence and nothing more.
+ */
+export type RelationRole = 
+/** Remove it and the thing stops being what it is. */
+"constitutive"
+/** Present and deliberate, but the scheme survives without it. */
+ | "accent";
+export interface TermRelation {
+    predicate: RelationPredicate;
+    /**
+     * Fully qualified target: `<axis>.<term id>`, or `<axis>.<facet>.<term id>` on a faceted axis.
+     *
+     * QUALIFICATION IS LOAD-BEARING, not a formatting preference. One `evokes` predicate works only
+     * because the target's axis types the reference: `evokes(place.region.nordic)` says "place"
+     * exactly once, and a consumer wanting the three-way split into place, period and typology
+     * reference recovers it losslessly by joining on the target's axis. A bare `nordic` would make
+     * that join impossible and would force a predicate per axis, which grows with the axis count.
+     *
+     * Twenty-one bare ids currently appear on more than one axis - `wall` on both application and
+     * element, `restaurant` on both space and typology, `contemporary` on both style and period -
+     * and every one of those pairs is deliberate. Qualification is what keeps them from colliding.
+     */
+    target: string;
+    role?: RelationRole;
+}
+export {};