// The $ex runtime header, emitted verbatim at the top of every compiled bundle.

export function runtimeSource(): string {
  return `"use strict";
const $ex = {
  ok: (v) => ({ ok: true, value: v }),
  err: (e) => ({ ok: false, error: e }),
  Err: class ExErr extends Error {
    constructor(msg, stack) {
      super(String(msg));
      this.name = "Err";
      if (stack !== undefined) this.stack = stack;
    }
  },
  raise: (v) => { throw new $ex.Err($ex.string(v)); },
  errMessage: (e) => {
    if (e instanceof $ex.Err) return e.message;
    if (e && typeof e === "object" && e.ok === false) return String(e.error);
    return String(e && e.message !== undefined ? e.message : e);
  },
  require: (v, msg) => {
    if (v === undefined) throw new $ex.Err(msg === undefined ? "expected a value but found none" : msg);
    return v;
  },
  requireResult: (r, msg) => {
    if (r && r.ok) return r.value;
    throw new $ex.Err(msg === undefined ? $ex.string(r && r.error) : msg);
  },
  string: (v) => {
    if (typeof v === "string") return v;
    if (v === undefined) return "none";
    if (v === null) return "null";
    if (typeof v === "number" || typeof v === "boolean") return String(v);
    if (Array.isArray(v)) return "[" + v.map((x) => $ex.string(x)).join(", ") + "]";
    if (v instanceof Uint8Array) return "<bytes " + v.length + ">";
    if (v instanceof Map) return "{" + [...v.entries()].map(([k, x]) => $ex.string(k) + ": " + $ex.string(x)).join(", ") + "}";
    if (v instanceof Set) return "{" + [...v].map((x) => $ex.string(x)).join(", ") + "}";
    if (typeof v === "object") {
      if (v.ok === true) return $ex.string(v.value);
      if (v.ok === false) return "err(" + $ex.string(v.error) + ")";
      if (v.tag !== undefined) {
        const rest = Object.keys(v).filter((k) => k !== "tag").map((k) => $ex.string(v[k]));
        return rest.length ? v.tag + "(" + rest.join(", ") + ")" : v.tag;
      }
      return "{" + Object.keys(v).map((k) => k + ": " + $ex.string(v[k])).join(", ") + "}";
    }
    return String(v);
  },
  interp: (v) => $ex.string(v),
  range: (a, b, inclusive) => ({
    start: a,
    end: b,
    inclusive: !!inclusive,
    [Symbol.iterator]: function* () {
      if (a <= b) {
        for (let i = a; i < (inclusive ? b + 1 : b); i++) yield i;
      } else {
        for (let i = a; i > (inclusive ? b - 1 : b); i--) yield i;
      }
    },
  }),
  sleep: (ms) => new Promise((res) => setTimeout(res, ms)),
  all: (fs) => Promise.all(fs.map((f) => Promise.resolve(f))).then((xs) => {
    for (const x of xs) if (x && x.ok === false) return x;
    return $ex.ok(xs);
  }),
  race: (fs) => Promise.race(fs.map((f) => Promise.resolve(f))).then((x) => {
    if (x && x.ok === false) return x;
    return $ex.ok(x);
  }),
  timeout: (ms, fut) => Promise.race([
    $ex.sleep(ms).then(() => $ex.err("timed out after " + ms + "ms")),
    Promise.resolve(fut),
  ]),
  with: (r, fn) => {
    try {
      return fn(r);
    } finally {
      if (r && typeof r.close === "function") r.close();
    }
  },
  eq: (a, b) => {
    if (a === b) return true;
    if (typeof a === "number" && typeof b === "number") return a === b;
    if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((x, i) => $ex.eq(x, b[i]));
    if (a instanceof Uint8Array && b instanceof Uint8Array) return a.length === b.length && a.every((x, i) => x === b[i]);
    if (a instanceof Map && b instanceof Map) {
      if (a.size !== b.size) return false;
      for (const [k, v] of a) if (!$ex.eq(v, b.get(k))) return false;
      return true;
    }
    if (a instanceof Set && b instanceof Set) {
      if (a.size !== b.size) return false;
      for (const v of a) if (!b.has(v)) return false;
      return true;
    }
    if (a && b && typeof a === "object" && typeof b === "object") {
      const ka = Object.keys(a);
      const kb = Object.keys(b);
      if (ka.length !== kb.length) return false;
      return ka.every((k) => $ex.eq(a[k], b[k]));
    }
    return false;
  },
  s: {
    charAt: (s, i) => s.charAt(i),
    extract: (s, from, to) => (to === undefined ? s.slice(from) : s.slice(from, to)),
    matches: (s, p) => new RegExp(p).test(s),
  },
  c: {
    map: (xs, f) => (xs && typeof xs[Symbol.iterator] === "function" && !Array.isArray(xs) ? [...xs] : xs).map(f),
    first: (xs) => xs[0],
    last: (xs) => xs[xs.length - 1],
    max: (xs) => (xs.length ? Math.max(...xs) : undefined),
    min: (xs) => (xs.length ? Math.min(...xs) : undefined),
    sum: (xs) => xs.reduce((a, b) => a + b, 0),
    fmax: (xs) => (xs.length ? Math.max(...xs) : undefined),
    fmin: (xs) => (xs.length ? Math.min(...xs) : undefined),
    fsum: (xs) => xs.reduce((a, b) => a + b, 0),
    reverse: (xs) => [...xs].reverse(),
    sort: (xs) => [...xs].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)),
    unique: (xs) => [...new Set(xs)],
    indexed: (xs) => xs.map((v, i) => [i, v]),
    splitFirst: (xs) => [xs[0], xs.slice(1)],
  },
  m: {
    randomInt: (min, max) => Math.floor(Math.random() * (max - min + 1)) + min,
  },
  n: {
    parseInt: (s) => {
      const t = s.trim();
      if (/^-?\\d+$/.test(t)) return $ex.ok(Number(t));
      return $ex.err("\\"" + s + "\\" is not an integer");
    },
    parseFloat: (s) => {
      const t = s.trim();
      if (/^-?(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?$/.test(t)) return $ex.ok(Number(t));
      return $ex.err("\\"" + s + "\\" is not a number");
    },
  },
  io: {
    print: (v) => process.stdout.write($ex.string(v)),
    println: (v) => process.stdout.write($ex.string(v) + "\\n"),
  },
  test: {
    _tests: [],
    run: (name, fn) => { $ex.test._tests.push({ name, fn }); },
    expect: (v) => ({ v }),
    fail: (msg) => { throw new Error("expect failed: " + msg); },
    eq: (e, v) => { if (!$ex.eq(e.v, v)) $ex.test.fail("expected " + $ex.string(e.v) + " but got " + $ex.string(v)); },
    ne: (e, v) => { if ($ex.eq(e.v, v)) $ex.test.fail("expected " + $ex.string(e.v) + " to differ from " + $ex.string(v)); },
    truthy: (e) => { if (!e.v) $ex.test.fail("expected a truthy value but got " + $ex.string(e.v)); },
    falsy: (e) => { if (e.v) $ex.test.fail("expected a falsy value but got " + $ex.string(e.v)); },
    raises: (e, f) => {
      try { f(); } catch { return; }
      $ex.test.fail("expected " + $ex.string(e.v) + " to raise but it did not");
    },
    fails: (e) => { if (!(e.v && e.v.ok === false)) $ex.test.fail("expected a failed Result but got " + $ex.string(e.v)); },
    contains: (e, v) => { if (!e.v.includes(v)) $ex.test.fail("expected " + $ex.string(e.v) + " to contain " + $ex.string(v)); },
    matches: (e, p) => { if (!new RegExp(p).test(e.v)) $ex.test.fail("expected " + $ex.string(e.v) + " to match /" + p + "/"); },
    approx: (e, v) => { if (Math.abs(e.v - v) > 1e-9) $ex.test.fail("expected " + e.v + " to be approx " + v); },
    main: async () => {
      let failed = 0;
      for (const t of $ex.test._tests) {
        try {
          await t.fn();
          process.stdout.write("ok - " + t.name + "\\n");
        } catch (e) {
          failed++;
          process.stdout.write("FAIL - " + t.name + ": " + (e && e.message ? e.message : String(e)) + "\\n");
        }
      }
      if (failed > 0) process.exitCode = 1;
    },
  },
  schema: (fields) => ({ fields }),
  checkField: (f, v) => {
    const t = f.type;
    if (t.k === "opt") {
      if (v === undefined) return null;
      return $ex.checkField({ name: f.name, type: t.inner }, v);
    }
    if (v === undefined) {
      if (f.default !== undefined) return null;
      return "missing required field '" + f.name + "'";
    }
    switch (t.k) {
      case "str": {
        if (typeof v !== "string") return "field '" + f.name + "' must be a string";
        if (t.minLen !== undefined && v.length < t.minLen) return "field '" + f.name + "' must be at least " + t.minLen + " char(s)";
        if (t.maxLen !== undefined && v.length > t.maxLen) return "field '" + f.name + "' must be at most " + t.maxLen + " char(s)";
        if (t.pattern !== undefined && !new RegExp(t.pattern).test(v)) return "field '" + f.name + "' does not match " + t.pattern;
        return null;
      }
      case "int": {
        if (typeof v !== "number" || !Number.isInteger(v)) return "field '" + f.name + "' must be an integer";
        if (t.min !== undefined && v < t.min) return "field '" + f.name + "' must be >= " + t.min;
        if (t.max !== undefined && v > t.max) return "field '" + f.name + "' must be <= " + t.max;
        return null;
      }
      case "float": {
        if (typeof v !== "number") return "field '" + f.name + "' must be a number";
        if (t.min !== undefined && v < t.min) return "field '" + f.name + "' must be >= " + t.min;
        if (t.max !== undefined && v > t.max) return "field '" + f.name + "' must be <= " + t.max;
        return null;
      }
      case "bool":
        if (typeof v !== "boolean") return "field '" + f.name + "' must be a boolean";
        return null;
      case "bytes":
        if (!(v instanceof Uint8Array)) return "field '" + f.name + "' must be bytes";
        return null;
      case "list": {
        if (!Array.isArray(v)) return "field '" + f.name + "' must be a list";
        for (const x of v) {
          const e = $ex.checkField({ name: f.name + "[]", type: t.elem }, x);
          if (e) return e;
        }
        return null;
      }
      case "format": {
        if (typeof v !== "string") return "field '" + f.name + "' must be a string";
        const re = t.name === "Email" ? /^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$/ : t.name === "Url" ? /^https?:\\/\\/\\S+$/i : t.name === "Uuid" ? /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i : null;
        if (re && !re.test(v)) return "field '" + f.name + "' must be a valid " + t.name;
        return null;
      }
      case "enum":
        if (!t.variants.includes(v)) return "field '" + f.name + "' must be one of " + t.variants.join(", ");
        return null;
      case "ref": {
        if (Array.isArray(t.fields)) {
          const e = $ex.schemaFrom({ fields: t.fields.map((s) => ({ name: s.name, type: s.type })) }, v);
          if (!e.ok) return "field '" + f.name + "': " + $ex.string(e.error);
          return null;
        }
        if (!t.fields.includes(v)) return "field '" + f.name + "' must be one of " + t.fields.join(", ");
        return null;
      }
      default:
        return null;
    }
  },
  schemaFrom: (spec, obj) => {
    if (obj === null || typeof obj !== "object" || Array.isArray(obj)) return $ex.err("expected an object but got " + $ex.string(obj));
    const out = {};
    for (const f of spec.fields) {
      let v = obj instanceof Map ? obj.get(f.name) : obj[f.name];
      if (v === undefined && f.default !== undefined) v = f.default;
      const e = $ex.checkField(f, v);
      if (e) return $ex.err(e);
      if (v !== undefined) out[f.name] = v;
    }
    return $ex.ok(out);
  },
  schemaParse: (spec, json) => {
    let obj;
    try {
      obj = JSON.parse(json);
    } catch {
      return $ex.err("invalid JSON");
    }
    return $ex.schemaFrom(spec, obj);
  },
};
`;
}