@primmel/primmel 1.3.2 → 1.4.0

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

@@ -1,8 +1,43 @@
 import Resolvable from './Resolvable';
+/** The four coverage levels of the coverage calculus (concept doc §5.3). */
+export type CoverageLevel = 'full' | 'minimal' | 'partial' | 'none';
+/** One mapping pair: source component ⇒ target component. */
+export interface MappingPair {
+    /**
+     * Target element as authored — the `Namespace#ElementID` aliasing form
+     * (e.g. `StdS#Process5`) or a bare id scoped by the profile's namespace
+     * (the v2 spelling). Both normalize against the profile namespace.
+     */
+    target: string;
+    /** How the fulfilment works (warning at audit strictness when missing). */
+    description: string;
+    /** Why the claim holds (optional per pair, demanded by auditors). */
+    justification: string;
+    /**
+     * Authored coverage assertion for the TARGET component ('' = none).
+     * Coverage is COMPUTED, not authored — an assertion that disagrees
+     * with the calculus is a lint error (C23).
+     */
+    coverage: CoverageLevel | '';
+}
 interface MapProfile {
+    /** The TARGET (reference model) namespace this profile maps into. */
     namespace: string;
     description: string;
-    mappings: Record<string, string>;
+    /**
+     * source component id (local to the owning model) → the pairs it maps
+     * to. One source may fulfil several reference components at once —
+     * "write once, comply twice" (concept doc §5.6 c).
+     */
+    mappings: Record<string, MappingPair[]>;
+    /**
+     * Authored coverage ASSERTIONS about reference components (bare or
+     * `Namespace#ElementID`-qualified ids) — e.g. pinning "Process1 is
+     * partially covered" as a regression tripwire. Coverage is COMPUTED,
+     * not authored: the linter (C23) flags every assertion that disagrees
+     * with the calculus.
+     */
+    coverage: Record<string, CoverageLevel>;
 }
 export default MapProfile;
 export type ResolvableMapProfile = Resolvable<MapProfile, never>;

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

@@ -1 +1 @@
-{"version":3,"file":"MapProfile.d.ts","sourceRoot":"","sources":["../../../src/types/MapProfile.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IAEpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,eAAe,UAAU,CAAC;AAG1B,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC"}
+{"version":3,"file":"MapProfile.d.ts","sourceRoot":"","sources":["../../../src/types/MapProfile.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AAiBtC,4EAA4E;AAC5E,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAEpE,6DAA6D;AAC7D,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,aAAa,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,EAAE,aAAa,GAAG,EAAE,CAAC;CAC9B;AAED,UAAU,UAAU;IAClB,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;IACxC;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACzC;AAED,eAAe,UAAU,CAAC;AAG1B,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC"}

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

@@ -0,0 +1,144 @@
+/**
+ * The `monitor` construct (Primmel v3, TODO.roadmap/34 — doctrine
+ * ch. 14 §14.5, grammar sketch §14.11): continuous compliance. A monitor
+ * is a continuous process — the tertiary tier run as a service against
+ * live twins:
+ *
+ *   monitor fleet_watch {
+ *     over { LoadCellModel }
+ *     triggers { every 1h on signal artifact_arrived on change state }
+ *     evaluate { requirements applicable_to(this.classification) promises all }
+ *     emit { evidence -> workspace verdicts -> verdict_log }
+ *     escalate { on fail { flag_certificate open_service_case } on invalid { open_service_case } }
+ *   }
+ *
+ * The loop (§14.5), every step existing for a reason:
+ *   1. TRIGGER — something says check now: a timer (every <window>), a
+ *      signal (an artifact arrived), a change (a watched aspect moved).
+ *      Without triggers, "continuous" has no clock.
+ *   2. FETCH — the engine queries the endpoint (or receives the push);
+ *      values arrive with timestamps (the gateway, TODO.roadmap/33).
+ *   3. FRESHNESS — a stale value degrades the verdict to `indeterminate`,
+ *      never `fail` (a network outage is not a metrological event), never
+ *      a silent pass (silence is not evidence). Runtime semantics, owned
+ *      by the smart app's verdict service (TODO.roadmap/32).
+ *   4. EVALUATE — the requirement's OCL limit and the promise's
+ *      conditions run over the fresh values — the SAME statements the lab
+ *      used (INV-9); no second dialect for "online mode". The refs are
+ *      applicability-expanded per twin at runtime.
+ *   5. VERDICT — pass · fail · indeterminate · invalid, per requirement
+ *      × twin. Invalid still means the setup was wrong; fail means the
+ *      product was wrong.
+ *   6. EVIDENCE — values seen, rule results, verdicts, timestamps,
+ *      appended to the workspace. Facts only; permanent; every record
+ *      carries definition version pins (INV-8, §14.12).
+ *   7. ACT — pass: history accrues (that IS the deliverable). Fail/
+ *      invalid: escalation — notify roles, flag the certificate, open a
+ *      case. §14.12: a monitor without an escalation path for `fail` is
+ *      a warning (linter C68).
+ *
+ * Surface-syntax notes (deviations from the §14.11 sketch — the chapter
+ * is the spec for SEMANTICS, not for delimiters; the same convention the
+ * twin constructs established): the sketch's `monitor <id> over <subject>`
+ * head moves `over` INSIDE the block (the kernel's construct shape is
+ * `keyword id { … }`), and the escalate action lists are `{ … }` blocks —
+ * PRL id lists are brace-delimited everywhere.
+ *
+ * Linter rules (check.ts, family twins): C65 monitor-subject-resolves,
+ * C66 monitor-trigger-wellformed, C67 monitor-evaluate-resolves,
+ * C68 monitor-fail-escalation (the §14.12 warning),
+ * C69 monitor-escalation-resolves, C70 monitor-emit-sinks.
+ */
+/** Trigger kinds (§14.5 step 1): a timer | a signal | a watched change. */
+export declare const MONITOR_TRIGGER_KINDS: readonly ["timer", "signal", "change"];
+export type MonitorTriggerKind = (typeof MONITOR_TRIGGER_KINDS)[number];
+/**
+ * One trigger of the monitor's clock. Exactly one field is populated per
+ * kind (the linter's C66 enforces the shape):
+ *   timer  — `every <window>`: a freshness-window duration (5s, 1h, PT1H);
+ *   signal — `on signal <name>`: an external signal (an artifact arrived);
+ *   change — `on change <aspect>`: a watched aspect moved (the serve
+ *            aspect vocabulary of types/Twin.ts).
+ */
+export interface MonitorTrigger {
+    kind: string;
+    /** kind=timer: the recurrence window (e.g. `1h`, `PT1H`). */
+    every: string;
+    /** kind=signal: the signal name (e.g. artifact_arrived). */
+    signal: string;
+    /** kind=change: the watched aspect path (serve aspect vocabulary). */
+    aspect: string;
+}
+/** Evaluate-selector kinds: everything | applicability-expanded | explicit. */
+export declare const MONITOR_REFSET_KINDS: readonly ["all", "applicable_to", "refs"];
+export type MonitorRefSetKind = (typeof MONITOR_REFSET_KINDS)[number];
+/**
+ * One evaluate selector (§14.5 step 4): which requirements / promises the
+ * cycle judges. `all` and `applicable_to(<expr>)` expand per twin at
+ * runtime (applicability-expanded — the brief); `refs` names explicit
+ * requirement / promise ids (the linter's C67 resolves them).
+ */
+export interface MonitorRefSet {
+    /** 'all' | 'applicable_to' | 'refs' (C67 flags others). */
+    kind: string;
+    /** kind=applicable_to: the applicability expression (e.g.
+     *  this.classification). */
+    expression: string;
+    /** kind=refs: the explicit ids. */
+    refs: string[];
+}
+/** The evaluate block: requirement + promise refs (§14.11). */
+export interface MonitorEvaluate {
+    requirements: MonitorRefSet;
+    promises: MonitorRefSet;
+}
+/** The emitted streams (§14.5 step 6): the fact stream + the verdict log. */
+export declare const MONITOR_STREAMS: readonly ["evidence", "verdicts"];
+export type MonitorStream = (typeof MONITOR_STREAMS)[number];
+/** One emit entry: `<stream> -> <sink>` (evidence -> workspace). */
+export interface MonitorEmitSink {
+    /** 'evidence' | 'verdicts' (C70 flags others). */
+    stream: string;
+    /** The sink id (deployment-named, e.g. workspace, verdict_log). */
+    target: string;
+}
+/** Escalation outcomes — the verdict outcomes an escalation rule binds. */
+export declare const MONITOR_OUTCOMES: readonly ["pass", "fail", "indeterminate", "invalid"];
+export type MonitorOutcome = (typeof MONITOR_OUTCOMES)[number];
+/** Escalation actions (§14.5 step 7): notify / flag certificate / open case. */
+export declare const MONITOR_ESCALATION_ACTIONS: readonly ["notify", "flag_certificate", "open_service_case"];
+export type MonitorEscalationActionKind = (typeof MONITOR_ESCALATION_ACTIONS)[number];
+/**
+ * One escalation action. `notify` carries the notified role id (C69
+ * resolves it against the package's roles); flag_certificate /
+ * open_service_case carry none.
+ */
+export interface MonitorEscalationAction {
+    /** 'notify' | 'flag_certificate' | 'open_service_case' (C69 flags others). */
+    action: string;
+    /** action=notify: the role notified (resolves against declared roles). */
+    role: string;
+}
+/** One escalation rule: `on <outcome> { <action> [<role>] … }`. */
+export interface MonitorEscalationRule {
+    /** The bound verdict outcome (C69: one of MONITOR_OUTCOMES). */
+    outcome: string;
+    actions: MonitorEscalationAction[];
+}
+/**
+ * monitor <id> — a continuous compliance process over a subject set
+ * (§14.5/§14.11). Top-level construct: a monitor watches subjects from
+ * the outside (the engine operator speaks for the standard, §14.8) — it
+ * is not anatomy of the watched subject.
+ */
+export interface Monitor {
+    id: string;
+    /** The monitored subject set — subject ids (C65 resolves them). */
+    over: string[];
+    triggers: MonitorTrigger[];
+    evaluate: MonitorEvaluate;
+    emit: MonitorEmitSink[];
+    escalate: MonitorEscalationRule[];
+    referenceIds: string[];
+}
+//# sourceMappingURL=Monitor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Monitor.d.ts","sourceRoot":"","sources":["../../../src/types/Monitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,wCAAyC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,+EAA+E;AAC/E,eAAO,MAAM,oBAAoB,2CAA4C,CAAC;AAC9E,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb;gCAC4B;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,mCAAmC;IACnC,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,aAAa,CAAC;IAC5B,QAAQ,EAAE,aAAa,CAAC;CACzB;AAED,6EAA6E;AAC7E,eAAO,MAAM,eAAe,mCAAoC,CAAC;AACjE,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D,oEAAoE;AACpE,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB,uDAKnB,CAAC;AACX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,8DAI7B,CAAC;AACX,MAAM,MAAM,2BAA2B,GACrC,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9C;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;CACd;AAED,mEAAmE;AACnE,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,uBAAuB,EAAE,CAAC;CACpC;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,mEAAmE;IACnE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,QAAQ,EAAE,eAAe,CAAC;IAC1B,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,QAAQ,EAAE,qBAAqB,EAAE,CAAC;IAClC,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB"}

package/dist/src/types/Monitor.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * The `monitor` construct (Primmel v3, TODO.roadmap/34 — doctrine
+ * ch. 14 §14.5, grammar sketch §14.11): continuous compliance. A monitor
+ * is a continuous process — the tertiary tier run as a service against
+ * live twins:
+ *
+ *   monitor fleet_watch {
+ *     over { LoadCellModel }
+ *     triggers { every 1h on signal artifact_arrived on change state }
+ *     evaluate { requirements applicable_to(this.classification) promises all }
+ *     emit { evidence -> workspace verdicts -> verdict_log }
+ *     escalate { on fail { flag_certificate open_service_case } on invalid { open_service_case } }
+ *   }
+ *
+ * The loop (§14.5), every step existing for a reason:
+ *   1. TRIGGER — something says check now: a timer (every <window>), a
+ *      signal (an artifact arrived), a change (a watched aspect moved).
+ *      Without triggers, "continuous" has no clock.
+ *   2. FETCH — the engine queries the endpoint (or receives the push);
+ *      values arrive with timestamps (the gateway, TODO.roadmap/33).
+ *   3. FRESHNESS — a stale value degrades the verdict to `indeterminate`,
+ *      never `fail` (a network outage is not a metrological event), never
+ *      a silent pass (silence is not evidence). Runtime semantics, owned
+ *      by the smart app's verdict service (TODO.roadmap/32).
+ *   4. EVALUATE — the requirement's OCL limit and the promise's
+ *      conditions run over the fresh values — the SAME statements the lab
+ *      used (INV-9); no second dialect for "online mode". The refs are
+ *      applicability-expanded per twin at runtime.
+ *   5. VERDICT — pass · fail · indeterminate · invalid, per requirement
+ *      × twin. Invalid still means the setup was wrong; fail means the
+ *      product was wrong.
+ *   6. EVIDENCE — values seen, rule results, verdicts, timestamps,
+ *      appended to the workspace. Facts only; permanent; every record
+ *      carries definition version pins (INV-8, §14.12).
+ *   7. ACT — pass: history accrues (that IS the deliverable). Fail/
+ *      invalid: escalation — notify roles, flag the certificate, open a
+ *      case. §14.12: a monitor without an escalation path for `fail` is
+ *      a warning (linter C68).
+ *
+ * Surface-syntax notes (deviations from the §14.11 sketch — the chapter
+ * is the spec for SEMANTICS, not for delimiters; the same convention the
+ * twin constructs established): the sketch's `monitor <id> over <subject>`
+ * head moves `over` INSIDE the block (the kernel's construct shape is
+ * `keyword id { … }`), and the escalate action lists are `{ … }` blocks —
+ * PRL id lists are brace-delimited everywhere.
+ *
+ * Linter rules (check.ts, family twins): C65 monitor-subject-resolves,
+ * C66 monitor-trigger-wellformed, C67 monitor-evaluate-resolves,
+ * C68 monitor-fail-escalation (the §14.12 warning),
+ * C69 monitor-escalation-resolves, C70 monitor-emit-sinks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MONITOR_ESCALATION_ACTIONS = exports.MONITOR_OUTCOMES = exports.MONITOR_STREAMS = exports.MONITOR_REFSET_KINDS = exports.MONITOR_TRIGGER_KINDS = void 0;
+/** Trigger kinds (§14.5 step 1): a timer | a signal | a watched change. */
+exports.MONITOR_TRIGGER_KINDS = ['timer', 'signal', 'change'];
+/** Evaluate-selector kinds: everything | applicability-expanded | explicit. */
+exports.MONITOR_REFSET_KINDS = ['all', 'applicable_to', 'refs'];
+/** The emitted streams (§14.5 step 6): the fact stream + the verdict log. */
+exports.MONITOR_STREAMS = ['evidence', 'verdicts'];
+/** Escalation outcomes — the verdict outcomes an escalation rule binds. */
+exports.MONITOR_OUTCOMES = [
+    'pass',
+    'fail',
+    'indeterminate',
+    'invalid',
+];
+/** Escalation actions (§14.5 step 7): notify / flag certificate / open case. */
+exports.MONITOR_ESCALATION_ACTIONS = [
+    'notify',
+    'flag_certificate',
+    'open_service_case',
+];
+//# sourceMappingURL=Monitor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Monitor.js","sourceRoot":"","sources":["../../../src/types/Monitor.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;;;AAEH,2EAA2E;AAC9D,QAAA,qBAAqB,GAAG,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAU,CAAC;AAqB5E,+EAA+E;AAClE,QAAA,oBAAoB,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,CAAU,CAAC;AAyB9E,6EAA6E;AAChE,QAAA,eAAe,GAAG,CAAC,UAAU,EAAE,UAAU,CAAU,CAAC;AAWjE,2EAA2E;AAC9D,QAAA,gBAAgB,GAAG;IAC9B,MAAM;IACN,MAAM;IACN,eAAe;IACf,SAAS;CACD,CAAC;AAGX,gFAAgF;AACnE,QAAA,0BAA0B,GAAG;IACxC,QAAQ;IACR,kBAAkB;IAClB,mBAAmB;CACX,CAAC"}

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

@@ -1,10 +1,13 @@
 import Reference from './Reference';
 import Resolvable from './Resolvable';
-export type NoteType = 'NOTE' | 'CAUTION' | 'WARNING';
+import type SourceDiscrepancy from './SourceDiscrepancy';
+export type NoteType = 'NOTE' | 'CAUTION' | 'WARNING' | 'EXAMPLE' | 'COMMENTARY';
 interface Note {
     id: string;
     type: NoteType;
     message: string;
+    /** Source-discrepancy annotation attached to this note. */
+    sourceDiscrepancy?: SourceDiscrepancy | null;
     ref: Reference[];
 }
 export default Note;

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

@@ -1 +1 @@
-{"version":3,"file":"Note.d.ts","sourceRoot":"","sources":["../../../src/types/Note.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,aAAa,CAAC;AACpC,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;AAEtD,UAAU,IAAI;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,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":"Note.d.ts","sourceRoot":"","sources":["../../../src/types/Note.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,aAAa,CAAC;AACpC,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,iBAAiB,MAAM,qBAAqB,CAAC;AAEzD,MAAM,MAAM,QAAQ,GAClB,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,YAAY,CAAC;AAE5D,UAAU,IAAI;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC7C,GAAG,EAAE,SAAS,EAAE,CAAC;CAClB;AAED,eAAe,IAAI,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC"}

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

@@ -0,0 +1,161 @@
+/**
+ * Package manifest (Primmel v2, gap G8).
+ *
+ * One `package.primmel` per Recommendation package — the only required file.
+ * Everything else in the package directory is merged by convention.
+ */
+export interface PackageSource {
+    collection: string;
+    parts: string[];
+}
+/**
+ * Edition lifecycle status (TODO.roadmap/28, doctrine §13.4): `current`
+ * (the in-force edition), `preview` (published for review, not yet in
+ * force — e.g. R 91:2025), `superseded` (a later edition holds force),
+ * `withdrawn` (pulled without a successor).
+ */
+export type EditionStatus = 'current' | 'preview' | 'superseded' | 'withdrawn';
+/**
+ * An edition's validity window (doctrine §13.4: "a fact about the
+ * package's force", time-primitive machinery applied at the manifest).
+ * `from` is an ISO 8601 date/datetime; `to` optional — the window closes
+ * when the edition is superseded (or explicitly at `to`).
+ */
+export interface EditionValidity {
+    from: string;
+    to?: string;
+}
+/**
+ * Package tier (TODO.roadmap/05): `core` = the shared kernel, `module` =
+ * a shared capability package consumed by ≥2 recs, `rec` = a publishable
+ * Recommendation. Registries skip non-rec kinds in rec listings.
+ * `product_reference` (TODO.roadmap/36, doctrine ch. 15) = a
+ * manufacturer's product model, mapped aspect-by-aspect to the
+ * Recommendation — a REFERENCE model consumed by users in two modes
+ * (abstract import / live integration), never a refinement of the
+ * standard: the two are related by mapping only.
+ * `certification_program` (TODO.v2/01, twin-certification-design Q4) =
+ * a scheme operator's certification program (e.g. the digital-twin
+ * program) — a FOURTH publisher with the product_reference shape:
+ * related to recs (maps_to) and product packages (pinned abstract
+ * imports) by mapping only, composed into nothing.
+ */
+export type PackageKind = 'core' | 'module' | 'rec' | 'product_reference' | 'certification_program';
+export interface PackageManifest {
+    id: string;
+    title: string;
+    version: string;
+    /** Available editions, newest first (e.g. [2021, 2017, 2000]). */
+    editions: string[];
+    baseUrn: string;
+    /**
+     * @deprecated Metamodel package this package extends (e.g. oiml-core).
+     * Kept for backwards compatibility: the loader treats it as a single
+     * entry of `uses` (with a deprecation warning). New packages declare
+     * `uses` instead.
+     */
+    extends: string;
+    /**
+     * Imported packages (`uses` composition — structural inclusion, "my
+     * model contains yours"; concept doc §5.6 b). Multi-package, merged in
+     * topological order by the loader (TODO.roadmap/05): a downstream
+     * package may REFERENCE upstream ids but never REDEFINE them.
+     * Import is NOT mapping: a namespace listed here (or in `extends`) may
+     * not also be the target of a map_profile/.prm mapSet — linter rule
+     * C24 (import-not-mapping).
+     *
+     * Two entry forms: a bare package id (`oiml-smart-core`), or a
+     * version-pinned ABSTRACT IMPORT `acme-lc500@2021` (TODO.roadmap/36)
+     * of a `product_reference` package — reference content cited at a
+     * pinned edition, located and checked but NEVER content-merged by the
+     * composer, and exempt from C24 (the import is expressed as a mapping
+     * to the product's promised aspects; doctrine ch. 15 §15.3). The pins
+     * land in `usePins`; this list always carries the bare ids.
+     */
+    uses?: string[];
+    /**
+     * Version pins parsed from `uses` entries of the form
+     * `<package-id>@<edition>` (abstract imports of product reference
+     * packages — linter rule C83 abstract-import-pinned requires the pin
+     * and checks it against the product package's edition register).
+     * Keyed by the bare package id.
+     */
+    usePins?: Record<string, string>;
+    /** Package tier; absent means an ordinary (rec) package. */
+    kind?: PackageKind;
+    /**
+     * Product reference packages only (TODO.roadmap/36, doctrine ch. 15
+     * §15.1): the manufacturer this model speaks for, and the product
+     * designation (e.g. "LC-500"). Linter rule C81 requires both.
+     */
+    manufacturer?: string;
+    product?: string;
+    /**
+     * Product reference and certification program packages only: the
+     * standards-reference packages this model maps to (`maps_to { oiml-r60 }`)
+     * — the declaration its map_profile/.prm maps must resolve into (C81
+     * product-maps-resolves, C97 program-maps-resolves).
+     */
+    mapsTo?: string[];
+    /**
+     * Certification program packages only (TODO.v2/01,
+     * twin-certification-design Q4): the program's self-classification
+     * against the ISO/IEC 17067 scheme-type register (`scheme_type
+     * type_5`) — a free token here (the register lives consumer-side; the
+     * kernel stays register-free, the C89 spelling precedent). C98 warns
+     * when a no-surveillance shape (type_1a/1b) is declared alongside
+     * surveillance machinery.
+     */
+    schemeType?: string;
+    /**
+     * Capability ids this package contributes for downstream consumers
+     * (module manifests). Every provides entry must be consumed by a
+     * downstream package's `requires` or explicitly waived — linter rule
+     * C30 (provides-consumed-or-waived).
+     */
+    provides?: string[];
+    /**
+     * Capability or package ids this package expects in the composition.
+     * Satisfied when the entry names a composed package's id or one of its
+     * `provides` entries — checked after the merge (C31 requires-satisfied).
+     */
+    requires?: string[];
+    /**
+     * Explicit consumer-side waivers for provides entries the composer
+     * would otherwise flag as unconsumed: `<packageId>:<providesEntry>`
+     * (a bare `<providesEntry>` also matches).
+     */
+    waives?: string[];
+    /**
+     * Edition lifecycle (TODO.roadmap/28, doctrine §13.4) — packagings, not
+     * core semantics: versioning relations live on the package manifest,
+     * never in subject models. `supersedes`/`replaces` name package URNs of
+     * earlier editions (urn:oiml:pub:r:60:2017); the supersedes graph must
+     * be acyclic (linter C79).
+     */
+    supersedes?: string[];
+    /** Stronger than supersedes: this edition takes the place of the target. */
+    replaces?: string[];
+    /** The edition's validity window; `to` absent = closes when superseded. */
+    validity?: EditionValidity;
+    /** Lifecycle status of THIS packaged edition (linter C77). */
+    status?: EditionStatus;
+    /**
+     * ISO 24229 multilinguality (TODO.roadmap/25, doctrine ch. 10 §10.6):
+     * the package's DEFAULT spelling code — the spelling every inline prose
+     * string (`name "…"`, `statement "…"`, …) is authored in. Alternate
+     * spellings are added by `text` blocks; every content set carries the
+     * default. Syntax checked by C89 (script mandatory).
+     */
+    defaultSpelling?: string;
+    /**
+     * The declared spelling set of the package (the default plus every
+     * spelling a localization ships) — the linter's coverage declaration
+     * (doctrine §10.6: declared spellings missing from a set are coverage
+     * gaps). Absent means the default spelling only.
+     */
+    spellings?: string[];
+    description: string;
+    source: PackageSource | null;
+}
+//# sourceMappingURL=Package.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Package.d.ts","sourceRoot":"","sources":["../../../src/types/Package.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,CAAC;AAE/E;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,GACrB,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,mBAAmB,GAAG,uBAAuB,CAAC;AAE5E,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,4DAA4D;IAC5D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,8DAA8D;IAC9D,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;CAC9B"}

package/dist/src/types/Package.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Package.js.map

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

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

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

@@ -0,0 +1,125 @@
+/**
+ * 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.
+ */
+/**
+ * The passport content classes (TODO.roadmap/35; §14.6's "identity,
+ * composition, compliance and sustainability data" + §15.6's two modes).
+ */
+export declare const PASSPORT_CONTENT_CLASSES: readonly ["identity", "composition", "promises_as_verified", "live_compliance_status", "artifacts", "sustainability"];
+export type PassportContentClass = (typeof PASSPORT_CONTENT_CLASSES)[number];
+/** The access classes (TODO.roadmap/35; JTC24 access rights). */
+export declare const PASSPORT_ACCESS_CLASSES: readonly ["public", "restricted", "authority"];
+export type PassportAccessClass = (typeof PASSPORT_ACCESS_CLASSES)[number];
+/** The ESPR unique-product-identifier levels (JTC24). */
+export declare const PASSPORT_UPI_LEVELS: readonly ["model", "batch", "item"];
+export type PassportUpiLevel = (typeof PASSPORT_UPI_LEVELS)[number];
+/**
+ * One content entry: `<class>` or `<class>.<ref>` declared under an
+ * access class. Content tokens are kept raw — the parser stays total
+ * and the linter (C86/C87) judges the content vocabularies. The ACCESS
+ * vocabulary is fail-closed at parse time (an unknown access class is a
+ * parse error), so `access` always names a declared class.
+ */
+export interface PassportContentEntry {
+    /** The access class the entry is served under ('public' | 'restricted'
+     *  | 'authority' — the parse is fail-closed on anything else). */
+    access: string;
+    /** The content class token as authored (C86 judges unknown classes). */
+    contentClass: string;
+    /** The qualified ref within the class's resolution domain ('' = the
+     *  whole class; C86 resolves it against the package's declared
+     *  aspects/promises). */
+    ref: string;
+}
+/** The unique product identifier: the pattern and its ESPR level. */
+export interface PassportUpi {
+    /** The UPI pattern (e.g. upi:acme:lc500, upi:acme:lc500:{serial}).
+     *  '' = undeclared (C88). */
+    pattern: string;
+    /** The ESPR level — 'model' | 'batch' | 'item'. '' = undeclared
+     *  (C88: the UPI pattern declares its level). */
+    level: string;
+}
+/** One data carrier: the on-product linkage to the passport endpoint. */
+export interface PassportCarrier {
+    /** The carrier technology token (qr | rfid | nfc — free, OCP). */
+    kind: string;
+    /** The carrier payload: the passport endpoint URL. */
+    payload: string;
+}
+/**
+ * passport <id> — the model-native DPP projection (§14.6/§15.6).
+ * Top-level construct of a product reference package: the passport is
+ * the product model's PUBLIC PROJECTION — declared once per served
+ * passport, alongside the subject it projects, never inside the
+ * anatomy (the projection speaks about the subject; it is not an
+ * aspect of it).
+ */
+export interface Passport {
+    id: string;
+    /** The unique product identifier scheme (C88 judges it). */
+    upi: PassportUpi;
+    /** The data-carrier linkages (payload = the passport endpoint URL). */
+    carriers: PassportCarrier[];
+    /** The access-classed content entries (C86 resolves, C87 leak-checks). */
+    entries: PassportContentEntry[];
+    referenceIds: string[];
+}
+//# sourceMappingURL=Passport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Passport.d.ts","sourceRoot":"","sources":["../../../src/types/Passport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB,uHAO3B,CAAC;AACX,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7E,iEAAiE;AACjE,eAAO,MAAM,uBAAuB,gDAI1B,CAAC;AACX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3E,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,qCAAsC,CAAC;AACvE,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC;sEACkE;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,YAAY,EAAE,MAAM,CAAC;IACrB;;6BAEyB;IACzB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,qEAAqE;AACrE,MAAM,WAAW,WAAW;IAC1B;iCAC6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB;qDACiD;IACjD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,GAAG,EAAE,WAAW,CAAC;IACjB,uEAAuE;IACvE,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,0EAA0E;IAC1E,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB"}