@tiinex/app 0.1.1

package/src/app/visualDormancy.js

@@ -0,0 +1,286 @@
+const PREVIEW_ID = 'tx-visual-dormancy-preview';
+const WORKSPACE_SELECTOR = '.tx-workspace-window';
+const PREVIEW_FIRST_RESTORE_DELAY_MS = 1100;
+const RETURN_SETTLE_MS = 0;
+const RETURN_SETTLE_ENABLED = false;
+
+export function visualDormancyReturnSettleEnabled() {
+  return RETURN_SETTLE_ENABLED;
+}
+
+function text(value) {
+  return String(value == null ? '' : value).trim();
+}
+
+function escapeHtml(value) {
+  return text(value).replace(/[&<>"]/g, (char) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[char]));
+}
+
+export function visualDormancySummary(state = {}) {
+  const workspaces = Array.isArray(state.workspaces) ? state.workspaces : [];
+  const active = workspaces.find((workspace) => workspace?.id === state.activeWorkspaceId) || workspaces[0] || null;
+  const records = Array.isArray(active?.records) ? active.records.length : 0;
+  const assets = Array.isArray(active?.assets) ? active.assets.length : 0;
+  const sources = Array.isArray(active?.sources) ? active.sources : [];
+  const source = sources.find((item) => item?.label || item?.repo || item?.owner) || null;
+  const sourceLabel = text(source?.label) || text(source?.repo) || (source?.owner && source?.name ? `${source.owner}/${source.name}` : '') || (sources.length ? `${sources.length} source${sources.length === 1 ? '' : 's'}` : 'No source');
+  const verse = text(state.view?.workspaceVerse) || 'feed';
+  return {
+    title: text(active?.title) || text(active?.name) || text(active?.label) || 'Tiinex workspace',
+    source: sourceLabel,
+    view: verse === 'tree' ? 'Tree view' : verse === 'lineage' ? 'Lineage view' : verse === 'audit' ? 'Audit view' : 'Feed view',
+    records,
+    assets,
+    sources: sources.length,
+    workspaces: workspaces.length,
+    hasMaterial: Boolean(records || assets || sources.length)
+  };
+}
+
+export function visualDormancyPreviewHtml(summary = {}) {
+  const counts = [];
+  if (summary.records) counts.push(`${summary.records} artifacts`);
+  if (summary.assets) counts.push(`${summary.assets} assets`);
+  if (summary.sources) counts.push(`${summary.sources} source${summary.sources === 1 ? '' : 's'}`);
+  return `<section id="${PREVIEW_ID}" class="tx-visual-dormancy-preview" aria-label="Parked Tiinex workspace preview" aria-hidden="true" hidden>
+    <p class="tx-visual-dormancy-kicker">Parked workspace</p>
+    <h2>${escapeHtml(summary.title || 'Tiinex workspace')}</h2>
+    <div class="tx-visual-dormancy-widget-grid" aria-label="Workspace resume summary">
+      <span><strong>View</strong><em>${escapeHtml(summary.view || 'View')}</em></span>
+      <span><strong>Material</strong><em>${escapeHtml(counts.join(' · ') || 'Workspace loaded')}</em></span>
+      <span><strong>Source</strong><em>${escapeHtml(summary.source || 'Workspace')}</em></span>
+    </div>
+    <p class="tx-visual-dormancy-resume">Tap, scroll, or press any key to resume the full workspace.</p>
+  </section>`;
+}
+
+export function visualDormancyEligible(summary = {}, viewport = {}) {
+  if (!summary.hasMaterial) return { ok: false, reason: 'no-material' };
+  const coarse = viewport.coarse === true;
+  // Desktop can be visually narrow in dev tools, side-by-side windows, or screenshots.
+  // Treat that as desktop UI, not mobile app-switch parking. Mobile preview is
+  // reserved for coarse-pointer surfaces where the browser/app switcher is the real
+  // constraint.
+  if (coarse) return { ok: true, reason: 'coarse-viewport' };
+  return { ok: false, reason: 'fine-pointer-no-preview' };
+}
+
+export function visualDormancyRequiresManualRestore(summary = {}, viewport = {}) {
+  const eligible = visualDormancyEligible(summary, viewport);
+  if (!eligible.ok) return false;
+  return viewport.coarse === true;
+}
+
+export function visualDormancyRestoreDelay(summary = {}, viewport = {}) {
+  const eligible = visualDormancyEligible(summary, viewport);
+  if (!eligible.ok) return 0;
+  if (visualDormancyRequiresManualRestore(summary, viewport)) return 0;
+  return PREVIEW_FIRST_RESTORE_DELAY_MS;
+}
+
+function viewportSnapshot() {
+  let coarse = false;
+  try { coarse = Boolean(window.matchMedia?.('(pointer: coarse)')?.matches); } catch (_) {}
+  return { coarse, width: Number(window.innerWidth || 0), height: Number(window.innerHeight || 0) };
+}
+
+function ensurePreview(root, summary) {
+  if (!root) return null;
+  let preview = root.querySelector(`#${PREVIEW_ID}`);
+  if (!preview) {
+    const wrap = document.createElement('div');
+    wrap.innerHTML = visualDormancyPreviewHtml(summary);
+    preview = wrap.firstElementChild;
+    const workspace = root.querySelector(WORKSPACE_SELECTOR);
+    if (workspace?.parentNode) workspace.parentNode.insertBefore(preview, workspace);
+    else root.appendChild(preview);
+  } else {
+    preview.outerHTML = visualDormancyPreviewHtml(summary);
+    preview = root.querySelector(`#${PREVIEW_ID}`);
+  }
+  return preview;
+}
+
+export function installVisualDormancy({ getSummary, rootSelector = '.tx-react-runtime', restoreDelayMs = PREVIEW_FIRST_RESTORE_DELAY_MS } = {}) {
+  if (typeof window === 'undefined' || typeof document === 'undefined') return () => {};
+  const state = {
+    parked: false,
+    previous: null,
+    restoreTimer: 0,
+    firstPaintTimer: 0,
+    settleTimer: 0,
+    events: [],
+    lastSkip: null,
+    lastPark: null,
+    lastRestore: null,
+    lastResumePreview: null,
+    lastSettle: null
+  };
+  const record = (event, detail = {}) => {
+    state.events.push(Object.assign({ at: new Date().toISOString(), event }, detail));
+    if (state.events.length > 40) state.events.splice(0, state.events.length - 40);
+  };
+  const root = () => document.querySelector(rootSelector) || document.getElementById('root');
+  const workspace = () => root()?.querySelector?.(WORKSPACE_SELECTOR) || null;
+  const clearRestoreTimers = () => {
+    if (state.restoreTimer) window.clearTimeout(state.restoreTimer);
+    if (state.firstPaintTimer) window.clearTimeout(state.firstPaintTimer);
+    state.restoreTimer = 0;
+    state.firstPaintTimer = 0;
+  };
+  const clearSettleTimer = () => {
+    if (state.settleTimer) window.clearTimeout(state.settleTimer);
+    state.settleTimer = 0;
+  };
+  const startReturnSettle = (reason = 'background') => {
+    // v286: broad body-level return-settle selectors caused a full style
+    // invalidation on mobile/devtools foreground and could be seen in the
+    // browser inspector as body.tx-return-settle during interaction. Keep the
+    // diagnostic seam, but do not toggle the global class by default.
+    const summary = (typeof getSummary === 'function' ? getSummary() : null) || {};
+    if (!summary.hasMaterial || !RETURN_SETTLE_ENABLED) {
+      state.lastSettle = { reason, phase: 'disabled', records: Number(summary.records || 0), at: new Date().toISOString() };
+      record('return-settle-skip', state.lastSettle);
+      return false;
+    }
+    document.body.classList.add('tx-return-settle');
+    state.lastSettle = { reason, phase: 'background-ready', records: Number(summary.records || 0), at: new Date().toISOString() };
+    record('return-settle-start', state.lastSettle);
+    return true;
+  };
+  const finishReturnSettle = (reason = 'foreground') => {
+    if (!RETURN_SETTLE_ENABLED) {
+      document.body.classList.remove('tx-return-settle');
+      return false;
+    }
+    if (!document.body.classList.contains('tx-return-settle')) return false;
+    clearSettleTimer();
+    const done = () => {
+      document.body.classList.remove('tx-return-settle');
+      state.lastSettle = Object.assign({}, state.lastSettle || {}, { reason, phase: 'restored', restoredAt: new Date().toISOString() });
+      record('return-settle-end', state.lastSettle);
+    };
+    window.requestAnimationFrame?.(() => {
+      state.settleTimer = window.setTimeout(done, RETURN_SETTLE_MS);
+    }) || (state.settleTimer = window.setTimeout(done, RETURN_SETTLE_MS));
+    return true;
+  };
+  const park = (reason = 'hidden') => {
+    const summary = (typeof getSummary === 'function' ? getSummary() : null) || {};
+    const viewport = viewportSnapshot();
+    const eligibility = visualDormancyEligible(summary, viewport);
+    if (!eligibility.ok) { state.lastSkip = Object.assign({ reason }, eligibility, summary); record('park-skip', state.lastSkip); return false; }
+    const target = workspace();
+    const parent = root();
+    if (!target || !parent) return false;
+    const preview = ensurePreview(parent, summary);
+    clearRestoreTimers();
+    if (!state.parked) {
+      state.previous = {
+        contentVisibility: target.style.contentVisibility || '',
+        contain: target.style.contain || '',
+        containIntrinsicSize: target.style.containIntrinsicSize || '',
+        visibility: target.style.visibility || '',
+        pointerEvents: target.style.pointerEvents || '',
+        display: target.style.display || ''
+      };
+    }
+    target.style.contentVisibility = 'hidden';
+    target.style.contain = 'layout paint style';
+    target.style.containIntrinsicSize = `${Math.max(520, Math.round(window.innerHeight || 720))}px`;
+    target.style.visibility = 'hidden';
+    target.style.pointerEvents = 'none';
+    target.style.display = 'none';
+    if (preview) { preview.hidden = false; preview.setAttribute('aria-hidden', 'false'); }
+    document.body.classList.add('tx-visual-dormant');
+    state.parked = true;
+    state.lastPark = Object.assign({
+      reason,
+      restoreDelayMs: visualDormancyRestoreDelay(summary, viewport) || 0,
+      manualRestore: visualDormancyRequiresManualRestore(summary, viewport)
+    }, summary);
+    record('park', state.lastPark);
+    return true;
+  };
+  const restoreNow = (reason = 'visible') => {
+    if (!state.parked) return false;
+    clearRestoreTimers();
+    const target = workspace();
+    const previous = state.previous || {};
+    if (target) {
+      target.style.display = previous.display || '';
+      target.style.contentVisibility = previous.contentVisibility || '';
+      target.style.contain = previous.contain || '';
+      target.style.containIntrinsicSize = previous.containIntrinsicSize || '';
+      target.style.visibility = previous.visibility || '';
+      target.style.pointerEvents = previous.pointerEvents || '';
+    }
+    const preview = root()?.querySelector?.(`#${PREVIEW_ID}`);
+    if (preview) { preview.hidden = true; preview.setAttribute('aria-hidden', 'true'); }
+    document.body.classList.remove('tx-visual-dormant');
+    state.parked = false;
+    state.previous = null;
+    state.lastRestore = { reason, records: (typeof getSummary === 'function' ? getSummary()?.records : 0) || 0 };
+    record('restore', state.lastRestore);
+    return true;
+  };
+  const schedulePreviewFirstRestore = (reason = 'visible') => {
+    if (!state.parked) return false;
+    clearRestoreTimers();
+    const summary = (typeof getSummary === 'function' ? getSummary() : null) || {};
+    const viewport = viewportSnapshot();
+    const manualRestore = visualDormancyRequiresManualRestore(summary, viewport);
+    const delay = Number(visualDormancyRestoreDelay(summary, viewport) || restoreDelayMs || PREVIEW_FIRST_RESTORE_DELAY_MS);
+    const markPreview = () => {
+      state.lastResumePreview = {
+        reason,
+        delay: manualRestore ? 0 : Math.max(250, delay),
+        manualRestore,
+        records: Number(summary.records || 0)
+      };
+      record(manualRestore ? 'resume-preview-manual' : 'resume-preview', state.lastResumePreview);
+      if (manualRestore) return;
+      state.restoreTimer = window.setTimeout(() => {
+        state.restoreTimer = 0;
+        window.requestAnimationFrame?.(() => restoreNow(`${reason}:deferred`)) || restoreNow(`${reason}:deferred`);
+      }, Math.max(250, delay));
+    };
+    window.requestAnimationFrame?.(() => window.requestAnimationFrame?.(markPreview) || markPreview()) || markPreview();
+    return true;
+  };
+  const onVisibility = () => { if (document.hidden) { startReturnSettle('visibility-hidden'); park('visibility-hidden'); } else { schedulePreviewFirstRestore('visibility-visible'); finishReturnSettle('visibility-visible'); } };
+  const onPageHide = () => { startReturnSettle('pagehide'); park('pagehide'); };
+  const onPageShow = () => { schedulePreviewFirstRestore('pageshow'); finishReturnSettle('pageshow'); };
+  const onFreeze = () => { startReturnSettle('page-freeze'); park('page-freeze'); };
+  const onResume = () => { schedulePreviewFirstRestore('page-resume'); finishReturnSettle('page-resume'); };
+  const onBlur = () => { startReturnSettle('window-blur'); park('window-blur'); };
+  const onFocus = () => { schedulePreviewFirstRestore('window-focus'); finishReturnSettle('window-focus'); };
+  const onInteract = () => { if (state.parked) restoreNow('user-interaction'); };
+  document.addEventListener('visibilitychange', onVisibility);
+  document.addEventListener('freeze', onFreeze);
+  document.addEventListener('resume', onResume);
+  window.addEventListener('pagehide', onPageHide, { passive: true });
+  window.addEventListener('pageshow', onPageShow, { passive: true });
+  window.addEventListener('blur', onBlur, { passive: true });
+  window.addEventListener('focus', onFocus, { passive: true });
+  window.addEventListener('pointerdown', onInteract, { passive: true });
+  window.addEventListener('wheel', onInteract, { passive: true });
+  window.addEventListener('keydown', onInteract, { passive: true });
+  window.TiinexVisualDormancyReport = () => Object.assign({ schema: 'tiinex.visualDormancy.report.v1', parked: state.parked, returnSettleEnabled: RETURN_SETTLE_ENABLED }, state);
+  return () => {
+    clearRestoreTimers();
+    clearSettleTimer();
+    document.body.classList.remove('tx-return-settle');
+    document.removeEventListener('visibilitychange', onVisibility);
+    document.removeEventListener('freeze', onFreeze);
+    document.removeEventListener('resume', onResume);
+    window.removeEventListener('pagehide', onPageHide);
+    window.removeEventListener('pageshow', onPageShow);
+    window.removeEventListener('blur', onBlur);
+    window.removeEventListener('focus', onFocus);
+    window.removeEventListener('pointerdown', onInteract);
+    window.removeEventListener('wheel', onInteract);
+    window.removeEventListener('keydown', onInteract);
+    restoreNow('cleanup');
+  };
+}

package/src/app/workspaceContinuityNotices.js

@@ -0,0 +1,32 @@
+export function workspaceRecordOpenedNotice(result = {}) {
+  const title = result.entry?.title || result.entry?.path || 'workspace artifact';
+  const sourceInputs = Array.isArray(result.sourceInputs) ? result.sourceInputs : [];
+  const labels = sourceInputs.map((input) => input.label || input.repository).filter(Boolean);
+  if (result.openedWorkspaceSet) return `Opened workspace artifact ${title} as the active workspace set${labels.length ? `; source loading queued for ${labels.join(', ')}` : ''}. Previous non-draft workspaces were replaced; unpublished local work was preserved.`;
+  return labels.length
+    ? `Opened workspace artifact ${title}; source loading queued for ${labels.join(', ')}.`
+    : `Opened workspace artifact ${title}.`;
+}
+
+export function workspaceRecordMergedNotice(result = {}) {
+  const title = result.entry?.title || result.entry?.path || 'workspace artifact';
+  const sourceInputs = Array.isArray(result.sourceInputs) ? result.sourceInputs : [];
+  if (result.merge) {
+    const created = Number(result.merge.createdCount || 0);
+    const touched = Array.isArray(result.merge.touchedWorkspaceIds) ? result.merge.touchedWorkspaceIds.length : 0;
+    const skipped = Number(result.merge.skippedLoads || 0);
+    const bits = [created ? `${created} workspace${created === 1 ? '' : 's'} opened` : '', touched && !created ? `${touched} workspace${touched === 1 ? '' : 's'} refreshed` : '', sourceInputs.length ? `${sourceInputs.length} source load${sourceInputs.length === 1 ? '' : 's'} queued` : '', skipped ? `${skipped} already loaded` : ''].filter(Boolean);
+    return `Merged workspace artifact ${title}. ${bits.length ? bits.join(' · ') : 'No additional source loading was needed.'}`;
+  }
+  return sourceInputs.length
+    ? `Merged workspace artifact ${title}; source loading queued.`
+    : `Merged workspace artifact ${title}.`;
+}
+
+export function appConfigMaterializationNotice(input = {}, materializationLabel = '', baseNotice = '') {
+  const plan = String(input.appConfigPlan || '').trim();
+  if (!plan) return baseNotice;
+  const label = materializationLabel || input.label || input.repository || 'source';
+  const planLabel = plan === 'workspace-discovery' ? 'workspace discovery source' : 'workspace entrypoint source';
+  return `${label}: ${planLabel} materialized. ${baseNotice}`;
+}

package/src/app/workspaceDisplayCounts.js

@@ -0,0 +1,9 @@
+import { buildWorkspaceAuditView } from '../workspaces/workspace.auditView.js';
+import { buildDiscoveryDisplayOptionCounts } from '../workspaces/workspace.discoveryView.js';
+
+export function buildDisplayOptionCounts(workspace = {}) {
+  const records = Array.isArray(workspace.records) ? workspace.records : [];
+  const audit = buildWorkspaceAuditView(workspace, { records, query: '' });
+  const auditById = new Map((audit.items || []).map((item) => [item.id, item]));
+  return buildDiscoveryDisplayOptionCounts(workspace, { records, auditById });
+}

package/src/app/workspaceEntrypointIntakeCommand.js

@@ -0,0 +1,87 @@
+import { collectLocalFilesFromDataTransfer, materializeLocalMarkdownFiles } from '../adapters/local/local.adapter.js';
+import { mergeWorkspaceRecordAction, openWorkspaceRecordAction } from './workspaceRecordActions.js';
+import { assertCanonicalWorkspaceRuntimeState } from '../workspaces/workspace.runtimeCanonical.js';
+import { durableLocalMutationDecision, DurableLocalMutationOperation } from './durableLocalMutationPolicy.js';
+
+export async function prepareWorkspaceEntrypointIntake({ fileList = [], adapterResult = null, options = {} } = {}) {
+  const collectFiles = options.collectFiles || collectLocalFilesFromDataTransfer;
+  const materialize = options.materialize || materializeLocalMarkdownFiles;
+  const files = options.fromDataTransfer ? await collectFiles(fileList) : Array.from(fileList || []).filter(Boolean);
+  if (!files.length && !adapterResult) return { ok: false, error: 'workspace.entrypoint.files.empty', files: [], notice: 'No workspace file was available.' };
+  let result = adapterResult;
+  if (!result) {
+    try {
+      result = await materialize(files, { ...options, sourceMode: options.sourceMode || 'global-workspace-drop' });
+    } catch (exception) {
+      return { ok: false, error: 'workspace.entrypoint.materialize.failed', files, exception, notice: 'Could not read the workspace file.' };
+    }
+  }
+  const workspaceEntries = Array.isArray(result?.workspaceEntries) ? result.workspaceEntries : [];
+  const ordinaryRecords = Array.isArray(result?.records) ? result.records : [];
+  const assets = Array.isArray(result?.assets) ? result.assets : [];
+  if (!workspaceEntries.length) return { ok: false, error: 'workspace.entrypoint.none', files, adapterResult: result, notice: 'Drop local material into a workspace or use Add.' };
+  if (ordinaryRecords.length || assets.length) {
+    return { ok: false, error: 'workspace.entrypoint.mixed-global-material', files, adapterResult: result, workspaceEntries, notice: 'Drop workspace files alone outside a workspace, or drop mixed material into a specific workspace.' };
+  }
+  return { ok: true, files, adapterResult: result, workspaceEntries };
+}
+
+export async function runWorkspaceEntrypointIntakeCommand({
+  lifecycle,
+  state = {},
+  parseWorkspaceConfig,
+  fileList = [],
+  adapterResult = null,
+  mode = '',
+  options = {},
+  persistenceOwnership = null
+} = {}) {
+  const authority = durableLocalMutationDecision(persistenceOwnership, DurableLocalMutationOperation.localWorkspaceEntrypointIntake);
+  if (!authority.ok) return { ok: false, error: authority.error, state, notice: authority.notice, authority };
+  const prepared = await prepareWorkspaceEntrypointIntake({ fileList, adapterResult, options });
+  if (!prepared.ok) return Object.assign({ state }, prepared);
+  const requestedMode = String(mode || '').trim().toLowerCase();
+  const existingWorkspaces = Array.isArray(state?.workspaces) ? state.workspaces.length : 0;
+  if (!requestedMode && existingWorkspaces > 0) {
+    return Object.assign({}, prepared, { ok: false, requiresChoice: true, error: 'workspace.entrypoint.choice-required', state, choices: ['open', 'merge'] });
+  }
+  const actionMode = requestedMode === 'merge' ? 'merge' : 'open';
+  let nextState = state;
+  const sourceInputs = [];
+  const appliedEntries = [];
+  for (const entry of prepared.workspaceEntries) {
+    const record = workspaceRecordFromEntry(entry);
+    const result = actionMode === 'merge'
+      ? mergeWorkspaceRecordAction({ lifecycle, parseWorkspaceConfig, state: nextState, workspaceId: nextState.activeWorkspaceId || '', record })
+      : openWorkspaceRecordAction({ lifecycle, parseWorkspaceConfig, state: nextState, record });
+    if (!result?.ok) return Object.assign({}, prepared, { ok: false, error: result?.error || 'workspace.entrypoint.apply.failed', message: result?.message || 'Could not apply workspace entrypoint.', state: nextState, mode: actionMode, appliedEntries, sourceInputs });
+    nextState = result.state;
+    appliedEntries.push(entry);
+    sourceInputs.push(...(result.sourceInputs || []));
+  }
+  const canonicality = assertCanonicalWorkspaceRuntimeState(nextState, `global-workspace-entrypoint-${actionMode}`);
+  if (!canonicality.ok) return Object.assign({}, prepared, { ok: false, error: 'workspace.runtime-candidate-model-leak', state, canonicality, mode: actionMode });
+  return Object.assign({}, prepared, {
+    ok: true,
+    state: nextState,
+    mode: actionMode,
+    sourceInputs,
+    appliedEntries,
+    notice: actionMode === 'merge'
+      ? `Merged workspace entrypoint${appliedEntries.length === 1 ? '' : 's'} into the current workspace set.`
+      : `Opened workspace entrypoint${appliedEntries.length === 1 ? '' : 's'} as the current workspace set.`
+  });
+}
+
+function workspaceRecordFromEntry(entry = {}) {
+  const path = entry.path || 'workspace.workspace.md';
+  return {
+    id: `local-workspace-entrypoint:${path}`,
+    title: entry.title || path,
+    path,
+    markdown: String(entry.markdown || ''),
+    sourceMode: entry.sourceMode || 'local-workspace-file',
+    source: { id: 'local', kind: 'local-session', adapterId: 'local', sourceKind: 'local.session' },
+    workspaceArtifactRole: { schema: 'tiinex.workspace.artifact.role.v1', openEligible: true, mergeEligible: true, origin: 'global-local-intake' }
+  };
+}

package/src/app/workspaceEntrypointProductRouting.case.mjs

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const app = readFileSync(new URL('./TiinexApp.jsx', import.meta.url), 'utf8');
+const workspaceViews = readFileSync(new URL('../schemas/workspace/workspace.views.jsx', import.meta.url), 'utf8');
+const addViews = readFileSync(new URL('../schemas/workspace/workspace.add.views.jsx', import.meta.url), 'utf8');
+const choiceViews = readFileSync(new URL('../schemas/workspace/workspace.entrypointChoice.views.jsx', import.meta.url), 'utf8');
+const cards = readFileSync(new URL('../schemas/workspace/workspace.cards.views.jsx', import.meta.url), 'utf8');
+
+assert(app.includes('useWorkspaceEntrypointIntake'), 'page/global workspace intake must be wired through the workspace-entrypoint lifecycle hook');
+assert(app.includes('handleGlobalWorkspaceDrop(event.dataTransfer'), 'page/global drop must route through workspace entrypoint semantics');
+assert(app.includes("dialog === 'workspace-entrypoint-choice'"), 'existing workspace set must expose explicit Open/Merge choice for a global workspace entrypoint');
+assert.equal(app.includes('addTiinexAppConfig'), false, 'workspace-local Add must not own app/config lifecycle');
+assert.equal(addViews.includes('Tiinex app config'), false, 'Tiinex app config must not appear in Add-to-workspace');
+assert(workspaceViews.includes('event.stopPropagation(); if (event.dataTransfer) onDropFiles?.'), 'drop onto a concrete workspace must remain scoped material intake and must not bubble into page/global workspace application');
+assert(choiceViews.includes('How should Tiinex use this workspace?'), 'global workspace entrypoint choice uses the PoC product question');
+assert(/>\s*Open\s*</u.test(choiceViews) && />\s*Merge\s*</u.test(choiceViews), 'global workspace entrypoint choice exposes canonical Open/Merge');
+assert.equal(cards.includes('Source/local states are roles'), false, 'primary cards must not explain internal role architecture');
+
+console.log('✓ workspace entrypoint product routing guards passed');

package/src/app/workspaceExportCommand.js

@@ -0,0 +1,21 @@
+import { exportWorkspaceTreeDownload } from './workspaceExportDownload.js';
+
+export function executeWorkspaceTreeExportCommand(input = {}) {
+  const workspace = input.workspace;
+  if (!workspace) return { ok: false, error: 'workspace.missing', notice: 'No workspace to export.' };
+  const exportPlan = input.exportPlan || null;
+  if (exportPlan && exportPlan.execution?.available === false) {
+    return { ok: false, error: 'export.adapter.not.executable', notice: 'Selected export adapter is not executable yet.' };
+  }
+  try {
+    const download = input.download || exportWorkspaceTreeDownload;
+    const bundle = download(workspace, input.document || globalThis.document, input.window || globalThis.window || globalThis, { prebuiltBundle: exportPlan?.treeBundle || null });
+    return {
+      ok: true,
+      bundle,
+      notice: `Export tree ${bundle.status}: ${bundle.counts.files} file${bundle.counts.files === 1 ? '' : 's'} · TL0 local download · no package envelope.`
+    };
+  } catch (error) {
+    return { ok: false, error: 'export.tree.failed', exception: error, notice: 'Could not build tree export.' };
+  }
+}

package/src/app/workspaceExportDownload.js

@@ -0,0 +1,23 @@
+import { buildWorkspaceTreeExportBundle } from '@tiinex/core/export/tree.bundle.js';
+import { exportTreeZipBlob } from '@tiinex/core/export/package.zip.js';
+
+export function exportWorkspaceTreeDownload(workspace = {}, doc = globalThis.document, win = globalThis.window || globalThis, options = {}) {
+  const bundle = options?.prebuiltBundle || buildWorkspaceTreeExportBundle(workspace);
+  const blob = exportTreeZipBlob(bundle);
+  const url = win.URL.createObjectURL(blob);
+  const link = doc.createElement('a');
+  link.href = url;
+  link.download = exportTreeFilename(workspace, bundle);
+  link.rel = 'noopener';
+  doc.body.appendChild(link);
+  link.click();
+  link.remove();
+  win.setTimeout(() => win.URL.revokeObjectURL(url), 1000);
+  return bundle;
+}
+
+export function exportTreeFilename(workspace = {}, bundle = {}) {
+  const slug = String(workspace.title || workspace.name || workspace.id || 'workspace').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 48) || 'workspace';
+  const stamp = String(bundle.builtAt || new Date().toISOString()).replace(/[^0-9]/g, '').slice(0, 14) || 'session';
+  return `tiinex-tree-${slug}-${stamp}.zip`;
+}

package/src/app/workspaceExportExecutionCommand.js

@@ -0,0 +1,10 @@
+import { executeWorkspaceTreeExportCommand } from './workspaceExportCommand.js';
+import { executeWorkspaceHandoffExportCommand } from './workspaceHandoffExport.js';
+
+export function executeWorkspaceExportCommand(input = {}) {
+  const action = String(input.exportPlan?.execution?.action || 'download-tree-zip');
+  if (action === 'download-handoff-package') return executeWorkspaceHandoffExportCommand(input);
+  if (action === 'download-tree-zip') return executeWorkspaceTreeExportCommand(input);
+  if (action === 'guided-github-publication') return { ok: false, error: 'github-publication.guided-routine-required', notice: 'Use the guided Copy / Open / Verify routine; Tiinex does not perform a hidden GitHub write.' };
+  return { ok: false, error: 'export.mode.not-executable', notice: 'Selected export mode is not executable.' };
+}