@demiurgejs/core 0.2.0-beta.4 → 0.2.0-beta.5

package/dist/chunks/testing-CUwGj2ie.js

@@ -0,0 +1,4751 @@
+import { B as Nr, A as Mr, C as Je, D as Ft, E as Wt, e as Bt, F as jr, G as Ur, I as Ir, q as zr, o as Hr, a as Fr } from "./index-0MNiR_wo.js";
+import { createElement as Ie } from "react";
+import { renderToString as Vt } from "react-dom/server";
+import { jsxs as X, jsx as ee } from "react/jsx-runtime";
+function Wr(e, t) {
+  const r = Ae(t.canonical);
+  if (e.canonical && Ae(e.canonical, r) !== r)
+    throw new Error(
+      `Localized metadata canonical URL ${JSON.stringify(e.canonical)} conflicts with ${JSON.stringify(t.canonical)}.`
+    );
+  const n = e.custom.filter(
+    (i) => i.kind === "link" && i.rel.toLowerCase() === "alternate" && !!i.hrefLang
+  ), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  for (const i of [...t.alternates, ...n]) {
+    const c = i.hrefLang.toLowerCase(), u = Ae(i.href, r), l = o.get(c), d = s.get(u);
+    if (l && l !== u)
+      throw new Error(`Localized metadata language ${JSON.stringify(i.hrefLang)} has conflicting URLs.`);
+    if (d && d !== c && d !== "x-default" && c !== "x-default")
+      throw new Error(`Localized metadata URL ${JSON.stringify(i.href)} has conflicting languages.`);
+    o.set(c, u), s.set(u, c);
+  }
+  const a = e.custom.filter(
+    (i) => !(i.kind === "link" && i.rel.toLowerCase() === "alternate" && i.hrefLang)
+  );
+  return {
+    ...e,
+    canonical: r,
+    custom: [
+      ...a,
+      ...[...o].map(([i, c]) => Br({ href: c, hrefLang: i, rel: "alternate" }))
+    ]
+  };
+}
+function Ae(e, t) {
+  try {
+    return new URL(e, t).href;
+  } catch {
+    throw new Error(`Localized metadata URL must be an absolute or root-relative URL: ${JSON.stringify(e)}.`);
+  }
+}
+function mi(e) {
+  return e;
+}
+function pi(e) {
+  return {
+    ...e,
+    kind: "meta"
+  };
+}
+function Br(e) {
+  return {
+    ...e,
+    kind: "link"
+  };
+}
+function gi(e) {
+  return {
+    kind: "structured-data",
+    value: e
+  };
+}
+function T(...e) {
+  const t = {
+    custom: [],
+    structuredData: []
+  };
+  for (const s of e)
+    s && Vr(t, s);
+  const r = _r(t), n = t.description, o = Gr(t.openGraph, r, n);
+  return {
+    canonical: t.canonical,
+    charset: "utf-8",
+    custom: t.custom,
+    description: n,
+    openGraph: o,
+    robots: t.robots,
+    structuredData: t.structuredData,
+    title: r,
+    viewport: "width=device-width, initial-scale=1"
+  };
+}
+function Vr(e, t) {
+  qr(e, t.title), t.description !== void 0 && (e.description = t.description), t.canonical !== void 0 && (e.canonical = t.canonical), t.robots && (e.robots = {
+    ...e.robots ?? {},
+    ...t.robots
+  }), t.openGraph && (e.openGraph = {
+    ...e.openGraph ?? {},
+    ...t.openGraph
+  }), t.custom && e.custom.push(...t.custom), t.structuredData && e.structuredData.push(...t.structuredData);
+}
+function qr(e, t) {
+  if (t !== void 0) {
+    if (typeof t == "string") {
+      e.title = t;
+      return;
+    }
+    t.default !== void 0 && (e.titleDefault = t.default), t.format && (e.titleFormat = t.format);
+  }
+}
+function _r(e) {
+  return e.title === void 0 ? e.titleDefault : e.titleFormat ? e.titleFormat(e.title) : e.title;
+}
+function Gr(e, t, r) {
+  if (!(!e && !t && !r))
+    return {
+      ...t ? { title: t } : {},
+      ...r ? { description: r } : {},
+      ...e ?? {}
+    };
+}
+const mt = ["build", "private", "public"], Jr = {
+  app: "demiurge-memory",
+  environment: "local",
+  schemaVersion: 1
+}, Kr = 1e4, Yr = 3e4;
+function wi(e) {
+  return (...t) => ({
+    fn: () => e.fn(...t),
+    key: e.key(...t),
+    locale: e.locale,
+    notFoundTtl: e.notFoundTtl,
+    scope: e.scope,
+    staleWhileRevalidate: e.staleWhileRevalidate,
+    tags: e.tags?.(...t),
+    ttl: e.ttl
+  });
+}
+class I extends Error {
+  constructor(t) {
+    super(t ?? "Not found"), this.name = "CacheNotFoundError";
+  }
+}
+function yi(e) {
+  throw new I(e);
+}
+function vi(e) {
+  return e instanceof I;
+}
+function Si(e) {
+  return { id: e };
+}
+function bi(e) {
+  return e;
+}
+function qt(e) {
+  const t = e.now ?? Date.now, r = en(e.refreshLeaseTtl), n = _t(e.namespace), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  return {
+    async get(a) {
+      const i = a.scope ?? "request";
+      if (i === "none")
+        return await a.fn();
+      const c = gt(a.key);
+      if (i === "request")
+        return await Xr(o, c, a, t);
+      const u = wt(n, i, c), l = (a.tags ?? []).map(
+        (g) => yt(n, i, ze(g))
+      ), d = await e.store.get(u);
+      if (d && (d.expiresAt === null || d.expiresAt > t())) {
+        if (d.negative)
+          throw new I(
+            typeof d.value == "string" ? d.value : void 0
+          );
+        return d.value;
+      }
+      if (d && tn(d, t())) {
+        const g = rn(e.store), O = globalThis.crypto.randomUUID();
+        if (await g.acquireRefreshLease(
+          u,
+          O,
+          t() + r
+        )) {
+          const _ = nn({
+            key: u,
+            now: t,
+            onBackgroundError: e.onBackgroundError,
+            refreshStore: g,
+            request: a,
+            tags: l,
+            token: O
+          });
+          e.waitUntil?.(_);
+        }
+        return d.value;
+      }
+      d && await e.store.delete(u);
+      const h = s.get(u);
+      if (h)
+        return await h.promise;
+      const f = { invalidated: !1 }, m = Promise.resolve().then(a.fn).then(
+        async (g) => (f.invalidated || await e.store.set(u, {
+          expiresAt: Ye(t(), a.ttl),
+          staleUntil: Ze(
+            t(),
+            a.ttl,
+            a.staleWhileRevalidate
+          ),
+          tags: l,
+          value: g
+        }), g),
+        async (g) => {
+          throw !f.invalidated && g instanceof I && await e.store.set(u, Gt(t(), a, l, g)), g;
+        }
+      ), w = {
+        promise: m,
+        state: f,
+        tags: l
+      };
+      s.set(u, w);
+      try {
+        return await m;
+      } finally {
+        s.get(u) === w && s.delete(u);
+      }
+    },
+    async invalidateKey(a) {
+      const i = gt(a), c = o.delete(i);
+      let u = !1;
+      const l = await Promise.all(
+        mt.map((d) => {
+          const h = wt(n, d, i), f = s.get(h);
+          return f && (f.state.invalidated = !0, u = !0), e.store.delete(h);
+        })
+      );
+      return c || u || l.some(Boolean);
+    },
+    async invalidateTags(a) {
+      const i = a.map(ze), c = on(
+        o,
+        new Set(i)
+      ), u = new Set(
+        mt.flatMap(
+          (h) => i.map((f) => yt(n, h, f))
+        )
+      );
+      let l = 0;
+      for (const h of s.values())
+        !h.state.invalidated && h.tags.some((f) => u.has(f)) && (h.state.invalidated = !0, l += 1);
+      const d = await e.store.invalidateTags([...u]);
+      return c + l + d;
+    }
+  };
+}
+function Ke(e = {}) {
+  const t = e.now ?? Date.now;
+  return qt({
+    namespace: Jr,
+    now: t,
+    onBackgroundError: e.onBackgroundError,
+    refreshLeaseTtl: e.refreshLeaseTtl,
+    store: Zr({
+      maximumEntries: e.maximumEntries,
+      now: t
+    }),
+    waitUntil: e.waitUntil
+  });
+}
+function Zr(e = {}) {
+  const t = e.entries ?? /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), n = e.maximumEntries ?? Kr, o = e.now ?? Date.now;
+  if (!Number.isSafeInteger(n) || n <= 0)
+    throw new Error(
+      "Demiurge memory cache maximumEntries must be a positive integer."
+    );
+  ke(t, r, o()), Qr(t, n);
+  let s = Le(t);
+  return {
+    acquireRefreshLease(a, i, c) {
+      const u = o(), l = r.get(a);
+      return l && l.expiresAt > u ? !1 : (r.set(a, { expiresAt: c, token: i }), !0);
+    },
+    delete(a) {
+      return r.delete(a), t.delete(a);
+    },
+    get(a) {
+      return o() >= s && (ke(t, r, o()), s = Le(t)), t.get(a);
+    },
+    invalidateTags(a) {
+      const i = new Set(a);
+      let c = 0;
+      for (const [u, l] of t)
+        l.tags.some((d) => i.has(d)) && (t.delete(u), r.delete(u), c += 1);
+      return c;
+    },
+    publishRefresh(a, i, c) {
+      const u = r.get(a);
+      return !u || u.token !== i || u.expiresAt <= o() ? !1 : (pt(
+        t,
+        r,
+        n,
+        a,
+        c
+      ), r.delete(a), c.staleUntil !== null && (s = Math.min(s, c.staleUntil)), !0);
+    },
+    releaseRefreshLease(a, i) {
+      r.get(a)?.token === i && r.delete(a);
+    },
+    set(a, i) {
+      const c = o();
+      c >= s && (ke(t, r, c), s = Le(t)), r.delete(a), pt(
+        t,
+        r,
+        n,
+        a,
+        i
+      ), i.staleUntil !== null && (s = Math.min(s, i.staleUntil));
+    }
+  };
+}
+function ke(e, t, r) {
+  for (const [n, o] of e)
+    o.staleUntil !== null && o.staleUntil <= r && (e.delete(n), t.delete(n));
+}
+function pt(e, t, r, n, o) {
+  if (!e.has(n) && e.size >= r)
+    for (; e.size >= r; ) {
+      const s = e.keys().next().value;
+      if (s === void 0)
+        break;
+      e.delete(s), t.delete(s);
+    }
+  e.set(n, o);
+}
+function Qr(e, t) {
+  for (; e.size > t; ) {
+    const r = e.keys().next().value;
+    if (r === void 0)
+      return;
+    e.delete(r);
+  }
+}
+function Le(e) {
+  let t = Number.POSITIVE_INFINITY;
+  for (const r of e.values())
+    r.staleUntil !== null && (t = Math.min(t, r.staleUntil));
+  return t;
+}
+function _t(e) {
+  const t = Ce("app", e.app), r = Ce(
+    "environment",
+    e.environment
+  );
+  if (typeof e.schemaVersion == "number" && (!Number.isInteger(e.schemaVersion) || e.schemaVersion < 0))
+    throw new Error(
+      "Demiurge cache namespace schemaVersion must be a non-negative integer or string."
+    );
+  const n = Ce(
+    "schemaVersion",
+    String(e.schemaVersion)
+  );
+  return `${t}:${r}:${n}`;
+}
+function Ei(e) {
+  return {
+    async key(t) {
+      return {
+        deleted: await e.invalidateKey(t) ? 1 : 0,
+        kind: "key"
+      };
+    },
+    async keys(t) {
+      let r = 0;
+      for (const n of t)
+        await e.invalidateKey(n) && (r += 1);
+      return {
+        deleted: r,
+        kind: "key"
+      };
+    },
+    async tag(t) {
+      return {
+        deleted: await e.invalidateTags([t]),
+        kind: "tag"
+      };
+    },
+    async tags(t) {
+      return {
+        deleted: await e.invalidateTags(t),
+        kind: "tag"
+      };
+    }
+  };
+}
+function z(e) {
+  if (e === void 0)
+    return Number.POSITIVE_INFINITY;
+  if (typeof e == "number") {
+    if (!Number.isInteger(e) || e < 0)
+      throw new Error("Demiurge cache duration must be a non-negative integer.");
+    return e;
+  }
+  const t = /^(\d+)(ms|s|m|h)$/.exec(e);
+  if (!t)
+    throw new Error("Demiurge cache duration must use an ms/s/m/h suffix.");
+  const r = Number(t[1]), n = t[2];
+  return n === "h" ? r * 36e5 : n === "m" ? r * 6e4 : n === "s" ? r * 1e3 : r;
+}
+function gt(e) {
+  return He(e, /* @__PURE__ */ new Set());
+}
+function ze(e) {
+  return e.id;
+}
+async function Xr(e, t, r, n) {
+  const o = e.get(t);
+  if (o && o.expiresAt > n())
+    return await o.value;
+  const s = Promise.resolve().then(r.fn), a = {
+    expiresAt: n() + z(r.ttl),
+    tags: (r.tags ?? []).map(ze),
+    value: s
+  };
+  e.set(t, a);
+  try {
+    return await s;
+  } catch (i) {
+    throw e.get(t) === a && (i instanceof I ? a.expiresAt = n() + z(r.notFoundTtl ?? r.ttl) : e.delete(t)), i;
+  }
+}
+function wt(e, t, r) {
+  return `${e}:${t}:key:${r}`;
+}
+function yt(e, t, r) {
+  return `${e}:${t}:tag:${r}`;
+}
+function Ye(e, t) {
+  const r = z(t);
+  return Number.isFinite(r) ? e + r : null;
+}
+function Gt(e, t, r, n) {
+  const o = t.notFoundTtl ?? t.ttl;
+  return {
+    expiresAt: Ye(e, o),
+    negative: !0,
+    // Negative entries do not participate in stale-while-revalidate: they
+    // expire outright and recompute on the next request.
+    staleUntil: Ze(e, o, void 0),
+    tags: r,
+    value: n.message
+  };
+}
+function Ze(e, t, r) {
+  const n = z(t);
+  if (!Number.isFinite(n)) {
+    if (r !== void 0)
+      throw new Error(
+        "Demiurge staleWhileRevalidate requires a finite cache ttl."
+      );
+    return null;
+  }
+  return e + n + z(r ?? 0);
+}
+function en(e) {
+  const t = z(e ?? Yr);
+  if (!Number.isFinite(t) || t <= 0)
+    throw new Error(
+      "Demiurge cache refreshLeaseTtl must be a positive finite duration."
+    );
+  return t;
+}
+function tn(e, t) {
+  return e.expiresAt !== null && e.expiresAt <= t && (e.staleUntil === null || e.staleUntil > t);
+}
+function rn(e) {
+  if (!e.acquireRefreshLease || !e.publishRefresh || !e.releaseRefreshLease)
+    throw new Error(
+      "Demiurge staleWhileRevalidate requires a cache store with acquireRefreshLease, publishRefresh, and releaseRefreshLease coordination methods."
+    );
+  return e;
+}
+async function nn(e) {
+  try {
+    const t = await e.request.fn(), r = e.now();
+    await e.refreshStore.publishRefresh(e.key, e.token, {
+      expiresAt: Ye(r, e.request.ttl),
+      staleUntil: Ze(
+        r,
+        e.request.ttl,
+        e.request.staleWhileRevalidate
+      ),
+      tags: e.tags,
+      value: t
+    });
+  } catch (t) {
+    if (t instanceof I) {
+      await e.refreshStore.publishRefresh(
+        e.key,
+        e.token,
+        Gt(e.now(), e.request, e.tags, t)
+      );
+      return;
+    }
+    e.onBackgroundError ? e.onBackgroundError(t) : console.error("Demiurge stale cache refresh failed.", t);
+  } finally {
+    await e.refreshStore.releaseRefreshLease(e.key, e.token);
+  }
+}
+function Ce(e, t) {
+  const r = [...t].some((n) => {
+    const o = n.charCodeAt(0);
+    return o <= 31 || o === 127;
+  });
+  if (!t || t.trim() !== t || t.includes(":") || r)
+    throw new Error(
+      `Demiurge cache namespace ${e} must be non-empty and cannot contain whitespace padding, colons, or control characters.`
+    );
+  return t;
+}
+function on(e, t) {
+  let r = 0;
+  for (const [n, o] of e)
+    o.tags.some((s) => t.has(s)) && (e.delete(n), r += 1);
+  return r;
+}
+function He(e, t) {
+  if (e === null || typeof e == "boolean" || typeof e == "string")
+    return JSON.stringify(e);
+  if (typeof e == "number") {
+    if (!Number.isFinite(e) || Object.is(e, -0))
+      throw new Error(
+        "Demiurge cache keys require finite numbers and do not accept negative zero."
+      );
+    return JSON.stringify(e);
+  }
+  if (typeof e != "object")
+    throw new Error(
+      `Demiurge cache keys do not accept values of type ${typeof e}.`
+    );
+  if (t.has(e))
+    throw new Error("Demiurge cache keys cannot contain circular references.");
+  if (t.add(e), Array.isArray(e)) {
+    const a = Reflect.ownKeys(e), i = [
+      ...Array.from({ length: e.length }, (u, l) => String(l)),
+      "length"
+    ];
+    if (a.length !== i.length || a.some((u, l) => u !== i[l]) || i.slice(0, -1).some((u) => {
+      const l = Object.getOwnPropertyDescriptor(e, u);
+      return !l?.enumerable || !("value" in l);
+    }))
+      throw t.delete(e), new Error(
+        "Demiurge cache key arrays must be dense and cannot contain accessors or custom properties."
+      );
+    const c = `[${e.map((u) => He(u, t)).join(",")}]`;
+    return t.delete(e), c;
+  }
+  const r = Object.getPrototypeOf(e);
+  if (r !== Object.prototype && r !== null)
+    throw new Error(
+      "Demiurge cache keys accept only primitives, arrays, and plain objects."
+    );
+  const n = Reflect.ownKeys(e);
+  if (n.some((a) => typeof a == "symbol") || n.some((a) => {
+    const i = Object.getOwnPropertyDescriptor(e, a);
+    return !i?.enumerable || !("value" in i);
+  }))
+    throw new Error(
+      "Demiurge cache key objects require enumerable string data properties."
+    );
+  const o = e, s = `{${Object.keys(o).sort().map(
+    (a) => `${JSON.stringify(a)}:${He(o[a], t)}`
+  ).join(",")}}`;
+  return t.delete(e), s;
+}
+class Jt extends Error {
+  field;
+  route;
+  constructor(t, r, n) {
+    super(t), this.name = "RouteSerializationError", this.route = r, this.field = n;
+  }
+}
+function Fe(e, t, r = [], n = /* @__PURE__ */ new Set()) {
+  if (e === null) return;
+  const o = typeof e;
+  if (o === "bigint")
+    throw vt(t, r, "a bigint value");
+  if (o !== "object") return;
+  const s = e;
+  if (n.has(s))
+    throw vt(t, r, "a circular reference");
+  if (n.add(s), Array.isArray(s)) {
+    for (let a = 0; a < s.length; a += 1)
+      Fe(
+        s[a],
+        t,
+        [...r, String(a)],
+        n
+      );
+    n.delete(s);
+    return;
+  }
+  for (const a of Object.keys(s))
+    Fe(
+      s[a],
+      t,
+      [...r, a],
+      n
+    );
+  n.delete(s);
+}
+function vt(e, t, r) {
+  const n = t.length === 0 ? "<root>" : t.join(".");
+  return new Jt(
+    `Route ${e} could not serialize the field ${n} for the browser. The value contains ${r}.`,
+    e,
+    n
+  );
+}
+function Kt(e) {
+  const t = {
+    fallbacks: {
+      error: [],
+      loading: [],
+      notFound: []
+    },
+    routes: [],
+    layouts: [],
+    middlewares: [],
+    policies: []
+  };
+  for (const [r, n] of Object.entries(e)) {
+    const o = r.replace(/^\/src\/routes\//, "").replace(/^\.\/routes\//, "").replace(/\.tsx?$/, "").split("/"), s = o.at(-1);
+    if (s === "@layout") {
+      t.layouts.push({
+        file: r,
+        fileSegments: o.slice(0, -1),
+        segments: x(o.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@policy") {
+      t.policies.push({
+        file: r,
+        fileSegments: o.slice(0, -1),
+        segments: x(o.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@middleware") {
+      t.middlewares.push({
+        file: r,
+        fileSegments: o.slice(0, -1),
+        segments: x(o.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@loading") {
+      t.fallbacks.loading.push({
+        file: r,
+        fileSegments: o.slice(0, -1),
+        segments: x(o.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@error") {
+      t.fallbacks.error.push({
+        file: r,
+        fileSegments: o.slice(0, -1),
+        segments: x(o.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@not-found") {
+      t.fallbacks.notFound.push({
+        file: r,
+        fileSegments: o.slice(0, -1),
+        segments: x(o.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    t.routes.push({
+      file: r,
+      fileSegments: o,
+      segments: x(o),
+      score: bn(o),
+      load: n
+    });
+  }
+  return sn(t.routes), t.routes.sort(un), t.layouts.sort(
+    (r, n) => r.fileSegments.length - n.fileSegments.length || r.file.localeCompare(n.file)
+  ), t.policies.sort(
+    (r, n) => r.fileSegments.length - n.fileSegments.length || r.file.localeCompare(n.file)
+  ), t.middlewares.sort(
+    (r, n) => r.fileSegments.length - n.fileSegments.length || r.file.localeCompare(n.file)
+  ), t.fallbacks.loading.sort(
+    (r, n) => r.fileSegments.length - n.fileSegments.length || r.file.localeCompare(n.file)
+  ), t.fallbacks.error.sort(
+    (r, n) => r.fileSegments.length - n.fileSegments.length || r.file.localeCompare(n.file)
+  ), t.fallbacks.notFound.sort(
+    (r, n) => r.fileSegments.length - n.fileSegments.length || r.file.localeCompare(n.file)
+  ), t;
+}
+function sn(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const r of e) {
+    const n = r.segments.findIndex(
+      (a) => a.startsWith("*")
+    );
+    if (n !== -1 && n !== r.segments.length - 1)
+      throw new Error(
+        `Catchall route segment in "${r.file}" must be the final URL segment.`
+      );
+    const o = r.segments.map(an).join("/"), s = t.get(o);
+    if (s)
+      throw new Error(
+        `Ambiguous routes "${s.file}" and "${r.file}" have the same runtime shape and both match "${cn(r.segments)}".`
+      );
+    t.set(o, r);
+  }
+}
+function an(e) {
+  return e.startsWith("*") ? "*" : e.startsWith(":") ? ":" : `=${e}`;
+}
+function cn(e) {
+  return e.length === 0 ? "/" : `/${e.map((t) => t.startsWith(":") || t.startsWith("*") ? "example" : t).join("/")}`;
+}
+function un(e, t) {
+  const r = Math.max(e.segments.length, t.segments.length);
+  for (let n = 0; n < r; n += 1) {
+    const o = St(t.segments[n]) - St(e.segments[n]);
+    if (o !== 0)
+      return o;
+  }
+  return e.file.localeCompare(t.file);
+}
+function St(e) {
+  return e === void 0 ? 4 : e.startsWith("*") ? 1 : e.startsWith(":") ? 2 : 3;
+}
+async function Yt(e, t, r = new Request(`http://demiurge.local${t}`), n, o = Ke(), s = {}) {
+  const a = s.documentContributions ?? !0, i = V(e.routes, t);
+  if (!i)
+    return {
+      ...await We(e, t, {
+        documentContributions: a,
+        locale: s.locale
+      }),
+      status: "not-found"
+    };
+  const c = e.layouts.filter(
+    (m) => C(m.fileSegments, i.route.fileSegments)
+  ), u = await i.route.load();
+  if (!u.GET || u.GET.kind !== "page")
+    return {
+      ...await We(e, t, {
+        fallback: Qe(
+          e.fallbacks.notFound,
+          i.route
+        ),
+        documentContributions: a,
+        layouts: c,
+        locale: s.locale
+      }),
+      status: "not-found"
+    };
+  const l = u.GET.layout === !1 ? [] : await Promise.all(c.map((m) => m.load())), d = new URL(r.url), h = {
+    cache: o,
+    context: s.requestContext ?? {},
+    locale: s.locale,
+    path: i.path,
+    pathname: t,
+    request: r,
+    search: d.searchParams,
+    url: d
+  };
+  let f;
+  return u.GET.data && !n?.hasData ? (f = await u.GET.data(h), Fe(f, Xt(i.route.segments))) : f = n?.data, {
+    status: "ready",
+    match: {
+      data: f,
+      error: await Zt(e, i.route),
+      links: a ? await Mr(
+        [
+          ...l.map((m) => m.links),
+          u.links
+        ],
+        h
+      ) : [],
+      page: u.GET.view,
+      layouts: l.map(
+        (m) => m.default
+      ),
+      locale: s.locale,
+      metadata: a ? T(...await Promise.all([
+        ...l.map((m) => M(m, h)),
+        M(u, h)
+      ])) : T(),
+      path: i.path,
+      pathname: t,
+      render: u.GET.render,
+      scripts: a ? await Nr(
+        [
+          ...l.map((m) => m.scripts),
+          u.scripts
+        ],
+        h
+      ) : []
+    }
+  };
+}
+async function Ri(e, t = {}) {
+  const r = Ke(), n = [];
+  for (const o of e.routes) {
+    const s = await o.load();
+    if (!s.GET || s.GET.kind !== "page" && !t.includeResources || s.GET.kind === "page" && t.includePages === !1)
+      continue;
+    if (s.GET.kind === "page" && s.GET.render.mode !== "static")
+      throw new Error(
+        `Page route "${o.file}" uses render mode "${s.GET.render.mode}" and cannot be emitted as static output. Set render: { mode: "static" } or deploy a runtime adapter.`
+      );
+    const a = Xt(o.segments);
+    if (wn(o.segments).length === 0) {
+      n.push({
+        file: o.file,
+        path: {},
+        pattern: a,
+        pathname: a
+      });
+      continue;
+    }
+    if (!s.paths)
+      throw new Error(
+        `Dynamic static route "${o.file}" must export paths for "${a}".`
+      );
+    const c = await s.paths({
+      cache: r,
+      locale: t.locale
+    });
+    for (const u of c) {
+      const l = yn(o, a, u);
+      n.push({
+        file: o.file,
+        path: l,
+        pattern: a,
+        pathname: Sn(o.segments, l)
+      });
+    }
+  }
+  return n;
+}
+async function Ti(e, t) {
+  const r = V(e.routes, t);
+  if (r)
+    return await mn(
+      Qe(e.fallbacks.loading, r.route)
+    );
+}
+async function ln(e, t) {
+  let r;
+  try {
+    r = V(e.routes, t);
+  } catch (n) {
+    if (!(n instanceof tt)) throw n;
+    return await et(
+      e.fallbacks.error.find(
+        (o) => o.fileSegments.length === 0
+      )
+    );
+  }
+  return r ? await Zt(e, r.route) : await dn(e, t);
+}
+async function Zt(e, t) {
+  return await et(
+    Qe(e.fallbacks.error, t)
+  );
+}
+async function dn(e, t) {
+  return await et(
+    Qt(e.fallbacks.error, t)
+  );
+}
+async function We(e, t, r = {}) {
+  const o = await (r.fallback ?? Qt(e.fallbacks.notFound, t))?.load(), s = o?.default, a = r.documentContributions ?? !0, i = { locale: r.locale, path: {}, pathname: t };
+  if (o?.layout === !1)
+    return {
+      layouts: [],
+      locale: r.locale,
+      metadata: a ? T(await M(o, i)) : T(),
+      notFound: s,
+      pathname: t
+    };
+  const c = r.layouts ?? fn(e, t);
+  try {
+    const u = await Promise.all(
+      c.map((l) => l.load())
+    );
+    return {
+      layouts: u.map(
+        (l) => l.default
+      ),
+      locale: r.locale,
+      metadata: a ? T(...await Promise.all([
+        ...u.map((l) => M(l, i)),
+        M(o, i)
+      ])) : T(),
+      notFound: s,
+      pathname: t
+    };
+  } catch (u) {
+    return r.onLayoutError?.(u), {
+      layouts: [],
+      locale: r.locale,
+      metadata: a ? T(await M(o, i)) : T(),
+      notFound: s,
+      pathname: t
+    };
+  }
+}
+async function M(e, t) {
+  return typeof e?.metadata == "function" ? await e.metadata(t) : e?.metadata;
+}
+function fn(e, t) {
+  const r = Te(t);
+  return e.layouts.filter(
+    (n) => !n.fileSegments.some(Re) && Xe(n.segments, r)
+  );
+}
+function hn(e, t) {
+  const r = Te(t);
+  return e.policies.filter(
+    (n) => !n.fileSegments.some(Re) && Xe(n.segments, r)
+  );
+}
+function Qe(e, t) {
+  for (let r = e.length - 1; r >= 0; r -= 1) {
+    const n = e[r];
+    if (C(n.fileSegments, t.fileSegments))
+      return n;
+  }
+}
+function Qt(e, t) {
+  const r = Te(t);
+  for (let n = e.length - 1; n >= 0; n -= 1) {
+    const o = e[n];
+    if (!o.fileSegments.some(Re) && Xe(o.segments, r))
+      return o;
+  }
+}
+function Xe(e, t) {
+  return e.every((r, n) => r.startsWith("*") ? t.length > n : r.startsWith(":") ? !!t[n] : t[n] === r);
+}
+async function mn(e) {
+  return e ? (await e.load()).default : void 0;
+}
+async function et(e) {
+  return e ? (await e.load()).default : void 0;
+}
+function V(e, t) {
+  const r = Te(t);
+  for (const n of e) {
+    const o = pn(n.segments, r);
+    if (o)
+      return { route: n, path: o };
+  }
+  return null;
+}
+const $i = Yt, xi = V;
+function pn(e, t) {
+  const r = {};
+  for (let n = 0; n < e.length; n += 1) {
+    const o = e[n], s = t[n];
+    if (o?.startsWith("*"))
+      return r[o.slice(1)] = t.slice(n).join("/"), r;
+    if (!s)
+      return null;
+    if (o.startsWith(":")) {
+      r[o.slice(1)] = s;
+      continue;
+    }
+    if (o !== s)
+      return null;
+  }
+  return e.length === t.length ? r : null;
+}
+function Ai(e, t) {
+  return e.every(
+    (r, n) => t[n] === r
+  );
+}
+function C(e, t) {
+  return e.every(
+    (r, n) => t[n] === r
+  );
+}
+function x(e) {
+  return e.flatMap((t) => Re(t) ? [] : t === "index" ? [] : t.startsWith("[...") && t.endsWith("]") ? [`*${t.slice(4, -1)}`] : t.startsWith("[") && t.endsWith("]") ? [`:${t.slice(1, -1)}`] : [t]);
+}
+function Re(e) {
+  return e.startsWith("(") && e.endsWith(")");
+}
+function Xt(e) {
+  return e.length === 0 ? "/" : `/${e.map(gn).join("/")}`;
+}
+function gn(e) {
+  return e.startsWith("*") ? `[...${e.slice(1)}]` : e.startsWith(":") ? `[${e.slice(1)}]` : e;
+}
+function wn(e) {
+  return e.flatMap((t) => t.startsWith(":") || t.startsWith("*") ? [t.slice(1)] : []);
+}
+function yn(e, t, r) {
+  const n = {};
+  for (const o of e.segments) {
+    if (!o.startsWith(":") && !o.startsWith("*"))
+      continue;
+    const s = o.slice(1), a = r[s];
+    if (a === void 0)
+      throw new Error(
+        `Static paths for "${e.file}" must include "${s}" for "${t}".`
+      );
+    if (!vn(a))
+      throw new Error(
+        `Static path "${s}" for "${e.file}" must be a string, number, or boolean.`
+      );
+    n[s] = String(a);
+  }
+  return n;
+}
+function vn(e) {
+  return typeof e == "string" || typeof e == "number" || typeof e == "boolean";
+}
+function Sn(e, t) {
+  return `/${e.map((n) => n.startsWith("*") ? t[n.slice(1)].split("/").filter(Boolean).map(encodeURIComponent).join("/") : n.startsWith(":") ? encodeURIComponent(t[n.slice(1)]) : encodeURIComponent(n)).filter(Boolean).join("/")}`;
+}
+function bn(e) {
+  return x(e).reduce((t, r) => r.startsWith("*") ? t : r.startsWith(":") ? t + 1 : t + 2, 0);
+}
+function Te(e) {
+  return e.replace(/^\/|\/$/g, "").split("/").filter(Boolean).map((t) => {
+    try {
+      return decodeURIComponent(t);
+    } catch (r) {
+      throw new tt(e, { cause: r });
+    }
+  });
+}
+class tt extends URIError {
+  pathname;
+  constructor(t, r) {
+    super(
+      `Malformed percent encoding in URL pathname ${JSON.stringify(t)}.`,
+      r
+    ), this.name = "MalformedPathnameError", this.pathname = t;
+  }
+}
+const H = "x-demiurge-navigation", En = "data", Rn = "data", fe = "error", Be = "not-found";
+function F(e) {
+  return e.headers.get(H) === En;
+}
+function rt(e, t = {}) {
+  const r = new Headers(t.headers);
+  return r.set("cache-control", "no-store"), r.set(
+    H,
+    t.kind ?? Rn
+  ), r.append("vary", H), Response.json(
+    {
+      data: e,
+      document: t.document,
+      error: t.error,
+      hasData: !0,
+      locale: t.locale
+    },
+    {
+      headers: r,
+      status: t.status
+    }
+  );
+}
+function ce(e, t) {
+  return e.headers.set("cache-control", "no-store"), e.headers.set(H, t), e.headers.append("vary", H), e;
+}
+function oe(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function ki(e) {
+  return typeof e == "object" && e !== null;
+}
+function Tn(e) {
+  if (typeof e == "string")
+    return e;
+  const t = $n(kn(
+    e.to,
+    "path" in e ? e.path : void 0
+  )), r = e.search === void 0 ? t.search : xn(e.search), n = e.hash === void 0 ? t.hash : e.hash ? e.hash.startsWith("#") ? e.hash : `#${e.hash}` : "";
+  return `${t.pathname}${r}${n}`;
+}
+function $n(e) {
+  const t = e.indexOf("#"), r = t === -1 ? e : e.slice(0, t), n = r.indexOf("?");
+  return {
+    hash: t === -1 ? "" : e.slice(t),
+    pathname: n === -1 ? r : r.slice(0, n),
+    search: n === -1 ? "" : r.slice(n)
+  };
+}
+function xn(e) {
+  if (!e)
+    return "";
+  if (typeof e == "string")
+    return e.startsWith("?") ? e : `?${e}`;
+  const r = (e instanceof URLSearchParams ? e : An(e)).toString();
+  return r ? `?${r}` : "";
+}
+function An(e) {
+  const t = new URLSearchParams();
+  for (const [r, n] of Object.entries(e)) {
+    const o = Array.isArray(n) ? n : [n];
+    for (const s of o)
+      s != null && t.append(r, String(s));
+  }
+  return t;
+}
+function kn(e, t) {
+  return t ? e.replace(
+    /\[(\.\.\.)?([a-zA-Z_$][a-zA-Z0-9_$]*)\]/g,
+    (r, n, o) => {
+      const s = t[o];
+      if (s === void 0)
+        throw new Error(`Missing path value for "${o}" in route "${e}".`);
+      return n ? String(s).split("/").filter(Boolean).map((a) => encodeURIComponent(a)).join("/") : encodeURIComponent(String(s));
+    }
+  ) : e;
+}
+function Ln(e) {
+  rr(e);
+  const t = new Map(
+    e.supportedLocales.map((i) => [i, A(i)])
+  ), r = (i) => {
+    const c = e.supportedLocales.find((u) => u === i);
+    if (!c) throw new Error(`The locale target "${i}" must be supported.`);
+    return t.get(c) ?? c;
+  }, o = e.path && Object.fromEntries(
+    e.supportedLocales.map((i) => [
+      A(i),
+      e.path?.labels[i].toLowerCase()
+    ])
+  ), a = e.domains && Object.fromEntries(
+    e.supportedLocales.flatMap((i) => {
+      const c = e.domains?.[i];
+      return c ? [[A(i), nr(c)]] : [];
+    })
+  );
+  return {
+    ...e,
+    aliases: e.aliases && Object.fromEntries(
+      Object.entries(e.aliases).map(([i, c]) => [i.toLowerCase(), r(String(c))])
+    ),
+    defaultLocale: r(e.defaultLocale),
+    // TYPE-EVIDENCE: validation restricts each direction key to a supported TLocale value.
+    directions: e.directions && Object.fromEntries(
+      Object.entries(e.directions).map(([i, c]) => [
+        A(i),
+        c
+      ])
+    ),
+    domains: a,
+    path: e.path && {
+      ...e.path,
+      labels: o,
+      reserved: e.path.reserved?.map((i) => i.toLowerCase())
+    },
+    supportedLocales: e.supportedLocales.map(A),
+    xDefault: e.xDefault && r(e.xDefault)
+  };
+}
+function Pe(e, t) {
+  const r = t?.directions?.[e];
+  if (r) return r;
+  const n = new Intl.Locale(e), o = n.textInfo?.direction;
+  return o || (Nn.has(n.maximize().script ?? "") ? "rtl" : "ltr");
+}
+function Cn(e, t) {
+  rr(t);
+  const r = new URL(e.url), [n = "", ...o] = r.pathname.slice(1).split("/"), s = nt(n, t), a = t.path?.reserved?.some(
+    (g) => g.toLowerCase() === n.toLowerCase()
+  ) ?? !1, i = Pn(r.hostname, t), c = Dn(e, t), u = On(e.headers.get("accept-language"), t), l = s ?? i ?? c ?? u ?? t.defaultLocale, d = s ? "path" : i ? "domain" : c ? "cookie" : u ? "accept-language" : "default", h = s || a ? `/${o.join("/")}`.replace(/\/$/, "") || "/" : r.pathname, f = tr(r, h, l, t), m = {
+    locale: l,
+    pathname: h,
+    redirect: !a && f.href !== r.href ? f : void 0,
+    source: d,
+    unsupported: a
+  }, w = t.resolver?.({
+    configuration: t,
+    defaultResolution: m,
+    request: e
+  }) ?? m;
+  if (!t.supportedLocales.includes(w.locale))
+    throw new Error(
+      `The locale resolver returned unsupported locale ${JSON.stringify(w.locale)}.`
+    );
+  if (w.redirect && w.redirect.origin !== r.origin && !Object.values(t.domains ?? {}).includes(w.redirect.hostname))
+    throw new Error("The locale resolver returned an external redirect.");
+  return w;
+}
+function er(e, t, r, n = "http://demiurge.local") {
+  const o = new URL(e, n), a = nt(o.pathname.slice(1).split("/")[0] ?? "", r) ? `/${o.pathname.slice(1).split("/").slice(1).join("/")}`.replace(/\/$/, "") || "/" : o.pathname, i = tr(o, a, t, r), c = new URL(n);
+  return i.origin === c.origin ? `${i.pathname}${i.search}${i.hash}` : i.href;
+}
+function Li(e, t) {
+  if (!t) return e;
+  const r = e.slice(1).split("/");
+  return nt(r[0] ?? "", t) ? `/${r.slice(1).join("/")}`.replace(/\/$/, "") || "/" : e;
+}
+function tr(e, t, r, n) {
+  const o = new URL(e), s = n.path?.labels[r], a = s && (r !== n.defaultLocale || n.path?.prefixDefault);
+  o.pathname = a ? `/${s}${t === "/" ? "" : t}` : t;
+  const i = n.domains?.[r];
+  return i && (o.hostname = i), o;
+}
+function nt(e, t) {
+  const r = Object.entries(t.path?.labels ?? {}).find(([, n]) => String(n).toLowerCase() === e.toLowerCase());
+  return r ? r[0] : Object.entries(t.aliases ?? {}).find(([n]) => n.toLowerCase() === e.toLowerCase())?.[1];
+}
+function Pn(e, t) {
+  return Object.entries(t.domains ?? {}).find(([, r]) => String(r).toLowerCase() === e.toLowerCase())?.[0];
+}
+function Dn(e, t) {
+  const r = t.cookie?.name;
+  if (!r) return;
+  const n = e.headers.get("cookie")?.split(";").map((o) => o.trim()).find((o) => o.startsWith(`${r}=`))?.slice(r.length + 1);
+  return t.supportedLocales.find((o) => o === n);
+}
+function On(e, t) {
+  if (!e) return;
+  const r = e.split(",").map((n, o) => {
+    const [s = "", ...a] = n.trim().split(";"), i = a.find((u) => u.trim().toLowerCase().startsWith("q=")), c = i ? Number(i.trim().slice(2)) : 1;
+    return { order: o, q: c, tag: s.trim() };
+  }).filter(({ q: n, tag: o }) => o !== "" && Number.isFinite(n) && n > 0 && n <= 1).sort((n, o) => o.q - n.q || n.order - o.order);
+  for (const n of r) {
+    if (n.tag === "*") return t.defaultLocale;
+    let o = n.tag.toLowerCase();
+    for (; o; ) {
+      const s = t.supportedLocales.find((i) => i.toLowerCase() === o) ?? t.supportedLocales.find((i) => i.toLowerCase().startsWith(`${o}-`));
+      if (s) return s;
+      const a = o.lastIndexOf("-");
+      if (a < 0) break;
+      o = o.slice(0, a);
+    }
+  }
+}
+function rr(e) {
+  if (e.supportedLocales.length === 0) throw new Error("Locale configuration requires at least one supported locale.");
+  const t = e.supportedLocales.map(A);
+  if (new Set(t).size !== t.length) throw new Error("Locale configuration contains duplicate canonical locales.");
+  if (!t.includes(A(e.defaultLocale))) throw new Error("The default locale must be supported.");
+  if (e.supportedLocales.length > 1 && !e.path && !e.domains) throw new Error("Multiple locales require a path or domain binding.");
+  const r = new Set(t), n = (i, c) => {
+    if (!r.has(A(i))) throw new Error(`The ${c} target "${i}" must be supported.`);
+  }, o = /* @__PURE__ */ new Map(), s = (i, c) => {
+    const u = i.toLowerCase(), l = o.get(u);
+    if (l) throw new Error(`Locale ${c} "${i}" conflicts with ${l}.`);
+    o.set(u, `${c} "${i}"`);
+  };
+  for (const [i, c] of Object.entries(e.path?.labels ?? {})) {
+    if (n(i, "path label"), !/^[a-z0-9][a-z0-9-]*$/i.test(String(c))) throw new Error(`Locale path label "${c}" is invalid.`);
+    s(String(c), "path label");
+  }
+  for (const [i, c] of Object.entries(e.aliases ?? {})) {
+    if (n(String(c), "alias"), !/^[a-z0-9][a-z0-9-]*$/i.test(i)) throw new Error(`Locale alias "${i}" is invalid.`);
+    s(i, "alias");
+  }
+  for (const i of e.path?.reserved ?? []) s(i, "reserved label");
+  const a = /* @__PURE__ */ new Set();
+  for (const [i, c] of Object.entries(e.domains ?? {})) {
+    n(i, "domain");
+    const u = nr(String(c));
+    if (a.has(u)) throw new Error(`Locale domain "${c}" is duplicated.`);
+    a.add(u);
+  }
+  for (const [i, c] of Object.entries(e.directions ?? {}))
+    if (n(i, "direction"), c !== "ltr" && c !== "rtl")
+      throw new Error(`Locale direction for "${i}" must be "ltr" or "rtl".`);
+  if (e.cookie && !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(e.cookie.name))
+    throw new Error("The locale cookie name is invalid.");
+  e.xDefault && n(e.xDefault, "x-default");
+}
+function A(e) {
+  const [t] = Intl.getCanonicalLocales(e);
+  if (!t) throw new Error(`Locale "${e}" is invalid.`);
+  return t;
+}
+const Nn = /* @__PURE__ */ new Set([
+  "Adlm",
+  "Arab",
+  "Armi",
+  "Avst",
+  "Chrs",
+  "Cprt",
+  "Elym",
+  "Gara",
+  "Hatr",
+  "Hebr",
+  "Hung",
+  "Khar",
+  "Lydi",
+  "Mand",
+  "Mani",
+  "Mend",
+  "Merc",
+  "Mero",
+  "Narb",
+  "Nbat",
+  "Nkoo",
+  "Orkh",
+  "Ougr",
+  "Palm",
+  "Phli",
+  "Phlp",
+  "Phnx",
+  "Prti",
+  "Rohg",
+  "Samr",
+  "Sarb",
+  "Sidt",
+  "Sogd",
+  "Sogo",
+  "Syrc",
+  "Thaa",
+  "Yezi"
+]);
+function nr(e) {
+  if (e.includes(":") || e.includes("/") || e.trim() !== e)
+    throw new Error(`Locale domain "${e}" must be a hostname.`);
+  const t = new URL(`https://${e}`).hostname.toLowerCase();
+  if (!t || t !== e.toLowerCase()) throw new Error(`Locale domain "${e}" must be a hostname.`);
+  return t;
+}
+function Ci(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "json",
+    security: t?.security,
+    timing: $(t?.timing),
+    value: e,
+    init: k(t)
+  };
+}
+function Pi(e, t) {
+  return {
+    cors: t?.cors,
+    init: k(t),
+    kind: "jsonl",
+    lines: e,
+    security: t?.security,
+    timing: $(t?.timing)
+  };
+}
+function Di(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "text",
+    security: t?.security,
+    timing: $(t?.timing),
+    value: e,
+    init: k(t)
+  };
+}
+function Oi(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "html",
+    security: t?.security,
+    timing: $(t?.timing),
+    value: e,
+    init: k(t)
+  };
+}
+function Ni(e, t) {
+  const r = typeof t == "number" ? void 0 : t;
+  return {
+    cors: r?.cors,
+    kind: "redirect",
+    security: r?.security,
+    timing: $(r?.timing),
+    to: Vn(e) ? Tn(e) : e,
+    init: typeof t == "number" ? { status: t } : k(t)
+  };
+}
+function Mi(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "not-found",
+    security: t?.security,
+    timing: $(t?.timing),
+    body: e,
+    init: k(t)
+  };
+}
+function Mn(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "response",
+    response: e,
+    security: t?.security,
+    timing: $(t?.timing)
+  };
+}
+function ji(e, t) {
+  return {
+    body: e,
+    cors: t?.cors,
+    init: k(t),
+    kind: "stream",
+    security: t?.security,
+    timing: $(t?.timing)
+  };
+}
+function Ui(e, t) {
+  return {
+    cors: t?.cors,
+    events: e,
+    init: k(t),
+    kind: "sse",
+    security: t?.security,
+    timing: $(t?.timing)
+  };
+}
+function Ii(...e) {
+  return e;
+}
+async function or(e, t) {
+  switch (e.kind) {
+    case "json":
+      return new Response(JSON.stringify(await E(e.value, t)), {
+        ...e.init,
+        headers: De(
+          e.init?.headers,
+          "content-type",
+          "application/json; charset=utf-8"
+        )
+      });
+    case "jsonl":
+      return new Response(
+        Un(await E(e.lines, t)),
+        {
+          ...e.init,
+          headers: he(e.init?.headers, {
+            "cache-control": "no-cache",
+            "content-type": "application/x-ndjson; charset=utf-8",
+            "x-accel-buffering": "no"
+          })
+        }
+      );
+    case "text":
+      return new Response(await E(e.value, t), {
+        ...e.init,
+        headers: De(
+          e.init?.headers,
+          "content-type",
+          "text/plain; charset=utf-8"
+        )
+      });
+    case "html":
+      return new Response(await E(e.value, t), {
+        ...e.init,
+        headers: De(
+          e.init?.headers,
+          "content-type",
+          "text/html; charset=utf-8"
+        )
+      });
+    case "redirect": {
+      const r = new Headers(e.init?.headers);
+      return r.set("location", String(await E(e.to, t))), new Response(null, {
+        ...e.init,
+        headers: r,
+        status: e.init?.status ?? 302
+      });
+    }
+    case "not-found":
+      return new Response(
+        e.body ? await E(e.body, t) : null,
+        {
+          ...e.init,
+          status: e.init?.status ?? 404
+        }
+      );
+    case "response":
+      return await E(e.response, t);
+    case "stream":
+      return new Response(
+        In(await E(e.body, t)),
+        {
+          ...e.init,
+          headers: he(e.init?.headers, {
+            "content-type": "application/octet-stream",
+            "x-accel-buffering": "no"
+          })
+        }
+      );
+    case "sse":
+      return new Response(
+        jn(await E(e.events, t)),
+        {
+          ...e.init,
+          headers: he(e.init?.headers, {
+            "cache-control": "no-cache",
+            "content-type": "text/event-stream; charset=utf-8",
+            "x-accel-buffering": "no"
+          })
+        }
+      );
+  }
+}
+async function E(e, t) {
+  return typeof e != "function" ? e : await e(
+    t
+  );
+}
+function De(e, t, r) {
+  return he(e, { [t]: r });
+}
+function he(e, t) {
+  const r = new Headers(e);
+  for (const [n, o] of Object.entries(t))
+    r.has(n) || r.set(n, o);
+  return r;
+}
+function jn(e) {
+  const t = new TextEncoder(), r = ot(e);
+  return new ReadableStream({
+    async pull(n) {
+      const o = await r.next();
+      if (o.done) {
+        n.close();
+        return;
+      }
+      n.enqueue(t.encode(Fn(o.value)));
+    },
+    async cancel() {
+      await r.return?.();
+    }
+  });
+}
+function Un(e) {
+  const t = new TextEncoder(), r = ot(e);
+  return new ReadableStream({
+    async pull(n) {
+      const o = await r.next();
+      if (o.done) {
+        n.close();
+        return;
+      }
+      n.enqueue(t.encode(`${JSON.stringify(o.value)}
+`));
+    },
+    async cancel() {
+      await r.return?.();
+    }
+  });
+}
+function In(e) {
+  const t = new TextEncoder(), r = ot(e);
+  return new ReadableStream({
+    async pull(n) {
+      const o = await r.next();
+      if (o.done) {
+        n.close();
+        return;
+      }
+      n.enqueue(zn(o.value, t));
+    },
+    async cancel() {
+      await r.return?.();
+    }
+  });
+}
+function zn(e, t) {
+  return typeof e == "string" ? t.encode(e) : e;
+}
+function ot(e) {
+  if (e instanceof ReadableStream) {
+    const t = e.getReader();
+    return {
+      async next() {
+        return await t.read();
+      },
+      async return() {
+        return t.releaseLock(), { done: !0, value: void 0 };
+      }
+    };
+  }
+  return Symbol.asyncIterator in e ? e[Symbol.asyncIterator]() : Hn(e[Symbol.iterator]());
+}
+function Hn(e) {
+  return {
+    async next() {
+      return e.next();
+    },
+    async return() {
+      return e.return?.(), { done: !0, value: void 0 };
+    }
+  };
+}
+function Fn(e) {
+  if (typeof e == "string")
+    return Wn(e);
+  const t = [];
+  if (e.comment !== void 0 && t.push(...K("", e.comment)), e.id !== void 0 && t.push(...K("id", e.id)), e.event !== void 0 && t.push(...K("event", e.event)), e.retry !== void 0) {
+    if (!Number.isInteger(e.retry) || e.retry < 0)
+      throw new Error("SSE retry must be a non-negative integer.");
+    t.push(`retry: ${e.retry}`);
+  }
+  return e.data !== void 0 && t.push(...K("data", Bn(e.data))), `${t.join(`
+`)}
+
+`;
+}
+function Wn(e) {
+  return `${K("data", e).join(`
+`)}
+
+`;
+}
+function K(e, t) {
+  return t.split(/\r\n|\r|\n/).map(
+    (r) => e ? `${e}: ${r}` : `: ${r}`
+  );
+}
+function Bn(e) {
+  return typeof e == "string" ? e : JSON.stringify(e);
+}
+function Vn(e) {
+  return typeof e == "object" && e !== null && !(e instanceof URL) && "to" in e;
+}
+function k(e) {
+  if (!e)
+    return;
+  const {
+    cors: t,
+    security: r,
+    timing: n,
+    ...o
+  } = e;
+  return o;
+}
+function qn(e, t) {
+  if (!t?.length)
+    return e;
+  const r = new Headers(e.headers), n = _n(t), o = r.get("server-timing");
+  return r.set(
+    "server-timing",
+    o ? `${o}, ${n}` : n
+  ), new Response(e.body, {
+    headers: r,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+function _n(e) {
+  return e.map(Gn).join(", ");
+}
+function $(e) {
+  if (e)
+    return Array.isArray(e) ? e : [e];
+}
+function Gn(e) {
+  if (!Jn(e.name))
+    throw new Error(
+      `Server-Timing metric name "${e.name}" is not a valid token.`
+    );
+  const t = [e.name];
+  if (e.duration !== void 0) {
+    if (!Number.isFinite(e.duration) || e.duration < 0)
+      throw new Error("Server-Timing metric duration must be a non-negative finite number.");
+    t.push(`dur=${Kn(e.duration)}`);
+  }
+  return e.description !== void 0 && t.push(`desc="${Yn(e.description)}"`), t.join(";");
+}
+function Jn(e) {
+  return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(e);
+}
+function Kn(e) {
+  return Number.isInteger(e), String(e);
+}
+function Yn(e) {
+  return e.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+const Zn = "x-demiurge-mutation", Qn = "data;v=1", Ve = "application/vnd.demiurge.mutation+json;v=1";
+class sr extends Error {
+  validation;
+  constructor(t) {
+    super("Mutation input validation failed."), this.name = "MutationValidationError", this.validation = {
+      issues: t.issues.map((r) => ({
+        ...r,
+        path: [...r.path]
+      }))
+    };
+  }
+}
+const W = "x-demiurge-revalidate-tags";
+function zi(e) {
+  return {
+    ...Mn(
+      async (r) => {
+        let n;
+        try {
+          n = e.input ? await e.input(r) : void 0;
+        } catch (u) {
+          if (!(u instanceof sr)) throw u;
+          return Xn(
+            r.request,
+            u.validation,
+            r.pathname
+          );
+        }
+        const o = {
+          ...r,
+          input: n
+        }, s = async () => {
+          const u = await e.handler(o), l = u instanceof Response || u.kind === "response" || u.kind === "not-found", d = await oo(
+            await to(u, r),
+            r
+          );
+          return l || !qe(r.request) ? d : await eo(
+            d,
+            e.revalidateRoute === !0,
+            r.pathname
+          );
+        };
+        if (!e.idempotency) {
+          const u = await s();
+          if (!bt(u)) return u;
+          const l = await Et(
+            e.revalidate,
+            o
+          );
+          return await Rt(
+            u,
+            l,
+            r.pathname
+          );
+        }
+        const a = typeof e.idempotency.key == "function" ? e.idempotency.key(o) : e.idempotency.key, i = await e.idempotency.store.run({
+          fn: s,
+          key: a,
+          ttl: e.idempotency.ttl
+        });
+        if (i.replayed) return ro(i.value);
+        if (!bt(i.value)) return i.value;
+        const c = await Et(
+          e.revalidate,
+          o
+        );
+        return await Rt(
+          i.value,
+          c,
+          r.pathname
+        );
+      },
+      {
+        cors: e.cors,
+        security: e.security,
+        timing: e.timing
+      }
+    ),
+    mutation: !0
+  };
+}
+function qe(e) {
+  return e.headers.get(Zn) === Qn;
+}
+function Xn(e, t, r) {
+  const n = qe(e) ? { version: 1, status: "invalid", validation: t } : { type: "validation-error", validation: t }, o = pe(n, r);
+  return qe(e) ? new Response(o, {
+    headers: { "content-type": Ve },
+    status: 400
+  }) : new Response(o, {
+    headers: { "content-type": "application/json; charset=utf-8" },
+    status: 400
+  });
+}
+async function eo(e, t, r) {
+  if (e.status >= 300 && e.status < 400) {
+    const o = e.headers.get("location");
+    return o ? new Response(pe({
+      version: 1,
+      status: "redirect",
+      location: o,
+      history: e.status === 301 || e.status === 308 ? "replace" : "push"
+    }, r), {
+      headers: { "content-type": Ve },
+      status: 200
+    }) : e;
+  }
+  const n = e.headers.get("content-type")?.includes("json") ? await e.clone().json().catch(() => {
+  }) : void 0;
+  return new Response(pe({
+    version: 1,
+    status: e.ok ? "success" : "failed",
+    ...t && e.ok ? { revalidate: !0 } : {},
+    ...e.ok && n !== void 0 ? { data: n } : {}
+  }, r), {
+    headers: { "content-type": Ve },
+    status: e.status
+  });
+}
+async function to(e, t) {
+  if (e instanceof Response || e.kind !== "json") return e;
+  const r = typeof e.value == "function" ? await e.value(t) : e.value;
+  return ge(r, t.pathname), { ...e, value: r };
+}
+function pe(e, t) {
+  return ge(e, t), JSON.stringify(e);
+}
+function ge(e, t, r = [], n = /* @__PURE__ */ new Set()) {
+  if (!(e === null || typeof e == "string" || typeof e == "boolean")) {
+    if (typeof e == "number") {
+      if (Number.isFinite(e)) return;
+      throw L(t, r);
+    }
+    if (typeof e != "object" || n.has(e)) throw L(t, r);
+    if (n.add(e), Array.isArray(e)) {
+      for (const o of Reflect.ownKeys(e))
+        if (o !== "length" && (typeof o != "string" || !/^(0|[1-9][0-9]*)$/.test(o)))
+          throw L(t, [...r, String(o)]);
+      for (let o = 0; o < e.length; o += 1) {
+        if (!(o in e))
+          throw L(t, [...r, String(o)]);
+        ge(e[o], t, [...r, String(o)], n);
+      }
+    } else {
+      const o = Object.getPrototypeOf(e);
+      if (o !== Object.prototype && o !== null)
+        throw L(t, r);
+      for (const s of Reflect.ownKeys(e)) {
+        if (typeof s != "string")
+          throw L(t, [...r, "<symbol>"]);
+        ge(
+          Object.getOwnPropertyDescriptor(e, s)?.value,
+          t,
+          [...r, s],
+          n
+        );
+      }
+    }
+    n.delete(e);
+  }
+}
+function L(e, t) {
+  const r = t.length === 0 ? "<root>" : t.join(".");
+  return new Jt(
+    `Route ${e} could not serialize the field ${r} for the browser. A mutation result contains a value that JSON cannot serialize.`,
+    e,
+    r
+  );
+}
+function bt(e) {
+  return e.status >= 200 && e.status < 400;
+}
+async function Et(e, t) {
+  return e ? typeof e == "function" ? await e(t) : e : {};
+}
+async function Rt(e, t, r) {
+  const n = new Headers(e.headers);
+  n.delete(W);
+  const o = t.keys ?? [], s = t.tags ?? [];
+  return (o.length > 0 || s.length > 0) && n.set(
+    W,
+    encodeURIComponent(pe({
+      keys: o,
+      tags: s.map((a) => a.id),
+      version: 1
+    }, r))
+  ), new Response(e.body, {
+    headers: n,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+function ro(e) {
+  if (!e.headers.has(W)) return e;
+  const t = new Headers(e.headers);
+  return t.delete(W), new Response(e.body, {
+    headers: t,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+const Hi = {
+  custom(e) {
+    return e;
+  },
+  form(e, t) {
+    return async (n) => {
+      const o = await n.request.formData(), s = await t(o, n), a = await e["~standard"].validate(s);
+      if (a.issues)
+        throw new sr({
+          issues: a.issues.map((i) => ({
+            code: "invalid",
+            message: i.message,
+            path: no(i.path)
+          }))
+        });
+      return a.value;
+    };
+  },
+  async formData({ request: e }) {
+    return await e.formData();
+  },
+  async json({ request: e }) {
+    return await e.json();
+  },
+  async text({ request: e }) {
+    return await e.text();
+  }
+};
+function no(e) {
+  if (!e) return [];
+  const t = e.map(
+    (r) => typeof r == "object" ? r.key : r
+  );
+  return typeof t[0] != "string" ? [] : t.some(
+    (r) => typeof r != "string" && typeof r != "number"
+  ) ? [] : t;
+}
+async function oo(e, t) {
+  return e instanceof Response ? e : await or(e, t);
+}
+const so = [
+  400,
+  401,
+  402,
+  403,
+  404,
+  405,
+  406,
+  407,
+  408,
+  409,
+  410,
+  411,
+  412,
+  413,
+  414,
+  415,
+  416,
+  417,
+  418,
+  421,
+  422,
+  423,
+  424,
+  425,
+  426,
+  428,
+  429,
+  431,
+  451,
+  500,
+  501,
+  502,
+  503,
+  504,
+  505,
+  506,
+  507,
+  508,
+  510,
+  511
+], ao = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Content Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a Teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Content",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+}, io = new Set(so);
+class ar extends Error {
+  detail;
+  extensions;
+  headers;
+  status;
+  title;
+  type;
+  constructor(t, r = {}, n = {}) {
+    co(t);
+    const o = typeof r == "string" ? { detail: r } : r, {
+      detail: s,
+      title: a = ao[t],
+      type: i = "about:blank",
+      ...c
+    } = o;
+    super(s ?? a, { cause: n.cause }), this.name = "HttpError", this.detail = s, this.extensions = Object.freeze({ ...c }), this.headers = new Headers(n.headers), this.status = t, this.title = a, this.type = i;
+  }
+}
+function Fi(e, t, r) {
+  return new ar(e, t, r);
+}
+function j(e) {
+  return e instanceof ar;
+}
+function co(e) {
+  if (!io.has(e))
+    throw new RangeError(
+      `HTTP error status must be a standard 4xx or 5xx status; received ${JSON.stringify(e)}.`
+    );
+}
+function Tt({ pathname: e }) {
+  return /* @__PURE__ */ X("main", { children: [
+    /* @__PURE__ */ ee("h1", { children: "404" }),
+    /* @__PURE__ */ X("p", { children: [
+      "No route matched ",
+      e,
+      "."
+    ] })
+  ] });
+}
+function $t({ status: e }) {
+  return /* @__PURE__ */ X("main", { children: [
+    /* @__PURE__ */ ee("h1", { children: e }),
+    /* @__PURE__ */ ee("p", { children: "Something went wrong." })
+  ] });
+}
+function uo({ error: e, pathname: t, status: r }) {
+  const { message: n, name: o, stack: s } = st(e);
+  return /* @__PURE__ */ X("main", { children: [
+    /* @__PURE__ */ X("h1", { children: [
+      r,
+      " ",
+      o,
+      " at ",
+      t
+    ] }),
+    /* @__PURE__ */ ee("p", { children: n }),
+    s ? /* @__PURE__ */ ee("pre", { children: s }) : null
+  ] });
+}
+function st(e) {
+  return e instanceof Error ? {
+    message: e.message,
+    name: e.name,
+    stack: e.stack
+  } : {
+    message: typeof e == "string" ? e : String(e),
+    name: "Error",
+    stack: void 0
+  };
+}
+const lo = ["text/html", "application/xhtml+xml"];
+function ir(e) {
+  return fo(e.headers.get("accept"));
+}
+function fo(e) {
+  return e ? ho(e).some(
+    (t) => t.quality > 0 && lo.includes(t.type)
+  ) : !1;
+}
+function ho(e) {
+  return e.split(",").flatMap((t) => {
+    const [r, ...n] = t.split(";"), o = r.trim().toLowerCase();
+    return o ? [
+      {
+        quality: mo(n),
+        type: o
+      }
+    ] : [];
+  });
+}
+function mo(e) {
+  for (const t of e) {
+    const [r, n] = t.split("=");
+    if (r?.trim().toLowerCase() !== "q")
+      continue;
+    const o = Number.parseFloat(n ?? "");
+    return Number.isNaN(o) ? 1 : o;
+  }
+  return 1;
+}
+const po = "application/problem+json";
+function go({
+  detail: e,
+  instance: t,
+  status: r,
+  title: n,
+  type: o = "about:blank",
+  ...s
+}) {
+  return {
+    type: o,
+    title: n,
+    status: r,
+    ...e === void 0 ? {} : { detail: e },
+    ...t === void 0 ? {} : { instance: t },
+    ...s
+  };
+}
+function te(e, t) {
+  const r = new Headers(t?.headers);
+  return r.set("content-type", `${po}; charset=utf-8`), new Response(JSON.stringify(go(e)), {
+    ...t,
+    headers: r,
+    status: e.status
+  });
+}
+const wo = "Internal Server Error";
+function at(e) {
+  return e === !0 && process.env.NODE_ENV !== "production";
+}
+async function me(e, t, r, n, o = {}) {
+  o.onError?.(r, n);
+  const s = new URL(t.url);
+  if (!(F(t) || n === "page" || n === "middleware" && ir(t)))
+    return yo(s, r, o);
+  if (F(t)) {
+    const i = st(r), c = j(r) ? new Headers(r.headers) : new Headers();
+    return rt(void 0, {
+      document: Je({
+        dir: o.dir,
+        lang: o.lang,
+        metadata: T(),
+        title: o.title
+      }),
+      locale: o.locale,
+      error: {
+        detail: j(r) ? r.detail : at(o.dev) ? i.message : void 0,
+        title: j(r) ? r.title : "Internal Server Error"
+      },
+      headers: c,
+      kind: fe,
+      status: it(r)
+    });
+  }
+  return await vo(e, s, r, o);
+}
+function yo(e, t, r = {}) {
+  if (j(t))
+    return te(
+      {
+        ...t.extensions,
+        detail: t.detail,
+        instance: `${e.pathname}${e.search}`,
+        status: t.status,
+        title: t.title,
+        type: t.type
+      },
+      { headers: t.headers }
+    );
+  const { message: n } = st(t);
+  return te({
+    // `detail` carries the thrown message, so it is dev only for the same
+    // reason the stack is.
+    ...at(r.dev) ? { detail: n } : {},
+    instance: `${e.pathname}${e.search}`,
+    status: 500,
+    title: "Internal Server Error"
+  });
+}
+async function vo(e, t, r, n) {
+  const o = it(r);
+  try {
+    const s = await bo(
+      e,
+      n.pathname ?? t.pathname,
+      r,
+      n
+    ), a = j(r) ? new Headers(r.headers) : new Headers();
+    return a.set("content-type", "text/html; charset=utf-8"), new Response(await n.transformDocument?.(s) ?? s, {
+      headers: a,
+      status: o
+    });
+  } catch (s) {
+    return n.onError?.(s, "page"), So();
+  }
+}
+function So() {
+  return new Response(wo, {
+    headers: { "content-type": "text/plain; charset=utf-8" },
+    status: 500
+  });
+}
+async function bo(e, t, r, n) {
+  const o = await Eo(e, t, n), s = Ft({
+    dev: n.dev,
+    nonce: n.nonce
+  }), a = Vt(
+    Wt(
+      s,
+      Ie(o, { error: r, locale: n.locale, pathname: t, status: it(r) })
+    )
+  );
+  return Bt({
+    body: { data: void 0, html: a, locale: n.locale, navigation: n.navigation },
+    entrySrc: n.clientEntry,
+    lang: n.lang,
+    nonce: n.nonce,
+    scripts: s.scripts(),
+    styles: n.styles,
+    title: n.title
+  });
+}
+function it(e) {
+  return j(e) ? e.status : 500;
+}
+async function Eo(e, t, r) {
+  if (at(r.dev))
+    return uo;
+  try {
+    return await ln(e, t) ?? $t;
+  } catch {
+    return $t;
+  }
+}
+const Ro = 403;
+function Wi(e) {
+  return e;
+}
+function cr(e) {
+  const t = [], r = [];
+  let n = !1, o = Ro;
+  for (const { policy: s, source: a } of e)
+    s && (s.replaces && (n = !0, t.length = 0, r.push({
+      ...s.replaces,
+      source: s.replaces.source ?? a
+    })), s.public && (n = !0), s.denyStatus && (o = s.denyStatus), s.authorize && (n = !0, t.push({ authorize: s.authorize, source: a })));
+  return {
+    chain: t,
+    declared: n,
+    denyStatus: o,
+    exceptions: r,
+    public: n && t.length === 0
+  };
+}
+function To(e) {
+  return cr(e.map((t) => ({ policy: t })));
+}
+async function xt(e, t) {
+  if (!e.declared)
+    return Oe(
+      e.denyStatus,
+      "Forbidden. This route inherits no access declaration."
+    );
+  for (const r of e.chain) {
+    let n;
+    try {
+      n = await r.authorize(t);
+    } catch {
+      return Oe(e.denyStatus);
+    }
+    if (!$o(n))
+      return Oe(xo(n, e.denyStatus));
+  }
+  return null;
+}
+function $o(e) {
+  return e === !0 ? !0 : oe(e) && e.allow === !0;
+}
+function xo(e, t) {
+  return oe(e) && Ao(e.status) ? e.status : t;
+}
+function Ao(e) {
+  return e === 401 || e === 403 || e === 404;
+}
+function Oe(e, t = ko(e)) {
+  return new Response(t, {
+    headers: {
+      "cache-control": "private, no-store",
+      "content-type": "text/plain; charset=utf-8"
+    },
+    status: e
+  });
+}
+function ko(e) {
+  return e === 401 ? "Unauthorized." : e === 404 ? "Not Found." : "Forbidden.";
+}
+function P(e) {
+  return oe(e) && typeof e.reason == "string" && "value" in e;
+}
+function S(e) {
+  return P(e) ? !1 : e;
+}
+function ur(e) {
+  return P(e) ? e : void 0;
+}
+function Lo(e) {
+  return P(e) ? !1 : e;
+}
+function lr(e) {
+  return P(e) ? e : void 0;
+}
+function ct(e) {
+  return P(e) ? e.value : e;
+}
+function dr(e) {
+  return P(e) ? e : void 0;
+}
+function Co(e, t) {
+  if (!e || !t)
+    return e;
+  const r = Po(e.document, t), n = Do(e.security, t);
+  return r === e.document && n === e.security ? e : { ...e, document: r, security: n };
+}
+function Po(e, t) {
+  const r = ur(e?.csp);
+  return !e || !r || r.source ? e : { ...e, csp: { ...r, source: t } };
+}
+function Do(e, t) {
+  if (!e)
+    return e;
+  const r = lr(e.csrf), n = dr(e.request?.maxBodySize);
+  return (!r || r.source) && (!n || n.source) ? e : {
+    ...e,
+    csrf: r && !r.source ? { ...r, source: t } : e.csrf,
+    request: n && !n.source ? { ...e.request, maxBodySize: { ...n, source: t } } : e.request
+  };
+}
+const we = "{nonce}", At = `'nonce-${we}'`, fr = {
+  baseUri: ["'self'"],
+  connectSrc: ["'self'"],
+  defaultSrc: ["'self'"],
+  fontSrc: ["'self'"],
+  formAction: ["'self'"],
+  frameAncestors: ["'none'"],
+  imgSrc: ["'self'", "data:", "blob:"],
+  objectSrc: ["'none'"],
+  scriptSrc: [At, "'strict-dynamic'"],
+  styleSrc: ["'self'", At],
+  upgradeInsecureRequests: !0
+}, Oo = {
+  ...fr,
+  scriptSrc: ["'self'"],
+  styleSrc: ["'self'"]
+}, kt = {
+  contentTypeOptions: "nosniff",
+  crossOriginOpenerPolicy: "same-origin",
+  crossOriginResourcePolicy: "same-origin",
+  permissionsPolicy: "camera=(), microphone=(), geolocation=(), payment=()",
+  referrerPolicy: "strict-origin-when-cross-origin",
+  strictTransportSecurity: {
+    includeSubDomains: !1,
+    maxAge: 31536e3,
+    preload: !1
+  }
+}, No = {
+  contentTypeOptions: "nosniff",
+  crossOriginResourcePolicy: "same-origin",
+  referrerPolicy: "strict-origin-when-cross-origin"
+}, J = {
+  api(e = {}) {
+    return Y(
+      {
+        headers: No
+      },
+      e
+    );
+  },
+  preset(e, t = {}) {
+    return e === "api" ? J.api(t) : e === "cross-origin-isolated" ? J.crossOriginIsolated(t) : e === "static" ? J.static(t) : J.strict(t);
+  },
+  static(e = {}) {
+    return Y(
+      {
+        csp: Oo,
+        headers: kt
+      },
+      e
+    );
+  },
+  strict(e = {}) {
+    return Y(
+      {
+        csp: fr,
+        headers: kt
+      },
+      e
+    );
+  },
+  crossOriginIsolated(e = {}) {
+    return Y(
+      J.strict({
+        headers: {
+          crossOriginEmbedderPolicy: "require-corp",
+          crossOriginOpenerPolicy: "same-origin"
+        }
+      }),
+      e
+    );
+  }
+};
+function Bi(e) {
+  return e;
+}
+function Vi(e) {
+  return e;
+}
+function Mo(...e) {
+  return e.reduce((t, r) => r ? Y(t, r) : t, {});
+}
+function ye(...e) {
+  const t = e.reduce((r, n) => n ? {
+    document: Mo(r.document, n.document),
+    security: jo(r.security, n.security)
+  } : r, {});
+  return {
+    ...t,
+    access: To(
+      e.map((r) => r ? r.access : void 0)
+    ),
+    document: Io(t.document, t.security?.needs)
+  };
+}
+function jo(...e) {
+  return e.reduce((t, r) => r ? {
+    csrf: r.csrf ?? t.csrf,
+    fetchMetadata: r.fetchMetadata ?? t.fetchMetadata,
+    needs: Uo(t.needs, r.needs),
+    rateLimit: r.rateLimit ?? t.rateLimit,
+    request: pr(t.request, r.request)
+  } : t, {});
+}
+const hr = [
+  { directive: "connectSrc", need: "connect" },
+  { directive: "imgSrc", need: "img" },
+  { directive: "scriptSrc", need: "script" }
+];
+function Uo(e, t) {
+  const r = {};
+  for (const { need: n } of hr) {
+    const o = [.../* @__PURE__ */ new Set([
+      ...e?.[n] ?? [],
+      ...t?.[n] ?? []
+    ])];
+    o.length > 0 && (r[n] = o);
+  }
+  return Object.keys(r).length > 0 ? r : void 0;
+}
+function Io(e, t) {
+  const r = S(e?.csp);
+  if (!e || !r || !t)
+    return e;
+  let n = r;
+  for (const { directive: o, need: s } of hr)
+    n = zo(n, o, s, t[s]);
+  return n === r ? e : { ...e, csp: n };
+}
+function zo(e, t, r, n) {
+  if (!n || n.length === 0)
+    return e;
+  if (e[t] === !1)
+    throw new Error(
+      `A route policy declares security.needs.${r} and sets csp.${t} to false. Set an explicit csp.${t} that includes ${n.join(", ")}.`
+    );
+  if (e[t] === void 0 && e.defaultSrc === void 0)
+    return e;
+  const o = D(
+    e[t] ?? e.defaultSrc
+  ) ?? [];
+  return Array.isArray(o) ? {
+    ...e,
+    [t]: [.../* @__PURE__ */ new Set([...o, ...n])]
+  } : e;
+}
+async function qi(e, t = "sha256") {
+  const r = await globalThis.crypto.subtle.digest(
+    es(t),
+    new TextEncoder().encode(e)
+  );
+  return `'${t}-${ts(new Uint8Array(r))}'`;
+}
+function se(e, t = {}) {
+  const r = S(e.csp);
+  r && Zo(r), Yo(e);
+  const n = new Headers(), o = r ? Go(r, t) : void 0, s = Vo(e.trustedTypes), a = e.trustedTypes ? e.trustedTypes.mode === "report-only" : !1;
+  return R(
+    n,
+    "content-security-policy",
+    ve(o, a ? void 0 : s)
+  ), R(
+    n,
+    "content-security-policy-report-only",
+    a ? ve(s, wr(r)) : void 0
+  ), Bo(n, e.headers, t), n;
+}
+function $e(e) {
+  const t = e ? S(e.csp) : void 0;
+  return t ? ae(t).some(([, r]) => {
+    const n = D(r);
+    return Array.isArray(n) && n.some((o) => o.includes(we));
+  }) : !1;
+}
+function mr() {
+  const e = new Uint8Array(16);
+  return globalThis.crypto.getRandomValues(e), btoa(String.fromCharCode(...e));
+}
+function Y(e, t) {
+  return {
+    csp: Fo(e.csp, t.csp),
+    headers: Ho(e.headers, t.headers),
+    trustedTypes: t.trustedTypes ?? e.trustedTypes
+  };
+}
+function Ho(e, t) {
+  const r = pr(e, t);
+  return !r || t?.reportingEndpoints === !1 || e?.reportingEndpoints && t?.reportingEndpoints && (r.reportingEndpoints = {
+    ...e.reportingEndpoints,
+    ...t.reportingEndpoints
+  }), r;
+}
+function pr(e, t) {
+  return t ? {
+    ...e ?? {},
+    ...t
+  } : e;
+}
+function Fo(e, t) {
+  if (P(t))
+    return t;
+  if (!t)
+    return e;
+  const r = S(e);
+  if (!r)
+    return Ne(t);
+  const n = Ne(r), o = Ne(t), s = {
+    ...n,
+    ...o
+  };
+  for (const [a, i] of ae(t)) {
+    const c = D(
+      n[a]
+    );
+    !ut(i) && Array.isArray(c) && Array.isArray(i) && gr(
+      s,
+      a,
+      Wo([...c, ...i])
+    );
+  }
+  return s;
+}
+function Ne(e) {
+  const t = { ...e };
+  for (const [r, n] of ae(e))
+    ut(n) && gr(t, r, n.replace);
+  return t;
+}
+function Wo(e) {
+  return [...new Set(e)];
+}
+function gr(e, t, r) {
+  if (!(t === "reportTo" || t === "upgradeInsecureRequests")) {
+    if (t === "reportUri") {
+      e.reportUri = r;
+      return;
+    }
+    e[t] = r;
+  }
+}
+function Bo(e, t, r) {
+  t && (R(e, "referrer-policy", t.referrerPolicy), R(e, "x-content-type-options", t.contentTypeOptions), R(e, "cross-origin-opener-policy", t.crossOriginOpenerPolicy), R(e, "cross-origin-embedder-policy", t.crossOriginEmbedderPolicy), R(e, "cross-origin-resource-policy", t.crossOriginResourcePolicy), R(e, "permissions-policy", t.permissionsPolicy), R(
+    e,
+    "reporting-endpoints",
+    Jo(t.reportingEndpoints)
+  ), t.strictTransportSecurity && (!r.request || new URL(r.request.url).protocol === "https:") && e.set(
+    "strict-transport-security",
+    _o(t.strictTransportSecurity)
+  ));
+}
+function Vo(e) {
+  if (!e)
+    return;
+  const t = [];
+  return e.requireFor?.includes("script") && t.push("require-trusted-types-for 'script'"), t.push(qo(e)), ve(...t);
+}
+function qo(e) {
+  if (e.policies !== void 0 && e.policies.length === 0)
+    return "trusted-types 'none'";
+  const t = [jr];
+  e.allowDefaultPolicy && t.push("default");
+  for (const r of e.policies ?? [])
+    t.push(r);
+  return `trusted-types ${[...new Set(t)].join(" ")}`;
+}
+function ve(...e) {
+  const t = e.filter((r) => r);
+  return t.length > 0 ? t.join("; ") : void 0;
+}
+function R(e, t, r) {
+  r && e.set(t, r);
+}
+function _o(e) {
+  const t = [`max-age=${e.maxAge}`];
+  return e.includeSubDomains && t.push("includeSubDomains"), e.preload && t.push("preload"), t.join("; ");
+}
+function Go(e, t) {
+  const r = [];
+  for (const [o, s] of ae(e)) {
+    if (o === "reportTo" || o === "reportUri")
+      continue;
+    const a = D(s);
+    if (a === !1 || a === void 0)
+      continue;
+    const i = yr(o);
+    if (a === !0 || o === "sandbox" && Array.isArray(a) && a.length === 0) {
+      r.push(i);
+      continue;
+    }
+    r.push(
+      `${i} ${Xo(a, t).join(" ")}`
+    );
+  }
+  const n = wr(e);
+  return n && r.push(n), r.join("; ");
+}
+function wr(e) {
+  if (!e)
+    return;
+  const t = [], r = D(e.reportUri);
+  return Array.isArray(r) && r.length && t.push(`report-uri ${r.join(" ")}`), e.reportTo && t.push(`report-to ${e.reportTo}`), ve(...t);
+}
+function Jo(e) {
+  if (e)
+    return Object.entries(e).sort(([t], [r]) => t.localeCompare(r)).map(([t, r]) => `${t}="${Ko(r)}"`).join(", ");
+}
+function Ko(e) {
+  return e.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function Yo(e) {
+  const t = e.headers?.reportingEndpoints;
+  if (t) {
+    const o = Object.entries(t);
+    if (o.length === 0)
+      throw new Error("Demiurge Reporting-Endpoints requires at least one endpoint.");
+    for (const [s, a] of o)
+      Lt(s), Ct(a, `Reporting-Endpoints member ${JSON.stringify(s)}`);
+  }
+  const r = S(e.csp) || void 0;
+  if (r?.reportTo && (Lt(r.reportTo), !t || !(r.reportTo in t)))
+    throw new Error(
+      `Demiurge CSP report-to group ${JSON.stringify(r.reportTo)} is not defined in headers.reportingEndpoints.`
+    );
+  const n = D(r?.reportUri);
+  for (const o of Array.isArray(n) ? n : [])
+    Ct(o, "CSP report-uri target");
+}
+function Zo(e) {
+  for (const [t, r] of ae(e)) {
+    const n = yr(t);
+    if (r === void 0)
+      continue;
+    if (t === "reportTo") {
+      if (typeof r != "string")
+        throw new Error(
+          `Demiurge CSP directive ${JSON.stringify(n)} must be a string.`
+        );
+      continue;
+    }
+    if (t === "upgradeInsecureRequests") {
+      if (typeof r != "boolean")
+        throw new Error(
+          `Demiurge CSP directive ${JSON.stringify(n)} must be a boolean.`
+        );
+      continue;
+    }
+    if (t === "sandbox") {
+      if (typeof r != "boolean" && (!Array.isArray(r) || !r.every((s) => typeof s == "string")))
+        throw new Error(
+          `Demiurge CSP directive ${JSON.stringify(n)} must be a boolean or a list of sandbox tokens.`
+        );
+      continue;
+    }
+    const o = D(r);
+    if (o !== !1 && (!Array.isArray(o) || !o.every((s) => typeof s == "string")))
+      throw new Error(
+        `Demiurge CSP directive ${JSON.stringify(n)} must be a source list, false, or a replacement object with a source list.`
+      );
+  }
+}
+function ut(e) {
+  return !!(e && typeof e == "object" && !Array.isArray(e) && "replace" in e);
+}
+function D(e) {
+  return ut(e) ? e.replace : e;
+}
+function Lt(e) {
+  if (!/^(?:[a-z]|\*)[a-z0-9_.*-]*$/.test(e))
+    throw new Error(
+      `Invalid reporting endpoint name ${JSON.stringify(e)}. Use a lowercase Structured Field key.`
+    );
+}
+function Ct(e, t) {
+  if (!Qo(e) || /[\s,;"\\]/.test(e) || !e.startsWith("/") && !e.startsWith("https://"))
+    throw new Error(`${t} must be a same-origin path or an HTTPS URL.`);
+  if (e.startsWith("//"))
+    throw new Error(`${t} must not be a scheme-relative URL.`);
+  let r;
+  try {
+    r = new URL(e, "https://demiurge.invalid");
+  } catch {
+    throw new Error(`${t} must be a valid URI reference.`);
+  }
+  if (r.username || r.password || r.hash)
+    throw new Error(`${t} must not contain credentials or a fragment.`);
+}
+function Qo(e) {
+  return /^[\x20-\x7e]+$/.test(e);
+}
+function ae(e) {
+  return Object.entries(e);
+}
+function Xo(e, t) {
+  return e.map((r) => {
+    if (!r.includes(we))
+      return r;
+    if (!t.nonce)
+      throw new Error("Demiurge security policy requires a CSP nonce.");
+    return r.replaceAll(we, t.nonce);
+  });
+}
+function yr(e) {
+  return e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+}
+function es(e) {
+  return e === "sha384" ? "SHA-384" : e === "sha512" ? "SHA-512" : "SHA-256";
+}
+function ts(e) {
+  let t = "";
+  for (const r of e)
+    t += String.fromCharCode(r);
+  return typeof btoa == "function" ? btoa(t) : Buffer.from(t, "binary").toString("base64");
+}
+function vr(e, t, r = {}) {
+  lt(e);
+  const n = t.request.headers.get("origin"), o = new Headers();
+  if (e.origins !== "*" && Sr(o, "Origin"), !n)
+    return o;
+  const s = os(e, n);
+  if (!s)
+    return o;
+  if (o.set("access-control-allow-origin", s), e.credentials && o.set("access-control-allow-credentials", "true"), e.exposeHeaders?.length && o.set("access-control-expose-headers", e.exposeHeaders.join(", ")), r.preflight) {
+    o.set("access-control-allow-methods", r.methods.join(", "));
+    const a = t.request.headers.get(
+      "access-control-request-headers"
+    ), i = e.headers?.join(", ") ?? a;
+    i && o.set("access-control-allow-headers", i), e.maxAge !== void 0 && o.set("access-control-max-age", String(e.maxAge));
+  }
+  return o;
+}
+function Z(e, t, r) {
+  if (!t)
+    return e;
+  const n = new Headers(e.headers);
+  return ss(n, vr(t, { request: r })), new Response(e.body, {
+    headers: n,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+function rs(e, t) {
+  const r = t.headers.get("access-control-request-method"), n = as(r);
+  if (!n)
+    return null;
+  const o = br(e, n);
+  if (!o?.cors)
+    return null;
+  const s = o.cors.methods ?? is(e);
+  return s.includes(n) ? new Response(null, {
+    headers: vr(
+      o.cors,
+      { request: t },
+      {
+        methods: s,
+        preflight: !0
+      }
+    ),
+    status: 204
+  }) : null;
+}
+function lt(e) {
+  if (e.credentials && e.origins === "*")
+    throw new Error(
+      "Demiurge CORS policy cannot use wildcard origins with credentials."
+    );
+  if (e.credentials && (e.headers?.includes("*") || e.exposeHeaders?.includes("*")))
+    throw new Error(
+      "Demiurge credentialed CORS policy must list allowed and exposed headers explicitly."
+    );
+  if (e.origins !== "*")
+    for (const t of e.origins)
+      ns(t);
+  if (e.maxAge !== void 0 && (!Number.isSafeInteger(e.maxAge) || e.maxAge < 0))
+    throw new Error(
+      "Demiurge CORS maxAge must be a non-negative integer number of seconds."
+    );
+}
+function ns(e) {
+  let t;
+  try {
+    t = new URL(e);
+  } catch {
+    throw Pt(e);
+  }
+  if (t.protocol !== "http:" && t.protocol !== "https:" || t.origin !== e)
+    throw Pt(e);
+}
+function Pt(e) {
+  return new Error(
+    `Demiurge CORS origin ${JSON.stringify(e)} must be a canonical HTTP(S) origin without credentials, a path, query, or fragment.`
+  );
+}
+function os(e, t) {
+  return e.origins === "*" ? "*" : e.origins.includes(t) ? t : null;
+}
+function ss(e, t) {
+  t.forEach((r, n) => {
+    if (n === "vary" && e.has("vary")) {
+      for (const o of r.split(","))
+        Sr(e, o.trim());
+      return;
+    }
+    e.set(n, r);
+  });
+}
+function Sr(e, t) {
+  if (!t)
+    return;
+  const r = e.get("vary")?.split(",").map((n) => n.trim()).filter(Boolean) ?? [];
+  r.some((n) => n.toLowerCase() === t.toLowerCase()) || e.set("vary", [...r, t].join(", "));
+}
+function as(e) {
+  if (!e)
+    return null;
+  const t = e.toUpperCase();
+  return cs(t) ? t : null;
+}
+function br(e, t) {
+  return t === "HEAD" ? e.HEAD ?? Dt(e.GET) : Dt(e[t]);
+}
+function Dt(e) {
+  return e?.kind === "page" ? void 0 : e;
+}
+function is(e) {
+  return [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "OPTIONS",
+    "HEAD"
+  ].filter((t) => br(e, t));
+}
+function cs(e) {
+  return e === "GET" || e === "POST" || e === "PUT" || e === "PATCH" || e === "DELETE" || e === "OPTIONS" || e === "HEAD";
+}
+const us = {
+  b: 1,
+  gb: 1024 ** 3,
+  kb: 1024,
+  mb: 1024 ** 2
+}, dt = "1mb";
+function ls(e, t, r) {
+  const n = fs(e, r);
+  if (n)
+    return n;
+  const o = t.headers.get("content-length");
+  if (!o)
+    return null;
+  const s = hs(o);
+  if (s === null)
+    return new Response("Invalid Content-Length.", {
+      status: 400
+    });
+  const a = Se(ct(e?.maxBodySize) ?? dt);
+  return s > a ? new Response("Request body too large.", {
+    status: 413
+  }) : null;
+}
+class Q extends Error {
+  constructor() {
+    super("Demiurge request body exceeded maxBodySize while being read."), this.name = "RequestBodyTooLargeError";
+  }
+}
+function ds(e, t) {
+  if (t.body === null)
+    return t;
+  const r = Se(ct(e?.maxBodySize) ?? dt), n = t.body.getReader();
+  let o = 0;
+  const s = new ReadableStream({
+    async pull(i) {
+      const c = await n.read();
+      if (c.done) {
+        i.close();
+        return;
+      }
+      if (o += c.value.byteLength, o > r) {
+        const u = new Q();
+        i.error(u);
+        try {
+          await n.cancel(u);
+        } catch {
+        }
+        return;
+      }
+      i.enqueue(c.value);
+    },
+    async cancel(i) {
+      try {
+        await n.cancel(i);
+      } catch {
+      }
+    }
+  }), a = new Request(t, {
+    body: s,
+    duplex: "half"
+  });
+  return Ur(t, a), a;
+}
+function ue() {
+  return new Response("Request body too large.", { status: 413 });
+}
+function fs(e, t) {
+  return !e?.allowedMethods || ms(e.allowedMethods, t) ? null : new Response(null, {
+    headers: {
+      allow: ps(e.allowedMethods)
+    },
+    status: 405
+  });
+}
+function Se(e) {
+  if (typeof e == "number") {
+    if (!Number.isSafeInteger(e) || e < 0)
+      throw new Error("Demiurge request maxBodySize must be a non-negative integer.");
+    return e;
+  }
+  const t = /^(\d+)(b|kb|mb|gb)$/i.exec(e.trim());
+  if (!t)
+    throw new Error(
+      "Demiurge request maxBodySize must use bytes or a b/kb/mb/gb suffix."
+    );
+  const r = Number(t[1]), n = t[2].toLowerCase(), o = r * us[n];
+  if (!Number.isSafeInteger(o))
+    throw new Error("Demiurge request maxBodySize is too large.");
+  return o;
+}
+function hs(e) {
+  if (!/^\d+$/.test(e))
+    return null;
+  const t = Number(e);
+  return Number.isSafeInteger(t) ? t : null;
+}
+function ms(e, t) {
+  return e.includes(t) || t === "HEAD" && e.includes("GET");
+}
+function ps(e) {
+  const t = [...e];
+  return t.includes("GET") && !t.includes("HEAD") && t.push("HEAD"), t.join(", ");
+}
+const gs = /* @__PURE__ */ new Set(["DELETE", "PATCH", "POST", "PUT"]);
+function ws(e = {}) {
+  const t = [], r = e.document, n = r ? bs(r.policy, r.headers, t) : {};
+  r && (ys(r.policy, t), vs(r.policy, t));
+  const o = e.route ? Cs(e.route, t) : void 0;
+  return r?.scripts && (Es(
+    S(r.policy.csp),
+    r.scripts,
+    r.headers,
+    t
+  ), r.scriptDependencies && t.push(
+    ...Ss(
+      r.scripts,
+      Rs(r.scriptDependencies)
+    )
+  )), {
+    findings: t,
+    headers: n,
+    route: o
+  };
+}
+function ys(e, t) {
+  const r = ur(e.csp);
+  if (r) {
+    t.push({
+      code: "csp-disabled",
+      message: `This document accepts no Content-Security-Policy. ${ft(r)} Reason: ${r.reason}`,
+      origin: r.origin ?? "application",
+      severity: "info",
+      source: r.source
+    });
+    return;
+  }
+  e.csp === void 0 && t.push({
+    code: "document-policy-missing",
+    message: "This document declares no Content-Security-Policy. Add document: security.strict() to the @policy.ts file of the route. To accept a document without a Content-Security-Policy, declare csp with a value of false and a reason.",
+    severity: "error"
+  });
+}
+function ft(e) {
+  const r = (e.origin ?? "application") === "framework" ? "A framework helper declared this exception" : "The application declared this exception";
+  return e.source ? `${r} in ${e.source}.` : `${r}.`;
+}
+function vs(e, t) {
+  if (!e.trustedTypes || e.trustedTypes.mode !== "report-only")
+    return;
+  const r = S(e.csp) || void 0, n = !!_e(r?.reportUri)?.length, o = e.headers?.reportingEndpoints, s = !!(r?.reportTo && o && o[r.reportTo]);
+  !n && !s && t.push({
+    code: "report-only-target-missing",
+    message: "Trusted Types report-only mode has no deliverable target. Configure CSP reportTo with a matching Reporting-Endpoints member, reportUri for compatibility, or both.",
+    severity: "warning"
+  });
+}
+function Ss(e, t = {}) {
+  const r = t.requirePurpose ?? !0, n = [];
+  for (const o of e) {
+    const s = js(o);
+    s && (r && !o.purpose && n.push({
+      code: "script-purpose-missing",
+      message: `Third-party script ${o.src} should declare a purpose for audits and consent flows.`,
+      severity: "warning"
+    }), t.requireIntegrity && !o.integrity && n.push({
+      code: "script-integrity-missing",
+      message: `Third-party script ${o.src} should declare an integrity hash or an explicit trust-boundary exception.`,
+      severity: "warning"
+    }), o.strategy === "beforeInteractive" && !t.allowBeforeInteractiveThirdParty && n.push({
+      code: "script-third-party-before-interactive",
+      message: `Third-party script ${o.src} runs before the app is interactive and should be justified by policy.`,
+      severity: "warning"
+    }), Us(s) && n.push({
+      code: "script-gtm-wide-trust-boundary",
+      message: "Google Tag Manager can load additional scripts at runtime and should be treated as a wide trust boundary.",
+      severity: "warning"
+    }));
+  }
+  return n;
+}
+function bs(e, t, r) {
+  try {
+    return Object.fromEntries(se(e, t));
+  } catch (n) {
+    return r.push({
+      code: "security-header-render-failed",
+      message: n instanceof Error ? n.message : "Security headers failed to render.",
+      severity: "error"
+    }), {};
+  }
+}
+function Es(e, t, r, n) {
+  if (!e)
+    return;
+  const o = Ts(e);
+  for (const s of t) {
+    if ($s(o) && !s.nonce) {
+      n.push({
+        code: "csp-script-missing-nonce",
+        message: `Document script ${s.src} needs a nonce for the effective script-src policy.`,
+        severity: "error"
+      });
+      continue;
+    }
+    s.nonce && r?.nonce && s.nonce === r.nonce || xs(o, s.src) || n.push({
+      code: "csp-script-src-blocked",
+      message: `Document script ${s.src} is not allowed by the effective script-src policy.`,
+      severity: "error"
+    });
+  }
+}
+function Rs(e) {
+  return typeof e == "boolean" ? {} : e;
+}
+function Ts(e) {
+  return _e(e.scriptSrc) ?? _e(e.defaultSrc) ?? [];
+}
+function _e(e) {
+  if (e)
+    return "replace" in e ? e.replace : e;
+}
+function $s(e) {
+  return e.some((t) => t.includes("'nonce-{nonce}'"));
+}
+function xs(e, t) {
+  return Ls(e) ? !1 : e.includes("*") ? !0 : e.includes("'none'") || e.some((r) => r.startsWith("'nonce-")) ? !1 : e.includes("'self'") && As(t) || t.startsWith("https:") && e.includes("https:") || t.startsWith("http:") && e.includes("http:") ? !0 : e.some((r) => ks(r, t));
+}
+function As(e) {
+  return e.startsWith("/") && !e.startsWith("//");
+}
+function ks(e, t) {
+  if (e.startsWith("'"))
+    return !1;
+  try {
+    const r = new URL(e), n = new URL(t), o = r.hostname.startsWith("*.") ? n.hostname.endsWith(r.hostname.slice(1)) && n.hostname !== r.hostname.slice(2) : n.hostname === r.hostname, s = r.pathname === "/" || r.pathname.endsWith("/") ? n.pathname.startsWith(r.pathname) : n.pathname === r.pathname;
+    return n.protocol === r.protocol && o && n.port === r.port && s;
+  } catch {
+    return !1;
+  }
+}
+function Ls(e) {
+  return e.includes("'strict-dynamic'") && e.some(
+    (t) => t.startsWith("'nonce-") || /^'sha(?:256|384|512)-/.test(t)
+  );
+}
+function Cs(e, t) {
+  return Os(e.cors, t), Ps(e.access, t), Ns(e.method, e.security, t), Ms(e.security, t), {
+    access: e.access,
+    cors: e.cors,
+    method: e.method,
+    security: e.security
+  };
+}
+function Ps(e, t) {
+  if (e) {
+    e.declared ? e.public ? t.push({
+      code: "access-public",
+      message: "This route declares public access, so it runs no authorization hook.",
+      severity: "info"
+    }) : t.push({
+      code: "access-authorized",
+      message: `This route runs ${e.chain.length} inherited authorization ${e.chain.length === 1 ? "hook" : "hooks"}, from ${Ds(e)}. A denial uses status ${e.denyStatus}.`,
+      severity: "info"
+    }) : t.push({
+      code: "access-declaration-missing",
+      message: "This route inherits no access declaration, so the request pipeline denies each request. Add access to this route or an ancestor @policy.ts file.",
+      severity: "error"
+    });
+    for (const r of e.exceptions)
+      t.push({
+        code: "access-exception",
+        message: `An access exception in ${r.source ?? "an unnamed policy file"} removed each inherited authorization hook for ${r.scope ?? "this subtree"}. Reason: ${r.reason}`,
+        severity: "warning",
+        source: r.source
+      });
+  }
+}
+function Ds(e) {
+  return e.chain.map((r) => r.source ?? "an unnamed policy file").join(", ");
+}
+function Os(e, t) {
+  if (e)
+    try {
+      lt(e);
+    } catch (r) {
+      t.push({
+        code: "cors-invalid",
+        message: r instanceof Error ? r.message : "CORS policy is invalid.",
+        severity: "error"
+      });
+    }
+}
+function Ns(e, t, r) {
+  if (!gs.has(e))
+    return;
+  const n = lr(t?.csrf);
+  n && r.push({
+    code: "csrf-disabled",
+    message: `This unsafe route runs no CSRF check. ${ft(n)} Reason: ${n.reason}`,
+    origin: n.origin ?? "application",
+    severity: "info",
+    source: n.source
+  }), t?.rateLimit || r.push({
+    code: "rate-limit-missing",
+    message: "Unsafe routes should declare rate limiting.",
+    severity: "warning"
+  });
+}
+function Ms(e, t) {
+  const r = dr(e?.request?.maxBodySize), n = ct(e?.request?.maxBodySize);
+  if (n === void 0)
+    return;
+  let o, s;
+  try {
+    o = Se(n), s = Se(dt);
+  } catch {
+    return;
+  }
+  if (!(o <= s)) {
+    if (!r) {
+      t.push({
+        code: "security-exception-reason-missing",
+        message: `This route raises the inherited request body limit to ${n} and states no reason. Declare maxBodySize with a limit value and a reason.`,
+        severity: "error"
+      });
+      return;
+    }
+    t.push({
+      code: "request-body-limit-raised",
+      message: `This route raises the inherited request body limit to ${n}. ${ft(r)} Reason: ${r.reason}`,
+      origin: r.origin ?? "application",
+      severity: "info",
+      source: r.source
+    });
+  }
+}
+function js(e) {
+  try {
+    const t = new URL(e.src);
+    if (t.protocol === "http:" || t.protocol === "https:")
+      return t;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function Us(e) {
+  return e.hostname === "www.googletagmanager.com" && (e.pathname === "/gtm.js" || e.pathname === "/ns.html");
+}
+const Is = /* @__PURE__ */ new Set(["DELETE", "PATCH", "POST", "PUT"]), zs = /^[!#$%&'*+\-.^_`|~A-Za-z0-9]+$/;
+function Hs() {
+  const e = new Uint8Array(32);
+  return globalThis.crypto.getRandomValues(e), btoa(String.fromCharCode(...e)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function Fs(e, t = {}) {
+  const r = t.cookie ?? "csrf-token";
+  if (!zs.test(r))
+    throw new Error("Demiurge CSRF cookie name is invalid.");
+  if (!e)
+    throw new Error("Demiurge CSRF token must not be empty.");
+  const n = [
+    `${r}=${encodeURIComponent(e)}`,
+    "Path=/",
+    "SameSite=Lax"
+  ];
+  return (t.secure ?? !0) && n.push("Secure"), n.join("; ");
+}
+function _i(e = {}) {
+  const t = Hs();
+  return {
+    cookie: Fs(t, e),
+    token: t
+  };
+}
+async function Ws(e, t) {
+  const r = Lo(e);
+  if (!Is.has(t.method.toUpperCase()) || r === !1)
+    return null;
+  const n = t.headers.get("cookie");
+  if (r === void 0 && !n?.trim())
+    return null;
+  const o = Vs(r ?? !0), a = Bs(n).get(o.cookie), i = t.headers.get(o.header);
+  if (!!(a && i && Ot(a, i)))
+    return null;
+  const u = o.field ? await qs(t.clone(), o.field) : null;
+  return !(a && u && Ot(a, u)) ? new Response("Invalid CSRF token.", {
+    status: 403
+  }) : null;
+}
+function Bs(e) {
+  const t = /* @__PURE__ */ new Map();
+  if (!e)
+    return t;
+  for (const r of e.split(";")) {
+    const n = r.indexOf("=");
+    if (n === -1)
+      continue;
+    const o = r.slice(0, n).trim(), s = r.slice(n + 1).trim();
+    o && t.set(o, _s(s));
+  }
+  return t;
+}
+function Vs(e) {
+  return e === !0 ? {
+    cookie: "csrf-token",
+    header: "x-csrf-token"
+  } : {
+    cookie: e.cookie ?? "csrf-token",
+    field: e.field,
+    header: e.header ?? "x-csrf-token"
+  };
+}
+async function qs(e, t) {
+  const r = e.headers.get("content-type")?.toLowerCase() ?? "";
+  if (!r.startsWith("application/x-www-form-urlencoded") && !r.startsWith("multipart/form-data"))
+    return null;
+  try {
+    const n = (await e.formData()).get(t);
+    return typeof n == "string" ? n : null;
+  } catch {
+    return null;
+  }
+}
+function _s(e) {
+  try {
+    return decodeURIComponent(e);
+  } catch {
+    return e;
+  }
+}
+function Ot(e, t) {
+  let r = e.length ^ t.length;
+  const n = Math.max(e.length, t.length);
+  for (let o = 0; o < n; o += 1)
+    r |= e.charCodeAt(o) ^ t.charCodeAt(o);
+  return r === 0;
+}
+const Me = "Sec-Fetch-Dest", Gs = "Sec-Fetch-Mode", Js = "Sec-Fetch-Site", Ks = /* @__PURE__ */ new Set(["embed", "object"]), Ys = /* @__PURE__ */ new Set(["GET", "HEAD"]), Nt = {
+  allowCrossSite: !1,
+  allowNavigation: !0,
+  allowSameSite: !1
+};
+function Zs(e, t, r = t.method) {
+  const n = e === !0 ? Nt : { ...Nt, ...e }, o = [];
+  if (Xs(t, r))
+    return { allowed: !0, reason: "cors-preflight", vary: o };
+  o.push(Js);
+  const s = t.headers.get("sec-fetch-site");
+  if (s === null)
+    return { allowed: !0, reason: "metadata-absent", vary: o };
+  if (s === "same-origin")
+    return { allowed: !0, reason: "same-origin", vary: o };
+  if (s === "none")
+    return { allowed: !0, reason: "user-initiated", vary: o };
+  if (s === "same-site" && n.allowSameSite)
+    return { allowed: !0, reason: "same-site-trusted", vary: o };
+  if (n.allowCrossSite)
+    return { allowed: !0, reason: "cross-site-exempt", vary: o };
+  const a = e === !0 ? void 0 : e.allowedDestinations;
+  if (a?.length && (o.push(Me), a.includes(t.headers.get("sec-fetch-dest") ?? "")))
+    return { allowed: !0, reason: "destination-exempt", vary: o };
+  if (n.allowNavigation && Ys.has(r.toUpperCase()) && (o.push(Gs), t.headers.get("sec-fetch-mode") === "navigate")) {
+    const i = t.headers.get("sec-fetch-dest") ?? "";
+    if (o.includes(Me) || o.push(Me), !Ks.has(i))
+      return { allowed: !0, reason: "top-level-navigation", vary: o };
+  }
+  return {
+    allowed: !1,
+    reason: s === "same-site" ? "same-site-denied" : "cross-site-denied",
+    vary: o
+  };
+}
+function Qs(e, t, r = t.method) {
+  if (!e)
+    return { response: null, vary: [] };
+  const n = Zs(e, t, r);
+  if (n.allowed)
+    return { response: null, vary: n.vary };
+  const o = new Response("Request blocked by the Fetch Metadata policy.", {
+    headers: { "content-type": "text/plain; charset=utf-8" },
+    status: 403
+  });
+  return Er(o, n.vary), { response: o, vary: n.vary };
+}
+function Er(e, t) {
+  if (t.length === 0)
+    return e;
+  const r = e.headers.get("vary")?.split(",").map((o) => o.trim()).filter(Boolean) ?? [];
+  if (r.includes("*"))
+    return e;
+  const n = [...r];
+  for (const o of t)
+    n.some((s) => s.toLowerCase() === o.toLowerCase()) || n.push(o);
+  return e.headers.set("vary", n.join(", ")), e;
+}
+function Xs(e, t) {
+  return t.toUpperCase() === "OPTIONS" && e.headers.has("access-control-request-method");
+}
+class Rr extends Error {
+  issues;
+  constructor(t) {
+    super(aa(t)), this.name = "EnvValidationError", this.issues = t;
+  }
+}
+function Gi(e) {
+  return e;
+}
+function Ji(e, t) {
+  const r = [], n = {};
+  for (const o of Object.keys(e)) {
+    const s = e[o], a = t[String(o)];
+    if (a === void 0 || a === "") {
+      if (s.optional) {
+        n[o] = void 0;
+        continue;
+      }
+      r.push({
+        code: "missing",
+        key: String(o),
+        message: `Environment variable ${String(o)} is required.`
+      });
+      continue;
+    }
+    try {
+      n[o] = s.parse(String(o), a);
+    } catch (i) {
+      r.push({
+        code: "invalid",
+        key: String(o),
+        message: i instanceof Error ? i.message : `Environment variable ${String(o)} is invalid.`
+      });
+    }
+  }
+  if (r.length)
+    throw new Rr(r);
+  return n;
+}
+function ea(e = {}) {
+  return q(e, !1, (t, r) => {
+    if (r === "true" || r === "1")
+      return !0;
+    if (r === "false" || r === "0")
+      return !1;
+    throw new Error(`Environment variable ${t} must be true, false, 1, or 0.`);
+  }, "boolean");
+}
+function ta(e, t = {}) {
+  return q(t, !1, (r, n) => {
+    if (e.includes(n))
+      return n;
+    throw new Error(
+      `Environment variable ${r} must be one of: ${e.join(", ")}.`
+    );
+  }, "enum", { values: [...e] });
+}
+function ra(e = {}) {
+  return q(e, !1, (t, r) => {
+    if (!/^-?\d+$/.test(r))
+      throw new Error(`Environment variable ${t} must be an integer.`);
+    const n = Number(r);
+    if (!Number.isSafeInteger(n))
+      throw new Error(`Environment variable ${t} must be a safe integer.`);
+    if (e.min !== void 0 && n < e.min)
+      throw new Error(
+        `Environment variable ${t} must be greater than or equal to ${e.min}.`
+      );
+    if (e.max !== void 0 && n > e.max)
+      throw new Error(
+        `Environment variable ${t} must be less than or equal to ${e.max}.`
+      );
+    return n;
+  }, "integer");
+}
+function na(e = {}) {
+  return q(
+    e,
+    !0,
+    (t, r) => Tr(t, r, e),
+    "secret"
+  );
+}
+function oa(e = {}) {
+  return q(
+    e,
+    !1,
+    (t, r) => Tr(t, r, e),
+    "string"
+  );
+}
+function sa(e = {}) {
+  return q(e, !1, (t, r) => {
+    let n;
+    try {
+      n = new URL(r);
+    } catch {
+      throw new Error(`Environment variable ${t} must be a valid URL.`);
+    }
+    if (e.protocols?.length && !e.protocols.includes(n.protocol))
+      throw new Error(
+        `Environment variable ${t} must use one of these protocols: ${e.protocols.join(", ")}.`
+      );
+    return n;
+  }, "url");
+}
+const N = {
+  boolean: ea,
+  enum: ta,
+  integer: ra,
+  secret: na,
+  string: oa,
+  url: sa
+};
+function q(e, t, r, n = "string", o = {}) {
+  const s = { ...e, ...o }, { client: a = !1, deferred: i = !1, optional: c = !1, ...u } = s;
+  if (a && t)
+    throw new Error(
+      "A secret environment variable cannot reach client code. Declare a separate variable for the browser."
+    );
+  if (c && i)
+    throw new Error(
+      "An environment variable cannot combine optional with deferred. Declare one of the two options."
+    );
+  if (a && i)
+    throw new Error(
+      "A client environment variable cannot be deferred. The build validates the value of a client variable."
+    );
+  return {
+    client: a,
+    deferred: i,
+    kind: n,
+    optional: c,
+    options: u,
+    parse: r,
+    sensitive: t
+  };
+}
+function Tr(e, t, r) {
+  if (r.minLength !== void 0 && t.length < r.minLength)
+    throw new Error(
+      `Environment variable ${e} must be at least ${r.minLength} characters.`
+    );
+  return t;
+}
+function aa(e) {
+  return e.length === 1 ? e[0].message : `Environment validation failed with ${e.length} issues.`;
+}
+const Mt = Symbol.for("demiurge.environmentState"), jt = Symbol.for("demiurge.deferredEnvironmentState"), be = globalThis, B = ia(), U = ca();
+function ia() {
+  const e = be[Mt];
+  if (e instanceof Map) return e;
+  const t = /* @__PURE__ */ new Map();
+  return be[Mt] = t, t;
+}
+function ca() {
+  const e = be[jt];
+  if (e instanceof Map) return e;
+  const t = /* @__PURE__ */ new Map();
+  return be[jt] = t, t;
+}
+function Ki(e) {
+  return Object.fromEntries(
+    Object.entries(e).map(([t, r]) => [t, {
+      client: r.client,
+      deferred: r.deferred,
+      kind: r.kind,
+      optional: r.optional,
+      options: r.options,
+      sensitive: r.sensitive
+    }])
+  );
+}
+function ua(e) {
+  return Object.fromEntries(
+    Object.entries(e).map(([t, r]) => [
+      t,
+      da(t, r)
+    ])
+  );
+}
+function Yi(e, t = {}) {
+  const r = fa(e) ? e : ua(e), n = t.source ?? ha(), o = [], s = {};
+  for (const [a, i] of Object.entries(r)) {
+    const c = n[a];
+    if (i.deferred) {
+      U.set(a, { rawValue: c, variable: i });
+      continue;
+    }
+    if (c === void 0 || c === "") {
+      if (s[a] = void 0, i.optional) continue;
+      o.push({
+        code: "missing",
+        key: a,
+        message: `Environment variable ${a} is required.`
+      });
+      continue;
+    }
+    try {
+      s[a] = i.parse(a, c);
+    } catch (u) {
+      s[a] = void 0, o.push({
+        code: "invalid",
+        key: a,
+        message: u instanceof Error ? u.message : `Environment variable ${a} is invalid.`
+      });
+    }
+  }
+  if (o.length) throw new Rr(o);
+  for (const [a, i] of Object.entries(s)) B.set(a, i);
+  return { values: s };
+}
+function Zi(e) {
+  const t = {};
+  for (const r of Object.keys(e)) {
+    if (U.has(r)) {
+      t[r] = la(r);
+      continue;
+    }
+    if (!B.has(r))
+      throw new Error(
+        `Demiurge did not validate the environment variable ${r}. The framework validates the schema of demiurge.config.ts when the server starts.`
+      );
+    t[r] = B.get(r);
+  }
+  return t;
+}
+function Qi() {
+  B.clear(), U.clear();
+}
+function la(e) {
+  const t = U.get(e), { rawValue: r, variable: n } = t;
+  if (r === void 0 || r === "") {
+    if (n.optional) {
+      U.delete(e), B.set(e, void 0);
+      return;
+    }
+    throw new Error(
+      `Environment variable ${e} is required. Give the variable a value before the code reads it.`
+    );
+  }
+  let o;
+  try {
+    o = n.parse(e, r);
+  } catch (s) {
+    throw new Error(
+      s instanceof Error ? s.message : `Environment variable ${e} is invalid.`,
+      { cause: s }
+    );
+  }
+  return U.delete(e), B.set(e, o), o;
+}
+function da(e, t) {
+  const r = {
+    ...t.options,
+    client: t.client,
+    deferred: t.deferred,
+    optional: t.optional
+  };
+  if (t.kind === "boolean") return N.boolean(r);
+  if (t.kind === "integer") return N.integer(r);
+  if (t.kind === "secret") return N.secret(r);
+  if (t.kind === "url") return N.url(r);
+  if (t.kind === "enum") {
+    const n = t.options.values;
+    if (!Array.isArray(n) || !n.length)
+      throw new Error(
+        `The environment variable ${e} does not have the values of its enum.`
+      );
+    return N.enum(n, r);
+  }
+  return N.string(r);
+}
+function fa(e) {
+  return Object.values(e).every(
+    (t) => "parse" in t && typeof t.parse == "function"
+  );
+}
+function ha() {
+  return globalThis.process?.env ?? {};
+}
+const ma = {
+  h: 3600 * 1e3,
+  m: 60 * 1e3,
+  s: 1e3
+}, pa = 1e4;
+function $r(e = {}) {
+  const t = e.maximumEntries ?? pa;
+  if (!Number.isSafeInteger(t) || t <= 0)
+    throw new Error(
+      "Demiurge rate limit maximumEntries must be a positive integer."
+    );
+  const r = /* @__PURE__ */ new Map();
+  let n = Number.POSITIVE_INFINITY;
+  return {
+    increment(o, s, a) {
+      a >= n && (ga(r, a), n = wa(r));
+      const i = r.get(o);
+      if (!i || i.resetAt <= a) {
+        const c = {
+          count: 1,
+          resetAt: a + s
+        };
+        return !i && r.size >= t && ya(r), r.set(o, c), n = Math.min(n, c.resetAt), { count: c.count, resetAt: c.resetAt };
+      }
+      return i.count += 1, { count: i.count, resetAt: i.resetAt };
+    }
+  };
+}
+function ga(e, t) {
+  for (const [r, n] of e)
+    n.resetAt <= t && e.delete(r);
+}
+function wa(e) {
+  let t = Number.POSITIVE_INFINITY;
+  for (const r of e.values())
+    t = Math.min(t, r.resetAt);
+  return t;
+}
+function ya(e) {
+  const t = e.keys().next().value;
+  t !== void 0 && e.delete(t);
+}
+async function va(e, t, r, n = Date.now()) {
+  if (!e)
+    return null;
+  ht(e);
+  const o = xr(e.window), s = Sa(e, t), a = await r.increment(s, o, n), i = Math.max(0, e.limit - a.count), c = new Headers({
+    "retry-after": String(Math.ceil(Math.max(0, a.resetAt - n) / 1e3)),
+    "x-ratelimit-limit": String(e.limit),
+    "x-ratelimit-remaining": String(i),
+    "x-ratelimit-reset": String(Math.ceil(a.resetAt / 1e3))
+  });
+  return a.count > e.limit ? new Response("Rate limit exceeded.", {
+    headers: c,
+    status: 429
+  }) : null;
+}
+function xr(e) {
+  if (typeof e == "number") {
+    if (!Number.isSafeInteger(e) || e <= 0)
+      throw new Error("Demiurge rate limit window must be a positive integer.");
+    return e;
+  }
+  const t = /^(\d+)(s|m|h)$/i.exec(e.trim());
+  if (!t)
+    throw new Error("Demiurge rate limit window must use an s/m/h suffix.");
+  const r = Number(t[1]), n = t[2].toLowerCase(), o = r * ma[n];
+  if (!Number.isSafeInteger(o))
+    throw new Error("Demiurge rate limit window is too large.");
+  return o;
+}
+function ht(e) {
+  if (!Number.isSafeInteger(e.limit) || e.limit <= 0)
+    throw new Error("Demiurge rate limit limit must be a positive integer.");
+  xr(e.window);
+}
+function Sa(e, t) {
+  return `${ba(e.key)}:${Ea(e.key, t)}`;
+}
+function ba(e) {
+  return typeof e == "string" ? e : `header:${e.header.toLowerCase()}`;
+}
+function Ea(e, t) {
+  return e === "ip" ? Ra(t) : t.headers.get(e.header) ?? "missing";
+}
+function Ra(e) {
+  return Ir(e)?.clientIp ?? "unknown";
+}
+const Ta = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+];
+function $a(e, t = {}) {
+  t.adapter && xa(t.adapter);
+  for (const [n, o] of Object.entries(e)) {
+    Aa(n, o);
+    for (const s of Ta) {
+      const a = o[s];
+      !a || a.kind === "page" || ka(n, s, a, o);
+    }
+  }
+  const r = Kt(
+    Object.fromEntries(
+      Object.entries(e).map(([n, o]) => [
+        n,
+        async () => o
+      ])
+    )
+  );
+  return Da(r, e, t.adapter), r;
+}
+function xa(e) {
+  zr(e, ["requestTimeoutEnforcement"]).ok || console.warn(
+    `Demiurge adapter "${e.name}" does not report requestTimeoutEnforcement. Every route inherits a bounded request body limit. This adapter gives the shared pipeline no guarantee against a slow request. A slow request can hold a connection open below that limit. Bound connection duration at the host or platform.`
+  );
+}
+function Aa(e, t) {
+  const r = t.policy?.security?.rateLimit;
+  r && ne(e, "policy", "rate limit", () => {
+    ht(r);
+  });
+}
+function ka(e, t, r, n) {
+  r.cors && ne(e, t, "CORS", () => {
+    lt(r.cors), La(e, t, r.cors.methods, n);
+  }), r.security?.rateLimit && ne(e, t, "rate limit", () => {
+    ht(r.security.rateLimit);
+  });
+}
+function La(e, t, r, n) {
+  if (r) {
+    for (const o of r)
+      if (o !== "OPTIONS" && !Ca(n, o))
+        throw new Error(
+          `Route ${JSON.stringify(e)} export ${t} allows CORS method ${o}, but the route does not export that response capability.`
+        );
+  }
+}
+function Ca(e, t) {
+  const r = t === "HEAD" ? e.HEAD ?? e.GET : e[t];
+  return Pa(r) ? r : void 0;
+}
+function Pa(e) {
+  return !!(e && e.kind !== "page");
+}
+function Da(e, t, r) {
+  for (const o of e.routes) {
+    const s = t[o.file], a = s?.GET;
+    if (!a || a.kind !== "page")
+      continue;
+    const i = ye(
+      ...e.policies.filter(
+        (c) => C(c.fileSegments, o.fileSegments)
+      ).map((c) => t[c.file]?.policy),
+      s.policy
+    );
+    Ut(o.file, "GET", i, r), Ia(
+      o.file,
+      a.render.mode,
+      i.document
+    ), Oa(
+      o.file,
+      "GET",
+      i,
+      [
+        ...e.layouts.filter(
+          (c) => C(c.fileSegments, o.fileSegments)
+        ).map((c) => t[c.file]?.scripts),
+        s.scripts
+      ]
+    );
+  }
+  const n = [
+    ...e.fallbacks.error,
+    ...e.fallbacks.loading,
+    ...e.fallbacks.notFound
+  ];
+  for (const o of n) {
+    const s = ye(
+      ...e.policies.filter(
+        (a) => C(a.fileSegments, o.fileSegments)
+      ).map((a) => t[a.file]?.policy),
+      t[o.file]?.policy
+    );
+    Ut(
+      o.file,
+      "policy",
+      s,
+      r
+    );
+  }
+}
+function Oa(e, t, r, n) {
+  const o = n.flatMap(
+    (d) => Array.isArray(d) ? d : []
+  );
+  if (o.length === 0 || !r.document)
+    return;
+  const s = "startup-verification-nonce", i = ws({
+    document: {
+      headers: { nonce: s },
+      policy: r.document,
+      scripts: o.map((d) => ({
+        ...d,
+        nonce: $e(r.document) ? s : d.nonce
+      }))
+    }
+  }).findings.find(
+    (d) => d.code === "csp-script-src-blocked"
+  );
+  if (!i) {
+    Ma(
+      e,
+      t,
+      S(r.document.csp),
+      o
+    );
+    return;
+  }
+  const c = o.find(
+    (d) => i.message.includes(d.src)
+  ), l = (se(r.document, { nonce: s }).get("content-security-policy") ?? "").split("; ").find(
+    (d) => d.startsWith("script-src ")
+  ) ?? "default-src (script-src fallback)";
+  throw new Error(
+    `Route ${JSON.stringify(e)} export ${t} declares script ${JSON.stringify(c?.src)} that violates the effective ${l} policy.`
+  );
+}
+const Na = [
+  { directive: "connectSrc", name: "connect-src", need: "connect" },
+  { directive: "imgSrc", name: "img-src", need: "img" }
+];
+function Ma(e, t, r, n) {
+  if (r)
+    for (const o of n)
+      for (const { directive: s, name: a, need: i } of Na) {
+        const c = o.needs?.[i] ?? [];
+        if (c.length === 0)
+          continue;
+        const u = re(r[s]) ?? re(r.defaultSrc);
+        if (u !== void 0) {
+          for (const l of c)
+            if (!(Array.isArray(u) && ja(u, l)))
+              throw new Error(
+                `Route ${JSON.stringify(e)} export ${t} declares script ${JSON.stringify(o.src)} that needs ${a} ${l}, which the effective policy does not allow. Add ${l} to security.needs.${i} or to csp.${s} for this route.`
+              );
+        }
+      }
+}
+function ja(e, t) {
+  return e.includes("'none'") ? !1 : e.includes("*") || e.includes(t) ? !0 : t.startsWith("'") ? !1 : e.some((r) => Ua(r, t));
+}
+function Ua(e, t) {
+  if (e.startsWith("'"))
+    return !1;
+  let r;
+  try {
+    r = new URL(t);
+  } catch {
+    return !1;
+  }
+  if (e === `${r.protocol}`)
+    return !0;
+  let n;
+  try {
+    n = new URL(e);
+  } catch {
+    return !1;
+  }
+  if (n.protocol !== r.protocol || n.port !== r.port)
+    return !1;
+  if (n.hostname.startsWith("*.")) {
+    const o = n.hostname.slice(1);
+    return r.hostname.endsWith(o) && r.hostname !== n.hostname.slice(2);
+  }
+  return n.hostname === r.hostname;
+}
+function Ut(e, t, r, n) {
+  ne(e, t, "effective document", () => {
+    se(r.document ?? {}, {
+      nonce: "startup-verification-nonce"
+    });
+  }), !(!n || !$e(r.document)) && ne(e, t, "effective CSP", () => {
+    Hr(n, ["nonceInjection"]);
+  });
+}
+function Ia(e, t, r) {
+  if (t === "static") {
+    const o = za(S(r?.csp));
+    if (o)
+      throw new Error(
+        `Route ${JSON.stringify(e)} uses render mode "static" with an effective ${o} directive that depends on a CSP nonce. Use security.static() for static output or remove the nonce source from the document policy.`
+      );
+    return;
+  }
+  if (t !== "streaming")
+    return;
+  const n = Ha(S(r?.csp));
+  if (!(!n || Fa(n.sources)))
+    throw new Error(
+      `Route ${JSON.stringify(e)} uses render mode "streaming" with an effective ${n.name} directive that does not allow React runtime inline payload scripts. Add a nonce placeholder or allow 'unsafe-inline' without nonce or hash sources.`
+    );
+}
+function za(e) {
+  if (e)
+    for (const [t, r] of Object.entries(e)) {
+      const n = re(r);
+      if (Array.isArray(n) && n.some((o) => Wa(o)))
+        return Va(t);
+    }
+}
+function Ha(e) {
+  if (!e)
+    return;
+  const t = re(e.scriptSrc);
+  if (Array.isArray(t))
+    return { name: "script-src", sources: t };
+  const r = re(e.defaultSrc);
+  if (Array.isArray(r))
+    return { name: "default-src", sources: r };
+}
+function Fa(e) {
+  return e.some((t) => Ar(t)) ? !0 : e.includes("'unsafe-inline'") && !e.some((t) => Ba(t));
+}
+function Wa(e) {
+  return Ar(e) || /^'nonce-[^']*'$/i.test(e);
+}
+function Ar(e) {
+  return e.includes("{nonce}");
+}
+function Ba(e) {
+  return /^'(?:nonce-|sha256-|sha384-|sha512-)/i.test(e);
+}
+function re(e) {
+  return e && typeof e == "object" && !Array.isArray(e) && "replace" in e ? e.replace : e;
+}
+function Va(e) {
+  return e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+}
+function ne(e, t, r, n) {
+  try {
+    n();
+  } catch (o) {
+    if (o instanceof Error && o.message.startsWith(`Route ${JSON.stringify(e)} export `))
+      throw o;
+    const s = o instanceof Error ? o.message : `${r} validation failed.`;
+    throw new Error(
+      `Route ${JSON.stringify(e)} export ${t} has an invalid ${r} policy. ${s}`,
+      { cause: o }
+    );
+  }
+}
+function qa(e) {
+  return te({
+    instance: `${e.pathname}${e.search}`,
+    status: 404,
+    title: "Not Found"
+  });
+}
+async function Ee(e, t, r = {}) {
+  const n = new URL(t.url), o = r.pathname ?? n.pathname;
+  if (!F(t) && !ir(t))
+    return qa(n);
+  const s = await We(e, o, {
+    locale: r.locale,
+    onLayoutError: (l) => r.onError?.(l, "page")
+  }), a = await _a(e, o), i = r.nonce ?? ($e(a) ? mr() : void 0), c = se(a ?? {}, {
+    nonce: i,
+    request: t
+  });
+  if (F(t))
+    return rt(void 0, {
+      document: Je({
+        dir: r.dir,
+        lang: r.lang,
+        metadata: s.metadata,
+        title: r.title
+      }),
+      locale: r.locale,
+      headers: c,
+      kind: Be,
+      status: 404
+    });
+  const u = Ga(s, { ...r, nonce: i });
+  return c.set("content-type", "text/html; charset=utf-8"), new Response(
+    await r.transformDocument?.(u) ?? u,
+    {
+      headers: c,
+      status: 404
+    }
+  );
+}
+async function _a(e, t) {
+  const r = await Promise.all(
+    hn(e, t).map((n) => n.load())
+  );
+  return ye(...r.map((n) => n.policy)).document;
+}
+function Ga(e, t = {}) {
+  const r = e.notFound ?? Tt;
+  try {
+    return je(e, r, e.layouts, t);
+  } catch (n) {
+    t.onError?.(n, "page");
+  }
+  try {
+    return je(e, r, [], t);
+  } catch (n) {
+    t.onError?.(n, "page");
+  }
+  return je(e, Tt, [], t);
+}
+function je(e, t, r, n) {
+  const o = r.reduceRight(
+    (a, i) => Ie(i, {
+      children: a,
+      locale: e.locale,
+      path: {},
+      pathname: e.pathname
+    }),
+    Ie(t, { locale: e.locale, pathname: e.pathname })
+  ), s = Ft({
+    dev: n.dev,
+    nonce: n.nonce
+  });
+  return Bt({
+    body: {
+      data: void 0,
+      fallback: "not-found",
+      html: Vt(Wt(s, o)),
+      locale: n.locale,
+      navigation: n.navigation
+    },
+    entrySrc: n.clientEntry,
+    lang: n.lang,
+    metadata: e.metadata,
+    nonce: n.nonce,
+    scripts: s.scripts(),
+    styles: n.styles,
+    title: n.title
+  });
+}
+const kr = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+], Lr = $r();
+function Xi(e) {
+  e.routeModules && $a(e.routeModules, { adapter: e.adapter });
+  const t = Kt(e.routes), r = e.locales ? Ln(e.locales) : void 0, n = e.rateLimitStore ?? $r();
+  return e.cacheStore && _t(e.cacheStore.namespace), async function(s) {
+    let a = e.ssr;
+    if (r) {
+      const i = Cn(s, r);
+      if (i.unsupported)
+        return await Ee(t, s, {
+          ...e.ssr,
+          dir: Pe(i.locale, r),
+          lang: i.locale,
+          locale: i.locale,
+          pathname: i.pathname
+        });
+      if (i.redirect) {
+        if (s.method !== "GET" && s.method !== "HEAD")
+          return te({ status: 400, title: "The locale URL is not canonical." });
+        const u = i.source === "cookie" || i.source === "accept-language";
+        if (u && !await Ja(t, i.pathname))
+          return await Ue(t, s, {
+            cacheStore: e.cacheStore,
+            onError: e.onError,
+            rateLimitStore: n,
+            renderPage: e.renderPage,
+            routePathname: i.pathname,
+            ssr: {
+              ...e.ssr,
+              dir: Pe(r.defaultLocale, r),
+              lang: r.defaultLocale,
+              locale: r.defaultLocale
+            }
+          });
+        const l = new Headers({ location: i.redirect.href });
+        return u && (l.set("cache-control", "private, no-store"), l.set("vary", [r.cookie ? "Cookie" : void 0, "Accept-Language"].filter(Boolean).join(", "))), new Response(null, { headers: l, status: u ? 307 : 308 });
+      }
+      a = {
+        ...e.ssr,
+        dir: Pe(i.locale, r),
+        lang: i.locale,
+        locale: i.locale
+      };
+      const c = await Ue(t, s, {
+        cacheStore: e.cacheStore,
+        locales: r,
+        onError: e.onError,
+        rateLimitStore: n,
+        renderPage: e.renderPage,
+        routePathname: i.pathname,
+        ssr: a
+      });
+      return Ka(c, s, i.locale, r), c;
+    }
+    return await Ue(t, s, {
+      cacheStore: e.cacheStore,
+      onError: e.onError,
+      rateLimitStore: n,
+      renderPage: e.renderPage,
+      ssr: a
+    });
+  };
+}
+async function Ja(e, t) {
+  const r = V(e.routes, t);
+  return r ? (await r.route.load()).GET?.kind === "page" : !0;
+}
+function Ka(e, t, r, n) {
+  const o = e.headers.get("location");
+  if (!o) return;
+  const s = new URL(t.url);
+  new URL(o, s).origin === s.origin && e.headers.set(
+    "location",
+    er(o, r, n, s.href)
+  );
+}
+async function Ue(e, t, r = {
+  rateLimitStore: Lr
+}) {
+  const n = new URL(t.url), o = r.routePathname ?? n.pathname, s = ri(n, r), a = F(t);
+  let i;
+  try {
+    i = V(e.routes, o);
+  } catch (c) {
+    if (!(c instanceof tt))
+      throw c;
+    const u = te({
+      instance: `${n.pathname}${n.search}`,
+      status: 400,
+      title: "Bad Request"
+    });
+    return a ? ce(u, fe) : u;
+  }
+  if (!i)
+    try {
+      const c = await Ee(
+        e,
+        t,
+        s
+      );
+      return a ? ce(c, Be) : c;
+    } catch (c) {
+      return s.onError(c, "page"), new Response("Not Found", {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+        status: 404
+      });
+    }
+  try {
+    const c = await Ya(
+      e,
+      t,
+      n,
+      i,
+      o,
+      r,
+      s
+    );
+    return a && !c.headers.has(H) ? ce(
+      c,
+      c.status === 404 ? Be : fe
+    ) : c;
+  } catch (c) {
+    const u = await me(
+      e,
+      t,
+      c,
+      "middleware",
+      s
+    );
+    return a ? ce(u, fe) : u;
+  }
+}
+async function Ya(e, t, r, n, o, s, a) {
+  const i = await n.route.load();
+  if (t.method.toUpperCase() === "OPTIONS") {
+    const p = rs(i, t);
+    if (p)
+      return p;
+  }
+  const c = ai(t.method);
+  if (!c)
+    return Ht(i);
+  const u = ii(i, c);
+  if (!u)
+    return Ht(i);
+  const l = await oi(
+    e,
+    n.route,
+    i,
+    u
+  ), d = l.security, h = Qs(
+    d?.fetchMetadata,
+    t,
+    c
+  ), f = (p) => Er(p, h.vary);
+  if (h.response)
+    return f(
+      Z(
+        h.response,
+        de(u),
+        t
+      )
+    );
+  const m = await Ws(d?.csrf, t);
+  if (m)
+    return f(
+      Z(m, de(u), t)
+    );
+  const w = await va(
+    d?.rateLimit,
+    t,
+    s.rateLimitStore ?? Lr
+  );
+  if (w)
+    return f(
+      Z(
+        w,
+        de(u),
+        t
+      )
+    );
+  const g = ls(
+    d?.request,
+    t,
+    c
+  );
+  if (g)
+    return f(
+      Z(
+        g,
+        de(u),
+        t
+      )
+    );
+  t = ds(d?.request, t);
+  const O = {}, xe = ti(s.cacheStore, s.ssr?.locale);
+  if (u.kind === "page") {
+    const p = {
+      locale: s.ssr?.locale,
+      path: n.path,
+      pathname: o,
+      request: t,
+      context: O,
+      search: r.searchParams,
+      url: r
+    }, Pr = await It(
+      e,
+      n.route
+    ), G = $e(l.document) ? mr() : void 0;
+    let b;
+    try {
+      b = await zt(Pr, p, async () => {
+        try {
+          const v = await xt(l.access, p);
+          if (v)
+            return v;
+          const y = await Yt(
+            e,
+            o,
+            t,
+            void 0,
+            xe,
+            { locale: s.ssr?.locale, requestContext: O }
+          );
+          if (y.status !== "ready")
+            return await Ee(e, t, {
+              ...a,
+              nonce: G
+            });
+          if (s.locales && s.ssr?.locale && (y.match.metadata = Za(
+            y.match.metadata,
+            t,
+            o,
+            s.ssr.locale,
+            s.locales
+          )), F(t))
+            return rt(y.match.data, {
+              document: Je({
+                dir: s.ssr?.dir,
+                lang: s.ssr?.lang,
+                links: y.match.links,
+                metadata: y.match.metadata,
+                scripts: y.match.scripts,
+                title: s.ssr?.title
+              }),
+              locale: s.ssr?.locale
+            });
+          if (y.match.render.mode === "streaming" && !s.renderPage)
+            throw new Error(
+              "Streaming page routes require an adapter renderer. Pass renderNodePageResponse from @demiurgejs/core/node as createRequestHandler({ renderPage })."
+            );
+          return await (s.renderPage ?? Fr)(y.match, {
+            ...s.ssr,
+            dev: s.dev,
+            nonce: G,
+            onStreamError: (Or) => {
+              s.onError?.(Or, {
+                pathname: r.pathname,
+                site: "page"
+              });
+            },
+            signal: t.signal
+          });
+        } catch (v) {
+          return v instanceof Q ? ue() : await me(e, t, v, "page", {
+            ...a,
+            nonce: G
+          });
+        }
+      });
+    } catch (v) {
+      if (!(v instanceof Q))
+        throw v;
+      b = ue();
+    }
+    const Dr = se(l.document ?? {}, {
+      nonce: G,
+      request: t
+    });
+    for (const [v, y] of Dr)
+      b.headers.set(v, y);
+    return G && b.headers.set("cache-control", "private, no-store"), f(b), c === "HEAD" ? (await b.body?.cancel(), new Response(null, {
+      headers: b.headers,
+      status: b.status
+    })) : b;
+  }
+  const _ = {
+    locale: s.ssr?.locale,
+    path: n.path,
+    pathname: o,
+    request: t,
+    context: O,
+    search: r.searchParams,
+    url: r
+  }, Cr = await It(
+    e,
+    n.route
+  );
+  let ie;
+  try {
+    ie = await zt(Cr, _, async () => {
+      try {
+        const p = await xt(l.access, _);
+        return p || (u.kind === "not-found" && u.body === void 0 ? ni(
+          await Ee(e, t, a),
+          u.init
+        ) : await or(u, _));
+      } catch (p) {
+        return p instanceof Q ? ue() : await me(
+          e,
+          t,
+          p,
+          "route",
+          a
+        );
+      }
+    });
+  } catch (p) {
+    if (!(p instanceof Q))
+      throw p;
+    ie = ue();
+  }
+  try {
+    return await Qa(ie, xe, "mutation" in u && u.mutation === !0), f(
+      si(ie, u, t, c)
+    );
+  } catch (p) {
+    return f(
+      await me(
+        e,
+        t,
+        p,
+        "route",
+        a
+      )
+    );
+  }
+}
+function Za(e, t, r, n, o) {
+  const s = t.url, a = (c) => new URL(er(r, c, o, s), s).href, i = o.supportedLocales.map((c) => ({
+    href: a(c),
+    hrefLang: c
+  }));
+  return o.xDefault && i.push({
+    href: a(o.xDefault),
+    hrefLang: "x-default"
+  }), Wr(e, {
+    alternates: i,
+    canonical: a(n)
+  });
+}
+async function Qa(e, t, r) {
+  const n = e.headers.get(W);
+  if (e.headers.delete(W), !n || !r || e.status < 200 || e.status >= 400) return;
+  const o = Xa(n);
+  for (const s of o.keys) await t.invalidateKey(s);
+  o.tags.length > 0 && await t.invalidateTags(
+    o.tags.map((s) => ({ id: s }))
+  );
+}
+function Xa(e) {
+  let t;
+  try {
+    t = JSON.parse(decodeURIComponent(e));
+  } catch {
+    throw le();
+  }
+  if (!oe(t) || t.version !== 1 || Object.keys(t).sort().join(",") !== "keys,tags,version" || !Array.isArray(t.keys) || !t.keys.every(ei) || !Array.isArray(t.tags) || !t.tags.every((n) => typeof n == "string"))
+    throw le();
+  return { keys: t.keys, tags: t.tags };
+}
+function ei(e) {
+  return Array.isArray(e) && e.every(Ge);
+}
+function Ge(e) {
+  return e === null || typeof e == "string" || typeof e == "boolean" ? !0 : typeof e == "number" ? Number.isFinite(e) : Array.isArray(e) ? e.every(Ge) : oe(e) && Object.values(e).every(Ge);
+}
+function le() {
+  return new Error("Demiurge received invalid internal mutation invalidation metadata.");
+}
+function ti(e, t) {
+  const r = e ? qt(e) : Ke();
+  if (!t) return r;
+  const n = (s) => ({ id: `demiurge:locale:${t}:${s}` }), o = (s) => [
+    { "demiurge:locale": t },
+    ...s
+  ];
+  return {
+    get: (s) => r.get(
+      s.locale === "neutral" ? s : {
+        ...s,
+        key: o(s.key),
+        tags: s.tags?.map((a) => n(a.id))
+      }
+    ),
+    invalidateKey: (s) => r.invalidateKey(o(s)),
+    invalidateTags: (s) => r.invalidateTags(
+      s.map((a) => n(a.id))
+    )
+  };
+}
+function ri(e, t) {
+  return {
+    ...t.ssr,
+    dev: t.dev,
+    pathname: t.routePathname ?? e.pathname,
+    onError: (r, n) => {
+      t.onError?.(r, { pathname: e.pathname, site: n });
+    },
+    transformDocument: t.transformDocument
+  };
+}
+function ni(e, t) {
+  if (!t)
+    return e;
+  const r = new Headers(e.headers), n = new Headers(t.headers);
+  for (const [o, s] of n)
+    o !== "set-cookie" && r.set(o, s);
+  for (const o of n.getSetCookie())
+    r.append("set-cookie", o);
+  return new Response(e.body, {
+    headers: r,
+    status: t.status ?? e.status,
+    statusText: t.statusText ?? e.statusText
+  });
+}
+async function oi(e, t, r, n) {
+  const o = e.policies.filter(
+    (i) => C(i.fileSegments, t.fileSegments)
+  ), s = await Promise.all(
+    o.map((i) => i.load())
+  );
+  return {
+    ...ye(
+      ...s.map(
+        (i, c) => Co(i.policy, o[c]?.file)
+      ),
+      r.policy,
+      {
+        security: !n || n.kind === "page" ? void 0 : n.security
+      }
+    ),
+    access: cr([
+      ...s.map((i, c) => ({
+        policy: i.policy?.access,
+        source: o[c]?.file
+      })),
+      { policy: r.policy?.access }
+    ])
+  };
+}
+async function It(e, t) {
+  return (await Promise.all(
+    e.middlewares.filter(
+      (n) => C(n.fileSegments, t.fileSegments)
+    ).map((n) => n.load())
+  )).flatMap(
+    (n) => n.middleware ? [n.middleware] : []
+  );
+}
+async function zt(e, t, r) {
+  let n = -1;
+  async function o(s) {
+    if (s <= n)
+      throw new Error("Demiurge route middleware next() called multiple times.");
+    n = s;
+    const a = e[s];
+    return a ? await a(t, () => o(s + 1)) : await r();
+  }
+  return await o(0);
+}
+function si(e, t, r, n) {
+  const o = qn(
+    Z(e, t.cors, r),
+    t.timing
+  );
+  return n === "HEAD" ? new Response(null, {
+    headers: o.headers,
+    status: o.status,
+    statusText: o.statusText
+  }) : o;
+}
+function de(e) {
+  return e.kind === "page" ? void 0 : e.cors;
+}
+function ai(e) {
+  const t = e.toUpperCase();
+  return kr.includes(t) ? t : null;
+}
+function ii(e, t) {
+  return t === "HEAD" ? e.HEAD ?? e.GET : e[t];
+}
+function Ht(e) {
+  return new Response(null, {
+    headers: {
+      allow: ci(e).join(", ")
+    },
+    status: 405
+  });
+}
+function ci(e) {
+  const t = kr.filter((r) => e[r]);
+  return e.GET && !t.includes("HEAD") && t.push("HEAD"), t;
+}
+export {
+  En as $,
+  C as A,
+  Re as B,
+  V as C,
+  dt as D,
+  $e as E,
+  mr as F,
+  ws as G,
+  Ke as H,
+  ze as I,
+  gt as J,
+  Ki as K,
+  Kt as L,
+  tt as M,
+  Yi as N,
+  z as O,
+  Bs as P,
+  ds as Q,
+  Q as R,
+  ki as S,
+  Tn as T,
+  Qn as U,
+  Ve as V,
+  Zn as W,
+  Li as X,
+  Ti as Y,
+  ln as Z,
+  H as _,
+  x as a,
+  _t as a$,
+  Rn as a0,
+  Be as a1,
+  fe as a2,
+  so as a3,
+  Fi as a4,
+  Tt as a5,
+  j as a6,
+  I as a7,
+  Rr as a8,
+  ar as a9,
+  va as aA,
+  ls as aB,
+  N as aC,
+  ur as aD,
+  lr as aE,
+  Oi as aF,
+  vi as aG,
+  _i as aH,
+  Ci as aI,
+  Pi as aJ,
+  Br as aK,
+  To as aL,
+  ye as aM,
+  jo as aN,
+  pi as aO,
+  zi as aP,
+  Hi as aQ,
+  Mi as aR,
+  xr as aS,
+  $o as aT,
+  wi as aU,
+  Zi as aV,
+  Ni as aW,
+  Lo as aX,
+  T as aY,
+  cr as aZ,
+  Mn as a_,
+  sr as aa,
+  Jt as ab,
+  Er as ac,
+  Wr as ad,
+  Co as ae,
+  Ss as af,
+  xt as ag,
+  yi as ah,
+  Zs as ai,
+  qt as aj,
+  vr as ak,
+  Fs as al,
+  Hs as am,
+  Ei as an,
+  Zr as ao,
+  At as ap,
+  Wi as aq,
+  Gi as ar,
+  mi as as,
+  Vi as at,
+  Bi as au,
+  bi as av,
+  ua as aw,
+  fs as ax,
+  Ws as ay,
+  Qs as az,
+  $a as b,
+  Ii as b0,
+  Ui as b1,
+  ji as b2,
+  gi as b3,
+  Si as b4,
+  Di as b5,
+  or as b6,
+  Qi as b7,
+  Ji as b8,
+  xi as b9,
+  Ai as ba,
+  $i as bb,
+  pn as bc,
+  bn as bd,
+  Te as be,
+  Xi as c,
+  Ri as d,
+  $r as e,
+  Ln as f,
+  Ee as g,
+  Ue as h,
+  oe as i,
+  Pe as j,
+  qi as k,
+  er as l,
+  Mo as m,
+  se as n,
+  ht as o,
+  S as p,
+  dr as q,
+  Cn as r,
+  Se as s,
+  Xt as t,
+  ct as u,
+  lt as v,
+  J as w,
+  P as x,
+  oi as y,
+  Yt as z
+};
+//# sourceMappingURL=testing-CUwGj2ie.js.map