webloom-framework 0.2.0 → 0.3.0

package/dist/{chunk-URY3E6UH.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 {
@@ -3147,51 +3146,82 @@ function createRuntimeUnitImplementationRegistry(implementations = []) {
   };
 }
 
-// src/transport/serviceBridge.ts
-function makeRequestId() {
-  try {
-    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-      return `service-request:${crypto.randomUUID()}`;
-    }
-  } catch {
-  }
-  return `service-request:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-}
-function mergeSignals2(...signals) {
-  const activeSignals = signals.filter((signal) => signal !== void 0);
-  if (activeSignals.length === 0) {
-    return { signal: new AbortController().signal, dispose: () => void 0 };
-  }
-  if (activeSignals.length === 1) {
-    const [signal] = activeSignals;
-    if (signal) return { signal, dispose: () => void 0 };
+// 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 alreadyAborted = activeSignals.find((signal) => signal.aborted);
-  if (alreadyAborted) {
-    const controller2 = new AbortController();
-    controller2.abort(alreadyAborted.reason);
-    return { signal: controller2.signal, dispose: () => void 0 };
+};
+var RuntimeUnavailableError = class extends Error {
+  code = "transport_unavailable";
+  constructor(message = "Runtime is unavailable") {
+    super(message);
+    this.name = "RuntimeUnavailableError";
   }
-  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 };
+};
+
+// src/runtime/runtimeProtocol.ts
+var RUNTIME_PROTOCOL_VERSION = "webloom.runtime.v2";
+var RUNTIME_SNAPSHOT_TYPE = "webloom.runtime.snapshot";
+var RUNTIME_ERROR_TYPE = "webloom.runtime.error";
+function isRecord2(input) {
+  return typeof input === "object" && input !== null;
+}
+function isNonEmptyString(input) {
+  return typeof input === "string" && input.length > 0;
+}
+function isRuntimeKind2(input) {
+  return input === "window-main" || input === "shared-worker";
+}
+function isPluginStateKind(input) {
+  return input === "registered" || input === "starting" || input === "stopping" || input === "enabled" || input === "disabled" || input === "blocked" || input === "error-disabled" || input === "cleanup-pending" || input === "unknown";
+}
+function isRemoteServiceReference(input) {
+  if (!isRecord2(input)) return false;
+  const reference = input;
+  return isNonEmptyString(reference.capabilityId) && isNonEmptyString(reference.contractVersion) && isRuntimeKind2(reference.runtime) && isNonEmptyString(reference.runtimeInstanceId) && isNonEmptyString(reference.serviceInstanceId) && (reference.status === "starting" || reference.status === "ready" || reference.status === "unavailable" || reference.status === "failed") && isRecord2(reference.attributes) && !Array.isArray(reference.attributes) && (reference.grantId === void 0 || isNonEmptyString(reference.grantId)) && (reference.authorizationRevision === void 0 || Number.isSafeInteger(reference.authorizationRevision) && reference.authorizationRevision >= 0);
+}
+function isRuntimeSnapshotUnit(input) {
+  if (!isRecord2(input)) return false;
+  const unit = input;
+  return isNonEmptyString(unit.pluginId) && isNonEmptyString(unit.unitId) && isRuntimeKind2(unit.runtime) && isPluginStateKind(unit.state) && (unit.instanceId === void 0 || isNonEmptyString(unit.instanceId));
+}
+function createRuntimeMessageCodec() {
+  return createRemoteServiceMessageCodec({
+    prefix: "webloom.runtime",
+    protocolVersion: RUNTIME_PROTOCOL_VERSION
   });
+}
+function isRuntimeSnapshot(input) {
+  if (!isRecord2(input)) return false;
+  const message = input;
+  return message.type === RUNTIME_SNAPSHOT_TYPE && isNonEmptyString(message.protocolVersion) && isNonEmptyString(message.runtimeId) && isRuntimeKind2(message.runtimeKind) && isNonEmptyString(message.runtimeInstanceId) && Number.isSafeInteger(message.revision) && message.revision >= 0 && Array.isArray(message.units) && message.units.every(isRuntimeSnapshotUnit) && Array.isArray(message.services) && message.services.every(isRemoteServiceReference) && (message.state === "starting" || message.state === "ready" || message.state === "stopping" || message.state === "failed" || message.state === "disposed");
+}
+function isRuntimeSnapshotProtocol(input) {
+  return input.protocolVersion === RUNTIME_PROTOCOL_VERSION;
+}
+function isRuntimeError(input) {
+  if (!isRecord2(input)) return false;
+  const message = input;
+  return message.type === RUNTIME_ERROR_TYPE && isNonEmptyString(message.protocolVersion) && (message.code === "runtime_initialization_failed" || message.code === "protocol_mismatch" || message.code === "transport_unavailable") && isNonEmptyString(message.message) && (message.pluginId === void 0 || isNonEmptyString(message.pluginId)) && (message.unitId === void 0 || isNonEmptyString(message.unitId)) && (message.phase === void 0 || message.phase === "startup" || message.phase === "snapshot");
+}
+function unitSnapshotFromState(state, runtime) {
   return {
-    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);
@@ -3202,34 +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.runtime,
     reference.contractVersion,
-    reference.authorityInstanceId,
-    reference.connectionId ?? "local",
-    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.runtime === void 0 || reference.runtime === lookup.runtime) && (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 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) {
-  let currentState = "disconnected";
-  let currentConnectionId;
-  let currentAuthorityInstanceId;
-  let lastRevision;
-  let hasBaseline = false;
-  const references = /* @__PURE__ */ new Map();
+  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 = () => {
@@ -3240,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 (currentState === "disposed") return { accepted: false, reason: "disposed" };
+      if (snapshot.protocolVersion !== options.protocolVersion) {
+        return { accepted: false, reason: "protocol-mismatch", receivedRevision: snapshot.revision };
       }
-      if (snapshot.authorityInstanceId !== currentAuthorityInstanceId) {
-        return {
-          accepted: false,
-          reason: "wrong-authority",
-          receivedRevision: snapshot.snapshotRevision
-        };
+      if (!isValidSnapshot(snapshot)) {
+        return { accepted: false, reason: "invalid-snapshot", receivedRevision: snapshot.revision };
       }
-      if (!Number.isSafeInteger(snapshot.snapshotRevision) || snapshot.snapshotRevision < 0) {
-        return {
-          accepted: false,
-          reason: "stale-revision",
-          receivedRevision: snapshot.snapshotRevision
-        };
+      if (currentRuntimeInstanceId === snapshot.runtimeInstanceId && currentRevision !== void 0 && snapshot.revision <= currentRevision) {
+        return { accepted: false, reason: "stale-revision", 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 (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.connectionId !== void 0 && reference.connectionId !== snapshot.connectionId || 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?.();
@@ -3396,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);
@@ -3468,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) => {
@@ -3593,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);
         }
       });
@@ -3641,6 +3854,252 @@ 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() {
@@ -3797,6 +4256,6 @@ function createPluginIntentController(options = {}) {
   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-URY3E6UH.js.map
-//# sourceMappingURL=chunk-URY3E6UH.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