@sigloch/contracts 0.7.0 → 1.0.0

package/dist/se/ontology.js

@@ -72,36 +72,24 @@ export const TestRefSchema = z.object({
     level: z.string().optional(),
 });
 /**
- * Code binding for a FUNC element (CR-GC-205 Item 5, ontology bump 3.6.0).
- * Resolves a FUNC node to the concrete code symbol that realizes it, enabling
- * graph<->code conformance: every non-concept/non-external FUNC must resolve to a
- * real symbol in its allocated MOD's file, and (via the consumer's LSP-backed
- * check) every cross-module-called symbol must itself be a FUNC node.
- *   - `file`   : implementation file path, e.g. `src/harness.ts` (the symbol's home).
- *   - `symbol` : the exported symbol (function/method/class) name realizing the FUNC.
- *   - `lang`   : optional language id (default `ts`) — selects the LSP/engine the
- *               conformance check drives, so the binding is language-agnostic.
- * Stored under `OntologyElement.attributes.codeRef` (additive, opt-in validation).
+ * Realization binding for an element (CR-228, ontology bump 3.9.0) — unifies the
+ * byte-identical former `codeRef` (FUNC → code symbol) and `schemaRef` (SCHEMA →
+ * Zod export), and extends to MOD (physical part → CAD/geometry artefact). The
+ * *type* of the pointing element disambiguates what kind of realization it is:
+ * FUNC→code, SCHEMA→Zod-def, physical MOD→CAD. TEST keeps its own `testRef`
+ * (a TEST is not just located but *executed* — the runner is the extra value).
+ *   - `file`   : realization file path, e.g. `src/harness.ts`, `part.step`.
+ *   - `symbol` : the realizing symbol (function/class/Zod export). Optional — a
+ *               geometry artefact (CAD) has no symbol; file-exists is the binding.
+ *   - `lang`   : optional language/format id (default `ts`) — selects the
+ *               conformance engine, so the binding is language-agnostic.
+ * Stored under `OntologyElement.attributes.realRef` (additive, opt-in validation).
+ * The free-text SCHEMA `contract` attribute stays a human description, not the
+ * conformance basis: RC-01/RC-03 resolve this binding, RC-04 checks it is parsed.
  */
-export const CodeRefSchema = z.object({
+export const RealRefSchema = z.object({
     file: RepoRelativePathSchema,
-    symbol: z.string(),
-    lang: z.string().optional(),
-});
-/**
- * Binding of a SCHEMA node to the Zod schema that defines it (CR-211), analogous
- * to CodeRefSchema for FUNC:
- *   - `file`   : the source file declaring the Zod schema, e.g. `src/se/ontology.ts`.
- *   - `symbol` : the exported schema symbol, e.g. `CodeRefSchema`.
- *   - `lang`   : optional language id (default `ts`).
- * Stored under `OntologyElement.attributes.schemaRef`. The free-text `contract`
- * attribute stays as a human description but is no longer the conformance basis:
- * RC-03 resolves this binding to a declared export, RC-04 checks it is parsed at
- * the modelled interface.
- */
-export const SchemaRefSchema = z.object({
-    file: RepoRelativePathSchema,
-    symbol: z.string(),
+    symbol: z.string().optional(),
     lang: z.string().optional(),
 });
 /**
@@ -188,8 +176,8 @@ export const ELEMENT_ATTRIBUTES = {
         { key: 'timingBudgetMs', type: 'number', description: 'NFR timing budget in ms' },
         { key: 'measuredMs', type: 'number', description: 'Measured execution time in ms' },
         { key: 'sourceFile', type: 'string', description: 'Implementation source file' },
-        { key: 'codeRef', type: 'object', description: 'Code binding {file, symbol, lang?} — the symbol that realizes this FUNC; see CodeRefSchema (CR-GC-205)' },
-        { key: 'external', type: 'boolean', description: 'Externally-realized FUNC (e.g. a renderer in another package): exempt from the R-20 codeRef-binding requirement (CR-GC-205)' },
+        { key: 'realRef', type: 'object', description: 'Realization binding {file, symbol?, lang?} — the code symbol that realizes this FUNC; see RealRefSchema (CR-228, was codeRef)' },
+        { key: 'external', type: 'boolean', description: 'Externally-realized FUNC (e.g. a renderer in another package): exempt from the R-20 realRef-binding requirement (CR-GC-205)' },
         { key: 'concept', type: 'boolean', description: 'Concept-only FUNC: specified, no implementation yet; exempt from R-20 (CR-GC-205)' },
     ],
     UC: [
@@ -206,11 +194,15 @@ export const ELEMENT_ATTRIBUTES = {
     ],
     MOD: [
         { key: 'path', type: 'string', description: 'Source file or glob the module owns, e.g. src/harness.ts — anchors the MOD<->file mapping for graph<->code conformance (CR-GC-205)' },
+        { key: 'kind', type: 'string', description: "Module kind, e.g. 'physical' for a machine part (Bauteil) — physical MODs are realized by a CAD/geometry realRef (R-27), logical MODs by their FUNCs' code (CR-191/228)" },
+        { key: 'realRef', type: 'object', description: 'Realization binding {file, symbol?, lang?} — CAD/geometry artefact realizing a physical MOD; see RealRefSchema (CR-228, symbol optional)' },
+        { key: 'external', type: 'boolean', description: 'Externally-realized MOD: exempt from the R-27 realRef-presence requirement (CR-228)' },
+        { key: 'concept', type: 'boolean', description: 'Concept-only MOD: modelled, no realization yet; exempt from R-27 (CR-228)' },
     ],
     SCHEMA: [
         { key: 'contract', type: 'string', description: 'Free-text contract description, e.g. "@sigloch/contracts LiveUpdateEventSchema" — human hint only, not the conformance basis (CR-211)' },
-        { key: 'schemaRef', type: 'object', description: 'Schema binding {file, symbol, lang?} — the Zod export defining this SCHEMA; see SchemaRefSchema (CR-211)' },
-        { key: 'external', type: 'boolean', description: 'Externally-defined SCHEMA (e.g. a foreign-API contract): exempt from the schemaRef-presence requirement (CR-211)' },
-        { key: 'concept', type: 'boolean', description: 'Concept-only SCHEMA: modelled, no Zod export yet; exempt from the schemaRef-presence requirement (CR-211)' },
+        { key: 'realRef', type: 'object', description: 'Realization binding {file, symbol?, lang?} — the Zod export defining this SCHEMA; see RealRefSchema (CR-228, was schemaRef)' },
+        { key: 'external', type: 'boolean', description: 'Externally-defined SCHEMA (e.g. a foreign-API contract): exempt from the realRef-presence requirement (CR-211)' },
+        { key: 'concept', type: 'boolean', description: 'Concept-only SCHEMA: modelled, no Zod export yet; exempt from the realRef-presence requirement (CR-211)' },
     ],
 };

package/dist/se/readiness.js

@@ -9,7 +9,7 @@ export const ReadinessDimension = z.enum([
     'arch', // Functional architecture (R-02, R-03, R-10, R-12)
     'alloc', // Module allocation (R-04)
     'ver', // Test coverage (R-01, R-05)
-    'schema', // Interface completeness (SC-01..03)
+    'schema', // Interface completeness (R-26 binding, SC-02 usage)
     'cr', // CR traceability (CR-R01..R03)
     'ms', // Milestone planning (MS-01..02)
 ]);
@@ -37,9 +37,11 @@ export const RULE_TO_DIMENSION = {
     'BQ-01': 'req', 'BQ-02': 'req', 'BQ-04': 'req',
     'BQ-06': 'req', 'BQ-07': 'req',
     'RD-01': 'req', 'RD-02': 'req', 'RD-03': 'req',
+    // RD-04 is decomposition *breadth* — an architecture concern, not a requirement one
+    'RD-04': 'arch',
     // trace/realization/allocation completeness rules (CR-228 D: previously unmapped → advisory fall-through)
     'R-18': 'arch', 'R-19': 'ver', 'R-20': 'arch', 'R-21': 'ver',
-    'R-22': 'alloc', 'R-23': 'alloc', 'R-26': 'schema',
+    'R-22': 'alloc', 'R-23': 'alloc', 'R-26': 'schema', 'R-27': 'arch',
     // uc
     'UC-01': 'uc', 'UC-02': 'uc', 'UC-03': 'uc', 'UC-04': 'uc',
     'UC-05': 'uc', 'UC-06': 'uc',
@@ -52,7 +54,7 @@ export const RULE_TO_DIMENSION = {
     // ver
     'R-01': 'ver', 'R-05': 'ver',
     // schema
-    'SC-01': 'schema', 'SC-02': 'schema', 'SC-03': 'schema',
+    'SC-02': 'schema', // SC-01/SC-03 deleted (BOK-CR-026) — R-26 is the binding rule
     // structural rules without primary dimension → assigned by closest concern
     'R-08': 'arch',
     // near-duplicate detection

package/dist/se/rules.js

@@ -4,7 +4,7 @@
  * @sigloch/contracts/se — single source of truth for SE validation rules.
  */
 import { z } from 'zod/v4';
-import { ElementType, TraceType, TestRefSchema, CodeRefSchema, SchemaRefSchema } from './ontology.js';
+import { ElementType, TraceType, TestRefSchema, RealRefSchema } from './ontology.js';
 import { isValidTrace } from './meta-model.js';
 export const RuleSeverity = z.enum(['error', 'warning', 'info']);
 /** Candidate target for resolving a violation (e.g. a REQ to satisfy, a TEST to link). */
@@ -411,6 +411,58 @@ function noPrematureDecomposition(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
+// RD-04: Decomposition breadth (CR-SM-221)
+// ---------------------------------------------------------------------------
+/**
+ * Max children on one decomposition level. The 7–11 convention existed only as
+ * prose ("darüber func-of-func"); below 7 is a guideline, not a violation, so only
+ * the upper bound is a rule.
+ *
+ * Counted per (parent, kind) — a MOD that both holds 12 FUNCs and composes 12
+ * sub-MODs has two breadth problems, not one. (The spike reference merged both into
+ * a single counter on the MOD id and would have reported 24 under one kind.)
+ */
+const DECOMPOSITION_BREADTH_MAX = 11;
+function decompositionBreadth(graph) {
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const byId = new Map(graph.elements.map(e => [e.id, e]));
+    const counts = new Map();
+    const bump = (parentId, kind) => {
+        const key = `${parentId}${kind}`;
+        const entry = counts.get(key);
+        if (entry)
+            entry.n++;
+        else
+            counts.set(key, { parentId, kind, n: 1 });
+    };
+    for (const t of graph.traces) {
+        const src = typeOf.get(t.source);
+        const tgt = typeOf.get(t.target);
+        if (t.type === 'compose' && src === 'FUNC' && tgt === 'FUNC') {
+            bump(t.source, 'sub-FUNC');
+        }
+        else if (t.type === 'allocate' && tgt === 'MOD' && src === 'FUNC') {
+            bump(t.target, 'allocated FUNC');
+        }
+        else if (t.type === 'compose' && (src === 'SYS' || src === 'MOD') && tgt === 'MOD') {
+            bump(t.source, 'sub-MOD');
+        }
+    }
+    return [...counts.values()]
+        .filter(c => c.n > DECOMPOSITION_BREADTH_MAX)
+        .map(c => {
+        const parent = byId.get(c.parentId);
+        return {
+            rule_id: 'RD-04',
+            severity: 'warning',
+            element_id: c.parentId,
+            message: `${c.parentId} has ${c.n} ${c.kind} children on one level (>${DECOMPOSITION_BREADTH_MAX})`,
+            fix_hint: 'Introduce an intermediate level (func-of-func / sub-MOD)',
+            context: { element_type: parent?.type, element_name: parent?.name },
+        };
+    });
+}
+// ---------------------------------------------------------------------------
 // R-14: UC must have at least 1 compose trace (→ FCHAIN or REQ) (CR-117)
 // ---------------------------------------------------------------------------
 function ucMustHaveCompose(graph) {
@@ -581,10 +633,10 @@ function testMustHaveRunnableBinding(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
-// R-20: FUNC code binding (CR-GC-205 Item 5, extended by CR-210) — a FUNC that
-// is not explicitly concept-only (attributes.concept === true) or externally
-// realized (attributes.external === true) counts as BOUND when it EITHER carries
-// a valid codeRef {file, symbol} OR is a blackbox parent whose compose→FUNC
+// R-20: FUNC realRef binding (CR-GC-205 Item 5, extended by CR-210, unified CR-228)
+// — a FUNC that is not explicitly concept-only (attributes.concept === true) or
+// externally realized (attributes.external === true) counts as BOUND when it EITHER
+// carries a valid realRef {file, symbol?} OR is a blackbox parent whose compose→FUNC
 // children are ALL (recursively) bound — the parent is realized by its children
 // (e.g. FUNC-gesture-capture, gve CR-GVE-150). A partially-bound parent fires
 // R-20 naming the still-unbound leaves in the fix_hint, so drift on a child is
@@ -598,7 +650,7 @@ function funcMustHaveCodeBinding(graph) {
     const composeFuncChildren = (id) => graph.traces
         .filter(t => t.source === id && t.type === 'compose' && funcById.has(t.target))
         .map(t => t.target);
-    const hasCodeRef = (el) => CodeRefSchema.safeParse(el.attributes?.codeRef).success;
+    const hasCodeRef = (el) => RealRefSchema.safeParse(el.attributes?.realRef).success;
     const isExempt = (el) => el.attributes?.concept === true || el.attributes?.external === true;
     // A FUNC is bound iff it is exempt, has a codeRef, or is a parent whose
     // compose→FUNC children are all bound (recursive, cycle-safe).
@@ -662,8 +714,8 @@ function funcMustHaveCodeBinding(graph) {
                 rule_id: 'R-20',
                 severity: 'warning',
                 element_id: fn.id,
-                message: `${fn.id} is a FUNC without a valid codeRef binding`,
-                fix_hint: 'Add attributes.codeRef {file, symbol, lang?}, or set attributes.concept:true (spec-only) / attributes.external:true (realized in another package)',
+                message: `${fn.id} is a FUNC without a valid realRef binding`,
+                fix_hint: 'Add attributes.realRef {file, symbol, lang?}, or set attributes.concept:true (spec-only) / attributes.external:true (realized in another package)',
                 context: { element_type: fn.type, element_name: fn.name },
             });
         }
@@ -800,28 +852,52 @@ function modMustHaveAllocatedFunc(graph) {
 // MOD→satisfy→REQ, behavioral NFRs FCHAIN→satisfy→REQ. R-18 now flags any residual
 // REQ→MOD allocate edge as an invalid trace pattern.
 // ---------------------------------------------------------------------------
-// R-26: SCHEMA schemaRef presence (CR-211) — a SCHEMA that is not explicitly
-// concept-only or external should carry a valid schemaRef {file, symbol} so its
-// Zod definition is machine-resolvable (RC-03 then checks it resolves, RC-04 that
-// it is parsed at the interface). WARNING, not error: the 9 currently-unbound
-// SCHEMAs on the reference model must not turn readiness red before any binding
-// exists — the presence signal mirrors R-20 (codeRef) / R-19 (testRef). Symbol
-// RESOLUTION is out of scope here (pure, no I/O — that is RC-03's job).
+// R-26: SCHEMA realRef presence (CR-211, unified CR-228) — a SCHEMA that is not
+// explicitly concept-only or external should carry a valid realRef {file, symbol?}
+// so its Zod definition is machine-resolvable (RC-03 then checks it resolves, RC-04
+// that it is parsed at the interface). WARNING, not error: currently-unbound SCHEMAs
+// on the reference model must not turn readiness red before any binding exists — the
+// presence signal mirrors R-20 (FUNC realRef) / R-19 (testRef). Symbol RESOLUTION is
+// out of scope here (pure, no I/O — that is RC-03's job).
 // ---------------------------------------------------------------------------
 function schemaMustHaveSchemaRef(graph) {
     return graph.elements
         .filter(e => e.type === 'SCHEMA')
         .filter(e => e.attributes?.concept !== true && e.attributes?.external !== true)
-        .filter(e => !SchemaRefSchema.safeParse(e.attributes?.schemaRef).success)
+        .filter(e => !RealRefSchema.safeParse(e.attributes?.realRef).success)
         .map(sc => ({
         rule_id: 'R-26',
         severity: 'warning',
         element_id: sc.id,
-        message: `${sc.id} is a SCHEMA without a valid schemaRef binding`,
-        fix_hint: 'Add attributes.schemaRef {file, symbol, lang?}, or set attributes.concept:true (spec-only) / attributes.external:true (foreign-API contract)',
+        message: `${sc.id} is a SCHEMA without a valid realRef binding`,
+        fix_hint: 'Add attributes.realRef {file, symbol, lang?}, or set attributes.concept:true (spec-only) / attributes.external:true (foreign-API contract)',
         context: { element_type: sc.type, element_name: sc.name },
     }));
 }
+// ---------------------------------------------------------------------------
+// R-27: physical MOD realRef presence (CR-228) — the MOD arm of the unified
+// "element must have a realRef" rule (FUNC=R-20, SCHEMA=R-26, physical MOD=R-27).
+// A physical MOD (kind='physical') is a Bauteil realized by a CAD/geometry
+// artefact, not by code (RT-01: FUNCs never allocate directly to it). Logical/SW
+// MODs are realized through their FUNCs' code (R-20) and are NOT in scope here.
+// WARNING (presence signal like R-20/R-26); concept/external MODs are exempt.
+// Symbol is optional on a realRef (a geometry file has none) — presence = a valid
+// realRef with a file. RESOLUTION (file on disk) is a consumer/RC concern.
+// ---------------------------------------------------------------------------
+function physicalModMustHaveRealRef(graph) {
+    return graph.elements
+        .filter(e => e.type === 'MOD' && e.attributes?.kind === 'physical')
+        .filter(e => e.attributes?.concept !== true && e.attributes?.external !== true)
+        .filter(e => !RealRefSchema.safeParse(e.attributes?.realRef).success)
+        .map(mod => ({
+        rule_id: 'R-27',
+        severity: 'warning',
+        element_id: mod.id,
+        message: `${mod.id} is a physical MOD without a valid realRef (CAD/geometry) binding`,
+        fix_hint: 'Add attributes.realRef {file, symbol?, lang?} pointing at the CAD/geometry artefact, or set attributes.concept:true / attributes.external:true',
+        context: { element_type: mod.type, element_name: mod.name },
+    }));
+}
 export const V3_RULES = [
     { id: 'R-01', name: 'REQ must have verification', severity: 'error', evaluate: reqMustHaveVerification },
     { id: 'R-02', name: 'FUNC must satisfy REQ', severity: 'warning', evaluate: funcMustSatisfyReq },
@@ -837,14 +913,16 @@ export const V3_RULES = [
     { id: 'R-12', name: 'No circular dependencies', severity: 'warning', evaluate: noDirectCircular },
     { id: 'R-18', name: 'Valid trace pattern', severity: 'error', evaluate: validTracePattern },
     { id: 'R-19', name: 'Runnable TEST binding', severity: 'warning', evaluate: testMustHaveRunnableBinding },
-    { id: 'R-20', name: 'FUNC code binding', severity: 'warning', evaluate: funcMustHaveCodeBinding },
+    { id: 'R-20', name: 'FUNC realRef binding', severity: 'warning', evaluate: funcMustHaveCodeBinding },
     { id: 'R-21', name: 'FUNC↔FUNC connection needs integration test', severity: 'warning', evaluate: fchainMustHaveIntegrationTest },
     { id: 'R-22', name: 'FUNC must be allocated to MOD', severity: 'warning', evaluate: funcMustBeAllocated },
     { id: 'R-23', name: 'MOD must have allocated FUNC', severity: 'warning', evaluate: modMustHaveAllocatedFunc },
-    { id: 'R-26', name: 'SCHEMA must have schemaRef', severity: 'warning', evaluate: schemaMustHaveSchemaRef },
+    { id: 'R-26', name: 'SCHEMA must have realRef', severity: 'warning', evaluate: schemaMustHaveSchemaRef },
+    { id: 'R-27', name: 'Physical MOD must have realRef', severity: 'warning', evaluate: physicalModMustHaveRealRef },
     { id: 'RD-01', name: 'Unresolved requirement', severity: 'warning', evaluate: unresolvedRequirement },
     { id: 'RD-02', name: 'Decomposition consistency', severity: 'warning', evaluate: decompositionConsistency },
     { id: 'RD-03', name: 'No premature decomposition', severity: 'info', evaluate: noPrematureDecomposition },
+    { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth },
     { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', evaluate: msEmptyScope },
     { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'error', evaluate: msDanglingDependency },
 ];

package/dist/se/schema-quality-rules.d.ts

@@ -1,11 +1,19 @@
 /**
- * SC-01..SC-03 — Schema Quality rules (CR-122).
- * Complement V3 structural rules with content checks on SCHEMA elements.
+ * SC-02 — Schema Quality rule (CR-122, reduced by BOK-CR-026).
+ *
+ * SC-01 (`zodDefinition` present) and SC-03 (`sourceFile`/`sourceExport` present) were
+ * DELETED: both re-asked R-26's question ("is this SCHEMA bound to code?") on legacy
+ * attributes and fired on exactly the same elements (Jaccard 1.0 vs R-26). SC-03 had
+ * additionally become wrong — a SCHEMA correctly bound via `realRef` still fired it.
+ * `realRef` is the single SCHEMA binding truth (R-26 presence, RC-03/RC-04 resolution);
+ * a spec-only SCHEMA is `concept:true`, it does NOT carry a Zod body copy in the graph
+ * (same rule as TEST: bindings point at code, they never mirror it).
+ *
+ * What remains here is the one SCHEMA check that is NOT about binding: is the interface
+ * used by any FLOW.
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
-export declare function sc01HasDefinition(graph: OntologyGraph): RuleViolation[];
 export declare function sc02IsReferenced(graph: OntologyGraph): RuleViolation[];
-export declare function sc03IsImplemented(graph: OntologyGraph): RuleViolation[];
 export declare const SC_RULES: RuleDefinition[];
 export declare function evaluateSCRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/schema-quality-rules.js

@@ -1,26 +1,4 @@
 // ---------------------------------------------------------------------------
-// SC-01: SCHEMA must have zodDefinition attribute
-// ---------------------------------------------------------------------------
-export function sc01HasDefinition(graph) {
-    return graph.elements
-        .filter(e => e.type === 'SCHEMA')
-        .filter(s => {
-        const def = s.attributes?.zodDefinition;
-        return !def || (typeof def === 'string' && def.trim().length === 0);
-    })
-        .map(s => ({
-        rule_id: 'SC-01',
-        severity: 'warning',
-        element_id: s.id,
-        message: `${s.id} has no zodDefinition attribute`,
-        fix_hint: 'Add zodDefinition attribute with Zod schema string',
-        context: {
-            element_type: s.type,
-            element_name: s.name,
-        },
-    }));
-}
-// ---------------------------------------------------------------------------
 // SC-02: SCHEMA must be referenced by at least one FLOW via relation trace
 // ---------------------------------------------------------------------------
 export function sc02IsReferenced(graph) {
@@ -42,31 +20,10 @@ export function sc02IsReferenced(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
-// SC-03: SCHEMA should have sourceFile (implementation marker)
-// ---------------------------------------------------------------------------
-export function sc03IsImplemented(graph) {
-    return graph.elements
-        .filter(e => e.type === 'SCHEMA')
-        .filter(s => !s.attributes?.sourceFile && !s.attributes?.sourceExport)
-        .map(s => ({
-        rule_id: 'SC-03',
-        severity: 'info',
-        element_id: s.id,
-        message: `${s.id} has no sourceFile/sourceExport (not implemented yet)`,
-        fix_hint: 'Implement the Zod schema in code and set sourceFile/sourceExport',
-        context: {
-            element_type: s.type,
-            element_name: s.name,
-        },
-    }));
-}
-// ---------------------------------------------------------------------------
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
 export const SC_RULES = [
-    { id: 'SC-01', name: 'Schema has definition', severity: 'warning', evaluate: sc01HasDefinition },
     { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', evaluate: sc02IsReferenced },
-    { id: 'SC-03', name: 'Schema is implemented', severity: 'info', evaluate: sc03IsImplemented },
 ];
 export function evaluateSCRules(graph) {
     return SC_RULES.flatMap(rule => rule.evaluate(graph));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/contracts",
-  "version": "0.7.0",
+  "version": "1.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/se/semantic-id.d.ts

@@ -1,30 +0,0 @@
-/**
- * SemanticId — Format-E canonical element ID schema.
- * Aligned with graphengine CR-052/CR-053.
- *
- * Format: {Name}.{TypeAbbr}.{Counter}
- * Example: ObserveSessions.UC.001
- *
- * @sigloch/contracts/se
- */
-import { z } from 'zod/v4';
-import type { ElementType } from './ontology.js';
-/** 2-char abbreviation → full ElementType. */
-export declare const ABBREV_TO_TYPE: Record<string, ElementType>;
-/** Full ElementType → 2-char abbreviation. */
-export declare const TYPE_TO_ABBREV: Record<string, string>;
-/** SemanticId: `Name.TypeAbbr.Counter` where Counter is 3-digit or 6-char alphanumeric. */
-export declare const SemanticId: z.ZodString;
-export type SemanticId = z.infer<typeof SemanticId>;
-/** Check if a string is a valid SemanticId. */
-export declare function isSemanticId(s: string): boolean;
-/** Extract name, type, and counter from a SemanticId. */
-export declare function extractFromSemanticId(semanticId: string): {
-    name: string;
-    type: ElementType;
-    counter: string;
-};
-/** Build a SemanticId from parts. */
-export declare function toSemanticId(name: string, type: ElementType, counter: string): string;
-/** Get the 2-char abbreviation for an ElementType. */
-export declare function getTypeAbbreviation(type: ElementType): string;

package/dist/se/semantic-id.js

@@ -1,90 +0,0 @@
-/**
- * SemanticId — Format-E canonical element ID schema.
- * Aligned with graphengine CR-052/CR-053.
- *
- * Format: {Name}.{TypeAbbr}.{Counter}
- * Example: ObserveSessions.UC.001
- *
- * @sigloch/contracts/se
- */
-import { z } from 'zod/v4';
-// ---------------------------------------------------------------------------
-// Type abbreviation maps (aligned with graphengine semantic-id.ts)
-// ---------------------------------------------------------------------------
-/** 2-char abbreviation → full ElementType. */
-export const ABBREV_TO_TYPE = {
-    SY: 'SYS',
-    UC: 'UC',
-    RQ: 'REQ',
-    FN: 'FUNC',
-    FC: 'FCHAIN',
-    FL: 'FLOW',
-    AC: 'ACTOR',
-    MD: 'MOD',
-    TC: 'TEST',
-    TS: 'TEST', // legacy alias
-    SC: 'SCHEMA',
-    CR: 'CR',
-    MS: 'MS',
-};
-/** Full ElementType → 2-char abbreviation. */
-export const TYPE_TO_ABBREV = {
-    SYS: 'SY',
-    UC: 'UC',
-    REQ: 'RQ',
-    FUNC: 'FN',
-    FCHAIN: 'FC',
-    FLOW: 'FL',
-    ACTOR: 'AC',
-    MOD: 'MD',
-    TEST: 'TC',
-    SCHEMA: 'SC',
-    SESSION: 'SE',
-    CR: 'CR',
-    MS: 'MS',
-};
-// ---------------------------------------------------------------------------
-// Zod schema
-// ---------------------------------------------------------------------------
-/** SemanticId: `Name.TypeAbbr.Counter` where Counter is 3-digit or 6-char alphanumeric. */
-export const SemanticId = z.string().regex(/^[A-Za-z][A-Za-z0-9_+]{0,49}\.[A-Z]{2}\.[a-z0-9]{3,6}$/, 'SemanticId must match {Name}.{TypeAbbr}.{Counter}');
-// ---------------------------------------------------------------------------
-// Pure functions
-// ---------------------------------------------------------------------------
-/** Check if a string is a valid SemanticId. */
-export function isSemanticId(s) {
-    return SemanticId.safeParse(s).success;
-}
-/** Extract name, type, and counter from a SemanticId. */
-export function extractFromSemanticId(semanticId) {
-    const parts = semanticId.split('.');
-    if (parts.length < 3) {
-        throw new Error(`Invalid semanticId: "${semanticId}" — expected Name.TypeAbbr.Counter`);
-    }
-    const name = parts[0];
-    const typeAbbr = parts[1];
-    const type = ABBREV_TO_TYPE[typeAbbr];
-    if (!type) {
-        throw new Error(`Unknown type abbreviation "${typeAbbr}" in: "${semanticId}"`);
-    }
-    return { name, type, counter: parts[2] };
-}
-/** Build a SemanticId from parts. */
-export function toSemanticId(name, type, counter) {
-    const abbr = TYPE_TO_ABBREV[type];
-    if (!abbr)
-        throw new Error(`No abbreviation for type: ${type}`);
-    const sanitized = sanitizeName(name);
-    return `${sanitized}.${abbr}.${counter}`;
-}
-/** Get the 2-char abbreviation for an ElementType. */
-export function getTypeAbbreviation(type) {
-    return TYPE_TO_ABBREV[type] ?? type.slice(0, 2).toUpperCase();
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Sanitize a name for SemanticId: PascalCase, only alnum + underscore + plus, max 50 chars. */
-function sanitizeName(name) {
-    return name.replace(/[^a-zA-Z0-9_+]/g, '').slice(0, 50);
-}