@forgeax/view 0.2.1-beta-20260924075842

package/dist/modules/index.mjs

@@ -0,0 +1,784 @@
+import {
+  VIEW_ENGINE_ASSET_SOURCE_TOOLS,
+  VIEW_ENGINE_WORKSPACE_ADAPTER,
+  createEngineWorkspaceAdapter,
+  isEngineWorkspaceAdapter
+} from "./chunks/chunk-FD4BAJ6K.mjs";
+import {
+  FORGEAX_VIEW_PLUGIN_ID,
+  FORGEAX_VIEW_PLUGIN_MODULE,
+  product_default
+} from "./chunks/chunk-H3KNBALD.mjs";
+import {
+  createViewCliContributions,
+  createViewHostCliContributions
+} from "./chunks/chunk-Q4RXBGQS.mjs";
+import "./chunks/chunk-JWZIREC3.mjs";
+import "./chunks/chunk-7ITLCRND.mjs";
+import {
+  VIEW_CLI_CONTRIBUTION_ID
+} from "./chunks/chunk-HES3DNTM.mjs";
+import "./chunks/chunk-AEK7ZESQ.mjs";
+import "./chunks/chunk-DQWVWWUU.mjs";
+import "./chunks/chunk-KSZNCFU4.mjs";
+import "./chunks/chunk-MVEPGFSB.mjs";
+import {
+  runViewWorkspaceCli
+} from "./chunks/chunk-2ASWB6IX.mjs";
+import {
+  runViewStartInteractive
+} from "./chunks/chunk-AAFVCQPK.mjs";
+import "./chunks/chunk-4GQWYU2V.mjs";
+import "./chunks/chunk-QL7V6DK7.mjs";
+import "./chunks/chunk-FOBRLUQV.mjs";
+import {
+  connectViewFrontend,
+  mountViewViewer,
+  mountViewWorkspace
+} from "./chunks/chunk-ZFXZ2NUI.mjs";
+import "./chunks/chunk-SR66S6EJ.mjs";
+import "./chunks/chunk-YVQSDKAO.mjs";
+import "./chunks/chunk-4WXD2KYX.mjs";
+import "./chunks/chunk-GYWIY7AL.mjs";
+import "./chunks/chunk-QURKBAG4.mjs";
+import "./chunks/chunk-6ZWWVAZK.mjs";
+import "./chunks/chunk-MBS3EICT.mjs";
+import "./chunks/chunk-QLBQQKRI.mjs";
+import "./chunks/chunk-ZNZPYE2V.mjs";
+import "./chunks/chunk-NBJKLWJ5.mjs";
+import "./chunks/chunk-AL6ZWIEU.mjs";
+import "./chunks/chunk-UAY27HT3.mjs";
+import {
+  ViewDisplayStatus,
+  frontend_default
+} from "./chunks/chunk-YTHGRKGI.mjs";
+import {
+  ViewWorkspaceInputController,
+  ViewWorkspaceShell,
+  createBrowserPagePresentation,
+  isViewportWorkspaceInputEvent
+} from "./chunks/chunk-QSKQZGK7.mjs";
+import "./chunks/chunk-7TGVWKH7.mjs";
+import "./chunks/chunk-UDVQHPWV.mjs";
+import "./chunks/chunk-PEUT3FW7.mjs";
+import "./chunks/chunk-UDLIWGWS.mjs";
+import "./chunks/chunk-4BXQOUDQ.mjs";
+import "./chunks/chunk-G7BAFAGO.mjs";
+import "./chunks/chunk-QF4V23GW.mjs";
+import "./chunks/chunk-FV3DSKZB.mjs";
+import "./chunks/chunk-OBK4LIJB.mjs";
+import {
+  createViewBackend,
+  createViewHostBinding,
+  createViewPlatformBinding
+} from "./chunks/chunk-EPSTTHWV.mjs";
+import "./chunks/chunk-XFQT7XCG.mjs";
+import "./chunks/chunk-L45W6KM6.mjs";
+import {
+  DEFAULT_CAPABILITIES,
+  ViewResourceBroker
+} from "./chunks/chunk-XUYFV23R.mjs";
+import {
+  disposeResource
+} from "./chunks/chunk-QD6CCRMG.mjs";
+import "./chunks/chunk-JHOURMYW.mjs";
+import "./chunks/chunk-R4I4JEY5.mjs";
+import {
+  ViewWorkspaceBroker
+} from "./chunks/chunk-C45U6IIY.mjs";
+import "./chunks/chunk-IVHNYKZB.mjs";
+import {
+  DEFAULT_PATH,
+  connectViewWorkspace,
+  startViewHostServer
+} from "./chunks/chunk-73UZNRHN.mjs";
+import {
+  VIEW_INSPECTOR_API_VERSION,
+  VIEW_INSPECTOR_OPERATIONS,
+  VIEW_INSPECTOR_SERVICES,
+  VIEW_INSPECTOR_TOPIC,
+  VIEW_STATUS_OPERATION,
+  ViewInspectorBroker,
+  ViewInspectorClient,
+  ViewInspectorPanel,
+  createInspectorRequest,
+  createViewInspectorToolContributions,
+  createViewStatusToolContributions,
+  createViewWorkspaceToolContributions,
+  runInspectorToolApi,
+  runViewToolApi,
+  runWorkspaceToolApi,
+  safeDetail,
+  safeError,
+  viewInspectorBackendPlugin,
+  viewInspectorFrontendPlugin
+} from "./chunks/chunk-KHRTIZ56.mjs";
+import "./chunks/chunk-IGRMZYRD.mjs";
+import "./chunks/chunk-H3M22JDL.mjs";
+import {
+  createViewProductPlan,
+  viewFrontendRoot
+} from "./chunks/chunk-RXF7SBBZ.mjs";
+import "./chunks/chunk-Y5HXCPPQ.mjs";
+import "./chunks/chunk-QK6W7MJO.mjs";
+import "./chunks/chunk-VIGOJWSO.mjs";
+import "./chunks/chunk-7URFF53W.mjs";
+import {
+  DISPLAY_SURFACE_ID,
+  VIEW_STATUS_SERVICE,
+  VIEW_STATUS_TOPIC
+} from "./chunks/chunk-KNBAYU5I.mjs";
+import "./chunks/chunk-TSAEK5P3.mjs";
+import "./chunks/chunk-VZXGRZYU.mjs";
+import {
+  VIEW_WORKSPACE_PAGE_LOST_CODE,
+  VIEW_WORKSPACE_TARGET_RECOVERY_CODES,
+  adoptRemoteWorkspaceProject,
+  isWorkspacePageLostError,
+  isWorkspaceTargetRecoveryCode,
+  navigateToWorkspaceProjectTarget,
+  reopenWorkspaceProject,
+  resolveWorkspaceFailure,
+  resolveWorkspaceFailureCode,
+  resolveWorkspaceReopenRoot,
+  shouldAdoptRemoteWorkspaceProject,
+  shouldOfferWorkspaceRecovery,
+  workspaceProjectTargetUrl
+} from "./chunks/chunk-VDZJWEAA.mjs";
+import "./chunks/chunk-EJGBVKFE.mjs";
+import "./chunks/chunk-D7GWRZLL.mjs";
+import "./chunks/chunk-NBLGKTEM.mjs";
+import "./chunks/chunk-YYXQDUVT.mjs";
+import "./chunks/chunk-LERMYZRC.mjs";
+import "./chunks/chunk-ALT7XVMQ.mjs";
+import "./chunks/chunk-SSQMQJ52.mjs";
+import "./chunks/chunk-C7R3YRA7.mjs";
+import {
+  ViewWorkspaceClient,
+  createViewWorkspaceClient,
+  workspaceBrowserEndpoint
+} from "./chunks/chunk-VY3S5BWI.mjs";
+import "./chunks/chunk-FMCACPX5.mjs";
+import "./chunks/chunk-FKCQYDLX.mjs";
+import "./chunks/chunk-2IJKOG2F.mjs";
+import "./chunks/chunk-ASI2HBE6.mjs";
+import "./chunks/chunk-RR6L6VVR.mjs";
+import "./chunks/chunk-46O5WX43.mjs";
+import "./chunks/chunk-FJM6WWIY.mjs";
+import {
+  VIEW_DISPLAY_TAB_ID,
+  VIEW_FILE_GET_SERVICE,
+  VIEW_PAGE_TYPES,
+  VIEW_WORKSPACE_API_VERSION,
+  VIEW_WORKSPACE_COOK_MODES,
+  VIEW_WORKSPACE_CORE_OPERATIONS,
+  VIEW_WORKSPACE_DOMAIN_OPERATIONS,
+  VIEW_WORKSPACE_OPERATIONS,
+  VIEW_WORKSPACE_SERVICES,
+  VIEW_WORKSPACE_STATE_TOPIC,
+  VIEW_WORKSPACE_TAB_ID,
+  ViewWorkspaceError,
+  assertWorkspaceRequest,
+  cloneWorkspaceValue,
+  createWorkspaceRequest,
+  isOpaqueWorkspaceDiagnostic,
+  jsonUnchanged,
+  requireWorkspaceInteger,
+  requireWorkspaceObject,
+  requireWorkspaceString,
+  serializeWorkspaceAsset,
+  serializeWorkspaceDdc,
+  serializeWorkspaceInspection,
+  serializeWorkspaceOpenRequest,
+  serializeWorkspaceProject,
+  serializeWorkspaceResourceOpens,
+  serializeWorkspaceState,
+  serializeWorkspaceTarget,
+  workspaceCapabilities,
+  workspaceError,
+  workspaceInspectionFactRows,
+  workspaceUiFingerprint
+} from "./chunks/chunk-32GD5LL6.mjs";
+import {
+  createWorkspaceId
+} from "./chunks/chunk-TP26TASL.mjs";
+import "./chunks/chunk-ZLNWF4ET.mjs";
+import {
+  VIEW_ENGINE_CARRIER_CONTRACT,
+  ViewCarrierAdapter,
+  createViewCarrierAdapter
+} from "./chunks/chunk-CUH2G6UF.mjs";
+import {
+  BROWSER_CARRIER,
+  FALLBACK_REASONS,
+  GPU_MODES,
+  VIEW_CARRIER,
+  VIEW_PROTOCOL,
+  VIEW_PROTOCOL_VERSION,
+  assertLeaseTarget,
+  browserFallback,
+  createLeaseRequest,
+  createRunIdentity,
+  deserializeRequest,
+  isFallbackDecision,
+  normalizeRunIdentity,
+  sameRun,
+  serializeTarget,
+  viewDecision
+} from "./chunks/chunk-GQBZMCTK.mjs";
+import "./chunks/chunk-FLGC65SR.mjs";
+
+// src/platform/browser-page.mjs
+var BrowserPagePlatform = class {
+  constructor({
+    page,
+    targetId = "view-browser-page",
+    kind = "browser-page",
+    capabilities = {}
+  } = {}) {
+    assertPage(page);
+    if (typeof targetId !== "string" || targetId.length === 0) {
+      throw new TypeError("browser page targetId must be a non-empty string");
+    }
+    if (typeof kind !== "string" || kind.length === 0) {
+      throw new TypeError("browser page kind must be a non-empty string");
+    }
+    this.page = page;
+    this.targetId = targetId;
+    this.kind = kind;
+    this.capabilityOverrides = { ...capabilities };
+    this.active = null;
+    this.disposed = false;
+  }
+  getCapabilities() {
+    const ready = !this.disposed && !pageIsClosed(this.page);
+    return {
+      // `auto` is the only honest default. An embedding browser owner may
+      // add hardware/software after it has probed the actual adapter.
+      maxWidth: 8192,
+      maxHeight: 8192,
+      canvasSizing: "fixed",
+      ...this.capabilityOverrides,
+      ready: ready && (this.capabilityOverrides.ready ?? true),
+      supportsPage: ready && (this.capabilityOverrides.supportsPage ?? true),
+      gpuModes: [...this.capabilityOverrides.gpuModes ?? ["auto"]]
+    };
+  }
+  async createPage({ leaseId, generation, width, height, signal, onLost } = {}) {
+    if (typeof leaseId !== "string" || leaseId.length === 0) {
+      throw new TypeError("browser page leaseId must be a non-empty string");
+    }
+    if (!Number.isSafeInteger(generation) || generation < 0) {
+      throw new TypeError("browser page generation must be a non-negative safe integer");
+    }
+    assertDimension(width, "width");
+    assertDimension(height, "height");
+    throwIfAborted(signal);
+    if (this.disposed || pageIsClosed(this.page)) {
+      throw Object.assign(new Error("the supplied browser page is no longer available"), {
+        fallbackReason: "view-target-lost"
+      });
+    }
+    if (this.active !== null) {
+      throw Object.assign(new Error("the supplied browser page is already leased"), {
+        fallbackReason: "view-occupied"
+      });
+    }
+    const surfaceId = "forgeax-view-display-surface";
+    const surfaceSelector = `#${surfaceId}`;
+    try {
+      await this.page.waitForFunction(
+        (id) => document.getElementById(id)?.tagName === "IFRAME",
+        surfaceId,
+        { timeout: 15e3 }
+      );
+      await this.page.evaluate(({ surfaceId: surfaceId2, leaseId: leaseId2, generation: generation2, targetId }) => {
+        const surface = document.getElementById(surfaceId2);
+        if (!surface || surface.tagName !== "IFRAME") {
+          throw new Error(`the display Frontend Fiber iframe is unavailable: ${surfaceId2}`);
+        }
+        if (surface.name !== surfaceId2) {
+          throw new Error(`the display Frontend Fiber iframe has an invalid name: ${surface.name}`);
+        }
+        surface.dataset.forgeaxViewSurface = "engine-target";
+        surface.dataset.forgeaxViewTargetId = String(targetId);
+        surface.dataset.forgeaxViewLeaseId = String(leaseId2);
+        surface.dataset.forgeaxViewGeneration = String(generation2);
+        surface.setAttribute("aria-hidden", "true");
+        surface.style.display = "block";
+        surface.style.visibility = "hidden";
+        surface.style.pointerEvents = "none";
+        surface.style.border = "0";
+        surface.style.width = "100%";
+        surface.style.height = "100%";
+      }, { surfaceId, leaseId, generation, targetId: this.targetId });
+      let frame = this.page.frame({ name: surfaceId });
+      if (!frame) {
+        await this.page.waitForFunction(
+          (id) => document.getElementById(id)?.tagName === "IFRAME",
+          surfaceId,
+          { timeout: 15e3 }
+        );
+        frame = this.page.frame({ name: surfaceId });
+      }
+      if (!frame) {
+        throw Object.assign(
+          new Error("the allocated display iframe did not expose its execution frame"),
+          { fallbackReason: "view-target-lost" }
+        );
+      }
+      const resource = {
+        leaseId,
+        generation,
+        targetId: this.targetId,
+        kind: this.kind,
+        surfaceId,
+        page: this.page,
+        execution: {
+          kind: "frame",
+          ownerPage: this.page,
+          realm: frame,
+          surfaceSelector
+        },
+        requestedCanvasSize: Object.freeze({ width, height }),
+        dispose: async () => {
+          if (this.active !== resource) return;
+          this.detachPageListeners(resource);
+          if (typeof frame.goto === "function") await frame.goto("about:blank").catch(() => {
+          });
+          await this.page.evaluate((id) => {
+            const surface = document.getElementById(id);
+            if (!surface) return;
+            delete surface.dataset.forgeaxViewTargetId;
+            delete surface.dataset.forgeaxViewLeaseId;
+            delete surface.dataset.forgeaxViewGeneration;
+            surface.style.visibility = "hidden";
+            surface.style.pointerEvents = "none";
+          }, surfaceId).catch(() => {
+          });
+          if (this.active === resource) this.active = null;
+        }
+      };
+      const onClose = () => {
+        if (this.active !== resource) return;
+        this.detachPageListeners(resource);
+        this.active = null;
+        onLost?.("browser-page-closed");
+      };
+      const onFrameDetached = (detachedFrame) => {
+        if (this.active !== resource || detachedFrame !== frame) return;
+        this.detachPageListeners(resource);
+        this.active = null;
+        onLost?.("browser-frame-detached");
+      };
+      resource.onClose = onClose;
+      resource.onFrameDetached = onFrameDetached;
+      this.active = resource;
+      this.attachPageListeners(resource);
+      if (signal?.aborted) {
+        await resource.dispose();
+        throwIfAborted(signal);
+      }
+      return resource;
+    } catch (error) {
+      throw error;
+    }
+  }
+  detachPageListeners(resource) {
+    if (typeof this.page.off !== "function") return;
+    const listener = resource.onClose;
+    if (listener === void 0) return;
+    this.page.off("close", listener);
+    this.page.off("crash", listener);
+    if (resource.onFrameDetached !== void 0) this.page.off("framedetached", resource.onFrameDetached);
+  }
+  attachPageListeners(resource) {
+    if (typeof this.page.on !== "function") return;
+    this.page.on("close", resource.onClose);
+    this.page.on("crash", resource.onClose);
+    if (resource.onFrameDetached !== void 0) this.page.on("framedetached", resource.onFrameDetached);
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    const active = this.active;
+    if (active !== null) await active.dispose();
+  }
+};
+function assertPage(page) {
+  if (!page || typeof page !== "object") throw new TypeError("an existing browser page is required");
+  if (typeof page.goto !== "function" || typeof page.evaluate !== "function" || typeof page.locator !== "function" || typeof page.frame !== "function" || typeof page.waitForFunction !== "function" || typeof page.waitForTimeout !== "function") {
+    throw new TypeError(
+      "the supplied browser page must provide goto, evaluate, locator, frame, waitForFunction, and waitForTimeout"
+    );
+  }
+}
+function pageIsClosed(page) {
+  return typeof page.isClosed === "function" && page.isClosed();
+}
+function assertDimension(value, field) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`${field} must be a positive safe integer`);
+  }
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = signal.reason ?? new Error("browser page allocation was cancelled");
+  if (error instanceof Error && error.name === "AbortError") throw error;
+  if (error instanceof Error) {
+    error.name = "AbortError";
+    throw error;
+  }
+  throw Object.assign(new Error("browser page allocation was cancelled"), {
+    name: "AbortError",
+    cause: error
+  });
+}
+function createBrowserPagePlatform(options) {
+  return new BrowserPagePlatform(options);
+}
+
+// src/platform/resource-browser.mjs
+var ResourceBrowserPlatform = class {
+  constructor({ targetId = "view-resource-browser" } = {}) {
+    if (typeof targetId !== "string" || targetId.length === 0) {
+      throw new TypeError("resource browser targetId must be a non-empty string");
+    }
+    this.targetId = targetId;
+    this.disposed = false;
+  }
+  getCapabilities() {
+    return Object.freeze({
+      ready: !this.disposed,
+      supportsPage: false,
+      resourceBrowser: true,
+      gpuModes: [],
+      maxWidth: 0,
+      maxHeight: 0,
+      canvasSizing: "none"
+    });
+  }
+  async createPage() {
+    throw Object.assign(new Error("the resource-browser host cannot allocate an Engine preview page"), {
+      fallbackReason: "view-resource-browser"
+    });
+  }
+  async dispose() {
+    this.disposed = true;
+  }
+};
+function createResourceBrowserPlatform(options) {
+  return new ResourceBrowserPlatform(options);
+}
+
+// src/bootstrap.mjs
+import { createFrontendHost } from "@forgeax/engine-host";
+async function startView(options = {}) {
+  const backend = await createViewBackend({
+    platform: options.platform,
+    capabilities: options.capabilities,
+    frontendConfig: options.frontendConfig,
+    disabledPages: options.disabledPages,
+    workspaceEngine: options.workspaceEngine,
+    workspaceAccessToken: options.workspaceAccessToken,
+    workspaceAuthorize: options.workspaceAuthorize,
+    engineHost: options.backendHost,
+    workspacePlugin: options.workspacePlugin,
+    workspaceOptions: options.workspaceOptions,
+    onActivationReport: options.onActivationReport,
+    workspaceServer: options.workspaceServer,
+    workspaceHost: options.workspaceHost,
+    workspacePort: options.workspacePort,
+    workspacePath: options.workspacePath,
+    staticRoot: options.staticRoot
+  });
+  const suppliedFrontendHost = options.frontendHost;
+  const createFrontend = options.frontend === true && suppliedFrontendHost === void 0;
+  const transport = createFrontend ? backend.backendHost.transport.connect({ kind: "frontend", sourceId: "view-frontend" }) : void 0;
+  if (transport && options.backendHost) {
+    backend.backendHost.bindProjection(transport.caller, { assembly: backend.hostBinding.frontendAssembly });
+  }
+  let frontendHost = suppliedFrontendHost;
+  let ownsFrontendHost = false;
+  try {
+    if (createFrontend) {
+      const { resolveViewFrontendRoot } = await import("./viewer-host/frontend.mjs");
+      frontendHost = await createFrontendHost({
+        context: options.frontendContext,
+        transport,
+        resolveRoot: (root) => resolveViewFrontendRoot(root, options.frontendConfig),
+        autoActivate: true
+      });
+      ownsFrontendHost = true;
+    }
+    return Object.freeze({
+      ...backend,
+      ...backend.workspaceFrontendEndpoint ? {
+        // A browser embedding needs the paired, server-issued frontend
+        // ticket; the CLI adapter strips that query before connecting.
+        workspaceEndpoint: backend.workspaceFrontendEndpoint,
+        workspaceUrl: backend.workspaceFrontendUrl
+      } : {},
+      frontendHost,
+      async dispose() {
+        if (ownsFrontendHost) await frontendHost.dispose();
+        transport?.close();
+        await backend.dispose();
+      }
+    });
+  } catch (error) {
+    transport?.close();
+    await backend.dispose().catch(() => {
+    });
+    throw error;
+  }
+}
+
+// src/viewer-static-server.mjs
+import { createReadStream, existsSync, statSync } from "node:fs";
+import { join, normalize } from "node:path";
+import { createServer } from "node:http";
+var VIEWER_BOOTSTRAP_PATH = "/__forgeax/view/bootstrap";
+var STATIC_MIME = Object.freeze({
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".json": "application/json; charset=utf-8"
+});
+function staticContentType(filePath) {
+  const index = filePath.lastIndexOf(".");
+  if (index === -1) return "application/octet-stream";
+  return STATIC_MIME[filePath.slice(index)] ?? "application/octet-stream";
+}
+function resolveStaticFile(root, requestPath) {
+  const relative = normalize(requestPath).replace(/^(\.\.(\/|\\|$))+/, "");
+  const absolute = join(root, relative);
+  if (!absolute.startsWith(root)) return void 0;
+  return absolute;
+}
+function createViewerBootstrapPayload(env = process.env) {
+  if (env.FORGEAX_VIEW_BOOTSTRAP_CONFIGURED !== "1") {
+    const reason = env.FORGEAX_VIEW_BOOTSTRAP_REASON?.trim() || "View workspace backend is not configured. Run forgeax backend start, then forgeax view start.";
+    return Object.freeze({ configured: false, reason });
+  }
+  const token = env.FORGEAX_VIEW_WORKSPACE_TOKEN?.trim();
+  const frontendEndpoint = env.FORGEAX_VIEW_FRONTEND_ENDPOINT?.trim();
+  const endpoint = env.FORGEAX_VIEW_WORKSPACE_ENDPOINT?.trim();
+  const frontendTicket = env.FORGEAX_VIEW_FRONTEND_TICKET?.trim();
+  if (!token || !frontendEndpoint) {
+    return Object.freeze({
+      configured: false,
+      reason: "View workspace bootstrap env is incomplete."
+    });
+  }
+  return Object.freeze({
+    configured: true,
+    token,
+    endpoint,
+    frontendEndpoint,
+    ...frontendTicket === void 0 ? {} : { frontendTicket }
+  });
+}
+async function startViewerStaticServer({
+  host = "127.0.0.1",
+  port = 0,
+  staticRoot,
+  env = process.env
+} = {}) {
+  if (!staticRoot || typeof staticRoot !== "string") {
+    throw new TypeError("viewer static server requires staticRoot");
+  }
+  const http = createServer((request, response) => {
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    if (url.pathname === VIEWER_BOOTSTRAP_PATH) {
+      response.statusCode = 200;
+      response.setHeader("Content-Type", "application/json; charset=utf-8");
+      response.setHeader("Cache-Control", "no-store");
+      response.end(JSON.stringify(createViewerBootstrapPayload(env)));
+      return;
+    }
+    let filePath = resolveStaticFile(staticRoot, url.pathname === "/" ? "/index.html" : url.pathname);
+    if (filePath && existsSync(filePath) && statSync(filePath).isFile()) {
+      response.statusCode = 200;
+      response.setHeader("Content-Type", staticContentType(filePath));
+      createReadStream(filePath).pipe(response);
+      return;
+    }
+    const spa = resolveStaticFile(staticRoot, "/index.html");
+    if (spa && existsSync(spa)) {
+      response.statusCode = 200;
+      response.setHeader("Content-Type", "text/html; charset=utf-8");
+      createReadStream(spa).pipe(response);
+      return;
+    }
+    response.statusCode = 404;
+    response.end("Not found");
+  });
+  await new Promise((resolveListen, rejectListen) => {
+    const onError = (error) => {
+      http.off("listening", onListening);
+      rejectListen(error);
+    };
+    const onListening = () => {
+      http.off("error", onError);
+      resolveListen();
+    };
+    http.once("error", onError);
+    http.once("listening", onListening);
+    http.listen(port, host);
+  });
+  const address = http.address();
+  const selectedPort = typeof address === "object" && address !== null ? address.port : port;
+  const loopbackHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+  const viewerUrl = `http://${loopbackHost}:${selectedPort}/`;
+  const close = async () => {
+    await new Promise((resolveClose) => {
+      if (!http.listening) return resolveClose();
+      http.close(() => resolveClose());
+    });
+  };
+  return Object.freeze({
+    host: loopbackHost,
+    port: selectedPort,
+    viewerUrl,
+    bootstrapUrl: `${viewerUrl.replace(/\/$/, "")}${VIEWER_BOOTSTRAP_PATH}`,
+    server: http,
+    close
+  });
+}
+export {
+  BROWSER_CARRIER,
+  BrowserPagePlatform,
+  DEFAULT_CAPABILITIES,
+  FALLBACK_REASONS,
+  FORGEAX_VIEW_PLUGIN_ID,
+  FORGEAX_VIEW_PLUGIN_MODULE,
+  GPU_MODES,
+  ResourceBrowserPlatform,
+  VIEW_CARRIER,
+  VIEW_CLI_CONTRIBUTION_ID,
+  DISPLAY_SURFACE_ID as VIEW_DISPLAY_SURFACE_ID,
+  VIEW_DISPLAY_TAB_ID,
+  VIEW_ENGINE_ASSET_SOURCE_TOOLS,
+  VIEW_ENGINE_CARRIER_CONTRACT,
+  VIEW_ENGINE_WORKSPACE_ADAPTER,
+  VIEW_FILE_GET_SERVICE,
+  VIEW_INSPECTOR_API_VERSION,
+  VIEW_INSPECTOR_OPERATIONS,
+  VIEW_INSPECTOR_SERVICES,
+  VIEW_INSPECTOR_TOPIC,
+  VIEW_PAGE_TYPES,
+  VIEW_PROTOCOL,
+  VIEW_PROTOCOL_VERSION,
+  VIEW_STATUS_OPERATION,
+  VIEW_STATUS_SERVICE,
+  VIEW_STATUS_TOPIC,
+  VIEW_WORKSPACE_API_VERSION,
+  VIEW_WORKSPACE_COOK_MODES,
+  VIEW_WORKSPACE_CORE_OPERATIONS,
+  VIEW_WORKSPACE_DOMAIN_OPERATIONS,
+  DEFAULT_PATH as VIEW_WORKSPACE_HOST_PATH,
+  VIEW_WORKSPACE_OPERATIONS,
+  VIEW_WORKSPACE_PAGE_LOST_CODE,
+  VIEW_WORKSPACE_SERVICES,
+  VIEW_WORKSPACE_STATE_TOPIC,
+  VIEW_WORKSPACE_TAB_ID,
+  VIEW_WORKSPACE_TARGET_RECOVERY_CODES,
+  ViewCarrierAdapter,
+  ViewDisplayStatus,
+  ViewInspectorBroker,
+  ViewInspectorClient,
+  ViewInspectorPanel,
+  ViewResourceBroker,
+  ViewWorkspaceBroker,
+  ViewWorkspaceClient,
+  ViewWorkspaceError,
+  ViewWorkspaceInputController,
+  ViewWorkspaceShell,
+  adoptRemoteWorkspaceProject,
+  assertLeaseTarget,
+  assertWorkspaceRequest,
+  browserFallback,
+  cloneWorkspaceValue,
+  connectViewFrontend,
+  connectViewWorkspace,
+  createBrowserPagePlatform,
+  createBrowserPagePresentation,
+  createEngineWorkspaceAdapter,
+  createInspectorRequest,
+  createLeaseRequest,
+  createResourceBrowserPlatform,
+  createRunIdentity,
+  createViewBackend,
+  createViewCarrierAdapter,
+  createViewCliContributions,
+  createViewHostBinding,
+  createViewHostCliContributions,
+  createViewInspectorToolContributions,
+  createViewPlatformBinding,
+  createViewProductPlan,
+  createViewStatusToolContributions,
+  createViewWorkspaceClient,
+  createViewWorkspaceToolContributions,
+  createWorkspaceId,
+  createWorkspaceRequest,
+  deserializeRequest,
+  disposeResource,
+  product_default as forgeaxViewPlugin,
+  isEngineWorkspaceAdapter,
+  isFallbackDecision,
+  isOpaqueWorkspaceDiagnostic,
+  isViewportWorkspaceInputEvent,
+  isWorkspacePageLostError,
+  isWorkspaceTargetRecoveryCode,
+  jsonUnchanged,
+  mountViewViewer,
+  mountViewWorkspace,
+  navigateToWorkspaceProjectTarget,
+  normalizeRunIdentity,
+  reopenWorkspaceProject,
+  requireWorkspaceInteger,
+  requireWorkspaceObject,
+  requireWorkspaceString,
+  resolveWorkspaceFailure,
+  resolveWorkspaceFailureCode,
+  resolveWorkspaceReopenRoot,
+  runInspectorToolApi,
+  runViewStartInteractive,
+  runViewToolApi,
+  runViewWorkspaceCli,
+  runWorkspaceToolApi,
+  safeDetail,
+  safeError,
+  sameRun,
+  serializeTarget,
+  serializeWorkspaceAsset,
+  serializeWorkspaceDdc,
+  serializeWorkspaceInspection,
+  serializeWorkspaceOpenRequest,
+  serializeWorkspaceProject,
+  serializeWorkspaceResourceOpens,
+  serializeWorkspaceState,
+  serializeWorkspaceTarget,
+  shouldAdoptRemoteWorkspaceProject,
+  shouldOfferWorkspaceRecovery,
+  startView,
+  startViewHostServer,
+  startViewerStaticServer,
+  viewDecision,
+  frontend_default as viewDisplayFrontendPlugin,
+  viewFrontendRoot,
+  viewInspectorBackendPlugin,
+  viewInspectorFrontendPlugin,
+  workspaceBrowserEndpoint,
+  workspaceCapabilities,
+  workspaceError,
+  workspaceInspectionFactRows,
+  workspaceProjectTargetUrl,
+  workspaceUiFingerprint
+};
+//# sourceMappingURL=index.mjs.map