@replohq/sandbox-runtime 0.1.0

package/_vendor/replo-utils/lib/fonts.mjs

@@ -0,0 +1,221 @@
+import { Symbol_default, isArray_default, isObjectLike_default, baseGetTag_default } from '../../../chunk-FNTGY7I5.mjs';
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_arrayMap.js
+function arrayMap(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+var arrayMap_default = arrayMap;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isSymbol.js
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
+}
+var isSymbol_default = isSymbol;
+var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
+var symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray_default(value)) {
+    return arrayMap_default(value, baseToString) + "";
+  }
+  if (isSymbol_default(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
+}
+var baseToString_default = baseToString;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/toString.js
+function toString(value) {
+  return value == null ? "" : baseToString_default(value);
+}
+var toString_default = toString;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseSlice.js
+function baseSlice(array, start, end) {
+  var index = -1, length = array.length;
+  if (start < 0) {
+    start = -start > length ? 0 : length + start;
+  }
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : end - start >>> 0;
+  start >>>= 0;
+  var result = Array(length);
+  while (++index < length) {
+    result[index] = array[index + start];
+  }
+  return result;
+}
+var baseSlice_default = baseSlice;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_castSlice.js
+function castSlice(array, start, end) {
+  var length = array.length;
+  end = end === void 0 ? length : end;
+  return !start && end >= length ? array : baseSlice_default(array, start, end);
+}
+var castSlice_default = castSlice;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_hasUnicode.js
+var rsAstralRange = "\\ud800-\\udfff";
+var rsComboMarksRange = "\\u0300-\\u036f";
+var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
+var rsComboSymbolsRange = "\\u20d0-\\u20ff";
+var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
+var rsVarRange = "\\ufe0e\\ufe0f";
+var rsZWJ = "\\u200d";
+var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
+function hasUnicode(string) {
+  return reHasUnicode.test(string);
+}
+var hasUnicode_default = hasUnicode;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_asciiToArray.js
+function asciiToArray(string) {
+  return string.split("");
+}
+var asciiToArray_default = asciiToArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_unicodeToArray.js
+var rsAstralRange2 = "\\ud800-\\udfff";
+var rsComboMarksRange2 = "\\u0300-\\u036f";
+var reComboHalfMarksRange2 = "\\ufe20-\\ufe2f";
+var rsComboSymbolsRange2 = "\\u20d0-\\u20ff";
+var rsComboRange2 = rsComboMarksRange2 + reComboHalfMarksRange2 + rsComboSymbolsRange2;
+var rsVarRange2 = "\\ufe0e\\ufe0f";
+var rsAstral = "[" + rsAstralRange2 + "]";
+var rsCombo = "[" + rsComboRange2 + "]";
+var rsFitz = "\\ud83c[\\udffb-\\udfff]";
+var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
+var rsNonAstral = "[^" + rsAstralRange2 + "]";
+var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
+var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
+var rsZWJ2 = "\\u200d";
+var reOptMod = rsModifier + "?";
+var rsOptVar = "[" + rsVarRange2 + "]?";
+var rsOptJoin = "(?:" + rsZWJ2 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
+var rsSeq = rsOptVar + reOptMod + rsOptJoin;
+var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
+var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+function unicodeToArray(string) {
+  return string.match(reUnicode) || [];
+}
+var unicodeToArray_default = unicodeToArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_stringToArray.js
+function stringToArray(string) {
+  return hasUnicode_default(string) ? unicodeToArray_default(string) : asciiToArray_default(string);
+}
+var stringToArray_default = stringToArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_createCaseFirst.js
+function createCaseFirst(methodName) {
+  return function(string) {
+    string = toString_default(string);
+    var strSymbols = hasUnicode_default(string) ? stringToArray_default(string) : void 0;
+    var chr = strSymbols ? strSymbols[0] : string.charAt(0);
+    var trailing = strSymbols ? castSlice_default(strSymbols, 1).join("") : string.slice(1);
+    return chr[methodName]() + trailing;
+  };
+}
+var createCaseFirst_default = createCaseFirst;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/upperFirst.js
+var upperFirst = createCaseFirst_default("toUpperCase");
+var upperFirst_default = upperFirst;
+
+// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/capitalize.js
+function capitalize(string) {
+  return upperFirst_default(toString_default(string).toLowerCase());
+}
+var capitalize_default = capitalize;
+
+// ../replo-utils/lib/fonts.ts
+function slugifyFontFamily(family) {
+  return family.replace(/([a-z])([A-Z])/g, "$1-$2").split(/[\s_-]+/u).map((word) => word.toLowerCase()).join("-");
+}
+function fontNameToCssVariable(fontName) {
+  return `--font-${slugifyFontFamily(fontName)}`;
+}
+function quoteFontFamily(family) {
+  return /\s/u.test(family) ? `'${family}'` : family;
+}
+function fontNameToVariableName(fontName) {
+  const words = fontName.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[\s_-]+/u);
+  return words.map((word, index) => {
+    return index === 0 ? word.toLowerCase() : capitalize_default(word);
+  }).join("");
+}
+function buildGoogleFontsCssUrl(family, weights) {
+  const requested = weights && weights.length > 0 ? Array.from(new Set(weights)) : [400];
+  const sortedWeights = requested.sort(
+    (leftWeight, rightWeight) => leftWeight - rightWeight
+  );
+  const familyParam = family.trim().replace(/\s+/gu, "+");
+  return `https://fonts.googleapis.com/css2?family=${familyParam}:wght@${sortedWeights.join(
+    ";"
+  )}&display=swap`;
+}
+var FONT_MIME_BY_EXTENSION = {
+  woff2: "font/woff2",
+  woff: "font/woff",
+  ttf: "font/ttf",
+  otf: "font/otf"
+};
+function describeFontFile(fileName) {
+  const lastDot = fileName.lastIndexOf(".");
+  const base = lastDot > 0 ? fileName.slice(0, lastDot) : fileName;
+  const extension = lastDot > 0 ? fileName.slice(lastDot + 1).toLowerCase() : "";
+  const family = base.replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").trim() || "Custom font";
+  return {
+    family,
+    mimeType: FONT_MIME_BY_EXTENSION[extension] ?? "font/woff2"
+  };
+}
+function fontFormatFromExtension(extension) {
+  const normalized = extension.toLowerCase().replace(/^\./u, "");
+  if (normalized === "woff2") return "woff2";
+  if (normalized === "woff") return "woff";
+  if (normalized === "otf") return "opentype";
+  if (normalized === "ttf") return "truetype";
+  return "woff2";
+}
+function fontFormatFromMimeType(mimeType) {
+  const normalized = mimeType.toLowerCase();
+  if (normalized.includes("woff2")) return "woff2";
+  if (normalized.includes("woff")) return "woff";
+  if (normalized.includes("otf") || normalized.includes("opentype")) {
+    return "opentype";
+  }
+  if (normalized.includes("ttf") || normalized.includes("truetype")) {
+    return "truetype";
+  }
+  return "woff2";
+}
+function escapeCssString(value) {
+  return value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"');
+}
+function buildFontFaceCss({
+  family,
+  faceUrl,
+  format,
+  weight = 400
+}) {
+  return `@font-face{font-family:"${escapeCssString(family)}";font-weight:${weight};font-style:normal;src:url("${escapeCssString(faceUrl)}") format("${escapeCssString(format)}");font-display:swap;}`;
+}
+var escapeFontFamilyName = (fontFamily) => {
+  return fontFamily.replace(/"/g, '\\"').replace(/'/g, "\\'");
+};
+
+export { buildFontFaceCss, buildGoogleFontsCssUrl, describeFontFile, escapeFontFamilyName, fontFormatFromExtension, fontFormatFromMimeType, fontNameToCssVariable, fontNameToVariableName, quoteFontFamily, slugifyFontFamily };

package/_vendor/replo-utils/lib/geometry.d.ts

@@ -0,0 +1,18 @@
+export type GeometryRect = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+/**
+ * Whether two axis-aligned rects overlap. `tolerance` expands the test
+ * rect on every side, so rects that fall a few pixels short of touching
+ * (sub-pixel rendering, borders) still count as intersecting.
+ */
+export declare function isIntersecting(targetRect: GeometryRect, destinationRect: GeometryRect, { tolerance }?: {
+    tolerance?: number;
+}): boolean;
+/**
+ * Whether `targetRect` wholly contains `testRect`.
+ */
+export declare function isRectEnclosing(targetRect: GeometryRect, testRect: GeometryRect): boolean;

package/_vendor/replo-utils/lib/geometry.mjs

@@ -0,0 +1,9 @@
+// ../replo-utils/lib/geometry.ts
+function isIntersecting(targetRect, destinationRect, { tolerance = 0 } = {}) {
+  return targetRect.left <= destinationRect.right + tolerance && targetRect.right >= destinationRect.left - tolerance && targetRect.top <= destinationRect.bottom + tolerance && targetRect.bottom >= destinationRect.top - tolerance;
+}
+function isRectEnclosing(targetRect, testRect) {
+  return targetRect.left <= testRect.left && targetRect.right >= testRect.right && targetRect.top <= testRect.top && targetRect.bottom >= testRect.bottom;
+}
+
+export { isIntersecting, isRectEnclosing };

package/_vendor/replo-utils/lib/json.d.ts

@@ -0,0 +1,6 @@
+export declare function parseJsonOrNull(json: string): unknown | null;
+export declare function omitJsonObjectFieldsOrNull({ json, fields, }: {
+    json: string;
+    fields: string[];
+}): string | null;
+export declare function jsonStringifyOrNull(value: unknown): string | null;

package/_vendor/replo-utils/lib/log.d.ts

@@ -0,0 +1,11 @@
+export type Logger = {
+    info: Console["log"];
+    debug: Console["debug"];
+    error: Console["error"];
+};
+export declare const defaultLogger: Logger;
+/**
+ * Silent logger, mostly useful for testing cases where you may not want
+ * a service logging out errors that you're expecting.
+ */
+export declare const noOpLogger: Logger;

package/_vendor/replo-utils/lib/misc.d.ts

@@ -0,0 +1,145 @@
+import isFunction from "lodash-es/isFunction";
+import isNumber from "lodash-es/isNumber";
+import isString from "lodash-es/isString";
+export { isFunction, isNumber, isString };
+/**
+ * Checks if a value is neither `null` nor `undefined`.
+ */
+export declare function isNotNullish<ValueType>(value: ValueType): value is Exclude<ValueType, null | undefined>;
+/**
+ * Checks if a value is either `null` or `undefined`.
+ */
+export declare function isNullish(value: unknown): value is null | undefined;
+export declare function getFromRecordOrNull<RecordKey extends PropertyKey, RecordValue>(record: Record<RecordKey, RecordValue> | null | undefined, key: RecordKey | undefined | null): NonNullable<Record<RecordKey, RecordValue>[RecordKey]> | null;
+export declare function isPrimitive(value: unknown): value is string | number | boolean;
+type StructureRecord<UnionType extends {
+    type: string;
+}, ResultType> = {
+    [MemberType in UnionType as MemberType["type"]]: ResultType | ((value: MemberType) => ResultType);
+};
+type StructureRecordBareString<UnionType extends string, ResultType> = {
+    [MemberType in UnionType]: ResultType | ((value: MemberType) => ResultType);
+};
+type StructureRecordGeneric<UnionType extends Record<KeyType, string>, ResultType, KeyType extends keyof UnionType> = {
+    [MemberType in UnionType as MemberType[KeyType]]: ResultType | ((value: MemberType) => ResultType);
+};
+/**
+ * @returns A function which can be used to create an exhaustive switch over all
+ * types of a discriminated union, based on a given key, or over all members of
+ * a bare string union.
+ *
+ * When no key is provided, it defaults to using "type" as the discriminant.
+ * When the value is a bare string union, the value is its own discriminant.
+ *
+ * Examples:
+ *
+ * With default "type" discriminant:
+ * ```
+ * type OneOrTwo = { type: "one", numberValue: number } |
+ * { type: "two", stringValue: string }
+ *
+ * let oneOrTwo = ...
+ * let result = exhaustiveSwitch(oneOrTwo)({
+ * one: (op) => `${op.numberValue + 1}`, // Typescript knows numberValue is a number
+ * two: (op) => op.stringValue + "hello", // Typescript knows stringValue is a string
+ * }) // type of result is inferred to be string
+ * ```
+ *
+ * With custom discriminant key:
+ * ```
+ * type OneOrTwo = { variant: "one", numberValue: number } |
+ * { variant: "two", stringValue: string }
+ *
+ * let oneOrTwo = ...
+ * let result = exhaustiveSwitch(oneOrTwo, "variant")({
+ * one: (op) => `${op.numberValue + 1}`, // Typescript knows numberValue is a number
+ * two: (op) => op.stringValue + "hello", // Typescript knows stringValue is a string
+ * }) // type of result is inferred to be string
+ * ```
+ *
+ * With a bare string union:
+ * ```
+ * type OneOrTwo = "one" | "two"
+ *
+ * let oneOrTwo = ...
+ * let result = exhaustiveSwitch(oneOrTwo)({
+ * one: 1, // cases can be plain values...
+ * two: () => 1 + 1, // ...or functions, evaluated lazily
+ * }) // type of result is inferred to be number
+ * ```
+ *
+ * Typescript will error if you forget a case, or if you assume the wrong type
+ * for a case value. The switch also returns the value you return from the
+ * function mapping, so it works well for "extension" methods where you want to
+ * map over all discriminated union cases and do a different thing for each.
+ *
+ * Works well for many of our types, like ComponentActionType, Action, etc
+ */
+export declare function exhaustiveSwitch<UnionType extends string>(value: UnionType): <ResultType>(cases: StructureRecordBareString<UnionType, ResultType>) => ResultType;
+export declare function exhaustiveSwitch<UnionType extends {
+    type: string;
+}>(value: UnionType): <ResultType>(cases: StructureRecord<UnionType, ResultType>) => ResultType;
+export declare function exhaustiveSwitch<UnionType extends Record<KeyType, string>, KeyType extends keyof UnionType>(value: UnionType, key: KeyType): <ResultType>(cases: StructureRecordGeneric<UnionType, ResultType, KeyType>) => ResultType;
+type EmptyObject<ValueType> = {
+    [KeyType in keyof ValueType]?: never;
+};
+type EmptyObjectOf<ValueType> = EmptyObject<ValueType> extends ValueType ? EmptyObject<ValueType> : never;
+/**
+ * The same as `isEmpty` from lodash, but with a few additional overloads for
+ * stronger type-checking on empty arrays.
+ */
+export declare function isEmpty(value: string): value is "";
+export declare function isEmpty<ValueType extends any[]>(value: ValueType | null | undefined): value is (ValueType & []) | null | undefined;
+export declare function isEmpty<ValueType extends ArrayLike<any>>(value: ValueType | null | undefined): value is (ValueType & {
+    length: 0;
+}) | null | undefined;
+export declare function isEmpty(value: Map<any, any> | Set<any> | ArrayLike<any> | null | undefined): boolean;
+export declare function isEmpty(value: object): boolean;
+export declare function isEmpty<ValueType extends object>(value: ValueType | null | undefined): value is EmptyObjectOf<ValueType> | null | undefined;
+export declare function isEmpty(value?: any): boolean;
+export declare function noop(): void;
+export declare function preventDefault(event: {
+    preventDefault(): void;
+}): void;
+/**
+ * Copyright (c) 2019 Alexander Reardon
+ * https://github.com/alexreardon/tiny-warning/blob/master/src/index.js
+ */
+export declare function warning(condition: unknown, message: string | (() => string), options?: {
+    severity: "log" | "warn" | "error";
+}): void;
+/**
+ *
+ * Copyright (c) 2019 Alexander Reardon
+ * https://github.com/alexreardon/tiny-warning/blob/master/src/index.js
+ */
+export declare function invariant(condition: unknown, message: string | (() => string), opts?: {
+    stripErrorMessage: unknown;
+}): asserts condition;
+export declare const mergeReplacingObjects: (first: Object, second: Object) => void;
+export declare const mergeReplacingArrays: (first: Object, second: Object) => void;
+export declare const deepCloneAndMergeReplacingArrays: <ValueType>(source: ValueType, ...toMerge: Object[]) => ValueType;
+/**
+ * hasOwnProperty with a type assertion. If this returns true, typescript knows that `obj`
+ * has a property called `prop` from that point forward
+ * https://fettblog.eu/typescript-hasownproperty/
+ */
+export declare function hasOwnProperty<ObjectType extends {} | null | undefined, KeyType extends PropertyKey>(obj: ObjectType, prop: KeyType): obj is ObjectType & Record<KeyType, unknown>;
+/**
+ * Given a string | number param, converts it to a string, unless it's nullish
+ * in which case it just returns it. Useful for times when you have string | number
+ * | nullish types, like when selecting the current value of a CSS property in a right
+ * bar modifier
+ */
+export declare function coerceNumberToString(value: string | number): string;
+export declare function coerceNumberToString(value: string | number | null | undefined): string | null | undefined;
+export declare function coerceNumberToString(value: string | number | undefined): string | undefined;
+export declare function coerceNumberToString(value: string | number | null): string | null;
+/**
+ * Formats a file size in bytes to a human readable string with appropriate
+ * units. Rounds to 0 decimal places unless otherwise specified and uses
+ * standard binary units (KB, MB, etc).
+ */
+export declare function formatFileSize(byteCount: number, decimalPlaces?: number): string;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare function errorMessage(error: unknown): string;

package/_vendor/replo-utils/lib/misc.mjs

@@ -0,0 +1,2 @@
+export { coerceNumberToString, deepCloneAndMergeReplacingArrays, errorMessage, exhaustiveSwitch, formatFileSize, getFromRecordOrNull, hasOwnProperty, invariant, isEmpty, isFunction_default as isFunction, isNotNullish, isNullish, isNumber_default as isNumber, isPrimitive, isString_default as isString, mergeReplacingArrays, mergeReplacingObjects, noop, preventDefault, sleep, warning } from '../../../chunk-N5EI2MOZ.mjs';
+import '../../../chunk-FNTGY7I5.mjs';

package/_vendor/replo-utils/lib/object.d.ts

@@ -0,0 +1,31 @@
+import { dequal as dequalLite } from "dequal/lite";
+interface ForEachPrimitiveValueArgs {
+    target: Record<string, any> | unknown[] | null;
+    fn: (value: unknown, key: string, newTarget: Record<string, any>) => void;
+    valueConversionFunction?: (transformValue: Record<string, any> | unknown[]) => Record<string, any> | unknown[];
+}
+/** There's probably a bug somewhere here since it assumes target is initially an object */
+export declare function forEachPrimitiveValue({ target, fn, valueConversionFunction, }: ForEachPrimitiveValueArgs): void;
+export declare function shallowEqual(objA: unknown, objB: unknown): boolean;
+/**
+ * Internally we use `dequal` for deep equality checks. It benchmarks faster
+ * than lodash and most other libraries.
+ *
+ * This function is an alias for `dequal`'s "lite" module. It does not check
+ * equality for `Map` or `Set` values. If you need to compare those, use
+ * `deepEqualHeavy`.
+ *
+ * @see https://github.com/lukeed/dequal#modes
+ */
+export declare const deepEqual: typeof dequalLite;
+/**
+ * Creates a new object with specified keys omitted.
+ *
+ * @param obj - The source object
+ * @param keysToOmit - Array of keys to omit from the result
+ * @returns A new object without the specified keys
+ */
+export declare function omit<ObjectType extends Record<string, any>, KeyType extends keyof ObjectType>(obj: ObjectType, keysToOmit: KeyType[]): Omit<ObjectType, KeyType>;
+export declare function filterUndefined<ObjectType extends Record<string, unknown>>(data: ObjectType): Partial<ObjectType>;
+export declare function toNullableIfDefined<ValueType>(value: ValueType | undefined): ValueType | null | undefined;
+export {};

package/_vendor/replo-utils/lib/parse.d.ts

@@ -0,0 +1,15 @@
+import type { z } from "zod";
+/**
+ * Parse a value using the zod schema, or default. This is useful when parsing build-time
+ * environmental variables that need to be access via the full object path, like
+ * `process.env.COMMIT`.
+ */
+export declare function parseOrDefault<SchemaType extends z.ZodType<any, any>>(value: string | undefined, schema: SchemaType, defaultValue: z.infer<SchemaType>): z.infer<SchemaType>;
+/**
+ * Parse an arbitrary value using the zod schema, returning `null` on
+ * failure. Use this for the common pattern of validating untrusted
+ * runtime data (postMessage payloads, JSON strings parsed out of DOM
+ * attributes, etc.) where the caller doesn't care *why* parsing failed
+ * — they just want the typed value or nothing.
+ */
+export declare function parseSchemaOrNull<SchemaType extends z.ZodType<any, any>>(value: unknown, schema: SchemaType): z.infer<SchemaType> | null;

package/_vendor/replo-utils/lib/posthogReplay.d.ts

@@ -0,0 +1,43 @@
+export declare const POSTHOG_REPLAY_SNAPSHOT_REQUEST = "posthog:replay:request-full-snapshot";
+interface PostHogRrweb {
+    record: {
+        takeFullSnapshot?: () => void;
+    };
+}
+type PostHogReplayMessageListener = (event: {
+    data: unknown;
+    source: unknown;
+}) => void;
+interface PostHogReplayWindow {
+    readonly parent: unknown;
+    readonly frames: ArrayLike<{
+        postMessage: (message: string, targetOrigin: string) => void;
+    }>;
+    readonly __PosthogExtensions__?: {
+        rrweb?: PostHogRrweb;
+    };
+    addEventListener(type: "message", listener: PostHogReplayMessageListener): void;
+    removeEventListener(type: "message", listener: PostHogReplayMessageListener): void;
+    setTimeout(listener: () => void, timeout: number): number;
+    clearTimeout(timeoutId: number): void;
+}
+declare global {
+    interface Window {
+        __PosthogExtensions__?: {
+            rrweb?: PostHogRrweb;
+        };
+    }
+}
+export declare function requestChildPostHogReplaySnapshots({ targetWindow, }: {
+    targetWindow: PostHogReplayWindow;
+}): void;
+export declare function startPostHogReplaySnapshotCascade({ isRecordingStarted, targetWindow, onReady, }: {
+    isRecordingStarted: () => boolean;
+    targetWindow: PostHogReplayWindow;
+    onReady?: () => void;
+}): () => void;
+export declare function startChildPostHogReplaySnapshotRelay({ isRecordingStarted, targetWindow, }: {
+    isRecordingStarted: () => boolean;
+    targetWindow: PostHogReplayWindow;
+}): () => void;
+export {};

package/_vendor/replo-utils/lib/posthogReplay.mjs

@@ -0,0 +1,121 @@
+// ../replo-utils/lib/posthogReplay.ts
+var POSTHOG_REPLAY_SNAPSHOT_REQUEST = "posthog:replay:request-full-snapshot";
+var POSTHOG_REPLAY_READY_POLL_INTERVAL_MS = 100;
+var POSTHOG_REPLAY_READY_POLL_TIMEOUT_MS = 1e4;
+function requestChildPostHogReplaySnapshots({
+  targetWindow
+}) {
+  for (let frameIndex = 0; frameIndex < targetWindow.frames.length; frameIndex++) {
+    targetWindow.frames[frameIndex]?.postMessage(
+      POSTHOG_REPLAY_SNAPSHOT_REQUEST,
+      "*"
+    );
+  }
+}
+function takePostHogReplayFullSnapshot({
+  isRecordingStarted,
+  targetWindow
+}) {
+  if (!isRecordingStarted()) {
+    return false;
+  }
+  const takeFullSnapshot = targetWindow.__PosthogExtensions__?.rrweb?.record.takeFullSnapshot;
+  if (!takeFullSnapshot) {
+    return false;
+  }
+  try {
+    takeFullSnapshot();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function startPostHogReplaySnapshotCascade({
+  isRecordingStarted,
+  targetWindow,
+  onReady
+}) {
+  const replayReadyPollDeadline = Date.now() + POSTHOG_REPLAY_READY_POLL_TIMEOUT_MS;
+  let timeoutId;
+  let stopCascading;
+  const startCascadingWhenReady = () => {
+    const record = targetWindow.__PosthogExtensions__?.rrweb?.record;
+    const takeFullSnapshot = record?.takeFullSnapshot;
+    if (!record || !takeFullSnapshot || !isRecordingStarted()) {
+      if (Date.now() < replayReadyPollDeadline) {
+        timeoutId = targetWindow.setTimeout(
+          startCascadingWhenReady,
+          POSTHOG_REPLAY_READY_POLL_INTERVAL_MS
+        );
+      }
+      return;
+    }
+    const takeFullSnapshotAndCascade = () => {
+      takeFullSnapshot();
+      requestChildPostHogReplaySnapshots({ targetWindow });
+    };
+    record.takeFullSnapshot = takeFullSnapshotAndCascade;
+    stopCascading = () => {
+      if (record.takeFullSnapshot === takeFullSnapshotAndCascade) {
+        record.takeFullSnapshot = takeFullSnapshot;
+      }
+    };
+    onReady?.();
+  };
+  startCascadingWhenReady();
+  return () => {
+    if (timeoutId !== void 0) {
+      targetWindow.clearTimeout(timeoutId);
+    }
+    stopCascading?.();
+  };
+}
+function startChildPostHogReplaySnapshotRelay({
+  isRecordingStarted,
+  targetWindow
+}) {
+  if (targetWindow.parent === targetWindow) {
+    return () => {
+    };
+  }
+  let hasPendingSnapshotRequest = false;
+  let isSnapshotCascadeReady = false;
+  let stopCascadingSnapshots = () => {
+  };
+  const startCascadingSnapshots = () => {
+    stopCascadingSnapshots();
+    isSnapshotCascadeReady = false;
+    stopCascadingSnapshots = startPostHogReplaySnapshotCascade({
+      isRecordingStarted,
+      targetWindow,
+      onReady: () => {
+        isSnapshotCascadeReady = true;
+        if (hasPendingSnapshotRequest) {
+          hasPendingSnapshotRequest = false;
+          takePostHogReplayFullSnapshot({ isRecordingStarted, targetWindow });
+        }
+      }
+    });
+  };
+  startCascadingSnapshots();
+  const onMessage = (event) => {
+    if (event.source !== targetWindow.parent || event.data !== POSTHOG_REPLAY_SNAPSHOT_REQUEST) {
+      return;
+    }
+    if (!takePostHogReplayFullSnapshot({ isRecordingStarted, targetWindow })) {
+      hasPendingSnapshotRequest = true;
+      startCascadingSnapshots();
+      return;
+    }
+    if (!isSnapshotCascadeReady) {
+      requestChildPostHogReplaySnapshots({ targetWindow });
+    }
+  };
+  targetWindow.addEventListener("message", onMessage);
+  return () => {
+    stopCascadingSnapshots();
+    targetWindow.removeEventListener("message", onMessage);
+  };
+}
+
+export { POSTHOG_REPLAY_SNAPSHOT_REQUEST, requestChildPostHogReplaySnapshots, startChildPostHogReplaySnapshotRelay, startPostHogReplaySnapshotCascade };

package/_vendor/replo-utils/react/use-iframe-rpc-channel.d.ts

@@ -0,0 +1,14 @@
+type SubscribableChannel = {
+    subscribe: () => () => void;
+};
+/**
+ * Subscribes an iframe RPC channel for the lifetime of the calling component.
+ * Returns the same channel so callers can keep a stable handle for `call`.
+ *
+ * Typed structurally so this hook can live in `replo-utils` without importing
+ * the channel implementation from `schemas` (which would close a workspace
+ * cycle: schemas → replo-utils).
+ */
+export declare function useIframeRpcChannel<ChannelType extends SubscribableChannel>(channel: ChannelType): ChannelType;
+export declare function useIframeRpcChannel<ChannelType extends SubscribableChannel>(channel: ChannelType | null): ChannelType | null;
+export {};

package/_vendor/replo-utils/react/use-iframe-rpc-channel.mjs

@@ -0,0 +1,14 @@
+import * as React from 'react';
+
+// ../replo-utils/react/use-iframe-rpc-channel.ts
+function useIframeRpcChannel(channel) {
+  React.useEffect(() => {
+    if (!channel) {
+      return;
+    }
+    return channel.subscribe();
+  }, [channel]);
+  return channel;
+}
+
+export { useIframeRpcChannel };