@tiinex/core 0.1.1

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

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

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

@@ -0,0 +1,11 @@
+export const interpretationCapabilities = Object.freeze({
+  canCreateArtifact: true,
+  canBeParent: true,
+  canRenderFallback: false,
+  supportedSurfaces: Object.freeze(['feed', 'tree', 'detail', 'lineage', 'preview', 'share']),
+  boundaries: Object.freeze([
+    'interpretation-does-not-mutate-source',
+    'interpretation-does-not-prove-target-role',
+    'browser-local-draft-interpretation'
+  ])
+});

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

@@ -0,0 +1,40 @@
+export const INTERPRETATION_REQUIRED_SECTIONS = Object.freeze([
+  'Interpretation Source',
+  'Interpreted As',
+  'Interpretation Basis',
+  'Resulting Artifact Boundary',
+  'Uncertainty And Review',
+  'Interpretation Limits'
+]);
+
+export const INTERPRETATION_CREATION_FIELDS = Object.freeze([
+  'Source Target',
+  'Source Role',
+  'Target Role',
+  'Interpretation Action',
+  'Rationale',
+  'Observed Basis',
+  'Original Mutation Policy',
+  'Result Boundary',
+  'Uncertainty',
+  'Review Need',
+  'Does Not Prove',
+  'Must Not Be Treated As'
+]);
+
+export const INTERPRETATION_SECTION_FIELDS = Object.freeze([
+  Object.freeze(['Interpretation Source', Object.freeze(['Source Target', 'Source Role'])]),
+  Object.freeze(['Interpreted As', Object.freeze(['Target Role', 'Interpretation Action'])]),
+  Object.freeze(['Interpretation Basis', Object.freeze(['Rationale', 'Observed Basis'])]),
+  Object.freeze(['Resulting Artifact Boundary', Object.freeze(['Original Mutation Policy', 'Result Boundary'])]),
+  Object.freeze(['Uncertainty And Review', Object.freeze(['Uncertainty', 'Review Need'])]),
+  Object.freeze(['Interpretation Limits', Object.freeze(['Does Not Prove', 'Must Not Be Treated As'])])
+]);
+
+export const INTERPRETATION_CANONICAL_SOURCE = Object.freeze({
+  repository: 'Tiinex/docs',
+  commit: '053d46ce082d4ec261b82abc44ecca403d61e240',
+  path: '.topics/.schemas/core/interpretation/tiinex.interpretation.v1.schema.md',
+  gitBlob: '330d8668e78cd6d164a76093982b02f616fd6ab4',
+  sha256: '977a46d67eb4e3e8ce383f7f33efbf10798122cc3f94e5b948c084a9af311017'
+});

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

@@ -0,0 +1,9 @@
+{
+  "label": "Interpretation",
+  "summary": "Explicit bounded interpretation of another artifact or target without mutating the original.",
+  "interpretation.schema.mismatch": "Interpretation validator was invoked for a different schema.",
+  "interpretation.title.missing": "Interpretation is missing a human-readable title.",
+  "interpretation.section.missing": "Interpretation is missing required section {section}.",
+  "interpretation.field.missing": "Interpretation is missing required field {field}.",
+  "interpretation.contract.readable": "Interpretation exposes the required bounded Use-as fields."
+}

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

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

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

@@ -0,0 +1,89 @@
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+import { createRecordFromMarkdown } from '../../../artifacts/artifact.record.js';
+import { compilePortableSchemaContractChain } from '../../../tooling/portable/schema/contract.compile.js';
+import { interpretationValidate } from './tiinex.interpretation.v1.validate.js';
+import { canonicalC14nV2SelfState, sealC14nV2Self } from '../../../integrity/integrity.c14nV2.js';
+import {
+  INTERPRETATION_CREATION_FIELDS,
+  INTERPRETATION_SECTION_FIELDS
+} from './tiinex.interpretation.v1.contract.js';
+
+export const CANONICAL_INTERPRETATION_LOCAL_MATERIALIZER_SCHEMA_ID = 'tiinex.site.canonical-interpretation-local-materializer.v1';
+export const CANONICAL_INTERPRETATION_SCHEMA_ID = 'tiinex.interpretation.v1';
+const REQUIRED_INPUTS = INTERPRETATION_CREATION_FIELDS;
+
+export function renderCanonicalInterpretationLocalArtifact(input = {}) {
+  const values = input.values || {};
+  const parent = input.parent || {};
+  if (parent.state !== 'qualified' || parent.finalized !== true) {
+    return Object.freeze({ state: 'unqualified', reason: 'parent-reference-unavailable', markdown: '' });
+  }
+  if (!REQUIRED_INPUTS.every((name) => Object.prototype.hasOwnProperty.call(values, name) && values[name] !== undefined && scalar(values[name]).trim())) {
+    return Object.freeze({ state: 'unqualified', reason: 'interpretation-generation-input-missing', markdown: '' });
+  }
+  const createdAt = rootTimestamp(input.now instanceof Date ? input.now : new Date(input.now || Date.now()));
+  const targetRole = scalar(values['Target Role']).trim();
+  const action = scalar(values['Interpretation Action']).trim();
+  const summary = `${action || 'Use as'} · ${targetRole || 'Interpretation'}`;
+  const body = INTERPRETATION_SECTION_FIELDS.map(([section, fields]) => `## ${section}\n\n${fields.map((field) => `- ${field}: ${scalar(values[field])}`).join('\n')}`).join('\n\n');
+  const unsigned = `# Continuity Context\n\n- Envelope Schema: tiinex.root.v1\n- Parent\n  - Parent Schema: ${parent.schemaId}\n  - Trace: ${parent.trace}\n  - Origin: ${parent.origin}\n- Current\n  - Current Schema: tiinex.interpretation.v1\n  - Created At: ${createdAt}\n  - Summary: ${summary}\n\n---\n\n# ${summary}\n\n${body}\n\n# Continuity Integrity\n\n- sha256-base64url-c14n-v2\n  - Towards: self\n  - Value: pending\n`;
+  const sealed = sealC14nV2Self(unsigned);
+  if (sealed.state !== 'sealed') return Object.freeze({ state: 'unqualified', reason: 'canonical-interpretation-integrity-seal-unavailable', markdown: '' });
+  return Object.freeze({ state: 'rendered', markdown: sealed.markdown, createdAt, summary, integrityValue: sealed.value });
+}
+
+export function qualifyCanonicalInterpretationLocalArtifact({ markdown = '', schemaMaterials = [], values = {}, parent = {}, path = '' } = {}) {
+  let compiled, parsed, projection;
+  try {
+    compiled = compilePortableSchemaContractChain(schemaMaterials);
+    parsed = parseArtifactMarkdown(markdown);
+    const schemaFindings = interpretationValidate(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-interpretation-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 parentEnvelope = parsed.envelope?.parent || {};
+  const exactFields = REQUIRED_INPUTS.every((name) => fieldValue(parsed.body?.text || '', name) === scalar(values[name]));
+  const integrity = canonicalC14nV2SelfState(markdown);
+  const invariant = compiled.schemaId === CANONICAL_INTERPRETATION_SCHEMA_ID
+    && current.schema?.id === CANONICAL_INTERPRETATION_SCHEMA_ID
+    && String(parentEnvelope.schema?.id || '') === String(parent.schemaId || '')
+    && String(parentEnvelope.trace || '') === String(parent.traceTarget || '')
+    && String(parentEnvelope.origin || '') === String(parent.originTarget || '')
+    && /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(String(current.createdAt || ''))
+    && exactFields
+    && integrity.state === 'verified';
+  if (errors.length || !invariant) {
+    return Object.freeze({ state: 'invalid', reason: errors.length ? 'canonical-interpretation-contract-errors' : 'canonical-interpretation-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_INTERPRETATION_SCHEMA_ID,
+    schemaId: CANONICAL_INTERPRETATION_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 });
+}
+
+export function canonicalInterpretationRequiredInputs() { return REQUIRED_INPUTS; }
+
+function fieldValue(body = '', field = '') {
+  const escaped = String(field).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return String(body).match(new RegExp(`^\\s*-\\s*${escaped}:\\s*(.+)$`, 'm'))?.[1]?.trim() || '';
+}
+function rootTimestamp(date) { return date.toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, ''); }
+function scalar(value) { return String(value === null ? '' : value ?? ''); }
+
+export const interpretationLocalMaterialization = Object.freeze({
+  schemaId: CANONICAL_INTERPRETATION_SCHEMA_ID,
+  label: 'Interpretation',
+  render: renderCanonicalInterpretationLocalArtifact,
+  qualify: qualifyCanonicalInterpretationLocalArtifact,
+  authoringInputsFromInvocationBindings: ({ parentTarget = '' } = {}) => Object.freeze({ 'Source Target': String(parentTarget || '') }),
+  implementation: Object.freeze({ kind: 'browser-local-artifact-representation', status: 'implemented' })
+});

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

@@ -0,0 +1,8 @@
+export function interpretationPresent(artifact = {}, context = {}) {
+  return {
+    title: artifact?.title || 'Interpretation',
+    summary: artifact?.summary || 'Explicit bounded interpretation of another artifact or target.',
+    badges: ['concrete', 'tiinex.interpretation.v1'],
+    disclosure: context.degraded ? 'degraded' : 'normal'
+  };
+}

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

@@ -0,0 +1,34 @@
+import { defineSchemaModule } from '../../contracts.js';
+import { defineArtifactCreationCapability } from '../../creation.capability.js';
+import { interpretationLocalMaterialization } from './tiinex.interpretation.v1.localMaterialization.js';
+import binding from './tiinex.interpretation.v1.schema.json' with { type: 'json' };
+import { schemaSource } from './tiinex.interpretation.v1.schema.source.js';
+import { interpretationCapabilities } from './tiinex.interpretation.v1.capabilities.js';
+import { interpretationValidate } from './tiinex.interpretation.v1.validate.js';
+import { interpretationPresent } from './tiinex.interpretation.v1.presenter.js';
+import { interpretationTransitions } from './tiinex.interpretation.v1.transitions.js';
+import interpretationI18nEn from './tiinex.interpretation.v1.en.i18n.json' with { type: 'json' };
+import interpretationI18nSv from './tiinex.interpretation.v1.sv.i18n.json' with { type: 'json' };
+import { interpretationFindings } from './tiinex.interpretation.v1.findings.js';
+import { INTERPRETATION_REQUIRED_SECTIONS } from './tiinex.interpretation.v1.contract.js';
+
+export const interpretationSchemaModule = defineSchemaModule({
+  id: 'tiinex.interpretation.v1',
+  label: 'Interpretation',
+  kind: 'concrete',
+  role: 'core-artifact',
+  parentSchemaId: 'tiinex.root.v1',
+  summary: 'Explicit bounded interpretation of another artifact or target without mutating the original.',
+  binding,
+  schemaSource,
+  artifactCreation: defineArtifactCreationCapability(binding, null),
+  capabilities: interpretationCapabilities,
+  validate: interpretationValidate,
+  present: interpretationPresent,
+  read: Object.freeze({ label: 'Interpretation', sections: INTERPRETATION_REQUIRED_SECTIONS }),
+  viewActions: Object.freeze({ lineage: Object.freeze(['record.open', 'record.markdown', 'record.source']) }),
+  transitions: interpretationTransitions,
+  localMaterialization: interpretationLocalMaterialization,
+  i18n: Object.freeze({ en: interpretationI18nEn, sv: interpretationI18nSv }),
+  findings: interpretationFindings
+});

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

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