@primmel/primmel 1.3.2 → 1.4.0

package/dist/src/types/Form.d.ts

@@ -1,9 +1,20 @@
 import Resolvable from './Resolvable';
 import Reference from './Reference';
+import type { SeriesDecl } from './Series';
+import type SourceDiscrepancy from './SourceDiscrepancy';
+import type { SourceRef } from './Subject';
 export interface ApplicabilityEntry {
     dimension: string;
     values: string[];
     mapping: Record<string, string | number> | null;
+    /**
+     * Declared-condition match mode for set-cardinality dimensions
+     * (rc.yaml $defs/applicability): 'any' (default — existential),
+     * 'all' (universal — every selected value must be listed), or
+     * 'exact' (mutual coverage — the selection covers the listed values
+     * and nothing else; set equality without implies).
+     */
+    match: 'any' | 'all' | 'exact' | null;
 }
 export interface CalculationBinding {
     inputName: string;
@@ -13,25 +24,89 @@ export interface EvaluationRule {
     rule: string;
     condition: string;
     referenceId: string | null;
+    /** Canonical verdict reference (verdict registry id). */
+    verdict?: string;
+    /** Comparison applied between the derived value and the limit. */
+    op?: string;
+    /** Limit predicate, ocl{...}. */
+    limit?: string;
+    /** Free-text source clause citation (e.g. "R 60-1, 5.7.2.6"). */
+    specificationReference?: string;
+    sourceDiscrepancy?: SourceDiscrepancy | null;
+}
+/** Role-grouped source reference (e.g. role requirement → clause URNs). */
+export interface RoleReference {
+    urn: string;
+    role: string;
 }
 export interface FormField {
     name: string;
     type: string;
+    /** True when the field head explicitly declared its type (`: string` included). */
+    typeDeclared?: boolean;
     label: string;
     definition: string;
+    /** Free-text description (distinct from the formal definition). */
+    description?: string;
     unit: string;
+    /** Binding path into the subject chain (v2 G5), e.g. model.parameters.e_max */
+    bind?: string;
+    /** Symbol id this field captures. */
+    symbol: string;
+    /** Canonical verdict id this field is judged by. */
+    verdict: string;
+    /** Requirement ids this field provides evidence for. */
+    targets: string[];
+    /** Classification dimension this field captures a value of. */
+    dimension: string;
+    /** Enum id when the field's values come from a declared enum. */
+    enumRef: string;
+    /** Regex validation pattern. */
+    pattern: string;
+    /** Field scope (e.g. administrative). */
+    scope?: string;
+    /** Example values shown as entry guidance. */
+    examples?: string;
     required: boolean;
     measurementMethod: string;
     calculationId: string | null;
     calculationBindings: CalculationBinding[];
     derivation: string;
     evaluation: EvaluationRule | null;
-    values: string[];
+    /** Allowed values; entries may carry a display label ({ value, label }). */
+    values: Array<string | {
+        value: string;
+        label: string;
+    }>;
+    /** Labels for boolean fields. */
+    trueLabel: string;
+    falseLabel: string;
+    /** Inline enum values (when the field defines its own axis).
+     *  Entries may carry a display label ({ value, label }). */
+    enumValues: Array<string | {
+        value: string;
+        label: string;
+    }>;
     defaultValue: string;
     hasDefault: boolean;
     referenceIds: string[];
+    /** Role-grouped source reference URNs. */
+    fieldReferences: RoleReference[];
+    /** Free-text source clause citation (e.g. "R 144-1, 4.5.2"). */
+    specificationReference: string;
+    /** Classification applicability filter (dimension → allowed values). */
+    applicability: ApplicabilityEntry[];
+    sourceDiscrepancy: SourceDiscrepancy | null;
     fields: FormField[];
     itemsType: string;
+    /** Unit of the array element type (items { <type> unit "…" }). */
+    itemsUnit?: string;
+    /** Series shape (axes + cell) when this datalist field holds a series. */
+    series?: SeriesDecl | null;
+    /** Array cardinality bounds (optional; parsed from min_items/max_items).
+     *  A non-numeric bound (e.g. the template "${{ n_runs }}") is kept verbatim. */
+    minItems?: number | string | null;
+    maxItems?: number | string | null;
     subformRef: SubformRef | null;
 }
 export interface SubformRef {
@@ -39,9 +114,37 @@ export interface SubformRef {
     parameters: Record<string, string>;
     applicability: ApplicabilityEntry[];
 }
+/** One derived value rule inside a pass_fail block. */
+export interface PassFailDerivation {
+    name: string;
+    calculation: string;
+    forEach: string;
+    unit: string;
+}
 export interface PassFail {
     criteria: string;
     passIf: string;
+    /** Derived-value rules feeding the pass_if expression. */
+    derivations: PassFailDerivation[];
+}
+/** Form calculation context (shared header + dimensions + tables). */
+export interface FormCalculationContext {
+    header: string;
+    dimensions: boolean;
+    tables: string[];
+}
+/** A named form instance (e.g. "on the load cell"). */
+export interface FormInstance {
+    id: string;
+    name: string;
+}
+/** A machine-checked form-level constraint. */
+export interface FormConstraint {
+    id: string;
+    rule: string;
+    onViolation: string;
+    notes: string;
+    source: SourceRef | null;
 }
 /**
  * A form is a declarative data-capture schema. Form fields can invoke
@@ -56,6 +159,29 @@ interface Form {
     dataClassId: string;
     headerFormId: string;
     conformanceProcessId: string;
+    /** Multiple conformance processes (forms covering several tests). */
+    conformanceProcessIds?: string[];
+    /** Grouping section (report structure). */
+    section: string;
+    /** Requirement ids this form provides evidence for. */
+    requirements: string[];
+    /** Free-text editorial notes (repeatable). */
+    formNotes: string[];
+    /** Form scope (e.g. administrative). */
+    scope: string;
+    /** Report-table row vocabulary (report-table forms). */
+    reportRows?: {
+        field: string;
+        itemKey: string;
+    };
+    /** Role-grouped source reference URNs. */
+    formReferences: RoleReference[];
+    /** Calculation context for evaluated fields. */
+    calculationContext: FormCalculationContext | null;
+    /** Named form instances. */
+    formInstances: FormInstance[];
+    /** Machine-checked form-level constraints. */
+    formConstraints: FormConstraint[];
     applicability: ApplicabilityEntry[];
     fields: FormField[];
     passFail: PassFail | null;

package/dist/src/types/Form.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Form.d.ts","sourceRoot":"","sources":["../../../src/types/Form.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,SAAS,MAAM,aAAa,CAAC;AAEpC,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IAEjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC;CACjD;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,mBAAmB,EAAE,kBAAkB,EAAE,CAAC;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,cAAc,GAAG,IAAI,CAAC;IAClC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAElB,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,aAAa,EAAE,kBAAkB,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,UAAU,IAAI;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,kBAAkB,EAAE,CAAC;IACpC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,GAAG,EAAE,SAAS,EAAE,CAAC;CAClB;AAED,eAAe,IAAI,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC"}
+{"version":3,"file":"Form.d.ts","sourceRoot":"","sources":["../../../src/types/Form.ts"],"names":[],"mappings":"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"}

package/dist/src/types/FormulasUsed.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The `formulas_used` construct (smart gap-close E11,
+ * analysis/architecture-gaps-2026-07.md; the smart contract
+ * data/schemas/formulas-used.yaml + data/r60/specification/
+ * formulas-used.yaml): the per-test evaluation-formula trace of a
+ * Recommendation — the first-class replacement for the hand-authored
+ * supplemental YAML the R 60 MDLO trace rides today:
+ *
+ *   formulas_used /conf/metrological-tests/measurement-error-repeatability-mdlo {
+ *     name "MDLO evaluation formulas"
+ *     description "The evaluation-level quantities of R 60-3, 2.1 the MDLO test derives from the indication output: …"
+ *     formulas { conversion_factor_f e_l e_r c_m }
+ *     source { doc "urn:oiml:pub:r:60-3:2021" clause "2.1" }
+ *   }
+ *
+ * The design (DECIDED — the 9.5-era file header contemplated a facet):
+ * a top-level registry block keyed by the conformance-test reference,
+ * NOT a facet on conformance_test — the YAML projection stays trivially
+ * byte-identical, the conformance_test grammar is untouched (OCP), and
+ * the shape mirrors the invariant/test_sequence pattern exactly. The
+ * block symbol IS the test reference — a bare reference-shaped id, the
+ * `text /req/….statement` construct's idiom (the ref alphabet `/`,
+ * letters, `-` is bare-token-safe; a quoted spelling round-trips as its
+ * own id, so authors pick one spelling).
+ *
+ * The facets (the smart side's formulas-used.yaml contract — the
+ * projection the kernel model feeds):
+ *   - name — the short trace name, MANDATORY (C94).
+ *   - description — what the listed formulas compute, with the clause
+ *     evidence, MANDATORY (C94). The default spelling's value is
+ *     authored inline; alternates ride the ISO 24229
+ *     `text <test-ref>.description { spell <code> "…" }` blocks
+ *     (TODO.roadmap/25 — the same machinery every prose field uses).
+ *   - formulas — the registry formula ids the test's evaluation
+ *     invokes, MANDATORY non-empty (C94): the registries' QUANTITY
+ *     names (calculation output names — conversion_factor_f, e_l, e_r,
+ *     c_m; the same ids the test declares as its variables).
+ *     Well-formedness is the snake_case identifier shape (C94);
+ *     RESOLUTION (does e_l exist in the calculations ∪ formulas
+ *     registries) is the smart-side linker rule R41's crosswalk —
+ *     the kernel checks syntax/shape only, exactly like E9's C90/C91
+ *     vs R38 and E10's C92/C93 vs R39 split.
+ *   - source — clause-URN provenance, the platform's content doctrine:
+ *     repeated `source { doc "urn:…" clause "…" }` blocks collecting
+ *     into sourceRefs (the requirement family's idiom). The trace is
+ *     keyed by test, so entry uniqueness is the parse-time
+ *     duplicate-id rule's — the collection key IS the test ref.
+ *
+ * Linter rules (check.ts, family base):
+ *   C94 formulas-used-shape.
+ */
+import type { SourceRef } from './Subject';
+/**
+ * The formula-identifier shape (C94): the snake_case identifier the
+ * calculations registry uses for output names (conversion_factor_f,
+ * e_l, e_r, c_m) — lowercase, digits and underscores after a leading
+ * letter. Shape only; an identifier that parses here may still dangle
+ * (resolution is the smart-side linker rule R41's job, never the
+ * kernel's).
+ */
+export declare const FORMULA_ID_SHAPE: RegExp;
+/**
+ * formulas_used <test-ref> — one per-test evaluation-formula trace
+ * (smart gap-close E11). Top-level construct, a sibling collection of
+ * `testSequences`: declared once per conformance test, composed through
+ * `uses` like every doctrine collection (MERGE_FIELDS).
+ */
+export interface FormulasUsed {
+    /**
+     * The conformance test whose evaluation invokes the formulas — the
+     * absolute test reference (e.g.
+     * /conf/metrological-tests/measurement-error-repeatability-mdlo).
+     * The block symbol itself; the trace is keyed by it (uniqueness is
+     * the parse-time duplicate-id rule's). Test-ref RESOLUTION (does the
+     * ref name a declared conformance test) is the smart-side linker R41.
+     */
+    id: string;
+    /** The short trace name ('' = undeclared — C94). */
+    name: string;
+    /**
+     * What the listed formulas compute, with the clause evidence ('' =
+     * undeclared — C94). The package-default spelling's value inline;
+     * alternates ride the ISO 24229 `text <id>.description` blocks.
+     */
+    description: string;
+    /**
+     * The registry formula ids the test's evaluation invokes, in declared
+     * order ([] = undeclared — C94). Well-formedness is FORMULA_ID_SHAPE
+     * (C94); resolution is the smart-side linker R41's.
+     */
+    formulas: string[];
+    /** Clause-URN provenance (the requirement family's repeated source blocks). */
+    sourceRefs: SourceRef[];
+}
+//# sourceMappingURL=FormulasUsed.d.ts.map

package/dist/src/types/FormulasUsed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulasUsed.d.ts","sourceRoot":"","sources":["../../../src/types/FormulasUsed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,QAAsB,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;OAOG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,+EAA+E;IAC/E,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB"}

package/dist/src/types/FormulasUsed.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * The `formulas_used` construct (smart gap-close E11,
+ * analysis/architecture-gaps-2026-07.md; the smart contract
+ * data/schemas/formulas-used.yaml + data/r60/specification/
+ * formulas-used.yaml): the per-test evaluation-formula trace of a
+ * Recommendation — the first-class replacement for the hand-authored
+ * supplemental YAML the R 60 MDLO trace rides today:
+ *
+ *   formulas_used /conf/metrological-tests/measurement-error-repeatability-mdlo {
+ *     name "MDLO evaluation formulas"
+ *     description "The evaluation-level quantities of R 60-3, 2.1 the MDLO test derives from the indication output: …"
+ *     formulas { conversion_factor_f e_l e_r c_m }
+ *     source { doc "urn:oiml:pub:r:60-3:2021" clause "2.1" }
+ *   }
+ *
+ * The design (DECIDED — the 9.5-era file header contemplated a facet):
+ * a top-level registry block keyed by the conformance-test reference,
+ * NOT a facet on conformance_test — the YAML projection stays trivially
+ * byte-identical, the conformance_test grammar is untouched (OCP), and
+ * the shape mirrors the invariant/test_sequence pattern exactly. The
+ * block symbol IS the test reference — a bare reference-shaped id, the
+ * `text /req/….statement` construct's idiom (the ref alphabet `/`,
+ * letters, `-` is bare-token-safe; a quoted spelling round-trips as its
+ * own id, so authors pick one spelling).
+ *
+ * The facets (the smart side's formulas-used.yaml contract — the
+ * projection the kernel model feeds):
+ *   - name — the short trace name, MANDATORY (C94).
+ *   - description — what the listed formulas compute, with the clause
+ *     evidence, MANDATORY (C94). The default spelling's value is
+ *     authored inline; alternates ride the ISO 24229
+ *     `text <test-ref>.description { spell <code> "…" }` blocks
+ *     (TODO.roadmap/25 — the same machinery every prose field uses).
+ *   - formulas — the registry formula ids the test's evaluation
+ *     invokes, MANDATORY non-empty (C94): the registries' QUANTITY
+ *     names (calculation output names — conversion_factor_f, e_l, e_r,
+ *     c_m; the same ids the test declares as its variables).
+ *     Well-formedness is the snake_case identifier shape (C94);
+ *     RESOLUTION (does e_l exist in the calculations ∪ formulas
+ *     registries) is the smart-side linker rule R41's crosswalk —
+ *     the kernel checks syntax/shape only, exactly like E9's C90/C91
+ *     vs R38 and E10's C92/C93 vs R39 split.
+ *   - source — clause-URN provenance, the platform's content doctrine:
+ *     repeated `source { doc "urn:…" clause "…" }` blocks collecting
+ *     into sourceRefs (the requirement family's idiom). The trace is
+ *     keyed by test, so entry uniqueness is the parse-time
+ *     duplicate-id rule's — the collection key IS the test ref.
+ *
+ * Linter rules (check.ts, family base):
+ *   C94 formulas-used-shape.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMULA_ID_SHAPE = void 0;
+/**
+ * The formula-identifier shape (C94): the snake_case identifier the
+ * calculations registry uses for output names (conversion_factor_f,
+ * e_l, e_r, c_m) — lowercase, digits and underscores after a leading
+ * letter. Shape only; an identifier that parses here may still dangle
+ * (resolution is the smart-side linker rule R41's job, never the
+ * kernel's).
+ */
+exports.FORMULA_ID_SHAPE = /^[a-z][a-z0-9_]*$/;
+//# sourceMappingURL=FormulasUsed.js.map

package/dist/src/types/FormulasUsed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulasUsed.js","sourceRoot":"","sources":["../../../src/types/FormulasUsed.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;;;AAIH;;;;;;;GAOG;AACU,QAAA,gBAAgB,GAAG,mBAAmB,CAAC"}

package/dist/src/types/Instance.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Instantiation (Primmel v3, TODO.roadmap/03): the `instance` construct —
+ * the instance plane of the definition/instance duality (doctrine ch. 3).
+ *
+ * A subject DEFINITION (subject/instrument constructs) says what kinds of
+ * things exist; an `instance` says THIS one exists — the canonical case is
+ * a Sample instance of a Model subject. Instances of the subject chain
+ * (family → group → model → sample) link upward (`model`/`group`/`family`
+ * carry the next enclosing instance id), and attribute values resolve by
+ * delegation along that chain (INV-10: upward resolution, lower override,
+ * never copied down — see src/instance-resolution.ts).
+ *
+ * Scope discipline: every attribute_definition declares the chain level at
+ * which its value is stated (`scope` family | group | model | sample).
+ * Instance values are checked against it by the linter (C17 instance-scope):
+ * a value may be stated at its declared scope or LOWER (a visible override),
+ * never higher; sample-scope (test-dependent) values live ONLY in
+ * has.testContext of a sample-level instance and are never inherited.
+ * Classification (dimension) values live in has.dimensions on the
+ * family/group/model levels — samples carry no classification.
+ *
+ * INV-8: every instance is version-pinned to its definitions via
+ * `definitionVersions` (definition id → version string); the linter (C18)
+ * rejects unpinned instances.
+ *
+ * Grammar sketch:
+ *   instance smp-hbk-hlci-001 of LoadCellSample {
+ *     level sample
+ *     model mod-hbk-hlci-2-2t-c3
+ *     definition_versions { LoadCellSample : "2021" attributes : "1.0.0" }
+ *     has {
+ *       attributes { serial_note : "calibration sticker present" }
+ *       dimensions { }                       // samples: none
+ *       test_context { d_min : 0 kg d_max : 2.2 t v : 0.037 kg n : 6000 }
+ *     }
+ *   }
+ */
+import type { QuantityValue } from './Quantity';
+/** The four subject-chain levels, from outermost to innermost. */
+export type ChainLevel = 'family' | 'group' | 'model' | 'sample';
+/**
+ * One exhibited attribute value on an instance — the QuantityValue shape
+ * (TODO.roadmap/06): `value` + optional `unit`, `quantityKind`,
+ * `uncertainty` (measured side), `tolerance` (specified side). INV-1: a
+ * value for a declared physical quantity is never a bare number — it
+ * carries a unit (linter C32). `value` holds a number when the source
+ * token was an unquoted numeric literal, otherwise the string as written
+ * (quote a numeric string to keep it a string, e.g.
+ * software_identification : "2.1").
+ *
+ * Growth note: `{value, unit?}` (task 03) widened to the full
+ * QuantityValue contract (task 06) — the two new facets are optional, so
+ * existing values type-check unchanged.
+ */
+export type InstanceValue = QuantityValue;
+/** has { … } — the instance's own exhibited values (never merged downward). */
+export interface InstanceHas {
+    /**
+     * Own attribute values (the parameters plane): attribute id → value.
+     * Holds values stated at this instance's level — including deliberate
+     * lower-level overrides of values declared at a wider scope.
+     *
+     * NOTE (sample-level override gap): the language permits a
+     * non-sample-scope attribute in a SAMPLE's has.attributes (the
+     * lower-override law), but the current app plane has no sample
+     * `parameters` field (only `test_context`) — recs SHOULD NOT author
+     * such values until the app plane grows one (tracked by TODO.roadmap
+     * task 29); a future strict mode may make this an error.
+     */
+    attributes: Record<string, InstanceValue>;
+    /** Classification membership: dimension id → value id (not on samples). */
+    dimensions: Record<string, string>;
+    /**
+     * Sample-scope (test-dependent) attribute values — the plane tests write
+     * into. Legal only on sample-level instances; never inherited (values
+     * here are never consulted when resolving from another instance).
+     */
+    testContext: Record<string, InstanceValue>;
+}
+/** instance <id> — one instance of a subject definition. */
+export interface Instance {
+    id: string;
+    /**
+     * The definition this is an instance of — a subject (v3) or instrument
+     * (v2) id. Resolution is checked by the linter (C20 instance-of-resolves).
+     */
+    of: string;
+    /**
+     * The instance's subject-chain level (family | group | model | sample),
+     * raw as written — the linter (C17) validates the enum and the scope
+     * discipline of every value against it.
+     */
+    level: string;
+    /** Upward chain links (instance ids): sample → model. */
+    model: string;
+    /** Upward chain links: model → group (optional level). */
+    group: string;
+    /** Upward chain links: model|group → family. */
+    family: string;
+    /** INV-8 pins: definition id → version string (linter C18 requires ≥1). */
+    definitionVersions: Record<string, string>;
+    has: InstanceHas;
+    referenceIds: string[];
+}
+//# sourceMappingURL=Instance.d.ts.map

package/dist/src/types/Instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instance.d.ts","sourceRoot":"","sources":["../../../src/types/Instance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,kEAAkE;AAClE,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEjE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC;AAE1C,+EAA+E;AAC/E,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;OAWG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC1C,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAC5C;AAED,4DAA4D;AAC5D,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,GAAG,EAAE,WAAW,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB"}

package/dist/src/types/Instance.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Instantiation (Primmel v3, TODO.roadmap/03): the `instance` construct —
+ * the instance plane of the definition/instance duality (doctrine ch. 3).
+ *
+ * A subject DEFINITION (subject/instrument constructs) says what kinds of
+ * things exist; an `instance` says THIS one exists — the canonical case is
+ * a Sample instance of a Model subject. Instances of the subject chain
+ * (family → group → model → sample) link upward (`model`/`group`/`family`
+ * carry the next enclosing instance id), and attribute values resolve by
+ * delegation along that chain (INV-10: upward resolution, lower override,
+ * never copied down — see src/instance-resolution.ts).
+ *
+ * Scope discipline: every attribute_definition declares the chain level at
+ * which its value is stated (`scope` family | group | model | sample).
+ * Instance values are checked against it by the linter (C17 instance-scope):
+ * a value may be stated at its declared scope or LOWER (a visible override),
+ * never higher; sample-scope (test-dependent) values live ONLY in
+ * has.testContext of a sample-level instance and are never inherited.
+ * Classification (dimension) values live in has.dimensions on the
+ * family/group/model levels — samples carry no classification.
+ *
+ * INV-8: every instance is version-pinned to its definitions via
+ * `definitionVersions` (definition id → version string); the linter (C18)
+ * rejects unpinned instances.
+ *
+ * Grammar sketch:
+ *   instance smp-hbk-hlci-001 of LoadCellSample {
+ *     level sample
+ *     model mod-hbk-hlci-2-2t-c3
+ *     definition_versions { LoadCellSample : "2021" attributes : "1.0.0" }
+ *     has {
+ *       attributes { serial_note : "calibration sticker present" }
+ *       dimensions { }                       // samples: none
+ *       test_context { d_min : 0 kg d_max : 2.2 t v : 0.037 kg n : 6000 }
+ *     }
+ *   }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Instance.js.map

package/dist/src/types/Instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instance.js","sourceRoot":"","sources":["../../../src/types/Instance.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG"}

package/dist/src/types/Invariant.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The `invariant` construct (smart gap-close E9,
+ * analysis/architecture-gaps-2026-07.md; the smart doctrine
+ * docs/oiml-core/09-invariants.md): a named architecture invariant of
+ * the platform — a rule the model, its linker, and its gates must
+ * never break:
+ *
+ *   invariant INV-1 {
+ *     name "No bare numbers"
+ *     statement "every physical quantity is a QuantityValue (value + unit [+ uncertainty])."
+ *     severity error
+ *     applies_to { QuantityValue }
+ *     source "docs/oiml-core/09-invariants.md#9.2"
+ *     enforcement { kernel:C32 kernel:C33 linker:quantity-coherence gate:schema-quantity-value }
+ *   }
+ *
+ *   invariant INV-99 {
+ *     name "…"
+ *     statement "…"
+ *     severity notice
+ *     enforcement aspirational
+ *   }
+ *
+ * Today these ride the generic `note` family with pipe-delimited
+ * structure inside the message string; the construct makes them
+ * first-class. The facets (the smart side's invariants.yaml contract —
+ * the projection the kernel model feeds):
+ *   - name — the short rule name, MANDATORY (C90).
+ *   - statement — the rule's prose, MANDATORY (C90). The default
+ *     spelling's value is authored inline; alternates ride the ISO
+ *     24229 `text INV-1.statement { spell <code> "…" }` blocks
+ *     (TODO.roadmap/25 — the same machinery every prose field uses).
+ *   - severity — free vocabulary, MANDATORY non-empty (C90). The smart
+ *     side owns the severity semantics; the kernel judges presence
+ *     only, never the vocabulary.
+ *   - applies_to — the construct/entity names the invariant constrains,
+ *     OPTIONAL (empty/absent allowed).
+ *   - source — provenance (doc path + anchor), OPTIONAL.
+ *   - enforcement — EITHER a non-empty claim list OR the literal marker
+ *     `aspirational`; never empty, never both (C90). A claim's grammar
+ *     is `kernel:C<n>` | `linker:<kebab-name>` | `gate:<kebab-name>`
+ *     (C91 — syntax only; claim TARGET resolution is the smart-side
+ *     linker rule R38's crosswalk, never the kernel's).
+ *
+ * Linter rules (check.ts, family base):
+ *   C90 invariant-shape, C91 invariant-enforcement-grammar.
+ */
+/**
+ * How an invariant is enforced: a non-empty claim list XOR the literal
+ * `aspirational` marker (declared, not yet machine-enforced). C90 owns
+ * the XOR; C91 owns the claim grammar.
+ */
+export interface InvariantEnforcement {
+    /** true = the bare `enforcement aspirational` marker. */
+    aspirational: boolean;
+    /** The enforcement claims — empty when aspirational (C90 judges both). */
+    claims: string[];
+}
+/**
+ * invariant <id> — a named architecture invariant (smart gap-close E9).
+ * Top-level construct, a sibling collection of `notes` (the generic
+ * family it replaces): declared once per invariant, composed through
+ * `uses` like every doctrine collection (MERGE_FIELDS).
+ */
+export interface Invariant {
+    id: string;
+    /** The short rule name ('' = undeclared — C90). */
+    name: string;
+    /** The rule's prose in the package's default spelling ('' = undeclared
+     *  — C90; alternates ride `text <id>.statement` blocks). */
+    statement: string;
+    /** The severity token — free vocabulary, the smart side owns the
+     *  semantics ('' = undeclared — C90). */
+    severity: string;
+    /** The construct/entity names the invariant constrains (empty allowed). */
+    appliesTo: string[];
+    /** Provenance: doc path + anchor ('' = absent). */
+    source: string;
+    /** The enforcement claims XOR the aspirational marker (C90/C91). */
+    enforcement: InvariantEnforcement;
+}
+//# sourceMappingURL=Invariant.d.ts.map

package/dist/src/types/Invariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Invariant.d.ts","sourceRoot":"","sources":["../../../src/types/Invariant.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,yDAAyD;IACzD,YAAY,EAAE,OAAO,CAAC;IACtB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb;gEAC4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB;6CACyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,WAAW,EAAE,oBAAoB,CAAC;CACnC"}

package/dist/src/types/Invariant.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * The `invariant` construct (smart gap-close E9,
+ * analysis/architecture-gaps-2026-07.md; the smart doctrine
+ * docs/oiml-core/09-invariants.md): a named architecture invariant of
+ * the platform — a rule the model, its linker, and its gates must
+ * never break:
+ *
+ *   invariant INV-1 {
+ *     name "No bare numbers"
+ *     statement "every physical quantity is a QuantityValue (value + unit [+ uncertainty])."
+ *     severity error
+ *     applies_to { QuantityValue }
+ *     source "docs/oiml-core/09-invariants.md#9.2"
+ *     enforcement { kernel:C32 kernel:C33 linker:quantity-coherence gate:schema-quantity-value }
+ *   }
+ *
+ *   invariant INV-99 {
+ *     name "…"
+ *     statement "…"
+ *     severity notice
+ *     enforcement aspirational
+ *   }
+ *
+ * Today these ride the generic `note` family with pipe-delimited
+ * structure inside the message string; the construct makes them
+ * first-class. The facets (the smart side's invariants.yaml contract —
+ * the projection the kernel model feeds):
+ *   - name — the short rule name, MANDATORY (C90).
+ *   - statement — the rule's prose, MANDATORY (C90). The default
+ *     spelling's value is authored inline; alternates ride the ISO
+ *     24229 `text INV-1.statement { spell <code> "…" }` blocks
+ *     (TODO.roadmap/25 — the same machinery every prose field uses).
+ *   - severity — free vocabulary, MANDATORY non-empty (C90). The smart
+ *     side owns the severity semantics; the kernel judges presence
+ *     only, never the vocabulary.
+ *   - applies_to — the construct/entity names the invariant constrains,
+ *     OPTIONAL (empty/absent allowed).
+ *   - source — provenance (doc path + anchor), OPTIONAL.
+ *   - enforcement — EITHER a non-empty claim list OR the literal marker
+ *     `aspirational`; never empty, never both (C90). A claim's grammar
+ *     is `kernel:C<n>` | `linker:<kebab-name>` | `gate:<kebab-name>`
+ *     (C91 — syntax only; claim TARGET resolution is the smart-side
+ *     linker rule R38's crosswalk, never the kernel's).
+ *
+ * Linter rules (check.ts, family base):
+ *   C90 invariant-shape, C91 invariant-enforcement-grammar.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Invariant.js.map

package/dist/src/types/Invariant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Invariant.js","sourceRoot":"","sources":["../../../src/types/Invariant.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG"}