@tiinex/core 0.1.1

package/src/schemas/core/task/tiinex.task.v1.schema.source.js

@@ -0,0 +1,9 @@
+import binding from './tiinex.task.v1.schema.json' with { type: 'json' };
+import projection from './tiinex.task.v1.schema.runtime.json' with { type: 'json' };
+import { defineBundledSchemaSource } from '../../schema.source.js';
+
+export const schemaSource = defineBundledSchemaSource(binding, projection, Object.freeze({
+  bundledPath: 'src/schemas/core/task/tiinex.task.v1.schema.md',
+  sourceLabel: 'Viewer schema registry',
+  assetUrl: new URL('./tiinex.task.v1.schema.md', import.meta.url).href
+}));

package/src/schemas/core/task/tiinex.task.v1.sv.i18n.json

@@ -0,0 +1,15 @@
+{
+  "label": "Task",
+  "summary": "Canonical Task artifact with bounded work and completion criteria.",
+  "task.schema.mismatch": "Task validator was invoked for a non-task current schema.",
+  "task.title.missing": "Task artifact should begin with a human-readable title.",
+  "task.objective.missing": "Task body is missing the required Objective section.",
+  "task.doneCriteria.missing": "Task body is missing the required Done Criteria section.",
+  "task.scope.missing": "Task body is missing the required Scope section.",
+  "task.dependencies.missing": "Task body is missing the required Dependencies section.",
+  "task.legacyShape.observed": "Task body uses legacy browser-draft sections and is not the exact current canonical Task shape.",
+  "task.body.thin": "Task body is thin; the bounded work request may be unclear.",
+  "task.body.canonical": "Task body exposes the current canonical Objective, Done Criteria, Scope, and Dependencies sections.",
+  "task.legacyShape.incomplete": "Legacy browser-draft compatibility is incomplete; required historical sections are missing.",
+  "task.legacyShape.readable": "Historical browser-local Task draft remains readable and editable through the explicit compatibility boundary."
+}

package/src/schemas/core/task/tiinex.task.v1.transitions.js

@@ -0,0 +1,3 @@
+export const taskTransitions = Object.freeze([
+  { id: 'inspect', label: 'Inspect', sideEffect: 'none' }
+]);

package/src/schemas/core/task/tiinex.task.v1.validate.js

@@ -0,0 +1,41 @@
+import { TASK_CANONICAL_BODY_SECTIONS, TASK_LEGACY_BODY_SECTIONS } from './tiinex.task.v1.contract.js';
+
+const SECTION_FINDINGS = Object.freeze({
+  Objective: ['task.objective.missing', 'Task body is missing the required Objective section.'],
+  'Done Criteria': ['task.doneCriteria.missing', 'Task body is missing the required Done Criteria section.'],
+  Scope: ['task.scope.missing', 'Task body is missing the required Scope section.'],
+  Dependencies: ['task.dependencies.missing', 'Task body is missing the required Dependencies section.']
+});
+
+export function taskValidate(artifact) {
+  const findings = [];
+  if (artifact.envelope.current.schema.id !== 'tiinex.task.v1') {
+    findings.push({ severity: 'warning', code: 'task.schema.mismatch', messageKey: 'task.schema.mismatch', message: 'Task validator invoked for non-task current schema.', source: 'tiinex.task.v1' });
+    return findings;
+  }
+  const body = String(artifact.body?.text || '');
+  const sections = new Set(Array.isArray(artifact.body?.sections) ? artifact.body.sections : []);
+  if (!artifact.body.title) findings.push({ severity: 'error', code: 'task.title.missing', messageKey: 'task.title.missing', message: 'Task artifact should begin with a human-readable title.', source: 'tiinex.task.v1', fixability: 'safe' });
+  for (const section of TASK_CANONICAL_BODY_SECTIONS) {
+    if (sections.has(section)) continue;
+    const [code, message] = SECTION_FINDINGS[section];
+    findings.push({ severity: 'error', code, messageKey: code, message, source: 'tiinex.task.v1', fixability: 'manual' });
+  }
+  if (TASK_LEGACY_BODY_SECTIONS.some((section) => sections.has(section))) findings.push({ severity: 'warning', code: 'task.legacyShape.observed', messageKey: 'task.legacyShape.observed', message: 'Task body uses legacy browser-draft sections and is not the exact current canonical Task shape.', source: 'tiinex.task.v1', fixability: 'manual' });
+  if (!body || body.length < 40) findings.push({ severity: 'warning', code: 'task.body.thin', messageKey: 'task.body.thin', message: 'Task body is thin; the bounded work request may be unclear.', source: 'tiinex.task.v1', fixability: 'manual' });
+  if (!findings.some((finding) => finding.severity === 'error')) findings.push({ severity: 'info', code: 'task.body.canonical', messageKey: 'task.body.canonical', message: 'Task body exposes the current canonical Objective, Done Criteria, Scope, and Dependencies sections.', source: 'tiinex.task.v1' });
+  return findings;
+}
+
+
+export function validateLegacyTaskDraftCompatibility(artifact) {
+  const findings = [];
+  if (artifact?.envelope?.current?.schema?.id !== 'tiinex.task.v1') return [{ severity: 'error', code: 'task.schema.mismatch', messageKey: 'task.schema.mismatch', message: 'Legacy Task compatibility invoked for non-task current schema.', source: 'tiinex.task.v1' }];
+  const sections = new Set(Array.isArray(artifact.body?.sections) ? artifact.body.sections : []);
+  if (!artifact.body?.title) findings.push({ severity: 'error', code: 'task.title.missing', messageKey: 'task.title.missing', message: 'Task artifact should begin with a human-readable title.', source: 'tiinex.task.v1', fixability: 'safe' });
+  const missing = TASK_LEGACY_BODY_SECTIONS.filter((section) => !sections.has(section));
+  if (missing.length) findings.push({ severity: 'error', code: 'task.legacyShape.incomplete', messageKey: 'task.legacyShape.incomplete', message: `Legacy browser-draft compatibility requires: ${missing.join(', ')}.`, source: 'tiinex.task.v1', fixability: 'manual', params: { missing: missing.join(', ') } });
+  findings.push({ severity: 'warning', code: 'task.legacyShape.observed', messageKey: 'task.legacyShape.observed', message: 'Task body uses the historical browser-draft shape; it is readable compatibility material, not the exact current canonical Task shape.', source: 'tiinex.task.v1', fixability: 'manual' });
+  if (!findings.some((finding) => finding.severity === 'error')) findings.push({ severity: 'info', code: 'task.legacyShape.readable', messageKey: 'task.legacyShape.readable', message: 'Historical browser-local Task draft remains readable and editable through the explicit compatibility boundary.', source: 'tiinex.task.v1' });
+  return findings;
+}

package/src/schemas/core/topic/tiinex.topic.v1.capabilities.js

@@ -0,0 +1,14 @@
+export const topicCapabilities = Object.freeze({
+  "canCreateArtifact": true,
+  "canBeParent": true,
+  "canRenderFallback": false,
+  "supportedSurfaces": [
+    "feed",
+    "tree",
+    "detail",
+    "lineage",
+    "preview",
+    "share",
+    "graph"
+  ]
+});

package/src/schemas/core/topic/tiinex.topic.v1.creation.js

@@ -0,0 +1,46 @@
+import { genericArtifactCreationImplementation } from '../../creation.renderer.js';
+import { sealC14nV2Self } from '../../../integrity/integrity.c14nV2.js';
+
+const ORIENTING_SHAPE_TEXT = 'summary sentence placeholder below the title';
+
+export const topicArtifactCreationImplementation = Object.freeze({
+  ...genericArtifactCreationImplementation,
+  renderer: Object.freeze({ id: 'tiinex.site.topic-artifact-creation-renderer.v1', scope: 'schema-owned-topic-create-representation' }),
+  execute(contract, input) {
+    const base = genericArtifactCreationImplementation.execute(contract, input);
+    if (String(contract?.transitionType || 'create-artifact') !== 'create-artifact') return base;
+    const markdown = typeof base === 'string' ? base : String(base?.markdown || '');
+    const summaryBinding = (contract?.creation?.inputBindings || []).find((item) => item?.kind === 'root-current-summary-body-title');
+    const values = { ...((input?.inputs && typeof input.inputs === 'object') ? input.inputs : {}), ...((input?.values && typeof input.values === 'object') ? input.values : {}) };
+    const summary = summaryBinding && Object.prototype.hasOwnProperty.call(values, summaryBinding.input) ? String(values[summaryBinding.input]) : '';
+    if (!markdown || !summary) return '';
+    const lines = markdown.replace(/\r\n?/g, '\n').split('\n');
+    const boundary = lines.findIndex((line) => line === '---');
+    let titleIndex = -1;
+    for (let i = Math.max(0, boundary + 1); i < lines.length; i += 1) { if (/^#\s+/.test(lines[i]) && lines[i] !== '# Continuity Integrity') { titleIndex = i; break; } }
+    if (titleIndex < 0) return '';
+    lines.splice(titleIndex + 1, 0, '', `This topic captures the current direction for ${summary}.`);
+    const sealed = sealC14nV2Self(lines.join('\n'));
+    return sealed.state === 'sealed' ? sealed.markdown : '';
+  },
+  qualifyRequiredShape({ markdown = '', residualItems = [], input = {} } = {}) {
+    const unknown = residualItems.filter((item) => String(item?.sourceText || '') !== ORIENTING_SHAPE_TEXT);
+    if (unknown.length) return Object.freeze({ state: 'unavailable', coveredItemIds: Object.freeze([]), findings: Object.freeze(unknown.map((item) => `Topic creation owner does not qualify residual Required Shape item ${item?.id || 'unknown'}.`)) });
+    const values = { ...((input?.inputs && typeof input.inputs === 'object') ? input.inputs : {}), ...((input?.values && typeof input.values === 'object') ? input.values : {}) };
+    const summary = Object.prototype.hasOwnProperty.call(values, 'Summary') ? String(values.Summary) : '';
+    const expected = `This topic captures the current direction for ${summary}.`;
+    const observed = bodyLeadLines(markdown);
+    const ok = residualItems.length === 1 && observed.length === 1 && observed[0] === expected;
+    return Object.freeze({ state: ok ? 'qualified' : 'unavailable', coveredItemIds: Object.freeze(ok ? residualItems.map((item) => item.id) : []), findings: Object.freeze(ok ? [] : [`Topic orienting sentence does not satisfy exact schema-owned Required Shape representation.`]) });
+  }
+});
+
+function bodyLeadLines(markdown = '') {
+  const lines = String(markdown || '').replace(/\r\n?/g, '\n').split('\n');
+  const boundary = lines.findIndex((line) => line === '---');
+  let title = -1; for (let i = boundary + 1; i < lines.length; i += 1) { if (/^#\s+/.test(lines[i]) && lines[i] !== '# Continuity Integrity') { title = i; break; } }
+  if (title < 0) return [];
+  const out = [];
+  for (let i = title + 1; i < lines.length; i += 1) { if (/^##\s+/.test(lines[i]) || lines[i] === '# Continuity Integrity') break; if (lines[i] !== '') out.push(lines[i]); }
+  return out;
+}

package/src/schemas/core/topic/tiinex.topic.v1.en.i18n.json

@@ -0,0 +1,8 @@
+{
+  "label": "Topic",
+  "summary": "Bounded topic-oriented lineage artifacts for live design and implementation threads.",
+  "topic.schema.mismatch": "Topic validator was invoked for a non-topic current schema.",
+  "topic.title.missing": "Topic artifact should begin with a human-readable title.",
+  "topic.body.thin": "Topic body is thin; reader may not understand the active topic thread.",
+  "topic.body.readable": "Topic body is readable at scaffold validation depth."
+}

package/src/schemas/core/topic/tiinex.topic.v1.findings.js

@@ -0,0 +1,11 @@
+export const topicFindings = Object.freeze({
+  namespace: 'tiinex.topic.v1',
+  defaultSeverity: 'info',
+  codes: Object.freeze({
+    'topic.schema.mismatch': finding('topic.schema.mismatch', 'warning', 'none'),
+    'topic.title.missing': finding('topic.title.missing', 'error', 'safe'),
+    'topic.body.thin': finding('topic.body.thin', 'warning', 'manual'),
+    'topic.body.readable': finding('topic.body.readable', 'info', 'none')
+  })
+});
+function finding(messageKey, severity, fixability) { return Object.freeze({ severity, messageKey, fixability }); }

package/src/schemas/core/topic/tiinex.topic.v1.localMaterialization.js

@@ -0,0 +1,135 @@
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+import { createRecordFromMarkdown } from '../../../artifacts/artifact.record.js';
+import { compilePortableSchemaContractChain } from '../../../tooling/portable/schema/contract.compile.js';
+import { topicValidate } from './tiinex.topic.v1.validate.js';
+import { canonicalC14nV2SelfState, sealC14nV2Self } from '../../../integrity/integrity.c14nV2.js';
+import { inspectCreationRepresentation } from '../../creation.representation.js';
+
+
+function exactRepresentationMultiplicity(representation = {}, mode = 'root') {
+  if (representation.continuityContextHeadings !== 1 || representation.currentBlocks !== 1 || representation.currentSchema?.length !== 1 || representation.createdAt?.length !== 1 || representation.summary?.length !== 1 || representation.bodyH1?.length !== 1 || representation.integrityHeadings !== 1 || representation.selfIntegrityEntries?.length !== 1) return false;
+  if (representation.parentBlocks !== (mode === 'parent' ? 1 : 0)) return false;
+  return REQUIRED_INPUTS.slice(1).every((name) => (representation.sectionBodies?.[name] || []).length === 1);
+}
+
+export const CANONICAL_TOPIC_LOCAL_MATERIALIZER_SCHEMA_ID = 'tiinex.site.canonical-topic-local-materializer.v1';
+export const CANONICAL_TOPIC_SCHEMA_ID = 'tiinex.topic.v1';
+export const TOPIC_CANONICAL_REQUIRED_INPUTS = Object.freeze(['Summary', 'Current Read', 'Design Direction', 'Next Artifacts']);
+const REQUIRED_INPUTS = TOPIC_CANONICAL_REQUIRED_INPUTS;
+
+export function renderCanonicalTopicLocalArtifact(input = {}) {
+  const values = input.values || {};
+  const parent = input.parent || null;
+  const continuityMode = input.continuityMode === 'parent' ? 'parent' : 'root';
+  const parentQualified = continuityMode === 'root' ? !parent : Boolean(parent?.state === 'qualified' && parent?.finalized === true && String(parent?.schemaId || '').trim());
+  if (!parentQualified) return Object.freeze({ state: 'unqualified', reason: continuityMode === 'root' ? 'root-parent-must-be-absent' : 'parent-reference-unavailable', markdown: '' });
+  if (!REQUIRED_INPUTS.every((name) => Object.prototype.hasOwnProperty.call(values, name) && values[name] !== undefined)) {
+    return Object.freeze({ state: 'unqualified', reason: 'topic-generation-input-missing', markdown: '' });
+  }
+  const createdAt = rootTimestamp(input.now instanceof Date ? input.now : new Date(input.now || Date.now()));
+  const summary = canonicalSummary(values.Summary);
+  const unsigned = `# Continuity Context
+
+- Envelope Schema: tiinex.root.v1
+${continuityMode === 'parent' ? `- Parent\n  - Parent Schema: ${parent.schemaId}\n  - Created At: ${parent.createdAt || 'unknown'}\n  - Trace: ${parent.traceTarget}\n  - Origin: ${parent.originTarget}\n  - Boundary: ${parent.boundary || 'explicit-parent-reference'}\n` : ''}- Current
+  - Current Schema: tiinex.topic.v1
+  - Created At: ${createdAt}
+  - Summary: ${summary}
+
+---
+
+# ${summary}
+
+This topic captures the current direction for ${summary}.
+
+## Current Read
+
+${canonicalSection(values['Current Read'])}
+
+## Design Direction
+
+${canonicalSection(values['Design Direction'])}
+
+## Next Artifacts
+
+${canonicalSection(values['Next Artifacts'])}
+
+# Continuity Integrity
+
+- sha256-base64url-c14n-v2
+  - Towards: self
+  - Value: pending
+`;
+  const sealed = sealC14nV2Self(unsigned);
+  if (sealed.state !== 'sealed') return Object.freeze({ state: 'unqualified', reason: 'canonical-topic-integrity-seal-unavailable', markdown: '' });
+  return Object.freeze({ state: 'rendered', markdown: sealed.markdown, createdAt, summary, integrityValue: sealed.value });
+}
+
+export function qualifyCanonicalTopicLocalArtifact({ markdown = '', schemaMaterials = [], values = {}, parent = null, path = '', continuityMode = '' } = {}) {
+  const mode = continuityMode === 'parent' ? 'parent' : 'root';
+  const parentQualified = mode === 'root' ? !parent : Boolean(parent?.state === 'qualified' && parent?.finalized === true && String(parent?.schemaId || '').trim());
+  if (!parentQualified) return Object.freeze({ state: 'invalid', reason: mode === 'root' ? 'root-parent-must-be-absent' : 'parent-reference-unavailable', findings: Object.freeze([]), record: null });
+  let compiled, parsed, projection;
+  try {
+    compiled = compilePortableSchemaContractChain(schemaMaterials);
+    parsed = parseArtifactMarkdown(markdown);
+    const schemaFindings = topicValidate(parsed);
+    projection = Object.freeze({ schema: 'tiinex.site.schema-local-materialization-qualification.v1', validation: Object.freeze({ findings: Object.freeze(schemaFindings) }) });
+  } catch (_) { return Object.freeze({ state: 'invalid', reason: 'canonical-topic-parse-or-compile-failed', findings: Object.freeze([]), record: null }); }
+  const errors = (projection.validation?.findings || []).filter((finding) => finding?.severity === 'error' || finding?.state === 'structurally-invalid' || finding?.state === 'contradictory');
+  const sections = sectionBodies(markdown);
+  const representation = inspectCreationRepresentation(markdown, { boundSections: REQUIRED_INPUTS.slice(1) });
+  const current = parsed.envelope?.current || {};
+  const exactBody = REQUIRED_INPUTS.slice(1).every((name) => sections[name] === canonicalSection(values[name]));
+  const integrity = canonicalC14nV2SelfState(markdown);
+  const invariant = compiled.schemaId === CANONICAL_TOPIC_SCHEMA_ID
+    && current.schema?.id === CANONICAL_TOPIC_SCHEMA_ID
+    && String(current.summary || '') === canonicalSummary(values.Summary)
+    && (mode === 'root'
+      ? !declaredParentEnvelope(parsed.envelope?.parent)
+      : String(parsed.envelope?.parent?.schema?.id || '') === String(parent.schemaId || '')
+        && String(parsed.envelope?.parent?.trace || '') === String(parent.traceTarget || '')
+        && String(parsed.envelope?.parent?.origin || '') === String(parent.originTarget || '')
+        && String(parsed.envelope?.parent?.boundary || '') === String(parent.boundary || 'explicit-parent-reference'))
+    && /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(String(current.createdAt || ''))
+    && firstBodyHeading(markdown) === canonicalSummary(values.Summary)
+    && exactBody
+    && exactRepresentationMultiplicity(representation, mode)
+    && integrity.state === 'verified';
+  if (errors.length || !invariant) return Object.freeze({ state: 'invalid', reason: errors.length ? 'canonical-topic-contract-errors' : 'canonical-topic-invariant-mismatch', findings: Object.freeze(errors), record: null, projection });
+  const record = Object.assign(createRecordFromMarkdown(markdown, { path, name: canonicalSummary(values.Summary), sourceMode: 'local-transition-canonical' }), {
+    kind: CANONICAL_TOPIC_SCHEMA_ID,
+    schemaId: CANONICAL_TOPIC_SCHEMA_ID,
+    status: 'local',
+    sourceMode: 'local-transition-canonical',
+    path,
+    hasContinuityContext: true,
+    hasIntegrity: true
+  });
+  return Object.freeze({ state: 'qualified', reason: '', findings: Object.freeze(errors), record, projection });
+}
+
+function rootTimestamp(date) { return date.toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, ''); }
+function scalar(value) { return String(value === null ? '' : value ?? ''); }
+function canonicalSummary(value) { return scalar(value).trim(); }
+function canonicalSection(value) { return scalar(value).trimEnd(); }
+function declaredParentEnvelope(parent = null) { return Boolean(parent && (String(parent.schema?.id || '').trim() || String(parent.trace || '').trim() || String(parent.origin || '').trim() || String(parent.createdAt || '').trim())); }
+function firstBodyHeading(markdown) { return String(markdown).split('\n---\n')[1]?.match(/^#\s+(.+)$/m)?.[1]?.trim() || ''; }
+function sectionBodies(markdown) {
+  const body = String(markdown).split('\n---\n')[1] || '';
+  const out = {};
+  for (const name of REQUIRED_INPUTS.slice(1)) {
+    const match = body.match(new RegExp(`^## ${escapeRegExp(name)}\\n\\n([\\s\\S]*?)(?=\\n\\n## |\\n\\n# Continuity Integrity|$)`, 'm'));
+    out[name] = match ? match[1].trimEnd() : undefined;
+  }
+  return out;
+}
+function escapeRegExp(value) { return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+export const topicLocalMaterialization = Object.freeze({
+  schemaId: CANONICAL_TOPIC_SCHEMA_ID,
+  label: 'Topic',
+  render: renderCanonicalTopicLocalArtifact,
+  qualify: qualifyCanonicalTopicLocalArtifact,
+  implementation: Object.freeze({ kind: 'browser-local-artifact-representation', status: 'implemented' })
+});

package/src/schemas/core/topic/tiinex.topic.v1.presenter.js

@@ -0,0 +1 @@
+export function topicPresent(artifact, context = {}) { return { title: artifact?.title || 'Topic', summary: artifact?.summary || 'Bounded topic-oriented lineage artifacts for live design and implementation threads.', badges: ['concrete', 'tiinex.topic.v1'], disclosure: context.degraded ? 'degraded' : 'normal' }; }

package/src/schemas/core/topic/tiinex.topic.v1.schema.js

@@ -0,0 +1,34 @@
+import { defineSchemaModule } from '../../contracts.js';
+import { topicArtifactCreationImplementation } from './tiinex.topic.v1.creation.js';
+import { defineArtifactCreationCapability } from '../../creation.capability.js';
+import { topicLocalMaterialization } from './tiinex.topic.v1.localMaterialization.js';
+import binding from './tiinex.topic.v1.schema.json' with { type: 'json' };
+import { schemaSource } from './tiinex.topic.v1.schema.source.js';
+import { topicCapabilities } from './tiinex.topic.v1.capabilities.js';
+import { topicValidate } from './tiinex.topic.v1.validate.js';
+import { topicPresent } from './tiinex.topic.v1.presenter.js';
+import { topicTransitions } from './tiinex.topic.v1.transitions.js';
+import topicI18nEn from './tiinex.topic.v1.en.i18n.json' with { type: 'json' };
+import topicI18nSv from './tiinex.topic.v1.sv.i18n.json' with { type: 'json' };
+import { topicFindings } from './tiinex.topic.v1.findings.js';
+
+export const topicSchemaModule = defineSchemaModule({
+  id: 'tiinex.topic.v1',
+  label: 'Topic',
+  kind: 'concrete',
+  role: 'core-artifact',
+  parentSchemaId: "tiinex.root.v1",
+  summary: 'Bounded topic-oriented lineage artifacts for live design and implementation threads.',
+  binding,
+  schemaSource,
+  artifactCreation: defineArtifactCreationCapability(binding, Object.freeze({ ...topicArtifactCreationImplementation, transitionTypes: Object.freeze(['create-artifact','continue-from-record']) })),
+  capabilities: topicCapabilities,
+  validate: topicValidate,
+  present: topicPresent,
+  read: Object.freeze({ label: 'Topic', sections: Object.freeze(['Content', 'Current Read', 'Design Direction', 'Next Artifacts', 'Good Child Candidates', 'Transition Boundary']), redundantIdentitySections: Object.freeze(['Topic']) }),
+  viewActions: Object.freeze({ lineage: Object.freeze(['record.open', 'record.markdown', 'record.source']) }),
+  transitions: topicTransitions,
+  localMaterialization: topicLocalMaterialization,
+  i18n: Object.freeze({ en: topicI18nEn, sv: topicI18nSv }),
+  findings: topicFindings
+});

package/src/schemas/core/topic/tiinex.topic.v1.schema.json

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