summer-engine 4.3.0 → 4.5.0

package/dist/core/local-project.js

@@ -0,0 +1,234 @@
+/**
+ * Writing a new Summer project to disk: the built-in generators, the pinned
+ * template fetch, the autopilot scaffold, `.summer/project.json` and the
+ * agent instruction files. Shared by `summer create`, `summer dev` and the
+ * MCP's projects.create_local.
+ */
+import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { checkEngineHealth, getApiPort } from "./engine.js";
+import { PACKAGE_ROOT } from "./package-root.js";
+import { SUMMER_ENGINE_COMPATIBILITY } from "./summer-compatibility.js";
+import { fetchPinnedTemplate } from "./templates.js";
+import { noteToolUsage, templateTags } from "./usage-fields.js";
+import { writeProjectManifest } from "../project-memory/project-manifest.js";
+import { writeAgentInstructions } from "../project-memory/agent-instructions.js";
+import { TOOLKIT_VERSION as toolkitVersion } from "./version.js";
+/** Summer Engine's version when it is reachable right now, else undefined —
+ *  the manifest then omits engine_version rather than guessing. */
+async function detectEngineVersion() {
+    try {
+        return (await checkEngineHealth(await getApiPort()))?.version;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const BUILTIN_GENERATORS = {
+    empty: (dir, name) => {
+        writeFileSync(join(dir, "project.godot"), renderProjectSettings(name, "res://main.tscn"));
+        writeFileSync(join(dir, "main.tscn"), emptyScene());
+    },
+    "3d-basic": (dir, name) => {
+        writeFileSync(join(dir, "project.godot"), renderProjectSettings(name, "res://main.tscn"));
+        writeFileSync(join(dir, "main.tscn"), basicScene3D());
+    },
+};
+/**
+ * Copy the autopilot verification scaffold into a fresh project.
+ *
+ * Every project gets a working example of how to prove its own gameplay: a probe
+ * that drives the player with real input, saves rendered frames, asserts, and
+ * exits. Without it every agent reinvents verification from scratch, and most
+ * settle for asking the user to play the game instead.
+ *
+ * Never overwrites — an existing tests/autopilot/ is the user's, not ours.
+ */
+export function scaffoldAutopilot(projectDir) {
+    const source = join(PACKAGE_ROOT, "assets", "autopilot");
+    const target = join(projectDir, "tests", "autopilot");
+    if (!existsSync(source) || existsSync(target))
+        return false;
+    cpSync(source, target, { recursive: true });
+    return true;
+}
+/** A folder `summer dev` may create a project in: missing, empty, or only
+ *  dotfiles (.git, .claude, .vscode, ...). */
+export function isEmptyProjectFolder(dir) {
+    if (!existsSync(dir))
+        return true;
+    if (!statSync(dir).isDirectory())
+        return false;
+    // .summer is Summer's own folder (in the home folder, its config): never a place to create in.
+    return readdirSync(dir).every((name) => name.startsWith(".") && name !== ".summer");
+}
+/** The home folder or a filesystem root: never a project folder by default. */
+export function isHomeOrRoot(dir, home = homedir()) {
+    const full = resolve(dir);
+    return full === resolve(home) || full === resolve(full, "/");
+}
+/** The project that holds `dir` (project.godot here or above, never above the home folder), or null. */
+export function projectRootAbove(dir, home = homedir()) {
+    let current = resolve(dir);
+    while (true) {
+        if (existsSync(join(current, "project.godot")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current || current === resolve(home))
+            return null;
+        current = parent;
+    }
+}
+/**
+ * Write a project from a template into `fullPath`: generate a built-in, or
+ * fetch a pinned template (verified tree digest), then the autopilot
+ * scaffold, `.summer/project.json` and the agent instruction files.
+ * `fullPath` may already exist when isEmptyProjectFolder says so; files that
+ * are already there are kept, never replaced.
+ */
+export async function createProject(entry, fullPath, options) {
+    const { log } = options;
+    // The usage line names the catalog template and its library domains, never the project name or folder.
+    noteToolUsage({ templateId: entry.slug, templateTags: templateTags(entry.slug) });
+    if (entry.builtin) {
+        const generate = BUILTIN_GENERATORS[entry.slug];
+        if (!generate)
+            throw new Error(`${entry.id} is declared builtin but this CLI has no generator for it. Update the CLI.`);
+        log(`Creating project from built-in '${entry.slug}' template...`);
+        mkdirSync(fullPath, { recursive: true });
+        generate(fullPath, options.name);
+        const scaffolded = scaffoldAutopilot(fullPath);
+        writeProjectManifest(fullPath, {
+            template: { id: entry.id, version: entry.version, builtin: true },
+            toolkit_version: toolkitVersion,
+            engine_version: await detectEngineVersion(),
+        });
+        return { scaffolded, instructions: writeAgentInstructions(fullPath) };
+    }
+    const pin = entry.pin;
+    // The fetch needs a folder that does not exist yet: into an existing
+    // (empty) folder, fetch next to its files and move them up.
+    const staging = existsSync(fullPath) ? join(fullPath, `.summer-create-${process.pid}`) : null;
+    const materialized = await fetchPinnedTemplate(entry, { targetDir: staging ?? fullPath, keepGit: options.keepGit, log });
+    if (staging) {
+        for (const name of readdirSync(staging)) {
+            const mine = join(fullPath, name);
+            if (!existsSync(mine))
+                renameSync(join(staging, name), mine);
+            else if (name === ".gitignore") {
+                // Keep both: the template's lines (.godot/ and the rest) after the folder's own.
+                const have = new Set(readFileSync(mine, "utf8").split(/\r?\n/));
+                const add = readFileSync(join(staging, name), "utf8").split(/\r?\n/).filter((line) => line.trim() && !have.has(line));
+                if (add.length)
+                    appendFileSync(mine, `\n# From the ${entry.slug} template\n${add.join("\n")}\n`);
+                log(`Added the template's .gitignore lines to the existing .gitignore.`);
+            }
+            else
+                log(`Kept the existing ${name}; the template's ${name} was not used.`);
+        }
+        rmSync(staging, { recursive: true, force: true });
+    }
+    const scaffolded = scaffoldAutopilot(fullPath);
+    writeProjectManifest(fullPath, {
+        template: {
+            id: entry.id,
+            version: entry.version,
+            repo: pin.repo,
+            commit: materialized.commit,
+            tree_digest: materialized.tree_digest,
+        },
+        toolkit_version: toolkitVersion,
+        engine_version: await detectEngineVersion(),
+    });
+    log(`Source: ${pin.repo} @ ${materialized.commit.slice(0, 12)} (tree digest verified)`);
+    return { scaffolded, instructions: writeAgentInstructions(fullPath) };
+}
+/**
+ * project.godot uses C-style double-quoted strings; a project name containing
+ * `"` or `\` must be escaped or the file does not parse.
+ */
+export function escapeGodotString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, "\\n");
+}
+export function renderProjectSettings(name, mainScene) {
+    return `; Summer Engine Project
+; Generated by summer-engine CLI
+; Technical base ${SUMMER_ENGINE_COMPATIBILITY.currentTechnicalBaseVersion}; Summer follows upstream continuously
+
+[application]
+
+config/name="${escapeGodotString(name)}"
+run/main_scene="${escapeGodotString(mainScene)}"
+config/features=PackedStringArray("${SUMMER_ENGINE_COMPATIBILITY.projectFeatureTag}")
+
+[rendering]
+
+renderer/rendering_method="forward_plus"
+`;
+}
+function emptyScene() {
+    return `[gd_scene format=3]
+
+[node name="World" type="Node3D"]
+`;
+}
+/** A small scene that already looks like a game: procedural sky on a real
+ *  Environment (ACES, sky ambient light), a sun with soft shadows, a tinted
+ *  ground and one lit hero, framed by the camera. */
+function basicScene3D() {
+    return `[gd_scene load_steps=8 format=3]
+
+[sub_resource type="ProceduralSkyMaterial" id="ProceduralSkyMaterial_sky"]
+sky_top_color = Color(0.25, 0.45, 0.8, 1)
+sky_horizon_color = Color(0.7, 0.78, 0.88, 1)
+ground_bottom_color = Color(0.16, 0.17, 0.15, 1)
+ground_horizon_color = Color(0.7, 0.78, 0.88, 1)
+
+[sub_resource type="Sky" id="Sky_main"]
+sky_material = SubResource("ProceduralSkyMaterial_sky")
+
+[sub_resource type="Environment" id="Environment_main"]
+background_mode = 2
+sky = SubResource("Sky_main")
+ambient_light_source = 3
+reflected_light_source = 2
+tonemap_mode = 3
+
+[sub_resource type="PlaneMesh" id="PlaneMesh_ground"]
+size = Vector2(200, 200)
+
+[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_ground"]
+albedo_color = Color(0.35, 0.52, 0.3, 1)
+roughness = 0.95
+
+[sub_resource type="CapsuleMesh" id="CapsuleMesh_hero"]
+
+[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_hero"]
+albedo_color = Color(0.95, 0.45, 0.2, 1)
+roughness = 0.45
+
+[node name="World" type="Node3D"]
+
+[node name="WorldEnvironment" type="WorldEnvironment" parent="."]
+environment = SubResource("Environment_main")
+
+[node name="Sun" type="DirectionalLight3D" parent="."]
+transform = Transform3D(0.536875, -0.636738, 0.55347, 0, 0.656033, 0.754732, -0.843661, -0.405197, 0.352208, 0, 10, 0)
+light_angular_distance = 0.5
+shadow_enabled = true
+directional_shadow_max_distance = 40.0
+
+[node name="Ground" type="MeshInstance3D" parent="."]
+mesh = SubResource("PlaneMesh_ground")
+surface_material_override/0 = SubResource("StandardMaterial3D_ground")
+
+[node name="Hero" type="MeshInstance3D" parent="."]
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0)
+mesh = SubResource("CapsuleMesh_hero")
+surface_material_override/0 = SubResource("StandardMaterial3D_hero")
+
+[node name="Camera3D" type="Camera3D" parent="."]
+transform = Transform3D(0.810679, -0.128625, 0.571187, 0, 0.97557, 0.219687, -0.585491, -0.178096, 0.790875, 2.6, 1.9, 3.6)
+`;
+}

package/dist/core/ops/areas.js

@@ -15,10 +15,16 @@ export const CLI_AREAS = [
 /**
  * Operations that run in this package: everything in `engine`, the library
  * (`docs`, apart from the Studio workflows, which are cloud), opening a
- * page or an editor surface, docking an App in the editor, and uploading a
- * local export. Everything else runs on the hosted server.
+ * page or an editor surface, docking an App in the editor, uploading a
+ * local export, taking a store game live and filling its store page
+ * sections (store.go_live, store.set_details), syncing the project's
+ * summer.items.json, and making a
+ * piece of content from footage on this computer (content.make; Summer's
+ * server keeps the request it reports to), and creating and opening a
+ * project on this computer (projects.create_local, projects.open_local).
+ * Everything else runs on the hosted server.
  */
-const LOCAL_OPS = new Set(["docs.search", "docs.read", "docs.feedback", "docs.plan", "docs.engine_api", "studio.open", "apps.dock", "apps.publish_folder", "store.upload_file"]);
+const LOCAL_OPS = new Set(["docs.search", "docs.read", "docs.feedback", "docs.plan", "docs.engine_api", "studio.open", "apps.dock", "apps.publish_folder", "store.upload_file", "store.go_live", "store.set_details", "economy.sync_items", "content.make", "projects.create_local", "projects.open_local"]);
 export function isLocalOp(op) {
     return op.startsWith("engine.") || LOCAL_OPS.has(op);
 }

package/dist/core/ops/catalog.d.ts

@@ -43,6 +43,15 @@ export declare function localInputSchema(op: string): Record<string, unknown> |
  * leaves the machine as an operation name.
  */
 export declare function knownOp(op: string | null | undefined): string | null;
+/**
+ * The operation `summer <area> <action>` runs. Agents often type a 3.x tool
+ * name as the action (`summer engine summer_get_scene_tree`, `summer engine
+ * camera-bookmark`, `summer engine search_library`): those resolve through
+ * legacy-names.json, so a 3.x name runs instead of failing not_found.
+ */
+export declare function resolveCliOp(area: string, action: string): string;
+/** The area's real actions nearest to what was typed, nearest first (kebab-case, as typed on the CLI). */
+export declare function closestActions(op: string, limit?: number): string[];
 export declare function localWireForm(op: string): Record<string, unknown> | null;
 /**
  * The first problem a JSON Schema's top level finds in an input: a missing

package/dist/core/ops/catalog.js

@@ -3,9 +3,9 @@ import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { loadLibraryIndex } from "../library-search.js";
 import { PACKAGE_ROOT } from "../package-root.js";
-import { CONTRACT_VERSION, isLocalOp, legacyNames, LOCAL_RUNNERS, mcpNameOf, MIN_APPROVAL } from "./contract.js";
+import { CONTRACT_VERSION, isLocalOp, legacyNames, LOCAL_RUNNERS, mcpNameOf, MIN_APPROVAL, opFromCli, resolveOpName } from "./contract.js";
 import { ENGINE_SPLIT_OPS, engineOpDef, isSplitOp, splitInputSchema } from "./engine.js";
-import { shippedTitle } from "./public-catalog.js";
+import { shippedCloudEntries, shippedTitle } from "./public-catalog.js";
 /** A local tool's effect from its registry authority: scene edits and project files are writes. */
 function effectOf(authority) {
     if (authority?.publish)
@@ -19,11 +19,23 @@ const titleOf = (summary, op) => {
     return sentence && sentence.length <= 60 ? sentence : op.replace(/^[a-z]+\./, "").replace(/_/g, " ").replace(/^./, (c) => c.toUpperCase());
 };
 let entriesCache = null;
+/**
+ * The local operations that reach Summer with the person's sign-in (the
+ * account and the store sign-in `summer login` makes; `summer login --store`
+ * for the store sign-in alone). Every other local one works signed out.
+ */
+const SIGNED_IN_LOCAL_OPS = new Set(["economy.sync_items", "store.upload_file", "store.go_live", "store.set_details", "apps.publish_folder", "content.make"]);
+/**
+ * Local operations that change Summer's records although their registry
+ * authority names no local file or publish: store.set_details saves the store
+ * page draft (players see nothing until it goes live).
+ */
+const REMOTE_WRITE_LOCAL_OPS = new Set(["store.set_details"]);
 function entryFor(op, toolName, tool, legacy) {
     // Engine operations carry their own title, summary and effect (engine.ts);
     // other local operations fall back to the descriptor.
     const def = engineOpDef(op);
-    const effect = def?.effect ?? effectOf(tool.authority);
+    const effect = def?.effect ?? (REMOTE_WRITE_LOCAL_OPS.has(op) ? "write" : effectOf(tool.authority));
     const summary = def?.summary ?? (tool.summary ?? "").slice(0, 300);
     return {
         name: op,
@@ -118,6 +130,46 @@ export function knownOp(op) {
         return null;
     return localEntries().some((entry) => entry.name === op) || shippedTitle(op) !== undefined ? op : null;
 }
+/**
+ * The operation `summer <area> <action>` runs. Agents often type a 3.x tool
+ * name as the action (`summer engine summer_get_scene_tree`, `summer engine
+ * camera-bookmark`, `summer engine search_library`): those resolve through
+ * legacy-names.json, so a 3.x name runs instead of failing not_found.
+ */
+export function resolveCliOp(area, action) {
+    const op = opFromCli(area, action);
+    if (knownOp(op))
+        return op;
+    const [cleanArea, word] = op.split(".");
+    const bare = word.replace(/^summer_/, "").replace(new RegExp(`^${cleanArea}_`), "");
+    for (const candidate of [`${cleanArea}.${bare}`, resolveOpName(`summer_${bare}`), resolveOpName(word)]) {
+        if (knownOp(candidate))
+            return candidate;
+    }
+    return op;
+}
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i++) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j++) {
+            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
+/** The area's real actions nearest to what was typed, nearest first (kebab-case, as typed on the CLI). */
+export function closestActions(op, limit = 3) {
+    const [area, action = ""] = op.split(".");
+    const typed = action.replace(/^summer_/, "");
+    const actions = new Set([...localEntries(), ...shippedCloudEntries()].filter((entry) => entry.name.startsWith(`${area}.`)).map((entry) => entry.name.slice(area.length + 1)));
+    const score = (candidate) => (candidate.includes(typed) || typed.includes(candidate) ? 0 : editDistance(typed, candidate));
+    return [...actions]
+        .sort((a, b) => score(a) - score(b) || a.localeCompare(b))
+        .slice(0, limit)
+        .map((candidate) => candidate.replace(/_/g, "-"));
+}
 export function localWireForm(op) {
     const entry = localEntries().find((candidate) => candidate.name === op);
     if (!entry)
@@ -135,7 +187,7 @@ export function localWireForm(op) {
         effect: entry.effect,
         approval: entry.approval,
         provider: entry.provider,
-        auth: def?.auth ?? "none",
+        auth: def?.auth ?? (SIGNED_IN_LOCAL_OPS.has(op) ? "account" : "none"),
         input: localInputSchema(op) ?? { type: "object" },
         output: { type: "object" },
         ...(legacy.length ? { legacy } : {}),

package/dist/core/ops/engine-answer.d.ts

@@ -7,7 +7,8 @@ import { type Answer, type NextStep } from "./contract.js";
  * `details.tool`, so nothing the 3.x result said is lost.
  */
 export declare const ENGINE_NOT_RUNNING_STEP: NextStep;
-export declare function engineNotRunning(): Answer;
+/** `recovery`: the 3.x result's own next step (not installed, no project, still starting, ...). */
+export declare function engineNotRunning(recovery?: string): Answer;
 /** The text blocks of a tool result: the first is its payload, the rest are notes (a tip, a caption). */
 export declare function textsOf(result: unknown): string[];
 /**
@@ -18,6 +19,8 @@ export declare function engineFailure(text: string, op: string, options: {
     effect: "read" | "write";
     guide?: string;
 }): Answer;
+/** A local tool's coded failure (`{ok:false, code, error, recovery}`) as the answer, with its recovery as the next step; null when it has no such code. */
+export declare function codedLocalFailure(body: Record<string, unknown>): Answer | null;
 /** A 3.x engine tool's whole result as the answer: its payload on success, the mapped failure otherwise. */
 export declare function answerOfEngineResult(result: unknown, op: string, options: {
     effect: "read" | "write";

package/dist/core/ops/engine-answer.js

@@ -9,8 +9,9 @@ import { errorAnswer } from "./contract.js";
 export const ENGINE_NOT_RUNNING_STEP = {
     say: "Open the project in Summer Engine, or run: npx -y summer-engine@latest run <project-path>",
 };
-export function engineNotRunning() {
-    return errorAnswer("engine_not_running", "Summer Engine is not running, or no project is open.", { next: ENGINE_NOT_RUNNING_STEP });
+/** `recovery`: the 3.x result's own next step (not installed, no project, still starting, ...). */
+export function engineNotRunning(recovery) {
+    return errorAnswer("engine_not_running", "Summer Engine is not running, or no project is open.", { next: recovery ? { say: recovery } : ENGINE_NOT_RUNNING_STEP });
 }
 /** The text blocks of a tool result: the first is its payload, the rest are notes (a tip, a caption). */
 export function textsOf(result) {
@@ -64,7 +65,7 @@ export function engineFailure(text, op, options) {
     const code = str(body?.code);
     const reason = str(body?.failure_reason);
     if (code === "engine_not_running" || NOT_RUNNING.test(text))
-        return engineNotRunning();
+        return engineNotRunning(code === "engine_not_running" ? str(body?.recovery) : undefined);
     if (SEVERAL_EDITORS.test(text))
         return errorAnswer("conflict", message, { next: SEVERAL_EDITORS_STEP, details });
     if (NO_PROJECT.test(text))
@@ -106,6 +107,18 @@ export function engineFailure(text, op, options) {
         return errorAnswer("not_found", message, { details });
     return errorAnswer("invalid_input", message, { next: describe, details });
 }
+/** The codes a local tool's failure keeps as they are (projects.create_local, projects.open_local). */
+const LOCAL_CODES = new Set(["engine_not_running", "invalid_input", "not_found", "unavailable", "conflict", "unsupported"]);
+/** A local tool's coded failure (`{ok:false, code, error, recovery}`) as the answer, with its recovery as the next step; null when it has no such code. */
+export function codedLocalFailure(body) {
+    const code = str(body.code);
+    if (body.ok !== false || !code || !LOCAL_CODES.has(code))
+        return null;
+    const recovery = str(body.recovery);
+    if (code === "engine_not_running")
+        return engineNotRunning(recovery);
+    return errorAnswer(code, str(body.error) ?? str(body.message) ?? "The operation failed.", { ...(recovery ? { next: { say: recovery } } : {}), details: { tool: body } });
+}
 /** A 3.x engine tool's whole result as the answer: its payload on success, the mapped failure otherwise. */
 export function answerOfEngineResult(result, op, options) {
     const [first = "", ...notes] = textsOf(result);

package/dist/core/ops/engine.js

@@ -270,7 +270,7 @@ export const ENGINE_OPS = {
     // ── Play, stop, runtime ───────────────────────────────────────────────────
     "engine.play": {
         title: "Play the game",
-        summary: "Start the game quietly (the editor keeps its tab and focus): the main scene or a given one, embedded or as a hidden offscreen instance, with an optional seed and fixed frame rate, or a local multiplayer session (players). Next: engine.is_running, then engine.get_diagnostics.",
+        summary: "Play the game in the editor's real window (agents may; quiet: the editor keeps its tab and focus): main scene or a given one, embedded or a hidden offscreen instance, optional seed and fixed frame rate, or local multiplayer (players). Next: engine.is_running, engine.get_diagnostics.",
         effect: "write",
         example: { input: { instance: "a", mode: "offscreen", deterministic: true, seed: 7 }, note: "A hidden, repeatable test run." },
     },
@@ -352,7 +352,7 @@ export const ENGINE_OPS = {
     // ── Seeing ────────────────────────────────────────────────────────────────
     "engine.screenshot": {
         title: "Take a screenshot",
-        summary: "Return a frame as an image you see: the editor viewport, an offscreen render of a scene (preset, camera, bookmark or free pose, numbered marks) or the running game. A blank viewport frame means no redraw yet: capture again.",
+        summary: "Return a frame as an image you see, to check your work by eye: the editor viewport, an offscreen render of a scene (preset, camera, bookmark or free pose, numbered marks) or the running game. A blank viewport frame means no redraw yet: capture again.",
         effect: "read",
         example: { input: { target: "scene", scenePath: MAIN, framing: "camera" }, note: "The level through its own camera and lights." },
     },
@@ -385,7 +385,7 @@ export const ENGINE_OPS = {
     },
     "engine.frame_shot": {
         title: "Find camera poses for a shot",
-        summary: "Find, score and save camera poses for a shot type (establishing, eye level, low angle, detail, corridor), tested against the real geometry. Returns the best 3 poses and a sheet, and saves the best as a bookmark.",
+        summary: "Find, score and save camera poses for a shot type (establishing, eye level, low angle, detail, corridor), tested against the real geometry in the open editor. Returns the best 3 poses and a sheet to look at, and saves the best as a bookmark.",
         effect: "write",
         example: { input: { scenePath: MAIN, shot: "establishing", subject: ["Town"] }, note: "A wide shot of the town." },
     },
@@ -638,7 +638,7 @@ export function splitInputSchema(def, toolSchema) {
         additionalProperties: false,
     };
 }
-const OP_REF = /\b(engine|docs|store)\.[a-z][a-z0-9_]*\b/g;
+const OP_REF = /\b(engine|docs|store|projects)\.[a-z][a-z0-9_]*\b/g;
 /** Every operation a summary names (`engine.snapshot_diff`, `docs.read`). */
 export function opsNamedIn(text) {
     return [...new Set(text.match(OP_REF) ?? [])];

package/dist/core/ops/save-files.d.ts

@@ -73,6 +73,11 @@ export declare class FileSaver {
     private targetOf;
     /** Download one file into the target under a free name; notes what changed from the caller's file name. */
     private download;
-    /** The file in a hidden temp file in `dir` (engines skip dot files), from a public https host, within the size limit. */
     private fetchToTemp;
 }
+/** The file in a hidden temp file in `dir` (engines skip dot files), from a public https host, within the size limit. */
+export declare function fetchPublicToTemp(url: string, dir: string, options?: Pick<FileSaverOptions, "fetch" | "lookup" | "maxBytes">): Promise<{
+    temp: string;
+    finalUrl: URL;
+    contentType?: string;
+}>;