@almadar/ui 5.111.0 → 5.113.0

package/dist/hooks/useUnitSpriteAtlas.d.ts

@@ -1,24 +0,0 @@
-import type { IsometricUnit } from '../lib/isometricTypes';
-import type { ResolvedFrame } from '../lib/spriteAnimationTypes';
-/**
- * Resolve the sprite-sheet atlas-JSON URL for a unit.
- *
- * A unit has an atlas iff `unit.spriteSheet.url` is set (explicit metadata wins).
- * No filename-pattern matching — a unit without a `spriteSheet` Asset keeps its static draw.
- */
-export declare function unitAtlasUrl(unit: Pick<IsometricUnit, 'spriteSheet'>): string | null;
-export interface UseUnitSpriteAtlasResult {
-    /** Atlas-JSON URLs successfully loaded — feed these to no one; sheet PNGs are returned below. */
-    sheetUrls: string[];
-    /** Resolve the current single-frame rect for a unit, or null if its atlas isn't loaded. */
-    resolveUnitFrame: (unitId: string) => ResolvedFrame | null;
-    /** Whether any atlas is still loading (drives isLoading / keeps RAF alive). */
-    pendingCount: number;
-}
-/**
- * Load per-unit sprite atlases and expose a pure frame resolver.
- * Frame is computed from each unit's own `animation` + `frame` props — no internal clock.
- *
- * @param units - Units whose atlases should be loaded.
- */
-export declare function useUnitSpriteAtlas(units: IsometricUnit[]): UseUnitSpriteAtlasResult;

package/dist/hooks/useValidation.d.ts

@@ -1,46 +0,0 @@
-export interface LLMErrorContext {
-    rawValuePreview?: string;
-    expectedType?: string;
-    actualType?: string;
-    source?: {
-        agent: 'requirements' | 'builder' | 'view-planner';
-        operation: string;
-        promptHash?: string;
-    };
-    tokenUsage?: {
-        prompt: number;
-        completion: number;
-    };
-}
-export interface ValidationError {
-    code: string;
-    message: string;
-    path?: string;
-    severity: 'error' | 'warning';
-    suggestion?: string;
-    validValues?: string[];
-    expectedShape?: string;
-    fixGuidance?: string;
-    llmContext?: LLMErrorContext;
-}
-export interface ValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-    warnings: ValidationError[];
-}
-export type ValidationStage = 'idle' | 'validating' | 'fixing' | 'complete';
-export interface UseValidationResult {
-    result: ValidationResult | null;
-    isValidating: boolean;
-    error: string | null;
-    stage: ValidationStage;
-    isFixing: boolean;
-    progressMessage: string | null;
-    errors: ValidationError[];
-    warnings: ValidationError[];
-    isValid: boolean;
-    validate: (appId: string) => Promise<ValidationResult>;
-    clearResult: () => void;
-    reset: () => void;
-}
-export declare function useValidation(): UseValidationResult;

package/dist/lib/api-client.d.ts

@@ -1,43 +0,0 @@
-/**
- * API Client - HTTP client for backend API calls
- *
- * Provides typed methods for making API requests.
- * All requests go through the backend server, NOT directly to Firestore.
- *
- * @packageDocumentation
- */
-import type { FieldValue } from '@almadar/core';
-/**
- * API Error class for handling HTTP errors
- */
-export declare class ApiError extends Error {
-    status: number;
-    statusText: string;
-    constructor(status: number, statusText: string, message?: string);
-}
-/**
- * API client with typed methods
- */
-export declare const apiClient: {
-    /**
-     * GET request
-     */
-    get<T>(endpoint: string): Promise<T>;
-    /**
-     * POST request
-     */
-    post<T>(endpoint: string, data?: Record<string, FieldValue>): Promise<T>;
-    /**
-     * PUT request
-     */
-    put<T>(endpoint: string, data?: Record<string, FieldValue>): Promise<T>;
-    /**
-     * PATCH request
-     */
-    patch<T>(endpoint: string, data?: Record<string, FieldValue>): Promise<T>;
-    /**
-     * DELETE request
-     */
-    delete<T = void>(endpoint: string): Promise<T>;
-};
-export default apiClient;

package/dist/lib/atlasSlice.d.ts

@@ -1,58 +0,0 @@
-/**
- * atlasSlice — the ONLY place a packed sheet is cut at runtime.
- *
- * An `Asset` may carry `{ url: <sheet.png>, atlas: <atlas.json>, sprite: <name|index> }`. This
- * module fetches + caches the atlas JSON (a `TextureAtlas` of named sub-rects or a uniform
- * `Tilesheet`) and resolves the source rectangle for a `sprite`, so the canvas can `drawImage`
- * exactly that sub-region of the sheet. Coexists with the whole-PNG path (an Asset with no
- * `atlas`/`sprite` draws the whole image) and the `useUnitSpriteAtlas` animation path.
- *
- * See `docs/Almadar_Std_Assets.md` §2, §7.
- *
- * @packageDocumentation
- */
-import type { TextureAtlas, Tilesheet } from '@almadar/core';
-/** The minimal draw-relevant projection of an `Asset` — a sheet URL plus an optional atlas
- *  sub-texture reference. A full `@almadar/core` `Asset` is structurally assignable. */
-export interface SpriteRef {
-    url?: string;
-    atlas?: string;
-    sprite?: string;
-}
-type ParsedAtlas = TextureAtlas | Tilesheet;
-/**
- * Get a parsed atlas by URL, fetching+caching on first request. Returns undefined until loaded;
- * `onReady` fires once when the fetch resolves so the caller can trigger a re-render.
- */
-export declare function getAtlas(url: string, onReady: () => void): ParsedAtlas | undefined;
-export interface SubRect {
-    sx: number;
-    sy: number;
-    sw: number;
-    sh: number;
-}
-/**
- * Resolve the source rect for `sprite` in `atlas`.
- * - `TextureAtlas`: `sprite` is a SubTexture name (e.g. `"blockBrown.png"`).
- * - `Tilesheet`: `sprite` is `"col,row"` or a flat index into the row-major grid.
- * Returns null if the name/index doesn't resolve.
- */
-export declare function subRectFor(atlas: ParsedAtlas, sprite: string): SubRect | null;
-/** True when the asset points into a sheet (needs slicing) rather than being a whole PNG. */
-export declare function isAtlasAsset(asset: SpriteRef | undefined | null): boolean;
-export interface AssetSource {
-    img: HTMLImageElement;
-    /** Sub-rect to blit; null = draw the whole image. */
-    rect: SubRect | null;
-    /** Source aspect ratio (width/height) — sub-rect for a slice, natural otherwise. */
-    aspect: number;
-}
-/**
- * Resolve what to draw for `asset` given its loaded sheet `img`. Returns null when the asset is
- * an atlas ref whose JSON isn't loaded yet (or whose sprite name doesn't resolve) — `onReady`
- * will trigger a re-render once the fetch lands. Callers use `.aspect` to size, then `blit`.
- */
-export declare function resolveAssetSource(img: HTMLImageElement, asset: SpriteRef | undefined | null, onReady: () => void): AssetSource | null;
-/** Draw a resolved source at `(dx,dy,dw,dh)` — sliced sub-rect or whole image. */
-export declare function blit(ctx: CanvasRenderingContext2D, src: AssetSource, dx: number, dy: number, dw: number, dh: number): void;
-export {};

package/dist/lib/boardEntity.d.ts

@@ -1,44 +0,0 @@
-/**
- * boardEntity — tiny coercion helpers for reading `EntityRow` data inside game
- * boards.
- *
- * The single entity type is `@almadar/core`'s `EntityRow`
- * (`{ id?: string } & Record<string, FieldValue | undefined>`). Boards read
- * deeply-nested, weakly-typed fields off it; these helpers narrow scalars,
- * arrays, and small positional objects without reintroducing private entity
- * interfaces. None of these are entity types — they are pure value coercers.
- *
- * @packageDocumentation
- */
-import type { EntityRow, FieldValue } from '@almadar/core';
-/** A 2D grid position read off an entity row. */
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-/** Lightweight trait-display shape carried on unit-like rows (UI value DTO). */
-export interface TeamUnitTraits {
-    name: string;
-    currentState: string;
-    states: string[];
-    cooldown?: number;
-}
-/** Resolve the single board-state entity row from a prop that may be a row,
- *  an array of rows, or undefined. Boards operate on one board state. */
-export declare function boardEntity(entity: EntityRow | readonly EntityRow[] | undefined): EntityRow | undefined;
-/** Coerce a field value to a string (empty string when absent). */
-export declare function str(v: FieldValue | undefined): string;
-/** Coerce a field value to a number (0 when absent / non-numeric). */
-export declare function num(v: FieldValue | undefined, fallback?: number): number;
-/** Coerce a field value to a boolean. */
-export declare function bool(v: FieldValue | undefined): boolean;
-/** Coerce a nested array field to a readonly array of entity rows. */
-export declare function rows(v: FieldValue | undefined): readonly EntityRow[];
-/** Read an `{ x, y }` position off an entity row's named field. */
-export declare function vec2(v: FieldValue | undefined): Vec2;
-/** Read a unit row's `position` as a `Vec2`. */
-export declare function unitPosition(u: EntityRow): Vec2;
-/** Read a unit row's `team` ('player' | 'enemy' | string). */
-export declare function unitTeam(u: EntityRow): string;
-/** Read a unit row's `health`. */
-export declare function unitHealth(u: EntityRow): number;

package/dist/lib/client-effect-executor.d.ts

@@ -1,57 +0,0 @@
-/**
- * Client Effect Executor
- *
- * Executes client effects returned from the server.
- * This is the core of the dual execution model - the server processes
- * events and returns client effects, which this module executes.
- *
- * Used by both Builder preview and compiled shells.
- *
- * @packageDocumentation
- */
-import type { FieldValue } from '@almadar/core';
-import type { ClientEffect, ClientEffectExecutorConfig, PatternConfig, NotifyOptions } from '../types/renderer-types';
-/**
- * Execute an array of client effects.
- *
- * Effects are executed sequentially in order.
- * Errors in one effect don't prevent subsequent effects from executing.
- *
- * @param effects - Array of client effects to execute
- * @param config - Configuration providing implementations for each effect type
- *
- * @example
- * ```typescript
- * executeClientEffects(
- *   [
- *     ['render-ui', 'main', { type: 'entity-table', entity: 'Task' }],
- *     ['notify', 'Tasks loaded!', { type: 'success' }]
- *   ],
- *   {
- *     renderToSlot: (slot, pattern) => slotManager.render(slot, pattern),
- *     navigate: (path) => router.push(path),
- *     notify: (message, opts) => toast.show(message, opts),
- *     eventBus: { emit: (event, payload) => bus.emit(event, payload) }
- *   }
- * );
- * ```
- */
-export declare function executeClientEffects(effects: ClientEffect[], config: ClientEffectExecutorConfig): void;
-/**
- * Parse a raw effect array into a typed ClientEffect.
- * Handles unknown effect formats gracefully.
- */
-export declare function parseClientEffect(raw: FieldValue[]): ClientEffect | null;
-/**
- * Parse an array of raw effects into typed ClientEffects.
- * Filters out invalid effects.
- */
-export declare function parseClientEffects(raw: FieldValue[] | undefined): ClientEffect[];
-/**
- * Get all render-ui effects.
- */
-export declare function getRenderUIEffects(effects: ClientEffect[]): Array<['render-ui', string, PatternConfig | null]>;
-/**
- * Get all notify effects.
- */
-export declare function getNotifyEffects(effects: ClientEffect[]): Array<['notify', string, NotifyOptions?]>;

package/dist/lib/cn.d.ts

@@ -1,6 +0,0 @@
-import { type ClassValue } from 'clsx';
-/**
- * Utility function to merge Tailwind CSS classes
- * Combines clsx for conditional classes with tailwind-merge to handle conflicts
- */
-export declare function cn(...inputs: ClassValue[]): string;

package/dist/lib/createClientEffectHandlers.d.ts

@@ -1,42 +0,0 @@
-/**
- * Client Effect Handlers Factory
- *
- * Creates the standard effect handler set for client-side trait execution.
- *
- * @packageDocumentation
- */
-import type { EventPayload, EntityRow, FieldValue, ServiceParams, PatternConfig } from '@almadar/core';
-import type { EffectHandlers } from '@almadar/runtime';
-export interface ClientEventBus {
-    emit: (type: string, payload?: EventPayload) => void;
-}
-export interface SlotSetter {
-    addPattern: (slot: string, pattern: PatternConfig | null, props?: Record<string, FieldValue | undefined>) => void;
-    clearSlot: (slot: string) => void;
-}
-export interface CreateClientEffectHandlersOptions {
-    eventBus: ClientEventBus;
-    slotSetter: SlotSetter;
-    navigate?: (path: string, params?: Record<string, string>) => void;
-    notify?: (message: string, type: 'success' | 'error' | 'warning' | 'info') => void;
-    /**
-     * Live client-entity write target for `[runtime]` entities. `(set
-     * @entity.<field> value)` runs entirely in the browser for in-memory
-     * entities (game boards, wizards): there is no server row to persist to,
-     * so the canonical client `set` must mutate THIS object — the same object
-     * `EffectExecutor` reads `@entity.*` from for the current `executeAll` and
-     * the next tick seeds from. When omitted, `set` is a no-op (bridge mode:
-     * the server owns persistence). One store, read live by render-ui, guards,
-     * and ticks — no guard-vs-render split.
-     */
-    liveEntity?: EntityRow;
-    /**
-     * Optional consumer-supplied call-service handler. When set, it runs
-     * instead of the default mock fallback — use to wire the playground
-     * to real backends. When omitted, `callService` returns a synthetic
-     * mock result so service-atom chains advance end-to-end in offline /
-     * standalone-preview mode (see OrbitalServerRuntime's mock parallel).
-     */
-    callService?: (service: string, action: string, params?: ServiceParams) => Promise<EventPayload>;
-}
-export declare function createClientEffectHandlers(options: CreateClientEffectHandlersOptions): EffectHandlers;

package/dist/lib/data-resolver.d.ts

@@ -1,55 +0,0 @@
-/**
- * Data Resolver
- *
- * Resolves entity data for pattern rendering.
- * Supports multiple data sources with priority:
- * 1. Server-provided data (from EventResponse.data)
- * 2. Entity store (Builder in-memory mock data)
- * 3. Empty array (fallback)
- *
- * Used by both Builder's PatternRenderer and compiled shell's UISlotRenderer.
- *
- * @packageDocumentation
- */
-import type { EntityRow } from '@almadar/core';
-import type { DataContext, DataResolution } from '../types/renderer-types';
-/**
- * Resolve entity data from available sources.
- *
- * Priority:
- * 1. fetchedData (from server response) - highest priority
- * 2. entityStore (Builder mock data)
- * 3. Empty array (fallback)
- *
- * @param entityName - Name of the entity to resolve data for
- * @param context - Data context with available sources
- * @returns Resolved data with loading state
- *
- * @example
- * ```typescript
- * const { data, loading } = resolveEntityData('Task', {
- *   fetchedData: response.data,
- *   entityStore: mockStore
- * });
- * ```
- */
-export declare function resolveEntityData(entityName: string, context: DataContext): DataResolution;
-/**
- * Resolve entity data with query filtering.
- *
- * Applies query singleton filters if available.
- *
- * @param entityName - Name of the entity
- * @param queryRef - Optional query reference for filtering
- * @param context - Data context
- * @returns Filtered resolved data
- */
-export declare function resolveEntityDataWithQuery(entityName: string, queryRef: string | undefined, context: DataContext): DataResolution;
-/**
- * Get a single entity record by ID.
- */
-export declare function resolveEntityById(entityName: string, id: string | number, context: DataContext): EntityRow | null;
-/**
- * Check if any entities exist for a given entity name.
- */
-export declare function hasEntities(entityName: string, context: DataContext): boolean;

package/dist/lib/debug.d.ts

@@ -1,36 +0,0 @@
-/**
- * Legacy debug helpers, now routed through `@almadar/logger`.
- *
- * The variadic `debug(...args)` shape is preserved for the many existing
- * call sites (Form.tsx, RelationSelect.tsx, game helpers, etc.), but the
- * gate is no longer a separate localStorage check — every helper here
- * runs through the same priority/namespace gate the rest of the codebase
- * uses. `setLogLevel('WARN')` silences them. `globalThis.__ALMADAR_DEBUG__`
- * filters them by namespace.
- *
- * Namespace: `almadar:ui:debug` (plus per-area suffixes for input,
- * collision, physics, game-state).
- */
-export declare function isDebugEnabled(): boolean;
-/**
- * Variadic legacy debug. The first arg is the message; the rest is
- * stringified into the LogData. Routes through the shared gate.
- */
-export declare function debug(...args: unknown[]): void;
-export declare function debugGroup(label: string): void;
-export declare function debugGroupEnd(): void;
-export declare function debugWarn(...args: unknown[]): void;
-export declare function debugError(...args: unknown[]): void;
-export declare function debugTable(data: unknown): void;
-export declare function debugTime(label: string): void;
-export declare function debugTimeEnd(label: string): void;
-export declare function debugInput(inputType: string, data: unknown): void;
-export declare function debugCollision(entityA: {
-    id?: string;
-    type?: string;
-}, entityB: {
-    id?: string;
-    type?: string;
-}, details?: unknown): void;
-export declare function debugPhysics(entityId: string, physics: unknown): void;
-export declare function debugGameState(stateName: string, value: unknown): void;

package/dist/lib/debugRegistry.d.ts

@@ -1,30 +0,0 @@
-/**
- * Debug Registry - Central event log for debugging
- *
- * @packageDocumentation
- */
-import type { FieldValue } from '@almadar/core';
-export type DebugEventType = 'state-change' | 'event-fired' | 'effect-executed' | 'guard-evaluated' | 'error' | 'warning' | 'info';
-export interface DebugEvent {
-    id: string;
-    type: DebugEventType;
-    source: string;
-    message: string;
-    data?: Record<string, FieldValue>;
-    timestamp: number;
-}
-type ChangeListener = () => void;
-export declare function logDebugEvent(type: DebugEventType, source: string, message: string, data?: Record<string, FieldValue>): void;
-export declare function logStateChange(source: string, from: string, to: string, event?: string): void;
-export declare function logEventFired(source: string, eventName: string, payload?: FieldValue): void;
-export declare function logEffectExecuted(source: string, effectType: string, details?: FieldValue): void;
-export declare function logError(source: string, message: string, error?: Error | null): void;
-export declare function logWarning(source: string, message: string, data?: Record<string, FieldValue>): void;
-export declare function logInfo(source: string, message: string, data?: Record<string, FieldValue>): void;
-export declare function getDebugEvents(): DebugEvent[];
-export declare function getRecentEvents(count: number): DebugEvent[];
-export declare function getEventsByType(type: DebugEventType): DebugEvent[];
-export declare function getEventsBySource(source: string): DebugEvent[];
-export declare function subscribeToDebugEvents(listener: ChangeListener): () => void;
-export declare function clearDebugEvents(): void;
-export {};

package/dist/lib/debugUtils.d.ts

@@ -1,27 +0,0 @@
-/**
- * Debug Utilities - Functions for toggling and checking debug mode
- *
- * @packageDocumentation
- */
-type DebugToggleListener = (enabled: boolean) => void;
-/**
- * Check if debug mode is enabled
- */
-export declare function isDebugEnabled(): boolean;
-/**
- * Enable or disable debug mode
- */
-export declare function setDebugEnabled(enabled: boolean): void;
-/**
- * Toggle debug mode
- */
-export declare function toggleDebug(): boolean;
-/**
- * Subscribe to debug mode changes
- */
-export declare function onDebugToggle(listener: DebugToggleListener): () => void;
-/**
- * Initialize debug mode from keyboard shortcut (Ctrl+Shift+D)
- */
-export declare function initDebugShortcut(): () => void;
-export {};

package/dist/lib/drawable/contract.d.ts

@@ -1,68 +0,0 @@
-/**
- * Drawable contract — the shared vocabulary every neutral drawable primitive
- * (the `draw-sprite`/`draw-shape`/`draw-text` atoms, `draw-sprite-layer`/
- * `draw-shape-layer` molecules) is authored against. A drawable is a pure
- * descriptor the canvas HOST walks and paints via the portable {@link Painter2D}
- * seam — no `CanvasRenderingContext2D`, no DOM. Genre (a "unit"/"tile"/
- * "highlight") is a `.lolo` COMPOSITION of these, never its own primitive.
- *
- * A position is a core `ScenePos` (logical scene space). The host's {@link Projector}
- * maps it to pixels; primitives never do projection math themselves. Because the
- * `ScenePos` type identity is what pattern-sync stamps as the `drawable`
- * capability, every drawable descriptor's `position` MUST be a core `ScenePos`.
- */
-import type { ScenePos } from '@almadar/core';
-import type { Painter2D, PainterPoint } from '../painter2d';
-/**
- * How a drawable aligns to its projected position.
- * - `top-left` — the cell's top-left corner (tiles).
- * - `ground`   — the cell's ground point, bottom-center of the drawable (units/features).
- * - `center`   — the cell's visual center (effects).
- */
-export type DrawableAnchor = 'top-left' | 'ground' | 'center';
-/**
- * Maps logical scene coordinates to pixel space for one projection (iso/hex/flat/free).
- * Owns ALL projection geometry so the primitives stay projection-agnostic. The host
- * applies the camera transform on the painter around the walk; the projector is
- * pre-camera (logical→cell-pixel).
- */
-export interface Projector {
-    /** Cell top-left in pixels. */
-    project(pos: ScenePos): PainterPoint;
-    /** The pixel reference point for an anchor (see {@link DrawableAnchor}). */
-    anchorPoint(pos: ScenePos, anchor: DrawableAnchor): PainterPoint;
-    /** The cell footprint polygon — a rect (square grids) or a diamond (iso/hex). */
-    cellPath(pos: ScenePos): PainterPoint[];
-    /** Scaled cell width in px (`TILE_WIDTH * scale`). */
-    readonly tileWidth: number;
-    /** Scaled floor/diamond height in px (`FLOOR_HEIGHT * scale`). */
-    readonly floorHeight: number;
-    /** Scaled diamond-top offset in px (`DIAMOND_TOP_Y * scale`). */
-    readonly diamondTopY: number;
-    /** Render scale factor. */
-    readonly scale: number;
-    /** True for square-pitch grids (`flat`/`free`); false for diamond (iso/hex). */
-    readonly squareGrid: boolean;
-}
-/** Per-frame context handed to every paint fn. */
-export interface DrawContext {
-    projector: Projector;
-    /** Animation clock in ms (0 when static). Reserved for a LOLO-driven pulse/breathe input. */
-    time: number;
-    /** Force a host re-draw once an async resource (image / atlas JSON) has loaded. */
-    invalidate: () => void;
-}
-/** Common shape of every drawable descriptor. `type` keys the host's paint dispatch. */
-export interface DrawableBase {
-    type: string;
-    /**
-     * Optional hit-test handle. When a board authors a per-entity id here (e.g.
-     * `id: (object/get @u id)` on a unit sprite), the canvas host indexes the
-     * descriptor's `ScenePos → id` and resolves a pointer/raycast at that cell to
-     * this id — the source of `unitClickEvent {unitId}`. A source-tagged handle,
-     * NOT a heuristic: no id → the host emits only the coordinate (tile click).
-     */
-    id?: string;
-}
-/** A paint function: draws one descriptor of type `T` to the painter. */
-export type PaintFn<T extends DrawableBase> = (painter: Painter2D, node: T, dctx: DrawContext) => void;

package/dist/lib/drawable/hitTest.d.ts

@@ -1,23 +0,0 @@
-/**
- * Drawable click hit-test — the shared walk both canvas hosts (2D + 3D) use to
- * resolve a pointer/raycast at a scene cell to a per-entity id.
- *
- * A drawable descriptor carries an optional source-tagged `id` (see
- * {@link DrawableBase.id}); a board tags its unit sprites (`id: (@u id)`). The
- * host collects every drawn descriptor's `ScenePos` + `id`, builds a
- * `"x,y" → id` index (later descriptors win, so a unit drawn over its tile takes
- * the cell), and a click that lands on a tagged cell becomes `unitClick {unitId}`.
- * No id → the host emits only the coordinate (tile click). One owner, both hosts —
- * no per-host duplicate walker.
- */
-import type { ScenePos } from '@almadar/core';
-import type { DrawableNode } from './paintDispatch';
-/** One drawn descriptor's scene position + optional hit-test id. */
-export interface DrawnItem {
-    pos: ScenePos;
-    id?: string;
-}
-/** Collect every drawable's scene position + hit id (atoms directly; layers via `items`). */
-export declare function collectDrawnItems(nodes: DrawableNode[]): DrawnItem[];
-/** Build the `"x,y" → id` cell index from the tagged descriptors (later wins). */
-export declare function buildHitIndex(items: DrawnItem[]): Map<string, string>;

package/dist/lib/drawable/paintDispatch.d.ts

@@ -1,22 +0,0 @@
-/**
- * Drawable paint dispatch (2D) + the `DrawableNode` union.
- *
- * `paintDrawable` routes ONE descriptor to its 2D painter; the host walks its
- * `children` through it. The "drawable" designation itself is NOT recorded here —
- * it is DERIVED from the core `ScenePos` type each descriptor's `position` uses
- * and stamped into `patterns-registry.json` by pattern-sync (mirroring how `Asset`
- * is tagged), then read by the orbital-rust validator. So this module is pure
- * paint routing; the capability is the registry's, not a hand-list.
- */
-import type { Painter2D } from '../painter2d';
-import type { DrawContext } from './contract';
-import { type DrawSpriteProps } from '../../components/game/atoms/DrawSprite';
-import { type DrawShapeProps } from '../../components/game/atoms/DrawShape';
-import { type DrawTextProps } from '../../components/game/atoms/DrawText';
-import { type DrawSpriteLayerProps } from '../../components/game/molecules/DrawSpriteLayer';
-import { type DrawShapeLayerProps } from '../../components/game/molecules/DrawShapeLayer';
-import { type DrawTextLayerProps } from '../../components/game/molecules/DrawTextLayer';
-/** Every drawable descriptor. The host's `children` are a `DrawableNode[]`. */
-export type DrawableNode = DrawSpriteProps | DrawShapeProps | DrawTextProps | DrawSpriteLayerProps | DrawShapeLayerProps | DrawTextLayerProps;
-/** Dispatch a drawable descriptor to its 2D painter. Unknown types are skipped — never throws. */
-export declare function paintDrawable(painter: Painter2D, node: DrawableNode, dctx: DrawContext): void;

package/dist/lib/drawable/projector.d.ts

@@ -1,14 +0,0 @@
-import type { Projector } from './contract';
-import { type TileLayout } from '../isometric';
-/** Projection modes the 2D host supports. `side` is handled by the side host, not here. */
-export type Projection2D = TileLayout | 'free';
-export interface Projector2DOptions {
-    scale: number;
-    /** Horizontal offset that centers the grid (0 for `flat`/`free`). */
-    baseOffsetX: number;
-    layout: Projection2D;
-    /** Override the measured diamond-top offset (default `DIAMOND_TOP_Y`). */
-    diamondTopY?: number;
-}
-/** Build a {@link Projector} for a 2D projection. */
-export declare function create2DProjector(opts: Projector2DOptions): Projector;

package/dist/lib/drawable/projector3d.d.ts

@@ -1,20 +0,0 @@
-/**
- * 3D projector — maps a core `ScenePos` to an R3F world position, mirroring the
- * `gridToWorld` convention in `grid3D.ts` (grid X → world X, grid Y → world Z on
- * the ground plane, scene Z → world Y as height). The 3D twin of `create2DProjector`;
- * the SAME drawable descriptors flow to both, only the renderer differs (mesh vs paint).
- */
-import type { ScenePos } from '@almadar/core';
-export interface Projector3D {
-    /** Scene position → `[x, y, z]` world position (y is up). */
-    toWorld(pos: ScenePos): [number, number, number];
-    /** World units per grid cell. */
-    readonly cellSize: number;
-}
-export interface Projector3DOptions {
-    cellSize?: number;
-    offsetX?: number;
-    offsetZ?: number;
-}
-/** Build a {@link Projector3D}. */
-export declare function create3DProjector(opts?: Projector3DOptions): Projector3D;