@markii/ansi 0.0.1

package/dist/components/card.js

@@ -0,0 +1,44 @@
+import { measure } from '../measure.js';
+import { selfLayoutAlign, selfLayoutWidth } from '../layout.js';
+const TEXT_ALIGNS = ['left', 'center', 'right'];
+function isTextAlign(value) {
+    return TEXT_ALIGNS.includes(value);
+}
+/** `width=fit` with no `title` and an unhelpfully-shaped body (nothing to measure a sensible box from) falls back to this column count rather than the full available width. */
+const FIT_DEFAULT_WIDTH = 40;
+/** Frame border + one space of interior padding on each side. */
+const FRAME_OVERHEAD = 2;
+/**
+ * `:::card{title="..." text=left|center|right} ... :::` — a titled panel.
+ * `title` is optional; the title is woven into the frame's top edge, not a
+ * separate line, when given. `text` aligns the body inside the frame;
+ * absent/invalid behaves as `left`.
+ *
+ * Registered `selfLayout` (see `callout.ts`'s doc comment for why): this
+ * component draws a real box-drawn frame, which a generic post-render
+ * narrow/pad would corrupt, so it reads `ctx.layout` and sizes its own frame.
+ */
+export const Card = (attributes, children, ctx) => {
+    const title = attributes.title ?? null;
+    const titleText = title ? ctx.text(title) : undefined;
+    const rawTextAlign = attributes.text;
+    const align = rawTextAlign && isTextAlign(rawTextAlign) ? rawTextAlign : 'left';
+    const naturalWidth = titleText
+        ? measure(titleText) + FRAME_OVERHEAD * 2
+        : FIT_DEFAULT_WIDTH;
+    const boxWidth = selfLayoutWidth(ctx.layout, ctx.width, naturalWidth);
+    const innerWidth = Math.max(1, boxWidth - FRAME_OVERHEAD);
+    const childrenText = children({ width: innerWidth });
+    const body = childrenText
+        ? childrenText
+            .split('\n')
+            .map((line) => align === 'left' ? line : ctx.pad(line, innerWidth, align))
+            .join('\n')
+        : '';
+    const framed = ctx.frame(body, {
+        style: 'solid',
+        title: titleText,
+        width: boxWidth,
+    });
+    return selfLayoutAlign(framed, ctx.layout, ctx.width);
+};

package/dist/components/cell.d.ts

@@ -0,0 +1,18 @@
+import type { AnsiComponent } from '../registry.js';
+/**
+ * `:::cell ... :::` — a transparent grouping container whose only job is
+ * letting several blocks count as ONE cell of `:::row`.
+ *
+ * `row.ts` no longer discovers its cells by splitting a flattened string on
+ * a blank-line heuristic: it walks its own directive's top-level children
+ * directly (`registry.ts`'s `AnsiChildren.parts`), so a `cell` grouping more
+ * than one block renders those blocks exactly as it would standalone,
+ * blank line and all, with no collapsing needed to keep a cell boundary
+ * unambiguous for `row.ts`.
+ *
+ * `text` aligns this cell's own content when rendered STANDALONE (outside a
+ * `row`); nested inside a `row`, the row's own `text` decides every cell's
+ * alignment uniformly instead, for the same reason `row.ts` does not look
+ * inside a cell's own attributes when it places columns.
+ */
+export declare const Cell: AnsiComponent;

package/dist/components/cell.js

@@ -0,0 +1,31 @@
+const TEXT_ALIGNS = ['left', 'center', 'right'];
+function isTextAlign(value) {
+    return TEXT_ALIGNS.includes(value);
+}
+/**
+ * `:::cell ... :::` — a transparent grouping container whose only job is
+ * letting several blocks count as ONE cell of `:::row`.
+ *
+ * `row.ts` no longer discovers its cells by splitting a flattened string on
+ * a blank-line heuristic: it walks its own directive's top-level children
+ * directly (`registry.ts`'s `AnsiChildren.parts`), so a `cell` grouping more
+ * than one block renders those blocks exactly as it would standalone,
+ * blank line and all, with no collapsing needed to keep a cell boundary
+ * unambiguous for `row.ts`.
+ *
+ * `text` aligns this cell's own content when rendered STANDALONE (outside a
+ * `row`); nested inside a `row`, the row's own `text` decides every cell's
+ * alignment uniformly instead, for the same reason `row.ts` does not look
+ * inside a cell's own attributes when it places columns.
+ */
+export const Cell = (attributes, children, ctx) => {
+    const rawTextAlign = attributes.text;
+    const align = rawTextAlign && isTextAlign(rawTextAlign) ? rawTextAlign : undefined;
+    const childrenText = children();
+    if (!align || align === 'left')
+        return childrenText;
+    return childrenText
+        .split('\n')
+        .map((line) => ctx.pad(line, ctx.width, align))
+        .join('\n');
+};

package/dist/components/chart.d.ts

@@ -0,0 +1,15 @@
+import type { AnsiComponent } from '../registry.js';
+/**
+ * `::chart{kind=line|bar values="1,3,2,5"}` — a dependency-free, hand-rolled
+ * chart. Data binding (§8) mirrors `@markii/html`'s `Chart`: a bound `data`
+ * array of numbers (or `{value}` objects) takes priority over the static
+ * `values=` attribute; non-numeric/non-finite entries are dropped and the
+ * point count capped at `MAX_POINTS`. An empty or all-invalid series renders
+ * a small neutral "no data" line rather than a broken chart.
+ *
+ * Terminal form: a `line` chart is a single sparkline row (`▁▂▃▄▅▆▇█`),
+ * flanked by its minimum and maximum as plain numbers. A `bar` chart is one
+ * horizontal `█` bar per point, its own value as the row's label, labels
+ * right-aligned to the widest one so every bar starts at the same column.
+ */
+export declare const Chart: AnsiComponent;

package/dist/components/chart.js

@@ -0,0 +1,129 @@
+import { pad } from '../box.js';
+import { measure } from '../measure.js';
+import { safeRead } from '../resolve.js';
+import { dataStateSuffix, failureToken } from '../failure-presentation.js';
+const CHART_KINDS = ['line', 'bar'];
+function isChartKind(value) {
+    return CHART_KINDS.includes(value);
+}
+const DEFAULT_KIND = 'line';
+/** Hard cap on rendered points, independent of source (mirrors `@markii/html`'s `Chart`). */
+const MAX_POINTS = 200;
+function parseNumericString(raw) {
+    const trimmed = raw.trim();
+    if (trimmed === '')
+        return undefined;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function coercePoint(entry) {
+    if (typeof entry === 'number')
+        return Number.isFinite(entry) ? entry : undefined;
+    if (typeof entry === 'string')
+        return parseNumericString(entry);
+    if (entry !== null && typeof entry === 'object' && !Array.isArray(entry)) {
+        const value = entry.value;
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+        if (typeof value === 'string')
+            return parseNumericString(value);
+    }
+    return undefined;
+}
+/** Builds the numeric point series to plot, a bound `data` array taking priority over the static `values=` attribute. Ported from `@markii/html`'s `resolvePoints`. */
+function resolvePoints(data, dataStatus, rawValues) {
+    if (dataStatus !== 'missing' &&
+        dataStatus !== 'error' &&
+        Array.isArray(data)) {
+        const points = [];
+        for (const entry of data) {
+            const point = coercePoint(entry);
+            if (point !== undefined)
+                points.push(point);
+            if (points.length >= MAX_POINTS)
+                break;
+        }
+        return points;
+    }
+    if (rawValues) {
+        const points = [];
+        for (const token of rawValues.split(',')) {
+            const point = coercePoint(token.trim());
+            if (point !== undefined)
+                points.push(point);
+            if (points.length >= MAX_POINTS)
+                break;
+        }
+        return points;
+    }
+    return [];
+}
+/** `▁▂▃▄▅▆▇█`, the eight-step block-height ramp a line chart's sparkline row is built from. */
+const SPARKLINE_CHARS = '▁▂▃▄▅▆▇█';
+function formatPoint(value) {
+    return Number.isFinite(value)
+        ? String(Math.round(value * 100) / 100)
+        : String(value);
+}
+function sparkline(points) {
+    const min = Math.min(...points);
+    const max = Math.max(...points);
+    const range = max - min;
+    return points
+        .map((point) => {
+        const normalized = range > 0 ? (point - min) / range : 0.5;
+        const index = Math.min(SPARKLINE_CHARS.length - 1, Math.max(0, Math.round(normalized * (SPARKLINE_CHARS.length - 1))));
+        return SPARKLINE_CHARS[index];
+    })
+        .join('');
+}
+/** `██████` bar length for `point`, scaled against the series' largest magnitude and capped at `budget` columns. */
+function barLength(point, maxMagnitude, budget) {
+    if (maxMagnitude <= 0)
+        return 0;
+    return Math.max(0, Math.min(budget, Math.round((Math.abs(point) / maxMagnitude) * budget)));
+}
+/**
+ * `::chart{kind=line|bar values="1,3,2,5"}` — a dependency-free, hand-rolled
+ * chart. Data binding (§8) mirrors `@markii/html`'s `Chart`: a bound `data`
+ * array of numbers (or `{value}` objects) takes priority over the static
+ * `values=` attribute; non-numeric/non-finite entries are dropped and the
+ * point count capped at `MAX_POINTS`. An empty or all-invalid series renders
+ * a small neutral "no data" line rather than a broken chart.
+ *
+ * Terminal form: a `line` chart is a single sparkline row (`▁▂▃▄▅▆▇█`),
+ * flanked by its minimum and maximum as plain numbers. A `bar` chart is one
+ * horizontal `█` bar per point, its own value as the row's label, labels
+ * right-aligned to the widest one so every bar starts at the same column.
+ */
+export const Chart = (attributes, _children, ctx) => {
+    const { data, dataStatus, dataFailureKind } = ctx;
+    const rawKind = attributes.kind ?? DEFAULT_KIND;
+    const kind = isChartKind(rawKind) ? rawKind : DEFAULT_KIND;
+    const bound = safeRead(() => resolvePoints(data, dataStatus, attributes.values), () => resolvePoints(undefined, 'missing', attributes.values));
+    const points = bound.fields;
+    const suffix = dataStateSuffix(dataStatus, dataFailureKind);
+    const token = failureToken(dataFailureKind);
+    const styledSuffix = suffix
+        ? token
+            ? ctx.style(suffix, token)
+            : ctx.dim(suffix)
+        : '';
+    if (points.length === 0) {
+        return `${ctx.dim('no data')}${styledSuffix}`;
+    }
+    if (kind === 'line') {
+        const min = ctx.dim(formatPoint(Math.min(...points)));
+        const max = ctx.dim(formatPoint(Math.max(...points)));
+        return `${min} ${sparkline(points)} ${max}${styledSuffix}`;
+    }
+    const labels = points.map((point) => formatPoint(point));
+    const labelWidth = Math.max(...labels.map((label) => measure(label)));
+    const budget = Math.max(1, ctx.width - labelWidth - 1);
+    const maxMagnitude = Math.max(...points.map((point) => Math.abs(point)));
+    const lines = points.map((point, index) => {
+        const bar = '█'.repeat(barLength(point, maxMagnitude, budget));
+        return `${pad(labels[index], labelWidth, 'right')} ${bar}`;
+    });
+    return `${lines.join('\n')}${styledSuffix}`;
+};

package/dist/components/details.d.ts

@@ -0,0 +1,12 @@
+import type { AnsiComponent } from '../registry.js';
+/**
+ * `:::details{title="..." open} ... :::` — a collapsible disclosure. A
+ * terminal has no collapse/expand affordance (see `render.ts`'s top comment
+ * on interactive components), so this ALWAYS shows the body: the bare
+ * `open` attribute instead only changes the marker glyph (`▾` for `open`,
+ * `▸` for folded-by-default), a quiet hint at the note's own authored
+ * default rather than a control that does anything here. The marker line
+ * also names the section a "collapsible section" so a reader understands
+ * why they are seeing an indented block with no directive name attached.
+ */
+export declare const Details: AnsiComponent;

package/dist/components/details.js

@@ -0,0 +1,25 @@
+import { indentBlock } from '../box.js';
+const DEFAULT_TITLE = 'Details';
+/** Columns the indent prefix ("  ") consumes from the enclosing width. */
+const INDENT_WIDTH = 2;
+/**
+ * `:::details{title="..." open} ... :::` — a collapsible disclosure. A
+ * terminal has no collapse/expand affordance (see `render.ts`'s top comment
+ * on interactive components), so this ALWAYS shows the body: the bare
+ * `open` attribute instead only changes the marker glyph (`▾` for `open`,
+ * `▸` for folded-by-default), a quiet hint at the note's own authored
+ * default rather than a control that does anything here. The marker line
+ * also names the section a "collapsible section" so a reader understands
+ * why they are seeing an indented block with no directive name attached.
+ */
+export const Details = (attributes, children, ctx) => {
+    const title = attributes.title ?? DEFAULT_TITLE;
+    const open = Object.hasOwn(attributes, 'open');
+    const glyph = open ? '▾' : '▸';
+    const marker = ctx.dim(`${glyph} ${ctx.bold(ctx.text(title))} (collapsible section, shown expanded)`);
+    const innerWidth = Math.max(1, ctx.width - INDENT_WIDTH);
+    const childrenText = children({ width: innerWidth });
+    if (!childrenText)
+        return marker;
+    return `${marker}\n${indentBlock(childrenText, '  ')}`;
+};

package/dist/components/divider.d.ts

@@ -0,0 +1,4 @@
+import type { AnsiComponent } from '../registry.js';
+export type DividerVariant = 'line' | 'dots' | 'ornament';
+export type DividerLabelAlign = 'left' | 'center' | 'right';
+export declare const Divider: AnsiComponent;

package/dist/components/divider.js

@@ -0,0 +1,80 @@
+import { measure } from '../measure.js';
+import { selfLayoutAlign, selfLayoutWidth } from '../layout.js';
+const DIVIDER_VARIANTS = [
+    'line',
+    'dots',
+    'ornament',
+];
+function isDividerVariant(value) {
+    return DIVIDER_VARIANTS.includes(value);
+}
+const LABEL_ALIGNS = ['left', 'center', 'right'];
+function isDividerLabelAlign(value) {
+    return LABEL_ALIGNS.includes(value);
+}
+const ORNAMENT_GLYPH = '❖';
+/** The rule character each non-ornament variant draws with. */
+const RULE_CHAR = { line: '─', dots: '·' };
+/** How much of a labeled rule's rule fill sits on the SHORT side when the label is pushed left/right (the rest fills the long side). */
+const SHORT_SIDE_RULE = 2;
+/** Builds a full-`width` rule with `label` woven in at `align`, e.g. `── Part 2 ─────────`. */
+function labeledRule(ruleChar, label, width, align) {
+    const labelText = ` ${label} `;
+    const remaining = Math.max(0, width - measure(labelText));
+    let left;
+    if (align === 'left')
+        left = Math.min(SHORT_SIDE_RULE, remaining);
+    else if (align === 'right')
+        left = remaining - Math.min(SHORT_SIDE_RULE, remaining);
+    else
+        left = Math.floor(remaining / 2);
+    const right = remaining - left;
+    return `${ruleChar.repeat(left)}${labelText}${ruleChar.repeat(right)}`;
+}
+/**
+ * `::divider` / `::divider{label="..." variant="line|dots|ornament"
+ * label-align="left|center|right"}` — a leaf directive drawing a section
+ * break. Unknown/missing `variant` falls back to `line`; unknown/missing
+ * `label-align` falls back to `center`. Terminal form: a full-width rule
+ * (`─` for `line`, `·` for `dots`) with the label woven into it at
+ * `label-align`, or, for `ornament`, no hairline at all — just the `❖` glyph
+ * (doubled around the label, when there is one) placed at `label-align`
+ * within the width. Dimmed, matching the plain thematic-break rendering.
+ *
+ * Registered `selfLayout` (`registry.ts`'s `AnsiRegistryEntry.selfLayout`):
+ * a full-width rule is ONE long run with no spaces in it, so a generic
+ * post-render `applyLayout` narrowing would treat the whole rule as a
+ * single over-long "word" and hard-break it into several shorter lines
+ * (`../box.ts`'s `wrap`'s `breakLongWord`) instead of drawing one shorter
+ * rule — this component instead reads `ctx.layout` and draws its own rule
+ * at the resolved width from the start, exactly like `card`/`callout`.
+ */
+const FIT_DEFAULT_WIDTH = 10;
+export const Divider = (attributes, _children, ctx) => {
+    const rawVariant = attributes.variant ?? 'line';
+    const variant = isDividerVariant(rawVariant)
+        ? rawVariant
+        : 'line';
+    const rawLabel = attributes.label ?? null;
+    const label = rawLabel ? ctx.text(rawLabel) : null;
+    const rawLabelAlign = attributes['label-align'];
+    const labelAlign = rawLabelAlign && isDividerLabelAlign(rawLabelAlign)
+        ? rawLabelAlign
+        : 'center';
+    const naturalWidth = label ? measure(label) + 4 : FIT_DEFAULT_WIDTH;
+    const width = selfLayoutWidth(ctx.layout, ctx.width, naturalWidth);
+    let line;
+    if (variant === 'ornament') {
+        const inner = label
+            ? `${ORNAMENT_GLYPH} ${label} ${ORNAMENT_GLYPH}`
+            : ORNAMENT_GLYPH;
+        line = ctx.pad(inner, width, labelAlign);
+    }
+    else {
+        const ruleChar = RULE_CHAR[variant];
+        line = label
+            ? labeledRule(ruleChar, label, width, labelAlign)
+            : ctx.rule(width, ruleChar);
+    }
+    return selfLayoutAlign(ctx.dim(line), ctx.layout, ctx.width);
+};

package/dist/components/figure.d.ts

@@ -0,0 +1,20 @@
+import type { AnsiComponent } from '../registry.js';
+/**
+ * `:::figure{src="..." alt="..."} caption markdown :::` — an image with a
+ * rich (markdown) caption. `src` is required; a missing `src` shows only the
+ * caption, matching the graceful-degradation spirit of the unknown-directive
+ * fallback rather than throwing.
+ *
+ * Security: `src` bypasses `@markii/core`'s hast-level URL sanitizer (it is
+ * a directive attribute, not a markdown image), so this component closes
+ * that gap itself with `@markii/core`'s `isSafeUrl` — the same allowlist the
+ * sanitizer uses — and drops the image line entirely on a refusal, replacing
+ * it with a short labeled marker (a terminal has no tooltip to carry the
+ * full sentence out of the text flow) plus the full sentence reported to
+ * `onDiagnostic`; matches `@markii/html`'s `Figure` in behavior, not in the
+ * inline wording.
+ *
+ * Terminal form: alt text, then the (possibly host-resolved) src, then the
+ * caption, each on its own line, dimmed except the caption itself.
+ */
+export declare const Figure: AnsiComponent;

package/dist/components/figure.js

@@ -0,0 +1,53 @@
+import { isSafeUrl } from '@markii/core';
+import { reportDiagnostic } from '@markii/stdlib';
+import { resolveImageAttribute } from '../image-resolve.js';
+import { unsafeImageSrcLabel, unsafeImageSrcTitle, } from '../failure-presentation.js';
+const DEFAULT_ALT = '';
+const DIRECTIVE_NAME = 'figure';
+/**
+ * `:::figure{src="..." alt="..."} caption markdown :::` — an image with a
+ * rich (markdown) caption. `src` is required; a missing `src` shows only the
+ * caption, matching the graceful-degradation spirit of the unknown-directive
+ * fallback rather than throwing.
+ *
+ * Security: `src` bypasses `@markii/core`'s hast-level URL sanitizer (it is
+ * a directive attribute, not a markdown image), so this component closes
+ * that gap itself with `@markii/core`'s `isSafeUrl` — the same allowlist the
+ * sanitizer uses — and drops the image line entirely on a refusal, replacing
+ * it with a short labeled marker (a terminal has no tooltip to carry the
+ * full sentence out of the text flow) plus the full sentence reported to
+ * `onDiagnostic`; matches `@markii/html`'s `Figure` in behavior, not in the
+ * inline wording.
+ *
+ * Terminal form: alt text, then the (possibly host-resolved) src, then the
+ * caption, each on its own line, dimmed except the caption itself.
+ */
+export const Figure = (attributes, children, ctx) => {
+    const rawSrc = attributes.src ?? null;
+    const alt = attributes.alt ?? DEFAULT_ALT;
+    const refused = Boolean(rawSrc) && !isSafeUrl(rawSrc);
+    const safeSrc = rawSrc && !refused ? rawSrc : null;
+    const src = safeSrc
+        ? ctx.text(resolveImageAttribute(safeSrc, ctx.resolveImageSrc))
+        : null;
+    const lines = [];
+    if (rawSrc) {
+        if (alt)
+            lines.push(ctx.dim(`alt: ${ctx.text(alt)}`));
+        if (refused) {
+            reportDiagnostic(ctx.onDiagnostic, {
+                kind: 'unsafe-image-src',
+                directive: DIRECTIVE_NAME,
+                message: unsafeImageSrcTitle(DIRECTIVE_NAME),
+            });
+            lines.push(ctx.dim(`[${unsafeImageSrcLabel(DIRECTIVE_NAME)}]`));
+        }
+        else if (src) {
+            lines.push(ctx.dim(src));
+        }
+    }
+    const childrenText = children();
+    if (childrenText)
+        lines.push(childrenText);
+    return lines.join('\n');
+};

package/dist/components/index.d.ts

@@ -0,0 +1,34 @@
+import type { AnsiRegistry } from '../registry.js';
+export { Badge } from './badge.js';
+export type { BadgeVariant } from './badge.js';
+export { Callout } from './callout.js';
+export type { CalloutType } from './callout.js';
+export { Card } from './card.js';
+export { Cell } from './cell.js';
+export { Chart } from './chart.js';
+export { Details } from './details.js';
+export { Divider } from './divider.js';
+export type { DividerVariant } from './divider.js';
+export { Figure } from './figure.js';
+export { Kbd } from './kbd.js';
+export { createLayoutWrapper, layoutWrapperPresetAxis, LAYOUT_WRAPPER_PRESETS, } from './layout-wrapper.js';
+export type { LayoutWrapperPreset } from './layout-wrapper.js';
+export { Progress } from './progress.js';
+export { Rating } from './rating.js';
+export { Row, ROW_COLUMN_THRESHOLD } from './row.js';
+export { Stat } from './stat.js';
+export { Tab, DEFAULT_TAB_LABEL } from './tab.js';
+export { Tabs } from './tabs.js';
+export { Table } from './table.js';
+export { drawTableGrid, measureTableGridWidth, MIN_COLUMN_WIDTH, } from './table-grid.js';
+/**
+ * The built-in standard components, pre-registered under their names —
+ * matching `@markii/html`'s `defaultHtmlRegistry` and `@markii/react`'s
+ * `defaultRegistry` in shape and coverage: the same 23 names. `card`,
+ * `callout`, `divider`, and `table` are marked `selfLayout` (`registry.ts`'s
+ * `AnsiRegistryEntry.selfLayout`) because they draw a single long
+ * frame/bar/rule/grid a generic post-render `applyLayout` narrow/pad would
+ * corrupt or hard-break mid-glyph; see `card.ts`'s and `divider.ts`'s doc
+ * comments.
+ */
+export declare const defaultAnsiRegistry: AnsiRegistry;

package/dist/components/index.js

@@ -0,0 +1,109 @@
+import { getContract } from '@markii/stdlib';
+import { createAnsiRegistry } from '../registry.js';
+import { Badge } from './badge.js';
+import { Callout } from './callout.js';
+import { Card } from './card.js';
+import { Cell } from './cell.js';
+import { Chart } from './chart.js';
+import { Details } from './details.js';
+import { Divider } from './divider.js';
+import { Figure } from './figure.js';
+import { Kbd } from './kbd.js';
+import { createLayoutWrapper, layoutWrapperPresetAxis, } from './layout-wrapper.js';
+import { Progress } from './progress.js';
+import { Rating } from './rating.js';
+import { Row } from './row.js';
+import { Stat } from './stat.js';
+import { Tab } from './tab.js';
+import { Tabs } from './tabs.js';
+import { Table } from './table.js';
+export { Badge } from './badge.js';
+export { Callout } from './callout.js';
+export { Card } from './card.js';
+export { Cell } from './cell.js';
+export { Chart } from './chart.js';
+export { Details } from './details.js';
+export { Divider } from './divider.js';
+export { Figure } from './figure.js';
+export { Kbd } from './kbd.js';
+export { createLayoutWrapper, layoutWrapperPresetAxis, LAYOUT_WRAPPER_PRESETS, } from './layout-wrapper.js';
+export { Progress } from './progress.js';
+export { Rating } from './rating.js';
+export { Row, ROW_COLUMN_THRESHOLD } from './row.js';
+export { Stat } from './stat.js';
+export { Tab, DEFAULT_TAB_LABEL } from './tab.js';
+export { Tabs } from './tabs.js';
+export { Table } from './table.js';
+export { drawTableGrid, measureTableGridWidth, MIN_COLUMN_WIDTH, } from './table-grid.js';
+/**
+ * Derives a registry entry's `inline` flag from `@markii/stdlib`'s standard
+ * component contract for `name`, matching `@markii/html`'s
+ * `inlineFromContract`: `kind: 'inline'` -> `inline: true`, otherwise
+ * `false`. Falls back to `false` if `name` has no standard contract.
+ */
+function inlineFromContract(name) {
+    return getContract(name)?.kind === 'inline';
+}
+/**
+ * One layout-wrapper registration: the shared wrapper component bound to
+ * `preset`, plus the `layout` axis that preset sets by its own name.
+ * Matches `@markii/html`'s `layoutWrapperEntry`.
+ */
+function layoutWrapperEntry(preset) {
+    return {
+        component: createLayoutWrapper(preset),
+        inline: inlineFromContract(preset),
+        layout: layoutWrapperPresetAxis(preset),
+    };
+}
+/**
+ * The built-in standard components, pre-registered under their names —
+ * matching `@markii/html`'s `defaultHtmlRegistry` and `@markii/react`'s
+ * `defaultRegistry` in shape and coverage: the same 23 names. `card`,
+ * `callout`, `divider`, and `table` are marked `selfLayout` (`registry.ts`'s
+ * `AnsiRegistryEntry.selfLayout`) because they draw a single long
+ * frame/bar/rule/grid a generic post-render `applyLayout` narrow/pad would
+ * corrupt or hard-break mid-glyph; see `card.ts`'s and `divider.ts`'s doc
+ * comments.
+ */
+export const defaultAnsiRegistry = createAnsiRegistry({
+    callout: {
+        component: Callout,
+        inline: inlineFromContract('callout'),
+        selfLayout: true,
+    },
+    kbd: { component: Kbd, inline: inlineFromContract('kbd') },
+    rating: { component: Rating, inline: inlineFromContract('rating') },
+    divider: {
+        component: Divider,
+        inline: inlineFromContract('divider'),
+        selfLayout: true,
+    },
+    details: { component: Details, inline: inlineFromContract('details') },
+    card: {
+        component: Card,
+        inline: inlineFromContract('card'),
+        selfLayout: true,
+    },
+    badge: { component: Badge, inline: inlineFromContract('badge') },
+    figure: { component: Figure, inline: inlineFromContract('figure') },
+    tabs: { component: Tabs, inline: inlineFromContract('tabs') },
+    tab: { component: Tab, inline: inlineFromContract('tab') },
+    row: { component: Row, inline: inlineFromContract('row') },
+    cell: { component: Cell, inline: inlineFromContract('cell') },
+    table: {
+        component: Table,
+        inline: inlineFromContract('table'),
+        selfLayout: true,
+    },
+    stat: { component: Stat, inline: inlineFromContract('stat') },
+    progress: { component: Progress, inline: inlineFromContract('progress') },
+    chart: { component: Chart, inline: inlineFromContract('chart') },
+    center: layoutWrapperEntry('center'),
+    left: layoutWrapperEntry('left'),
+    right: layoutWrapperEntry('right'),
+    wide: layoutWrapperEntry('wide'),
+    narrow: layoutWrapperEntry('narrow'),
+    full: layoutWrapperEntry('full'),
+    fit: layoutWrapperEntry('fit'),
+});

package/dist/components/kbd.d.ts

@@ -0,0 +1,7 @@
+import type { AnsiComponent } from '../registry.js';
+/**
+ * `:kbd[Ctrl+S]` — a styled keycap for an inline text directive. Terminal
+ * form: bracketed bold text, e.g. `[Ctrl+S]`. Takes no attributes; its inner
+ * content (already rendered plain text) is the key label.
+ */
+export declare const Kbd: AnsiComponent;

package/dist/components/kbd.js

@@ -0,0 +1,8 @@
+/**
+ * `:kbd[Ctrl+S]` — a styled keycap for an inline text directive. Terminal
+ * form: bracketed bold text, e.g. `[Ctrl+S]`. Takes no attributes; its inner
+ * content (already rendered plain text) is the key label.
+ */
+export const Kbd = (_attributes, children, ctx) => {
+    return `[${ctx.bold(children())}]`;
+};

package/dist/components/layout-wrapper.d.ts

@@ -0,0 +1,35 @@
+import type { LayoutAxis } from '@markii/stdlib';
+import type { AnsiComponent } from '../registry.js';
+/**
+ * The closed set of layout-wrapper container names (docs/format.md):
+ * aliases of the one shared implementation below (`createLayoutWrapper`),
+ * matching `@markii/html`'s `layout-wrapper.ts`. There is deliberately no
+ * `normal` alias: the default needs no wrapper at all. Every name here is
+ * ALSO one of `@markii/stdlib`'s own width/align preset values (`center`/
+ * `left`/`right` are align presets, `wide`/`narrow`/`full`/`fit` are width
+ * presets), which is what lets `createLayoutWrapper` use the preset name
+ * itself as that axis's value with no separate lookup table.
+ */
+export declare const LAYOUT_WRAPPER_PRESETS: readonly ["center", "left", "right", "wide", "narrow", "full", "fit"];
+export type LayoutWrapperPreset = (typeof LAYOUT_WRAPPER_PRESETS)[number];
+/**
+ * Creates the registry component for one of docs/format.md's layout-wrapper
+ * container names. One shared implementation, bound to `preset` at
+ * registration time, matching `@markii/html`'s `createLayoutWrapper` in
+ * spirit: it never reads `attributes` at all — `render.ts` already stripped
+ * both reserved keys before this ever runs.
+ *
+ * A wrapper sets ONE axis by its own NAME (docs/spec.md §3): `preset` itself
+ * IS that axis's value (`center` sets `align: 'center'`; `narrow` sets
+ * `width: 'narrow'`), so it is applied unconditionally, whatever the author
+ * wrote for that axis's own reserved attribute (already discarded — the
+ * name always wins). The OTHER axis, when the author supplied it, arrives
+ * as `ctx.layout` (`render.ts` resolved it on this wrapper's behalf, since
+ * this wrapper is the directive's registered `layout` scope). Both are
+ * merged into one `ResolvedLayoutPresets` and applied together via
+ * `../layout.js`'s `applyLayout`, so `:::center{width=fit}` narrows AND
+ * centers in one pass.
+ */
+export declare function createLayoutWrapper(preset: LayoutWrapperPreset): AnsiComponent;
+/** The layout axis `preset` sets by its own name. Mirrors `@markii/html`'s `layoutWrapperPresetAxis`. */
+export declare function layoutWrapperPresetAxis(preset: LayoutWrapperPreset): LayoutAxis;