webloom-framework 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { createRemoteServiceMessageCodec, createRuntimeUnitImplementationRegistry, createPluginHost, StartupPluginError, createServiceBridge, createMessagePortServiceTransport, UpgradeGateRejectedError } from './chunk-URY3E6UH.js';
-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 } from './chunk-URY3E6UH.js';
+import { RuntimeInitializationError, createRuntimeUnitImplementationRegistry, createPluginHost, StartupPluginError, createRemoteServiceMessageCodec, createRuntimeMessageCodec, RemoteServiceError, UpgradeGateRejectedError, unitSnapshotFromState, RuntimeUnavailableError, RUNTIME_PROTOCOL_VERSION, RUNTIME_SNAPSHOT_TYPE, RUNTIME_ERROR_TYPE } from './chunk-76BGPI6M.js';
+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, 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 } from './chunk-76BGPI6M.js';
 
 // src/contracts/plugin.ts
 function runtimeCapabilityContractVersion(capability) {
@@ -156,90 +156,6 @@ function materializePluginDefinitions(inputs, runtime) {
   return inputs.map((input) => materializePluginDefinition(input, runtime));
 }
 
-// src/runtime/runtimeTypes.ts
-var RuntimeInitializationError = class extends Error {
-  code = "runtime.initialization_failed";
-  details;
-  constructor(details) {
-    super(
-      `Runtime initialization failed${details.pluginId ? ` for ${details.pluginId}` : ""} during ${details.phase}: ${details.error}`
-    );
-    this.name = "RuntimeInitializationError";
-    this.details = details;
-  }
-};
-var RuntimeUnavailableError = class extends Error {
-  code = "runtime.unavailable";
-  constructor(message = "Runtime is unavailable") {
-    super(message);
-    this.name = "RuntimeUnavailableError";
-  }
-};
-
-// src/runtime/runtimeProtocol.ts
-var RUNTIME_PROTOCOL_VERSION = "webloom.runtime.v1";
-var RUNTIME_HELLO_TYPE = "webloom.runtime.hello";
-var RUNTIME_SNAPSHOT_TYPE = "webloom.runtime.snapshot";
-var RUNTIME_RESYNC_TYPE = "webloom.runtime.resync";
-var RUNTIME_ERROR_TYPE = "webloom.runtime.error";
-function isRecord(input) {
-  return typeof input === "object" && input !== null;
-}
-function isNonEmptyString(input) {
-  return typeof input === "string" && input.length > 0;
-}
-function isRuntimeKind(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 (!isRecord(input)) return false;
-  const reference = input;
-  return isNonEmptyString(reference.capabilityId) && isNonEmptyString(reference.providerInstanceId) && isRuntimeKind(reference.runtime) && isNonEmptyString(reference.contractVersion) && isNonEmptyString(reference.authorityInstanceId) && isNonEmptyString(reference.scopeId) && Number.isSafeInteger(reference.handoverGeneration) && reference.handoverGeneration >= 0 && isRecord(reference.attributes) && !Array.isArray(reference.attributes) && (reference.status === "starting" || reference.status === "ready" || reference.status === "unavailable" || reference.status === "failed") && Number.isSafeInteger(reference.snapshotRevision) && reference.snapshotRevision >= 0 && (reference.connectionId === void 0 || isNonEmptyString(reference.connectionId)) && (reference.grantId === void 0 || isNonEmptyString(reference.grantId)) && (reference.authorizationRevision === void 0 || Number.isSafeInteger(reference.authorizationRevision) && reference.authorizationRevision >= 0);
-}
-function isRuntimeSnapshotUnit(input) {
-  if (!isRecord(input)) return false;
-  const unit = input;
-  return isNonEmptyString(unit.pluginId) && isNonEmptyString(unit.unitId) && isRuntimeKind(unit.runtime) && isPluginStateKind(unit.state) && (unit.instanceId === void 0 || isNonEmptyString(unit.instanceId));
-}
-function createRuntimeMessageCodec() {
-  return createRemoteServiceMessageCodec({
-    prefix: "webloom.runtime",
-    protocolVersion: RUNTIME_PROTOCOL_VERSION
-  });
-}
-function isRuntimeHello(input) {
-  if (!isRecord(input)) return false;
-  const message = input;
-  return message.type === RUNTIME_HELLO_TYPE && isNonEmptyString(message.protocolVersion) && isNonEmptyString(message.connectionId) && isNonEmptyString(message.runtimeId);
-}
-function isRuntimeResync(input) {
-  if (!isRecord(input)) return false;
-  const message = input;
-  return message.type === RUNTIME_RESYNC_TYPE && isNonEmptyString(message.connectionId);
-}
-function isRuntimeSnapshot(input) {
-  if (!isRecord(input)) return false;
-  const message = input;
-  return message.type === RUNTIME_SNAPSHOT_TYPE && message.protocolVersion === RUNTIME_PROTOCOL_VERSION && isNonEmptyString(message.runtimeId) && isRuntimeKind(message.runtimeKind) && isNonEmptyString(message.runtimeInstanceId) && isNonEmptyString(message.connectionId) && Number.isSafeInteger(message.snapshotRevision) && message.snapshotRevision >= 0 && typeof message.baseline === "boolean" && 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 isRuntimeError(input) {
-  if (!isRecord(input)) return false;
-  const message = input;
-  return message.type === RUNTIME_ERROR_TYPE && isNonEmptyString(message.protocolVersion) && (message.code === "runtime.protocol_mismatch" || message.code === "runtime.initialization_failed" || message.code === "runtime.invalid_connection") && isNonEmptyString(message.message) && (message.pluginId === void 0 || isNonEmptyString(message.pluginId)) && (message.unitId === void 0 || isNonEmptyString(message.unitId)) && (message.phase === void 0 || isNonEmptyString(message.phase));
-}
-function unitSnapshotFromState(state, runtime) {
-  return {
-    pluginId: state.pluginId,
-    unitId: state.unitId,
-    runtime,
-    ...state.instanceId !== void 0 ? { instanceId: state.instanceId } : {},
-    state: state.kind
-  };
-}
-
 // src/runtime/windowRuntime.ts
 function makeRuntimeInstanceId(runtimeId) {
   try {
@@ -256,25 +172,21 @@ function errorMessage(error) {
 function isStartupPluginError(error) {
   return error instanceof StartupPluginError && typeof error.details?.pluginId === "string";
 }
-function buildLocalServices(host, manifests, runtimeInstanceId, revision) {
+function buildLocalServices(host, manifests, runtimeInstanceId) {
   const services = [];
   for (const manifest of manifests) {
     const state = host.state(manifest.id);
     const unit = manifest.units?.find((candidate) => candidate.id === state.unitId) ?? manifest.units?.[0];
     if (!unit || unit.runtime === void 0 || !state.instanceId || state.kind !== "enabled") continue;
-    const scopeId = host.scope(manifest.id)?.identity.scopeId ?? `scope:${state.instanceId}`;
     for (const capability of unit.provides ?? []) {
       services.push({
         capabilityId: capability,
-        providerInstanceId: state.instanceId,
-        runtime: unit.runtime,
         contractVersion: unit.providedContracts?.[capability] ?? `${capability}.v1`,
-        authorityInstanceId: runtimeInstanceId,
-        scopeId,
-        handoverGeneration: 0,
-        attributes: Object.freeze({}),
+        runtime: unit.runtime,
+        runtimeInstanceId,
+        serviceInstanceId: state.instanceId,
         status: "ready",
-        snapshotRevision: revision
+        attributes: Object.freeze({})
       });
     }
   }
@@ -289,7 +201,7 @@ async function createWindowApp(options) {
     runtimeKind: "window-main",
     runtimeInstanceId,
     state: "starting",
-    snapshotRevision: 0,
+    revision: 0,
     units: [],
     services: []
   };
@@ -332,6 +244,7 @@ async function createWindowApp(options) {
   }
   let host;
   const suppliedHost = options.host;
+  const remoteServiceBridge = remoteRuntime ? remoteRuntime.serviceBridge : void 0;
   try {
     const {
       id: _id,
@@ -353,7 +266,7 @@ async function createWindowApp(options) {
         ...unit.instanceId !== void 0 ? { instanceId: unit.instanceId } : {},
         state: unit.state
       })) : hostOptions.runtimeSnapshots?.() ?? [],
-      serviceBridgeForPlugin: (pluginId, instanceId) => suppliedBridgeFactory?.(pluginId, instanceId) ?? remoteRuntime?.serviceBridge,
+      serviceBridgeForPlugin: (pluginId, instanceId) => suppliedBridgeFactory?.(pluginId, instanceId) ?? remoteServiceBridge,
       rootAttributes: {
         ...hostOptions.rootAttributes ?? {},
         runtimeId,
@@ -378,13 +291,13 @@ async function createWindowApp(options) {
         unit.runtime
       ));
     });
-    const revision = Math.max(currentState.snapshotRevision + 1, host.version());
+    const revision = Math.max(currentState.revision + 1, host.version());
     emit({
       ...currentState,
-      snapshotRevision: revision,
+      revision,
       units,
       services: [
-        ...buildLocalServices(host, snapshotManifests, runtimeInstanceId, revision),
+        ...buildLocalServices(host, snapshotManifests, runtimeInstanceId),
         ...remoteRuntime?.state().services ?? []
       ]
     });
@@ -470,22 +383,46 @@ async function createWindowApp(options) {
 function isCallMessage(input, codec) {
   if (!input || typeof input !== "object") return false;
   const message = input;
-  return message.type === codec.type("call") && typeof message.callId === "string" && message.callId.length > 0 && typeof message.connectionId === "string" && typeof message.providerInstanceId === "string" && Boolean(message.reference);
+  return message.type === codec.type("call") && typeof message.protocolVersion === "string" && typeof message.callId === "string" && message.callId.length > 0 && typeof message.capabilityId === "string" && typeof message.contractVersion === "string" && typeof message.serviceInstanceId === "string";
 }
 function isCancelMessage(input, codec) {
   if (!input || typeof input !== "object") return false;
   const message = input;
-  return message.type === codec.type("cancel") && typeof message.callId === "string" && typeof message.connectionId === "string" && typeof message.providerInstanceId === "string";
+  return message.type === codec.type("cancel") && typeof message.protocolVersion === "string" && typeof message.callId === "string" && typeof message.serviceInstanceId === "string";
 }
 function errorMessage2(error) {
   const candidate = error && typeof error === "object" ? error : void 0;
+  const code = typeof candidate?.code === "string" && candidate.code.length > 0 ? candidate.code : "handler_failed";
   return {
     ...typeof candidate?.name === "string" ? { name: candidate.name } : {},
     message: typeof candidate?.message === "string" ? candidate.message : String(error),
-    ...typeof candidate?.code === "string" ? { code: candidate.code } : {}
+    code,
+    ...candidate?.details && typeof candidate.details === "object" && !Array.isArray(candidate.details) ? { details: candidate.details } : {}
   };
 }
-function post(port, message) {
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stableValue(item)])
+  );
+}
+function bindingKey(reference) {
+  return [
+    reference.capabilityId,
+    reference.contractVersion,
+    reference.runtime,
+    reference.runtimeInstanceId,
+    reference.serviceInstanceId
+  ].join("\0");
+}
+function referenceFingerprint(reference) {
+  return JSON.stringify({
+    ...reference,
+    attributes: stableValue(reference.attributes)
+  });
+}
+function postBestEffort(port, message) {
   try {
     port.postMessage(message);
   } catch {
@@ -494,114 +431,151 @@ function post(port, message) {
 function createMessagePortServiceProvider(options) {
   const pending = /* @__PURE__ */ new Map();
   const codec = options.codec ?? createRemoteServiceMessageCodec();
-  let activeProviderInstanceIds = new Set(
-    options.snapshot.services.map((service) => service.providerInstanceId)
-  );
+  let services = [...options.services?.() ?? []];
+  let bindings = /* @__PURE__ */ new Map();
+  let nextBindingEpoch = 0;
+  let revoked = false;
   let disposed = false;
+  const buildBindings = (nextServices) => {
+    const nextBindings = /* @__PURE__ */ new Map();
+    for (const reference of nextServices) {
+      const key = bindingKey(reference);
+      const previous = bindings.get(key);
+      const epoch = previous && referenceFingerprint(previous.reference) === referenceFingerprint(reference) ? previous.epoch : ++nextBindingEpoch;
+      nextBindings.set(key, { reference, epoch });
+    }
+    return nextBindings;
+  };
+  const isCurrent = (callId, call) => {
+    const current = bindings.get(call.bindingKey);
+    return !disposed && !revoked && pending.get(callId) === call && current?.epoch === call.bindingEpoch && current.reference.serviceInstanceId === call.serviceInstanceId;
+  };
+  const revokeReplacedCalls = (nextBindings) => {
+    for (const call of pending.values()) {
+      const next = nextBindings.get(call.bindingKey);
+      if (!next || next.epoch !== call.bindingEpoch) {
+        sendError(call.message, new RemoteServiceError("service_revoked", "Remote service binding was replaced"));
+        call.controller.abort(new RemoteServiceError("service_revoked", "Remote service binding was replaced"));
+      }
+    }
+  };
+  bindings = buildBindings(services);
   const sendError = (message, error) => {
     const response = {
       type: codec.type("error"),
+      protocolVersion: codec.protocolVersion,
       callId: message.callId,
-      connectionId: message.connectionId,
-      providerInstanceId: message.providerInstanceId,
+      serviceInstanceId: message.serviceInstanceId,
       error: errorMessage2(error)
     };
-    post(options.port, codec.encode(response));
+    postBestEffort(options.port, codec.encode(response));
   };
   const onMessage = (event) => {
     if (disposed) return;
     const decoded = codec.decode(event.data);
     if (isCancelMessage(decoded, codec)) {
-      if (decoded.connectionId !== options.handshake.connectionId) return;
-      const call = pending.get(decoded.callId);
-      if (call?.providerInstanceId === decoded.providerInstanceId) {
-        call.controller.abort(new Error("Remote service request cancelled"));
+      if (decoded.protocolVersion !== codec.protocolVersion) return;
+      const call2 = pending.get(decoded.callId);
+      if (call2?.serviceInstanceId === decoded.serviceInstanceId) {
+        call2.controller.abort(new RemoteServiceError("request_cancelled", "Remote service request cancelled"));
       }
       return;
     }
     if (!isCallMessage(decoded, codec)) return;
     const message = decoded;
-    if (message.connectionId !== options.handshake.connectionId) {
-      sendError(message, Object.assign(new Error("Remote service connection mismatch"), { code: "service.connection_mismatch" }));
+    if (message.protocolVersion !== codec.protocolVersion) {
+      sendError(message, new RemoteServiceError("protocol_mismatch", "Remote service protocol version mismatch"));
+      return;
+    }
+    if (revoked) {
+      sendError(message, new RemoteServiceError("service_revoked", "Remote service Provider has been revoked"));
       return;
     }
-    if (!activeProviderInstanceIds.has(message.providerInstanceId)) {
-      sendError(message, Object.assign(new Error("Remote service provider mismatch"), { code: "service.provider_mismatch" }));
+    const reference = services.find((candidate) => candidate.status === "ready" && candidate.capabilityId === message.capabilityId && candidate.contractVersion === message.contractVersion && candidate.serviceInstanceId === message.serviceInstanceId);
+    if (!reference) {
+      sendError(message, new RemoteServiceError("service_stale", "Remote service instance is stale or unavailable"));
       return;
     }
     if (pending.has(message.callId)) {
-      sendError(message, Object.assign(new Error("Remote service callId is duplicated"), { code: "service.duplicate_call" }));
+      sendError(message, new RemoteServiceError("handler_failed", "Remote service callId is duplicated"));
       return;
     }
     const controller = new AbortController();
-    pending.set(message.callId, { controller, providerInstanceId: message.providerInstanceId });
+    const currentBindingKey = bindingKey(reference);
+    const currentBinding = bindings.get(currentBindingKey);
+    if (!currentBinding || currentBinding.reference !== reference) {
+      sendError(message, new RemoteServiceError("service_stale", "Remote service binding changed"));
+      return;
+    }
+    const call = {
+      message,
+      controller,
+      serviceInstanceId: message.serviceInstanceId,
+      bindingKey: currentBindingKey,
+      bindingEpoch: currentBinding.epoch
+    };
+    pending.set(message.callId, call);
     void (async () => {
       try {
-        const result = await options.handleCall({ message, signal: controller.signal });
-        if (controller.signal.aborted || disposed) return;
+        const result = await options.handleCall({ message, reference, signal: controller.signal });
+        if (controller.signal.aborted || !isCurrent(message.callId, call)) return;
         const response = {
           type: codec.type("result"),
+          protocolVersion: codec.protocolVersion,
           callId: message.callId,
-          connectionId: message.connectionId,
-          providerInstanceId: message.providerInstanceId,
+          serviceInstanceId: message.serviceInstanceId,
           result
         };
-        post(options.port, codec.encode(response));
+        postBestEffort(options.port, codec.encode(response));
       } catch (error) {
-        if (disposed) return;
+        if (controller.signal.aborted || !isCurrent(message.callId, call)) return;
         sendError(message, error);
       } finally {
-        pending.delete(message.callId);
+        if (pending.get(message.callId) === call) pending.delete(message.callId);
       }
     })();
   };
   options.port.addEventListener("message", onMessage);
   options.port.start();
-  post(options.port, codec.encode({
-    type: codec.type("handshake"),
-    handshake: options.handshake
-  }));
-  post(options.port, codec.encode({
-    type: codec.type("snapshot"),
-    snapshot: options.snapshot
-  }));
-  const dispose = () => {
-    if (disposed) return;
-    disposed = true;
-    options.port.removeEventListener("message", onMessage);
-    for (const { controller } of pending.values()) controller.abort(new Error("Remote service provider disposed"));
-    pending.clear();
-    if (options.closeOnDispose !== false) options.port.close();
-  };
   const provider = {
-    publishSnapshot(snapshot) {
+    setServices(nextServices) {
       if (disposed) return;
-      activeProviderInstanceIds = new Set(
-        snapshot.services.map((service) => service.providerInstanceId)
-      );
-      post(options.port, codec.encode({
-        type: codec.type("snapshot"),
-        snapshot
-      }));
+      const next = [...nextServices];
+      const nextBindings = buildBindings(next);
+      revoked = true;
+      revokeReplacedCalls(nextBindings);
+      services = next;
+      bindings = nextBindings;
+      revoked = false;
     },
-    invalidate(reason = "Remote service invalidated") {
+    revoke(reason = "Remote service Provider revoked") {
       if (disposed) return;
-      activeProviderInstanceIds = /* @__PURE__ */ new Set();
-      for (const { controller } of pending.values()) controller.abort(new Error(reason));
-      post(options.port, codec.encode({
-        type: codec.type("invalidate"),
-        reason
-      }));
+      revoked = true;
+      for (const call of pending.values()) {
+        sendError(call.message, new RemoteServiceError("service_revoked", reason));
+        call.controller.abort(new RemoteServiceError("service_revoked", reason));
+      }
+      services = [];
+      bindings = /* @__PURE__ */ new Map();
     },
-    disconnect(reason = "Remote service disconnected") {
+    dispose() {
       if (disposed) return;
-      post(options.port, codec.encode({
-        type: codec.type("disconnect"),
-        reason
-      }));
-      dispose();
-    },
-    dispose
+      disposed = true;
+      revoked = true;
+      options.port.removeEventListener("message", onMessage);
+      for (const { controller } of pending.values()) {
+        controller.abort(new RemoteServiceError("transport_unavailable", "Remote service Provider disposed"));
+      }
+      pending.clear();
+      services = [];
+      bindings = /* @__PURE__ */ new Map();
+      if (options.closeOnDispose !== false) {
+        try {
+          options.port.close();
+        } catch {
+        }
+      }
+    }
   };
   return provider;
 }
@@ -621,69 +595,18 @@ function errorMessage3(error) {
 }
 function startupDetails(error) {
   if (error instanceof StartupPluginError) {
-    return {
-      pluginId: error.details.pluginId,
-      unitId: error.details.unitId,
-      message: error.details.error ?? error.message
-    };
+    return { pluginId: error.details.pluginId, unitId: error.details.unitId, message: error.details.error ?? error.message };
   }
   if (error instanceof RuntimeInitializationError) {
-    return {
-      pluginId: error.details.pluginId,
-      unitId: error.details.unitId,
-      message: error.message
-    };
+    return { pluginId: error.details.pluginId, unitId: error.details.unitId, message: error.message };
   }
   return { message: errorMessage3(error) };
 }
 function addPortListener(port, listener) {
-  const target = port;
-  const add = target.addEventListener;
-  const remove = target.removeEventListener;
-  if (add && remove) {
-    const before2 = target.onmessage;
-    const probe = () => void 0;
-    add.call(port, "message", probe);
-    const overwritesProperty = target.onmessage === probe;
-    remove.call(port, "message", probe);
-    if (!overwritesProperty) {
-      add.call(port, "message", listener);
-      return () => remove.call(port, "message", listener);
-    }
-    const listeners2 = /* @__PURE__ */ new Set();
-    const dispatch2 = (event) => {
-      before2?.call(port, event);
-      for (const current of [...listeners2]) current(event);
-    };
-    target.addEventListener = function addMessageListener2(type, current) {
-      if (type === "message") listeners2.add(current);
-      else add.call(port, type, current);
-    };
-    target.removeEventListener = function removeMessageListener(type, current) {
-      if (type === "message") listeners2.delete(current);
-      else remove.call(port, type, current);
-    };
-    target.onmessage = dispatch2;
-    listeners2.add(listener);
-    return () => listeners2.delete(listener);
-  }
-  const listeners = /* @__PURE__ */ new Set();
-  const before = target.onmessage;
-  const dispatch = (event) => {
-    before?.call(port, event);
-    for (const current of [...listeners]) current(event);
-  };
-  target.addEventListener = function addMessageListener2(type, current) {
-    if (type === "message") listeners.add(current);
-  };
-  target.removeEventListener = function removeMessageListener(type, current) {
-    if (type === "message") listeners.delete(current);
-  };
-  target.onmessage = dispatch;
-  listeners.add(listener);
-  return () => listeners.delete(listener);
+  port.addEventListener("message", listener);
+  return () => port.removeEventListener("message", listener);
 }
-function post2(port, message) {
+function post(port, message) {
   try {
     port.postMessage(message);
   } catch {
@@ -710,22 +633,38 @@ function startSharedWorkerApp(options) {
   let host;
   let manifests = [];
   let disposed = false;
+  let acceptingConnections = true;
   let disposePromise;
-  const emit = () => {
-    const snapshot = currentSnapshot();
-    for (const listener of [...listeners]) {
-      try {
-        listener(snapshot);
-      } catch {
+  let startupError;
+  const serviceReferences = () => {
+    if (!host || runtimeState !== "ready") return [];
+    const services = [];
+    for (const manifest of manifests) {
+      const state = host.state(manifest.id);
+      const unit = manifest.units?.find((candidate) => candidate.id === state.unitId) ?? manifest.units?.[0];
+      if (!unit || unit.runtime === void 0 || !state.instanceId || state.kind !== "enabled") continue;
+      const scope = host.scope(manifest.id);
+      const attributes = Object.freeze({ ...scope?.identity.attributes ?? {} });
+      for (const capability of unit.provides ?? []) {
+        services.push({
+          capabilityId: capability,
+          contractVersion: unit.providedContracts?.[capability] ?? `${capability}.v1`,
+          runtime: unit.runtime,
+          runtimeInstanceId,
+          serviceInstanceId: state.instanceId,
+          status: "ready",
+          attributes
+        });
       }
     }
+    return services;
   };
   const currentSnapshot = () => Object.freeze({
     runtimeId,
     runtimeKind: "shared-worker",
     runtimeInstanceId,
     state: runtimeState,
-    snapshotRevision: revision,
+    revision,
     units: Object.freeze(host && runtimeState !== "failed" ? manifests.flatMap((manifest) => {
       const state = host?.state(manifest.id);
       return (state?.units ?? []).map((unit) => ({
@@ -736,70 +675,42 @@ function startSharedWorkerApp(options) {
         state: unit.kind
       }));
     }) : []),
-    services: Object.freeze(host && runtimeState !== "failed" ? serviceReferences("", revision) : [])
+    services: Object.freeze(serviceReferences())
   });
-  const serviceReferences = (connectionId, snapshotRevision) => {
-    if (!host || runtimeState === "failed" || runtimeState === "disposed") return [];
-    const services = [];
-    for (const manifest of manifests) {
-      const state = host.state(manifest.id);
-      const unit = manifest.units?.find((candidate) => candidate.id === state.unitId) ?? manifest.units?.[0];
-      if (!unit || unit.runtime === void 0 || !state.instanceId || state.kind !== "enabled") continue;
-      const scopeId = host.scope(manifest.id)?.identity.scopeId ?? `scope:${state.instanceId}`;
-      for (const capability of unit.provides ?? []) {
-        services.push({
-          capabilityId: capability,
-          providerInstanceId: state.instanceId,
-          runtime: unit.runtime,
-          contractVersion: unit.providedContracts?.[capability] ?? `${capability}.v1`,
-          authorityInstanceId: runtimeInstanceId,
-          scopeId,
-          handoverGeneration: 0,
-          attributes: Object.freeze({}),
-          status: "ready",
-          snapshotRevision,
-          // The same service object is never valid through another port.
-          ...connectionId ? { connectionId } : {}
-        });
+  const emit = () => {
+    const snapshot = currentSnapshot();
+    for (const listener of [...listeners]) {
+      try {
+        listener(snapshot);
+      } catch {
       }
     }
-    return services;
   };
-  const runtimeSnapshotFor = (endpoint, baseline) => ({
+  const runtimeSnapshot = () => ({
     type: RUNTIME_SNAPSHOT_TYPE,
     protocolVersion: RUNTIME_PROTOCOL_VERSION,
     runtimeId,
     runtimeKind: "shared-worker",
     runtimeInstanceId,
-    connectionId: endpoint.connectionId,
-    snapshotRevision: revision,
-    baseline,
+    revision,
     state: runtimeState,
     units: currentSnapshot().units,
-    services: serviceReferences(endpoint.connectionId, revision)
-  });
-  const serviceSnapshotFor = (endpoint, baseline) => ({
-    connectionId: endpoint.connectionId,
-    authorityInstanceId: runtimeInstanceId,
-    snapshotRevision: revision,
-    baseline,
-    services: serviceReferences(endpoint.connectionId, revision)
+    services: serviceReferences()
   });
-  const publishEndpoint = (endpoint, baseline) => {
-    if (endpoint.closed || disposed) return;
-    const serviceSnapshot = serviceSnapshotFor(endpoint, baseline);
-    endpoint.provider.publishSnapshot(serviceSnapshot);
-    post2(endpoint.port, codec.encode(runtimeSnapshotFor(endpoint, baseline)));
+  const publishEndpoint = (endpoint) => {
+    if (endpoint.closed) return;
+    endpoint.provider.setServices(serviceReferences());
+    post(endpoint.port, codec.encode(runtimeSnapshot()));
   };
-  const publishAll = (baseline = false) => {
-    for (const endpoint of [...endpoints]) publishEndpoint(endpoint, baseline);
+  const publishAll = () => {
+    for (const endpoint of [...endpoints]) publishEndpoint(endpoint);
   };
-  const closeEndpoint = (endpoint, reason) => {
+  const closeEndpoint = (endpoint, _reason) => {
     if (endpoint.closed) return;
     endpoint.closed = true;
     endpoints.delete(endpoint);
     endpoint.removeMessage();
-    endpoint.provider.disconnect(reason);
+    endpoint.provider.dispose();
   };
   const sendError = (port, code, message, details = {}) => {
     const error = {
@@ -811,31 +722,34 @@ function startSharedWorkerApp(options) {
       ...details.unitId !== void 0 ? { unitId: details.unitId } : {},
       ...details.phase !== void 0 ? { phase: details.phase } : {}
     };
-    post2(port, error);
+    post(port, error);
+  };
+  const isAcceptingConnections = () => acceptingConnections && runtimeState !== "stopping" && runtimeState !== "disposed" && !disposed;
+  const rejectLateConnection = (port) => {
+    post(port, codec.encode(runtimeSnapshot()));
+    setTimeout(() => {
+      try {
+        port.close();
+      } catch {
+      }
+    }, 0);
   };
-  const handleCall = async (connectionId, input) => {
+  const handleCall = async (input) => {
     if (!host || runtimeState !== "ready") throw new Error("SharedWorker Runtime is not ready");
-    const message = input.message;
-    if (message.connectionId !== connectionId) throw new Error("Runtime connection mismatch");
-    const reference = message.reference;
-    if (message.providerInstanceId !== reference.providerInstanceId || reference.authorityInstanceId !== runtimeInstanceId || reference.connectionId !== connectionId || reference.runtime !== "shared-worker" || reference.status !== "ready" || reference.snapshotRevision !== revision || reference.handoverGeneration !== 0) {
+    const { message, reference } = input;
+    if (reference.runtimeInstanceId !== runtimeInstanceId || reference.runtime !== "shared-worker" || reference.status !== "ready") {
       throw new Error("Runtime service reference is stale");
     }
-    const manifest = manifests.find((candidate) => {
-      const state2 = host?.state(candidate.id);
-      return state2?.instanceId === reference.providerInstanceId;
-    });
+    const manifest = manifests.find((candidate) => host?.state(candidate.id).instanceId === reference.serviceInstanceId);
     if (!manifest) throw new Error("Runtime service provider is no longer active");
     const state = host.state(manifest.id);
-    if (state.kind !== "enabled" || state.instanceId !== reference.providerInstanceId) {
+    if (state.kind !== "enabled" || state.instanceId !== reference.serviceInstanceId) {
       throw new Error("Runtime service provider is no longer active");
     }
     const unit = manifest.units?.find((candidate) => candidate.id === state.unitId);
     if (!unit || unit.runtime !== "shared-worker" || !unit.provides?.includes(reference.capabilityId)) {
       throw new Error("Runtime capability is not declared");
     }
-    const expectedScopeId = host.scope(manifest.id)?.identity.scopeId ?? `scope:${state.instanceId}`;
-    if (reference.scopeId !== expectedScopeId) throw new Error("Runtime service scope is stale");
     const expectedVersion = unit.providedContracts?.[reference.capabilityId] ?? `${reference.capabilityId}.v1`;
     if (expectedVersion !== reference.contractVersion) throw new Error("Runtime capability contract mismatch");
     const value = host.capabilities.get(reference.capabilityId);
@@ -858,104 +772,50 @@ function startSharedWorkerApp(options) {
   };
   const attachPort = (port) => {
     let endpoint;
-    let helloSeen = false;
     let removeMessage = () => void 0;
+    const onMessageError = () => {
+      if (endpoint) closeEndpoint(endpoint);
+    };
+    endpoint = {
+      port,
+      provider: void 0,
+      removeMessage: () => void 0,
+      closed: false
+    };
+    endpoint.provider = createMessagePortServiceProvider({
+      port,
+      codec,
+      services: serviceReferences,
+      handleCall
+    });
+    endpoints.add(endpoint);
     const onMessage = (event) => {
-      if (endpoint?.closed) return;
-      const decoded = codec.decode(event.data);
-      if (!helloSeen) {
-        if (!isRuntimeHello(event.data)) return;
-        const hello = event.data;
-        helloSeen = true;
-        if (hello.protocolVersion !== RUNTIME_PROTOCOL_VERSION) {
-          sendError(port, "runtime.protocol_mismatch", "Runtime protocol version mismatch", { phase: "handshake" });
-          try {
-            port.close();
-          } catch {
-          }
-          return;
-        }
-        if (hello.runtimeId !== runtimeId) {
-          sendError(port, "runtime.invalid_connection", "Runtime id mismatch", { phase: "handshake" });
-          try {
-            port.close();
-          } catch {
-          }
-          return;
-        }
-        if (runtimeState === "failed") {
-          const detail = startupDetails(startupError);
-          sendError(port, "runtime.initialization_failed", detail.message, {
-            pluginId: detail.pluginId,
-            unitId: detail.unitId,
-            phase: "startup"
-          });
-          try {
-            port.close();
-          } catch {
-          }
-          return;
-        }
-        if (runtimeState === "stopping" || runtimeState === "disposed") {
-          sendError(port, "runtime.invalid_connection", "SharedWorker Runtime is no longer accepting connections", { phase: "handshake" });
-          try {
-            port.close();
-          } catch {
-          }
-          return;
-        }
-        if (endpointsHasConnection(hello.connectionId)) {
-          sendError(port, "runtime.invalid_connection", "Connection id is already active", { phase: "handshake" });
-          try {
-            port.close();
-          } catch {
-          }
-          return;
-        }
-        const candidate = { port, connectionId: hello.connectionId };
-        const provider = createMessagePortServiceProvider({
-          port,
-          codec,
-          handshake: {
-            connectionId: hello.connectionId,
-            authorityInstanceId: runtimeInstanceId,
-            protocolVersion: RUNTIME_PROTOCOL_VERSION
-          },
-          snapshot: serviceSnapshotFor(candidate, true),
-          handleCall: (input) => handleCall(hello.connectionId, input)
-        });
-        endpoint = { ...candidate, provider, removeMessage, closed: false };
-        endpoints.add(endpoint);
-        if (runtimeState === "ready") publishEndpoint(endpoint, true);
-        return;
-      }
-      if (!endpoint) return;
-      if (isRuntimeResync(event.data)) {
-        if (event.data.connectionId === endpoint.connectionId) publishEndpoint(endpoint, true);
-        return;
-      }
-      if (decoded?.type === codec.type("disconnect")) {
-        closeEndpoint(endpoint, typeof decoded.reason === "string" ? decoded.reason : "Window disconnected");
-      }
     };
     removeMessage = addPortListener(port, onMessage);
+    endpoint.removeMessage = () => {
+      removeMessage();
+      port.removeEventListener("messageerror", onMessageError);
+    };
+    port.addEventListener("messageerror", onMessageError);
     port.start();
+    publishEndpoint(endpoint);
   };
-  const endpointsHasConnection = (connectionId) => [...endpoints].some((endpoint) => endpoint.connectionId === connectionId);
-  let startupError;
   workerScope.onconnect = (event) => {
+    const ports = event.ports ?? [];
+    if (!isAcceptingConnections()) {
+      for (const port of ports) rejectLateConnection(port);
+      return;
+    }
     try {
       options.onPortConnect?.(event);
     } catch (error) {
       const detail = startupDetails(error);
-      for (const port of event.ports ?? []) {
-        sendError(port, "runtime.initialization_failed", detail.message, {
+      for (const port of ports) {
+        sendError(port, "runtime_initialization_failed", detail.message, {
           pluginId: detail.pluginId,
           unitId: detail.unitId,
-          phase: "handshake"
+          phase: "startup"
         });
-      }
-      for (const port of event.ports ?? []) {
         try {
           port.close();
         } catch {
@@ -963,39 +823,37 @@ function startSharedWorkerApp(options) {
       }
       return;
     }
-    for (const port of event.ports ?? []) attachPort(port);
+    if (!isAcceptingConnections()) {
+      for (const port of ports) rejectLateConnection(port);
+      return;
+    }
+    for (const port of ports) attachPort(port);
   };
   let materialized = [];
   let readyPromise;
   try {
     materialized = materializePluginDefinitions(options.plugins, "shared-worker");
     manifests = materialized.map((item) => item.manifest);
-    const implementations = createRuntimeUnitImplementationRegistry(
-      materialized.map((item) => ({
-        pluginId: item.manifest.id,
-        unitId: item.unitId,
-        setup: item.setup
-      }))
-    );
+    const implementations = createRuntimeUnitImplementationRegistry(materialized.map((item) => ({
+      pluginId: item.manifest.id,
+      unitId: item.unitId,
+      setup: item.setup
+    })));
     const { id: _id, plugins: _plugins, globalScope: _scope, onPortConnect: _onPortConnect, ...hostOptions } = options;
     host = createPluginHost({
       ...hostOptions,
       runtime: "shared-worker",
-      rootAttributes: {
-        ...hostOptions.rootAttributes ?? {},
-        runtimeId,
-        runtimeInstanceId
-      },
+      rootAttributes: { ...hostOptions.rootAttributes ?? {}, runtimeId, runtimeInstanceId },
       runtimeUnitImplementationRegistry: implementations
     });
     host.subscribe(() => {
       if (runtimeState !== "ready" || disposed) return;
       revision += 1;
-      publishAll(false);
+      publishAll();
       emit();
     });
     readyPromise = host.registerAll(manifests).then(() => {
-      if (disposed) return;
+      if (runtimeState === "stopping" || disposed) return;
       const runtimeHost = host;
       if (!runtimeHost) throw new Error("SharedWorker Plugin Host is unavailable");
       const failedRequired = manifests.find((manifest) => {
@@ -1009,20 +867,21 @@ function startSharedWorkerApp(options) {
           unitId: state.unitId ?? failedRequired.units?.[0]?.id ?? failedRequired.id,
           capabilities: [],
           state: state.kind,
-          error: state.error ?? `Required plugin is ${state.kind}${state.blockedBy ? `: ${state.blockedBy.join(", ")}` : ""}`
+          error: state.error ?? `Required plugin is ${state.kind}`
         });
       }
       runtimeState = "ready";
       revision = Math.max(1, revision + 1);
-      publishAll(true);
+      publishAll();
       emit();
     }).catch((error) => {
+      if (runtimeState === "stopping" || disposed) return;
       startupError = error;
       runtimeState = "failed";
       emit();
       const detail = startupDetails(error);
       for (const endpoint of [...endpoints]) {
-        sendError(endpoint.port, "runtime.initialization_failed", detail.message, {
+        sendError(endpoint.port, "runtime_initialization_failed", detail.message, {
           pluginId: detail.pluginId,
           unitId: detail.unitId,
           phase: "startup"
@@ -1041,6 +900,7 @@ function startSharedWorkerApp(options) {
     runtimeState = "failed";
     emit();
     readyPromise = Promise.reject(error instanceof RuntimeInitializationError ? error : new RuntimeInitializationError({ phase: "validate", error: errorMessage3(error) }));
+    void readyPromise.catch(() => void 0);
   }
   const app = {
     runtimeKind: "shared-worker",
@@ -1052,7 +912,7 @@ function startSharedWorkerApp(options) {
         await readyPromise;
         return;
       }
-      if (runtimeState === "failed" || runtimeState === "disposed" || disposed) {
+      if (runtimeState === "failed" || runtimeState === "stopping" || runtimeState === "disposed" || disposed) {
         await readyPromise;
         return;
       }
@@ -1066,14 +926,35 @@ function startSharedWorkerApp(options) {
     },
     dispose(reason = "shared worker runtime disposed") {
       if (disposePromise) return disposePromise;
-      disposed = true;
+      acceptingConnections = false;
       runtimeState = "stopping";
+      revision += 1;
+      publishAll();
       emit();
       disposePromise = (async () => {
-        for (const endpoint of [...endpoints]) closeEndpoint(endpoint, reason);
-        const result = host ? await host.dispose(reason) : { scopeId: `runtime:${runtimeInstanceId}`, state: "stopped", attempted: 0, released: 0, pending: [], errors: [], cleanupIncomplete: false };
+        let result;
+        let failure;
+        try {
+          result = host ? await host.dispose(reason) : { scopeId: `runtime:${runtimeInstanceId}`, state: "stopped", attempted: 0, released: 0, pending: [], errors: [], cleanupIncomplete: false };
+        } catch (error) {
+          failure = error;
+          result = {
+            scopeId: `runtime:${runtimeInstanceId}`,
+            state: "stopped",
+            attempted: 0,
+            released: 0,
+            pending: [],
+            errors: [{ resourceId: "runtime.dispose", code: "lifecycle.cleanup_failed", message: errorMessage3(error) }],
+            cleanupIncomplete: true
+          };
+        }
         runtimeState = "disposed";
+        revision += 1;
+        publishAll();
         emit();
+        disposed = true;
+        for (const endpoint of [...endpoints]) closeEndpoint(endpoint);
+        if (failure) throw failure;
         return result;
       })();
       return disposePromise;
@@ -1082,495 +963,6 @@ function startSharedWorkerApp(options) {
   return app;
 }
 
-// src/runtime/connectSharedWorker.ts
-function makeConnectionId(runtimeId) {
-  try {
-    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-      return `${runtimeId}:connection:${crypto.randomUUID()}`;
-    }
-  } catch {
-  }
-  return `${runtimeId}:connection:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-}
-function errorMessage4(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function createDeferred() {
-  let resolvePromise;
-  let rejectPromise;
-  const deferred = {
-    promise: new Promise((resolve, reject) => {
-      resolvePromise = resolve;
-      rejectPromise = reject;
-    }),
-    settled: false,
-    resolve(value) {
-      if (deferred.settled) return;
-      deferred.settled = true;
-      resolvePromise(value);
-    },
-    reject(error) {
-      if (deferred.settled) return;
-      deferred.settled = true;
-      rejectPromise(error);
-    }
-  };
-  return deferred;
-}
-function post3(port, message) {
-  try {
-    port.postMessage(message);
-  } catch {
-  }
-}
-function addMessageListener(port, listener) {
-  const before = port.onmessage;
-  port.addEventListener("message", listener);
-  if (port.onmessage === listener && before && before !== listener) {
-    port.removeEventListener("message", listener);
-    const composed = (event) => {
-      before.call(port, event);
-      listener(event);
-    };
-    port.addEventListener("message", composed);
-    return () => port.removeEventListener("message", composed);
-  }
-  return () => port.removeEventListener("message", listener);
-}
-function ensureMessageEventTarget(port) {
-  const target = port;
-  const add = target.addEventListener;
-  const remove = target.removeEventListener;
-  if (add && remove) {
-    const before = target.onmessage;
-    const probe = () => void 0;
-    add.call(port, "message", probe);
-    const overwritesProperty = target.onmessage === probe;
-    remove.call(port, "message", probe);
-    if (!overwritesProperty) return;
-    const listeners2 = /* @__PURE__ */ new Set();
-    const dispatch2 = (event) => {
-      before?.call(port, event);
-      for (const listener of [...listeners2]) listener(event);
-    };
-    target.addEventListener = function addMessageListener2(type, listener) {
-      if (type === "message") listeners2.add(listener);
-      else add.call(port, type, listener);
-    };
-    target.removeEventListener = function removeMessageListener(type, listener) {
-      if (type === "message") listeners2.delete(listener);
-      else remove.call(port, type, listener);
-    };
-    target.onmessage = dispatch2;
-    return;
-  }
-  const listeners = /* @__PURE__ */ new Set();
-  const original = target.onmessage;
-  const dispatch = (event) => {
-    original?.call(port, event);
-    for (const listener of [...listeners]) listener(event);
-  };
-  target.addEventListener = function addMessageListener2(type, listener) {
-    if (type === "message") listeners.add(listener);
-  };
-  target.removeEventListener = function removeMessageListener(type, listener) {
-    if (type === "message") listeners.delete(listener);
-  };
-  target.onmessage = dispatch;
-}
-function makeWorker(options) {
-  const workerOptions = {
-    type: "module",
-    ...options.name ? { name: options.name } : {}
-  };
-  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);
-}
-async function connectSharedWorker(options) {
-  if (!options || typeof options.id !== "string" || options.id.trim() === "") {
-    throw new Error("SharedWorker runtime id must be a non-empty string");
-  }
-  const codec = createRuntimeMessageCodec();
-  const listeners = /* @__PURE__ */ new Set();
-  const autoReconnect = options.autoReconnect ?? true;
-  const reconnectDelayMs = Math.max(0, options.reconnectDelayMs ?? 25);
-  const handshakeTimeoutMs = Math.max(1, options.handshakeTimeoutMs ?? 1e4);
-  let disposed = false;
-  let currentWorker;
-  let currentPort;
-  let currentTransport;
-  let removeMessage;
-  let removeWorkerError;
-  let handshakeTimer;
-  let reconnectTimer;
-  let connectionGeneration = 0;
-  let currentConnection;
-  let readyDeferred = createDeferred();
-  let initialConnection = true;
-  let runtimeInstanceId;
-  let connectionId;
-  let currentSnapshot = {
-    runtimeId: options.id,
-    runtimeKind: "shared-worker",
-    runtimeInstanceId: "",
-    state: "connecting",
-    snapshotRevision: 0,
-    units: [],
-    services: []
-  };
-  const bridgeTransport = {
-    call(request, context) {
-      if (!currentTransport) return Promise.reject(new RuntimeUnavailableError("SharedWorker connection is unavailable"));
-      return currentTransport.call(request, context);
-    }
-  };
-  const bridge = createServiceBridge({ protocolVersion: RUNTIME_PROTOCOL_VERSION, transport: bridgeTransport });
-  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 rejectReady = (error) => {
-    readyDeferred.reject(error);
-    void readyDeferred.promise.catch(() => void 0);
-  };
-  const beginReadinessGeneration = (reason) => {
-    rejectReady(new RuntimeUnavailableError(reason));
-    readyDeferred = createDeferred();
-  };
-  const replaceWithRejectedReadiness = (error) => {
-    rejectReady(error);
-    readyDeferred = createDeferred();
-    rejectReady(error);
-  };
-  const scheduleReconnect = () => {
-    if (disposed || !autoReconnect || reconnectTimer !== void 0) return;
-    reconnectTimer = setTimeout(() => {
-      reconnectTimer = void 0;
-      void openConnection().catch((error) => {
-        if (disposed) return;
-        if (currentSnapshot.state !== "disconnected") {
-          emit({ ...currentSnapshot, state: "disconnected", error: errorMessage4(error), units: [], services: [] });
-        }
-        rejectReady(error);
-        beginReadinessGeneration("SharedWorker reconnecting");
-        scheduleReconnect();
-      });
-    }, reconnectDelayMs);
-  };
-  const cleanupConnection = (connection) => {
-    if (!connection || connection.cleaned) return;
-    connection.cleaned = true;
-    const timer = connection.handshakeTimer;
-    const removeMessageForConnection = connection.removeMessage;
-    const removeWorkerErrorForConnection = connection.removeWorkerError;
-    const transport = connection.transport;
-    if (timer !== void 0) clearTimeout(timer);
-    connection.handshakeTimer = void 0;
-    removeMessageForConnection?.();
-    connection.removeMessage = void 0;
-    removeWorkerErrorForConnection?.();
-    connection.removeWorkerError = void 0;
-    transport?.dispose();
-    connection.transport = void 0;
-    if (currentConnection === connection) currentConnection = void 0;
-    if (currentWorker === connection.worker) currentWorker = void 0;
-    if (currentPort === connection.port) currentPort = void 0;
-    if (currentTransport === transport) currentTransport = void 0;
-    if (removeMessage === removeMessageForConnection) removeMessage = void 0;
-    if (removeWorkerError === removeWorkerErrorForConnection) removeWorkerError = void 0;
-    if (handshakeTimer === timer) handshakeTimer = void 0;
-    try {
-      connection.port.close();
-    } catch {
-    }
-  };
-  const disconnect = (reason, failure, fatal = false) => {
-    if (disposed) return;
-    const connection = currentConnection;
-    connection?.port ?? currentPort;
-    cleanupConnection(connection);
-    currentTransport = void 0;
-    currentWorker = void 0;
-    currentPort = void 0;
-    connectionId = void 0;
-    bridge.disconnect(reason);
-    emit({
-      ...currentSnapshot,
-      state: fatal ? "failed" : "disconnected",
-      error: failure ? errorMessage4(failure) : reason,
-      runtimeInstanceId: "",
-      connectionId: void 0,
-      units: [],
-      services: []
-    });
-    runtimeInstanceId = void 0;
-    const unavailable = failure ?? new RuntimeUnavailableError(reason);
-    if (!initialConnection && !fatal && autoReconnect) {
-      beginReadinessGeneration("SharedWorker reconnecting");
-      scheduleReconnect();
-    } else {
-      replaceWithRejectedReadiness(unavailable);
-    }
-  };
-  const onRuntimeError = (message) => {
-    const error = new RuntimeInitializationError({
-      pluginId: message.pluginId,
-      unitId: message.unitId,
-      phase: message.phase === "handshake" ? "handshake" : "startup",
-      error: message.message
-    });
-    const fatal = message.code === "runtime.protocol_mismatch" || message.code === "runtime.initialization_failed";
-    disconnect(message.message, error, fatal);
-  };
-  const onSnapshot = (snapshot) => {
-    if (snapshot.runtimeId !== options.id || snapshot.connectionId !== connectionId) return;
-    if (snapshot.runtimeKind !== "shared-worker") {
-      onRuntimeError({
-        code: "runtime.protocol_mismatch",
-        message: "Connected Runtime is not a SharedWorker Runtime",
-        phase: "handshake"
-      });
-      return;
-    }
-    const isNewAuthority = runtimeInstanceId !== snapshot.runtimeInstanceId;
-    if (isNewAuthority || bridge.state === "disconnected") {
-      const result = bridge.handshake({
-        connectionId: snapshot.connectionId,
-        authorityInstanceId: snapshot.runtimeInstanceId,
-        protocolVersion: snapshot.protocolVersion
-      });
-      if (!result.accepted) {
-        onRuntimeError({
-          code: "runtime.protocol_mismatch",
-          message: "Runtime protocol version mismatch",
-          phase: "handshake"
-        });
-        return;
-      }
-    }
-    runtimeInstanceId = snapshot.runtimeInstanceId;
-    const applied = bridge.applySnapshot({
-      connectionId: snapshot.connectionId,
-      authorityInstanceId: snapshot.runtimeInstanceId,
-      snapshotRevision: snapshot.snapshotRevision,
-      baseline: snapshot.baseline,
-      services: snapshot.services
-    });
-    if (!applied.accepted) {
-      if (applied.reason === "revision-gap" || applied.reason === "baseline-required") {
-        beginReadinessGeneration(`Runtime snapshot ${applied.reason}`);
-        emit({
-          ...currentSnapshot,
-          state: "disconnected",
-          error: `Runtime snapshot ${applied.reason}`,
-          units: [],
-          services: []
-        });
-        const port = currentPort;
-        if (port && connectionId) post3(port, { type: "webloom.runtime.resync", connectionId });
-      }
-      return;
-    }
-    emit({
-      runtimeId: snapshot.runtimeId,
-      runtimeKind: snapshot.runtimeKind,
-      runtimeInstanceId: snapshot.runtimeInstanceId,
-      state: snapshot.state === "ready" ? "ready" : snapshot.state,
-      snapshotRevision: snapshot.snapshotRevision,
-      connectionId: snapshot.connectionId,
-      units: snapshot.units,
-      services: snapshot.services
-    });
-    if (snapshot.baseline && snapshot.state === "ready" && bridge.state === "ready") {
-      if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
-      handshakeTimer = void 0;
-      readyDeferred.resolve(void 0);
-      initialConnection = false;
-    }
-  };
-  async function openConnection() {
-    if (disposed) return;
-    const generation = ++connectionGeneration;
-    if (readyDeferred.settled) readyDeferred = createDeferred();
-    let connection;
-    try {
-      const worker = makeWorker(options);
-      const port = worker.port;
-      const nextConnectionId = makeConnectionId(options.id);
-      connection = {
-        generation,
-        worker,
-        port,
-        connectionId: nextConnectionId,
-        cleaned: false
-      };
-      currentConnection = connection;
-      currentWorker = worker;
-      currentPort = port;
-      connectionId = nextConnectionId;
-      emit({
-        ...currentSnapshot,
-        state: "connecting",
-        connectionId: nextConnectionId,
-        error: void 0
-      });
-      await options.onConnection?.({
-        worker,
-        port,
-        connectionId: nextConnectionId
-      });
-      if (disposed || currentConnection !== connection) {
-        cleanupConnection(connection);
-        return;
-      }
-      ensureMessageEventTarget(port);
-      connection.transport = createMessagePortServiceTransport({ port, codec });
-      currentTransport = connection.transport;
-      const onWorkerError = (event) => {
-        if (disposed || generation !== connectionGeneration || worker !== currentWorker) return;
-        disconnect(`SharedWorker error${event.type ? `: ${event.type}` : ""}`);
-      };
-      if (worker.addEventListener) {
-        worker.addEventListener("error", onWorkerError);
-        connection.removeWorkerError = () => worker.removeEventListener?.("error", onWorkerError);
-        removeWorkerError = connection.removeWorkerError;
-      } else {
-        const workerWithOnError = worker;
-        const previousOnError = workerWithOnError.onerror;
-        const composedOnError = (event) => {
-          previousOnError?.(event);
-          onWorkerError(event);
-        };
-        workerWithOnError.onerror = composedOnError;
-        connection.removeWorkerError = () => {
-          if (workerWithOnError.onerror === composedOnError) workerWithOnError.onerror = previousOnError;
-        };
-        removeWorkerError = connection.removeWorkerError;
-      }
-      const onMessage = (event) => {
-        if (disposed || generation !== connectionGeneration || port !== currentPort) return;
-        if (isRuntimeError(event.data)) {
-          onRuntimeError(event.data);
-          return;
-        }
-        if (isSnapshot(event.data)) {
-          onSnapshot(event.data);
-          return;
-        }
-        const decoded = codec.decode(event.data);
-        if (decoded?.type === codec.type("disconnect")) {
-          disconnect(typeof decoded.reason === "string" ? decoded.reason : "SharedWorker disconnected");
-        }
-      };
-      connection.removeMessage = addMessageListener(port, onMessage);
-      removeMessage = connection.removeMessage;
-      port.start();
-      const timer = setTimeout(() => {
-        if (disposed || generation !== connectionGeneration || port !== currentPort) return;
-        const error = new RuntimeInitializationError({
-          phase: "handshake",
-          error: `SharedWorker handshake timed out after ${handshakeTimeoutMs}ms`
-        });
-        disconnect(error.message, error, false);
-      }, handshakeTimeoutMs);
-      connection.handshakeTimer = timer;
-      handshakeTimer = timer;
-      post3(port, {
-        type: RUNTIME_HELLO_TYPE,
-        protocolVersion: RUNTIME_PROTOCOL_VERSION,
-        connectionId: nextConnectionId,
-        runtimeId: options.id
-      });
-      await readyDeferred.promise;
-    } catch (error) {
-      if (connection && !connection.cleaned && currentConnection === connection) {
-        disconnect("SharedWorker connection setup failed", error, false);
-      } else if (connection && !connection.cleaned) {
-        cleanupConnection(connection);
-      } else if (!connection && !disposed && initialConnection) {
-        replaceWithRejectedReadiness(error);
-      }
-      throw error;
-    }
-  }
-  function isSnapshot(input) {
-    return isRuntimeSnapshot(input);
-  }
-  const app = {
-    runtimeKind: "shared-worker",
-    runtimeId: options.id,
-    serviceBridge: bridge,
-    get runtimeInstanceId() {
-      return runtimeInstanceId;
-    },
-    get connectionId() {
-      return connectionId;
-    },
-    state: () => currentSnapshot,
-    ready: () => readyDeferred.promise,
-    capability(capabilityId, capabilityOptions = {}) {
-      if (disposed || currentSnapshot.state !== "ready") {
-        throw new RuntimeUnavailableError(`Capability "${capabilityId}" is not ready`);
-      }
-      return bridge.requireProxy({
-        capabilityId,
-        contractVersion: capabilityOptions.contractVersion ?? `${capabilityId}.v1`
-      });
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      listener(currentSnapshot);
-      return () => listeners.delete(listener);
-    },
-    dispose(reason = "SharedWorker connection disposed") {
-      if (disposed) return Promise.resolve();
-      disposed = true;
-      if (reconnectTimer !== void 0) clearTimeout(reconnectTimer);
-      replaceWithRejectedReadiness(new RuntimeUnavailableError(reason));
-      const connection = currentConnection;
-      const port = connection?.port ?? currentPort;
-      if (port) post3(port, codec.encode({ type: codec.type("disconnect"), reason }));
-      cleanupConnection(connection);
-      currentWorker = void 0;
-      currentPort = void 0;
-      connectionId = void 0;
-      runtimeInstanceId = void 0;
-      currentTransport?.dispose();
-      currentTransport = void 0;
-      bridge.disconnect(reason);
-      emit({
-        ...currentSnapshot,
-        state: "disposed",
-        runtimeInstanceId: "",
-        connectionId: void 0,
-        units: [],
-        services: []
-      });
-      return Promise.resolve();
-    }
-  };
-  try {
-    await openConnection();
-  } catch (error) {
-    if (!disposed) {
-      emit({ ...currentSnapshot, state: "failed", error: errorMessage4(error) });
-    }
-    throw error;
-  }
-  return app;
-}
-
 // src/lifecycle/permissionVerifier.ts
 function verifyPermissionLease(options) {
   options.lease.assert(options.permission);
@@ -1988,6 +1380,6 @@ function createUpgradeGate(options) {
   };
 }
 
-export { RUNTIME_ERROR_TYPE, RUNTIME_HELLO_TYPE, RUNTIME_PROTOCOL_VERSION, RUNTIME_RESYNC_TYPE, RUNTIME_SNAPSHOT_TYPE, RuntimeInitializationError, RuntimeUnavailableError, connectSharedWorker, createMessagePortServiceProvider, createRuntimeMessageCodec, createScopedRegistryFacade, createUpgradeGate, createWindowApp, definePlugin, defineRuntimeUnitDependencies, defineRuntimeUnitProvidedContracts, isRuntimeError, isRuntimeHello, isRuntimeResync, isRuntimeSnapshot, materializePluginDefinition, materializePluginDefinitions, runtimeCapabilityContractVersion, startSharedWorkerApp, unitSnapshotFromState, verifyPermissionLease };
+export { createMessagePortServiceProvider, createScopedRegistryFacade, createUpgradeGate, createWindowApp, definePlugin, defineRuntimeUnitDependencies, defineRuntimeUnitProvidedContracts, materializePluginDefinition, materializePluginDefinitions, runtimeCapabilityContractVersion, startSharedWorkerApp, verifyPermissionLease };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map