@forgeax/view 0.2.1-beta-20260924075842

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

@@ -0,0 +1,1400 @@
+import {
+  PLUGINS_OPERATION_DESCRIPTIONS
+} from "./chunk-IGRMZYRD.mjs";
+import {
+  BACKEND_MODULE,
+  BACKEND_PLUGIN_ID
+} from "./chunk-VZXGRZYU.mjs";
+import {
+  reportWorkspaceCommandError
+} from "./chunk-ASI2HBE6.mjs";
+import {
+  VIEW_WORKSPACE_API_VERSION,
+  VIEW_WORKSPACE_DOMAIN_OPERATIONS,
+  ViewWorkspaceError,
+  cloneWorkspaceValue,
+  jsonUnchanged,
+  requireWorkspaceObject,
+  requireWorkspaceString,
+  workspaceError
+} from "./chunk-32GD5LL6.mjs";
+import {
+  createWorkspaceId
+} from "./chunk-TP26TASL.mjs";
+
+// packages/view-plugin-plugins/src/runtime.mjs
+import { defineTool } from "@forgeax/engine-tool-runtime";
+import { inspectPluginFiber, registerTools } from "@forgeax/engine-plugin";
+var VIEW_INSPECTOR_API_VERSION = "forgeax.view.inspector/1";
+var VIEW_INSPECTOR_SERVICES = Object.freeze({
+  sources: "forgeax.view.inspector.sources",
+  inspect: "forgeax.view.inspector.inspect",
+  watch: "forgeax.view.inspector.watch",
+  unwatch: "forgeax.view.inspector.unwatch",
+  report: "forgeax.view.inspector.report"
+});
+var VIEW_INSPECTOR_TOPIC = "forgeax.view.inspector.changed";
+var VIEW_STATUS_OPERATION = "view.status";
+var VIEW_INSPECTOR_OPERATIONS = Object.freeze(
+  PLUGINS_OPERATION_DESCRIPTIONS.map((description) => description.id)
+);
+var VIEW_INSPECTOR_INTERNAL_OPERATIONS = Object.freeze(["plugins.report", "plugins.unwatch"]);
+var INSPECTOR_OPERATION_SET = /* @__PURE__ */ new Set([
+  ...VIEW_INSPECTOR_OPERATIONS,
+  ...VIEW_INSPECTOR_INTERNAL_OPERATIONS
+]);
+var WORKSPACE_OPERATION_SET = new Set(VIEW_WORKSPACE_DOMAIN_OPERATIONS);
+var MAX_TEXT = 512;
+var SAFE_ERROR_FIELDS = /* @__PURE__ */ new Set([
+  "actual",
+  "actualGeneration",
+  "expectedGeneration",
+  "fiberState",
+  "generation",
+  "module",
+  "operation",
+  "phase",
+  "providerId",
+  "reason",
+  "remoteCode",
+  "runId",
+  "service",
+  "sourceId",
+  "watchId"
+]);
+function redactCredentials(value) {
+  return value.replace(/([a-z][a-z\d+.-]*:\/\/)([^\s/?#]+)@/gi, "$1[redacted]@").replace(
+    /\b(authorization|proxy-authorization)\b\s*([:=])\s*(?:(?:bearer|basic)\s+)?[^\s,;)}\]]+/gi,
+    (_match, key, separator) => `${key}${separator}[redacted]`
+  ).replace(/\b(bearer|basic)\s+[a-z\d._~+\/-]+=*/gi, "$1 [redacted]").replace(
+    /([?&](?:token|password|passwd|secret|authorization|api[-_]?key|access[-_]?token)=)[^&#\s,;)}\]]+/gi,
+    "$1[redacted]"
+  ).replace(
+    /\b(token|password|passwd|secret|authorization|api[-_]?key|access[-_]?token)\b\s*([:=])\s*("[^"]*"|'[^']*'|\[[^\]]*\]|[^\s,;)}\]]+)/gi,
+    (_match, key, separator) => `${key}${separator}[redacted]`
+  ).replace(/\b(secret|password|passwd|token)(?:[-_][a-z\d][a-z\d_.-]*)?\b/gi, "[redacted]").replace(/\b(secret|password|passwd|token|api[-_]?key|access[-_]?token)[-_][a-z\d][a-z\d_.-]*\b/gi, "[redacted]");
+}
+function safeText(value, fallback = "unknown") {
+  const text = typeof value === "string" ? value : value === void 0 ? fallback : String(value);
+  const redacted = redactCredentials(text);
+  return redacted.length > MAX_TEXT ? `${redacted.slice(0, MAX_TEXT)}...` : redacted;
+}
+function safeStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.filter((entry) => typeof entry === "string").slice(0, 64).map((entry) => safeText(entry));
+}
+function safeClone(value) {
+  try {
+    return cloneWorkspaceValue(value);
+  } catch {
+    return null;
+  }
+}
+function safeDetail(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!SAFE_ERROR_FIELDS.has(key)) continue;
+    if (typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean" || entry === null) {
+      result[key] = typeof entry === "string" ? safeText(entry) : entry;
+    } else if (Array.isArray(entry) && entry.every((item) => typeof item === "string")) {
+      result[key] = entry.map((item) => safeText(item));
+    }
+  }
+  return Object.keys(result).length === 0 ? void 0 : result;
+}
+function safeError(error) {
+  if (error === void 0 || error === null) return void 0;
+  const detail = error?.detail;
+  const safe = safeDetail(detail);
+  return {
+    code: safeText(error?.code, "unknown-error"),
+    expected: safeText(error?.expected),
+    hint: safeText(error?.hint),
+    ...safe === void 0 ? {} : { detail: safe }
+  };
+}
+function safeSchema(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const allowed = /* @__PURE__ */ new Set([
+    "additionalProperties",
+    "const",
+    "description",
+    "enum",
+    "items",
+    "maximum",
+    "minimum",
+    "properties",
+    "required",
+    "type"
+  ]);
+  const project = (schema) => {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema)) return void 0;
+    const result = {};
+    for (const [key, entry] of Object.entries(schema)) {
+      if (!allowed.has(key)) continue;
+      if (key === "properties" && entry && typeof entry === "object" && !Array.isArray(entry)) {
+        result.properties = Object.fromEntries(
+          Object.entries(entry).map(([name, child]) => [name, project(child)]).filter(([, child]) => child !== void 0)
+        );
+        continue;
+      }
+      if (key === "items") {
+        const child = project(entry);
+        if (child !== void 0) result.items = child;
+        continue;
+      }
+      if (key === "description") result.description = safeText(entry, "");
+      else if (Array.isArray(entry)) result[key] = entry.filter((item) => typeof item === "string").map(safeText);
+      else if (typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean") result[key] = entry;
+    }
+    return result;
+  };
+  return project(value);
+}
+function safeOwner(owner) {
+  if (!owner || typeof owner !== "object") return null;
+  return {
+    providerId: safeText(owner.providerId),
+    sourceId: safeText(owner.sourceId),
+    generation: Number.isSafeInteger(owner.generation) ? owner.generation : null,
+    realm: safeText(owner.realm),
+    ...owner.fiberId === void 0 ? {} : { fiberId: safeText(owner.fiberId) },
+    ...owner.module === void 0 ? {} : { module: safeText(owner.module) }
+  };
+}
+function safeToolDescriptor(descriptor) {
+  if (!descriptor || typeof descriptor !== "object") return null;
+  return {
+    id: safeText(descriptor.id),
+    path: Array.isArray(descriptor.path) ? descriptor.path.filter((value) => typeof value === "string").map((value) => safeText(value)) : safeText(descriptor.id).split("."),
+    title: safeText(descriptor.title),
+    summary: safeText(descriptor.summary),
+    realm: safeText(descriptor.realm),
+    evidence: Array.isArray(descriptor.evidence) ? descriptor.evidence.filter((value) => typeof value === "string").map((value) => safeText(value)) : [],
+    ...descriptor.inputSchema === void 0 ? {} : { inputSchema: safeSchema(descriptor.inputSchema) },
+    ...descriptor.outputSchema === void 0 ? {} : { outputSchema: safeSchema(descriptor.outputSchema) },
+    ...Array.isArray(descriptor.capabilities) ? { capabilities: descriptor.capabilities.map((value) => safeText(value)) } : {},
+    ...Array.isArray(descriptor.errors) ? { errors: descriptor.errors.map((value) => safeText(value)) } : {}
+  };
+}
+function safePluginEntry(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const desiredState = entry.desiredState === "disabled" || entry.disabled === true ? "disabled" : "enabled";
+  const state = typeof (entry.fiberState ?? entry.state) === "string" && ["pending", "loading", "active", "failed", "disposed", "disabled", "unloading", "unknown"].includes(
+    entry.fiberState ?? entry.state
+  ) ? entry.fiberState ?? entry.state : void 0;
+  const origin = entry.origin && typeof entry.origin === "object" ? entry.origin : void 0;
+  return {
+    entryId: safeText(entry.entryId ?? entry.id ?? (entry.uid == null ? void 0 : `fiber:${entry.uid}`)),
+    module: safeText(entry.module ?? entry.name),
+    realm: safeText(entry.realm),
+    desiredState,
+    ...(origin?.guid ?? entry.assetGuid) === void 0 ? {} : { assetGuid: safeText(origin?.guid ?? entry.assetGuid) },
+    ...(origin?.program ?? entry.program) === void 0 ? {} : { program: safeText(origin?.program ?? entry.program) },
+    ...entry.fiberId === void 0 ? {} : { fiberId: safeText(entry.fiberId) },
+    ...entry.parent === void 0 ? {} : { parent: safeText(entry.parent) },
+    ...safeStringArray(entry.requiredServices) === void 0 ? {} : { requiredServices: safeStringArray(entry.requiredServices) },
+    ...safeStringArray(entry.providedServices) === void 0 ? {} : { providedServices: safeStringArray(entry.providedServices) },
+    ...safeStringArray(entry.missingServices) === void 0 ? {} : { missingServices: safeStringArray(entry.missingServices) },
+    ...entry.configDigest === void 0 ? {} : { configDigest: safeText(entry.configDigest) },
+    ...state === void 0 ? {} : { fiberState: state },
+    ...entry.failure === void 0 ? {} : { failure: safeError(entry.failure) }
+  };
+}
+function safeToolSnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== "object") {
+    return { providers: [], operations: [], state: "unavailable" };
+  }
+  return {
+    providers: Array.isArray(snapshot.providers) ? snapshot.providers.map((provider) => ({
+      owner: safeOwner(provider.owner),
+      state: safeText(provider.state),
+      callable: provider.callable === true,
+      ...provider.fiberState === void 0 ? {} : { fiberState: safeText(provider.fiberState) },
+      operationIds: Array.isArray(provider.operationIds) ? provider.operationIds.map((value) => safeText(value)) : []
+    })) : [],
+    operations: Array.isArray(snapshot.operations) ? snapshot.operations.map((operation) => ({
+      descriptor: safeToolDescriptor(operation.descriptor),
+      owner: safeOwner(operation.owner),
+      providerState: safeText(operation.providerState),
+      declared: operation.declared === true,
+      callable: operation.callable === true,
+      ...operation.fiberState === void 0 ? {} : { fiberState: safeText(operation.fiberState) }
+    })) : []
+  };
+}
+function safeProviderPlugins(snapshot) {
+  if (!snapshot || !Array.isArray(snapshot.providers)) return [];
+  return snapshot.providers.map((provider) => {
+    const owner = provider?.owner;
+    if (!owner || typeof owner !== "object") return null;
+    return safePluginEntry({
+      entryId: `provider:${owner.sourceId ?? "unknown"}:${owner.providerId ?? "unknown"}`,
+      module: owner.module ?? "tool-provider",
+      realm: owner.realm,
+      fiberState: provider.fiberState ?? provider.state
+    });
+  }).filter((entry) => entry !== null);
+}
+function actualPluginEntries(status, snapshot, supplied = []) {
+  const entries = Array.isArray(status?.entries) ? status.entries.map(safePluginEntry).filter((entry) => entry !== null) : [];
+  const byId = new Map(entries.map((entry) => [entry.entryId, entry]));
+  for (const entry of safeProviderPlugins(snapshot)) byId.set(entry.entryId, entry);
+  for (const entry of supplied) {
+    const safe = safePluginEntry(entry);
+    if (safe !== null) byId.set(safe.entryId, safe);
+  }
+  return [...byId.values()];
+}
+function fiberStateName(state) {
+  return ["pending", "loading", "active", "failed", "disposed", "unloading"][state] ?? "unknown";
+}
+function safeAssembly(value) {
+  const assembly = value?.current ?? value;
+  if (!assembly || typeof assembly !== "object") return null;
+  return {
+    revision: safeText(assembly.revision),
+    schemaVersion: safeText(assembly.schemaVersion),
+    sessionGeneration: assembly.sessionGeneration,
+    root: assembly.root ? {
+      program: safeText(assembly.root.program),
+      codeRevision: safeText(assembly.root.codeRevision),
+      ...assembly.root.source === void 0 ? {} : { assetGuid: safeText(assembly.root.source) }
+    } : null
+  };
+}
+function safeActivationStatus(status) {
+  if (!status || typeof status !== "object") return { state: "unknown" };
+  const entries = Array.isArray(status.entries) ? status.entries.map((entry) => {
+    const safe = safePluginEntry(entry);
+    return {
+      entryId: safe?.entryId ?? safeText(entry.entryId ?? entry.id),
+      fiberState: safe?.fiberState ?? safeText(entry.fiberState),
+      ...safe?.parent === void 0 ? {} : { parent: safe.parent },
+      ...safe?.requiredServices === void 0 ? {} : { requiredServices: safe.requiredServices },
+      ...safe?.providedServices === void 0 ? {} : { providedServices: safe.providedServices },
+      ...safe?.configDigest === void 0 ? {} : { configDigest: safe.configDigest },
+      ...entry.failure === void 0 ? {} : { failure: safeError(entry.failure) }
+    };
+  }) : void 0;
+  return {
+    state: safeText(status.state),
+    revision: safeText(status.revision),
+    ...entries === void 0 ? {} : { entries: [...new Map(entries.map((entry) => [entry.entryId, entry])).values()] },
+    ...status.error === void 0 ? {} : { error: safeError(status.error) }
+  };
+}
+function sourceIdFor(caller) {
+  return `view-frontend:${safeText(caller?.connectionId, "unknown-connection")}`;
+}
+function assertInspectorRequest(value, expectedOperation) {
+  const request = requireWorkspaceObject(value, "request");
+  if (request.apiVersion !== VIEW_INSPECTOR_API_VERSION) {
+    throw workspaceError(
+      "view-inspector-version-mismatch",
+      `API version ${VIEW_INSPECTOR_API_VERSION}`,
+      "Install a matching View inspector client.",
+      { actual: request.apiVersion, expected: VIEW_INSPECTOR_API_VERSION }
+    );
+  }
+  if (!INSPECTOR_OPERATION_SET.has(request.operation) || request.operation !== expectedOperation) {
+    throw workspaceError(
+      "view-inspector-operation-unknown",
+      "operation to be present in the View inspector API",
+      "Refresh inspector capabilities and use a supported operation.",
+      { operation: request.operation }
+    );
+  }
+  requireWorkspaceString(request.clientId, "clientId");
+  requireWorkspaceString(request.requestId, "requestId");
+  requireWorkspaceObject(request.args, "args");
+  return request;
+}
+function createInspectorRequest(operation, args = {}, { clientId, token, requestId } = {}) {
+  if (!INSPECTOR_OPERATION_SET.has(operation)) {
+    throw workspaceError(
+      "view-inspector-operation-unknown",
+      "operation to be present in the View inspector API",
+      "Refresh inspector capabilities and use a supported operation.",
+      { operation }
+    );
+  }
+  const request = {
+    apiVersion: VIEW_INSPECTOR_API_VERSION,
+    operation,
+    clientId: requireWorkspaceString(clientId, "clientId"),
+    requestId: requestId === void 0 ? createWorkspaceId("inspector-request") : requireWorkspaceString(requestId, "requestId"),
+    args: requireWorkspaceObject(args, "args")
+  };
+  if (token !== void 0) request.token = requireWorkspaceString(token, "token");
+  return Object.freeze(request);
+}
+function decodeInspectorError(error) {
+  if (error instanceof ViewWorkspaceError) return error;
+  const remoteCode = typeof error?.detail?.remoteCode === "string" ? error.detail.remoteCode : void 0;
+  const code = [error?.code, remoteCode].find(
+    (candidate) => typeof candidate === "string" && candidate.startsWith("view-inspector-")
+  );
+  if (code === void 0) return error;
+  const message = typeof error?.message === "string" && error.message.trim() !== "" ? error.message : String(error);
+  return new ViewWorkspaceError(
+    code,
+    typeof error?.expected === "string" ? error.expected : message,
+    typeof error?.hint === "string" ? error.hint : message,
+    {
+      ...error?.detail && typeof error.detail === "object" ? error.detail : {},
+      ...remoteCode === void 0 ? {} : { remoteCode },
+      ...typeof error?.name === "string" ? { name: error.name } : {}
+    }
+  );
+}
+function toolFailureError(failure) {
+  const detail = failure?.detail;
+  const operationCode = [detail?.code, detail?.remoteCode].find(
+    (candidate) => typeof candidate === "string" && candidate.startsWith("view-")
+  );
+  const payload = detail?.payload ?? detail?.detail;
+  const diagnostic = [failure?.code, detail?.code, detail?.remoteCode].filter((value, index, values) => typeof value === "string" && values.indexOf(value) === index).join(" -> ");
+  const preservedHint = (typeof failure?.hint === "string" && failure.hint.trim() !== "" ? failure.hint : void 0) ?? (typeof failure?.expected === "string" && failure.expected.trim() !== "" ? failure.expected : void 0);
+  const hint = `${preservedHint ?? ""}${diagnostic ? `${preservedHint ? " " : ""}(provider: ${diagnostic})` : ""}`.trim();
+  if (operationCode !== void 0) {
+    return workspaceError(
+      operationCode,
+      typeof detail.expected === "string" ? detail.expected : failure.expected,
+      typeof detail.hint === "string" ? detail.hint : hint || preservedHint,
+      {
+        failure: safeError(failure) ?? { failure },
+        ...payload && typeof payload === "object" ? { cause: payload } : {}
+      }
+    );
+  }
+  return workspaceError(
+    "view-tool-provider-failed",
+    typeof failure?.expected === "string" ? safeText(failure.expected) : preservedHint,
+    hint || preservedHint,
+    { failure: safeError(failure) }
+  );
+}
+async function runWorkspaceToolApi(api, { operation, args, clientId, token, requestId, caller, signal, providerId, generation }) {
+  const run = api.run(
+    operation,
+    { args, clientId, token, requestId },
+    { sourceId: "view-backend", providerId, generation, caller, signal }
+  );
+  const terminal = await run.terminal;
+  if (terminal.outcome === "failed") throw toolFailureError(terminal.failure);
+  return terminal.result;
+}
+async function runInspectorToolApi(api, { operation, payload, caller, signal, providerId, generation }) {
+  const run = api.run(operation, payload, {
+    sourceId: "view-backend",
+    providerId,
+    generation,
+    caller,
+    signal
+  });
+  const terminal = await run.terminal;
+  if (terminal.outcome === "failed") throw toolFailureError(terminal.failure);
+  return terminal.result;
+}
+async function runViewToolApi(api, { operation, args = {}, caller, signal, providerId, generation }) {
+  const run = api.run(operation, args, {
+    sourceId: "view-backend",
+    providerId,
+    generation,
+    caller,
+    signal
+  });
+  const terminal = await run.terminal;
+  if (terminal.outcome === "failed") throw toolFailureError(terminal.failure);
+  return terminal.result;
+}
+function createViewWorkspaceToolContributions(workspace) {
+  const schema = {
+    parse(value) {
+      return value !== null && typeof value === "object" && !Array.isArray(value) ? { ok: true, value } : { ok: false, error: "workspace API arguments must be an object" };
+    },
+    describe: "JSON object accepted by the View workspace operation."
+  };
+  return VIEW_WORKSPACE_DOMAIN_OPERATIONS.filter((operation) => WORKSPACE_OPERATION_SET.has(operation)).map(
+    (operation) => defineTool(
+      {
+        id: operation,
+        path: operation.split("."),
+        title: operation,
+        summary: `View workspace operation ${operation}.`,
+        realm: "host",
+        argsSchema: schema,
+        resultSchema: schema,
+        inputSchema: { type: "object" },
+        outputSchema: { type: "object" },
+        evidence: []
+      },
+      async (envelope, context) => {
+        try {
+          const request = {
+            apiVersion: VIEW_WORKSPACE_API_VERSION,
+            operation,
+            clientId: envelope.clientId,
+            requestId: envelope.requestId,
+            args: envelope.args,
+            ...envelope.token === void 0 ? {} : { token: envelope.token }
+          };
+          return safeClone(await workspace.call(request, { signal: context.signal, caller: context.caller }));
+        } catch (error) {
+          if (error instanceof ViewWorkspaceError) {
+            return {
+              ok: false,
+              error: {
+                code: error.code,
+                expected: error.expected,
+                hint: error.hint,
+                detail: safeClone(error.detail)
+              }
+            };
+          }
+          throw error;
+        }
+      }
+    )
+  );
+}
+function inspectorRequestSchema(operation) {
+  return {
+    parse(value) {
+      try {
+        return { ok: true, value: assertInspectorRequest(value, operation) };
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+    describe: '{"type":"object","required":["apiVersion","operation","clientId","requestId","args"]}'
+  };
+}
+var inspectorResultSchema = {
+  parse(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? { ok: true, value } : { ok: false, error: "inspector result must be an object" };
+  },
+  describe: '{"type":"object"}'
+};
+function inspectorFailure(error) {
+  if (!(error instanceof ViewWorkspaceError)) throw error;
+  return {
+    ok: false,
+    error: {
+      code: error.code,
+      expected: error.expected,
+      hint: error.hint,
+      detail: safeDetail(error.detail)
+    }
+  };
+}
+function createViewInspectorToolContributions(broker) {
+  return [...VIEW_INSPECTOR_OPERATIONS, ...VIEW_INSPECTOR_INTERNAL_OPERATIONS].map(
+    (operation) => {
+      const description = PLUGINS_OPERATION_DESCRIPTIONS.find((entry) => entry.id === operation);
+      return defineTool(
+        {
+          id: operation,
+          path: description?.path ?? operation.split("."),
+          title: description?.title ?? `Inspect ${operation}`,
+          summary: description?.summary ?? `Internal View inspector operation ${operation}.`,
+          realm: "host",
+          argsSchema: inspectorRequestSchema(operation),
+          resultSchema: inspectorResultSchema,
+          inputSchema: { type: "object" },
+          outputSchema: { type: "object" },
+          evidence: []
+        },
+        async (request, context) => {
+          try {
+            const canonical = { ...request, caller: context.caller };
+            if (operation === "plugins.sources") {
+              return broker.sources(canonical);
+            }
+            if (operation === "plugins.inspect") return broker.inspect(canonical);
+            if (operation === "plugins.watch") return broker.watch(canonical);
+            if (operation === "plugins.unwatch") return broker.unwatch(canonical);
+            return await broker.report(canonical, context.caller);
+          } catch (error) {
+            return inspectorFailure(error);
+          }
+        }
+      );
+    }
+  );
+}
+function createViewStatusToolContributions(broker) {
+  const argsSchema = {
+    parse(value) {
+      return value === void 0 || value !== null && typeof value === "object" && !Array.isArray(value) ? { ok: true, value: value ?? {} } : { ok: false, error: "View status arguments must be an object" };
+    },
+    describe: "JSON object accepted by the read-only View status operation."
+  };
+  const resultSchema = {
+    parse(value) {
+      return value !== null && typeof value === "object" && !Array.isArray(value) ? { ok: true, value } : { ok: false, error: "View status result must be an object" };
+    },
+    describe: "JSON object returned by the View status operation."
+  };
+  return [
+    defineTool(
+      {
+        id: VIEW_STATUS_OPERATION,
+        path: VIEW_STATUS_OPERATION.split("."),
+        title: "View status",
+        summary: "Read the current View display and workspace status.",
+        realm: "host",
+        argsSchema,
+        resultSchema,
+        inputSchema: { type: "object" },
+        outputSchema: { type: "object" },
+        evidence: []
+      },
+      async () => broker.handshake()
+    )
+  ];
+}
+var ViewInspectorBroker = class {
+  constructor({ transport, accessToken, hostAssembly, toolApi, context } = {}) {
+    if (!transport || typeof transport.register !== "function") {
+      throw new TypeError("View inspector requires an Engine Host transport");
+    }
+    this.transport = transport;
+    this.accessToken = requireWorkspaceString(accessToken, "accessToken");
+    this.hostAssembly = hostAssembly;
+    this.toolApi = toolApi;
+    this.context = context;
+    this.reports = /* @__PURE__ */ new Map();
+    this.watches = /* @__PURE__ */ new Map();
+    this.frontendCapabilities = /* @__PURE__ */ new Map();
+    this.disposers = [];
+    this.backendSourceGeneration = 1;
+  }
+  grantFrontendConnection(caller) {
+    if (!caller || caller.kind !== "frontend" || caller.sourceId !== "view-frontend" || typeof caller.capability !== "string") {
+      throw workspaceError(
+        "view-inspector-unauthorized",
+        "a real FrontendHost connection to receive the inspector capability",
+        "Connect the frontend through the backend Host pairing before reporting activation."
+      );
+    }
+    this.frontendCapabilities.set(caller.connectionId, caller.capability);
+    return caller.capability;
+  }
+  assertFrontendCaller(caller) {
+    if (!caller || caller.kind !== "frontend" || caller.sourceId !== "view-frontend" || this.frontendCapabilities.get(caller.connectionId) !== caller.capability) {
+      throw workspaceError(
+        "view-inspector-unauthorized",
+        "a backend-issued inspector capability on a real FrontendHost connection",
+        "Report frontend activation only through the paired FrontendHost transport.",
+        { kind: caller?.kind, sourceId: caller?.sourceId }
+      );
+    }
+  }
+  backendSnapshot() {
+    let api;
+    let state = "unknown";
+    try {
+      api = safeToolSnapshot(this.toolApi?.snapshot?.());
+    } catch (error) {
+      state = "unavailable";
+      api = { providers: [], operations: [], error: safeError(error) };
+    }
+    const assembly = safeAssembly(this.hostAssembly);
+    const activation = safeActivationStatus(this.hostAssembly?.activation);
+    if (activation.state !== "unknown") state = activation.state;
+    const fibers = [];
+    for (const runtime of this.context?.registry?.values?.() ?? []) {
+      for (const fiber of runtime.fibers ?? []) {
+        const inspected = inspectPluginFiber(fiber);
+        if (inspected.uid !== null) fibers.push({ ...inspected, realm: "host" });
+      }
+    }
+    const actual = actualPluginEntries(this.hostAssembly?.activation, api, fibers);
+    return {
+      apiVersion: VIEW_INSPECTOR_API_VERSION,
+      sourceId: "view-backend",
+      kind: "backend",
+      generation: this.hostAssembly?.generation ?? this.backendSourceGeneration,
+      state,
+      observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      coverage: {
+        assembly: assembly !== null,
+        activation: this.hostAssembly?.activation === void 0 ? "unknown" : "actual",
+        api: this.toolApi !== void 0,
+        frontend: false
+      },
+      assembly,
+      actual: activation,
+      api,
+      plugins: actual
+    };
+  }
+  frontendSnapshot(record) {
+    return {
+      apiVersion: VIEW_INSPECTOR_API_VERSION,
+      sourceId: record.sourceId,
+      kind: "frontend",
+      generation: record.generation,
+      state: record.state,
+      observedAt: record.observedAt,
+      connection: record.connection,
+      coverage: {
+        assembly: record.assembly !== null,
+        activation: record.actual?.entries === void 0 ? "unknown" : "actual",
+        api: true,
+        frontend: true
+      },
+      assembly: record.assembly,
+      actual: record.actual,
+      api: record.api,
+      plugins: record.plugins
+    };
+  }
+  source(sourceId) {
+    if (sourceId === "view-backend") return this.backendSnapshot();
+    const report = this.reports.get(sourceId);
+    return report === void 0 ? void 0 : this.frontendSnapshot(report);
+  }
+  requireSource(sourceId, generation) {
+    requireWorkspaceString(sourceId, "sourceId");
+    if (!Number.isSafeInteger(generation) || generation <= 0) {
+      throw workspaceError(
+        "view-inspector-generation-required",
+        "source generation to be a positive integer",
+        "Call plugins.sources and pass the generation returned for the selected source.",
+        { sourceId }
+      );
+    }
+    const current = this.source(sourceId);
+    if (current === void 0) {
+      throw workspaceError(
+        "view-inspector-source-unavailable",
+        `source ${sourceId} to be connected and observed`,
+        "Refresh plugins.sources and select an authenticated source that is still connected.",
+        { sourceId }
+      );
+    }
+    if (generation !== current.generation) {
+      throw workspaceError(
+        "view-inspector-stale-generation",
+        `source ${sourceId} generation ${generation} to match ${current.generation}`,
+        "Refresh plugins.sources before inspecting or watching this source.",
+        { sourceId, expectedGeneration: current.generation, actualGeneration: generation }
+      );
+    }
+    return current;
+  }
+  authorize(request) {
+    if (request.token !== this.accessToken) {
+      throw workspaceError(
+        "view-inspector-unauthorized",
+        "the caller to use the View Host inspector token",
+        "Connect with the token issued by the View Host.",
+        { clientId: request.clientId }
+      );
+    }
+  }
+  sources(request) {
+    this.authorize(request);
+    const backend = this.backendSnapshot();
+    const frontend = [...this.reports.values()].map((record) => this.frontendSnapshot(record));
+    return {
+      apiVersion: VIEW_INSPECTOR_API_VERSION,
+      observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sources: [backend, ...frontend].map((source) => ({
+        sourceId: source.sourceId,
+        kind: source.kind,
+        generation: source.generation,
+        state: source.state,
+        observedAt: source.observedAt,
+        ...source.connection === void 0 ? {} : { connection: source.connection },
+        coverage: source.coverage,
+        pluginCount: Array.isArray(source.plugins) ? source.plugins.length : 0,
+        operationCount: source.api?.operations?.length ?? 0
+      })),
+      caller: { connectionId: request.caller?.connectionId, kind: request.caller?.kind }
+    };
+  }
+  inspect(request) {
+    this.authorize(request);
+    const source = this.requireSource(request.args.sourceId, request.args.generation);
+    const entryId = request.args.entryId;
+    if (entryId !== void 0) requireWorkspaceString(entryId, "entryId");
+    if (entryId === void 0) return source;
+    return {
+      ...source,
+      plugins: source.plugins.filter((entry) => entry.entryId === entryId),
+      api: {
+        ...source.api,
+        operations: source.api.operations.filter(
+          (operation) => operation.owner?.fiberId === entryId || operation.descriptor?.id === entryId
+        )
+      }
+    };
+  }
+  watch(request) {
+    this.authorize(request);
+    const source = this.requireSource(request.args.sourceId, request.args.generation);
+    const watchId = createWorkspaceId("inspector-watch");
+    this.watches.set(watchId, {
+      watchId,
+      sourceId: source.sourceId,
+      generation: source.generation,
+      connectionId: request.caller.connectionId
+    });
+    return {
+      apiVersion: VIEW_INSPECTOR_API_VERSION,
+      watchId,
+      topic: VIEW_INSPECTOR_TOPIC,
+      source
+    };
+  }
+  unwatch(request) {
+    this.authorize(request);
+    const watchId = requireWorkspaceString(request.args.watchId, "watchId");
+    const watch = this.watches.get(watchId);
+    if (watch !== void 0 && watch.connectionId !== request.caller.connectionId) {
+      throw workspaceError(
+        "view-inspector-unauthorized",
+        "the watch to be owned by the authenticated caller",
+        "Use the watchId returned by this connection.",
+        { watchId }
+      );
+    }
+    this.watches.delete(watchId);
+    return { apiVersion: VIEW_INSPECTOR_API_VERSION, watchId, released: true };
+  }
+  async report(request, caller) {
+    this.authorize(request);
+    this.assertFrontendCaller(caller);
+    const sourceId = sourceIdFor(caller);
+    const previous = this.reports.get(sourceId);
+    const generation = (previous?.generation ?? 0) + 1;
+    const report = request.args?.report ?? {};
+    if (!report || typeof report !== "object" || Array.isArray(report)) {
+      throw workspaceError(
+        "view-inspector-invalid-report",
+        "frontend report to be a structured object",
+        "Send the activation status and safe API projection produced by FrontendHost."
+      );
+    }
+    const record = {
+      sourceId,
+      generation,
+      state: safeText(report.actual?.state ?? report.state, "active"),
+      observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      connection: { connectionId: caller.connectionId, kind: caller.kind ?? "unknown" },
+      assembly: safeAssembly(report.assembly),
+      actual: safeActivationStatus(report.actual ?? report.status),
+      api: safeToolSnapshot(report.api),
+      plugins: actualPluginEntries(
+        report.actual ?? report.status,
+        report.api,
+        Array.isArray(report.plugins) ? report.plugins : []
+      )
+    };
+    this.reports.set(sourceId, record);
+    this.publish(sourceId);
+    return { apiVersion: VIEW_INSPECTOR_API_VERSION, sourceId, generation };
+  }
+  publish(sourceId) {
+    const source = this.source(sourceId);
+    if (source === void 0) return;
+    for (const [watchId, watch] of this.watches) {
+      if (watch.sourceId !== sourceId) continue;
+      if (watch.generation !== source.generation) {
+        this.transport.publish(
+          VIEW_INSPECTOR_TOPIC,
+          {
+            apiVersion: VIEW_INSPECTOR_API_VERSION,
+            watchId,
+            sourceId,
+            state: "stale",
+            generation: source.generation,
+            reason: "source-generation-changed"
+          },
+          { connectionId: watch.connectionId }
+        );
+        this.watches.delete(watchId);
+        continue;
+      }
+      this.transport.publish(
+        VIEW_INSPECTOR_TOPIC,
+        { apiVersion: VIEW_INSPECTOR_API_VERSION, watchId, source },
+        { connectionId: watch.connectionId }
+      );
+    }
+  }
+  install({ dispatch } = {}) {
+    if (typeof dispatch !== "function") {
+      throw new TypeError("View inspector requires an Engine ToolApi dispatch adapter");
+    }
+    const register = (service, operation) => {
+      this.disposers.push(
+        this.transport.register(
+          service,
+          ({ payload, signal, caller }) => dispatch({ operation, payload, signal, caller })
+        )
+      );
+    };
+    register(VIEW_INSPECTOR_SERVICES.sources, "plugins.sources");
+    register(VIEW_INSPECTOR_SERVICES.inspect, "plugins.inspect");
+    register(VIEW_INSPECTOR_SERVICES.watch, "plugins.watch");
+    register(VIEW_INSPECTOR_SERVICES.unwatch, "plugins.unwatch");
+    register(VIEW_INSPECTOR_SERVICES.report, "plugins.report");
+    if (typeof this.toolApi?.subscribe === "function") {
+      this.disposers.push(this.toolApi.subscribe(() => this.publish("view-backend")));
+    }
+    if (typeof this.transport.onClientConnect === "function") {
+      this.disposers.push(
+        this.transport.onClientConnect((caller) => {
+          if (caller.kind === "frontend" && caller.sourceId === "view-frontend") {
+            try {
+              this.grantFrontendConnection(caller);
+            } catch {
+            }
+          }
+        })
+      );
+    }
+    if (typeof this.transport.onClientDisconnect === "function") {
+      this.disposers.push(
+        this.transport.onClientDisconnect((caller) => {
+          const sourceId = sourceIdFor(caller);
+          const report = this.reports.get(sourceId);
+          if (report !== void 0) {
+            for (const [watchId, watch] of this.watches) {
+              if (watch.sourceId !== sourceId || watch.connectionId === caller.connectionId) continue;
+              this.transport.publish(
+                VIEW_INSPECTOR_TOPIC,
+                {
+                  apiVersion: VIEW_INSPECTOR_API_VERSION,
+                  watchId,
+                  sourceId,
+                  state: "stale",
+                  generation: report.generation + 1,
+                  reason: "source-disconnected"
+                },
+                { connectionId: watch.connectionId }
+              );
+              this.watches.delete(watchId);
+            }
+          }
+          this.reports.delete(sourceId);
+          this.frontendCapabilities.delete(caller.connectionId);
+          for (const [watchId, watch] of this.watches) {
+            if (watch.connectionId === caller.connectionId) this.watches.delete(watchId);
+          }
+        })
+      );
+    }
+    return () => {
+      for (const dispose of this.disposers.splice(0)) dispose?.();
+      this.reports.clear();
+      this.watches.clear();
+      this.frontendCapabilities.clear();
+    };
+  }
+};
+var viewInspectorBackendPlugin = {
+  name: BACKEND_PLUGIN_ID,
+  provide: ["viewInspector"],
+  async apply(ctx, config = {}) {
+    const transport = ctx.get?.("hostTransport", false);
+    if (!transport) return;
+    const broker = new ViewInspectorBroker({
+      transport,
+      accessToken: config.accessToken ?? ctx.get?.("viewWorkspaceAccessToken", false),
+      hostAssembly: ctx.get?.("hostAssembly", false),
+      toolApi: ctx.get?.("toolApi", false),
+      context: ctx
+    });
+    ctx.provide("viewInspector", broker);
+    const inspectorTools = createViewInspectorToolContributions(broker);
+    const inspectorProviderId = `view-inspector:${String(ctx.fiber.uid)}`;
+    ctx.effect(() => registerTools(ctx, inspectorTools, {
+      providerId: inspectorProviderId,
+      sourceId: "view-backend",
+      module: BACKEND_MODULE,
+      realm: "host"
+    }));
+    const inspectorOwner = ctx.get?.("toolApi", false)?.describe("plugins.sources", "view-backend")?.find((record) => record.owner.providerId === inspectorProviderId)?.owner;
+    if (!inspectorOwner) {
+      throw new Error("View inspector ToolApi provider did not activate");
+    }
+    const uninstall = broker.install({
+      dispatch: ({ operation, payload, signal, caller }) => runInspectorToolApi(ctx.get?.("toolApi", false), {
+        operation,
+        payload,
+        signal,
+        caller,
+        providerId: inspectorOwner.providerId,
+        generation: inspectorOwner.generation
+      })
+    });
+    ctx.effect(() => () => uninstall());
+  }
+};
+function projectLocalAssembly(value) {
+  const assembly = value?.current ?? value;
+  return safeAssembly(assembly);
+}
+var ViewInspectorClient = class {
+  constructor({ transport, clientId, token } = {}) {
+    if (!transport || typeof transport.request !== "function") {
+      throw new TypeError("View inspector client requires an Engine Host transport");
+    }
+    this.transport = transport;
+    this.clientId = requireWorkspaceString(clientId, "clientId");
+    this.token = token === void 0 ? void 0 : requireWorkspaceString(token, "token");
+  }
+  request(service, operation, args = {}, options = {}) {
+    const request = createInspectorRequest(operation, args, {
+      clientId: this.clientId,
+      token: this.token,
+      requestId: options.requestId
+    });
+    return this.transport.request(service, request, { signal: options.signal }).catch((error) => {
+      const decoded = decodeInspectorError(error);
+      reportWorkspaceCommandError(decoded, { operation, signal: options.signal });
+      throw decoded;
+    });
+  }
+  sources(options = {}) {
+    return this.request(VIEW_INSPECTOR_SERVICES.sources, "plugins.sources", {}, options);
+  }
+  inspect({ sourceId, generation, entryId, ...options } = {}) {
+    return this.request(
+      VIEW_INSPECTOR_SERVICES.inspect,
+      "plugins.inspect",
+      { sourceId, generation, ...entryId === void 0 ? {} : { entryId } },
+      options
+    );
+  }
+  watch({ sourceId, generation, ...options } = {}) {
+    return this.request(VIEW_INSPECTOR_SERVICES.watch, "plugins.watch", { sourceId, generation }, options);
+  }
+  unwatch(watchId, options = {}) {
+    return this.request(VIEW_INSPECTOR_SERVICES.unwatch, "plugins.unwatch", { watchId }, options);
+  }
+  report(report) {
+    return this.request(VIEW_INSPECTOR_SERVICES.report, "plugins.report", { report });
+  }
+  subscribe(listener) {
+    return this.transport.subscribe?.(VIEW_INSPECTOR_TOPIC, listener) ?? (() => {
+    });
+  }
+  onDisconnect(listener) {
+    return this.transport.onDisconnect?.(listener) ?? (() => {
+    });
+  }
+};
+var ViewInspectorPanel = class {
+  constructor({
+    client,
+    document = globalThis.document,
+    mountId = "forgeax-view-inspector",
+    registry,
+    mountSlot
+  } = {}) {
+    this.client = client;
+    this.document = document;
+    this.mountId = mountId;
+    this.sourceId = null;
+    this.generation = null;
+    this.watchId = null;
+    this.sources = [];
+    this.refreshToken = 0;
+    this.search = null;
+    this.stateFilter = null;
+    this.sourceList = null;
+    this.hierarchy = null;
+    this.detail = null;
+    this.opened = false;
+    this.element = null;
+    this.button = null;
+    this.selector = null;
+    this.output = null;
+    this.unsubscribe = null;
+    this.removeDisconnect = null;
+    this.unmountSlot = void 0;
+    if (document?.createElement) {
+      const slotted = registry && mountSlot;
+      if (!slotted) {
+        this.button = document.createElement("button");
+        this.button.type = "button";
+        this.button.textContent = "Plugins";
+        this.button.dataset.forgeaxView = "inspector-entry";
+        this.button.addEventListener?.("click", () => void this.toggle());
+        document.body?.append(this.button);
+      }
+      this.element = document.getElementById?.(mountId) ?? document.createElement("aside");
+      this.element.id ||= mountId;
+      this.element.dataset.forgeaxView = "inspector";
+      this.element.hidden = !slotted;
+      if (slotted) {
+        this.unmountSlot = registry.mount(mountSlot, this.element);
+        this.opened = true;
+      } else {
+        document.body?.append(this.element);
+      }
+      this.selector = document.createElement("select");
+      this.selector.dataset.forgeaxView = "inspector-source";
+      this.selector.addEventListener?.("change", () => {
+        void this.selectSource(
+          this.selector.value || null,
+          Number(this.selector.selectedOptions?.[0]?.dataset?.generation ?? 0) || null
+        );
+      });
+      this.element.append(this.selector);
+      this.search = document.createElement("input");
+      this.search.type = "search";
+      this.search.placeholder = "Filter plugins, modules, entries, or services";
+      this.search.dataset.forgeaxView = "inspector-search";
+      this.search.addEventListener?.("input", () => {
+        this.renderSources({ sources: this.sources });
+        this.renderHierarchy(this.lastValue);
+      });
+      this.element.append(this.search);
+      this.stateFilter = document.createElement("select");
+      this.stateFilter.dataset.forgeaxView = "inspector-state-filter";
+      for (const state of ["all", "active", "pending", "failed", "disposed", "unknown"]) {
+        const option = document.createElement("option");
+        option.value = state;
+        option.textContent = state;
+        this.stateFilter.append(option);
+      }
+      this.stateFilter.addEventListener?.("change", () => {
+        this.renderSources({ sources: this.sources });
+        this.renderHierarchy(this.lastValue);
+      });
+      this.element.append(this.stateFilter);
+      this.sourceList = document.createElement("ul");
+      this.sourceList.dataset.forgeaxView = "inspector-sources";
+      this.element.append(this.sourceList);
+      this.hierarchy = document.createElement("ul");
+      this.hierarchy.dataset.forgeaxView = "inspector-hierarchy";
+      this.element.append(this.hierarchy);
+      this.detail = document.createElement("section");
+      this.detail.dataset.forgeaxView = "inspector-detail";
+      this.output = document.createElement("pre");
+      this.output.dataset.forgeaxView = "inspector-output";
+      this.detail.append(this.output);
+      this.element.append(this.detail);
+      this.unsubscribe = client?.subscribe?.((payload) => this.handleChange(payload));
+      this.removeDisconnect = client?.onDisconnect?.(() => {
+        this.watchId = null;
+        this.sourceId = null;
+        this.generation = null;
+        if (this.opened) void this.refresh();
+      });
+    }
+  }
+  async toggle() {
+    if (this.opened) return this.close();
+    return this.open();
+  }
+  async open() {
+    this.opened = true;
+    if (this.element) this.element.hidden = false;
+    await this.refresh();
+  }
+  async refresh() {
+    if (!this.client) {
+      if (this.element) this.element.textContent = "Plugin inspection unavailable";
+      return;
+    }
+    const refreshToken = ++this.refreshToken;
+    try {
+      const listed = await this.client.sources();
+      if (refreshToken !== this.refreshToken) return;
+      this.renderSources(listed);
+      const own = listed.sources.find((source) => source.sourceId === this.sourceId);
+      const selected = own ?? (this.sourceId === null && listed.sources.length === 1 ? listed.sources[0] : void 0);
+      if (selected === void 0) {
+        this.render(listed);
+        return;
+      }
+      this.sourceId = selected.sourceId;
+      this.generation = selected.generation;
+      const inspected = await this.client.inspect({ sourceId: this.sourceId, generation: this.generation });
+      if (refreshToken !== this.refreshToken) return;
+      this.render(inspected);
+      if (this.watchId === null) {
+        const watch = await this.client.watch({ sourceId: this.sourceId, generation: this.generation });
+        if (refreshToken !== this.refreshToken) {
+          await this.client.unwatch(watch.watchId).catch(() => {
+          });
+          return;
+        }
+        this.watchId = watch.watchId;
+      }
+    } catch (error) {
+      if (refreshToken !== this.refreshToken) return;
+      this.render({ state: "error", error: safeError(error) ?? { message: safeText(error?.message) } });
+    }
+  }
+  handleChange(payload) {
+    if (!this.opened || payload?.watchId !== this.watchId) return;
+    if (payload.state === "stale") {
+      this.watchId = null;
+      this.generation = null;
+      void this.refresh();
+      return;
+    }
+    if (payload.source) this.render(payload.source);
+  }
+  render(value) {
+    if (jsonUnchanged(this.lastValue, value)) return value;
+    this.lastValue = value;
+    if (Array.isArray(value?.sources)) this.renderSources(value);
+    this.renderHierarchy(value);
+    if (this.output) this.output.textContent = JSON.stringify(value, null, 2);
+    else if (this.element) this.element.textContent = JSON.stringify(value, null, 2);
+    return value;
+  }
+  renderSources(value) {
+    const sources = Array.isArray(value?.sources) ? value.sources : [];
+    if (Array.isArray(value?.sources)) this.sources = sources;
+    const query = String(this.search?.value ?? "").trim().toLowerCase();
+    const state = this.stateFilter?.value || "all";
+    const filtered = this.sources.filter((source) => {
+      if (state !== "all" && source.state !== state) return false;
+      if (query === "") return true;
+      return `${source.sourceId} ${source.kind} ${source.state}`.toLowerCase().includes(query);
+    });
+    if (!this.selector) return;
+    this.selector.replaceChildren?.();
+    this.selector.hidden = this.sources.length === 0;
+    for (const source of this.sources) {
+      const option = this.document.createElement("option");
+      option.value = source.sourceId;
+      option.textContent = `${source.kind ?? "source"}: ${source.sourceId} (generation ${source.generation})`;
+      option.dataset.generation = String(source.generation ?? "");
+      option.selected = source.sourceId === this.sourceId;
+      this.selector.append(option);
+    }
+    if (this.sourceList) {
+      this.sourceList.replaceChildren?.();
+      for (const source of filtered) {
+        const item = this.document.createElement("li");
+        item.textContent = `${source.kind ?? "source"} ${source.sourceId} \xB7 ${source.state ?? "unknown"}`;
+        item.dataset.sourceId = source.sourceId;
+        this.sourceList.append(item);
+      }
+    }
+  }
+  renderHierarchy(value) {
+    if (!this.hierarchy) return;
+    this.hierarchy.replaceChildren?.();
+    const query = String(this.search?.value ?? "").trim().toLowerCase();
+    const stateFilter = this.stateFilter?.value || "all";
+    const plugins = Array.isArray(value?.plugins) ? value.plugins : [];
+    const pluginsById = new Map(
+      plugins.filter((plugin) => typeof plugin?.entryId === "string").map((plugin) => [plugin.entryId, plugin])
+    );
+    const depthById = /* @__PURE__ */ new Map();
+    const depthFor = (plugin, visiting = /* @__PURE__ */ new Set()) => {
+      if (!plugin?.parent || visiting.has(plugin.entryId)) return 0;
+      const cached = depthById.get(plugin.entryId);
+      if (cached !== void 0) return cached;
+      visiting.add(plugin.entryId);
+      const parent = pluginsById.get(plugin.parent);
+      const depth = parent === void 0 ? 0 : Math.min(8, depthFor(parent, visiting) + 1);
+      visiting.delete(plugin.entryId);
+      depthById.set(plugin.entryId, depth);
+      return depth;
+    };
+    const matches = (state, text) => (stateFilter === "all" || state === stateFilter) && (query === "" || text.toLowerCase().includes(query));
+    for (const plugin of plugins) {
+      const state = plugin.fiberState ?? plugin.state ?? "unknown";
+      const services = [
+        ...Array.isArray(plugin.requiredServices) ? plugin.requiredServices : [],
+        ...Array.isArray(plugin.providedServices) ? plugin.providedServices : []
+      ];
+      const text = `${plugin.entryId ?? ""} ${plugin.module ?? ""} ${plugin.realm ?? ""} ${state} ${services.join(" ")} ${plugin.parent ?? ""}`;
+      if (!matches(state, text)) continue;
+      const depth = depthFor(plugin);
+      const parentModule = pluginsById.get(plugin.parent)?.module;
+      const parent = parentModule && parentModule !== "unknown" ? ` parent ${parentModule}` : "";
+      const item = this.document.createElement("li");
+      item.dataset.parent = plugin.parent ?? "";
+      item.dataset.state = state;
+      if (item.style) {
+        item.style.paddingInlineStart = `${depth * 1.25}rem`;
+        item.style.paddingLeft = `${depth * 1.25}rem`;
+      }
+      item.textContent = `${"  ".repeat(depth)}${plugin.module ?? "Unnamed plugin"} \xB7 ${state}${parent}`;
+      item.dataset.entryId = plugin.entryId ?? "";
+      this.hierarchy.append(item);
+    }
+    const operations = Array.isArray(value?.api?.operations) ? value.api.operations : [];
+    for (const operation of operations) {
+      const descriptor = operation.descriptor ?? {};
+      const state = operation.fiberState ?? operation.providerState ?? "unknown";
+      const services = [
+        ...Array.isArray(operation.requiredServices) ? operation.requiredServices : [],
+        ...Array.isArray(operation.providedServices) ? operation.providedServices : []
+      ];
+      const text = `${descriptor.id ?? ""} ${descriptor.title ?? ""} ${descriptor.summary ?? ""} ${operation.owner?.module ?? ""} ${operation.owner?.providerId ?? ""} ${services.join(" ")}`;
+      if (!matches(state, text)) continue;
+      const item = this.document.createElement("li");
+      item.dataset.state = state;
+      item.textContent = `service ${descriptor.id ?? "unknown"} \xB7 ${state}`;
+      item.dataset.operationId = descriptor.id ?? "";
+      this.hierarchy.append(item);
+    }
+  }
+  async selectSource(sourceId, generation) {
+    const refreshToken = ++this.refreshToken;
+    const previousWatch = this.watchId;
+    this.watchId = null;
+    if (previousWatch !== null && this.client) {
+      await this.client.unwatch(previousWatch).catch(() => {
+      });
+    }
+    if (refreshToken !== this.refreshToken) return;
+    this.sourceId = sourceId;
+    this.generation = generation;
+    await this.refresh();
+  }
+  async close() {
+    this.opened = false;
+    this.refreshToken += 1;
+    if (this.element) this.element.hidden = true;
+    if (this.watchId !== null) {
+      if (this.client) await this.client.unwatch(this.watchId).catch(() => {
+      });
+      this.watchId = null;
+    }
+  }
+  async dispose() {
+    await this.close();
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    this.removeDisconnect?.();
+    this.removeDisconnect = null;
+    this.unmountSlot?.();
+    this.unmountSlot = void 0;
+    this.button?.remove?.();
+    this.element?.remove?.();
+    this.button = null;
+    this.element = null;
+    this.selector = null;
+    this.search = null;
+    this.stateFilter = null;
+    this.sourceList = null;
+    this.hierarchy = null;
+    this.detail = null;
+    this.output = null;
+  }
+};
+var viewInspectorFrontendPlugin = {
+  name: "forgeax.view.service.plugin-inspection-reporter.frontend",
+  provide: ["viewInspectorClient", "viewInspectorPanel"],
+  async apply(ctx, config = {}) {
+    const transport = config.transport ?? ctx.get?.("hostTransport", false);
+    const workspace = config.workspace ?? {};
+    const token = config.token ?? workspace.token;
+    const client = transport && typeof token === "string" && typeof workspace.clientId === "string" ? new ViewInspectorClient({ transport, clientId: workspace.clientId, token }) : void 0;
+    const panel = new ViewInspectorPanel({
+      client,
+      document: config.document ?? globalThis.document,
+      mountId: config.mountId ?? "forgeax-view-inspector",
+      registry: config.registry,
+      mountSlot: config.mountSlot
+    });
+    ctx.provide("viewInspectorClient", client);
+    ctx.provide("viewInspectorPanel", panel);
+    if (client) {
+      const toolApi = ctx.get?.("toolApi", false);
+      const hostAssembly = ctx.get?.("hostAssembly", false);
+      const inspectorFiberEntry = () => ({
+        entryId: `fiber:${String(ctx.fiber.uid ?? "unknown")}`,
+        fiberId: String(ctx.fiber.uid ?? "unknown"),
+        module: "forgeax.view.service.plugin-inspection-reporter.frontend",
+        realm: "engine",
+        fiberState: fiberStateName(ctx.fiber.state)
+      });
+      const report = () => ({
+        // The report is emitted after this plugin's apply completed. The
+        // outer FrontendHost may still be in its loading phase while it
+        // collects the complete activation receipt.
+        status: ctx.get?.("hostAssembly", false)?.status ?? { state: "unknown" },
+        actual: (() => {
+          const status = hostAssembly?.status ?? { state: "unknown" };
+          const live = hostAssembly?.inspection;
+          return {
+            ...status,
+            entries: [
+              ...Array.isArray(status.entries) ? status.entries : [],
+              ...Array.isArray(live) ? live : [],
+              inspectorFiberEntry()
+            ]
+          };
+        })(),
+        assembly: projectLocalAssembly(ctx.get?.("hostAssembly", false)),
+        api: safeToolSnapshot(toolApi?.snapshot?.()),
+        plugins: [
+          safePluginEntry(inspectorFiberEntry()),
+          ...Array.isArray(ctx.get?.("hostAssembly", false)?.status?.entries) ? ctx.get("hostAssembly", false).status.entries.map(safePluginEntry).filter((entry) => entry !== null) : [],
+          ...Array.isArray(ctx.get?.("hostAssembly", false)?.inspection) ? ctx.get("hostAssembly", false).inspection.map(safePluginEntry).filter((entry) => entry !== null) : []
+        ]
+      });
+      let reporting = Promise.resolve();
+      const publishReport = ({ allowUnready = false } = {}) => {
+        const state = hostAssembly?.status?.state;
+        if (!allowUnready && hostAssembly !== void 0 && (state === "created" || state === "loading")) {
+          return reporting;
+        }
+        reporting = reporting.then(async () => {
+          const registered = await client.report(report());
+          panel.sourceId = registered.sourceId;
+          panel.generation = registered.generation;
+        }).catch(() => {
+        });
+        return reporting;
+      };
+      const unsubscribeAssembly = hostAssembly?.subscribe?.(() => {
+        void publishReport();
+      });
+      const unsubscribeToolApi = toolApi?.subscribe?.(() => {
+        void publishReport();
+      });
+      await publishReport({ allowUnready: true });
+      ctx.effect(() => async () => {
+        unsubscribeAssembly?.();
+        unsubscribeToolApi?.();
+        await panel.dispose();
+      });
+    } else {
+      ctx.effect(() => async () => panel.dispose());
+    }
+  }
+};
+
+export {
+  VIEW_INSPECTOR_API_VERSION,
+  VIEW_INSPECTOR_SERVICES,
+  VIEW_INSPECTOR_TOPIC,
+  VIEW_STATUS_OPERATION,
+  VIEW_INSPECTOR_OPERATIONS,
+  safeDetail,
+  safeError,
+  createInspectorRequest,
+  runWorkspaceToolApi,
+  runInspectorToolApi,
+  runViewToolApi,
+  createViewWorkspaceToolContributions,
+  createViewInspectorToolContributions,
+  createViewStatusToolContributions,
+  ViewInspectorBroker,
+  viewInspectorBackendPlugin,
+  ViewInspectorClient,
+  ViewInspectorPanel,
+  viewInspectorFrontendPlugin
+};
+//# sourceMappingURL=chunk-KHRTIZ56.mjs.map