Engine API

export { CadEngine }/** * The engine on a page. It owns its `<canvas>`: sizes the backing store to * the canvas's CSS box and the device's pixel ratio, draws a frame whenever * something changed, and takes the pointer, the wheel and the keys (from its * `scope`). Everything else is the host's: it shows {@link getState} in its * own chrome and calls the methods below. `CadDriver` is the same engine with * no browser. */export declare class CadEngine {    constructor(canvas: HTMLCanvasElement, options?: CadEngineOptions);    /**     * Calls `listener` after every change to the state, once per change, with     * nothing: read the new state with {@link getState}. Returns the unsubscribe.     */    subscribe(listener: Listener): () => void;    /**     * The engine's state, an immutable snapshot: the same object until something     * changes, and a changed one keeps every part that did not, so a host can     * compare by identity (`useSyncExternalStore` takes it as it is).     */    getState(): EngineState;    /** Switches the language; what the command line already shows stays. */    setLocale(locale: EngineLocale): void;    /**     * Starts a tool as its button would, by its id in `state.tools` (`"line"`):     * the running command ends, the tool's command starts and the command line     * echoes it. `"select"` goes back to the Command prompt.     */    setActiveTool(id: string): void;    /**     * The Delete key: ERASE on what is selected at the Command prompt, one undo     * step. Nothing happens while a command runs.     */    deleteSelection(): void;    /**     * NEW: an empty drawing in place of this one, the running command ended. It     * is one undo step, so U brings the old drawing back.     */    newDrawing(): void;    /**     * U: takes back the last step, a whole command or gesture, and writes what     * it took back on the command line.     */    undo(): void;    /**     * REDO: does again what the last undo took back.     */    redo(): void;    zoomIn(): void;    zoomOut(): void;    resetView(): void;    /**     * ZOOM Extents: frames every object, `padding` screen pixels in from the     * edges; the default view on an empty drawing.     */    zoomToFit(padding?: number): void;    zoomToBounds(bounds: Bounds, padding?: number): void;    zoomPrevious(): boolean;    toggleSnap(): void;    /**     * Turns one running object snap on or off (OSNAP's checkboxes); {@link toggleSnap}     * switches them all, as F3 does.     */    setSnapEnabled(type: SnapType, enabled: boolean): void;    setSnapOverride(override: SnapType | "none"): void;    closeSnapOverrideMenu(): void;    closeShortcutMenu(): void;    chooseShortcutMenuAction(action: ShortcutMenuAction): void;    chooseShortcutMenuOption(id: string): void;    chooseShortcutMenuDimStyle(id: string): void;    toggleSelectionCycling(): void;    setSelectionCyclingList(showList: boolean): void;    setUcsIconShown(shown: boolean): void;    chooseCyclingCandidate(id: EntityId): void;    previewCyclingCandidate(id: EntityId): void;    closeCyclingList(): void;    toggleOrtho(): void;    togglePolar(): void;    setPolarAngleStep(step: number): void;    choosePolarAngle(step: number): void;    toggleObjectSnapTracking(): void;    clearTracking(): void;    toggleGrid(): void;    toggleSnapMode(): void;    /**     * Whether snap mode steps on the rectangular lattice or by polar distance.     */    setSnapModeType(type: SnapModeType): void;    setSnapSpacing(x: number, y?: number): void;    setSnapPolarDistance(distance: number): void;    /**     * Turns Ortho or Polar tracking on or off; the two exclude each other.     */    setConstraintEnabled(type: ConstraintType, enabled: boolean): void;    /**     * A new layer, current unless `makeCurrent` is false, as -LAYER's Make     * does: one undo step. Unnamed, it is the next `Layer<n>`. Returns its id.     */    createLayer(name?: string, color?: string, makeCurrent?: boolean): string;    /**     * The Layer Properties Manager's New Layer: the next `Layer<n>`, with the     * colour, linetype and lineweight of `like` or the defaults, the current     * layer kept. Returns its id.     */    newLayer(like?: string): string;    updateLayer(id: string, patch: Partial<Pick<Layer, "name" | "color" | "linetype" | "lineweight" | "visible" | "locked">>): LayerNameRefusal | null;    /**     * Makes a layer current, as the Layers drop-down does (CLAYER), or as the     * Layer Properties Manager does with `"manager"`, which names the undo step     * after it.     */    setCurrentLayer(id: string, from?: "control" | "manager"): void;    /**     * Deletes a layer, one undo step, unless it is layer `0`, the current layer     * or holds an object (in a block definition too). Returns whether it went.     */    removeLayer(id: string): boolean;    /**     * The selection edits take a scope: the whole selection, as the ribbon's     * drop-downs edit it, or `"properties"`, the objects the Properties     * palette's type filter leaves.     */    setSelectionLayer(id: string, scope?: SelectionScope): void;    applyLayerControl(id: string): void;    /**     * Gives the selected objects a colour, a hex value or `"ByLayer"`, in one     * undo step.     */    setSelectionColor(color: string, scope?: SelectionScope): void;    /** Starts the FROM point modifier (pick a base, then type an offset). */    startFrom(): boolean;    /**     * Types a point filter at the running point prompt (`.X`, `.XY`…), as the     * Point Filters menu does: the next point gives those coordinates, and     * `(need …)` asks for the rest.     */    choosePointFilter(filter: PointFilterName): void;    /**     * Gives the selected objects a linetype, an id of `LINETYPES` or     * `"ByLayer"`, in one undo step.     */    setSelectionLinetype(linetype: string, scope?: SelectionScope): void;    setSelectionLineweight(lineweight: number | "ByLayer", scope?: SelectionScope): void;    /** CECOLOR, CELTYPE and CELWEIGHT: what new objects take. */    setCurrentColor(color: string): void;    setCurrentLinetype(linetype: string): void;    setCurrentLineweight(lineweight: number | "ByLayer"): void;    /**     * The top bar's property drop-downs: the selection when there is one, else     * the current property, as {@link applyLayerControl} does with the layer.     */    applyColorControl(color: string): void;    applyLinetypeControl(linetype: string): void;    applyLineweightControl(lineweight: number | "ByLayer"): void;    /** Narrows the Properties palette to one object type, or to all with null. */    setPropertiesFilter(type: ObjectType | null): void;    /** Retypes one geometry value of the one object the Properties palette edits. */    setSelectionProperty(property: EntityProperty, text: string): boolean;    /**     * The text of a field of the dynamic input (`state.dynamicInput.fields`),     * the active one unless `fieldId` names another, as the user types it.     */    setDynamicInputText(text: string, fieldId?: string): void;    /**     * Moves the dynamic input to another of its fields, as Tab does.     */    setActiveDynamicField(fieldId: string): void;    /**     * Answers the prompt's `[Close/Undo]` with a keyword typed as a user types     * it: its letters or word in the command language, or `_` and the global word.     * Returns whether the prompt offered it.     */    invokeToolOption(input: string): boolean;    /**     * A key in a field of the host's dynamic input, by the field's id: whether     * the engine took it (prevent the browser's). After a Tab the host moves     * focus to the field now active.     */    dynamicInputKey(fieldId: string, key: string, modifiers?: Omit<PointerModifiers, "button">): boolean;    /**     * Replaces what is typed at the prompt; what is typed on the drawing goes     * there too. {@link commandLineKey} sends the keys that act on it.     */    setCommandLineText(text: string): void;    /**     * Runs a command as typed at the prompt and confirmed: its name or alias in     * the command language, or `_` and its global name in any (`_LINE`). Returns     * false, writing the error on the command line, when no command has the name.     */    runCommand(name: string): boolean;    /** A preset view from the viewport controls, run as `'_-view _<preset>`. */    applyViewPreset(preset: ViewPreset): boolean;    /** The navigation bar's Pan and Orbit, run as their macros. Transparent mid-command. */    navigate(command: "PAN" | "3DORBIT"): boolean;    /** A member of the navigation bar's Zoom, run as its macro (`'_zoom 2x`). Transparent mid-command. */    zoom(option: ZoomOption): boolean;    /**     * A press on the ViewCube, by what it landed on; its moves and release     * follow, in the same pixels. The engine tells a click from a drag.     */    viewCubePress(target: ViewCubeTarget, screen: Vec2): void;    viewCubeMove(screen: Vec2): void;    /** The press let go, at `screen`; `null` when the pointer was lost (cancelled). */    viewCubeRelease(screen: Vec2 | null): void;    viewCubeRoll(turn: ViewCubeRoll): void;    viewCubeAdjacent(side: ViewCubeSide): void;    viewCubeHome(): void;    setHomeFromCurrentView(): void;    setViewCubeVisible(visible: boolean): void;    /** The WCS (`null`) or a saved UCS, from the ViewCube's UCS menu. */    restoreUcs(name: string | null): boolean;    /** A key in the host's command-line field: whether the engine took it (prevent the browser's). */    commandLineKey(key: string): boolean;    toggleCommandLine(): void;    toggleCommandHistory(): void;    setCleanScreen(on: boolean): void;    toggleCleanScreen(): void;    /**     * A point of the state's screen space (the canvas's own pixels: the cursor,     * the snap override menu, the cycling list) in the page's viewport, where a     * popup anchored to it is positioned. The canvas does not start at the     * page's corner, so the two differ.     */    clientFromScreen(screen: Vec2): Vec2;    /** Returns keyboard focus to the drawing surface. */    focusSurface(): void;    /**     * Whether the engine's own UI (the dynamic-input box) may take keyboard     * focus away from `from`. The editor owns the page, so from anywhere but an     * open menu or modal dialog, which keep their keys (an Escape there taken by     * the box would end the command), or another field being typed in — the     * command line, a palette's value: the next render took the rest of what     * was typed there into the box. An embedded engine only while active, and     * only from its canvas, its scope or the body — never from the rest of the     * page, nor from a control beside the canvas that the user tabbed to.     */    mayTakeFocus(from: Element | null): boolean;    /**     * The drawing's unit, which lengths are written in (`10.00 mm`): one     * drawing unit is one of it, so nothing is rescaled.     */    setDocumentUnit(unit: LengthUnit): void;    /**     * How many decimal places lengths are written with.     */    setDocumentPrecision(precision: number): void;    applyDrawingUnits(unit: LengthUnit, precision: number): void;    setLtScale(ltScale: number): void;    setDimScale(scale: number): void;    createDimStyle(name?: string, basedOn?: string, makeCurrent?: boolean): string;    updateDimStyle(id: string, patch: Partial<Omit<DimStyle, "id">>): void;    /**     * Makes a dimension style the one new dimensions take.     */    setCurrentDimStyle(id: string): void;    removeDimStyle(id: string): boolean;    setSelectionDimStyle(id: string): void;    createTextStyle(name?: string, basedOn?: string, makeCurrent?: boolean): string;    updateTextStyle(id: string, patch: Partial<Omit<TextStyle, "id">>): void;    /**     * Makes a text style the one new text takes.     */    setCurrentTextStyle(id: string): void;    removeTextStyle(id: string): boolean;    setSelectionTextStyle(id: string): void;    setStylesTable(table: StylesPanelTab): void;    /** Opens the palette panel on one of its palettes. */    showPalette(tab: PaletteTab): void;    /** Folds the palette panel; with a tab, only while that palette shows. */    closePalette(tab?: PaletteTab): void;    /** A palette's trigger: opens the panel on it, or folds it if it shows. */    togglePalette(tab: PaletteTab): void;    setPaletteOpen(open: boolean): void;    setUnitsDialog(open: boolean): void;    openDrawingUnits(): void;    openDrawingUnitsFromMenu(): void;    runFileButton(bar: "quickAccess" | "applicationMenu", button: "new" | "open" | "save" | "saveAs"): void;    closeLockedObjectsDialog(): void;    answerUnsavedText(answer: "yes" | "no" | "cancel"): void;    insertBlock(id: string): void;    /**     * Deletes the block definitions named, or every one, that nothing in the     * drawing uses: PURGE's Blocks, one undo step. Returns how many went.     */    purgeBlocks(ids?: readonly string[]): number;    /**     * A block's thumbnail, framed in `width`×`height` pixels, as a scene for a     * presenter. Null for an unknown or empty block.     */    buildBlockPreview(id: string, width: number, height: number): Scene | null;    toggleLineweightDisplay(): void;    /**     * The drawing as the text of a drawing file: versioned JSON, in world     * coordinates, what SAVE writes and {@link loadDrawing} reads.     */    serializeDrawing(): string;    /**     * The name SAVE gives the file, `drawing-<date>.ecad.json` with `drawing`     * in the command language (`dibujo-` in Spanish).     */    suggestedFileName(): string;    /**     * Replaces the drawing with a drawing file's text, framed in the view, with     * an empty undo history; the store is written at once. Throws an `Error`     * whose message is for the user when the text is no drawing or is from a     * newer version.     */    loadDrawing(text: string): void;    /**     * SAVE: hands the drawing file to the file transport, a download in the     * browser.     */    saveDrawingToFile(): void;    /**     * OPEN: asks the file transport for a file, a file picker in the browser,     * and loads it. Never rejects: a cancelled pick does nothing and a bad file is     * reported on the command line.     */    openDrawingFromFile(): Promise<void>;    /**     * PASTECLIP: reads the clipboard and starts placing what was copied there.     */    pasteFromClipboard(): Promise<void>;    /**     * Ctrl+A: selects every object that can be, the running command ended.     */    selectAll(): void;    /**     * Stops listening to the page and drawing, and writes a change still     * waiting for the store. Call it when the canvas goes away.     */    dispose(): void;}
export type { CadEngineOptions }export interface CadEngineOptions {    /**     * Where the transparent autosave goes, and what the engine restores when it     * starts. None by default: an engine never writes a drawing it was not given     * a store for. The editor passes this device's,     * `createLocalStorageDrawingStore()`; `null` is the same as leaving it out.     */    readonly store?: DrawingStore | null;    /**     * What part of the page the engine may take keys, the wheel and the context     * menu from. By default its canvas: the engine is **active** from a press or     * a focus inside the scope until the next one outside it. Inactive, it hears     * no keys, leaves the wheel to scroll the page and never takes focus. Active,     * it hears keys aimed at the canvas or at the page body, and none of them     * scrolls the page; fields inside the scope keep the editor's rule for     * fields, and any other control there keeps its own keys. A host whose own     * controls sit beside the canvas passes the element holding both.     *     * `"document"` gives the engine the whole page, as the editor needs: every     * key reaches it wherever focus sits, the wheel always zooms and the native     * context menu never opens.     */    readonly scope?: HTMLElement | "document";    /**     * The language the engine speaks — its prompts, keywords, palettes and what     * it draws on the canvas. English, built in, when left out.     */    readonly locale?: EngineLocale;    /**     * Whether the palette panel starts open, so the engine agrees with what the     * host laid out before it existed. Folded when left out.     */    readonly paletteOpen?: boolean;    /**     * Shows a command's help, AutoCAD's F1: the global name of the command     * running, or `null` for the help's start. Without it F1 is the browser's.     */    readonly onHelp?: (command: string | null) => void;}

export { CadDriver }export declare class CadDriver {    constructor(options?: CadDriverOptions);    dispose(): void;    /** World → screen through the live viewport (survives zoom/pan). */    toScreen(world: WorldPoint): Vec2;    toWorld(screen: Vec2): Vec2;    moveTo(world: WorldPoint, modifiers?: PointerModifiers): this;    /** A full press-and-release at one point: the ordinary "pick". */    click(world: WorldPoint, modifiers?: PointerModifiers): this;    /**     * A press and release of the right button: Enter, or one of AutoCAD's     * shortcut menus, as the prompt decides; with Shift at a point prompt, the     * object-snap override menu.     */    rightClick(world: WorldPoint, modifiers?: Omit<PointerModifiers, "button">): this;    /** The press half of a gesture, left held until {@link mouseUp}. */    mouseDown(world: WorldPoint, modifiers?: PointerModifiers): this;    mouseUp(world: WorldPoint, modifiers?: PointerModifiers): this;    /**     * Two picks followed by the double-click the browser then fires — the order     * the real adapter delivers, so the tool sees the selection the clicks made.     */    doubleClick(world: WorldPoint, modifiers?: PointerModifiers): this;    /**     * A press-move-release gesture. Two intermediate moves are sent so tools that     * only start dragging past a pixel threshold (box selection, grips) see the     * motion they expect.     */    drag(from: WorldPoint, to: WorldPoint, modifiers?: PointerModifiers): this;    /**     * A press at the path's first point, the cursor dragged through the rest     * and released at its last: AutoCAD's lasso, drawn along that path.     */    lasso(path: readonly WorldPoint[], modifiers?: PointerModifiers): this;    wheel(world: WorldPoint, deltaY: number): this;    /** Sends a key to the drawing surface. Returns whether it was consumed. */    press(key: string, modifiers?: Omit<PointerModifiers, "button">): boolean;    /** Lets go of a key held on the drawing surface. */    release(key: string): this;    /**     * True when a dynamic-input *field* is on screen. This mirrors focus in the     * real UI: a session with fields auto-focuses its input (so keys go to the     * box), whereas a keyword-only prompt renders chips and leaves focus on the     * canvas. Routing scripted keystrokes the same way keeps them honest.     */    hasFocusedField(): boolean;    /** Types into a dynamic-input field (the active one unless `fieldId` given). */    type(text: string, fieldId?: string): this;    /**     * The Down or Up arrow, routed as the UI routes it: the box's own key when a     * field is focused, else the drawing's. Down opens the prompt's option list.     */    arrow(direction: "up" | "down"): this;    /**     * Enter: the focused box's, else the drawing's. A paragraphs box takes     * Enter as a line break, so it gets Ctrl+Enter, which closes it.     */    enter(): this;    /** Escape: the focused box's, else the drawing's. */    escape(): this;    /**     * Answers a keyword prompt (AutoCAD's `[Close/Undo]`) with the keyword whose     * global id is `id` — `option("Close")` in every language — typed as a     * user of the command language would: its abbreviation, then Enter. Routed     * like the UI does: through the focused input when there is one, else on     * the drawing surface. An id the running command does not have is a mistake     * in the script, and throws.     */    option(id: string): this;    /**     * What a user types to answer with keyword `id` at the current prompt: its     * abbreviation in the command language.     */    optionAnswer(id: string): string;    /** Runs a command by name or alias, as typing it at the prompt would. */    command(text: string): this;    tool(id: string): this;    activeToolId(): string;    undo(): this;    redo(): this;    select(...ids: EntityId[]): this;    selectAll(): this;    selectedIds(): EntityId[];    entities(): Entity[];    get entityCount(): number;    /** The most recently added entity — what a draw command just produced. */    latest(): Entity;    /**     * The single entity of `type` in the drawing, failing loudly otherwise. Makes     * a wrong entity count fail with a useful message instead of a `undefined`     * property access three lines later.     */    only<T extends Entity>(type: Entity["type"]): T;    byId<T extends Entity>(id: EntityId): T;    typeCounts(): Record<string, number>;    state(): EngineState;    scene(): Scene;    /** The abbreviations the keyword chips the active tool offers show. */    optionAbbreviations(): string[];    /** The global ids of the keywords the active tool currently offers. */    optionIds(): string[];    /** Everything written to the command prompt, in order. */    commandLog(): string[];}
export type { CadDriverOptions }export interface CadDriverOptions {    /** Viewport size in CSS pixels. The default keeps world→screen trivial. */    readonly width?: number;    readonly height?: number;    /** Geometry present before the script starts (loaded outside the undo stack). */    readonly entities?: readonly Entity[];    /** Block definitions present before the script starts. */    readonly blocks?: readonly BlockDefinition[];    /**     * Running object snaps. Off by default so a click lands exactly where the     * script asked; turn it on for scripts that are *about* snapping.     */    readonly snap?: boolean;    /**     * Polar tracking (F10), which a fresh AutoCAD has on. Off by default for the     * same reason as {@link snap}: near an angle it would bend a click.     */    readonly polar?: boolean;    /**     * The UCS icon. Off by default so a frame holds only what the script drew;     * turn it on for scripts that are *about* the icon.     */    readonly ucsIcon?: boolean;    readonly store?: DrawingStore | null;    /** The language the engine speaks; English when left out. */    readonly locale?: EngineLocale;    /** File save/open. Absent means the host offers none (SSR, headless). */    readonly files?: FileTransport | null;    readonly clipboard?: Clipboard | null;    /** Shows a command's help on F1 (`EngineHost.showHelp`); F1 does nothing without it. */    readonly help?: (command: string | null) => void;}
export type { PointerModifiers }export interface PointerModifiers {    readonly shiftKey?: boolean;    readonly ctrlKey?: boolean;    readonly altKey?: boolean;    readonly button?: number;}

export type { BlockInfo }/** A block definition as the Blocks palette lists it. */export interface BlockInfo {    readonly id: BlockId;    readonly name: string;    /** How many references to it the drawing currently holds. */    readonly referenceCount: number;}
export type { CleanScreenUi }/** Clean Screen: what it hides is the host's chrome, so the host hides it. */export interface CleanScreenUi {    /** CLEANSCREENSTATE: the tool palette, the palette panel and the ribbon hidden. */    readonly active: boolean;    /** A palette was opened while it is on: the palette panel shows again. */    readonly palette: boolean;}
export type { CommandLineEntry }/** * One line of the command-line scrollback: a command started (`command`), a * prompt with its answer (`prompt`), or what a command reported. */export interface CommandLineEntry {    readonly kind: CommandLineEntryKind;    readonly text: string;}
export type { CommandLineEntryKind }/** * AutoCAD's command line: the keyboard-first way to run commands by name or * alias, with a scrollback of what happened and recall of what was typed. * * This controller owns only the *text* side of it (buffer, log, history). What * a command name means is decided by the runtime, which registers a * {@link CommandDefinition} per command. */export type CommandLineEntryKind = "command" | "prompt" | "info" | "error";
export type { CommandLineUi }/** Snapshot of the command line (AutoCAD's `Command:` prompt) for the UI. */export interface CommandLineUi {    /** Whether the prompt is shown (AutoCAD's Ctrl+9). */    readonly visible: boolean;    /** Whether the command history is expanded above the prompt (F2). */    readonly historyOpen: boolean;    /**     * The temporary prompt history: the last lines of the most recent command,     * shown above the one-line prompt (CLIPROMPTLINES, 3).     */    readonly recent: ReadonlyArray<CommandLineEntry>;    /**     * Text before the input: `Command:`, the running command's name and its     * question, `LINE Specify next point or [Undo]:`, or its name alone when     * it names no question, `PLINE [Close/Undo]:`.     */    readonly prompt: string;    /**     * The same prompt in spans, the keyword list set apart, so a host can style     * it without taking the text apart.     */    readonly promptSegments: ReadonlyArray<PromptSegment>;    /** The running command's name as the prompt shows it; null at rest. */    readonly command: string | null;    /**     * The question alone, as the history writes it once answered —     * `Specify next point or [Undo]:` — in spans; null when there is none.     */    readonly question: ReadonlyArray<PromptSegment> | null;    /** The neutral prompt, `Command:`, which also heads each echoed command. */    readonly idlePrompt: string;    /** What the user has typed so far, whether on the canvas or in the box. */    readonly buffer: string;    /**     * Whether Space types a space after what is typed rather than answering:     * a prompt whose answer holds spaces (UCS's names). Elsewhere the command     * line's Space is Enter.     */    readonly takesSpaces: boolean;    /** Scrollback: commands echoed, results and errors. */    readonly lines: ReadonlyArray<CommandLineEntry>;    /** Autocomplete matches for the current buffer; empty when nothing typed. */    readonly suggestions: ReadonlyArray<CommandSuggestion>;    /**     * The command language's BCP 47 tag, for the `lang` of whatever shows the     * prompts — English on an Arabic page, whose command language is global.     */    readonly lang: string;}
export type { CommandOptionUi }/** * A keyword the running command offers, resolved into the command language: * AutoCAD's `[Close/Undo]`, one entry per word. */export interface CommandOptionUi {    /** The global keyword the tool receives, whatever was typed. */    readonly id: string;    /** The word in the command language, its abbreviation in capitals. */    readonly keyword: string;    readonly abbreviation: string;    /** What the chip and the prompt show, e.g. `Close` or `Erase: Yes`. */    readonly label: string;}
export type { CommandSuggestion }/** A command offered by autocomplete while typing. */export interface CommandSuggestion {    readonly name: string;    readonly description: string;}
export type { CompassLetter }export type CompassLetter = "N" | "E" | "S" | "W";
export { ConstraintType }/** * Drawing constraints ("aids") that restrict where a point can land, such as * AutoCAD's Ortho or Polar tracking. They are deliberately kept separate from * object snaps: snaps *attract* the cursor to existing geometry, while * constraints *restrict* the cursor relative to a base point. The two compose * in a pipeline (snap first, then constraints) so, for example, an Ortho line * can still lock onto the X of a snapped endpoint. */export declare enum ConstraintType {    Ortho = "ortho",    Polar = "polar"}
export type { DimStyleInfo }export interface DimStyleInfo extends DimStyle {    readonly entityCount: number;}
export type { DynamicFieldKind }/** * Dynamic input is AutoCAD's floating "type a value near the cursor" mechanism. * It is deliberately part of the engine's tool system rather than a React * widget: a tool opens a *session* describing one or more typed fields (a * distance today; radius, angle, coordinates or offsets tomorrow) and provides * a `commit` callback. React merely renders whatever fields the session * exposes and forwards keystrokes back through the engine. * * This keeps the semantics (what a value means, how it is applied) with the * tool, and makes the whole feature reusable for any future measurement input. */export type DynamicFieldKind = "distance" | "length" | "angle" | "number"/** A whole point typed as an AutoCAD coordinate (e.g. `@30,0`, `100<45`). */ | "coordinate"/** * Free text — the content of an annotation. Never resolves to a number, so a * session using one is committed through {@link DynamicInputSession.commitRaw}. */ | "text"/** * A word typed as text that answers like a value — the prompt's keywords * and a transparent command are read from it, as from a number: SETVAR's * variable name and a string variable's value (desktop workspace/d07-4). * Never read as a number: {@link DynamicInputSession.commitRaw} takes it. */ | "word"/** Free text over several lines (MTEXT): Enter breaks a line, Ctrl+Enter commits. */ | "paragraphs";
export type { DynamicInputFieldUi }/** One dynamic-input field, formatted for display by the UI. */export interface DynamicInputFieldUi {    readonly id: string;    readonly label: string;    readonly kind: DynamicFieldKind;    /** The text the user has typed (controlled by the UI). */    readonly value: string;    /** Formatted live value shown as a placeholder when nothing is typed. */    readonly placeholder: string;    /** Unit label shown after the field, e.g. `mm` or `°`. */    readonly unitSuffix: string;    readonly active: boolean;}
export type { DynamicInputUi }/** Snapshot of the active dynamic-input session for the UI. */export interface DynamicInputUi {    /** Screen (CSS-pixel) position to anchor the floating input near. */    readonly screen: Vec2;    /**     * The dynamic prompt: the running command's question without its name,     * `Specify first point:`; null when it names none. A line a command shows     * above the question comes first, after it a `\n` (DIST's `Distance = …`).     */    readonly prompt: string | null;    readonly fields: ReadonlyArray<DynamicInputFieldUi>;    /**     * How far below its place the box starts (CSS pixels): it clears the     * tooltips the scene stacks under the cursor, a snap's name and Polar's     * reading, which take AutoCAD's place there.     */    readonly clearance: number;}
export type { EngineNames }/** * What the engine names, in the interface language (`EngineState.names`): a * host draws these words and never keeps a copy of its own, so a menu and the * engine cannot disagree and a language changes them all at once. Each table * is keyed by the id the engine hands the host elsewhere in its state. * * Tool labels and aliases are `EngineState.tools`, a command's name and * description `commandCatalog()`, property rows `properties.info`; everything * else the host's own chrome says is the host's. */export interface EngineNames {    /** Object snaps, by `SnapType`: the snap menus and the status bar's list. */    readonly snaps: Readonly<Record<SnapType, string>>;    /** The standard colours, by `STANDARD_COLORS[].id`. */    readonly colors: Readonly<Record<string, string>>;    /** ByLayer, for the colour, linetype and lineweight pickers. */    readonly byLayer: string;    /**     * Linetypes, by `LINETYPES[].id`. One without an entry shows its id: a     * linetype's name is the drawing's data, the same in every language.     */    readonly linetypes: Readonly<Record<string, string>>;    /** The preset views (`state.view.preset`), and `custom` for any other. */    readonly views: Readonly<Record<ViewPreset | "custom", string>>;    /** The ViewCube's face labels, by the faces of `state.viewCube`. */    readonly viewCubeFaces: Readonly<Record<ViewCubeFace, string>>;    /** The ViewCube's compass letters, by `state.viewCube`'s compass. */    readonly compass: Readonly<Record<CompassLetter, string>>;}
export type { EngineState }/** Immutable snapshot of engine state consumed by the React UI. */export interface EngineState {    readonly activeToolId: string;    readonly tools: ReadonlyArray<{        id: string;        label: string;        shortcut?: string;    }>;    readonly entityCount: number;    readonly selectionCount: number;    readonly scale: number;    /**     * The view the viewport control names: the preset the camera looks along     * (in the WCS, as -VIEW sets it), or `null` for a custom view.     */    readonly view: {        readonly preset: ViewPreset | null;    };    /** The ViewCube, already projected for the current camera and UCS. */    readonly viewCube: ViewCubeUi;    /**     * The ViewCube's UCS menu: the current UCS (the WCS, a saved one by name, or     * neither — `*NO NAME*`) and the saved UCSs it can restore.     */    readonly ucsMenu: {        readonly world: boolean;        readonly name: string | null;        readonly named: readonly string[];    };    /**     * The cursor as the status bar reads it: in the current UCS, on the     * elevation plane (AutoCAD's COORDS shows X, Y and Z).     */    readonly cursorUcs: Vec3 | null;    /**     * `cursorUcs` as the status bar writes it, `1.5000, 2.0039, 0.0000`: each     * value at LUPREC, a zero unsigned (Absolute, COORDS 1).     */    readonly coordinates: string | null;    readonly snap: {        type: SnapType;        point: Vec3;    } | null;    readonly snapActive: boolean;    readonly snapEnabled: Readonly<Record<SnapType, boolean>>;    /**     * The one-shot object-snap override forced for the next point (AutoCAD's     * Shift+right-click), `"none"` to suppress snapping for it, or null when the     * running snaps apply.     */    readonly snapOverride: SnapType | "none" | null;    /**     * Screen position at which to pop the object-snap override menu, or null when     * it is closed.     */    readonly snapOverrideMenu: Vec2 | null;    /** The shortcut menu a right-click opened, or null when it is closed. */    readonly shortcutMenu: ShortcutMenuUi | null;    readonly orthoActive: boolean;    /** Polar tracking (AutoCAD's POLAR / F10) on/off. */    readonly polarActive: boolean;    /** Polar tracking angle increment in degrees (e.g. 45). */    readonly polarAngleStep: number;    readonly objectSnapTrackingActive: boolean;    readonly acquiredTrackingPoints: number;    /** Selection cycling: the badge, the candidate list and its settings. */    readonly selectionCycling: SelectionCyclingUi;    /** The rollover tooltip, or null when the cursor is over no object at `Command:`. */    readonly rollover: RolloverUi | null;    readonly gridVisible: boolean;    /** Snap mode (AutoCAD's SNAP / F9): the cursor is forced onto increments. */    readonly snapModeActive: boolean;    /** Whether snap uses the rectangular lattice or polar distance increments. */    readonly snapModeType: SnapModeType;    /** Snap lattice spacing in drawing units (AutoCAD's SNAPUNIT). */    readonly snapSpacing: Vec2;    /** Polar snap distance increment (AutoCAD's POLARDIST). */    readonly snapPolarDistance: number;    readonly dynamicInput: DynamicInputUi | null;    readonly documentUnit: LengthUnit;    readonly documentPrecision: number;    /** AUPREC: the decimal places angles are written with. */    readonly documentAnglePrecision: number;    /** Global linetype scale (AutoCAD's LTSCALE). */    readonly ltScale: number;    /** The current dimension style's overall scale (AutoCAD's DIMSCALE). */    readonly dimScale: number;    /** Whether lineweights are drawn at real thickness (AutoCAD's LWDISPLAY). */    readonly lwDisplay: boolean;    /** All layers with live entity counts, for the layer manager. */    readonly layers: ReadonlyArray<LayerInfo>;    /** The layer new geometry is drawn on. */    readonly currentLayerId: LayerId;    /** CECOLOR: the colour new objects take, a hex value or `"ByLayer"`. */    readonly currentColor: EntityColor | "ByLayer";    /** CELTYPE: the linetype new objects take, a linetype's id or `"ByLayer"`. */    readonly currentLinetype: LinetypeId | "ByLayer";    /** CELWEIGHT: the lineweight new objects take, in millimetres, or `"ByLayer"`. */    readonly currentLineweight: Lineweight | "ByLayer";    readonly canUndo: boolean;    readonly canRedo: boolean;    /** Transparent auto-save lifecycle, drives the save button's spinner. */    readonly saveState: SaveState;    /** Epoch millis of the last successful auto-save, or null if never saved. */    readonly lastSavedAt: number | null;    /** The Properties palette: its type filter and what it edits. */    readonly properties: PropertiesUi;    /**     * The layer shared by every selected entity, or null when the selection is     * empty or spans multiple layers. Drives the ribbon's layer drop-down.     */    readonly selectionLayerId: LayerId | null;    /**     * The colour shared by every selected entity for the properties picker:     * `"ByLayer"` when they all inherit their layer, a hex value when they share     * one override, or null when the selection is empty or mixed.     */    readonly selectionColor: EntityColor | "ByLayer" | null;    /**     * The linetype shared by every selected entity for the properties picker:     * `"ByLayer"` when they all inherit their layer, a concrete id when they share     * one override, or null when the selection is empty or mixed.     */    readonly selectionLinetype: LinetypeId | "ByLayer" | null;    /**     * The lineweight shared by every selected entity, as     * {@link selectionLinetype}: `"ByLayer"`, a millimetre value, or null.     */    readonly selectionLineweight: Lineweight | "ByLayer" | null;    /** Every text style with the number of objects using it (the STYLE table). */    readonly textStyles: ReadonlyArray<TextStyleInfo>;    /** The style new text is created with. */    readonly currentTextStyleId: TextStyleId;    /** Every dimension style with its usage count (the DIMSTYLE table). */    readonly dimStyles: ReadonlyArray<DimStyleInfo>;    /** The style new dimensions are created with. */    readonly currentDimStyleId: DimStyleId;    /** Which style table the Styles palette shows. */    readonly stylesTable: StylesPanelTab;    /** Every block defined in the drawing (the Blocks palette's Current tab). */    readonly blocks: ReadonlyArray<BlockInfo>;    /** The palette panel: open or folded, and the palette it shows. */    readonly palette: PaletteUi;    /** Whether the Drawing Units dialog (UNITS) is showing. */    readonly unitsDialog: boolean;    /**     * The task dialog `Properties - Locked objects`, with how many objects on a     * locked layer an edit left out of the selection, or null while it is not     * showing (desktop properties/d03-6).     */    readonly lockedObjectsDialog: {        readonly removed: number;    } | null;    /**     * The task dialog `Multiline Text - Unsaved Changes`: Escape in MTEXT's     * editor, or TEXTEDIT's on an MTEXT, found changes (desktop text/d05-5).     * Answered with `answerUnsavedText`.     */    readonly unsavedTextDialog: boolean;    /** Clean Screen (CLEANSCREENON / CLEANSCREENOFF, Ctrl+0). */    readonly cleanScreen: CleanScreenUi;    /**     * Command options (keywords) the active tool currently offers — AutoCAD's     * `[Close/Undo]` prompt. The UI renders these as hint chips near the dynamic     * input; empty when the tool exposes none.     */    readonly commandOptions: ReadonlyArray<CommandOptionUi>;    /**     * The dynamic prompt's option list, opened by the Down arrow: null while     * shut. `marked` is the option Enter picks (AutoCAD's dot), the id of one of     * `commandOptions`, or null before a second Down marks the first.     */    readonly commandOptionList: {        readonly marked: string | null;    } | null;    /** The command prompt: what is typed, what it suggests and what it logged. */    readonly commandLine: CommandLineUi;    /**     * The engine's vocabulary for a host's menus and pickers — object snaps,     * colours, ByLayer, linetypes — in the interface language. The same object     * until the language changes.     */    readonly names: EngineNames;}
export type { LayerInfo }/** A layer plus its live entity count, ready for the layer manager UI. */export interface LayerInfo extends Layer {    /** How many entities currently live on this layer. */    readonly entityCount: number;}
export type { ObjectType }/** * An object type of the Properties palette's drop-down: an entity's, but an * array is a type of its own, its kind's, apart from the block references * (`Array (Rectangular)`, desktop properties/d06-2). */export type ObjectType = EntityType | `${ArrayKind}Array` | `${DimensionKind}Dimension`;
export { PALETTE_TABS }/** The palette panel's tabs, in their order. */export declare const PALETTE_TABS: readonly [    "properties",    "layers",    "blocks",    "styles"];
export type { PaletteTab }export type PaletteTab = (typeof PALETTE_TABS)[number];
export type { PaletteUi }/** * The docked palette panel: which palette it shows and whether it is open or * folded to its strip. Modeless, as AutoCAD's palettes are: nothing on the * drawing closes it, only its own button, its tab's trigger or a CLOSE command. */export interface PaletteUi {    readonly open: boolean;    readonly tab: PaletteTab;}
export { POINT_FILTERS }/** * The point filters AutoCAD's Point Filters menu lists, in its order, with a * separator before `.XY` (acad.cuix's `ID_MnPointFi`). */export declare const POINT_FILTERS: readonly [    ".X",    ".Y",    ".Z",    ".XY",    ".XZ",    ".YZ"];
export type { PointFilterName }/** A point filter as the Point Filters menu types it. */export type PointFilterName = (typeof POINT_FILTERS)[number];
export { POLAR_ANGLE_MENU }/** * POLARANG's increments as the status bar's Polar ▾ offers them (desktop * workspace/d01-m), each written with its first four multiples rounded: * `90, 180, 270, 360...`, 22.5 as `23, 45, 68, 90...` (e01-4). Choosing one * is `choosePolarAngle(step)`. */export declare const POLAR_ANGLE_MENU: readonly {    readonly step: number;    readonly label: string;}[];
export type { PromptSegment }/** A span of a prompt: text, or the bracketed keyword list. */export interface PromptSegment {    readonly text: string;    /** The `[Close/Undo]` span, which a host may set apart. */    readonly keywords: boolean;}
export type { PropertiesFilterOption }/** One entry of the Properties palette's object type drop-down. */export interface PropertiesFilterOption {    /** The type it narrows the palette to; null is All. */    readonly type: ObjectType | null;    /** `All (6)`, `Line (5)`, `Array (Rectangular) (1)`. */    readonly label: string;}
export type { PropertiesUi }/** * What the Properties palette shows and edits: the selection, narrowed to one * object type when its drop-down picks one ("modify the properties of a single * object type at a time"). Every value is the narrowed objects'; the ribbon's * drop-downs read the whole selection (`selectionLayerId` and its siblings). */export interface PropertiesUi {    /**     * The drop-down's entry: the type picked, the only type when the selection     * has one, or null for All.     */    readonly filter: ObjectType | null;    /**     * All first when the selection mixes types, then each type, most objects     * first; empty with nothing selected.     */    readonly filters: ReadonlyArray<PropertiesFilterOption>;    /** Geometric properties of the objects edited, or null with nothing selected. */    readonly info: SelectionInfo | null;    /** As `selectionLayerId`, over the objects edited. */    readonly layerId: LayerId | null;    readonly color: EntityColor | "ByLayer" | null;    readonly linetype: LinetypeId | "ByLayer" | null;    readonly lineweight: Lineweight | "ByLayer" | null;    /** The style shared by every edited text object, else null. */    readonly textStyleId: TextStyleId | null;    /** The style shared by every edited dimension, else null. */    readonly dimStyleId: DimStyleId | null;}
export type { PropertyEdit }/** Makes a property row typeable, the way AutoCAD's Properties palette is. */export interface PropertyEdit {    readonly property: EntityProperty;    /** Bare number to seed the input with (no unit). */    readonly text: string;    /** Unit shown after the input, e.g. `mm` or `°`. */    readonly unit: string;    /**     * A value picked from a list (a polyline's Closed) rather than typed: each     * choice's `value` is the text handed back, `text` the current one.     */    readonly choices?: ReadonlyArray<{        readonly value: string;        readonly label: string;    }>;}
export type { PropertyGroup }/** A titled group of related properties (e.g. "Geometry"). */export interface PropertyGroup {    readonly id: string;    readonly title: string;    readonly rows: ReadonlyArray<PropertyRow>;}
export type { PropertyRow }/** A single label/value line shown in the properties panel. */export interface PropertyRow {    /** Stable across languages, unlike the label: a React key. */    readonly id: string;    readonly label: string;    readonly value: string;    /** Present when the value can be retyped to change the geometry. */    readonly edit?: PropertyEdit;}
export type { RolloverUi }/** * AutoCAD's rollover tooltip (ROLLOVERTIPS 1): the object under the cursor at * `Command:`, its type and its Color, Layer and Linetype (desktop d20). */export interface RolloverUi {    readonly id: EntityId;    /** Where the cursor stood as it came over the object, in canvas pixels. */    readonly at: Vec2;    /** The object's type, as the palette titles it ("Line"). */    readonly title: string;    /** Its colour's name (ByLayer, Red, or the colour as stored). */    readonly color: string;    /** The colour it shows, for the swatch. */    readonly swatch: string;    readonly layer: string;    readonly linetype: string;}
export type { SelectionCandidateUi }/** One of the overlapping objects offered by selection cycling. */export interface SelectionCandidateUi {    readonly id: EntityId;    /** Object type, as AutoCAD's Selection list box names them ("Line"). */    readonly label: string;}
export type { SelectionCyclingUi }/** Snapshot of selection cycling (AutoCAD's SELECTIONCYCLING) for the UI. */export interface SelectionCyclingUi {    readonly active: boolean;    /** Whether a click over a stack offers the Selection list box (value 2). */    readonly showList: boolean;    /** Objects under the pick box, topmost first; the badge shows when > 1. */    readonly candidates: ReadonlyArray<SelectionCandidateUi>;    /** The candidate a pick resolves to right now (Shift+Space walks these). */    readonly currentId: EntityId | null;    /** Screen position of the open Selection list box, or null when closed. */    readonly listAt: Vec2 | null;}
export type { SelectionInfo }/** * Description of the current selection for the properties panel, modelled on * AutoCAD's Properties palette. `null` when nothing is selected. */export interface SelectionInfo {    /** Heading, e.g. "Line", "Circle" or "3 objects". */    readonly title: string;    readonly count: number;    /** Rows of the palette's General section after its pickers (Thickness). */    readonly general: ReadonlyArray<PropertyRow>;    readonly groups: ReadonlyArray<PropertyGroup>;}
export type { SelectionScope }/** * What a selection edit applies to: the whole selection (the ribbon's * drop-downs) or the objects the Properties palette's type filter leaves. */export type SelectionScope = "selection" | "properties";
export type { ShortcutMenuAction }/** A fixed entry of a shortcut menu; the host words it by this id. */export type ShortcutMenuAction = "repeat" | "cut" | "copy" | "copyBase" | "paste" | "undo" | "redo" | "pan" | "erase" | "move" | "copySelection" | "scale" | "rotate" | "deselectAll" | "properties" | "enter" | "cancel";
export type { ShortcutMenuEntry }export type ShortcutMenuEntry = {    readonly kind: "action";    readonly action: ShortcutMenuAction;}/** A keyword of the prompt, as its brackets show it. */ | {    readonly kind: "option";    readonly option: CommandOptionUi;} | {    readonly kind: "submenu";    readonly submenu: "clipboard";    readonly entries: ReadonlyArray<ShortcutMenuEntry>;}/** Osnap Overrides: the object-snap menu Shift+right-click opens. */ | {    readonly kind: "snapOverrides";}/** * Dimension Style ▸ over a selection of dimensions: the table's styles, the * one they share marked (null when they differ). */ | {    readonly kind: "dimensionStyle";    readonly styles: ReadonlyArray<{        readonly id: DimStyleId;        readonly name: string;    }>;    readonly current: DimStyleId | null;};
export type { ShortcutMenuMode }/** * AutoCAD's three shortcut menus of the drawing area (SHORTCUTMENU 11): Default * with no command and nothing selected, Edit with objects selected, Command * while a command offers options. */export type ShortcutMenuMode = "default" | "edit" | "command";
export type { ShortcutMenuUi }/** The shortcut menu a right-click opened on the drawing. */export interface ShortcutMenuUi {    readonly mode: ShortcutMenuMode;    /** Where it opened, in the canvas's pixels. */    readonly at: Vec2;    /** Its entries in AutoCAD's order, in the groups a separator parts. */    readonly groups: ReadonlyArray<ReadonlyArray<ShortcutMenuEntry>>;    /** The command Repeat runs, as the command line names it. */    readonly repeat: string | null;}
export type { SnapModeType }/** * How the cursor is forced onto an increment: onto a rectangular lattice of * X/Y spacings, or onto distance increments measured along the engaged * Ortho/Polar alignment path (AutoCAD's SNAPTYPE). */export type SnapModeType = "grid" | "polar";
export { SnapType }/** * The kinds of snap the engine understands. Only a subset is implemented today, * but the type is exhaustive so new providers can be added without touching the * rest of the system. This mirrors the object-snap ("OSNAP") vocabulary of * classic CAD tools. */export declare enum SnapType {    Endpoint = "endpoint",    Midpoint = "midpoint",    Center = "center",    Intersection = "intersection",    /**     * The point where two entities *would* meet if one or both were extended —     * AutoCAD's "Apparent Intersection". Distinct from {@link Intersection},     * which requires the geometries to actually cross.     */    ApparentIntersection = "apparentIntersection",    Perpendicular = "perpendicular",    Tangent = "tangent",    /** The point a text object hangs off — AutoCAD's "Insertion". */    Insertion = "insertion",    /**     * A point on the imaginary prolongation of a line, beyond its endpoints —     * AutoCAD's "Extension". Lets a new point land on the line's extension.     */    Extension = "extension",    /**     * A point that keeps the segment being drawn *parallel* to an existing line —     * AutoCAD's "Parallel". Needs a base point (the anchor), so it only offers     * candidates while a point is pending.     */    Parallel = "parallel",    /** The 0°/90°/180°/270° cardinal points of a circle. */    Quadrant = "quadrant",    Nearest = "nearest"}
export type { StylesPanelTab }/** Which of the two style tables the manager is showing. */export type StylesPanelTab = "dimension" | "text";
export type { TextStyleInfo }/** * A style plus how many objects wear it, for the style managers. The count is * what lets the UI grey out a delete AutoCAD would refuse ("you cannot delete a * style that is current or in use"). */export interface TextStyleInfo extends TextStyle {    readonly entityCount: number;}
export { VIEW_MENU }/** The preset views as the viewport controls' view menu lists them. */export declare const VIEW_MENU: readonly ViewPreset[];
export type { ViewCubeFace }/** * AutoCAD's ViewCube as a model: its 26 parts, the view each one shows, and * what the cube looks like from the current camera, already projected, so a * host draws it without a line of geometry. Everything is in the frame of the * current UCS, which the cube is oriented to (NAVVCUBEORIENT 1). */export type ViewCubeFace = "top" | "bottom" | "front" | "back" | "left" | "right";
export type { ViewCubePart }/** * A face, an edge or a corner, named by the faces it touches: the top or the * bottom first, then the left or the right, then the front or the back * (`top`, `top-front`, `left-front`, `top-left-front`). */export type ViewCubePart = string;
export type { ViewCubeRoll }/** Which way the roll arrows turn the scene on the screen. */export type ViewCubeRoll = "clockwise" | "counterclockwise";
export type { ViewCubeSide }/** The neighbour a face view's triangles turn to, by where it is on the screen. */export type ViewCubeSide = "up" | "down" | "left" | "right";
export type { ViewCubeTarget }/** * What a press on the ViewCube landed on: a part, a compass letter (a drag * from it turns the ring), or the ring itself. */export type ViewCubeTarget = {    readonly part: ViewCubePart;} | {    readonly letter: CompassLetter;} | {    readonly ring: true;};
export type { ViewCubeUi }/** What `EngineState` gives a host to draw the ViewCube with. */export interface ViewCubeUi {    /** NAVVCUBE. */    readonly visible: boolean;    /** The faces turned to the viewer, farthest first. */    readonly faces: readonly ViewCubeFaceUi[];    readonly compass: ViewCubeCompassUi;    /** The part the view looks along (a solid outline), or `null` (dashed). */    readonly current: ViewCubePart | null;    /** A face view: the roll arrows and the four triangles are on offer. */    readonly faceView: boolean;}
export type { ViewPreset }export type ViewPreset = keyof typeof VIEW_PRESETS;
export { ZOOM_MENU }/** * The Zoom drop-down's members that exist here, in the ribbon's order * (Extents, Window, Previous, …, In, Out); Realtime, All, Dynamic, Scale, * Center and Object are not offered. Each runs as `zoom(option)`. */export declare const ZOOM_MENU: readonly ZoomOption[];
export type { ZoomOption }/** A member of the navigation bar's Zoom drop-down. */export type ZoomOption = "extents" | "window" | "previous" | "in" | "out";

export { commandCatalog }/** * Every command the prompt accepts — name, aliases and description, in * `locale`'s command language — read off a headless runtime rather than * restated, so a list built from it (the landing's catalogue, its counts) is * exactly the table the editor registers. */export declare function commandCatalog(locale?: EngineLocale): CommandInfo[];
export type { CommandInfo }/** A command as it is listed: the name, what else can be typed, what it does. */export interface CommandInfo {    /** The global name, the same in every language, e.g. `"LINE"`. */    readonly id: string;    /** The name in the command language, e.g. `"LINE"`. */    readonly name: string;    /** Extra uppercase forms that run it, e.g. `["L"]`. */    readonly aliases: readonly string[];    /** One-line description shown in the autocomplete list. */    readonly description: string;}
export { matchCommands }/** * Autocomplete: commands whose name or any alias starts with what has been * typed, best match first (an exact alias beats a name prefix), like AutoCAD's * suggestion list. */export declare function matchCommands(commands: readonly Pick<CommandInfo, "name" | "aliases" | "description">[], text: string, limit?: number): CommandSuggestion[];

export type { Clipboard }/** * The system clipboard, behind COPYCLIP / CUTCLIP / PASTECLIP. Both halves are * asynchronous because the browser's is: a write can be refused and a read can * prompt for permission or not exist at all. Neither is an error the user needs * to hear about — the runtime keeps what it last copied, so copy and paste go * on working inside the session whatever the host answers. */export interface Clipboard {    /** Puts `text` on the clipboard. Rejects when the host refuses. */    write(text: string): Promise<void>;    /** The clipboard's text, or `null` when there is none. */    read(): Promise<string | null>;}
export { createLocalStorageDrawingStore }/** * localStorage implementation of the {@link DrawingStore} port. Returns `null` * outside the browser (SSR) so the application core stays environment-safe. * Failures are swallowed by contract: storage may be full or blocked (private * mode); manual file save still works. */export declare function createLocalStorageDrawingStore(): DrawingStore | null;
export { createMemoryDrawingStore }/** * A {@link DrawingStore} that lives only as long as the page: what an engine * embedded beside the editor autosaves to, so it can never write over the * drawing this device keeps for the editor. `initial` is what it restores. */export declare function createMemoryDrawingStore(initial?: string | null): DrawingStore;
export type { DrawingStore }/** * Key/value persistence for the transparent auto-save. Implemented by * localStorage in the browser; could be a file or IndexedDB elsewhere. */export interface DrawingStore {    /** Returns the stored drawing text, or `null` when none exists / unreadable. */    read(): string | null;    /** Persists the drawing text. Failures must not throw (fail quietly). */    write(text: string): void;}
export type { DrawingSummary }/** What a page needs to know about a drawing without loading it. */export interface DrawingSummary {    /** Top-level objects in the drawing (block contents are not counted). */    readonly objects: number;    /** Entries in its layer table, the base layer included. */    readonly layers: number;}
export type { FileTransport }/** * Explicit file save/open, the counterpart of {@link DrawingStore}'s implicit * auto-save. Implemented by a download + file picker in the browser; a host * embedding the engine can point it at its own backend instead. */export interface FileTransport {    /** Hands the drawing text to the user as a named file. */    save(text: string, fileName: string): void;    /**     * Asks the user for a drawing file. Resolves with its text, or with `null`     * when the pick was cancelled. Rejects only when the file cannot be read.     */    open(): Promise<string | null>;}
export { readSavedDrawingSummary }/** * What is auto-saved on this device, without loading it — so a page outside the * editor can offer to continue a drawing without knowing where it is kept. Null * when there is none, it is unreadable, or there is no browser storage. */export declare function readSavedDrawingSummary(): DrawingSummary | null;
export type { SaveState }/** Lifecycle of the transparent auto-save, surfaced to the UI save button. */export type SaveState = "idle" | "saving" | "saved";

export { buildDrawingPreview }/** * The drawing, or part of it, as a neutral scene with nothing but the objects: * no grid, cursor, snap markers or selection. It is built by the very scene * builder the editor draws with, so a preview can never disagree with how the * drawing looks. Null when there is nothing to frame. */export declare function buildDrawingPreview(document: DocumentReader, options: DrawingPreviewOptions): Scene | null;
export type { CameraTransform }/** * The world↔screen mapping the scene builder needs. The application layer's * `Viewport` satisfies it structurally; keeping the scene layer typed against * this minimal interface avoids a dependency on the application layer. */export interface CameraTransform {    readonly width: number;    readonly height: number;    readonly scale: number;    /** A plan view's twist: radians CCW from world X to the direction drawn pointing right. */    readonly twist: number;    /** True when the view looks straight down the world Z axis, so a point's Z does not show. */    readonly isPlan: boolean;    worldToScreen(p: Vec2 | Vec3): Vec2;    screenToWorld(p: Vec2): Vec2;    worldToScreenDistance(distance: number): number;}
export { CanvasScenePresenter }/** * Canvas 2D render adapter: walks the neutral {@link Scene} display list and * draws it. This is the only place in the system that talks to * `CanvasRenderingContext2D`; an SVG or WebGL presenter could replace it * without touching the core. */export declare class CanvasScenePresenter {    /**     * Draws a full frame. `dpr` scaling is applied here so the scene stays in     * CSS pixels.     */    draw(ctx: CanvasRenderingContext2D, scene: Scene, dpr: number): void;}
export type { DrawingPreviewOptions }export interface DrawingPreviewOptions {    /** Frame size in screen pixels. */    readonly width: number;    readonly height: number;    /** Breathing room around the framed rectangle, in screen pixels. */    readonly padding?: number;    /** What to draw: the whole drawing by default. */    readonly entities?: readonly Entity[];    /**     * What the camera frames: the whole drawing by default. Because the default     * does not depend on `entities`, previews of different parts of one drawing     * share a camera and overlay each other to the pixel.     */    readonly frame?: Bounds;    /**     * Draw lineweights (LWDISPLAY). Off by default: a thumbnail is a shape, not a     * plot, and real lineweights would blot a small one out.     */    readonly lwDisplay?: boolean;}
export { primitiveLength }/** * How far a primitive's outline runs on screen — what a plotter would travel — * so an animation can give long strokes more time than short ones. */export declare function primitiveLength(p: ScenePrimitive): number;
export type { Scene }export interface Scene {    /** Frame size in CSS pixels. */    readonly width: number;    readonly height: number;    readonly background: string;    readonly primitives: readonly ScenePrimitive[];    /**     * The BCP 47 tag of the command language its labels are in. A presenter     * sets it on its text so that the page's own language — Arabic around an     * English command language — never changes the fonts a generic family     * (`monospace`) resolves to: the drawing looks the same in every page.     */    readonly lang?: string;}
export type { ScenePrimitive }export type ScenePrimitive = {    readonly kind: "segment";    readonly a: Vec2;    readonly b: Vec2;    readonly stroke: StrokeStyle;} | {    readonly kind: "circle";    readonly center: Vec2;    readonly radius: number;    readonly stroke?: StrokeStyle;    readonly fill?: string;} | {    /**     * A circular arc. Angles are in *screen* space (already transformed);     * `counterclockwise` matches the Canvas 2D `arc()` sweep flag, so the     * builder resolves the world→screen orientation once.     */    readonly kind: "arc";    readonly center: Vec2;    readonly radius: number;    readonly startAngle: number;    readonly endAngle: number;    readonly counterclockwise: boolean;    readonly stroke: StrokeStyle;} | {    /**     * An ellipse or elliptical arc. Like `arc`, everything here is already in     * *screen* space: `rotation` and the two parameters are the arguments the     * Canvas 2D `ellipse()` call takes, so the builder resolves the camera's     * Y flip once instead of every renderer repeating it.     */    readonly kind: "ellipse";    readonly center: Vec2;    readonly radiusX: number;    readonly radiusY: number;    /** Major-axis direction in screen radians (clockwise-positive). */    readonly rotation: number;    readonly startAngle: number;    readonly endAngle: number;    readonly counterclockwise: boolean;    readonly stroke: StrokeStyle;} | {    readonly kind: "rect";    readonly min: Vec2;    readonly width: number;    readonly height: number;    readonly stroke?: StrokeStyle;    readonly fill?: string;} | {    /** A polyline / polygon, e.g. triangle and diamond markers. */    readonly kind: "path";    readonly points: readonly Vec2[];    readonly closed?: boolean;    /**     * Further closed rings filled together with `points` under the even-odd     * rule, so a ring inside another punches a hole — a hatch's islands. The     * same rule decides where a hatch's pattern lines are drawn, so the two     * fill types agree about what is inside.     */    readonly subpaths?: readonly (readonly Vec2[])[];    /**     * Omit on a solid shape. A stroke around a very sharp corner spikes far     * past the vertex through its mitre join — and by a screen-pixel amount,     * so the spike never shrinks with the zoom (see dimension arrowheads).     */    readonly stroke?: StrokeStyle;    /** Solid fill for a closed path, e.g. a dimension arrowhead. */    readonly fill?: string;} | {    readonly kind: "label";    readonly at: Vec2;    readonly text: string;    readonly color: string;    readonly font?: string;} | {    /**     * A *world-space* text object: unlike {@link ScenePrimitive} `label`,     * which is chrome pinned to the screen at a fixed size, this one carries     * the size and angle the drawing gives it, so it zooms and rotates with     * the geometry.     *     * The presenter draws it with a transform, aligned along the baseline     * by the renderer; where the baseline lies is the engine's, which     * places a drawing text by Arial's metrics, not the font's em box.     */    readonly kind: "text";    /** Screen position of the point on the alphabetic baseline it is aligned to. */    readonly at: Vec2;    readonly text: string;    /** Capital-letter height in screen pixels. */    readonly height: number;    /** Baseline rotation in *screen* radians (clockwise-positive). */    readonly rotation: number;    /**     * In a view off the plan, the text's own frame (X along the baseline, Y     * down, the capitals `height` pixels tall) mapped to the screen as the     * canvas's `transform(a, b, c, d)` takes it, in place of `rotation`.     */    readonly matrix?: readonly [        number,        number,        number,        number    ];    readonly align: TextAlign;    readonly color: string;    /** Font family; the presenter supplies a default. */    readonly font?: string;};
export type { StrokeStyle }/** * A renderer-agnostic description of one frame: a flat display list of styled * primitives in *screen* (CSS-pixel) coordinates. * * The application layer builds a {@link Scene} from the document, viewport, * selection and transient interaction state; a concrete adapter (Canvas 2D * today — SVG, WebGL or a test serialiser tomorrow) merely walks the list and * draws. Nothing in here references the DOM, Canvas or React. */export interface StrokeStyle {    readonly color: string;    readonly width: number;    /** Dash pattern in pixels; omitted/empty means solid. A run of 0 is a dot. */    readonly dash?: readonly number[];    /** How far into {@link dash} the stroke starts, in pixels; 0 when absent. */    readonly dashOffset?: number;}
export type { SvgDecorator }/** Extra attributes for one element, e.g. the timing of its animation. */export type SvgDecorator = (primitive: ScenePrimitive, index: number) => Readonly<Record<string, string | number>> | undefined;
export type { SvgDocumentOptions }export interface SvgDocumentOptions {    /** Accessible name, emitted as `<title>` with `role="img"`. */    readonly title?: string;    /** Longer accessible description, emitted as `<desc>`. */    readonly description?: string;    /** Paint the scene's background; off when the page behind is the sheet. */    readonly background?: boolean;    /** Extra attributes for the root `<svg>`. */    readonly attributes?: Readonly<Record<string, string | number>>;}
export { SvgScenePresenter }/** * SVG render adapter: the twin of `CanvasScenePresenter`, walking the same * neutral {@link Scene} but returning markup instead of drawing. It runs * anywhere — at build time on a server, in a test — because it touches no DOM. * A primitive kind added to the scene needs a branch here as well. */export declare class SvgScenePresenter {    constructor(options?: SvgScenePresenterOptions);    /** A standalone `<svg>` document for the whole scene. */    render(scene: Scene, options?: SvgDocumentOptions): string;    /** Just the elements, for a caller that groups or times them itself. */    elements(primitives: readonly ScenePrimitive[], decorate?: SvgDecorator): string;}
export type { SvgScenePresenterOptions }export interface SvgScenePresenterOptions {    /**     * The command language its labels are in (`Scene.lang`), set on every text     * so the page's language never changes the font a generic family picks.     */    readonly lang?: string;    /**     * Maps a scene colour to what the SVG writes — {@link themePalette} turns     * `THEME`'s into CSS custom properties, so a page can restyle the drawing     * without rendering it again. Colours it does not know pass through.     */    readonly palette?: (color: string) => string;    /** Decimals kept in coordinates; one is invisible at any sane zoom. */    readonly precision?: number;    /** Family for `text` primitives that name none. */    readonly fontFamily?: string;    /** Cap height ÷ em of {@link fontFamily}. */    readonly capHeightRatio?: number;    /**     * Prepares every solid stroke to be plotted — `pathLength="1"`, so a CSS     * `stroke-dashoffset` from 1 to 0 draws it along its length whatever its     * size. Dashed strokes and fills are left alone: their dash array is taken.     */    readonly plot?: boolean;    /**     * The frame the elements will be shown in. Segments are clipped to it (see     * {@link clipSegment}). {@link SvgScenePresenter.render} uses the scene's     * own size.     */    readonly frame?: {        readonly width: number;        readonly height: number;    };}
export type { TextAlign }/** Horizontal alignment of a `text` primitive around its point. */export type TextAlign = "left" | "center" | "right";
export { THEME }/** * Colour palette for the technical-drawing look. Pure data — usable by any * render backend and by tools composing overlay primitives. */export declare const THEME: {    readonly background: "#0b0f14";    readonly gridMinor: "rgba(148, 163, 184, 0.08)";    readonly gridMajor: "rgba(148, 163, 184, 0.16)";    readonly axisX: "rgba(248, 113, 113, 0.55)";    readonly axisY: "rgba(74, 222, 128, 0.55)";    /**     * The UCS icon, AutoCAD 2027's 3D one: White in model space, its arms and     * letters alike (desktop ucs/d07-1, d01-2).     */    readonly ucsIcon: "#ffffff";    /**     * The 2D icon's axis colours, which the scene no longer draws (the 3D icon     * is one colour); kept as THEME is public.     */    readonly ucsIconX: "#f87171";    readonly ucsIconY: "#4ade80";    readonly entity: "#e2e8f0";    readonly entityHover: "#cbd5e1";    /**     * The selection's glow, laid over the object as AutoCAD's selection effect     * does: blue at the edges, the object's colour paled beneath (desktop d15).     */    readonly selected: "rgba(59, 130, 246, 0.45)";    /** Cold selection grip (unselected handle) — AutoCAD's blue square. */    readonly grip: "#3b82f6";    /** Hot grip currently being dragged — AutoCAD's red square. */    readonly gripHot: "#ef4444";    /** A selected polar array's ring through its base point, grey (desktop arrays/d11-2). */    readonly arrayRing: "#8a8f96";    /** TRIM's ✕ beside the cursor (desktop trim/d01-1z). */    readonly trimBadge: "#eb5555";    /** The circle-and-slash beside the cursor where a pick is refused (desktop trim/d09-1). */    readonly refusedBadge: "#ffffff";    /** The padlock beside the cursor over a locked layer's object (desktop properties/d01-1). */    readonly lockedBadge: "#ffffff";    /** MATCHPROP's paintbrush beside the pick box (desktop properties/d07-1). */    readonly paintBadge: "#ffffff";    /** The AutoSnap marker, AutoCAD's green as its dark theme draws it (desktop d05, d21). */    readonly snap: "#00a500";    /** The cursor's tooltips (a snap's name, Polar's reading): AutoCAD's light grey box. */    readonly snapTooltipBg: "#999999";    readonly snapTooltipBorder: "#000000";    readonly snapTooltipText: "#000000";    /** The crosshair drawn in place of the OS cursor, and the tracked point's ✕. */    readonly crosshair: "#e4e5e6";    /** OTRACK's paths and acquired points, green as Polar's (desktop d13). */    readonly tracking: "#049606";    readonly trackingSolid: "#049606";    /** Polar tracking's path (desktop d12). */    readonly polar: "#049606";    /**     * The rubber-band line drawn from the last point to the cursor while a draw     * command is active. AutoCAD renders this in the object/layer colour as a     * solid line — it looks just like the segment about to be committed — so it     * matches {@link THEME.entity} rather than a distinct highlight colour.     */    readonly rubberBand: "#e2e8f0";    /**     * AREA's corners: AutoCAD's translucent green, sampled (25,91,37) over     * (33,40,48) (desktop inquiry/d03-1).     */    readonly measureAreaFill: "rgba(0, 255, 0, 0.24)";    /**     * The dashed line PLINE draws from its last vertex at the width prompts and     * along its arc's chord: amber beside a white polyline, so not the object's     * colour (desktop pline/d03, d06).     */    readonly dashedRubberBand: "#d7a320";    readonly preview: "#38bdf8";    readonly selectionWindowFill: "rgba(64, 140, 255, 0.12)";    /**     * The window's outline, white over its blue as AutoCAD draws it, solid; the     * crossing's dashed over its green, and a fence's (desktop erase/d02-1,     * d03-1, d04-2).     */    readonly selectionWindowStroke: "#ffffff";    readonly selectionCrossingFill: "rgba(74, 222, 128, 0.12)";    readonly selectionCrossingStroke: "#ffffff";};
export { themeCustomProperties }/** The declarations {@link themePalette} refers to, e.g. `--cad-entity:#e2e8f0;`. */export declare function themeCustomProperties(prefix?: string): string;
export { themePalette }/** * `THEME`'s colours as CSS custom properties: a palette for * {@link SvgScenePresenter} that writes `var(--cad-entity)` instead of a hex. * Where two roles share a value the first one named in `THEME` wins. */export declare function themePalette(prefix?: string): (color: string) => string;