@rpcbase/server 0.507.0 → 0.509.0

package/dist/index.js

@@ -4,7 +4,7 @@ import MongoStore from "connect-mongo";
 import { createClient } from "redis";
 import { MongoClient } from "mongodb";
 import env from "@rpcbase/env";
-import { initApiClient, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
+import { initApiClient, STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY, RtsSsrRuntimeProvider, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
 import { dirname, posix, sep } from "path";
 import fs, { createReadStream, readFileSync } from "node:fs";
 import { createInterface } from "node:readline";
@@ -16,11 +16,12 @@ import fsPromises from "node:fs/promises";
 import inspector from "node:inspector";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { Transform } from "node:stream";
+import { Writable, Transform } from "node:stream";
 import { StrictMode, createElement } from "react";
 import { renderToPipeableStream, renderToStaticMarkup } from "react-dom/server";
 import { jsx } from "react/jsx-runtime";
 import { createPath, matchRoutes, parsePath, createStaticRouter, StaticRouterProvider } from "@rpcbase/router";
+import { r as resolveRtsRequestTenantId, i as isRtsRequestAuthorized, b as buildRtsAbilityFromRequest, n as normalizeRtsQueryOptions, a as runRtsQuery } from "./queryExecutor-BZ0GSPM1.js";
 import { s } from "./email-DEw8keax.js";
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
@@ -539,6 +540,8 @@ var types_PostHogPersistedProperty = /* @__PURE__ */ (function(PostHogPersistedP
   PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
   PostHogPersistedProperty["DistinctId"] = "distinct_id";
   PostHogPersistedProperty["Props"] = "props";
+  PostHogPersistedProperty["EnablePersonProcessing"] = "enable_person_processing";
+  PostHogPersistedProperty["PersonMode"] = "person_mode";
   PostHogPersistedProperty["FeatureFlagDetails"] = "feature_flag_details";
   PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
   PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
@@ -573,7 +576,7 @@ const isObject = (x) => x === Object(x) && !isArray(x);
 const isUndefined = (x) => void 0 === x;
 const isString = (x) => "[object String]" == type_utils_toString.call(x);
 const isEmptyString = (x) => isString(x) && 0 === x.trim().length;
-const isNumber = (x) => "[object Number]" == type_utils_toString.call(x);
+const isNumber = (x) => "[object Number]" == type_utils_toString.call(x) && x === x;
 const isPlainError = (x) => x instanceof Error;
 function isPrimitive(value) {
   return null === value || "object" != typeof value;
@@ -855,10 +858,11 @@ class PostHogCoreStateless {
     this.disableGeoip = options.disableGeoip ?? true;
     this.disabled = options.disabled ?? false;
     this.historicalMigration = options?.historicalMigration ?? false;
-    this.evaluationEnvironments = options?.evaluationEnvironments;
     this._initPromise = Promise.resolve();
     this._isInitialized = true;
     this._logger = createLogger("[PostHog]", this.logMsgIfDebug.bind(this));
+    this.evaluationContexts = options?.evaluationContexts ?? options?.evaluationEnvironments;
+    if (options?.evaluationEnvironments && !options?.evaluationContexts) this._logger.warn("evaluationEnvironments is deprecated. Use evaluationContexts instead. This property will be removed in a future version.");
     this.disableCompression = !isGzipSupported() || (options?.disableCompression ?? false);
   }
   logMsgIfDebug(fn) {
@@ -1033,7 +1037,7 @@ class PostHogCoreStateless {
       group_properties: groupProperties,
       ...extraPayload
     };
-    if (this.evaluationEnvironments && this.evaluationEnvironments.length > 0) requestData.evaluation_environments = this.evaluationEnvironments;
+    if (this.evaluationContexts && this.evaluationContexts.length > 0) requestData.evaluation_contexts = this.evaluationContexts;
     const fetchOptions = {
       method: "POST",
       headers: {
@@ -1045,10 +1049,35 @@ class PostHogCoreStateless {
     this._logger.info("Flags URL", url);
     return this.fetchWithRetry(url, fetchOptions, {
       retryCount: 0
-    }, this.featureFlagsRequestTimeoutMs).then((response) => response.json()).then((response) => normalizeFlagsResponse(response)).catch((error) => {
+    }, this.featureFlagsRequestTimeoutMs).then((response) => response.json()).then((response) => ({
+      success: true,
+      response: normalizeFlagsResponse(response)
+    })).catch((error) => {
       this._events.emit("error", error);
+      return {
+        success: false,
+        error: this.categorizeRequestError(error)
+      };
     });
   }
+  categorizeRequestError(error) {
+    if (error instanceof PostHogFetchHttpError) return {
+      type: "api_error",
+      statusCode: error.status
+    };
+    if (error instanceof PostHogFetchNetworkError) {
+      const cause = error.error;
+      if (cause instanceof Error && ("AbortError" === cause.name || "TimeoutError" === cause.name)) return {
+        type: "timeout"
+      };
+      return {
+        type: "connection_error"
+      };
+    }
+    return {
+      type: "unknown_error"
+    };
+  }
   async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
     await this._initPromise;
     const flagDetailResponse = await this.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
@@ -1115,8 +1144,9 @@ class PostHogCoreStateless {
     const extraPayload = {};
     if (disableGeoip ?? this.disableGeoip) extraPayload["geoip_disable"] = true;
     if (flagKeysToEvaluate) extraPayload["flag_keys_to_evaluate"] = flagKeysToEvaluate;
-    const flagsResponse = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
-    if (void 0 === flagsResponse) return;
+    const result = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
+    if (!result.success) return;
+    const flagsResponse = result.response;
     if (flagsResponse.errorsWhileComputingFlags) console.error("[FEATURE FLAGS] Error while computing feature flags, some flags may be missing or incorrect. Learn more at https://posthog.com/docs/feature-flags/best-practices");
     if (flagsResponse.quotaLimited?.includes("feature_flags")) {
       console.warn("[FEATURE FLAGS] Feature flags quota limit exceeded - feature flags unavailable. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts");
@@ -1183,10 +1213,17 @@ class PostHogCoreStateless {
       this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
     });
   }
+  processBeforeEnqueue(message) {
+    return message;
+  }
+  async flushStorage() {
+  }
   enqueue(type, _message, options) {
     this.wrap(() => {
       if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
-      const message = this.prepareMessage(type, _message, options);
+      let message = this.prepareMessage(type, _message, options);
+      message = this.processBeforeEnqueue(message);
+      if (null === message) return;
       const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
       if (queue.length >= this.maxQueueSize) {
         queue.shift();
@@ -1205,10 +1242,13 @@ class PostHogCoreStateless {
     if (this.disabled) return void this._logger.warn("The client is disabled");
     if (!this._isInitialized) await this._initPromise;
     if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
+    let message = this.prepareMessage(type, _message, options);
+    message = this.processBeforeEnqueue(message);
+    if (null === message) return;
     const data = {
       api_key: this.apiKey,
       batch: [
-        this.prepareMessage(type, _message, options)
+        message
       ],
       sent_at: currentISOTime()
     };
@@ -1293,11 +1333,12 @@ class PostHogCoreStateless {
     while (queue.length > 0 && sentMessages.length < originalQueueLength) {
       const batchItems = queue.slice(0, this.maxBatchSize);
       const batchMessages = batchItems.map((item) => item.message);
-      const persistQueueChange = () => {
+      const persistQueueChange = async () => {
         const refreshedQueue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
         const newQueue = refreshedQueue.slice(batchItems.length);
         this.setPersistedProperty(types_PostHogPersistedProperty.Queue, newQueue);
         queue = newQueue;
+        await this.flushStorage();
       };
       const data = {
         api_key: this.apiKey,
@@ -1333,11 +1374,11 @@ class PostHogCoreStateless {
           this._logger.warn(`Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`);
           continue;
         }
-        if (!(err instanceof PostHogFetchNetworkError)) persistQueueChange();
+        if (!(err instanceof PostHogFetchNetworkError)) await persistQueueChange();
         this._events.emit("error", err);
         throw err;
       }
-      persistQueueChange();
+      await persistQueueChange();
       sentMessages.push(...batchMessages);
     }
     this._events.emit("flush", sentMessages);
@@ -1462,7 +1503,7 @@ class ErrorPropertiesBuilder {
     };
     const coercingContext = this.buildCoercingContext(mechanism, hint, 0);
     const exceptionWithCause = coercingContext.apply(input);
-    const parsingContext = this.buildParsingContext();
+    const parsingContext = this.buildParsingContext(hint);
     const exceptionWithStack = this.parseStacktrace(exceptionWithCause, parsingContext);
     const exceptionList = this.convertToExceptionList(exceptionWithStack, mechanism);
     return {
@@ -1486,7 +1527,7 @@ class ErrorPropertiesBuilder {
     let cause;
     if (null != err.cause) cause = this.parseStacktrace(err.cause, ctx);
     let stack;
-    if ("" != err.stack && null != err.stack) stack = this.applyChunkIds(this.stackParser(err.stack, err.synthetic ? 1 : 0), ctx.chunkIdMap);
+    if ("" != err.stack && null != err.stack) stack = this.applyChunkIds(this.stackParser(err.stack, err.synthetic ? ctx.skipFirstLines : 0), ctx.chunkIdMap);
     return {
       ...err,
       cause,
@@ -1531,9 +1572,10 @@ class ErrorPropertiesBuilder {
     }));
     return exceptionList;
   }
-  buildParsingContext() {
+  buildParsingContext(hint) {
     const context = {
-      chunkIdMap: getFilenameToChunkIdMap(this.stackParser)
+      chunkIdMap: getFilenameToChunkIdMap(this.stackParser),
+      skipFirstLines: hint.skipFirstLines ?? 1
     };
     return context;
   }
@@ -2105,7 +2147,7 @@ class ErrorTracking {
     this._rateLimiter.stop();
   }
 }
-const version = "5.20.0";
+const version = "5.24.11";
 const FeatureFlagError = {
   ERRORS_WHILE_COMPUTING: "errors_while_computing_flags",
   FLAG_MISSING: "flag_missing",
@@ -2170,6 +2212,7 @@ class FeatureFlagsPoller {
     this.customHeaders = customHeaders;
     this.onLoad = options.onLoad;
     this.cacheProvider = options.cacheProvider;
+    this.strictLocalEvaluation = options.strictLocalEvaluation ?? false;
     this.loadFeatureFlags();
   }
   debug(enabled = true) {
@@ -2365,6 +2408,11 @@ class FeatureFlagsPoller {
     this.cohorts = flagData.cohorts;
     this.loadedSuccessfullyOnce = true;
   }
+  warnAboutExperienceContinuityFlags(flags) {
+    if (this.strictLocalEvaluation) return;
+    const experienceContinuityFlags = flags.filter((f) => f.ensure_experience_continuity);
+    if (experienceContinuityFlags.length > 0) console.warn(`[PostHog] You are using local evaluation but ${experienceContinuityFlags.length} flag(s) have experience continuity enabled: ${experienceContinuityFlags.map((f) => f.key).join(", ")}. Experience continuity is incompatible with local evaluation and will cause a server request on every flag evaluation, negating local evaluation cost savings. To avoid server requests and unexpected costs, either disable experience continuity on these flags in PostHog, use strictLocalEvaluation: true in client init, or pass onlyEvaluateLocally: true per flag call (flags that cannot be evaluated locally will return undefined).`);
+  }
   async loadFromCache(debugMessage) {
     if (!this.cacheProvider) return false;
     try {
@@ -2373,6 +2421,7 @@ class FeatureFlagsPoller {
         this.updateFlagState(cached);
         this.logMsgIfDebug(() => console.debug(`[FEATURE FLAGS] ${debugMessage} (${cached.flags.length} flags)`));
         this.onLoad?.(this.featureFlags.length);
+        this.warnAboutExperienceContinuityFlags(cached.flags);
         return true;
       }
       return false;
@@ -2466,6 +2515,7 @@ class FeatureFlagsPoller {
             this.onError?.(new Error(`Failed to store in cache: ${err}`));
           }
           this.onLoad?.(this.featureFlags.length);
+          this.warnAboutExperienceContinuityFlags(flagData.flags);
           break;
         }
         default:
@@ -2720,7 +2770,8 @@ class PostHogBackendClient extends PostHogCoreStateless {
           this._events.emit("localEvaluationFlagsLoaded", count);
         },
         customHeaders: this.getCustomHeaders(),
-        cacheProvider: options.flagDefinitionCacheProvider
+        cacheProvider: options.flagDefinitionCacheProvider,
+        strictLocalEvaluation: options.strictLocalEvaluation
       });
     }
     this.errorTracking = new ErrorTracking(this, options, this._logger);
@@ -2826,21 +2877,56 @@ class PostHogBackendClient extends PostHogCoreStateless {
       });
     });
   }
-  async getFeatureFlag(key, distinctId, options) {
-    if (void 0 !== this._flagOverrides && key in this._flagOverrides) return this._flagOverrides[key];
-    const { groups, disableGeoip } = options || {};
-    let { onlyEvaluateLocally, sendFeatureFlagEvents, personProperties, groupProperties } = options || {};
+  async _getFeatureFlagResult(key, distinctId, options = {}, matchValue) {
+    const sendFeatureFlagEvents = options.sendFeatureFlagEvents ?? true;
+    if (void 0 !== this._flagOverrides && key in this._flagOverrides) {
+      const overrideValue = this._flagOverrides[key];
+      if (void 0 === overrideValue) return;
+      const overridePayload = this._payloadOverrides?.[key];
+      return {
+        key,
+        enabled: false !== overrideValue,
+        variant: "string" == typeof overrideValue ? overrideValue : void 0,
+        payload: overridePayload
+      };
+    }
+    const { groups, disableGeoip } = options;
+    let { onlyEvaluateLocally, personProperties, groupProperties } = options;
     const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
     personProperties = adjustedProperties.allPersonProperties;
     groupProperties = adjustedProperties.allGroupProperties;
-    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
-    if (void 0 == sendFeatureFlagEvents) sendFeatureFlagEvents = this.options.sendFeatureFlagEvent ?? true;
-    let response = await this.featureFlagsPoller?.getFeatureFlag(key, distinctId, groups, personProperties, groupProperties);
-    const flagWasLocallyEvaluated = void 0 !== response;
+    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = this.options.strictLocalEvaluation ?? false;
+    let result;
+    let flagWasLocallyEvaluated = false;
     let requestId;
     let evaluatedAt;
-    let flagDetail;
     let featureFlagError;
+    let flagId;
+    let flagVersion;
+    let flagReason;
+    const localEvaluationEnabled = void 0 !== this.featureFlagsPoller;
+    if (localEvaluationEnabled) {
+      await this.featureFlagsPoller?.loadFeatureFlags();
+      const flag = this.featureFlagsPoller?.featureFlagsByKey[key];
+      if (flag) try {
+        const localResult = await this.featureFlagsPoller?.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, matchValue);
+        if (localResult) {
+          flagWasLocallyEvaluated = true;
+          const value = localResult.value;
+          flagId = flag.id;
+          flagReason = "Evaluated locally";
+          result = {
+            key,
+            enabled: false !== value,
+            variant: "string" == typeof value ? value : void 0,
+            payload: localResult.payload ?? void 0
+          };
+        }
+      } catch (e) {
+        if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this._logger?.info(`${e.name} when computing flag locally: ${key}: ${e.message}`);
+        else throw e;
+      }
+    }
     if (!flagWasLocallyEvaluated && !onlyEvaluateLocally) {
       const flagsResponse = await super.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [
         key
@@ -2852,68 +2938,87 @@ class PostHogBackendClient extends PostHogCoreStateless {
         const errors = [];
         if (flagsResponse.errorsWhileComputingFlags) errors.push(FeatureFlagError.ERRORS_WHILE_COMPUTING);
         if (flagsResponse.quotaLimited?.includes("feature_flags")) errors.push(FeatureFlagError.QUOTA_LIMITED);
-        flagDetail = flagsResponse.flags[key];
+        const flagDetail = flagsResponse.flags[key];
         if (void 0 === flagDetail) errors.push(FeatureFlagError.FLAG_MISSING);
+        else {
+          flagId = flagDetail.metadata?.id;
+          flagVersion = flagDetail.metadata?.version;
+          flagReason = flagDetail.reason?.description ?? flagDetail.reason?.code;
+          let parsedPayload;
+          if (flagDetail.metadata?.payload !== void 0) try {
+            parsedPayload = JSON.parse(flagDetail.metadata.payload);
+          } catch {
+            parsedPayload = flagDetail.metadata.payload;
+          }
+          result = {
+            key,
+            enabled: flagDetail.enabled,
+            variant: flagDetail.variant,
+            payload: parsedPayload
+          };
+        }
         if (errors.length > 0) featureFlagError = errors.join(",");
-        response = getFeatureFlagValue(flagDetail);
       }
     }
-    const featureFlagReportedKey = `${key}_${response}`;
-    if (sendFeatureFlagEvents && (!(distinctId in this.distinctIdHasSentFlagCalls) || !this.distinctIdHasSentFlagCalls[distinctId].includes(featureFlagReportedKey))) {
-      if (Object.keys(this.distinctIdHasSentFlagCalls).length >= this.maxCacheSize) this.distinctIdHasSentFlagCalls = {};
-      if (Array.isArray(this.distinctIdHasSentFlagCalls[distinctId])) this.distinctIdHasSentFlagCalls[distinctId].push(featureFlagReportedKey);
-      else this.distinctIdHasSentFlagCalls[distinctId] = [
-        featureFlagReportedKey
-      ];
-      const properties = {
-        $feature_flag: key,
-        $feature_flag_response: response,
-        $feature_flag_id: flagDetail?.metadata?.id,
-        $feature_flag_version: flagDetail?.metadata?.version,
-        $feature_flag_reason: flagDetail?.reason?.description ?? flagDetail?.reason?.code,
-        locally_evaluated: flagWasLocallyEvaluated,
-        [`$feature/${key}`]: response,
-        $feature_flag_request_id: requestId,
-        $feature_flag_evaluated_at: evaluatedAt
-      };
-      if (featureFlagError) properties.$feature_flag_error = featureFlagError;
-      this.capture({
-        distinctId,
-        event: "$feature_flag_called",
-        properties,
-        groups,
-        disableGeoip
-      });
+    if (sendFeatureFlagEvents) {
+      const response = void 0 === result ? void 0 : false === result.enabled ? false : result.variant ?? true;
+      const featureFlagReportedKey = `${key}_${response}`;
+      if (!(distinctId in this.distinctIdHasSentFlagCalls) || !this.distinctIdHasSentFlagCalls[distinctId].includes(featureFlagReportedKey)) {
+        if (Object.keys(this.distinctIdHasSentFlagCalls).length >= this.maxCacheSize) this.distinctIdHasSentFlagCalls = {};
+        if (Array.isArray(this.distinctIdHasSentFlagCalls[distinctId])) this.distinctIdHasSentFlagCalls[distinctId].push(featureFlagReportedKey);
+        else this.distinctIdHasSentFlagCalls[distinctId] = [
+          featureFlagReportedKey
+        ];
+        const properties = {
+          $feature_flag: key,
+          $feature_flag_response: response,
+          $feature_flag_id: flagId,
+          $feature_flag_version: flagVersion,
+          $feature_flag_reason: flagReason,
+          locally_evaluated: flagWasLocallyEvaluated,
+          [`$feature/${key}`]: response,
+          $feature_flag_request_id: requestId,
+          $feature_flag_evaluated_at: evaluatedAt
+        };
+        if (featureFlagError) properties.$feature_flag_error = featureFlagError;
+        this.capture({
+          distinctId,
+          event: "$feature_flag_called",
+          properties,
+          groups,
+          disableGeoip
+        });
+      }
     }
-    return response;
+    if (void 0 !== result && void 0 !== this._payloadOverrides && key in this._payloadOverrides) result = {
+      ...result,
+      payload: this._payloadOverrides[key]
+    };
+    return result;
+  }
+  async getFeatureFlag(key, distinctId, options) {
+    const result = await this._getFeatureFlagResult(key, distinctId, {
+      ...options,
+      sendFeatureFlagEvents: options?.sendFeatureFlagEvents ?? this.options.sendFeatureFlagEvent ?? true
+    });
+    if (void 0 === result) return;
+    if (false === result.enabled) return false;
+    return result.variant ?? true;
   }
   async getFeatureFlagPayload(key, distinctId, matchValue, options) {
     if (void 0 !== this._payloadOverrides && key in this._payloadOverrides) return this._payloadOverrides[key];
-    const { groups, disableGeoip } = options || {};
-    let { onlyEvaluateLocally, personProperties, groupProperties } = options || {};
-    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
-    personProperties = adjustedProperties.allPersonProperties;
-    groupProperties = adjustedProperties.allGroupProperties;
-    let response;
-    const localEvaluationEnabled = void 0 !== this.featureFlagsPoller;
-    if (localEvaluationEnabled) {
-      await this.featureFlagsPoller?.loadFeatureFlags();
-      const flag = this.featureFlagsPoller?.featureFlagsByKey[key];
-      if (flag) try {
-        const result = await this.featureFlagsPoller?.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, matchValue);
-        if (result) {
-          matchValue = result.value;
-          response = result.payload;
-        }
-      } catch (e) {
-        if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this._logger?.info(`${e.name} when computing flag locally: ${flag.key}: ${e.message}`);
-        else throw e;
-      }
-    }
-    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
-    const payloadWasLocallyEvaluated = void 0 !== response;
-    if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
-    return response;
+    const result = await this._getFeatureFlagResult(key, distinctId, {
+      ...options,
+      sendFeatureFlagEvents: false
+    }, matchValue);
+    if (void 0 === result) return;
+    return result.payload ?? null;
+  }
+  async getFeatureFlagResult(key, distinctId, options) {
+    return this._getFeatureFlagResult(key, distinctId, {
+      ...options,
+      sendFeatureFlagEvents: options?.sendFeatureFlagEvents ?? this.options.sendFeatureFlagEvent ?? true
+    });
   }
   async getRemoteConfigPayload(flagKey) {
     if (!this.options.personalApiKey) throw new Error("Personal API key is required for remote config payload decryption");
@@ -2941,7 +3046,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
     const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
     personProperties = adjustedProperties.allPersonProperties;
     groupProperties = adjustedProperties.allGroupProperties;
-    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
+    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = this.options.strictLocalEvaluation ?? false;
     const localEvaluationResult = await this.featureFlagsPoller?.getAllFlagsAndPayloads(distinctId, groups, personProperties, groupProperties, flagKeys);
     let featureFlags = {};
     let featureFlagPayloads = {};
@@ -3091,7 +3196,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
     const finalPersonProperties = sendFeatureFlagsOptions?.personProperties || {};
     const finalGroupProperties = sendFeatureFlagsOptions?.groupProperties || {};
     const flagKeys = sendFeatureFlagsOptions?.flagKeys;
-    const onlyEvaluateLocally = sendFeatureFlagsOptions?.onlyEvaluateLocally ?? false;
+    const onlyEvaluateLocally = sendFeatureFlagsOptions?.onlyEvaluateLocally ?? this.options.strictLocalEvaluation ?? false;
     if (onlyEvaluateLocally) if (!((this.featureFlagsPoller?.featureFlags?.length || 0) > 0)) return {};
     else {
       const groupsWithStringValues = {};
@@ -4319,6 +4424,142 @@ async function applyRouteLoaders(req, dataRoutes) {
     statusCode
   };
 }
+const DEFAULT_MAX_QUERIES = 32;
+const DEFAULT_MAX_DOCS_PER_QUERY = 500;
+const DEFAULT_MAX_SERIALIZED_BYTES = 200 * 1024;
+const makeRegistrationKey = (modelName, queryKey) => `${modelName}.${queryKey}`;
+const hasSessionUser = (req) => {
+  const id = req.session?.user?.id;
+  return typeof id === "string" && id.trim().length > 0;
+};
+const escapeForInlineScript = (value) => {
+  return value.replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+};
+const createRtsSsrCollector = (req, opts) => {
+  const maxQueries = DEFAULT_MAX_QUERIES;
+  const maxDocsPerQuery = DEFAULT_MAX_DOCS_PER_QUERY;
+  const maxSerializedBytes = DEFAULT_MAX_SERIALIZED_BYTES;
+  const registrations = /* @__PURE__ */ new Map();
+  const resolved = /* @__PURE__ */ new Map();
+  const runtime = {
+    registerQuery(query) {
+      const modelName = typeof query.modelName === "string" ? query.modelName.trim() : "";
+      const queryKey = typeof query.queryKey === "string" ? query.queryKey.trim() : "";
+      if (!modelName || !queryKey) return;
+      const key = makeRegistrationKey(modelName, queryKey);
+      if (registrations.has(key)) return;
+      if (registrations.size >= maxQueries) return;
+      registrations.set(key, {
+        modelName,
+        queryKey,
+        query: query.query ?? {},
+        options: query.options ?? {}
+      });
+    },
+    getQueryData(modelName, queryKey) {
+      return resolved.get(makeRegistrationKey(modelName, queryKey));
+    }
+  };
+  const resolve = async () => {
+    if (!registrations.size) return null;
+    const tenantId = resolveRtsRequestTenantId(req);
+    if (!tenantId) return null;
+    if (hasSessionUser(req) && !isRtsRequestAuthorized(req, tenantId)) {
+      return null;
+    }
+    const { ability, userId } = await buildRtsAbilityFromRequest(req, tenantId);
+    const queryEntries = [];
+    for (const registration of registrations.values()) {
+      const options = normalizeRtsQueryOptions(registration.options);
+      try {
+        const data = await runRtsQuery({
+          tenantId,
+          ability,
+          modelName: registration.modelName,
+          query: registration.query,
+          options
+        });
+        const boundedData = maxDocsPerQuery > 0 ? data.slice(0, maxDocsPerQuery) : data;
+        queryEntries.push({
+          modelName: registration.modelName,
+          queryKey: registration.queryKey,
+          data: boundedData
+        });
+      } catch {
+        continue;
+      }
+    }
+    if (!queryEntries.length) return null;
+    const payload = {
+      v: 1,
+      tenantId,
+      uid: userId,
+      queries: []
+    };
+    for (const entry of queryEntries) {
+      payload.queries.push(entry);
+      const bytes = Buffer.byteLength(JSON.stringify(payload), "utf8");
+      if (bytes > maxSerializedBytes) {
+        payload.queries.pop();
+        break;
+      }
+    }
+    resolved.clear();
+    for (const entry of payload.queries) {
+      resolved.set(makeRegistrationKey(entry.modelName, entry.queryKey), entry.data);
+    }
+    return payload.queries.length ? payload : null;
+  };
+  const hasRegistrations = () => registrations.size > 0;
+  return { runtime, hasRegistrations, resolve };
+};
+const renderRtsHydrationScript = (data) => {
+  if (!data) return "";
+  const serialized = escapeForInlineScript(JSON.stringify(data));
+  return `<script>window.${STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY}=${serialized};<\/script>`;
+};
+const RTS_SSR_PREPASS_TIMEOUT_MS = 4e3;
+const runRtsPrepass = async (element) => {
+  return await new Promise((resolve) => {
+    let isDone = false;
+    let timeoutId = null;
+    const finish = (ok) => {
+      if (isDone) return;
+      isDone = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      resolve(ok);
+    };
+    const sink = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      }
+    });
+    sink.on("finish", () => {
+      finish(true);
+    });
+    sink.on("error", () => {
+      finish(false);
+    });
+    const { pipe, abort } = renderToPipeableStream(element, {
+      onAllReady() {
+        if (isDone) return;
+        pipe(sink);
+      },
+      onShellError() {
+        finish(false);
+        abort();
+      },
+      onError() {
+      }
+    });
+    timeoutId = setTimeout(() => {
+      abort();
+      finish(false);
+    }, RTS_SSR_PREPASS_TIMEOUT_MS);
+  });
+};
 async function renderSSR(req, dataRoutes) {
   const routerContext = await applyRouteLoaders(req, dataRoutes);
   const isMatched = routerContext.matches.length > 0;
@@ -4329,7 +4570,8 @@ async function renderSSR(req, dataRoutes) {
       statusCode: routerContext.statusCode ?? routerContext.redirectResponse.status ?? 302,
       redirectResponse: routerContext.redirectResponse,
       redirectRouteId: routerContext.redirectRouteId,
-      redirectRoutePath: routerContext.redirectRoutePath
+      redirectRoutePath: routerContext.redirectRoutePath,
+      rtsHydrationData: null
     };
   }
   if (routerContext.errors) {
@@ -4364,18 +4606,34 @@ async function renderSSR(req, dataRoutes) {
       throw error;
     }
   }
-  const router = createStaticRouter(dataRoutes, routerContext);
-  const element = /* @__PURE__ */ jsx(StrictMode, { children: /* @__PURE__ */ jsx(
-    StaticRouterProvider,
-    {
-      router,
-      context: routerContext
+  const buildElement = (runtime2) => {
+    const router = createStaticRouter(dataRoutes, routerContext);
+    const app = /* @__PURE__ */ jsx(
+      StaticRouterProvider,
+      {
+        router,
+        context: routerContext
+      }
+    );
+    return /* @__PURE__ */ jsx(StrictMode, { children: runtime2 ? /* @__PURE__ */ jsx(RtsSsrRuntimeProvider, { value: runtime2, children: app }) : app });
+  };
+  const tenantId = resolveRtsRequestTenantId(req);
+  let rtsHydrationData = null;
+  let runtime = null;
+  if (tenantId) {
+    const collector = createRtsSsrCollector(req);
+    const prepassOk = await runRtsPrepass(buildElement(collector.runtime));
+    if (prepassOk && collector.hasRegistrations()) {
+      rtsHydrationData = await collector.resolve();
     }
-  ) });
+    runtime = collector.runtime;
+  }
+  const element = buildElement(runtime);
   return {
     element,
     isMatched,
-    statusCode: routerContext.statusCode ?? (routerContext.errors ? 500 : 200)
+    statusCode: routerContext.statusCode ?? (routerContext.errors ? 500 : 200),
+    rtsHydrationData
   };
 }
 const ABORT_DELAY_MS = 1e4;
@@ -4526,6 +4784,7 @@ const ssrMiddleware = ({
       element,
       isMatched,
       statusCode,
+      rtsHydrationData,
       redirectResponse,
       redirectRouteId,
       redirectRoutePath
@@ -4593,9 +4852,10 @@ const ssrMiddleware = ({
           });
           const start = htmlStart;
           const end = htmlEnd;
+          const rtsHydrationScript = renderRtsHydrationScript(rtsHydrationData);
           res.write(start);
           transformStream.on("finish", () => {
-            res.end(end);
+            res.end(`${rtsHydrationScript}${end}`);
           });
           pipe(transformStream);
         }