@tiinex/app 0.1.1

package/src/ui/panels/SourcePanel.js

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

package/src/ui/primitives/Badge.js

@@ -0,0 +1 @@
+export { Badge } from './Badge.jsx';

package/src/ui/primitives/Badge.jsx

@@ -0,0 +1,5 @@
+import React from 'react';
+
+export function Badge({ children, tone = 'default', className = '', ...props }) {
+  return <span {...props} className={`tx-badge tx-badge-${tone} ${className}`.trim()}>{children}</span>;
+}

package/src/ui/primitives/Button.js

@@ -0,0 +1 @@
+export { Button } from './Button.jsx';

package/src/ui/primitives/Button.jsx

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Icon } from './Icon.jsx';
+
+export function Button({ children, icon, variant = 'default', shape = '', className = '', type = 'button', ...props }) {
+  const classes = ['tx-button', `tx-button-${variant}`, shape ? `tx-button-${shape}` : '', className].filter(Boolean).join(' ');
+  return (
+    <button type={type} className={classes} {...props}>
+      {icon ? <Icon name={icon} /> : null}
+      {children ? <span>{children}</span> : null}
+    </button>
+  );
+}

package/src/ui/primitives/Card.js

@@ -0,0 +1 @@
+export function Card({ children }) { return children; }

package/src/ui/primitives/Field.js

@@ -0,0 +1 @@
+export { TextField as Field, TextField } from './Field.jsx';

package/src/ui/primitives/Field.jsx

@@ -0,0 +1,21 @@
+import React from 'react';
+
+export function TextField({ id, label, value, onChange, error = '', ...props }) {
+  return (
+    <label className="tx-field" htmlFor={id}>
+      <span>{label}</span>
+      <input id={id} value={value} onChange={(event) => onChange(event.target.value)} aria-invalid={Boolean(error)} {...props} />
+      {error ? <small role="alert">{error}</small> : null}
+    </label>
+  );
+}
+
+export function TextareaField({ id, label, value, onChange, error = '', ...props }) {
+  return (
+    <label className="tx-textarea-field" htmlFor={id}>
+      <span>{label}</span>
+      <textarea id={id} value={value} onChange={(event) => onChange(event.target.value)} aria-invalid={Boolean(error)} {...props} />
+      {error ? <small role="alert">{error}</small> : null}
+    </label>
+  );
+}

package/src/ui/primitives/Icon.jsx

@@ -0,0 +1,90 @@
+import React from 'react';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import {
+  faArrowLeft,
+  faArrowRight,
+  faArrowUpFromBracket,
+  faCircleNodes,
+  faCircleCheck,
+  faCirclePlus,
+  faCloudArrowUp,
+  faCodeBranch,
+  faCompass,
+  faPenToSquare,
+  faFileArrowUp,
+  faFileCode,
+  faFolder,
+  faDownload,
+  faDownLeftAndUpRightToCenter,
+  faFolderOpen,
+  faFolderPlus,
+  faHandPointer,
+  faSliders,
+  faHouse,
+  faLink,
+  faListCheck,
+  faMagnifyingGlass,
+  faQuestion,
+  faQuoteRight,
+  faShareNodes,
+  faSitemap,
+  faTriangleExclamation,
+  faTrashCan,
+  faUpRightFromSquare,
+  faUpRightAndDownLeftFromCenter,
+  faXmark
+} from '@fortawesome/free-solid-svg-icons';
+import { faCircle, faFileLines } from '@fortawesome/free-regular-svg-icons';
+
+const ICONS = {
+  add: faCirclePlus,
+  archive: faFolder,
+  audit: faCircleCheck,
+  check: faCircleCheck,
+  asset: faFileLines,
+  close: faXmark,
+  collapse: faDownLeftAndUpRightToCenter,
+  continue: faCodeBranch,
+  create: faCirclePlus,
+  delete: faTrashCan,
+  download: faDownload,
+  drop: faCloudArrowUp,
+  edit: faPenToSquare,
+  expand: faUpRightAndDownLeftFromCenter,
+  faCodeBranch,
+  fileUpload: faFileArrowUp,
+  filters: faSliders,
+  folderDownload: faDownload,
+  folderOpen: faFolderOpen,
+  folderPlus: faFolderPlus,
+  github: faCircleNodes,
+  handPointer: faHandPointer,
+  interpret: faArrowRight,
+  help: faQuestion,
+  faQuoteRight,
+  home: faHouse,
+  lineage: faCodeBranch,
+  local: faFolder,
+  markdown: faFileCode,
+  manualFiles: faFileLines,
+  multiverse: faCompass,
+  next: faArrowRight,
+  noNodes: faCircle,
+  open: faFileLines,
+  previous: faArrowLeft,
+  reference: faQuoteRight,
+  search: faMagnifyingGlass,
+  share: faShareNodes,
+  shareNodes: faShareNodes,
+  source: faUpRightFromSquare,
+  task: faListCheck,
+  tree: faSitemap,
+  upload: faArrowUpFromBracket,
+  warning: faTriangleExclamation,
+  workspace: faCircleNodes
+};
+
+export function Icon({ name, className = '', ...props }) {
+  const icon = ICONS[name] || faCircle;
+  return <FontAwesomeIcon className={`tx-icon ${className}`.trim()} icon={icon} aria-hidden="true" {...props} />;
+}

package/src/ui/primitives/Modal.jsx

@@ -0,0 +1,27 @@
+import React, { useEffect, useRef } from 'react';
+import { Button } from './Button.jsx';
+
+export function Modal({ title, children, onDismiss, initialFocus, className = '' }) {
+  const ref = useRef(null);
+  useEffect(() => {
+    const node = initialFocus ? ref.current?.querySelector(`#${CSS.escape(initialFocus)}`) : ref.current?.querySelector('button, input, textarea, select, [tabindex]');
+    node?.focus?.();
+    const onKey = (event) => {
+      if (event.key === 'Escape') onDismiss?.();
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, [initialFocus, onDismiss]);
+
+  return (
+    <div className="tx-dialog-backdrop" role="presentation" onMouseDown={(event) => { if (event.target === event.currentTarget) onDismiss?.(); }}>
+      <section className={`tx-dialog ${className}`.trim()} role="dialog" aria-modal="true" aria-labelledby="tx-dialog-title" ref={ref}>
+        <header className="tx-dialog-head">
+          <h2 id="tx-dialog-title">{title}</h2>
+          <Button variant="ghost" icon="close" aria-label="Close dialog" onClick={onDismiss} />
+        </header>
+        <div className="tx-dialog-body">{children}</div>
+      </section>
+    </div>
+  );
+}

package/src/validation/i18n.js

@@ -0,0 +1,37 @@
+import { resolveSchemaModule } from '@tiinex/core/schemas/resolver.js';
+import { resolveFindingDefinition } from '@tiinex/core/validation/findings.js';
+
+export function resolveFindingMessage(finding = {}, options = {}) {
+  const code = String(finding.code || '').trim();
+  const locale = normalizeLocale(options.locale || 'en');
+  const messageKey = String(finding.messageKey || resolveFindingDefinition(code, { source: finding.source })?.messageKey || code).trim();
+  const schemaIds = [finding.source, schemaIdFromFindingCode(code), options.schemaId, 'tiinex.root.v1'].filter(Boolean);
+  for (const schemaId of [...new Set(schemaIds)]) {
+    const message = resolveSchemaMessage(schemaId, messageKey, locale);
+    if (message) return interpolate(message, finding.params || options.params || {});
+  }
+  return finding.message || messageKey || code || 'Validation finding.';
+}
+
+export function resolveSchemaMessage(schemaId = '', key = '', locale = 'en') {
+  const resolution = resolveSchemaModule({ schemaId });
+  const packs = resolution.module?.i18n || {};
+  const normalized = normalizeLocale(locale);
+  const pack = packs[normalized] || packs[normalized.split('-')[0]] || packs.en || null;
+  if (!pack) return '';
+  return String(pack[key] || pack.messages?.[key] || '').trim();
+}
+
+function normalizeLocale(locale = 'en') { return String(locale || 'en').trim().toLowerCase() || 'en'; }
+function schemaIdFromFindingCode(code = '') {
+  const text = String(code || '');
+  if (text.startsWith('root.')) return 'tiinex.root.v1';
+  if (text.startsWith('topic.')) return 'tiinex.topic.v1';
+  if (text.startsWith('evidence.')) return 'tiinex.evidence.v1';
+  if (text.startsWith('preservation.')) return 'tiinex.preservation.v1';
+  if (text.startsWith('workspace.')) return 'tiinex.workspace.v1';
+  return '';
+}
+function interpolate(message = '', params = {}) {
+  return String(message || '').replace(/\{([a-zA-Z0-9_.-]+)\}/g, (_, key) => params[key] == null ? `{${key}}` : String(params[key]));
+}

package/src/validation/validateArtifact.case.mjs

@@ -0,0 +1,41 @@
+import assert from 'node:assert/strict';
+import { validateArtifact } from '@tiinex/core/validation/validateArtifact.js';
+import { resolveFindingMessage } from './i18n.js';
+
+const topicMarkdown = [
+  '# Continuity Context',
+  '',
+  '- Envelope Schema: [tiinex.root.v1](tiinex.root.v1.schema.md)',
+  '- Current',
+  '  - Current Schema: [tiinex.topic.v1](tiinex.topic.v1.schema.md)',
+  '  - Created At: 2026-01-01T00:00:00Z',
+  '  - Summary: Topic test.',
+  '',
+  '---',
+  '',
+  '# Short',
+  '',
+  'tiny',
+  '',
+  '# Continuity Integrity',
+  '',
+  '- sha256-base64url-c14n-v2',
+  '  - Towards: self',
+  '  - Value: pending'
+].join('\n');
+
+const result = validateArtifact({ markdown: topicMarkdown });
+assert.equal(result.validation.rootValidator, 'diagnostic', 'rootValidate remains a readability diagnostic while compiled Root/descendant contract owns semantic validity');
+assert.equal(result.contractValidation.available, true, 'qualified compiled Root/descendant contract must run through the shared pipeline');
+assert.equal(result.validation.childValidator, 'run', 'exact Topic validator must run after Root');
+assert(result.findings.some((finding) => finding.code === 'root.parent.absent'), 'Root findings must be present');
+assert(result.findings.some((finding) => finding.code === 'topic.body.thin'), 'Topic-specific findings must be present');
+assert(result.findings.some((finding) => finding.code === 'integrity.c14n-v2.detected'), 'integrity engine must see c14n-v2 declarations');
+assert(!result.findings.some((finding) => finding.code === 'audit.validator.unavailable'), 'exact schema validators must not be reported unavailable');
+const titleFinding = result.findings.find((finding) => finding.code === 'topic.body.thin');
+assert.equal(resolveFindingMessage(titleFinding, { locale: 'en' }), 'Topic body is thin; reader may not understand the active topic thread.');
+
+const rootlessChildSource = await import('@tiinex/core/schemas/core/topic/tiinex.topic.v1.validate.js');
+assert.equal(typeof rootlessChildSource.topicValidate, 'function');
+
+console.log('✓ validation pipeline composes Root, integrity, exact schema, findings, and i18n');

package/src/verses/column/ColumnVerse.js

@@ -0,0 +1 @@
+export function ColumnVerse() { return { verse: 'column', multiverse: true }; }

package/src/verses/column/column.model.js

@@ -0,0 +1,6 @@
+export const columnVerseModel = Object.freeze({
+  id: 'column',
+  kind: 'multiverse',
+  layout: 'columns',
+  paneTruth: 'isolated-source-boundaries'
+});

package/src/verses/column/column.project.js

@@ -0,0 +1,7 @@
+export function projectColumnVerse(workspaces = []) {
+  return workspaces.map((workspace, index) => ({
+    columnId: workspace.id || `column-${index + 1}`,
+    workspace,
+    width: workspace.width || 'auto'
+  }));
+}

package/src/verses/context.js

@@ -0,0 +1,26 @@
+export const verseContextAvailability = Object.freeze({
+  universe: Object.freeze({
+    meaning: 'root entry context over one or more workspaces',
+    implemented: ['column'],
+    planned: ['atlas', 'desktop']
+  }),
+  workspace: Object.freeze({
+    meaning: 'single workspace context with its own source boundary',
+    implemented: ['feed', 'tree', 'graph'],
+    planned: ['spatial-graph', 'desktop', 'gallery']
+  }),
+  artifact: Object.freeze({
+    meaning: 'single artifact context',
+    implemented: [],
+    planned: ['detail', 'lineage', 'preview']
+  }),
+  report: Object.freeze({
+    meaning: 'audit or validation report context',
+    implemented: [],
+    planned: ['audit-report']
+  })
+});
+
+export function isVerseImplementedInContext(context, verseId) {
+  return Boolean(verseContextAvailability[context]?.implemented.includes(verseId));
+}

package/src/verses/contracts.js

@@ -0,0 +1 @@
+export function defineVerse(verse) { return Object.freeze(verse); }

package/src/verses/hostRegistry.js

@@ -0,0 +1,47 @@
+export function defineVerse(input = {}) {
+  const id = token(input.id);
+  if (!id) throw new TypeError('Verse id is required.');
+  if (typeof input.load !== 'function') throw new TypeError(`Verse ${id} requires a lazy load() function.`);
+  return Object.freeze({
+    id,
+    label: text(input.label || id),
+    load: input.load,
+    fullscreen: Boolean(input.fullscreen),
+    capabilities: Object.freeze([...(Array.isArray(input.capabilities) ? input.capabilities : [])].map(text).filter(Boolean)),
+    companionProviderIds: Object.freeze([...(Array.isArray(input.companionProviderIds) ? input.companionProviderIds : [])].map(text).filter(Boolean)),
+    boundary: text(input.boundary || 'Verse projection/presentation only; no implicit Tiinex authority')
+  });
+}
+
+export function createVerseRegistry(initial = []) {
+  const entries = new Map();
+  const api = {
+    register(definition) {
+      const verse = definition?.load ? defineVerse(definition) : definition;
+      if (!verse?.id) throw new TypeError('Verse definition is invalid.');
+      if (entries.has(verse.id)) throw new Error(`Verse already registered: ${verse.id}`);
+      entries.set(verse.id, verse);
+      return verse;
+    },
+    unregister(id) { return entries.delete(token(id)); },
+    get(id) { return entries.get(token(id)) || null; },
+    has(id) { return entries.has(token(id)); },
+    list() { return Object.freeze([...entries.values()].sort((a, b) => codePoint(a.id, b.id))); }
+  };
+  for (const definition of initial) api.register(definition);
+  return Object.freeze(api);
+}
+
+export async function loadVerse(registry, id) {
+  const definition = registry?.get?.(id);
+  if (!definition) return Object.freeze({ status: 'missing', id: token(id), definition: null, module: null });
+  try {
+    const module = await definition.load();
+    return Object.freeze({ status: 'ready', id: definition.id, definition, module });
+  } catch (error) {
+    return Object.freeze({ status: 'failed', id: definition.id, definition, module: null, error: String(error?.message || error) });
+  }
+}
+function text(value) { return String(value ?? '').trim(); }
+function token(value) { return text(value).toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, ''); }
+function codePoint(a, b) { return a < b ? -1 : a > b ? 1 : 0; }

package/src/verses/registry.js

@@ -0,0 +1,22 @@
+export const verseRegistry = Object.freeze({
+  root: 'universe',
+  defaultMultiverse: 'column',
+  visibleImplementedVerses: ['universe', 'column', 'feed', 'tree', 'graph'],
+  contexts: Object.freeze({
+    universe: Object.freeze({ implemented: ['column'], planned: ['atlas', 'desktop'] }),
+    workspace: Object.freeze({ implemented: ['feed', 'tree', 'graph'], planned: ['spatial-graph', 'desktop', 'gallery'] }),
+    artifact: Object.freeze({ implemented: [], planned: ['detail', 'lineage', 'preview'] }),
+    report: Object.freeze({ implemented: [], planned: ['audit-report'] })
+  }),
+  adaptersAreSourceTransportBoundaries: true,
+  renderersAreAdapters: false,
+  showOnlyImplementedInPrimaryUi: true
+});
+
+export function getImplementedVersesForContext(context) {
+  return verseRegistry.contexts[context]?.implemented || [];
+}
+
+export function getPlannedVersesForContext(context) {
+  return verseRegistry.contexts[context]?.planned || [];
+}

package/src/verses/universe.model.js

@@ -0,0 +1,8 @@
+export const universeModel = Object.freeze({
+  id: 'universe',
+  kind: 'entry-verse',
+  contains: 'multiverse',
+  defaultMultiverse: 'column',
+  sourceTruth: 'preserved-per-pane',
+  cyclePolicy: 'block-roundtrip-expansion-keys-not-depth'
+});

package/src/verses/universe.presenter.js

@@ -0,0 +1,8 @@
+export function presentUniverse(universeProjection) {
+  return {
+    title: 'Universe',
+    subtitle: 'Column Multiverse entry',
+    panes: universeProjection?.panes || [],
+    disclosure: 'Arrangement changes layout only; source truth remains owned by each workspace pane.'
+  };
+}

package/src/verses/universe.project.js

@@ -0,0 +1,12 @@
+export function projectUniverse(workspaces = []) {
+  return {
+    verse: 'universe',
+    multiverse: 'column',
+    panes: workspaces.map((workspace, index) => ({
+      paneId: workspace.id || `workspace-${index + 1}`,
+      workspaceId: workspace.id || `workspace-${index + 1}`,
+      activeVerse: workspace.activeVerse || 'feed',
+      sourceBoundary: workspace.sourceBoundary || 'preserve-per-pane'
+    }))
+  };
+}

package/src/viewer.js

@@ -0,0 +1,34 @@
+import React from 'react';
+import packageMetadata from '../package.json' with {type:'json'};
+import { createRoot } from 'react-dom/client';
+
+import './ui/icon.paths.js';
+import './workspaces/workspace.config.js';
+import { tiinexBuildIdentity, TIINEX_RUNTIME_ID } from './build.identity.js';
+import './sources/source.identity.js';
+import './workspaces/workspace.lifecycle.js';
+import './workspaces/workspace.route.js';
+import './workspaces/workspace.persistenceRecovery.js';
+import './workspaces/workspace.persistenceRouteCache.js';
+import './workspaces/workspace.persistencePresentation.js';
+import './workspaces/workspace.persistenceCache.js';
+import './workspaces/workspace.persistenceClear.js';
+import './workspaces/workspace.persistence.js';
+
+import './styles/tokens.css';
+import './styles/theme.css';
+import './styles/responsive.css';
+import './styles/app.css';
+
+import { TiinexApplication } from './react/TiinexApplication.jsx';
+
+
+export { TiinexApplication };
+export function mountTiinexApp(element, config = {}) {
+  if (!element) throw new TypeError('A mount element is required.');
+  const root = createRoot(element);
+  const identity = Object.freeze({ ...tiinexBuildIdentity(), applicationPackage: '@tiinex/app', applicationVersion: packageMetadata.version, deploymentId: config.deploymentId || 'custom' });
+  element.ownerDocument.documentElement.dataset.tiinexRuntime = TIINEX_RUNTIME_ID;
+  root.render(React.createElement(TiinexApplication, { config }));
+  return Object.freeze({ identity, unmount: () => root.unmount() });
+}

package/src/workspace.model.js

@@ -0,0 +1,5 @@
+export const WorkspaceMode = Object.freeze({ local: 'file-local', sourceBacked: 'source-backed', mixed: 'mixed' });
+
+export function createWorkspace({ id, name, mode = WorkspaceMode.local } = {}) {
+  return { id: id || 'local-workspace', name: name || 'Local workspace', mode, records: [], activeId: '' };
+}

package/src/workspaces/workspace.actions.js

@@ -0,0 +1 @@
+export const WorkspaceActions = Object.freeze({ loadArtifact: 'load-artifact', setReader: 'set-reader', setSourceBoundary: 'set-source-boundary' });

package/src/workspaces/workspace.artifactActions.js

@@ -0,0 +1,56 @@
+export const WORKSPACE_ARTIFACT_ACTION_CONTRACT_ID = 'tiinex.workspace.artifact.actions.v1';
+
+export function workspaceArtifactActionModel(subject = {}) {
+  const title = workspaceArtifactTitle(subject);
+  return Object.freeze({
+    schema: WORKSPACE_ARTIFACT_ACTION_CONTRACT_ID,
+    subjectTitle: title,
+    roleLabel: 'workspace artifact',
+    roleDescription: 'Workspace entrypoint.',
+    open: Object.freeze({
+      id: 'workspace.open',
+      label: 'Open',
+      title: `Open ${title} as the active workspace context.`,
+      description: 'Open switches focus to this workspace artifact and applies its own entrypoints without cloning sibling material.'
+    }),
+    merge: Object.freeze({
+      id: 'workspace.merge',
+      label: 'Merge',
+      title: `Merge ${title} into the current workspace context.`,
+      description: 'Merge intentionally brings this workspace context into the current workspace without changing the selected workspace artifact into a duplicate user object.'
+    })
+  });
+}
+
+export function workspaceArtifactBoundaryBadge(subject = {}) {
+  const source = subject?.source || {};
+  const mode = String(subject?.sourceMode || subject?.status || '').toLowerCase();
+  const reconciliation = String(subject?.materialReconciliation?.status || '').toLowerCase();
+  if (reconciliation.includes('snapshot') || reconciliation.includes('local') && reconciliation.includes('source')) return 'source + local snapshot';
+  if (mode.includes('source-backed') || source.adapterId === 'github' || source.kind === 'github-tree' || source.sourceKind === 'github-tree') return 'source-backed';
+  if (subject?.importedFromWorkspaceId || subject?.contextReferenceId) return 'local/session';
+  return 'local/session';
+}
+
+export function workspaceArtifactRoleBadge() {
+  return 'workspace artifact';
+}
+
+
+export function workspaceArtifactTitle(subject = {}) {
+  return String(subject?.title || subject?.name || subject?.path || 'workspace artifact').trim() || 'workspace artifact';
+}
+
+export function forbiddenPrimaryWorkspaceActionCopy(text = '') {
+  const value = String(text || '');
+  return [
+    'Open as workspace',
+    'Merge context',
+    'Open as a separate workspace',
+    'creates a separate workspace',
+    'as a separate workspace',
+    'Current workspace remains available',
+    'open/merge candidate',
+    'Open details'
+  ].filter((needle) => value.includes(needle));
+}