@cancia/astro 0.0.1

package/dist/index.js

@@ -0,0 +1,712 @@
+import {
+  makeListsRoutes
+} from "./chunk-22DJVJBR.js";
+import {
+  makeSchemasRoute
+} from "./chunk-YPVZDWTW.js";
+import "./chunk-NG5GJME5.js";
+import {
+  setCanciaRuntime
+} from "./chunk-DGCGIEFD.js";
+import {
+  defineList,
+  describeList,
+  z
+} from "./chunk-QAM5VKAF.js";
+import {
+  canciaLoader,
+  createJsonFileAdapter,
+  createJsonFileAdapterV2
+} from "./chunk-YQDZQSES.js";
+import {
+  RevConflictError
+} from "./chunk-7IA5B5CF.js";
+import {
+  detectImageType,
+  isValidSite
+} from "./chunk-5IPHDIC6.js";
+
+// src/integration.ts
+import { loadEnv } from "vite";
+import { fileURLToPath } from "url";
+
+// src/routes/content.ts
+function makeContentRoute(storage, secret) {
+  function checkAuth(req) {
+    if (!secret) return null;
+    const token = req.headers.get("Authorization")?.replace("Bearer ", "").trim();
+    if (token !== secret) return new Response(JSON.stringify({ error: "Unauthorized" }), { status: 401 });
+    return null;
+  }
+  return {
+    GET: async ({ request }) => {
+      const deny = checkAuth(request);
+      if (deny) return deny;
+      const site = new URL(request.url).searchParams.get("site");
+      if (!site) return new Response(JSON.stringify({ error: "Missing ?site=" }), { status: 400 });
+      const data = await storage.getAll(site);
+      return new Response(JSON.stringify(data), {
+        headers: { "Content-Type": "application/json" }
+      });
+    },
+    POST: async ({ request }) => {
+      const deny = checkAuth(request);
+      if (deny) return deny;
+      const body = await request.json().catch(() => null);
+      if (!body?.site || !body?.key || !body?.lang || body?.value === void 0) {
+        return new Response(JSON.stringify({ error: "Missing fields: site, key, lang, value" }), { status: 400 });
+      }
+      await storage.set(body.site, body.key, body.lang, body.value);
+      return new Response(JSON.stringify({ ok: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    },
+    DELETE: async ({ request }) => {
+      const deny = checkAuth(request);
+      if (deny) return deny;
+      const body = await request.json().catch(() => null);
+      if (!body?.site || !body?.key || !body?.lang) {
+        return new Response(JSON.stringify({ error: "Missing fields: site, key, lang" }), { status: 400 });
+      }
+      await storage.delete(body.site, body.key, body.lang);
+      return new Response(JSON.stringify({ ok: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  };
+}
+
+// src/routes/upload.ts
+import { writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { randomUUID } from "crypto";
+function makeLocalUploadHandler(opts) {
+  const uploadDir = opts.uploadDir ?? join(process.cwd(), "public/uploads");
+  const publicUrlBase = opts.publicUrlBase ?? "/uploads";
+  const maxBytes = (opts.maxMB ?? 10) * 1024 * 1024;
+  return async (file, site, detected) => {
+    const dest = join(uploadDir, site);
+    await mkdir(dest, { recursive: true });
+    const name = `${randomUUID()}.${detected.ext}`;
+    await writeFile(join(dest, name), Buffer.from(await file.arrayBuffer()));
+    return `${publicUrlBase}/${site}/${name}`;
+  };
+}
+function makeUploadRoute(uploadHandler, secret, maxMB = 10) {
+  return async ({ request }) => {
+    if (secret) {
+      const token = request.headers.get("Authorization")?.replace("Bearer ", "").trim();
+      if (token !== secret) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), { status: 401 });
+      }
+    }
+    const form = await request.formData().catch(() => null);
+    const file = form?.get("file");
+    const site = form?.get("site");
+    if (!(file instanceof File)) {
+      return new Response(JSON.stringify({ error: "Missing file field" }), { status: 400 });
+    }
+    if (typeof site !== "string" || !isValidSite(site)) {
+      return new Response(
+        JSON.stringify({ error: "Invalid site (allowed: a-z, 0-9, and . _ -; must start alphanumeric)" }),
+        { status: 400 }
+      );
+    }
+    if (file.size > maxMB * 1024 * 1024) {
+      return new Response(JSON.stringify({ error: `File too large (max ${maxMB}MB)` }), { status: 413 });
+    }
+    const buf = new Uint8Array(await file.arrayBuffer());
+    const detected = detectImageType(buf);
+    if (!detected) {
+      return new Response(JSON.stringify({ error: "File type not allowed" }), { status: 415 });
+    }
+    const url = await uploadHandler(file, site, detected);
+    return new Response(JSON.stringify({ url }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  };
+}
+
+// src/routes/publish.ts
+function makePublishRoute(deployHook, secret) {
+  return async ({ request }) => {
+    if (secret) {
+      const token = request.headers.get("Authorization")?.replace("Bearer ", "").trim();
+      if (token !== secret) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), { status: 401 });
+      }
+    }
+    const hook = deployHook ?? process.env.CANCIA_DEPLOY_HOOK;
+    if (!hook) {
+      return new Response(
+        JSON.stringify({ error: "No deploy hook configured. Set CANCIA_DEPLOY_HOOK." }),
+        { status: 503 }
+      );
+    }
+    try {
+      const res = await fetch(hook, { method: "POST" });
+      if (!res.ok) {
+        return new Response(
+          JSON.stringify({ error: `Deploy hook responded with ${res.status}` }),
+          { status: 502 }
+        );
+      }
+      return new Response(JSON.stringify({ ok: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch {
+      return new Response(JSON.stringify({ error: "Failed to reach deploy hook" }), { status: 502 });
+    }
+  };
+}
+
+// src/routes/auth.ts
+var buckets = /* @__PURE__ */ new Map();
+var MAX_FAILURES = 5;
+var WINDOW_MS = 6e4;
+function getIp(req) {
+  return req.headers.get("x-forwarded-for")?.split(",")[0].trim() ?? req.headers.get("x-real-ip") ?? "unknown";
+}
+function isRateLimited(ip) {
+  const now = Date.now();
+  const bucket = buckets.get(ip);
+  if (!bucket || now > bucket.resetAt) return false;
+  return bucket.failures >= MAX_FAILURES;
+}
+function recordFailure(ip) {
+  const now = Date.now();
+  const bucket = buckets.get(ip);
+  if (!bucket || now > bucket.resetAt) {
+    buckets.set(ip, { failures: 1, resetAt: now + WINDOW_MS });
+  } else {
+    bucket.failures += 1;
+  }
+}
+function clearFailures(ip) {
+  buckets.delete(ip);
+}
+function makeAuthRoute(secret) {
+  return async function authRoute(req) {
+    const ip = getIp(req);
+    if (isRateLimited(ip)) {
+      return new Response(
+        JSON.stringify({ error: "Too many attempts. Try again in a minute." }),
+        { status: 429, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    let token;
+    try {
+      const body = await req.json();
+      token = body?.token;
+    } catch {
+      return new Response(
+        JSON.stringify({ error: "Invalid request body" }),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    if (!token || token !== secret) {
+      recordFailure(ip);
+      return new Response(
+        JSON.stringify({ error: "Invalid token" }),
+        { status: 401, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    clearFailures(ip);
+    return new Response(
+      JSON.stringify({ ok: true }),
+      { status: 200, headers: { "Content-Type": "application/json" } }
+    );
+  };
+}
+
+// src/routes/upload-r2.ts
+import { createHmac, createHash } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
+function sha256hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function hmacSha256(key, data) {
+  return createHmac("sha256", key).update(data).digest();
+}
+function getSigningKey(secretKey, date, region, service) {
+  const kDate = hmacSha256(Buffer.from(`AWS4${secretKey}`, "utf8"), date);
+  const kRegion = hmacSha256(kDate, region);
+  const kService = hmacSha256(kRegion, service);
+  const kSigning = hmacSha256(kService, "aws4_request");
+  return kSigning;
+}
+async function signedPutRequest(opts) {
+  const { endpoint, bucket, key, body, contentType, accessKeyId, secretAccessKey } = opts;
+  const region = "auto";
+  const service = "s3";
+  const now = /* @__PURE__ */ new Date();
+  const isoDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "").slice(0, 15) + "Z";
+  const shortDate = isoDate.slice(0, 8);
+  const url = `${endpoint}/${bucket}/${key}`;
+  const host = new URL(endpoint).host;
+  const payloadHash = sha256hex(body);
+  const headers = {
+    "content-type": contentType,
+    "host": host,
+    "x-amz-content-sha256": payloadHash,
+    "x-amz-date": isoDate
+  };
+  const signedHeaders = Object.keys(headers).sort().join(";");
+  const canonicalHeaders = Object.keys(headers).sort().map((k) => `${k}:${headers[k]}
+`).join("");
+  const canonicalRequest = [
+    "PUT",
+    `/${bucket}/${key}`,
+    "",
+    canonicalHeaders,
+    signedHeaders,
+    payloadHash
+  ].join("\n");
+  const credentialScope = `${shortDate}/${region}/${service}/aws4_request`;
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    isoDate,
+    credentialScope,
+    sha256hex(canonicalRequest)
+  ].join("\n");
+  const signingKey = getSigningKey(secretAccessKey, shortDate, region, service);
+  const signature = createHmac("sha256", signingKey).update(stringToSign).digest("hex");
+  const authHeader = `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "PUT",
+      headers: { ...headers, Authorization: authHeader },
+      body: new Uint8Array(body)
+    });
+  } catch (err) {
+    throw new Error(`R2 upload: network error reaching ${url} \u2014 ${err}`);
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => res.statusText);
+    throw new Error(`R2 upload failed (${res.status}): ${text}`);
+  }
+}
+function makeR2UploadHandler(opts) {
+  const {
+    accountId,
+    bucket,
+    accessKeyId,
+    secretAccessKey,
+    publicUrl,
+    prefix = "uploads"
+  } = opts;
+  const endpoint = `https://${accountId}.r2.cloudflarestorage.com`;
+  return async (file, _site, detected) => {
+    const key = `${prefix}/${randomUUID2()}.${detected.ext}`;
+    const body = Buffer.from(await file.arrayBuffer());
+    await signedPutRequest({
+      endpoint,
+      bucket,
+      key,
+      body,
+      contentType: file.type,
+      accessKeyId,
+      secretAccessKey
+    });
+    return `${publicUrl.replace(/\/$/, "")}/${key}`;
+  };
+}
+
+// src/token.ts
+import { randomBytes } from "crypto";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join as join2 } from "path";
+function generateToken() {
+  return randomBytes(32).toString("hex");
+}
+function ensureToken(rootPath) {
+  const envPath = join2(rootPath, ".env");
+  let contents = "";
+  if (existsSync(envPath)) {
+    contents = readFileSync(envPath, "utf-8");
+  }
+  const match = contents.match(/^CANCIA_TOKEN=(\S+)$/m);
+  if (match?.[1]) return match[1];
+  const token = generateToken();
+  if (/^CANCIA_TOKEN=\s*$/m.test(contents)) {
+    writeFileSync(envPath, contents.replace(/^CANCIA_TOKEN=\s*$/m, `CANCIA_TOKEN=${token}`), "utf-8");
+  } else {
+    writeFileSync(envPath, contents + `
+CANCIA_TOKEN=${token}
+`, "utf-8");
+  }
+  return token;
+}
+
+// src/integration.ts
+function canciaIntegration(opts = {}) {
+  let storage;
+  let resolvedToken = "";
+  let resolvedSite = "";
+  let resolvedRootPath = "";
+  let resolvedUploadHandler;
+  let resolvedDeployHook;
+  let resolvedLocales = ["en"];
+  return {
+    name: "@cancia/astro",
+    hooks: {
+      "astro:config:setup": ({ injectScript, injectRoute, updateConfig, config }) => {
+        resolvedRootPath = config.root.pathname.replace(/^\/([A-Za-z]:)/, "$1").replace(/\/$/, "");
+        const rootPath = resolvedRootPath;
+        const env = loadEnv(process.env.NODE_ENV ?? "development", rootPath, "");
+        const site = opts.site ?? env.CANCIA_SITE ?? process.env.CANCIA_SITE ?? "default";
+        const accentColor = opts.accentColor ?? "#6366f1";
+        const languages = opts.languages ?? (() => {
+          const i18n = config.i18n;
+          if (!i18n) return ["en"];
+          const all = i18n.locales.flatMap(
+            (l) => typeof l === "string" ? [l] : l.codes
+          );
+          const def = i18n.defaultLocale;
+          return [def, ...all.filter((l) => l !== def)];
+        })();
+        resolvedLocales = languages;
+        const envToken = env.CANCIA_TOKEN?.trim() || process.env.CANCIA_TOKEN?.trim() || "";
+        resolvedToken = opts.token ?? (envToken || ensureToken(rootPath));
+        resolvedSite = config.site?.replace(/\/$/, "") ?? "";
+        const token = resolvedToken;
+        const isNewToken = !opts.token && !envToken;
+        if (isNewToken) {
+          console.log(`
+  \x1B[32mcancia\x1B[0m  No CANCIA_TOKEN found \u2014 generated one for you.`);
+        }
+        const hasDeployHook = !!(opts.deployHook ?? env.CANCIA_DEPLOY_HOOK ?? process.env.CANCIA_DEPLOY_HOOK);
+        injectScript(
+          "head-inline",
+          `window.__CANCIA__=${JSON.stringify({
+            apiUrl: "",
+            // empty = same origin
+            site,
+            accentColor,
+            languages,
+            page: "unknown",
+            public: opts.public ?? false,
+            hasDeployHook
+          })};`
+        );
+        injectScript("page", `import "@cancia/toolbar";`);
+        const endpointsDir = new URL("./endpoints/", import.meta.url);
+        const endpointPath = (name) => fileURLToPath(new URL(`${name}.js`, endpointsDir));
+        injectRoute({ pattern: "/api/cancia/content", entrypoint: endpointPath("content"), prerender: false });
+        injectRoute({ pattern: "/api/cancia/save", entrypoint: endpointPath("content"), prerender: false });
+        injectRoute({ pattern: "/api/cancia/upload", entrypoint: endpointPath("upload"), prerender: false });
+        injectRoute({ pattern: "/api/cancia/publish", entrypoint: endpointPath("publish"), prerender: false });
+        injectRoute({ pattern: "/api/cancia/auth", entrypoint: endpointPath("auth"), prerender: false });
+        injectRoute({ pattern: "/api/cancia/health", entrypoint: endpointPath("health"), prerender: false });
+        injectRoute({ pattern: "/api/cancia/schemas", entrypoint: endpointPath("schemas"), prerender: false });
+        injectRoute({ pattern: "/api/cancia/lists/[listName]", entrypoint: endpointPath("lists"), prerender: false });
+        injectRoute({ pattern: "/api/cancia/lists/[listName]/[id]", entrypoint: endpointPath("lists"), prerender: false });
+        updateConfig({
+          vite: {
+            plugins: [
+              {
+                name: "vite-plugin-cancia-runtime",
+                resolveId(id) {
+                  if (id === "virtual:cancia/runtime") {
+                    return fileURLToPath(new URL("./runtime.js", import.meta.url));
+                  }
+                }
+              }
+            ]
+          }
+        });
+      },
+      "astro:server:setup": ({ server }) => {
+        storage = opts.storage ?? createJsonFileAdapter(opts.dbPath);
+        const secret = resolvedToken;
+        const deployHook = opts.deployHook ?? process.env.CANCIA_DEPLOY_HOOK;
+        let uploadHandler;
+        if (opts.r2) {
+          const serverEnv = loadEnv(process.env.NODE_ENV ?? "development", resolvedRootPath, "");
+          const r2Opts = typeof opts.r2 === "function" ? opts.r2() : opts.r2;
+          const resolved = {
+            accountId: r2Opts.accountId ?? serverEnv.R2_ACCOUNT_ID,
+            bucket: r2Opts.bucket ?? serverEnv.R2_BUCKET_NAME ?? serverEnv.R2_BUCKET,
+            accessKeyId: r2Opts.accessKeyId ?? serverEnv.R2_ACCESS_KEY_ID,
+            secretAccessKey: r2Opts.secretAccessKey ?? serverEnv.R2_SECRET_ACCESS_KEY,
+            publicUrl: r2Opts.publicUrl ?? serverEnv.R2_PUBLIC_URL,
+            prefix: r2Opts.prefix
+          };
+          uploadHandler = makeR2UploadHandler(resolved);
+        } else {
+          uploadHandler = opts.uploadHandler ?? makeLocalUploadHandler({ maxMB: opts.maxUploadMB });
+        }
+        const routeSecret = opts.public ? void 0 : secret || void 0;
+        resolvedUploadHandler = uploadHandler;
+        resolvedDeployHook = deployHook;
+        const storageV2 = opts.storageV2 === null ? void 0 : opts.storageV2 ?? createJsonFileAdapterV2({ projectRoot: resolvedRootPath });
+        setCanciaRuntime({
+          storage,
+          storageV2,
+          projectRoot: resolvedRootPath,
+          schemasPath: opts.schemasPath,
+          defaultLocale: resolvedLocales[0],
+          locales: resolvedLocales,
+          secret: routeSecret,
+          uploadHandler,
+          deployHook,
+          maxUploadMB: opts.maxUploadMB ?? 10
+        });
+        const contentRoutes = makeContentRoute(storage, routeSecret);
+        const uploadRoute = makeUploadRoute(uploadHandler, routeSecret, opts.maxUploadMB);
+        const publishRoute = makePublishRoute(deployHook, routeSecret);
+        const authRoute = makeAuthRoute(secret);
+        const listsRoutes = makeListsRoutes({
+          storageV2,
+          projectRoot: resolvedRootPath,
+          schemasPath: opts.schemasPath,
+          secret: routeSecret,
+          defaultLocale: resolvedLocales[0]
+        });
+        const schemasRoute = makeSchemasRoute({
+          projectRoot: resolvedRootPath,
+          schemasPath: opts.schemasPath,
+          secret: routeSecret
+        });
+        server.middlewares.use(async (req, res, next) => {
+          const url = req.url ?? "";
+          if (!url.startsWith("/api/cancia/")) return next();
+          const method = req.method ?? "GET";
+          let body;
+          if (method !== "GET" && method !== "HEAD") {
+            const IDLE_TIMEOUT_MS = 1e4;
+            const read = await new Promise((resolve) => {
+              const chunks = [];
+              let timer;
+              const arm = () => {
+                clearTimeout(timer);
+                timer = setTimeout(() => resolve({ failed: true }), IDLE_TIMEOUT_MS);
+              };
+              arm();
+              req.on("data", (c) => {
+                chunks.push(c);
+                arm();
+              });
+              req.on("end", () => {
+                clearTimeout(timer);
+                resolve({ buf: Buffer.concat(chunks) });
+              });
+              req.on("error", () => {
+                clearTimeout(timer);
+                resolve({ failed: true });
+              });
+            });
+            if ("failed" in read) {
+              res.statusCode = 408;
+              res.end(JSON.stringify({ error: "Request body timed out or errored" }));
+              return;
+            }
+            body = read.buf.length ? read.buf : void 0;
+          }
+          const headers = {};
+          for (let i = 0; i < (req.rawHeaders?.length ?? 0); i += 2) {
+            headers[req.rawHeaders[i].toLowerCase()] = req.rawHeaders[i + 1];
+          }
+          const fullUrl = `http://localhost${url}`;
+          const webReq = new Request(fullUrl, {
+            method,
+            headers,
+            body: body?.length ? body : void 0
+          });
+          const ctx = { request: webReq };
+          let response;
+          if (url.startsWith("/api/cancia/lists/")) {
+            response = await listsRoutes.handle(webReq, method);
+          } else if (url.startsWith("/api/cancia/schemas")) {
+            response = await schemasRoute(webReq);
+          } else if (url.startsWith("/api/cancia/content") && method === "GET") {
+            response = await contentRoutes.GET(ctx);
+          } else if (url.startsWith("/api/cancia/save") && method === "POST") {
+            response = await contentRoutes.POST(ctx);
+          } else if (url.startsWith("/api/cancia/content") && method === "DELETE") {
+            response = await contentRoutes.DELETE(ctx);
+          } else if (url.startsWith("/api/cancia/upload") && method === "POST") {
+            response = await uploadRoute(ctx);
+          } else if (url.startsWith("/api/cancia/publish") && method === "POST") {
+            response = await publishRoute(ctx);
+          } else if (url === "/api/cancia/health") {
+            response = new Response(JSON.stringify({ ok: true }), { status: 200 });
+          } else if (url === "/api/cancia/auth" && method === "POST") {
+            response = await authRoute(webReq);
+          }
+          if (!response) return next();
+          res.statusCode = response.status;
+          response.headers.forEach((v, k) => res.setHeader(k, v));
+          const text = await response.text();
+          res.end(text);
+        });
+      },
+      "astro:server:start": ({ address }) => {
+        const raw = address.address;
+        const host = raw === "::" || raw === "::1" || raw === "0.0.0.0" || raw === "127.0.0.1" ? "localhost" : raw;
+        const localUrl = `http://${host}:${address.port}`;
+        console.log(`
+  \x1B[32mcancia\x1B[0m  Client editor link:
+`);
+        console.log(`    \x1B[2mlocal   \x1B[0m \x1B[36m${localUrl}?cancia=${resolvedToken}\x1B[0m`);
+        if (resolvedSite) {
+          console.log(`    \x1B[2msite    \x1B[0m \x1B[36m${resolvedSite}?cancia=${resolvedToken}\x1B[0m`);
+        } else {
+          console.log(`
+  \x1B[2mTip: set \`site: "https://yoursite.com"\` in astro.config.mjs to get the production URL.\x1B[0m`);
+        }
+        console.log();
+      },
+      "astro:config:done": ({ buildOutput, logger }) => {
+        if (buildOutput === "static") {
+          logger.warn(
+            "Output is static \u2014 Cancia API routes won't be available at runtime. Set output: 'server' (or 'hybrid') in astro.config.mjs, or point the toolbar at an external Cancia API server via the apiUrl option."
+          );
+        }
+      },
+      // For production SSR builds: init storage + runtime singleton before requests are served
+      "astro:build:start": () => {
+        storage = opts.storage ?? createJsonFileAdapter(opts.dbPath);
+        const secret = resolvedToken;
+        const routeSecret = opts.public ? void 0 : secret || void 0;
+        let uploadHandler;
+        if (opts.r2) {
+          const buildEnv = loadEnv(process.env.NODE_ENV ?? "production", resolvedRootPath, "");
+          const r2Opts = typeof opts.r2 === "function" ? opts.r2() : opts.r2;
+          const resolved = {
+            accountId: r2Opts.accountId ?? buildEnv.R2_ACCOUNT_ID,
+            bucket: r2Opts.bucket ?? buildEnv.R2_BUCKET_NAME ?? buildEnv.R2_BUCKET,
+            accessKeyId: r2Opts.accessKeyId ?? buildEnv.R2_ACCESS_KEY_ID,
+            secretAccessKey: r2Opts.secretAccessKey ?? buildEnv.R2_SECRET_ACCESS_KEY,
+            publicUrl: r2Opts.publicUrl ?? buildEnv.R2_PUBLIC_URL,
+            prefix: r2Opts.prefix
+          };
+          uploadHandler = makeR2UploadHandler(resolved);
+        } else {
+          uploadHandler = opts.uploadHandler ?? makeLocalUploadHandler({ maxMB: opts.maxUploadMB });
+        }
+        const deployHook = opts.deployHook ?? process.env.CANCIA_DEPLOY_HOOK;
+        const storageV2 = opts.storageV2 === null ? void 0 : opts.storageV2 ?? createJsonFileAdapterV2({ projectRoot: resolvedRootPath });
+        setCanciaRuntime({
+          storage,
+          storageV2,
+          projectRoot: resolvedRootPath,
+          schemasPath: opts.schemasPath,
+          defaultLocale: resolvedLocales[0],
+          locales: resolvedLocales,
+          secret: routeSecret,
+          uploadHandler,
+          deployHook,
+          maxUploadMB: opts.maxUploadMB ?? 10
+        });
+      }
+    }
+  };
+}
+
+// src/fetch-cms.ts
+async function fetchCMSData(opts) {
+  const { apiUrl, site, token } = opts;
+  const url = `${apiUrl}/api/cancia/content?site=${encodeURIComponent(site)}`;
+  const headers = {};
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  try {
+    const res = await fetch(url, { headers });
+    if (!res.ok) {
+      console.warn(`[cancia] Failed to fetch CMS data (${res.status}). Using defaults.`);
+      return {};
+    }
+    return res.json();
+  } catch (err) {
+    console.warn("[cancia] CMS API unreachable. Using defaults.", err);
+    return {};
+  }
+}
+
+// src/use-translations.ts
+function makeUseTranslations(ui, defaultLang) {
+  return function useTranslations(lang, cmsData) {
+    return function t(key) {
+      const cmsKey = `${String(key)}.${String(lang)}`;
+      if (cmsData?.[cmsKey] !== void 0) return cmsData[cmsKey];
+      return ui[lang]?.[key] ?? ui[defaultLang]?.[key] ?? String(key);
+    };
+  };
+}
+
+// src/storage/sqlite.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var _db = null;
+function createDB(dbPath) {
+  const Database = require2("better-sqlite3");
+  const sqlite = new Database(dbPath);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS cancia_content (
+      id         INTEGER PRIMARY KEY AUTOINCREMENT,
+      site       TEXT NOT NULL,
+      key        TEXT NOT NULL,
+      lang       TEXT NOT NULL,
+      value      TEXT NOT NULL,
+      updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      UNIQUE(site, key, lang)
+    )
+  `);
+  return {
+    get: sqlite.prepare(
+      "SELECT value FROM cancia_content WHERE site=? AND key=? AND lang=?"
+    ),
+    set: sqlite.prepare(
+      `INSERT INTO cancia_content (site, key, lang, value, updated_at)
+       VALUES (?, ?, ?, ?, unixepoch())
+       ON CONFLICT(site, key, lang) DO UPDATE SET value=excluded.value, updated_at=unixepoch()`
+    ),
+    getAll: sqlite.prepare(
+      "SELECT key, lang, value FROM cancia_content WHERE site=?"
+    ),
+    delete: sqlite.prepare(
+      "DELETE FROM cancia_content WHERE site=? AND key=? AND lang=?"
+    )
+  };
+}
+function getDB(dbPath) {
+  if (!_db) _db = createDB(dbPath);
+  return _db;
+}
+function createSQLiteAdapter(dbPath) {
+  const path = dbPath ?? process.cwd() + "/cancia.db";
+  return {
+    async get(site, key, lang) {
+      const row = getDB(path).get.get(site, key, lang);
+      return row?.value ?? null;
+    },
+    async set(site, key, lang, value) {
+      getDB(path).set.run(site, key, lang, value);
+    },
+    async getAll(site) {
+      const rows = getDB(path).getAll.all(site);
+      return Object.fromEntries(rows.map((r) => [`${r.key}.${r.lang}`, r.value]));
+    },
+    async delete(site, key, lang) {
+      getDB(path).delete.run(site, key, lang);
+    }
+  };
+}
+export {
+  RevConflictError,
+  canciaIntegration,
+  canciaLoader,
+  createJsonFileAdapter,
+  createJsonFileAdapterV2,
+  createSQLiteAdapter,
+  canciaIntegration as default,
+  defineList,
+  describeList,
+  fetchCMSData,
+  makeLocalUploadHandler,
+  makeR2UploadHandler,
+  makeUseTranslations,
+  z
+};