@govplane/runtime-sdk 0.2.4 → 0.5.0

package/dist/index.d.ts

@@ -20,15 +20,24 @@ type Effect = {
         windowSeconds: number;
         key: string;
     };
+} | {
+    type: "custom";
+    value: string;
 };
 type WhenAstV1 = {
+    op: "and" | "or";
+    conditions: WhenAstV1[];
+} | {
     op: "and" | "or";
     args: WhenAstV1[];
+} | {
+    op: "not";
+    condition: WhenAstV1;
 } | {
     op: "not";
     arg: WhenAstV1;
 } | {
-    op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte";
+    op: "eq" | "neq" | "ne" | "gt" | "gte" | "lt" | "lte";
     path: string;
     value: any;
 } | {
@@ -45,15 +54,38 @@ type RuntimeRule = {
     priority: number;
     target: Target;
     when?: WhenAstV1;
+    /** Effect applied when `when` evaluates to true (falls back to `effect`). */
+    thenEffect?: Effect;
+    /** Effect applied when `when` evaluates to false (rule is skipped if absent). */
+    elseEffect?: Effect;
     effect: Effect;
     description?: string;
 };
+type PolicyDefault = {
+    effect: "allow";
+} | {
+    effect: "deny";
+} | {
+    effect: "kill_switch";
+    killSwitch: {
+        service: string;
+        reason?: string;
+    };
+} | {
+    effect: "throttle";
+    throttle: {
+        limit: number;
+        windowSeconds: number;
+        key: string;
+    };
+} | {
+    effect: "custom";
+    customEffect: string;
+};
 type RuntimePolicy = {
     policyKey: string;
     activeVersion: number;
-    defaults: {
-        effect: "allow" | "deny";
-    };
+    defaults?: PolicyDefault;
     rules: RuntimeRule[];
 };
 type RuntimeBundleV1 = {
@@ -76,23 +108,30 @@ type Decision = {
     ruleId?: string;
 } | {
     decision: "kill_switch";
-    reason: "rule";
-    policyKey: string;
-    ruleId: string;
+    reason: "default" | "rule";
+    policyKey?: string;
+    ruleId?: string;
     killSwitch: {
         service: string;
         reason?: string;
     };
 } | {
     decision: "throttle";
-    reason: "rule";
-    policyKey: string;
-    ruleId: string;
+    reason: "default" | "rule";
+    policyKey?: string;
+    ruleId?: string;
     throttle: {
         limit: number;
         windowSeconds: number;
         key: string;
     };
+} | {
+    decision: "custom";
+    reason: "default" | "rule";
+    policyKey?: string;
+    ruleId?: string;
+    value: string;
+    parsedValue?: unknown;
 };
 type TraceDiscardReason = "disabled" | "target_mismatch" | "when_false" | "invalid_effect";
 type TraceRule = {
@@ -115,6 +154,7 @@ type DecisionTrace = {
             deny: number;
             throttle: number;
             allow: number;
+            custom: number;
         };
     };
     winner?: {
@@ -163,6 +203,7 @@ type DecisionTraceCompact = {
             deny: number;
             throttle: number;
             allow: number;
+            custom: number;
         };
     };
     winner?: {
@@ -202,6 +243,7 @@ type StructuredTraceEvent = {
             deny: number;
             throttle: number;
             allow: number;
+            custom: number;
         };
     };
     rules?: Array<{
@@ -241,9 +283,6 @@ declare function validateContext(ctx: Record<string, unknown>, policy: ContextPo
 type RuntimeClientConfig = {
     baseUrl: string;
     runtimeKey: string;
-    orgId: string;
-    projectId: string;
-    env: string;
     pollMs?: number;
     burstPollMs?: number;
     burstDurationMs?: number;
@@ -259,6 +298,11 @@ type RuntimeClientConfig = {
     engine?: {
         validateContext?: boolean;
         contextPolicy?: ContextPolicy;
+        /**
+         * When true, custom-effect `value` strings are JSON-parsed and the result
+         * is attached as `parsedValue` on the returned decision.
+         */
+        parseCustomEffect?: boolean;
     };
     /**
      * Decision trace (SDK-only, zero PII)
@@ -369,6 +413,7 @@ declare class RuntimeClient<TBundle = RuntimeBundleV1> {
     private computeBackoffDelayMs;
     private bundleUrl;
     private commonHeaders;
+    private fetchWithTimeout;
     private headBundle;
     private getBundle;
     private enableBurst;
@@ -401,6 +446,12 @@ type EngineOpts = {
     traceQueueMax?: number;
     traceQueueDropPolicy?: TraceQueueDropPolicy;
     onTraceSinkError?: (err: unknown) => void;
+    /**
+     * When true, custom effect `value` strings are JSON-parsed and the result
+     * is attached as `parsedValue` on the decision.  Parsing errors are
+     * silently swallowed and `parsedValue` is left undefined.
+     */
+    parseCustomEffect?: boolean;
 };
 declare function createPolicyEngine(opts: EngineOpts): PolicyEngine;
 
@@ -410,4 +461,4 @@ type FormatOpts = {
 };
 declare function formatTrace(trace: DecisionTraceCompact | DecisionTraceFull, opts?: FormatOpts): string;
 
-export { type BundleMeta, type ContextPolicy, DEFAULT_CONTEXT_POLICY, type Decision, type DecisionTrace, type DecisionTraceCompact, type DecisionTraceFull, type DecisionTraceHook, type DecisionWithOptionalTrace, type DecisionWithTrace, type Effect, GovplaneError, HttpError, type PolicyEngine, type PolicyEngineEvaluateInput, type RefreshResult, type RuntimeBundleV1, type RuntimeCache, RuntimeClient, type RuntimeClientConfig, type RuntimeClientOptions, type RuntimePolicy, type RuntimeRule, type RuntimeStatus, type StructuredTraceEvent, type Target, type TraceDiscardReason, type TraceLevel, type TraceMode, type TraceOptions, type TraceQueueDropPolicy, type TraceRule, type TraceSink, type TraceSinkAsync, type WhenAstV1, createPolicyEngine, formatTrace, validateContext };
+export { type BundleMeta, type ContextPolicy, DEFAULT_CONTEXT_POLICY, type Decision, type DecisionTrace, type DecisionTraceCompact, type DecisionTraceFull, type DecisionTraceHook, type DecisionWithOptionalTrace, type DecisionWithTrace, type Effect, GovplaneError, HttpError, type PolicyDefault, type PolicyEngine, type PolicyEngineEvaluateInput, type RefreshResult, type RuntimeBundleV1, type RuntimeCache, RuntimeClient, type RuntimeClientConfig, type RuntimeClientOptions, type RuntimePolicy, type RuntimeRule, type RuntimeStatus, type StructuredTraceEvent, type Target, type TraceDiscardReason, type TraceLevel, type TraceMode, type TraceOptions, type TraceQueueDropPolicy, type TraceRule, type TraceSink, type TraceSinkAsync, type WhenAstV1, createPolicyEngine, formatTrace, validateContext };

package/dist/index.js

@@ -5,19 +5,16 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/client/RuntimeClient.ts
-import { request } from "undici";
-
 // src/engine/context.ts
 var DEFAULT_CONTEXT_POLICY = {
   allowedKeys: [
-    "ctx.plan",
-    "ctx.country",
-    "ctx.requestTier",
-    "ctx.feature",
-    "ctx.amount",
-    "ctx.isAuthenticated",
-    "ctx.role"
+    "plan",
+    "country",
+    "requestTier",
+    "feature",
+    "amount",
+    "isAuthenticated",
+    "role"
   ],
   maxStringLen: 64,
   maxArrayLen: 10,
@@ -45,19 +42,18 @@ var DEFAULT_POLICY = {
   blockLikelyPiiKeys: true
 };
 function validateContext(ctx, policy) {
-  const allowed = new Set(policy.allowedKeys);
+  const allowed = new Set(policy.allowedKeys.map((k) => k.startsWith("ctx.") ? k.slice(4) : k));
   const maxStringLen = policy.maxStringLen ?? DEFAULT_POLICY.maxStringLen;
   const maxArrayLen = policy.maxArrayLen ?? DEFAULT_POLICY.maxArrayLen;
   const blockLikelyPiiKeys = policy.blockLikelyPiiKeys ?? DEFAULT_POLICY.blockLikelyPiiKeys;
   for (const [k, v] of Object.entries(ctx)) {
-    const path = `ctx.${k}`;
-    if (!allowed.has(path)) {
-      throw new Error(`Context key not allowed: ${path}`);
+    if (!allowed.has(k)) {
+      throw new Error(`Context key not allowed: ${k}`);
     }
     if (blockLikelyPiiKeys) {
       for (const re of PII_KEY_PATTERNS) {
         if (re.test(k)) {
-          throw new Error(`Context key looks like PII and is blocked: ${path}`);
+          throw new Error(`Context key looks like PII and is blocked: ${k}`);
         }
       }
     }
@@ -65,25 +61,26 @@ function validateContext(ctx, policy) {
     const t = typeof v;
     if (t === "boolean" || t === "number") continue;
     if (t === "string") {
-      if (v.length > maxStringLen) throw new Error(`Context value too long: ${path}`);
+      if (v.length > maxStringLen) throw new Error(`Context value too long: ${k}`);
       continue;
     }
     if (Array.isArray(v)) {
-      if (v.length > maxArrayLen) throw new Error(`Context array too long: ${path}`);
+      if (v.length > maxArrayLen) throw new Error(`Context array too long: ${k}`);
       for (const it of v) {
-        if (typeof it !== "string") throw new Error(`Invalid array value type: ${path}`);
-        if (it.length > maxStringLen) throw new Error(`Invalid array value length: ${path}`);
+        if (typeof it !== "string") throw new Error(`Invalid array value type: ${k}`);
+        if (it.length > maxStringLen) throw new Error(`Invalid array value length: ${k}`);
       }
       continue;
     }
-    throw new Error(`Invalid context type for ${path}`);
+    throw new Error(`Invalid context type for ${k}`);
   }
 }
 
 // src/engine/when.ts
-function getPath(obj, path) {
-  const parts = path.split(".");
-  let cur = obj;
+function getPath(ctx, path) {
+  const normalizedPath = path.startsWith("ctx.") ? path.slice(4) : path;
+  const parts = normalizedPath.split(".");
+  let cur = ctx;
   for (const p of parts) {
     if (!cur || typeof cur !== "object") return void 0;
     cur = cur[p];
@@ -92,30 +89,40 @@ function getPath(obj, path) {
 }
 function evalWhen(node, ctx) {
   switch (node.op) {
-    case "and":
-      return node.args.every((n) => evalWhen(n, ctx));
-    case "or":
-      return node.args.some((n) => evalWhen(n, ctx));
-    case "not":
-      return !evalWhen(node.arg, ctx);
-    case "exists":
-      return getPath({ ctx }, node.path) !== void 0;
+    case "and": {
+      const children = node.conditions ?? node.args ?? [];
+      return children.every((n) => evalWhen(n, ctx));
+    }
+    case "or": {
+      const children = node.conditions ?? node.args ?? [];
+      return children.some((n) => evalWhen(n, ctx));
+    }
+    case "not": {
+      const child = node.condition ?? node.arg;
+      return !evalWhen(child, ctx);
+    }
+    case "exists": {
+      const v = getPath(ctx, node.path);
+      return v !== void 0 && v !== null;
+    }
     case "in": {
-      const v = getPath({ ctx }, node.path);
+      const v = getPath(ctx, node.path);
       return node.values.some((x) => x === v);
     }
     case "eq":
-      return getPath({ ctx }, node.path) === node.value;
+      return getPath(ctx, node.path) === node.value;
+    // `neq` is the canonical spelling; `ne` is kept for legacy bundles
+    case "neq":
     case "ne":
-      return getPath({ ctx }, node.path) !== node.value;
+      return getPath(ctx, node.path) !== node.value;
     case "gt":
-      return Number(getPath({ ctx }, node.path)) > Number(node.value);
+      return Number(getPath(ctx, node.path)) > Number(node.value);
     case "gte":
-      return Number(getPath({ ctx }, node.path)) >= Number(node.value);
+      return Number(getPath(ctx, node.path)) >= Number(node.value);
     case "lt":
-      return Number(getPath({ ctx }, node.path)) < Number(node.value);
+      return Number(getPath(ctx, node.path)) < Number(node.value);
     case "lte":
-      return Number(getPath({ ctx }, node.path)) <= Number(node.value);
+      return Number(getPath(ctx, node.path)) <= Number(node.value);
     default:
       return false;
   }
@@ -325,7 +332,7 @@ function createPolicyEngine(opts) {
         policiesSeen: 0,
         rulesSeen: 0,
         matched: 0,
-        considered: { kill_switch: 0, deny: 0, throttle: 0, allow: 0 }
+        considered: { kill_switch: 0, deny: 0, throttle: 0, allow: 0, custom: 0 }
       },
       rules: []
     } : null;
@@ -344,23 +351,24 @@ function createPolicyEngine(opts) {
     const denies = [];
     const throttles = [];
     const allows = [];
+    const customs = [];
     const policies = bundle.policies ?? [];
     if (wantTrace) traceBase.summary.policiesSeen = policies.length;
     for (const p of policies) {
       const policyKey = String(p.policyKey ?? "");
       const rules = p.rules ?? [];
+      let policyHadMatch = false;
       for (const r of rules) {
         if (wantTrace) traceBase.summary.rulesSeen += 1;
         const ruleId = String(r?.id ?? "");
         const priority = Number(r?.priority ?? 0);
-        const effectType = safeEffectType(r?.effect);
         if (r?.status !== "active") {
           if (wantTrace) {
             traceBase.rules.push({
               policyKey,
               ruleId,
               priority,
-              effectType,
+              effectType: safeEffectType(r?.effect),
               matched: false,
               discardedReason: "disabled"
             });
@@ -373,26 +381,39 @@ function createPolicyEngine(opts) {
               policyKey,
               ruleId,
               priority,
-              effectType,
+              effectType: safeEffectType(r?.effect),
               matched: false,
               discardedReason: "target_mismatch"
             });
           }
           continue;
         }
-        if (r.when && !evalWhen(r.when, ctx)) {
-          if (wantTrace) {
-            traceBase.rules.push({
-              policyKey,
-              ruleId,
-              priority,
-              effectType,
-              matched: false,
-              discardedReason: "when_false"
-            });
+        let resolvedEffect;
+        if (r.when !== void 0) {
+          const whenResult = evalWhen(r.when, ctx);
+          if (whenResult) {
+            resolvedEffect = r.thenEffect ?? r.effect;
+          } else {
+            if (r.elseEffect) {
+              resolvedEffect = r.elseEffect;
+            } else {
+              if (wantTrace) {
+                traceBase.rules.push({
+                  policyKey,
+                  ruleId,
+                  priority,
+                  effectType: safeEffectType(r?.effect),
+                  matched: false,
+                  discardedReason: "when_false"
+                });
+              }
+              continue;
+            }
           }
-          continue;
+        } else {
+          resolvedEffect = r.effect;
         }
+        const effectType = safeEffectType(resolvedEffect);
         if (!effectType) {
           if (wantTrace) {
             traceBase.rules.push({
@@ -406,6 +427,7 @@ function createPolicyEngine(opts) {
           }
           continue;
         }
+        policyHadMatch = true;
         if (wantTrace) {
           traceBase.summary.matched += 1;
           traceBase.rules.push({
@@ -416,7 +438,7 @@ function createPolicyEngine(opts) {
             matched: true
           });
         }
-        const m = { policyKey, ruleId, priority, effect: r.effect };
+        const m = { policyKey, ruleId, priority, effect: resolvedEffect };
         if (effectType === "kill_switch") {
           kills.push(m);
           if (wantTrace) traceBase.summary.considered.kill_switch += 1;
@@ -429,16 +451,55 @@ function createPolicyEngine(opts) {
         } else if (effectType === "allow") {
           allows.push(m);
           if (wantTrace) traceBase.summary.considered.allow += 1;
+        } else if (effectType === "custom") {
+          customs.push(m);
+          if (wantTrace) traceBase.summary.considered.custom += 1;
+        }
+      }
+      if (!policyHadMatch) {
+        const defaults = p.defaults;
+        if (defaults?.effect) {
+          const defEffectType = String(defaults.effect);
+          let syntheticEffect;
+          if (defEffectType === "custom") {
+            syntheticEffect = { type: "custom", value: String(defaults.customEffect ?? "") };
+          } else if (defEffectType === "throttle" && defaults.throttle) {
+            syntheticEffect = { type: "throttle", throttle: defaults.throttle };
+          } else if (defEffectType === "kill_switch" && defaults.killSwitch) {
+            syntheticEffect = { type: "kill_switch", killSwitch: defaults.killSwitch };
+          } else if (defEffectType === "allow" || defEffectType === "deny") {
+            syntheticEffect = { type: defEffectType };
+          }
+          if (syntheticEffect) {
+            const dm = { policyKey, ruleId: "__default__", priority: -1, effect: syntheticEffect };
+            if (defEffectType === "kill_switch") {
+              kills.push(dm);
+              if (wantTrace) traceBase.summary.considered.kill_switch += 1;
+            } else if (defEffectType === "deny") {
+              denies.push(dm);
+              if (wantTrace) traceBase.summary.considered.deny += 1;
+            } else if (defEffectType === "throttle") {
+              throttles.push(dm);
+              if (wantTrace) traceBase.summary.considered.throttle += 1;
+            } else if (defEffectType === "allow") {
+              allows.push(dm);
+              if (wantTrace) traceBase.summary.considered.allow += 1;
+            } else if (defEffectType === "custom") {
+              customs.push(dm);
+              if (wantTrace) traceBase.summary.considered.custom += 1;
+            }
+          }
         }
       }
     }
     if (kills.length) {
       const w = kills.sort(byRuleOrder)[0];
+      const isDefault = w.ruleId === "__default__";
       const decision2 = {
         decision: "kill_switch",
-        reason: "rule",
+        reason: isDefault ? "default" : "rule",
         policyKey: w.policyKey,
-        ruleId: w.ruleId,
+        ruleId: isDefault ? void 0 : w.ruleId,
         killSwitch: w.effect.killSwitch
       };
       if (!wantTrace) return decision2;
@@ -452,11 +513,12 @@ function createPolicyEngine(opts) {
     }
     if (denies.length) {
       const w = denies.sort(byRuleOrder)[0];
+      const isDefault = w.ruleId === "__default__";
       const decision2 = {
         decision: "deny",
-        reason: "rule",
+        reason: isDefault ? "default" : "rule",
         policyKey: w.policyKey,
-        ruleId: w.ruleId
+        ruleId: isDefault ? void 0 : w.ruleId
       };
       if (!wantTrace) return decision2;
       return {
@@ -476,11 +538,12 @@ function createPolicyEngine(opts) {
         if (A.windowSeconds !== B.windowSeconds) return A.windowSeconds - B.windowSeconds;
         return byRuleOrder(a, b);
       })[0];
+      const isDefault = w.ruleId === "__default__";
       const decision2 = {
         decision: "throttle",
-        reason: "rule",
+        reason: isDefault ? "default" : "rule",
         policyKey: w.policyKey,
-        ruleId: w.ruleId,
+        ruleId: isDefault ? void 0 : w.ruleId,
         throttle: w.effect.throttle
       };
       if (!wantTrace) return decision2;
@@ -494,11 +557,12 @@ function createPolicyEngine(opts) {
     }
     if (allows.length) {
       const w = allows.sort(byRuleOrder)[0];
+      const isDefault = w.ruleId === "__default__";
       const decision2 = {
         decision: "allow",
-        reason: "rule",
+        reason: isDefault ? "default" : "rule",
         policyKey: w.policyKey,
-        ruleId: w.ruleId
+        ruleId: isDefault ? void 0 : w.ruleId
       };
       if (!wantTrace) return decision2;
       return {
@@ -509,6 +573,34 @@ function createPolicyEngine(opts) {
         }
       };
     }
+    if (customs.length) {
+      const w = customs.sort(byRuleOrder)[0];
+      const isDefault = w.ruleId === "__default__";
+      const rawValue = String(w.effect.value ?? "");
+      let parsedValue;
+      if (opts.parseCustomEffect) {
+        try {
+          parsedValue = JSON.parse(rawValue);
+        } catch {
+        }
+      }
+      const decision2 = {
+        decision: "custom",
+        reason: isDefault ? "default" : "rule",
+        policyKey: w.policyKey,
+        ruleId: isDefault ? void 0 : w.ruleId,
+        value: rawValue,
+        ...parsedValue !== void 0 ? { parsedValue } : {}
+      };
+      if (!wantTrace) return decision2;
+      return {
+        ...decision2,
+        trace: {
+          ...traceBase,
+          winner: { policyKey: w.policyKey, ruleId: w.ruleId, effectType: "custom", priority: w.priority }
+        }
+      };
+    }
     const decision = { decision: "deny", reason: "default" };
     if (!wantTrace) return decision;
     return {
@@ -612,6 +704,7 @@ var RuntimeClient = class {
   installedSignalHandler = false;
   sigHandler;
   constructor(config) {
+    console.log("[RuntimeClient] initializing with config");
     this.cfg = {
       ...config,
       pollMs: config.pollMs ?? 5e3,
@@ -630,6 +723,7 @@ var RuntimeClient = class {
       getBundle: () => this.cache.bundle,
       validateContext: config.engine?.validateContext !== false,
       contextPolicy: config.engine?.contextPolicy,
+      parseCustomEffect: config.engine?.parseCustomEffect,
       traceDefaults: config.trace?.defaults,
       traceSink: config.trace?.onDecisionTrace,
       traceSinkAsync: config.trace?.onDecisionTraceAsync,
@@ -826,34 +920,38 @@ var RuntimeClient = class {
   }
   bundleUrl() {
     const u = new URL(this.cfg.baseUrl);
-    u.pathname = "/v1/runtime/bundle";
-    u.searchParams.set("projectId", this.cfg.projectId);
-    u.searchParams.set("env", this.cfg.env);
     return u.toString();
   }
   commonHeaders(extra) {
     return {
-      Authorization: `Bearer ${this.cfg.runtimeKey}`,
+      Authorization: this.cfg.runtimeKey,
       "User-Agent": this.cfg.userAgent ?? "govplane-runtime-sdk/0.x",
       ...extra
     };
   }
+  async fetchWithTimeout(url, init) {
+    const ac = new AbortController();
+    const t = setTimeout(() => ac.abort(), this.cfg.timeoutMs);
+    try {
+      return await fetch(url, { ...init, signal: ac.signal });
+    } finally {
+      clearTimeout(t);
+    }
+  }
   async headBundle() {
     const url = this.bundleUrl();
-    const { statusCode, headers, body } = await request(url, {
+    const res = await this.fetchWithTimeout(url, {
       method: "HEAD",
-      headers: this.commonHeaders(),
-      bodyTimeout: this.cfg.timeoutMs,
-      headersTimeout: this.cfg.timeoutMs
+      headers: this.commonHeaders()
     });
-    await body.text().catch(() => void 0);
-    if (statusCode === 401 || statusCode === 403) throw new Error(`Unauthorized (${statusCode})`);
-    if (statusCode >= 500) throw new Error(`Runtime server error (${statusCode})`);
-    if (statusCode !== 200 && statusCode !== 304) return this.cache.meta;
-    const etag = headers["etag"] ?? "";
+    console.log(`[RuntimeClient] HEAD bundle status=${res.status}`);
+    if (res.status === 401 || res.status === 403) throw new Error(`Unauthorized (${res.status})`);
+    if (res.status >= 500) throw new Error(`Runtime server error (${res.status})`);
+    if (res.status !== 200 && res.status !== 304) return this.cache.meta;
+    const etag = res.headers.get("etag") ?? "";
     if (!etag) return this.cache.meta;
-    const bundleVersionRaw = headers["x-gp-bundle-version"];
-    const updatedAt = headers["x-gp-updated-at"];
+    const bundleVersionRaw = res.headers.get("x-gp-bundle-version") ?? void 0;
+    const updatedAt = res.headers.get("x-gp-updated-at") ?? void 0;
     return {
       etag,
       bundleVersion: bundleVersionRaw ? Number(bundleVersionRaw) : void 0,
@@ -863,26 +961,24 @@ var RuntimeClient = class {
   async getBundle() {
     const url = this.bundleUrl();
     const ifNoneMatch = this.cache.meta?.etag;
-    const { statusCode, headers, body } = await request(url, {
+    const res = await this.fetchWithTimeout(url, {
       method: "GET",
-      headers: this.commonHeaders(ifNoneMatch ? { "If-None-Match": ifNoneMatch } : void 0),
-      bodyTimeout: this.cfg.timeoutMs,
-      headersTimeout: this.cfg.timeoutMs
+      headers: this.commonHeaders(ifNoneMatch ? { "If-None-Match": ifNoneMatch } : void 0)
     });
-    const txt = await body.text();
-    if (statusCode === 304) {
-      const etag2 = headers["etag"] ?? ifNoneMatch ?? "";
-      const bundleVersionRaw2 = headers["x-gp-bundle-version"];
-      const updatedAt2 = headers["x-gp-updated-at"];
+    const txt = await res.text();
+    if (res.status === 304) {
+      const etag2 = res.headers.get("etag") ?? ifNoneMatch ?? "";
+      const bundleVersionRaw2 = res.headers.get("x-gp-bundle-version") ?? void 0;
+      const updatedAt2 = res.headers.get("x-gp-updated-at") ?? void 0;
       const meta2 = etag2 ? { etag: etag2, bundleVersion: bundleVersionRaw2 ? Number(bundleVersionRaw2) : void 0, updatedAt: updatedAt2 } : this.cache.meta;
       if (meta2) this.cache.meta = meta2;
       return { changed: false, meta: meta2 };
     }
-    if (statusCode === 401 || statusCode === 403) throw new Error(`Unauthorized (${statusCode})`);
-    if (statusCode >= 400) throw new Error(`Runtime HTTP error (${statusCode}): ${txt.slice(0, 200)}`);
-    const etag = headers["etag"] ?? "";
-    const bundleVersionRaw = headers["x-gp-bundle-version"];
-    const updatedAt = headers["x-gp-updated-at"];
+    if (res.status === 401 || res.status === 403) throw new Error(`Unauthorized (${res.status})`);
+    if (res.status >= 400) throw new Error(`Runtime HTTP error (${res.status}): ${txt.slice(0, 200)}`);
+    const etag = res.headers.get("etag") ?? "";
+    const bundleVersionRaw = res.headers.get("x-gp-bundle-version") ?? void 0;
+    const updatedAt = res.headers.get("x-gp-updated-at") ?? void 0;
     const meta = {
       etag: etag || (ifNoneMatch ?? ""),
       bundleVersion: bundleVersionRaw ? Number(bundleVersionRaw) : void 0,