@tiinex/core 0.30.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "Shared host-neutral Tiinex implementation core for artifacts, schemas, validation, lineage, grounding, Handoffs, provenance and deterministic workflows.",
   "type": "module",
   "sideEffects": true,
@@ -173,12 +173,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "5d51273d4c10f8a15367c32bcef8bbce11484ca8",
+  "gitHead": "54c359f5d721194579aec2089cae096643912f07",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "5d51273d4c10f8a15367c32bcef8bbce11484ca8",
-    "sourceTree": "1372b29b40dbee5e11d2a52d9cac7731f41941a2",
+    "sourceCommit": "54c359f5d721194579aec2089cae096643912f07",
+    "sourceTree": "fbf8219dabf97f9939544b63387372c2c705726e",
     "repository": "Tiinex/core",
-    "previousVersion": "0.29.0"
+    "previousVersion": "0.30.0"
   }
 }

package/src/schemas/schema.lineageAuthority.js

@@ -0,0 +1,120 @@
+export const SCHEMA_LINEAGE_SOURCE_AUTHORITY_QUALIFICATION_SCHEMA_ID = 'tiinex.core.schema-lineage-source-authority-qualification.v1';
+
+export function qualifyCompiledSchemaLineageSourceAuthority(validationContract = {}) {
+  const lineage = Array.isArray(validationContract?.lineage) ? validationContract.lineage.map((item) => String(item || '').trim()) : [];
+  const projected = Array.isArray(validationContract?.lineageAuthority) ? validationContract.lineageAuthority : [];
+  const findings = [];
+  const edges = [];
+
+  if (!lineage.length || validationContract?.lineageQualification?.state !== 'valid') {
+    findings.push('Compiled validation lineage is unavailable or not valid.');
+  }
+  if (projected.length !== lineage.length) {
+    findings.push(`Compiled validation lineage source authority cardinality is ${projected.length}; expected ${lineage.length}.`);
+  }
+
+  const count = Math.min(projected.length, lineage.length);
+  for (let index = 0; index < count; index += 1) {
+    const entry = projected[index] || {};
+    const expectedSchemaId = lineage[index] || '';
+    const actualSchemaId = String(entry?.schemaId || '').trim();
+    if (!actualSchemaId || actualSchemaId !== expectedSchemaId) {
+      findings.push(`Compiled lineage source authority identity mismatch at index ${index}: expected ${expectedSchemaId || '(missing schema id)'} but observed ${actualSchemaId || '(missing schema id)'}.`);
+    }
+  }
+
+  for (let index = 1; index < count; index += 1) {
+    const parent = projected[index - 1] || {};
+    const child = projected[index] || {};
+    const parentSchemaId = String(parent?.schemaId || '').trim();
+    const childSchemaId = String(child?.schemaId || '').trim();
+    const declaredParentSchemaId = String(child?.parentSchemaId || '').trim();
+    const parentSource = normalizeSourceTuple(parent?.source || {});
+    const candidates = Object.freeze((Array.isArray(child?.parentSourceCandidates) ? child.parentSourceCandidates : []).map(normalizeSourceTuple));
+
+    if (!declaredParentSchemaId || declaredParentSchemaId !== parentSchemaId) {
+      findings.push(`Compiled lineage identity is incoherent across ${parentSchemaId || '(unknown parent)'} -> ${childSchemaId || '(unknown child)'}.`);
+      edges.push(freezeEdge({ state: 'contradictory', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'parent-schema-identity-mismatch' }));
+      continue;
+    }
+
+    if (isQualifiedLocalUnpublishedSchemaSource(parent?.source || {})) {
+      edges.push(freezeEdge({ state: 'qualified-local-supersession', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'qualified-local-unpublished-parent-authority' }));
+      continue;
+    }
+
+    const exactCandidates = candidates.filter(completeSourceTuple);
+    if (candidates.length !== 1 || exactCandidates.length !== 1) {
+      const reason = candidates.length > 1 ? 'ambiguous-parent-source-authority' : 'parent-source-authority-unavailable';
+      findings.push(candidates.length > 1
+        ? `Declared parent source authority is ambiguous for ${childSchemaId}: ${candidates.length} exact pinned candidates.`
+        : `Declared parent source authority is unavailable for ${childSchemaId} -> ${parentSchemaId}.`);
+      edges.push(freezeEdge({ state: 'unresolved', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason }));
+      continue;
+    }
+
+    const expected = exactCandidates[0];
+    if (!sameSourceTuple(parentSource, expected)) {
+      findings.push(`Compiled lineage substitutes source authority for ${childSchemaId} -> ${parentSchemaId}: declared ${formatSource(expected)} but compiled ${formatSource(parentSource)}.`);
+      edges.push(freezeEdge({ state: 'contradictory', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'compiled-parent-source-substitution' }));
+      continue;
+    }
+
+    edges.push(freezeEdge({ state: 'qualified', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'exact-parent-source-match' }));
+  }
+
+  const contradictory = edges.some((edge) => edge.state === 'contradictory') || findings.some((finding) => finding.includes('identity mismatch') || finding.includes('identity is incoherent') || finding.includes('substitutes source authority'));
+  const unresolved = !contradictory && (findings.length > 0 || edges.some((edge) => edge.state === 'unresolved'));
+  const state = contradictory ? 'contradictory' : unresolved ? 'unresolved' : 'qualified';
+  return deepFreeze({
+    schema: SCHEMA_LINEAGE_SOURCE_AUTHORITY_QUALIFICATION_SCHEMA_ID,
+    state,
+    complete: state === 'qualified',
+    lineage: Object.freeze([...lineage]),
+    edges: Object.freeze(edges),
+    findings: Object.freeze(findings),
+    boundary: 'Exact runtime validation authority requires source-coherent compiled inheritance. Qualified local unpublished Parent authority may intentionally supersede published Parent locators; all other inheritance edges require one exact declared Parent source tuple matching the compiled Parent material.'
+  });
+}
+
+export function isQualifiedLocalUnpublishedSchemaSource(source = {}) {
+  return String(source?.publicationState || '').trim().toLowerCase() === 'accepted-local-unpublished'
+    && String(source?.snapshotCompleteness || '').trim() === 'exact-axiom-canonical-unpublished-bounded-workspace-contract';
+}
+
+function normalizeSourceTuple(value = {}) {
+  return Object.freeze({
+    repository: String(value?.repository || '').trim(),
+    commit: String(value?.commit || '').trim().toLowerCase(),
+    path: String(value?.path || '').trim()
+  });
+}
+
+function completeSourceTuple(value = {}) {
+  return Boolean(value.repository && /^[0-9a-f]{40}$/.test(value.commit) && value.path);
+}
+
+function sameSourceTuple(left = {}, right = {}) {
+  return left.repository === right.repository && left.commit === right.commit && left.path === right.path;
+}
+
+function formatSource(value = {}) {
+  return `${value.repository || '(unknown repo)'}@${value.commit || '(unknown commit)'}/${value.path || '(unknown path)'}`;
+}
+
+function freezeEdge(value = {}) {
+  return Object.freeze({
+    state: String(value.state || 'unresolved'),
+    parentSchemaId: String(value.parentSchemaId || ''),
+    childSchemaId: String(value.childSchemaId || ''),
+    actual: value.actual || Object.freeze({ repository: '', commit: '', path: '' }),
+    candidates: value.candidates || Object.freeze([]),
+    reason: String(value.reason || '')
+  });
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}

package/src/schemas/schema.source.js

@@ -1,5 +1,6 @@
 import { sha256Hex, utf8Bytes } from '../export/package.bytes.js';
 import { qualifyGithubSchemaSourceProvider } from './schema.githubSourceTarget.js';
+import { qualifyCompiledSchemaLineageSourceAuthority } from './schema.lineageAuthority.js';
 
 export const BUNDLED_SCHEMA_SOURCE_SCHEMA_ID = 'tiinex.site.bundled-schema-source.v1';
 export const SCHEMA_RUNTIME_PROJECTION_SCHEMA_ID = 'tiinex.site.schema-runtime-projection.v1';
@@ -48,6 +49,7 @@ export function defineBundledSchemaSource(binding = {}, projection = {}, options
         ...(!loadedBlobSha ? ['Loaded schema Git-blob identity is unavailable from the runtime projection.'] : [])
       ])
     });
+    const validationLineageAuthority = qualifyCompiledSchemaLineageSourceAuthority(runtimeProjection.validationContract || {});
     const validationContract = projectionExact && runtimeProjection.validationContract?.schemaId === schemaId && runtimeProjection.validationContract?.lineageQualification?.state === 'valid'
       ? runtimeProjection.validationContract
       : null;
@@ -85,6 +87,7 @@ export function defineBundledSchemaSource(binding = {}, projection = {}, options
       authority,
       bindingMaterialCoherence,
       materialIdentity,
+      validationLineageAuthority,
       compiledContract,
       projection: runtimeProjection,
       findings: Object.freeze([
@@ -93,7 +96,8 @@ export function defineBundledSchemaSource(binding = {}, projection = {}, options
         ...(runtimeProjection.sourceChecksum !== expectedChecksum ? ['Schema runtime projection source checksum does not match binding.'] : []),
         ...(runtimeProjection.bindingChecksum !== expectedChecksum ? ['Schema runtime projection binding checksum does not match binding.'] : []),
         ...(runtimeProjection.validationContract && runtimeProjection.validationContract?.schemaId !== schemaId ? ['Schema runtime validation projection identity does not match binding.'] : []),
-        ...(runtimeProjection.validationContract && runtimeProjection.validationContract?.lineageQualification?.state !== 'valid' ? ['Schema runtime validation projection lineage is not exact/valid.'] : [])
+        ...(runtimeProjection.validationContract && runtimeProjection.validationContract?.lineageQualification?.state !== 'valid' ? ['Schema runtime validation projection lineage is not exact/valid.'] : []),
+        ...(validationLineageAuthority.state !== 'qualified' ? validationLineageAuthority.findings : [])
       ])
     });
     return cached;

package/src/tooling/portable/schema/qualifiedLocalRoot.runtime.js

@@ -13,10 +13,19 @@ export function portableRuntimeValidationContractForSchema(schemaId = '', resolu
   const resolution = resolutionInput || resolveSchemaModule({ schemaId });
   if (resolution?.fallbackUsed || !resolution?.module) return unavailable('registered-schema-resolution-unavailable', { resolution });
   const qualification = typeof resolution.module.schemaSource?.qualify === 'function' ? resolution.module.schemaSource.qualify() : null;
+  const lineageAuthority = qualification?.validationLineageAuthority || null;
+  if (qualification?.state === 'qualified' && lineageAuthority && lineageAuthority.state !== 'qualified') {
+    return unavailable('compiled-validation-lineage-source-authority-unqualified', {
+      resolution,
+      findings: Object.freeze([...(lineageAuthority.findings || [])]),
+      lineageAuthority,
+      baseQualificationState: String(qualification?.state || 'unavailable')
+    });
+  }
   const baseContract = qualification?.state === 'qualified' ? qualification?.compiledContract?.validationContract || null : null;
-  if (!baseContract) return unavailable(qualification?.state === 'qualified' ? 'compiled-validation-contract-unavailable' : 'schema-source-unqualified', { resolution });
+  if (!baseContract) return unavailable(qualification?.state === 'qualified' ? 'compiled-validation-contract-unavailable' : 'schema-source-unqualified', { resolution, findings: Object.freeze([...(qualification?.findings || [])]), baseQualificationState: String(qualification?.state || 'unavailable') });
   const projected = projectPortableValidationContractWithQualifiedLocalRoot(baseContract);
-  return deepFreeze({ ...projected, resolution, baseQualificationState: String(qualification?.state || 'unavailable') });
+  return deepFreeze({ ...projected, resolution, lineageAuthority, baseQualificationState: String(qualification?.state || 'unavailable') });
 }
 
 export function portableRuntimeValidationAuthorityForRecord(record = {}) {
@@ -26,7 +35,10 @@ export function portableRuntimeValidationAuthorityForRecord(record = {}) {
   const schemaId = String(declaredSchema.id || record?.schemaId || record?.currentSchemaId || '').trim();
   const runtime = portableRuntimeValidationContractForSchema(schemaId);
   if (runtime.state !== 'qualified' || !runtime.compiledContract) {
-    return unavailableAuthority(schemaId, runtime, ['Registered compiled validation authority is unavailable for the declared Current Schema.']);
+    const runtimeFindings = Array.isArray(runtime?.findings) && runtime.findings.length
+      ? runtime.findings
+      : ['Registered compiled validation authority is unavailable for the declared Current Schema.'];
+    return unavailableAuthority(schemaId, runtime, runtimeFindings);
   }
 
   const findings = [];