yarramate 0.19.0 → 0.20.0

package/README.md

@@ -252,6 +252,13 @@ const result = compileWorkspace([
 lineage for operations that explicitly require kind ancestry. Graph v2
 remains the stable, graph-only interchange result.
 
+`compileWorkspaceIncremental(sources, previous)` is the entry point for a
+consumer that recompiles a whole workspace on every write. It returns the
+same result plus an opaque `cache` to hand back on the next call, and
+re-parses only the sources whose text changed; `incremental: false` reports
+that it fell back to a full compile. Reuse is decided by source-text
+equality, so a stale cache costs work but never changes output.
+
 Normative schemas are available through package exports such as
 `yarramate/schema/document`, `yarramate/schema/workspace`,
 `yarramate/schema/graph-v2`, `yarramate/schema/projection`,

package/dist/adapters/likec4-export.d.ts

@@ -4,7 +4,7 @@ import type { ProjectionResult } from '../projection.js';
 import type { LikeC4KindMapping } from './likec4-kind-mapping.js';
 export interface LikeC4ExportDiagnostic {
     readonly severity: 'error';
-    readonly code: 'YMLC101' | 'YMLC102' | 'YMLC103' | 'YMLC104' | 'YMLC105' | 'YMLC106' | 'YMLC107' | 'YMLC108' | 'YMLC109' | 'YMLC111';
+    readonly code: 'YMLC101' | 'YMLC102' | 'YMLC103' | 'YMLC104' | 'YMLC105' | 'YMLC106' | 'YMLC107' | 'YMLC108' | 'YMLC109' | 'YMLC111' | 'YMLC112';
     readonly message: string;
     readonly subject?: string;
     readonly path: string;

package/dist/adapters/likec4-export.js

@@ -155,6 +155,38 @@ export function exportLikeC4(projection, mapping, kindMapping, options = {}) {
                 : [`    description ${quote(description)}`]), ...metadata, '  }');
         }
     }
+    // `likec4 validate` accepts an empty model as valid, so it can never notice
+    // that selected concepts stopped reaching the emitted text. The shortfall is
+    // only visible here, and it is measured on the assembled lines rather than on
+    // loop iterations so that a dropped definition is what fails, not a skipped
+    // turn of the loop.
+    const rendered = new Set(lines.flatMap((line) => {
+        if (!line.startsWith('  ') || line.startsWith('   '))
+            return [];
+        const [head, ...rest] = line.slice(2).split(' = ');
+        return rest.length > 0 ? [head] : [];
+    }));
+    const unrendered = concepts.filter(({ id }) => !rendered.has(externalByNative.get(id)));
+    const missing = unrendered[0];
+    if (missing !== undefined) {
+        const source = sourceForConcept(projection.claims, missing.id) ??
+            adapterMappingLocation(mapping, 'adapter');
+        return {
+            ok: false,
+            diagnostics: [
+                {
+                    severity: 'error',
+                    code: 'YMLC112',
+                    message: `Rendering coverage: ${concepts.length - unrendered.length} of ${concepts.length} projected concepts reached the LikeC4 model`,
+                    subject: missing.id,
+                    path: source.path,
+                    pointer: source.pointer,
+                    line: source.line,
+                    column: source.column,
+                },
+            ],
+        };
+    }
     const relationships = projection.subjects
         .filter(({ type }) => type === 'relationship')
         .sort((left, right) => left.id.localeCompare(right.id));

package/dist/adapters/visual/session-store.d.ts

@@ -110,7 +110,9 @@ export declare const buildVisualModelGraph: (sources: readonly WorkspaceSource[]
 /**
  * Recovers the handoff and only then deletes the session, so cleanup can never
  * be the step that loses confirmed state. Returns `undefined` when the session
- * is already gone, which makes a repeated stop idempotent.
+ * is already gone, which makes a repeated stop idempotent, and when a previous
+ * cleanup already took the journal: there is no handoff left to recover, and
+ * refusing would strand a marked directory that only this call will remove.
  */
 export declare const removeVisualSession: (paths: VisualSessionPaths, includeTranscript?: boolean) => Promise<VisualHandoff | undefined>;
 /**

package/dist/adapters/visual/session-store.js

@@ -582,10 +582,66 @@ export const buildVisualModelGraph = (sources) => {
         graph: projectGraphForCanvas(compiled.graph, compiled.profileContext),
     };
 };
+/**
+ * Whether a journal is still on disk. A cleanup that failed partway can leave
+ * a marked session without one, and that is a question about the filesystem
+ * rather than a corruption to report.
+ */
+const journalExists = async (paths) => {
+    try {
+        await lstat(paths.journal);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Deletes a session directory one entry at a time, journal and marker last.
+ *
+ * `rm(..., { recursive: true })` rejects the moment one entry fails while the
+ * sibling removals it already started are still in flight; those stragglers go
+ * on deleting after the caller has already seen the rejection. A cleanup that
+ * failed could therefore still take the journal with it, leaving the retry that
+ * follows nothing to recover from. Removing entries in a decided order, and
+ * awaiting each one, keeps the two files a retry depends on - the journal it
+ * recovers from, and the marker that authorises deleting this directory at all
+ * - on disk for as long as any other trace of the session is. The marker goes
+ * last of the two: a directory that outlives its marker is one no later pass
+ * would agree to remove.
+ */
+const removeSessionDirectory = async (paths) => {
+    let entries;
+    try {
+        entries = await readdir(paths.root, { withFileTypes: true });
+    }
+    catch (cause) {
+        // A session already gone is a completed cleanup, not a failed one.
+        if (typeof cause === 'object' &&
+            cause !== null &&
+            'code' in cause &&
+            cause.code === 'ENOENT') {
+            return;
+        }
+        throw cause;
+    }
+    const journal = basename(paths.journal);
+    const marker = basename(paths.marker);
+    for (const entry of entries) {
+        if (entry.name === journal || entry.name === marker)
+            continue;
+        await rm(join(paths.root, entry.name), { recursive: true, force: true });
+    }
+    await rm(paths.journal, { force: true });
+    await rm(paths.marker, { force: true });
+    await rm(paths.root, { recursive: true, force: true });
+};
 /**
  * Recovers the handoff and only then deletes the session, so cleanup can never
  * be the step that loses confirmed state. Returns `undefined` when the session
- * is already gone, which makes a repeated stop idempotent.
+ * is already gone, which makes a repeated stop idempotent, and when a previous
+ * cleanup already took the journal: there is no handoff left to recover, and
+ * refusing would strand a marked directory that only this call will remove.
  */
 export const removeVisualSession = async (paths, includeTranscript = false) => {
     let entry;
@@ -599,8 +655,12 @@ export const removeVisualSession = async (paths, includeTranscript = false) => {
     if (!entry.isDirectory()) {
         throw storeError('YMVS125', `Session root "${paths.root}" is not a directory`);
     }
-    const handoff = await recoverVisualSession(paths, includeTranscript);
-    await rm(paths.root, { recursive: true, force: true });
+    // The marker authorises the deletion whether or not a journal survived it.
+    await readSessionMarker(paths);
+    const handoff = (await journalExists(paths))
+        ? await recoverVisualSession(paths, includeTranscript)
+        : undefined;
+    await removeSessionDirectory(paths);
     await syncDirectory(dirname(paths.root));
     forget(paths);
     return handoff;
@@ -683,8 +743,9 @@ export const pruneStaleVisualSessions = async (baseDir, now, limit = VISUAL_SESS
     stale.sort((left, right) => left.activeAt - right.activeAt || left.root.localeCompare(right.root));
     const removed = [];
     for (const candidate of stale.slice(0, Math.max(0, limit))) {
-        await rm(candidate.root, { recursive: true, force: true });
-        forget(visualSessionPaths(candidate.root));
+        const paths = visualSessionPaths(candidate.root);
+        await removeSessionDirectory(paths);
+        forget(paths);
         removed.push(candidate.root);
     }
     if (removed.length > 0) {

package/dist/compiler.d.ts

@@ -70,6 +70,44 @@ export type ContextualCompilationResult = {
     readonly ok: false;
     readonly diagnostics: readonly Diagnostic[];
 };
+/**
+ * One parsed workspace source, retained by a {@link CompilationCache}. Hold it
+ * and hand it back; never construct one. `value` is the composed YAML of
+ * `source` and nothing else, so an entry is a pure function of its text.
+ */
+export interface ParsedWorkspaceSource {
+    readonly source: string;
+    readonly kind: 'profile' | 'document';
+    readonly value: unknown;
+    readonly schemaDiagnostics: readonly Diagnostic[];
+    /**
+     * Line/column already resolved for this text, keyed by YAML path. An
+     * internal memo of the compiler, filled as positions are asked for; a
+     * consumer that mutates it corrupts the `source` of later claims.
+     */
+    readonly positions: Map<string, ResolvedPosition>;
+}
+/**
+ * Opaque parse cache returned by {@link compileWorkspaceIncremental} and
+ * accepted by its next call. Reuse is decided by exact source-text equality,
+ * not by a caller-declared change set and not by a digest, so a stale cache
+ * cannot change the compiled output - it can only fail to save work.
+ */
+export interface CompilationCache {
+    readonly sources: ReadonlyMap<string, ParsedWorkspaceSource>;
+}
+export type IncrementalCompilationResult = ({
+    readonly ok: true;
+    readonly graph: SemanticGraph;
+    readonly profileContext: ResolvedProfileContext;
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly Diagnostic[];
+}) & {
+    /** False when every source had to be parsed, e.g. the first call. */
+    readonly incremental: boolean;
+    readonly cache: CompilationCache;
+};
 export declare const ATTESTATION_PREDICATE_PREFIX = "yarramate/attestation/";
 export declare const attestationClaimValue: (attestation: {
     readonly by: string;
@@ -88,5 +126,20 @@ export interface ConstraintExpectsParts {
     readonly value: string;
 }
 export declare const parseConstraintExpectsValue: (value: string) => ConstraintExpectsParts | undefined;
+interface ResolvedPosition {
+    readonly line: number;
+    readonly col: number;
+}
 export declare function compileWorkspace(sources: readonly WorkspaceSource[]): CompilationResult;
 export declare const compileWorkspaceWithProfileContext: (sources: readonly WorkspaceSource[]) => ContextualCompilationResult;
+/**
+ * Compiles the whole workspace, reusing the YAML parse of every source whose
+ * text is unchanged since `previous`. The compiled output is byte-identical to
+ * {@link compileWorkspaceWithProfileContext} for the same sources: the cache
+ * holds parse results only, and every cross-document decision is re-derived.
+ *
+ * Hold the returned `cache` and pass it to the next call. It retains one
+ * composed value per current source and drops sources that left the workspace.
+ */
+export declare const compileWorkspaceIncremental: (sources: readonly WorkspaceSource[], previous?: CompilationCache) => IncrementalCompilationResult;
+export {};

package/dist/compiler.js

@@ -99,12 +99,143 @@ const diagnosticFailure = (diagnostics) => ({
         left.code.localeCompare(right.code) ||
         left.message.localeCompare(right.message)),
 });
-function compileWorkspaceResolved(sources) {
+const nodePosition = (yaml, lineCounter, yamlPath) => {
+    const node = yaml.getIn(yamlPath, true);
+    const offset = typeof node === 'object' &&
+        node !== null &&
+        'range' in node &&
+        Array.isArray(node.range)
+        ? node.range[0]
+        : 0;
+    return lineCounter.linePos(offset);
+};
+// A position is read for every emitted claim's `source`, not only for faults,
+// so a compile that re-derived them from text would parse every fresh source
+// twice - measured at 282us/document against 193us/document for one parse.
+// A source parsed in this call hands its composed document straight to the
+// reader; a source served from cache carries the memo its earlier compile
+// filled and parses only for a path never asked for before. The reader
+// memoises either way, so the returned cache answers next time without the
+// document - and without the memo a delta costs 95% of a full compile.
+const positionReader = (source, positions, fresh) => {
+    let parsed = fresh;
+    return (yamlPath) => {
+        // Paths mix keys and indices; a JSON key cannot confuse `['a']` with
+        // `['a', 0]` the way a joined string could, and a wrong hit here would be
+        // a wrong line number in compiled output rather than lost work.
+        const key = JSON.stringify(yamlPath);
+        const memoised = positions.get(key);
+        if (memoised !== undefined) {
+            return memoised;
+        }
+        if (parsed === undefined) {
+            const lineCounter = new LineCounter();
+            parsed = { yaml: parseDocument(source, { lineCounter }), lineCounter };
+        }
+        const position = nodePosition(parsed.yaml, parsed.lineCounter, yamlPath);
+        positions.set(key, position);
+        return position;
+    };
+};
+// Every field of the entry is derived from `input.source` alone, which is what
+// makes an entry reusable across compiles: profile membership, the composed
+// value, and the faults the text carries on its own. Cross-document faults are
+// never cached - they are re-derived on every compile.
+const parseWorkspaceSource = (input) => {
+    const lineCounter = new LineCounter();
+    const yaml = parseDocument(input.source, { lineCounter });
+    const value = yaml.toJS();
+    const parseDiagnostics = yaml.errors.map((error) => {
+        const position = error.linePos?.[0] ?? { line: 1, col: 1 };
+        return {
+            severity: 'error',
+            code: 'YM101',
+            message: error.message.split(' at line ')[0] ?? error.message,
+            path: input.path,
+            pointer: '/',
+            line: position.line,
+            column: position.col,
+        };
+    });
+    // Classification reads the composed mapping through the YAML document, which
+    // types the lookup as `unknown` - the same key the old probe pass read.
+    const fresh = { yaml, lineCounter };
+    if (yaml.get('format') === 'yarramate/profile/v1') {
+        return {
+            entry: {
+                source: input.source,
+                kind: 'profile',
+                value,
+                schemaDiagnostics: parseDiagnostics,
+                positions: new Map(),
+            },
+            fresh,
+        };
+    }
+    const valid = parseDiagnostics.length === 0 && validateDocument(value);
+    const schemaDiagnostics = parseDiagnostics.length > 0
+        ? parseDiagnostics
+        : valid
+            ? []
+            : (validateDocument.errors ?? []).map((error) => {
+                const property = error.keyword === 'additionalProperties'
+                    ? String(error.params.additionalProperty)
+                    : undefined;
+                const pointer = property
+                    ? `${error.instancePath}/${property}`
+                    : error.instancePath || '/';
+                const yamlPath = pointer
+                    .split('/')
+                    .slice(1)
+                    .map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+                const position = nodePosition(yaml, lineCounter, yamlPath);
+                return {
+                    severity: 'error',
+                    code: 'YM201',
+                    message: property
+                        ? `Property "${property}" is not allowed`
+                        : `Document schema violation: ${describeSchemaViolation(error)}`,
+                    path: input.path,
+                    pointer,
+                    line: position.line,
+                    column: position.col,
+                };
+            });
+    return {
+        entry: {
+            source: input.source,
+            kind: 'document',
+            value,
+            schemaDiagnostics,
+            positions: new Map(),
+        },
+        fresh,
+    };
+};
+// Reuse is decided by exact source-text equality against the previous cache, so
+// a wrong or stale cache can only cost work, never change output. Sources that
+// left the workspace leave the returned cache with them.
+const parseSources = (sources, previous) => {
+    const entries = new Map();
+    let reused = 0;
+    const parsed = sources.map((input) => {
+        const cached = previous?.sources.get(input.path);
+        if (cached !== undefined && cached.source === input.source) {
+            reused += 1;
+            entries.set(input.path, cached);
+            return { input, entry: cached };
+        }
+        const { entry, fresh } = parseWorkspaceSource(input);
+        entries.set(input.path, entry);
+        return { input, entry, fresh };
+    });
+    return { parsed, cache: { sources: entries }, reused };
+};
+function compileWorkspaceResolved(parsed) {
     const profileInputs = [];
     const documentInputs = [];
-    for (const source of sources) {
-        const probe = parseDocument(source.source);
-        if (probe.get('format') === 'yarramate/profile/v1') {
+    for (const source of parsed) {
+        if (source.entry.kind === 'profile') {
             profileInputs.push(source);
         }
         else {
@@ -146,33 +277,13 @@ function compileWorkspaceResolved(sources) {
     });
     const profileDiagnostics = [];
     const pendingProfiles = [];
-    for (const input of profileInputs) {
-        const lineCounter = new LineCounter();
-        const yaml = parseDocument(input.source, { lineCounter });
-        const value = yaml.toJS();
-        const positionFor = (yamlPath) => {
-            const node = yaml.getIn(yamlPath, true);
-            const offset = typeof node === 'object' &&
-                node !== null &&
-                'range' in node &&
-                Array.isArray(node.range)
-                ? node.range[0]
-                : 0;
-            return lineCounter.linePos(offset);
-        };
-        if (yaml.errors.length > 0) {
-            for (const error of yaml.errors) {
-                const position = error.linePos?.[0] ?? { line: 1, col: 1 };
-                profileDiagnostics.push({
-                    severity: 'error',
-                    code: 'YM101',
-                    message: error.message.split(' at line ')[0] ?? error.message,
-                    path: input.path,
-                    pointer: '/',
-                    line: position.line,
-                    column: position.col,
-                });
-            }
+    for (const { input, entry, fresh } of profileInputs) {
+        // `validateProfile` below is what checks this shape; the cast carries the
+        // same pre-validation assumption the loop has always made.
+        const value = entry.value;
+        const positionFor = positionReader(input.source, entry.positions, fresh);
+        if (entry.schemaDiagnostics.length > 0) {
+            profileDiagnostics.push(...entry.schemaDiagnostics);
             continue;
         }
         if (!validateProfile(value)) {
@@ -383,19 +494,13 @@ function compileWorkspaceResolved(sources) {
     if (profileDiagnostics.length > 0) {
         return diagnosticFailure(profileDiagnostics);
     }
-    const documents = documentInputs.map((input) => {
-        const lineCounter = new LineCounter();
-        const yaml = parseDocument(input.source, { lineCounter });
-        const value = yaml.toJS();
+    const documents = documentInputs.map(({ input, entry, fresh }) => {
+        // Schema-checked by `parseWorkspaceSource`; the faults it found are the
+        // `schemaDiagnostics` returned below, and they gate every later phase.
+        const value = entry.value;
+        const positionAt = positionReader(input.source, entry.positions, fresh);
         const location = (yamlPath, pointer) => {
-            const node = yaml.getIn(yamlPath, true);
-            const offset = typeof node === 'object' &&
-                node !== null &&
-                'range' in node &&
-                Array.isArray(node.range)
-                ? node.range[0]
-                : 0;
-            const position = lineCounter.linePos(offset);
+            const position = positionAt(yamlPath);
             return {
                 document: value?.id ?? '<unknown>',
                 path: input.path,
@@ -404,48 +509,12 @@ function compileWorkspaceResolved(sources) {
                 column: position.col,
             };
         };
-        const parseDiagnostics = yaml.errors.map((error) => {
-            const position = error.linePos?.[0] ?? { line: 1, col: 1 };
-            return {
-                severity: 'error',
-                code: 'YM101',
-                message: error.message.split(' at line ')[0] ?? error.message,
-                path: input.path,
-                pointer: '/',
-                line: position.line,
-                column: position.col,
-            };
-        });
-        const valid = parseDiagnostics.length === 0 && validateDocument(value);
-        const schemaDiagnostics = parseDiagnostics.length > 0
-            ? parseDiagnostics
-            : valid
-                ? []
-                : (validateDocument.errors ?? []).map((error) => {
-                    const property = error.keyword === 'additionalProperties'
-                        ? String(error.params.additionalProperty)
-                        : undefined;
-                    const pointer = property
-                        ? `${error.instancePath}/${property}`
-                        : error.instancePath || '/';
-                    const yamlPath = pointer
-                        .split('/')
-                        .slice(1)
-                        .map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
-                    const source = location(yamlPath, pointer);
-                    return {
-                        severity: 'error',
-                        code: 'YM201',
-                        message: property
-                            ? `Property "${property}" is not allowed`
-                            : `Document schema violation: ${describeSchemaViolation(error)}`,
-                        path: input.path,
-                        pointer,
-                        line: source.line,
-                        column: source.column,
-                    };
-                });
-        return { input, value, location, schemaDiagnostics };
+        return {
+            input,
+            value,
+            location,
+            schemaDiagnostics: entry.schemaDiagnostics,
+        };
     });
     const claims = [];
     const subjects = [];
@@ -1395,7 +1464,24 @@ function compileWorkspaceResolved(sources) {
     };
 }
 export function compileWorkspace(sources) {
-    const result = compileWorkspaceResolved(sources);
+    const result = compileWorkspaceResolved(parseSources(sources).parsed);
     return result.ok ? { ok: true, graph: result.graph } : result;
 }
-export const compileWorkspaceWithProfileContext = (sources) => compileWorkspaceResolved(sources);
+export const compileWorkspaceWithProfileContext = (sources) => compileWorkspaceResolved(parseSources(sources).parsed);
+/**
+ * Compiles the whole workspace, reusing the YAML parse of every source whose
+ * text is unchanged since `previous`. The compiled output is byte-identical to
+ * {@link compileWorkspaceWithProfileContext} for the same sources: the cache
+ * holds parse results only, and every cross-document decision is re-derived.
+ *
+ * Hold the returned `cache` and pass it to the next call. It retains one
+ * composed value per current source and drops sources that left the workspace.
+ */
+export const compileWorkspaceIncremental = (sources, previous) => {
+    const { parsed, cache, reused } = parseSources(sources, previous);
+    return {
+        ...compileWorkspaceResolved(parsed),
+        incremental: reused > 0,
+        cache,
+    };
+};

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { compileWorkspace, compileWorkspaceWithProfileContext, } from './compiler.js';
+export { compileWorkspace, compileWorkspaceIncremental, compileWorkspaceWithProfileContext, } from './compiler.js';
 export { serializeSemanticGraph } from './graph.js';
 export { checkCoreContract, loadCoreContract, type CoreContract, type CoreContractCommand, type CoreContractFormat, type CoreContractLoadResult, type CoreContractSurface, } from './core-contract.js';
 export { compareArchitectureStates, type StateComparison, type StateComparisonIssue, type StateComparisonResult, } from './architecture-state.js';
@@ -7,7 +7,7 @@ export { evaluateEvidence, evaluateEvidenceWorkspace, loadEvidence, type Evidenc
 export { constraintExpectsPredicate, reconcileEvidenceReports, type AssertedRelationship, type AttestationStaleness, type DeclaredSource, type EvidenceFinding, type ExpectationComparison, type ReconciliationFinding, type ReconciliationReport, type StaleAttestationFinding, type UnobservedExpectation, } from './reconciliation.js';
 export { deriveAttestationStaleness } from './attestation-staleness.js';
 export { buildRtm, renderRtmMarkdown, type RequirementsTraceabilityMatrix, type RtmAttestation, type RtmContextEntry, type RtmDescopedEntry, type RtmEvidenceVerdict, type RtmLineageEntry, type RtmRealizer, type RtmRow, type RtmSource, } from './rtm.js';
-export type { CompilationResult, ContextualCompilationResult, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
+export type { CompilationCache, CompilationResult, ContextualCompilationResult, IncrementalCompilationResult, ParsedWorkspaceSource, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
 export { canonicalProjection, evaluateProjection, loadProjection, renderProjectionMarkdown, } from './projection.js';
 export { loadAdapterMapping, validateAdapterMapping, validateAdapterMappings, type AdapterMapping, type AdapterMappingLoadResult, type AdapterMappingValidationResult, type AdapterMappingsValidationResult, type AdapterSubjectMapping, } from './adapter-mapping.js';
 export type { LifecycleStatus, ProjectionDefinition, ProjectionLoadResult, ProjectionResult, } from './projection.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { compileWorkspace, compileWorkspaceWithProfileContext, } from './compiler.js';
+export { compileWorkspace, compileWorkspaceIncremental, compileWorkspaceWithProfileContext, } from './compiler.js';
 export { serializeSemanticGraph } from './graph.js';
 export { checkCoreContract, loadCoreContract, } from './core-contract.js';
 export { compareArchitectureStates, } from './architecture-state.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yarramate",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Tool-neutral semantic architecture engine and guided methodology",
   "license": "MIT",
   "repository": {
@@ -113,7 +113,8 @@
     "self:check:likec4": "pnpm build && node dist/adapters/likec4-cli.js check .yarramate/likec4-project.yaml .yarramate/workspace.yaml",
     "self:check:likec4:json": "pnpm build && node dist/adapters/likec4-cli.js check .yarramate/likec4-project.yaml --json .yarramate/workspace.yaml",
     "self:export:likec4": "pnpm build && node dist/adapters/likec4-cli.js export-project .yarramate/likec4-project.yaml .yarramate-out/likec4 .yarramate/workspace.yaml",
-    "validate": "pnpm self:export:likec4 && likec4 validate --no-layout .yarramate-out/likec4",
+    "self:check:likec4:output": "pnpm build && node dist/adapters/likec4-cli.js export-project --check .yarramate/likec4-project.yaml .yarramate-out/likec4 .yarramate/workspace.yaml",
+    "validate": "pnpm self:export:likec4 && pnpm self:check:likec4:output && likec4 validate --no-layout .yarramate-out/likec4",
     "verify": "pnpm typecheck && pnpm build && pnpm test && pnpm self:check && pnpm validate",
     "test": "vitest run",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.visual.json"
@@ -124,7 +125,6 @@
     "yaml": "^2.8.1"
   },
   "devDependencies": {
-    "@likec4/core": "1.59.2",
     "@types/node": "^26.1.2",
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",
@@ -132,7 +132,7 @@
     "cytoscape": "^3.34.1",
     "cytoscape-elk": "^2.3.0",
     "elkjs": "^0.12.0",
-    "likec4": "^1.59.2",
+    "likec4": "1.59.2",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "typescript": "^7.0.2",

package/schema/yarramate-likec4-diagnostic-result.schema.json

@@ -34,7 +34,7 @@
                 "const": "error"
               },
               "code": {
-                "enum": ["YMLC101", "YMLC102", "YMLC103", "YMLC104", "YMLC105", "YMLC106", "YMLC107", "YMLC108", "YMLC109", "YMLC110"]
+                "enum": ["YMLC101", "YMLC102", "YMLC103", "YMLC104", "YMLC105", "YMLC106", "YMLC107", "YMLC108", "YMLC109", "YMLC110", "YMLC111", "YMLC112"]
               },
               "message": {
                 "type": "string",