@tiinex/app 0.1.1

package/src/transitions/canonicalTransition.packageContracts.js

@@ -0,0 +1,22 @@
+import rootMarkdown from './canonical-schema-cache/d69b8ff55a56b8cb9282b8684db6a938a4435b94/tiinex.root.v1.schema.md?raw';
+import transitionDefinitionMarkdown from './canonical-schema-cache/d69b8ff55a56b8cb9282b8684db6a938a4435b94/tiinex.transition.definition.v1.schema.md?raw';
+import semanticPackageMarkdown from './canonical-schema-cache/053d46ce082d4ec261b82abc44ecca403d61e240/tiinex.semantic.package.v1.schema.md?raw';
+import schemaTransitionCompanionMarkdown from './canonical-schema-cache/053d46ce082d4ec261b82abc44ecca403d61e240/tiinex.schema.transition.companion.v1.schema.md?raw';
+
+export const CANONICAL_TRANSITION_PACKAGE_CONTRACT_SOURCES = Object.freeze({
+  root: source('tiinex.root.v1', 'd69b8ff55a56b8cb9282b8684db6a938a4435b94', '.topics/.schemas/tiinex.root.v1.schema.md', '7078e4832872be0df0df4ee944ee1bcd1d886f12', '79843e23d6e4142d3c1c3281457ec18fcee8104297f4e6d98096c3b04809a28c'),
+  semanticPackage: source('tiinex.semantic.package.v1', '053d46ce082d4ec261b82abc44ecca403d61e240', '.topics/.schemas/package/semantic/tiinex.semantic.package.v1.schema.md', '5686051540603e05d483dc527af27b8e69ffee36', '5a457d9a7a4f6b9281819d2c1e1bc80e7d4f3ea15069285399fce4f7a28c1502'),
+  schemaTransitionCompanion: source('tiinex.schema.transition.companion.v1', '053d46ce082d4ec261b82abc44ecca403d61e240', '.topics/.schemas/schema/transition/companion/tiinex.schema.transition.companion.v1.schema.md', '1b45d674c3f8b553b9a26f2e9983d2ccf4197cca', 'f78dbf800c3080d6f0ab5832a31e793278ba723796996aae57a6a82a4a5c8f4a'),
+  transitionDefinition: source('tiinex.transition.definition.v1', 'd69b8ff55a56b8cb9282b8684db6a938a4435b94', '.topics/.schemas/transition/definition/tiinex.transition.definition.v1.schema.md', '548dac027abcc4fddf918e294a80b5aca1603c46', '4be6d46edcdaf48c2ea6bca6fb3c5760959ed61e6d3849bd13bb8bbb117c0ce5')
+});
+
+export const BUNDLED_CANONICAL_TRANSITION_PACKAGE_CONTRACTS = Object.freeze({
+  root: rootMarkdown,
+  semanticPackage: semanticPackageMarkdown,
+  schemaTransitionCompanion: schemaTransitionCompanionMarkdown,
+  transitionDefinition: transitionDefinitionMarkdown
+});
+
+function source(schemaId, commit, path, gitBlob, sha256) {
+  return Object.freeze({ schemaId, repository: 'Tiinex/docs', commit, path, gitBlob, sha256, sourceQualification: 'source-qualified-canonical-snapshot' });
+}

package/src/transitions/canonicalTransition.productDefaults.js

@@ -0,0 +1,105 @@
+import taskMarkdown from '../schemas/core/task/tiinex.task.v1.schema.md?raw';
+import topicMarkdown from '../schemas/core/topic/tiinex.topic.v1.schema.md?raw';
+import topicCanonicalMarkdown from './canonical-schema-cache/52ecdea0a75893882ce282214d155f70e1309c2a/tiinex.topic.v1.schema.md?raw';
+import taskPackageMarkdown from '../schemas/core/task/task-semantic-package.trace.md?raw';
+import taskCompanionMarkdown from '../schemas/core/task/tiinex.task.v1-transitions.trace.md?raw';
+import topicPackageMarkdown from '../schemas/core/topic/topic-semantic-package.trace.md?raw';
+import topicCompanionMarkdown from '../schemas/core/topic/tiinex.topic.v1-transitions.trace.md?raw';
+import topicToTaskMarkdown from '../schemas/core/task/.transitions/topic-to-task-transition-definition.trace.md?raw';
+import interpretationMarkdown from '../schemas/core/interpretation/tiinex.interpretation.v1.schema.md?raw';
+import evidenceToInterpretationMarkdown from '../schemas/core/interpretation/.transitions/evidence-to-interpretation-transition-definition.trace.md?raw';
+import createTopicMarkdown from '../schemas/core/topic/.transitions/create-topic-transition-definition.trace.md?raw';
+import createTaskMarkdown from '../schemas/core/task/.transitions/create-task-transition-definition.trace.md?raw';
+import relationMarkdown from './canonical-schema-cache/053d46ce082d4ec261b82abc44ecca403d61e240/tiinex.relation.v1.schema.md?raw';
+import schemaContractMarkdown from './canonical-schema-cache/053d46ce082d4ec261b82abc44ecca403d61e240/tiinex.schema.contract.v1.schema.md?raw';
+import schemaGenerationMarkdown from './canonical-schema-cache/053d46ce082d4ec261b82abc44ecca403d61e240/tiinex.schema.generation.v1.schema.md?raw';
+import topicReferencesTaskMarkdown from '../schemas/core/relation/.transitions/topic-references-task-transition-definition.trace.md?raw';
+import referenceRelationGenerationMarkdown from '../schemas/core/relation/.generation/reference-relation-generation-authority.trace.md?raw';
+import { CANONICAL_TRANSITION_SCHEMA_CACHE_COMMIT, CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST } from './canonicalTransition.schemaCache.js';
+import { compileCanonicalTransitionSemanticPackage } from './canonicalTransition.semanticPackage.js';
+import { BUNDLED_CANONICAL_TRANSITION_PACKAGE_CONTRACTS } from './canonicalTransition.packageContracts.js';
+
+const bySchema = Object.fromEntries(CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST.map((item) => [item.schemaId, item]));
+export const BUNDLED_CANONICAL_TRANSITION_SCHEMA_CACHE = Object.freeze([
+  cacheEntry('tiinex.root.v1', BUNDLED_CANONICAL_TRANSITION_PACKAGE_CONTRACTS.root),
+  cacheEntry('tiinex.transition.definition.v1', BUNDLED_CANONICAL_TRANSITION_PACKAGE_CONTRACTS.transitionDefinition),
+  cacheEntry('tiinex.task.v1', taskMarkdown),
+  cacheEntry('tiinex.topic.v1', topicCanonicalMarkdown),
+  cacheEntry('tiinex.interpretation.v1', interpretationMarkdown),
+  cacheEntry('tiinex.relation.v1', relationMarkdown),
+  cacheEntry('tiinex.schema.contract.v1', schemaContractMarkdown),
+  cacheEntry('tiinex.schema.generation.v1', schemaGenerationMarkdown)
+]);
+export const BUNDLED_CANONICAL_TRANSITION_SEMANTIC_PACKAGE = compileCanonicalTransitionSemanticPackage({
+  contracts: BUNDLED_CANONICAL_TRANSITION_PACKAGE_CONTRACTS,
+  materials: {
+    taskPackage: taskPackageMarkdown,
+    taskSchema: taskMarkdown,
+    taskCompanion: taskCompanionMarkdown,
+    transition: topicToTaskMarkdown,
+    topicPackage: topicPackageMarkdown,
+    topicSchema: topicMarkdown,
+    topicCompanion: topicCompanionMarkdown
+  }
+});
+const semanticPackageDefinitions = BUNDLED_CANONICAL_TRANSITION_SEMANTIC_PACKAGE.compilation.status === 'valid'
+  ? BUNDLED_CANONICAL_TRANSITION_SEMANTIC_PACKAGE.definitions
+  : Object.freeze([]);
+function siteLocalDefinition(id, title, path, markdown, extra = {}) {
+  return Object.freeze({
+    id: `bundled-transition:${id}`,
+    title,
+    path,
+    markdown,
+    schemaId: 'tiinex.transition.definition.v1',
+    sourceMode: 'bundled-canonical-transition-definition',
+    sourceQualification: 'site-local-definition-source-qualified',
+    source: Object.freeze({ id: `tiinex-site-local-transition:${id}`, adapterId: 'static', sourceKind: 'bundled-canonical', sourceMode: 'bundled-canonical-transition-definition', sourceArtifactPath: path }),
+    ...extra
+  });
+}
+const siteLocalUseAsDefinition = siteLocalDefinition(
+  'evidence-to-interpretation:v1',
+  'Evidence to Interpretation',
+  'src/schemas/core/interpretation/.transitions/evidence-to-interpretation-transition-definition.trace.md',
+  evidenceToInterpretationMarkdown
+);
+const siteLocalCreateTopicDefinition = siteLocalDefinition(
+  'create-topic:v1',
+  'Create standalone Topic',
+  'src/schemas/core/topic/.transitions/create-topic-transition-definition.trace.md',
+  createTopicMarkdown
+);
+const REFERENCE_GENERATION_REFERENCE = 'site-local:src/schemas/core/relation/.generation/reference-relation-generation-authority.trace.md';
+const siteLocalReferenceDefinition = siteLocalDefinition(
+  'topic-references-task:v1',
+  'Topic references Task',
+  'src/schemas/core/relation/.transitions/topic-references-task-transition-definition.trace.md',
+  topicReferencesTaskMarkdown,
+  Object.freeze({ generationMaterials: Object.freeze([Object.freeze({
+    id: 'tiinex-site-local-generation:topic-task-reference:v1',
+    path: 'src/schemas/core/relation/.generation/reference-relation-generation-authority.trace.md',
+    url: REFERENCE_GENERATION_REFERENCE,
+    reference: REFERENCE_GENERATION_REFERENCE,
+    markdown: referenceRelationGenerationMarkdown,
+    source: Object.freeze({ id: 'tiinex-site-local-generation:topic-task-reference:v1', adapterId: 'static', sourceKind: 'bundled-canonical', sourceMode: 'site-local-generation-authority', sourceArtifactPath: 'src/schemas/core/relation/.generation/reference-relation-generation-authority.trace.md' })
+  })]) })
+);
+const siteLocalCreateTaskDefinition = siteLocalDefinition(
+  'create-task:v1',
+  'Create standalone Task',
+  'src/schemas/core/task/.transitions/create-task-transition-definition.trace.md',
+  createTaskMarkdown
+);
+export const BUNDLED_CANONICAL_TRANSITION_DEFINITIONS = Object.freeze([
+  ...semanticPackageDefinitions,
+  siteLocalUseAsDefinition,
+  siteLocalReferenceDefinition,
+  siteLocalCreateTopicDefinition,
+  siteLocalCreateTaskDefinition
+]);
+
+function cacheEntry(schemaId, markdown) {
+  const expected = bySchema[schemaId];
+  return Object.freeze({ ...expected, markdown, sourceQualification: 'source-qualified-cache', cacheCommit: expected?.commit || CANONICAL_TRANSITION_SCHEMA_CACHE_COMMIT });
+}

package/src/transitions/canonicalTransition.schemaCache.case.mjs

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import {
+  CANONICAL_TRANSITION_SCHEMA_CACHE_COMMIT,
+  CANONICAL_TOPIC_SCHEMA_CACHE_COMMIT,
+  CANONICAL_REFERENCE_SCHEMA_CACHE_COMMIT,
+  CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST,
+  gitBlobSha1,
+  qualifyCanonicalTransitionSchemaCache
+} from './canonicalTransition.schemaCache.js';
+
+const fileBySchema = Object.freeze({
+  'tiinex.root.v1': new URL(`./canonical-schema-cache/${CANONICAL_TRANSITION_SCHEMA_CACHE_COMMIT}/tiinex.root.v1.schema.md`, import.meta.url),
+  'tiinex.transition.definition.v1': new URL(`./canonical-schema-cache/${CANONICAL_TRANSITION_SCHEMA_CACHE_COMMIT}/tiinex.transition.definition.v1.schema.md`, import.meta.url),
+  'tiinex.task.v1': new URL('../schemas/core/task/tiinex.task.v1.schema.md', import.meta.url),
+  'tiinex.topic.v1': new URL(`./canonical-schema-cache/${CANONICAL_TOPIC_SCHEMA_CACHE_COMMIT}/tiinex.topic.v1.schema.md`, import.meta.url),
+  'tiinex.interpretation.v1': new URL('../schemas/core/interpretation/tiinex.interpretation.v1.schema.md', import.meta.url),
+  'tiinex.relation.v1': new URL(`./canonical-schema-cache/${CANONICAL_REFERENCE_SCHEMA_CACHE_COMMIT}/tiinex.relation.v1.schema.md`, import.meta.url),
+  'tiinex.schema.contract.v1': new URL(`./canonical-schema-cache/${CANONICAL_REFERENCE_SCHEMA_CACHE_COMMIT}/tiinex.schema.contract.v1.schema.md`, import.meta.url),
+  'tiinex.schema.generation.v1': new URL(`./canonical-schema-cache/${CANONICAL_REFERENCE_SCHEMA_CACHE_COMMIT}/tiinex.schema.generation.v1.schema.md`, import.meta.url)
+});
+const entries = CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST.map((item) => {
+  const markdown = fs.readFileSync(fileBySchema[item.schemaId], 'utf8');
+  assert.equal(gitBlobSha1(markdown), item.gitBlob, `${item.schemaId} cached bytes must retain exact Git blob identity`);
+  return { ...item, markdown, sourceQualification: 'source-qualified-cache' };
+});
+assert.deepEqual(entries.map((item) => item.gitBlob), [
+  '7078e4832872be0df0df4ee944ee1bcd1d886f12',
+  '548dac027abcc4fddf918e294a80b5aca1603c46',
+  'e4d545ad45382a150351ead587339d8b43cc0fb2',
+  'c36472b0d20ad97d01cc1ca78a50fc69ce35fdae',
+  '330d8668e78cd6d164a76093982b02f616fd6ab4',
+  '46c476c6b24f448f462c9f67e56cb1a40751ee14',
+  '02d42cee2e797c770f9e5596da9afdf8368c7c9c',
+  '46d803c0e17371121fa094add7be8f6459b6becb'
+]);
+const exact = qualifyCanonicalTransitionSchemaCache(entries);
+assert.equal(exact.status, 'qualified');
+assert.equal(exact.sourceQualified, true);
+assert.equal(exact.entries.length, 8);
+const stale = entries.map((item, index) => index === 2 ? { ...item, markdown: `${item.markdown}\n` } : item);
+const rejected = qualifyCanonicalTransitionSchemaCache(stale);
+assert.equal(rejected.sourceQualified, false);
+assert.ok(rejected.findings.some((finding) => finding.code === 'schema-cache-source-identity-mismatch' && finding.schemaId === 'tiinex.task.v1'));
+console.log('canonical Transition product schema-cache source identity: PASS');

package/src/transitions/canonicalTransition.schemaCache.js

@@ -0,0 +1,81 @@
+export const CANONICAL_TRANSITION_SCHEMA_CACHE_COMMIT = 'd69b8ff55a56b8cb9282b8684db6a938a4435b94';
+export const CANONICAL_INTERPRETATION_SCHEMA_CACHE_COMMIT = '053d46ce082d4ec261b82abc44ecca403d61e240';
+export const CANONICAL_REFERENCE_SCHEMA_CACHE_COMMIT = CANONICAL_INTERPRETATION_SCHEMA_CACHE_COMMIT;
+export const CANONICAL_TOPIC_SCHEMA_CACHE_COMMIT = '52ecdea0a75893882ce282214d155f70e1309c2a';
+export const CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST = Object.freeze([
+  Object.freeze({ schemaId: 'tiinex.root.v1', repository: 'Tiinex/docs', commit: CANONICAL_TRANSITION_SCHEMA_CACHE_COMMIT, path: '.topics/.schemas/tiinex.root.v1.schema.md', gitBlob: '7078e4832872be0df0df4ee944ee1bcd1d886f12' }),
+  Object.freeze({ schemaId: 'tiinex.transition.definition.v1', repository: 'Tiinex/docs', commit: CANONICAL_TRANSITION_SCHEMA_CACHE_COMMIT, path: '.topics/.schemas/transition/definition/tiinex.transition.definition.v1.schema.md', gitBlob: '548dac027abcc4fddf918e294a80b5aca1603c46' }),
+  Object.freeze({ schemaId: 'tiinex.task.v1', repository: 'Tiinex/docs', commit: CANONICAL_TRANSITION_SCHEMA_CACHE_COMMIT, path: '.topics/.schemas/core/task/tiinex.task.v1.schema.md', gitBlob: 'e4d545ad45382a150351ead587339d8b43cc0fb2' }),
+  Object.freeze({ schemaId: 'tiinex.topic.v1', repository: 'Tiinex/docs', commit: CANONICAL_TOPIC_SCHEMA_CACHE_COMMIT, path: '.topics/.schemas/core/topic/tiinex.topic.v1.schema.md', gitBlob: 'c36472b0d20ad97d01cc1ca78a50fc69ce35fdae' }),
+  Object.freeze({ schemaId: 'tiinex.interpretation.v1', repository: 'Tiinex/docs', commit: CANONICAL_INTERPRETATION_SCHEMA_CACHE_COMMIT, path: '.topics/.schemas/core/interpretation/tiinex.interpretation.v1.schema.md', gitBlob: '330d8668e78cd6d164a76093982b02f616fd6ab4' }),
+  Object.freeze({ schemaId: 'tiinex.relation.v1', repository: 'Tiinex/docs', commit: CANONICAL_REFERENCE_SCHEMA_CACHE_COMMIT, path: '.topics/.schemas/relation/tiinex.relation.v1.schema.md', gitBlob: '46c476c6b24f448f462c9f67e56cb1a40751ee14' }),
+  Object.freeze({ schemaId: 'tiinex.schema.contract.v1', repository: 'Tiinex/docs', commit: CANONICAL_REFERENCE_SCHEMA_CACHE_COMMIT, path: '.topics/.schemas/schema/contract/tiinex.schema.contract.v1.schema.md', gitBlob: '02d42cee2e797c770f9e5596da9afdf8368c7c9c' }),
+  Object.freeze({ schemaId: 'tiinex.schema.generation.v1', repository: 'Tiinex/docs', commit: CANONICAL_REFERENCE_SCHEMA_CACHE_COMMIT, path: '.topics/.schemas/schema/contract/generation/tiinex.schema.generation.v1.schema.md', gitBlob: '46d803c0e17371121fa094add7be8f6459b6becb' })
+]);
+
+export function qualifyCanonicalTransitionSchemaCache(entries = []) {
+  return qualifyCanonicalTransitionSchemaCacheSubset(entries, CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST.map((item) => item.schemaId));
+}
+
+export function qualifyCanonicalTransitionSchemaCacheSubset(entries = [], requiredSchemaIds = []) {
+  const requested = new Set((Array.isArray(requiredSchemaIds) ? requiredSchemaIds : []).map((value) => String(value || '').trim()).filter(Boolean));
+  const expectedEntries = CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST.filter((item) => requested.has(item.schemaId));
+  const findings = [], qualified = [];
+  for (const expected of expectedEntries) {
+    const matches = (Array.isArray(entries) ? entries : []).filter((item) => String(item?.schemaId || '') === expected.schemaId);
+    if (matches.length !== 1) {
+      findings.push(Object.freeze({ code: matches.length ? 'schema-cache-entry-duplicate' : 'schema-cache-entry-missing', schemaId: expected.schemaId }));
+      continue;
+    }
+    const item = matches[0], markdown = String(item.markdown ?? item.content ?? '');
+    const actualBlob = gitBlobSha1(markdown);
+    if (String(item.repository || '') !== expected.repository || String(item.commit || '') !== expected.commit || String(item.path || '') !== expected.path || actualBlob !== expected.gitBlob) {
+      findings.push(Object.freeze({ code: 'schema-cache-source-identity-mismatch', schemaId: expected.schemaId, expectedBlob: expected.gitBlob, actualBlob }));
+      continue;
+    }
+    qualified.push(Object.freeze({ ...expected, markdown, sourceQualification: 'source-qualified' }));
+  }
+  const complete = findings.length === 0 && qualified.length === expectedEntries.length && expectedEntries.length === requested.size;
+  if (expectedEntries.length !== requested.size) {
+    for (const schemaId of requested) if (!CANONICAL_TRANSITION_SCHEMA_CACHE_MANIFEST.some((item) => item.schemaId === schemaId)) findings.push(Object.freeze({ code: 'schema-cache-schema-unregistered', schemaId }));
+  }
+  return Object.freeze({
+    status: complete ? 'qualified' : 'unqualified',
+    sourceQualified: complete,
+    entries: Object.freeze(qualified),
+    findings: Object.freeze(findings)
+  });
+}
+
+export function gitBlobSha1(text = '') {
+  const content = utf8Bytes(String(text));
+  const header = utf8Bytes(`blob ${content.length}\0`);
+  const bytes = new Uint8Array(header.length + content.length);
+  bytes.set(header); bytes.set(content, header.length);
+  return sha1Hex(bytes);
+}
+
+function utf8Bytes(text) {
+  if (typeof TextEncoder !== 'undefined') return new TextEncoder().encode(text);
+  const encoded = unescape(encodeURIComponent(text));
+  return Uint8Array.from(encoded, (char) => char.charCodeAt(0));
+}
+function sha1Hex(input) {
+  const bitLength = input.length * 8, padLength = ((56 - (input.length + 1) % 64) + 64) % 64;
+  const data = new Uint8Array(input.length + 1 + padLength + 8); data.set(input); data[input.length] = 0x80;
+  const view = new DataView(data.buffer); view.setUint32(data.length - 4, bitLength >>> 0, false); view.setUint32(data.length - 8, Math.floor(bitLength / 0x100000000), false);
+  let h0=0x67452301,h1=0xefcdab89,h2=0x98badcfe,h3=0x10325476,h4=0xc3d2e1f0;
+  const w = new Uint32Array(80), rol=(n,b)=>((n<<b)|(n>>>(32-b)))>>>0;
+  for (let offset=0; offset<data.length; offset+=64) {
+    for (let i=0;i<16;i++) w[i]=view.getUint32(offset+i*4,false);
+    for (let i=16;i<80;i++) w[i]=rol(w[i-3]^w[i-8]^w[i-14]^w[i-16],1);
+    let a=h0,b=h1,c=h2,d=h3,e=h4;
+    for (let i=0;i<80;i++) {
+      const f=i<20?(b&c)|((~b)&d):i<40?b^c^d:i<60?(b&c)|(b&d)|(c&d):b^c^d;
+      const k=i<20?0x5a827999:i<40?0x6ed9eba1:i<60?0x8f1bbcdc:0xca62c1d6;
+      const t=(rol(a,5)+f+e+k+w[i])>>>0; e=d; d=c; c=rol(b,30); b=a; a=t;
+    }
+    h0=(h0+a)>>>0; h1=(h1+b)>>>0; h2=(h2+c)>>>0; h3=(h3+d)>>>0; h4=(h4+e)>>>0;
+  }
+  return [h0,h1,h2,h3,h4].map((n)=>n.toString(16).padStart(8,'0')).join('');
+}

package/src/transitions/canonicalTransition.semanticPackage.js

@@ -0,0 +1,146 @@
+import { compilePortableSchemaContractChain } from '@tiinex/core/tooling/portable/schema/contract.compile.js';
+import { compilePortableSemanticPackage } from '@tiinex/core/tooling/portable/package/semantic.package.js';
+
+export const CANONICAL_TRANSITION_TASK_PACKAGE_KEY = 'site-package:task';
+export const CANONICAL_TRANSITION_TOPIC_PACKAGE_KEY = 'site-package:topic';
+export const CANONICAL_TOPIC_TO_TASK_REPRESENTATION_KEY = 'site-transition:topic-to-task:v1';
+export const CANONICAL_TOPIC_TO_TASK_BUNDLED_SOURCE_ID = 'tiinex-site-semantic-package:site-transition:topic-to-task:v1';
+const SITE_SEMANTIC_PACKAGE_SOURCE_ID = 'tiinex-site-semantic-package';
+export const CANONICAL_TOPIC_TO_TASK_BUNDLED_SOURCE_MODE = 'bundled-canonical-transition-definition';
+
+const SITE_LOCAL = 'site-local:';
+const paths = Object.freeze({
+  taskPackage: 'src/schemas/core/task/task-semantic-package.trace.md',
+  taskSchema: 'src/schemas/core/task/tiinex.task.v1.schema.md',
+  taskCompanion: 'src/schemas/core/task/tiinex.task.v1-transitions.trace.md',
+  transition: 'src/schemas/core/task/.transitions/topic-to-task-transition-definition.trace.md',
+  topicPackage: 'src/schemas/core/topic/topic-semantic-package.trace.md',
+  topicSchema: 'src/schemas/core/topic/tiinex.topic.v1.schema.md',
+  topicCompanion: 'src/schemas/core/topic/tiinex.topic.v1-transitions.trace.md'
+});
+
+export const CANONICAL_TRANSITION_SEMANTIC_PACKAGE_PATHS = paths;
+
+export function compileCanonicalTransitionSemanticPackage(input = {}) {
+  const contracts = compileContracts(input.contracts || {});
+  const materials = canonicalPackageMaterials(input.materials || {});
+  const compilation = compilePortableSemanticPackage({
+    selectedManifest: CANONICAL_TRANSITION_TASK_PACKAGE_KEY,
+    materials,
+    contracts,
+    resolvers: input.resolvers || buildPackageSchemaResolvers(input.contracts?.root, input.materials || {})
+  });
+  const byKey = new Map(materials.map((material) => [material.id, material]));
+  const definitions = (compilation.transitionRegistry || [])
+    .filter((entry) => entry.representationQualification === 'valid')
+    .map((entry) => definitionFromCompiledEntry(entry, byKey.get(entry.representationKey)))
+    .filter(Boolean);
+  return Object.freeze({
+    compilation,
+    definitions: Object.freeze(definitions),
+    materials: Object.freeze(materials.map((material) => Object.freeze({
+      representationKey: material.id,
+      path: material.path,
+      reference: material.reference || '',
+      source: material.source
+    })))
+  });
+}
+
+function buildPackageSchemaResolvers(rootMarkdown = '', materials = {}) {
+  const schemaAuthorities = {};
+  for (const markdown of [materials.topicSchema, materials.taskSchema]) {
+    const compiled = compilePortableSchemaContractChain([String(rootMarkdown || ''), String(markdown || '')]);
+    if (compiled.lineageQualification?.state !== 'valid' || compiled.lineageQualification?.complete !== true || !compiled.schemaId) continue;
+    const generation = (compiled.creation?.groups || []).length > 0;
+    const fileNaming = (compiled.validation?.groups || []).some((group) => group.name === 'File Naming');
+    schemaAuthorities[compiled.schemaId] = Object.freeze({ targetKind: 'artifact', generation, fileNaming, sourceQualification: 'compiled-package-schema-authority' });
+  }
+  return Object.freeze({ schemaAuthorities: Object.freeze(schemaAuthorities) });
+}
+
+function compileContracts(input = {}) {
+  const root = String(input.root || '');
+  return Object.freeze({
+    semanticPackage: compilePortableSchemaContractChain([root, String(input.semanticPackage || '')]),
+    schemaTransitionCompanion: compilePortableSchemaContractChain([root, String(input.schemaTransitionCompanion || '')]),
+    transitionDefinition: compilePortableSchemaContractChain([root, String(input.transitionDefinition || '')])
+  });
+}
+
+function canonicalPackageMaterials(input = {}) {
+  return [
+    material(CANONICAL_TRANSITION_TASK_PACKAGE_KEY, paths.taskPackage, input.taskPackage, paths.taskPackage),
+    material('site-schema:task', paths.taskSchema, input.taskSchema, paths.taskSchema, sourceIdentity('tiinex.task.v1')),
+    material('site-companion:task', paths.taskCompanion, input.taskCompanion),
+    material(CANONICAL_TOPIC_TO_TASK_REPRESENTATION_KEY, paths.transition, input.transition, paths.transition, transitionSource()),
+    material(CANONICAL_TRANSITION_TOPIC_PACKAGE_KEY, paths.topicPackage, input.topicPackage, paths.topicPackage),
+    material('site-schema:topic', paths.topicSchema, input.topicSchema, paths.topicSchema),
+    material('site-companion:topic', paths.topicCompanion, input.topicCompanion)
+  ];
+}
+
+function material(id, path, markdown, aliasPath = '', source = null) {
+  const actualSource = source || Object.freeze({
+    id: SITE_SEMANTIC_PACKAGE_SOURCE_ID,
+    adapterId: 'static',
+    sourceKind: 'bundled-canonical',
+    sourceMode: 'semantic-package-locality'
+  });
+  return Object.freeze({
+    id,
+    path,
+    markdown: String(markdown || ''),
+    reference: aliasPath ? `${SITE_LOCAL}${aliasPath}` : '',
+    source: actualSource
+  });
+}
+
+function sourceIdentity(schemaId) {
+  return Object.freeze({
+    id: SITE_SEMANTIC_PACKAGE_SOURCE_ID,
+    adapterId: 'static',
+    sourceKind: 'bundled-canonical',
+    sourceMode: 'semantic-package-locality',
+    schemaId,
+    repository: 'Tiinex/docs',
+    commit: 'd69b8ff55a56b8cb9282b8684db6a938a4435b94',
+    sourceArtifactPath: '.topics/.schemas/core/task/tiinex.task.v1.schema.md',
+    gitBlob: 'e4d545ad45382a150351ead587339d8b43cc0fb2'
+  });
+}
+
+function transitionSource() {
+  return Object.freeze({
+    id: CANONICAL_TOPIC_TO_TASK_BUNDLED_SOURCE_ID,
+    adapterId: 'static',
+    sourceKind: 'bundled-canonical',
+    sourceMode: CANONICAL_TOPIC_TO_TASK_BUNDLED_SOURCE_MODE,
+    semanticPackageRepresentationKey: CANONICAL_TOPIC_TO_TASK_REPRESENTATION_KEY,
+    semanticPackageManifestKey: CANONICAL_TRANSITION_TASK_PACKAGE_KEY
+  });
+}
+
+function definitionFromCompiledEntry(entry = {}, material = null) {
+  if (!material) return null;
+  const source = Object.freeze({
+    ...(material.source || {}),
+    sourceArtifactPath: entry.path,
+    semanticPackageRepresentationKey: entry.representationKey,
+    semanticPackageManifestKey: CANONICAL_TRANSITION_TASK_PACKAGE_KEY,
+    packageDiscoveryProvenance: Object.freeze([...(entry.discoveryProvenance || [])]),
+    packageAttachmentProvenance: Object.freeze([...(entry.attachmentProvenance || [])])
+  });
+  return Object.freeze({
+    id: `bundled-transition:${entry.representationKey}`,
+    title: String(entry.transitionIdentity?.Name || material.title || 'Transition'),
+    path: entry.path,
+    markdown: material.markdown,
+    schemaId: 'tiinex.transition.definition.v1',
+    sourceMode: CANONICAL_TOPIC_TO_TASK_BUNDLED_SOURCE_MODE,
+    sourceQualification: 'compiled-semantic-package-qualified',
+    semanticPackageRepresentationKey: entry.representationKey,
+    semanticPackageManifestKey: CANONICAL_TRANSITION_TASK_PACKAGE_KEY,
+    source
+  });
+}

package/src/transitions/record.transitions.case.mjs

@@ -0,0 +1,88 @@
+import assert from 'node:assert/strict';
+import { schemaRegistry } from '@tiinex/core/schemas/registry.js';
+import { parseArtifactMarkdown } from '@tiinex/core/artifacts/artifact.parse.js';
+import { rootValidate } from '@tiinex/core/schemas/tiinex.root.v1.validate.js';
+import { resolveLineage } from '@tiinex/core/lineage/lineage.resolve.js';
+import { createContinuationDraft, createReferenceDraft, ensureUniqueTransitionPath, listContinuationTargets, RECORD_TRANSITION_RESULT_SCHEMA_ID } from '@tiinex/core/transitions/record.transitions.js';
+
+const targets = listContinuationTargets(schemaRegistry);
+assert(targets.some((target) => target.id === 'tiinex.task.v1'), 'task continuation target must be exposed');
+assert(targets.every((target) => target.id === 'tiinex.task.v1'), 'only schema-honest Task continuation is exposed until other renderers land');
+assert(targets.every((target) => target.contract === 'tiinex.record.transitions.v1'), 'targets must declare transition contract');
+
+const parent = {
+  id: 'local:ws:notes/example.md',
+  title: 'Example artifact',
+  summary: 'Example summary',
+  path: 'notes/example.md',
+  markdown: '# Example artifact\n\nMaterial body',
+  kind: 'tiinex.topic.v1',
+  schemaId: 'tiinex.topic.v1',
+  createdAt: '2026-07-20',
+  source: { adapterId: 'local', kind: 'local-session' },
+  sourceMode: 'local-files'
+};
+
+const continuation = createContinuationDraft(parent, targets.find((target) => target.id === 'tiinex.task.v1'), {}, { clock: () => '2026-07-21T00:00:00.000Z' });
+assert.equal(continuation.schema, RECORD_TRANSITION_RESULT_SCHEMA_ID, 'continuation draft must declare result schema');
+assert.equal(continuation.kind, 'tiinex.task.v1', 'continuation draft must target selected schema');
+assert.equal(continuation.status, 'local', 'continuation must remain local/session');
+assert.equal(continuation.hasContinuityContext, true, 'continuation must claim continuity context');
+assert.equal(continuation.hasIntegrity, true, 'continuation must include draft integrity marker');
+assert.equal(continuation.validation.ok, true, 'continuation must pass transition validation');
+assert(continuation.markdown.includes('Envelope Schema: [tiinex.root.v1]'), 'continuation markdown must include Envelope Schema');
+assert(continuation.markdown.includes('Parent Schema: [tiinex.topic.v1]'), 'continuation markdown must include Parent Schema');
+assert(continuation.markdown.includes('Trace: record:local:ws:notes/example.md'), 'continuation markdown must include parent trace');
+assert(continuation.markdown.includes('Current Schema: [tiinex.task.v1]'), 'continuation markdown must include target schema');
+assert.equal(continuation.path, 'notes/example-artifact--task.trace.md', 'continuation path defaults to parent directory with trace suffix');
+assert.equal(continuation.schemaId, 'tiinex.task.v1', 'continuation record metadata exposes current schema for runtime readmodels');
+assert.equal(continuation.parentSchemaId, 'tiinex.topic.v1', 'continuation record metadata exposes parent schema for runtime readmodels');
+assert.equal(continuation.trace, 'record:local:ws:notes/example.md', 'continuation record metadata exposes parent trace for loaded lineage');
+assert.equal(continuation.origin, 'notes/example.md', 'continuation record metadata exposes parent origin for diagnostics');
+const localLineage = resolveLineage([parent, continuation]);
+assert(localLineage.edges.some((edge) => edge.from === parent.id && edge.to === continuation.path && edge.kind === 'parent'), 'fresh local continuation should resolve to its loaded parent without reparsing during render');
+
+const siblingContinuation = createContinuationDraft(parent, targets.find((target) => target.id === 'tiinex.task.v1'), {}, { clock: () => '2026-07-21T00:01:00.000Z', existingRecords: [continuation] });
+assert.notEqual(siblingContinuation.path, continuation.path, 'repeated continuations from same parent must not reuse the same local path');
+assert.equal(siblingContinuation.path, 'notes/example-artifact--task-2.trace.md', 'second continuation uses a deterministic sibling suffix in the parent directory');
+const defensiveContinuation = ensureUniqueTransitionPath(continuation, [continuation]);
+assert.equal(defensiveContinuation.path, 'notes/example-artifact--task-2.trace.md', 'final add path guard prevents lifecycle overwrite when dialogs race');
+
+const numberedParent = Object.assign({}, parent, { id: 'numbered', path: '.topics/ai-provenance/12-01-gpt-5-mini.trace.md', title: 'GPT 5 mini' });
+const numberedContinuation = createContinuationDraft(numberedParent, targets.find((target) => target.id === 'tiinex.task.v1'), { title: 'Model follow-up' }, { existingRecords: [], clock: () => '2026-07-21T00:02:00.000Z' });
+assert.equal(numberedContinuation.path, '.topics/ai-provenance/12-01-01-model-follow-up.trace.md', 'dimensioned parents allocate child prefix in same folder');
+const numberedSibling = createContinuationDraft(numberedParent, targets.find((target) => target.id === 'tiinex.task.v1'), { title: 'Model follow-up' }, { existingRecords: [numberedContinuation], clock: () => '2026-07-21T00:03:00.000Z' });
+assert.equal(numberedSibling.path, '.topics/ai-provenance/12-01-02-model-follow-up.trace.md', 'dimensioned siblings increment the lineage child segment');
+const issueCommentParent = Object.assign({}, parent, { id: 'issue-comment-parent', path: '.topics/.github/tiinusen/socials/.issues/3/comment-001-5008615398-recovered-lagar-och-regler.trace.md', title: 'Lagar och regler' });
+const issueDraft = createContinuationDraft(issueCommentParent, targets.find((target) => target.id === 'tiinex.task.v1'), { title: 'Lagar och regler continuation' }, { existingRecords: [issueCommentParent], clock: () => '2026-07-21T00:04:00.000Z' });
+assert.equal(issueDraft.path, '.topics/.github/tiinusen/socials/.issues/3/001-1-lagar-och-regler-continuation.trace.md', 'recovered issue-comment parents still allocate canonical dimension-prefixed child paths');
+const issueSiblingDraft = createContinuationDraft(issueCommentParent, targets.find((target) => target.id === 'tiinex.task.v1'), { title: 'Lagar och regler continuation' }, { existingRecords: [issueCommentParent, issueDraft], clock: () => '2026-07-21T00:05:00.000Z' });
+assert.equal(issueSiblingDraft.path, '.topics/.github/tiinusen/socials/.issues/3/001-2-lagar-och-regler-continuation.trace.md', 'recovered issue-comment parent siblings increment canonical dimension child segment');
+assert.equal(issueDraft.trace, 'record:issue-comment-parent', 'issue draft exposes parent trace on the record metadata');
+const issueLineage = resolveLineage([issueCommentParent, issueDraft]);
+assert(issueLineage.edges.some((edge) => edge.from === issueCommentParent.id && edge.to === issueDraft.path && edge.kind === 'parent'), 'issue-adjacent local continuation should resolve to its loaded parent');
+
+
+const parsedContinuation = parseArtifactMarkdown(continuation.markdown);
+assert.equal(parsedContinuation.envelope.envelopeSchema.id, 'tiinex.root.v1', 'parsed continuation has envelope schema');
+assert.equal(parsedContinuation.envelope.current.schema.id, 'tiinex.task.v1', 'parsed continuation has current schema');
+assert.equal(parsedContinuation.envelope.current.createdAt, '2026-07-21T00:00:00.000Z', 'parsed continuation has created at');
+assert.equal(parsedContinuation.envelope.parent.schema.id, 'tiinex.topic.v1', 'parsed continuation has parent schema');
+assert.equal(parsedContinuation.hasIntegrity, true, 'parsed continuation has integrity marker');
+assert(!rootValidate(parsedContinuation).some((finding) => finding.severity === 'error'), 'continuation draft must satisfy root-required envelope fields');
+
+const reference = createReferenceDraft(parent, {}, { clock: () => '2026-07-21T00:00:00.000Z' });
+assert.equal(reference.kind, 'tiinex.evidence.v1', 'reference draft should materialize as evidence');
+assert.equal(reference.hasIntegrity, true, 'reference must include draft integrity marker');
+assert.equal(reference.validation.ok, true, 'reference must pass transition validation');
+assert(reference.markdown.includes('## Reference'), 'reference draft must contain reference section');
+assert(reference.markdown.includes('## Supported Claim Or Question'), 'reference draft must satisfy Evidence body contract');
+assert.equal(reference.creationValidation.ok, false, 'legacy Site reference draft must not be upgraded to exact canonical creation under v475');
+assert(reference.creationValidation.findings.some((finding) => finding.code.startsWith('creation.continuation-representation.')), 'exact creation validation must expose canonical Parent/footer representation drift');
+assert(reference.markdown.includes('Current Schema: [tiinex.evidence.v1]'), 'reference draft must declare evidence current schema');
+assert(reference.path.startsWith('references/'), 'reference path must be deterministic local reference path');
+const parsedReference = parseArtifactMarkdown(reference.markdown);
+assert.equal(parsedReference.envelope.current.schema.id, 'tiinex.evidence.v1', 'parsed reference has evidence schema');
+assert(!rootValidate(parsedReference).some((finding) => finding.severity === 'error'), 'reference draft must satisfy root-required envelope fields');
+
+console.log('✓ record.transitions tests passed');

package/src/transitions/transition.authorityRepresentation.js

@@ -0,0 +1,55 @@
+import { C14N_V2_METHOD_ID, canonicalC14nV2SelfState } from '@tiinex/core/integrity/integrity.c14nV2.js';
+
+export const EXACT_AUTHORITY_REPRESENTATION_SCHEMA_ID = 'tiinex.site.exact-authority-representation.v1';
+const freeze = Object.freeze;
+
+export function qualifyExactAuthorityRepresentation(input = {}) {
+  const reference = token(input.reference) || (token(input.path) ? `site-local:${token(input.path)}` : '');
+  const path = token(input.path);
+  const markdown = String(input.markdown || '');
+  if (!reference || !path || !markdown) return unavailable(reference, path, 'authority-representation-input-missing');
+  const integrity = canonicalC14nV2SelfState(markdown);
+  if (integrity.state !== 'verified' || integrity.method !== C14N_V2_METHOD_ID || !token(integrity.declaredValue)) {
+    return unavailable(reference, path, `authority-representation-integrity-${integrity.state || 'unavailable'}`, integrity);
+  }
+  return freeze({
+    schema: EXACT_AUTHORITY_REPRESENTATION_SCHEMA_ID,
+    state: 'qualified',
+    reason: '',
+    reference,
+    path,
+    method: integrity.method,
+    value: integrity.declaredValue,
+    integrity: freeze({ state: integrity.state, method: integrity.method, towards: integrity.towards, declaredValue: integrity.declaredValue, computedValue: integrity.computedValue }),
+    readOnly: true
+  });
+}
+
+export function verifyExactAuthorityRepresentation(expected = {}, material = {}) {
+  const actual = qualifyExactAuthorityRepresentation(material);
+  const match = actual.state === 'qualified'
+    && token(expected.reference) === actual.reference
+    && token(expected.method) === actual.method
+    && token(expected.value) === actual.value;
+  return freeze({
+    state: match ? 'qualified' : 'mismatch',
+    reason: match ? '' : actual.state !== 'qualified' ? actual.reason : 'authority-representation-identity-mismatch',
+    expected: freeze({ reference: token(expected.reference), method: token(expected.method), value: token(expected.value) }),
+    actual
+  });
+}
+
+function unavailable(reference = '', path = '', reason = '', integrity = null) {
+  return freeze({
+    schema: EXACT_AUTHORITY_REPRESENTATION_SCHEMA_ID,
+    state: 'unavailable',
+    reason,
+    reference,
+    path,
+    method: token(integrity?.method),
+    value: token(integrity?.declaredValue),
+    integrity: integrity ? freeze({ state: integrity.state || '', method: integrity.method || '', towards: integrity.towards || '', declaredValue: integrity.declaredValue || '', computedValue: integrity.computedValue || '' }) : null,
+    readOnly: true
+  });
+}
+function token(value = '') { return String(value || '').trim(); }