@primmel/primmel 1.3.2 → 1.4.0

package/dist/src/types/Passport.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * The `passport` construct (Primmel v3, TODO.roadmap/35 — doctrine
+ * ch. 14 §14.6, ch. 15 §15.6, grammar sketch §15.8): the model-native
+ * Digital Product Passport. A passport is a named, access-classed
+ * PROJECTION of the product model plus its live instance state —
+ * "generated from the model, served by the endpoint, verified through
+ * the engine. It cannot drift from the model because it *is* the
+ * model" (§14.6) — declared on a `kind product_reference` package
+ * (ch. 15: the manufacturer's side of the model supply chain):
+ *
+ *   passport lc500_passport {
+ *     upi { pattern upi:acme:lc500 level model }
+ *     carrier { kind qr payload "https://passport.acme.example/passport/upi:acme:lc500.json" }
+ *     public { identity composition promises_as_verified }
+ *     authority { live_compliance_status }
+ *   }
+ *
+ * The facets (TODO.roadmap/35 scope, first bullet):
+ *   - CONTENT CLASSES — what the projection serves, a subset of
+ *     {identity, composition, promises_as_verified,
+ *     live_compliance_status, artifacts, sustainability}. An entry is a
+ *     bare class (the whole class) or a qualified `<class>.<ref>` naming
+ *     one aspect/promise/artifact within the class's resolution domain
+ *     (the linter's C86 resolves it; §15.9: "the passport projection
+ *     contains only aspects that resolve"). `sustainability` is the
+ *     forward class — the ESPR delegated-act content models do not
+ *     exist yet (TODO.roadmap/35, "Out"), so its refs are not
+ *     kernel-resolved.
+ *   - ACCESS CLASSES — who may read an entry: public | restricted |
+ *     authority (the JTC24 "access rights" area; §15.6: the abstract
+ *     passport is "what the EU DPP registry looks up", the authority
+ *     view is "what market surveillance actually wants"). Distinct
+ *     from the twin endpoint's access scopes (public | registered |
+ *     authority, types/Twin.ts): endpoint scopes govern API calls,
+ *     passport classes govern projection visibility. §15.9: "public
+ *     classes contain nothing marked restricted" (the linter's C87).
+ *   - UPI — the unique product identifier (ESPR; JTC24 "unique
+ *     identifiers" area): a pattern (`upi:acme:lc500`, per-unit
+ *     `upi:acme:lc500:{serial}`) and its LEVEL — model | batch | item
+ *     (the ESPR unique-product-identifier levels). The sketch's
+ *     `identifier upi:acme:lc500` spelling parses as the bare pattern
+ *     with no level — the linter's C88 demands the level.
+ *   - DATA CARRIER — the linkage (JTC24 "data carriers" area; §14.6:
+ *     reachable "through a data carrier on the product"): `kind` is
+ *     the carrier technology token (qr, rfid, nfc — free, OCP) and
+ *     `payload` is the carrier's content: the passport endpoint URL
+ *     (TODO.roadmap/35: "QR/RFID payload = the passport endpoint URL").
+ *
+ * The two SERVICE MODES of §15.6 are NOT a facet: abstract
+ * (point-in-time, as-certified — the buyer's design-time view) and
+ * live (continuous — the regulator's fleet view) are serving decisions
+ * of the projection engine; the declaration already separates the live
+ * content via the `live_compliance_status` class ("the same identity
+ * and composition, plus live compliance status computed by the
+ * engine").
+ *
+ * Linter rules (check.ts, family supply-chain):
+ *   C86 passport-content-resolves, C87 passport-access-leak,
+ *   C88 passport-upi-scheme.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PASSPORT_UPI_LEVELS = exports.PASSPORT_ACCESS_CLASSES = exports.PASSPORT_CONTENT_CLASSES = void 0;
+/**
+ * The passport content classes (TODO.roadmap/35; §14.6's "identity,
+ * composition, compliance and sustainability data" + §15.6's two modes).
+ */
+exports.PASSPORT_CONTENT_CLASSES = [
+    'identity',
+    'composition',
+    'promises_as_verified',
+    'live_compliance_status',
+    'artifacts',
+    'sustainability',
+];
+/** The access classes (TODO.roadmap/35; JTC24 access rights). */
+exports.PASSPORT_ACCESS_CLASSES = [
+    'public',
+    'restricted',
+    'authority',
+];
+/** The ESPR unique-product-identifier levels (JTC24). */
+exports.PASSPORT_UPI_LEVELS = ['model', 'batch', 'item'];
+//# sourceMappingURL=Passport.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Passport.js","sourceRoot":"","sources":["../../../src/types/Passport.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;;;AAEH;;;GAGG;AACU,QAAA,wBAAwB,GAAG;IACtC,UAAU;IACV,aAAa;IACb,sBAAsB;IACtB,wBAAwB;IACxB,WAAW;IACX,gBAAgB;CACR,CAAC;AAGX,iEAAiE;AACpD,QAAA,uBAAuB,GAAG;IACrC,QAAQ;IACR,YAAY;IACZ,WAAW;CACH,CAAC;AAGX,yDAAyD;AAC5C,QAAA,mBAAmB,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAU,CAAC"}

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

@@ -0,0 +1,99 @@
+/**
+ * Quantities, time, and the IS↔HAS value duality
+ * (Primmel v3, TODO.roadmap/06; doctrine ch. 6 — data and values).
+ *
+ * INV-1 (no bare numbers): every physical quantity is a QuantityValue —
+ * value + unit are inseparable; tolerance marks the symmetric band of a
+ * SPECIFIED value (the designed side), uncertainty the dispersion of a
+ * MEASURED value (the exhibited side). The two never merge.
+ *
+ * The quantity_register is the typed unit/quantity-kind registry of a
+ * package: units carry symbol + kind; kinds carry the dimension vector and
+ * the SI coherent unit; every non-coherent unit declares its conversion
+ * factor to SI. Comparison coherence is judged on KINDS, never on unit
+ * strings (linter C33 quantity-coherence).
+ *
+ * The `dual` construct is the IS↔HAS duality relation: ONE quantity in
+ * two aspect roles — designed (IS: what the design promises) vs exhibited
+ * (HAS: what the instance shows) — enabling as-found verification. Both
+ * roles are optional individually, but at least one must be present
+ * (linter C34 duality-coherence).
+ */
+/**
+ * One quantity value: value + unit, with the optional facets of the two
+ * duality roles. `value` holds a number when the source token was an
+ * unquoted numeric literal, otherwise the string as written.
+ */
+export interface QuantityValue {
+    value: string | number;
+    /** Unit id or symbol — resolves in a quantity_register (C33). */
+    unit?: string;
+    /**
+     * Quantity kind override. Normally derived from `unit` through the
+     * register; declared explicitly only when the unit is unmapped.
+     */
+    quantityKind?: string;
+    /** Dispersion of a MEASURED value (exhibited side; GUM-shaped). */
+    uncertainty?: string | number;
+    /** Symmetric band of a SPECIFIED value (designed side). */
+    tolerance?: string | number;
+}
+/**
+ * One quantity kind — the comparison-coherence unit. `dimensions` is the
+ * dimension vector over the SI base dimensions (M, L, T, I, Θ, N, J);
+ * `siUnit` is the SI coherent unit of the kind (symbol, e.g. "kg", "m/s").
+ */
+export interface QuantityKindDef {
+    id: string;
+    /** Dimension vector: SI base-dimension symbol → exponent (0 elided). */
+    dimensions: Record<string, number>;
+    /** SI coherent unit of the kind (symbol; "1" for dimensionless). */
+    siUnit: string;
+    description: string;
+}
+/** One unit in a quantity register. */
+export interface UnitDef {
+    id: string;
+    symbol: string;
+    label: string;
+    /** Quantity-kind id this unit measures (resolves across registers). */
+    kind: string;
+    /**
+     * Multiplicative conversion factor to the kind's SI coherent unit
+     * (km/h → 1/3.6 m/s). 1 for SI coherent units.
+     */
+    factorToSI: number;
+    /**
+     * Affine offset to SI, added AFTER scaling (degC → K: factor 1,
+     * offset 273.15). 0 for purely multiplicative units.
+     */
+    offsetToSI: number;
+    /** Free-text definition (e.g. "kg⋅m/s²" for N). */
+    definition: string;
+}
+/**
+ * quantity_register <id> — the typed unit/quantity-kind registry of a
+ * package. A rec package EXTENDS the register by adding domain units; it
+ * never redefines SI entries (linter C33).
+ */
+export interface QuantityRegister {
+    id: string;
+    kinds: QuantityKindDef[];
+    units: UnitDef[];
+    referenceIds: string[];
+}
+/**
+ * dual <id> — the IS↔HAS value duality (doctrine §3.2/§9.6). One value
+ * structure, two roles: `designed` (IS — rating, with tolerance) and
+ * `exhibited` (HAS — observation, with uncertainty). Both roles optional
+ * individually; at least one present (C34).
+ */
+export interface Dual {
+    id: string;
+    /** The attribute_definition both roles measure (id). */
+    attribute: string;
+    designed?: QuantityValue;
+    exhibited?: QuantityValue;
+    referenceIds: string[];
+}
+//# sourceMappingURL=Quantity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Quantity.d.ts","sourceRoot":"","sources":["../../../src/types/Quantity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,oEAAoE;IACpE,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,uCAAuC;AACvC,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB"}

package/dist/src/types/Quantity.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Quantities, time, and the IS↔HAS value duality
+ * (Primmel v3, TODO.roadmap/06; doctrine ch. 6 — data and values).
+ *
+ * INV-1 (no bare numbers): every physical quantity is a QuantityValue —
+ * value + unit are inseparable; tolerance marks the symmetric band of a
+ * SPECIFIED value (the designed side), uncertainty the dispersion of a
+ * MEASURED value (the exhibited side). The two never merge.
+ *
+ * The quantity_register is the typed unit/quantity-kind registry of a
+ * package: units carry symbol + kind; kinds carry the dimension vector and
+ * the SI coherent unit; every non-coherent unit declares its conversion
+ * factor to SI. Comparison coherence is judged on KINDS, never on unit
+ * strings (linter C33 quantity-coherence).
+ *
+ * The `dual` construct is the IS↔HAS duality relation: ONE quantity in
+ * two aspect roles — designed (IS: what the design promises) vs exhibited
+ * (HAS: what the instance shows) — enabling as-found verification. Both
+ * roles are optional individually, but at least one must be present
+ * (linter C34 duality-coherence).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Quantity.js.map

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

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

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

@@ -2,5 +2,7 @@ export default interface Reference {
     id: string;
     document: string;
     clause: string;
+    /** Human-readable document title. */
+    title?: string;
 }
 //# sourceMappingURL=Reference.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Reference.d.ts","sourceRoot":"","sources":["../../../src/types/Reference.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,WAAW,SAAS;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB"}
+{"version":3,"file":"Reference.d.ts","sourceRoot":"","sources":["../../../src/types/Reference.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,WAAW,SAAS;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

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

@@ -0,0 +1,53 @@
+/**
+ * Reference material construct (data/schemas/reference-materials.yaml,
+ * TODO.refactor/10 L7): the reference-material registry.
+ *
+ * Every measurement reference a standard's tests rely on (R 144 CGMs,
+ * R 91 reference speed meters) is declared once here with its identity
+ * fields and its normative CONSTRAINTS as machine-checkable rules.
+ * Conformance tests link a material via `reference_materials { <id> }`;
+ * a violated constraint with on_violation invalidate voids the run
+ * (verdict outcome invalid, never fail).
+ */
+import type { SourceRef } from './Subject';
+/** One identity field of a material instance (certified value, ...). */
+export interface MaterialIdentityField {
+    name: string;
+    description: string;
+    unit: string;
+    type: string;
+    required: boolean;
+}
+/** Authority-allowed relaxation of a constraint (recorded evidence only). */
+export interface MaterialConstraintOverride {
+    /** Relaxed OCL Boolean rule (same binding as `rule`). */
+    rule: string;
+    /** Who may allow the override (e.g. issuing_authority). */
+    by: string;
+    /** Boolean evidence field id whose true value activates the override. */
+    evidence: string;
+}
+/** Normative, machine-checked constraint on the material. */
+export interface MaterialConstraint {
+    id: string;
+    description: string;
+    /** OCL Boolean expression — free identifiers bind via `evidence`. */
+    rule: string;
+    /** Constraint identifier → evidence field id binding. */
+    evidence: Record<string, string>;
+    override: MaterialConstraintOverride | null;
+    /** invalidate: a violated constraint voids the run. */
+    onViolation: string;
+    source: SourceRef | null;
+}
+export default interface ReferenceMaterial {
+    id: string;
+    /** Material kind (e.g. certified_gas_mixture, reference_speed_meter). */
+    kind: string;
+    name: string;
+    definition: string;
+    source: SourceRef | null;
+    identityFields: MaterialIdentityField[];
+    constraints: MaterialConstraint[];
+}
+//# sourceMappingURL=ReferenceMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReferenceMaterial.d.ts","sourceRoot":"","sources":["../../../src/types/ReferenceMaterial.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,wEAAwE;AACxE,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,6EAA6E;AAC7E,MAAM,WAAW,0BAA0B;IACzC,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,6DAA6D;AAC7D,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,EAAE,0BAA0B,GAAG,IAAI,CAAC;IAC5C,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,CAAC,OAAO,WAAW,iBAAiB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,cAAc,EAAE,qBAAqB,EAAE,CAAC;IACxC,WAAW,EAAE,kBAAkB,EAAE,CAAC;CACnC"}

package/dist/src/types/ReferenceMaterial.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Reference material construct (data/schemas/reference-materials.yaml,
+ * TODO.refactor/10 L7): the reference-material registry.
+ *
+ * Every measurement reference a standard's tests rely on (R 144 CGMs,
+ * R 91 reference speed meters) is declared once here with its identity
+ * fields and its normative CONSTRAINTS as machine-checkable rules.
+ * Conformance tests link a material via `reference_materials { <id> }`;
+ * a violated constraint with on_violation invalidate voids the run
+ * (verdict outcome invalid, never fail).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ReferenceMaterial.js.map

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

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

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

@@ -0,0 +1,111 @@
+/**
+ * Requirement constructs (Primmel v2, gap G3).
+ *
+ * Requirements are REGULATORY LIMITS bound to the subject chain — not prose:
+ * statement + binds_to paths + machine OCL limit + applicability.
+ * Requirement classes group requirements into scopes (/req/<area>).
+ */
+import type AcceptanceDecision from './Acceptance';
+import type { ApplicabilityEntry } from './Form';
+import type SourceDiscrepancy from './SourceDiscrepancy';
+import type { SourceRef } from './Subject';
+/** Canonical acceptance: reference a declared VerdictQuantity by id. */
+export interface RequirementLimitAccepts {
+    /** VerdictQuantity id from the verdict registry. */
+    verdict: string;
+    /** Comparison applied between the derived value and the limit. */
+    op: string;
+    /** Limit predicate, ocl{...}. */
+    limit: string;
+    sourceDiscrepancy: SourceDiscrepancy | null;
+}
+export interface RequirementLimit {
+    expression: string;
+    uses: string[];
+    /** shall (default) | should — a failed should-limit is an observation. */
+    modality: string;
+    /** Declared base of a relative (ratio) limit. */
+    relativeTo: string;
+    notes: string;
+    /** Canonical acceptance via the verdict registry (derive once). */
+    accepts: RequirementLimitAccepts | null;
+    /** Acceptance decision rule (guarding, criterion, statistics). */
+    acceptance: AcceptanceDecision | null;
+    sourceDiscrepancy: SourceDiscrepancy | null;
+}
+/** One subject slot the requirement verifies (numbered subject chain). */
+export interface RequirementSubject {
+    slot: number;
+    entityId: string;
+    label: string;
+}
+/** Typed requirement parameter (e.g. n_runs with default + range). */
+export interface RequirementParameter {
+    name: string;
+    type: string;
+    description: string;
+    unit: string;
+    defaultValue: string;
+    hasDefault: boolean;
+    rangeMin: string;
+    rangeMax: string;
+    hasRange: boolean;
+    enumValues: string[];
+}
+export interface Requirement {
+    id: string;
+    name: string;
+    statement: string;
+    /** Free-text guidance (application notes). */
+    guidance: string;
+    /** Attribute paths into the subject chain (INV-3 — bind, never restate). */
+    bindsTo: string[];
+    /** Machine-checkable limit as OCL (quantitative requirements). */
+    limit: RequirementLimit | null;
+    /** Classification applicability filter (dimension → allowed values). */
+    applicability: ApplicabilityEntry[];
+    /**
+     * Channel dimension id (a set-cardinality classification dimension,
+     * e.g. measurand_components). When declared, this requirement is
+     * verified PER SELECTED VALUE of the channel dimension (see the
+     * instrument's per_channel declaration). Empty = once per model.
+     */
+    channel: string;
+    /** Subject slots the requirement verifies. */
+    subjects: RequirementSubject[];
+    /** Typed parameters (n_runs etc.) with defaults/ranges. */
+    parameters: RequirementParameter[];
+    /** shall (default) | should obligation level. */
+    obligation: string;
+    /** Report-table row this examination-targeted requirement maps to (rc.yaml). */
+    reportRow?: string;
+    /** Structured acceptance criteria (threshold/tiered/composite/qualitative), raw. */
+    acceptanceCriteria: string;
+    /** definitional | testing | examination | documentation */
+    verificationMethod: string;
+    /** Free-text explanation of the verification approach. */
+    verificationDescription?: string;
+    /** Other requirement ids this one depends on. */
+    dependencies: string[];
+    sourceDiscrepancy: SourceDiscrepancy | null;
+    source: SourceRef | null;
+    /** All structured provenance bindings when the requirement cites several
+     * fragments (TODO.roadmap/24 — repeated `source {}` blocks; source is
+     * the first entry, kept for back-compatibility). */
+    sourceRefs?: SourceRef[];
+    referenceIds: string[];
+}
+export interface RequirementClass {
+    id: string;
+    name: string;
+    /** Display title (defaults to name when absent). */
+    title?: string;
+    description?: string;
+    subject: string;
+    guidance: string;
+    /** Classification applicability filter at class scope (dimension → allowed values). */
+    applicability?: ApplicabilityEntry[];
+    dependencies: string[];
+    referenceIds: string[];
+}
+//# sourceMappingURL=Requirement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Requirement.d.ts","sourceRoot":"","sources":["../../../src/types/Requirement.ts"],"names":[],"mappings":"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"}

package/dist/src/types/Requirement.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Requirement constructs (Primmel v2, gap G3).
+ *
+ * Requirements are REGULATORY LIMITS bound to the subject chain — not prose:
+ * statement + binds_to paths + machine OCL limit + applicability.
+ * Requirement classes group requirements into scopes (/req/<area>).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Requirement.js.map

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

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

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

@@ -1,5 +1,9 @@
 export default interface Role {
     id: string;
     name: string;
+    /** Short human label (v2 G10). */
+    label?: string;
+    /** Free-text description of the actor's responsibilities (v2 G10). */
+    description?: string;
 }
 //# sourceMappingURL=Role.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Role.d.ts","sourceRoot":"","sources":["../../../src/types/Role.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,WAAW,IAAI;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd"}
+{"version":3,"file":"Role.d.ts","sourceRoot":"","sources":["../../../src/types/Role.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,WAAW,IAAI;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

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

@@ -0,0 +1,31 @@
+/**
+ * Series declarations (OIML SMART TODO.refactor/05 — L6).
+ *
+ * A series is an ordered array of ROW OBJECTS: declared axis fields plus
+ * one measured CELL quantity. The OCL series ops (reading_at / window /
+ * drift_over / pairwise_max_difference / group_by / change_since) select
+ * over these identifiers, so symbols, test variables, and form datalist
+ * fields that hold series must declare the shape explicitly.
+ *
+ * Maps 1:1 to `series_declaration` in data/schemas/form.yaml (axes + cell).
+ */
+/** One typed axis of a series row. */
+export interface SeriesAxis {
+    /** Row field id carrying the axis values (e.g. elapsed_min). */
+    id: string;
+    /** Measurement unit of the axis values (numeric/time axes, e.g. min). */
+    unit: string;
+    /** Value type for reference/enum axes (e.g. reference_material). */
+    type: string;
+    /** Axis role — at most one axis may carry role 'time'. */
+    role: string;
+}
+/** Typed series shape: axes + the measured cell quantity. */
+export interface SeriesDecl {
+    axes: SeriesAxis[];
+    /** Row field id of the measured cell quantity (e.g. change_v). */
+    cellSymbol: string;
+    /** Measurement unit of the cell values. */
+    cellUnit: string;
+}
+//# sourceMappingURL=Series.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Series.d.ts","sourceRoot":"","sources":["../../../src/types/Series.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,sCAAsC;AACtC,MAAM,WAAW,UAAU;IACzB,gEAAgE;IAChE,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;CACd;AAED,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;CAClB"}

package/dist/src/types/Series.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Series declarations (OIML SMART TODO.refactor/05 — L6).
+ *
+ * A series is an ordered array of ROW OBJECTS: declared axis fields plus
+ * one measured CELL quantity. The OCL series ops (reading_at / window /
+ * drift_over / pairwise_max_difference / group_by / change_since) select
+ * over these identifiers, so symbols, test variables, and form datalist
+ * fields that hold series must declare the shape explicitly.
+ *
+ * Maps 1:1 to `series_declaration` in data/schemas/form.yaml (axes + cell).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Series.js.map

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Shared source_discrepancy block (data/schemas/rc.yaml
+ * $defs/source_discrepancy, TODO.refactor/11).
+ *
+ * First-class annotation for a self-contradicting source: when two
+ * clauses of the source disagree, the element declares the conflict
+ * instead of silently picking a side. Attachable to requirements,
+ * requirement limits, limit accepts blocks, conformance tests, form
+ * fields, field evaluation rules, tables, table profiles, and notes.
+ */
+export default interface SourceDiscrepancy {
+    /** One-line statement of the contradiction. */
+    summary: string;
+    /** Clause URNs of the conflicting sources. */
+    sources: string[];
+    /** follows_clause_x (model follows one cited clause) | annotated_only. */
+    resolution: string;
+    /** Why the model resolves the contradiction this way. */
+    rationale: string;
+}
+//# sourceMappingURL=SourceDiscrepancy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SourceDiscrepancy.d.ts","sourceRoot":"","sources":["../../../src/types/SourceDiscrepancy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,CAAC,OAAO,WAAW,iBAAiB;IACxC,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/src/types/SourceDiscrepancy.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Shared source_discrepancy block (data/schemas/rc.yaml
+ * $defs/source_discrepancy, TODO.refactor/11).
+ *
+ * First-class annotation for a self-contradicting source: when two
+ * clauses of the source disagree, the element declares the conflict
+ * instead of silently picking a side. Attachable to requirements,
+ * requirement limits, limit accepts blocks, conformance tests, form
+ * fields, field evaluation rules, tables, table profiles, and notes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SourceDiscrepancy.js.map

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

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