@tiinex/core 0.1.1

package/src/tooling/portable/schema/ordinary.contract.js

@@ -0,0 +1,193 @@
+export function compileOrdinaryFieldAuthority(document = {}) {
+  const groups = document?.validation?.groups || [];
+  const targeting = groups.find((group) => exactToken(group.name) === 'Ordinary Instance Field Targeting');
+  const override = groups.find((group) => exactToken(group.name) === 'Instance Target');
+  if (!targeting || !override) return null;
+
+  const targetingRules = categoryItems(targeting, ['Rules']).map(exactToken);
+  const overrideRules = categoryItems(override, ['Rules']).map(exactToken);
+  const overrideShape = categoryItems(override, ['Required Shape']).map(cleanToken);
+  const hasDefault = targetingRules.includes('Unless an ordinary instance-field group declares `Instance Target`, its Artifact instance target is the exact second-level heading whose text equals the contract group name.');
+  const hasLocalOwnership = targetingRules.includes('Ordinary field occurrences are owned only by their authorized target block. Fields inside a nested heading or named-declaration-owned region are not claimed by an ancestor ordinary group merely because the label matches.');
+  const hasSingularOverride = overrideRules.includes('`Instance Target` is singular; it must not be used as a list of multiple Artifact targets.');
+  const hasLiteralHeadingShape = overrideShape.includes('one literal Markdown heading token');
+  if (!hasDefault || !hasLocalOwnership || !hasSingularOverride || !hasLiteralHeadingShape) return null;
+
+  return Object.freeze({
+    state: 'available',
+    sourceSchemaId: document?.schemaId || '',
+    defaultTarget: 'exact-second-level-same-name',
+    overrideCategory: 'Instance Target',
+    overrideShape: 'one-literal-markdown-heading-token',
+    rules: Object.freeze([...targetingRules, ...overrideRules])
+  });
+}
+
+export function mergeOrdinaryFieldAuthorities(authorities = []) {
+  const available = authorities.filter((authority) => authority?.state === 'available');
+  if (!available.length) return Object.freeze({ state: 'unavailable', sources: Object.freeze([]) });
+  const signatures = unique(available.map((authority) => `${authority.defaultTarget}\u0000${authority.overrideCategory}\u0000${authority.overrideShape}`));
+  if (signatures.length !== 1) {
+    return Object.freeze({
+      state: 'contradictory',
+      sources: Object.freeze(unique(available.map((authority) => authority.sourceSchemaId))),
+      findings: Object.freeze(['Ordinary instance-field authority declarations disagree.'])
+    });
+  }
+  return Object.freeze({
+    state: 'available',
+    sources: Object.freeze(unique(available.map((authority) => authority.sourceSchemaId))),
+    defaultTarget: available[0].defaultTarget,
+    overrideCategory: available[0].overrideCategory,
+    overrideShape: available[0].overrideShape
+  });
+}
+
+export function compileOrdinaryInstanceFieldGroups({ groups = [], declarations = [], requiredSections = [], requiredHeadings = [], optionalSections = [], authority = null } = {}) {
+  if (authority?.state !== 'available') return Object.freeze([]);
+  const declarationGroups = new Set((declarations || []).map((item) => exactToken(item.group)));
+  const requiredTargets = new Set((requiredSections || []).map(exactToken));
+  const optionalTargets = new Set((optionalSections || []).map(exactToken));
+  const out = [];
+
+  const authoritySources = new Set(authority.sources || []);
+  for (const group of groups || []) {
+    if (!isOrdinaryInstanceFieldGroup(group, declarationGroups, authoritySources)) continue;
+    const contributors = (group.contributors?.length ? group.contributors : [group])
+      .map((contribution) => compileOrdinaryContribution(contribution, authority));
+    const target = reconcileOrdinaryTargets(contributors, requiredTargets, optionalTargets, requiredHeadings);
+    const requiredFields = unique(contributors.flatMap((item) => item.requiredFields || []));
+    const requiredKeys = new Set(requiredFields.map(exactToken));
+    const optionalFields = unique(contributors.flatMap((item) => item.optionalFields || []))
+      .filter((field) => !requiredKeys.has(exactToken(field)));
+    out.push(Object.freeze({
+      group: group.name,
+      qualification: target.qualification,
+      target,
+      requiredFields: Object.freeze(requiredFields),
+      optionalFields: Object.freeze(optionalFields),
+      contributors: Object.freeze(contributors)
+    }));
+  }
+  return Object.freeze(out);
+}
+
+export function compileOrdinaryGroupContribution(group = {}, authority = null) {
+  if (authority?.state !== 'available') return null;
+  const requiredFields = categoryItems(group, ['Required Fields']).map(cleanToken);
+  const optionalFields = categoryItems(group, ['Optional Fields']).map(cleanToken);
+  if (!requiredFields.length && !optionalFields.length) return null;
+  if (categoryItems(group, ['Entry Shape']).length) return null;
+  if ([...requiredFields, ...optionalFields].some((field) => !isOrdinaryUnqualifiedField(field))) return null;
+  return compileOrdinaryContribution(group, authority);
+}
+
+function isOrdinaryInstanceFieldGroup(group = {}, declarationGroups = new Set(), authoritySources = new Set()) {
+  if (declarationGroups.has(exactToken(group.name))) return false;
+  const contributors = group.contributors?.length ? group.contributors : [group];
+  if (contributors.length && contributors.every((item) => authoritySources.has(String(item.sourceSchemaId || '')))) return false;
+  const requiredFields = categoryItems(group, ['Required Fields']).map(cleanToken);
+  const optionalFields = categoryItems(group, ['Optional Fields']).map(cleanToken);
+  if (!requiredFields.length && !optionalFields.length) return false;
+  if (categoryItems(group, ['Entry Shape']).length) return false;
+  if ([...requiredFields, ...optionalFields].some((field) => !isOrdinaryUnqualifiedField(field))) return false;
+  return true;
+}
+
+function isOrdinaryUnqualifiedField(field = '') {
+  const token = cleanToken(field);
+  return Boolean(token) && !token.includes('->') && !/^#{1,6}\s+/.test(token);
+}
+
+function compileOrdinaryContribution(group = {}, authority = {}) {
+  const requiredFields = categoryItems(group, ['Required Fields']).map(cleanToken).filter(isOrdinaryUnqualifiedField);
+  const optionalFields = categoryItems(group, ['Optional Fields']).map(cleanToken).filter(isOrdinaryUnqualifiedField);
+  const targetCategory = (group.categories || []).find((category) => exactToken(category.name) === exactToken(authority.overrideCategory));
+  const targetLabelPresent = Boolean(targetCategory) || (group.labelCandidates || []).some((label) => exactToken(label) === exactToken(authority.overrideCategory));
+  const tokens = targetCategory ? (targetCategory.items || []).map(cleanToken).filter(Boolean) : [];
+  let target;
+  if (!targetLabelPresent) {
+    target = Object.freeze({
+      heading: `## ${group.name}`,
+      title: group.name,
+      level: 2,
+      authority: 'root-same-name-default',
+      qualification: 'valid'
+    });
+  } else if (tokens.length !== 1) {
+    target = Object.freeze({
+      heading: '', title: '', level: 0,
+      authority: 'explicit-instance-target',
+      qualification: 'structurally-invalid',
+      findings: Object.freeze([`Instance Target requires exactly one heading token; observed ${tokens.length}.`])
+    });
+  } else {
+    const parsed = parseExactHeadingToken(tokens[0]);
+    target = parsed
+      ? Object.freeze({ heading: tokens[0], title: parsed.title, level: parsed.level, authority: 'explicit-instance-target', qualification: 'valid' })
+      : Object.freeze({ heading: tokens[0], title: '', level: 0, authority: 'explicit-instance-target', qualification: 'structurally-invalid', findings: Object.freeze(['Instance Target must be one exact literal Markdown heading token.']) });
+  }
+  return Object.freeze({
+    sourceSchemaId: String(group.sourceSchemaId || ''),
+    group: group.name,
+    requiredFields: Object.freeze(unique(requiredFields)),
+    optionalFields: Object.freeze(unique(optionalFields)),
+    target
+  });
+}
+
+function reconcileOrdinaryTargets(contributors = [], requiredTargets = new Set(), optionalTargets = new Set(), requiredHeadings = []) {
+  const invalid = contributors.filter((item) => item.target?.qualification !== 'valid');
+  if (invalid.length) {
+    return Object.freeze({
+      heading: '', title: '', level: 0, authority: '', requiredness: 'unresolved',
+      qualification: 'structurally-invalid',
+      findings: Object.freeze(invalid.flatMap((item) => item.target?.findings || []))
+    });
+  }
+  const headings = unique(contributors.map((item) => item.target.heading));
+  if (headings.length !== 1) {
+    return Object.freeze({
+      heading: '', title: '', level: 0, authority: 'conflicting-contributions', requiredness: 'unresolved',
+      qualification: 'conflicting',
+      findings: Object.freeze([`Ordinary group contributors resolve to different targets: ${headings.join(', ')}.`])
+    });
+  }
+  const first = contributors[0]?.target || {};
+  const title = first.title || exactHeadingTitle(first.heading);
+  const level = Number(first.level || 0);
+  const requiredByExactHeading = (requiredHeadings || []).some((item) => Number(item?.level || 0) === level && exactToken(item?.title) === exactToken(title));
+  const requiredBySection = level === 2 && requiredTargets.has(title);
+  const optionalBySection = level === 2 && optionalTargets.has(title);
+  const required = requiredByExactHeading || requiredBySection;
+  const optional = optionalBySection;
+  // Root inheritance is additive and descendants may strengthen local requirements.
+  // Therefore an inherited optional target plus a required target resolves to required;
+  // a field requirement by itself never participates in this decision.
+  const requiredness = required ? 'required' : optional ? 'optional' : 'unresolved';
+  const targetAuthorities = unique(contributors.map((item) => item.target.authority));
+  return Object.freeze({
+    heading: first.heading,
+    title,
+    level,
+    authority: targetAuthorities.length === 1 ? targetAuthorities[0] : 'compatible-mixed-authority',
+    requiredness,
+    qualification: 'valid',
+    findings: Object.freeze([])
+  });
+}
+
+function parseExactHeadingToken(value = '') {
+  const match = exactToken(value).match(/^(#{1,6})\s+(.+?)\s*$/);
+  return match ? { level: match[1].length, title: match[2].trim() } : null;
+}
+
+function categoryItems(group = {}, names = []) {
+  const wanted = new Set(names.map(exactToken));
+  return (group.categories || []).flatMap((category) => wanted.has(exactToken(category.name)) ? category.items : []);
+}
+
+function cleanToken(value = '') { return String(value || '').trim().replace(/^`|`$/g, '').trim(); }
+function exactToken(value = '') { return String(value || '').trim(); }
+function exactHeadingTitle(value = '') { return exactToken(value).replace(/^#{1,6}\s+/, ''); }
+function unique(values = []) { return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))]; }

package/src/tooling/portable/schema/ordinary.fields.js

@@ -0,0 +1,205 @@
+import { declarationOwnershipRanges, parseDeclarationsAgainstContract } from './named.declarations.js';
+
+export const PORTABLE_ORDINARY_FIELD_INSTANCE_SCHEMA_ID = 'tiinex.portable.ordinary-field-instance.v1';
+
+export function resolveOrdinaryFieldInstances(markdown = '', compiledContract = {}, options = {}) {
+  const source = String(markdown || '');
+  const blocks = parseHeadingBlocks(source);
+  const parsedDeclarations = options.parsedDeclarations || parseDeclarationsAgainstContract(source, compiledContract?.declarations || []);
+  const declarationOwnership = declarationOwnershipRanges(parsedDeclarations);
+  const groups = (compiledContract?.validation?.ordinaryGroups || []).map((contract) => resolveGroup(contract, blocks, declarationOwnership));
+  return Object.freeze({
+    schema: PORTABLE_ORDINARY_FIELD_INSTANCE_SCHEMA_ID,
+    groups: Object.freeze(groups)
+  });
+}
+
+function resolveGroup(contract = {}, blocks = [], declarationOwnership = []) {
+  const compiledQualification = String(contract.qualification || 'unresolved');
+  const targetContract = contract.target || {};
+  if (compiledQualification !== 'valid' || targetContract.qualification !== 'valid' || !targetContract.title) {
+    return Object.freeze({
+      group: contract.group || '',
+      qualification: compiledQualification === 'valid' ? String(targetContract.qualification || 'unresolved') : compiledQualification,
+      target: projectTarget(targetContract, [], false),
+      fields: Object.freeze(projectFields(contract, [])),
+      contributors: contract.contributors || Object.freeze([])
+    });
+  }
+
+  const exactBlocks = blocks.filter((block) => block.level === Number(targetContract.level || 0) && block.title === targetContract.title);
+  const ambiguous = exactBlocks.length > 1;
+  const block = exactBlocks.length === 1 ? exactBlocks[0] : null;
+  const targetPresent = exactBlocks.length > 0;
+  const targetQualification = ambiguous ? 'ambiguous' : targetContract.requiredness === 'unresolved' && !targetPresent ? 'unresolved' : 'resolved';
+  const fieldDeclarations = [...(contract.requiredFields || []).map((label) => ({ label, requirement: 'required' })),
+    ...(contract.optionalFields || []).map((label) => ({ label, requirement: 'optional' }))];
+  const fields = fieldDeclarations.map((declaration) => resolveField(declaration, block, {
+    ambiguous,
+    targetPresent,
+    requiredness: targetContract.requiredness,
+    declarationOwnership
+  }));
+
+  return Object.freeze({
+    group: contract.group || '',
+    qualification: ambiguous ? 'ambiguous' : targetQualification,
+    target: projectTarget(targetContract, exactBlocks, targetPresent, targetQualification),
+    fields: Object.freeze(fields),
+    contributors: contract.contributors || Object.freeze([])
+  });
+}
+
+function projectTarget(target = {}, blocks = [], present = false, qualification = '') {
+  return Object.freeze({
+    heading: String(target.heading || ''),
+    title: String(target.title || ''),
+    level: Number(target.level || 0),
+    authority: String(target.authority || ''),
+    requiredness: String(target.requiredness || 'unresolved'),
+    qualification: qualification || String(target.qualification || 'unresolved'),
+    present: Boolean(present),
+    occurrenceCount: blocks.length,
+    occurrences: Object.freeze(blocks.map((block) => Object.freeze({
+      line: block.line,
+      endLine: block.endLine,
+      order: block.order
+    })))
+  });
+}
+
+function projectFields(contract = {}, occurrences = []) {
+  return [
+    ...(contract.requiredFields || []).map((label) => Object.freeze({ label, requirement: 'required', qualification: 'unresolved', occurrences: Object.freeze(occurrences) })),
+    ...(contract.optionalFields || []).map((label) => Object.freeze({ label, requirement: 'optional', qualification: 'unresolved', occurrences: Object.freeze(occurrences) }))
+  ];
+}
+
+function resolveField(declaration = {}, block = null, context = {}) {
+  if (context.ambiguous) {
+    return Object.freeze({
+      label: declaration.label,
+      requirement: declaration.requirement,
+      qualification: 'unresolved',
+      occurrences: Object.freeze([])
+    });
+  }
+  if (!context.targetPresent) {
+    const inactiveOptionalTarget = context.requiredness === 'optional';
+    return Object.freeze({
+      label: declaration.label,
+      requirement: declaration.requirement,
+      qualification: inactiveOptionalTarget || declaration.requirement === 'optional' ? 'absent' : context.requiredness === 'required' ? 'missing-required' : 'unresolved',
+      occurrences: Object.freeze([])
+    });
+  }
+  const occurrences = (block?.fields || []).filter((field) => field.label === declaration.label && !lineOwnedByDeclaration(field.line, context.declarationOwnership));
+  const qualification = occurrences.length > 1
+    ? 'duplicate'
+    : occurrences.length === 1
+      ? 'present'
+      : declaration.requirement === 'required'
+        ? 'missing-required'
+        : 'absent';
+  return Object.freeze({
+    label: declaration.label,
+    requirement: declaration.requirement,
+    qualification,
+    occurrences: Object.freeze(occurrences.map((field) => Object.freeze({
+      value: field.value,
+      rawValue: field.rawValue,
+      line: field.line,
+      order: field.order,
+      form: field.form
+    })))
+  });
+}
+
+function lineOwnedByDeclaration(line = 0, ranges = []) {
+  const target = Number(line || 0);
+  return target > 0 && (ranges || []).some((range) => target >= Number(range.line || 0) && target <= Number(range.endLine || 0));
+}
+
+export function parseHeadingBlocks(markdown = '') {
+  const lines = String(markdown || '').replace(/\r\n?/g, '\n').split('\n');
+  const headings = [];
+  let fenced = false;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (/^\s*```/.test(line)) { fenced = !fenced; continue; }
+    if (fenced) continue;
+    const match = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+    if (!match) continue;
+    headings.push({ index, level: match[1].length, title: match[2].trim() });
+  }
+
+  const blocks = [];
+  let order = 0;
+  for (let position = 0; position < headings.length; position += 1) {
+    const heading = headings[position];
+    let end = lines.length;
+    for (let cursor = position + 1; cursor < headings.length; cursor += 1) {
+      if (headings[cursor].level <= heading.level) { end = headings[cursor].index; break; }
+    }
+    const directContentEnd = Math.min(end, headings[position + 1]?.index ?? end);
+    blocks.push(Object.freeze({
+      level: heading.level,
+      title: heading.title,
+      line: heading.index + 1,
+      endLine: end,
+      order: order++,
+      fields: Object.freeze(parseTopLevelFieldOccurrences(lines, heading.index + 1, directContentEnd))
+    }));
+  }
+  return Object.freeze(blocks);
+}
+
+export function parseSecondLevelBlocks(markdown = '') {
+  return Object.freeze(parseHeadingBlocks(markdown).filter((block) => block.level === 2));
+}
+
+function parseTopLevelFieldOccurrences(lines = [], start = 0, end = 0) {
+  const fields = [];
+  let fenced = false;
+  let order = 0;
+  for (let index = start; index < end; index += 1) {
+    const raw = lines[index];
+    if (/^\s*```/.test(raw)) { fenced = !fenced; continue; }
+    if (fenced) continue;
+
+    const scalar = raw.match(/^-\s+([^:]+):\s*(.*?)\s*$/);
+    if (scalar) {
+      fields.push(Object.freeze({
+        label: scalar[1].trim(),
+        value: scalar[2],
+        rawValue: scalar[2],
+        line: index + 1,
+        order: order++,
+        form: 'scalar'
+      }));
+      continue;
+    }
+
+    const block = raw.match(/^-\s+([^:]+?)\s*$/);
+    if (!block) continue;
+    const nested = [];
+    let cursor = index + 1;
+    while (cursor < end) {
+      const next = lines[cursor];
+      if (!next.trim()) { nested.push(next); cursor += 1; continue; }
+      if (/^\s+/.test(next)) { nested.push(next); cursor += 1; continue; }
+      break;
+    }
+    if (!nested.some((line) => /^\s+-\s+/.test(line))) continue;
+    const rawValue = nested.join('\n').trimEnd();
+    fields.push(Object.freeze({
+      label: block[1].trim(),
+      value: rawValue,
+      rawValue,
+      line: index + 1,
+      order: order++,
+      form: 'block'
+    }));
+  }
+  return fields;
+}

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

@@ -0,0 +1,70 @@
+import projection from './bootstrap/qualified-local-root/tiinex.root.v1.runtime-projection.json' with { type: 'json' };
+
+export const PORTABLE_QUALIFIED_LOCAL_ROOT_RUNTIME_PROJECTION_SCHEMA_ID = 'tiinex.portable.qualified-local-root-runtime-projection.v1';
+
+export function qualifiedLocalRootRuntimeProjection() {
+  return deepFreeze(clone(projection));
+}
+
+export function projectPortableValidationContractWithQualifiedLocalRoot(baseContract = null) {
+  if (!baseContract || typeof baseContract !== 'object') return unavailable('base-validation-contract-unavailable');
+  const lineage = Array.isArray(baseContract.lineage) ? baseContract.lineage.map(String) : [];
+  if (!lineage.includes('tiinex.root.v1')) return unavailable('root-not-in-validation-lineage');
+  if (projection?.lineageQualification?.state !== 'valid' || projection?.lineageQualification?.complete !== true) return unavailable('local-root-lineage-unqualified');
+
+  const requirements = Array.isArray(baseContract?.validation?.conditionalRequirements)
+    ? baseContract.validation.conditionalRequirements
+    : [];
+  const matchingIndexes = requirements
+    .map((entry, index) => ({ entry, index }))
+    .filter(({ entry }) => String(entry?.name || '') === 'Parent Origin' && normalizeList(entry?.requiredWhen).includes('Parent exists'))
+    .map(({ index }) => index);
+  if (matchingIndexes.length !== 1) return unavailable('parent-origin-contract-cardinality-unqualified', { observedMatches: matchingIndexes.length });
+
+  const replacement = clone(projection.parentOrigin);
+  const conditionalRequirements = requirements.map((entry, index) => index === matchingIndexes[0] ? replacement : clone(entry));
+  const compiledContract = {
+    ...clone(baseContract),
+    validation: {
+      ...clone(baseContract.validation || {}),
+      conditionalRequirements
+    },
+    portableRuntimeProjection: {
+      schema: PORTABLE_QUALIFIED_LOCAL_ROOT_RUNTIME_PROJECTION_SCHEMA_ID,
+      state: 'qualified-local',
+      schemaId: String(projection.schemaId || 'tiinex.root.v1'),
+      authority: clone(projection.authority || {}),
+      source: clone(projection.source || {}),
+      boundary: String(projection?.authority?.boundary || '')
+    }
+  };
+  return deepFreeze({
+    state: 'qualified',
+    reason: '',
+    compiledContract,
+    projection: clone(projection)
+  });
+}
+
+function unavailable(reason, extra = {}) {
+  return deepFreeze({ state: 'unavailable', reason: String(reason || 'unavailable'), compiledContract: null, projection: clone(projection), ...extra });
+}
+
+function normalizeList(value) {
+  return Array.isArray(value) ? value.map((item) => String(item || '').trim()).filter(Boolean) : [];
+}
+
+function clone(value) {
+  if (value == null || typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.map(clone);
+  const result = {};
+  for (const [key, child] of Object.entries(value)) result[key] = clone(child);
+  return result;
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}

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

@@ -0,0 +1,170 @@
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+import { resolveSchemaModule } from '../../../schemas/resolver.js';
+import { qualifySchemaReferenceValue, schemaReferenceAuthorityFromBinding } from '../../../schemas/schema.reference.js';
+import {
+  PORTABLE_QUALIFIED_LOCAL_ROOT_RUNTIME_PROJECTION_SCHEMA_ID,
+  qualifiedLocalRootRuntimeProjection,
+  projectPortableValidationContractWithQualifiedLocalRoot
+} from './qualifiedLocalRoot.projection.js';
+
+export { PORTABLE_QUALIFIED_LOCAL_ROOT_RUNTIME_PROJECTION_SCHEMA_ID, qualifiedLocalRootRuntimeProjection, projectPortableValidationContractWithQualifiedLocalRoot };
+
+export function portableRuntimeValidationContractForSchema(schemaId = '', resolutionInput = null) {
+  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 baseContract = qualification?.state === 'qualified' ? qualification?.compiledContract?.validationContract || null : null;
+  if (!baseContract) return unavailable(qualification?.state === 'qualified' ? 'compiled-validation-contract-unavailable' : 'schema-source-unqualified', { resolution });
+  const projected = projectPortableValidationContractWithQualifiedLocalRoot(baseContract);
+  return deepFreeze({ ...projected, resolution, baseQualificationState: String(qualification?.state || 'unavailable') });
+}
+
+export function portableRuntimeValidationAuthorityForRecord(record = {}) {
+  const markdown = String(record?.markdown || '');
+  const parsed = parseArtifactMarkdown(markdown);
+  const declaredSchema = parsed?.envelope?.current?.schema || {};
+  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 findings = [];
+  const currentModule = runtime.resolution?.module || null;
+  const currentQualification = typeof currentModule?.schemaSource?.qualify === 'function' ? currentModule.schemaSource.qualify() : null;
+  const currentBinding = currentModule?.binding || {};
+  const localWorkspaceAuthority = isQualifiedLocalUnpublishedAuthority(currentBinding, currentQualification);
+  let currentReferenceState = 'unavailable';
+  let currentReferenceBasis = 'unavailable';
+
+  if (!declaredSchema.id || declaredSchema.id !== schemaId) {
+    findings.push(`Current Schema identity is unavailable or contradictory for ${schemaId || '(missing schema id)'}.`);
+  } else if (localWorkspaceAuthority) {
+    currentReferenceState = 'qualified';
+    currentReferenceBasis = 'qualified-workspace-local-authority';
+  } else if (declaredSchema.form === 'plain-schema-id') {
+    findings.push(`Current Schema ${schemaId} declares no version-bearing locator and no qualified local workspace authority supersedes that omission.`);
+    currentReferenceBasis = 'schema-id-only-version-unresolved';
+  } else {
+    const referenceAuthority = schemaReferenceAuthorityFromBinding(schemaId, currentBinding, currentQualification?.authority || null, currentQualification);
+    const referenceQualification = qualifySchemaReferenceValue(String(declaredSchema.raw || ''), referenceAuthority);
+    if (referenceQualification.state === 'qualified' && referenceQualification.targetState === 'qualified') {
+      currentReferenceState = 'qualified';
+      currentReferenceBasis = 'declared-current-schema-exact-source-target';
+    } else {
+      findings.push(...(referenceQualification.findings || []).map((item) => `Current Schema authority: ${item}`));
+      currentReferenceBasis = 'declared-current-schema-target-unqualified';
+    }
+  }
+
+  const lineage = Array.isArray(runtime.compiledContract?.lineage) ? runtime.compiledContract.lineage : [];
+  const projectedLineageAuthority = Array.isArray(runtime.compiledContract?.lineageAuthority) ? runtime.compiledContract.lineageAuthority : [];
+  if (!lineage.length || runtime.compiledContract?.lineageQualification?.state !== 'valid') {
+    findings.push('Compiled validation lineage is unavailable or not valid.');
+  }
+  if (projectedLineageAuthority.length !== lineage.length) {
+    findings.push(`Compiled validation lineage source authority is unavailable for ${schemaId || '(unknown schema)'}.`);
+  }
+
+  const lineageAuthorities = projectedLineageAuthority.map((entry) => Object.freeze({
+    schemaId: String(entry?.schemaId || ''),
+    sourceRepository: String(entry?.source?.repository || '').trim(),
+    sourceCommit: String(entry?.source?.commit || '').trim().toLowerCase(),
+    sourcePath: String(entry?.source?.path || '').trim(),
+    publicationState: String(entry?.source?.publicationState || '').trim(),
+    snapshotCompleteness: String(entry?.source?.snapshotCompleteness || '').trim(),
+    parentSchemaId: String(entry?.parentSchemaId || '').trim(),
+    parentSourceCandidates: Object.freeze((entry?.parentSourceCandidates || []).map((candidate) => Object.freeze({
+      repository: String(candidate?.repository || '').trim(),
+      commit: String(candidate?.commit || '').trim().toLowerCase(),
+      path: String(candidate?.path || '').trim()
+    })))
+  }));
+
+  // A qualified local unpublished current-schema module is itself the Axiom-approved
+  // bounded workspace authority for its compiled validation contract. Its local
+  // lineage may intentionally supersede published parent locators, so do not
+  // reinterpret those edges through today's registry. For published/current
+  // authority, every compiled lineage edge must remain source-coherent.
+  if (!localWorkspaceAuthority) {
+    for (let index = 1; index < lineageAuthorities.length; index += 1) {
+      const parent = lineageAuthorities[index - 1];
+      const child = lineageAuthorities[index];
+      if (!child.parentSchemaId || child.parentSchemaId !== parent.schemaId) {
+        findings.push(`Compiled lineage identity is incoherent across ${parent.schemaId || '(unknown parent)'} -> ${child.schemaId || '(unknown child)'}.`);
+        continue;
+      }
+      if (isQualifiedLocalUnpublishedSource(parent)) continue;
+      const candidates = child.parentSourceCandidates || [];
+      if (candidates.length !== 1) {
+        findings.push(candidates.length
+          ? `Declared parent source authority is ambiguous for ${child.schemaId}: ${candidates.length} exact pinned candidates.`
+          : `Declared parent source authority is unavailable for ${child.schemaId} -> ${parent.schemaId}.`);
+        continue;
+      }
+      const expected = candidates[0];
+      if (!sameSourceTuple(parent, expected)) {
+        findings.push(`Compiled lineage substitutes source authority for ${child.schemaId} -> ${parent.schemaId}: declared ${expected.repository || '(unknown repo)'}@${expected.commit || '(unknown commit)'}/${expected.path || '(unknown path)'} but compiled ${parent.sourceRepository || '(unknown repo)'}@${parent.sourceCommit || '(unknown commit)'}/${parent.sourcePath || '(unknown path)'}.`);
+      }
+    }
+  }
+
+  const qualified = currentReferenceState === 'qualified' && findings.length === 0;
+  return deepFreeze({
+    schema: 'tiinex.portable.runtime-validation-authority.v1',
+    state: qualified ? 'qualified' : 'unavailable',
+    reason: qualified ? '' : 'exact-schema-authority-or-lineage-unqualified',
+    schemaId,
+    currentReference: Object.freeze({ state: currentReferenceState, basis: currentReferenceBasis, raw: String(declaredSchema.raw || ''), target: String(declaredSchema.target || '') }),
+    lineage: Object.freeze(lineageAuthorities),
+    findings: Object.freeze(findings),
+    resolution: runtime.resolution,
+    compiledContract: qualified ? runtime.compiledContract : null,
+    baseQualificationState: runtime.baseQualificationState || 'unavailable'
+  });
+}
+
+function sameSourceTuple(actual = {}, expected = {}) {
+  return String(actual?.sourceRepository || '') === String(expected?.repository || '')
+    && String(actual?.sourceCommit || '').toLowerCase() === String(expected?.commit || '').toLowerCase()
+    && String(actual?.sourcePath || '') === String(expected?.path || '');
+}
+
+function isQualifiedLocalUnpublishedSource(source = {}) {
+  return String(source?.publicationState || '').trim().toLowerCase() === 'accepted-local-unpublished'
+    && String(source?.snapshotCompleteness || '').trim() === 'exact-axiom-canonical-unpublished-bounded-workspace-contract';
+}
+
+function isQualifiedLocalUnpublishedAuthority(binding = {}, qualification = null) {
+  const publicationState = String(binding?.publicationState || '').trim().toLowerCase();
+  const snapshotCompleteness = String(binding?.snapshotCompleteness || '').trim();
+  return qualification?.state === 'qualified'
+    && publicationState === 'accepted-local-unpublished'
+    && snapshotCompleteness === 'exact-axiom-canonical-unpublished-bounded-workspace-contract';
+}
+
+function unavailableAuthority(schemaId = '', runtime = {}, findings = []) {
+  return deepFreeze({
+    schema: 'tiinex.portable.runtime-validation-authority.v1',
+    state: 'unavailable',
+    reason: String(runtime?.reason || 'exact-schema-authority-or-lineage-unqualified'),
+    schemaId: String(schemaId || ''),
+    currentReference: Object.freeze({ state: 'unavailable', basis: 'unavailable', raw: '', target: '' }),
+    lineage: Object.freeze([]),
+    findings: Object.freeze(findings),
+    resolution: runtime?.resolution || null,
+    compiledContract: null,
+    baseQualificationState: String(runtime?.baseQualificationState || 'unavailable')
+  });
+}
+
+function unavailable(reason, extra = {}) {
+  return deepFreeze({ state: 'unavailable', reason: String(reason || 'unavailable'), compiledContract: null, projection: qualifiedLocalRootRuntimeProjection(), ...extra });
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}