@nuflo/engine 0.1.1

package/nf_wasm.d.ts

@@ -0,0 +1,656 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * The graph engine exposed to JavaScript.
+ */
+export class Engine {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of assets currently resolved (for diagnostics / the host loader).
+     */
+    asset_count(): number;
+    /**
+     * Keyframe-bake the current scene along the scroll axis (#4): evaluate the graph at
+     * `samples` scroll positions and store the geometry so `tick` interpolates it instead
+     * of re-evaluating the graph every frame ("bake the function"). Returns `false` (no
+     * bake) when there's no document, no mesh, or the topology changes across scroll.
+     * PRECONDITION: lighting/camera/materials must be static (only geometry animates
+     * along scroll) — the bake captures the render config once at scroll 0.
+     */
+    bake_scroll(samples: number): boolean;
+    /**
+     * The active scene camera as a flat float array for
+     * [`Viewport::set_scene_camera`](crate::Viewport::set_scene_camera):
+     * `[eye.xyz(3), target.xyz(3), up.xyz(3), fov_y_deg, projection(0 persp/1 ortho),
+     *   ortho_height, znear, zfar]` (14 floats).
+     *
+     * When no `camera` node ran this returns `SceneCamera::default()` — the framing
+     * the editor viewport hardcoded before the camera became a node — so existing
+     * scenes look unchanged.
+     */
+    camera(): Float32Array;
+    /**
+     * `[view_proj | inverse(view_proj)]` (32 column-major f32) for the live editor
+     * camera, built with the renderer's own [`nf_render::Camera`] so editor
+     * overlays project against the EXACT matrix the renderer draws with (no TS
+     * re-derivation of the camera math — the source of the old +Y/+Z drift).
+     * `cam` is the flat camera ABI ([`Engine::camera`] layout); `aspect` = w/h.
+     */
+    camera_matrices(cam: Float32Array, aspect: number): Float32Array;
+    /**
+     * The node catalog as a JSON array of node definitions, for the editor
+     * palette and the AI layer. Serialization of the catalog cannot realistically
+     * fail; on the off chance it does we return an empty JSON array.
+     */
+    catalog(): string;
+    /**
+     * Drop every provided asset. The host calls this when switching to an
+     * unrelated scene; document edits do NOT need it (handles are content-stable).
+     */
+    clear_assets(): void;
+    /**
+     * Drop the scroll bake; `tick` returns to live graph evaluation.
+     */
+    clear_bake(): void;
+    /**
+     * Drop a host-injected external signal by name. Subsequent reads on
+     * nodes referencing `name` fall back to their literal default.
+     */
+    clear_external_signal(name: string): void;
+    /**
+     * Flattened `r, g, b, a` per-vertex linear colors of the cached mesh, read
+     * from the `color` point attribute (empty if absent or not vertex-aligned).
+     * This is the glTF `COLOR_0` channel: an imported `.glb`'s vertex colors land
+     * here and survive a re-export. Returned to JS as a `Float32Array`.
+     */
+    colors(): Float32Array;
+    /**
+     * Flattened `r, g, b, a` per-vertex HDR emission colors of the cached mesh
+     * (empty if no point-domain emission attribute is present).
+     */
+    emissions(): Float32Array;
+    /**
+     * The most recently evaluated environment as a flat float array for
+     * [`Viewport::set_environment`](crate::Viewport::set_environment):
+     * `[floor_rgb(3), zenith_rgb(3), intensity(1), softbox_count(1),
+     *   fog_color_rgb(3), fog_near(1), fog_far(1), fog_density(1), fog_mode(1),
+     *   bg_rgba(4), bg_enabled(1), then per softbox: dir_xyz(3), color_rgb(3),
+     *   sharpness(1)]` (20-float header).
+     * Prefers an `environment` node's value; falls back to the evaluated `LookSpec`
+     * environment when the graph has none. Disabled softboxes are already dropped.
+     */
+    environment(): Float32Array;
+    /**
+     * Parse and evaluate a [`GraphDocument`] (as JSON), caching the resulting
+     * geometry for the buffer accessors.
+     *
+     * Returns a JSON status string and never panics on bad input:
+     * - success: `{"ok":true,"verts":N,"faces":M,"tris":T}`
+     * - parse/eval failure: `{"ok":false,"error":"<message>"}`
+     */
+    evaluate(document_json: string): string;
+    /**
+     * Current host-injected external signals as a typed JSON array, for the
+     * inspector's live-values panel. Each entry: `{kind, name, value}`. `value`
+     * shape varies by kind (number for float, bool for bool, `[x,y,z]` for vec3).
+     * Inline-typed so we can carry the kind tag without `serde_json::Value`.
+     */
+    external_signals_json(): string;
+    /**
+     * Per-TRIANGLE source-node indices of the cached mesh, aligned 1:1 with the
+     * triangles emitted by [`Engine::indices`] (`indices().len() / 3` entries). Each
+     * value indexes [`Engine::source_node_ids`]; the sentinel `u32::MAX` means "no
+     * node". Empty if there is no cached mesh. Returned to JS as a `Uint32Array`.
+     */
+    face_source_nodes(): Uint32Array;
+    /**
+     * Read a boolean state variable (false if unset).
+     */
+    get_var_bool(name: string): boolean;
+    /**
+     * Read a color state variable as `[r, g, b, a]` (opaque black if unset).
+     */
+    get_var_color(name: string): Float32Array;
+    /**
+     * Read a numeric state variable (0.0 if unset).
+     */
+    get_var_number(name: string): number;
+    /**
+     * Read a vector state variable as `[x, y, z]` (zeros if unset). This is the
+     * host→3D binding path for positions/rotations/scales.
+     */
+    get_var_vector(name: string): Float32Array;
+    /**
+     * The cached GPU-SDF field's compiled-shader description, as the strings/floats
+     * the viewport reconstructs a render request from (the `Field` itself can't
+     * cross the JS boundary). Layout:
+     * `[result_type, needs_noise, needs_op_lib, center_x, center_y, center_z, size,
+     *   resolution]` (all `f32`; booleans are 0/1, `resolution` rounds to `u32`),
+     * returned alongside the WGSL `body`/`result` strings via
+     * [`Engine::gpu_sdf_program_body`]/[`Engine::gpu_sdf_program_result`]. Empty if
+     * there is no `gpu_sdf` or its field doesn't compile to WGSL.
+     */
+    gpu_sdf_descriptor(): Float32Array;
+    /**
+     * The WGSL `body` (SSA statements) of the cached GPU-SDF field's compiled
+     * program; empty if there is no `gpu_sdf` or it doesn't compile.
+     */
+    gpu_sdf_program_body(): string;
+    /**
+     * The WGSL `result` expression of the cached GPU-SDF field's compiled program;
+     * empty if there is no `gpu_sdf` or it doesn't compile.
+     */
+    gpu_sdf_program_result(): string;
+    /**
+     * The most recent `tick`'s signals (8 floats, `SignalKind` order) for the
+     * GPU-SDF density shader's uniform, so the field animates per frame.
+     */
+    gpu_sdf_signals(): Float32Array;
+    /**
+     * Whether the cached geometry carries a GPU-polygonized SDF (`sdf_to_mesh` in
+     * GPU mode). When true, the frontend should drive the viewport's GPU-SDF glass
+     * path (`render_gpu_sdf`) instead of `set_mesh` — the field is polygonized on
+     * the GPU every frame rather than carried as a CPU mesh.
+     */
+    has_gpu_sdf(): boolean;
+    /**
+     * Triangulated triangle indices of the cached mesh (empty if none).
+     * Returned to JS as a `Uint32Array`.
+     */
+    indices(): Uint32Array;
+    /**
+     * Whether a scroll bake is currently active.
+     */
+    is_baked(): boolean;
+    /**
+     * The scene lights from the most recent evaluation, flattened to
+     * [`LIGHT_STRIDE`] floats each for
+     * [`Viewport::set_lights`](crate::Viewport::set_lights):
+     * `[kind(0 dir/1 point/2 spot), pos.x,pos.y,pos.z, dir.x,dir.y,dir.z,
+     *   color.r,color.g,color.b, intensity, range, cos_inner, cos_outer]`.
+     *
+     * When the graph emitted no light nodes the array is a single default
+     * directional light (a soft key from above-front) so lightless scenes still
+     * render instead of going black. The frontend infers the light count as
+     * `len / LIGHT_STRIDE`.
+     */
+    lights_flat(): Float32Array;
+    /**
+     * Load a `scene.wasm` (or its raw `nf-scene` section payload): decode the
+     * bundle, install the document, register any Embedded assets into the store,
+     * and return a JSON status listing the External assets the host must still
+     * fetch and `provide_asset`. Shape:
+     * `{"ok":true,"external":[{"handle","mime","sha256","url"}]}` or
+     * `{"ok":false,"error":...}`.
+     */
+    load_scene_wasm(scene_wasm: Uint8Array): string;
+    /**
+     * The cached geometry's PBR material as the full 32-float ABI documented on
+     * [`nf_core::geometry::Material::from_engine_slice`]: the 24-float core
+     * (`base_color.rgba`, metallic, roughness, emission, iridescence, matcap,
+     * texture controls, map strengths, video_texture_mix) followed by the glass
+     * block `[transmission, ior, thickness, attenuation_color.rgb,
+     * attenuation_distance, dispersion]`. `Viewport::set_material` and the GLB
+     * exporter decode it with the same constructor. Defaults if no geometry yet.
+     */
+    material(): Float32Array;
+    /**
+     * Build an engine with all built-in node types registered.
+     */
+    constructor();
+    /**
+     * Flattened `x, y, z` vertex normals of the cached mesh (empty if none).
+     * Returned to JS as a `Float32Array`.
+     */
+    normals(): Float32Array;
+    /**
+     * Export the current document as a `scene.wasm`: the graph (MessagePack) plus
+     * an asset table baked into the `nf-scene` custom section. `embedded` selects
+     * the asset mode:
+     * - `true`  — every provided asset's bytes ride inside the section (a single
+     *   self-contained download; re-ships on every edit, no cross-scene dedup).
+     * - `false` — only a content-addressed manifest rides in the section (handle,
+     *   MIME, sha256); the bytes are fetched separately at load (cached, shared,
+     *   parallel). The host hosts the bytes by sha256 / the loader's configured base.
+     *
+     * Returns the `scene.wasm` bytes, or an error if no document is loaded.
+     */
+    pack_scene_wasm(embedded: boolean): Uint8Array;
+    /**
+     * Drain the host-bound runtime actions queued since the last call,
+     * returning them as a JSON array of tagged objects (the same shape as
+     * [`RuntimeAction`]'s `#[serde(tag = "kind")]` representation). The
+     * frontend parses this once per frame as a typed discriminated union
+     * (`{ kind: "open_link", url, new_tab } | { kind: "play_sound", ... }
+     * | ...`) and dispatches each intent to its host handler.
+     *
+     * Engine-local intents (variable resets) are dispatched inside `tick`
+     * and never appear here. Calling this method clears the queue, so back-
+     * to-back calls in the same frame will return `[]` for the second one.
+     */
+    pending_actions_json(): string;
+    /**
+     * The source-node id of the geometry under a viewport point, or `None` on a
+     * miss. `ndc_x`/`ndc_y` are normalized device coords in `[-1, 1]` (+Y up).
+     * Raycasts the cached mesh (Möller–Trumbore) using a ray unprojected from the
+     * live camera — the picking compute lives here in Rust, not TS.
+     */
+    pick(cam: Float32Array, aspect: number, ndc_x: number, ndc_y: number): string | undefined;
+    /**
+     * Source-node ids whose geometry falls inside a screen-rect marquee (NDC, +Y
+     * up). A node is included when any of its triangles' centroids project inside
+     * the rect. The box-select compute lives here in Rust, not TS.
+     */
+    pick_rect(cam: Float32Array, aspect: number, min_x: number, min_y: number, max_x: number, max_y: number): string[];
+    /**
+     * Flattened `x, y, z` vertex positions of the cached mesh (empty if none).
+     * Returned to JS as a `Float32Array`.
+     */
+    positions(): Float32Array;
+    /**
+     * The most recently evaluated post-process settings as a flat float
+     * array for [`Viewport::set_post`](crate::Viewport::set_post):
+     * `[bloom_threshold, bloom_knee, bloom_strength, vignette_intensity,
+     * vignette_radius, vignette_smoothness, vignette_roundness,
+     * film_grain_intensity, film_grain_size, film_grain_time,
+     * color_grade_exposure, color_grade_contrast, color_grade_saturation,
+     * color_grade_hue]`.
+     */
+    post(): Float32Array;
+    /**
+     * Provide (or replace) an asset's bytes under its handle. The host calls this
+     * for each External asset it has fetched (keyed by the handle the scene's
+     * nodes reference); the next `tick`/`evaluate` resolves it. Copy-on-write:
+     * cheap when the store isn't currently borrowed by an in-flight eval.
+     */
+    provide_asset(handle: string, mime: string, bytes: Uint8Array): void;
+    /**
+     * Clear transient and held input state, useful when the host loses focus.
+     */
+    reset_input_state(): void;
+    /**
+     * Reset the cached scene runtime to the current document defaults.
+     *
+     * This keeps the loaded document and cached geometry, but re-seeds declared
+     * variables, clears keyboard/pointer/drag state, resets the first-frame start
+     * pulse, and restores the evaluated look cache to the current spec defaults.
+     */
+    reset_scene(): string;
+    /**
+     * Cache a [`GraphDocument`] (as JSON) for per-frame evaluation via [`tick`].
+     *
+     * Returns a JSON status: `{"ok":true}` or `{"ok":false,"error":...}`. Parsing
+     * happens once here, not every frame.
+     *
+     * [`tick`]: Engine::tick
+     */
+    set_document(document_json: string): string;
+    /**
+     * Cache a [`GraphDocument`] from its binary (MessagePack) wire form — the
+     * payload an exported `scene.wasm` carries. The authoring path stays JSON
+     * ([`Engine::set_document`]); this is the runtime path for a binary scene
+     * with no embedded assets (or after assets were provided separately).
+     */
+    set_document_bin(document_bin: Uint8Array): string;
+    /**
+     * Set a host-injected external signal bool by name. Read by
+     * `input_external_bool` nodes next tick.
+     */
+    set_external_signal_bool(name: string, value: boolean): void;
+    /**
+     * Set a host-injected external signal float by name. Read by
+     * `input_external_float` nodes next tick; absent keys fall back to the
+     * node's literal default. Use `clear_external_signal` to drop a key.
+     */
+    set_external_signal_float(name: string, value: number): void;
+    /**
+     * Set a host-injected external signal vec3 by name. Read by
+     * `input_external_vec3` nodes next tick.
+     */
+    set_external_signal_vec3(name: string, x: number, y: number, z: number): void;
+    /**
+     * Update keyboard state from a host `keydown`/`keyup` listener.
+     *
+     * `key` may be either `KeyboardEvent.key` (`"Space"`, `"a"`, `"ArrowLeft"`)
+     * or `KeyboardEvent.code` (`"KeyA"`, `"Digit1"`). The next `tick` exposes
+     * key-down/key-up pulses; held state remains true until released.
+     */
+    set_key_state(key: string, pressed: boolean): string;
+    /**
+     * Set the declarative, signal-driven render Look (as a JSON [`LookSpec`]).
+     *
+     * Every numeric field of the spec is a `ParamValue` — a constant or a driver
+     * expression evaluated each `tick` against the live browser signals (exactly
+     * like node params). Parsing happens once here, not per frame. Returns the same
+     * JSON status shape as [`evaluate`](Engine::evaluate); on parse failure the
+     * previous Look spec is kept.
+     */
+    set_look_spec(spec_json: string): string;
+    /**
+     * Set a boolean state variable.
+     */
+    set_var_bool(name: string, value: boolean): void;
+    /**
+     * Set an RGBA color state variable (coerced to its declared type). The host→3D
+     * color-binding path — e.g. push the current product variant's accent color.
+     */
+    set_var_color(name: string, r: number, g: number, b: number, a: number): void;
+    /**
+     * Set a numeric state variable (coerced to its declared type). No-op if the
+     * value can't coerce to the declared type.
+     */
+    set_var_number(name: string, value: number): void;
+    /**
+     * Set a 3-component vector state variable (coerced to its declared type).
+     */
+    set_var_vector(name: string, x: number, y: number, z: number): void;
+    /**
+     * The ordered provenance table as a JSON array of node-instance-id strings, e.g.
+     * `["cube_abc","sphere_def"]`. Index `i` returned by [`Engine::face_source_nodes`]
+     * refers to entry `i` here. This is a return value (not a struct field), so
+     * serializing a `Vec<String>` with `serde_json` is permitted.
+     */
+    source_node_ids(): string;
+    /**
+     * Active scene-wide image bindings, as JSON `[{ "slot": ..., "url": ... }]`.
+     *
+     * Scans the currently loaded document for `image_texture` nodes (not hidden,
+     * with a non-empty `asset_url` literal). The frontend reads this each frame
+     * and lazy-loads each URL into RGBA, binding into `Viewport::set_*_map`
+     * slots. A later collision (two `image_texture` nodes targeting the same
+     * slot) is resolved last-wins, mirroring how the renderer accepts one
+     * texture per slot today.
+     */
+    texture_bindings_json(): string;
+    /**
+     * Evaluate the cached document with the current frame's browser signals.
+     *
+     * `time` is seconds since the scene started; the frame delta is derived from
+     * the previous `tick`. `mouse_x`/`mouse_y` are pixel coordinates (origin
+     * top-left). `scroll` is `0..1`. The result is cached for the buffer accessors.
+     * Returns the same JSON status shape as [`evaluate`](Engine::evaluate).
+     */
+    tick(time: number, mouse_x: number, mouse_y: number, scroll: number, viewport_w: number, viewport_h: number, click: boolean, section_index: number, section_progress: number, dark_mode: boolean, reduced_motion: boolean): string;
+}
+
+/**
+ * A canvas-bound fila renderer.
+ */
+export class Viewport {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a viewport for `canvas`, asynchronously acquiring a wgpu adapter and device and
+     * configuring the surface. Rejects (throws a `JsError`) if no adapter/device is available or the
+     * surface can't be created.
+     */
+    static create(canvas: HTMLCanvasElement): Promise<Viewport>;
+    /**
+     * Per-frame render instrumentation for the LAST `render_fila`, as a flat float vector:
+     * `[scene_lowering_ms, fila_passes_ms, present_ms, buffers_created, bytes_uploaded,
+     *   bind_groups_created, render_passes, programs_total, pipelines_total, textures_created,
+     *   submits, t_create_buffer_ms, t_create_bind_group_ms, t_texture_ms, t_end_pass_ms]`. CPU
+     * wall-clock for the timing fields (browser `performance.now()`); driver counters for the rest.
+     * The editor reads this into `globalThis.__perf` to attribute the frame cost (mesh rebuild vs GPU
+     * encode vs present, and per-frame buffer/bind-group/texture churn) and pin what to make persistent.
+     */
+    prof(): Float64Array;
+    /**
+     * Render the engine's last-evaluated scene through fila and present it to the canvas. The graph is
+     * lowered to fila's scene IR by [`crate::Engine::fila_scene`]; the viewport's interactive camera
+     * overrides the graph camera so orbit/zoom work. With no geometry yet, the frame is cleared.
+     */
+    render_fila(engine: Engine): void;
+    /**
+     * GPU-polygonized SDF (metaballs) is parked: fila has no GPU marching-cubes path yet, so an SDF
+     * scene clears to the backdrop instead of rendering (tracked: a compute-MC bridge into fila). The
+     * arguments mirror the old nf-render signature so the JS hand-off is unchanged.
+     */
+    render_gpu_sdf(_body: string, _result: string, _descriptor: Float32Array, _signals: Float32Array): void;
+    /**
+     * Resize the surface to `w` x `h` pixels and update the camera aspect.
+     */
+    resize(w: number, h: number): void;
+    /**
+     * Set the camera from eye/target positions and a vertical field of view (deg).
+     */
+    set_camera(eye_x: number, eye_y: number, eye_z: number, target_x: number, target_y: number, target_z: number, fov_deg: number): void;
+    /**
+     * Switch the camera projection. `mode` accepts `perspective`, `orthographic`, `ortho`, or
+     * `orthographic2d`; `orthographic_height` is the vertical world-space size for orthographic mode.
+     */
+    set_camera_projection(mode: string, orthographic_height: number): void;
+    /**
+     * Enable/configure the EDITOR ground grid (a depth-composited pass on the world z=0 plane —
+     * geometry occludes the grid). `cell` is the minor cell size (world units); `fade_distance` is
+     * where the grid fades to nothing (also the quad's half-extent). EDITOR-ONLY.
+     */
+    set_grid(enabled: boolean, cell: number, fade_distance: number): void;
+    /**
+     * Set the camera from the flat float layout that [`crate::Engine::camera`] emits:
+     * `[eye.xyz(3), target.xyz(3), up.xyz(3), fov_y_deg, projection(0 persp/1 ortho),
+     *   ortho_height, znear, zfar]` (14 floats, + optional pinned aspect at 14). A short slice is
+     * ignored. This is the graph-driven camera path; the editor overrides it interactively.
+     */
+    set_scene_camera(c: Float32Array): void;
+    /**
+     * Upload the selected geometry's triangles for the EDITOR selection outline — tightly-packed
+     * world-space xyz positions + triangle indices into them. Empty input clears the selection. The
+     * data is held CPU-side; fila-render's selection pass uploads + draws it. EDITOR-ONLY.
+     */
+    set_selection_mesh(positions: Float32Array, indices: Uint32Array): void;
+    /**
+     * Enable/configure the EDITOR selection outline (linear RGBA halo color + pixel thickness). Only
+     * draws when enabled AND a selection mesh has been uploaded. EDITOR-ONLY.
+     */
+    set_selection_outline(enabled: boolean, r: number, g: number, b: number, a: number, thickness: number): void;
+}
+
+/**
+ * Apply a high-level [`GraphCommand`] to a document.
+ *
+ * `document_json` is a serialized `GraphDocument`; `command_json` is a
+ * serialized `GraphCommand`. Returns a JSON-stringified `CommandResult` —
+ * either `{ ok: true, doc, outcome }` or `{ ok: false, error }`.
+ *
+ * This is a standalone function (NOT a method on [`crate::Engine`]) so the
+ * editor's React state doesn't have to round-trip through any engine handle
+ * just to perform a mutation. The renderer's `Engine::evaluate` is unchanged.
+ */
+export function apply_command(document_json: string, command_json: string): string;
+
+/**
+ * Compute the structural diff between `prev_json` and `next_json`.
+ * Returns a JSON-stringified `DiffResult` — either `{ ok: true, diff }` or
+ * `{ ok: false, error }`.
+ */
+export function diff_graph(prev_json: string, next_json: string): string;
+
+/**
+ * Compute the downstream closure of `root` in `doc_json`. Mirror of
+ * [`upstream_closure`] but walks consumers; used by the workspace "Isolate"
+ * gesture to compute the visible-while-isolated set.
+ */
+export function downstream_closure(doc_json: string, root: string): string;
+
+/**
+ * Serialize the evaluated mesh to a self-contained glTF 2.0 GLB with its PBR
+ * material and per-vertex colors.
+ *
+ * * `positions`/`normals` are packed xyz, vertex-aligned. Empty `normals` is fine
+ *   (omitted from the output — the recomputed shading normals are baked into the
+ *   frame anyway).
+ * * `colors` is packed rgba (linear), vertex-aligned, or empty for none → written
+ *   as the `COLOR_0` attribute.
+ * * `indices` are triangle indices.
+ * * `material` is the 32-float ABI from `Engine::material` (decoded by
+ *   [`Material::from_engine_slice`]); base color, metalness/roughness, emission,
+ *   and the glass/finish KHR extensions are written into the glTF material.
+ */
+export function export_glb(positions: Float32Array, normals: Float32Array, colors: Float32Array, indices: Uint32Array, material: Float32Array): Uint8Array;
+
+/**
+ * Serialize flat geometry to Wavefront OBJ text. `positions`/`normals` are packed
+ * xyz; `indices` are triangle indices. Normals are emitted only when present and
+ * vertex-aligned. OBJ is 1-indexed.
+ */
+export function export_obj(positions: Float32Array, normals: Float32Array, indices: Uint32Array): string;
+
+/**
+ * Wrap the selected `node_ids` from `doc_json` into a fresh `NodePackage`.
+ * `category_str` is the snake_case `NodeCategory` (e.g. `"generator"`).
+ */
+export function extract_component(doc_json: string, node_ids_json: string, type_id: string, label: string, category_str: string): string;
+
+/**
+ * Append a fresh promoted input. `promoted_json` is the current
+ * `Vec<PromotedInput>` JSON; `target_json` is a `SocketPath` JSON.
+ */
+export function promote_input(promoted_json: string, doc_json: string, target_json: string, public_id: string, label: string): string;
+
+/**
+ * Update the label of the promoted input whose `socket.id == public_id`.
+ */
+export function relabel_promoted_input(promoted_json: string, public_id: string, new_label: string): string;
+
+/**
+ * Wasm entry point: install the renderer panic hook (readable console
+ * backtrace + a `globalThis.__nfRendererPanic` flag the `<nf-scene>` host
+ * reads to degrade gracefully on a fatal panic). Marked `#[wasm_bindgen(start)]`
+ * so it runs automatically when the module is instantiated.
+ */
+export function start(): void;
+
+/**
+ * Remove the promoted input with `public_id`. Idempotent.
+ */
+export function unpromote_input(promoted_json: string, public_id: string): string;
+
+/**
+ * Compute the upstream closure of `root` in `doc_json`. Returns the result
+ * as a JSON array of node ids (sorted) OR a JSON `{ ok: false, error }`
+ * envelope on parse failure. The closure itself can't fail; missing roots
+ * just return a single-element vec containing `root`.
+ */
+export function upstream_closure(doc_json: string, root: string): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_engine_free: (a: number, b: number) => void;
+    readonly __wbg_viewport_free: (a: number, b: number) => void;
+    readonly apply_command: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly diff_graph: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly downstream_closure: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly engine_asset_count: (a: number) => number;
+    readonly engine_bake_scroll: (a: number, b: number) => number;
+    readonly engine_camera: (a: number) => [number, number];
+    readonly engine_camera_matrices: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly engine_catalog: (a: number) => [number, number];
+    readonly engine_clear_assets: (a: number) => void;
+    readonly engine_clear_bake: (a: number) => void;
+    readonly engine_clear_external_signal: (a: number, b: number, c: number) => void;
+    readonly engine_colors: (a: number) => [number, number];
+    readonly engine_emissions: (a: number) => [number, number];
+    readonly engine_environment: (a: number) => [number, number];
+    readonly engine_evaluate: (a: number, b: number, c: number) => [number, number];
+    readonly engine_external_signals_json: (a: number) => [number, number];
+    readonly engine_face_source_nodes: (a: number) => [number, number];
+    readonly engine_get_var_bool: (a: number, b: number, c: number) => number;
+    readonly engine_get_var_color: (a: number, b: number, c: number) => [number, number];
+    readonly engine_get_var_number: (a: number, b: number, c: number) => number;
+    readonly engine_get_var_vector: (a: number, b: number, c: number) => [number, number];
+    readonly engine_gpu_sdf_descriptor: (a: number) => [number, number];
+    readonly engine_gpu_sdf_program_body: (a: number) => [number, number];
+    readonly engine_gpu_sdf_program_result: (a: number) => [number, number];
+    readonly engine_gpu_sdf_signals: (a: number) => [number, number];
+    readonly engine_has_gpu_sdf: (a: number) => number;
+    readonly engine_indices: (a: number) => [number, number];
+    readonly engine_is_baked: (a: number) => number;
+    readonly engine_lights_flat: (a: number) => [number, number];
+    readonly engine_load_scene_wasm: (a: number, b: number, c: number) => [number, number];
+    readonly engine_material: (a: number) => [number, number];
+    readonly engine_new: () => number;
+    readonly engine_normals: (a: number) => [number, number];
+    readonly engine_pack_scene_wasm: (a: number, b: number) => [number, number, number, number];
+    readonly engine_pending_actions_json: (a: number) => [number, number];
+    readonly engine_pick: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly engine_pick_rect: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+    readonly engine_positions: (a: number) => [number, number];
+    readonly engine_post: (a: number) => [number, number];
+    readonly engine_provide_asset: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_reset_input_state: (a: number) => void;
+    readonly engine_reset_scene: (a: number) => [number, number];
+    readonly engine_set_document: (a: number, b: number, c: number) => [number, number];
+    readonly engine_set_document_bin: (a: number, b: number, c: number) => [number, number];
+    readonly engine_set_external_signal_bool: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_set_external_signal_float: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_set_external_signal_vec3: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_set_key_state: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly engine_set_look_spec: (a: number, b: number, c: number) => [number, number];
+    readonly engine_set_var_bool: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_set_var_color: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_set_var_number: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_set_var_vector: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_source_node_ids: (a: number) => [number, number];
+    readonly engine_texture_bindings_json: (a: number) => [number, number];
+    readonly engine_tick: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => [number, number];
+    readonly export_glb: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly export_obj: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly extract_component: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly promote_input: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly relabel_promoted_input: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly unpromote_input: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly upstream_closure: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly viewport_create: (a: any) => any;
+    readonly viewport_prof: (a: number) => [number, number];
+    readonly viewport_render_fila: (a: number, b: number) => [number, number];
+    readonly viewport_render_gpu_sdf: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
+    readonly viewport_resize: (a: number, b: number, c: number) => void;
+    readonly viewport_set_camera: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly viewport_set_camera_projection: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly viewport_set_grid: (a: number, b: number, c: number, d: number) => void;
+    readonly viewport_set_scene_camera: (a: number, b: number, c: number) => void;
+    readonly viewport_set_selection_mesh: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly viewport_set_selection_outline: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly start: () => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h70a5e17d363fcdff: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h1ef02cf0d1d48747: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hc9b514610e2ea6ee: (a: number, b: number, c: any) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __externref_drop_slice: (a: number, b: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;