@tiinex/app 0.1.1

package/src/transitions/transition.resultSemantics.js

@@ -0,0 +1,453 @@
+import { TRANSITION_DEFINITION_READ_MODEL_SCHEMA_ID } from './transition.definitionRegistry.js';
+import { CANONICAL_TRANSITION_DEFINITION_SCHEMA_ID } from './transition.legacyShorthand.js';
+import {
+  roleParticipantClassification,
+  participantClassificationUsable,
+  schemaRestrictionUnresolved
+} from './transition.availabilitySemantics.js';
+
+export const TRANSITION_RESULT_SEMANTICS_PLAN_SCHEMA_ID = 'tiinex.site.transition-result-semantics-plan.v1';
+
+export function buildCanonicalTransitionResultPlan({ definition } = {}) {
+  if (!isCanonicalDefinitionReadModel(definition)) return blockedPlan(definition, 'definition-not-canonical-read-model');
+  if (definition.canonicalReadQualified !== true) return blockedPlan(definition, 'canonical-read-not-qualified');
+
+  const inputRoles = activeDeclarations(definition.inputRoles);
+  const outputRoleDeclarations = activeDeclarations(definition.outputRoles);
+  const destinations = activeDeclarations(definition.destinationBindings);
+  const roleNames = new Set([...inputRoles, ...outputRoleDeclarations].map((item) => String(item.name || '')));
+  const outputNames = new Set(outputRoleDeclarations.map((item) => String(item.name || '')));
+  const destinationNames = new Set(destinations.map((item) => String(item.name || '')));
+
+  const projectedOutputRoles = outputRoleDeclarations.map(projectOutputRole);
+  const lifecycleEffects = activeDeclarations(definition.lifecycleEffects).map((effect) => projectLifecycleEffect(effect, roleNames));
+  const parentEffects = activeDeclarations(definition.parentEffects).map((effect) => projectParentEffect(effect, roleNames, outputNames));
+  const relationEffects = activeDeclarations(definition.relationEffects).map((effect) => projectRelationEffect(effect, roleNames));
+  const outputPlacements = activeDeclarations(definition.outputPlacements).map((placement) => projectOutputPlacement(placement, roleNames, outputNames, destinationNames));
+  const outputRoles = projectedOutputRoles.map((role) => withLifecycleCoverage(role, lifecycleEffects));
+  const destinationBindings = destinations
+    .map(projectDestinationBinding)
+    .map((binding) => withDestinationPlacementCoverage(binding, outputPlacements));
+  const authoringGuidance = projectAuthoringGuidance(definition);
+
+  const unresolvedReasons = collectUnresolvedReasons({
+    outputRoles,
+    destinationBindings,
+    lifecycleEffects,
+    parentEffects,
+    relationEffects,
+    outputPlacements
+  });
+
+  return Object.freeze({
+    schema: TRANSITION_RESULT_SEMANTICS_PLAN_SCHEMA_ID,
+    definition: definitionIdentity(definition),
+    readOnly: true,
+    mutation: false,
+    networkFetch: false,
+    executable: false,
+    qualification: unresolvedReasons.length ? 'unresolved' : 'qualified',
+    reasons: Object.freeze(unresolvedReasons),
+    outputRoles: Object.freeze(outputRoles),
+    lifecycleEffects: Object.freeze(lifecycleEffects),
+    parentEffects: Object.freeze(parentEffects),
+    relationEffects: Object.freeze(relationEffects),
+    destinationBindings: Object.freeze(destinationBindings),
+    outputPlacements: Object.freeze(outputPlacements),
+    authoringGuidance,
+    boundary: Object.freeze({
+      participantBinding: false,
+      conditionEvaluation: false,
+      concreteMemberMapping: false,
+      generationResolution: false,
+      pathResolution: false,
+      materialization: false,
+      parentMutation: false,
+      relationMaterialization: false,
+      execution: false
+    })
+  });
+}
+
+function projectOutputRole(role = {}) {
+  const fields = role.fields || {};
+  const participantClassification = roleParticipantClassification(role);
+  const schemaConstraint = schemaToken(fields['Schema Constraint']);
+  const generationBinding = token(fields['Generation Binding']);
+  const classificationResolved = participantClassificationUsable(participantClassification);
+  const schemaRestrictionQualification = participantClassification.schemaConstraint?.qualification || (schemaConstraint ? 'unresolved' : 'absent');
+  const generation = generationBinding === 'target-schema'
+    ? Object.freeze({ declared: generationBinding, authority: 'target-schema', qualification: 'not-evaluated', executable: false })
+    : generationBinding
+      ? Object.freeze({ declared: generationBinding, authority: 'explicit-reference', qualification: 'not-evaluated', executable: false })
+      : Object.freeze({ declared: '', authority: 'none-prescribed', qualification: 'absent', executable: false });
+  return Object.freeze({
+    name: String(role.name || ''),
+    meaning: token(fields.Meaning),
+    minimumCount: cardinality(fields['Minimum Count'], false),
+    maximumCount: cardinality(fields['Maximum Count'], true),
+    targetKind: participantClassification.declared,
+    effectiveParticipantKind: classificationResolved ? participantClassification.resolved : '',
+    participantClassification,
+    schemaConstraint,
+    schemaConstraintQualification: schemaRestrictionQualification,
+    generationBinding,
+    generation,
+    selectionNotes: token(fields['Selection Notes']),
+    qualification: !classificationResolved || schemaRestrictionUnresolved(schemaConstraint, schemaRestrictionQualification)
+      ? 'unresolved'
+      : 'qualified',
+    executable: false
+  });
+}
+
+function projectLifecycleEffect(effect = {}, roleNames) {
+  const fields = effect.fields || {};
+  const targetBinding = bindingReference(fields['Target Binding'], roleNames, 'participant-role', true);
+  const resultBinding = bindingReference(fields['Result Binding'], roleNames, 'participant-role', false);
+  const effectLabel = token(fields.Effect);
+  const logicalContinuity = token(fields['Logical Continuity']);
+  const effectMeaning = token(fields['Effect Meaning']);
+  const preserveWhy = token(fields['Preserve Why']);
+  const mapping = memberMapping(fields);
+  const participation = effectParticipation(fields);
+  const reasons = [];
+  if (participation.state === 'unresolved') reasons.push('condition-unresolved');
+  if (targetBinding.qualification === 'unresolved') reasons.push('target-binding-unresolved');
+  if (resultBinding.qualification === 'unresolved') reasons.push('result-binding-unresolved');
+  if (effectLabel === 'unknown') reasons.push('effect-unresolved');
+  if (logicalContinuity === 'unknown') reasons.push('logical-continuity-unresolved');
+  if (preserveWhy === 'unknown') reasons.push('preserve-why-unresolved');
+  if (effectLabel === 'custom' && !effectMeaning) reasons.push('effect-meaning-required');
+  reasons.push(...mapping.semanticQualification.reasons.map((reason) => `member-mapping-${reason}`));
+  return Object.freeze({
+    name: String(effect.name || ''),
+    targetBinding,
+    effect: effectLabel,
+    resultBinding,
+    logicalContinuity,
+    effectMeaning,
+    requiredMaterializationOperation: token(fields['Required Materialization Operation']),
+    preserveWhy,
+    memberMapping: mapping,
+    participation,
+    semanticQualification: semanticQualification(reasons),
+    notes: token(fields.Notes),
+    executable: false,
+    command: null
+  });
+}
+
+function projectParentEffect(effect = {}, roleNames, outputNames) {
+  const fields = effect.fields || {};
+  const outputBinding = bindingReference(fields['Output Binding'], outputNames, 'output-role', true);
+  const effectLabel = token(fields.Effect);
+  const parentBinding = bindingReference(fields['Parent Binding'], roleNames, 'participant-role', false);
+  const mapping = memberMapping(fields);
+  const participation = effectParticipation(fields);
+  const reasons = [];
+  if (participation.state === 'unresolved') reasons.push('condition-unresolved');
+  if (outputBinding.qualification === 'unresolved') reasons.push('output-binding-unresolved');
+  if (parentBinding.qualification === 'unresolved') reasons.push('parent-binding-unresolved');
+  if (effectLabel === 'unknown') reasons.push('effect-unresolved');
+  if (['set', 'replace'].includes(effectLabel) && parentBinding.qualification !== 'resolved') {
+    reasons.push('parent-binding-required');
+  }
+  reasons.push(...mapping.semanticQualification.reasons.map((reason) => `member-mapping-${reason}`));
+  return Object.freeze({
+    name: String(effect.name || ''),
+    outputBinding,
+    effect: effectLabel,
+    parentBinding,
+    memberMapping: mapping,
+    participation,
+    semanticQualification: semanticQualification(reasons),
+    notes: token(fields.Notes),
+    actualParentAssigned: false,
+    executable: false
+  });
+}
+
+function projectRelationEffect(effect = {}, roleNames) {
+  const fields = effect.fields || {};
+  const predicateVocabulary = token(fields['Predicate Vocabulary']);
+  const predicateAuthority = token(fields['Predicate Authority']);
+  const predicateScope = predicateAuthority
+    ? 'declared-authority'
+    : predicateVocabulary
+      ? 'declared-vocabulary'
+      : 'local-transition-definition';
+  const subjectBinding = bindingReference(fields['Subject Binding'], roleNames, 'participant-role', true);
+  const objectBinding = bindingReference(fields['Object Binding'], roleNames, 'participant-role', true);
+  const effectLabel = token(fields.Effect);
+  const mapping = memberMapping(fields);
+  const participation = effectParticipation(fields);
+  const reasons = [];
+  if (participation.state === 'unresolved') reasons.push('condition-unresolved');
+  if (subjectBinding.qualification === 'unresolved') reasons.push('subject-binding-unresolved');
+  if (objectBinding.qualification === 'unresolved') reasons.push('object-binding-unresolved');
+  if (effectLabel === 'unknown') reasons.push('effect-unresolved');
+  reasons.push(...mapping.semanticQualification.reasons.map((reason) => `member-mapping-${reason}`));
+  return Object.freeze({
+    name: String(effect.name || ''),
+    effect: effectLabel,
+    subjectBinding,
+    predicateIdentifier: token(fields['Predicate Identifier']),
+    predicateMeaning: token(fields['Predicate Meaning']),
+    objectBinding,
+    directionality: token(fields.Directionality),
+    predicateLabel: token(fields['Predicate Label']),
+    predicateVocabulary,
+    predicateAuthority,
+    predicateScope,
+    portablePredicateIdentityClaimed: Boolean(predicateAuthority || predicateVocabulary),
+    inversePredicateIdentifier: token(fields['Inverse Predicate Identifier']),
+    memberMapping: mapping,
+    participation,
+    semanticQualification: semanticQualification(reasons),
+    notes: token(fields.Notes),
+    relationMaterialized: false,
+    executable: false
+  });
+}
+
+function projectDestinationBinding(binding = {}) {
+  const fields = binding.fields || {};
+  const required = token(fields.Required);
+  return Object.freeze({
+    name: String(binding.name || ''),
+    fields: Object.freeze({ ...fields }),
+    meaning: token(fields.Meaning),
+    required,
+    requiredQualification: Object.freeze({
+      state: required === 'yes' ? 'required' : required === 'no' || !required ? 'not-required' : 'unresolved'
+    }),
+    invocationInputRequired: required === 'yes',
+    executable: false
+  });
+}
+
+function projectOutputPlacement(placement = {}, roleNames, outputNames, destinationNames) {
+  const fields = placement.fields || {};
+  const outputBinding = bindingReference(fields['Output Binding'], outputNames, 'output-role', true);
+  const destinationBinding = bindingReference(fields['Destination Binding'], destinationNames, 'destination-binding', false);
+  const relativeToBinding = bindingReference(fields['Relative To Binding'], roleNames, 'participant-role', false);
+  const placementIntent = token(fields['Placement Intent']);
+  const namingAuthority = token(fields['Naming Authority']);
+  const namingAuthorityReference = token(fields['Naming Authority Reference']);
+  const namingQualification = namingAuthorityQualification(namingAuthority, namingAuthorityReference);
+  const explicitOverrideAllowed = token(fields['Explicit Override Allowed']);
+  const reasons = [];
+  if (outputBinding.qualification === 'unresolved') reasons.push('output-binding-unresolved');
+  if (destinationBinding.qualification === 'unresolved') reasons.push('destination-binding-unresolved');
+  if (relativeToBinding.qualification === 'unresolved') reasons.push('relative-to-binding-unresolved');
+  if (placementIntent === 'unknown') reasons.push('intent-unresolved');
+  if (namingQualification.state === 'unresolved') reasons.push(namingQualification.reason || 'naming-unresolved');
+  if (explicitOverrideAllowed === 'unknown') reasons.push('explicit-override-unresolved');
+  return Object.freeze({
+    name: String(placement.name || ''),
+    outputBinding,
+    destinationBinding,
+    placementIntent,
+    namingAuthority,
+    namingAuthorityReference,
+    namingQualification,
+    relativeToBinding,
+    relativePlacementMeaning: token(fields['Relative Placement Meaning']),
+    explicitOverrideAllowed,
+    semanticQualification: semanticQualification(reasons),
+    notes: token(fields.Notes),
+    concretePath: null,
+    pathQualification: 'not-evaluated',
+    materializationCommand: null,
+    executable: false
+  });
+}
+
+function withLifecycleCoverage(role = {}, lifecycleEffects = []) {
+  const matchingEffects = lifecycleEffects.filter((effect) =>
+    effect.targetBinding?.resolvedName === role.name || effect.resultBinding?.resolvedName === role.name);
+  const active = matchingEffects.filter((effect) => effect.participation?.state === 'active');
+  const unresolved = matchingEffects.filter((effect) => effect.participation?.state === 'unresolved');
+  const state = active.length ? 'present' : unresolved.length ? 'unresolved' : 'missing';
+  return Object.freeze({
+    ...role,
+    lifecycleCoverage: Object.freeze({
+      state,
+      effectNames: Object.freeze(matchingEffects.map((effect) => effect.name).sort()),
+      activeEffectNames: Object.freeze(active.map((effect) => effect.name).sort()),
+      unresolvedEffectNames: Object.freeze(unresolved.map((effect) => effect.name).sort())
+    })
+  });
+}
+
+function withDestinationPlacementCoverage(binding = {}, placements = []) {
+  const placementNames = placements
+    .filter((placement) => placement.destinationBinding?.resolvedName === binding.name)
+    .map((placement) => placement.name)
+    .sort();
+  return Object.freeze({
+    ...binding,
+    placementCoverage: Object.freeze({
+      state: placementNames.length ? 'present' : 'missing',
+      placementNames: Object.freeze(placementNames)
+    })
+  });
+}
+
+function namingAuthorityQualification(authority = '', reference = '') {
+  if (!authority) return Object.freeze({ state: 'absent', reason: '' });
+  if (authority === 'unknown') return Object.freeze({ state: 'unresolved', reason: 'naming-authority-unresolved' });
+  if (authority === 'external-authority' && !reference) {
+    return Object.freeze({ state: 'unresolved', reason: 'naming-authority-reference-required' });
+  }
+  return Object.freeze({ state: 'not-evaluated', reason: '' });
+}
+
+function projectAuthoringGuidance(definition = {}) {
+  const group = definition.ordinaryProjection?.byGroup?.['Authoring Bindings'] || {};
+  const values = group.values || {};
+  return Object.freeze({
+    interactionUnit: token(values['Interaction Unit']),
+    schemaModule: token(values['Schema Module']),
+    presentationSurface: token(values['Presentation Surface']),
+    authoringNotes: token(values['Authoring Notes']),
+    qualification: token(group.qualification) || 'unresolved',
+    guidanceOnly: true,
+    generationAuthority: false,
+    executionAuthority: false
+  });
+}
+
+function effectParticipation(fields = {}) {
+  const condition = token(fields.Condition);
+  const conditionReference = token(fields['Condition Reference']);
+  return Object.freeze({
+    condition,
+    conditionReference,
+    state: condition || conditionReference ? 'unresolved' : 'active',
+    reason: condition || conditionReference ? 'effect-condition-not-evaluated' : 'no-condition-prescribed'
+  });
+}
+
+function memberMapping(fields = {}) {
+  const declared = token(fields['Member Mapping']);
+  const mappingKey = token(fields['Mapping Key']);
+  const mappingMeaning = token(fields['Mapping Meaning']);
+  const reasons = [];
+  if (declared === 'unknown') reasons.push('unresolved');
+  if (declared === 'custom' && !mappingMeaning) reasons.push('meaning-required');
+  if (declared === 'by-key' && !mappingKey) reasons.push('key-required');
+  return Object.freeze({
+    declared,
+    mappingKey,
+    mappingMeaning,
+    semanticQualification: semanticQualification(reasons),
+    concreteQualification: declared ? 'not-evaluated' : 'not-required',
+    concreteAssociations: Object.freeze([]),
+    positionalInference: false
+  });
+}
+
+function bindingReference(value, allowedNames, namespace, required) {
+  const declared = token(value);
+  if (!declared) return Object.freeze({ declared: '', namespace, qualification: required ? 'unresolved' : 'absent', resolvedName: '' });
+  return Object.freeze({
+    declared,
+    namespace,
+    qualification: allowedNames.has(declared) ? 'resolved' : 'unresolved',
+    resolvedName: allowedNames.has(declared) ? declared : ''
+  });
+}
+
+function collectUnresolvedReasons(plan = {}) {
+  const reasons = [];
+  for (const role of plan.outputRoles || []) {
+    if (role.qualification !== 'qualified') reasons.push(`output-role:${role.name}:unresolved`);
+    if (role.minimumCount.kind === 'unknown' || role.maximumCount.kind === 'unknown') reasons.push(`output-role:${role.name}:cardinality-unresolved`);
+    if (role.lifecycleCoverage?.state === 'missing') reasons.push(`output-role:${role.name}:lifecycle-coverage-missing`);
+    if (role.lifecycleCoverage?.state === 'unresolved') reasons.push(`output-role:${role.name}:lifecycle-coverage-unresolved`);
+  }
+  for (const destination of plan.destinationBindings || []) {
+    if (destination.requiredQualification.state === 'unresolved') reasons.push(`destination:${destination.name}:requiredness-unresolved`);
+    if (destination.requiredQualification.state === 'required' && destination.placementCoverage?.state !== 'present') {
+      reasons.push(`destination:${destination.name}:required-placement-missing`);
+    }
+  }
+  for (const [groupName, effects] of [['lifecycle', plan.lifecycleEffects], ['parent', plan.parentEffects], ['relation', plan.relationEffects]]) {
+    for (const effect of effects || []) {
+      for (const reason of effect.semanticQualification?.reasons || []) reasons.push(`${groupName}:${effect.name}:${reason}`);
+    }
+  }
+  for (const placement of plan.outputPlacements || []) {
+    for (const reason of placement.semanticQualification?.reasons || []) reasons.push(`placement:${placement.name}:${reason}`);
+  }
+  return [...new Set(reasons)].sort();
+}
+
+function semanticQualification(reasons = []) {
+  const unique = [...new Set(reasons.filter(Boolean))].sort();
+  return Object.freeze({
+    state: unique.length ? 'unresolved' : 'qualified',
+    reasons: Object.freeze(unique)
+  });
+}
+
+function bindingKeysFor(groupName) {
+  if (groupName === 'lifecycle') return ['targetBinding', 'resultBinding'];
+  if (groupName === 'parent') return ['outputBinding', 'parentBinding'];
+  return ['subjectBinding', 'objectBinding'];
+}
+
+function activeDeclarations(items = []) {
+  const list = Array.isArray(items) ? items : [];
+  if (list.length === 1 && token(list[0]?.name).toLowerCase() === 'none') return [];
+  return list.filter((item) => token(item?.name).toLowerCase() !== 'none');
+}
+
+function cardinality(value, maximum) {
+  const raw = token(value);
+  if (raw === 'unknown') return Object.freeze({ raw, kind: 'unknown', value: null });
+  if (maximum && raw === 'unbounded') return Object.freeze({ raw, kind: 'unbounded', value: null });
+  if (/^(0|[1-9]\d*)$/.test(raw)) return Object.freeze({ raw, kind: 'numeric', value: Number(raw) });
+  return Object.freeze({ raw, kind: raw ? 'invalid' : 'absent', value: null });
+}
+
+function definitionIdentity(definition = {}) {
+  return Object.freeze({
+    canonicalIdentifier: String(definition.transitionIdentity?.['Canonical Identifier'] || ''),
+    name: String(definition.transitionIdentity?.Name || ''),
+    version: String(definition.transitionIdentity?.Version || ''),
+    registryIdentity: String(definition.artifact?.registryIdentity || ''),
+    artifactId: String(definition.artifact?.id || '')
+  });
+}
+
+function blockedPlan(definition, reason) {
+  return Object.freeze({
+    schema: TRANSITION_RESULT_SEMANTICS_PLAN_SCHEMA_ID,
+    definition: definitionIdentity(definition),
+    readOnly: true,
+    mutation: false,
+    networkFetch: false,
+    executable: false,
+    qualification: 'blocked',
+    reasons: Object.freeze([reason]),
+    outputRoles: Object.freeze([]),
+    lifecycleEffects: Object.freeze([]),
+    parentEffects: Object.freeze([]),
+    relationEffects: Object.freeze([]),
+    destinationBindings: Object.freeze([]),
+    outputPlacements: Object.freeze([]),
+    authoringGuidance: Object.freeze({ guidanceOnly: true, generationAuthority: false, executionAuthority: false }),
+    boundary: Object.freeze({ execution: false })
+  });
+}
+
+function isCanonicalDefinitionReadModel(definition = {}) {
+  return definition?.schema === TRANSITION_DEFINITION_READ_MODEL_SCHEMA_ID
+    && definition?.artifact?.schemaId === CANONICAL_TRANSITION_DEFINITION_SCHEMA_ID;
+}
+
+function schemaToken(value = '') { return token(value).replace(/^\[([^\]]+)\]\([^)]+\)$/, '$1'); }
+function token(value = '') { return String(value || '').trim(); }

package/src/transitions/transition.taskMaterializer.js

@@ -0,0 +1,2 @@
+// Compatibility re-export. Schema-specific representation ownership lives with the schema companion.
+export * from '@tiinex/core/schemas/core/task/tiinex.task.v1.localMaterialization.js';

package/src/transitions/transition.topicMaterializer.js

@@ -0,0 +1,2 @@
+// Compatibility re-export. Schema-specific representation ownership lives with the schema companion.
+export * from '@tiinex/core/schemas/core/topic/tiinex.topic.v1.localMaterialization.js';

package/src/transitions/transition.validate.case.mjs

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict';
+import { createContinuationDraft, createReferenceDraft } from '@tiinex/core/transitions/record.transitions.js';
+import { validateTransitionDraft } from '@tiinex/core/transitions/transition.validate.js';
+
+const localParent = {
+  id: 'local:workspace:notes/parent.md',
+  title: 'Local parent',
+  summary: 'Local summary',
+  path: 'notes/parent.md',
+  kind: 'tiinex.topic.v1',
+  schemaId: 'tiinex.topic.v1',
+  markdown: '# Local parent',
+  sourceMode: 'local-files',
+  source: { adapterId: 'local', kind: 'local-session' }
+};
+
+const localDraft = createContinuationDraft(localParent, { id: 'tiinex.topic.v1', label: 'Topic' }, {}, { clock: () => '2026-07-21T02:00:00.000Z' });
+assert.equal(localDraft.validation.schema, 'tiinex.transition.validation.v1');
+assert.equal(localDraft.validation.ok, true, 'local continuation should validate');
+assert.equal(localDraft.validation.parsed.parentTrace, 'record:local:workspace:notes/parent.md');
+assert.equal(localDraft.validation.parsed.parentOrigin, 'notes/parent.md');
+assert.match(localDraft.validation.parsed.parentBoundary, /no GitHub provenance inferred/i);
+assert(!localDraft.validation.findings.some((finding) => finding.severity === 'error'), 'local continuation has no validation errors');
+
+const githubParent = {
+  id: 'source:github:tiinex/docs:topics/parent.md',
+  title: 'GitHub parent',
+  summary: 'GitHub summary',
+  path: 'topics/parent.md',
+  kind: 'tiinex.topic.v1',
+  schemaId: 'tiinex.topic.v1',
+  markdown: '# GitHub parent',
+  sourceMode: 'source-backed',
+  source: { adapterId: 'github', kind: 'github-tree', sourceKind: 'github.repo', repo: 'Tiinex/docs', ref: 'master' }
+};
+
+const githubReference = createReferenceDraft(githubParent, {}, { clock: () => '2026-07-21T02:00:00.000Z' });
+assert.equal(githubReference.validation.ok, true, 'github parent reference should validate as a local draft with source-backed parent boundary');
+assert.match(githubReference.validation.parsed.parentBoundary, /source-backed github material/i);
+assert.equal(githubReference.sourceMode, 'local-reference', 'transition result must stay local even when parent is source-backed');
+assert.equal(githubReference.source?.adapterId, undefined, 'transition draft must not inherit GitHub source object');
+
+const tampered = { ...localDraft, markdown: localDraft.markdown.replace(/# Continuity Integrity[\s\S]*$/, ''), hasIntegrity: false };
+const tamperedValidation = validateTransitionDraft(tampered, localParent);
+assert.equal(tamperedValidation.ok, false, 'missing integrity must fail transition validation');
+assert(tamperedValidation.findings.some((finding) => finding.code === 'transition.integrity.required'), 'missing integrity has transition finding');
+
+const wrongTrace = { ...localDraft, markdown: localDraft.markdown.replace('Trace: record:local:workspace:notes/parent.md', 'Trace: record:somewhere-else') };
+const wrongTraceValidation = validateTransitionDraft(wrongTrace, localParent);
+assert.equal(wrongTraceValidation.ok, false, 'trace mismatch must fail transition validation');
+assert(wrongTraceValidation.findings.some((finding) => finding.code === 'transition.parent.trace.mismatch'), 'trace mismatch has transition finding');
+
+const leakedBoundary = { ...localDraft, markdown: localDraft.markdown.replace('Boundary: browser-local session material; no GitHub provenance inferred', 'Boundary: source-backed github material') };
+const leakValidation = validateTransitionDraft(leakedBoundary, localParent);
+assert.equal(leakValidation.ok, false, 'local parent must not be promoted to GitHub provenance');
+assert(leakValidation.findings.some((finding) => finding.code === 'transition.parent.boundary.local-github-leak'), 'boundary leak has transition finding');
+
+console.log('transition.validate: ok');

package/src/ui/cards/ArtifactCard.js

@@ -0,0 +1 @@
+export function ArtifactCard(model) { return model; }

package/src/ui/cards/SchemaCard.js

@@ -0,0 +1 @@
+export function SchemaCard(model) { return model; }

package/src/ui/cards/SourceCard.js

@@ -0,0 +1 @@
+export function SourceCard(model) { return model; }

package/src/ui/dialog.presenter.js

@@ -0,0 +1,24 @@
+(function attachDialogPresenter(global) {
+  'use strict';
+
+  function renderAddMaterialDialog(workspace, ctx) {
+    return `<div class="tx-dialog-backdrop" role="presentation"><section class="tx-dialog tx-workspace-action-dialog tx-local-material-dialog" role="dialog" aria-modal="true" aria-labelledby="add-material-title"><button class="tx-dialog-close" type="button" data-dialog-close aria-label="Close">${ctx.icon('close')}</button><div class="tx-mini-label">Local material</div><h2 id="add-material-title">Add local Markdown</h2><p>Add browser-local Markdown text to <strong>${ctx.escapeHtml(workspace?.name || 'this workspace')}</strong>. It stays local/session and does not infer GitHub provenance.</p><form id="add-material-form" data-workspace-id="${ctx.escapeHtml(workspace?.id || '')}"><label class="tx-field"><span>Title</span><input name="recordTitle" autocomplete="off" maxlength="96" required placeholder="Example: Local note or pasted Markdown"></label><label class="tx-field"><span>Markdown or summary</span><textarea name="recordSummary" rows="6" maxlength="280" placeholder="# Heading or short summary"></textarea></label><div class="tx-badges">${ctx.badge('local/session')}${ctx.badge('not GitHub')}${ctx.badge('hash restore')}</div><p class="tx-form-error" data-form-error aria-live="polite"></p><button class="tx-button tx-primary tx-dialog-primary" type="submit">${ctx.icon('load')} Add local Markdown</button></form></section></div>`;
+  }
+
+  function renderContinueDialog(workspace, ctx) {
+    const title = `${workspace?.name || 'Workspace'} continuation`;
+    return `<div class="tx-dialog-backdrop" role="presentation"><section class="tx-dialog tx-workspace-action-dialog" role="dialog" aria-modal="true" aria-labelledby="continue-title"><button class="tx-dialog-close" type="button" data-dialog-close aria-label="Close">${ctx.icon('close')}</button><div class="tx-mini-label">Continue</div><h2 id="continue-title">Create continuation leaf</h2><p>Create a browser-local continuation placeholder from <strong>${ctx.escapeHtml(workspace?.name || 'this workspace')}</strong>. Source boundaries remain local until material is explicitly exported or published.</p><form id="continue-form" data-workspace-id="${ctx.escapeHtml(workspace?.id || '')}"><label class="tx-field"><span>Title</span><input name="recordTitle" autocomplete="off" maxlength="96" required value="${ctx.escapeHtml(title)}"></label><label class="tx-field"><span>Summary</span><textarea name="recordSummary" rows="4" maxlength="280">Continuation leaf drafted in Tiinex Viewer.</textarea></label><div class="tx-badges">${ctx.badge('draft')}${ctx.badge('child of workspace')}${ctx.badge('local/session')}</div><p class="tx-form-error" data-form-error aria-live="polite"></p><button class="tx-button tx-primary tx-dialog-primary" type="submit">${ctx.icon('lineage')} Create continuation</button></form></section></div>`;
+  }
+
+  function renderOpenWorkspaceDialog(workspace, ctx) {
+    const count = Array.isArray(workspace?.records) ? workspace.records.length : 0;
+    const sourceBoundary = workspace?.source?.boundary || 'browser-local session state; no source files or GitHub provenance inferred';
+    return `<div class="tx-dialog-backdrop" role="presentation"><section class="tx-dialog tx-workspace-summary-dialog" role="dialog" aria-modal="true" aria-labelledby="open-workspace-title"><button class="tx-dialog-close" type="button" data-dialog-close aria-label="Close">${ctx.icon('close')}</button><div class="tx-mini-label">Workspace</div><h2 id="open-workspace-title">${ctx.escapeHtml(workspace?.name || 'Workspace')}</h2><p>Current browser-local workspace. Opening this summary does not change source truth or fetch remote material.</p><div class="tx-action-summary"><div><span>Records</span><strong>${count}</strong></div><div><span>Boundary</span><strong>local/session</strong></div><div><span>GitHub</span><strong>not guessed</strong></div></div><p class="tx-form-note">${ctx.escapeHtml(sourceBoundary)}</p></section></div>`;
+  }
+
+  function renderCommandInfoDialog(command, ctx) {
+    return `<div class="tx-dialog-backdrop" role="presentation"><section class="tx-dialog" role="dialog" aria-modal="true" aria-labelledby="command-info-title"><button class="tx-dialog-close" type="button" data-dialog-close aria-label="Close">${ctx.icon('close')}</button><div class="tx-mini-label">Command</div><h2 id="command-info-title">${ctx.escapeHtml(command.action || 'Command')}</h2><p>This command is not available for this local/session record yet. It is hidden from the primary happy path until the matching source-bound use-case exists.</p><div class="tx-badges">${ctx.badge('not source destructive')}${ctx.badge('deferred use-case')}</div></section></div>`;
+  }
+
+  global.TiinexDialogPresenter = { renderAddMaterialDialog, renderContinueDialog, renderOpenWorkspaceDialog, renderCommandInfoDialog };
+})(typeof window !== 'undefined' ? window : globalThis);

package/src/ui/feedback/DegradedNotice.js

@@ -0,0 +1 @@
+export function DegradedNotice(message) { return { kind: 'degraded', message }; }

package/src/ui/feedback/EmptyState.js

@@ -0,0 +1 @@
+export function EmptyState(message) { return { kind: 'empty', message }; }

package/src/ui/feedback/ValidationNotice.js

@@ -0,0 +1 @@
+export function ValidationNotice(message) { return { kind: 'validation', message }; }

package/src/ui/forms/FormRenderer.js

@@ -0,0 +1 @@
+export function FormRenderer(spec) { return spec; }

package/src/ui/forms/fields/MarkdownField.js

@@ -0,0 +1 @@
+export function MarkdownField(field) { return field; }

package/src/ui/forms/fields/SelectField.js

@@ -0,0 +1 @@
+export function SelectField(field) { return field; }

package/src/ui/forms/fields/SourcePickerField.js

@@ -0,0 +1 @@
+export function SourcePickerField(field) { return field; }

package/src/ui/forms/fields/TextField.js

@@ -0,0 +1 @@
+export function TextField(field) { return field; }

package/src/ui/icon.paths.js

@@ -0,0 +1,37 @@
+(function attachTiinexIconPaths(global) {
+  'use strict';
+
+  const iconPaths = Object.freeze({
+    previous: '<path d="M15 6l-6 6 6 6"/>',
+    next: '<path d="M9 6l6 6-6 6"/>',
+    // circle + icon for Create (visually closer to the legacy header)
+    create: '<circle cx="12" cy="12" r="9"/><path d="M12 8v8M8 12h8"/>',
+    multiverse: '<path d="M5 7h14M5 12h14M5 17h14"/>',
+    display: '<path d="M5 7h14M5 12h14M5 17h14"/>',
+    source: '<path d="M12 4l7 4-7 4-7-4 7-4z"/><path d="M5 12l7 4 7-4M5 16l7 4 7-4"/>',
+    audit: '<path d="M5 13l4 4L19 7"/>',
+    external: '<path d="M8 16L16 8M10 8h6v6"/>',
+    close: '<path d="M7 7l10 10M17 7L7 17"/>',
+    share: '<path d="M8 12h8M12 8l4 4-4 4"/>',
+    open: '<path d="M4 8h7l2 3h7v8H4z"/>',
+    merge: '<path d="M6 6v4a4 4 0 004 4h8"/><path d="M14 10l4 4-4 4"/>',
+    lineage: '<path d="M7 7h4v4H7zM13 13h4v4h-4z"/><path d="M11 9h2a2 2 0 012 2v2"/>',
+    help: '<path d="M9 9a3 3 0 116 2c-2 1-3 2-3 4"/><path d="M12 19h.01"/>',
+    load: '<path d="M12 4v10M8 10l4 4 4-4"/><path d="M5 20h14"/>',
+    preview: '<path d="M4 6h16v12H4z"/><path d="M8 10h8M8 14h5"/>',
+    database: '<ellipse cx="12" cy="5" rx="7" ry="3"/><path d="M5 5v6c0 1.7 3.1 3 7 3s7-1.3 7-3V5"/><path d="M5 11v6c0 1.7 3.1 3 7 3s7-1.3 7-3v-6"/>',
+    file: '<path d="M7 3h7l3 3v15H7z"/><path d="M14 3v4h4M9 12h6M9 16h6"/>',
+    seedling: '<path d="M12 20v-7"/><path d="M12 13c-4 0-6-2-6-5 4 0 6 2 6 5z"/><path d="M12 13c4 0 6-2 6-5-4 0-6 2-6 5z"/>',
+    pen: '<path d="M4 20l4-1 10-10-3-3L5 16z"/><path d="M13 6l3 3"/>',
+    shareNodes: '<circle cx="7" cy="12" r="2"/><circle cx="17" cy="7" r="2"/><circle cx="17" cy="17" r="2"/><path d="M9 11l6-3M9 13l6 3"/>',
+    scale: '<path d="M12 4v16M5 7h14"/><path d="M7 7l-3 6h6zM17 7l-3 6h6z"/>',
+    document: '<path d="M7 3h7l4 4v14H7z"/><path d="M14 3v5h5M9 13h6M9 17h6"/>',
+    download: '<path d="M12 4v10M8 10l4 4 4-4"/><path d="M5 20h14"/>',
+    folder: '<path d="M3 7h7l2 3h9v9H3z"/>',
+    github: '<path d="M12 3a9 9 0 00-3 17c.5.1.7-.2.7-.5v-2c-3 .7-3.6-1.2-3.6-1.2-.5-1.1-1.1-1.4-1.1-1.4-.9-.6.1-.6.1-.6 1 0 1.5 1 1.5 1 .9 1.5 2.4 1.1 3 .8.1-.7.4-1.1.7-1.3-2.4-.3-5-1.2-5-5.4 0-1.2.4-2.1 1-2.9-.1-.3-.4-1.4.1-2.8 0 0 .8-.3 2.9 1.1.8-.2 1.7-.3 2.6-.3s1.8.1 2.6.3c2.1-1.4 2.9-1.1 2.9-1.1.5 1.4.2 2.5.1 2.8.6.8 1 1.7 1 2.9 0 4.2-2.6 5.1-5 5.4.4.3.8 1 .8 2v2.7c0 .3.2.6.8.5A9 9 0 0012 3z"/>',
+    link: '<path d="M10 13a5 5 0 007 0l2-2a5 5 0 00-7-7l-1 1"/><path d="M14 11a5 5 0 00-7 0l-2 2a5 5 0 007 7l1-1"/>',
+    spinner: '<path d="M12 3a9 9 0 019 9"/><path d="M21 12a9 9 0 01-9 9" opacity=".35"/><path d="M12 21a9 9 0 01-9-9" opacity=".35"/><path d="M3 12a9 9 0 019-9" opacity=".35"/>'
+  });
+
+  global.TiinexIconPaths = iconPaths;
+})(typeof window !== 'undefined' ? window : globalThis);

package/src/ui/layout/Panel.js

@@ -0,0 +1 @@
+export function Panel(children = []) { return { layout: 'panel', children }; }

package/src/ui/layout/ResponsiveFrame.js

@@ -0,0 +1 @@
+export function ResponsiveFrame(children = []) { return { layout: 'responsive', children }; }

package/src/ui/layout/SplitView.js

@@ -0,0 +1 @@
+export function SplitView(children = []) { return { layout: 'split', children }; }

package/src/ui/layout/Stack.js

@@ -0,0 +1 @@
+export function Stack(children = []) { return { layout: 'stack', children }; }

package/src/ui/panels/DetailPanel.js

@@ -0,0 +1 @@
+export function DetailPanel(model) { return model; }

package/src/ui/panels/LineagePanel.js

@@ -0,0 +1 @@
+export function LineagePanel(model) { return model; }