@tiinex/core 0.33.0 → 0.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.33.0",
+  "version": "0.34.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": "a317bd83e450d04e6e9b0a5229944d958b61eb91",
+  "gitHead": "873ac202d2f12a6fbf43437c61b198a85dd7afb3",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "a317bd83e450d04e6e9b0a5229944d958b61eb91",
-    "sourceTree": "7f7ff3bb4a7926eb901476d777630c3d536ebed2",
+    "sourceCommit": "873ac202d2f12a6fbf43437c61b198a85dd7afb3",
+    "sourceTree": "90fab47ce492c14411836043f221511212b5471e",
     "repository": "Tiinex/core",
-    "previousVersion": "0.32.0"
+    "previousVersion": "0.33.0"
   }
 }

package/src/tooling/portable/editor/editor.assistance.js

@@ -76,6 +76,24 @@ function projectDocument(record = {}, records = [], lineageInspection = null, re
   diagnostics.push(...referenceResolution.diagnostics);
   actions.push(...referenceResolution.actions);
 
+  const lineageArtifact = (lineageInspection?.artifacts || []).find((item) => norm(item?.path || '') === recordPath) || null;
+  const parentIntegrityRepair = deterministicParentIntegrityRepair(markdown, lineageArtifact);
+  const parentRepairQualification = parentIntegrityRepair.state === 'ready'
+    ? qualifyReplacementAgainstSharedGuardrails(record, records, parentIntegrityRepair.markdown, {
+      allowExistingWarningCodes: sharedFindings.filter((item) => item.severity === 'warning').map((item) => String(item.code || ''))
+    })
+    : { state: 'unavailable' };
+  if (parentIntegrityRepair.state === 'ready' && parentIntegrityRepair.markdown !== markdown && parentRepairQualification.state === 'qualified') actions.push(freeze({
+    id: 'refresh-parent-integrity-and-self-seal',
+    title: 'Refresh Tiinex Parent integrity and self seal',
+    kind: 'replace-document',
+    qualification: 'deterministic-shared-core',
+    sourceSha256: sha256Hex(new TextEncoder().encode(markdown)),
+    replacementMarkdown: parentIntegrityRepair.markdown,
+    diagnosticCodes: ['portable.lineage-integrity.parent-target-mismatch', 'integrity.c14n-v2.mismatch', 'portable.lineage-integrity.child-self-mismatch'],
+    boundary: 'Refreshes only an existing Parent integrity digest whose declared locator already matches the exact resolved Parent and whose verified Parent self digest is available locally; the focused artifact is resealed and the action is withheld when loaded descendants would become inconsistent.'
+  }));
+
   const integrityRepair = deterministicIntegrityHygieneRepair(markdown, sharedFindings);
   const repairQualification = integrityRepair.state === 'ready'
     ? qualifyReplacementAgainstSharedGuardrails(record, records, integrityRepair.markdown, {
@@ -394,9 +412,12 @@ export function locateFindingLine(finding = {}, markdown = '') {
   const code = String(finding.code || '');
 
   // Integrity findings often carry the generic field name `Value`. That field
-  // appears once per integrity relation, so resolving `field:Value` first would
-  // incorrectly anchor a self-integrity finding on the first Parent digest.
-  // Resolve semantically-owned integrity locations before generic field lookup.
+  // appears once per integrity relation, so resolve semantically-owned relation
+  // locations before generic field lookup.
+  if (code === 'portable.lineage-integrity.parent-target-mismatch') {
+    const parentValueIndex = primaryParentIntegrityValueLine(lines);
+    if (parentValueIndex >= 0) return locatedLine(lines, parentValueIndex, 'deterministic', 'continuity-integrity-primary-parent-value');
+  }
   if (code === 'integrity.c14n-v2.mismatch' || code === 'integrity.c14n-v2.ambiguous' || code === 'portable.lineage-integrity.child-self-mismatch' || code === 'portable.lineage-integrity.child-self-unavailable') {
     const selfValueIndex = primarySelfIntegrityValueLine(lines);
     if (selfValueIndex >= 0) return locatedLine(lines, selfValueIndex, 'deterministic', 'continuity-integrity-primary-self-value');
@@ -451,6 +472,24 @@ export function locateFindingLine(finding = {}, markdown = '') {
   return freeze({ state: 'unresolved', line: null, sourceRange: null, basis: 'shared-finding-has-no-deterministic-line-evidence' });
 }
 
+function primaryParentIntegrityValueLine(lines = []) {
+  const headingIndex = lines.findIndex((line) => String(line || '').trim() === '# Continuity Integrity');
+  if (headingIndex < 0) return -1;
+  let parentTowards = -1;
+  for (let index = headingIndex + 1; index < lines.length; index += 1) {
+    const line = String(lines[index] || '');
+    if (index > headingIndex + 1 && /^#\s+/.test(line)) break;
+    const towards = line.match(/^\s+-\s+Towards\s*:\s*(.+?)\s*$/i);
+    if (towards) {
+      parentTowards = String(towards[1] || '').trim().toLowerCase() === 'self' ? -1 : index;
+      continue;
+    }
+    if (parentTowards >= 0 && /^\s+-\s+Value\s*:/.test(line)) return index;
+    if (parentTowards >= 0 && /^-\s+/.test(line)) parentTowards = -1;
+  }
+  return -1;
+}
+
 function primarySelfIntegrityValueLine(lines = []) {
   const headingIndex = lines.findIndex((line) => String(line || '').trim() === '# Continuity Integrity');
   if (headingIndex < 0) return -1;
@@ -465,6 +504,43 @@ function primarySelfIntegrityValueLine(lines = []) {
   return -1;
 }
 
+function deterministicParentIntegrityRepair(markdown = '', artifact = null) {
+  const source = String(markdown || '');
+  if (!source || !artifact || artifact.state !== 'parent-target-mismatch') return freeze({ state: 'unavailable' });
+  if (String(artifact?.parentTarget?.reason || '') !== 'target-self-digest-mismatch') return freeze({ state: 'unavailable' });
+  if (artifact?.parentAvailability?.state !== 'resolved' || artifact?.parentPrimarySelf?.state !== 'verified') return freeze({ state: 'unavailable' });
+  const declaredTarget = String(artifact?.parentTarget?.declaredTarget || '').trim();
+  const expectedTarget = String(artifact?.exactParent?.expectedIntegrityTarget || '').trim();
+  const digest = String(artifact?.repairCandidate?.candidateTargetDigest || artifact?.parentPrimarySelf?.value || '').trim();
+  if (!declaredTarget || !expectedTarget || declaredTarget !== expectedTarget || !digest) return freeze({ state: 'unavailable' });
+
+  const lines = source.replace(/\r\n?/g, '\n').split('\n');
+  const headingIndex = lines.findIndex((line) => String(line || '').trim() === '# Continuity Integrity');
+  if (headingIndex < 0) return freeze({ state: 'unavailable' });
+  let targetMatched = false;
+  let changed = false;
+  for (let index = headingIndex + 1; index < lines.length; index += 1) {
+    const line = String(lines[index] || '');
+    if (index > headingIndex + 1 && /^#\s+/.test(line)) break;
+    const towards = line.match(/^\s+-\s+Towards\s*:\s*(?:\[[^\]]+\]\(([^)]+)\)|(\S.*))\s*$/i);
+    if (towards) {
+      const value = String(towards[1] || towards[2] || '').trim();
+      targetMatched = value === declaredTarget;
+      continue;
+    }
+    if (targetMatched && /^(\s+-\s+Value\s*:\s*)(.*)$/.test(line)) {
+      const match = line.match(/^(\s+-\s+Value\s*:\s*)(.*)$/);
+      lines[index] = `${match?.[1] || '  - Value: '}${digest}`;
+      changed = String(match?.[2] || '').trim() !== digest;
+      break;
+    }
+  }
+  if (!changed) return freeze({ state: 'unavailable' });
+  const sealed = sealC14nV2Self(lines.join('\n'));
+  if (sealed.state !== 'sealed' && sealed.state !== 'unchanged') return freeze({ state: 'unavailable' });
+  return freeze({ state: 'ready', markdown: String(sealed.markdown || lines.join('\n')) });
+}
+
 function deterministicIntegrityHygieneRepair(markdown = '', findings = []) {
   const source = String(markdown || '');
   const codes = new Set((findings || []).map((item) => String(item?.code || '')));

package/src/tooling/portable/lineage/lineage.integrity.plan.js

@@ -223,11 +223,15 @@ function choosePrimaryState({ parentResolution, parentSchema, parentPrimarySelf,
     || consider(parentSchema.state !== 'verified', 'parent-schema-unavailable', parentSchema.reason)
     || consider(parentPrimarySelf.state === 'mismatch', 'parent-self-mismatch', parentPrimarySelf.reason)
     || consider(parentPrimarySelf.state !== 'verified', 'parent-self-unavailable', parentPrimarySelf.reason)
-    || consider(childSelf.state === 'mismatch', 'child-self-mismatch', childSelf.reason)
-    || consider(childSelf.state !== 'verified', 'child-self-unavailable', childSelf.reason)
+    // Parent-target corruption is more specific than the consequential child-self
+    // mismatch caused by changing footer bytes. Surface the owned Parent relation
+    // first so editors can locate and repair the actual mutated digest.
     || consider(targetInspection.state === 'missing', 'parent-target-missing', targetInspection.reason)
     || consider(targetInspection.state === 'mismatch', 'parent-target-mismatch', targetInspection.reason)
-    || consider(targetInspection.state !== 'verified', targetInspection.state === 'ambiguous' ? 'parent-target-ambiguous' : 'unsupported', targetInspection.reason)
+    || consider(targetInspection.state === 'ambiguous', 'parent-target-ambiguous', targetInspection.reason)
+    || consider(childSelf.state === 'mismatch', 'child-self-mismatch', childSelf.reason)
+    || consider(childSelf.state !== 'verified', 'child-self-unavailable', childSelf.reason)
+    || consider(targetInspection.state !== 'verified', 'unsupported', targetInspection.reason)
     || consider(publicationOrigin.state === 'contradictory', 'publication-origin-contradictory', publicationOrigin.reason)
     || consider(publicationOrigin.state === 'stale', 'publication-origin-stale', publicationOrigin.reason)
     || consider(publicationOrigin.state === 'unresolved', 'publication-origin-unresolved', publicationOrigin.reason)