@tiinex/core 0.1.1

package/src/lineage/lineage.targetKeys.js

@@ -0,0 +1,80 @@
+export function provenanceTargetKeysForValue(value = '') {
+  const raw = String(value || '').trim();
+  if (!raw) return [];
+  const keys = [];
+  const add = (item = '') => {
+    const clean = String(item || '').trim().toLowerCase();
+    if (clean && !keys.includes(clean)) keys.push(clean);
+  };
+  add(`raw:${raw}`);
+  const commentId = raw.match(/(?:issuecomment-|issues\/comments\/)(\d+)/i)?.[1] || '';
+  if (commentId) add(`github-comment:${commentId}`);
+  try {
+    const url = new URL(raw);
+    const host = url.hostname.toLowerCase();
+    const parts = url.pathname.split('/').filter(Boolean);
+    const hash = url.hash || '';
+    if ((host === 'github.com' || host.endsWith('.github.com')) && parts.length >= 4 && parts[2] === 'issues') {
+      const repo = normalizeRepoKey(`${parts[0]}/${parts[1]}`);
+      const number = String(parts[3] || '').trim();
+      if (repo && number) {
+        add(`github-issue:${repo}#${number}`);
+        if (hash) add(`github-issue:${repo}#${number}${hash.toLowerCase()}`);
+      }
+    }
+    if (host === 'api.github.com' && parts.length >= 5 && parts[0] === 'repos' && parts[3] === 'issues') {
+      const repo = normalizeRepoKey(`${parts[1]}/${parts[2]}`);
+      const number = String(parts[4] || '').trim();
+      if (repo && number) add(`github-issue:${repo}#${number}`);
+    }
+  } catch (error) {
+  }
+  return keys;
+}
+export function githubRepoRelativePathFromUrl(value = '') {
+  try { const u = new URL(String(value || '').trim()), p = u.pathname.split('/').filter(Boolean), h = u.hostname.toLowerCase();
+    if (h === 'raw.githubusercontent.com' && p.length >= 4) return p.slice(3).join('/');
+    if ((h === 'github.com' || h.endsWith('.github.com')) && p.length >= 5 && p[2] === 'blob') return p.slice(4).join('/');
+  } catch (_) {}
+  return '';
+}
+export function sourceKeyFromTarget(value = '') {
+  try {
+    const url = new URL(String(value || ''));
+    const parts = url.pathname.split('/').filter(Boolean);
+    if (url.hostname === 'raw.githubusercontent.com' && parts.length >= 2) return normalizeRepoKey(`${parts[0]}/${parts[1]}`);
+    if (url.hostname.endsWith('github.com') && parts.length >= 2) return normalizeRepoKey(`${parts[0]}/${parts[1]}`);
+  } catch (error) {
+  }
+  return '';
+}
+export function normalizeRepoKey(value = '') {
+  const parts = String(value || '').trim().toLowerCase().split('/').filter(Boolean);
+  return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : '';
+}
+export function normalizeRef(value = '') {
+  return String(value || '').trim().toLowerCase();
+}
+export function canonicalToken(value = '') {
+  return String(value || '').trim().replace(/^record:/i, 'record:').replace(/\s+/g, '');
+}
+export function canonicalPath(value = '') {
+  let raw = String(value || '').trim();
+  if (!raw) return '';
+  raw = raw.replace(/^record:/i, '');
+  const githubPath = githubRepoRelativePathFromUrl(raw);
+  if (githubPath) raw = githubPath;
+  else {
+    try {
+      const url = new URL(raw);
+      raw = url.pathname.replace(/^\/+/, '');
+    } catch (e) {}
+  }
+  const out = [];
+  for (const part of raw.replace(/\\/g, '/').split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') out.pop();
+    else out.push(part);
+  }
+  return out.join('/');
+}

package/src/lineage/lineage.traverse.js

@@ -0,0 +1,132 @@
+import { resolveLineage } from './lineage.resolve.js';
+
+export const LINEAGE_TRAVERSAL_SCHEMA_ID = 'tiinex.lineage.traversal.v1';
+
+export function traverseLoadedLineage(artifacts = [], options = {}) {
+  const resolved = options.resolvedLineage || resolveLineage(artifacts, { depth: 'loaded-workspace' });
+  const maxDepth = normalizeDepth(options.maxDepth ?? options.depth ?? 3);
+  const direction = normalizeDirection(options.direction || 'ancestors');
+  const startIds = normalizeStartIds(options.startIds || options.startId || options.selectedId, resolved.nodes);
+  const nodeMap = new Map((resolved.nodes || []).map((node) => [node.id, node]));
+  const outgoing = new Map();
+  const incoming = new Map();
+  for (const edge of resolved.edges || []) {
+    if (edge.status === 'missing') {
+      addEdge(incoming, edge.to, edge);
+      continue;
+    }
+    addEdge(outgoing, edge.from, edge);
+    addEdge(incoming, edge.to, edge);
+  }
+
+  const visited = new Map();
+  const edgeIds = new Set();
+  const missingEdges = [];
+  const findings = [];
+  const queue = [];
+
+  for (const id of startIds) {
+    if (!nodeMap.has(id)) {
+      findings.push(finding('warning', 'lineage.traversal.start.missing', 'Traversal start node is not loaded.', { nodeId: id }));
+      continue;
+    }
+    visited.set(id, { node: nodeMap.get(id), depth: 0, role: 'start' });
+    queue.push({ id, depth: 0 });
+  }
+
+  while (queue.length) {
+    const item = queue.shift();
+    if (item.depth >= maxDepth) continue;
+    const edges = edgesForDirection({ incoming, outgoing, id: item.id, direction });
+    for (const edge of edges) {
+      if (edge.status === 'missing') {
+        if (!missingEdges.some((existing) => existing.id === edge.id)) missingEdges.push(edge);
+        findings.push(finding('warning', 'lineage.traversal.missingTarget', 'Declared lineage target is not loaded; traversal stops at this boundary.', { nodeId: edge.to, target: edge.target }));
+        continue;
+      }
+      edgeIds.add(edge.id);
+      const nextId = edge.from === item.id ? edge.to : edge.from;
+      if (!nextId || !nodeMap.has(nextId)) continue;
+      const nextDepth = item.depth + 1;
+      if (!visited.has(nextId) || nextDepth < visited.get(nextId).depth) {
+        visited.set(nextId, { node: nodeMap.get(nextId), depth: nextDepth, role: edge.from === nextId ? 'ancestor' : 'descendant' });
+        queue.push({ id: nextId, depth: nextDepth });
+      }
+    }
+  }
+
+  const nodes = Array.from(visited.values()).sort((a, b) => a.depth - b.depth || String(a.node.path || a.node.id).localeCompare(String(b.node.path || b.node.id)));
+  const edges = (resolved.edges || []).filter((edge) => edgeIds.has(edge.id));
+  if (!nodes.length) findings.push(finding('info', 'lineage.traversal.empty', 'No loaded lineage nodes matched traversal start options.', {}));
+
+  return Object.freeze({
+    schema: LINEAGE_TRAVERSAL_SCHEMA_ID,
+    boundary: 'loaded-only; no remote fetch; no inferred edges',
+    direction,
+    maxDepth,
+    startIds: Object.freeze(startIds),
+    nodes: Object.freeze(nodes.map(({ node, depth, role }) => Object.freeze({ id: node.id, title: node.title, path: node.path, schemaId: node.schemaId, depth, role, trace: node.trace || '', origin: node.origin || '' }))),
+    edges: Object.freeze(edges),
+    missingEdges: Object.freeze(missingEdges),
+    findings: Object.freeze(dedupeFindings(findings)),
+    resolvedLineage: resolved,
+    stats: Object.freeze({
+      loadedNodes: resolved.nodes?.length || 0,
+      visitedNodes: nodes.length,
+      traversedEdges: edges.length,
+      missingEdges: missingEdges.length,
+      findings: dedupeFindings(findings).length,
+      stoppedAtDepth: nodes.some((entry) => entry.depth >= maxDepth)
+    })
+  });
+}
+
+function edgesForDirection({ incoming, outgoing, id, direction }) {
+  if (direction === 'ancestors') return ancestorEdges(incoming.get(id) || []);
+  if (direction === 'descendants') return outgoing.get(id) || [];
+  return [...ancestorEdges(incoming.get(id) || []), ...(outgoing.get(id) || [])];
+}
+
+function ancestorEdges(edges = []) {
+  const list = Array.isArray(edges) ? edges : [];
+  const parentEdges = list.filter((edge) => edge.kind === 'parent');
+  if (parentEdges.length) return parentEdges;
+  return list;
+}
+
+function normalizeStartIds(value, nodes = []) {
+  const values = Array.isArray(value) ? value : [value];
+  const out = values.map((item) => String(item || '').trim()).filter(Boolean);
+  return out.length ? out : (nodes[0]?.id ? [nodes[0].id] : []);
+}
+
+function normalizeDirection(value = '') {
+  const text = String(value || '').toLowerCase();
+  if (text === 'descendants' || text === 'children') return 'descendants';
+  if (text === 'both' || text === 'all') return 'both';
+  return 'ancestors';
+}
+
+function normalizeDepth(value) {
+  const number = Number.parseInt(value, 10);
+  if (!Number.isFinite(number)) return 3;
+  return Math.max(0, Math.min(32, number));
+}
+
+function addEdge(map, key, edge) {
+  if (!key) return;
+  if (!map.has(key)) map.set(key, []);
+  map.get(key).push(edge);
+}
+
+function dedupeFindings(findings = []) {
+  const seen = new Set();
+  return findings.filter((entry) => {
+    const key = `${entry.code}:${entry.nodeId || ''}:${entry.target || ''}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function finding(severity, code, message, extra = {}) { return Object.freeze(Object.assign({ severity, code, message, source: LINEAGE_TRAVERSAL_SCHEMA_ID }, extra)); }

package/src/public/applicationProjection.js

@@ -0,0 +1,236 @@
+import { parseArtifactMarkdown } from '../artifacts/artifact.parse.js';
+
+export const APPLICATION_DATA_SCHEMA_ID = 'tiinex.core.application-data.v1';
+
+export function projectApplicationData(input = {}) {
+  const workspaces = Array.isArray(input) ? input : Array.isArray(input.workspaces) ? input.workspaces : [];
+  const findings = [];
+  const projectedWorkspaces = workspaces.map((workspace, index) => projectWorkspace(workspace, index, findings));
+  const locator = buildLocator(projectedWorkspaces);
+
+  const records = projectedWorkspaces.flatMap((workspace) => workspace.records.map((record) => finalizeRecord(record, workspace, locator, findings)));
+  const byWorkspace = new Map();
+  for (const record of records) {
+    if (!byWorkspace.has(record.workspaceId)) byWorkspace.set(record.workspaceId, []);
+    byWorkspace.get(record.workspaceId).push(record);
+  }
+  const finalizedWorkspaces = projectedWorkspaces.map((workspace) => freeze({
+    ...workspace,
+    records: freeze((byWorkspace.get(workspace.id) || []).sort(compareHistorical))
+  }));
+
+  return freeze({
+    schema: APPLICATION_DATA_SCHEMA_ID,
+    workspaces: finalizedWorkspaces,
+    records: freeze([...records].sort(compareHistorical)),
+    relations: freeze(records.flatMap((record) => record.relation ? [record.relation] : [])),
+    findings,
+    boundary: 'Read-only declared-data projection; parsing and exact-reference resolution do not certify schema validity or authority. Parent and endpoint links use exact declared references only; titles, filenames, chronology and repository basenames never infer semantic relations or authority.'
+  });
+}
+
+export function toPlaythingsStoryRecords(applicationData = {}) {
+  const records = Array.isArray(applicationData.records) ? applicationData.records : [];
+  const counts = new Map();
+  for (const record of records) counts.set(record.id, (counts.get(record.id) || 0) + 1);
+  return freeze(records.flatMap((record) => {
+    if (!Number.isFinite(record.historicalTimeMs) || counts.get(record.id) !== 1) return [];
+    const story = {
+      id: record.id,
+      historicalTimeMs: record.historicalTimeMs,
+      authors: record.authors,
+      actionStatus: record.actionStatus || 'unknown'
+    };
+    if (record.parent.state === 'resolved') story.parentId = record.parent.id;
+    else if (record.parent.state === 'root') story.parentId = null;
+    // Unknown/unresolved Parent deliberately omits parentId.
+    if (record.participants !== undefined) story.participants = record.participants;
+    if (record.handoff) story.handoff = { from: record.handoff.from, to: record.handoff.to };
+    return [freeze(story)];
+  }));
+}
+
+function projectWorkspace(workspace = {}, index, findings) {
+  const id = text(workspace.id || workspace.workspaceId);
+  if (!id || id.includes('::')) throw new TypeError('An explicit unambiguous Workspace id is required.');
+  const title = text(workspace.title || workspace.name || id);
+  const sourceIdentity = freeze({
+    workspaceId: id,
+    repository: text(workspace.repository || workspace.repo || workspace.source?.repository || ''),
+    revision: text(workspace.revision || workspace.commit || workspace.source?.revision || ''),
+    sourceMode: text(workspace.sourceMode || workspace.source?.adapterId || ''),
+    origin: text(workspace.origin || workspace.source?.origin || '')
+  });
+  const rawRecords = Array.isArray(workspace.records) ? workspace.records : [];
+  const records = rawRecords.map((record, recordIndex) => projectRecord(record, { id, title, sourceIdentity }, recordIndex, findings));
+  return freeze({ id, title, sourceIdentity, records, assets: freeze(Array.isArray(workspace.assets) ? workspace.assets.map(safeAssetProjection) : []) });
+}
+
+function projectRecord(record = {}, workspace, index, findings) {
+  const path = normPath(record.path || record.id);
+  if (!path) throw new TypeError('An explicit artifact path or id is required.');
+  const id = `${workspace.id}::${path}`;
+  let parsed = null;
+  if (typeof record.markdown === 'string' && record.markdown.trim()) {
+    try { parsed = parseArtifactMarkdown(record.markdown); }
+    catch (error) { findings.push(finding('warning', 'application-data.parse.failed', 'Artifact Markdown could not be projected.', { id, message: String(error?.message || error) })); }
+  }
+  const schemaId = text(parsed?.envelope?.current?.schema?.id || record.currentSchemaId || record.schemaId || record.kind || '');
+  const createdAt = text(record.currentCreatedAt || record.createdAt || parsed?.envelope?.current?.createdAt || '');
+  const historicalTimeMs = createdAt ? Date.parse(createdAt.replace(' ', 'T') + (/Z$|[+-]\d\d:?\d\d$/.test(createdAt) ? '' : 'Z')) : NaN;
+  if (createdAt && !Number.isFinite(historicalTimeMs)) findings.push(finding('warning', 'application-data.created-at.invalid', 'Created At is present but cannot be represented as a deterministic historical timestamp.', { id, createdAt }));
+  const authors = splitIdentities(record.authors ?? parsed?.envelope?.current?.authors ?? '');
+  const parentTarget = text(parsed?.envelope?.parent?.trace || record.parentRef || record.trace || '');
+  const explicitParticipants = Array.isArray(record.participants) ? freeze(record.participants.map(identityString).filter(Boolean)) : undefined;
+  const actionStatus = ['unknown', 'planned', 'occurred', 'cancelled'].includes(text(record.actionStatus).toLowerCase()) ? text(record.actionStatus).toLowerCase() : 'unknown';
+  return freeze({
+    id,
+    workspaceId: workspace.id,
+    path,
+    title: text(record.title || parsed?.title || path),
+    schemaId,
+    createdAt,
+    historicalTimeMs: Number.isFinite(historicalTimeMs) ? historicalTimeMs : null,
+    authors,
+    participants: explicitParticipants,
+    actionStatus,
+    parentTarget,
+    parentDeclared: Boolean(parsed?.hasContinuityContext && /^\s*- Parent\s*$/m.test(record.markdown || '')),
+    hasEnvelope: Boolean(parsed?.hasContinuityContext),
+    parsed,
+    source: freeze({ ...workspace.sourceIdentity, recordSourceMode: text(record.sourceMode || record.source?.adapterId || '') }),
+    raw: record
+  });
+}
+
+function finalizeRecord(record, workspace, locator, findings) {
+  const parent = resolveParent(record, workspace, locator, findings);
+  const handoff = record.schemaId === 'tiinex.handoff.v1' ? projectHandoff(record, workspace, locator, findings) : null;
+  const relation = record.schemaId === 'tiinex.relation.v1' ? projectRelation(record, workspace, locator, findings) : null;
+  const result = {
+    id: record.id,
+    workspaceId: record.workspaceId,
+    path: record.path,
+    title: record.title,
+    schemaId: record.schemaId,
+    createdAt: record.createdAt,
+    historicalTimeMs: record.historicalTimeMs,
+    authors: record.authors,
+    actionStatus: record.actionStatus,
+    parent,
+    source: record.source,
+    qualification: { schema: 'not-validated-by-this-projection', integrity: 'not-checked-by-this-projection' },
+    handoff,
+    relation
+  };
+  if (record.participants !== undefined) result.participants = record.participants;
+  return freeze(result);
+}
+
+function buildLocator(workspaces) {
+  const exact = new Map();
+  for (const workspace of workspaces) {
+    for (const record of workspace.records) { const matches = exact.get(record.id) || []; matches.push(record); exact.set(record.id, matches); }
+  }
+  return { exact };
+}
+
+function resolveParent(record, workspace, locator, findings) {
+  if (!record.parentTarget) return freeze({ state: record.hasEnvelope && !record.parentDeclared ? 'root' : 'unresolved', id: null, target: '', basis: 'declared-envelope-not-semantic-qualification' });
+  const resolved = resolveReference(record.parentTarget, record, workspace, locator);
+  if (resolved.state === 'resolved') return freeze({ state: 'resolved', id: resolved.record.id, target: record.parentTarget, method: resolved.method });
+  findings.push(finding(resolved.state === 'ambiguous' ? 'error' : 'warning', `application-data.parent.${resolved.state}`, 'Declared Parent reference did not resolve to exactly one loaded artifact.', { id: record.id, target: record.parentTarget, candidates: resolved.candidates || [] }));
+  return freeze({ state: resolved.state, id: null, target: record.parentTarget });
+}
+
+function projectHandoff(record, workspace, locator, findings) {
+  const body = record.parsed?.body?.text || '';
+  const from = field(body, 'From');
+  const to = field(body, 'To');
+  const fromRef = markdownTarget(field(body, 'From Reference'));
+  const toRef = markdownTarget(field(body, 'To Reference'));
+  const fromProjection = resolveEndpoint(from, fromRef, record, workspace, locator, findings, 'from');
+  const toProjection = resolveEndpoint(to, toRef, record, workspace, locator, findings, 'to');
+  return freeze({
+    declaration: freeze({ from: text(from), to: text(to), fromReference: fromRef, toReference: toRef }),
+    from: freeze(fromProjection.ids),
+    to: freeze(toProjection.ids),
+    endpoints: freeze([fromProjection, toProjection]),
+    impliesAcceptance: false
+  });
+}
+
+function resolveEndpoint(label, reference, record, workspace, locator, findings, side) {
+  if (!reference) return freeze({ side, state: 'unresolved', ids: [], label: text(label), reference: '' });
+  const resolved = resolveReference(reference, record, workspace, locator);
+  if (resolved.state === 'resolved') return freeze({ side, state: 'resolved', ids: [resolved.record.id], label: text(label), reference, artifactId: resolved.record.id });
+  findings.push(finding(resolved.state === 'ambiguous' ? 'error' : 'warning', `application-data.handoff.${side}.${resolved.state}`, 'Handoff endpoint reference did not resolve to exactly one loaded artifact. Display name was not used as identity.', { id: record.id, reference }));
+  return freeze({ side, state: resolved.state, ids: [], label: text(label), reference });
+}
+
+function projectRelation(record, workspace, locator, findings) {
+  const body = record.parsed?.body?.text || '';
+  const sourceRef = markdownTarget(field(body, 'Source'));
+  const targetRef = markdownTarget(field(body, 'Target'));
+  const source = sourceRef ? resolveReference(sourceRef, record, workspace, locator) : { state: 'unresolved' };
+  const target = targetRef ? resolveReference(targetRef, record, workspace, locator) : { state: 'unresolved' };
+  if (sourceRef && source.state !== 'resolved') findings.push(finding('warning', `application-data.relation.source.${source.state}`, 'Relation Source did not resolve exactly in loaded application data.', { id: record.id, reference: sourceRef }));
+  if (targetRef && target.state !== 'resolved') findings.push(finding('warning', `application-data.relation.target.${target.state}`, 'Relation Target did not resolve exactly in loaded application data.', { id: record.id, reference: targetRef }));
+  return freeze({
+    id: record.id,
+    type: text(field(body, 'Relation Type')),
+    direction: text(field(body, 'Relation Direction')),
+    scope: text(field(body, 'Relation Scope')),
+    source: freeze({ reference: sourceRef, state: source.state, artifactId: source.record?.id || null }),
+    target: freeze({ reference: targetRef, state: target.state, artifactId: target.record?.id || null })
+  });
+}
+
+function resolveReference(value, record, workspace, locator) {
+  const target = text(value);
+  if (!target) return { state: 'unresolved', candidates: [] };
+  const workspaceQualified = target.match(/^([^:]+)::(.+)$/);
+  if (workspaceQualified) {
+    const id = `${text(workspaceQualified[1])}::${normPath(workspaceQualified[2])}`;
+    const hit = locator.exact.get(id);
+    return exactCandidateResult(hit || [], 'workspace-qualified');
+  }
+  if (/^[a-z]+:\/\//i.test(target)) {
+    const candidates = [...locator.exact.values()].flat().filter((candidate) => [candidate.raw?.browseUrl, candidate.raw?.rawUrl, candidate.raw?.sourceUrl, candidate.raw?.source?.url].map(text).includes(target));
+    return exactCandidateResult(candidates, 'exact-url');
+  }
+  const resolvedPath = target.startsWith('/') ? normPath(target) : resolveRelative(record.path, target);
+  const hit = locator.exact.get(`${workspace.id}::${resolvedPath}`);
+  return exactCandidateResult(hit || [], 'relative-path');
+}
+
+function exactCandidateResult(candidates, method) {
+  if (candidates.length === 1) return { state: 'resolved', record: candidates[0], method };
+  if (candidates.length > 1) return { state: 'ambiguous', candidates: candidates.map((candidate) => candidate.id) };
+  return { state: 'unresolved', candidates: [] };
+}
+
+function resolveRelative(currentPath, target) {
+  const base = normPath(currentPath).split('/'); base.pop();
+  for (const part of normPath(target).split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') { if (!base.length) return ''; base.pop(); } else base.push(part);
+  }
+  return base.join('/');
+}
+
+function field(markdown, label) {
+  const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = String(markdown || '').match(new RegExp(`^\\s*-\\s*${escaped}:\\s*(.+?)\\s*$`, 'mi'));
+  return match?.[1]?.trim() || '';
+}
+function markdownTarget(value) { const match = text(value).match(/^\[[^\]]+\]\(([^)]+)\)$/); return match ? match[1].trim() : text(value); }
+function splitIdentities(value) { if (Array.isArray(value)) return freeze(value.map(identityString).filter(Boolean)); return freeze(text(value).split(/[;,]/).map(identityString).filter(Boolean)); }
+function identityString(value) { if (value && typeof value === 'object') return text(value.id || value.reference || value.target || value.label); return text(value); }
+function safeAssetProjection(asset = {}) { return freeze({ id: text(asset.id || asset.path), path: normPath(asset.path || asset.id), mediaType: text(asset.mediaType || asset.type || ''), ownerArtifactPath: normPath(asset.ownerArtifactPath || ''), sha256: text(asset.sha256 || '') }); }
+function compareHistorical(a, b) { const ta = Number.isFinite(a.historicalTimeMs) ? a.historicalTimeMs : Number.POSITIVE_INFINITY; const tb = Number.isFinite(b.historicalTimeMs) ? b.historicalTimeMs : Number.POSITIVE_INFINITY; return ta - tb || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0); }
+function normPath(value = '') { return text(value).replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+|\/+$/g, ''); }
+function token(value = '') { return text(value).toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, ''); }
+function text(value) { return String(value ?? '').trim(); }
+function finding(severity, code, message, details = {}) { return freeze({ severity, code, message, details }); }
+function freeze(value) { if (Array.isArray(value)) return Object.freeze(value.map(freeze)); if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value; return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, freeze(item)]))); }