@frontman-ai/nextjs 0.1.0

package/dist/instrumentation.js

@@ -0,0 +1,2400 @@
+import * as Nextjs from '@sentry/nextjs';
+
+// src/FrontmanNextjs__Sentry.res.mjs
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_option.js
+function some(x) {
+  if (x === void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: 0
+    };
+  } else if (x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: x.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
+    };
+  } else {
+    return x;
+  }
+}
+function fromNullable(x) {
+  if (x == null) {
+    return;
+  } else {
+    return some(x);
+  }
+}
+function valFromOption(x) {
+  if (x === null || x.BS_PRIVATE_NESTED_SOME_NONE === void 0) {
+    return x;
+  }
+  let depth = x.BS_PRIVATE_NESTED_SOME_NONE;
+  if (depth === 0) {
+    return;
+  } else {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: depth - 1 | 0
+    };
+  }
+}
+
+// src/FrontmanNextjs__Sentry.res.mjs
+var dsn = "https://442ae992e5a5ccfc42e6910220aeb2a9@o4510512511320064.ingest.de.sentry.io/4510512546185296";
+var initialized = {
+  contents: false
+};
+function initialize(transport) {
+  if (initialized.contents) {
+    return;
+  }
+  let options_environment = process.env.NODE_ENV || "development";
+  let options_release = process.env.npm_package_version || "unknown";
+  let options_sampleRate = 1;
+  let options_initialScope = {
+    tags: Object.fromEntries([[
+      "frontman.library",
+      "frontman-nextjs"
+    ]])
+  };
+  let options = {
+    dsn,
+    environment: options_environment,
+    release: options_release,
+    sampleRate: options_sampleRate,
+    initialScope: options_initialScope
+  };
+  Nextjs.init(options);
+  initialized.contents = true;
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_int.js
+function min(x, y) {
+  if (x < y) {
+    return x;
+  } else {
+    return y;
+  }
+}
+function mod_(x, y) {
+  if (y === 0) {
+    throw {
+      RE_EXN_ID: "Division_by_zero",
+      Error: new Error()
+    };
+  }
+  return x % y;
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_exceptions.js
+var idMap = {};
+function create(str) {
+  let v = idMap[str];
+  if (v !== void 0) {
+    let id = v + 1 | 0;
+    idMap[str] = id;
+    return str + ("/" + id);
+  }
+  idMap[str] = 1;
+  return str;
+}
+
+// ../../node_modules/sury/src/Sury.res.mjs
+var immutableEmpty = {};
+var immutableEmpty$1 = [];
+function capitalize(string4) {
+  return string4.slice(0, 1).toUpperCase() + string4.slice(1);
+}
+var copy = ((d2) => ({ ...d2 }));
+function fromString(string4) {
+  let _idx = 0;
+  while (true) {
+    let idx = _idx;
+    let match = string4[idx];
+    if (match === void 0) {
+      return `"` + string4 + `"`;
+    }
+    switch (match) {
+      case '"':
+      case "\n":
+        return JSON.stringify(string4);
+      default:
+        _idx = idx + 1 | 0;
+        continue;
+    }
+  }
+}
+function toArray2(path) {
+  if (path === "") {
+    return [];
+  } else {
+    return JSON.parse(path.split(`"]["`).join(`","`));
+  }
+}
+var vendor = "sury";
+var s = Symbol(vendor);
+var $$Error = /* @__PURE__ */ create("Sury.Error");
+var constField = "const";
+function has(acc, flag) {
+  return (acc & flag) !== 0;
+}
+var flags = {
+  unknown: 1,
+  string: 2,
+  number: 4,
+  boolean: 8,
+  undefined: 16,
+  null: 32,
+  object: 64,
+  array: 128,
+  union: 256,
+  ref: 512,
+  bigint: 1024,
+  nan: 2048,
+  "function": 4096,
+  instance: 8192,
+  never: 16384,
+  symbol: 32768
+};
+function stringify(unknown2) {
+  let tagFlag = flags[typeof unknown2];
+  if (tagFlag & 16) {
+    return "undefined";
+  }
+  if (!(tagFlag & 64)) {
+    if (tagFlag & 2) {
+      return `"` + unknown2 + `"`;
+    } else if (tagFlag & 1024) {
+      return unknown2 + `n`;
+    } else {
+      return unknown2.toString();
+    }
+  }
+  if (unknown2 === null) {
+    return "null";
+  }
+  if (Array.isArray(unknown2)) {
+    let string4 = "[";
+    for (let i = 0, i_finish = unknown2.length; i < i_finish; ++i) {
+      if (i !== 0) {
+        string4 = string4 + ", ";
+      }
+      string4 = string4 + stringify(unknown2[i]);
+    }
+    return string4 + "]";
+  }
+  if (unknown2.constructor !== Object) {
+    return Object.prototype.toString.call(unknown2);
+  }
+  let keys = Object.keys(unknown2);
+  let string$1 = "{ ";
+  for (let i$1 = 0, i_finish$1 = keys.length; i$1 < i_finish$1; ++i$1) {
+    let key = keys[i$1];
+    let value = unknown2[key];
+    string$1 = string$1 + key + `: ` + stringify(value) + `; `;
+  }
+  return string$1 + "}";
+}
+function toExpression(schema3) {
+  let tag = schema3.type;
+  let $$const = schema3.const;
+  let name = schema3.name;
+  if (name !== void 0) {
+    return name;
+  }
+  if ($$const !== void 0) {
+    return stringify($$const);
+  }
+  let format = schema3.format;
+  let anyOf = schema3.anyOf;
+  if (anyOf !== void 0) {
+    return anyOf.map(toExpression).join(" | ");
+  }
+  if (format !== void 0) {
+    return format;
+  }
+  switch (tag) {
+    case "nan":
+      return "NaN";
+    case "object":
+      let additionalItems = schema3.additionalItems;
+      let properties = schema3.properties;
+      let locations = Object.keys(properties);
+      if (locations.length === 0) {
+        if (typeof additionalItems === "object") {
+          return `{ [key: string]: ` + toExpression(additionalItems) + `; }`;
+        } else {
+          return `{}`;
+        }
+      } else {
+        return `{ ` + locations.map((location) => location + `: ` + toExpression(properties[location]) + `;`).join(" ") + ` }`;
+      }
+    default:
+      if (schema3.b) {
+        return tag;
+      }
+      switch (tag) {
+        case "instance":
+          return schema3.class.name;
+        case "array":
+          let additionalItems$1 = schema3.additionalItems;
+          let items = schema3.items;
+          if (typeof additionalItems$1 !== "object") {
+            return `[` + items.map((item) => toExpression(item.schema)).join(", ") + `]`;
+          }
+          let itemName = toExpression(additionalItems$1);
+          return (additionalItems$1.type === "union" ? `(` + itemName + `)` : itemName) + "[]";
+        default:
+          return tag;
+      }
+  }
+}
+var SuryError = class extends Error {
+  constructor(code, flag, path) {
+    super();
+    this.flag = flag;
+    this.code = code;
+    this.path = path;
+  }
+};
+var d = Object.defineProperty;
+var p = SuryError.prototype;
+d(p, "message", {
+  get() {
+    return message(this);
+  }
+});
+d(p, "reason", {
+  get() {
+    return reason(this);
+  }
+});
+d(p, "name", { value: "SuryError" });
+d(p, "s", { value: s });
+d(p, "_1", {
+  get() {
+    return this;
+  }
+});
+d(p, "RE_EXN_ID", {
+  value: $$Error
+});
+var Schema = function(type) {
+  this.type = type;
+};
+var sp = /* @__PURE__ */ Object.create(null);
+d(sp, "with", {
+  get() {
+    return (fn, ...args) => fn(this, ...args);
+  }
+});
+Schema.prototype = sp;
+function getOrRethrow(exn) {
+  if (exn && exn.s === s) {
+    return exn;
+  }
+  throw exn;
+}
+function reason(error, nestedLevelOpt) {
+  let nestedLevel = nestedLevelOpt !== void 0 ? nestedLevelOpt : 0;
+  let reason$1 = error.code;
+  if (typeof reason$1 !== "object") {
+    return "Encountered unexpected async transform or refine. Use parseAsyncOrThrow operation instead";
+  }
+  switch (reason$1.TAG) {
+    case "OperationFailed":
+      return reason$1._0;
+    case "InvalidOperation":
+      return reason$1.description;
+    case "InvalidType":
+      let unionErrors = reason$1.unionErrors;
+      let m = `Expected ` + toExpression(reason$1.expected) + `, received ` + stringify(reason$1.received);
+      if (unionErrors !== void 0) {
+        let lineBreak = `
+` + " ".repeat(nestedLevel << 1);
+        let reasonsDict = {};
+        for (let idx = 0, idx_finish = unionErrors.length; idx < idx_finish; ++idx) {
+          let error$1 = unionErrors[idx];
+          let reason$2 = reason(error$1, nestedLevel + 1);
+          let nonEmptyPath = error$1.path;
+          let location = nonEmptyPath === "" ? "" : `At ` + nonEmptyPath + `: `;
+          let line = `- ` + location + reason$2;
+          if (!reasonsDict[line]) {
+            reasonsDict[line] = 1;
+            m = m + lineBreak + line;
+          }
+        }
+      }
+      return m;
+    case "UnsupportedTransformation":
+      return `Unsupported transformation from ` + toExpression(reason$1.from) + ` to ` + toExpression(reason$1.to);
+    case "ExcessField":
+      return `Unrecognized key "` + reason$1._0 + `"`;
+    case "InvalidJsonSchema":
+      return toExpression(reason$1._0) + ` is not valid JSON`;
+  }
+}
+function message(error) {
+  let op = error.flag;
+  let text = "Failed ";
+  if (op & 2) {
+    text = text + "async ";
+  }
+  text = text + (op & 1 ? op & 4 ? "asserting" : "parsing" : "converting");
+  if (op & 8) {
+    text = text + " to JSON" + (op & 16 ? " string" : "");
+  }
+  let nonEmptyPath = error.path;
+  let tmp = nonEmptyPath === "" ? "" : ` at ` + nonEmptyPath;
+  return text + tmp + `: ` + reason(error, void 0);
+}
+var globalConfig = {
+  a: "strip"};
+var shakenRef = "as";
+var shakenTraps = {
+  get: (target, prop) => {
+    let l = target[shakenRef];
+    if (l === void 0) {
+      return target[prop];
+    }
+    if (prop === shakenRef) {
+      return target[prop];
+    }
+    let l$1 = valFromOption(l);
+    let message2 = `Schema S.` + l$1 + ` is not enabled. To start using it, add S.enable` + capitalize(l$1) + `() at the project root.`;
+    throw new Error(`[Sury] ` + message2);
+  }
+};
+function shaken(apiName) {
+  let mut = new Schema("never");
+  mut[shakenRef] = apiName;
+  return new Proxy(mut, shakenTraps);
+}
+var unknown = new Schema("unknown");
+var bool = new Schema("boolean");
+var string = new Schema("string");
+var int = new Schema("number");
+int.format = "int32";
+var float = new Schema("number");
+var unit = new Schema("undefined");
+unit.const = void 0;
+var copyWithoutCache = ((schema3) => {
+  let c = new Schema(schema3.type);
+  for (let k in schema3) {
+    if (k > "a" || k === "$ref" || k === "$defs") {
+      c[k] = schema3[k];
+    }
+  }
+  return c;
+});
+function updateOutput(schema3, fn) {
+  let root = copyWithoutCache(schema3);
+  let mut = root;
+  while (mut.to) {
+    let next = copyWithoutCache(mut.to);
+    mut.to = next;
+    mut = next;
+  }
+  fn(mut);
+  return root;
+}
+function embed(b, value) {
+  let e = b.g.e;
+  let l = e.length;
+  e[l] = value;
+  return `e[` + l + `]`;
+}
+function inlineConst(b, schema3) {
+  let tagFlag = flags[schema3.type];
+  let $$const = schema3.const;
+  if (tagFlag & 16) {
+    return "void 0";
+  } else if (tagFlag & 2) {
+    return fromString($$const);
+  } else if (tagFlag & 1024) {
+    return $$const + "n";
+  } else if (tagFlag & 45056) {
+    return embed(b, schema3.const);
+  } else {
+    return $$const;
+  }
+}
+function inlineLocation(b, location) {
+  let key = `"` + location + `"`;
+  let i = b.g[key];
+  if (i !== void 0) {
+    return i;
+  }
+  let inlinedLocation = fromString(location);
+  b.g[key] = inlinedLocation;
+  return inlinedLocation;
+}
+function secondAllocate(v) {
+  let b = this;
+  b.l = b.l + "," + v;
+}
+function initialAllocate(v) {
+  let b = this;
+  b.l = v;
+  b.a = secondAllocate;
+}
+function rootScope(flag, defs) {
+  let global2 = {
+    c: "",
+    l: "",
+    a: initialAllocate,
+    v: -1,
+    o: flag,
+    f: "",
+    e: [],
+    d: defs
+  };
+  global2.g = global2;
+  return global2;
+}
+function allocateScope(b) {
+  delete b.a;
+  let varsAllocation = b.l;
+  if (varsAllocation === "") {
+    return b.f + b.c;
+  } else {
+    return b.f + `let ` + varsAllocation + `;` + b.c;
+  }
+}
+function varWithoutAllocation(global2) {
+  let newCounter = global2.v + 1;
+  global2.v = newCounter;
+  return `v` + newCounter;
+}
+function _var(_b) {
+  return this.i;
+}
+function _notVar(b) {
+  let val2 = this;
+  let v = varWithoutAllocation(b.g);
+  let i = val2.i;
+  if (i === "") {
+    val2.b.a(v);
+  } else if (b.a !== void 0) {
+    b.a(v + `=` + i);
+  } else {
+    b.c = b.c + (v + `=` + i + `;`);
+    b.g.a(v);
+  }
+  val2.v = _var;
+  val2.i = v;
+  return v;
+}
+function allocateVal(b, schema3) {
+  let v = varWithoutAllocation(b.g);
+  b.a(v);
+  return {
+    b,
+    v: _var,
+    i: v,
+    f: 0,
+    type: schema3.type
+  };
+}
+function val(b, initial, schema3) {
+  return {
+    b,
+    v: _notVar,
+    i: initial,
+    f: 0,
+    type: schema3.type
+  };
+}
+function constVal(b, schema3) {
+  return {
+    b,
+    v: _notVar,
+    i: inlineConst(b, schema3),
+    f: 0,
+    type: schema3.type,
+    const: schema3.const
+  };
+}
+function asyncVal(b, initial) {
+  return {
+    b,
+    v: _notVar,
+    i: initial,
+    f: 2,
+    type: "unknown"
+  };
+}
+function objectJoin(inlinedLocation, value) {
+  return inlinedLocation + `:` + value + `,`;
+}
+function arrayJoin(_inlinedLocation, value) {
+  return value + ",";
+}
+function make(b, isArray) {
+  return {
+    b,
+    v: _notVar,
+    i: "",
+    f: 0,
+    type: isArray ? "array" : "object",
+    properties: {},
+    additionalItems: "strict",
+    j: isArray ? arrayJoin : objectJoin,
+    c: 0,
+    r: ""
+  };
+}
+function add(objectVal, location, val2) {
+  let inlinedLocation = inlineLocation(objectVal.b, location);
+  objectVal.properties[location] = val2;
+  if (val2.f & 2) {
+    objectVal.r = objectVal.r + val2.i + ",";
+    objectVal.i = objectVal.i + objectVal.j(inlinedLocation, `a[` + objectVal.c++ + `]`);
+  } else {
+    objectVal.i = objectVal.i + objectVal.j(inlinedLocation, val2.i);
+  }
+}
+function complete(objectVal, isArray) {
+  objectVal.i = isArray ? "[" + objectVal.i + "]" : "{" + objectVal.i + "}";
+  if (objectVal.c) {
+    objectVal.f = objectVal.f | 2;
+    objectVal.i = `Promise.all([` + objectVal.r + `]).then(a=>(` + objectVal.i + `))`;
+  }
+  objectVal.additionalItems = "strict";
+  return objectVal;
+}
+function addKey(b, input, key, val2) {
+  return input.v(b) + `[` + key + `]=` + val2.i;
+}
+function set(b, input, val2) {
+  if (input === val2) {
+    return "";
+  }
+  let inputVar = input.v(b);
+  let match = input.f & 2;
+  let match$1 = val2.f & 2;
+  if (match) {
+    if (!match$1) {
+      return inputVar + `=Promise.resolve(` + val2.i + `)`;
+    }
+  } else if (match$1) {
+    input.f = input.f | 2;
+    return inputVar + `=` + val2.i;
+  }
+  return inputVar + `=` + val2.i;
+}
+function get(b, targetVal, location) {
+  let properties = targetVal.properties;
+  let val2 = properties[location];
+  if (val2 !== void 0) {
+    return val2;
+  }
+  let schema3 = targetVal.additionalItems;
+  let schema$1;
+  if (schema3 === "strip" || schema3 === "strict") {
+    if (schema3 === "strip") {
+      throw new Error(`[Sury] The schema doesn't have additional items`);
+    }
+    throw new Error(`[Sury] The schema doesn't have additional items`);
+  } else {
+    schema$1 = schema3;
+  }
+  let val$1 = {
+    b,
+    v: _notVar,
+    i: targetVal.v(b) + (`[` + fromString(location) + `]`),
+    f: 0,
+    type: schema$1.type
+  };
+  properties[location] = val$1;
+  return val$1;
+}
+function setInlined(b, input, inlined) {
+  return input.v(b) + `=` + inlined;
+}
+function map(inlinedFn, input) {
+  return {
+    b: input.b,
+    v: _notVar,
+    i: inlinedFn + `(` + input.i + `)`,
+    f: 0,
+    type: "unknown"
+  };
+}
+function $$throw(b, code, path) {
+  throw new SuryError(code, b.g.o, path);
+}
+function failWithArg(b, path, fn, arg) {
+  return embed(b, (arg2) => $$throw(b, fn(arg2), path)) + `(` + arg + `)`;
+}
+function withPathPrepend(b, input, path, maybeDynamicLocationVar, appendSafe, fn) {
+  if (path === "" && maybeDynamicLocationVar === void 0) {
+    return fn(b, input, path);
+  }
+  try {
+    let $$catch = (b2, errorVar2) => {
+      b2.c = errorVar2 + `.path=` + fromString(path) + `+` + (maybeDynamicLocationVar !== void 0 ? `'["'+` + maybeDynamicLocationVar + `+'"]'+` : "") + errorVar2 + `.path`;
+    };
+    let fn$1 = (b2) => fn(b2, input, "");
+    let prevCode = b.c;
+    b.c = "";
+    let errorVar = varWithoutAllocation(b.g);
+    let maybeResolveVal = $$catch(b, errorVar);
+    let catchCode = `if(` + (errorVar + `&&` + errorVar + `.s===s`) + `){` + b.c;
+    b.c = "";
+    let bb = {
+      c: "",
+      l: "",
+      a: initialAllocate,
+      f: "",
+      g: b.g
+    };
+    let fnOutput = fn$1(bb);
+    b.c = b.c + allocateScope(bb);
+    let isNoop = fnOutput.i === input.i && b.c === "";
+    if (appendSafe !== void 0) ;
+    if (isNoop) {
+      return fnOutput;
+    }
+    let isAsync2 = fnOutput.f & 2;
+    let output = input === fnOutput ? input : appendSafe !== void 0 ? fnOutput : {
+      b,
+      v: _notVar,
+      i: "",
+      f: isAsync2 ? 2 : 0,
+      type: "unknown"
+    };
+    let catchCode$1 = maybeResolveVal !== void 0 ? (catchLocation) => catchCode + (catchLocation === 1 ? `return ` + maybeResolveVal.i : set(b, output, maybeResolveVal)) + (`}else{throw ` + errorVar + `}`) : (param) => catchCode + `}throw ` + errorVar;
+    b.c = prevCode + (`try{` + b.c + (isAsync2 ? setInlined(b, output, fnOutput.i + `.catch(` + errorVar + `=>{` + catchCode$1(1) + `})`) : set(b, output, fnOutput)) + `}catch(` + errorVar + `){` + catchCode$1(0) + `}`);
+    return output;
+  } catch (exn) {
+    let error = getOrRethrow(exn);
+    throw new SuryError(error.code, error.flag, path + "[]" + error.path);
+  }
+}
+function validation(b, inputVar, schema3, negative) {
+  let eq = negative ? "!==" : "===";
+  let and_ = negative ? "||" : "&&";
+  let exp = negative ? "!" : "";
+  let tag = schema3.type;
+  let tagFlag = flags[tag];
+  if (tagFlag & 2048) {
+    return exp + (`Number.isNaN(` + inputVar + `)`);
+  }
+  if (constField in schema3) {
+    return inputVar + eq + inlineConst(b, schema3);
+  }
+  if (tagFlag & 4) {
+    return `typeof ` + inputVar + eq + `"` + tag + `"`;
+  }
+  if (tagFlag & 64) {
+    return `typeof ` + inputVar + eq + `"` + tag + `"` + and_ + exp + inputVar;
+  }
+  if (tagFlag & 128) {
+    return exp + `Array.isArray(` + inputVar + `)`;
+  }
+  if (!(tagFlag & 8192)) {
+    return `typeof ` + inputVar + eq + `"` + tag + `"`;
+  }
+  let c = inputVar + ` instanceof ` + embed(b, schema3.class);
+  if (negative) {
+    return `!(` + c + `)`;
+  } else {
+    return c;
+  }
+}
+function refinement(b, inputVar, schema3, negative) {
+  let eq = negative ? "!==" : "===";
+  let and_ = negative ? "||" : "&&";
+  let not_ = negative ? "" : "!";
+  let lt = negative ? ">" : "<";
+  let gt = negative ? "<" : ">";
+  let match = schema3.type;
+  let tag;
+  let exit = 0;
+  let match$1 = schema3.const;
+  if (match$1 !== void 0) {
+    return "";
+  }
+  let match$2 = schema3.format;
+  if (match$2 !== void 0) {
+    switch (match$2) {
+      case "int32":
+        return and_ + inputVar + lt + `2147483647` + and_ + inputVar + gt + `-2147483648` + and_ + inputVar + `%1` + eq + `0`;
+      case "port":
+      case "json":
+        exit = 2;
+        break;
+    }
+  } else {
+    exit = 2;
+  }
+  if (exit === 2) {
+    switch (match) {
+      case "number":
+        {
+          return and_ + not_ + `Number.isNaN(` + inputVar + `)`;
+        }
+      case "array":
+      case "object":
+        tag = match;
+        break;
+      default:
+        return "";
+    }
+  }
+  let additionalItems = schema3.additionalItems;
+  let items = schema3.items;
+  let length2 = items.length;
+  let code = tag === "array" ? additionalItems === "strip" || additionalItems === "strict" ? additionalItems === "strip" ? and_ + inputVar + `.length` + gt + length2 : and_ + inputVar + `.length` + eq + length2 : "" : additionalItems === "strip" ? "" : and_ + not_ + `Array.isArray(` + inputVar + `)`;
+  for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
+    let match$3 = items[idx];
+    let location = match$3.location;
+    let item = match$3.schema;
+    let itemCode;
+    if (constField in item || schema3.unnest) {
+      let inlinedLocation = inlineLocation(b, location);
+      itemCode = validation(b, inputVar + (`[` + inlinedLocation + `]`), item, negative);
+    } else if (item.items) {
+      let inlinedLocation$1 = inlineLocation(b, location);
+      let inputVar$1 = inputVar + (`[` + inlinedLocation$1 + `]`);
+      itemCode = validation(b, inputVar$1, item, negative) + refinement(b, inputVar$1, item, negative);
+    } else {
+      itemCode = "";
+    }
+    if (itemCode !== "") {
+      code = code + and_ + itemCode;
+    }
+  }
+  return code;
+}
+function makeRefinedOf(b, input, schema3) {
+  let mut = {
+    b,
+    v: input.v,
+    i: input.i,
+    f: input.f,
+    type: schema3.type
+  };
+  let loop = (mut2, schema4) => {
+    if (constField in schema4) {
+      mut2.const = schema4.const;
+    }
+    let items = schema4.items;
+    if (items === void 0) {
+      return;
+    }
+    let properties = {};
+    items.forEach((item) => {
+      let schema5 = item.schema;
+      let isConst = constField in schema5;
+      if (!(isConst || schema5.items)) {
+        return;
+      }
+      let tmp;
+      if (isConst) {
+        tmp = inlineConst(b, schema5);
+      } else {
+        let inlinedLocation = inlineLocation(b, item.location);
+        tmp = mut2.v(b) + (`[` + inlinedLocation + `]`);
+      }
+      let mut$1 = {
+        b: mut2.b,
+        v: _notVar,
+        i: tmp,
+        f: 0,
+        type: schema5.type
+      };
+      loop(mut$1, schema5);
+      properties[item.location] = mut$1;
+    });
+    mut2.properties = properties;
+    mut2.additionalItems = unknown;
+  };
+  loop(mut, schema3);
+  return mut;
+}
+function typeFilterCode(b, schema3, input, path) {
+  if (schema3.noValidation || flags[schema3.type] & 17153) {
+    return "";
+  }
+  let inputVar = input.v(b);
+  return `if(` + validation(b, inputVar, schema3, true) + refinement(b, inputVar, schema3, true) + `){` + failWithArg(b, path, (input2) => ({
+    TAG: "InvalidType",
+    expected: schema3,
+    received: input2
+  }), inputVar) + `}`;
+}
+function unsupportedTransform(b, from, target, path) {
+  return $$throw(b, {
+    TAG: "UnsupportedTransformation",
+    from,
+    to: target
+  }, path);
+}
+function noopOperation(i) {
+  return i;
+}
+function setHas(has2, tag) {
+  has2[tag === "union" || tag === "ref" ? "unknown" : tag] = true;
+}
+var jsonName = `JSON`;
+var jsonString = shaken("jsonString");
+function inputToString(b, input) {
+  return val(b, `""+` + input.i, string);
+}
+function parse(prevB, schema3, inputArg, path) {
+  let b = {
+    c: "",
+    l: "",
+    a: initialAllocate,
+    f: "",
+    g: prevB.g
+  };
+  if (schema3.$defs) {
+    b.g.d = schema3.$defs;
+  }
+  let input = inputArg;
+  let isFromLiteral = constField in input;
+  let isSchemaLiteral = constField in schema3;
+  let isSameTag = input.type === schema3.type;
+  let schemaTagFlag = flags[schema3.type];
+  let inputTagFlag = flags[input.type];
+  let isUnsupported = false;
+  if (!(schemaTagFlag & 257 || schema3.format === "json")) {
+    if (schema3.name === jsonName && !(inputTagFlag & 1)) {
+      if (!(inputTagFlag & 14)) {
+        if (inputTagFlag & 1024) {
+          input = inputToString(b, input);
+        } else {
+          isUnsupported = true;
+        }
+      }
+    } else if (isSchemaLiteral) {
+      if (isFromLiteral) {
+        if (input.const !== schema3.const) {
+          input = constVal(b, schema3);
+        }
+      } else if (inputTagFlag & 2 && schemaTagFlag & 3132) {
+        let inputVar = input.v(b);
+        b.f = schema3.noValidation ? "" : input.i + `==="` + schema3.const + `"||` + failWithArg(b, path, (input2) => ({
+          TAG: "InvalidType",
+          expected: schema3,
+          received: input2
+        }), inputVar) + `;`;
+        input = constVal(b, schema3);
+      } else if (schema3.noValidation) {
+        input = constVal(b, schema3);
+      } else {
+        b.f = typeFilterCode(prevB, schema3, input, path);
+        input.type = schema3.type;
+        input.const = schema3.const;
+      }
+    } else if (isFromLiteral && !isSchemaLiteral) {
+      if (!isSameTag) {
+        if (schemaTagFlag & 2 && inputTagFlag & 3132) {
+          let $$const = "" + input.const;
+          input = {
+            b,
+            v: _notVar,
+            i: `"` + $$const + `"`,
+            f: 0,
+            type: "string",
+            const: $$const
+          };
+        } else {
+          isUnsupported = true;
+        }
+      }
+    } else if (inputTagFlag & 1) {
+      let ref = schema3.$ref;
+      if (ref !== void 0) {
+        let defs = b.g.d;
+        let identifier = ref.slice(8);
+        let def = defs[identifier];
+        let flag = schema3.noValidation ? (b.g.o | 1) ^ 1 : b.g.o;
+        let fn = def[flag];
+        let recOperation;
+        if (fn !== void 0) {
+          let fn$1 = valFromOption(fn);
+          recOperation = fn$1 === 0 ? embed(b, def) + (`[` + flag + `]`) : embed(b, fn$1);
+        } else {
+          def[flag] = 0;
+          let fn$2 = internalCompile(def, flag, b.g.d);
+          def[flag] = fn$2;
+          recOperation = embed(b, fn$2);
+        }
+        input = withPathPrepend(b, input, path, void 0, void 0, (param, input2, param$1) => {
+          let output = map(recOperation, input2);
+          if (def.isAsync === void 0) {
+            let defsMut = copy(defs);
+            defsMut[identifier] = unknown;
+            isAsyncInternal(def, defsMut);
+          }
+          if (def.isAsync) {
+            output.f = output.f | 2;
+          }
+          return output;
+        });
+        input.v(b);
+      } else {
+        if (b.g.o & 1) {
+          b.f = typeFilterCode(prevB, schema3, input, path);
+        }
+        let refined = makeRefinedOf(b, input, schema3);
+        input.type = refined.type;
+        input.i = refined.i;
+        input.v = refined.v;
+        input.additionalItems = refined.additionalItems;
+        input.properties = refined.properties;
+        if (constField in refined) {
+          input.const = refined.const;
+        }
+      }
+    } else if (schemaTagFlag & 2 && inputTagFlag & 1036) {
+      input = inputToString(b, input);
+    } else if (!isSameTag) {
+      if (inputTagFlag & 2) {
+        let inputVar$1 = input.v(b);
+        if (schemaTagFlag & 8) {
+          let output = allocateVal(b, schema3);
+          b.c = b.c + (`(` + output.i + `=` + inputVar$1 + `==="true")||` + inputVar$1 + `==="false"||` + failWithArg(b, path, (input2) => ({
+            TAG: "InvalidType",
+            expected: schema3,
+            received: input2
+          }), inputVar$1) + `;`);
+          input = output;
+        } else if (schemaTagFlag & 4) {
+          let output$1 = val(b, `+` + inputVar$1, schema3);
+          let outputVar = output$1.v(b);
+          let match = schema3.format;
+          b.c = b.c + (match !== void 0 ? `(` + refinement(b, outputVar, schema3, true).slice(2) + `)` : `Number.isNaN(` + outputVar + `)`) + (`&&` + failWithArg(b, path, (input2) => ({
+            TAG: "InvalidType",
+            expected: schema3,
+            received: input2
+          }), inputVar$1) + `;`);
+          input = output$1;
+        } else if (schemaTagFlag & 1024) {
+          let output$2 = allocateVal(b, schema3);
+          b.c = b.c + (`try{` + output$2.i + `=BigInt(` + inputVar$1 + `)}catch(_){` + failWithArg(b, path, (input2) => ({
+            TAG: "InvalidType",
+            expected: schema3,
+            received: input2
+          }), inputVar$1) + `}`);
+          input = output$2;
+        } else {
+          isUnsupported = true;
+        }
+      } else if (inputTagFlag & 4 && schemaTagFlag & 1024) {
+        input = val(b, `BigInt(` + input.i + `)`, schema3);
+      } else {
+        isUnsupported = true;
+      }
+    }
+  }
+  if (isUnsupported) {
+    unsupportedTransform(b, input, schema3, path);
+  }
+  let compiler2 = schema3.compiler;
+  if (compiler2 !== void 0) {
+    input = compiler2(b, input, schema3, path);
+  }
+  if (input.t !== true) {
+    let refiner = schema3.refiner;
+    if (refiner !== void 0) {
+      b.c = b.c + refiner(b, input.v(b), schema3, path);
+    }
+  }
+  let to2 = schema3.to;
+  if (to2 !== void 0) {
+    let parser2 = schema3.parser;
+    if (parser2 !== void 0) {
+      input = parser2(b, input, schema3, path);
+    }
+    if (input.t !== true) {
+      input = parse(b, to2, input, path);
+    }
+  }
+  prevB.c = prevB.c + allocateScope(b);
+  return input;
+}
+function isAsyncInternal(schema3, defs) {
+  try {
+    let b = rootScope(2, defs);
+    let input = {
+      b,
+      v: _var,
+      i: "i",
+      f: 0,
+      type: "unknown"
+    };
+    let output = parse(b, schema3, input, "");
+    let isAsync2 = has(output.f, 2);
+    schema3.isAsync = isAsync2;
+    return isAsync2;
+  } catch (exn) {
+    getOrRethrow(exn);
+    return false;
+  }
+}
+function internalCompile(schema3, flag, defs) {
+  let b = rootScope(flag, defs);
+  if (flag & 8) {
+    let output = reverse(schema3);
+    jsonableValidation(output, output, "", flag);
+  }
+  let input = {
+    b,
+    v: _var,
+    i: "i",
+    f: 0,
+    type: "unknown"
+  };
+  let schema$1 = flag & 4 ? updateOutput(schema3, (mut) => {
+    let t = new Schema(unit.type);
+    t.const = unit.const;
+    t.noValidation = true;
+    mut.to = t;
+  }) : flag & 16 ? updateOutput(schema3, (mut) => {
+    mut.to = jsonString;
+  }) : schema3;
+  let output$1 = parse(b, schema$1, input, "");
+  let code = allocateScope(b);
+  let isAsync2 = has(output$1.f, 2);
+  schema$1.isAsync = isAsync2;
+  if (code === "" && output$1 === input && !(flag & 2)) {
+    return noopOperation;
+  }
+  let inlinedOutput = output$1.i;
+  if (flag & 2 && !isAsync2 && !defs) {
+    inlinedOutput = `Promise.resolve(` + inlinedOutput + `)`;
+  }
+  let inlinedFunction = `i=>{` + code + `return ` + inlinedOutput + `}`;
+  let ctxVarValue1 = b.g.e;
+  return new Function("e", "s", `return ` + inlinedFunction)(ctxVarValue1, s);
+}
+function reverse(schema3) {
+  let reversedHead;
+  let current = schema3;
+  while (current) {
+    let mut = copyWithoutCache(current);
+    let next = mut.to;
+    let to2 = reversedHead;
+    if (to2 !== void 0) {
+      mut.to = to2;
+    } else {
+      delete mut.to;
+    }
+    let parser2 = mut.parser;
+    let serializer = mut.serializer;
+    if (serializer !== void 0) {
+      mut.parser = serializer;
+    } else {
+      delete mut.parser;
+    }
+    if (parser2 !== void 0) {
+      mut.serializer = parser2;
+    } else {
+      delete mut.serializer;
+    }
+    let fromDefault = mut.fromDefault;
+    let $$default = mut.default;
+    if ($$default !== void 0) {
+      mut.fromDefault = $$default;
+    } else {
+      delete mut.fromDefault;
+    }
+    if (fromDefault !== void 0) {
+      mut.default = fromDefault;
+    } else {
+      delete mut.default;
+    }
+    let items = mut.items;
+    if (items !== void 0) {
+      let properties = {};
+      let newItems = new Array(items.length);
+      for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
+        let item = items[idx];
+        let reversed_schema = reverse(item.schema);
+        let reversed_location = item.location;
+        let reversed = {
+          schema: reversed_schema,
+          location: reversed_location
+        };
+        if (item.r) {
+          reversed.r = item.r;
+        }
+        properties[item.location] = reversed_schema;
+        newItems[idx] = reversed;
+      }
+      mut.items = newItems;
+      let match = mut.properties;
+      if (match !== void 0) {
+        mut.properties = properties;
+      }
+    }
+    if (typeof mut.additionalItems === "object") {
+      mut.additionalItems = reverse(mut.additionalItems);
+    }
+    let anyOf = mut.anyOf;
+    if (anyOf !== void 0) {
+      let has2 = {};
+      let newAnyOf = [];
+      for (let idx$1 = 0, idx_finish$1 = anyOf.length; idx$1 < idx_finish$1; ++idx$1) {
+        let s2 = anyOf[idx$1];
+        let reversed$1 = reverse(s2);
+        newAnyOf.push(reversed$1);
+        setHas(has2, reversed$1.type);
+      }
+      mut.has = has2;
+      mut.anyOf = newAnyOf;
+    }
+    let defs = mut.$defs;
+    if (defs !== void 0) {
+      let reversedDefs = {};
+      for (let idx$2 = 0, idx_finish$2 = Object.keys(defs).length; idx$2 < idx_finish$2; ++idx$2) {
+        let key = Object.keys(defs)[idx$2];
+        reversedDefs[key] = reverse(defs[key]);
+      }
+      mut.$defs = reversedDefs;
+    }
+    reversedHead = mut;
+    current = next;
+  }
+  return reversedHead;
+}
+function jsonableValidation(output, parent, path, flag) {
+  let tagFlag = flags[output.type];
+  if (tagFlag & 48129 || tagFlag & 16 && parent.type !== "object") {
+    throw new SuryError({
+      TAG: "InvalidJsonSchema",
+      _0: parent
+    }, flag, path);
+  }
+  if (tagFlag & 256) {
+    output.anyOf.forEach((s2) => jsonableValidation(s2, parent, path, flag));
+    return;
+  }
+  if (!(tagFlag & 192)) {
+    return;
+  }
+  let additionalItems = output.additionalItems;
+  if (additionalItems === "strip" || additionalItems === "strict") ; else {
+    jsonableValidation(additionalItems, parent, path, flag);
+  }
+  let p2 = output.properties;
+  if (p2 !== void 0) {
+    let keys = Object.keys(p2);
+    for (let idx = 0, idx_finish = keys.length; idx < idx_finish; ++idx) {
+      let key = keys[idx];
+      jsonableValidation(p2[key], parent, path, flag);
+    }
+    return;
+  }
+  output.items.forEach((item) => jsonableValidation(item.schema, output, path + (`[` + fromString(item.location) + `]`), flag));
+}
+function getOutputSchema(_schema) {
+  while (true) {
+    let schema3 = _schema;
+    let to2 = schema3.to;
+    if (to2 === void 0) {
+      return schema3;
+    }
+    _schema = to2;
+    continue;
+  }
+}
+function operationFn(s2, o) {
+  if (o in s2) {
+    return s2[o];
+  }
+  let f = internalCompile(s2, o, 0);
+  s2[o] = f;
+  return f;
+}
+d(sp, "~standard", {
+  get: function() {
+    let schema3 = this;
+    return {
+      version: 1,
+      vendor,
+      validate: (input) => {
+        try {
+          return {
+            value: operationFn(schema3, 1)(input)
+          };
+        } catch (exn) {
+          let error = getOrRethrow(exn);
+          return {
+            issues: [{
+              message: reason(error, void 0),
+              path: error.path === "" ? void 0 : toArray2(error.path)
+            }]
+          };
+        }
+      }
+    };
+  }
+});
+var $$null = new Schema("null");
+$$null.const = null;
+function parse$1(value) {
+  if (value === null) {
+    return $$null;
+  }
+  let $$typeof = typeof value;
+  let schema3;
+  if ($$typeof === "object") {
+    let i = new Schema("instance");
+    i.class = value.constructor;
+    schema3 = i;
+  } else {
+    schema3 = $$typeof === "undefined" ? unit : $$typeof === "number" ? Number.isNaN(value) ? new Schema("nan") : new Schema($$typeof) : new Schema($$typeof);
+  }
+  schema3.const = value;
+  return schema3;
+}
+var defsPath = `#/$defs/`;
+function appendRefiner(maybeExistingRefiner, refiner) {
+  if (maybeExistingRefiner !== void 0) {
+    return (b, inputVar, selfSchema, path) => maybeExistingRefiner(b, inputVar, selfSchema, path) + refiner(b, inputVar, selfSchema, path);
+  } else {
+    return refiner;
+  }
+}
+var nullAsUnit = new Schema("null");
+nullAsUnit.const = null;
+nullAsUnit.to = unit;
+function neverBuilder(b, input, selfSchema, path) {
+  b.c = b.c + failWithArg(b, path, (input2) => ({
+    TAG: "InvalidType",
+    expected: selfSchema,
+    received: input2
+  }), input.i) + ";";
+  return input;
+}
+var never = new Schema("never");
+never.compiler = neverBuilder;
+var nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE";
+function getItemCode(b, schema3, input, output, deopt, path) {
+  try {
+    let globalFlag = b.g.o;
+    if (deopt) {
+      b.g.o = globalFlag | 1;
+    }
+    let bb = {
+      c: "",
+      l: "",
+      a: initialAllocate,
+      f: "",
+      g: b.g
+    };
+    let input$1 = deopt ? copy(input) : makeRefinedOf(bb, input, schema3);
+    let itemOutput = parse(bb, schema3, input$1, path);
+    if (itemOutput !== input$1) {
+      itemOutput.b = bb;
+      if (itemOutput.f & 2) {
+        output.f = output.f | 2;
+      }
+      bb.c = bb.c + (output.v(b) + `=` + itemOutput.i);
+    }
+    b.g.o = globalFlag;
+    return allocateScope(bb);
+  } catch (exn) {
+    return "throw " + embed(b, getOrRethrow(exn));
+  }
+}
+function isPriority(tagFlag, byKey) {
+  if (tagFlag & 8320 && "object" in byKey) {
+    return true;
+  } else if (tagFlag & 2048) {
+    return "number" in byKey;
+  } else {
+    return false;
+  }
+}
+function isWiderUnionSchema(schemaAnyOf, inputAnyOf) {
+  return inputAnyOf.every((inputSchema, idx) => {
+    let schema3 = schemaAnyOf[idx];
+    if (schema3 !== void 0 && !(flags[inputSchema.type] & 9152) && inputSchema.type === schema3.type) {
+      return inputSchema.const === schema3.const;
+    } else {
+      return false;
+    }
+  });
+}
+function compiler(b, input, selfSchema, path) {
+  let schemas = selfSchema.anyOf;
+  let inputAnyOf = input.anyOf;
+  if (inputAnyOf !== void 0) {
+    if (isWiderUnionSchema(schemas, inputAnyOf)) {
+      return input;
+    } else {
+      return unsupportedTransform(b, input, selfSchema, path);
+    }
+  }
+  let fail = (caught2) => embed(b, function() {
+    let args = arguments;
+    return $$throw(b, {
+      TAG: "InvalidType",
+      expected: selfSchema,
+      received: args[0],
+      unionErrors: args.length > 1 ? Array.from(args).slice(1) : void 0
+    }, path);
+  }) + `(` + input.v(b) + caught2 + `)`;
+  let typeValidation = b.g.o & 1;
+  let initialInline = input.i;
+  let deoptIdx = -1;
+  let lastIdx = schemas.length - 1 | 0;
+  let byKey = {};
+  let keys = [];
+  for (let idx = 0; idx <= lastIdx; ++idx) {
+    let target = selfSchema.to;
+    let schema3 = target !== void 0 && !selfSchema.parser && target.type !== "union" ? updateOutput(schemas[idx], (mut) => {
+      let refiner = selfSchema.refiner;
+      if (refiner !== void 0) {
+        mut.refiner = appendRefiner(mut.refiner, refiner);
+      }
+      mut.to = target;
+    }) : schemas[idx];
+    let tag = schema3.type;
+    let tagFlag = flags[tag];
+    if (!(tagFlag & 16 && "fromDefault" in selfSchema)) {
+      if (tagFlag & 17153 || !(flags[input.type] & 1) && input.type !== tag) {
+        deoptIdx = idx;
+        byKey = {};
+        keys = [];
+      } else {
+        let key = tagFlag & 8192 ? schema3.class.name : tag;
+        let arr = byKey[key];
+        if (arr !== void 0) {
+          if (tagFlag & 64 && nestedLoc in schema3.properties) {
+            arr.unshift(schema3);
+          } else if (!(tagFlag & 2096)) {
+            arr.push(schema3);
+          }
+        } else {
+          if (isPriority(tagFlag, byKey)) {
+            keys.unshift(key);
+          } else {
+            keys.push(key);
+          }
+          byKey[key] = [schema3];
+        }
+      }
+    }
+  }
+  let deoptIdx$1 = deoptIdx;
+  let byKey$1 = byKey;
+  let keys$1 = keys;
+  let start = "";
+  let end = "";
+  let caught = "";
+  let exit = false;
+  if (deoptIdx$1 !== -1) {
+    for (let idx$1 = 0; idx$1 <= deoptIdx$1; ++idx$1) {
+      if (!exit) {
+        let schema$1 = schemas[idx$1];
+        let itemCode = getItemCode(b, schema$1, input, input, true, path);
+        if (itemCode) {
+          let errorVar = `e` + idx$1;
+          start = start + (`try{` + itemCode + `}catch(` + errorVar + `){`);
+          end = "}" + end;
+          caught = caught + `,` + errorVar;
+        } else {
+          exit = true;
+        }
+      }
+    }
+  }
+  if (!exit) {
+    let nextElse = false;
+    let noop = "";
+    for (let idx$2 = 0, idx_finish = keys$1.length; idx$2 < idx_finish; ++idx$2) {
+      let schemas$1 = byKey$1[keys$1[idx$2]];
+      let isMultiple = schemas$1.length > 1;
+      let firstSchema = schemas$1[0];
+      let cond = 0;
+      let body;
+      if (isMultiple) {
+        let inputVar = input.v(b);
+        let itemStart = "";
+        let itemEnd = "";
+        let itemNextElse = false;
+        let itemNoop = {
+          contents: ""
+        };
+        let caught$1 = "";
+        let byDiscriminant = {};
+        let itemIdx = 0;
+        let lastIdx$1 = schemas$1.length - 1 | 0;
+        while (itemIdx <= lastIdx$1) {
+          let schema$2 = schemas$1[itemIdx];
+          let itemCond = (constField in schema$2 ? validation(b, inputVar, schema$2, false) : "") + refinement(b, inputVar, schema$2, false).slice(2);
+          let itemCode$1 = getItemCode(b, schema$2, input, input, false, path);
+          if (itemCond) {
+            if (itemCode$1) {
+              let match = byDiscriminant[itemCond];
+              if (match !== void 0) {
+                if (typeof match === "string") {
+                  byDiscriminant[itemCond] = [
+                    match,
+                    itemCode$1
+                  ];
+                } else {
+                  match.push(itemCode$1);
+                }
+              } else {
+                byDiscriminant[itemCond] = itemCode$1;
+              }
+            } else {
+              itemNoop.contents = itemNoop.contents ? itemNoop.contents + `||` + itemCond : itemCond;
+            }
+          }
+          if (!itemCond || itemIdx === lastIdx$1) {
+            let accedDiscriminants = Object.keys(byDiscriminant);
+            for (let idx$3 = 0, idx_finish$1 = accedDiscriminants.length; idx$3 < idx_finish$1; ++idx$3) {
+              let discrim = accedDiscriminants[idx$3];
+              let if_ = itemNextElse ? "else if" : "if";
+              itemStart = itemStart + if_ + (`(` + discrim + `){`);
+              let code = byDiscriminant[discrim];
+              if (typeof code === "string") {
+                itemStart = itemStart + code + "}";
+              } else {
+                let caught$2 = "";
+                for (let idx$4 = 0, idx_finish$2 = code.length; idx$4 < idx_finish$2; ++idx$4) {
+                  let code$1 = code[idx$4];
+                  let errorVar$1 = `e` + idx$4;
+                  itemStart = itemStart + (`try{` + code$1 + `}catch(` + errorVar$1 + `){`);
+                  caught$2 = caught$2 + `,` + errorVar$1;
+                }
+                itemStart = itemStart + fail(caught$2) + "}".repeat(code.length) + "}";
+              }
+              itemNextElse = true;
+            }
+            byDiscriminant = {};
+          }
+          if (!itemCond) {
+            if (itemCode$1) {
+              if (itemNoop.contents) {
+                let if_$1 = itemNextElse ? "else if" : "if";
+                itemStart = itemStart + if_$1 + (`(!(` + itemNoop.contents + `)){`);
+                itemEnd = "}" + itemEnd;
+                itemNoop.contents = "";
+                itemNextElse = false;
+              }
+              let errorVar$2 = `e` + itemIdx;
+              itemStart = itemStart + ((itemNextElse ? "else{" : "") + `try{` + itemCode$1 + `}catch(` + errorVar$2 + `){`);
+              itemEnd = (itemNextElse ? "}" : "") + "}" + itemEnd;
+              caught$1 = caught$1 + `,` + errorVar$2;
+              itemNextElse = false;
+            } else {
+              itemNoop.contents = "";
+              itemIdx = lastIdx$1;
+            }
+          }
+          itemIdx = itemIdx + 1;
+        }
+        cond = (inputVar2) => validation(b, inputVar2, {
+          type: firstSchema.type,
+          parser: 0
+        }, false);
+        if (itemNoop.contents) {
+          if (itemStart) {
+            if (typeValidation) {
+              let if_$2 = itemNextElse ? "else if" : "if";
+              itemStart = itemStart + if_$2 + (`(!(` + itemNoop.contents + `)){` + fail(caught$1) + `}`);
+            }
+          } else {
+            let condBefore = cond;
+            cond = (inputVar2) => condBefore(inputVar2) + (`&&(` + itemNoop.contents + `)`);
+          }
+        } else if (typeValidation && itemStart) {
+          let errorCode = fail(caught$1);
+          itemStart = itemStart + (itemNextElse ? `else{` + errorCode + `}` : errorCode);
+        }
+        body = itemStart + itemEnd;
+      } else {
+        cond = (inputVar) => validation(b, inputVar, firstSchema, false) + refinement(b, inputVar, firstSchema, false);
+        body = getItemCode(b, firstSchema, input, input, false, path);
+      }
+      if (body || isPriority(flags[firstSchema.type], byKey$1)) {
+        let if_$3 = nextElse ? "else if" : "if";
+        start = start + if_$3 + (`(` + cond(input.v(b)) + `){` + body + `}`);
+        nextElse = true;
+      } else if (typeValidation) {
+        let cond$1 = cond(input.v(b));
+        noop = noop ? noop + `||` + cond$1 : cond$1;
+      }
+    }
+    if (typeValidation || deoptIdx$1 === lastIdx) {
+      let errorCode$1 = fail(caught);
+      let tmp;
+      if (noop) {
+        let if_$4 = nextElse ? "else if" : "if";
+        tmp = if_$4 + (`(!(` + noop + `)){` + errorCode$1 + `}`);
+      } else {
+        tmp = nextElse ? `else{` + errorCode$1 + `}` : errorCode$1;
+      }
+      start = start + tmp;
+    }
+  }
+  b.c = b.c + start + end;
+  let o = input.f & 2 ? asyncVal(b, `Promise.resolve(` + input.i + `)`) : input.v === _var ? b.c === "" && input.b.c === "" && (input.b.l === input.i + `=` + initialInline || initialInline === "i") ? (input.b.l = "", input.b.a = initialAllocate, input.v = _notVar, input.i = initialInline, input) : copy(input) : input;
+  o.anyOf = selfSchema.anyOf;
+  let to2 = selfSchema.to;
+  o.type = to2 !== void 0 && to2.type !== "union" ? (o.t = true, getOutputSchema(to2).type) : "union";
+  return o;
+}
+function factory(schemas) {
+  let len = schemas.length;
+  if (len === 1) {
+    return schemas[0];
+  }
+  if (len !== 0) {
+    let has2 = {};
+    let anyOf = /* @__PURE__ */ new Set();
+    for (let idx = 0, idx_finish = schemas.length; idx < idx_finish; ++idx) {
+      let schema3 = schemas[idx];
+      if (schema3.type === "union" && schema3.to === void 0) {
+        schema3.anyOf.forEach((item) => {
+          anyOf.add(item);
+        });
+        Object.assign(has2, schema3.has);
+      } else {
+        anyOf.add(schema3);
+        setHas(has2, schema3.type);
+      }
+    }
+    let mut = new Schema("union");
+    mut.anyOf = Array.from(anyOf);
+    mut.compiler = compiler;
+    mut.has = has2;
+    return mut;
+  }
+  throw new Error(`[Sury] S.union requires at least one item`);
+}
+function nestedNone() {
+  let itemSchema = parse$1(0);
+  let item = {
+    schema: itemSchema,
+    location: nestedLoc
+  };
+  let properties = {};
+  properties[nestedLoc] = itemSchema;
+  return {
+    type: "object",
+    serializer: (b, param, selfSchema, param$1) => constVal(b, selfSchema.to),
+    additionalItems: "strip",
+    items: [item],
+    properties
+  };
+}
+function parser(b, param, selfSchema, param$1) {
+  return val(b, `{` + nestedLoc + `:` + getOutputSchema(selfSchema).items[0].schema.const + `}`, selfSchema.to);
+}
+function nestedOption(item) {
+  return updateOutput(item, (mut) => {
+    mut.to = nestedNone();
+    mut.parser = parser;
+  });
+}
+function factory$1(item, unitOpt) {
+  let unit$1 = unitOpt !== void 0 ? unitOpt : unit;
+  let match = getOutputSchema(item);
+  let match$1 = match.type;
+  switch (match$1) {
+    case "undefined":
+      return factory([
+        unit$1,
+        nestedOption(item)
+      ]);
+    case "union":
+      let has2 = match.has;
+      let anyOf = match.anyOf;
+      return updateOutput(item, (mut) => {
+        let mutHas = copy(has2);
+        let newAnyOf = [];
+        for (let idx = 0, idx_finish = anyOf.length; idx < idx_finish; ++idx) {
+          let schema3 = anyOf[idx];
+          let match2 = getOutputSchema(schema3);
+          let match$12 = match2.type;
+          let tmp;
+          if (match$12 === "undefined") {
+            mutHas[unit$1.type] = true;
+            newAnyOf.push(unit$1);
+            tmp = nestedOption(schema3);
+          } else {
+            let properties = match2.properties;
+            if (properties !== void 0) {
+              let nestedSchema = properties[nestedLoc];
+              tmp = nestedSchema !== void 0 ? updateOutput(schema3, (mut2) => {
+                let newItem_schema = {
+                  type: nestedSchema.type,
+                  parser: nestedSchema.parser,
+                  const: nestedSchema.const + 1
+                };
+                let newItem = {
+                  schema: newItem_schema,
+                  location: nestedLoc
+                };
+                let properties2 = {};
+                properties2[nestedLoc] = newItem_schema;
+                mut2.items = [newItem];
+                mut2.properties = properties2;
+              }) : schema3;
+            } else {
+              tmp = schema3;
+            }
+          }
+          newAnyOf.push(tmp);
+        }
+        if (newAnyOf.length === anyOf.length) {
+          mutHas[unit$1.type] = true;
+          newAnyOf.push(unit$1);
+        }
+        mut.anyOf = newAnyOf;
+        mut.has = mutHas;
+      });
+    default:
+      return factory([
+        item,
+        unit$1
+      ]);
+  }
+}
+function arrayCompiler(b, input, selfSchema, path) {
+  let item = selfSchema.additionalItems;
+  let inputVar = input.v(b);
+  let iteratorVar = varWithoutAllocation(b.g);
+  let bb = {
+    c: "",
+    l: "",
+    a: initialAllocate,
+    f: "",
+    g: b.g
+  };
+  let itemInput = val(bb, inputVar + `[` + iteratorVar + `]`, unknown);
+  let itemOutput = withPathPrepend(bb, itemInput, path, iteratorVar, void 0, (b2, input2, path2) => parse(b2, item, input2, path2));
+  let itemCode = allocateScope(bb);
+  let isTransformed = itemInput !== itemOutput;
+  let output = isTransformed ? val(b, `new Array(` + inputVar + `.length)`, selfSchema) : input;
+  output.type = selfSchema.type;
+  output.additionalItems = selfSchema.additionalItems;
+  if (isTransformed || itemCode !== "") {
+    b.c = b.c + (`for(let ` + iteratorVar + `=0;` + iteratorVar + `<` + inputVar + `.length;++` + iteratorVar + `){` + itemCode + (isTransformed ? addKey(b, output, iteratorVar, itemOutput) : "") + `}`);
+  }
+  if (itemOutput.f & 2) {
+    return asyncVal(output.b, `Promise.all(` + output.i + `)`);
+  } else {
+    return output;
+  }
+}
+function factory$2(item) {
+  let mut = new Schema("array");
+  mut.additionalItems = item;
+  mut.items = immutableEmpty$1;
+  mut.compiler = arrayCompiler;
+  return mut;
+}
+function dictCompiler(b, input, selfSchema, path) {
+  let item = selfSchema.additionalItems;
+  let inputVar = input.v(b);
+  let keyVar = varWithoutAllocation(b.g);
+  let bb = {
+    c: "",
+    l: "",
+    a: initialAllocate,
+    f: "",
+    g: b.g
+  };
+  let itemInput = val(bb, inputVar + `[` + keyVar + `]`, unknown);
+  let itemOutput = withPathPrepend(bb, itemInput, path, keyVar, void 0, (b2, input2, path2) => parse(b2, item, input2, path2));
+  let itemCode = allocateScope(bb);
+  let isTransformed = itemInput !== itemOutput;
+  let output = isTransformed ? val(b, "{}", selfSchema) : input;
+  output.type = selfSchema.type;
+  output.additionalItems = selfSchema.additionalItems;
+  if (isTransformed || itemCode !== "") {
+    b.c = b.c + (`for(let ` + keyVar + ` in ` + inputVar + `){` + itemCode + (isTransformed ? addKey(b, output, keyVar, itemOutput) : "") + `}`);
+  }
+  if (!(itemOutput.f & 2)) {
+    return output;
+  }
+  let resolveVar = varWithoutAllocation(b.g);
+  let rejectVar = varWithoutAllocation(b.g);
+  let asyncParseResultVar = varWithoutAllocation(b.g);
+  let counterVar = varWithoutAllocation(b.g);
+  let outputVar = output.v(b);
+  return asyncVal(b, `new Promise((` + resolveVar + `,` + rejectVar + `)=>{let ` + counterVar + `=Object.keys(` + outputVar + `).length;for(let ` + keyVar + ` in ` + outputVar + `){` + outputVar + `[` + keyVar + `].then(` + asyncParseResultVar + `=>{` + outputVar + `[` + keyVar + `]=` + asyncParseResultVar + `;if(` + counterVar + `--===1){` + resolveVar + `(` + outputVar + `)}},` + rejectVar + `)}})`);
+}
+function factory$3(item) {
+  let mut = new Schema("object");
+  mut.properties = immutableEmpty;
+  mut.items = immutableEmpty$1;
+  mut.additionalItems = item;
+  mut.compiler = dictCompiler;
+  return mut;
+}
+var json = shaken("json");
+function enableJson() {
+  if (!json[shakenRef]) {
+    return;
+  }
+  delete json.as;
+  let jsonRef = new Schema("ref");
+  jsonRef.$ref = defsPath + jsonName;
+  jsonRef.name = jsonName;
+  json.type = jsonRef.type;
+  json.$ref = jsonRef.$ref;
+  json.name = jsonName;
+  let defs = {};
+  defs[jsonName] = {
+    type: "union",
+    compiler,
+    name: jsonName,
+    has: {
+      string: true,
+      boolean: true,
+      number: true,
+      null: true,
+      object: true,
+      array: true
+    },
+    anyOf: [
+      string,
+      bool,
+      float,
+      $$null,
+      factory$3(jsonRef),
+      factory$2(jsonRef)
+    ]
+  };
+  json.$defs = defs;
+}
+function objectStrictModeCheck(b, input, items, selfSchema, path) {
+  if (!(selfSchema.type === "object" && selfSchema.additionalItems === "strict" && b.g.o & 1)) {
+    return;
+  }
+  let key = allocateVal(b, unknown);
+  let keyVar = key.i;
+  b.c = b.c + (`for(` + keyVar + ` in ` + input.v(b) + `){if(`);
+  if (items.length !== 0) {
+    for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
+      let match = items[idx];
+      if (idx !== 0) {
+        b.c = b.c + "&&";
+      }
+      b.c = b.c + (keyVar + `!==` + inlineLocation(b, match.location));
+    }
+  } else {
+    b.c = b.c + "true";
+  }
+  b.c = b.c + (`){` + failWithArg(b, path, (exccessFieldName) => ({
+    TAG: "ExcessField",
+    _0: exccessFieldName
+  }), keyVar) + `}}`);
+}
+function schemaCompiler(b, input, selfSchema, path) {
+  let additionalItems = selfSchema.additionalItems;
+  let items = selfSchema.items;
+  let isArray = flags[selfSchema.type] & 128;
+  if (b.g.o & 64) {
+    let objectVal = make(b, isArray);
+    for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
+      let match = items[idx];
+      let location = match.location;
+      add(objectVal, location, input.properties[location]);
+    }
+    return complete(objectVal, isArray);
+  }
+  let objectVal$1 = make(b, isArray);
+  for (let idx$1 = 0, idx_finish$1 = items.length; idx$1 < idx_finish$1; ++idx$1) {
+    let match$1 = items[idx$1];
+    let location$1 = match$1.location;
+    let itemInput = get(b, input, location$1);
+    let inlinedLocation = inlineLocation(b, location$1);
+    let path$1 = path + (`[` + inlinedLocation + `]`);
+    add(objectVal$1, location$1, parse(b, match$1.schema, itemInput, path$1));
+  }
+  objectStrictModeCheck(b, input, items, selfSchema, path);
+  if ((additionalItems !== "strip" || b.g.o & 32) && items.every((item) => objectVal$1.properties[item.location] === input.properties[item.location])) {
+    input.additionalItems = "strip";
+    return input;
+  } else {
+    return complete(objectVal$1, isArray);
+  }
+}
+function definitionToSchema(definition) {
+  if (typeof definition !== "object" || definition === null) {
+    return parse$1(definition);
+  }
+  if (definition["~standard"]) {
+    return definition;
+  }
+  if (Array.isArray(definition)) {
+    for (let idx = 0, idx_finish = definition.length; idx < idx_finish; ++idx) {
+      let schema3 = definitionToSchema(definition[idx]);
+      let location = idx.toString();
+      definition[idx] = {
+        schema: schema3,
+        location
+      };
+    }
+    let mut = new Schema("array");
+    mut.items = definition;
+    mut.additionalItems = "strict";
+    mut.compiler = schemaCompiler;
+    return mut;
+  }
+  let cnstr = definition.constructor;
+  if (cnstr && cnstr !== Object) {
+    return {
+      type: "instance",
+      const: definition,
+      class: cnstr
+    };
+  }
+  let fieldNames = Object.keys(definition);
+  let length2 = fieldNames.length;
+  let items = [];
+  for (let idx$1 = 0; idx$1 < length2; ++idx$1) {
+    let location$1 = fieldNames[idx$1];
+    let schema$1 = definitionToSchema(definition[location$1]);
+    let item = {
+      schema: schema$1,
+      location: location$1
+    };
+    definition[location$1] = schema$1;
+    items[idx$1] = item;
+  }
+  let mut$1 = new Schema("object");
+  mut$1.items = items;
+  mut$1.properties = definition;
+  mut$1.additionalItems = globalConfig.a;
+  mut$1.compiler = schemaCompiler;
+  return mut$1;
+}
+function matches(schema3) {
+  return schema3;
+}
+var ctx = {
+  m: matches
+};
+function factory$4(definer) {
+  return definitionToSchema(definer(ctx));
+}
+var js_schema = definitionToSchema;
+function option(item) {
+  return factory$1(item, unit);
+}
+var literal = js_schema;
+var union = factory;
+var schema = factory$4;
+
+// ../../node_modules/sury/src/S.res.mjs
+var string2 = string;
+var json2 = json;
+var enableJson2 = enableJson;
+var literal2 = literal;
+var option2 = option;
+var union2 = union;
+var schema2 = schema;
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Option.js
+function mapOr(opt, $$default, f) {
+  if (opt !== void 0) {
+    return f(valFromOption(opt));
+  } else {
+    return $$default;
+  }
+}
+function map2(opt, f) {
+  if (opt !== void 0) {
+    return some(f(valFromOption(opt)));
+  }
+}
+function flatMap(opt, f) {
+  if (opt !== void 0) {
+    return f(valFromOption(opt));
+  }
+}
+function getOr(opt, $$default) {
+  if (opt !== void 0) {
+    return valFromOption(opt);
+  } else {
+    return $$default;
+  }
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Array.js
+function make2(length2, x) {
+  if (length2 <= 0) {
+    return [];
+  }
+  let arr = new Array(length2);
+  arr.fill(x);
+  return arr;
+}
+
+// src/FrontmanNextjs__CircularBuffer.res.mjs
+function make3(capacity) {
+  return {
+    data: make2(capacity, void 0),
+    writeIndex: 0,
+    count: 0,
+    maxSize: capacity
+  };
+}
+function push(buffer, entry) {
+  buffer.data[buffer.writeIndex] = some(entry);
+  return {
+    data: buffer.data,
+    writeIndex: mod_(buffer.writeIndex + 1 | 0, buffer.maxSize),
+    count: min(buffer.count + 1 | 0, buffer.maxSize),
+    maxSize: buffer.maxSize
+  };
+}
+
+// src/FrontmanNextjs__LogCapture.res.mjs
+enableJson2();
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function getPatchedFlag() {
+  return globalThis.__FRONTMAN_CONSOLE_PATCHED__;
+}
+function setPatchedFlag(_value) {
+  globalThis.__FRONTMAN_CONSOLE_PATCHED__ = _value;
+}
+var logLevelSchema = union2([
+  literal2("console"),
+  literal2("build"),
+  literal2("error")
+]);
+var consoleMethodSchema = union2([
+  literal2("log"),
+  literal2("info"),
+  literal2("warn"),
+  literal2("error"),
+  literal2("debug")
+]);
+schema2((s2) => ({
+  timestamp: s2.m(string2),
+  level: s2.m(logLevelSchema),
+  message: s2.m(string2),
+  attributes: s2.m(option2(json2)),
+  resource: s2.m(option2(json2)),
+  consoleMethod: s2.m(option2(consoleMethodSchema))
+}));
+var defaultConfig_stdoutPatterns = [
+  "webpack",
+  "turbopack",
+  "Compiled",
+  "Failed"
+];
+var defaultConfig = {
+  bufferCapacity: 1024,
+  stdoutPatterns: defaultConfig_stdoutPatterns
+};
+function getGlobalInstanceOpt() {
+  return globalThis.__FRONTMAN_INSTANCE__;
+}
+function setGlobalInstance(_state) {
+  globalThis.__FRONTMAN_INSTANCE__ = _state;
+}
+function getOrCreateInstance(config) {
+  let state = getGlobalInstanceOpt();
+  if (state !== void 0) {
+    return state;
+  }
+  let state_buffer = {
+    contents: make3(config.bufferCapacity)
+  };
+  let state$1 = {
+    buffer: state_buffer,
+    config
+  };
+  setGlobalInstance(state$1);
+  return state$1;
+}
+function getInstance() {
+  let state = getGlobalInstanceOpt();
+  if (state !== void 0) {
+    return state;
+  } else {
+    return getOrCreateInstance(defaultConfig);
+  }
+}
+function argsToString(args) {
+  return args.map((arg) => {
+    let match = typeof arg;
+    if (match === "string") {
+      return arg;
+    } else if (match === "object") {
+      if (arg instanceof Error) {
+        return getOr(arg.stack, arg.message);
+      } else {
+        return getOr(JSON.stringify(arg), "null");
+      }
+    } else {
+      return String(arg);
+    }
+  }).join(" ");
+}
+function stripAnsi(str) {
+  return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+}
+function addLog(state, level, message2, attributes, consoleMethod) {
+  let cleanMessage = stripAnsi(message2).trim();
+  if (cleanMessage === "") {
+    return;
+  }
+  let entry_timestamp = new Date(Date.now()).toISOString();
+  let entry = {
+    timestamp: entry_timestamp,
+    level,
+    message: cleanMessage,
+    attributes,
+    resource: void 0,
+    consoleMethod
+  };
+  state.buffer.contents = push(state.buffer.contents, entry);
+}
+function handleConsoleLog(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "log");
+  } catch (exn) {
+    return;
+  }
+}
+function handleConsoleWarn(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "warn");
+  } catch (exn) {
+    return;
+  }
+}
+function handleConsoleError(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "error");
+  } catch (exn) {
+    return;
+  }
+}
+function handleConsoleInfo(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "info");
+  } catch (exn) {
+    return;
+  }
+}
+function handleConsoleDebug(state, args) {
+  try {
+    return addLog(state, "console", argsToString(args), void 0, "debug");
+  } catch (exn) {
+    return;
+  }
+}
+var interceptConsole = (function(state) {
+  const originalLog = console.log.bind(console);
+  const originalWarn = console.warn.bind(console);
+  const originalError = console.error.bind(console);
+  const originalInfo = console.info.bind(console);
+  const originalDebug = console.debug.bind(console);
+  console.log = (...args) => {
+    handleConsoleLog(state, args);
+    originalLog(...args);
+  };
+  console.warn = (...args) => {
+    handleConsoleWarn(state, args);
+    originalWarn(...args);
+  };
+  console.error = (...args) => {
+    handleConsoleError(state, args);
+    originalError(...args);
+  };
+  console.info = (...args) => {
+    handleConsoleInfo(state, args);
+    originalInfo(...args);
+  };
+  console.debug = (...args) => {
+    handleConsoleDebug(state, args);
+    originalDebug(...args);
+  };
+});
+function handleStdoutWrite(state, message2) {
+  try {
+    let matchesPattern = state.config.stdoutPatterns.some((pattern2) => message2.includes(pattern2));
+    if (matchesPattern) {
+      return addLog(state, "build", message2, void 0, void 0);
+    } else {
+      return;
+    }
+  } catch (exn) {
+    return;
+  }
+}
+function interceptStdout(_state) {
+  (function(_state2) {
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (chunk, ...args) => {
+      const message2 = typeof chunk === "string" ? chunk : chunk.toString();
+      handleStdoutWrite(_state2, message2);
+      return originalWrite(chunk, ...args);
+    };
+  })(_state);
+}
+function interceptUncaughtErrors(state) {
+  process.on("uncaughtException", (error) => {
+    try {
+      let errorMessage = getOr(error.message, "Unknown error");
+      let attributes = Object.fromEntries([
+        [
+          "stack",
+          getOr(map2(error.stack, (prim) => prim), null)
+        ],
+        [
+          "name",
+          error.name
+        ]
+      ]);
+      return addLog(state, "error", errorMessage, attributes, void 0);
+    } catch (exn) {
+      return;
+    }
+  });
+  process.on("unhandledRejection", (reason2) => {
+    try {
+      let reasonMessage = getOr(reason2.message, String.toString(reason2));
+      let attributes = Object.fromEntries([[
+        "stack",
+        getOr(map2(reason2.stack, (prim) => prim), null)
+      ]]);
+      return addLog(state, "error", reasonMessage, attributes, void 0);
+    } catch (exn) {
+      return;
+    }
+  });
+}
+function initialize2(configOpt, param) {
+  let config = defaultConfig;
+  if (isBrowser()) {
+    return;
+  }
+  let match = getPatchedFlag();
+  if (match !== void 0 && match) {
+    return;
+  }
+  setPatchedFlag(true);
+  let state = getOrCreateInstance(config);
+  interceptConsole(state);
+  interceptStdout(state);
+  interceptUncaughtErrors(state);
+}
+if (typeof window === "undefined") {
+  initialize2();
+}
+function string3(json3) {
+  if (typeof json3 === "string") {
+    return json3;
+  }
+}
+function float2(json3) {
+  if (typeof json3 === "number") {
+    return json3;
+  }
+}
+var Decode = {
+  string: string3,
+  float: float2};
+
+// src/FrontmanNextjs__SpanProcessor.res.mjs
+function hrTimeToISO(param) {
+  let ms = param[0] * 1e3 + param[1] / 1e6;
+  return new Date(ms).toISOString();
+}
+function calculateDuration(span) {
+  let match = span.startTime;
+  let match$1 = span.endTime;
+  let startMs = match[0] * 1e3 + match[1] / 1e6;
+  let endMs = match$1[0] * 1e3 + match$1[1] / 1e6;
+  return endMs - startMs;
+}
+function getStr(attrs, key) {
+  return flatMap(attrs[key], Decode.string);
+}
+function getNum(attrs, key) {
+  return flatMap(attrs[key], Decode.float);
+}
+function make4() {
+  let onStart = (_span, _ctx) => {
+  };
+  let onEnd = (span) => {
+    try {
+      let attrs = span.attributes;
+      let spanType = getStr(attrs, "next.span_type");
+      let relevantTypes = [
+        "BaseServer.handleRequest",
+        "AppRender.getBodyResult",
+        "AppRouteRouteHandlers.runHandler"
+      ];
+      let isRelevant = mapOr(spanType, false, (st) => relevantTypes.includes(st));
+      if (!isRelevant) {
+        return;
+      }
+      let httpMethod = getStr(attrs, "http.method");
+      let r = getStr(attrs, "next.route");
+      let route = r !== void 0 ? r : getStr(attrs, "http.route");
+      let statusCode = getNum(attrs, "http.status_code");
+      let path = getOr(route, "unknown");
+      if (path.startsWith("/frontman")) {
+        return;
+      }
+      let durationMs = calculateDuration(span);
+      let match;
+      if (spanType !== void 0) {
+        switch (spanType) {
+          case "AppRender.getBodyResult":
+            let msg = `Rendered route: ` + path + ` (` + durationMs.toFixed(2) + `ms)`;
+            match = [
+              msg,
+              "console"
+            ];
+            break;
+          case "AppRouteRouteHandlers.runHandler":
+            let msg$1 = `API route: ` + path + ` (` + durationMs.toFixed(2) + `ms)`;
+            match = [
+              msg$1,
+              "console"
+            ];
+            break;
+          case "BaseServer.handleRequest":
+            let method = getOr(httpMethod, "UNKNOWN");
+            let status = getOr(map2(statusCode, (code) => code.toString()), "unknown");
+            let msg$2 = method + ` ` + path + ` ` + status + ` ` + durationMs.toFixed(2) + `ms`;
+            let lvl = mapOr(statusCode, "console", (code) => {
+              if (code >= 500) {
+                return "error";
+              } else {
+                return "console";
+              }
+            });
+            match = [
+              msg$2,
+              lvl
+            ];
+            break;
+          default:
+            match = [
+              "",
+              "console"
+            ];
+        }
+      } else {
+        match = [
+          "",
+          "console"
+        ];
+      }
+      let message2 = match[0];
+      if (message2 === "") {
+        return;
+      }
+      let logAttrs = Object.fromEntries([
+        [
+          "log.origin",
+          "opentelemetry-span"
+        ],
+        [
+          "span.name",
+          span.name
+        ],
+        [
+          "span.type",
+          getOr(spanType, "")
+        ],
+        [
+          "http.method",
+          getOr(httpMethod, "")
+        ],
+        [
+          "http.route",
+          getOr(route, "")
+        ],
+        [
+          "http.status_code",
+          getOr(map2(statusCode, (prim) => prim), null)
+        ],
+        [
+          "duration.ms",
+          durationMs
+        ]
+      ]);
+      let match$1 = span.endTime;
+      hrTimeToISO([
+        match$1[0],
+        match$1[1]
+      ]);
+      let state = getInstance();
+      return addLog(state, match[1], message2, logAttrs, void 0);
+    } catch (exn) {
+      return;
+    }
+  };
+  let forceFlush = () => Promise.resolve();
+  let shutdown = () => Promise.resolve();
+  return new Object({
+    onStart,
+    onEnd,
+    forceFlush,
+    shutdown
+  });
+}
+
+// src/FrontmanNextjs__LogRecordProcessor.res.mjs
+function mapSeverity(severityText) {
+  if (severityText === void 0) {
+    return "console";
+  }
+  switch (severityText) {
+    case "CRITICAL":
+    case "ERROR":
+    case "FATAL":
+      return "error";
+    default:
+      return "console";
+  }
+}
+function make5() {
+  let onEmit = (logRecord, _context) => {
+    try {
+      let body = getOr(fromNullable(logRecord.body), "");
+      let level = mapSeverity(fromNullable(logRecord.severityText));
+      let attributes = map2(fromNullable(logRecord.attributes), (attrs) => attrs);
+      let state = getInstance();
+      return addLog(state, level, body, attributes, void 0);
+    } catch (exn) {
+      return;
+    }
+  };
+  let forceFlush = () => Promise.resolve();
+  let shutdown = () => Promise.resolve();
+  return new Object({
+    onEmit,
+    forceFlush,
+    shutdown
+  });
+}
+
+// src/FrontmanNextjs__Instrumentation.res.mjs
+function setup() {
+  initialize2();
+  initialize();
+  return [
+    make5(),
+    make4()
+  ];
+}
+var LogCapture;
+var Sentry;
+
+export { LogCapture, Sentry, setup };