@squinch/core 0.1.0

package/dist/model/packs.d.ts

@@ -0,0 +1,13 @@
+import { iconTitle, iconColor, packMonochrome, packFullBleed } from "../packs/registry.js";
+export interface IconMeta {
+    /** Fallback plate text when a pack has no artwork (builtin/sys glyphs). */
+    code: string;
+    color: string;
+}
+export declare function iconMeta(pack: string, id: string): IconMeta | undefined;
+export { packMonochrome, packFullBleed, iconColor };
+export declare function iconExists(pack: string, id: string): boolean;
+export declare function packExists(pack: string): boolean;
+export declare function iconIds(pack: string): string[];
+export declare function allPackNames(): string[];
+export { iconTitle };

package/dist/model/packs.js

@@ -0,0 +1,29 @@
+// Model-facing pack surface. Real artwork lives in installed packs (see
+// ../packs/registry.ts); builtin/sys are renderer-drawn glyphs.
+import { hasIcon, hasPack, iconIds as registryIconIds, iconTitle, glyph, packNames, iconColor, packMonochrome, packFullBleed, } from "../packs/registry.js";
+export function iconMeta(pack, id) {
+    const g = glyph(pack, id);
+    if (g)
+        return g;
+    if (!hasIcon(pack, id))
+        return undefined;
+    return { code: "", color: iconColor(pack, id) ?? "#6F6E69" };
+}
+// `iconColor` is undefined for packs that publish no colours, which is the
+// honest test for "is this a brand mark?" — `iconMeta` folds a neutral grey in
+// as a fallback, and a renderer that read that could not tell a trademark from
+// our own generic vocabulary.
+export { packMonochrome, packFullBleed, iconColor };
+export function iconExists(pack, id) {
+    return hasIcon(pack, id);
+}
+export function packExists(pack) {
+    return hasPack(pack);
+}
+export function iconIds(pack) {
+    return registryIconIds(pack);
+}
+export function allPackNames() {
+    return packNames();
+}
+export { iconTitle };

package/dist/model/source.d.ts

@@ -0,0 +1,10 @@
+/** CRLF (and lone CR) → LF. Returns the same string when there is nothing to
+ *  do, so the common path costs one `memchr`-class scan. */
+export declare const normalizeSource: (src: string) => string;
+/** Positions are safe across this transform: a CR only ever sits at the end of
+ *  a line, so every line/character pair is identical before and after. That is
+ *  what lets a host normalize its own buffer and still map core's offsets back
+ *  into it — see `packages/vscode/src/features.ts`. */
+export declare const normalizeFiles: <T extends {
+    src: string;
+}>(files: T[]) => T[];

package/dist/model/source.js

@@ -0,0 +1,28 @@
+// Line endings are an *input* invariant, not only an output one.
+//
+// The determinism contract is: same (source, packs, theme, tool version) →
+// byte-identical SVG. A `.squinch` file checked out on Windows arrives CRLF.
+// The grammar itself skips `\r`, so nothing *fails* — which is precisely the
+// danger: anything downstream that reads the source text rather than the parse
+// tree sees a different string on Windows and quietly renders a different file.
+// The sketch theme was the first such reader (its jitter hashed the source, so
+// a CRLF checkout wobbled differently); it is gone, and the rule outlives it —
+// labels, descriptions and titleblock values are all source text that reaches
+// the SVG verbatim, and a host mapping `Loc` offsets back into its own buffer
+// depends on the same normalization.
+//
+// This is the ONE place source line endings are normalized. It is applied at
+// core's two entry points (`buildProject` and `renderProject`) rather than in
+// each host, because there are many hosts — CLI, VS Code, the playground, the
+// lookbook builder, the gauntlet scorer, the HTML export — and the one that
+// forgets produces a subtly different diagram rather than an error.
+/** CRLF (and lone CR) → LF. Returns the same string when there is nothing to
+ *  do, so the common path costs one `memchr`-class scan. */
+export const normalizeSource = (src) => src.includes("\r") ? src.replace(/\r\n?/g, "\n") : src;
+/** Positions are safe across this transform: a CR only ever sits at the end of
+ *  a line, so every line/character pair is identical before and after. That is
+ *  what lets a host normalize its own buffer and still map core's offsets back
+ *  into it — see `packages/vscode/src/features.ts`. */
+export const normalizeFiles = (files) => files.some((f) => f.src.includes("\r"))
+    ? files.map((f) => (f.src.includes("\r") ? { ...f, src: normalizeSource(f.src) } : f))
+    : files;

package/dist/model/suggest.d.ts

@@ -0,0 +1,2 @@
+/** Closest candidate within a length-proportional distance budget, or undefined. */
+export declare function suggest(input: string, candidates: string[]): string | undefined;

package/dist/model/suggest.js

@@ -0,0 +1,24 @@
+// Edit-distance suggestions for did-you-mean diagnostics.
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const d = Array.from({ length: m + 1 }, (_, i) => [i, ...Array(n).fill(0)]);
+    for (let j = 0; j <= n; j++)
+        d[0][j] = j;
+    for (let i = 1; i <= m; i++)
+        for (let j = 1; j <= n; j++)
+            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    return d[m][n];
+}
+/** Closest candidate within a length-proportional distance budget, or undefined. */
+export function suggest(input, candidates) {
+    let best;
+    let bestD = Math.max(2, Math.floor(input.length / 3)) + 1;
+    for (const c of candidates) {
+        const dist = levenshtein(input.toLowerCase(), c.toLowerCase());
+        if (dist < bestD) {
+            bestD = dist;
+            best = c;
+        }
+    }
+    return best;
+}

package/dist/model/types.d.ts

@@ -0,0 +1,226 @@
+export interface Loc {
+    from: number;
+    to: number;
+    line: number;
+    col: number;
+}
+export interface Diagnostic {
+    severity: "error" | "warning";
+    message: string;
+    fix?: string;
+    loc: Loc;
+    file?: string;
+}
+/** The one colour vocabulary (SPEC §3/§4/§Zones/§5): eight designed hues,
+ *  each a light/dark pair in the theme, plus the brand `accent`. The same nine
+ *  words apply to leaves, containers, edges, zones and a view's `color #tag`
+ *  statement — never hex, because a literal cannot be right on both canvases
+ *  and the adaptive merge swaps tokens, not values. Hue is annotation: shape
+ *  and pattern stay the encoding (DESIGN §6), so a reader who cannot tell red
+ *  from green loses emphasis, never meaning. */
+export declare const HUES: readonly ["red", "amber", "green", "teal", "blue", "violet", "pink", "gray", "accent"];
+export type Hue = (typeof HUES)[number];
+export interface SNode {
+    path: string;
+    name: string;
+    label: string;
+    icon?: {
+        pack: string;
+        id: string;
+    };
+    kinds: ("external" | "datastore" | "person")[];
+    description?: string;
+    tags: string[];
+    attrs: Record<string, string>;
+    /** `color:` — the node's spine, as a card's (DESIGN §3). Validated copy of `attrs.color`. */
+    color?: Hue;
+    loc: Loc;
+    file?: string;
+}
+export interface SContainer {
+    path: string;
+    name: string;
+    kind: "system" | "container";
+    /** `external` only — someone else's system, drawn with DESIGN §3's hatched
+     *  card surface. The other two node kinds have no card treatment and are
+     *  refused here. */
+    kinds: ("external")[];
+    label?: string;
+    children: string[];
+    attrs: Record<string, string>;
+    tags: string[];
+    /** `color:` — the card's spine, or the frame's stroke once expanded. */
+    color?: Hue;
+    loc: Loc;
+    file?: string;
+}
+export type ArrowKind = "->" | "~>" | "<->" | "--";
+/** Edge stroke styles (SPEC §edges). Sync edges default to solid, async to
+ *  dashed; `solid` on an async edge is a check-time error — the dash IS the
+ *  async convention. */
+export declare const EDGE_STYLES: readonly ["solid", "dashed", "dotted"];
+export type EdgeStyle = (typeof EDGE_STYLES)[number];
+/** `animate:` vocabulary (SPEC §edges). `false` opts out; the travel values
+ *  (flow/reverse/slow/fast) need a dash pattern to be visible, so on a sync
+ *  edge they require `style: dashed|dotted`; `packets` draws its own pattern;
+ *  `pulse` breathes and works on anything. One value per edge — no combos. */
+export declare const EDGE_ANIMATE: readonly ["false", "flow", "reverse", "slow", "fast", "packets", "pulse", "comet"];
+export type EdgeAnimate = Exclude<(typeof EDGE_ANIMATE)[number], "false">;
+export interface SEdge {
+    id: string;
+    from: string;
+    to: string;
+    arrow: ArrowKind;
+    label?: string;
+    attrs: Record<string, string>;
+    tags: string[];
+    /** `color:` — stroke, head and comet. Survives lifting only when every
+     *  aggregated member agrees, like `style`/`animate`. */
+    color?: Hue;
+    loc: Loc;
+    file?: string;
+}
+export type Side = "north" | "south" | "east" | "west";
+export type RelPos = "right-of" | "left-of" | "above" | "below";
+export type NoteAnchor = {
+    kind: "relpos";
+    relpos: RelPos;
+    target: string;
+} | {
+    kind: "edge";
+    from: string;
+    to: string;
+} | {
+    kind: "corner";
+    corner: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+};
+export interface SNote {
+    anchor: NoteAnchor;
+    text: string;
+    style?: string;
+    loc: Loc;
+}
+export interface SView {
+    name: string;
+    title?: string;
+    theme?: string;
+    scope?: string;
+    /** Filter: keep only interior elements matching these ids/tags. Empty = no
+     *  filter. This is the view's *which* axis; `scope` is its *where*. */
+    only: (string | {
+        tag: string;
+    })[];
+    include: (string | {
+        tag: string;
+    })[];
+    includeStar: boolean;
+    exclude: (string | {
+        tag: string;
+    })[];
+    expand: string[];
+    /** `expand *` — open every visible container to leaf depth, frames nesting
+     *  as they go (SPEC §5). The depth counterpart of `includeStar`'s breadth. */
+    expandStar: boolean;
+    /** Outside elements to draw at their own depth instead of as their top-level
+     *  card. Split out of `include`, which used to carry this second meaning. */
+    detail: string[];
+    context: "auto" | "off";
+    highlight: string[];
+    /** `color #tag <hue>` — colour everything visible that carries the tag.
+     *  A lens, so it overrides an element's own `color:`; declaration order,
+     *  last wins when two match one element (and that is a warning). */
+    colors: {
+        tag: string;
+        hue: Hue;
+        loc: Loc;
+    }[];
+    showDescriptions: boolean;
+    showFlow?: string;
+    legend: boolean;
+    titleblock?: Record<string, string>;
+    notes: SNote[];
+    layout: {
+        direction?: "down" | "right";
+        density?: "compact" | "comfortable" | "spacious";
+        lines?: "orthogonal" | "curved" | "straight";
+        rows?: string[][];
+        /** vertical bands, left to right: members share an axis exactly */
+        cols?: string[][];
+        place: {
+            node: string;
+            relpos: RelPos;
+            target: string;
+            loc: Loc;
+        }[];
+        /** `align a b c` — b and c share a's axis exactly (a is the anchor). */
+        align: {
+            nodes: string[];
+            loc: Loc;
+        }[];
+        routes: {
+            from: string;
+            to: string;
+            label?: string;
+            fromSide?: Side;
+            toSide?: Side;
+            loc: Loc;
+        }[];
+        /** `channel a, b, c -> db` — those edges merge into one trunk (SPEC §6 Tier 2). */
+        channels: {
+            sources: string[];
+            target: string;
+            loc: Loc;
+        }[];
+    };
+    loc: Loc;
+    file?: string;
+    /** Synthesized for a container that has no explicit view (SPEC §5). */
+    auto?: boolean;
+}
+export declare const ZONE_KINDS: readonly ["account", "region", "vpc", "subnet", "network", "cloud", "onprem", "custom"];
+export type ZoneKind = (typeof ZONE_KINDS)[number];
+export type ZoneLabelPos = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export interface SZone {
+    id: string;
+    label?: string;
+    kind: ZoneKind;
+    members: string[];
+    icon?: {
+        pack: string;
+        id: string;
+    };
+    labelPos: ZoneLabelPos;
+    /** outline/chip tint override; the default derives from `kind` (DESIGN §5) */
+    color?: Hue;
+    /** A second, monospaced chip segment for the boundary's hard fact — a CIDR
+     *  block, an account number, a region. Free text: the engine never parses
+     *  it, it just sets it in mono so digits line up between diagrams. */
+    detail?: string;
+    loc: Loc;
+    file?: string;
+}
+export interface SFlow {
+    id: string;
+    label?: string;
+    steps: {
+        from: string;
+        to: string;
+    }[];
+    loc: Loc;
+    file?: string;
+}
+export interface SModel {
+    packs: string[];
+    nodes: Map<string, SNode>;
+    containers: Map<string, SContainer>;
+    edges: SEdge[];
+    zones: SZone[];
+    flows: SFlow[];
+    views: SView[];
+    fileTheme?: string;
+}
+export interface BuildResult {
+    model: SModel;
+    diagnostics: Diagnostic[];
+    ok: boolean;
+}

package/dist/model/types.js

@@ -0,0 +1,24 @@
+/** The one colour vocabulary (SPEC §3/§4/§Zones/§5): eight designed hues,
+ *  each a light/dark pair in the theme, plus the brand `accent`. The same nine
+ *  words apply to leaves, containers, edges, zones and a view's `color #tag`
+ *  statement — never hex, because a literal cannot be right on both canvases
+ *  and the adaptive merge swaps tokens, not values. Hue is annotation: shape
+ *  and pattern stay the encoding (DESIGN §6), so a reader who cannot tell red
+ *  from green loses emphasis, never meaning. */
+export const HUES = [
+    "red", "amber", "green", "teal", "blue", "violet", "pink", "gray", "accent",
+];
+/** Edge stroke styles (SPEC §edges). Sync edges default to solid, async to
+ *  dashed; `solid` on an async edge is a check-time error — the dash IS the
+ *  async convention. */
+export const EDGE_STYLES = ["solid", "dashed", "dotted"];
+/** `animate:` vocabulary (SPEC §edges). `false` opts out; the travel values
+ *  (flow/reverse/slow/fast) need a dash pattern to be visible, so on a sync
+ *  edge they require `style: dashed|dotted`; `packets` draws its own pattern;
+ *  `pulse` breathes and works on anything. One value per edge — no combos. */
+export const EDGE_ANIMATE = ["false", "flow", "reverse", "slow", "fast", "packets", "pulse", "comet"];
+// Deployment boundaries (SPEC §Zones): cross-cutting membership, separate
+// from the ownership hierarchy. Kind drives the frame styling.
+export const ZONE_KINDS = [
+    "account", "region", "vpc", "subnet", "network", "cloud", "onprem", "custom",
+];

package/dist/packs/node-fs.d.ts

@@ -0,0 +1 @@
+export declare function registerPackFromDisk(packageName: string): boolean;

package/dist/packs/node-fs.js

@@ -0,0 +1,37 @@
+// Node-only pack source: finds installed packs on disk and registers them with
+// synchronous loaders. Imported for side effect by the Node entry point.
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { registerPack } from "./registry.js";
+export function registerPackFromDisk(packageName) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const short = packageName.replace("@squinch/", "");
+    const candidates = [];
+    try {
+        candidates.push(dirname(createRequire(import.meta.url).resolve(`${packageName}/pack.json`)));
+    }
+    catch {
+        /* not resolvable via node — fall back to workspace layout */
+    }
+    candidates.push(join(here, "..", "..", "..", short));
+    candidates.push(join(here, "..", "..", "..", "..", short));
+    // bundled hosts (the VS Code extension) ship the pack beside their output
+    candidates.push(join(here, short));
+    candidates.push(join(here, "..", short));
+    for (const dir of candidates) {
+        const manifestPath = join(dir, "pack.json");
+        if (!existsSync(manifestPath))
+            continue;
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+        registerPack(manifest, (file) => readFileSync(join(dir, "icons", file), "utf8"));
+        return true;
+    }
+    return false;
+}
+registerPackFromDisk("@squinch/pack-aws");
+registerPackFromDisk("@squinch/pack-azure");
+registerPackFromDisk("@squinch/pack-logos");
+registerPackFromDisk("@squinch/pack-sys");
+registerPackFromDisk("@squinch/pack-k8s");

package/dist/packs/registry.d.ts

@@ -0,0 +1,61 @@
+import { type SanitizedIcon } from "./sanitize.js";
+export interface PackManifest {
+    name: string;
+    title: string;
+    release?: string;
+    source?: string;
+    license?: string;
+    attribution?: string;
+    icons: Record<string, {
+        file: string;
+        title: string;
+        category?: string;
+        color?: string;
+    }>;
+    aliases?: Record<string, string>;
+    /** single-colour marks (e.g. Simple Icons): the renderer plates and tints
+     *  them rather than drawing the artwork on a neutral background. */
+    monochrome?: boolean;
+    /** artwork drawn edge-to-edge in its viewBox (no built-in optical margin,
+     *  unlike Azure's glyphs): contexts that place icons flush against a border
+     *  — the zone-chip tab — inset it slightly instead. Nodes are unaffected. */
+    fullBleed?: boolean;
+}
+/** Returns raw SVG text for a pack-relative file. May be async (browser). */
+export type AssetLoader = (file: string) => string | Promise<string>;
+/** Built-in fallbacks: no assets, drawn by the renderer itself.
+ *
+ *  `sys` used to live here too. It is a real disk pack now (@squinch/pack-sys,
+ *  Lucide), and a name present in BOTH this map and the pack registry is a trap:
+ *  `iconIds` short-circuits on this map, so every disk icon would vanish from
+ *  search, completions and `squinch icons` while `hasIcon` still accepted it. */
+export declare const BUILTIN_GLYPHS: Record<string, Record<string, {
+    code: string;
+    color: string;
+}>>;
+export declare function registerPack(manifest: PackManifest, load: AssetLoader): void;
+export declare function hasIcon(packName: string, id: string): boolean;
+export declare function hasPack(packName: string): boolean;
+export declare function packNames(): string[];
+export declare function iconIds(packName: string): string[];
+export declare function iconTitle(packName: string, id: string): string | undefined;
+/** Stable symbol id — aliases collapse onto their canonical icon. */
+export declare const symbolId: (packName: string, id: string) => string;
+/** Synchronous lookup used by the renderer; undefined until loaded. */
+export declare function iconAsset(packName: string, id: string): SanitizedIcon | undefined;
+/** Resolve assets ahead of a synchronous render (browsers). */
+export declare function preloadIcons(refs: {
+    pack: string;
+    id: string;
+}[]): Promise<void>;
+export declare function glyph(packName: string, id: string): {
+    code: string;
+    color: string;
+} | undefined;
+/** True when a pack's artwork is single-colour and wants the plate treatment. */
+export declare function packMonochrome(packName: string): boolean;
+/** True when a pack's artwork runs edge-to-edge in its viewBox (k8s). */
+export declare function packFullBleed(packName: string): boolean;
+/** A pack's declared brand colour for an icon, if it has one. */
+export declare function iconColor(packName: string, id: string): string | undefined;
+export declare function packInfo(packName: string): PackManifest | undefined;

package/dist/packs/registry.js

@@ -0,0 +1,122 @@
+// Pack registry — pure and browser-safe. Hosts supply assets:
+//   Node  : registerPackFromDisk() in ./node-fs.ts (used by the CLI + tests)
+//   Browser: registerPack() with a fetch-backed loader, then preloadIcons()
+// Rendering itself stays synchronous, so assets must be resident before render.
+import { SYS_GLYPH_ART, SYS_GLYPH_VIEWBOX } from "./sysGlyphs.js";
+import { sanitizeIcon } from "./sanitize.js";
+/** Built-in fallbacks: no assets, drawn by the renderer itself.
+ *
+ *  `sys` used to live here too. It is a real disk pack now (@squinch/pack-sys,
+ *  Lucide), and a name present in BOTH this map and the pack registry is a trap:
+ *  `iconIds` short-circuits on this map, so every disk icon would vanish from
+ *  search, completions and `squinch icons` while `hasIcon` still accepted it. */
+export const BUILTIN_GLYPHS = {
+    builtin: {
+        box: { code: "▢", color: "#6F6E69" },
+        person: { code: "☺", color: "#6F6E69" },
+    },
+};
+const packs = new Map();
+const assets = new Map();
+export function registerPack(manifest, load) {
+    packs.set(manifest.name, { manifest, load });
+}
+function canonical(pack, id) {
+    if (pack.manifest.icons[id])
+        return id;
+    const alias = pack.manifest.aliases?.[id];
+    return alias && pack.manifest.icons[alias] ? alias : undefined;
+}
+export function hasIcon(packName, id) {
+    if (BUILTIN_GLYPHS[packName]?.[id])
+        return true;
+    const pack = packs.get(packName);
+    return !!pack && !!canonical(pack, id);
+}
+export function hasPack(packName) {
+    return !!BUILTIN_GLYPHS[packName] || packs.has(packName);
+}
+export function packNames() {
+    return [...new Set([...Object.keys(BUILTIN_GLYPHS), ...packs.keys()])].sort();
+}
+export function iconIds(packName) {
+    const builtin = BUILTIN_GLYPHS[packName];
+    if (builtin)
+        return Object.keys(builtin);
+    const pack = packs.get(packName);
+    if (!pack)
+        return [];
+    return [...Object.keys(pack.manifest.icons), ...Object.keys(pack.manifest.aliases ?? {})].sort();
+}
+export function iconTitle(packName, id) {
+    const pack = packs.get(packName);
+    if (!pack)
+        return undefined;
+    const key = canonical(pack, id);
+    return key ? pack.manifest.icons[key].title : undefined;
+}
+/** Stable symbol id — aliases collapse onto their canonical icon. */
+export const symbolId = (packName, id) => {
+    const pack = packs.get(packName);
+    const key = pack ? canonical(pack, id) ?? id : id;
+    return `sq-${packName}-${key}`;
+};
+const cacheKey = (packName, key) => `${packName}/${key}`;
+/** Synchronous lookup used by the renderer; undefined until loaded. */
+export function iconAsset(packName, id) {
+    // first-party glyph artwork ships in-core (browser-safe, no preload needed)
+    const art = SYS_GLYPH_ART[packName]?.[id];
+    if (art)
+        return { viewBox: SYS_GLYPH_VIEWBOX, body: art };
+    const pack = packs.get(packName);
+    if (!pack)
+        return undefined;
+    const key = canonical(pack, id);
+    if (!key)
+        return undefined;
+    const hit = assets.get(cacheKey(packName, key));
+    if (hit)
+        return hit;
+    // Node loaders are synchronous: resolve inline so callers need no preload.
+    const raw = pack.load(pack.manifest.icons[key].file);
+    if (typeof raw !== "string")
+        return undefined; // async source → must preload
+    const asset = sanitizeIcon(raw, `${packName}-${key}`);
+    assets.set(cacheKey(packName, key), asset);
+    return asset;
+}
+/** Resolve assets ahead of a synchronous render (browsers). */
+export async function preloadIcons(refs) {
+    await Promise.all(refs.map(async ({ pack: packName, id }) => {
+        const pack = packs.get(packName);
+        if (!pack)
+            return;
+        const key = canonical(pack, id);
+        if (!key || assets.has(cacheKey(packName, key)))
+            return;
+        const raw = await pack.load(pack.manifest.icons[key].file);
+        assets.set(cacheKey(packName, key), sanitizeIcon(raw, `${packName}-${key}`));
+    }));
+}
+export function glyph(packName, id) {
+    return BUILTIN_GLYPHS[packName]?.[id];
+}
+/** True when a pack's artwork is single-colour and wants the plate treatment. */
+export function packMonochrome(packName) {
+    return packs.get(packName)?.manifest.monochrome === true;
+}
+/** True when a pack's artwork runs edge-to-edge in its viewBox (k8s). */
+export function packFullBleed(packName) {
+    return packs.get(packName)?.manifest.fullBleed === true;
+}
+/** A pack's declared brand colour for an icon, if it has one. */
+export function iconColor(packName, id) {
+    const pack = packs.get(packName);
+    if (!pack)
+        return undefined;
+    const key = canonical(pack, id);
+    return key ? pack.manifest.icons[key]?.color : undefined;
+}
+export function packInfo(packName) {
+    return packs.get(packName)?.manifest;
+}

package/dist/packs/sanitize.d.ts

@@ -0,0 +1,12 @@
+export interface SanitizedIcon {
+    /** Inner markup, ids namespaced, safe to inline. */
+    body: string;
+    /** viewBox of the original asset — placement uses it, never rewrites it. */
+    viewBox: string;
+}
+/**
+ * Strip everything not on the allowlist and namespace internal ids so several
+ * icons can coexist in one document. Does not alter geometry or colour — the
+ * asset itself must stay byte-faithful (CC-BY-ND).
+ */
+export declare function sanitizeIcon(svg: string, idPrefix: string): SanitizedIcon;