@tiinex/core 0.1.1

package/src/tooling/portable/package/semantic.package.schema-resolution.js

@@ -0,0 +1,158 @@
+import { portableFinding } from '../findings.js';
+import {
+  extractQualifiedMarkdownLinkTarget,
+  isAbsoluteReference,
+  materialIsSchemaDocument,
+  portableFieldDomainOccurrenceQualification,
+  relativePathEscapesBoundary,
+  resolvePortableMaterialReference
+} from './material.graph.js';
+import { packageContainingMaterial } from './semantic.package.graph.js';
+
+export function compileSemanticPackageSchemaResolution(input = {}) {
+  const state = {
+    nodes: input.nodes || [],
+    materialIndex: input.materialIndex,
+    findings: []
+  };
+  const index = new Map();
+  const nodeByKey = new Map(state.nodes.map((node) => [node.manifestKey, node]));
+
+  for (const node of state.nodes) {
+    const reachable = new Set(node.reachablePackageKeys);
+    const candidates = new Map();
+    for (const packageKey of reachable) {
+      const targetNode = nodeByKey.get(packageKey);
+      for (const key of targetNode?.localSchemaKeys || []) {
+        const material = state.materialIndex.byKey.get(key);
+        if (!material?.schemaId) continue;
+        if (!candidates.has(material.schemaId)) candidates.set(material.schemaId, []);
+        candidates.get(material.schemaId).push(Object.freeze({ material, packageKey }));
+      }
+    }
+
+    const bindingsById = new Map();
+    for (const binding of node.schemaBindingDeclarations || []) {
+      if (binding.name === 'none') continue;
+      if (!bindingsById.has(binding.name)) bindingsById.set(binding.name, []);
+      bindingsById.get(binding.name).push(binding);
+    }
+
+    const ids = new Set([...candidates.keys(), ...bindingsById.keys()]);
+    for (const schemaId of ids) {
+      const key = resolutionKey(node.manifestKey, schemaId);
+      const bindings = bindingsById.get(schemaId) || [];
+      let resolution;
+      if (bindings.length > 1) {
+        resolution = schemaResolution(node, schemaId, 'ambiguous', null, candidates.get(schemaId) || [], bindings, ['Duplicate/conflicting Schema Resolution Bindings.']);
+        state.findings.push(portableFinding('error', 'portable.semantic-package.schema-binding.duplicate', `Duplicate Schema Resolution Bindings for ${schemaId}.`, { ref: node.manifestPath, schemaId }));
+      } else if (bindings.length === 1) {
+        resolution = resolveExplicitSchemaBinding(node, schemaId, bindings[0], candidates.get(schemaId) || [], state);
+      } else {
+        const available = candidates.get(schemaId) || [];
+        if (available.length === 1) resolution = schemaResolution(node, schemaId, 'resolved', available[0], available, [], []);
+        else if (!available.length) resolution = schemaResolution(node, schemaId, 'unresolved', null, available, [], ['No resolvable schema candidate exists in the reachable package graph.']);
+        else resolution = schemaResolution(node, schemaId, 'ambiguous', null, available, [], [`${available.length} competing schema candidates exist without one exact manifest binding.`]);
+      }
+      index.set(key, resolution);
+      appendResolutionFinding(resolution, node, state.findings);
+    }
+  }
+
+  return Object.freeze({ index, findings: Object.freeze(state.findings) });
+}
+
+export function resolveCompanionSchemaReference(node, fromMaterial, target, input = {}) {
+  if (!isAbsoluteReference(target) && relativePathEscapesBoundary(fromMaterial, target, node.packageRoot)) {
+    return Object.freeze({ qualification: 'invalid', candidates: Object.freeze([]), finding: 'Companion Schema Reference must not escape its selected package boundary through a relative path.' });
+  }
+  const resolved = resolvePortableMaterialReference(input.materialIndex, fromMaterial, target);
+  if (resolved.qualification !== 'resolved') return resolved;
+  const material = resolved.candidates[0];
+  if (!node.localMaterialKeys.includes(material.representationKey)) return Object.freeze({ qualification: 'unresolved', candidates: Object.freeze([]), finding: 'Companion Schema Reference must resolve inside its own selected package boundary.' });
+  if (!materialIsSchemaDocument(material)) return Object.freeze({ qualification: 'unresolved', candidates: Object.freeze([]), finding: 'Companion Schema Reference target is not a schema document.' });
+  return Object.freeze({ qualification: 'resolved', candidates: Object.freeze([material]), material, finding: '' });
+}
+
+export function schemaResolutionFor(index, packageKey, schemaId) {
+  return index.get(resolutionKey(packageKey, schemaId)) || Object.freeze({ qualification: 'unresolved', target: null });
+}
+
+export function projectSchemaResolutions(index = new Map()) {
+  return Object.freeze([...index.values()].sort((a, b) => compare(`${a.packageKey}\u0000${a.schemaId}`, `${b.packageKey}\u0000${b.schemaId}`)));
+}
+
+function resolveExplicitSchemaBinding(node, schemaId, binding, candidates, state) {
+  const schemaReference = String(binding.fields?.['Schema Reference'] || '');
+  const schemaShape = portableFieldDomainOccurrenceQualification(node.manifestProjection, 'Schema Resolution Binding Declaration', 'Schema Reference', schemaReference, binding.name);
+  if (schemaShape !== 'core') return schemaResolution(node, schemaId, 'unresolved', null, candidates, [binding], ['Schema Reference shape authority is unresolved or invalid.']);
+
+  const schemaTarget = extractQualifiedMarkdownLinkTarget(schemaReference);
+  const manifestMaterial = state.materialIndex.byKey.get(node.manifestKey);
+  if (!isAbsoluteReference(schemaTarget) && relativePathEscapesBoundary(manifestMaterial, schemaTarget, node.packageRoot)) {
+    return schemaResolution(node, schemaId, 'invalid', null, candidates, [binding], ['Relative Schema Reference escapes the selected package boundary.']);
+  }
+  const schemaResolved = resolvePortableMaterialReference(state.materialIndex, manifestMaterial, schemaTarget);
+  if (schemaResolved.qualification !== 'resolved') return schemaResolution(node, schemaId, schemaResolved.qualification, null, candidates, [binding], [schemaResolved.finding]);
+  const targetMaterial = schemaResolved.candidates[0];
+  if (!isAbsoluteReference(schemaTarget) && !node.localMaterialKeys.includes(targetMaterial.representationKey)) {
+    return schemaResolution(node, schemaId, 'invalid', null, candidates, [binding], ['Relative Schema Reference crosses a declared semantic package boundary; cross-package schema bindings require an explicit non-relative Schema Reference plus Package Reference.']);
+  }
+  if (!materialIsSchemaDocument(targetMaterial) || targetMaterial.schemaId !== schemaId) {
+    state.findings.push(portableFinding('error', 'portable.semantic-package.schema-binding.target.invalid', `Schema binding for ${schemaId} does not resolve to exactly that schema document.`, { ref: node.manifestPath, schemaId, target: schemaTarget }));
+    return schemaResolution(node, schemaId, 'invalid', null, candidates, [binding], ['Resolved Schema Reference does not identify the declared exact schema artifact.']);
+  }
+
+  const packageReference = String(binding.fields?.['Package Reference'] || '');
+  if (!packageReference) {
+    if (!node.localMaterialKeys.includes(targetMaterial.representationKey)) return schemaResolution(node, schemaId, 'invalid', null, candidates, [binding], ['Package-external Schema Reference requires an explicit Package Reference.']);
+  } else {
+    const packageShape = portableFieldDomainOccurrenceQualification(node.manifestProjection, 'Schema Resolution Binding Declaration', 'Package Reference', packageReference, binding.name);
+    if (packageShape !== 'core') return schemaResolution(node, schemaId, 'unresolved', null, candidates, [binding], ['Package Reference shape authority is unresolved or invalid.']);
+    const packageTarget = extractQualifiedMarkdownLinkTarget(packageReference);
+    if (!isAbsoluteReference(packageTarget) && relativePathEscapesBoundary(manifestMaterial, packageTarget, node.packageRoot)) {
+      return schemaResolution(node, schemaId, 'invalid', null, candidates, [binding], ['Relative Package Reference escapes the selected package boundary.']);
+    }
+    const packageResolved = resolvePortableMaterialReference(state.materialIndex, manifestMaterial, packageTarget);
+    if (packageResolved.qualification !== 'resolved') return schemaResolution(node, schemaId, packageResolved.qualification, null, candidates, [binding], [packageResolved.finding]);
+    const targetPackageKey = packageResolved.candidates[0].representationKey;
+    const directTarget = node.outgoingEdges.some((edge) => edge.qualification === 'resolved' && edge.targetPackageKey === targetPackageKey);
+    if (!directTarget) return schemaResolution(node, schemaId, 'invalid', null, candidates, [binding], ['Package Reference is not one of the package authorities explicitly declared by this manifest.']);
+    const targetNode = state.nodes.find((candidate) => candidate.manifestKey === targetPackageKey);
+    if (!targetNode?.localMaterialKeys.includes(targetMaterial.representationKey)) return schemaResolution(node, schemaId, 'invalid', null, candidates, [binding], ['Schema Reference does not resolve inside the explicitly referenced package boundary.']);
+  }
+
+  const packageKey = packageContainingMaterial(targetMaterial.representationKey, state.nodes);
+  return schemaResolution(node, schemaId, 'resolved', Object.freeze({ material: targetMaterial, packageKey }), candidates, [binding], []);
+}
+
+function appendResolutionFinding(resolution, node, findings) {
+  if (resolution.qualification === 'ambiguous' || resolution.qualification === 'invalid') {
+    findings.push(portableFinding('error', 'portable.semantic-package.schema-resolution.fail-closed', `Schema resolution for ${resolution.schemaId} is ${resolution.qualification}.`, { ref: node.manifestPath, schemaId: resolution.schemaId, qualification: resolution.qualification }));
+  } else if (resolution.qualification === 'unresolved') {
+    findings.push(portableFinding('warning', 'portable.semantic-package.schema-resolution.unresolved', `Schema resolution for ${resolution.schemaId} is unresolved.`, { ref: node.manifestPath, schemaId: resolution.schemaId }));
+  }
+}
+
+function schemaResolution(node, schemaId, qualification, target, candidates, bindings, findings) {
+  return Object.freeze({
+    packageKey: node.manifestKey,
+    packagePath: node.manifestPath,
+    schemaId,
+    qualification,
+    target: target ? Object.freeze({ representationKey: target.material.representationKey, path: target.material.path, packageKey: target.packageKey }) : null,
+    candidates: Object.freeze((candidates || []).map((item) => Object.freeze({ representationKey: item.material.representationKey, path: item.material.path, packageKey: item.packageKey }))),
+    bindingCount: (bindings || []).length,
+    bindingProvenance: Object.freeze((bindings || []).map((binding) => Object.freeze({
+      schemaId: String(binding.name || ''),
+      schemaReference: String(binding.fields?.['Schema Reference'] || ''),
+      packageReference: String(binding.fields?.['Package Reference'] || ''),
+      note: String(binding.fields?.Note || ''),
+      source: binding.source || null
+    }))),
+    findings: Object.freeze([...(findings || [])])
+  });
+}
+
+function resolutionKey(packageKey, schemaId) { return `${packageKey}\u0000${String(schemaId || '').trim()}`; }
+function compare(a = '', b = '') { const left = String(a); const right = String(b); return left < right ? -1 : left > right ? 1 : 0; }

package/src/tooling/portable/package/semantic.package.transition-registry.js

@@ -0,0 +1,189 @@
+import { portableFinding } from '../findings.js';
+import { projectPortableContractInstance } from '../schema/contract.project.js';
+import {
+  isAbsoluteReference,
+  relativePathEscapesBoundary,
+  resolvePortableMaterialReference
+} from './material.graph.js';
+import { packageContainingMaterial } from './semantic.package.graph.js';
+import { schemaResolutionFor } from './semantic.package.schema-resolution.js';
+import { isTransitionArtifact } from './semantic.package.types.js';
+
+export function resolvePackageTransitionReference(node, fromMaterial, target, input = {}) {
+  const relative = !isAbsoluteReference(target);
+  if (relative && relativePathEscapesBoundary(fromMaterial, target, node.packageRoot)) {
+    return Object.freeze({ qualification: 'invalid', candidates: Object.freeze([]), finding: 'Relative Transition Reference must remain inside the companion package boundary; cross-package attachments require an explicit non-relative reference reachable through the package graph.' });
+  }
+  const resolved = resolvePortableMaterialReference(input.materialIndex, fromMaterial, target);
+  if (resolved.qualification !== 'resolved') return resolved;
+  const material = resolved.candidates[0];
+  if (!isTransitionArtifact(material)) return Object.freeze({ qualification: 'unresolved', candidates: Object.freeze([]), finding: 'Transition Reference target is not a canonical Transition Definition artifact.' });
+  const containing = packageContainingMaterial(material.representationKey, input.nodes || []);
+  if (relative && containing !== node.manifestKey) {
+    return Object.freeze({ qualification: 'invalid', candidates: Object.freeze([material]), finding: 'Relative Transition Reference crosses a declared semantic package boundary; cross-package attachments require an explicit non-relative reference.' });
+  }
+  if (!containing || !node.reachablePackageKeys.includes(containing)) return Object.freeze({ qualification: 'unresolved', candidates: Object.freeze([]), finding: 'Transition Reference target is not reachable through the active explicit package graph.' });
+  return Object.freeze({ qualification: 'resolved', candidates: Object.freeze([material]), material, packageKey: containing, finding: '' });
+}
+
+export function ensureTransitionRegistryEntry(registry, material, node, discoveryKind, input = {}) {
+  if (!material) return null;
+  let entry = registry.get(material.representationKey);
+  if (!entry) {
+    const projection = projectPortableContractInstance({ markdown: material.markdown, compiledContract: input.transitionContract, resolvers: input.resolvers || {} });
+    const identity = ordinaryGroupMap(projection, 'Transition Identity');
+    entry = {
+      representationKey: material.representationKey,
+      path: material.path,
+      source: material.source,
+      references: Object.freeze([...(material.referenceAliases || [])]),
+      schemaId: material.schemaId,
+      representationQualification: projection.validation.status,
+      transitionIdentity: Object.freeze(identity),
+      canonicalIdentifier: String(identity['Canonical Identifier'] || ''),
+      version: String(identity.Version || ''),
+      projection,
+      discoveryProvenance: [],
+      attachmentProvenance: []
+    };
+    registry.set(material.representationKey, entry);
+  }
+  const containingPackageKey = packageContainingMaterial(material.representationKey, input.nodes || []);
+  const route = Object.freeze({
+    kind: discoveryKind,
+    packageKey: node.manifestKey,
+    packagePath: node.manifestPath,
+    containingPackageKey,
+    materialPath: material.path,
+    packageRoutes: Object.freeze([...(node.routes || [])].sort(compareObject))
+  });
+  if (!entry.discoveryProvenance.some((item) => JSON.stringify(item) === JSON.stringify(route))) entry.discoveryProvenance.push(route);
+  return entry;
+}
+
+export function qualifyAttachmentParticipation(input = {}) {
+  const { schemaBinding, transitionMaterial, packageNode } = input;
+  if (schemaBinding?.qualification !== 'resolved' || !schemaBinding.material?.representationKey) return Object.freeze({ qualification: 'unresolved', evidence: Object.freeze([]) });
+  const entry = ensureTransitionRegistryEntry(input.transitionRegistry, transitionMaterial, packageNode, 'participation-check', input);
+  const boundKey = schemaBinding.material.representationKey;
+  const evidence = [];
+  let unresolved = false;
+  const roles = transitionRoleEntries(entry.projection);
+  if (!roles.length) return Object.freeze({ qualification: 'contradictory', evidence: Object.freeze([]) });
+
+  for (const role of roles) {
+    const targetKind = String(role.fields?.['Target Kind'] || '');
+    const constraint = String(role.fields?.['Schema Constraint'] || '');
+    if (!constraint) {
+      if (targetKind === 'non-artifact') evidence.push(Object.freeze({ group: role.group, entry: role.name, qualification: 'excluded-non-artifact' }));
+      else unresolved = true;
+      continue;
+    }
+    const resolved = resolveRoleSchemaConstraint(constraint, packageNode, transitionMaterial, input);
+    if (resolved.qualification === 'resolved') {
+      const representationKey = resolved.target?.representationKey || resolved.target?.material?.representationKey || '';
+      evidence.push(Object.freeze({ group: role.group, entry: role.name, schemaConstraint: constraint, qualification: representationKey === boundKey ? 'match' : 'resolved-other', representationKey }));
+      if (representationKey === boundKey) return Object.freeze({ qualification: 'consistent', evidence: Object.freeze(evidence) });
+    } else {
+      unresolved = true;
+      evidence.push(Object.freeze({ group: role.group, entry: role.name, schemaConstraint: constraint, qualification: resolved.qualification }));
+    }
+  }
+  return Object.freeze({ qualification: unresolved ? 'unresolved' : 'contradictory', evidence: Object.freeze(evidence) });
+}
+
+export function detectCompanionConflicts(companions, findings) {
+  const bySchema = new Map();
+  for (const companion of companions) {
+    const key = String(companion.schemaBinding?.representationKey || '');
+    if (companion.schemaBinding?.qualification !== 'resolved' || !key) continue;
+    if (!bySchema.has(key)) bySchema.set(key, []);
+    bySchema.get(key).push(companion);
+  }
+  const conflicts = new Set();
+  for (const [schemaKey, values] of bySchema) {
+    if (values.length <= 1) continue;
+    conflicts.add(schemaKey);
+    findings.push(portableFinding('error', 'portable.companion.binding.competing', 'More than one companion resolves to the same exact schema artifact inside one package compilation.', { schemaRepresentationKey: schemaKey, companions: values.map((item) => item.representationKey) }));
+  }
+  return conflicts;
+}
+
+export function compileAttachmentStates(nodes, companions, conflicts, materialIndex) {
+  const bySchema = new Map();
+  for (const companion of companions) {
+    if (companion.schemaBinding?.qualification !== 'resolved') continue;
+    const key = String(companion.schemaBinding?.representationKey || '');
+    if (!key) continue;
+    if (!bySchema.has(key)) bySchema.set(key, []);
+    bySchema.get(key).push(companion);
+  }
+  const schemaKeys = unique(nodes.flatMap((node) => node.localSchemaKeys || []));
+  return Object.freeze(schemaKeys.map((schemaKey) => {
+    const material = materialIndex.byKey.get(schemaKey);
+    const bound = bySchema.get(schemaKey) || [];
+    let state = 'absent';
+    if (conflicts.has(schemaKey)) state = 'competing';
+    else if (bound.length === 1) state = bound[0].attachmentSet.explicitEmpty ? 'explicit-empty' : 'declared';
+    return Object.freeze({
+      schemaRepresentationKey: schemaKey,
+      schemaId: material?.schemaId || '',
+      path: material?.path || '',
+      state,
+      companions: Object.freeze(bound.map((item) => item.representationKey).sort(compare)),
+      attachments: Object.freeze(bound.flatMap((item) => item.attachmentSet.attachments || []))
+    });
+  }).sort((a, b) => compare(a.schemaRepresentationKey, b.schemaRepresentationKey)));
+}
+
+export function finalizeTransitionRegistry(registry) {
+  return Object.freeze([...registry.values()].map((entry) => Object.freeze({
+    representationKey: entry.representationKey,
+    path: entry.path,
+    source: entry.source,
+    references: entry.references,
+    schemaId: entry.schemaId,
+    representationQualification: entry.representationQualification,
+    transitionIdentity: entry.transitionIdentity,
+    canonicalIdentifier: entry.canonicalIdentifier,
+    version: entry.version,
+    projection: entry.projection,
+    discoveryProvenance: Object.freeze([...entry.discoveryProvenance].sort(compareObject)),
+    attachmentProvenance: Object.freeze([...entry.attachmentProvenance].sort(compareObject))
+  })).sort((a, b) => compare(a.representationKey, b.representationKey)));
+}
+
+function resolveRoleSchemaConstraint(value, packageNode, transitionMaterial, input) {
+  if (typeof input.resolveSchemaConstraint === 'function') {
+    const custom = input.resolveSchemaConstraint({ value, packageNode, transitionMaterial, schemaResolutionIndex: input.schemaResolutionIndex, materials: input.materialIndex.materials });
+    if (custom) return custom;
+  }
+  const resolution = schemaResolutionFor(input.schemaResolutionIndex, packageNode.manifestKey, String(value || '').trim());
+  return Object.freeze({ qualification: resolution.qualification, target: resolution.target });
+}
+
+function transitionRoleEntries(projection = {}) {
+  const groups = ['Input Role Declaration', 'Output Role Declaration'];
+  const out = [];
+  for (const parsed of projection.validation?.declarations || []) {
+    const group = String(parsed.contract?.group || '');
+    if (!groups.includes(group)) continue;
+    for (const section of parsed.sections || []) {
+      if (!section.present) continue;
+      for (const entry of section.entries || []) if (entry.name !== 'none') out.push(Object.freeze({ group, name: entry.name, fields: entry.fields }));
+    }
+  }
+  return out;
+}
+
+function ordinaryGroupMap(projection, groupName) {
+  const group = (projection.ordinaryGroups || []).find((item) => exact(item.group) === exact(groupName));
+  const out = {};
+  for (const field of group?.fields || []) if (field.occurrences?.length === 1) out[field.label] = String(field.occurrences[0].value ?? '');
+  return out;
+}
+
+function unique(values = []) { return [...new Set(values.map(String).filter(Boolean))]; }
+function compare(a = '', b = '') { const left = String(a); const right = String(b); return left < right ? -1 : left > right ? 1 : 0; }
+function compareObject(a = {}, b = {}) { return compare(JSON.stringify(a), JSON.stringify(b)); }
+function exact(value = '') { return String(value || '').trim(); }

package/src/tooling/portable/package/semantic.package.types.js

@@ -0,0 +1,18 @@
+import { materialIsSchemaDocument } from './material.graph.js';
+
+export const PORTABLE_SEMANTIC_PACKAGE_COMPILATION_SCHEMA_ID = 'tiinex.portable.semantic-package-compilation.v1';
+export const SEMANTIC_PACKAGE_SCHEMA_ID = 'tiinex.semantic.package.v1';
+export const SCHEMA_TRANSITION_COMPANION_SCHEMA_ID = 'tiinex.schema.transition.companion.v1';
+export const TRANSITION_DEFINITION_SCHEMA_ID = 'tiinex.transition.definition.v1';
+
+export function isPackageManifestArtifact(material) {
+  return material?.schemaId === SEMANTIC_PACKAGE_SCHEMA_ID && !materialIsSchemaDocument(material);
+}
+
+export function isCompanionArtifact(material) {
+  return material?.schemaId === SCHEMA_TRANSITION_COMPANION_SCHEMA_ID && !materialIsSchemaDocument(material);
+}
+
+export function isTransitionArtifact(material) {
+  return material?.schemaId === TRANSITION_DEFINITION_SCHEMA_ID && !materialIsSchemaDocument(material);
+}

package/src/tooling/portable/providers/schema.bootstrap.provenance.js

@@ -0,0 +1,10 @@
+const runtimeOwnedBootstrapSources = new WeakSet();
+
+export function markPortableBootstrapCanonicalSource(source = {}) {
+  if (source && typeof source === 'object') runtimeOwnedBootstrapSources.add(source);
+  return source;
+}
+
+export function hasPortableBootstrapCanonicalProvenance(source = null) {
+  return Boolean(source && typeof source === 'object' && runtimeOwnedBootstrapSources.has(source));
+}

package/src/tooling/portable/providers/schema.provider.qualification.js

@@ -0,0 +1,52 @@
+import { canonicalC14nV2SelfState } from '../../../integrity/integrity.c14nV2.js';
+
+export function qualifyPortableSchemaMaterial({ path = '', source = {}, binding = null, checksum = '', markdown = '', runtimeBootstrapProvenance = false } = {}) {
+  const integrity = canonicalC14nV2SelfState(markdown || '');
+  const bundledCanonicalSnapshot = Boolean(
+    runtimeBootstrapProvenance === true
+    && source.providerId === 'bootstrap-canonical-schema-pack'
+    && source.qualification === 'bundled-byte-bound-canonical-snapshot'
+    && source.repository
+    && source.commit
+    && source.path
+    && integrity.state === 'verified'
+  );
+  const repositoryMatch = Boolean(binding?.sourceRepository && source.repository && binding.sourceRepository === source.repository);
+  const pathMatch = Boolean(binding?.sourcePath && normalizePath(binding.sourcePath) === normalizePath(path));
+  const commitMatch = Boolean(binding?.sourceCommit && source.commit && binding.sourceCommit === source.commit);
+  const expectedChecksum = String(binding?.checksum?.value || binding?.checksum || '');
+  const checksumMatch = Boolean(expectedChecksum && checksum && expectedChecksum === checksum);
+  const bindingMatch = Boolean(binding && repositoryMatch && pathMatch && commitMatch && (!checksum || checksumMatch));
+  const authority = bindingMatch
+    ? 'canonical-binding-match'
+    : bundledCanonicalSnapshot
+      ? 'bundled-canonical-self-verified'
+      : source.authority === 'canonical-core'
+        ? 'provider-declared-canonical-unverified'
+        : source.cached
+          ? 'cache-preserved-source-qualification'
+          : 'supplied-unverified';
+  const limitations = [];
+  if (!bindingMatch && binding) limitations.push('Registered binding was not fully matched by explicit repository, commit, path, and optional checksum metadata.');
+  if (!binding) limitations.push('Schema is not registered in the current site runtime; readable schema material is available but executable child tooling may be unavailable.');
+  if (source.qualification === 'bundled-byte-bound-canonical-snapshot' && !bundledCanonicalSnapshot) limitations.push('Bundled canonical snapshot metadata was present but runtime-owned bootstrap provenance, c14n-v2 self-integrity, or required source identity could not be verified.');
+  if (!source.repository && source.remoteFetch) limitations.push('Remote material lacks explicit repository identity.');
+  return Object.freeze({
+    exactSchemaIdentity: true,
+    authority,
+    sourceQualified: Boolean(bindingMatch || bundledCanonicalSnapshot),
+    representationIntegrity: integrity.state,
+    bindingMatch,
+    registered: Boolean(binding),
+    repositoryMatch,
+    pathMatch,
+    commitMatch,
+    checksumMatch,
+    remoteFetch: Boolean(source.remoteFetch),
+    cached: Boolean(source.cached),
+    runtimeBootstrapProvenance: Boolean(runtimeBootstrapProvenance),
+    limitations: Object.freeze(limitations)
+  });
+}
+
+function normalizePath(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/{2,}/g, '/'); }