@primmel/primmel 1.3.2 → 1.4.0

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

@@ -0,0 +1,155 @@
+/**
+ * Twin interface constructs (Primmel v3, TODO.roadmap/32 — doctrine
+ * ch. 14 §14.4, concept doc §10.2–10.3): the live twin's integration
+ * language.
+ *
+ * A live twin is a subject instance whose anatomy is SERVED (ch. 14 §14.3):
+ * "no new anatomy needed, only plumbing to serve it". Three small
+ * primitives, two of which live on the subject anatomy itself:
+ *
+ *   endpoint  (IS-level) — the subject's declared API surface, part of the
+ *     type definition "like a marking or a software identification"
+ *     (§14.3). Declared inline in the subject's `is { … }` block (§14.11
+ *     grammar sketch), NOT as a top-level construct: an endpoint is
+ *     meaningless detached from the subject whose interface it is. Each
+ *     endpoint declares:
+ *       operations — { name, kind: query | subscribe | invoke, serves/does
+ *         refs, payload schema }: query pulls a current value, subscribe
+ *         pushes on change, invoke triggers a process. Every operation
+ *         carries a payload schema — a QuantityValue per INV-1, ALWAYS
+ *         with unit (`1` for dimensionless/state payloads) and timestamp
+ *         (§14.4; §14.12: "every endpoint operation has an access scope
+ *         and a payload schema (QuantityValue with timestamp)").
+ *       access scopes — who may call what: public | registered |
+ *         authority. Every operation is covered by exactly one scope
+ *         (linter C62).
+ *       profile — the connector profile binding the protocol (below).
+ *
+ *   serve  (HAS-level) — the binding from an aspect to an operation:
+ *     `serve <aspect> via <operation> { fresh_within <duration> }`,
+ *     declared in the subject's `has { … }` block. Freshness is part of
+ *     the binding (§14.4): "the engine must know how old a value may be
+ *     before it stops meaning anything" — a live binding without
+ *     `fresh_within` is an error (§14.12; linter C63). The aspect path
+ *     uses the task-03 scope vocabulary ([level.]{parameters|
+ *     classification|test_context}.<key>, plus the reserved `state` /
+ *     `environmental_context` aspects and bare attribute/characteristic
+ *     names); the operation resolves against the owning subject's
+ *     endpoints (linter C60, with unit coherence between the served
+ *     aspect and the operation's payload).
+ *
+ *   connector_profile  (foundations) — the protocol binding registry:
+ *     the model is protocol-neutral; profiles bind protocols (§14.4).
+ *     The four standard profiles (rest_json, mqtt, opc_ua, file_drop —
+ *     BUILTIN_CONNECTOR_PROFILES) are known to the kernel without
+ *     declaration; packages extend the registry by declaring
+ *     `connector_profile` constructs (OCP — new profiles are added by
+ *     declaration, never by kernel edits). An endpoint's `profile`
+ *     resolves against declared profiles ∪ the built-ins (linter C64).
+ *
+ * Freshness semantics (§14.5 step 3): served values are timestamped; 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). The runtime half lives in the smart app's
+ * verdict service (browser/src/services/verdict.service.ts); the window
+ * parser is parseFreshnessWindow in src/time.ts.
+ *
+ * Maps 1:1 to the OIML SMART domain model layer (data/<rec>/model/
+ * twin.yaml): the YAML side carries `endpoints:` / `serves:` registries;
+ * the codecs emit/parse the subject blocks (construct-symmetric,
+ * TODO.refactor/16).
+ */
+/** Operation kinds (§14.4): pull a current value | push on change |
+ *  trigger a process. */
+export declare const ENDPOINT_OPERATION_KINDS: readonly ["query", "subscribe", "invoke"];
+export type EndpointOperationKind = (typeof ENDPOINT_OPERATION_KINDS)[number];
+/** Access scopes (§14.4): who may call what. */
+export declare const ENDPOINT_ACCESS_SCOPES: readonly ["public", "registered", "authority"];
+export type EndpointAccessScope = (typeof ENDPOINT_ACCESS_SCOPES)[number];
+/**
+ * The payload schema of an operation (§14.4): a QuantityValue per INV-1,
+ * always with unit and timestamp. `unit` carries the package register's
+ * dimensionless unit id (e.g. R 60's `dimensionless` entry) for
+ * non-quantity payloads (state reports, diagnostic reports).
+ */
+export interface EndpointPayload {
+    /** Quantity kind of the served value (mass, state, diagnostic_report, …). */
+    quantityKind: string;
+    /** Unit id from the package's quantity register; the register's
+     *  dimensionless id (e.g. `dimensionless`) when the payload is
+     *  non-quantity. */
+    unit: string;
+    /** Served values carry timestamps (§14.5) — must be true (C61): a value
+     *  without a time is not evidence. */
+    timestamp: boolean;
+}
+/** operation <name> { … } — one operation of an endpoint. */
+export interface EndpointOperation {
+    name: string;
+    /** query | subscribe | invoke (ENDPOINT_OPERATION_KINDS; C60/C62 flag others). */
+    kind: string;
+    /**
+     * The aspects this operation serves (query/subscribe face) — logical
+     * aspect names in the owning subject's vocabulary (attribute ids,
+     * characteristic names, the reserved `state` / `environmental_context`
+     * aspects); comma- or space-separated in the surface syntax.
+     */
+    serves: string[];
+    /** The processes this operation invokes (invoke face) — behavior ids. */
+    does: string[];
+    /** The payload schema; null when undeclared (C61). */
+    payload: EndpointPayload | null;
+}
+/**
+ * endpoint <id> — the subject's declared API surface (IS-level). Nested in
+ * the subject's `is { … }` block; the owning subject is implicit.
+ */
+export interface Endpoint {
+    id: string;
+    operations: EndpointOperation[];
+    /** Access scope → operation names. Every operation is covered by
+     *  exactly one scope (C62); scopes are public | registered | authority. */
+    access: Partial<Record<EndpointAccessScope, string[]>>;
+    /** Connector profile id — a declared connector_profile or one of the
+     *  built-ins (C64). */
+    profile: string;
+}
+/**
+ * serve <aspect> via <operation> { fresh_within <duration> } — the
+ * HAS-level binding from an aspect to an endpoint operation (§14.4).
+ * `freshWithin` is the freshness window: ISO-8601 duration or the
+ * shorthand form (`5s`, `500ms`, `1min`, `1h`, `1d`); empty = C63 (a live
+ * binding without fresh_within is an error — §14.12).
+ */
+export interface ServeBinding {
+    /** The served aspect path (task-03 scope vocabulary:
+     *  [level.]{parameters|classification|test_context}.<key>, the reserved
+     *  `state` / `environmental_context` aspects, or a bare
+     *  attribute/characteristic/dimension name). */
+    aspect: string;
+    /** The serving operation name (resolves against the owning subject's
+     *  endpoints — C60). */
+    via: string;
+    /** The freshness window (e.g. `5s`, `PT1M`); empty when undeclared (C63). */
+    freshWithin: string;
+}
+/** connector_profile <id> — a protocol binding declared per endpoint family. */
+export interface ConnectorProfile {
+    id: string;
+    /** The bound protocol (free text, e.g. "REST/JSON", "MQTT", "OPC-UA"). */
+    protocol: string;
+    /** What the profile carries / how the operation kinds map. */
+    description: string;
+    referenceIds: string[];
+}
+/**
+ * The four standard connector profiles (§14.4) — known to the kernel
+ * without declaration; the linter (C64) resolves endpoint profiles
+ * against declared connector_profile constructs ∪ this set. The registry
+ * is OCP-extensible: packages add profiles by declaring them.
+ */
+export declare const BUILTIN_CONNECTOR_PROFILES: Readonly<Record<string, {
+    protocol: string;
+    description: string;
+}>>;
+//# sourceMappingURL=Twin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Twin.d.ts","sourceRoot":"","sources":["../../../src/types/Twin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH;yBACyB;AACzB,eAAO,MAAM,wBAAwB,2CAI3B,CAAC;AACX,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9E,gDAAgD;AAChD,eAAO,MAAM,sBAAsB,gDAIzB,CAAC;AACX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAC;IACrB;;wBAEoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb;0CACsC;IACtC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,kFAAkF;IAClF,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,yEAAyE;IACzE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,sDAAsD;IACtD,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAChC;+EAC2E;IAC3E,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;IACvD;2BACuB;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B;;;oDAGgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf;4BACwB;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAC/C,MAAM,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAsB1D,CAAC"}

package/dist/src/types/Twin.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Twin interface constructs (Primmel v3, TODO.roadmap/32 — doctrine
+ * ch. 14 §14.4, concept doc §10.2–10.3): the live twin's integration
+ * language.
+ *
+ * A live twin is a subject instance whose anatomy is SERVED (ch. 14 §14.3):
+ * "no new anatomy needed, only plumbing to serve it". Three small
+ * primitives, two of which live on the subject anatomy itself:
+ *
+ *   endpoint  (IS-level) — the subject's declared API surface, part of the
+ *     type definition "like a marking or a software identification"
+ *     (§14.3). Declared inline in the subject's `is { … }` block (§14.11
+ *     grammar sketch), NOT as a top-level construct: an endpoint is
+ *     meaningless detached from the subject whose interface it is. Each
+ *     endpoint declares:
+ *       operations — { name, kind: query | subscribe | invoke, serves/does
+ *         refs, payload schema }: query pulls a current value, subscribe
+ *         pushes on change, invoke triggers a process. Every operation
+ *         carries a payload schema — a QuantityValue per INV-1, ALWAYS
+ *         with unit (`1` for dimensionless/state payloads) and timestamp
+ *         (§14.4; §14.12: "every endpoint operation has an access scope
+ *         and a payload schema (QuantityValue with timestamp)").
+ *       access scopes — who may call what: public | registered |
+ *         authority. Every operation is covered by exactly one scope
+ *         (linter C62).
+ *       profile — the connector profile binding the protocol (below).
+ *
+ *   serve  (HAS-level) — the binding from an aspect to an operation:
+ *     `serve <aspect> via <operation> { fresh_within <duration> }`,
+ *     declared in the subject's `has { … }` block. Freshness is part of
+ *     the binding (§14.4): "the engine must know how old a value may be
+ *     before it stops meaning anything" — a live binding without
+ *     `fresh_within` is an error (§14.12; linter C63). The aspect path
+ *     uses the task-03 scope vocabulary ([level.]{parameters|
+ *     classification|test_context}.<key>, plus the reserved `state` /
+ *     `environmental_context` aspects and bare attribute/characteristic
+ *     names); the operation resolves against the owning subject's
+ *     endpoints (linter C60, with unit coherence between the served
+ *     aspect and the operation's payload).
+ *
+ *   connector_profile  (foundations) — the protocol binding registry:
+ *     the model is protocol-neutral; profiles bind protocols (§14.4).
+ *     The four standard profiles (rest_json, mqtt, opc_ua, file_drop —
+ *     BUILTIN_CONNECTOR_PROFILES) are known to the kernel without
+ *     declaration; packages extend the registry by declaring
+ *     `connector_profile` constructs (OCP — new profiles are added by
+ *     declaration, never by kernel edits). An endpoint's `profile`
+ *     resolves against declared profiles ∪ the built-ins (linter C64).
+ *
+ * Freshness semantics (§14.5 step 3): served values are timestamped; 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). The runtime half lives in the smart app's
+ * verdict service (browser/src/services/verdict.service.ts); the window
+ * parser is parseFreshnessWindow in src/time.ts.
+ *
+ * Maps 1:1 to the OIML SMART domain model layer (data/<rec>/model/
+ * twin.yaml): the YAML side carries `endpoints:` / `serves:` registries;
+ * the codecs emit/parse the subject blocks (construct-symmetric,
+ * TODO.refactor/16).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_CONNECTOR_PROFILES = exports.ENDPOINT_ACCESS_SCOPES = exports.ENDPOINT_OPERATION_KINDS = void 0;
+/** Operation kinds (§14.4): pull a current value | push on change |
+ *  trigger a process. */
+exports.ENDPOINT_OPERATION_KINDS = [
+    'query',
+    'subscribe',
+    'invoke',
+];
+/** Access scopes (§14.4): who may call what. */
+exports.ENDPOINT_ACCESS_SCOPES = [
+    'public',
+    'registered',
+    'authority',
+];
+/**
+ * The four standard connector profiles (§14.4) — known to the kernel
+ * without declaration; the linter (C64) resolves endpoint profiles
+ * against declared connector_profile constructs ∪ this set. The registry
+ * is OCP-extensible: packages add profiles by declaring them.
+ */
+exports.BUILTIN_CONNECTOR_PROFILES = {
+    rest_json: {
+        protocol: 'REST/JSON',
+        description: 'HTTP resource endpoints — query → GET, subscribe → server-push stream, invoke → POST; JSON payloads.',
+    },
+    mqtt: {
+        protocol: 'MQTT',
+        description: 'Pub/sub telemetry — subscribe → topic subscription, query → retained topic read, invoke → command topic.',
+    },
+    opc_ua: {
+        protocol: 'OPC-UA',
+        description: 'Industrial interoperability — query → read, subscribe → monitored items, invoke → method call.',
+    },
+    file_drop: {
+        protocol: 'file drop',
+        description: 'Batch/plugin sources (§14.7) — values arrive as dropped files/records; query reads the latest drop.',
+    },
+};
+//# sourceMappingURL=Twin.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Twin.js","sourceRoot":"","sources":["../../../src/types/Twin.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;;;AAEH;yBACyB;AACZ,QAAA,wBAAwB,GAAG;IACtC,OAAO;IACP,WAAW;IACX,QAAQ;CACA,CAAC;AAGX,gDAAgD;AACnC,QAAA,sBAAsB,GAAG;IACpC,QAAQ;IACR,YAAY;IACZ,WAAW;CACH,CAAC;AAoFX;;;;;GAKG;AACU,QAAA,0BAA0B,GAEnC;IACF,SAAS,EAAE;QACT,QAAQ,EAAE,WAAW;QACrB,WAAW,EACT,sGAAsG;KACzG;IACD,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM;QAChB,WAAW,EACT,0GAA0G;KAC7G;IACD,MAAM,EAAE;QACN,QAAQ,EAAE,QAAQ;QAClB,WAAW,EACT,gGAAgG;KACnG;IACD,SAAS,EAAE;QACT,QAAQ,EAAE,WAAW;QACrB,WAAW,EACT,qGAAqG;KACxG;CACF,CAAC"}

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

@@ -0,0 +1,40 @@
+/**
+ * Verdict construct (OIML SMART TODO.refactor/04 — canonical verdict chain).
+ *
+ * A Verdict declares the SINGLE canonical derivation of one acceptance
+ * quantity ("derive once, reference everywhere"): requirements
+ * (limit.accepts), conformance tests, and form fields reference it by id
+ * instead of restating the expression. Every free identifier of the
+ * derivation must appear in `inputs` (linker rule verdict-inputs-resolve).
+ *
+ * Maps 1:1 to verdicts.yaml (data/schemas/verdicts.yaml).
+ */
+import type AcceptanceDecision from './Acceptance';
+import type { SourceRef } from './Subject';
+/** How a series of derived values reduces to one scalar before acceptance. */
+export type SeriesReduction = 'none' | 'max' | 'mean' | 'worst_case' | 'max_abs_over_window';
+/** verdict <id> — one canonical acceptance quantity. */
+export default interface Verdict {
+    id: string;
+    /** Display symbol of the quantity (e.g. C_M for mdlo_normalized). */
+    symbol?: string;
+    /**
+     * Id of the declared behavior this quantity is derived from — the
+     * behavior→I/O→characteristic chain link (TODO.roadmap/10).
+     */
+    behavior?: string;
+    /** Quantity kind of the derived value (e.g. mass, volume-fraction). */
+    quantityKind: string;
+    /** Measurement unit of the derived value; empty for dimensionless. */
+    unit: string;
+    /** The single canonical derivation, ocl{...}. */
+    derive: string;
+    /** Symbol ids the derivation reads (its free identifiers). */
+    inputs: string[];
+    /** Series→scalar reduction; null for scalar (single-measurement) verdicts. */
+    seriesReduction: SeriesReduction | null;
+    /** Acceptance decision rule (guarding, criterion, statistics). */
+    acceptance?: AcceptanceDecision | null;
+    source: SourceRef | null;
+}
+//# sourceMappingURL=Verdict.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Verdict.d.ts","sourceRoot":"","sources":["../../../src/types/Verdict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,kBAAkB,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,8EAA8E;AAC9E,MAAM,MAAM,eAAe,GACzB,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,YAAY,GAAG,qBAAqB,CAAC;AAEjE,wDAAwD;AACxD,MAAM,CAAC,OAAO,WAAW,OAAO;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,YAAY,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,8EAA8E;IAC9E,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,kEAAkE;IAClE,UAAU,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACvC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;CAC1B"}

package/dist/src/types/Verdict.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Verdict construct (OIML SMART TODO.refactor/04 — canonical verdict chain).
+ *
+ * A Verdict declares the SINGLE canonical derivation of one acceptance
+ * quantity ("derive once, reference everywhere"): requirements
+ * (limit.accepts), conformance tests, and form fields reference it by id
+ * instead of restating the expression. Every free identifier of the
+ * derivation must appear in `inputs` (linker rule verdict-inputs-resolve).
+ *
+ * Maps 1:1 to verdicts.yaml (data/schemas/verdicts.yaml).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Verdict.js.map

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

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

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

@@ -4,6 +4,12 @@ interface ViewProfile {
     description: string;
     roles: string[];
     visibleElements: string[];
+    /**
+     * The reference-model namespace this view is read against ('' = none).
+     * Views reading coverage name the map_profile/mapSet namespace whose
+     * coverage they filter — they never mutate it.
+     */
+    against: string;
 }
 export default ViewProfile;
 export type ResolvableViewProfile = Resolvable<ViewProfile, never>;

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

@@ -1 +1 @@
-{"version":3,"file":"ViewProfile.d.ts","sourceRoot":"","sources":["../../../src/types/ViewProfile.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,UAAU,WAAW;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IAEpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,eAAe,WAAW,CAAC;AAG3B,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC"}
+{"version":3,"file":"ViewProfile.d.ts","sourceRoot":"","sources":["../../../src/types/ViewProfile.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AAYtC,UAAU,WAAW;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IAEpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAe,WAAW,CAAC;AAG3B,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC"}

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

@@ -10,10 +10,25 @@ export type ResolvableRegistry = Resolvable<Registry, 'data'>;
 export interface DataClass {
     id: string;
     attributes: DataAttribute[];
+    /** Persistent store name for storable classes (v2 G2). */
+    store?: string;
+    /** Store indexes (v2 G2). */
+    indexes?: string[];
+    /** Helper classes embed into their parents (no store) (v2 G2). */
+    helper?: boolean;
+    /** Inheritance: fields merge from the parent (v2 G2). */
+    extends?: string;
+    /** Class-level description. */
+    description?: string;
 }
 export type ResolvableDataClass = {
     id: string;
     attributes: ResolveableDataAttribute[];
+    store?: string;
+    indexes?: string[];
+    helper?: boolean;
+    extends?: string;
+    description?: string;
 };
 export interface DataAttribute {
     id: string;
@@ -23,6 +38,18 @@ export interface DataAttribute {
     definition: string;
     ref: Reference[];
     satisfy: string[];
+    /** FK edge semantics on reference fields (v2 G2). */
+    onDelete?: string;
+    /** Legacy field kept for migration only (v2 G2). */
+    deprecated?: boolean;
+    /** Inline enum values for `enum`-typed fields. */
+    enumValues?: string[];
+    /** Explicit required flag (companion of modality). */
+    required?: boolean;
+    /** Unit of a quantity-valued field. */
+    unit?: string;
+    /** Default value (verbatim; structured defaults travel as JSON strings). */
+    defaultValue?: string;
 }
 export type ResolveableDataAttribute = Resolvable<DataAttribute, 'ref'>;
 export interface Enum {

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

@@ -1 +1 @@
-{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../src/types/data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,YAAY,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAE9D,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,wBAAwB,EAAE,CAAC;CACxC,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,SAAS,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;AAExE,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB"}
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../src/types/data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,YAAY,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAE9D,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6BAA6B;IAC7B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,kEAAkE;IAClE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,wBAAwB,EAAE,CAAC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,SAAS,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,kDAAkD;IAClD,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;AAExE,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB"}

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

@@ -1,8 +1,166 @@
 import { Resolvable } from './Resolvable';
 import { Registry } from './data';
 import { Subprocess } from './flow';
+import type { TestInstances, TestPrecondition } from './ConformanceTest';
+import type { QuantityValue } from './Quantity';
+import type { SourceRef } from './Subject';
 import Provision from './Provision';
 import Role from './Role';
+/** A typed name — a signature parameter or a register. */
+export interface ProcessParameter {
+    name: string;
+    /** Quantity-kind / type annotation (single token, e.g. mass, time). */
+    type: string;
+    /**
+     * Registers only (TODO.roadmap/50): the slot's INITIAL value — a literal
+     * consistent with the declared type (number, text, boolean token, or a
+     * quantity value + unit; the block form carries the full QuantityValue
+     * contract). `= <value> [unit]` in the `registers { … }` entry.
+     * undefined = no initial value declared. Signature parameters never
+     * carry one (their values arrive at the call).
+     */
+    initial?: QuantityValue;
+}
+/** Process I/O signature: what the process consumes (IN) and produces (OUT). */
+export interface ProcessSignature {
+    inputs: ProcessParameter[];
+    outputs: ProcessParameter[];
+}
+/**
+ * One role-segregation constraint of a process (TODO.roadmap/39b — the
+ * ISO/IEC 17065 clause-7 non-involvement rules: 7.5.1 reviewer ∉
+ * evaluation, 7.6.2 decider ∉ evaluation, 7.13.5 complaint resolution ∉
+ * case activities, 7.13.6/4.2.10 consultancy bars). First-class structured
+ * declaration, NOT an OCL invariant: invariants quantify over one
+ * process's own signature records, while segregation is a CROSS-process
+ * relation over personnel sets, per case — and invariant strings are never
+ * mechanically evaluated.
+ *
+ * `pair` members are PROCESS ids (that process's personnel set for the
+ * case at hand), or the reserved token `case_personnel` (the personnel
+ * involved in the certification activities of the case a complaint
+ * relates to — 7.13.5's case-relative set). Roles are deliberately not
+ * members: a scheme may bind one role to evaluation, review AND decision,
+ * so the norms quantify over process INVOLVEMENT, not role assignment.
+ * The linter (C59 segregation-members-resolve) checks well-formedness;
+ * per-assignment runtime enforcement is the platform's business.
+ */
+export interface SegregationEntry {
+    id: string;
+    /** 'case_personnel_disjoint' | 'consultancy_bar' ('' = undeclared). */
+    kind: string;
+    /** Clause of the source standard stating the constraint (e.g. "7.5.1"). */
+    clause: string;
+    /** The two disjoint personnel sets (disjoint entries; exactly two). */
+    pair: string[];
+    /** ISO-8601 duration of a fixed consultancy bar (7.13.6: "P2Y"); '' = none. */
+    period: string;
+    /** The barred client relations ('consultancy' | 'employment') — bar entries. */
+    barred: string[];
+    /** Verbatim-faithful normative statement of the constraint. */
+    statement: string;
+}
+/** The eight step kinds of the v3 step vocabulary. */
+export type ProcessStepKind = 'action' | 'approval' | 'gateway' | 'parallel_gateway' | 'start_event' | 'end_event' | 'timer_event' | 'signal_event';
+/**
+ * One signature binding of a subprocess call (TODO.roadmap/38): the callee
+ * signature parameter `param` binds to the caller-side register/parameter
+ * `bind`. `callIn` bindings feed the callee's IN parameters (the caller
+ * name is READ); `callOut` mappings return the callee's OUT parameters
+ * (the caller name is WRITTEN). The linter (C76
+ * subprocess-signature-bound) checks completeness and kind compatibility;
+ * the caller-side names join the step's I/O for C12/C13/C75.
+ */
+export interface ProcessCallBinding {
+    /** Callee signature parameter name. */
+    param: string;
+    /** Caller-side register/parameter name it binds to. */
+    bind: string;
+}
+/**
+ * One step of an executable process.
+ *
+ * Executor typing (`executor`):
+ *   - 'machine' — the engine runs the step (OCL evaluation, gateway
+ *     resolution, waits, register writes);
+ *   - 'actor' — a role performs the step; actor steps are RECORDED, not
+ *     run: `role` binds the performing role and `capture` binds the form
+ *     through which the step's outputs land in evidence;
+ *   - '' — untyped (events; or the author didn't declare one).
+ *
+ * Step I/O (`reads`/`writes`/`wait`, plus the caller-side names of a
+ * call's `with` bindings) names registers and signature parameters — the
+ * linter (C12/C13) checks those names resolve and that the step set
+ * realizes the process signature.
+ */
+export interface ProcessStep {
+    id: string;
+    kind: ProcessStepKind;
+    executor: 'machine' | 'actor' | '';
+    /** Actor steps: the bound role id. */
+    role: string;
+    /** Actor steps: the capture form id through which outputs are recorded. */
+    capture: string;
+    /** Register/parameter names the step reads. */
+    reads: string[];
+    /** Register/parameter names the step writes. */
+    writes: string[];
+    /**
+     * `wait <name>` — a machine hold on a duration register/parameter.
+     * Counts as a read for the linter (C12/C13).
+     */
+    wait: string;
+    /** timer_event: ISO-8601 recurrence period (e.g. "P12M"). */
+    period: string;
+    /** signal_event: name of the external trigger that starts/resumes. */
+    signal: string;
+    /**
+     * `fires <transition>` (TODO.roadmap/07): when the step COMPLETES, the
+     * process's bound state machine (`state <machineRef>`) takes the named
+     * transition (identified by its action name). The fired sequence lands
+     * in the run's state trajectory (see src/operational-state.ts).
+     */
+    fires: string;
+    /**
+     * `calls <process>` (TODO.roadmap/38): the step invokes a sub-process.
+     * When the callee declares a signature, `callIn`/`callOut` bind it —
+     * every IN parameter bound from a caller register, every OUT parameter
+     * mapped back to a caller register (`calls <p> { with { in {…} out {…} } }`).
+     * '' = not a call step.
+     */
+    calls: string;
+    /** IN bindings of the call (callee param ← caller name; the caller READS). */
+    callIn: ProcessCallBinding[];
+    /** OUT mappings of the call (callee param → caller name; the caller WRITES). */
+    callOut: ProcessCallBinding[];
+    description: string;
+}
+/**
+ * A flow edge between two steps of the same `does` body.
+ *
+ * Connection semantics (three rules only):
+ *   1. serial — `A -> B`: do A, then B;
+ *   2. parallel — two unconditioned paths: both, in any order;
+ *   3. self-loop + timer — repeat with a period (recurrence).
+ *
+ * `condition` is an OCL Boolean over declared registers ('' = the
+ * unconditioned/default edge). On a gateway's outgoing edges the first
+ * satisfied condition in document order wins; the unconditioned edge
+ * catches the rest.
+ */
+export interface ProcessFlowEdge {
+    from: string;
+    to: string;
+    condition: string;
+}
+/**
+ * The executable body (the DOES of the process). Its PRESENCE is what
+ * marks a process executable — `does: null` is the abstract form.
+ */
+export interface ProcessFlow {
+    steps: ProcessStep[];
+    edges: ProcessFlowEdge[];
+}
 export default interface Process {
     id: string;
     name: string;
@@ -11,10 +169,83 @@ export default interface Process {
     output: Registry[];
     input: Registry[];
     provision: Provision[];
+    /**
+     * The raw `validate_provision { … }` ids, exactly as authored. Unlike
+     * `provision` (which holds only ids that resolved to declared
+     * `provision` constructs), this list never loses a reference: OIML
+     * SMART packages point validate_provision at REQUIREMENT ids
+     * (`/req/cs/*` provisions — verified by the process, never by a
+     * conformance test), which the provision resolver cannot see. The
+     * linter reads this list (a provision'd requirement is covered, C5);
+     * the dumper emits it, so an unresolvable reference survives the
+     * load → dump round-trip instead of being silently dropped.
+     */
+    provisionRefs: string[];
     page: Subprocess | null;
     measure: string[];
     parent: string;
     children: string[];
+    /** IS: the I/O signature (null = undeclared). */
+    signature: ProcessSignature | null;
+    /** IS: OCL invariants over the signature and registers. */
+    invariants: string[];
+    /**
+     * IS: ISO/IEC 17000 activity-kind ids classifying this process in the
+     * functional approach (TODO.roadmap/39) — an abstract process may be
+     * tagged with several kinds (ISO/IEC 17065 §7.4 "evaluation" =
+     * selection + determination). Classification, not inheritance; the ids
+     * resolve against a declared activity_archetype register when one is in
+     * scope (C58 activity-kind-resolves).
+     */
+    activityKinds: string[];
+    /**
+     * IS: role-segregation constraints (TODO.roadmap/39b — the ISO/IEC
+     * 17065 non-involvement rules: review/decision personnel disjoint from
+     * evaluation personnel, complaint-resolution independence, consultancy
+     * bars). First-class machine-checkable declarations, not invariants;
+     * the linter (C59 segregation-members-resolve) checks well-formedness,
+     * per-assignment enforcement is the runtime's business.
+     */
+    segregation: SegregationEntry[];
+    /**
+     * IS: OCL Boolean guards on entry. A violated precondition voids the
+     * run AS A RUN (verdicts `invalid`, never `fail`); the language carries
+     * the declaration, the runtime evaluates it.
+     */
+    preconditions: TestPrecondition[];
+    /** IS: default executor — a role id, or the literal `machine`. */
+    executor: string;
+    /** HAS: typed registers the steps read and write. */
+    registers: ProcessParameter[];
+    /** HAS: the process's state machine reference. */
+    state: string;
+    /**
+     * Per-classification instance parameters keyed by a subject dimension
+     * (R 60: n_runs = 5 for accuracy classes A/B, 3 for C/D). Shared shape
+     * with conformance-test instances: TestInstances.
+     */
+    instances: TestInstances | null;
+    /**
+     * Child composition for the coverage calculus (TODO.roadmap/04): how
+     * this process's declared CHILDREN combine into its own fulfilment —
+     * `all` (default): every child is required (serial/parallel semantics);
+     * `gateway`: the children are exclusive branches and the gateway minimum
+     * (at least one branch) suffices for minimal cover. Coverage aggregation
+     * walks the parent/children tree (concept doc §5.3).
+     */
+    childComposition: 'all' | 'gateway';
+    /** DOES: the executable body. null = abstract process (always valid). */
+    does: ProcessFlow | null;
+    /**
+     * Clause-URN provenance (the same facet requirement/provision carry):
+     * `source { doc "urn:…" clause "…" [fragment "…"] }`. null = undeclared.
+     */
+    source: SourceRef | null;
+    /**
+     * Repeated `source { … }` blocks collect here (TODO.roadmap/24);
+     * `source` stays the first entry for back-compatibility.
+     */
+    sourceRefs?: SourceRef[];
 }
 export type ResolvableProcess = Resolvable<Process, 'actor' | 'output' | 'input' | 'provision' | 'page'>;
 //# sourceMappingURL=process.d.ts.map