// Compile-time safety gate for user-authored play code (enrich `extract_js`,
// `run_if_js`, and `run_javascript` step `code`).
//
// Plays replay deterministically under Worker Loader, and the step code runs
// with provider data in scope. So user code may NOT be non-deterministic
// (Math.random, Date.now, ...) — replay would diverge — and may NOT reach out
// of the sandbox (fetch, require, process, ...). We reject those at compile
// time with a clear, named error (fail loud, per the repo non-negotiables).
//
// This is a fast static scan, not a security boundary on its own: the play
// runtime is the real boundary (it executes step code in an isolate that does
// not expose these globals). The scan exists to fail authoring early with a
// readable message instead of producing a play that silently misbehaves at run
// time. The `(?<!\.)` guards keep it from flagging harmless property access on
// user objects (e.g. `row.process_date`, `data.fetch`).

type ForbiddenRule = { readonly pattern: RegExp; readonly reason: string };

const FORBIDDEN: readonly ForbiddenRule[] = [
  // Non-deterministic — breaks replay.
  { pattern: /\bMath\s*\.\s*random\b/, reason: 'Math.random()' },
  { pattern: /\bDate\s*\.\s*now\b/, reason: 'Date.now()' },
  { pattern: /\bnew\s+Date\s*\(\s*\)/, reason: 'new Date() with no argument' },
  { pattern: /\bperformance\s*\.\s*now\b/, reason: 'performance.now()' },
  {
    pattern: /\bcrypto\s*\.\s*(?:randomUUID|getRandomValues)\b/,
    reason: 'crypto random',
  },
  // Sandbox escape / I/O.
  { pattern: /(?<!\.)\bfetch\s*\(/, reason: 'fetch()' },
  { pattern: /(?<!\.)\bimport\s*\(/, reason: 'dynamic import()' },
  { pattern: /(?<!\.)\brequire\s*\(/, reason: 'require()' },
  { pattern: /(?<!\.)\beval\s*\(/, reason: 'eval()' },
  {
    pattern: /(?<!\.)\bnew\s+Function\b|(?<!\.)\bFunction\s*\(/,
    reason: 'the Function constructor',
  },
  { pattern: /(?<!\.)\bprocess\b/, reason: 'process' },
  { pattern: /(?<!\.)\bglobalThis\b/, reason: 'globalThis' },
  { pattern: /(?<!\.)\b(?:window|self)\b/, reason: 'window/self' },
  { pattern: /(?<!\.)\bXMLHttpRequest\b/, reason: 'XMLHttpRequest' },
  { pattern: /(?<!\.)\bWebAssembly\b/, reason: 'WebAssembly' },
];

/**
 * Throw if `code` references a forbidden (non-deterministic or sandbox-escaping)
 * construct. `label` describes where the code came from for the error message,
 * e.g. `extract_js for "email"` or `run_javascript step "enrich"`.
 */
export function assertUserCodeIsSafe(code: string, label: string): void {
  if (typeof code !== 'string' || !code.trim()) return;
  for (const { pattern, reason } of FORBIDDEN) {
    if (pattern.test(code)) {
      throw new Error(
        `${label} uses ${reason}, which is not allowed in play code: it ` +
          `breaks deterministic replay or escapes the sandbox. Remove it and ` +
          `compute the value from the row/result instead.`,
      );
    }
  }
}