@bstage-sdk/bridge 0.0.0-stage → 0.9.0

package/dist/host.js

@@ -0,0 +1,594 @@
+import {
+  ALLOWED_METHODS,
+  ALLOWED_REQUEST_HEADERS,
+  BRIDGE_SURFACES,
+  BridgeError,
+  DEFAULT_GATEWAY_DENY_SEGMENTS,
+  DEFAULT_POLICY,
+  HOST_ONLY_HEADERS,
+  IFRAME_ATTRIBUTES,
+  INIT_RESPONSE,
+  MAX_DECODE_PASSES,
+  MAX_PARTNER_ORIGINS,
+  READY_EVENT,
+  checkPath,
+  classifyDestination,
+  createEnvelope,
+  createNonce,
+  createSession,
+  createSrcdoc,
+  hasSession,
+  isAllowedGatewayPath,
+  isBridgeEnvelope,
+  isBridgeErrorLike,
+  isBridgeSurface,
+  isHostEventType,
+  isRequestType,
+  isValidSession,
+  normalizeExactOrigin,
+  normalizePartnerOrigins,
+  normalizePinnedHeaders,
+  prepareFetch,
+  resolveDestination,
+  resolvePolicy
+} from "./chunk-6LV7HEN4.js";
+import "./chunk-KQMJY4ZH.js";
+
+// src/host/rateLimiter.ts
+var DEFAULT_WINDOW_MS = 6e4;
+function createRateLimiter(max, windowMs = DEFAULT_WINDOW_MS) {
+  let stamps = [];
+  return {
+    take(now = Date.now()) {
+      const recent = stamps.filter((t) => now - t < windowMs);
+      if (recent.length >= max) {
+        stamps = recent;
+        return false;
+      }
+      stamps = [...recent, now];
+      return true;
+    }
+  };
+}
+
+// src/host/events.ts
+function obj(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function sanitizeTheme(value) {
+  return { dark: obj(value).dark === true };
+}
+function sanitizeMember(value) {
+  const m = obj(value);
+  return {
+    signedIn: m.signedIn === true,
+    ...typeof m.nickname === "string" ? { nickname: m.nickname } : {}
+  };
+}
+function sanitizeSlot(value) {
+  const s = obj(value);
+  return typeof s.id === "string" ? { id: s.id, context: s.context } : void 0;
+}
+function sanitizeTranslations(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  return Object.freeze(
+    Object.fromEntries(
+      Object.entries(value).filter(
+        ([k, v]) => typeof v === "string" && k !== "__proto__"
+      )
+    )
+  );
+}
+function sanitizeEvent(type, payload) {
+  const p = obj(payload);
+  switch (type) {
+    case "theme":
+      return sanitizeTheme(p);
+    case "member":
+      return sanitizeMember(p);
+    case "visibility":
+      return { visible: p.visible === true };
+    case "slot.context": {
+      const slot = sanitizeSlot(p);
+      if (!slot) throw new TypeError("[bstage-bridge] slot.context\uC5D0\uB294 id\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4");
+      return slot;
+    }
+    case "locale": {
+      if (typeof p.locale !== "string") {
+        throw new TypeError("[bstage-bridge] locale \uC774\uBCA4\uD2B8\uC5D0\uB294 locale\uC774 \uD544\uC694\uD569\uB2C8\uB2E4");
+      }
+      const translations = sanitizeTranslations(p.translations);
+      return { locale: p.locale, ...translations ? { translations } : {} };
+    }
+    default:
+      throw new TypeError(`[bstage-bridge] \uC54C \uC218 \uC5C6\uB294 \uC774\uBCA4\uD2B8: ${String(type)}`);
+  }
+}
+function buildInit(init, hostOrigin, partnerOrigins, policy) {
+  const slot = init.slot ? sanitizeSlot(init.slot) : void 0;
+  const translations = sanitizeTranslations(init.translations);
+  return Object.freeze({
+    placementId: String(init.placementId),
+    surface: init.surface,
+    phase: String(init.phase),
+    spaceId: String(init.spaceId),
+    hostOrigin,
+    gatewayBase: `${hostOrigin}/gw`,
+    locale: String(init.locale),
+    theme: sanitizeTheme(init.theme),
+    ...slot ? { slot } : {},
+    member: sanitizeMember(init.member),
+    limits: {
+      maxBodyBytes: policy.maxBodyBytes,
+      maxRequestsPerMinute: policy.maxRequestsPerMinute
+    },
+    partnerOrigins,
+    ...translations ? { translations } : {}
+  });
+}
+function applyEvent(init, type, payload) {
+  switch (type) {
+    case "locale": {
+      const p = payload;
+      const { translations: _drop, ...rest } = init;
+      return Object.freeze({
+        ...rest,
+        locale: p.locale,
+        ...p.translations ? { translations: p.translations } : {}
+      });
+    }
+    case "member":
+      return Object.freeze({ ...init, member: payload });
+    case "theme":
+      return Object.freeze({ ...init, theme: payload });
+    case "slot.context":
+      return Object.freeze({ ...init, slot: payload });
+    default:
+      return init;
+  }
+}
+
+// src/host/storage.ts
+var STORAGE_MAX_KEYS = 50;
+var STORAGE_MAX_VALUE_LENGTH = 4096;
+var STORAGE_MAX_KEY_LENGTH = 200;
+var stores = /* @__PURE__ */ new Map();
+function handleStorage(scope, req) {
+  const { op, key, value } = req;
+  if (typeof key !== "string" || key.length === 0 || key.length > STORAGE_MAX_KEY_LENGTH) {
+    throw new BridgeError("BAD_REQUEST", "invalid storage key");
+  }
+  const current = stores.get(scope) ?? {};
+  const has = Object.prototype.hasOwnProperty.call(current, key);
+  if (op === "get") return { value: has ? current[key] : null };
+  if (op === "remove") {
+    if (has) {
+      const next = Object.fromEntries(Object.entries(current).filter(([k]) => k !== key));
+      stores = new Map([...stores, [scope, next]]);
+    }
+    return { value: null };
+  }
+  if (op === "set") {
+    if (typeof value !== "string" || value.length > STORAGE_MAX_VALUE_LENGTH) {
+      throw new BridgeError("BAD_REQUEST", "invalid storage value");
+    }
+    if (!has && Object.keys(current).length >= STORAGE_MAX_KEYS) {
+      throw new BridgeError("BAD_REQUEST", "storage key limit reached");
+    }
+    stores = new Map([...stores, [scope, { ...current, [key]: value }]]);
+    return { value };
+  }
+  throw new BridgeError("BAD_REQUEST", "invalid storage op");
+}
+
+// src/host/validators.ts
+var MAX_PATH_LENGTH = 2048;
+var TOAST_MAX_LENGTH = 500;
+var TRACK_NAME_MAX_LENGTH = 100;
+var TRACK_PARAMS_MAX_BYTES = 4096;
+var RESIZE_MAX_HEIGHT = 2e4;
+var LOG_MAX_LENGTH = 2e3;
+var UNSAFE_KEYS = ["__proto__", "constructor", "prototype"];
+var TOAST_KINDS = ["info", "success", "warning", "error"];
+var LOG_LEVELS = ["debug", "info", "warn", "error"];
+function field(payload, key) {
+  return typeof payload === "object" && payload !== null ? payload[key] : void 0;
+}
+function validatePath(payload, hostOrigin) {
+  const path = field(payload, "path");
+  if (typeof path !== "string" || path.length === 0 || path.length > MAX_PATH_LENGTH || !path.startsWith("/") || path.startsWith("//") || // eslint-disable-next-line no-control-regex -- 제어문자를 거르는 것이 목적이다
+  /[\s\\\u0000-\u001f\u007f]/.test(path)) {
+    throw new BridgeError("BAD_REQUEST", "invalid path");
+  }
+  let resolved;
+  try {
+    resolved = new URL(path, hostOrigin);
+  } catch {
+    throw new BridgeError("BAD_REQUEST", "invalid path");
+  }
+  if (resolved.origin !== new URL(hostOrigin).origin || resolved.pathname.startsWith("//")) {
+    throw new BridgeError("BAD_REQUEST", "invalid path");
+  }
+  if (!checkPath(resolved.pathname, { forbidDoubleSlash: true }).ok) {
+    throw new BridgeError("BAD_REQUEST", "invalid path");
+  }
+  return resolved.pathname + resolved.search + resolved.hash;
+}
+function validateExternalUrl(payload) {
+  const raw = field(payload, "url");
+  if (typeof raw !== "string") throw new BridgeError("BAD_REQUEST", "invalid url");
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new BridgeError("BAD_REQUEST", "invalid url");
+  }
+  if (url.protocol !== "https:" || url.username !== "" || url.password !== "") {
+    throw new BridgeError("FORBIDDEN_DESTINATION", "only https urls can be opened");
+  }
+  return url.href;
+}
+function validateToast(payload) {
+  const message = field(payload, "message");
+  if (typeof message !== "string") throw new BridgeError("BAD_REQUEST", "invalid toast");
+  const kind = field(payload, "kind");
+  const known = TOAST_KINDS.find((k) => k === kind);
+  return { message: message.slice(0, TOAST_MAX_LENGTH), ...known ? { kind: known } : {} };
+}
+function validateHeight(payload) {
+  const height = field(payload, "height");
+  if (typeof height !== "number" || !Number.isFinite(height)) {
+    throw new BridgeError("BAD_REQUEST", "invalid height");
+  }
+  return Math.min(RESIZE_MAX_HEIGHT, Math.max(0, Math.round(height)));
+}
+function validateTrack(payload) {
+  const name = field(payload, "name");
+  const params = field(payload, "params");
+  if (typeof name !== "string" || name.length === 0 || name.length > TRACK_NAME_MAX_LENGTH) {
+    throw new BridgeError("BAD_REQUEST", "invalid track name");
+  }
+  if (params === void 0) return { name };
+  if (typeof params !== "object" || params === null || Array.isArray(params)) {
+    throw new BridgeError("BAD_REQUEST", "invalid track params");
+  }
+  let serialized;
+  try {
+    serialized = JSON.stringify(params);
+  } catch {
+    throw new BridgeError("BAD_REQUEST", "invalid track params");
+  }
+  if (new TextEncoder().encode(serialized).length > TRACK_PARAMS_MAX_BYTES) {
+    throw new BridgeError("BAD_REQUEST", "track params too large");
+  }
+  return {
+    name,
+    params: JSON.parse(
+      serialized,
+      (key, value) => UNSAFE_KEYS.includes(key) ? void 0 : value
+    )
+  };
+}
+function validateLog(payload) {
+  const level = field(payload, "level");
+  const message = field(payload, "message");
+  const known = LOG_LEVELS.find((l) => l === level);
+  if (!known || typeof message !== "string") throw new BridgeError("BAD_REQUEST", "invalid log");
+  return { level: known, message: message.slice(0, LOG_MAX_LENGTH) };
+}
+
+// src/host/createBridgeHost.ts
+var OPAQUE_ORIGIN = "null";
+var UNLIMITED_REQUESTS = ["resize"];
+var EMPTY = Object.freeze({});
+var MAX_IN_FLIGHT_FETCHES = 16;
+var TOAST_PER_MINUTE = 5;
+var READY_PER_SECOND = 2;
+var RESIZE_PER_SECOND = 30;
+var defaultUncredentialedFetch = (url, init) => globalThis.fetch(url, {
+  ...init,
+  credentials: "omit",
+  redirect: "error",
+  referrerPolicy: "no-referrer"
+});
+function unsupported() {
+  throw new BridgeError("UNSUPPORTED", "not supported by host");
+}
+var TOO_LARGE = () => new BridgeError("BODY_TOO_LARGE", "response too large");
+async function readBodyCapped(res, max) {
+  const stream = res.body;
+  if (stream === null) {
+    try {
+      return await res.text();
+    } catch {
+      throw new BridgeError("NETWORK_ERROR", "network error");
+    }
+  }
+  if (typeof stream?.getReader !== "function") {
+    throw new BridgeError("NETWORK_ERROR", "network error");
+  }
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let received = 0;
+  let text = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      received += value.byteLength;
+      if (received > max) {
+        void reader.cancel().catch(() => {
+        });
+        throw TOO_LARGE();
+      }
+      text += decoder.decode(value, { stream: true });
+    }
+  } catch (err) {
+    if (err instanceof BridgeError) throw err;
+    throw new BridgeError("NETWORK_ERROR", "network error");
+  }
+  return text + decoder.decode();
+}
+async function runFetch(ctx, payload) {
+  const prepared = prepareFetch(payload, ctx.destination);
+  let res;
+  try {
+    const send = prepared.kind === "gateway" ? ctx.fetchImpl : prepared.kind === "partner" ? ctx.partnerFetchImpl : ctx.externalFetchImpl;
+    res = await send(prepared.url, {
+      ...prepared.init,
+      headers: { ...prepared.init.headers }
+    });
+  } catch {
+    throw new BridgeError("NETWORK_ERROR", "network error");
+  }
+  const max = ctx.destination.policy.maxResponseBytes;
+  const declared = Number(res.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > max) {
+    void res.body?.cancel().catch(() => {
+    });
+    throw TOO_LARGE();
+  }
+  if (prepared.init.method === "HEAD") {
+    void res.body?.cancel().catch(() => {
+    });
+  }
+  const bodyText = prepared.init.method === "HEAD" ? "" : await readBodyCapped(res, max);
+  const contentType = res.headers.get("content-type");
+  return {
+    status: res.status,
+    statusText: res.statusText,
+    headers: contentType !== null ? { "content-type": contentType } : {},
+    bodyText
+  };
+}
+function writeConsole(level, message) {
+  const write = globalThis.console?.[level];
+  if (typeof write === "function") write.call(globalThis.console, `[bstage-bridge] ${message}`);
+}
+async function dispatch(ctx, type, payload) {
+  const h = ctx.handlers;
+  switch (type) {
+    case "fetch":
+      return runFetch(ctx, payload);
+    case "navigate": {
+      const path = validatePath(payload, ctx.hostOrigin);
+      if (!h.navigate) unsupported();
+      h.navigate(path);
+      return EMPTY;
+    }
+    case "back":
+      if (!h.back) unsupported();
+      h.back();
+      return EMPTY;
+    case "openExternal": {
+      const url = validateExternalUrl(payload);
+      if (h.openExternal) h.openExternal(url);
+      else if (typeof ctx.win.open === "function")
+        ctx.win.open(url, "_blank", "noopener,noreferrer");
+      else unsupported();
+      return EMPTY;
+    }
+    case "toast": {
+      const { message, kind } = validateToast(payload);
+      if (!h.toast) unsupported();
+      if (!ctx.toastLimiter.take()) throw new BridgeError("RATE_LIMITED", "too many toasts");
+      h.toast(message, kind);
+      return EMPTY;
+    }
+    case "resize":
+      ctx.scheduleResize(validateHeight(payload));
+      return EMPTY;
+    case "track": {
+      const { name, params } = validateTrack(payload);
+      if (!h.track) unsupported();
+      h.track(name, params);
+      return EMPTY;
+    }
+    case "storage":
+      return handleStorage(ctx.storageScope, payload ?? {});
+    case "log": {
+      const { level, message } = validateLog(payload);
+      if (ctx.phase === "real") return EMPTY;
+      if (h.log) h.log(level, message);
+      else writeConsole(level, message);
+      return EMPTY;
+    }
+  }
+}
+function failure(code, message) {
+  return { ok: false, error: { code, message } };
+}
+function toFailure(err) {
+  if (err instanceof BridgeError || isBridgeErrorLike(err)) return failure(err.code, err.message);
+  return failure("BAD_REQUEST", "request failed");
+}
+function assertOptions(options) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("[bstage-bridge] createBridgeHost \uC635\uC158\uC774 \uD544\uC694\uD569\uB2C8\uB2E4");
+  }
+  if (!isValidSession(options.session)) {
+    throw new TypeError("[bstage-bridge] session \uD615\uC2DD\uC774 \uC798\uBABB\uB410\uC2B5\uB2C8\uB2E4(createSession() \uC0AC\uC6A9)");
+  }
+  const hostOrigin = normalizeExactOrigin(options.hostOrigin, ["https:", "http:"]);
+  if (!hostOrigin) throw new TypeError("[bstage-bridge] hostOrigin\uC740 \uC815\uD655\uD55C origin\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4");
+  if (typeof options.fetchImpl !== "function") {
+    throw new TypeError("[bstage-bridge] fetchImpl\uC774 \uD544\uC694\uD569\uB2C8\uB2E4");
+  }
+  if (options.partnerFetchImpl !== void 0 && typeof options.partnerFetchImpl !== "function") {
+    throw new TypeError("[bstage-bridge] partnerFetchImpl\uC740 \uD568\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4");
+  }
+  if (options.externalFetchImpl !== void 0 && typeof options.externalFetchImpl !== "function") {
+    throw new TypeError("[bstage-bridge] externalFetchImpl\uC740 \uD568\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4");
+  }
+  if (options.externalFetchImpl !== void 0 && options.externalFetchImpl === options.fetchImpl) {
+    throw new TypeError(
+      "[bstage-bridge] externalFetchImpl\uC5D0 fetchImpl(\uC778\uC99D fetch)\uC744 \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4"
+    );
+  }
+  if (options.partnerFetchImpl !== void 0 && options.partnerFetchImpl === options.fetchImpl) {
+    throw new TypeError("[bstage-bridge] partnerFetchImpl\uC5D0 fetchImpl(\uC778\uC99D fetch)\uC744 \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+  }
+  if (options.externalFetchImpl !== void 0 && options.externalFetchImpl === options.partnerFetchImpl) {
+    throw new TypeError(
+      "[bstage-bridge] externalFetchImpl\uC5D0 partnerFetchImpl(\uD32C \uD1A0\uD070 fetch)\uC744 \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4"
+    );
+  }
+  if (!options.iframe || !options.init) {
+    throw new TypeError("[bstage-bridge] iframe\xB7init\uC774 \uD544\uC694\uD569\uB2C8\uB2E4");
+  }
+  if (!isBridgeSurface(options.init.surface)) {
+    throw new TypeError('[bstage-bridge] init.surface\uB294 "page" \uB610\uB294 "slot"\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4');
+  }
+  return hostOrigin;
+}
+function createBridgeHost(options) {
+  const hostOrigin = assertOptions(options);
+  const policy = resolvePolicy(options.policy);
+  const partnerOrigins = normalizePartnerOrigins(options.init.partnerOrigins, hostOrigin);
+  const pinnedHeaders = normalizePinnedHeaders(options.pinnedHeaders);
+  const { iframe, session } = options;
+  const win = iframe.ownerDocument?.defaultView ?? globalThis;
+  const handlers = options.handlers ?? {};
+  const limiter = createRateLimiter(policy.maxRequestsPerMinute);
+  const readyLimiter = createRateLimiter(READY_PER_SECOND, 1e3);
+  const resizeLimiter = createRateLimiter(RESIZE_PER_SECOND, 1e3);
+  let current = buildInit(options.init, hostOrigin, partnerOrigins, policy);
+  let inFlightFetches = 0;
+  let disposed = false;
+  let resizeHandle;
+  let pendingHeight;
+  const raf = typeof win.requestAnimationFrame === "function" ? (cb) => win.requestAnimationFrame(cb) : (cb) => setTimeout(cb, 16);
+  const cancelRaf = typeof win.cancelAnimationFrame === "function" ? (id) => win.cancelAnimationFrame(id) : (id) => clearTimeout(id);
+  function scheduleResize(height) {
+    pendingHeight = height;
+    if (resizeHandle !== void 0 || !handlers.resize) return;
+    resizeHandle = raf(() => {
+      resizeHandle = void 0;
+      const h = pendingHeight;
+      pendingHeight = void 0;
+      if (!disposed && h !== void 0) handlers.resize?.(h);
+    });
+  }
+  const ctx = {
+    options,
+    handlers,
+    win,
+    destination: { hostOrigin, partnerOrigins, policy, pinnedHeaders },
+    storageScope: `${options.init.spaceId}\0${options.init.placementId}`,
+    phase: options.init.phase,
+    fetchImpl: options.fetchImpl,
+    partnerFetchImpl: options.partnerFetchImpl ?? defaultUncredentialedFetch,
+    externalFetchImpl: options.externalFetchImpl ?? defaultUncredentialedFetch,
+    hostOrigin,
+    toastLimiter: createRateLimiter(TOAST_PER_MINUTE),
+    scheduleResize
+  };
+  function post(target, envelope) {
+    if (disposed) return;
+    target.postMessage(envelope, "*");
+  }
+  async function handleRequest(target, env) {
+    let result;
+    if (env.type === "resize" && !resizeLimiter.take()) {
+      return;
+    }
+    if (!isRequestType(env.type)) {
+      result = failure("UNSUPPORTED", "unknown request type");
+    } else if (env.type === "fetch" && inFlightFetches >= MAX_IN_FLIGHT_FETCHES) {
+      result = failure("RATE_LIMITED", "too many concurrent requests");
+    } else if (!UNLIMITED_REQUESTS.includes(env.type) && !limiter.take()) {
+      result = failure("RATE_LIMITED", "too many requests");
+    } else {
+      if (env.type === "fetch") inFlightFetches += 1;
+      try {
+        result = { ok: true, data: await dispatch(ctx, env.type, env.payload) };
+      } catch (err) {
+        result = toFailure(err);
+      } finally {
+        if (env.type === "fetch") inFlightFetches -= 1;
+      }
+    }
+    post(target, createEnvelope("res", env.type, env.id, result));
+  }
+  function onMessage(ev) {
+    if (disposed) return;
+    const frame = iframe.contentWindow;
+    if (!frame || ev.source !== frame) return;
+    if (ev.origin !== OPAQUE_ORIGIN) return;
+    const env = ev.data;
+    if (!isBridgeEnvelope(env)) return;
+    if (!hasSession(env.payload, session)) return;
+    if (env.kind === "evt" && env.type === READY_EVENT) {
+      if (!readyLimiter.take()) return;
+      post(frame, createEnvelope("res", INIT_RESPONSE, env.id, { ok: true, data: current }));
+      return;
+    }
+    if (env.kind === "req") void handleRequest(frame, env);
+  }
+  win.addEventListener("message", onMessage);
+  return {
+    send(type, payload) {
+      if (disposed) return;
+      if (!isHostEventType(type)) throw new TypeError(`[bstage-bridge] \uC54C \uC218 \uC5C6\uB294 \uC774\uBCA4\uD2B8: ${type}`);
+      if (typeof payload !== "object" || payload === null) {
+        throw new TypeError("[bstage-bridge] \uC774\uBCA4\uD2B8 payload\uB294 \uAC1D\uCCB4\uC5EC\uC57C \uD569\uB2C8\uB2E4");
+      }
+      const clean = sanitizeEvent(type, payload);
+      current = applyEvent(current, type, clean);
+      const frame = iframe.contentWindow;
+      if (frame) post(frame, createEnvelope("evt", type, createSession(), clean));
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      win.removeEventListener("message", onMessage);
+      if (resizeHandle !== void 0) cancelRaf(resizeHandle);
+      resizeHandle = void 0;
+    }
+  };
+}
+export {
+  ALLOWED_METHODS,
+  ALLOWED_REQUEST_HEADERS,
+  BRIDGE_SURFACES,
+  DEFAULT_GATEWAY_DENY_SEGMENTS,
+  DEFAULT_POLICY,
+  HOST_ONLY_HEADERS,
+  IFRAME_ATTRIBUTES,
+  MAX_DECODE_PASSES,
+  MAX_PARTNER_ORIGINS,
+  checkPath,
+  classifyDestination,
+  createBridgeHost,
+  createNonce,
+  createSession,
+  createSrcdoc,
+  isAllowedGatewayPath,
+  isBridgeSurface,
+  isValidSession,
+  normalizePartnerOrigins,
+  normalizePinnedHeaders,
+  prepareFetch,
+  resolveDestination,
+  resolvePolicy
+};