webloom-framework 0.3.0 → 0.4.1

package/dist/chunk-76BGPI6M.js

@@ -1,4261 +0,0 @@
-// src/contracts/lifecycle.ts
-var LifecycleScopeRevokedError = class extends Error {
-  code = "lifecycle.scope_revoked";
-  constructor(message = "Lifecycle scope has been revoked") {
-    super(message);
-    this.name = "LifecycleScopeRevokedError";
-  }
-};
-var PermissionLeaseRevokedError = class extends Error {
-  code = "permission.lease_revoked";
-  constructor(message = "Permission lease has been revoked") {
-    super(message);
-    this.name = "PermissionLeaseRevokedError";
-  }
-};
-var PermissionDeniedError = class extends Error {
-  code = "permission.denied";
-  permission;
-  constructor(permission, message = `Permission denied: ${permission}`) {
-    super(message);
-    this.name = "PermissionDeniedError";
-    this.permission = permission;
-  }
-};
-function createRemoteServiceMessageCodec(options = {}) {
-  const prefix = options.prefix ?? "webloom.remote-service";
-  const protocolVersion = options.protocolVersion ?? "webloom.remote-service.v2";
-  const types = /* @__PURE__ */ new Map([
-    ["call", `${prefix}.call`],
-    ["result", `${prefix}.result`],
-    ["error", `${prefix}.error`],
-    ["cancel", `${prefix}.cancel`]
-  ]);
-  return Object.freeze({
-    protocolVersion,
-    type(kind) {
-      const value = types.get(kind);
-      if (!value) throw new Error(`Unknown remote service message kind: ${kind}`);
-      return value;
-    },
-    encode(message) {
-      return { ...message };
-    },
-    decode(input) {
-      if (!input || typeof input !== "object") return void 0;
-      const message = input;
-      if (typeof message.type !== "string" || ![...types.values()].includes(message.type)) return void 0;
-      return message;
-    }
-  });
-}
-var RemoteServiceError = class extends Error {
-  code;
-  details;
-  constructor(code, message, details) {
-    super(message);
-    this.name = "RemoteServiceError";
-    this.code = code;
-    this.details = details;
-  }
-};
-var UpgradeGateRejectedError = class extends Error {
-  code = "upgrade.gate_rejected";
-  reason;
-  constructor(reason, message = `Upgrade gate rejected operation: ${reason}`) {
-    super(message);
-    this.name = "UpgradeGateRejectedError";
-    this.reason = reason;
-  }
-};
-var SCOPED_TASK_SCHEDULER_CAPABILITY = "runtime.task-scheduler";
-var LIFECYCLE_ERROR_TEXT = Object.freeze({
-  "lifecycle.scope_revoked": "\u8FD0\u884C\u5B9E\u4F8B\u5DF2\u505C\u6B62",
-  "permission.denied": "\u63D2\u4EF6\u6CA1\u6709\u83B7\u5F97\u8BE5\u64CD\u4F5C\u7684\u6743\u9650",
-  "permission.lease_revoked": "\u6388\u6743\u79DF\u7EA6\u5DF2\u64A4\u9500",
-  "lifecycle.cleanup_failed": "\u8D44\u6E90\u6E05\u7406\u5931\u8D25\uFF0C\u7B49\u5F85\u91CD\u8BD5",
-  "lifecycle.cleanup_timeout": "\u8D44\u6E90\u6E05\u7406\u8D85\u65F6\uFF0C\u4ECD\u5728\u540E\u53F0\u6392\u7A7A",
-  "upgrade.gate_rejected": "\u7248\u672C\u63A5\u7BA1\u95E8\u7981\u672A\u901A\u8FC7"
-});
-function lifecycleErrorText(code) {
-  return LIFECYCLE_ERROR_TEXT[code] ?? "\u751F\u547D\u5468\u671F\u64CD\u4F5C\u672A\u5B8C\u6210";
-}
-
-// src/contracts/messageBus.ts
-var RUNTIME_MESSAGE_BUS = "webloom.messageBus";
-
-// src/contracts/resource.ts
-var RESOURCE_OWNER = /* @__PURE__ */ Symbol("webloom.resource.owner");
-var RESOURCE_REGISTRY_CAPABILITY = "webloom.resource.registry";
-
-// src/host/capabilityRegistry.ts
-function createCapabilityRegistry() {
-  const map = /* @__PURE__ */ new Map();
-  return {
-    provide(key, value) {
-      if (map.has(key)) {
-        throw new Error(`Capability "${key}" is already provided`);
-      }
-      map.set(key, value);
-    },
-    revoke(key) {
-      if (!map.has(key)) return;
-      map.delete(key);
-    },
-    get(key) {
-      if (!map.has(key)) {
-        throw new Error(`Capability "${key}" is not available`);
-      }
-      return map.get(key);
-    },
-    has(key) {
-      return map.has(key);
-    },
-    require(key) {
-      if (!map.has(key)) {
-        throw new Error(`Required capability "${key}" is missing`);
-      }
-    },
-    keys() {
-      return [...map.keys()];
-    }
-  };
-}
-
-// src/host/pluginGraph.ts
-var PluginGraphValidationError = class extends Error {
-  code = "plugin.graph_invalid";
-  diagnostics;
-  constructor(diagnostics) {
-    super(diagnostics.map((diagnostic) => diagnostic.message).join("; "));
-    this.name = "PluginGraphValidationError";
-    this.diagnostics = [...diagnostics];
-  }
-};
-function unique(values) {
-  return [...new Set(values)];
-}
-function isRuntimeKind(value) {
-  return value === "window-main" || value === "shared-worker";
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function validateRuntimeUnitDependencyContracts(manifests) {
-  const diagnostics = [];
-  for (const manifest of manifests) {
-    const units = manifest.units;
-    if (units === void 0) continue;
-    const productLevelFields = [
-      ["dependencies", manifest.dependencies],
-      ["permissions", manifest.permissions],
-      ["contribution", manifest.contribution],
-      ["config", manifest.config]
-    ];
-    for (const [field, value] of productLevelFields) {
-      if (value === void 0) continue;
-      diagnostics.push({
-        code: "plugin.runtime_declaration_at_product_level",
-        ids: [manifest.id, field],
-        message: `\u591A\u8FD0\u884C\u5355\u5143\u63D2\u4EF6 "${manifest.id}" \u7684 ${field} \u5FC5\u987B\u58F0\u660E\u5728\u5BF9\u5E94 RuntimeUnitDescriptor \u4E2D\uFF0C\u4E0D\u80FD\u4F7F\u7528\u4EA7\u54C1\u7EA7 fallback`
-      });
-    }
-    if ((manifest.provides?.length ?? 0) > 0) {
-      diagnostics.push({
-        code: "plugin.runtime_declaration_at_product_level",
-        ids: [manifest.id, "provides"],
-        message: `\u591A\u8FD0\u884C\u5355\u5143\u63D2\u4EF6 "${manifest.id}" \u7684 provides \u5FC5\u987B\u58F0\u660E\u5728\u5BF9\u5E94 RuntimeUnitDescriptor \u4E2D\uFF0C\u4E0D\u80FD\u4F7F\u7528\u4EA7\u54C1\u7EA7 capability \u6458\u8981`
-      });
-    }
-    if (!Array.isArray(units)) {
-      diagnostics.push({
-        code: "plugin.dependency_contract_invalid",
-        ids: [manifest.id, "units"],
-        message: `\u63D2\u4EF6 "${manifest.id}" \u7684 units \u5FC5\u987B\u662F\u8FD0\u884C\u5355\u5143\u6570\u7EC4`
-      });
-      continue;
-    }
-    units.forEach((unitValue, unitIndex) => {
-      if (!isRecord(unitValue)) {
-        diagnostics.push({
-          code: "plugin.dependency_contract_invalid",
-          ids: [manifest.id, `unit:${unitIndex}`],
-          message: `\u63D2\u4EF6 "${manifest.id}" \u7684\u7B2C ${unitIndex + 1} \u4E2A\u8FD0\u884C\u5355\u5143\u63CF\u8FF0\u65E0\u6548`
-        });
-        return;
-      }
-      const unitId = typeof unitValue.id === "string" && unitValue.id.length > 0 ? unitValue.id : `unit:${unitIndex}`;
-      const providedContracts = unitValue.providedContracts;
-      if (providedContracts !== void 0) {
-        if (!isRecord(providedContracts)) {
-          diagnostics.push({
-            code: "plugin.dependency_contract_invalid",
-            ids: [manifest.id, unitId],
-            message: `\u63D2\u4EF6 "${manifest.id}" \u7684\u8FD0\u884C\u5355\u5143 "${unitId}" \u7684 providedContracts\uFF08\u63D0\u4F9B\u5951\u7EA6\u7248\u672C\uFF09\u5FC5\u987B\u662F\u5BF9\u8C61`
-          });
-        } else {
-          for (const [capability, version] of Object.entries(providedContracts)) {
-            if (typeof version !== "string" || version.trim() === "") {
-              diagnostics.push({
-                code: "plugin.dependency_contract_invalid",
-                ids: [manifest.id, unitId, capability],
-                message: `\u63D2\u4EF6 "${manifest.id}" \u7684\u8FD0\u884C\u5355\u5143 "${unitId}" \u4E3A\u80FD\u529B "${capability}" \u58F0\u660E\u7684\u5951\u7EA6\u7248\u672C\u4E0D\u80FD\u4E3A\u7A7A`
-              });
-            }
-          }
-        }
-      }
-      const dependencies = unitValue.dependencies;
-      if (dependencies === void 0) return;
-      if (!Array.isArray(dependencies)) {
-        diagnostics.push({
-          code: "plugin.dependency_contract_invalid",
-          ids: [manifest.id, unitId],
-          message: `\u63D2\u4EF6 "${manifest.id}" \u7684\u8FD0\u884C\u5355\u5143 "${unitId}" \u7684 dependencies \u5FC5\u987B\u662F\u6570\u7EC4`
-        });
-        return;
-      }
-      dependencies.forEach((dependencyValue, dependencyIndex) => {
-        const dependency = isRecord(dependencyValue) ? dependencyValue : {};
-        const errors = [];
-        if (typeof dependency.capability !== "string" || dependency.capability.trim() === "") {
-          errors.push("capability\uFF08\u80FD\u529B\u6807\u8BC6\uFF09\u4E0D\u80FD\u4E3A\u7A7A");
-        }
-        if (typeof dependency.contractVersion !== "string" || dependency.contractVersion.trim() === "") {
-          errors.push("contractVersion\uFF08\u5951\u7EA6\u7248\u672C\uFF09\u4E0D\u80FD\u4E3A\u7A7A");
-        }
-        if (!isRuntimeKind(dependency.sourceRuntime)) {
-          errors.push("sourceRuntime\uFF08\u63D0\u4F9B\u8005 Runtime\uFF09\u65E0\u6548");
-        }
-        if (unitValue.runtime !== void 0 && !isRuntimeKind(unitValue.runtime)) {
-          errors.push("runtime\uFF08\u76EE\u6807 Runtime\uFF09\u65E0\u6548");
-        }
-        if (dependency.reason !== void 0 && typeof dependency.reason !== "string") {
-          errors.push("reason\uFF08\u4F9D\u8D56\u8BF4\u660E\uFF09\u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
-        }
-        if (dependency.optional !== void 0 && typeof dependency.optional !== "boolean") {
-          errors.push("optional\uFF08\u662F\u5426\u53EF\u9009\uFF09\u5FC5\u987B\u662F\u5E03\u5C14\u503C");
-        }
-        if (errors.length === 0) return;
-        const capability = typeof dependency.capability === "string" && dependency.capability.length > 0 ? dependency.capability : `dependency:${dependencyIndex}`;
-        diagnostics.push({
-          code: "plugin.dependency_contract_invalid",
-          ids: [manifest.id, unitId, capability],
-          message: `\u63D2\u4EF6 "${manifest.id}" \u7684\u8FD0\u884C\u5355\u5143 "${unitId}" \u7B2C ${dependencyIndex + 1} \u6761\u4F9D\u8D56\u5951\u7EA6\u65E0\u6548\uFF1A${errors.join("\u3001")}`
-        });
-      });
-    });
-  }
-  for (const manifest of manifests) {
-    for (const unit of manifest.units ?? []) {
-      if (!isRuntimeKind(unit.runtime)) {
-        diagnostics.push({
-          code: "plugin.runtime_invalid",
-          ids: [manifest.id, unit.id],
-          message: `\u63D2\u4EF6 "${manifest.id}" \u7684\u8FD0\u884C\u5355\u5143 "${unit.id}" \u58F0\u660E\u4E86\u4E0D\u652F\u6301\u7684 Runtime\uFF1Bv1 \u4EC5\u652F\u6301 window-main/shared-worker`
-        });
-      }
-    }
-  }
-  return diagnostics;
-}
-function unitRuntime(unit) {
-  return unit.runtime;
-}
-function isRuntimeUnit(unit) {
-  return typeof unit.id === "string" && unit.id.length > 0 && isRuntimeKind(unit.runtime);
-}
-function selectedRuntimeUnits(manifest, runtime) {
-  const units = manifest.units ?? [];
-  if (units.length === 0) return [];
-  if (runtime !== void 0) return units.filter(
-    (unit) => isRuntimeUnit(unit) && unit.runtime === runtime
-  );
-  return units.length === 1 && isRuntimeUnit(units[0]) ? [units[0]] : [];
-}
-function dependenciesOfManifest(manifest, runtime) {
-  const byCapability = /* @__PURE__ */ new Map();
-  const add = (dependency) => {
-    const previous = byCapability.get(dependency.capability);
-    if (!previous || previous.optional === true && dependency.optional !== true) {
-      byCapability.set(dependency.capability, { ...dependency });
-    }
-  };
-  const units = manifest.units ?? [];
-  if (units.length > 1 && runtime === void 0) return [];
-  const selectedUnits = selectedRuntimeUnits(manifest, runtime);
-  if (units.length > 0 && selectedUnits.length === 0) return [];
-  if (units.length === 0) {
-    for (const dependency of manifest.dependencies ?? []) add(dependency);
-  } else {
-    for (const unit of selectedUnits) {
-      for (const dependency of unit.dependencies ?? []) add(dependency);
-    }
-  }
-  return [...byCapability.values()];
-}
-function providesOfManifest(manifest, runtime) {
-  const units = manifest.units ?? [];
-  if (units.length > 1 && runtime === void 0) return [];
-  return unique([
-    ...units.length === 0 ? manifest.provides ?? [] : [],
-    ...selectedRuntimeUnits(manifest, runtime).flatMap((unit) => unit.provides ?? [])
-  ]);
-}
-function runtimeUnitProviders(manifests, capability) {
-  const providers = [];
-  for (const manifest of manifests) {
-    for (const unit of manifest.units ?? []) {
-      if (!unit.provides?.includes(capability)) continue;
-      if (!isRuntimeUnit(unit)) continue;
-      providers.push({
-        pluginId: manifest.id,
-        unitId: unit.id,
-        runtime: unit.runtime,
-        contractVersion: unit.providedContracts?.[capability]
-      });
-    }
-  }
-  return providers;
-}
-function matchingRuntimeUnitProviders(manifests, dependency) {
-  return runtimeUnitProviders(manifests, dependency.capability).filter(
-    (provider) => provider.runtime === dependency.sourceRuntime && provider.contractVersion === dependency.contractVersion
-  );
-}
-function runtimeDependenciesForValidation(manifest, runtime) {
-  const units = manifest.units ?? [];
-  const selected = runtime === void 0 ? units : units.filter((unit) => unitRuntime(unit) === runtime);
-  return selected.flatMap((unit) => unit.dependencies ?? []);
-}
-function buildPluginGraph(manifests, options = {}) {
-  const provides = {};
-  const dependencies = {};
-  const optionalDependencies = {};
-  const dependencyDetails = {};
-  const providers = {};
-  const unitGraph = {};
-  const enabled = options.enabledPluginIds;
-  for (const manifest of manifests) {
-    const selectedUnits = selectedRuntimeUnits(manifest, options.runtime);
-    const provided = providesOfManifest(manifest, options.runtime);
-    const dependencyEntries = dependenciesOfManifest(manifest, options.runtime);
-    dependencyDetails[manifest.id] = dependencyEntries.map((dependency) => ({ ...dependency }));
-    const deps = unique(dependencyEntries.map((dependency) => dependency.capability));
-    optionalDependencies[manifest.id] = unique(
-      dependencyEntries.filter((dependency) => dependency.optional).map((dependency) => dependency.capability)
-    );
-    provides[manifest.id] = provided;
-    dependencies[manifest.id] = deps;
-    for (const unit of selectedUnits) {
-      const unitKey = `${manifest.id}:${unit.id}`;
-      unitGraph[unitKey] = {
-        pluginId: manifest.id,
-        unitId: unit.id,
-        runtime: unit.runtime,
-        dependencies: unique((unit.dependencies ?? []).map((dependency) => dependency.capability)),
-        dependencyDetails: (unit.dependencies ?? []).map((dependency) => ({ ...dependency })),
-        provides: unique(unit.provides ?? []),
-        providedContracts: unit.providedContracts ? { ...unit.providedContracts } : void 0
-      };
-    }
-    for (const capability of provided) {
-      (providers[capability] ??= []).push(manifest.id);
-    }
-  }
-  const providerByCapability = /* @__PURE__ */ new Map();
-  for (const [capability, pluginIds] of Object.entries(providers)) {
-    providerByCapability.set(capability, pluginIds);
-  }
-  const reverse = {};
-  for (const manifest of manifests) {
-    const dependentEnabled = enabled?.has(manifest.id) ?? manifest.meta.defaultEnabled;
-    for (const capability of dependencies[manifest.id] ?? []) {
-      if (optionalDependencies[manifest.id]?.includes(capability)) continue;
-      for (const providerId of providerByCapability.get(capability) ?? []) {
-        if (providerId === manifest.id) continue;
-        const entries = reverse[providerId] ??= [];
-        let entry = entries.find((item) => item.pluginId === manifest.id);
-        if (!entry) {
-          entry = { pluginId: manifest.id, enabled: dependentEnabled, capabilities: [] };
-          entries.push(entry);
-        }
-        if (!entry.capabilities.includes(capability)) entry.capabilities.push(capability);
-      }
-    }
-  }
-  const cycles = [];
-  const firstProvider = /* @__PURE__ */ new Map();
-  for (const [capability, pluginIds] of providerByCapability) {
-    if (pluginIds[0]) firstProvider.set(capability, pluginIds[0]);
-  }
-  const visited = /* @__PURE__ */ new Set();
-  const path = [];
-  const visit = (pluginId) => {
-    if (visited.has(pluginId)) return;
-    const position = path.indexOf(pluginId);
-    if (position >= 0) {
-      const cycle = [...path.slice(position), pluginId];
-      if (!cycles.some((item) => item.join("\0") === cycle.join("\0"))) cycles.push(cycle);
-      return;
-    }
-    path.push(pluginId);
-    const manifest = manifests.find((item) => item.id === pluginId);
-    if (!manifest) {
-      path.pop();
-      visited.add(pluginId);
-      return;
-    }
-    for (const dependency of dependenciesOfManifest(manifest, options.runtime)) {
-      if (dependency.optional) continue;
-      const provider = firstProvider.get(dependency.capability);
-      if (provider) visit(provider);
-    }
-    path.pop();
-    visited.add(pluginId);
-  };
-  for (const manifest of manifests) visit(manifest.id);
-  return {
-    plugins: manifests.map((manifest) => manifest.id),
-    dependencies,
-    optionalDependencies,
-    provides,
-    reverse,
-    providers,
-    dependencyDetails,
-    cycles,
-    units: unitGraph
-  };
-}
-function validatePluginGraph(manifests, options = {}) {
-  const diagnostics = [];
-  diagnostics.push(...validateRuntimeUnitDependencyContracts(manifests));
-  const ids = /* @__PURE__ */ new Set();
-  for (const manifest of manifests) {
-    if (ids.has(manifest.id)) {
-      diagnostics.push({
-        code: "plugin.duplicate_id",
-        ids: [manifest.id],
-        message: `\u63D2\u4EF6\u6807\u8BC6 "${manifest.id}" \u91CD\u590D\uFF0C\u65E0\u6CD5\u786E\u5B9A\u552F\u4E00\u8FD0\u884C\u5B9E\u4F8B`
-      });
-    }
-    ids.add(manifest.id);
-  }
-  const graph = buildPluginGraph([...manifests], options);
-  const builtins = options.builtinCapabilities ?? /* @__PURE__ */ new Set();
-  const multiProvider = options.multiProviderCapabilities ?? /* @__PURE__ */ new Set();
-  for (const [capability, pluginIds] of Object.entries(graph.providers ?? {})) {
-    if (pluginIds.length > 1 && !multiProvider.has(capability)) {
-      diagnostics.push({
-        code: "capability.duplicate_provider",
-        ids: [capability, ...pluginIds],
-        message: `\u80FD\u529B "${capability}" \u6709\u591A\u4E2A\u63D0\u4F9B\u8005\uFF08${pluginIds.join(", ")}\uFF09\uFF0C\u4F46\u672A\u58F0\u660E\u4E13\u7528 Provider Registry`
-      });
-    }
-  }
-  for (const manifest of manifests) {
-    const strictDependencies = runtimeDependenciesForValidation(manifest, options.runtime);
-    for (const dependency of strictDependencies) {
-      if (dependency.optional) continue;
-      if (options.externalRuntimeDependencies && options.runtime !== void 0 && dependency.sourceRuntime !== options.runtime) {
-        continue;
-      }
-      const matches = matchingRuntimeUnitProviders(manifests, dependency);
-      if (matches.length > 0) {
-        if (matches.length > 1 && !multiProvider.has(dependency.capability)) {
-          diagnostics.push({
-            code: "capability.duplicate_provider",
-            ids: [dependency.capability, ...matches.map((provider) => `${provider.pluginId}:${provider.unitId}`)],
-            message: `\u80FD\u529B "${dependency.capability}" \u7684\u8FD0\u884C\u5355\u5143\u5951\u7EA6\u6709\u591A\u4E2A\u5339\u914D Provider\uFF08${matches.map((provider) => `${provider.pluginId}:${provider.unitId}`).join(", ")}\uFF09\uFF0C\u4F46\u672A\u58F0\u660E\u4E13\u7528 Provider Registry`
-          });
-        }
-        continue;
-      }
-      const candidates = runtimeUnitProviders(manifests, dependency.capability);
-      if (builtins.has(dependency.capability) && candidates.length === 0) {
-        continue;
-      }
-      if (candidates.length > 0) {
-        diagnostics.push({
-          code: "plugin.dependency_contract_unavailable",
-          ids: [manifest.id, dependency.capability],
-          message: `\u63D2\u4EF6 "${manifest.id}" \u7684\u8FD0\u884C\u5355\u5143\u4F9D\u8D56 "${dependency.capability}" \u6CA1\u6709\u5339\u914D\u7684\u5951\u7EA6\u7248\u672C\u3001\u6765\u6E90\u73AF\u5883\u6216\u4F5C\u7528\u57DF`
-        });
-      } else if (!options.allowMissingDependencies) {
-        diagnostics.push({
-          code: "plugin.missing_dependency",
-          ids: [manifest.id, dependency.capability],
-          message: `\u63D2\u4EF6 "${manifest.id}" \u7F3A\u5C11\u786C\u4F9D\u8D56\u80FD\u529B "${dependency.capability}"`
-        });
-      }
-    }
-  }
-  for (const manifest of manifests) {
-    const strictDependencyCapabilities = new Set(
-      runtimeDependenciesForValidation(manifest, options.runtime).map((dependency) => dependency.capability)
-    );
-    for (const dependency of dependenciesOfManifest(manifest, options.runtime)) {
-      if (dependency.optional) continue;
-      if (strictDependencyCapabilities.has(dependency.capability)) continue;
-      const provided = (graph.providers?.[dependency.capability]?.length ?? 0) > 0 || builtins.has(dependency.capability);
-      if (!provided && !options.allowMissingDependencies) {
-        diagnostics.push({
-          code: "plugin.missing_dependency",
-          ids: [manifest.id, dependency.capability],
-          message: `\u63D2\u4EF6 "${manifest.id}" \u7F3A\u5C11\u786C\u4F9D\u8D56\u80FD\u529B "${dependency.capability}"`
-        });
-      }
-    }
-  }
-  for (const cycle of graph.cycles ?? []) {
-    diagnostics.push({
-      code: "plugin.dependency_cycle",
-      ids: cycle,
-      message: `\u63D2\u4EF6\u5B58\u5728\u786C\u4F9D\u8D56\u73AF\uFF1A${cycle.join(" -> ")}`
-    });
-  }
-  if (diagnostics.length > 0) throw new PluginGraphValidationError(diagnostics);
-  return graph;
-}
-function reverseDependentsOf(graph, pluginId, enabledSet) {
-  return (graph.reverse[pluginId] ?? []).filter((dependent) => enabledSet.has(dependent.pluginId));
-}
-
-// src/messaging/messageBus.ts
-function makeMessageId() {
-  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
-    return crypto.randomUUID();
-  }
-  return `m_${Date.now().toString(36)}_${Math.floor(Math.random() * 1e9).toString(36)}`;
-}
-function errorMessage(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
-  return String(err);
-}
-var MAX_HANDLER_CONCURRENCY = 128;
-function waitForHandler(result, signal) {
-  if (signal.aborted) {
-    return Promise.reject(signal.reason ?? new Error("aborted"));
-  }
-  return new Promise((resolve, reject) => {
-    const onAbort = () => {
-      reject(signal.reason ?? new Error("aborted"));
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    result.then(resolve, reject).finally(() => {
-      signal.removeEventListener("abort", onAbort);
-    });
-  });
-}
-function createMessageBus() {
-  const subscriptions = /* @__PURE__ */ new Map();
-  const routedHandlers = /* @__PURE__ */ new Map();
-  const mailboxes = /* @__PURE__ */ new Map();
-  const targetHandlerCount = /* @__PURE__ */ new Map();
-  const targetConcurrency = /* @__PURE__ */ new Map();
-  const snapshotListeners = /* @__PURE__ */ new Set();
-  let total = 0;
-  let completed = 0;
-  let failed = 0;
-  let canceled = 0;
-  let inFlight = 0;
-  let lastError;
-  const pumping = /* @__PURE__ */ new Set();
-  function emitSnapshot() {
-    const snap = snapshot();
-    for (const l of snapshotListeners) l(snap);
-  }
-  function snapshot() {
-    const byTarget = {};
-    let queued = 0;
-    for (const [target, queue] of mailboxes.entries()) {
-      byTarget[target] = queue.length;
-      queued += queue.length;
-    }
-    return {
-      total,
-      queued,
-      inFlight,
-      completed,
-      failed,
-      canceled,
-      lastError,
-      byTarget
-    };
-  }
-  function makeMessage(type, mode, payload, options) {
-    return {
-      id: options.messageId ?? makeMessageId(),
-      type,
-      mode,
-      payload,
-      target: options.target,
-      priority: options.priority,
-      timeoutMs: options.timeoutMs,
-      causationId: options.causationId,
-      createdAt: Date.now()
-    };
-  }
-  function publishInternal(message) {
-    total += 1;
-    const routed = routedHandlers.get(message.type);
-    if (routed && !routed.target) {
-      try {
-        const result = routed.handler(message);
-        if (result && typeof result.then === "function") {
-          result.catch((err) => {
-            failed += 1;
-            lastError = errorMessage(err);
-            emitSnapshot();
-          });
-        }
-      } catch (err) {
-        failed += 1;
-        lastError = errorMessage(err);
-      }
-    }
-    const bucket = subscriptions.get(message.type);
-    if (bucket) {
-      for (const sub of [...bucket]) {
-        try {
-          sub.handler(message.payload);
-        } catch (err) {
-          failed += 1;
-          lastError = errorMessage(err);
-        }
-      }
-    }
-    emitSnapshot();
-    return message.id;
-  }
-  function settleEntry(entry, state, value) {
-    if (entry.settled) return;
-    entry.settled = true;
-    const wasRunning = entry.state === "running";
-    entry.state = state;
-    entry.cleanup();
-    if (state === "completed") {
-      completed += 1;
-    } else if (state === "failed") {
-      failed += 1;
-      lastError = errorMessage(value);
-    } else {
-      canceled += 1;
-      lastError = errorMessage(value ?? entry.signal.reason);
-    }
-    if (wasRunning) inFlight -= 1;
-    emitSnapshot();
-    try {
-      entry.onSettled?.();
-    } catch (err) {
-      lastError = errorMessage(err);
-    }
-    if (entry.mode === "request") {
-      if (state === "completed") entry.resolve(value);
-      else entry.reject(value);
-    }
-  }
-  function enqueueMessage(message, mode, signal, onSettled) {
-    total += 1;
-    const target = message.target;
-    if (!target) {
-      failed += 1;
-      lastError = `MessageBus.${mode === "request" ? "request" : "dispatch"} requires a target`;
-      emitSnapshot();
-      try {
-        onSettled?.();
-      } catch {
-      }
-      return mode === "request" ? Promise.reject(new Error(lastError)) : message.id;
-    }
-    const handler = routedHandlers.get(message.type);
-    if (!handler || handler.target !== target) {
-      failed += 1;
-      lastError = `No handler registered for type "${message.type}" at target "${target}"`;
-      emitSnapshot();
-      try {
-        onSettled?.();
-      } catch {
-      }
-      return mode === "request" ? Promise.reject(new Error(lastError)) : message.id;
-    }
-    if (signal?.aborted) {
-      canceled += 1;
-      lastError = errorMessage(signal.reason ?? new Error("aborted"));
-      emitSnapshot();
-      try {
-        onSettled?.();
-      } catch {
-      }
-      return mode === "request" ? Promise.reject(signal.reason ?? new Error("aborted")) : message.id;
-    }
-    const ctl = new AbortController();
-    let timeoutHandle;
-    const onUpstreamAbort = () => {
-      ctl.abort(signal?.reason ?? new Error("aborted"));
-    };
-    if (signal) {
-      signal.addEventListener("abort", onUpstreamAbort, { once: true });
-    }
-    if (typeof message.timeoutMs === "number" && message.timeoutMs > 0) {
-      timeoutHandle = setTimeout(() => {
-        ctl.abort(new Error("MessageBus.request timeout"));
-      }, message.timeoutMs);
-    }
-    const stamped = { ...message, signal: ctl.signal };
-    const mailbox = mailboxes.get(target) ?? [];
-    mailboxes.set(target, mailbox);
-    return new Promise((resolve, reject) => {
-      const entry = {
-        message: stamped,
-        signal: ctl.signal,
-        mode,
-        state: "queued",
-        settled: false,
-        resolve: (v) => resolve(v),
-        reject: (e) => reject(e),
-        onSettled,
-        cleanup: () => {
-          if (timeoutHandle) clearTimeout(timeoutHandle);
-          if (signal) signal.removeEventListener("abort", onUpstreamAbort);
-          ctl.signal.removeEventListener("abort", onAbort);
-        }
-      };
-      function onAbort() {
-        if (entry.state === "queued") {
-          const idx = mailbox.indexOf(entry);
-          if (idx >= 0) {
-            mailbox.splice(idx, 1);
-          }
-        }
-        settleEntry(entry, "canceled", ctl.signal.reason ?? new Error("aborted"));
-      }
-      ctl.signal.addEventListener("abort", onAbort, { once: true });
-      mailbox.push(entry);
-      emitSnapshot();
-      schedulePump(target);
-    });
-  }
-  function schedulePump(target) {
-    if (pumping.has(target)) return;
-    const mailbox = mailboxes.get(target);
-    if (!mailbox || mailbox.length === 0) return;
-    pumping.add(target);
-    if (typeof queueMicrotask === "function") {
-      queueMicrotask(() => {
-        void runPump(target);
-      });
-    } else {
-      Promise.resolve().then(() => {
-        void runPump(target);
-      });
-    }
-  }
-  async function runPump(target) {
-    const concurrency = targetConcurrency.get(target) ?? 1;
-    const workers = [];
-    for (let i = 0; i < concurrency; i += 1) {
-      workers.push(workerLoop(target));
-    }
-    try {
-      await Promise.all(workers);
-    } finally {
-      pumping.delete(target);
-      const mailbox = mailboxes.get(target);
-      if (mailbox && mailbox.length > 0) {
-        schedulePump(target);
-      }
-      emitSnapshot();
-    }
-  }
-  async function workerLoop(target, workerId) {
-    while (true) {
-      const entry = pickBestEntry(target);
-      if (!entry) return;
-      await processEntry(target, entry);
-    }
-  }
-  function pickBestEntry(target) {
-    const mailbox = mailboxes.get(target);
-    if (!mailbox || mailbox.length === 0) return void 0;
-    let bestIdx = -1;
-    let bestEntry;
-    for (let i = 0; i < mailbox.length; i += 1) {
-      const cur = mailbox[i];
-      if (cur.settled) continue;
-      if (!bestEntry) {
-        bestEntry = cur;
-        bestIdx = i;
-        continue;
-      }
-      const bestPriority = bestEntry.message.priority ?? 0;
-      const curPriority = cur.message.priority ?? 0;
-      if (curPriority > bestPriority || curPriority === bestPriority && cur.message.createdAt < bestEntry.message.createdAt) {
-        bestEntry = cur;
-        bestIdx = i;
-      }
-    }
-    if (bestEntry && bestIdx >= 0) {
-      mailbox.splice(bestIdx, 1);
-    }
-    return bestEntry;
-  }
-  async function processEntry(target, entry) {
-    if (entry.settled) return;
-    entry.state = "running";
-    inFlight += 1;
-    emitSnapshot();
-    const handler = routedHandlers.get(entry.message.type);
-    if (!handler) {
-      settleEntry(entry, "failed", new Error(`No handler for type "${entry.message.type}"`));
-      return;
-    }
-    try {
-      const result = handler.handler(entry.message);
-      if (result && typeof result.then === "function") {
-        const v = await waitForHandler(
-          result,
-          entry.signal
-        );
-        if (entry.signal.aborted) {
-          settleEntry(entry, "canceled", entry.signal.reason);
-        } else {
-          settleEntry(entry, "completed", v);
-        }
-      } else {
-        if (entry.signal.aborted) {
-          settleEntry(entry, "canceled", entry.signal.reason);
-        } else {
-          settleEntry(entry, "completed", result);
-        }
-      }
-    } catch (err) {
-      if (entry.signal.aborted) {
-        settleEntry(entry, "canceled", entry.signal.reason ?? err);
-      } else {
-        settleEntry(entry, "failed", err);
-      }
-    }
-  }
-  const bus = {
-    publish(type, payload, options) {
-      const message = makeMessage(type, "event", payload, {
-        causationId: options?.causationId,
-        messageId: options?.messageId
-      });
-      return publishInternal(message);
-    },
-    subscribe(type, handler) {
-      const record = { type, handler };
-      let bucket = subscriptions.get(type);
-      if (!bucket) {
-        bucket = /* @__PURE__ */ new Set();
-        subscriptions.set(type, bucket);
-      }
-      bucket.add(record);
-      return () => {
-        bucket?.delete(record);
-      };
-    },
-    dispatch(type, payload, options) {
-      const message = makeMessage(type, "command", payload, {
-        target: options.target,
-        priority: options.priority,
-        timeoutMs: options.timeoutMs,
-        causationId: options.causationId,
-        messageId: options.messageId
-      });
-      const result = enqueueMessage(message, "command", options.signal, options.onSettled);
-      if (typeof result === "string") return result;
-      return message.id;
-    },
-    request(type, payload, options) {
-      const message = makeMessage(type, "request", payload, {
-        target: options.target,
-        priority: options.priority,
-        timeoutMs: options.timeoutMs,
-        causationId: options.causationId,
-        messageId: options.messageId
-      });
-      const result = enqueueMessage(message, "request", options.signal, options.onSettled);
-      if (typeof result === "string") {
-        return Promise.reject(new Error("MessageBus.request returned a string id unexpectedly"));
-      }
-      return result;
-    },
-    handle(type, handler, options) {
-      const concurrency = options?.concurrency ?? 1;
-      if (!Number.isFinite(concurrency) || !Number.isInteger(concurrency) || concurrency <= 0) {
-        throw new Error("Handler concurrency must be a positive integer");
-      }
-      if (concurrency > MAX_HANDLER_CONCURRENCY) {
-        throw new Error(
-          `Handler concurrency must not exceed ${MAX_HANDLER_CONCURRENCY}`
-        );
-      }
-      const record = {
-        type,
-        target: options?.target ?? "",
-        priority: options?.priority ?? 0,
-        concurrency,
-        handler
-      };
-      if (routedHandlers.has(type)) {
-        throw new Error(`Handler for "${type}" is already registered`);
-      }
-      if (record.target) {
-        const existing = targetConcurrency.get(record.target);
-        if (existing !== void 0 && existing !== concurrency) {
-          throw new Error(`Conflicting concurrency for target "${record.target}"`);
-        }
-        targetConcurrency.set(record.target, concurrency);
-        targetHandlerCount.set(record.target, (targetHandlerCount.get(record.target) ?? 0) + 1);
-        if (!mailboxes.has(record.target)) {
-          mailboxes.set(record.target, []);
-        }
-        schedulePump(record.target);
-      }
-      routedHandlers.set(type, record);
-      return () => {
-        if (routedHandlers.get(type) === record) {
-          routedHandlers.delete(type);
-          if (record.target) {
-            const count = (targetHandlerCount.get(record.target) ?? 1) - 1;
-            if (count <= 0) {
-              targetHandlerCount.delete(record.target);
-              targetConcurrency.delete(record.target);
-            } else {
-              targetHandlerCount.set(record.target, count);
-            }
-          }
-        }
-      };
-    },
-    snapshot,
-    onSnapshot(handler) {
-      snapshotListeners.add(handler);
-      handler(snapshot());
-      return () => snapshotListeners.delete(handler);
-    }
-  };
-  return bus;
-}
-
-// src/lifecycle/resourceScope.ts
-function makeId(prefix) {
-  try {
-    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-      return `${prefix}:${crypto.randomUUID()}`;
-    }
-  } catch {
-  }
-  return `${prefix}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-}
-function errorMessage2(error) {
-  if (error instanceof Error) return error.message;
-  return typeof error === "string" ? error : String(error);
-}
-function isPositiveFiniteNumber(value) {
-  return value !== void 0 && Number.isFinite(value) && value >= 0;
-}
-function createLifecycleScope(options) {
-  const identity = {
-    scopeId: options.scopeId ?? makeId(`scope:${options.kind}`),
-    instanceId: options.instanceId ?? makeId("instance"),
-    kind: options.kind,
-    attributes: {},
-    ...options.metadata
-  };
-  const controller = new AbortController();
-  const revokeListeners = /* @__PURE__ */ new Set();
-  const entries = /* @__PURE__ */ new Map();
-  const usedIds = /* @__PURE__ */ new Set();
-  let currentState = "active";
-  let revokeReason = "scope revoked";
-  let disposalPromise;
-  let refreshPublishedDisposeResult;
-  const disposeResultNotifier = options.onDisposeResult;
-  const notifyChange = (scope) => {
-    try {
-      options.onChange?.(scope);
-    } catch {
-    }
-  };
-  const publicScope = {};
-  function uniqueResourceId(resourceId) {
-    const base = resourceId && resourceId.length > 0 ? resourceId : makeId("resource");
-    if (!usedIds.has(base)) {
-      usedIds.add(base);
-      return base;
-    }
-    let index = 2;
-    while (usedIds.has(`${base}#${index}`)) index += 1;
-    const unique2 = `${base}#${index}`;
-    usedIds.add(unique2);
-    return unique2;
-  }
-  function assertActive() {
-    if (currentState !== "active") {
-      throw new LifecycleScopeRevokedError(
-        `Lifecycle scope "${identity.scopeId}" is ${currentState}`
-      );
-    }
-  }
-  function addEntry(resourceId, cleanup, state, removeOnFailure = false, phase = "before-teardown") {
-    assertActive();
-    const entry = {
-      resourceId: uniqueResourceId(resourceId),
-      state,
-      cleanup,
-      phase,
-      cleanupStarted: false,
-      cleanupFinished: false,
-      removeOnFailure
-    };
-    entries.set(entry.resourceId, entry);
-    notifyChange(publicScope);
-    return entry;
-  }
-  function releaseEntry(entry, reason) {
-    if (entry.cleanupPromise) return entry.cleanupPromise;
-    entry.cleanupStarted = true;
-    entry.cleanupPromise = Promise.resolve().then(() => entry.cleanup(reason)).then(() => {
-      entry.cleanupFinished = true;
-      if (!entry.lateReleaseFailed) {
-        entry.state = "released";
-        entry.error = void 0;
-      }
-      notifyChange(publicScope);
-    }).catch((error) => {
-      entry.cleanupFinished = true;
-      entry.state = "pending";
-      entry.error = errorMessage2(error);
-      notifyChange(publicScope);
-      throw error;
-    });
-    entry.cleanupPromise.catch(() => void 0);
-    return entry.cleanupPromise;
-  }
-  function track(resource, release, resourceId) {
-    if (currentState !== "active") {
-      void Promise.resolve().then(() => release(resource, revokeReason)).catch(() => void 0);
-      throw new LifecycleScopeRevokedError();
-    }
-    let released = false;
-    addEntry(
-      resourceId,
-      async (reason) => {
-        if (released) return;
-        released = true;
-        await release(resource, reason);
-      },
-      "active"
-    );
-    return resource;
-  }
-  function acquire(resourceId, create, release) {
-    assertActive();
-    let resource;
-    let hasResource = false;
-    let released = false;
-    let resolveAcquisition;
-    let rejectAcquisition;
-    let acquisitionSettled = false;
-    const acquisitionDone = new Promise((resolve, reject) => {
-      resolveAcquisition = () => {
-        if (acquisitionSettled) return;
-        acquisitionSettled = true;
-        resolve();
-      };
-      rejectAcquisition = (error) => {
-        if (acquisitionSettled) return;
-        acquisitionSettled = true;
-        reject(error);
-      };
-    });
-    acquisitionDone.catch(() => void 0);
-    const entry = addEntry(
-      resourceId,
-      async (reason) => {
-        await acquisitionDone;
-        if (!hasResource || released) return;
-        released = true;
-        await release(resource, reason);
-      },
-      "acquiring",
-      true,
-      "before-teardown"
-    );
-    entry.acquisitionDone = acquisitionDone;
-    return Promise.resolve().then(() => create(controller.signal)).then(async (created) => {
-      resource = created;
-      hasResource = true;
-      if (currentState !== "active" || controller.signal.aborted || entry.cleanupStarted) {
-        if (!released) {
-          released = true;
-          try {
-            await release(created, revokeReason);
-          } catch (error) {
-            entry.lateReleaseFailed = true;
-            entry.state = "pending";
-            entry.error = errorMessage2(error);
-            notifyChange(publicScope);
-            rejectAcquisition(error);
-            throw error;
-          }
-        }
-        entry.state = "released";
-        resolveAcquisition();
-        notifyChange(publicScope);
-        throw new LifecycleScopeRevokedError(
-          `Resource "${entry.resourceId}" completed after scope revoke`
-        );
-      }
-      entry.state = "active";
-      entry.removeOnFailure = false;
-      resolveAcquisition();
-      notifyChange(publicScope);
-      return created;
-    }).catch((error) => {
-      if (!hasResource) {
-        resolveAcquisition();
-        entries.delete(entry.resourceId);
-        usedIds.delete(entry.resourceId);
-      }
-      throw error;
-    });
-  }
-  function onDispose(cleanup, resourceId, phase = "before-teardown") {
-    if (currentState !== "active") {
-      void Promise.resolve().then(() => cleanup(revokeReason)).catch(() => void 0);
-      return () => void 0;
-    }
-    const entry = addEntry(resourceId, cleanup, "active", false, phase);
-    return () => {
-      if (entry.cleanupStarted || entry.cleanupFinished) return;
-      entries.delete(entry.resourceId);
-      usedIds.delete(entry.resourceId);
-      notifyChange(publicScope);
-    };
-  }
-  function onRevoke(listener) {
-    if (currentState === "active") {
-      revokeListeners.add(listener);
-      return () => revokeListeners.delete(listener);
-    }
-    try {
-      listener(revokeReason);
-    } catch {
-    }
-    return () => void 0;
-  }
-  function revoke(reason = "scope revoked") {
-    if (currentState !== "active") return;
-    revokeReason = reason;
-    currentState = "stopping";
-    try {
-      controller.abort(new LifecycleScopeRevokedError(reason));
-    } catch {
-      controller.abort();
-    }
-    for (const listener of [...revokeListeners]) {
-      try {
-        listener(reason);
-      } catch {
-      }
-    }
-    notifyChange(publicScope);
-  }
-  async function runEntry(entry, reason, timeoutMs, issues, onLateSuccess, onLateFailure) {
-    if (entry.cleanupFinished && entry.state === "released") return "released";
-    const cleanup = releaseEntry(entry, reason);
-    if (!isPositiveFiniteNumber(timeoutMs)) {
-      try {
-        await cleanup;
-        return entry.state === "released" ? "released" : "pending";
-      } catch (error) {
-        issues.push({
-          resourceId: entry.resourceId,
-          code: "lifecycle.cleanup_failed",
-          message: errorMessage2(error)
-        });
-        return "pending";
-      }
-    }
-    let timeoutHandle;
-    const timeout = new Promise((resolve) => {
-      timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs);
-    });
-    const result = await Promise.race([
-      cleanup.then(() => "released", (error) => ({ error })),
-      timeout
-    ]);
-    if (timeoutHandle) clearTimeout(timeoutHandle);
-    if (result === "timeout") {
-      entry.state = "pending";
-      issues.push({
-        resourceId: entry.resourceId,
-        code: "lifecycle.cleanup_timeout",
-        message: `Cleanup timed out after ${timeoutMs}ms`
-      });
-      void cleanup.then(
-        () => {
-          try {
-            onLateSuccess?.(entry);
-          } catch {
-          }
-        },
-        (error) => {
-          try {
-            onLateFailure?.(entry, error);
-          } catch {
-          }
-        }
-      );
-      return "pending";
-    }
-    if (result === "released") return "released";
-    entry.state = "pending";
-    issues.push({
-      resourceId: entry.resourceId,
-      code: "lifecycle.cleanup_failed",
-      message: errorMessage2(result.error)
-    });
-    return "pending";
-  }
-  async function dispose(options2 = {}) {
-    if (disposalPromise) return disposalPromise;
-    revoke(options2.reason ?? "scope disposed");
-    const reason = options2.reason ?? revokeReason;
-    const entriesToRelease = [...entries.values()].reverse();
-    disposalPromise = (async () => {
-      const errors = [];
-      const pending = /* @__PURE__ */ new Set();
-      const lateReleased = /* @__PURE__ */ new Set();
-      let released = 0;
-      let attempted = 0;
-      let resultSnapshot;
-      let resultPublished = false;
-      const publishDisposeResult = () => {
-        if (!resultPublished || !resultSnapshot) return;
-        try {
-          disposeResultNotifier?.(resultSnapshot);
-        } catch {
-        }
-      };
-      const rebuildResultSnapshot = () => {
-        if (!resultSnapshot) return;
-        const mergedPending = new Set(pending);
-        const mergedErrors = [...errors];
-        let mergedAttempted = attempted;
-        let mergedReleased = released;
-        for (const childEntry of entries.values()) {
-          const childScope = childEntry.childScope;
-          const childResult = childEntry.childResult;
-          if (!childScope || !childResult) continue;
-          const prefix = `child:${childScope.identity.scopeId}:`;
-          mergedAttempted += childResult.attempted;
-          mergedReleased += childResult.released;
-          for (const resourceId of childResult.pending) {
-            mergedPending.add(`${prefix}${resourceId}`);
-          }
-          for (const issue of childResult.errors) {
-            mergedErrors.push({
-              ...issue,
-              resourceId: `${prefix}${issue.resourceId}`
-            });
-          }
-        }
-        resultSnapshot.attempted = mergedAttempted;
-        resultSnapshot.released = mergedReleased;
-        resultSnapshot.pending = [...mergedPending];
-        resultSnapshot.errors = mergedErrors;
-        resultSnapshot.cleanupIncomplete = mergedPending.size > 0 || mergedErrors.length > 0;
-      };
-      const projectChildResult = (entry, childResult, lateResourceId, lateError) => {
-        if (!entry.childScope) return;
-        const previous = entry.childResult;
-        entry.childResult = childResult;
-        entry.state = childResult.cleanupIncomplete ? "pending" : "released";
-        entry.error = childResult.cleanupIncomplete ? childResult.errors[0]?.message ?? "Child scope cleanup is still pending" : void 0;
-        rebuildResultSnapshot();
-        publishDisposeResult();
-        if (lateResourceId && resultSnapshot) {
-          const resourceId = `child:${entry.childScope.identity.scopeId}:${lateResourceId}`;
-          try {
-            if (lateError !== void 0) options2.onLateFailure?.(resourceId, lateError, resultSnapshot);
-            else options2.onLateSuccess?.(resourceId, resultSnapshot);
-          } catch {
-          }
-        } else if (previous?.cleanupIncomplete && !childResult.cleanupIncomplete && resultSnapshot) {
-          try {
-            options2.onLateSuccess?.(`child:${entry.childScope.identity.scopeId}`, resultSnapshot);
-          } catch {
-          }
-        }
-        notifyChange(publicScope);
-      };
-      refreshPublishedDisposeResult = () => {
-        if (!resultPublished || !resultSnapshot) return;
-        rebuildResultSnapshot();
-        publishDisposeResult();
-      };
-      const onLateFailure = (entry, error) => {
-        entry.state = "pending";
-        entry.error = errorMessage2(error);
-        if (!errors.some((issue) => issue.resourceId === entry.resourceId && issue.code === "lifecycle.cleanup_failed")) {
-          errors.push({
-            resourceId: entry.resourceId,
-            code: "lifecycle.cleanup_failed",
-            message: errorMessage2(error)
-          });
-        }
-        pending.add(entry.resourceId);
-        if (resultSnapshot) {
-          rebuildResultSnapshot();
-        }
-        publishDisposeResult();
-        try {
-          options2.onLateFailure?.(entry.resourceId, error, resultSnapshot);
-        } catch {
-        }
-        notifyChange(publicScope);
-      };
-      const onLateSuccess = (entry) => {
-        if (lateReleased.has(entry.resourceId)) return;
-        lateReleased.add(entry.resourceId);
-        pending.delete(entry.resourceId);
-        released += 1;
-        for (let index = errors.length - 1; index >= 0; index -= 1) {
-          const issue = errors[index];
-          if (issue?.resourceId === entry.resourceId && issue.code === "lifecycle.cleanup_timeout") {
-            errors.splice(index, 1);
-          }
-        }
-        if (resultSnapshot) {
-          rebuildResultSnapshot();
-        }
-        publishDisposeResult();
-        try {
-          options2.onLateSuccess?.(entry.resourceId, resultSnapshot);
-        } catch {
-        }
-        notifyChange(publicScope);
-      };
-      const releasePhase = async (phase) => {
-        for (const entry of entriesToRelease.filter((item) => item.phase === phase)) {
-          if (entry.childScope) {
-            entry.cleanupStarted = true;
-            try {
-              const childResult = await entry.childScope.dispose({
-                reason,
-                timeoutMs: options2.timeoutMs,
-                onLateSuccess: (resourceId, result2) => {
-                  if (result2) projectChildResult(entry, result2, resourceId);
-                },
-                onLateFailure: (resourceId, error, result2) => {
-                  if (result2) projectChildResult(entry, result2, resourceId, error);
-                }
-              });
-              entry.cleanupFinished = true;
-              projectChildResult(entry, childResult);
-            } catch (error) {
-              entry.cleanupFinished = true;
-              entry.state = "pending";
-              entry.error = errorMessage2(error);
-              pending.add(entry.resourceId);
-              errors.push({
-                resourceId: entry.resourceId,
-                code: "lifecycle.cleanup_failed",
-                message: errorMessage2(error)
-              });
-              notifyChange(publicScope);
-            }
-            continue;
-          }
-          attempted += 1;
-          const result = await runEntry(entry, reason, options2.timeoutMs, errors, onLateSuccess, onLateFailure);
-          if (result === "released") released += 1;
-          else if (!lateReleased.has(entry.resourceId)) pending.add(entry.resourceId);
-        }
-      };
-      await releasePhase("before-teardown");
-      if (options2.teardown) {
-        const teardownEntry = {
-          resourceId: "scope:teardown",
-          state: "active",
-          cleanup: options2.teardown,
-          phase: "before-teardown",
-          cleanupStarted: false,
-          cleanupFinished: false,
-          removeOnFailure: false
-        };
-        attempted += 1;
-        const result = await runEntry(teardownEntry, reason, options2.timeoutMs, errors, onLateSuccess, onLateFailure);
-        if (result === "released") released += 1;
-        else if (!lateReleased.has(teardownEntry.resourceId)) pending.add(teardownEntry.resourceId);
-      }
-      await releasePhase("after-teardown");
-      currentState = "stopped";
-      notifyChange(publicScope);
-      resultSnapshot = {
-        scopeId: identity.scopeId,
-        state: "stopped",
-        attempted,
-        released,
-        pending: [...pending],
-        errors,
-        cleanupIncomplete: pending.size > 0 || errors.length > 0
-      };
-      rebuildResultSnapshot();
-      resultPublished = true;
-      publishDisposeResult();
-      return resultSnapshot;
-    })();
-    return disposalPromise;
-  }
-  function resources() {
-    return [...entries.values()].map((entry) => ({
-      resourceId: entry.resourceId,
-      state: entry.state,
-      ...entry.error ? { error: entry.error } : {}
-    }));
-  }
-  function child(kind, metadata = {}) {
-    assertActive();
-    let childEntry;
-    const childScope = createLifecycleScope({
-      kind,
-      metadata: {
-        ...metadata,
-        parentScopeId: identity.scopeId
-      },
-      // 父作用域的 Host 订阅者也必须看到子作用域资源的状态变化。
-      onChange: () => notifyChange(publicScope),
-      // 只有子作用域已经生成最终结果后，父级才允许更新/删除登记。
-      onDisposeResult: (result) => {
-        const entry2 = childEntry;
-        if (!entry2) return;
-        entry2.childResult = result;
-        entry2.state = result.cleanupIncomplete ? "pending" : "released";
-        entry2.error = result.cleanupIncomplete ? result.errors[0]?.message ?? "Child scope cleanup is still pending" : void 0;
-        refreshPublishedDisposeResult?.();
-        if (!result.cleanupIncomplete && !disposalPromise && !entry2.cleanupStarted) {
-          entries.delete(entry2.resourceId);
-          usedIds.delete(entry2.resourceId);
-        }
-        notifyChange(publicScope);
-      }
-    });
-    const removeRevoke = onRevoke((reason) => childScope.revoke(reason));
-    const entry = addEntry(`child:${childScope.identity.scopeId}`, async () => void 0, "active");
-    childEntry = entry;
-    entry.childScope = childScope;
-    childScope.onDispose(() => {
-      removeRevoke();
-    }, `parent-link:${identity.scopeId}`);
-    return childScope;
-  }
-  Object.assign(publicScope, {
-    identity,
-    signal: controller.signal,
-    onRevoke,
-    onDispose,
-    track,
-    acquire,
-    child,
-    revoke,
-    dispose,
-    assertActive,
-    resources
-  });
-  Object.defineProperty(publicScope, "state", {
-    enumerable: true,
-    configurable: false,
-    get: () => currentState
-  });
-  return publicScope;
-}
-var createResourceScope = createLifecycleScope;
-
-// src/lifecycle/scopedMessageBus.ts
-function mergeSignals(scopeSignal, requestSignal) {
-  if (!requestSignal) return { signal: scopeSignal, dispose: () => void 0 };
-  if (scopeSignal.aborted) {
-    const controller2 = new AbortController();
-    controller2.abort(scopeSignal.reason);
-    return { signal: controller2.signal, dispose: () => void 0 };
-  }
-  if (requestSignal.aborted) {
-    const controller2 = new AbortController();
-    controller2.abort(requestSignal.reason);
-    return { signal: controller2.signal, dispose: () => void 0 };
-  }
-  const controller = new AbortController();
-  const abortFrom = (source) => {
-    try {
-      controller.abort(source.reason);
-    } catch {
-      controller.abort();
-    }
-  };
-  const onScopeAbort = () => abortFrom(scopeSignal);
-  const onRequestAbort = () => abortFrom(requestSignal);
-  scopeSignal.addEventListener("abort", onScopeAbort, { once: true });
-  requestSignal.addEventListener("abort", onRequestAbort, { once: true });
-  return {
-    signal: controller.signal,
-    dispose: () => {
-      scopeSignal.removeEventListener("abort", onScopeAbort);
-      requestSignal.removeEventListener("abort", onRequestAbort);
-    }
-  };
-}
-function withScopeCleanup(scope, cleanup) {
-  let active = true;
-  let removeRevoke = () => void 0;
-  let removeDispose = () => void 0;
-  const runCleanup = () => {
-    if (!active) return;
-    active = false;
-    removeRevoke();
-    removeDispose();
-    cleanup();
-  };
-  removeRevoke = scope.onRevoke(runCleanup);
-  removeDispose = scope.onDispose(runCleanup, "message-bus-registration");
-  return () => {
-    if (!active) return;
-    active = false;
-    removeRevoke();
-    removeDispose();
-    cleanup();
-  };
-}
-function createScopedMessageBus(base, scope) {
-  return {
-    publish(type, payload, options) {
-      scope.assertActive();
-      return base.publish(type, payload, options);
-    },
-    subscribe(type, handler) {
-      scope.assertActive();
-      const unsubscribe = base.subscribe(type, (payload) => {
-        if (scope.state !== "active") return;
-        handler(payload);
-      });
-      return withScopeCleanup(scope, unsubscribe);
-    },
-    dispatch(type, payload, options) {
-      scope.assertActive();
-      const merged = mergeSignals(scope.signal, options.signal);
-      const cleanup = withScopeCleanup(scope, merged.dispose);
-      try {
-        return base.dispatch(type, payload, {
-          ...options,
-          signal: merged.signal,
-          onSettled: () => {
-            cleanup();
-            options.onSettled?.();
-          }
-        });
-      } catch (error) {
-        cleanup();
-        throw error;
-      }
-    },
-    request(type, payload, options) {
-      scope.assertActive();
-      const merged = mergeSignals(scope.signal, options.signal);
-      const cleanup = withScopeCleanup(scope, merged.dispose);
-      try {
-        const request = base.request(type, payload, {
-          ...options,
-          signal: merged.signal,
-          onSettled: () => {
-            cleanup();
-            options.onSettled?.();
-          }
-        });
-        return request.finally(cleanup);
-      } catch (error) {
-        cleanup();
-        return Promise.reject(error);
-      }
-    },
-    handle(type, handler, options) {
-      scope.assertActive();
-      const scopedHandler = (message) => {
-        if (scope.state !== "active") {
-          throw new LifecycleScopeRevokedError(
-            `Lifecycle scope "${scope.identity.scopeId}" is ${scope.state}`
-          );
-        }
-        const merged = mergeSignals(scope.signal, message.signal);
-        try {
-          const result = handler({ ...message, signal: merged.signal });
-          if (result && typeof result.then === "function") {
-            return Promise.resolve(result).finally(merged.dispose);
-          }
-          merged.dispose();
-          return result;
-        } catch (error) {
-          merged.dispose();
-          throw error;
-        }
-      };
-      const unregister = base.handle(type, scopedHandler, options);
-      return withScopeCleanup(scope, unregister);
-    },
-    snapshot() {
-      return base.snapshot();
-    },
-    onSnapshot(handler) {
-      scope.assertActive();
-      const unsubscribe = base.onSnapshot(handler);
-      return withScopeCleanup(scope, unsubscribe);
-    }
-  };
-}
-
-// src/lifecycle/permissionLease.ts
-function uniquePermissions(permissions) {
-  return [...new Set(permissions ?? [])];
-}
-function sameBindingValue(actual, expected) {
-  return expected === void 0 || actual === expected;
-}
-function sameAttributes(actual, expected) {
-  if (expected === void 0) return true;
-  return Object.keys(expected).every((key) => Object.is(actual[key], expected[key]));
-}
-function normalizedRevision(value, name) {
-  if (value === void 0) return void 0;
-  if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${name} must be a non-negative safe integer`);
-  return value;
-}
-function createPermissionLease(options) {
-  const binding = {
-    ...options.identity,
-    requested: Object.freeze(uniquePermissions(options.requested)),
-    approved: Object.freeze(uniquePermissions(options.approved)),
-    ...options.sessionConstraints ? { sessionConstraints: Object.freeze(uniquePermissions(options.sessionConstraints)) } : {},
-    ...options.policyRevision !== void 0 ? { policyRevision: normalizedRevision(options.policyRevision, "policyRevision") } : {},
-    ...options.grantRevision !== void 0 ? { grantRevision: normalizedRevision(options.grantRevision, "grantRevision") } : {},
-    ...options.grantId !== void 0 ? { grantId: options.grantId } : {}
-  };
-  Object.freeze(binding);
-  const granted = new Set(
-    binding.requested.filter(
-      (permission) => binding.approved.includes(permission) && (binding.sessionConstraints === void 0 || binding.sessionConstraints.includes(permission))
-    )
-  );
-  let revoked = false;
-  let revokeReason = "permission lease revoked";
-  const lease = {
-    binding,
-    get revoked() {
-      return revoked || options.scope !== void 0 && options.scope.state !== "active";
-    },
-    has(permission) {
-      return !lease.revoked && granted.has(permission);
-    },
-    assert(permission) {
-      if (lease.revoked) {
-        throw new PermissionLeaseRevokedError(revokeReason);
-      }
-      if (!granted.has(permission)) {
-        throw new PermissionDeniedError(permission);
-      }
-    },
-    assertBinding(expected) {
-      if (!sameBindingValue(binding.pluginId, expected.pluginId) || !sameBindingValue(binding.instanceId, expected.instanceId) || !sameAttributes(binding.attributes, expected.attributes) || !sameBindingValue(binding.policyRevision, expected.policyRevision) || !sameBindingValue(binding.grantRevision, expected.grantRevision) || !sameBindingValue(binding.grantId, expected.grantId)) {
-        throw new PermissionLeaseRevokedError("Permission lease identity does not match");
-      }
-      if (lease.revoked) throw new PermissionLeaseRevokedError(revokeReason);
-    },
-    revoke(reason = "permission lease revoked") {
-      if (revoked) return;
-      revoked = true;
-      revokeReason = reason;
-    }
-  };
-  if (options.scope) {
-    options.scope.onRevoke((reason) => lease.revoke(reason));
-    options.scope.onDispose((reason) => lease.revoke(reason), "permission-lease");
-  }
-  return lease;
-}
-
-// src/lifecycle/taskScheduler.ts
-function errorMessage3(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function createScopedTaskScheduler(scope, options = {}) {
-  const tasks = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Set();
-  let disposed = false;
-  const notify = () => {
-    const value = [...tasks.values()].map((task) => ({
-      id: task.definition.id,
-      pluginId: task.definition.pluginId ?? scope.identity.pluginId ?? "unknown",
-      label: task.definition.label,
-      state: task.state,
-      ...task.error ? { error: task.error } : {},
-      ...task.lastCompletedAt ? { lastCompletedAt: task.lastCompletedAt } : {},
-      ...task.nextRunAt ? { nextRunAt: task.nextRunAt } : {}
-    }));
-    for (const listener of [...listeners]) {
-      try {
-        listener(value);
-      } catch {
-      }
-    }
-  };
-  const clearTimer = (task) => {
-    if (task.timer !== void 0) {
-      clearTimeout(task.timer);
-      task.timer = void 0;
-    }
-    task.nextRunAt = void 0;
-  };
-  const schedule = (task) => {
-    clearTimer(task);
-    const intervalMs = task.definition.intervalMs;
-    if (!task.active || disposed || intervalMs === void 0) {
-      notify();
-      return;
-    }
-    if (!Number.isFinite(intervalMs) || intervalMs < 0) {
-      task.error = "\u4EFB\u52A1 intervalMs \u5FC5\u987B\u662F\u975E\u8D1F\u6709\u9650\u6570";
-      task.state = "failed";
-      notify();
-      return;
-    }
-    const dueAt = Date.now() + intervalMs;
-    task.nextRunAt = new Date(dueAt).toISOString();
-    task.timer = setTimeout(() => {
-      task.timer = void 0;
-      task.nextRunAt = void 0;
-      void runTask(task, "interval");
-    }, intervalMs);
-    notify();
-  };
-  const runTask = async (task, reason) => {
-    if (!task.active || disposed || scope.state !== "active") return;
-    if (task.runPromise) {
-      task.rerunRequested = true;
-      return task.runPromise;
-    }
-    task.state = "queued";
-    task.error = void 0;
-    notify();
-    const run = (async () => {
-      let requestScope;
-      let controller;
-      let abortFromScope;
-      try {
-        requestScope = scope.child("request");
-        controller = new AbortController();
-        task.controller = controller;
-        abortFromScope = () => controller?.abort(scope.signal.reason);
-        if (scope.signal.aborted) abortFromScope();
-        else scope.signal.addEventListener("abort", abortFromScope, { once: true });
-        task.state = "running";
-        notify();
-        await task.definition.run({ signal: controller.signal, reason });
-        if (!controller.signal.aborted && !requestScope.signal.aborted) {
-          task.state = "idle";
-          task.error = void 0;
-          task.lastCompletedAt = (/* @__PURE__ */ new Date()).toISOString();
-        } else {
-          task.state = "idle";
-        }
-      } catch (error) {
-        task.state = "failed";
-        task.error = controller?.signal.aborted ? void 0 : errorMessage3(error);
-      } finally {
-        if (abortFromScope) scope.signal.removeEventListener("abort", abortFromScope);
-        task.controller = void 0;
-        if (requestScope) {
-          await requestScope.dispose({ reason: `task ${task.definition.id} finished` });
-        }
-        if (task.active && !disposed && scope.state === "active") schedule(task);
-        else clearTimer(task);
-        notify();
-      }
-    })();
-    task.runPromise = run;
-    try {
-      await run;
-    } finally {
-      task.runPromise = void 0;
-      notify();
-      if (task.rerunRequested && task.active && !disposed && scope.state === "active") {
-        task.rerunRequested = false;
-        queueMicrotask(() => {
-          void runTask(task, "coalesced");
-        });
-      }
-    }
-  };
-  const releaseTask = async (task, reason) => {
-    if (!task.active) return;
-    task.active = false;
-    task.rerunRequested = false;
-    clearTimer(task);
-    task.controller?.abort(reason);
-    if (task.runPromise) await task.runPromise;
-    tasks.delete(task.definition.id);
-    notify();
-  };
-  const scheduler = {
-    register(definition) {
-      scope.assertActive();
-      if (!definition.id || tasks.has(definition.id)) {
-        throw new Error(`Scoped task id "${definition.id}" is already registered or empty`);
-      }
-      const task = {
-        definition: { ...definition },
-        state: "idle",
-        rerunRequested: false,
-        active: true
-      };
-      tasks.set(definition.id, task);
-      const removeScopeCleanup = scope.onDispose(
-        (reason) => releaseTask(task, reason),
-        `task:${definition.id}`
-      );
-      const unregister = () => {
-        if (!task.active) return;
-        removeScopeCleanup();
-        void releaseTask(task, "task unregistered");
-      };
-      schedule(task);
-      if (options.runOnRegister) void runTask(task, "initial");
-      return unregister;
-    },
-    async runNow(id, reason = "manual") {
-      const task = tasks.get(id);
-      if (!task) throw new Error(`Scoped task "${id}" is not registered`);
-      await runTask(task, reason);
-    },
-    async cancel(id) {
-      const task = tasks.get(id);
-      if (!task) return;
-      task.rerunRequested = false;
-      task.controller?.abort("task canceled");
-      if (task.runPromise) await task.runPromise;
-    },
-    snapshot() {
-      return [...tasks.values()].map((task) => ({
-        id: task.definition.id,
-        pluginId: task.definition.pluginId ?? scope.identity.pluginId ?? "unknown",
-        label: task.definition.label,
-        state: task.state,
-        ...task.error ? { error: task.error } : {},
-        ...task.lastCompletedAt ? { lastCompletedAt: task.lastCompletedAt } : {},
-        ...task.nextRunAt ? { nextRunAt: task.nextRunAt } : {}
-      }));
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      listener(scheduler.snapshot());
-      return () => listeners.delete(listener);
-    },
-    async dispose() {
-      if (disposed) return;
-      disposed = true;
-      for (const task of [...tasks.values()]) {
-        task.controller?.abort("task scheduler disposed");
-        clearTimer(task);
-      }
-      await Promise.all([...tasks.values()].map((task) => releaseTask(task, "task scheduler disposed")));
-      listeners.clear();
-    }
-  };
-  return scheduler;
-}
-
-// src/resources/resourceRegistry.ts
-function createResourceRegistry() {
-  const definitions = /* @__PURE__ */ new Map();
-  function registerOwned(ownerId, definition) {
-    if (definitions.has(definition.id)) {
-      throw new Error(
-        `Resource definition "${definition.id}" is already registered`
-      );
-    }
-    const owned = Object.assign({}, definition);
-    Object.defineProperty(owned, RESOURCE_OWNER, {
-      value: ownerId,
-      enumerable: false,
-      writable: false,
-      configurable: false
-    });
-    definitions.set(definition.id, owned);
-  }
-  return {
-    _registerOwned: registerOwned,
-    register(definition) {
-      registerOwned("", definition);
-    },
-    unregister(id) {
-      definitions.delete(id);
-    },
-    get(id) {
-      return definitions.get(id);
-    },
-    /** 获取所有已注册的资源定义 id（用于 ownership 快照） */
-    _ids() {
-      return Array.from(definitions.keys());
-    }
-  };
-}
-function registerOwnedResource(registry, ownerId, definition) {
-  const internal = registry;
-  if (!internal._registerOwned) {
-    registry.register(definition);
-    return;
-  }
-  internal._registerOwned(ownerId, definition);
-}
-
-// src/resources/resourceStore.ts
-function createContext(ownerId, getCapability, getAttributes) {
-  return {
-    getCapability,
-    attributes: getAttributes(ownerId),
-    ownerId
-  };
-}
-function recordKey(definitionId, key) {
-  return `${definitionId}::${key.join("::")}`;
-}
-function defaultEquals(a, b) {
-  return Object.is(a, b);
-}
-function createResourceStore(registry, getCapability, getAttributes = () => ({})) {
-  const records = /* @__PURE__ */ new Map();
-  const microtaskQueue = /* @__PURE__ */ new Map();
-  const contextSubscribers = /* @__PURE__ */ new Set();
-  let microtaskScheduled = false;
-  const notify = (record) => {
-    for (const subscriber of [...record.subscribers]) {
-      try {
-        subscriber();
-      } catch {
-      }
-    }
-  };
-  const notifyContext = () => {
-    for (const subscriber of [...contextSubscribers]) {
-      try {
-        subscriber();
-      } catch {
-      }
-    }
-  };
-  const cleanupRecord = (record) => {
-    record.abortController?.abort();
-    record.providerUnsubscribe?.();
-    record.providerUnsubscribe = null;
-  };
-  const contextFor = (definition) => createContext(
-    definition[RESOURCE_OWNER] ?? "__unowned__",
-    getCapability,
-    getAttributes
-  );
-  const getOrCreateRecord = (definition, args) => {
-    const context = contextFor(definition);
-    const key = definition.key(args, context);
-    const keyString = recordKey(definition.id, key);
-    const current = records.get(keyString);
-    if (current) {
-      if (definition.subscribe && !current.providerUnsubscribe) {
-        current.providerUnsubscribe = definition.subscribe(args, context, () => {
-          scheduleInvalidation(definition.id, args);
-        });
-      }
-      return current;
-    }
-    const record = {
-      snapshot: { key, status: "pending", data: void 0, revision: 0 },
-      inFlight: null,
-      abortController: null,
-      subscribers: /* @__PURE__ */ new Set(),
-      invalidationScheduled: false,
-      loadRevision: 0,
-      owner: definition[RESOURCE_OWNER] ?? "__unowned__",
-      providerUnsubscribe: null
-    };
-    records.set(keyString, record);
-    if (definition.subscribe) {
-      record.providerUnsubscribe = definition.subscribe(args, context, () => {
-        scheduleInvalidation(definition.id, args);
-      });
-    }
-    return record;
-  };
-  const loadResource = (definition, args, record) => {
-    record.abortController?.abort();
-    const context = contextFor(definition);
-    const key = definition.key(args, context);
-    if (record.snapshot.key.join("::") !== key.join("::")) return;
-    const abortController = new AbortController();
-    const loadRevision = ++record.loadRevision;
-    record.abortController = abortController;
-    try {
-      record.inFlight = Promise.resolve(definition.load(args, context, abortController.signal));
-    } catch (error) {
-      record.inFlight = Promise.reject(error);
-    }
-    record.snapshot = { ...record.snapshot, status: "pending", revision: record.snapshot.revision + 1 };
-    notify(record);
-    record.inFlight.then((data) => {
-      if (abortController.signal.aborted || record.loadRevision !== loadRevision) return;
-      if (record.snapshot.key.join("::") !== key.join("::")) return;
-      const equals = definition.equals ?? defaultEquals;
-      const changed = !equals(record.snapshot.data, data);
-      record.snapshot = {
-        key,
-        status: "ready",
-        data,
-        revision: changed ? record.snapshot.revision + 1 : record.snapshot.revision
-      };
-      record.inFlight = null;
-      record.abortController = null;
-      if (changed) notify(record);
-    }).catch((error) => {
-      if (abortController.signal.aborted || record.loadRevision !== loadRevision) return;
-      const blocked = error instanceof Error && error.message === "blocked";
-      const errorValue = error instanceof Error ? error : new Error(String(error));
-      record.snapshot = blocked ? { ...record.snapshot, status: "blocked", revision: record.snapshot.revision + 1 } : {
-        ...record.snapshot,
-        status: record.snapshot.data === void 0 ? "error" : "stale",
-        error: {
-          code: typeof errorValue.code === "string" ? String(errorValue.code) : "resource.load_failed",
-          message: errorValue.message
-        },
-        revision: record.snapshot.revision + 1
-      };
-      record.inFlight = null;
-      record.abortController = null;
-      notify(record);
-    });
-  };
-  const invalidateNow = (definitionId, args) => {
-    const definition = registry.get(definitionId);
-    if (!definition) return;
-    const context = contextFor(definition);
-    const key = definition.key(args, context);
-    const record = records.get(recordKey(definitionId, key));
-    if (!record) return;
-    record.snapshot = { ...record.snapshot, status: "stale", revision: record.snapshot.revision + 1 };
-    notify(record);
-    loadResource(definition, args, record);
-  };
-  const flushInvalidations = () => {
-    const queue = [...microtaskQueue.values()];
-    microtaskQueue.clear();
-    microtaskScheduled = false;
-    for (const item of queue) invalidateNow(item.definitionId, item.args);
-  };
-  const scheduleInvalidation = (definitionId, args) => {
-    const definition = registry.get(definitionId);
-    if (!definition) return;
-    if (definition.invalidation === "immediate") {
-      invalidateNow(definitionId, args);
-      return;
-    }
-    const key = recordKey(definitionId, definition.key(args, contextFor(definition)));
-    if (microtaskQueue.has(key)) return;
-    microtaskQueue.set(key, { definitionId, args });
-    if (!microtaskScheduled) {
-      microtaskScheduled = true;
-      queueMicrotask(flushInvalidations);
-    }
-  };
-  const refreshRuntimeBindings = () => {
-    for (const record of records.values()) cleanupRecord(record);
-    records.clear();
-    notifyContext();
-  };
-  return {
-    ensure(definitionId, args) {
-      const definition = registry.get(definitionId);
-      if (!definition) throw new Error(`Resource definition "${definitionId}" not found`);
-      const record = getOrCreateRecord(definition, args);
-      if (!record.inFlight && record.snapshot.status === "pending") loadResource(definition, args, record);
-      return record.snapshot;
-    },
-    subscribe(definitionId, args, callback) {
-      const definition = registry.get(definitionId);
-      if (!definition) return () => void 0;
-      let record = getOrCreateRecord(definition, args);
-      record.subscribers.add(callback);
-      const removeContext = definition.scope === "context" ? (() => {
-        const listener = () => {
-          record.subscribers.delete(callback);
-          record = getOrCreateRecord(definition, args);
-          record.subscribers.add(callback);
-          callback();
-        };
-        contextSubscribers.add(listener);
-        return () => contextSubscribers.delete(listener);
-      })() : void 0;
-      return () => {
-        removeContext?.();
-        record.subscribers.delete(callback);
-        if (record.subscribers.size === 0 && record.providerUnsubscribe) {
-          record.providerUnsubscribe();
-          record.providerUnsubscribe = null;
-        }
-        if (record.subscribers.size === 0 && record.abortController) {
-          const current = record;
-          setTimeout(() => {
-            if (current.subscribers.size === 0 && current.abortController) {
-              current.abortController.abort();
-              current.abortController = null;
-              current.inFlight = null;
-            }
-          }, 100);
-        }
-      };
-    },
-    read(definitionId, args) {
-      const definition = registry.get(definitionId);
-      if (!definition) return void 0;
-      const key = definition.key(args, contextFor(definition));
-      return records.get(recordKey(definitionId, key))?.snapshot;
-    },
-    invalidate: scheduleInvalidation,
-    disposeOwner(ownerId) {
-      for (const [key, record] of records) {
-        if (record.owner !== ownerId) continue;
-        cleanupRecord(record);
-        records.delete(key);
-      }
-    },
-    refreshRuntimeBindings,
-    subscribeContext(callback) {
-      contextSubscribers.add(callback);
-      return () => contextSubscribers.delete(callback);
-    }
-  };
-}
-
-// src/host/createPluginHost.ts
-function createInMemoryPluginConfigStore(initial = {}, readOnly = false) {
-  const values = /* @__PURE__ */ new Map();
-  for (const [id, value] of Object.entries(initial)) {
-    if (typeof value === "boolean") values.set(id, value);
-  }
-  const listeners = /* @__PURE__ */ new Set();
-  const snapshot = () => Object.freeze(Object.fromEntries(values));
-  return {
-    read: snapshot,
-    setEnabled(pluginId, enabled) {
-      if (readOnly) return;
-      if (values.get(pluginId) === enabled) return;
-      values.set(pluginId, enabled);
-      const next = snapshot();
-      for (const listener of [...listeners]) listener(next);
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    }
-  };
-}
-function errorMessage4(error) {
-  if (error instanceof Error) return error.message;
-  if (error && typeof error === "object" && "message" in error) {
-    const message = error.message;
-    if (typeof message === "string") return message;
-  }
-  return String(error);
-}
-function makeInstanceId(pluginId, unitId) {
-  try {
-    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-      return `${pluginId}:${unitId}:${crypto.randomUUID()}`;
-    }
-  } catch {
-  }
-  return `${pluginId}:${unitId}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-}
-function lifecycleStateFor(state, desired) {
-  switch (state) {
-    case "starting":
-      return "starting";
-    case "stopping":
-      return "stopping";
-    case "enabled":
-      return "running";
-    case "blocked":
-      return "waiting";
-    case "error-disabled":
-    case "cleanup-pending":
-      return "failed";
-    case "unknown":
-      return desired ? "waiting" : "disabled";
-    case "disabled":
-      return "disabled";
-    case "registered":
-      return desired ? "waiting" : "disabled";
-  }
-}
-function selectedUnit(manifest, runtime) {
-  const units = manifest.units ?? [];
-  if (units.length > 1) {
-    const matches = runtime === void 0 ? [] : units.filter(
-      (unit) => unit.runtime === runtime
-    );
-    return matches.length === 1 ? matches[0] : void 0;
-  }
-  if (units.length === 1) {
-    const unit = units[0];
-    return unit && (runtime === void 0 || unit.runtime === runtime) && unit.runtime !== void 0 ? unit : void 0;
-  }
-  const targetRuntime = runtime ?? "window-main";
-  return {
-    id: manifest.id,
-    runtime: targetRuntime,
-    dependencies: manifest.dependencies?.map((dependency) => ({
-      capability: dependency.capability,
-      contractVersion: dependency.contractVersion ?? `${dependency.capability}.v1`,
-      sourceRuntime: dependency.sourceRuntime ?? targetRuntime,
-      ...dependency.reason !== void 0 ? { reason: dependency.reason } : {},
-      ...dependency.optional !== void 0 ? { optional: dependency.optional } : {}
-    })),
-    provides: manifest.provides,
-    permissions: manifest.permissions,
-    config: manifest.config,
-    contribution: manifest.contribution
-  };
-}
-function dependenciesFor(manifest, runtime) {
-  return dependenciesOfManifest(manifest, runtime);
-}
-function setupFor(manifest, unit, options) {
-  return options.runtimeUnitImplementationRegistry?.get(manifest.id, unit.id);
-}
-var StartupCapabilityError = class extends Error {
-  details;
-  constructor(details, phase = "startup") {
-    super(`Startup prerequisite unavailable: ${details.map((item) => item.capability).join(", ")} (${phase})`);
-    this.name = "StartupCapabilityError";
-    this.details = details;
-  }
-};
-var StartupPluginError = class extends Error {
-  details;
-  constructor(details) {
-    super(`Startup plugin failed: ${details.pluginId}`);
-    this.name = "StartupPluginError";
-    this.details = details;
-  }
-};
-function createPluginHost(options = {}) {
-  const runtimeKind = options.runtime;
-  const listeners = /* @__PURE__ */ new Set();
-  let versionCounter = 0;
-  let hostDisposed = false;
-  let disposePromise;
-  let runtimeSnapshots = options.runtimeSnapshots;
-  const bumpVersion = () => {
-    versionCounter += 1;
-    for (const listener of [...listeners]) {
-      try {
-        listener({ version: versionCounter });
-      } catch {
-      }
-    }
-  };
-  const rootScope = createLifecycleScope({
-    kind: "root",
-    metadata: { attributes: Object.freeze({ ...options.rootAttributes ?? {} }) },
-    onChange: bumpVersion
-  });
-  const taskScheduler = createScopedTaskScheduler(rootScope);
-  const capabilities = createCapabilityRegistry();
-  const messageBus = options.messageBus ?? createMessageBus();
-  const resourceRegistry = options.resourceRegistry ?? createResourceRegistry();
-  let rootAttributes = Object.freeze({ ...options.rootAttributes ?? {} });
-  const instanceAttributes = /* @__PURE__ */ new Map();
-  const resourceStore = createResourceStore(resourceRegistry, (key) => capabilities.has(key) ? capabilities.get(key) : void 0, (ownerId) => instanceAttributes.get(ownerId ?? "") ?? rootAttributes);
-  const injectCapabilities = (source) => {
-    if (!source) return;
-    const entries = source instanceof Map ? source.entries() : Object.entries(source);
-    for (const [key, value] of entries) capabilities.provide(key, value);
-  };
-  injectCapabilities(options.capabilities);
-  injectCapabilities(options.builtinCapabilities);
-  if (!capabilities.has(RUNTIME_MESSAGE_BUS)) capabilities.provide(RUNTIME_MESSAGE_BUS, messageBus);
-  if (!capabilities.has(RESOURCE_REGISTRY_CAPABILITY)) capabilities.provide(RESOURCE_REGISTRY_CAPABILITY, resourceRegistry);
-  if (!capabilities.has(SCOPED_TASK_SCHEDULER_CAPABILITY)) capabilities.provide(SCOPED_TASK_SCHEDULER_CAPABILITY, taskScheduler);
-  const configStore = options.configStore ?? createInMemoryPluginConfigStore(options.initialPluginConfig, false);
-  const knownManifests = /* @__PURE__ */ new Map();
-  const records = /* @__PURE__ */ new Map();
-  const enabledSet = /* @__PURE__ */ new Set();
-  const starting = /* @__PURE__ */ new Map();
-  const stopping = /* @__PURE__ */ new Map();
-  const internalConfigWrites = /* @__PURE__ */ new Set();
-  let intentSnapshot = options.pluginIntentCoordinator?.snapshot();
-  let removeConfigSubscription = () => void 0;
-  let removeIntentSubscription = () => void 0;
-  let reconcilePromise;
-  const desiredEnabledFor = (pluginId, manifest) => {
-    if (manifest?.meta.startup === "required" || manifest?.meta.canDisable === false) return true;
-    if (intentSnapshot && Object.prototype.hasOwnProperty.call(intentSnapshot.desiredEnabled, pluginId)) {
-      return intentSnapshot.desiredEnabled[pluginId] === true;
-    }
-    return configStore.read()[pluginId] ?? manifest?.meta.defaultEnabled ?? false;
-  };
-  const desiredRevisionFor = (pluginId) => intentSnapshot?.desiredRevision[pluginId];
-  const selected = (manifest) => selectedUnit(manifest, runtimeKind);
-  const graph = () => buildPluginGraph([
-    ...knownManifests.values()
-  ], { runtime: runtimeKind, enabledPluginIds: enabledSet });
-  const validateManifest = (manifest) => {
-    if (!manifest || typeof manifest.id !== "string" || manifest.id.trim() === "") throw new Error("Plugin id must be a non-empty string");
-    if (typeof manifest.name !== "string" || manifest.name.trim() === "") throw new Error(`Plugin "${manifest.id}" name must be a non-empty string`);
-    if (!manifest.meta || typeof manifest.meta.defaultEnabled !== "boolean" || typeof manifest.meta.canDisable !== "boolean") {
-      throw new Error(`Plugin "${manifest.id}" meta must define defaultEnabled and canDisable`);
-    }
-    if (manifest.meta.startup === "required" && (manifest.meta.canDisable || !manifest.meta.defaultEnabled)) {
-      throw new Error(`Plugin "${manifest.id}" required startup metadata is inconsistent`);
-    }
-    if (manifest.units !== void 0 && !Array.isArray(manifest.units)) throw new Error(`Plugin "${manifest.id}" units must be an array`);
-    if ((manifest.units?.length ?? 0) > 1 && runtimeKind === void 0) {
-      throw new Error(`Plugin "${manifest.id}" runtime must be explicit for multi-unit manifests`);
-    }
-    if (manifest.units && manifest.units.length > 0) {
-      const ids = /* @__PURE__ */ new Set();
-      for (const unit of manifest.units) {
-        if (!unit.id || ids.has(unit.id)) throw new Error(`Plugin "${manifest.id}" has duplicate or empty unit id`);
-        ids.add(unit.id);
-        if (unit.runtime !== "window-main" && unit.runtime !== "shared-worker") {
-          throw new Error(`Plugin "${manifest.id}" unit "${unit.id}" declares an unsupported Runtime`);
-        }
-      }
-    }
-    options.manifestValidator?.(manifest);
-  };
-  const isRequired = (manifest) => manifest.meta.startup === "required" || manifest.meta.canDisable === false;
-  const missingDependencies = (manifest) => {
-    const missing = [];
-    const selectedUnitForDependencies = selected(manifest);
-    const localRuntime = selectedUnitForDependencies?.runtime ?? runtimeKind;
-    for (const dependency of dependenciesFor(manifest, runtimeKind)) {
-      if (dependency.optional) continue;
-      const sourceRuntime = dependency.sourceRuntime ?? localRuntime;
-      const contractVersion = dependency.contractVersion ?? `${dependency.capability}.v1`;
-      if (sourceRuntime !== void 0 && sourceRuntime !== localRuntime) {
-        const available = options.remoteServiceReferences?.().some((reference) => reference.status === "ready" && reference.runtime === sourceRuntime && reference.capabilityId === dependency.capability && reference.contractVersion === contractVersion) ?? false;
-        if (!available) missing.push(dependency.capability);
-      } else if (!capabilities.has(dependency.capability)) {
-        missing.push(dependency.capability);
-      }
-    }
-    return [...new Set(missing)];
-  };
-  const runtimeUnavailable = (manifest) => {
-    const unit = selected(manifest);
-    if (!unit) {
-      const units = manifest.units ?? [];
-      if (units.length > 0 && runtimeKind !== void 0 && !units.some((item) => item.runtime === runtimeKind)) {
-        const snapshots = runtimeSnapshots?.() ?? [];
-        if (snapshots.some((item) => item.pluginId === manifest.id)) return `runtime:${manifest.id}:unknown`;
-      }
-      return units.length > 0 ? `runtime:${manifest.id}:unit-unavailable` : void 0;
-    }
-    const unavailable = options.runtimeUnitAvailability?.({
-      pluginId: manifest.id,
-      unitId: unit.id,
-      runtime: unit.runtime
-    });
-    if (unavailable) return unavailable;
-    if (!setupFor(manifest, unit, options)) return `runtime:${manifest.id}:${unit.id}:implementation-unavailable`;
-    return void 0;
-  };
-  const revokeContributions = (record) => {
-    for (const contribution of record.contributions) {
-      if (!contribution.active) continue;
-      contribution.active = false;
-      try {
-        contribution.revoke();
-      } catch {
-      }
-    }
-  };
-  const releaseContributions = async (record) => {
-    let firstError;
-    for (const contribution of [...record.contributions].reverse()) {
-      try {
-        await contribution.dispose();
-      } catch (error) {
-        firstError ??= error;
-      }
-    }
-    record.contributions = [];
-    if (firstError) throw firstError;
-  };
-  const registerContribution = async (record, unit, instanceId, scope) => {
-    const contribution = unit.contribution;
-    if (contribution === void 0 || !options.contributionAdapters) return;
-    for (const adapter of options.contributionAdapters) {
-      const result = await adapter.register({
-        pluginId: record.manifest.id,
-        unitId: unit.id,
-        instanceId,
-        scope,
-        contribution,
-        manifest: record.manifest
-      });
-      if (!result) continue;
-      if (typeof result === "function") {
-        let active = true;
-        let cleanupPromise;
-        const dispose = async () => {
-          if (cleanupPromise) return cleanupPromise;
-          if (!active) return;
-          active = false;
-          cleanupPromise = Promise.resolve(result());
-          await cleanupPromise;
-        };
-        record.contributions.push({ active: true, revoke: () => {
-          void dispose().catch(() => void 0);
-        }, dispose });
-      } else {
-        const handle = result;
-        let cleanupPromise;
-        record.contributions.push({
-          active: true,
-          revoke: () => {
-            try {
-              handle.revoke?.();
-            } catch {
-            }
-            if (!cleanupPromise) cleanupPromise = Promise.resolve(handle.dispose?.());
-            cleanupPromise.catch(() => void 0);
-          },
-          dispose: async () => {
-            if (cleanupPromise) return cleanupPromise;
-            cleanupPromise = Promise.resolve(handle.dispose?.());
-            return cleanupPromise;
-          }
-        });
-      }
-    }
-  };
-  const buildContext = (record, unit, scope, instanceId) => {
-    const requested = [...new Set(unit.permissions ?? [])];
-    const policy = options.permissionPolicy?.({
-      pluginId: record.manifest.id,
-      unitId: unit.id,
-      // Host 的实例令牌和 Scope 原语的内部 instanceId 是两个生成点；
-      // PermissionLease 必须绑定 Context 对外暴露的实例令牌。
-      identity: { ...scope.identity, instanceId },
-      requested
-    }) ?? { approved: requested };
-    const permissionLease = createPermissionLease({
-      identity: { ...scope.identity, instanceId },
-      requested,
-      approved: policy.approved ?? requested,
-      sessionConstraints: policy.sessionConstraints,
-      ...policy.binding ?? {},
-      scope
-    });
-    const extension = Object.freeze({
-      ...options.contextExtension?.({
-        pluginId: record.manifest.id,
-        unitId: unit.id,
-        instanceId,
-        scope,
-        manifest: record.manifest
-      }) ?? {}
-    });
-    const config = unit.config === void 0 ? void 0 : Object.freeze({ ...unit.config });
-    const contextTaskScheduler = createScopedTaskScheduler(scope);
-    const scopedMessageBus = createScopedMessageBus(messageBus, scope);
-    const ownedResourceIds = /* @__PURE__ */ new Set();
-    let resourceDefinitionsRevoked = false;
-    const revokeResourceDefinitions = () => {
-      if (resourceDefinitionsRevoked) return;
-      resourceDefinitionsRevoked = true;
-      resourceStore.disposeOwner(instanceId);
-      for (const resourceId of ownedResourceIds) {
-        if (resourceRegistry.get(resourceId)) resourceRegistry.unregister(resourceId);
-      }
-      ownedResourceIds.clear();
-    };
-    const scopedResourceRegistry = {
-      register(definition) {
-        scope.assertActive();
-        registerOwnedResource(resourceRegistry, instanceId, definition);
-        ownedResourceIds.add(definition.id);
-      },
-      unregister(resourceId) {
-        scope.assertActive();
-        if (!ownedResourceIds.has(resourceId)) {
-          throw new Error(`Resource definition "${resourceId}" is not owned by plugin instance "${instanceId}"`);
-        }
-        resourceRegistry.unregister(resourceId);
-        ownedResourceIds.delete(resourceId);
-      },
-      get(resourceId) {
-        return resourceRegistry.get(resourceId);
-      },
-      _ids() {
-        return [...ownedResourceIds];
-      }
-    };
-    scope.onRevoke(revokeResourceDefinitions);
-    scope.onDispose(revokeResourceDefinitions, `resource-definitions:${record.manifest.id}`, "after-teardown");
-    scope.onDispose(() => contextTaskScheduler.dispose(), `task-scheduler:${record.manifest.id}`);
-    const context = {
-      pluginId: record.manifest.id,
-      instanceId,
-      unitId: unit.id,
-      scope,
-      signal: scope.signal,
-      permissions: Object.freeze([...permissionLease.binding.requested.filter((permission) => permissionLease.has(permission))]),
-      permissionLease,
-      serviceBridge: options.serviceBridgeForPlugin?.(record.manifest.id, instanceId),
-      taskScheduler: contextTaskScheduler,
-      extension,
-      config,
-      onDispose(cleanup) {
-        scope.onDispose(cleanup, `plugin-dispose:${record.manifest.id}`);
-        record.disposeCallbacks.push(cleanup);
-      },
-      provide(key, value) {
-        scope.assertActive();
-        capabilities.provide(key, value);
-        record.capabilities.add(key);
-      },
-      get(key) {
-        if (key === RUNTIME_MESSAGE_BUS) return scopedMessageBus;
-        if (key === RESOURCE_REGISTRY_CAPABILITY) return scopedResourceRegistry;
-        return capabilities.get(key);
-      },
-      has(key) {
-        return capabilities.has(key);
-      },
-      require(key) {
-        capabilities.require(key);
-      },
-      messageBus: scopedMessageBus
-    };
-    return context;
-  };
-  const beginStop = (record, reason, preserveIntent, blockedBy) => {
-    if (record.state === "stopping" || record.state === "cleanup-pending") return;
-    const wasStarting = record.state === "starting";
-    record.state = "stopping";
-    record.error = void 0;
-    record.blockedBy = void 0;
-    record.stopRequested = reason;
-    record.preserveIntentOnStop = preserveIntent;
-    record.scope?.revoke(reason);
-    revokeContributions(record);
-    for (const capability of record.capabilities) capabilities.revoke(capability);
-    record.capabilities.clear();
-    enabledSet.delete(record.manifest.id);
-    if (wasStarting) record.pendingDesiredEnabled = desiredEnabledFor(record.manifest.id, record.manifest);
-    if (blockedBy) record.blockedBy = [...blockedBy];
-    resourceStore.disposeOwner(record.instanceId ?? record.manifest.id);
-    bumpVersion();
-  };
-  const finishStop = async (record, reason) => {
-    const scope = record.scope;
-    const preserveIntent = preserveIntentOf(record);
-    let teardownError;
-    const projectLateCleanup = (result, error2) => {
-      if (result) record.cleanup = result;
-      if (error2 !== void 0) {
-        record.error = errorMessage4(error2);
-        bumpVersion();
-        return;
-      }
-      if (!result || result.cleanupIncomplete || record.state !== "cleanup-pending") return;
-      const desired2 = record.pendingDesiredEnabled ?? desiredEnabledFor(record.manifest.id, record.manifest);
-      const missing2 = missingDependencies(record.manifest);
-      const unavailable2 = runtimeUnavailable(record.manifest);
-      record.state = desired2 && (missing2.length > 0 || unavailable2) ? "blocked" : "disabled";
-      record.blockedBy = record.state === "blocked" ? [.../* @__PURE__ */ new Set([...missing2, ...unavailable2 ? [unavailable2] : []])] : void 0;
-      record.error = void 0;
-      bumpVersion();
-      if (desired2 && record.state === "disabled" && !hostDisposed) {
-        queueMicrotask(() => {
-          void enable(record.manifest.id).catch(() => void 0);
-        });
-      }
-    };
-    const cleanup = scope ? await scope.dispose({
-      reason,
-      timeoutMs: options.lifecycleCleanupTimeoutMs,
-      teardown: async () => {
-        try {
-          if (record.teardown) await record.teardown();
-          await releaseContributions(record);
-        } catch (error2) {
-          teardownError = error2;
-          throw error2;
-        }
-      },
-      onLateSuccess: (_resourceId, result) => projectLateCleanup(result),
-      onLateFailure: (_resourceId, error2, result) => projectLateCleanup(result, error2)
-    }) : void 0;
-    record.cleanup = cleanup;
-    record.scope = void 0;
-    if (record.instanceId) instanceAttributes.delete(record.instanceId);
-    record.instanceId = void 0;
-    record.unitId = void 0;
-    record.teardown = void 0;
-    record.stopRequested = void 0;
-    record.disposeCallbacks = [];
-    const desired = record.pendingDesiredEnabled ?? desiredEnabledFor(record.manifest.id, record.manifest);
-    record.pendingDesiredEnabled = void 0;
-    const missing = missingDependencies(record.manifest);
-    const unavailable = runtimeUnavailable(record.manifest);
-    const incomplete = Boolean(cleanup?.pending.length && cleanup.errors.some((item) => item.code === "lifecycle.cleanup_timeout"));
-    const error = teardownError ?? cleanup?.errors.find((item) => item.code !== "lifecycle.cleanup_timeout");
-    if (incomplete) {
-      record.state = "cleanup-pending";
-      record.error = errorMessage4(error ?? "Plugin cleanup is still pending");
-    } else if (error || cleanup?.cleanupIncomplete) {
-      record.state = "error-disabled";
-      record.error = errorMessage4(error ?? "Plugin cleanup did not complete");
-    } else if (desired && (missing.length > 0 || unavailable)) {
-      record.state = "blocked";
-      record.blockedBy = [.../* @__PURE__ */ new Set([...missing, ...unavailable ? [unavailable] : []])];
-    } else {
-      record.state = "disabled";
-      record.error = void 0;
-      record.blockedBy = void 0;
-    }
-    if (!preserveIntent && !desired) {
-      internalConfigWrites.add(record.manifest.id);
-      try {
-        configStore.setEnabled(record.manifest.id, false);
-      } finally {
-        internalConfigWrites.delete(record.manifest.id);
-      }
-    }
-    record.preserveIntentOnStop = void 0;
-    bumpVersion();
-    if (desired && record.state === "disabled" && !hostDisposed) {
-      queueMicrotask(() => {
-        void enable(record.manifest.id).catch(() => void 0);
-      });
-    }
-  };
-  const preserveIntentOf = (record) => record.preserveIntentOnStop === true;
-  const stopPlugin = async (record, reason, preserveIntent, blockedBy) => {
-    const existing = stopping.get(record.manifest.id);
-    if (existing) return existing;
-    beginStop(record, reason, preserveIntent, blockedBy);
-    const start = starting.get(record.manifest.id);
-    const promise = (start ? start.catch(() => void 0) : Promise.resolve()).then(() => finishStop(record, reason)).finally(() => stopping.delete(record.manifest.id));
-    stopping.set(record.manifest.id, promise);
-    return promise;
-  };
-  const enable = async (pluginId) => {
-    if (hostDisposed) throw new LifecycleScopeRevokedError("Plugin host is disposed");
-    const record = records.get(pluginId);
-    if (!record) throw new Error(`Plugin "${pluginId}" is not registered`);
-    if (!options.pluginIntentCoordinator) {
-      internalConfigWrites.add(pluginId);
-      try {
-        configStore.setEnabled(pluginId, true);
-      } finally {
-        internalConfigWrites.delete(pluginId);
-      }
-    }
-    record.pendingDesiredEnabled = true;
-    const existingStop = stopping.get(pluginId);
-    if (existingStop) {
-      await existingStop;
-    }
-    if (record.state === "enabled") return;
-    const existing = starting.get(pluginId);
-    if (existing) return existing;
-    record.stopRequested = void 0;
-    if (record.state === "cleanup-pending") {
-      throw new Error(`Plugin "${pluginId}" cannot start while cleanup is pending`);
-    }
-    if (record.state === "error-disabled") {
-      record.error = void 0;
-      record.cleanup = void 0;
-    }
-    const task = (async () => {
-      const missing = missingDependencies(record.manifest);
-      const unavailable = runtimeUnavailable(record.manifest);
-      if (missing.length > 0 || unavailable) {
-        record.state = "blocked";
-        record.blockedBy = [.../* @__PURE__ */ new Set([...missing, ...unavailable ? [unavailable] : []])];
-        bumpVersion();
-        return;
-      }
-      const unit = selected(record.manifest);
-      if (!unit) {
-        record.state = "blocked";
-        record.blockedBy = [`runtime:${record.manifest.id}:unit-unavailable`];
-        bumpVersion();
-        return;
-      }
-      const instanceId = makeInstanceId(record.manifest.id, unit.id);
-      let scope;
-      try {
-        const attributes = Object.freeze({
-          ...rootAttributes,
-          ...options.runtimeUnitAttributes?.({
-            pluginId: record.manifest.id,
-            unitId: unit.id,
-            runtime: unit.runtime,
-            manifest: record.manifest
-          }) ?? {}
-        });
-        const parent = options.runtimeUnitParentScope?.({
-          pluginId: record.manifest.id,
-          unitId: unit.id,
-          runtime: unit.runtime,
-          manifest: record.manifest
-        }) ?? rootScope;
-        scope = parent.child("runtime-unit", { pluginId: record.manifest.id, attributes });
-      } catch (error) {
-        record.state = "blocked";
-        record.blockedBy = [errorMessage4(error)];
-        bumpVersion();
-        return;
-      }
-      record.state = "starting";
-      record.scope = scope;
-      record.instanceId = instanceId;
-      record.unitId = unit.id;
-      instanceAttributes.set(instanceId, scope.identity.attributes);
-      record.error = void 0;
-      record.blockedBy = void 0;
-      bumpVersion();
-      try {
-        const setup = setupFor(record.manifest, unit, options);
-        if (!setup) throw new Error(`Runtime implementation is unavailable for ${record.manifest.id}/${unit.id}`);
-        const context = buildContext(record, unit, scope, instanceId);
-        const result = await setup(context);
-        record.teardown = typeof result === "function" ? result : void 0;
-        await registerContribution(record, unit, instanceId, scope);
-        const declared = providesOfManifest(record.manifest, runtimeKind);
-        const missingDeclarations = declared.filter((key) => !record.capabilities.has(key));
-        if (missingDeclarations.length > 0) {
-          throw new Error(`Plugin "${record.manifest.id}" did not provide declared capabilities: ${missingDeclarations.join(", ")}`);
-        }
-        if (record.stopRequested || scope.state !== "active" || !desiredEnabledFor(record.manifest.id, record.manifest)) {
-          return;
-        }
-        enabledSet.add(record.manifest.id);
-        record.state = "enabled";
-        record.pendingDesiredEnabled = void 0;
-        bumpVersion();
-        queueMicrotask(() => {
-          void reconcile().catch(() => void 0);
-        });
-      } catch (error) {
-        if (record.stopRequested || scope.state !== "active") {
-          return;
-        }
-        record.state = "error-disabled";
-        record.error = errorMessage4(error);
-        record.scope?.revoke("plugin setup failed");
-        revokeContributions(record);
-        for (const capability of record.capabilities) capabilities.revoke(capability);
-        record.capabilities.clear();
-        record.cleanup = await scope.dispose({ reason: "plugin setup failed", timeoutMs: options.lifecycleCleanupTimeoutMs });
-        record.scope = void 0;
-        instanceAttributes.delete(instanceId);
-        record.instanceId = void 0;
-        record.unitId = void 0;
-        bumpVersion();
-        throw new StartupPluginError({
-          pluginId: record.manifest.id,
-          unitId: unit.id,
-          capabilities: providesOfManifest(record.manifest, runtimeKind),
-          state: record.state,
-          error: record.error
-        });
-      }
-    })();
-    starting.set(pluginId, task);
-    try {
-      await task;
-    } finally {
-      starting.delete(pluginId);
-    }
-  };
-  const collectDisablePlan = (pluginId) => {
-    const plan = [];
-    const visited = /* @__PURE__ */ new Set();
-    const currentGraph = graph();
-    const activePluginIds = /* @__PURE__ */ new Set([
-      ...enabledSet,
-      ...[...records.values()].filter((record) => record.state === "starting" || record.state === "stopping").map((record) => record.manifest.id)
-    ]);
-    const visit = (providerId) => {
-      for (const dependent of reverseDependentsOf(currentGraph, providerId, activePluginIds)) {
-        if (visited.has(dependent.pluginId)) continue;
-        visited.add(dependent.pluginId);
-        visit(dependent.pluginId);
-        const dependentRecord = records.get(dependent.pluginId);
-        if (dependentRecord) plan.push(dependentRecord);
-      }
-    };
-    visit(pluginId);
-    const target = records.get(pluginId);
-    if (target) plan.push(target);
-    return plan;
-  };
-  const reconcile = async () => {
-    if (hostDisposed) return;
-    if (reconcilePromise) return reconcilePromise;
-    reconcilePromise = (async () => {
-      const manifests = [...knownManifests.values()];
-      const ordered = orderManifestsByDependencies(manifests, runtimeKind);
-      for (const manifest of ordered) {
-        const record = records.get(manifest.id);
-        if (!record) continue;
-        if (record && (record.state === "enabled" || record.state === "starting")) {
-          const missing = missingDependencies(manifest);
-          const unavailable = runtimeUnavailable(manifest);
-          if (missing.length > 0 || unavailable) {
-            await stopPlugin(
-              record,
-              "runtime dependency unavailable",
-              true,
-              [.../* @__PURE__ */ new Set([...missing, ...unavailable ? [unavailable] : []])]
-            );
-          }
-        }
-        if (desiredEnabledFor(manifest.id, manifest) && record.state !== "enabled" && record.state !== "starting") {
-          try {
-            await enable(manifest.id);
-          } catch (error) {
-            if (!isRequired(manifest)) continue;
-            throw error;
-          }
-        }
-      }
-      for (const manifest of manifests) {
-        const record = records.get(manifest.id);
-        if (record && !desiredEnabledFor(manifest.id, manifest) && (record.state === "enabled" || record.state === "starting")) {
-          await stopPlugin(record, "desired intent disabled", false);
-        }
-      }
-    })().finally(() => {
-      reconcilePromise = void 0;
-    });
-    return reconcilePromise;
-  };
-  function orderManifestsByDependencies(manifests, runtime) {
-    const byId = new Map(manifests.map((manifest) => [manifest.id, manifest]));
-    const providers = /* @__PURE__ */ new Map();
-    for (const manifest of manifests) {
-      for (const capability of providesOfManifest(manifest, runtime)) {
-        if (!providers.has(capability)) providers.set(capability, manifest.id);
-      }
-    }
-    const visited = /* @__PURE__ */ new Set();
-    const visiting = /* @__PURE__ */ new Set();
-    const ordered = [];
-    const visit = (manifest) => {
-      if (visited.has(manifest.id)) return;
-      if (visiting.has(manifest.id)) return;
-      visiting.add(manifest.id);
-      for (const dependency of dependenciesFor(manifest, runtime)) {
-        if (dependency.optional) continue;
-        const provider = providers.get(dependency.capability);
-        const providerManifest = provider ? byId.get(provider) : void 0;
-        if (providerManifest) visit(providerManifest);
-      }
-      visiting.delete(manifest.id);
-      visited.add(manifest.id);
-      ordered.push(manifest);
-    };
-    for (const manifest of manifests) visit(manifest);
-    return ordered;
-  }
-  const host = {
-    capabilities,
-    messageBus,
-    resourceRegistry,
-    resourceStore,
-    rootScope,
-    taskScheduler,
-    installed: () => [...knownManifests.keys()],
-    manifests: () => [...knownManifests.keys()],
-    state(pluginId) {
-      const record = records.get(pluginId);
-      if (!record) return { id: pluginId, kind: "disabled", lifecycleState: "disabled" };
-      const desired = desiredEnabledFor(pluginId, record.manifest);
-      const unit = selected(record.manifest);
-      return {
-        id: pluginId,
-        kind: record.state,
-        lifecycleState: lifecycleStateFor(record.state, desired),
-        ...record.error ? { error: record.error } : {},
-        desiredEnabled: desired,
-        ...desiredRevisionFor(pluginId) !== void 0 ? { desiredRevision: desiredRevisionFor(pluginId) } : {},
-        ...record.instanceId ? { instanceId: record.instanceId } : {},
-        ...record.unitId ? { unitId: record.unitId } : {},
-        ...record.blockedBy ? { blockedBy: [...record.blockedBy] } : {},
-        ...record.cleanup ? { cleanup: record.cleanup } : {},
-        units: unit ? [{
-          pluginId,
-          unitId: unit.id,
-          runtime: unit.runtime,
-          kind: record.state,
-          ...record.instanceId ? { instanceId: record.instanceId } : {},
-          ...record.error ? { error: record.error } : {}
-        }] : []
-      };
-    },
-    scope: (pluginId) => records.get(pluginId)?.scope,
-    refreshRuntimeUnitSnapshots() {
-      runtimeSnapshots = options.runtimeSnapshots;
-      bumpVersion();
-    },
-    reconcile,
-    graph,
-    version: () => versionCounter,
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    getManifest: (pluginId) => knownManifests.get(pluginId),
-    reverseDeps(pluginId) {
-      return graph().reverse[pluginId] ?? [];
-    },
-    validateManifestSet(manifests) {
-      for (const manifest of manifests) validateManifest(manifest);
-      validatePluginGraph([...manifests], {
-        runtime: runtimeKind,
-        builtinCapabilities: /* @__PURE__ */ new Set([
-          ...capabilities.keys(),
-          ...(options.remoteServiceReferences?.() ?? []).map((reference) => reference.capabilityId)
-        ]),
-        externalRuntimeDependencies: options.externalRuntimeDependencies
-      });
-    },
-    provide(key, value) {
-      if (hostDisposed) throw new LifecycleScopeRevokedError("Plugin host is disposed");
-      capabilities.provide(key, value);
-      bumpVersion();
-    },
-    register: async (manifest) => {
-      if (hostDisposed) throw new LifecycleScopeRevokedError("Plugin host is disposed");
-      validateManifest(manifest);
-      if (knownManifests.has(manifest.id)) throw new Error(`Plugin "${manifest.id}" is already registered`);
-      knownManifests.set(manifest.id, manifest);
-      records.set(manifest.id, { manifest, state: "registered", disposeCallbacks: [], capabilities: /* @__PURE__ */ new Set(), contributions: [] });
-      bumpVersion();
-      if (desiredEnabledFor(manifest.id, manifest)) await enable(manifest.id);
-    },
-    registerAll: async (manifests) => {
-      if (hostDisposed) throw new LifecycleScopeRevokedError("Plugin host is disposed");
-      const current = [...manifests];
-      for (const manifest of current) {
-        validateManifest(manifest);
-        if (knownManifests.has(manifest.id)) throw new Error(`Plugin "${manifest.id}" is already registered`);
-      }
-      validatePluginGraph(current, {
-        runtime: runtimeKind,
-        builtinCapabilities: /* @__PURE__ */ new Set([
-          ...capabilities.keys(),
-          ...(options.remoteServiceReferences?.() ?? []).map((reference) => reference.capabilityId)
-        ]),
-        allowMissingDependencies: false,
-        externalRuntimeDependencies: options.externalRuntimeDependencies
-      });
-      for (const manifest of current) {
-        knownManifests.set(manifest.id, manifest);
-        records.set(manifest.id, { manifest, state: "registered", disposeCallbacks: [], capabilities: /* @__PURE__ */ new Set(), contributions: [] });
-      }
-      bumpVersion();
-      await reconcile();
-    },
-    enable,
-    retry: async (pluginId) => {
-      const record = records.get(pluginId);
-      if (!record) throw new Error(`Plugin "${pluginId}" is not registered`);
-      record.error = void 0;
-      record.cleanup = void 0;
-      record.state = "registered";
-      await enable(pluginId);
-    },
-    submitIntent: async (pluginId, desired) => {
-      if (!knownManifests.has(pluginId)) throw new Error(`Plugin "${pluginId}" is not registered`);
-      if (options.pluginIntentCoordinator) {
-        const current = options.pluginIntentCoordinator.snapshot();
-        const command = {
-          commandId: `plugin-intent:${pluginId}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`,
-          authorityInstanceId: options.pluginIntentCoordinator.authorityInstanceId,
-          expectedRevision: current.revision,
-          pluginId,
-          desiredEnabled: desired
-        };
-        return options.pluginIntentCoordinator.submit(command);
-      }
-      internalConfigWrites.add(pluginId);
-      try {
-        configStore.setEnabled(pluginId, desired);
-      } finally {
-        internalConfigWrites.delete(pluginId);
-      }
-      if (desired) await enable(pluginId);
-      else await host.disable(pluginId);
-      const next = Object.freeze({
-        revision: 0,
-        desiredEnabled: { ...configStore.read() },
-        desiredRevision: {}
-      });
-      return { status: "accepted", commandId: `local:${pluginId}`, snapshot: next, persisted: true };
-    },
-    disable: async (pluginId) => {
-      const record = records.get(pluginId);
-      if (!record) throw new Error(`Plugin "${pluginId}" is not registered`);
-      if (isRequired(record.manifest)) return { ok: false, reason: `Plugin "${pluginId}" cannot be disabled` };
-      if (!options.pluginIntentCoordinator) {
-        internalConfigWrites.add(pluginId);
-        try {
-          configStore.setEnabled(pluginId, false);
-        } finally {
-          internalConfigWrites.delete(pluginId);
-        }
-      }
-      const plan = collectDisablePlan(pluginId);
-      for (const item of plan) beginStop(
-        item,
-        item.manifest.id === pluginId ? "plugin disabled" : `dependency ${pluginId} disabled`,
-        item.manifest.id !== pluginId,
-        item.manifest.id === pluginId ? void 0 : [pluginId]
-      );
-      for (const item of plan) await stopPlugin(
-        item,
-        item.manifest.id === pluginId ? "plugin disabled" : `dependency ${pluginId} disabled`,
-        item.manifest.id !== pluginId,
-        item.manifest.id === pluginId ? void 0 : [pluginId]
-      );
-      return { ok: true };
-    },
-    suspend: async (pluginId, reason = "runtime identity changed") => {
-      const record = records.get(pluginId);
-      if (!record) return;
-      if (record.state !== "enabled" && record.state !== "starting") return;
-      beginStop(record, reason, true);
-      await stopPlugin(record, reason, true);
-    },
-    unregister: async (pluginId) => {
-      const record = records.get(pluginId);
-      if (!record) return;
-      if (isRequired(record.manifest)) throw new Error(`Plugin "${pluginId}" cannot be unregistered`);
-      await host.disable(pluginId);
-      if (record.state === "cleanup-pending") throw new Error(`Plugin "${pluginId}" cleanup is still pending`);
-      records.delete(pluginId);
-      knownManifests.delete(pluginId);
-      bumpVersion();
-    },
-    dispose: (reason = "plugin host disposed") => {
-      if (disposePromise) return disposePromise;
-      hostDisposed = true;
-      removeConfigSubscription();
-      removeIntentSubscription();
-      disposePromise = (async () => {
-        for (const record of [...records.values()].reverse()) {
-          if (record.state === "enabled" || record.state === "starting") {
-            await stopPlugin(record, reason, false);
-          }
-        }
-        return rootScope.dispose({ reason, timeoutMs: options.lifecycleCleanupTimeoutMs });
-      })();
-      return disposePromise;
-    },
-    assertCapabilities(required, extra = {}) {
-      const details = [];
-      for (const capability of required) {
-        if (capabilities.has(capability)) continue;
-        const provider = graph().providers?.[capability]?.[0];
-        const providerRecord = provider ? records.get(provider) : void 0;
-        details.push({
-          capability,
-          providerPluginId: provider,
-          providerState: providerRecord?.state,
-          providerError: providerRecord?.error,
-          configuredEnabled: providerRecord ? desiredEnabledFor(providerRecord.manifest.id, providerRecord.manifest) : void 0
-        });
-      }
-      if (details.length > 0) throw new StartupCapabilityError(details, extra.phase ?? "startup");
-    }
-  };
-  if (options.pluginIntentCoordinator) {
-    removeIntentSubscription = options.pluginIntentCoordinator.subscribe((snapshot) => {
-      intentSnapshot = snapshot;
-      void reconcile().catch(() => void 0);
-      bumpVersion();
-    });
-  }
-  removeConfigSubscription = configStore.subscribe((snapshot) => {
-    if (internalConfigWrites.size > 0) return;
-    for (const [pluginId, manifest] of knownManifests) {
-      if (manifest.meta.startup !== "required" && manifest.meta.canDisable !== false) continue;
-      if (snapshot[pluginId] === true) continue;
-      internalConfigWrites.add(pluginId);
-      try {
-        configStore.setEnabled(pluginId, true);
-      } finally {
-        internalConfigWrites.delete(pluginId);
-      }
-    }
-    void reconcile().catch(() => void 0);
-    bumpVersion();
-  });
-  return host;
-}
-
-// src/host/runtimeUnitImplementationRegistry.ts
-function implementationKey(pluginId, unitId) {
-  return `${pluginId}\0${unitId}`;
-}
-function createRuntimeUnitImplementationRegistry(implementations = []) {
-  const entries = /* @__PURE__ */ new Map();
-  const register = (implementation) => {
-    const key = implementationKey(implementation.pluginId, implementation.unitId);
-    if (entries.has(key)) throw new Error(`\u8FD0\u884C\u5355\u5143\u5B9E\u73B0\u91CD\u590D\u6CE8\u518C: ${implementation.pluginId}/${implementation.unitId}`);
-    entries.set(key, implementation.setup);
-  };
-  for (const implementation of implementations) register(implementation);
-  return {
-    get(pluginId, unitId) {
-      return entries.get(implementationKey(pluginId, unitId));
-    },
-    register,
-    unregister(pluginId, unitId) {
-      entries.delete(implementationKey(pluginId, unitId));
-    }
-  };
-}
-
-// src/runtime/runtimeTypes.ts
-var RuntimeInitializationError = class extends Error {
-  code = "runtime_initialization_failed";
-  details;
-  constructor(details) {
-    super(
-      `Runtime initialization failed${details.pluginId ? ` for ${details.pluginId}` : ""} during ${details.phase}: ${details.error}`
-    );
-    this.name = "RuntimeInitializationError";
-    this.details = details;
-  }
-};
-var RuntimeUnavailableError = class extends Error {
-  code = "transport_unavailable";
-  constructor(message = "Runtime is unavailable") {
-    super(message);
-    this.name = "RuntimeUnavailableError";
-  }
-};
-
-// src/runtime/runtimeProtocol.ts
-var RUNTIME_PROTOCOL_VERSION = "webloom.runtime.v2";
-var RUNTIME_SNAPSHOT_TYPE = "webloom.runtime.snapshot";
-var RUNTIME_ERROR_TYPE = "webloom.runtime.error";
-function isRecord2(input) {
-  return typeof input === "object" && input !== null;
-}
-function isNonEmptyString(input) {
-  return typeof input === "string" && input.length > 0;
-}
-function isRuntimeKind2(input) {
-  return input === "window-main" || input === "shared-worker";
-}
-function isPluginStateKind(input) {
-  return input === "registered" || input === "starting" || input === "stopping" || input === "enabled" || input === "disabled" || input === "blocked" || input === "error-disabled" || input === "cleanup-pending" || input === "unknown";
-}
-function isRemoteServiceReference(input) {
-  if (!isRecord2(input)) return false;
-  const reference = input;
-  return isNonEmptyString(reference.capabilityId) && isNonEmptyString(reference.contractVersion) && isRuntimeKind2(reference.runtime) && isNonEmptyString(reference.runtimeInstanceId) && isNonEmptyString(reference.serviceInstanceId) && (reference.status === "starting" || reference.status === "ready" || reference.status === "unavailable" || reference.status === "failed") && isRecord2(reference.attributes) && !Array.isArray(reference.attributes) && (reference.grantId === void 0 || isNonEmptyString(reference.grantId)) && (reference.authorizationRevision === void 0 || Number.isSafeInteger(reference.authorizationRevision) && reference.authorizationRevision >= 0);
-}
-function isRuntimeSnapshotUnit(input) {
-  if (!isRecord2(input)) return false;
-  const unit = input;
-  return isNonEmptyString(unit.pluginId) && isNonEmptyString(unit.unitId) && isRuntimeKind2(unit.runtime) && isPluginStateKind(unit.state) && (unit.instanceId === void 0 || isNonEmptyString(unit.instanceId));
-}
-function createRuntimeMessageCodec() {
-  return createRemoteServiceMessageCodec({
-    prefix: "webloom.runtime",
-    protocolVersion: RUNTIME_PROTOCOL_VERSION
-  });
-}
-function isRuntimeSnapshot(input) {
-  if (!isRecord2(input)) return false;
-  const message = input;
-  return message.type === RUNTIME_SNAPSHOT_TYPE && isNonEmptyString(message.protocolVersion) && isNonEmptyString(message.runtimeId) && isRuntimeKind2(message.runtimeKind) && isNonEmptyString(message.runtimeInstanceId) && Number.isSafeInteger(message.revision) && message.revision >= 0 && Array.isArray(message.units) && message.units.every(isRuntimeSnapshotUnit) && Array.isArray(message.services) && message.services.every(isRemoteServiceReference) && (message.state === "starting" || message.state === "ready" || message.state === "stopping" || message.state === "failed" || message.state === "disposed");
-}
-function isRuntimeSnapshotProtocol(input) {
-  return input.protocolVersion === RUNTIME_PROTOCOL_VERSION;
-}
-function isRuntimeError(input) {
-  if (!isRecord2(input)) return false;
-  const message = input;
-  return message.type === RUNTIME_ERROR_TYPE && isNonEmptyString(message.protocolVersion) && (message.code === "runtime_initialization_failed" || message.code === "protocol_mismatch" || message.code === "transport_unavailable") && isNonEmptyString(message.message) && (message.pluginId === void 0 || isNonEmptyString(message.pluginId)) && (message.unitId === void 0 || isNonEmptyString(message.unitId)) && (message.phase === void 0 || message.phase === "startup" || message.phase === "snapshot");
-}
-function unitSnapshotFromState(state, runtime) {
-  return {
-    pluginId: state.pluginId,
-    unitId: state.unitId,
-    runtime,
-    ...state.instanceId !== void 0 ? { instanceId: state.instanceId } : {},
-    state: state.kind
-  };
-}
-
-// src/transport/serviceBridge.ts
-function stableAttributes(value) {
-  const normalize = (input) => {
-    if (Array.isArray(input)) return input.map(normalize);
-    if (!input || typeof input !== "object") return input;
-    return Object.fromEntries(
-      Object.entries(input).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, normalize(item)])
-    );
-  };
-  return JSON.stringify(normalize(value));
-}
-function isPlainRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function isSafeAttributeValue(value, seen) {
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "boolean") return true;
-  if (typeof value === "number") return Number.isFinite(value);
-  if (typeof value !== "object") return false;
-  if (seen.has(value)) return false;
-  seen.add(value);
-  const valid = Array.isArray(value) ? value.every((item) => isSafeAttributeValue(item, seen)) : isPlainRecord(value) && !Reflect.ownKeys(value).some((key) => typeof key !== "string") && Object.values(value).every((item) => isSafeAttributeValue(item, seen));
-  seen.delete(value);
-  return valid;
-}
-function isValidAttributes(value) {
-  return isPlainRecord(value) && isSafeAttributeValue(value, /* @__PURE__ */ new Set());
-}
-function isValidSnapshot(snapshot) {
-  if (!snapshot || typeof snapshot !== "object" || typeof snapshot.protocolVersion !== "string" || snapshot.protocolVersion.length === 0 || typeof snapshot.runtimeInstanceId !== "string" || snapshot.runtimeInstanceId.length === 0 || !Number.isSafeInteger(snapshot.revision) || snapshot.revision < 0 || !Array.isArray(snapshot.services)) return false;
-  if (snapshot.runtimeId !== void 0 && (typeof snapshot.runtimeId !== "string" || snapshot.runtimeId.length === 0)) return false;
-  if (snapshot.runtimeKind !== void 0 && snapshot.runtimeKind !== "window-main" && snapshot.runtimeKind !== "shared-worker") return false;
-  if (snapshot.state !== void 0 && snapshot.state !== "starting" && snapshot.state !== "ready" && snapshot.state !== "stopping" && snapshot.state !== "failed" && snapshot.state !== "disposed") return false;
-  const bindingKeys = /* @__PURE__ */ new Set();
-  const serviceCapabilityKeys = /* @__PURE__ */ new Set();
-  const readyLookupKeys = /* @__PURE__ */ new Set();
-  for (const service of snapshot.services) {
-    if (!service || typeof service !== "object" || typeof service.capabilityId !== "string" || service.capabilityId.length === 0 || typeof service.contractVersion !== "string" || service.contractVersion.length === 0 || service.runtime !== "window-main" && service.runtime !== "shared-worker" || service.runtimeInstanceId !== snapshot.runtimeInstanceId || typeof service.serviceInstanceId !== "string" || service.serviceInstanceId.length === 0 || service.status !== "starting" && service.status !== "ready" && service.status !== "unavailable" && service.status !== "failed" || !isValidAttributes(service.attributes) || service.grantId !== void 0 && (typeof service.grantId !== "string" || service.grantId.length === 0) || service.authorizationRevision !== void 0 && (!Number.isSafeInteger(service.authorizationRevision) || service.authorizationRevision < 0)) return false;
-    if (snapshot.runtimeKind !== void 0 && service.runtime !== snapshot.runtimeKind) return false;
-    const key = bindingKey(service);
-    if (bindingKeys.has(key)) return false;
-    bindingKeys.add(key);
-    const serviceCapabilityKey = `${service.capabilityId}\0${service.serviceInstanceId}`;
-    if (serviceCapabilityKeys.has(serviceCapabilityKey)) return false;
-    serviceCapabilityKeys.add(serviceCapabilityKey);
-    if (service.status === "ready") {
-      const lookupKey = `${service.capabilityId}\0${service.contractVersion}\0${service.runtime}`;
-      if (readyLookupKeys.has(lookupKey)) return false;
-      readyLookupKeys.add(lookupKey);
-    }
-  }
-  return true;
-}
-function referenceKey(reference) {
-  return [
-    reference.capabilityId,
-    reference.contractVersion,
-    reference.runtime,
-    reference.runtimeInstanceId,
-    reference.serviceInstanceId,
-    reference.status,
-    stableAttributes(reference.attributes),
-    reference.grantId ?? "null",
-    reference.authorizationRevision ?? "null"
-  ].join("\0");
-}
-function bindingKey(reference) {
-  return [
-    reference.capabilityId,
-    reference.contractVersion,
-    reference.runtime,
-    reference.runtimeInstanceId,
-    reference.serviceInstanceId
-  ].join("\0");
-}
-function lookupMatches(reference, lookup) {
-  return reference.capabilityId === lookup.capabilityId && reference.contractVersion === lookup.contractVersion && (lookup.runtime === void 0 || reference.runtime === lookup.runtime);
-}
-function ensureTimeout(value, label) {
-  const timeout = value ?? 3e4;
-  if (!Number.isFinite(timeout) || timeout <= 0) {
-    throw new TypeError(`${label} must be a finite number greater than zero`);
-  }
-  return timeout;
-}
-function mergeSignals2(...signals) {
-  const active = signals.filter((signal) => signal !== void 0);
-  if (active.length === 0) return { signal: new AbortController().signal, dispose: () => void 0 };
-  const alreadyAborted = active.find((signal) => signal.aborted);
-  if (alreadyAborted) {
-    const controller2 = new AbortController();
-    controller2.abort(alreadyAborted.reason);
-    return { signal: controller2.signal, dispose: () => void 0 };
-  }
-  const controller = new AbortController();
-  const listeners = active.map((signal) => {
-    const listener = () => {
-      try {
-        controller.abort(signal.reason);
-      } catch {
-        controller.abort();
-      }
-    };
-    signal.addEventListener("abort", listener, { once: true });
-    return { signal, listener };
-  });
-  return {
-    signal: controller.signal,
-    dispose: () => {
-      for (const { signal, listener } of listeners) signal.removeEventListener("abort", listener);
-    }
-  };
-}
-function abortedError(signal, fallback = "request_cancelled") {
-  const reason = signal.reason;
-  if (reason instanceof Error && typeof reason.code === "string") return reason;
-  if (reason instanceof Error && fallback === "request_cancelled") {
-    return new RemoteServiceError("request_cancelled", reason.message);
-  }
-  return new RemoteServiceError(fallback, fallback === "call_timeout" ? "Remote service call timed out" : "Remote service request was cancelled");
-}
-function callTimeoutError(timeoutMs) {
-  return new RemoteServiceError("call_timeout", `Remote service call exceeded its ${timeoutMs}ms deadline`, { timeoutMs });
-}
-function createServiceBridge(options) {
-  const defaultCallTimeoutMs = ensureTimeout(options.defaultCallTimeoutMs, "defaultCallTimeoutMs");
-  let currentState = "empty";
-  let currentRuntimeInstanceId;
-  let currentRevision;
-  let currentServices = [];
-  let terminalError;
-  const proxies = /* @__PURE__ */ new Set();
-  const listeners = /* @__PURE__ */ new Set();
-  const notify = () => {
-    for (const listener of [...listeners]) {
-      try {
-        listener();
-      } catch {
-      }
-    }
-  };
-  const revokeProxy = (record, reason, code = "service_revoked") => {
-    if (record.revoked) return;
-    record.revoked = true;
-    record.reason = reason;
-    try {
-      record.controller.abort(new RemoteServiceError(code, reason));
-    } catch {
-      record.controller.abort();
-    }
-  };
-  const revokeAll = (reason, code = "service_revoked") => {
-    for (const record of proxies) revokeProxy(record, reason, code);
-  };
-  const currentMatches = (lookup) => currentServices.filter((reference) => reference.status === "ready" && lookupMatches(reference, lookup));
-  const findBinding = (record, lookup) => {
-    if (record.boundReference) return record.boundReference;
-    if (terminalError) throw terminalError;
-    const matches = currentMatches(lookup);
-    if (matches.length > 1) {
-      throw new RemoteServiceError(
-        "capability_unavailable",
-        `Service "${lookup.capabilityId}" version "${lookup.contractVersion}" has multiple ready instances`
-      );
-    }
-    const reference = matches[0];
-    if (reference) {
-      record.boundReference = Object.freeze({
-        ...reference,
-        attributes: Object.freeze({ ...reference.attributes })
-      });
-      return record.boundReference;
-    }
-    return void 0;
-  };
-  const waitForBinding = (record, lookup, signal) => {
-    const immediate = findBinding(record, lookup);
-    if (immediate) return Promise.resolve(immediate);
-    if (record.revoked) return Promise.reject(new RemoteServiceError("service_revoked", record.reason));
-    if (signal.aborted) return Promise.reject(abortedError(signal));
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      const finish = (callback) => {
-        if (settled) return;
-        settled = true;
-        removeListener();
-        callback();
-      };
-      const check = () => {
-        if (record.revoked) {
-          finish(() => reject(new RemoteServiceError("service_revoked", record.reason)));
-          return;
-        }
-        if (signal.aborted) {
-          finish(() => reject(abortedError(signal)));
-          return;
-        }
-        try {
-          const reference = findBinding(record, lookup);
-          if (reference) finish(() => resolve(reference));
-        } catch (error) {
-          finish(() => reject(error));
-        }
-      };
-      const onAbort = () => check();
-      const listener = () => check();
-      const removeListener = () => {
-        signal.removeEventListener("abort", onAbort);
-        listeners.delete(listener);
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-      listeners.add(listener);
-      check();
-    });
-  };
-  const bridge = {
-    get state() {
-      return currentState;
-    },
-    get runtimeInstanceId() {
-      return currentRuntimeInstanceId;
-    },
-    get defaultCallTimeoutMs() {
-      return defaultCallTimeoutMs;
-    },
-    applySnapshot(snapshot) {
-      if (currentState === "disposed") return { accepted: false, reason: "disposed" };
-      if (snapshot.protocolVersion !== options.protocolVersion) {
-        return { accepted: false, reason: "protocol-mismatch", receivedRevision: snapshot.revision };
-      }
-      if (!isValidSnapshot(snapshot)) {
-        return { accepted: false, reason: "invalid-snapshot", receivedRevision: snapshot.revision };
-      }
-      if (currentRuntimeInstanceId === snapshot.runtimeInstanceId && currentRevision !== void 0 && snapshot.revision <= currentRevision) {
-        return { accepted: false, reason: "stale-revision", receivedRevision: snapshot.revision };
-      }
-      const runtimeChanged = currentRuntimeInstanceId !== void 0 && currentRuntimeInstanceId !== snapshot.runtimeInstanceId;
-      if (runtimeChanged) revokeAll("Runtime instance changed; proxy cannot be rebound", "service_stale");
-      const nextServices = snapshot.services.map((service) => Object.freeze({
-        ...service,
-        attributes: Object.freeze({ ...service.attributes })
-      }));
-      const nextReady = new Map(nextServices.filter((service) => service.status === "ready").map((service) => [bindingKey(service), service]));
-      if (!runtimeChanged) {
-        for (const record of proxies) {
-          const bound = record.boundReference;
-          if (!bound) continue;
-          const replacement = nextReady.get(bindingKey(bound));
-          if (!replacement || referenceKey(replacement) !== referenceKey(bound)) {
-            revokeProxy(record, "Bound service instance was replaced or revoked", "service_revoked");
-          }
-        }
-      }
-      currentRuntimeInstanceId = snapshot.runtimeInstanceId;
-      currentRevision = snapshot.revision;
-      currentServices = Object.freeze(nextServices);
-      terminalError = void 0;
-      if (snapshot.state === "failed") {
-        currentState = "stale";
-        terminalError = new RemoteServiceError("runtime_initialization_failed", "Remote Runtime initialization failed");
-      } else if (snapshot.state === "disposed" || snapshot.state === "stopping") {
-        currentState = "stale";
-        terminalError = new RemoteServiceError("transport_unavailable", "Remote Runtime is no longer accepting calls");
-        revokeAll("Remote Runtime is no longer accepting calls", "transport_unavailable");
-      } else if (snapshot.state === "ready") {
-        currentState = "ready";
-      } else {
-        currentState = "empty";
-      }
-      notify();
-      return { accepted: true, state: currentState, revision: snapshot.revision };
-    },
-    markProtocolMismatch(reason = "Remote Runtime protocol version mismatch") {
-      if (currentState === "disposed") return;
-      terminalError = new RemoteServiceError("protocol_mismatch", reason);
-      revokeAll(reason, "protocol_mismatch");
-      currentState = "stale";
-      notify();
-    },
-    markInitializationFailed(reason = "Remote Runtime initialization failed") {
-      if (currentState === "disposed") return;
-      terminalError = new RemoteServiceError("runtime_initialization_failed", reason);
-      revokeAll(reason, "runtime_initialization_failed");
-      currentState = "stale";
-      notify();
-    },
-    getProxy(lookup, scope) {
-      const record = {
-        revoked: false,
-        reason: "Remote service proxy revoked",
-        controller: new AbortController()
-      };
-      proxies.add(record);
-      let removeScopeRevoke;
-      let removeScopeDispose;
-      const revokeFromScope = (reason) => {
-        revokeProxy(record, reason, "service_revoked");
-        proxies.delete(record);
-        removeScopeRevoke?.();
-        removeScopeDispose?.();
-      };
-      if (scope) {
-        try {
-          removeScopeRevoke = scope.onRevoke(revokeFromScope);
-          removeScopeDispose = scope.onDispose(revokeFromScope, `service-proxy:${lookup.capabilityId}`);
-        } catch {
-          revokeFromScope("Remote service proxy scope is already revoked");
-        }
-      }
-      const proxy = {
-        get reference() {
-          return record.boundReference;
-        },
-        get revoked() {
-          return record.revoked;
-        },
-        async call(request, callOptions = {}) {
-          if (record.revoked) throw new RemoteServiceError("service_revoked", record.reason);
-          const timeoutMs = ensureTimeout(callOptions.timeoutMs ?? defaultCallTimeoutMs, "timeoutMs");
-          const deadlineAt = Date.now() + timeoutMs;
-          const timeoutController = new AbortController();
-          const timeout = setTimeout(() => {
-            try {
-              timeoutController.abort(callTimeoutError(timeoutMs));
-            } catch {
-              timeoutController.abort();
-            }
-          }, timeoutMs);
-          const merged = mergeSignals2(scope?.signal, record.controller.signal, callOptions.signal, timeoutController.signal);
-          try {
-            const reference = await waitForBinding(record, lookup, merged.signal);
-            if (merged.signal.aborted) throw abortedError(merged.signal);
-            const context = {
-              operationId: callOptions.operationId ?? callOptions.requestId,
-              reference,
-              grantId: reference.grantId,
-              signal: merged.signal,
-              deadlineAt,
-              timeoutMs
-            };
-            let result;
-            try {
-              result = Promise.resolve(options.transport.call(request, context));
-            } catch (error) {
-              throw error;
-            }
-            const value = await Promise.race([
-              result,
-              new Promise((_, reject) => {
-                if (merged.signal.aborted) {
-                  reject(abortedError(merged.signal));
-                  return;
-                }
-                const onAbort = () => reject(abortedError(merged.signal));
-                merged.signal.addEventListener("abort", onAbort, { once: true });
-                result.finally(() => merged.signal.removeEventListener("abort", onAbort)).catch(() => void 0);
-              })
-            ]);
-            if (record.revoked) throw new RemoteServiceError("service_revoked", record.reason);
-            return value;
-          } catch (error) {
-            if (merged.signal.aborted) throw abortedError(merged.signal);
-            if (error instanceof RemoteServiceError) throw error;
-            throw error;
-          } finally {
-            clearTimeout(timeout);
-            merged.dispose();
-            if (record.revoked) {
-              proxies.delete(record);
-              removeScopeRevoke?.();
-              removeScopeDispose?.();
-            }
-          }
-        },
-        revoke(reason = "Remote service proxy revoked") {
-          revokeFromScope(reason);
-        }
-      };
-      return proxy;
-    },
-    requireProxy(lookup, scope) {
-      return bridge.getProxy(lookup, scope);
-    },
-    invalidate(reason = "Remote service directory invalidated") {
-      if (currentState === "disposed") return;
-      currentServices = [];
-      currentRevision = void 0;
-      terminalError = void 0;
-      revokeAll(reason, "service_revoked");
-      currentState = "stale";
-      notify();
-    },
-    disconnect(reason = "Remote service transport disconnected") {
-      if (currentState === "disposed") return;
-      currentServices = [];
-      currentRevision = void 0;
-      currentRuntimeInstanceId = void 0;
-      terminalError = new RemoteServiceError("transport_unavailable", reason);
-      revokeAll(reason, "transport_unavailable");
-      currentState = "stale";
-      notify();
-    },
-    dispose(reason = "Remote service bridge disposed") {
-      if (currentState === "disposed") return;
-      currentServices = [];
-      currentRevision = void 0;
-      currentRuntimeInstanceId = void 0;
-      terminalError = new RemoteServiceError("transport_unavailable", reason);
-      revokeAll(reason, "transport_unavailable");
-      currentState = "disposed";
-      notify();
-      proxies.clear();
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    services() {
-      return currentServices;
-    }
-  };
-  return bridge;
-}
-
-// src/transport/messagePortServiceTransport.ts
-var nextTransportId = 0;
-var nextCallSequence = 0;
-function makeCallId(transportId) {
-  nextCallSequence += 1;
-  return `remote-call:${transportId}:${nextCallSequence}`;
-}
-function finiteTimeout(value) {
-  const timeout = value ?? 3e4;
-  if (!Number.isFinite(timeout) || timeout <= 0) throw new TypeError("Remote service timeout must be finite and greater than zero");
-  return timeout;
-}
-function errorFromWire(input) {
-  return new RemoteServiceError(
-    typeof input?.code === "string" && input.code.length > 0 ? input.code : "handler_failed",
-    typeof input?.message === "string" ? input.message : "Remote service call failed",
-    input?.details
-  );
-}
-function abortReason(signal) {
-  const reason = signal.reason;
-  if (reason instanceof Error && typeof reason.code === "string") return reason;
-  if (reason instanceof Error) return new RemoteServiceError("request_cancelled", reason.message);
-  return new RemoteServiceError("request_cancelled", "Remote service request was cancelled");
-}
-function addMessageListener(port, listener) {
-  port.addEventListener("message", listener);
-  return () => port.removeEventListener("message", listener);
-}
-function postBestEffort(port, message, transfer = []) {
-  try {
-    port.postMessage(message, [...transfer]);
-  } catch {
-  }
-}
-function postRequest(port, message, transfer = []) {
-  try {
-    port.postMessage(message, [...transfer]);
-  } catch (error) {
-    const name = error && typeof error === "object" && typeof error.name === "string" ? error.name : "DataCloneError";
-    const messageText = error instanceof Error ? error.message : String(error);
-    throw new RemoteServiceError(
-      "request_clone_failed",
-      `Remote service request could not be posted: ${messageText}`,
-      { name, message: messageText }
-    );
-  }
-}
-function isResponseMessage(input, codec) {
-  if (!input || typeof input !== "object") return false;
-  const message = input;
-  return (message.type === codec.type("result") || message.type === codec.type("error")) && typeof message.protocolVersion === "string" && typeof message.callId === "string" && typeof message.serviceInstanceId === "string";
-}
-function createMessagePortServiceTransport(options) {
-  const pending = /* @__PURE__ */ new Map();
-  let disposed = false;
-  const transportId = ++nextTransportId;
-  const codec = options.codec ?? createRemoteServiceMessageCodec();
-  const defaultCallTimeoutMs = finiteTimeout(options.defaultCallTimeoutMs);
-  const rejectPending = (error, sendCancel) => {
-    for (const [callId, call] of pending) {
-      pending.delete(callId);
-      call.removeAbort();
-      call.disposeDeadline();
-      if (sendCancel) {
-        postBestEffort(options.port, codec.encode({
-          type: codec.type("cancel"),
-          protocolVersion: codec.protocolVersion,
-          callId,
-          serviceInstanceId: call.serviceInstanceId
-        }));
-      }
-      call.reject(error);
-    }
-  };
-  const onMessage = (event) => {
-    const decoded = codec.decode(event.data);
-    if (!isResponseMessage(decoded, codec)) return;
-    const call = pending.get(decoded.callId);
-    if (!call) return;
-    if (decoded.serviceInstanceId !== call.serviceInstanceId) return;
-    pending.delete(decoded.callId);
-    call.removeAbort();
-    call.disposeDeadline();
-    if (decoded.protocolVersion !== codec.protocolVersion) {
-      call.reject(new RemoteServiceError("protocol_mismatch", "Remote service protocol version mismatch"));
-      return;
-    }
-    if (decoded.type === codec.type("error")) {
-      call.reject(errorFromWire(decoded.error));
-    } else {
-      call.resolve(decoded.result);
-    }
-  };
-  const onMessageError = () => rejectPending(new RemoteServiceError("transport_unavailable", "Remote service message could not be decoded"), false);
-  const removeMessage = addMessageListener(options.port, onMessage);
-  options.port.addEventListener("messageerror", onMessageError);
-  options.port.start();
-  const dispose = () => {
-    if (disposed) return;
-    disposed = true;
-    removeMessage();
-    options.port.removeEventListener("messageerror", onMessageError);
-    rejectPending(new RemoteServiceError("transport_unavailable", "Remote service transport disposed"), true);
-    if (options.closeOnDispose) {
-      try {
-        options.port.close();
-      } catch {
-      }
-    }
-  };
-  const transport = {
-    call(request, context) {
-      if (disposed) return Promise.reject(new RemoteServiceError("transport_unavailable", "Remote service transport disposed"));
-      if (context.signal.aborted) return Promise.reject(abortReason(context.signal));
-      const callId = makeCallId(transportId);
-      const serviceInstanceId = context.reference.serviceInstanceId;
-      const timeoutMs = finiteTimeout(context.timeoutMs ?? defaultCallTimeoutMs);
-      const deadlineAt = context.deadlineAt ?? Date.now() + timeoutMs;
-      const timeoutController = new AbortController();
-      const remaining = Math.max(0, deadlineAt - Date.now());
-      const deadlineTimer = setTimeout(() => {
-        try {
-          timeoutController.abort(new RemoteServiceError("call_timeout", "Remote service call timed out"));
-        } catch {
-          timeoutController.abort();
-        }
-      }, remaining);
-      const merged = (() => {
-        const controller = new AbortController();
-        const signals = [context.signal, timeoutController.signal];
-        const listeners = signals.map((signal) => {
-          const listener = () => {
-            try {
-              controller.abort(signal.reason);
-            } catch {
-              controller.abort();
-            }
-          };
-          signal.addEventListener("abort", listener, { once: true });
-          return { signal, listener };
-        });
-        return {
-          signal: controller.signal,
-          dispose: () => listeners.forEach(({ signal, listener }) => signal.removeEventListener("abort", listener))
-        };
-      })();
-      return new Promise((resolve, reject) => {
-        let settled = false;
-        const finish = (callback) => {
-          if (settled) return;
-          settled = true;
-          callback();
-        };
-        const sendCancel = () => postBestEffort(options.port, codec.encode({
-          type: codec.type("cancel"),
-          protocolVersion: codec.protocolVersion,
-          callId,
-          serviceInstanceId
-        }));
-        const onAbort = () => {
-          if (!pending.delete(callId)) return;
-          sendCancel();
-          const reason = merged.signal.reason instanceof RemoteServiceError ? merged.signal.reason : merged.signal.reason?.code === "call_timeout" ? merged.signal.reason : abortReason(merged.signal);
-          finish(() => reject(reason));
-          merged.dispose();
-          clearTimeout(deadlineTimer);
-        };
-        const pendingCall = {
-          protocolVersion: codec.protocolVersion,
-          serviceInstanceId,
-          resolve: (value) => finish(() => resolve(value)),
-          reject: (error) => finish(() => reject(error)),
-          removeAbort: () => merged.signal.removeEventListener("abort", onAbort),
-          disposeDeadline: () => {
-            merged.dispose();
-            clearTimeout(deadlineTimer);
-          }
-        };
-        pending.set(callId, pendingCall);
-        merged.signal.addEventListener("abort", onAbort, { once: true });
-        const message = {
-          type: codec.type("call"),
-          protocolVersion: codec.protocolVersion,
-          callId,
-          capabilityId: context.reference.capabilityId,
-          contractVersion: context.reference.contractVersion,
-          serviceInstanceId,
-          ...context.operationId ? { operationId: context.operationId } : {},
-          ...context.grantId ?? context.reference.grantId ? { grantId: context.grantId ?? context.reference.grantId } : {},
-          request
-        };
-        try {
-          const transfer = options.transferForRequest?.(request, context) ?? [];
-          postRequest(options.port, codec.encode(message), transfer);
-          if (merged.signal.aborted) onAbort();
-        } catch (error) {
-          pending.delete(callId);
-          pendingCall.removeAbort();
-          pendingCall.disposeDeadline();
-          pendingCall.reject(error);
-        }
-      });
-    },
-    dispose
-  };
-  return transport;
-}
-function ensureTimeout2(value) {
-  const timeout = value ?? 3e4;
-  if (!Number.isFinite(timeout) || timeout <= 0) {
-    throw new TypeError("defaultCallTimeoutMs must be a finite number greater than zero");
-  }
-  return timeout;
-}
-function addMessageListener2(port, listener) {
-  port.addEventListener("message", listener);
-  return () => port.removeEventListener("message", listener);
-}
-function ensureMessageEventTarget(port) {
-  const target = port;
-  if (target.addEventListener && target.removeEventListener) return;
-  const listeners = /* @__PURE__ */ new Set();
-  const original = target.onmessage;
-  target.addEventListener = function add(type, listener) {
-    if (type === "message") listeners.add(listener);
-  };
-  target.removeEventListener = function remove(type, listener) {
-    if (type === "message") listeners.delete(listener);
-  };
-  target.onmessage = (event) => {
-    original?.call(port, event);
-    for (const listener of [...listeners]) listener(event);
-  };
-}
-function makeWorker(options) {
-  const workerOptions = {
-    type: "module",
-    ...options.name ? { name: options.name } : {},
-    ...options.credentials ? { credentials: options.credentials } : {}
-  };
-  if (options.workerFactory) return options.workerFactory(options.url, workerOptions);
-  const WorkerConstructor = globalThis.SharedWorker;
-  if (!WorkerConstructor) throw new RuntimeUnavailableError("SharedWorker is not supported by this browser");
-  return new WorkerConstructor(options.url, workerOptions);
-}
-function connectSharedWorkerInternal(options) {
-  if (!options || typeof options.id !== "string" || options.id.trim() === "") {
-    throw new Error("SharedWorker runtime id must be a non-empty string");
-  }
-  const defaultCallTimeoutMs = ensureTimeout2(options.defaultCallTimeoutMs);
-  const worker = makeWorker(options);
-  const port = worker.port;
-  if (!port) throw new RuntimeUnavailableError("SharedWorker did not expose a MessagePort");
-  ensureMessageEventTarget(port);
-  const listeners = /* @__PURE__ */ new Set();
-  const codec = createRuntimeMessageCodec();
-  let disposed = false;
-  let runtimeInstanceId;
-  let removeRuntimeMessage;
-  let transport;
-  let restoreWorkerError = () => void 0;
-  let currentSnapshot = {
-    runtimeId: options.id,
-    runtimeKind: "shared-worker",
-    runtimeInstanceId: "",
-    state: "starting",
-    revision: 0,
-    units: [],
-    services: []
-  };
-  const emit = (next) => {
-    currentSnapshot = Object.freeze({
-      ...next,
-      units: Object.freeze([...next.units]),
-      services: Object.freeze([...next.services])
-    });
-    for (const listener of [...listeners]) {
-      try {
-        listener(currentSnapshot);
-      } catch {
-      }
-    }
-  };
-  const bridgeTransport = {
-    call(request, context) {
-      if (!transport) {
-        return Promise.reject(new RuntimeUnavailableError("SharedWorker connection is unavailable"));
-      }
-      return transport.call(request, context);
-    }
-  };
-  const bridge = createServiceBridge({
-    protocolVersion: RUNTIME_PROTOCOL_VERSION,
-    transport: bridgeTransport,
-    defaultCallTimeoutMs
-  });
-  const cleanup = () => {
-    removeRuntimeMessage?.();
-    removeRuntimeMessage = void 0;
-    port.removeEventListener("messageerror", onWorkerError);
-    transport?.dispose();
-    transport = void 0;
-    try {
-      port.close();
-    } catch {
-    }
-    if (worker.removeEventListener) worker.removeEventListener("error", onWorkerError);
-    restoreWorkerError();
-    restoreWorkerError = () => void 0;
-  };
-  const disconnect = (reason, failure) => {
-    if (disposed) return;
-    cleanup();
-    bridge.disconnect(reason);
-    emit({
-      ...currentSnapshot,
-      state: "disconnected",
-      runtimeInstanceId: "",
-      revision: 0,
-      units: [],
-      services: [],
-      error: reason
-    });
-    runtimeInstanceId = void 0;
-  };
-  const onRuntimeError = (message) => {
-    const error = new RuntimeInitializationError({
-      pluginId: message.pluginId,
-      unitId: message.unitId,
-      phase: message.phase === "snapshot" ? "snapshot" : "startup",
-      error: message.message
-    });
-    if (message.code === "protocol_mismatch") bridge.markProtocolMismatch(message.message);
-    else if (message.code === "runtime_initialization_failed") bridge.markInitializationFailed(message.message);
-    else bridge.disconnect(message.message);
-    emit({ ...currentSnapshot, state: "failed", error: error.message, units: [], services: [] });
-  };
-  const onSnapshot = (snapshot) => {
-    if (snapshot.runtimeId !== options.id || snapshot.runtimeKind !== "shared-worker") return;
-    if (!isRuntimeSnapshotProtocol(snapshot)) {
-      bridge.markProtocolMismatch(`Runtime protocol ${snapshot.protocolVersion} is not supported`);
-      emit({
-        ...currentSnapshot,
-        state: "failed",
-        error: `Runtime protocol ${snapshot.protocolVersion} is not supported`,
-        units: [],
-        services: []
-      });
-      return;
-    }
-    const applied = bridge.applySnapshot(snapshot);
-    if (!applied.accepted) return;
-    runtimeInstanceId = snapshot.runtimeInstanceId;
-    emit({
-      runtimeId: snapshot.runtimeId,
-      runtimeKind: snapshot.runtimeKind,
-      runtimeInstanceId: snapshot.runtimeInstanceId,
-      state: snapshot.state === "ready" ? "ready" : snapshot.state,
-      revision: snapshot.revision,
-      units: snapshot.units,
-      services: snapshot.services
-    });
-  };
-  const onWorkerError = (event) => {
-    const detail = event.type ? `SharedWorker error: ${event.type}` : "SharedWorker error";
-    disconnect(detail);
-  };
-  const onMessage = (event) => {
-    if (disposed) return;
-    if (isRuntimeError(event.data)) {
-      onRuntimeError(event.data);
-      return;
-    }
-    if (isRuntimeSnapshot(event.data)) {
-      onSnapshot(event.data);
-      return;
-    }
-    const decoded = codec.decode(event.data);
-    if (decoded?.type === codec.type("error")) ;
-  };
-  try {
-    options.onConnection?.({ worker, port });
-    transport = createMessagePortServiceTransport({
-      port,
-      codec,
-      defaultCallTimeoutMs,
-      closeOnDispose: false
-    });
-    removeRuntimeMessage = addMessageListener2(port, onMessage);
-    port.addEventListener("messageerror", onWorkerError);
-    if (worker.addEventListener) worker.addEventListener("error", onWorkerError);
-    else {
-      const previous = worker.onerror;
-      const fallbackHandler = (event) => {
-        previous?.(event);
-        onWorkerError(event);
-      };
-      worker.onerror = fallbackHandler;
-      restoreWorkerError = () => {
-        if (worker.onerror === fallbackHandler) worker.onerror = previous;
-      };
-    }
-    port.start();
-  } catch (error) {
-    cleanup();
-    throw error;
-  }
-  const handle = {
-    runtimeKind: "shared-worker",
-    runtimeId: options.id,
-    get runtimeInstanceId() {
-      return runtimeInstanceId;
-    },
-    serviceBridge: bridge,
-    state: () => currentSnapshot,
-    capability(capabilityId, capabilityOptions = {}) {
-      const proxy = bridge.requireProxy({
-        capabilityId,
-        contractVersion: capabilityOptions.contractVersion ?? `${capabilityId}.v1`
-      });
-      return proxy;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      listener(currentSnapshot);
-      return () => listeners.delete(listener);
-    },
-    dispose(reason = "SharedWorker connection disposed") {
-      if (disposed) return Promise.resolve();
-      disposed = true;
-      emit({ ...currentSnapshot, state: "stopping" });
-      bridge.dispose(reason);
-      cleanup();
-      runtimeInstanceId = void 0;
-      emit({
-        ...currentSnapshot,
-        state: "disposed",
-        runtimeInstanceId: "",
-        revision: 0,
-        units: [],
-        services: []
-      });
-      return Promise.resolve();
-    }
-  };
-  return handle;
-}
-function connectSharedWorker(options) {
-  return connectSharedWorkerInternal(options);
-}
-function connectSharedWorkerForTesting(options, workerFactory) {
-  return connectSharedWorkerInternal({ ...options, workerFactory });
-}
-
-// src/lifecycle/pluginIntentController.ts
-function makeAuthorityInstanceId() {
-  try {
-    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-      return `authority:${crypto.randomUUID()}`;
-    }
-  } catch {
-  }
-  return `authority:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-}
-function cloneSnapshot(snapshot) {
-  return {
-    revision: snapshot.revision,
-    desiredEnabled: { ...snapshot.desiredEnabled },
-    desiredRevision: { ...snapshot.desiredRevision }
-  };
-}
-function normalizeSnapshot(initial) {
-  const revision = Number.isSafeInteger(initial?.revision) && (initial?.revision ?? 0) >= 0 ? initial.revision : 0;
-  const desiredEnabled = {};
-  for (const [pluginId, value] of Object.entries(initial?.desiredEnabled ?? {})) {
-    if (typeof value === "boolean") desiredEnabled[pluginId] = value;
-  }
-  const desiredRevision = {};
-  for (const [pluginId, value] of Object.entries(initial?.desiredRevision ?? {})) {
-    if (Number.isSafeInteger(value) && value >= 0) desiredRevision[pluginId] = value;
-  }
-  return { revision, desiredEnabled, desiredRevision };
-}
-function commandFingerprint(command) {
-  return [
-    command.authorityInstanceId,
-    command.expectedRevision,
-    command.pluginId,
-    command.desiredEnabled ? "true" : "false"
-  ].join("\0");
-}
-function commandError(message) {
-  return { status: "command-conflict", commandId: "", message };
-}
-function createPluginIntentController(options = {}) {
-  const authorityInstanceId = options.authorityInstanceId ?? makeAuthorityInstanceId();
-  const maxCommandRecords = Math.max(1, Math.floor(options.maxCommandRecords ?? 256));
-  let current = normalizeSnapshot(options.initial);
-  const commandRecords = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Set();
-  let queue = Promise.resolve();
-  const notify = () => {
-    const snapshot = cloneSnapshot(current);
-    for (const listener of [...listeners]) {
-      try {
-        listener(snapshot);
-      } catch {
-      }
-    }
-  };
-  const process = async (command) => {
-    const candidate = command;
-    const commandId = typeof candidate?.commandId === "string" ? candidate.commandId : "";
-    if (!candidate || typeof candidate.authorityInstanceId !== "string" || candidate.authorityInstanceId.length === 0 || typeof candidate.pluginId !== "string" || candidate.pluginId.length === 0 || typeof candidate.desiredEnabled !== "boolean" || !Number.isSafeInteger(candidate.expectedRevision) || (candidate.expectedRevision ?? -1) < 0 || commandId.length === 0) {
-      const result = commandError("commandId\u3001pluginId \u548C expectedRevision \u5FC5\u987B\u662F\u6709\u6548\u503C");
-      return { ...result, commandId };
-    }
-    if (command.authorityInstanceId !== authorityInstanceId) {
-      return {
-        status: "stale-authority",
-        commandId: command.commandId,
-        expectedAuthorityInstanceId: authorityInstanceId
-      };
-    }
-    const fingerprint = commandFingerprint(command);
-    const existing = commandRecords.get(command.commandId);
-    if (existing) {
-      if (existing.fingerprint !== fingerprint) {
-        return {
-          status: "command-conflict",
-          commandId: command.commandId,
-          message: "\u76F8\u540C commandId \u7684\u547D\u4EE4\u5185\u5BB9\u4E0D\u540C\uFF0C\u62D2\u7EDD\u8986\u76D6\u539F\u547D\u4EE4"
-        };
-      }
-      return {
-        status: "duplicate",
-        commandId: command.commandId,
-        snapshot: cloneSnapshot(existing.result.snapshot),
-        persisted: true
-      };
-    }
-    if (command.expectedRevision !== current.revision) {
-      return {
-        status: "revision-conflict",
-        commandId: command.commandId,
-        snapshot: cloneSnapshot(current)
-      };
-    }
-    const next = {
-      revision: current.revision + 1,
-      desiredEnabled: {
-        ...current.desiredEnabled,
-        [command.pluginId]: command.desiredEnabled
-      },
-      desiredRevision: {
-        ...current.desiredRevision,
-        [command.pluginId]: (current.desiredRevision[command.pluginId] ?? 0) + 1
-      }
-    };
-    try {
-      await options.persist?.(cloneSnapshot(next));
-    } catch (error) {
-      return {
-        status: "persistence-failed",
-        commandId: command.commandId,
-        message: error instanceof Error ? error.message : String(error),
-        snapshot: cloneSnapshot(current)
-      };
-    }
-    current = next;
-    const accepted = {
-      status: "accepted",
-      commandId: command.commandId,
-      snapshot: cloneSnapshot(current),
-      persisted: true
-    };
-    commandRecords.set(command.commandId, {
-      fingerprint,
-      result: accepted
-    });
-    while (commandRecords.size > maxCommandRecords) {
-      const oldest = commandRecords.keys().next().value;
-      if (oldest === void 0) break;
-      commandRecords.delete(oldest);
-    }
-    notify();
-    return {
-      status: "accepted",
-      commandId: accepted.commandId,
-      snapshot: cloneSnapshot(accepted.snapshot),
-      persisted: true
-    };
-  };
-  const controller = {
-    authorityInstanceId,
-    snapshot: () => cloneSnapshot(current),
-    submit(command) {
-      const result = queue.then(() => process(command));
-      queue = result.then(() => void 0, () => void 0);
-      return result;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    }
-  };
-  return controller;
-}
-
-export { LIFECYCLE_ERROR_TEXT, LifecycleScopeRevokedError, PermissionDeniedError, PermissionLeaseRevokedError, PluginGraphValidationError, RESOURCE_OWNER, RESOURCE_REGISTRY_CAPABILITY, RUNTIME_ERROR_TYPE, RUNTIME_MESSAGE_BUS, RUNTIME_PROTOCOL_VERSION, RUNTIME_SNAPSHOT_TYPE, RemoteServiceError, RuntimeInitializationError, RuntimeUnavailableError, SCOPED_TASK_SCHEDULER_CAPABILITY, StartupCapabilityError, StartupPluginError, UpgradeGateRejectedError, buildPluginGraph, connectSharedWorker, connectSharedWorkerForTesting, createCapabilityRegistry, createInMemoryPluginConfigStore, createLifecycleScope, createMessageBus, createMessagePortServiceTransport, createPermissionLease, createPluginHost, createPluginIntentController, createRemoteServiceMessageCodec, createResourceRegistry, createResourceScope, createResourceStore, createRuntimeMessageCodec, createRuntimeUnitImplementationRegistry, createScopedMessageBus, createScopedTaskScheduler, createServiceBridge, dependenciesOfManifest, isRuntimeError, isRuntimeSnapshot, isRuntimeSnapshotProtocol, lifecycleErrorText, providesOfManifest, registerOwnedResource, reverseDependentsOf, unitSnapshotFromState, validatePluginGraph, validateRuntimeUnitDependencyContracts };
-//# sourceMappingURL=chunk-76BGPI6M.js.map
-//# sourceMappingURL=chunk-76BGPI6M.js.map