spexcode 0.6.2 → 0.6.6

package/node_modules/@spexcode/spec-core/dist/graph-delta.d.ts

@@ -0,0 +1,44 @@
+export type Units = Map<string, {
+    j: string;
+    v: unknown;
+}>;
+export type Delta = {
+    from: string;
+    to: string;
+    set: Record<string, unknown>;
+    del: string[];
+};
+type Boardish = {
+    nodes?: unknown;
+    sessions?: unknown;
+    [k: string]: unknown;
+};
+export declare function unitize(board: Boardish): {
+    units: Units;
+    ok: boolean;
+};
+export type UnitKeyKind = {
+    kind: 'node';
+    id: string;
+} | {
+    kind: 'nodes-order';
+} | {
+    kind: 'session';
+    id: string;
+} | {
+    kind: 'sessions-order';
+} | {
+    kind: 'meta';
+} | {
+    kind: 'unknown';
+    key: string;
+};
+export declare function unitKeyKind(key: string): UnitKeyKind;
+export declare function applyDelta(values: Map<string, unknown>, d: Pick<Delta, 'set' | 'del'>): Map<string, unknown>;
+export declare function boardFromUnits(values: Map<string, unknown>): Boardish;
+export declare function diffUnits(prev: Units, next: Units): {
+    set: Record<string, unknown>;
+    del: string[];
+};
+export declare const unitValues: (units: Units) => Map<string, unknown>;
+export {};

package/node_modules/@spexcode/spec-core/dist/graph-delta.js

@@ -0,0 +1,72 @@
+// decompose a board into units. `ok` = the bijection precondition held (arrays are arrays, ids unique &
+// non-empty); when false the map is still returned (usable for tagging) but must not seed a delta chain.
+export function unitize(board) {
+    const units = new Map();
+    let ok = true;
+    const keyed = (arr, prefix, orderKey) => {
+        const list = Array.isArray(arr) ? arr : (ok = false, []);
+        const order = [];
+        for (const item of list) {
+            const id = item?.id;
+            if (typeof id !== 'string' || !id || units.has(`${prefix}${id}`)) {
+                ok = false;
+                continue;
+            }
+            units.set(`${prefix}${id}`, { j: JSON.stringify(item), v: item });
+            order.push(id);
+        }
+        units.set(orderKey, { j: JSON.stringify(order), v: order });
+    };
+    const { nodes, sessions, ...meta } = board;
+    keyed(nodes, 'node:', 'nodes#order');
+    keyed(sessions, 'sess:', 'sess#order');
+    units.set('meta', { j: JSON.stringify(meta), v: meta });
+    return { units, ok };
+}
+export function unitKeyKind(key) {
+    if (key === 'nodes#order')
+        return { kind: 'nodes-order' };
+    if (key === 'sess#order')
+        return { kind: 'sessions-order' };
+    if (key === 'meta')
+        return { kind: 'meta' };
+    if (key.startsWith('node:') && key.length > 'node:'.length)
+        return { kind: 'node', id: key.slice(5) };
+    if (key.startsWith('sess:') && key.length > 'sess:'.length)
+        return { kind: 'session', id: key.slice(5) };
+    return { kind: 'unknown', key };
+}
+// apply a patch to a unit-value map — the exact algorithm the dashboard mirrors in data.js, kept here so
+// the round-trip property is provable against the real shape, not a paraphrase of it.
+export function applyDelta(values, d) {
+    const out = new Map(values);
+    for (const key of d.del)
+        out.delete(key);
+    for (const [key, v] of Object.entries(d.set))
+        out.set(key, v);
+    return out;
+}
+// reconstruct the board from unit values — R(U(B)) = B on the P-satisfying subspace (the client's render
+// input after every applied patch). Order rides the #order units, so array order survives the round trip.
+export function boardFromUnits(values) {
+    const pick = (prefix, orderKey) => {
+        const order = values.get(orderKey) || [];
+        return order.map((id) => values.get(`${prefix}${id}`));
+    };
+    const meta = values.get('meta') || {};
+    return { ...meta, nodes: pick('node:', 'nodes#order'), sessions: pick('sess:', 'sess#order') };
+}
+export function diffUnits(prev, next) {
+    const set = {};
+    const del = [];
+    for (const [key, u] of next) {
+        const p = prev.get(key);
+        if (!p || p.j !== u.j)
+            set[key] = u.v;
+    }
+    for (const key of prev.keys())
+        if (!next.has(key))
+            del.push(key);
+    return { set, del };
+}
+export const unitValues = (units) => new Map([...units].map(([k, u]) => [k, u.v]));

package/node_modules/@spexcode/spec-core/dist/graph.d.ts

@@ -0,0 +1,34 @@
+export type BoardSnapshot = {
+    root: string;
+    specs: any[];
+    layout: {
+        worktrees: any[];
+    };
+    sessions: any[];
+    issues: any[];
+    issuesStamp: string;
+    forgeRevision: number;
+    evalTimelines: Map<string, any>;
+    sessionEvalProjections: Map<string, any>;
+};
+export declare function latestPerScenario<T extends {
+    scenario: string;
+}>(readings: T[]): T[];
+export declare function nodeEvalSummary(scenarios: {
+    name: string;
+}[], readings: any[]): {
+    total: number;
+    pass: number;
+    fail: number;
+    stalePass: number;
+    staleFail: number;
+    empty: number;
+};
+export declare function buildBoard({ root, specs, layout, sessions, issues: merged, issuesStamp, forgeRevision, evalTimelines, sessionEvalProjections }: BoardSnapshot): Promise<{
+    nodes: any[];
+    sessions: any[];
+    identity: import("./project-identity.js").ResolvedIdentity;
+    issuesStamp: string;
+}>;
+export declare function spliceSessions(prev: Awaited<ReturnType<typeof buildBoard>>, sessions: any[], sessionEvalProjections: Map<string, any>): Promise<Awaited<ReturnType<typeof buildBoard>>>;
+export declare function rebasePublishedSessions(topology: Awaited<ReturnType<typeof buildBoard>>, published: Awaited<ReturnType<typeof buildBoard>>): Awaited<ReturnType<typeof buildBoard>>;

package/node_modules/@spexcode/spec-core/dist/graph.js

@@ -0,0 +1,237 @@
+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, byDir) {
+    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 server-only review snapshot keeps latest readings verbatim. Graph JSON receives only counts.
+export function latestPerScenario(readings) {
+    const seen = new Set();
+    return readings.filter((r) => !seen.has(r.scenario) && (seen.add(r.scenario), true));
+}
+export function nodeEvalSummary(scenarios, readings) {
+    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');
+        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, opsByPath) => (s.archived ? [] : opsByPath[s.path] || []);
+export async function buildBoard({ root, specs, layout, sessions, issues: merged, issuesStamp, forgeRevision, evalTimelines, sessionEvalProjections }) {
+    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 = {};
+    sessions.forEach((s) => { sessIdByPath[s.path] = s.id; });
+    const seedOf = (path) => sessIdByPath[path] || path;
+    const byId = Object.fromEntries(specs.map((n) => [n.id, n]));
+    const byDir = {};
+    specs.forEach((n) => { 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 = {};
+    const ghostById = {};
+    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) => {
+            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) => 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 = {};
+    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 = {};
+    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, sessions, sessionEvalProjections) {
+    const activeSources = new Set(sessions.map((session) => session.path));
+    const opsByPath = {};
+    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) => {
+        const overlays = (node.overlays || []).filter((overlay) => 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 = {};
+        for (const node of nodes)
+            if (node.path)
+                byDir[node.path.replace(/\/spec\.md$/, '')] = node.id;
+        const retainedIds = new Set(nodes.map((node) => node.id));
+        for (let index = 0; index < nodes.length; index++) {
+            const node = 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) => {
+                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, published) {
+    const opsByPath = {};
+    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/node_modules/@spexcode/spec-core/dist/graphDelta.d.ts

@@ -0,0 +1,3 @@
+import type { Units } from './graph-delta.js';
+export * from './graph-delta.js';
+export declare function tagOf(units: Units): string;

package/node_modules/@spexcode/spec-core/dist/graphDelta.js

@@ -0,0 +1,13 @@
+import { createHash } from 'node:crypto';
+export * from './graph-delta.js';
+// the snapshot tag: a digest over every unit's key + content hash, order-independent (keys sorted). Two
+// builds serializing equal content get equal tags; JSON.stringify equality is conservative (equal strings ⇒
+// equal values; a key-order difference at worst re-sends an unchanged unit, never misses a changed one).
+export function tagOf(units) {
+    const h = createHash('sha1');
+    for (const key of [...units.keys()].sort()) {
+        const u = units.get(key);
+        h.update(key).update('\0').update(u.j).update('\0');
+    }
+    return h.digest('hex');
+}

package/node_modules/@spexcode/spec-core/dist/harness-identity.d.ts

@@ -0,0 +1,31 @@
+export declare const HARNESS_IDENTITIES: readonly [{
+    readonly id: "claude";
+    readonly sessionEnvVar: "CLAUDE_CODE_SESSION_ID";
+}, {
+    readonly id: "codex";
+    readonly sessionEnvVar: "CODEX_THREAD_ID";
+}, {
+    readonly id: "opencode";
+    readonly sessionEnvVar: "OPENCODE_SESSION_ID";
+}, {
+    readonly id: "pi";
+    readonly sessionEnvVar: "PI_SESSION_ID";
+}, {
+    readonly id: "zcode";
+    readonly sessionEnvVar: "ZCODE_SESSION_ID";
+}, {
+    readonly id: "claude-headless";
+    readonly sessionEnvVar: "CLAUDE_CODE_SESSION_ID";
+}, {
+    readonly id: "opencode-headless";
+    readonly sessionEnvVar: "OPENCODE_SESSION_ID";
+}, {
+    readonly id: "pi-headless";
+    readonly sessionEnvVar: "PI_SESSION_ID";
+}, {
+    readonly id: "codex-headless";
+    readonly sessionEnvVar: "CODEX_THREAD_ID";
+}];
+export type HarnessId = typeof HARNESS_IDENTITIES[number]['id'];
+export type HarnessIdentity = typeof HARNESS_IDENTITIES[number];
+export declare function harnessIdentity(id: HarnessId): HarnessIdentity;

package/node_modules/@spexcode/spec-core/dist/harness-identity.js

@@ -0,0 +1,20 @@
+// 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' },
+];
+const identityById = new Map(HARNESS_IDENTITIES.map((identity) => [identity.id, identity]));
+export function harnessIdentity(id) {
+    const identity = identityById.get(id);
+    if (!identity)
+        throw new Error(`unknown harness identity '${id}'`);
+    return identity;
+}

package/node_modules/@spexcode/spec-core/dist/identity-presets.d.ts

@@ -0,0 +1,152 @@
+export function resolvedIdentityIcon(value: any, fallback?: string): string;
+export function identityPreset(value: any): {
+    id: string;
+    label: string;
+    bg: string;
+    fg: string;
+    shapes: {
+        tag: string;
+        d: string;
+        fill: string;
+        stroke: string;
+    }[];
+} | {
+    id: string;
+    label: string;
+    bg: string;
+    fg: string;
+    shapes: ({
+        tag: string;
+        d: string;
+        cx?: undefined;
+        cy?: undefined;
+        r?: undefined;
+    } | {
+        tag: string;
+        cx: number;
+        cy: number;
+        r: number;
+        d?: undefined;
+    })[];
+} | {
+    id: string;
+    label: string;
+    bg: string;
+    fg: string;
+    shapes: ({
+        tag: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        rx: number;
+        d?: undefined;
+    } | {
+        tag: string;
+        d: string;
+        x?: undefined;
+        y?: undefined;
+        width?: undefined;
+        height?: undefined;
+        rx?: undefined;
+    })[];
+} | {
+    id: string;
+    label: string;
+    bg: string;
+    fg: string;
+    shapes: ({
+        tag: string;
+        cx: number;
+        cy: number;
+        rx: number;
+        ry: number;
+        d?: undefined;
+    } | {
+        tag: string;
+        d: string;
+        cx?: undefined;
+        cy?: undefined;
+        rx?: undefined;
+        ry?: undefined;
+    })[];
+} | null;
+export function isIconifyIcon(value: any): boolean;
+export function requireIdentityChoice(value: any): string;
+export function identitySvg(value: any, fallback?: string): string;
+export function identityFaviconHref(value: any, fallback?: string): string;
+export const DEFAULT_PROJECT_ICON: "spexcode";
+export const DEFAULT_GATEWAY_ICON: "gateway";
+export const IDENTITY_PRESETS: readonly ({
+    id: string;
+    label: string;
+    bg: string;
+    fg: string;
+    shapes: {
+        tag: string;
+        d: string;
+        fill: string;
+        stroke: string;
+    }[];
+} | {
+    id: string;
+    label: string;
+    bg: string;
+    fg: string;
+    shapes: ({
+        tag: string;
+        d: string;
+        cx?: undefined;
+        cy?: undefined;
+        r?: undefined;
+    } | {
+        tag: string;
+        cx: number;
+        cy: number;
+        r: number;
+        d?: undefined;
+    })[];
+} | {
+    id: string;
+    label: string;
+    bg: string;
+    fg: string;
+    shapes: ({
+        tag: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        rx: number;
+        d?: undefined;
+    } | {
+        tag: string;
+        d: string;
+        x?: undefined;
+        y?: undefined;
+        width?: undefined;
+        height?: undefined;
+        rx?: undefined;
+    })[];
+} | {
+    id: string;
+    label: string;
+    bg: string;
+    fg: string;
+    shapes: ({
+        tag: string;
+        cx: number;
+        cy: number;
+        rx: number;
+        ry: number;
+        d?: undefined;
+    } | {
+        tag: string;
+        d: string;
+        cx?: undefined;
+        cy?: undefined;
+        rx?: undefined;
+        ry?: undefined;
+    })[];
+})[];
+export const IDENTITY_PRESET_IDS: readonly string[];