@volter/live 0.5.210 → 0.5.212

package/dist/chunk-7SZ3C4CC.js

@@ -0,0 +1,768 @@
+// src/http-transport.ts
+import { Agent, fetch as nodeFetch } from "undici";
+function createDispatcher(timeoutMs) {
+  return new Agent({ headersTimeout: timeoutMs, bodyTimeout: timeoutMs });
+}
+async function dispatchFetch(url, init, dispatcher) {
+  if (!dispatcher) return fetch(url, init);
+  return await nodeFetch(url, {
+    ...init,
+    dispatcher
+  });
+}
+
+// ../sdk/src/commands.ts
+function verbCommandId(type) {
+  return `volter.${type}`;
+}
+
+// src/client.ts
+var DEFAULT_URL = "http://127.0.0.1:20173";
+var EditorCommandError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "EditorCommandError";
+    this.code = code;
+  }
+};
+var COMMAND_DEADLINE_MS = 15e4;
+var UNDICI_DEFAULT_HEADERS_TIMEOUT_MS = 3e5;
+var CONSOLE_DRAIN_TIMEOUT_MS = 1500;
+function describeFetchFailure(error) {
+  const messages = [];
+  let current = error;
+  for (let depth = 0; depth < 8; depth++) {
+    if (!(current instanceof Error)) break;
+    if (current.message) messages.push(current.message);
+    const code = current.code;
+    if (typeof code === "string" && code !== "") {
+      return { code, detail: messages.join(" <- ") };
+    }
+    const aggregate = current.errors;
+    if (Array.isArray(aggregate) && aggregate.length > 0) {
+      const inner = describeFetchFailure(aggregate[0]);
+      return { code: inner.code, detail: [...messages, inner.detail].join(" <- ") };
+    }
+    current = current.cause;
+  }
+  return { code: "UNKNOWN", detail: messages.join(" <- ") || String(error) };
+}
+var RETRYABLE_TRANSPORT_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EPIPE",
+  "ETIMEDOUT",
+  "EHOSTUNREACH",
+  "UND_ERR_SOCKET",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+var TRANSPORT_RETRY_DELAY_MS = 400;
+var EditorClient = class {
+  baseUrl;
+  fetchOverride;
+  transport;
+  constructor(opts) {
+    if (opts !== void 0 && (typeof opts !== "object" || opts === null || Array.isArray(opts))) {
+      throw new TypeError(
+        'EditorClient options must be an object. Use new EditorClient({ url: "http://127.0.0.1:20173" }), not new EditorClient("...").'
+      );
+    }
+    const unknownOptions = Object.keys(opts ?? {}).filter(
+      (key) => key !== "url" && key !== "transport" && key !== "fetch"
+    );
+    if (unknownOptions.length > 0) {
+      throw new Error(
+        `EditorClient: unknown option${unknownOptions.length === 1 ? "" : "s"} ${unknownOptions.map((key) => `"${key}"`).join(", ")}. Use { url: "http://127.0.0.1:<port>" } to target an editor.`
+      );
+    }
+    this.baseUrl = (opts?.url ?? DEFAULT_URL).replace(/\/$/, "");
+    this.fetchOverride = opts?.fetch;
+    this.transport = opts?.transport ?? null;
+  }
+  /**
+   * `retryTransport` opts a command into ONE automatic retry after a transport
+   * failure (see {@link RETRYABLE_TRANSPORT_CODES}). It is deliberately
+   * OPT-IN and off by default: a socket that died after the request was written
+   * cannot prove the editor did not already run the command, so a blanket retry
+   * would risk playing/stopping/writing twice. Read-only relays — the captures —
+   * have no such hazard and turn it on.
+   */
+  async command(body, options) {
+    const type = String(body["type"] ?? "command");
+    const deadlineMs = options?.deadlineMs ?? COMMAND_DEADLINE_MS;
+    if (this.transport) {
+      const answered = await this.transport(body);
+      if (!answered.ok) {
+        throw new EditorCommandError(
+          answered.error ?? `Editor command "${type}" failed`,
+          answered.code
+        );
+      }
+      return answered;
+    }
+    const url = `${this.baseUrl}/__editor/command`;
+    const request = JSON.stringify(body);
+    let res;
+    let retried = false;
+    let commandDispatcher;
+    for (; ; ) {
+      try {
+        const init = {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: request,
+          signal: AbortSignal.timeout(deadlineMs)
+        };
+        commandDispatcher = deadlineMs > UNDICI_DEFAULT_HEADERS_TIMEOUT_MS ? createDispatcher(deadlineMs + 3e4) : void 0;
+        res = this.fetchOverride ? await this.fetchOverride(url, init) : await dispatchFetch(url, init, commandDispatcher);
+        break;
+      } catch (error) {
+        await commandDispatcher?.destroy();
+        commandDispatcher = void 0;
+        if (error?.name === "TimeoutError") {
+          throw new EditorCommandError(
+            `The editor at ${this.baseUrl} never answered "${type}" within ${Math.round(deadlineMs / 1e3)}s \u2014 past every server-side budget, so the server itself is not answering. Check the terminal that started this editor session.`
+          );
+        }
+        const { code, detail } = describeFetchFailure(error);
+        if (options?.retryTransport === true && !retried && RETRYABLE_TRANSPORT_CODES.has(code)) {
+          retried = true;
+          await new Promise((resolve) => setTimeout(resolve, TRANSPORT_RETRY_DELAY_MS));
+          continue;
+        }
+        throw new EditorCommandError(
+          `POST ${url} ("${type}") never reached the editor: ${code}${detail ? ` (${detail})` : ""}.` + (retried ? ` Retried once after ${TRANSPORT_RETRY_DELAY_MS}ms; it failed the same way.` : "") + (options?.retryTransport === true ? "" : " Not retried automatically: this command can change editor state, and a socket that died after the request was written cannot prove the editor did not already run it.") + " A transport failure means the port stopped answering, not that the editor refused \u2014 the dev server restarts on any watched source edit, and it shuts itself down after an idle window. Check the terminal that started this editor session and confirm the port this client resolved.",
+          code
+        );
+      }
+    }
+    let data;
+    try {
+      data = await this.readJson(res);
+    } finally {
+      await commandDispatcher?.destroy();
+    }
+    if (!data.ok) {
+      throw new EditorCommandError(
+        data.error ?? `Editor command failed: ${res.status}`,
+        data.code
+      );
+    }
+    return data;
+  }
+  /** Refuse shutdown if a document cannot be saved. Does not stop the server. */
+  async prepareClose() {
+    await this.command({ type: "session-prepare-close" });
+  }
+  // --- Selection ---
+  async select(id) {
+    await this.command({ type: "select", id });
+  }
+  async selectMultiple(ids) {
+    await this.command({ type: "select-multiple", ids });
+  }
+  async selectAll() {
+    await this.command({ type: "select-all" });
+  }
+  // --- Viewport ---
+  async focusEntity(id) {
+    await this.command({ type: "focus-entity", id });
+  }
+  async focusSelection() {
+    await this.command({ type: "focus-selection" });
+  }
+  /**
+   * Frame the EDIT viewport camera on one entity — the strict sibling of
+   * {@link focusEntity}. Same framing; an id the scene does not know is a
+   * refusal naming the id (`EditorCommandError`, code `ENTITY_NOT_FOUND`)
+   * rather than `focusEntity`'s silent no-op, so a caller that frames an
+   * entity before capturing it cannot photograph the wrong thing.
+   */
+  async frameEntity(id) {
+    await this.command({ type: "frame-entity", id });
+  }
+  async viewPreset(preset) {
+    await this.command({ type: "view-preset", preset });
+  }
+  /**
+   * LOOK AROUND THE OPEN MODEL, visibly. Swings the active asset
+   * document's camera — the one on the human's screen — by `azimuth`/
+   * `elevation` radians, animated over `duration` seconds, and resolves when
+   * the move ends. A human drag during the move cancels it where it stands
+   * (`cancelledBy: 'human'`); the promise still resolves.
+   */
+  async orbitDocument(options) {
+    return this.command({ type: "document-orbit", ...options });
+  }
+  /** What a frame of a 3D document's stage costs, uncapped (`document-frame-cost`). */
+  async frameCostDocument(options) {
+    return this.command({ type: "document-frame-cost", ...options });
+  }
+  /** A slow full revolution around the open document's subject, at a constant rate. */
+  async turntableDocument(options) {
+    return this.command({ type: "document-turntable", ...options });
+  }
+  /**
+   * Frame the open document's subject (its selection if it has one). `fit`
+   * scales the fitted distance: 1 is the toolbar Frame button's tight fit.
+   */
+  async frameDocument(fit) {
+    return this.command({
+      type: "document-frame",
+      ...fit === void 0 ? {} : { fit }
+    });
+  }
+  async setCamera(position, target, fov) {
+    await this.command({
+      type: "set-camera",
+      position,
+      target,
+      ...fov === void 0 ? {} : { fov }
+    });
+  }
+  async captureViewport(size) {
+    const data = await this.command({
+      type: "capture-viewport",
+      ...size === void 0 ? {} : { size }
+    });
+    return { base64: data.base64, mimeType: data.mimeType };
+  }
+  /**
+   * Capture an isolated, deterministic four-view preview through the editor's
+   * native Asset Lab. The SDK delegates rendering to the editor; it never
+   * loads, clones, or interprets 3D assets itself.
+   */
+  async captureAssetPreview(source, options = {}) {
+    const data = await this.command(
+      {
+        type: "capture-asset-preview",
+        ...source,
+        ...options
+      },
+      // Photographing changes nothing, so a momentary transport failure is
+      // retried rather than costing the caller its capture.
+      { retryTransport: true }
+    );
+    return {
+      width: data.width,
+      height: data.height,
+      orientation: data.orientation,
+      views: data.views,
+      contactSheet: data.contactSheet
+    };
+  }
+  /**
+   * A caller-defined labeled shot set (`live`'s `assetPreviewShots`): the
+   * DEFINITION travels with the command (see `AssetPreviewShotSetDefinition`),
+   * and the editor's generic
+   * capture engine renders it — see the 3D integration's
+   * `captureShotSetAssetPreview`. Throws (via `command`'s `{ok:false}`
+   * unwrap) with a clear message naming the missing joint(s) when the asset
+   * lacks a bone the definition requires.
+   */
+  async captureShotSetPreview(source, definition, options = {}) {
+    const data = await this.command(
+      {
+        type: "capture-asset-preview",
+        ...source,
+        ...options,
+        shotSet: definition
+      },
+      { retryTransport: true }
+    );
+    return {
+      width: data.width,
+      height: data.height,
+      shots: data.shots,
+      warnings: data.warnings,
+      contactSheet: data.contactSheet
+    };
+  }
+  /**
+   * Score the asset against a reference GLB (the editor's `screenshot
+   * <model.glb> --compare <ref.glb>` command): matched orthographic front + side silhouettes
+   * (equal-height bounding-box framing, both yaw-normalized to face the
+   * camera), per-view IoU numbers, and overlay evidence images. The
+   * reference GLB's raw bytes travel base64 in the command; the editor
+   * renders and scores — the SDK never interprets 3D assets itself.
+   */
+  async captureAssetComparePreview(source, refGlbBase64, options = {}) {
+    const { refForward, ...dimensions } = options;
+    const data = await this.command({
+      type: "capture-asset-preview",
+      ...source,
+      ...dimensions,
+      compare: { glbBase64: refGlbBase64, ...refForward ? { forward: refForward } : {} }
+    });
+    return { width: data.width, height: data.height, views: data.views };
+  }
+  // --- Panels ---
+  /** Focus a static workspace panel by the key the editor's panel registry
+   *  holds; an unknown key refuses naming the keys it does hold. */
+  async showPanel(panel) {
+    await this.command({ type: "show-panel", panel });
+  }
+  /** Show several instances of the running project split-screen — multiplayer
+   *  authoring. Pass a total `count` (default "Player N" labels) or an array of
+   *  `names` (its length is the count; index 0 is the primary). Requires a live
+   *  play session. */
+  async setInstanceCount(countOrNames) {
+    await this.command(
+      Array.isArray(countOrNames) ? { type: "set-instance-count", names: countOrNames } : { type: "set-instance-count", count: countOrNames }
+    );
+  }
+  async openAsset(path, kind) {
+    await this.command({ type: "open-asset-tab", path, kind });
+  }
+  /** SELECT a project asset — the other half of the browser's
+   *  selection-vs-open contract (single click selects and fills the
+   *  Inspector; double click opens a document). */
+  async selectAsset(path) {
+    await this.command({ type: "select-asset", path });
+  }
+  async closeAsset(key) {
+    await this.command({ type: "close-asset-tab", key });
+  }
+  async toggleCommandPalette() {
+    await this.command({ type: "toggle-command-palette" });
+  }
+  async toggleConsole() {
+    await this.command({ type: "toggle-console" });
+  }
+  /** Switch the editor's NAMED WORKSPACE — the task-named layout memory
+   *  (`design`/`animate`/`look`, or one a package contributes). Resolves once the
+   *  dock has finished rebuilding, so a following capture photographs the
+   *  arrangement that was asked for. */
+  async setWorkspace(workspace) {
+    await this.command({ type: "set-workspace", workspace });
+  }
+  /** Choose a STYLE (`volter.style`) — its material, icon set and type, and the colour theme it
+   *  was drawn with (`classic`/`glass`/`maya`/`substance`, or one a package the project or
+   *  product composes carries). */
+  async setStyle(style) {
+    await this.command({ type: "set-style", style });
+  }
+  /** A view's presentation, answered resolved. With a LAYER the person's choice is recorded
+   *  first. */
+  async viewportPresentation(documentId, layer) {
+    return this.command({
+      type: "viewport-presentation",
+      documentId,
+      ...layer ? { layer } : {}
+    });
+  }
+  async showBuild() {
+    await this.command({ type: "show-build" });
+  }
+  /** Atomically present a durable editor view and return its shareable URL. */
+  async present(view) {
+    const presented = await this.command({ type: "present-view", view });
+    return { view: presented.view, url: presented.url, warnings: presented.warnings };
+  }
+  async inspect() {
+    const data = await this.command({ type: "inspect" });
+    return data.subject;
+  }
+  /** Run one verb exposed by the active Inspector subject, by its id. */
+  async runInspectionAction(actionId) {
+    const data = await this.command({
+      type: "run-inspection-action",
+      actionId
+    });
+    return data.subject;
+  }
+  /**
+   * Run ONE command by id — the door to everything the command palette lists.
+   *
+   * Under the Code-OSS frame this is the workbench's own `ICommandService`, so
+   * any command id works: a view's `volter.<view>.<verb>`, an editor action's
+   * `volter.action.<id>`, or one of VS Code's own. A call made before the
+   * command service lands waits for it.
+   *
+   * The result is whatever the command answered — a view verb's state, or
+   * `null` for a command that returns nothing.
+   */
+  async runCommand(commandId, args) {
+    const data = await this.command({
+      type: "run-command",
+      commandId,
+      ...args === void 0 ? {} : { args }
+    });
+    return data.result;
+  }
+  /**
+   * One STRUCTURE op on the authored tree — the hierarchy context menu's own
+   * verbs, on the same helpers, for a caller with no pointer to right-click
+   * with. `id`/`ids` default to the current selection.
+   */
+  async structureOp(op, options = {}) {
+    return this.command({ type: "structure-op", op, ...options });
+  }
+  /** "Extract Component…" — the hierarchy row's action, as a command. Answers
+   *  the action's own sentence, which NAMES the files it created. */
+  async extractComponent(options = {}) {
+    return this.command({ type: "extract-component", ...options });
+  }
+  /** "Fork Component…" — extract's twin: one new file, one callsite retargeted. */
+  async forkComponent(options = {}) {
+    return this.command({ type: "fork-component", ...options });
+  }
+  /**
+   * The HIERARCHY PANEL's actual rendered row tree, as data.
+   *
+   * The panel projects component marks, document promotion, child caps,
+   * collapse state, search and selection scope onto the adapter tree.
+   *
+   * Deliberately NOT `status().entities`, which walks the raw adapter tree and
+   * therefore answers a different question: a panel defect is invisible in it.
+   *
+   * Each row reports the projected child count and whether the panel draws a disclosure control.
+   *
+   * Rejects, naming the panel, when no hierarchy panel is mounted: an empty
+   * tree would be a fabricated answer about a surface nobody is being shown.
+   */
+  async hierarchy() {
+    const data = await this.command({ type: "hierarchy" });
+    return data.hierarchy;
+  }
+  /** Run the Hierarchy panel's own Expand All action. */
+  async expandHierarchyAll() {
+    await this.command({ type: "expand-hierarchy-all" });
+  }
+  /** Run the Hierarchy panel's own Collapse All action — Expand All's other
+   *  half, and the only way back to the tree's rest state through the product
+   *  (see `HierarchyPanelSnapshot.collapseAll`). */
+  async collapseHierarchyAll() {
+    await this.command({ type: "collapse-hierarchy-all" });
+  }
+  /**
+   * Write one editable path through the active Inspector's own IO.
+   *
+   * The answer carries `write` as well as the subject, because an ack alone
+   * cannot be believed: a write with no persistence route open succeeds and
+   * changes no byte, and `write.persisted` is how the caller tells the two
+   * apart without diffing the tree (`InspectedWriteDestination` in `types.ts`).
+   */
+  async setInspectionField(path, value) {
+    const data = await this.command({
+      type: "set-inspection-field",
+      path,
+      value
+    });
+    return { subject: data.subject, write: data.write };
+  }
+  /**
+   * REMOVE one editable path's authored override — the other half of the write
+   * door, and the only one that can express byte-ABSENCE.
+   *
+   * {@link setInspectionField} writes a VALUE, so reverting a property an
+   * authoring gesture ADDED puts the default back EXPLICITLY and leaves the
+   * source one attribute heavier than it started. This drops the property, so
+   * whatever governs it in its absence takes over — the same `io.remove` the
+   * Inspector's revert arrow calls, the same persistence pipe, the same awaited
+   * `{ destination, persisted }` ack.
+   *
+   * Rejects with `code: 'REMOVAL_UNAVAILABLE'` when the field does not declare
+   * itself removable or the lane implements no removal door. That refusal is a
+   * MISSING SEAM, not a failed removal, and it is coded rather than phrased
+   * precisely so a caller can grade the two differently.
+   */
+  async removeInspectionField(path) {
+    const data = await this.command({
+      type: "remove-inspection-field",
+      path
+    });
+    return { subject: data.subject, write: data.write };
+  }
+  /**
+   * OPEN one piece of the adapter's SCENE TABLE by id — a scene, a prefab, or
+   * a story state, because the table makes them siblings (they differ only in
+   * instance site). The ids are exactly what `getState().adapter.scenes.entries`
+   * reports, so the table is both the menu and the address space. It opens
+   * the entry's document in Play as in Edit.
+   *
+   * Rejects with a coded reason rather than prose: `SCENE_NOT_FOUND` (and it
+   * names the ids that DO exist), `SCENE_NOT_OPENABLE` carrying the reason an
+   * entry owns no document (the adapter's own, when it declared one),
+   * `SCENE_TABLE_UNAVAILABLE` before the adapter has loaded, and
+   * `SCENE_DOCUMENT_NOT_MOUNTED` when the host has no document for a piece the
+   * table says is openable — a host gap, not a table statement.
+   */
+  async open(id) {
+    return this.command({ type: "open", id });
+  }
+  /**
+   * Undo / redo one project transaction — the same queue the keyboard shortcut
+   * drives. `moved` is false when there was nothing left in that direction.
+   */
+  async undo() {
+    return this.command({ type: "undo" });
+  }
+  async redo() {
+    return this.command({ type: "redo" });
+  }
+  /** Read the editor's actual current durable projection. */
+  async currentView() {
+    const data = await this.command({ type: "current-view" });
+    return data.view;
+  }
+  /** Photograph the editor PAGE itself — every panel as the person sees it, at
+   *  `scale` output pixels per CSS pixel (default `devicePixelRatio`), which is
+   *  what a 1 px border or a glyph edge is judged through. */
+  async captureEditorChrome(options) {
+    return this.command({
+      type: "capture-editor-chrome",
+      ...options?.scale === void 0 ? {} : { scale: options.scale },
+      ...options?.region === void 0 ? {} : { region: options.region },
+      ...options?.name === void 0 ? {} : { name: options.name }
+    });
+  }
+  /** Capture the active document's render, excluding editor chrome. A number
+   * requests a square; `{width, height}` requests that shape, bounded by
+   * {@link CaptureDimensions}. With a view, present and capture it in one request
+   * so discovery cannot retarget the capture between client calls. */
+  async captureActiveDocument(size, view) {
+    return this.command({
+      type: "capture-active-document",
+      ...view ? { view } : {},
+      ...typeof size === "number" ? { size } : {},
+      ...typeof size === "object" && size !== null ? { width: size.width, height: size.height } : {}
+    });
+  }
+  /**
+   * Read or drive the ACTIVE center document's own DOM — the scoped
+   * editor-chrome door, and the read/gesture half of the same subject
+   * {@link captureActiveDocument} photographs. NOT play-mode gated, and NOT
+   * page automation: a target outside the active document's container is
+   * refused by name. Design and scope contract:
+   * `packages/sdk/src/editor-document-probe.ts`.
+   */
+  async documentProbe(step) {
+    return this.command({ type: "document-probe", step });
+  }
+  /**
+   * A verb a package contributes: the Code-OSS command `volter.<type>` its page half registers,
+   * waited on as long as its declaration says (`contributes.commands`' `volter.timeoutMs`, which
+   * the relay reads from the same manifest), so a package's long verb (a modeling chunk, minutes
+   * under Wasm) has its budget in one place. A verb no package declares is refused by name
+   * before anything is sent.
+   */
+  async contributedVerb(type, fields = {}) {
+    const id = verbCommandId(type);
+    const res = await this.httpFetch(`${this.baseUrl}/__editor/commands/${encodeURIComponent(id)}`);
+    const declared = await this.readJson(res);
+    if (!res.ok) throw new Error(declared.error ?? `No package declares the command "${id}" (${res.status}).`);
+    return this.command({ type, ...fields }, { deadlineMs: declared.timeoutMs + 3e4 });
+  }
+  /**
+   * Run a wire-carried step against the ACTIVE document's published context
+   * (`packages/editor-core/src/document-context-registry.ts`) — the REPL door over
+   * an open document. `src` is JavaScript source evaluated in the page; references to the caller's
+   * closures are unavailable.
+   */
+  async documentScript(src) {
+    const outcome = await this.command({ type: "document-script", src });
+    return outcome.result;
+  }
+  // --- Display (set semantics) ---
+  async setGrid(enabled) {
+    await this.command({ type: "set-grid", enabled });
+  }
+  async setHelpers(enabled) {
+    await this.command({ type: "set-helpers", enabled });
+  }
+  async setStats(enabled) {
+    await this.command({ type: "set-stats", enabled });
+  }
+  async setShadingMode(mode) {
+    await this.command({ type: "set-shading-mode", mode });
+  }
+  async setHelperType(helperType, enabled) {
+    await this.command({ type: "set-helper-type", helperType, enabled });
+  }
+  // --- Transform tools (set semantics) ---
+  async setTransformMode(mode) {
+    await this.command({ type: "set-transform-mode", mode });
+  }
+  async setTransformSpace(space) {
+    await this.command({ type: "set-transform-space", space });
+  }
+  async setSnap(enabled) {
+    await this.command({ type: "set-snap", enabled });
+  }
+  // --- Project management ---
+  /** A new project from one of the running product's templates or examples (its `/__editor/templates`), or its default
+   *  where neither is named. */
+  async createProject(name, location, from = {}) {
+    const res = await this.httpFetch(`${this.baseUrl}/__editor/create-project`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name, location, ...from })
+    });
+    const data = await this.readJson(res);
+    if (!res.ok) {
+      throw new Error(data.error ?? `Create project failed: ${res.status}`);
+    }
+    return { path: data.path, config: data.config };
+  }
+  async openProject(path) {
+    const res = await this.httpFetch(`${this.baseUrl}/__editor/open-project`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path })
+    });
+    const body = await this.readJson(res);
+    if (!res.ok) {
+      throw new Error(body.error ?? `Open project failed: ${res.status}`);
+    }
+  }
+  async getProject() {
+    const res = await this.httpFetch(`${this.baseUrl}/__editor/project`);
+    const data = await this.readJson(res);
+    if (!res.ok) throw new Error(data.error ?? `Failed to get project: ${res.status}`);
+    return data.project;
+  }
+  async listRecentProjects() {
+    const res = await this.httpFetch(`${this.baseUrl}/__editor/recent-projects`);
+    const data = await this.readJson(res);
+    if (!res.ok) throw new Error(data.error ?? `Failed to list projects: ${res.status}`);
+    return data.projects;
+  }
+  // --- State ---
+  /**
+   * The document table the host resolved — every scene, prefab, page, model,
+   * shot, take … the project's finders produced (`getState().adapter.scenes`
+   * is the same projection). A command, so it answers wherever the control
+   * channel reaches, not only where `/__editor/state` is served.
+   */
+  async documentTable() {
+    return this.command({ type: "document-table" });
+  }
+  async reloadPage() {
+    const timeoutMs = 6e4;
+    const epochs = async () => {
+      const { tabs } = await this.getState().catch(() => ({ tabs: [] }));
+      return new Map(tabs.map((tab) => [tab.tabId8, tab]));
+    };
+    const pause = () => new Promise((settle) => setTimeout(settle, 250));
+    const before = await epochs();
+    const deadline = Date.now() + timeoutMs;
+    await this.command({ type: "page-reload" });
+    let reloaded = [];
+    while (reloaded.length === 0) {
+      if (Date.now() > deadline) throw new Error("The reload was ordered and no tab of this session reported a new page load.");
+      await pause();
+      const now = await epochs();
+      reloaded = [...now].filter(([tabId, tab]) => tab.epochCount > (before.get(tabId)?.epochCount ?? 0)).map(([tabId]) => tabId);
+    }
+    for (; ; ) {
+      if (Date.now() > deadline) throw new Error("A new page loaded, but its command listener did not become ready.");
+      const now = await epochs();
+      if (reloaded.some((tabId) => {
+        const listener = now.get(tabId)?.commandListener;
+        return typeof listener !== "string" || listener === "ready";
+      })) break;
+      await pause();
+    }
+    for (; ; ) {
+      try {
+        await this.command({ type: "current-view" });
+        return;
+      } catch (error) {
+        if (Date.now() > deadline) throw error;
+        await pause();
+      }
+    }
+  }
+  async getState() {
+    const res = await this.httpFetch(`${this.baseUrl}/__editor/state`);
+    const state = await this.readJson(res);
+    if (!res.ok) throw new Error(`Failed to get editor state: ${res.status} ${res.statusText}`);
+    return state;
+  }
+  /**
+   * The complete unresolved console set the session is holding right now.
+   *
+   * The console endpoint returns named conditions; command envelopes carry
+   * only their counts. The request has a bounded header deadline.
+   */
+  async getUnresolvedConsole(opts) {
+    const res = await this.httpFetch(
+      `${this.baseUrl}/__editor/console${opts?.all === true ? "?all=1" : ""}`,
+      { signal: AbortSignal.timeout(CONSOLE_DRAIN_TIMEOUT_MS) }
+    );
+    if (!res.ok) {
+      throw new Error(`Failed to read unresolved console: ${res.status}`);
+    }
+    return await this.readJson(res);
+  }
+  /** Acknowledge one named console condition. */
+  async acknowledgeConsole(input) {
+    const res = await this.httpFetch(`${this.baseUrl}/__editor/console/ack`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input),
+      signal: AbortSignal.timeout(CONSOLE_DRAIN_TIMEOUT_MS * 4)
+    });
+    const body = await this.readJson(res);
+    return body;
+  }
+  /**
+   * `fetch` for this client's plain routes, with the ONE thing Node's `fetch`
+   * will not do: name why it failed.
+   *
+   * `readJson` below already owns "the server answered the wrong thing"; this
+   * owns "nothing answered at all", naming the real code Node buries on
+   * `.cause`. No retry
+   * here — these routes create projects, run tools and acknowledge console
+   * conditions, so repeating one is the caller's decision. The relayed
+   * `command` path above has its own opt-in retry for the read-only captures.
+   */
+  async httpFetch(url, init) {
+    try {
+      return this.fetchOverride ? await this.fetchOverride(url, init) : await dispatchFetch(url, init);
+    } catch (error) {
+      if (error?.name === "TimeoutError") throw error;
+      const { code, detail } = describeFetchFailure(error);
+      throw new EditorCommandError(
+        `${init?.method ?? "GET"} ${url} never reached the editor: ${code}${detail ? ` (${detail})` : ""}. Nothing answered on that port \u2014 check the terminal that started this editor session and confirm the port this client resolved.`,
+        code
+      );
+    }
+  }
+  /** Require a JSON response from the editor server. */
+  async readJson(res) {
+    const contentType = res.headers.get("content-type") ?? "";
+    if (!contentType.includes("application/json")) {
+      throw new Error(
+        `The editor at ${this.baseUrl} answered with its page fallback (${contentType || "no content-type"}) rather than JSON, so no editor server handled the request. Check that this URL is a running editor session.`
+      );
+    }
+    return await res.json();
+  }
+  /**
+   * Whether an editor browser tab is connected to the server *right now*.
+   * Unlike {@link getState}, this reflects live SSE connections, not cached
+   * state — use it to check whether commands will actually reach an editor.
+   */
+  async isConnected() {
+    const state = await this.getState();
+    return state.connected === true;
+  }
+  async waitForState(predicate, timeoutMs = 1e4) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const state = await this.getState();
+      if (predicate(state)) return state;
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    throw new Error(`waitForState timed out after ${timeoutMs}ms`);
+  }
+};
+
+export {
+  EditorCommandError,
+  EditorClient
+};
+//# sourceMappingURL=chunk-7SZ3C4CC.js.map