summer-engine 2.8.2 → 3.0.0

package/dist/core/capabilities/hdri-import.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Poly Haven HDRI import (tool/import-hdri). Shared by the MCP tool
+ * (summer_import_hdri) and the CLI dispatcher (`summer tool import-hdri`).
+ *
+ * Talks to Poly Haven's public API — no key, no Summer account, CC0 catalog —
+ * then downloads the chosen .hdr/.exr THROUGH the engine's import pipeline
+ * (ImportFromUrl) so the result is a usable res:// texture. Every value read
+ * from the API is treated as untrusted data: ids must be slugs, download URLs
+ * must point back at Poly Haven over https.
+ */
+import { z } from "zod";
+export declare const HDRI_RESOLUTIONS: readonly ["1k", "2k", "4k"];
+export type HdriResolution = (typeof HDRI_RESOLUTIONS)[number];
+/** Refuse downloads above this unless the caller opts in: a 16k .exr is
+ *  hundreds of MB pulled through the engine on a user's machine. */
+export declare const HDRI_MAX_DOWNLOAD_BYTES: number;
+/**
+ * The one input contract for summer_import_hdri, shared by the MCP tool (pass
+ * `.shape` to server.tool) and the CLI dispatcher (`summer tool import-hdri`)
+ * so an off-ladder resolution is rejected on both faces.
+ */
+export declare const importHdriArgsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    assetId: z.ZodOptional<z.ZodString>;
+    resolution: z.ZodDefault<z.ZodEnum<["1k", "2k", "4k"]>>;
+    allow_large: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    resolution: "1k" | "2k" | "4k";
+    allow_large: boolean;
+    query?: string | undefined;
+    assetId?: string | undefined;
+}, {
+    query?: string | undefined;
+    assetId?: string | undefined;
+    resolution?: "1k" | "2k" | "4k" | undefined;
+    allow_large?: boolean | undefined;
+}>;
+export interface ImportHdriArgs {
+    query?: string;
+    assetId?: string;
+    resolution?: HdriResolution;
+    /** Opt in to files above HDRI_MAX_DOWNLOAD_BYTES. */
+    allow_large?: boolean;
+}
+/** The engine surface this capability needs: one ImportFromUrl op. */
+export interface HdriImportEngine {
+    executeOps(ops: Record<string, unknown>[]): Promise<unknown>;
+}
+export interface ImportHdriResult {
+    success: true;
+    assetId: string;
+    name?: string;
+    resolution: string;
+    resolutionNote?: string;
+    format: string;
+    importedTo: string;
+    license: string;
+    alternates?: Array<{
+        id: string;
+        name?: string;
+    }>;
+    nextStep: string;
+    applyScript: string;
+}
+export type ImportHdriErrorCode = "bad_args" | "no_results" | "no_hdri_file" | "file_too_large" | "import_failed" | "hdri_import_failed";
+export declare class ImportHdriError extends Error {
+    readonly code: ImportHdriErrorCode;
+    readonly hint?: string | undefined;
+    constructor(code: ImportHdriErrorCode, message: string, hint?: string | undefined);
+}
+/** Poly Haven asset ids are lowercase slugs. Anything else in an API response
+ *  is rejected before it can reach a URL or res:// path. */
+export declare function isSafePolyHavenId(id: string): boolean;
+/** Only accept download URLs that point back at Poly Haven over https, with
+ *  no embedded credentials (https://user:pw@polyhaven.com/... parses to the
+ *  right hostname but is not a URL we should ever hand to the engine). */
+export declare function isPolyHavenDownloadUrl(rawUrl: string): boolean;
+/**
+ * The summer_run_script body that wires an imported HDRI as the sky. Plain
+ * GDScript against WorldEnvironment using only the baseline ctx helpers
+ * (get_scene_root / set_owner_recursive / report) — `ctx.ensure_environment`
+ * is not part of any shipped engine's ctx API and must not be relied on.
+ */
+export declare function hdriApplySnippet(importedPath: string): string;
+/**
+ * Search (or pick by id), choose a file, import through the engine. Throws
+ * ImportHdriError with a stable code for every failure the caller should
+ * surface as data; unexpected transport errors propagate as plain Errors.
+ */
+export declare function importPolyHavenHdri(args: ImportHdriArgs, engine: () => Promise<HdriImportEngine>): Promise<ImportHdriResult>;

package/dist/core/capabilities/hdri-import.js

@@ -0,0 +1,250 @@
+/**
+ * Poly Haven HDRI import (tool/import-hdri). Shared by the MCP tool
+ * (summer_import_hdri) and the CLI dispatcher (`summer tool import-hdri`).
+ *
+ * Talks to Poly Haven's public API — no key, no Summer account, CC0 catalog —
+ * then downloads the chosen .hdr/.exr THROUGH the engine's import pipeline
+ * (ImportFromUrl) so the result is a usable res:// texture. Every value read
+ * from the API is treated as untrusted data: ids must be slugs, download URLs
+ * must point back at Poly Haven over https.
+ */
+import { z } from "zod";
+const POLYHAVEN_API_URL = "https://api.polyhaven.com";
+const POLYHAVEN_USER_AGENT = "summer-engine-cli";
+export const HDRI_RESOLUTIONS = ["1k", "2k", "4k"];
+/** Refuse downloads above this unless the caller opts in: a 16k .exr is
+ *  hundreds of MB pulled through the engine on a user's machine. */
+export const HDRI_MAX_DOWNLOAD_BYTES = 64 * 1024 * 1024;
+/**
+ * The one input contract for summer_import_hdri, shared by the MCP tool (pass
+ * `.shape` to server.tool) and the CLI dispatcher (`summer tool import-hdri`)
+ * so an off-ladder resolution is rejected on both faces.
+ */
+export const importHdriArgsSchema = z.object({
+    query: z.string().optional(),
+    assetId: z.string().optional(),
+    resolution: z.enum(HDRI_RESOLUTIONS).default("2k"),
+    allow_large: z
+        .boolean()
+        .default(false)
+        .describe(`Allow files above ${HDRI_MAX_DOWNLOAD_BYTES / (1024 * 1024)} MB.`),
+});
+export class ImportHdriError extends Error {
+    code;
+    hint;
+    constructor(code, message, hint) {
+        super(message);
+        this.code = code;
+        this.hint = hint;
+        this.name = "ImportHdriError";
+    }
+}
+/** Poly Haven asset ids are lowercase slugs. Anything else in an API response
+ *  is rejected before it can reach a URL or res:// path. */
+export function isSafePolyHavenId(id) {
+    return /^[a-z0-9_-]{1,100}$/.test(id);
+}
+/** Only accept download URLs that point back at Poly Haven over https, with
+ *  no embedded credentials (https://user:pw@polyhaven.com/... parses to the
+ *  right hostname but is not a URL we should ever hand to the engine). */
+export function isPolyHavenDownloadUrl(rawUrl) {
+    try {
+        const parsed = new URL(rawUrl);
+        return (parsed.protocol === "https:" &&
+            parsed.username === "" &&
+            parsed.password === "" &&
+            (parsed.hostname === "polyhaven.com" ||
+                parsed.hostname.endsWith(".polyhaven.com") ||
+                parsed.hostname === "polyhaven.org" ||
+                parsed.hostname.endsWith(".polyhaven.org")));
+    }
+    catch {
+        return false;
+    }
+}
+async function polyHavenGetJson(endpoint) {
+    const res = await fetch(`${POLYHAVEN_API_URL}${endpoint}`, {
+        headers: { "User-Agent": POLYHAVEN_USER_AGENT },
+        signal: AbortSignal.timeout(20_000),
+    });
+    if (!res.ok) {
+        throw new Error(`Poly Haven API request failed (${res.status}) for ${endpoint}`);
+    }
+    return (await res.json());
+}
+/** The Poly Haven API has no text-search endpoint; /assets?type=hdris returns
+ *  the full HDRI catalog keyed by id. Score entries against the query terms. */
+function scorePolyHavenEntry(id, entry, terms) {
+    const name = typeof entry.name === "string" ? entry.name.toLowerCase() : "";
+    const tags = Array.isArray(entry.tags)
+        ? entry.tags.filter((tag) => typeof tag === "string").map((tag) => tag.toLowerCase())
+        : [];
+    const categories = Array.isArray(entry.categories)
+        ? entry.categories
+            .filter((category) => typeof category === "string")
+            .map((category) => category.toLowerCase())
+        : [];
+    let score = 0;
+    for (const term of terms) {
+        if (id.includes(term))
+            score += 4;
+        if (name.includes(term))
+            score += 4;
+        if (tags.some((tag) => tag === term))
+            score += 3;
+        else if (tags.some((tag) => tag.includes(term)))
+            score += 2;
+        if (categories.some((category) => category === term))
+            score += 3;
+        else if (categories.some((category) => category.includes(term)))
+            score += 1;
+    }
+    return score;
+}
+function pickHdriFile(files, requested) {
+    const hdri = files.hdri;
+    if (!hdri || typeof hdri !== "object")
+        return null;
+    // Prefer the requested resolution, then step DOWN, then step up.
+    const ladder = ["1k", "2k", "4k", "8k", "16k"];
+    const start = ladder.indexOf(requested);
+    const candidates = start === -1
+        ? ladder
+        : [
+            ladder[start],
+            ...ladder.slice(0, start).reverse(),
+            ...ladder.slice(start + 1),
+        ];
+    for (const resolution of candidates) {
+        const byFormat = hdri[resolution];
+        if (!byFormat || typeof byFormat !== "object")
+            continue;
+        for (const format of ["hdr", "exr"]) {
+            const file = byFormat[format];
+            if (file && typeof file.url === "string" && isPolyHavenDownloadUrl(file.url)) {
+                return { resolution, format, url: file.url, size: file.size };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * The summer_run_script body that wires an imported HDRI as the sky. Plain
+ * GDScript against WorldEnvironment using only the baseline ctx helpers
+ * (get_scene_root / set_owner_recursive / report) — `ctx.ensure_environment`
+ * is not part of any shipped engine's ctx API and must not be relied on.
+ */
+export function hdriApplySnippet(importedPath) {
+    return [
+        "func run(ctx):",
+        "    var root = ctx.get_scene_root()",
+        "    var env: WorldEnvironment = null",
+        '    var found = root.find_children("*", "WorldEnvironment", true, false)',
+        "    if found.size() > 0:",
+        "        env = found[0]",
+        "    else:",
+        "        env = WorldEnvironment.new()",
+        '        env.name = "WorldEnvironment"',
+        "        root.add_child(env)",
+        "        ctx.set_owner_recursive(env)",
+        "    var e: Environment = env.environment",
+        "    if e == null:",
+        "        e = Environment.new()",
+        "        env.environment = e",
+        "    var mat := PanoramaSkyMaterial.new()",
+        `    mat.panorama = load("${importedPath}")`,
+        "    var sky := Sky.new()",
+        "    sky.sky_material = mat",
+        "    e.background_mode = Environment.BG_SKY",
+        "    e.sky = sky",
+        "    e.ambient_light_source = Environment.AMBIENT_SOURCE_BG",
+        "    e.reflected_light_source = Environment.REFLECTION_SOURCE_BG",
+        `    ctx.report("sky", "${importedPath}")`,
+    ].join("\n");
+}
+/**
+ * Search (or pick by id), choose a file, import through the engine. Throws
+ * ImportHdriError with a stable code for every failure the caller should
+ * surface as data; unexpected transport errors propagate as plain Errors.
+ */
+export async function importPolyHavenHdri(args, engine) {
+    const resolution = args.resolution ?? "2k";
+    const query = args.query?.trim() ?? "";
+    if (!args.assetId && !query) {
+        throw new ImportHdriError("bad_args", "Pass query (to search) or assetId (exact Poly Haven id).");
+    }
+    let chosenId = args.assetId?.trim() ?? "";
+    let chosenName;
+    let alternates = [];
+    if (chosenId) {
+        if (!isSafePolyHavenId(chosenId)) {
+            throw new ImportHdriError("bad_args", "assetId must be a Poly Haven slug (lowercase letters, digits, _ or -).");
+        }
+    }
+    else {
+        const catalog = await polyHavenGetJson("/assets?type=hdris");
+        const terms = query
+            .toLowerCase()
+            .split(/[^a-z0-9]+/)
+            .filter((term) => term.length > 1);
+        const scored = Object.entries(catalog)
+            .filter(([id]) => isSafePolyHavenId(id))
+            .map(([id, entry]) => ({
+            id,
+            entry,
+            score: scorePolyHavenEntry(id, entry ?? {}, terms),
+        }))
+            .filter((candidate) => candidate.score > 0)
+            .sort((a, b) => b.score - a.score);
+        if (scored.length === 0) {
+            throw new ImportHdriError("no_results", `No Poly Haven HDRI matched "${query}". Try broader terms like 'sunset', 'studio', 'night', 'forest'.`);
+        }
+        chosenId = scored[0].id;
+        chosenName =
+            typeof scored[0].entry?.name === "string" ? scored[0].entry.name : undefined;
+        alternates = scored.slice(1, 5).map((candidate) => ({
+            id: candidate.id,
+            name: typeof candidate.entry?.name === "string" ? candidate.entry.name : undefined,
+        }));
+    }
+    const files = await polyHavenGetJson(`/files/${encodeURIComponent(chosenId)}`);
+    const file = pickHdriFile(files, resolution);
+    if (!file) {
+        throw new ImportHdriError("no_hdri_file", `Poly Haven asset "${chosenId}" has no downloadable .hdr/.exr — is it an HDRI id?`);
+    }
+    if (typeof file.size === "number" &&
+        file.size > HDRI_MAX_DOWNLOAD_BYTES &&
+        args.allow_large !== true) {
+        const mb = (bytes) => (bytes / (1024 * 1024)).toFixed(1);
+        throw new ImportHdriError("file_too_large", `Poly Haven "${chosenId}" at ${file.resolution} is ${mb(file.size)} MB, above the ` +
+            `${mb(HDRI_MAX_DOWNLOAD_BYTES)} MB ceiling for an engine-side download.`, "Pick a lower resolution, or pass allow_large:true to download it anyway.");
+    }
+    const importedPath = `res://sky/${chosenId}_${file.resolution}.${file.format}`;
+    const client = await engine();
+    const importResult = await client.executeOps([
+        { op: "ImportFromUrl", url: file.url, path: importedPath },
+    ]);
+    const receipts = importResult?.results ?? [];
+    const failure = receipts.find((receipt) => receipt?.ok === false);
+    if (importResult?.status === "error" || failure) {
+        throw new ImportHdriError("import_failed", failure?.error || "Could not import the HDRI. Check engine logs.", "Make sure Summer Engine is running with the project loaded.");
+    }
+    return {
+        success: true,
+        assetId: chosenId,
+        name: chosenName,
+        resolution: file.resolution,
+        resolutionNote: file.resolution === resolution
+            ? undefined
+            : `Requested ${resolution} was not available; imported ${file.resolution} instead.`,
+        format: file.format,
+        importedTo: importedPath,
+        license: "CC0 (Poly Haven) — free for any use, no attribution required.",
+        alternates: alternates.length > 0 ? alternates : undefined,
+        nextStep: "Wire it into the environment with summer_run_script using this exact script " +
+            "(needs an engine with RunSceneScript; on an older engine run the same body through " +
+            "summer_run_editor_script), then verify with summer_screenshot framing:\"camera\" " +
+            "(preset framings substitute the environment):",
+        applyScript: hdriApplySnippet(importedPath),
+    };
+}

package/dist/core/capabilities/image-generation.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+/** Shared MCP/CLI image request contract; optional flags preserve omission. */
+export declare const imageGenerationArgsSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    model: z.ZodDefault<z.ZodString>;
+    style: z.ZodDefault<z.ZodString>;
+    referenceImageUrl: z.ZodOptional<z.ZodString>;
+    removeBackground: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    model: string;
+    style: string;
+    options?: Record<string, any> | undefined;
+    referenceImageUrl?: string | undefined;
+    removeBackground?: boolean | undefined;
+}, {
+    prompt: string;
+    options?: Record<string, any> | undefined;
+    model?: string | undefined;
+    style?: string | undefined;
+    referenceImageUrl?: string | undefined;
+    removeBackground?: boolean | undefined;
+}>;

package/dist/core/capabilities/image-generation.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+/** Shared MCP/CLI image request contract; optional flags preserve omission. */
+export const imageGenerationArgsSchema = z.object({
+    prompt: z.string().describe("Description of the image to generate"),
+    model: z
+        .string()
+        .default("nano-banana-2")
+        .describe("Model name or full provider ID"),
+    style: z
+        .string()
+        .default("realistic")
+        .describe("Style preset: realistic, cartoon, anime, or 'none' to skip"),
+    referenceImageUrl: z
+        .string()
+        .optional()
+        .describe("Source image URL for img2img / edit mode. The prompt describes how to transform this image."),
+    removeBackground: z.boolean().optional().describe("Remove the background server-side and return an alpha PNG for sprites, icons, or isolated objects."),
+    options: z
+        .record(z.any())
+        .optional()
+        .describe("Provider-specific params (guidance_scale, seed, image_size, negative_prompt, etc.)"),
+});

package/dist/core/capabilities/navigation/open.d.ts

@@ -0,0 +1,156 @@
+/**
+ * `summer open` / `summer_open` — one behavior, two faces (CONTRACT §3).
+ *
+ * Resolve a target (id, intent phrase, res:// path or summerengine.com path)
+ * against the product map (./targets.ts), then either open it — the browser
+ * for web targets (through /login?returnUrl= when login is required and the
+ * CLI is not logged in), the running Summer Engine via the local API for
+ * editor targets — or, with `open: false`, return what would open without
+ * opening.
+ *
+ * Editor targets are FORWARDED, not implemented here: when the engine
+ * advertises `capabilities.navigation` the tool sends the one-table op
+ * `Navigate { target, ...args }`; on an engine that predates it the few ids the
+ * original ops can serve (scene, node, script, file, the three docks) use those
+ * ops and everything else answers `engine_lacks_op`. See NAVIGATION-PLAN.md.
+ *
+ * Both faces call runOpen(); the CLI (tool-dispatch + `summer open`) and the
+ * MCP tool (src/mcp/tools/navigation-tools.ts) only differ in how the engine
+ * client and the browser launcher are supplied.
+ */
+import { z } from "zod";
+import type { EngineCapabilities } from "../../capability-skew.js";
+import { type EditorTargetMeta, type NavParam, type NavSurface, type NavTarget } from "./targets.js";
+export type OpenSurface = "auto" | NavSurface;
+/** The ONE argument shape both faces validate with (mirrors
+ *  library/tools/open/resource.yaml input_schema; parity-tested). */
+export declare const openArgsShape: {
+    target: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    surface: z.ZodOptional<z.ZodEnum<["auto", "web", "editor"]>>;
+    open: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const openArgsSchema: z.ZodObject<{
+    target: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    surface: z.ZodOptional<z.ZodEnum<["auto", "web", "editor"]>>;
+    open: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    params?: Record<string, string> | undefined;
+    target?: string | undefined;
+    surface?: "web" | "editor" | "auto" | undefined;
+    open?: boolean | undefined;
+}, {
+    params?: Record<string, string> | undefined;
+    target?: string | undefined;
+    surface?: "web" | "editor" | "auto" | undefined;
+    open?: boolean | undefined;
+}>;
+export type OpenArgs = z.infer<typeof openArgsSchema>;
+export type OpenAction = "opened" | "printed" | "listed" | "ambiguous" | "unsupported" | "engine_not_running" | "engine_error" | "not_found" | "invalid_params" | "open_failed" | "blocked_origin";
+export interface OpenMatch {
+    id: string;
+    surface: NavSurface;
+    title: string;
+    score: number;
+}
+export type EditorAvailability = "available" | "legacy" | "unavailable" | "unknown";
+export interface OpenTargetSummary {
+    id: string;
+    surface: NavSurface;
+    title: string;
+    description: string;
+    requires: NavTarget["requires"];
+    params?: readonly NavParam[];
+    /** Editor rows: whether the connected engine can open it. `legacy` = served by
+     *  a pre-Navigate op; `unknown` = engine not reachable when listing. */
+    availability?: EditorAvailability;
+}
+export interface OpenResult {
+    ok: boolean;
+    action: OpenAction;
+    target?: OpenTargetSummary;
+    /** Web: the destination URL. */
+    url?: string;
+    /** Web: the login deep link when the target requires login. */
+    login_url?: string;
+    /** Web: whether this CLI holds a Summer login token (a hint; the browser may still ask). */
+    logged_in?: boolean;
+    /** Web: the URL actually launched (url or login_url). */
+    opened_url?: string;
+    /** Web: the path was not in the map but is on an allowed origin. */
+    unmapped?: boolean;
+    /** Editor: the op that was (or would be) sent. */
+    op?: Record<string, unknown>;
+    /** Editor: engine state. */
+    engine?: {
+        running: boolean;
+        version?: string;
+        navigation?: boolean;
+        error?: string;
+    };
+    /** Editor: the raw engine receipt on success. */
+    receipt?: unknown;
+    /** Structured failure class for ok:false results (engine_lacks_op, …). */
+    failure_reason?: string;
+    matches?: OpenMatch[];
+    targets?: OpenTargetSummary[];
+    hint?: string;
+}
+/** The slice of the engine client the tool needs (EngineApiClient satisfies it). */
+export interface OpenEngineClient {
+    executeOps(ops: Array<Record<string, unknown>>): Promise<unknown>;
+    getProjectState(prefix?: string): Promise<unknown>;
+    getEngineVersion?(): string | undefined;
+    getEngineCapabilities?(): EngineCapabilities | undefined;
+}
+export interface OpenDeps {
+    /** Connect to the running engine; MUST throw when it is not reachable. */
+    engine(): Promise<OpenEngineClient>;
+    openUrl(url: string): Promise<unknown>;
+    isLoggedIn(): Promise<boolean>;
+    gatewayUrl(): Promise<string>;
+    docsOrigin?: string;
+}
+/** The only origins this tool ever opens a browser on: summerengine.com and its
+ *  subdomains, plus loopback for local web development. A configured gateway
+ *  (SUMMER_GATEWAY_URL / gateway.url) that points anywhere else is refused —
+ *  the API calls may go there, a browser launch never does. */
+export declare function isAllowedNavigationOrigin(origin: string): boolean;
+/** A project resource path the engine may be asked to open: `res://` plus a
+ *  plain relative path — no parent segments, no backslashes, no percent
+ *  escapes, nothing that could name a file outside the project. Returns the
+ *  problem, or null when the path is acceptable. */
+export declare function resPathProblem(value: string): string | null;
+export declare function tokenize(text: string): string[];
+/** Rank every target for a free-text query. Exported for tests. */
+export declare function rankTargets(query: string, surface?: OpenSurface): OpenMatch[];
+type Resolution = {
+    kind: "target";
+    target: NavTarget;
+    params: Record<string, string>;
+} | {
+    kind: "url";
+    url: string;
+} | {
+    kind: "ambiguous";
+    matches: OpenMatch[];
+} | {
+    kind: "not_found";
+    matches: OpenMatch[];
+    hint: string;
+};
+export declare function unsafeRedirectParam(pathWithQuery: string): string | null;
+export declare function resolveTarget(rawTarget: string, params: Record<string, string>, surface: OpenSurface): Resolution;
+/** Fill a web path template. `{slot}` required, `[/{slot}]` optional. */
+export declare function renderWebPath(template: string, params: Record<string, string>, declared?: readonly NavParam[]): string;
+/** The one-table op: Navigate { target, ...args }. */
+export declare function buildNavigateOp(meta: EditorTargetMeta, params: Record<string, string>): Record<string, unknown>;
+/** The pre-Navigate op for engines that predate the table (only some rows have one). */
+export declare function buildLegacyOp(meta: EditorTargetMeta, params: Record<string, string>): Record<string, unknown> | null;
+/** Which ids the connected engine can open. undefined = engine predates the advert. */
+export declare function advertisedNavigation(client: OpenEngineClient): Set<string> | undefined;
+export declare function editorAvailability(meta: EditorTargetMeta, advertised: Set<string> | undefined): EditorAvailability;
+export declare function listTargets(surface?: OpenSurface, advertised?: Set<string> | undefined | "unknown"): OpenTargetSummary[];
+export declare function runOpen(args: OpenArgs, deps: OpenDeps): Promise<OpenResult>;
+export {};