@womp/mesh-editor 0.1.0

package/README.md

@@ -0,0 +1,33 @@
+# @womp/mesh-editor
+
+Framework-independent browser mesh editing for Womp products.
+
+This package is publicly downloadable but remains proprietary. No license is
+granted for external use.
+
+The package contains the `EditableMesh` model, the `PortableMeshEditor`
+engine, Three.js conversion helpers, and the edit-only reference session. It
+does not include rigging clients, provider integrations, backend platforms, or
+Python workers.
+
+```ts
+import { open_edit_session } from "@womp/mesh-editor/session";
+
+await open_edit_session({
+  title: "Edit mesh",
+  editable_mesh,
+  root_class: "product-mesh-editor-theme",
+  on_commit: async ({ mesh }) => {
+    await persist_mesh(mesh);
+  },
+});
+```
+
+`root_class` scopes the semantic `--womp-mesh-editor-*` theme tokens documented
+in `docs/ui-theming.md`. Omit it to retain the default appearance.
+
+The reference session prepares Dense tessellation before editing, falls back to
+Standard when required by mesh limits, and hides tessellation controls. The
+prepared mesh is the clean session baseline and is returned on commit.
+
+`three@0.184.0` is a peer dependency and must be supplied by the host.

package/dist/browser/src/mesh_editor/editor.d.ts

@@ -0,0 +1,603 @@
+import { SculptNormalWorkerPool } from "./sculpt_normal_workers.js";
+import type { EditableMaterial, EditableMesh, EditableMeshBounds, EditableTexture, Vec2, Vec3 } from "./types.js";
+type ThreeModule = any;
+type ThreeObject = any;
+type UpdateRange = {
+    start: number;
+    count: number;
+};
+export type MeshTessellationFrequency = 2 | 3;
+export interface MeshTessellationEstimate {
+    frequency: MeshTessellationFrequency;
+    vertexCount: number;
+    triangleCount: number;
+    geometryByteLength: number;
+    withinLimits: boolean;
+}
+export interface InitialMeshTessellationResult {
+    mesh: EditableMesh;
+    frequency: MeshTessellationFrequency | null;
+}
+export interface MeshEditorSymmetryOptions {
+    enabled?: boolean;
+    vertical?: boolean;
+    horizontal?: boolean;
+}
+export interface MeshEditorOptions {
+    THREE: ThreeModule;
+    canvas: HTMLCanvasElement;
+    symmetryEnabled?: boolean;
+    symmetryVertical?: boolean;
+    symmetryHorizontal?: boolean;
+    onStatus?: (message: string) => void;
+    onCommit?: (mesh: EditableMesh) => void;
+    onCancel?: () => void;
+    onHistoryChange?: (state: MeshEditorHistoryState) => void;
+}
+export interface MeshEditorHistoryState {
+    canUndo: boolean;
+    canRedo: boolean;
+    dirty: boolean;
+}
+export interface MeshEditorVisualOptions {
+    showVertices?: boolean;
+    showWireframe?: boolean;
+    smoothShading?: boolean;
+}
+interface RefreshGeometryOptions {
+    rebuildWireframe?: boolean;
+    recomputeDerived?: boolean;
+    recomputeNormals?: boolean;
+    recomputeBounds?: boolean;
+    updateStart?: number;
+    updateCount?: number;
+    updateRanges?: UpdateRange[];
+    boundsVertices?: number[];
+    updatePositions?: boolean;
+    updateColors?: boolean;
+}
+interface OrbitState {
+    target: ThreeObject;
+    radius: number;
+    theta: number;
+    phi: number;
+    active: boolean;
+    pointerId: number | null;
+    lastX: number;
+    lastY: number;
+    mode: "orbit" | "pan";
+}
+interface DragState {
+    pointerId: number;
+    vertexIndex: number;
+}
+interface BrushStrokeState {
+    pointerId: number;
+    historyStarted: boolean;
+    sourceStamp: number;
+    lastCenter: Vec3 | null;
+    lastNormal: Vec3 | null;
+    lastTriangleIndex: number | undefined;
+    lastClientX: number;
+    lastClientY: number;
+    queuedClientX: number;
+    queuedClientY: number;
+    distanceSinceSample: number;
+    finishRequested: boolean;
+    finalizeDerived: boolean;
+    movePointerOffset: Vec3;
+    moveAppliedOffset: Vec3;
+}
+interface TexturePaintMetric {
+    uvRadius: number;
+    worldRadius: number;
+    worldFromU: Vec3 | null;
+    worldFromV: Vec3 | null;
+}
+interface TexturePaintTriangle {
+    triangleIndex: number;
+    a: number;
+    b: number;
+    c: number;
+    materialIndex: number;
+    min: Vec3;
+    max: Vec3;
+    maxEdge: number;
+}
+interface MeshSnapshotHistoryEntry {
+    kind: "snapshot";
+    mesh: EditableMesh;
+    revision: number;
+    byteLength: number;
+}
+interface MeshPositionHistoryEntry {
+    kind: "positions";
+    vertexIndices: number[] | Uint32Array;
+    positions: number[] | Float32Array;
+    revision: number;
+    byteLength: number;
+}
+type MeshHistoryEntry = MeshSnapshotHistoryEntry | MeshPositionHistoryEntry;
+interface TexturePaintTriangleIndex {
+    triangles: TexturePaintTriangle[];
+    triangleSlots: Int32Array;
+    cells: Map<string, number[]>;
+    min: Vec3;
+    boundsRadius: number;
+    cellSize: number;
+    invCellSize: number;
+    visited: Uint32Array;
+    visitStamp: number;
+    queue: Uint32Array;
+}
+interface GpuPaintTextureState {
+    textureIndex: number;
+    width: number;
+    height: number;
+    current: ThreeObject;
+    next: ThreeObject;
+    mask: ThreeObject;
+    geometry: ThreeObject | null;
+    maskMesh: ThreeObject | null;
+    readRect: GpuPaintDirtyRect | null;
+    dirty: boolean;
+    synced: boolean;
+}
+interface GpuPaintDirtyRect {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export declare function prepare_initial_mesh_tessellation(mesh: EditableMesh): InitialMeshTessellationResult;
+interface CompactIndexLists {
+    offsets: Uint32Array;
+    values: Uint32Array;
+}
+declare class VertexSpatialIndex {
+    positions: Float32Array;
+    vertexCount: number;
+    min: Vec3;
+    cellSize: number;
+    invCellSize: number;
+    cells: Map<number, Map<number, Map<number, number[]>>>;
+    cellX: Int32Array;
+    cellY: Int32Array;
+    cellZ: Int32Array;
+    cellSlot: Int32Array;
+    constructor(positions: Float32Array, bounds: EditableMeshBounds);
+    cell_coord(value: number, axis: number): number;
+    cell_for(x: number, y: number, z: number, create: boolean): number[] | undefined;
+    delete_empty_cell(x: number, y: number, z: number): void;
+    insert_vertex(vertexIndex: number): void;
+    update_vertices(vertexIndices: number[]): void;
+    query_radius(center: ArrayLike<number>, radius: number, output: number[]): number[];
+    query_cell_visit_count(center: ArrayLike<number>, radius: number): number;
+    should_query_radius(center: ArrayLike<number>, radius: number): boolean;
+}
+declare class GpuTexturePainter {
+    editor: PortableMeshEditor;
+    THREE: ThreeModule;
+    renderer: ThreeObject;
+    camera: ThreeObject;
+    copyScene: ThreeObject;
+    copyMaterial: ThreeObject;
+    copyMesh: ThreeObject;
+    paintScene: ThreeObject;
+    paintMaterial: ThreeObject;
+    paintMesh: ThreeObject;
+    maskScene: ThreeObject;
+    maskMaterial: ThreeObject;
+    dilationScene: ThreeObject;
+    dilationMaterial: ThreeObject;
+    dilationMesh: ThreeObject;
+    clearColor: ThreeObject;
+    textureStates: Map<number, GpuPaintTextureState>;
+    paintVertexCapacity: number;
+    paintPositionArray: Float32Array;
+    paintUvArray: Float32Array;
+    paintWorldArray: Float32Array;
+    failed: boolean;
+    constructor(editor: PortableMeshEditor);
+    can_paint_texture_dimensions(width: number, height: number): boolean;
+    texture_target_bytes(width: number, height: number): number;
+    allocated_target_bytes(excludedTextureIndex?: number): number;
+    can_paint_texture_requests(requests: Array<{
+        key: number;
+        width: number;
+        height: number;
+    }>): boolean;
+    context_lost(): boolean;
+    make_render_target(width: number, height: number, mask: boolean): ThreeObject;
+    render_to_target(target: ThreeObject, clear: boolean, rect: GpuPaintDirtyRect | null, callback: () => void): void;
+    copy_texture_to_target(sourceTexture: ThreeObject, target: ThreeObject, clear: boolean, rect: GpuPaintDirtyRect | null): void;
+    expand_dirty_rect(rect: GpuPaintDirtyRect, width: number, height: number, padding: number): GpuPaintDirtyRect;
+    append_repeat_wrapped_triangle(mesh: EditableMesh, a: number, b: number, c: number, paintPositions: number[], paintUvs: number[], worldPositions: number[]): void;
+    build_geometry(textureIndex: number): ThreeObject | null;
+    ensure_paint_geometry_capacity(vertexCount: number): void;
+    repeat_wrapped_triangle_count(mesh: EditableMesh, a: number, b: number, c: number): number;
+    write_repeat_wrapped_triangle(mesh: EditableMesh, a: number, b: number, c: number, vertexOffset: number): number;
+    update_paint_geometry(textureIndex: number, triangles: TexturePaintTriangle[]): boolean;
+    ensure_state(textureIndex: number): GpuPaintTextureState | null;
+    render_mask(state: GpuPaintTextureState): void;
+    update_preview_texture(textureIndex: number, textureObject: ThreeObject): void;
+    dirty_rect_for_triangles(textureIndex: number, triangles: TexturePaintTriangle[], center: Vec3): GpuPaintDirtyRect | null;
+    merge_dirty_rect(a: GpuPaintDirtyRect | null, b: GpuPaintDirtyRect): GpuPaintDirtyRect;
+    paint(triangles: TexturePaintTriangle[], textureIndices: Set<number>, center: Vec3, radius: number, color: Vec3, exposure: number): number;
+    sync_dirty_textures_to_cpu(fullReadback: boolean): void;
+    dispose(): void;
+}
+export declare class PortableMeshEditor {
+    THREE: ThreeModule;
+    canvas: HTMLCanvasElement;
+    onStatus: (message: string) => void;
+    onCommit: (mesh: EditableMesh) => void;
+    onCancel: () => void;
+    onHistoryChange: (state: MeshEditorHistoryState) => void;
+    tool: string;
+    brushRadius: number;
+    brushStrength: number;
+    brushSoftness: number;
+    brushColor: Vec3;
+    brushSubMode: boolean;
+    symmetryEnabled: boolean;
+    symmetryVertical: boolean;
+    symmetryHorizontal: boolean;
+    symmetryObjectCenter: Vec3;
+    showVertices: boolean;
+    showWireframe: boolean;
+    smoothShading: boolean;
+    effectiveShowVertices: boolean;
+    effectiveShowWireframe: boolean;
+    originalMesh: EditableMesh | null;
+    sessionMesh: EditableMesh | null;
+    undoStack: MeshHistoryEntry[];
+    redoStack: MeshHistoryEntry[];
+    pendingHistoryEntry: MeshHistoryEntry | null;
+    historyActionChanged: boolean;
+    historyPositionStamps: Uint32Array;
+    historyReferencePositions: Float32Array;
+    historyPositionStamp: number;
+    historyTouchedVertices: number[];
+    currentRevision: number;
+    cleanRevision: number;
+    nextRevision: number;
+    preparedCommitRevision: number | null;
+    sessionBoundsRadius: number;
+    brushReferenceRadius: number;
+    brushMeanEdgeLength: number;
+    spatialIndex: VertexSpatialIndex | null;
+    spatialIndexPendingDisplacement: number;
+    texturePaintTriangleIndex: TexturePaintTriangleIndex | null;
+    usableTextureUvs: boolean | null;
+    gpuTexturePainter: GpuTexturePainter | null;
+    vertexWeldGroups: CompactIndexLists;
+    vertexNeighbors: CompactIndexLists;
+    vertexTriangles: CompactIndexLists;
+    triangleMaterialIndices: Uint32Array;
+    boundaryVertices: Uint8Array;
+    spatialQueryResults: number[];
+    surfaceCandidateVertices: number[];
+    surfaceQueueVertices: number[];
+    surfaceCandidateStamps: Uint32Array;
+    surfaceVisitedStamps: Uint32Array;
+    surfaceQueryStamp: number;
+    brushAffectedVertices: number[];
+    brushSortVertices: number[];
+    brushTouchedVertices: Uint32Array;
+    brushTouchedStamp: number;
+    brushSourcePositions: Float32Array;
+    brushSourceStamps: Uint32Array;
+    brushSourceStamp: number;
+    nonAccumulatingSourcePositions: Float32Array;
+    nonAccumulatingSourceNormals: Float32Array;
+    nonAccumulatingInfluences: Float32Array;
+    nonAccumulatingSourceStamps: Uint32Array;
+    nonAccumulatingSourceStamp: number;
+    moveStrokeVertices: number[];
+    moveStrokeWeights: number[];
+    normalAffectedVertices: number[];
+    normalAffectedTriangles: number[];
+    normalTouchedVertices: Uint32Array;
+    normalTouchedStamp: number;
+    normalTriangleStamps: Uint32Array;
+    normalTriangleStamp: number;
+    triangleNormals: Float32Array;
+    sculptNormalWorkers: SculptNormalWorkerPool | null;
+    sculptNormalWorkerSetupHandle: number;
+    deferSculptNormalRefresh: boolean;
+    deferredNormalAffectedVertices: number[];
+    deferredNormalAffectedStamps: Uint32Array;
+    deferredNormalAffectedStamp: number;
+    updateRangeScratch: UpdateRange[];
+    singleUpdateRange: UpdateRange;
+    singleUpdateRangeList: UpdateRange[];
+    pendingDerivedRefresh: boolean;
+    derivedRefreshHandle: number;
+    pendingBrushPositions: number[];
+    brushFrameHandle: number;
+    brushFrameProcessing: boolean;
+    brushIdleResolvers: Array<() => void>;
+    brushFrameBatchDepth: number;
+    brushFrameAffectedVertices: number[];
+    brushFrameAffectedStamps: Uint32Array;
+    brushFrameAffectedStamp: number;
+    brushFrameUpdateStart: number;
+    brushFrameUpdateEnd: number;
+    brushFrameRebuildWireframe: boolean;
+    cursorFrameHandle: number;
+    queuedCursorClientX: number;
+    queuedCursorClientY: number;
+    renderSuppressionDepth: number;
+    renderPending: boolean;
+    dragState: DragState | null;
+    brushStrokeState: BrushStrokeState | null;
+    pointer: ThreeObject;
+    raycaster: ThreeObject;
+    boundsTreeRefitBox: ThreeObject;
+    boundsTreeRefitNodes: Set<number>;
+    boundsTreeRefitCallbacks: ThreeObject;
+    boundsTreeRefitPrepared: boolean;
+    renderer: ThreeObject;
+    scene: ThreeObject;
+    camera: ThreeObject;
+    meshObject: ThreeObject | null;
+    vertexObject: ThreeObject | null;
+    selectedVertexObject: ThreeObject | null;
+    selectedPositionArray: Float32Array;
+    selectedPositionCapacity: number;
+    wireObject: ThreeObject | null;
+    wireMaterial: ThreeObject;
+    brushCursor: ThreeObject;
+    symmetryBrushCursors: ThreeObject[];
+    brushCursorCenter: ThreeObject;
+    brushCursorMaterial: ThreeObject;
+    brushCursorAxis: ThreeObject;
+    brushCursorNormal: ThreeObject;
+    textureObjects: ThreeObject[];
+    materialObjects: ThreeObject[];
+    selectedVertices: Set<number>;
+    dragPlane: ThreeObject;
+    dragPoint: ThreeObject;
+    dragNextPoint: ThreeObject;
+    cameraDirection: ThreeObject;
+    projectedVertex: ThreeObject;
+    boundsPoint: ThreeObject;
+    raycastHits: ThreeObject[];
+    brushDirectionScratch: Vec3;
+    brushCenterScratch: Vec3;
+    brushNormalScratch: Vec3;
+    brushVertexNormalScratch: Vec3;
+    brushPlanePointScratch: Vec3;
+    brushPlaneNormalScratch: Vec3;
+    brushPatternTangentScratch: Vec3;
+    brushPatternBitangentScratch: Vec3;
+    brushStrokeDirectionScratch: Vec3;
+    symmetryCenterScratch: Vec3;
+    symmetryNormalScratch: Vec3;
+    symmetryDirectionScratch: Vec3;
+    symmetrySampleCenters: Float64Array;
+    symmetrySampleNormals: Float64Array;
+    symmetrySampleDirections: Float64Array;
+    dragDeltaScratch: Vec3;
+    moveDeltaScratch: Vec3;
+    pickQueryCenterScratch: Vec3;
+    orbit: OrbitState;
+    _boundResize: () => void;
+    _boundPointerDown: (event: PointerEvent) => void;
+    _boundPointerMove: (event: PointerEvent) => void;
+    _boundPointerLeave: () => void;
+    _boundContextMenu: (event: Event) => void;
+    _boundPointerUp: (event: PointerEvent) => void;
+    _boundPointerCancel: (event: PointerEvent) => void;
+    _boundLostPointerCapture: (event: PointerEvent) => void;
+    _boundWindowBlur: () => void;
+    _boundWheel: (event: WheelEvent) => void;
+    constructor(options: MeshEditorOptions);
+    dispose(): void;
+    mesh_history_byte_length(mesh: EditableMesh): number;
+    create_history_entry(): MeshHistoryEntry | null;
+    ensure_history_position_capacity(vertexCount: number): void;
+    next_history_position_stamp(): number;
+    create_position_history_entry(): MeshPositionHistoryEntry | null;
+    create_inverse_position_history_entry(entry: MeshPositionHistoryEntry): MeshPositionHistoryEntry | null;
+    finalize_position_history_entry(entry: MeshPositionHistoryEntry): void;
+    history_state(): MeshEditorHistoryState;
+    notify_history_change(): void;
+    is_dirty(): boolean;
+    trim_history_memory(): void;
+    begin_history_action(): boolean;
+    begin_position_history_action(): boolean;
+    begin_pointer_history_action(pointerId: number, positionsOnly: boolean): boolean;
+    mark_history_changed(): void;
+    finish_history_action(): void;
+    rollback_history_action(): void;
+    restore_history_entry(entry: MeshHistoryEntry): void;
+    restore_position_history_entry(entry: MeshPositionHistoryEntry): void;
+    undo(): boolean;
+    redo(): boolean;
+    open(mesh: EditableMesh): void;
+    open_with_initial_tessellation(mesh: EditableMesh): MeshTessellationFrequency | null;
+    initialize_open_mesh(mesh: EditableMesh): void;
+    set_tool(tool: string | undefined): void;
+    set_brush_sub_mode(enabled: boolean): void;
+    set_brush(radius: number, strength: number, softness?: number): void;
+    set_brush_world_radius(radius: number, strength: number, softness?: number): void;
+    set_symmetry_vertical(enabled: boolean): void;
+    set_symmetry_horizontal(enabled: boolean): void;
+    set_symmetry(options: MeshEditorSymmetryOptions): void;
+    symmetry_applies_to_active_tool(): boolean;
+    append_symmetry_sample(centerX: number, centerY: number, centerZ: number, normalX: number, normalY: number, normalZ: number, directionX: number, directionY: number, directionZ: number, source: ArrayLike<number>, count: number): number;
+    build_symmetry_samples(center: ArrayLike<number>, normal: ArrayLike<number>, direction?: ArrayLike<number>): number;
+    load_symmetry_sample(index: number): void;
+    ensure_symmetry_cursor_capacity(count: number): void;
+    hide_brush_cursor(): void;
+    position_brush_cursor(cursor: ThreeObject, center: ArrayLike<number>, normal: ArrayLike<number>): boolean;
+    show_brush_cursor(center: ArrayLike<number>, normal: ArrayLike<number>): void;
+    update_brush_cursor_at(clientX: number, clientY: number): void;
+    queue_brush_cursor_update(clientX: number, clientY: number): void;
+    set_brush_color(color: ArrayLike<number> | string | undefined): void;
+    fill_vertex_colors(): boolean;
+    fill_texture_colors(): boolean;
+    clamp_color_component(value: number): number;
+    color_from_hex_string(color: string): Vec3;
+    set_visuals(options: MeshEditorVisualOptions): void;
+    tessellation_estimate(frequency: MeshTessellationFrequency): MeshTessellationEstimate;
+    tessellation_estimates(): [MeshTessellationEstimate, MeshTessellationEstimate];
+    tessellate_all(): EditableMesh;
+    tessellate_all_with_frequency(frequency: MeshTessellationFrequency): EditableMesh;
+    prepare_commit(): EditableMesh;
+    prepare_commit_async(): Promise<EditableMesh>;
+    accept_commit(): void;
+    commit(): EditableMesh;
+    cancel(): EditableMesh | null;
+    apply_vertex_delta(vertexIndex: number, delta: ArrayLike<number>): void;
+    apply_move_delta(center: ArrayLike<number>, delta: ArrayLike<number>, radius: number, rebuildWireframe?: boolean, strength?: number, softness?: number): number;
+    prepare_move_stroke(center: ArrayLike<number>, radius: number, softness: number, seedTriangleIndex?: number): number;
+    apply_prepared_move_delta(delta: ArrayLike<number>, strength: number, rebuildWireframe?: boolean): number;
+    ensure_brush_vertex_capacity(vertexCount: number): void;
+    next_surface_query_stamp(): number;
+    next_brush_source_stamp(): number;
+    cache_brush_source_vertex(vertexIndex: number, positions: Float32Array, stamp: number): void;
+    next_non_accumulating_source_stamp(): number;
+    cache_non_accumulating_source_vertex(vertexIndex: number, positions: Float32Array, normal: ArrayLike<number>, stamp: number): void;
+    build_brush_pattern_basis(normal: ArrayLike<number>, preferredDirection: ArrayLike<number> | undefined, tangentTarget: Vec3, bitangentTarget: Vec3): void;
+    sample_brush_plane(candidateVertices: number[], center: ArrayLike<number>, radius: number, fallbackNormal: ArrayLike<number>, pointTarget: Vec3, normalTarget: Vec3): void;
+    surface_normal_for_vertex(vertexIndex: number, fallback: ArrayLike<number>, positions: Float32Array, target: Vec3): Vec3;
+    next_brush_touched_stamp(): number;
+    query_brush_candidates(center: ArrayLike<number>, radius: number): number[] | null;
+    query_surface_brush_candidates(center: ArrayLike<number>, radius: number, seedTriangleIndex?: number): number[];
+    ensure_color_buffer(): Float32Array;
+    set_mesh_material_vertex_colors(enabled: boolean): void;
+    ensure_material_index(materialIndex: number): EditableMaterial;
+    isolate_vertices_by_material(): boolean;
+    material_indices_for_vertices(vertices: number[]): Set<number>;
+    sample_texture_linear(texture: EditableTexture, u: number, v: number, output: Vec3): void;
+    create_preview_texture(texture: EditableTexture): ThreeObject;
+    refresh_paint_representation(materialIndices: Set<number>): void;
+    create_white_texture_pixels(width: number, height: number): Uint8Array;
+    texture_reference_count(textureIndex: number): number;
+    ensure_texture_data_for_material(materialIndex: number): number;
+    ensure_texture_for_material(materialIndex: number, refreshExisting: boolean): number;
+    prepare_vertex_paint_representation(materialIndices: Set<number>): boolean;
+    prepare_texture_paint_representation(materialIndices: Set<number>): boolean;
+    refresh_material_texture(textureIndex: number, materialIndex: number): void;
+    gpu_texture_painter(): GpuTexturePainter;
+    sync_dirty_gpu_textures_to_cpu(fullReadback: boolean): void;
+    restore_cpu_texture_previews(): void;
+    invalidate_gpu_texture_painter(syncDirtyTextures: boolean): void;
+    update_spatial_vertices_after_edit(affectedVertices: number[]): void;
+    flush_spatial_index_updates(): void;
+    next_normal_touched_stamp(): number;
+    next_normal_triangle_stamp(): number;
+    refresh_triangle_normal(triangleIndex: number): void;
+    refresh_all_triangle_normals(): void;
+    cached_surface_normal_for_vertex(vertexIndex: number, fallback: ArrayLike<number>, target: Vec3): Vec3;
+    refresh_affected_normals(affectedVertices: number[]): void;
+    refresh_affected_normals_async(affectedVertices: number[]): Promise<void>;
+    begin_deferred_sculpt_normal_refresh(): void;
+    queue_deferred_sculpt_normal_refresh(affectedVertices: number[]): void;
+    end_deferred_sculpt_normal_refresh(): Promise<void>;
+    begin_brush_frame_edit_batch(): void;
+    queue_brush_frame_position_refresh(affectedVertices: number[], updateStart: number, updateEnd: number, rebuildWireframe: boolean): void;
+    end_brush_frame_edit_batch(): void;
+    refresh_edited_positions(affectedVertices: number[], updateStart: number, updateEnd: number, rebuildWireframe: boolean, canMutateAffectedVertices: boolean): void;
+    refresh_edited_colors(affectedVertices: number[], updateStart: number, updateEnd: number, canMutateAffectedVertices: boolean): void;
+    material_index_for_hit(hit: any): number;
+    brush_world_radius(): number;
+    minimum_world_length(): number;
+    recommended_brush_radius_minimum(): number;
+    active_brush_world_radius(): number;
+    texture_paint_metric_for_hit(hit: any): TexturePaintMetric;
+    texture_paint_distance(metric: TexturePaintMetric, deltaU: number, deltaV: number): number;
+    repeated_texture_paint_distance(metric: TexturePaintMetric, deltaU: number, deltaV: number): number;
+    texture_paint_metric_from_radius(radius: number): TexturePaintMetric;
+    texture_paint_triangles(): TexturePaintTriangle[];
+    has_usable_texture_uvs(): boolean;
+    paint_texture_pixel(texture: {
+        width: number;
+        height: number;
+        pixels: Uint8Array;
+    }, offset: number, amount: number): void;
+    apply_texture_paint_sample(uv: Vec2, metricOrRadius: TexturePaintMetric | number, materialIndex: number): number;
+    paint_texture_triangle_surface(triangle: TexturePaintTriangle, center: Vec3, radius: number, paintedTextureIndices: Set<number>): number;
+    rollback_failed_texture_paint(): void;
+    apply_texture_paint_surface(center: Vec3, seedTriangleIndex?: number, pathRatio?: number): number;
+    apply_symmetric_texture_paint_sample(center: Vec3, normal: Vec3, seedTriangleIndex?: number, pathRatio?: number): number;
+    apply_texture_paint_hit(hit: any, pathRatio?: number): number;
+    break_brush_stroke_segment(): void;
+    clear_selection(): void;
+    select_vertex(vertexIndex: number): void;
+    is_vertex_selected(vertexIndex: number): boolean;
+    apply_brush(center: ArrayLike<number>, direction: ArrayLike<number>, radius: number, strength: number, tool: string | undefined, rebuildWireframe?: boolean, seedTriangleIndex?: number, pathRatio?: number, patternDirection?: ArrayLike<number>): number;
+    resize(): void;
+    frame_mesh(): void;
+    vertex_count(): number;
+    update_effective_visuals(): void;
+    build_spatial_index(): void;
+    build_texture_paint_triangle_index(): TexturePaintTriangleIndex | null;
+    query_texture_paint_triangles(center: Vec3, radius: number, seedTriangleIndex?: number): TexturePaintTriangle[];
+    configure_sculpt_normal_workers(): void;
+    cancel_scheduled_sculpt_normal_workers(): void;
+    schedule_sculpt_normal_workers(): void;
+    build_topology_maps(): void;
+    cancel_scheduled_derived_refresh(): void;
+    schedule_derived_refresh(): void;
+    flush_pending_derived_refresh(rebuildWireframe: boolean): void;
+    sync_geometry_normals_to_session(): void;
+    update_ranges_from_vertices(vertexIndices: number[], fallbackStart: number, fallbackCount: number, canMutateVertexIndices: boolean): UpdateRange[];
+    set_update_range(index: number, start: number, count: number): void;
+    update_point_pixel_ratio(): void;
+    clear_scene_mesh(): void;
+    rebuild_scene_mesh(): void;
+    prepare_mesh_bounds_tree_refit(vertexIndices: number[]): void;
+    refit_mesh_bounds_tree(): void;
+    rebuild_wireframe(): void;
+    ensure_selected_position_capacity(vertexCount: number): void;
+    refresh_selection_geometry(): void;
+    expand_geometry_bounds(updateRanges: UpdateRange[] | undefined, vertexIndices?: number[]): void;
+    refresh_geometry(options: RefreshGeometryOptions | boolean): void;
+    handle_pointer_down(event: PointerEvent): void;
+    handle_pointer_move(event: PointerEvent): void;
+    queue_brush_pointer_position(clientX: number, clientY: number): void;
+    queue_brush_pointer_event(event: PointerEvent): void;
+    should_use_sculpt_normal_workers(): boolean;
+    schedule_brush_frame(): void;
+    wait_for_brush_idle(): Promise<void>;
+    resolve_brush_idle(): void;
+    process_brush_frame_async(): Promise<void>;
+    brush_world_per_css_pixel(center: Vec3 | null): number;
+    brush_spacing_css_pixels(center: Vec3 | null): number;
+    brush_path_ratio_css_pixels(distance: number, center: Vec3 | null): number;
+    apply_move_pointer_sample(clientX: number, clientY: number): void;
+    apply_surface_brush_pointer_sample(clientX: number, clientY: number, pathRatio: number): void;
+    apply_surface_brush_pointer_sample_async(clientX: number, clientY: number, pathRatio: number): Promise<void>;
+    apply_pending_brush_events(finalizeStroke?: boolean): void;
+    apply_next_pending_brush_dab_async(strokeState: BrushStrokeState, finalizeStroke: boolean): Promise<boolean>;
+    apply_pending_brush_events_async(finalizeStroke?: boolean): Promise<void>;
+    complete_brush_stroke(strokeState: BrushStrokeState): void;
+    release_pointer_capture(pointerId: number): void;
+    finish_pointer(pointerId: number, finalizeDerived: boolean): void;
+    handle_pointer_up(event: PointerEvent): void;
+    handle_pointer_cancel(event: PointerEvent): void;
+    handle_lost_pointer_capture(event: PointerEvent): void;
+    cancel_active_pointer(): void;
+    apply_brush_sample(center: Vec3, normal: Vec3, seedTriangleIndex?: number, pathRatio?: number, patternDirection?: ArrayLike<number>): void;
+    apply_brush_sample_async(center: Vec3, normal: Vec3, seedTriangleIndex?: number, pathRatio?: number, patternDirection?: ArrayLike<number>): Promise<void>;
+    update_brush_stroke_surface_hit(hit: any): void;
+    apply_brush_hit(hit: any, pathRatio?: number): void;
+    handle_wheel(event: WheelEvent): void;
+    pan_camera(dx: number, dy: number): void;
+    pick_mesh(event: PointerEvent): any;
+    pick_mesh_at(clientX: number, clientY: number): any;
+    pick_vertex(event: PointerEvent, meshHit: any): {
+        index: number;
+        point: any;
+    } | null;
+    apply_orbit_camera(): void;
+    begin_deferred_render(): void;
+    end_deferred_render(): void;
+    render(): void;
+    set_status(message: string): void;
+}
+export {};