webloom-framework 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,16 +1,15 @@
-import { createRemoteServiceMessageCodec, UpgradeGateRejectedError } from './chunk-KGNF36DZ.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-KGNF36DZ.js';
+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';
 
 // src/contracts/plugin.ts
 function runtimeCapabilityContractVersion(capability) {
   return `${capability}.v1`;
 }
-function defineRuntimeUnitDependencies(dependencies, defaults = {}) {
+function defineRuntimeUnitDependencies(dependencies, defaults) {
   return dependencies.map((dependency) => ({
     capability: dependency.capability,
     contractVersion: runtimeCapabilityContractVersion(dependency.capability),
-    sourceExecution: defaults.sourceExecution ?? "default",
-    scope: defaults.scope ?? "root",
+    sourceRuntime: defaults.sourceRuntime,
     ...dependency.reason !== void 0 ? { reason: dependency.reason } : {},
     ...dependency.optional !== void 0 ? { optional: dependency.optional } : {}
   }));
@@ -21,6 +20,1557 @@ function defineRuntimeUnitProvidedContracts(capabilities) {
   );
 }
 
+// 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 ?? {}
+  };
+  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 } : {},
+    ...options.permissions !== void 0 ? { permissions: [...options.permissions] } : {},
+    ...options.config !== void 0 ? { config: options.config } : {}
+  };
+  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,
+    units: [descriptor]
+  };
+  return Object.freeze({
+    manifest: Object.freeze(manifest),
+    descriptor: Object.freeze(descriptor),
+    setup: options.setup
+  });
+}
+
+// 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);
@@ -438,146 +1988,6 @@ function createUpgradeGate(options) {
   };
 }
 
-// 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 errorMessage(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: errorMessage(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;
-}
-
-export { createMessagePortServiceProvider, createScopedRegistryFacade, createUpgradeGate, defineRuntimeUnitDependencies, defineRuntimeUnitProvidedContracts, runtimeCapabilityContractVersion, verifyPermissionLease };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map