@tiinex/core 0.1.1

package/src/schemas/tiinex.root.v1.capabilities.js

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

package/src/schemas/tiinex.root.v1.classify.js

@@ -0,0 +1,55 @@
+export function schemaKey(schemaId) {
+  const text = String(schemaId || '').toLowerCase();
+  if (text.includes('discovery.')) return 'discovery';
+  if (text.includes('resource.')) return 'resource';
+  if (text.includes('instrument.')) return 'instrument';
+  if (text.includes('relation')) return 'relation';
+  if (text.includes('privacy') || text.includes('redaction')) return 'privacy';
+  if (text.includes('attestation')) return 'attestation';
+  if (text.includes('external.payload')) return 'payload';
+  if (text.includes('topic')) return 'topic';
+  if (text.includes('task')) return 'task';
+  if (text.includes('decision')) return 'decision';
+  if (text.includes('evidence')) return 'evidence';
+  if (text.includes('feedback')) return 'feedback';
+  if (text.includes('reduction')) return 'reduction';
+  if (text.includes('runtime')) return 'runtime';
+  if (text.includes('signal')) return 'signal';
+  if (text.includes('pointer')) return 'pointer';
+  if (text.includes('lineage.upgrade')) return 'lineage-upgrade';
+  if (text.includes('schema.family') || text.includes('definition')) return 'schema-governance';
+  if (text.includes('schema.module')) return 'schema-module';
+  if (text.includes('presentation.surface')) return 'surface';
+  if (text.includes('validation.method')) return 'validation';
+  if (text.includes('workspace')) return 'workspace';
+  return schemaId ? 'unknown' : 'plain';
+}
+
+export function schemaBadgeClass(schemaId) {
+  const key = schemaKey(schemaId);
+  const known = [
+    'topic', 'task', 'decision', 'evidence', 'feedback', 'reduction',
+    'runtime', 'signal', 'pointer', 'discovery', 'resource', 'instrument',
+    'relation', 'privacy', 'attestation', 'payload', 'lineage-upgrade',
+    'schema-governance', 'schema-module', 'surface', 'workspace', 'validation'
+  ];
+  if (known.includes(key)) return key;
+  return key === 'plain' ? 'plain' : 'unknown';
+}
+
+export function schemaIdFromText(value, fallback = 'tiinex.topic.v1') {
+  const text = String(value || '').trim();
+  if (!text) return fallback;
+  const markdown = text.match(/\[([^\]]+)\]\([^)]+\)/);
+  if (markdown) return markdown[1].trim() || fallback;
+  return text.replace(/^Current Schema:\s*/i, '').trim() || fallback;
+}
+
+export function schemaLabel(schemaId = '') {
+  const id = String(schemaId || '').trim();
+  if (!id) return 'Plain material';
+  const key = schemaKey(id);
+  if (key && key !== 'unknown') return key.replace(/-/g, ' ');
+  const parts = id.split('.').filter(Boolean);
+  return parts.length ? parts.slice(-2, -1)[0] || parts.at(-1) : id;
+}

package/src/schemas/tiinex.root.v1.en.i18n.json

@@ -0,0 +1,24 @@
+{
+  "label": "Root",
+  "summary": "Minimum shared contract for Tiinex lineage artifacts; abstract envelope and fallback.",
+  "root.continuity.missing": "Missing # Continuity Context.",
+  "root.envelopeSchema.missing": "Missing Envelope Schema.",
+  "root.currentSchema.missing": "Missing Current → Current Schema.",
+  "root.createdAt.missing": "Missing Current → Created At.",
+  "root.integrity.missing": "Missing Continuity Integrity footer.",
+  "root.parent.absent": "No parent edge declared; artifact is local lineage root unless another relation says otherwise.",
+  "root.parent.schema.missing": "Parent edge is present but Parent Schema is missing.",
+  "root.parent.trace.missing": "Parent edge is present but Trace is missing; lineage traversal will be degraded.",
+  "root.parent.origin.missing": "Parent edge is present but Origin is missing; recovery will rely on other hints.",
+  "root.repairs.declared": "Envelope declares repair notes; validators should preserve unknown repair fields.",
+  "root.envelope.readable": "Root envelope is readable at current validation depth.",
+  "root.fallback.used": "Schema module is unavailable; root/envelope semantics only.",
+  "integrity.validation.skipped": "Continuity Integrity footer is missing; integrity engine did not run byte/canonicalization validation.",
+  "integrity.method.unspecified": "Continuity Integrity exists but no machine-verifiable integrity method is declared.",
+  "integrity.c14n-v2.detected": "c14n-v2 integrity method is declared; the integrity engine evaluates self entries when canonical artifact bytes are available.",
+  "integrity.local-draft.declared": "Draft/local integrity marker is present; it is a recoverability marker, not a published byte-verification proof.",
+  "integrity.method.declared": "Integrity method declared.",
+  "integrity.c14n-v2.verified": "c14n-v2 self-integrity is verified against the current canonical artifact bytes.",
+  "integrity.c14n-v2.mismatch": "c14n-v2 self-integrity does not match the current canonical artifact bytes.",
+  "integrity.c14n-v2.ambiguous": "c14n-v2 self-integrity could not be verified unambiguously."
+}

package/src/schemas/tiinex.root.v1.fallback.js

@@ -0,0 +1,84 @@
+import { schemaBadgeClass, schemaKey, schemaLabel } from './tiinex.root.v1.classify.js';
+
+export const ROOT_FALLBACK_CONTRACT_ID = 'tiinex.root.fallback.v1';
+
+export function createRootFallbackModel(parsedArtifact = {}, schemaResolution = {}, findings = []) {
+  const envelope = parsedArtifact.envelope || {};
+  const currentSchemaId = envelope.current?.schema?.id || '';
+  const parentSchemaId = envelope.parent?.schema?.id || '';
+  const resolutionStatus = schemaResolution.status || (schemaResolution.fallbackUsed ? 'root-fallback' : 'unknown');
+  const fallbackUsed = Boolean(schemaResolution.fallbackUsed || resolutionStatus === 'root-fallback');
+  const integrity = parsedArtifact.integrity || {};
+  const findingCounts = countFindings(findings);
+  return {
+    schema: ROOT_FALLBACK_CONTRACT_ID,
+    title: parsedArtifact.title || envelope.current?.summary || 'Untitled artifact',
+    summary: envelope.current?.summary || parsedArtifact.body?.sections?.slice(0, 3).join(' · ') || 'Tiinex artifact readable through root fallback.',
+    currentSchemaId: currentSchemaId || 'unknown',
+    envelopeSchemaId: envelope.envelopeSchema?.id || 'unknown',
+    schemaKey: schemaKey(currentSchemaId),
+    schemaLabel: schemaLabel(currentSchemaId),
+    badgeClass: schemaBadgeClass(currentSchemaId),
+    resolutionStatus,
+    fallbackUsed,
+    rootReadable: Boolean(parsedArtifact.hasContinuityContext && envelope.current?.schema?.id),
+    continuity: {
+      hasContinuityContext: Boolean(parsedArtifact.hasContinuityContext),
+      hasIntegrity: Boolean(parsedArtifact.hasIntegrity),
+      createdAt: envelope.current?.createdAt || '',
+      parentSchemaId: parentSchemaId || null,
+      trace: envelope.parent?.trace || '',
+      origin: envelope.parent?.origin || envelope.origin || '',
+      boundary: envelope.parent?.boundary || envelope.boundary || '',
+      repairsDeclared: Boolean(envelope.repairsDeclared)
+    },
+    integrity: {
+      methods: integrity.methods || [],
+      values: integrity.values || []
+    },
+    findings,
+    findingCounts,
+    badges: makeBadges({ currentSchemaId, fallbackUsed, parsedArtifact, findingCounts }),
+    disclosure: fallbackUsed ? 'root-fallback' : findingCounts.error ? 'invalid-or-incomplete' : 'readable'
+  };
+}
+
+export function presentRootFallback(artifactOrModel = {}, context = {}) {
+  const model = artifactOrModel.schema === ROOT_FALLBACK_CONTRACT_ID
+    ? artifactOrModel
+    : createRootFallbackModel(artifactOrModel, context.schemaResolution || {}, context.findings || []);
+  return {
+    title: model.title,
+    summary: model.summary,
+    badges: model.badges,
+    disclosure: model.disclosure,
+    schemaKey: model.schemaKey,
+    schemaLabel: model.schemaLabel,
+    continuity: model.continuity,
+    findings: model.findings
+  };
+}
+
+function countFindings(findings = []) {
+  const counts = { error: 0, warning: 0, info: 0, preserve: 0, total: 0 };
+  for (const finding of Array.isArray(findings) ? findings : []) {
+    const severity = finding?.severity || 'info';
+    if (counts[severity] == null) counts[severity] = 0;
+    counts[severity] += 1;
+    counts.total += 1;
+  }
+  return counts;
+}
+
+function makeBadges({ currentSchemaId, fallbackUsed, parsedArtifact, findingCounts }) {
+  const badges = [];
+  badges.push(currentSchemaId || 'unknown schema');
+  badges.push(schemaKey(currentSchemaId));
+  if (fallbackUsed) badges.push('root fallback');
+  if (parsedArtifact?.hasContinuityContext) badges.push('continuity');
+  else badges.push('plain markdown');
+  if (parsedArtifact?.hasIntegrity) badges.push('integrity');
+  if (findingCounts.error) badges.push(`${findingCounts.error} errors`);
+  if (findingCounts.warning) badges.push(`${findingCounts.warning} warnings`);
+  return badges.filter(Boolean);
+}

package/src/schemas/tiinex.root.v1.findings.js

@@ -0,0 +1,19 @@
+export const rootFindings = Object.freeze({
+  namespace: 'tiinex.root.v1',
+  defaultSeverity: 'info',
+  codes: Object.freeze({
+    'root.continuity.missing': finding('root.continuity.missing', 'error', false),
+    'root.envelopeSchema.missing': finding('root.envelopeSchema.missing', 'error', false),
+    'root.currentSchema.missing': finding('root.currentSchema.missing', 'error', false),
+    'root.createdAt.missing': finding('root.createdAt.missing', 'error', false),
+    'root.integrity.missing': finding('root.integrity.missing', 'warning', false),
+    'root.parent.absent': finding('root.parent.absent', 'info', false),
+    'root.parent.schema.missing': finding('root.parent.schema.missing', 'warning', false),
+    'root.parent.trace.missing': finding('root.parent.trace.missing', 'warning', false),
+    'root.parent.origin.missing': finding('root.parent.origin.missing', 'warning', false),
+    'root.repairs.declared': finding('root.repairs.declared', 'info', false),
+    'root.envelope.readable': finding('root.envelope.readable', 'info', false),
+    'root.fallback.used': finding('root.fallback.used', 'warning', false)
+  })
+});
+function finding(messageKey, severity, safeFix) { return Object.freeze({ severity, messageKey, fixability: safeFix ? 'safe' : 'none' }); }

package/src/schemas/tiinex.root.v1.presenter.js

@@ -0,0 +1,5 @@
+import { presentRootFallback } from './tiinex.root.v1.fallback.js';
+
+export function rootPresent(artifact, context = {}) {
+  return presentRootFallback(artifact, context);
+}

package/src/schemas/tiinex.root.v1.schema.js

@@ -0,0 +1,29 @@
+import { defineSchemaModule } from './contracts.js';
+import binding from './tiinex.root.v1.schema.json' with { type: 'json' };
+import { schemaSource } from './tiinex.root.v1.schema.source.js';
+import { rootCapabilities } from './tiinex.root.v1.capabilities.js';
+import { rootValidate } from './tiinex.root.v1.validate.js';
+import { rootPresent } from './tiinex.root.v1.presenter.js';
+import { rootTransitions } from './tiinex.root.v1.transitions.js';
+import rootI18nEn from './tiinex.root.v1.en.i18n.json' with { type: 'json' };
+import rootI18nSv from './tiinex.root.v1.sv.i18n.json' with { type: 'json' };
+import { rootFindings } from './tiinex.root.v1.findings.js';
+
+export const rootSchemaModule = defineSchemaModule({
+  id: 'tiinex.root.v1',
+  label: 'Root',
+  kind: 'abstract',
+  role: 'envelope',
+  parentSchemaId: null,
+  summary: 'Minimum shared contract for Tiinex lineage artifacts; abstract envelope and fallback.',
+  binding,
+  schemaSource,
+  capabilities: rootCapabilities,
+  validate: rootValidate,
+  present: rootPresent,
+  read: Object.freeze({ label: 'Root', sections: Object.freeze(['Summary', 'Root Semantics', 'Contract Reading Model']) }),
+  viewActions: Object.freeze({ lineage: Object.freeze(['record.open', 'record.markdown', 'record.source']) }),
+  transitions: rootTransitions,
+  i18n: Object.freeze({ en: rootI18nEn, sv: rootI18nSv }),
+  findings: rootFindings
+});

package/src/schemas/tiinex.root.v1.schema.json

@@ -0,0 +1,24 @@
+{
+  "schemaId": "tiinex.root.v1",
+  "kind": "abstract",
+  "role": "envelope",
+  "module": "./tiinex.root.v1.schema.js",
+  "snapshot": "./tiinex.root.v1.schema.md",
+  "canonicalUri": "tiinex://schemas/tiinex.root.v1",
+  "permalink": "https://github.com/Tiinex/docs/blob/3988951208eb9a8926e84ab42625d4b42fa00c2d/.topics/.schemas/tiinex.root.v1.schema.md",
+  "rawUrl": "https://raw.githubusercontent.com/Tiinex/docs/3988951208eb9a8926e84ab42625d4b42fa00c2d/.topics/.schemas/tiinex.root.v1.schema.md",
+  "sourcePath": ".topics/.schemas/tiinex.root.v1.schema.md",
+  "sourceRepository": "Tiinex/docs",
+  "sourceCommit": "3988951208eb9a8926e84ab42625d4b42fa00c2d",
+  "sourceBlobSha": "0162368365b452ea134b71bf52ced7554a7c5abc",
+  "checksum": {
+    "algorithm": "sha256",
+    "value": "4ec6d17ef55f51c2305ede8e2f22c8c4a9324c478489114adb86a33664d4d156"
+  },
+  "capabilityContract": "tiinex.schema.module.v1",
+  "snapshotCompleteness": "exact-axiom-canonical-unpublished-bounded-workspace-contract",
+  "bindingVersion": "tiinex.web.schema-binding.v1",
+  "originId": "tiinex-docs-39889512-accepted-local",
+  "originTrustRole": "canonical-core",
+  "publicationState": "accepted-local-unpublished"
+}