@rewindkit/runtime 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,736 @@
+// src/bundle.ts
+var SCHEMA_VERSION = 2;
+var DELTA_FORMAT_VERSION = "1.0";
+// src/env.ts
+var isProd = () => {
+  try {
+    return process.env.NODE_ENV === "production";
+  } catch {
+    return false;
+  }
+};
+var warned = new Set;
+var warnOnce = (message) => {
+  if (isProd())
+    return;
+  if (warned.has(message))
+    return;
+  warned.add(message);
+  console.warn(`[rewindkit] ${message}`);
+};
+
+// src/redaction.ts
+var REDACTED = "‹redacted›";
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var maskKeys = (value, redactKeys) => {
+  if (Array.isArray(value))
+    return value.map((item) => maskKeys(item, redactKeys));
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const [key, val] of Object.entries(value)) {
+      if (redactKeys.has(key)) {
+        warnOnce(`redacted key "${key}" — value masked before capture`);
+        out[key] = REDACTED;
+      } else {
+        out[key] = maskKeys(val, redactKeys);
+      }
+    }
+    return out;
+  }
+  return value;
+};
+var __maskDeep = (value, redactKeys) => redactKeys && redactKeys.length ? maskKeys(value, new Set(redactKeys)) : value;
+var __redact = (value, opts) => {
+  const redactKeys = new Set(opts.redactKeys ?? []);
+  if (!isPlainObject(value)) {
+    return redactKeys.size ? maskKeys(value, redactKeys) : value;
+  }
+  let entries = Object.entries(value);
+  if (opts.includeStateKeys === undefined) {
+    warnOnce("includeStateKeys is not set — capturing ALL slices. Set an allowlist in production (PII risk).");
+  } else {
+    const allow = new Set(opts.includeStateKeys);
+    entries = entries.filter(([key]) => allow.has(key));
+  }
+  const out = {};
+  for (const [key, val] of entries) {
+    out[key] = redactKeys.size ? maskKeys(val, redactKeys) : val;
+  }
+  return out;
+};
+var DEFAULTS = { depth: 6, nodes: 200, strLen: 1e4 };
+var serializeForDisplay = (value, opts = {}) => {
+  const cfg = { ...DEFAULTS, ...opts };
+  let budget = cfg.nodes;
+  const walk = (v, depth) => {
+    budget -= 1;
+    if (budget < 0)
+      return "… (capped)";
+    if (typeof v === "string") {
+      return v.length > cfg.strLen ? `${v.slice(0, cfg.strLen)}… (${v.length} chars)` : v;
+    }
+    if (typeof v === "bigint")
+      return `${v}n`;
+    if (typeof v === "function")
+      return `‹function ${v.name || "anonymous"}›`;
+    if (typeof v === "symbol")
+      return v.toString();
+    if (v === null || typeof v !== "object")
+      return v;
+    if (v instanceof Date)
+      return `Date(${v.toISOString()})`;
+    if (v instanceof Error)
+      return `${v.name}: ${v.message}`;
+    if (v instanceof Map) {
+      if (v.size === 0)
+        return "Map(0) {}";
+      if (depth >= cfg.depth)
+        return `Map(${v.size}) …`;
+      const obj = {};
+      for (const [k, val] of v)
+        obj[String(k)] = walk(val, depth + 1);
+      return { "‹Map›": obj };
+    }
+    if (v instanceof Set) {
+      if (v.size === 0)
+        return "Set(0) {}";
+      if (depth >= cfg.depth)
+        return `Set(${v.size}) …`;
+      return { "‹Set›": [...v].map((item) => walk(item, depth + 1)) };
+    }
+    if (Array.isArray(v)) {
+      if (v.length === 0)
+        return [];
+      if (depth >= cfg.depth)
+        return `[Array(${v.length})]`;
+      return v.map((item) => walk(item, depth + 1));
+    }
+    const keys = Object.keys(v);
+    if (keys.length === 0)
+      return {};
+    if (depth >= cfg.depth)
+      return `{…(${keys.length} keys)}`;
+    const out = {};
+    for (const key of keys)
+      out[key] = walk(v[key], depth + 1);
+    return out;
+  };
+  return walk(value, 0);
+};
+
+// src/recorder.ts
+var DEFAULT_CONFIG = {
+  keyframeEvery: 25,
+  fullKeyframeRatio: 8,
+  sample: 1,
+  maxEventsPerSecond: 200
+};
+var UNSERIALIZABLE = "__unserializable";
+var KEY = "__REPLAYKIT_RECORDER__";
+var createRecorder = () => {
+  const bundle = {
+    version: DELTA_FORMAT_VERSION,
+    schemaVersion: SCHEMA_VERSION,
+    mode: "state-snapshot",
+    sessionId: crypto.randomUUID(),
+    startTime: Date.now(),
+    duration: 0,
+    remotes: [],
+    events: []
+  };
+  const stores = new Map;
+  const rawStash = new Map;
+  const prevLiveSlices = new Map;
+  const actionCount = new Map;
+  let windowStart = 0;
+  let windowCount = 0;
+  const suppression = { depth: 0 };
+  const rec = {
+    suppression,
+    config: { ...DEFAULT_CONFIG },
+    recording: false,
+    origin: "host",
+    now: () => Date.now(),
+    start() {
+      rec.recording = true;
+      for (const [name, store] of stores)
+        emitKeyframe(name, store.getState(), true);
+    },
+    stop() {
+      rec.recording = false;
+    },
+    isRecording() {
+      return rec.recording;
+    },
+    configure(opts) {
+      const { origin, now, ...cfg } = opts;
+      rec.config = { ...rec.config, ...cfg };
+      if (origin !== undefined)
+        rec.origin = origin;
+      if (now !== undefined) {
+        rec.now = now;
+        bundle.startTime = now();
+      }
+    },
+    registerStore(name, store) {
+      if (stores.has(name)) {
+        warnOnce(`store "${name}" already registered — names must be unique (ignoring re-register)`);
+        return;
+      }
+      stores.set(name, store);
+      const registeredAtMs = rec.now() - bundle.startTime;
+      bundle.remotes.push({ name, storeKey: name, registeredAtMs });
+      if (rec.recording)
+        emitKeyframe(name, store.getState(), true);
+    },
+    unregisterStore(name) {
+      stores.delete(name);
+    },
+    getStore(name) {
+      return stores.get(name);
+    },
+    captureAction(storeKey, action) {
+      if (!armed())
+        return;
+      if (rec.config.sample < 1 && Math.random() > rec.config.sample)
+        return;
+      if (throttled())
+        return;
+      append({
+        type: "action",
+        tsMs: tsMs(),
+        origin: rec.origin,
+        storeKey,
+        seq: nextSeq(),
+        action: { type: action.type, payload: action.payload }
+      });
+    },
+    captureKeyframe(storeKey) {
+      if (!armed())
+        return;
+      const store = stores.get(storeKey);
+      if (!store)
+        return;
+      const count = (actionCount.get(storeKey) ?? 0) + 1;
+      actionCount.set(storeKey, count);
+      const fullEvery = rec.config.keyframeEvery * rec.config.fullKeyframeRatio;
+      if (count % rec.config.keyframeEvery !== 0)
+        return;
+      const full = count % fullEvery === 0;
+      emitKeyframe(storeKey, store.getState(), full);
+    },
+    captureRoute(path, search) {
+      if (!armed())
+        return;
+      if (throttled())
+        return;
+      append({
+        type: "route",
+        tsMs: tsMs(),
+        origin: rec.origin,
+        storeKey: rec.origin,
+        seq: nextSeq(),
+        path,
+        search
+      });
+    },
+    pushFeedEvent(ev) {
+      if (!armed())
+        return;
+      const topics = rec.config.includeFeedTopics;
+      if (!topics || topics.length === 0) {
+        warnOnce("includeFeedTopics is empty — no feed_message recorded. Allowlist a topic.");
+        return;
+      }
+      if (!topics.includes(ev.topic))
+        return;
+      if (throttled())
+        return;
+      const redactKeys = rec.config.redactKeys;
+      const rows = ev.rows ? structuredClone(__maskDeep(ev.rows, redactKeys)) : ev.rows;
+      const data = ev.data !== undefined ? structuredClone(__maskDeep(ev.data, redactKeys)) : ev.data;
+      append({
+        ...ev,
+        rows,
+        data,
+        type: "feed_message",
+        tsMs: tsMs(),
+        origin: rec.origin,
+        storeKey: ev.storeKey ?? rec.origin,
+        seq: nextSeq()
+      });
+    },
+    suppress() {
+      suppression.depth += 1;
+    },
+    unsuppress() {
+      suppression.depth -= 1;
+      if (suppression.depth < 0) {
+        suppression.depth = 0;
+        if (!isProdSafe())
+          throw new Error("[replaykit] suppression depth went negative");
+      }
+    },
+    getBundle() {
+      bundle.duration = rawStashMaxTs();
+      return bundle;
+    }
+  };
+  const armed = () => rec.recording && suppression.depth === 0;
+  const tsMs = () => rec.now() - bundle.startTime;
+  const nextSeq = () => bundle.events.length;
+  const append = (event) => {
+    bundle.events.push(event);
+    rec.config.sink?.push(event);
+  };
+  const throttled = () => {
+    const t = rec.now();
+    if (t - windowStart >= 1000) {
+      windowStart = t;
+      windowCount = 0;
+    }
+    if (windowCount >= rec.config.maxEventsPerSecond)
+      return true;
+    windowCount += 1;
+    return false;
+  };
+  const emitKeyframe = (storeKey, state, full) => {
+    const liveSlices = state && typeof state === "object" && !Array.isArray(state) ? state : {};
+    const redacted = __redact(state, {
+      includeStateKeys: rec.config.includeStateKeys,
+      redactKeys: rec.config.redactKeys
+    });
+    const prevStash = rawStash.get(storeKey);
+    const prevLive = prevLiveSlices.get(storeKey);
+    if (full || !prevStash || !prevLive) {
+      const cloned = cloneSlices(redacted);
+      rawStash.set(storeKey, cloned);
+      prevLiveSlices.set(storeKey, { ...liveSlices });
+      append({
+        type: "state_snapshot",
+        kind: "keyframe",
+        tsMs: tsMs(),
+        origin: rec.origin,
+        storeKey,
+        seq: nextSeq(),
+        slices: cloned
+      });
+      return;
+    }
+    const changedStash = {};
+    const nextStash = { ...prevStash };
+    for (const key of Object.keys(redacted)) {
+      if (!Object.is(prevLive[key], liveSlices[key])) {
+        const clonedVal = cloneSingle(redacted[key]);
+        changedStash[key] = clonedVal;
+        nextStash[key] = clonedVal;
+      }
+    }
+    const removed = Object.keys(prevStash).filter((key) => !(key in redacted));
+    for (const key of removed)
+      delete nextStash[key];
+    rawStash.set(storeKey, nextStash);
+    prevLiveSlices.set(storeKey, { ...liveSlices });
+    append({
+      type: "state_snapshot",
+      kind: "delta",
+      tsMs: tsMs(),
+      origin: rec.origin,
+      storeKey,
+      seq: nextSeq(),
+      slices: changedStash,
+      ...removed.length ? { removedSlices: removed } : {}
+    });
+  };
+  const cloneSingle = (val) => {
+    try {
+      return structuredClone(val);
+    } catch {
+      return { [UNSERIALIZABLE]: true };
+    }
+  };
+  const cloneSlices = (state) => {
+    const out = {};
+    for (const [key, val] of Object.entries(state))
+      out[key] = cloneSingle(val);
+    return out;
+  };
+  const rawStashMaxTs = () => {
+    let max = 0;
+    for (const ev of bundle.events)
+      if (ev.tsMs > max)
+        max = ev.tsMs;
+    return max;
+  };
+  return rec;
+};
+var isProdSafe = () => {
+  try {
+    return process.env.NODE_ENV === "production";
+  } catch {
+    return false;
+  }
+};
+var acquireRecorder = () => {
+  const g = globalThis;
+  const existing = g[KEY];
+  if (existing)
+    return existing;
+  const r = createRecorder();
+  g[KEY] = r;
+  return g[KEY] ?? r;
+};
+var __peekRecorder = () => globalThis[KEY];
+
+// src/enhancer.ts
+var RESTORE_TYPE = "__REPLAYKIT_RESTORE";
+var isRestore = (action) => typeof action === "object" && action !== null && action.type === RESTORE_TYPE;
+var wrapReducer = (reducer) => (state, action) => {
+  if (isRestore(action)) {
+    const base = state ?? {};
+    const next = { ...base, ...action.slices };
+    for (const key of action.removedSlices ?? [])
+      delete next[key];
+    return next;
+  }
+  return reducer(state, action);
+};
+var enhancer = (createStore) => (reducer, preloadedState) => {
+  const store = createStore(wrapReducer(reducer), preloadedState);
+  const dispatch = (action) => {
+    const recorder = __peekRecorder();
+    if (!recorder)
+      return store.dispatch(action);
+    const result = store.dispatch(action);
+    if (!isRestore(action) && typeof action.type === "string") {
+      const storeKey = recorder.origin;
+      recorder.captureAction(storeKey, {
+        type: action.type,
+        payload: action.payload
+      });
+      recorder.captureKeyframe(storeKey);
+    }
+    return result;
+  };
+  return { ...store, dispatch };
+};
+var replayEnhancer = enhancer;
+
+// src/replay.ts
+var mode = "live";
+var listeners = new Set;
+var getReplayMode = () => mode;
+var subscribeReplayMode = (cb) => {
+  listeners.add(cb);
+  cb(mode);
+  return () => {
+    listeners.delete(cb);
+  };
+};
+var notify = () => {
+  for (const cb of listeners)
+    cb(mode);
+};
+var setMode = (next) => {
+  if (next === mode)
+    return;
+  const recorder = acquireRecorder();
+  if (next === "history") {
+    recorder.suppress();
+    mode = "history";
+  } else {
+    mode = "live";
+    recorder.unsuppress();
+  }
+  notify();
+};
+var applyReplayState = (snapshot, storeKey) => {
+  const recorder = acquireRecorder();
+  const key = storeKey ?? recorder.origin;
+  const store = recorder.getStore(key);
+  if (!store) {
+    warnOnce(`applyReplayState: no store registered for "${key}"`);
+    return;
+  }
+  recorder.suppress();
+  try {
+    const action = { type: RESTORE_TYPE, slices: { ...snapshot.slices } };
+    store.dispatch(action);
+  } finally {
+    recorder.unsuppress();
+  }
+};
+var seek = (player, tMs) => {
+  const states = player.statesAt(tMs);
+  if (mode !== "history")
+    setMode("history");
+  const recorder = acquireRecorder();
+  recorder.suppress();
+  try {
+    for (const [storeKey, snap] of Object.entries(states)) {
+      if (snap)
+        applyReplayState(snap, storeKey);
+    }
+  } finally {
+    recorder.unsuppress();
+  }
+};
+var returnToLive = () => {
+  setMode("live");
+  const recorder = acquireRecorder();
+  if (recorder.suppression.depth !== 0) {
+    warnOnce("suppression depth non-zero after returnToLive — a suppress/unsuppress pair leaked");
+  }
+};
+
+// src/configure.ts
+var configureReplay = (opts = {}) => {
+  const recorder = acquireRecorder();
+  recorder.configure({
+    sink: opts.sink,
+    redactKeys: opts.redactKeys,
+    includeStateKeys: opts.includeStateKeys,
+    includeFeedTopics: opts.includeFeedTopics,
+    ...opts.keyframeEvery !== undefined ? { keyframeEvery: opts.keyframeEvery } : {},
+    ...opts.fullKeyframeRatio !== undefined ? { fullKeyframeRatio: opts.fullKeyframeRatio } : {},
+    ...opts.sample !== undefined ? { sample: opts.sample } : {},
+    ...opts.maxEventsPerSecond !== undefined ? { maxEventsPerSecond: opts.maxEventsPerSecond } : {},
+    origin: opts.origin,
+    now: opts.now
+  });
+  if (opts.store)
+    recorder.registerStore(opts.origin ?? "host", opts.store);
+  const allowed = opts.force === true || !isProd();
+  if (!allowed) {
+    warnOnce("recording disabled in production — pass force: true to enable (staging demos only).");
+  }
+  return {
+    start() {
+      if (!allowed)
+        return;
+      recorder.start();
+    },
+    stop() {
+      recorder.stop();
+      returnToLive();
+    },
+    isRecording() {
+      return recorder.isRecording();
+    },
+    getBundle() {
+      return structuredClone(recorder.getBundle());
+    }
+  };
+};
+var registerStore = (name, store) => {
+  acquireRecorder().registerStore(name, store);
+};
+var unregisterStore = (name) => {
+  acquireRecorder().unregisterStore(name);
+};
+// src/player.ts
+var asRaw = (slices) => ({ __brand: "raw", slices });
+var foldStateAt = (bundle, storeKey, tMs) => {
+  let acc;
+  for (const ev of bundle.events) {
+    if (ev.tsMs > tMs)
+      break;
+    if (ev.storeKey !== storeKey)
+      continue;
+    if (ev.type !== "state_snapshot")
+      continue;
+    const snap = ev;
+    if (snap.kind === "keyframe") {
+      acc = { ...snap.slices };
+    } else if (snap.kind === "delta") {
+      if (!acc) {
+        warnOnce("delta before keyframe — skipped");
+        continue;
+      }
+      acc = { ...acc, ...snap.slices };
+      for (const k of snap.removedSlices ?? [])
+        delete acc[k];
+    } else {
+      warnOnce(`unknown snapshot kind — skipped`);
+    }
+  }
+  return acc === undefined ? undefined : asRaw(acc);
+};
+var snapshotStoreKeys = (bundle) => {
+  const keys = new Set;
+  for (const ev of bundle.events) {
+    if (ev.type === "state_snapshot")
+      keys.add(ev.storeKey);
+  }
+  return keys;
+};
+var foldFeedAt = (bundle, origin, topic, tMs) => {
+  const relevant = bundle.events.filter((ev) => ev.type === "feed_message" && ev.origin === origin && ev.topic === topic && ev.tsMs <= tMs).sort((a, b) => a.seq - b.seq || (a.feedSeq ?? 0) - (b.feedSeq ?? 0));
+  if (relevant.length === 0)
+    return;
+  let base;
+  for (const ev of relevant)
+    if (ev.channel === "sow_page")
+      base = ev;
+  if (!base)
+    return;
+  const rows = new Map;
+  let nextKey = 0;
+  for (const row of base.rows ?? []) {
+    const key = keyOf(row) ?? `__idx${nextKey++}`;
+    rows.set(key, row);
+  }
+  let matched = base.matched ?? rows.size;
+  const lastFeedSeq = new Map;
+  const baseSeq = base.seq;
+  for (const ev of relevant) {
+    if (ev.seq <= baseSeq)
+      continue;
+    const key = ev.key;
+    if (ev.channel === "tick" || ev.channel === "ack") {
+      if (key === undefined)
+        continue;
+      const evFeedSeq = ev.feedSeq ?? 0;
+      const seenFeedSeq = lastFeedSeq.get(key) ?? -1;
+      if (evFeedSeq >= seenFeedSeq) {
+        rows.set(key, ev.data);
+        lastFeedSeq.set(key, evFeedSeq);
+      }
+    } else if (ev.channel === "oof") {
+      if (key !== undefined && rows.delete(key)) {
+        matched = Math.max(0, matched - 1);
+        lastFeedSeq.delete(key);
+      }
+    }
+  }
+  return { rows: [...rows.values()], matched };
+};
+var keyOf = (row) => {
+  if (row && typeof row === "object") {
+    const r = row;
+    for (const cand of ["symbol", "orderId", "id", "key"]) {
+      if (typeof r[cand] === "string")
+        return r[cand];
+    }
+  }
+  return;
+};
+var routeAt = (bundle, tMs) => {
+  let last;
+  for (const ev of bundle.events) {
+    if (ev.tsMs > tMs)
+      break;
+    if (ev.type === "route")
+      last = ev;
+  }
+  return last;
+};
+var eventId = (ev) => {
+  let content = "";
+  const e = ev;
+  if (ev.type === "action")
+    content = JSON.stringify(e["action"]);
+  else if (ev.type === "state_snapshot")
+    content = JSON.stringify(e["slices"]);
+  else if (ev.type === "feed_message")
+    content = JSON.stringify(e["data"] ?? e["rows"]);
+  else if (ev.type === "route")
+    content = String(e["path"]);
+  return `${ev.seq}|${ev.storeKey}|${ev.type}|${ev.tsMs}|${content}`;
+};
+var diffBundles = (a, b) => {
+  const aIds = new Set(a.events.map(eventId));
+  const bIds = new Set(b.events.map(eventId));
+  const added = b.events.filter((ev) => !aIds.has(eventId(ev)));
+  const removed = a.events.filter((ev) => !bIds.has(eventId(ev)));
+  const tA = a.duration;
+  const tB = b.duration;
+  const keys = new Set([...snapshotStoreKeys(a), ...snapshotStoreKeys(b)]);
+  const changedStoreKeys = [];
+  for (const key of keys) {
+    const sa = foldStateAt(a, key, tA);
+    const sb = foldStateAt(b, key, tB);
+    if (JSON.stringify(sa?.slices) !== JSON.stringify(sb?.slices))
+      changedStoreKeys.push(key);
+  }
+  return { added, removed, changedStoreKeys };
+};
+var createPlayer = (bundle) => ({
+  statesAt(tMs) {
+    const out = {};
+    for (const key of snapshotStoreKeys(bundle))
+      out[key] = foldStateAt(bundle, key, tMs);
+    return out;
+  },
+  routeAt(tMs) {
+    return routeAt(bundle, tMs);
+  },
+  feedAt(origin, topic, tMs) {
+    return foldFeedAt(bundle, origin, topic, tMs);
+  },
+  diffBundles(a, b) {
+    return diffBundles(a, b);
+  }
+});
+// src/bundle-io.ts
+class BundleValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BundleValidationError";
+  }
+}
+var validateBundle = (b) => {
+  if (!b || typeof b !== "object")
+    throw new BundleValidationError("bundle is not an object");
+  const bundle = b;
+  if (bundle.version !== DELTA_FORMAT_VERSION) {
+    throw new BundleValidationError(`unsupported bundle version "${String(bundle.version)}" — expected "${DELTA_FORMAT_VERSION}". ` + `A different fold algorithm may be required.`);
+  }
+  if (typeof bundle.schemaVersion !== "number" || bundle.schemaVersion > SCHEMA_VERSION) {
+    throw new BundleValidationError(`unknown schemaVersion ${String(bundle.schemaVersion)} — this runtime understands up to ${SCHEMA_VERSION}`);
+  }
+  if (!Array.isArray(bundle.events)) {
+    throw new BundleValidationError("bundle.events must be an array");
+  }
+  if (!bundle.mode) {
+    throw new BundleValidationError("bundle.mode is missing");
+  }
+  return b;
+};
+var exportBundle = () => {
+  const bundle = acquireRecorder().getBundle();
+  return structuredClone(bundle);
+};
+var importBundle = (json) => {
+  const parsed = typeof json === "string" ? JSON.parse(json) : json;
+  return validateBundle(parsed);
+};
+
+// src/index.ts
+var VERSION = "0.1.0-alpha.1";
+export {
+  unregisterStore,
+  subscribeReplayMode,
+  serializeForDisplay,
+  seek,
+  routeAt,
+  returnToLive,
+  replayEnhancer,
+  registerStore,
+  importBundle,
+  getReplayMode,
+  foldStateAt,
+  foldFeedAt,
+  exportBundle,
+  diffBundles,
+  createPlayer,
+  configureReplay,
+  applyReplayState,
+  __redact,
+  VERSION,
+  SCHEMA_VERSION,
+  DELTA_FORMAT_VERSION
+};
+
+//# debugId=093C993363C31DB564756E2164756E21
+//# sourceMappingURL=index.js.map