webloom-framework 0.1.0 → 0.3.0

package/dist/{chunk-KGNF36DZ.js → chunk-76BGPI6M.js}

@@ -24,16 +24,12 @@ var PermissionDeniedError = class extends Error {
 };
 function createRemoteServiceMessageCodec(options = {}) {
   const prefix = options.prefix ?? "webloom.remote-service";
-  const protocolVersion = options.protocolVersion ?? "1";
+  const protocolVersion = options.protocolVersion ?? "webloom.remote-service.v2";
   const types = /* @__PURE__ */ new Map([
     ["call", `${prefix}.call`],
     ["result", `${prefix}.result`],
     ["error", `${prefix}.error`],
-    ["cancel", `${prefix}.cancel`],
-    ["handshake", `${prefix}.handshake`],
-    ["snapshot", `${prefix}.snapshot`],
-    ["invalidate", `${prefix}.invalidate`],
-    ["disconnect", `${prefix}.disconnect`]
+    ["cancel", `${prefix}.cancel`]
   ]);
   return Object.freeze({
     protocolVersion,
@@ -53,11 +49,14 @@ function createRemoteServiceMessageCodec(options = {}) {
     }
   });
 }
-var RemoteServiceUnavailableError = class extends Error {
-  code = "service.unavailable";
-  constructor(message = "Remote service is unavailable") {
+var RemoteServiceError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
     super(message);
-    this.name = "RemoteServiceUnavailableError";
+    this.name = "RemoteServiceError";
+    this.code = code;
+    this.details = details;
   }
 };
 var UpgradeGateRejectedError = class extends Error {
@@ -136,11 +135,8 @@ var PluginGraphValidationError = class extends Error {
 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 isRuntimeKind(value) {
+  return value === "window-main" || value === "shared-worker";
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -228,11 +224,11 @@ function validateRuntimeUnitDependencyContracts(manifests) {
         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 (!isRuntimeKind(dependency.sourceRuntime)) {
+          errors.push("sourceRuntime\uFF08\u63D0\u4F9B\u8005 Runtime\uFF09\u65E0\u6548");
         }
-        if (!isPluginLifetime(dependency.scope)) {
-          errors.push("scope\uFF08\u63D0\u4F9B\u8005\u4F5C\u7528\u57DF\uFF09\u65E0\u6548");
+        if (unitValue.runtime !== void 0 && !isRuntimeKind(unitValue.runtime)) {
+          errors.push("runtime\uFF08\u76EE\u6807 Runtime\uFF09\u65E0\u6548");
         }
         if (dependency.reason !== void 0 && typeof dependency.reason !== "string") {
           errors.push("reason\uFF08\u4F9D\u8D56\u8BF4\u660E\uFF09\u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
@@ -250,15 +246,34 @@ function validateRuntimeUnitDependencyContracts(manifests) {
       });
     });
   }
+  for (const manifest of manifests) {
+    for (const unit of manifest.units ?? []) {
+      if (!isRuntimeKind(unit.runtime)) {
+        diagnostics.push({
+          code: "plugin.runtime_invalid",
+          ids: [manifest.id, unit.id],
+          message: `\u63D2\u4EF6 "${manifest.id}" \u7684\u8FD0\u884C\u5355\u5143 "${unit.id}" \u58F0\u660E\u4E86\u4E0D\u652F\u6301\u7684 Runtime\uFF1Bv1 \u4EC5\u652F\u6301 window-main/shared-worker`
+        });
+      }
+    }
+  }
   return diagnostics;
 }
-function selectedRuntimeUnits(manifest, execution) {
+function unitRuntime(unit) {
+  return unit.runtime;
+}
+function isRuntimeUnit(unit) {
+  return typeof unit.id === "string" && unit.id.length > 0 && isRuntimeKind(unit.runtime);
+}
+function selectedRuntimeUnits(manifest, runtime) {
   const units = manifest.units ?? [];
   if (units.length === 0) return [];
-  if (execution !== void 0) return units.filter((unit) => unit.execution === execution);
-  return units.length === 1 ? [...units] : [];
+  if (runtime !== void 0) return units.filter(
+    (unit) => isRuntimeUnit(unit) && unit.runtime === runtime
+  );
+  return units.length === 1 && isRuntimeUnit(units[0]) ? [units[0]] : [];
 }
-function dependenciesOfManifest(manifest, execution) {
+function dependenciesOfManifest(manifest, runtime) {
   const byCapability = /* @__PURE__ */ new Map();
   const add = (dependency) => {
     const previous = byCapability.get(dependency.capability);
@@ -267,8 +282,8 @@ function dependenciesOfManifest(manifest, execution) {
     }
   };
   const units = manifest.units ?? [];
-  if (units.length > 1 && execution === void 0) return [];
-  const selectedUnits = selectedRuntimeUnits(manifest, execution);
+  if (units.length > 1 && runtime === void 0) return [];
+  const selectedUnits = selectedRuntimeUnits(manifest, runtime);
   if (units.length > 0 && selectedUnits.length === 0) return [];
   if (units.length === 0) {
     for (const dependency of manifest.dependencies ?? []) add(dependency);
@@ -279,12 +294,12 @@ function dependenciesOfManifest(manifest, execution) {
   }
   return [...byCapability.values()];
 }
-function providesOfManifest(manifest, execution) {
+function providesOfManifest(manifest, runtime) {
   const units = manifest.units ?? [];
-  if (units.length > 1 && execution === void 0) return [];
+  if (units.length > 1 && runtime === void 0) return [];
   return unique([
     ...units.length === 0 ? manifest.provides ?? [] : [],
-    ...selectedRuntimeUnits(manifest, execution).flatMap((unit) => unit.provides ?? [])
+    ...selectedRuntimeUnits(manifest, runtime).flatMap((unit) => unit.provides ?? [])
   ]);
 }
 function runtimeUnitProviders(manifests, capability) {
@@ -292,11 +307,11 @@ function runtimeUnitProviders(manifests, capability) {
   for (const manifest of manifests) {
     for (const unit of manifest.units ?? []) {
       if (!unit.provides?.includes(capability)) continue;
+      if (!isRuntimeUnit(unit)) continue;
       providers.push({
         pluginId: manifest.id,
         unitId: unit.id,
-        execution: unit.execution,
-        lifetime: unit.lifetime,
+        runtime: unit.runtime,
         contractVersion: unit.providedContracts?.[capability]
       });
     }
@@ -305,12 +320,12 @@ function runtimeUnitProviders(manifests, capability) {
 }
 function matchingRuntimeUnitProviders(manifests, dependency) {
   return runtimeUnitProviders(manifests, dependency.capability).filter(
-    (provider) => provider.execution === dependency.sourceExecution && provider.lifetime === dependency.scope && provider.contractVersion === dependency.contractVersion
+    (provider) => provider.runtime === dependency.sourceRuntime && provider.contractVersion === dependency.contractVersion
   );
 }
-function runtimeDependenciesForValidation(manifest, execution) {
+function runtimeDependenciesForValidation(manifest, runtime) {
   const units = manifest.units ?? [];
-  const selected = execution === void 0 ? units : units.filter((unit) => unit.execution === execution);
+  const selected = runtime === void 0 ? units : units.filter((unit) => unitRuntime(unit) === runtime);
   return selected.flatMap((unit) => unit.dependencies ?? []);
 }
 function buildPluginGraph(manifests, options = {}) {
@@ -322,9 +337,9 @@ function buildPluginGraph(manifests, options = {}) {
   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);
+    const selectedUnits = selectedRuntimeUnits(manifest, options.runtime);
+    const provided = providesOfManifest(manifest, options.runtime);
+    const dependencyEntries = dependenciesOfManifest(manifest, options.runtime);
     dependencyDetails[manifest.id] = dependencyEntries.map((dependency) => ({ ...dependency }));
     const deps = unique(dependencyEntries.map((dependency) => dependency.capability));
     optionalDependencies[manifest.id] = unique(
@@ -337,7 +352,7 @@ function buildPluginGraph(manifests, options = {}) {
       unitGraph[unitKey] = {
         pluginId: manifest.id,
         unitId: unit.id,
-        execution: unit.execution,
+        runtime: unit.runtime,
         dependencies: unique((unit.dependencies ?? []).map((dependency) => dependency.capability)),
         dependencyDetails: (unit.dependencies ?? []).map((dependency) => ({ ...dependency })),
         provides: unique(unit.provides ?? []),
@@ -391,7 +406,7 @@ function buildPluginGraph(manifests, options = {}) {
       visited.add(pluginId);
       return;
     }
-    for (const dependency of dependenciesOfManifest(manifest, options.execution)) {
+    for (const dependency of dependenciesOfManifest(manifest, options.runtime)) {
       if (dependency.optional) continue;
       const provider = firstProvider.get(dependency.capability);
       if (provider) visit(provider);
@@ -439,9 +454,12 @@ function validatePluginGraph(manifests, options = {}) {
     }
   }
   for (const manifest of manifests) {
-    const strictDependencies = runtimeDependenciesForValidation(manifest, options.execution);
+    const strictDependencies = runtimeDependenciesForValidation(manifest, options.runtime);
     for (const dependency of strictDependencies) {
       if (dependency.optional) continue;
+      if (options.externalRuntimeDependencies && options.runtime !== void 0 && dependency.sourceRuntime !== options.runtime) {
+        continue;
+      }
       const matches = matchingRuntimeUnitProviders(manifests, dependency);
       if (matches.length > 0) {
         if (matches.length > 1 && !multiProvider.has(dependency.capability)) {
@@ -474,9 +492,9 @@ function validatePluginGraph(manifests, options = {}) {
   }
   for (const manifest of manifests) {
     const strictDependencyCapabilities = new Set(
-      runtimeDependenciesForValidation(manifest, options.execution).map((dependency) => dependency.capability)
+      runtimeDependenciesForValidation(manifest, options.runtime).map((dependency) => dependency.capability)
     );
-    for (const dependency of dependenciesOfManifest(manifest, options.execution)) {
+    for (const dependency of dependenciesOfManifest(manifest, options.runtime)) {
       if (dependency.optional) continue;
       if (strictDependencyCapabilities.has(dependency.capability)) continue;
       const provided = (graph.providers?.[dependency.capability]?.length ?? 0) > 0 || builtins.has(dependency.capability);
@@ -2189,24 +2207,26 @@ function lifecycleStateFor(state, desired) {
       return desired ? "waiting" : "disabled";
   }
 }
-function selectedUnit(manifest, execution, defaultLifetime) {
+function selectedUnit(manifest, runtime) {
   const units = manifest.units ?? [];
   if (units.length > 1) {
-    const matches = execution === void 0 ? [] : units.filter((unit) => unit.execution === execution);
+    const matches = runtime === void 0 ? [] : units.filter(
+      (unit) => unit.runtime === runtime
+    );
     return matches.length === 1 ? matches[0] : void 0;
   }
   if (units.length === 1) {
-    return execution === void 0 || units[0]?.execution === execution ? units[0] : void 0;
+    const unit = units[0];
+    return unit && (runtime === void 0 || unit.runtime === runtime) && unit.runtime !== void 0 ? unit : void 0;
   }
+  const targetRuntime = runtime ?? "window-main";
   return {
     id: manifest.id,
-    execution: manifest.meta.execution ?? execution ?? "default",
-    lifetime: manifest.meta.lifetime ?? defaultLifetime,
+    runtime: targetRuntime,
     dependencies: manifest.dependencies?.map((dependency) => ({
       capability: dependency.capability,
       contractVersion: dependency.contractVersion ?? `${dependency.capability}.v1`,
-      sourceExecution: dependency.sourceExecution ?? "default",
-      scope: dependency.scope ?? defaultLifetime,
+      sourceRuntime: dependency.sourceRuntime ?? targetRuntime,
       ...dependency.reason !== void 0 ? { reason: dependency.reason } : {},
       ...dependency.optional !== void 0 ? { optional: dependency.optional } : {}
     })),
@@ -2216,17 +2236,12 @@ function selectedUnit(manifest, execution, defaultLifetime) {
     contribution: manifest.contribution
   };
 }
-function dependenciesFor(manifest, execution) {
-  return dependenciesOfManifest(manifest, execution);
+function dependenciesFor(manifest, runtime) {
+  return dependenciesOfManifest(manifest, runtime);
 }
 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") {
@@ -2244,6 +2259,7 @@ var StartupPluginError = class extends Error {
   }
 };
 function createPluginHost(options = {}) {
+  const runtimeKind = options.runtime;
   const listeners = /* @__PURE__ */ new Set();
   let versionCounter = 0;
   let hostDisposed = false;
@@ -2290,7 +2306,6 @@ function createPluginHost(options = {}) {
   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;
@@ -2300,8 +2315,10 @@ function createPluginHost(options = {}) {
     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 selected = (manifest) => selectedUnit(manifest, runtimeKind);
+  const graph = () => buildPluginGraph([
+    ...knownManifests.values()
+  ], { runtime: runtimeKind, enabledPluginIds: enabledSet });
   const validateManifest = (manifest) => {
     if (!manifest || typeof manifest.id !== "string" || manifest.id.trim() === "") throw new Error("Plugin id must be a non-empty string");
     if (typeof manifest.name !== "string" || manifest.name.trim() === "") throw new Error(`Plugin "${manifest.id}" name must be a non-empty string`);
@@ -2312,12 +2329,17 @@ function createPluginHost(options = {}) {
       throw new Error(`Plugin "${manifest.id}" required startup metadata is inconsistent`);
     }
     if (manifest.units !== void 0 && !Array.isArray(manifest.units)) throw new Error(`Plugin "${manifest.id}" units must be an array`);
+    if ((manifest.units?.length ?? 0) > 1 && runtimeKind === void 0) {
+      throw new Error(`Plugin "${manifest.id}" runtime must be explicit for multi-unit manifests`);
+    }
     if (manifest.units && manifest.units.length > 0) {
       const ids = /* @__PURE__ */ new Set();
       for (const unit of manifest.units) {
         if (!unit.id || ids.has(unit.id)) throw new Error(`Plugin "${manifest.id}" has duplicate or empty unit id`);
         ids.add(unit.id);
-        if (!unit.execution || !unit.lifetime) throw new Error(`Plugin "${manifest.id}" unit "${unit.id}" must define execution and lifetime`);
+        if (unit.runtime !== "window-main" && unit.runtime !== "shared-worker") {
+          throw new Error(`Plugin "${manifest.id}" unit "${unit.id}" declares an unsupported Runtime`);
+        }
       }
     }
     options.manifestValidator?.(manifest);
@@ -2325,9 +2347,18 @@ function createPluginHost(options = {}) {
   const isRequired = (manifest) => manifest.meta.startup === "required" || manifest.meta.canDisable === false;
   const missingDependencies = (manifest) => {
     const missing = [];
-    for (const dependency of dependenciesFor(manifest, options.execution)) {
+    const selectedUnitForDependencies = selected(manifest);
+    const localRuntime = selectedUnitForDependencies?.runtime ?? runtimeKind;
+    for (const dependency of dependenciesFor(manifest, runtimeKind)) {
       if (dependency.optional) continue;
-      if (!capabilities.has(dependency.capability)) missing.push(dependency.capability);
+      const sourceRuntime = dependency.sourceRuntime ?? localRuntime;
+      const contractVersion = dependency.contractVersion ?? `${dependency.capability}.v1`;
+      if (sourceRuntime !== void 0 && sourceRuntime !== localRuntime) {
+        const available = options.remoteServiceReferences?.().some((reference) => reference.status === "ready" && reference.runtime === sourceRuntime && reference.capabilityId === dependency.capability && reference.contractVersion === contractVersion) ?? false;
+        if (!available) missing.push(dependency.capability);
+      } else if (!capabilities.has(dependency.capability)) {
+        missing.push(dependency.capability);
+      }
     }
     return [...new Set(missing)];
   };
@@ -2335,21 +2366,21 @@ function createPluginHost(options = {}) {
     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)) {
+      if (units.length > 0 && runtimeKind !== void 0 && !units.some((item) => item.runtime === runtimeKind)) {
         const snapshots = runtimeSnapshots?.() ?? [];
         if (snapshots.some((item) => item.pluginId === manifest.id)) return `runtime:${manifest.id}:unknown`;
       }
       return units.length > 0 ? `runtime:${manifest.id}:unit-unavailable` : void 0;
     }
+    const unavailable = options.runtimeUnitAvailability?.({
+      pluginId: manifest.id,
+      unitId: unit.id,
+      runtime: unit.runtime
+    });
+    if (unavailable) return unavailable;
     if (!setupFor(manifest, unit, options)) return `runtime:${manifest.id}:${unit.id}:implementation-unavailable`;
     return void 0;
   };
-  const 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;
@@ -2677,19 +2708,25 @@ function createPluginHost(options = {}) {
         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 });
+        const attributes = Object.freeze({
+          ...rootAttributes,
+          ...options.runtimeUnitAttributes?.({
+            pluginId: record.manifest.id,
+            unitId: unit.id,
+            runtime: unit.runtime,
+            manifest: record.manifest
+          }) ?? {}
+        });
+        const parent = options.runtimeUnitParentScope?.({
+          pluginId: record.manifest.id,
+          unitId: unit.id,
+          runtime: unit.runtime,
+          manifest: record.manifest
+        }) ?? rootScope;
+        scope = parent.child("runtime-unit", { pluginId: record.manifest.id, attributes });
       } catch (error) {
         record.state = "blocked";
         record.blockedBy = [errorMessage4(error)];
@@ -2701,7 +2738,6 @@ function createPluginHost(options = {}) {
       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();
@@ -2712,7 +2748,7 @@ function createPluginHost(options = {}) {
         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 declared = providesOfManifest(record.manifest, runtimeKind);
         const missingDeclarations = declared.filter((key) => !record.capabilities.has(key));
         if (missingDeclarations.length > 0) {
           throw new Error(`Plugin "${record.manifest.id}" did not provide declared capabilities: ${missingDeclarations.join(", ")}`);
@@ -2743,7 +2779,13 @@ function createPluginHost(options = {}) {
         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 });
+        throw new StartupPluginError({
+          pluginId: record.manifest.id,
+          unitId: unit.id,
+          capabilities: providesOfManifest(record.manifest, runtimeKind),
+          state: record.state,
+          error: record.error
+        });
       }
     })();
     starting.set(pluginId, task);
@@ -2780,32 +2822,29 @@ function createPluginHost(options = {}) {
     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);
-      }
+      const ordered = orderManifestsByDependencies(manifests, runtimeKind);
       for (const manifest of ordered) {
         const record = records.get(manifest.id);
         if (!record) continue;
+        if (record && (record.state === "enabled" || record.state === "starting")) {
+          const missing = missingDependencies(manifest);
+          const unavailable = runtimeUnavailable(manifest);
+          if (missing.length > 0 || unavailable) {
+            await stopPlugin(
+              record,
+              "runtime dependency unavailable",
+              true,
+              [.../* @__PURE__ */ new Set([...missing, ...unavailable ? [unavailable] : []])]
+            );
+          }
+        }
         if (desiredEnabledFor(manifest.id, manifest) && record.state !== "enabled" && record.state !== "starting") {
-          await enable(manifest.id);
+          try {
+            await enable(manifest.id);
+          } catch (error) {
+            if (!isRequired(manifest)) continue;
+            throw error;
+          }
         }
       }
       for (const manifest of manifests) {
@@ -2819,10 +2858,14 @@ function createPluginHost(options = {}) {
     });
     return reconcilePromise;
   };
-  function orderManifestsByDependencies(manifests, execution) {
+  function orderManifestsByDependencies(manifests, runtime) {
     const byId = new Map(manifests.map((manifest) => [manifest.id, manifest]));
     const providers = /* @__PURE__ */ new Map();
-    for (const manifest of manifests) for (const capability of providesOfManifest(manifest, execution)) if (!providers.has(capability)) providers.set(capability, manifest.id);
+    for (const manifest of manifests) {
+      for (const capability of providesOfManifest(manifest, runtime)) {
+        if (!providers.has(capability)) providers.set(capability, manifest.id);
+      }
+    }
     const visited = /* @__PURE__ */ new Set();
     const visiting = /* @__PURE__ */ new Set();
     const ordered = [];
@@ -2830,7 +2873,7 @@ function createPluginHost(options = {}) {
       if (visited.has(manifest.id)) return;
       if (visiting.has(manifest.id)) return;
       visiting.add(manifest.id);
-      for (const dependency of dependenciesFor(manifest, execution)) {
+      for (const dependency of dependenciesFor(manifest, runtime)) {
         if (dependency.optional) continue;
         const provider = providers.get(dependency.capability);
         const providerManifest = provider ? byId.get(provider) : void 0;
@@ -2868,7 +2911,14 @@ function createPluginHost(options = {}) {
         ...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 } : {} }] : []
+        units: unit ? [{
+          pluginId,
+          unitId: unit.id,
+          runtime: unit.runtime,
+          kind: record.state,
+          ...record.instanceId ? { instanceId: record.instanceId } : {},
+          ...record.error ? { error: record.error } : {}
+        }] : []
       };
     },
     scope: (pluginId) => records.get(pluginId)?.scope,
@@ -2889,7 +2939,14 @@ function createPluginHost(options = {}) {
     },
     validateManifestSet(manifests) {
       for (const manifest of manifests) validateManifest(manifest);
-      validatePluginGraph([...manifests], { execution: options.execution, builtinCapabilities: new Set(capabilities.keys()) });
+      validatePluginGraph([...manifests], {
+        runtime: runtimeKind,
+        builtinCapabilities: /* @__PURE__ */ new Set([
+          ...capabilities.keys(),
+          ...(options.remoteServiceReferences?.() ?? []).map((reference) => reference.capabilityId)
+        ]),
+        externalRuntimeDependencies: options.externalRuntimeDependencies
+      });
     },
     provide(key, value) {
       if (hostDisposed) throw new LifecycleScopeRevokedError("Plugin host is disposed");
@@ -2912,7 +2969,15 @@ function createPluginHost(options = {}) {
         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 });
+      validatePluginGraph(current, {
+        runtime: runtimeKind,
+        builtinCapabilities: /* @__PURE__ */ new Set([
+          ...capabilities.keys(),
+          ...(options.remoteServiceReferences?.() ?? []).map((reference) => reference.capabilityId)
+        ]),
+        allowMissingDependencies: false,
+        externalRuntimeDependencies: options.externalRuntimeDependencies
+      });
       for (const manifest of current) {
         knownManifests.set(manifest.id, manifest);
         records.set(manifest.id, { manifest, state: "registered", disposeCallbacks: [], capabilities: /* @__PURE__ */ new Set(), contributions: [] });
@@ -2984,6 +3049,13 @@ function createPluginHost(options = {}) {
       );
       return { ok: true };
     },
+    suspend: async (pluginId, reason = "runtime identity changed") => {
+      const record = records.get(pluginId);
+      if (!record) return;
+      if (record.state !== "enabled" && record.state !== "starting") return;
+      beginStop(record, reason, true);
+      await stopPlugin(record, reason, true);
+    },
     unregister: async (pluginId) => {
       const record = records.get(pluginId);
       if (!record) return;
@@ -2999,7 +3071,6 @@ function createPluginHost(options = {}) {
       hostDisposed = true;
       removeConfigSubscription();
       removeIntentSubscription();
-      removeScopeSubscription();
       disposePromise = (async () => {
         for (const record of [...records.values()].reverse()) {
           if (record.state === "enabled" || record.state === "starting") {
@@ -3049,13 +3120,6 @@ function createPluginHost(options = {}) {
     void reconcile().catch(() => void 0);
     bumpVersion();
   });
-  if (options.scopeResolver?.subscribe) {
-    removeScopeSubscription = options.scopeResolver.subscribe(() => {
-      void reconcile().catch(() => void 0);
-      resourceStore.refreshRuntimeBindings();
-      bumpVersion();
-    });
-  }
   return host;
 }
 
@@ -3082,206 +3146,82 @@ function createRuntimeUnitImplementationRegistry(implementations = []) {
   };
 }
 
-// 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;
+// src/runtime/runtimeTypes.ts
+var RuntimeInitializationError = class extends Error {
+  code = "runtime_initialization_failed";
+  details;
+  constructor(details) {
+    super(
+      `Runtime initialization failed${details.pluginId ? ` for ${details.pluginId}` : ""} during ${details.phase}: ${details.error}`
+    );
+    this.name = "RuntimeInitializationError";
+    this.details = details;
   }
-  const desiredRevision = {};
-  for (const [pluginId, value] of Object.entries(initial?.desiredRevision ?? {})) {
-    if (Number.isSafeInteger(value) && value >= 0) desiredRevision[pluginId] = value;
+};
+var RuntimeUnavailableError = class extends Error {
+  code = "transport_unavailable";
+  constructor(message = "Runtime is unavailable") {
+    super(message);
+    this.name = "RuntimeUnavailableError";
   }
-  return { revision, desiredEnabled, desiredRevision };
+};
+
+// src/runtime/runtimeProtocol.ts
+var RUNTIME_PROTOCOL_VERSION = "webloom.runtime.v2";
+var RUNTIME_SNAPSHOT_TYPE = "webloom.runtime.snapshot";
+var RUNTIME_ERROR_TYPE = "webloom.runtime.error";
+function isRecord2(input) {
+  return typeof input === "object" && input !== null;
 }
-function commandFingerprint(command) {
-  return [
-    command.authorityInstanceId,
-    command.expectedRevision,
-    command.pluginId,
-    command.desiredEnabled ? "true" : "false"
-  ].join("\0");
+function isNonEmptyString(input) {
+  return typeof input === "string" && input.length > 0;
 }
-function commandError(message) {
-  return { status: "command-conflict", commandId: "", message };
+function isRuntimeKind2(input) {
+  return input === "window-main" || input === "shared-worker";
 }
-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;
+function isPluginStateKind(input) {
+  return input === "registered" || input === "starting" || input === "stopping" || input === "enabled" || input === "disabled" || input === "blocked" || input === "error-disabled" || input === "cleanup-pending" || input === "unknown";
 }
-
-// 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 isRemoteServiceReference(input) {
+  if (!isRecord2(input)) return false;
+  const reference = input;
+  return isNonEmptyString(reference.capabilityId) && isNonEmptyString(reference.contractVersion) && isRuntimeKind2(reference.runtime) && isNonEmptyString(reference.runtimeInstanceId) && isNonEmptyString(reference.serviceInstanceId) && (reference.status === "starting" || reference.status === "ready" || reference.status === "unavailable" || reference.status === "failed") && isRecord2(reference.attributes) && !Array.isArray(reference.attributes) && (reference.grantId === void 0 || isNonEmptyString(reference.grantId)) && (reference.authorizationRevision === void 0 || Number.isSafeInteger(reference.authorizationRevision) && reference.authorizationRevision >= 0);
 }
-function 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 };
+function isRuntimeSnapshotUnit(input) {
+  if (!isRecord2(input)) return false;
+  const unit = input;
+  return isNonEmptyString(unit.pluginId) && isNonEmptyString(unit.unitId) && isRuntimeKind2(unit.runtime) && isPluginStateKind(unit.state) && (unit.instanceId === void 0 || isNonEmptyString(unit.instanceId));
+}
+function createRuntimeMessageCodec() {
+  return createRemoteServiceMessageCodec({
+    prefix: "webloom.runtime",
+    protocolVersion: RUNTIME_PROTOCOL_VERSION
   });
+}
+function isRuntimeSnapshot(input) {
+  if (!isRecord2(input)) return false;
+  const message = input;
+  return message.type === RUNTIME_SNAPSHOT_TYPE && isNonEmptyString(message.protocolVersion) && isNonEmptyString(message.runtimeId) && isRuntimeKind2(message.runtimeKind) && isNonEmptyString(message.runtimeInstanceId) && Number.isSafeInteger(message.revision) && message.revision >= 0 && Array.isArray(message.units) && message.units.every(isRuntimeSnapshotUnit) && Array.isArray(message.services) && message.services.every(isRemoteServiceReference) && (message.state === "starting" || message.state === "ready" || message.state === "stopping" || message.state === "failed" || message.state === "disposed");
+}
+function isRuntimeSnapshotProtocol(input) {
+  return input.protocolVersion === RUNTIME_PROTOCOL_VERSION;
+}
+function isRuntimeError(input) {
+  if (!isRecord2(input)) return false;
+  const message = input;
+  return message.type === RUNTIME_ERROR_TYPE && isNonEmptyString(message.protocolVersion) && (message.code === "runtime_initialization_failed" || message.code === "protocol_mismatch" || message.code === "transport_unavailable") && isNonEmptyString(message.message) && (message.pluginId === void 0 || isNonEmptyString(message.pluginId)) && (message.unitId === void 0 || isNonEmptyString(message.unitId)) && (message.phase === void 0 || message.phase === "startup" || message.phase === "snapshot");
+}
+function unitSnapshotFromState(state, runtime) {
   return {
-    signal: controller.signal,
-    dispose: () => {
-      for (const item of listeners) item.signal.removeEventListener("abort", item.listener);
-    }
+    pluginId: state.pluginId,
+    unitId: state.unitId,
+    runtime,
+    ...state.instanceId !== void 0 ? { instanceId: state.instanceId } : {},
+    state: state.kind
   };
 }
+
+// src/transport/serviceBridge.ts
 function stableAttributes(value) {
   const normalize = (input) => {
     if (Array.isArray(input)) return input.map(normalize);
@@ -3292,33 +3232,127 @@ function stableAttributes(value) {
   };
   return JSON.stringify(normalize(value));
 }
+function isPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isSafeAttributeValue(value, seen) {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  const valid = Array.isArray(value) ? value.every((item) => isSafeAttributeValue(item, seen)) : isPlainRecord(value) && !Reflect.ownKeys(value).some((key) => typeof key !== "string") && Object.values(value).every((item) => isSafeAttributeValue(item, seen));
+  seen.delete(value);
+  return valid;
+}
+function isValidAttributes(value) {
+  return isPlainRecord(value) && isSafeAttributeValue(value, /* @__PURE__ */ new Set());
+}
+function isValidSnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== "object" || typeof snapshot.protocolVersion !== "string" || snapshot.protocolVersion.length === 0 || typeof snapshot.runtimeInstanceId !== "string" || snapshot.runtimeInstanceId.length === 0 || !Number.isSafeInteger(snapshot.revision) || snapshot.revision < 0 || !Array.isArray(snapshot.services)) return false;
+  if (snapshot.runtimeId !== void 0 && (typeof snapshot.runtimeId !== "string" || snapshot.runtimeId.length === 0)) return false;
+  if (snapshot.runtimeKind !== void 0 && snapshot.runtimeKind !== "window-main" && snapshot.runtimeKind !== "shared-worker") return false;
+  if (snapshot.state !== void 0 && snapshot.state !== "starting" && snapshot.state !== "ready" && snapshot.state !== "stopping" && snapshot.state !== "failed" && snapshot.state !== "disposed") return false;
+  const bindingKeys = /* @__PURE__ */ new Set();
+  const serviceCapabilityKeys = /* @__PURE__ */ new Set();
+  const readyLookupKeys = /* @__PURE__ */ new Set();
+  for (const service of snapshot.services) {
+    if (!service || typeof service !== "object" || typeof service.capabilityId !== "string" || service.capabilityId.length === 0 || typeof service.contractVersion !== "string" || service.contractVersion.length === 0 || service.runtime !== "window-main" && service.runtime !== "shared-worker" || service.runtimeInstanceId !== snapshot.runtimeInstanceId || typeof service.serviceInstanceId !== "string" || service.serviceInstanceId.length === 0 || service.status !== "starting" && service.status !== "ready" && service.status !== "unavailable" && service.status !== "failed" || !isValidAttributes(service.attributes) || service.grantId !== void 0 && (typeof service.grantId !== "string" || service.grantId.length === 0) || service.authorizationRevision !== void 0 && (!Number.isSafeInteger(service.authorizationRevision) || service.authorizationRevision < 0)) return false;
+    if (snapshot.runtimeKind !== void 0 && service.runtime !== snapshot.runtimeKind) return false;
+    const key = bindingKey(service);
+    if (bindingKeys.has(key)) return false;
+    bindingKeys.add(key);
+    const serviceCapabilityKey = `${service.capabilityId}\0${service.serviceInstanceId}`;
+    if (serviceCapabilityKeys.has(serviceCapabilityKey)) return false;
+    serviceCapabilityKeys.add(serviceCapabilityKey);
+    if (service.status === "ready") {
+      const lookupKey = `${service.capabilityId}\0${service.contractVersion}\0${service.runtime}`;
+      if (readyLookupKeys.has(lookupKey)) return false;
+      readyLookupKeys.add(lookupKey);
+    }
+  }
+  return true;
+}
 function referenceKey(reference) {
   return [
     reference.capabilityId,
-    reference.providerInstanceId,
-    reference.execution,
     reference.contractVersion,
-    reference.authorityInstanceId,
-    reference.scopeId,
-    reference.handoverGeneration,
+    reference.runtime,
+    reference.runtimeInstanceId,
+    reference.serviceInstanceId,
+    reference.status,
     stableAttributes(reference.attributes),
     reference.grantId ?? "null",
-    reference.authorizationRevision ?? "null",
-    // 代理绑定的是某一份权威目录快照；目录修订后即使 Provider 实例未变，
-    // 旧代理也不能继续使用旧授权视图，必须重新取得当前引用。
-    reference.snapshotRevision
+    reference.authorizationRevision ?? "null"
+  ].join("\0");
+}
+function bindingKey(reference) {
+  return [
+    reference.capabilityId,
+    reference.contractVersion,
+    reference.runtime,
+    reference.runtimeInstanceId,
+    reference.serviceInstanceId
   ].join("\0");
 }
 function lookupMatches(reference, lookup) {
-  return reference.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);
+  return reference.capabilityId === lookup.capabilityId && reference.contractVersion === lookup.contractVersion && (lookup.runtime === void 0 || reference.runtime === lookup.runtime);
 }
-function createServiceBridge(options) {
-  let currentState = "disconnected";
-  let currentConnectionId;
-  let currentAuthorityInstanceId;
-  let lastRevision;
-  let hasBaseline = false;
-  const references = /* @__PURE__ */ new Map();
+function ensureTimeout(value, label) {
+  const timeout = value ?? 3e4;
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new TypeError(`${label} must be a finite number greater than zero`);
+  }
+  return timeout;
+}
+function mergeSignals2(...signals) {
+  const active = signals.filter((signal) => signal !== void 0);
+  if (active.length === 0) return { signal: new AbortController().signal, dispose: () => void 0 };
+  const alreadyAborted = active.find((signal) => signal.aborted);
+  if (alreadyAborted) {
+    const controller2 = new AbortController();
+    controller2.abort(alreadyAborted.reason);
+    return { signal: controller2.signal, dispose: () => void 0 };
+  }
+  const controller = new AbortController();
+  const listeners = active.map((signal) => {
+    const listener = () => {
+      try {
+        controller.abort(signal.reason);
+      } catch {
+        controller.abort();
+      }
+    };
+    signal.addEventListener("abort", listener, { once: true });
+    return { signal, listener };
+  });
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      for (const { signal, listener } of listeners) signal.removeEventListener("abort", listener);
+    }
+  };
+}
+function abortedError(signal, fallback = "request_cancelled") {
+  const reason = signal.reason;
+  if (reason instanceof Error && typeof reason.code === "string") return reason;
+  if (reason instanceof Error && fallback === "request_cancelled") {
+    return new RemoteServiceError("request_cancelled", reason.message);
+  }
+  return new RemoteServiceError(fallback, fallback === "call_timeout" ? "Remote service call timed out" : "Remote service request was cancelled");
+}
+function callTimeoutError(timeoutMs) {
+  return new RemoteServiceError("call_timeout", `Remote service call exceeded its ${timeoutMs}ms deadline`, { timeoutMs });
+}
+function createServiceBridge(options) {
+  const defaultCallTimeoutMs = ensureTimeout(options.defaultCallTimeoutMs, "defaultCallTimeoutMs");
+  let currentState = "empty";
+  let currentRuntimeInstanceId;
+  let currentRevision;
+  let currentServices = [];
+  let terminalError;
   const proxies = /* @__PURE__ */ new Set();
   const listeners = /* @__PURE__ */ new Set();
   const notify = () => {
@@ -3329,155 +3363,162 @@ function createServiceBridge(options) {
       }
     }
   };
-  const revokeProxy = (proxy, reason) => {
-    if (proxy.revoked) return;
-    proxy.revoked = true;
-    proxy.reason = reason;
+  const revokeProxy = (record, reason, code = "service_revoked") => {
+    if (record.revoked) return;
+    record.revoked = true;
+    record.reason = reason;
     try {
-      proxy.controller.abort(new RemoteServiceUnavailableError(reason));
+      record.controller.abort(new RemoteServiceError(code, reason));
     } catch {
-      proxy.controller.abort();
+      record.controller.abort();
     }
   };
-  const invalidateProxies = (reason, keep) => {
-    for (const proxy of proxies) {
-      if (!keep?.has(referenceKey(proxy.reference))) {
-        revokeProxy(proxy, reason);
-        proxies.delete(proxy);
-      }
+  const revokeAll = (reason, code = "service_revoked") => {
+    for (const record of proxies) revokeProxy(record, reason, code);
+  };
+  const currentMatches = (lookup) => currentServices.filter((reference) => reference.status === "ready" && lookupMatches(reference, lookup));
+  const findBinding = (record, lookup) => {
+    if (record.boundReference) return record.boundReference;
+    if (terminalError) throw terminalError;
+    const matches = currentMatches(lookup);
+    if (matches.length > 1) {
+      throw new RemoteServiceError(
+        "capability_unavailable",
+        `Service "${lookup.capabilityId}" version "${lookup.contractVersion}" has multiple ready instances`
+      );
+    }
+    const reference = matches[0];
+    if (reference) {
+      record.boundReference = Object.freeze({
+        ...reference,
+        attributes: Object.freeze({ ...reference.attributes })
+      });
+      return record.boundReference;
     }
+    return void 0;
   };
-  const clearReferences = (reason) => {
-    references.clear();
-    invalidateProxies(reason);
+  const waitForBinding = (record, lookup, signal) => {
+    const immediate = findBinding(record, lookup);
+    if (immediate) return Promise.resolve(immediate);
+    if (record.revoked) return Promise.reject(new RemoteServiceError("service_revoked", record.reason));
+    if (signal.aborted) return Promise.reject(abortedError(signal));
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (callback) => {
+        if (settled) return;
+        settled = true;
+        removeListener();
+        callback();
+      };
+      const check = () => {
+        if (record.revoked) {
+          finish(() => reject(new RemoteServiceError("service_revoked", record.reason)));
+          return;
+        }
+        if (signal.aborted) {
+          finish(() => reject(abortedError(signal)));
+          return;
+        }
+        try {
+          const reference = findBinding(record, lookup);
+          if (reference) finish(() => resolve(reference));
+        } catch (error) {
+          finish(() => reject(error));
+        }
+      };
+      const onAbort = () => check();
+      const listener = () => check();
+      const removeListener = () => {
+        signal.removeEventListener("abort", onAbort);
+        listeners.delete(listener);
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      listeners.add(listener);
+      check();
+    });
   };
   const bridge = {
     get state() {
       return currentState;
     },
-    get connectionId() {
-      return currentConnectionId;
+    get runtimeInstanceId() {
+      return currentRuntimeInstanceId;
     },
-    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 };
+    get defaultCallTimeoutMs() {
+      return defaultCallTimeoutMs;
     },
     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 (currentState === "disposed") return { accepted: false, reason: "disposed" };
+      if (snapshot.protocolVersion !== options.protocolVersion) {
+        return { accepted: false, reason: "protocol-mismatch", receivedRevision: snapshot.revision };
       }
-      if (!Number.isSafeInteger(snapshot.snapshotRevision) || snapshot.snapshotRevision < 0) {
-        return {
-          accepted: false,
-          reason: "stale-revision",
-          receivedRevision: snapshot.snapshotRevision
-        };
+      if (!isValidSnapshot(snapshot)) {
+        return { accepted: false, reason: "invalid-snapshot", receivedRevision: snapshot.revision };
       }
-      if (!snapshot.baseline && !hasBaseline) {
-        currentState = "stale";
-        clearReferences("service bridge baseline required");
-        notify();
-        return {
-          accepted: false,
-          reason: "baseline-required",
-          receivedRevision: snapshot.snapshotRevision
-        };
+      if (currentRuntimeInstanceId === snapshot.runtimeInstanceId && currentRevision !== void 0 && snapshot.revision <= currentRevision) {
+        return { accepted: false, reason: "stale-revision", receivedRevision: snapshot.revision };
       }
-      if (lastRevision !== void 0 && snapshot.snapshotRevision <= lastRevision) {
-        return {
-          accepted: false,
-          reason: "stale-revision",
-          receivedRevision: snapshot.snapshotRevision
-        };
+      const runtimeChanged = currentRuntimeInstanceId !== void 0 && currentRuntimeInstanceId !== snapshot.runtimeInstanceId;
+      if (runtimeChanged) revokeAll("Runtime instance changed; proxy cannot be rebound", "service_stale");
+      const nextServices = snapshot.services.map((service) => Object.freeze({
+        ...service,
+        attributes: Object.freeze({ ...service.attributes })
+      }));
+      const nextReady = new Map(nextServices.filter((service) => service.status === "ready").map((service) => [bindingKey(service), service]));
+      if (!runtimeChanged) {
+        for (const record of proxies) {
+          const bound = record.boundReference;
+          if (!bound) continue;
+          const replacement = nextReady.get(bindingKey(bound));
+          if (!replacement || referenceKey(replacement) !== referenceKey(bound)) {
+            revokeProxy(record, "Bound service instance was replaced or revoked", "service_revoked");
+          }
+        }
       }
-      if (!snapshot.baseline && lastRevision !== void 0 && snapshot.snapshotRevision !== lastRevision + 1) {
+      currentRuntimeInstanceId = snapshot.runtimeInstanceId;
+      currentRevision = snapshot.revision;
+      currentServices = Object.freeze(nextServices);
+      terminalError = void 0;
+      if (snapshot.state === "failed") {
         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 }));
+        terminalError = new RemoteServiceError("runtime_initialization_failed", "Remote Runtime initialization failed");
+      } else if (snapshot.state === "disposed" || snapshot.state === "stopping") {
+        currentState = "stale";
+        terminalError = new RemoteServiceError("transport_unavailable", "Remote Runtime is no longer accepting calls");
+        revokeAll("Remote Runtime is no longer accepting calls", "transport_unavailable");
+      } else if (snapshot.state === "ready") {
+        currentState = "ready";
+      } else {
+        currentState = "empty";
       }
-      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
-      };
+      return { accepted: true, state: currentState, revision: snapshot.revision };
+    },
+    markProtocolMismatch(reason = "Remote Runtime protocol version mismatch") {
+      if (currentState === "disposed") return;
+      terminalError = new RemoteServiceError("protocol_mismatch", reason);
+      revokeAll(reason, "protocol_mismatch");
+      currentState = "stale";
+      notify();
+    },
+    markInitializationFailed(reason = "Remote Runtime initialization failed") {
+      if (currentState === "disposed") return;
+      terminalError = new RemoteServiceError("runtime_initialization_failed", reason);
+      revokeAll(reason, "runtime_initialization_failed");
+      currentState = "stale";
+      notify();
     },
     getProxy(lookup, scope) {
-      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",
+        reason: "Remote service proxy revoked",
         controller: new AbortController()
       };
       proxies.add(record);
       let removeScopeRevoke;
       let removeScopeDispose;
-      let proxy;
       const revokeFromScope = (reason) => {
-        revokeProxy(record, reason);
+        revokeProxy(record, reason, "service_revoked");
         proxies.delete(record);
         removeScopeRevoke?.();
         removeScopeDispose?.();
@@ -3485,70 +3526,68 @@ function createServiceBridge(options) {
       if (scope) {
         try {
           removeScopeRevoke = scope.onRevoke(revokeFromScope);
-          removeScopeDispose = scope.onDispose(revokeFromScope, `service-proxy:${reference.capabilityId}`);
+          removeScopeDispose = scope.onDispose(revokeFromScope, `service-proxy:${lookup.capabilityId}`);
         } catch {
-          record.revoked = true;
+          revokeFromScope("Remote service proxy scope is already revoked");
         }
       }
-      if (record.revoked) {
-        proxies.delete(record);
-        removeScopeRevoke?.();
-        removeScopeDispose?.();
-        return void 0;
-      }
-      proxy = {
-        reference,
+      const proxy = {
+        get reference() {
+          return record.boundReference;
+        },
         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;
-          }
+          if (record.revoked) throw new RemoteServiceError("service_revoked", record.reason);
+          const timeoutMs = ensureTimeout(callOptions.timeoutMs ?? defaultCallTimeoutMs, "timeoutMs");
+          const deadlineAt = Date.now() + timeoutMs;
+          const timeoutController = new AbortController();
+          const timeout = setTimeout(() => {
+            try {
+              timeoutController.abort(callTimeoutError(timeoutMs));
+            } catch {
+              timeoutController.abort();
+            }
+          }, timeoutMs);
+          const merged = mergeSignals2(scope?.signal, record.controller.signal, callOptions.signal, timeoutController.signal);
           try {
+            const reference = await waitForBinding(record, lookup, merged.signal);
+            if (merged.signal.aborted) throw abortedError(merged.signal);
+            const context = {
+              operationId: callOptions.operationId ?? callOptions.requestId,
+              reference,
+              grantId: reference.grantId,
+              signal: merged.signal,
+              deadlineAt,
+              timeoutMs
+            };
+            let result;
+            try {
+              result = Promise.resolve(options.transport.call(request, context));
+            } catch (error) {
+              throw error;
+            }
             const value = await Promise.race([
               result,
               new Promise((_, reject) => {
                 if (merged.signal.aborted) {
-                  reject(merged.signal.reason ?? new RemoteServiceUnavailableError("Remote service request aborted"));
+                  reject(abortedError(merged.signal));
                   return;
                 }
-                const onAbort = () => reject(merged.signal.reason ?? new RemoteServiceUnavailableError("Remote service request aborted"));
+                const onAbort = () => reject(abortedError(merged.signal));
                 merged.signal.addEventListener("abort", onAbort, { once: true });
                 result.finally(() => merged.signal.removeEventListener("abort", onAbort)).catch(() => void 0);
               })
             ]);
-            if (record.revoked || currentState !== "ready" || references.get(referenceKey(reference))?.status !== "ready") {
-              throw new RemoteServiceUnavailableError("Remote service request belongs to an invalidated proxy");
-            }
+            if (record.revoked) throw new RemoteServiceError("service_revoked", record.reason);
             return value;
+          } catch (error) {
+            if (merged.signal.aborted) throw abortedError(merged.signal);
+            if (error instanceof RemoteServiceError) throw error;
+            throw error;
           } finally {
+            clearTimeout(timeout);
             merged.dispose();
             if (record.revoked) {
               proxies.delete(record);
@@ -3557,124 +3596,203 @@ function createServiceBridge(options) {
             }
           }
         },
-        revoke(reason = "remote service proxy revoked") {
-          revokeProxy(record, reason);
-          proxies.delete(record);
-          removeScopeRevoke?.();
-          removeScopeDispose?.();
+        revoke(reason = "Remote service proxy revoked") {
+          revokeFromScope(reason);
         }
       };
       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;
+      return bridge.getProxy(lookup, scope);
     },
-    invalidate(reason = "remote service bridge invalidated") {
-      clearReferences(reason);
+    invalidate(reason = "Remote service directory invalidated") {
+      if (currentState === "disposed") return;
+      currentServices = [];
+      currentRevision = void 0;
+      terminalError = void 0;
+      revokeAll(reason, "service_revoked");
       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";
+    disconnect(reason = "Remote service transport disconnected") {
+      if (currentState === "disposed") return;
+      currentServices = [];
+      currentRevision = void 0;
+      currentRuntimeInstanceId = void 0;
+      terminalError = new RemoteServiceError("transport_unavailable", reason);
+      revokeAll(reason, "transport_unavailable");
+      currentState = "stale";
+      notify();
+    },
+    dispose(reason = "Remote service bridge disposed") {
+      if (currentState === "disposed") return;
+      currentServices = [];
+      currentRevision = void 0;
+      currentRuntimeInstanceId = void 0;
+      terminalError = new RemoteServiceError("transport_unavailable", reason);
+      revokeAll(reason, "transport_unavailable");
+      currentState = "disposed";
       notify();
+      proxies.clear();
     },
     subscribe(listener) {
       listeners.add(listener);
       return () => listeners.delete(listener);
     },
     services() {
-      return [...references.values()];
+      return currentServices;
     }
   };
   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 finiteTimeout(value) {
+  const timeout = value ?? 3e4;
+  if (!Number.isFinite(timeout) || timeout <= 0) throw new TypeError("Remote service timeout must be finite and greater than zero");
+  return timeout;
+}
 function errorFromWire(input) {
-  const error = new Error(
-    typeof input?.message === "string" ? input.message : "Remote service call failed"
+  return new RemoteServiceError(
+    typeof input?.code === "string" && input.code.length > 0 ? input.code : "handler_failed",
+    typeof input?.message === "string" ? input.message : "Remote service call failed",
+    input?.details
   );
-  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");
+  const reason = signal.reason;
+  if (reason instanceof Error && typeof reason.code === "string") return reason;
+  if (reason instanceof Error) return new RemoteServiceError("request_cancelled", reason.message);
+  return new RemoteServiceError("request_cancelled", "Remote service request was cancelled");
+}
+function addMessageListener(port, listener) {
+  port.addEventListener("message", listener);
+  return () => port.removeEventListener("message", listener);
+}
+function postBestEffort(port, message, transfer = []) {
+  try {
+    port.postMessage(message, [...transfer]);
+  } catch {
+  }
+}
+function postRequest(port, message, transfer = []) {
+  try {
+    port.postMessage(message, [...transfer]);
+  } catch (error) {
+    const name = error && typeof error === "object" && typeof error.name === "string" ? error.name : "DataCloneError";
+    const messageText = error instanceof Error ? error.message : String(error);
+    throw new RemoteServiceError(
+      "request_clone_failed",
+      `Remote service request could not be posted: ${messageText}`,
+      { name, message: messageText }
+    );
+  }
 }
 function isResponseMessage(input, codec) {
   if (!input || typeof input !== "object") return false;
   const message = input;
-  return (message.type === codec.type("result") || message.type === codec.type("error")) && typeof message.callId === "string" && typeof message.connectionId === "string" && typeof message.providerInstanceId === "string";
+  return (message.type === codec.type("result") || message.type === codec.type("error")) && typeof message.protocolVersion === "string" && typeof message.callId === "string" && typeof message.serviceInstanceId === "string";
 }
 function createMessagePortServiceTransport(options) {
   const pending = /* @__PURE__ */ new Map();
   let disposed = false;
-  const transportId = makeTransportId();
+  const transportId = ++nextTransportId;
   const codec = options.codec ?? createRemoteServiceMessageCodec();
+  const defaultCallTimeoutMs = finiteTimeout(options.defaultCallTimeoutMs);
+  const rejectPending = (error, sendCancel) => {
+    for (const [callId, call] of pending) {
+      pending.delete(callId);
+      call.removeAbort();
+      call.disposeDeadline();
+      if (sendCancel) {
+        postBestEffort(options.port, codec.encode({
+          type: codec.type("cancel"),
+          protocolVersion: codec.protocolVersion,
+          callId,
+          serviceInstanceId: call.serviceInstanceId
+        }));
+      }
+      call.reject(error);
+    }
+  };
   const onMessage = (event) => {
     const decoded = codec.decode(event.data);
     if (!isResponseMessage(decoded, codec)) return;
     const call = pending.get(decoded.callId);
     if (!call) return;
-    if (decoded.connectionId !== call.connectionId || decoded.providerInstanceId !== call.providerInstanceId) return;
+    if (decoded.serviceInstanceId !== call.serviceInstanceId) return;
     pending.delete(decoded.callId);
     call.removeAbort();
+    call.disposeDeadline();
+    if (decoded.protocolVersion !== codec.protocolVersion) {
+      call.reject(new RemoteServiceError("protocol_mismatch", "Remote service protocol version mismatch"));
+      return;
+    }
     if (decoded.type === codec.type("error")) {
       call.reject(errorFromWire(decoded.error));
     } else {
       call.resolve(decoded.result);
     }
   };
-  options.port.addEventListener("message", onMessage);
+  const onMessageError = () => rejectPending(new RemoteServiceError("transport_unavailable", "Remote service message could not be decoded"), false);
+  const removeMessage = addMessageListener(options.port, onMessage);
+  options.port.addEventListener("messageerror", onMessageError);
   options.port.start();
   const dispose = () => {
     if (disposed) return;
     disposed = true;
-    options.port.removeEventListener("message", onMessage);
-    for (const [callId, call] of pending) {
-      pending.delete(callId);
-      call.removeAbort();
-      call.reject(new RemoteServiceUnavailableError("Remote service transport disposed"));
+    removeMessage();
+    options.port.removeEventListener("messageerror", onMessageError);
+    rejectPending(new RemoteServiceError("transport_unavailable", "Remote service transport disposed"), true);
+    if (options.closeOnDispose) {
+      try {
+        options.port.close();
+      } catch {
+      }
     }
-    if (options.closeOnDispose) options.port.close();
   };
   const transport = {
     call(request, context) {
-      if (disposed) return Promise.reject(new RemoteServiceUnavailableError("Remote service transport disposed"));
+      if (disposed) return Promise.reject(new RemoteServiceError("transport_unavailable", "Remote service transport disposed"));
       if (context.signal.aborted) return Promise.reject(abortReason(context.signal));
       const callId = makeCallId(transportId);
-      const providerInstanceId = context.reference.providerInstanceId;
+      const serviceInstanceId = context.reference.serviceInstanceId;
+      const timeoutMs = finiteTimeout(context.timeoutMs ?? defaultCallTimeoutMs);
+      const deadlineAt = context.deadlineAt ?? Date.now() + timeoutMs;
+      const timeoutController = new AbortController();
+      const remaining = Math.max(0, deadlineAt - Date.now());
+      const deadlineTimer = setTimeout(() => {
+        try {
+          timeoutController.abort(new RemoteServiceError("call_timeout", "Remote service call timed out"));
+        } catch {
+          timeoutController.abort();
+        }
+      }, remaining);
+      const merged = (() => {
+        const controller = new AbortController();
+        const signals = [context.signal, timeoutController.signal];
+        const listeners = signals.map((signal) => {
+          const listener = () => {
+            try {
+              controller.abort(signal.reason);
+            } catch {
+              controller.abort();
+            }
+          };
+          signal.addEventListener("abort", listener, { once: true });
+          return { signal, listener };
+        });
+        return {
+          signal: controller.signal,
+          dispose: () => listeners.forEach(({ signal, listener }) => signal.removeEventListener("abort", listener))
+        };
+      })();
       return new Promise((resolve, reject) => {
         let settled = false;
         const finish = (callback) => {
@@ -3682,46 +3800,52 @@ function createMessagePortServiceTransport(options) {
           settled = true;
           callback();
         };
+        const sendCancel = () => postBestEffort(options.port, codec.encode({
+          type: codec.type("cancel"),
+          protocolVersion: codec.protocolVersion,
+          callId,
+          serviceInstanceId
+        }));
         const onAbort = () => {
           if (!pending.delete(callId)) return;
-          finish(() => reject(abortReason(context.signal)));
-          try {
-            const cancel = {
-              type: codec.type("cancel"),
-              callId,
-              connectionId: context.connectionId,
-              providerInstanceId
-            };
-            options.port.postMessage(codec.encode(cancel));
-          } catch {
-          }
+          sendCancel();
+          const reason = merged.signal.reason instanceof RemoteServiceError ? merged.signal.reason : merged.signal.reason?.code === "call_timeout" ? merged.signal.reason : abortReason(merged.signal);
+          finish(() => reject(reason));
+          merged.dispose();
+          clearTimeout(deadlineTimer);
         };
         const pendingCall = {
-          connectionId: context.connectionId,
-          providerInstanceId,
+          protocolVersion: codec.protocolVersion,
+          serviceInstanceId,
           resolve: (value) => finish(() => resolve(value)),
           reject: (error) => finish(() => reject(error)),
-          removeAbort: () => context.signal.removeEventListener("abort", onAbort)
+          removeAbort: () => merged.signal.removeEventListener("abort", onAbort),
+          disposeDeadline: () => {
+            merged.dispose();
+            clearTimeout(deadlineTimer);
+          }
         };
         pending.set(callId, pendingCall);
-        context.signal.addEventListener("abort", onAbort, { once: true });
+        merged.signal.addEventListener("abort", onAbort, { once: true });
+        const message = {
+          type: codec.type("call"),
+          protocolVersion: codec.protocolVersion,
+          callId,
+          capabilityId: context.reference.capabilityId,
+          contractVersion: context.reference.contractVersion,
+          serviceInstanceId,
+          ...context.operationId ? { operationId: context.operationId } : {},
+          ...context.grantId ?? context.reference.grantId ? { grantId: context.grantId ?? context.reference.grantId } : {},
+          request
+        };
         try {
-          const 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();
+          postRequest(options.port, codec.encode(message), transfer);
+          if (merged.signal.aborted) onAbort();
         } catch (error) {
           pending.delete(callId);
           pendingCall.removeAbort();
+          pendingCall.disposeDeadline();
           pendingCall.reject(error);
         }
       });
@@ -3730,7 +3854,408 @@ function createMessagePortServiceTransport(options) {
   };
   return transport;
 }
+function ensureTimeout2(value) {
+  const timeout = value ?? 3e4;
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new TypeError("defaultCallTimeoutMs must be a finite number greater than zero");
+  }
+  return timeout;
+}
+function addMessageListener2(port, listener) {
+  port.addEventListener("message", listener);
+  return () => port.removeEventListener("message", listener);
+}
+function ensureMessageEventTarget(port) {
+  const target = port;
+  if (target.addEventListener && target.removeEventListener) return;
+  const listeners = /* @__PURE__ */ new Set();
+  const original = target.onmessage;
+  target.addEventListener = function add(type, listener) {
+    if (type === "message") listeners.add(listener);
+  };
+  target.removeEventListener = function remove(type, listener) {
+    if (type === "message") listeners.delete(listener);
+  };
+  target.onmessage = (event) => {
+    original?.call(port, event);
+    for (const listener of [...listeners]) listener(event);
+  };
+}
+function makeWorker(options) {
+  const workerOptions = {
+    type: "module",
+    ...options.name ? { name: options.name } : {},
+    ...options.credentials ? { credentials: options.credentials } : {}
+  };
+  if (options.workerFactory) return options.workerFactory(options.url, workerOptions);
+  const WorkerConstructor = globalThis.SharedWorker;
+  if (!WorkerConstructor) throw new RuntimeUnavailableError("SharedWorker is not supported by this browser");
+  return new WorkerConstructor(options.url, workerOptions);
+}
+function connectSharedWorkerInternal(options) {
+  if (!options || typeof options.id !== "string" || options.id.trim() === "") {
+    throw new Error("SharedWorker runtime id must be a non-empty string");
+  }
+  const defaultCallTimeoutMs = ensureTimeout2(options.defaultCallTimeoutMs);
+  const worker = makeWorker(options);
+  const port = worker.port;
+  if (!port) throw new RuntimeUnavailableError("SharedWorker did not expose a MessagePort");
+  ensureMessageEventTarget(port);
+  const listeners = /* @__PURE__ */ new Set();
+  const codec = createRuntimeMessageCodec();
+  let disposed = false;
+  let runtimeInstanceId;
+  let removeRuntimeMessage;
+  let transport;
+  let restoreWorkerError = () => void 0;
+  let currentSnapshot = {
+    runtimeId: options.id,
+    runtimeKind: "shared-worker",
+    runtimeInstanceId: "",
+    state: "starting",
+    revision: 0,
+    units: [],
+    services: []
+  };
+  const emit = (next) => {
+    currentSnapshot = Object.freeze({
+      ...next,
+      units: Object.freeze([...next.units]),
+      services: Object.freeze([...next.services])
+    });
+    for (const listener of [...listeners]) {
+      try {
+        listener(currentSnapshot);
+      } catch {
+      }
+    }
+  };
+  const bridgeTransport = {
+    call(request, context) {
+      if (!transport) {
+        return Promise.reject(new RuntimeUnavailableError("SharedWorker connection is unavailable"));
+      }
+      return transport.call(request, context);
+    }
+  };
+  const bridge = createServiceBridge({
+    protocolVersion: RUNTIME_PROTOCOL_VERSION,
+    transport: bridgeTransport,
+    defaultCallTimeoutMs
+  });
+  const cleanup = () => {
+    removeRuntimeMessage?.();
+    removeRuntimeMessage = void 0;
+    port.removeEventListener("messageerror", onWorkerError);
+    transport?.dispose();
+    transport = void 0;
+    try {
+      port.close();
+    } catch {
+    }
+    if (worker.removeEventListener) worker.removeEventListener("error", onWorkerError);
+    restoreWorkerError();
+    restoreWorkerError = () => void 0;
+  };
+  const disconnect = (reason, failure) => {
+    if (disposed) return;
+    cleanup();
+    bridge.disconnect(reason);
+    emit({
+      ...currentSnapshot,
+      state: "disconnected",
+      runtimeInstanceId: "",
+      revision: 0,
+      units: [],
+      services: [],
+      error: reason
+    });
+    runtimeInstanceId = void 0;
+  };
+  const onRuntimeError = (message) => {
+    const error = new RuntimeInitializationError({
+      pluginId: message.pluginId,
+      unitId: message.unitId,
+      phase: message.phase === "snapshot" ? "snapshot" : "startup",
+      error: message.message
+    });
+    if (message.code === "protocol_mismatch") bridge.markProtocolMismatch(message.message);
+    else if (message.code === "runtime_initialization_failed") bridge.markInitializationFailed(message.message);
+    else bridge.disconnect(message.message);
+    emit({ ...currentSnapshot, state: "failed", error: error.message, units: [], services: [] });
+  };
+  const onSnapshot = (snapshot) => {
+    if (snapshot.runtimeId !== options.id || snapshot.runtimeKind !== "shared-worker") return;
+    if (!isRuntimeSnapshotProtocol(snapshot)) {
+      bridge.markProtocolMismatch(`Runtime protocol ${snapshot.protocolVersion} is not supported`);
+      emit({
+        ...currentSnapshot,
+        state: "failed",
+        error: `Runtime protocol ${snapshot.protocolVersion} is not supported`,
+        units: [],
+        services: []
+      });
+      return;
+    }
+    const applied = bridge.applySnapshot(snapshot);
+    if (!applied.accepted) return;
+    runtimeInstanceId = snapshot.runtimeInstanceId;
+    emit({
+      runtimeId: snapshot.runtimeId,
+      runtimeKind: snapshot.runtimeKind,
+      runtimeInstanceId: snapshot.runtimeInstanceId,
+      state: snapshot.state === "ready" ? "ready" : snapshot.state,
+      revision: snapshot.revision,
+      units: snapshot.units,
+      services: snapshot.services
+    });
+  };
+  const onWorkerError = (event) => {
+    const detail = event.type ? `SharedWorker error: ${event.type}` : "SharedWorker error";
+    disconnect(detail);
+  };
+  const onMessage = (event) => {
+    if (disposed) return;
+    if (isRuntimeError(event.data)) {
+      onRuntimeError(event.data);
+      return;
+    }
+    if (isRuntimeSnapshot(event.data)) {
+      onSnapshot(event.data);
+      return;
+    }
+    const decoded = codec.decode(event.data);
+    if (decoded?.type === codec.type("error")) ;
+  };
+  try {
+    options.onConnection?.({ worker, port });
+    transport = createMessagePortServiceTransport({
+      port,
+      codec,
+      defaultCallTimeoutMs,
+      closeOnDispose: false
+    });
+    removeRuntimeMessage = addMessageListener2(port, onMessage);
+    port.addEventListener("messageerror", onWorkerError);
+    if (worker.addEventListener) worker.addEventListener("error", onWorkerError);
+    else {
+      const previous = worker.onerror;
+      const fallbackHandler = (event) => {
+        previous?.(event);
+        onWorkerError(event);
+      };
+      worker.onerror = fallbackHandler;
+      restoreWorkerError = () => {
+        if (worker.onerror === fallbackHandler) worker.onerror = previous;
+      };
+    }
+    port.start();
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+  const handle = {
+    runtimeKind: "shared-worker",
+    runtimeId: options.id,
+    get runtimeInstanceId() {
+      return runtimeInstanceId;
+    },
+    serviceBridge: bridge,
+    state: () => currentSnapshot,
+    capability(capabilityId, capabilityOptions = {}) {
+      const proxy = bridge.requireProxy({
+        capabilityId,
+        contractVersion: capabilityOptions.contractVersion ?? `${capabilityId}.v1`
+      });
+      return proxy;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(currentSnapshot);
+      return () => listeners.delete(listener);
+    },
+    dispose(reason = "SharedWorker connection disposed") {
+      if (disposed) return Promise.resolve();
+      disposed = true;
+      emit({ ...currentSnapshot, state: "stopping" });
+      bridge.dispose(reason);
+      cleanup();
+      runtimeInstanceId = void 0;
+      emit({
+        ...currentSnapshot,
+        state: "disposed",
+        runtimeInstanceId: "",
+        revision: 0,
+        units: [],
+        services: []
+      });
+      return Promise.resolve();
+    }
+  };
+  return handle;
+}
+function connectSharedWorker(options) {
+  return connectSharedWorkerInternal(options);
+}
+function connectSharedWorkerForTesting(options, workerFactory) {
+  return connectSharedWorkerInternal({ ...options, workerFactory });
+}
+
+// src/lifecycle/pluginIntentController.ts
+function makeAuthorityInstanceId() {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return `authority:${crypto.randomUUID()}`;
+    }
+  } catch {
+  }
+  return `authority:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+}
+function cloneSnapshot(snapshot) {
+  return {
+    revision: snapshot.revision,
+    desiredEnabled: { ...snapshot.desiredEnabled },
+    desiredRevision: { ...snapshot.desiredRevision }
+  };
+}
+function normalizeSnapshot(initial) {
+  const revision = Number.isSafeInteger(initial?.revision) && (initial?.revision ?? 0) >= 0 ? initial.revision : 0;
+  const desiredEnabled = {};
+  for (const [pluginId, value] of Object.entries(initial?.desiredEnabled ?? {})) {
+    if (typeof value === "boolean") desiredEnabled[pluginId] = value;
+  }
+  const desiredRevision = {};
+  for (const [pluginId, value] of Object.entries(initial?.desiredRevision ?? {})) {
+    if (Number.isSafeInteger(value) && value >= 0) desiredRevision[pluginId] = value;
+  }
+  return { revision, desiredEnabled, desiredRevision };
+}
+function commandFingerprint(command) {
+  return [
+    command.authorityInstanceId,
+    command.expectedRevision,
+    command.pluginId,
+    command.desiredEnabled ? "true" : "false"
+  ].join("\0");
+}
+function commandError(message) {
+  return { status: "command-conflict", commandId: "", message };
+}
+function createPluginIntentController(options = {}) {
+  const authorityInstanceId = options.authorityInstanceId ?? makeAuthorityInstanceId();
+  const maxCommandRecords = Math.max(1, Math.floor(options.maxCommandRecords ?? 256));
+  let current = normalizeSnapshot(options.initial);
+  const commandRecords = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let queue = Promise.resolve();
+  const notify = () => {
+    const snapshot = cloneSnapshot(current);
+    for (const listener of [...listeners]) {
+      try {
+        listener(snapshot);
+      } catch {
+      }
+    }
+  };
+  const process = async (command) => {
+    const candidate = command;
+    const commandId = typeof candidate?.commandId === "string" ? candidate.commandId : "";
+    if (!candidate || typeof candidate.authorityInstanceId !== "string" || candidate.authorityInstanceId.length === 0 || typeof candidate.pluginId !== "string" || candidate.pluginId.length === 0 || typeof candidate.desiredEnabled !== "boolean" || !Number.isSafeInteger(candidate.expectedRevision) || (candidate.expectedRevision ?? -1) < 0 || commandId.length === 0) {
+      const result = commandError("commandId\u3001pluginId \u548C expectedRevision \u5FC5\u987B\u662F\u6709\u6548\u503C");
+      return { ...result, commandId };
+    }
+    if (command.authorityInstanceId !== authorityInstanceId) {
+      return {
+        status: "stale-authority",
+        commandId: command.commandId,
+        expectedAuthorityInstanceId: authorityInstanceId
+      };
+    }
+    const fingerprint = commandFingerprint(command);
+    const existing = commandRecords.get(command.commandId);
+    if (existing) {
+      if (existing.fingerprint !== fingerprint) {
+        return {
+          status: "command-conflict",
+          commandId: command.commandId,
+          message: "\u76F8\u540C commandId \u7684\u547D\u4EE4\u5185\u5BB9\u4E0D\u540C\uFF0C\u62D2\u7EDD\u8986\u76D6\u539F\u547D\u4EE4"
+        };
+      }
+      return {
+        status: "duplicate",
+        commandId: command.commandId,
+        snapshot: cloneSnapshot(existing.result.snapshot),
+        persisted: true
+      };
+    }
+    if (command.expectedRevision !== current.revision) {
+      return {
+        status: "revision-conflict",
+        commandId: command.commandId,
+        snapshot: cloneSnapshot(current)
+      };
+    }
+    const next = {
+      revision: current.revision + 1,
+      desiredEnabled: {
+        ...current.desiredEnabled,
+        [command.pluginId]: command.desiredEnabled
+      },
+      desiredRevision: {
+        ...current.desiredRevision,
+        [command.pluginId]: (current.desiredRevision[command.pluginId] ?? 0) + 1
+      }
+    };
+    try {
+      await options.persist?.(cloneSnapshot(next));
+    } catch (error) {
+      return {
+        status: "persistence-failed",
+        commandId: command.commandId,
+        message: error instanceof Error ? error.message : String(error),
+        snapshot: cloneSnapshot(current)
+      };
+    }
+    current = next;
+    const accepted = {
+      status: "accepted",
+      commandId: command.commandId,
+      snapshot: cloneSnapshot(current),
+      persisted: true
+    };
+    commandRecords.set(command.commandId, {
+      fingerprint,
+      result: accepted
+    });
+    while (commandRecords.size > maxCommandRecords) {
+      const oldest = commandRecords.keys().next().value;
+      if (oldest === void 0) break;
+      commandRecords.delete(oldest);
+    }
+    notify();
+    return {
+      status: "accepted",
+      commandId: accepted.commandId,
+      snapshot: cloneSnapshot(accepted.snapshot),
+      persisted: true
+    };
+  };
+  const controller = {
+    authorityInstanceId,
+    snapshot: () => cloneSnapshot(current),
+    submit(command) {
+      const result = queue.then(() => process(command));
+      queue = result.then(() => void 0, () => void 0);
+      return result;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+  return controller;
+}
 
-export { LIFECYCLE_ERROR_TEXT, LifecycleScopeRevokedError, PermissionDeniedError, PermissionLeaseRevokedError, PluginGraphValidationError, RESOURCE_OWNER, RESOURCE_REGISTRY_CAPABILITY, RUNTIME_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
+export { LIFECYCLE_ERROR_TEXT, LifecycleScopeRevokedError, PermissionDeniedError, PermissionLeaseRevokedError, PluginGraphValidationError, RESOURCE_OWNER, RESOURCE_REGISTRY_CAPABILITY, RUNTIME_ERROR_TYPE, RUNTIME_MESSAGE_BUS, RUNTIME_PROTOCOL_VERSION, RUNTIME_SNAPSHOT_TYPE, RemoteServiceError, RuntimeInitializationError, RuntimeUnavailableError, SCOPED_TASK_SCHEDULER_CAPABILITY, StartupCapabilityError, StartupPluginError, UpgradeGateRejectedError, buildPluginGraph, connectSharedWorker, connectSharedWorkerForTesting, createCapabilityRegistry, createInMemoryPluginConfigStore, createLifecycleScope, createMessageBus, createMessagePortServiceTransport, createPermissionLease, createPluginHost, createPluginIntentController, createRemoteServiceMessageCodec, createResourceRegistry, createResourceScope, createResourceStore, createRuntimeMessageCodec, createRuntimeUnitImplementationRegistry, createScopedMessageBus, createScopedTaskScheduler, createServiceBridge, dependenciesOfManifest, isRuntimeError, isRuntimeSnapshot, isRuntimeSnapshotProtocol, lifecycleErrorText, providesOfManifest, registerOwnedResource, reverseDependentsOf, unitSnapshotFromState, validatePluginGraph, validateRuntimeUnitDependencyContracts };
+//# sourceMappingURL=chunk-76BGPI6M.js.map
+//# sourceMappingURL=chunk-76BGPI6M.js.map