@tiinex/core 0.1.1

package/src/schemas/creation.renderer.js

@@ -0,0 +1,244 @@
+import { sealC14nV2Self, validatedC14nV2PrimarySelfDigest } from '../integrity/integrity.c14nV2.js';
+import { schemaIdForRecord } from './schema.identity.js';
+import { canonicalRootCreatedAt } from './creation.rootMetadata.js';
+import { renderSchemaReference } from './schema.reference.js';
+import { C14N_V2_METHOD_ID, renderIntegrityMethodReference } from '../integrity/integrity.methodReference.js';
+
+export const GENERIC_ARTIFACT_CREATION_RENDERER_ID = 'tiinex.site.generic-artifact-creation-renderer.v1';
+
+export function renderArtifactCreationDraftMarkdown(contract = {}, input = {}) {
+  const parentRecord = input.parentRecord || {};
+  const rootCreation = String(contract?.transitionType || 'create-artifact') === 'create-artifact';
+  const currentSchemaId = String(input.currentSchemaId || contract.target?.schemaId || '').trim();
+  const createdAt = canonicalRootCreatedAt(input.createdAt);
+  const values = creationValues(input);
+  const summaryBinding = (contract?.creation?.inputBindings || []).find((binding) => binding?.kind === 'root-current-summary-body-title');
+  const boundSummary = summaryBinding ? creationValue(values, summaryBinding.input) : undefined;
+  const hasBoundSummary = Boolean(summaryBinding && boundSummary !== undefined);
+  const boundSummaryText = hasBoundSummary ? exactOneLineValue(boundSummary, 'Summary') : '';
+  if (hasBoundSummary && input.title !== undefined && String(input.title) !== boundSummaryText) throw new Error('creation-summary-title-conflict');
+  if (hasBoundSummary && input.summary !== undefined && String(input.summary) !== boundSummaryText) throw new Error('creation-summary-envelope-conflict');
+  const title = hasBoundSummary ? boundSummaryText : exactOneLineValue(input.title !== undefined ? input.title : `${contract.target?.label || labelFromSchemaId(currentSchemaId)} Draft`, 'title');
+  const summary = hasBoundSummary ? boundSummaryText : exactOneLineValue(input.summary !== undefined ? input.summary : title, 'summary');
+  const authorsValue = input.authors !== undefined ? input.authors : creationValue(values, 'Authors');
+  const authors = authorsValue === undefined ? '' : exactOneLineValue(authorsValue, 'Authors');
+  const whyValue = input.why !== undefined ? input.why : creationValue(values, 'Why');
+  const why = whyValue === undefined || String(whyValue) === '' ? '' : exactOneLineValue(whyValue, 'Why');
+  const statusValue = input.status !== undefined ? input.status : creationValue(values, 'Status');
+  const status = statusValue === undefined || String(statusValue) === '' ? '' : exactOneLineValue(statusValue, 'Status');
+  const bodyMarkdown = input.bodyMarkdown !== undefined ? String(input.bodyMarkdown) : contractDrivenBodyMarkdown(contract, { title, values });
+  const rootSchemaId = 'tiinex.root.v1';
+  const envelopeSchemaReference = renderSchemaReference(contract?.schemaReferences?.envelope || { schemaId: rootSchemaId });
+  const currentSchemaReference = renderSchemaReference(contract?.schemaReferences?.current || { schemaId: currentSchemaId });
+  const parent = parentEnvelope(parentRecord, input.childPath || '');
+  const integrityMethodReference = renderIntegrityMethodReference(contract?.integrityMethodReferences?.primarySelf || { methodId: C14N_V2_METHOD_ID });
+  if (rootCreation && parent) throw new Error('creation-root-parent-not-authorized');
+  if (!rootCreation && !parent) throw new Error('creation-continuation-parent-required');
+  const lines = [
+    '# Continuity Context', '',
+    `- Envelope Schema: ${envelopeSchemaReference}`,
+    ...(parent ? renderParent(parent) : []),
+    '- Current',
+    `  - Current Schema: ${currentSchemaReference}`,
+    `  - Created At: ${createdAt}`,
+    ...(authors ? [`  - Authors: ${authors}`] : []),
+    ...(why ? [`  - Why: ${why}`] : []),
+    `  - Summary: ${summary}`,
+    ...(status ? [`  - Status: ${status}`] : []),
+    '', '---', '', bodyMarkdown, '', '---', '', '# Continuity Integrity', '',
+    ...(parent ? [
+      `- ${integrityMethodReference}`,
+      `  - Towards: [${parent.traceLabel}](${parent.integrityTarget})`,
+      `  - Value: ${parent.primarySelfDigest}`,
+      ''
+    ] : []),
+    `- ${integrityMethodReference}`,
+    '  - Towards: self',
+    '  - Value: pending'
+  ];
+  const unsigned = lines.join('\n');
+  const sealed = sealC14nV2Self(unsigned);
+  if (sealed.state !== 'sealed') throw new Error(`creation-integrity-seal-${sealed.reason || sealed.state}`);
+  return sealed.markdown;
+}
+
+export const genericArtifactCreationImplementation = Object.freeze({
+  status: 'implemented',
+  renderer: Object.freeze({ id: GENERIC_ARTIFACT_CREATION_RENDERER_ID, scope: 'contract-driven-browser-local-draft' }),
+  execute: renderArtifactCreationDraftMarkdown
+});
+
+function renderParent(parent) {
+  return [
+    '- Parent',
+    `  - Parent Schema: ${renderSchemaReference(parent.schemaReferenceAuthority)}`,
+    ...(parent.createdAt ? [`  - Created At: ${parent.createdAt}`] : []),
+    `  - Trace: [${parent.traceLabel}](${parent.traceReference})`,
+    '  - Origin:',
+    ...(parent.relativeReference ? [`    - [relative](${parent.relativeReference})`] : []),
+    ...(parent.publishedReference ? [`    - [browse + git](${parent.publishedReference})`] : [])
+  ];
+}
+
+function contractDrivenBodyMarkdown(contract = {}, { title = '', values = {} } = {}) {
+  const creation = contract?.creation || {};
+  const bindings = Array.isArray(creation.inputBindings) ? creation.inputBindings : [];
+  const supplementalRequiredFields = Array.isArray(creation.supplementalRequiredFields) ? creation.supplementalRequiredFields : [];
+  const sections = Array.isArray(creation.representationSections) && creation.representationSections.length
+    ? creation.representationSections
+    : (Array.isArray(creation.requiredSections) ? creation.requiredSections : []);
+  if (!sections.length) throw new Error('creation-representation-required-sections-unavailable');
+  const lines = [`# ${title}`];
+  if ((creation.requiredShape || []).some((item) => String(item?.primitive?.kind || '') === 'body-prose-block')) {
+    lines.push('', 'Provide the required unheaded body prose here.');
+  }
+  for (const section of sections) {
+    const sectionBindings = bindings.filter((candidate) => candidate?.section === section && candidate?.kind !== 'root-current-summary-body-title');
+    if (!sectionBindings.length) throw new Error(`creation-input-binding-unavailable:${section}`);
+    lines.push('', `## ${section}`, '');
+    if (sectionBindings.length === 1 && sectionBindings[0]?.kind === 'section-body') {
+      const binding = sectionBindings[0];
+      const value = creationValue(values, binding.input);
+      if (value === undefined || String(value).trim() === '') throw new Error(`creation-required-input-missing:${binding.input}`);
+      lines.push(String(value));
+      continue;
+    }
+    const fieldBindings = sectionBindings.filter((binding) => binding?.kind === 'ordinary-field');
+    const groupBindings = sectionBindings.filter((binding) => binding?.kind === 'ordinary-group');
+    const declarationBindings = sectionBindings.filter((binding) => binding?.kind === 'named-declaration-section');
+    if (fieldBindings.length && groupBindings.length) throw new Error(`creation-section-binding-ambiguous:${section}`);
+    if ((fieldBindings.length || groupBindings.length) && declarationBindings.length) throw new Error(`creation-section-binding-ambiguous:${section}`);
+    if (declarationBindings.length > 1 || groupBindings.length > 1) throw new Error(`creation-section-binding-ambiguous:${section}`);
+    if (fieldBindings.length) {
+      for (const binding of fieldBindings) {
+        const value = creationValue(values, binding.input);
+        if (value === undefined) throw new Error(`creation-required-input-missing:${binding.input}`);
+        lines.push(`- ${binding.field || binding.input}: ${exactOneLineValue(value, binding.input)}`);
+      }
+      for (const supplemental of supplementalRequiredFields.filter((item) => String(item?.section || '') === String(section || ''))) {
+        lines.push(`- ${supplemental.field}: ${exactOneLineValue(supplemental.value, supplemental.field)}`);
+      }
+      continue;
+    }
+    if (groupBindings.length === 1) {
+      lines.push(...renderOrdinaryGroupBinding(groupBindings[0], creationValue(values, groupBindings[0].input)));
+      continue;
+    }
+    if (declarationBindings.length === 1) {
+      lines.push(...renderNamedDeclarationBinding(declarationBindings[0], creationValue(values, declarationBindings[0].input)));
+      continue;
+    }
+    throw new Error(`creation-input-binding-unavailable:${section}`);
+  }
+  return lines.join('\n');
+}
+
+function renderOrdinaryGroupBinding(binding = {}, value) {
+  const object = structuredObject(value, binding.input);
+  const required = [...(binding.requiredFields || [])];
+  const optional = [...(binding.optionalFields || [])];
+  const allowed = new Set([...required, ...optional]);
+  for (const field of required) if (!Object.prototype.hasOwnProperty.call(object, field)) throw new Error(`creation-required-structured-field-missing:${binding.input}:${field}`);
+  for (const field of Object.keys(object)) if (!allowed.has(field)) throw new Error(`creation-structured-field-unqualified:${binding.input}:${field}`);
+  const lines = [];
+  for (const field of [...required, ...optional]) {
+    if (!Object.prototype.hasOwnProperty.call(object, field)) continue;
+    lines.push(`- ${field}: ${exactOneLineValue(object[field], `${binding.input}.${field}`)}`);
+  }
+  return lines;
+}
+
+function renderNamedDeclarationBinding(binding = {}, value) {
+  if (typeof value === 'string' && value === 'none' && binding.allowLiteralNone === true) return ['- none'];
+  if (!Array.isArray(value) || value.length === 0) throw new Error(`creation-declaration-list-required:${binding.input}`);
+  const required = [...(binding.requiredFields || [])];
+  const optional = [...(binding.optionalFields || [])];
+  const allowed = new Set([...required, ...optional]);
+  const seen = new Set();
+  const lines = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) throw new Error(`creation-declaration-entry-invalid:${binding.input}`);
+    const name = exactOneLineValue(entry.name, `${binding.input}.name`);
+    if (name === 'none') throw new Error(`creation-declaration-name-reserved:${binding.input}`);
+    if (seen.has(name)) throw new Error(`creation-declaration-name-duplicate:${binding.input}:${name}`);
+    seen.add(name);
+    const fields = structuredObject(entry.fields, `${binding.input}.${name}.fields`);
+    for (const field of required) if (!Object.prototype.hasOwnProperty.call(fields, field)) throw new Error(`creation-required-structured-field-missing:${binding.input}:${field}`);
+    for (const field of Object.keys(fields)) if (!allowed.has(field)) throw new Error(`creation-structured-field-unqualified:${binding.input}:${field}`);
+    lines.push(`- ${name}`);
+    for (const field of [...required, ...optional]) {
+      if (!Object.prototype.hasOwnProperty.call(fields, field)) continue;
+      lines.push(`  - ${field}: ${exactOneLineValue(fields[field], `${binding.input}.${name}.${field}`)}`);
+    }
+  }
+  return lines;
+}
+
+function structuredObject(value, label = 'value') {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`creation-structured-object-required:${label}`);
+  return value;
+}
+function creationValues(input = {}) {
+  const explicit = input.values && typeof input.values === 'object' && !Array.isArray(input.values) ? input.values : {};
+  const alternate = input.inputs && typeof input.inputs === 'object' && !Array.isArray(input.inputs) ? input.inputs : {};
+  return Object.freeze({ ...alternate, ...explicit });
+}
+function creationValue(values = {}, name = '') { return Object.prototype.hasOwnProperty.call(values, name) ? values[name] : undefined; }
+
+function parentEnvelope(record = {}, childPath = '') {
+  const hasParent = Boolean(record?.id || record?.path || record?.schemaId || record?.currentSchemaId || record?.publishedReference);
+  if (!hasParent) return null;
+  const schemaId = schemaIdForRecord(record);
+  const parentPath = normalizePath(record.path);
+  const child = normalizePath(childPath);
+  const recoveryMode = normalizeParentRecoveryMode(record.recoveryMode || record.parentRecoveryMode || 'local-relative');
+  const published = normalizePublishedReference(record.publishedReference || record.browseGitReference || record.browseGit || '');
+  const publishedReference = published.state === 'qualified' ? published.target : '';
+  const relativeReference = recoveryMode === 'external-versioned' ? '' : String(record.relativeReference || relativePath(dirname(child), parentPath)).trim();
+  const traceReference = recoveryMode === 'external-versioned' ? publishedReference : relativeReference;
+  const schemaReferenceAuthority = normalizeParentSchemaReferenceAuthority(record.schemaReferenceAuthority || record.parentSchemaReferenceAuthority, schemaId);
+  if (!schemaId || !parentPath || !child || !traceReference) throw new Error('creation-parent-identity-incomplete');
+  if (recoveryMode === 'external-versioned' && !publishedReference) throw new Error('creation-parent-external-versioned-reference-required');
+  const parentSelf = validatedC14nV2PrimarySelfDigest(record.markdown || '');
+  if (parentSelf.state !== 'verified') throw new Error(`creation-parent-primary-self-${parentSelf.reason || parentSelf.state}`);
+  const integrityTarget = publishedReference || relativeReference;
+  if (!integrityTarget) throw new Error('creation-parent-integrity-target-unavailable');
+  return Object.freeze({
+    schemaId,
+    schemaReferenceAuthority,
+    createdAt: String(record.createdAt || '').trim(),
+    recoveryMode,
+    traceReference,
+    relativeReference,
+    publishedReference,
+    integrityTarget,
+    primarySelfDigest: parentSelf.value,
+    traceLabel: basename(parentPath)
+  });
+}
+
+function normalizeParentRecoveryMode(value = '') { return String(value || '').trim() === 'external-versioned' ? 'external-versioned' : 'local-relative'; }
+function normalizePublishedReference(value) {
+  if (typeof value === 'string') return Object.freeze({ target: value, state: value ? 'unresolved' : 'unavailable' });
+  return Object.freeze({ target: String(value?.target || value?.url || ''), state: String(value?.state || value?.resolutionState || 'unresolved') });
+}
+function normalizeParentSchemaReferenceAuthority(value, schemaId) {
+  if (typeof value === 'string') return Object.freeze({ schemaId, exactTargets: Object.freeze([value]), preferredTarget: value, resolutionState: 'unresolved' });
+  const target = String(value?.preferredTarget || value?.target || '');
+  const exactTargets = [...new Set([...(value?.exactTargets || []), target].map(String).filter(Boolean))];
+  return Object.freeze({ schemaId: String(value?.schemaId || schemaId), exactTargets: Object.freeze(exactTargets), preferredTarget: target || exactTargets[0] || '', resolutionState: String(value?.resolutionState || value?.state || 'unresolved') });
+}
+function exactOneLineValue(value, label = 'value') {
+  const text = String(value ?? '');
+  if (!text || /[\r\n]/.test(text) || text !== text.trim()) throw new Error(`creation-one-line-value-unrepresentable:${label}`);
+  return text;
+}
+function labelFromSchemaId(id = '') { const tail = String(id || '').split('.').filter(Boolean).slice(-2, -1)[0] || String(id || 'artifact'); return tail.charAt(0).toUpperCase() + tail.slice(1); }
+function normalizePath(value='') { return String(value || '').replace(/\\/g,'/').replace(/^\.\//,'').replace(/^\/+|\/+$/g,''); }
+function dirname(value='') { const p=normalizePath(value); const i=p.lastIndexOf('/'); return i<0?'':p.slice(0,i); }
+function basename(value='') { const p=normalizePath(value); return p.split('/').pop() || 'parent'; }
+function relativePath(fromDir='', toPath='') {
+  const from=normalizePath(fromDir).split('/').filter(Boolean), to=normalizePath(toPath).split('/').filter(Boolean);
+  let i=0; while (i<from.length && i<to.length && from[i]===to[i]) i+=1;
+  return [...Array(from.length-i).fill('..'), ...to.slice(i)].join('/') || basename(toPath);
+}

package/src/schemas/creation.representation.js

@@ -0,0 +1,279 @@
+import { C14N_V2_METHOD_ID, qualifyIntegrityMethodReferenceValue } from '../integrity/integrity.methodReference.js';
+import { isMarkdownLink, isRelativePath } from './reference.shapes.js';
+
+export function inspectCreationRepresentation(markdown = '', options = {}) {
+  const text = String(markdown || '').replace(/\r\n?/g, '\n');
+  const lines = text.split('\n');
+  const boundary = lines.findIndex((line) => line === '---');
+  const envelopeLines = boundary >= 0 ? lines.slice(0, boundary) : lines.slice();
+  const integrityHeadingIndexes = indexesOf(lines, (line) => line === '# Continuity Integrity');
+  const integrityStart = integrityHeadingIndexes.length ? integrityHeadingIndexes[0] : lines.length;
+  const footerSeparatorIndexes = integrityHeadingIndexes.filter((index) => canonicalDividerImmediatelyBefore(lines, index));
+  const bodyEnd = footerSeparatorIndexes.length === 1 ? footerSeparatorIndexes[0] - 2 : integrityStart;
+  const bodyLines = boundary >= 0 ? lines.slice(boundary + 1, bodyEnd) : [];
+  const currentBlocks = topLevelListBlocks(envelopeLines, 'Current');
+  const parentBlocks = topLevelListBlocks(envelopeLines, 'Parent');
+  const boundSections = [...new Set((options.boundSections || []).map((value) => String(value || '')).filter(Boolean))];
+  const bodyH1 = headingOccurrences(bodyLines, 1);
+  const bodyH2 = headingOccurrences(bodyLines, 2);
+  const sectionBodies = Object.fromEntries(boundSections.map((section) => [section, Object.freeze(exactSectionBodies(bodyLines, section))]));
+  const integrityEntriesDetailed = integrityEntries(lines, integrityHeadingIndexes);
+  const selfEntries = integrityEntriesDetailed.filter(isSelf);
+  return Object.freeze({
+    schema: 'tiinex.site.creation-representation-occurrences.v1',
+    continuityContextHeadings: countExact(envelopeLines, '# Continuity Context'),
+    envelopeSeparators: boundary >= 0 ? 1 : 0,
+    currentBlocks: currentBlocks.length,
+    parentBlocks: parentBlocks.length,
+    envelopeSchema: Object.freeze(topLevelFieldValues(envelopeLines, 'Envelope Schema')),
+    currentSchema: Object.freeze(currentFieldValues(currentBlocks, 'Current Schema')),
+    createdAt: Object.freeze(currentFieldValues(currentBlocks, 'Created At')),
+    summary: Object.freeze(currentFieldValues(currentBlocks, 'Summary')),
+    bodyH1: Object.freeze(bodyH1),
+    bodyH2: Object.freeze(bodyH2),
+    sectionBodies: Object.freeze(sectionBodies),
+    integrityHeadings: integrityHeadingIndexes.length,
+    footerSeparators: footerSeparatorIndexes.length,
+    integrityEntries: integrityEntriesDetailed.length,
+    integrityEntryDetails: Object.freeze(integrityEntriesDetailed),
+    selfIntegrityEntries: Object.freeze(selfEntries)
+  });
+}
+
+export function qualifyRootCreationRepresentation(markdown = '', contract = {}) {
+  const creation = contract?.creation || {};
+  const summaryBound = (creation.inputBindings || []).some((item) => item?.kind === 'root-current-summary-body-title');
+  const sections = [...new Set([...(creation.representationSections || []), ...(creation.requiredSections || []), ...(creation.inputBindings || []).map((item) => item?.section).filter(Boolean)])];
+  const observed = inspectCreationRepresentation(markdown, { boundSections: sections });
+  const findings = [];
+  expectCount(findings, 'Continuity Context heading', observed.continuityContextHeadings, 1);
+  expectCount(findings, 'Envelope Schema field', observed.envelopeSchema.length, 1);
+  expectCount(findings, 'Current block', observed.currentBlocks, 1);
+  expectCount(findings, 'Parent block', observed.parentBlocks, 0);
+  expectCount(findings, 'Current Schema field', observed.currentSchema.length, 1);
+  expectCount(findings, 'Created At field', observed.createdAt.length, 1);
+  if (summaryBound) expectCount(findings, 'Current Summary field', observed.summary.length, 1);
+  expectCount(findings, 'body H1 title', observed.bodyH1.length, 1);
+  expectCount(findings, 'Continuity Integrity heading', observed.integrityHeadings, 1);
+  expectCount(findings, 'canonical divider immediately before Continuity Integrity', observed.footerSeparators, 1);
+  expectCount(findings, 'Continuity Integrity method entry', observed.integrityEntries, 1);
+  expectCount(findings, `${C14N_V2_METHOD_ID} Towards:self entry`, observed.selfIntegrityEntries.length, 1);
+  qualifyPrimarySelfMethodReference(findings, observed, contract);
+  for (const section of sections) expectCount(findings, `bound section ${section}`, observed.sectionBodies[section]?.length || 0, 1);
+  return Object.freeze({ state: findings.length ? 'ambiguous' : 'qualified', findings: Object.freeze(findings), observed });
+}
+
+
+function qualifyPrimarySelfMethodReference(findings, observed, contract) {
+  if (observed.selfIntegrityEntries.length !== 1) return;
+  const authority = contract?.integrityMethodReferences?.primarySelf || null;
+  if (!authority) return;
+  const qualification = qualifyIntegrityMethodReferenceValue(observed.selfIntegrityEntries[0].methodRaw || observed.selfIntegrityEntries[0].method || '', authority);
+  for (const finding of qualification.findings || []) findings.push(finding);
+}
+
+function canonicalDividerImmediatelyBefore(lines, headingIndex) {
+  if (headingIndex < 2) return false;
+  return lines[headingIndex - 1] === '' && lines[headingIndex - 2] === '---';
+}
+
+function expectCount(findings, label, count, expected) {
+  if (count === expected) return;
+  findings.push(`${label} requires exactly ${expected} occurrence${expected === 1 ? '' : 's'}; observed ${count}.`);
+}
+function countExact(lines, exact) { return lines.reduce((count, line) => count + (line === exact ? 1 : 0), 0); }
+function indexesOf(lines, predicate) { const out = []; for (let i = 0; i < lines.length; i += 1) if (predicate(lines[i], i)) out.push(i); return out; }
+function topLevelListBlocks(lines, label) {
+  const starts = indexesOf(lines, (line) => line === `- ${label}`);
+  return starts.map((start) => {
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i += 1) if (/^-\s+\S/.test(lines[i])) { end = i; break; }
+    return Object.freeze({ start, end, lines: Object.freeze(lines.slice(start + 1, end)) });
+  });
+}
+
+function topLevelFieldValues(lines, label) {
+  const escaped = escapeRegExp(label); const out = [];
+  for (const line of lines) {
+    const match = line.match(new RegExp(`^-\\s*${escaped}:\\s*(.*)$`));
+    if (match) out.push(match[1]);
+  }
+  return out;
+}
+
+function currentFieldValues(blocks, label) {
+  const escaped = escapeRegExp(label); const out = [];
+  for (const block of blocks) for (const line of block.lines) {
+    const match = line.match(new RegExp(`^\\s+-\\s*${escaped}:\\s*(.*)$`));
+    if (match) out.push(match[1]);
+  }
+  return out;
+}
+function headingOccurrences(lines, level) {
+  const prefix = '#'.repeat(level); const out = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const match = lines[i].match(new RegExp(`^${prefix}\\s+(.+)$`));
+    if (match) out.push(Object.freeze({ index: i, text: match[1] }));
+  }
+  return out;
+}
+function exactSectionBodies(lines, section) {
+  const heading = `## ${section}`; const starts = indexesOf(lines, (line) => line === heading); const out = [];
+  for (const startHeading of starts) {
+    let start = startHeading + 1; if (lines[start] === '') start += 1;
+    let end = lines.length;
+    for (let i = start; i < lines.length; i += 1) if (/^#{1,2}\s+/.test(lines[i])) { end = i; break; }
+    if (end > start && lines[end - 1] === '') end -= 1;
+    out.push(lines.slice(start, end).join('\n'));
+  }
+  return out;
+}
+function integrityEntryCount(lines, integrityHeadingIndexes) {
+  let count = 0;
+  for (const headingIndex of integrityHeadingIndexes) {
+    const end = nextTopLevelHeading(lines, headingIndex + 1);
+    for (let i = headingIndex + 1; i < end; i += 1) if (/^-\s+\S/.test(lines[i])) count += 1;
+  }
+  return count;
+}
+
+function integrityEntries(lines, integrityHeadingIndexes) {
+  const out = [];
+  for (const headingIndex of integrityHeadingIndexes) {
+    const end = nextTopLevelHeading(lines, headingIndex + 1);
+    let current = null;
+    const flush = () => {
+      if (!current) return;
+      out.push(Object.freeze(current));
+      current = null;
+    };
+    for (let i = headingIndex + 1; i < end; i += 1) {
+      const top = lines[i].match(/^-\s+(.+?)\s*$/);
+      if (top) {
+        flush();
+        current = { methodRaw: top[1], method: stripLink(top[1]), towardsRaw: '', towards: '', towardsLabel: '', valueCount: 0, value: '' };
+        continue;
+      }
+      if (!current) continue;
+      const towards = lines[i].match(/^\s+-\s+Towards:\s*(.*?)\s*$/);
+      if (towards) {
+        current.towardsRaw = towards[1];
+        current.towards = linkTargetOrText(towards[1]);
+        current.towardsLabel = stripLink(towards[1]);
+      }
+      const value = lines[i].match(/^\s+-\s+Value:\s*(.*?)\s*$/);
+      if (value) {
+        current.valueCount += 1;
+        if (current.valueCount === 1) current.value = value[1];
+      }
+    }
+    flush();
+  }
+  return out;
+}
+function isSelf(entry) { return entry.method === C14N_V2_METHOD_ID && entry.towards === 'self'; }
+function nextTopLevelHeading(lines, start) { for (let i = start; i < lines.length; i += 1) if (/^#\s+/.test(lines[i])) return i; return lines.length; }
+function stripLink(value = '') { const text = String(value || '').trim(); const link = text.match(/^\[([^\]]+)\]\([^)]+\)$/); return (link ? link[1] : text).trim(); }
+function linkTargetOrText(value = '') { const text = String(value || '').trim(); const link = text.match(/^\[([^\]]+)\]\(([^)]+)\)$/); return (link ? link[2] : text).trim(); }
+function escapeRegExp(value = '') { return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+export function qualifyContinuationCreationRepresentation(markdown = '', contract = {}, parentRecord = {}, options = {}) {
+  const creation = contract?.creation || {};
+  const sections = [...new Set([...(creation.representationSections || []), ...(creation.requiredSections || []), ...(creation.inputBindings || []).map((item) => item?.section).filter(Boolean)])];
+  const observed = inspectCreationRepresentation(markdown, { boundSections: sections });
+  const findings = [];
+  expectCount(findings, 'Continuity Context heading', observed.continuityContextHeadings, 1);
+  expectCount(findings, 'Envelope Schema field', observed.envelopeSchema.length, 1);
+  expectCount(findings, 'Current block', observed.currentBlocks, 1);
+  expectCount(findings, 'Parent block', observed.parentBlocks, 1);
+  expectCount(findings, 'Current Schema field', observed.currentSchema.length, 1);
+  expectCount(findings, 'Created At field', observed.createdAt.length, 1);
+  expectCount(findings, 'body H1 title', observed.bodyH1.length, 1);
+  expectCount(findings, 'Continuity Integrity heading', observed.integrityHeadings, 1);
+  expectCount(findings, 'canonical divider immediately before Continuity Integrity', observed.footerSeparators, 1);
+  expectCount(findings, 'Continuity Integrity method entry', observed.integrityEntries, 2);
+  expectCount(findings, `${C14N_V2_METHOD_ID} Towards:self entry`, observed.selfIntegrityEntries.length, 1);
+  qualifyPrimarySelfMethodReference(findings, observed, contract);
+  qualifyParentTargetIntegrityEntry(findings, observed, contract, options.parentIntegrityTarget || '');
+  for (const section of sections) expectCount(findings, `bound section ${section}`, observed.sectionBodies[section]?.length || 0, 1);
+
+  const text = String(markdown || '').replace(/\r\n?/g, '\n');
+  const parentBlock = exactTopLevelBlock(text, 'Parent');
+  if (!parentBlock) findings.push('Parent block is required.');
+  else {
+    const traceLines = exactNestedFieldLines(parentBlock, 'Trace');
+    const originHeader = exactNestedFieldLines(parentBlock, 'Origin', { allowEmpty: true });
+    const boundaryLines = exactNestedFieldLines(parentBlock, 'Boundary');
+    expectCount(findings, 'Parent Trace field', traceLines.length, 1);
+    expectCount(findings, 'Parent Origin block', originHeader.length, 1);
+    expectCount(findings, 'undeclared Parent Boundary field', boundaryLines.length, 0);
+    const trace = traceLines[0]?.value || '';
+    if (trace && !isMarkdownLink(trace) && !isRelativePath(trace)) findings.push('Parent Trace must be one Markdown link or one relative path; synthetic record tokens are not Root Trace authority.');
+    if (trace.startsWith('record:')) findings.push('Parent Trace must not use a record: synthetic token.');
+    const origins = originHeader.length ? nestedOriginLinks(parentBlock, originHeader[0].index) : [];
+    const relative = origins.filter((entry) => entry.label === 'relative');
+    const browse = origins.filter((entry) => entry.label === 'browse + git');
+    const publishedReference = parentRecord?.publishedReference || parentRecord?.browseGitReference || parentRecord?.browseGit || null;
+    const publishedTarget = typeof publishedReference === 'string' ? '' : String(publishedReference?.target || publishedReference?.url || '');
+    const publishedState = typeof publishedReference === 'string' ? 'unresolved' : String(publishedReference?.state || publishedReference?.resolutionState || 'unresolved');
+    const publishedQualified = Boolean(publishedTarget && publishedState === 'qualified');
+    const recoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim() === 'external-versioned' ? 'external-versioned' : 'local-relative';
+    if (recoveryMode === 'external-versioned') {
+      if (!publishedQualified) findings.push('External Parent recovery requires one qualified version-stable published representation.');
+      if (origins.length !== 1 || relative.length !== 0 || browse.length !== 1) findings.push('External Parent Origin must contain exactly one [browse + git](...) entry and must not fabricate [relative](...).');
+      if (browse[0]?.target !== publishedTarget) findings.push('Parent browse + git Origin must preserve the exact qualified published Parent representation.');
+      if (linkTargetOrText(trace) !== publishedTarget) findings.push('External Parent Trace must target the exact qualified published Parent representation.');
+    } else {
+      if (relative.length !== 1 || origins.length < 1 || origins.length > 2 || browse.length > 1) findings.push('Directly recoverable local Parent Origin must contain exactly one [relative](...) entry and may contain at most one truthful [browse + git](...) supplement.');
+      if (relative[0]?.target !== String(options.relativeReference || '')) findings.push(`Parent relative Origin must be exactly ${options.relativeReference || '(unavailable)'}.`);
+      if (browse.length && (!publishedQualified || browse[0]?.target !== publishedTarget)) findings.push('Parent browse + git Origin must preserve qualified publication evidence and must not be invented.');
+    }
+  }
+  return Object.freeze({ state: findings.length ? 'ambiguous' : 'qualified', findings: Object.freeze(findings), observed });
+}
+
+
+function qualifyParentTargetIntegrityEntry(findings, observed, contract, expectedTarget = '') {
+  const candidates = (observed.integrityEntryDetails || []).filter((entry) => entry.method === C14N_V2_METHOD_ID && entry.towards !== 'self');
+  expectCount(findings, `${C14N_V2_METHOD_ID} Parent-target entry`, candidates.length, 1);
+  if (candidates.length !== 1) return;
+  const entry = candidates[0];
+  const authority = contract?.integrityMethodReferences?.primarySelf || null;
+  if (authority) {
+    const qualification = qualifyIntegrityMethodReferenceValue(entry.methodRaw || entry.method || '', authority);
+    for (const finding of qualification.findings || []) findings.push(finding);
+  }
+  if (!entry.towards) findings.push('Parent-target integrity Towards value is required.');
+  else if (!expectedTarget) findings.push('Required Parent-target integrity target is unavailable.');
+  else if (entry.towards !== String(expectedTarget)) findings.push(`Parent-target integrity Towards must be exactly ${expectedTarget}.`);
+  expectCount(findings, 'Parent-target integrity Value field', entry.valueCount, 1);
+  if (entry.valueCount === 1 && !entry.value) findings.push('Parent-target integrity Value must not be empty.');
+}
+
+function exactTopLevelBlock(text, label) {
+  const lines = String(text || '').split('\n');
+  const start = lines.findIndex((line) => line === `- ${label}`);
+  if (start < 0) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) if (/^-\s+\S/.test(lines[i])) { end = i; break; }
+  return Object.freeze({ lines: Object.freeze(lines.slice(start + 1, end)) });
+}
+function exactNestedFieldLines(block, label, options = {}) {
+  const escaped = escapeRegExp(label); const out = [];
+  for (let i = 0; i < (block?.lines || []).length; i += 1) {
+    const match = block.lines[i].match(new RegExp(`^  - ${escaped}:\\s*(.*)$`));
+    if (!match) continue;
+    if (match[1] || options.allowEmpty) out.push(Object.freeze({ index: i, value: match[1] }));
+  }
+  return out;
+}
+function nestedOriginLinks(block, originIndex) {
+  const out = [];
+  for (let i = originIndex + 1; i < (block?.lines || []).length; i += 1) {
+    const line = block.lines[i];
+    if (/^  - \S/.test(line)) break;
+    const match = line.match(/^    - \[([^\]]+)\]\(([^)]+)\)$/);
+    if (match) out.push(Object.freeze({ label: match[1], target: match[2] }));
+  }
+  return out;
+}

package/src/schemas/creation.rootMetadata.js

@@ -0,0 +1,6 @@
+export function canonicalRootCreatedAt(value) {
+  if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value)) return value;
+  const date = value instanceof Date ? value : new Date(value);
+  if (!(date instanceof Date) || Number.isNaN(date.getTime())) throw new Error('creation-created-at-unrepresentable');
+  return date.toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, '');
+}

package/src/schemas/creation.schemaReferences.js

@@ -0,0 +1,65 @@
+import { resolveSchemaModule as resolveRegisteredSchemaModule } from './resolver.js';
+import { inspectCreationRepresentation } from './creation.representation.js';
+import { qualifySchemaReferenceMaterialCoherence, qualifySchemaReferenceValue, schemaReferenceAuthorityFromBinding } from './schema.reference.js';
+
+export function schemaReferenceAuthoritiesForCreation(targetModule = null, explicit = null) {
+  const root = resolveRegisteredSchemaModule({ schemaId: 'tiinex.root.v1' });
+  const rootModule = root?.fallbackUsed ? null : root?.module || null;
+  const rootQualification = qualifiedSourceQualification(rootModule);
+  const targetQualification = qualifiedSourceQualification(targetModule);
+  const defaults = {
+    envelope: schemaReferenceAuthorityFromBinding('tiinex.root.v1', rootModule?.binding || {}, rootQualification?.authority || null, rootQualification),
+    current: schemaReferenceAuthorityFromBinding(String(targetModule?.id || ''), targetModule?.binding || {}, targetQualification?.authority || null, targetQualification)
+  };
+  return Object.freeze({
+    envelope: explicitSchemaReferenceAuthority(explicit?.envelope, defaults.envelope),
+    current: explicitSchemaReferenceAuthority(explicit?.current, defaults.current)
+  });
+}
+
+export function explicitSchemaReferenceAuthority(value = null, fallback = {}) {
+  if (!value) return fallback;
+  const schemaId = String(value.schemaId || fallback.schemaId || '').trim();
+  const exactTargets = [...new Set([
+    ...(Array.isArray(value.exactTargets) ? value.exactTargets : []),
+    value.preferredTarget || value.target || ''
+  ].map((item) => String(item || '')).filter(Boolean))];
+  const preferredTarget = String(value.preferredTarget || value.target || exactTargets[0] || '').trim();
+  const fallbackTargets = Object.freeze([...(fallback.exactTargets || [])]);
+  const materialBoundTarget = Boolean(preferredTarget && fallback?.materialBoundTarget === true && fallbackTargets.includes(preferredTarget));
+  return Object.freeze({
+    ...fallback,
+    schemaId,
+    exactTargets: Object.freeze(exactTargets),
+    preferredTarget,
+    targetAuthority: exactTargets.length ? 'explicit-exact-reference' : String(fallback.targetAuthority || 'schema-id-only'),
+    resolutionState: String(value.resolutionState || value.state || (materialBoundTarget ? 'qualified' : 'unresolved')),
+    resolutionEvidence: Object.freeze({ ...(materialBoundTarget ? fallback.resolutionEvidence || {} : {}), ...(value.resolutionEvidence || value.evidence || {}) }),
+    semanticSourceTargets: fallbackTargets,
+    materialBoundTarget,
+    semanticMaterialIdentity: fallback.semanticMaterialIdentity || Object.freeze({ state: 'unavailable' })
+  });
+}
+
+export function qualifyCreationSchemaReferences(markdown = '', contract = {}) {
+  const observed = inspectCreationRepresentation(markdown);
+  const authorities = contract?.schemaReferences || {};
+  const envelopeValue = observed.envelopeSchema.length === 1 ? observed.envelopeSchema[0] : '';
+  const currentValue = observed.currentSchema.length === 1 ? observed.currentSchema[0] : '';
+  const envelope = qualifyResolvedSchemaReference(envelopeValue, authorities.envelope || { schemaId: 'tiinex.root.v1', exactTargets: [] });
+  const current = qualifyResolvedSchemaReference(currentValue, authorities.current || { schemaId: String(contract?.target?.schemaId || ''), exactTargets: [] });
+  const findings = Object.freeze([...(envelope.findings || []).map((item) => `Envelope Schema: ${item}`), ...(current.findings || []).map((item) => `Current Schema: ${item}`)]);
+  return Object.freeze({ state: findings.length ? 'unavailable' : 'qualified', envelope, current, findings });
+}
+
+function qualifyResolvedSchemaReference(value, authority) {
+  const lexical = qualifySchemaReferenceValue(value, authority);
+  const material = qualifySchemaReferenceMaterialCoherence(authority);
+  const findings = [...(lexical.findings || []), ...(material.findings || [])];
+  return Object.freeze({ ...lexical, state: findings.length ? 'unavailable' : 'qualified', resolutionState: authority?.resolutionState || '', materialCoherence: material, findings: Object.freeze(findings) });
+}
+
+function qualifiedSourceQualification(module = null) {
+  const qualified = typeof module?.schemaSource?.qualify === 'function' ? module.schemaSource.qualify() : null;
+  return qualified?.state === 'qualified' ? qualified : null;
+}

package/src/schemas/discovery/finding/tiinex.discovery.finding.v1.schema.js

@@ -0,0 +1,14 @@
+import binding from './tiinex.discovery.finding.v1.schema.json' with { type: 'json' };
+import { schemaSource } from './tiinex.discovery.finding.v1.schema.source.js';
+import { defineGenericArtifactSchemaModule } from '../../generic.artifact.module.js';
+
+export const discoveryFindingSchemaModule = defineGenericArtifactSchemaModule({
+  id: 'tiinex.discovery.finding.v1',
+  label: 'Discovery Finding',
+  parentSchemaId: 'tiinex.discovery.v1',
+  kind: 'concrete',
+  role: 'workflow-discovery-finding-artifact',
+  summary: 'Maintained discovered finding/triage artifact.',
+  binding,
+  schemaSource
+});

package/src/schemas/discovery/finding/tiinex.discovery.finding.v1.schema.json

@@ -0,0 +1,23 @@
+{
+  "schemaId": "tiinex.discovery.finding.v1",
+  "kind": "concrete",
+  "role": "workflow-discovery-finding-artifact",
+  "module": "./tiinex.discovery.finding.v1.schema.js",
+  "snapshot": "./tiinex.discovery.finding.v1.schema.md",
+  "canonicalUri": "tiinex://schemas/discovery/finding/tiinex.discovery.finding.v1",
+  "permalink": "https://github.com/Tiinex/docs/blob/e713557f8be630967571d11a73f9ecd05ae329ce/.topics/.schemas/discovery/finding/tiinex.discovery.finding.v1.schema.md",
+  "rawUrl": "https://raw.githubusercontent.com/Tiinex/docs/e713557f8be630967571d11a73f9ecd05ae329ce/.topics/.schemas/discovery/finding/tiinex.discovery.finding.v1.schema.md",
+  "sourcePath": ".topics/.schemas/discovery/finding/tiinex.discovery.finding.v1.schema.md",
+  "sourceRepository": "Tiinex/docs",
+  "sourceCommit": "e713557f8be630967571d11a73f9ecd05ae329ce",
+  "sourceBlobSha": "e4f4b5caaf590ed3dc138b5bf2f25e2ece85e6b8",
+  "checksum": {
+    "algorithm": "sha256",
+    "value": "dafb380d7ee1b0cfe91bc1db3c5c18a40fc3826d2120bb71f54491b885d2b696"
+  },
+  "capabilityContract": "tiinex.schema.module.v1",
+  "snapshotCompleteness": "exact-canonical-docs-snapshot",
+  "bindingVersion": "tiinex.web.schema-binding.v1",
+  "originId": "tiinex-docs-e713557f",
+  "originTrustRole": "canonical-core"
+}