@lupinum/ginko-content 0.1.0

package/dist/cms-contract/build.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `buildCmsContract` — deterministic normalization of a host's
+ * `content.config.ts` output into the shape `@lupinum/ginko-cms` consumes.
+ *
+ * Per the refactor plan: the CMS used to *infer* labels, types, locales,
+ * routing, and field shape from a content collection's loose config. That
+ * inference produced misclassifications (data collections rendered as
+ * route-backed, singletons treated as flat, fields losing media metadata).
+ *
+ * `buildCmsContract` instead produces a single normalized artifact. Anything
+ * the CMS needs to know is recorded explicitly. The CMS is forbidden from
+ * inferring on its own; it just reads this contract.
+ *
+ * This is a Gate 0 spike: the function is shaped end-to-end so the CMS can
+ * import and call it, but the schema-introspection branches are intentionally
+ * minimal. Gate 1 will fill them in against real fixtures.
+ */
+import type { ContentCollectionConfig } from '../types/config.js';
+import type { CmsContract, CmsSchemaCapabilities } from './types.js';
+/** Stable contract version. Bump when the CMS-facing artifact shape changes. */
+export declare const CMS_CONTRACT_VERSION = "v1";
+export declare class CmsContractSchemaUnsupportedError extends Error {
+    readonly collectionSlug: string;
+    readonly unsupported: CmsSchemaCapabilities['unsupported'];
+    constructor(collectionSlug: string, unsupported: CmsSchemaCapabilities['unsupported']);
+}
+export interface BuildCmsContractOptions {
+    /** Site default locale, e.g. `'en'`. */
+    defaultLocale: string;
+    /** All locale codes the site can serve. */
+    locales: string[];
+    /** Optional include filter — when set, only listed collections are emitted. */
+    include?: string[];
+}
+export interface BuildCmsContractInput {
+    collections: Record<string, ContentCollectionConfig>;
+}
+/**
+ * Build a normalized CMS contract from a host's `content.config.ts` output.
+ *
+ * The function is deterministic: same input yields byte-identical output. The
+ * CMS hashes the result to detect contract changes between deployments.
+ */
+export declare function buildCmsContract(config: BuildCmsContractInput, options: BuildCmsContractOptions): CmsContract;

package/dist/cms-contract/build.js

@@ -0,0 +1,513 @@
+import {
+  getSchemaDef,
+  getObjectShape,
+  getReferenceDescriptor,
+  getSchemaTypeName,
+  unwrapSchema
+} from "../core/references/schema.js";
+import { getContentFieldMetadata } from "../types/fields.js";
+export const CMS_CONTRACT_VERSION = "v1";
+const IMPLICIT_PAGE_FIELDS = /* @__PURE__ */ new Set(["title", "description", "body", "bodyMdc"]);
+const SUPPORTED_TYPENAMES = /* @__PURE__ */ new Set([
+  "ZodObject",
+  "ZodArray",
+  "ZodString",
+  "ZodNumber",
+  "ZodBoolean",
+  "ZodDate",
+  "ZodEnum",
+  "ZodOptional",
+  "ZodNullable",
+  "ZodDefault"
+]);
+const WRAPPER_TYPENAMES = /* @__PURE__ */ new Set(["ZodOptional", "ZodNullable", "ZodDefault"]);
+export class CmsContractSchemaUnsupportedError extends Error {
+  constructor(collectionSlug, unsupported) {
+    super(
+      [
+        `CMS schema for collection "${collectionSlug}" contains unsupported Zod constructs.`,
+        ...unsupported.map((item) => `- ${item.path}: ${item.feature} (${item.reason})`)
+      ].join("\n")
+    );
+    this.collectionSlug = collectionSlug;
+    this.unsupported = unsupported;
+    this.name = "CmsContractSchemaUnsupportedError";
+  }
+}
+export function buildCmsContract(config, options) {
+  const include = options.include ? new Set(options.include) : null;
+  const collections = {};
+  for (const [slug, collection] of Object.entries(config.collections)) {
+    if (include && !include.has(slug)) continue;
+    collections[slug] = buildCollectionContract(slug, collection, options);
+  }
+  return {
+    contractVersion: CMS_CONTRACT_VERSION,
+    defaultLocale: options.defaultLocale,
+    locales: [...options.locales],
+    collections
+  };
+}
+function buildCollectionContract(slug, collection, options) {
+  const cms = collection.cms ?? {};
+  const locales = resolveLocales(collection, options);
+  const defaultLocale = resolveDefaultLocale(collection, options);
+  const isLocalized = locales.length > 1;
+  const routing = buildRouting(slug, collection, cms, options);
+  const fields = buildFields(collection, cms, isLocalized);
+  const schema = buildSchemaArtifactRef(slug, collection);
+  const contract = {
+    slug,
+    label: cms.label ?? deriveLabel(slug),
+    type: cms.type ?? deriveCollectionType(slug, collection),
+    icon: cms.icon ?? null,
+    locales,
+    defaultLocale,
+    routing,
+    fields
+  };
+  if (schema) contract.schema = schema;
+  if (cms.settings !== void 0) contract.settings = cms.settings;
+  return contract;
+}
+function resolveLocales(collection, options) {
+  if (collection.i18n === true) return [...options.locales];
+  if (collection.i18n && Array.isArray(collection.i18n.locales)) {
+    return [...collection.i18n.locales];
+  }
+  return [options.defaultLocale];
+}
+function resolveDefaultLocale(collection, options) {
+  if (collection.i18n && typeof collection.i18n === "object") {
+    return collection.i18n.defaultLocale ?? options.defaultLocale;
+  }
+  return options.defaultLocale;
+}
+function buildRouting(slug, collection, cms, options) {
+  const explicitMode = cms.route?.mode;
+  const localizedRoute = localizedRouteMap(collection.route);
+  const pathPrefix = cms.route?.pathPrefix ?? deriveRoutePathPrefix(slug, collection, options.defaultLocale);
+  const mode = explicitMode ?? (collection.sitemap === false && !pathPrefix ? "none" : "route");
+  const singleton = cms.route?.singleton ?? isSingleRouteSource(collection);
+  const routing = {
+    mode,
+    pathPrefix: mode === "none" ? "" : pathPrefix,
+    slugMode: cms.route?.slugMode ?? (collection.translatedSlugs ? "localized" : "shared"),
+    rootSlug: cms.route?.rootSlug ?? null,
+    singleton
+  };
+  if (mode !== "none" && localizedRoute) {
+    if (routing.singleton) {
+      routing.localizedSingletonPaths = localizedRoute;
+    } else {
+      routing.localizedPathPrefixes = localizedRoute;
+    }
+  }
+  return routing;
+}
+function deriveRoutePathPrefix(slug, collection, defaultLocale) {
+  const route = collection.route;
+  if (!route) return `/${slug}`;
+  if (typeof route === "string") return route;
+  const first = route[defaultLocale] ?? Object.values(route)[0];
+  return first ?? `/${slug}`;
+}
+function localizedRouteMap(route) {
+  if (!route || typeof route !== "object") return null;
+  return { ...route };
+}
+function isSingleRouteSource(collection) {
+  if (!collection.route) return false;
+  const sources = Array.isArray(collection.source) ? collection.source : [collection.source];
+  const routeSources = sources.filter((source) => typeof source === "string");
+  return routeSources.length === 1 && !/[{*?[\]]/.test(routeSources[0] ?? "");
+}
+function deriveCollectionType(slug, collection) {
+  if (collection.cms?.type) return collection.cms.type;
+  if (slug === "docs" || collection.cms?.route?.rootSlug) return "tree";
+  return "flat";
+}
+function deriveLabel(slug) {
+  return slug.split(/[-_]/g).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
+}
+function buildFields(collection, cms, isLocalized) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const field2 of implicitPageFields(collection, isLocalized)) {
+    fields.set(field2.key, field2);
+  }
+  for (const field2 of fieldsFromSchema(collection.schema, isLocalized)) {
+    fields.set(field2.key, field2);
+  }
+  for (const [key, override] of Object.entries(cms.fields ?? {})) {
+    const existing = fields.get(key);
+    fields.set(key, mergeField(existing, key, override, isLocalized));
+  }
+  return [...fields.values()].sort((a, b) => (a.order ?? 0) - (b.order ?? 0)).map((field2, index) => ({ ...field2, order: index }));
+}
+function implicitPageFields(collection, isLocalized) {
+  const fields = [
+    field({ key: "title", type: "text", required: true, localized: isLocalized }),
+    field({ key: "description", type: "textarea", localized: isLocalized })
+  ];
+  if (isMarkdownCollection(collection)) {
+    fields.push(field({ key: "bodyMdc", type: "richtext", localized: isLocalized }));
+  }
+  return fields;
+}
+function isMarkdownCollection(collection) {
+  if (collection.type === "page" || collection.route) return true;
+  const source = collection.source;
+  if (!source) return false;
+  const sources = Array.isArray(source) ? source : [source];
+  return sources.some((s) => typeof s === "string" && /\.(md|mdc|markdown)$/.test(s));
+}
+function fieldsFromSchema(schema, isLocalized) {
+  if (!schema) return [];
+  const shape = getObjectShape(schema);
+  if (!shape) return [];
+  const out = [];
+  for (const [key, child] of Object.entries(shape)) {
+    if (IMPLICIT_PAGE_FIELDS.has(key)) continue;
+    out.push(fieldFromSchema(key, child, isLocalized));
+  }
+  return out;
+}
+function fieldFromSchema(key, schema, isLocalized) {
+  const unwrapped = unwrapSchema(schema);
+  const required = !isOptional(schema);
+  const metadata = getContentFieldMetadata(schema) ?? getContentFieldMetadata(unwrapped);
+  if (metadata) {
+    return fieldFromMetadata(key, metadata, unwrapped, isLocalized, required);
+  }
+  const reference = getReferenceDescriptor(unwrapped);
+  if (reference) {
+    return field({
+      key,
+      type: "relation",
+      required,
+      localized: false,
+      relation: { collectionId: reference.collection ?? "", multiple: false }
+    });
+  }
+  const typeName = getSchemaTypeName(unwrapped);
+  if (typeName === "ZodArray") {
+    const element = getArrayElement(unwrapped);
+    const elementReference = getReferenceDescriptor(element);
+    if (elementReference) {
+      return field({
+        key,
+        type: "relations",
+        required,
+        localized: false,
+        relation: { collectionId: elementReference.collection ?? "", multiple: true }
+      });
+    }
+    const objectFields = fieldsFromArrayElement(element);
+    if (!objectFields) {
+      return field({
+        key,
+        type: "json",
+        required,
+        localized: isLocalized
+      });
+    }
+    return field({
+      key,
+      type: "array",
+      required,
+      localized: isLocalized,
+      fields: objectFields
+    });
+  }
+  if (typeName === "ZodObject") {
+    return field({
+      key,
+      type: "object",
+      required,
+      localized: isLocalized,
+      fields: fieldsFromObjectSchema(unwrapped, false)
+    });
+  }
+  if (typeName === "ZodString")
+    return field({ key, type: "text", required, localized: isLocalized });
+  if (typeName === "ZodNumber") return field({ key, type: "number", required, localized: false });
+  if (typeName === "ZodBoolean") return field({ key, type: "toggle", required, localized: false });
+  if (typeName === "ZodDate") return field({ key, type: "date", required, localized: false });
+  return field({ key, type: "json", required, localized: isLocalized });
+}
+function getArrayElement(schema) {
+  const def = getSchemaDef(schema);
+  return def?.element ?? def?.type ?? null;
+}
+function fieldsFromObjectSchema(schema, isLocalized) {
+  return Object.entries(getObjectShape(unwrapSchema(schema))).sort(([left], [right]) => left.localeCompare(right)).map(([key, child], index) => ({
+    ...fieldFromSchema(key, child, isLocalized),
+    order: index
+  }));
+}
+function fieldFromMetadata(key, metadata, schema, isLocalized, required) {
+  const localized = metadata.localized ?? isLocalized;
+  const result = field({
+    key,
+    type: metadataToContractType(metadata),
+    required: metadata.required ?? required,
+    localized,
+    label: metadata.label ?? null,
+    description: metadata.description ?? null,
+    options: metadata.options ?? null,
+    slugFrom: metadata.slugFrom ?? null
+  });
+  if (metadata.image) {
+    result.media = {
+      ...metadata.image.accept ? { accept: metadata.image.accept } : {},
+      aspectRatio: metadata.image.aspectRatio ?? null
+    };
+  }
+  if (metadata.asset) {
+    result.media = {
+      ...metadata.asset.accept ? { accept: metadata.asset.accept } : {},
+      aspectRatio: null
+    };
+  }
+  if (metadata.relation) {
+    result.relation = metadata.relation;
+  }
+  if (result.type === "object") {
+    result.fields = fieldsFromObjectSchema(schema, false);
+  }
+  if (result.type === "array") {
+    const element = getArrayElement(unwrapSchema(schema));
+    const objectFields = fieldsFromArrayElement(element);
+    if (!objectFields) {
+      result.type = "json";
+      result.fields = null;
+    } else {
+      result.fields = objectFields;
+    }
+  }
+  return result;
+}
+function fieldsFromArrayElement(element) {
+  return element && getSchemaTypeName(unwrapSchema(element)) === "ZodObject" ? fieldsFromObjectSchema(element, false) : null;
+}
+function metadataToContractType(metadata) {
+  switch (metadata.type) {
+    case "boolean":
+      return "toggle";
+    case "asset":
+      return "file";
+    default:
+      return metadata.type;
+  }
+}
+function isOptional(schema) {
+  const typeName = getSchemaTypeName(schema);
+  return typeName === "ZodOptional" || typeName === "ZodDefault" || typeName === "ZodNullable";
+}
+function mergeField(existing, key, override, isLocalized) {
+  const base = existing ?? field({ key, type: override.type ?? "text", localized: isLocalized });
+  return {
+    ...base,
+    ...override.type !== void 0 ? { type: override.type } : {},
+    ...override.label !== void 0 ? { label: override.label } : {},
+    ...override.description !== void 0 ? { description: override.description } : {},
+    ...override.required !== void 0 ? { required: override.required } : {},
+    ...override.localized !== void 0 ? { localized: override.localized } : {},
+    ...override.hidden !== void 0 ? { hidden: override.hidden } : {},
+    ...override.searchable !== void 0 ? { searchable: override.searchable } : {},
+    ...override.sortable !== void 0 ? { sortable: override.sortable } : {},
+    ...override.order !== void 0 ? { order: override.order } : {},
+    ...override.width !== void 0 ? { width: override.width } : {},
+    ...override.defaultValue !== void 0 ? { defaultValue: override.defaultValue } : {},
+    ...override.validation !== void 0 ? { validation: override.validation } : {},
+    ...override.condition !== void 0 ? { condition: override.condition } : {},
+    ...override.options !== void 0 ? { options: override.options } : {},
+    ...override.relation !== void 0 ? { relation: override.relation } : {},
+    ...override.min !== void 0 ? { min: override.min } : {},
+    ...override.max !== void 0 ? { max: override.max } : {},
+    ...override.step !== void 0 ? { step: override.step } : {},
+    ...override.slugFrom !== void 0 ? { slugFrom: override.slugFrom } : {},
+    ...override.language !== void 0 ? { language: override.language } : {}
+  };
+}
+function field(input) {
+  return {
+    key: input.key,
+    type: input.type,
+    label: input.label ?? null,
+    description: input.description ?? null,
+    required: input.required ?? false,
+    localized: input.localized ?? false,
+    hidden: input.hidden ?? false,
+    searchable: input.searchable ?? false,
+    sortable: input.sortable ?? false,
+    order: input.order ?? 0,
+    width: input.width ?? "full",
+    defaultValue: input.defaultValue,
+    options: input.options ?? null,
+    relation: input.relation ?? null,
+    media: input.media ?? null,
+    fields: input.fields ?? null,
+    validation: input.validation ?? null,
+    condition: input.condition ?? null,
+    min: input.min ?? null,
+    max: input.max ?? null,
+    step: input.step ?? null,
+    slugFrom: input.slugFrom ?? null,
+    language: input.language ?? null
+  };
+}
+function stableJson(value) {
+  if (value === void 0) return "null";
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableJson(entryValue)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function buildSchemaArtifactRef(slug, collection) {
+  const schema = collection.schema;
+  if (!schema) return void 0;
+  const capabilities = inspectSchemaCapabilities(schema);
+  if (capabilities.unsupported.length > 0) {
+    throw new CmsContractSchemaUnsupportedError(slug, capabilities.unsupported);
+  }
+  const artifact = buildSchemaValidationArtifact(schema);
+  const artifactBytes = stableJson(artifact);
+  return {
+    artifactId: `cms-schema:${slug}:${CMS_CONTRACT_VERSION}`,
+    checksum: checksumArtifactBytes(artifactBytes),
+    capabilities,
+    artifact: artifactBytes
+  };
+}
+function buildSchemaValidationArtifact(schema) {
+  return {
+    version: CMS_CONTRACT_VERSION,
+    root: schemaNode(schema)
+  };
+}
+function schemaNode(schema) {
+  const typeName = getSchemaTypeName(schema);
+  if (typeName === "ZodOptional") {
+    return { kind: "optional", inner: schemaNode(getSchemaDef(schema)?.innerType) };
+  }
+  if (typeName === "ZodNullable") {
+    return { kind: "nullable", inner: schemaNode(getSchemaDef(schema)?.innerType) };
+  }
+  if (typeName === "ZodDefault") {
+    return {
+      kind: "default",
+      inner: schemaNode(getSchemaDef(schema)?.innerType),
+      value: getSchemaDef(schema)?.defaultValue
+    };
+  }
+  if (typeName === "ZodObject") {
+    const shape = getObjectShape(schema);
+    return {
+      kind: "object",
+      required: Object.entries(shape).filter(([, child]) => !isOptional(child)).map(([key]) => key).sort((left, right) => left.localeCompare(right)),
+      shape: Object.fromEntries(
+        Object.entries(shape).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, schemaNode(child)])
+      )
+    };
+  }
+  if (typeName === "ZodArray") {
+    return { kind: "array", element: schemaNode(getSchemaDef(schema)?.element) };
+  }
+  if (typeName === "ZodString") {
+    return { kind: "string", checks: stringChecks(schema) };
+  }
+  if (typeName === "ZodNumber") return { kind: "number" };
+  if (typeName === "ZodBoolean") return { kind: "boolean" };
+  if (typeName === "ZodDate") return { kind: "date" };
+  if (typeName === "ZodEnum") {
+    const entries = getSchemaDef(schema)?.entries;
+    return {
+      kind: "enum",
+      values: Object.values(entries ?? {}).filter((value) => typeof value === "string").sort((left, right) => left.localeCompare(right))
+    };
+  }
+  throw new Error(`Unsupported schema node ${typeName ?? "<unknown>"}.`);
+}
+function stringChecks(schema) {
+  const checks = [];
+  const value = schema;
+  if (typeof value.minLength === "number") checks.push({ kind: "min", value: value.minLength });
+  if (typeof value.maxLength === "number") checks.push({ kind: "max", value: value.maxLength });
+  if (value.format === "email") checks.push({ kind: "email" });
+  if (value.format === "url") checks.push({ kind: "url" });
+  return checks.length > 0 ? checks : void 0;
+}
+function checksumArtifactBytes(source) {
+  let hash = 2166136261;
+  for (let index = 0; index < source.length; index += 1) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function inspectSchemaCapabilities(schema) {
+  const supports = /* @__PURE__ */ new Set();
+  const unsupported = [];
+  walkSchema(schema, "", supports, unsupported);
+  return {
+    supports: [...supports],
+    unsupported
+  };
+}
+function walkSchema(schema, path, supports, unsupported) {
+  const typeName = getSchemaTypeName(schema);
+  if (!typeName) return;
+  if (!SUPPORTED_TYPENAMES.has(typeName)) {
+    unsupported.push({
+      feature: typeName,
+      path: path || "<root>",
+      reason: `${typeName} is not yet supported by the validation artifact pipeline.`
+    });
+    return;
+  }
+  collectUnsupportedChecks(schema, path, unsupported);
+  if (typeName === "ZodOptional") supports.add("optional");
+  if (typeName === "ZodNullable") supports.add("nullable");
+  if (typeName === "ZodDefault") supports.add("default");
+  if (WRAPPER_TYPENAMES.has(typeName)) {
+    const inner = getSchemaDef(schema)?.innerType;
+    if (inner) walkSchema(inner, path, supports, unsupported);
+    return;
+  }
+  if (typeName === "ZodObject") {
+    supports.add("object");
+    const shape = getObjectShape(schema);
+    for (const [key, child] of Object.entries(shape)) {
+      walkSchema(child, path ? `${path}.${key}` : key, supports, unsupported);
+    }
+  }
+  if (typeName === "ZodArray") {
+    supports.add("array");
+    const element = getSchemaDef(schema)?.element;
+    if (element) walkSchema(element, `${path || "<root>"}[]`, supports, unsupported);
+  }
+  if (typeName === "ZodString") {
+    supports.add("string");
+    if (getReferenceDescriptor(schema)) supports.add("reference");
+  }
+  if (typeName === "ZodNumber") supports.add("number");
+  if (typeName === "ZodBoolean") supports.add("boolean");
+  if (typeName === "ZodDate") supports.add("date");
+  if (typeName === "ZodEnum") supports.add("enum");
+}
+function collectUnsupportedChecks(schema, path, unsupported) {
+  const checks = getSchemaDef(schema)?.checks;
+  if (!Array.isArray(checks)) return;
+  for (const check of checks) {
+    const def = check?._zod?.def ?? check?.def;
+    if (!def || def.check !== "custom" && def.type !== "custom") continue;
+    const isAsync = def.fn?.constructor?.name === "AsyncFunction";
+    unsupported.push({
+      feature: isAsync ? "ZodAsyncRefinement" : "ZodRefinement",
+      path: path || "<root>",
+      reason: "Custom Zod refinements are not supported by the validation artifact pipeline."
+    });
+  }
+}

package/dist/cms-contract/index

@@ -0,0 +1 @@
+export * from './index.js'

package/dist/cms-contract/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @lupinum/ginko-content/cms-contract
+ *
+ * Pure, runtime-safe surface that ginko-cms consumes. This subpath contains
+ * NO Node, Nuxt, h3, nitropack, filesystem, or @nuxt/kit dependencies. Every
+ * module re-exported from here MUST be importable from a V8 isolate (Convex
+ * component, Cloudflare Workers, browser).
+ *
+ * The CMS uses this surface to:
+ *  - normalize a host's `content.config.ts` into a `CmsContract` artifact
+ *    (`buildCmsContract`),
+ *  - introspect Zod schemas without re-implementing the walker
+ *    (`unwrapSchema`, `getObjectShape`, `getReferenceDescriptor`, ...),
+ *  - generate paths consistently with how the filesystem provider does
+ *    (`generatePath`, `generateCanonicalKey`, `slugifyUrlSegment`),
+ *  - parse MDC into the same AST the filesystem provider uses (`parseMdcBody`).
+ *
+ * If a future change introduces a Node/Nuxt dependency anywhere in this
+ * tree, the CMS Convex build will break loudly. That's intentional.
+ */
+export { CMS_CONTRACT_VERSION, CmsContractSchemaUnsupportedError, buildCmsContract, type BuildCmsContractInput, type BuildCmsContractOptions, } from './build.js';
+export type { CmsCollectionContract, CmsCollectionRouting, CmsContract, CmsFieldContract, CmsSchemaArtifactRef, CmsSchemaCapabilities, ContentCmsCollectionConfig, ContentCmsFieldConfig, ContentCmsFieldType, ContentCmsRelationConfig, ContentCollectionConfig, ContentCollectionI18nConfig, } from './types.js';
+export { describeId, generatePath, generateCanonicalKey, generateTitle, isDraftPath, isPartialPath, longestMountForPath, mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale, refineUrlPart, routeRemainder, routeToContentPathCandidates, slugifyUrlSegment, stripLocalePrefix, } from './path.js';
+export { CONTENT_FIELD_METADATA_KEY, CONTENT_REFERENCE_PREFIX, collectTopLevelReferenceFields, getContentFieldMetadata, getObjectShape, getReferenceDescriptor, getSchemaDef, getSchemaTypeName, unwrapSchema, type ContentFieldMetadata, type ContentFieldSchema, } from './schema.js';
+export { parseMdcBody, type ParseMdcBodyOptions, type ParseMdcBodyResult, } from './mdc.js';

package/dist/cms-contract/index.js

@@ -0,0 +1,37 @@
+export {
+  CMS_CONTRACT_VERSION,
+  CmsContractSchemaUnsupportedError,
+  buildCmsContract
+} from "./build.js";
+export {
+  describeId,
+  generatePath,
+  generateCanonicalKey,
+  generateTitle,
+  isDraftPath,
+  isPartialPath,
+  longestMountForPath,
+  mountContentPath,
+  normalizeContentPath,
+  normalizeRouteMounts,
+  prefixPathWithLocale,
+  refineUrlPart,
+  routeRemainder,
+  routeToContentPathCandidates,
+  slugifyUrlSegment,
+  stripLocalePrefix
+} from "./path.js";
+export {
+  CONTENT_FIELD_METADATA_KEY,
+  CONTENT_REFERENCE_PREFIX,
+  collectTopLevelReferenceFields,
+  getContentFieldMetadata,
+  getObjectShape,
+  getReferenceDescriptor,
+  getSchemaDef,
+  getSchemaTypeName,
+  unwrapSchema
+} from "./schema.js";
+export {
+  parseMdcBody
+} from "./mdc.js";

package/dist/cms-contract/mdc

@@ -0,0 +1 @@
+export * from './mdc.js'

package/dist/cms-contract/mdc.d.ts

@@ -0,0 +1,32 @@
+/**
+ * parseMdcBody - single canonical MDC parser entry point for the CMS.
+ *
+ * The CMS used to fake a parsed MDC body at read-time by wrapping the raw
+ * markdown string in a paragraph element and regexing headings. That broke
+ * MDC components, links, tables, and any non-trivial markdown.
+ *
+ * Per Gate 0: parse once at publish time using ginko-content's real parser,
+ * store the AST on `publicEntries`, and have the public provider return the
+ * stored AST verbatim. The CMS imports this function from the pure subpath.
+ */
+import type { MarkdownRoot, Toc } from '../types/content.js';
+export interface ParseMdcBodyOptions {
+    /** Maximum heading depth captured into `toc`. Default 3. */
+    tocDepth?: number;
+}
+export interface ParseMdcBodyResult {
+    /** Normalized MDC AST root. The public provider serves this verbatim. */
+    body: MarkdownRoot;
+    /** Table-of-contents extracted from headings in the parsed AST (NOT regex). */
+    toc: Toc | undefined;
+    /** Plain text rendering of the body, for search indexing. */
+    searchText: string;
+}
+/**
+ * Parse a raw MDC string into a normalized AST + TOC + searchable plaintext.
+ *
+ * The function is async because comark's parser is async (frontmatter
+ * extraction, plugin pipeline). It is safe to call from a Convex mutation
+ * handler — the V8 isolate supports async/await.
+ */
+export declare function parseMdcBody(raw: string, options?: ParseMdcBodyOptions): Promise<ParseMdcBodyResult>;