@vibecook/ghosttea-react 0.10.0 → 0.11.0

package/dist/terminal-render.worker.js

@@ -2686,6 +2686,934 @@ function definitionCatalogFits(installed, definitions, maxDefinitions, retainedD
   return true;
 }
 
+// ../ghosttea-protocol/dist/routed.js
+var ROUTED_PROTOCOL_VERSION = { major: 1, minor: 0 };
+var DEFAULT_ROUTED_RECEIVER_CAPACITIES = {
+  connectionCreditBytes: 8388608,
+  perActivationCreditBytes: 2097152,
+  stagingBytesPerSession: 16777216,
+  stagingBytesTotal: 67108864,
+  maxConcurrentActivations: 128,
+  maxConcurrentSeeds: 4
+};
+var ROUTED_DOOR_LIMITS = {
+  helloDeadlineMs: 5e3,
+  preAuthMaxBytes: 65536,
+  preAuthConnectionCap: 64,
+  maxConnectionSets: 256,
+  heartbeatIntervalMs: 5e3,
+  heartbeatTtlMs: 15e3
+};
+var ROUTED_CLOSE_CODES = {
+  GOING_AWAY: 1001,
+  POLICY_PRE_AUTH: 1008,
+  SERVER_ERROR: 1011,
+  STALE_ROUTE: 4e3,
+  FENCED: 4001,
+  SUPERSEDED: 4002,
+  PROTOCOL: 4003,
+  LEG_TIMEOUT: 4004
+};
+function compareRoutedSceneContent(left, right) {
+  if (left.sceneEpoch.cellBootId !== right.sceneEpoch.cellBootId || left.sceneEpoch.modelGeneration !== right.sceneEpoch.modelGeneration) {
+    return null;
+  }
+  if (left.sceneRevision === right.sceneRevision)
+    return 0;
+  return left.sceneRevision < right.sceneRevision ? -1 : 1;
+}
+var ROUTED_MESSAGE_TYPES = [
+  "ConnectionHello",
+  "ConnectionAccepted",
+  "ConnectionRefused",
+  "LegHeartbeat",
+  "LegHeartbeatAck",
+  "AttachControlLeg",
+  "ControlLegAttached",
+  "AttachRefused",
+  "DeclareDemand",
+  "DemandAccepted",
+  "CellActivationStatus",
+  "ClaimGeometry",
+  "ReleaseGeometry",
+  "TransferGeometry",
+  "GeometryCommitted",
+  "GeometryRefused",
+  "AttachFramesLeg",
+  "FramesLegAttached",
+  "TransportCredit",
+  "SceneApplied",
+  "CalibrationPing"
+];
+var ROUTED_LEG_OUTBOUND = {
+  control: [
+    "ConnectionAccepted",
+    "ConnectionRefused",
+    "LegHeartbeatAck",
+    "ControlLegAttached",
+    "AttachRefused",
+    "DemandAccepted",
+    "CellActivationStatus",
+    "GeometryCommitted",
+    "GeometryRefused"
+  ],
+  frames: ["ConnectionAccepted", "ConnectionRefused", "LegHeartbeatAck", "FramesLegAttached", "AttachRefused"]
+};
+var routedMessageTypeSet = new Set(ROUTED_MESSAGE_TYPES);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCounter(value) {
+  return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+function isPositiveInteger(value) {
+  return Number.isSafeInteger(value) && Number(value) > 0;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isSortedUniqueStringArray(value, allowed) {
+  return isStringArray(value) && value.every((item, index) => (allowed === void 0 || allowed.has(item)) && (index === 0 || String(value[index - 1]) < item));
+}
+function hasOptionalCounter(record, key) {
+  return record[key] === void 0 || isCounter(record[key]);
+}
+function hasOptionalString(record, key) {
+  return record[key] === void 0 || typeof record[key] === "string";
+}
+function isStamp(value) {
+  if (!isRecord(value) || !isRecord(value.sceneEpoch))
+    return false;
+  return isNonEmptyString(value.sceneEpoch.cellBootId) && isCounter(value.sceneEpoch.modelGeneration) && isCounter(value.sceneRevision);
+}
+var transportChannels = /* @__PURE__ */ new Set(["control", "frames"]);
+var sessionRights = /* @__PURE__ */ new Set(["geometry", "geometryAdmin", "input", "read"]);
+function isGrantProtectedHeader(value, type) {
+  return isRecord(value) && value.v === 1 && value.typ === type && value.iss === "fieldd" && value.alg === "HS256" && isRecord(value.kid) && isNonEmptyString(value.kid.cellBootId) && isCounter(value.kid.keyGeneration);
+}
+function isRoutedCellTransportGrant(value) {
+  if (!isRecord(value) || !isGrantProtectedHeader(value.protected, "CellTransportGrant"))
+    return false;
+  const claims = value.claims;
+  return isRecord(claims) && isNonEmptyString(claims.audienceCellBootId) && isNonEmptyString(claims.clientId) && isNonEmptyString(claims.connectionSetId) && isSortedUniqueStringArray(claims.allowedChannels, transportChannels) && claims.allowedChannels.length > 0 && isCounter(claims.transportGrantGeneration) && isCounter(claims.issuedAt) && isCounter(claims.expiresAt) && isNonEmptyString(claims.nonce) && isNonEmptyString(value.mac);
+}
+function isRoutedSessionAttachGrant(value) {
+  if (!isRecord(value) || !isGrantProtectedHeader(value.protected, "SessionAttachGrant"))
+    return false;
+  const claims = value.claims;
+  return isRecord(claims) && isNonEmptyString(claims.audienceCellBootId) && isNonEmptyString(claims.clientId) && isNonEmptyString(claims.sessionId) && hasOptionalCounter(claims, "leaseEpoch") && isCounter(claims.routeRevision) && isCounter(claims.grantGeneration) && isSortedUniqueStringArray(claims.rights, sessionRights) && isCounter(claims.issuedAt) && isCounter(claims.expiresAt) && isNonEmptyString(value.mac);
+}
+function isRoutedReceiverCapacities(value) {
+  return isRecord(value) && isCounter(value.connectionCreditBytes) && isCounter(value.perActivationCreditBytes) && isCounter(value.stagingBytesPerSession) && isCounter(value.stagingBytesTotal) && isCounter(value.maxConcurrentActivations) && isCounter(value.maxConcurrentSeeds);
+}
+function isRoutedProtocolLimits(value) {
+  return isRecord(value) && isCounter(value.maxControlMessageBytes) && isCounter(value.maxPresentationChunkBytes) && isCounter(value.maxBatchLatencyMs) && isCounter(value.maxCreditReturnDelayMs) && isCounter(value.maxSceneAppliedDelayMs) && isCounter(value.sceneAppliedRefreshMs) && isCounter(value.presentationStatusRefreshMs) && isCounter(value.activationAttachDeadlineMs) && isCounter(value.maxActivationCatchupMs) && isCounter(value.maxCatchupBytes) && isCounter(value.creditAccountDrainTtlMs) && isCounter(value.urgentReserveBytes) && isCounter(value.maxBulkBytesAdmittedAhead) && isCounter(value.maxUrgentPresentationUnitBytes);
+}
+function isSourceDemand(value) {
+  return isRecord(value) && (value.mode === "none" || value.mode === "snapshot" || value.mode === "live") && (value.cadenceClass === void 0 || value.cadenceClass === "low" || value.cadenceClass === "normal" || value.cadenceClass === "high") && (value.urgency === void 0 || value.urgency === "background" || value.urgency === "normal" || value.urgency === "urgent");
+}
+function isTrfIdentity(value) {
+  return isRecord(value) && typeof value.sessionHandle === "string" && /^(0|[1-9][0-9]*)$/.test(value.sessionHandle) && typeof value.viewHandle === "string" && /^(0|[1-9][0-9]*)$/.test(value.viewHandle);
+}
+function isFramesAttachOutcome(value) {
+  if (!isRecord(value) || value.kind !== "resume-accepted" && value.kind !== "seed-required")
+    return false;
+  if (!hasOptionalString(value, "reason"))
+    return false;
+  if (value.kind === "resume-accepted")
+    return isStamp(value.from) && isStamp(value.newestAvailable);
+  return (value.from === void 0 || isStamp(value.from)) && (value.newestAvailable === void 0 || isStamp(value.newestAvailable));
+}
+function isGeometryClaimant(value) {
+  return isRecord(value) && isNonEmptyString(value.clientId) && isNonEmptyString(value.viewId);
+}
+function isGeometryHolder(value) {
+  return isGeometryClaimant(value) && isCounter(value.holderGeneration);
+}
+function hasActivation(record) {
+  return isNonEmptyString(record.activationId);
+}
+function validateRoutedBody(type, body) {
+  switch (type) {
+    case "ConnectionHello":
+      return isCounter(body.protocolMajor) && isCounter(body.protocolMinor) && (body.channel === "control" || body.channel === "frames") && isRoutedCellTransportGrant(body.transportGrant) && (body.receiverCapacities === void 0 || isRoutedReceiverCapacities(body.receiverCapacities)) && isStringArray(body.capabilities);
+    case "ConnectionAccepted":
+      return isRecord(body.selectedProtocolVersion) && isCounter(body.selectedProtocolVersion.major) && isCounter(body.selectedProtocolVersion.minor) && isNonEmptyString(body.connectionSetId) && (body.channel === "control" || body.channel === "frames") && isCounter(body.legGeneration) && isCounter(body.heartbeatTtlMs) && hasOptionalCounter(body, "creditEpoch") && (body.initialWindows === void 0 || isRoutedReceiverCapacities(body.initialWindows)) && isRoutedProtocolLimits(body.protocolLimits) && isStringArray(body.capabilities);
+    case "ConnectionRefused":
+      return typeof body.code === "string" && typeof body.retryable === "boolean";
+    case "LegHeartbeat":
+      return isNonEmptyString(body.connectionSetId) && (body.channel === "control" || body.channel === "frames") && isCounter(body.legGeneration) && isCounter(body.sequence);
+    case "LegHeartbeatAck":
+      return isCounter(body.sequence);
+    case "AttachControlLeg":
+      return hasActivation(body) && isRoutedSessionAttachGrant(body.attachGrant) && (body.replacesActivationId === void 0 || isNonEmptyString(body.replacesActivationId)) && isSourceDemand(body.initialDemand);
+    case "ControlLegAttached":
+      return isNonEmptyString(body.sessionId) && hasActivation(body) && isCounter(body.grantGenerationAccepted) && isSortedUniqueStringArray(body.rights, sessionRights);
+    case "AttachRefused":
+      return (body.activationId === void 0 || isNonEmptyString(body.activationId)) && typeof body.code === "string" && typeof body.retryable === "boolean";
+    case "DeclareDemand":
+      return isNonEmptyString(body.sessionId) && hasActivation(body) && isCounter(body.leaseEpoch) && isCounter(body.demandSequence) && isSourceDemand(body.demand);
+    case "DemandAccepted":
+      return isCounter(body.demandSequence);
+    case "CellActivationStatus":
+      if (!isNonEmptyString(body.sessionId) || !hasActivation(body) || !isCounter(body.cellStatusSequence) || !isCounter(body.leaseTtlMs) || body.acceptedContent !== void 0 && !isStamp(body.acceptedContent) || !isRecord(body.presentation) || !["presenting", "stopped", "revoked"].includes(String(body.presentation.state)) || !hasOptionalString(body.presentation, "reason") || !isRecord(body.input) || !["allowed", "suspended", "revoked"].includes(String(body.input.state)) || !hasOptionalString(body.input, "reason")) {
+        return false;
+      }
+      return body.input.state !== "allowed" || body.presentation.state === "presenting";
+    case "ClaimGeometry":
+      return isNonEmptyString(body.sessionId) && hasActivation(body) && isCounter(body.leaseEpoch) && isGeometryClaimant(body.claimant) && isPositiveInteger(body.cols) && isPositiveInteger(body.rows) && isCounter(body.expectRevision);
+    case "ReleaseGeometry":
+      return isNonEmptyString(body.sessionId) && hasActivation(body) && isCounter(body.leaseEpoch) && isGeometryHolder(body.holder);
+    case "TransferGeometry":
+      return isNonEmptyString(body.sessionId) && hasActivation(body) && isCounter(body.leaseEpoch) && isGeometryHolder(body.from) && isGeometryClaimant(body.to) && isCounter(body.expectRevision) && isPositiveInteger(body.cols) && isPositiveInteger(body.rows);
+    case "GeometryCommitted":
+      return isGeometryHolder(body.holder) && isCounter(body.geometryRevision) && isPositiveInteger(body.cols) && isPositiveInteger(body.rows);
+    case "GeometryRefused":
+      return typeof body.code === "string" && (body.currentHolder === void 0 || isGeometryHolder(body.currentHolder)) && hasOptionalCounter(body, "geometryRevision");
+    case "AttachFramesLeg":
+      return hasActivation(body) && isRoutedSessionAttachGrant(body.attachGrant) && (body.resume === void 0 || isRecord(body.resume) && isNonEmptyString(body.resume.resumeToken) && isStamp(body.resume.from));
+    case "FramesLegAttached":
+      return isNonEmptyString(body.sessionId) && hasActivation(body) && isNonEmptyString(body.resumeToken) && isTrfIdentity(body.trfIdentity) && isFramesAttachOutcome(body.outcome);
+    case "TransportCredit":
+      return isCounter(body.creditEpoch) && isCounter(body.creditSequence) && isCounter(body.connectionBytesReturned) && Array.isArray(body.accounts) && body.accounts.every((account) => isRecord(account) && isNonEmptyString(account.activationId) && isCounter(account.bytesReturned));
+    case "SceneApplied":
+      return isNonEmptyString(body.sessionId) && hasActivation(body) && isCounter(body.leaseEpoch) && isStamp(body.appliedContent);
+    case "CalibrationPing":
+      return isCounter(body.sequence) && typeof body.t0 === "number" && Number.isFinite(body.t0);
+  }
+}
+function decodeRoutedMessage(raw, allowed = ROUTED_MESSAGE_TYPES) {
+  let value = raw;
+  if (typeof raw === "string") {
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return { ok: false, error: "not-json" };
+    }
+  }
+  if (!isRecord(value))
+    return { ok: false, error: "not-an-object" };
+  if (typeof value.type !== "string")
+    return { ok: false, error: "missing-type" };
+  if (!routedMessageTypeSet.has(value.type))
+    return { ok: false, error: "unknown-type" };
+  const type = value.type;
+  if (!allowed.includes(type))
+    return { ok: false, error: "not-allowed-here" };
+  const body = { ...value };
+  delete body.type;
+  if (!validateRoutedBody(type, body))
+    return { ok: false, error: "invalid" };
+  return { ok: true, message: value };
+}
+function encodeRoutedMessage(type, body) {
+  if (!isRecord(body) || Object.hasOwn(body, "type") || !validateRoutedBody(type, body)) {
+    throw new TypeError(`invalid routed ${type} message`);
+  }
+  return JSON.stringify({ type, ...body });
+}
+var ROUTED_PRESENTATION_ENVELOPE_MAGIC = [84, 80];
+var ROUTED_PRESENTATION_ENVELOPE_VERSION = 1;
+var ROUTED_PRESENTATION_ENVELOPE_PREFIX_BYTES = 8;
+var ROUTED_PRESENTATION_ENVELOPE_MAX_HEADER_BYTES = 4096;
+var routedUtf8Encoder = new TextEncoder();
+var routedUtf8Decoder = new TextDecoder("utf-8", { fatal: true });
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isTransferLayout(value) {
+  return isRecord(value) && isPositiveInteger(value.cols) && isPositiveInteger(value.rows) && isCounter(value.scrollbackRows);
+}
+function isTransferChecksum(value) {
+  return isRecord(value) && value.alg === "crc32c" && isCounter(value.value);
+}
+function isCalibrationEcho(value) {
+  return isRecord(value) && isCounter(value.sequence) && isFiniteNumber(value.t0) && isFiniteNumber(value.t1) && isFiniteNumber(value.t2);
+}
+function isProfilingEnvelope(value) {
+  return isRecord(value) && isFiniteNumber(value.damageFirstTs) && isFiniteNumber(value.damageLastTs) && isFiniteNumber(value.encodeTs) && (value.probeId === void 0 || typeof value.probeId === "string");
+}
+function validateEnvelopeHeader(value) {
+  if (!isRecord(value))
+    return false;
+  if (!isCounter(value.creditEpoch) || !isCounter(value.activationSequence) || !isNonEmptyString(value.sessionId) || !isNonEmptyString(value.activationId) || !isCounter(value.leaseEpoch) || !["trf1-frame", "transfer-begin", "transfer-chunk", "transfer-end", "calibration"].includes(String(value.kind))) {
+    return false;
+  }
+  const base = value.baseContent;
+  const result = value.resultContent;
+  if (base !== void 0 && base !== null && !isStamp(base))
+    return false;
+  if (result !== void 0 && !isStamp(result))
+    return false;
+  if (value.profiling !== void 0 && !isProfilingEnvelope(value.profiling))
+    return false;
+  if (isStamp(base) && isStamp(result) && compareRoutedSceneContent(base, result) === null)
+    return false;
+  switch (value.kind) {
+    case "trf1-frame":
+      return Object.hasOwn(value, "baseContent") && isStamp(result);
+    case "transfer-begin": {
+      if (!isRecord(value.transfer) || !isNonEmptyString(value.transfer.transferId))
+        return false;
+      if (value.transfer.kind !== "seed" && value.transfer.kind !== "catchup")
+        return false;
+      if (!isCounter(value.transfer.totalBytes) || !isCounter(value.transfer.chunkCount))
+        return false;
+      if (!isTransferLayout(value.transfer.targetLayout) || !isTransferChecksum(value.transfer.checksum) || !isStamp(result)) {
+        return false;
+      }
+      if (value.transfer.kind === "seed")
+        return base === null;
+      return isStamp(base);
+    }
+    case "transfer-chunk":
+      return isRecord(value.transfer) && isNonEmptyString(value.transfer.transferId) && isCounter(value.transfer.chunkIndex) && isCounter(value.transfer.byteOffset);
+    case "transfer-end":
+      return isRecord(value.transfer) && isNonEmptyString(value.transfer.transferId);
+    case "calibration":
+      return isCalibrationEcho(value.calibration);
+    default:
+      return false;
+  }
+}
+function decodeRoutedPresentationEnvelope(bytes) {
+  if (bytes.byteLength < ROUTED_PRESENTATION_ENVELOPE_PREFIX_BYTES)
+    return { ok: false, error: "short" };
+  if (bytes[0] !== ROUTED_PRESENTATION_ENVELOPE_MAGIC[0] || bytes[1] !== ROUTED_PRESENTATION_ENVELOPE_MAGIC[1]) {
+    return { ok: false, error: "bad-magic" };
+  }
+  if (bytes[2] !== ROUTED_PRESENTATION_ENVELOPE_VERSION)
+    return { ok: false, error: "bad-version" };
+  if (bytes[3] !== 0)
+    return { ok: false, error: "bad-reserved" };
+  const headerLength = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(4, false);
+  if (headerLength > ROUTED_PRESENTATION_ENVELOPE_MAX_HEADER_BYTES) {
+    return { ok: false, error: "header-too-large" };
+  }
+  const headerEnd = ROUTED_PRESENTATION_ENVELOPE_PREFIX_BYTES + headerLength;
+  if (headerEnd > bytes.byteLength)
+    return { ok: false, error: "header-truncated" };
+  let text;
+  try {
+    text = routedUtf8Decoder.decode(bytes.subarray(ROUTED_PRESENTATION_ENVELOPE_PREFIX_BYTES, headerEnd));
+  } catch {
+    return { ok: false, error: "header-not-utf8" };
+  }
+  let header;
+  try {
+    header = JSON.parse(text);
+  } catch {
+    return { ok: false, error: "header-not-json" };
+  }
+  if (!validateEnvelopeHeader(header))
+    return { ok: false, error: "header-invalid" };
+  return {
+    ok: true,
+    envelope: { header, payload: bytes.subarray(headerEnd) },
+    chargedBytes: bytes.byteLength
+  };
+}
+function routedCrc32c(bytes, seed = 0) {
+  let crc = (seed ^ 4294967295) >>> 0;
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit += 1) {
+      crc = (crc >>> 1 ^ 2197175160 & -(crc & 1)) >>> 0;
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/routed-frames.ts
+var socketOpen = 1;
+var socketClosing = 2;
+function exactStamp(left, right) {
+  return left !== void 0 && compareRoutedSceneContent(left, right) === 0;
+}
+function copyArrayBuffer(bytes) {
+  const copy = bytes.slice();
+  return copy.buffer;
+}
+function capacitiesFitWithin(accepted, advertised) {
+  return accepted.connectionCreditBytes <= advertised.connectionCreditBytes && accepted.perActivationCreditBytes <= advertised.perActivationCreditBytes && accepted.stagingBytesPerSession <= advertised.stagingBytesPerSession && accepted.stagingBytesTotal <= advertised.stagingBytesTotal && accepted.maxConcurrentActivations <= advertised.maxConcurrentActivations && accepted.maxConcurrentSeeds <= advertised.maxConcurrentSeeds;
+}
+var RoutedFramesTransport = class {
+  #socketFactory;
+  #applyFrame;
+  #emit;
+  #creditReturned;
+  #connections = /* @__PURE__ */ new Map();
+  #activations = /* @__PURE__ */ new Map();
+  #stagingBytes = 0;
+  #disposed = false;
+  constructor(options) {
+    this.#socketFactory = options.socketFactory ?? ((url) => new WebSocket(url));
+    this.#applyFrame = options.applyFrame;
+    this.#emit = options.emit;
+    this.#creditReturned = options.creditReturned;
+  }
+  attach(request) {
+    if (this.#disposed) return;
+    const claims = request.attachGrant.claims;
+    if (claims.sessionId.length === 0 || request.activationId.length === 0 || !/^(0|[1-9][0-9]*)$/.test(request.sessionHandle) || claims.audienceCellBootId !== request.cellBootId || request.transportGrant.claims.audienceCellBootId !== request.cellBootId) {
+      throw new Error("Routed frames attach grant does not match the requested cell");
+    }
+    const previous = this.#activations.get(request.activationId);
+    if (previous?.appliedContent !== void 0 && request.resume !== void 0 && !exactStamp(previous.appliedContent, request.resume.from)) {
+      throw new Error("Routed frames resume does not name the worker's applied scene");
+    }
+    const appliedContent = request.resume?.from ?? previous?.appliedContent;
+    const lastActivationSequence = previous?.lastActivationSequence ?? -1;
+    const workerStatusSequence = previous?.workerStatusSequence ?? 0;
+    if (previous) this.detach(request.activationId);
+    const activation = {
+      request,
+      sessionId: claims.sessionId,
+      leaseEpoch: claims.leaseEpoch ?? 0,
+      ...appliedContent === void 0 ? {} : { appliedContent },
+      lastActivationSequence,
+      workerStatusSequence
+    };
+    this.#activations.set(request.activationId, activation);
+    this.#emit({ type: "frames-state", activationId: request.activationId, state: "attaching" });
+    const connection = this.#connection(request);
+    connection.activationIds.add(request.activationId);
+    if (connection.accepted) this.#sendAttach(connection, activation);
+  }
+  detach(activationId) {
+    const activation = this.#activations.get(activationId);
+    if (!activation) return;
+    this.#releaseTransfer(activation);
+    if (activation.sceneRefreshTimer !== void 0) clearTimeout(activation.sceneRefreshTimer);
+    if (activation.presentationRefreshTimer !== void 0) clearTimeout(activation.presentationRefreshTimer);
+    this.#activations.delete(activationId);
+    const connection = this.#connections.get(activation.request.cellBootId);
+    if (connection) {
+      connection.activationIds.delete(activationId);
+      this.#scheduleAccountDrain(connection, activationId);
+    }
+  }
+  dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    for (const activationId of [...this.#activations.keys()]) this.detach(activationId);
+    for (const connection of this.#connections.values()) {
+      if (connection.heartbeatTimer !== void 0) clearTimeout(connection.heartbeatTimer);
+      if (connection.heartbeatDeadlineTimer !== void 0) clearTimeout(connection.heartbeatDeadlineTimer);
+      if (connection.creditTimer !== void 0) clearTimeout(connection.creditTimer);
+      for (const timer of connection.accountDrainTimers.values()) clearTimeout(timer);
+      if (connection.socket.readyState < socketClosing) connection.socket.close(1e3, "runtime-destroyed");
+    }
+    this.#connections.clear();
+  }
+  #connection(request) {
+    const existing = this.#connections.get(request.cellBootId);
+    if (existing && existing.framesUrl === request.framesUrl && existing.transportGrant.claims.connectionSetId === request.transportGrant.claims.connectionSetId && existing.socket.readyState < socketClosing) {
+      return existing;
+    }
+    if (existing) this.#closeConnection(existing, 1e3, "connection-replaced", true);
+    const socket = this.#socketFactory(request.framesUrl);
+    socket.binaryType = "arraybuffer";
+    const connection = {
+      cellBootId: request.cellBootId,
+      framesUrl: request.framesUrl,
+      transportGrant: request.transportGrant,
+      receiverCapacities: request.receiverCapacities ?? DEFAULT_ROUTED_RECEIVER_CAPACITIES,
+      capabilities: request.capabilities ?? ["resume"],
+      socket,
+      activationIds: /* @__PURE__ */ new Set(),
+      heartbeatSequence: 0,
+      heartbeatAckSequence: 0,
+      creditSequence: 0,
+      connectionBytesReturned: 0,
+      connectionBytesReported: 0,
+      accountBytesReturned: /* @__PURE__ */ new Map(),
+      accountDrainTimers: /* @__PURE__ */ new Map()
+    };
+    this.#connections.set(request.cellBootId, connection);
+    socket.addEventListener("open", () => this.#hello(connection));
+    socket.addEventListener("message", (event) => void this.#message(connection, event));
+    socket.addEventListener("close", (event) => this.#closed(connection, event.code, event.reason));
+    socket.addEventListener("error", () => {
+    });
+    return connection;
+  }
+  #hello(connection) {
+    this.#send(
+      connection,
+      encodeRoutedMessage("ConnectionHello", {
+        protocolMajor: ROUTED_PROTOCOL_VERSION.major,
+        protocolMinor: ROUTED_PROTOCOL_VERSION.minor,
+        channel: "frames",
+        transportGrant: connection.transportGrant,
+        receiverCapacities: connection.receiverCapacities,
+        capabilities: connection.capabilities
+      })
+    );
+  }
+  async #message(connection, event) {
+    if (this.#connections.get(connection.cellBootId) !== connection) return;
+    if (typeof event.data === "string") {
+      this.#text(connection, event.data);
+      return;
+    }
+    let bytes;
+    if (event.data instanceof ArrayBuffer) bytes = new Uint8Array(event.data);
+    else if (ArrayBuffer.isView(event.data)) {
+      bytes = new Uint8Array(event.data.buffer, event.data.byteOffset, event.data.byteLength);
+    } else if (event.data instanceof Blob) {
+      bytes = new Uint8Array(await event.data.arrayBuffer());
+    } else {
+      this.#protocolFailure(connection, void 0, 0, "unsupported binary message");
+      return;
+    }
+    this.#binary(connection, bytes);
+  }
+  #text(connection, text) {
+    const maxBytes = connection.accepted?.protocolLimits.maxControlMessageBytes ?? 262144;
+    if (new TextEncoder().encode(text).byteLength > maxBytes) {
+      this.#protocolFailure(connection, void 0, 0, "frames control message too large");
+      return;
+    }
+    const decoded = decodeRoutedMessage(text, ROUTED_LEG_OUTBOUND.frames);
+    if (!decoded.ok) {
+      this.#protocolFailure(connection, void 0, 0, `invalid frames message: ${decoded.error}`);
+      return;
+    }
+    const message = decoded.message;
+    if (message.type === "ConnectionAccepted") {
+      if (connection.accepted || message.channel !== "frames" || message.connectionSetId !== connection.transportGrant.claims.connectionSetId || message.selectedProtocolVersion.major !== ROUTED_PROTOCOL_VERSION.major || message.selectedProtocolVersion.minor > ROUTED_PROTOCOL_VERSION.minor || message.capabilities.some((capability) => !connection.capabilities.includes(capability)) || message.creditEpoch === void 0 || message.initialWindows === void 0 || !capacitiesFitWithin(message.initialWindows, connection.receiverCapacities)) {
+        this.#protocolFailure(connection, void 0, 0, "invalid frames acceptance");
+        return;
+      }
+      connection.accepted = message;
+      this.#armHeartbeatDeadline(connection);
+      this.#scheduleHeartbeat(connection);
+      for (const activationId of connection.activationIds) {
+        const activation = this.#activations.get(activationId);
+        if (activation) this.#sendAttach(connection, activation);
+      }
+      return;
+    }
+    if (message.type === "ConnectionRefused") {
+      connection.refusal = message;
+      this.#closeConnection(connection, 1e3, message.code, true);
+      return;
+    }
+    if (!connection.accepted) {
+      this.#protocolFailure(connection, void 0, 0, "message before ConnectionAccepted");
+      return;
+    }
+    if (message.type === "LegHeartbeatAck") {
+      if (message.sequence > connection.heartbeatSequence) {
+        this.#protocolFailure(connection, void 0, 0, "heartbeat ack is ahead");
+        return;
+      }
+      if (message.sequence > connection.heartbeatAckSequence) {
+        connection.heartbeatAckSequence = message.sequence;
+        this.#armHeartbeatDeadline(connection);
+      }
+      return;
+    }
+    if (message.type === "AttachRefused") {
+      if (message.activationId !== void 0 && !connection.activationIds.has(message.activationId)) {
+        if (!this.#activations.has(message.activationId)) return;
+        this.#protocolFailure(connection, void 0, 0, "attach refusal binding mismatch");
+        return;
+      }
+      this.#emit({
+        type: "attach-refused",
+        ...message.activationId === void 0 ? {} : { activationId: message.activationId },
+        code: message.code,
+        retryable: message.retryable
+      });
+      return;
+    }
+    if (message.type === "FramesLegAttached") {
+      const activation = this.#activations.get(message.activationId);
+      if (!connection.activationIds.has(message.activationId) && !activation) return;
+      const duplicateIdentity = [...connection.activationIds].some((activationId) => {
+        if (activationId === message.activationId) return false;
+        const identity = this.#activations.get(activationId)?.identity;
+        return identity?.sessionHandle === message.trfIdentity.sessionHandle && identity.viewHandle === message.trfIdentity.viewHandle;
+      });
+      if (!activation || !connection.activationIds.has(message.activationId) || message.sessionId !== activation.sessionId || message.trfIdentity.sessionHandle !== activation.request.sessionHandle || duplicateIdentity || message.outcome.kind === "resume-accepted" && (!connection.accepted.capabilities.includes("resume") || activation.request.resume === void 0 || message.outcome.from === void 0 || !exactStamp(activation.request.resume.from, message.outcome.from))) {
+        this.#protocolFailure(connection, message.activationId, 0, "frames attach identity mismatch");
+        return;
+      }
+      activation.identity = message.trfIdentity;
+      activation.resumeToken = message.resumeToken;
+      this.#emit({ type: "frames-attached", attached: message });
+      this.#emit({
+        type: "frames-state",
+        activationId: message.activationId,
+        state: message.outcome.kind === "resume-accepted" ? "resuming" : "seeding",
+        resumeToken: message.resumeToken
+      });
+      this.#reportPresentation(
+        connection,
+        activation,
+        message.outcome.kind === "resume-accepted" ? "recovering" : "seeding"
+      );
+      return;
+    }
+    this.#protocolFailure(connection, void 0, 0, `unexpected frames message ${message.type}`);
+  }
+  #sendAttach(connection, activation) {
+    const resume = connection.accepted?.capabilities.includes("resume") ? activation.request.resume : void 0;
+    const body = {
+      activationId: activation.request.activationId,
+      attachGrant: activation.request.attachGrant,
+      ...resume === void 0 ? {} : { resume }
+    };
+    this.#send(connection, encodeRoutedMessage("AttachFramesLeg", body));
+  }
+  #binary(connection, bytes) {
+    if (!connection.accepted) {
+      this.#protocolFailure(connection, void 0, bytes.byteLength, "binary message before acceptance");
+      return;
+    }
+    const decoded = decodeRoutedPresentationEnvelope(bytes);
+    if (!decoded.ok) {
+      this.#protocolFailure(connection, void 0, bytes.byteLength, `bad envelope: ${decoded.error}`);
+      return;
+    }
+    const { header, payload } = decoded.envelope;
+    if (header.creditEpoch !== connection.accepted.creditEpoch) {
+      this.#protocolFailure(connection, header.activationId, decoded.chargedBytes, "credit epoch mismatch");
+      return;
+    }
+    if (header.profiling !== void 0 && !connection.accepted.capabilities.includes("profiling-envelope")) {
+      this.#protocolFailure(connection, header.activationId, decoded.chargedBytes, "unnegotiated profiling envelope");
+      return;
+    }
+    if (header.kind === "calibration") {
+      if (payload.byteLength !== 0) {
+        this.#protocolFailure(connection, void 0, decoded.chargedBytes, "calibration payload is not empty");
+        return;
+      }
+      const sequence = header.calibration.sequence;
+      if (sequence > connection.heartbeatSequence) {
+        this.#protocolFailure(connection, void 0, decoded.chargedBytes, "calibration echo is ahead");
+        return;
+      }
+      if (sequence > connection.heartbeatAckSequence) {
+        connection.heartbeatAckSequence = sequence;
+        this.#armHeartbeatDeadline(connection);
+      }
+      this.#returnCredit(connection, void 0, decoded.chargedBytes);
+      return;
+    }
+    const activation = this.#activations.get(header.activationId);
+    if (!activation || !connection.activationIds.has(header.activationId) || !activation.identity) {
+      this.#returnCredit(connection, header.activationId, decoded.chargedBytes);
+      if (activation)
+        this.#protocolFailure(connection, header.activationId, 0, "presentation activation binding mismatch");
+      return;
+    }
+    if (header.sessionId !== activation.sessionId || header.leaseEpoch !== activation.leaseEpoch || header.activationSequence <= activation.lastActivationSequence) {
+      this.#protocolFailure(
+        connection,
+        header.activationId,
+        decoded.chargedBytes,
+        "presentation identity or sequence mismatch"
+      );
+      return;
+    }
+    activation.lastActivationSequence = header.activationSequence;
+    if ((header.kind === "transfer-begin" || header.kind === "transfer-end") && payload.byteLength !== 0) {
+      this.#protocolFailure(connection, header.activationId, decoded.chargedBytes, "transfer metadata carries payload");
+      return;
+    }
+    switch (header.kind) {
+      case "trf1-frame":
+        this.#incremental(connection, activation, header, payload, decoded.chargedBytes);
+        break;
+      case "transfer-begin":
+        this.#beginTransfer(connection, activation, header, decoded.chargedBytes);
+        break;
+      case "transfer-chunk":
+        this.#transferChunk(connection, activation, header, payload, decoded.chargedBytes);
+        break;
+      case "transfer-end":
+        this.#endTransfer(connection, activation, header, decoded.chargedBytes);
+        break;
+    }
+  }
+  #incremental(connection, activation, header, payload, chargedBytes) {
+    if (payload.byteLength > connection.accepted.protocolLimits.maxPresentationChunkBytes || !header.resultContent || header.baseContent === void 0 || header.baseContent !== null && !exactStamp(activation.appliedContent, header.baseContent)) {
+      this.#protocolFailure(connection, header.activationId, chargedBytes, "incremental base mismatch");
+      return;
+    }
+    try {
+      this.#emit({ type: "frames-state", activationId: header.activationId, state: "applying" });
+      this.#applyFrame(copyArrayBuffer(payload), activation.identity);
+      activation.appliedContent = header.resultContent;
+      this.#returnCredit(connection, header.activationId, chargedBytes);
+      this.#sceneApplied(connection, activation);
+    } catch (error) {
+      this.#protocolFailure(connection, header.activationId, chargedBytes, String(error));
+    }
+  }
+  #beginTransfer(connection, activation, header, chargedBytes) {
+    const transfer = header.transfer;
+    const limits = connection.accepted.protocolLimits;
+    const windows = connection.accepted.initialWindows;
+    if (activation.transfer || !transfer?.kind || transfer.totalBytes === void 0 || transfer.chunkCount === void 0 || !transfer.targetLayout || !transfer.checksum || !header.resultContent || transfer.totalBytes > windows.stagingBytesPerSession || this.#stagingBytes + transfer.totalBytes > windows.stagingBytesTotal || transfer.kind === "catchup" && transfer.totalBytes > limits.maxCatchupBytes || transfer.kind === "catchup" && (header.baseContent == null || !exactStamp(activation.appliedContent, header.baseContent))) {
+      this.#protocolFailure(connection, header.activationId, chargedBytes, "transfer budget or header invalid");
+      return;
+    }
+    const activeSeeds = [...this.#activations.values()].filter(
+      (candidate) => candidate.transfer?.kind === "seed"
+    ).length;
+    if (transfer.kind === "seed" && activeSeeds >= windows.maxConcurrentSeeds) {
+      this.#protocolFailure(connection, header.activationId, chargedBytes, "seed concurrency exceeded");
+      return;
+    }
+    activation.transfer = {
+      transferId: transfer.transferId,
+      kind: transfer.kind,
+      bytes: new Uint8Array(transfer.totalBytes),
+      chunkCount: transfer.chunkCount,
+      chunks: /* @__PURE__ */ new Set(),
+      ranges: [],
+      checksum: transfer.checksum.value,
+      targetLayout: transfer.targetLayout,
+      baseContent: header.baseContent ?? null,
+      resultContent: header.resultContent
+    };
+    this.#stagingBytes += transfer.totalBytes;
+    this.#returnCredit(connection, header.activationId, chargedBytes);
+    this.#emit({ type: "frames-state", activationId: header.activationId, state: "seeding" });
+  }
+  #transferChunk(connection, activation, header, payload, chargedBytes) {
+    const staging = activation.transfer;
+    const transfer = header.transfer;
+    const chunkIndex = transfer?.chunkIndex;
+    const byteOffset = transfer?.byteOffset;
+    if (!staging || transfer?.transferId !== staging.transferId || chunkIndex === void 0 || byteOffset === void 0 || chunkIndex >= staging.chunkCount || staging.chunks.has(chunkIndex) || payload.byteLength > connection.accepted.protocolLimits.maxPresentationChunkBytes || byteOffset + payload.byteLength > staging.bytes.byteLength) {
+      this.#protocolFailure(connection, header.activationId, chargedBytes, "transfer chunk invalid");
+      return;
+    }
+    const end = byteOffset + payload.byteLength;
+    if (staging.ranges.some((range) => byteOffset < range.end && end > range.start)) {
+      this.#protocolFailure(connection, header.activationId, chargedBytes, "transfer chunk overlap");
+      return;
+    }
+    staging.bytes.set(payload, byteOffset);
+    staging.chunks.add(chunkIndex);
+    staging.ranges.push({ start: byteOffset, end });
+    this.#returnCredit(connection, header.activationId, chargedBytes);
+  }
+  #endTransfer(connection, activation, header, chargedBytes) {
+    const staging = activation.transfer;
+    if (!staging || header.transfer?.transferId !== staging.transferId) {
+      this.#protocolFailure(connection, header.activationId, chargedBytes, "transfer end without begin");
+      return;
+    }
+    this.#returnCredit(connection, header.activationId, chargedBytes);
+    const ranges = [...staging.ranges].sort((left, right) => left.start - right.start);
+    let cursor = 0;
+    for (const range of ranges) {
+      if (range.start !== cursor) {
+        this.#protocolFailure(connection, header.activationId, 0, "transfer has a range gap");
+        return;
+      }
+      cursor = range.end;
+    }
+    if (staging.chunks.size !== staging.chunkCount || cursor !== staging.bytes.byteLength || routedCrc32c(staging.bytes) !== staging.checksum || staging.kind === "catchup" && (staging.baseContent === null || !exactStamp(activation.appliedContent, staging.baseContent))) {
+      this.#protocolFailure(connection, header.activationId, 0, "transfer validation failed");
+      return;
+    }
+    try {
+      this.#emit({ type: "frames-state", activationId: header.activationId, state: "applying" });
+      this.#applyFrame(staging.bytes.buffer, activation.identity, staging.targetLayout);
+      activation.appliedContent = staging.resultContent;
+      this.#releaseTransfer(activation);
+      this.#sceneApplied(connection, activation);
+    } catch (error) {
+      this.#protocolFailure(connection, header.activationId, 0, String(error));
+    }
+  }
+  #releaseTransfer(activation) {
+    if (!activation.transfer) return;
+    this.#stagingBytes = Math.max(0, this.#stagingBytes - activation.transfer.bytes.byteLength);
+    delete activation.transfer;
+  }
+  #sceneApplied(connection, activation) {
+    const appliedContent = activation.appliedContent;
+    if (!appliedContent) return;
+    this.#send(
+      connection,
+      encodeRoutedMessage("SceneApplied", {
+        sessionId: activation.sessionId,
+        activationId: activation.request.activationId,
+        leaseEpoch: activation.leaseEpoch,
+        appliedContent
+      })
+    );
+    this.#emit({
+      type: "frames-state",
+      activationId: activation.request.activationId,
+      state: "active",
+      ...activation.resumeToken === void 0 ? {} : { resumeToken: activation.resumeToken },
+      appliedContent
+    });
+    this.#reportPresentation(connection, activation, "active");
+    if (activation.sceneRefreshTimer !== void 0) clearTimeout(activation.sceneRefreshTimer);
+    activation.sceneRefreshTimer = setTimeout(
+      () => this.#sceneApplied(connection, activation),
+      connection.accepted.protocolLimits.sceneAppliedRefreshMs
+    );
+  }
+  #reportPresentation(connection, activation, state) {
+    activation.workerStatusSequence += 1;
+    const status = {
+      activationId: activation.request.activationId,
+      workerStatusSequence: activation.workerStatusSequence,
+      state,
+      ...activation.appliedContent === void 0 ? {} : { sceneContent: activation.appliedContent },
+      leaseTtlMs: Math.max(
+        connection.accepted?.protocolLimits.presentationStatusRefreshMs ?? 2e3,
+        connection.accepted?.heartbeatTtlMs ?? ROUTED_DOOR_LIMITS.heartbeatTtlMs
+      )
+    };
+    this.#emit({ type: "presentation-status", status });
+    if (activation.presentationRefreshTimer !== void 0) clearTimeout(activation.presentationRefreshTimer);
+    const refreshMs = connection.accepted?.protocolLimits.presentationStatusRefreshMs ?? 2e3;
+    activation.presentationRefreshTimer = setTimeout(
+      () => this.#reportPresentation(connection, activation, state),
+      refreshMs
+    );
+  }
+  #returnCredit(connection, activationId, bytes) {
+    if (bytes <= 0) return;
+    connection.connectionBytesReturned += bytes;
+    if (activationId) {
+      connection.accountBytesReturned.set(
+        activationId,
+        (connection.accountBytesReturned.get(activationId) ?? 0) + bytes
+      );
+      if (!connection.activationIds.has(activationId)) this.#scheduleAccountDrain(connection, activationId);
+    }
+    const limits = connection.accepted?.protocolLimits;
+    if (connection.creditTimer !== void 0) return;
+    connection.creditTimer = setTimeout(() => this.#flushCredit(connection), limits?.maxCreditReturnDelayMs ?? 16);
+  }
+  #flushCredit(connection) {
+    if (connection.creditTimer !== void 0) clearTimeout(connection.creditTimer);
+    delete connection.creditTimer;
+    if (!connection.accepted || connection.connectionBytesReturned === 0) return;
+    connection.creditSequence += 1;
+    const newlyReturned = connection.connectionBytesReturned - connection.connectionBytesReported;
+    connection.connectionBytesReported = connection.connectionBytesReturned;
+    this.#send(
+      connection,
+      encodeRoutedMessage("TransportCredit", {
+        creditEpoch: connection.accepted.creditEpoch,
+        creditSequence: connection.creditSequence,
+        connectionBytesReturned: connection.connectionBytesReturned,
+        accounts: [...connection.accountBytesReturned].map(([activationId, bytesReturned]) => ({
+          activationId,
+          bytesReturned
+        }))
+      })
+    );
+    this.#creditReturned?.(newlyReturned);
+  }
+  #scheduleAccountDrain(connection, activationId) {
+    const previous = connection.accountDrainTimers.get(activationId);
+    if (previous !== void 0) clearTimeout(previous);
+    const ttl = connection.accepted?.protocolLimits.creditAccountDrainTtlMs ?? 5e3;
+    connection.accountDrainTimers.set(
+      activationId,
+      setTimeout(() => {
+        connection.accountDrainTimers.delete(activationId);
+        if (!connection.activationIds.has(activationId)) connection.accountBytesReturned.delete(activationId);
+      }, ttl)
+    );
+  }
+  #scheduleHeartbeat(connection) {
+    if (connection.heartbeatTimer !== void 0) clearTimeout(connection.heartbeatTimer);
+    connection.heartbeatTimer = setTimeout(
+      () => {
+        if (!connection.accepted || connection.socket.readyState !== socketOpen) return;
+        connection.heartbeatSequence += 1;
+        this.#send(
+          connection,
+          encodeRoutedMessage("CalibrationPing", {
+            sequence: connection.heartbeatSequence,
+            t0: Date.now()
+          })
+        );
+        this.#scheduleHeartbeat(connection);
+      },
+      Math.max(
+        100,
+        Math.min(
+          ROUTED_DOOR_LIMITS.heartbeatIntervalMs,
+          Math.floor((connection.accepted?.heartbeatTtlMs ?? ROUTED_DOOR_LIMITS.heartbeatTtlMs) / 3)
+        )
+      )
+    );
+  }
+  #armHeartbeatDeadline(connection) {
+    if (connection.heartbeatDeadlineTimer !== void 0) clearTimeout(connection.heartbeatDeadlineTimer);
+    const ttl = connection.accepted?.heartbeatTtlMs ?? ROUTED_DOOR_LIMITS.heartbeatTtlMs;
+    connection.heartbeatDeadlineTimer = setTimeout(() => {
+      if (this.#connections.get(connection.cellBootId) !== connection) return;
+      this.#closeConnection(connection, ROUTED_CLOSE_CODES.LEG_TIMEOUT, "heartbeat timeout", true);
+    }, ttl);
+  }
+  #protocolFailure(connection, activationId, chargedBytes, reason) {
+    this.#returnCredit(connection, activationId, chargedBytes);
+    this.#flushCredit(connection);
+    if (activationId) this.#emit({ type: "frames-state", activationId, state: "failed", reason: "PROTOCOL" });
+    this.#closeConnection(connection, ROUTED_CLOSE_CODES.PROTOCOL, reason, true);
+  }
+  #send(connection, text) {
+    if (connection.socket.readyState === socketOpen) connection.socket.send(text);
+  }
+  #closeConnection(connection, code, reason, closeSocket) {
+    if (connection.heartbeatTimer !== void 0) clearTimeout(connection.heartbeatTimer);
+    if (connection.heartbeatDeadlineTimer !== void 0) clearTimeout(connection.heartbeatDeadlineTimer);
+    if (connection.creditTimer !== void 0) clearTimeout(connection.creditTimer);
+    for (const timer of connection.accountDrainTimers.values()) clearTimeout(timer);
+    if (closeSocket && connection.socket.readyState < socketClosing)
+      connection.socket.close(code, reason.slice(0, 123));
+    this.#closed(connection, code, reason);
+  }
+  #closed(connection, code, reason) {
+    if (this.#connections.get(connection.cellBootId) !== connection) return;
+    this.#connections.delete(connection.cellBootId);
+    if (connection.heartbeatTimer !== void 0) clearTimeout(connection.heartbeatTimer);
+    if (connection.heartbeatDeadlineTimer !== void 0) clearTimeout(connection.heartbeatDeadlineTimer);
+    if (connection.creditTimer !== void 0) clearTimeout(connection.creditTimer);
+    for (const timer of connection.accountDrainTimers.values()) clearTimeout(timer);
+    connection.accountDrainTimers.clear();
+    const activationIds = [...connection.activationIds];
+    for (const activationId of activationIds) {
+      const activation = this.#activations.get(activationId);
+      if (!activation) continue;
+      this.#releaseTransfer(activation);
+      if (activation.sceneRefreshTimer !== void 0) clearTimeout(activation.sceneRefreshTimer);
+      if (activation.presentationRefreshTimer !== void 0) clearTimeout(activation.presentationRefreshTimer);
+    }
+    this.#emit({
+      type: "transport-closed",
+      cellBootId: connection.cellBootId,
+      code,
+      reason,
+      activationIds,
+      preAuth: connection.refusal === void 0 && connection.accepted === void 0 && code === 1008,
+      ...connection.refusal === void 0 ? {} : { refusal: connection.refusal }
+    });
+  }
+};
+
 // src/terminal-render.worker.ts
 var hiddenCursor = { x: 0, y: 0, visible: false, style: 1, blinking: false };
 var CURSOR_BLINK_INTERVAL_MS = 600;
@@ -2731,6 +3659,37 @@ var pendingFrameCreditBytes = 0;
 var frameCreditTimer;
 var shaderAnimationScheduled = false;
 var performanceMeasurement;
+var lifetimeStartedAt = performance.now();
+var lifetimeFrames = {
+  received: 0,
+  bytes: 0,
+  full: 0,
+  incremental: 0,
+  stale: 0,
+  decodes: 0,
+  applies: 0
+};
+var lifetimeSessions = /* @__PURE__ */ new Map();
+var lifetimeRenderer = { queueSubmits: 0, presents: 0 };
+var lifetimeFlow = { creditBytesReturned: 0, creditBatchesReturned: 0 };
+function sessionCounters(sessionHandle) {
+  let counters = lifetimeSessions.get(sessionHandle);
+  if (!counters) {
+    counters = { received: 0, bytes: 0, full: 0, incremental: 0, stale: 0, decodes: 0, applies: 0 };
+    lifetimeSessions.set(sessionHandle, counters);
+  }
+  return counters;
+}
+function counterSnapshot() {
+  return {
+    backend: renderer?.kind ?? "starting",
+    durationMs: performance.now() - lifetimeStartedAt,
+    frames: { ...lifetimeFrames },
+    renderer: { ...lifetimeRenderer },
+    flow: { ...lifetimeFlow },
+    sessions: Object.fromEntries([...lifetimeSessions].map(([id, counters]) => [id, { ...counters }]))
+  };
+}
 function appendPerformanceSample(samples, value) {
   if (samples.length < MAX_PERFORMANCE_SAMPLES) samples.push(value);
 }
@@ -2740,6 +3699,8 @@ function flushFrameCredit() {
   if (pendingFrameCreditBytes === 0) return;
   const bytes = pendingFrameCreditBytes;
   pendingFrameCreditBytes = 0;
+  lifetimeFlow.creditBytesReturned += bytes;
+  lifetimeFlow.creditBatchesReturned += 1;
   postToRenderer({ type: "frame-credit", bytes });
 }
 function returnFrameCredit(bytes) {
@@ -2813,6 +3774,10 @@ function recordRenderMetrics(metrics) {
   target.atlasUploadBytes += metrics.atlasUploadBytes;
   target.atlasUploadCalls += metrics.atlasUploadCalls;
 }
+function recordLifetimeRenderMetrics(metrics) {
+  lifetimeRenderer.queueSubmits += metrics.queueSubmits;
+  lifetimeRenderer.presents += metrics.fullRenders + metrics.partialRenders;
+}
 async function finishPerformanceMeasurement(requestId, quietMs, timeoutMs) {
   const active = performanceMeasurement;
   if (!active) throw new Error("No terminal render performance measurement is active");
@@ -2859,25 +3824,28 @@ async function finishPerformanceMeasurement(requestId, quietMs, timeoutMs) {
 function postToRenderer(message) {
   self.postMessage(message);
 }
+function emptySessionSnapshot() {
+  return {
+    rows: [],
+    nativeRows: [],
+    nativeStyleRows: [],
+    glyphDefinitions: /* @__PURE__ */ new Map(),
+    glyphPixelBytes: 0,
+    styleDefinitions: /* @__PURE__ */ new Map(),
+    rowRevisions: [],
+    cursor: hiddenCursor,
+    layoutEpoch: 0n,
+    sessionEpoch: 0n,
+    sequence: 0n,
+    awaitingResync: false,
+    catalogFallback: false,
+    scrollbar: null
+  };
+}
 function snapshot(sessionHandle) {
   let value = snapshots.get(sessionHandle);
   if (!value) {
-    value = {
-      rows: [],
-      nativeRows: [],
-      nativeStyleRows: [],
-      glyphDefinitions: /* @__PURE__ */ new Map(),
-      glyphPixelBytes: 0,
-      styleDefinitions: /* @__PURE__ */ new Map(),
-      rowRevisions: [],
-      cursor: hiddenCursor,
-      layoutEpoch: 0n,
-      sessionEpoch: 0n,
-      sequence: 0n,
-      awaitingResync: false,
-      catalogFallback: false,
-      scrollbar: null
-    };
+    value = emptySessionSnapshot();
     snapshots.set(sessionHandle, value);
   }
   return value;
@@ -3117,6 +4085,7 @@ async function flush() {
       const active = performanceMeasurement;
       const beforeRender = active ? performance.now() : 0;
       const metrics = backend.renderBatch ? backend.renderBatch(entries) : entries.map(({ id, view }) => backend.render(id, view));
+      for (const metric of metrics) recordLifetimeRenderMetrics(metric ?? emptyRenderMetrics());
       const renderedAt = active ? performance.now() : 0;
       for (const { id } of entries) {
         const damage = surfaces.get(id)?.damage;
@@ -3200,9 +4169,11 @@ async function mount(surfaceId, sessionHandle, canvas) {
   invalidateFull(surfaceId);
   scheduleShaderAnimation();
 }
-function applyFrame(packet) {
+function applyFrame(packet, expectedIdentity, expectedLayout) {
   const active = performanceMeasurement;
   const applyStarted = active ? performance.now() : 0;
+  lifetimeFrames.received += 1;
+  lifetimeFrames.bytes += packet.byteLength;
   if (active) {
     active.frames.received += 1;
     active.frames.bytes += packet.byteLength;
@@ -3210,15 +4181,39 @@ function applyFrame(packet) {
   }
   const frame = decodeFrame(packet);
   const id = frame.sessionHandle.toString();
+  if (expectedIdentity && (id !== expectedIdentity.sessionHandle || frame.viewHandle.toString() !== expectedIdentity.viewHandle)) {
+    throw new Error("TRF1 identity does not match the routed activation binding");
+  }
+  if (expectedLayout && (frame.cols !== expectedLayout.cols || frame.rows !== expectedLayout.rows)) {
+    throw new Error("transfer layout does not match TRF1");
+  }
+  if (expectedLayout && (frame.flags & FrameFlag.FullSnapshot) === 0) {
+    throw new Error("routed transfer is not a full TRF1 snapshot");
+  }
+  const counters = sessionCounters(id);
+  lifetimeFrames.decodes += 1;
+  counters.received += 1;
+  counters.bytes += packet.byteLength;
+  counters.decodes += 1;
+  if ((frame.flags & FrameFlag.FullSnapshot) !== 0) {
+    lifetimeFrames.full += 1;
+    counters.full += 1;
+  } else {
+    lifetimeFrames.incremental += 1;
+    counters.incremental += 1;
+  }
   if (active) {
     active.lastFrameAt.set(id, applyStarted);
     if ((frame.flags & FrameFlag.FullSnapshot) !== 0) active.frames.full += 1;
     else active.frames.incremental += 1;
   }
-  const previous = snapshot(id);
+  const replacingScene = expectedLayout !== void 0;
+  const installedScene = replacingScene ? snapshots.get(id) : void 0;
+  const previous = replacingScene ? emptySessionSnapshot() : snapshot(id);
   const fullFrame = (frame.flags & FrameFlag.FullSnapshot) !== 0;
   const catalogReset = (frame.flags & FrameFlag.CatalogReset) !== 0;
   if (catalogReset && !fullFrame) {
+    if (expectedIdentity) throw new Error("catalog reset without a full routed frame");
     if (active) {
       active.frames.resyncRequested += 1;
       appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
@@ -3234,21 +4229,25 @@ function applyFrame(packet) {
     full: fullFrame
   });
   if (classification === "stale") {
+    lifetimeFrames.stale += 1;
+    counters.stale += 1;
     if (active) {
       active.frames.stale += 1;
       appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
     }
-    return;
+    if (expectedIdentity) throw new Error("stale routed TRF1 frame");
+    return void 0;
   }
   const changedSession = previous.sessionEpoch !== 0n && frame.sessionEpoch !== previous.sessionEpoch;
   if (classification === "resync") {
+    if (expectedIdentity) throw new Error("routed TRF1 continuity requires a transfer");
     if (active) {
       active.frames.resyncRequested += 1;
       appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
     }
     previous.awaitingResync = true;
     postToRenderer({ type: "frame-resync-needed", sessionHandle: id });
-    return;
+    return void 0;
   }
   const completingResync = previous.awaitingResync;
   const rowSection = frame.sections.find((candidate) => candidate.kind === SectionKind.RowReplacements);
@@ -3258,13 +4257,39 @@ function applyFrame(packet) {
   const clipboardSection = frame.sections.find((candidate) => candidate.kind === SectionKind.ClipboardWrite);
   const scrollbarSection = frame.sections.find((candidate) => candidate.kind === SectionKind.ScrollbarState);
   if (!rowSection || !cursorSection) {
+    if (expectedIdentity) throw new Error("routed TRF1 frame is missing required sections");
     if (active) appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
-    return;
+    return void 0;
+  }
+  const fullRows = (rowSection.flags & 1) !== 0;
+  if (replacingScene && !fullRows) {
+    throw new Error("routed transfer row section is not a full snapshot");
   }
   const glyphDefinitions = glyphSection ? decodeGlyphDefinitions(glyphSection) : NO_GLYPH_DEFINITIONS;
   const styleDefinitions = styleSection ? decodeStyleDefinitions(styleSection) : NO_STYLE_DEFINITIONS;
+  const replacements = decodeRowReplacements(rowSection);
+  for (const replacement of replacements) {
+    if (replacement.row >= frame.rows) throw new RangeError("Row replacement exceeds viewport");
+  }
+  const nextCursor = decodeCursorState(cursorSection);
+  const clipboardText = clipboardSection ? decodeClipboardWrite(clipboardSection) : void 0;
+  let scrollbar;
+  if (scrollbarSection) {
+    const decoded = decodeScrollbarState(scrollbarSection);
+    scrollbar = {
+      total: Number(decoded.total),
+      offset: Number(decoded.offset),
+      length: Number(decoded.length)
+    };
+    if (!Number.isSafeInteger(scrollbar.total) || !Number.isSafeInteger(scrollbar.offset) || !Number.isSafeInteger(scrollbar.length)) {
+      throw new RangeError("Scrollbar state exceeds JavaScript's safe integer range");
+    }
+  }
+  if (expectedLayout && (scrollbar === void 0 || scrollbar.length !== expectedLayout.rows || scrollbar.total - scrollbar.length !== expectedLayout.scrollbackRows)) {
+    throw new Error("transfer scrollback layout does not match TRF1");
+  }
   if (active) active.frames.glyphDefinitions += glyphDefinitions.length;
-  const resetsCatalog = changedSession || completingResync || catalogReset;
+  const resetsCatalog = replacingScene || changedSession || completingResync || catalogReset;
   const wasCatalogFallback = previous.catalogFallback;
   if (resetsCatalog) {
     previous.rows = [];
@@ -3315,13 +4340,14 @@ function applyFrame(packet) {
     );
     const admission = catalogAdmission(false, false, catalogFits);
     if (admission === "request-full") {
+      if (expectedIdentity) throw new Error("routed catalog pressure requires a fresh transfer");
       if (active) {
         active.frames.resyncRequested += 1;
         appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
       }
       previous.awaitingResync = true;
       postToRenderer({ type: "frame-resync-needed", sessionHandle: id });
-      return;
+      return void 0;
     }
     if (admission === "install") {
       installGlyphDefinitions(previous, glyphDefinitions);
@@ -3332,34 +4358,21 @@ function applyFrame(packet) {
     nativeTextAnnounced = true;
     postToRenderer({ type: "renderer-status", backend: renderer?.kind ?? "starting", textEngine: "native" });
   }
-  if (clipboardSection) {
-    postToRenderer({ type: "clipboard-write", text: decodeClipboardWrite(clipboardSection) });
-  }
-  if (scrollbarSection) {
-    const decoded = decodeScrollbarState(scrollbarSection);
-    const scrollbar = {
-      total: Number(decoded.total),
-      offset: Number(decoded.offset),
-      length: Number(decoded.length)
-    };
-    if (!Number.isSafeInteger(scrollbar.total) || !Number.isSafeInteger(scrollbar.offset) || !Number.isSafeInteger(scrollbar.length))
-      throw new RangeError("Scrollbar state exceeds JavaScript's safe integer range");
+  let scrollbarChanged = false;
+  if (scrollbar) {
     if (!previous.scrollbar || previous.scrollbar.total !== scrollbar.total || previous.scrollbar.offset !== scrollbar.offset || previous.scrollbar.length !== scrollbar.length) {
       previous.scrollbar = scrollbar;
-      postToRenderer({ type: "scrollbar-state", sessionHandle: id, scrollbar });
+      scrollbarChanged = true;
     }
   }
-  const full = (rowSection.flags & 1) !== 0;
   const useNativeCatalog = !previous.catalogFallback;
-  const rows = full ? Array(frame.rows).fill("") : previous.rows.slice();
-  const nativeRows = full ? Array.from({ length: frame.rows }, () => []) : previous.nativeRows.slice();
-  const nativeStyleRows = full ? Array.from({ length: frame.rows }, () => []) : previous.nativeStyleRows.slice();
-  const rowRevisions = full ? Array(frame.rows).fill(0n) : previous.rowRevisions.slice();
-  const replacements = decodeRowReplacements(rowSection);
+  const rows = fullRows ? Array(frame.rows).fill("") : previous.rows.slice();
+  const nativeRows = fullRows ? Array.from({ length: frame.rows }, () => []) : previous.nativeRows.slice();
+  const nativeStyleRows = fullRows ? Array.from({ length: frame.rows }, () => []) : previous.nativeStyleRows.slice();
+  const rowRevisions = fullRows ? Array(frame.rows).fill(0n) : previous.rowRevisions.slice();
   const damagedRows = [];
   if (active) active.frames.rowsDecoded += replacements.length;
   for (const replacement of replacements) {
-    if (replacement.row >= frame.rows) throw new RangeError("Row replacement exceeds viewport");
     if (replacement.revision < (rowRevisions[replacement.row] ?? 0n)) continue;
     rows[replacement.row] = replacement.text;
     nativeRows[replacement.row] = useNativeCatalog ? replacement.glyphs : [];
@@ -3373,15 +4386,20 @@ function applyFrame(packet) {
   previous.rowRevisions = rowRevisions;
   const geometryChanged = damagedRows.length > 0;
   const previousCursor = previous.cursor;
-  const nextCursor = decodeCursorState(cursorSection);
   const cursorChanged = nextCursor.x !== previousCursor.x || nextCursor.y !== previousCursor.y || nextCursor.visible !== previousCursor.visible || nextCursor.style !== previousCursor.style || nextCursor.blinking !== previousCursor.blinking;
   previous.cursor = nextCursor;
   previous.layoutEpoch = frame.layoutEpoch;
   previous.sessionEpoch = frame.sessionEpoch;
   previous.sequence = frame.frameSequence;
   previous.awaitingResync = false;
+  if (replacingScene) {
+    snapshots.set(id, previous);
+    if (installedScene) clearSessionCatalog(installedScene);
+  }
+  if (clipboardText !== void 0) postToRenderer({ type: "clipboard-write", text: clipboardText });
+  if (scrollbarChanged && scrollbar) postToRenderer({ type: "scrollbar-state", sessionHandle: id, scrollbar });
   if (completingResync) postToRenderer({ type: "frame-resync-complete", sessionHandle: id });
-  const requiresFullRedraw = full || changedSession || completingResync;
+  const requiresFullRedraw = fullRows || changedSession || completingResync;
   if (!requiresFullRedraw && cursorChanged) damagedRows.push(previousCursor.y, nextCursor.y);
   const hasRowDamage = damagedRows.length > 0;
   for (const surfaceId of surfaceIdsForSession(id)) {
@@ -3399,8 +4417,28 @@ function applyFrame(packet) {
     // recovered screen apart from a partial update of the stale one.
     fullSnapshot: fullFrame
   });
+  lifetimeFrames.applies += 1;
+  counters.applies += 1;
   if (active) appendPerformanceSample(active.samples.frameApplyMs, performance.now() - applyStarted);
+  return {
+    sessionHandle: id,
+    viewHandle: frame.viewHandle.toString(),
+    cols: frame.cols,
+    rows: frame.rows
+  };
 }
+var routedFrames = new RoutedFramesTransport({
+  applyFrame: (packet, identity, expectedLayout) => {
+    const applied = applyFrame(packet, identity, expectedLayout);
+    if (!applied) throw new Error("routed TRF1 frame was not applied");
+    return applied;
+  },
+  emit: (event) => postToRenderer({ type: "routed-frames-event", event }),
+  creditReturned: (bytes) => {
+    lifetimeFlow.creditBytesReturned += bytes;
+    lifetimeFlow.creditBatchesReturned += 1;
+  }
+});
 self.onmessage = (event) => {
   const message = event.data;
   try {
@@ -3557,6 +4595,12 @@ self.onmessage = (event) => {
       void finishPerformanceMeasurement(message.requestId, message.quietMs, message.timeoutMs).catch((error) => {
         console.error("[terminal-renderer] failed to finish performance measurement", error);
       });
+    } else if (message.type === "performance-counters") {
+      postToRenderer({ type: "performance-counters", requestId: message.requestId, snapshot: counterSnapshot() });
+    } else if (message.type === "routed-frames-attach") {
+      routedFrames.attach(message.request);
+    } else if (message.type === "routed-frames-detach") {
+      routedFrames.detach(message.activationId);
     }
   } catch (error) {
     console.error("[terminal-renderer] rejected worker message", error);