gazetta 0.7.0 → 0.8.0

package/dist/ai/vision-prep.js

@@ -0,0 +1,113 @@
+/**
+ * Image preprocessing for vision-using AI tasks.
+ *
+ * # Single responsibility
+ *
+ * Take raw asset bytes; return bytes suitable for sending to a vision
+ * provider. Concretely:
+ *
+ *   - Resize to `MAX_EDGE` long-edge (default 768) preserving aspect ratio
+ *   - Re-encode to JPEG (or PNG if alpha) post-resize
+ *   - Rasterize SVG to PNG at MAX_EDGE
+ *   - Pass through if already small (no needless re-encode)
+ *   - Use the analyzer-extracted poster bytes for animated images
+ *
+ * No knowledge of providers, prompts, refusal, or task-specific config.
+ *
+ * # Why 768
+ *
+ * Smallest size that fits all v1.5 providers natively without quality
+ * loss:
+ *
+ *   - Ollama llama3.2-vision native input is 1120×1120
+ *   - Anthropic Claude (non-Opus) recommended max long edge is 1568
+ *   - OpenAI gpt-4o "high detail" mode targets 768 as the short-edge
+ *     value when tiling 512×512 — chosen by OpenAI as the size where
+ *     in-image text remains legible
+ *
+ * 768 sits below all three ceilings, makes OpenAI tile to exactly
+ * 4 tiles + base = 765 tokens, and produces predictable cost on
+ * Anthropic (~786 tokens for a 768×768 image, well under the 1568
+ * token ceiling).
+ *
+ * Going lower (e.g., 512) hits OpenAI's "low detail" tier which the
+ * provider's own docs mark as worse for in-image text. Going higher
+ * exceeds Ollama's native input so the model downsamples internally
+ * — we'd be paying upload bandwidth for bytes that get discarded.
+ *
+ * # Per-task override
+ *
+ * Vision tasks that need different sizing (e.g., a future tag-suggestion
+ * task on detailed product shots wanting 1024) pass `maxEdge` per call.
+ * `MAX_EDGE` is the default; `prepareForVision` accepts an override.
+ *
+ * # Animated images
+ *
+ * The animated-image analyzer (shipped in media v1) extracts a
+ * first-frame PNG poster as a supplementary file. Suggester callers
+ * pass those bytes via `posterBytes` — `prepareForVision` skips its
+ * own rasterization and uses the poster directly. Cross-feature reuse
+ * over duplication.
+ *
+ * # SOLID lenses
+ *
+ *   - SRP: this module owns "raw asset bytes → vision-call bytes"
+ *   - OCP: a future `pdf-prep.ts` peer handles document tasks the same way
+ *   - DIP: callers depend on `prepareForVision`, not on sharp directly
+ */
+import sharp from 'sharp';
+/** Default long-edge cap. Per-call override available via `maxEdge`. */
+export const MAX_EDGE = 768;
+/**
+ * SVG rasterization density. 144 dpi is a sensible doubled-72-dpi
+ * default that produces ~2x the nominal SVG dimensions. Combined with
+ * the resize step, the final output is bounded by `maxEdge` regardless
+ * of the SVG's intrinsic size — density only affects rendering quality
+ * before the cap kicks in.
+ */
+const SVG_DENSITY = 144;
+/**
+ * Prepare image bytes for a vision-call. Single async call that picks
+ * the right code path based on input.
+ *
+ * Throws on hard failures (corrupt source bytes that sharp can't
+ * decode, even past metadata). Callers wrap in their adapter's error
+ * taxonomy.
+ */
+export async function prepareForVision(input) {
+    const maxEdge = input.maxEdge ?? MAX_EDGE;
+    // Animated source: use the pre-extracted poster bytes (always PNG).
+    // Posters are extracted at upload time and already represent the
+    // first frame; for vision-call purposes that's what we want.
+    if (input.posterBytes) {
+        return { bytes: input.posterBytes, mime: 'image/png' };
+    }
+    // SVG: rasterize to PNG at the cap. Vector input has no intrinsic
+    // pixel size; we pick density × resize to bound the output.
+    if (input.mime === 'image/svg+xml') {
+        const buf = await sharp(input.bytes, { density: SVG_DENSITY })
+            .resize({ width: maxEdge, height: maxEdge, fit: 'inside' })
+            .png()
+            .toBuffer();
+        return { bytes: new Uint8Array(buf), mime: 'image/png' };
+    }
+    // Raster: resize if larger than maxEdge on long edge; otherwise pass
+    // through. Avoids a no-op JPEG-of-JPEG re-encode that would lose
+    // quality without saving bandwidth.
+    const meta = await sharp(input.bytes).metadata();
+    const longEdge = Math.max(meta.width ?? 0, meta.height ?? 0);
+    if (longEdge > 0 && longEdge <= maxEdge) {
+        return { bytes: input.bytes, mime: input.mime };
+    }
+    // Preserve PNG when source has alpha (logos with transparency lose
+    // semantically when flattened to JPEG). Otherwise JPEG quality 85 —
+    // sharp's default for `.jpeg()`, well-balanced for AI input.
+    const hasAlpha = meta.hasAlpha === true;
+    const pipeline = sharp(input.bytes).resize({ width: maxEdge, height: maxEdge, fit: 'inside' });
+    const buf = hasAlpha ? await pipeline.png().toBuffer() : await pipeline.jpeg({ quality: 85 }).toBuffer();
+    return {
+        bytes: new Uint8Array(buf),
+        mime: hasAlpha ? 'image/png' : 'image/jpeg',
+    };
+}
+//# sourceMappingURL=vision-prep.js.map

package/dist/ai/vision-prep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vision-prep.js","sourceRoot":"","sources":["../../src/ai/vision-prep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,wEAAwE;AACxE,MAAM,CAAC,MAAM,QAAQ,GAAG,GAAG,CAAA;AAwB3B;;;;;;GAMG;AACH,MAAM,WAAW,GAAG,GAAG,CAAA;AAEvB;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,KAAmB;IACxD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,QAAQ,CAAA;IAEzC,oEAAoE;IACpE,iEAAiE;IACjE,6DAA6D;IAC7D,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;QACtB,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,CAAA;IACxD,CAAC;IAED,kEAAkE;IAClE,4DAA4D;IAC5D,IAAI,KAAK,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;QACnC,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;aAC3D,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;aAC1D,GAAG,EAAE;aACL,QAAQ,EAAE,CAAA;QACb,OAAO,EAAE,KAAK,EAAE,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAA;IAC1D,CAAC;IAED,qEAAqE;IACrE,iEAAiE;IACjE,oCAAoC;IACpC,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAA;IAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,EAAE,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,CAAA;IAC5D,IAAI,QAAQ,GAAG,CAAC,IAAI,QAAQ,IAAI,OAAO,EAAE,CAAC;QACxC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAA;IACjD,CAAC;IAED,mEAAmE;IACnE,oEAAoE;IACpE,6DAA6D;IAC7D,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAA;IACvC,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAA;IAC9F,MAAM,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAA;IACxG,OAAO;QACL,KAAK,EAAE,IAAI,UAAU,CAAC,GAAG,CAAC;QAC1B,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,YAAY;KAC5C,CAAA;AACH,CAAC"}

package/dist/alt/adapter.d.ts

@@ -0,0 +1,140 @@
+/**
+ * `AltTextAdapter` — provider-substitutable interface for generating
+ * alt text from image bytes.
+ *
+ * Three concrete implementations ship in v1.5: `anthropicAltAdapter`,
+ * `openAIAltAdapter`, `ollamaAltAdapter` (commits 3-5). One safe
+ * default also ships: `nullAltAdapter` (this commit), used when no
+ * adapter is configured for the target.
+ *
+ * # SOLID lenses
+ *
+ *   - SRP: this module owns the alt-text task contracts (request,
+ *     suggestion, adapter interface). Nothing else lives here.
+ *   - OCP: new providers implement the interface and slot into the
+ *     factory (commit 6). No existing module changes.
+ *   - LSP: every adapter — including `nullAltAdapter` — honors the
+ *     same contract. Substitutable in tests.
+ *   - ISP: adapter exposes only `name`, `supports`, `generate` — no
+ *     UI concerns, no config concerns.
+ *   - DIP: callers depend on this interface, not on Anthropic SDK,
+ *     OpenAI SDK, or Ollama HTTP details.
+ *
+ * # Why `AltSuggestion` carries refused state
+ *
+ * Vision providers can return a 200 OK with refusal text in the
+ * content field (e.g., "I can't describe this image"). The structural
+ * cut: refusal is a *successful API call with a domain-level no*.
+ * Treating refusal as a structured field — not as inspecting `text`
+ * for substrings in every consumer — keeps DIP. UI consumers branch
+ * on `refused`, not on text patterns.
+ *
+ * Considered and rejected: a `confidence: number | null` field.
+ * Vision providers don't expose calibrated confidence for free-form
+ * description tasks; a hardcoded null would be a stub-on-the-interface
+ * (LSP violation, per [team-preferences rule 18]). If a future
+ * provider exposes real calibrated confidence, it lands as a separate
+ * field — not as a retrofit of a placeholder.
+ */
+import type { PromptPolicy } from '../ai/compose-prompt.js';
+/**
+ * What the caller wants. Provider-agnostic. Each field has a documented
+ * default applied by the factory when callers don't specify.
+ */
+export interface AltRequest {
+    /**
+     * Target language for the description (BCP 47 locale code; 'en',
+     * 'fr', 'pt-BR'). The model writes alt directly in this language —
+     * no separate translation pass. Default 'en'.
+     */
+    locale: string;
+    /**
+     * Soft length suggestion in characters. Used in prompt guidance
+     * ("Maximum N characters") and as native `max_tokens` derivation
+     * for adapters that have it. Default 125 (WAI-ARIA convention).
+     *
+     * NOT enforced by the suggester or adapter — if the model returns
+     * longer text, the consumer sees the full string and can edit. Hard
+     * truncation would lose meaning.
+     */
+    maxChars: number;
+    /**
+     * Output style. Closed enum; extended additively (future:
+     * `'marketing' | 'technical'`).
+     */
+    style: AltStyle;
+}
+/** Closed enum; extends additively. */
+export type AltStyle = 'descriptive';
+/** Default `AltRequest` values, applied by the suggester when callers omit fields. */
+export declare const DEFAULT_ALT_REQUEST: AltRequest;
+/**
+ * What the suggester delivers. `text` is the model's output (which may
+ * be a refusal). `refused` is the structured signal: when true, don't
+ * auto-fill, surface `refusalReason` to the author instead.
+ */
+export interface AltSuggestion {
+    text: string;
+    /** True when the model declined or couldn't describe the image. */
+    refused: boolean;
+    /** Truncated reason text when refused; null otherwise. */
+    refusalReason: string | null;
+}
+/**
+ * Input to an adapter's `generate` call. The suggester does prep:
+ *
+ *   - Resolves `AltRequest` from caller-provided fields + defaults
+ *   - Composes the prompt via `composePrompt(request, policies)`
+ *   - Calls `prepareForVision` on the bytes
+ *
+ * The adapter receives both the structured request (for native params
+ * like Anthropic's `max_tokens`) and the composed prompt string (for
+ * adapters that just inject text). Pre-computed once per call.
+ */
+export interface AltGenerateInput {
+    /** Bytes ready to send to the provider (post-prep, ≤ maxImageEdge). */
+    bytes: Uint8Array;
+    /** MIME of the prepared bytes — `image/jpeg` or `image/png`. */
+    mime: string;
+    /** Structured request — adapters with native parameters use this. */
+    request: AltRequest;
+    /** Composed prompt string — adapters that just need a prompt use this. */
+    prompt: string;
+}
+/**
+ * Per-task adapter contract. Every implementation honors this exactly;
+ * substitutable across tests and production via the factory.
+ *
+ * Throws on transport / provider errors (`AIAdapterFailedError` from
+ * `ai/errors.ts`). Refusals are NOT thrown — they're returned in the
+ * structured `AltSuggestion`. The distinction: throws are runtime
+ * failures (retryable; gateway-level concern); refusals are domain
+ * outcomes (not retryable; user-level concern).
+ */
+export interface AltTextAdapter {
+    /** Stable identifier for diagnostics ('anthropic', 'openai', 'ollama', 'null'). */
+    readonly name: string;
+    /**
+     * True when this adapter can describe the given MIME. v1.5 adapters
+     * support image MIMEs only. The null adapter returns false for
+     * everything.
+     */
+    supports(mime: string): boolean;
+    /**
+     * Generate alt text. Forwards `signal` to the underlying provider
+     * call so consumers can cancel in-flight requests (e.g., when the
+     * author starts typing into the alt field).
+     *
+     * Throws `AIAdapterFailedError` / `AIInvalidResponseError` on
+     * transport or response-shape failures. Returns refusals as
+     * `AltSuggestion` with `refused: true`.
+     */
+    generate(input: AltGenerateInput, signal?: AbortSignal): Promise<AltSuggestion>;
+}
+/**
+ * Type alias for prompt policies operating on alt-text requests.
+ * Per-task policy modules implement these and pass arrays to the
+ * generic `composePrompt<AltRequest>(req, policies)`.
+ */
+export type AltPromptPolicy = PromptPolicy<AltRequest>;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/alt/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/alt/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE3D;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;;;OAQG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,KAAK,EAAE,QAAQ,CAAA;CAChB;AAED,uCAAuC;AACvC,MAAM,MAAM,QAAQ,GAAG,aAAa,CAAA;AAEpC,sFAAsF;AACtF,eAAO,MAAM,mBAAmB,EAAE,UAIjC,CAAA;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,OAAO,EAAE,OAAO,CAAA;IAChB,0DAA0D;IAC1D,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uEAAuE;IACvE,KAAK,EAAE,UAAU,CAAA;IACjB,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAA;IACZ,qEAAqE;IACrE,OAAO,EAAE,UAAU,CAAA;IACnB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;IAE/B;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;CAChF;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,UAAU,CAAC,CAAA"}

package/dist/alt/adapter.js

@@ -0,0 +1,7 @@
+/** Default `AltRequest` values, applied by the suggester when callers omit fields. */
+export const DEFAULT_ALT_REQUEST = {
+    locale: 'en',
+    maxChars: 125,
+    style: 'descriptive',
+};
+//# sourceMappingURL=adapter.js.map

package/dist/alt/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/alt/adapter.ts"],"names":[],"mappings":"AAuEA,sFAAsF;AACtF,MAAM,CAAC,MAAM,mBAAmB,GAAe;IAC7C,MAAM,EAAE,IAAI;IACZ,QAAQ,EAAE,GAAG;IACb,KAAK,EAAE,aAAa;CACrB,CAAA"}

package/dist/alt/anthropic.d.ts

@@ -0,0 +1,63 @@
+import type { AIProvider } from '../ai/provider.js';
+import type { AltTextAdapter } from './adapter.js';
+/**
+ * Default model for the Anthropic adapter. Haiku is the cost-optimized
+ * choice for the alt-text task (~$0.003/image at 768x768 input). Sites
+ * needing higher quality set `altText.model` in `site.config.ts` to a
+ * Sonnet or Opus model.
+ */
+export declare const ANTHROPIC_DEFAULT_MODEL = "claude-haiku-4-5";
+/**
+ * Anthropic transport-only options. Per Path X (single-axis with
+ * transport-vs-task split for AI), these fields bind to "which Anthropic
+ * account at which endpoint" — not to per-task tuning. Per-task config
+ * (model, systemPrompt, maxTokens) lives on the resolver-supplied
+ * `AltTextTaskConfig`, not here.
+ */
+export interface AnthropicTransportOptions {
+    apiKey: string;
+    /**
+     * Optional override of the SDK base URL — handy for tests pointing
+     * at msw, or future operators routing through a private proxy.
+     */
+    baseURL?: string;
+    /**
+     * Override the SDK's retry count (default 2). Tests pass 0 to keep
+     * runs deterministic and fast; production sticks with the default
+     * so transient 429/5xx are auto-retried with backoff.
+     */
+    maxRetries?: number;
+}
+/**
+ * Internal type for `createAnthropicAltAdapter` callers (tests).
+ * Combines transport with per-task config so existing tests don't have
+ * to thread two arguments. New code goes through the operator-facing
+ * `anthropicProvider(transport).altText(taskConfig)` chain.
+ */
+export interface AnthropicAltAdapterOptions extends AnthropicTransportOptions {
+    /** Model ID; defaults to {@link ANTHROPIC_DEFAULT_MODEL} when absent. */
+    model?: string;
+    /** Operator-supplied system prompt; prepended to system-composed prompt. */
+    systemPrompt?: string;
+    /** Generation token cap; provider derives from maxChars when absent. */
+    maxTokens?: number;
+}
+/**
+ * Construct the Anthropic alt-text adapter. Internal factory — kept
+ * public for tests + advanced wiring. Operator-facing config goes
+ * through `anthropicProvider(transport).altText(taskConfig)` (Path X).
+ */
+export declare function createAnthropicAltAdapter(opts: AnthropicAltAdapterOptions): AltTextAdapter;
+/**
+ * Operator-facing Anthropic provider. Constructs the transport-only
+ * `AIProvider` used in `site.config.ts`:
+ *
+ *   const anthropic = anthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY! })
+ *   ai: { provider: anthropic, model: 'claude-haiku-4-5' }
+ *
+ * The provider exposes per-task builders (`.altText({...})`); the
+ * resolver supplies the merged `AltTextTaskConfig` from the three-rung
+ * inheritance chain at boot.
+ */
+export declare function anthropicProvider(transport: AnthropicTransportOptions): AIProvider;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/alt/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../src/alt/anthropic.ts"],"names":[],"mappings":"AAyCA,OAAO,KAAK,EAAE,UAAU,EAAqB,MAAM,mBAAmB,CAAA;AAEtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AASlD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,qBAAqB,CAAA;AAUzD;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,0BAA2B,SAAQ,yBAAyB;IAC3E,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAOD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,0BAA0B,GAAG,cAAc,CAoD1F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,yBAAyB,GAAG,UAAU,CAelF"}

package/dist/alt/anthropic.js

@@ -0,0 +1,147 @@
+/**
+ * Anthropic Claude adapter — alt-text via the `messages.create` vision API.
+ *
+ * # Defaults
+ *
+ *   - Model: `claude-haiku-4-5` (cost-effective vision; ~$0.003/image).
+ *     Sites needing higher quality override via `altText.model` in `site.config.ts`.
+ *
+ * # API contract details (verified against @anthropic-ai/sdk v0.92.0)
+ *
+ *   - Image content: `{ type: 'image', source: { type: 'base64',
+ *     media_type, data: <base64-string> } }`. SDK requires base64-encoded
+ *     string, not raw bytes/Uint8Array.
+ *   - Accepted MIME types: `image/jpeg`, `image/png`, `image/gif`,
+ *     `image/webp`. After `prepareForVision`, our bytes are always JPEG
+ *     or PNG, both supported.
+ *   - `max_tokens` is required by the API. Scaffold derives it from
+ *     `request.maxChars` unless operator overrides via `maxTokens`.
+ *   - `system` parameter at the top level (not a message role). The
+ *     scaffold-prepared `systemPrompt` (operator override + composed)
+ *     becomes the system prompt; the user message holds the image.
+ *
+ * # AbortSignal
+ *
+ *   - Passed via `messages.create(body, { signal })`. SDK throws
+ *     `APIUserAbortError` on abort; scaffold's `isAbortError` recognizes
+ *     it so the suggester can return null on cancellation.
+ *
+ * # SOLID
+ *
+ *   - SRP: this module owns the Anthropic-specific request shape and
+ *     response parsing only. Orchestration (prompt-prepend, max-tokens
+ *     derivation, error translation, refusal detection) lives in
+ *     `ai/adapter-scaffold.ts`.
+ *   - LSP: implements `AltTextAdapter` exactly via the scaffold —
+ *     substitutable.
+ *   - DIP: callers depend on `AltTextAdapter`; never on `Anthropic` SDK
+ *     type directly.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { AIInvalidResponseError } from '../ai/errors.js';
+import { buildAltAdapterFromScaffold } from '../ai/adapter-scaffold.js';
+/**
+ * Anthropic-specific refusal phrases observed in production responses
+ * but not yet in `ai/refusal.ts`'s shared list. Maintained here so
+ * provider-specific markers evolve independently of the shared list.
+ */
+const ANTHROPIC_REFUSAL_MARKERS = ['i cannot create captions', 'i cannot generate descriptions'];
+/**
+ * Default model for the Anthropic adapter. Haiku is the cost-optimized
+ * choice for the alt-text task (~$0.003/image at 768x768 input). Sites
+ * needing higher quality set `altText.model` in `site.config.ts` to a
+ * Sonnet or Opus model.
+ */
+export const ANTHROPIC_DEFAULT_MODEL = 'claude-haiku-4-5';
+/**
+ * Anthropic only accepts a subset of image MIME types. After
+ * `prepareForVision` our bytes are JPEG or PNG, but defending here
+ * means a future caller invoking the adapter directly with WebP or
+ * GIF still gets the right answer.
+ */
+const ANTHROPIC_SUPPORTED_MIMES = new Set(['image/jpeg', 'image/png', 'image/gif', 'image/webp']);
+/** Encode a Uint8Array as a base64 string for the API call. */
+function toBase64(bytes) {
+    return Buffer.from(bytes).toString('base64');
+}
+/**
+ * Construct the Anthropic alt-text adapter. Internal factory — kept
+ * public for tests + advanced wiring. Operator-facing config goes
+ * through `anthropicProvider(transport).altText(taskConfig)` (Path X).
+ */
+export function createAnthropicAltAdapter(opts) {
+    const client = new Anthropic({
+        apiKey: opts.apiKey,
+        baseURL: opts.baseURL,
+        maxRetries: opts.maxRetries,
+    });
+    const model = opts.model ?? ANTHROPIC_DEFAULT_MODEL;
+    return buildAltAdapterFromScaffold({
+        name: 'anthropic',
+        supportedMimes: ANTHROPIC_SUPPORTED_MIMES,
+        operatorSystemPrompt: opts.systemPrompt,
+        operatorMaxTokens: opts.maxTokens,
+        refusalMarkers: ANTHROPIC_REFUSAL_MARKERS,
+        isAbortError: err => err instanceof Anthropic.APIUserAbortError,
+        async callProvider({ bytes, mime, systemPrompt, maxTokens, signal }) {
+            const response = await client.messages.create({
+                model,
+                max_tokens: maxTokens,
+                system: systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'image',
+                                source: {
+                                    type: 'base64',
+                                    // SDK accepts the four MIMEs above; cast is safe
+                                    // because supports() guards entry.
+                                    media_type: mime,
+                                    data: toBase64(bytes),
+                                },
+                            },
+                        ],
+                    },
+                ],
+            }, { signal });
+            // Response shape: `content` is an array of blocks; alt-text comes
+            // back as a single text block. Defensive against tool-use blocks
+            // or unexpected shapes by finding the first text block.
+            const textBlock = response.content.find(block => block.type === 'text');
+            if (!textBlock || textBlock.type !== 'text') {
+                throw new AIInvalidResponseError('Anthropic response contained no text content block');
+            }
+            return textBlock.text;
+        },
+    });
+}
+/**
+ * Operator-facing Anthropic provider. Constructs the transport-only
+ * `AIProvider` used in `site.config.ts`:
+ *
+ *   const anthropic = anthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY! })
+ *   ai: { provider: anthropic, model: 'claude-haiku-4-5' }
+ *
+ * The provider exposes per-task builders (`.altText({...})`); the
+ * resolver supplies the merged `AltTextTaskConfig` from the three-rung
+ * inheritance chain at boot.
+ */
+export function anthropicProvider(transport) {
+    if (!transport.apiKey) {
+        throw new Error('anthropicProvider: "apiKey" is required (typically `process.env.ANTHROPIC_API_KEY!`)');
+    }
+    return {
+        name: 'anthropic',
+        altText(taskConfig) {
+            return createAnthropicAltAdapter({
+                ...transport,
+                model: taskConfig.model,
+                systemPrompt: taskConfig.systemPrompt,
+                maxTokens: taskConfig.maxTokens,
+            });
+        },
+    };
+}
+//# sourceMappingURL=anthropic.js.map

package/dist/alt/anthropic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.js","sourceRoot":"","sources":["../../src/alt/anthropic.ts"],"names":[],"mappings":"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"}

package/dist/alt/config.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Alt-text config resolver — composes gazetta-level + site-level + per-target
+ * config into a single `ResolvedAltConfig` per [`design-ai.md`](../../../.claude/rules/design-ai.md)
+ * "Three-rung inheritance" + Path X Exception A.
+ *
+ * Three-rung chain (target → site → gazetta), per field:
+ *
+ *   - `provider` (transport):  target.altText.ai.provider ?? site.ai.provider ?? gazetta.ai.provider
+ *   - `model`:                  target.altText.ai.model    ?? site.ai.model    ?? gazetta.ai.model
+ *                                ?? PROVIDER_DEFAULT_MODELS[provider.name]
+ *   - `systemPrompt`:           target.altText.ai.systemPrompt ?? site.altText.systemPrompt
+ *                                ?? gazetta.altText.systemPrompt ?? null
+ *   - `maxTokens`:              target.altText.ai.maxTokens    ?? site.altText.maxTokens
+ *                                ?? gazetta.altText.maxTokens   ?? undefined
+ *   - `auto` (behavior):        target.altText.auto    ?? site.altText.auto    ?? gazetta.altText.auto
+ *                                ?? DEFAULT_AUTO
+ *   - `maxImageEdge` (behavior): target.altText.maxImageEdge ?? site.altText.maxImageEdge
+ *                                ?? gazetta.altText.maxImageEdge ?? MAX_EDGE
+ *
+ * Behavior fields (`auto`, `maxImageEdge`) live at the root of `altText:`
+ * (Exception B); AI fields (provider, model, systemPrompt, maxTokens)
+ * live under `altText.ai` at target level (Exception A's third rung).
+ *
+ * Pure function — no I/O, no env reads, no SDK construction. The factory
+ * in `alt/factory.ts` consumes the resolved config + calls
+ * `provider.altText({...})` to build the adapter.
+ *
+ * # SOLID
+ *
+ *   - SRP: this module owns "merge config layers into one resolved value."
+ *     Doesn't read env, doesn't construct adapters.
+ *   - DIP: factory depends on this resolved shape, never on raw
+ *     `SiteManifest`/`TargetConfig`.
+ *   - LSP: resolver is total — every input shape produces either a
+ *     `ResolvedAltConfig` or `null`.
+ */
+import type { AIProvider } from '../ai/provider.js';
+import type { GazettaManifest, SiteManifest, TargetConfig } from '../types.js';
+/**
+ * Fully-resolved alt-text config — what the factory needs to construct
+ * an adapter and what the suggester needs to invoke it. No optional
+ * fields after this point; defaults applied (except `systemPrompt` and
+ * `maxTokens` which are legitimately absent when no operator override
+ * is configured anywhere in the chain).
+ */
+export interface ResolvedAltConfig {
+    provider: AIProvider;
+    /** Concrete model ID. Either explicitly configured or per-provider default. */
+    model: string;
+    /** Operator-supplied system prompt; null = use system default only. */
+    systemPrompt: string | null;
+    /** Generation token cap; undefined = provider default. */
+    maxTokens: number | undefined;
+    /** Whether upload flows auto-fire suggest after upload. */
+    auto: boolean;
+    /** Long-edge cap for vision-call image bytes. */
+    maxImageEdge: number;
+}
+/**
+ * Resolve alt-text config from gazetta + site + target. Returns null
+ * when no provider is configured at any layer.
+ *
+ * `gazetta` is optional — sites without a project-level `gazetta.config.ts`
+ * pass `undefined` (or omit the argument).
+ */
+export declare function resolveAltConfig(site: Pick<SiteManifest, 'ai' | 'altText'>, target: Pick<TargetConfig, 'altText'> | undefined, gazetta?: Pick<GazettaManifest, 'ai' | 'altText'>): ResolvedAltConfig | null;
+//# sourceMappingURL=config.d.ts.map

package/dist/alt/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/alt/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAGnD,OAAO,KAAK,EAA0C,eAAe,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAKtH;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,UAAU,CAAA;IACpB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,CAAA;IACb,uEAAuE;IACvE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,0DAA0D;IAC1D,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,2DAA2D;IAC3D,IAAI,EAAE,OAAO,CAAA;IACb,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,SAAS,CAAC,EAC1C,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,GAAG,SAAS,EACjD,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,SAAS,CAAC,GAChD,iBAAiB,GAAG,IAAI,CAkC1B"}

package/dist/alt/config.js

@@ -0,0 +1,41 @@
+import { PROVIDER_DEFAULT_MODELS } from '../ai/provider.js';
+import { MAX_EDGE } from '../ai/vision-prep.js';
+/** Hardcoded default for the `auto` flag. */
+const DEFAULT_AUTO = true;
+/**
+ * Resolve alt-text config from gazetta + site + target. Returns null
+ * when no provider is configured at any layer.
+ *
+ * `gazetta` is optional — sites without a project-level `gazetta.config.ts`
+ * pass `undefined` (or omit the argument).
+ */
+export function resolveAltConfig(site, target, gazetta) {
+    const siteAi = site.ai;
+    const siteAlt = site.altText;
+    const targetAlt = target?.altText;
+    const gazettaAi = gazetta?.ai;
+    const gazettaAlt = gazetta?.altText;
+    // Provider: target → site → gazetta. If nothing configured anywhere,
+    // the feature is off.
+    const provider = targetAlt?.ai?.provider ?? siteAi?.provider ?? gazettaAi?.provider;
+    if (!provider)
+        return null;
+    // Model: target → site → gazetta → per-provider default.
+    const model = targetAlt?.ai?.model ?? siteAi?.model ?? gazettaAi?.model ?? PROVIDER_DEFAULT_MODELS[provider.name] ?? null;
+    if (model === null) {
+        // Plugin-supplied provider with no default-model registration AND
+        // no operator-supplied model anywhere in the chain. Surface as
+        // "feature off" rather than constructing an adapter that will fail
+        // at first SDK call.
+        return null;
+    }
+    // systemPrompt: target → site → gazetta → null (use system default).
+    const systemPrompt = targetAlt?.ai?.systemPrompt ?? siteAlt?.systemPrompt ?? gazettaAlt?.systemPrompt ?? null;
+    // maxTokens: target → site → gazetta → undefined (provider derives from maxChars).
+    const maxTokens = targetAlt?.ai?.maxTokens ?? siteAlt?.maxTokens ?? gazettaAlt?.maxTokens;
+    // Behavior fields (auto, maxImageEdge): target → site → gazetta → hardcoded defaults.
+    const auto = targetAlt?.auto ?? siteAlt?.auto ?? gazettaAlt?.auto ?? DEFAULT_AUTO;
+    const maxImageEdge = targetAlt?.maxImageEdge ?? siteAlt?.maxImageEdge ?? gazettaAlt?.maxImageEdge ?? MAX_EDGE;
+    return { provider, model, systemPrompt, maxTokens, auto, maxImageEdge };
+}
+//# sourceMappingURL=config.js.map

package/dist/alt/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/alt/config.ts"],"names":[],"mappings":"AAqCA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAG/C,6CAA6C;AAC7C,MAAM,YAAY,GAAG,IAAI,CAAA;AAuBzB;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAA0C,EAC1C,MAAiD,EACjD,OAAiD;IAEjD,MAAM,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;IACtB,MAAM,OAAO,GAAkC,IAAI,CAAC,OAAO,CAAA;IAC3D,MAAM,SAAS,GAAoC,MAAM,EAAE,OAAO,CAAA;IAClE,MAAM,SAAS,GAAG,OAAO,EAAE,EAAE,CAAA;IAC7B,MAAM,UAAU,GAAG,OAAO,EAAE,OAAO,CAAA;IAEnC,qEAAqE;IACrE,sBAAsB;IACtB,MAAM,QAAQ,GAAG,SAAS,EAAE,EAAE,EAAE,QAAQ,IAAI,MAAM,EAAE,QAAQ,IAAI,SAAS,EAAE,QAAQ,CAAA;IACnF,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAA;IAE1B,yDAAyD;IACzD,MAAM,KAAK,GACT,SAAS,EAAE,EAAE,EAAE,KAAK,IAAI,MAAM,EAAE,KAAK,IAAI,SAAS,EAAE,KAAK,IAAI,uBAAuB,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,CAAA;IAC7G,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,kEAAkE;QAClE,+DAA+D;QAC/D,mEAAmE;QACnE,qBAAqB;QACrB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,qEAAqE;IACrE,MAAM,YAAY,GAAG,SAAS,EAAE,EAAE,EAAE,YAAY,IAAI,OAAO,EAAE,YAAY,IAAI,UAAU,EAAE,YAAY,IAAI,IAAI,CAAA;IAE7G,mFAAmF;IACnF,MAAM,SAAS,GAAG,SAAS,EAAE,EAAE,EAAE,SAAS,IAAI,OAAO,EAAE,SAAS,IAAI,UAAU,EAAE,SAAS,CAAA;IAEzF,sFAAsF;IACtF,MAAM,IAAI,GAAG,SAAS,EAAE,IAAI,IAAI,OAAO,EAAE,IAAI,IAAI,UAAU,EAAE,IAAI,IAAI,YAAY,CAAA;IACjF,MAAM,YAAY,GAAG,SAAS,EAAE,YAAY,IAAI,OAAO,EAAE,YAAY,IAAI,UAAU,EAAE,YAAY,IAAI,QAAQ,CAAA;IAE7G,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,CAAA;AACzE,CAAC"}

package/dist/alt/factory.d.ts

@@ -0,0 +1,19 @@
+import type { AltTextAdapter } from './adapter.js';
+import type { GazettaManifest, SiteManifest, TargetConfig } from '../types.js';
+/**
+ * True when the resolved alt-text config has all required pieces.
+ * Pure: returns the structural state — does NOT verify the credential
+ * works (no network call). Verification surfaces at first use of the route.
+ */
+export declare function isAltAdapterConfigured(site: Pick<SiteManifest, 'ai' | 'altText'>, target: Pick<TargetConfig, 'altText'> | undefined, gazetta?: Pick<GazettaManifest, 'ai' | 'altText'>): boolean;
+/**
+ * Construct the alt-text adapter for the resolved config. Returns the
+ * null adapter when no provider is configured at any layer.
+ *
+ * Always returns an `AltTextAdapter` — consumers never null-check the
+ * factory's return value. The null adapter throws if `generate()` is
+ * called, but that only happens if a consumer skips the
+ * `supports()` / `available()` capability check.
+ */
+export declare function buildAltAdapter(site: Pick<SiteManifest, 'ai' | 'altText'>, target: Pick<TargetConfig, 'altText'> | undefined, gazetta?: Pick<GazettaManifest, 'ai' | 'altText'>): AltTextAdapter;
+//# sourceMappingURL=factory.d.ts.map

package/dist/alt/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/alt/factory.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE9E;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,SAAS,CAAC,EAC1C,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,GAAG,SAAS,EACjD,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,SAAS,CAAC,GAChD,OAAO,CAET;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,SAAS,CAAC,EAC1C,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,GAAG,SAAS,EACjD,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,SAAS,CAAC,GAChD,cAAc,CAahB"}