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

package/dist/chunks/testing-DueXbMo4.js

@@ -0,0 +1,4167 @@
+import { B as lr, A as dr, C as Ue, D as Rt, E as Tt, e as xt, F as fr, G as hr, I as mr, o as pr, a as gr } from "./index-BVk9zWbe.js";
+import { createElement as ke } from "react";
+import { renderToString as Lt } from "react-dom/server";
+import { jsxs as _, jsx as V } from "react/jsx-runtime";
+function wr(e, t) {
+  const r = we(t.canonical);
+  if (e.canonical && we(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(
+    (o) => o.kind === "link" && o.rel.toLowerCase() === "alternate" && !!o.hrefLang
+  ), a = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  for (const o of [...t.alternates, ...n]) {
+    const c = o.hrefLang.toLowerCase(), u = we(o.href, r), l = a.get(c), d = s.get(u);
+    if (l && l !== u)
+      throw new Error(`Localized metadata language ${JSON.stringify(o.hrefLang)} has conflicting URLs.`);
+    if (d && d !== c && d !== "x-default" && c !== "x-default")
+      throw new Error(`Localized metadata URL ${JSON.stringify(o.href)} has conflicting languages.`);
+    a.set(c, u), s.set(u, c);
+  }
+  const i = e.custom.filter(
+    (o) => !(o.kind === "link" && o.rel.toLowerCase() === "alternate" && o.hrefLang)
+  );
+  return {
+    ...e,
+    canonical: r,
+    custom: [
+      ...i,
+      ...[...a].map(([o, c]) => yr({ href: c, hrefLang: o, rel: "alternate" }))
+    ]
+  };
+}
+function we(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 mo(e) {
+  return e;
+}
+function po(e) {
+  return {
+    ...e,
+    kind: "meta"
+  };
+}
+function yr(e) {
+  return {
+    ...e,
+    kind: "link"
+  };
+}
+function go(e) {
+  return {
+    kind: "structured-data",
+    value: e
+  };
+}
+function E(...e) {
+  const t = {
+    custom: [],
+    structuredData: []
+  };
+  for (const s of e)
+    s && Sr(t, s);
+  const r = Er(t), n = t.description, a = br(t.openGraph, r, n);
+  return {
+    canonical: t.canonical,
+    charset: "utf-8",
+    custom: t.custom,
+    description: n,
+    openGraph: a,
+    robots: t.robots,
+    structuredData: t.structuredData,
+    title: r,
+    viewport: "width=device-width, initial-scale=1"
+  };
+}
+function Sr(e, t) {
+  vr(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 vr(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 Er(e) {
+  return e.title === void 0 ? e.titleDefault : e.titleFormat ? e.titleFormat(e.title) : e.title;
+}
+function br(e, t, r) {
+  if (!(!e && !t && !r))
+    return {
+      ...t ? { title: t } : {},
+      ...r ? { description: r } : {},
+      ...e ?? {}
+    };
+}
+const et = ["build", "private", "public"], Rr = {
+  app: "demiurge-memory",
+  environment: "local",
+  schemaVersion: 1
+}, Tr = 1e4, xr = 3e4;
+function wo(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 O extends Error {
+  constructor(t) {
+    super(t ?? "Not found"), this.name = "CacheNotFoundError";
+  }
+}
+function yo(e) {
+  throw new O(e);
+}
+function So(e) {
+  return e instanceof O;
+}
+function vo(e) {
+  return { id: e };
+}
+function Eo(e) {
+  return e;
+}
+function kt(e) {
+  const t = e.now ?? Date.now, r = Cr(e.refreshLeaseTtl), n = At(e.namespace), a = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  return {
+    async get(i) {
+      const o = i.scope ?? "request";
+      if (o === "none")
+        return await i.fn();
+      const c = rt(i.key);
+      if (o === "request")
+        return await Ar(a, c, i, t);
+      const u = nt(n, o, c), l = (i.tags ?? []).map(
+        (p) => at(n, o, Ae(p))
+      ), d = await e.store.get(u);
+      if (d && (d.expiresAt === null || d.expiresAt > t())) {
+        if (d.negative)
+          throw new O(
+            typeof d.value == "string" ? d.value : void 0
+          );
+        return d.value;
+      }
+      if (d && Pr(d, t())) {
+        const p = $r(e.store), P = globalThis.crypto.randomUUID();
+        if (await p.acquireRefreshLease(
+          u,
+          P,
+          t() + r
+        )) {
+          const Q = Dr({
+            key: u,
+            now: t,
+            onBackgroundError: e.onBackgroundError,
+            refreshStore: p,
+            request: i,
+            tags: l,
+            token: P
+          });
+          e.waitUntil?.(Q);
+        }
+        return d.value;
+      }
+      d && await e.store.delete(u);
+      const h = s.get(u);
+      if (h)
+        return await h.promise;
+      const f = { invalidated: !1 }, R = Promise.resolve().then(i.fn).then(
+        async (p) => (f.invalidated || await e.store.set(u, {
+          expiresAt: je(t(), i.ttl),
+          staleUntil: He(
+            t(),
+            i.ttl,
+            i.staleWhileRevalidate
+          ),
+          tags: l,
+          value: p
+        }), p),
+        async (p) => {
+          throw !f.invalidated && p instanceof O && await e.store.set(u, Ct(t(), i, l, p)), p;
+        }
+      ), w = {
+        promise: R,
+        state: f,
+        tags: l
+      };
+      s.set(u, w);
+      try {
+        return await R;
+      } finally {
+        s.get(u) === w && s.delete(u);
+      }
+    },
+    async invalidateKey(i) {
+      const o = rt(i), c = a.delete(o);
+      let u = !1;
+      const l = await Promise.all(
+        et.map((d) => {
+          const h = nt(n, d, o), f = s.get(h);
+          return f && (f.state.invalidated = !0, u = !0), e.store.delete(h);
+        })
+      );
+      return c || u || l.some(Boolean);
+    },
+    async invalidateTags(i) {
+      const o = i.map(Ae), c = Or(
+        a,
+        new Set(o)
+      ), u = new Set(
+        et.flatMap(
+          (h) => o.map((f) => at(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 Ie(e = {}) {
+  const t = e.now ?? Date.now;
+  return kt({
+    namespace: Rr,
+    now: t,
+    onBackgroundError: e.onBackgroundError,
+    refreshLeaseTtl: e.refreshLeaseTtl,
+    store: Lr({
+      maximumEntries: e.maximumEntries,
+      now: t
+    }),
+    waitUntil: e.waitUntil
+  });
+}
+function Lr(e = {}) {
+  const t = e.entries ?? /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), n = e.maximumEntries ?? Tr, a = e.now ?? Date.now;
+  if (!Number.isSafeInteger(n) || n <= 0)
+    throw new Error(
+      "Demiurge memory cache maximumEntries must be a positive integer."
+    );
+  ye(t, r, a()), kr(t, n);
+  let s = Se(t);
+  return {
+    acquireRefreshLease(i, o, c) {
+      const u = a(), l = r.get(i);
+      return l && l.expiresAt > u ? !1 : (r.set(i, { expiresAt: c, token: o }), !0);
+    },
+    delete(i) {
+      return r.delete(i), t.delete(i);
+    },
+    get(i) {
+      return a() >= s && (ye(t, r, a()), s = Se(t)), t.get(i);
+    },
+    invalidateTags(i) {
+      const o = new Set(i);
+      let c = 0;
+      for (const [u, l] of t)
+        l.tags.some((d) => o.has(d)) && (t.delete(u), r.delete(u), c += 1);
+      return c;
+    },
+    publishRefresh(i, o, c) {
+      const u = r.get(i);
+      return !u || u.token !== o || u.expiresAt <= a() ? !1 : (tt(
+        t,
+        r,
+        n,
+        i,
+        c
+      ), r.delete(i), c.staleUntil !== null && (s = Math.min(s, c.staleUntil)), !0);
+    },
+    releaseRefreshLease(i, o) {
+      r.get(i)?.token === o && r.delete(i);
+    },
+    set(i, o) {
+      const c = a();
+      c >= s && (ye(t, r, c), s = Se(t)), r.delete(i), tt(
+        t,
+        r,
+        n,
+        i,
+        o
+      ), o.staleUntil !== null && (s = Math.min(s, o.staleUntil));
+    }
+  };
+}
+function ye(e, t, r) {
+  for (const [n, a] of e)
+    a.staleUntil !== null && a.staleUntil <= r && (e.delete(n), t.delete(n));
+}
+function tt(e, t, r, n, a) {
+  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, a);
+}
+function kr(e, t) {
+  for (; e.size > t; ) {
+    const r = e.keys().next().value;
+    if (r === void 0)
+      return;
+    e.delete(r);
+  }
+}
+function Se(e) {
+  let t = Number.POSITIVE_INFINITY;
+  for (const r of e.values())
+    r.staleUntil !== null && (t = Math.min(t, r.staleUntil));
+  return t;
+}
+function At(e) {
+  const t = ve("app", e.app), r = ve(
+    "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 = ve(
+    "schemaVersion",
+    String(e.schemaVersion)
+  );
+  return `${t}:${r}:${n}`;
+}
+function bo(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 N(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 rt(e) {
+  return Ce(e, /* @__PURE__ */ new Set());
+}
+function Ae(e) {
+  return e.id;
+}
+async function Ar(e, t, r, n) {
+  const a = e.get(t);
+  if (a && a.expiresAt > n())
+    return await a.value;
+  const s = Promise.resolve().then(r.fn), i = {
+    expiresAt: n() + N(r.ttl),
+    tags: (r.tags ?? []).map(Ae),
+    value: s
+  };
+  e.set(t, i);
+  try {
+    return await s;
+  } catch (o) {
+    throw e.get(t) === i && (o instanceof O ? i.expiresAt = n() + N(r.notFoundTtl ?? r.ttl) : e.delete(t)), o;
+  }
+}
+function nt(e, t, r) {
+  return `${e}:${t}:key:${r}`;
+}
+function at(e, t, r) {
+  return `${e}:${t}:tag:${r}`;
+}
+function je(e, t) {
+  const r = N(t);
+  return Number.isFinite(r) ? e + r : null;
+}
+function Ct(e, t, r, n) {
+  const a = t.notFoundTtl ?? t.ttl;
+  return {
+    expiresAt: je(e, a),
+    negative: !0,
+    // Negative entries do not participate in stale-while-revalidate: they
+    // expire outright and recompute on the next request.
+    staleUntil: He(e, a, void 0),
+    tags: r,
+    value: n.message
+  };
+}
+function He(e, t, r) {
+  const n = N(t);
+  if (!Number.isFinite(n)) {
+    if (r !== void 0)
+      throw new Error(
+        "Demiurge staleWhileRevalidate requires a finite cache ttl."
+      );
+    return null;
+  }
+  return e + n + N(r ?? 0);
+}
+function Cr(e) {
+  const t = N(e ?? xr);
+  if (!Number.isFinite(t) || t <= 0)
+    throw new Error(
+      "Demiurge cache refreshLeaseTtl must be a positive finite duration."
+    );
+  return t;
+}
+function Pr(e, t) {
+  return e.expiresAt !== null && e.expiresAt <= t && (e.staleUntil === null || e.staleUntil > t);
+}
+function $r(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 Dr(e) {
+  try {
+    const t = await e.request.fn(), r = e.now();
+    await e.refreshStore.publishRefresh(e.key, e.token, {
+      expiresAt: je(r, e.request.ttl),
+      staleUntil: He(
+        r,
+        e.request.ttl,
+        e.request.staleWhileRevalidate
+      ),
+      tags: e.tags,
+      value: t
+    });
+  } catch (t) {
+    if (t instanceof O) {
+      await e.refreshStore.publishRefresh(
+        e.key,
+        e.token,
+        Ct(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 ve(e, t) {
+  const r = [...t].some((n) => {
+    const a = n.charCodeAt(0);
+    return a <= 31 || a === 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 Or(e, t) {
+  let r = 0;
+  for (const [n, a] of e)
+    a.tags.some((s) => t.has(s)) && (e.delete(n), r += 1);
+  return r;
+}
+function Ce(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 i = Reflect.ownKeys(e), o = [
+      ...Array.from({ length: e.length }, (u, l) => String(l)),
+      "length"
+    ];
+    if (i.length !== o.length || i.some((u, l) => u !== o[l]) || o.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) => Ce(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((i) => typeof i == "symbol") || n.some((i) => {
+    const o = Object.getOwnPropertyDescriptor(e, i);
+    return !o?.enumerable || !("value" in o);
+  }))
+    throw new Error(
+      "Demiurge cache key objects require enumerable string data properties."
+    );
+  const a = e, s = `{${Object.keys(a).sort().map(
+    (i) => `${JSON.stringify(i)}:${Ce(a[i], t)}`
+  ).join(",")}}`;
+  return t.delete(e), s;
+}
+function Pt(e) {
+  const t = {
+    fallbacks: {
+      error: [],
+      loading: [],
+      notFound: []
+    },
+    routes: [],
+    layouts: [],
+    middlewares: [],
+    policies: []
+  };
+  for (const [r, n] of Object.entries(e)) {
+    const a = r.replace(/^\/src\/routes\//, "").replace(/^\.\/routes\//, "").replace(/\.tsx?$/, "").split("/"), s = a.at(-1);
+    if (s === "@layout") {
+      t.layouts.push({
+        file: r,
+        fileSegments: a.slice(0, -1),
+        segments: T(a.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@policy") {
+      t.policies.push({
+        file: r,
+        fileSegments: a.slice(0, -1),
+        segments: T(a.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@middleware") {
+      t.middlewares.push({
+        file: r,
+        fileSegments: a.slice(0, -1),
+        segments: T(a.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@loading") {
+      t.fallbacks.loading.push({
+        file: r,
+        fileSegments: a.slice(0, -1),
+        segments: T(a.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@error") {
+      t.fallbacks.error.push({
+        file: r,
+        fileSegments: a.slice(0, -1),
+        segments: T(a.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (s === "@not-found") {
+      t.fallbacks.notFound.push({
+        file: r,
+        fileSegments: a.slice(0, -1),
+        segments: T(a.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    t.routes.push({
+      file: r,
+      fileSegments: a,
+      segments: T(a),
+      score: Yr(a),
+      load: n
+    });
+  }
+  return Nr(t.routes), t.routes.sort(Ir), 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 Nr(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const r of e) {
+    const n = r.segments.findIndex(
+      (i) => i.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 a = r.segments.map(Mr).join("/"), s = t.get(a);
+    if (s)
+      throw new Error(
+        `Ambiguous routes "${s.file}" and "${r.file}" have the same runtime shape and both match "${Ur(r.segments)}".`
+      );
+    t.set(a, r);
+  }
+}
+function Mr(e) {
+  return e.startsWith("*") ? "*" : e.startsWith(":") ? ":" : `=${e}`;
+}
+function Ur(e) {
+  return e.length === 0 ? "/" : `/${e.map((t) => t.startsWith(":") || t.startsWith("*") ? "example" : t).join("/")}`;
+}
+function Ir(e, t) {
+  const r = Math.max(e.segments.length, t.segments.length);
+  for (let n = 0; n < r; n += 1) {
+    const a = st(t.segments[n]) - st(e.segments[n]);
+    if (a !== 0)
+      return a;
+  }
+  return e.file.localeCompare(t.file);
+}
+function st(e) {
+  return e === void 0 ? 4 : e.startsWith("*") ? 1 : e.startsWith(":") ? 2 : 3;
+}
+async function $t(e, t, r = new Request(`http://demiurge.local${t}`), n, a = Ie(), s = {}) {
+  const i = s.documentContributions ?? !0, o = j(e.routes, t);
+  if (!o)
+    return {
+      ...await Pe(e, t, {
+        documentContributions: i,
+        locale: s.locale
+      }),
+      status: "not-found"
+    };
+  const c = e.layouts.filter(
+    (f) => A(f.fileSegments, o.route.fileSegments)
+  ), u = await o.route.load();
+  if (!u.GET || u.GET.kind !== "page")
+    return {
+      ...await Pe(e, t, {
+        fallback: Fe(
+          e.fallbacks.notFound,
+          o.route
+        ),
+        documentContributions: i,
+        layouts: c,
+        locale: s.locale
+      }),
+      status: "not-found"
+    };
+  const l = u.GET.layout === !1 ? [] : await Promise.all(c.map((f) => f.load())), d = new URL(r.url), h = {
+    cache: a,
+    context: s.requestContext ?? {},
+    locale: s.locale,
+    path: o.path,
+    pathname: t,
+    request: r,
+    search: d.searchParams,
+    url: d
+  };
+  return {
+    status: "ready",
+    match: {
+      data: u.GET.data && !n?.hasData ? await u.GET.data(h) : n?.data,
+      error: await Dt(e, o.route),
+      links: i ? await dr(
+        [
+          ...l.map((f) => f.links),
+          u.links
+        ],
+        h
+      ) : [],
+      page: u.GET.view,
+      layouts: l.map(
+        (f) => f.default
+      ),
+      locale: s.locale,
+      metadata: i ? E(...await Promise.all([
+        ...l.map((f) => $(f, h)),
+        $(u, h)
+      ])) : E(),
+      path: o.path,
+      pathname: t,
+      render: u.GET.render,
+      scripts: i ? await lr(
+        [
+          ...l.map((f) => f.scripts),
+          u.scripts
+        ],
+        h
+      ) : []
+    }
+  };
+}
+async function Ro(e, t = {}) {
+  const r = Ie(), n = [];
+  for (const a of e.routes) {
+    const s = await a.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 "${a.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 i = Gr(a.segments);
+    if (Vr(a.segments).length === 0) {
+      n.push({
+        file: a.file,
+        path: {},
+        pattern: i,
+        pathname: i
+      });
+      continue;
+    }
+    if (!s.paths)
+      throw new Error(
+        `Dynamic static route "${a.file}" must export paths for "${i}".`
+      );
+    const c = await s.paths({
+      cache: r,
+      locale: t.locale
+    });
+    for (const u of c) {
+      const l = Jr(a, i, u);
+      n.push({
+        file: a.file,
+        path: l,
+        pattern: i,
+        pathname: Kr(a.segments, l)
+      });
+    }
+  }
+  return n;
+}
+async function To(e, t) {
+  const r = j(e.routes, t);
+  if (r)
+    return await Wr(
+      Fe(e.fallbacks.loading, r.route)
+    );
+}
+async function jr(e, t) {
+  let r;
+  try {
+    r = j(e.routes, t);
+  } catch (n) {
+    if (!(n instanceof Be)) throw n;
+    return await We(
+      e.fallbacks.error.find(
+        (a) => a.fileSegments.length === 0
+      )
+    );
+  }
+  return r ? await Dt(e, r.route) : await Hr(e, t);
+}
+async function Dt(e, t) {
+  return await We(
+    Fe(e.fallbacks.error, t)
+  );
+}
+async function Hr(e, t) {
+  return await We(
+    Ot(e.fallbacks.error, t)
+  );
+}
+async function Pe(e, t, r = {}) {
+  const a = await (r.fallback ?? Ot(e.fallbacks.notFound, t))?.load(), s = a?.default, i = r.documentContributions ?? !0, o = { locale: r.locale, path: {}, pathname: t };
+  if (a?.layout === !1)
+    return {
+      layouts: [],
+      locale: r.locale,
+      metadata: i ? E(await $(a, o)) : E(),
+      notFound: s,
+      pathname: t
+    };
+  const c = r.layouts ?? Fr(e, t);
+  try {
+    const u = await Promise.all(
+      c.map((l) => l.load())
+    );
+    return {
+      layouts: u.map(
+        (l) => l.default
+      ),
+      locale: r.locale,
+      metadata: i ? E(...await Promise.all([
+        ...u.map((l) => $(l, o)),
+        $(a, o)
+      ])) : E(),
+      notFound: s,
+      pathname: t
+    };
+  } catch (u) {
+    return r.onLayoutError?.(u), {
+      layouts: [],
+      locale: r.locale,
+      metadata: i ? E(await $(a, o)) : E(),
+      notFound: s,
+      pathname: t
+    };
+  }
+}
+async function $(e, t) {
+  return typeof e?.metadata == "function" ? await e.metadata(t) : e?.metadata;
+}
+function Fr(e, t) {
+  const r = me(t);
+  return e.layouts.filter(
+    (n) => !n.fileSegments.some(he) && ze(n.segments, r)
+  );
+}
+function zr(e, t) {
+  const r = me(t);
+  return e.policies.filter(
+    (n) => !n.fileSegments.some(he) && ze(n.segments, r)
+  );
+}
+function Fe(e, t) {
+  for (let r = e.length - 1; r >= 0; r -= 1) {
+    const n = e[r];
+    if (A(n.fileSegments, t.fileSegments))
+      return n;
+  }
+}
+function Ot(e, t) {
+  const r = me(t);
+  for (let n = e.length - 1; n >= 0; n -= 1) {
+    const a = e[n];
+    if (!a.fileSegments.some(he) && ze(a.segments, r))
+      return a;
+  }
+}
+function ze(e, t) {
+  return e.every((r, n) => r.startsWith("*") ? t.length > n : r.startsWith(":") ? !!t[n] : t[n] === r);
+}
+async function Wr(e) {
+  return e ? (await e.load()).default : void 0;
+}
+async function We(e) {
+  return e ? (await e.load()).default : void 0;
+}
+function j(e, t) {
+  const r = me(t);
+  for (const n of e) {
+    const a = Br(n.segments, r);
+    if (a)
+      return { route: n, path: a };
+  }
+  return null;
+}
+const xo = $t, Lo = j;
+function Br(e, t) {
+  const r = {};
+  for (let n = 0; n < e.length; n += 1) {
+    const a = e[n], s = t[n];
+    if (a?.startsWith("*"))
+      return r[a.slice(1)] = t.slice(n).join("/"), r;
+    if (!s)
+      return null;
+    if (a.startsWith(":")) {
+      r[a.slice(1)] = s;
+      continue;
+    }
+    if (a !== s)
+      return null;
+  }
+  return e.length === t.length ? r : null;
+}
+function ko(e, t) {
+  return e.every(
+    (r, n) => t[n] === r
+  );
+}
+function A(e, t) {
+  return e.every(
+    (r, n) => t[n] === r
+  );
+}
+function T(e) {
+  return e.flatMap((t) => he(t) ? [] : t === "index" ? [] : t.startsWith("[...") && t.endsWith("]") ? [`*${t.slice(4, -1)}`] : t.startsWith("[") && t.endsWith("]") ? [`:${t.slice(1, -1)}`] : [t]);
+}
+function he(e) {
+  return e.startsWith("(") && e.endsWith(")");
+}
+function Gr(e) {
+  return e.length === 0 ? "/" : `/${e.map(_r).join("/")}`;
+}
+function _r(e) {
+  return e.startsWith("*") ? `[...${e.slice(1)}]` : e.startsWith(":") ? `[${e.slice(1)}]` : e;
+}
+function Vr(e) {
+  return e.flatMap((t) => t.startsWith(":") || t.startsWith("*") ? [t.slice(1)] : []);
+}
+function Jr(e, t, r) {
+  const n = {};
+  for (const a of e.segments) {
+    if (!a.startsWith(":") && !a.startsWith("*"))
+      continue;
+    const s = a.slice(1), i = r[s];
+    if (i === void 0)
+      throw new Error(
+        `Static paths for "${e.file}" must include "${s}" for "${t}".`
+      );
+    if (!qr(i))
+      throw new Error(
+        `Static path "${s}" for "${e.file}" must be a string, number, or boolean.`
+      );
+    n[s] = String(i);
+  }
+  return n;
+}
+function qr(e) {
+  return typeof e == "string" || typeof e == "number" || typeof e == "boolean";
+}
+function Kr(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 Yr(e) {
+  return T(e).reduce((t, r) => r.startsWith("*") ? t : r.startsWith(":") ? t + 1 : t + 2, 0);
+}
+function me(e) {
+  return e.replace(/^\/|\/$/g, "").split("/").filter(Boolean).map((t) => {
+    try {
+      return decodeURIComponent(t);
+    } catch (r) {
+      throw new Be(e, { cause: r });
+    }
+  });
+}
+class Be extends URIError {
+  pathname;
+  constructor(t, r) {
+    super(
+      `Malformed percent encoding in URL pathname ${JSON.stringify(t)}.`,
+      r
+    ), this.name = "MalformedPathnameError", this.pathname = t;
+  }
+}
+const M = "x-demiurge-navigation", Zr = "data", Qr = "data", ae = "error", $e = "not-found";
+function U(e) {
+  return e.headers.get(M) === Zr;
+}
+function Ge(e, t = {}) {
+  const r = new Headers(t.headers);
+  return r.set("cache-control", "no-store"), r.set(
+    M,
+    t.kind ?? Qr
+  ), r.append("vary", M), Response.json(
+    {
+      data: e,
+      document: t.document,
+      error: t.error,
+      hasData: !0,
+      locale: t.locale
+    },
+    {
+      headers: r,
+      status: t.status
+    }
+  );
+}
+function ee(e, t) {
+  return e.headers.set("cache-control", "no-store"), e.headers.set(M, t), e.headers.append("vary", M), e;
+}
+function Nt(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function Ao(e) {
+  return typeof e == "object" && e !== null;
+}
+function Xr(e) {
+  if (typeof e == "string")
+    return e;
+  const t = en(nn(
+    e.to,
+    "path" in e ? e.path : void 0
+  )), r = e.search === void 0 ? t.search : tn(e.search), n = e.hash === void 0 ? t.hash : e.hash ? e.hash.startsWith("#") ? e.hash : `#${e.hash}` : "";
+  return `${t.pathname}${r}${n}`;
+}
+function en(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 tn(e) {
+  if (!e)
+    return "";
+  if (typeof e == "string")
+    return e.startsWith("?") ? e : `?${e}`;
+  const r = (e instanceof URLSearchParams ? e : rn(e)).toString();
+  return r ? `?${r}` : "";
+}
+function rn(e) {
+  const t = new URLSearchParams();
+  for (const [r, n] of Object.entries(e)) {
+    const a = Array.isArray(n) ? n : [n];
+    for (const s of a)
+      s != null && t.append(r, String(s));
+  }
+  return t;
+}
+function nn(e, t) {
+  return t ? e.replace(
+    /\[(\.\.\.)?([a-zA-Z_$][a-zA-Z0-9_$]*)\]/g,
+    (r, n, a) => {
+      const s = t[a];
+      if (s === void 0)
+        throw new Error(`Missing path value for "${a}" in route "${e}".`);
+      return n ? String(s).split("/").filter(Boolean).map((i) => encodeURIComponent(i)).join("/") : encodeURIComponent(String(s));
+    }
+  ) : e;
+}
+function an(e) {
+  It(e);
+  const t = new Map(
+    e.supportedLocales.map((o) => [o, x(o)])
+  ), r = (o) => {
+    const c = e.supportedLocales.find((u) => u === o);
+    if (!c) throw new Error(`The locale target "${o}" must be supported.`);
+    return t.get(c) ?? c;
+  }, a = e.path && Object.fromEntries(
+    e.supportedLocales.map((o) => [
+      x(o),
+      e.path?.labels[o].toLowerCase()
+    ])
+  ), i = e.domains && Object.fromEntries(
+    e.supportedLocales.flatMap((o) => {
+      const c = e.domains?.[o];
+      return c ? [[x(o), jt(c)]] : [];
+    })
+  );
+  return {
+    ...e,
+    aliases: e.aliases && Object.fromEntries(
+      Object.entries(e.aliases).map(([o, c]) => [o.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(([o, c]) => [
+        x(o),
+        c
+      ])
+    ),
+    domains: i,
+    path: e.path && {
+      ...e.path,
+      labels: a,
+      reserved: e.path.reserved?.map((o) => o.toLowerCase())
+    },
+    supportedLocales: e.supportedLocales.map(x),
+    xDefault: e.xDefault && r(e.xDefault)
+  };
+}
+function Ee(e, t) {
+  const r = t?.directions?.[e];
+  if (r) return r;
+  const n = new Intl.Locale(e), a = n.textInfo?.direction;
+  return a || (ln.has(n.maximize().script ?? "") ? "rtl" : "ltr");
+}
+function sn(e, t) {
+  It(t);
+  const r = new URL(e.url), [n = "", ...a] = r.pathname.slice(1).split("/"), s = _e(n, t), i = t.path?.reserved?.some(
+    (p) => p.toLowerCase() === n.toLowerCase()
+  ) ?? !1, o = on(r.hostname, t), c = cn(e, t), u = un(e.headers.get("accept-language"), t), l = s ?? o ?? c ?? u ?? t.defaultLocale, d = s ? "path" : o ? "domain" : c ? "cookie" : u ? "accept-language" : "default", h = s || i ? `/${a.join("/")}`.replace(/\/$/, "") || "/" : r.pathname, f = Ut(r, h, l, t), R = {
+    locale: l,
+    pathname: h,
+    redirect: !i && f.href !== r.href ? f : void 0,
+    source: d,
+    unsupported: i
+  }, w = t.resolver?.({
+    configuration: t,
+    defaultResolution: R,
+    request: e
+  }) ?? R;
+  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 Mt(e, t, r, n = "http://demiurge.local") {
+  const a = new URL(e, n), i = _e(a.pathname.slice(1).split("/")[0] ?? "", r) ? `/${a.pathname.slice(1).split("/").slice(1).join("/")}`.replace(/\/$/, "") || "/" : a.pathname, o = Ut(a, i, t, r), c = new URL(n);
+  return o.origin === c.origin ? `${o.pathname}${o.search}${o.hash}` : o.href;
+}
+function Co(e, t) {
+  if (!t) return e;
+  const r = e.slice(1).split("/");
+  return _e(r[0] ?? "", t) ? `/${r.slice(1).join("/")}`.replace(/\/$/, "") || "/" : e;
+}
+function Ut(e, t, r, n) {
+  const a = new URL(e), s = n.path?.labels[r], i = s && (r !== n.defaultLocale || n.path?.prefixDefault);
+  a.pathname = i ? `/${s}${t === "/" ? "" : t}` : t;
+  const o = n.domains?.[r];
+  return o && (a.hostname = o), a;
+}
+function _e(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 on(e, t) {
+  return Object.entries(t.domains ?? {}).find(([, r]) => String(r).toLowerCase() === e.toLowerCase())?.[0];
+}
+function cn(e, t) {
+  const r = t.cookie?.name;
+  if (!r) return;
+  const n = e.headers.get("cookie")?.split(";").map((a) => a.trim()).find((a) => a.startsWith(`${r}=`))?.slice(r.length + 1);
+  return t.supportedLocales.find((a) => a === n);
+}
+function un(e, t) {
+  if (!e) return;
+  const r = e.split(",").map((n, a) => {
+    const [s = "", ...i] = n.trim().split(";"), o = i.find((u) => u.trim().toLowerCase().startsWith("q=")), c = o ? Number(o.trim().slice(2)) : 1;
+    return { order: a, q: c, tag: s.trim() };
+  }).filter(({ q: n, tag: a }) => a !== "" && Number.isFinite(n) && n > 0 && n <= 1).sort((n, a) => a.q - n.q || n.order - a.order);
+  for (const n of r) {
+    if (n.tag === "*") return t.defaultLocale;
+    let a = n.tag.toLowerCase();
+    for (; a; ) {
+      const s = t.supportedLocales.find((o) => o.toLowerCase() === a) ?? t.supportedLocales.find((o) => o.toLowerCase().startsWith(`${a}-`));
+      if (s) return s;
+      const i = a.lastIndexOf("-");
+      if (i < 0) break;
+      a = a.slice(0, i);
+    }
+  }
+}
+function It(e) {
+  if (e.supportedLocales.length === 0) throw new Error("Locale configuration requires at least one supported locale.");
+  const t = e.supportedLocales.map(x);
+  if (new Set(t).size !== t.length) throw new Error("Locale configuration contains duplicate canonical locales.");
+  if (!t.includes(x(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 = (o, c) => {
+    if (!r.has(x(o))) throw new Error(`The ${c} target "${o}" must be supported.`);
+  }, a = /* @__PURE__ */ new Map(), s = (o, c) => {
+    const u = o.toLowerCase(), l = a.get(u);
+    if (l) throw new Error(`Locale ${c} "${o}" conflicts with ${l}.`);
+    a.set(u, `${c} "${o}"`);
+  };
+  for (const [o, c] of Object.entries(e.path?.labels ?? {})) {
+    if (n(o, "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 [o, c] of Object.entries(e.aliases ?? {})) {
+    if (n(String(c), "alias"), !/^[a-z0-9][a-z0-9-]*$/i.test(o)) throw new Error(`Locale alias "${o}" is invalid.`);
+    s(o, "alias");
+  }
+  for (const o of e.path?.reserved ?? []) s(o, "reserved label");
+  const i = /* @__PURE__ */ new Set();
+  for (const [o, c] of Object.entries(e.domains ?? {})) {
+    n(o, "domain");
+    const u = jt(String(c));
+    if (i.has(u)) throw new Error(`Locale domain "${c}" is duplicated.`);
+    i.add(u);
+  }
+  for (const [o, c] of Object.entries(e.directions ?? {}))
+    if (n(o, "direction"), c !== "ltr" && c !== "rtl")
+      throw new Error(`Locale direction for "${o}" 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 x(e) {
+  const [t] = Intl.getCanonicalLocales(e);
+  if (!t) throw new Error(`Locale "${e}" is invalid.`);
+  return t;
+}
+const ln = /* @__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 jt(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 Po(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "json",
+    security: t?.security,
+    timing: b(t?.timing),
+    value: e,
+    init: L(t)
+  };
+}
+function $o(e, t) {
+  return {
+    cors: t?.cors,
+    init: L(t),
+    kind: "jsonl",
+    lines: e,
+    security: t?.security,
+    timing: b(t?.timing)
+  };
+}
+function Do(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "text",
+    security: t?.security,
+    timing: b(t?.timing),
+    value: e,
+    init: L(t)
+  };
+}
+function Oo(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "html",
+    security: t?.security,
+    timing: b(t?.timing),
+    value: e,
+    init: L(t)
+  };
+}
+function No(e, t) {
+  const r = typeof t == "number" ? void 0 : t;
+  return {
+    cors: r?.cors,
+    kind: "redirect",
+    security: r?.security,
+    timing: b(r?.timing),
+    to: vn(e) ? Xr(e) : e,
+    init: typeof t == "number" ? { status: t } : L(t)
+  };
+}
+function Mo(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "not-found",
+    security: t?.security,
+    timing: b(t?.timing),
+    body: e,
+    init: L(t)
+  };
+}
+function dn(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "response",
+    response: e,
+    security: t?.security,
+    timing: b(t?.timing)
+  };
+}
+function Uo(e, t) {
+  return {
+    body: e,
+    cors: t?.cors,
+    init: L(t),
+    kind: "stream",
+    security: t?.security,
+    timing: b(t?.timing)
+  };
+}
+function Io(e, t) {
+  return {
+    cors: t?.cors,
+    events: e,
+    init: L(t),
+    kind: "sse",
+    security: t?.security,
+    timing: b(t?.timing)
+  };
+}
+function jo(...e) {
+  return e;
+}
+async function Ht(e, t) {
+  switch (e.kind) {
+    case "json":
+      return new Response(JSON.stringify(await S(e.value, t)), {
+        ...e.init,
+        headers: be(
+          e.init?.headers,
+          "content-type",
+          "application/json; charset=utf-8"
+        )
+      });
+    case "jsonl":
+      return new Response(
+        hn(await S(e.lines, t)),
+        {
+          ...e.init,
+          headers: se(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 S(e.value, t), {
+        ...e.init,
+        headers: be(
+          e.init?.headers,
+          "content-type",
+          "text/plain; charset=utf-8"
+        )
+      });
+    case "html":
+      return new Response(await S(e.value, t), {
+        ...e.init,
+        headers: be(
+          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 S(e.to, t))), new Response(null, {
+        ...e.init,
+        headers: r,
+        status: e.init?.status ?? 302
+      });
+    }
+    case "not-found":
+      return new Response(
+        e.body ? await S(e.body, t) : null,
+        {
+          ...e.init,
+          status: e.init?.status ?? 404
+        }
+      );
+    case "response":
+      return await S(e.response, t);
+    case "stream":
+      return new Response(
+        mn(await S(e.body, t)),
+        {
+          ...e.init,
+          headers: se(e.init?.headers, {
+            "content-type": "application/octet-stream",
+            "x-accel-buffering": "no"
+          })
+        }
+      );
+    case "sse":
+      return new Response(
+        fn(await S(e.events, t)),
+        {
+          ...e.init,
+          headers: se(e.init?.headers, {
+            "cache-control": "no-cache",
+            "content-type": "text/event-stream; charset=utf-8",
+            "x-accel-buffering": "no"
+          })
+        }
+      );
+  }
+}
+async function S(e, t) {
+  return typeof e != "function" ? e : await e(
+    t
+  );
+}
+function be(e, t, r) {
+  return se(e, { [t]: r });
+}
+function se(e, t) {
+  const r = new Headers(e);
+  for (const [n, a] of Object.entries(t))
+    r.has(n) || r.set(n, a);
+  return r;
+}
+function fn(e) {
+  const t = new TextEncoder(), r = Ve(e);
+  return new ReadableStream({
+    async pull(n) {
+      const a = await r.next();
+      if (a.done) {
+        n.close();
+        return;
+      }
+      n.enqueue(t.encode(wn(a.value)));
+    },
+    async cancel() {
+      await r.return?.();
+    }
+  });
+}
+function hn(e) {
+  const t = new TextEncoder(), r = Ve(e);
+  return new ReadableStream({
+    async pull(n) {
+      const a = await r.next();
+      if (a.done) {
+        n.close();
+        return;
+      }
+      n.enqueue(t.encode(`${JSON.stringify(a.value)}
+`));
+    },
+    async cancel() {
+      await r.return?.();
+    }
+  });
+}
+function mn(e) {
+  const t = new TextEncoder(), r = Ve(e);
+  return new ReadableStream({
+    async pull(n) {
+      const a = await r.next();
+      if (a.done) {
+        n.close();
+        return;
+      }
+      n.enqueue(pn(a.value, t));
+    },
+    async cancel() {
+      await r.return?.();
+    }
+  });
+}
+function pn(e, t) {
+  return typeof e == "string" ? t.encode(e) : e;
+}
+function Ve(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]() : gn(e[Symbol.iterator]());
+}
+function gn(e) {
+  return {
+    async next() {
+      return e.next();
+    },
+    async return() {
+      return e.return?.(), { done: !0, value: void 0 };
+    }
+  };
+}
+function wn(e) {
+  if (typeof e == "string")
+    return yn(e);
+  const t = [];
+  if (e.comment !== void 0 && t.push(...z("", e.comment)), e.id !== void 0 && t.push(...z("id", e.id)), e.event !== void 0 && t.push(...z("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(...z("data", Sn(e.data))), `${t.join(`
+`)}
+
+`;
+}
+function yn(e) {
+  return `${z("data", e).join(`
+`)}
+
+`;
+}
+function z(e, t) {
+  return t.split(/\r\n|\r|\n/).map(
+    (r) => e ? `${e}: ${r}` : `: ${r}`
+  );
+}
+function Sn(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 L(e) {
+  if (!e)
+    return;
+  const {
+    cors: t,
+    security: r,
+    timing: n,
+    ...a
+  } = e;
+  return a;
+}
+function En(e, t) {
+  if (!t?.length)
+    return e;
+  const r = new Headers(e.headers), n = bn(t), a = r.get("server-timing");
+  return r.set(
+    "server-timing",
+    a ? `${a}, ${n}` : n
+  ), new Response(e.body, {
+    headers: r,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+function bn(e) {
+  return e.map(Rn).join(", ");
+}
+function b(e) {
+  if (e)
+    return Array.isArray(e) ? e : [e];
+}
+function Rn(e) {
+  if (!Tn(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=${xn(e.duration)}`);
+  }
+  return e.description !== void 0 && t.push(`desc="${Ln(e.description)}"`), t.join(";");
+}
+function Tn(e) {
+  return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(e);
+}
+function xn(e) {
+  return Number.isInteger(e), String(e);
+}
+function Ln(e) {
+  return e.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+const kn = "x-demiurge-mutation", An = "data;v=1", De = "application/vnd.demiurge.mutation+json;v=1";
+class Ft 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 I = "x-demiurge-revalidate-tags";
+function Ho(e) {
+  return {
+    ...dn(
+      async (r) => {
+        let n;
+        try {
+          n = e.input ? await e.input(r) : void 0;
+        } catch (u) {
+          if (!(u instanceof Ft)) throw u;
+          return Cn(r.request, u.validation);
+        }
+        const a = {
+          ...r,
+          input: n
+        }, s = async () => {
+          const u = await e.handler(a), l = u instanceof Response || u.kind === "response" || u.kind === "not-found", d = await Nn(
+            await $n(u, r),
+            r
+          );
+          return l || !Oe(r.request) ? d : await Pn(
+            d,
+            e.revalidateRoute === !0
+          );
+        };
+        if (!e.idempotency) {
+          const u = await s();
+          if (!ot(u)) return u;
+          const l = await it(
+            e.revalidate,
+            a
+          );
+          return await ct(u, l);
+        }
+        const i = typeof e.idempotency.key == "function" ? e.idempotency.key(a) : e.idempotency.key, o = await e.idempotency.store.run({
+          fn: s,
+          key: i,
+          ttl: e.idempotency.ttl
+        });
+        if (o.replayed) return Dn(o.value);
+        if (!ot(o.value)) return o.value;
+        const c = await it(
+          e.revalidate,
+          a
+        );
+        return await ct(o.value, c);
+      },
+      {
+        cors: e.cors,
+        security: e.security,
+        timing: e.timing
+      }
+    ),
+    mutation: !0
+  };
+}
+function Oe(e) {
+  return e.headers.get(kn) === An;
+}
+function Cn(e, t) {
+  const r = Oe(e) ? { version: 1, status: "invalid", validation: t } : { type: "validation-error", validation: t }, n = ie(r);
+  return Oe(e) ? new Response(n, {
+    headers: { "content-type": De },
+    status: 400
+  }) : new Response(n, {
+    headers: { "content-type": "application/json; charset=utf-8" },
+    status: 400
+  });
+}
+async function Pn(e, t) {
+  if (e.status >= 300 && e.status < 400) {
+    const n = e.headers.get("location");
+    return n ? new Response(ie({
+      version: 1,
+      status: "redirect",
+      location: n,
+      history: e.status === 301 || e.status === 308 ? "replace" : "push"
+    }), {
+      headers: { "content-type": De },
+      status: 200
+    }) : e;
+  }
+  const r = e.headers.get("content-type")?.includes("json") ? await e.clone().json().catch(() => {
+  }) : void 0;
+  return new Response(ie({
+    version: 1,
+    status: e.ok ? "success" : "failed",
+    ...t && e.ok ? { revalidate: !0 } : {},
+    ...e.ok && r !== void 0 ? { data: r } : {}
+  }), {
+    headers: { "content-type": De },
+    status: e.status
+  });
+}
+async function $n(e, t) {
+  if (e instanceof Response || e.kind !== "json") return e;
+  const r = typeof e.value == "function" ? await e.value(t) : e.value;
+  return ce(r), { ...e, value: r };
+}
+function ie(e) {
+  return ce(e), JSON.stringify(e);
+}
+function ce(e, t = /* @__PURE__ */ new Set()) {
+  if (!(e === null || typeof e == "string" || typeof e == "boolean")) {
+    if (typeof e == "number") {
+      if (Number.isFinite(e)) return;
+      throw k();
+    }
+    if (typeof e != "object" || t.has(e)) throw k();
+    if (t.add(e), Array.isArray(e)) {
+      for (const r of Reflect.ownKeys(e))
+        if (r !== "length" && (typeof r != "string" || !/^(0|[1-9][0-9]*)$/.test(r)))
+          throw k();
+      for (let r = 0; r < e.length; r += 1) {
+        if (!(r in e)) throw k();
+        ce(e[r], t);
+      }
+    } else {
+      const r = Object.getPrototypeOf(e);
+      if (r !== Object.prototype && r !== null)
+        throw k();
+      for (const n of Reflect.ownKeys(e)) {
+        if (typeof n != "string") throw k();
+        ce(Object.getOwnPropertyDescriptor(e, n)?.value, t);
+      }
+    }
+    t.delete(e);
+  }
+}
+function k() {
+  return new TypeError("A mutation result contains a value that JSON cannot serialize.");
+}
+function ot(e) {
+  return e.status >= 200 && e.status < 400;
+}
+async function it(e, t) {
+  return e ? typeof e == "function" ? await e(t) : e : {};
+}
+async function ct(e, t) {
+  const r = new Headers(e.headers);
+  r.delete(I);
+  const n = t.keys ?? [], a = t.tags ?? [];
+  return (n.length > 0 || a.length > 0) && r.set(
+    I,
+    encodeURIComponent(ie({
+      keys: n,
+      tags: a.map((s) => s.id),
+      version: 1
+    }))
+  ), new Response(e.body, {
+    headers: r,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+function Dn(e) {
+  if (!e.headers.has(I)) return e;
+  const t = new Headers(e.headers);
+  return t.delete(I), new Response(e.body, {
+    headers: t,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+const Fo = {
+  custom(e) {
+    return e;
+  },
+  form(e, t) {
+    return async (n) => {
+      const a = await n.request.formData(), s = await t(a, n), i = await e["~standard"].validate(s);
+      if (i.issues)
+        throw new Ft({
+          issues: i.issues.map((o) => ({
+            code: "invalid",
+            message: o.message,
+            path: On(o.path)
+          }))
+        });
+      return i.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 On(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 Nn(e, t) {
+  return e instanceof Response ? e : await Ht(e, t);
+}
+const Mn = [
+  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
+], Un = {
+  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"
+}, In = new Set(Mn);
+class zt extends Error {
+  detail;
+  extensions;
+  headers;
+  status;
+  title;
+  type;
+  constructor(t, r = {}, n = {}) {
+    jn(t);
+    const a = typeof r == "string" ? { detail: r } : r, {
+      detail: s,
+      title: i = Un[t],
+      type: o = "about:blank",
+      ...c
+    } = a;
+    super(s ?? i, { 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 = i, this.type = o;
+  }
+}
+function zo(e, t, r) {
+  return new zt(e, t, r);
+}
+function D(e) {
+  return e instanceof zt;
+}
+function jn(e) {
+  if (!In.has(e))
+    throw new RangeError(
+      `HTTP error status must be a standard 4xx or 5xx status; received ${JSON.stringify(e)}.`
+    );
+}
+function ut({ pathname: e }) {
+  return /* @__PURE__ */ _("main", { children: [
+    /* @__PURE__ */ V("h1", { children: "404" }),
+    /* @__PURE__ */ _("p", { children: [
+      "No route matched ",
+      e,
+      "."
+    ] })
+  ] });
+}
+function lt({ status: e }) {
+  return /* @__PURE__ */ _("main", { children: [
+    /* @__PURE__ */ V("h1", { children: e }),
+    /* @__PURE__ */ V("p", { children: "Something went wrong." })
+  ] });
+}
+function Hn({ error: e, pathname: t, status: r }) {
+  const { message: n, name: a, stack: s } = Je(e);
+  return /* @__PURE__ */ _("main", { children: [
+    /* @__PURE__ */ _("h1", { children: [
+      r,
+      " ",
+      a,
+      " at ",
+      t
+    ] }),
+    /* @__PURE__ */ V("p", { children: n }),
+    s ? /* @__PURE__ */ V("pre", { children: s }) : null
+  ] });
+}
+function Je(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 Fn = ["text/html", "application/xhtml+xml"];
+function Wt(e) {
+  return zn(e.headers.get("accept"));
+}
+function zn(e) {
+  return e ? Wn(e).some(
+    (t) => t.quality > 0 && Fn.includes(t.type)
+  ) : !1;
+}
+function Wn(e) {
+  return e.split(",").flatMap((t) => {
+    const [r, ...n] = t.split(";"), a = r.trim().toLowerCase();
+    return a ? [
+      {
+        quality: Bn(n),
+        type: a
+      }
+    ] : [];
+  });
+}
+function Bn(e) {
+  for (const t of e) {
+    const [r, n] = t.split("=");
+    if (r?.trim().toLowerCase() !== "q")
+      continue;
+    const a = Number.parseFloat(n ?? "");
+    return Number.isNaN(a) ? 1 : a;
+  }
+  return 1;
+}
+const Gn = "application/problem+json";
+function _n({
+  detail: e,
+  instance: t,
+  status: r,
+  title: n,
+  type: a = "about:blank",
+  ...s
+}) {
+  return {
+    type: a,
+    title: n,
+    status: r,
+    ...e === void 0 ? {} : { detail: e },
+    ...t === void 0 ? {} : { instance: t },
+    ...s
+  };
+}
+function J(e, t) {
+  const r = new Headers(t?.headers);
+  return r.set("content-type", `${Gn}; charset=utf-8`), new Response(JSON.stringify(_n(e)), {
+    ...t,
+    headers: r,
+    status: e.status
+  });
+}
+const Vn = "Internal Server Error";
+function qe(e) {
+  return e === !0 && process.env.NODE_ENV !== "production";
+}
+async function oe(e, t, r, n, a = {}) {
+  a.onError?.(r, n);
+  const s = new URL(t.url);
+  if (!(U(t) || n === "page" || n === "middleware" && Wt(t)))
+    return Jn(s, r, a);
+  if (U(t)) {
+    const o = Je(r), c = D(r) ? new Headers(r.headers) : new Headers();
+    return Ge(void 0, {
+      document: Ue({
+        dir: a.dir,
+        lang: a.lang,
+        metadata: E(),
+        title: a.title
+      }),
+      locale: a.locale,
+      error: {
+        detail: D(r) ? r.detail : qe(a.dev) ? o.message : void 0,
+        title: D(r) ? r.title : "Internal Server Error"
+      },
+      headers: c,
+      kind: ae,
+      status: Ke(r)
+    });
+  }
+  return await qn(e, s, r, a);
+}
+function Jn(e, t, r = {}) {
+  if (D(t))
+    return J(
+      {
+        ...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 } = Je(t);
+  return J({
+    // `detail` carries the thrown message, so it is dev only for the same
+    // reason the stack is.
+    ...qe(r.dev) ? { detail: n } : {},
+    instance: `${e.pathname}${e.search}`,
+    status: 500,
+    title: "Internal Server Error"
+  });
+}
+async function qn(e, t, r, n) {
+  const a = Ke(r);
+  try {
+    const s = await Yn(
+      e,
+      n.pathname ?? t.pathname,
+      r,
+      n
+    ), i = D(r) ? new Headers(r.headers) : new Headers();
+    return i.set("content-type", "text/html; charset=utf-8"), new Response(await n.transformDocument?.(s) ?? s, {
+      headers: i,
+      status: a
+    });
+  } catch (s) {
+    return n.onError?.(s, "page"), Kn();
+  }
+}
+function Kn() {
+  return new Response(Vn, {
+    headers: { "content-type": "text/plain; charset=utf-8" },
+    status: 500
+  });
+}
+async function Yn(e, t, r, n) {
+  const a = await Zn(e, t, n), s = Rt({
+    dev: n.dev,
+    nonce: n.nonce
+  }), i = Lt(
+    Tt(
+      s,
+      ke(a, { error: r, locale: n.locale, pathname: t, status: Ke(r) })
+    )
+  );
+  return xt({
+    body: { data: void 0, html: i, 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 Ke(e) {
+  return D(e) ? e.status : 500;
+}
+async function Zn(e, t, r) {
+  if (qe(r.dev))
+    return Hn;
+  try {
+    return await jr(e, t) ?? lt;
+  } catch {
+    return lt;
+  }
+}
+const ue = "{nonce}", dt = `'nonce-${ue}'`, Bt = {
+  baseUri: ["'self'"],
+  connectSrc: ["'self'"],
+  defaultSrc: ["'self'"],
+  fontSrc: ["'self'"],
+  formAction: ["'self'"],
+  frameAncestors: ["'none'"],
+  imgSrc: ["'self'", "data:", "blob:"],
+  objectSrc: ["'none'"],
+  scriptSrc: [dt, "'strict-dynamic'"],
+  styleSrc: ["'self'", dt],
+  upgradeInsecureRequests: !0
+}, Qn = {
+  ...Bt,
+  scriptSrc: ["'self'"],
+  styleSrc: ["'self'"]
+}, ft = {
+  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
+  }
+}, Xn = {
+  contentTypeOptions: "nosniff",
+  crossOriginResourcePolicy: "same-origin",
+  referrerPolicy: "strict-origin-when-cross-origin"
+}, F = {
+  api(e = {}) {
+    return W(
+      {
+        headers: Xn
+      },
+      e
+    );
+  },
+  preset(e, t = {}) {
+    return e === "api" ? F.api(t) : e === "cross-origin-isolated" ? F.crossOriginIsolated(t) : e === "static" ? F.static(t) : F.strict(t);
+  },
+  static(e = {}) {
+    return W(
+      {
+        csp: Qn,
+        headers: ft
+      },
+      e
+    );
+  },
+  strict(e = {}) {
+    return W(
+      {
+        csp: Bt,
+        headers: ft
+      },
+      e
+    );
+  },
+  crossOriginIsolated(e = {}) {
+    return W(
+      F.strict({
+        headers: {
+          crossOriginEmbedderPolicy: "require-corp",
+          crossOriginOpenerPolicy: "same-origin"
+        }
+      }),
+      e
+    );
+  }
+};
+function Wo(e) {
+  return e;
+}
+function Bo(e) {
+  return e;
+}
+function ea(...e) {
+  return e.reduce((t, r) => r ? W(t, r) : t, {});
+}
+function le(...e) {
+  const t = e.reduce((r, n) => n ? {
+    document: ea(r.document, n.document),
+    security: ta(r.security, n.security)
+  } : r, {});
+  return {
+    ...t,
+    document: na(t.document, t.security?.needs)
+  };
+}
+function ta(...e) {
+  return e.reduce((t, r) => r ? {
+    csrf: r.csrf ?? t.csrf,
+    fetchMetadata: r.fetchMetadata ?? t.fetchMetadata,
+    needs: ra(t.needs, r.needs),
+    rateLimit: r.rateLimit ?? t.rateLimit,
+    request: Vt(t.request, r.request)
+  } : t, {});
+}
+const Gt = [
+  { directive: "connectSrc", need: "connect" },
+  { directive: "imgSrc", need: "img" },
+  { directive: "scriptSrc", need: "script" }
+];
+function ra(e, t) {
+  const r = {};
+  for (const { need: n } of Gt) {
+    const a = [.../* @__PURE__ */ new Set([
+      ...e?.[n] ?? [],
+      ...t?.[n] ?? []
+    ])];
+    a.length > 0 && (r[n] = a);
+  }
+  return Object.keys(r).length > 0 ? r : void 0;
+}
+function na(e, t) {
+  if (!e?.csp || !t)
+    return e;
+  let r = e.csp;
+  for (const { directive: n, need: a } of Gt)
+    r = aa(r, n, a, t[a]);
+  return r === e.csp ? e : { ...e, csp: r };
+}
+function aa(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 a = C(
+    e[t] ?? e.defaultSrc
+  ) ?? [];
+  return Array.isArray(a) ? {
+    ...e,
+    [t]: [.../* @__PURE__ */ new Set([...a, ...n])]
+  } : e;
+}
+async function Go(e, t = "sha256") {
+  const r = await globalThis.crypto.subtle.digest(
+    Sa(t),
+    new TextEncoder().encode(e)
+  );
+  return `'${t}-${va(new Uint8Array(r))}'`;
+}
+function Y(e, t = {}) {
+  e.csp && ga(e.csp), pa(e);
+  const r = new Headers(), n = e.csp !== !1 && e.csp ? fa(e.csp, t) : void 0, a = ua(e.trustedTypes), s = e.trustedTypes ? e.trustedTypes.mode === "report-only" : !1;
+  return v(
+    r,
+    "content-security-policy",
+    de(n, s ? void 0 : a)
+  ), v(
+    r,
+    "content-security-policy-report-only",
+    s ? de(a, qt(e.csp)) : void 0
+  ), ca(r, e.headers, t), r;
+}
+function pe(e) {
+  return !e || !e.csp ? !1 : Z(e.csp).some(([, t]) => {
+    const r = C(t);
+    return Array.isArray(r) && r.some((n) => n.includes(ue));
+  });
+}
+function _t() {
+  const e = new Uint8Array(16);
+  return globalThis.crypto.getRandomValues(e), btoa(String.fromCharCode(...e));
+}
+function W(e, t) {
+  return {
+    csp: oa(e.csp, t.csp),
+    headers: sa(e.headers, t.headers),
+    trustedTypes: t.trustedTypes ?? e.trustedTypes
+  };
+}
+function sa(e, t) {
+  const r = Vt(e, t);
+  return !r || t?.reportingEndpoints === !1 || e?.reportingEndpoints && t?.reportingEndpoints && (r.reportingEndpoints = {
+    ...e.reportingEndpoints,
+    ...t.reportingEndpoints
+  }), r;
+}
+function Vt(e, t) {
+  return t ? {
+    ...e ?? {},
+    ...t
+  } : e;
+}
+function oa(e, t) {
+  if (t === !1)
+    return !1;
+  if (!t)
+    return e;
+  if (!e)
+    return Re(t);
+  const r = Re(e), n = Re(t), a = {
+    ...r,
+    ...n
+  };
+  for (const [s, i] of Z(t)) {
+    const o = C(
+      r[s]
+    );
+    !Ye(i) && Array.isArray(o) && Array.isArray(i) && Jt(
+      a,
+      s,
+      ia([...o, ...i])
+    );
+  }
+  return a;
+}
+function Re(e) {
+  const t = { ...e };
+  for (const [r, n] of Z(e))
+    Ye(n) && Jt(t, r, n.replace);
+  return t;
+}
+function ia(e) {
+  return [...new Set(e)];
+}
+function Jt(e, t, r) {
+  if (!(t === "reportTo" || t === "upgradeInsecureRequests")) {
+    if (t === "reportUri") {
+      e.reportUri = r;
+      return;
+    }
+    e[t] = r;
+  }
+}
+function ca(e, t, r) {
+  t && (v(e, "referrer-policy", t.referrerPolicy), v(e, "x-content-type-options", t.contentTypeOptions), v(e, "cross-origin-opener-policy", t.crossOriginOpenerPolicy), v(e, "cross-origin-embedder-policy", t.crossOriginEmbedderPolicy), v(e, "cross-origin-resource-policy", t.crossOriginResourcePolicy), v(e, "permissions-policy", t.permissionsPolicy), v(
+    e,
+    "reporting-endpoints",
+    ha(t.reportingEndpoints)
+  ), t.strictTransportSecurity && (!r.request || new URL(r.request.url).protocol === "https:") && e.set(
+    "strict-transport-security",
+    da(t.strictTransportSecurity)
+  ));
+}
+function ua(e) {
+  if (!e)
+    return;
+  const t = [];
+  return e.requireFor?.includes("script") && t.push("require-trusted-types-for 'script'"), t.push(la(e)), de(...t);
+}
+function la(e) {
+  if (e.policies !== void 0 && e.policies.length === 0)
+    return "trusted-types 'none'";
+  const t = [fr];
+  e.allowDefaultPolicy && t.push("default");
+  for (const r of e.policies ?? [])
+    t.push(r);
+  return `trusted-types ${[...new Set(t)].join(" ")}`;
+}
+function de(...e) {
+  const t = e.filter((r) => r);
+  return t.length > 0 ? t.join("; ") : void 0;
+}
+function v(e, t, r) {
+  r && e.set(t, r);
+}
+function da(e) {
+  const t = [`max-age=${e.maxAge}`];
+  return e.includeSubDomains && t.push("includeSubDomains"), e.preload && t.push("preload"), t.join("; ");
+}
+function fa(e, t) {
+  const r = [];
+  for (const [a, s] of Z(e)) {
+    if (a === "reportTo" || a === "reportUri")
+      continue;
+    const i = C(s);
+    if (i === !1 || i === void 0)
+      continue;
+    const o = Kt(a);
+    if (i === !0 || a === "sandbox" && Array.isArray(i) && i.length === 0) {
+      r.push(o);
+      continue;
+    }
+    r.push(
+      `${o} ${ya(i, t).join(" ")}`
+    );
+  }
+  const n = qt(e);
+  return n && r.push(n), r.join("; ");
+}
+function qt(e) {
+  if (!e)
+    return;
+  const t = [], r = C(e.reportUri);
+  return Array.isArray(r) && r.length && t.push(`report-uri ${r.join(" ")}`), e.reportTo && t.push(`report-to ${e.reportTo}`), de(...t);
+}
+function ha(e) {
+  if (e)
+    return Object.entries(e).sort(([t], [r]) => t.localeCompare(r)).map(([t, r]) => `${t}="${ma(r)}"`).join(", ");
+}
+function ma(e) {
+  return e.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function pa(e) {
+  const t = e.headers?.reportingEndpoints;
+  if (t) {
+    const a = Object.entries(t);
+    if (a.length === 0)
+      throw new Error("Demiurge Reporting-Endpoints requires at least one endpoint.");
+    for (const [s, i] of a)
+      ht(s), mt(i, `Reporting-Endpoints member ${JSON.stringify(s)}`);
+  }
+  const r = e.csp || void 0;
+  if (r?.reportTo && (ht(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 = C(r?.reportUri);
+  for (const a of Array.isArray(n) ? n : [])
+    mt(a, "CSP report-uri target");
+}
+function ga(e) {
+  for (const [t, r] of Z(e)) {
+    const n = Kt(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 a = C(r);
+    if (a !== !1 && (!Array.isArray(a) || !a.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 Ye(e) {
+  return !!(e && typeof e == "object" && !Array.isArray(e) && "replace" in e);
+}
+function C(e) {
+  return Ye(e) ? e.replace : e;
+}
+function ht(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 mt(e, t) {
+  if (!wa(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 wa(e) {
+  return /^[\x20-\x7e]+$/.test(e);
+}
+function Z(e) {
+  return Object.entries(e);
+}
+function ya(e, t) {
+  return e.map((r) => {
+    if (!r.includes(ue))
+      return r;
+    if (!t.nonce)
+      throw new Error("Demiurge security policy requires a CSP nonce.");
+    return r.replaceAll(ue, t.nonce);
+  });
+}
+function Kt(e) {
+  return e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+}
+function Sa(e) {
+  return e === "sha384" ? "SHA-384" : e === "sha512" ? "SHA-512" : "SHA-256";
+}
+function va(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 Yt(e, t, r = {}) {
+  Ze(e);
+  const n = t.request.headers.get("origin"), a = new Headers();
+  if (e.origins !== "*" && Zt(a, "Origin"), !n)
+    return a;
+  const s = Ra(e, n);
+  if (!s)
+    return a;
+  if (a.set("access-control-allow-origin", s), e.credentials && a.set("access-control-allow-credentials", "true"), e.exposeHeaders?.length && a.set("access-control-expose-headers", e.exposeHeaders.join(", ")), r.preflight) {
+    a.set("access-control-allow-methods", r.methods.join(", "));
+    const i = t.request.headers.get(
+      "access-control-request-headers"
+    ), o = e.headers?.join(", ") ?? i;
+    o && a.set("access-control-allow-headers", o), e.maxAge !== void 0 && a.set("access-control-max-age", String(e.maxAge));
+  }
+  return a;
+}
+function B(e, t, r) {
+  if (!t)
+    return e;
+  const n = new Headers(e.headers);
+  return Ta(n, Yt(t, { request: r })), new Response(e.body, {
+    headers: n,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+function Ea(e, t) {
+  const r = t.headers.get("access-control-request-method"), n = xa(r);
+  if (!n)
+    return null;
+  const a = Qt(e, n);
+  if (!a?.cors)
+    return null;
+  const s = a.cors.methods ?? La(e);
+  return s.includes(n) ? new Response(null, {
+    headers: Yt(
+      a.cors,
+      { request: t },
+      {
+        methods: s,
+        preflight: !0
+      }
+    ),
+    status: 204
+  }) : null;
+}
+function Ze(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)
+      ba(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 ba(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 Ra(e, t) {
+  return e.origins === "*" ? "*" : e.origins.includes(t) ? t : null;
+}
+function Ta(e, t) {
+  t.forEach((r, n) => {
+    if (n === "vary" && e.has("vary")) {
+      for (const a of r.split(","))
+        Zt(e, a.trim());
+      return;
+    }
+    e.set(n, r);
+  });
+}
+function Zt(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 xa(e) {
+  if (!e)
+    return null;
+  const t = e.toUpperCase();
+  return ka(t) ? t : null;
+}
+function Qt(e, t) {
+  return t === "HEAD" ? e.HEAD ?? gt(e.GET) : gt(e[t]);
+}
+function gt(e) {
+  return e?.kind === "page" ? void 0 : e;
+}
+function La(e) {
+  return [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "OPTIONS",
+    "HEAD"
+  ].filter((t) => Qt(e, t));
+}
+function ka(e) {
+  return e === "GET" || e === "POST" || e === "PUT" || e === "PATCH" || e === "DELETE" || e === "OPTIONS" || e === "HEAD";
+}
+const Aa = /* @__PURE__ */ new Set(["DELETE", "PATCH", "POST", "PUT"]);
+function Ca(e = {}) {
+  const t = [], r = e.document, n = r ? Da(r.policy, r.headers, t) : {};
+  r && Pa(r.policy, t);
+  const a = e.route ? za(e.route, t) : void 0;
+  return r?.scripts && (Oa(
+    r.policy.csp,
+    r.scripts,
+    r.headers,
+    t
+  ), r.scriptDependencies && t.push(
+    ...$a(
+      r.scripts,
+      Na(r.scriptDependencies)
+    )
+  )), {
+    findings: t,
+    headers: n,
+    route: a
+  };
+}
+function Pa(e, t) {
+  if (!e.trustedTypes || e.trustedTypes.mode !== "report-only")
+    return;
+  const r = e.csp || void 0, n = !!Ne(r?.reportUri)?.length, a = e.headers?.reportingEndpoints, s = !!(r?.reportTo && a && a[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 $a(e, t = {}) {
+  const r = t.requirePurpose ?? !0, n = [];
+  for (const a of e) {
+    const s = Ga(a);
+    s && (r && !a.purpose && n.push({
+      code: "script-purpose-missing",
+      message: `Third-party script ${a.src} should declare a purpose for audits and consent flows.`,
+      severity: "warning"
+    }), t.requireIntegrity && !a.integrity && n.push({
+      code: "script-integrity-missing",
+      message: `Third-party script ${a.src} should declare an integrity hash or an explicit trust-boundary exception.`,
+      severity: "warning"
+    }), a.strategy === "beforeInteractive" && !t.allowBeforeInteractiveThirdParty && n.push({
+      code: "script-third-party-before-interactive",
+      message: `Third-party script ${a.src} runs before the app is interactive and should be justified by policy.`,
+      severity: "warning"
+    }), _a(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 Da(e, t, r) {
+  try {
+    return Object.fromEntries(Y(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 Oa(e, t, r, n) {
+  if (!e)
+    return;
+  const a = Ma(e);
+  for (const s of t) {
+    if (Ua(a) && !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 || Ia(a, 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 Na(e) {
+  return typeof e == "boolean" ? {} : e;
+}
+function Ma(e) {
+  return Ne(e.scriptSrc) ?? Ne(e.defaultSrc) ?? [];
+}
+function Ne(e) {
+  if (e)
+    return "replace" in e ? e.replace : e;
+}
+function Ua(e) {
+  return e.some((t) => t.includes("'nonce-{nonce}'"));
+}
+function Ia(e, t) {
+  return Fa(e) ? !1 : e.includes("*") ? !0 : e.includes("'none'") || e.some((r) => r.startsWith("'nonce-")) ? !1 : e.includes("'self'") && ja(t) || t.startsWith("https:") && e.includes("https:") || t.startsWith("http:") && e.includes("http:") ? !0 : e.some((r) => Ha(r, t));
+}
+function ja(e) {
+  return e.startsWith("/") && !e.startsWith("//");
+}
+function Ha(e, t) {
+  if (e.startsWith("'"))
+    return !1;
+  try {
+    const r = new URL(e), n = new URL(t), a = 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 && a && n.port === r.port && s;
+  } catch {
+    return !1;
+  }
+}
+function Fa(e) {
+  return e.includes("'strict-dynamic'") && e.some(
+    (t) => t.startsWith("'nonce-") || /^'sha(?:256|384|512)-/.test(t)
+  );
+}
+function za(e, t) {
+  return Wa(e.cors, t), Ba(e.method, e.security, t), {
+    cors: e.cors,
+    method: e.method,
+    security: e.security
+  };
+}
+function Wa(e, t) {
+  if (e)
+    try {
+      Ze(e);
+    } catch (r) {
+      t.push({
+        code: "cors-invalid",
+        message: r instanceof Error ? r.message : "CORS policy is invalid.",
+        severity: "error"
+      });
+    }
+}
+function Ba(e, t, r) {
+  Aa.has(e) && (t?.csrf === !1 && r.push({
+    code: "csrf-disabled",
+    message: "CSRF protection is explicitly disabled for this unsafe route.",
+    severity: "info"
+  }), t?.rateLimit || r.push({
+    code: "rate-limit-missing",
+    message: "Unsafe routes should declare rate limiting.",
+    severity: "warning"
+  }), t?.request?.maxBodySize || r.push({
+    code: "request-body-limit-missing",
+    message: "Unsafe routes should declare a request body size limit.",
+    severity: "warning"
+  }));
+}
+function Ga(e) {
+  try {
+    const t = new URL(e.src);
+    if (t.protocol === "http:" || t.protocol === "https:")
+      return t;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function _a(e) {
+  return e.hostname === "www.googletagmanager.com" && (e.pathname === "/gtm.js" || e.pathname === "/ns.html");
+}
+const Va = /* @__PURE__ */ new Set(["DELETE", "PATCH", "POST", "PUT"]), Ja = /^[!#$%&'*+\-.^_`|~A-Za-z0-9]+$/;
+function qa() {
+  const e = new Uint8Array(32);
+  return globalThis.crypto.getRandomValues(e), btoa(String.fromCharCode(...e)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function Ka(e, t = {}) {
+  const r = t.cookie ?? "csrf-token";
+  if (!Ja.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 _o(e = {}) {
+  const t = qa();
+  return {
+    cookie: Ka(t, e),
+    token: t
+  };
+}
+async function Ya(e, t) {
+  if (!Va.has(t.method.toUpperCase()) || e === !1)
+    return null;
+  const r = t.headers.get("cookie");
+  if (e === void 0 && !r?.trim())
+    return null;
+  const n = Qa(e ?? !0), s = Za(r).get(n.cookie), i = t.headers.get(n.header);
+  if (!!(s && i && wt(s, i)))
+    return null;
+  const c = n.field ? await Xa(t.clone(), n.field) : null;
+  return !(s && c && wt(s, c)) ? new Response("Invalid CSRF token.", {
+    status: 403
+  }) : null;
+}
+function Za(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 a = r.slice(0, n).trim(), s = r.slice(n + 1).trim();
+    a && t.set(a, es(s));
+  }
+  return t;
+}
+function Qa(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 Xa(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 es(e) {
+  try {
+    return decodeURIComponent(e);
+  } catch {
+    return e;
+  }
+}
+function wt(e, t) {
+  let r = e.length ^ t.length;
+  const n = Math.max(e.length, t.length);
+  for (let a = 0; a < n; a += 1)
+    r |= e.charCodeAt(a) ^ t.charCodeAt(a);
+  return r === 0;
+}
+const Te = "Sec-Fetch-Dest", ts = "Sec-Fetch-Mode", rs = "Sec-Fetch-Site", ns = /* @__PURE__ */ new Set(["embed", "object"]), as = /* @__PURE__ */ new Set(["GET", "HEAD"]), yt = {
+  allowCrossSite: !1,
+  allowNavigation: !0,
+  allowSameSite: !1
+};
+function ss(e, t, r = t.method) {
+  const n = e === !0 ? yt : { ...yt, ...e }, a = [];
+  if (is(t, r))
+    return { allowed: !0, reason: "cors-preflight", vary: a };
+  a.push(rs);
+  const s = t.headers.get("sec-fetch-site");
+  if (s === null)
+    return { allowed: !0, reason: "metadata-absent", vary: a };
+  if (s === "same-origin")
+    return { allowed: !0, reason: "same-origin", vary: a };
+  if (s === "none")
+    return { allowed: !0, reason: "user-initiated", vary: a };
+  if (s === "same-site" && n.allowSameSite)
+    return { allowed: !0, reason: "same-site-trusted", vary: a };
+  if (n.allowCrossSite)
+    return { allowed: !0, reason: "cross-site-exempt", vary: a };
+  const i = e === !0 ? void 0 : e.allowedDestinations;
+  if (i?.length && (a.push(Te), i.includes(t.headers.get("sec-fetch-dest") ?? "")))
+    return { allowed: !0, reason: "destination-exempt", vary: a };
+  if (n.allowNavigation && as.has(r.toUpperCase()) && (a.push(ts), t.headers.get("sec-fetch-mode") === "navigate")) {
+    const o = t.headers.get("sec-fetch-dest") ?? "";
+    if (a.includes(Te) || a.push(Te), !ns.has(o))
+      return { allowed: !0, reason: "top-level-navigation", vary: a };
+  }
+  return {
+    allowed: !1,
+    reason: s === "same-site" ? "same-site-denied" : "cross-site-denied",
+    vary: a
+  };
+}
+function os(e, t, r = t.method) {
+  if (!e)
+    return { response: null, vary: [] };
+  const n = ss(e, t, r);
+  if (n.allowed)
+    return { response: null, vary: n.vary };
+  const a = new Response("Request blocked by the Fetch Metadata policy.", {
+    headers: { "content-type": "text/plain; charset=utf-8" },
+    status: 403
+  });
+  return Xt(a, n.vary), { response: a, vary: n.vary };
+}
+function Xt(e, t) {
+  if (t.length === 0)
+    return e;
+  const r = e.headers.get("vary")?.split(",").map((a) => a.trim()).filter(Boolean) ?? [];
+  if (r.includes("*"))
+    return e;
+  const n = [...r];
+  for (const a of t)
+    n.some((s) => s.toLowerCase() === a.toLowerCase()) || n.push(a);
+  return e.headers.set("vary", n.join(", ")), e;
+}
+function is(e, t) {
+  return t.toUpperCase() === "OPTIONS" && e.headers.has("access-control-request-method");
+}
+const cs = {
+  h: 3600 * 1e3,
+  m: 60 * 1e3,
+  s: 1e3
+}, us = 1e4;
+function er(e = {}) {
+  const t = e.maximumEntries ?? us;
+  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(a, s, i) {
+      i >= n && (ls(r, i), n = ds(r));
+      const o = r.get(a);
+      if (!o || o.resetAt <= i) {
+        const c = {
+          count: 1,
+          resetAt: i + s
+        };
+        return !o && r.size >= t && fs(r), r.set(a, c), n = Math.min(n, c.resetAt), { count: c.count, resetAt: c.resetAt };
+      }
+      return o.count += 1, { count: o.count, resetAt: o.resetAt };
+    }
+  };
+}
+function ls(e, t) {
+  for (const [r, n] of e)
+    n.resetAt <= t && e.delete(r);
+}
+function ds(e) {
+  let t = Number.POSITIVE_INFINITY;
+  for (const r of e.values())
+    t = Math.min(t, r.resetAt);
+  return t;
+}
+function fs(e) {
+  const t = e.keys().next().value;
+  t !== void 0 && e.delete(t);
+}
+async function hs(e, t, r, n = Date.now()) {
+  if (!e)
+    return null;
+  Qe(e);
+  const a = tr(e.window), s = ms(e, t), i = await r.increment(s, a, n), o = Math.max(0, e.limit - i.count), c = new Headers({
+    "retry-after": String(Math.ceil(Math.max(0, i.resetAt - n) / 1e3)),
+    "x-ratelimit-limit": String(e.limit),
+    "x-ratelimit-remaining": String(o),
+    "x-ratelimit-reset": String(Math.ceil(i.resetAt / 1e3))
+  });
+  return i.count > e.limit ? new Response("Rate limit exceeded.", {
+    headers: c,
+    status: 429
+  }) : null;
+}
+function tr(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(), a = r * cs[n];
+  if (!Number.isSafeInteger(a))
+    throw new Error("Demiurge rate limit window is too large.");
+  return a;
+}
+function Qe(e) {
+  if (!Number.isSafeInteger(e.limit) || e.limit <= 0)
+    throw new Error("Demiurge rate limit limit must be a positive integer.");
+  tr(e.window);
+}
+function ms(e, t) {
+  return `${ps(e.key)}:${gs(e.key, t)}`;
+}
+function ps(e) {
+  return typeof e == "string" ? e : `header:${e.header.toLowerCase()}`;
+}
+function gs(e, t) {
+  return e === "ip" ? ws(t) : t.headers.get(e.header) ?? "missing";
+}
+function ws(e) {
+  return hr(e)?.clientIp ?? "unknown";
+}
+const ys = {
+  b: 1,
+  gb: 1024 ** 3,
+  kb: 1024,
+  mb: 1024 ** 2
+};
+function Ss(e, t, r) {
+  const n = Es(e, r);
+  if (n)
+    return n;
+  if (e?.maxBodySize === void 0)
+    return null;
+  const a = t.headers.get("content-length");
+  if (!a)
+    return null;
+  const s = bs(a);
+  if (s === null)
+    return new Response("Invalid Content-Length.", {
+      status: 400
+    });
+  const i = rr(e.maxBodySize);
+  return s > i ? new Response("Request body too large.", {
+    status: 413
+  }) : null;
+}
+class G extends Error {
+  constructor() {
+    super("Demiurge request body exceeded maxBodySize while being read."), this.name = "RequestBodyTooLargeError";
+  }
+}
+function vs(e, t) {
+  if (e?.maxBodySize === void 0 || t.body === null)
+    return t;
+  const r = rr(e.maxBodySize), n = t.body.getReader();
+  let a = 0;
+  const s = new ReadableStream({
+    async pull(o) {
+      const c = await n.read();
+      if (c.done) {
+        o.close();
+        return;
+      }
+      if (a += c.value.byteLength, a > r) {
+        const u = new G();
+        o.error(u);
+        try {
+          await n.cancel(u);
+        } catch {
+        }
+        return;
+      }
+      o.enqueue(c.value);
+    },
+    async cancel(o) {
+      try {
+        await n.cancel(o);
+      } catch {
+      }
+    }
+  }), i = new Request(t, {
+    body: s,
+    duplex: "half"
+  });
+  return mr(t, i), i;
+}
+function te() {
+  return new Response("Request body too large.", { status: 413 });
+}
+function Es(e, t) {
+  return !e?.allowedMethods || Rs(e.allowedMethods, t) ? null : new Response(null, {
+    headers: {
+      allow: Ts(e.allowedMethods)
+    },
+    status: 405
+  });
+}
+function rr(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(), a = r * ys[n];
+  if (!Number.isSafeInteger(a))
+    throw new Error("Demiurge request maxBodySize is too large.");
+  return a;
+}
+function bs(e) {
+  if (!/^\d+$/.test(e))
+    return null;
+  const t = Number(e);
+  return Number.isSafeInteger(t) ? t : null;
+}
+function Rs(e, t) {
+  return e.includes(t) || t === "HEAD" && e.includes("GET");
+}
+function Ts(e) {
+  const t = [...e];
+  return t.includes("GET") && !t.includes("HEAD") && t.push("HEAD"), t.join(", ");
+}
+const xs = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+];
+function Ls(e, t = {}) {
+  for (const [n, a] of Object.entries(e)) {
+    ks(n, a);
+    for (const s of xs) {
+      const i = a[s];
+      !i || i.kind === "page" || As(n, s, i, a);
+    }
+  }
+  const r = Pt(
+    Object.fromEntries(
+      Object.entries(e).map(([n, a]) => [
+        n,
+        async () => a
+      ])
+    )
+  );
+  return Ds(r, e, t.adapter), r;
+}
+function ks(e, t) {
+  const r = t.policy?.security?.rateLimit;
+  r && K(e, "policy", "rate limit", () => {
+    Qe(r);
+  });
+}
+function As(e, t, r, n) {
+  r.cors && K(e, t, "CORS", () => {
+    Ze(r.cors), Cs(e, t, r.cors.methods, n);
+  }), r.security?.rateLimit && K(e, t, "rate limit", () => {
+    Qe(r.security.rateLimit);
+  });
+}
+function Cs(e, t, r, n) {
+  if (r) {
+    for (const a of r)
+      if (a !== "OPTIONS" && !Ps(n, a))
+        throw new Error(
+          `Route ${JSON.stringify(e)} export ${t} allows CORS method ${a}, but the route does not export that response capability.`
+        );
+  }
+}
+function Ps(e, t) {
+  const r = t === "HEAD" ? e.HEAD ?? e.GET : e[t];
+  return $s(r) ? r : void 0;
+}
+function $s(e) {
+  return !!(e && e.kind !== "page");
+}
+function Ds(e, t, r) {
+  for (const a of e.routes) {
+    const s = t[a.file], i = s?.GET;
+    if (!i || i.kind !== "page")
+      continue;
+    const o = le(
+      ...e.policies.filter(
+        (c) => A(c.fileSegments, a.fileSegments)
+      ).map((c) => t[c.file]?.policy),
+      s.policy
+    );
+    St(a.file, "GET", o, r), js(
+      a.file,
+      i.render.mode,
+      o.document
+    ), Os(
+      a.file,
+      "GET",
+      o,
+      [
+        ...e.layouts.filter(
+          (c) => A(c.fileSegments, a.fileSegments)
+        ).map((c) => t[c.file]?.scripts),
+        s.scripts
+      ]
+    );
+  }
+  const n = [
+    ...e.fallbacks.error,
+    ...e.fallbacks.loading,
+    ...e.fallbacks.notFound
+  ];
+  for (const a of n) {
+    const s = le(
+      ...e.policies.filter(
+        (i) => A(i.fileSegments, a.fileSegments)
+      ).map((i) => t[i.file]?.policy),
+      t[a.file]?.policy
+    );
+    St(
+      a.file,
+      "policy",
+      s,
+      r
+    );
+  }
+}
+function Os(e, t, r, n) {
+  const a = n.flatMap(
+    (d) => Array.isArray(d) ? d : []
+  );
+  if (a.length === 0 || !r.document)
+    return;
+  const s = "startup-verification-nonce", o = Ca({
+    document: {
+      headers: { nonce: s },
+      policy: r.document,
+      scripts: a.map((d) => ({
+        ...d,
+        nonce: pe(r.document) ? s : d.nonce
+      }))
+    }
+  }).findings.find(
+    (d) => d.code === "csp-script-src-blocked"
+  );
+  if (!o) {
+    Ms(
+      e,
+      t,
+      r.document.csp,
+      a
+    );
+    return;
+  }
+  const c = a.find(
+    (d) => o.message.includes(d.src)
+  ), l = (Y(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 Ns = [
+  { directive: "connectSrc", name: "connect-src", need: "connect" },
+  { directive: "imgSrc", name: "img-src", need: "img" }
+];
+function Ms(e, t, r, n) {
+  if (r)
+    for (const a of n)
+      for (const { directive: s, name: i, need: o } of Ns) {
+        const c = a.needs?.[o] ?? [];
+        if (c.length === 0)
+          continue;
+        const u = q(r[s]) ?? q(r.defaultSrc);
+        if (u !== void 0) {
+          for (const l of c)
+            if (!(Array.isArray(u) && Us(u, l)))
+              throw new Error(
+                `Route ${JSON.stringify(e)} export ${t} declares script ${JSON.stringify(a.src)} that needs ${i} ${l}, which the effective policy does not allow. Add ${l} to security.needs.${o} or to csp.${s} for this route.`
+              );
+        }
+      }
+}
+function Us(e, t) {
+  return e.includes("'none'") ? !1 : e.includes("*") || e.includes(t) ? !0 : t.startsWith("'") ? !1 : e.some((r) => Is(r, t));
+}
+function Is(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 a = n.hostname.slice(1);
+    return r.hostname.endsWith(a) && r.hostname !== n.hostname.slice(2);
+  }
+  return n.hostname === r.hostname;
+}
+function St(e, t, r, n) {
+  K(e, t, "effective document", () => {
+    Y(r.document ?? {}, {
+      nonce: "startup-verification-nonce"
+    });
+  }), !(!n || !pe(r.document)) && K(e, t, "effective CSP", () => {
+    pr(n, ["nonceInjection"]);
+  });
+}
+function js(e, t, r) {
+  if (t === "static") {
+    const a = Hs(r?.csp);
+    if (a)
+      throw new Error(
+        `Route ${JSON.stringify(e)} uses render mode "static" with an effective ${a} 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 = Fs(r?.csp);
+  if (!(!n || zs(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 Hs(e) {
+  if (e)
+    for (const [t, r] of Object.entries(e)) {
+      const n = q(r);
+      if (Array.isArray(n) && n.some((a) => Ws(a)))
+        return Gs(t);
+    }
+}
+function Fs(e) {
+  if (!e)
+    return;
+  const t = q(e.scriptSrc);
+  if (Array.isArray(t))
+    return { name: "script-src", sources: t };
+  const r = q(e.defaultSrc);
+  if (Array.isArray(r))
+    return { name: "default-src", sources: r };
+}
+function zs(e) {
+  return e.some((t) => nr(t)) ? !0 : e.includes("'unsafe-inline'") && !e.some((t) => Bs(t));
+}
+function Ws(e) {
+  return nr(e) || /^'nonce-[^']*'$/i.test(e);
+}
+function nr(e) {
+  return e.includes("{nonce}");
+}
+function Bs(e) {
+  return /^'(?:nonce-|sha256-|sha384-|sha512-)/i.test(e);
+}
+function q(e) {
+  return e && typeof e == "object" && !Array.isArray(e) && "replace" in e ? e.replace : e;
+}
+function Gs(e) {
+  return e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+}
+function K(e, t, r, n) {
+  try {
+    n();
+  } catch (a) {
+    if (a instanceof Error && a.message.startsWith(`Route ${JSON.stringify(e)} export `))
+      throw a;
+    const s = a instanceof Error ? a.message : `${r} validation failed.`;
+    throw new Error(
+      `Route ${JSON.stringify(e)} export ${t} has an invalid ${r} policy. ${s}`,
+      { cause: a }
+    );
+  }
+}
+function _s(e) {
+  return J({
+    instance: `${e.pathname}${e.search}`,
+    status: 404,
+    title: "Not Found"
+  });
+}
+async function fe(e, t, r = {}) {
+  const n = new URL(t.url), a = r.pathname ?? n.pathname;
+  if (!U(t) && !Wt(t))
+    return _s(n);
+  const s = await Pe(e, a, {
+    locale: r.locale,
+    onLayoutError: (l) => r.onError?.(l, "page")
+  }), i = await Vs(e, a), o = r.nonce ?? (pe(i) ? _t() : void 0), c = Y(i ?? {}, {
+    nonce: o,
+    request: t
+  });
+  if (U(t))
+    return Ge(void 0, {
+      document: Ue({
+        dir: r.dir,
+        lang: r.lang,
+        metadata: s.metadata,
+        title: r.title
+      }),
+      locale: r.locale,
+      headers: c,
+      kind: $e,
+      status: 404
+    });
+  const u = Js(s, { ...r, nonce: o });
+  return c.set("content-type", "text/html; charset=utf-8"), new Response(
+    await r.transformDocument?.(u) ?? u,
+    {
+      headers: c,
+      status: 404
+    }
+  );
+}
+async function Vs(e, t) {
+  const r = await Promise.all(
+    zr(e, t).map((n) => n.load())
+  );
+  return le(...r.map((n) => n.policy)).document;
+}
+function Js(e, t = {}) {
+  const r = e.notFound ?? ut;
+  try {
+    return xe(e, r, e.layouts, t);
+  } catch (n) {
+    t.onError?.(n, "page");
+  }
+  try {
+    return xe(e, r, [], t);
+  } catch (n) {
+    t.onError?.(n, "page");
+  }
+  return xe(e, ut, [], t);
+}
+function xe(e, t, r, n) {
+  const a = r.reduceRight(
+    (i, o) => ke(o, {
+      children: i,
+      locale: e.locale,
+      path: {},
+      pathname: e.pathname
+    }),
+    ke(t, { locale: e.locale, pathname: e.pathname })
+  ), s = Rt({
+    dev: n.dev,
+    nonce: n.nonce
+  });
+  return xt({
+    body: {
+      data: void 0,
+      fallback: "not-found",
+      html: Lt(Tt(s, a)),
+      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 ar = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+], sr = er();
+function Vo(e) {
+  e.routeModules && Ls(e.routeModules, { adapter: e.adapter });
+  const t = Pt(e.routes), r = e.locales ? an(e.locales) : void 0, n = e.rateLimitStore ?? er();
+  return e.cacheStore && At(e.cacheStore.namespace), async function(s) {
+    let i = e.ssr;
+    if (r) {
+      const o = sn(s, r);
+      if (o.unsupported)
+        return await fe(t, s, {
+          ...e.ssr,
+          dir: Ee(o.locale, r),
+          lang: o.locale,
+          locale: o.locale,
+          pathname: o.pathname
+        });
+      if (o.redirect) {
+        if (s.method !== "GET" && s.method !== "HEAD")
+          return J({ status: 400, title: "The locale URL is not canonical." });
+        const u = o.source === "cookie" || o.source === "accept-language";
+        if (u && !await qs(t, o.pathname))
+          return await Le(t, s, {
+            cacheStore: e.cacheStore,
+            onError: e.onError,
+            rateLimitStore: n,
+            renderPage: e.renderPage,
+            routePathname: o.pathname,
+            ssr: {
+              ...e.ssr,
+              dir: Ee(r.defaultLocale, r),
+              lang: r.defaultLocale,
+              locale: r.defaultLocale
+            }
+          });
+        const l = new Headers({ location: o.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 });
+      }
+      i = {
+        ...e.ssr,
+        dir: Ee(o.locale, r),
+        lang: o.locale,
+        locale: o.locale
+      };
+      const c = await Le(t, s, {
+        cacheStore: e.cacheStore,
+        locales: r,
+        onError: e.onError,
+        rateLimitStore: n,
+        renderPage: e.renderPage,
+        routePathname: o.pathname,
+        ssr: i
+      });
+      return Ks(c, s, o.locale, r), c;
+    }
+    return await Le(t, s, {
+      cacheStore: e.cacheStore,
+      onError: e.onError,
+      rateLimitStore: n,
+      renderPage: e.renderPage,
+      ssr: i
+    });
+  };
+}
+async function qs(e, t) {
+  const r = j(e.routes, t);
+  return r ? (await r.route.load()).GET?.kind === "page" : !0;
+}
+function Ks(e, t, r, n) {
+  const a = e.headers.get("location");
+  if (!a) return;
+  const s = new URL(t.url);
+  new URL(a, s).origin === s.origin && e.headers.set(
+    "location",
+    Mt(a, r, n, s.href)
+  );
+}
+async function Le(e, t, r = {
+  rateLimitStore: sr
+}) {
+  const n = new URL(t.url), a = r.routePathname ?? n.pathname, s = ro(n, r), i = U(t);
+  let o;
+  try {
+    o = j(e.routes, a);
+  } catch (c) {
+    if (!(c instanceof Be))
+      throw c;
+    const u = J({
+      instance: `${n.pathname}${n.search}`,
+      status: 400,
+      title: "Bad Request"
+    });
+    return i ? ee(u, ae) : u;
+  }
+  if (!o)
+    try {
+      const c = await fe(
+        e,
+        t,
+        s
+      );
+      return i ? ee(c, $e) : 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 Ys(
+      e,
+      t,
+      n,
+      o,
+      a,
+      r,
+      s
+    );
+    return i && !c.headers.has(M) ? ee(
+      c,
+      c.status === 404 ? $e : ae
+    ) : c;
+  } catch (c) {
+    const u = await oe(
+      e,
+      t,
+      c,
+      "middleware",
+      s
+    );
+    return i ? ee(u, ae) : u;
+  }
+}
+async function Ys(e, t, r, n, a, s, i) {
+  const o = await n.route.load();
+  if (t.method.toUpperCase() === "OPTIONS") {
+    const g = Ea(o, t);
+    if (g)
+      return g;
+  }
+  const c = oo(t.method);
+  if (!c)
+    return bt(o);
+  const u = io(o, c);
+  if (!u)
+    return bt(o);
+  const l = await ao(
+    e,
+    n.route,
+    o,
+    u
+  ), d = l.security, h = os(
+    d?.fetchMetadata,
+    t,
+    c
+  ), f = (g) => Xt(g, h.vary);
+  if (h.response)
+    return f(
+      B(
+        h.response,
+        ne(u),
+        t
+      )
+    );
+  const R = await Ya(d?.csrf, t);
+  if (R)
+    return f(
+      B(R, ne(u), t)
+    );
+  const w = await hs(
+    d?.rateLimit,
+    t,
+    s.rateLimitStore ?? sr
+  );
+  if (w)
+    return f(
+      B(
+        w,
+        ne(u),
+        t
+      )
+    );
+  const p = Ss(
+    d?.request,
+    t,
+    c
+  );
+  if (p)
+    return f(
+      B(
+        p,
+        ne(u),
+        t
+      )
+    );
+  t = vs(d?.request, t);
+  const P = {}, ge = to(s.cacheStore, s.ssr?.locale);
+  if (u.kind === "page") {
+    const g = {
+      locale: s.ssr?.locale,
+      path: n.path,
+      pathname: a,
+      request: t,
+      context: P,
+      search: r.searchParams,
+      url: r
+    }, ir = await vt(
+      e,
+      n.route
+    ), H = pe(l.document) ? _t() : void 0;
+    let y;
+    try {
+      y = await Et(ir, g, async () => {
+        try {
+          const m = await $t(
+            e,
+            a,
+            t,
+            void 0,
+            ge,
+            { locale: s.ssr?.locale, requestContext: P }
+          );
+          if (m.status !== "ready")
+            return await fe(e, t, {
+              ...i,
+              nonce: H
+            });
+          if (s.locales && s.ssr?.locale && (m.match.metadata = Zs(
+            m.match.metadata,
+            t,
+            a,
+            s.ssr.locale,
+            s.locales
+          )), U(t))
+            return Ge(m.match.data, {
+              document: Ue({
+                dir: s.ssr?.dir,
+                lang: s.ssr?.lang,
+                links: m.match.links,
+                metadata: m.match.metadata,
+                scripts: m.match.scripts,
+                title: s.ssr?.title
+              }),
+              locale: s.ssr?.locale
+            });
+          if (m.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 ?? gr)(m.match, {
+            ...s.ssr,
+            dev: s.dev,
+            nonce: H,
+            onStreamError: (ur) => {
+              s.onError?.(ur, {
+                pathname: r.pathname,
+                site: "page"
+              });
+            },
+            signal: t.signal
+          });
+        } catch (m) {
+          return m instanceof G ? te() : await oe(e, t, m, "page", {
+            ...i,
+            nonce: H
+          });
+        }
+      });
+    } catch (m) {
+      if (!(m instanceof G))
+        throw m;
+      y = te();
+    }
+    const cr = Y(l.document ?? {}, {
+      nonce: H,
+      request: t
+    });
+    for (const [m, Xe] of cr)
+      y.headers.set(m, Xe);
+    return H && y.headers.set("cache-control", "private, no-store"), f(y), c === "HEAD" ? (await y.body?.cancel(), new Response(null, {
+      headers: y.headers,
+      status: y.status
+    })) : y;
+  }
+  const Q = {
+    locale: s.ssr?.locale,
+    path: n.path,
+    pathname: a,
+    request: t,
+    context: P,
+    search: r.searchParams,
+    url: r
+  }, or = await vt(
+    e,
+    n.route
+  );
+  let X;
+  try {
+    X = await Et(or, Q, async () => {
+      try {
+        return u.kind === "not-found" && u.body === void 0 ? no(
+          await fe(e, t, i),
+          u.init
+        ) : await Ht(u, Q);
+      } catch (g) {
+        return g instanceof G ? te() : await oe(
+          e,
+          t,
+          g,
+          "route",
+          i
+        );
+      }
+    });
+  } catch (g) {
+    if (!(g instanceof G))
+      throw g;
+    X = te();
+  }
+  try {
+    return await Qs(X, ge, "mutation" in u && u.mutation === !0), f(
+      so(X, u, t, c)
+    );
+  } catch (g) {
+    return f(
+      await oe(
+        e,
+        t,
+        g,
+        "route",
+        i
+      )
+    );
+  }
+}
+function Zs(e, t, r, n, a) {
+  const s = t.url, i = (c) => new URL(Mt(r, c, a, s), s).href, o = a.supportedLocales.map((c) => ({
+    href: i(c),
+    hrefLang: c
+  }));
+  return a.xDefault && o.push({
+    href: i(a.xDefault),
+    hrefLang: "x-default"
+  }), wr(e, {
+    alternates: o,
+    canonical: i(n)
+  });
+}
+async function Qs(e, t, r) {
+  const n = e.headers.get(I);
+  if (e.headers.delete(I), !n || !r || e.status < 200 || e.status >= 400) return;
+  const a = Xs(n);
+  for (const s of a.keys) await t.invalidateKey(s);
+  a.tags.length > 0 && await t.invalidateTags(
+    a.tags.map((s) => ({ id: s }))
+  );
+}
+function Xs(e) {
+  let t;
+  try {
+    t = JSON.parse(decodeURIComponent(e));
+  } catch {
+    throw re();
+  }
+  if (!Nt(t) || t.version !== 1 || Object.keys(t).sort().join(",") !== "keys,tags,version" || !Array.isArray(t.keys) || !t.keys.every(eo) || !Array.isArray(t.tags) || !t.tags.every((n) => typeof n == "string"))
+    throw re();
+  return { keys: t.keys, tags: t.tags };
+}
+function eo(e) {
+  return Array.isArray(e) && e.every(Me);
+}
+function Me(e) {
+  return e === null || typeof e == "string" || typeof e == "boolean" ? !0 : typeof e == "number" ? Number.isFinite(e) : Array.isArray(e) ? e.every(Me) : Nt(e) && Object.values(e).every(Me);
+}
+function re() {
+  return new Error("Demiurge received invalid internal mutation invalidation metadata.");
+}
+function to(e, t) {
+  const r = e ? kt(e) : Ie();
+  if (!t) return r;
+  const n = (s) => ({ id: `demiurge:locale:${t}:${s}` }), a = (s) => [
+    { "demiurge:locale": t },
+    ...s
+  ];
+  return {
+    get: (s) => r.get(
+      s.locale === "neutral" ? s : {
+        ...s,
+        key: a(s.key),
+        tags: s.tags?.map((i) => n(i.id))
+      }
+    ),
+    invalidateKey: (s) => r.invalidateKey(a(s)),
+    invalidateTags: (s) => r.invalidateTags(
+      s.map((i) => n(i.id))
+    )
+  };
+}
+function ro(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 no(e, t) {
+  if (!t)
+    return e;
+  const r = new Headers(e.headers), n = new Headers(t.headers);
+  for (const [a, s] of n)
+    a !== "set-cookie" && r.set(a, s);
+  for (const a of n.getSetCookie())
+    r.append("set-cookie", a);
+  return new Response(e.body, {
+    headers: r,
+    status: t.status ?? e.status,
+    statusText: t.statusText ?? e.statusText
+  });
+}
+async function ao(e, t, r, n) {
+  const a = await Promise.all(
+    e.policies.filter(
+      (s) => A(s.fileSegments, t.fileSegments)
+    ).map((s) => s.load())
+  );
+  return le(
+    ...a.map((s) => s.policy),
+    r.policy,
+    {
+      security: !n || n.kind === "page" ? void 0 : n.security
+    }
+  );
+}
+async function vt(e, t) {
+  return (await Promise.all(
+    e.middlewares.filter(
+      (n) => A(n.fileSegments, t.fileSegments)
+    ).map((n) => n.load())
+  )).flatMap(
+    (n) => n.middleware ? [n.middleware] : []
+  );
+}
+async function Et(e, t, r) {
+  let n = -1;
+  async function a(s) {
+    if (s <= n)
+      throw new Error("Demiurge route middleware next() called multiple times.");
+    n = s;
+    const i = e[s];
+    return i ? await i(t, () => a(s + 1)) : await r();
+  }
+  return await a(0);
+}
+function so(e, t, r, n) {
+  const a = En(
+    B(e, t.cors, r),
+    t.timing
+  );
+  return n === "HEAD" ? new Response(null, {
+    headers: a.headers,
+    status: a.status,
+    statusText: a.statusText
+  }) : a;
+}
+function ne(e) {
+  return e.kind === "page" ? void 0 : e.cors;
+}
+function oo(e) {
+  const t = e.toUpperCase();
+  return ar.includes(t) ? t : null;
+}
+function io(e, t) {
+  return t === "HEAD" ? e.HEAD ?? e.GET : e[t];
+}
+function bt(e) {
+  return new Response(null, {
+    headers: {
+      allow: co(e).join(", ")
+    },
+    status: 405
+  });
+}
+function co(e) {
+  const t = ar.filter((r) => e[r]);
+  return e.GET && !t.includes("HEAD") && t.push("HEAD"), t;
+}
+export {
+  O as $,
+  Ie as A,
+  Ae as B,
+  rt as C,
+  Pt as D,
+  N as E,
+  Za as F,
+  vs as G,
+  rr as H,
+  Ao as I,
+  Xr as J,
+  An as K,
+  De as L,
+  Be as M,
+  kn as N,
+  Co as O,
+  To as P,
+  jr as Q,
+  G as R,
+  M as S,
+  Zr as T,
+  Qr as U,
+  $e as V,
+  ae as W,
+  Mn as X,
+  zo as Y,
+  ut as Z,
+  D as _,
+  Ls as a,
+  zt as a0,
+  Ft as a1,
+  Xt as a2,
+  wr as a3,
+  $a as a4,
+  yo as a5,
+  ss as a6,
+  kt as a7,
+  Yt as a8,
+  Ka as a9,
+  wo as aA,
+  No as aB,
+  E as aC,
+  dn as aD,
+  At as aE,
+  jo as aF,
+  Io as aG,
+  Uo as aH,
+  go as aI,
+  vo as aJ,
+  Do as aK,
+  Ht as aL,
+  Lo as aM,
+  ko as aN,
+  xo as aO,
+  Br as aP,
+  Yr as aQ,
+  me as aR,
+  T as aS,
+  qa as aa,
+  bo as ab,
+  Lr as ac,
+  dt as ad,
+  mo as ae,
+  Bo as af,
+  Wo as ag,
+  Eo as ah,
+  Es as ai,
+  Ya as aj,
+  os as ak,
+  hs as al,
+  Ss as am,
+  Oo as an,
+  So as ao,
+  _o as ap,
+  Po as aq,
+  $o as ar,
+  yr as as,
+  le as at,
+  ta as au,
+  po as av,
+  Ho as aw,
+  Fo as ax,
+  Mo as ay,
+  tr as az,
+  Ro as b,
+  Vo as c,
+  er as d,
+  an as e,
+  fe as f,
+  Ee as g,
+  Le as h,
+  Nt as i,
+  Go as j,
+  Y as k,
+  Mt as l,
+  ea as m,
+  Qe as n,
+  ao as o,
+  $t as p,
+  A as q,
+  sn as r,
+  F as s,
+  Gr as t,
+  he as u,
+  Ze as v,
+  j as w,
+  pe as x,
+  _t as y,
+  Ca as z
+};
+//# sourceMappingURL=testing-DueXbMo4.js.map