@cancia/astro 0.2.1 → 0.4.0

package/dist/chunk-U7V53JX7.js

@@ -0,0 +1,83 @@
+// src/storage/github-client.ts
+function toBase64(text) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(text, "utf-8").toString("base64");
+  }
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary);
+}
+function createGitHubClient(opts) {
+  const { repo, branch, token, committer } = opts;
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  const apiBase = (opts.apiBase ?? "https://api.github.com").replace(/\/$/, "");
+  if (!doFetch) {
+    throw new Error("createGitHubClient: no fetch available (pass opts.fetch)");
+  }
+  const headers = () => ({
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  });
+  const contentsUrl = (path) => {
+    const encoded = path.split("/").map((seg) => encodeURIComponent(seg)).join("/");
+    return `${apiBase}/repos/${repo}/contents/${encoded}`;
+  };
+  async function getFileSha(path) {
+    const url = `${contentsUrl(path)}?ref=${encodeURIComponent(branch)}`;
+    const res = await doFetch(url, { method: "GET", headers: headers() });
+    if (res.status === 404) return null;
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`GitHub getFileSha ${path} failed: ${res.status} ${detail}`);
+    }
+    const body = await res.json();
+    return body.sha ?? null;
+  }
+  async function putFile(file, message) {
+    const sha = await getFileSha(file.path);
+    const payload = {
+      message,
+      content: toBase64(file.content),
+      branch
+    };
+    if (sha) payload.sha = sha;
+    if (committer) payload.committer = committer;
+    const res = await doFetch(contentsUrl(file.path), {
+      method: "PUT",
+      headers: headers(),
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`GitHub commit ${file.path} failed: ${res.status} ${detail}`);
+    }
+  }
+  async function commitFiles(files, message) {
+    for (const file of files) {
+      await putFile(file, message);
+    }
+  }
+  async function dispatch(eventType, clientPayload) {
+    const url = `${apiBase}/repos/${repo}/dispatches`;
+    const payload = { event_type: eventType };
+    if (clientPayload !== void 0) payload.client_payload = clientPayload;
+    const res = await doFetch(url, {
+      method: "POST",
+      headers: headers(),
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(
+        `GitHub repository_dispatch ${eventType} failed: ${res.status} ${detail}`
+      );
+    }
+  }
+  return { getFileSha, commitFiles, dispatch };
+}
+
+export {
+  createGitHubClient
+};

package/dist/{chunk-337LJIKX.js → chunk-UR5WC3RA.js}

@@ -1,6 +1,6 @@
 import {
   createJsonFileAdapterV2
-} from "./chunk-ST44VULL.js";
+} from "./chunk-L2VKQJPY.js";
 
 // src/loader/index.ts
 import { join } from "path";

package/dist/endpoints/publish.js

@@ -1,33 +1,63 @@
+import {
+  fireDispatch,
+  firePublish
+} from "../chunk-BMCI2F2Y.js";
+import "../chunk-U7V53JX7.js";
+
 // src/endpoints/publish.ts
 import { getCanciaRuntime } from "virtual:cancia/runtime";
 async function POST({ request }) {
-  const { deployHook, secret } = getCanciaRuntime();
+  const {
+    deployHook,
+    deployHookToken,
+    deployHookMethod,
+    deployHookHeaders,
+    publishRepo,
+    publishGithubToken,
+    secret
+  } = getCanciaRuntime();
   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)
+  const ghToken = publishGithubToken ?? process.env.CANCIA_GITHUB_TOKEN?.trim();
+  if (publishRepo && ghToken) {
+    const dispatched = await fireDispatch({ repo: publishRepo, token: ghToken });
+    if (dispatched.ok)
+      return new Response(JSON.stringify({ ok: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
     return new Response(
-      JSON.stringify({ error: "No deploy hook configured. Set CANCIA_DEPLOY_HOOK." }),
-      { status: 503 }
+      JSON.stringify({ error: "GitHub repository_dispatch failed" }),
+      { status: 502 }
     );
-  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 }
-      );
+  }
+  const hook = deployHook ?? process.env.CANCIA_DEPLOY_HOOK;
+  const result = await firePublish(hook, {
+    token: deployHookToken,
+    method: deployHookMethod,
+    headers: deployHookHeaders
+  });
+  if (result.ok)
     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 === "no-hook")
+    return new Response(
+      JSON.stringify({
+        error: "No publish mechanism configured. Set a publish repo + CANCIA_GITHUB_TOKEN, or CANCIA_DEPLOY_HOOK."
+      }),
+      { status: 503 }
+    );
+  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
+  });
 }
 export {
   POST

package/dist/git-backed-DtiH52EI.d.ts

@@ -0,0 +1,98 @@
+import { C as CanciaStorage, a as CanciaStorageV2 } from './types-BMlLS-OS.js';
+import { G as GitHubCommitter, a as GitHubClient, F as FetchLike } from './github-client-Db0pIrqE.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;
+
+interface SqliteV2Options {
+    /** Absolute path to the .db file. Defaults to <projectRoot>/cancia.db. */
+    dbPath?: string;
+    /** Project root. Defaults to process.cwd(). Used to derive dbPath. */
+    projectRoot?: string;
+}
+declare function createSqliteAdapterV2(opts?: SqliteV2Options): CanciaStorageV2;
+/**
+ * Close and forget the cached connection for a db path (or all connections
+ * when no path is given). The store interface has no lifecycle hook, so this
+ * is the seam for graceful shutdown and for tests that need to release the
+ * file handle before deleting the .db (Windows keeps WAL files locked while
+ * the connection is open). No-op if the path was never opened.
+ */
+declare function closeSqliteAdapterV2(dbPath?: string): void;
+
+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 { type GitBackedContentPaths as G, type SqliteV2Options as S, type GitBackedControls as a, type GitBackedOptions as b, type GitBackedStorage as c, closeSqliteAdapterV2 as d, createGitBackedAdapter as e, createJsonFileAdapter as f, createJsonFileAdapterV2 as g, createSQLiteAdapter as h, createSqliteAdapterV2 as i };

package/dist/{github-client-BAZ1pW24.d.ts → github-client-Db0pIrqE.d.ts}

@@ -42,6 +42,15 @@ interface GitHubClient {
      * any PUT fails so the caller can keep the batch dirty and retry.
      */
     commitFiles(files: CommitFile[], message: string): Promise<void>;
+    /**
+     * Fire a `repository_dispatch` event on the repo. POSTs
+     * `/repos/{owner}/{repo}/dispatches` with `{ event_type, client_payload }`
+     * and the Bearer token. GitHub returns 204 on success — throws on anything
+     * else. This is the host-independent publish trigger (031): a workflow in the
+     * client repo listens for the event and makes an empty commit, so the host's
+     * normal git integration rebuilds. Same repo-write PAT the Contents API uses.
+     */
+    dispatch(eventType: string, clientPayload?: object): Promise<void>;
 }
 declare function createGitHubClient(opts: GitHubClientOptions): GitHubClient;
 

package/dist/index.d.ts

@@ -3,10 +3,10 @@ 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';
 import { U as UploadHandler } from './upload-DwCGjXbz.js';
 export { m as makeLocalUploadHandler } from './upload-DwCGjXbz.js';
-import { G as GitHubCommitter } from './github-client-BAZ1pW24.js';
+import { G as GitHubCommitter } from './github-client-Db0pIrqE.js';
 export { CanciaLoaderOptions, canciaLoader } from './loader/index.js';
 export { FieldDescription, FieldMeta, FieldMetaBase, FieldWidget, ListDescription, ListSchema, SchemasModule, defineField, defineList, describeList } from './schema/index.js';
-export { GitBackedContentPaths, GitBackedControls, GitBackedOptions, GitBackedStorage, createGitBackedAdapter, createJsonFileAdapter, createJsonFileAdapterV2, createSQLiteAdapter } from './storage/index.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-DtiH52EI.js';
 export { z } from 'zod';
 import 'astro/loaders';
 import './portable-text-BikSqS9T.js';
@@ -48,6 +48,37 @@ interface CanciaIntegrationOptions {
     accentColor?: string;
     /** Deploy hook URL. Reads CANCIA_DEPLOY_HOOK env var if not set. */
     deployHook?: string;
+    /**
+     * Auth token for the deploy hook (e.g. Coolify's "auth required" hook).
+     * When set, the publish POST sends `Authorization: Bearer <token>`.
+     * SECRET — prefer the CANCIA_DEPLOY_HOOK_TOKEN env var (read at runtime,
+     * never baked into the build). This option is a dev/testing convenience.
+     */
+    deployHookToken?: string;
+    /** Optional HTTP method for the deploy hook. Default: "POST". */
+    deployHookMethod?: string;
+    /** Optional extra headers merged into the deploy-hook request. */
+    deployHookHeaders?: Record<string, string>;
+    /**
+     * The host-independent standard publish path (031). When set, the Publish
+     * button fires a GitHub `repository_dispatch` (event `cancia-publish`) on
+     * this repo instead of the raw deploy hook — a workflow in the repo
+     * (templates/cancia-publish.yml) makes an empty commit → the host's normal
+     * git integration rebuilds. Identical for every host; no host API / IP
+     * allowlist. The token is NEVER baked — it is read from
+     * `process.env.CANCIA_GITHUB_TOKEN` at runtime (a fine-grained PAT with
+     * `contents:write`, which covers repository_dispatch). Precedence:
+     * publish-dispatch (if repo + token) → deploy hook (030) → 503.
+     *
+     * If a git-backed `git.repo` is already declared, that repo is reused as the
+     * publish target unless overridden here.
+     */
+    publish?: {
+        github?: {
+            /** "owner/name" of the repo whose `cancia-publish` workflow rebuilds. */
+            repo: string;
+        };
+    };
     /**
      * Custom storage adapter.
      * Default: SQLite (cancia.db in project root) — works anywhere with Node.
@@ -90,6 +121,27 @@ interface CanciaIntegrationOptions {
      * (named or default) — a record of list name → defineList() output.
      */
     schemasPath?: string;
+    /**
+     * Declarative v2 storage backend — bakes SERIALISABLY into the runtime
+     * descriptor so a fresh production SSR server reconstructs the same adapter
+     * from config + `process.cwd()` (no live object crosses the build→deploy
+     * boundary). Prefer this over a live `storageV2` object for production.
+     *
+     * - `{ kind: "sqlite" }` (recommended) — the everything-store: KV + pages +
+     *   lists in ONE `.db` per site (default `<root>/cancia.db`; override with
+     *   `path`, relative paths resolve against the project root). Gitignore the
+     *   `.db` for webhook-publish sites — it is NOT committed (contrast the
+     *   git-backed model).
+     * - `{ kind: "json-file" }` — the JSON-file v2 default (files under
+     *   `<root>/.cancia/`).
+     *
+     * Ignored when `git` is set (git-backed wins) or `storageV2` is passed as a
+     * live object (dev uses that eagerly).
+     */
+    db?: {
+        kind: "sqlite" | "json-file";
+        path?: string;
+    };
     /**
      * Git-backed storage, described SERIALISABLY so a production SSR server can
      * reconstruct the adapter in its own (fresh) process from this config + the

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  fireDispatch,
+  firePublish
+} from "./chunk-BMCI2F2Y.js";
 import {
   makeListsRoutes
 } from "./chunk-22DJVJBR.js";
@@ -10,7 +14,7 @@ import {
   makeR2UploadHandler,
   makeUploadRoute,
   setCanciaRuntime
-} from "./chunk-7MPOERVU.js";
+} from "./chunk-U46HCJN3.js";
 import {
   defineField,
   defineList,
@@ -19,17 +23,20 @@ import {
 } from "./chunk-MCHQV6Y7.js";
 import {
   canciaLoader
-} from "./chunk-337LJIKX.js";
+} from "./chunk-UR5WC3RA.js";
 import {
   createSQLiteAdapter
 } from "./chunk-AE4SIY24.js";
 import {
-  createGitBackedAdapter
-} from "./chunk-5ELSN6LI.js";
+  closeSqliteAdapterV2,
+  createGitBackedAdapter,
+  createSqliteAdapterV2
+} from "./chunk-5AUIPW2I.js";
+import "./chunk-U7V53JX7.js";
 import {
   createJsonFileAdapter,
   createJsonFileAdapterV2
-} from "./chunk-ST44VULL.js";
+} from "./chunk-L2VKQJPY.js";
 import {
   RevConflictError
 } from "./chunk-7IA5B5CF.js";
@@ -39,6 +46,7 @@ import "./chunk-5IPHDIC6.js";
 // src/integration.ts
 import { loadEnv } from "vite";
 import { fileURLToPath, pathToFileURL } from "url";
+import { isAbsolute, join as join2 } from "path";
 
 // src/routes/content.ts
 function makeContentRoute(storage, secret) {
@@ -87,7 +95,7 @@ function makeContentRoute(storage, secret) {
 }
 
 // src/routes/publish.ts
-function makePublishRoute(deployHook, secret) {
+function makePublishRoute(deployHook, secret, hookOptions, dispatch) {
   return async ({ request }) => {
     if (secret) {
       const token = request.headers.get("Authorization")?.replace("Bearer ", "").trim();
@@ -95,27 +103,40 @@ function makePublishRoute(deployHook, secret) {
         return new Response(JSON.stringify({ error: "Unauthorized" }), { status: 401 });
       }
     }
-    const hook = deployHook ?? process.env.CANCIA_DEPLOY_HOOK;
-    if (!hook) {
+    if (dispatch?.repo && dispatch?.token) {
+      const dispatched = await fireDispatch({ repo: dispatch.repo, token: dispatch.token });
+      if (dispatched.ok) {
+        return new Response(JSON.stringify({ ok: true }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
       return new Response(
-        JSON.stringify({ error: "No deploy hook configured. Set CANCIA_DEPLOY_HOOK." }),
-        { status: 503 }
+        JSON.stringify({ error: "GitHub repository_dispatch failed" }),
+        { status: 502 }
       );
     }
-    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 }
-        );
-      }
+    const hook = deployHook ?? process.env.CANCIA_DEPLOY_HOOK;
+    const result = await firePublish(hook, hookOptions);
+    if (result.ok) {
       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 === "no-hook") {
+      return new Response(
+        JSON.stringify({
+          error: "No publish mechanism configured. Set a publish repo + CANCIA_GITHUB_TOKEN, or CANCIA_DEPLOY_HOOK."
+        }),
+        { status: 503 }
+      );
+    }
+    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 });
   };
 }
 
@@ -205,6 +226,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 = "";
@@ -212,6 +240,7 @@ function canciaIntegration(opts = {}) {
   let resolvedRootPath = "";
   let resolvedUploadHandler;
   let resolvedDeployHook;
+  let resolvedPublishRepo;
   let resolvedLocales = ["en"];
   let bakedConfig = null;
   return {
@@ -243,6 +272,7 @@ 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);
+        resolvedPublishRepo = opts.publish?.github?.repo ?? opts.git?.repo;
         let storageDescriptor;
         if (opts.git) {
           storageDescriptor = {
@@ -255,6 +285,8 @@ function canciaIntegration(opts = {}) {
           };
         } 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 };
         }
@@ -276,6 +308,9 @@ function canciaIntegration(opts = {}) {
           maxUploadMB: opts.maxUploadMB ?? 10,
           public: opts.public ?? false,
           hasDeployHook,
+          deployHookMethod: opts.deployHookMethod,
+          deployHookHeaders: opts.deployHookHeaders,
+          publishRepo: resolvedPublishRepo,
           storage: storageDescriptor,
           r2: r2Baked
         };
@@ -335,6 +370,8 @@ 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;
+        const publishGithubToken = process.env.CANCIA_GITHUB_TOKEN?.trim() || void 0;
         let uploadHandler;
         if (opts.r2) {
           const serverEnv = loadEnv(process.env.NODE_ENV ?? "development", resolvedRootPath, "");
@@ -354,7 +391,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,
@@ -365,11 +402,25 @@ function canciaIntegration(opts = {}) {
           secret: routeSecret,
           uploadHandler,
           deployHook,
+          deployHookToken,
+          deployHookMethod: opts.deployHookMethod,
+          deployHookHeaders: opts.deployHookHeaders,
+          publishRepo: resolvedPublishRepo,
+          publishGithubToken,
           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
+          },
+          { repo: resolvedPublishRepo, token: publishGithubToken }
+        );
         const authRoute = makeAuthRoute(secret);
         const listsRoutes = makeListsRoutes({
           storageV2,
@@ -501,7 +552,9 @@ 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 publishGithubToken = process.env.CANCIA_GITHUB_TOKEN?.trim() || void 0;
+        const storageV2 = opts.storageV2 === null ? void 0 : opts.storageV2 ?? buildDefaultV2Store(opts, resolvedRootPath);
         setCanciaRuntime({
           storage,
           storageV2,
@@ -512,6 +565,11 @@ function canciaIntegration(opts = {}) {
           secret: routeSecret,
           uploadHandler,
           deployHook,
+          deployHookToken,
+          deployHookMethod: opts.deployHookMethod,
+          deployHookHeaders: opts.deployHookHeaders,
+          publishRepo: resolvedPublishRepo,
+          publishGithubToken,
           maxUploadMB: opts.maxUploadMB ?? 10
         });
       }
@@ -552,10 +610,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