@nowline/layout 0.2.0

package/src/frame-tab-geometry.ts

@@ -0,0 +1,165 @@
+// Frame-tab chiclet geometry — the rounded label tab that overhangs a
+// swimlane's frame. Both the layout (collision math) and the renderer
+// (drawing) call `frameTabGeometry` so the chiclet's painted footprint
+// matches the bounding box layout reserves for it, and so the same
+// helper computes WHERE inside the chiclet each text element lands.
+//
+// Design note: this helper separates two concerns that used to be
+// conflated in a single set of "column widths":
+//
+//   * Text-end positions (`titleX`, `ownerX`, `badgeX`) are computed
+//     from estimated actual text widths plus a small explicit
+//     `FRAME_TAB_INNER_GAP_PX`. The renderer paints elements at these
+//     X coordinates directly — no second placement pass.
+//
+//   * Chiclet width (`tabW`) is computed from the right edge of the
+//     last painted element plus `FRAME_TAB_RIGHT_INSET_PX`, with a
+//     small minimum so a 2–3 char solo title still produces a usable
+//     chip. This means short labels naturally shrink-wrap their
+//     chiclet rather than reserving a wide whitespace column.
+//
+// The per-char width factors are calibrated to actual avg-char-width
+// of the system sans-serif stack at the relevant font sizes / weights.
+// They lean slightly conservative (~5 % over actual) so the chiclet
+// never visually clips its label even when the runtime font's metrics
+// exceed the calibration target.
+
+/**
+ * Px-per-char for a 12 pt 600-weight title in `FONT_STACK.sans`.
+ * Calibrated against system-ui at 12 pt bold (~6.3 px/char actual);
+ * 6.5 leaves a small safety margin without producing a wide gap to
+ * the owner / badge that follows.
+ */
+export const FRAME_TAB_TITLE_PX_PER_CHAR = 6.5;
+
+/**
+ * Px-per-char for a 10 pt regular owner suffix in `FONT_STACK.sans`.
+ * Calibrated against system-ui at 10 pt regular (~5 px/char actual).
+ */
+export const FRAME_TAB_OWNER_PX_PER_CHAR = 5;
+
+/**
+ * Visible gap (px) between adjacent text elements inside the chiclet:
+ * title→owner, owner→badge, and (no-owner) title→badge. Small enough
+ * to read as a single chip but big enough that the eye can still
+ * separate the tokens.
+ */
+export const FRAME_TAB_INNER_GAP_PX = 6;
+
+/** Horizontal inset (px) from the chiclet's left edge to the title text. */
+export const FRAME_TAB_LEFT_INSET_PX = 12;
+
+/** Horizontal inset (px) from the rightmost element's right edge to the chiclet's right edge. */
+export const FRAME_TAB_RIGHT_INSET_PX = 12;
+
+/**
+ * Minimum total chiclet width (px). Acts as a floor so very short
+ * solo titles ("Q1", "Mob") don't produce a tiny chip that's hard to
+ * notice. Owner / badge presence almost always pushes the chiclet
+ * past this floor on its own.
+ */
+export const FRAME_TAB_MIN_WIDTH_PX = 56;
+
+/** Horizontal offset (px) from the swimlane box's left edge to the tab's left edge. */
+export const FRAME_TAB_OFFSET_FROM_BOX_PX = 10;
+
+export interface FrameTabGeometry {
+    /** Estimated rendered width (px) of the title text, no min-clamp. */
+    titleTextWidth: number;
+    /** Estimated rendered width (px) of the owner suffix; 0 when no owner. */
+    ownerTextWidth: number;
+    /** Width (px) of the capacity badge as supplied by the caller; 0 when none. */
+    capacityBadgeWidth: number;
+    /** Width (px) of the footnote indicator text as supplied by the caller; 0 when none. */
+    footnoteIndicatorWidth: number;
+
+    /** Canvas X (px) where the title text is painted. */
+    titleX: number;
+    /** Canvas X (px) where the owner text is painted; 0 when no owner. */
+    ownerX: number;
+    /** Canvas X (px) where the capacity badge starts; 0 when no badge. */
+    badgeX: number;
+    /**
+     * Canvas X (px) for the right edge of the footnote indicator text
+     * (use with `text-anchor: end`); 0 when no footnote. Sits inside
+     * the chiclet just before the right inset.
+     */
+    footnoteRightX: number;
+
+    /** Left X (canvas px) of the chiclet rectangle. */
+    tabX: number;
+    /** Total chiclet width (px). */
+    tabW: number;
+    /** Right X (canvas px) of the chiclet — convenience for layout collisions. */
+    rightX: number;
+}
+
+/**
+ * Single source of truth for the swimlane chiclet's geometry.
+ *
+ * `capacityBadgeWidth` and `footnoteIndicatorWidth` are supplied by
+ * the caller — they depend on resolved icon shape / footnote-indicator
+ * string which neither the layout nor the renderer wants to duplicate.
+ * Pass 0 (or omit) when the lane has no capacity badge / footnote
+ * indicators to render.
+ *
+ * Layout order inside the chiclet, left → right:
+ *
+ *     [LEFT_INSET] title (INNER_GAP) owner (INNER_GAP) badge (INNER_GAP) footnote [RIGHT_INSET]
+ *
+ * Each element is optional except title; gaps are inserted only between
+ * present elements.
+ */
+export function frameTabGeometry(
+    boxX: number,
+    title: string,
+    owner: string | undefined,
+    capacityBadgeWidth: number = 0,
+    footnoteIndicatorWidth: number = 0,
+): FrameTabGeometry {
+    const tabX = boxX + FRAME_TAB_OFFSET_FROM_BOX_PX;
+    const titleX = tabX + FRAME_TAB_LEFT_INSET_PX;
+
+    const titleTextWidth = title.length * FRAME_TAB_TITLE_PX_PER_CHAR;
+    let cursorX = titleX + titleTextWidth;
+
+    let ownerTextWidth = 0;
+    let ownerX = 0;
+    if (owner) {
+        ownerTextWidth = `owner: ${owner}`.length * FRAME_TAB_OWNER_PX_PER_CHAR;
+        ownerX = cursorX + FRAME_TAB_INNER_GAP_PX;
+        cursorX = ownerX + ownerTextWidth;
+    }
+
+    let badgeX = 0;
+    if (capacityBadgeWidth > 0) {
+        badgeX = cursorX + FRAME_TAB_INNER_GAP_PX;
+        cursorX = badgeX + capacityBadgeWidth;
+    }
+
+    let footnoteRightX = 0;
+    if (footnoteIndicatorWidth > 0) {
+        // Footnote indicator paints with `text-anchor: end`, so its
+        // X is the RIGHT edge of the text. Add the gap before it and
+        // its own width to the running content cursor.
+        footnoteRightX = cursorX + FRAME_TAB_INNER_GAP_PX + footnoteIndicatorWidth;
+        cursorX = footnoteRightX;
+    }
+
+    const contentW = cursorX - tabX + FRAME_TAB_RIGHT_INSET_PX;
+    const tabW = Math.max(FRAME_TAB_MIN_WIDTH_PX, contentW);
+
+    return {
+        titleTextWidth,
+        ownerTextWidth,
+        capacityBadgeWidth,
+        footnoteIndicatorWidth,
+        titleX,
+        ownerX,
+        badgeX,
+        footnoteRightX,
+        tabX,
+        tabW,
+        rightX: tabX + tabW,
+    };
+}

package/src/header-card-geometry.ts

@@ -0,0 +1,48 @@
+// Header card geometry — sizing and text-stack metrics for the
+// "header card" that sits beside the timeline (title + author block).
+//
+// Layout owns the card *size* (computed up-front in `sizeBesideHeader`
+// from wrapped title/author text). The renderer paints the rectangle +
+// text using the *same* paddings, line heights, and font sizes so the
+// card is laid out and drawn consistently.
+//
+// Bumping any of these constants changes the visible size of the
+// header card and the position of every text line inside it. Always
+// keep the layout's `sizeBesideHeader` and the renderer's
+// `renderHeader` aligned by going through this module.
+
+/** Horizontal padding (px) inside the card from edge to text. */
+export const HEADER_CARD_PADDING_X = 16;
+
+/**
+ * Top padding (px) — measured to the BASELINE of the first title
+ * line. Larger than a typical "padding top" because it includes the
+ * cap-to-baseline distance for the 16 pt title font.
+ */
+export const HEADER_CARD_PADDING_TOP = 26;
+
+/**
+ * Bottom padding (px) below the descender of the last text line.
+ * Symmetric-feeling visual padding (smaller than `PADDING_TOP` since
+ * top includes the cap-to-baseline distance).
+ */
+export const HEADER_CARD_PADDING_BOTTOM = 14;
+
+/** Baseline-to-baseline spacing between consecutive title lines. */
+export const HEADER_TITLE_LINE_HEIGHT_PX = 20;
+
+/** Baseline-to-baseline spacing between consecutive author lines. */
+export const HEADER_AUTHOR_LINE_HEIGHT_PX = 14;
+
+/**
+ * Vertical gap (px) between the LAST title baseline and the FIRST
+ * author baseline. Larger than a normal line height because it spans
+ * the title's descender + the author's cap height.
+ */
+export const HEADER_TITLE_TO_AUTHOR_GAP_PX = 18;
+
+/** Font size (px) of the title text. */
+export const HEADER_TITLE_FONT_SIZE_PX = 16;
+
+/** Font size (px) of the author text (subtitle). */
+export const HEADER_AUTHOR_FONT_SIZE_PX = 11;

package/src/i18n.ts

@@ -0,0 +1,124 @@
+// Locale-aware strings used by the layout pipeline. Owns three things:
+//   - The BCP-47 fallback chain (`fr-CA → fr → en-US`).
+//   - A small message table for chrome strings the renderer paints
+//     directly (now-pill, quarter prefix).
+//   - The locale token passed to `Intl.DateTimeFormat` for axis labels.
+//
+// Today the table is inline; m-loc-d / m-loc-e (per `specs/localization.md`)
+// will move this to a proper `messages.<locale>.ts` bundle layout. The
+// shape here is deliberately minimal so that swap is mechanical.
+
+export const DEFAULT_LOCALE = 'en-US';
+
+export interface LocaleStrings {
+    /** Short label painted inside the now-line pill. Sized for ~3-6 chars. */
+    nowLabel: string;
+    /** Prefix used when the timeline scale is quarters (e.g. `Q1 2026` / `T1 2026`). */
+    quarterPrefix: string;
+}
+
+// Bundle entries keyed by language tag. The fallback chain strips the
+// trailing `-SUBTAG` and retries; a missing key in a child bundle falls
+// through to the parent. `en-US` is the root.
+//
+// Region overlays (fr-CA, fr-FR) are intentionally omitted: at launch they
+// have nothing region-specific to override. Empty overlays are a feature,
+// not a bug — they exist as a contract for future divergence. See
+// `specs/localization.md` § "Locale resolution".
+const BUNDLES: Record<string, Partial<LocaleStrings>> = {
+    'en-US': {
+        nowLabel: 'now',
+        quarterPrefix: 'Q',
+    },
+    fr: {
+        // Short form of "maintenant"; keeps the pill compact while staying
+        // correct French. The full word is too wide for the ~3-6 char pill
+        // budget without geometry work (tracked in m-loc-c).
+        nowLabel: 'maint.',
+        // `T` for trimestre — the standard French business convention.
+        quarterPrefix: 'T',
+    },
+};
+
+/**
+ * Resolve the effective locale for the rendered artifact.
+ *
+ * Precedence (highest wins):
+ *   1. `directiveLocale` — `nowline v1 locale:fr-CA` from the file itself.
+ *      The file is the artifact; its declared locale is authoritative the
+ *      same way `<html lang="fr">` is on a web page or `:lang:` is in
+ *      AsciiDoc. This guarantees cross-machine determinism: a French
+ *      roadmap renders French even when invoked from a US-locale shell.
+ *   2. `override` — the CLI `--locale` flag plus env-var fallback,
+ *      already resolved by the CLI before calling layout. Used only when
+ *      the file declines to declare its own locale.
+ *   3. `DEFAULT_LOCALE` (`en-US`).
+ *
+ * Returns the input string verbatim — callers downstream walk the BCP-47
+ * fallback chain to find string entries.
+ *
+ * Note: the operator's locale (CLI flag / env vars) controls a separate,
+ * independent chain for terminal output (validator diagnostics, --help,
+ * verbose logs). See `specs/localization.md` for the two-chain model.
+ */
+export function resolveLocale(
+    override: string | undefined,
+    directiveLocale: string | undefined,
+): string {
+    return directiveLocale ?? override ?? DEFAULT_LOCALE;
+}
+
+/**
+ * Look up a locale's chrome strings, walking the BCP-47 tree until a
+ * value is found. The walk strips the trailing `-SUBTAG` and retries:
+ *   `fr-CA → fr → en-US`
+ *   `fr-BE → fr → en-US` (no fr-BE bundle yet — works for free)
+ *   `de-AT → de → en-US` (no de bundles yet — falls all the way through)
+ *
+ * Always returns a fully-populated `LocaleStrings` because the `en-US`
+ * root has every key.
+ */
+export function localeStrings(locale: string): LocaleStrings {
+    const result: Partial<LocaleStrings> = {};
+    for (const tag of fallbackChain(locale)) {
+        const bundle = BUNDLES[tag];
+        if (!bundle) continue;
+        for (const key of Object.keys(bundle) as (keyof LocaleStrings)[]) {
+            if (result[key] === undefined && bundle[key] !== undefined) {
+                result[key] = bundle[key];
+            }
+        }
+    }
+    // The root bundle (`en-US`) is always populated, so this cast is safe.
+    return result as LocaleStrings;
+}
+
+/**
+ * BCP-47 fallback chain for a locale tag. Strips trailing `-SUBTAG`s
+ * one at a time until a primary subtag remains, then appends the root
+ * locale. Case-normalized to lowercase primary + uppercase region so
+ * lookups are stable regardless of input casing.
+ */
+export function fallbackChain(locale: string): string[] {
+    const chain: string[] = [];
+    let current = normalizeTag(locale);
+    while (current.length > 0) {
+        if (!chain.includes(current)) chain.push(current);
+        const dash = current.lastIndexOf('-');
+        if (dash <= 0) break;
+        current = current.slice(0, dash);
+    }
+    if (!chain.includes(DEFAULT_LOCALE)) chain.push(DEFAULT_LOCALE);
+    return chain;
+}
+
+function normalizeTag(locale: string): string {
+    const parts = locale.split('-');
+    return parts
+        .map((part, index) => {
+            if (index === 0) return part.toLowerCase();
+            // Region subtag: 2 letters → upper-case; 3 digits → keep as-is.
+            return /^[a-zA-Z]{2}$/.test(part) ? part.toUpperCase() : part;
+        })
+        .join('-');
+}

package/src/include-chrome-geometry.ts

@@ -0,0 +1,156 @@
+// Include-region chrome geometry — the label tab + content badge +
+// source-path bookmark that float across the top edge of an isolated
+// `include {}` region's dashed bracket. Both the layout (which needs
+// to know the chrome's right edge to shrink-wrap the bracket) and the
+// renderer (which paints each element) call `includeChromeGeometry`,
+// so the painted footprint and the layout's reserved footprint stay
+// in sync. Mirrors `frameTabGeometry`'s "compute placement X for each
+// element + derive total width from the cursor" model.
+//
+// Layout order, left → right:
+//
+//   [LEFT_INSET] tab(LABEL) (BADGE_GAP) badge (SOURCE_GAP) [HALO_PAD] source [HALO_PAD]
+//
+// The badge and source-path are optional in spirit but always present
+// for current `include` regions; the helper passes `0` widths through
+// cleanly should that ever change.
+
+/**
+ * Horizontal offset (px) from the include region's bounding-box left
+ * edge to the label tab's left edge. Equals the region's outer pad
+ * (8 px from `renderIncludeRegion`) plus a 16 px tab inset that keeps
+ * the chiclet visually anchored inside the dashed bracket rather than
+ * straddling its rounded corner.
+ */
+export const INCLUDE_CHROME_OFFSET_FROM_BOX_PX = 24;
+
+/** Horizontal inset (px) from the tab's left edge to the label text. */
+export const INCLUDE_CHROME_TAB_LEFT_INSET_PX = 10;
+/**
+ * Horizontal inset (px) from the label text's right edge to the tab's
+ * right edge. Same as the left inset so the label appears optically
+ * centered inside its chiclet.
+ */
+export const INCLUDE_CHROME_TAB_RIGHT_INSET_PX = 10;
+
+/**
+ * Px-per-char for the label rendered at 11 pt 600w in `FONT_STACK.sans`.
+ * Calibrated against system-ui at 11 pt bold (~5.8 px/char actual);
+ * 6.0 leaves a small safety margin without producing wide right
+ * whitespace inside the chiclet.
+ */
+export const INCLUDE_CHROME_TAB_LABEL_PER_CHAR_PX = 6;
+
+/**
+ * Minimum total chiclet width (px). A floor so tiny labels still
+ * produce a chip wide enough to read; the badge/source bookmark sit
+ * outside the chiclet so they never push it past this minimum.
+ */
+export const INCLUDE_CHROME_TAB_MIN_WIDTH_PX = 60;
+
+/** Gap (px) between the chiclet's right edge and the content badge. */
+export const INCLUDE_CHROME_BADGE_GAP_PX = 6;
+/** Square content-badge tile size (px). */
+export const INCLUDE_CHROME_BADGE_SIZE_PX = 18;
+
+/** Gap (px) between the badge's right edge and the source-path text. */
+export const INCLUDE_CHROME_SOURCE_GAP_PX = 6;
+/**
+ * Px-per-char for the source-path rendered at 9 pt in `FONT_STACK.mono`.
+ * Calibrated against ui-monospace at 9 pt regular (~5.4 px/char actual);
+ * 5.5 leaves a small safety margin so the halo never clips the path.
+ */
+export const INCLUDE_CHROME_SOURCE_PER_CHAR_PX = 5.5;
+/**
+ * Halo padding (px) on each side of the source-path text. The halo
+ * masks the dashed bracket border that runs through the text's
+ * baseline so the path stays legible.
+ */
+export const INCLUDE_CHROME_SOURCE_HALO_PAD_PX = 3;
+
+export interface IncludeChromeGeometry {
+    /** Estimated rendered width (px) of the label text, no min-clamp. */
+    labelTextWidth: number;
+    /** Estimated rendered width (px) of the source-path text; 0 when no source. */
+    sourceTextWidth: number;
+
+    /** Left X (canvas px) of the chiclet rectangle. */
+    tabX: number;
+    /** Total chiclet width (px), with min-width floor applied. */
+    tabWidth: number;
+    /** Canvas X (px) where the label text is painted (left-anchored). */
+    tabLabelX: number;
+
+    /** Left X (canvas px) of the content-badge tile; 0 when no badge. */
+    badgeX: number;
+    /** Square content-badge tile size (px); mirrors `INCLUDE_CHROME_BADGE_SIZE_PX`. */
+    badgeSize: number;
+
+    /** Left X (canvas px) of the source-path halo rect; 0 when no source. */
+    sourceHaloX: number;
+    /** Width (px) of the source-path halo rect; 0 when no source. */
+    sourceHaloWidth: number;
+    /** Canvas X (px) where the source-path text is painted (left-anchored); 0 when no source. */
+    sourceTextX: number;
+
+    /**
+     * Right edge (canvas px) of the entire chrome strip — used by the
+     * layout to size the include region's bounding box so the dashed
+     * bracket always encloses its own chrome. Equals the badge's right
+     * edge when no source is present, or the halo's right edge when
+     * one is.
+     */
+    chromeRightX: number;
+}
+
+/**
+ * Single source of truth for the include-region chrome's geometry.
+ *
+ * `boxX` is the left edge of the include region's bounding box in
+ * canvas px. `label` is the chiclet text; `sourcePath` is the
+ * breadcrumb beside the badge (pass `''` to omit the bookmark).
+ */
+export function includeChromeGeometry(
+    boxX: number,
+    label: string,
+    sourcePath: string,
+): IncludeChromeGeometry {
+    const tabX = boxX + INCLUDE_CHROME_OFFSET_FROM_BOX_PX;
+    const tabLabelX = tabX + INCLUDE_CHROME_TAB_LEFT_INSET_PX;
+
+    const labelTextWidth = label.length * INCLUDE_CHROME_TAB_LABEL_PER_CHAR_PX;
+    const tabWidth = Math.max(
+        INCLUDE_CHROME_TAB_MIN_WIDTH_PX,
+        labelTextWidth + INCLUDE_CHROME_TAB_LEFT_INSET_PX + INCLUDE_CHROME_TAB_RIGHT_INSET_PX,
+    );
+
+    const badgeX = tabX + tabWidth + INCLUDE_CHROME_BADGE_GAP_PX;
+    const badgeRightX = badgeX + INCLUDE_CHROME_BADGE_SIZE_PX;
+
+    let sourceTextWidth = 0;
+    let sourceTextX = 0;
+    let sourceHaloX = 0;
+    let sourceHaloWidth = 0;
+    let chromeRightX = badgeRightX;
+    if (sourcePath) {
+        sourceTextX = badgeRightX + INCLUDE_CHROME_SOURCE_GAP_PX;
+        sourceTextWidth = sourcePath.length * INCLUDE_CHROME_SOURCE_PER_CHAR_PX;
+        sourceHaloX = sourceTextX - INCLUDE_CHROME_SOURCE_HALO_PAD_PX;
+        sourceHaloWidth = sourceTextWidth + INCLUDE_CHROME_SOURCE_HALO_PAD_PX * 2;
+        chromeRightX = sourceHaloX + sourceHaloWidth;
+    }
+
+    return {
+        labelTextWidth,
+        sourceTextWidth,
+        tabX,
+        tabWidth,
+        tabLabelX,
+        badgeX,
+        badgeSize: INCLUDE_CHROME_BADGE_SIZE_PX,
+        sourceHaloX,
+        sourceHaloWidth,
+        sourceTextX,
+        chromeRightX,
+    };
+}

package/src/index.ts

@@ -0,0 +1,116 @@
+export {
+    estimateCapacitySuffixWidth,
+    formatCapacityNumber,
+    parseCapacityValue,
+    type ResolvedCapacityIcon,
+    resolveCapacityIcon,
+} from './capacity.js';
+export {
+    FRAME_TAB_INNER_GAP_PX,
+    FRAME_TAB_LEFT_INSET_PX,
+    FRAME_TAB_MIN_WIDTH_PX,
+    FRAME_TAB_OFFSET_FROM_BOX_PX,
+    FRAME_TAB_OWNER_PX_PER_CHAR,
+    FRAME_TAB_RIGHT_INSET_PX,
+    FRAME_TAB_TITLE_PX_PER_CHAR,
+    type FrameTabGeometry,
+    frameTabGeometry,
+} from './frame-tab-geometry.js';
+export {
+    HEADER_AUTHOR_FONT_SIZE_PX,
+    HEADER_AUTHOR_LINE_HEIGHT_PX,
+    HEADER_CARD_PADDING_BOTTOM,
+    HEADER_CARD_PADDING_TOP,
+    HEADER_CARD_PADDING_X,
+    HEADER_TITLE_FONT_SIZE_PX,
+    HEADER_TITLE_LINE_HEIGHT_PX,
+    HEADER_TITLE_TO_AUTHOR_GAP_PX,
+} from './header-card-geometry.js';
+export {
+    INCLUDE_CHROME_BADGE_GAP_PX,
+    INCLUDE_CHROME_BADGE_SIZE_PX,
+    INCLUDE_CHROME_OFFSET_FROM_BOX_PX,
+    INCLUDE_CHROME_SOURCE_GAP_PX,
+    INCLUDE_CHROME_SOURCE_HALO_PAD_PX,
+    INCLUDE_CHROME_SOURCE_PER_CHAR_PX,
+    INCLUDE_CHROME_TAB_LABEL_PER_CHAR_PX,
+    INCLUDE_CHROME_TAB_LEFT_INSET_PX,
+    INCLUDE_CHROME_TAB_MIN_WIDTH_PX,
+    INCLUDE_CHROME_TAB_RIGHT_INSET_PX,
+    type IncludeChromeGeometry,
+    includeChromeGeometry,
+} from './include-chrome-geometry.js';
+export {
+    ITEM_CAPTION_INSET_X_PX,
+    ITEM_CAPTION_META_BASELINE_OFFSET_PX,
+    ITEM_CAPTION_META_FONT_SIZE_PX,
+    ITEM_CAPTION_SPILL_GAP_PX,
+    ITEM_CAPTION_TITLE_BASELINE_OFFSET_PX,
+    ITEM_CAPTION_TITLE_FONT_SIZE_PX,
+    ITEM_DECORATION_SPILL_GAP_PX,
+    ITEM_FOOTNOTE_INDICATOR_BASELINE_OFFSET_PX,
+    ITEM_FOOTNOTE_INDICATOR_INSET_RIGHT_PX,
+    ITEM_FOOTNOTE_INDICATOR_STEP_PX,
+    ITEM_LINK_ICON_INSET_PX,
+    ITEM_LINK_ICON_TILE_SIZE_PX,
+    ITEM_STATUS_DOT_INSET_RIGHT_PX,
+    ITEM_STATUS_DOT_INSET_TOP_PX,
+    ITEM_STATUS_DOT_RADIUS_PX,
+    LABEL_CHIP_GAP_ABOVE_PROGRESS_STRIP_PX,
+    LABEL_CHIP_GAP_BETWEEN_PX,
+    LABEL_CHIP_HEIGHT_PX,
+    MIN_BAR_WIDTH_FOR_DOT_PX,
+    MIN_BAR_WIDTH_FOR_FOOTNOTE_PX,
+    MIN_BAR_WIDTH_FOR_LINK_AND_DOT_PX,
+} from './item-bar-geometry.js';
+export type { LayoutOptions, LayoutResult } from './layout.js';
+export { layoutRoadmap } from './layout.js';
+export {
+    darkTheme,
+    lightTheme,
+    type Theme,
+    type ThemeName,
+    themes,
+} from './themes/index.js';
+export {
+    ACCENT_DASH_PATTERN,
+    ATTRIBUTION_BAR_LOGICAL_WIDTH,
+    ATTRIBUTION_BAR_LOGICAL_X,
+    ATTRIBUTION_INE_LOGICAL_X,
+    ATTRIBUTION_LINK,
+    ATTRIBUTION_NOW_LOGICAL_X,
+    ATTRIBUTION_PREFIX_FONT_SIZE,
+    ATTRIBUTION_SCALE,
+    ATTRIBUTION_TEXT,
+    ATTRIBUTION_WORDMARK_FONT_SIZE,
+    CORNER_RADIUS_PX,
+    EDGE_CORNER_RADIUS,
+    FONT_STACK,
+    FOOTNOTE_HEADER_BASELINE_OFFSET_PX,
+    FOOTNOTE_HEADER_HEIGHT_PX,
+    FOOTNOTE_PANEL_PADDING_PX,
+    FOOTNOTE_ROW_HEIGHT,
+    FRAME_TAB_HEIGHT_PX,
+    FRAME_TAB_LABEL_BASELINE_OFFSET_PX,
+    GROUP_BOTTOM_PAD_PX,
+    GROUP_BRACKET_LABEL_OVERHANG_PX,
+    GROUP_TITLE_TAB_CHAR_WIDTH_PX,
+    GROUP_TITLE_TAB_GUTTER_PX,
+    GROUP_TITLE_TAB_HEIGHT_PX,
+    GROUP_TITLE_TAB_LABEL_BASELINE_OFFSET_PX,
+    GROUP_TITLE_TAB_LABEL_FONT_SIZE_PX,
+    GROUP_TITLE_TAB_PAD_X_PX,
+    NOW_PILL_CORNER_RADIUS_PX,
+    NOW_PILL_HEIGHT_PX,
+    NOW_PILL_LABEL_BASELINE_OFFSET_PX,
+    NOW_PILL_LABEL_FONT_SIZE_PX,
+    NOW_PILL_LABEL_INSET_X_PX,
+    NOW_PILL_WIDTH_PX,
+    NOWLINE_STROKE_WIDTH_PX,
+    PROGRESS_STRIP_HEIGHT_PX,
+    TEXT_SIZE_PX,
+    TIMELINE_TICK_LABEL_BASELINE_OFFSET_PX,
+    TIMELINE_TICK_PANEL_HEIGHT_PX,
+    TRACK_BLOCK_TAIL_GUTTER_PX,
+} from './themes/shared.js';
+export * from './types.js';