@cancia/astro 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,3 +1,6 @@
+import {
+  firePublish
+} from "./chunk-PIDFNJME.js";
 import {
   makeListsRoutes
 } from "./chunk-22DJVJBR.js";
@@ -6,8 +9,11 @@ import {
 } from "./chunk-IIGDU5SV.js";
 import "./chunk-NG5GJME5.js";
 import {
+  makeLocalUploadHandler,
+  makeR2UploadHandler,
+  makeUploadRoute,
   setCanciaRuntime
-} from "./chunk-DGCGIEFD.js";
+} from "./chunk-AIPRCBJM.js";
 import {
   defineField,
   defineList,
@@ -16,27 +22,29 @@ import {
 } from "./chunk-MCHQV6Y7.js";
 import {
   canciaLoader
-} from "./chunk-337LJIKX.js";
+} from "./chunk-UR5WC3RA.js";
 import {
-  createGitBackedAdapter,
   createSQLiteAdapter
-} from "./chunk-SXKZ2WUL.js";
+} from "./chunk-AE4SIY24.js";
+import {
+  closeSqliteAdapterV2,
+  createGitBackedAdapter,
+  createSqliteAdapterV2
+} from "./chunk-52URFK5Y.js";
 import {
   createJsonFileAdapter,
   createJsonFileAdapterV2
-} from "./chunk-ST44VULL.js";
+} from "./chunk-L2VKQJPY.js";
 import {
   RevConflictError
 } from "./chunk-7IA5B5CF.js";
 import "./chunk-BOIQNZAO.js";
-import {
-  detectImageType,
-  isValidSite
-} from "./chunk-5IPHDIC6.js";
+import "./chunk-5IPHDIC6.js";
 
 // src/integration.ts
 import { loadEnv } from "vite";
-import { fileURLToPath } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
+import { isAbsolute, join as join2 } from "path";
 
 // src/routes/content.ts
 function makeContentRoute(storage, secret) {
@@ -84,59 +92,8 @@ function makeContentRoute(storage, secret) {
   };
 }
 
-// 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) {
+function makePublishRoute(deployHook, secret, hookOptions) {
   return async ({ request }) => {
     if (secret) {
       const token = request.headers.get("Authorization")?.replace("Bearer ", "").trim();
@@ -145,26 +102,25 @@ function makePublishRoute(deployHook, secret) {
       }
     }
     const hook = deployHook ?? process.env.CANCIA_DEPLOY_HOOK;
-    if (!hook) {
+    const result = await firePublish(hook, hookOptions);
+    if (result.ok) {
+      return new Response(JSON.stringify({ ok: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (result.kind === "no-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 });
+    if (result.kind === "bad-response") {
+      return new Response(
+        JSON.stringify({ error: `Deploy hook responded with ${result.status}` }),
+        { status: 502 }
+      );
     }
+    return new Response(JSON.stringify({ error: "Failed to reach deploy hook" }), { status: 502 });
   };
 }
 
@@ -227,109 +183,15 @@ function makeAuthRoute(secret) {
   };
 }
 
-// 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";
+import { join } from "path";
 function generateToken() {
   return randomBytes(32).toString("hex");
 }
 function ensureToken(rootPath) {
-  const envPath = join2(rootPath, ".env");
+  const envPath = join(rootPath, ".env");
   let contents = "";
   if (existsSync(envPath)) {
     contents = readFileSync(envPath, "utf-8");
@@ -348,6 +210,13 @@ CANCIA_TOKEN=${token}
 }
 
 // src/integration.ts
+function buildDefaultV2Store(opts, projectRoot) {
+  if (opts.db?.kind === "sqlite") {
+    const path = opts.db.path ? isAbsolute(opts.db.path) ? opts.db.path : join2(projectRoot, opts.db.path) : join2(projectRoot, "cancia.db");
+    return createSqliteAdapterV2({ dbPath: path });
+  }
+  return createJsonFileAdapterV2({ projectRoot });
+}
 function canciaIntegration(opts = {}) {
   let storage;
   let resolvedToken = "";
@@ -356,6 +225,7 @@ function canciaIntegration(opts = {}) {
   let resolvedUploadHandler;
   let resolvedDeployHook;
   let resolvedLocales = ["en"];
+  let bakedConfig = null;
   return {
     name: "@cancia/astro",
     hooks: {
@@ -385,6 +255,46 @@ function canciaIntegration(opts = {}) {
   \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);
+        let storageDescriptor;
+        if (opts.git) {
+          storageDescriptor = {
+            kind: "git-backed",
+            repo: opts.git.repo,
+            branch: opts.git.branch,
+            committer: opts.git.committer,
+            debounceMs: opts.git.debounceMs,
+            commitMessage: opts.git.commitMessage
+          };
+        } else if (opts.storageV2 === null) {
+          storageDescriptor = void 0;
+        } else if (opts.db?.kind === "sqlite") {
+          storageDescriptor = { kind: "sqlite-v2", dbPath: opts.db.path };
+        } else {
+          storageDescriptor = { kind: "json-file", dbPath: opts.dbPath };
+        }
+        let r2Baked;
+        if (opts.r2) {
+          const r2Opts = typeof opts.r2 === "function" ? opts.r2() : opts.r2;
+          r2Baked = {
+            accountId: r2Opts.accountId,
+            bucket: r2Opts.bucket,
+            publicUrl: r2Opts.publicUrl,
+            prefix: r2Opts.prefix
+          };
+        }
+        bakedConfig = {
+          projectRoot: resolvedRootPath,
+          schemasPath: opts.schemasPath,
+          defaultLocale: resolvedLocales[0],
+          locales: resolvedLocales,
+          maxUploadMB: opts.maxUploadMB ?? 10,
+          public: opts.public ?? false,
+          hasDeployHook,
+          deployHookMethod: opts.deployHookMethod,
+          deployHookHeaders: opts.deployHookHeaders,
+          storage: storageDescriptor,
+          r2: r2Baked
+        };
         injectScript(
           "head-inline",
           `window.__CANCIA__=${JSON.stringify({
@@ -410,6 +320,8 @@ function canciaIntegration(opts = {}) {
         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 });
+        const runtimeModulePath = fileURLToPath(new URL("./runtime.js", import.meta.url));
+        const RESOLVED_VIRTUAL_ID = "\0virtual:cancia/runtime";
         updateConfig({
           vite: {
             plugins: [
@@ -417,8 +329,18 @@ function canciaIntegration(opts = {}) {
                 name: "vite-plugin-cancia-runtime",
                 resolveId(id) {
                   if (id === "virtual:cancia/runtime") {
-                    return fileURLToPath(new URL("./runtime.js", import.meta.url));
+                    return RESOLVED_VIRTUAL_ID;
                   }
+                },
+                load(id) {
+                  if (id !== RESOLVED_VIRTUAL_ID) return;
+                  const importUrl = pathToFileURL(runtimeModulePath).href;
+                  const bakedLiteral = JSON.stringify(bakedConfig ?? null);
+                  return [
+                    `import { setBakedConfig, getCanciaRuntime } from ${JSON.stringify(importUrl)};`,
+                    `setBakedConfig(${bakedLiteral});`,
+                    `export { getCanciaRuntime };`
+                  ].join("\n");
                 }
               }
             ]
@@ -429,6 +351,7 @@ function canciaIntegration(opts = {}) {
         storage = opts.storage ?? createJsonFileAdapter(opts.dbPath);
         const secret = resolvedToken;
         const deployHook = opts.deployHook ?? process.env.CANCIA_DEPLOY_HOOK;
+        const deployHookToken = process.env.CANCIA_DEPLOY_HOOK_TOKEN || opts.deployHookToken;
         let uploadHandler;
         if (opts.r2) {
           const serverEnv = loadEnv(process.env.NODE_ENV ?? "development", resolvedRootPath, "");
@@ -448,7 +371,7 @@ function canciaIntegration(opts = {}) {
         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 });
+        const storageV2 = opts.storageV2 === null ? void 0 : opts.storageV2 ?? buildDefaultV2Store(opts, resolvedRootPath);
         setCanciaRuntime({
           storage,
           storageV2,
@@ -459,11 +382,18 @@ function canciaIntegration(opts = {}) {
           secret: routeSecret,
           uploadHandler,
           deployHook,
+          deployHookToken,
+          deployHookMethod: opts.deployHookMethod,
+          deployHookHeaders: opts.deployHookHeaders,
           maxUploadMB: opts.maxUploadMB ?? 10
         });
         const contentRoutes = makeContentRoute(storage, routeSecret);
         const uploadRoute = makeUploadRoute(uploadHandler, routeSecret, opts.maxUploadMB);
-        const publishRoute = makePublishRoute(deployHook, routeSecret);
+        const publishRoute = makePublishRoute(deployHook, routeSecret, {
+          token: deployHookToken,
+          method: opts.deployHookMethod,
+          headers: opts.deployHookHeaders
+        });
         const authRoute = makeAuthRoute(secret);
         const listsRoutes = makeListsRoutes({
           storageV2,
@@ -595,7 +525,8 @@ function canciaIntegration(opts = {}) {
           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 });
+        const deployHookToken = process.env.CANCIA_DEPLOY_HOOK_TOKEN || opts.deployHookToken;
+        const storageV2 = opts.storageV2 === null ? void 0 : opts.storageV2 ?? buildDefaultV2Store(opts, resolvedRootPath);
         setCanciaRuntime({
           storage,
           storageV2,
@@ -606,6 +537,9 @@ function canciaIntegration(opts = {}) {
           secret: routeSecret,
           uploadHandler,
           deployHook,
+          deployHookToken,
+          deployHookMethod: opts.deployHookMethod,
+          deployHookHeaders: opts.deployHookHeaders,
           maxUploadMB: opts.maxUploadMB ?? 10
         });
       }
@@ -646,10 +580,12 @@ export {
   RevConflictError,
   canciaIntegration,
   canciaLoader,
+  closeSqliteAdapterV2,
   createGitBackedAdapter,
   createJsonFileAdapter,
   createJsonFileAdapterV2,
   createSQLiteAdapter,
+  createSqliteAdapterV2,
   canciaIntegration as default,
   defineField,
   defineList,

package/dist/loader/index.js

@@ -1,7 +1,7 @@
 import {
   canciaLoader
-} from "../chunk-337LJIKX.js";
-import "../chunk-ST44VULL.js";
+} from "../chunk-UR5WC3RA.js";
+import "../chunk-L2VKQJPY.js";
 import "../chunk-7IA5B5CF.js";
 export {
   canciaLoader

package/dist/runtime.d.ts

@@ -1,5 +1,6 @@
 import { C as CanciaStorage, a as CanciaStorageV2 } from './types-BMlLS-OS.js';
 import { U as UploadHandler } from './upload-DwCGjXbz.js';
+import { G as GitHubCommitter } from './github-client-BAZ1pW24.js';
 
 interface CanciaRuntime {
     /** v1 KV-only storage. Kept for the existing /content endpoint. */
@@ -26,9 +27,70 @@ interface CanciaRuntime {
     secret: string | undefined;
     uploadHandler: UploadHandler;
     deployHook: string | undefined;
+    /**
+     * Auth token for the deploy hook (e.g. Coolify's "auth required" hook).
+     * SECRET — read from CANCIA_DEPLOY_HOOK_TOKEN at runtime, never baked. When
+     * set the publish POST sends `Authorization: Bearer <token>`.
+     */
+    deployHookToken: string | undefined;
+    /** Optional HTTP method for the hook (default POST). Non-secret, baked. */
+    deployHookMethod: string | undefined;
+    /** Optional extra headers merged into the hook request. Non-secret, baked. */
+    deployHookHeaders: Record<string, string> | undefined;
+    maxUploadMB: number;
+}
+/** Describes which storage adapter to build lazily in the server process. */
+type BakedStorageDescriptor = {
+    kind: "json-file";
+    dbPath?: string;
+} | {
+    kind: "sqlite-v2";
+    dbPath?: string;
+} | {
+    kind: "git-backed";
+    repo: string;
+    branch?: string;
+    committer?: GitHubCommitter;
+    debounceMs?: number;
+    commitMessage?: string;
+};
+/** R2 config baked minus its secrets (accessKeyId/secretAccessKey come from env). */
+interface BakedR2Config {
+    accountId?: string;
+    bucket?: string;
+    publicUrl?: string;
+    prefix?: string;
+}
+interface BakedConfig {
+    projectRoot: string;
+    schemasPath: string | undefined;
+    defaultLocale: string;
+    locales: string[];
     maxUploadMB: number;
+    /** When true, endpoints skip auth (public demos). Baked, never a secret. */
+    public: boolean;
+    /** Whether a deploy hook exists — the value itself is read from env. */
+    hasDeployHook: boolean;
+    /** Optional deploy-hook HTTP method (default POST). Non-secret. */
+    deployHookMethod: string | undefined;
+    /** Optional deploy-hook extra headers. Non-secret (the token stays in env). */
+    deployHookHeaders: Record<string, string> | undefined;
+    /** How to build the v2 storage adapter at runtime. Absent = no v2 storage. */
+    storage: BakedStorageDescriptor | undefined;
+    /** When set, build an R2 upload handler; secrets come from env at runtime. */
+    r2: BakedR2Config | undefined;
 }
+/**
+ * Called by the generated virtual:cancia/runtime module at import time with the
+ * build-baked, non-secret config. Enables lazy self-init in a fresh process.
+ */
+declare function setBakedConfig(config: BakedConfig): void;
+/**
+ * Eagerly set the runtime. Used in dev (astro:server:setup) and in-process
+ * builds where the resolved runtime already exists. Production falls through
+ * to lazy init instead.
+ */
 declare function setCanciaRuntime(runtime: CanciaRuntime): void;
 declare function getCanciaRuntime(): CanciaRuntime;
 
-export { type CanciaRuntime, getCanciaRuntime, setCanciaRuntime };
+export { type BakedConfig, type BakedR2Config, type BakedStorageDescriptor, type CanciaRuntime, getCanciaRuntime, setBakedConfig, setCanciaRuntime };

package/dist/runtime.js

@@ -1,8 +1,14 @@
 import {
   getCanciaRuntime,
+  setBakedConfig,
   setCanciaRuntime
-} from "./chunk-DGCGIEFD.js";
+} from "./chunk-AIPRCBJM.js";
+import "./chunk-52URFK5Y.js";
+import "./chunk-L2VKQJPY.js";
+import "./chunk-7IA5B5CF.js";
+import "./chunk-5IPHDIC6.js";
 export {
   getCanciaRuntime,
+  setBakedConfig,
   setCanciaRuntime
 };

package/dist/storage/index.d.ts

@@ -1,129 +1,13 @@
-import { C as CanciaStorage, a as CanciaStorageV2 } from '../types-BMlLS-OS.js';
-export { b as CanciaKVStore, c as CanciaListStore, d as CanciaPageStore, L as ListEntry, P as PageMeta, e as PageRecord, f as PageSEO, R as Rev, g as RevConflictError } from '../types-BMlLS-OS.js';
-
-declare function createJsonFileAdapter(filePath?: string): CanciaStorage;
-
-interface JsonFileV2Options {
-    /** Project root. Defaults to process.cwd(). */
-    projectRoot?: string;
-    /** Override the KV file path. Defaults to <root>/cancia-content.json. */
-    kvPath?: string;
-    /** Override the pages file path. Defaults to <root>/.cancia/pages.json. */
-    pagesPath?: string;
-    /** Override the lists directory. Defaults to <root>/.cancia/lists. */
-    listsDir?: string;
-}
-declare function createJsonFileAdapterV2(opts?: JsonFileV2Options): CanciaStorageV2;
-
-declare function createSQLiteAdapter(dbPath?: string): CanciaStorage;
-
-/** Minimal fetch signature — matches the global `fetch` we depend on. */
-type FetchLike = (input: string, init?: {
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string;
-}) => Promise<{
-    ok: boolean;
-    status: number;
-    json(): Promise<unknown>;
-    text(): Promise<string>;
-}>;
-interface GitHubCommitter {
-    name: string;
-    email: string;
-}
-interface GitHubClientOptions {
-    /** "owner/name" */
-    repo: string;
-    /** Branch to commit onto, e.g. "main". */
-    branch: string;
-    /** Fine-grained PAT with contents:write on the one repo. */
-    token: string;
-    /** Optional committer identity. GitHub uses the token's user if omitted. */
-    committer?: GitHubCommitter;
-    /** Injectable fetch (defaults to global fetch) — tests mock this. */
-    fetch?: FetchLike;
-    /** API base — defaults to https://api.github.com. Overridable for tests. */
-    apiBase?: string;
-}
-interface CommitFile {
-    /** Repo-relative path, forward slashes, no leading slash. */
-    path: string;
-    /** Raw file content (UTF-8 text). Encoded to base64 before PUT. */
-    content: string;
-}
-interface GitHubClient {
-    /** Current blob sha for `path`, or null if the file doesn't exist yet. */
-    getFileSha(path: string): Promise<string | null>;
-    /**
-     * Commit each file to the branch. Updates pass the current sha; creates omit
-     * it. Resolves once every PUT succeeds; rejects (without partial silence) if
-     * any PUT fails so the caller can keep the batch dirty and retry.
-     */
-    commitFiles(files: CommitFile[], message: string): Promise<void>;
-}
-declare function createGitHubClient(opts: GitHubClientOptions): GitHubClient;
-
-interface GitBackedContentPaths {
-    /** KV file path. Default <projectRoot>/cancia-content.json. */
-    kvPath?: string;
-    /** Pages file path. Default <projectRoot>/.cancia/pages.json. */
-    pagesPath?: string;
-    /** Lists directory. Default <projectRoot>/.cancia/lists. */
-    listsDir?: string;
-}
-interface GitBackedOptions {
-    /** The wrapped local adapter — the on-disk source of truth. */
-    local: CanciaStorageV2;
-    /** "owner/name" of the GitHub repo whose builds carry the content. */
-    repo: string;
-    /** Branch to commit onto. Default "main". */
-    branch?: string;
-    /**
-     * GitHub PAT. Reads CANCIA_GITHUB_TOKEN if omitted. When absent entirely the
-     * adapter runs in local-only mode (disk writes only; no commits) + warns once.
-     */
-    token?: string;
-    /** Optional committer identity for commits. */
-    committer?: GitHubCommitter;
-    /**
-     * Project root the local adapter writes under — needed to turn absolute
-     * on-disk paths into repo-relative commit paths. Default process.cwd().
-     */
-    projectRoot?: string;
-    /** Override where the local adapter's content lives (must match `local`). */
-    contentPaths?: GitBackedContentPaths;
-    /** Quiet window (ms) before a flush fires. Default 3000. */
-    debounceMs?: number;
-    /** Commit message for content updates. */
-    commitMessage?: string;
-    /** Injected GitHub client (tests pass a mock). Overrides token/fetch. */
-    client?: GitHubClient;
-    /** Injected fetch, forwarded to the default GitHub client. */
-    fetch?: FetchLike;
-    /** API base override, forwarded to the default GitHub client (tests). */
-    apiBase?: string;
-    /** Warn sink (tests capture). Default console.warn. */
-    warn?: (msg: string) => void;
-    /** Error sink for push failures (tests capture). Default console.error. */
-    onError?: (msg: string, err: unknown) => void;
-}
-/** The extra control surface the git adapter adds on top of CanciaStorageV2. */
-interface GitBackedControls {
-    /**
-     * Force any pending dirty files to commit now, bypassing the debounce.
-     * Resolves once the flush completes (or rejects if the push failed — the
-     * files stay dirty for the next flush). For tests + graceful shutdown.
-     */
-    flush(): Promise<void>;
-    /** True if git commits are active (token present). */
-    readonly gitEnabled: boolean;
-    /** Snapshot of currently-dirty repo-relative paths (for tests/inspection). */
-    pendingPaths(): string[];
-}
-type GitBackedStorage = CanciaStorageV2 & {
-    git: GitBackedControls;
-};
-declare function createGitBackedAdapter(opts: GitBackedOptions): GitBackedStorage;
-
-export { CanciaStorage, CanciaStorageV2, type CommitFile, type GitBackedContentPaths, type GitBackedControls, type GitBackedOptions, type GitBackedStorage, type GitHubClient, type GitHubClientOptions, type GitHubCommitter, createGitBackedAdapter, createGitHubClient, createJsonFileAdapter, createJsonFileAdapterV2, createSQLiteAdapter };
+import { R as Rev } from '../types-BMlLS-OS.js';
+export { b as CanciaKVStore, c as CanciaListStore, d as CanciaPageStore, C as CanciaStorage, a as CanciaStorageV2, L as ListEntry, P as PageMeta, e as PageRecord, f as PageSEO, g as RevConflictError } from '../types-BMlLS-OS.js';
+export { G as GitBackedContentPaths, a as GitBackedControls, b as GitBackedOptions, c as GitBackedStorage, S as SqliteV2Options, d as closeSqliteAdapterV2, e as createGitBackedAdapter, f as createJsonFileAdapter, g as createJsonFileAdapterV2, h as createSQLiteAdapter, i as createSqliteAdapterV2 } from '../git-backed-DFAB0tzf.js';
+export { C as CommitFile, a as GitHubClient, b as GitHubClientOptions, G as GitHubCommitter, c as createGitHubClient } from '../github-client-BAZ1pW24.js';
+
+/**
+ * Canonical JSON: keys sorted alphabetically at every level. Two values that
+ * are logically equal hash to the same _rev regardless of insertion order.
+ */
+declare function canonicalize(value: unknown): string;
+declare function hashRev(value: unknown): Rev;
+
+export { Rev, canonicalize, hashRev };