@markii/ansi 0.0.1

package/dist/components/table.js

@@ -0,0 +1,101 @@
+import { deriveTableShape, formatValue, isNumericLike } from '@markii/stdlib';
+import { selfLayoutAlign, selfLayoutWidth } from '../layout.js';
+import { safeRead } from '../resolve.js';
+import { dataStateSuffix, failureToken } from '../failure-presentation.js';
+import { drawTableGrid, measureTableGridWidth } from './table-grid.js';
+function parseColumns(raw) {
+    if (!raw)
+        return undefined;
+    const list = raw
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return list.length > 0 ? list : undefined;
+}
+function parseLimit(raw) {
+    if (!raw)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!/^\d+$/.test(trimmed))
+        return undefined;
+    const parsed = Number(trimmed);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function limitRows(rows, limit) {
+    return limit === undefined ? rows : rows.slice(0, limit);
+}
+/** Renders one cell's display text: `format`/`decimals` apply only when the cell's raw value is itself numeric-like, matching `@markii/html`'s `Table` exactly. */
+function renderCell(value, format, decimals) {
+    if (format && isNumericLike(value))
+        return formatValue(value, format, decimals);
+    return formatValue(value);
+}
+const TEXT_ALIGNS = ['left', 'center', 'right'];
+function isTextAlign(value) {
+    return TEXT_ALIGNS.includes(value);
+}
+/**
+ * `::table{data=users columns="name,role" limit=10}` — a data-bound table.
+ * Data binding (§8) mirrors `@markii/html`'s `Table`: `@markii/stdlib`'s
+ * `deriveTableShape` decides the layout from the bound value's own shape.
+ * `format`/`decimals` apply to numeric cells only; `text` aligns every
+ * cell's content within its column; `caption`, when given, is a bold line
+ * above the grid. A missing/stale/failed binding degrades to the same quiet
+ * "no data" line `chart`/`progress` use, with the failure suffix appended.
+ *
+ * Registered `selfLayout` (see `card.ts`'s doc comment): draws real
+ * box-drawing glyphs (`./table-grid.ts`), so it sizes its own grid off
+ * `ctx.layout` instead of letting a generic post-render narrow/pad corrupt
+ * the borders.
+ */
+export const Table = (attributes, _children, ctx) => {
+    const { data, dataStatus, dataFailureKind } = ctx;
+    const columnsOverride = parseColumns(attributes.columns);
+    const limit = parseLimit(attributes.limit);
+    const format = attributes.format ?? undefined;
+    const decimals = attributes.decimals ?? undefined;
+    const caption = attributes.caption ?? null;
+    const rawTextAlign = attributes.text;
+    const align = rawTextAlign && isTextAlign(rawTextAlign) ? rawTextAlign : 'left';
+    const bound = safeRead(() => dataStatus === 'missing' || dataStatus === 'error'
+        ? { kind: 'empty' }
+        : deriveTableShape(data, columnsOverride), () => ({ kind: 'empty' }));
+    const shape = bound.fields;
+    const suffix = dataStateSuffix(dataStatus, dataFailureKind);
+    const token = failureToken(dataFailureKind);
+    const styledSuffix = suffix
+        ? token
+            ? ctx.style(suffix, token)
+            : ctx.dim(suffix)
+        : '';
+    const captionLine = caption ? ctx.bold(ctx.text(caption)) : undefined;
+    if (shape.kind === 'empty') {
+        const emptyLine = `${ctx.dim('no data')}${styledSuffix}`;
+        return captionLine ? `${captionLine}\n${emptyLine}` : emptyLine;
+    }
+    const cell = (value) => ctx.text(renderCell(value, format, decimals));
+    let header;
+    let rows;
+    if (shape.kind === 'objects') {
+        header = shape.columns.map((column) => ctx.text(column));
+        rows = limitRows(shape.rows, limit).map((cells) => cells.map(cell));
+    }
+    else if (shape.kind === 'arrays') {
+        rows = limitRows(shape.rows, limit).map((cells) => cells.map(cell));
+    }
+    else if (shape.kind === 'primitives') {
+        rows = limitRows(shape.rows, limit).map((cells) => [cell(cells[0])]);
+    }
+    else {
+        rows = limitRows(shape.rows, limit).map(([key, value]) => [
+            ctx.text(key),
+            cell(value),
+        ]);
+    }
+    const naturalWidth = measureTableGridWidth(header, rows);
+    const boxWidth = selfLayoutWidth(ctx.layout, ctx.width, naturalWidth);
+    const grid = drawTableGrid(header, rows, boxWidth, (text) => ctx.bold(text), align);
+    const body = `${grid}${styledSuffix}`;
+    const withCaption = captionLine ? `${captionLine}\n${body}` : body;
+    return selfLayoutAlign(withCaption, ctx.layout, ctx.width);
+};

package/dist/components/tabs.d.ts

@@ -0,0 +1,18 @@
+import type { AnsiComponent } from '../registry.js';
+/**
+ * `::::tabs :::tab{label="..."} ... ::: :::tab{label="..."} ... ::: ::::` —
+ * a tabbed panel switcher. A terminal has no click-driven tab switching (see
+ * `render.ts`'s top comment on interactive components), so every panel is
+ * shown, stacked, in document order — matching `@markii/html`'s `Tabs`
+ * faithfulness limitation of showing every panel rather than picking one.
+ *
+ * "The active tab marked": since every panel is always visible here, this
+ * engine treats the FIRST tab (document order) as the one a live host would
+ * show before any interaction, and marks only its heading line — every
+ * `tab` child's block is joined into `childrenText` with a blank line
+ * between them (`render.ts`'s `renderBlocks`), the same separator this
+ * engine uses between any two sibling blocks, so splitting on the first
+ * blank line reliably finds the boundary between the first tab's block and
+ * the rest without needing any information `tabs` does not have.
+ */
+export declare const Tabs: AnsiComponent;

package/dist/components/tabs.js

@@ -0,0 +1,30 @@
+/** The visible marker appended to whichever tab is treated as "active" (see this module's doc comment for how that is decided). */
+const ACTIVE_MARKER = ' (active)';
+/**
+ * `::::tabs :::tab{label="..."} ... ::: :::tab{label="..."} ... ::: ::::` —
+ * a tabbed panel switcher. A terminal has no click-driven tab switching (see
+ * `render.ts`'s top comment on interactive components), so every panel is
+ * shown, stacked, in document order — matching `@markii/html`'s `Tabs`
+ * faithfulness limitation of showing every panel rather than picking one.
+ *
+ * "The active tab marked": since every panel is always visible here, this
+ * engine treats the FIRST tab (document order) as the one a live host would
+ * show before any interaction, and marks only its heading line — every
+ * `tab` child's block is joined into `childrenText` with a blank line
+ * between them (`render.ts`'s `renderBlocks`), the same separator this
+ * engine uses between any two sibling blocks, so splitting on the first
+ * blank line reliably finds the boundary between the first tab's block and
+ * the rest without needing any information `tabs` does not have.
+ */
+export const Tabs = (_attributes, children) => {
+    const childrenText = children();
+    if (!childrenText.trim())
+        return '';
+    const blocks = childrenText.split('\n\n');
+    const [first, ...rest] = blocks;
+    if (first === undefined)
+        return childrenText;
+    const lines = first.split('\n');
+    lines[0] = `${lines[0] ?? ''}${ACTIVE_MARKER}`;
+    return [lines.join('\n'), ...rest].join('\n\n');
+};

package/dist/failure-presentation.d.ts

@@ -0,0 +1,58 @@
+import type { FailureKind, ValueStatus } from './value-types.js';
+import type { Tier1Token } from './theme.js';
+/** The short phrase for `kind`, or `undefined` if absent or not one of the four taxonomy members. */
+export declare function failurePhrase(kind: FailureKind | undefined): string | undefined;
+/** The tooltip-equivalent text for a failed/missing binding: the short phrase for `kind`, with `error` appended when there is one. */
+export declare function failureTitle(error: string | undefined, kind: FailureKind | undefined): string | undefined;
+/**
+ * The theme token a failed binding's marker is colored with, this engine's
+ * terminal equivalent of `@markii/html`'s `failureKindClass`: `script-error`
+ * and `capability-denied` both read as `--mk-danger` (the note asked for
+ * something and could not get it, one way or another), `tier-blocked` reads
+ * as `--mk-warning` (a manual run would fix it, nothing is actually broken),
+ * `limit` reads as `--mk-limit`'s dedicated purple. `undefined` for an
+ * absent or out-of-taxonomy `kind`, in which case a caller applies no color
+ * at all rather than guessing one.
+ */
+export declare function failureToken(kind: FailureKind | undefined): Tier1Token | undefined;
+/**
+ * The quiet trailing marker text for a data-bound value's state: ` (stale)`
+ * for a stale value, ` (<phrase>)` for a failed one (built from the SAME
+ * `FAILURE_PHRASE` table `failureTitle` uses, so the two never say something
+ * different about the same failure), `''` for a fresh or plain-missing
+ * value (a plain miss already shows as the empty/placeholder marker
+ * `render.ts` builds; it needs no additional suffix). `status: 'error'`
+ * without a recognized `kind` still gets the generic wording via
+ * `failurePhrase`'s `undefined` fallback in the caller.
+ */
+export declare function dataStateSuffix(status: ValueStatus | undefined, kind: FailureKind | undefined): string;
+/**
+ * The marker text `render.ts` shows for an INLINE-registered component that
+ * receives no content (e.g. `::badge{label="x"}`, text put in an attribute
+ * instead of the directive body). Wording identical to `@markii/html`'s
+ * `emptyInlineTitle`.
+ */
+export declare function emptyInlineTitle(name: string): string;
+/** The marker text for a known attribute's value outside its closed enum. Wording identical to `@markii/html`'s `invalidAttributeValueTitle`. */
+export declare function invalidAttributeValueTitle(directive: string, attribute: string, value: string): string;
+/** The marker text for a component-built image whose `src` was refused as unsafe. Wording identical to `@markii/html`'s `unsafeImageSrcTitle`. */
+export declare function unsafeImageSrcTitle(directive: string): string;
+/**
+ * The INLINE marker text for a known attribute's value outside its closed
+ * enum, this engine's own departure from `@markii/html`'s identical wording:
+ * a terminal has no tooltip to carry `invalidAttributeValueTitle`'s full
+ * sentence out of the text flow, so printing that sentence inline would put
+ * the reason back in the page, the exact thing AGENTS.md's "clean is not
+ * silent" rule exists to prevent. This short label is what render.ts prints
+ * next to the component's own output; the full sentence still reaches a
+ * host's diagnostics surface via `onDiagnostic`.
+ */
+export declare function invalidAttributeValueLabel(directive: string, attribute: string): string;
+/**
+ * The INLINE marker text for a component-built image whose `src` was
+ * refused as unsafe, this engine's short counterpart to
+ * `unsafeImageSrcTitle` for the same reason `invalidAttributeValueLabel`
+ * exists: no tooltip channel, so the full sentence goes to `onDiagnostic`
+ * only.
+ */
+export declare function unsafeImageSrcLabel(directive: string): string;

package/dist/failure-presentation.js

@@ -0,0 +1,124 @@
+/**
+ * This engine's port of `@markii/html`'s `failure-presentation.ts` — the ONE
+ * place UI wording for `@markii/runtime`'s failure taxonomy lives in this
+ * engine. Ported (not imported) for the same reason `./resolve.ts` is
+ * ported: each platform renderer independently implements the same
+ * presentation contract (docs/scripting.md), kept identical in wording so a
+ * failing name reads the same everywhere. `failure-presentation.drift.test.ts`
+ * is the executable proof: it reads `@markii/html`'s copy of this module as
+ * TEXT and asserts the phrases and title templates match byte for byte.
+ *
+ * The presentation contract (AGENTS.md's cleanliness principle) carries over
+ * unchanged: a failure never becomes body text. In a terminal it surfaces as
+ * a quiet trailing marker (`dataStateSuffix`) plus, where the caller wants
+ * it, a themed color (`failureToken`) — the terminal's equivalent of the
+ * HTML engine's `title` tooltip and modifier class, since neither exists in
+ * a terminal.
+ *
+ * Two notices (an out-of-enum attribute value, a refused image source) carry
+ * a full sentence in the browser engines' `title` tooltip, reached out of
+ * the text flow. A terminal has no tooltip, so printing that sentence inline
+ * would put the reason back in the rendered note. `invalidAttributeValueLabel`
+ * and `unsafeImageSrcLabel` are this engine's short inline labels for those
+ * two cases; the full sentence (`invalidAttributeValueTitle`/
+ * `unsafeImageSrcTitle`, unchanged) still reaches a host only through
+ * `onDiagnostic`.
+ */
+/** Human-facing phrase per `FailureKind`. Identical wording to `@markii/html`'s `FAILURE_PHRASE`; kept in sync by `failure-presentation.drift.test.ts`. Null-prototype so an out-of-taxonomy `kind` can never resolve through the prototype chain. */
+const FAILURE_PHRASE = Object.assign(Object.create(null), {
+    'script-error': 'script error',
+    'capability-denied': 'needs permission',
+    'tier-blocked': 'requires manual run',
+    limit: 'limit exceeded',
+});
+/** The short phrase for `kind`, or `undefined` if absent or not one of the four taxonomy members. */
+export function failurePhrase(kind) {
+    if (kind === undefined)
+        return undefined;
+    return Object.hasOwn(FAILURE_PHRASE, kind) ? FAILURE_PHRASE[kind] : undefined;
+}
+/** The tooltip-equivalent text for a failed/missing binding: the short phrase for `kind`, with `error` appended when there is one. */
+export function failureTitle(error, kind) {
+    const phrase = failurePhrase(kind);
+    if (!phrase)
+        return error ? error : undefined;
+    return error ? `${phrase}: ${error}` : phrase;
+}
+/**
+ * The theme token a failed binding's marker is colored with, this engine's
+ * terminal equivalent of `@markii/html`'s `failureKindClass`: `script-error`
+ * and `capability-denied` both read as `--mk-danger` (the note asked for
+ * something and could not get it, one way or another), `tier-blocked` reads
+ * as `--mk-warning` (a manual run would fix it, nothing is actually broken),
+ * `limit` reads as `--mk-limit`'s dedicated purple. `undefined` for an
+ * absent or out-of-taxonomy `kind`, in which case a caller applies no color
+ * at all rather than guessing one.
+ */
+export function failureToken(kind) {
+    if (kind === 'script-error' || kind === 'capability-denied')
+        return '--mk-danger';
+    if (kind === 'tier-blocked')
+        return '--mk-warning';
+    if (kind === 'limit')
+        return '--mk-limit';
+    return undefined;
+}
+/**
+ * The quiet trailing marker text for a data-bound value's state: ` (stale)`
+ * for a stale value, ` (<phrase>)` for a failed one (built from the SAME
+ * `FAILURE_PHRASE` table `failureTitle` uses, so the two never say something
+ * different about the same failure), `''` for a fresh or plain-missing
+ * value (a plain miss already shows as the empty/placeholder marker
+ * `render.ts` builds; it needs no additional suffix). `status: 'error'`
+ * without a recognized `kind` still gets the generic wording via
+ * `failurePhrase`'s `undefined` fallback in the caller.
+ */
+export function dataStateSuffix(status, kind) {
+    if (status === 'error') {
+        const phrase = failurePhrase(kind) ?? 'error';
+        return ` (${phrase})`;
+    }
+    if (status === 'stale')
+        return ' (stale)';
+    return '';
+}
+/**
+ * The marker text `render.ts` shows for an INLINE-registered component that
+ * receives no content (e.g. `::badge{label="x"}`, text put in an attribute
+ * instead of the directive body). Wording identical to `@markii/html`'s
+ * `emptyInlineTitle`.
+ */
+export function emptyInlineTitle(name) {
+    return `${name}: no content (an attribute may have been used where directive text was expected)`;
+}
+/** The marker text for a known attribute's value outside its closed enum. Wording identical to `@markii/html`'s `invalidAttributeValueTitle`. */
+export function invalidAttributeValueTitle(directive, attribute, value) {
+    return `${directive}: "${value}" is not a valid ${attribute} value (ignored)`;
+}
+/** The marker text for a component-built image whose `src` was refused as unsafe. Wording identical to `@markii/html`'s `unsafeImageSrcTitle`. */
+export function unsafeImageSrcTitle(directive) {
+    return `${directive}: image source was refused as unsafe and was not shown`;
+}
+/**
+ * The INLINE marker text for a known attribute's value outside its closed
+ * enum, this engine's own departure from `@markii/html`'s identical wording:
+ * a terminal has no tooltip to carry `invalidAttributeValueTitle`'s full
+ * sentence out of the text flow, so printing that sentence inline would put
+ * the reason back in the page, the exact thing AGENTS.md's "clean is not
+ * silent" rule exists to prevent. This short label is what render.ts prints
+ * next to the component's own output; the full sentence still reaches a
+ * host's diagnostics surface via `onDiagnostic`.
+ */
+export function invalidAttributeValueLabel(directive, attribute) {
+    return `${directive}: ${attribute} ignored`;
+}
+/**
+ * The INLINE marker text for a component-built image whose `src` was
+ * refused as unsafe, this engine's short counterpart to
+ * `unsafeImageSrcTitle` for the same reason `invalidAttributeValueLabel`
+ * exists: no tooltip channel, so the full sentence goes to `onDiagnostic`
+ * only.
+ */
+export function unsafeImageSrcLabel(directive) {
+    return `${directive}: image not shown`;
+}

package/dist/href-resolve.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The link-rewrite twin of `./image-resolve.js`'s `resolveImageSrc`:
+ * `renderMarkToAnsi`'s `resolveHref` option (`render.ts`'s
+ * `RenderMarkOptions`), applied to every link an ordinary markdown link
+ * produces. Ported verbatim from `@markii/html`'s `href-resolve.ts`.
+ *
+ * Same resolvability rule as images (no scheme, no protocol-relative
+ * `//host/...`, no bare `#fragment`, not empty), and the same
+ * `javascript:`/`vbscript:` refusal on the resolver's OWN return value,
+ * both shared with `./image-resolve.js` via `./url-resolve.js`.
+ */
+export type ResolveHref = (href: string) => string | undefined;
+/**
+ * The value one link should actually carry: `value` unchanged unless
+ * `resolveHref` is present, `value` is worth resolving at all, the resolver
+ * returns something, and that something passes `isSafeResolvedUrl`. A
+ * resolver that throws is treated exactly like one that returned
+ * `undefined`: `value` is kept, and the render is never broken over one
+ * link.
+ */
+export declare function resolveHrefAttribute(value: string, resolveHref: ResolveHref | undefined): string;

package/dist/href-resolve.js

@@ -0,0 +1,25 @@
+import { isResolvableRelativeValue, isSafeResolvedUrl } from './url-resolve.js';
+/**
+ * The value one link should actually carry: `value` unchanged unless
+ * `resolveHref` is present, `value` is worth resolving at all, the resolver
+ * returns something, and that something passes `isSafeResolvedUrl`. A
+ * resolver that throws is treated exactly like one that returned
+ * `undefined`: `value` is kept, and the render is never broken over one
+ * link.
+ */
+export function resolveHrefAttribute(value, resolveHref) {
+    if (!resolveHref)
+        return value;
+    if (!isResolvableRelativeValue(value))
+        return value;
+    let resolved;
+    try {
+        resolved = resolveHref(value);
+    }
+    catch {
+        return value;
+    }
+    if (resolved === undefined)
+        return value;
+    return isSafeResolvedUrl(resolved) ? resolved : value;
+}

package/dist/image-resolve.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The shared logic behind `renderMarkToAnsi`'s `resolveImageSrc` option
+ * (see `render.ts`'s `RenderMarkOptions`), used everywhere an image
+ * reference reaches this engine's output: an ordinary markdown image and
+ * any future standard component that builds its own image reference from a
+ * directive attribute. Ported verbatim from `@markii/html`'s
+ * `image-resolve.ts` (itself mirroring `@markii/react`'s).
+ *
+ * A host resolver is only ever asked about a source that could plausibly
+ * be its own: one with no scheme, no protocol-relative `//host/...` form,
+ * no bare `#fragment`, and no empty/whitespace value — `./url-resolve.js`'s
+ * `isResolvableRelativeValue`, shared with `resolveHref`
+ * (`./href-resolve.js`) rather than duplicated.
+ *
+ * WHY THE RESULT CHECK IS NOT `isSafeUrl`. `isSafeUrl`'s allowlist
+ * (`http`/`https`/`mailto`/`tel`) exists to judge a URL an AUTHOR typed
+ * into the document, where any other scheme is suspicious. A resolver's
+ * RETURN VALUE is the opposite trust direction: it is the HOST's own
+ * answer for where its resolved image actually lives, and the two
+ * reference hosts already return values `isSafeUrl` would reject outright
+ * (a `data:` URI, an `app://` vault path). What still needs guarding
+ * against is a resolver, hostile or merely buggy, echoing a
+ * `javascript:`/`vbscript:` value back out — the one class of scheme that
+ * turns an image reference into a script-execution vector rather than an
+ * image request. `./url-resolve.js`'s `isSafeResolvedUrl` is a narrow
+ * denylist for exactly that, not a repeat of the author-facing allowlist.
+ */
+/** The shape `renderMarkToAnsi`/`renderMarkNodeToAnsi` accept, and the one carried on `AnsiRenderContext` for a component that resolves its own image reference. */
+export type ResolveImageSrc = (src: string) => string | undefined;
+/**
+ * The value one image reference should actually carry: `value` unchanged
+ * unless `resolveImageSrc` is present, `value` is worth resolving at all,
+ * the resolver returns something, and that something passes
+ * `isSafeResolvedUrl` — so a resolver can never smuggle a `javascript:` URL
+ * past the sanitizer that already ran on everything else in the document,
+ * while a legitimate `data:`/`app:`/host-scheme result still reaches the
+ * output. A resolver that throws is treated exactly like one that returned
+ * `undefined`: `value` is kept, and the render is never broken over one
+ * image.
+ */
+export declare function resolveImageAttribute(value: string, resolveImageSrc: ResolveImageSrc | undefined): string;

package/dist/image-resolve.js

@@ -0,0 +1,28 @@
+import { isResolvableRelativeValue, isSafeResolvedUrl } from './url-resolve.js';
+/**
+ * The value one image reference should actually carry: `value` unchanged
+ * unless `resolveImageSrc` is present, `value` is worth resolving at all,
+ * the resolver returns something, and that something passes
+ * `isSafeResolvedUrl` — so a resolver can never smuggle a `javascript:` URL
+ * past the sanitizer that already ran on everything else in the document,
+ * while a legitimate `data:`/`app:`/host-scheme result still reaches the
+ * output. A resolver that throws is treated exactly like one that returned
+ * `undefined`: `value` is kept, and the render is never broken over one
+ * image.
+ */
+export function resolveImageAttribute(value, resolveImageSrc) {
+    if (!resolveImageSrc)
+        return value;
+    if (!isResolvableRelativeValue(value))
+        return value;
+    let resolved;
+    try {
+        resolved = resolveImageSrc(value);
+    }
+    catch {
+        return value;
+    }
+    if (resolved === undefined)
+        return value;
+    return isSafeResolvedUrl(resolved) ? resolved : value;
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { renderMarkToAnsi, renderMarkNodeToAnsi, renderMarkInlineToAnsi, type RenderMarkOptions, } from './render.js';
+export { fg, colorize, bold, dim, italic, underline, inverse, hyperlink, detectColorLevel, resolveColorOption, type ColorLevel, type ColorOption, type AnsiColor, } from './ansi.js';
+export { defaultAnsiTheme, type AnsiTheme, type Tier1Token } from './theme.js';
+export { style } from './style.js';
+export { createAnsiRegistry, mergeAnsiRegistries, registryAliases, readRegistryComponent, resolveDirectiveAlias, REGISTRY_ALIASES, type DirectiveAttributes, type AnsiRegistry, type AnsiRegistryEntry, type AnsiComponent, type AnsiChildren, type AnsiChildPart, type AnsiChildrenOptions, type AnsiRenderContext, type RegistryAlias, type RegistryAliases, type ResolvedDirective, type ValueResolution, } from './registry.js';
+export { resolveStorePath, resolveScopedPath, VAULT_NAME_PREFIX, type StorePathResolution, type ValueScope, } from './resolve.js';
+export { failurePhrase, failureTitle, failureToken, dataStateSuffix, emptyInlineTitle, invalidAttributeValueLabel, invalidAttributeValueTitle, unsafeImageSrcLabel, unsafeImageSrcTitle, } from './failure-presentation.js';
+export { stringifyStoredValue } from './value-format.js';
+export { measure, stripAnsi } from './measure.js';
+export { stripControlCharacters, sanitizeBlockText, sanitizeUrlText, BLOCK_TAB_WIDTH, } from './sanitize.js';
+export { wrap, pad, indentBlock, columns, frame, rule, type FrameOptions, } from './box.js';
+export { resolveLayoutAttributes, applyLayout, LAYOUT_ATTRIBUTE_KEYS, type ResolvedLayoutAttributes, type ResolvedLayoutPresets, type WidthPreset, type AlignPreset, } from './layout.js';
+export { type ResolveImageSrc } from './image-resolve.js';
+export { type ResolveHref } from './href-resolve.js';
+export type { AnsiValueStore, AnsiVaultStore, FailureKind, StoredValue, ValueStatus, } from './value-types.js';

package/dist/index.js

@@ -0,0 +1,17 @@
+// @markii/ansi: a framework-free terminal renderer for Markii documents. It
+// consumes @markii/core's sanitized hast and emits a plain string (optionally
+// carrying ANSI SGR/OSC 8 escapes) for a terminal, a pipe, or any host that
+// wants text with no HTML and no React runtime. It is a third platform
+// renderer alongside @markii/html and @markii/react.
+export { renderMarkToAnsi, renderMarkNodeToAnsi, renderMarkInlineToAnsi, } from './render.js';
+export { fg, colorize, bold, dim, italic, underline, inverse, hyperlink, detectColorLevel, resolveColorOption, } from './ansi.js';
+export { defaultAnsiTheme } from './theme.js';
+export { style } from './style.js';
+export { createAnsiRegistry, mergeAnsiRegistries, registryAliases, readRegistryComponent, resolveDirectiveAlias, REGISTRY_ALIASES, } from './registry.js';
+export { resolveStorePath, resolveScopedPath, VAULT_NAME_PREFIX, } from './resolve.js';
+export { failurePhrase, failureTitle, failureToken, dataStateSuffix, emptyInlineTitle, invalidAttributeValueLabel, invalidAttributeValueTitle, unsafeImageSrcLabel, unsafeImageSrcTitle, } from './failure-presentation.js';
+export { stringifyStoredValue } from './value-format.js';
+export { measure, stripAnsi } from './measure.js';
+export { stripControlCharacters, sanitizeBlockText, sanitizeUrlText, BLOCK_TAB_WIDTH, } from './sanitize.js';
+export { wrap, pad, indentBlock, columns, frame, rule, } from './box.js';
+export { resolveLayoutAttributes, applyLayout, LAYOUT_ATTRIBUTE_KEYS, } from './layout.js';

package/dist/layout.d.ts

@@ -0,0 +1,73 @@
+import { ALIGN_PRESETS, LAYOUT_ATTRIBUTE_KEYS, WIDTH_PRESETS } from '@markii/stdlib';
+import type { LayoutAxis } from '@markii/stdlib';
+import type { DirectiveAttributes } from './registry.js';
+/**
+ * The terminal counterpart of `@markii/html`'s `layout.ts`: the same closed
+ * `width`/`align` vocabulary from `@markii/stdlib`, but resolved to COLUMN
+ * ARITHMETIC instead of a CSS class, since there is no stylesheet here. The
+ * two reserved keys are still always stripped off a directive's attributes
+ * before a component sees them, whether or not their value turns out to be
+ * valid, exactly like the other two engines.
+ */
+export { LAYOUT_ATTRIBUTE_KEYS };
+export type WidthPreset = (typeof WIDTH_PRESETS)[number];
+export type AlignPreset = (typeof ALIGN_PRESETS)[number];
+/** The two layout attributes' resolved preset names, present only for a preset that actually applied. */
+export interface ResolvedLayoutPresets {
+    width?: WidthPreset;
+    align?: AlignPreset;
+}
+export interface ResolvedLayoutAttributes {
+    /** `attributes` with every reserved layout key (present, valid or not) removed. */
+    attributes: DirectiveAttributes;
+    /** The resolved presets, or `undefined` if neither attribute produced one. */
+    resolved?: ResolvedLayoutPresets;
+}
+/**
+ * Splits `width`/`align` off `attributes`, returning the remaining
+ * attributes untouched plus the presets those two attributes resolved to,
+ * if any. Same rules as `@markii/html`'s `resolveLayoutAttributes`: both
+ * keys are stripped whenever present regardless of validity; an invalid or
+ * hostile value never produces a preset; `ownedAxis` (a layout wrapper's own
+ * axis) strips its attribute but produces no preset for it, since the
+ * directive's NAME already decided that axis. Never throws.
+ */
+export declare function resolveLayoutAttributes(attributes: DirectiveAttributes, ownedAxis?: LayoutAxis): ResolvedLayoutAttributes;
+/** The minimum column count `narrow` ever shrinks to, regardless of how small `width` is. */
+export declare const NARROW_MINIMUM = 20;
+/**
+ * Turns `layout`'s resolved presets into an actual re-wrapped, aligned
+ * block, given `width` columns of budget. Mapping (all documented here,
+ * the one place it is decided): `narrow` halves `width` (rounded, never
+ * below `NARROW_MINIMUM`); `wide` and `full` both use the entire `width`
+ * (a terminal has no notion of "wider than the column" to distinguish
+ * them); `fit` shrinks to `block`'s own widest existing line, never wider
+ * than `width`. `align` then places the (possibly narrowed) block within
+ * the full `width` using `./box.js`'s `pad`, which is where `align`'s
+ * `left`/`center`/`right` meaning comes from — this function invents none
+ * of its own.
+ */
+export declare function applyLayout(block: string, layout: ResolvedLayoutPresets | undefined, width: number): string;
+/**
+ * The target width a SELF-DRAWING box component (`card`, `callout`, `table`,
+ * `chart`; see `registry.ts`'s `AnsiRegistryEntry.selfLayout`) should draw
+ * its own frame at, given the resolved `width` preset. Mirrors the width
+ * half of `applyLayout`'s mapping exactly (`narrow` halves `width`, floored
+ * at `NARROW_MINIMUM`; `wide`/`full`/absent use the whole budget; `fit`
+ * shrinks to the box's own natural content width, capped at `width`), so a
+ * component that draws at this width up front needs no further narrowing:
+ * `applyLayout`'s `wrap` step becomes a no-op on an already-correctly-sized
+ * line. `naturalWidth` is the box's own widest line at its full content size
+ * (only consulted for `fit`); a caller that draws lazily may pass a function
+ * to defer that measurement until it is known to matter.
+ */
+export declare function selfLayoutWidth(layout: ResolvedLayoutPresets | undefined, width: number, naturalWidth: number | (() => number)): number;
+/**
+ * Pads a SELF-DRAWING box's already-drawn frame (every line already
+ * `boxWidth` columns wide) within the full `width` per the resolved `align`
+ * preset — the align half of `applyLayout`, factored out so a `selfLayout`
+ * component can align its own frame without going through the generic
+ * narrow/wrap path that would otherwise re-wrap (and corrupt) its
+ * box-drawing characters. A no-op when `layout.align` is absent.
+ */
+export declare function selfLayoutAlign(block: string, layout: ResolvedLayoutPresets | undefined, width: number): string;