webloom-framework 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,1993 +1,64 @@
-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';
+export { startSharedWorkerApp } from './chunk-YOIH6H36.js';
+export { connectSharedWorker } from './chunk-RAQOFUZY.js';
+import { capabilityDescriptor } from './chunk-JHJZIO2H.js';
+export { LIFECYCLE_ERROR_TEXT, LifecycleScopeRevokedError, PermissionDeniedError, PermissionLeaseRevokedError, RESOURCE_OWNER, RESOURCE_REGISTRY, RuntimeInitializationError, RuntimeUnavailableError, SCOPED_TASK_SCHEDULER_CAPABILITY, UpgradeGateRejectedError, WebLoomError, assertCapability, capabilityDescriptor, capabilityKey, createLifecycleScope, createMessageBus, createResourceScope, createWindowApp, defineCapability, isCapability, isCapabilityDescriptor, lifecycleErrorText } from './chunk-JHJZIO2H.js';
 
-// src/contracts/plugin.ts
-function runtimeCapabilityContractVersion(capability) {
-  return `${capability}.v1`;
+// src/contracts/messageBus.ts
+var RUNTIME_MESSAGE_BUS = "webloom.messageBus";
+
+// src/authoring/definePlugin.ts
+function nonEmpty(value, label) {
+  if (value.trim() === "") throw new TypeError(`${label} must be a non-empty string`);
+  return value;
 }
-function defineRuntimeUnitDependencies(dependencies, defaults) {
+function normalizeDependencies(dependencies, runtime) {
   return dependencies.map((dependency) => ({
-    capability: dependency.capability,
-    contractVersion: runtimeCapabilityContractVersion(dependency.capability),
-    sourceRuntime: defaults.sourceRuntime,
+    capability: capabilityDescriptor(dependency.capability),
+    ...dependency.source === "peer" ? { source: "peer" } : { sourceRuntime: dependency.sourceRuntime ?? runtime },
     ...dependency.reason !== void 0 ? { reason: dependency.reason } : {},
     ...dependency.optional !== void 0 ? { optional: dependency.optional } : {}
   }));
 }
-function defineRuntimeUnitProvidedContracts(capabilities) {
-  return Object.fromEntries(
-    capabilities.map((capability) => [capability, runtimeCapabilityContractVersion(capability)])
-  );
-}
-
-// src/authoring/definePlugin.ts
-function normalizeDependency(dependency) {
-  const contractVersion = dependency.contractVersion ?? runtimeCapabilityContractVersion(dependency.capability);
-  return {
-    capability: dependency.capability,
-    contractVersion,
-    ...dependency.sourceRuntime !== void 0 ? { sourceRuntime: dependency.sourceRuntime } : {},
-    ...dependency.reason !== void 0 ? { reason: dependency.reason } : {},
-    ...dependency.optional !== void 0 ? { optional: dependency.optional } : {}
-  };
-}
 function definePlugin(options) {
-  if (!options || typeof options.id !== "string" || options.id.trim() === "") {
-    throw new Error("Plugin id must be a non-empty string");
-  }
-  if (typeof options.setup !== "function") throw new Error(`Plugin "${options.id}" setup must be a function`);
-  const unitId = options.unitId ?? options.id;
-  if (unitId.trim() === "") throw new Error(`Plugin "${options.id}" unitId must be a non-empty string`);
-  const provides = [...new Set(options.provides ?? [])];
-  const dependencies = (options.dependencies ?? []).map(normalizeDependency);
-  const providedContracts = {
-    ...defineRuntimeUnitProvidedContracts(provides),
-    ...options.providedContracts ?? {}
-  };
+  if (!options || typeof options.id !== "string") throw new TypeError("Plugin id must be a non-empty string");
+  nonEmpty(options.id, "Plugin id");
+  if (typeof options.setup !== "function") throw new TypeError(`Plugin "${options.id}" setup must be a function`);
+  const unitId = nonEmpty(options.unitId ?? options.id, `Plugin "${options.id}" unitId`);
+  const startup = options.startup ?? "optional";
+  const defaultEnabled = options.defaultEnabled ?? true;
+  const canDisable = options.canDisable ?? startup !== "required";
+  if (startup === "required" && (!defaultEnabled || canDisable)) {
+    throw new TypeError(`Plugin "${options.id}" required startup policy is inconsistent`);
+  }
+  const provides = [...options.provides ?? []];
+  const dependencies = [...options.dependencies ?? []];
+  const runtime = options.runtime;
   const descriptor = {
     id: unitId,
-    ...options.runtime !== void 0 ? { runtime: options.runtime } : {},
-    ...dependencies.length > 0 ? { dependencies } : {},
-    ...provides.length > 0 ? { provides } : {},
-    ...Object.keys(providedContracts).length > 0 ? { providedContracts } : {},
-    ...options.contribution !== void 0 ? { contribution: options.contribution } : {},
+    ...runtime !== void 0 ? { runtime } : {},
+    ...provides.length > 0 ? { provides: provides.map((capability) => capabilityDescriptor(capability)) } : {},
+    ...dependencies.length > 0 ? { dependencies: normalizeDependencies(dependencies, runtime ?? "window-main") } : {},
     ...options.permissions !== void 0 ? { permissions: [...options.permissions] } : {},
-    ...options.config !== void 0 ? { config: options.config } : {}
+    ...options.config !== void 0 ? { config: options.config } : {},
+    ...options.contribution !== void 0 ? { contribution: options.contribution } : {}
   };
-  const metaInput = options.meta ?? {};
-  const required = options.required === true || options.startup === "required" || metaInput.startup === "required";
-  const meta = {
-    ...metaInput,
-    defaultEnabled: options.defaultEnabled ?? metaInput.defaultEnabled ?? true,
-    canDisable: options.canDisable ?? metaInput.canDisable ?? !required,
-    startup: required ? "required" : options.startup ?? metaInput.startup ?? "optional"
-  };
-  if (meta.startup === "required" && (meta.canDisable || !meta.defaultEnabled)) {
-    throw new Error(`Plugin "${options.id}" required metadata is inconsistent`);
-  }
   const manifest = {
     id: options.id,
     name: options.name ?? options.id,
     ...options.description !== void 0 ? { description: options.description } : {},
-    meta,
+    startup,
+    defaultEnabled,
+    canDisable,
     units: [descriptor]
   };
   return Object.freeze({
     manifest: Object.freeze(manifest),
     descriptor: Object.freeze(descriptor),
-    setup: options.setup
+    setup: options.setup,
+    capabilities: Object.freeze([...provides, ...dependencies.map((dependency) => dependency.capability)])
   });
 }
 
-// src/runtime/pluginDefinitions.ts
-function normalizeProductDependencies(dependencies, runtime) {
-  return dependencies?.map((dependency) => ({
-    capability: dependency.capability,
-    contractVersion: dependency.contractVersion ?? runtimeCapabilityContractVersion(dependency.capability),
-    sourceRuntime: dependency.sourceRuntime ?? runtime,
-    ...dependency.reason !== void 0 ? { reason: dependency.reason } : {},
-    ...dependency.optional !== void 0 ? { optional: dependency.optional } : {}
-  }));
-}
-function materializePluginDefinition(input, runtime) {
-  const manifest = input.manifest;
-  const setup = input.setup;
-  if (!manifest || typeof manifest.id !== "string" || manifest.id.trim() === "") {
-    throw new Error("Plugin manifest id must be a non-empty string");
-  }
-  const existingUnits = manifest.units ?? [];
-  const requestedUnitId = "unitId" in input ? input.unitId : void 0;
-  const matchingUnits = existingUnits.filter((unit) => unit.runtime === void 0 || unit.runtime === runtime);
-  let implementationUnitId;
-  if (existingUnits.length === 0) {
-    implementationUnitId = manifest.id;
-  } else if (requestedUnitId !== void 0) {
-    const selected = existingUnits.find((unit) => unit.id === requestedUnitId);
-    if (!selected) throw new Error(`Plugin "${manifest.id}" does not declare unit "${requestedUnitId}"`);
-    if (selected.runtime !== void 0 && selected.runtime !== runtime) {
-      throw new Error(`Plugin "${manifest.id}" unit "${requestedUnitId}" targets ${selected.runtime}, not ${runtime}`);
-    }
-    implementationUnitId = selected.id;
-  } else if (matchingUnits.length === 1 && matchingUnits[0]) {
-    implementationUnitId = matchingUnits[0].id;
-  } else {
-    throw new Error(
-      `Plugin "${manifest.id}" has ${matchingUnits.length} implementation units for ${runtime}; specify unitId explicitly`
-    );
-  }
-  const selectedUnit = existingUnits.length > 0 ? existingUnits.find((unit) => unit.id === implementationUnitId) : void 0;
-  const units = selectedUnit ? [(() => {
-    const unitRuntime = selectedUnit.runtime ?? runtime;
-    const provides = [...selectedUnit.provides ?? []];
-    const dependencies = selectedUnit.dependencies?.map((dependency) => ({
-      capability: dependency.capability,
-      contractVersion: dependency.contractVersion ?? runtimeCapabilityContractVersion(dependency.capability),
-      sourceRuntime: dependency.sourceRuntime ?? unitRuntime,
-      ...dependency.reason !== void 0 ? { reason: dependency.reason } : {},
-      ...dependency.optional !== void 0 ? { optional: dependency.optional } : {}
-    }));
-    return {
-      ...selectedUnit,
-      runtime: unitRuntime,
-      dependencies,
-      ...provides.length > 0 ? { providedContracts: { ...defineRuntimeUnitProvidedContracts(provides), ...selectedUnit.providedContracts ?? {} } } : {}
-    };
-  })()] : [{
-    id: manifest.id,
-    runtime,
-    dependencies: normalizeProductDependencies(manifest.dependencies, runtime),
-    ...manifest.provides && manifest.provides.length > 0 ? {
-      provides: [...manifest.provides],
-      providedContracts: defineRuntimeUnitProvidedContracts(manifest.provides)
-    } : {},
-    ...manifest.permissions !== void 0 ? { permissions: [...manifest.permissions] } : {},
-    ...manifest.config !== void 0 ? { config: manifest.config } : {},
-    ...manifest.contribution !== void 0 ? { contribution: manifest.contribution } : {}
-  }];
-  const normalized = {
-    ...manifest,
-    units
-    // Product-level declarations are retained only for compatibility with
-    // low-level manifests; the selected unit is the source of truth in Host.
-  };
-  return { manifest: normalized, unitId: implementationUnitId, setup };
-}
-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 {
-    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-      return `${runtimeId}:${crypto.randomUUID()}`;
-    }
-  } catch {
-  }
-  return `${runtimeId}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function isStartupPluginError(error) {
-  return error instanceof StartupPluginError && typeof error.details?.pluginId === "string";
-}
-function buildLocalServices(host, manifests, runtimeInstanceId, revision) {
-  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: revision
-      });
-    }
-  }
-  return services;
-}
-async function createWindowApp(options) {
-  const runtimeId = options.id ?? "window-main";
-  const remoteRuntime = options.remoteRuntime;
-  const runtimeInstanceId = makeRuntimeInstanceId(runtimeId);
-  let currentState = {
-    runtimeId,
-    runtimeKind: "window-main",
-    runtimeInstanceId,
-    state: "starting",
-    snapshotRevision: 0,
-    units: [],
-    services: []
-  };
-  const listeners = /* @__PURE__ */ new Set();
-  let disposed = false;
-  let disposePromise;
-  const emit = (next) => {
-    currentState = Object.freeze({
-      ...next,
-      units: Object.freeze([...next.units]),
-      services: Object.freeze([...next.services])
-    });
-    for (const listener of [...listeners]) {
-      try {
-        listener(currentState);
-      } catch {
-      }
-    }
-  };
-  let materialized;
-  try {
-    materialized = materializePluginDefinitions(options.plugins, "window-main");
-  } catch (error) {
-    throw new RuntimeInitializationError({ phase: "validate", error: errorMessage(error) });
-  }
-  const manifests = materialized.map((item) => item.manifest);
-  let implementations;
-  try {
-    const duplicate = manifests.find((manifest, index) => manifests.findIndex((candidate) => candidate.id === manifest.id) !== index);
-    if (duplicate) throw new Error(`Plugin "${duplicate.id}" is declared more than once`);
-    implementations = createRuntimeUnitImplementationRegistry(
-      materialized.map((item) => ({
-        pluginId: item.manifest.id,
-        unitId: item.unitId,
-        setup: item.setup
-      }))
-    );
-  } catch (error) {
-    throw new RuntimeInitializationError({ phase: "validate", error: errorMessage(error) });
-  }
-  let host;
-  const suppliedHost = options.host;
-  try {
-    const {
-      id: _id,
-      plugins: _plugins,
-      host: _host,
-      remoteRuntime: _remoteRuntime,
-      ...hostOptions
-    } = options;
-    const suppliedBridgeFactory = hostOptions.serviceBridgeForPlugin;
-    host = suppliedHost ?? createPluginHost({
-      ...hostOptions,
-      runtime: "window-main",
-      externalRuntimeDependencies: remoteRuntime !== void 0 || hostOptions.externalRuntimeDependencies,
-      remoteServiceReferences: () => remoteRuntime?.state().services ?? hostOptions.remoteServiceReferences?.() ?? [],
-      runtimeSnapshots: () => remoteRuntime ? remoteRuntime.state().units.map((unit) => ({
-        pluginId: unit.pluginId,
-        unitId: unit.unitId,
-        runtime: unit.runtime,
-        ...unit.instanceId !== void 0 ? { instanceId: unit.instanceId } : {},
-        state: unit.state
-      })) : hostOptions.runtimeSnapshots?.() ?? [],
-      serviceBridgeForPlugin: (pluginId, instanceId) => suppliedBridgeFactory?.(pluginId, instanceId) ?? remoteRuntime?.serviceBridge,
-      rootAttributes: {
-        ...hostOptions.rootAttributes ?? {},
-        runtimeId,
-        runtimeInstanceId
-      },
-      runtimeUnitImplementationRegistry: implementations
-    });
-  } catch (error) {
-    throw new RuntimeInitializationError({ phase: "validate", error: errorMessage(error) });
-  }
-  let removeRemoteSubscription;
-  const manifestsForSnapshot = () => {
-    if (!suppliedHost) return manifests;
-    return suppliedHost.manifests().map((pluginId) => suppliedHost.getManifest(pluginId)).filter((manifest) => manifest !== void 0);
-  };
-  const refresh = () => {
-    const snapshotManifests = manifestsForSnapshot();
-    const units = snapshotManifests.flatMap((manifest) => {
-      const state = host.state(manifest.id);
-      return (state.units ?? []).map((unit) => unitSnapshotFromState(
-        unit,
-        unit.runtime
-      ));
-    });
-    const revision = Math.max(currentState.snapshotRevision + 1, host.version());
-    emit({
-      ...currentState,
-      snapshotRevision: revision,
-      units,
-      services: [
-        ...buildLocalServices(host, snapshotManifests, runtimeInstanceId, revision),
-        ...remoteRuntime?.state().services ?? []
-      ]
-    });
-  };
-  const removeHostSubscription = host.subscribe(refresh);
-  try {
-    if (!suppliedHost) await host.registerAll(manifests);
-    const failedRequired = suppliedHost ? void 0 : manifests.find((manifest) => {
-      const required = manifest.meta.startup === "required" || manifest.meta.canDisable === false;
-      return required && host.state(manifest.id).kind !== "enabled";
-    });
-    if (failedRequired) {
-      const state = host.state(failedRequired.id);
-      throw new StartupPluginError({
-        pluginId: failedRequired.id,
-        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(", ")}` : ""}`
-      });
-    }
-  } catch (error) {
-    refresh();
-    const pluginId = isStartupPluginError(error) ? error.details.pluginId : void 0;
-    const manifest = pluginId ? manifests.find((candidate) => candidate.id === pluginId) : void 0;
-    const required = manifest?.meta.startup === "required" || manifest?.meta.canDisable === false;
-    if (required || !isStartupPluginError(error)) {
-      removeHostSubscription();
-      removeRemoteSubscription?.();
-      await host.dispose("window runtime initialization failed").catch(() => void 0);
-      if (error instanceof RuntimeInitializationError) throw error;
-      throw new RuntimeInitializationError({
-        pluginId,
-        unitId: isStartupPluginError(error) ? error.details.unitId : manifest?.units?.[0]?.id,
-        phase: "startup",
-        error: errorMessage(error)
-      });
-    }
-  }
-  refresh();
-  emit({ ...currentState, state: "ready" });
-  removeRemoteSubscription = remoteRuntime?.subscribe(() => {
-    host.refreshRuntimeUnitSnapshots();
-    void host.reconcile().catch(() => void 0);
-  });
-  const app = {
-    runtimeKind: "window-main",
-    runtimeId,
-    runtimeInstanceId,
-    host,
-    state: () => currentState,
-    capability(capabilityId) {
-      if (disposed || currentState.state === "disposed" || currentState.state === "stopping") {
-        throw new RuntimeUnavailableError("Window Runtime has been disposed");
-      }
-      return host.capabilities.get(capabilityId);
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      listener(currentState);
-      return () => listeners.delete(listener);
-    },
-    dispose(reason = "window runtime disposed") {
-      if (disposePromise) return disposePromise;
-      disposed = true;
-      emit({ ...currentState, state: "stopping" });
-      removeHostSubscription();
-      removeRemoteSubscription?.();
-      disposePromise = host.dispose(reason).then((result) => {
-        emit({ ...currentState, state: "disposed" });
-        return result;
-      }, (error) => {
-        emit({ ...currentState, state: "failed", error: errorMessage(error) });
-        throw error;
-      });
-      return disposePromise;
-    }
-  };
-  return app;
-}
-
-// src/transport/messagePortServiceProvider.ts
-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);
-}
-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";
-}
-function errorMessage2(error) {
-  const candidate = error && typeof error === "object" ? error : void 0;
-  return {
-    ...typeof candidate?.name === "string" ? { name: candidate.name } : {},
-    message: typeof candidate?.message === "string" ? candidate.message : String(error),
-    ...typeof candidate?.code === "string" ? { code: candidate.code } : {}
-  };
-}
-function post(port, message) {
-  try {
-    port.postMessage(message);
-  } catch {
-  }
-}
-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 disposed = false;
-  const sendError = (message, error) => {
-    const response = {
-      type: codec.type("error"),
-      callId: message.callId,
-      connectionId: message.connectionId,
-      providerInstanceId: message.providerInstanceId,
-      error: errorMessage2(error)
-    };
-    post(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"));
-      }
-      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" }));
-      return;
-    }
-    if (!activeProviderInstanceIds.has(message.providerInstanceId)) {
-      sendError(message, Object.assign(new Error("Remote service provider mismatch"), { code: "service.provider_mismatch" }));
-      return;
-    }
-    if (pending.has(message.callId)) {
-      sendError(message, Object.assign(new Error("Remote service callId is duplicated"), { code: "service.duplicate_call" }));
-      return;
-    }
-    const controller = new AbortController();
-    pending.set(message.callId, { controller, providerInstanceId: message.providerInstanceId });
-    void (async () => {
-      try {
-        const result = await options.handleCall({ message, signal: controller.signal });
-        if (controller.signal.aborted || disposed) return;
-        const response = {
-          type: codec.type("result"),
-          callId: message.callId,
-          connectionId: message.connectionId,
-          providerInstanceId: message.providerInstanceId,
-          result
-        };
-        post(options.port, codec.encode(response));
-      } catch (error) {
-        if (disposed) return;
-        sendError(message, error);
-      } finally {
-        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) {
-      if (disposed) return;
-      activeProviderInstanceIds = new Set(
-        snapshot.services.map((service) => service.providerInstanceId)
-      );
-      post(options.port, codec.encode({
-        type: codec.type("snapshot"),
-        snapshot
-      }));
-    },
-    invalidate(reason = "Remote service invalidated") {
-      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
-      }));
-    },
-    disconnect(reason = "Remote service disconnected") {
-      if (disposed) return;
-      post(options.port, codec.encode({
-        type: codec.type("disconnect"),
-        reason
-      }));
-      dispose();
-    },
-    dispose
-  };
-  return provider;
-}
-
-// src/runtime/sharedWorkerHost.ts
-function makeRuntimeInstanceId2(runtimeId) {
-  try {
-    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-      return `${runtimeId}:${crypto.randomUUID()}`;
-    }
-  } catch {
-  }
-  return `${runtimeId}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-}
-function errorMessage3(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function startupDetails(error) {
-  if (error instanceof StartupPluginError) {
-    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 { 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);
-}
-function post2(port, message) {
-  try {
-    port.postMessage(message);
-  } catch {
-  }
-}
-function startSharedWorkerApp(options) {
-  if (!options || typeof options.id !== "string" || options.id.trim() === "") {
-    throw new Error("SharedWorker runtime id must be a non-empty string");
-  }
-  const workerScope = options.globalScope ?? ("onconnect" in globalThis ? globalThis : void 0);
-  if (!workerScope) {
-    throw new RuntimeInitializationError({
-      phase: "validate",
-      error: "startSharedWorkerApp must run in a SharedWorkerGlobalScope"
-    });
-  }
-  const runtimeId = options.id;
-  const runtimeInstanceId = makeRuntimeInstanceId2(runtimeId);
-  const listeners = /* @__PURE__ */ new Set();
-  const endpoints = /* @__PURE__ */ new Set();
-  const codec = createRuntimeMessageCodec();
-  let runtimeState = "starting";
-  let revision = 0;
-  let host;
-  let manifests = [];
-  let disposed = false;
-  let disposePromise;
-  const emit = () => {
-    const snapshot = currentSnapshot();
-    for (const listener of [...listeners]) {
-      try {
-        listener(snapshot);
-      } catch {
-      }
-    }
-  };
-  const currentSnapshot = () => Object.freeze({
-    runtimeId,
-    runtimeKind: "shared-worker",
-    runtimeInstanceId,
-    state: runtimeState,
-    snapshotRevision: revision,
-    units: Object.freeze(host && runtimeState !== "failed" ? manifests.flatMap((manifest) => {
-      const state = host?.state(manifest.id);
-      return (state?.units ?? []).map((unit) => ({
-        pluginId: unit.pluginId,
-        unitId: unit.unitId,
-        runtime: unit.runtime,
-        ...unit.instanceId !== void 0 ? { instanceId: unit.instanceId } : {},
-        state: unit.kind
-      }));
-    }) : []),
-    services: Object.freeze(host && runtimeState !== "failed" ? serviceReferences("", revision) : [])
-  });
-  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 } : {}
-        });
-      }
-    }
-    return services;
-  };
-  const runtimeSnapshotFor = (endpoint, baseline) => ({
-    type: RUNTIME_SNAPSHOT_TYPE,
-    protocolVersion: RUNTIME_PROTOCOL_VERSION,
-    runtimeId,
-    runtimeKind: "shared-worker",
-    runtimeInstanceId,
-    connectionId: endpoint.connectionId,
-    snapshotRevision: revision,
-    baseline,
-    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)
-  });
-  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 publishAll = (baseline = false) => {
-    for (const endpoint of [...endpoints]) publishEndpoint(endpoint, baseline);
-  };
-  const closeEndpoint = (endpoint, reason) => {
-    if (endpoint.closed) return;
-    endpoint.closed = true;
-    endpoints.delete(endpoint);
-    endpoint.removeMessage();
-    endpoint.provider.disconnect(reason);
-  };
-  const sendError = (port, code, message, details = {}) => {
-    const error = {
-      type: RUNTIME_ERROR_TYPE,
-      protocolVersion: RUNTIME_PROTOCOL_VERSION,
-      code,
-      message,
-      ...details.pluginId !== void 0 ? { pluginId: details.pluginId } : {},
-      ...details.unitId !== void 0 ? { unitId: details.unitId } : {},
-      ...details.phase !== void 0 ? { phase: details.phase } : {}
-    };
-    post2(port, error);
-  };
-  const handleCall = async (connectionId, 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) {
-      throw new Error("Runtime service reference is stale");
-    }
-    const manifest = manifests.find((candidate) => {
-      const state2 = host?.state(candidate.id);
-      return state2?.instanceId === reference.providerInstanceId;
-    });
-    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) {
-      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);
-    if (input.signal.aborted) throw input.signal.reason ?? new Error("Runtime service request cancelled");
-    const request = message.request;
-    if (typeof value === "function") return await value(request, input.signal);
-    if (value && typeof value === "object") {
-      const object = value;
-      if (typeof object.handle === "function") return await object.handle(request, input.signal);
-      if (request && typeof request === "object" && typeof request.method === "string") {
-        const method = request.method;
-        const methodValue = object[method];
-        if (typeof methodValue === "function") {
-          const args = request.args;
-          return await methodValue(...Array.isArray(args) ? args : []);
-        }
-      }
-    }
-    throw new Error(`Runtime capability "${reference.capabilityId}" does not expose an RPC handler`);
-  };
-  const attachPort = (port) => {
-    let endpoint;
-    let helloSeen = false;
-    let removeMessage = () => void 0;
-    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);
-    port.start();
-  };
-  const endpointsHasConnection = (connectionId) => [...endpoints].some((endpoint) => endpoint.connectionId === connectionId);
-  let startupError;
-  workerScope.onconnect = (event) => {
-    try {
-      options.onPortConnect?.(event);
-    } catch (error) {
-      const detail = startupDetails(error);
-      for (const port of event.ports ?? []) {
-        sendError(port, "runtime.initialization_failed", detail.message, {
-          pluginId: detail.pluginId,
-          unitId: detail.unitId,
-          phase: "handshake"
-        });
-      }
-      for (const port of event.ports ?? []) {
-        try {
-          port.close();
-        } catch {
-        }
-      }
-      return;
-    }
-    for (const port of event.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 { id: _id, plugins: _plugins, globalScope: _scope, onPortConnect: _onPortConnect, ...hostOptions } = options;
-    host = createPluginHost({
-      ...hostOptions,
-      runtime: "shared-worker",
-      rootAttributes: {
-        ...hostOptions.rootAttributes ?? {},
-        runtimeId,
-        runtimeInstanceId
-      },
-      runtimeUnitImplementationRegistry: implementations
-    });
-    host.subscribe(() => {
-      if (runtimeState !== "ready" || disposed) return;
-      revision += 1;
-      publishAll(false);
-      emit();
-    });
-    readyPromise = host.registerAll(manifests).then(() => {
-      if (disposed) return;
-      const runtimeHost = host;
-      if (!runtimeHost) throw new Error("SharedWorker Plugin Host is unavailable");
-      const failedRequired = manifests.find((manifest) => {
-        const required = manifest.meta.startup === "required" || manifest.meta.canDisable === false;
-        return required && runtimeHost.state(manifest.id).kind !== "enabled";
-      });
-      if (failedRequired) {
-        const state = runtimeHost.state(failedRequired.id);
-        throw new StartupPluginError({
-          pluginId: failedRequired.id,
-          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(", ")}` : ""}`
-        });
-      }
-      runtimeState = "ready";
-      revision = Math.max(1, revision + 1);
-      publishAll(true);
-      emit();
-    }).catch((error) => {
-      startupError = error;
-      runtimeState = "failed";
-      emit();
-      const detail = startupDetails(error);
-      for (const endpoint of [...endpoints]) {
-        sendError(endpoint.port, "runtime.initialization_failed", detail.message, {
-          pluginId: detail.pluginId,
-          unitId: detail.unitId,
-          phase: "startup"
-        });
-        closeEndpoint(endpoint, "Runtime initialization failed");
-      }
-      throw new RuntimeInitializationError({
-        pluginId: detail.pluginId,
-        unitId: detail.unitId,
-        phase: "startup",
-        error: detail.message
-      });
-    });
-  } catch (error) {
-    startupError = error;
-    runtimeState = "failed";
-    emit();
-    readyPromise = Promise.reject(error instanceof RuntimeInitializationError ? error : new RuntimeInitializationError({ phase: "validate", error: errorMessage3(error) }));
-  }
-  const app = {
-    runtimeKind: "shared-worker",
-    runtimeId,
-    runtimeInstanceId,
-    ready: () => readyPromise,
-    async reconcile() {
-      if (!host) {
-        await readyPromise;
-        return;
-      }
-      if (runtimeState === "failed" || runtimeState === "disposed" || disposed) {
-        await readyPromise;
-        return;
-      }
-      await host.reconcile();
-    },
-    state: currentSnapshot,
-    subscribe(listener) {
-      listeners.add(listener);
-      listener(currentSnapshot());
-      return () => listeners.delete(listener);
-    },
-    dispose(reason = "shared worker runtime disposed") {
-      if (disposePromise) return disposePromise;
-      disposed = true;
-      runtimeState = "stopping";
-      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 };
-        runtimeState = "disposed";
-        emit();
-        return result;
-      })();
-      return disposePromise;
-    }
-  };
-  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);
-  if (options.binding) options.lease.assertBinding(options.binding);
-}
-
-// src/lifecycle/scopedRegistry.ts
-function definitionId(value) {
-  if (!value || typeof value !== "object") return void 0;
-  const id = value.id;
-  return typeof id === "string" && id.length > 0 ? id : void 0;
-}
-function defaultRegistrationRules() {
-  return [{ method: "register", idArgument: 0, unregisterMethod: "unregister" }];
-}
-function createScopedRegistryFacade(target, scope, options) {
-  const rules = options.registrations ?? defaultRegistrationRules();
-  const byMethod = new Map(rules.map((rule) => [rule.method, rule]));
-  const unregisterMethods = new Set(
-    rules.map((rule) => rule.unregisterMethod).filter((method) => Boolean(method))
-  );
-  const ownedRegistrations = /* @__PURE__ */ new Set();
-  const objectTarget = target;
-  const remember = (rule, id, result, args) => {
-    const unregisterMethod = rule.unregisterMethod;
-    if (typeof result !== "function" && (!unregisterMethod || id === void 0)) return result;
-    const key = rule.method + ":" + (id ?? "returned");
-    let active = true;
-    let removeScopeRevoke = () => void 0;
-    let removeScopeCleanup = () => void 0;
-    const entry = {};
-    const clearOwnership = (removeDispose = true) => {
-      if (!active) return false;
-      active = false;
-      ownedRegistrations.delete(entry);
-      removeScopeRevoke();
-      if (removeDispose) removeScopeCleanup();
-      return true;
-    };
-    const invokeUnregister = (...offArgs) => {
-      if (typeof result === "function") {
-        return result.apply(target, offArgs);
-      }
-      const unregister = objectTarget[unregisterMethod];
-      if (typeof unregister !== "function") return void 0;
-      const unregisterArgument = rule.unregisterArgument ?? rule.idArgument ?? 0;
-      const unregisterArgs = [...args];
-      unregisterArgs[unregisterArgument] = id;
-      return unregister.apply(target, unregisterArgs);
-    };
-    const cleanup = async (_reason) => {
-      if (!active) {
-        if (entry.revokedCleanup) await entry.revokedCleanup;
-        return;
-      }
-      if (!clearOwnership()) return;
-      await invokeUnregister();
-    };
-    const revokeNow = (_reason) => {
-      if (!clearOwnership(false)) return;
-      try {
-        const pending = invokeUnregister();
-        if (pending && typeof pending.then === "function") {
-          const revokedCleanup = Promise.resolve(pending).then(() => void 0);
-          entry.revokedCleanup = revokedCleanup;
-          revokedCleanup.catch(() => void 0);
-        }
-      } catch (error) {
-        entry.revokedCleanup = Promise.reject(error);
-        entry.revokedCleanup.catch(() => void 0);
-      }
-    };
-    entry.id = id;
-    entry.unregisterMethod = unregisterMethod;
-    entry.revokeNow = revokeNow;
-    Object.defineProperty(entry, "active", {
-      enumerable: true,
-      configurable: false,
-      get: () => active,
-      set: (value) => {
-        active = value;
-      }
-    });
-    entry.removeScopeCleanup = removeScopeCleanup;
-    ownedRegistrations.add(entry);
-    removeScopeCleanup = scope.onDispose(
-      cleanup,
-      options.name + ":" + key,
-      "after-teardown"
-    );
-    entry.removeScopeCleanup = removeScopeCleanup;
-    removeScopeRevoke = scope.onRevoke(revokeNow);
-    if (typeof result === "function") {
-      return (...offArgs) => {
-        if (!clearOwnership()) return void 0;
-        return result.apply(target, offArgs);
-      };
-    }
-    return result;
-  };
-  return new Proxy(target, {
-    get(current, property, receiver) {
-      const value = Reflect.get(current, property, receiver);
-      if (typeof value !== "function") return value;
-      const rule = typeof property === "string" ? byMethod.get(property) : void 0;
-      if (rule) {
-        return (...args) => {
-          scope.assertActive();
-          const callArgs = [...args];
-          if (rule.bindPluginIdArgument !== void 0 && scope.identity.pluginId) {
-            const claimedPluginId = callArgs[rule.bindPluginIdArgument];
-            if (claimedPluginId !== void 0 && claimedPluginId !== scope.identity.pluginId) {
-              throw new Error(
-                'Registry owner "' + String(claimedPluginId) + '" does not match plugin instance "' + scope.identity.pluginId + '"'
-              );
-            }
-            callArgs[rule.bindPluginIdArgument] = scope.identity.pluginId;
-          }
-          if (rule.ownerPluginIdProperty && scope.identity.pluginId) {
-            const definition = callArgs[rule.idArgument ?? 0];
-            if (definition && typeof definition === "object") {
-              const claimedPluginId = definition[rule.ownerPluginIdProperty];
-              if (claimedPluginId !== void 0 && claimedPluginId !== scope.identity.pluginId) {
-                throw new Error(
-                  'Registry owner "' + String(claimedPluginId) + '" does not match plugin instance "' + scope.identity.pluginId + '"'
-                );
-              }
-            }
-          }
-          const result = value.apply(target, callArgs);
-          const id = rule.idArgument === void 0 ? void 0 : definitionId(callArgs[rule.idArgument]);
-          return remember(rule, id, result, callArgs);
-        };
-      }
-      if (typeof property === "string" && unregisterMethods.has(property)) {
-        return (...args) => {
-          scope.assertActive();
-          const id = definitionId(args[0]) ?? (typeof args[0] === "string" ? args[0] : void 0);
-          const owned = [...ownedRegistrations].find(
-            (entry) => entry.active && entry.id === id && entry.unregisterMethod === property
-          );
-          if (!owned) {
-            throw new Error(
-              'Registry resource "' + (id ?? "unknown") + '" is not owned by this plugin instance'
-            );
-          }
-          const result = value.apply(target, args);
-          owned.active = false;
-          ownedRegistrations.delete(owned);
-          owned.removeScopeCleanup();
-          return result;
-        };
-      }
-      return value.bind(target);
-    }
-  });
-}
-
-// src/lifecycle/upgradeGate.ts
-function validGeneration(value) {
-  return Number.isSafeInteger(value) && value >= 0;
-}
-function uniqueStrings(values) {
-  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
-}
-function makeSessionId() {
-  try {
-    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-      return `upgrade-session:${crypto.randomUUID()}`;
-    }
-  } catch {
-  }
-  return `upgrade-session:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-}
-function buildIsCompatible(options, buildId) {
-  try {
-    if (options.isBuildCompatible) return options.isBuildCompatible(buildId);
-  } catch {
-    return false;
-  }
-  return buildId === options.buildId || options.compatibleBuildIds?.has(buildId) === true;
-}
-function createUpgradeGate(options) {
-  if (!options.protocolVersion || !options.buildId || !options.authorityInstanceId) {
-    throw new Error("\u5347\u7EA7\u95E8\u7981\u7684 protocolVersion\u3001buildId \u548C authorityInstanceId \u5FC5\u987B\u6709\u6548");
-  }
-  if (!validGeneration(options.handoverGeneration)) {
-    throw new Error("\u5347\u7EA7\u95E8\u7981\u7684 handoverGeneration \u5FC5\u987B\u662F\u975E\u8D1F\u5B89\u5168\u6574\u6570");
-  }
-  const contractVersions = uniqueStrings(options.supportedContractVersions);
-  if (contractVersions.length === 0) {
-    throw new Error("\u5347\u7EA7\u95E8\u7981\u81F3\u5C11\u9700\u8981\u4E00\u4E2A supportedContractVersions");
-  }
-  let currentState = "active";
-  let closeReason = "upgrade gate closed";
-  const leases = /* @__PURE__ */ new Set();
-  const sessions = /* @__PURE__ */ new Set();
-  const sessionByObject = /* @__PURE__ */ new WeakMap();
-  const emptyWaiters = /* @__PURE__ */ new Set();
-  const notifyEmpty = () => {
-    if (leases.size !== 0) return;
-    for (const resolve of [...emptyWaiters]) {
-      emptyWaiters.delete(resolve);
-      resolve();
-    }
-  };
-  const removeLease = (record) => {
-    if (!leases.delete(record)) return;
-    record.session.leases.delete(record);
-    record.removeExternalAbort?.();
-    record.removeExternalAbort = void 0;
-    notifyEmpty();
-  };
-  const revokeSession = (record, reason) => {
-    if (record.revoked) return;
-    record.revoked = true;
-    record.reason = reason;
-    try {
-      record.controller.abort(new UpgradeGateRejectedError(reason));
-    } catch {
-      record.controller.abort();
-    }
-    for (const lease of [...record.leases]) revokeLease(lease, reason);
-    sessions.delete(record);
-  };
-  const revokeLease = (record, reason) => {
-    if (record.revoked) return;
-    record.revoked = true;
-    record.reason = reason;
-    try {
-      record.controller.abort(new UpgradeGateRejectedError(reason));
-    } catch {
-      record.controller.abort();
-    }
-    removeLease(record);
-  };
-  const assertAccepting = () => {
-    if (currentState === "active") return;
-    throw new UpgradeGateRejectedError(currentState === "draining" ? "draining" : "closed", closeReason);
-  };
-  const handshake = (input) => {
-    if (currentState !== "active") {
-      return { accepted: false, reason: currentState === "draining" ? "draining" : "closed" };
-    }
-    if (typeof input.connectionId !== "string" || input.connectionId.length === 0 || input.protocolVersion !== options.protocolVersion || typeof input.protocolVersion !== "string" || typeof input.buildId !== "string" || typeof input.authorityInstanceId !== "string" || input.authorityInstanceId.length === 0) {
-      return { accepted: false, reason: "protocol-mismatch" };
-    }
-    if (!buildIsCompatible(options, input.buildId)) {
-      return { accepted: false, reason: "build-incompatible" };
-    }
-    if (!validGeneration(input.handoverGeneration)) {
-      return { accepted: false, reason: "stale-generation" };
-    }
-    if (input.handoverGeneration < options.handoverGeneration) {
-      return { accepted: false, reason: "stale-generation" };
-    }
-    if (input.handoverGeneration > options.handoverGeneration) {
-      return { accepted: false, reason: "future-generation" };
-    }
-    const contractVersion = contractVersions.find((version) => input.supportedContractVersions.includes(version));
-    if (!contractVersion) return { accepted: false, reason: "contract-mismatch" };
-    const sessionRecord = {
-      sessionId: makeSessionId(),
-      connectionId: input.connectionId,
-      contractVersion,
-      controller: new AbortController(),
-      revoked: false,
-      reason: "upgrade session closed",
-      leases: /* @__PURE__ */ new Set()
-    };
-    const session = {
-      connectionId: sessionRecord.connectionId,
-      sessionId: sessionRecord.sessionId,
-      authorityInstanceId: options.authorityInstanceId,
-      handoverGeneration: options.handoverGeneration,
-      contractVersion,
-      get revoked() {
-        return sessionRecord.revoked || !sessions.has(sessionRecord);
-      },
-      signal: sessionRecord.controller.signal,
-      assertActive() {
-        if (sessionRecord.revoked || !sessions.has(sessionRecord)) {
-          throw new UpgradeGateRejectedError(sessionRecord.reason, "\u5347\u7EA7\u63E1\u624B\u4F1A\u8BDD\u5DF2\u5931\u6548");
-        }
-        if (currentState === "closed") {
-          throw new UpgradeGateRejectedError("closed", closeReason);
-        }
-      },
-      admit(input2) {
-        return admitForSession(sessionRecord, input2);
-      },
-      close(reason = "upgrade session closed") {
-        revokeSession(sessionRecord, reason);
-      }
-    };
-    sessionRecord.session = session;
-    sessions.add(sessionRecord);
-    sessionByObject.set(session, sessionRecord);
-    return {
-      accepted: true,
-      mode: options.mode ?? "cold-switch",
-      handoverGeneration: options.handoverGeneration,
-      contractVersion,
-      connectionId: sessionRecord.connectionId,
-      sessionId: sessionRecord.sessionId,
-      session
-    };
-  };
-  const admitForSession = (sessionRecord, input) => {
-    if (sessionRecord.revoked || !sessions.has(sessionRecord)) {
-      throw new UpgradeGateRejectedError(sessionRecord.reason, "\u5347\u7EA7\u63E1\u624B\u4F1A\u8BDD\u5DF2\u5931\u6548");
-    }
-    assertAccepting();
-    if (input.signal?.aborted) {
-      throw new UpgradeGateRejectedError("caller-aborted", "I/O \u5728\u53D6\u5F97\u63A5\u7BA1\u79DF\u7EA6\u524D\u5DF2\u53D6\u6D88");
-    }
-    const record = {
-      session: sessionRecord,
-      operation: input.operation,
-      controller: new AbortController(),
-      revoked: false,
-      reason: "upgrade I/O lease released"
-    };
-    leases.add(record);
-    sessionRecord.leases.add(record);
-    if (input.signal) {
-      const onAbort = () => revokeLease(record, "caller-aborted");
-      input.signal.addEventListener("abort", onAbort, { once: true });
-      record.removeExternalAbort = () => input.signal?.removeEventListener("abort", onAbort);
-    }
-    const lease = {
-      connectionId: sessionRecord.connectionId,
-      sessionId: sessionRecord.sessionId,
-      authorityInstanceId: options.authorityInstanceId,
-      handoverGeneration: options.handoverGeneration,
-      contractVersion: sessionRecord.contractVersion,
-      operation: record.operation,
-      get revoked() {
-        return record.revoked || !leases.has(record);
-      },
-      signal: record.controller.signal,
-      assertActive() {
-        if (record.revoked || !leases.has(record)) {
-          throw new UpgradeGateRejectedError(record.reason, "\u5347\u7EA7 I/O \u79DF\u7EA6\u5DF2\u5931\u6548");
-        }
-        if (currentState === "closed") {
-          throw new UpgradeGateRejectedError("closed", closeReason);
-        }
-      },
-      release() {
-        if (record.revoked) return;
-        record.revoked = true;
-        record.reason = "upgrade I/O lease released";
-        removeLease(record);
-      }
-    };
-    return lease;
-  };
-  const admit = (input) => {
-    const sessionRecord = sessionByObject.get(input.session);
-    if (!sessionRecord) {
-      throw new UpgradeGateRejectedError("invalid-session", "I/O \u5FC5\u987B\u4F7F\u7528\u5F53\u524D\u95E8\u7981\u63E1\u624B\u8FD4\u56DE\u7684\u4F1A\u8BDD");
-    }
-    return admitForSession(sessionRecord, input);
-  };
-  const beginDrain = (reason = "upgrade handover draining") => {
-    if (currentState !== "active") return;
-    closeReason = reason;
-    currentState = "draining";
-  };
-  const drain = async (timeoutMs) => {
-    beginDrain();
-    if (leases.size === 0) return { state: currentState, drained: true, pending: 0 };
-    if (timeoutMs !== void 0 && (!Number.isFinite(timeoutMs) || timeoutMs < 0)) {
-      throw new Error("\u5347\u7EA7\u6392\u7A7A timeoutMs \u5FC5\u987B\u662F\u975E\u8D1F\u6709\u9650\u6570");
-    }
-    let timeout;
-    let timerResolve;
-    const empty = new Promise((resolve) => {
-      emptyWaiters.add(resolve);
-      timerResolve = resolve;
-    });
-    const timeoutPromise = timeoutMs === void 0 ? void 0 : new Promise((resolve) => {
-      timeout = setTimeout(resolve, timeoutMs);
-    });
-    if (timeoutPromise) await Promise.race([empty, timeoutPromise]);
-    else await empty;
-    if (timeout !== void 0) clearTimeout(timeout);
-    if (timerResolve) emptyWaiters.delete(timerResolve);
-    const pending = leases.size;
-    return { state: currentState, drained: pending === 0, pending };
-  };
-  const close = (reason = "upgrade gate closed") => {
-    if (currentState === "closed") return;
-    closeReason = reason;
-    currentState = "closed";
-    for (const session of [...sessions]) revokeSession(session, reason);
-    for (const lease of [...leases]) revokeLease(lease, reason);
-    notifyEmpty();
-  };
-  return {
-    get state() {
-      return currentState;
-    },
-    mode: options.mode ?? "cold-switch",
-    authorityInstanceId: options.authorityInstanceId,
-    handoverGeneration: options.handoverGeneration,
-    handshake,
-    assertAccepting,
-    admit,
-    beginDrain,
-    drain,
-    close,
-    activeIo: () => leases.size
-  };
-}
-
-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 { RUNTIME_MESSAGE_BUS, definePlugin };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map