@qvac/sdk 0.18.2 → 0.19.0

package/dist/src/client/api/vla-helpers.js

@@ -0,0 +1,139 @@
+/**
+ * Pure-JS helpers for preparing VLA inference inputs on the client side.
+ *
+ * Mirrors `preprocessImage` / `padState` / `DEFAULT_IMAGE_SIZE` from
+ * `@qvac/vla-ggml/addon.js`. Kept inlined (not re-exported from the addon)
+ * so the SDK's client surface never loads the addon's native binding —
+ * consumers running under Node / Bun / Expo without VLA prebuilds can still
+ * use the SDK to drive a remote VLA worker.
+ *
+ * This file is a verbatim port of the addon's JS implementation; keep them
+ * in sync so the wire-format tensors stay byte-identical regardless of
+ * where preprocessing runs (consumer process vs worker vs addon).
+ */
+/** Default vision tower image size used by SmolVLA-LIBERO. */
+export const VLA_DEFAULT_IMAGE_SIZE = 512;
+function detectScale(pixels) {
+    if (pixels instanceof Uint8Array)
+        return 1 / 255;
+    // Float/Number arrays: scan a small window to decide whether it's [0,255] or [0,1].
+    const limit = Math.min(pixels.length, 256);
+    let maxVal = 0;
+    for (let i = 0; i < limit; i++) {
+        const v = pixels[i];
+        if (v > maxVal)
+            maxVal = v;
+    }
+    return maxVal > 1.001 ? 1 / 255 : 1;
+}
+/**
+ * Resize + letterbox + normalize a camera frame to `(3, size, size)` Float32
+ * in `[-1, 1]`. Drop-in equivalent of `@qvac/vla-ggml`'s `preprocessImage`.
+ *
+ * Letterbox places the resized content at the **bottom-right** with padding
+ * at top/left (`padLeft = size - newW`, `padTop = size - newH`), matching
+ * the reference smolvla.cpp behavior.
+ *
+ * @param pixels - RGB pixel values in HWC or CHW layout.
+ * @param width - Source image width in pixels.
+ * @param height - Source image height in pixels.
+ * @param opts - Target size, source layout, and optional input-range scale.
+ * @returns A normalized CHW tensor with shape `(3, size, size)`.
+ * @throws {TypeError} When width or height is not a positive integer.
+ * @throws {RangeError} When the pixel count does not match the dimensions.
+ */
+export function vlaPreprocessImage(pixels, width, height, opts = {}) {
+    const size = opts.size ?? VLA_DEFAULT_IMAGE_SIZE;
+    const layout = opts.layout ?? 'hwc';
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+        throw new TypeError('vlaPreprocessImage: width/height must be positive integers');
+    }
+    const expected = width * height * 3;
+    if (pixels.length !== expected) {
+        throw new RangeError(`vlaPreprocessImage: expected ${expected} pixel values, got ${pixels.length}`);
+    }
+    const normalize = opts.scale === 1 || opts.scale === 1 / 255 ? opts.scale : detectScale(pixels);
+    // Letterbox target size (aspect-ratio preserving).
+    const ratio = Math.max(width / size, height / size);
+    const newW = Math.max(1, Math.floor(width / ratio));
+    const newH = Math.max(1, Math.floor(height / ratio));
+    const padLeft = size - newW;
+    const padTop = size - newH;
+    const xScale = width / newW;
+    const yScale = height / newH;
+    // Output starts at -1 so the pad region is already in [-1, 1] and we only
+    // need to overwrite the (newH × newW) inner region with the resized content.
+    const out = new Float32Array(3 * size * size);
+    out.fill(-1);
+    const planeStride = size * size;
+    const widthHeight = width * height;
+    for (let yy = 0; yy < newH; yy++) {
+        const yIn = (yy + 0.5) * yScale - 0.5;
+        const y0 = Math.max(0, Math.floor(yIn));
+        const y1 = Math.min(height - 1, y0 + 1);
+        const dy = Math.min(1, Math.max(0, yIn - y0));
+        const dyInv = 1 - dy;
+        const outY = yy + padTop;
+        for (let xx = 0; xx < newW; xx++) {
+            const xIn = (xx + 0.5) * xScale - 0.5;
+            const x0 = Math.max(0, Math.floor(xIn));
+            const x1 = Math.min(width - 1, x0 + 1);
+            const dx = Math.min(1, Math.max(0, xIn - x0));
+            const dxInv = 1 - dx;
+            const outX = xx + padLeft;
+            const w00 = dxInv * dyInv;
+            const w10 = dx * dyInv;
+            const w01 = dxInv * dy;
+            const w11 = dx * dy;
+            const outIdx = outY * size + outX;
+            if (layout === 'hwc') {
+                const i00 = (y0 * width + x0) * 3;
+                const i10 = (y0 * width + x1) * 3;
+                const i01 = (y1 * width + x0) * 3;
+                const i11 = (y1 * width + x1) * 3;
+                for (let c = 0; c < 3; c++) {
+                    const v = pixels[i00 + c] * w00 +
+                        pixels[i10 + c] * w10 +
+                        pixels[i01 + c] * w01 +
+                        pixels[i11 + c] * w11;
+                    // Apply scale and shift into [-1, 1] in one fused multiply-add.
+                    out[c * planeStride + outIdx] = v * normalize * 2 - 1;
+                }
+            }
+            else {
+                for (let c = 0; c < 3; c++) {
+                    const plane = c * widthHeight;
+                    const v = pixels[plane + y0 * width + x0] * w00 +
+                        pixels[plane + y0 * width + x1] * w10 +
+                        pixels[plane + y1 * width + x0] * w01 +
+                        pixels[plane + y1 * width + x1] * w11;
+                    out[c * planeStride + outIdx] = v * normalize * 2 - 1;
+                }
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Zero-pad a state vector to `targetDim`. Extra entries are zero-initialised;
+ * input longer than `targetDim` raises. Mirrors how smolvla.cpp expects the
+ * state tensor (`max_state_dim` = 32 by default).
+ *
+ * @param state - Robot state values to copy into the padded tensor.
+ * @param targetDim - Required output dimension (default: 32).
+ * @returns A `Float32Array` of exactly `targetDim` values.
+ * @throws {TypeError} When `targetDim` is not a positive integer.
+ * @throws {RangeError} When `state` is longer than `targetDim`.
+ */
+export function vlaPadState(state, targetDim = 32) {
+    if (!Number.isInteger(targetDim) || targetDim <= 0) {
+        throw new TypeError('vlaPadState: targetDim must be a positive integer');
+    }
+    if (state.length > targetDim) {
+        throw new RangeError(`vlaPadState: input length ${state.length} exceeds targetDim ${targetDim}`);
+    }
+    const out = new Float32Array(targetDim);
+    for (let i = 0; i < state.length; i++)
+        out[i] = state[i];
+    return out;
+}

package/dist/src/client/api/vla.d.ts

@@ -0,0 +1,114 @@
+import { type VlaClientRunParams, type VlaClientRunResult, type VlaEmbodimentSelection, type VlaHparams } from '@qvac/inference/surface';
+/**
+ * Run VLA inference on a loaded model (SmolVLA, π₀.₅, or GR00T) and return the
+ * produced action chunk plus per-stage timings.
+ *
+ * @param params - Inference inputs.
+ * @param params.modelId - Identifier of the loaded VLA model (returned by
+ *   `loadModel({ modelType: "vla", ... })`).
+ * @param params.images - The preprocessed camera frames, one per camera. For
+ *   pixel-input models (SmolVLA, π₀.₅) each is a `Float32Array` of length
+ *   `3 * imgWidth * imgHeight` in CHW layout, range `[-1, 1]`, produced by the
+ *   addon's `preprocessImage()` (re-exported as `vlaPreprocessImage`). For
+ *   patch-input models (GR00T, `hparams.imageInputMode === 'patches'`) each is
+ *   the pre-patchified buffer of length `hparams.imagePatchElems` instead. Pass
+ *   exactly `hparams.numCameras` frames (2 for SmolVLA and GR00T, 3 for π₀.₅).
+ * @param params.imgWidth - Width of each preprocessed image; must equal
+ *   `hparams.visionImageSize`.
+ * @param params.imgHeight - Height of each preprocessed image; must equal
+ *   `hparams.visionImageSize`.
+ * @param params.state - Robot end-effector / gripper state. For
+ *   continuous-state models (SmolVLA, GR00T) pad to `hparams.maxStateDim` with
+ *   `vlaPadState`. For discrete-state models (π₀.₅,
+ *   `hparams.stateInputMode === 'discrete'`) the state is tokenised into the
+ *   prompt and this buffer is ignored — pass an empty `Float32Array(0)`.
+ * @param params.tokens - Tokenized instruction (`Int32Array` of length
+ *   `hparams.tokenizerMaxLength`). Tokenize on the consumer side with the
+ *   model's tokenizer (SmolVLM2 for SmolVLA, PaliGemma/Gemma for π₀.₅,
+ *   Qwen3-VL for GR00T).
+ * @param params.mask - Token attention mask (`Uint8Array` matching `tokens`).
+ * @param params.noise - Seeded noise prior
+ *   (`Float32Array` of length `hparams.chunkSize * hparams.maxActionDim`).
+ *   Optional for SmolVLA / π₀.₅ (addon samples its own prior when omitted).
+ *   Required for GR00T (`hparams.imageInputMode === 'patches'`).
+ * @returns A `VlaClientRunResult` with the produced `actions` Float32Array
+ *   (length `chunkSize * actionDim`), the corresponding `chunkSize` /
+ *   `actionDim` returned by the addon, and optional per-stage `stats`.
+ *
+ * @example
+ * ```typescript
+ * import { loadModel, vla, vlaPreprocessImage, vlaPadState, vlaHparams } from "@qvac/sdk";
+ *
+ * const modelId = await loadModel({ modelSrc: "/path/to/smolvla.gguf", modelType: "vla" });
+ * const { hparams } = await vlaHparams({ modelId });
+ * const size = hparams.visionImageSize;
+ * const front = vlaPreprocessImage(frontPixels, frontW, frontH, { size });
+ * const wrist = vlaPreprocessImage(wristPixels, wristW, wristH, { size });
+ * const state = vlaPadState(robotState, hparams.maxStateDim);
+ * const tokens = new Int32Array(hparams.tokenizerMaxLength);
+ * const mask = new Uint8Array(hparams.tokenizerMaxLength);
+ * // ...tokenize the instruction into tokens/mask...
+ * const { actions } = await vla({
+ *   modelId, images: [front, wrist], imgWidth: size, imgHeight: size,
+ *   state, tokens, mask,
+ * });
+ * ```
+ */
+export declare function vla(params: VlaClientRunParams): Promise<VlaClientRunResult>;
+/**
+ * Fetch the loaded VLA model's hyperparameters and the active ggml backend
+ * name. Useful to size token / state / noise buffers before calling `vla()`.
+ *
+ * @param params - Identifier of the loaded VLA model.
+ * @returns The model's hparams and the human-readable backend name
+ *   (`"CPU"` / `"Vulkan"` / `"Metal"` / `"OpenCL"` / `null` if the addon
+ *   has not surfaced one).
+ */
+export declare function vlaHparams(params: {
+    modelId: string;
+}): Promise<{
+    hparams: VlaHparams;
+    backendName: string | null;
+}>;
+/**
+ * Switch a loaded multi-embodiment GR00T model to another embodiment shipped
+ * in the same GGUF — no reload, only that embodiment's weight rows are re-read.
+ *
+ * The returned hparams follow the newly active embodiment: re-read
+ * `numCameras` (and re-size buffers if needed) before the next `vla()` call.
+ * `selectedEmbodimentTag` / `selectedEmbodimentCatId` report what was
+ * resolved. Selecting by `catId` reports that id's canonical tag, which may
+ * differ from the alias used to select — the id is the stable identity.
+ *
+ * Rejects (leaving the current embodiment active) for a non-GR00T or
+ * single-embodiment model, an unknown tag or `cat_id`, one not stored in the
+ * GGUF, an embodiment with no known camera count and no `numCameras`
+ * override, or while an inference response is still pending — await the
+ * in-flight `vla()` call first.
+ *
+ * @param params.modelId - Identifier of the loaded VLA model.
+ * @param params.embodiment - The embodiment to activate: a tag string, a
+ *   numeric `cat_id` (0..31), or `{ tag | catId, numCameras }` where
+ *   `numCameras` overrides the camera count stored in the GGUF.
+ * @returns The refreshed model hparams after the switch.
+ *
+ * @example
+ * ```typescript
+ * import { loadModel, vlaSetEmbodiment, vlaHparams } from "@qvac/sdk";
+ *
+ * const modelId = await loadModel({
+ *   modelSrc: "/path/to/groot-multi.gguf",
+ *   modelType: "vla",
+ *   modelConfig: { embodiment: "libero_sim" }, // initial selection at load
+ * });
+ * const { hparams } = await vlaSetEmbodiment({ modelId, embodiment: "real_droid" });
+ * console.log(hparams.selectedEmbodimentTag, hparams.numCameras);
+ * ```
+ */
+export declare function vlaSetEmbodiment(params: {
+    modelId: string;
+    embodiment: VlaEmbodimentSelection;
+}): Promise<{
+    hparams: VlaHparams;
+}>;
+//# sourceMappingURL=vla.d.ts.map

package/dist/src/client/api/vla.js

@@ -0,0 +1,166 @@
+import { vlaHparamsResponseSchema, vlaRunResponseSchema, vlaSetEmbodimentResponseSchema } from '@qvac/inference/surface';
+import { decodeBase64, encodeBase64 } from '../../utils/encoding.js';
+import { invokePlugin } from './invoke-plugin.js';
+const VLA_RUN_HANDLER = 'vlaRun';
+const VLA_HPARAMS_HANDLER = 'vlaHparams';
+const VLA_SET_EMBODIMENT_HANDLER = 'vlaSetEmbodiment';
+function bytesOf(arr) {
+    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function f32FromBase64(b64) {
+    const bytes = decodeBase64(b64);
+    // base64 round-trip produces a fresh Uint8Array whose buffer starts at 0
+    // and isn't shared, so the underlying ArrayBuffer is safe to reinterpret.
+    return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+}
+/**
+ * Run VLA inference on a loaded model (SmolVLA, π₀.₅, or GR00T) and return the
+ * produced action chunk plus per-stage timings.
+ *
+ * @param params - Inference inputs.
+ * @param params.modelId - Identifier of the loaded VLA model (returned by
+ *   `loadModel({ modelType: "vla", ... })`).
+ * @param params.images - The preprocessed camera frames, one per camera. For
+ *   pixel-input models (SmolVLA, π₀.₅) each is a `Float32Array` of length
+ *   `3 * imgWidth * imgHeight` in CHW layout, range `[-1, 1]`, produced by the
+ *   addon's `preprocessImage()` (re-exported as `vlaPreprocessImage`). For
+ *   patch-input models (GR00T, `hparams.imageInputMode === 'patches'`) each is
+ *   the pre-patchified buffer of length `hparams.imagePatchElems` instead. Pass
+ *   exactly `hparams.numCameras` frames (2 for SmolVLA and GR00T, 3 for π₀.₅).
+ * @param params.imgWidth - Width of each preprocessed image; must equal
+ *   `hparams.visionImageSize`.
+ * @param params.imgHeight - Height of each preprocessed image; must equal
+ *   `hparams.visionImageSize`.
+ * @param params.state - Robot end-effector / gripper state. For
+ *   continuous-state models (SmolVLA, GR00T) pad to `hparams.maxStateDim` with
+ *   `vlaPadState`. For discrete-state models (π₀.₅,
+ *   `hparams.stateInputMode === 'discrete'`) the state is tokenised into the
+ *   prompt and this buffer is ignored — pass an empty `Float32Array(0)`.
+ * @param params.tokens - Tokenized instruction (`Int32Array` of length
+ *   `hparams.tokenizerMaxLength`). Tokenize on the consumer side with the
+ *   model's tokenizer (SmolVLM2 for SmolVLA, PaliGemma/Gemma for π₀.₅,
+ *   Qwen3-VL for GR00T).
+ * @param params.mask - Token attention mask (`Uint8Array` matching `tokens`).
+ * @param params.noise - Seeded noise prior
+ *   (`Float32Array` of length `hparams.chunkSize * hparams.maxActionDim`).
+ *   Optional for SmolVLA / π₀.₅ (addon samples its own prior when omitted).
+ *   Required for GR00T (`hparams.imageInputMode === 'patches'`).
+ * @returns A `VlaClientRunResult` with the produced `actions` Float32Array
+ *   (length `chunkSize * actionDim`), the corresponding `chunkSize` /
+ *   `actionDim` returned by the addon, and optional per-stage `stats`.
+ *
+ * @example
+ * ```typescript
+ * import { loadModel, vla, vlaPreprocessImage, vlaPadState, vlaHparams } from "@qvac/sdk";
+ *
+ * const modelId = await loadModel({ modelSrc: "/path/to/smolvla.gguf", modelType: "vla" });
+ * const { hparams } = await vlaHparams({ modelId });
+ * const size = hparams.visionImageSize;
+ * const front = vlaPreprocessImage(frontPixels, frontW, frontH, { size });
+ * const wrist = vlaPreprocessImage(wristPixels, wristW, wristH, { size });
+ * const state = vlaPadState(robotState, hparams.maxStateDim);
+ * const tokens = new Int32Array(hparams.tokenizerMaxLength);
+ * const mask = new Uint8Array(hparams.tokenizerMaxLength);
+ * // ...tokenize the instruction into tokens/mask...
+ * const { actions } = await vla({
+ *   modelId, images: [front, wrist], imgWidth: size, imgHeight: size,
+ *   state, tokens, mask,
+ * });
+ * ```
+ */
+export async function vla(params) {
+    const wireRequest = {
+        type: 'vlaRun',
+        modelId: params.modelId,
+        images: params.images.map((img) => encodeBase64(bytesOf(img))),
+        imgWidth: params.imgWidth,
+        imgHeight: params.imgHeight,
+        state: encodeBase64(bytesOf(params.state)),
+        tokens: encodeBase64(bytesOf(params.tokens)),
+        mask: encodeBase64(bytesOf(params.mask)),
+        ...(params.noise !== undefined && {
+            noise: encodeBase64(bytesOf(params.noise))
+        })
+    };
+    const result = await invokePlugin({
+        modelId: params.modelId,
+        handler: VLA_RUN_HANDLER,
+        params: wireRequest
+    });
+    const parsed = vlaRunResponseSchema.parse(result);
+    return {
+        actions: f32FromBase64(parsed.actions),
+        actionDim: parsed.actionDim,
+        chunkSize: parsed.chunkSize,
+        ...(parsed.stats && { stats: parsed.stats })
+    };
+}
+/**
+ * Fetch the loaded VLA model's hyperparameters and the active ggml backend
+ * name. Useful to size token / state / noise buffers before calling `vla()`.
+ *
+ * @param params - Identifier of the loaded VLA model.
+ * @returns The model's hparams and the human-readable backend name
+ *   (`"CPU"` / `"Vulkan"` / `"Metal"` / `"OpenCL"` / `null` if the addon
+ *   has not surfaced one).
+ */
+export async function vlaHparams(params) {
+    const wireRequest = {
+        type: 'vlaHparams',
+        modelId: params.modelId
+    };
+    const result = await invokePlugin({
+        modelId: params.modelId,
+        handler: VLA_HPARAMS_HANDLER,
+        params: wireRequest
+    });
+    return vlaHparamsResponseSchema.parse(result);
+}
+/**
+ * Switch a loaded multi-embodiment GR00T model to another embodiment shipped
+ * in the same GGUF — no reload, only that embodiment's weight rows are re-read.
+ *
+ * The returned hparams follow the newly active embodiment: re-read
+ * `numCameras` (and re-size buffers if needed) before the next `vla()` call.
+ * `selectedEmbodimentTag` / `selectedEmbodimentCatId` report what was
+ * resolved. Selecting by `catId` reports that id's canonical tag, which may
+ * differ from the alias used to select — the id is the stable identity.
+ *
+ * Rejects (leaving the current embodiment active) for a non-GR00T or
+ * single-embodiment model, an unknown tag or `cat_id`, one not stored in the
+ * GGUF, an embodiment with no known camera count and no `numCameras`
+ * override, or while an inference response is still pending — await the
+ * in-flight `vla()` call first.
+ *
+ * @param params.modelId - Identifier of the loaded VLA model.
+ * @param params.embodiment - The embodiment to activate: a tag string, a
+ *   numeric `cat_id` (0..31), or `{ tag | catId, numCameras }` where
+ *   `numCameras` overrides the camera count stored in the GGUF.
+ * @returns The refreshed model hparams after the switch.
+ *
+ * @example
+ * ```typescript
+ * import { loadModel, vlaSetEmbodiment, vlaHparams } from "@qvac/sdk";
+ *
+ * const modelId = await loadModel({
+ *   modelSrc: "/path/to/groot-multi.gguf",
+ *   modelType: "vla",
+ *   modelConfig: { embodiment: "libero_sim" }, // initial selection at load
+ * });
+ * const { hparams } = await vlaSetEmbodiment({ modelId, embodiment: "real_droid" });
+ * console.log(hparams.selectedEmbodimentTag, hparams.numCameras);
+ * ```
+ */
+export async function vlaSetEmbodiment(params) {
+    const wireRequest = {
+        type: 'vlaSetEmbodiment',
+        modelId: params.modelId,
+        embodiment: params.embodiment
+    };
+    const result = await invokePlugin({
+        modelId: params.modelId,
+        handler: VLA_SET_EMBODIMENT_HANDLER,
+        params: wireRequest
+    });
+    return vlaSetEmbodimentResponseSchema.parse(result);
+}

package/dist/src/client/api/world-result.d.ts

@@ -0,0 +1,72 @@
+import { type WalkKey, type WalkKeysInput, type WorldSceneClientParams, type WorldSceneStats, type WorldSceneStreamRequest, type WorldStepClientParams, type WorldStepStats, type WorldStepStreamRequest } from '@qvac/inference/surface';
+export type WorldStepStreamFactory = (request: WorldStepStreamRequest) => AsyncGenerator<unknown>;
+export type WorldSceneStreamFactory = (request: WorldSceneStreamRequest) => AsyncGenerator<unknown>;
+/** Mirrors `VideoProgressTick` / `DiffusionProgressTick`. */
+export interface WorldStepProgressTick {
+    /** Blocks completed on this session, as the engine counts them. */
+    step: number;
+    /**
+     * Frames DELIVERED by the block that just finished — a final count, since the
+     * engine emits this after the frames rather than during. Named `totalSteps`
+     * only to keep the wire shape identical to `video` and `diffusion`.
+     */
+    totalSteps: number;
+    elapsedMs: number;
+}
+export interface WorldStepResult {
+    requestId: string;
+    /** Frames of this block, yielded as the transport delivers them. */
+    frameStream: AsyncGenerator<Uint8Array>;
+    /**
+     * The engine's own tick for each completed block, forwarded verbatim — the
+     * same field shape `video` and `diffusion` expose.
+     *
+     * NOT mid-block liveness, and it cannot be. `WorldSessionModel.cpp` runs the
+     * block to completion, delivers every frame, and only then fires its progress
+     * callback: exactly one tick per block, after the frames. So this yields once
+     * per `worldStep`, at the end. Use it to report what a block did; a "still
+     * working" signal during the 1.8-7.5s a block takes needs an addon change.
+     */
+    progressStream: AsyncGenerator<WorldStepProgressTick>;
+    /** Every frame of the block, once it completes. */
+    frames: Promise<Uint8Array[]>;
+    stats: Promise<WorldStepStats | undefined>;
+}
+/**
+ * Completion of a scene creation. The world is live on the session either way —
+ * `stats` is what tells you it finished.
+ */
+export interface WorldSceneResult {
+    requestId: string;
+    stats: Promise<WorldSceneStats | undefined>;
+}
+/**
+ * What `worldCreateScene({ returnPack: true })` returns. `scene` exists only on
+ * this shape, so the bytes cannot be awaited on a request that never asked for
+ * them — the alternative, a `Promise<Uint8Array | undefined>` on one shared
+ * type, pushes that check to every caller and hides it from the compiler.
+ *
+ * Save the bytes to walk the world again: pass the file back as
+ * `modelConfig.sceneSrc` on a later `loadModel`. `sceneSrc` stays a path/URL —
+ * it is resolved on the load path with every other model source.
+ */
+export interface WorldSceneResultWithPack extends WorldSceneResult {
+    scene: Promise<Uint8Array>;
+}
+/**
+ * Normalizes the three accepted key forms to the array the wire schema takes.
+ *
+ * A raw mask is accepted because the native session is ultimately driven by
+ * one, and a key-state object is accepted because that is what a keyboard
+ * handler naturally holds — neither should force the caller to convert.
+ */
+export declare function toWalkKeys(keys: WalkKeysInput | undefined): WalkKey[];
+export declare function createWorldStepResult(params: WorldStepClientParams, streamFactory: WorldStepStreamFactory): WorldStepResult;
+export declare function createWorldSceneResult(params: WorldSceneClientParams & {
+    returnPack: true;
+}, streamFactory: WorldSceneStreamFactory): WorldSceneResultWithPack;
+export declare function createWorldSceneResult(params: WorldSceneClientParams & {
+    returnPack?: false | undefined;
+}, streamFactory: WorldSceneStreamFactory): WorldSceneResult;
+export declare function createWorldSceneResult(params: WorldSceneClientParams, streamFactory: WorldSceneStreamFactory): WorldSceneResult | WorldSceneResultWithPack;
+//# sourceMappingURL=world-result.d.ts.map