@tiinex/core 0.1.1

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

@@ -0,0 +1,9 @@
+import binding from './tiinex.preservation.v1.schema.json' with { type: 'json' };
+import projection from './tiinex.preservation.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/preservation/tiinex.preservation.v1.schema.md',
+  sourceLabel: 'Viewer schema registry',
+  assetUrl: new URL('./tiinex.preservation.v1.schema.md', import.meta.url).href
+}));

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

@@ -0,0 +1,6 @@
+{
+  "label": "Preservation",
+  "summary": "Captured or preserved material made available for later judgment.",
+  "preservation.section.missing": "Missing required preservation section: {section}.",
+  "preservation.sections.present": "Required preservation sections are present."
+}

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

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

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

@@ -0,0 +1,10 @@
+const requiredSections = ['Preserved Material', 'Preservation Act', 'Provenance', 'Fidelity And Loss', 'Custody Or Storage Boundary', 'Interpretation Limits'];
+
+export function preservationValidate(artifact) {
+  const findings = [];
+  for (const section of requiredSections) {
+    if (!artifact.body.sections.includes(section)) findings.push({ severity: 'error', code: 'preservation.section.missing', messageKey: 'preservation.section.missing', message: `Missing required preservation section: ${section}.`, source: 'tiinex.preservation.v1', params: { section }, fixability: 'manual' });
+  }
+  if (!findings.some((finding) => finding.severity === 'error')) findings.push({ severity: 'info', code: 'preservation.sections.present', messageKey: 'preservation.sections.present', message: 'Required preservation sections are present.', source: 'tiinex.preservation.v1' });
+  return findings;
+}

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

@@ -0,0 +1,7 @@
+export const relationCapabilities = Object.freeze({
+  canCreateArtifact: false,
+  canBeParent: true,
+  canRenderFallback: false,
+  supportedSurfaces: Object.freeze(['feed','tree','detail','lineage','preview','share']),
+  boundaries: Object.freeze(['relation-is-not-parent','relation-does-not-prove-truth','reference-relation-created-only-by-qualified-transition'])
+});

package/src/schemas/core/relation/tiinex.relation.v1.contract.js

@@ -0,0 +1,3 @@
+export const RELATION_REQUIRED_SECTIONS = Object.freeze(['Relation Declaration', 'Relation Target', 'Relation Boundary']);
+export const RELATION_DECLARATION_FIELDS = Object.freeze(['Relation Type', 'Relation Direction', 'Relation Scope']);
+export const RELATION_REFERENCE_DURABILITY_FIELDS = Object.freeze(['Predicate Identifier', 'Predicate Meaning', 'Subject Binding', 'Object Binding', 'Directionality']);

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

@@ -0,0 +1,4 @@
+{
+  "schema.label": "Relation",
+  "schema.summary": "Typed non-parent relation."
+}

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

@@ -0,0 +1,9 @@
+export const relationFindings = Object.freeze({ namespace: 'tiinex.relation.v1', defaultSeverity: 'info', codes: Object.freeze({
+  'relation.schema.mismatch': finding('warning','manual'),
+  'relation.title.missing': finding('error','manual'),
+  'relation.section.missing': finding('error','manual'),
+  'relation.field.missing': finding('error','manual'),
+  'relation.boundary.parent-confusion': finding('error','manual'),
+  'relation.contract.readable': finding('info','none')
+}) });
+function finding(severity, fixability) { return Object.freeze({ severity, messageKey: '', fixability }); }

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

@@ -0,0 +1,153 @@
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+import { createRecordFromMarkdown } from '../../../artifacts/artifact.record.js';
+import { compilePortableSchemaContractChain } from '../../../tooling/portable/schema/contract.compile.js';
+import { relationValidate } from './tiinex.relation.v1.validate.js';
+import { canonicalC14nV2SelfState, sealC14nV2Self } from '../../../integrity/integrity.c14nV2.js';
+
+export const CANONICAL_RELATION_SCHEMA_ID = 'tiinex.relation.v1';
+export const CANONICAL_RELATION_LOCAL_MATERIALIZER_SCHEMA_ID = 'tiinex.site.canonical-relation-local-materializer.v1';
+export const REFERENCE_RELATION_REQUIRED_INPUTS = Object.freeze([
+  'Relation Type', 'Relation Direction', 'Relation Scope', 'Relation Target',
+  'Predicate Identifier', 'Predicate Meaning', 'Subject Binding', 'Object Binding',
+  'Directionality', 'Transition Authority', 'Transition Authority Representation Method', 'Transition Authority Representation Value',
+  'Generation Authority', 'Generation Authority Representation Method', 'Generation Authority Representation Value'
+]);
+
+export function renderCanonicalRelationLocalArtifact(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 (!REFERENCE_RELATION_REQUIRED_INPUTS.every((name) => scalar(values[name]).trim())) {
+    return Object.freeze({ state: 'unqualified', reason: 'relation-generation-input-missing', markdown: '' });
+  }
+  const createdAt = rootTimestamp(input.now instanceof Date ? input.now : new Date(input.now || Date.now()));
+  const title = `${scalar(values['Relation Type'])}: ${readableTarget(values['Subject Binding'])} → ${readableTarget(values['Object Binding'])}`;
+  const summary = `${scalar(values['Relation Type'])}: ${readableTarget(values['Subject Binding'])} → ${readableTarget(values['Object Binding'])}`;
+  const unsigned = `# Continuity Context
+
+- Envelope Schema: tiinex.root.v1
+${continuityMode === 'parent' ? `- Parent
+  - Parent Schema: ${parent.schemaId}
+  - Created At: ${parent.createdAt || 'unknown'}
+  - Trace: ${parent.traceTarget}
+  - Origin: ${parent.originTarget}
+  - Boundary: ${parent.boundary || 'explicit-parent-reference'}
+` : ''}- Current
+  - Current Schema: tiinex.relation.v1
+  - Created At: ${createdAt}
+  - Summary: ${summary}
+
+---
+
+# ${title}
+
+## Relation Declaration
+
+- Relation Type: ${scalar(values['Relation Type'])}
+- Relation Direction: ${scalar(values['Relation Direction'])}
+- Relation Scope: ${scalar(values['Relation Scope'])}
+
+## Relation Target
+
+- Target: ${scalar(values['Relation Target'])}
+
+## Relation Boundary
+
+- This Relation records a typed non-parent binding. The Relation target is not the Tiinex continuity Parent.
+
+## Relation Source
+
+- Subject: ${scalar(values['Subject Binding'])}
+- Object: ${scalar(values['Object Binding'])}
+- Predicate Identifier: ${scalar(values['Predicate Identifier'])}
+- Predicate Meaning: ${scalar(values['Predicate Meaning'])}
+- Directionality: ${scalar(values.Directionality)}
+
+## References
+
+- Defining Transition: ${scalar(values['Transition Authority'])}
+- Defining Transition Representation Method: ${scalar(values['Transition Authority Representation Method'])}
+- Defining Transition Representation Value: ${scalar(values['Transition Authority Representation Value'])}
+- Generation Authority: ${scalar(values['Generation Authority'])}
+- Generation Authority Representation Method: ${scalar(values['Generation Authority Representation Method'])}
+- Generation Authority Representation Value: ${scalar(values['Generation Authority Representation Value'])}
+
+## Interpretation Limits
+
+- Does Not Prove: truth, evidence, authority, dependency, or continuity ancestry.
+- Must Not Be Treated As: Parent, Evidence, source provenance, or universal Reference applicability.
+
+# 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-relation-integrity-seal-unavailable', markdown: '' });
+  return Object.freeze({ state: 'rendered', markdown: sealed.markdown, createdAt, summary, integrityValue: sealed.value });
+}
+
+export function qualifyCanonicalRelationLocalArtifact({ 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 = relationValidate(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-relation-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 current = parsed.envelope?.current || {};
+  const body = parsed.body?.text || '';
+  const integrity = canonicalC14nV2SelfState(markdown);
+  const invariant = compiled.schemaId === CANONICAL_RELATION_SCHEMA_ID
+    && current.schema?.id === CANONICAL_RELATION_SCHEMA_ID
+    && (mode === 'root'
+      ? !declaredParent(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'))
+    && fieldValue(body, 'Relation Type') === scalar(values['Relation Type'])
+    && fieldValue(body, 'Relation Direction') === scalar(values['Relation Direction'])
+    && fieldValue(body, 'Relation Scope') === scalar(values['Relation Scope'])
+    && fieldValue(body, 'Target') === scalar(values['Relation Target'])
+    && fieldValue(body, 'Predicate Identifier') === scalar(values['Predicate Identifier'])
+    && fieldValue(body, 'Predicate Meaning') === scalar(values['Predicate Meaning'])
+    && fieldValue(body, 'Subject') === scalar(values['Subject Binding'])
+    && fieldValue(body, 'Object') === scalar(values['Object Binding'])
+    && fieldValue(body, 'Directionality') === scalar(values.Directionality)
+    && fieldValue(body, 'Defining Transition') === scalar(values['Transition Authority'])
+    && fieldValue(body, 'Defining Transition Representation Method') === scalar(values['Transition Authority Representation Method'])
+    && fieldValue(body, 'Defining Transition Representation Value') === scalar(values['Transition Authority Representation Value'])
+    && fieldValue(body, 'Generation Authority') === scalar(values['Generation Authority'])
+    && fieldValue(body, 'Generation Authority Representation Method') === scalar(values['Generation Authority Representation Method'])
+    && fieldValue(body, 'Generation Authority Representation Value') === scalar(values['Generation Authority Representation Value'])
+    && /not\s+(?:the\s+)?tiinex\s+continuity\s+Parent/i.test(sectionBody(body, 'Relation Boundary'))
+    && integrity.state === 'verified';
+  if (errors.length || !invariant) return Object.freeze({ state: 'invalid', reason: errors.length ? 'canonical-relation-contract-errors' : 'canonical-relation-invariant-mismatch', findings: Object.freeze(errors), record: null, projection });
+  const record = Object.assign(createRecordFromMarkdown(markdown, { path, name: String(current.summary || ''), sourceMode: 'local-transition-canonical' }), {
+    kind: CANONICAL_RELATION_SCHEMA_ID, schemaId: CANONICAL_RELATION_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 declaredParent(parent = {}) { return Boolean(String(parent?.schema?.id || '').trim() || String(parent?.trace || '').trim() || String(parent?.origin || '').trim()); }
+function fieldValue(body = '', field = '') { const escaped = String(field).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); return String(body).match(new RegExp(`^\\s*-\\s*${escaped}:\\s*(.+)$`, 'm'))?.[1]?.trim() || ''; }
+function sectionBody(body = '', name = '') { const escaped = String(name).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); return String(body).match(new RegExp(`^##\\s+${escaped}[^\\S\\r\\n]*$([\\s\\S]*?)(?=^##\\s+|^#\\s+Continuity Integrity[^\\S\\r\\n]*$|(?![\\s\\S]))`, 'm'))?.[1]?.trim() || ''; }
+function readableTarget(value = '') { const text = scalar(value).trim(); return text.length > 70 ? `${text.slice(0, 67)}…` : text; }
+function rootTimestamp(date) { return date.toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, ''); }
+function scalar(value) { return String(value === null ? '' : value ?? ''); }
+
+export const relationLocalMaterialization = Object.freeze({
+  schemaId: CANONICAL_RELATION_SCHEMA_ID,
+  label: 'Relation',
+  render: renderCanonicalRelationLocalArtifact,
+  qualify: qualifyCanonicalRelationLocalArtifact,
+  implementation: Object.freeze({ kind: 'browser-local-artifact-representation', status: 'implemented' })
+});

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

@@ -0,0 +1,3 @@
+export function relationPresent(artifact = {}, context = {}) {
+  return { title: artifact?.title || 'Relation', summary: artifact?.summary || 'Typed non-parent relation.', badges: ['concrete','tiinex.relation.v1'], disclosure: context.degraded ? 'degraded' : 'normal' };
+}

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

@@ -0,0 +1,20 @@
+import { defineSchemaModule } from '../../contracts.js';
+import { relationLocalMaterialization } from './tiinex.relation.v1.localMaterialization.js';
+import binding from './tiinex.relation.v1.schema.json' with { type: 'json' };
+import { schemaSource } from './tiinex.relation.v1.schema.source.js';
+import { relationCapabilities } from './tiinex.relation.v1.capabilities.js';
+import { relationValidate } from './tiinex.relation.v1.validate.js';
+import { relationPresent } from './tiinex.relation.v1.presenter.js';
+import { relationTransitions } from './tiinex.relation.v1.transitions.js';
+import relationI18nEn from './tiinex.relation.v1.en.i18n.json' with { type: 'json' };
+import relationI18nSv from './tiinex.relation.v1.sv.i18n.json' with { type: 'json' };
+import { relationFindings } from './tiinex.relation.v1.findings.js';
+import { RELATION_REQUIRED_SECTIONS } from './tiinex.relation.v1.contract.js';
+export const relationSchemaModule = defineSchemaModule({
+  id: 'tiinex.relation.v1', label: 'Relation', kind: 'concrete', role: 'core-artifact', parentSchemaId:'tiinex.root.v1',
+  schemaSource, summary:'Typed non-parent relation between artifacts or bounded targets.', binding, capabilities:relationCapabilities,
+  validate:relationValidate, present:relationPresent, read:Object.freeze({label:'Relation',sections:RELATION_REQUIRED_SECTIONS}),
+  viewActions:Object.freeze({lineage:Object.freeze(['record.open','record.markdown','record.source'])}), transitions:relationTransitions,
+  localMaterialization: relationLocalMaterialization,
+  i18n:Object.freeze({en:relationI18nEn,sv:relationI18nSv}), findings:relationFindings
+});

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

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