@tiinex/app 0.1.1

package/src/app/workspaceRecordActions.js

@@ -0,0 +1,158 @@
+import { addConfiguredSourceToWorkspace, workspaceDeclaredSourceInputsFromMarkdown, workspaceSourceInputsFromMarkdown } from '../workspaces/workspace.entrypoints.js';
+import { replaceNonDraftWorkspaceSet } from '../workspaces/workspace.openSemantics.js';
+import { mergeWorkspaceEntrypointSet, openWorkspaceEntrypointSet } from '../workspaces/workspace.entrypointLifecycle.js';
+import { appendWorkspaceMemberBinding, resolveWorkspaceMemberSourceInput, workspaceMemberBindingFromApply } from '../workspaces/workspace.memberIdentity.js';
+import { publicTargetFromRecord } from './publicTarget.js';
+export function workspaceEntryFromRecord(record = {}, descriptorTargetOverride = null) {
+  const path = record.path || record.sourcePath || record.sourceTarget?.sourceArtifactPath || 'workspace.workspace.md';
+  const descriptorTarget = workspaceDescriptorTarget(descriptorTargetOverride) || publicTargetFromRecord(record);
+  return {
+    id: `workspace-record:${record.id || path}`,
+    title: record.title || workspaceTitleFromMarkdown(record.markdown || '') || path,
+    path,
+    markdown: String(record.markdown || ''),
+    sourceMode: record.source?.adapterId === 'github' ? 'source-backed-workspace-file' : 'local-workspace-file',
+    source: record.source ? Object.assign({}, record.source) : undefined,
+    sourceRecordId: record.id || '',
+    sourceTarget: record.sourceTarget ? Object.assign({}, record.sourceTarget) : undefined,
+    descriptorTarget
+  };
+}
+
+export function openWorkspaceRecordAction({ lifecycle, parseWorkspaceConfig, state, record, descriptorTarget = null }) {
+  const entry = workspaceEntryFromRecord(record, descriptorTarget);
+  if (!entry.markdown) return { ok: false, error: 'workspace.markdown.unavailable', message: 'Workspace artifact body is unavailable; reload the source first.', state, entry };
+  const sourceInputs = workspaceSourceInputsFromMarkdown(entry.markdown, parseWorkspaceConfig);
+  if (sourceInputs.length) return openWorkspaceRecordEntrypointSet({ lifecycle, state, entry, sourceInputs });
+
+  const opened = lifecycle?.openWorkspaceFromMarkdown?.(state, entry.markdown, entry);
+  if (!opened?.ok) return { ok: false, error: opened?.error || 'workspace.open.failed', message: 'Could not open workspace artifact.', state, entry };
+  const replaced = replaceNonDraftWorkspaceSet(opened.state, [opened.workspace?.id]);
+  const focusedState = stateWithFocusedWorkspace(replaced.state, opened.workspace?.id, { previousWorkspaceId: state.activeWorkspaceId || '', previousView: state.view || {} });
+  const workspace = (Array.isArray(focusedState?.workspaces) ? focusedState.workspaces : []).find((item) => item.id === opened.workspace?.id) || opened.workspace;
+  return { ok: true, state: focusedState, workspace, entry, sourceInputs: [], openBoundary: replaced.report };
+}
+
+export function openWorkspaceRecordMemberAction({ lifecycle, parseWorkspaceConfig, state, record, memberIdentity, descriptorTarget = null }) {
+  const entry = workspaceEntryFromRecord(record, descriptorTarget);
+  if (!entry.markdown) return { ok: false, error: 'workspace.markdown.unavailable', message: 'Workspace artifact body is unavailable; reload the source first.', state, entry };
+  const declaredInputs = workspaceDeclaredSourceInputsFromMarkdown(entry.markdown, parseWorkspaceConfig);
+  const resolution = resolveWorkspaceMemberSourceInput(declaredInputs, memberIdentity);
+  if (!resolution.ok) {
+    const message = resolution.status === 'ambiguous'
+      ? 'Workspace member target matches more than one declared entrypoint.'
+      : 'Workspace member target no longer matches a declared entrypoint.';
+    return { ok: false, error: resolution.error, message, state, entry, memberResolution: resolution };
+  }
+  const opened = openWorkspaceRecordEntrypointSet({ lifecycle, state, entry, sourceInputs: [resolution.sourceInput] });
+  return opened?.ok ? Object.assign({}, opened, { memberIdentity: resolution.memberIdentity, memberResolution: resolution }) : opened;
+}
+
+export function mergeWorkspaceRecordAction({ lifecycle, parseWorkspaceConfig, state, workspaceId, record }) {
+  const entry = workspaceEntryFromRecord(record);
+  if (!entry.markdown) return { ok: false, error: 'workspace.markdown.unavailable', message: 'Workspace artifact body is unavailable; reload the source first.', state, entry };
+  const sourceInputs = workspaceSourceInputsFromMarkdown(entry.markdown, parseWorkspaceConfig);
+  if (sourceInputs.length) return mergeWorkspaceEntrypointSet({ lifecycle, state, entry, sourceInputs, annotateWorkspace: annotateWorkspaceEntrypoint });
+
+  const merged = lifecycle?.mergeWorkspaceArtifactContext?.(state, workspaceId, entry)
+    || lifecycle?.mergeWorkspaceImport?.(state, workspaceId, entry);
+  if (!merged?.ok) return { ok: false, error: merged?.error || 'workspace.merge.failed', message: 'Could not merge workspace artifact context.', state, entry };
+  return { ok: true, state: merged.state, workspace: merged.workspace, entry, sourceInputs: [], merge: merged.merge || { mode: 'artifact-context' } };
+}
+
+export function registerWorkspaceConfigSources(state, workspaceId, markdown = '', { lifecycle, parseWorkspaceConfig } = {}) {
+  if (!lifecycle?.addWorkspaceSource || typeof parseWorkspaceConfig !== 'function') return state;
+  const sourceInputs = workspaceSourceInputsFromMarkdown(markdown, parseWorkspaceConfig);
+  let next = state;
+  for (const sourceInput of sourceInputs) {
+    const added = addConfiguredSourceToWorkspace(lifecycle, next, workspaceId, sourceInput);
+    if (added?.ok) next = added.state;
+  }
+  return next;
+}
+
+function openWorkspaceRecordEntrypointSet({ lifecycle, state, entry, sourceInputs }) {
+  const opened = openWorkspaceEntrypointSet({ lifecycle, state, entry, sourceInputs, annotateWorkspace: annotateWorkspaceEntrypoint });
+  if (!opened?.ok) return opened;
+  const focusedState = stateWithFocusedWorkspace(opened.state, opened.workspace?.id, { previousWorkspaceId: state.activeWorkspaceId || '', previousView: state.view || {} });
+  const workspace = (focusedState.workspaces || []).find((item) => item.id === opened.workspace?.id) || opened.workspace;
+  return Object.assign({}, opened, { state: focusedState, workspace, openedWorkspaceSet: true });
+}
+
+function annotateWorkspaceEntrypoint({ state, workspaceId, entry, sourceInput, mode }) {
+  annotateWorkspaceImport(state, workspaceId, entry, mode);
+  const workspace = (Array.isArray(state?.workspaces) ? state.workspaces : []).find((item) => item.id === workspaceId);
+  const binding = workspaceMemberBindingFromApply({ descriptorTarget: entry?.descriptorTarget, sourceInput });
+  if (workspace && binding) appendWorkspaceMemberBinding(workspace, binding);
+}
+
+function annotateWorkspaceImport(state = {}, workspaceId = '', entry = {}, mode = 'open') {
+  const workspace = (Array.isArray(state?.workspaces) ? state.workspaces : []).find((item) => item.id === workspaceId);
+  if (!workspace) return;
+  workspace.workspaceMarkdown = entry.markdown || workspace.workspaceMarkdown || '';
+  workspace.workspaceImport = Object.assign({}, workspace.workspaceImport || {}, {
+    schema: 'tiinex.workspace.import.v1',
+    path: entry.path || workspace.workspaceImport?.path || 'workspace.workspace.md',
+    sourceMode: entry.sourceMode || workspace.workspaceImport?.sourceMode || 'workspace-file',
+    sourceRecordId: entry.sourceRecordId || '',
+    mode
+  });
+  workspace.importLog = Array.isArray(workspace.importLog) ? workspace.importLog.slice() : [];
+  workspace.importLog.unshift({ kind: `workspace-record-${mode}`, path: entry.path || '', title: entry.title || '', at: new Date().toISOString() });
+}
+
+function stateWithFocusedWorkspace(state = {}, workspaceId = '', { previousWorkspaceId = '', previousView = {} } = {}) {
+  const target = (Array.isArray(state?.workspaces) ? state.workspaces : []).find((workspace) => workspace.id === workspaceId);
+  if (!target) return state;
+  const views = Object.assign({}, state.workspaceViews || {});
+  const prevId = String(previousWorkspaceId || '').trim();
+  if (prevId && prevId !== target.id && (Array.isArray(state.workspaces) ? state.workspaces : []).some((workspace) => workspace.id === prevId)) views[prevId] = normalizeWorkspaceView(previousView || state.view || {});
+  views[target.id] = normalizeWorkspaceView({ workspaceVerse: 'feed', selectedRecordId: '', lineageQuery: '', expandedLineageRecordIds: [], lineageAuditReport: null, lineageLoadReport: null });
+  return Object.assign({}, state, {
+    activeWorkspaceId: target.id,
+    workspaceViews: views,
+    view: views[target.id]
+  });
+}
+
+function normalizeWorkspaceView(view = {}) {
+  return Object.assign({ universe: 'column', workspaceVerse: 'feed', reader: 'scan', query: '' }, view || {}, {
+    workspaceVerse: view.workspaceVerse && ['feed', 'tree', 'lineage', 'audit'].includes(String(view.workspaceVerse)) ? view.workspaceVerse : 'feed',
+    selectedRecordId: String(view.selectedRecordId || ''),
+    lineageQuery: String(view.lineageQuery || ''),
+    expandedLineageRecordIds: Array.isArray(view.expandedLineageRecordIds) ? view.expandedLineageRecordIds.slice() : [],
+    lineageAuditReport: view.lineageAuditReport || null,
+    lineageLoadReport: view.lineageLoadReport || null
+  });
+}
+
+function canonicalizeLocalPath(inputPath = '') {
+  let p = String(inputPath || '').trim().replace(/\\/g, '/').replace(/\/{2,}/g, '/');
+  const out = [];
+  for (const part of p.split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') out.pop();
+    else out.push(part);
+  }
+  return out.join('/');
+}
+
+function workspaceTitleFromMarkdown(markdown = '') {
+  const text = String(markdown || '');
+  const browserTitle = text.match(/^\s*-\s*Browser Title:\s*(.+)$/mi)?.[1]?.trim();
+  if (browserTitle) return stripMarkdown(browserTitle);
+  const heading = text.match(/^#\s+(.+)\s*$/m)?.[1]?.trim();
+  return stripMarkdown(heading || '');
+}
+
+function stripMarkdown(value = '') {
+  return String(value || '').replace(/^\[([^\]]+)\]\([^)]*\)$/u, '$1').trim();
+}
+
+function workspaceDescriptorTarget(target = null) {
+  if (!target || typeof target !== 'object' || !/^https?:\/\//i.test(String(target.externalTarget || ''))) return null;
+  if (!['workspace', 'workspace.member'].includes(String(target.targetKind || ''))) return null;
+  const out = Object.assign({}, target, { targetKind: 'workspace' });
+  delete out.memberIdentity;
+  return Object.freeze(out);
+}

package/src/app/workspaceScopedInteraction.js

@@ -0,0 +1,68 @@
+import { activeWorkspaceViewFor as activeWorkspaceViewForState, stateWithActiveWorkspace, stateWithWorkspacePresentationPruned, stateWithWorkspaceViewPatch, stateWithWorkspaceViewUpdate } from './workspaceMulticolumn.js';
+import { stateWithWorkspaceWindowFocus, stateWithWorkspaceWindowPruned } from './workspaceWindow.js';
+
+export function workspaceById(state = {}, workspaceId = '') {
+  const id = String(workspaceId || '').trim();
+  return (Array.isArray(state.workspaces) ? state.workspaces : []).find((workspace) => workspace.id === id) || null;
+}
+
+export function stateWithWorkspaceFocused(state = {}, workspaceId = '', viewportWidth = 0) {
+  const id = String(workspaceId || '').trim();
+  if (!workspaceById(state, id)) return state;
+  const focused = stateWithActiveWorkspace(state, id);
+  return stateWithWorkspaceWindowFocus(focused, id, viewportWidth);
+}
+
+export function stateWithWorkspaceViewPatchAndFocus(state = {}, workspaceId = '', patch = {}, viewportWidth = 0) {
+  const id = String(workspaceId || '').trim();
+  const patched = stateWithWorkspaceViewPatch(state, id, patch);
+  return stateWithWorkspaceFocused(patched, id, viewportWidth);
+}
+
+export function stateWithRecordLineageFocused(state = {}, workspaceId = '', recordId = '', viewportWidth = 0) {
+  const id = String(workspaceId || state.activeWorkspaceId || '').trim();
+  const selectedRecordId = String(recordId || '').trim();
+  if (!id || !selectedRecordId || !workspaceById(state, id)) return state;
+  const currentView = activeWorkspaceViewForState(state, id);
+  const currentVerse = String(currentView.workspaceVerse || 'feed');
+  const existingReturnVerse = String(currentView.lineageReturnVerse || '');
+  const lineageReturnVerse = currentVerse === 'tree' || currentVerse === 'feed'
+    ? currentVerse
+    : existingReturnVerse === 'tree' || existingReturnVerse === 'feed'
+      ? existingReturnVerse
+      : 'feed';
+  return stateWithWorkspaceViewPatchAndFocus(state, id, {
+    workspaceVerse: 'lineage',
+    lineageReturnVerse,
+    selectedRecordId,
+    lineageQuery: '',
+    expandedLineageRecordIds: [],
+    lineageAuditReport: null,
+    lineageLoadReport: null
+  }, viewportWidth);
+}
+
+
+export function workspaceVerseNavigationPatch(verse = 'feed') {
+  const normalizedVerse = verse === 'tree' || verse === 'graph' || verse === 'lineage' ? verse : 'feed';
+  if (normalizedVerse === 'lineage') return { workspaceVerse: 'lineage' };
+  if (normalizedVerse === 'graph') return { workspaceVerse: 'graph', lineageAuditReport: null };
+  return {
+    workspaceVerse: normalizedVerse,
+    lineageReturnVerse: '',
+    selectedRecordId: '',
+    expandedLineageRecordIds: [],
+    lineageAuditReport: null,
+    lineageLoadReport: null
+  };
+}
+
+export function stateWithWorkspaceViewUpdateAndFocus(state = {}, workspaceId = '', updater = null, viewportWidth = 0) {
+  const id = String(workspaceId || '').trim();
+  const updated = stateWithWorkspaceViewUpdate(state, id, updater);
+  return stateWithWorkspaceFocused(updated, id, viewportWidth);
+}
+
+export function stateAfterWorkspaceClosePresentation(state = {}, viewportWidth = 0) {
+  return stateWithWorkspaceWindowPruned(stateWithWorkspacePresentationPruned(state), viewportWidth);
+}

package/src/app/workspaceSelectionOriginContext.js

@@ -0,0 +1,29 @@
+export const WORKSPACE_SELECTION_ORIGIN_CONTEXT_SCHEMA_ID = 'tiinex.site.workspace-selection-origin-context.v1';
+
+export function captureWorkspaceSelectionOriginContext(state = {}) {
+  return Object.freeze({
+    schema: WORKSPACE_SELECTION_ORIGIN_CONTEXT_SCHEMA_ID,
+    activeWorkspaceId: String(state.activeWorkspaceId || ''),
+    view: cloneJson(state.view || {}),
+    workspaceViews: cloneJson(state.workspaceViews || {}),
+    workspaceWindow: state.workspaceWindow ? cloneJson(state.workspaceWindow) : null
+  });
+}
+
+export function restoreWorkspaceSelectionOriginContext(state = {}, context = null) {
+  if (!context || context.schema !== WORKSPACE_SELECTION_ORIGIN_CONTEXT_SCHEMA_ID) return state;
+  const workspaces = Array.isArray(state.workspaces) ? state.workspaces : [];
+  const activeWorkspaceId = workspaces.some((workspace) => String(workspace?.id || '') === String(context.activeWorkspaceId || ''))
+    ? String(context.activeWorkspaceId || '')
+    : String(state.activeWorkspaceId || '');
+  const next = Object.assign({}, state, {
+    activeWorkspaceId,
+    view: cloneJson(context.view || state.view || {}),
+    workspaceViews: cloneJson(context.workspaceViews || state.workspaceViews || {})
+  });
+  if (context.workspaceWindow) next.workspaceWindow = cloneJson(context.workspaceWindow);
+  else delete next.workspaceWindow;
+  return next;
+}
+
+function cloneJson(value) { return JSON.parse(JSON.stringify(value ?? null)); }

package/src/app/workspaceSelectionSession.js

@@ -0,0 +1,54 @@
+export const WORKSPACE_SELECTION_SESSION_SCHEMA_ID = 'tiinex.site.workspace-selection-session.v1';
+
+export function createWorkspaceSelectionSession(input = {}) {
+  const role = token(input.role);
+  const candidates = normalizeCandidates(input.candidates);
+  if (!role) return Object.freeze({ ok: false, error: 'selection-role-missing' });
+  const enabled = candidates.filter((item) => item.enabled !== false);
+  return Object.freeze({
+    ok: true,
+    schema: WORKSPACE_SELECTION_SESSION_SCHEMA_ID,
+    id: token(input.id) || `selection:${role}:${token(input.ownerKey) || 'session'}`,
+    role,
+    ownerKey: token(input.ownerKey),
+    title: token(input.title) || 'Choose in workspace',
+    guidance: token(input.guidance),
+    originWorkspaceId: token(input.originWorkspaceId),
+    originContext: input.originContext ?? null,
+    presentation: input.presentation && typeof input.presentation === 'object' ? Object.freeze({ ...input.presentation }) : null,
+    candidates,
+    candidateKeys: Object.freeze(enabled.map((item) => item.key)),
+    boundary: token(input.boundary) || 'Selection chooses only among caller-qualified candidates; session core owns no semantic role, eligibility, identity, or presentation meaning.'
+  });
+}
+
+export function workspaceSelectionCandidateFor(session = {}, candidate = {}) {
+  if (!session?.ok) return null;
+  const key = candidateKey(candidate);
+  return session.candidates?.find((item) => item.key === key) || null;
+}
+
+export function workspaceSelectionAllows(session = {}, candidate = {}) {
+  const qualified = workspaceSelectionCandidateFor(session, candidate);
+  return Boolean(qualified && qualified.enabled !== false);
+}
+
+export function workspaceSelectionResult(session = {}, candidate = {}) {
+  const qualified = workspaceSelectionCandidateFor(session, candidate);
+  if (!qualified || qualified.enabled === false) return Object.freeze({ ok: false, error: 'selection-candidate-unqualified', sessionId: session?.id || '' });
+  return Object.freeze({ ok: true, schema: 'tiinex.site.workspace-selection-result.v1', sessionId: session.id, role: session.role, ownerKey: session.ownerKey, candidate: qualified });
+}
+
+export function candidateKey(candidate = {}) { return candidate?.key == null ? '' : String(candidate.key); }
+
+function normalizeCandidates(values = []) {
+  const out = [], seen = new Set();
+  for (const raw of Array.isArray(values) ? values : []) {
+    const key = candidateKey(raw);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(Object.freeze({ ...raw, key, enabled: raw?.enabled !== false }));
+  }
+  return Object.freeze(out);
+}
+function token(value = '') { return String(value || '').trim(); }

package/src/app/workspaceSourceCloseCommand.js

@@ -0,0 +1,25 @@
+import { clearGithubSourceCacheForSource } from './githubSourceOperation.js';
+
+export function runWorkspaceSourceCloseCommand(input = {}) {
+  const lifecycle = input.lifecycle;
+  const state = input.state;
+  const workspaceId = String(input.workspaceId || state?.activeWorkspaceId || '').trim();
+  const sourceId = String(input.sourceId || '').trim();
+  const workspace = (Array.isArray(state?.workspaces) ? state.workspaces : []).find((item) => item.id === workspaceId) || lifecycle?.activeWorkspace?.(state) || null;
+  const source = (workspace?.sources || []).find((item) => String(item.id || '') === sourceId) || null;
+  if (source) clearGithubSourceCacheForSource(source);
+  const result = lifecycle?.closeWorkspaceSource?.(state, workspaceId, sourceId);
+  if (!result?.ok) return { ok: false, error: result?.error || 'source.close.failed', state, notice: 'Source stays pinned.' };
+  return { ok: true, state: result.state, localSessionCleared: Boolean(result.localSessionCleared), counts: result.counts || {}, notice: sourceCloseNotice(result) };
+}
+
+function sourceCloseNotice(result = {}) {
+  if (!result.localSessionCleared) return 'Source closed.';
+  const counts = result.counts || {};
+  const parts = [
+    Number(counts.records || 0) ? `${Number(counts.records || 0)} record${Number(counts.records || 0) === 1 ? '' : 's'}` : '',
+    Number(counts.assets || 0) ? `${Number(counts.assets || 0)} asset${Number(counts.assets || 0) === 1 ? '' : 's'}` : '',
+    Number(counts.workspaceArtifacts || 0) ? `${Number(counts.workspaceArtifacts || 0)} workspace artifact${Number(counts.workspaceArtifacts || 0) === 1 ? '' : 's'}` : ''
+  ].filter(Boolean);
+  return parts.length ? `Cleared Local session material: ${parts.join(', ')}. Local source row stays available.` : 'Local source was already empty.';
+}

package/src/app/workspaceSpineProductRouting.case.mjs

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+
+const app = fs.readFileSync(new URL('./TiinexApp.jsx', import.meta.url), 'utf8');
+const surface = fs.readFileSync(new URL('../schemas/workspace/workspace.views.jsx', import.meta.url), 'utf8');
+const css = fs.readFileSync(new URL('../styles/app.css', import.meta.url), 'utf8');
+
+assert.ok(app.includes("onClose={() => openWorkspaceDialog('close-workspace', workspace.id)}"), 'close targets clicked visible workspace explicitly');
+assert.ok(app.includes("onRenameWorkspace={() => openWorkspaceDialog('rename-workspace', workspace.id)}"), 'rename targets clicked visible workspace explicitly');
+assert.ok(app.includes("onVerse={(verse) => setVerse(verse, workspace.id)}"), 'view actions target clicked visible workspace explicitly');
+assert.ok(app.includes("onOpenAddDialog={(sourceId = '') => openAddToWorkspace(sourceId, workspace.id)}"), 'Add targets clicked visible workspace explicitly');
+assert.ok(app.includes('onViewScroll={(verse, top) => noteViewScroll(workspace.id, verse, top)}'), 'scroll ownership is keyed by workspace');
+assert.ok(!app.includes('itemActive ? setVerse : undefined'), 'inactive visible workspace must not be an inert preview');
+assert.ok(!app.includes('itemActive ? openAddToWorkspace : undefined'), 'inactive visible workspace Add must remain interactive');
+assert.ok(surface.includes('layoutMode = \'expanded\''), 'workspace surface consumes per-workspace layout mode');
+assert.ok(surface.includes('Collapse workspace'), 'expanded workspace has compact/collapse affordance');
+assert.ok(surface.includes('Expand workspace'), 'compact workspace has expand affordance');
+assert.ok(css.includes('.tx-workspace-frame-inactive'), 'sibling focus styling remains explicit');
+assert.ok(css.includes('opacity: 1;'), 'inactive visible workspace is not dimmed/disabled-looking');
+assert.ok(css.includes('overscroll-behavior: contain'), 'workspace stage owns vertical scroll independently');
+
+console.log('✓ workspace spine product routing guards passed');

package/src/app/workspaceStartupTransition.js

@@ -0,0 +1,32 @@
+import { runInitialWorkspaceBootstrapOperation } from './initialWorkspaceBootstrapOperation.js';
+
+export async function runWorkspaceStartupTransition({
+  runtimeApi = {},
+  emptyState = {},
+  workspaceConfig = {},
+  storage = null,
+  locationLike = null,
+  windowObj = null,
+  fetchImpl = globalThis.fetch,
+  commit = null,
+  materializeSource = null,
+  setDiagnostics = null,
+  mode = 'replace',
+  resolveStartupInput
+} = {}) {
+  let committed = null;
+  const result = await runInitialWorkspaceBootstrapOperation({
+    runtimeApi,
+    state: emptyState,
+    workspaceConfig,
+    storage,
+    locationLike,
+    windowObj,
+    fetchImpl,
+    materializeSource,
+    setDiagnostics,
+    resolveStartupInput,
+    commit: (nextState) => { committed = nextState; commit?.(nextState, mode); }
+  });
+  return Object.assign({}, result, { state: committed || result?.state || emptyState });
+}

package/src/app/workspaceWindow.js

@@ -0,0 +1,85 @@
+export function workspaceColumnCapacity(viewportWidth = 0) {
+  const width = Number(viewportWidth || 0) || 1280;
+  if (width < 980) return 1;
+  if (width < 1500) return 2;
+  return 3;
+}
+
+export function shouldPageWorkspaces(workspaceCount, viewportWidth = 0) {
+  const count = Math.max(0, Number(workspaceCount || 0));
+  return count > workspaceColumnCapacity(viewportWidth);
+}
+
+export function workspaceWindowFor(state = {}, { viewportWidth = 0, activeWorkspaceId = '' } = {}) {
+  const workspaces = Array.isArray(state.workspaces) ? state.workspaces : [];
+  const capacity = workspaceColumnCapacity(viewportWidth);
+  const count = workspaces.length;
+  const activeId = String(activeWorkspaceId || state.activeWorkspaceId || workspaces[0]?.id || '').trim();
+  const activeIndex = Math.max(0, workspaces.findIndex((workspace) => workspace.id === activeId));
+  const limit = Math.max(1, Math.min(capacity, Math.max(1, count)));
+  const maxOffset = Math.max(0, count - limit);
+  const preferredOffset = Number(state.workspaceWindow?.offset || 0);
+  let offset = Number.isFinite(preferredOffset) ? Math.max(0, Math.min(preferredOffset, maxOffset)) : 0;
+  if (count && (activeIndex < offset || activeIndex >= offset + limit)) {
+    offset = Math.max(0, Math.min(activeIndex - Math.floor((limit - 1) / 2), maxOffset));
+  }
+  const visible = workspaces.slice(offset, offset + limit);
+  return {
+    schema: 'tiinex.workspace.window.v1',
+    capacity,
+    count,
+    offset,
+    canPage: count > capacity,
+    from: count ? offset + 1 : 0,
+    to: Math.min(count, offset + limit),
+    visible,
+    visibleIds: visible.map((workspace) => workspace.id),
+    activeWorkspaceId: activeId,
+    previousEnabled: offset > 0,
+    nextEnabled: offset + limit < count
+  };
+}
+
+export function stateWithWorkspaceWindowOffset(state = {}, offset = 0, viewportWidth = 0) {
+  const workspaces = Array.isArray(state.workspaces) ? state.workspaces : [];
+  const windowState = workspaceWindowFor(state, { viewportWidth });
+  const maxOffset = Math.max(0, windowState.count - Math.max(1, windowState.capacity));
+  const nextOffset = Math.max(0, Math.min(Number(offset || 0), maxOffset));
+  const firstVisibleId = String(workspaces[nextOffset]?.id || state.activeWorkspaceId || '').trim();
+  return Object.assign({}, state, {
+    activeWorkspaceId: firstVisibleId || state.activeWorkspaceId,
+    workspaceWindow: { schema: 'tiinex.workspace.window.v1', offset: nextOffset }
+  });
+}
+
+export function stateWithWorkspaceWindowPage(state = {}, direction = 'next', viewportWidth = 0) {
+  const current = workspaceWindowFor(state, { viewportWidth });
+  const delta = direction === 'previous' ? -1 : 1;
+  if ((delta < 0 && !current.previousEnabled) || (delta > 0 && !current.nextEnabled)) return state;
+  return stateWithWorkspaceWindowOffset(state, current.offset + delta, viewportWidth);
+}
+
+export function stateWithWorkspaceWindowFocus(state = {}, workspaceId = '', viewportWidth = 0) {
+  const id = String(workspaceId || '').trim();
+  const workspaces = Array.isArray(state.workspaces) ? state.workspaces : [];
+  const index = workspaces.findIndex((workspace) => workspace.id === id);
+  if (index < 0) return state;
+  const capacity = workspaceColumnCapacity(viewportWidth);
+  const maxOffset = Math.max(0, workspaces.length - capacity);
+  const current = workspaceWindowFor(state, { viewportWidth, activeWorkspaceId: id });
+  let offset = current.offset;
+  if (index < offset) offset = index;
+  if (index >= offset + capacity) offset = Math.max(0, index - capacity + 1);
+  offset = Math.max(0, Math.min(offset, maxOffset));
+  return Object.assign({}, state, {
+    activeWorkspaceId: id,
+    workspaceWindow: { schema: 'tiinex.workspace.window.v1', offset }
+  });
+}
+
+export function stateWithWorkspaceWindowPruned(state = {}, viewportWidth = 0) {
+  const workspaces = Array.isArray(state.workspaces) ? state.workspaces : [];
+  if (!workspaces.length) return Object.assign({}, state, { workspaceWindow: { schema: 'tiinex.workspace.window.v1', offset: 0 } });
+  const activeId = workspaces.some((workspace) => workspace.id === state.activeWorkspaceId) ? state.activeWorkspaceId : workspaces[0].id;
+  return stateWithWorkspaceWindowFocus(Object.assign({}, state, { activeWorkspaceId: activeId }), activeId, viewportWidth);
+}

package/src/artifacts/artifact.fixture.js

@@ -0,0 +1 @@
+export const artifactFixtureNames = ['topic.trace.md', 'evidence.trace.md', 'unknown-schema.trace.md'];

package/src/artifacts/artifact.identity.js

@@ -0,0 +1,6 @@
+export function localArtifactIdentity(parsedArtifact) {
+  const schema = parsedArtifact.envelope.current.schema.id || 'unknown-schema';
+  const title = parsedArtifact.title || 'untitled';
+  const createdAt = parsedArtifact.envelope.current.createdAt || 'unknown-time';
+  return `${schema}::${createdAt}::${title}`;
+}