@spexcode/spec-core 0.6.2 → 0.6.3

package/src/graph.ts

@@ -1,251 +0,0 @@
-import { deriveStatus } from './specs.js'
-import { resolveProjectIdentity } from './project-identity.js'
-import { publishReviewSnapshot } from './reviewSnapshot.js'
-import { evalReviewState } from './review/reviewFilters.js'
-
-// a ghost (added) node's parent: the existing node whose directory is the longest prefix of the new one.
-function resolveParent(path: string, byDir: Record<string, string>): string | null {
-  const dir = path.replace(/\/spec\.md$/, '')
-  const segs = dir.split('/')
-  for (let k = segs.length - 1; k > 0; k--) {
-    const anc = segs.slice(0, k).join('/')
-    if (byDir[anc]) return byDir[anc]
-  }
-  return null
-}
-
-const OVERLAY_TO_PATH = Symbol('overlay-to-path')
-
-// The graph owns only the composition of these frozen inputs. Session enumeration and forge/issue reads
-// belong to the CLI/server adapter, so this module has no hidden runtime-system fallback.
-export type BoardSnapshot = {
-  root: string
-  specs: any[]
-  layout: { worktrees: any[] }
-  sessions: any[]
-  issues: any[]
-  issuesStamp: string
-  forgeRevision: string
-  evalTimelines: Map<string, any>
-  sessionEvalProjections: Map<string, any>
-}
-
-// The server-only review snapshot keeps latest readings verbatim. Graph JSON receives only counts.
-export function latestPerScenario<T extends { scenario: string }>(readings: T[]): T[] {
-  const seen = new Set<string>()
-  return readings.filter((r) => !seen.has(r.scenario) && (seen.add(r.scenario), true))
-}
-
-export function nodeEvalSummary(scenarios: { name: string }[], readings: any[]) {
-  type State = 'pass' | 'fail' | 'stalePass' | 'staleFail' | 'empty'
-  const latest = new Map(latestPerScenario(readings).map((reading) => [reading.scenario, reading]))
-  const summary = { total: scenarios.length, pass: 0, fail: 0, stalePass: 0, staleFail: 0, empty: 0 }
-  for (const scenario of scenarios) {
-    const reading = latest.get(scenario.name)
-    const state = (reading ? evalReviewState(reading) : 'empty') as State
-    summary[state]++
-  }
-  return summary
-}
-
-// @@@ a shelved row carries no delta ([[archive]]) - the board has TWO producers (a full buildBoard and the
-// sessions-only spliceSessions), and shelving is a session-scoped write, so it takes the SPLICE path — which
-// reuses the previous board's ops by path. Skipping the delta only in layout's row builder would therefore be
-// invisible exactly when it fires: the splice would carry the stale ops forward forever. The rule belongs to
-// the row, not to one producer, so both decorate through this one function.
-const rowOps = (s: { path: string; archived?: boolean }, opsByPath: Record<string, any[]>): any[] =>
-  (s.archived ? [] : opsByPath[s.path] || [])
-
-export async function buildBoard({ root, specs, layout, sessions, issues: merged, issuesStamp, forgeRevision, evalTimelines, sessionEvalProjections }: BoardSnapshot) {
-  const worktrees = layout.worktrees.filter((w) => !w.isMain)
-  // resolveLayout already zeroed ops for unmanaged worktrees, so this is just "has pending changes".
-  const opWts = worktrees.filter((w) => w.ops && w.ops.length)
-
-  const sessIdByPath: Record<string, string> = {}
-  sessions.forEach((s) => { sessIdByPath[s.path] = s.id })
-  const seedOf = (path: string): string => sessIdByPath[path] || path
-
-  const byId: Record<string, any> = Object.fromEntries(specs.map((n) => [n.id, n]))
-  const byDir: Record<string, string> = {}
-  specs.forEach((n: any) => { if (n.path) byDir[n.path.replace(/\/spec\.md$/, '')] = n.id })
-  // register each added node's own dir in byDir first, so resolveParent can chain a new node to its new
-  // ghost ancestor (a whole added subtree renders as one tree, not a flat scatter of roots).
-  for (const w of opWts) for (const op of w.ops) {
-    if (op.op === 'added') byDir[op.path.replace(/\/spec\.md$/, '')] = op.nodeId
-  }
-
-  const overlaysByNode: Record<string, any[]> = {}
-  const ghostById: Record<string, any> = {}
-  for (const w of opWts) {
-    const source = w.path, label = w.node || w.branch || w.path, seed = seedOf(w.path)
-    for (const op of w.ops) {
-      const ov = {
-        op: op.op, source, label, branch: w.branch, seed,
-        committed: op.committed, dirty: op.dirty,
-        toParent: op.op === 'moved' ? resolveParent(op.toPath || op.path, byDir) : null,
-        [OVERLAY_TO_PATH]: op.op === 'moved' ? op.toPath || op.path : null,
-      }
-      if (op.op === 'added' && !byId[op.nodeId]) {
-        if (ghostById[op.nodeId]) { ghostById[op.nodeId].overlays.push(ov); continue }
-        // a ghost is a node being ADDED by a worktree but not yet on main -> it has a pending op,
-        // so its derived status is `active` (live, in-flight), never `pending`.
-        ghostById[op.nodeId] = {
-          id: op.nodeId, parent: resolveParent(op.path, byDir), path: op.path,
-          title: op.nodeId, status: deriveStatus({ version: 0, drift: 0, hasOverlay: true }),
-          version: 0, session: null, fmStatus: null,
-          desc: '', code: [], related: [], body: '', drift: 0, driftFiles: [], ghost: true, overlays: [ov],
-        }
-      } else {
-        (overlaysByNode[op.nodeId] ??= []).push(ov)
-      }
-    }
-  }
-
-  // re-derive status WITH the overlay so a node an unmerged worktree is touching reads `active` — the only
-  // place in-flight work is known, so the only place `active` is produced.
-  const nodes = [
-    ...specs.map((n: any) => {
-      const overlays = overlaysByNode[n.id] || []
-      // `body` and its derivation `parts` are DROPPED from the board payload ([[graph-lean]]): together ~56% of
-      // the bytes, and detail the graph overview never renders. The detail view fetches them per node from
-      // `/api/specs/:id/content` on open, and the search palette fetches the body corpus from `/api/specs/lite`
-      // once on open — both off this hot poll. `undefined` makes JSON.stringify omit the keys.
-      return { ...n, body: undefined, parts: undefined, overlays, status: deriveStatus({ version: n.version, drift: n.drift, hasOverlay: overlays.length > 0, hasCode: (n.code?.length ?? 0) > 0, fmStatus: n.fmStatus ?? undefined }) }
-    }),
-    ...Object.values(ghostById),
-  ]
-  // The outer adapter reads Issues once. Full rows stay in the server-only review snapshot; graph nodes get
-  // counts and open identity only, enough for tile/stat/tree glances without reconstructing the list.
-  const isOpen = (i: { status: string }) => i.status === 'open'
-  // `issuesStamp` above is that ONE board-level freshness stamp, over EVERY thread — noded or nodeless,
-  // both stores, BOTH remark hosts. It is folded from the whole store and NOT from the split `merged`: a
-  // scenario-hosted remark lands on an eval track the issue read splits out ([[eval-issue-split]]), so a
-  // carrier folded over the issue half alone left an open READING blind to every remark on it — the write
-  // moved no board byte, [[graph-delta]] correctly suppressed the no-change broadcast, and the push never
-  // fired at all. The per-node fold below stays [[graph-lean]]-slim (no reply payloads).
-  const issuesByNode: Record<string, any[]> = {}
-  for (const issue of merged)
-    for (const nid of issue.nodes) (issuesByNode[nid] ??= []).push(issue)
-  for (const n of nodes) {
-    const issues = issuesByNode[n.id]
-    if (!issues || !issues.length) continue
-    const open = issues.filter(isOpen)
-    n.reviewSummary = {
-      ...(n.reviewSummary || {}),
-      issues: { open: open.length, closed: issues.length - open.length, openIds: open.map((issue) => issue.id) },
-    }
-  }
-
-  // The L1 adapter calculates current eval timelines once. Latest rows/declarations stay server-only for
-  // paged review; graph nodes receive the explicit per-state count projection and nothing row-shaped.
-  const evalReviewNodes = nodes.flatMap((n) => {
-    const timeline = evalTimelines.get(n.id)
-    if (!timeline?.hasEvalFile) return []
-    const latest = latestPerScenario(timeline.readings)
-    n.reviewSummary = { ...(n.reviewSummary || {}), evals: nodeEvalSummary(timeline.scenarios, latest) }
-    return [{ id: n.id, hue: n.hue, scenarios: timeline.scenarios, evals: latest, readings: timeline.readings }]
-  })
-
-  publishReviewSnapshot({ issues: merged, evalNodes: evalReviewNodes, forgeRevision })
-
-  const opsByPath: Record<string, any[]> = {}
-  opWts.forEach((w) => { opsByPath[w.path] = w.ops })
-  const sess = sessions.map((s) => ({
-    ...s,
-    source: s.path,
-    ops: rowOps(s, opsByPath),
-    evalSummary: sessionEvalProjections.get(s.id),
-  }))
-
-  // One resolved identity projection feeds title, favicon, rail, and catalog compatibility. A worktree
-  // backend reads the actual served tree's branch config and identity; endpoint registration uses the
-  // same git toplevel, so a linked worktree occupies its own host slot instead of replacing main.
-  const identity = resolveProjectIdentity(root, root)
-  return { nodes, sessions: sess, identity, issuesStamp }
-}
-
-// @@@ spliceSessions — the SESSIONS-ONLY producer ([[graph-cache]]). A session-scoped change (a lifecycle
-// write, a liveness/activity poll flip) reshapes only the board's `sessions` rows — the node/meta units are
-// untouched — so the cache re-derives ONLY the sessions and splices them onto the previous board verbatim,
-// skipping the whole loadSpecs/layout/eval assembly a full buildBoard() pays. The adapter supplies every
-// live input:
-// each row is decorated EXACTLY as buildBoard's sess mapping (`{...s, source: s.path, ops}`), and every
-// path's `ops` is REUSED from the previous board (a path→ops map). A session path absent in `prev` gets []
-// — a brand-new worktree has no pending spec ops yet, and any later ops-CHANGING event (a commit, a
-// worktree `.spec` edit) is refs/worktree-scoped, i.e. a FULL rebuild, never a sessions splice. So the
-// splice is byte-indistinguishable from a full rebuild whenever only session state moved.
-export async function spliceSessions(
-  prev: Awaited<ReturnType<typeof buildBoard>>,
-  sessions: any[],
-  sessionEvalProjections: Map<string, any>,
-): Promise<Awaited<ReturnType<typeof buildBoard>>> {
-  const activeSources = new Set(sessions.map((session) => session.path))
-  const opsByPath: Record<string, any[]> = {}
-  for (const s of prev.sessions) opsByPath[s.source] = s.ops
-  const sess = sessions.map((s) => ({
-    ...s,
-    source: s.path,
-    ops: rowOps(s, opsByPath),
-    evalSummary: sessionEvalProjections.get(s.id),
-  }))
-  // Archive and close are subtractive topology changes: their worktree leaves the working set, so its
-  // overlays must leave in the same cheap publication as its row. Filtering the already-built units is exact
-  // and forks nothing. A newly-active source is intentionally absent here; graphCache keeps a full obligation
-  // for additions/resume so resolveLayout can discover that worktree's current delta.
-  let nodeProjectionMoved = false
-  const projectedNodes = prev.nodes.flatMap((node: any) => {
-    const overlays = (node.overlays || []).filter((overlay: any) => activeSources.has(overlay.source))
-    if (node.ghost && overlays.length === 0) { nodeProjectionMoved = true; return [] }
-    if (overlays.length === (node.overlays || []).length) return [node]
-    nodeProjectionMoved = true
-    if (node.ghost) return [{ ...node, overlays, status: deriveStatus({ version: 0, drift: 0, hasOverlay: true }) }]
-    return [{ ...node, overlays, status: deriveStatus({
-      version: node.version,
-      drift: node.drift,
-      hasOverlay: overlays.length > 0,
-      hasCode: (node.code?.length ?? 0) > 0,
-      fmStatus: node.fmStatus ?? undefined,
-    }) }]
-  })
-  const nodes = nodeProjectionMoved ? projectedNodes : prev.nodes
-  if (nodeProjectionMoved) {
-    const byDir: Record<string, string> = {}
-    for (const node of nodes) if (node.path) byDir[node.path.replace(/\/spec\.md$/, '')] = node.id
-    const retainedIds = new Set(nodes.map((node: any) => node.id))
-    for (let index = 0; index < nodes.length; index++) {
-      const node: any = nodes[index]
-      let changed = false
-      let parent = node.parent
-      if (node.ghost) {
-        const next = resolveParent(node.path, byDir)
-        if (next !== parent) { parent = next; changed = true }
-      }
-      const overlays = (node.overlays || []).map((overlay: any) => {
-        if (!overlay.toParent || retainedIds.has(overlay.toParent)) return overlay
-        const toPath = overlay[OVERLAY_TO_PATH]
-        changed = true
-        return { ...overlay, toParent: typeof toPath === 'string' ? resolveParent(toPath, byDir) : null }
-      })
-      if (changed) nodes[index] = { ...node, parent, overlays }
-    }
-  }
-  return { ...prev, nodes, sessions: sess }
-}
-
-// A full producer may finish after the session lane has already shown a newer row. Reuse that published
-// projection on the full topology without another store read: topology owns the current per-path ops, while
-// the published row owns lifecycle/eval fields. This is deliberately synchronous so a full completion never
-// waits for a quiet session store.
-export function rebasePublishedSessions(
-  topology: Awaited<ReturnType<typeof buildBoard>>,
-  published: Awaited<ReturnType<typeof buildBoard>>,
-): Awaited<ReturnType<typeof buildBoard>> {
-  const opsByPath: Record<string, any[]> = {}
-  for (const session of topology.sessions) opsByPath[session.source] = session.ops
-  const sessions = published.sessions.map((session) => ({
-    ...session,
-    source: session.path,
-    ops: rowOps(session, opsByPath),
-  }))
-  return { ...topology, sessions }
-}

package/src/harness-identity.ts

@@ -1,26 +0,0 @@
-type HarnessIdentityRow = { id: string; sessionEnvVar: string }
-
-// Adapter-neutral identity facts. Full harness adapters project these rows; consumers that only resolve an
-// environment identity must not load launchers, runtime transport, or materialization code.
-export const HARNESS_IDENTITIES = [
-  { id: 'claude', sessionEnvVar: 'CLAUDE_CODE_SESSION_ID' },
-  { id: 'codex', sessionEnvVar: 'CODEX_THREAD_ID' },
-  { id: 'opencode', sessionEnvVar: 'OPENCODE_SESSION_ID' },
-  { id: 'pi', sessionEnvVar: 'PI_SESSION_ID' },
-  { id: 'zcode', sessionEnvVar: 'ZCODE_SESSION_ID' },
-  { id: 'claude-headless', sessionEnvVar: 'CLAUDE_CODE_SESSION_ID' },
-  { id: 'opencode-headless', sessionEnvVar: 'OPENCODE_SESSION_ID' },
-  { id: 'pi-headless', sessionEnvVar: 'PI_SESSION_ID' },
-  { id: 'codex-headless', sessionEnvVar: 'CODEX_THREAD_ID' },
-] as const satisfies readonly HarnessIdentityRow[]
-
-export type HarnessId = typeof HARNESS_IDENTITIES[number]['id']
-export type HarnessIdentity = typeof HARNESS_IDENTITIES[number]
-
-const identityById = new Map(HARNESS_IDENTITIES.map((identity) => [identity.id, identity]))
-
-export function harnessIdentity(id: HarnessId): HarnessIdentity {
-  const identity = identityById.get(id)
-  if (!identity) throw new Error(`unknown harness identity '${id}'`)
-  return identity
-}

package/src/identity-presets.d.ts

@@ -1,13 +0,0 @@
-export type IdentityShape = { tag: string; [key: string]: string | number }
-export type IdentityPreset = { id: string; label: string; bg: string; fg: string; shapes: IdentityShape[] }
-
-export const DEFAULT_PROJECT_ICON: string
-export const DEFAULT_GATEWAY_ICON: string
-export const IDENTITY_PRESETS: readonly IdentityPreset[]
-export const IDENTITY_PRESET_IDS: readonly string[]
-export function resolvedIdentityIcon(value: unknown, fallback?: string): string
-export function identityPreset(value: unknown): IdentityPreset | null
-export function isIconifyIcon(value: unknown): boolean
-export function requireIdentityChoice(value: unknown): string
-export function identitySvg(value: unknown, fallback?: string): string
-export function identityFaviconHref(value: unknown, fallback?: string): string

package/src/identity-presets.js

@@ -1,138 +0,0 @@
-// One browser-safe identity registry shared by backend validation and every dashboard projection.
-// Geometry is data so the React renderer and favicon serializer cannot drift into separate drawings.
-//
-// @@@ shape keys travel through two renderers - a shape's own attributes override the group's
-// fill/stroke, which is how a multi-colour mark fits a single-fg registry. Both consumers pass the keys
-// through verbatim: the string serializer spreads them as attributes, React spreads them as JSX props.
-// So a key must be valid in BOTH, which rules out hyphenated names (React wants strokeWidth) - hence a
-// painted seam outline rather than a stroked line, since per-shape stroke-width cannot be expressed.
-
-export const DEFAULT_PROJECT_ICON = 'spexcode'
-export const DEFAULT_GATEWAY_ICON = 'gateway'
-
-export const IDENTITY_PRESETS = Object.freeze([
-  {
-    // The brand mark: two brackets holding one file, cleft corner to corner and regenerated on the
-    // upper-right of the cleft. Painted rather than stroked — see the paint note below. Geometry is
-    // docs/brand/mark-dark.svg scaled by 24/512; the two surface gradients flatten to their midpoints
-    // because a 24-unit chip has no room for a ramp and the format carries no defs.
-    id: 'spexcode', label: 'SpexCode', bg: '#12161C', fg: '#EFE8D8',
-    shapes: [
-      { tag: 'path', d: 'M 4.500,4.500 L 9.750,4.500 L 9.750,6.656 L 6.656,6.656 L 6.656,17.344 L 9.750,17.344 L 9.750,19.500 L 4.500,19.500 Z', fill: '#EFE8D8', stroke: 'none' },
-      { tag: 'path', d: 'M 19.500,4.500 L 14.250,4.500 L 14.250,6.656 L 17.344,6.656 L 17.344,17.344 L 14.250,17.344 L 14.250,19.500 L 19.500,19.500 Z', fill: '#EFE8D8', stroke: 'none' },
-      { tag: 'path', d: 'M 15.281,15.281 L 11.731,13.057 L 12.269,10.943 L 8.719,8.719 L 8.719,15.281 Z', fill: '#327D95', stroke: 'none' },
-      { tag: 'path', d: 'M 8.719,8.719 L 12.269,10.943 L 11.731,13.057 L 15.281,15.281 L 15.281,12.000 L 12.000,8.719 Z', fill: '#82C3D6', stroke: 'none' },
-      { tag: 'path', d: 'M 8.569,8.957 L 11.946,11.073 L 11.408,13.186 L 15.132,15.520 L 15.431,15.043 L 12.054,12.927 L 12.592,10.814 L 8.868,8.480 Z', fill: '#E4F7FD', stroke: 'none' },
-    ],
-  },
-  {
-    id: 'gateway', label: 'Gateway', bg: '#155e75', fg: '#ecfeff',
-    shapes: [
-      { tag: 'path', d: 'm12 3 8 4.2-8 4.2-8-4.2Z' },
-      { tag: 'path', d: 'm4 11.2 8 4.2 8-4.2' },
-      { tag: 'path', d: 'm4 15.2 8 4.2 8-4.2' },
-    ],
-  },
-  {
-    id: 'mdi:rocket-launch', label: 'Rocket', bg: '#9f1239', fg: '#fff1f2',
-    shapes: [
-      { tag: 'path', d: 'M14.5 5.2c2.2-2.2 4.8-2 5.3-1.8.2.5.4 3.1-1.8 5.3l-5.5 5.5-4.2-4.2Z' },
-      { tag: 'path', d: 'm11.2 6.8-4.1.6-2.5 2.5 4.1.7' },
-      { tag: 'path', d: 'm16.4 12-1 4.7-2.5 2.5-.7-4.1' },
-      { tag: 'circle', cx: 16.1, cy: 7.1, r: 1.2 },
-      { tag: 'path', d: 'M7.6 14.6c-2.2.4-3.4 1.6-3.6 3.8 2.2-.2 3.4-1.4 3.8-3.6' },
-    ],
-  },
-  {
-    id: 'compass', label: 'Compass', bg: '#1d4ed8', fg: '#eff6ff',
-    shapes: [
-      { tag: 'circle', cx: 12, cy: 12, r: 8.5 },
-      { tag: 'path', d: 'm15.2 8.8-1.8 4.6-4.6 1.8 1.8-4.6Z' },
-    ],
-  },
-  {
-    id: 'terminal', label: 'Terminal', bg: '#3f3f46', fg: '#fafafa',
-    shapes: [
-      { tag: 'rect', x: 3.5, y: 4.5, width: 17, height: 15, rx: 2 },
-      { tag: 'path', d: 'm7 9 3 3-3 3' },
-      { tag: 'path', d: 'M12.5 15H17' },
-    ],
-  },
-  {
-    id: 'package', label: 'Package', bg: '#6d28d9', fg: '#f5f3ff',
-    shapes: [
-      { tag: 'path', d: 'm12 3 8 4.5v9L12 21l-8-4.5v-9Z' },
-      { tag: 'path', d: 'm4.3 7.7 7.7 4.4 7.7-4.4' },
-      { tag: 'path', d: 'M12 12.1V21' },
-    ],
-  },
-  {
-    id: 'database', label: 'Database', bg: '#a16207', fg: '#fefce8',
-    shapes: [
-      { tag: 'ellipse', cx: 12, cy: 6, rx: 7.5, ry: 3 },
-      { tag: 'path', d: 'M4.5 6v6c0 1.7 3.4 3 7.5 3s7.5-1.3 7.5-3V6' },
-      { tag: 'path', d: 'M4.5 12v6c0 1.7 3.4 3 7.5 3s7.5-1.3 7.5-3v-6' },
-    ],
-  },
-  {
-    id: 'spark', label: 'Spark', bg: '#c2410c', fg: '#fff7ed',
-    shapes: [
-      { tag: 'path', d: 'm12 3 1.5 5.2L19 10l-5.5 1.8L12 17l-1.5-5.2L5 10l5.5-1.8Z' },
-      { tag: 'path', d: 'm18.5 15 .7 2.2 2.3.8-2.3.8-.7 2.2-.7-2.2-2.3-.8 2.3-.8Z' },
-    ],
-  },
-])
-
-const BY_ID = new Map(IDENTITY_PRESETS.map((preset) => [preset.id, preset]))
-const ICONIFY_ID = /^[a-z0-9-]+[:/][a-z0-9-]+$/i
-const ALIASES = new Map([
-  ['rocket', 'mdi:rocket-launch'],
-  ['mdi/rocket-launch', 'mdi:rocket-launch'],
-  ['layers', 'gateway'],
-  ['default', 'spexcode'],
-])
-
-export const IDENTITY_PRESET_IDS = Object.freeze(IDENTITY_PRESETS.map((preset) => preset.id))
-
-export function resolvedIdentityIcon(value, fallback = DEFAULT_PROJECT_ICON) {
-  const raw = typeof value === 'string' ? value.trim() : ''
-  const id = ALIASES.get(raw) || raw
-  return id || fallback
-}
-
-export function identityPreset(value) {
-  const raw = typeof value === 'string' ? value.trim() : ''
-  return BY_ID.get(ALIASES.get(raw) || raw) || null
-}
-
-export function isIconifyIcon(value) {
-  return ICONIFY_ID.test(typeof value === 'string' ? value.trim() : '')
-}
-
-export function requireIdentityChoice(value) {
-  const raw = typeof value === 'string' ? value.trim() : ''
-  const id = ALIASES.get(raw) || raw
-  if (BY_ID.has(id)) return id
-  if (isIconifyIcon(id)) return id.replace('/', ':')
-  throw new Error(`unknown identity icon '${raw}' (choose a preset or Iconify prefix:name)`)
-}
-
-function attrs(shape) {
-  return Object.entries(shape).filter(([key]) => key !== 'tag')
-    .map(([key, value]) => `${key === 'className' ? 'class' : key}="${String(value).replaceAll('&', '&').replaceAll('"', '"')}"`).join(' ')
-}
-
-export function identitySvg(value, fallback = DEFAULT_PROJECT_ICON) {
-  const preset = identityPreset(value) || identityPreset(fallback)
-  const geometry = preset.shapes.map((shape) => `<${shape.tag} ${attrs(shape)}/>`).join('')
-  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><rect x="1" y="1" width="22" height="22" rx="5" fill="${preset.bg}"/><g fill="none" stroke="${preset.fg}" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">${geometry}</g></svg>`
-}
-
-export function identityFaviconHref(value, fallback = DEFAULT_PROJECT_ICON) {
-  const resolved = resolvedIdentityIcon(value, fallback)
-  if (identityPreset(resolved)) return `data:image/svg+xml,${encodeURIComponent(identitySvg(resolved, fallback))}`
-  if (/^https?:\/\//.test(resolved)) return resolved
-  if (isIconifyIcon(resolved)) return `https://api.iconify.design/${resolved.replace(':', '/')}.svg`
-  const glyph = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><text x="50" y=".86em" font-size="82" text-anchor="middle">${resolved.replaceAll('&', '&amp;').replaceAll('<', '&lt;')}</text></svg>`
-  return `data:image/svg+xml,${encodeURIComponent(glyph)}`
-}

package/src/index.ts

@@ -1,20 +0,0 @@
-import { sourceIndexesFull } from './git.js'
-import { loadSpecs } from './specs.js'
-
-export async function readSpecs(root: string) {
-  const [history, drift] = await sourceIndexesFull(root)
-  return loadSpecs(root, { history, drift })
-}
-
-export * from './anchors.js'
-export * from './git.js'
-export * from './graph.js'
-export * from './harness-identity.js'
-export * from './layout.js'
-export * from './process-identity.js'
-export * from './project-identity.js'
-export * from './project-store.js'
-export * from './resilience.js'
-export * from './reviewSnapshot.js'
-export * from './root-lru.js'
-export * from './specs.js'