@bitmagic/cli 0.1.1 → 0.1.3

package/dist/forge/stream.js

@@ -0,0 +1,286 @@
+import { CliError } from '../errors.js';
+import { consumeSseStream } from '../http/sse.js';
+/**
+ * Did the SERVER'S REQUEST DEADLINE fire, rather than a step failing?
+ *
+ * This has to be answered BEFORE {@link classifyForgeFailure}, because the classifier is
+ * structurally unable to get it right: a deadline that fires during the geometry step has
+ * `Scene design complete` in its progress, so the classifier correctly reports stage `forge` — and
+ * the advice for a genuine forge failure is "that step is deterministic, change the prompt rather
+ * than resuming", which is the exact opposite of what a timed-out run needs. The run was cut off
+ * mid-flight, is unharmed, and IS resumable; api-server's own deadline message says so, so without
+ * this the creator gets two contradictory sentences with the wrong one last.
+ *
+ * The deadline is not an edge case — `cli-forge.ts` notes the designer alone takes minutes with up
+ * to four attempts against a 280s budget, so it is expected to fire routinely.
+ *
+ * Primary signal is the structural `timedOut` flag on the frame. The message fallback exists
+ * because the CLI and api-server ship independently: a CLI carrying this fix can talk to a server
+ * deployed before the flag existed, and that is precisely the window in which getting this wrong
+ * costs a creator a second design. It matches on the server's own distinctive phrase and is
+ * deliberately narrow — a false positive would suppress correct "change the prompt" advice, which
+ * is the cheaper of the two errors.
+ */
+const DEADLINE_MESSAGE_MARKER = 's server limit';
+export function isDeadlineFailure(failure) {
+    return failure.timedOut || failure.message.includes(DEADLINE_MESSAGE_MARKER);
+}
+/**
+ * What to tell a creator whose run hit the server deadline: resume, unconditionally. No stage
+ * advice, because no stage failed.
+ */
+export function forgeDeadlineAdvice(jobId) {
+    const unchanged = 'world.json is unchanged.';
+    if (jobId === null) {
+        return `${unchanged} No job id was reported, so there is nothing to resume — run the command again.`;
+    }
+    return `${unchanged} Nothing failed — the server simply ran out of request time, and the work so `
+        + `far is saved. Resume it with \`bitmagic forge --resume ${jobId}\`; the steps already `
+        + 'completed are skipped and are not billed again. Do NOT start a fresh forge.';
+}
+/**
+ * What to tell a creator whose stream ended with NO terminal frame at all.
+ *
+ * This is the deadline's twin and needs the same answer — the run was cut off mid-flight, api-server
+ * deliberately does not cancel it (`cli-forge.ts`'s run promise is left to finish), and whatever it
+ * completes is written to the job's store — except that here nothing said so, because no frame
+ * arrived to say it. Without a job id the creator's only move is a fresh `--prompt` run, which mints
+ * a NEW job id and re-runs (and re-bills) a design the abandoned job may already have finished and
+ * saved. That is why {@link requestForge} tracks the job id off EVERY frame rather than only the
+ * terminal one: api-server puts it on every progress frame precisely so this case has an answer.
+ */
+export function forgeTruncationMessage(jobId) {
+    const opening = 'The connection to api-server ended before the forge finished. This is NOT a '
+        + 'confirmed failure: the server may already have designed the level (and billed for it) before '
+        + 'the stream broke. world.json is unchanged.';
+    if (jobId === null) {
+        return `${opening} No job id arrived before the stream broke, so there is nothing to resume — `
+            + 'run `bitmagic forge` again with the same prompt.';
+    }
+    return `${opening} The run was reported as job "${jobId}", and the server keeps whatever it `
+        + `completed — resume it with \`bitmagic forge --resume ${jobId}\` so the design is not re-run `
+        + 'and not billed a second time. Do NOT start a fresh forge.';
+}
+/**
+ * The progress lines `cli-forge.ts` emits around step 1. They bracket the step precisely — one
+ * before `steps.design(...)` is awaited, one after it returns — so "did a design-completed line
+ * arrive before the error frame?" is an exact answer to "did step 1 succeed in this request?".
+ *
+ * This is a coupling to another service's log strings, and it is deliberate but bounded: there is
+ * no step key on the wire, and `classifyForgeFailure` degrades to `unknown` (the both-cases
+ * message) the moment any of these stops matching. A drift therefore costs precision, never
+ * correctness — which is why the fallback exists rather than a default guess of one stage.
+ */
+const DESIGN_STARTED_MARKER = 'Designing the level scene';
+const DESIGN_FINISHED_MARKERS = ['Scene design complete', 'Design already complete'];
+export function classifyForgeFailure(progress) {
+    const designFinished = progress.some((line) => DESIGN_FINISHED_MARKERS.some((marker) => line.includes(marker)));
+    if (designFinished)
+        return 'forge';
+    if (progress.some((line) => line.includes(DESIGN_STARTED_MARKER)))
+        return 'design';
+    return 'unknown';
+}
+/**
+ * The resume advice for a failure, as a paragraph appended to the server's own message. Every
+ * branch says explicitly that world.json is unchanged, because a creator who does not know has to
+ * go and look — and a forge costs enough that "did I just pay for nothing, and is my project
+ * still intact?" is the first question.
+ */
+export function forgeFailureAdvice(stage, jobId) {
+    const unchanged = 'world.json is unchanged.';
+    if (jobId === null) {
+        return `${unchanged} No job id was reported, so there is nothing to resume — run the command again.`;
+    }
+    const resume = `\`bitmagic forge --resume ${jobId}\``;
+    switch (stage) {
+        case 'design':
+            return `${unchanged} The scene design did NOT complete, and it is saved only on success — `
+                + `so ${resume} re-runs the design and is billed for it again. It may well succeed on a `
+                + 'second attempt; if it keeps failing, change the prompt.';
+        case 'forge':
+            return `${unchanged} The scene design IS saved, but building its geometry failed. That step `
+                + `is deterministic: ${resume} feeds the same design to the same code and fails the same `
+                + 'way. Change the prompt and run a fresh forge rather than resuming this one.';
+        case 'unknown':
+            return `${unchanged} If the DESIGN step failed, it was not saved and ${resume} re-runs (and `
+                + 're-charges) it. If the GEOMETRY step failed, resuming fails identically — that step is '
+                + 'deterministic — so change the prompt instead of retrying.';
+    }
+}
+/**
+ * The complete message for a failed forge: the server's own text, then the ONE piece of advice
+ * that fits. The deadline check comes first and short-circuits the stage classification — see
+ * {@link isDeadlineFailure} for why the two must never both speak.
+ *
+ * The single entry point the command uses, so "which advice wins" is decided in one place and is
+ * testable without a network.
+ */
+export function describeForgeFailure(failure) {
+    const advice = isDeadlineFailure(failure)
+        ? forgeDeadlineAdvice(failure.jobId)
+        : forgeFailureAdvice(classifyForgeFailure(failure.progress), failure.jobId);
+    const glb = failure.glbUrl
+        ? ` The forged GLB is still available at ${failure.glbUrl} and can be voxelized by hand.`
+        : '';
+    return `${failure.message} ${advice}${glb}`;
+}
+/**
+ * Excludes arrays, unlike the `typeof x === 'object'` shorthand — matching `browser-host.ts`'s
+ * definition. It matters at the one call site that narrows a payload rather than a wrapper:
+ * `!isRecord(data.artifact)` is what rejects a malformed terminal frame, and a JSON array is an
+ * `object` that is emphatically not a `ForgeArtifact`.
+ */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringField(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+async function readJsonBody(response) {
+    try {
+        const parsed = await response.json();
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Maps the pre-stream failure shapes `cli-forge.ts` documents into a message an agent can act on.
+ * Never includes the access token — only the game id and the server's own text.
+ */
+async function toCliError(response, gameId) {
+    const body = await readJsonBody(response);
+    const serverMessage = stringField(body.error);
+    if (response.status === 403) {
+        // Covers both "you do not own this game" and "this job was created for a different game" —
+        // the server deliberately does not distinguish them, so neither does this.
+        return new CliError(`${serverMessage ?? `You cannot forge a level for game "${gameId}".`} world.json is unchanged.`);
+    }
+    if (response.status === 402) {
+        const { balance, required } = body;
+        const detail = typeof balance === 'number' && typeof required === 'number'
+            ? ` You have ${balance} sparks; starting a forge requires at least ${required}.`
+            : '';
+        return new CliError(`Not enough sparks to start a forge.${detail} world.json is unchanged.`);
+    }
+    if (response.status === 400) {
+        return new CliError(`${serverMessage ?? 'The server rejected this forge request.'} world.json is unchanged.`);
+    }
+    if (response.status === 503) {
+        return new CliError(`${serverMessage ?? 'Forge storage is not configured on the server.'} `
+            + 'This is a server-side configuration problem, not something this project can fix. '
+            + 'world.json is unchanged.');
+    }
+    return new CliError(`api-server returned HTTP ${response.status} starting the forge`
+        + (serverMessage ? `: ${serverMessage}.` : '.')
+        + ' world.json is unchanged.');
+}
+/** The terminal `result` frame: `{ success: true, jobId, artifact, platformerMovement? }`. */
+function asForgeSuccess(data) {
+    if (!isRecord(data) || data.success !== true)
+        return null;
+    const jobId = stringField(data.jobId);
+    if (jobId === null || !isRecord(data.artifact))
+        return null;
+    // `artifact` is trusted structurally, not field-by-field: it is a large schema produced by the
+    // very package this CLI then hands it back to, and `requireArtifact` plus the step code itself
+    // are what validate it in the only way that matters. A shallow re-validation here would give
+    // false confidence without catching anything the steps would not.
+    return {
+        success: true,
+        jobId,
+        artifact: data.artifact,
+        // Absent on every non-platformer forge, and absent from any server deployed before the field
+        // existed — so it is optional here rather than a reason to reject the frame.
+        ...(isRecord(data.platformerMovement) ? { platformerMovement: data.platformerMovement } : {}),
+    };
+}
+/**
+ * POSTs to `/api/cli/v1/forge/stream` and consumes the SSE response.
+ *
+ * A non-2xx response fails before any stream opens (see `toCliError`). On 200, each `progress`
+ * event is forwarded AND recorded, and the terminal `result`/`error` event resolves this call. A
+ * stream that closes with no terminal event is a truncated connection, not a success — and it fails
+ * with {@link forgeTruncationMessage}, naming the job id the frames already reported so the
+ * expensive half can be resumed rather than paid for twice.
+ */
+export async function requestForge(environment, accessToken, body, deps) {
+    const gameId = typeof body.gameId === 'string' ? body.gameId : '(unknown game)';
+    const url = `${environment.apiUrl}/api/cli/v1/forge/stream`;
+    let response;
+    try {
+        response = await deps.fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                Accept: 'text/event-stream',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    catch {
+        // A transport failure and an error status send people to very different places.
+        throw new CliError(`Cannot reach api-server at ${environment.apiUrl}. world.json is unchanged.`);
+    }
+    if (!response.ok) {
+        throw await toCliError(response, gameId);
+    }
+    if (!response.body) {
+        throw new CliError('The server accepted the forge but returned no stream body. world.json is unchanged.');
+    }
+    const progress = [];
+    let outcome = null;
+    /**
+     * The job id from the LAST frame that carried one, whatever kind of frame that was.
+     *
+     * Read off every frame in ONE place rather than per-branch, because the paths that most need it
+     * are exactly the ones no per-branch read covers: a stream that breaks before any terminal frame,
+     * and a terminal frame malformed enough that `asForgeSuccess` rejects it. api-server puts the job
+     * id on every progress frame (`{ jobId, message }`) for precisely this reason, so as soon as the
+     * first one arrives the work is resumable — and losing it costs the creator a second paid design.
+     */
+    let lastJobId = null;
+    const onEvent = (event) => {
+        if (isRecord(event.data)) {
+            lastJobId = stringField(event.data.jobId) ?? lastJobId;
+        }
+        if (event.event === 'progress') {
+            const message = isRecord(event.data) ? stringField(event.data.message) : null;
+            if (message !== null) {
+                progress.push(message);
+                deps.onProgress(message);
+            }
+            return false;
+        }
+        if (event.event === 'result') {
+            const success = asForgeSuccess(event.data);
+            if (success) {
+                outcome = success;
+                return true;
+            }
+            return false;
+        }
+        if (event.event === 'error') {
+            const data = isRecord(event.data) ? event.data : {};
+            outcome = {
+                success: false,
+                jobId: lastJobId,
+                message: stringField(data.message) ?? 'The forge failed without reporting a reason.',
+                ...(stringField(data.glbUrl) !== null ? { glbUrl: stringField(data.glbUrl) } : {}),
+                timedOut: data.timedOut === true,
+                progress,
+            };
+            return true;
+        }
+        return false;
+    };
+    const sawTerminal = await consumeSseStream(response.body, onEvent);
+    if (!sawTerminal || outcome === null) {
+        throw new CliError(forgeTruncationMessage(lastJobId));
+    }
+    return outcome;
+}
+//# sourceMappingURL=stream.js.map

package/dist/forge/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../src/forge/stream.ts"],"names":[],"mappings":"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"}

package/dist/forge/transport.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The CLI lane's `ForgeTransport` — the same seam game-play-agent fills with a WebSocket
+ * (`utils/voxel-ws.ts`'s `sendAndWaitForResult`), filled here by posting straight into a page the
+ * CLI owns. Semantics are deliberately re-implemented, not redesigned: null on timeout or
+ * transport failure, 3 attempts by default, an idle timeout when `progressType` is given, and
+ * matching on type AND requestId. Read `voxel-ws.ts` alongside this file — every rule below has a
+ * counterpart there, and the two must not drift.
+ *
+ * Two things differ from the web lane, both because there is no relay in between:
+ *
+ *  - The command envelope. The engine's message handler reads `{ type, data }`, so the flat
+ *    command the pipeline builds (`{ type, requestId, ...payload }`) is repacked here.
+ *  - The reply rename. The engine posts `*_SAVED` / `*_PLACED`; the pipeline awaits `*_RESULT`.
+ *    In the web lane the creator does that rename in the browser. Doing it HERE, in Node, is what
+ *    keeps the extracted pipeline byte-identical for both lanes.
+ *
+ * NOTE on the import below: `@bitmagic/world-forger` is a real **dependency** of this package,
+ * like `@bitmagic/asset-core`. It is the PUBLISHABLE half of the forger — the artifact schema, the
+ * host seams and the three browser-driven pipeline steps — and `publish-npm.yml` publishes it
+ * ahead of the CLI so npm can resolve it at install time. The private design/geometry half lives
+ * in `@bitmagic/world-forger-internal`, which is never published and must never be imported from
+ * here, nor bundled into `dist/`: bundled JS is readable, and minification is not protection.
+ */
+import type { ForgeTransport } from '@bitmagic/world-forger/pipeline/transport-types.js';
+/** The `{ type, data }` envelope `CreatorMessageHandler` dispatches on. */
+export interface PageCommand {
+    type: string;
+    data: Record<string, unknown>;
+}
+/**
+ * The narrow slice of "a loaded game page" the transport needs. `browser-host.ts` implements it
+ * over Playwright; tests implement it with an object, which is why every rule in this file is
+ * unit-testable without a browser.
+ */
+export interface ForgePageBridge {
+    /** Post a command into the page. Rejecting means the page is gone — a transport failure. */
+    postCommand(command: PageCommand): Promise<void>;
+    /** Subscribe to every message the page posted. Returns an unsubscribe. */
+    onMessage(listener: (message: Record<string, unknown>) => void): () => void;
+}
+export interface ForgePageTransportOptions {
+    log?: (message: string) => void;
+    /** Gap between attempts. Overridden in tests; 1s in production, matching the web lane. */
+    retryDelayMs?: number;
+}
+/**
+ * Reply-name → awaited-name. Authoritative list carried over from the creator's own relay
+ * (`game-play-agent/src/lab/browser.ts:112-123`). The last two entries are identity: the level
+ * bake already posts its result and its progress under the names the pipeline awaits, and they are
+ * listed rather than omitted so this map reads as the complete forge vocabulary.
+ */
+export declare const RESULT_TYPE_MAP: Record<string, string>;
+/**
+ * Build the transport over a page bridge. The returned object is the shared package's
+ * `ForgeTransport` and nothing more — `commands/forge.ts` hands it straight to
+ * `ForgeDeps.transport` via `buildCliForgeDeps`.
+ */
+export declare function createForgePageTransport(bridge: ForgePageBridge, options?: ForgePageTransportOptions): ForgeTransport;

package/dist/forge/transport.js

@@ -0,0 +1,145 @@
+/**
+ * Reply-name → awaited-name. Authoritative list carried over from the creator's own relay
+ * (`game-play-agent/src/lab/browser.ts:112-123`). The last two entries are identity: the level
+ * bake already posts its result and its progress under the names the pipeline awaits, and they are
+ * listed rather than omitted so this map reads as the complete forge vocabulary.
+ */
+export const RESULT_TYPE_MAP = {
+    VOXEL_OBJECT_PLACED: 'VOXEL_PLACE_RESULT',
+    BATCH_VOXEL_OBJECTS_PLACED: 'BATCH_VOXEL_PLACE_RESULT',
+    VOXEL_OBJECT_MODIFIED: 'VOXEL_MODIFY_RESULT',
+    VOXEL_OBJECT_DELETED: 'VOXEL_DELETE_RESULT',
+    VOXEL_ASSET_SAVED: 'VOXEL_ASSET_RESULT',
+    ASSET_FROM_GLB_URL_SAVED: 'ASSET_FROM_GLB_URL_RESULT',
+    VOXELIZE_GLB_AS_LEVEL_RESULT: 'VOXELIZE_GLB_AS_LEVEL_RESULT',
+    VOXELIZE_GLB_AS_LEVEL_PROGRESS: 'VOXELIZE_GLB_AS_LEVEL_PROGRESS',
+};
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 1000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Whether a page message answers a caller awaiting `expected`.
+ *
+ * BOTH the message's own type and its renamed form count, because the pipeline is not consistent
+ * about which vocabulary it awaits — and it cannot be made consistent from this side, since the
+ * same code runs behind the web lane's relay:
+ *
+ *   - `create-level-archetypes.ts` awaits `ASSET_FROM_GLB_URL_RESULT` — the RENAMED name.
+ *   - `voxelize-level.ts` awaits `VOXELIZE_GLB_AS_LEVEL_RESULT` — renamed, but identity.
+ *   - `place-and-persist-level.ts` awaits `BATCH_VOXEL_OBJECTS_PLACED` — the ENGINE's OWN name,
+ *     which the map renames to `BATCH_VOXEL_PLACE_RESULT`.
+ *
+ * Renaming alone therefore answers two of the three and silently starves the third: the engine
+ * posts `BATCH_VOXEL_OBJECTS_PLACED`, this returns `BATCH_VOXEL_PLACE_RESULT`, nothing matches,
+ * and placement waits out its full idle timeout three times over. That is not hypothetical — it
+ * is what the first end-to-end forge did, after successfully baking every chunk.
+ *
+ * Accepting either name is safe here because no engine reply name is another's renamed form; the
+ * map's values are all distinct from its keys except the two deliberate identities.
+ */
+function matchesAwaited(message, expected) {
+    const raw = message.type;
+    if (typeof raw !== 'string')
+        return false;
+    // Unmapped types compare on their own name rather than being dropped, so a reply the engine
+    // gains later reaches a caller awaiting it instead of vanishing into a timeout.
+    return raw === expected || RESULT_TYPE_MAP[raw] === expected;
+}
+/**
+ * One send + wait. Resolves the matching message, or null on timeout / a failed post — never
+ * rejects, because callers distinguish "no answer" from "answered with an error".
+ */
+function singleAttempt(bridge, command, requestId, resultType, timeoutMs, progressType, log) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let timer;
+        let unsubscribe;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            unsubscribe?.();
+            resolve(result);
+        };
+        // (Re)arm the idle timer. Called once up front and again on every progress event, so the
+        // deadline is "no progress (or result) for timeoutMs", not a flat cap on the whole job.
+        const armTimer = () => {
+            if (settled)
+                return;
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => {
+                log(`forge transport: no ${resultType} within ${timeoutMs}ms of silence`);
+                finish(null);
+            }, timeoutMs);
+        };
+        unsubscribe = bridge.onMessage((message) => {
+            // Progress for THIS request keeps the attempt alive and resets the idle timer.
+            if (progressType && matchesAwaited(message, progressType) && (!requestId || message.requestId === requestId)) {
+                armTimer();
+                return;
+            }
+            if (!matchesAwaited(message, resultType))
+                return;
+            if (requestId && message.requestId !== requestId)
+                return;
+            // Surface the real failure reason: some engine paths put it in `message`, but every caller
+            // reads `result.error` — mirror it rather than let a clear reason degrade to "unknown".
+            // Copied, never mutated in place: `ForgeBrowserHost.dispatch` hands the SAME object to every
+            // subscribed listener, and step 5 places instances in batches with concurrent waits, so a
+            // mutation here would be visible to another waiter. (`voxel-ws.ts` mutates safely only
+            // because each of its connections parses its own object.)
+            if (message.success === false && !message.error && typeof message.message === 'string') {
+                finish({ ...message, error: message.message });
+                return;
+            }
+            finish(message);
+        });
+        // Armed before the post, not after it, so a `page.evaluate` that never settles (a hung or
+        // crashed renderer) is bounded by the same timeout as a silent game.
+        armTimer();
+        bridge.postCommand(command).catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            log(`forge transport: could not post ${command.type} into the page: ${detail}`);
+            finish(null);
+        });
+    });
+}
+/**
+ * Build the transport over a page bridge. The returned object is the shared package's
+ * `ForgeTransport` and nothing more — `commands/forge.ts` hands it straight to
+ * `ForgeDeps.transport` via `buildCliForgeDeps`.
+ */
+export function createForgePageTransport(bridge, options) {
+    const log = options?.log ?? (() => { });
+    const retryDelayMs = options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+    return {
+        async sendAndWait(command, resultType, timeoutMs, waitOptions) {
+            const { type, ...payload } = command;
+            if (typeof type !== 'string') {
+                // Not a timeout and not a transport failure — a malformed command is a caller bug, and
+                // returning null here would hide it as "the browser never answered".
+                throw new Error(`A forge command must carry a string \`type\`, got ${JSON.stringify(type)}`);
+            }
+            const requestId = typeof command.requestId === 'string' ? command.requestId : undefined;
+            const envelope = { type, data: payload };
+            const maxRetries = waitOptions?.maxRetries ?? DEFAULT_MAX_RETRIES;
+            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                const result = await singleAttempt(bridge, envelope, requestId, resultType, timeoutMs, waitOptions?.progressType, log);
+                if (result !== null)
+                    return result;
+                if (attempt < maxRetries) {
+                    log(`forge transport: ${type} attempt ${attempt} failed, retrying in ${retryDelayMs}ms`);
+                    await sleep(retryDelayMs);
+                }
+            }
+            log(`forge transport: ${type} exhausted ${maxRetries} attempt(s) waiting for ${resultType}`);
+            return null;
+        },
+    };
+}
+//# sourceMappingURL=transport.js.map

package/dist/forge/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/forge/transport.ts"],"names":[],"mappings":"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"}

package/dist/forge/upload-proxy.d.ts

@@ -0,0 +1,21 @@
+/** The path the ENGINE calls. Not api-server's — that is what this proxy translates. */
+export declare const ENGINE_UPLOAD_PATH = "/api/generate-upload-url";
+/** The api-server route it forwards to. */
+export declare const API_SERVER_UPLOAD_PATH = "/api/cli/v1/uploads/signed-url";
+export interface UploadProxyOptions {
+    /** api-server base URL, e.g. `https://beta.portal.bitmagic.cloud`. */
+    apiUrl: string;
+    /** The creator's access token. Never leaves this process. */
+    token: string;
+    /** The game the CLI project owns. Overrides whatever the page asks for. */
+    gameId: string;
+    log?: (message: string) => void;
+    /** Injected in tests. Defaults to global fetch. */
+    fetchImpl?: typeof fetch;
+}
+export interface UploadProxy {
+    /** What `agentUrl` should be set to, e.g. `http://127.0.0.1:51234`. */
+    readonly url: string;
+    close(): Promise<void>;
+}
+export declare function startUploadProxy(options: UploadProxyOptions): Promise<UploadProxy>;