@almadar/shell-web 0.0.0-stage → 1.0.0

package/dist/lib/index.d.ts

@@ -0,0 +1,602 @@
+import { FieldValue, EntityRow, EventKey, EnterAnimation } from '@almadar/core';
+export { AssetLoadStatus, BridgeHealth, CheckStatus, EffectTrace, EventLogEntry, OrbitalVerificationAPI, ServerResponseTrace, TraitStateSnapshot, TransitionTrace, VerificationCheck, VerificationSnapshot, VerificationSummary, getNestedValue } from '@almadar/core';
+export { p as profilerOnRender, u as usePerfBuffer } from '../perf-CKiBKbkw.js';
+export { T as TraitSnapshotGetter, b as bindCanvasCapture, a as bindConfigApplier, c as bindEventBus, d as bindLastDrawables, e as bindTraitStateGetter, f as clearVerification, g as getAllChecks, h as getBridgeHealth, i as getSnapshot, j as getSummary, k as getTraitSnapshots, l as getTransitions, m as getTransitionsForTrait, r as recordOrbitalResponse, n as recordServerResponse, o as recordTransition, p as recordingTransport, q as registerCheck, s as registerTraitSnapshot, t as serverEffectTraces, u as subscribeToVerification, v as updateAssetStatus, w as updateBridgeHealth, x as updateCheck, y as verifierAttached, z as waitForTransition } from '../verificationRegistry-CVrcxG1s.js';
+export { A as ApplyOperatorInput, a as ApplyOperatorResult, C as ContentSegment, E as EDITOR_MOTIONS, b as EDITOR_OPERATORS, c as EditorMotion, d as EditorOperator, I as INDENT_UNIT, L as LessonSegment, e as applyMotion, f as applyOperator, i as isEditorMotion, g as isEditorOperator, m as motionRange, p as parseContentSegments, h as parseLessonSegments, j as parseMarkdownWithCodeBlocks } from '../parseLessonSegments-GpCeMrb2.js';
+export { D as DENSITY_ELEMENT_VARS, a as DENSITY_SPACING_VARS, b as DIAGRAM_VARS, E as ELEVATION_VARS, F as FlatVarEntry, G as GEOMETRY_VARS, I as ICONOGRAPHY_VARS, L as LEGACY_PREFIXES, M as MOTION_DURATION_KEYS, c as MOTION_EASING_KEYS, d as MOTION_INTENT_VARS, e as MOTION_SHAPE_VARS, S as SCENE_VARS, f as SURFACE_VARS, g as StringValueKey, h as TYPE_FAMILY_VARS, i as TYPE_HEADING_VARS, j as TYPE_INTENT_VARS, k as TYPE_SIZE_KEYS, T as ThemeMode, l as enterKeyframe, r as resolveThemeForRuntime, t as themeTokensToCssVars } from '../themeTokens-CRd8AEDF.js';
+export { a as PERF_NAMESPACE, P as PerfEntry, c as clearPerf, p as perfEnd, g as perfGauge, b as perfStart, d as perfTime, i as perfTimeAsync } from '../perf-Dr28-AgT.js';
+import 'react';
+import '../verification-C5pTeMJv.js';
+import '../paintDispatch-CuJLsr9Y.js';
+import '../fx-CmQjnHmT.js';
+import 'lucide-react';
+import '../EventBusProvider-BFFHfN4O.js';
+import '@almadar/shell-runtime/client/EventTransport';
+
+/**
+ * Trait Registry - Tracks active traits and their state machines for debugging
+ *
+ * @packageDocumentation
+ */
+interface TraitTransition {
+    from: string;
+    to: string;
+    event: string;
+    guard?: string;
+}
+interface TraitGuard {
+    name: string;
+    lastResult?: boolean;
+}
+interface TraitDebugInfo {
+    id: string;
+    name: string;
+    currentState: string;
+    states: string[];
+    transitions: TraitTransition[];
+    guards: TraitGuard[];
+    transitionCount: number;
+}
+type ChangeListener$3 = () => void;
+declare function registerTrait(info: TraitDebugInfo): void;
+declare function updateTraitState(id: string, newState: string): void;
+declare function updateGuardResult(traitId: string, guardName: string, result: boolean): void;
+declare function unregisterTrait(id: string): void;
+declare function getAllTraits(): TraitDebugInfo[];
+declare function getTrait(id: string): TraitDebugInfo | undefined;
+declare function subscribeToTraitChanges(listener: ChangeListener$3): () => void;
+declare function clearTraits(): void;
+
+/**
+ * Tick Registry - Tracks scheduled tick executions for debugging
+ *
+ * @packageDocumentation
+ */
+interface TickExecution {
+    id: string;
+    traitName: string;
+    /** Tick name (display name) */
+    name: string;
+    /** Tick identifier */
+    tickName: string;
+    interval: number;
+    /** Last execution timestamp */
+    lastRun: number;
+    lastExecuted: number | null;
+    nextExecution: number | null;
+    /** Number of times this tick has run */
+    runCount: number;
+    executionCount: number;
+    /** Average execution time in ms */
+    executionTime: number;
+    /** Whether the tick is currently active */
+    active: boolean;
+    isActive: boolean;
+    /** Guard name if this tick has a guard */
+    guardName?: string;
+    /** Whether the guard passed on last evaluation */
+    guardPassed?: boolean;
+}
+type ChangeListener$2 = () => void;
+declare function registerTick(tick: TickExecution): void;
+declare function updateTickExecution(id: string, timestamp: number): void;
+declare function setTickActive(id: string, isActive: boolean): void;
+declare function unregisterTick(id: string): void;
+declare function getAllTicks(): TickExecution[];
+declare function getTick(id: string): TickExecution | undefined;
+declare function subscribeToTickChanges(listener: ChangeListener$2): () => void;
+declare function clearTicks(): void;
+
+/**
+ * Guard Registry - Tracks guard evaluations for debugging
+ *
+ * @packageDocumentation
+ */
+
+interface GuardContext {
+    traitName?: string;
+    type?: "transition" | "tick";
+    transitionFrom?: string;
+    transitionTo?: string;
+    tickName?: string;
+    [key: string]: FieldValue | undefined;
+}
+interface GuardEvaluation {
+    id: string;
+    traitName: string;
+    guardName: string;
+    expression: string;
+    result: boolean;
+    context: GuardContext;
+    timestamp: number;
+    /** Input values used in guard evaluation */
+    inputs: Record<string, FieldValue>;
+}
+type ChangeListener$1 = () => void;
+declare function recordGuardEvaluation(evaluation: Omit<GuardEvaluation, "id" | "timestamp">): void;
+declare function getGuardHistory(): GuardEvaluation[];
+declare function getRecentGuardEvaluations(count: number): GuardEvaluation[];
+declare function getGuardEvaluationsForTrait(traitName: string): GuardEvaluation[];
+declare function subscribeToGuardChanges(listener: ChangeListener$1): () => void;
+declare function clearGuardHistory(): void;
+
+/**
+ * Entity Debug - Provides entity state snapshots for debugging
+ *
+ * @packageDocumentation
+ */
+
+interface EntityState {
+    id: string;
+    type: string;
+    fields: Record<string, FieldValue>;
+    lastUpdated: number;
+}
+interface RuntimeEntity {
+    id: string;
+    type: string;
+    data: Record<string, FieldValue>;
+}
+interface PersistentEntityInfo {
+    loaded: boolean;
+    count: number;
+}
+interface EntitySnapshot {
+    entities: EntityState[];
+    timestamp: number;
+    totalCount: number;
+    /** Singleton entities by name */
+    singletons: Record<string, EntityRow>;
+    /** Runtime entities (in-memory) */
+    runtime: RuntimeEntity[];
+    /** Persistent entities info by type */
+    persistent: Record<string, PersistentEntityInfo>;
+}
+type EntityProvider = () => EntityState[];
+declare function setEntityProvider(provider: EntityProvider): void;
+declare function clearEntityProvider(): void;
+declare function getEntitySnapshot(): EntitySnapshot | null;
+declare function getEntityById(id: string): EntityState | undefined;
+declare function getEntitiesByType(type: string): EntityState[];
+
+/**
+ * Debug Registry - Central event log for debugging
+ *
+ * @packageDocumentation
+ */
+
+type DebugEventType = 'state-change' | 'event-fired' | 'effect-executed' | 'guard-evaluated' | 'error' | 'warning' | 'info';
+interface DebugEvent {
+    id: string;
+    type: DebugEventType;
+    source: string;
+    message: string;
+    data?: Record<string, FieldValue>;
+    timestamp: number;
+}
+type ChangeListener = () => void;
+declare function logDebugEvent(type: DebugEventType, source: string, message: string, data?: Record<string, FieldValue>): void;
+declare function logStateChange(source: string, from: string, to: string, event?: string): void;
+declare function logEventFired(source: string, eventName: string, payload?: FieldValue): void;
+declare function logEffectExecuted(source: string, effectType: string, details?: FieldValue): void;
+declare function logError(source: string, message: string, error?: Error | null): void;
+declare function logWarning(source: string, message: string, data?: Record<string, FieldValue>): void;
+declare function logInfo(source: string, message: string, data?: Record<string, FieldValue>): void;
+declare function getDebugEvents(): DebugEvent[];
+declare function getRecentEvents(count: number): DebugEvent[];
+declare function getEventsByType(type: DebugEventType): DebugEvent[];
+declare function getEventsBySource(source: string): DebugEvent[];
+declare function subscribeToDebugEvents(listener: ChangeListener): () => void;
+declare function clearDebugEvents(): void;
+
+/**
+ * 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
+ */
+
+/**
+ * API Error class for handling HTTP errors
+ */
+declare class ApiError extends Error {
+    status: number;
+    statusText: string;
+    constructor(status: number, statusText: string, message?: string);
+}
+/**
+ * API client with typed methods
+ */
+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>;
+};
+
+/**
+ * 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).
+ */
+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.
+ */
+declare function debug(...args: unknown[]): void;
+declare function debugGroup(label: string): void;
+declare function debugGroupEnd(): void;
+declare function debugWarn(...args: unknown[]): void;
+declare function debugError(...args: unknown[]): void;
+declare function debugTable(data: unknown): void;
+declare function debugTime(label: string): void;
+declare function debugTimeEnd(label: string): void;
+declare function debugInput(inputType: string, data: unknown): void;
+declare function debugCollision(entityA: {
+    id?: string;
+    type?: string;
+}, entityB: {
+    id?: string;
+    type?: string;
+}, details?: unknown): void;
+declare function debugPhysics(entityId: string, physics: unknown): void;
+declare function debugGameState(stateName: string, value: unknown): void;
+
+/**
+ * Debug Utilities - Functions for toggling and checking debug mode
+ *
+ * @packageDocumentation
+ */
+type DebugToggleListener = (enabled: boolean) => void;
+/**
+ * Enable or disable debug mode
+ */
+declare function setDebugEnabled(enabled: boolean): void;
+/**
+ * Toggle debug mode
+ */
+declare function toggleDebug(): boolean;
+/**
+ * Subscribe to debug mode changes
+ */
+declare function onDebugToggle(listener: DebugToggleListener): () => void;
+/**
+ * Initialize debug mode from keyboard shortcut (Ctrl+Shift+D)
+ */
+declare function initDebugShortcut(): () => void;
+
+/**
+ * Command send pump (T7, docs/Almadar_Tick_Loop.md §3a item 2).
+ *
+ * Command-class events are a lossless ordered stream: two OW_DAMAGE hits must
+ * land twice, and the server must apply them in the exact order the client
+ * executed them. Pre-T7 the actor-queue drain `await`ed the server round trip
+ * per entry, so network latency sat on the input path — a keyup's local
+ * transition didn't run until every queued command ahead of it had completed
+ * its round trip (R-COMMAND-DRAIN-AWAIT-INPUT-LAG: 400-900ms typical, 1.6s
+ * peak under rapid platformer input).
+ *
+ * The pump restores ordering without the stall: jobs run strictly one at a
+ * time in enqueue order (request N+1 leaves only after response N arrived, so
+ * the server sees ordered commands and responses arrive in order — no seq
+ * numbers, no server machinery), while the caller's continuation runs when
+ * its own job settles and the drain moves on immediately. Tick-class traffic
+ * never passes through here — it is lossy and goes through
+ * `tick-send-relay.ts` instead.
+ *
+ * @packageDocumentation
+ */
+interface CommandSendPump {
+    /** Run `job` after every previously enqueued job settles, in FIFO order. */
+    enqueue: <T>(job: () => Promise<T>) => Promise<T>;
+}
+declare function createCommandSendPump(): CommandSendPump;
+
+/**
+ * Resolve a field value that may be a raw URL string (legacy `image`/`url` fields) or a
+ * structured `file`-typed {@link FileValue} into the URL an `<img src>` can use. Gallery/card
+ * grid image tiles only ever rendered the raw-string case before the file-type promotion —
+ * this keeps them working once a field is retyped to `file`.
+ */
+declare function resolveImageUrl(value: FieldValue | undefined): string | undefined;
+
+type KeyMap = Record<string, EventKey>;
+declare function isEditableTarget(target: EventTarget | null): boolean;
+declare function keyMapCode(e: KeyboardEvent): string;
+/** A modified entry (`Mod+`/`Shift+`/`Alt+` prefixed) wins over the bare code; a bare
+ *  entry still fires under modifiers it never declared (existing boards keep their
+ *  bindings); keystrokes in editable elements never route. */
+declare function resolveKeyMapEvent(map: KeyMap | undefined, e: KeyboardEvent): EventKey | undefined;
+
+/**
+ * Shared types for the Al-Jazari state machine visualization.
+ * Pure TypeScript — zero React/DOM dependencies.
+ */
+/** Layout for a single gear (state node) */
+interface JazariGearLayout {
+    /** State name */
+    name: string;
+    /** Center X coordinate */
+    cx: number;
+    /** Center Y coordinate */
+    cy: number;
+    /** Gear outer radius */
+    radius: number;
+    /** Whether this is the initial state */
+    isInitial: boolean;
+    /** Whether this is a terminal state */
+    isTerminal: boolean;
+}
+/** Guard info attached to an arm */
+interface JazariGuardInfo {
+    /** Position X along the arm (30% point) */
+    x: number;
+    /** Position Y along the arm (30% point) */
+    y: number;
+    /** Whether this is an AI guard (call-service) vs deterministic */
+    isAI: boolean;
+}
+/** Effect info attached to an arm */
+interface JazariEffectInfo {
+    /** Position X along the arm (70% point) */
+    x: number;
+    /** Position Y along the arm (70% point) */
+    y: number;
+    /** Number of effects */
+    count: number;
+    /** Effect labels for tooltip display */
+    names: string[];
+}
+/** Layout for a single transition arm */
+interface JazariArmLayout {
+    /** Source state name */
+    from: string;
+    /** Target state name */
+    to: string;
+    /** Event name label */
+    event: string;
+    /** SVG path d attribute for the arm curve */
+    path: string;
+    /** Label position X (midpoint of arm) */
+    labelX: number;
+    /** Label position Y (midpoint of arm) */
+    labelY: number;
+    /** Guard info if transition has guards */
+    guard: JazariGuardInfo | null;
+    /** Effect info if transition has effects */
+    effect: JazariEffectInfo | null;
+    /** Whether this is a self-loop */
+    isSelfLoop: boolean;
+}
+/** Complete layout result for an entire state machine diagram */
+interface JazariLayout {
+    /** Total SVG width */
+    width: number;
+    /** Total SVG height */
+    height: number;
+    /** All gear positions */
+    gears: JazariGearLayout[];
+    /** All transition arm paths */
+    arms: JazariArmLayout[];
+    /** Golden axis Y position */
+    axisY: number;
+    /** Golden axis start X */
+    axisStartX: number;
+    /** Golden axis end X */
+    axisEndX: number;
+    /** Entity field labels to display on the axis */
+    entityFields: string[];
+    /** Text direction */
+    direction: 'ltr' | 'rtl';
+}
+/** Al-Jazari color palette constants */
+declare const JAZARI_COLORS: {
+    readonly brass: "#B87333";
+    readonly gold: "#C8A951";
+    readonly sky: "#0EA5E9";
+    readonly crimson: "#DC2626";
+    readonly lapis: "#1E40AF";
+    readonly ivory: "#FFFBEB";
+    readonly darkBg: "#1a1a2e";
+};
+
+/**
+ * Layout algorithm for the Al-Jazari state machine visualization.
+ * Pure TypeScript — zero React/DOM dependencies.
+ *
+ * 1. BFS from initial state to order states by graph distance.
+ * 2. Horizontal distribution of gears along the golden axis.
+ * 3. Transition arm routing: forward arcs above, backward arcs below, self-loops above.
+ * 4. Guard icons at 30% along arm, effect icons at 70%.
+ */
+
+interface LayoutState {
+    name: string;
+    isInitial?: boolean;
+    isTerminal?: boolean;
+    isFinal?: boolean;
+}
+interface LayoutTransition {
+    from: string;
+    to: string;
+    event: string;
+    guard?: FieldValue;
+    effects?: FieldValue[];
+}
+interface LayoutInput {
+    states: LayoutState[];
+    transitions: LayoutTransition[];
+    entityFields?: string[];
+    direction?: 'ltr' | 'rtl';
+}
+declare function computeJazariLayout(input: LayoutInput): JazariLayout;
+
+/**
+ * SVG path generators for the Al-Jazari state machine visualization.
+ * Pure TypeScript — zero React/DOM dependencies.
+ *
+ * Generates paths for gear teeth, arabesque borders, pipe shapes, and lock icons.
+ */
+/**
+ * Generate an SVG path for gear teeth around a circle.
+ *
+ * @param cx - Center X
+ * @param cy - Center Y
+ * @param innerRadius - Inner radius (base circle)
+ * @param outerRadius - Outer radius (tip of teeth)
+ * @param numTeeth - Number of teeth around the gear
+ * @returns SVG path d attribute string
+ */
+declare function gearTeethPath(cx: number, cy: number, innerRadius: number, outerRadius: number, numTeeth: number): string;
+/**
+ * Generate an SVG path for a small gear-shaped lock icon.
+ *
+ * @param cx - Center X
+ * @param cy - Center Y
+ * @param size - Overall size of the lock icon
+ * @returns SVG path d attribute for the lock body + shackle
+ */
+declare function lockIconPath(cx: number, cy: number, size: number): string;
+/**
+ * Generate a simple brain-like icon path.
+ *
+ * @param cx - Center X
+ * @param cy - Center Y
+ * @param size - Overall size
+ * @returns SVG path d attribute
+ */
+declare function brainIconPath(cx: number, cy: number, size: number): string;
+/**
+ * Generate a simple pipe/tube icon path.
+ *
+ * @param cx - Center X
+ * @param cy - Center Y
+ * @param size - Overall size
+ * @returns SVG path d attribute
+ */
+declare function pipeIconPath(cx: number, cy: number, size: number): string;
+/**
+ * Generate a single 8-pointed star path for the arabesque border pattern.
+ *
+ * @param cx - Center X
+ * @param cy - Center Y
+ * @param outerR - Outer radius (star tips)
+ * @param innerR - Inner radius (star valleys)
+ * @returns SVG path d attribute
+ */
+declare function eightPointedStarPath(cx: number, cy: number, outerR: number, innerR: number): string;
+/**
+ * Generate a simple arrowhead path for transition arm endpoints.
+ *
+ * @param size - Arrow size
+ * @returns SVG path d attribute
+ */
+declare function arrowheadPath(size: number): string;
+
+/**
+ * Lucide canonical icon name → native platform glyph (Layer 1 Iconography
+ * axis, native path). `lib/iconFamily.tsx` resolves a canonical name to a
+ * React component for the web/runtime path; this table is the same
+ * dispatch for the compiled iOS/Android shells, which have no React DOM to
+ * render into and instead need a platform symbol name.
+ *
+ * Hand-curated (no fuzzy matching — see `resolveNativeIcon`). Covers:
+ *   (a) every alias key in `components/core/atoms/Icon.tsx` `iconAliases`
+ *       and `lib/iconFamily.tsx` `lucideAliases`
+ *   (b) every icon name appearing as an icon-prop `default` or in an
+ *       icon-prop description's quoted examples in
+ *       `orbital-rust/crates/orbital-compiler/src/baked/patterns-registry.json`
+ *   (c) every icon name used by the wave-1 native pattern set's React
+ *       components under `components/core/**`
+ *   (d) the common Lucide vocabulary: navigation, actions, files,
+ *       communication, status, media, arrows, editing.
+ *
+ * `sfSymbol` values are real SF Symbols 5 names; `materialSymbol` values are
+ * real Material Symbols names. The table is `lib/iconNativeMap.json`, the one source
+ * `orb shell-renderers icon-map` also reads to emit `IconMap.swift`/`IconMap.kt`; edit the
+ * JSON, then regenerate. The JSON also carries each icon's `categories` entry and the
+ * per-icon rationale `notes` (the former inline comments); the TS ignores both.
+ */
+interface NativeIconGlyph {
+    sfSymbol: string;
+    materialSymbol: string;
+}
+declare const ICON_FALLBACK: NativeIconGlyph;
+declare const ICON_NATIVE_MAP: Readonly<Record<string, NativeIconGlyph>>;
+/**
+ * Every non-standard name from `iconAliases` (`components/core/atoms/Icon.tsx`)
+ * and `lucideAliases` (`lib/iconFamily.tsx`) — the names that don't kebab→Pascal
+ * to a real Lucide export. Each one is also a first-class `ICON_NATIVE_MAP` key
+ * (requirement (a)); exported so the alias set has one pinned source of truth
+ * a test can check against, independent of whatever else the map grows to cover.
+ */
+declare const ICON_ALIASES: ReadonlyArray<string>;
+/** Exact key match, then an `iconAliases` alias, then the deterministic fallback — no fuzzy matching. */
+declare function resolveNativeIcon(name: string): NativeIconGlyph;
+
+/** One line of a line-level diff between two texts. */
+interface LineDiffLine {
+    type: 'added' | 'removed' | 'unchanged';
+    beforeLineNumber?: number;
+    afterLineNumber?: number;
+    content: string;
+}
+/**
+ * Minimal line diff — the one diff every diff view renders. Empty text has no lines.
+ * Myers' O(ND) algorithm with the linear-space middle-snake split (what git uses):
+ * time grows with the size of the change, memory with the size of the texts.
+ */
+declare function computeLineDiff(before: string, after: string): LineDiffLine[];
+
+/**
+ * Element entry — the one mechanism behind a render-ui node's `enter` and a
+ * slot's theme-default entry. Pure CSS (`themes/_base.css`): the classes name
+ * keyframes whose shape, timing and default are theme tokens. Both execution
+ * paths call these helpers — the runtime renderer per node, and the compiled
+ * emitter's generated JSX — so the two never diverge.
+ *
+ * Off when the theme sets `--motion-enable: off`; the OS reduced-motion
+ * setting collapses the keyframes in `_base.css`.
+ */
+
+/** Plays the theme's `--motion-enter-default` keyframe on a slot's content box. */
+declare const ENTER_SLOT_CLASS = "almadar-enter-slot";
+/** Narrows a prop value to the entry vocabulary (anything else is not an entry). */
+declare function asEnterAnimation(value: string | undefined): EnterAnimation | undefined;
+/** Highest `enterDelay` step (`almadar-enter-delay-1` … `-8` in `_base.css`). */
+declare const MAX_ENTER_DELAY: 8;
+/**
+ * The class a node's declared `enter` (+ optional stagger step `enterDelay`)
+ * adds to its element. `none` and an unset `enter` add nothing.
+ */
+declare function enterClassName(enter: EnterAnimation | undefined, enterDelay?: number): string | undefined;
+
+export { ApiError, ENTER_SLOT_CLASS, ICON_ALIASES, ICON_FALLBACK, ICON_NATIVE_MAP, JAZARI_COLORS, MAX_ENTER_DELAY, apiClient, arrowheadPath, asEnterAnimation, brainIconPath, clearDebugEvents, clearEntityProvider, clearGuardHistory, clearTicks, clearTraits, computeJazariLayout, computeLineDiff, createCommandSendPump, debug, debugCollision, debugError, debugGameState, debugGroup, debugGroupEnd, debugInput, debugPhysics, debugTable, debugTime, debugTimeEnd, debugWarn, eightPointedStarPath, enterClassName, gearTeethPath, getAllTicks, getAllTraits, getDebugEvents, getEntitiesByType, getEntityById, getEntitySnapshot, getEventsBySource, getEventsByType, getGuardEvaluationsForTrait, getGuardHistory, getRecentEvents, getRecentGuardEvaluations, getTick, getTrait, initDebugShortcut, isDebugEnabled, isEditableTarget, keyMapCode, lockIconPath, logDebugEvent, logEffectExecuted, logError, logEventFired, logInfo, logStateChange, logWarning, onDebugToggle, pipeIconPath, recordGuardEvaluation, registerTick, registerTrait, resolveImageUrl, resolveKeyMapEvent, resolveNativeIcon, setDebugEnabled, setEntityProvider, setTickActive, subscribeToDebugEvents, subscribeToGuardChanges, subscribeToTickChanges, subscribeToTraitChanges, toggleDebug, unregisterTick, unregisterTrait, updateGuardResult, updateTickExecution, updateTraitState };
+export type { CommandSendPump, DebugEvent, DebugEventType, EntitySnapshot, EntityState, GuardContext, GuardEvaluation, JazariArmLayout, JazariEffectInfo, JazariGearLayout, JazariGuardInfo, JazariLayout, KeyMap, LayoutInput, LayoutState, LayoutTransition, LineDiffLine, NativeIconGlyph, PersistentEntityInfo, RuntimeEntity, TickExecution, TraitDebugInfo, TraitGuard, TraitTransition };