@tiinex/app 0.1.1

package/src/schemas/workspace/workspace.viewFormatting.js

@@ -0,0 +1,172 @@
+import { RecordActionKind } from '@tiinex/core/actions/record.actions.js';
+import { recordLogicalPath } from '@tiinex/core/workspaces/workspace.recordPaths.js';
+import { sourceBoundaryClass } from '@tiinex/core/workspaces/workspace.materialRole.js';
+
+
+export function assetSourceBadge(asset = {}) {
+  const boundary = sourceBoundaryClass(asset);
+  if (boundary === 'source-backed') return 'source-backed';
+  if (boundary === 'local') return 'local/session';
+  return 'source unknown';
+}
+
+export function assetSourceBoundary(asset = {}) {
+  const declared = String(asset?.source?.boundary || asset?.boundary || '').trim();
+  if (declared) return declared;
+  const boundary = sourceBoundaryClass(asset);
+  if (boundary === 'source-backed') return 'Source-backed asset material/reference; preview availability is separate from source provenance.';
+  if (boundary === 'local') return 'Browser-local asset; no GitHub provenance inferred.';
+  return 'Asset source boundary is unresolved; no provenance inferred.';
+}
+
+export function assetPreviewSummary(asset = {}) {
+  const boundary = sourceBoundaryClass(asset);
+  const size = Number(asset?.size || 0);
+  if (boundary === 'source-backed') return size > 0
+    ? `${size} bytes described for a source-backed asset; preview availability is separate.`
+    : 'Source-backed asset/reference preserved without inventing preview availability.';
+  if (boundary === 'local') return size > 0
+    ? `${size} bytes preserved as local asset.`
+    : 'Preserved as a local asset, not a fake leaf.';
+  return size > 0
+    ? `${size} bytes described; source ownership is unresolved.`
+    : 'Asset metadata preserved; source ownership is unresolved.';
+}
+
+export function compactPath(path = '') {
+  const value = String(path || '').trim();
+  if (value.length <= 44) return value;
+  const parts = value.split('/').filter(Boolean);
+  if (parts.length <= 2) return `…${value.slice(-41)}`;
+  return `${parts[0]}/…/${parts.slice(-2).join('/')}`;
+}
+
+
+export function recordDisplayPath(record = {}) {
+  return recordLogicalPath(record);
+}
+
+export function compactRecordDate(record = {}) {
+  const raw = record.currentCreatedAt || record.createdAt || record.date || '';
+  const text = String(raw || '').trim();
+  if (!text) return '';
+  const match = text.match(/\d{4}-\d{2}-\d{2}/);
+  return match ? match[0] : text.slice(0, 10);
+}
+
+export function recordSchemaOpenValue(record = {}) {
+  return String(record.schemaId || record.currentSchemaId || record.envelopeSchemaId || '').trim();
+}
+
+
+export function recordSchemaCanOpen(record = {}) {
+  const text = recordSchemaOpenValue(record).toLowerCase();
+  return Boolean(text && !['artifact', 'plain', 'markdown', 'unknown'].includes(text));
+}
+
+export function recordSchemaBadge(record = {}) {
+  const text = recordSchemaOpenValue(record);
+  if (!text) return 'artifact';
+  return text.replace(/^tiinex\./, '').replace(/\.v\d+$/, '');
+}
+
+export function recordMaterialBadge(record = {}) {
+  const status = String(record?.materialReconciliation?.status || '').trim();
+  if (status === 'checksum-match') return record.materialReconciliation.displayLabel || 'source + local';
+  if (status === 'source-canonical-pruned-local-duplicate' || status === 'local-duplicate-pruned-source-canonical') return 'source-backed';
+  if (status === 'local-shadowed-by-source') return record.materialReconciliation.displayLabel || 'local snapshot';
+  if (status === 'checksum-mismatch') return record.materialReconciliation.displayLabel || 'material mismatch';
+  if (status === 'same-origin-unverified') return record.materialReconciliation.displayLabel || 'same origin · unverified';
+  if (status === 'source-only-after-local-clear') return 'source only';
+  if (status === 'source-removed-local-restored') return 'local restored';
+  return '';
+}
+
+export function recordSourceBadge(record = {}) {
+  const source = record.source || {};
+  if (source.label) return source.label;
+  if (source.repo) return source.repo;
+  if (source.adapterId && source.adapterId !== 'local') return source.adapterId;
+  return 'Local';
+}
+
+export function recordLifecycleBadge(record = {}) {
+  const values = [record.lifecycleStatus, record.currentStatus, record.status, record.envelope?.current?.status];
+  const text = values.map((value) => String(value || '').trim()).find(Boolean) || '';
+  if (!text) return '';
+  const clean = text.toLowerCase();
+  if (clean === 'schema ok' || clean === 'local') return '';
+  return text;
+}
+
+export function actionClassName(action = {}) {
+  const id = action.id;
+  const isTransition = String(id || '').startsWith('record.transition:');
+  const labeled = id === RecordActionKind.continue || id === RecordActionKind.reference || id === RecordActionKind.editLocal || id === RecordActionKind.workspaceOpen || id === RecordActionKind.workspaceMerge;
+  const danger = id === RecordActionKind.deleteLocal;
+  const side = isTransition || id === RecordActionKind.continue || id === RecordActionKind.reference || id === RecordActionKind.workspaceOpen || id === RecordActionKind.workspaceMerge ? 'tx-action-right' : 'tx-action-left';
+  return ['tx-button', 'tx-button-ghost', 'tx-legacy-action', isTransition ? 'tx-transition-action' : '', danger ? 'tx-danger tx-delete-local-action' : '', labeled ? 'tx-labeled-action' : '', side].filter(Boolean).join(' ');
+}
+
+export function actionLabel(action = {}) {
+  if (action.id === RecordActionKind.open) return 'Details';
+  if (action.id === RecordActionKind.markdown) return 'Show markdown';
+  if (action.id === RecordActionKind.lineage) return 'Anchor';
+  if (action.id === RecordActionKind.workspaceOpen) return 'Open';
+  if (action.id === RecordActionKind.workspaceMerge) return 'Merge';
+  if (action.id === RecordActionKind.editLocal) return 'Edit local draft';
+  if (action.id === RecordActionKind.deleteLocal) return 'Delete local draft';
+  return action.label;
+}
+
+export function validationStateLabel(value = '') {
+  const state = String(value || '').trim();
+  if (state === 'exact-schema-validated') return 'schema validation ran';
+  if (state === 'root-validated') return 'root validation ran';
+  if (state === 'root-only-child-validator-unavailable') return 'root only · validator unavailable';
+  if (state === 'not-run-body-unavailable') return 'not run · body missing';
+  if (state === 'not-applicable-supporting') return 'not applicable';
+  if (state === 'validation-unknown') return 'validation unknown';
+  return state || 'validation unknown';
+}
+
+export function validatorLabel(childValidator = '', coverage = '') {
+  const child = String(childValidator || '').trim();
+  const cov = String(coverage || '').trim();
+  if (child === 'run') return 'exact child validator ran';
+  if (child === 'unavailable') return 'child validator unavailable';
+  if (child === 'skipped') return 'skipped until body loads';
+  if (child === 'not-applicable') return cov === 'root-exact' ? 'Root validator only' : 'not applicable';
+  return child || cov || 'validator unknown';
+}
+
+export function readStateLabel(value = '') {
+  const state = String(value || '').trim();
+  if (state === 'schema-owned') return 'schema-owned';
+  if (state === 'root-readable') return 'root-readable';
+  if (state === 'root-fallback') return 'root fallback';
+  if (state === 'unavailable-body') return 'body unavailable';
+  if (state === 'unknown-schema') return 'unknown schema';
+  return state || 'read state unknown';
+}
+
+export function schemaCoverageLabel(value = '') {
+  const state = String(value || '').trim();
+  if (state === 'exact-companion') return 'exact companion';
+  if (state === 'unknown-schema') return 'unknown schema';
+  if (state === 'missing-schema') return 'missing schema';
+  return state || 'schema unknown';
+}
+
+export function materialLedgerReceiptSummary(receipt = {}) {
+  const bits = [];
+  if (Number(receipt.rawAdapterRecords || 0)) bits.push(`${Number(receipt.rawAdapterRecords || 0)} adapter records`);
+  if (Number(receipt.sourceRecords || 0)) bits.push(`${Number(receipt.sourceRecords || 0)} inserted`);
+  if (Number(receipt.visibleSourceRecords || receipt.visibleRecords || 0)) bits.push(`${Number(receipt.visibleSourceRecords || receipt.visibleRecords || 0)} visible`);
+  if (Number(receipt.hiddenSourceRecords || receipt.hiddenRecords || 0)) bits.push(`${Number(receipt.hiddenSourceRecords || receipt.hiddenRecords || 0)} hidden`);
+  if (Number(receipt.groupedSourceRecords || receipt.groupedRecords || 0)) bits.push(`${Number(receipt.groupedSourceRecords || receipt.groupedRecords || 0)} grouped`);
+  if (Number(receipt.sourceWorkspaceArtifacts || 0)) bits.push(`${Number(receipt.sourceWorkspaceArtifacts || 0)} workspace artifact${Number(receipt.sourceWorkspaceArtifacts || 0) === 1 ? '' : 's'}`);
+  return bits.join(' · ') || 'material ledger unavailable';
+}
+
+export const recordSchemaFilterValue = recordSchemaOpenValue;

package/src/schemas/workspace/workspace.views.jsx

@@ -0,0 +1,210 @@
+import React, { useEffect, useMemo, useRef } from 'react';
+import { Button } from '../../ui/primitives/Button.jsx';
+import { isWorkspaceRecord } from '@tiinex/core/actions/record.actions.js';
+import { Icon } from '../../ui/primitives/Icon.jsx';
+import { presentWorkspaceFeed, presentWorkspaceTree } from '@tiinex/core/schemas/workspace/tiinex.workspace.v1.presenter.js';
+import { summarizeWorkspaceMaterial } from '../../workspaces/workspace.summary.js';
+import { buildWorkspaceLineageView } from '../../workspaces/workspace.lineageView.js';
+import { buildDiscoveryMaterialIndex, buildWorkspaceDiscoveryView } from '../../workspaces/workspace.discoveryView.js';
+import { buildWorkspaceAuditView } from '../../workspaces/workspace.auditView.js';
+import { normalizeWorkspaceDisplayOptions } from '../../workspaces/workspace.displayOptions.js';
+import { WorkspaceBoundaryKicker, SourceStrip, WorkspaceDropHint, WorkspaceMaterialSummary, ModeToolbar, ProgressStrip, EmptyWorkspaceState } from './workspace.chrome.views.jsx';
+import { DiscoveryRecordList } from './workspace.discovery.views.jsx';
+import { WorkspaceTreeState } from './workspace.tree.views.jsx';
+import { WorkspaceAuditState } from './workspace.audit.views.jsx';
+import { WorkspaceLineageState } from './workspace.lineage.views.jsx';
+import { transitionProductContextForWorkspace } from '../../transitions/transition.productPresentation.browser.js';
+import { TimePortalBanner, TimePortalCompactMarker } from './workspace.timePortal.views.jsx';
+import { WorkspaceSelectionSurface } from './workspace.selection.views.jsx';
+
+const WorkspaceGraphState = React.lazy(() => import('./workspace.graph.views.jsx').then((module) => ({ default: module.WorkspaceGraphState })));
+
+export { AssetDetailDialog } from './workspace.cards.views.jsx';
+export { RecordDetailDialog, RecordMarkdownDialog, RecordActionDialog, CreateWorkspaceDialog, RenameWorkspaceDialog, CloseWorkspaceDialog } from './workspace.recordDialogs.views.jsx';
+export { WorkspaceCanonicalCreateDialog } from './workspace.canonicalTaskDialog.views.jsx';
+export { GovernanceBoundaryDialog } from './workspace.governance.views.jsx';
+
+function auditIndexForWorkspace(workspace = {}, records = []) {
+  const audit = buildWorkspaceAuditView(workspace, { records, query: '' });
+  return new Map((audit.items || []).map((item) => [item.id, item]));
+}
+
+function selectedRecordFrom(workspace = {}, selectedRecordId = '') {
+  const records = Array.isArray(workspace.records) ? workspace.records : [];
+  return records.find((record) => record.id === selectedRecordId) || null;
+}
+
+function lineageControlsReadyForTraversal(traversal = null) {
+  if (!traversal) return false;
+  const state = String(traversal.terminalState || traversal.status?.terminalState || '').trim();
+  if (traversal.noParentDeclared === true) return true;
+  if (['root-reached', 'root-reached-scope-transition', 'no-parent-declared', 'target-unavailable', 'ambiguous-parent', 'integrity-mismatch'].includes(state)) return true;
+  return traversal.complete === true;
+}
+
+export const WorkspaceColumnSurface = React.memo(function WorkspaceColumnSurface({ workspace, state, referenceRecords = [], graphWorkspaces = [], selectionSession = null, onSelectionChoose, onSelectionCancel, layoutMode = 'expanded', onLayoutMode, onClose, onRenameWorkspace, onVerse, onQuery, onOpenDisplayOptions, onOpenAddDialog, onOpenCreateArtifact, onShareWorkspace, onExportWorkspace, onCloseSource, onDropFiles, onOpenRecord, onOpenGraphRecord, onFocusRecordLineage, onOpenAsset, onShareRecord, onRecordAction, onOpenSchema, onToggleTreeFolder, onSourceTransportRefresh, onOpenGovernance, onViewScroll, stageScrollTop, expandedLineageRecordIds = [], lineageAuditReport = null, lineageLoadReport = null, onToggleLineageCard, onRunLineageAudit, onLoadFullLineage, timePortal = null, historicalReadModel = null, readOnlyHistorical = false, onLoadHistoricalSnapshot, onReturnToLatest }) {
+  const stageRef = useRef(null);
+  const restoreKey = `${workspace?.id || 'workspace'}:${state.view?.workspaceVerse || 'feed'}:${state.view?.query || ''}:${state.view?.selectedRecordId || ''}`;
+  useEffect(() => {
+    const stage = stageRef.current;
+    if (!stage) return;
+    const top = Number(stageScrollTop || 0);
+    stage.scrollTop = Number.isFinite(top) && top > 0 ? top : 0;
+  }, [restoreKey, stageScrollTop]);
+  const sources = Array.isArray(workspace.sources) ? workspace.sources : [];
+  const requestedVerse = state.view?.workspaceVerse || 'feed';
+  const selectionActive = Boolean(selectionSession?.ok);
+  const selectionVerse = String(selectionSession?.presentation?.verse || '');
+  const verse = selectionActive && ['feed', 'tree'].includes(selectionVerse) ? selectionVerse : readOnlyHistorical && !['feed', 'tree', 'graph'].includes(requestedVerse) ? 'feed' : requestedVerse;
+  const lineageVerse = verse === 'lineage';
+  const allRecords = Array.isArray(workspace.records) ? workspace.records : [];
+  const transitionProductActionsVisible = !selectionActive && !readOnlyHistorical && (verse === 'feed' || verse === 'lineage');
+  const transitionProductContext = useMemo(() => (transitionProductActionsVisible
+    ? transitionProductContextForWorkspace({ workspaceRecords: allRecords, referenceRecords })
+    : null), [transitionProductActionsVisible, allRecords, referenceRecords]);
+  const selectedRecordId = String(state.view?.selectedRecordId || '');
+  const lineageTraversalPreview = useMemo(() => (lineageVerse && selectedRecordId
+    ? buildWorkspaceLineageView(workspace, { records: allRecords, query: '', selectedRecordId }).selectedTraversal
+    : null), [lineageVerse, selectedRecordId, workspace, allRecords]);
+  const lineageAlreadyReady = lineageControlsReadyForTraversal(lineageTraversalPreview);
+  const lineageLoadReady = Boolean(lineageVerse && selectedRecordId && (lineageAlreadyReady || (lineageLoadReport && String(lineageLoadReport.selectedRecordId || '') === String(state.view?.selectedRecordId || ''))));
+  const discoveryQuery = state.view?.query || '';
+  const lineageQuery = lineageLoadReady ? (state.view?.lineageQuery || '') : '';
+  const query = lineageVerse ? lineageQuery : discoveryQuery;
+  const displayOptions = useMemo(() => normalizeWorkspaceDisplayOptions(state.view?.displayOptions), [state.view?.displayOptions]);
+  const selectedRecord = selectedRecordFrom(workspace, selectedRecordId);
+  const materialIndex = useMemo(() => buildDiscoveryMaterialIndex(allRecords), [allRecords]);
+  const auditById = useMemo(() => auditIndexForWorkspace(workspace, allRecords), [workspace, allRecords]);
+  const allAssets = useMemo(() => (Array.isArray(workspace.assets) ? workspace.assets : []), [workspace.assets]);
+  const workspaceArtifactCount = useMemo(() => allRecords.filter(isWorkspaceRecord).length, [allRecords]);
+  const discoveryView = useMemo(() => buildWorkspaceDiscoveryView(workspace, {
+    records: allRecords,
+    assets: allAssets,
+    displayOptions,
+    query: discoveryQuery,
+    auditById,
+    materialIndex
+  }), [workspace, allRecords, allAssets, displayOptions, discoveryQuery, auditById, materialIndex]);
+  const selectionCandidates = useMemo(() => (Array.isArray(selectionSession?.candidates) ? selectionSession.candidates : []).filter((item) => item?.enabled !== false && String(item.workspaceId || '') === String(workspace?.id || '')), [selectionSession, workspace?.id]);
+  const selectionRecordIds = useMemo(() => new Set(selectionCandidates.filter((item) => item?.id).map((item) => String(item.id))), [selectionCandidates]);
+  const records = selectionActive && verse !== 'tree' ? allRecords.filter((record) => selectionRecordIds.has(String(record.id))) : discoveryView.records;
+  const assets = selectionActive ? [] : discoveryView.assets;
+  const hasMaterial = Boolean(allRecords.length || allAssets.length);
+  const isFilteredEmpty = Boolean(hasMaterial && !records.length && !assets.length);
+  const presentation = useMemo(() => (verse === 'tree'
+    ? presentWorkspaceTree(workspace, { verse, query: discoveryQuery })
+    : presentWorkspaceFeed(workspace, { verse, query: discoveryQuery })), [workspace, verse, discoveryQuery]);
+  const materialSummary = useMemo(() => summarizeWorkspaceMaterial(workspace), [workspace]);
+  const interactionRevision = [
+    state.activeWorkspaceId || '',
+    workspace?.id || '',
+    state.view?.workspaceVerse || '',
+    state.view?.selectedRecordId || '',
+    allRecords.length,
+    allAssets.length,
+    sources.map((source) => `${source.id || source.label || ''}:${source.discoveryState || ''}:${Number(source.count || 0)}`).join('|')
+  ].join('::');
+  if (layoutMode === 'compact') {
+    return (
+      <section className="tx-workspace-window tx-workspace-window-compact tx-schema-workspace-surface" aria-label={`Compact workspace ${presentation.title || ''}`.trim()} data-schema-id="tiinex.workspace.v1" data-workspace-layout="compact">
+        <div className="tx-workspace-compact-inner">
+          <Button icon="expand" variant="ghost" shape="round" aria-label={`Expand workspace ${presentation.title || ''}`.trim()} title="Expand workspace" onClick={() => onLayoutMode?.('expanded')} />
+          {readOnlyHistorical ? (
+            <div className="tx-workspace-compact-historical">
+              <TimePortalCompactMarker timePortal={timePortal} />
+              <div className="tx-workspace-compact-title tx-workspace-compact-title-readonly" title={`Historical workspace review · ${presentation.title || ''}`.trim()}>{presentation.title}</div>
+            </div>
+          ) : <button type="button" className="tx-workspace-compact-title" title="Rename workspace" onClick={onRenameWorkspace}>{presentation.title}</button>}
+          <div className="tx-workspace-compact-stats" aria-label={`${allRecords.length} records, ${allAssets.length} assets, ${sources.length} sources`}>
+            <span><Icon name="manualFiles" />{allRecords.length}</span>
+            <span><Icon name="asset" />{allAssets.length}</span>
+            <span><Icon name="source" />{sources.length}</span>
+          </div>
+          <Button icon="close" variant="ghost" shape="round" aria-label={`Close workspace ${presentation.title || ''}`.trim()} title="Close workspace" onClick={onClose} />
+        </div>
+      </section>
+    );
+  }
+
+  return (
+    <section className="tx-workspace-window tx-column-window tx-uc001-created-workspace tx-schema-workspace-surface tx-compact-column-window" aria-label="Tiinex workspace window" data-schema-id="tiinex.workspace.v1" data-workspace-layout="expanded" onDragOver={(event) => event.preventDefault()} onDrop={(event) => { event.preventDefault(); event.stopPropagation(); if (event.dataTransfer) onDropFiles?.(event.dataTransfer, { sourceMode: 'workspace-drop', fromDataTransfer: true }); }}>
+      <header className="tx-window-header tx-workspace-schema-header tx-compact-window-header">
+        <div className="tx-window-title-block">
+          <h1>
+            <button type="button" className="tx-workspace-title-rename-button" title={readOnlyHistorical ? 'Historical workspace review' : 'Rename workspace'} aria-label={`${readOnlyHistorical ? 'Historical workspace review' : 'Rename workspace'} ${presentation.title || ''}`.trim()} onClick={readOnlyHistorical ? undefined : onRenameWorkspace}>
+              <span>{presentation.title}</span>
+              <Icon name="edit" />
+            </button>
+          </h1>
+          <WorkspaceBoundaryKicker workspace={workspace} />
+        </div>
+        <div className="tx-window-actions tx-compact-window-actions" aria-label="Workspace actions">
+          <span className="tx-stat-pill" title="Visible records after Display options"><Icon name="manualFiles" />{records.length}</span>
+          <span className="tx-stat-pill" title="Local assets"><Icon name="asset" />{allAssets.length}</span>
+          <span className="tx-stat-pill" title="Workspace artifacts"><Icon name="workspace" />{workspaceArtifactCount}</span>
+          <span className="tx-stat-pill" title="Sources"><Icon name="source" />{sources.length}</span>
+          {!readOnlyHistorical ? <Button icon="create" variant="primary" aria-label="Create artifact" title="Create artifact" onClick={onOpenCreateArtifact}>Create</Button> : null}
+          {!readOnlyHistorical ? <Button icon="add" variant="primary" shape="round" aria-label="Add to workspace" title="Add to workspace" onClick={onOpenAddDialog} /> : null}
+          <Button icon="shareNodes" variant="ghost" shape="round" aria-label="Share workspace" title="Share workspace" onClick={onShareWorkspace} />
+          {!readOnlyHistorical ? <Button icon="edit" variant="ghost" shape="round" aria-label="Rename workspace" title="Rename workspace" onClick={onRenameWorkspace} /> : null}
+          {!readOnlyHistorical ? <Button icon="download" variant="ghost" shape="round" aria-label="Prepare workspace export" title="Prepare workspace export" onClick={onExportWorkspace} /> : null}
+          <Button icon="collapse" variant="ghost" shape="round" aria-label="Collapse workspace" title="Collapse workspace" onClick={() => onLayoutMode?.('compact')} />
+          <Button icon="close" variant="ghost" shape="round" aria-label="Close workspace" title="Close workspace" onClick={onClose} />
+        </div>
+      </header>
+      <TimePortalBanner timePortal={timePortal} readModel={historicalReadModel} onLoadSnapshot={onLoadHistoricalSnapshot} onReturnLatest={onReturnToLatest} />
+      <SourceStrip readOnly={readOnlyHistorical} workspace={workspace} boundary={presentation.sourceBoundary} onCloseSource={onCloseSource} onOpenAddDialog={onOpenAddDialog} onSourceTransportRefresh={onSourceTransportRefresh} onOpenGovernance={onOpenGovernance} />
+      {selectionActive ? <WorkspaceSelectionSurface session={selectionSession} onCancel={onSelectionCancel} /> : null}
+      {!readOnlyHistorical && !selectionActive ? <WorkspaceDropHint workspace={workspace} hasMaterial={hasMaterial} /> : null}
+      <WorkspaceMaterialSummary summary={materialSummary} />
+      <ModeToolbar readOnly={readOnlyHistorical} state={state} query={query} displayOptions={displayOptions} selectedRecord={selectedRecord} lineageLoadReport={lineageLoadReport} lineageReady={lineageLoadReady} onVerse={onVerse} onQuery={onQuery} onOpenDisplayOptions={onOpenDisplayOptions} onRunLineageAudit={onRunLineageAudit} onLoadFullLineage={onLoadFullLineage} />
+      <ProgressStrip workspace={workspace} />
+      <section ref={stageRef} className="tx-primary-stage tx-column-primary-stage" aria-label="Column feed" onScroll={(event) => onViewScroll?.(verse, event.currentTarget.scrollTop)} data-workspace-verse={verse}>
+        {verse === 'tree'
+          ? <WorkspaceTreeState workspace={workspace} query={selectionActive ? '' : query} records={selectionActive ? allRecords : records} assets={assets} auditById={auditById} expandedFolders={state.view?.expandedTreeFolders} onToggleTreeFolder={onToggleTreeFolder} onOpenRecord={onOpenRecord} onFocusRecordLineage={onFocusRecordLineage} onOpenAsset={onOpenAsset} readOnly={readOnlyHistorical || selectionActive} selectionActive={selectionActive} selectionCandidates={selectionCandidates} onSelectCandidate={onSelectionChoose} />
+          : verse === 'graph'
+            ? <React.Suspense fallback={<div className="tx-graph-loading" role="status">Loading Node Graph Verse…</div>}><WorkspaceGraphState workspace={workspace} graphWorkspaces={graphWorkspaces} query={query} selectedRecordId={selectedRecordId} onOpenRecord={onOpenGraphRecord} readOnly={readOnlyHistorical} /></React.Suspense>
+          : verse === 'lineage'
+            ? <WorkspaceLineageState workspace={workspace} query={query} records={allRecords} selectedRecordId={selectedRecordId} auditById={auditById} onOpenRecord={onOpenRecord} onRecordAction={onRecordAction} onFocusRecordLineage={onFocusRecordLineage} onShareRecord={onShareRecord} onOpenSchema={onOpenSchema} lineageAuditReport={lineageAuditReport} lineageLoadReport={lineageLoadReport} lineageReady={lineageLoadReady} expandedRecordIds={expandedLineageRecordIds} displayOptions={displayOptions} onToggleLineageCard={onToggleLineageCard} actionStateKey={interactionRevision} workspaceRecords={allRecords} workspaceId={workspace.id} transitionProductContext={transitionProductContext} />
+          : verse === 'audit'
+            ? <WorkspaceAuditState workspace={workspace} query={query} records={allRecords} assets={allAssets} onOpenRecord={onOpenRecord} />
+          : (records.length || assets.length)
+            ? <DiscoveryRecordList
+                records={records}
+                assets={assets}
+                stageScrollTop={stageScrollTop}
+                auditById={auditById}
+                actionStateKey={interactionRevision}
+                workspaceRecords={allRecords}
+                workspaceId={workspace.id}
+                transitionProductContext={transitionProductContext}
+                onOpenRecord={onOpenRecord}
+                onFocusRecordLineage={onFocusRecordLineage}
+                onShareRecord={onShareRecord}
+                onRecordAction={onRecordAction}
+                onOpenSchema={onOpenSchema}
+                onOpenAsset={onOpenAsset}
+                readOnly={readOnlyHistorical || selectionActive}
+                selectionActive={selectionActive}
+                selectionCandidates={selectionCandidates}
+                onSelectCandidate={onSelectionChoose}
+              />
+            : <EmptyWorkspaceState filtered={isFilteredEmpty} hasMaterial={hasMaterial} query={query} summary={materialSummary} progress={workspace.discoveryProgress} />}
+      </section>
+    </section>
+  );
+}, workspaceColumnSurfacePropsEqual);
+
+function workspaceColumnSurfacePropsEqual(previous = {}, next = {}) {
+  return previous.workspace === next.workspace
+    && previous.state === next.state
+    && previous.referenceRecords === next.referenceRecords
+    && previous.graphWorkspaces === next.graphWorkspaces
+    && previous.selectionSession === next.selectionSession
+    && previous.expandedLineageRecordIds === next.expandedLineageRecordIds
+    && previous.lineageAuditReport === next.lineageAuditReport
+    && previous.lineageLoadReport === next.lineageLoadReport
+    && previous.timePortal === next.timePortal
+    && previous.historicalReadModel === next.historicalReadModel
+    && previous.readOnlyHistorical === next.readOnlyHistorical;
+}

package/src/source-settings/sourceSettings.model.js

@@ -0,0 +1,7 @@
+export const sourceSettingsModel = {
+  type: 'tiinex.web.source-settings.model.v1',
+  owner: 'src/source-settings',
+  modes: ['static-fixture', 'local-file', 'draft', 'github-source-backed'],
+  invariant: 'local, draft, and static material remain non-GitHub unless an explicit source descriptor exists',
+  ergonomics: 'source state should remain visible as compact chips; detailed explanation belongs in expandable controls'
+};

package/src/sources/draft/draft.source.js

@@ -0,0 +1 @@
+export function draftSource(id) { return { kind: 'draft', id }; }

package/src/sources/github/github.loader.js

@@ -0,0 +1,204 @@
+import { createRecordFromMarkdown } from '@tiinex/core/artifacts/artifact.record.js';
+
+function isHttps(url) {
+  return /^https:\/\//i.test(url);
+}
+
+function normalizeLoadTarget(item, index = 0) {
+  if (item && typeof item === 'object') {
+    const ref = String(item.ref || item.path || item.url || item.target || '').trim();
+    return {
+      ref,
+      surface: String(item.surface || item.sourceSurface || 'explicitFiles').trim() || 'explicitFiles',
+      targetKind: String(item.targetKind || item.kind || 'github-markdown').trim() || 'github-markdown',
+      inputTarget: String(item.inputTarget || item.original || item.ref || ref).trim() || ref,
+      targetIndex: Number.isFinite(Number(item.targetIndex)) ? Number(item.targetIndex) : index
+    };
+  }
+  const ref = String(item || '').trim();
+  return { ref, surface: 'explicitFiles', targetKind: 'github-markdown', inputTarget: ref, targetIndex: index };
+}
+
+function targetAttribution(target = {}) {
+  return {
+    surface: target.surface || 'explicitFiles',
+    targetKind: target.targetKind || 'github-markdown',
+    inputTarget: target.inputTarget || target.ref || '',
+    targetIndex: Number.isFinite(Number(target.targetIndex)) ? Number(target.targetIndex) : 0
+  };
+}
+
+function toRawFromBlobUrl(url) {
+  // https://github.com/:owner/:repo/blob/:ref/:path -> https://raw.githubusercontent.com/:owner/:repo/:ref/:path
+  const u = new URL(url);
+  const parts = u.pathname.split('/').filter(Boolean);
+  // parts: [owner, repo, 'blob', ref, ...path]
+  if (parts.length < 5) throw new Error('invalid blob URL');
+  const owner = parts[0];
+  const repo = parts[1];
+  const ref = parts[3];
+  const path = parts.slice(4).join('/');
+  return `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path}`;
+}
+
+function rootPaths(source) {
+  return String(source?.rootPath || '')
+    .split(/\r?\n|,/)
+    .map((item) => item.trim().replace(/^\.\//, '').replace(/^\/+/, '').replace(/\/+$/, ''))
+    .filter((item) => item && item !== '.');
+}
+
+function sourceRepo(source) {
+  const srcRepo = String(source?.repo || source?.repository || '').trim().toLowerCase();
+  if (!srcRepo) throw new Error('source.repo missing');
+  return srcRepo;
+}
+
+function normalizeRelativePath(source, ref) {
+  const relative = String(ref || '').trim().replace(/^\/+/, '').replace(/\\/g, '/').replace(/\/{2,}/g, '/');
+  const roots = rootPaths(source);
+  if (!roots.length) return relative;
+  const matchingRoot = roots.find((root) => relative === root || relative.startsWith(root + '/')) || roots[0];
+  return relative === matchingRoot || relative.startsWith(matchingRoot + '/') ? relative : `${matchingRoot}/${relative}`;
+}
+
+export function normalizeGithubRefToRaw(source, ref) {
+  const srcRepo = sourceRepo(source);
+  const trimmed = String(ref || '').trim();
+  if (!trimmed) throw new Error('empty ref');
+
+  // Absolute URL handling: explicitly reject unsupported hosts or non-https.
+  const looksAbsolute = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed);
+  if (looksAbsolute) {
+    const u = new URL(trimmed);
+    if (u.protocol !== 'https:') throw new Error('non-https URL');
+    if (u.hostname === 'raw.githubusercontent.com') {
+      const parts = u.pathname.split('/').filter(Boolean);
+      if (parts.length < 4) throw new Error('invalid raw GitHub URL');
+      const ownerRepo = `${parts[0]}/${parts[1]}`.toLowerCase();
+      if (ownerRepo !== srcRepo) throw new Error('cross-repo URL not allowed');
+      return u.href;
+    }
+    if (u.hostname === 'github.com' && /\/blob\//.test(u.pathname)) {
+      const raw = toRawFromBlobUrl(u.href);
+      const parts = new URL(raw).pathname.split('/').filter(Boolean);
+      const ownerRepo = `${parts[0]}/${parts[1]}`.toLowerCase();
+      if (ownerRepo !== srcRepo) throw new Error('cross-repo blob URL not allowed');
+      return raw;
+    }
+    // Explicit absolute URL but unsupported host: reject.
+    throw new Error('unsupported host');
+  }
+
+  const sourceRef = String(source.ref || '').trim();
+  if (!sourceRef) throw new Error('source.ref missing for repo-relative path');
+  const path = normalizeRelativePath(source, trimmed);
+  const [owner, repo] = srcRepo.split('/');
+  return `https://raw.githubusercontent.com/${owner}/${repo}/${sourceRef}/${path}`;
+}
+
+
+function exactCommitFromRawUrl(url = '') {
+  try {
+    const parts = new URL(url).pathname.split('/').filter(Boolean);
+    const ref = parts[2] || '';
+    return /^[0-9a-f]{40}$/i.test(ref) ? ref : '';
+  } catch (_) { return ''; }
+}
+
+export async function loadGithubFilesForSource(source, fileRefs = [], options = {}) {
+  const fetchImpl = options.fetchImpl || (typeof fetch !== 'undefined' ? fetch : null);
+  if (!fetchImpl) throw new Error('fetchImpl not available');
+  const refs = (Array.isArray(fileRefs) ? fileRefs : []).map((item, index) => normalizeLoadTarget(item, index));
+  const total = refs.length;
+  const concurrency = Math.max(1, Math.min(Number(options.concurrency || options.maxConcurrency || 8) || 8, 12, Math.max(total, 1)));
+  const recordsByIndex = new Array(total);
+  const errorsByIndex = new Array(total);
+  const transportEvents = [];
+  let requests = 0;
+  let nextIndex = 0;
+  let completed = 0;
+  let lastReported = -1;
+
+  const report = (loaded, labelPrefix = 'Loaded') => {
+    if (typeof options.onProgress !== 'function') return;
+    if (loaded === lastReported && loaded !== 0 && loaded !== total) return;
+    if (loaded !== 0 && loaded !== total && loaded % 10 !== 0) return;
+    lastReported = loaded;
+    options.onProgress({
+      phase: 'raw-file-load',
+      loaded,
+      total,
+      percent: total ? Math.min(92, 40 + Math.round((loaded / total) * 50)) : 90,
+      label: `${labelPrefix} GitHub Markdown ${loaded}/${total}`
+    });
+  };
+
+  const loadOne = async (index) => {
+    const target = refs[index];
+    const ref = target.ref;
+    let rawUrl;
+    try {
+      rawUrl = normalizeGithubRefToRaw(source, ref);
+    } catch (e) {
+      const message = String(e && e.message ? e.message : e);
+      errorsByIndex[index] = Object.assign({ ref, error: message }, targetAttribution(target));
+      transportEvents.push(Object.assign({ ref, code: 'github.raw.ref.invalid', severity: 'error', message }, targetAttribution(target)));
+      return;
+    }
+    if (!isHttps(rawUrl)) {
+      errorsByIndex[index] = Object.assign({ ref, error: 'non-https URL' }, targetAttribution(target));
+      transportEvents.push(Object.assign({ ref, code: 'github.raw.non-https', severity: 'error', message: 'non-https URL' }, targetAttribution(target)));
+      return;
+    }
+    try {
+      requests += 1;
+      const res = await fetchImpl(rawUrl, {});
+      if (!res || !res.ok) {
+        const message = `${res?.status || 'ERR'} ${res?.statusText || ''}`.trim();
+        errorsByIndex[index] = Object.assign({ ref, error: message }, targetAttribution(target));
+        transportEvents.push(Object.assign({ ref, url: rawUrl, status: res?.status || 0, code: 'github.raw.fetch.failed', severity: 'error', message }, targetAttribution(target)));
+        return;
+      }
+      const markdown = await res.text();
+      const name = rawUrl.split('/').pop() || ref;
+      const sourceTarget = Object.assign({
+        schema: 'tiinex.source.material.target.v1',
+        rawUrl,
+        materializedCommit: exactCommitFromRawUrl(rawUrl),
+        transportTier: res.transportTier || '',
+        loaded: true
+      }, targetAttribution(target));
+      recordsByIndex[index] = Object.assign(createRecordFromMarkdown(markdown, { path: rawUrl, name, sourceMode: 'github-source' }), { sourceTarget });
+      transportEvents.push(Object.assign({ ref, url: rawUrl, tier: res.transportTier || '', code: 'github.raw.record.loaded', severity: 'info' }, targetAttribution(target)));
+    } catch (e) {
+      const message = String(e && e.message ? e.message : e);
+      errorsByIndex[index] = Object.assign({ ref, error: message }, targetAttribution(target));
+      transportEvents.push(Object.assign({ ref, url: rawUrl || '', code: 'github.raw.fetch.exception', severity: 'error', message }, targetAttribution(target)));
+    }
+  };
+
+  const worker = async () => {
+    for (;;) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= total) return;
+      await loadOne(index);
+      completed += 1;
+      report(completed);
+    }
+  };
+
+  if (total) report(0, 'Starting');
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+
+  const records = recordsByIndex.filter(Boolean);
+  const errors = errorsByIndex.filter(Boolean);
+  return {
+    records,
+    errors,
+    okCount: records.length,
+    failCount: errors.length,
+    diagnostics: { requests, concurrency, transportEvents }
+  };
+}

package/src/sources/github/github.permalink.js

@@ -0,0 +1 @@
+export function githubPermalink(repo, commit, path) { return `https://github.com/${repo}/blob/${commit}/${path}`; }

package/src/sources/github/github.source.js

@@ -0,0 +1 @@
+export function githubSource(repo, path) { return { kind: 'github', repo, path }; }