@transitrix/diagrams 1.15.0 → 1.16.0

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

@@ -8,6 +8,11 @@ export interface RenderGoalsOptions {
     entryCurvature?: number;
     edgeStyle?: EdgeStyle;
     nodeSizePreset?: NodeSizePreset;
+    /**
+     * Theme CSS embedded via {@link renderGoalsLayoutSvg}.
+     * Defaults to `'transitrix'` for self-contained host-neutral SVG.
+     */
+    embedCssTheme?: ThemeId;
 }
 /**
  * Host-neutral goals renderer (IntelliJ/UI). Lays the tree out with the default

package/dist/webview/render-goals.js

@@ -27,7 +27,7 @@ const PAD = 24;
  * with the shared theme CSS embedded so the output is self-contained.
  */
 export function renderGoalsSvg(tree, options = {}) {
-    const { treeName = '', curvature = DEFAULT_EDGE_CURVATURE, entryCurvature, edgeStyle, nodeSizePreset = 'normal' } = options;
+    const { treeName = '', curvature = DEFAULT_EDGE_CURVATURE, entryCurvature, edgeStyle, nodeSizePreset = 'normal', embedCssTheme = 'transitrix', } = options;
     const nodeSize = resolveGoalsNodeSize(parseNodeSizePreset(nodeSizePreset));
     const layout = layoutGoalTree(tree, {
         nodeWidth: nodeSize.width,
@@ -42,7 +42,14 @@ export function renderGoalsSvg(tree, options = {}) {
         ? `<text class="text-header" x="${PAD}" y="${PAD - 6}">${escXml(`Goal tree — ${treeName}`)}</text>`
         : '';
     // Reserve a separate header row; the theme centers text on its y coordinate.
-    return renderGoalsLayoutSvg(layout, { curvature, entryCurvature, edgeStyle, title, topInset: title ? PAD : 0, embedCssTheme: 'transitrix' });
+    return renderGoalsLayoutSvg(layout, {
+        curvature,
+        entryCurvature,
+        edgeStyle,
+        title,
+        topInset: title ? PAD : 0,
+        embedCssTheme,
+    });
 }
 /**
  * The single goals SVG emitter shared by every host. Takes an already-computed

package/dist/webview/render-process-blueprint.d.ts

@@ -1,9 +1,15 @@
 import type { ProcessBlueprintFile, ProcessBlueprintLayout, ProcessBlueprintLayoutOptions } from '../process-blueprint/types.js';
 import { type NodeSizePreset } from '../node-size-presets.js';
+import { type ThemeId } from '../theme/index.js';
 export declare function renderProcessBlueprintBody(layout: ProcessBlueprintLayout, ox: number, oy: number, clipId?: string): string;
 export interface RenderProcessBlueprintOptions {
     title?: string;
     nodeSizePreset?: NodeSizePreset;
     layoutOptions?: ProcessBlueprintLayoutOptions;
+    /**
+     * 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 renderProcessBlueprintSvg(doc: ProcessBlueprintFile, options?: RenderProcessBlueprintOptions): string;

package/dist/webview/render-process-blueprint.js

@@ -127,7 +127,7 @@ export function renderProcessBlueprintBody(layout, ox, oy, clipId = 'bp-clip') {
     return parts.join('\n');
 }
 export function renderProcessBlueprintSvg(doc, options = {}) {
-    const { title = '', nodeSizePreset = 'normal', layoutOptions } = options;
+    const { title = '', nodeSizePreset = 'normal', layoutOptions, embedCssTheme = 'transitrix' } = options;
     const sizing = resolveProcessBlueprintSize(parseNodeSizePreset(nodeSizePreset));
     const layout = layoutProcessBlueprint(doc, {
         ...sizing,
@@ -145,7 +145,7 @@ export function renderProcessBlueprintSvg(doc, options = {}) {
     const titleSvg = title
         ? `<text class="text-header" x="${PAD}" y="${PAD - 6}">${escXml(title)}</text>`
         : '';
-    const embedCss = generateSvgEmbedCss('transitrix') + BP_EMBED_CSS;
+    const embedCss = generateSvgEmbedCss(embedCssTheme) + BP_EMBED_CSS;
     return `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">
 <style>${embedCss}</style>
 ${titleSvg}

package/dist/webview/render-products.js

@@ -1,5 +1,6 @@
 import { escHtml } from './render-util.js';
 const TYPE_LABEL = {
+    physical_product: 'Physical Product',
     digital_product: 'Digital Product',
     service: 'Service',
     platform: 'Platform',

package/dist/yaml-normalize.d.ts

@@ -15,6 +15,8 @@
  * A bare `2026-06-01` parses to midnight UTC and round-trips to
  * `"2026-06-01"` regardless of `process.env.TZ`.
  *
- * Walks in place and returns the same reference for convenience.
+ * Walks in place and returns the same reference for convenience. Shared
+ * object graphs from YAML aliases (and cycles) are visited once via WeakSet
+ * so diamond / recursive anchors cannot amplify the walk into a hang.
  */
 export declare function coerceDatesToIsoStrings<T>(value: T): T;

package/dist/yaml-normalize.js

@@ -15,9 +15,14 @@
  * A bare `2026-06-01` parses to midnight UTC and round-trips to
  * `"2026-06-01"` regardless of `process.env.TZ`.
  *
- * Walks in place and returns the same reference for convenience.
+ * Walks in place and returns the same reference for convenience. Shared
+ * object graphs from YAML aliases (and cycles) are visited once via WeakSet
+ * so diamond / recursive anchors cannot amplify the walk into a hang.
  */
 export function coerceDatesToIsoStrings(value) {
+    return walk(value, new WeakSet());
+}
+function walk(value, seen) {
     if (value === null || value === undefined)
         return value;
     if (value instanceof Date) {
@@ -25,6 +30,9 @@ export function coerceDatesToIsoStrings(value) {
     }
     if (typeof value !== 'object')
         return value;
+    if (seen.has(value))
+        return value;
+    seen.add(value);
     if (Array.isArray(value)) {
         for (let i = 0; i < value.length; i++) {
             const v = value[i];
@@ -32,7 +40,7 @@ export function coerceDatesToIsoStrings(value) {
                 value[i] = dateToIsoYmd(v);
             }
             else if (v !== null && typeof v === 'object') {
-                coerceDatesToIsoStrings(v);
+                walk(v, seen);
             }
         }
         return value;
@@ -44,7 +52,7 @@ export function coerceDatesToIsoStrings(value) {
             obj[key] = dateToIsoYmd(v);
         }
         else if (v !== null && typeof v === 'object') {
-            coerceDatesToIsoStrings(v);
+            walk(v, seen);
         }
     }
     return value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transitrix/diagrams",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "type": "module",
   "description": "Shared rendering, validation, and pure mutations for Transitrix custom diagram formats.",
   "license": "MIT",

package/src/compliance/catalogue.ts

@@ -0,0 +1,49 @@
+import { emptyCanon, ingestComplianceDoc } from './classify.js';
+
+/** 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 async function scanRequirementCatalogue(io: RequirementCatalogueIO) {
+  const canon = emptyCanon();
+  const transcript: unknown[] = [];
+  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: string, message: string) => {
+    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: string, top = false): Promise<void> => {
+    let entries: Awaited<ReturnType<RequirementCatalogueIO['list']>>;
+    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: string;
+      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/src/compliance/index.ts

@@ -76,6 +76,9 @@ export type {
   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/src/compliance/requirement-chain.ts

@@ -7,7 +7,8 @@ import { validateVerification } from '../verification/validate.js';
 
 export const CHAIN_STAGES = ['Source document', 'Driver', 'Need', 'Stakeholder requirement',
   'System requirement', 'Software requirement', 'Unclassified requirement', 'Verification definition', 'Result'] as const;
-export interface ChainScope { catalogue: string; product?: string; release?: string; project?: string }
+export interface ChainSubject { type: 'PRODUCT' | 'APPLICATION'; id: string }
+export interface ChainScope { catalogue: string; subject?: ChainSubject; product?: string; release?: string; project?: string }
 export interface ChainInput {
   index: ComplianceIndex; scope: ChainScope; asAt: string; snapshotId: string;
   sourceRevision?: string; complete: boolean;
@@ -23,7 +24,7 @@ export interface RequirementChainEdge {
 }
 export interface ChainAssignment { requirement: string; nearest: string; depth: number; relations: string[] }
 export interface RequirementChainProjection {
-  contract: 'requirement-chain/0.2'; contractRevision: string; asAt: string; snapshotId: string; sourceRevision?: string;
+  contract: 'requirement-chain/0.2' | 'requirement-chain/0.3'; contractRevision: string; asAt: string; snapshotId: string; sourceRevision?: string;
   scope: ChainScope; completeness: 'complete' | 'incomplete'; scopeFindings: string[];
   populations: { product: ChainSet; release: ChainSet; selected: ChainSet; inactive: ChainSet; unresolved: ChainSet };
   assignments: { here: ChainSet; otherReleaseOnly: ChainSet; unassigned: ChainSet; invalid: ChainSet; provenance: ChainAssignment[] };
@@ -53,9 +54,26 @@ function freeze<T>(value: T): T {
 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: ChainInput): RequirementChainProjection {
+  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: ChainInput & { scope: ChainScope & { subject: ChainSubject } }): RequirementChainProjection {
+  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: ChainInput): RequirementChainProjection {
   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: string[] = [];
   const records = new Map<string, ChainRecord>();
@@ -64,7 +82,7 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
     const id = `${owner}.${field}`;
     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;
     } else records.set(id, structuredClone(versions[0]));
@@ -114,7 +132,7 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
       if (r.raw.level !== undefined && level < 0) finding(r.id, 'level', 'REQ-LEVEL', 'Invalid level; displayed as unclassified');
     } else if (r.type === 'NEED') node(r, 2);
     else if (r.type === 'DRIVER') node(r, 1);
-    else if (['PRODUCT', 'RELEASE', 'ACTION'].includes(r.type)) node(r, -1);
+    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);
       if (r.raw.source_document !== undefined) {
@@ -162,6 +180,8 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
     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 === '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') :
@@ -198,38 +218,38 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
     }
   }
   const memberships = (id: string, kind: string) => 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))) productComplete = false;
+  if (unresolved.length) 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<string>();
   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')) { productComplete = false; selectedComplete = false; scopeFindings.push('Product unselected or unresolved'); }
-  if (!is(scope.release, 'RELEASE') || records.get(scope.release ?? '')?.raw.of !== scope.product) {
-    selectedComplete = false; scopeFindings.push('Release unselected, unresolved or wrong product');
+  if (!is(subject.id, subject.type)) { productComplete = false; selectedComplete = false; scopeFindings.push(scope.subject ? 'Subject unselected or unresolved' : 'Product unselected or unresolved'); }
+  if (!is(scope.release, 'RELEASE') || records.get(scope.release ?? '')?.raw.of !== subject.id) {
+    selectedComplete = false; scopeFindings.push(`Release unselected, unresolved or wrong ${subjectWord}`);
   }
-  if (scope.project && (!isProject(scope.project) || !memberships(scope.project, 'project_product').includes(scope.product ?? ''))) {
-    selectedComplete = false; scopeFindings.push('Invalid or unmodelled project/product pair');
+  if (scope.project && (!isProject(scope.project) || !memberships(scope.project, pairKind).includes(subject.id ?? ''))) {
+    selectedComplete = false; scopeFindings.push(`Invalid or unmodelled project/${subjectWord} pair`);
   }
   function query(release: string): { ids: string[]; provenance: ChainAssignment[]; complete: boolean } {
     const chain: string[] = []; let cursor: string | undefined = release; let valid = true;
     while (cursor) {
       const r: ChainRecord | undefined = 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');
+          chain.includes(cursor) ? 'Release predecessor cycle' : `Missing, invalid or cross-${subjectWord} predecessor`);
         break;
       }
       chain.push(cursor);
@@ -251,13 +271,13 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
   if (scope.project && L.some(id => memberships(id, 'project_scope').length === 0 || rels.some(r => r.raw.type === 'project_scope' && r.raw.from === id && active.get(r.id) && !usable.has(r.id)))) {
     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))) selectedComplete = false;
-  if (scope.project && L.some(id => memberships(id, 'project_scope').some(project => !memberships(project, 'project_product').includes(scope.product ?? '')))) {
-    selectedComplete = false; scopeFindings.push('Inconsistent project/product membership');
+  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, pairKind).includes(subject.id ?? '')))) {
+    selectedComplete = false; scopeFindings.push(`Inconsistent project/${subjectWord} membership`);
   }
   const S = L.filter(id => !scope.project || memberships(id, 'project_scope').includes(scope.project));
   const elsewhere = new Set<string>();
-  for (const release of records.values()) if (release.type === 'RELEASE' && release.raw.of === scope.product) {
+  for (const release of records.values()) if (release.type === 'RELEASE' && release.raw.of === subject.id) {
     const q = query(release.id); productComplete &&= q.complete; q.ids.forEach(id => elsewhere.add(id));
   }
   const unassigned = P.filter(id => !elsewhere.has(id) && !invalidAssignments.has(id));
@@ -307,7 +327,7 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
     const owners = new Set(ancestors);
     for (const v of verifications) 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);
     }
     for (const f of findings) if (owners.has(f.owner)) (affectedRequirements[f.id] ??= []).push(r.id);
@@ -326,15 +346,16 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
   const selectedRefs = refs.filter(f => affectedRequirements[f.id]?.some(id => S.includes(id)));
   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: RequirementChainProjection = {
-    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)) },
@@ -408,6 +429,7 @@ export function requirementReleaseCounts(p: RequirementChainProjection) {
   const contextUnits = { 0: 'source documents', 1: 'drivers', 2: 'needs', 7: 'definition parts', 8: 'result parts' } as const;
   for (const stage of [0, 1, 2, 7, 8] as const) 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);
 }
 
@@ -421,7 +443,10 @@ export class RequirementChainSnapshot {
     try {
       const input = await load();
       if (generation !== this.generation) return false;
-      this.current = buildRequirementChain(input); this.stale = false; return true;
+      this.current = input.scope.subject
+        ? buildSubjectRequirementChain({ ...input, scope: { ...input.scope, subject: input.scope.subject } })
+        : buildRequirementChain(input);
+      this.stale = false; return true;
     } catch {
       if (generation === this.generation) this.stale = true;
       return false;

package/src/products/types.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 {

package/src/products/validate.ts

@@ -4,7 +4,7 @@ import type { ValidationError, ValidationWarning, ValidationResult } from '../va
 
 export type { ValidationError, ValidationWarning, ValidationResult };
 
-const VALID_TYPES = new Set<ProductType>(['digital_product', 'service', 'platform', 'bundle']);
+const VALID_TYPES = new Set<ProductType>(['physical_product', 'digital_product', 'service', 'platform', 'bundle']);
 const VALID_STATUSES = new Set<ProductStatus>(['Draft', 'Active', 'Deprecated']);
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 

package/src/standalone/validate.ts

@@ -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, type CanonCatalog } from '../typed-id.js';
+import { isCanonicalId, isCanonicalIdOfType, typeOfId, type CanonCatalog } from '../typed-id.js';
 import type { ValidationResult } from '../validation-types.js';
 
 export const mapping = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v);
@@ -45,10 +45,46 @@ export function validateStandalone(notation: string, input: unknown, options: St
   };
   optionalText('description');
   if (notation === 'product') {
-    if (!['digital_product','service','platform','bundle'].includes(d.type as string)) fail('type', 'digital_product|service|platform|bundle', d.type);
+    if (!['physical_product', 'digital_product','service','platform','bundle'].includes(d.type as string)) 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)) fail('maturity', 'integer 1..5', d.maturity);
     references('capabilities', ['CAPABILITY']); 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<string>();
+        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 as string)) fail(`${key}.type`, types.join('|'), step.type);
+          if ((!['startEvent','endEvent'].includes(step.type as string) || '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] as string)) 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 as string)) fail('type', 'domain|supporting', d.type);
     for (const key of ['current_maturity','target_maturity','owner_role','target_date']) if (key in d) fail(key, 'attribute in history sidecar, absent inline', d[key], 'VERSIONED-004');

package/src/webview/render-activities.ts

@@ -26,7 +26,7 @@ import type {
 } from '../activities/types.js';
 import { horizontalCubicEdgePath, bowedCubicEdgePath, DEFAULT_EDGE_CURVATURE } from '../edge-path.js';
 import { parseNodeSizePreset, resolveActionNodeSize, type NodeSizePreset } from '../node-size-presets.js';
-import { generateSvgEmbedCss } from '../theme/index.js';
+import { generateSvgEmbedCss, type ThemeId } from '../theme/index.js';
 import { emitCenteredTextSvg, layoutCenteredEntityText } from './entity-text-layout.js';
 import { escXml } from './render-util.js';
 
@@ -235,6 +235,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;
 }
 
 /**
@@ -259,6 +264,7 @@ export function renderActivitiesSvg(doc: ActivityDoc, options: RenderActivitiesO
     curvature = DEFAULT_EDGE_CURVATURE,
     entryCurvature,
     suppressProjectNodes = true,
+    embedCssTheme = 'transitrix',
   } = options;
   const nodeSize = resolveActionNodeSize(parseNodeSizePreset(nodeSizePreset));
   const layoutGaps: ActivitiesLayoutOptions = {
@@ -300,7 +306,7 @@ export function renderActivitiesSvg(doc: ActivityDoc, options: RenderActivitiesO
   // 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>

package/src/webview/render-activity-card.ts

@@ -31,7 +31,7 @@ import type {
   ResolvedActivityCard,
   ResolvedMilestone,
 } from '../activity-card/types.js';
-import { generateSvgEmbedCss } from '../theme/index.js';
+import { generateSvgEmbedCss, type ThemeId } from '../theme/index.js';
 import { escXml } from './render-util.js';
 
 const PAD = 24;
@@ -39,6 +39,11 @@ const EMPTY_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0"
 
 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;
 }
 
 function truncate(text: string, maxChars: number): string {
@@ -241,7 +246,7 @@ export function renderActivityCardSvg(
   // §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);
 
@@ -259,7 +264,7 @@ export function renderActivityCardSvg(
     ? `<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>

package/src/webview/render-blocks.ts

@@ -41,6 +41,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;
 }
 
 /**
@@ -133,7 +138,7 @@ ${parts.join('\n')}
  * with the shared theme CSS embedded so the output is self-contained.
  */
 export function renderBlocksSvg(doc: BlocksFile, options: RenderBlocksOptions = {}): string {
-  const { title = '', nodeSizePreset = 'normal', layoutOptions } = options;
+  const { title = '', nodeSizePreset = 'normal', layoutOptions, embedCssTheme = 'transitrix' } = options;
   const leaf = resolveBlocksLeafSize(parseNodeSizePreset(nodeSizePreset));
 
   const layout: BlocksLayout = layoutNestedBlocks(doc, {
@@ -150,7 +155,7 @@ export function renderBlocksSvg(doc: BlocksFile, options: RenderBlocksOptions =
     ? `<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 });
 }
 
 /**
@@ -285,11 +290,16 @@ ${body}
 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 function renderGridSvg(doc: GridFile, options: RenderGridOptions = {}): string {
-  const { title = '', layoutOptions } = options;
+  const { title = '', layoutOptions, embedCssTheme = 'transitrix' } = options;
   const layout = layoutGrid(doc, layoutOptions);
 
   if (layout.columns.length === 0 || layout.rows.length === 0) {
@@ -300,5 +310,5 @@ export function renderGridSvg(doc: GridFile, options: RenderGridOptions = {}): s
     ? `<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 });
 }