@tiinex/app 0.1.1

package/src/workspaces/workspace.summary.js

@@ -0,0 +1,116 @@
+import { isOriginReferenceSource } from '@tiinex/core/sources/origin.references.js';
+import { materialReconciliationCounts, countReconciledLocalSnapshots } from './workspace.materialReconciliation.js';
+import { isLocalSessionMaterial } from './workspace.localSourceLifecycle.js';
+import { buildWorkspaceMaterialLedger } from './workspace.materialLedger.js';
+import { isWorkspaceRecord } from '@tiinex/core/actions/record.actions.js';
+export function summarizeWorkspaceMaterial(workspace = {}) {
+  const records = Array.isArray(workspace.records) ? workspace.records : [];
+  const assets = Array.isArray(workspace.assets) ? workspace.assets : [];
+  const sources = Array.isArray(workspace.sources) ? workspace.sources : [];
+  const importResults = Array.isArray(workspace.importResults) ? workspace.importResults : [];
+  const recoveryOriginSources = sources.filter((source) => isOriginReferenceSource(source) || source.recoveryOnly === true);
+  const configuredSources = sources.filter((source) => source.id !== 'local' && !recoveryOriginSources.includes(source));
+  const sourceBackedRecords = records.filter((record) => isSourceBackedMaterial(record));
+  const localRecords = records.filter((record) => isLocalSessionMaterial(record));
+  const workspaceArtifacts = records.filter(isWorkspaceRecord);
+  const sourceBackedWorkspaceArtifacts = workspaceArtifacts.filter((record) => isSourceBackedMaterial(record));
+  const localWorkspaceArtifacts = workspaceArtifacts.filter((record) => isLocalSessionMaterial(record));
+  const localAssets = assets.filter((asset) => isLocalSessionMaterial(asset));
+  const reconciliationCounts = materialReconciliationCounts(records);
+  const reconciledLocalRecords = countReconciledLocalSnapshots(records);
+  const directLocalRecords = localRecords.length;
+  const localMaterial = Object.freeze({
+    records: directLocalRecords + reconciledLocalRecords,
+    directRecords: directLocalRecords,
+    reconciledLocalRecords,
+    assets: localAssets.length,
+    workspaceArtifacts: localWorkspaceArtifacts.length,
+    total: directLocalRecords + reconciledLocalRecords + localAssets.length
+  });
+  const currentImportResults = importResults.filter((receipt) => receiptAppliesToCurrentWorkspace(receipt, configuredSources));
+  const latestImport = currentImportResults[0] || null;
+  const materialLedger = buildWorkspaceMaterialLedger(workspace, { displayOptions: workspace.displayOptions || {} });
+  return {
+    schema: 'tiinex.workspace.material.summary.v1',
+    counts: {
+      records: records.length,
+      assets: assets.length,
+      workspaceArtifacts: workspaceArtifacts.length,
+      sources: sources.length,
+      configuredSources: configuredSources.length,
+      recoveryOriginSources: recoveryOriginSources.length,
+      originReferences: recoveryOriginSources.reduce((sum, source) => sum + Number(source.originReferenceCount || 0), 0),
+      localRecords: localMaterial.records,
+      directLocalRecords: localMaterial.directRecords,
+      reconciledLocalRecords,
+      localAssets: localAssets.length,
+      localWorkspaceArtifacts: localWorkspaceArtifacts.length,
+      sourceBackedRecords: sourceBackedRecords.length,
+      sourceBackedWorkspaceArtifacts: sourceBackedWorkspaceArtifacts.length,
+      materialChecksumMatches: reconciliationCounts.checksumMatches,
+      materialChecksumMismatches: reconciliationCounts.checksumMismatches,
+      materialUnverifiedSameOrigin: reconciliationCounts.unverifiedSameOrigin,
+      warnings: Number(latestImport?.counts?.warnings || 0),
+      errors: Number(latestImport?.counts?.errors || 0),
+      previewOmitted: Number(latestImport?.counts?.previewOmitted || 0),
+      visibleRecords: materialLedger.counts.visibleRecords,
+      hiddenRecords: materialLedger.counts.hiddenRecords,
+      groupedRecords: materialLedger.counts.groupedRecords,
+      hiddenByDisplayRecords: materialLedger.counts.hiddenByDisplayRecords,
+      hiddenWorkspaceArtifacts: materialLedger.counts.hiddenWorkspaceArtifacts,
+      visibleWorkspaceArtifacts: materialLedger.counts.visibleWorkspaceArtifacts,
+      lineageUsableRecords: materialLedger.counts.lineageUsableRecords
+    },
+    materialLedger,
+    latestImport: latestImport ? {
+      ok: latestImport.ok !== false,
+      message: String(latestImport.message || 'Import completed.').slice(0, 220),
+      at: latestImport.at || '',
+      warnings: Array.isArray(latestImport.warnings) ? latestImport.warnings.slice(0, 3) : [],
+      errors: Array.isArray(latestImport.errors) ? latestImport.errors.slice(0, 3) : [],
+      diagnostics: latestImport.diagnostics || {}
+    } : null,
+    boundaryReadability: buildBoundaryReadability({ localMaterial, sourceBackedRecords, sourceBackedWorkspaceArtifacts, recoveryOriginSources }),
+    hasMaterial: Boolean(records.length || assets.length),
+    hasSourceBackedMaterial: Boolean(sourceBackedRecords.length || sourceBackedWorkspaceArtifacts.length),
+    hasRecoveryOrigins: Boolean(recoveryOriginSources.length),
+    hasLocalMaterial: Boolean(localMaterial.total)
+  };
+}
+
+
+function receiptAppliesToCurrentWorkspace(receipt = {}, configuredSources = []) {
+  const diagnostics = receipt?.diagnostics || {};
+  const sourceId = String(diagnostics.sourceId || diagnostics.materialLedgerReceipt?.sourceId || '').trim();
+  if (!sourceId) return true;
+  return (Array.isArray(configuredSources) ? configuredSources : []).some((source) => String(source?.id || '') === sourceId);
+}
+
+export function shouldShowWorkspaceSummary(summary = {}) {
+  return Boolean(summary.hasMaterial || summary.latestImport);
+}
+
+function isSourceBackedMaterial(item = {}) {
+  const source = item?.source || {};
+  const mode = String(item?.sourceMode || '').trim().toLowerCase();
+  return Boolean(source.adapterId && source.adapterId !== 'local')
+    || source.kind === 'github-tree'
+    || source.sourceKind === 'github.repo'
+    || mode === 'source-backed'
+    || mode.includes('source-backed');
+}
+
+function buildBoundaryReadability({ localMaterial = {}, sourceBackedRecords = [], sourceBackedWorkspaceArtifacts = [], recoveryOriginSources = [] } = {}) {
+  const sourceTotal = Number(sourceBackedRecords.length || 0) + Number(sourceBackedWorkspaceArtifacts.length || 0);
+  const localTotal = Number(localMaterial.total || 0);
+  const recoveryTotal = Array.isArray(recoveryOriginSources) ? recoveryOriginSources.length : 0;
+  return Object.freeze({
+    local: localTotal ? 'local/session material: imported or created in this browser; no GitHub provenance inferred' : '',
+    source: sourceTotal ? 'source-backed material: loaded from explicitly configured source rows' : '',
+    recovery: recoveryTotal ? 'recovery origins: explicit origin metadata only; not loaded source authority' : '',
+    mixed: Boolean(localTotal && sourceTotal),
+    localTotal,
+    sourceTotal,
+    recoveryTotal
+  });
+}

package/src/workspaces/workspace.timePortal.js

@@ -0,0 +1,137 @@
+const TIME_PORTAL_SCHEMA = 'tiinex.site.workspace.timePortalView.v1';
+const EXACT_COMMIT = /^[0-9a-f]{40}$/i;
+
+export function latestTimePortalView() {
+  return null;
+}
+
+export function normalizeTimePortalView(input = null) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return null;
+  const begin = clean(input.begin);
+  const end = clean(input.end);
+  const sourceId = clean(input.sourceId);
+  const snapshotInput = clean(input.snapshotInput);
+  const snapshot = normalizeResolvedSnapshot(input.snapshot);
+  if (snapshot) {
+    return {
+      schema: TIME_PORTAL_SCHEMA,
+      mode: 'historical',
+      begin,
+      end,
+      sourceId: snapshot.sourceId || sourceId,
+      snapshotInput: snapshotInput || snapshot.inputTarget || snapshot.requestedRef || snapshot.materializedCommit,
+      snapshot
+    };
+  }
+  if (!begin && !end && !sourceId && !snapshotInput && input.mode !== 'intent') return null;
+  return { schema: TIME_PORTAL_SCHEMA, mode: 'intent', begin, end, sourceId, snapshotInput };
+}
+
+export function timePortalViewFor(view = {}) {
+  return normalizeTimePortalView(view?.timePortal);
+}
+
+export function timePortalIntentFor(view = {}) {
+  const current = timePortalViewFor(view);
+  return {
+    begin: current?.begin || '',
+    end: current?.end || '',
+    sourceId: current?.sourceId || '',
+    snapshotInput: current?.snapshotInput || ''
+  };
+}
+
+export function timePortalIntentActive(view = {}) {
+  return Boolean(timePortalViewFor(view));
+}
+
+export function timePortalHistoricalActive(view = {}) {
+  return timePortalViewFor(view)?.mode === 'historical';
+}
+
+export function timePortalWithIntent(view = {}, intent = {}) {
+  const next = Object.assign({}, view || {});
+  const normalized = normalizeTimePortalView({
+    mode: 'intent',
+    begin: intent.begin,
+    end: intent.end,
+    sourceId: intent.sourceId,
+    snapshotInput: intent.snapshotInput
+  });
+  if (normalized) next.timePortal = normalized;
+  else delete next.timePortal;
+  return next;
+}
+
+export function timePortalWithResolvedSnapshot(view = {}, snapshot = {}, intent = null) {
+  const current = intent && typeof intent === 'object' ? intent : timePortalIntentFor(view);
+  const next = Object.assign({}, view || {});
+  const normalized = normalizeTimePortalView({
+    mode: 'historical',
+    begin: current.begin,
+    end: current.end,
+    sourceId: snapshot.sourceId || current.sourceId,
+    snapshotInput: current.snapshotInput || snapshot.inputTarget || snapshot.requestedRef || snapshot.materializedCommit,
+    snapshot
+  });
+  if (!normalized?.snapshot) throw new Error('time-portal.snapshot.exact-commit-required');
+  next.timePortal = normalized;
+  return next;
+}
+
+export function timePortalWithoutIntent(view = {}) {
+  const next = Object.assign({}, view || {});
+  delete next.timePortal;
+  return next;
+}
+
+export function normalizeResolvedSnapshot(input = null) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return null;
+  const materializedCommit = clean(input.materializedCommit).toLowerCase();
+  if (!EXACT_COMMIT.test(materializedCommit)) return null;
+  const repository = normalizeRepository(input.repository || input.repo);
+  const sourceId = clean(input.sourceId);
+  if (!sourceId || !repository) return null;
+  return {
+    schema: 'tiinex.site.githubHistoricalSnapshot.v1',
+    sourceId,
+    repository,
+    rootPath: clean(input.rootPath),
+    requestedRef: clean(input.requestedRef),
+    resolvedRef: clean(input.resolvedRef || input.ref || materializedCommit),
+    materializedCommit,
+    inputTarget: clean(input.inputTarget),
+    resolvedBy: clean(input.resolvedBy)
+  };
+}
+
+
+export function timePortalReferencesSource(view = {}, sourceId = '') {
+  const current = timePortalViewFor(view);
+  const id = clean(sourceId);
+  return Boolean(current && id && (current.sourceId === id || current.snapshot?.sourceId === id));
+}
+
+export function timePortalIntentLabel(input = null) {
+  const current = normalizeTimePortalView(input?.timePortal || input);
+  if (!current) return 'Latest source';
+  const parts = [];
+  if (current.begin) parts.push(`Begin ${current.begin}`);
+  if (current.end) parts.push(`End ${current.end}`);
+  return parts.length ? parts.join(' · ') : 'Explicit snapshot intent';
+}
+
+function normalizeRepository(value = '') {
+  const raw = clean(value);
+  if (!raw) return '';
+  try {
+    const url = new URL(raw);
+    const parts = url.pathname.replace(/^\/+|\.git$/g, '').split('/').filter(Boolean);
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : '';
+  } catch {
+    const parts = raw.replace(/^github\.com\//i, '').replace(/^https?:\/\/github\.com\//i, '').replace(/\.git$/i, '').replace(/^\/+|\/+$/g, '').split('/').filter(Boolean);
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : '';
+  }
+}
+
+function clean(value) { return String(value || '').trim(); }