summer-engine 2.8.2 → 3.1.0

package/dist/{lib → core}/api-client.js

@@ -1,23 +1,11 @@
-import { mkdir, writeFile } from "fs/promises";
+import { mkdir, readdir, rm, stat, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
 import { randomUUID } from "node:crypto";
-import { getApiToken, getApiPort, checkEngineHealth, resolveEngineConnection, } from "./engine.js";
+import { checkEngineHealth, discoverRegistryConnection, engineNotRunningError, engineSelectionFromEnv, getApiPort, getApiToken, resolveEngineConnection, } from "./engine.js";
+import { asRecord, boolFrom, numberFrom, stringFrom } from "./util/json.js";
 import { classifyOpsResponse, pollOpToTerminal, } from "./async-op-lifecycle.js";
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function stringFrom(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function numberFrom(value) {
-    return typeof value === "number" ? value : undefined;
-}
-function boolFrom(value) {
-    return typeof value === "boolean" ? value : undefined;
-}
+import { pickPlayDeterminism } from "./capabilities/play-determinism.js";
 function findSnapshotPayload(value) {
     const record = asRecord(value);
     if (!record)
@@ -65,6 +53,38 @@ function withoutImageData(payload) {
     }
     return metadata;
 }
+/** rebind() could not re-read engine health; the session identity is unchanged. */
+export class EngineRebindError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EngineRebindError";
+    }
+}
+const SNAPSHOT_TTL_MS = 24 * 60 * 60 * 1000;
+/**
+ * Snapshot files otherwise accumulate in tmpdir for the life of the machine.
+ * Remove those older than 24h on each write. Best-effort by contract: a
+ * failed reap must never fail (or slow down) the capture that triggered it.
+ */
+async function reapStaleSnapshots(dir) {
+    try {
+        const cutoff = Date.now() - SNAPSHOT_TTL_MS;
+        for (const name of await readdir(dir)) {
+            const full = join(dir, name);
+            try {
+                const info = await stat(full);
+                if (info.isFile() && info.mtimeMs < cutoff)
+                    await rm(full, { force: true });
+            }
+            catch {
+                // per-file failure (raced by another process, permissions): skip it
+            }
+        }
+    }
+    catch {
+        // unreadable directory: nothing to reap
+    }
+}
 export class EngineApiClient {
     port;
     token;
@@ -75,6 +95,14 @@ export class EngineApiClient {
     // supplied a projectIdHash.
     targetIdentity;
     selection;
+    // Set only when the no-selection connect found its editor through the
+    // instance registry (no live pointer): credentialsChanged then re-runs the
+    // registry lookup with the same options instead of reading the pointer.
+    registryDiscovery = null;
+    // The most recent /api/health seen at connect/rebind. Carries the engine's
+    // capability advert (opKinds, singleOnlyOps) so tools can fail closed on a
+    // provably missing op without a second health round trip per call.
+    lastHealth = null;
     constructor(port, token, targetIdentity = {}, selection = null) {
         this.port = port;
         this.token = token;
@@ -84,34 +112,73 @@ export class EngineApiClient {
                 : { ...targetIdentity };
         this.selection = selection ? { ...selection } : null;
     }
-    static async connect(selection) {
-        if (selection) {
-            const connection = await resolveEngineConnection(selection);
-            return new EngineApiClient(connection.port, connection.token, {
+    /**
+     * With a selection (the MCP server: --project / --instance / its cwd) the
+     * registry decides — resolveEngineConnection. Without one (the CLI face):
+     * SUMMER_ENGINE_PROJECT / SUMMER_ENGINE_INSTANCE_ID when set (same names the
+     * MCP server reads), else the global pointer (~/.summer/api-token + api-port)
+     * when it names an engine that answers /api/health — today's behaviour,
+     * unchanged — else the instance registry (discoverRegistryConnection), so an
+     * editor launched `--summer-no-publish` or a second editor is still found.
+     * The pointer is read through getApiPort/getApiToken/checkEngineHealth so
+     * tests that stub those readers never touch the real ~/.summer. `discovery`
+     * is a test seam (fake ~/.summer, cwd, env).
+     */
+    static async connect(selection, discovery = {}) {
+        const envSelection = selection ? null : engineSelectionFromEnv(discovery.env);
+        const effective = selection ?? envSelection;
+        if (effective) {
+            const connection = await resolveEngineConnection(effective, {
+                summerDir: discovery.summerDir,
+                nowMs: discovery.nowMs,
+            });
+            const client = new EngineApiClient(connection.port, connection.token, {
                 instanceId: connection.health.instanceId,
                 projectId: connection.health.projectId,
                 projectIdHash: connection.health.projectIdHash,
-            }, { ...selection });
-        }
-        const port = await getApiPort();
-        const token = await getApiToken();
-        if (!token) {
-            throw new Error("Summer Engine is not running (no api-token found). Open Summer Engine first.");
-        }
-        const health = await checkEngineHealth(port);
-        if (!health) {
-            throw new Error(`Summer Engine is not responding on port ${port}. Make sure it's open.`);
+            }, { ...effective });
+            client.lastHealth = connection.health;
+            return client;
         }
         // Bind to whatever project is open right now. On a genuine engine restart the
         // token rotates and getClient() rebuilds this client, so a restart naturally
         // rebinds to the current project. An in-place project switch keeps the same
         // token, so the cached client retains its original binding and the engine
         // rejects mismatched mutations until the agent explicitly rebinds.
-        return new EngineApiClient(port, token, {
-            instanceId: health.instanceId,
-            projectId: health.projectId,
-            projectIdHash: health.projectIdHash,
+        const port = await getApiPort(discovery.summerDir);
+        const token = await getApiToken(discovery.summerDir);
+        if (token) {
+            const health = await checkEngineHealth(port);
+            if (health) {
+                const client = new EngineApiClient(port, token, {
+                    instanceId: health.instanceId,
+                    projectId: health.projectId,
+                    projectIdHash: health.projectIdHash,
+                });
+                client.lastHealth = health;
+                return client;
+            }
+        }
+        const connection = await discoverRegistryConnection(discovery);
+        if (!connection)
+            throw engineNotRunningError({ port, token }, discovery.summerDir);
+        const client = new EngineApiClient(connection.port, connection.token, {
+            instanceId: connection.health.instanceId,
+            projectId: connection.health.projectId,
+            projectIdHash: connection.health.projectIdHash,
         });
+        client.lastHealth = connection.health;
+        client.registryDiscovery = { ...discovery };
+        return client;
+    }
+    /** The engine's capability advert from the last health read (connect or
+     *  rebind), or undefined when the engine predates the advert. */
+    getEngineCapabilities() {
+        return this.lastHealth?.capabilities;
+    }
+    /** Engine version string from the last health read, for skew messages. */
+    getEngineVersion() {
+        return this.lastHealth?.version;
     }
     /** The projectIdHash this session is bound to (undefined if none was reported
      *  at connect — e.g. no project open yet). */
@@ -124,16 +191,22 @@ export class EngineApiClient {
      * switch (the deliberate escape hatch after an identity_mismatch). Returns the
      * new bound hash. The direct health probe is intentionally unscoped, so it can
      * reach the current engine even when bound requests would be rejected.
+     *
+     * Throws EngineRebindError when the health probe fails: the previous identity
+     * is kept, and reporting it as "the rebound hash" would tell the agent a
+     * switch it never followed had succeeded.
      */
     async rebind() {
         const health = await checkEngineHealth(this.port);
-        if (health) {
-            this.targetIdentity = {
-                instanceId: health.instanceId,
-                projectId: health.projectId,
-                projectIdHash: health.projectIdHash,
-            };
+        if (!health) {
+            throw new EngineRebindError(`Summer Engine did not answer the health probe on port ${this.port}; this session is still bound to ${this.targetIdentity.projectIdHash ?? "no project"}. Recovery: confirm the engine is running with the project open, then call summer_get_project_context again.`);
         }
+        this.lastHealth = health;
+        this.targetIdentity = {
+            instanceId: health.instanceId,
+            projectId: health.projectId,
+            projectIdHash: health.projectIdHash,
+        };
         return this.targetIdentity.projectIdHash;
     }
     /** Identity to attach to a MUTATING command's options so the engine can reject
@@ -179,7 +252,14 @@ export class EngineApiClient {
             const text = await res.text().catch(() => "");
             throw new Error(`Engine API error ${res.status}: ${text.slice(0, 200)}`);
         }
-        return res.json();
+        try {
+            return await res.json();
+        }
+        catch {
+            // A bare SyntaxError names nothing; say which request answered with a
+            // non-JSON body (a proxy page, an HTML error, a half-written stream).
+            throw new Error(`Engine API returned a non-JSON response for ${method} ${path} (HTTP ${res.status}).`);
+        }
     }
     /** Raw fetch with auth + timeout — returns the Response so callers can inspect
      *  the status (202 queued vs 200 legacy). */
@@ -240,6 +320,16 @@ export class EngineApiClient {
             const detail = error instanceof Error ? error.message : String(error);
             throw new Error(`Summer Engine did not acknowledge request ${clientRequestId}; dispatch state is unknown. Do not retry blindly. ${detail}`);
         }
+        return this._resolveQueuedResponse(res, clientRequestId, timeoutMs);
+    }
+    /**
+     * The post-submission half of _requestQueued: classify an already-fetched
+     * response (200 legacy / 202 queued / 429 backpressure) and, for 202, poll
+     * the accepted requestId to its terminal receipt. Split out so a caller that
+     * has to inspect the raw status first (gameSnapshot's 409 bridge check) can
+     * feed its ONE response in here instead of issuing a second request.
+     */
+    async _resolveQueuedResponse(res, clientRequestId, timeoutMs) {
         // 202 (queued) + 429 (backpressure, errorClass in body) are handled below;
         // any other non-2xx is a real transport error.
         if (!res.ok && res.status !== 202 && res.status !== 429) {
@@ -304,24 +394,83 @@ export class EngineApiClient {
     async health() {
         return this.request("GET", "/api/health");
     }
-    async executeOps(ops, options) {
+    /**
+     * One long-poll of GET /api/events/poll (the engine's events channel). The
+     * engine answers on the first event matching `kinds` with seq > `since`, or
+     * after `wait` ms with `timed_out:true`; a 2xx is the poll envelope
+     * {ok, events:[{seq, kind, ts, data}], next_seq, last_seq, since, truncated,
+     * timed_out}. Identity-gated like every other route: the bound project rides
+     * in the query, so a wrong project answers 409 identity_mismatch.
+     *
+     * The three answers this route documents — 404 (no channel on this build),
+     * 409 (identity mismatch), 503 (bus not started) — come back as a STRUCTURED
+     * failure {ok:false, http_status, ...body} so both faces classify them (a
+     * terminalState keeps its standard message and rebind hint; the events
+     * capability rewrites a 404 into engine_lacks_events). Anything else throws
+     * like every other request, so a stale-token 401/403 still triggers
+     * withEngine's reconnect-and-retry.
+     */
+    async pollEvents(params = {}, timeoutMs) {
+        const query = new URLSearchParams();
+        if (params.since !== undefined)
+            query.set("since", String(params.since));
+        if (params.kinds && params.kinds.length > 0)
+            query.set("kinds", params.kinds.join(","));
+        if (params.wait !== undefined)
+            query.set("wait", String(params.wait));
+        if (params.limit !== undefined)
+            query.set("limit", String(params.limit));
+        // URLSearchParams.size is undefined on Node < 18.16; stringify instead.
+        const suffix = query.toString();
+        const path = `/api/events/poll${suffix ? `?${suffix}` : ""}`;
+        // The engine holds the request up to `wait` ms; give the socket headroom.
+        const wait = params.wait ?? 25_000;
+        const res = await this._fetchRaw("GET", path, undefined, timeoutMs ?? wait + 5_000);
+        if (res.ok) {
+            try {
+                return await res.json();
+            }
+            catch {
+                throw new Error(`Engine API returned a non-JSON response for GET /api/events/poll (HTTP ${res.status}).`);
+            }
+        }
+        const text = await res.text().catch(() => "");
+        if (res.status === 404 || res.status === 409 || res.status === 503) {
+            let body = {};
+            try {
+                body = asRecord(JSON.parse(text)) ?? {};
+            }
+            catch {
+                // non-JSON body (an HTML 404 page): keep the raw text below
+            }
+            const failure = { ok: false, ...body, http_status: res.status };
+            if (typeof failure.error !== "string" && typeof failure.terminalState !== "string") {
+                failure.error = `Engine API error ${res.status}: ${text.slice(0, 200)}`;
+            }
+            return failure;
+        }
+        throw new Error(`Engine API error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    async executeOps(ops, options, timeoutMs = 120_000) {
         // Ops may include long-running work (ImportFromUrlBatch, GitCommit); the
-        // engine keeps it "running" and we poll. 120s budget. Resolves legacy-200 or
-        // async-202 (Block E).
+        // engine keeps it "running" and we poll. 120s budget by default; ops that
+        // declare a longer server-side max_seconds (RunEditorScript) pass a larger
+        // timeoutMs so the client never gives up before the engine can finish.
+        // Resolves legacy-200 or async-202 (Block E).
         // Attach the bound project identity so the engine rejects a write aimed at a
         // different project (identity_mismatch, atomic — before any op applies).
         const merged = { ...(options ?? {}), ...this.identityOptions() };
         const body = Object.keys(merged).length ? { ops, options: merged } : { ops };
-        return this._requestQueued("POST", "/api/ops", body, 120_000);
+        return this._requestQueued("POST", "/api/ops", body, timeoutMs);
     }
     /**
      * Mutation path for MCP file tools. Unlike legacy executeOps callers, this
      * fails closed when health did not provide a complete target identity. The
      * bound hash is stamped last so a caller cannot override it in options.
      */
-    async executeIdentityBoundOps(ops, options) {
+    async executeIdentityBoundOps(ops, options, timeoutMs) {
         const identity = this.requireBoundIdentity();
-        return this.executeOps(ops, { ...(options ?? {}), ...identity });
+        return this.executeOps(ops, { ...(options ?? {}), ...identity }, timeoutMs);
     }
     async readProjectFile(path, maxBytes = 200_000) {
         const query = new URLSearchParams({
@@ -370,8 +519,18 @@ export class EngineApiClient {
     async getScriptErrors(path) {
         return this.request("GET", `/api/state/script-errors?path=${encodeURIComponent(path)}`);
     }
-    async play(scene) {
+    async play(scene, determinism) {
         // Cold-load on large projects can take 25-40s. 60s budget.
+        const pins = pickPlayDeterminism(determinism);
+        if (pins) {
+            // Determinism params (seed / fixed_fps / time_scale) — the /api/play rung
+            // copies ONLY `scene` from options into the PlayGame op
+            // (local_api_server.cpp play branch), so a pinned launch travels as an
+            // explicit PlayGame op through /api/ops. executeOps stamps the bound
+            // identity like every other op. An engine that predates the params
+            // ignores the extra keys and answers the v1 result (no `determinism`).
+            return this.executeOps([{ op: "PlayGame", ...(scene ? { scene } : {}), ...pins }], undefined, 60_000);
+        }
         // The engine reads play params from body.options (tool_net_thread.cpp:503),
         // and the play handler reads options["scene"] — a top-level { scene } is
         // dropped, so the scene MUST be nested inside options. The bound identity
@@ -402,6 +561,7 @@ export class EngineApiClient {
     async writeSnapshotFile(kind, buffer, ext) {
         const dir = join(tmpdir(), "summer-engine", "snapshots");
         await mkdir(dir, { recursive: true });
+        await reapStaleSnapshots(dir);
         const filename = `${kind}-${Date.now()}-${Math.random()
             .toString(36)
             .slice(2, 8)}.${ext}`;
@@ -419,16 +579,17 @@ export class EngineApiClient {
         // reason (`failure_reason:"unsupported_transport"`, `bridge_required:true`,
         // tool_net_thread.cpp:495-503). Detect that specific shape and return it
         // verbatim so the tool can give an honest message — do NOT hardcode "game
-        // always fails": once the engine answers 200/202 (P4.4), the normal path
-        // below just works.
-        if (kind === "game") {
-            const bridge = await this._detectBridgeRequired(`/api/snapshot/${kind}`);
-            if (bridge)
-                return bridge;
-        }
+        // always fails": once the engine answers 200/202 (P4.4), the same response
+        // flows into the normal queued path. ONE request either way: a probe that
+        // discarded a 200 (or orphaned an accepted 202 requestId) and then asked
+        // again would capture the game twice.
         let response;
         try {
-            response = await this._requestQueued("GET", `/api/snapshot/${kind}`, undefined, 60_000);
+            const res = await this._fetchRaw("GET", `/api/snapshot/${kind}`, undefined, 60_000);
+            if (kind === "game" && res.status === 409) {
+                return this._bridgeRequiredFromResponse(res);
+            }
+            response = await this._resolveQueuedResponse(res, undefined, 60_000);
         }
         catch (err) {
             return { ok: false, error: err instanceof Error ? err.message : String(err) };
@@ -502,24 +663,12 @@ export class EngineApiClient {
         };
     }
     /**
-     * Probe /api/snapshot/game for the structural 409 `bridge_required` shape
-     * (tool_net_thread.cpp:495-503). Returns a structured failure only when the
-     * engine actually answers 409 with `bridge_required` / `unsupported_transport`;
-     * ANY other status (200/202/other) returns null so the caller proceeds to the
-     * normal queued path — so the moment the engine starts answering over HTTP
-     * (P4.4), game capture just works with no code change here.
+     * Turn a 409 from /api/snapshot/game into a structured failure. The engine's
+     * structural refusal carries `bridge_required` / `unsupported_transport`
+     * (tool_net_thread.cpp:495-503); a 409 without that shape is surfaced as a
+     * plain error rather than silently claiming "bridge required".
      */
-    async _detectBridgeRequired(path) {
-        let res;
-        try {
-            res = await this._fetchRaw("GET", path, undefined, 15_000);
-        }
-        catch {
-            // Transport error — let the normal path surface it uniformly.
-            return null;
-        }
-        if (res.status !== 409)
-            return null;
+    async _bridgeRequiredFromResponse(res) {
         const body = (await res.json().catch(() => ({})));
         const reason = stringFrom(body.failure_reason);
         const bridge = body.bridge_required === true;
@@ -552,9 +701,24 @@ export class EngineApiClient {
      * name `node_path`); an unresolvable node fails with failure_reason
      * "node_not_found". framing "auto" is an alias of "iso"; the engine also
      * accepts "top"/"front"/"back"/"left"/"right" and echoes the resolved framing.
-     * The result carries image_base64 + mime (+ width/height) plus the P4.3
-     * confession fields (scene_has_camera / scene_had_light /
+     * framing "camera" renders through the scene's current/first Camera3D — or
+     * the Camera3D named by `cameraPath` — with the scene's REAL WorldEnvironment
+     * instead of the flat preview substitute; the engine echoes the resolved
+     * framing, so an older build that ignores the value is detectable by the
+     * caller. The result carries image_base64 + mime (+ width/height) plus the
+     * P4.3 confession fields (scene_has_camera / scene_had_light /
      * used_synthetic_camera) and framing / framed_node / render_retries.
+     *
+     * Perception additions (engine scene-scripting contracts): framing "free" takes
+     * `cameraPosition` / `cameraLookAt` (Godot "Vector3(x, y, z)" literals) and
+     * `fov`; framing "bookmark:<name>" resolves the pose from the project's
+     * camera bookmarks (fov overrides the bookmark's). `marks` draws the
+     * Set-of-Mark overlay (numbered tags + boxes over the largest visible
+     * VisualInstance3D nodes), capped by `maxMarks`. The result adds
+     * framing_source / camera_pose / bookmark and marks / marks_skipped /
+     * marks_candidates / marks_truncated / max_marks (all kept in `metadata`).
+     * Older engines resolve the new framings to a preset and echo THAT — the
+     * caller compares the echo against what it asked for.
      */
     async scenePreview(input) {
         const opInput = { op: "ScenePreview" };
@@ -567,6 +731,18 @@ export class EngineApiClient {
             opInput.size = input.size;
         if (input?.nodePath)
             opInput.node = input.nodePath;
+        if (input?.cameraPath)
+            opInput.camera_path = input.cameraPath;
+        if (input?.cameraPosition)
+            opInput.camera_position = input.cameraPosition;
+        if (input?.cameraLookAt)
+            opInput.camera_look_at = input.cameraLookAt;
+        if (input?.fov !== undefined)
+            opInput.fov = input.fov;
+        if (input?.marks !== undefined)
+            opInput.marks = input.marks;
+        if (input?.maxMarks !== undefined)
+            opInput.max_marks = input.maxMarks;
         let response;
         try {
             // executeOps stamps the bound identity so a drifted project is rejected
@@ -609,6 +785,22 @@ export class EngineApiClient {
                 return true;
             }
         }
+        if (this.registryDiscovery) {
+            // Found through the registry (no pointer): ask the registry again. An
+            // editor that vanished or became ambiguous is real drift, like the
+            // selected-editor case above.
+            try {
+                const connection = await discoverRegistryConnection(this.registryDiscovery);
+                if (!connection)
+                    return true;
+                return (connection.port !== this.port ||
+                    connection.token !== this.token ||
+                    connection.health.instanceId !== this.targetIdentity.instanceId);
+            }
+            catch {
+                return true;
+            }
+        }
         try {
             const [port, token] = await Promise.all([getApiPort(), getApiToken()]);
             if (!token)

package/dist/{lib → core}/async-op-lifecycle.d.ts

@@ -1,9 +1,8 @@
 /**
- * 0.5.34 Block E — async tool-lifecycle consumer for the CLI/MCP.
+ * Async tool-lifecycle consumer for the CLI/MCP.
  *
- * Ported from the web orchestrator (publicsummerengine
- * src/lib/bridge/async-op-lifecycle.ts) so the CLI speaks the SAME contract as
- * the engine's responsive tool server (Block E):
+ * Speaks the engine tool server's async op contract (the same one the Summer
+ * web app uses), so both clients read engine responses identically:
  *   - NEW path: `202 {requestId, status:"queued"}` -> long-poll
  *     GET /api/ops/result?requestId=&wait=ms until terminal (done|failed|canceled).
  *   - LEGACY path (dormant/older engine): a synchronous `200` with the full apply

package/dist/{lib → core}/async-op-lifecycle.js

@@ -1,9 +1,8 @@
 /**
- * 0.5.34 Block E — async tool-lifecycle consumer for the CLI/MCP.
+ * Async tool-lifecycle consumer for the CLI/MCP.
  *
- * Ported from the web orchestrator (publicsummerengine
- * src/lib/bridge/async-op-lifecycle.ts) so the CLI speaks the SAME contract as
- * the engine's responsive tool server (Block E):
+ * Speaks the engine tool server's async op contract (the same one the Summer
+ * web app uses), so both clients read engine responses identically:
  *   - NEW path: `202 {requestId, status:"queued"}` -> long-poll
  *     GET /api/ops/result?requestId=&wait=ms until terminal (done|failed|canceled).
  *   - LEGACY path (dormant/older engine): a synchronous `200` with the full apply

package/dist/{lib → core}/auth.d.ts

@@ -14,20 +14,29 @@ export interface CredentialMetadata {
 interface CredentialMetadataDocument {
     schemaVersion: 1;
     auth?: CredentialMetadata;
-    cloud?: CredentialMetadata;
     creator?: CredentialMetadata;
 }
 export interface LoginSession {
     token: string;
-    cloudToken?: string | null;
     user?: SummerUserInfo;
     scopes?: string[];
-    cloudScopes?: string[];
 }
+/**
+ * Gateway credential. SUMMER_TOKEN wins over ~/.summer/auth-token so a
+ * headless/cloud agent can authenticate gateway features (asset search,
+ * generation, releases) without a browser login. The env override never
+ * touches the store: `summer login` still writes the file, and the desktop
+ * engine keeps reading it. Local engine ops need neither — they authenticate
+ * with the engine-minted ~/.summer/api-token (see core/engine.ts).
+ */
 export declare function getAuthToken(): Promise<string | null>;
+/**
+ * True when SUMMER_TOKEN (env) is the credential in effect. `summer logout`
+ * only clears the store, so status/logout must say the env token still
+ * applies rather than reporting the stored identity as the active one.
+ */
+export declare function hasEnvAuthToken(): boolean;
 export declare function saveAuthToken(token: string, scopes?: string[]): Promise<void>;
-export declare function getCloudToken(): Promise<string | null>;
-export declare function saveCloudToken(token: string, scopes?: string[]): Promise<void>;
 /**
  * Summercraft creator tokens are a separate credential audience from the
  * core-compatible Summer CLI JWT. Never store an sc_ token in auth-token:
@@ -40,4 +49,3 @@ export declare function saveUserInfo(info: SummerUserInfo): Promise<void>;
 export declare function saveLoginSession(session: LoginSession): Promise<void>;
 export declare function getCredentialMetadata(): Promise<CredentialMetadataDocument>;
 export declare function clearAuthCredentials(): Promise<number>;
-export declare function assertCredentialScopes(metadata: CredentialMetadata | undefined, requiredScopes: string[]): void;