webloom-framework 0.1.0

package/dist/chunk-KGNF36DZ.js

@@ -0,0 +1,3736 @@
+// 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 ?? "1";
+  const types = /* @__PURE__ */ new Map([
+    ["call", `${prefix}.call`],
+    ["result", `${prefix}.result`],
+    ["error", `${prefix}.error`],
+    ["cancel", `${prefix}.cancel`],
+    ["handshake", `${prefix}.handshake`],
+    ["snapshot", `${prefix}.snapshot`],
+    ["invalidate", `${prefix}.invalidate`],
+    ["disconnect", `${prefix}.disconnect`]
+  ]);
+  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 RemoteServiceUnavailableError = class extends Error {
+  code = "service.unavailable";
+  constructor(message = "Remote service is unavailable") {
+    super(message);
+    this.name = "RemoteServiceUnavailableError";
+  }
+};
+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 isPluginExecution(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isPluginLifetime(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+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 (!isPluginExecution(dependency.sourceExecution)) {
+          errors.push("sourceExecution\uFF08\u63D0\u4F9B\u8005\u8FD0\u884C\u73AF\u5883\uFF09\u65E0\u6548");
+        }
+        if (!isPluginLifetime(dependency.scope)) {
+          errors.push("scope\uFF08\u63D0\u4F9B\u8005\u4F5C\u7528\u57DF\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")}`
+        });
+      });
+    });
+  }
+  return diagnostics;
+}
+function selectedRuntimeUnits(manifest, execution) {
+  const units = manifest.units ?? [];
+  if (units.length === 0) return [];
+  if (execution !== void 0) return units.filter((unit) => unit.execution === execution);
+  return units.length === 1 ? [...units] : [];
+}
+function dependenciesOfManifest(manifest, execution) {
+  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 && execution === void 0) return [];
+  const selectedUnits = selectedRuntimeUnits(manifest, execution);
+  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, execution) {
+  const units = manifest.units ?? [];
+  if (units.length > 1 && execution === void 0) return [];
+  return unique([
+    ...units.length === 0 ? manifest.provides ?? [] : [],
+    ...selectedRuntimeUnits(manifest, execution).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;
+      providers.push({
+        pluginId: manifest.id,
+        unitId: unit.id,
+        execution: unit.execution,
+        lifetime: unit.lifetime,
+        contractVersion: unit.providedContracts?.[capability]
+      });
+    }
+  }
+  return providers;
+}
+function matchingRuntimeUnitProviders(manifests, dependency) {
+  return runtimeUnitProviders(manifests, dependency.capability).filter(
+    (provider) => provider.execution === dependency.sourceExecution && provider.lifetime === dependency.scope && provider.contractVersion === dependency.contractVersion
+  );
+}
+function runtimeDependenciesForValidation(manifest, execution) {
+  const units = manifest.units ?? [];
+  const selected = execution === void 0 ? units : units.filter((unit) => unit.execution === execution);
+  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.execution);
+    const provided = providesOfManifest(manifest, options.execution);
+    const dependencyEntries = dependenciesOfManifest(manifest, options.execution);
+    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,
+        execution: unit.execution,
+        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.execution)) {
+      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.execution);
+    for (const dependency of strictDependencies) {
+      if (dependency.optional) 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.execution).map((dependency) => dependency.capability)
+    );
+    for (const dependency of dependenciesOfManifest(manifest, options.execution)) {
+      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, execution, defaultLifetime) {
+  const units = manifest.units ?? [];
+  if (units.length > 1) {
+    const matches = execution === void 0 ? [] : units.filter((unit) => unit.execution === execution);
+    return matches.length === 1 ? matches[0] : void 0;
+  }
+  if (units.length === 1) {
+    return execution === void 0 || units[0]?.execution === execution ? units[0] : void 0;
+  }
+  return {
+    id: manifest.id,
+    execution: manifest.meta.execution ?? execution ?? "default",
+    lifetime: manifest.meta.lifetime ?? defaultLifetime,
+    dependencies: manifest.dependencies?.map((dependency) => ({
+      capability: dependency.capability,
+      contractVersion: dependency.contractVersion ?? `${dependency.capability}.v1`,
+      sourceExecution: dependency.sourceExecution ?? "default",
+      scope: dependency.scope ?? defaultLifetime,
+      ...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, execution) {
+  return dependenciesOfManifest(manifest, execution);
+}
+function setupFor(manifest, unit, options) {
+  return options.runtimeUnitImplementationRegistry?.get(manifest.id, unit.id);
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return `[${value.map(stableValue).join(",")}]`;
+  if (!value || typeof value !== "object") return JSON.stringify(value);
+  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableValue(item)}`).join(",")}}`;
+}
+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 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 removeScopeSubscription = () => 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, options.execution, options.defaultLifetime ?? "plugin-instance");
+  const graph = () => buildPluginGraph([...knownManifests.values()], { execution: options.execution, 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 && 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.execution || !unit.lifetime) throw new Error(`Plugin "${manifest.id}" unit "${unit.id}" must define execution and lifetime`);
+      }
+    }
+    options.manifestValidator?.(manifest);
+  };
+  const isRequired = (manifest) => manifest.meta.startup === "required" || manifest.meta.canDisable === false;
+  const missingDependencies = (manifest) => {
+    const missing = [];
+    for (const dependency of dependenciesFor(manifest, options.execution)) {
+      if (dependency.optional) continue;
+      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 && options.execution !== void 0 && !units.some((item) => item.execution === options.execution)) {
+        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;
+    }
+    if (!setupFor(manifest, unit, options)) return `runtime:${manifest.id}:${unit.id}:implementation-unavailable`;
+    return void 0;
+  };
+  const resolveScope = (record, unit) => {
+    const resolver = options.scopeResolver;
+    if (!resolver) return { available: true, parent: rootScope, attributes: rootAttributes, key: stableValue(rootAttributes) };
+    return resolver.resolve({ pluginId: record.manifest.id, unitId: unit.id, lifetime: unit.lifetime, manifest: record.manifest });
+  };
+  const scopeKeyForResolution = (resolution, unit) => resolution.key ?? `${resolution.parent?.identity.scopeId ?? "root"}:${unit.lifetime}:${stableValue(resolution.attributes ?? rootAttributes)}`;
+  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 resolution = resolveScope(record, unit);
+      if (!resolution.available) {
+        record.state = "blocked";
+        record.blockedBy = [resolution.reason ?? `scope:${unit.lifetime}:unavailable`];
+        bumpVersion();
+        return;
+      }
+      const instanceId = makeInstanceId(record.manifest.id, unit.id);
+      let scope;
+      try {
+        const parent = resolution.parent ?? rootScope;
+        const attributes = Object.freeze({ ...resolution.attributes ?? rootAttributes });
+        scope = parent.child(unit.lifetime || "plugin-instance", { 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.scopeKey = scopeKeyForResolution(resolution, unit);
+      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, options.execution);
+        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, capabilities: providesOfManifest(record.manifest, options.execution), 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, options.execution);
+      const rotationTargets = manifests.filter((manifest) => {
+        const record = records.get(manifest.id);
+        if (!record || !desiredEnabledFor(manifest.id, manifest) || record.state !== "enabled" && record.state !== "starting") return false;
+        const unit = selected(record.manifest);
+        if (!unit || !options.scopeResolver) return false;
+        const resolution = resolveScope(record, unit);
+        return !resolution.available || record.scopeKey !== scopeKeyForResolution(resolution, unit);
+      });
+      const rotationPlan = [];
+      const planned = /* @__PURE__ */ new Set();
+      for (const target of rotationTargets) {
+        for (const item of collectDisablePlan(target.id)) {
+          if (planned.has(item.manifest.id)) continue;
+          planned.add(item.manifest.id);
+          rotationPlan.push(item);
+        }
+      }
+      for (const item of rotationPlan) {
+        await stopPlugin(item, "scope resolution changed", true);
+      }
+      for (const manifest of ordered) {
+        const record = records.get(manifest.id);
+        if (!record) continue;
+        if (desiredEnabledFor(manifest.id, manifest) && record.state !== "enabled" && record.state !== "starting") {
+          await enable(manifest.id);
+        }
+      }
+      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, execution) {
+    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, execution)) 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, execution)) {
+        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, execution: unit.execution, 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], { execution: options.execution, builtinCapabilities: new Set(capabilities.keys()) });
+    },
+    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, { execution: options.execution, builtinCapabilities: new Set(capabilities.keys()), allowMissingDependencies: false });
+      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 };
+    },
+    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();
+      removeScopeSubscription();
+      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();
+  });
+  if (options.scopeResolver?.subscribe) {
+    removeScopeSubscription = options.scopeResolver.subscribe(() => {
+      void reconcile().catch(() => void 0);
+      resourceStore.refreshRuntimeBindings();
+      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/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;
+}
+
+// src/transport/serviceBridge.ts
+function makeRequestId() {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return `service-request:${crypto.randomUUID()}`;
+    }
+  } catch {
+  }
+  return `service-request:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+}
+function mergeSignals2(...signals) {
+  const activeSignals = signals.filter((signal) => signal !== void 0);
+  if (activeSignals.length === 0) {
+    return { signal: new AbortController().signal, dispose: () => void 0 };
+  }
+  if (activeSignals.length === 1) {
+    const [signal] = activeSignals;
+    if (signal) return { signal, dispose: () => void 0 };
+  }
+  const alreadyAborted = activeSignals.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 abort = (source) => {
+    try {
+      controller.abort(source.reason);
+    } catch {
+      controller.abort();
+    }
+  };
+  const listeners = activeSignals.map((signal) => {
+    const listener = () => abort(signal);
+    signal.addEventListener("abort", listener, { once: true });
+    return { signal, listener };
+  });
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      for (const item of listeners) item.signal.removeEventListener("abort", item.listener);
+    }
+  };
+}
+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 referenceKey(reference) {
+  return [
+    reference.capabilityId,
+    reference.providerInstanceId,
+    reference.execution,
+    reference.contractVersion,
+    reference.authorityInstanceId,
+    reference.scopeId,
+    reference.handoverGeneration,
+    stableAttributes(reference.attributes),
+    reference.grantId ?? "null",
+    reference.authorizationRevision ?? "null",
+    // 代理绑定的是某一份权威目录快照；目录修订后即使 Provider 实例未变，
+    // 旧代理也不能继续使用旧授权视图，必须重新取得当前引用。
+    reference.snapshotRevision
+  ].join("\0");
+}
+function lookupMatches(reference, lookup) {
+  return reference.status === "ready" && reference.capabilityId === lookup.capabilityId && reference.contractVersion === lookup.contractVersion && (lookup.execution === void 0 || reference.execution === lookup.execution) && (lookup.scopeId === void 0 || reference.scopeId === lookup.scopeId);
+}
+function createServiceBridge(options) {
+  let currentState = "disconnected";
+  let currentConnectionId;
+  let currentAuthorityInstanceId;
+  let lastRevision;
+  let hasBaseline = false;
+  const references = /* @__PURE__ */ new Map();
+  const proxies = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const revokeProxy = (proxy, reason) => {
+    if (proxy.revoked) return;
+    proxy.revoked = true;
+    proxy.reason = reason;
+    try {
+      proxy.controller.abort(new RemoteServiceUnavailableError(reason));
+    } catch {
+      proxy.controller.abort();
+    }
+  };
+  const invalidateProxies = (reason, keep) => {
+    for (const proxy of proxies) {
+      if (!keep?.has(referenceKey(proxy.reference))) {
+        revokeProxy(proxy, reason);
+        proxies.delete(proxy);
+      }
+    }
+  };
+  const clearReferences = (reason) => {
+    references.clear();
+    invalidateProxies(reason);
+  };
+  const bridge = {
+    get state() {
+      return currentState;
+    },
+    get connectionId() {
+      return currentConnectionId;
+    },
+    get authorityInstanceId() {
+      return currentAuthorityInstanceId;
+    },
+    handshake(input) {
+      if (input.protocolVersion !== options.protocolVersion) {
+        clearReferences("service bridge protocol mismatch");
+        currentConnectionId = void 0;
+        currentAuthorityInstanceId = void 0;
+        lastRevision = void 0;
+        hasBaseline = false;
+        currentState = "disconnected";
+        notify();
+        return { accepted: false, reason: "protocol-mismatch" };
+      }
+      const isNewBinding = currentConnectionId !== input.connectionId || currentAuthorityInstanceId !== input.authorityInstanceId;
+      if (isNewBinding) {
+        clearReferences("remote service authority or connection changed");
+        lastRevision = void 0;
+        hasBaseline = false;
+      }
+      currentConnectionId = input.connectionId;
+      currentAuthorityInstanceId = input.authorityInstanceId;
+      currentState = "handshaking";
+      notify();
+      return { accepted: true };
+    },
+    applySnapshot(snapshot) {
+      if (snapshot.connectionId !== currentConnectionId) {
+        return {
+          accepted: false,
+          reason: "wrong-connection",
+          receivedRevision: snapshot.snapshotRevision
+        };
+      }
+      if (snapshot.authorityInstanceId !== currentAuthorityInstanceId) {
+        return {
+          accepted: false,
+          reason: "wrong-authority",
+          receivedRevision: snapshot.snapshotRevision
+        };
+      }
+      if (!Number.isSafeInteger(snapshot.snapshotRevision) || snapshot.snapshotRevision < 0) {
+        return {
+          accepted: false,
+          reason: "stale-revision",
+          receivedRevision: snapshot.snapshotRevision
+        };
+      }
+      if (!snapshot.baseline && !hasBaseline) {
+        currentState = "stale";
+        clearReferences("service bridge baseline required");
+        notify();
+        return {
+          accepted: false,
+          reason: "baseline-required",
+          receivedRevision: snapshot.snapshotRevision
+        };
+      }
+      if (lastRevision !== void 0 && snapshot.snapshotRevision <= lastRevision) {
+        return {
+          accepted: false,
+          reason: "stale-revision",
+          receivedRevision: snapshot.snapshotRevision
+        };
+      }
+      if (!snapshot.baseline && lastRevision !== void 0 && snapshot.snapshotRevision !== lastRevision + 1) {
+        currentState = "stale";
+        clearReferences("service bridge revision gap");
+        hasBaseline = false;
+        notify();
+        return {
+          accepted: false,
+          reason: "revision-gap",
+          expectedRevision: lastRevision + 1,
+          receivedRevision: snapshot.snapshotRevision
+        };
+      }
+      const next = /* @__PURE__ */ new Map();
+      for (const reference of snapshot.services) {
+        if (reference.authorityInstanceId !== currentAuthorityInstanceId || reference.snapshotRevision !== snapshot.snapshotRevision) continue;
+        next.set(referenceKey(reference), Object.freeze({ ...reference }));
+      }
+      references.clear();
+      for (const [key, reference] of next) references.set(key, reference);
+      const validKeys = new Set(
+        [...next.values()].filter((reference) => reference.status === "ready").map(referenceKey)
+      );
+      invalidateProxies("remote service reference is no longer ready", validKeys);
+      lastRevision = snapshot.snapshotRevision;
+      hasBaseline = true;
+      currentState = "ready";
+      notify();
+      return {
+        accepted: true,
+        state: currentState,
+        snapshotRevision: snapshot.snapshotRevision
+      };
+    },
+    getProxy(lookup, scope) {
+      if (currentState !== "ready") return void 0;
+      const matches = [...references.values()].filter((candidate) => lookupMatches(candidate, lookup));
+      if (matches.length > 1) {
+        throw new RemoteServiceUnavailableError(
+          `Service reference is ambiguous for "${lookup.capabilityId}" version "${lookup.contractVersion}"`
+        );
+      }
+      const reference = matches[0];
+      if (!reference) return void 0;
+      const record = {
+        reference,
+        revoked: false,
+        reason: "remote service proxy revoked",
+        controller: new AbortController()
+      };
+      proxies.add(record);
+      let removeScopeRevoke;
+      let removeScopeDispose;
+      let proxy;
+      const revokeFromScope = (reason) => {
+        revokeProxy(record, reason);
+        proxies.delete(record);
+        removeScopeRevoke?.();
+        removeScopeDispose?.();
+      };
+      if (scope) {
+        try {
+          removeScopeRevoke = scope.onRevoke(revokeFromScope);
+          removeScopeDispose = scope.onDispose(revokeFromScope, `service-proxy:${reference.capabilityId}`);
+        } catch {
+          record.revoked = true;
+        }
+      }
+      if (record.revoked) {
+        proxies.delete(record);
+        removeScopeRevoke?.();
+        removeScopeDispose?.();
+        return void 0;
+      }
+      proxy = {
+        reference,
+        get revoked() {
+          return record.revoked;
+        },
+        async call(request, callOptions = {}) {
+          if (record.revoked) throw new RemoteServiceUnavailableError(record.reason);
+          const current = references.get(referenceKey(reference));
+          if (currentState !== "ready" || !current || current.status !== "ready") {
+            record.revoked = true;
+            record.reason = "Remote service reference is no longer ready";
+            throw new RemoteServiceUnavailableError(record.reason);
+          }
+          const merged = mergeSignals2(scope?.signal, record.controller.signal, callOptions.signal);
+          const connectionId = currentConnectionId;
+          if (!connectionId) {
+            merged.dispose();
+            throw new RemoteServiceUnavailableError("Remote service connection is no longer active");
+          }
+          const context = {
+            // requestId 只作为旧调用方的业务 operationId 别名；真正的
+            // MessagePort callId 由传输层每次调用单独生成。
+            operationId: callOptions.operationId ?? callOptions.requestId ?? makeRequestId(),
+            connectionId,
+            reference,
+            grantId: reference.grantId,
+            signal: merged.signal
+          };
+          let result;
+          try {
+            result = Promise.resolve(options.transport.call(request, context));
+          } catch (error) {
+            merged.dispose();
+            throw error;
+          }
+          try {
+            const value = await Promise.race([
+              result,
+              new Promise((_, reject) => {
+                if (merged.signal.aborted) {
+                  reject(merged.signal.reason ?? new RemoteServiceUnavailableError("Remote service request aborted"));
+                  return;
+                }
+                const onAbort = () => reject(merged.signal.reason ?? new RemoteServiceUnavailableError("Remote service request aborted"));
+                merged.signal.addEventListener("abort", onAbort, { once: true });
+                result.finally(() => merged.signal.removeEventListener("abort", onAbort)).catch(() => void 0);
+              })
+            ]);
+            if (record.revoked || currentState !== "ready" || references.get(referenceKey(reference))?.status !== "ready") {
+              throw new RemoteServiceUnavailableError("Remote service request belongs to an invalidated proxy");
+            }
+            return value;
+          } finally {
+            merged.dispose();
+            if (record.revoked) {
+              proxies.delete(record);
+              removeScopeRevoke?.();
+              removeScopeDispose?.();
+            }
+          }
+        },
+        revoke(reason = "remote service proxy revoked") {
+          revokeProxy(record, reason);
+          proxies.delete(record);
+          removeScopeRevoke?.();
+          removeScopeDispose?.();
+        }
+      };
+      return proxy;
+    },
+    requireProxy(lookup, scope) {
+      const proxy = bridge.getProxy(lookup, scope);
+      if (!proxy) {
+        throw new RemoteServiceUnavailableError(
+          `Service "${lookup.capabilityId}" version "${lookup.contractVersion}" is not ready`
+        );
+      }
+      return proxy;
+    },
+    invalidate(reason = "remote service bridge invalidated") {
+      clearReferences(reason);
+      currentState = "stale";
+      lastRevision = void 0;
+      hasBaseline = false;
+      notify();
+    },
+    disconnect(reason = "remote service connection disconnected") {
+      clearReferences(reason);
+      currentConnectionId = void 0;
+      currentAuthorityInstanceId = void 0;
+      lastRevision = void 0;
+      hasBaseline = false;
+      currentState = "disconnected";
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    services() {
+      return [...references.values()];
+    }
+  };
+  return bridge;
+}
+var createRemoteServiceBridge = createServiceBridge;
+
+// src/transport/messagePortServiceTransport.ts
+var nextTransportId = 0;
+var nextCallSequence = 0;
+function makeTransportId() {
+  nextTransportId += 1;
+  return nextTransportId;
+}
+function makeCallId(transportId) {
+  nextCallSequence += 1;
+  return `remote-call:${transportId}:${nextCallSequence}`;
+}
+function errorFromWire(input) {
+  const error = new Error(
+    typeof input?.message === "string" ? input.message : "Remote service call failed"
+  );
+  if (typeof input?.name === "string" && input.name.length > 0) error.name = input.name;
+  if (typeof input?.code === "string" && input.code.length > 0) {
+    Object.defineProperty(error, "code", {
+      configurable: true,
+      enumerable: true,
+      value: input.code,
+      writable: false
+    });
+  }
+  return error;
+}
+function abortReason(signal) {
+  return signal.reason ?? new RemoteServiceUnavailableError("Remote service request aborted");
+}
+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.callId === "string" && typeof message.connectionId === "string" && typeof message.providerInstanceId === "string";
+}
+function createMessagePortServiceTransport(options) {
+  const pending = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const transportId = makeTransportId();
+  const codec = options.codec ?? createRemoteServiceMessageCodec();
+  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.connectionId !== call.connectionId || decoded.providerInstanceId !== call.providerInstanceId) return;
+    pending.delete(decoded.callId);
+    call.removeAbort();
+    if (decoded.type === codec.type("error")) {
+      call.reject(errorFromWire(decoded.error));
+    } else {
+      call.resolve(decoded.result);
+    }
+  };
+  options.port.addEventListener("message", onMessage);
+  options.port.start();
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    options.port.removeEventListener("message", onMessage);
+    for (const [callId, call] of pending) {
+      pending.delete(callId);
+      call.removeAbort();
+      call.reject(new RemoteServiceUnavailableError("Remote service transport disposed"));
+    }
+    if (options.closeOnDispose) options.port.close();
+  };
+  const transport = {
+    call(request, context) {
+      if (disposed) return Promise.reject(new RemoteServiceUnavailableError("Remote service transport disposed"));
+      if (context.signal.aborted) return Promise.reject(abortReason(context.signal));
+      const callId = makeCallId(transportId);
+      const providerInstanceId = context.reference.providerInstanceId;
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (callback) => {
+          if (settled) return;
+          settled = true;
+          callback();
+        };
+        const onAbort = () => {
+          if (!pending.delete(callId)) return;
+          finish(() => reject(abortReason(context.signal)));
+          try {
+            const cancel = {
+              type: codec.type("cancel"),
+              callId,
+              connectionId: context.connectionId,
+              providerInstanceId
+            };
+            options.port.postMessage(codec.encode(cancel));
+          } catch {
+          }
+        };
+        const pendingCall = {
+          connectionId: context.connectionId,
+          providerInstanceId,
+          resolve: (value) => finish(() => resolve(value)),
+          reject: (error) => finish(() => reject(error)),
+          removeAbort: () => context.signal.removeEventListener("abort", onAbort)
+        };
+        pending.set(callId, pendingCall);
+        context.signal.addEventListener("abort", onAbort, { once: true });
+        try {
+          const message = {
+            type: codec.type("call"),
+            callId,
+            connectionId: context.connectionId,
+            providerInstanceId,
+            ...context.operationId ? { operationId: context.operationId } : {},
+            ...context.grantId ?? context.reference.grantId ? { grantId: context.grantId ?? context.reference.grantId } : {},
+            reference: context.reference,
+            request
+          };
+          const transfer = options.transferForRequest?.(request, context) ?? [];
+          options.port.postMessage(codec.encode(message), [...transfer]);
+          if (context.signal.aborted) onAbort();
+        } catch (error) {
+          pending.delete(callId);
+          pendingCall.removeAbort();
+          pendingCall.reject(error);
+        }
+      });
+    },
+    dispose
+  };
+  return transport;
+}
+
+export { LIFECYCLE_ERROR_TEXT, LifecycleScopeRevokedError, PermissionDeniedError, PermissionLeaseRevokedError, PluginGraphValidationError, RESOURCE_OWNER, RESOURCE_REGISTRY_CAPABILITY, RUNTIME_MESSAGE_BUS, RemoteServiceUnavailableError, SCOPED_TASK_SCHEDULER_CAPABILITY, StartupCapabilityError, StartupPluginError, UpgradeGateRejectedError, buildPluginGraph, createCapabilityRegistry, createInMemoryPluginConfigStore, createLifecycleScope, createMessageBus, createMessagePortServiceTransport, createPermissionLease, createPluginHost, createPluginIntentController, createRemoteServiceBridge, createRemoteServiceMessageCodec, createResourceRegistry, createResourceScope, createResourceStore, createRuntimeUnitImplementationRegistry, createScopedMessageBus, createScopedTaskScheduler, createServiceBridge, dependenciesOfManifest, lifecycleErrorText, providesOfManifest, registerOwnedResource, reverseDependentsOf, validatePluginGraph, validateRuntimeUnitDependencyContracts };
+//# sourceMappingURL=chunk-KGNF36DZ.js.map
+//# sourceMappingURL=chunk-KGNF36DZ.js.map