@tiinex/app 0.1.1

package/src/artifacts/artifact.identityAggregation.js

@@ -0,0 +1,218 @@
+import '../sources/source.identity.js';
+
+export function collectLoadedArtifactAggregates(input = {}, declaredSchemaIdForRecord = () => '', metadataSchemaIdForRecord = () => '', canonicalSchemaId = '', identityPrefix = 'tiinex.artifact.registry') {
+  const aggregates = new Map();
+  const append = (record, containingWorkspaceId = '') => {
+    if (!record || typeof record !== 'object') return;
+    const memberships = recordWorkspaceMemberships(record, containingWorkspaceId);
+    const identity = artifactRegistryIdentityForRecord(record, memberships, declaredSchemaIdForRecord, metadataSchemaIdForRecord, identityPrefix);
+    const observation = {
+      record,
+      memberships,
+      representation: normalizedRepresentation(record.markdown || ''),
+      declaredSchemaId: String(declaredSchemaIdForRecord(record) || '').trim(),
+      metadataSchemaId: String(metadataSchemaIdForRecord(record) || '').trim()
+    };
+    const existing = aggregates.get(identity.key);
+    if (existing) {
+      for (const membership of memberships) existing.workspaceIds.add(membership);
+      existing.observations.push(observation);
+      return;
+    }
+    aggregates.set(identity.key, { identity, observations: [observation], workspaceIds: new Set(memberships) });
+  };
+  for (const record of Array.isArray(input.records) ? input.records : []) append(record);
+  for (const workspace of Array.isArray(input.state?.workspaces) ? input.state.workspaces : []) {
+    for (const record of Array.isArray(workspace?.records) ? workspace.records : []) append(record, workspace?.id || '');
+  }
+  return [...aggregates.values()].map((aggregate) => finalizeRecordAggregate(aggregate, canonicalSchemaId));
+}
+
+export function artifactRegistryIdentityForRecord(record = {}, workspaceIds = [], declaredSchemaIdForRecord = () => '', metadataSchemaIdForRecord = () => '', identityPrefix = 'tiinex.artifact.registry') {
+  const boundary = artifactSourceBoundaryIdentity(record);
+  const sourceArtifactPath = canonicalSourceArtifactPath(record);
+  const inputTarget = String(record.sourceTarget?.inputTarget || '').trim();
+  if (boundary?.key && sourceArtifactPath) {
+    return Object.freeze({
+      global: true,
+      kind: 'configured-source',
+      key: ['source-boundary', boundary.key, sourceArtifactPath].join('\u0000'),
+      id: registryIdentityId(identityPrefix, 'source-boundary', [boundary.key, sourceArtifactPath]),
+      sourceBoundary: boundary,
+      boundaryKey: boundary.key,
+      boundarySignature: boundary.signature,
+      sourceArtifactPath
+    });
+  }
+  if (inputTarget) {
+    const artifactScoped = Boolean(sourceArtifactPath && embeddedIssueArtifact(record));
+    const kind = artifactScoped ? 'input-target-artifact' : 'input-target';
+    const identityParts = artifactScoped ? [inputTarget, sourceArtifactPath] : [inputTarget];
+    return Object.freeze({
+      global: true,
+      kind,
+      key: ['target', ...identityParts].join('\u0000'),
+      id: registryIdentityId(identityPrefix, kind, identityParts),
+      inputTarget,
+      sourceArtifactPath: artifactScoped ? sourceArtifactPath : ''
+    });
+  }
+  const membershipScope = (Array.isArray(workspaceIds) ? workspaceIds : []).join(',');
+  const key = ['workspace-record', membershipScope, record.id || '', record.path || ''].join('\u0000');
+  return Object.freeze({
+    global: false,
+    kind: 'workspace-record',
+    key,
+    id: String(record.id || registryIdentityId(identityPrefix, 'workspace-record', [membershipScope, record.path || '']))
+  });
+}
+
+export function readArtifactRepresentationQualification(record = {}) {
+  const aggregation = record.registryAggregation || {};
+  const variants = Array.isArray(aggregation.representationVariants) ? aggregation.representationVariants : [];
+  return Object.freeze({
+    state: String(aggregation.representationState || (variants.length ? 'equivalent' : 'unresolved')),
+    observationCount: Number(aggregation.observationCount || (variants.length ? 1 : 0)),
+    variantCount: variants.length,
+    variants: Object.freeze(variants.map((variant) => Object.freeze({
+      markdown: String(variant.markdown || ''),
+      recordIds: Object.freeze([...(variant.recordIds || [])]),
+      workspaceIds: Object.freeze([...(variant.workspaceIds || [])])
+    }))),
+    reconciliationStatuses: Object.freeze([...(aggregation.reconciliationStatuses || [])])
+  });
+}
+
+export function readArtifactSchemaQualification(record = {}, canonicalSchemaId = '') {
+  const aggregation = record.registryAggregation || {};
+  const declaredSchemaIds = [...(aggregation.declaredSchemaIds || [])];
+  return Object.freeze({
+    state: String(aggregation.schemaState || (declaredSchemaIds.length === 1 ? 'equivalent' : 'unresolved')),
+    declaredSchemaIds: Object.freeze(declaredSchemaIds),
+    canonicalSchemaId: String(canonicalSchemaId || aggregation.canonicalSchemaId || ''),
+    canonicalObserved: aggregation.canonicalSchemaObserved === true,
+    unresolvedObservationCount: Number(aggregation.unresolvedSchemaObservationCount || 0),
+    observationCount: Number(aggregation.observationCount || 0)
+  });
+}
+
+export function artifactSourceBoundaryIdentity(record = {}) {
+  const source = record.source || {};
+  return globalThis.TiinexSourceIdentity?.configuredSourceBoundaryIdentity?.({
+    repository: source.repository || source.repo || source.config?.repo || '',
+    ref: source.ref || source.requestedRef || source.config?.ref || '',
+    rootPath: source.rootPath || source.config?.rootPath || '.topics'
+  }) || null;
+}
+
+export function artifactSourceBoundarySignature(record = {}) {
+  return String(artifactSourceBoundaryIdentity(record)?.signature || '');
+}
+
+function finalizeRecordAggregate(aggregate = {}, canonicalSchemaId = '') {
+  const memberships = [...(aggregate.workspaceIds || [])].sort();
+  const observations = [...(aggregate.observations || [])].sort(compareObservations);
+  const schemaQualification = schemaAggregateQualification(observations, canonicalSchemaId);
+  const representative = representativeObservation(observations, canonicalSchemaId)?.record || {};
+  const loadedRecordIds = [...new Set(observations.map((item) => String(item.record?.id || '').trim()).filter(Boolean))].sort();
+  const loadedSourceIds = [...new Set(observations.map((item) => String(item.record?.source?.id || '').trim()).filter(Boolean))].sort();
+  const variants = representationVariants(observations);
+  const reconciliationStatuses = [...new Set(observations.map((item) => String(item.record?.materialReconciliation?.status || '').trim()).filter(Boolean))].sort();
+  const representationState = representationAggregateState(variants, reconciliationStatuses);
+  const identity = aggregate.identity || {};
+  return Object.assign({}, representative, {
+    id: identity.global ? String(loadedRecordIds[0] || identity.id || '') : String(representative.id || identity.id || ''),
+    workspaceId: memberships[0] || '',
+    workspaceIds: memberships,
+    registryIdentity: identity,
+    loadedRecordIds,
+    loadedSourceIds,
+    registryAggregation: Object.freeze({
+      observationCount: observations.length,
+      representationState,
+      representationVariants: Object.freeze(variants),
+      reconciliationStatuses: Object.freeze(reconciliationStatuses),
+      schemaState: schemaQualification.state,
+      declaredSchemaIds: Object.freeze(schemaQualification.declaredSchemaIds),
+      canonicalSchemaId: String(canonicalSchemaId || ''),
+      canonicalSchemaObserved: schemaQualification.canonicalObserved,
+      unresolvedSchemaObservationCount: schemaQualification.unresolvedObservationCount
+    })
+  });
+}
+
+function schemaAggregateQualification(observations = [], canonicalSchemaId = '') {
+  const declaredSchemaIds = [...new Set(observations.map((item) => String(item.declaredSchemaId || '').trim()).filter(Boolean))].sort();
+  const unresolvedObservationCount = observations.filter((item) => !String(item.declaredSchemaId || '').trim()).length;
+  const canonicalObserved = Boolean(canonicalSchemaId && declaredSchemaIds.includes(canonicalSchemaId));
+  let state = 'unresolved';
+  if (!unresolvedObservationCount && declaredSchemaIds.length === 1) state = 'equivalent';
+  else if (declaredSchemaIds.length > 1) state = 'conflicting';
+  return { state, declaredSchemaIds, canonicalObserved, unresolvedObservationCount };
+}
+
+function representativeObservation(observations = [], canonicalSchemaId = '') {
+  if (canonicalSchemaId) {
+    const canonical = observations.filter((item) => item.declaredSchemaId === canonicalSchemaId);
+    if (canonical.length) return canonical[0];
+  }
+  return observations[0];
+}
+
+function recordWorkspaceMemberships(record = {}, containingWorkspaceId = '') {
+  const memberships = new Set();
+  const add = (value) => {
+    const id = String(value || '').trim();
+    if (id) memberships.add(id);
+  };
+  add(containingWorkspaceId);
+  add(record.workspaceId);
+  for (const value of Array.isArray(record.workspaceIds) ? record.workspaceIds : []) add(value);
+  return [...memberships].sort();
+}
+
+function compareObservations(left = {}, right = {}) {
+  return String(left.representation || '').localeCompare(String(right.representation || ''))
+    || String(left.declaredSchemaId || '').localeCompare(String(right.declaredSchemaId || ''))
+    || String(left.record?.path || '').localeCompare(String(right.record?.path || ''))
+    || String(left.record?.id || '').localeCompare(String(right.record?.id || ''))
+    || String((left.memberships || []).join(',')).localeCompare(String((right.memberships || []).join(',')));
+}
+
+function representationVariants(observations = []) {
+  const variants = new Map();
+  for (const observation of observations) {
+    const markdown = String(observation.representation || '');
+    const existing = variants.get(markdown) || { markdown, recordIds: new Set(), workspaceIds: new Set() };
+    const recordId = String(observation.record?.id || '').trim();
+    if (recordId) existing.recordIds.add(recordId);
+    for (const workspaceId of observation.memberships || []) if (workspaceId) existing.workspaceIds.add(workspaceId);
+    variants.set(markdown, existing);
+  }
+  return [...variants.values()]
+    .sort((a, b) => a.markdown.localeCompare(b.markdown))
+    .map((variant) => Object.freeze({
+      markdown: variant.markdown,
+      recordIds: Object.freeze([...variant.recordIds].sort()),
+      workspaceIds: Object.freeze([...variant.workspaceIds].sort())
+    }));
+}
+
+function representationAggregateState(variants = [], reconciliationStatuses = []) {
+  if (variants.length > 1 || reconciliationStatuses.includes('checksum-mismatch')) return 'conflicting';
+  if (reconciliationStatuses.includes('same-origin-unverified')) return 'unresolved';
+  return variants.length === 1 ? 'equivalent' : 'unresolved';
+}
+
+function normalizedRepresentation(markdown = '') { return String(markdown || '').replace(/\r\n?/g, '\n'); }
+
+function embeddedIssueArtifact(record = {}) {
+  const mode = String(record.sourceMode || '').trim();
+  const targetKind = String(record.sourceTarget?.targetKind || '').trim();
+  return mode === 'github-issue-embedded-artifact'
+    || mode === 'github-comment-embedded-artifact'
+    || targetKind === 'github-issue-embedded-artifact'
+    || targetKind === 'github-comment-embedded-artifact';
+}
+function canonicalSourceArtifactPath(record = {}) { return String(record.sourceTarget?.sourceArtifactPath || record.path || '').trim().replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/{2,}/g, '/'); }
+function registryIdentityId(prefix, kind, parts = []) { return `${prefix}:${kind}:${parts.map((value) => encodeURIComponent(String(value || ''))).join(':')}`; }

package/src/artifacts/artifact.model.js

@@ -0,0 +1,2 @@
+export const artifactModelVersion = 'tiinex.web.artifact.model.v84';
+export const artifactStates = Object.freeze(['parsed', 'degraded', 'invalid', 'unresolved']);

package/src/artifacts/artifact.parse.case.mjs

@@ -0,0 +1,196 @@
+import assert from 'node:assert/strict';
+import { parseArtifactMarkdown } from '@tiinex/core/artifacts/artifact.parse.js';
+
+const ROOT_WITHOUT_PARENT = `# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+- Current
+  - Current Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+  - Created At: 2026-07-23T00:00:00.000Z
+  - Summary: Root artifact without an artifact parent.
+
+---
+
+# Root Artifact
+
+## Summary
+
+No parent is declared.
+
+# Continuity Integrity
+
+- Method: pending
+  - Value: pending
+`;
+
+const CHILD_SCHEMA_WITHOUT_ARTIFACT_PARENT = `# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+- Current
+  - Current Schema: [tiinex.schema.module.v1](tiinex.schema.module.v1.schema.md)
+  - Created At: 2026-07-23T00:01:00.000Z
+  - Summary: Child schema artifact that inherits schema meaning but declares no artifact parent.
+
+---
+
+# Schema Module
+
+## Summary
+
+No artifact Parent block is declared here.
+
+# Continuity Integrity
+
+- Method: pending
+  - Value: pending
+`;
+
+const CHILD_WITH_PARENT = `# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+- Parent
+  - Parent Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Trace: [parent](parent.trace.md)
+  - Origin: [browse + git](https://github.com/Tiinex/docs/blob/abc/parent.trace.md)
+  - Created At: 2026-07-22T00:00:00.000Z
+- Current
+  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Created At: 2026-07-23T00:02:00.000Z
+  - Summary: Child with declared parent.
+
+---
+
+# Child
+
+# Continuity Integrity
+
+- Method: pending
+  - Value: pending
+`;
+
+const root = parseArtifactMarkdown(ROOT_WITHOUT_PARENT);
+assert.equal(root.envelope.parent.schema.id, '', 'root without Parent must not inherit Current Schema as Parent Schema');
+assert.equal(root.envelope.parent.createdAt, '', 'Current Created At must not leak into Parent Created At');
+assert.equal(root.envelope.parent.trace, '', 'root without Parent must not infer a Trace');
+assert.equal(root.envelope.parent.origin, '', 'root without Parent must not infer an Origin');
+assert.equal(root.envelope.current.schema.id, 'tiinex.root.v1', 'Current Schema remains readable');
+assert.equal(root.envelope.current.createdAt, '2026-07-23T00:00:00.000Z', 'Current Created At remains readable');
+
+const schemaArtifact = parseArtifactMarkdown(CHILD_SCHEMA_WITHOUT_ARTIFACT_PARENT);
+assert.equal(schemaArtifact.envelope.parent.schema.id, '', 'child schema artifact without artifact Parent must not fabricate parent schema');
+assert.equal(schemaArtifact.envelope.parent.trace, '', 'child schema artifact without artifact Parent must not fabricate parent trace');
+assert.equal(schemaArtifact.envelope.current.schema.id, 'tiinex.schema.module.v1', 'child schema Current Schema remains readable');
+
+const child = parseArtifactMarkdown(CHILD_WITH_PARENT);
+assert.equal(child.envelope.parent.schema.id, 'tiinex.topic.v1', 'valid Parent Schema parses');
+assert.equal(child.envelope.parent.trace, 'parent.trace.md', 'valid Parent Trace uses markdown link target for resolution');
+assert.equal(child.envelope.parent.traceLabel, 'parent', 'valid Parent Trace preserves markdown link label for presentation');
+assert.equal(child.envelope.parent.origin, 'https://github.com/Tiinex/docs/blob/abc/parent.trace.md', 'valid Parent Origin parses');
+assert.equal(child.envelope.parent.createdAt, '2026-07-22T00:00:00.000Z', 'valid Parent Created At parses');
+assert.equal(child.envelope.current.createdAt, '2026-07-23T00:02:00.000Z', 'valid Current Created At stays separate');
+
+const CANONICAL_FOOTER_DIVIDER = `# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+- Current
+  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Created At: 2026-07-23T00:02:30.000Z
+  - Summary: Canonical footer divider
+
+---
+
+# Canonical Divider
+
+## Current Read
+
+body sentinel
+
+---
+
+# Continuity Integrity
+
+- sha256-base64url-c14n-v2
+  - Towards: self
+  - Value: pending
+`;
+const canonicalDivider = parseArtifactMarkdown(CANONICAL_FOOTER_DIVIDER);
+assert.equal(canonicalDivider.body.text.includes('---'), false, 'canonical footer divider is representation boundary, not body content');
+assert.equal(canonicalDivider.body.text.endsWith('body sentinel'), true, 'body ends before canonical footer divider');
+assert.equal(canonicalDivider.integrity.entries.length, 1, 'integrity remains readable after canonical footer divider');
+
+
+const CHILD_WITH_RELATIVE_PARENT_LINK = `# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+- Parent
+  - Parent Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Trace: [001.trace.md](../001.trace.md)
+- Current
+  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Created At: 2026-07-23T00:03:00.000Z
+  - Summary: Child with relative parent href.
+
+---
+
+# Child With Relative Parent
+`;
+
+const relativeChild = parseArtifactMarkdown(CHILD_WITH_RELATIVE_PARENT_LINK);
+assert.equal(relativeChild.envelope.parent.trace, '../001.trace.md', 'Parent Trace link href is the resolution target');
+assert.equal(relativeChild.envelope.parent.traceLabel, '001.trace.md', 'Parent Trace label remains available for display');
+
+
+const CHILD_WITH_LABELLED_PARENT_ORIGIN = `# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+- Parent
+  - Parent Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Trace: [001.trace.md](001.trace.md)
+  - Origin:
+    - relative: 001.trace.md
+    - [github git file](https://github.com/Tiinex/docs/blob/main/.topics/area/001.trace.md)
+- Current
+  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Created At: 2026-07-25T00:00:00.000Z
+  - Summary: Child with labelled nested origin.
+
+---
+
+# Child With Labelled Origin
+`;
+const labelledOriginChild = parseArtifactMarkdown(CHILD_WITH_LABELLED_PARENT_ORIGIN);
+assert.equal(labelledOriginChild.envelope.parent.origin, '001.trace.md', 'labelled nested Parent Origin should expose the value, not the label prefix');
+
+
+const INTEGRITY_WITH_TOWARDS = `# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)
+- Parent
+  - Parent Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Trace: [001.trace.md](001.trace.md)
+- Current
+  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)
+  - Summary: Integrity entries
+
+---
+
+# Integrity Entries
+
+# Continuity Integrity
+
+- [sha256-base64url-c14n-v2](validator.md)
+  - Towards: [001.trace.md](001.trace.md)
+  - Value: parent-hash
+
+- [sha256-base64url-c14n-v2](validator.md)
+  - Towards: self
+  - Value: self-hash
+`;
+const integrityEntries = parseArtifactMarkdown(INTEGRITY_WITH_TOWARDS).integrity.entries;
+assert.equal(integrityEntries.length, 2, 'integrity parser should expose structured entries');
+assert.equal(integrityEntries[0].towards, '001.trace.md', 'integrity Towards should prefer link target');
+assert.equal(integrityEntries[0].value, 'parent-hash', 'integrity parent Value should parse');
+assert.equal(integrityEntries[1].towards, 'self', 'integrity self Towards should parse');
+assert.equal(integrityEntries[1].value, 'self-hash', 'integrity self Value should parse');
+
+console.log('✓ artifact parser Parent-block regression guards passed');

package/src/artifacts/artifact.participantIndex.js

@@ -0,0 +1,189 @@
+import { parseArtifactMarkdown } from '@tiinex/core/artifacts/artifact.parse.js';
+import {
+  collectLoadedArtifactAggregates,
+  readArtifactRepresentationQualification,
+  readArtifactSchemaQualification,
+  artifactSourceBoundaryIdentity,
+  artifactRegistryIdentityForRecord
+} from './artifact.identityAggregation.js';
+
+export const ARTIFACT_PARTICIPANT_INDEX_SCHEMA_ID = 'tiinex.site.artifact-participant-index.v1';
+export const ARTIFACT_PARTICIPANT_SCHEMA_ID = 'tiinex.site.artifact-participant.v1';
+const PARTICIPANT_IDENTITY_PREFIX = 'tiinex.artifact.participant';
+
+export function buildLoadedArtifactParticipantIndex(input = {}) {
+  const aggregates = collectLoadedArtifactAggregates(
+    input,
+    declaredRecordSchemaId,
+    metadataRecordSchemaId,
+    '',
+    PARTICIPANT_IDENTITY_PREFIX
+  );
+  const participants = aggregates
+    .filter(hasAnyDeclaredArtifactSchema)
+    .map(buildArtifactParticipantReadModel)
+    .sort(compareParticipants);
+  return Object.freeze({
+    schema: ARTIFACT_PARTICIPANT_INDEX_SCHEMA_ID,
+    count: participants.length,
+    cleanCandidateCount: participants.filter((participant) => participant.cleanCandidate).length,
+    participants: Object.freeze(participants),
+    boundary: Object.freeze({
+      readOnly: true,
+      networkFetch: false,
+      mutation: false,
+      completenessRequired: false
+    })
+  });
+}
+
+export function buildArtifactParticipantReadModel(record = {}) {
+  const representationQualification = readArtifactRepresentationQualification(record);
+  const schemaQualification = readArtifactSchemaQualification(record);
+  const declaredSchemaIds = [...schemaQualification.declaredSchemaIds];
+  const aggregateIdentity = record.registryIdentity || {};
+  const identity = participantIdentityProjection(aggregateIdentity);
+  const cleanCandidate = Boolean(identity.id)
+    && representationQualification.state === 'equivalent'
+    && schemaQualification.state === 'equivalent'
+    && declaredSchemaIds.length === 1;
+  return Object.freeze({
+    schema: ARTIFACT_PARTICIPANT_SCHEMA_ID,
+    identity: Object.freeze({
+      id: identity.id,
+      key: identity.key,
+      kind: identity.kind,
+      global: identity.global
+    }),
+    artifact: Object.freeze({
+      id: String(record.id || ''),
+      loadedRecordIds: Object.freeze([...(record.loadedRecordIds || [record.id]).map(normalizeToken).filter(Boolean)].sort()),
+      workspaceIds: Object.freeze([...(record.workspaceIds || []).map(normalizeToken).filter(Boolean)].sort()),
+      path: String(record.path || ''),
+      title: String(record.title || ''),
+      declaredSchemaId: cleanCandidate ? declaredSchemaIds[0] : '',
+      declaredSchemaIds: Object.freeze(declaredSchemaIds),
+      metadataSchemaId: metadataRecordSchemaId(record),
+      currentCreatedAt: String(record.currentCreatedAt || record.createdAt || '')
+    }),
+    source: sourceProjection(record),
+    representationQualification,
+    schemaQualification,
+    indexedReadable: declaredSchemaIds.length > 0,
+    cleanCandidate,
+    candidateSchemaId: cleanCandidate ? declaredSchemaIds[0] : '',
+    completeness: 'not-evaluated'
+  });
+}
+
+export function participantMatchesSchema(participant = {}, schemaConstraint = '') {
+  if (!participant?.cleanCandidate) return false;
+  const constraint = normalizeSchemaConstraint(schemaConstraint);
+  return !constraint || participant.candidateSchemaId === constraint;
+}
+
+export function resolveCurrentArtifactParticipant(currentArtifact, participantIndex = {}) {
+  if (!currentArtifact) return null;
+  if (currentArtifact.schema === ARTIFACT_PARTICIPANT_SCHEMA_ID) return currentArtifact;
+  const participants = Array.isArray(participantIndex.participants) ? participantIndex.participants : [];
+
+  const suppliedIdentityKey = normalizeToken(currentArtifact.identity?.key || currentArtifact.participantIdentity?.key || currentArtifact.registryIdentity?.key);
+  if (suppliedIdentityKey) {
+    const matches = participants.filter((participant) => participant.identity.key === suppliedIdentityKey);
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) return null;
+  }
+
+  const suppliedIdentityId = normalizeToken(currentArtifact.identity?.id || currentArtifact.participantIdentity?.id);
+  if (suppliedIdentityId) {
+    const matches = participants.filter((participant) => participant.identity.id === suppliedIdentityId);
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) return null;
+  }
+
+  const aggregateIdentity = artifactRegistryIdentityForRecord(
+    currentArtifact,
+    currentArtifactWorkspaceIds(currentArtifact),
+    declaredRecordSchemaId,
+    metadataRecordSchemaId,
+    PARTICIPANT_IDENTITY_PREFIX
+  );
+  if (aggregateIdentity?.key) {
+    const matches = participants.filter((participant) => participant.identity.key === aggregateIdentity.key);
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) return null;
+  }
+
+  const recordId = normalizeToken(currentArtifact.id);
+  if (!recordId) return null;
+  const recordIdMatches = participants.filter((participant) => participant.artifact.loadedRecordIds.includes(recordId));
+  return recordIdMatches.length === 1 ? recordIdMatches[0] : null;
+}
+
+
+function participantIdentityProjection(identity = {}) {
+  const key = normalizeToken(identity.key);
+  const kind = normalizeToken(identity.kind);
+  const global = identity.global === true;
+  const id = global
+    ? normalizeToken(identity.id) || participantIdentityId(kind || 'global', key)
+    : participantIdentityId(kind || 'workspace-record', key);
+  return Object.freeze({ id, key, kind, global });
+}
+
+function participantIdentityId(kind = '', key = '') {
+  return `${PARTICIPANT_IDENTITY_PREFIX}:${encodeURIComponent(normalizeToken(kind))}:${encodeURIComponent(normalizeToken(key))}`;
+}
+
+function currentArtifactWorkspaceIds(record = {}) {
+  const memberships = new Set();
+  const add = (value) => {
+    const id = normalizeToken(value);
+    if (id) memberships.add(id);
+  };
+  add(record.workspaceId);
+  for (const value of Array.isArray(record.workspaceIds) ? record.workspaceIds : []) add(value);
+  return [...memberships].sort();
+}
+
+function hasAnyDeclaredArtifactSchema(record = {}) {
+  return readArtifactSchemaQualification(record).declaredSchemaIds.length > 0;
+}
+
+function sourceProjection(record = {}) {
+  const identity = record.registryIdentity || {};
+  const boundary = identity.sourceBoundary || artifactSourceBoundaryIdentity(record) || {};
+  return Object.freeze({
+    sourceIds: Object.freeze([...(record.loadedSourceIds || [record.source?.id]).map(normalizeToken).filter(Boolean)].sort()),
+    adapterId: String(record.source?.adapterId || ''),
+    sourceMode: String(record.sourceMode || ''),
+    repository: String(boundary.repository || record.source?.repository || record.source?.repo || ''),
+    ref: String(boundary.ref || record.source?.ref || ''),
+    rootPath: String(boundary.rootPath || record.source?.rootPath || ''),
+    boundaryKey: String(boundary.key || identity.boundaryKey || ''),
+    boundarySignature: String(boundary.signature || identity.boundarySignature || ''),
+    sourceArtifactPath: String(identity.sourceArtifactPath || record.sourceTarget?.sourceArtifactPath || record.path || ''),
+    inputTarget: String(identity.inputTarget || record.sourceTarget?.inputTarget || '')
+  });
+}
+
+function declaredRecordSchemaId(record = {}) {
+  const markdown = String(record.markdown || '');
+  if (!markdown.trim()) return '';
+  try { return normalizeToken(parseArtifactMarkdown(markdown).envelope?.current?.schema?.id); }
+  catch { return ''; }
+}
+
+function metadataRecordSchemaId(record = {}) {
+  return normalizeToken(record.schemaId || record.currentSchemaId || '');
+}
+
+function normalizeSchemaConstraint(value = '') {
+  return normalizeToken(value).replace(/^\[([^\]]+)\]\([^)]+\)$/, '$1');
+}
+function normalizeToken(value = '') { return String(value || '').trim(); }
+function compareParticipants(left, right) {
+  return String(left.identity.id).localeCompare(String(right.identity.id))
+    || String(left.artifact.path).localeCompare(String(right.artifact.path))
+    || String(left.artifact.id).localeCompare(String(right.artifact.id));
+}

package/src/artifacts/fixtures/evidence.trace.md

@@ -0,0 +1,50 @@
+# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](../../.topics/.schemas/tiinex.root.v1.schema.md)
+- Parent
+  - Parent Schema: [tiinex.preservation.v1](../../.topics/.schemas/core/preservation/tiinex.preservation.v1.schema.md)
+  - Created At: 2026-07-19 00:00:00
+  - Trace: [demo-preservation.trace.md](demo-preservation.trace.md)
+- Current
+  - Current Schema: [tiinex.evidence.v1](../../.topics/.schemas/core/evidence/tiinex.evidence.v1.schema.md)
+  - Created At: 2026-07-19 00:00:00
+  - Summary: Demo evidence artifact for parser/root fallback validation.
+
+---
+
+# Local Startup Evidence
+
+## Supported Claim Or Question
+
+- Supported Claim Or Question: whether the fresh shell can start through local index.html
+- Evidence Role: supports that the file-local startup path is visible
+
+## Provenance
+
+- Known Source: Q manual screenshot feedback
+- Preservation Basis: summarized observation in this demo artifact
+- Provenance Limits: exact browser console details are outside this sample
+
+## Evidence Material
+
+- Material Kind: screenshot observation
+- Material: v82 shell rendered locally without loading app.js
+
+## Preservation And Fidelity
+
+- Preservation State: readable summary preserved in markdown
+- Fidelity Notes: summarized by reviewer from screenshot
+- Known Losses: exact pixel state and full devtools console not embedded
+
+## Interpretation Limits
+
+- Does Not Prove: full UX correctness or schema validation completeness
+- Must Not Be Treated As: deployment proof, source authority, or user acceptance
+
+---
+
+# Continuity Integrity
+
+- sha256-base64url-c14n-v2
+  - Towards: self
+  - Value: demo-evidence-v84-not-authoritative