@tiinex/core 0.1.1

package/src/tooling/portable/draft/draft.set.js

@@ -0,0 +1,193 @@
+import { createPortableLocalDraft } from './draft.create.js';
+import { prepareEpistemicMaterialization } from '../materialization/epistemic.plan.js';
+import { portableFinding, summarizePortableFindings } from '../findings.js';
+import { normalizePortableInput } from '../input/portable.input.js';
+import { resolveLineage } from '../../../lineage/lineage.resolve.js';
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+
+export const PORTABLE_ARTIFACT_SET_CREATION_SCHEMA_ID = 'tiinex.portable.artifact-set-creation.v1';
+
+export function createPortableLocalArtifactSet(input = {}, options = {}) {
+  const planResult = input.plan?.schema === 'tiinex.portable.epistemic-materialization-plan.v1'
+    ? input.plan
+    : prepareEpistemicMaterialization(input, options);
+  const findings = [...(planResult.findings || [])];
+  if (planResult.status !== 'ready') {
+    findings.push(portableFinding('error', 'portable.artifact-set.plan.not-ready', 'Artifact-set creation requires a ready epistemic materialization plan.', { planStatus: planResult.status }));
+    return finalize('blocked', planResult, [], findings, emptyLineageClosure());
+  }
+
+  const created = [];
+  const byProposal = new Map();
+  for (const proposal of planResult.proposals) {
+    const parentRecord = proposal.parentKind === 'proposal'
+      ? createdParent(byProposal.get(proposal.parent?.proposalId), proposal.path, proposal.parent?.proposalId)
+      : proposal.parentKind === 'loaded-record'
+        ? parentForChild(proposal.parent, proposal.path)
+        : {};
+    if (proposal.parentKind === 'proposal' && !parentRecord.id) {
+      findings.push(portableFinding('error', 'portable.artifact-set.parent.proposal-unavailable', 'An earlier proposal did not produce a usable Parent artifact.', { proposalId: proposal.id, parentProposalId: proposal.parent?.proposalId || '' }));
+      break;
+    }
+    const result = createPortableLocalDraft({
+      ...(input.materials ? { materials: input.materials } : input),
+      schemaId: proposal.schemaId,
+      id: proposal.id,
+      path: proposal.path,
+      title: proposal.title,
+      summary: proposal.summary,
+      why: proposal.why || proposal.rationale,
+      values: proposal.values,
+      sections: proposal.sections,
+      bodyMarkdown: proposal.bodyMarkdown,
+      createdAt: proposal.createdAt || input.createdAt || options.createdAt,
+      schemaReferences: proposal.schemaReferences || input.schemaReferences || null,
+      transitionType: proposal.creationContract?.transitionType || (proposal.parentKind ? 'continue-from-record' : 'create-artifact'),
+      parentRecord
+    }, options);
+    findings.push(...(result.findings || []));
+    const entry = Object.freeze({
+      proposalId: proposal.id,
+      parentProposalId: proposal.parentKind === 'proposal' ? proposal.parent?.proposalId || '' : '',
+      parentLoadedRef: proposal.parentKind === 'loaded-record' ? proposal.parent?.path || proposal.parent?.id || '' : '',
+      result
+    });
+    created.push(entry);
+    byProposal.set(proposal.id, entry);
+    if (!usableCreation(result)) {
+      findings.push(portableFinding('error', 'portable.artifact-set.creation.not-clean', 'Artifact-set creation stopped because one proposal did not produce a clean local artifact.', { proposalId: proposal.id, status: result.status }));
+      break;
+    }
+  }
+
+  const complete = created.length === planResult.proposals.length && created.every((entry) => usableCreation(entry.result));
+  const localContinuity = complete && created.some((entry) => entry.result.qualification?.localContinuityUsable === true);
+  const status = complete ? localContinuity ? 'created-local-continuity' : 'created-clean' : 'blocked';
+  return finalize(status, planResult, created, findings, buildLineageClosure(input, planResult, created));
+}
+
+function finalize(status, plan, created, findings, lineageClosure) {
+  const summary = summarizePortableFindings(findings);
+  return Object.freeze({
+    schema: PORTABLE_ARTIFACT_SET_CREATION_SCHEMA_ID,
+    status,
+    plan,
+    artifacts: Object.freeze(created.map((entry, index) => Object.freeze({
+      order: index + 1,
+      proposalId: entry.proposalId,
+      parentProposalId: entry.parentProposalId,
+      parentLoadedRef: entry.parentLoadedRef,
+      draft: entry.result.draft,
+      validation: entry.result.validation,
+      qualification: entry.result.qualification
+    }))),
+    lineageClosure,
+    boundary: Object.freeze({
+      localOutput: true,
+      sourceMutation: false,
+      remoteWrite: false,
+      parentFromLoadedOrEarlierProposalOnly: true,
+      schemaSelectionValidatedThroughSharedRegistry: true
+    }),
+    findings: Object.freeze(findings),
+    findingSummary: summary
+  });
+}
+
+function createdParent(entry, childPath = '', proposalId = '') {
+  const draft = entry?.result?.draft;
+  if (!draft || !usableCreation(entry.result)) return {};
+  const parsed = safeParse(draft.markdown);
+  const currentSchema = parsed?.envelope?.current?.schema || {};
+  return parentForChild({
+    id: draft.id || proposalId,
+    path: draft.path,
+    kind: draft.schemaId,
+    schemaId: draft.schemaId,
+    createdAt: draft.createdAt,
+    schemaReferenceAuthority: currentSchema.target ? {
+      schemaId: currentSchema.id || draft.schemaId,
+      preferredTarget: currentSchema.target,
+      exactTargets: [currentSchema.target],
+      resolutionState: 'qualified',
+      evidence: { source: 'earlier-proposal-rendered-current-schema-reference' }
+    } : null,
+    boundary: 'portable local artifact set; no remote source provenance inferred',
+    sourceMode: draft.sourceMode,
+    source: null,
+    markdown: String(draft.markdown || ''),
+    integrity: parsed?.integrity || null
+  }, childPath);
+}
+
+function parentForChild(parent = {}, childPath = '') {
+  void childPath;
+  return Object.freeze({ ...parent, continuationTrace: '' });
+}
+
+function usableCreation(result = {}) {
+  return Boolean(result?.draft && (result.status === 'created-clean' || result.qualification?.localContinuityUsable === true));
+}
+
+function safeParse(markdown = '') {
+  try { return parseArtifactMarkdown(markdown); }
+  catch { return null; }
+}
+
+
+function buildLineageClosure(input = {}, plan = {}, created = []) {
+  const material = normalizePortableInput(input.materials || input);
+  const records = (material.records || []).filter((record) => record.path && record.markdown && (record.hasContinuityContext || record.schemaId || String(record.kind || '').startsWith('tiinex.')));
+  const lineage = resolveLineage(records, { depth: 'portable-artifact-set-closure' });
+  const nodeById = new Map((lineage.nodes || []).map((node) => [node.id, node]));
+  const nodesByPath = new Map((lineage.nodes || []).map((node) => [String(node.path || ''), node]));
+  const selected = new Set();
+  const queue = [];
+  for (const proposal of plan.proposals || []) {
+    if (proposal.parentKind !== 'loaded-record') continue;
+    const node = nodesByPath.get(String(proposal.parent?.path || '')) || nodeById.get(String(proposal.parent?.id || ''));
+    if (node) queue.push(node.id);
+  }
+  while (queue.length) {
+    const id = queue.shift();
+    if (!id || selected.has(id)) continue;
+    selected.add(id);
+    for (const edge of lineage.edges || []) if (edge.kind === 'parent' && edge.to === id && edge.from) queue.push(edge.from);
+  }
+  const context = [...selected].map((id) => nodeById.get(id)).filter(Boolean).map((node) => Object.freeze({
+    id: node.id,
+    path: node.path,
+    schemaId: node.schemaId,
+    markdown: String(node.record?.markdown || ''),
+    trace: String(node.trace || ''),
+    parentSchemaId: String(node.parentSchemaId || ''),
+    sourceMode: String(node.sourceMode || ''),
+    boundary: String(node.boundary || '')
+  })).sort((a, b) => a.path.localeCompare(b.path));
+  const createdByProposal = new Map(created.map((entry) => [entry.proposalId, entry.result?.draft]));
+  const edges = [];
+  for (const edge of lineage.edges || []) {
+    if (edge.kind !== 'parent' || !edge.from || !edge.to || !selected.has(edge.to) || !selected.has(edge.from)) continue;
+    const parent = nodeById.get(edge.from);
+    const child = nodeById.get(edge.to);
+    if (parent?.path && child?.path) edges.push(Object.freeze({ childPath: child.path, parentPath: parent.path, parentKind: 'loaded-context' }));
+  }
+  for (const proposal of plan.proposals || []) {
+    const child = createdByProposal.get(proposal.id);
+    if (!child?.path) continue;
+    if (proposal.parentKind === 'proposal') {
+      const parent = createdByProposal.get(proposal.parent?.proposalId);
+      if (parent?.path) edges.push(Object.freeze({ childPath: child.path, parentPath: parent.path, parentKind: 'created-in-set' }));
+    } else if (proposal.parentKind === 'loaded-record' && proposal.parent?.path) {
+      edges.push(Object.freeze({ childPath: child.path, parentPath: proposal.parent.path, parentKind: 'loaded-context' }));
+    }
+  }
+  return Object.freeze({
+    schema: 'tiinex.portable.lineage-closure.v1',
+    context: Object.freeze(context),
+    edges: Object.freeze(uniqueEdges(edges)),
+    boundary: 'Minimum loaded Parent closure for changed artifacts. Context remains unchanged and carries exact loaded Markdown bytes.'
+  });
+}
+function emptyLineageClosure() { return Object.freeze({ schema: 'tiinex.portable.lineage-closure.v1', context: Object.freeze([]), edges: Object.freeze([]), boundary: 'No ready artifact plan.' }); }
+function uniqueEdges(edges = []) { const map = new Map(); for (const edge of edges) map.set(`${edge.childPath}\0${edge.parentPath}`, edge); return [...map.values()].sort((a, b) => `${a.childPath}\0${a.parentPath}`.localeCompare(`${b.childPath}\0${b.parentPath}`)); }

package/src/tooling/portable/draft/draft.validation-context.js

@@ -0,0 +1,7 @@
+export function creationSchemaReferenceValidationContext(exactContract = {}, parentRecord = null) {
+  return Object.freeze({
+    envelope: exactContract?.schemaReferences?.envelope || null,
+    current: exactContract?.schemaReferences?.current || null,
+    parent: parentRecord?.schemaReferenceAuthority || null
+  });
+}

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

@@ -0,0 +1,37 @@
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+import { auditPortableRecord } from '../audit/audit.capability.js';
+
+export const PORTABLE_AUTHORING_PARENT_SCHEMA_ID = 'tiinex.portable.authoring-parent.v1';
+
+export function projectPortableAuthoringParent(input = {}) {
+  const records = normalizeRecords(input);
+  if (records.length !== 1) return freeze({ schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID, status: 'blocked', parentRecord: null, findings: [{ severity: 'error', code: 'portable.authoring-parent.exactly-one-required', message: 'Authoring Parent projection requires exactly one local text artifact.' }], operationBoundary: boundary() });
+  const record = records[0];
+  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 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 || '');
+  return freeze({
+    schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID,
+    status: 'ready',
+    parentRecord: {
+      id: String(record.path || record.id || ''), path: String(record.path || record.id || ''), schemaId, currentSchemaId: schemaId, currentCreatedAt: createdAt,
+      markdown: record.markdown, sourceMode: String(record.sourceMode || 'portable-node-local'),
+      schemaReferenceAuthority: { schemaId, preferredTarget: schemaTarget, exactTargets: schemaTarget ? [schemaTarget] : [], resolutionState: 'unresolved', evidence: { basis: 'declared-current-schema-reference-only' } }
+    },
+    findings: [],
+    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.'
+  });
+}
+
+function normalizeRecords(input = {}) {
+  if (Array.isArray(input.records)) return input.records;
+  return (Array.isArray(input.files) ? input.files : []).filter((item) => typeof item?.content === 'string').map((item) => ({ id: String(item.path || ''), path: String(item.path || ''), markdown: String(item.content || ''), sourceMode: item.sourceMode || '' }));
+}
+function boundary() { return { sourceMutation: false, remoteWrite: false, authoring: false }; }
+function freeze(value) { if (Array.isArray(value)) return Object.freeze(value.map(freeze)); if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value; return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, freeze(item)]))); }

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

@@ -0,0 +1,221 @@
+import { auditPortableRecord } from '../audit/audit.capability.js';
+import { C14N_V2_METHOD_ID, canonicalC14nV2SelfState, sealC14nV2Self } from '../../../integrity/integrity.c14nV2.js';
+import { sha256Hex } from '../../../export/package.bytes.js';
+import { integrityMethodReferenceAuthorityForCreation } from '../../../integrity/integrity.methodReference.js';
+import { inspectPortableLineageIntegrity } from '../lineage/lineage.integrity.plan.js';
+import { portableFinding } from '../findings.js';
+
+export const PORTABLE_EDITOR_ASSISTANCE_SCHEMA_ID = 'tiinex.portable.editor-assistance.v1';
+
+export function projectPortableEditorAssistance(input = {}) {
+  const records = normalizeRecords(input);
+  const focusPath = norm(input.focusPath || input.focus || '');
+  const selectedRecords = focusPath ? records.filter((record) => norm(record.path || record.id || '') === focusPath) : records;
+  const lineageInspection = inspectPortableLineageIntegrity({ records });
+  const documents = selectedRecords.map((record) => projectDocument(record, records, lineageInspection));
+  const diagnostics = documents.flatMap((item) => item.diagnostics);
+  return freeze({
+    schema: PORTABLE_EDITOR_ASSISTANCE_SCHEMA_ID,
+    status: diagnostics.some((item) => item.severity === 'error') ? 'invalid' : diagnostics.some((item) => item.severity === 'warning') ? 'degraded' : 'clean',
+    documents,
+    operationBoundary: { sourceMutation: false, remoteWrite: false, automaticRepair: false },
+    boundary: 'Adapter-neutral projection of exact shared audit/validator findings plus only deterministic byte replacements. Presentation adapters must not invent finding severity, validator choice, source line, or repair content.'
+  });
+}
+
+function projectDocument(record = {}, records = [], lineageInspection = null) {
+  const audit = auditPortableRecord(record, { requireExactSchemaAuthority: true });
+  const markdown = String(record.markdown || '');
+  const recordPath = norm(record.path || record.id || '');
+  const lineageFindings = findingsForPath(lineageInspection?.findings || [], recordPath);
+  const referenceFindings = schemaReferenceCompositionFindings(audit, recordPath);
+  const sharedFindings = [...(audit.findings || []), ...lineageFindings, ...referenceFindings];
+  const diagnostics = sharedFindings
+    .filter((item) => item.severity === 'error' || item.severity === 'warning')
+    .map((finding) => projectDiagnostic(finding, markdown));
+  const actions = [];
+  const integrityRepair = deterministicIntegrityHygieneRepair(markdown, audit.findings || []);
+  const repairQualification = integrityRepair.state === 'ready'
+    ? qualifyReplacementAgainstSharedGuardrails(record, records, integrityRepair.markdown)
+    : { state: 'unavailable' };
+  if (integrityRepair.state === 'ready' && integrityRepair.markdown !== markdown && repairQualification.state === 'qualified') actions.push(freeze({
+    id: 'refresh-primary-self-integrity',
+    title: integrityRepair.methodReferenceChanged ? 'Refresh Tiinex integrity references and self seal' : 'Refresh Tiinex c14n-v2 self integrity',
+    kind: 'replace-document',
+    qualification: 'deterministic-shared-core',
+    sourceSha256: sha256Hex(new TextEncoder().encode(markdown)),
+    replacementMarkdown: integrityRepair.markdown,
+    diagnosticCodes: integrityRepair.diagnosticCodes,
+    boundary: integrityRepair.methodReferenceChanged
+      ? 'Rebinds only unqualified c14n-v2 footer method links to the shared qualified maintained target and reseals the existing primary self Value; the replacement is exposed only after the same shared audit and lineage guardrails re-qualify the focused artifact and every loaded digest-bound descendant.'
+      : 'Refreshes only the existing primary c14n-v2 self Value through the shared integrity algorithm; the replacement is exposed only after the same shared audit and lineage guardrails re-qualify the focused artifact and every loaded digest-bound descendant.'
+  }));
+  const validationAuthority = audit.schemaValidationAuthority || null;
+  return freeze({
+    path: String(record.path || record.id || ''),
+    schemaId: String(audit.schemaId || ''),
+    validator: {
+      state: audit.qualification?.exact && validationAuthority?.state === 'qualified' ? 'qualified-exact' : 'degraded',
+      requestedSchema: String(audit.qualification?.requestedSchema || audit.schemaId || ''),
+      resolvedThrough: String(audit.qualification?.resolvedThrough || ''),
+      fallbackUsed: Boolean(audit.qualification?.fallback?.used),
+      authorityState: String(validationAuthority?.state || 'unavailable'),
+      authorityBasis: String(validationAuthority?.currentReference?.basis || ''),
+      authorityFindings: [...(validationAuthority?.findings || [])]
+    },
+    diagnostics,
+    actions
+  });
+}
+
+function schemaReferenceCompositionFindings(audit = {}, recordPath = '') {
+  const envelope = audit?.parsed?.envelope || {};
+  const references = [
+    { field: 'Envelope Schema', value: envelope.envelopeSchema || {} },
+    { field: 'Current Schema', value: envelope.current?.schema || {} },
+    { field: 'Parent Schema', value: envelope.parent?.schema || {} }
+  ].filter((entry) => String(entry.value?.id || '').trim());
+  const exactPublishedStyle = references.some((entry) => entry.value?.form === 'markdown-link' && /^https:\/\/github\.com\/[^/]+\/[^/]+\/blob\/[0-9a-f]{40}\//i.test(String(entry.value?.target || '')));
+  if (!exactPublishedStyle) return [];
+  const findings = [];
+  for (const entry of references) {
+    if (entry.value?.form !== 'plain-schema-id') continue;
+    const schemaId = String(entry.value?.id || '').trim();
+    findings.push(portableFinding('warning', 'portable.editor.schema-reference.canonical-target-available', `${entry.field} uses only a schema id while the same artifact otherwise uses exact immutable schema locators. This mixed representation requires explicit qualification instead of being treated as clean.`, {
+      ref: recordPath,
+      params: { field: entry.field, schemaId },
+      fixability: 'manual-or-holistic-repair-required'
+    }));
+  }
+  return findings;
+}
+
+function findingsForPath(findings = [], path = '') {
+  const wanted = norm(path);
+  return (findings || []).filter((finding) => norm(finding?.evidencePath || finding?.ref || '') === wanted);
+}
+
+function qualifyReplacementAgainstSharedGuardrails(record = {}, records = [], replacementMarkdown = '') {
+  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 || []), ...schemaReferenceCompositionFindings(replacementAudit, focusPath)].filter((item) => item.severity === 'error' || item.severity === 'warning');
+  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');
+  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 projectDiagnostic(finding = {}, markdown = '') {
+  const located = locateFindingLine(finding, markdown);
+  return freeze({
+    severity: String(finding.severity || 'warning'),
+    code: String(finding.code || 'tiinex.validation.finding'),
+    message: String(finding.message || 'Tiinex validation finding.'),
+    fixability: String(finding.fixability || 'unknown'),
+    line: located.line,
+    locationState: located.state,
+    locationBasis: located.basis
+  });
+}
+
+export function locateFindingLine(finding = {}, markdown = '') {
+  const lines = String(markdown || '').replace(/\r\n?/g, '\n').split('\n');
+  const params = finding.params || finding;
+  const field = String(params.field || '').trim();
+  const section = String(params.section || '').trim();
+  const heading = String(params.heading || '').replace(/^#{1,6}\s+/, '').trim();
+  const group = String(params.group || '').trim();
+  if (field) {
+    const index = lines.findIndex((line) => new RegExp(`^\\s*-\\s+${escapeRegExp(field)}\\s*:`).test(line));
+    if (index >= 0) return freeze({ state: 'deterministic', line: index + 1, basis: `field:${field}` });
+  }
+  for (const owner of [section, heading, group].filter(Boolean)) {
+    const sectionIndex = lines.findIndex((line) => new RegExp(`^#{2,6}\\s+${escapeRegExp(owner)}\\s*$`, 'i').test(line));
+    if (sectionIndex >= 0) return freeze({ state: section || heading ? 'deterministic' : 'deterministic-anchor', line: sectionIndex + 1, basis: `${section || heading ? 'section' : 'owning-section'}:${owner}` });
+    const envelopeIndex = lines.findIndex((line) => new RegExp(`^\\s*-\\s+${escapeRegExp(owner)}(?:\\s*:.*)?\\s*$`, 'i').test(line));
+    if (envelopeIndex >= 0) return freeze({ state: 'deterministic-anchor', line: envelopeIndex + 1, basis: `envelope-owner:${owner}` });
+  }
+  const code = String(finding.code || '');
+  if (code.includes('schema.') || code.endsWith('.schema.mismatch') || code === 'audit.schema-authority.unqualified') {
+    const index = lines.findIndex((line) => /^\s*-\s+Current Schema\s*:/.test(line));
+    if (index >= 0) return freeze({ state: 'deterministic', line: index + 1, basis: 'current-schema-field' });
+  }
+  if (code === 'integrity.method-reference.unqualified') {
+    const headingIndex = lines.findIndex((line) => line.trim() === '# Continuity Integrity');
+    const methodIndex = lines.findIndex((line, index) => index > headingIndex && /^\s*-\s+\[sha256-base64url-c14n-v2\]\([^)]+\)\s*$/.test(line));
+    if (methodIndex >= 0) return freeze({ state: 'deterministic', line: methodIndex + 1, basis: 'continuity-integrity-method-reference' });
+  }
+  if (code.includes('integrity') || /integrity|checksum|digest/i.test(String(finding.message || ''))) {
+    const headingIndex = lines.findIndex((line) => line.trim() === '# Continuity Integrity');
+    if (headingIndex >= 0) {
+      const index = lines.findIndex((line, i) => i > headingIndex && /^\s+-\s+Value\s*:/.test(line));
+      if (index >= 0) return freeze({ state: 'deterministic', line: index + 1, basis: 'continuity-integrity-value' });
+      return freeze({ state: 'deterministic-anchor', line: headingIndex + 1, basis: 'continuity-integrity-heading' });
+    }
+  }
+  if (/^(portable\.contract\.|root\.|integrity\.)/i.test(code) && (/missing|required|incomplete/i.test(code) || /\bmissing\b|\brequired\b/i.test(String(finding.message || '')))) {
+    const bodyHeading = lines.findIndex((line) => /^#\s+\S/.test(line) && !/^#\s+Continuity (?:Context|Integrity)\s*$/.test(line));
+    if (bodyHeading >= 0) return freeze({ state: 'deterministic-anchor', line: bodyHeading + 1, basis: section ? `body-heading-for-missing-section:${section}` : field ? `body-heading-for-missing-field:${field}` : 'body-heading-for-missing-required-content' });
+    const contextHeading = lines.findIndex((line) => line.trim() === '# Continuity Context');
+    if (contextHeading >= 0) return freeze({ state: 'deterministic-anchor', line: contextHeading + 1, basis: 'continuity-context-for-missing-required-content' });
+  }
+  if (/\.body\.|body/i.test(code) || /\bbody\b/i.test(String(finding.message || ''))) {
+    const bodyHeading = lines.findIndex((line) => /^#\s+\S/.test(line) && !/^#\s+Continuity (?:Context|Integrity)\s*$/.test(line));
+    if (bodyHeading >= 0) return freeze({ state: 'deterministic-anchor', line: bodyHeading + 1, basis: 'body-heading-for-body-finding' });
+  }
+  return freeze({ state: 'unresolved', line: null, basis: 'shared-finding-has-no-deterministic-line-evidence' });
+}
+
+function deterministicIntegrityHygieneRepair(markdown = '', findings = []) {
+  const source = String(markdown || '');
+  const codes = new Set((findings || []).map((item) => String(item?.code || '')));
+  const authority = integrityMethodReferenceAuthorityForCreation(C14N_V2_METHOD_ID);
+  const preferredTarget = authority?.resolutionState === 'qualified' ? String(authority?.preferredTarget || '') : '';
+  const exactTargets = new Set((authority?.exactTargets || []).map((item) => String(item || '')));
+  let methodReferenceChanged = false;
+  let repaired = source;
+  if (codes.has('integrity.method-reference.unqualified') && preferredTarget) {
+    const lines = source.replace(/\r\n?/g, '\n').split('\n');
+    const heading = lines.findIndex((line) => line.trim() === '# Continuity Integrity');
+    if (heading >= 0) {
+      for (let index = heading + 1; index < lines.length; index += 1) {
+        if (/^#\s+/.test(lines[index])) break;
+        const match = lines[index].match(/^(\s*-\s+)\[sha256-base64url-c14n-v2\]\(([^)]+)\)(\s*)$/);
+        if (!match || exactTargets.has(match[2])) continue;
+        lines[index] = `${match[1]}[${C14N_V2_METHOD_ID}](${preferredTarget})${match[3]}`;
+        methodReferenceChanged = true;
+      }
+      if (methodReferenceChanged) repaired = lines.join('\n');
+    }
+  }
+
+  const integrity = canonicalC14nV2SelfState(repaired);
+  const requiresSeal = methodReferenceChanged || integrity.state === 'mismatch' || integrity.state === 'prepared';
+  if (!requiresSeal) return freeze({ state: 'unavailable', markdown: source, methodReferenceChanged: false, diagnosticCodes: [] });
+  const sealed = sealC14nV2Self(repaired);
+  if (sealed.state !== 'sealed') return freeze({ state: 'unavailable', markdown: source, methodReferenceChanged, diagnosticCodes: [] });
+  const diagnosticCodes = [
+    ...(methodReferenceChanged ? ['integrity.method-reference.unqualified'] : []),
+    'integrity.c14n-v2.mismatch',
+    'integrity.c14n-v2.ambiguous'
+  ];
+  return freeze({ state: 'ready', markdown: sealed.markdown, methodReferenceChanged, diagnosticCodes: [...new Set(diagnosticCodes)] });
+}
+
+function norm(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+|\/+$/g, ''); }
+function escapeRegExp(value = '') { return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function freeze(value) { if (Array.isArray(value)) return Object.freeze(value.map(freeze)); if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value; return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, freeze(item)]))); }
+
+function normalizeRecords(input = {}) {
+  if (Array.isArray(input.records)) return input.records;
+  return (Array.isArray(input.files) ? input.files : []).filter((item) => typeof item?.content === 'string').map((item) => Object.freeze({ id: String(item.path || ''), path: String(item.path || ''), markdown: String(item.content || ''), sourceMode: item.sourceMode || '' }));
+}

package/src/tooling/portable/editor/staged.validation.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+import { projectPortableEditorAssistance } from './editor.assistance.js';
+import { auditPortableRecord } from '../audit/audit.capability.js';
+
+export const PORTABLE_STAGED_VALIDATION_SCHEMA_ID = 'tiinex.portable.staged-validation.v1';
+
+export function projectPortableStagedValidation(input = {}) {
+  const records = normalizeRecords(input);
+  const byPath = new Map(records.map((record) => [norm(record.path), record]).filter(([recordPath]) => recordPath));
+  const stagedPaths = unique((input.stagedPaths || input.paths || []).map(norm).filter(Boolean));
+  const stagedTiinexPaths = [];
+  const ignoredStagedPaths = [];
+
+  for (const stagedPath of stagedPaths) {
+    const record = byPath.get(stagedPath);
+    if (record && isTiinexArtifact(record.markdown)) stagedTiinexPaths.push(stagedPath);
+    else ignoredStagedPaths.push(stagedPath);
+  }
+
+  const closure = new Set(stagedTiinexPaths);
+  const queue = [...stagedTiinexPaths];
+  while (queue.length) {
+    const currentPath = queue.shift();
+    const record = byPath.get(currentPath);
+    const parentPath = record ? localParentPath(currentPath, record.markdown) : '';
+    if (!parentPath || closure.has(parentPath) || !byPath.has(parentPath)) continue;
+    closure.add(parentPath);
+    queue.push(parentPath);
+  }
+
+  const validationRecords = records.filter((record) => closure.has(norm(record.path)) || /\.schema\.md$/i.test(norm(record.path)));
+  const documents = [];
+  const findings = [];
+  for (const focusPath of [...closure].sort()) {
+    const scope = stagedTiinexPaths.includes(focusPath) ? 'staged' : 'required-closure';
+    const record = byPath.get(focusPath);
+    let document;
+    if (/\.schema\.md$/i.test(focusPath) && record) {
+      const audit = auditPortableRecord(record);
+      document = {
+        path: focusPath,
+        schemaId: audit.schemaId || '',
+        validator: { state: audit.qualification?.exact === true ? 'qualified-exact-schema-definition' : 'unqualified-schema-definition' },
+        diagnostics: (audit.findings || []).filter((item) => item.severity !== 'info').map((item) => ({ ...item, line: null, locationState: 'unresolved', locationBasis: 'schema-definition-audit' }))
+      };
+    } else {
+      const projected = projectPortableEditorAssistance({ records: validationRecords, focusPath });
+      document = projected.documents?.[0];
+    }
+    if (!document) {
+      findings.push(finding('error', 'portable.staged-validation.document.unprojected', 'Shared validation could not project a staged or required-closure Tiinex artifact.', { path: focusPath, scope }));
+      continue;
+    }
+    const diagnostics = (document.diagnostics || []).map((diagnostic) => freeze({ ...diagnostic, path: focusPath, scope }));
+    documents.push(freeze({ path: focusPath, scope, schemaId: document.schemaId || '', validator: document.validator || null, diagnostics }));
+    for (const diagnostic of diagnostics) findings.push(finding(diagnostic.severity || 'warning', diagnostic.code || 'portable.staged-validation.diagnostic', diagnostic.message || 'Shared validation finding.', { path: focusPath, scope, line: diagnostic.line ?? null, locationState: diagnostic.locationState || 'unresolved', locationBasis: diagnostic.locationBasis || '' }));
+  }
+
+  const blockingFindings = findings.filter((item) => item.severity === 'error' || item.severity === 'warning');
+  const state = stagedTiinexPaths.length === 0 ? 'no-staged-tiinex' : blockingFindings.length ? 'blocked' : 'clean';
+  return freeze({
+    schema: PORTABLE_STAGED_VALIDATION_SCHEMA_ID,
+    status: state === 'blocked' ? 'blocked' : 'ready',
+    state,
+    stagedPaths,
+    stagedTiinexPaths,
+    ignoredStagedPaths,
+    closurePaths: [...closure].sort(),
+    documents,
+    findings,
+    blockingFindingCount: blockingFindings.length,
+    operationBoundary: { sourceMutation: false, remoteWrite: false, gitMutation: false },
+    boundary: 'Validates only explicit staged Tiinex artifacts plus their required loaded local Parent closure. Unrelated non-staged defects are outside the gate; non-staged material may participate only as required validation authority or Parent closure.'
+  });
+}
+
+function normalizeRecords(input = {}) {
+  if (Array.isArray(input.records)) return input.records.map((record) => freeze({ ...record, path: norm(record.path || record.id || ''), markdown: String(record.markdown || record.content || '') }));
+  return (Array.isArray(input.files) ? input.files : []).filter((item) => typeof item?.content === 'string').map((item) => freeze({ id: norm(item.path || ''), path: norm(item.path || ''), markdown: String(item.content || ''), sourceMode: item.sourceMode || '' }));
+}
+function isTiinexArtifact(markdown = '') {
+  try { return Boolean(String(parseArtifactMarkdown(markdown)?.envelope?.current?.schema?.id || '').trim()); }
+  catch { return false; }
+}
+function localParentPath(childPath = '', markdown = '') {
+  try {
+    const trace = String(parseArtifactMarkdown(markdown)?.envelope?.parent?.trace || '').trim();
+    if (!trace || /^(?:https?:|github:|raw:)/i.test(trace)) return '';
+    return norm(path.posix.join(path.posix.dirname(norm(childPath)), trace.replace(/\\/g, '/')));
+  } catch { return ''; }
+}
+function unique(values = []) { return [...new Set(values)]; }
+function norm(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+|\/+$/g, ''); }
+function finding(severity, code, message, context = {}) { return freeze({ severity, code, message, context }); }
+function freeze(value) { if (Array.isArray(value)) return Object.freeze(value.map(freeze)); if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value; return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, freeze(item)]))); }