@transitrix/diagrams 1.15.0 → 1.16.0

package/dist/compliance/catalogue.d.ts

@@ -0,0 +1,17 @@
+/** Relative POSIX paths keep scanning policy and content identity independent of host APIs. */
+export interface RequirementCatalogueIO {
+    read(path: string): Promise<string>;
+    list(path: string): Promise<Array<{
+        name: string;
+        kind: 'file' | 'directory' | 'symlink' | 'other';
+    }>>;
+    missing(error: unknown): boolean;
+    parse(content: string): unknown;
+    digest(content: string): string;
+    sourcePath?(path: string): string;
+}
+/** Shared disk/editor policy: one manifest boundary, all three zones, lossless failures. */
+export declare function scanRequirementCatalogue(io: RequirementCatalogueIO): Promise<{
+    canon: import("./classify.js").ComplianceCanon;
+    snapshotId: string;
+}>;

package/dist/compliance/catalogue.js

@@ -0,0 +1,68 @@
+import { emptyCanon, ingestComplianceDoc } from './classify.js';
+/** Shared disk/editor policy: one manifest boundary, all three zones, lossless failures. */
+export async function scanRequirementCatalogue(io) {
+    const canon = emptyCanon();
+    const transcript = [];
+    const manifest = await io.read('transitrix.yaml');
+    const parsed = io.parse(manifest);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error('Invalid transitrix.yaml manifest: expected a mapping');
+    transcript.push(['transitrix.yaml', manifest]);
+    const fail = (path, message) => {
+        transcript.push(['failure', path, message]);
+        canon.findings.push({ id: `${path}:load`, owner: path, field: '', code: 'LOAD', message, reference: false, severity: 'error' });
+    };
+    const walk = async (dir, top = false) => {
+        let entries;
+        try {
+            entries = await io.list(dir);
+        }
+        catch (error) {
+            if (top && io.missing(error)) {
+                transcript.push(['absent-zone', dir]);
+                return;
+            }
+            fail(dir, 'Directory could not be enumerated');
+            return;
+        }
+        if (!top && entries.some(e => e.name === 'transitrix.yaml')) {
+            transcript.push(['catalogue-boundary', dir]);
+            return;
+        }
+        for (const { name, kind } of entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+            const path = `${dir}/${name}`;
+            if (kind === 'symlink') {
+                fail(path, 'Symbolic link was not enumerated');
+                continue;
+            }
+            if (kind === 'directory') {
+                await walk(path);
+                continue;
+            }
+            if (!/\.ya?ml$/i.test(name))
+                continue;
+            if (kind !== 'file') {
+                fail(path, 'Unsupported file type');
+                continue;
+            }
+            let content;
+            try {
+                content = await io.read(path);
+            }
+            catch {
+                fail(path, 'Unreadable YAML record');
+                continue;
+            }
+            transcript.push([path, content]);
+            try {
+                ingestComplianceDoc(canon, io.parse(content), io.sourcePath?.(path) ?? path);
+            }
+            catch {
+                fail(path, 'Malformed YAML record');
+            }
+        }
+    };
+    for (const zone of ['canon', 'codex', 'field'])
+        await walk(zone, true);
+    return { canon, snapshotId: `sha256:${io.digest(JSON.stringify(transcript))}` };
+}

package/dist/compliance/index.d.ts

@@ -19,6 +19,8 @@ export { assertionToScoringElement, complianceConfidenceHeader, requirementToSco
 export { parseCoverageMetricConfig, buildCoverageMatrix, collectCoverageViewResolutionFindings, } from './coverage-metric.js';
 export type { CoverageMetricConfig, CoverageMetricRegimes, CoverageMetricRegimesFilter, CoverageMetricSubjects, CoverageMetricThresholds, CoverageMatrix, CoverageRow, CoverageViewFinding, ParseCoverageMetricResult, RagStatus, } from './coverage-metric.js';
 export type { ComplianceIndex, ComplianceIndexInput, DeadlineStatus, IndexRequirement, IndexAssertion, IndexVerification, IndexNeed, IndexValidation, LawTree, LawTreeRequirement, ProductView, ProductRequirementStatus, ObjectDetailDef, ObjectDetailInput, RequirementTrace, TraceAssertionRow, TraceVerificationRow, TraceElementCatalog, TraceElementRef, TraceSourceRef, } from './types.js';
-export { buildRequirementChain, requirementReleaseCounts, selectRequirementChain, RequirementChainSnapshot, CHAIN_STAGES, chainDate } from './requirement-chain.js';
-export type { ChainInput, ChainScope, ChainSet, RequirementChainNode, RequirementChainEdge, RequirementChainProjection } from './requirement-chain.js';
+export { buildSubjectRequirementChain, buildRequirementChain, requirementReleaseCounts, selectRequirementChain, RequirementChainSnapshot, CHAIN_STAGES, chainDate } from './requirement-chain.js';
+export type { ChainSubject, ChainInput, ChainScope, ChainSet, RequirementChainNode, RequirementChainEdge, RequirementChainProjection } from './requirement-chain.js';
 export type { ChainRecord, ChainFinding } from './types.js';
+export { scanRequirementCatalogue } from './catalogue.js';
+export type { RequirementCatalogueIO } from './catalogue.js';

package/dist/compliance/index.js

@@ -11,4 +11,5 @@ export { renderComplianceHtml, renderImpactMatrixHtml } from './html.js';
 export { buildImpactMatrix, renderImpactMarkdown, parseImpactViewConfig, collectImpactViewResolutionFindings, COMPLIANCE_IMPACT_DEFAULTS, extractObjectDetails, extractProcessFlowTasks, mergeStageTaskDetails, computeDeadlineStatus } from './impact.js';
 export { assertionToScoringElement, complianceConfidenceHeader, requirementToScoringElement, scoreComplianceView, } from './confidence.js';
 export { parseCoverageMetricConfig, buildCoverageMatrix, collectCoverageViewResolutionFindings, } from './coverage-metric.js';
-export { buildRequirementChain, requirementReleaseCounts, selectRequirementChain, RequirementChainSnapshot, CHAIN_STAGES, chainDate } from './requirement-chain.js';
+export { buildSubjectRequirementChain, buildRequirementChain, requirementReleaseCounts, selectRequirementChain, RequirementChainSnapshot, CHAIN_STAGES, chainDate } from './requirement-chain.js';
+export { scanRequirementCatalogue } from './catalogue.js';

package/dist/compliance/requirement-chain.d.ts

@@ -1,7 +1,12 @@
 import type { ChainRecord, ChainFinding, ComplianceIndex } from './types.js';
 export declare const CHAIN_STAGES: readonly ["Source document", "Driver", "Need", "Stakeholder requirement", "System requirement", "Software requirement", "Unclassified requirement", "Verification definition", "Result"];
+export interface ChainSubject {
+    type: 'PRODUCT' | 'APPLICATION';
+    id: string;
+}
 export interface ChainScope {
     catalogue: string;
+    subject?: ChainSubject;
     product?: string;
     release?: string;
     project?: string;
@@ -46,7 +51,7 @@ export interface ChainAssignment {
     relations: string[];
 }
 export interface RequirementChainProjection {
-    contract: 'requirement-chain/0.2';
+    contract: 'requirement-chain/0.2' | 'requirement-chain/0.3';
     contractRevision: string;
     asAt: string;
     snapshotId: string;
@@ -89,8 +94,14 @@ export interface RequirementChainProjection {
     executions: Record<string, string[]>;
 }
 export declare function chainDate(v: unknown): v is string;
-/** Pure, lossless release projection; no legacy coverage verdict is reinterpreted. */
+/** Explicit PRODUCT compatibility adapter for requirement-chain/0.2. */
 export declare function buildRequirementChain(input: ChainInput): RequirementChainProjection;
+/** Subject-aware 0.3 entry point; both versions use the same deterministic projection. */
+export declare function buildSubjectRequirementChain(input: ChainInput & {
+    scope: ChainScope & {
+        subject: ChainSubject;
+    };
+}): RequirementChainProjection;
 /** Both is two independent walks, never an expansion from the union frontier. */
 export declare function selectRequirementChain(p: RequirementChainProjection, focus?: string, direction?: 'upstream' | 'downstream' | 'both'): {
     nodes: RequirementChainNode[];

package/dist/compliance/requirement-chain.js

@@ -26,10 +26,28 @@ function freeze(value) {
 }
 const CODEX = ['LAW', 'REGULATION', 'STANDARD', 'POLICY', 'INTERNAL_STANDARD', 'PRINCIPLE'];
 const FIELD = ['INTERVIEW', 'SURVEY', 'OBSERVATION', 'DRAFT'];
-/** Pure, lossless release projection; no legacy coverage verdict is reinterpreted. */
+/** Explicit PRODUCT compatibility adapter for requirement-chain/0.2. */
 export function buildRequirementChain(input) {
+    if (input.scope.subject)
+        throw new Error('Use buildSubjectRequirementChain for explicit subjects');
+    return projectRequirementChain(input);
+}
+/** Subject-aware 0.3 entry point; both versions use the same deterministic projection. */
+export function buildSubjectRequirementChain(input) {
+    if (input.scope.product !== undefined)
+        throw new Error('Conflicting product and subject selectors');
+    if (!['PRODUCT', 'APPLICATION'].includes(input.scope.subject.type))
+        throw new Error('Unsupported subject type');
+    return projectRequirementChain(input);
+}
+/** Pure, lossless release projection; no legacy coverage verdict is reinterpreted. */
+function projectRequirementChain(input) {
     var _a;
     const { index, asAt, scope } = input;
+    const subject = scope.subject ?? { type: 'PRODUCT', id: scope.product };
+    const membershipKind = subject.type === 'APPLICATION' ? 'application_scope' : 'product_scope';
+    const pairKind = subject.type === 'APPLICATION' ? 'project_application' : 'project_product';
+    const subjectWord = scope.subject ? 'subject' : 'product';
     const findings = structuredClone(index.findings);
     const scopeFindings = [];
     const records = new Map();
@@ -39,7 +57,7 @@ export function buildRequirementChain(input) {
         if (!findings.some(f => f.id === id && f.code === code))
             findings.push({ id, owner, field, code, message, reference, severity: warning ? 'warning' : 'error' });
     };
-    for (const [id, versions] of index.recordsById) {
+    for (const [id, versions] of [...index.recordsById].sort(([a], [b]) => a.localeCompare(b))) {
         if (versions.length !== 1) {
             finding(id, 'id', 'DUPLICATE', 'Ambiguous catalogue identity');
             complete = false;
@@ -109,7 +127,7 @@ export function buildRequirementChain(input) {
             node(r, 2);
         else if (r.type === 'DRIVER')
             node(r, 1);
-        else if (['PRODUCT', 'RELEASE', 'ACTION'].includes(r.type))
+        else if (['PRODUCT', 'APPLICATION', 'RELEASE', 'ACTION'].includes(r.type))
             node(r, -1);
         else if (CODEX.includes(r.type) || FIELD.includes(r.type)) {
             node(r, 0);
@@ -165,13 +183,15 @@ export function buildRequirementChain(input) {
         const src = records.get(from), dst = records.get(to);
         const endpoints = kind === 'requirement_parent' ? is(from, 'REQUIREMENT') && is(to, 'REQUIREMENT') :
             kind === 'serves' ? is(from, 'REQUIREMENT') && is(to, 'NEED') :
-                kind === 'product_scope' ? is(from, 'REQUIREMENT') && is(to, 'PRODUCT') :
-                    kind === 'project_scope' ? is(from, 'REQUIREMENT') && isProject(to) :
-                        kind === 'project_product' ? isProject(from) && is(to, 'PRODUCT') :
-                            kind === 'required_for' ? is(from, 'REQUIREMENT') && is(to, 'RELEASE') :
-                                kind === 'source_trace' ? !!src && !!dst && envelope.get(from) === true && envelope.get(to) === true &&
-                                    (['REQUIREMENT', 'NEED'].includes(src.type) && (dst.type === 'DRIVER' || FIELD.includes(dst.type)) ||
-                                        src.type === 'DRIVER' && FIELD.includes(dst.type)) : !!src && !!dst;
+                kind === 'application_scope' ? is(from, 'REQUIREMENT') && is(to, 'APPLICATION') :
+                    kind === 'project_application' ? isProject(from) && is(to, 'APPLICATION') :
+                        kind === 'product_scope' ? is(from, 'REQUIREMENT') && is(to, 'PRODUCT') :
+                            kind === 'project_scope' ? is(from, 'REQUIREMENT') && isProject(to) :
+                                kind === 'project_product' ? isProject(from) && is(to, 'PRODUCT') :
+                                    kind === 'required_for' ? is(from, 'REQUIREMENT') && is(to, 'RELEASE') :
+                                        kind === 'source_trace' ? !!src && !!dst && envelope.get(from) === true && envelope.get(to) === true &&
+                                            (['REQUIREMENT', 'NEED'].includes(src.type) && (dst.type === 'DRIVER' || FIELD.includes(dst.type)) ||
+                                                src.type === 'DRIVER' && FIELD.includes(dst.type)) : !!src && !!dst;
         const temporal = contains(r, src) && contains(r, dst);
         if (!temporal)
             finding(r.id, 'to', 'REL-003', 'Relation window must be contained in both endpoints', true);
@@ -207,38 +227,38 @@ export function buildRequirementChain(input) {
         }
     }
     const memberships = (id, kind) => rels.filter(r => usable.has(r.id) && r.raw.type === kind && r.raw.from === id).map(r => String(r.raw.to));
-    const unresolved = requirements.filter(r => active.get(r.id) && memberships(r.id, 'product_scope').length === 0).map(r => r.id);
-    const P = requirements.filter(r => active.get(r.id) && memberships(r.id, 'product_scope').includes(scope.product ?? '')).map(r => r.id);
+    const unresolved = requirements.filter(r => active.get(r.id) && memberships(r.id, 'product_scope').length === 0 && (!scope.subject || memberships(r.id, 'application_scope').length === 0)).map(r => r.id);
+    const P = requirements.filter(r => active.get(r.id) && memberships(r.id, membershipKind).includes(subject.id ?? '')).map(r => r.id);
     let productComplete = complete && unresolved.length === 0;
     if (unresolved.length)
-        scopeFindings.push('Unresolved product membership');
-    if (requirements.some(r => !envelope.get(r.id)) || rels.some(r => r.raw.type === 'product_scope' && active.get(r.id) && !usable.has(r.id)))
+        scopeFindings.push(`Unresolved ${subjectWord} membership`);
+    if (requirements.some(r => !envelope.get(r.id)) || rels.some(r => r.raw.type === membershipKind && active.get(r.id) && !usable.has(r.id)))
         productComplete = false;
     const invalidAssignments = new Set();
     for (const r of rels.filter(r => r.raw.type === 'required_for')) {
         const from = String(r.raw.from), to = records.get(String(r.raw.to));
         const historical = chainDate(r.raw.valid_to) && r.raw.valid_to < asAt;
         const future = chainDate(r.raw.valid_from) && r.raw.valid_from > asAt;
-        if (!historical && !future && (!usable.has(r.id) || !memberships(from, 'product_scope').includes(String(to?.raw.of)))) {
+        if (!historical && !future && (!usable.has(r.id) || ![...memberships(from, 'product_scope'), ...(scope.subject ? memberships(from, 'application_scope') : [])].includes(String(to?.raw.of)))) {
             invalidAssignments.add(from);
-            finding(r.id, 'to', 'ASSIGNMENT', 'Invalid, dangling or wrong-product assignment', true);
+            finding(r.id, 'to', 'ASSIGNMENT', `Invalid, dangling or wrong-${subjectWord} assignment`, true);
             if (!envelope.get(r.id))
                 productComplete = false;
         }
     }
     let selectedComplete = complete;
-    if (!is(scope.product, 'PRODUCT')) {
+    if (!is(subject.id, subject.type)) {
         productComplete = false;
         selectedComplete = false;
-        scopeFindings.push('Product unselected or unresolved');
+        scopeFindings.push(scope.subject ? 'Subject unselected or unresolved' : 'Product unselected or unresolved');
     }
-    if (!is(scope.release, 'RELEASE') || records.get(scope.release ?? '')?.raw.of !== scope.product) {
+    if (!is(scope.release, 'RELEASE') || records.get(scope.release ?? '')?.raw.of !== subject.id) {
         selectedComplete = false;
-        scopeFindings.push('Release unselected, unresolved or wrong product');
+        scopeFindings.push(`Release unselected, unresolved or wrong ${subjectWord}`);
     }
-    if (scope.project && (!isProject(scope.project) || !memberships(scope.project, 'project_product').includes(scope.product ?? ''))) {
+    if (scope.project && (!isProject(scope.project) || !memberships(scope.project, pairKind).includes(subject.id ?? ''))) {
         selectedComplete = false;
-        scopeFindings.push('Invalid or unmodelled project/product pair');
+        scopeFindings.push(`Invalid or unmodelled project/${subjectWord} pair`);
     }
     function query(release) {
         const chain = [];
@@ -246,9 +266,9 @@ export function buildRequirementChain(input) {
         let valid = true;
         while (cursor) {
             const r = records.get(cursor);
-            if (chain.includes(cursor) || !is(cursor, 'RELEASE') || r?.raw.of !== scope.product) {
+            if (chain.includes(cursor) || !is(cursor, 'RELEASE') || r?.raw.of !== subject.id) {
                 valid = false;
-                finding(chain[chain.length - 1] ?? release, 'predecessor', 'RELEASE-SCOPE', chain.includes(cursor) ? 'Release predecessor cycle' : 'Missing, invalid or cross-product predecessor');
+                finding(chain[chain.length - 1] ?? release, 'predecessor', 'RELEASE-SCOPE', chain.includes(cursor) ? 'Release predecessor cycle' : `Missing, invalid or cross-${subjectWord} predecessor`);
                 break;
             }
             chain.push(cursor);
@@ -275,16 +295,16 @@ export function buildRequirementChain(input) {
         selectedComplete = false;
         scopeFindings.push('Unresolved project membership');
     }
-    if (rels.some(r => ['product_scope', 'project_scope', 'required_for'].includes(String(r.raw.type)) && !envelope.get(r.id)))
+    if (rels.some(r => [membershipKind, 'project_scope', 'required_for'].includes(String(r.raw.type)) && !envelope.get(r.id)))
         selectedComplete = false;
-    if (scope.project && L.some(id => memberships(id, 'project_scope').some(project => !memberships(project, 'project_product').includes(scope.product ?? '')))) {
+    if (scope.project && L.some(id => memberships(id, 'project_scope').some(project => !memberships(project, pairKind).includes(subject.id ?? '')))) {
         selectedComplete = false;
-        scopeFindings.push('Inconsistent project/product membership');
+        scopeFindings.push(`Inconsistent project/${subjectWord} membership`);
     }
     const S = L.filter(id => !scope.project || memberships(id, 'project_scope').includes(scope.project));
     const elsewhere = new Set();
     for (const release of records.values())
-        if (release.type === 'RELEASE' && release.raw.of === scope.product) {
+        if (release.type === 'RELEASE' && release.raw.of === subject.id) {
             const q = query(release.id);
             productComplete && (productComplete = q.complete);
             q.ids.forEach(id => elsewhere.add(id));
@@ -352,7 +372,7 @@ export function buildRequirementChain(input) {
             if (v.raw.verifies === r.id)
                 owners.add(v.id);
         for (const rel of rels) {
-            const ownScope = ['product_scope', 'project_scope', 'required_for'].includes(String(rel.raw.type));
+            const ownScope = [membershipKind, 'project_scope', 'required_for'].includes(String(rel.raw.type));
             if (ownScope ? rel.raw.from === r.id : owners.has(String(rel.raw.from)))
                 owners.add(rel.id);
         }
@@ -379,15 +399,17 @@ export function buildRequirementChain(input) {
     const broken = S.filter(id => selectedRefs.some(f => affectedRequirements[f.id]?.includes(id)));
     for (const n of nodes)
         if (records.get(n.recordId)?.type === 'REQUIREMENT' && !S.includes(n.recordId)) {
-            n.context.push(!active.get(n.recordId) ? 'inactive' : !P.includes(n.recordId) ? 'unresolved or other product' :
+            n.context.push(!active.get(n.recordId) ? 'inactive' : !P.includes(n.recordId) ? `unresolved or other ${subjectWord}` :
                 !L.includes(n.recordId) ? 'other release or unassigned' : 'other project');
         }
+    if (scope.subject && (!is(subject.id, subject.type) || !is(scope.release, 'RELEASE') || records.get(scope.release ?? '')?.raw.of !== subject.id))
+        productComplete = false;
     const unassignedSet = set(unassigned, productComplete);
     const result = {
-        contract: 'requirement-chain/0.2', contractRevision: '97c9d41819011ead8fe192c266cba32707eae82f', asAt, snapshotId: input.snapshotId, sourceRevision: input.sourceRevision,
+        contract: scope.subject ? 'requirement-chain/0.3' : 'requirement-chain/0.2', contractRevision: scope.subject ? 'a131b1862d86f34be8feb729e1cc6ebc994c3891' : '97c9d41819011ead8fe192c266cba32707eae82f', asAt, snapshotId: input.snapshotId, sourceRevision: input.sourceRevision,
         scope: structuredClone(scope), completeness: productComplete && selectedComplete ? 'complete' : 'incomplete', scopeFindings: sorted(scopeFindings),
         populations: { product: set(P, productComplete), release: set(L, selectedComplete), selected: set(S, selectedComplete),
-            inactive: set(requirements.filter(r => envelope.get(r.id) && !active.get(r.id) && rels.some(rel => rel.raw.type === 'product_scope' && rel.raw.from === r.id && rel.raw.to === scope.product && envelope.get(rel.id))).map(r => r.id), complete),
+            inactive: set(requirements.filter(r => envelope.get(r.id) && !active.get(r.id) && rels.some(rel => rel.raw.type === membershipKind && rel.raw.from === r.id && rel.raw.to === subject.id && envelope.get(rel.id))).map(r => r.id), complete),
             unresolved: set(unresolved, complete) },
         assignments: { here: set(L, selectedComplete), otherReleaseOnly: set(P.filter(id => elsewhere.has(id) && !L.includes(id)), productComplete),
             unassigned: unassignedSet, invalid: set(P.filter(id => invalidAssignments.has(id)), complete), provenance: selected.provenance.sort((a, b) => a.requirement.localeCompare(b.requirement)) },
@@ -474,6 +496,9 @@ export function requirementReleaseCounts(p) {
     const contextUnits = { 0: 'source documents', 1: 'drivers', 2: 'needs', 7: 'definition parts', 8: 'result parts' };
     for (const stage of [0, 1, 2, 7, 8])
         add('context-' + stage, CHAIN_STAGES[stage], set(view.nodes.filter(n => n.stage === stage).map(n => n.id), p.populations.selected.completeness === 'complete'), contextUnits[stage]);
+    if (p.scope.subject)
+        for (const count of Object.values(counts))
+            count.label = count.label.replace(/whole product/g, 'whole subject').replace('Product requirements', 'Subject requirements');
     return freeze(counts);
 }
 /** Monotonic refresh gate shared by reports; late successes and failures cannot replace newer data. */
@@ -488,7 +513,9 @@ export class RequirementChainSnapshot {
             const input = await load();
             if (generation !== this.generation)
                 return false;
-            this.current = buildRequirementChain(input);
+            this.current = input.scope.subject
+                ? buildSubjectRequirementChain({ ...input, scope: { ...input.scope, subject: input.scope.subject } })
+                : buildRequirementChain(input);
             this.stale = false;
             return true;
         }

package/dist/products/types.d.ts

@@ -1,4 +1,4 @@
-export type ProductType = 'digital_product' | 'service' | 'platform' | 'bundle';
+export type ProductType = 'physical_product' | 'digital_product' | 'service' | 'platform' | 'bundle';
 export type ProductStatus = 'Draft' | 'Active' | 'Deprecated';
 export interface Product {
     product_id: string;

package/dist/products/validate.js

@@ -1,5 +1,5 @@
 import { schemaFinding } from '../schema-finding.js';
-const VALID_TYPES = new Set(['digital_product', 'service', 'platform', 'bundle']);
+const VALID_TYPES = new Set(['physical_product', 'digital_product', 'service', 'platform', 'bundle']);
 const VALID_STATUSES = new Set(['Draft', 'Active', 'Deprecated']);
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 export function validateProductsCatalogue(input) {

package/dist/standalone/validate.js

@@ -1,6 +1,6 @@
 // Standalone forms from ELEMENT_PRIMITIVES and CONTRACT (Methodology 7).
 // Field payloads are opaque: only their published identity/admission contract is checked.
-import { isCanonicalIdOfType, typeOfId } from '../typed-id.js';
+import { isCanonicalId, isCanonicalIdOfType, typeOfId } from '../typed-id.js';
 export const mapping = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const text = (v) => typeof v === 'string' && v.trim().length > 0;
 export const isoDate = (v) => typeof v === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(v) && Number.isFinite(Date.parse(v)) && new Date(v).toISOString().slice(0, 10) === v;
@@ -68,8 +68,8 @@ export function validateStandalone(notation, input, options = {}) {
     };
     optionalText('description');
     if (notation === 'product') {
-        if (!['digital_product', 'service', 'platform', 'bundle'].includes(d.type))
-            fail('type', 'digital_product|service|platform|bundle', d.type);
+        if (!['physical_product', 'digital_product', 'service', 'platform', 'bundle'].includes(d.type))
+            fail('type', 'physical_product|digital_product|service|platform|bundle', d.type);
         optionalText('domain');
         reference('owner_role', ['ROLE']);
         if ('maturity' in d && !(Number.isInteger(d.maturity) && Number(d.maturity) >= 1 && Number(d.maturity) <= 5))
@@ -78,6 +78,67 @@ export function validateStandalone(notation, input, options = {}) {
         references('processes', ['PROCESS']);
         references('supporting_apps', ['APPLICATION']);
     }
+    else if (notation === 'process') {
+        reference('owner_role', ['ROLE']);
+        reference('capability', ['CAPABILITY']);
+        references('participants', ['ROLE', 'ACTOR']);
+        optionalText('goal');
+        optionalText('result');
+        for (const key of ['parent', 'bpmn_file', 'maturity'])
+            if (key in d)
+                fail(key, 'absent inline; use canonical relations, flow or history', d[key]);
+        if (Array.isArray(d.participants) && new Set(d.participants).size !== d.participants.length)
+            fail('participants', 'unique references', d.participants);
+        if ('flow' in d) {
+            if (!mapping(d.flow))
+                fail('flow', 'mapping', d.flow);
+            else {
+                const flow = d.flow;
+                const steps = Array.isArray(flow.steps) ? flow.steps : [];
+                const sequence = Array.isArray(flow.sequence) ? flow.sequence : [];
+                if (!Array.isArray(flow.steps) || !steps.length)
+                    fail('flow.steps', 'nonempty list', flow.steps);
+                if (!Array.isArray(flow.sequence))
+                    fail('flow.sequence', 'list', flow.sequence);
+                const ids = new Set();
+                const types = ['startEvent', 'endEvent', 'task', 'userTask', 'serviceTask', 'exclusiveGateway', 'parallelGateway'];
+                steps.forEach((step, i) => {
+                    const key = `flow.steps[${i}]`;
+                    if (!mapping(step)) {
+                        fail(key, 'mapping', step);
+                        return;
+                    }
+                    if (!isCanonicalId(step.id) || ids.has(step.id))
+                        fail(`${key}.id`, 'unique canonical step ID', step.id);
+                    else
+                        ids.add(step.id);
+                    if (!types.includes(step.type))
+                        fail(`${key}.type`, types.join('|'), step.type);
+                    if ((!['startEvent', 'endEvent'].includes(step.type) || 'name' in step) && !text(step.name))
+                        fail(`${key}.name`, 'nonempty string', step.name);
+                    ref(`${key}.performed_by`, step.performed_by, ['ROLE', 'ACTOR']);
+                    if (!Array.isArray(d.participants) || !d.participants.includes(step.performed_by))
+                        fail(`${key}.performed_by`, 'member of participants', step.performed_by);
+                    if ('supported_by_application' in step)
+                        ref(`${key}.supported_by_application`, step.supported_by_application, ['APPLICATION']);
+                });
+                sequence.forEach((edge, i) => {
+                    const key = `flow.sequence[${i}]`;
+                    if (!mapping(edge)) {
+                        fail(key, 'mapping', edge);
+                        return;
+                    }
+                    for (const end of ['from', 'to'])
+                        if (typeof edge[end] !== 'string' || !ids.has(edge[end]))
+                            fail(`${key}.${end}`, 'ID in flow.steps', edge[end]);
+                    if ('condition' in edge && !text(edge.condition))
+                        fail(`${key}.condition`, 'nonempty string', edge.condition);
+                    if ('default' in edge && typeof edge.default !== 'boolean')
+                        fail(`${key}.default`, 'boolean', edge.default);
+                });
+            }
+        }
+    }
     else if (notation === 'capability') {
         if (!['domain', 'supporting'].includes(d.type))
             fail('type', 'domain|supporting', d.type);

package/dist/webview/render-activities.d.ts

@@ -1,6 +1,7 @@
 import { computeCpm } from '../activities/cpm.js';
 import type { ActivityDoc, ActivitiesLayout, ActivitiesLayoutOptions } from '../activities/types.js';
 import { type NodeSizePreset } from '../node-size-presets.js';
+import { type ThemeId } from '../theme/index.js';
 /**
  * Network-view diagram CSS (critical path, milestones, edge colours) — the
  * canonical rules shared with the VS Code preview's `ACTIVITIES_DIAGRAM_CSS`
@@ -54,6 +55,11 @@ export interface RenderActivitiesOptions {
      * Action name in the view header.
      */
     suppressProjectNodes?: boolean;
+    /**
+     * Theme CSS embedded as `<style>` so the SVG is self-contained.
+     * Defaults to `'transitrix'`. VS Code live preview uses body emitters + webview CSS instead.
+     */
+    embedCssTheme?: ThemeId;
 }
 /**
  * Render the network (PSND) view of an already-validated ActivityDoc to a

package/dist/webview/render-activities.js

@@ -194,7 +194,7 @@ export function renderActivitiesNetworkBody(layout, cpm, ox, oy, curvature, entr
  * than short-circuiting.
  */
 export function renderActivitiesSvg(doc, options = {}) {
-    const { title = '', gaps = {}, nodeSizePreset = 'normal', curvature = DEFAULT_EDGE_CURVATURE, entryCurvature, suppressProjectNodes = true, } = options;
+    const { title = '', gaps = {}, nodeSizePreset = 'normal', curvature = DEFAULT_EDGE_CURVATURE, entryCurvature, suppressProjectNodes = true, embedCssTheme = 'transitrix', } = options;
     const nodeSize = resolveActionNodeSize(parseNodeSizePreset(nodeSizePreset));
     const layoutGaps = {
         ...gaps,
@@ -228,7 +228,7 @@ export function renderActivitiesSvg(doc, options = {}) {
     // drop the SVG into the DOM and styling resolves without any cooperation from
     // the host stylesheet. Matches what the VS Code path produces via
     // `prepareSvgForExport`.
-    const embedCss = generateSvgEmbedCss('transitrix') + ACTIVITIES_NETWORK_CSS;
+    const embedCss = generateSvgEmbedCss(embedCssTheme) + ACTIVITIES_NETWORK_CSS;
     return `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">
 <style>${embedCss}</style>
 ${ACTIVITIES_NETWORK_DEFS}

package/dist/webview/render-activity-card.d.ts

@@ -1,6 +1,12 @@
 import type { ActivityCardDoc, ActivityCardLayout } from '../activity-card/types.js';
+import { type ThemeId } from '../theme/index.js';
 export interface RenderActivityCardOptions {
     title?: string;
+    /**
+     * Theme CSS embedded as `<style>` so the SVG is self-contained.
+     * Defaults to `'transitrix'`. VS Code live preview uses body emitters + webview CSS instead.
+     */
+    embedCssTheme?: ThemeId;
 }
 /**
  * The single Activity Card SVG body emitter shared by every host. Takes an

package/dist/webview/render-activity-card.js

@@ -175,7 +175,7 @@ export function renderActivityCardSvg(doc, options = {}) {
     // `ARCHIMATE_CLASS` is referenced so the host-neutral module pins the same
     // §5.1 class convention the layout applies; keeps the import meaningful.
     void ARCHIMATE_CLASS;
-    const { title = '' } = options;
+    const { title = '', embedCssTheme = 'transitrix' } = options;
     const resolved = resolveSingleDoc(doc);
     const layout = layoutActivityCard(resolved);
     if (layout.bounds.width <= 0 || layout.bounds.height <= 0)
@@ -189,7 +189,7 @@ export function renderActivityCardSvg(doc, options = {}) {
     const titleSvg = title
         ? `<text class="text-header" x="${PAD}" y="${PAD + 14}">${escXml(`Activity Card — ${title}`)}</text>`
         : '';
-    const embedCss = generateSvgEmbedCss('transitrix');
+    const embedCss = generateSvgEmbedCss(embedCssTheme);
     return `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">
 <style>${embedCss}</style>
 <defs>

package/dist/webview/render-blocks.d.ts

@@ -5,6 +5,11 @@ export interface RenderBlocksOptions {
     title?: string;
     nodeSizePreset?: NodeSizePreset;
     layoutOptions?: BlocksLayoutOptions;
+    /**
+     * Theme CSS embedded via {@link renderBlocksLayoutSvg}.
+     * Defaults to `'transitrix'` for self-contained host-neutral SVG.
+     */
+    embedCssTheme?: ThemeId;
 }
 export interface RenderBlocksLayoutOptions {
     /** Extra vertical space reserved at the top of the canvas (e.g. for a title block). */
@@ -48,6 +53,11 @@ export declare function renderGridLayoutSvg(layout: GridLayout, options?: Render
 export interface RenderGridOptions {
     title?: string;
     layoutOptions?: GridLayoutOptions;
+    /**
+     * Theme CSS embedded via {@link renderGridLayoutSvg}.
+     * Defaults to `'transitrix'` for self-contained host-neutral SVG.
+     */
+    embedCssTheme?: ThemeId;
 }
 /** Host-neutral grid (matrix subset) renderer (IntelliJ/UI). */
 export declare function renderGridSvg(doc: GridFile, options?: RenderGridOptions): string;

package/dist/webview/render-blocks.js

@@ -90,7 +90,7 @@ ${parts.join('\n')}
  * with the shared theme CSS embedded so the output is self-contained.
  */
 export function renderBlocksSvg(doc, options = {}) {
-    const { title = '', nodeSizePreset = 'normal', layoutOptions } = options;
+    const { title = '', nodeSizePreset = 'normal', layoutOptions, embedCssTheme = 'transitrix' } = options;
     const leaf = resolveBlocksLeafSize(parseNodeSizePreset(nodeSizePreset));
     const layout = layoutNestedBlocks(doc, {
         leafWidth: leaf.width,
@@ -103,7 +103,7 @@ export function renderBlocksSvg(doc, options = {}) {
     const titleSvg = title
         ? `<text class="text-header" x="${PAD}" y="${PAD - 6}">${escXml(`Nested Blocks — ${title}`)}</text>`
         : '';
-    return renderBlocksLayoutSvg(layout, { title: titleSvg, embedCssTheme: 'transitrix' });
+    return renderBlocksLayoutSvg(layout, { title: titleSvg, embedCssTheme });
 }
 /**
  * Matrix subset (08-blocks.md §4a) — first cut: a single-layer rectangular
@@ -195,7 +195,7 @@ ${body}
 }
 /** Host-neutral grid (matrix subset) renderer (IntelliJ/UI). */
 export function renderGridSvg(doc, options = {}) {
-    const { title = '', layoutOptions } = options;
+    const { title = '', layoutOptions, embedCssTheme = 'transitrix' } = options;
     const layout = layoutGrid(doc, layoutOptions);
     if (layout.columns.length === 0 || layout.rows.length === 0) {
         return `<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0" viewBox="0 0 0 0"></svg>`;
@@ -203,5 +203,5 @@ export function renderGridSvg(doc, options = {}) {
     const titleSvg = title
         ? `<text class="text-header" x="${PAD}" y="${PAD - 6}">${escXml(`Nested Blocks — ${title}`)}</text>`
         : '';
-    return renderGridLayoutSvg(layout, { title: titleSvg, embedCssTheme: 'transitrix' });
+    return renderGridLayoutSvg(layout, { title: titleSvg, embedCssTheme });
 }

package/dist/webview/render-fgca.d.ts

@@ -2,6 +2,7 @@ import { layoutFGCAPreview } from '../fgca/preview-layout.js';
 import type { FGCADoc } from '../fgca/validate.js';
 import { type EdgeStyle } from '../edge-path.js';
 import { type NodeSizePreset } from '../node-size-presets.js';
+import { type ThemeId } from '../theme/index.js';
 type FgcaLayout = ReturnType<typeof layoutFGCAPreview>;
 export interface RenderFgcaBodyOptions {
     nodeWidth?: number;
@@ -35,6 +36,11 @@ export interface RenderFgcaOptions {
     scopeCaption?: boolean;
     /** Show completion percent badges on action nodes. */
     showCompletionPercent?: boolean;
+    /**
+     * Theme CSS embedded as `<style>` so the SVG is self-contained.
+     * Defaults to `'transitrix'`. VS Code live preview uses body emitters + webview CSS instead.
+     */
+    embedCssTheme?: ThemeId;
 }
 export declare function renderFgcaSvg(doc: FGCADoc, options?: RenderFgcaOptions): string;
 export {};

package/dist/webview/render-fgca.js

@@ -86,7 +86,7 @@ export function renderFgcaBody(columns, nodes, edges, curvature, entryCurvature,
     return `${headerSvg}\n${nodeSvg}\n${edgeSvg}`;
 }
 export function renderFgcaSvg(doc, options = {}) {
-    const { variant = 'dgca', title = '', curvature = DEFAULT_EDGE_CURVATURE, entryCurvature, edgeStyle, nodeSizePreset = 'normal', layoutOptions, scopeCaption = false, showCompletionPercent = true, } = options;
+    const { variant = 'dgca', title = '', curvature = DEFAULT_EDGE_CURVATURE, entryCurvature, edgeStyle, nodeSizePreset = 'normal', layoutOptions, scopeCaption = false, showCompletionPercent = true, embedCssTheme = 'transitrix', } = options;
     const hideChanges = variant === 'dga' || doc.hideChanges === true;
     const nodeSize = resolveDgcaNodeSize(parseNodeSizePreset(nodeSizePreset));
     const { nodes, edges, columns, width, height } = layoutFGCAPreview(doc, {
@@ -110,7 +110,7 @@ export function renderFgcaSvg(doc, options = {}) {
     const captionSvg = scopeCaption
         ? `<text class="text-caption" x="${PAD}" y="${height + 16}">${escXml('This diagram is shown for the selected goal scope. Actions on it may also serve goals outside that scope.')}</text>`
         : '';
-    const embedCss = generateSvgEmbedCss('transitrix');
+    const embedCss = generateSvgEmbedCss(embedCssTheme);
     // Calculate final height including caption if present
     const finalHeight = scopeCaption ? height + 24 : height;
     return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${finalHeight}" viewBox="0 0 ${width} ${finalHeight}">