@tiinex/core 0.31.0 → 0.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.31.0",
+  "version": "0.32.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": "54c359f5d721194579aec2089cae096643912f07",
+  "gitHead": "036df699dd3a0455f849c4c4e421fee7c969e85a",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "54c359f5d721194579aec2089cae096643912f07",
-    "sourceTree": "fbf8219dabf97f9939544b63387372c2c705726e",
+    "sourceCommit": "036df699dd3a0455f849c4c4e421fee7c969e85a",
+    "sourceTree": "540c88695f9de86c928a737e1ea2c51b5be5cd82",
     "repository": "Tiinex/core",
-    "previousVersion": "0.30.0"
+    "previousVersion": "0.31.0"
   }
 }

package/src/tooling/portable/adapters/cli/cli.handoff-sibling-allocation.js

@@ -30,7 +30,26 @@ export function deriveHandoffSiblingAllocation({ parentInspection = null, select
     workspaceId: String(route.workspaceId || '').trim(),
     workspaceRelativeHandoffPath: String(route.workspaceRelativeHandoffPath || '').trim()
   }));
-  if (!routes.length) return blocked('qualified-parent-route-topology-empty');
+  if (!routes.length) {
+    const siblingIndex = 1;
+    if (explicit && explicit !== siblingIndex) return blocked('explicit-sibling-index-conflicts-with-qualified-pointerless-topology', { expectedSiblingIndex: siblingIndex });
+    return freeze({
+      state: 'qualified',
+      siblingIndex,
+      childDimension: parentDimension ? `${String(parentDimension).trim()}-${siblingIndex}` : '',
+      allocationMode: 'qualified-parent-pointerless-default',
+      explicitOverride: explicit ? 'matched-derived-value' : 'not-supplied',
+      reasonCode: '',
+      provenance: {
+        ...provenanceBase({ parentPackagePath, parentPackageSha256, parentDimension, explicitSiblingIndex: explicit }),
+        basis: 'qualified-parent-pointerless-default',
+        routeOrdinal: siblingIndex,
+        qualifiedRouteCount: 0,
+        pointerOrder: []
+      },
+      boundary: allocationBoundary()
+    });
+  }
 
   const qualified = [];
   const seenDimensions = new Set();

package/src/tooling/portable/editor/authoring.parent.js

@@ -2,6 +2,7 @@ import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
 import { auditPortableRecord } from '../audit/audit.capability.js';
 import { classifyParentRecoveryReference } from '../../../lineage/parentRecoveryReference.js';
 import { buildArtifactCreationContract } from '../../../schemas/creation.contracts.js';
+import { canonicalC14nV2SelfState } from '../../../integrity/integrity.c14nV2.js';
 
 export const PORTABLE_AUTHORING_PARENT_SCHEMA_ID = 'tiinex.portable.authoring-parent.v1';
 
@@ -12,8 +13,15 @@ export function projectPortableAuthoringParent(input = {}) {
   let parsed;
   try { parsed = parseArtifactMarkdown(record.markdown); }
   catch { return freeze({ schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID, status: 'blocked', parentRecord: null, findings: [{ severity: 'error', code: 'portable.authoring-parent.parse-failed', message: 'Selected Parent bytes are not a readable Tiinex artifact.' }], operationBoundary: boundary() }); }
-  const audit = auditPortableRecord({ ...record, title: parsed.title, schemaId: parsed.envelope?.current?.schema?.id, currentSchemaId: parsed.envelope?.current?.schema?.id, parent: parsed.envelope?.parent });
-  if (audit.status !== 'readable' || audit.qualification?.exact !== true || (audit.findings || []).some((item) => item.severity === 'error')) return freeze({ schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID, status: 'blocked', parentRecord: null, findings: [{ severity: 'error', code: 'portable.authoring-parent.unqualified', message: 'Selected Parent must pass exact shared audit before it can be used for native authoring.' }], operationBoundary: boundary() });
+  const audit = auditPortableRecord({ ...record, title: parsed.title, schemaId: parsed.envelope?.current?.schema?.id, currentSchemaId: parsed.envelope?.current?.schema?.id, parent: parsed.envelope?.parent }, { requireExactSchemaAuthority: true });
+  const auditErrors = (audit.findings || []).filter((item) => item.severity === 'error');
+  const historicalParentRecoveryDebt = auditErrors.length > 0 && auditErrors.every((item) => String(item.code || '') === 'root.parent.recovery.workspace-qualified.malformed');
+  const selfIntegrity = canonicalC14nV2SelfState(record.markdown || '');
+  const directParentUsableWithHistoricalDebt = historicalParentRecoveryDebt
+    && audit.qualification?.exact === true
+    && audit.schemaValidationAuthority?.state === 'qualified'
+    && selfIntegrity.state === 'verified';
+  if ((audit.status !== 'readable' && !directParentUsableWithHistoricalDebt) || audit.qualification?.exact !== true || (auditErrors.length && !directParentUsableWithHistoricalDebt)) return freeze({ schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID, status: 'blocked', parentRecord: null, findings: [{ severity: 'error', code: 'portable.authoring-parent.unqualified', message: 'Selected Parent must pass exact shared audit before it can be used for native authoring.' }], operationBoundary: boundary() });
   const schemaId = String(parsed.envelope?.current?.schema?.id || audit.schemaId || '');
   const schemaTarget = String(parsed.envelope?.current?.schema?.target || '');
   const createdAt = String(parsed.envelope?.current?.createdAt || audit.artifact?.createdAt || '');
@@ -36,9 +44,11 @@ export function projectPortableAuthoringParent(input = {}) {
       markdown: record.markdown, sourceMode: String(record.sourceMode || 'portable-node-local'),
       schemaReferenceAuthority
     },
-    findings: [],
+    findings: directParentUsableWithHistoricalDebt ? [{ severity: 'warning', code: 'portable.authoring-parent.historical-ancestor-recovery-debt', message: 'Selected Parent has historical malformed Workspace-qualified recovery references to its own ancestor. Direct child authoring is allowed from the Parent exact current bytes and verified self integrity; that ancestor debt is not repaired, inherited, or upgraded.' }] : [],
     operationBoundary: boundary(),
-    boundary: 'Projects exact supplied Parent bytes and declared current schema locator into shared draft-authoring input. A declared schema locator remains unresolved and is not upgraded to publication or canonical reference authority.'
+    boundary: directParentUsableWithHistoricalDebt
+      ? 'Projects exact supplied Parent current bytes for direct continuation while preserving unresolved historical ancestor-recovery debt on the Parent itself. The child does not inherit or repair that ancestor locator.'
+      : 'Projects exact supplied Parent bytes and declared current schema locator into shared draft-authoring input. A declared schema locator remains unresolved and is not upgraded to publication or canonical reference authority.'
   });
 }
 

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

@@ -5,6 +5,7 @@ import { integrityMethodReferenceAuthorityForCreation } from '../../../integrity
 import { inspectPortableLineageIntegrity } from '../lineage/lineage.integrity.plan.js';
 import { portableFinding } from '../findings.js';
 import { qualifyTiinexRouteArtifact } from '../handoff/routeArtifactConformance.js';
+import { classifyParentRecoveryReference } from '../../../lineage/parentRecoveryReference.js';
 
 export const PORTABLE_EDITOR_ASSISTANCE_SCHEMA_ID = 'tiinex.portable.editor-assistance.v1';
 
@@ -49,6 +50,28 @@ function projectDocument(record = {}, records = [], lineageInspection = null) {
     diagnosticCodes: workspacePackagingRepair.diagnosticCodes,
     boundary: 'Repairs only a tiinex.workspace.v1 artifact whose replacement independently qualifies through the same exact registered Workspace contract and c14n-v2 self-integrity requirements used by Handoff package manufacture. Existing resolver-capable Current Schema references are preserved; permalink refresh is a separate resolution operation and must not be inferred from integrity repair.'
   }));
+  const referenceRepair = deterministicReferenceHygieneRepair(record, audit, markdown);
+  const referenceQualification = referenceRepair.state === 'ready'
+    ? qualifyReplacementAgainstSharedGuardrails(record, records, referenceRepair.markdown, {
+      allowQualifiedExternalParentUnresolved: true,
+      allowExistingWarningCodes: (audit.findings || []).filter((item) => item.severity === 'warning').map((item) => String(item.code || ''))
+    })
+    : { state: 'unavailable' };
+  if (referenceRepair.state === 'ready' && referenceRepair.markdown !== markdown && referenceQualification.state === 'qualified') actions.push(freeze({
+    id: 'repair-qualified-references-and-self-integrity',
+    title: referenceRepair.parentReferenceChanged && referenceRepair.schemaReferenceChanged
+      ? 'Repair Tiinex Parent/schema references and self integrity'
+      : referenceRepair.parentReferenceChanged
+        ? 'Repair Tiinex Parent references and self integrity'
+        : 'Repair Tiinex schema reference and self integrity',
+    kind: 'replace-document',
+    qualification: 'deterministic-shared-core',
+    sourceSha256: sha256Hex(new TextEncoder().encode(markdown)),
+    replacementMarkdown: referenceRepair.markdown,
+    diagnosticCodes: referenceRepair.diagnosticCodes,
+    boundary: 'Repairs only deterministically malformed Workspace-qualified Parent recovery locators and/or a bare Current Schema id when exact qualified current-schema source authority exists; reseals self integrity and exposes the replacement only after shared audit and loaded-descendant guardrails re-qualify it. External Parent availability is not invented.'
+  }));
+
   const integrityRepair = deterministicIntegrityHygieneRepair(markdown, audit.findings || []);
   const repairQualification = integrityRepair.state === 'ready'
     ? qualifyReplacementAgainstSharedGuardrails(record, records, integrityRepair.markdown)
@@ -117,25 +140,119 @@ function deterministicWorkspacePackagingRepair(record = {}, audit = {}, markdown
   return freeze({ state: 'ready', markdown: candidate, schemaReferenceChanged, diagnosticCodes });
 }
 
-function qualifyReplacementAgainstSharedGuardrails(record = {}, records = [], replacementMarkdown = '') {
+function qualifyReplacementAgainstSharedGuardrails(record = {}, records = [], replacementMarkdown = '', options = {}) {
   const focusPath = norm(record.path || record.id || '');
   if (!focusPath || !replacementMarkdown) return freeze({ state: 'unavailable', reason: 'replacement-or-focus-unavailable' });
   const replacedRecords = records.map((item) => norm(item.path || item.id || '') === focusPath ? { ...item, markdown: replacementMarkdown } : item);
   const replacementRecord = replacedRecords.find((item) => norm(item.path || item.id || '') === focusPath);
   if (!replacementRecord) return freeze({ state: 'unavailable', reason: 'focused-record-unavailable' });
   const replacementAudit = auditPortableRecord(replacementRecord, { requireExactSchemaAuthority: true });
-  const auditBlockers = [...(replacementAudit.findings || [])].filter((item) => item.severity === 'error' || item.severity === 'warning');
+  const allowedWarnings = new Set((options.allowExistingWarningCodes || []).map((item) => String(item || '')));
+  const auditBlockers = [...(replacementAudit.findings || [])].filter((item) => {
+    if (item.severity === 'error') return true;
+    if (item.severity !== 'warning') return false;
+    return !allowedWarnings.has(String(item.code || ''));
+  });
   if (auditBlockers.length) return freeze({ state: 'blocked', reason: 'replacement-shared-audit-not-clean', blockerCodes: auditBlockers.map((item) => String(item.code || '')) });
 
   const before = inspectPortableLineageIntegrity({ records });
   const after = inspectPortableLineageIntegrity({ records: replacedRecords });
   const beforeFocus = (before.artifacts || []).find((item) => norm(item.path || '') === focusPath);
   const affectedPaths = new Set([focusPath, ...((beforeFocus?.downstreamDescendants || []).map((item) => norm(item.path || '')).filter(Boolean))]);
-  const lineageBlockers = (after.artifacts || []).filter((item) => affectedPaths.has(norm(item.path || '')) && item.state !== 'healthy');
+  const lineageBlockers = (after.artifacts || []).filter((item) => {
+    if (!affectedPaths.has(norm(item.path || '')) || item.state === 'healthy') return false;
+    if (options.allowQualifiedExternalParentUnresolved === true && norm(item.path || '') === focusPath && item.state === 'parent-unresolved' && hasQualifiedWorkspaceParentReference(replacementMarkdown)) return false;
+    return true;
+  });
   if (lineageBlockers.length) return freeze({ state: 'blocked', reason: 'replacement-shared-lineage-not-clean', blockers: lineageBlockers.map((item) => ({ path: item.path, state: item.state })) });
   return freeze({ state: 'qualified', affectedPaths: [...affectedPaths] });
 }
 
+function deterministicReferenceHygieneRepair(record = {}, audit = {}, markdown = '') {
+  const source = String(markdown || '');
+  if (!source) return freeze({ state: 'unavailable' });
+  let candidate = source;
+  let parentReferenceChanged = false;
+  let schemaReferenceChanged = false;
+  const diagnosticCodes = [];
+
+  const lines = candidate.replace(/\r\n?/g, '\n').split('\n');
+  const parentStart = lines.findIndex((line) => /^\s*-\s+Parent\s*$/.test(line));
+  if (parentStart >= 0) {
+    let parentEnd = lines.length;
+    for (let index = parentStart + 1; index < lines.length; index += 1) {
+      if (/^-\s+\S/.test(lines[index])) { parentEnd = index; break; }
+    }
+    for (let index = parentStart + 1; index < parentEnd; index += 1) {
+      lines[index] = lines[index].replace(/\]\(([^)]+::[^)]+)\)/g, (whole, target) => {
+        const normalized = normalizeMalformedWorkspaceQualifiedTarget(target);
+        if (!normalized || normalized === target) return whole;
+        parentReferenceChanged = true;
+        return `](${normalized})`;
+      });
+    }
+  }
+  if (parentReferenceChanged) {
+    candidate = lines.join('\n');
+    const integrityLines = candidate.replace(/\r\n?/g, '\n').split('\n');
+    const integrityStart = integrityLines.findIndex((line) => line.trim() === '# Continuity Integrity');
+    if (integrityStart >= 0) {
+      for (let index = integrityStart + 1; index < integrityLines.length; index += 1) {
+        integrityLines[index] = integrityLines[index].replace(/\]\(([^)]+::[^)]+)\)/g, (whole, target) => {
+          const normalized = normalizeMalformedWorkspaceQualifiedTarget(target);
+          return normalized && normalized !== target ? `](${normalized})` : whole;
+        });
+      }
+      candidate = integrityLines.join('\n');
+    }
+    diagnosticCodes.push('root.parent.recovery.workspace-qualified.malformed', 'portable.lineage-integrity.parent-unresolved');
+  }
+
+  const exactTarget = String(audit?.schemaValidationAuthority?.currentReference?.target || '').trim();
+  const schemaId = String(audit?.schemaId || '').trim();
+  const schemaWarning = (audit?.findings || []).some((item) => String(item?.code || '') === 'schema.reference.exact-target-omitted');
+  if (schemaWarning && schemaId && exactTarget && audit?.schemaValidationAuthority?.currentReference?.state === 'qualified') {
+    const schemaLines = candidate.replace(/\r\n?/g, '\n').split('\n');
+    const index = schemaLines.findIndex((line) => /^\s*-\s+Current Schema:\s*/.test(line));
+    if (index >= 0) {
+      const match = schemaLines[index].match(/^(\s*-\s+Current Schema:\s*)([^\s].*)$/);
+      const raw = String(match?.[2] || '').trim();
+      if (match && raw === schemaId) {
+        schemaLines[index] = `${match[1]}[${schemaId}](${exactTarget})`;
+        candidate = schemaLines.join('\n');
+        schemaReferenceChanged = true;
+        diagnosticCodes.push('schema.reference.exact-target-omitted');
+      }
+    }
+  }
+
+  if (!parentReferenceChanged && !schemaReferenceChanged) return freeze({ state: 'unavailable' });
+  const sealed = sealC14nV2Self(candidate);
+  if (sealed.state !== 'sealed' && sealed.state !== 'unchanged') return freeze({ state: 'unavailable' });
+  return freeze({ state: 'ready', markdown: String(sealed.markdown || candidate), parentReferenceChanged, schemaReferenceChanged, diagnosticCodes: [...new Set(diagnosticCodes)] });
+}
+
+function normalizeMalformedWorkspaceQualifiedTarget(value = '') {
+  const raw = String(value || '').trim();
+  if (classifyParentRecoveryReference(raw).kind !== 'malformed-workspace-qualified') return raw;
+  const stripped = raw.replace(/^(?:\.\.\/)+/, '').replace(/^\.\//, '');
+  return classifyParentRecoveryReference(stripped).kind === 'workspace-qualified' ? stripped : raw;
+}
+
+function hasQualifiedWorkspaceParentReference(markdown = '') {
+  const source = String(markdown || '');
+  const parentStart = source.split(/\r?\n/).findIndex((line) => /^\s*-\s+Parent\s*$/.test(line));
+  if (parentStart < 0) return false;
+  const lines = source.split(/\r?\n/);
+  let parentEnd = lines.length;
+  for (let index = parentStart + 1; index < lines.length; index += 1) if (/^-\s+\S/.test(lines[index])) { parentEnd = index; break; }
+  const targets = [];
+  for (let index = parentStart + 1; index < parentEnd; index += 1) {
+    for (const match of lines[index].matchAll(/\]\(([^)]+)\)/g)) targets.push(String(match[1] || ''));
+  }
+  return targets.some((target) => classifyParentRecoveryReference(target).kind === 'workspace-qualified');
+}
+
 function projectDiagnostic(finding = {}, markdown = '') {
   const located = locateFindingLine(finding, markdown);
   return freeze({