@cancia/astro 0.7.0 → 0.8.0

package/dist/{chunk-UR5WC3RA.js → chunk-3B3CXOMK.js}

@@ -1,15 +1,21 @@
 import {
   createJsonFileAdapterV2
 } from "./chunk-L2VKQJPY.js";
+import {
+  isDraft
+} from "./chunk-WVHTCFE6.js";
 
 // src/loader/index.ts
 import { join } from "path";
 function makeId(locale, entryId) {
   return `${locale}/${entryId}`;
 }
-async function syncOnce(ctx, lists, list, site) {
+async function syncOnce(ctx, lists, list, site, schema, includeDrafts) {
   ctx.store.clear();
-  const entries = await lists.list(site, list);
+  const all = await lists.list(site, list);
+  const drafts = schema?.draftField && !includeDrafts ? all.filter((e) => isDraft(schema, e.data)) : [];
+  const draftIds = new Set(drafts.map((e) => `${e.locale}/${e.id}`));
+  const entries = draftIds.size ? all.filter((e) => !draftIds.has(`${e.locale}/${e.id}`)) : all;
   for (const entry of entries) {
     const id = makeId(entry.locale, entry.id);
     const data = {
@@ -24,8 +30,9 @@ async function syncOnce(ctx, lists, list, site) {
       digest: entry._rev
     });
   }
+  const skipped = drafts.length ? ` (${drafts.length} draft${drafts.length === 1 ? "" : "s"} skipped)` : "";
   ctx.logger.info(
-    `cancia: loaded ${entries.length} entr${entries.length === 1 ? "y" : "ies"} from list "${list}"`
+    `cancia: loaded ${entries.length} entr${entries.length === 1 ? "y" : "ies"} from list "${list}"${skipped}`
   );
 }
 function canciaLoader(opts) {
@@ -41,7 +48,7 @@ function canciaLoader(opts) {
         projectRoot: opts.projectRoot ?? process.cwd()
       });
       const { lists } = storage;
-      await syncOnce(ctx, lists, opts.list, opts.site);
+      await syncOnce(ctx, lists, opts.list, opts.site, opts.schema, opts.includeDrafts);
       if (ctx.watcher && !watcherAttached) {
         watcherAttached = true;
         const root = opts.projectRoot ?? process.cwd();
@@ -53,7 +60,14 @@ function canciaLoader(opts) {
             pendingTimer = null;
             inflight = inflight.catch(() => {
             }).then(
-              () => syncOnce(latestCtx, lists, opts.list, opts.site).catch((err) => {
+              () => syncOnce(
+                latestCtx,
+                lists,
+                opts.list,
+                opts.site,
+                opts.schema,
+                opts.includeDrafts
+              ).catch((err) => {
                 latestCtx.logger.error(`cancia: resync failed \u2014 ${err.message}`);
               })
             );

package/dist/{chunk-22DJVJBR.js → chunk-DIV2FFYX.js}

@@ -1,6 +1,6 @@
 import {
   loadListSchema
-} from "./chunk-NG5GJME5.js";
+} from "./chunk-VL6FO446.js";
 import {
   RevConflictError
 } from "./chunk-7IA5B5CF.js";

package/dist/{chunk-VFMOVGMC.js → chunk-HQIGNRIU.js}

@@ -1,9 +1,9 @@
 import {
   loadSchemas
-} from "./chunk-NG5GJME5.js";
+} from "./chunk-VL6FO446.js";
 import {
   describeList
-} from "./chunk-UMCBQXB6.js";
+} from "./chunk-WVHTCFE6.js";
 
 // src/routes/schemas.ts
 function json(body, status = 200) {

package/dist/{chunk-BOIQNZAO.js → chunk-KHCFVVYV.js}

@@ -53,6 +53,56 @@ var ptBlockSchema = z.object({
   }
 });
 var portableTextSubsetSchema = z.array(ptBlockSchema);
+function parseRichValue(raw) {
+  if (raw == null) return [];
+  let candidate = raw;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed === "") return [];
+    if (trimmed.startsWith("[")) {
+      try {
+        candidate = JSON.parse(trimmed);
+      } catch {
+        return [];
+      }
+    } else {
+      return [textBlock(raw)];
+    }
+  }
+  if (!Array.isArray(candidate)) return [];
+  const sanitised = candidate.map(stripUnsafeHrefs);
+  const parsed = portableTextSubsetSchema.safeParse(sanitised);
+  return parsed.success ? parsed.data : [];
+}
+function serializeRichValue(value) {
+  return value.length === 0 ? "" : JSON.stringify(value);
+}
+function textBlock(text) {
+  return {
+    _type: "block",
+    _key: "legacy",
+    style: "normal",
+    markDefs: [],
+    children: [{ _type: "span", _key: "legacy0", text, marks: [] }]
+  };
+}
+function stripUnsafeHrefs(block) {
+  if (!block || typeof block !== "object") return block;
+  const b = block;
+  if (!Array.isArray(b.markDefs)) return block;
+  const dropped = /* @__PURE__ */ new Set();
+  const markDefs = b.markDefs.filter((def) => {
+    const href = def?.href;
+    if (typeof href === "string" && isSafeHref(href)) return true;
+    if (typeof def?._key === "string") dropped.add(def._key);
+    return false;
+  });
+  if (dropped.size === 0) return block;
+  const children = Array.isArray(b.children) ? b.children.map(
+    (span) => Array.isArray(span?.marks) ? { ...span, marks: span.marks.filter((m) => !dropped.has(m)) } : span
+  ) : b.children;
+  return { ...b, markDefs, children };
+}
 
 export {
   PT_STYLES,
@@ -60,5 +110,7 @@ export {
   PT_DECORATORS,
   isSafeHref,
   ptBlockSchema,
-  portableTextSubsetSchema
+  portableTextSubsetSchema,
+  parseRichValue,
+  serializeRichValue
 };

package/dist/{chunk-NG5GJME5.js → chunk-VL6FO446.js}

@@ -32,8 +32,15 @@ async function loadListSchema(projectRoot, listName, overridePath) {
   const schemas = await loadSchemas(projectRoot, overridePath);
   return schemas[listName] ?? null;
 }
+function clearSchemaCache() {
+  _cache = null;
+  _cachedPath = null;
+  _cachedMtime = 0;
+}
 
 export {
+  resolveSchemasPath,
   loadSchemas,
-  loadListSchema
+  loadListSchema,
+  clearSchemaCache
 };

package/dist/{chunk-UMCBQXB6.js → chunk-WVHTCFE6.js}

@@ -1,10 +1,14 @@
 import {
   isSafeHref,
   portableTextSubsetSchema
-} from "./chunk-BOIQNZAO.js";
+} from "./chunk-KHCFVVYV.js";
 
 // src/schema/index.ts
 import { z } from "zod";
+function isDraft(schema, data) {
+  if (!schema.draftField) return false;
+  return data[schema.draftField] === true;
+}
 function defineList(opts) {
   return {
     label: opts.label,
@@ -12,6 +16,7 @@ function defineList(opts) {
     titleField: opts.titleField,
     bodyField: opts.bodyField,
     slugField: opts.slugField,
+    draftField: opts.draftField,
     fields: opts.fields,
     validator: z.object(opts.fields)
   };
@@ -23,6 +28,15 @@ var defineField = {
   email: (o) => z.string().email().meta({ widget: "email", ...o }),
   datetime: (o) => z.string().datetime().meta({ widget: "datetime", ...o }),
   checkbox: (o) => z.boolean().meta({ widget: "checkbox", ...o }),
+  /**
+   * The draft flag for a list's `draftField`. A checkbox that DEFAULTS to
+   * false, which is what makes it safe to add to an existing list: every
+   * stored entry that predates the field validates and reads as published
+   * rather than vanishing from the built site.
+   *
+   * Label defaults to "Draft" so the affordance reads the same on every list.
+   */
+  draft: (o) => z.boolean().default(false).meta({ widget: "checkbox", label: "Draft", ...o }),
   number: (o) => {
     let n = z.number();
     if (o?.min != null) n = n.min(o.min);
@@ -167,6 +181,7 @@ function describeList(name, schema) {
     titleField: schema.titleField,
     bodyField: schema.bodyField,
     slugField: schema.slugField,
+    draftField: schema.draftField,
     fields
   };
 }
@@ -202,6 +217,7 @@ function isExternalHref(href) {
 
 export {
   z,
+  isDraft,
   defineList,
   defineField,
   slugify,

package/dist/content.d.ts

@@ -9,6 +9,20 @@ interface LinkValue {
 }
 /** Resolve a link field, falling back to the values authored in the page. */
 type TranslateLink = (key: string, fallback: LinkValue) => LinkValue;
+/**
+ * Resolve a rich-text region (plan 051).
+ *
+ * Returns `null` when there is NO stored override — which the region renders as
+ * "show the markup authored in the page". That is deliberate and load-bearing:
+ * a rich fallback cannot be a JS string, so the authored markup IS the fallback,
+ * which is what keeps an empty DB rendering byte-identically.
+ *
+ * `[]` is a different answer from `null`: it means a stored, deliberately empty
+ * value — the client removed the prose on purpose — and renders nothing.
+ */
+type TranslateRich = (key: string) => RichValue | null;
+/** A Portable-Text subset document. Structurally typed to keep this subpath Vite-free. */
+type RichValue = Record<string, unknown>[];
 interface ContentReaderOptions {
     /** Site id (the `?site=` query param and the storage `site` column). */
     site: string;
@@ -57,10 +71,18 @@ interface ContentReader {
      * authored in the page. Never throws; drops an unsafe href.
      */
     makeTLink(cms: ContentMap): TranslateLink;
-    /** Sugar: `const { t, tLink, cms } = await reader.get()` in frontmatter. */
+    /**
+     * Build a rich-text resolver over a content map. Returns `null` when no
+     * override is stored, which a rich region renders as "show the markup
+     * authored in the page" — the reason an empty DB still renders identically.
+     * `[]` means a stored, deliberately empty value and renders nothing.
+     */
+    makeRich(cms: ContentMap): TranslateRich;
+    /** Sugar: `const { t, tLink, tRich, cms } = await reader.get()` in frontmatter. */
     get(): Promise<{
         t: Translate;
         tLink: TranslateLink;
+        tRich: TranslateRich;
         cms: ContentMap;
     }>;
 }
@@ -71,4 +93,4 @@ interface ContentReader {
  */
 declare function createContentReader(opts: ContentReaderOptions): ContentReader;
 
-export { type ContentMap, type ContentReader, type ContentReaderOptions, type LinkValue, type Translate, type TranslateLink, createContentReader };
+export { type ContentMap, type ContentReader, type ContentReaderOptions, type LinkValue, type RichValue, type Translate, type TranslateLink, type TranslateRich, createContentReader };

package/dist/content.js

@@ -37,6 +37,46 @@ function parseLink(raw, fallback) {
   }
   return { label: raw, href: fallback.href };
 }
+function parseRich(raw) {
+  if (raw === void 0) return null;
+  const trimmed = raw.trim();
+  if (trimmed === "") return [];
+  if (!trimmed.startsWith("[")) {
+    return [
+      {
+        _type: "block",
+        _key: "legacy",
+        style: "normal",
+        markDefs: [],
+        children: [{ _type: "span", _key: "legacy0", text: raw, marks: [] }]
+      }
+    ];
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.map(stripUnsafeMarkDefs);
+  } catch {
+    return [];
+  }
+}
+function stripUnsafeMarkDefs(block) {
+  if (!block || typeof block !== "object") return block;
+  const b = block;
+  if (!Array.isArray(b.markDefs)) return block;
+  const dropped = /* @__PURE__ */ new Set();
+  const markDefs = b.markDefs.filter((def) => {
+    const href = def?.href;
+    if (typeof href === "string" && isSafeHref(href)) return true;
+    if (typeof def?._key === "string") dropped.add(def._key);
+    return false;
+  });
+  if (dropped.size === 0) return block;
+  const children = Array.isArray(b.children) ? b.children.map(
+    (span) => Array.isArray(span?.marks) ? { ...span, marks: span.marks.filter((m) => !dropped.has(m)) } : span
+  ) : b.children;
+  return { ...b, markDefs, children };
+}
 function createContentReader(opts) {
   const site = opts.site;
   const lang = opts.lang ?? "en";
@@ -73,11 +113,14 @@ function createContentReader(opts) {
   function makeTLink(cms) {
     return (key, fallback) => parseLink(cms[`${key}.${lang}`], fallback);
   }
+  function makeRich(cms) {
+    return (key) => parseRich(cms[`${key}.${lang}`]);
+  }
   async function get() {
     const cms = await getCMS();
-    return { t: makeT(cms), tLink: makeTLink(cms), cms };
+    return { t: makeT(cms), tLink: makeTLink(cms), tRich: makeRich(cms), cms };
   }
-  return { getCMS, makeT, makeTLink, get };
+  return { getCMS, makeT, makeTLink, makeRich, get };
 }
 export {
   createContentReader

package/dist/endpoints/lists.js

@@ -4,9 +4,9 @@ import {
 } from "../chunk-VGRG5DN7.js";
 import {
   makeListsRoutes
-} from "../chunk-22DJVJBR.js";
-import "../chunk-NG5GJME5.js";
+} from "../chunk-DIV2FFYX.js";
 import "../chunk-X6ZFFGIA.js";
+import "../chunk-VL6FO446.js";
 import "../chunk-7IA5B5CF.js";
 
 // src/endpoints/lists.ts

package/dist/endpoints/schemas.js

@@ -1,9 +1,9 @@
 import {
   makeSchemasRoute
-} from "../chunk-VFMOVGMC.js";
-import "../chunk-NG5GJME5.js";
-import "../chunk-UMCBQXB6.js";
-import "../chunk-BOIQNZAO.js";
+} from "../chunk-HQIGNRIU.js";
+import "../chunk-VL6FO446.js";
+import "../chunk-WVHTCFE6.js";
+import "../chunk-KHCFVVYV.js";
 
 // src/endpoints/schemas.ts
 import { getCanciaRuntime } from "virtual:cancia/runtime";

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export { FieldDescription, FieldMeta, FieldMetaBase, FieldWidget, ListDescriptio
 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';
+import './portable-text-D74aIuHn.js';
 
 interface R2UploadHandlerOptions {
     /** Cloudflare account ID (from R2 dashboard) */

package/dist/index.js

@@ -1,13 +1,12 @@
+import {
+  makeSchemasRoute
+} from "./chunk-HQIGNRIU.js";
 import {
   runPublish
 } from "./chunk-5RCLBWRH.js";
 import {
   makeListsRoutes
-} from "./chunk-22DJVJBR.js";
-import {
-  makeSchemasRoute
-} from "./chunk-VFMOVGMC.js";
-import "./chunk-NG5GJME5.js";
+} from "./chunk-DIV2FFYX.js";
 import {
   makeLocalUploadHandler,
   makeR2UploadHandler,
@@ -15,15 +14,6 @@ import {
   setCanciaRuntime
 } from "./chunk-AGNPUTKS.js";
 import "./chunk-5IPHDIC6.js";
-import {
-  defineField,
-  defineList,
-  describeList,
-  z
-} from "./chunk-UMCBQXB6.js";
-import {
-  canciaLoader
-} from "./chunk-UR5WC3RA.js";
 import {
   createSQLiteAdapter
 } from "./chunk-CJDIVWO3.js";
@@ -33,6 +23,10 @@ import {
   createSqliteAdapterV2
 } from "./chunk-GNWD7EL2.js";
 import "./chunk-U7V53JX7.js";
+import "./chunk-VL6FO446.js";
+import {
+  canciaLoader
+} from "./chunk-3B3CXOMK.js";
 import {
   createJsonFileAdapter,
   createJsonFileAdapterV2
@@ -40,11 +34,18 @@ import {
 import {
   RevConflictError
 } from "./chunk-7IA5B5CF.js";
-import "./chunk-BOIQNZAO.js";
+import {
+  defineField,
+  defineList,
+  describeList,
+  z
+} from "./chunk-WVHTCFE6.js";
+import "./chunk-KHCFVVYV.js";
 
 // src/integration.ts
 import { loadEnv } from "vite";
 import { fileURLToPath, pathToFileURL } from "url";
+import { readFile } from "fs/promises";
 import { isAbsolute, join as join2 } from "path";
 
 // src/routes/content.ts
@@ -198,6 +199,211 @@ CANCIA_TOKEN=${token}
   return token;
 }
 
+// src/transform/attribute-text.ts
+import { parse } from "@astrojs/compiler";
+var HELPER_NAME = "__canciaText";
+var LINK_HELPER_NAME = "__canciaLink";
+var LOADER_NAME = "__canciaContent";
+var CONTENT_LOCAL = "__canciaCms";
+var HELPER_MODULE = "virtual:cancia/text";
+var RAW_TEXT = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "pre",
+  "textarea",
+  "code",
+  "title",
+  "option",
+  "noscript",
+  "template"
+]);
+function byteToCharMap(source) {
+  let ascii = true;
+  for (let i = 0; i < source.length; i++) {
+    if (source.charCodeAt(i) > 127) {
+      ascii = false;
+      break;
+    }
+  }
+  if (ascii) return (b) => b;
+  const map = /* @__PURE__ */ new Map();
+  let byte = 0;
+  for (let char = 0; char < source.length; char++) {
+    map.set(byte, char);
+    const code = source.codePointAt(char);
+    byte += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+    if (code >= 65536) char++;
+  }
+  map.set(byte, source.length);
+  return (b) => map.get(b) ?? b;
+}
+function quote(text) {
+  return JSON.stringify(text);
+}
+function findOpenAngle(node, src, at) {
+  const name = node.name ?? "";
+  const floor = Math.max(0, at - 4096);
+  for (let i = Math.min(at, src.length - 1); i >= floor; i--) {
+    if (src[i] !== "<") continue;
+    if (src.slice(i + 1, i + 1 + name.length) !== name) continue;
+    const boundary = src[i + 1 + name.length];
+    if (boundary === void 0 || /[\s/>]/.test(boundary)) return i;
+  }
+  return null;
+}
+function readAttr(openTag, name) {
+  const re = new RegExp(`\\s${name}\\s*=\\s*["']([^"']*)["']`);
+  return re.exec(openTag)?.[1] ?? null;
+}
+function findOpenTagEnd(src, lt) {
+  let quoteChar = null;
+  for (let i = lt; i < src.length; i++) {
+    const c = src[i];
+    if (quoteChar) {
+      if (c === quoteChar) quoteChar = null;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quoteChar = c;
+      continue;
+    }
+    if (c === ">") return i + 1;
+  }
+  return null;
+}
+async function transformAttributeText(source) {
+  if (!source.includes("data-cms")) {
+    return { code: source, changed: false, substituted: [] };
+  }
+  const toChar = byteToCharMap(source);
+  let ast;
+  try {
+    ast = (await parse(source, { position: true })).ast;
+  } catch {
+    return { code: source, changed: false, substituted: [] };
+  }
+  const edits = [];
+  const substituted = [];
+  function visit(node) {
+    if (node.type === "element" && RAW_TEXT.has((node.name ?? "").toLowerCase())) {
+      return;
+    }
+    if (node.type === "element") {
+      const reported = node.position?.start?.offset;
+      if (reported !== void 0) {
+        const lt = findOpenAngle(node, source, toChar(reported));
+        if (lt !== null) {
+          const gt = findOpenTagEnd(source, lt);
+          if (gt !== null) {
+            const openTag = source.slice(lt, gt);
+            const key = readAttr(openTag, "data-cms");
+            if (key !== null) {
+              const declaredType = readAttr(openTag, "data-cms-type");
+              const isList = /\sdata-cms-list\s*=/.test(openTag);
+              if (declaredType === "link" && !isList) {
+                const kids = (node.children ?? []).filter(
+                  (c) => c.type !== "text" || (c.value ?? "").trim() !== ""
+                );
+                const soleText = kids.length === 1 && kids[0].type === "text" ? kids[0] : null;
+                const authoredHref = readAttr(openTag, "href");
+                if (soleText && authoredHref !== null) {
+                  const raw = soleText.value ?? "";
+                  const literal = raw.replace(/\s+/g, " ").trim();
+                  const s = soleText.position?.start?.offset;
+                  const e = soleText.position?.end?.offset;
+                  const hrefRe = /\shref\s*=\s*(["'])([^"']*)\1/.exec(openTag);
+                  if (literal !== "" && s !== void 0 && e !== void 0 && hrefRe) {
+                    const call = `${LINK_HELPER_NAME}(${CONTENT_LOCAL}, ${quote(key)}, ${quote(literal)}, ${quote(hrefRe[2])})`;
+                    edits.push({
+                      start: lt + hrefRe.index,
+                      end: lt + hrefRe.index + hrefRe[0].length,
+                      text: ` href={${call}.href}`
+                    });
+                    edits.push({
+                      start: toChar(s),
+                      end: toChar(e),
+                      text: `{${call}.label}`
+                    });
+                    substituted.push({ key, line: node.position?.start?.line ?? 0 });
+                  }
+                }
+              }
+              const typed = declaredType !== null;
+              if (!typed && !isList) {
+                const kids = (node.children ?? []).filter(
+                  (c) => c.type !== "text" || (c.value ?? "").trim() !== ""
+                );
+                const soleText = kids.length === 1 && kids[0].type === "text" ? kids[0] : null;
+                if (soleText) {
+                  const raw = soleText.value ?? "";
+                  const literal = raw.replace(/\s+/g, " ").trim();
+                  const s = soleText.position?.start?.offset;
+                  const e = soleText.position?.end?.offset;
+                  if (literal !== "" && s !== void 0 && e !== void 0) {
+                    edits.push({
+                      start: toChar(s),
+                      end: toChar(e),
+                      // Emitted as an EXPRESSION, not a spliced string: Astro
+                      // escapes {expression} output, which is the XSS gate. A
+                      // probe proved naive splicing executes a stored
+                      // <script> tag.
+                      text: `{${HELPER_NAME}(${CONTENT_LOCAL}, ${quote(key)}, ${quote(literal)})}`
+                    });
+                    substituted.push({
+                      key,
+                      line: node.position?.start?.line ?? 0
+                    });
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    for (const child of node.children ?? []) visit(child);
+  }
+  visit(ast);
+  if (edits.length === 0) {
+    return { code: source, changed: false, substituted: [] };
+  }
+  edits.sort((a, b) => b.start - a.start);
+  let code = source;
+  for (const edit of edits) {
+    code = code.slice(0, edit.start) + edit.text + code.slice(edit.end);
+  }
+  return {
+    code: injectImports(code, {
+      text: code.includes(`${HELPER_NAME}(`),
+      link: code.includes(`${LINK_HELPER_NAME}(`)
+    }),
+    changed: true,
+    substituted
+  };
+}
+function injectImports(code, used) {
+  const names = [
+    LOADER_NAME,
+    used.text ? HELPER_NAME : null,
+    used.link ? LINK_HELPER_NAME : null
+  ].filter(Boolean).join(", ");
+  const preamble = [
+    `import { ${names} } from ${quote(HELPER_MODULE)};`,
+    `const ${CONTENT_LOCAL} = await ${LOADER_NAME}();`
+  ].join("\n");
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(code);
+  if (!fm) {
+    return `---
+${preamble}
+---
+${code}`;
+  }
+  if (fm[1].includes(HELPER_MODULE)) return code;
+  const at = fm.index + fm[0].length - 3;
+  return `${code.slice(0, at)}${preamble}
+${code.slice(at)}`;
+}
+
 // src/integration.ts
 function resolvePublish(opts, hasDeployHookEnv) {
   const publish = opts.publish;
@@ -343,6 +549,11 @@ function canciaIntegration(opts = {}) {
         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";
+        const textHelperModulePath = fileURLToPath(
+          new URL("./transform/text-helper.js", import.meta.url)
+        );
+        const TEXT_VIRTUAL_ID = "virtual:cancia/text";
+        const RESOLVED_TEXT_VIRTUAL_ID = "\0virtual:cancia/text";
         updateConfig({
           vite: {
             plugins: [
@@ -363,6 +574,56 @@ function canciaIntegration(opts = {}) {
                     `export { getCanciaRuntime };`
                   ].join("\n");
                 }
+              },
+              // ---- plan 054: attribute-only authoring ---------------------
+              // Rewrites `<h1 data-cms="k">text</h1>` into a helper call before
+              // Astro's compiler reads the file, so a developer never writes a
+              // t() call, an import, or a repeated key.
+              //
+              // This works because Astro compiles the `source` ARGUMENT rather
+              // than reading from disk (deliberate since astro#3889), so an
+              // upstream transform is honoured.
+              //
+              // NOTE `enforce: "pre"` does NOT place this before Astro's own
+              // plugin — Astro prepends its own and mergeConfig appends ours
+              // (measured: ours at 20, astro:build at 9). It works because Vite
+              // CHAINS transform hooks and Astro's has an id filter. Do not
+              // write anything here that depends on plugin array position.
+              {
+                name: "vite-plugin-cancia-attribute-text",
+                enforce: "pre",
+                resolveId(id) {
+                  if (id === TEXT_VIRTUAL_ID) return RESOLVED_TEXT_VIRTUAL_ID;
+                },
+                async load(id) {
+                  if (id.endsWith(".astro") && !id.includes("?")) {
+                    let source;
+                    try {
+                      source = await readFile(id, "utf8");
+                    } catch {
+                      return null;
+                    }
+                    const result = await transformAttributeText(source);
+                    return result.changed ? result.code : null;
+                  }
+                  if (id !== RESOLVED_TEXT_VIRTUAL_ID) return;
+                  const importUrl = pathToFileURL(textHelperModulePath).href;
+                  return [
+                    `import { __canciaText, __canciaLink, __canciaContent, configureTextHelper } from ${JSON.stringify(importUrl)};`,
+                    `import { getCanciaRuntime } from "virtual:cancia/runtime";`,
+                    `configureTextHelper({`,
+                    `  site: ${JSON.stringify(site)},`,
+                    `  lang: ${JSON.stringify(languages[0] ?? "en")},`,
+                    // The read goes through the runtime so it uses whatever
+                    // storage this project configured — no second adapter path.
+                    `  read: async () => {`,
+                    `    const rt = getCanciaRuntime();`,
+                    `    return rt.storageV2 ? rt.storageV2.kv.getAll(${JSON.stringify(site)}) : {};`,
+                    `  },`,
+                    `});`,
+                    `export { __canciaText, __canciaLink, __canciaContent };`
+                  ].join("\n");
+                }
               }
             ]
           }

package/dist/loader/index.d.ts

@@ -1,5 +1,8 @@
 import { Loader } from 'astro/loaders';
 import { a as CanciaStorageV2 } from '../types-BMlLS-OS.js';
+import { ListSchema } from '../schema/index.js';
+import 'zod';
+import '../portable-text-D74aIuHn.js';
 
 interface CanciaLoaderOptions {
     /** The list name as declared in src/cms/schemas.ts. */
@@ -20,6 +23,27 @@ interface CanciaLoaderOptions {
      * adapter. Ignored when `storage` is supplied.
      */
     projectRoot?: string;
+    /**
+     * The list's schema. Pass it to enable draft filtering: when the schema
+     * declares a `draftField`, entries flagged as drafts are omitted from the
+     * collection, so an unpublished entry never reaches the built site.
+     *
+     * Optional — omitting it keeps the pre-056 behaviour of emitting every
+     * stored entry. You are almost certainly already importing `schemas` in
+     * `src/content.config.ts` for the collection's `schema:`, so this is one
+     * more reference to the same object:
+     *
+     *   loader: canciaLoader({ list: "blog", site: "x", schema: schemas.blog }),
+     *   schema: schemas.blog.validator,
+     */
+    schema?: Pick<ListSchema, "draftField">;
+    /**
+     * Emit drafts anyway, even when `schema.draftField` is set. The escape hatch
+     * for a preview deployment: build the same site with drafts visible by
+     * flipping one flag (e.g. `includeDrafts: import.meta.env.PREVIEW === "1"`),
+     * rather than maintaining a second content config.
+     */
+    includeDrafts?: boolean;
 }
 declare function canciaLoader(opts: CanciaLoaderOptions): Loader;
 

package/dist/loader/index.js

@@ -1,8 +1,10 @@
 import {
   canciaLoader
-} from "../chunk-UR5WC3RA.js";
+} from "../chunk-3B3CXOMK.js";
 import "../chunk-L2VKQJPY.js";
 import "../chunk-7IA5B5CF.js";
+import "../chunk-WVHTCFE6.js";
+import "../chunk-KHCFVVYV.js";
 export {
   canciaLoader
 };

package/dist/{portable-text-BikSqS9T.d.ts → portable-text-D74aIuHn.d.ts}

@@ -113,5 +113,29 @@ declare const portableTextSubsetSchema: z.ZodArray<z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>>;
 type PortableTextValue = z.infer<typeof portableTextSubsetSchema>;
+/**
+ * Parse a stored rich-text value. NEVER throws.
+ *
+ * The KV surface stores every value as a string, so a rich document round-trips
+ * as JSON — exactly the precedent `link` set (see parseLinkValue). Four cases
+ * must all degrade gracefully rather than break a render:
+ *
+ *   - valid PT-subset JSON  → used as-is, with unsafe hrefs stripped
+ *   - a bare string         → ONE normal block containing that text. This is
+ *                             the migration path for a field promoted from
+ *                             `text` to `richtext`: it keeps rendering.
+ *   - empty string          → [] (deliberately empty — renders nothing, on
+ *                             purpose; NOT the same as "no override")
+ *   - malformed / off-subset → [] rather than propagating bad data to the
+ *                             renderer
+ *
+ * Unsafe hrefs are dropped ON READ, not only rejected on write. Validation
+ * guards the save path, but a value can reach a renderer another way — an older
+ * row, a hand-edited DB, a different adapter — so the read is where the
+ * guarantee actually holds. Same rule, same reason, as parseLinkValue.
+ */
+declare function parseRichValue(raw: unknown): PortableTextValue;
+/** Serialise a rich value for the KV store. Empty array -> "" (hidden). */
+declare function serializeRichValue(value: PortableTextValue): string;
 
-export { PT_DECORATORS as P, PT_LIST_ITEMS as a, PT_STYLES as b, type PortableTextValue as c, type PtBlock as d, type PtDecorator as e, type PtLinkMarkDef as f, type PtListItem as g, type PtSpan as h, type PtStyle as i, isSafeHref as j, ptBlockSchema as k, portableTextSubsetSchema as p };
+export { PT_DECORATORS as P, PT_LIST_ITEMS as a, PT_STYLES as b, type PortableTextValue as c, type PtBlock as d, type PtDecorator as e, type PtLinkMarkDef as f, type PtListItem as g, type PtSpan as h, type PtStyle as i, isSafeHref as j, portableTextSubsetSchema as k, ptBlockSchema as l, parseRichValue as p, serializeRichValue as s };

package/dist/richtext/CanciaRichRegion.astro

@@ -0,0 +1,57 @@
+---
+// =============================================================================
+// <CanciaRichRegion> — an editable rich-text region on the INLINE surface
+// =============================================================================
+// A slot the client can fill with real prose: paragraphs, h2/h3, blockquotes,
+// bullet/number lists, strong/em, and links. They may ADD and DELETE paragraphs
+// inside it. What they cannot do is invent a new section — the structure of the
+// PAGE stays the developer's; the structure INSIDE a region is the client's.
+//
+// Usage:
+//   ---
+//   import CanciaRichRegion from "@cancia/astro/richtext/CanciaRichRegion.astro";
+//   const { tRich } = await reader.get();
+//   ---
+//   <CanciaRichRegion key="about.story" value={tRich("about.story")}>
+//     <p>The prose authored in the page. This is the fallback.</p>
+//   </CanciaRichRegion>
+//
+// THE FALLBACK IS THE SLOT. A rich fallback cannot be a JS string, so rather
+// than serialise the markup into a Portable-Text literal at annotate time
+// (lossy, unreadable, and it stops the source being the source of truth), the
+// authored children ARE the fallback. An empty DB therefore renders
+// byte-identically — the invariant that makes annotating a live client site
+// safe.
+//
+// Three states, and the difference between the last two matters:
+//   value === null  → no override. Render the authored children.
+//   value === []    → a stored, DELIBERATELY EMPTY value. Render nothing; the
+//                     client removed this prose on purpose. Falling back to the
+//                     authored children here would resurrect deleted content.
+//   value = blocks  → render the stored document.
+//
+// Ships as a raw .astro under dist/richtext/ (an .astro file can't be a tsup
+// entry) and is Vite-free at the package boundary.
+// =============================================================================
+import CanciaRichText from "./CanciaRichText.astro";
+
+export interface Props {
+  /** Content key — what the toolbar edits and what the value is stored under. */
+  key: string;
+  /** The resolved value from `tRich(key)`. `null` means "no override". */
+  value?: Record<string, unknown>[] | null;
+  /** Element to render as the region wrapper. Default: `div`. */
+  as?: string;
+  class?: string;
+}
+
+const { key, value = null, as: Tag = "div", class: className } = Astro.props;
+
+// `null` (no row) is the only state that shows the authored markup. An empty
+// array is a real stored value and must render empty — see the header.
+const hasOverride = Array.isArray(value);
+---
+
+<Tag data-cms={key} data-cms-type="richtext" class={className}>
+  {hasOverride ? <CanciaRichText value={value} /> : <slot />}
+</Tag>

package/dist/richtext/index.d.ts

@@ -1,5 +1,5 @@
-import { i as PtStyle, g as PtListItem, d as PtBlock } from '../portable-text-BikSqS9T.js';
-export { P as PT_DECORATORS, a as PT_LIST_ITEMS, b as PT_STYLES, c as PortableTextValue, e as PtDecorator, f as PtLinkMarkDef, h as PtSpan, j as isSafeHref, p as portableTextSubsetSchema, k as ptBlockSchema } from '../portable-text-BikSqS9T.js';
+import { i as PtStyle, g as PtListItem, d as PtBlock } from '../portable-text-D74aIuHn.js';
+export { P as PT_DECORATORS, a as PT_LIST_ITEMS, b as PT_STYLES, c as PortableTextValue, e as PtDecorator, f as PtLinkMarkDef, h as PtSpan, j as isSafeHref, p as parseRichValue, k as portableTextSubsetSchema, l as ptBlockSchema, s as serializeRichValue } from '../portable-text-D74aIuHn.js';
 import 'zod';
 
 /** A row as the editor holds it: raw shorthand text + style + optional list kind. */

package/dist/richtext/index.js

@@ -3,9 +3,11 @@ import {
   PT_LIST_ITEMS,
   PT_STYLES,
   isSafeHref,
+  parseRichValue,
   portableTextSubsetSchema,
-  ptBlockSchema
-} from "../chunk-BOIQNZAO.js";
+  ptBlockSchema,
+  serializeRichValue
+} from "../chunk-KHCFVVYV.js";
 
 // src/richtext/markdown.ts
 function keyGen(prefix) {
@@ -134,9 +136,11 @@ export {
   PT_STYLES,
   blockToRow,
   isSafeHref,
+  parseRichValue,
   portableTextSubsetSchema,
   portableTextToRows,
   ptBlockSchema,
   rowToBlock,
-  rowsToPortableText
+  rowsToPortableText,
+  serializeRichValue
 };

package/dist/schema/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export { z } from 'zod';
-export { P as PT_DECORATORS, a as PT_LIST_ITEMS, b as PT_STYLES, c as PortableTextValue, d as PtBlock, e as PtDecorator, f as PtLinkMarkDef, g as PtListItem, h as PtSpan, i as PtStyle, j as isSafeHref, p as portableTextSubsetSchema, k as ptBlockSchema } from '../portable-text-BikSqS9T.js';
+export { P as PT_DECORATORS, a as PT_LIST_ITEMS, b as PT_STYLES, c as PortableTextValue, d as PtBlock, e as PtDecorator, f as PtLinkMarkDef, g as PtListItem, h as PtSpan, i as PtStyle, j as isSafeHref, p as parseRichValue, k as portableTextSubsetSchema, l as ptBlockSchema, s as serializeRichValue } from '../portable-text-D74aIuHn.js';
 
 /**
  * Widget hint the modal form uses to pick an input element. The Zod type
@@ -82,6 +82,21 @@ interface ListSchemaOptions<TFields extends Record<string, z.ZodTypeAny>> {
      * Defaults to the entry ID. The server validates slug uniqueness on save.
      */
     slugField?: keyof TFields & string;
+    /**
+     * Field name holding the entry's draft flag. When set, `canciaLoader`
+     * omits entries whose value is truthy from the content collection, so a
+     * draft never reaches the built site.
+     *
+     * The field MUST be a boolean with a default (`defineField.draft()` gives
+     * you exactly that) — an `undefined` draft flag reads as published, which
+     * is the safe direction for the pre-existing entries of a list that adds
+     * `draftField` later.
+     *
+     * Draft is deliberately per-list opt-in rather than an implicit field on
+     * every list: a list of office locations or nav links has no meaningful
+     * draft state, and a phantom "Draft" checkbox on every form is noise.
+     */
+    draftField?: keyof TFields & string;
     /** Field definitions. */
     fields: TFields;
 }
@@ -91,10 +106,24 @@ interface ListSchema<TFields extends Record<string, z.ZodTypeAny> = Record<strin
     titleField: string;
     bodyField: string | undefined;
     slugField: string | undefined;
+    draftField: string | undefined;
     fields: TFields;
     /** Zod object schema combining all fields, for one-shot validation. */
     validator: z.ZodObject<TFields>;
 }
+/**
+ * True when `entry.data` is a draft under `schema.draftField`.
+ *
+ * The single source of truth for "is this entry a draft" — the loader, the
+ * toolbar preview rows and any user-side filter all call THIS, so a draft is
+ * decided identically everywhere. Vite-free and dependency-free by design.
+ *
+ * Reads as published (`false`) when the list declares no draftField, when the
+ * field is absent, or when it is `undefined` — every ambiguous case resolves
+ * to "published", matching the field's own default and keeping entries that
+ * predate the draftField visible.
+ */
+declare function isDraft(schema: Pick<ListSchema, "draftField">, data: Record<string, unknown>): boolean;
 declare function defineList<TFields extends Record<string, z.ZodTypeAny>>(opts: ListSchemaOptions<TFields>): ListSchema<TFields>;
 /**
  * One field as seen by the modal form. Plain JSON, no Zod refs.
@@ -154,6 +183,15 @@ declare const defineField: {
     email: (o?: PlainFieldOptions) => z.ZodString;
     datetime: (o?: PlainFieldOptions) => z.ZodString;
     checkbox: (o?: PlainFieldOptions) => z.ZodBoolean;
+    /**
+     * The draft flag for a list's `draftField`. A checkbox that DEFAULTS to
+     * false, which is what makes it safe to add to an existing list: every
+     * stored entry that predates the field validates and reads as published
+     * rather than vanishing from the built site.
+     *
+     * Label defaults to "Draft" so the affordance reads the same on every list.
+     */
+    draft: (o?: PlainFieldOptions) => z.ZodDefault<z.ZodBoolean>;
     number: (o?: PlainFieldOptions & {
         min?: number;
         max?: number;
@@ -266,6 +304,11 @@ interface ListDescription {
     titleField: string;
     bodyField?: string;
     slugField?: string;
+    /**
+     * Field holding the draft flag, when the list opts in. The toolbar uses it
+     * to badge unpublished rows; the loader uses it to omit them from the build.
+     */
+    draftField?: string;
     fields: FieldDescription[];
 }
 /**
@@ -317,4 +360,4 @@ declare function isExternalHref(href: string): boolean;
 /** Map of list name → schema. What users export from src/cms/schemas.ts. */
 type SchemasModule = Record<string, ListSchema>;
 
-export { type FieldDescription, type FieldMeta, type FieldMetaBase, type FieldWidget, type LinkValue, type ListDescription, type ListSchema, type ListSchemaOptions, type SchemasModule, defineField, defineList, describeList, isExternalHref, parseLinkValue, serializeLinkValue, slugify };
+export { type FieldDescription, type FieldMeta, type FieldMetaBase, type FieldWidget, type LinkValue, type ListDescription, type ListSchema, type ListSchemaOptions, type SchemasModule, defineField, defineList, describeList, isDraft, isExternalHref, parseLinkValue, serializeLinkValue, slugify };

package/dist/schema/index.js

@@ -2,20 +2,23 @@ import {
   defineField,
   defineList,
   describeList,
+  isDraft,
   isExternalHref,
   parseLinkValue,
   serializeLinkValue,
   slugify,
   z
-} from "../chunk-UMCBQXB6.js";
+} from "../chunk-WVHTCFE6.js";
 import {
   PT_DECORATORS,
   PT_LIST_ITEMS,
   PT_STYLES,
   isSafeHref,
+  parseRichValue,
   portableTextSubsetSchema,
-  ptBlockSchema
-} from "../chunk-BOIQNZAO.js";
+  ptBlockSchema,
+  serializeRichValue
+} from "../chunk-KHCFVVYV.js";
 export {
   PT_DECORATORS,
   PT_LIST_ITEMS,
@@ -23,12 +26,15 @@ export {
   defineField,
   defineList,
   describeList,
+  isDraft,
   isExternalHref,
   isSafeHref,
   parseLinkValue,
+  parseRichValue,
   portableTextSubsetSchema,
   ptBlockSchema,
   serializeLinkValue,
+  serializeRichValue,
   slugify,
   z
 };

package/dist/schema/loader.d.ts

@@ -0,0 +1,23 @@
+import { ListSchema, SchemasModule } from './index.js';
+import 'zod';
+import '../portable-text-D74aIuHn.js';
+
+/**
+ * Resolve the absolute path to the user's schemas.ts. Returns null if no
+ * file exists at the expected location.
+ */
+declare function resolveSchemasPath(projectRoot: string, overridePath?: string): string | null;
+/**
+ * Load (and cache) the user's schemas module. Returns an empty map if no
+ * schemas.ts exists — the inline editor still works for KV edits without
+ * any lists defined.
+ */
+declare function loadSchemas(projectRoot: string, overridePath?: string): Promise<SchemasModule>;
+/**
+ * Get a single list schema, or null if it doesn't exist.
+ */
+declare function loadListSchema(projectRoot: string, listName: string, overridePath?: string): Promise<ListSchema | null>;
+/** For tests — drop the in-memory cache. */
+declare function clearSchemaCache(): void;
+
+export { clearSchemaCache, loadListSchema, loadSchemas, resolveSchemasPath };

package/dist/schema/loader.js

@@ -0,0 +1,12 @@
+import {
+  clearSchemaCache,
+  loadListSchema,
+  loadSchemas,
+  resolveSchemasPath
+} from "../chunk-VL6FO446.js";
+export {
+  clearSchemaCache,
+  loadListSchema,
+  loadSchemas,
+  resolveSchemasPath
+};

package/dist/transform/text-helper.d.ts

@@ -0,0 +1,47 @@
+import { ContentMap } from '../content.js';
+
+/** Test/dev hook — a content change must not be served from a stale cache. */
+declare function clearTextCache(): void;
+interface TextHelperConfig {
+    site: string;
+    lang: string;
+    /** Reads the whole content map. Injected so this module imports no adapter. */
+    read: () => Promise<ContentMap>;
+}
+declare function configureTextHelper(next: TextHelperConfig): void;
+/**
+ * Load the content map. Awaited once per page, in frontmatter.
+ *
+ * NEVER throws or rejects. A content read must not break a build — the same rule
+ * createContentReader holds — so every failure resolves to an empty map, and
+ * every call site then falls back to the text authored in the page. A site whose
+ * database is unreachable renders exactly as its source says.
+ */
+declare function __canciaContent(): Promise<ContentMap>;
+/**
+ * Resolve one annotated element's text.
+ *
+ * `??` is load-bearing, not style: a stored "" means DELIBERATELY EMPTY (the
+ * client removed this text on purpose) and must NOT fall through to the authored
+ * fallback, or deleted content reappears on every build.
+ */
+declare function __canciaText(cms: ContentMap, key: string, fallback: string): string;
+interface LinkValue {
+    label: string;
+    href: string;
+}
+/**
+ * Resolve a link field — label AND href from one stored value.
+ *
+ * A link stores `{label, href}` as JSON so a new label can never be saved
+ * against a stale href. Both halves have an authored fallback (the text, and the
+ * `href=` already in the markup), which is why a link needs no t() call either.
+ *
+ * An unsafe href is DROPPED on read, falling back to the authored one — the same
+ * rule parseLinkValue holds, and for the same reason: validation guards the
+ * write path, but a value can reach a renderer from an older row or a
+ * hand-edited DB, so the read is where the guarantee has to hold.
+ */
+declare function __canciaLink(cms: ContentMap, key: string, labelFallback: string, hrefFallback: string): LinkValue;
+
+export { type LinkValue, type TextHelperConfig, __canciaContent, __canciaLink, __canciaText, clearTextCache, configureTextHelper };

package/dist/transform/text-helper.js

@@ -0,0 +1,64 @@
+// src/transform/text-helper.ts
+var contentPromise = null;
+function clearTextCache() {
+  contentPromise = null;
+}
+var config = null;
+function configureTextHelper(next) {
+  config = next;
+  contentPromise = null;
+}
+async function __canciaContent() {
+  if (!config) return {};
+  try {
+    if (!contentPromise) contentPromise = config.read();
+    return await contentPromise;
+  } catch {
+    contentPromise = null;
+    return {};
+  }
+}
+function lang() {
+  return config?.lang ?? "en";
+}
+function __canciaText(cms, key, fallback) {
+  return cms[`${key}.${lang()}`] ?? fallback;
+}
+function isSafeHref(href) {
+  const trimmed = href.trim();
+  if (trimmed === "") return true;
+  if (/^(https?:|mailto:|tel:)/i.test(trimmed)) return true;
+  const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(trimmed);
+  if (scheme) {
+    const firstSep = trimmed.search(/[/?#]/);
+    if (firstSep === -1 || scheme[1].length < firstSep) return false;
+  }
+  return true;
+}
+function __canciaLink(cms, key, labelFallback, hrefFallback) {
+  const fallback = { label: labelFallback, href: hrefFallback };
+  const raw = cms[`${key}.${lang()}`];
+  if (raw === void 0) return fallback;
+  if (raw === "") return { label: "", href: "" };
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const href = String(parsed.href ?? "");
+      return {
+        label: String(parsed.label ?? "") || labelFallback,
+        href: href && isSafeHref(href) ? href : hrefFallback
+      };
+    } catch {
+      return fallback;
+    }
+  }
+  return { label: raw, href: hrefFallback };
+}
+export {
+  __canciaContent,
+  __canciaLink,
+  __canciaText,
+  clearTextCache,
+  configureTextHelper
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cancia/astro",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Astro integration for Cancia CMS — inline editing with zero separate server",
   "license": "MIT",
   "repository": {
@@ -20,6 +20,10 @@
       "types": "./dist/schema/index.d.ts",
       "import": "./dist/schema/index.js"
     },
+    "./schema-loader": {
+      "types": "./dist/schema/loader.d.ts",
+      "import": "./dist/schema/loader.js"
+    },
     "./loader": {
       "types": "./dist/loader/index.d.ts",
       "import": "./dist/loader/index.js"
@@ -40,7 +44,8 @@
       "types": "./dist/richtext/index.d.ts",
       "import": "./dist/richtext/index.js"
     },
-    "./richtext/CanciaRichText.astro": "./dist/richtext/CanciaRichText.astro"
+    "./richtext/CanciaRichText.astro": "./dist/richtext/CanciaRichText.astro",
+    "./richtext/CanciaRichRegion.astro": "./dist/richtext/CanciaRichRegion.astro"
   },
   "files": [
     "dist"
@@ -68,7 +73,8 @@
   },
   "dependencies": {
     "astro-portabletext": "^0.13.0",
-    "zod": "^4.4.3"
+    "zod": "^4.4.3",
+    "@astrojs/compiler": "^2.10.0"
   },
   "scripts": {
     "build": "tsup",