# Images (WASM) API reference

> Exports of @gramforge/images-wasm.

Source: https://gramforge.n.yatsyk.com/docs/images-wasm/jsdoc

## Functions

### buildChartTree

```ts
buildChartTree(input: ChartCardInput): Promise<CardNode>
```

### buildCompletionTree

```ts
buildCompletionTree(input: CompletionCardInput): CardNode
```

### buildFailureTree

```ts
buildFailureTree(input: FailureCardInput): CardNode
```

### buildFleetOverviewTree

```ts
buildFleetOverviewTree(input: FleetOverviewCardInput): Promise<CardNode>
```

### buildNeedsInputTree

```ts
buildNeedsInputTree(input: Omit<NeedsInputCardInput, "options"> & { readonly options: readonly NeedsInputOption[]; }): CardNode
```

### buildStatusTree

```ts
buildStatusTree(input: StatusCardInput): CardNode
```

### chartToSvg

Render a validated `ChartSpec` to an SVG string (pure, no rasterization).

```ts
chartToSvg(spec: ChartSpec, dimensions: ChartDimensions): string
```

### col

A vertical flex container (`flexDirection: column`).

```ts
col(style: CardStyle, children: readonly CardNode[]): BoxNode
```

### computeContentHash

SHA-256 of `bytes`, returned as a branded lowercase-hex `ContentHash`.

```ts
computeContentHash(bytes: Uint8Array): Promise<ContentHash>
```

### containsColorEmoji

True when `input` contains at least one codepoint in a color-emoji
presentation range (emoticons, symbols/pictographs, transport, supplemental,
regional indicators, and the common Misc-Symbols/Dingbats emoji subset).

```ts
containsColorEmoji(input: string): boolean
```

### createInMemoryFileIdCacheStore

A process-lifetime `Map`-backed store for development/testing.

```ts
createInMemoryFileIdCacheStore(): FileIdCacheStore
```

### createTakumiWasmBackend

Create the wasm backend. Instantiation of the wasm module and font
registration happen lazily on the first `renderPng` call so this factory is
synchronous and side-effect-free until a render is actually requested.

```ts
createTakumiWasmBackend(inputs: TakumiWasmInputs): ImageBackend
```

### div

A generic flex container.

```ts
div(style: CardStyle, children: readonly CardNode[]): BoxNode
```

### emojiCodepoints

Collect the distinct emoji codepoints (as `U+XXXX` strings) in `input`.

```ts
emojiCodepoints(input: string): string[]
```

### img

An image leaf carrying raw bytes (e.g. a rendered chart PNG).

```ts
img(input: { readonly src: Uint8Array; readonly width: number; readonly height: number; readonly style?: CardStyle; }): ImageNode
```

### rasterizeSvgResvgWasm

Rasterize an SVG string to PNG via `@resvg/resvg-wasm` (portable). The resvg
wasm binary is injected and initialized once per process.

```ts
rasterizeSvgResvgWasm(svg: string, wasm: InitInput): Promise<RasterizeResult>
```

### recordUpload

Record a newly-uploaded `file_id` into the store. The single place a caller
writes a `file_id` back — this package itself never performs the upload.

```ts
recordUpload(store: FileIdCacheStore, hash: ContentHash, botId: BotId, fileId: TelegramFileId): Promise<void>
```

### renderCardWasm

Render a card node tree to PNG bytes via the Takumi WASM backend — a single
node-free call for the common case. Reuse a backend across renders by calling
{@link createTakumiWasmBackend} directly if you render many cards.

```ts
renderCardWasm(node: CardNode, options: RenderPngOptions, inputs: TakumiWasmInputs): Promise<Uint8Array>
```

### resetDiagnostics

Test-only: clear the dedup set between tests.

```ts
resetDiagnostics(): void
```

### row

A horizontal flex container (`flexDirection: row`).

```ts
row(style: CardStyle, children: readonly CardNode[]): BoxNode
```

### setDiagnosticHook

```ts
setDiagnosticHook(fn: ((e: DiagnosticEvent) => void) | null): void
```

### text

A text leaf.

```ts
text(value: string, style?: CardStyle): TextNode
```

### toTakumiNode

```ts
toTakumiNode(node: CardNode): Node
```

### warnDegraded

```ts
warnDegraded(context: string, detail: string): void
```

### warnNotImplemented

```ts
warnNotImplemented(category: string, detail: string): void
```

### warnUnexpected

```ts
warnUnexpected(context: string, detail: string, data?: Record<string, unknown>): void
```

## Types

### BackendKind

```ts
type BackendKind = "takumi-native" | "takumi-wasm"
```

### BotId

```ts
type BotId = string & z.BRAND<"BotId">
```

### BoxNode

```ts
type BoxNode = {
  readonly kind: "box";
  readonly style: CardStyle;
  readonly children: readonly CardNode[];
}
```

### CachedFileHit

```ts
type CachedFileHit = { contentHash: string & z.BRAND<"ContentHash">; hit: true; fileId: string & z.BRAND<"TelegramFileId">; }
```

### CardInput

```ts
type CardInput = { template: "status"; agentName: string; level: "ok" | "warn" | "error"; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; } | { title: string; template: "fleet-overview"; timestampIso: string; agents: { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }[]; chart: { kind: "none"; } | { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }; } | { options: { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }[]; template: "needs-input"; agentName: string; timestampIso: string; question: string; } | { template: "completion"; agentName: string; headline: string; timestampIso: string; summary: { kind: "none"; } | { kind: "text"; value: string; }; durationMs: number; } | { template: "failure"; agentName: string; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; } | { template: "chart"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; caption: { kind: "none"; } | { kind: "text"; value: string; }; }
```

### CardNode

```ts
type CardNode = BoxNode | TextNode | ImageNode
```

### ChartCardInput

```ts
type ChartCardInput = { template: "chart"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; caption: { kind: "none"; } | { kind: "text"; value: string; }; }
```

### ChartKind

```ts
type ChartKind = "bar" | "line"
```

### ChartSeries

```ts
type ChartSeries = { values: number[]; name: string; }
```

### ChartSpec

```ts
type ChartSpec = { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }
```

### CompletionCardInput

```ts
type CompletionCardInput = { template: "completion"; agentName: string; headline: string; timestampIso: string; summary: { kind: "none"; } | { kind: "text"; value: string; }; durationMs: number; }
```

### ContentHash

```ts
type ContentHash = string & z.BRAND<"ContentHash">
```

### DiagnosticKind

Runtime diagnostics — the house alternative to deferred-work comments.

Three functions: `warnNotImplemented`, `warnDegraded`, `warnUnexpected`.
Each fires once per stable key (except `warnUnexpected`, which always fires),
is greppable, and can be piped into a UI panel via {@link setDiagnosticHook}.

Usage:
  warnDegraded("MyModule.fallback", "linear interp — cubic deferred, spec:120-140");
  warnNotImplemented("MyModule.featureX", "spec §4 not yet lowered");
  warnUnexpected("MyModule.parse", "expected number, got string", { value });

```ts
type DiagnosticKind = "not-implemented" | "degraded" | "unexpected"
```

### FailureCardInput

```ts
type FailureCardInput = { template: "failure"; agentName: string; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }
```

### FleetAgent

```ts
type FleetAgent = { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }
```

### FleetOverviewCardInput

```ts
type FleetOverviewCardInput = { title: string; template: "fleet-overview"; timestampIso: string; agents: { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }[]; chart: { kind: "none"; } | { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }; }
```

### FlexAlign

```ts
type FlexAlign = "flex-start" | "center" | "flex-end" | "stretch" | "baseline"
```

### FlexDirection

The single flexbox-safe authoring format for both backends.

Card templates build a neutral `CardNode` tree via `div`/`row`/`col`/`text`/
`img`. The backends convert it to their native shape (Takumi's
`{ type: "container" | "text" | "image" }` nodes, or a satori element tree).
`CardStyle` deliberately exposes only flexbox-compatible props — there is no
CSS Grid and no free-form `style: string` escape hatch, so a template that
type-checks renders consistently on Takumi and satori alike.

```ts
type FlexDirection = "row" | "column"
```

### FlexJustify

```ts
type FlexJustify = "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | "space-evenly"
```

### FlexWrap

```ts
type FlexWrap = "nowrap" | "wrap"
```

### ImageNode

```ts
type ImageNode = {
  readonly kind: "image";
  readonly style: CardStyle;
  readonly src: Uint8Array;
  readonly width: number;
  readonly height: number;
}
```

### NeedsInputCardInput

```ts
type NeedsInputCardInput = { options: { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }[]; template: "needs-input"; agentName: string; timestampIso: string; question: string; }
```

### NeedsInputOption

```ts
type NeedsInputOption = { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }
```

### NetworkUsage

```ts
type NetworkUsage = { kind: "offline"; } | { kind: "emoji-font-fetch"; codepoints: string[]; }
```

### ObjectFit

```ts
type ObjectFit = "fill" | "contain" | "cover"
```

### RasterizeResult

```ts
type RasterizeResult = {
  readonly ok: true;
  readonly bytes: Uint8Array;
  readonly width: number;
  readonly height: number;
} | {
  readonly ok: false;
  readonly message: string;
}
```

### RenderErr

```ts
type RenderErr = {
  readonly ok: false;
  readonly error: RenderFailure;
}
```

### RenderFailure

```ts
type RenderFailure = { kind: "invalid-template-input"; issues: string[]; } | { kind: "renderer-unavailable"; attempted: ({ kind: "takumi"; } | { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; })[]; } | { kind: "rasterize-failed"; message: string; } | { kind: "chart-spec-invalid"; issues: string[]; }
```

### RenderMeta

```ts
type RenderMeta = { backend: { kind: "takumi"; } | { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }; contentHash: string & z.BRAND<"ContentHash">; network: { kind: "offline"; } | { kind: "emoji-font-fetch"; codepoints: string[]; }; renderMs: number; widthPx: number; heightPx: number; }
```

### RenderOk

```ts
type RenderOk = {
  readonly ok: true;
  readonly bytes: Uint8Array;
  readonly meta: RenderMeta;
}
```

### RenderResult

```ts
type RenderResult = RenderOk | RenderErr
```

### RendererBackend

```ts
type RendererBackend = { kind: "takumi"; } | { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }
```

### RendererFallbackReason

```ts
type RendererFallbackReason = { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }
```

### StatusCardInput

```ts
type StatusCardInput = { template: "status"; agentName: string; level: "ok" | "warn" | "error"; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }
```

### StatusLevel

```ts
type StatusLevel = "ok" | "warn" | "error"
```

### TelegramFileId

```ts
type TelegramFileId = string & z.BRAND<"TelegramFileId">
```

### TextAlign

```ts
type TextAlign = "left" | "center" | "right"
```

### TextNode

```ts
type TextNode = {
  readonly kind: "text";
  readonly style: CardStyle;
  readonly text: string;
}
```

## Interfaces

### CardStyle

The flexbox-only style subset. Every property is optional at the type level,
but there is no `[k: string]: unknown` index signature and no raw string
escape hatch, so unsupported CSS (grid, position tricks) cannot be expressed.

```ts
interface CardStyle
```

- `flexDirection: FlexDirection`
- `alignItems: FlexAlign`
- `justifyContent: FlexJustify`
- `flexWrap: FlexWrap`
- `flexGrow: number`
- `flexShrink: number`
- `flexBasis: string | number`
- `gap: number`
- `padding: string | number`
- `margin: string | number`
- `width: string | number`
- `height: string | number`
- `minWidth: string | number`
- `maxWidth: string | number`
- `minHeight: string | number`
- `maxHeight: string | number`
- `backgroundColor: string`
- `color: string`
- `fontSize: number`
- `fontWeight: number`
- `fontFamily: string`
- `lineHeight: number`
- `letterSpacing: number`
- `textAlign: TextAlign`
- `borderRadius: number`
- `borderWidth: number`
- `borderColor: string`
- `borderStyle: "solid"`
- `objectFit: ObjectFit`
- `opacity: number`

### ChartDimensions

```ts
interface ChartDimensions
```

- `width: number`
- `height: number`

### DiagnosticEvent

```ts
interface DiagnosticEvent
```

- `kind: DiagnosticKind`
- `category: string`
- `detail: string`
- `stack: string`
- `data: Record<string, unknown>`
- `timestamp: number`

### FileIdCacheStore

Pluggable storage port. The in-memory default ships here; callers substitute
a persistent (SQLite/Redis) implementation without any change to `renderCard`.

```ts
interface FileIdCacheStore
```

- `get(hash: ContentHash, botId: BotId): Promise<TelegramFileId | null>`
- `set(hash: ContentHash, botId: BotId, fileId: TelegramFileId): Promise<void>`

### ImageBackend

```ts
interface ImageBackend
```

- `kind: BackendKind`
- `renderPng(node: CardNode, opts: RenderPngOptions): Promise<Uint8Array>`

### RenderPngOptions

```ts
interface RenderPngOptions
```

- `width: number`
- `height: number`

### TakumiWasmInputs

```ts
interface TakumiWasmInputs
```

- `wasm: SyncInitInput` — The `takumi_wasm_bg.wasm` bytes or a precompiled module.
- `fonts: readonly Uint8Array<ArrayBufferLike>[]` — Font buffers to register (e.g. a Latin/monospace font).

## Constants

### BotIdSchema

```ts
const BotIdSchema: z.ZodBranded<z.ZodString, "BotId">
```

### CHART_DIMENSIONS

```ts
const CHART_DIMENSIONS: RenderPngOptions
```

### COMPLETION_DIMENSIONS

```ts
const COMPLETION_DIMENSIONS: RenderPngOptions
```

### CachedFileHitSchema

```ts
const CachedFileHitSchema: z.ZodObject<{ hit: z.ZodLiteral<true>; fileId: z.ZodBranded<z.ZodString, "TelegramFileId">; contentHash: z.ZodBranded<z.ZodString, "ContentHash">; }, "strip", z.ZodTypeAny, { contentHash: string & z.BRAND<"ContentHash">; hit: true; fileId: string & z.BRAND<"TelegramFileId">; }, { contentHash: string; hit: true; fileId: string; }>
```

### CardInputSchema

```ts
const CardInputSchema: z.ZodDiscriminatedUnion<"template", [z.ZodObject<{ template: z.ZodLiteral<"status">; agentName: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; headline: z.ZodString; detail: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template: "status"; agentName: string; level: "ok" | "warn" | "error"; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }, { template: "status"; agentName: string; level: "ok" | "warn" | "error"; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }>, z.ZodObject<{ template: z.ZodLiteral<"fleet-overview">; title: z.ZodString; agents: z.ZodArray<z.ZodObject<{ name: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; note: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; }, "strip", z.ZodTypeAny, { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }, { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }>, "many">; chart: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"spec">; spec: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values: number[]; name: string; }, { values: number[]; name: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }>; }, "strip", z.ZodTypeAny, { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }, { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { title: string; template: "fleet-overview"; timestampIso: string; agents: { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }[]; chart: { kind: "none"; } | { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }; }, { title: string; template: "fleet-overview"; timestampIso: string; agents: { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }[]; chart: { kind: "none"; } | { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }; }>, z.ZodObject<{ template: z.ZodLiteral<"needs-input">; agentName: z.ZodString; question: z.ZodString; options: z.ZodArray<z.ZodObject<{ label: z.ZodString; hint: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; }, "strip", z.ZodTypeAny, { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }, { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }>, "many">; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { options: { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }[]; template: "needs-input"; agentName: string; timestampIso: string; question: string; }, { options: { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }[]; template: "needs-input"; agentName: string; timestampIso: string; question: string; }>, z.ZodObject<{ template: z.ZodLiteral<"completion">; agentName: z.ZodString; headline: z.ZodString; summary: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; durationMs: z.ZodNumber; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template: "completion"; agentName: string; headline: string; timestampIso: string; summary: { kind: "none"; } | { kind: "text"; value: string; }; durationMs: number; }, { template: "completion"; agentName: string; headline: string; timestampIso: string; summary: { kind: "none"; } | { kind: "text"; value: string; }; durationMs: number; }>, z.ZodObject<{ template: z.ZodLiteral<"failure">; agentName: z.ZodString; headline: z.ZodString; detail: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template: "failure"; agentName: string; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }, { template: "failure"; agentName: string; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }>, z.ZodObject<{ template: z.ZodLiteral<"chart">; spec: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values: number[]; name: string; }, { values: number[]; name: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }>; caption: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; }, "strip", z.ZodTypeAny, { template: "chart"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; caption: { kind: "none"; } | { kind: "text"; value: string; }; }, { template: "chart"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; caption: { kind: "none"; } | { kind: "text"; value: string; }; }>]>
```

### ChartCardInputSchema

```ts
const ChartCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"chart">; spec: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values: number[]; name: string; }, { values: number[]; name: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }>; caption: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; }, "strip", z.ZodTypeAny, { template: "chart"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; caption: { kind: "none"; } | { kind: "text"; value: string; }; }, { template: "chart"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; caption: { kind: "none"; } | { kind: "text"; value: string; }; }>
```

### ChartKindSchema

```ts
const ChartKindSchema: z.ZodEnum<["bar", "line"]>
```

### ChartSeriesSchema

```ts
const ChartSeriesSchema: z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values: number[]; name: string; }, { values: number[]; name: string; }>
```

### ChartSpecSchema

```ts
const ChartSpecSchema: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values: number[]; name: string; }, { values: number[]; name: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }>
```

### CompletionCardInputSchema

```ts
const CompletionCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"completion">; agentName: z.ZodString; headline: z.ZodString; summary: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; durationMs: z.ZodNumber; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template: "completion"; agentName: string; headline: string; timestampIso: string; summary: { kind: "none"; } | { kind: "text"; value: string; }; durationMs: number; }, { template: "completion"; agentName: string; headline: string; timestampIso: string; summary: { kind: "none"; } | { kind: "text"; value: string; }; durationMs: number; }>
```

### ContentHashSchema

```ts
const ContentHashSchema: z.ZodBranded<z.ZodString, "ContentHash">
```

### DEFAULT_CHART_HEIGHT

```ts
const DEFAULT_CHART_HEIGHT: 480
```

### DEFAULT_CHART_WIDTH

```ts
const DEFAULT_CHART_WIDTH: 800
```

### FAILURE_DIMENSIONS

```ts
const FAILURE_DIMENSIONS: RenderPngOptions
```

### FLEET_OVERVIEW_DIMENSIONS

```ts
const FLEET_OVERVIEW_DIMENSIONS: RenderPngOptions
```

### FailureCardInputSchema

```ts
const FailureCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"failure">; agentName: z.ZodString; headline: z.ZodString; detail: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template: "failure"; agentName: string; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }, { template: "failure"; agentName: string; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }>
```

### FleetAgentSchema

```ts
const FleetAgentSchema: z.ZodObject<{ name: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; note: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; }, "strip", z.ZodTypeAny, { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }, { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }>
```

### FleetOverviewCardInputSchema

```ts
const FleetOverviewCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"fleet-overview">; title: z.ZodString; agents: z.ZodArray<z.ZodObject<{ name: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; note: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; }, "strip", z.ZodTypeAny, { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }, { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }>, "many">; chart: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"spec">; spec: z.ZodObject<{ kind: z.ZodEnum<["bar", "line"]>; title: z.ZodString; categories: z.ZodArray<z.ZodString, "many">; series: z.ZodArray<z.ZodObject<{ name: z.ZodString; values: z.ZodArray<z.ZodNumber, "many">; }, "strip", z.ZodTypeAny, { values: number[]; name: string; }, { values: number[]; name: string; }>, "many">; }, "strip", z.ZodTypeAny, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }, { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }>; }, "strip", z.ZodTypeAny, { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }, { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { title: string; template: "fleet-overview"; timestampIso: string; agents: { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }[]; chart: { kind: "none"; } | { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }; }, { title: string; template: "fleet-overview"; timestampIso: string; agents: { name: string; level: "ok" | "warn" | "error"; note: { kind: "none"; } | { kind: "text"; value: string; }; }[]; chart: { kind: "none"; } | { kind: "spec"; spec: { kind: "bar" | "line"; title: string; categories: string[]; series: { values: number[]; name: string; }[]; }; }; }>
```

### NEEDS_INPUT_DIMENSIONS

```ts
const NEEDS_INPUT_DIMENSIONS: RenderPngOptions
```

### NeedsInputCardInputSchema

```ts
const NeedsInputCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"needs-input">; agentName: z.ZodString; question: z.ZodString; options: z.ZodArray<z.ZodObject<{ label: z.ZodString; hint: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; }, "strip", z.ZodTypeAny, { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }, { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }>, "many">; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { options: { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }[]; template: "needs-input"; agentName: string; timestampIso: string; question: string; }, { options: { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }[]; template: "needs-input"; agentName: string; timestampIso: string; question: string; }>
```

### NeedsInputOptionSchema

```ts
const NeedsInputOptionSchema: z.ZodObject<{ label: z.ZodString; hint: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; }, "strip", z.ZodTypeAny, { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }, { label: string; hint: { kind: "none"; } | { kind: "text"; value: string; }; }>
```

### NetworkUsageSchema

```ts
const NetworkUsageSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"offline">; }, "strip", z.ZodTypeAny, { kind: "offline"; }, { kind: "offline"; }>, z.ZodObject<{ kind: z.ZodLiteral<"emoji-font-fetch">; codepoints: z.ZodArray<z.ZodString, "many">; }, "strip", z.ZodTypeAny, { kind: "emoji-font-fetch"; codepoints: string[]; }, { kind: "emoji-font-fetch"; codepoints: string[]; }>]>
```

### RenderFailureSchema

```ts
const RenderFailureSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"invalid-template-input">; issues: z.ZodArray<z.ZodString, "many">; }, "strip", z.ZodTypeAny, { kind: "invalid-template-input"; issues: string[]; }, { kind: "invalid-template-input"; issues: string[]; }>, z.ZodObject<{ kind: z.ZodLiteral<"renderer-unavailable">; attempted: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"takumi">; }, "strip", z.ZodTypeAny, { kind: "takumi"; }, { kind: "takumi"; }>, z.ZodObject<{ kind: z.ZodLiteral<"satori-sharp">; reason: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"native-module-load-failed">; platform: z.ZodString; arch: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "native-module-load-failed"; platform: string; arch: string; }, { kind: "native-module-load-failed"; platform: string; arch: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"forced-fallback">; }, "strip", z.ZodTypeAny, { kind: "forced-fallback"; }, { kind: "forced-fallback"; }>]>; }, "strip", z.ZodTypeAny, { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }, { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }>]>, "many">; }, "strip", z.ZodTypeAny, { kind: "renderer-unavailable"; attempted: ({ kind: "takumi"; } | { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; })[]; }, { kind: "renderer-unavailable"; attempted: ({ kind: "takumi"; } | { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; })[]; }>, z.ZodObject<{ kind: z.ZodLiteral<"rasterize-failed">; message: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "rasterize-failed"; message: string; }, { kind: "rasterize-failed"; message: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"chart-spec-invalid">; issues: z.ZodArray<z.ZodString, "many">; }, "strip", z.ZodTypeAny, { kind: "chart-spec-invalid"; issues: string[]; }, { kind: "chart-spec-invalid"; issues: string[]; }>]>
```

### RenderMetaSchema

```ts
const RenderMetaSchema: z.ZodObject<{ backend: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"takumi">; }, "strip", z.ZodTypeAny, { kind: "takumi"; }, { kind: "takumi"; }>, z.ZodObject<{ kind: z.ZodLiteral<"satori-sharp">; reason: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"native-module-load-failed">; platform: z.ZodString; arch: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "native-module-load-failed"; platform: string; arch: string; }, { kind: "native-module-load-failed"; platform: string; arch: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"forced-fallback">; }, "strip", z.ZodTypeAny, { kind: "forced-fallback"; }, { kind: "forced-fallback"; }>]>; }, "strip", z.ZodTypeAny, { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }, { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }>]>; contentHash: z.ZodBranded<z.ZodString, "ContentHash">; network: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"offline">; }, "strip", z.ZodTypeAny, { kind: "offline"; }, { kind: "offline"; }>, z.ZodObject<{ kind: z.ZodLiteral<"emoji-font-fetch">; codepoints: z.ZodArray<z.ZodString, "many">; }, "strip", z.ZodTypeAny, { kind: "emoji-font-fetch"; codepoints: string[]; }, { kind: "emoji-font-fetch"; codepoints: string[]; }>]>; renderMs: z.ZodNumber; widthPx: z.ZodNumber; heightPx: z.ZodNumber; }, "strip", z.ZodTypeAny, { backend: { kind: "takumi"; } | { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }; contentHash: string & z.BRAND<"ContentHash">; network: { kind: "offline"; } | { kind: "emoji-font-fetch"; codepoints: string[]; }; renderMs: number; widthPx: number; heightPx: number; }, { backend: { kind: "takumi"; } | { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }; contentHash: string; network: { kind: "offline"; } | { kind: "emoji-font-fetch"; codepoints: string[]; }; renderMs: number; widthPx: number; heightPx: number; }>
```

### RendererBackendSchema

```ts
const RendererBackendSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"takumi">; }, "strip", z.ZodTypeAny, { kind: "takumi"; }, { kind: "takumi"; }>, z.ZodObject<{ kind: z.ZodLiteral<"satori-sharp">; reason: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"native-module-load-failed">; platform: z.ZodString; arch: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "native-module-load-failed"; platform: string; arch: string; }, { kind: "native-module-load-failed"; platform: string; arch: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"forced-fallback">; }, "strip", z.ZodTypeAny, { kind: "forced-fallback"; }, { kind: "forced-fallback"; }>]>; }, "strip", z.ZodTypeAny, { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }, { kind: "satori-sharp"; reason: { kind: "native-module-load-failed"; platform: string; arch: string; } | { kind: "forced-fallback"; }; }>]>
```

### RendererFallbackReasonSchema

```ts
const RendererFallbackReasonSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"native-module-load-failed">; platform: z.ZodString; arch: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "native-module-load-failed"; platform: string; arch: string; }, { kind: "native-module-load-failed"; platform: string; arch: string; }>, z.ZodObject<{ kind: z.ZodLiteral<"forced-fallback">; }, "strip", z.ZodTypeAny, { kind: "forced-fallback"; }, { kind: "forced-fallback"; }>]>
```

### STATUS_DIMENSIONS

```ts
const STATUS_DIMENSIONS: RenderPngOptions
```

### StatusCardInputSchema

```ts
const StatusCardInputSchema: z.ZodObject<{ template: z.ZodLiteral<"status">; agentName: z.ZodString; level: z.ZodEnum<["ok", "warn", "error"]>; headline: z.ZodString; detail: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{ kind: z.ZodLiteral<"none">; }, "strip", z.ZodTypeAny, { kind: "none"; }, { kind: "none"; }>, z.ZodObject<{ kind: z.ZodLiteral<"text">; value: z.ZodString; }, "strip", z.ZodTypeAny, { kind: "text"; value: string; }, { kind: "text"; value: string; }>]>; timestampIso: z.ZodString; }, "strip", z.ZodTypeAny, { template: "status"; agentName: string; level: "ok" | "warn" | "error"; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }, { template: "status"; agentName: string; level: "ok" | "warn" | "error"; headline: string; detail: { kind: "none"; } | { kind: "text"; value: string; }; timestampIso: string; }>
```

### StatusLevelSchema

```ts
const StatusLevelSchema: z.ZodEnum<["ok", "warn", "error"]>
```

### TelegramFileIdSchema

```ts
const TelegramFileIdSchema: z.ZodBranded<z.ZodString, "TelegramFileId">
```