webloom-framework 0.3.0 → 0.4.0

package/dist/chunk-RAQOFUZY.js

@@ -0,0 +1,1737 @@
+import { createRuntimeMessageCodec, normalizeRuntimeLimits, createRuntimeBudget, WebLoomError, validateTransferList, DEFAULT_RUNTIME_LIMITS, capabilityKey, createReceivePortLedger, RUNTIME_CALL_TYPE, RUNTIME_CANCEL_TYPE, RUNTIME_CREDIT_TYPE, RUNTIME_SNAPSHOT_TYPE, RUNTIME_ERROR_TYPE, RUNTIME_RESULT_TYPE, RUNTIME_ERROR_MESSAGE_TYPE, RUNTIME_NEXT_TYPE, RUNTIME_PROTOCOL_VERSION, validateDto, cloneFrozenAttributes, hostForWindowApp, RuntimeUnavailableError, validateRawDto, validateTransferListWithStats, assertReceivedPortSet } from './chunk-JHJZIO2H.js';
+
+// src/transport/serviceBridge.ts
+function id(prefix) {
+  try {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return `${prefix}:${crypto.randomUUID()}`;
+  } catch {
+  }
+  return `${prefix}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+}
+function timeoutMs(value, fallback) {
+  const result = value ?? fallback;
+  if (!Number.isFinite(result) || result < 1 || result > 3e5) throw new TypeError("timeoutMs must be a finite number from 1 to 300000");
+  return result;
+}
+function mergeSignals(...signals) {
+  const controller = new AbortController();
+  const active = signals.filter((signal) => signal !== void 0);
+  const listeners = active.map((signal) => {
+    const listener = () => {
+      try {
+        controller.abort(signal.reason);
+      } catch {
+        controller.abort();
+      }
+    };
+    if (signal.aborted) listener();
+    else signal.addEventListener("abort", listener, { once: true });
+    return { signal, listener };
+  });
+  return { signal: controller.signal, dispose() {
+    for (const item of listeners) item.signal.removeEventListener("abort", item.listener);
+  } };
+}
+function frameworkError(code, phase, context) {
+  const text = {
+    protocol_mismatch: "Remote Runtime protocol is not supported",
+    capability_unavailable: "Capability is unavailable",
+    request_validation_failed: "Capability request failed validation",
+    response_validation_failed: "Capability response failed validation",
+    request_clone_failed: "Capability request could not be delivered",
+    response_clone_failed: "Capability response could not be delivered",
+    transfer_invalid: "Capability transfer declaration is invalid",
+    handler_failed: "Remote capability operation failed",
+    call_timeout: "Capability call timed out; remote side effect is unknown",
+    request_cancelled: "Capability call was cancelled",
+    service_revoked: "Capability exposure was revoked",
+    service_stale: "Capability exposure is stale",
+    transport_unavailable: "Runtime transport is unavailable",
+    stream_overflow: "Stream credit or sequence is invalid",
+    resource_limit_exceeded: "Runtime resource limit exceeded",
+    invalid_snapshot: "Invalid Runtime snapshot",
+    invalid_message: "Invalid WebLoom runtime message"
+  };
+  return new WebLoomError(code, text[String(code)] ?? "WebLoom operation failed", phase, context);
+}
+function errorFromWire(message) {
+  return frameworkError(message.error.code, message.error.phase, { serviceInstanceId: message.serviceInstanceId });
+}
+function validCredit(value, maximum) {
+  return Number.isSafeInteger(value) && value >= 1 && value <= maximum;
+}
+function serviceMatches(reference, capability) {
+  return reference.kind === capability.kind && reference.capabilityId === capability.id && reference.contractVersion === capability.version;
+}
+function serviceKey(service) {
+  return `${service.kind}\0${service.capabilityId}\0${service.contractVersion}`;
+}
+function contextFor(capability, reference) {
+  return { capabilityId: capability.id, ...reference ? { serviceInstanceId: reference.serviceInstanceId } : {} };
+}
+function createCapabilityBridge(options) {
+  const codec = createRuntimeMessageCodec();
+  const limits = normalizeRuntimeLimits(options.limits);
+  const budget = options.budget ?? createRuntimeBudget(limits);
+  const listeners = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  const streams = /* @__PURE__ */ new Map();
+  const waitingCalls = /* @__PURE__ */ new Set();
+  const callbackExecutions = /* @__PURE__ */ new Set();
+  const proxies = /* @__PURE__ */ new Map();
+  const clients = /* @__PURE__ */ new Map();
+  let pendingCount = 0;
+  let peerRetainedPayloadBytes = 0;
+  let currentState = "empty";
+  let terminalFailure;
+  let remoteRuntimeId;
+  let remoteRuntimeKind;
+  let remoteRuntimeInstanceId;
+  let revision = -1;
+  let appliedSnapshotFingerprint;
+  let currentServices = [];
+  let disposed = false;
+  let reservedStreamCount = 0;
+  const defaultTimeout = timeoutMs(options.defaultCallTimeoutMs, 3e4);
+  const emit = () => {
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const reserve = (payloadBytes, stream) => {
+    if (pendingCount >= limits.maxPendingCallsPerPeer || budget.pendingCalls >= limits.maxPendingCallsPerRuntime) return frameworkError("resource_limit_exceeded", "dispatch");
+    if (stream && (reservedStreamCount >= limits.maxActiveStreamsPerPeer || budget.activeStreams >= limits.maxActiveStreamsPerRuntime)) return frameworkError("resource_limit_exceeded", "dispatch");
+    if (payloadBytes > limits.maxMessageBudgetBytes || peerRetainedPayloadBytes > limits.maxRetainedPayloadBytesPerPeer - payloadBytes || budget.retainedPayloadBytes > limits.maxRetainedPayloadBytesPerRuntime - payloadBytes) return frameworkError("resource_limit_exceeded", "dispatch");
+    budget.pendingCalls += 1;
+    if (stream) budget.activeStreams += 1;
+    peerRetainedPayloadBytes += payloadBytes;
+    budget.retainedPayloadBytes += payloadBytes;
+    pendingCount += 1;
+    if (stream) reservedStreamCount += 1;
+    return { payloadBytes, pendingReserved: true, streamReserved: stream, payloadReserved: true };
+  };
+  const releasePendingReservation = (reservation) => {
+    if (!reservation.pendingReserved) return;
+    reservation.pendingReserved = false;
+    pendingCount = Math.max(0, pendingCount - 1);
+    budget.pendingCalls = Math.max(0, budget.pendingCalls - 1);
+  };
+  const releaseStreamReservation = (reservation) => {
+    if (!reservation.streamReserved) return;
+    reservation.streamReserved = false;
+    reservedStreamCount = Math.max(0, reservedStreamCount - 1);
+    budget.activeStreams = Math.max(0, budget.activeStreams - 1);
+  };
+  const releasePayloadReservation = (reservation) => {
+    if (!reservation.payloadReserved) return;
+    reservation.payloadReserved = false;
+    peerRetainedPayloadBytes = Math.max(0, peerRetainedPayloadBytes - reservation.payloadBytes);
+    budget.retainedPayloadBytes = Math.max(0, budget.retainedPayloadBytes - reservation.payloadBytes);
+  };
+  const releaseReservation = (reservation) => {
+    releasePendingReservation(reservation);
+    releaseStreamReservation(reservation);
+    releasePayloadReservation(reservation);
+  };
+  const releaseCallbackExecution = (record) => {
+    if (record.released) return;
+    record.released = true;
+    callbackExecutions.delete(record);
+    peerRetainedPayloadBytes = Math.max(0, peerRetainedPayloadBytes - record.item.budgetBytes);
+    budget.retainedPayloadBytes = Math.max(0, budget.retainedPayloadBytes - record.item.budgetBytes);
+    budget.releaseExecutionSlot();
+    emit();
+  };
+  const releaseQueueItem = (item) => {
+    item.ledger.closeUndelivered();
+    peerRetainedPayloadBytes = Math.max(0, peerRetainedPayloadBytes - item.budgetBytes);
+    budget.retainedPayloadBytes = Math.max(0, budget.retainedPayloadBytes - item.budgetBytes);
+  };
+  const settleUnary = (entry, error, value) => {
+    if (entry.settled) return;
+    entry.settled = true;
+    if (entry.timer !== void 0) clearTimeout(entry.timer);
+    pending.delete(entry.callId);
+    releaseReservation(entry.reservation);
+    entry.cleanup?.();
+    if (error !== void 0) entry.reject(error);
+    else entry.resolve(value);
+    emit();
+  };
+  const sendCancel = (entry) => {
+    if (entry.cancelSent) return;
+    entry.cancelSent = true;
+    try {
+      options.transport.send({ type: RUNTIME_CANCEL_TYPE, protocolVersion: RUNTIME_PROTOCOL_VERSION, callId: entry.callId, serviceInstanceId: entry.reference.serviceInstanceId });
+    } catch {
+    }
+    try {
+      entry.controller.abort();
+    } catch {
+    }
+  };
+  const settleReadyReject = (stream, error) => {
+    if (stream.readySettled) return;
+    stream.readySettled = true;
+    stream.rejectReady(error);
+  };
+  const settleClosedReject = (stream, error) => {
+    if (stream.closedSettled) return;
+    stream.closedSettled = true;
+    stream.rejectClosed(error);
+  };
+  const settleClosedResolve = (stream) => {
+    if (stream.closedSettled) return;
+    stream.closedSettled = true;
+    stream.resolveClosed();
+  };
+  const forgetStream = (stream) => {
+    if (!stream.closedSettled || stream.processing || stream.queue.length > 0) return;
+    streams.delete(stream.callId);
+  };
+  const finishDraining = (stream) => {
+    if (!stream.doneReceived || stream.processing || stream.queue.length > 0 || stream.closedSettled) return;
+    stream.state = "closed";
+    settleClosedResolve(stream);
+    forgetStream(stream);
+    emit();
+  };
+  const terminateStream = (stream, error, notifyRemote) => {
+    if (stream.state === "closed" || stream.state === "failed") return;
+    stream.state = "failed";
+    if (stream.timer !== void 0) clearTimeout(stream.timer);
+    pending.delete(stream.callId);
+    stream.executionWaiterRemove?.();
+    stream.executionWaiterRemove = void 0;
+    releaseReservation(stream.reservation);
+    try {
+      stream.controller.abort(error);
+    } catch {
+    }
+    for (const item of stream.queue.splice(0)) releaseQueueItem(item);
+    if (!stream.readySettled) settleReadyReject(stream, error);
+    settleClosedReject(stream, error);
+    stream.cleanup?.();
+    if (notifyRemote) sendCancel(stream);
+    forgetStream(stream);
+    emit();
+  };
+  const errorWithTerminalCause = (cause, capability, reference) => new WebLoomError(cause.code, cause.message, cause.phase, { ...cause.context, ...contextFor(capability, reference) }, cause.details);
+  const revokeProxy = (proxy, reason, terminalCause) => {
+    if (proxy.revoked) return;
+    proxy.revoked = true;
+    proxy.reason = reason;
+    if (proxies.get(proxy.cacheKey) === proxy) clients.delete(proxy.cacheKey);
+    const affected = /* @__PURE__ */ new Set();
+    for (const entry of pending.values()) if (entry.proxy === proxy) affected.add(entry);
+    for (const entry of streams.values()) if (entry.proxy === proxy) affected.add(entry);
+    for (const entry of affected) {
+      if (entry.proxy !== proxy) continue;
+      const error = terminalCause ? errorWithTerminalCause(terminalCause, entry.capability, entry.reference) : frameworkError("service_revoked", "dispose", contextFor(entry.capability, entry.reference));
+      if (entry.mode === "stream") terminateStream(entry, error, true);
+      else {
+        settleUnary(entry, error);
+        sendCancel(entry);
+      }
+    }
+    for (const record of [...waitingCalls]) {
+      if (record.proxy === proxy) record.fail(terminalCause ? errorWithTerminalCause(terminalCause, record.proxy.capability, record.proxy.bound) : frameworkError("service_revoked", "dispose", contextFor(record.proxy.capability, record.proxy.bound)));
+    }
+  };
+  const findService = (capability) => currentServices.find((service) => serviceMatches(service, capability));
+  const terminalError = (proxy, capability) => {
+    if (terminalFailure && !disposed) return frameworkError(terminalFailure.code, terminalFailure.phase, contextFor(capability, proxy.bound));
+    if (disposed || proxy.revoked) return frameworkError("service_revoked", "dispatch", contextFor(capability, proxy.bound));
+    if (currentState === "stale" || currentState === "disposed") return frameworkError("service_revoked", "dispatch", contextFor(capability, proxy.bound));
+    if (proxy.bound && !currentServices.some((service) => serviceKey(service) === serviceKey(proxy.bound) && service.serviceInstanceId === proxy.bound?.serviceInstanceId)) {
+      return frameworkError("service_stale", "dispatch", contextFor(capability, proxy.bound));
+    }
+    if (currentState === "ready" && !proxy.bound && !findService(capability)) {
+      return frameworkError("capability_unavailable", "wait", contextFor(capability));
+    }
+    return void 0;
+  };
+  const prepareRequest = (capability, request) => {
+    validateRawDto(request, limits, "validate");
+    const parser = capability;
+    let parsed;
+    try {
+      parsed = parser.request.parse(request);
+    } catch {
+      throw frameworkError("request_validation_failed", "validate", contextFor(capability));
+    }
+    let validation;
+    try {
+      const descriptor = capability.transfer;
+      validation = validateTransferListWithStats(parsed, descriptor?.request?.(parsed), { limits, phase: "validate" });
+    } catch (error) {
+      if (error instanceof WebLoomError) throw error;
+      throw frameworkError("transfer_invalid", "validate", contextFor(capability));
+    }
+    return { value: parsed, transfer: validation.transfer, budgetBytes: validation.stats.budgetBytes };
+  };
+  const prepareIncoming = (capability, value, direction, ledger) => {
+    try {
+      validateRawDto(value, limits, "receive");
+    } catch (error) {
+      ledger.closeUndelivered();
+      throw error;
+    }
+    const parser = capability;
+    let parsed;
+    try {
+      const selected = direction === "response" ? parser.response : parser.item;
+      if (!selected) throw new Error("parser unavailable");
+      parsed = selected.parse(value);
+    } catch {
+      ledger.closeUndelivered();
+      throw frameworkError("response_validation_failed", "receive", contextFor(capability));
+    }
+    let validation;
+    try {
+      validation = validateTransferListWithStats(parsed, parser.transfer?.[direction]?.(parsed), { limits, phase: "receive" });
+    } catch (error) {
+      ledger.closeUndelivered();
+      throw error instanceof WebLoomError ? error : frameworkError("transfer_invalid", "receive", contextFor(capability));
+    }
+    try {
+      assertReceivedPortSet(ledger, validation.transfer, { limits, phase: "receive" });
+    } catch (error) {
+      ledger.closeUndelivered();
+      throw error;
+    }
+    return { value: parsed, transfer: validation.transfer, stats: validation.stats };
+  };
+  const sendWire = (message, transfer = []) => {
+    const encoded = codec.encode(message);
+    options.transport.send(encoded, transfer);
+  };
+  const startUnary = (proxy, prepared, reference, callOptions, timeout, existingReservation) => {
+    const reservation = existingReservation ?? reserve(prepared.budgetBytes, false);
+    if (reservation instanceof WebLoomError) return Promise.reject(reservation);
+    const controller = new AbortController();
+    const merged = mergeSignals(controller.signal, proxy.scope?.signal, callOptions.signal);
+    const callId = id("call");
+    return new Promise((resolve, reject) => {
+      const entry = { callId, capability: proxy.capability, reference, proxy, controller, cleanup: merged.dispose, reservation, timer: void 0, settled: false, cancelSent: false, mode: "unary", resolve, reject };
+      pending.set(callId, entry);
+      const onAbort = () => {
+        if (entry.settled) return;
+        settleUnary(entry, frameworkError("request_cancelled", "dispose", contextFor(entry.capability, reference)));
+        sendCancel(entry);
+      };
+      merged.signal.addEventListener("abort", onAbort, { once: true });
+      entry.timer = setTimeout(() => {
+        if (entry.settled) return;
+        settleUnary(entry, frameworkError("call_timeout", "receive", contextFor(entry.capability, reference)));
+        sendCancel(entry);
+      }, timeout);
+      if (merged.signal.aborted) {
+        onAbort();
+        return;
+      }
+      try {
+        sendWire({ type: RUNTIME_CALL_TYPE, protocolVersion: RUNTIME_PROTOCOL_VERSION, callId, capabilityId: entry.capability.id, contractVersion: entry.capability.version, serviceInstanceId: reference.serviceInstanceId, mode: "unary", timeoutMs: timeout, request: prepared.value, ...callOptions.operationId !== void 0 ? { operationId: callOptions.operationId } : {} }, prepared.transfer);
+      } catch {
+        settleUnary(entry, frameworkError("request_clone_failed", "dispatch", contextFor(entry.capability, reference)));
+      }
+    });
+  };
+  const waitForService = (proxy, prepared, callOptions) => {
+    const timeout = timeoutMs(callOptions.timeoutMs, defaultTimeout);
+    const deadline = Date.now() + timeout;
+    const reserved = reserve(prepared.budgetBytes, false);
+    if (reserved instanceof WebLoomError) return Promise.reject(reserved);
+    return new Promise((resolve, reject) => {
+      const record = {
+        proxy,
+        prepared,
+        reservation: reserved,
+        deadline,
+        mode: "unary",
+        finished: false,
+        fail: () => void 0,
+        start: () => void 0
+      };
+      const cleanup = () => {
+        if (record.timer !== void 0) clearTimeout(record.timer);
+        record.removeListener?.();
+        callOptions.signal?.removeEventListener("abort", onAbort);
+        waitingCalls.delete(record);
+      };
+      record.fail = (error) => {
+        if (record.finished) return;
+        record.finished = true;
+        cleanup();
+        releaseReservation(record.reservation);
+        reject(error);
+      };
+      record.start = (reference, remaining) => {
+        if (record.finished) return;
+        record.finished = true;
+        cleanup();
+        if (!proxy.bound) proxy.bound = reference;
+        void startUnary(proxy, prepared, reference, callOptions, remaining, record.reservation).then(resolve, reject);
+      };
+      const check = () => {
+        if (record.finished) return;
+        const unavailable = terminalError(proxy, proxy.capability);
+        if (unavailable) {
+          record.fail(unavailable);
+          return;
+        }
+        const reference = proxy.bound ?? findService(proxy.capability);
+        if (!reference) return;
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+          record.fail(frameworkError("call_timeout", "wait", contextFor(proxy.capability)));
+          return;
+        }
+        record.start(reference, remaining);
+      };
+      const onAbort = () => record.fail(frameworkError("request_cancelled", "dispose", contextFor(proxy.capability)));
+      record.timer = setTimeout(() => record.fail(frameworkError("call_timeout", "wait", contextFor(proxy.capability))), timeout);
+      if (callOptions.signal) {
+        if (callOptions.signal.aborted) {
+          onAbort();
+          return;
+        }
+        callOptions.signal.addEventListener("abort", onAbort, { once: true });
+      }
+      listeners.add(check);
+      record.removeListener = () => listeners.delete(check);
+      waitingCalls.add(record);
+      check();
+    });
+  };
+  const call = (proxy, request, callOptions) => {
+    const unavailable = terminalError(proxy, proxy.capability);
+    if (unavailable) return Promise.reject(unavailable);
+    const timeout = timeoutMs(callOptions.timeoutMs, defaultTimeout);
+    let prepared;
+    try {
+      prepared = prepareRequest(proxy.capability, request);
+    } catch (error) {
+      return Promise.reject(error instanceof WebLoomError ? error : frameworkError("request_validation_failed", "validate", contextFor(proxy.capability)));
+    }
+    const reference = proxy.bound ?? findService(proxy.capability);
+    if (!reference) return waitForService(proxy, prepared, callOptions);
+    if (!proxy.bound) proxy.bound = reference;
+    return startUnary(proxy, prepared, reference, callOptions, timeout);
+  };
+  const createRejectedSubscription = (error) => {
+    let readyReject;
+    let closedReject;
+    const ready = new Promise((_, reject) => {
+      readyReject = reject;
+    });
+    const closed = new Promise((_, reject) => {
+      closedReject = reject;
+    });
+    void ready.catch(() => void 0);
+    void closed.catch(() => void 0);
+    readyReject(error);
+    closedReject(error);
+    return { ready, closed, cancel() {
+    } };
+  };
+  const startStream = (proxy, prepared, reference, optionsForSubscribe, timeout, existingReservation) => {
+    const maximumCredit = Math.min(256, limits.maxStreamCredit);
+    const window = optionsForSubscribe.initialCredit ?? 16;
+    if (!validCredit(window, maximumCredit)) {
+      if (existingReservation) releaseReservation(existingReservation);
+      return createRejectedSubscription(frameworkError("stream_overflow", "validate", contextFor(proxy.capability, reference)));
+    }
+    const reservation = existingReservation ?? reserve(prepared.budgetBytes, true);
+    if (reservation instanceof WebLoomError) return createRejectedSubscription(reservation);
+    let resolveReady;
+    let rejectReady;
+    let resolveClosed;
+    let rejectClosed;
+    const ready = new Promise((resolve, reject) => {
+      resolveReady = resolve;
+      rejectReady = reject;
+    });
+    const closed = new Promise((resolve, reject) => {
+      resolveClosed = resolve;
+      rejectClosed = reject;
+    });
+    void ready.catch(() => void 0);
+    void closed.catch(() => void 0);
+    const controller = new AbortController();
+    const merged = mergeSignals(controller.signal, proxy.scope?.signal, optionsForSubscribe.signal);
+    const callId = id("stream");
+    const entry = {
+      callId,
+      capability: proxy.capability,
+      reference,
+      proxy,
+      controller,
+      cleanup: merged.dispose,
+      reservation,
+      timer: void 0,
+      settled: false,
+      cancelSent: false,
+      mode: "stream",
+      onNext: optionsForSubscribe.onNext,
+      itemParser: proxy.capability.item,
+      window,
+      credit: window,
+      sequence: 1,
+      state: "opening",
+      doneReceived: false,
+      processing: false,
+      draining: false,
+      readySettled: false,
+      closedSettled: false,
+      queue: [],
+      resolveReady,
+      rejectReady,
+      resolveClosed,
+      rejectClosed
+    };
+    streams.set(callId, entry);
+    pending.set(callId, entry);
+    const cancel = () => {
+      if (entry.state === "closed" || entry.state === "failed") return;
+      terminateStream(entry, frameworkError("request_cancelled", "dispose", contextFor(entry.capability, reference)), true);
+    };
+    merged.signal.addEventListener("abort", cancel, { once: true });
+    entry.timer = setTimeout(() => {
+      if (entry.state !== "opening") return;
+      terminateStream(entry, frameworkError("call_timeout", "wait", contextFor(entry.capability, reference)), true);
+    }, timeout);
+    if (merged.signal.aborted) {
+      cancel();
+      return { ready, closed, cancel };
+    }
+    try {
+      sendWire({ type: RUNTIME_CALL_TYPE, protocolVersion: RUNTIME_PROTOCOL_VERSION, callId, capabilityId: entry.capability.id, contractVersion: entry.capability.version, serviceInstanceId: reference.serviceInstanceId, mode: "stream", timeoutMs: timeout, request: prepared.value, initialCredit: window, ...optionsForSubscribe.operationId !== void 0 ? { operationId: optionsForSubscribe.operationId } : {} }, prepared.transfer);
+    } catch {
+      terminateStream(entry, frameworkError("request_clone_failed", "dispatch", contextFor(entry.capability, reference)), false);
+    }
+    return { ready, closed, cancel };
+  };
+  const waitForStream = (proxy, prepared, optionsForSubscribe) => {
+    const timeout = timeoutMs(optionsForSubscribe.timeoutMs, defaultTimeout);
+    const deadline = Date.now() + timeout;
+    const reserved = reserve(prepared.budgetBytes, true);
+    if (reserved instanceof WebLoomError) return createRejectedSubscription(reserved);
+    let resolveReady;
+    let rejectReady;
+    let resolveClosed;
+    let rejectClosed;
+    const ready = new Promise((resolve, reject) => {
+      resolveReady = resolve;
+      rejectReady = reject;
+    });
+    const closed = new Promise((resolve, reject) => {
+      resolveClosed = resolve;
+      rejectClosed = reject;
+    });
+    void ready.catch(() => void 0);
+    void closed.catch(() => void 0);
+    let active;
+    const record = {
+      proxy,
+      prepared,
+      reservation: reserved,
+      deadline,
+      mode: "stream",
+      finished: false,
+      fail: () => void 0,
+      start: () => void 0
+    };
+    const cleanup = () => {
+      if (record.timer !== void 0) clearTimeout(record.timer);
+      record.removeListener?.();
+      optionsForSubscribe.signal?.removeEventListener("abort", onAbort);
+      waitingCalls.delete(record);
+    };
+    record.fail = (error) => {
+      if (record.finished) return;
+      record.finished = true;
+      cleanup();
+      releaseReservation(record.reservation);
+      rejectReady(error);
+      rejectClosed(error);
+    };
+    record.start = (reference, remaining) => {
+      if (record.finished) return;
+      record.finished = true;
+      cleanup();
+      if (!proxy.bound) proxy.bound = reference;
+      active = startStream(proxy, prepared, reference, optionsForSubscribe, remaining, record.reservation);
+      active.ready.then(resolveReady, rejectReady);
+      active.closed.then(resolveClosed, rejectClosed);
+    };
+    const onAbort = () => record.fail(frameworkError("request_cancelled", "dispose", contextFor(proxy.capability)));
+    const check = () => {
+      if (record.finished) return;
+      const unavailable = terminalError(proxy, proxy.capability);
+      if (unavailable) {
+        record.fail(unavailable);
+        return;
+      }
+      const reference = proxy.bound ?? findService(proxy.capability);
+      if (!reference) return;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        record.fail(frameworkError("call_timeout", "wait", contextFor(proxy.capability)));
+        return;
+      }
+      record.start(reference, remaining);
+    };
+    record.timer = setTimeout(() => record.fail(frameworkError("call_timeout", "wait", contextFor(proxy.capability))), timeout);
+    if (optionsForSubscribe.signal) {
+      if (optionsForSubscribe.signal.aborted) {
+        onAbort();
+        return { ready, closed, cancel() {
+        } };
+      }
+      optionsForSubscribe.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    listeners.add(check);
+    record.removeListener = () => listeners.delete(check);
+    waitingCalls.add(record);
+    check();
+    return { ready, closed, cancel(reason = "stream cancelled") {
+      if (active) active.cancel(reason);
+      else record.fail(frameworkError("request_cancelled", "dispose", contextFor(proxy.capability)));
+    } };
+  };
+  const subscribe = (proxy, request, optionsForSubscribe) => {
+    const unavailable = terminalError(proxy, proxy.capability);
+    if (unavailable) return createRejectedSubscription(unavailable);
+    if (typeof optionsForSubscribe.onNext !== "function") return createRejectedSubscription(frameworkError("request_validation_failed", "validate", contextFor(proxy.capability)));
+    let prepared;
+    try {
+      prepared = prepareRequest(proxy.capability, request);
+    } catch (error) {
+      return createRejectedSubscription(error instanceof WebLoomError ? error : frameworkError("request_validation_failed", "validate", contextFor(proxy.capability)));
+    }
+    const reference = proxy.bound ?? findService(proxy.capability);
+    if (!reference) return waitForStream(proxy, prepared, optionsForSubscribe);
+    if (!proxy.bound) proxy.bound = reference;
+    return startStream(proxy, prepared, reference, optionsForSubscribe, timeoutMs(optionsForSubscribe.timeoutMs, defaultTimeout));
+  };
+  let drainStream;
+  const waitForExecutionSlot = (stream) => {
+    if (stream.executionWaiterRemove || stream.state === "failed" || stream.state === "closed" || stream.queue.length === 0) return;
+    stream.executionWaiterRemove = budget.registerExecutionWaiter(() => {
+      stream.executionWaiterRemove = void 0;
+      drainStream(stream);
+    });
+  };
+  drainStream = (stream) => {
+    if (stream.draining) return;
+    stream.draining = true;
+    void (async () => {
+      try {
+        while (stream.queue.length > 0) {
+          if (stream.state === "failed" || stream.state === "closed") break;
+          const item = stream.queue.shift();
+          if (!item) break;
+          if (callbackExecutions.size >= limits.maxExecutionSlotsPerPeer || budget.executionSlots >= limits.maxExecutionSlotsPerRuntime) {
+            stream.queue.unshift(item);
+            waitForExecutionSlot(stream);
+            break;
+          }
+          stream.executionWaiterRemove?.();
+          stream.executionWaiterRemove = void 0;
+          const execution = { stream, item, released: false };
+          callbackExecutions.add(execution);
+          budget.executionSlots += 1;
+          stream.processing = true;
+          try {
+            item.ledger.handoff();
+            await stream.onNext(item.value);
+            if (stream.state === "active" && !stream.doneReceived) {
+              stream.credit += 1;
+              try {
+                sendWire({ type: RUNTIME_CREDIT_TYPE, protocolVersion: RUNTIME_PROTOCOL_VERSION, callId: stream.callId, serviceInstanceId: stream.reference.serviceInstanceId, count: 1 });
+              } catch {
+                terminateStream(stream, frameworkError("transport_unavailable", "dispatch", contextFor(stream.capability, stream.reference)), true);
+                break;
+              }
+            }
+          } catch {
+            terminateStream(stream, frameworkError("handler_failed", "execute", contextFor(stream.capability, stream.reference)), true);
+            break;
+          } finally {
+            stream.processing = false;
+            releaseCallbackExecution(execution);
+          }
+        }
+      } finally {
+        stream.processing = false;
+        stream.draining = false;
+        if (stream.queue.length === 0 || stream.state === "failed" || stream.state === "closed") {
+          stream.executionWaiterRemove?.();
+          stream.executionWaiterRemove = void 0;
+        } else {
+          waitForExecutionSlot(stream);
+        }
+        finishDraining(stream);
+        forgetStream(stream);
+      }
+    })().catch(() => {
+      terminateStream(stream, frameworkError("handler_failed", "execute", contextFor(stream.capability, stream.reference)), true);
+    });
+  };
+  const invalidate = (reason = "remote service directory replaced", terminalCause) => {
+    if (terminalCause) {
+      for (const record of [...waitingCalls]) record.fail(errorWithTerminalCause(terminalCause, record.proxy.capability, record.proxy.bound));
+      for (const entry of [...pending.values()]) {
+        const error = errorWithTerminalCause(terminalCause, entry.capability, entry.reference);
+        if (entry.mode === "stream") terminateStream(entry, error, true);
+        else settleUnary(entry, error);
+      }
+    }
+    for (const proxy of proxies.values()) revokeProxy(proxy, reason, terminalCause);
+    if (!terminalCause) for (const record of [...waitingCalls]) record.fail(frameworkError("service_stale", "dispose", contextFor(record.proxy.capability, record.proxy.bound)));
+    clients.clear();
+    if (!terminalCause) for (const entry of [...pending.values()]) {
+      if (entry.mode === "stream") terminateStream(entry, frameworkError("service_stale", "dispose", contextFor(entry.capability, entry.reference)), true);
+      else settleUnary(entry, frameworkError("service_stale", "dispose", contextFor(entry.capability, entry.reference)));
+    }
+    currentServices = [];
+    currentState = disposed ? "disposed" : "stale";
+    emit();
+  };
+  const failClose = (reason, code = "invalid_message") => {
+    if (disposed) return;
+    terminalFailure = frameworkError(code, "receive");
+    invalidate(reason, terminalFailure);
+    try {
+      options.transport.close?.();
+    } catch {
+    }
+  };
+  const onMessage = (message, metadata) => {
+    const ledger = metadata?.ledger ?? createReceivePortLedger(metadata?.ports, { limits, phase: "receive" });
+    if (!ledger.valid) {
+      failClose("Invalid received transfer metadata", "transfer_invalid");
+      return;
+    }
+    try {
+      if (!metadata?.decoded) {
+        message = codec.decode(message);
+      }
+    } catch (error) {
+      ledger.closeUndelivered();
+      if (error instanceof WebLoomError && error.code === "protocol_mismatch") {
+        failClose("Remote Runtime protocol mismatch", "protocol_mismatch");
+      } else if (error instanceof WebLoomError && error.code === "invalid_snapshot") {
+        failClose("Invalid WebLoom runtime message", "invalid_snapshot");
+      } else failClose("Invalid WebLoom runtime message", "invalid_message");
+      return;
+    }
+    try {
+      if (message.type === RUNTIME_CALL_TYPE || message.type === RUNTIME_CANCEL_TYPE || message.type === RUNTIME_CREDIT_TYPE) return;
+      if (message.type === RUNTIME_SNAPSHOT_TYPE) {
+        if (ledger.ports.length > 0) throw frameworkError("transfer_invalid", "receive");
+        const result = applySnapshot(message);
+        if (!result.accepted && result.reason === "protocol-mismatch") failClose("Remote Runtime protocol mismatch", "protocol_mismatch");
+        else if (!result.accepted && result.reason === "invalid-snapshot") failClose("Invalid Runtime snapshot", "invalid_snapshot");
+        return;
+      }
+      if (message.type === RUNTIME_ERROR_TYPE) {
+        ledger.closeUndelivered();
+        invalidate(message.message);
+        return;
+      }
+      if (message.type === RUNTIME_RESULT_TYPE) {
+        const entry = pending.get(message.callId);
+        if (!entry || entry.reference.serviceInstanceId !== message.serviceInstanceId) {
+          ledger.closeUndelivered();
+          return;
+        }
+        if (entry.mode === "unary") {
+          if (!("result" in message)) {
+            ledger.closeUndelivered();
+            settleUnary(entry, frameworkError("invalid_message", "receive", contextFor(entry.capability, entry.reference)));
+            return;
+          }
+          try {
+            const incoming = prepareIncoming(entry.capability, message.result, "response", ledger);
+            ledger.handoff();
+            settleUnary(entry, void 0, incoming.value);
+          } catch (error) {
+            settleUnary(entry, error instanceof WebLoomError ? error : frameworkError("response_validation_failed", "receive", contextFor(entry.capability, entry.reference)));
+          }
+          return;
+        }
+        const stream = entry;
+        if ("streamReady" in message && message.streamReady) {
+          if (stream.state !== "opening") {
+            ledger.closeUndelivered();
+            terminateStream(stream, frameworkError("invalid_message", "receive", contextFor(stream.capability, stream.reference)), true);
+            return;
+          }
+          if (ledger.ports.length > 0) {
+            ledger.closeUndelivered();
+            terminateStream(stream, frameworkError("transfer_invalid", "receive", contextFor(stream.capability, stream.reference)), true);
+            return;
+          }
+          stream.state = "active";
+          stream.readySettled = true;
+          if (stream.timer !== void 0) clearTimeout(stream.timer);
+          releasePendingReservation(stream.reservation);
+          stream.resolveReady();
+          emit();
+          return;
+        }
+        if ("done" in message && message.done) {
+          if (stream.state !== "active" || stream.doneReceived) {
+            ledger.closeUndelivered();
+            terminateStream(stream, frameworkError("invalid_message", "receive", contextFor(stream.capability, stream.reference)), true);
+            return;
+          }
+          if (ledger.ports.length > 0) {
+            ledger.closeUndelivered();
+            terminateStream(stream, frameworkError("transfer_invalid", "receive", contextFor(stream.capability, stream.reference)), true);
+            return;
+          }
+          stream.doneReceived = true;
+          stream.state = "draining";
+          pending.delete(stream.callId);
+          releaseStreamReservation(stream.reservation);
+          releasePayloadReservation(stream.reservation);
+          stream.cleanup?.();
+          finishDraining(stream);
+          drainStream(stream);
+          emit();
+          return;
+        }
+        ledger.closeUndelivered();
+        terminateStream(stream, frameworkError("invalid_message", "receive", contextFor(stream.capability, stream.reference)), true);
+        return;
+      }
+      if (message.type === RUNTIME_ERROR_MESSAGE_TYPE) {
+        const entry = pending.get(message.callId);
+        if (!entry || entry.reference.serviceInstanceId !== message.serviceInstanceId) {
+          ledger.closeUndelivered();
+          return;
+        }
+        ledger.closeUndelivered();
+        const error = errorFromWire(message);
+        if (entry.mode === "stream") terminateStream(entry, error, false);
+        else settleUnary(entry, error);
+        return;
+      }
+      if (message.type === RUNTIME_NEXT_TYPE) {
+        const entry = pending.get(message.callId);
+        if (!entry || entry.mode !== "stream" || entry.reference.serviceInstanceId !== message.serviceInstanceId) {
+          ledger.closeUndelivered();
+          return;
+        }
+        const stream = entry;
+        if (stream.state !== "active" || stream.doneReceived) {
+          ledger.closeUndelivered();
+          terminateStream(stream, frameworkError("invalid_message", "receive", contextFor(stream.capability, stream.reference)), true);
+          return;
+        }
+        if (stream.credit < 1) {
+          ledger.closeUndelivered();
+          terminateStream(stream, frameworkError("stream_overflow", "receive", contextFor(stream.capability, stream.reference)), true);
+          return;
+        }
+        if (message.sequence !== stream.sequence) {
+          ledger.closeUndelivered();
+          terminateStream(stream, frameworkError("stream_overflow", "receive", contextFor(stream.capability, stream.reference)), true);
+          return;
+        }
+        let incoming;
+        try {
+          incoming = prepareIncoming(stream.capability, message.item, "item", ledger);
+        } catch (error) {
+          terminateStream(stream, error instanceof WebLoomError ? error : frameworkError("response_validation_failed", "receive", contextFor(stream.capability, stream.reference)), true);
+          return;
+        }
+        const { value, stats } = incoming;
+        if (peerRetainedPayloadBytes > limits.maxRetainedPayloadBytesPerPeer - stats.budgetBytes || budget.retainedPayloadBytes > limits.maxRetainedPayloadBytesPerRuntime - stats.budgetBytes || stream.queue.length >= stream.window) {
+          ledger.closeUndelivered();
+          terminateStream(stream, frameworkError("resource_limit_exceeded", "receive", contextFor(stream.capability, stream.reference)), true);
+          return;
+        }
+        stream.credit -= 1;
+        stream.sequence += 1;
+        stream.queue.push({ value, ledger, budgetBytes: stats.budgetBytes });
+        peerRetainedPayloadBytes += stats.budgetBytes;
+        budget.retainedPayloadBytes += stats.budgetBytes;
+        drainStream(stream);
+        return;
+      }
+      ledger.closeUndelivered();
+    } catch (error) {
+      ledger.closeUndelivered();
+      if (error instanceof WebLoomError && error.code === "protocol_mismatch") failClose("Remote Runtime protocol mismatch", "protocol_mismatch");
+      else if (error instanceof WebLoomError && error.code === "invalid_snapshot") failClose("Invalid WebLoom runtime message", "invalid_snapshot");
+      else if (error instanceof WebLoomError && error.code === "transfer_invalid") failClose("Invalid WebLoom runtime message", "transfer_invalid");
+      else failClose("Invalid WebLoom runtime message", "invalid_message");
+    }
+  };
+  const removeTransport = options.transport.subscribe((message, metadata) => onMessage(message, metadata));
+  const removeTransportError = options.transport.subscribeError?.((error, metadata) => {
+    metadata?.ledger?.closeUndelivered();
+    if (error instanceof WebLoomError && error.code === "protocol_mismatch") failClose("Remote Runtime protocol mismatch", "protocol_mismatch");
+    else if (error instanceof WebLoomError && error.code === "transfer_invalid") failClose("Invalid received transfer metadata", "transfer_invalid");
+    else failClose("Invalid WebLoom runtime message", "invalid_message");
+  });
+  function applySnapshot(snapshot) {
+    if (disposed) return { accepted: false, reason: "disposed" };
+    if (!snapshot || typeof snapshot !== "object") return { accepted: false, reason: "invalid-snapshot" };
+    if (snapshot.protocolVersion !== RUNTIME_PROTOCOL_VERSION) return { accepted: false, reason: "protocol-mismatch" };
+    try {
+      if (snapshot.units.length > limits.maxSnapshotUnits || snapshot.services.length > limits.maxSnapshotServices) return { accepted: false, reason: "invalid-snapshot" };
+      codec.encode({ ...snapshot, type: RUNTIME_SNAPSHOT_TYPE });
+      validateDto(snapshot, { limits: { maxDepth: limits.maxDtoDepth, maxNodes: limits.maxDtoNodes, maxEdges: limits.maxDtoEdges, maxBudgetBytes: limits.maxMessageBudgetBytes }, phase: "receive" });
+    } catch {
+      return { accepted: false, reason: "invalid-snapshot" };
+    }
+    if (options.remoteRuntimeId !== void 0 && snapshot.runtimeId !== options.remoteRuntimeId) return { accepted: false, reason: "invalid-snapshot" };
+    if (options.remoteRuntimeKind !== void 0 && snapshot.runtimeKind !== options.remoteRuntimeKind) return { accepted: false, reason: "invalid-snapshot" };
+    if (remoteRuntimeId !== void 0 && snapshot.runtimeId !== remoteRuntimeId) return { accepted: false, reason: "invalid-snapshot" };
+    if (remoteRuntimeKind !== void 0 && snapshot.runtimeKind !== remoteRuntimeKind) return { accepted: false, reason: "invalid-snapshot" };
+    let fingerprint;
+    try {
+      fingerprint = JSON.stringify(snapshot);
+    } catch {
+      return { accepted: false, reason: "invalid-snapshot" };
+    }
+    if (remoteRuntimeInstanceId !== void 0 && remoteRuntimeInstanceId === snapshot.runtimeInstanceId && snapshot.revision <= revision) {
+      if (snapshot.revision === revision && fingerprint === appliedSnapshotFingerprint) return { accepted: true, state: currentState === "disposed" ? "stale" : currentState, revision };
+      return { accepted: false, reason: "stale-revision", receivedRevision: snapshot.revision };
+    }
+    const services = [];
+    const keys = /* @__PURE__ */ new Set();
+    try {
+      for (const service of snapshot.state === "ready" ? snapshot.services : []) {
+        const key = serviceKey(service);
+        if (keys.has(key)) return { accepted: false, reason: "invalid-snapshot" };
+        keys.add(key);
+        services.push(Object.freeze({ kind: service.kind, capabilityId: service.capabilityId, contractVersion: service.contractVersion, runtime: snapshot.runtimeKind, runtimeInstanceId: snapshot.runtimeInstanceId, serviceInstanceId: service.serviceInstanceId, attributes: cloneFrozenAttributes(service.attributes), ...service.grantId !== void 0 ? { grantId: service.grantId } : {}, ...service.authorizationRevision !== void 0 ? { authorizationRevision: service.authorizationRevision } : {} }));
+      }
+    } catch {
+      return { accepted: false, reason: "invalid-snapshot" };
+    }
+    const newRuntime = remoteRuntimeInstanceId !== void 0 && remoteRuntimeInstanceId !== snapshot.runtimeInstanceId;
+    const replaced = !newRuntime && remoteRuntimeInstanceId === snapshot.runtimeInstanceId && currentServices.some((current) => {
+      const next = services.find((service) => serviceKey(service) === serviceKey(current));
+      return next !== void 0 && next.serviceInstanceId !== current.serviceInstanceId;
+    });
+    if (newRuntime || replaced) invalidate(newRuntime ? "Remote Runtime instance changed" : "Remote Runtime service exposure replaced");
+    if (!newRuntime && !replaced) {
+      for (const proxy of proxies.values()) {
+        if (proxy.bound && !services.some((service) => serviceKey(service) === serviceKey(proxy.bound) && service.serviceInstanceId === proxy.bound?.serviceInstanceId)) {
+          revokeProxy(proxy, "Remote Runtime service exposure was removed");
+        }
+      }
+    }
+    remoteRuntimeId = snapshot.runtimeId;
+    remoteRuntimeKind = snapshot.runtimeKind;
+    remoteRuntimeInstanceId = snapshot.runtimeInstanceId;
+    revision = snapshot.revision;
+    appliedSnapshotFingerprint = fingerprint;
+    currentServices = Object.freeze(services);
+    currentState = snapshot.state === "ready" ? "ready" : snapshot.state === "starting" ? "empty" : snapshot.state === "disposed" ? "disposed" : "stale";
+    if (currentState !== "ready" && snapshot.state !== "starting") for (const proxy of proxies.values()) revokeProxy(proxy, `Remote Runtime is ${snapshot.state}`);
+    emit();
+    return { accepted: true, state: currentState === "disposed" ? "stale" : currentState, revision };
+  }
+  const bridge = {
+    get state() {
+      return currentState;
+    },
+    get runtimeInstanceId() {
+      return remoteRuntimeInstanceId;
+    },
+    get runtimeKind() {
+      return remoteRuntimeKind;
+    },
+    getClient(capability, scope) {
+      const key = `${capability.kind}\0${capability.id}\0${capability.version}\0${scope?.identity.scopeId ?? "root"}`;
+      let proxy = proxies.get(key);
+      if (!proxy || proxy.revoked) {
+        proxy = { capability, scope, cacheKey: key, revoked: false, reason: "Capability proxy is revoked" };
+        proxies.set(key, proxy);
+        scope?.onRevoke((reason) => revokeProxy(proxy, reason));
+      }
+      const cached = clients.get(key);
+      if (cached && !proxy.revoked) return cached;
+      const client = capability.kind === "rpc" ? { call: (request, optionsForCall) => call(proxy, request, optionsForCall ?? {}) } : { subscribe: (request, optionsForSubscribe) => subscribe(proxy, request, optionsForSubscribe) };
+      clients.set(key, client);
+      return client;
+    },
+    applySnapshot,
+    invalidate,
+    disconnect(reason = "Runtime disconnected") {
+      invalidate(reason);
+      currentState = "stale";
+    },
+    dispose(reason = "Runtime bridge disposed") {
+      if (disposed) return;
+      disposed = true;
+      invalidate(reason);
+      removeTransport();
+      removeTransportError?.();
+      options.transport.close?.();
+      currentState = "disposed";
+      emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    services() {
+      return currentServices;
+    },
+    get pendingCallCount() {
+      return pendingCount;
+    },
+    get activeStreamCount() {
+      return [...streams.values()].filter((entry) => entry.state === "opening" || entry.state === "active").length;
+    },
+    get retainedPayloadBytes() {
+      return budget.retainedPayloadBytes;
+    }
+  };
+  return bridge;
+}
+function validateTransferables(value, transfer, limits) {
+  return validateTransferList(value, transfer, { limits: limits ?? DEFAULT_RUNTIME_LIMITS, phase: "validate" });
+}
+
+// src/transport/messagePortServiceTransport.ts
+function createMessagePortRuntimeTransport(port, options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const errorListeners = /* @__PURE__ */ new Set();
+  const codec = createRuntimeMessageCodec();
+  const limits = normalizeRuntimeLimits(options.limits);
+  const onMessage = (event) => {
+    const ledger = createReceivePortLedger(event.ports ?? [], { limits, phase: "receive" });
+    const metadata = Object.freeze({
+      ports: ledger.ports,
+      ledger,
+      decoded: true
+    });
+    if (!ledger.valid) {
+      const error = new WebLoomError("transfer_invalid", "Invalid received transfer metadata", "receive");
+      for (const listener of [...errorListeners]) {
+        try {
+          listener(error, metadata);
+        } catch {
+        }
+      }
+      return;
+    }
+    let message;
+    try {
+      message = codec.decode(event.data);
+    } catch (error) {
+      ledger.closeUndelivered();
+      for (const listener of [...errorListeners]) {
+        try {
+          listener(error, metadata);
+        } catch {
+        }
+      }
+      return;
+    }
+    for (const listener of [...listeners]) {
+      try {
+        listener(message, metadata);
+      } catch {
+      }
+    }
+  };
+  port.addEventListener("message", onMessage);
+  port.start?.();
+  let closed = false;
+  return {
+    send(message, transfer) {
+      if (closed) throw new Error("MessagePort transport is closed");
+      port.postMessage(message, transfer);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    subscribeError(listener) {
+      errorListeners.add(listener);
+      return () => errorListeners.delete(listener);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      port.removeEventListener("message", onMessage);
+      port.close?.();
+      listeners.clear();
+      errorListeners.clear();
+    }
+  };
+}
+
+// src/transport/messagePortServiceProvider.ts
+function safeErrorCode(error, fallback) {
+  return error instanceof WebLoomError ? error.code : fallback;
+}
+function post(transport, codec, message, transfer = []) {
+  try {
+    transport.send(codec.encode(message), transfer);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function safeErrorMessage(code) {
+  const messages = {
+    capability_unavailable: "Capability is unavailable",
+    permission_denied: "Capability authorization denied",
+    service_stale: "Runtime service exposure is stale",
+    request_validation_failed: "Capability request failed validation",
+    response_validation_failed: "Capability response failed validation",
+    request_clone_failed: "Capability request could not be delivered",
+    response_clone_failed: "Capability response could not be delivered",
+    transfer_invalid: "Capability transfer declaration is invalid",
+    handler_failed: "Remote capability operation failed",
+    call_timeout: "Capability call timed out",
+    request_cancelled: "Capability call was cancelled",
+    service_revoked: "Capability exposure was revoked",
+    transport_unavailable: "Runtime transport is unavailable",
+    stream_overflow: "Stream credit or sequence is invalid",
+    resource_limit_exceeded: "Runtime resource limit exceeded",
+    invalid_message: "Invalid WebLoom runtime message"
+  };
+  return messages[code] ?? "Remote capability operation failed";
+}
+function createMessagePortServiceProvider(options) {
+  const codec = createRuntimeMessageCodec();
+  const limits = normalizeRuntimeLimits(options.limits);
+  const budget = options.budget ?? createRuntimeBudget(limits);
+  const configuredTransport = options.transport ?? (options.port ? createMessagePortRuntimeTransport(options.port, { limits }) : void 0);
+  if (!configuredTransport) throw new TypeError("MessagePort service provider requires transport or port");
+  const transport = configuredTransport;
+  const activeCalls = /* @__PURE__ */ new Map();
+  const streams = /* @__PURE__ */ new Map();
+  const executionSlots = /* @__PURE__ */ new Map();
+  let peerRetainedPayloadBytes = 0;
+  let disposed = false;
+  const serviceFor = (message) => options.services().find((service) => service.kind === (message.mode === "stream" ? "stream" : "rpc") && service.capabilityId === message.capabilityId && service.contractVersion === message.contractVersion && service.serviceInstanceId === message.serviceInstanceId);
+  const serviceErrorCode = (message) => {
+    const visibleContract = options.services().some((service) => service.kind === (message.mode === "stream" ? "stream" : "rpc") && service.capabilityId === message.capabilityId && service.contractVersion === message.contractVersion);
+    return visibleContract ? "service_stale" : "capability_unavailable";
+  };
+  const sendError = (call, code, phase) => {
+    post(transport, codec, {
+      type: RUNTIME_ERROR_MESSAGE_TYPE,
+      protocolVersion: RUNTIME_PROTOCOL_VERSION,
+      callId: call.callId,
+      serviceInstanceId: call.serviceInstanceId,
+      error: { code, message: safeErrorMessage(code), phase }
+    });
+  };
+  const releaseExecution = (active) => {
+    if (active.executionReleased) return;
+    active.executionReleased = true;
+    if (executionSlots.get(active.call.callId) === active) executionSlots.delete(active.call.callId);
+    budget.releaseExecutionSlot();
+    peerRetainedPayloadBytes = Math.max(0, peerRetainedPayloadBytes - active.requestBytes);
+    budget.retainedPayloadBytes = Math.max(0, budget.retainedPayloadBytes - active.requestBytes);
+    active.removePeerRevoke?.();
+    active.removePeerRevoke = void 0;
+  };
+  const releaseStreamReservation = (active) => {
+    if (!active.streamReserved) return;
+    active.streamReserved = false;
+    budget.activeStreams = Math.max(0, budget.activeStreams - 1);
+  };
+  const releasePending = (active) => {
+    if (!active.pending) return;
+    active.pending = false;
+    if (activeCalls.get(active.call.callId) === active) activeCalls.delete(active.call.callId);
+    if (active.deadlineTimer !== void 0) {
+      clearTimeout(active.deadlineTimer);
+      active.deadlineTimer = void 0;
+    }
+    budget.pendingCalls = Math.max(0, budget.pendingCalls - 1);
+  };
+  const finishPending = (active) => {
+    releasePending(active);
+  };
+  const maybeReleaseStreamExecution = (stream) => {
+    if (stream.pumpDone && stream.returnDone) releaseExecution(stream.active);
+  };
+  const returnIterator = (stream) => {
+    if (stream.returnStarted) return;
+    stream.returnStarted = true;
+    const candidate = stream.iterator?.return;
+    if (!candidate) {
+      stream.returnDone = true;
+      maybeReleaseStreamExecution(stream);
+      return;
+    }
+    let result;
+    try {
+      result = candidate.call(stream.iterator);
+    } catch {
+      stream.returnDone = true;
+      maybeReleaseStreamExecution(stream);
+      return;
+    }
+    void Promise.resolve(result).then(() => {
+      stream.returnDone = true;
+      maybeReleaseStreamExecution(stream);
+    }, () => {
+      stream.returnDone = true;
+      maybeReleaseStreamExecution(stream);
+    });
+  };
+  const closeStream = (stream, normalDone = false) => {
+    if (stream.closed) return;
+    stream.closed = true;
+    stream.active.cancelled = true;
+    finishPending(stream.active);
+    streams.delete(stream.call.callId);
+    releaseStreamReservation(stream.active);
+    if (normalDone) {
+      stream.iteratorDone = true;
+      stream.returnDone = true;
+      maybeReleaseStreamExecution(stream);
+    } else {
+      if (!stream.running) stream.pumpDone = true;
+      returnIterator(stream);
+      maybeReleaseStreamExecution(stream);
+    }
+  };
+  const closeLateIterable = async (value) => {
+    try {
+      if (!value || typeof value[Symbol.asyncIterator] !== "function") return;
+      const iterator = value[Symbol.asyncIterator]();
+      const close = iterator.return;
+      if (close) await Promise.resolve(close.call(iterator));
+    } catch {
+    }
+  };
+  const cancelActive = (active, errorCode = "request_cancelled") => {
+    if (active.cancelled) return;
+    active.frameworkSettled = true;
+    active.cancelled = true;
+    try {
+      active.controller.abort();
+    } catch {
+    }
+    const stream = streams.get(active.call.callId);
+    if (stream) closeStream(stream);
+    else finishPending(active);
+  };
+  const reserve = (requestBytes, stream) => {
+    if (activeCalls.size >= limits.maxPendingCallsPerPeer || budget.pendingCalls >= limits.maxPendingCallsPerRuntime) return new WebLoomError("resource_limit_exceeded", safeErrorMessage("resource_limit_exceeded"), "dispatch");
+    if (executionSlots.size >= limits.maxExecutionSlotsPerPeer || budget.executionSlots >= limits.maxExecutionSlotsPerRuntime) return new WebLoomError("resource_limit_exceeded", safeErrorMessage("resource_limit_exceeded"), "dispatch");
+    if (stream && (streams.size >= limits.maxActiveStreamsPerPeer || budget.activeStreams >= limits.maxActiveStreamsPerRuntime)) return new WebLoomError("resource_limit_exceeded", safeErrorMessage("resource_limit_exceeded"), "dispatch");
+    if (requestBytes > limits.maxMessageBudgetBytes || peerRetainedPayloadBytes > limits.maxRetainedPayloadBytesPerPeer - requestBytes || budget.retainedPayloadBytes > limits.maxRetainedPayloadBytesPerRuntime - requestBytes) return new WebLoomError("resource_limit_exceeded", safeErrorMessage("resource_limit_exceeded"), "dispatch");
+    budget.pendingCalls += 1;
+    if (stream) budget.activeStreams += 1;
+    budget.executionSlots += 1;
+    peerRetainedPayloadBytes += requestBytes;
+    budget.retainedPayloadBytes += requestBytes;
+    return void 0;
+  };
+  const prepareRequest = (call, ledger) => {
+    try {
+      validateRawDto(call.request, limits, "receive");
+    } catch (error) {
+      ledger.closeUndelivered();
+      throw error;
+    }
+    let prepared;
+    try {
+      prepared = options.prepareRequest?.(call, ledger) ?? { value: call.request };
+    } catch (error) {
+      ledger.closeUndelivered();
+      throw error;
+    }
+    let transfer;
+    try {
+      transfer = validateTransferList(prepared.value, prepared.transfer, { limits, phase: "receive" });
+    } catch (error) {
+      ledger.closeUndelivered();
+      throw error;
+    }
+    try {
+      assertReceivedPortSet(ledger, transfer, { limits, phase: "receive" });
+    } catch (error) {
+      ledger.closeUndelivered();
+      throw error;
+    }
+    const stats = validateDto(prepared.value, { limits: { maxDepth: limits.maxDtoDepth, maxNodes: limits.maxDtoNodes, maxEdges: limits.maxDtoEdges, maxBudgetBytes: limits.maxMessageBudgetBytes }, transferables: new Set(transfer), phase: "receive" });
+    return { value: prepared.value, budgetBytes: stats.budgetBytes };
+  };
+  const prepareOutput = (prepared, ledger) => {
+    try {
+      const transfer = validateTransferList(prepared.value, prepared.transfer, { limits, phase: "receive" });
+      if (ledger) ;
+      validateDto(prepared.value, { limits: { maxDepth: limits.maxDtoDepth, maxNodes: limits.maxDtoNodes, maxEdges: limits.maxDtoEdges, maxBudgetBytes: limits.maxMessageBudgetBytes }, transferables: new Set(transfer), phase: "receive" });
+      return { value: prepared.value, transfer };
+    } catch (error) {
+      throw error;
+    }
+  };
+  const pump = async (entry) => {
+    if (entry.running || entry.closed || !entry.iterator) return;
+    entry.running = true;
+    try {
+      while (!entry.closed && !entry.active.cancelled && entry.credit > 0) {
+        let next;
+        try {
+          next = await entry.iterator.next();
+        } catch (error) {
+          if (!entry.closed && !entry.active.cancelled) sendError(entry.call, safeErrorCode(error, "handler_failed"), "execute");
+          closeStream(entry);
+          break;
+        }
+        if (entry.closed || entry.active.cancelled) break;
+        if (next.done) {
+          entry.iteratorDone = true;
+          if (post(transport, codec, { type: RUNTIME_RESULT_TYPE, protocolVersion: RUNTIME_PROTOCOL_VERSION, callId: entry.call.callId, serviceInstanceId: entry.reference.serviceInstanceId, done: true })) closeStream(entry, true);
+          else {
+            sendError(entry.call, "transport_unavailable", "receive");
+            closeStream(entry, true);
+          }
+          break;
+        }
+        try {
+          const prepared = options.prepareItem?.(next.value, entry.call) ?? { value: next.value };
+          const output = prepareOutput(prepared);
+          if (!post(transport, codec, { type: RUNTIME_NEXT_TYPE, protocolVersion: RUNTIME_PROTOCOL_VERSION, callId: entry.call.callId, serviceInstanceId: entry.reference.serviceInstanceId, sequence: entry.sequence, item: output.value }, output.transfer)) {
+            sendError(entry.call, "response_clone_failed", "receive");
+            closeStream(entry);
+            break;
+          }
+          entry.credit -= 1;
+          entry.sequence += 1;
+        } catch (error) {
+          if (!entry.closed && !entry.active.cancelled) sendError(entry.call, safeErrorCode(error, "response_validation_failed"), "receive");
+          closeStream(entry);
+          break;
+        }
+      }
+    } finally {
+      entry.running = false;
+      entry.pumpDone = true;
+      maybeReleaseStreamExecution(entry);
+    }
+  };
+  const onMessage = (message, metadata) => {
+    const ledger = metadata?.ledger ?? createReceivePortLedger(metadata?.ports, { limits, phase: "receive" });
+    if (!ledger.valid) {
+      failClose();
+      return;
+    }
+    if (message.type === RUNTIME_CANCEL_TYPE) {
+      ledger.closeUndelivered();
+      const active2 = activeCalls.get(message.callId) ?? streams.get(message.callId)?.active;
+      if (!active2 || active2.reference.serviceInstanceId !== message.serviceInstanceId) return;
+      cancelActive(active2);
+      return;
+    }
+    if (message.type === RUNTIME_CREDIT_TYPE) {
+      ledger.closeUndelivered();
+      const stream = streams.get(message.callId);
+      const valid = stream !== void 0 && stream.reference.serviceInstanceId === message.serviceInstanceId && Number.isSafeInteger(message.count) && message.count >= 1 && message.count <= limits.maxStreamCredit && stream.credit + message.count <= stream.window;
+      if (!valid) {
+        if (stream && !stream.active.cancelled) sendError(stream.call, "stream_overflow", "receive");
+        if (stream) closeStream(stream);
+        return;
+      }
+      stream.credit += message.count;
+      void pump(stream);
+      return;
+    }
+    if (message.type !== RUNTIME_CALL_TYPE) return;
+    const reference = serviceFor(message);
+    if (!reference) {
+      ledger.closeUndelivered();
+      sendError(message, serviceErrorCode(message), "dispatch");
+      return;
+    }
+    if (activeCalls.has(message.callId) || executionSlots.has(message.callId)) {
+      ledger.closeUndelivered();
+      sendError(message, "invalid_message", "dispatch");
+      return;
+    }
+    if (message.grantId !== void 0 && message.grantId !== reference.grantId) {
+      ledger.closeUndelivered();
+      sendError(message, "permission_denied", "dispatch");
+      return;
+    }
+    const initialCredit = message.initialCredit;
+    if (message.mode === "stream" && (!Number.isSafeInteger(initialCredit) || initialCredit < 1 || initialCredit > limits.maxStreamCredit)) {
+      ledger.closeUndelivered();
+      sendError(message, "stream_overflow", "validate");
+      return;
+    }
+    let request;
+    try {
+      request = prepareRequest(message, ledger);
+    } catch (error) {
+      sendError(message, safeErrorCode(error, "request_validation_failed"), error instanceof WebLoomError ? error.phase : "receive");
+      return;
+    }
+    const quotaError = reserve(request.budgetBytes, message.mode === "stream");
+    if (quotaError) {
+      ledger.closeUndelivered();
+      sendError(message, quotaError.code, "dispatch");
+      return;
+    }
+    ledger.handoff();
+    const controller = new AbortController();
+    const active = { call: { ...message, request: request.value }, controller, reference, requestBytes: request.budgetBytes, deadlineAt: Date.now() + message.timeoutMs, pending: true, streamReserved: message.mode === "stream", cancelled: false, frameworkSettled: false, executionReleased: false };
+    activeCalls.set(message.callId, active);
+    executionSlots.set(message.callId, active);
+    if (options.peerScope) active.removePeerRevoke = options.peerScope.onRevoke(() => cancelActive(active, "service_revoked"));
+    active.deadlineTimer = setTimeout(() => cancelActive(active, "call_timeout"), message.timeoutMs);
+    const callPeer = options.peerForCall?.(active.call, reference) ?? options.peer;
+    void (async () => {
+      let stream;
+      try {
+        if (active.cancelled || disposed) {
+          releaseExecution(active);
+          return;
+        }
+        const result = await options.handleCall({ message: active.call, request: request.value, reference, signal: controller.signal, deadlineAt: active.deadlineAt, peer: callPeer });
+        if (active.cancelled || disposed || executionSlots.get(message.callId) !== active) {
+          if (message.mode === "stream") await closeLateIterable(result);
+          releaseExecution(active);
+          return;
+        }
+        if (message.mode === "unary") {
+          try {
+            const output = prepareOutput(options.prepareResult?.(result, active.call) ?? { value: result });
+            if (!active.cancelled && !post(transport, codec, { type: RUNTIME_RESULT_TYPE, protocolVersion: RUNTIME_PROTOCOL_VERSION, callId: message.callId, serviceInstanceId: reference.serviceInstanceId, result: output.value }, output.transfer)) sendError(message, "response_clone_failed", "receive");
+          } catch (error) {
+            if (!active.cancelled) sendError(message, safeErrorCode(error, "response_validation_failed"), "receive");
+          }
+          finishPending(active);
+          releaseExecution(active);
+          return;
+        }
+        if (!result || typeof result[Symbol.asyncIterator] !== "function") throw new WebLoomError("handler_failed", "Stream handler did not return AsyncIterable", "execute");
+        const iterator = result[Symbol.asyncIterator]();
+        stream = { active, call: active.call, controller, reference, window: message.initialCredit ?? 16, iterator, credit: message.initialCredit ?? 16, sequence: 1, running: false, closed: false, iteratorDone: false, returnStarted: false, returnDone: false, pumpDone: false };
+        streams.set(message.callId, stream);
+        if (!post(transport, codec, { type: RUNTIME_RESULT_TYPE, protocolVersion: RUNTIME_PROTOCOL_VERSION, callId: message.callId, serviceInstanceId: reference.serviceInstanceId, streamReady: true })) {
+          sendError(message, "transport_unavailable", "dispatch");
+          closeStream(stream);
+          return;
+        }
+        releasePending(active);
+        void pump(stream);
+      } catch (error) {
+        if (!active.cancelled && !disposed) sendError(message, safeErrorCode(error, "handler_failed"), error instanceof WebLoomError ? error.phase : "execute");
+        if (stream) closeStream(stream);
+        else {
+          finishPending(active);
+          releaseExecution(active);
+        }
+      }
+    })().catch(() => {
+      const lateStream = streams.get(active.call.callId);
+      if (lateStream) closeStream(lateStream);
+      else {
+        finishPending(active);
+        releaseExecution(active);
+      }
+    });
+  };
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    for (const active of [...activeCalls.values()]) cancelActive(active, "service_revoked");
+    for (const stream of [...streams.values()]) closeStream(stream);
+    removeTransport();
+  }
+  function failClose() {
+    dispose();
+    try {
+      transport.close?.();
+    } catch {
+    }
+  }
+  const removeTransport = transport.subscribe(onMessage);
+  return {
+    setServices() {
+    },
+    dispose,
+    pendingCount() {
+      return activeCalls.size;
+    },
+    executionCount() {
+      return executionSlots.size;
+    },
+    nonCooperativeExecutionCount() {
+      return [...executionSlots.values()].filter((active) => active.frameworkSettled).length;
+    },
+    retainedPayloadBytes() {
+      return budget.retainedPayloadBytes;
+    }
+  };
+}
+
+// src/runtime/peerView.ts
+function createPeerScopeView(scope) {
+  return Object.freeze({
+    get state() {
+      return scope.state;
+    },
+    signal: scope.signal,
+    onRevoke(listener) {
+      return scope.onRevoke(listener);
+    }
+  });
+}
+function createCapabilityPeerView(options) {
+  const allowed = options.allowed === void 0 ? void 0 : new Set(options.allowed.map((descriptor) => capabilityKey(descriptor)));
+  return Object.freeze({
+    peerId: options.peerId,
+    get runtime() {
+      return options.bridge.runtimeKind;
+    },
+    get runtimeInstanceId() {
+      return options.bridge.runtimeInstanceId;
+    },
+    scope: options.scope,
+    capability(capability) {
+      if (allowed && !allowed.has(capabilityKey(capability))) {
+        throw new WebLoomError("capability_unavailable", "Capability is unavailable", "dispatch", { capabilityId: capability.id });
+      }
+      return options.bridge.getClient(capability, options.capabilityScope);
+    }
+  });
+}
+
+// src/runtime/connectSharedWorker.ts
+var handleBridges = /* @__PURE__ */ new WeakMap();
+function makeWorker(options) {
+  const workerOptions = { type: "module", ...options.name !== void 0 ? { name: options.name } : {}, ...options.credentials !== void 0 ? { credentials: options.credentials } : {} };
+  if (options.workerFactory) return options.workerFactory(options.url, workerOptions);
+  const WorkerConstructor = globalThis.SharedWorker;
+  if (!WorkerConstructor) throw new RuntimeUnavailableError("SharedWorker is not supported by this browser");
+  return new WorkerConstructor(options.url, workerOptions);
+}
+function snapshotForClient(app, runtimeId, runtimeInstanceId, exposed, revision) {
+  const allowed = new Set(exposed.map((capability) => capabilityKey(capability)));
+  const state = app.state();
+  const runtimeState = state.state === "disconnected" ? "failed" : state.state;
+  return {
+    type: RUNTIME_SNAPSHOT_TYPE,
+    protocolVersion: RUNTIME_PROTOCOL_VERSION,
+    runtimeId,
+    runtimeKind: "window-main",
+    runtimeInstanceId,
+    revision,
+    state: runtimeState,
+    units: state.units,
+    services: runtimeState === "ready" ? state.services.filter((service) => allowed.has(capabilityKey({ kind: service.kind, id: service.capabilityId, version: service.contractVersion }))).map((service) => ({ kind: service.kind, capabilityId: service.capabilityId, contractVersion: service.contractVersion, serviceInstanceId: service.serviceInstanceId, attributes: cloneFrozenAttributes(service.attributes), ...service.grantId !== void 0 ? { grantId: service.grantId } : {}, ...service.authorizationRevision !== void 0 ? { authorizationRevision: service.authorizationRevision } : {} })) : []
+  };
+}
+function connectInternal(options) {
+  if (!options || typeof options.id !== "string" || options.id.trim() === "") throw new TypeError("SharedWorker runtime id must be a non-empty string");
+  const requestedClientHost = options.client ? hostForWindowApp(options.client.app) : void 0;
+  const exposed = options.client?.expose ?? [];
+  for (const capability of exposed) {
+    if (capability.kind !== "rpc" && capability.kind !== "stream") throw new TypeError(`Capability "${capability.id ?? "unknown"}" is not remotely exposable`);
+    if (!requestedClientHost?.capabilities.registration(capability)) throw new TypeError(`Capability "${capability.id}" is not registered by the WindowApp`);
+  }
+  const worker = makeWorker(options);
+  const port = worker.port;
+  if (!port) throw new RuntimeUnavailableError("SharedWorker did not expose a MessagePort");
+  const limits = normalizeRuntimeLimits(options.limits);
+  const transport = createMessagePortRuntimeTransport({
+    addEventListener(type, listener) {
+      port.addEventListener(type, listener);
+    },
+    removeEventListener(type, listener) {
+      port.removeEventListener(type, listener);
+    },
+    postMessage(messageValue, transfer) {
+      port.postMessage(messageValue, transfer ? [...transfer] : void 0);
+    },
+    start() {
+      port.start();
+    },
+    close() {
+      try {
+        port.close();
+      } catch {
+      }
+    }
+  }, { limits });
+  const outboundBudget = createRuntimeBudget(limits);
+  const inboundBudget = createRuntimeBudget(limits);
+  const bridge = createCapabilityBridge({ transport, remoteRuntimeKind: "shared-worker", remoteRuntimeId: options.id, defaultCallTimeoutMs: options.defaultCallTimeoutMs, limits, budget: outboundBudget });
+  const listeners = /* @__PURE__ */ new Set();
+  const workerInstanceId = { value: "" };
+  const localRuntimeInstanceId = options.client?.app.runtimeInstanceId ?? `window:${Date.now().toString(36)}`;
+  let revision = 0;
+  let disposed = false;
+  let current = Object.freeze({ protocolVersion: RUNTIME_PROTOCOL_VERSION, runtimeId: options.id, runtimeKind: "shared-worker", runtimeInstanceId: "", state: "starting", revision: 0, units: [], services: [] });
+  const clientHost = requestedClientHost;
+  const clientPeerScope = options.client && clientHost ? clientHost.rootScope.child("peer", { attributes: { peerId: `peer:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}` } }) : void 0;
+  const clientPeerScopeView = clientPeerScope ? createPeerScopeView(clientPeerScope) : void 0;
+  const clientPeer = clientPeerScope && clientPeerScopeView ? createCapabilityPeerView({
+    peerId: clientPeerScope.identity.attributes.peerId,
+    scope: clientPeerScopeView,
+    bridge,
+    capabilityScope: clientPeerScope
+  }) : void 0;
+  const provider = options.client && clientHost ? createMessagePortServiceProvider({
+    transport,
+    peerScope: clientPeerScope,
+    peer: clientPeer,
+    budget: inboundBudget,
+    limits,
+    services: () => clientHost.serviceReferences().filter((service) => exposed.some((capability) => capabilityKey(capability) === capabilityKey({ kind: service.kind, id: service.capabilityId, version: service.contractVersion }))),
+    peerForCall: (_call, reference) => {
+      const registration = clientHost.capabilities.registration({ kind: reference.kind, id: reference.capabilityId, version: reference.contractVersion });
+      return clientPeerScope && clientPeerScopeView ? createCapabilityPeerView({
+        peerId: clientPeerScope.identity.attributes.peerId,
+        scope: clientPeerScopeView,
+        bridge,
+        allowed: registration?.peerDependencies ?? [],
+        capabilityScope: clientPeerScope
+      }) : void 0;
+    },
+    prepareRequest: (call) => {
+      const registration = clientHost.capabilities.registration({ kind: call.mode === "stream" ? "stream" : "rpc", id: call.capabilityId, version: call.contractVersion });
+      if (!registration || registration.capability.kind !== (call.mode === "stream" ? "stream" : "rpc")) throw new WebLoomError("service_stale", "Window service exposure is stale", "dispatch");
+      const capability = registration.capability;
+      let value;
+      try {
+        value = capability.request.parse(call.request);
+      } catch {
+        throw new WebLoomError("request_validation_failed", "Capability request failed validation", "receive");
+      }
+      return { value, transfer: capability.transfer?.request?.(value) };
+    },
+    handleCall: async ({ request, reference, signal, deadlineAt, peer }) => {
+      const registration = clientHost.capabilities.registration({ kind: reference.kind, id: reference.capabilityId, version: reference.contractVersion });
+      if (!registration) throw new WebLoomError("service_stale", "Window exposure is no longer available", "dispatch");
+      const handler = registration.handler;
+      if (!handler) throw new WebLoomError("service_stale", "Window service handler is unavailable", "dispatch");
+      return handler(request, { signal, deadlineAt, reference, origin: "remote", peer });
+    },
+    prepareResult: (value, call) => {
+      const registration = clientHost.capabilities.registration({ kind: "rpc", id: call.capabilityId, version: call.contractVersion });
+      if (!registration || registration.capability.kind !== "rpc") throw new Error("Window RPC registration disappeared");
+      const rpc = registration.capability;
+      const parsed = rpc.response.parse(value);
+      return { value: parsed, transfer: rpc.transfer?.response?.(parsed) };
+    },
+    prepareItem: (value, call) => {
+      const registration = clientHost.capabilities.registration({ kind: "stream", id: call.capabilityId, version: call.contractVersion });
+      if (!registration || registration.capability.kind !== "stream") throw new Error("Window stream registration disappeared");
+      const stream = registration.capability;
+      const parsed = stream.item.parse(value);
+      return { value: parsed, transfer: stream.transfer?.item?.(parsed) };
+    }
+  }) : void 0;
+  const emit = (next) => {
+    current = Object.freeze({ ...next, units: Object.freeze([...next.units]), services: Object.freeze([...next.services]) });
+    for (const listener of [...listeners]) {
+      try {
+        listener(current);
+      } catch {
+      }
+    }
+  };
+  const sendClientSnapshot = () => {
+    if (!options.client || disposed) return;
+    revision += 1;
+    try {
+      transport.send(snapshotForClient(options.client.app, `${options.client.app.runtimeId}`, localRuntimeInstanceId, exposed, revision));
+    } catch {
+    }
+  };
+  const removeRaw = transport.subscribe((messageValue) => {
+    if (messageValue.type === RUNTIME_SNAPSHOT_TYPE && messageValue.runtimeKind === "shared-worker") {
+      const applied = bridge.applySnapshot(messageValue);
+      if (applied.accepted) {
+        workerInstanceId.value = messageValue.runtimeInstanceId;
+        emit({ protocolVersion: RUNTIME_PROTOCOL_VERSION, runtimeId: messageValue.runtimeId, runtimeKind: messageValue.runtimeKind, runtimeInstanceId: messageValue.runtimeInstanceId, state: messageValue.state, revision: messageValue.revision, units: messageValue.units, services: messageValue.services });
+      }
+    } else if (messageValue.type === RUNTIME_ERROR_TYPE) {
+      bridge.invalidate(messageValue.message);
+      emit({ ...current, state: "failed", error: messageValue.message, units: [], services: [] });
+    }
+  });
+  const onError = () => {
+    if (!disposed) {
+      clientPeerScope?.revoke("SharedWorker disconnected");
+      provider?.dispose();
+      bridge.disconnect("SharedWorker disconnected");
+      emit({ ...current, state: "disconnected", runtimeInstanceId: "", revision: 0, units: [], services: [], error: "SharedWorker disconnected" });
+    }
+  };
+  port.addEventListener("messageerror", onError);
+  if (worker.addEventListener) worker.addEventListener("error", onError);
+  else worker.onerror = onError;
+  sendClientSnapshot();
+  const removeClient = options.client?.app.subscribe(() => sendClientSnapshot());
+  const handle = {
+    runtimeKind: "shared-worker",
+    runtimeId: options.id,
+    get runtimeInstanceId() {
+      return workerInstanceId.value;
+    },
+    state: () => current,
+    capability(capability) {
+      return bridge.getClient(capability);
+    },
+    optionalCapability(capability) {
+      return bridge.services().some((service) => service.kind === capability.kind && service.capabilityId === capability.id && service.contractVersion === capability.version) ? bridge.getClient(capability) : void 0;
+    },
+    inspect: () => Object.freeze({ ...current, pendingCallCount: bridge.pendingCallCount, activeStreamCount: bridge.activeStreamCount, peerCount: current.state === "ready" ? 1 : 0 }),
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(current);
+      return () => listeners.delete(listener);
+    },
+    dispose(reason = "SharedWorker connection disposed") {
+      if (disposed) return Promise.resolve();
+      disposed = true;
+      emit({ ...current, state: "stopping" });
+      removeClient?.();
+      removeRaw();
+      clientPeerScope?.revoke(reason);
+      provider?.dispose();
+      bridge.dispose(reason);
+      port.removeEventListener("messageerror", onError);
+      worker.removeEventListener?.("error", onError);
+      transport.close?.();
+      emit({ ...current, state: "disposed", runtimeInstanceId: "", revision: 0, units: [], services: [] });
+      return clientPeerScope ? clientPeerScope.dispose({ reason }).then(() => void 0) : Promise.resolve();
+    }
+  };
+  handleBridges.set(handle, bridge);
+  return handle;
+}
+function connectSharedWorker(options) {
+  return connectInternal(options);
+}
+function connectSharedWorkerForTesting(options, workerFactory) {
+  return connectInternal({ ...options, workerFactory });
+}
+function bridgeForRuntimeHandle(handle) {
+  const bridge = handleBridges.get(handle);
+  if (!bridge) throw new Error("RuntimeHandle is not owned by WebLoom");
+  return bridge;
+}
+
+export { bridgeForRuntimeHandle, connectSharedWorker, connectSharedWorkerForTesting, createCapabilityBridge, createCapabilityPeerView, createMessagePortRuntimeTransport, createMessagePortServiceProvider, createPeerScopeView, validateTransferables };
+//# sourceMappingURL=chunk-RAQOFUZY.js.map
+//# sourceMappingURL=chunk-RAQOFUZY.js.map