@demiurgejs/core 0.0.0 → 0.1.0

package/dist/chunks/testing-BBnJ5WUR.js

@@ -0,0 +1,2871 @@
+import { g as mt, h as ht, b as Le, r as pt } from "./ssr-O3d7Q73U.js";
+import { createElement as ee } from "react";
+import { renderToString as He } from "react-dom/server";
+import { jsxs as N, jsx as $ } from "react/jsx-runtime";
+function as(e) {
+  return e;
+}
+function cs(e, t = {}) {
+  return {
+    ...t,
+    href: e,
+    kind: "link",
+    rel: "preconnect"
+  };
+}
+function us(e, t) {
+  return {
+    ...t,
+    href: e,
+    kind: "link",
+    rel: "preload"
+  };
+}
+function ls(e) {
+  return {
+    href: e,
+    kind: "link",
+    rel: "modulepreload"
+  };
+}
+async function gt(e, t) {
+  const r = [];
+  for (const n of e) {
+    if (!n)
+      continue;
+    const s = typeof n == "function" ? await n(t) : n;
+    r.push(...s);
+  }
+  return wt(r).sort(yt);
+}
+function wt(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const r of e)
+    t.set(pe(r), {
+      ...t.get(pe(r)),
+      ...r
+    });
+  return [...t.values()];
+}
+function pe(e) {
+  return [
+    e.rel,
+    e.href,
+    e.as ?? "",
+    e.type ?? "",
+    e.crossOrigin ?? ""
+  ].join("\0");
+}
+function yt(e, t) {
+  return ge(e.rel) - ge(t.rel) || e.href.localeCompare(t.href);
+}
+function ge(e) {
+  return e === "preconnect" ? 0 : e === "preload" ? 1 : e === "modulepreload" ? 2 : 3;
+}
+function fs(e) {
+  return e;
+}
+function ds(e) {
+  return {
+    ...e,
+    kind: "meta"
+  };
+}
+function ms(e) {
+  return {
+    ...e,
+    kind: "link"
+  };
+}
+function hs(e) {
+  return {
+    kind: "structured-data",
+    value: e
+  };
+}
+function b(...e) {
+  const t = {
+    custom: [],
+    structuredData: []
+  };
+  for (const o of e)
+    o && St(t, o);
+  const r = Rt(t), n = t.description, s = bt(t.openGraph, r, n);
+  return {
+    canonical: t.canonical,
+    charset: "utf-8",
+    custom: t.custom,
+    description: n,
+    openGraph: s,
+    robots: t.robots,
+    structuredData: t.structuredData,
+    title: r,
+    viewport: "width=device-width, initial-scale=1"
+  };
+}
+function St(e, t) {
+  Et(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 Et(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 Rt(e) {
+  return e.title === void 0 ? e.titleDefault : e.titleFormat ? e.titleFormat(e.title) : e.title;
+}
+function bt(e, t, r) {
+  if (!(!e && !t && !r))
+    return {
+      ...t ? { title: t } : {},
+      ...r ? { description: r } : {},
+      ...e ?? {}
+    };
+}
+const Tt = /* @__PURE__ */ new Set([
+  "afterInteractive",
+  "beforeInteractive",
+  "module"
+]);
+function ps(e) {
+  return e;
+}
+function gs(e) {
+  const t = e.strategy ?? "afterInteractive";
+  if (!Tt.has(t))
+    throw new Error(
+      `Unsupported script strategy ${JSON.stringify(t)}. Demiurge 0.1 supports "beforeInteractive", "module", and "afterInteractive"; deferred, visibility-triggered, and worker loading require a future client script runtime.`
+    );
+  if (t === "module" && e.type && e.type !== "module")
+    throw new Error(
+      'The "module" script strategy cannot be combined with type="text/javascript".'
+    );
+  return {
+    ...e,
+    kind: "script",
+    strategy: t
+  };
+}
+async function vt(e, t) {
+  const r = [];
+  for (const n of e) {
+    if (!n)
+      continue;
+    const s = typeof n == "function" ? await n(t) : n;
+    r.push(...s);
+  }
+  return xt(r).sort(kt);
+}
+function xt(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const r of e)
+    t.set(we(r), {
+      ...t.get(we(r)),
+      ...r
+    });
+  return [...t.values()];
+}
+function we(e) {
+  return [
+    e.src,
+    e.type ?? "",
+    e.integrity ?? "",
+    e.strategy
+  ].join("\0");
+}
+function kt(e, t) {
+  return ye(e.strategy) - ye(t.strategy) || e.src.localeCompare(t.src);
+}
+function ye(e) {
+  return e === "beforeInteractive" ? 0 : e === "module" ? 1 : 2;
+}
+function Pt(e) {
+  if (typeof e == "string")
+    return e;
+  const t = Ct(Nt(
+    e.to,
+    "path" in e ? e.path : void 0
+  )), r = e.search === void 0 ? t.search : At(e.search), n = e.hash === void 0 ? t.hash : e.hash ? e.hash.startsWith("#") ? e.hash : `#${e.hash}` : "";
+  return `${t.pathname}${r}${n}`;
+}
+function Ct(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 At(e) {
+  if (!e)
+    return "";
+  if (typeof e == "string")
+    return e.startsWith("?") ? e : `?${e}`;
+  const r = (e instanceof URLSearchParams ? e : Dt(e)).toString();
+  return r ? `?${r}` : "";
+}
+function Dt(e) {
+  const t = new URLSearchParams();
+  for (const [r, n] of Object.entries(e)) {
+    const s = Array.isArray(n) ? n : [n];
+    for (const o of s)
+      o != null && t.append(r, String(o));
+  }
+  return t;
+}
+function Nt(e, t) {
+  return t ? e.replace(
+    /\[(\.\.\.)?([a-zA-Z_$][a-zA-Z0-9_$]*)\]/g,
+    (r, n, s) => {
+      const o = t[s];
+      if (o === void 0)
+        throw new Error(`Missing path value for "${s}" in route "${e}".`);
+      return n ? String(o).split("/").filter(Boolean).map((i) => encodeURIComponent(i)).join("/") : encodeURIComponent(String(o));
+    }
+  ) : e;
+}
+function ws(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "json",
+    security: t?.security,
+    timing: S(t?.timing),
+    value: e,
+    init: T(t)
+  };
+}
+function ys(e, t) {
+  return {
+    cors: t?.cors,
+    init: T(t),
+    kind: "jsonl",
+    lines: e,
+    security: t?.security,
+    timing: S(t?.timing)
+  };
+}
+function Ss(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "text",
+    security: t?.security,
+    timing: S(t?.timing),
+    value: e,
+    init: T(t)
+  };
+}
+function Es(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "html",
+    security: t?.security,
+    timing: S(t?.timing),
+    value: e,
+    init: T(t)
+  };
+}
+function Rs(e, t) {
+  const r = typeof t == "number" ? void 0 : t;
+  return {
+    cors: r?.cors,
+    kind: "redirect",
+    security: r?.security,
+    timing: S(r?.timing),
+    to: zt(e) ? Pt(e) : e,
+    init: typeof t == "number" ? { status: t } : T(t)
+  };
+}
+function bs(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "not-found",
+    security: t?.security,
+    timing: S(t?.timing),
+    body: e,
+    init: T(t)
+  };
+}
+function Ts(e, t) {
+  return {
+    cors: t?.cors,
+    kind: "response",
+    response: e,
+    security: t?.security,
+    timing: S(t?.timing)
+  };
+}
+function vs(e, t) {
+  return {
+    body: e,
+    cors: t?.cors,
+    init: T(t),
+    kind: "stream",
+    security: t?.security,
+    timing: S(t?.timing)
+  };
+}
+function xs(e, t) {
+  return {
+    cors: t?.cors,
+    events: e,
+    init: T(t),
+    kind: "sse",
+    security: t?.security,
+    timing: S(t?.timing)
+  };
+}
+function ks(...e) {
+  return e;
+}
+async function $t(e, t) {
+  switch (e.kind) {
+    case "json":
+      return new Response(JSON.stringify(await w(e.value, t)), {
+        ...e.init,
+        headers: V(
+          e.init?.headers,
+          "content-type",
+          "application/json; charset=utf-8"
+        )
+      });
+    case "jsonl":
+      return new Response(
+        Ot(await w(e.lines, t)),
+        {
+          ...e.init,
+          headers: j(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 w(e.value, t), {
+        ...e.init,
+        headers: V(
+          e.init?.headers,
+          "content-type",
+          "text/plain; charset=utf-8"
+        )
+      });
+    case "html":
+      return new Response(await w(e.value, t), {
+        ...e.init,
+        headers: V(
+          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 w(e.to, t))), new Response(null, {
+        ...e.init,
+        headers: r,
+        status: e.init?.status ?? 302
+      });
+    }
+    case "not-found":
+      return new Response(
+        e.body ? await w(e.body, t) : null,
+        {
+          ...e.init,
+          status: e.init?.status ?? 404
+        }
+      );
+    case "response":
+      return await w(e.response, t);
+    case "stream":
+      return new Response(
+        Lt(await w(e.body, t)),
+        {
+          ...e.init,
+          headers: j(e.init?.headers, {
+            "content-type": "application/octet-stream",
+            "x-accel-buffering": "no"
+          })
+        }
+      );
+    case "sse":
+      return new Response(
+        It(await w(e.events, t)),
+        {
+          ...e.init,
+          headers: j(e.init?.headers, {
+            "cache-control": "no-cache",
+            "content-type": "text/event-stream; charset=utf-8",
+            "x-accel-buffering": "no"
+          })
+        }
+      );
+  }
+}
+async function w(e, t) {
+  return typeof e != "function" ? e : await e(
+    t
+  );
+}
+function V(e, t, r) {
+  return j(e, { [t]: r });
+}
+function j(e, t) {
+  const r = new Headers(e);
+  for (const [n, s] of Object.entries(t))
+    r.has(n) || r.set(n, s);
+  return r;
+}
+function It(e) {
+  const t = new TextEncoder(), r = oe(e);
+  return new ReadableStream({
+    async pull(n) {
+      const s = await r.next();
+      if (s.done) {
+        n.close();
+        return;
+      }
+      n.enqueue(t.encode(Mt(s.value)));
+    },
+    async cancel() {
+      await r.return?.();
+    }
+  });
+}
+function Ot(e) {
+  const t = new TextEncoder(), r = oe(e);
+  return new ReadableStream({
+    async pull(n) {
+      const s = await r.next();
+      if (s.done) {
+        n.close();
+        return;
+      }
+      n.enqueue(t.encode(`${JSON.stringify(s.value)}
+`));
+    },
+    async cancel() {
+      await r.return?.();
+    }
+  });
+}
+function Lt(e) {
+  const t = new TextEncoder(), r = oe(e);
+  return new ReadableStream({
+    async pull(n) {
+      const s = await r.next();
+      if (s.done) {
+        n.close();
+        return;
+      }
+      n.enqueue(Ht(s.value, t));
+    },
+    async cancel() {
+      await r.return?.();
+    }
+  });
+}
+function Ht(e, t) {
+  return typeof e == "string" ? t.encode(e) : e;
+}
+function oe(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]() : Ut(e[Symbol.iterator]());
+}
+function Ut(e) {
+  return {
+    async next() {
+      return e.next();
+    },
+    async return() {
+      return e.return?.(), { done: !0, value: void 0 };
+    }
+  };
+}
+function Mt(e) {
+  if (typeof e == "string")
+    return jt(e);
+  const t = [];
+  if (e.comment !== void 0 && t.push(...C("", e.comment)), e.id !== void 0 && t.push(...C("id", e.id)), e.event !== void 0 && t.push(...C("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(...C("data", Ft(e.data))), `${t.join(`
+`)}
+
+`;
+}
+function jt(e) {
+  return `${C("data", e).join(`
+`)}
+
+`;
+}
+function C(e, t) {
+  return t.split(/\r\n|\r|\n/).map(
+    (r) => e ? `${e}: ${r}` : `: ${r}`
+  );
+}
+function Ft(e) {
+  return typeof e == "string" ? e : JSON.stringify(e);
+}
+function zt(e) {
+  return typeof e == "object" && e !== null && !(e instanceof URL) && "to" in e;
+}
+function T(e) {
+  if (!e)
+    return;
+  const {
+    cors: t,
+    security: r,
+    timing: n,
+    ...s
+  } = e;
+  return s;
+}
+function qt(e, t) {
+  if (!t?.length)
+    return e;
+  const r = new Headers(e.headers), n = Wt(t), s = r.get("server-timing");
+  return r.set(
+    "server-timing",
+    s ? `${s}, ${n}` : n
+  ), new Response(e.body, {
+    headers: r,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+function Wt(e) {
+  return e.map(Bt).join(", ");
+}
+function S(e) {
+  if (e)
+    return Array.isArray(e) ? e : [e];
+}
+function Bt(e) {
+  if (!Gt(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=${_t(e.duration)}`);
+  }
+  return e.description !== void 0 && t.push(`desc="${Vt(e.description)}"`), t.join(";");
+}
+function Gt(e) {
+  return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(e);
+}
+function _t(e) {
+  return Number.isInteger(e), String(e);
+}
+function Vt(e) {
+  return e.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+const Kt = [
+  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
+], Jt = {
+  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"
+}, Yt = new Set(Kt);
+class Ue extends Error {
+  detail;
+  extensions;
+  headers;
+  status;
+  title;
+  type;
+  constructor(t, r = {}, n = {}) {
+    Zt(t);
+    const s = typeof r == "string" ? { detail: r } : r, {
+      detail: o,
+      title: i = Jt[t],
+      type: a = "about:blank",
+      ...c
+    } = s;
+    super(o ?? i, { cause: n.cause }), this.name = "HttpError", this.detail = o, this.extensions = Object.freeze({ ...c }), this.headers = new Headers(n.headers), this.status = t, this.title = i, this.type = a;
+  }
+}
+function Ps(e, t, r) {
+  return new Ue(e, t, r);
+}
+function ie(e) {
+  return e instanceof Ue;
+}
+function Zt(e) {
+  if (!Yt.has(e))
+    throw new RangeError(
+      `HTTP error status must be a standard 4xx or 5xx status; received ${JSON.stringify(e)}.`
+    );
+}
+const Se = ["build", "private", "public"], Qt = {
+  app: "demiurge-memory",
+  environment: "local",
+  schemaVersion: 1
+}, Xt = 1e4, er = 3e4;
+function Cs(e) {
+  return (...t) => ({
+    fn: () => e.fn(...t),
+    key: e.key(...t),
+    scope: e.scope,
+    staleWhileRevalidate: e.staleWhileRevalidate,
+    tags: e.tags?.(...t),
+    ttl: e.ttl
+  });
+}
+function As(e) {
+  return { id: e };
+}
+function Ds(e) {
+  return e;
+}
+function Me(e) {
+  const t = e.now ?? Date.now, r = sr(e.refreshLeaseTtl), n = je(e.namespace), s = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+  return {
+    async get(i) {
+      const a = i.scope ?? "request";
+      if (a === "none")
+        return await i.fn();
+      const c = Re(i.key);
+      if (a === "request")
+        return await nr(s, c, i, t);
+      const u = be(n, a, c), l = (i.tags ?? []).map(
+        (g) => Te(n, a, te(g))
+      ), d = await e.store.get(u);
+      if (d && (d.expiresAt === null || d.expiresAt > t()))
+        return d.value;
+      if (d && or(d, t())) {
+        const g = ir(e.store), h = globalThis.crypto.randomUUID();
+        if (await g.acquireRefreshLease(
+          u,
+          h,
+          t() + r
+        )) {
+          const v = ar({
+            key: u,
+            now: t,
+            onBackgroundError: e.onBackgroundError,
+            refreshStore: g,
+            request: i,
+            tags: l,
+            token: h
+          });
+          e.waitUntil?.(v);
+        }
+        return d.value;
+      }
+      d && await e.store.delete(u);
+      const m = o.get(u);
+      if (m)
+        return await m.promise;
+      const f = { invalidated: !1 }, k = Promise.resolve().then(i.fn).then(async (g) => (f.invalidated || await e.store.set(u, {
+        expiresAt: Fe(t(), i.ttl),
+        staleUntil: ze(
+          t(),
+          i.ttl,
+          i.staleWhileRevalidate
+        ),
+        tags: l,
+        value: g
+      }), g)), H = {
+        promise: k,
+        state: f,
+        tags: l
+      };
+      o.set(u, H);
+      try {
+        return await k;
+      } finally {
+        o.get(u) === H && o.delete(u);
+      }
+    },
+    async invalidateKey(i) {
+      const a = Re(i), c = s.delete(a);
+      let u = !1;
+      const l = await Promise.all(
+        Se.map((d) => {
+          const m = be(n, d, a), f = o.get(m);
+          return f && (f.state.invalidated = !0, u = !0), e.store.delete(m);
+        })
+      );
+      return c || u || l.some(Boolean);
+    },
+    async invalidateTags(i) {
+      const a = i.map(te), c = cr(
+        s,
+        new Set(a)
+      ), u = new Set(
+        Se.flatMap(
+          (m) => a.map((f) => Te(n, m, f))
+        )
+      );
+      let l = 0;
+      for (const m of o.values())
+        !m.state.invalidated && m.tags.some((f) => u.has(f)) && (m.state.invalidated = !0, l += 1);
+      const d = await e.store.invalidateTags([...u]);
+      return c + l + d;
+    }
+  };
+}
+function ae(e = {}) {
+  const t = e.now ?? Date.now;
+  return Me({
+    namespace: Qt,
+    now: t,
+    onBackgroundError: e.onBackgroundError,
+    refreshLeaseTtl: e.refreshLeaseTtl,
+    store: tr({
+      maximumEntries: e.maximumEntries,
+      now: t
+    }),
+    waitUntil: e.waitUntil
+  });
+}
+function tr(e = {}) {
+  const t = e.entries ?? /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), n = e.maximumEntries ?? Xt, s = e.now ?? Date.now;
+  if (!Number.isSafeInteger(n) || n <= 0)
+    throw new Error(
+      "Demiurge memory cache maximumEntries must be a positive integer."
+    );
+  K(t, r, s()), rr(t, n);
+  let o = J(t);
+  return {
+    acquireRefreshLease(i, a, c) {
+      const u = s(), l = r.get(i);
+      return l && l.expiresAt > u ? !1 : (r.set(i, { expiresAt: c, token: a }), !0);
+    },
+    delete(i) {
+      return r.delete(i), t.delete(i);
+    },
+    get(i) {
+      return s() >= o && (K(t, r, s()), o = J(t)), t.get(i);
+    },
+    invalidateTags(i) {
+      const a = new Set(i);
+      let c = 0;
+      for (const [u, l] of t)
+        l.tags.some((d) => a.has(d)) && (t.delete(u), r.delete(u), c += 1);
+      return c;
+    },
+    publishRefresh(i, a, c) {
+      const u = r.get(i);
+      return !u || u.token !== a || u.expiresAt <= s() ? !1 : (Ee(
+        t,
+        r,
+        n,
+        i,
+        c
+      ), r.delete(i), c.staleUntil !== null && (o = Math.min(o, c.staleUntil)), !0);
+    },
+    releaseRefreshLease(i, a) {
+      r.get(i)?.token === a && r.delete(i);
+    },
+    set(i, a) {
+      const c = s();
+      c >= o && (K(t, r, c), o = J(t)), r.delete(i), Ee(
+        t,
+        r,
+        n,
+        i,
+        a
+      ), a.staleUntil !== null && (o = Math.min(o, a.staleUntil));
+    }
+  };
+}
+function K(e, t, r) {
+  for (const [n, s] of e)
+    s.staleUntil !== null && s.staleUntil <= r && (e.delete(n), t.delete(n));
+}
+function Ee(e, t, r, n, s) {
+  if (!e.has(n) && e.size >= r)
+    for (; e.size >= r; ) {
+      const o = e.keys().next().value;
+      if (o === void 0)
+        break;
+      e.delete(o), t.delete(o);
+    }
+  e.set(n, s);
+}
+function rr(e, t) {
+  for (; e.size > t; ) {
+    const r = e.keys().next().value;
+    if (r === void 0)
+      return;
+    e.delete(r);
+  }
+}
+function J(e) {
+  let t = Number.POSITIVE_INFINITY;
+  for (const r of e.values())
+    r.staleUntil !== null && (t = Math.min(t, r.staleUntil));
+  return t;
+}
+function je(e) {
+  const t = Y("app", e.app), r = Y(
+    "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 = Y(
+    "schemaVersion",
+    String(e.schemaVersion)
+  );
+  return `${t}:${r}:${n}`;
+}
+function Ns(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 I(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 Re(e) {
+  return re(e, /* @__PURE__ */ new Set());
+}
+function te(e) {
+  return e.id;
+}
+async function nr(e, t, r, n) {
+  const s = e.get(t);
+  if (s && s.expiresAt > n())
+    return await s.value;
+  const o = Promise.resolve().then(r.fn), i = {
+    expiresAt: n() + I(r.ttl),
+    tags: (r.tags ?? []).map(te),
+    value: o
+  };
+  e.set(t, i);
+  try {
+    return await o;
+  } catch (a) {
+    throw e.get(t) === i && e.delete(t), a;
+  }
+}
+function be(e, t, r) {
+  return `${e}:${t}:key:${r}`;
+}
+function Te(e, t, r) {
+  return `${e}:${t}:tag:${r}`;
+}
+function Fe(e, t) {
+  const r = I(t);
+  return Number.isFinite(r) ? e + r : null;
+}
+function ze(e, t, r) {
+  const n = I(t);
+  if (!Number.isFinite(n)) {
+    if (r !== void 0)
+      throw new Error(
+        "Demiurge staleWhileRevalidate requires a finite cache ttl."
+      );
+    return null;
+  }
+  return e + n + I(r ?? 0);
+}
+function sr(e) {
+  const t = I(e ?? er);
+  if (!Number.isFinite(t) || t <= 0)
+    throw new Error(
+      "Demiurge cache refreshLeaseTtl must be a positive finite duration."
+    );
+  return t;
+}
+function or(e, t) {
+  return e.expiresAt !== null && e.expiresAt <= t && (e.staleUntil === null || e.staleUntil > t);
+}
+function ir(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 ar(e) {
+  try {
+    const t = await e.request.fn(), r = e.now();
+    await e.refreshStore.publishRefresh(e.key, e.token, {
+      expiresAt: Fe(r, e.request.ttl),
+      staleUntil: ze(
+        r,
+        e.request.ttl,
+        e.request.staleWhileRevalidate
+      ),
+      tags: e.tags,
+      value: t
+    });
+  } catch (t) {
+    e.onBackgroundError ? e.onBackgroundError(t) : console.error("Demiurge stale cache refresh failed.", t);
+  } finally {
+    await e.refreshStore.releaseRefreshLease(e.key, e.token);
+  }
+}
+function Y(e, t) {
+  const r = [...t].some((n) => {
+    const s = n.charCodeAt(0);
+    return s <= 31 || s === 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 cr(e, t) {
+  let r = 0;
+  for (const [n, s] of e)
+    s.tags.some((o) => t.has(o)) && (e.delete(n), r += 1);
+  return r;
+}
+function re(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), a = [
+      ...Array.from({ length: e.length }, (u, l) => String(l)),
+      "length"
+    ];
+    if (i.length !== a.length || i.some((u, l) => u !== a[l]) || a.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) => re(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 a = Object.getOwnPropertyDescriptor(e, i);
+    return !a?.enumerable || !("value" in a);
+  }))
+    throw new Error(
+      "Demiurge cache key objects require enumerable string data properties."
+    );
+  const s = e, o = `{${Object.keys(s).sort().map(
+    (i) => `${JSON.stringify(i)}:${re(s[i], t)}`
+  ).join(",")}}`;
+  return t.delete(e), o;
+}
+function ur(e) {
+  const t = {
+    fallbacks: {
+      error: [],
+      loading: [],
+      notFound: []
+    },
+    routes: [],
+    layouts: [],
+    middlewares: [],
+    policies: []
+  };
+  for (const [r, n] of Object.entries(e)) {
+    const s = r.replace(/^\/src\/routes\//, "").replace(/^\.\/routes\//, "").replace(/\.tsx?$/, "").split("/"), o = s.at(-1);
+    if (o === "@layout") {
+      t.layouts.push({
+        file: r,
+        fileSegments: s.slice(0, -1),
+        segments: R(s.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (o === "@policy") {
+      t.policies.push({
+        file: r,
+        fileSegments: s.slice(0, -1),
+        segments: R(s.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (o === "@middleware") {
+      t.middlewares.push({
+        file: r,
+        fileSegments: s.slice(0, -1),
+        segments: R(s.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (o === "@loading") {
+      t.fallbacks.loading.push({
+        file: r,
+        fileSegments: s.slice(0, -1),
+        segments: R(s.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (o === "@error") {
+      t.fallbacks.error.push({
+        file: r,
+        fileSegments: s.slice(0, -1),
+        segments: R(s.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    if (o === "@not-found") {
+      t.fallbacks.notFound.push({
+        file: r,
+        fileSegments: s.slice(0, -1),
+        segments: R(s.slice(0, -1)),
+        load: n
+      });
+      continue;
+    }
+    t.routes.push({
+      file: r,
+      fileSegments: s,
+      segments: R(s),
+      score: kr(s),
+      load: n
+    });
+  }
+  return lr(t.routes), t.routes.sort(mr), 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 lr(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 s = r.segments.map(fr).join("/"), o = t.get(s);
+    if (o)
+      throw new Error(
+        `Ambiguous routes "${o.file}" and "${r.file}" have the same runtime shape and both match "${dr(r.segments)}".`
+      );
+    t.set(s, r);
+  }
+}
+function fr(e) {
+  return e.startsWith("*") ? "*" : e.startsWith(":") ? ":" : `=${e}`;
+}
+function dr(e) {
+  return e.length === 0 ? "/" : `/${e.map((t) => t.startsWith(":") || t.startsWith("*") ? "example" : t).join("/")}`;
+}
+function mr(e, t) {
+  const r = Math.max(e.segments.length, t.segments.length);
+  for (let n = 0; n < r; n += 1) {
+    const s = ve(t.segments[n]) - ve(e.segments[n]);
+    if (s !== 0)
+      return s;
+  }
+  return e.file.localeCompare(t.file);
+}
+function ve(e) {
+  return e === void 0 ? 4 : e.startsWith("*") ? 1 : e.startsWith(":") ? 2 : 3;
+}
+async function qe(e, t, r = new Request(`http://demiurge.local${t}`), n, s = ae(), o = {}) {
+  const i = o.documentContributions ?? !0, a = L(e.routes, t);
+  if (!a)
+    return {
+      ...await ne(e, t, {
+        documentContributions: i
+      }),
+      status: "not-found"
+    };
+  const c = e.layouts.filter(
+    (f) => B(f.fileSegments, a.route.fileSegments)
+  ), u = await a.route.load();
+  if (!u.GET || u.GET.kind !== "page")
+    return {
+      ...await ne(e, t, {
+        fallback: ce(
+          e.fallbacks.notFound,
+          a.route
+        ),
+        documentContributions: i,
+        layouts: c
+      }),
+      status: "not-found"
+    };
+  const l = u.GET.layout === !1 ? [] : await Promise.all(c.map((f) => f.load())), d = new URL(r.url), m = {
+    cache: s,
+    path: a.path,
+    pathname: t,
+    request: r,
+    search: d.searchParams,
+    url: d
+  };
+  return {
+    status: "ready",
+    match: {
+      data: u.GET.data && !n?.hasData ? await u.GET.data(m) : n?.data,
+      error: await We(e, a.route),
+      links: i ? await gt(
+        [
+          ...l.map((f) => f.links),
+          u.links
+        ],
+        m
+      ) : [],
+      page: u.GET.view,
+      layouts: l.map(
+        (f) => f.default
+      ),
+      metadata: i ? b(
+        ...l.map((f) => f.metadata),
+        u.metadata
+      ) : b(),
+      path: a.path,
+      pathname: t,
+      render: u.GET.render,
+      scripts: i ? await vt(
+        [
+          ...l.map((f) => f.scripts),
+          u.scripts
+        ],
+        m
+      ) : []
+    }
+  };
+}
+async function $s(e) {
+  const t = ae(), r = [];
+  for (const n of e.routes) {
+    const s = await n.load();
+    if (!s.GET || s.GET.kind !== "page")
+      continue;
+    if (s.GET.render.mode !== "static")
+      throw new Error(
+        `Page route "${n.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 o = Er(n.segments);
+    if (br(n.segments).length === 0) {
+      r.push({
+        file: n.file,
+        path: {},
+        pattern: o,
+        pathname: o
+      });
+      continue;
+    }
+    if (!s.paths)
+      throw new Error(
+        `Dynamic static route "${n.file}" must export paths for "${o}".`
+      );
+    const a = await s.paths({ cache: t });
+    for (const c of a) {
+      const u = Tr(n, o, c);
+      r.push({
+        file: n.file,
+        path: u,
+        pattern: o,
+        pathname: xr(n.segments, u)
+      });
+    }
+  }
+  return r;
+}
+async function Is(e, t) {
+  const r = L(e.routes, t);
+  if (r)
+    return await yr(
+      ce(e.fallbacks.loading, r.route)
+    );
+}
+async function hr(e, t) {
+  let r;
+  try {
+    r = L(e.routes, t);
+  } catch (n) {
+    if (!(n instanceof fe)) throw n;
+    return await le(
+      e.fallbacks.error.find(
+        (s) => s.fileSegments.length === 0
+      )
+    );
+  }
+  return r ? await We(e, r.route) : await pr(e, t);
+}
+async function We(e, t) {
+  return await le(
+    ce(e.fallbacks.error, t)
+  );
+}
+async function pr(e, t) {
+  return await le(
+    Be(e.fallbacks.error, t)
+  );
+}
+async function ne(e, t, r = {}) {
+  const s = await (r.fallback ?? Be(e.fallbacks.notFound, t))?.load(), o = s?.default, i = r.documentContributions ?? !0;
+  if (s?.layout === !1)
+    return {
+      layouts: [],
+      metadata: i ? b(s.metadata) : b(),
+      notFound: o,
+      pathname: t
+    };
+  const a = r.layouts ?? gr(e, t);
+  try {
+    const c = await Promise.all(
+      a.map((u) => u.load())
+    );
+    return {
+      layouts: c.map(
+        (u) => u.default
+      ),
+      metadata: i ? b(
+        ...c.map((u) => u.metadata),
+        s?.metadata
+      ) : b(),
+      notFound: o,
+      pathname: t
+    };
+  } catch (c) {
+    return r.onLayoutError?.(c), {
+      layouts: [],
+      metadata: i ? b(s?.metadata) : b(),
+      notFound: o,
+      pathname: t
+    };
+  }
+}
+function gr(e, t) {
+  const r = _(t);
+  return e.layouts.filter(
+    (n) => !n.fileSegments.some(G) && ue(n.segments, r)
+  );
+}
+function wr(e, t) {
+  const r = _(t);
+  return e.policies.filter(
+    (n) => !n.fileSegments.some(G) && ue(n.segments, r)
+  );
+}
+function ce(e, t) {
+  for (let r = e.length - 1; r >= 0; r -= 1) {
+    const n = e[r];
+    if (B(n.fileSegments, t.fileSegments))
+      return n;
+  }
+}
+function Be(e, t) {
+  const r = _(t);
+  for (let n = e.length - 1; n >= 0; n -= 1) {
+    const s = e[n];
+    if (!s.fileSegments.some(G) && ue(s.segments, r))
+      return s;
+  }
+}
+function ue(e, t) {
+  return e.every((r, n) => r.startsWith("*") ? t.length > n : r.startsWith(":") ? !!t[n] : t[n] === r);
+}
+async function yr(e) {
+  return e ? (await e.load()).default : void 0;
+}
+async function le(e) {
+  return e ? (await e.load()).default : void 0;
+}
+function L(e, t) {
+  const r = _(t);
+  for (const n of e) {
+    const s = Sr(n.segments, r);
+    if (s)
+      return { route: n, path: s };
+  }
+  return null;
+}
+const Os = qe, Ls = L;
+function Sr(e, t) {
+  const r = {};
+  for (let n = 0; n < e.length; n += 1) {
+    const s = e[n], o = t[n];
+    if (s?.startsWith("*"))
+      return r[s.slice(1)] = t.slice(n).join("/"), r;
+    if (!o)
+      return null;
+    if (s.startsWith(":")) {
+      r[s.slice(1)] = o;
+      continue;
+    }
+    if (s !== o)
+      return null;
+  }
+  return e.length === t.length ? r : null;
+}
+function Hs(e, t) {
+  return e.every(
+    (r, n) => t[n] === r
+  );
+}
+function B(e, t) {
+  return e.every(
+    (r, n) => t[n] === r
+  );
+}
+function R(e) {
+  return e.flatMap((t) => G(t) ? [] : t === "index" ? [] : t.startsWith("[...") && t.endsWith("]") ? [`*${t.slice(4, -1)}`] : t.startsWith("[") && t.endsWith("]") ? [`:${t.slice(1, -1)}`] : [t]);
+}
+function G(e) {
+  return e.startsWith("(") && e.endsWith(")");
+}
+function Er(e) {
+  return e.length === 0 ? "/" : `/${e.map(Rr).join("/")}`;
+}
+function Rr(e) {
+  return e.startsWith("*") ? `[...${e.slice(1)}]` : e.startsWith(":") ? `[${e.slice(1)}]` : e;
+}
+function br(e) {
+  return e.flatMap((t) => t.startsWith(":") || t.startsWith("*") ? [t.slice(1)] : []);
+}
+function Tr(e, t, r) {
+  const n = {};
+  for (const s of e.segments) {
+    if (!s.startsWith(":") && !s.startsWith("*"))
+      continue;
+    const o = s.slice(1), i = r[o];
+    if (i === void 0)
+      throw new Error(
+        `Static paths for "${e.file}" must include "${o}" for "${t}".`
+      );
+    if (!vr(i))
+      throw new Error(
+        `Static path "${o}" for "${e.file}" must be a string, number, or boolean.`
+      );
+    n[o] = String(i);
+  }
+  return n;
+}
+function vr(e) {
+  return typeof e == "string" || typeof e == "number" || typeof e == "boolean";
+}
+function xr(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 kr(e) {
+  return R(e).reduce((t, r) => r.startsWith("*") ? t : r.startsWith(":") ? t + 1 : t + 2, 0);
+}
+function _(e) {
+  return e.replace(/^\/|\/$/g, "").split("/").filter(Boolean).map((t) => {
+    try {
+      return decodeURIComponent(t);
+    } catch (r) {
+      throw new fe(e, { cause: r });
+    }
+  });
+}
+class fe extends URIError {
+  pathname;
+  constructor(t, r) {
+    super(
+      `Malformed percent encoding in URL pathname ${JSON.stringify(t)}.`,
+      r
+    ), this.name = "MalformedPathnameError", this.pathname = t;
+  }
+}
+const x = "x-demiurge-navigation", Pr = "data", Cr = "data", Z = "error", xe = "not-found";
+function Ge(e) {
+  return e.headers.get(x) === Pr;
+}
+function Ar(e) {
+  return Response.json(
+    { data: e, hasData: !0 },
+    {
+      headers: {
+        "cache-control": "no-store",
+        [x]: Cr,
+        vary: x
+      }
+    }
+  );
+}
+function U(e, t) {
+  return e.headers.set("cache-control", "no-store"), e.headers.set(x, t), e.headers.append("vary", x), e;
+}
+function ke({ pathname: e }) {
+  return /* @__PURE__ */ N("main", { children: [
+    /* @__PURE__ */ $("h1", { children: "404" }),
+    /* @__PURE__ */ N("p", { children: [
+      "No route matched ",
+      e,
+      "."
+    ] })
+  ] });
+}
+function Pe({ status: e }) {
+  return /* @__PURE__ */ N("main", { children: [
+    /* @__PURE__ */ $("h1", { children: e }),
+    /* @__PURE__ */ $("p", { children: "Something went wrong." })
+  ] });
+}
+function Dr({ error: e, pathname: t, status: r }) {
+  const { message: n, name: s, stack: o } = _e(e);
+  return /* @__PURE__ */ N("main", { children: [
+    /* @__PURE__ */ N("h1", { children: [
+      r,
+      " ",
+      s,
+      " at ",
+      t
+    ] }),
+    /* @__PURE__ */ $("p", { children: n }),
+    o ? /* @__PURE__ */ $("pre", { children: o }) : null
+  ] });
+}
+function _e(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 O = "{nonce}", Ve = {
+  baseUri: ["'self'"],
+  connectSrc: ["'self'"],
+  defaultSrc: ["'self'"],
+  fontSrc: ["'self'"],
+  formAction: ["'self'"],
+  frameAncestors: ["'none'"],
+  imgSrc: ["'self'", "data:", "blob:"],
+  objectSrc: ["'none'"],
+  scriptSrc: [`'nonce-${O}'`, "'strict-dynamic'"],
+  styleSrc: ["'self'", `'nonce-${O}'`],
+  upgradeInsecureRequests: !0
+}, Nr = {
+  ...Ve,
+  scriptSrc: ["'self'"],
+  styleSrc: ["'self'"]
+}, Ce = {
+  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
+  }
+}, $r = {
+  contentTypeOptions: "nosniff",
+  crossOriginResourcePolicy: "same-origin",
+  referrerPolicy: "strict-origin-when-cross-origin"
+}, P = {
+  api(e = {}) {
+    return A(
+      {
+        headers: $r
+      },
+      e
+    );
+  },
+  preset(e, t = {}) {
+    return e === "api" ? P.api(t) : e === "cross-origin-isolated" ? P.crossOriginIsolated(t) : e === "static" ? P.static(t) : P.strict(t);
+  },
+  static(e = {}) {
+    return A(
+      {
+        csp: Nr,
+        headers: Ce
+      },
+      e
+    );
+  },
+  strict(e = {}) {
+    return A(
+      {
+        csp: Ve,
+        headers: Ce
+      },
+      e
+    );
+  },
+  crossOriginIsolated(e = {}) {
+    return A(
+      P.strict({
+        headers: {
+          crossOriginEmbedderPolicy: "require-corp",
+          crossOriginOpenerPolicy: "same-origin"
+        }
+      }),
+      e
+    );
+  }
+};
+function Us(e) {
+  return e;
+}
+function Ms(e) {
+  return e;
+}
+function Ir(...e) {
+  return e.reduce((t, r) => r ? A(t, r) : t, {});
+}
+function Ke(...e) {
+  return e.reduce((t, r) => r ? {
+    document: Ir(t.document, r.document),
+    security: Or(t.security, r.security)
+  } : t, {});
+}
+function Or(...e) {
+  return e.reduce((t, r) => r ? {
+    csrf: r.csrf ?? t.csrf,
+    rateLimit: r.rateLimit ?? t.rateLimit,
+    request: Qe(t.request, r.request)
+  } : t, {});
+}
+async function js(e, t = "sha256") {
+  const r = await globalThis.crypto.subtle.digest(
+    Jr(t),
+    new TextEncoder().encode(e)
+  );
+  return `'${t}-${Yr(new Uint8Array(r))}'`;
+}
+function Je(e, t = {}) {
+  Gr(e);
+  const r = new Headers(), n = e.csp !== !1 && e.csp ? qr(e.csp, t) : void 0, s = Fr(e.trustedTypes), o = e.trustedTypes ? e.trustedTypes.mode === "report-only" : !1;
+  return y(
+    r,
+    "content-security-policy",
+    q(n, o ? void 0 : s)
+  ), y(
+    r,
+    "content-security-policy-report-only",
+    o ? q(s, Xe(e.csp)) : void 0
+  ), jr(r, e.headers, t), r;
+}
+function Ye(e) {
+  return !e || !e.csp ? !1 : de(e.csp).some(
+    ([, t]) => Array.isArray(t) && t.some((r) => r.includes(O))
+  );
+}
+function Ze() {
+  const e = new Uint8Array(16);
+  return globalThis.crypto.getRandomValues(e), btoa(String.fromCharCode(...e));
+}
+function A(e, t) {
+  return {
+    csp: Hr(e.csp, t.csp),
+    headers: Lr(e.headers, t.headers),
+    trustedTypes: t.trustedTypes ?? e.trustedTypes
+  };
+}
+function Lr(e, t) {
+  const r = Qe(e, t);
+  return !r || t?.reportingEndpoints === !1 || e?.reportingEndpoints && t?.reportingEndpoints && (r.reportingEndpoints = {
+    ...e.reportingEndpoints,
+    ...t.reportingEndpoints
+  }), r;
+}
+function Qe(e, t) {
+  return t ? {
+    ...e ?? {},
+    ...t
+  } : e;
+}
+function Hr(e, t) {
+  if (t === !1)
+    return !1;
+  if (!t)
+    return e;
+  if (!e)
+    return t;
+  const r = {
+    ...e,
+    ...t
+  };
+  for (const [n, s] of de(t)) {
+    const o = e[n];
+    n !== "reportUri" && Array.isArray(o) && Array.isArray(s) && Mr(r, n, Ur([...o, ...s]));
+  }
+  return e.reportUri && t.reportUri && (r.reportUri = [.../* @__PURE__ */ new Set([...e.reportUri, ...t.reportUri])]), r;
+}
+function Ur(e) {
+  return [...new Set(e)];
+}
+function Mr(e, t, r) {
+  t === "reportTo" || t === "reportUri" || t === "upgradeInsecureRequests" || (e[t] = r);
+}
+function jr(e, t, r) {
+  t && (y(e, "referrer-policy", t.referrerPolicy), y(e, "x-content-type-options", t.contentTypeOptions), y(e, "cross-origin-opener-policy", t.crossOriginOpenerPolicy), y(e, "cross-origin-embedder-policy", t.crossOriginEmbedderPolicy), y(e, "cross-origin-resource-policy", t.crossOriginResourcePolicy), y(e, "permissions-policy", t.permissionsPolicy), y(
+    e,
+    "reporting-endpoints",
+    Wr(t.reportingEndpoints)
+  ), t.strictTransportSecurity && (!r.request || new URL(r.request.url).protocol === "https:") && e.set(
+    "strict-transport-security",
+    zr(t.strictTransportSecurity)
+  ));
+}
+function Fr(e) {
+  if (!e)
+    return;
+  const t = [];
+  return e.requireFor?.includes("script") && t.push("require-trusted-types-for 'script'"), e.policies.length > 0 && t.push(`trusted-types ${e.policies.join(" ")}`), q(...t);
+}
+function q(...e) {
+  const t = e.filter((r) => r);
+  return t.length > 0 ? t.join("; ") : void 0;
+}
+function y(e, t, r) {
+  r && e.set(t, r);
+}
+function zr(e) {
+  const t = [`max-age=${e.maxAge}`];
+  return e.includeSubDomains && t.push("includeSubDomains"), e.preload && t.push("preload"), t.join("; ");
+}
+function qr(e, t) {
+  const r = [];
+  for (const [s, o] of de(e)) {
+    if (s === "reportTo" || s === "reportUri" || o === !1 || o === void 0)
+      continue;
+    const i = Kr(s);
+    if (o === !0) {
+      r.push(i);
+      continue;
+    }
+    r.push(`${i} ${Vr(o, t).join(" ")}`);
+  }
+  const n = Xe(e);
+  return n && r.push(n), r.join("; ");
+}
+function Xe(e) {
+  if (!e)
+    return;
+  const t = [];
+  return e.reportUri?.length && t.push(`report-uri ${e.reportUri.join(" ")}`), e.reportTo && t.push(`report-to ${e.reportTo}`), q(...t);
+}
+function Wr(e) {
+  if (e)
+    return Object.entries(e).sort(([t], [r]) => t.localeCompare(r)).map(([t, r]) => `${t}="${Br(r)}"`).join(", ");
+}
+function Br(e) {
+  return e.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function Gr(e) {
+  const t = e.headers?.reportingEndpoints;
+  if (t) {
+    const n = Object.entries(t);
+    if (n.length === 0)
+      throw new Error("Demiurge Reporting-Endpoints requires at least one endpoint.");
+    for (const [s, o] of n)
+      Ae(s), De(o, `Reporting-Endpoints member ${JSON.stringify(s)}`);
+  }
+  const r = e.csp || void 0;
+  if (r?.reportTo && (Ae(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.`
+    );
+  for (const n of r?.reportUri ?? [])
+    De(n, "CSP report-uri target");
+}
+function Ae(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 De(e, t) {
+  if (!_r(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 _r(e) {
+  return /^[\x20-\x7e]+$/.test(e);
+}
+function de(e) {
+  return Object.entries(e);
+}
+function Vr(e, t) {
+  return e.map((r) => {
+    if (!r.includes(O))
+      return r;
+    if (!t.nonce)
+      throw new Error("Demiurge security policy requires a CSP nonce.");
+    return r.replaceAll(O, t.nonce);
+  });
+}
+function Kr(e) {
+  return e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+}
+function Jr(e) {
+  return e === "sha384" ? "SHA-384" : e === "sha512" ? "SHA-512" : "SHA-256";
+}
+function Yr(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 et(e, t, r = {}) {
+  Qr(e);
+  const n = t.request.headers.get("origin"), s = new Headers();
+  if (e.origins !== "*" && tt(s, "Origin"), !n)
+    return s;
+  const o = Xr(e, n);
+  if (!o)
+    return s;
+  if (s.set("access-control-allow-origin", o), e.credentials && s.set("access-control-allow-credentials", "true"), e.exposeHeaders?.length && s.set("access-control-expose-headers", e.exposeHeaders.join(", ")), r.preflight) {
+    s.set("access-control-allow-methods", r.methods.join(", "));
+    const i = t.request.headers.get(
+      "access-control-request-headers"
+    ), a = e.headers?.join(", ") ?? i;
+    a && s.set("access-control-allow-headers", a), e.maxAge !== void 0 && s.set("access-control-max-age", String(e.maxAge));
+  }
+  return s;
+}
+function F(e, t, r) {
+  if (!t)
+    return e;
+  const n = new Headers(e.headers);
+  return en(n, et(t, { request: r })), new Response(e.body, {
+    headers: n,
+    status: e.status,
+    statusText: e.statusText
+  });
+}
+function Zr(e, t) {
+  const r = t.headers.get("access-control-request-method"), n = tn(r);
+  if (!n)
+    return null;
+  const s = rt(e, n);
+  if (!s?.cors)
+    return null;
+  const o = s.cors.methods ?? rn(e);
+  return o.includes(n) ? new Response(null, {
+    headers: et(
+      s.cors,
+      { request: t },
+      {
+        methods: o,
+        preflight: !0
+      }
+    ),
+    status: 204
+  }) : null;
+}
+function Qr(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.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 Xr(e, t) {
+  return e.origins === "*" ? "*" : e.origins.includes(t) ? t : null;
+}
+function en(e, t) {
+  t.forEach((r, n) => {
+    if (n === "vary" && e.has("vary")) {
+      for (const s of r.split(","))
+        tt(e, s.trim());
+      return;
+    }
+    e.set(n, r);
+  });
+}
+function tt(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 tn(e) {
+  if (!e)
+    return null;
+  const t = e.toUpperCase();
+  return nn(t) ? t : null;
+}
+function rt(e, t) {
+  return t === "HEAD" ? e.HEAD ?? Ne(e.GET) : Ne(e[t]);
+}
+function Ne(e) {
+  return e?.kind === "page" ? void 0 : e;
+}
+function rn(e) {
+  return [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "OPTIONS",
+    "HEAD"
+  ].filter((t) => rt(e, t));
+}
+function nn(e) {
+  return e === "GET" || e === "POST" || e === "PUT" || e === "PATCH" || e === "DELETE" || e === "OPTIONS" || e === "HEAD";
+}
+const sn = /* @__PURE__ */ new Set(["DELETE", "PATCH", "POST", "PUT"]), on = /^[!#$%&'*+\-.^_`|~A-Za-z0-9]+$/;
+function an() {
+  const e = new Uint8Array(32);
+  return globalThis.crypto.getRandomValues(e), btoa(String.fromCharCode(...e)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function cn(e, t = {}) {
+  const r = t.cookie ?? "csrf-token";
+  if (!on.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 Fs(e = {}) {
+  const t = an();
+  return {
+    cookie: cn(t, e),
+    token: t
+  };
+}
+function un(e, t) {
+  if (!sn.has(t.method.toUpperCase()) || e === !1)
+    return null;
+  const r = t.headers.get("cookie");
+  if (e === void 0 && !r?.trim())
+    return null;
+  const n = fn(e ?? !0), o = ln(r).get(n.cookie), i = t.headers.get(n.header);
+  return !o || !i || !mn(o, i) ? new Response("Invalid CSRF token.", {
+    status: 403
+  }) : null;
+}
+function ln(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 s = r.slice(0, n).trim(), o = r.slice(n + 1).trim();
+    s && t.set(s, dn(o));
+  }
+  return t;
+}
+function fn(e) {
+  return e === !0 ? {
+    cookie: "csrf-token",
+    header: "x-csrf-token"
+  } : {
+    cookie: e.cookie ?? "csrf-token",
+    header: e.header ?? "x-csrf-token"
+  };
+}
+function dn(e) {
+  try {
+    return decodeURIComponent(e);
+  } catch {
+    return e;
+  }
+}
+function mn(e, t) {
+  let r = e.length ^ t.length;
+  const n = Math.max(e.length, t.length);
+  for (let s = 0; s < n; s += 1)
+    r |= e.charCodeAt(s) ^ t.charCodeAt(s);
+  return r === 0;
+}
+const hn = {
+  h: 3600 * 1e3,
+  m: 60 * 1e3,
+  s: 1e3
+}, pn = 1e4;
+function nt(e = {}) {
+  const t = e.maximumEntries ?? pn;
+  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(s, o, i) {
+      i >= n && (gn(r, i), n = wn(r));
+      const a = r.get(s);
+      if (!a || a.resetAt <= i) {
+        const c = {
+          count: 1,
+          resetAt: i + o
+        };
+        return !a && r.size >= t && yn(r), r.set(s, c), n = Math.min(n, c.resetAt), c;
+      }
+      return a.count += 1, a;
+    }
+  };
+}
+function gn(e, t) {
+  for (const [r, n] of e)
+    n.resetAt <= t && e.delete(r);
+}
+function wn(e) {
+  let t = Number.POSITIVE_INFINITY;
+  for (const r of e.values())
+    t = Math.min(t, r.resetAt);
+  return t;
+}
+function yn(e) {
+  const t = e.keys().next().value;
+  t !== void 0 && e.delete(t);
+}
+function Sn(e, t, r, n = Date.now()) {
+  if (!e)
+    return null;
+  En(e);
+  const s = st(e.window), o = Rn(e, t), i = r.increment(o, s, n), a = 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(a),
+    "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 st(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(), s = r * hn[n];
+  if (!Number.isSafeInteger(s))
+    throw new Error("Demiurge rate limit window is too large.");
+  return s;
+}
+function En(e) {
+  if (!Number.isSafeInteger(e.limit) || e.limit <= 0)
+    throw new Error("Demiurge rate limit limit must be a positive integer.");
+  st(e.window);
+}
+function Rn(e, t) {
+  return `${bn(e.key)}:${Tn(e.key, t)}`;
+}
+function bn(e) {
+  return typeof e == "string" ? e : `header:${e.header.toLowerCase()}`;
+}
+function Tn(e, t) {
+  return e === "ip" ? vn(t) : t.headers.get(e.header) ?? "missing";
+}
+function vn(e) {
+  return mt(e)?.clientIp ?? "unknown";
+}
+const xn = {
+  b: 1,
+  gb: 1024 ** 3,
+  kb: 1024,
+  mb: 1024 ** 2
+};
+function kn(e, t, r) {
+  const n = Cn(e, r);
+  if (n)
+    return n;
+  if (e?.maxBodySize === void 0)
+    return null;
+  const s = t.headers.get("content-length");
+  if (!s)
+    return null;
+  const o = An(s);
+  if (o === null)
+    return new Response("Invalid Content-Length.", {
+      status: 400
+    });
+  const i = ot(e.maxBodySize);
+  return o > i ? new Response("Request body too large.", {
+    status: 413
+  }) : null;
+}
+class D extends Error {
+  constructor() {
+    super("Demiurge request body exceeded maxBodySize while being read."), this.name = "RequestBodyTooLargeError";
+  }
+}
+function Pn(e, t) {
+  if (e?.maxBodySize === void 0 || t.body === null)
+    return t;
+  const r = ot(e.maxBodySize), n = t.body.getReader();
+  let s = 0;
+  const o = new ReadableStream({
+    async pull(a) {
+      const c = await n.read();
+      if (c.done) {
+        a.close();
+        return;
+      }
+      if (s += c.value.byteLength, s > r) {
+        const u = new D();
+        a.error(u);
+        try {
+          await n.cancel(u);
+        } catch {
+        }
+        return;
+      }
+      a.enqueue(c.value);
+    },
+    async cancel(a) {
+      try {
+        await n.cancel(a);
+      } catch {
+      }
+    }
+  }), i = new Request(t, {
+    body: o,
+    duplex: "half"
+  });
+  return ht(t, i), i;
+}
+function M() {
+  return new Response("Request body too large.", { status: 413 });
+}
+function Cn(e, t) {
+  return !e?.allowedMethods || Dn(e.allowedMethods, t) ? null : new Response(null, {
+    headers: {
+      allow: Nn(e.allowedMethods)
+    },
+    status: 405
+  });
+}
+function ot(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(), s = r * xn[n];
+  if (!Number.isSafeInteger(s))
+    throw new Error("Demiurge request maxBodySize is too large.");
+  return s;
+}
+function An(e) {
+  if (!/^\d+$/.test(e))
+    return null;
+  const t = Number(e);
+  return Number.isSafeInteger(t) ? t : null;
+}
+function Dn(e, t) {
+  return e.includes(t) || t === "HEAD" && e.includes("GET");
+}
+function Nn(e) {
+  const t = [...e];
+  return t.includes("GET") && !t.includes("HEAD") && t.push("HEAD"), t.join(", ");
+}
+const $n = ["text/html", "application/xhtml+xml"];
+function it(e) {
+  return In(e.headers.get("accept"));
+}
+function In(e) {
+  return e ? On(e).some(
+    (t) => t.quality > 0 && $n.includes(t.type)
+  ) : !1;
+}
+function On(e) {
+  return e.split(",").flatMap((t) => {
+    const [r, ...n] = t.split(";"), s = r.trim().toLowerCase();
+    return s ? [
+      {
+        quality: Ln(n),
+        type: s
+      }
+    ] : [];
+  });
+}
+function Ln(e) {
+  for (const t of e) {
+    const [r, n] = t.split("=");
+    if (r?.trim().toLowerCase() !== "q")
+      continue;
+    const s = Number.parseFloat(n ?? "");
+    return Number.isNaN(s) ? 1 : s;
+  }
+  return 1;
+}
+const Hn = "application/problem+json";
+function Un({
+  detail: e,
+  instance: t,
+  status: r,
+  title: n,
+  type: s = "about:blank",
+  ...o
+}) {
+  return {
+    type: s,
+    title: n,
+    status: r,
+    ...e === void 0 ? {} : { detail: e },
+    ...t === void 0 ? {} : { instance: t },
+    ...o
+  };
+}
+function W(e, t) {
+  const r = new Headers(t?.headers);
+  return r.set("content-type", `${Hn}; charset=utf-8`), new Response(JSON.stringify(Un(e)), {
+    ...t,
+    headers: r,
+    status: e.status
+  });
+}
+const Mn = "Internal Server Error";
+function at(e) {
+  return e === !0 && process.env.NODE_ENV !== "production";
+}
+async function z(e, t, r, n, s = {}) {
+  s.onError?.(r, n);
+  const o = new URL(t.url);
+  return n === "page" || n === "middleware" && it(t) ? await Fn(e, o, r, s) : jn(o, r, s);
+}
+function jn(e, t, r = {}) {
+  if (ie(t))
+    return W(
+      {
+        ...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 } = _e(t);
+  return W({
+    // `detail` carries the thrown message, so it is dev only for the same
+    // reason the stack is.
+    ...at(r.dev) ? { detail: n } : {},
+    instance: `${e.pathname}${e.search}`,
+    status: 500,
+    title: "Internal Server Error"
+  });
+}
+async function Fn(e, t, r, n) {
+  const s = ct(r);
+  try {
+    const o = await qn(
+      e,
+      t.pathname,
+      r,
+      n
+    ), i = ie(r) ? new Headers(r.headers) : new Headers();
+    return i.set("content-type", "text/html; charset=utf-8"), new Response(await n.transformDocument?.(o) ?? o, {
+      headers: i,
+      status: s
+    });
+  } catch (o) {
+    return n.onError?.(o, "page"), zn();
+  }
+}
+function zn() {
+  return new Response(Mn, {
+    headers: { "content-type": "text/plain; charset=utf-8" },
+    status: 500
+  });
+}
+async function qn(e, t, r, n) {
+  const s = await Wn(e, t, n), o = He(
+    ee(s, { error: r, pathname: t, status: ct(r) })
+  );
+  return Le({
+    body: { data: void 0, html: o, navigation: n.navigation },
+    entrySrc: n.clientEntry,
+    lang: n.lang,
+    nonce: n.nonce,
+    styles: n.styles,
+    title: n.title
+  });
+}
+function ct(e) {
+  return ie(e) ? e.status : 500;
+}
+async function Wn(e, t, r) {
+  if (at(r.dev))
+    return Dr;
+  try {
+    return await hr(e, t) ?? Pe;
+  } catch {
+    return Pe;
+  }
+}
+function Bn(e) {
+  return W({
+    instance: `${e.pathname}${e.search}`,
+    status: 404,
+    title: "Not Found"
+  });
+}
+async function se(e, t, r = {}) {
+  const n = new URL(t.url);
+  if (!it(t))
+    return Bn(n);
+  const s = await ne(e, n.pathname, {
+    onLayoutError: (u) => r.onError?.(u, "page")
+  }), o = await Gn(e, n.pathname), i = r.nonce ?? (Ye(o) ? Ze() : void 0), a = _n(s, { ...r, nonce: i }), c = Je(o ?? {}, {
+    nonce: i,
+    request: t
+  });
+  return c.set("content-type", "text/html; charset=utf-8"), new Response(
+    await r.transformDocument?.(a) ?? a,
+    {
+      headers: c,
+      status: 404
+    }
+  );
+}
+async function Gn(e, t) {
+  const r = await Promise.all(
+    wr(e, t).map((n) => n.load())
+  );
+  return Ke(...r.map((n) => n.policy)).document;
+}
+function _n(e, t = {}) {
+  const r = e.notFound ?? ke;
+  try {
+    return Q(e, r, e.layouts, t);
+  } catch (n) {
+    t.onError?.(n, "page");
+  }
+  try {
+    return Q(e, r, [], t);
+  } catch (n) {
+    t.onError?.(n, "page");
+  }
+  return Q(e, ke, [], t);
+}
+function Q(e, t, r, n) {
+  const s = r.reduceRight(
+    (o, i) => ee(i, {
+      children: o,
+      path: {},
+      pathname: e.pathname
+    }),
+    ee(t, { pathname: e.pathname })
+  );
+  return Le({
+    body: {
+      data: void 0,
+      fallback: "not-found",
+      html: He(s),
+      navigation: n.navigation
+    },
+    entrySrc: n.clientEntry,
+    lang: n.lang,
+    metadata: e.metadata,
+    nonce: n.nonce,
+    styles: n.styles,
+    title: n.title
+  });
+}
+const ut = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+], lt = nt();
+function zs(e) {
+  const t = ur(e.routes), r = e.rateLimitStore ?? nt();
+  return e.cacheStore && je(e.cacheStore.namespace), async function(s) {
+    return await Vn(t, s, {
+      cacheStore: e.cacheStore,
+      onError: e.onError,
+      rateLimitStore: r,
+      renderPage: e.renderPage,
+      ssr: e.ssr
+    });
+  };
+}
+async function Vn(e, t, r = {
+  rateLimitStore: lt
+}) {
+  const n = new URL(t.url), s = Yn(n, r), o = Ge(t);
+  let i;
+  try {
+    i = L(e.routes, n.pathname);
+  } catch (a) {
+    if (!(a instanceof fe))
+      throw a;
+    const c = W({
+      instance: `${n.pathname}${n.search}`,
+      status: 400,
+      title: "Bad Request"
+    });
+    return o ? U(c, Z) : c;
+  }
+  if (!i)
+    try {
+      const a = await se(
+        e,
+        t,
+        s
+      );
+      return o ? U(a, xe) : a;
+    } catch (a) {
+      return s.onError(a, "page"), new Response("Not Found", {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+        status: 404
+      });
+    }
+  try {
+    const a = await Kn(
+      e,
+      t,
+      n,
+      i,
+      r,
+      s
+    );
+    return o && !a.headers.has(x) ? U(
+      a,
+      a.status === 404 ? xe : Z
+    ) : a;
+  } catch (a) {
+    const c = await z(
+      e,
+      t,
+      a,
+      "middleware",
+      s
+    );
+    return o ? U(c, Z) : c;
+  }
+}
+async function Kn(e, t, r, n, s, o) {
+  const i = await n.route.load();
+  if (t.method.toUpperCase() === "OPTIONS") {
+    const h = Zr(i, t);
+    if (h)
+      return h;
+  }
+  const a = es(t.method);
+  if (!a)
+    return Oe(i);
+  const c = ts(i, a);
+  if (!c)
+    return Oe(i);
+  const u = await Qn(
+    e,
+    n.route,
+    i,
+    c
+  ), l = u.security, d = un(l?.csrf, t);
+  if (d)
+    return F(d, X(c), t);
+  const m = Sn(
+    l?.rateLimit,
+    t,
+    s.rateLimitStore ?? lt
+  );
+  if (m)
+    return F(
+      m,
+      X(c),
+      t
+    );
+  const f = kn(
+    l?.request,
+    t,
+    a
+  );
+  if (f)
+    return F(
+      f,
+      X(c),
+      t
+    );
+  if (t = Pn(l?.request, t), c.kind === "page") {
+    const h = {
+      path: n.path,
+      pathname: r.pathname,
+      request: t,
+      search: r.searchParams,
+      url: r
+    }, me = await $e(
+      e,
+      n.route
+    ), v = Ye(u.document) ? Ze() : void 0;
+    let E;
+    try {
+      E = await Ie(me, h, async () => {
+        try {
+          const p = await qe(
+            e,
+            r.pathname,
+            t,
+            void 0,
+            Jn(s.cacheStore)
+          );
+          if (p.status !== "ready")
+            return await se(e, t, {
+              ...o,
+              nonce: v
+            });
+          if (Ge(t))
+            return Ar(p.match.data);
+          if (p.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 ?? pt)(p.match, {
+            ...s.ssr,
+            nonce: v,
+            onStreamError: (dt) => {
+              s.onError?.(dt, {
+                pathname: r.pathname,
+                site: "page"
+              });
+            },
+            signal: t.signal
+          });
+        } catch (p) {
+          return p instanceof D ? M() : await z(e, t, p, "page", {
+            ...o,
+            nonce: v
+          });
+        }
+      });
+    } catch (p) {
+      if (!(p instanceof D))
+        throw p;
+      E = M();
+    }
+    const ft = Je(u.document ?? {}, {
+      nonce: v,
+      request: t
+    });
+    for (const [p, he] of ft)
+      E.headers.set(p, he);
+    return v && E.headers.set("cache-control", "private, no-store"), a === "HEAD" ? (await E.body?.cancel(), new Response(null, {
+      headers: E.headers,
+      status: E.status
+    })) : E;
+  }
+  const k = {
+    path: n.path,
+    pathname: r.pathname,
+    request: t,
+    search: r.searchParams,
+    url: r
+  }, H = await $e(
+    e,
+    n.route
+  );
+  let g;
+  try {
+    g = await Ie(H, k, async () => {
+      try {
+        return c.kind === "not-found" && c.body === void 0 ? Zn(
+          await se(e, t, o),
+          c.init
+        ) : await $t(c, k);
+      } catch (h) {
+        return h instanceof D ? M() : await z(
+          e,
+          t,
+          h,
+          "route",
+          o
+        );
+      }
+    });
+  } catch (h) {
+    if (!(h instanceof D))
+      throw h;
+    g = M();
+  }
+  try {
+    return Xn(g, c, t, a);
+  } catch (h) {
+    return await z(
+      e,
+      t,
+      h,
+      "route",
+      o
+    );
+  }
+}
+function Jn(e) {
+  return e ? Me(e) : ae();
+}
+function Yn(e, t) {
+  return {
+    ...t.ssr,
+    dev: t.dev,
+    onError: (r, n) => {
+      t.onError?.(r, { pathname: e.pathname, site: n });
+    },
+    transformDocument: t.transformDocument
+  };
+}
+function Zn(e, t) {
+  if (!t)
+    return e;
+  const r = new Headers(e.headers), n = new Headers(t.headers);
+  for (const [s, o] of n)
+    s !== "set-cookie" && r.set(s, o);
+  for (const s of n.getSetCookie())
+    r.append("set-cookie", s);
+  return new Response(e.body, {
+    headers: r,
+    status: t.status ?? e.status,
+    statusText: t.statusText ?? e.statusText
+  });
+}
+async function Qn(e, t, r, n) {
+  const s = await Promise.all(
+    e.policies.filter(
+      (o) => B(o.fileSegments, t.fileSegments)
+    ).map((o) => o.load())
+  );
+  return Ke(
+    ...s.map((o) => o.policy),
+    r.policy,
+    {
+      security: n.kind === "page" ? void 0 : n.security
+    }
+  );
+}
+async function $e(e, t) {
+  return (await Promise.all(
+    e.middlewares.filter(
+      (n) => B(n.fileSegments, t.fileSegments)
+    ).map((n) => n.load())
+  )).flatMap(
+    (n) => n.middleware ? [n.middleware] : []
+  );
+}
+async function Ie(e, t, r) {
+  let n = -1;
+  async function s(o) {
+    if (o <= n)
+      throw new Error("Demiurge route middleware next() called multiple times.");
+    n = o;
+    const i = e[o];
+    return i ? await i(t, () => s(o + 1)) : await r();
+  }
+  return await s(0);
+}
+function Xn(e, t, r, n) {
+  const s = qt(
+    F(e, t.cors, r),
+    t.timing
+  );
+  return n === "HEAD" ? new Response(null, {
+    headers: s.headers,
+    status: s.status,
+    statusText: s.statusText
+  }) : s;
+}
+function X(e) {
+  return e.kind === "page" ? void 0 : e.cors;
+}
+function es(e) {
+  const t = e.toUpperCase();
+  return ut.includes(t) ? t : null;
+}
+function ts(e, t) {
+  return t === "HEAD" ? e.HEAD ?? e.GET : e[t];
+}
+function Oe(e) {
+  return new Response(null, {
+    headers: {
+      allow: rs(e).join(", ")
+    },
+    status: 405
+  });
+}
+function rs(e) {
+  const t = ut.filter((r) => e[r]);
+  return e.GET && !t.includes("HEAD") && t.push("HEAD"), t;
+}
+export {
+  ms as $,
+  Ue as A,
+  ke as B,
+  Me as C,
+  et as D,
+  cn as E,
+  an as F,
+  Ns as G,
+  Kt as H,
+  ae as I,
+  tr as J,
+  zs as K,
+  as as L,
+  fs as M,
+  x as N,
+  Ms as O,
+  ps as P,
+  Us as Q,
+  D as R,
+  Ds as S,
+  Cn as T,
+  un as U,
+  Sn as V,
+  kn as W,
+  Es as X,
+  Fs as Y,
+  ws as Z,
+  ys as _,
+  $s as a,
+  Ke as a0,
+  Or as a1,
+  Ir as a2,
+  ds as a3,
+  ls as a4,
+  bs as a5,
+  ln as a6,
+  st as a7,
+  cs as a8,
+  us as a9,
+  Cs as aa,
+  Rs as ab,
+  gt as ac,
+  b as ad,
+  vt as ae,
+  P as af,
+  je as ag,
+  te as ah,
+  ks as ai,
+  xs as aj,
+  vs as ak,
+  hs as al,
+  As as am,
+  Ss as an,
+  En as ao,
+  Ls as ap,
+  B as aq,
+  Hs as ar,
+  Os as as,
+  Sr as at,
+  kr as au,
+  _ as av,
+  R as aw,
+  nt as b,
+  ur as c,
+  js as d,
+  Ts as e,
+  L as f,
+  Pt as g,
+  Vn as h,
+  qe as i,
+  hr as j,
+  Pr as k,
+  Is as l,
+  Cr as m,
+  xe as n,
+  Z as o,
+  I as p,
+  Ps as q,
+  se as r,
+  Re as s,
+  $t as t,
+  ie as u,
+  gs as v,
+  Je as w,
+  Qr as x,
+  Pn as y,
+  ot as z
+};
+//# sourceMappingURL=testing-BBnJ5WUR.js.map