@tiinex/app 0.1.1

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

@@ -0,0 +1,33 @@
+# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](../../.topics/.schemas/tiinex.root.v1.schema.md)
+- Current
+  - Current Schema: [tiinex.topic.v1](../../.topics/.schemas/core/topic/tiinex.topic.v1.schema.md)
+  - Created At: 2026-07-19 00:00:00
+  - Summary: Demo topic artifact for parser/root fallback validation.
+
+---
+
+# Parser Grounding Topic
+
+This topic captures the current direction for artifact parsing and root fallback in the fresh Tiinex Site shell.
+
+## Current Read
+
+The app should parse continuity envelope fields before child schema-specific presentation is trusted.
+
+## Design Direction
+
+Keep root fallback visible when a child schema module is unavailable.
+
+## Next Artifacts
+
+- Add feed/detail cards from parsed artifact view models.
+
+---
+
+# Continuity Integrity
+
+- sha256-base64url-c14n-v2
+  - Towards: self
+  - Value: demo-topic-v84-not-authoritative

package/src/artifacts/fixtures/unknown-schema.trace.md

@@ -0,0 +1,25 @@
+# Continuity Context
+
+- Envelope Schema: [tiinex.root.v1](../../.topics/.schemas/tiinex.root.v1.schema.md)
+- Current
+  - Current Schema: [tiinex.experimental.unknown.v1](../../.topics/.schemas/experimental/unknown.schema.md)
+  - Created At: 2026-07-19 00:00:00
+  - Summary: Demo unknown child schema artifact for root fallback.
+
+---
+
+# Unknown Schema Demo
+
+This artifact intentionally names a schema module the app does not know yet.
+
+## Local Material
+
+The shell should not pretend child-specific validation passed. It should use root fallback and disclose that child validation was skipped.
+
+---
+
+# Continuity Integrity
+
+- sha256-base64url-c14n-v2
+  - Towards: self
+  - Value: demo-unknown-v84-not-authoritative

package/src/audit/audit.findings.js

@@ -0,0 +1 @@
+export function finding(severity, code, message, source = 'tiinex.web.audit.v84') { return { severity, code, message, source }; }

package/src/audit/audit.model.js

@@ -0,0 +1,2 @@
+export const auditModelVersion = 'tiinex.web.audit.model.v84';
+export const auditStatuses = Object.freeze(['readable', 'degraded', 'invalid-or-incomplete']);

package/src/audit/audit.plan.js

@@ -0,0 +1,13 @@
+export function planAudit(scope = {}) {
+  return {
+    type: 'tiinex.web.audit.plan.v84',
+    scope: scope.name || 'single-artifact',
+    steps: [
+      'parse continuity envelope',
+      'resolve schema module',
+      'run available validation immediately',
+      'disclose root fallback when child module is unavailable',
+      'summarize findings visibly'
+    ]
+  };
+}

package/src/audit/audit.report.js

@@ -0,0 +1,12 @@
+export function auditReport(result) {
+  return {
+    type: 'tiinex.web.audit.report.v84',
+    status: result.status,
+    schemaId: result.artifact.schemaId,
+    moduleId: result.artifact.moduleId,
+    fallbackUsed: result.artifact.fallbackUsed,
+    validation: result.validation || null,
+    summary: result.summary,
+    findings: result.findings
+  };
+}

package/src/audit/audit.severity.js

@@ -0,0 +1 @@
+export const severities = Object.freeze(['error', 'warning', 'info', 'preserve']);

package/src/audit/audit.traverse.js

@@ -0,0 +1,119 @@
+import { traverseLoadedLineage } from '@tiinex/core/lineage/lineage.traverse.js';
+import { runAudit } from '@tiinex/core/audit/audit.run.js';
+import { auditReport } from './audit.report.js';
+
+export const AUDIT_TRAVERSAL_SCOPE_SCHEMA_ID = 'tiinex.audit.traversal.scope.v1';
+
+export function buildLoadedAuditTraversalScope(records = [], options = {}) {
+  const traversal = options.traversal || traverseLoadedLineage(records, {
+    startIds: options.startIds || options.startId || options.selectedId,
+    direction: options.direction || 'ancestors',
+    maxDepth: options.maxDepth ?? options.depth ?? 3,
+    resolvedLineage: options.resolvedLineage
+  });
+  const recordById = new Map((Array.isArray(records) ? records : []).map((record) => [record.id || record.path || record.title || '', record]));
+  const audited = [];
+  const findings = [...(traversal.findings || [])];
+
+  for (const node of traversal.nodes || []) {
+    const record = recordById.get(node.id);
+    if (!record) {
+      findings.push(finding('warning', 'audit.traversal.record.missing', 'Traversal node has no loaded record; audit cannot run for it.', { nodeId: node.id }));
+      continue;
+    }
+    const result = safeRunAudit(record);
+    audited.push(Object.freeze({
+      id: node.id,
+      title: record.title || node.title || 'Untitled artifact',
+      path: record.path || node.path || '',
+      depth: node.depth,
+      role: node.role,
+      status: result.report.status,
+      schemaId: result.report.schemaId || record.schemaId || record.currentSchemaId || '',
+      fallbackUsed: Boolean(result.report.fallbackUsed),
+      summary: result.report.summary || {},
+      findings: Object.freeze(result.report.findings || [])
+    }));
+  }
+
+  for (const edge of traversal.missingEdges || []) {
+    findings.push(finding('warning', 'audit.traversal.unavailableTarget', 'Declared lineage target is unavailable in loaded material and was not audited.', { nodeId: edge.to, target: edge.target }));
+  }
+
+  const counts = summarizeAudited(audited, findings, traversal);
+  return Object.freeze({
+    schema: AUDIT_TRAVERSAL_SCOPE_SCHEMA_ID,
+    boundary: 'loaded-only audit traversal; no remote fetch; validates only loaded nodes in traversal scope',
+    traversal,
+    audited: Object.freeze(audited),
+    findings: Object.freeze(dedupeFindings(findings)),
+    counts,
+    status: counts.errors ? 'invalid-or-incomplete' : counts.warnings || counts.unavailableTargets ? 'degraded' : 'readable'
+  });
+}
+
+function safeRunAudit(record = {}) {
+  try {
+    const result = runAudit({ markdown: record.markdown || '', record });
+    return { result, report: auditReport(result) };
+  } catch (error) {
+    const report = {
+      status: 'invalid-or-incomplete',
+      schemaId: record.schemaId || record.currentSchemaId || '',
+      moduleId: 'tiinex.root.v1',
+      fallbackUsed: true,
+      summary: { error: 1, warning: 0, info: 0, preserve: 0 },
+      findings: [finding('error', 'audit.traversal.exception', error?.message || 'Audit traversal failed.', { nodeId: record.id || '' })]
+    };
+    return { result: null, report };
+  }
+}
+
+function summarizeAudited(audited = [], findings = [], traversal = {}) {
+  const counts = {
+    visitedNodes: traversal.stats?.visitedNodes || 0,
+    auditedNodes: audited.length,
+    missingEdges: traversal.stats?.missingEdges || 0,
+    unavailableTargets: (traversal.missingEdges || []).length,
+    readable: 0,
+    degraded: 0,
+    invalid: 0,
+    pending: 0,
+    unavailable: 0,
+    supporting: 0,
+    fallbackUsed: 0,
+    errors: 0,
+    warnings: 0,
+    infos: 0,
+    traversalFindings: findings.length
+  };
+  for (const item of audited) {
+    if (item.status === 'readable') counts.readable += 1;
+    else if (item.status === 'degraded') counts.degraded += 1;
+    else if (item.status === 'pending-unavailable') {
+      counts.pending += 1;
+      counts.unavailable += 1;
+    } else if (item.status === 'supporting-material') counts.supporting += 1;
+    else counts.invalid += 1;
+    if (item.fallbackUsed) counts.fallbackUsed += 1;
+    counts.errors += Number(item.summary?.error || 0);
+    counts.warnings += Number(item.summary?.warning || 0);
+    counts.infos += Number(item.summary?.info || 0);
+  }
+  counts.warnings += findings.filter((item) => item.severity === 'warning').length;
+  counts.errors += findings.filter((item) => item.severity === 'error').length;
+  counts.infos += findings.filter((item) => item.severity === 'info').length;
+  return Object.freeze(counts);
+}
+
+function dedupeFindings(findings = []) {
+  const seen = new Set();
+  return findings.filter((entry) => {
+    const key = `${entry.source || ''}:${entry.code || ''}:${entry.nodeId || ''}:${entry.target || ''}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function finding(severity, code, message, extra = {}) { return Object.freeze(Object.assign({ severity, code, message, source: AUDIT_TRAVERSAL_SCOPE_SCHEMA_ID }, extra)); }

package/src/audit/integrity/auditIntegrity.checks.js

@@ -0,0 +1 @@
+export function checkIntegrity() { return []; }

package/src/audit/integrity/auditIntegrity.compare.js

@@ -0,0 +1 @@
+export function compareIntegrity(a, b) { return Object.is(a, b); }

package/src/audit/lineage/auditLineage.load.js

@@ -0,0 +1 @@
+export async function loadAuditLineage() { return { loaded: [], unavailable: [] }; }

package/src/audit/lineage/auditLineage.plan.js

@@ -0,0 +1 @@
+export function planLineageLoad() { return ['parents','schema-lineage','source-boundaries']; }

package/src/audit/lineage/auditLineage.resolve.js

@@ -0,0 +1,12 @@
+import { resolveLineage } from '@tiinex/core/lineage/lineage.resolve.js';
+
+export function resolveAuditLineage(nodes = []) {
+  const result = resolveLineage(nodes, { depth: 'loaded-audit' });
+  return {
+    schema: 'tiinex.audit.lineage.resolve.v1',
+    nodes: result.nodes,
+    edges: result.edges,
+    findings: result.findings,
+    stats: result.stats
+  };
+}

package/src/audit/sources/auditSources.boundaries.js

@@ -0,0 +1 @@
+export function auditSourceBoundaries() { return []; }

package/src/audit/sources/auditSources.checks.js

@@ -0,0 +1 @@
+export function checkAuditSources() { return []; }

package/src/audit/validation/auditValidation.recheck.js

@@ -0,0 +1 @@
+export function shouldRecheckAfterLineageLoad(before, after) { return before !== after; }

package/src/audit/validation/auditValidation.run.js

@@ -0,0 +1 @@
+export function runAuditValidation(modules = [], artifacts = []) { return []; }

package/src/build.identity.js

@@ -0,0 +1,15 @@
+export const TIINEX_SITE_CHECKPOINT = 'v470';
+export const TIINEX_SITE_VERSION = '0.2.289-v470';
+export const TIINEX_SITE_TITLE = 'Tiinex Site v470';
+export const TIINEX_RUNTIME_ID = 'react-v470-schema-reading-contract-materialization-identity-source-coalescing-authority-correction';
+export const TIINEX_PUBLIC_BUILD_SOURCE = 'v470-schema-reading-contract-materialization-identity-source-coalescing-authority-correction';
+
+export function tiinexBuildIdentity() {
+  return Object.freeze({
+    checkpoint: TIINEX_SITE_CHECKPOINT,
+    siteVersion: TIINEX_SITE_VERSION,
+    siteTitle: TIINEX_SITE_TITLE,
+    runtimeId: TIINEX_RUNTIME_ID,
+    publicBuildSource: TIINEX_PUBLIC_BUILD_SOURCE
+  });
+}

package/src/commands/command.vocabulary.js

@@ -0,0 +1,14 @@
+// Command vocabulary is UI-neutral on purpose.
+// The browser UI, future CLI, and remote-control surfaces should bind to these command ids
+// instead of inventing separate semantics per renderer.
+
+export const commandVocabulary = [
+  { id: 'open', scope: 'workspace', cli: 'tiinex workspace open <id>', status: 'implemented-scaffold' },
+  { id: 'merge', scope: 'lineage', cli: 'tiinex lineage merge <id>', status: 'scaffold' },
+  { id: 'source', scope: 'source', cli: 'tiinex source show <id>', status: 'scaffold' },
+  { id: 'audit', scope: 'audit', cli: 'tiinex audit loaded', status: 'loaded-only' },
+  { id: 'markdown', scope: 'artifact', cli: 'tiinex artifact markdown <id>', status: 'scaffold' },
+  { id: 'preview', scope: 'artifact', cli: 'tiinex artifact preview <id>', status: 'scaffold' },
+  { id: 'edit', scope: 'draft', cli: 'tiinex draft edit <id>', status: 'scaffold' },
+  { id: 'share', scope: 'transport', cli: 'tiinex artifact share <id>', status: 'scaffold' }
+];

package/src/conformance/conformance.fixtures.js

@@ -0,0 +1,151 @@
+export const CONFORMANCE_FIXTURE_SCHEMA_ID = 'tiinex.conformance.fixtureSet.v1';
+
+export const conformanceFixtures = Object.freeze({
+  schema: CONFORMANCE_FIXTURE_SCHEMA_ID,
+  id: 'core-loaded-workspace-v1',
+  description: 'Small normative fixture set for loaded-only Tiinex artifact/source/lineage/audit/transition conformance.',
+  records: Object.freeze([
+    fixtureRecord({
+      id: 'topic-parent',
+      path: 'topics/parent.md',
+      title: 'Parent Topic',
+      markdown: artifactMarkdown({
+        title: 'Parent Topic',
+        currentSchema: 'tiinex.topic.v1',
+        createdAt: '2026-07-21T00:00:00.000Z',
+        summary: 'Loaded parent topic used by conformance fixtures.',
+        body: '## Notes\n\nThe loaded parent is intentionally a local/session artifact.'
+      })
+    }),
+    fixtureRecord({
+      id: 'topic-child-trace',
+      path: 'topics/child-trace.md',
+      title: 'Child Topic via Trace',
+      markdown: artifactMarkdown({
+        title: 'Child Topic via Trace',
+        currentSchema: 'tiinex.topic.v1',
+        createdAt: '2026-07-21T00:10:00.000Z',
+        summary: 'Child topic with an explicit Parent Trace and Origin.',
+        parentSchema: 'tiinex.topic.v1',
+        parentCreatedAt: '2026-07-21T00:00:00.000Z',
+        trace: 'record:topic-parent',
+        origin: 'topics/parent.md',
+        boundary: 'browser-local session material; no GitHub provenance inferred',
+        body: '## Continuation\n\nThis fixture must resolve its parent through Trace.'
+      })
+    }),
+    fixtureRecord({
+      id: 'evidence-origin-only',
+      path: 'evidence/origin-only.md',
+      title: 'Evidence via Origin',
+      markdown: artifactMarkdown({
+        title: 'Evidence via Origin',
+        currentSchema: 'tiinex.evidence.v1',
+        createdAt: '2026-07-21T00:20:00.000Z',
+        summary: 'Evidence fixture with Origin but no Trace.',
+        parentSchema: 'tiinex.topic.v1',
+        parentCreatedAt: '2026-07-21T00:00:00.000Z',
+        origin: 'https://github.com/Tiinex/docs/blob/abc123/topics/parent.md',
+        boundary: 'browser-local session material; no GitHub provenance inferred',
+        body: '## Evidence\n\nOrigin may provide recovery context, but does not replace Trace authority.'
+      })
+    }),
+    fixtureRecord({
+      id: 'missing-parent',
+      path: 'topics/missing-parent.md',
+      title: 'Missing Parent Topic',
+      markdown: artifactMarkdown({
+        title: 'Missing Parent Topic',
+        currentSchema: 'tiinex.topic.v1',
+        createdAt: '2026-07-21T00:30:00.000Z',
+        summary: 'Child fixture whose declared parent is not loaded.',
+        parentSchema: 'tiinex.topic.v1',
+        parentCreatedAt: '2026-07-20T00:00:00.000Z',
+        trace: 'record:not-loaded',
+        origin: 'topics/not-loaded.md',
+        boundary: 'browser-local session material; no GitHub provenance inferred',
+        body: '## Gap\n\nThis fixture must report a missing parent instead of guessing.'
+      })
+    }),
+    fixtureRecord({
+      id: 'unknown-schema',
+      path: 'unknown/custom.md',
+      title: 'Unknown Schema Artifact',
+      markdown: artifactMarkdown({
+        title: 'Unknown Schema Artifact',
+        currentSchema: 'tiinex.experimental.custom.v1',
+        envelopeSchemaTarget: 'https://github.com/Tiinex/docs/blob/053d46ce082d4ec261b82abc44ecca403d61e240/.topics/.schemas/tiinex.root.v1.schema.md',
+        createdAt: '2026-07-21T00:40:00.000Z',
+        summary: 'Unknown child schema that must remain Root-readable.',
+        body: '## Custom payload\n\nUnknown schema-specific fields are preserved, not interpreted.'
+      })
+    }),
+    fixtureRecord({
+      id: 'invalid-markdown',
+      path: 'invalid/no-envelope.md',
+      title: 'Invalid Missing Envelope',
+      markdown: '# Continuity Context\n\n---\n\n# Invalid Missing Envelope\n\nThis record intentionally lacks required Root envelope fields and Integrity.'
+    })
+  ]),
+  assets: Object.freeze([
+    Object.freeze({
+      id: 'asset:core-loaded-workspace-v1:evidence/image.png',
+      path: 'evidence/image.png',
+      name: 'image.png',
+      type: 'image/png',
+      size: 128,
+      previewState: 'metadata-only',
+      sourceMode: 'local-asset',
+      source: Object.freeze({ adapterId: 'local', kind: 'local-session', boundary: 'Browser-local asset; no GitHub provenance inferred.' })
+    })
+  ]),
+  workspaceCandidates: Object.freeze([
+    Object.freeze({
+      id: 'workspace-candidate:fixtures/core.workspace.md',
+      path: 'fixtures/core.workspace.md',
+      title: 'Conformance Fixture Workspace',
+      markdown: '# Conformance Fixture Workspace\n',
+      sourceMode: 'local-workspace-candidate',
+      source: Object.freeze({ adapterId: 'local', kind: 'local-session', boundary: 'Browser-local workspace candidate; no GitHub provenance inferred.' })
+    })
+  ])
+});
+
+function fixtureRecord(input) {
+  return Object.freeze(Object.assign({ sourceMode: 'local-fixture' }, input));
+}
+
+function artifactMarkdown(input = {}) {
+  const parentLines = input.parentSchema || input.trace || input.origin ? [
+    '- Parent',
+    input.parentSchema ? `  - Parent Schema: [${input.parentSchema}](${input.parentSchema}.schema.md)` : '',
+    input.parentCreatedAt ? `  - Created At: ${input.parentCreatedAt}` : '',
+    input.trace ? `  - Trace: ${input.trace}` : '',
+    input.origin ? `  - Origin: ${input.origin}` : '',
+    input.boundary ? `  - Boundary: ${input.boundary}` : ''
+  ].filter(Boolean) : [];
+  return [
+    '# Continuity Context',
+    '',
+    `- Envelope Schema: [tiinex.root.v1](${input.envelopeSchemaTarget || 'tiinex.root.v1.schema.md'})`,
+    ...parentLines,
+    '- Current',
+    `  - Current Schema: [${input.currentSchema || 'tiinex.topic.v1'}](${input.currentSchema || 'tiinex.topic.v1'}.schema.md)`,
+    `  - Created At: ${input.createdAt || '2026-07-21T00:00:00.000Z'}`,
+    `  - Summary: ${input.summary || ''}`,
+    '  - Status: fixture/local',
+    '  - Why: Conformance fixture for loaded-only Tiinex runtime behavior.',
+    '',
+    '---',
+    '',
+    `# ${input.title || 'Fixture Artifact'}`,
+    '',
+    input.body || '## Body\n\nFixture body.',
+    '',
+    '# Continuity Integrity',
+    '',
+    '- Fixture Integrity',
+    '  - Method: fixture-static',
+    '  - Value: fixture'
+  ].join('\n');
+}