@caelo-cms/shared 0.10.71 → 0.11.0

package/src/lists/list-type.ts

@@ -0,0 +1,306 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * List types — the definition part of a list (epic #1107,
+ * `docs/lists.md` §3). A list type names the entry kinds (`nodes`), the
+ * fields each carries, what may hang under what, and which nodes are
+ * filled from a source instead of stored children. Every form of list
+ * is expressed with it: a flat link group, a three-level menu, a mega
+ * dropdown with columns, teasers and a "latest news" block, an unbounded
+ * category tree.
+ */
+
+import { z } from "zod";
+import {
+  checkFieldDef,
+  type FieldDef,
+  fieldDefSchema,
+  fieldExtSchema,
+  isReservedListName,
+  type ListIssue,
+  listNameSchema,
+} from "./fields.js";
+
+/** Hard ceiling for any tree, recursive or not. */
+export const LIST_MAX_DEPTH = 8;
+/** Entries per list (all levels together). */
+export const LIST_MAX_ITEMS = 500;
+/** Entries one query may return. */
+export const LIST_QUERY_MAX_LIMIT = 50;
+
+export const QUERY_KNOBS = [
+  "page_type",
+  "terms",
+  "terms_mode",
+  "parent",
+  "exclude_current",
+  "order",
+  "limit",
+] as const;
+export type QueryKnob = (typeof QUERY_KNOBS)[number];
+
+export const SYSTEM_SOURCE_NAMES = [
+  "breadcrumbs",
+  "children",
+  "siblings",
+  "page_terms",
+  "term_pages",
+] as const;
+export type SystemSourceName = (typeof SYSTEM_SOURCE_NAMES)[number];
+
+const queryOrderSchema = z.union([
+  z.enum(["published_desc", "published_asc", "title_asc"]),
+  z.string().regex(/^prop_(?:desc|asc):[a-z][a-z0-9_]{0,63}$/),
+]);
+
+/** A query over pages. Resolved at render time; nothing is stored. */
+export const pageQuerySchema = z
+  .object({
+    page_type: z
+      .string()
+      .regex(/^[a-z0-9-]+$/)
+      .optional(),
+    terms: z
+      .array(z.string().regex(/^caelo:term\/[0-9a-f-]{36}\/[0-9a-f-]{36}$/))
+      .max(20)
+      .optional(),
+    terms_mode: z.enum(["any", "all"]).optional(),
+    parent: z
+      .string()
+      .regex(/^caelo:page\/[0-9a-f-]{36}$/)
+      .optional(),
+    exclude_current: z.boolean().optional(),
+    order: queryOrderSchema,
+    limit: z.number().int().min(1).max(LIST_QUERY_MAX_LIMIT),
+  })
+  .strict();
+export type PageQuery = z.infer<typeof pageQuerySchema>;
+
+/** Partial query: defaults on a node, or the knobs an entry overrides. */
+export const pageQueryPartialSchema = pageQuerySchema.partial();
+
+export const sourceDefSchema = z.discriminatedUnion("kind", [
+  z
+    .object({
+      kind: z.literal("query"),
+      /** Which query parts an editor (or the AI) may set per entry/placement. */
+      editable: z.array(z.enum(QUERY_KNOBS)).max(QUERY_KNOBS.length),
+      defaults: pageQueryPartialSchema,
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("system"),
+      // The AI reached for {kind:"system", name:"consent_categories"} in the
+      // PR #1121 e2e run: name the plugin form in the refusal itself.
+      name: z.enum(SYSTEM_SOURCE_NAMES, {
+        error: () =>
+          `system sources are ${SYSTEM_SOURCE_NAMES.join(", ")} — a plugin's list source (consent_categories, language_links, …) is {kind:"plugin", name:"<source>"}, and a module that only iterates it needs no field at all: {{#<source>}}…{{/<source>}}.`,
+      }),
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("plugin"),
+      /** The list-source name an active plugin declared. */
+      name: z.string().regex(/^[a-z][a-z0-9_]{0,63}$/),
+    })
+    .strict(),
+]);
+export type SourceDef = z.infer<typeof sourceDefSchema>;
+
+const childrenSchema = z
+  .object({
+    /** Loop name in templates (`{{#columns}}`). Storage always uses `children`. */
+    name: listNameSchema,
+    allow: z.array(listNameSchema).min(1).max(32),
+    max: z.number().int().min(1).max(LIST_MAX_ITEMS).optional(),
+  })
+  .strict();
+
+export const nodeDefSchema = z
+  .object({
+    label: z.string().min(1).max(128),
+    fields: z.array(fieldDefSchema).max(32),
+    children: childrenSchema.optional(),
+    /** Link field that decides `is_current` / `is_ancestor`. */
+    current_from: listNameSchema.optional(),
+    /** Generated children (`items`) instead of stored ones. */
+    source: sourceDefSchema.optional(),
+    ext: fieldExtSchema.optional(),
+  })
+  .strict();
+export type NodeDef = z.infer<typeof nodeDefSchema>;
+
+export const LIST_TYPE_ROLES = ["navigation", "vocabulary", "content"] as const;
+export type ListTypeRole = (typeof LIST_TYPE_ROLES)[number];
+
+export const listTypeDefSchema = z
+  .object({
+    slug: z.string().regex(/^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/),
+    name: z.string().min(1).max(200),
+    purpose: z.string().min(1).max(1000),
+    role: z.enum(LIST_TYPE_ROLES),
+    root: z
+      .object({
+        allow: z.array(listNameSchema).min(1).max(32),
+        max: z.number().int().min(1).max(LIST_MAX_ITEMS).optional(),
+      })
+      .strict(),
+    nodes: z.record(listNameSchema, nodeDefSchema),
+    max_depth: z.number().int().min(1).max(LIST_MAX_DEPTH).optional(),
+  })
+  .strict();
+export type ListTypeDef = z.infer<typeof listTypeDefSchema>;
+
+/**
+ * Static checks Zod cannot express. Returns every issue found so the AI
+ * fixes a definition in one round instead of one error per call.
+ */
+export function checkListTypeDef(def: ListTypeDef): ListIssue[] {
+  const issues: ListIssue[] = [];
+  const kinds = new Set(Object.keys(def.nodes));
+  if (kinds.size === 0) {
+    issues.push({ path: "nodes", message: "a list type needs at least one node kind." });
+  }
+  const checkAllow = (allow: readonly string[], path: string): void => {
+    for (const k of allow) {
+      if (!kinds.has(k)) {
+        issues.push({
+          path,
+          message: `node kind "${k}" is not defined — add it under nodes or remove it from allow.`,
+        });
+      }
+    }
+  };
+  checkAllow(def.root.allow, "root.allow");
+
+  for (const [kind, node] of Object.entries(def.nodes)) {
+    const at = `nodes.${kind}`;
+    if (isReservedListName(kind)) {
+      issues.push({ path: at, message: `node kind "${kind}" is a reserved name — rename it.` });
+    }
+    const seen = new Set<string>();
+    node.fields.forEach((f, i) => {
+      const fp = `${at}.fields[${i}]`;
+      if (seen.has(f.name)) issues.push({ path: fp, message: `duplicate field name "${f.name}".` });
+      seen.add(f.name);
+      issues.push(...checkFieldDef(f, fp));
+    });
+    if (node.children) {
+      if (isReservedListName(node.children.name)) {
+        issues.push({
+          path: `${at}.children.name`,
+          message: `children name "${node.children.name}" is reserved — pick another loop name.`,
+        });
+      }
+      if (seen.has(node.children.name)) {
+        issues.push({
+          path: `${at}.children.name`,
+          message: `children name "${node.children.name}" collides with a field of the same node.`,
+        });
+      }
+      checkAllow(node.children.allow, `${at}.children.allow`);
+    }
+    if (node.children && node.source) {
+      issues.push({
+        path: at,
+        message: "a node has either stored children or a source, not both — remove one.",
+      });
+    }
+    if (node.current_from !== undefined) {
+      const target = node.fields.find((f) => f.name === node.current_from);
+      if (target?.type !== "link") {
+        issues.push({
+          path: `${at}.current_from`,
+          message: `current_from must name a link field of this node ("${node.current_from}" is not one).`,
+        });
+      }
+    }
+    if (node.source?.kind === "query") {
+      const q = pageQueryPartialSchema.safeParse(node.source.defaults);
+      if (!q.success) {
+        issues.push({ path: `${at}.source.defaults`, message: "query defaults are invalid." });
+      } else if (
+        node.source.defaults.order === undefined &&
+        !node.source.editable.includes("order")
+      ) {
+        issues.push({
+          path: `${at}.source`,
+          message: 'a query source needs a default "order" or "order" in editable.',
+        });
+      } else if (
+        node.source.defaults.limit === undefined &&
+        !node.source.editable.includes("limit")
+      ) {
+        issues.push({
+          path: `${at}.source`,
+          message: 'a query source needs a default "limit" or "limit" in editable.',
+        });
+      }
+    }
+  }
+
+  if (hasRecursion(def) && def.max_depth === undefined) {
+    issues.push({
+      path: "max_depth",
+      message: "this type nests a node kind inside itself — set max_depth (1–8).",
+    });
+  }
+
+  if (def.role === "vocabulary") {
+    const rootKinds = def.root.allow;
+    for (const k of rootKinds) {
+      const node = def.nodes[k];
+      if (!node) continue;
+      const hasText = (n: string): boolean =>
+        node.fields.some((f: FieldDef) => f.name === n && f.type === "text");
+      if (!hasText("name") || !hasText("slug")) {
+        issues.push({
+          path: `nodes.${k}`,
+          message: 'vocabulary entries need a text field "name" and a text field "slug".',
+        });
+      }
+      if (node.source) {
+        issues.push({ path: `nodes.${k}`, message: "vocabulary entries cannot have a source." });
+      }
+    }
+  }
+  return issues;
+}
+
+/** True when some node kind can (transitively) contain itself. */
+export function hasRecursion(def: ListTypeDef): boolean {
+  const edges = new Map<string, readonly string[]>();
+  for (const [k, n] of Object.entries(def.nodes)) edges.set(k, n.children?.allow ?? []);
+  const visiting = new Set<string>();
+  const done = new Set<string>();
+  const visit = (k: string): boolean => {
+    if (visiting.has(k)) return true;
+    if (done.has(k)) return false;
+    visiting.add(k);
+    for (const c of edges.get(k) ?? []) if (visit(c)) return true;
+    visiting.delete(k);
+    done.add(k);
+    return false;
+  };
+  return [...edges.keys()].some(visit);
+}
+
+/**
+ * Effective depth limit of a type: `max_depth` when set, else the
+ * longest non-recursive path (bounded by {@link LIST_MAX_DEPTH}).
+ */
+export function effectiveMaxDepth(def: ListTypeDef): number {
+  if (def.max_depth !== undefined) return def.max_depth;
+  const longest = (k: string, seen: ReadonlySet<string>): number => {
+    if (seen.has(k)) return LIST_MAX_DEPTH;
+    const next = new Set(seen).add(k);
+    const kids = def.nodes[k]?.children?.allow ?? [];
+    return 1 + kids.reduce((m, c) => Math.max(m, longest(c, next)), 0);
+  };
+  return Math.min(
+    LIST_MAX_DEPTH,
+    def.root.allow.reduce((m, k) => Math.max(m, longest(k, new Set())), 0),
+  );
+}

package/src/lists/lists.test.ts

@@ -0,0 +1,328 @@
+// SPDX-License-Identifier: MPL-2.0
+
+import { describe, expect, it } from "bun:test";
+import { formatValueAddress, parseValueAddress } from "./address.js";
+import { DEFAULT_LIST_TYPES } from "./default-types.js";
+import { checkFieldDef, type FieldDef, validateFieldValue } from "./fields.js";
+import {
+  applyListItemPatches,
+  diffListItems,
+  findListItem,
+  type ListItem,
+  ListPatchError,
+  validateListItems,
+} from "./items.js";
+import {
+  checkListTypeDef,
+  effectiveMaxDepth,
+  hasRecursion,
+  type ListTypeDef,
+  listTypeDefSchema,
+  sourceDefSchema,
+} from "./list-type.js";
+import { checkPageTypeDef, pageTypeDefSchema } from "./page-type.js";
+
+const PAGE = "11111111-1111-4111-8111-111111111111";
+const LIST = "22222222-2222-4222-8222-222222222222";
+const ITEM = "33333333-3333-4333-8333-333333333333";
+
+function ids(): () => string {
+  let n = 0;
+  return () => {
+    n += 1;
+    return `00000000-0000-4000-8000-${String(n).padStart(12, "0")}`;
+  };
+}
+
+const MEGA: ListTypeDef = listTypeDefSchema.parse({
+  slug: "main-menu",
+  name: "Main menu",
+  purpose: "Header navigation with mega panels",
+  role: "navigation",
+  root: { allow: ["entry"], max: 8 },
+  nodes: {
+    entry: {
+      label: "Entry",
+      fields: [
+        { name: "label", label: "Label", type: "text", required: true },
+        { name: "link", label: "Link", type: "link" },
+        { name: "panel", label: "Panel", type: "select", options: ["none", "dropdown", "mega"] },
+      ],
+      children: { name: "columns", allow: ["column", "news_feed", "promo"], max: 4 },
+      current_from: "link",
+    },
+    column: {
+      label: "Column",
+      fields: [{ name: "heading", label: "Heading", type: "text" }],
+      children: { name: "links", allow: ["sub_link"], max: 12 },
+    },
+    sub_link: {
+      label: "Sub link",
+      fields: [
+        { name: "label", label: "Label", type: "text", required: true },
+        { name: "link", label: "Link", type: "link", required: true },
+        { name: "icon", label: "Icon", type: "icon" },
+      ],
+      current_from: "link",
+    },
+    news_feed: {
+      label: "Latest posts",
+      fields: [{ name: "heading", label: "Heading", type: "text" }],
+      source: {
+        kind: "query",
+        editable: ["page_type", "terms", "limit"],
+        defaults: { page_type: "news", order: "published_desc", limit: 3 },
+      },
+    },
+    promo: {
+      label: "Teaser",
+      fields: [{ name: "teaser", label: "Teaser", type: "module", accepts: ["promo-card"] }],
+    },
+  },
+});
+
+describe("field values", () => {
+  const text: FieldDef = { name: "label", label: "Label", type: "text", required: true };
+  it("requires required fields and accepts valid values", () => {
+    expect(validateFieldValue(text, undefined, "p")).toHaveLength(1);
+    expect(validateFieldValue(text, "  ", "p")).toHaveLength(1);
+    expect(validateFieldValue(text, "Docs", "p")).toEqual([]);
+  });
+  it("checks every type's shape", () => {
+    const cases: [FieldDef, unknown, boolean][] = [
+      [{ name: "l", label: "L", type: "link" }, { href: "/about" }, true],
+      [{ name: "l", label: "L", type: "link" }, "/about", false],
+      [{ name: "m", label: "M", type: "media" }, `caelo:media/${PAGE}`, true],
+      [{ name: "m", label: "M", type: "media" }, "/x.png", false],
+      [{ name: "s", label: "S", type: "select", options: ["a", "b"] }, "b", true],
+      [{ name: "s", label: "S", type: "select", options: ["a", "b"] }, "c", false],
+      [{ name: "b", label: "B", type: "boolean" }, false, true],
+      [{ name: "n", label: "N", type: "number", min: 1 }, 0, false],
+      [{ name: "d", label: "D", type: "date" }, "2026-10-25", true],
+      [{ name: "d", label: "D", type: "date" }, "25.10.2026", false],
+      [{ name: "i", label: "I", type: "icon" }, "radar", true],
+      [{ name: "t", label: "T", type: "term", list: "tags" }, [`caelo:term/${LIST}/${ITEM}`], true],
+      [
+        { name: "t", label: "T", type: "term", list: "tags" },
+        [`caelo:term/${LIST}/${ITEM}`, `caelo:term/${LIST}/${PAGE}`],
+        false,
+      ],
+    ];
+    for (const [f, v, ok] of cases) {
+      expect(validateFieldValue(f, v, "p").length === 0).toBe(ok);
+    }
+  });
+  it("rejects reserved names and invalid defaults", () => {
+    expect(checkFieldDef({ name: "is_open", label: "x", type: "boolean" }, "f")).toHaveLength(1);
+    expect(checkFieldDef({ name: "depth", label: "x", type: "number" }, "f")).toHaveLength(1);
+    expect(
+      checkFieldDef({ name: "n", label: "x", type: "number", default: "1" }, "f"),
+    ).toHaveLength(1);
+  });
+});
+
+describe("list type definitions", () => {
+  it("accepts the mega menu and every shipped type", () => {
+    expect(checkListTypeDef(MEGA)).toEqual([]);
+    for (const t of DEFAULT_LIST_TYPES)
+      expect(checkListTypeDef(listTypeDefSchema.parse(t))).toEqual([]);
+  });
+  it("requires max_depth for recursive types", () => {
+    const t = { ...DEFAULT_LIST_TYPES[2], max_depth: undefined } as ListTypeDef;
+    expect(hasRecursion(t)).toBe(true);
+    expect(checkListTypeDef(t).map((i) => i.path)).toContain("max_depth");
+  });
+  it("reports unknown node kinds, bad current_from, children+source", () => {
+    const t: ListTypeDef = {
+      ...MEGA,
+      root: { allow: ["entry", "ghost"] },
+      nodes: {
+        ...MEGA.nodes,
+        column: {
+          ...MEGA.nodes.column!,
+          current_from: "heading",
+          source: { kind: "system", name: "breadcrumbs" },
+        },
+      },
+    };
+    const paths = checkListTypeDef(t).map((i) => i.path);
+    expect(paths).toContain("root.allow");
+    expect(paths).toContain("nodes.column.current_from");
+    expect(paths).toContain("nodes.column");
+  });
+  it("requires name+slug on vocabulary entries", () => {
+    const t: ListTypeDef = {
+      slug: "v",
+      name: "V",
+      purpose: "p",
+      role: "vocabulary",
+      root: { allow: ["t"] },
+      nodes: { t: { label: "T", fields: [{ name: "name", label: "N", type: "text" }] } },
+    };
+    expect(checkListTypeDef(t)).toHaveLength(1);
+  });
+  it("computes the effective depth", () => {
+    expect(effectiveMaxDepth(MEGA)).toBe(3);
+    expect(effectiveMaxDepth(listTypeDefSchema.parse(DEFAULT_LIST_TYPES[2]))).toBe(3);
+  });
+});
+
+describe("list items", () => {
+  const items = [
+    {
+      node: "entry",
+      values: { label: "Products", link: { href: `caelo:page/${PAGE}` }, panel: "mega" },
+      children: [
+        {
+          node: "column",
+          values: { heading: "Platform" },
+          children: [
+            { node: "sub_link", values: { label: "Crawler", link: { href: "/crawler" } } },
+          ],
+        },
+        { node: "news_feed", values: { heading: "New" }, query: { limit: 5 } },
+      ],
+    },
+  ];
+
+  it("validates a mega menu and assigns ids", () => {
+    const r = validateListItems(MEGA, items, { newId: ids() });
+    expect(r.issues).toEqual([]);
+    expect(r.items[0]?.id).toBe("00000000-0000-4000-8000-000000000001");
+    expect(r.items[0]?.children?.[0]?.children?.[0]?.values.label).toBe("Crawler");
+  });
+
+  it("reports misplaced nodes, missing fields, unknown values and query knobs", () => {
+    const r = validateListItems(MEGA, [
+      { node: "sub_link", values: { label: "x" } },
+      {
+        node: "entry",
+        values: { label: "y", colour: "red" },
+        children: [{ node: "news_feed", values: {}, query: { order: "title_asc" } }],
+      },
+    ]);
+    const paths = r.issues.map((i) => i.path);
+    expect(paths).toContain("items[0].node");
+    expect(paths).toContain("items[0].values.link");
+    expect(paths).toContain("items[1].values.colour");
+    expect(paths).toContain("items[1].children[0].query.order");
+  });
+
+  // e2e-livedit run 40360756064 — the AI restated the type's defaults.
+  it("drops a non-editable query knob that equals the type default", () => {
+    const r = validateListItems(MEGA, [
+      {
+        node: "entry",
+        values: { label: "y" },
+        children: [{ node: "news_feed", values: {}, query: { limit: 3, order: "published_desc" } }],
+      },
+    ]);
+    expect(r.issues).toEqual([]);
+    expect(r.items[0]?.children?.[0]?.query).toEqual({ limit: 3 });
+  });
+
+  it("enforces depth and per-level max", () => {
+    const menu = listTypeDefSchema.parse(DEFAULT_LIST_TYPES[2]);
+    const deep = {
+      node: "entry",
+      values: { label: "a" },
+      children: [
+        {
+          node: "entry",
+          values: { label: "b" },
+          children: [
+            {
+              node: "entry",
+              values: { label: "c" },
+              children: [{ node: "entry", values: { label: "d" } }],
+            },
+          ],
+        },
+      ],
+    };
+    expect(validateListItems(menu, [deep]).issues.some((i) => i.message.includes("deeper"))).toBe(
+      true,
+    );
+    const many = Array.from({ length: 9 }, (_, i) => ({
+      node: "entry",
+      values: { label: `e${i}` },
+    }));
+    expect(validateListItems(MEGA, many).issues.some((i) => i.message.includes("at most 8"))).toBe(
+      true,
+    );
+  });
+
+  it("patches by id and diffs", () => {
+    const base = validateListItems(MEGA, items, { newId: ids() }).items;
+    const entry = base[0] as ListItem;
+    const column = entry.children?.[0] as ListItem;
+    const next = applyListItemPatches(base, [
+      { op: "update", itemId: entry.id, values: { label: "Platform" } },
+      {
+        op: "add",
+        parentId: column.id,
+        position: 0,
+        item: { id: ITEM, node: "sub_link", values: { label: "API", link: { href: "/api" } } },
+      },
+      { op: "move", itemId: column.id, parentId: entry.id, position: 1 },
+    ]);
+    const validated = validateListItems(MEGA, next).items;
+    expect(findListItem(validated, ITEM)?.values.label).toBe("API");
+    const changes = diffListItems(base, validated);
+    expect(changes).toContainEqual({ kind: "added", itemId: ITEM });
+    expect(changes.find((c) => c.kind === "updated" && c.itemId === entry.id)).toBeDefined();
+    expect(changes).toContainEqual({ kind: "moved", itemId: column.id });
+  });
+
+  it("refuses patches on unknown ids and moves into a child", () => {
+    const base = validateListItems(MEGA, items, { newId: ids() }).items;
+    const entry = base[0] as ListItem;
+    const column = entry.children?.[0] as ListItem;
+    expect(() => applyListItemPatches(base, [{ op: "remove", itemId: ITEM }])).toThrow(
+      ListPatchError,
+    );
+    expect(() =>
+      applyListItemPatches(base, [
+        { op: "move", itemId: entry.id, parentId: column.id, position: 0 },
+      ]),
+    ).toThrow(ListPatchError);
+  });
+});
+
+describe("page types and addresses", () => {
+  it("checks the default template and module properties", () => {
+    const t = pageTypeDefSchema.parse({
+      slug: "news",
+      name: "News",
+      purpose: "Dated announcements",
+      templates: [PAGE],
+      defaultTemplate: LIST,
+      properties: [{ name: "teaser", label: "T", type: "module" }],
+    });
+    expect(checkPageTypeDef(t).map((i) => i.path)).toEqual(["defaultTemplate", "properties[0]"]);
+  });
+  it("round-trips addresses", () => {
+    for (const s of [
+      `list/${LIST}/item/${ITEM}/label`,
+      `instance/${LIST}/features/item/${ITEM}/text`,
+      `page/${PAGE}/props/author`,
+      `list_type/${LIST}/node/entry/label`,
+    ]) {
+      const a = parseValueAddress(s);
+      expect(a).not.toBeNull();
+      expect(formatValueAddress(a!)).toBe(s);
+    }
+    expect(parseValueAddress("pages/x")).toBeNull();
+  });
+});
+
+describe("source definitions", () => {
+  it("a plugin source written as a system source is refused with the plugin form (PR #1121 e2e)", () => {
+    const r = sourceDefSchema.safeParse({ kind: "system", name: "consent_categories" });
+    expect(r.success).toBe(false);
+    expect(r.error?.issues[0]?.message).toContain('{kind:"plugin", name:"<source>"}');
+    expect(sourceDefSchema.safeParse({ kind: "plugin", name: "consent_categories" }).success).toBe(
+      true,
+    );
+  });
+});

package/src/lists/model.ts

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * Epic #1107 part G — the list definitions without the renderer: field
+ * system, list and page type schemas, entries and value addresses. Only
+ * Zod underneath, so the plugin SDK can re-export it into plugin code —
+ * the Deno sandbox bundles the SDK with everything it imports, and the
+ * package root pulls in the template engine and HTML parser.
+ * Exposed as `@caelo-cms/shared/lists-model`.
+ */
+
+export * from "./address.js";
+export * from "./fields.js";
+export * from "./items.js";
+export * from "./list-type.js";
+export * from "./page-type.js";