@forgeax/view 0.2.1-beta-20260924075842

package/dist/modules/chunks/chunk-C45U6IIY.mjs

@@ -0,0 +1,692 @@
+import {
+  runWorkspaceToolApi
+} from "./chunk-H3M22JDL.mjs";
+import {
+  isWorkspaceTargetRecoveryCode,
+  resolveWorkspaceFailure,
+  resolveWorkspaceReopenRoot
+} from "./chunk-VDZJWEAA.mjs";
+import {
+  editorSceneTargetIds,
+  isEditorWorkspaceAsset,
+  isTypePreviewAsset,
+  logResourceOpen,
+  selectEditorWorkspacePreview,
+  summarizeResourceAsset
+} from "./chunk-FKCQYDLX.mjs";
+import {
+  VIEW_DISPLAY_TAB_ID,
+  VIEW_FILE_GET_SERVICE,
+  VIEW_WORKSPACE_API_VERSION,
+  VIEW_WORKSPACE_OPERATIONS,
+  VIEW_WORKSPACE_SERVICES,
+  VIEW_WORKSPACE_STATE_TOPIC,
+  VIEW_WORKSPACE_TAB_ID,
+  assertWorkspaceRequest,
+  cloneWorkspaceValue,
+  requireWorkspaceString,
+  serializeWorkspaceAsset,
+  serializeWorkspaceInspection,
+  serializeWorkspaceOpenRequest,
+  serializeWorkspaceState,
+  workspaceCapabilities,
+  workspaceError,
+  workspaceUiFingerprint
+} from "./chunk-32GD5LL6.mjs";
+import {
+  createWorkspaceId
+} from "./chunk-TP26TASL.mjs";
+
+// packages/view-workspace-core/src/broker.mjs
+import { randomUUID } from "node:crypto";
+
+// packages/view-workspace-core/src/file-preview.mjs
+import { readFile, stat } from "node:fs/promises";
+import { extname, isAbsolute, relative, resolve } from "node:path";
+var EXT_KIND = Object.freeze({
+  ".png": { kind: "image", mime: "image/png" },
+  ".jpg": { kind: "image", mime: "image/jpeg" },
+  ".jpeg": { kind: "image", mime: "image/jpeg" },
+  ".gif": { kind: "image", mime: "image/gif" },
+  ".webp": { kind: "image", mime: "image/webp" },
+  ".avif": { kind: "image", mime: "image/avif" },
+  ".bmp": { kind: "image", mime: "image/bmp" },
+  ".ico": { kind: "image", mime: "image/x-icon" },
+  ".svg": { kind: "image", mime: "image/svg+xml" },
+  ".mp3": { kind: "audio", mime: "audio/mpeg" },
+  ".wav": { kind: "audio", mime: "audio/wav" },
+  ".ogg": { kind: "audio", mime: "audio/ogg" },
+  ".m4a": { kind: "audio", mime: "audio/mp4" },
+  ".flac": { kind: "audio", mime: "audio/flac" },
+  ".aac": { kind: "audio", mime: "audio/aac" },
+  ".mp4": { kind: "video", mime: "video/mp4" },
+  ".webm": { kind: "video", mime: "video/webm" },
+  ".mov": { kind: "video", mime: "video/quicktime" },
+  ".glb": { kind: "model", mime: "model/gltf-binary" },
+  ".gltf": { kind: "model", mime: "model/gltf+json" },
+  ".fbx": { kind: "model", mime: "application/octet-stream" },
+  ".ttf": { kind: "binary", mime: "font/ttf" },
+  ".otf": { kind: "binary", mime: "font/otf" },
+  ".woff": { kind: "binary", mime: "font/woff" },
+  ".woff2": { kind: "binary", mime: "font/woff2" }
+});
+var MAX_BINARY_PREVIEW_BYTES = 10 * 1024 * 1024;
+var BINARY_PREVIEW_KINDS = /* @__PURE__ */ new Set(["image", "audio", "video", "binary"]);
+function classifyFile(path) {
+  const ext = extname(path).toLowerCase();
+  return EXT_KIND[ext] ?? { kind: "text", mime: "text/plain; charset=utf-8" };
+}
+function resolveProjectFilePath(root, input) {
+  if (typeof root !== "string" || root.trim() === "") return null;
+  if (typeof input !== "string" || input.length === 0 || input.includes("\0")) return null;
+  const rootAbs = resolve(root);
+  const abs = isAbsolute(input) ? resolve(input) : resolve(rootAbs, input);
+  const rel = relative(rootAbs, abs);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return null;
+  const normalized = rel.split(/[/\\]/).join("/");
+  if (normalized === ".forgeax/ddc" || normalized.startsWith(".forgeax/ddc/")) return null;
+  return { abs, rel: normalized };
+}
+async function readFilePreview(absPath, rel) {
+  let info;
+  try {
+    info = await stat(absPath);
+  } catch {
+    throw new Error("not found");
+  }
+  if (info.isDirectory()) throw new Error("is a directory");
+  const ext = extname(rel).toLowerCase();
+  const { kind, mime } = classifyFile(rel);
+  const base = { path: rel, kind, mime, size: info.size, mtime: info.mtimeMs };
+  if (kind === "text") {
+    const content = await readFile(absPath, "utf8");
+    return { ...base, content };
+  }
+  if (kind === "image" && ext === ".svg") {
+    const content = await readFile(absPath, "utf8");
+    return { ...base, content };
+  }
+  if (BINARY_PREVIEW_KINDS.has(kind)) {
+    if (info.size > MAX_BINARY_PREVIEW_BYTES) return base;
+    const buffer = await readFile(absPath);
+    return { ...base, dataUrl: `data:${mime};base64,${buffer.toString("base64")}` };
+  }
+  return base;
+}
+async function readWorkspaceFilePreview(workspace, payload = {}) {
+  const root = workspace?.project?.root;
+  if (typeof root !== "string" || root.trim() === "") {
+    throw workspaceError(
+      "view-workspace-project-closed",
+      "an open project",
+      "Open a project before previewing source files."
+    );
+  }
+  const resolved = resolveProjectFilePath(root, payload?.path);
+  if (!resolved) {
+    throw workspaceError(
+      "view-workspace-invalid-args",
+      "path to be a file inside the open project",
+      "Provide a project-relative or in-project absolute path.",
+      { field: "path" }
+    );
+  }
+  try {
+    return await readFilePreview(resolved.abs, resolved.rel);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith("is a directory")) {
+      throw workspaceError(
+        "view-workspace-invalid-args",
+        "a file path",
+        message,
+        { path: resolved.rel }
+      );
+    }
+    throw workspaceError(
+      "view-workspace-file-not-found",
+      "the file to exist in the open project",
+      "Refresh the content browser and retry.",
+      { path: resolved.rel }
+    );
+  }
+}
+
+// packages/view-workspace-core/src/broker.mjs
+var ENGINE_SOURCE = "engine-workspace";
+var UI_OPERATIONS = Object.freeze({
+  "target.select": (workspace, args) => workspace.selectTarget(args),
+  "tabs.get": (workspace) => workspace.snapshot(),
+  "tabs.select": (workspace, args) => workspace.selectTab(args),
+  "scene.select": (workspace, args, context) => workspace.selectSceneEntity(args, context),
+  "scene.pick": (workspace, args, context) => workspace.pickSceneEntity(args, context),
+  "scene.clear": (workspace, args, context) => workspace.clearSceneSelection(args, context)
+});
+var ViewWorkspaceBroker = class {
+  constructor({ engine, toolApi, display = () => void 0, accessToken = randomUUID(), authorize } = {}) {
+    this.engine = engine;
+    this.toolApi = toolApi;
+    this.display = display;
+    this.accessToken = accessToken;
+    this.authorize = authorize;
+    this.selectedTabId = VIEW_WORKSPACE_TAB_ID;
+    this.targetBinding = "editor";
+    this.editorTargetId = void 0;
+    this.playOwner = void 0;
+    this.revision = 0;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.assets = null;
+    this.inspection = null;
+    this.openRequest = null;
+    this.openRequestSequence = 0;
+    this.resourceOpens = /* @__PURE__ */ new Map();
+    this.sceneSelection = null;
+    this.selectionAbort?.abort();
+    this.previewProjection = null;
+    this.projectOwner = void 0;
+    this.previewOwner = void 0;
+    this.workspaceTargetLost = false;
+    this.disposing = false;
+    this.publishFingerprint = "";
+  }
+  get project() {
+    return this.engine?.project?.project ?? null;
+  }
+  get projectTarget() {
+    return this.engine?.project?.target ?? null;
+  }
+  get preview() {
+    this.syncBindings();
+    return this.previewProjection;
+  }
+  previews() {
+    return this.engine?.previews ?? (this.engine?.preview ? [this.engine.preview] : []);
+  }
+  classifiedPreviews() {
+    return this.previews().map((preview) => ({
+      target: preview.target,
+      asset: this.hydrateAsset(preview.asset)
+    }));
+  }
+  editorPreview() {
+    const live = this.previews();
+    const selected = selectEditorWorkspacePreview(this.classifiedPreviews(), this.editorTargetId);
+    if (!selected) return void 0;
+    return live.find((preview) => String(preview.target.targetId) === String(selected.target.targetId));
+  }
+  boundTarget() {
+    return this.targetBinding === "play" ? this.engine?.play : this.previews().find((preview) => preview.target.targetId === this.previewTargetId) ?? this.editorPreview();
+  }
+  hydrateAsset(asset) {
+    if (!asset?.guid) return asset ?? null;
+    if (asset.kind) return asset;
+    const catalog = Array.isArray(this.assets) ? this.assets.find((entry) => entry.guid === asset.guid) : void 0;
+    if (!catalog?.kind) return asset;
+    return { ...asset, kind: catalog.kind, name: asset.name ?? catalog.name };
+  }
+  selectTarget({ targetId } = {}) {
+    if (targetId === this.engine?.play?.target.targetId) this.targetBinding = "play";
+    else {
+      const preview = this.previews().find((entry) => entry.target.targetId === targetId);
+      if (!preview) throw workspaceError("view-workspace-target-mismatch", "An existing preview or Play target", "Refresh tabs.get.");
+      this.targetBinding = "editor";
+      this.previewTargetId = targetId;
+      if (isEditorWorkspaceAsset(this.hydrateAsset(preview.asset))) this.editorTargetId = String(targetId);
+    }
+    this.changed();
+    return this.snapshot();
+  }
+  syncBindings() {
+    if (this.playOwner !== this.engine?.play) {
+      this.playOwner = this.engine?.play;
+      this.targetBinding = this.playOwner ? "play" : "editor";
+      if (!this.playOwner) this.previewTargetId = this.editorPreview()?.target.targetId;
+    }
+    if (this.projectOwner !== this.engine?.project) {
+      this.projectOwner = this.engine?.project;
+      this.assets = null;
+      this.inspection = null;
+      this.openRequest = null;
+      this.openRequestSequence = 0;
+      this.resourceOpens = /* @__PURE__ */ new Map();
+      this.editorTargetId = void 0;
+      this.sceneSelection = null;
+      this.selectionAbort?.abort();
+    }
+    if (this.previewOwner !== this.boundTarget()) {
+      this.previewOwner = this.boundTarget();
+      this.sceneSelection = null;
+      this.selectionAbort?.abort();
+      this.previewProjection = this.previewOwner ? {
+        target: this.previewOwner.target,
+        asset: this.previewOwner.asset,
+        presentation: this.previewOwner.presentation
+      } : null;
+    }
+  }
+  snapshot() {
+    this.syncBindings();
+    const display = this.display?.();
+    return serializeWorkspaceState({
+      revision: this.revision,
+      selectedTabId: this.selectedTabId,
+      tabs: [
+        {
+          tabId: VIEW_DISPLAY_TAB_ID,
+          kind: "display",
+          selected: this.selectedTabId === VIEW_DISPLAY_TAB_ID,
+          state: display?.state,
+          run: display?.occupancy?.run,
+          target: display?.occupancy?.target,
+          targetId: display?.occupancy?.targetId
+        },
+        {
+          tabId: VIEW_WORKSPACE_TAB_ID,
+          kind: "workspace",
+          selected: this.selectedTabId === VIEW_WORKSPACE_TAB_ID,
+          state: this.previewProjection ? "previewing" : this.project ? "project-open" : "empty",
+          ...this.previewProjection?.target ?? this.projectTarget ? { target: this.previewProjection?.target ?? this.projectTarget } : {}
+        }
+      ],
+      project: this.project,
+      projectTarget: this.projectTarget,
+      assets: this.assets,
+      preview: this.previewProjection && { ...this.previewProjection, target: this.boundTarget().target, asset: this.hydrateAsset(this.previewProjection.asset) },
+      editorPreview: this.editorPreview() ? { target: this.editorPreview().target, asset: this.hydrateAsset(this.editorPreview().asset) } : null,
+      previews: this.previews().map((preview) => ({ target: preview.target, asset: this.hydrateAsset(preview.asset) })),
+      play: this.engine?.play ? { target: this.engine.play.target, phase: this.engine.play.phase } : null,
+      targetBinding: this.targetBinding,
+      inspection: this.inspection,
+      openRequest: this.openRequest,
+      resourceOpens: Object.fromEntries(this.resourceOpens),
+      sceneSelection: this.sceneSelection,
+      workspaceTargetLost: this.workspaceTargetLost
+    });
+  }
+  changed() {
+    const current = this.snapshot();
+    const fingerprint = workspaceUiFingerprint(current);
+    if (fingerprint === this.publishFingerprint) return;
+    this.revision += 1;
+    const state = this.snapshot();
+    this.publishFingerprint = workspaceUiFingerprint(state);
+    for (const listener of this.listeners) {
+      try {
+        listener(state);
+      } catch {
+      }
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    const state = this.snapshot();
+    this.publishFingerprint ||= workspaceUiFingerprint(state);
+    listener(state);
+    return () => this.listeners.delete(listener);
+  }
+  capabilities() {
+    const descriptions = this.toolApi?.list().filter((record) => record.callable && (record.owner.sourceId === ENGINE_SOURCE || record.descriptor.id.startsWith("view.display."))).map((record) => ({ id: record.descriptor.id.replace(/^(engine|view)\./, ""), path: record.descriptor.path, title: record.descriptor.title, summary: record.descriptor.summary, inputSchema: record.descriptor.inputSchema, outputSchema: record.descriptor.outputSchema })) ?? [];
+    const operations = [
+      ...Object.keys(UI_OPERATIONS),
+      ...descriptions.map((item) => item.id),
+      ...VIEW_WORKSPACE_OPERATIONS.filter((id) => id.startsWith("plugins.") && this.toolApi?.describe(id, "view-backend").some((record) => record.callable))
+    ].filter((id) => VIEW_WORKSPACE_OPERATIONS.includes(id));
+    return { ...workspaceCapabilities({ ready: !!this.engine && !this.disposing, headed: this.projectTarget?.headed === true, operations }), descriptions };
+  }
+  async authorizeRequest(request, caller) {
+    if (this.disposing) throw workspaceError("view-workspace-stopping", "View bindings to remain available", "Reconnect to the backend.");
+    if (request.token !== this.accessToken || this.authorize && !await this.authorize({ clientId: request.clientId, operation: request.operation, request, caller })) {
+      throw workspaceError("view-workspace-unauthorized", "an authorized workspace connection", "Connect with the issued token.", { clientId: request.clientId });
+    }
+  }
+  async call(rawRequest, { signal, caller } = {}) {
+    const request = assertWorkspaceRequest(rawRequest);
+    await this.authorizeRequest(request, caller);
+    const ui = UI_OPERATIONS[request.operation];
+    if (ui) return ui(this, request.args, { signal, caller, clientId: request.clientId });
+    if (request.operation === "project.reopen") {
+      return this.reopenProject(request.args, {
+        signal,
+        caller,
+        clientId: request.clientId,
+        token: request.token,
+        requestId: request.requestId
+      });
+    }
+    return this.invoke(request.operation, request.args, { signal, caller, clientId: request.clientId, token: request.token, requestId: request.requestId });
+  }
+  async invoke(operation, args = {}, { signal, caller, clientId = "view-owner", token, requestId } = {}) {
+    const { tabId, ...input } = args;
+    if (tabId !== void 0) this.assertWorkspaceTab(tabId);
+    const inspector = operation.startsWith("plugins.");
+    const presentation = operation.startsWith("display.");
+    const id = inspector ? operation : `${presentation ? "view" : "engine"}.${operation}`;
+    const sourceId = inspector || presentation ? "view-backend" : ENGINE_SOURCE;
+    const owner = this.toolApi?.describe(id, sourceId).find((record) => record.callable)?.owner;
+    if (!owner) throw workspaceError("view-workspace-operation-unavailable", `Engine operation ${operation} to be installed`, "Enable the Engine capability; UI plugins do not provide domain APIs.", { operation });
+    const requestedPreview = [...this.previews(), this.engine?.play].find((preview) => preview?.target.targetId === input.targetId);
+    const terminal = await this.toolApi.run(id, inspector ? {
+      apiVersion: "forgeax.view.inspector/1",
+      operation,
+      args: input,
+      ...input,
+      clientId,
+      token,
+      requestId
+    } : presentation ? input : { ...input, clientId }, { sourceId, providerId: owner.providerId, generation: owner.generation, caller, signal }).terminal;
+    if (terminal.outcome === "failed") {
+      const resolved = resolveWorkspaceFailure(terminal.failure);
+      const addressesWorkspace = input.targetId === void 0 || [this.projectTarget, this.editorPreview()?.target].some((target) => target && target.targetId === input.targetId && (input.targetGeneration === void 0 || target.generation === input.targetGeneration));
+      if (isWorkspaceTargetRecoveryCode(resolved.code) && addressesWorkspace) {
+        this.workspaceTargetLost = true;
+      }
+      this.changed();
+      throw workspaceError(resolved.code, resolved.expected, resolved.hint, resolved.detail);
+    }
+    const result = terminal.result;
+    if (Array.isArray(result?.assets)) this.assets = result.assets.map((asset) => serializeWorkspaceAsset({ ...asset, ...asset.ddc || !asset.cookReceiptUrl ? {} : { ddc: { receiptUrl: asset.cookReceiptUrl } } }));
+    if (result?.inspection) this.inspection = serializeWorkspaceInspection(result.inspection);
+    if (operation === "asset.open") this.bindOpenedAsset(result, input.guid);
+    if (operation === "preview.close" && input.targetId != null && String(input.targetId) === this.editorTargetId) {
+      this.editorTargetId = void 0;
+    }
+    this.syncBindings();
+    if (operation === "asset.open") this.recordOpenRequest({ requestId, result, guid: input.guid });
+    if ((operation.startsWith("camera.") || operation === "target.control") && this.previewProjection && this.boundTarget() === requestedPreview) {
+      this.previewProjection.camera = result?.camera;
+      this.previewProjection.cameraVersion = result?.version;
+      this.previewProjection.interaction = result?.interaction ?? null;
+    }
+    if (!["scene-tree.get", "entity.inspect", "workspace.get", "preview.capture"].includes(operation)) this.changed();
+    if (["project.open", "project.close", "project.reopen", "asset.open", "preview.close", "camera.abort", "play.start", "play.ready", "play.stop"].includes(operation)) {
+      if (operation === "project.open" || operation === "project.reopen") this.workspaceTargetLost = false;
+      return this.snapshot();
+    }
+    if (operation.startsWith("camera.")) return { ...cloneWorkspaceValue(result), apiVersion: VIEW_WORKSPACE_API_VERSION, target: requestedPreview?.target };
+    if (operation === "assets.list") return { ...cloneWorkspaceValue(result), assets: this.assets };
+    return cloneWorkspaceValue(result);
+  }
+  assertWorkspaceTab(tabId) {
+    requireWorkspaceString(tabId, "tabId");
+    if (tabId !== VIEW_WORKSPACE_TAB_ID) throw workspaceError("view-workspace-tab-read-only", "the Editor binding", "Address AI execution through the Engine run API.", { tabId });
+  }
+  selectTab({ tabId } = {}) {
+    if (![VIEW_DISPLAY_TAB_ID, VIEW_WORKSPACE_TAB_ID].includes(tabId)) throw workspaceError("view-workspace-tab-not-found", "an existing tab", "Refresh tabs.get.", { tabId });
+    this.selectedTabId = tabId;
+    this.changed();
+    return this.snapshot();
+  }
+  async selectSceneEntity(args = {}, context) {
+    requireWorkspaceString(args.entityId, "entityId");
+    return this.changeSceneSelection(args, context, () => args);
+  }
+  pickSceneEntity(args = {}, context) {
+    return this.changeSceneSelection(args, context, async (requestContext) => {
+      const result = await this.invoke("target.pick", args, requestContext);
+      if (result?.entityId === null) return null;
+      requireWorkspaceString(result?.entityId, "pick.entityId");
+      return { entityId: result.entityId };
+    });
+  }
+  clearSceneSelection(args = {}, context) {
+    return this.changeSceneSelection(args, context, () => null);
+  }
+  async changeSceneSelection({ tabId, targetId, targetGeneration } = {}, context, resolveSelection) {
+    if (tabId !== void 0) this.assertWorkspaceTab(tabId);
+    this.syncBindings();
+    const requested = this.boundTarget();
+    if (!requested || requested.target.targetId !== targetId || requested.target.generation !== targetGeneration) throw workspaceError("view-workspace-selection-stale", "The bound target and generation", "Select the target before changing its selection.");
+    this.selectionAbort?.abort();
+    const controller = new AbortController();
+    this.selectionAbort = controller;
+    const signal = context?.signal ? AbortSignal.any([context.signal, controller.signal]) : controller.signal;
+    const requestContext = { ...context, signal };
+    const assertCurrent = () => {
+      signal.throwIfAborted();
+      if (this.boundTarget() !== requested) throw workspaceError("view-workspace-selection-stale", "The same selected target", "Refresh the hierarchy.");
+    };
+    const selection = await resolveSelection(requestContext);
+    assertCurrent();
+    const { entityId, label } = selection ?? {};
+    if (selection) {
+      const result = await this.invoke("entity.inspect", { entityId, targetId, targetGeneration }, requestContext);
+      assertCurrent();
+      if (result?.entityId !== entityId) throw workspaceError(
+        "view-workspace-selection-stale",
+        "The inspected entity on the same target",
+        "Refresh the hierarchy before selecting."
+      );
+    }
+    await this.invoke("entity.highlight", { ...selection ? { entityId } : {}, targetId, targetGeneration }, requestContext);
+    assertCurrent();
+    this.sceneSelection = selection ? { primary: { entityId, ...label === void 0 ? {} : { label: String(label) } }, targetId, targetGeneration } : null;
+    this.changed();
+    return this.snapshot();
+  }
+  openProject(args, context) {
+    return this.invoke("project.open", args, context);
+  }
+  async reopenProject(args = {}, context) {
+    const root = resolveWorkspaceReopenRoot(this.snapshot(), args.root);
+    const { tabId, ...rest } = args;
+    return this.openProject({ ...rest, root, ...tabId === void 0 ? {} : { tabId } }, context);
+  }
+  closeProject(args, context) {
+    return this.invoke("project.close", args, context);
+  }
+  listAssets(args, context) {
+    return this.invoke("assets.list", args, context);
+  }
+  inspectAsset(args, context) {
+    return this.invoke("asset.inspect", args, context);
+  }
+  rebuildAssetSource(args, { mode = "rebuild", ...context } = {}) {
+    return this.invoke(`asset-source.${mode}`, args, context);
+  }
+  bindOpenedAsset(result, guid) {
+    this.targetBinding = "editor";
+    const kind = this.hydrateAsset(result?.preview?.asset)?.kind ?? this.hydrateAsset(result?.asset)?.kind ?? this.assets?.find((entry) => entry?.guid === guid)?.kind;
+    if (kind && !isTypePreviewAsset({ kind })) {
+      const targetId = result?.preview?.target?.targetId ?? result?.target?.targetId ?? this.previews().find((entry) => this.hydrateAsset(entry.asset)?.guid === guid)?.target?.targetId;
+      if (targetId != null) {
+        this.editorTargetId = String(targetId);
+        this.previewTargetId = this.editorTargetId;
+      }
+      return;
+    }
+    const editorId = this.editorPreview()?.target?.targetId;
+    if (editorId !== void 0) this.previewTargetId = editorId;
+  }
+  recordOpenRequest({ requestId, result, guid } = {}) {
+    const requested = typeof guid === "string" && guid.trim() !== "" ? guid : void 0;
+    const editor = this.editorPreview();
+    const editorIds = editorSceneTargetIds(
+      this.classifiedPreviews(),
+      editor ? { target: editor.target, asset: this.hydrateAsset(editor.asset) } : void 0
+    );
+    const extras = this.previews().filter(
+      (entry) => entry?.target?.targetId && !editorIds.has(String(entry.target.targetId))
+    );
+    const preview = [result?.preview, ...extras].find(
+      (entry) => entry?.target && !editorIds.has(String(entry.target.targetId)) && (!entry.asset || requested === void 0 || entry.asset.guid === requested)
+    );
+    const catalogAsset = requested && Array.isArray(this.assets) ? this.assets.find((entry) => entry?.guid === requested && entry?.kind) : void 0;
+    const asset = [
+      this.hydrateAsset(result?.preview?.asset),
+      this.hydrateAsset(result?.asset),
+      this.hydrateAsset(preview?.asset),
+      catalogAsset
+    ].find(
+      (candidate) => candidate?.guid && candidate?.kind && (requested === void 0 || candidate.guid === requested)
+    );
+    if (!asset?.guid || !asset?.kind) {
+      logResourceOpen("open-request-skipped", {
+        reason: "asset-kind-unavailable",
+        requested: requested ?? null,
+        resultPreview: summarizeResourceAsset(result?.preview?.asset),
+        resultAsset: summarizeResourceAsset(result?.asset),
+        extraPreview: summarizeResourceAsset(preview?.asset),
+        extraPreviewCount: extras.length,
+        catalog: summarizeResourceAsset(catalogAsset),
+        editorTargetId: this.editorTargetId ?? null
+      }, { level: "warn" });
+      return;
+    }
+    this.openRequestSequence += 1;
+    const inspection = result?.inspection?.guid === asset.guid ? result.inspection : this.inspection?.guid === asset.guid ? this.inspection : void 0;
+    const previewMatches = preview?.target && (!preview.asset || preview.asset.guid === asset.guid);
+    const recordedPreview = previewMatches ? { asset, target: preview.target } : void 0;
+    this.openRequest = serializeWorkspaceOpenRequest({
+      requestId: typeof requestId === "string" && requestId.trim() !== "" ? requestId : createWorkspaceId("open"),
+      sequence: this.openRequestSequence,
+      asset,
+      preview: recordedPreview,
+      ...inspection === void 0 ? {} : { inspection }
+    });
+    this.resourceOpens.set(asset.kind, {
+      asset,
+      preview: recordedPreview
+    });
+    logResourceOpen("open-request-recorded", {
+      requestId: this.openRequest.requestId,
+      sequence: this.openRequest.sequence,
+      asset: summarizeResourceAsset(this.openRequest.asset),
+      hasPreview: Boolean(this.openRequest.preview?.target),
+      previewTargetId: this.openRequest.preview?.target?.targetId ?? null
+    });
+  }
+  openAsset(args, context) {
+    return this.invoke("asset.open", args, context);
+  }
+  closePreview(args, context) {
+    return this.invoke("preview.close", args, context);
+  }
+  capture(args, context) {
+    return this.invoke("preview.capture", args, context);
+  }
+  resizePreview(args, context) {
+    return this.invoke("preview.resize", args, context);
+  }
+  getCamera(args, context) {
+    return this.invoke("camera.get", args, context);
+  }
+  beginCamera(args, context) {
+    return this.invoke("camera.begin", { ...args, interactionId: args.interactionId ?? randomUUID() }, context);
+  }
+  updateCamera(args, context) {
+    return this.invoke("camera.update", args, context);
+  }
+  commitCamera(args, context) {
+    return this.invoke("camera.commit", args, context);
+  }
+  abortCamera(args, context) {
+    return this.invoke("camera.abort", args, context);
+  }
+  getSceneTree(args, context) {
+    return this.invoke("scene-tree.get", args, context);
+  }
+  async revokeConnection(connectionId) {
+    if (typeof connectionId !== "string") return;
+    for (const preview of [this.engine?.preview, this.engine?.play]) {
+      if (!preview) continue;
+      try {
+        const result = await preview.revokeConnection?.({ targetId: preview.target.targetId, connectionId });
+        this.syncBindings();
+        if (this.previewOwner === preview && this.previewProjection && result) {
+          this.previewProjection.interaction = result.interaction ?? null;
+          this.previewProjection.cameraVersion = result.version;
+        }
+      } catch {
+      }
+    }
+    this.changed();
+  }
+  /**
+   * Reset per-page UI session state when a new View frontend page is admitted.
+   * The open project and its Engine session stay; everything the previous page
+   * accumulated after project.open returns to the just-opened state, so a
+   * refreshed page's first snapshot does not inherit the old page's history.
+   */
+  resetPageSession() {
+    if (this.disposing) return;
+    this.selectedTabId = VIEW_WORKSPACE_TAB_ID;
+    this.targetBinding = "editor";
+    this.previewTargetId = void 0;
+    this.inspection = null;
+    this.openRequest = null;
+    this.openRequestSequence = 0;
+    this.resourceOpens = /* @__PURE__ */ new Map();
+    this.sceneSelection = null;
+    this.selectionAbort?.abort();
+    this.selectionAbort = void 0;
+    this.previewOwner = void 0;
+    this.syncBindings();
+    this.changed();
+    const project = this.project;
+    if (project) {
+      void this.invoke("assets.list", { projectId: project.id }).catch(() => {
+      });
+    }
+  }
+  registerTransport(transport, { routeThroughTools = false } = {}) {
+    const capabilities = transport.register(VIEW_WORKSPACE_SERVICES.capabilities, () => this.capabilities());
+    const call = transport.register(VIEW_WORKSPACE_SERVICES.call, async ({ payload, signal, caller }) => {
+      try {
+        return routeThroughTools ? await runWorkspaceToolApi(this.toolApi, {
+          operation: `view.workspace.${payload.operation}`,
+          args: payload.args,
+          clientId: payload.clientId,
+          token: payload.token,
+          requestId: payload.requestId,
+          caller,
+          signal,
+          sourceId: "view-workspace"
+        }) : await this.call(payload, { signal, caller });
+      } catch (error) {
+        if (!error.code?.startsWith("view-")) throw error;
+        throw Object.assign(new Error(error.message), {
+          name: "HostAssemblyError",
+          code: "host-transport-failure",
+          expected: error.expected,
+          hint: error.hint,
+          detail: { ...error.detail, remoteCode: error.code }
+        });
+      }
+    });
+    const fileGet = transport.register(VIEW_FILE_GET_SERVICE, async ({ payload }) => {
+      try {
+        return await readWorkspaceFilePreview(this, payload);
+      } catch (error) {
+        if (!error.code?.startsWith("view-")) throw error;
+        throw Object.assign(new Error(error.message), {
+          name: "HostAssemblyError",
+          code: "host-transport-failure",
+          expected: error.expected,
+          hint: error.hint,
+          detail: { ...error.detail, remoteCode: error.code }
+        });
+      }
+    });
+    const subscription = this.subscribe((state) => transport.publish(VIEW_WORKSPACE_STATE_TOPIC, state));
+    const observer = transport.connect();
+    const engineSubscription = observer.subscribe("engine.workspace.state", () => this.changed());
+    return () => {
+      capabilities();
+      call();
+      fileGet();
+      subscription();
+      engineSubscription();
+      observer.close();
+    };
+  }
+  async dispose() {
+    this.selectionAbort?.abort();
+    this.disposing = true;
+    this.listeners.clear();
+  }
+};
+
+export {
+  ViewWorkspaceBroker
+};
+//# sourceMappingURL=chunk-C45U6IIY.mjs.map