@qvac/sdk 0.18.2 → 0.19.0

package/dist/src/client/api/world-result.js

@@ -0,0 +1,296 @@
+import { MAX_SCENE_IMAGE_BYTES, walkKeySchema, worldSceneStreamRequestSchema, worldSceneStreamResponseSchema, worldStepStreamRequestSchema, worldStepStreamResponseSchema } from '@qvac/inference/surface';
+import { parseClientInput } from '../parse-input.js';
+import { generateClientRequestId } from './client-request-id.js';
+import { decodeBase64, encodeBase64 } from '../../utils/encoding.js';
+import { InvalidResponseError, RequestValidationFailedError, StreamEndedError } from '../../utils/errors-client.js';
+import { InferenceCancelledError } from '../../utils/errors-server.js';
+import { SDK_SERVER_ERROR_CODES } from '../../schemas/sdk-errors-server.js';
+/** Bit order the native action adapter expects: bit 0..7 = W,A,S,D,I,J,K,L. */
+const KEY_ORDER = ['W', 'A', 'S', 'D', 'I', 'J', 'K', 'L'];
+/**
+ * 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 function toWalkKeys(keys) {
+    if (keys === undefined)
+        return [];
+    if (typeof keys === 'number') {
+        if (!Number.isInteger(keys) || keys < 0 || keys > 255) {
+            throw new RequestValidationFailedError(`walk key mask must be an integer in [0, 255], got: ${keys}`);
+        }
+        return KEY_ORDER.filter((_, bit) => (keys & (1 << bit)) !== 0);
+    }
+    const pressed = Array.isArray(keys)
+        ? keys.map((key) => String(key))
+        : Object.entries(keys)
+            .filter(([, held]) => Boolean(held))
+            .map(([key]) => key);
+    const seen = new Set();
+    for (const key of pressed) {
+        const parsed = walkKeySchema.safeParse(key.toUpperCase());
+        if (!parsed.success) {
+            throw new RequestValidationFailedError(`unknown walk key '${key}' (valid: ${KEY_ORDER.join(', ')})`);
+        }
+        seen.add(parsed.data);
+    }
+    // Emit in bit order so an identical set of keys always produces an identical
+    // request, whatever order the caller supplied them in.
+    return KEY_ORDER.filter((key) => seen.has(key));
+}
+function deferred() {
+    let resolve = () => { };
+    let reject = () => { };
+    let settled = false;
+    const promise = new Promise((res, rej) => {
+        resolve = (value) => {
+            settled = true;
+            res(value);
+        };
+        reject = (error) => {
+            settled = true;
+            rej(error);
+        };
+    });
+    // Nothing else settles these, so an unobserved rejection must not surface as
+    // an unhandled rejection just because the caller only awaited one of them.
+    promise.catch(() => { });
+    return { promise, resolve, reject, isSettled: () => settled };
+}
+/**
+ * A stream that ends without a `done` frame has to fail the result promises
+ * explicitly. Nothing else settles them, so leaving them pending turns a
+ * dropped connection or a truncated stream into an `await` that never returns —
+ * a hang the caller cannot distinguish from slow generation, and cannot time
+ * out because no error is ever delivered.
+ *
+ * `StreamEndedError` rather than a bare `Error`, matching `upscale.ts`, so a
+ * caller can `instanceof` a dropped walk instead of matching on message text.
+ */
+function truncatedStream() {
+    return new StreamEndedError();
+}
+/**
+ * The world ops throw `InferenceCancelledError` on the server, so it crosses the
+ * RPC envelope and arrives as a generic `RPCError` — `instanceof` fails and a
+ * caller cannot tell a cancelled walk from a failed one. Rebuild it here rather
+ * than registering a reconstructor in `client/rpc/rpc-error.ts`: that file's
+ * maintenance contract keeps client-constructed typed errors out of the
+ * reconstructor map, because a global entry would also fire for the completion
+ * path, which builds this same class from its aggregated partial state.
+ */
+function asClientError(error, requestId) {
+    if (error instanceof InferenceCancelledError)
+        return error;
+    const code = error?.code;
+    if (code === SDK_SERVER_ERROR_CODES.INFERENCE_CANCELLED) {
+        return new InferenceCancelledError(requestId, {}, error);
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+export function createWorldStepResult(params, streamFactory) {
+    const requestId = generateClientRequestId();
+    const { keys, ...rest } = params;
+    // Validate before opening the stream so a bad key or a missing modelId fails
+    // here rather than costing a server round-trip, as audio-gen-result.ts does.
+    const request = parseClientInput(worldStepStreamRequestSchema, {
+        ...rest,
+        keys: toWalkKeys(keys),
+        type: 'worldStepStream',
+        requestId
+    });
+    const collected = [];
+    const pending = [];
+    // Its own queue and its own waker: a progress tick must not wake the frame
+    // generator into an empty buffer, and a consumer may iterate either stream
+    // alone.
+    const progressPending = [];
+    let done = false;
+    // Set by the terminal `done` frame; later chunks for the same request are
+    // ignored rather than appended to a block that has already been delivered.
+    let terminated = false;
+    let streamError = null;
+    let wake = null;
+    let progressWake = null;
+    const framesOut = deferred();
+    const statsOut = deferred();
+    async function pump() {
+        try {
+            for await (const response of streamFactory(request)) {
+                if (response === null ||
+                    typeof response !== 'object' ||
+                    !('type' in response) ||
+                    response.type !== 'worldStepStream') {
+                    continue;
+                }
+                const parsed = worldStepStreamResponseSchema.parse(response);
+                if (parsed.step !== undefined &&
+                    parsed.totalSteps !== undefined &&
+                    parsed.elapsedMs !== undefined) {
+                    progressPending.push({
+                        step: parsed.step,
+                        totalSteps: parsed.totalSteps,
+                        elapsedMs: parsed.elapsedMs
+                    });
+                    progressWake?.();
+                    progressWake = null;
+                }
+                // `done` is terminal for this block. Anything after it is not part of
+                // the block the caller was handed, and accepting it would let
+                // `frameStream` and the `frames` promise disagree about the same block:
+                // `frames` is already resolved with what `collected` held at `done`,
+                // while the generator would keep yielding.
+                if (terminated)
+                    continue;
+                if (parsed.data) {
+                    const frame = decodeBase64(parsed.data);
+                    collected.push(frame);
+                    pending.push(frame);
+                    wake?.();
+                    wake = null;
+                }
+                if (parsed.done) {
+                    terminated = true;
+                    statsOut.resolve(parsed.stats);
+                    framesOut.resolve(collected);
+                }
+            }
+        }
+        catch (error) {
+            streamError = asClientError(error, requestId);
+            statsOut.reject(streamError);
+            framesOut.reject(streamError);
+        }
+        if (!framesOut.isSettled()) {
+            const truncated = streamError ?? truncatedStream();
+            streamError = truncated;
+            statsOut.reject(truncated);
+            framesOut.reject(truncated);
+        }
+        done = true;
+        wake?.();
+        wake = null;
+        progressWake?.();
+        progressWake = null;
+    }
+    void pump();
+    const progressStream = (async function* () {
+        while (true) {
+            if (progressPending.length > 0) {
+                yield progressPending.shift();
+            }
+            else if (done) {
+                if (streamError)
+                    throw streamError;
+                return;
+            }
+            else {
+                await new Promise((resolve) => {
+                    progressWake = resolve;
+                });
+            }
+        }
+    })();
+    const frameStream = (async function* () {
+        while (true) {
+            if (pending.length > 0) {
+                yield pending.shift();
+            }
+            else if (done) {
+                // The cast satisfies @typescript-eslint/only-throw-error, which does not
+                // accept the `Error | null` declared type as throwable even though the
+                // guard narrows it. Same shape as client/api/video.ts.
+                if (streamError)
+                    throw streamError;
+                return;
+            }
+            else {
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+            }
+        }
+    })();
+    return {
+        requestId,
+        frameStream,
+        progressStream,
+        frames: framesOut.promise,
+        stats: statsOut.promise
+    };
+}
+export function createWorldSceneResult(params, streamFactory) {
+    const requestId = generateClientRequestId();
+    const { image, ...rest } = params;
+    // Checked on the RAW bytes, before base64. The schema has a `.max()` on the
+    // encoded string, but it cannot be relied on to produce the error: Zod runs
+    // every check on a string regardless of order, so the base64 pattern runs too,
+    // and on V8 that pattern THROWS `RangeError: Maximum call stack size exceeded`
+    // rather than returning false once the input passes roughly 4.5M characters.
+    // `parseClientInput` only converts `ZodError`, so the caller would get a raw
+    // RangeError instead of the typed validation error this API promises.
+    if (image.byteLength > MAX_SCENE_IMAGE_BYTES) {
+        throw new RequestValidationFailedError(`The first-frame image is ${image.byteLength} bytes, over the ` +
+            `${MAX_SCENE_IMAGE_BYTES}-byte ceiling. It is cover-scaled and cropped to ` +
+            'width x height, so send a smaller one.');
+    }
+    // Empty prompts and dimensions that are not multiples of 32 are rejected
+    // locally rather than after a round-trip carrying ~10 MB of image bytes.
+    const request = parseClientInput(worldSceneStreamRequestSchema, {
+        ...rest,
+        image: encodeBase64(image),
+        type: 'worldSceneStream',
+        requestId
+    });
+    const wantsPack = params.returnPack === true;
+    const sceneOut = deferred();
+    const statsOut = deferred();
+    async function pump() {
+        try {
+            let scene;
+            for await (const response of streamFactory(request)) {
+                if (response === null ||
+                    typeof response !== 'object' ||
+                    !('type' in response) ||
+                    response.type !== 'worldSceneStream') {
+                    continue;
+                }
+                const parsed = worldSceneStreamResponseSchema.parse(response);
+                if (parsed.data)
+                    scene = decodeBase64(parsed.data);
+                if (parsed.done) {
+                    statsOut.resolve(parsed.stats);
+                    if (scene) {
+                        sceneOut.resolve(scene);
+                    }
+                    else if (wantsPack) {
+                        // Only a failure when the caller asked for the bytes; otherwise the
+                        // server keeping them is the whole point of the default.
+                        // Same typed error the other stream helpers raise for a response
+                        // that is well-formed but missing what it promised — see
+                        // audio-gen-result.ts and cancel.ts.
+                        sceneOut.reject(new InvalidResponseError('worldSceneStream scene pack'));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const failure = asClientError(error, requestId);
+            statsOut.reject(failure);
+            sceneOut.reject(failure);
+        }
+        if (!statsOut.isSettled()) {
+            const failure = truncatedStream();
+            statsOut.reject(failure);
+            sceneOut.reject(failure);
+        }
+    }
+    void pump();
+    // `scene` is present only on the requested shape, so a caller who did not ask
+    // for the bytes has nothing to await by mistake.
+    return wantsPack
+        ? { requestId, scene: sceneOut.promise, stats: statsOut.promise }
+        : { requestId, stats: statsOut.promise };
+}

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

@@ -0,0 +1,144 @@
+import type { WorldSceneClientParams, WorldStepClientParams } from '@qvac/inference/surface';
+import { type WorldSceneResult, type WorldSceneResultWithPack, type WorldStepResult } from './world-result.js';
+/**
+ * Builds a world for an ABot-World session: the prompt and first frame are
+ * encoded into a scene pack the walk then runs on.
+ *
+ * Run this once per world. The world is live on the session as soon as this
+ * completes — `stats` is the completion signal. Creating a world on a session
+ * that already has one replaces it and restarts the walk from the beginning.
+ *
+ * The pack itself is NOT returned by default: it is 10+ MB, a third larger again
+ * as base64, and the common create-then-walk-now flow never touches the bytes.
+ * Pass `returnPack: true` to get them, save them, and pass that file back as
+ * `modelConfig.sceneSrc` on a later `loadModel` to walk the same world again.
+ * `sceneSrc` takes a path or URL, so persist the bytes yourself.
+ *
+ * Scene creation cannot be interrupted — the engine exposes no abort hook for
+ * it — so cancelling by request id stops the SDK from yielding but the encode
+ * runs to completion. Await the result before unloading the model.
+ *
+ * @param params - Loaded world model ID, scene prompt, first-frame image bytes, optional dimensions, and `returnPack`.
+ * @returns `requestId` and `stats`; plus `scene` (promise of the pack) when `returnPack: true`.
+ * @throws {RequestValidationFailedError} Client-side, before any RPC, if the
+ *   prompt is empty, the dimensions are not positive multiples of 32 within the
+ *   per-axis and total-pixel ceilings, or the first frame exceeds 3 MB.
+ *   Server-side, before the session is touched, if the first frame's header
+ *   declares more than 8192x8192 pixels or cannot be read. Raised as
+ *   `PluginRequestValidationFailedError` on the engine; that class is not
+ *   exported from the client package and is not in the RPC reconstructor map, so
+ *   match it on message rather than with `instanceof`.
+ * @throws {ModelOperationNotSupportedError} If the model was not loaded with
+ *   `mode: "world"`.
+ * @throws {RequestRejectedByPolicyError} If a world job is already running on
+ *   this model — world refuses rather than queues.
+ * @throws {InferenceCancelledError} If cancel by request id is accepted.
+ *   Scene creation is uninterruptible, so this stops delivery while the encode
+ *   runs to completion.
+ * @throws {StreamEndedError} If the RPC stream closes without a terminal
+ *   `done` chunk.
+ *
+ * @example
+ * ```typescript
+ * const modelId = await loadModel({
+ *   modelType: "diffusion",
+ *   modelSrc: ABOT_WORLD_0_5B_Q8_0,
+ *   modelConfig: {
+ *     mode: "world",
+ *     taehvModelSrc: ABOT_WORLD_0_5B_LF_VAE,
+ *     t5XxlModelSrc: UMT5_XXL_ENC_Q8_0,
+ *     vaeModelSrc: ABOT_WORLD_0_5B_LF_VAE_F16,
+ *     world: { seed: 42, kvCache: true },
+ *   },
+ * });
+ *
+ * // Walk it now and never persist it: no pack crosses the wire.
+ * const { stats } = worldCreateScene({
+ *   modelId,
+ *   prompt: "| unknown | A realistic outdoor world scene with a navigable path.",
+ *   image: fs.readFileSync("first-frame.jpg"),
+ * });
+ * await stats;
+ *
+ * // Or keep it, to walk the same world after a reload.
+ * const { scene } = worldCreateScene({
+ *   modelId,
+ *   prompt: "| unknown | A realistic outdoor world scene with a navigable path.",
+ *   image: fs.readFileSync("first-frame.jpg"),
+ *   returnPack: true,
+ * });
+ * fs.writeFileSync("world.safetensors", await scene);
+ * ```
+ */
+export declare function worldCreateScene(params: WorldSceneClientParams & {
+    returnPack: true;
+}): WorldSceneResultWithPack;
+export declare function worldCreateScene(params: WorldSceneClientParams & {
+    returnPack?: false | undefined;
+}): WorldSceneResult;
+export declare function worldCreateScene(params: WorldSceneClientParams): WorldSceneResult | WorldSceneResultWithPack;
+/**
+ * Generates the next block of an ABot-World walk under the keys held for it.
+ *
+ * One call produces one block: at the default `world.numFramePerBlock`, 9 frames
+ * for the first block after the session loads (decoder warmup) and 12
+ * thereafter. Both counts move with `numFramePerBlock`, so read `stats.frames`
+ * rather than assuming them. Frames arrive on `frameStream` as they are decoded,
+ * so a viewer can display them without waiting for the block.
+ *
+ * Only one block runs at a time per model — a second call while one is in
+ * flight is rejected rather than queued, so drive the next call off the
+ * previous one. Cancelling has block granularity: the current block finishes
+ * internally, delivery stops, and the call rejects rather than returning a
+ * truncated block.
+ *
+ * `keys` accepts an array, a key-state object, or a raw 8-bit mask. WASD move,
+ * IJKL steer the camera; omit for an idle block.
+ *
+ * `progressStream` forwards the engine's step / totalSteps / elapsedMs tick,
+ * the same shape `video` and `diffusion` emit. The engine fires it once per
+ * block, AFTER the frames, so it is an end-of-block summary rather than
+ * mid-block liveness — one tick per `worldStep` call.
+ *
+ * @param params - Loaded world model ID and the keys held for this block.
+ * @returns `requestId`, `frameStream`, `progressStream`, `frames` (the whole block), and `stats`.
+ * @throws {RequestValidationFailedError} Client-side, before any RPC, on an
+ *   unknown walk key.
+ * @throws {ModelOperationNotSupportedError} If the model was not loaded with
+ *   `mode: "world"`.
+ * @throws {RequestRejectedByPolicyError} If a block is already in flight on
+ *   this model.
+ * @throws {InferenceCancelledError} If cancel by request id is accepted. The
+ *   step rejects rather than resolving with a truncated block, and the session
+ *   is rebuilt on the next call.
+ * @throws {StreamEndedError} If the RPC stream closes without a terminal
+ *   `done` chunk.
+ *
+ * @example Walk forward, displaying frames as they arrive
+ * ```typescript
+ * const { frameStream } = worldStep({ modelId, keys: ["W"] });
+ * for await (const frame of frameStream) {
+ *   display(frame); // PNG, or JPEG when world.frameJpegQuality is set
+ * }
+ * ```
+ *
+ * @example Report what each block did
+ * ```typescript
+ * const { progressStream, frames } = worldStep({ modelId, keys: ["W"] });
+ * for await (const { totalSteps, elapsedMs } of progressStream) {
+ *   // Once per block, after its frames: a summary, not a spinner tick.
+ *   report(`block delivered ${totalSteps} frames in ${elapsedMs}ms`);
+ * }
+ * for (const frame of await frames) display(frame);
+ * ```
+ *
+ * @example Drive a key loop off the one-block-at-a-time contract
+ * ```typescript
+ * while (walking) {
+ *   const { frames } = worldStep({ modelId, keys: heldKeys }); // e.g. { W: true, L: true }
+ *   for (const frame of await frames) display(frame);
+ * }
+ * ```
+ */
+export declare function worldStep(params: WorldStepClientParams): WorldStepResult;
+//# sourceMappingURL=world.d.ts.map

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

@@ -0,0 +1,71 @@
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+import { createWorldSceneResult, createWorldStepResult } from './world-result.js';
+export function worldCreateScene(params) {
+    return createWorldSceneResult(params, streamRpc);
+}
+/**
+ * Generates the next block of an ABot-World walk under the keys held for it.
+ *
+ * One call produces one block: at the default `world.numFramePerBlock`, 9 frames
+ * for the first block after the session loads (decoder warmup) and 12
+ * thereafter. Both counts move with `numFramePerBlock`, so read `stats.frames`
+ * rather than assuming them. Frames arrive on `frameStream` as they are decoded,
+ * so a viewer can display them without waiting for the block.
+ *
+ * Only one block runs at a time per model — a second call while one is in
+ * flight is rejected rather than queued, so drive the next call off the
+ * previous one. Cancelling has block granularity: the current block finishes
+ * internally, delivery stops, and the call rejects rather than returning a
+ * truncated block.
+ *
+ * `keys` accepts an array, a key-state object, or a raw 8-bit mask. WASD move,
+ * IJKL steer the camera; omit for an idle block.
+ *
+ * `progressStream` forwards the engine's step / totalSteps / elapsedMs tick,
+ * the same shape `video` and `diffusion` emit. The engine fires it once per
+ * block, AFTER the frames, so it is an end-of-block summary rather than
+ * mid-block liveness — one tick per `worldStep` call.
+ *
+ * @param params - Loaded world model ID and the keys held for this block.
+ * @returns `requestId`, `frameStream`, `progressStream`, `frames` (the whole block), and `stats`.
+ * @throws {RequestValidationFailedError} Client-side, before any RPC, on an
+ *   unknown walk key.
+ * @throws {ModelOperationNotSupportedError} If the model was not loaded with
+ *   `mode: "world"`.
+ * @throws {RequestRejectedByPolicyError} If a block is already in flight on
+ *   this model.
+ * @throws {InferenceCancelledError} If cancel by request id is accepted. The
+ *   step rejects rather than resolving with a truncated block, and the session
+ *   is rebuilt on the next call.
+ * @throws {StreamEndedError} If the RPC stream closes without a terminal
+ *   `done` chunk.
+ *
+ * @example Walk forward, displaying frames as they arrive
+ * ```typescript
+ * const { frameStream } = worldStep({ modelId, keys: ["W"] });
+ * for await (const frame of frameStream) {
+ *   display(frame); // PNG, or JPEG when world.frameJpegQuality is set
+ * }
+ * ```
+ *
+ * @example Report what each block did
+ * ```typescript
+ * const { progressStream, frames } = worldStep({ modelId, keys: ["W"] });
+ * for await (const { totalSteps, elapsedMs } of progressStream) {
+ *   // Once per block, after its frames: a summary, not a spinner tick.
+ *   report(`block delivered ${totalSteps} frames in ${elapsedMs}ms`);
+ * }
+ * for (const frame of await frames) display(frame);
+ * ```
+ *
+ * @example Drive a key loop off the one-block-at-a-time contract
+ * ```typescript
+ * while (walking) {
+ *   const { frames } = worldStep({ modelId, keys: heldKeys }); // e.g. { W: true, L: true }
+ *   for (const frame of await frames) display(frame);
+ * }
+ * ```
+ */
+export function worldStep(params) {
+    return createWorldStepResult(params, streamRpc);
+}

package/dist/src/client/config-loader/config-utils.d.ts

@@ -0,0 +1,5 @@
+import { type QvacConfig } from '@qvac/inference/surface';
+export type { QvacConfig };
+export declare function validateConfig(config: unknown): QvacConfig;
+export declare function parseJsonConfig(content: string, filePath: string): unknown;
+//# sourceMappingURL=config-utils.d.ts.map

package/dist/src/client/config-loader/config-utils.js

@@ -0,0 +1,18 @@
+import { qvacConfigSchema } from '@qvac/inference/surface';
+import { ConfigValidationFailedError } from '../../utils/errors-client.js';
+import { formatZodError } from '../../utils/zod-error.js';
+export function validateConfig(config) {
+    const result = qvacConfigSchema.safeParse(config);
+    if (!result.success) {
+        throw new ConfigValidationFailedError(formatZodError(result.error));
+    }
+    return result.data;
+}
+export function parseJsonConfig(content, filePath) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        throw new ConfigValidationFailedError(`Invalid JSON in config file: ${filePath}`);
+    }
+}

package/dist/src/client/config-loader/resolve-config.expo.js

@@ -0,0 +1,60 @@
+/**
+ * Config loader for Expo/React Native runtime
+ * Only uses expo-file-system - no Node.js or Bare imports
+ */
+import { File, Paths } from 'expo-file-system';
+import { validateConfig, parseJsonConfig } from './config-utils.js';
+import { getClientLogger } from '../../logging/index.js';
+const logger = getClientLogger();
+function fileExists(filePath) {
+    try {
+        const file = new File(filePath);
+        return file.exists;
+    }
+    catch {
+        return false;
+    }
+}
+async function readFile(filePath) {
+    const file = new File(filePath);
+    return await file.text();
+}
+async function loadJsonConfig(filePath) {
+    const content = await readFile(filePath);
+    const parsed = parseJsonConfig(content, filePath);
+    return validateConfig(parsed);
+}
+/**
+ * Resolution order for Expo:
+ * 1. QVAC_CONFIG_PATH environment variable (if set)
+ * 2. Default Expo path: ${Paths.document.uri}qvac.config.json
+ * 3. SDK defaults
+ *
+ * Note: Only JSON config files are supported in React Native
+ */
+export async function resolveConfig() {
+    // Check environment variable first
+    const configPath = typeof process !== 'undefined' ? process.env?.['QVAC_CONFIG_PATH'] : undefined;
+    if (configPath) {
+        if (fileExists(configPath)) {
+            logger.info(`✅ Loaded config from: ${configPath}`);
+            return await loadJsonConfig(configPath);
+        }
+    }
+    // Try default Expo document directory path
+    try {
+        const documentDir = Paths.document.uri;
+        if (documentDir) {
+            const defaultExpoConfigPath = `${documentDir}qvac.config.json`;
+            if (fileExists(defaultExpoConfigPath)) {
+                logger.info(`✅ Loaded config from: ${defaultExpoConfigPath}`);
+                return await loadJsonConfig(defaultExpoConfigPath);
+            }
+        }
+    }
+    catch {
+        // Paths not available
+    }
+    logger.info('ℹ️ No config file found, using SDK defaults');
+    return undefined;
+}