@astris-labs/cli 0.1.3 → 0.2.0

package/src/main.mjs

@@ -4,7 +4,9 @@ import { createInterface } from "node:readline";
 import { Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_BASE_URL } from "./client.mjs";
-import { accountExport, app, compose, database, deploy, diagnose, domains, env, list, login, logout, logs, next, plans, preflight, restart, rollback, status, storage, usage, whoami } from "./commands.mjs";
+import { mcp } from "./mcp-bridge.mjs";
+import { newProject } from "./new.mjs";
+import { accountExport, app, billing, compose, database, deploy, diagnose, domains, env, list, login, logout, logs, next, plans, preflight, project, restart, rollback, status, storage, usage, whoami } from "./commands.mjs";
 
 const PROMPT = "Paste your Astris API key: ";
 
@@ -54,8 +56,10 @@ const handlers = new Map([
   ["restart", restart],
   ["logs", logs],
   ["list", list],
+  ["project", project],
   ["usage", usage],
   ["plans", plans],
+  ["billing", billing],
   ["whoami", whoami],
   ["next", next],
   ["rollback", rollback],
@@ -64,6 +68,8 @@ const handlers = new Map([
   ["app", app],
   ["preflight", preflight],
   ["export", accountExport],
+  ["mcp", mcp],
+  ["new", newProject],
 ]);
 
 export const COMMANDS = [...handlers.keys()];
@@ -92,6 +98,7 @@ async function readStdin() {
 
 if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
   const isEnvWithoutNames = process.argv[2] === "env" && !process.argv.slice(3).includes("--names");
+  const isMcp = process.argv[2] === "mcp";
   const stdin = (isEnvWithoutNames || process.argv[2] === "login") && !process.stdin.isTTY ? await readStdin() : "";
   const io = {
     env: process.env,
@@ -100,7 +107,10 @@ if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToP
     stdin,
     stdout: process.stdout,
     stderr: process.stderr,
+    cwd: process.cwd(),
+    templatesFile: fileURLToPath(new URL("../templates.json", import.meta.url)),
   };
+  if (isMcp) io.stdin = process.stdin;
   if (process.argv[2] === "login" && process.stdin.isTTY) io.readSecret = readSecret;
   const code = await main(process.argv, io);
   process.exit(code);

package/src/mcp-bridge.mjs

@@ -0,0 +1,186 @@
+import { createInterface } from "node:readline";
+import { DEFAULT_BASE_URL, redact } from "./client.mjs";
+import { readApiKey } from "./key.mjs";
+
+// The SDK server answers 406 to a POST that does not list both media types.
+const MCP_ACCEPT = "application/json, text/event-stream";
+
+export async function mcp(_args, io) {
+  let key;
+  try {
+    key = readApiKey(io.env);
+  } catch {
+    io.stderr.write("Run astris login.\n");
+    return { exitCode: 1 };
+  }
+
+  const rl = createInterface({ input: io.stdin, crlfDelay: Infinity });
+  let readFailed = false;
+  const onReadError = () => {
+    readFailed = true;
+    rl.close();
+  };
+  io.stdin.on("error", onReadError);
+  rl.on("error", onReadError);
+
+  try {
+    for await (const line of rl) {
+      if (line.trim() === "") {
+        continue;
+      }
+
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        io.stdout.write(
+          redact(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: null,
+              error: { code: -32700, message: "Parse error" },
+            }) + "\n",
+            key,
+          ),
+        );
+        continue;
+      }
+
+      const isPlainObject = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+      const isNotification = isPlainObject && !Object.hasOwn(parsed, "id");
+
+      if (isNotification) {
+        try {
+          const response = await io.fetchImpl(DEFAULT_BASE_URL + "/mcp", {
+            method: "POST",
+            redirect: "manual",
+            headers: {
+              Authorization: "Bearer " + key,
+              "content-type": "application/json",
+              accept: MCP_ACCEPT,
+            },
+            body: line,
+          });
+
+          if (response.status === 401) {
+            io.stderr.write("Run astris login.\n");
+          } else if (response.status !== 202) {
+            io.stderr.write("A notification was refused.\n");
+          }
+        } catch {
+          io.stderr.write("The request failed.\n");
+        }
+        continue;
+      }
+
+      const requestId =
+        isPlainObject &&
+        (typeof parsed.id === "string" || typeof parsed.id === "number" || parsed.id === null)
+          ? parsed.id
+          : null;
+
+      try {
+        const response = await io.fetchImpl(DEFAULT_BASE_URL + "/mcp", {
+          method: "POST",
+          redirect: "manual",
+          headers: {
+            Authorization: "Bearer " + key,
+            "content-type": "application/json",
+            accept: MCP_ACCEPT,
+          },
+          body: line,
+        });
+
+        // The server answers JSON. A stream could stay open, so refuse it before reading the body.
+        if ((response.headers.get("content-type") ?? "").toLowerCase().includes("text/event-stream")) {
+          await response.body?.cancel();
+          io.stdout.write(
+            redact(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                id: requestId,
+                error: { code: -32603, message: "Internal error" },
+              }) + "\n",
+              key,
+            ),
+          );
+          io.stderr.write("The request failed.\n");
+          continue;
+        }
+
+        const text = await response.text();
+
+        if (response.status === 401) {
+          io.stderr.write("Run astris login.\n");
+          if (text !== "") {
+            try {
+              const parsed_body = JSON.parse(text);
+              if (typeof parsed_body === "object" && parsed_body !== null) {
+                io.stdout.write(redact(JSON.stringify(parsed_body) + "\n", key));
+                continue;
+              }
+            } catch {
+              // Fall through to synthesized error
+            }
+          }
+          io.stdout.write(
+            redact(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                id: requestId,
+                error: { code: -32001, message: "Unauthorized" },
+              }) + "\n",
+              key,
+            ),
+          );
+          continue;
+        }
+
+        if (text !== "") {
+          try {
+            const parsed_body = JSON.parse(text);
+            io.stdout.write(redact(JSON.stringify(parsed_body) + "\n", key));
+            continue;
+          } catch {
+            // Fall through to error handling
+          }
+        }
+
+        io.stdout.write(
+          redact(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: requestId,
+              error: { code: -32603, message: "Internal error" },
+            }) + "\n",
+            key,
+          ),
+        );
+        io.stderr.write("The request failed.\n");
+      } catch {
+        io.stdout.write(
+          redact(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: requestId,
+              error: { code: -32603, message: "Internal error" },
+            }) + "\n",
+            key,
+          ),
+        );
+        io.stderr.write("The request failed.\n");
+      }
+    }
+  } catch {
+    readFailed = true;
+  } finally {
+    io.stdin.removeListener("error", onReadError);
+    rl.removeListener("error", onReadError);
+    rl.close();
+  }
+
+  if (readFailed) {
+    io.stderr.write("Could not read the next line.\n");
+  }
+  return { exitCode: 0 };
+}

package/src/new.mjs

@@ -0,0 +1,159 @@
+import { lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SENTENCE = {
+  refused: "Those arguments were refused. Check the flags and send them again.",
+  notEmpty: "That directory is not empty. Choose a new or empty directory.",
+  noBundle: "This install has no templates. Run the CLI from npm: npx @astris-labs/cli new <template>.",
+  damaged: "The templates in this install are damaged. Install the CLI again.",
+};
+
+const NAME = /^[a-z0-9][a-z0-9-]*$/;
+
+// One row per template on main: the database it needs (or null) and the
+// apps it deploys, each with its name and its extra deploy flags. A new
+// template adds its row here (T-556).
+const DOCKERFILE = " --build dockerfile --dockerfile Dockerfile";
+export const NEXT_STEPS = new Map([
+  ["fastapi-postgres", { database: "postgres", apps: [{ name: "<name>", flags: "" }] }],
+  ["go-dockerfile", { database: null, apps: [{ name: "<name>", flags: DOCKERFILE }] }],
+  ["nextjs-postgres", { database: "postgres", apps: [{ name: "<name>", flags: DOCKERFILE }] }],
+  [
+    "node-worker-cron",
+    {
+      database: "postgres",
+      apps: [
+        { name: "<name>-worker", id: "<worker app id>", flags: ' --kind worker --command "node worker.mjs"' },
+        { name: "<name>-cron", id: "<cron app id>", flags: ' --kind cron --command "node heartbeat.mjs" --schedule "*/5 * * * *"' },
+      ],
+    },
+  ],
+]);
+
+// Reads templates/<name>/ into { name: { files: [{ path, exec, body }] } },
+// bodies in base64. npm drops nested .gitignore and .npmrc files from a
+// tarball, so the templates travel as this one JSON file (T-556).
+export function bundleTemplates(dir) {
+  let names;
+  try {
+    names = readdirSync(dir).sort();
+  } catch {
+    throw new Error(`templates folder not found: ${dir}`);
+  }
+  const bundle = {};
+  for (const name of names) {
+    if (!lstatSync(path.join(dir, name)).isDirectory()) throw new Error(`not a directory: ${name}`);
+    const files = [];
+    const walk = (rel) => {
+      for (const entry of readdirSync(path.join(dir, name, rel)).sort()) {
+        const relPath = rel === "" ? entry : `${rel}/${entry}`;
+        const st = lstatSync(path.join(dir, name, relPath));
+        if (st.isDirectory()) walk(relPath);
+        else if (st.isFile()) files.push({ path: relPath, exec: (st.mode & 0o111) !== 0, body: readFileSync(path.join(dir, name, relPath)).toString("base64") });
+        else throw new Error(`not a file or a directory: ${name}/${relPath}`);
+      }
+    };
+    walk("");
+    bundle[name] = { files };
+  }
+  return bundle;
+}
+
+function safePath(value) {
+  if (typeof value !== "string" || value === "" || value.includes("\\") || value.startsWith("/") || /^[A-Za-z]:/.test(value)) return false;
+  return value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+
+function validFiles(template) {
+  const files = template?.files;
+  if (!Array.isArray(files)) return null;
+  const seen = new Set();
+  for (const file of files) {
+    if (!safePath(file?.path) || typeof file.body !== "string" || typeof file.exec !== "boolean") return null;
+    seen.add(file.path);
+  }
+  // Two entries that clash (the same path twice, or "a" beside "a/b") would
+  // fail half way through the writes, so they are refused before the first.
+  if (seen.size !== files.length) return null;
+  for (const file of files) {
+    const parts = file.path.split("/");
+    for (let i = 1; i < parts.length; i++) if (seen.has(parts.slice(0, i).join("/"))) return null;
+  }
+  return files;
+}
+
+function nextSteps(name) {
+  const row = NEXT_STEPS.get(name) ?? { database: null, apps: [{ name: "<name>", flags: "" }] };
+  const lines = ["Next:", "1. Push this folder to a Git repository of your own."];
+  for (const app of row.apps) {
+    lines.push(`${lines.length}. astris deploy --project <project name> --name ${app.name} --git-url <repository URL> --branch main${app.flags}`);
+  }
+  if (row.database !== null) {
+    lines.push(`${lines.length}. astris database create --project <project id> --kind ${row.database} --name <name>-db`, "   Build DATABASE_URL from its answer. Astris shows the password only once.");
+    for (const app of row.apps) {
+      const id = app.id ?? "<app id>";
+      lines.push(`${lines.length - 1}. Set DATABASE_URL with astris env --app ${id}, then run astris deploy --app ${id}.`);
+    }
+    lines.push("   astris env replaces every variable on the app, so send all of them in one call.");
+  }
+  return lines.join("\n");
+}
+
+function refuse(io, sentence) {
+  io.stderr.write(`${sentence}\n`);
+  return { exitCode: 1 };
+}
+
+// astris new <template> [dir]: writes one bundled template into a new or
+// empty directory. Local only: no key, no request.
+export async function newProject(args, io) {
+  if (args.length > 2 || args.some((word) => word.startsWith("-"))) return refuse(io, SENTENCE.refused);
+  let bundle;
+  try {
+    bundle = JSON.parse(readFileSync(io.templatesFile, "utf8"));
+  } catch (error) {
+    return refuse(io, error?.code === "ENOENT" ? SENTENCE.noBundle : SENTENCE.damaged);
+  }
+  if (bundle === null || typeof bundle !== "object" || Array.isArray(bundle)) return refuse(io, SENTENCE.damaged);
+  const names = Object.keys(bundle).filter((key) => NAME.test(key)).sort();
+  const [name, dirArg] = args;
+  if (name === undefined || !NAME.test(name) || !Object.hasOwn(bundle, name)) {
+    return refuse(io, `Name one of these templates: ${names.join(", ")}.`);
+  }
+  const files = validFiles(bundle[name]);
+  if (files === null) return refuse(io, SENTENCE.damaged);
+
+  const shown = dirArg ?? name;
+  const target = path.resolve(io.cwd ?? process.cwd(), shown);
+  let st = null;
+  try {
+    st = lstatSync(target);
+  } catch {
+    st = null;
+  }
+  if (st !== null && (!st.isDirectory() || readdirSync(target).length > 0)) return refuse(io, SENTENCE.notEmpty);
+  mkdirSync(target, { recursive: true });
+  for (const file of files) {
+    const dest = path.join(target, ...file.path.split("/"));
+    mkdirSync(path.dirname(dest), { recursive: true });
+    writeFileSync(dest, Buffer.from(file.body, "base64"), { flag: "wx", mode: file.exec ? 0o755 : 0o644 });
+  }
+  io.stdout.write(`Wrote ${files.length} files to ${shown}.\n${nextSteps(name)}\n`);
+  return { exitCode: 0 };
+}
+
+// npm runs these from cli/: prepack "node src/new.mjs --bundle", postpack
+// "node src/new.mjs --unbundle".
+if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
+  const cliDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+  const out = path.join(cliDir, "templates.json");
+  if (process.argv[2] === "--bundle") {
+    writeFileSync(out, JSON.stringify(bundleTemplates(path.join(cliDir, "..", "templates"))));
+  } else if (process.argv[2] === "--unbundle") {
+    rmSync(out, { force: true });
+  } else {
+    process.stderr.write("Use --bundle or --unbundle.\n");
+    process.exit(1);
+  }
+}

package/templates.json

@@ -0,0 +1 @@
+{"fastapi-postgres":{"files":[{"path":".env.example","exec":false,"body":"IyBTZXQgdGhpcyBvbiB0aGUgYXBwIHdpdGggdGhlIGVudiB0b29sLiBOZXZlciBjb21taXQgYSB2YWx1ZS4KREFUQUJBU0VfVVJMPQo="},{"path":".gitignore","exec":false,"body":"LmVudgpfX3B5Y2FjaGVfXy8KLnZlbnYvCg=="},{"path":".python-version","exec":false,"body":"My4xMgo="},{"path":"README.md","exec":false,"body":"IyBGYXN0QVBJICsgUG9zdGdyZXMgc3RhcnRlcgoKQSBzbWFsbCBGYXN0QVBJIGFwcCB3aXRoIG9uZSBQb3N0Z3JlcyB0YWJsZSwgYG5vdGVzYC4gSXQgaGFzIHRocmVlIHJvdXRlczogYEdFVCAvaGVhbHRoYCwgYEdFVCAvbm90ZXNgLCBhbmQgYFBPU1QgL25vdGVzYCB3aXRoIGB7ImJvZHkiOiAiLi4uIn1gLgoKIyMgRGVwbG95IG9uIEFzdHJpcwoKR2l2ZSB0aGVzZSBzdGVwcyB0byB5b3VyIEFJIGNvZGluZyB0b29sLiBJdCBydW5zIHRoZW0gd2l0aCB0aGUgQXN0cmlzIE1DUC4KCjEuIERlcGxveSB0aGUgR2l0IFVSTCBvZiB0aGlzIHJlcG9zaXRvcnkgd2l0aCBubyBgYnVpbGRgIGFuZCB3aXRoIGBwb3J0YCAzMDAwLiBLZWVwIHRoZSBgYXBwX2lkYCB0aGF0IHRoZSBhbnN3ZXIgZ2l2ZXMuCjIuIENyZWF0ZSBhIFBvc3RncmVzIGRhdGFiYXNlIGluIHRoZSBzYW1lIHByb2plY3QuIEtlZXAgdGhlIGhvc3QsIHBvcnQsIHVzZXIsIHBhc3N3b3JkIGFuZCBkYXRhYmFzZSBuYW1lIGZyb20gdGhlIGFuc3dlci4gQXN0cmlzIHNob3dzIHRoZSBwYXNzd29yZCBvbmx5IG9uY2UuCjMuIFNldCBgREFUQUJBU0VfVVJMYCBvbiB0aGUgYXBwIHdpdGggYGVudmA6IGBwb3N0Z3Jlc3FsOi8vPHVzZXI+OjxwYXNzd29yZD5APGhvc3Q+Ojxwb3J0Pi88ZGF0YWJhc2U+YC4gYGVudmAgcmVwbGFjZXMgZXZlcnkgdmFyaWFibGUgb24gdGhlIGFwcCwgc28gc2VuZCBhbnkgb3RoZXIgdmFyaWFibGVzIGluIHRoZSBzYW1lIGNhbGwuCjQuIERlcGxveSB0aGUgc2FtZSBgYXBwX2lkYCBhZ2Fpbi4gVGhlbiBjaGVjayBgc3RhdHVzYCB1bnRpbCBpdCBzaG93cyB0aGF0IHRoZSBkZXBsb3kgaXMgZG9uZS4KNS4gQmluZCBhIGRvbWFpbiBhbmQgb3BlbiBgaHR0cHM6Ly88aG9zdG5hbWU+L2hlYWx0aGAuIFRoZSBhbnN3ZXIgaXMgYHsic3RhdHVzIjogIm9rIiwgImRhdGFiYXNlIjogIm9rIn1gLgoKS2VlcCB0aGUgcGFzc3dvcmQgb3V0IG9mIHlvdXIgZmlsZXMgYW5kIGNvbW1pdHMuIEl0IGJlbG9uZ3Mgb25seSBpbiB0aGUgYXBwJ3MgdmFyaWFibGVzLgoKIyMgUnVuIGl0IG9uIHlvdXIgY29tcHV0ZXIKClNldCBgREFUQUJBU0VfVVJMYCB0byBhIFBvc3RncmVzIGRhdGFiYXNlIHRoYXQgeW91IHJ1bi4gVGhlbiBydW4gYHBpcCBpbnN0YWxsIC1yIHJlcXVpcmVtZW50cy50eHRgIGFuZCBgcHl0aG9uIG1haW4ucHlgLiBUaGUgYXBwIGxpc3RlbnMgb24gZXZlcnkgaW50ZXJmYWNlLCBvbiB0aGUgcG9ydCBpbiBgUE9SVGAsIG9yIG9uIDMwMDAgd2hlbiBgUE9SVGAgaXMgbm90IHNldC4gVW50aWwgYERBVEFCQVNFX1VSTGAgaXMgc2V0LCBgL2hlYWx0aGAgYW5zd2VycyB3aXRoIHN0YXR1cyA1MDMuCgpUbyBjaGFuZ2UgYSBkZXBlbmRlbmN5LCBlZGl0IGByZXF1aXJlbWVudHMuaW5gLCB0aGVuIHJ1biBgdXYgcGlwIGNvbXBpbGUgcmVxdWlyZW1lbnRzLmluIC0tcHl0aG9uLXZlcnNpb24gMy4xMiAtbyByZXF1aXJlbWVudHMudHh0YC4K"},{"path":"main.py","exec":false,"body":"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"},{"path":"requirements.in","exec":false,"body":"ZmFzdGFwaQp1dmljb3JuCnBzeWNvcGdbYmluYXJ5XQo="},{"path":"requirements.txt","exec":false,"body":"IyBMb2NrZmlsZS4gUmVnZW5lcmF0ZSB3aXRoOiB1diBwaXAgY29tcGlsZSByZXF1aXJlbWVudHMuaW4gLS1weXRob24tdmVyc2lvbiAzLjEyIC1vIHJlcXVpcmVtZW50cy50eHQKYW5ub3RhdGVkLWRvYz09MC4wLjUKICAgICMgdmlhIGZhc3RhcGkKYW5ub3RhdGVkLXR5cGVzPT0wLjguMAogICAgIyB2aWEgcHlkYW50aWMKYW55aW89PTQuMTUuMQogICAgIyB2aWEgc3RhcmxldHRlCmNsaWNrPT04LjUuMAogICAgIyB2aWEgdXZpY29ybgpmYXN0YXBpPT0wLjE2MS4xCiAgICAjIHZpYSAtciByZXF1aXJlbWVudHMuaW4KaDExPT0wLjE2LjAKICAgICMgdmlhIHV2aWNvcm4KaWRuYT09My4yMAogICAgIyB2aWEgYW55aW8Kb3BlbnRlbGVtZXRyeS1hcGk9PTEuNDUuMQogICAgIyB2aWEgZmFzdGFwaQpwc3ljb3BnPT0zLjMuNgogICAgIyB2aWEgLXIgcmVxdWlyZW1lbnRzLmluCnBzeWNvcGctYmluYXJ5PT0zLjMuNgogICAgIyB2aWEgcHN5Y29wZwpweWRhbnRpYz09Mi4xNC4xCiAgICAjIHZpYSBmYXN0YXBpCnB5ZGFudGljLWNvcmU9PTIuNTAuMQogICAgIyB2aWEgcHlkYW50aWMKc3RhcmxldHRlPT0xLjkuMAogICAgIyB2aWEgZmFzdGFwaQp0eXBpbmctZXh0ZW5zaW9ucz09NC4xNi4wCiAgICAjIHZpYQogICAgIyAgIGFueWlvCiAgICAjICAgZmFzdGFwaQogICAgIyAgIG9wZW50ZWxlbWV0cnktYXBpCiAgICAjICAgcHN5Y29wZwogICAgIyAgIHB5ZGFudGljCiAgICAjICAgcHlkYW50aWMtY29yZQogICAgIyAgIHN0YXJsZXR0ZQogICAgIyAgIHR5cGluZy1pbnNwZWN0aW9uCnR5cGluZy1pbnNwZWN0aW9uPT0wLjQuNAogICAgIyB2aWEKICAgICMgICBmYXN0YXBpCiAgICAjICAgcHlkYW50aWMKdXZpY29ybj09MC41NC4wCiAgICAjIHZpYSAtciByZXF1aXJlbWVudHMuaW4K"}]},"go-dockerfile":{"files":[{"path":"Dockerfile","exec":false,"body":"IyBCdWlsZCBzdGFnZTogY29tcGlsZSBhIHN0YXRpYyBiaW5hcnkgd2l0aCB0aGUgR28gdG9vbGNoYWluLgpGUk9NIGdvbGFuZzoxLjI0LWFscGluZSBBUyBidWlsZApXT1JLRElSIC9zcmMKIyBUaGUgd2hvbGUgbW9kdWxlLCBzbyBwYWNrYWdlcyBpbiBzdWJmb2xkZXJzIGJ1aWxkIHRvby4gV2hlbiB0aGUgbW9kdWxlIGdldHMKIyBhIGRlcGVuZGVuY3ksIGdvLnN1bSBjb21lcyB3aXRoIGl0LgpDT1BZIC4gLgpSVU4gQ0dPX0VOQUJMRUQ9MCBnbyBidWlsZCAtdHJpbXBhdGggLWxkZmxhZ3M9Ii1zIC13IiAtbyAvb3V0L3NlcnZlciAuCgojIFJ1biBzdGFnZTogbm8gc2hlbGwsIG5vIHBhY2thZ2UgbWFuYWdlciwgYSBub24tcm9vdCB1c2VyLgpGUk9NIGdjci5pby9kaXN0cm9sZXNzL3N0YXRpYy1kZWJpYW4xMjpub25yb290CkNPUFkgLS1mcm9tPWJ1aWxkIC9vdXQvc2VydmVyIC9zZXJ2ZXIKVVNFUiA2NTUzMjo2NTUzMgpFWFBPU0UgMzAwMApFTlRSWVBPSU5UIFsiL3NlcnZlciJdCg=="},{"path":"README.md","exec":false,"body":"IyBHbyB3ZWIgc2VydmljZSAoRG9ja2VyZmlsZSkKCkEgc21hbGwgR28gd2ViIHNlcnZpY2UgdGhhdCBBc3RyaXMgYnVpbGRzIGZyb20gaXRzIG93biBEb2NrZXJmaWxlLiBJdCByZWFkcyBgUE9SVGAsIGxpc3RlbnMgb24gZXZlcnkgaW50ZXJmYWNlLCBhbmQgYW5zd2VycyBgR0VUIC9oZWFsdGhgIHdpdGggYHsib2siOnRydWV9YC4gVGhlIGltYWdlIHJ1bnMgYXMgYSBub24tcm9vdCB1c2VyLgoKU3RlcHMgZm9yIHlvdXIgY29kaW5nIGFnZW50OgoKMS4gQ29weSB0aGlzIGZvbGRlciB0byB0aGUgcm9vdCBvZiBhIG5ldyBHaXQgcmVwb3NpdG9yeSBvZiB5b3VyIG93biwgYW5kIHB1c2ggaXQgdG8gR2l0SHViLgoyLiBEZXBsb3kgaXQgd2l0aCB0aGUgQXN0cmlzIGBkZXBsb3lgIHRvb2w6IHlvdXIgcHJvamVjdCBuYW1lLCBhbiBhcHAgbmFtZSwgdGhlIHJlcG9zaXRvcnkncyBgZ2l0X3VybGAsIGl0cyBgYnJhbmNoYCwgYGJ1aWxkX3BhdGhgIGAiLyJgLCBgYnVpbGRgIGAiZG9ja2VyZmlsZSJgLCBgZG9ja2VyZmlsZWAgYCJEb2NrZXJmaWxlImAsIGFuZCBgd2FpdGAgYHRydWVgLgozLiBJZiB5b3UgcGFzcyBhIGBwb3J0YCBvdGhlciB0aGFuIDMwMDAsIHNldCB0aGUgdmFyaWFibGUgYFBPUlRgIHRvIHRoZSBzYW1lIG51bWJlciB3aXRoIHRoZSBgZW52YCB0b29sLCB0aGVuIGRlcGxveSBhZ2Fpbi4gYGVudmAgcmVwbGFjZXMgZXZlcnkgdmFyaWFibGUgb24gdGhlIGFwcCwgc28gc2VuZCBhbnkgb3RoZXIgdmFyaWFibGVzIGluIHRoZSBzYW1lIGNhbGwuCjQuIE9wZW4gYGh0dHBzOi8vPGFwcD4uYXN0cmlzLmxpdmUvaGVhbHRoYCBhbmQgY2hlY2sgdGhhdCBpdCBhbnN3ZXJzIGB7Im9rIjp0cnVlfWAuCjUuIEFkZCB5b3VyIG93biByb3V0ZXMgaW4gYG1haW4uZ29gLCBjb21taXQsIHB1c2gsIGFuZCBkZXBsb3kgYWdhaW4gd2l0aCB0aGUgYXBwJ3MgYGFwcF9pZGAuCgpUaGUgbW9kdWxlIGhhcyBubyBkZXBlbmRlbmNpZXMuIFdoZW4geW91IGFkZCBvbmUsIHJ1biBgZ28gbW9kIHRpZHlgIGFuZCBjb21taXQgdGhlIGBnby5zdW1gIGZpbGUgaXQgd3JpdGVzLiBUaGUgRG9ja2VyZmlsZSBjb3BpZXMgdGhlIHdob2xlIGZvbGRlciwgc28gYGdvLnN1bWAgcmVhY2hlcyB0aGUgYnVpbGQgd2l0aCBubyBjaGFuZ2UgdG8gdGhlIERvY2tlcmZpbGUuCg=="},{"path":"go.mod","exec":false,"body":"bW9kdWxlIGV4YW1wbGUuY29tL2dvLWRvY2tlcmZpbGUKCmdvIDEuMjQK"},{"path":"main.go","exec":false,"body":"Ly8gQSBtaW5pbWFsIHdlYiBzZXJ2aWNlIGZvciBBc3RyaXM6IGl0IHJlYWRzIFBPUlQsIGJpbmRzIDAuMC4wLjAgYW5kIGFuc3dlcnMKLy8gR0VUIC9oZWFsdGguCnBhY2thZ2UgbWFpbgoKaW1wb3J0ICgKCSJsb2ciCgkibmV0IgoJIm5ldC9odHRwIgoJIm9zIgoJInRpbWUiCikKCmZ1bmMgbWFpbigpIHsKCXBvcnQgOj0gb3MuR2V0ZW52KCJQT1JUIikKCWlmIHBvcnQgPT0gIiIgewoJCXBvcnQgPSAiMzAwMCIKCX0KCgltdXggOj0gaHR0cC5OZXdTZXJ2ZU11eCgpCgltdXguSGFuZGxlRnVuYygiR0VUIC9oZWFsdGgiLCBmdW5jKHcgaHR0cC5SZXNwb25zZVdyaXRlciwgciAqaHR0cC5SZXF1ZXN0KSB7CgkJdy5IZWFkZXIoKS5TZXQoIkNvbnRlbnQtVHlwZSIsICJhcHBsaWNhdGlvbi9qc29uIikKCQlfLCBfID0gdy5Xcml0ZShbXWJ5dGUoYHsib2siOnRydWV9YCkpCgl9KQoJbXV4LkhhbmRsZUZ1bmMoIkdFVCAveyR9IiwgZnVuYyh3IGh0dHAuUmVzcG9uc2VXcml0ZXIsIHIgKmh0dHAuUmVxdWVzdCkgewoJCXcuSGVhZGVyKCkuU2V0KCJDb250ZW50LVR5cGUiLCAidGV4dC9wbGFpbjsgY2hhcnNldD11dGYtOCIpCgkJXywgXyA9IHcuV3JpdGUoW11ieXRlKCJIZWxsbyBmcm9tIEFzdHJpcy5cbiIpKQoJfSkKCglzZXJ2ZXIgOj0gJmh0dHAuU2VydmVyewoJCUFkZHI6ICAgICAgICAgICAgICBuZXQuSm9pbkhvc3RQb3J0KCIwLjAuMC4wIiwgcG9ydCksCgkJSGFuZGxlcjogICAgICAgICAgIG11eCwKCQlSZWFkSGVhZGVyVGltZW91dDogMTAgKiB0aW1lLlNlY29uZCwKCX0KCWxvZy5QcmludGYoImxpc3RlbmluZyBvbiAlcyIsIHNlcnZlci5BZGRyKQoJbG9nLkZhdGFsKHNlcnZlci5MaXN0ZW5BbmRTZXJ2ZSgpKQp9Cg=="}]},"nextjs-postgres":{"files":[{"path":".dockerignore","exec":false,"body":"LmdpdApub2RlX21vZHVsZXMKLm5leHQKLmVudgouZW52LioK"},{"path":".env.example","exec":false,"body":"REFUQUJBU0VfVVJMPQo="},{"path":".gitignore","exec":false,"body":"bm9kZV9tb2R1bGVzCi5uZXh0Ci5lbnYKLmVudi4qCiEuZW52LmV4YW1wbGUK"},{"path":"Dockerfile","exec":false,"body":"RlJPTSBub2RlOjIyLWJvb2t3b3JtLXNsaW0gQVMgYnVpbGRlcgpXT1JLRElSIC9hcHAKQ09QWSBwYWNrYWdlLmpzb24gcG5wbS1sb2NrLnlhbWwgLi8KUlVOIGNvcmVwYWNrIHBucG0gaW5zdGFsbCAtLWZyb3plbi1sb2NrZmlsZQpDT1BZIC4gLgpSVU4gbWtkaXIgLXAgcHVibGljClJVTiBjb3JlcGFjayBwbnBtIHJ1biBidWlsZAoKRlJPTSBub2RlOjIyLWJvb2t3b3JtLXNsaW0KV09SS0RJUiAvYXBwCkVOViBOT0RFX0VOVj1wcm9kdWN0aW9uCkVOViBIT1NUTkFNRT0wLjAuMC4wCkVOViBQT1JUPTMwMDAKQ09QWSAtLWZyb209YnVpbGRlciAtLWNob3duPW5vZGU6bm9kZSAvYXBwLy5uZXh0L3N0YW5kYWxvbmUgLi8KQ09QWSAtLWZyb209YnVpbGRlciAtLWNob3duPW5vZGU6bm9kZSAvYXBwLy5uZXh0L3N0YXRpYyAuLy5uZXh0L3N0YXRpYwpDT1BZIC0tZnJvbT1idWlsZGVyIC0tY2hvd249bm9kZTpub2RlIC9hcHAvcHVibGljIC4vcHVibGljClVTRVIgbm9kZQpFWFBPU0UgMzAwMApDTUQgWyJub2RlIiwgInNlcnZlci5qcyJdCg=="},{"path":"README.md","exec":false,"body":"IyBOZXh0LmpzICsgUG9zdGdyZXMgc3RhcnRlcgoKQSBzbWFsbCBOZXh0LmpzIGFwcCB3aXRoIG9uZSBQb3N0Z3JlcyB0YWJsZS4gRWFjaCB2aXNpdCB0byB0aGUgaG9tZSBwYWdlIGFkZHMgYSByb3cgYW5kIHNob3dzIHRoZSBjb3VudC4gYC9oZWFsdGhgIGFuc3dlcnMgYHsib2siOnRydWV9YCBhbmQgZG9lcyBub3QgdXNlIHRoZSBkYXRhYmFzZS4KCiMjIERlcGxveSBvbiBBc3RyaXMKCkFzayB5b3VyIGNvZGluZyBhZ2VudCB0byBydW4gdGhlc2Ugc3RlcHMgd2l0aCB0aGUgQXN0cmlzIE1DUC4KCjEuIENyZWF0ZSBhIFBvc3RncmVzIGRhdGFiYXNlIHdpdGggdGhlIGBkYXRhYmFzZWAgdG9vbDogYGFjdGlvbmAgY3JlYXRlLCBga2luZGAgcG9zdGdyZXMsIHlvdXIgcHJvamVjdCBuYW1lIGFuZCBhIGRhdGFiYXNlIG5hbWUuIEtlZXAgdGhlIGFuc3dlciwgYmVjYXVzZSBBc3RyaXMgc2hvd3MgdGhlIHBhc3N3b3JkIG9ubHkgb25jZS4KMi4gRGVwbG95IHRoZSBhcHAgd2l0aCB0aGUgYGRlcGxveWAgdG9vbDogYGdpdF91cmxgIGh0dHBzOi8vZ2l0aHViLmNvbS9hc3RyaXMtbGFicy90ZW1wbGF0ZS1uZXh0anMtcG9zdGdyZXMsIGBicmFuY2hgIG1haW4sIGBidWlsZGAgZG9ja2VyZmlsZSwgYGRvY2tlcmZpbGVgIERvY2tlcmZpbGUsIHRoZSBzYW1lIHByb2plY3QgYW5kIGFuIGFwcCBuYW1lLgozLiBTZXQgYERBVEFCQVNFX1VSTGAgd2l0aCB0aGUgYGVudmAgdG9vbC4gQnVpbGQgaXQgZnJvbSB0aGUgZGF0YWJhc2UgYW5zd2VyOiBgcG9zdGdyZXM6Ly88dXNlcj46PHBhc3N3b3JkPkA8aG9zdD46PHBvcnQ+LzxkYXRhYmFzZT5gLiBgZW52YCByZXBsYWNlcyBldmVyeSB2YXJpYWJsZSBvbiB0aGUgYXBwLCBzbyBzZW5kIGFueSBvdGhlciB2YXJpYWJsZXMgaW4gdGhlIHNhbWUgY2FsbC4KNC4gUmVzdGFydCB0aGUgYXBwIHdpdGggdGhlIGByZXN0YXJ0YCB0b29sLCBzbyB0aGF0IGl0IHJlYWRzIHRoZSBuZXcgdmFyaWFibGUuCjUuIEJpbmQgYW4gYWRkcmVzcyB3aXRoIHRoZSBgZG9tYWluc2AgdG9vbCwgdGhlbiBvcGVuIGl0LgoKS2VlcCB0aGUgcGFzc3dvcmQgb3V0IG9mIHlvdXIgZmlsZXMgYW5kIGNvbW1pdHMuIEl0IGJlbG9uZ3Mgb25seSBpbiB0aGUgYXBwJ3MgdmFyaWFibGVzLgoKIyMgUnVuIGl0IG9uIHlvdXIgY29tcHV0ZXIKClNldCBgREFUQUJBU0VfVVJMYCB0byBhIFBvc3RncmVzIGRhdGFiYXNlIHRoYXQgeW91IHJ1biwgdGhlbiBydW4gYHBucG0gaW5zdGFsbGAgYW5kIGBwbnBtIGRldmAuCg=="},{"path":"app/health/route.js","exec":false,"body":"Ly8gQW5zd2VycyB3aXRob3V0IHRoZSBkYXRhYmFzZSwgc28gYSBkZXBsb3kgaXMgaGVhbHRoeSBiZWZvcmUgREFUQUJBU0VfVVJMIGlzIHNldC4KZXhwb3J0IGNvbnN0IGR5bmFtaWMgPSAiZm9yY2UtZHluYW1pYyI7CgpleHBvcnQgZnVuY3Rpb24gR0VUKCkgewogIHJldHVybiBSZXNwb25zZS5qc29uKHsgb2s6IHRydWUgfSk7Cn0K"},{"path":"app/layout.js","exec":false,"body":"ZXhwb3J0IGNvbnN0IG1ldGFkYXRhID0geyB0aXRsZTogIk5leHQuanMgKyBQb3N0Z3JlcyBvbiBBc3RyaXMiIH07CgpleHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBSb290TGF5b3V0KHsgY2hpbGRyZW4gfSkgewogIHJldHVybiAoCiAgICA8aHRtbCBsYW5nPSJlbiI+CiAgICAgIDxib2R5PntjaGlsZHJlbn08L2JvZHk+CiAgICA8L2h0bWw+CiAgKTsKfQo="},{"path":"app/page.js","exec":false,"body":"aW1wb3J0IHsgZ2V0UG9vbCB9IGZyb20gIi4uL2xpYi9kYiI7CmltcG9ydCB7IHJlY29yZFZpc2l0IH0gZnJvbSAiLi4vbGliL3Zpc2l0cyI7CgpleHBvcnQgY29uc3QgZHluYW1pYyA9ICJmb3JjZS1keW5hbWljIjsKCmV4cG9ydCBkZWZhdWx0IGFzeW5jIGZ1bmN0aW9uIEhvbWUoKSB7CiAgaWYgKCFwcm9jZXNzLmVudi5EQVRBQkFTRV9VUkwpIHsKICAgIHJldHVybiAoCiAgICAgIDxtYWluPgogICAgICAgIDxoMT5OZXh0LmpzICsgUG9zdGdyZXMgb24gQXN0cmlzPC9oMT4KICAgICAgICA8cD5TZXQgREFUQUJBU0VfVVJMIG9uIHRoaXMgYXBwLCB0aGVuIHJlc3RhcnQgaXQuPC9wPgogICAgICA8L21haW4+CiAgICApOwogIH0KICBjb25zdCBjb3VudCA9IGF3YWl0IHJlY29yZFZpc2l0KGdldFBvb2woKSk7CiAgcmV0dXJuICgKICAgIDxtYWluPgogICAgICA8aDE+TmV4dC5qcyArIFBvc3RncmVzIG9uIEFzdHJpczwvaDE+CiAgICAgIDxwPlZpc2l0czoge2NvdW50fTwvcD4KICAgIDwvbWFpbj4KICApOwp9Cg=="},{"path":"lib/db.js","exec":false,"body":"aW1wb3J0IHBnIGZyb20gInBnIjsKCi8vIE9uZSBwb29sIHBlciBzZXJ2ZXIgcHJvY2Vzcy4gREFUQUJBU0VfVVJMIGlzIHJlYWQgb24gdGhlIGZpcnN0IHF1ZXJ5LCBzbyB0aGUKLy8gYnVpbGQgYW5kIC9oZWFsdGggcnVuIHdpdGhvdXQgaXQuCmxldCBwb29sOwoKZXhwb3J0IGNvbnN0IGdldFBvb2wgPSAoKSA9PiB7CiAgcG9vbCA/Pz0gbmV3IHBnLlBvb2woeyBjb25uZWN0aW9uU3RyaW5nOiBwcm9jZXNzLmVudi5EQVRBQkFTRV9VUkwsIG1heDogNSB9KTsKICByZXR1cm4gcG9vbDsKfTsK"},{"path":"lib/visits.js","exec":false,"body":"Ly8gUmVjb3JkcyBvbmUgdmlzaXQgYW5kIHJldHVybnMgaG93IG1hbnkgdGhlcmUgYXJlLiBgZGJgIGlzIGFueXRoaW5nIHdpdGgKLy8gcXVlcnkoc3FsLCBwYXJhbXMpIHRoYXQgYW5zd2VycyB7IHJvd3MgfTogYSBwZyBQb29sIG9yIGEgUEdsaXRlIGNsaWVudC4KZXhwb3J0IGNvbnN0IHJlY29yZFZpc2l0ID0gYXN5bmMgKGRiKSA9PiB7CiAgYXdhaXQgZGIucXVlcnkoCiAgICAiY3JlYXRlIHRhYmxlIGlmIG5vdCBleGlzdHMgdmlzaXRzIChpZCBzZXJpYWwgcHJpbWFyeSBrZXksIHZpc2l0ZWRfYXQgdGltZXN0YW1wdHogbm90IG51bGwgZGVmYXVsdCBub3coKSkiLAogICk7CiAgYXdhaXQgZGIucXVlcnkoImluc2VydCBpbnRvIHZpc2l0cyBkZWZhdWx0IHZhbHVlcyIpOwogIGNvbnN0IHsgcm93cyB9ID0gYXdhaXQgZGIucXVlcnkoInNlbGVjdCBjb3VudCgqKTo6aW50IGFzIGNvdW50IGZyb20gdmlzaXRzIik7CiAgcmV0dXJuIHJvd3NbMF0uY291bnQ7Cn07Cg=="},{"path":"next.config.mjs","exec":false,"body":"LyoqIEB0eXBlIHtpbXBvcnQoIm5leHQiKS5OZXh0Q29uZmlnfSAqLwpjb25zdCBuZXh0Q29uZmlnID0geyBvdXRwdXQ6ICJzdGFuZGFsb25lIiB9OwoKZXhwb3J0IGRlZmF1bHQgbmV4dENvbmZpZzsK"},{"path":"package.json","exec":false,"body":"ewogICJuYW1lIjogIm5leHRqcy1wb3N0Z3JlcyIsCiAgInZlcnNpb24iOiAiMC4xLjAiLAogICJwcml2YXRlIjogdHJ1ZSwKICAic2NyaXB0cyI6IHsKICAgICJkZXYiOiAibmV4dCBkZXYiLAogICAgImJ1aWxkIjogIm5leHQgYnVpbGQiLAogICAgInN0YXJ0IjogIm5leHQgc3RhcnQgLUggMC4wLjAuMCIKICB9LAogICJkZXBlbmRlbmNpZXMiOiB7CiAgICAibmV4dCI6ICIxNi40LjEiLAogICAgInBnIjogIjguMjMuMCIsCiAgICAicmVhY3QiOiAiMTkuMy4wIiwKICAgICJyZWFjdC1kb20iOiAiMTkuMy4wIgogIH0sCiAgImVuZ2luZXMiOiB7CiAgICAibm9kZSI6ICI+PTIyIgogIH0sCiAgInBhY2thZ2VNYW5hZ2VyIjogInBucG1AMTAuMzMuMyIKfQo="},{"path":"pnpm-lock.yaml","exec":false,"body":"lockfileVersion: '9.0'

settings:
  autoInstallPeers: true
  excludeLinksFromLockfile: false

importers:

  .:
    dependencies:
      next:
        specifier: 16.4.1
        version: 16.4.1(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
      pg:
        specifier: 8.23.0
        version: 8.23.0
      react:
        specifier: 19.3.0
        version: 19.3.0
      react-dom:
        specifier: 19.3.0
        version: 19.3.0(react@19.3.0)

packages:

  '@emnapi/runtime@1.11.3':
    resolution: {integrity: sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==}

  '@img/colour@1.1.0':
    resolution: {integrity: sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==}
    engines: {node: '>=18'}

  '@img/sharp-darwin-arm64@0.35.5':
    resolution: {integrity: sha512-QRUlFQ0WxvdWyqqG/WtI3iupfD5rBzmCHXSdPsY91sAtVtTo7Q4cb6zOccZ3gqEqkr0f1As1ehLqmEpDsRf+lg==}
    engines: {node: '>=20.9.0'}
    cpu: [arm64]
    os: [darwin]

  '@img/sharp-darwin-x64@0.35.5':
    resolution: {integrity: sha512-+BR255RhDlpygUpOc/Jdt1nT6DQ3XG/ERo5wbcdOf5Q320dKtPCKPLR1LJs9VGXRaMa8l1uUa0tkCNOXiAxZUw==}
    engines: {node: '>=20.9.0'}
    cpu: [x64]
    os: [darwin]

  '@img/sharp-freebsd-wasm32@0.35.5':
    resolution: {integrity: sha512-Y/z91nEZ4uIBX5X3nfTovjU9lHNKFYbL2lpHCLVNmXQK03VIZvXBBt0KxbPGp2SdGSF+2mQU4e+hQaWOt86iAw==}
    engines: {node: '>=20.9.0'}
    os: [freebsd]

  '@img/sharp-libvips-darwin-arm64@1.3.4':
    resolution: {integrity: sha512-5R89nBYiRdUlSWJxPhO+GVtaXzXSxKnRu/xqMn3KTA3L9EB9Oy/P+Nn2f2vlhPuUdy/Zusb2DarbyTpGCfEDuw==}
    cpu: [arm64]
    os: [darwin]

  '@img/sharp-libvips-darwin-x64@1.3.4':
    resolution: {integrity: sha512-iR2OKH80yi0U+dUplyh3/xdpFvps6YkCwsXenIJxqxR1v9o+xtKTGbS9H7cps+2Vxjc8B1j96p75NmTGjIhtpQ==}
    cpu: [x64]
    os: [darwin]

  '@img/sharp-libvips-linux-arm64@1.3.4':
    resolution: {integrity: sha512-Y3dgX/6lE2QhQb+Gxy0WZxfg9MEm/JBjamZpS2IklP7xIQoKN4hzAm7KcMVGtaVDt3neE9OKBC7vAfonA/Lr1A==}
    cpu: [arm64]
    os: [linux]
    libc: [glibc]

  '@img/sharp-libvips-linux-arm@1.3.4':
    resolution: {integrity: sha512-LmRtTsOHuvM2+wlO2Db37dx5MiZhB0FvSunciw48YjdOkZz9KAiRbm8ujeMOA1INqmei5NapFxYEK1D1ZSidmw==}
    cpu: [arm]
    os: [linux]
    libc: [glibc]

  '@img/sharp-libvips-linux-ppc64@1.3.4':
    resolution: {integrity: sha512-Le6boB8Tai0Nis+gIxIpKx68UDVVIqdR8Tin5Yf1z2LJJQLDJvCDRqRu+jC2qCoD+eIomonmOwB4smBRxfVpYQ==}
    cpu: [ppc64]
    os: [linux]
    libc: [glibc]

  '@img/sharp-libvips-linux-riscv64@1.3.4':
    resolution: {integrity: sha512-aHkkIEHPRdQEegJN20MLmGtxYD9R2wQr3Cwpddnu5+YKMt6Uzax7S9h5gpZTo8wyrGuZSlfQ63OevL5mTyOC7Q==}
    cpu: [riscv64]
    os: [linux]
    libc: [glibc]

  '@img/sharp-libvips-linux-s390x@1.3.4':
    resolution: {integrity: sha512-ra/mB6MikESDUO7Yg+Mi95bFBb9GsObURuhnOv3OqknjGe9sZrG8tCe9q0xSIGrtLgvgw0gKnFWcK4blSgQOuQ==}
    cpu: [s390x]
    os: [linux]
    libc: [glibc]

  '@img/sharp-libvips-linux-x64@1.3.4':
    resolution: {integrity: sha512-GJ//SSXbnwSDes02umB3nDJLFcQzw8a18V8fyhqr6tV515tOEMdImjjxj1AoafMRz56F3PHgftnj1QEKSU1zkw==}
    cpu: [x64]
    os: [linux]
    libc: [glibc]

  '@img/sharp-libvips-linuxmusl-arm64@1.3.4':
    resolution: {integrity: sha512-hvulFwtjUcagsis6BBxHwGFwWoNZjgYmULGVrZcyfNbjA8hKILbRxGg15/7w5HDyXHXUos/j6baAWqnCyQ2DWA==}
    cpu: [arm64]
    os: [linux]
    libc: [musl]

  '@img/sharp-libvips-linuxmusl-x64@1.3.4':
    resolution: {integrity: sha512-6zXKeE/p39I1AmA3cJG35eyBGNqNddLnUXjhwBnsGjFPWqf5VKkDBEqaEkPDoTEtkxwi2vv8Tcr2mDyP4So7Fg==}
    cpu: [x64]
    os: [linux]
    libc: [musl]

  '@img/sharp-linux-arm64@0.35.5':
    resolution: {integrity: sha512-LYVx5JTsOM2CBzmxreh+nl64/3H6Xb09iSLknqH47z2T2DFFxDeFLP5y4dJwe6H7uGQlHPyEEtIqyo3DYsRwdQ==}
    engines: {node: '>=20.9.0'}
    cpu: [arm64]
    os: [linux]
    libc: [glibc]

  '@img/sharp-linux-arm@0.35.5':
    resolution: {integrity: sha512-LEaXK2WdXVK5ykcw0buWyPMsmLLL2vpHLD6yrNSW+JGEL3BZPA4tpKN6iaMc4AxTTAoaX/sU1rOL51lcIz48ZQ==}
    engines: {node: '>=20.9.0'}
    cpu: [arm]
    os: [linux]
    libc: [glibc]

  '@img/sharp-linux-ppc64@0.35.5':
    resolution: {integrity: sha512-QVxAAq8evVRI9ia2vqgwrmWucn5Dfv+JdWzj75pD8omHLPSP7f8p20O8jxzjCcuCEQEOtYOZUmX1hkiZ0kdevA==}
    engines: {node: '>=20.9.0'}
    cpu: [ppc64]
    os: [linux]
    libc: [glibc]

  '@img/sharp-linux-riscv64@0.35.5':
    resolution: {integrity: sha512-LtdreXguaavKODPIfzJ4kffx7UNt1omwtK0rch4EBbbSTXPnxWmYSayXdLJw0fJzQ97kHt1gL/yh4tvU+nCyRQ==}
    engines: {node: '>=20.9.0'}
    cpu: [riscv64]
    os: [linux]
    libc: [glibc]

  '@img/sharp-linux-s390x@0.35.5':
    resolution: {integrity: sha512-UZasTOFiYzotTsGOCu42BfUzP6Tu6Do/947iRm1RsLKvlllxwGcn4RN27LibGWceix4Y+Pmw3jsnTcCQIgWjqA==}
    engines: {node: '>=20.9.0'}
    cpu: [s390x]
    os: [linux]
    libc: [glibc]

  '@img/sharp-linux-x64@0.35.5':
    resolution: {integrity: sha512-SxFtLTeJInhAA9Q836kux2vZNeOBQEx658qvbboZScr0wIARym3IcGmW7KpVD5sbVg0Ojy+udFQdayYIZyoNog==}
    engines: {node: '>=20.9.0'}
    cpu: [x64]
    os: [linux]
    libc: [glibc]

  '@img/sharp-linuxmusl-arm64@0.35.5':
    resolution: {integrity: sha512-9HbMclmI1zlNkFRs3z9/eBtDjfD0sGlrX1z6b1qwmiFY5ElDLh4BC0LPBdVp7z1DXFiKlIcznf+ZlsuZzLxQqg==}
    engines: {node: '>=20.9.0'}
    cpu: [arm64]
    os: [linux]
    libc: [musl]

  '@img/sharp-linuxmusl-x64@0.35.5':
    resolution: {integrity: sha512-4KOphqB035HrVdqLZfCgMzzERrQkkzOwRhl4OAkRO1YCldbaFjySXMaK534Mo0V+LndnlJk+sbUyLeU0ULyD1A==}
    engines: {node: '>=20.9.0'}
    cpu: [x64]
    os: [linux]
    libc: [musl]

  '@img/sharp-wasm32@0.35.5':
    resolution: {integrity: sha512-Ptsga1su4tQx+LLF1ECS9U6nz5kmrXKo6XVbtR48Ke3ZRxxgaWBu7IDtEe1quo8hiupwm6WFqxVlXaSf7IINGQ==}
    engines: {node: '>=20.9.0'}

  '@img/sharp-webcontainers-wasm32@0.35.5':
    resolution: {integrity: sha512-hfhF/FmoQyTUkA0bIKFOtw536BQSeBMe6BF6QyWlrPxT754+TFLaZ7sKKTfvvM0yJgKgaYTwnFCIZ/GuDw5SUA==}
    engines: {node: '>=20.9.0'}
    cpu: [wasm32]

  '@img/sharp-win32-arm64@0.35.5':
    resolution: {integrity: sha512-X4t7g+7ZA5DKblCBEXGjUqqemj4vczING/5viFwAL8h4N3qYeyjwdCvRLHi4EdOUI+2Z7UFlp1VM+p/AuEtm6Q==}
    engines: {node: '>=20.9.0'}
    cpu: [arm64]
    os: [win32]

  '@img/sharp-win32-ia32@0.35.5':
    resolution: {integrity: sha512-5Zm82LoBc43nhwNybZlG7Y1KO//Zhsn306fQl29ZOuStHLGTo3BWL83q3cznX0poxSAMuYL1On/BHBxkBeKr6A==}
    engines: {node: ^20.9.0}
    cpu: [ia32]
    os: [win32]

  '@img/sharp-win32-x64@0.35.5':
    resolution: {integrity: sha512-x76eH0vEiHlcMQu8Y8IenntaACtddpT6W0wmXtWrnKcnKI7ME5DdgqhAD6SEWOEl1v2zDvkZDhFA9KnURwpfqg==}
    engines: {node: '>=20.9.0'}
    cpu: [x64]
    os: [win32]

  '@next/env@16.4.1':
    resolution: {integrity: sha512-5sUUrrSvs/2/2LnLoesybMGx12EtPB46fdZ6RhAw0XDGSPxU2LFyQBB7yuEiOFFJPKmBY6+q2jTr1/AMbnp0/g==}

  '@next/swc-darwin-arm64@16.4.1':
    resolution: {integrity: sha512-U+hQ5Gj3fpzf4fveTIF3dpUFYhaSW8vHhdAnbiIomzXzg7boreYFgBqprepXFtW4sw+aTttiNmg0gew/iFNhbg==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [darwin]

  '@next/swc-darwin-x64@16.4.1':
    resolution: {integrity: sha512-/hqC3V1XLUjhMASf/WridKdO9FXoEgN3HBWmtKbj00MPgnltutfraWJ3bYTpCRIgEIpbjJyOVLpYgAhh/BkdcQ==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [darwin]

  '@next/swc-linux-arm64-gnu@16.4.1':
    resolution: {integrity: sha512-GHzncHbcaS9g95kcvTNtKQW3aCLoR+xc3Jm7qrkpk1R+D2BjMHIPyvQGRPKCdMX95BsH/421jBUK06q9tEwzjw==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [linux]
    libc: [glibc]

  '@next/swc-linux-arm64-musl@16.4.1':
    resolution: {integrity: sha512-1SuJyDxW/PR9dHJat/ZRgcYLhuSZ+1psP4DlKb2tKIuXbjygqpLrJWRSq+onZQBv8LcmU67EIrmb6c3XTaJLjw==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [linux]
    libc: [musl]

  '@next/swc-linux-x64-gnu@16.4.1':
    resolution: {integrity: sha512-Istng1hMGp9TGO4lUqeKLd70MPN/OOkucVTP2Nmj+gLkwBgmPqUw8CJYBCC7nbl/B/23bBCcjCI5Hsh6hazC1A==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [linux]
    libc: [glibc]

  '@next/swc-linux-x64-musl@16.4.1':
    resolution: {integrity: sha512-aSC9wMNiZRRFVpPkPWBzRwLQxIGm/CiQcXyFF1XNcgodb+uMxdk7aSSGGpDXCbnvZdf4itjHxpOd5h7i7zaiYw==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [linux]
    libc: [musl]

  '@next/swc-win32-arm64-msvc@16.4.1':
    resolution: {integrity: sha512-t/myvwFDlypMUjRvbBf8qLPyuaB0iXYYdBtwMt6DM6f+60wtGr4bSYholdPqNeV5VUXZhrpMwfza829kmhS3iA==}
    engines: {node: '>= 10'}
    cpu: [arm64]
    os: [win32]

  '@next/swc-win32-x64-msvc@16.4.1':
    resolution: {integrity: sha512-6ICqPo9awCkrtYNPhwkx1uU7rlFWrZRrIboDHS2LU+jv088UBYQtmJ25h6pCp27/+FZjF6BQ4Te4ErugyMeuBg==}
    engines: {node: '>= 10'}
    cpu: [x64]
    os: [win32]

  '@swc/helpers@0.5.23':
    resolution: {integrity: sha512-5lSsMOTXURePglDfvuAQUqkGek9Hg2kksOYay2m0+XR++b2NWYL/4sWyuvVBIs8oKnJaxkdi9whaL/sqN13afw==}

  baseline-browser-mapping@2.11.31:
    resolution: {integrity: sha512-b0k7wXlWjpuL/Uxb/pYlpjY0ej5BjAmurtPUk3eRGuloI4yjK32m8TiKUQ81l1ptcLjKS/KH2+uqIolZti1x4Q==}
    engines: {node: '>=6.0.0'}
    hasBin: true

  caniuse-lite@1.0.30001819:
    resolution: {integrity: sha512-LFUqIIAwpzsIuevnKnsR9qnStBcgzPShTX61lBwN9uFkkf8o8zLiebEjbW8AYtZiF+1YKDWfdt/pWDtMuG8Xwg==}

  client-only@0.0.1:
    resolution: {integrity: sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==}

  detect-libc@2.1.2:
    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
    engines: {node: '>=8'}

  nanoid@3.3.20:
    resolution: {integrity: sha512-uKdg2G3GNCKQn9byYOpxbGqrT2fGO5KRt5J/8b3pok8rT6qxGWF6hxMyJiEYtAf+FVyYuD9hRaDqX5uPFYJ4ZQ==}
    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
    hasBin: true

  next@16.4.1:
    resolution: {integrity: sha512-uc657V62E34fOI6W5NtG9IzwsPcms0Z60grz2MJGtglgD+pTFnNt4Yw2PzaU622tfX4vhrDgLZzicE2YlhI20Q==}
    engines: {node: '>=20.9.0'}
    hasBin: true
    peerDependencies:
      '@opentelemetry/api': ^1.1.0
      '@playwright/test': ^1.51.1
      babel-plugin-react-compiler: '*'
      react: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0
      react-dom: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0
      sass: ^1.3.0
    peerDependenciesMeta:
      '@opentelemetry/api':
        optional: true
      '@playwright/test':
        optional: true
      babel-plugin-react-compiler:
        optional: true
      sass:
        optional: true

  pg-cloudflare@1.4.1:
    resolution: {integrity: sha512-6PQbsFWZcp9EmJEwy5cGQ2La+AMWpP46lgbb8X+U/XsHIUweYDNCpeuKck5RxL2MdVFi7krbbEi5nX4Zh7JhrQ==}

  pg-connection-string@2.14.1:
    resolution: {integrity: sha512-qR3kGNPBLpCNtz0evbKA0Y/MRFXwSSdT+pTJvYp/bXTcReZbvX1kzF0IyTc1QnxqF7AZbOeBhNL8R5mYQZV/MA==}

  pg-int8@1.0.1:
    resolution: {integrity: sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==}
    engines: {node: '>=4.0.0'}

  pg-pool@3.14.0:
    resolution: {integrity: sha512-gKtPkFdQPU3DksooVLi9LsjZxrsBUZIpa+7aVx+LV5pNh0KzP4Zleud2po+ConrxbuXGBJ6Hfer6hdgpIBpBaw==}
    peerDependencies:
      pg: '>=8.0'

  pg-protocol@1.16.1:
    resolution: {integrity: sha512-p9VOFMiHB/ZbJATetbg+99PxssTVSQRnyuPSQ67mN1+1KBOjZaZ83ZQzltnxPhJwSsC3nwVjJ10DVJlerbFzLg==}

  pg-types@2.2.0:
    resolution: {integrity: sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==}
    engines: {node: '>=4'}

  pg@8.23.0:
    resolution: {integrity: sha512-Ip2EQCngowJLGOfCwkFhPXU7/ljlhn6Rxlmy4XYfL2Y+vyRM59+8uR2xqRWKdYmbXmxCFOAmKxBuSUCdF34qLg==}
    engines: {node: '>= 16.0.0'}
    peerDependencies:
      pg-native: '>=3.0.1'
    peerDependenciesMeta:
      pg-native:
        optional: true

  pgpass@1.0.5:
    resolution: {integrity: sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==}

  picocolors@1.1.1:
    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}

  postcss@8.5.23:
    resolution: {integrity: sha512-g50586zr4bZmwFiTlflMu8E0bDTb5I5gertgwAKmsdUlTQIhZtunzUlD1WSzwcVWPoAVpsrA6vlfCD7oXvRwgg==}
    engines: {node: ^10 || ^12 || >=14}

  postgres-array@2.0.0:
    resolution: {integrity: sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==}
    engines: {node: '>=4'}

  postgres-bytea@1.0.1:
    resolution: {integrity: sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==}
    engines: {node: '>=0.10.0'}

  postgres-date@1.0.7:
    resolution: {integrity: sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==}
    engines: {node: '>=0.10.0'}

  postgres-interval@1.2.0:
    resolution: {integrity: sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==}
    engines: {node: '>=0.10.0'}

  react-dom@19.3.0:
    resolution: {integrity: sha512-JDk8dgif51OjFoDE70+OT9ICyYr+69HlmihNwp1+Nsfbna3t5sIiCa9ZJktDmQ4/1b/rn26hIAR2uYXDMr5r0Q==}
    peerDependencies:
      react: ^19.3.0

  react@19.3.0:
    resolution: {integrity: sha512-E8LUcbtBWt20bbl2YoHfx4ZDBdxVTfOKtCZn9cDSJ4l6/nuoApcpIBcj47t2wZoVX8g2ZHuMHbiShgCR1T5Sog==}
    engines: {node: '>=0.10.0'}

  scheduler@0.28.0:
    resolution: {integrity: sha512-juorfCmIkIw8tT+p5BXSm6PJjQF/ycEYmKyzURCIt/RaZIhL+PulbQ9Yu2z1HdOJDdqDTlxA1+xKBmHXJsczAw==}

  semver@7.8.5:
    resolution: {integrity: sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==}
    engines: {node: '>=10'}
    hasBin: true

  sharp@0.35.5:
    resolution: {integrity: sha512-Ywn4OnzGukp7CDMrp08RQ50YKmuwG47brZgIVPTvBaaAfQlRlygrRqSrxdCiL9M+LlzLBiJ68IR1QqvzHyjC7g==}
    engines: {node: '>=20.9.0'}
    peerDependencies:
      '@types/node': '*'
    peerDependenciesMeta:
      '@types/node':
        optional: true

  source-map-js@1.2.2:
    resolution: {integrity: sha512-KGj/8Y43x35aZVDtt+J4mK1hoLGHULMYfSkODJNQjNDC3oW1PqPoxMwo0pLUsWM/UEGzON/NxeHywEfNXNP3Vw==}
    engines: {node: '>=0.10.0'}

  split2@4.2.0:
    resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==}
    engines: {node: '>= 10.x'}

  styled-jsx@5.1.6:
    resolution: {integrity: sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA==}
    engines: {node: '>= 12.0.0'}
    peerDependencies:
      '@babel/core': '*'
      babel-plugin-macros: '*'
      react: '>= 16.8.0 || 17.x.x || ^18.0.0-0 || ^19.0.0-0'
    peerDependenciesMeta:
      '@babel/core':
        optional: true
      babel-plugin-macros:
        optional: true

  tslib@2.8.1:
    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}

  xtend@4.0.2:
    resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
    engines: {node: '>=0.4'}

snapshots:

  '@emnapi/runtime@1.11.3':
    dependencies:
      tslib: 2.8.1
    optional: true

  '@img/colour@1.1.0':
    optional: true

  '@img/sharp-darwin-arm64@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-darwin-arm64': 1.3.4
    optional: true

  '@img/sharp-darwin-x64@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-darwin-x64': 1.3.4
    optional: true

  '@img/sharp-freebsd-wasm32@0.35.5':
    dependencies:
      '@img/sharp-wasm32': 0.35.5
    optional: true

  '@img/sharp-libvips-darwin-arm64@1.3.4':
    optional: true

  '@img/sharp-libvips-darwin-x64@1.3.4':
    optional: true

  '@img/sharp-libvips-linux-arm64@1.3.4':
    optional: true

  '@img/sharp-libvips-linux-arm@1.3.4':
    optional: true

  '@img/sharp-libvips-linux-ppc64@1.3.4':
    optional: true

  '@img/sharp-libvips-linux-riscv64@1.3.4':
    optional: true

  '@img/sharp-libvips-linux-s390x@1.3.4':
    optional: true

  '@img/sharp-libvips-linux-x64@1.3.4':
    optional: true

  '@img/sharp-libvips-linuxmusl-arm64@1.3.4':
    optional: true

  '@img/sharp-libvips-linuxmusl-x64@1.3.4':
    optional: true

  '@img/sharp-linux-arm64@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-linux-arm64': 1.3.4
    optional: true

  '@img/sharp-linux-arm@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-linux-arm': 1.3.4
    optional: true

  '@img/sharp-linux-ppc64@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-linux-ppc64': 1.3.4
    optional: true

  '@img/sharp-linux-riscv64@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-linux-riscv64': 1.3.4
    optional: true

  '@img/sharp-linux-s390x@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-linux-s390x': 1.3.4
    optional: true

  '@img/sharp-linux-x64@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-linux-x64': 1.3.4
    optional: true

  '@img/sharp-linuxmusl-arm64@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-linuxmusl-arm64': 1.3.4
    optional: true

  '@img/sharp-linuxmusl-x64@0.35.5':
    optionalDependencies:
      '@img/sharp-libvips-linuxmusl-x64': 1.3.4
    optional: true

  '@img/sharp-wasm32@0.35.5':
    dependencies:
      '@emnapi/runtime': 1.11.3
    optional: true

  '@img/sharp-webcontainers-wasm32@0.35.5':
    dependencies:
      '@img/sharp-wasm32': 0.35.5
    optional: true

  '@img/sharp-win32-arm64@0.35.5':
    optional: true

  '@img/sharp-win32-ia32@0.35.5':
    optional: true

  '@img/sharp-win32-x64@0.35.5':
    optional: true

  '@next/env@16.4.1': {}

  '@next/swc-darwin-arm64@16.4.1':
    optional: true

  '@next/swc-darwin-x64@16.4.1':
    optional: true

  '@next/swc-linux-arm64-gnu@16.4.1':
    optional: true

  '@next/swc-linux-arm64-musl@16.4.1':
    optional: true

  '@next/swc-linux-x64-gnu@16.4.1':
    optional: true

  '@next/swc-linux-x64-musl@16.4.1':
    optional: true

  '@next/swc-win32-arm64-msvc@16.4.1':
    optional: true

  '@next/swc-win32-x64-msvc@16.4.1':
    optional: true

  '@swc/helpers@0.5.23':
    dependencies:
      tslib: 2.8.1

  baseline-browser-mapping@2.11.31: {}

  caniuse-lite@1.0.30001819: {}

  client-only@0.0.1: {}

  detect-libc@2.1.2:
    optional: true

  nanoid@3.3.20: {}

  next@16.4.1(react-dom@19.3.0(react@19.3.0))(react@19.3.0):
    dependencies:
      '@next/env': 16.4.1
      '@swc/helpers': 0.5.23
      baseline-browser-mapping: 2.11.31
      caniuse-lite: 1.0.30001819
      postcss: 8.5.23
      react: 19.3.0
      react-dom: 19.3.0(react@19.3.0)
      styled-jsx: 5.1.6(react@19.3.0)
    optionalDependencies:
      '@next/swc-darwin-arm64': 16.4.1
      '@next/swc-darwin-x64': 16.4.1
      '@next/swc-linux-arm64-gnu': 16.4.1
      '@next/swc-linux-arm64-musl': 16.4.1
      '@next/swc-linux-x64-gnu': 16.4.1
      '@next/swc-linux-x64-musl': 16.4.1
      '@next/swc-win32-arm64-msvc': 16.4.1
      '@next/swc-win32-x64-msvc': 16.4.1
      sharp: 0.35.5
    transitivePeerDependencies:
      - '@babel/core'
      - '@types/node'
      - babel-plugin-macros

  pg-cloudflare@1.4.1:
    optional: true

  pg-connection-string@2.14.1: {}

  pg-int8@1.0.1: {}

  pg-pool@3.14.0(pg@8.23.0):
    dependencies:
      pg: 8.23.0

  pg-protocol@1.16.1: {}

  pg-types@2.2.0:
    dependencies:
      pg-int8: 1.0.1
      postgres-array: 2.0.0
      postgres-bytea: 1.0.1
      postgres-date: 1.0.7
      postgres-interval: 1.2.0

  pg@8.23.0:
    dependencies:
      pg-connection-string: 2.14.1
      pg-pool: 3.14.0(pg@8.23.0)
      pg-protocol: 1.16.1
      pg-types: 2.2.0
      pgpass: 1.0.5
    optionalDependencies:
      pg-cloudflare: 1.4.1

  pgpass@1.0.5:
    dependencies:
      split2: 4.2.0

  picocolors@1.1.1: {}

  postcss@8.5.23:
    dependencies:
      nanoid: 3.3.20
      picocolors: 1.1.1
      source-map-js: 1.2.2

  postgres-array@2.0.0: {}

  postgres-bytea@1.0.1: {}

  postgres-date@1.0.7: {}

  postgres-interval@1.2.0:
    dependencies:
      xtend: 4.0.2

  react-dom@19.3.0(react@19.3.0):
    dependencies:
      react: 19.3.0
      scheduler: 0.28.0

  react@19.3.0: {}

  scheduler@0.28.0: {}

  semver@7.8.5:
    optional: true

  sharp@0.35.5:
    dependencies:
      '@img/colour': 1.1.0
      detect-libc: 2.1.2
      semver: 7.8.5
    optionalDependencies:
      '@img/sharp-darwin-arm64': 0.35.5
      '@img/sharp-darwin-x64': 0.35.5
      '@img/sharp-freebsd-wasm32': 0.35.5
      '@img/sharp-libvips-darwin-arm64': 1.3.4
      '@img/sharp-libvips-darwin-x64': 1.3.4
      '@img/sharp-libvips-linux-arm': 1.3.4
      '@img/sharp-libvips-linux-arm64': 1.3.4
      '@img/sharp-libvips-linux-ppc64': 1.3.4
      '@img/sharp-libvips-linux-riscv64': 1.3.4
      '@img/sharp-libvips-linux-s390x': 1.3.4
      '@img/sharp-libvips-linux-x64': 1.3.4
      '@img/sharp-libvips-linuxmusl-arm64': 1.3.4
      '@img/sharp-libvips-linuxmusl-x64': 1.3.4
      '@img/sharp-linux-arm': 0.35.5
      '@img/sharp-linux-arm64': 0.35.5
      '@img/sharp-linux-ppc64': 0.35.5
      '@img/sharp-linux-riscv64': 0.35.5
      '@img/sharp-linux-s390x': 0.35.5
      '@img/sharp-linux-x64': 0.35.5
      '@img/sharp-linuxmusl-arm64': 0.35.5
      '@img/sharp-linuxmusl-x64': 0.35.5
      '@img/sharp-webcontainers-wasm32': 0.35.5
      '@img/sharp-win32-arm64': 0.35.5
      '@img/sharp-win32-ia32': 0.35.5
      '@img/sharp-win32-x64': 0.35.5
    optional: true

  source-map-js@1.2.2: {}

  split2@4.2.0: {}

  styled-jsx@5.1.6(react@19.3.0):
    dependencies:
      client-only: 0.0.1
      react: 19.3.0

  tslib@2.8.1: {}

  xtend@4.0.2: {}
"}]},"node-worker-cron":{"files":[{"path":".env.example","exec":false,"body":"REFUQUJBU0VfVVJMPQo="},{"path":"README.md","exec":false,"body":"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"},{"path":"heartbeat.mjs","exec":false,"body":"Ly8gVGhlIGNyb24gY29tbWFuZDogd3JpdGVzIG9uZSBoZWFydGJlYXRzIHJvdywgdGhlbiBleGl0cy4KaW1wb3J0IHBnIGZyb20gInBnIjsKaW1wb3J0IHsgSEVBUlRCRUFULCBTQ0hFTUEgfSBmcm9tICIuL3NxbC5tanMiOwoKY29uc3QgdXJsID0gcHJvY2Vzcy5lbnYuREFUQUJBU0VfVVJMOwppZiAoIXVybCkgewogIGNvbnNvbGUuZXJyb3IoIkRBVEFCQVNFX1VSTCBpcyBub3Qgc2V0LiBTZXQgaXQgb24gdGhpcyBhcHAsIHRoZW4gZGVwbG95IGFnYWluLiIpOwogIHByb2Nlc3MuZXhpdCgxKTsKfQoKY29uc3QgY2xpZW50ID0gbmV3IHBnLkNsaWVudCh7IGNvbm5lY3Rpb25TdHJpbmc6IHVybCB9KTsKYXdhaXQgY2xpZW50LmNvbm5lY3QoKTsKdHJ5IHsKICBhd2FpdCBjbGllbnQucXVlcnkoU0NIRU1BKTsKICBjb25zdCB7IHJvd3MgfSA9IGF3YWl0IGNsaWVudC5xdWVyeShIRUFSVEJFQVQpOwogIGNvbnNvbGUubG9nKGBoZWFydGJlYXQgJHtyb3dzWzBdLmlkfSBhdCAke3Jvd3NbMF0uYXQudG9JU09TdHJpbmcoKX1gKTsKfSBmaW5hbGx5IHsKICBhd2FpdCBjbGllbnQuZW5kKCk7Cn0K"},{"path":"keepalive.mjs","exec":false,"body":"Ly8gVGhlIGNyb24gYXBwJ3Mgc3RhcnQuIFRoZSBzY2hlZHVsZSBydW5zIGl0cyBjb21tYW5kIGluc2lkZSB0aGlzIHJ1bm5pbmcKLy8gY29udGFpbmVyLCBzbyB0aGUgY29udGFpbmVyIG11c3Qgc3RheSB1cC4gVGhpcyBkb2VzIG5vIHdvcmsgYW5kIG9wZW5zIG5vIHBvcnQuCmNvbnN0IHRpbWVyID0gc2V0SW50ZXJ2YWwoKCkgPT4ge30sIDEgPDwgMzApOwpwcm9jZXNzLm9uKCJTSUdURVJNIiwgKCkgPT4gewogIGNsZWFySW50ZXJ2YWwodGltZXIpOwogIHByb2Nlc3MuZXhpdCgwKTsKfSk7CmNvbnNvbGUubG9nKCJ3YWl0aW5nIGZvciB0aGUgc2NoZWR1bGUiKTsK"},{"path":"package-lock.json","exec":false,"body":"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"},{"path":"package.json","exec":false,"body":"ewogICJuYW1lIjogIm5vZGUtd29ya2VyLWNyb24iLAogICJwcml2YXRlIjogdHJ1ZSwKICAidHlwZSI6ICJtb2R1bGUiLAogICJlbmdpbmVzIjogewogICAgIm5vZGUiOiAiMjIiCiAgfSwKICAic2NyaXB0cyI6IHsKICAgICJzdGFydCI6ICJub2RlIGtlZXBhbGl2ZS5tanMiCiAgfSwKICAiZGVwZW5kZW5jaWVzIjogewogICAgInBnIjogIl44LjEzLjAiCiAgfQp9Cg=="},{"path":"sql.mjs","exec":false,"body":"Ly8gU1FMIG9ubHksIHNvIGVhY2ggc3RhdGVtZW50IGNhbiBiZSByZWFkIGFuZCB0ZXN0ZWQgd2l0aG91dCBhIGRhdGFiYXNlIGRyaXZlci4KCi8vIEJvdGggdGFibGVzIGFyZSBjcmVhdGVkIGlmIG1pc3NpbmcsIHNvIGV2ZXJ5IHByb2Nlc3MgY2FuIHJ1biB0aGlzIGF0IHN0YXJ0LgpleHBvcnQgY29uc3QgU0NIRU1BID0gYApDUkVBVEUgVEFCTEUgSUYgTk9UIEVYSVNUUyBqb2JzICgKICBpZCBiaWdzZXJpYWwgUFJJTUFSWSBLRVksCiAga2luZCB0ZXh0IE5PVCBOVUxMLAogIHBheWxvYWQganNvbmIgTk9UIE5VTEwgREVGQVVMVCAne30nOjpqc29uYiwKICBzdGF0dXMgdGV4dCBOT1QgTlVMTCBERUZBVUxUICdxdWV1ZWQnLAogIGNyZWF0ZWRfYXQgdGltZXN0YW1wdHogTk9UIE5VTEwgREVGQVVMVCBub3coKSwKICBzdGFydGVkX2F0IHRpbWVzdGFtcHR6LAogIGZpbmlzaGVkX2F0IHRpbWVzdGFtcHR6LAogIGVycm9yIHRleHQKKTsKQ1JFQVRFIElOREVYIElGIE5PVCBFWElTVFMgam9ic19xdWV1ZWQgT04gam9icyAoY3JlYXRlZF9hdCkgV0hFUkUgc3RhdHVzID0gJ3F1ZXVlZCc7CkNSRUFURSBUQUJMRSBJRiBOT1QgRVhJU1RTIGhlYXJ0YmVhdHMgKAogIGlkIGJpZ3NlcmlhbCBQUklNQVJZIEtFWSwKICBhdCB0aW1lc3RhbXB0eiBOT1QgTlVMTCBERUZBVUxUIG5vdygpCik7CmA7CgovLyBUYWtlcyB0aGUgb2xkZXN0IHF1ZXVlZCBqb2IgYW5kIG1hcmtzIGl0IHJ1bm5pbmcuIFNLSVAgTE9DS0VEIGxldHMgc2V2ZXJhbAovLyB3b3JrZXJzIHJ1biBhdCBvbmNlIHdpdGhvdXQgdGFraW5nIHRoZSBzYW1lIGpvYi4KZXhwb3J0IGNvbnN0IENMQUlNID0gYApVUERBVEUgam9icyBTRVQgc3RhdHVzID0gJ3J1bm5pbmcnLCBzdGFydGVkX2F0ID0gbm93KCkKV0hFUkUgaWQgPSAoCiAgU0VMRUNUIGlkIEZST00gam9icyBXSEVSRSBzdGF0dXMgPSAncXVldWVkJwogIE9SREVSIEJZIGNyZWF0ZWRfYXQsIGlkCiAgRk9SIFVQREFURSBTS0lQIExPQ0tFRAogIExJTUlUIDEKKQpSRVRVUk5JTkcgaWQsIGtpbmQsIHBheWxvYWQKYDsKCi8vICQxIGpvYiBpZCwgJDIgJ2RvbmUnIG9yICdmYWlsZWQnLCAkMyBlcnJvciB0ZXh0IG9yIG51bGwuCmV4cG9ydCBjb25zdCBGSU5JU0ggPSBgClVQREFURSBqb2JzIFNFVCBzdGF0dXMgPSAkMiwgZmluaXNoZWRfYXQgPSBub3coKSwgZXJyb3IgPSAkMyBXSEVSRSBpZCA9ICQxCmA7CgpleHBvcnQgY29uc3QgSEVBUlRCRUFUID0gYElOU0VSVCBJTlRPIGhlYXJ0YmVhdHMgREVGQVVMVCBWQUxVRVMgUkVUVVJOSU5HIGlkLCBhdGA7Cg=="},{"path":"worker.mjs","exec":false,"body":"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"}]}}