@lupinum/ginko-content 1.0.0-beta.2 → 1.0.0-beta.3

package/README.md

@@ -15,7 +15,7 @@
 </p>
 
 > [!WARNING]
-> Version `1.0.0-beta.2` is a prerelease. Install it from npm's `next`
+> Version `1.0.0-beta.3` is a prerelease. Install it from npm's `next`
 > channel. The stable `0.3` line remains on `latest`.
 
 ## Why use this package?
@@ -40,13 +40,13 @@ output.
 Use the Nuxt CLI:
 
 ```bash
-npx nuxi module add @lupinum/ginko-content@1.0.0-beta.2
+npx nuxi module add @lupinum/ginko-content@1.0.0-beta.3
 ```
 
 Or install and register the module by hand:
 
 ```bash
-pnpm add @lupinum/ginko-content@1.0.0-beta.2
+pnpm add @lupinum/ginko-content@1.0.0-beta.3
 ```
 
 ```ts

package/dist/cms-contract/build.js

@@ -1,5 +1,8 @@
 import { getObjectShape, getReferenceDescriptor, getSchemaDef, getSchemaTypeName, unwrapSchema } from "../core/references/schema.js";
-import { getContentFieldMetadata } from "../types/fields.js";
+import {
+  CONTENT_MANAGED_MEDIA_TYPES,
+  getContentFieldMetadata
+} from "../types/fields.js";
 import { canonicalJsonBytes } from "./hash.js";
 import {
   canonicalizePortableComponentName,
@@ -105,7 +108,7 @@ function fieldFromSchema(key, schema, localized) {
   return field({ key, type: typeName === "ZodString" ? "text" : "json", required, localized, default: defaultFromSchema(schema, key), validation: validationFromSchema(schema) });
 }
 function fieldFromMetadata(key, metadata, sourceSchema, schema, localized, required) {
-  const type = metadata.type === "boolean" ? "toggle" : metadata.type === "asset" ? "file" : metadata.type;
+  const type = metadata.type === "boolean" ? "toggle" : metadata.type;
   const nested = type === "object" ? nestedFields(schema) : type === "array" && getSchemaTypeName(unwrapSchema(getSchemaDef(schema)?.element)) === "ZodObject" ? nestedFields(getSchemaDef(schema)?.element) : null;
   return field({
     key,
@@ -115,7 +118,7 @@ function fieldFromMetadata(key, metadata, sourceSchema, schema, localized, requi
     default: defaultFromSchema(sourceSchema, key),
     options: metadata.options ?? null,
     relation: metadata.relation ? { collection: metadata.relation.collectionId, multiple: metadata.relation.multiple ?? type === "relations" } : null,
-    media: metadata.image || metadata.asset ? { mediaTypes: portableMediaTypes(metadata.image?.accept ?? metadata.asset?.accept), aspectRatio: metadata.image?.aspectRatio ?? null } : null,
+    media: metadata.image ? { mediaTypes: portableMediaTypes(metadata.image.accept), aspectRatio: metadata.image.aspectRatio ?? null } : null,
     fields: nested,
     validation: validationFromSchema(sourceSchema, type),
     slugFrom: metadata.slugFrom ?? null
@@ -296,7 +299,7 @@ function validateFieldLevel(collection, fields) {
     if (candidate.relation && (!candidate.relation.collection || candidate.relation.multiple !== (candidate.type === "relations"))) {
       throw new Error(`Field "${candidate.key}" has invalid relation cardinality or target.`);
     }
-    if (candidate.media && !["image", "images", "file"].includes(candidate.type)) throw new Error(`Field "${candidate.key}" has media policy for type "${candidate.type}".`);
+    if (candidate.media && !["image", "images"].includes(candidate.type)) throw new Error(`Field "${candidate.key}" has media policy for type "${candidate.type}".`);
     if (candidate.fields && !["object", "array", "blocks"].includes(candidate.type)) throw new Error(`Field "${candidate.key}" has nested fields for type "${candidate.type}".`);
     if (candidate.options && !["select", "multiselect", "radio"].includes(candidate.type)) throw new Error(`Field "${candidate.key}" has options for type "${candidate.type}".`);
     if ((candidate.min !== null || candidate.max !== null || candidate.step !== null) && !["number", "range"].includes(candidate.type)) {
@@ -374,8 +377,16 @@ function dataFormat(collection) {
   return formats[0] ?? "yaml";
 }
 function portableMediaTypes(values) {
-  const allowed = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
-  return unique(values ?? []).filter((value) => allowed.has(value));
+  if (!values) return [...CONTENT_MANAGED_MEDIA_TYPES];
+  const allowed = new Set(CONTENT_MANAGED_MEDIA_TYPES);
+  const normalized = unique(values);
+  const unsupported = normalized.filter((value) => !allowed.has(value));
+  if (unsupported.length > 0) {
+    throw new Error(
+      `Managed asset media types are limited to ${CONTENT_MANAGED_MEDIA_TYPES.join(", ")}; unsupported: ${unsupported.join(", ")}.`
+    );
+  }
+  return normalized;
 }
 function normalizeComponentPolicy(policy) {
   const components = {};

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

@@ -7,8 +7,9 @@
  * or browser.
  *
  * Consumers use this surface to:
- *  - normalize a host's `content.config.ts` into the one portable
- *    `ResolvedContentContractV1` artifact (`buildResolvedContentContract`),
+ *  - build a framework-free `ResolvedContentContractV1` from already resolved
+ *    inputs (`buildResolvedContentContract`); Nuxt applications consume the
+ *    generated artifact through the separate Node subpath,
  *  - produce RFC 8785 canonical JSON and incremental SHA-256 hashes without
  *    relying on Node or Web Crypto,
  *  - introspect Zod schemas without re-implementing the walker
@@ -23,11 +24,11 @@
  */
 export { RESOLVED_CONTENT_CONTRACT_VERSION, buildResolvedContentContract, type BuildResolvedContentContractInput, type BuildResolvedContentContractOptions, } from './build.js';
 export type { PortableComponentPolicyV1, PortableMediaType, ResolvedContentCollectionV1, ResolvedContentContractV1, ResolvedContentFieldTypeV1, ResolvedContentFieldV1, ResolvedContentValidationV1, ContentCmsCollectionConfig, ContentCmsFieldConfig, ContentCmsFieldType, ContentCmsRelationConfig, ContentCollectionConfig, ContentCollectionI18nConfig, } from './types.js';
-export { describeId, generatePath, generateCanonicalKey, generateTitle, isDraftPath, isPartialPath, mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale, refineUrlPart, routeRemainder, routeToContentPathCandidates, slugifyUrlSegment, stripLocalePrefix, } from './path.js';
+export { describeId, generatePath, generateCanonicalKey, generateTitle, isDraftPath, isPartialPath, mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale, refineUrlPart, routeRemainder, slugifyUrlSegment, stripLocalePrefix, } from './path.js';
 export { CONTENT_FIELD_METADATA_KEY, CONTENT_REFERENCE_METADATA_KEY, collectTopLevelReferenceFields, getContentFieldMetadata, getObjectShape, getReferenceDescriptor, getSchemaDef, getSchemaTypeName, unwrapSchema, type ContentFieldMetadata, type ContentFieldSchema, } from './schema.js';
 export { parseMdcBody, type ParseMdcBodyOptions, type ParseMdcBodyResult, } from './mdc.js';
 export { assertPublicMarkdownAst, isSafePublicMarkdownUrl, PublicMarkdownValidationError, validatePublicMarkdownAst, type PublicMarkdownIssue, type PublicMarkdownIssueCode, type PublicMarkdownValidationResult, } from './render-policy.js';
 export { verifyPublicImageBytes, type VerifiedPublicImage, } from './asset-bytes.js';
 export { canonicalJsonBytes, hashCanonicalJson, sha256Hex, IncrementalSha256, type JsonPrimitive, type JsonValue, } from './hash.js';
 export { assertResolvedContentContract } from './validate.js';
-export { assertCmsRequestedFacts, cmsPublicEntryWireSchema, parseCmsListWireResult, parseCmsNavWireResult, parseCmsPageWireResult, parseCmsRoutesWireResult, parseCmsSearchWireResult, parseCmsSiteDataWireResult, parseCmsSurroundWireResult, type CmsPublicEntryWire, } from './provider-wire.js';
+export { CMS_PROVIDER_WIRE_PROTOCOL, assertCmsRequestedFacts, cmsPublicEntryWireSchema, createCmsProviderWireEnvelope, parseCmsListWireResult, parseCmsNavWireResult, parseCmsPageWireResult, parseCmsRoutesWireResult, parseCmsSearchWireResult, parseCmsSiteDataWireResult, parseCmsSurroundWireResult, type CmsPublicEntryWire, type CmsProviderWireEnvelope, } from './provider-wire.js';

package/dist/cms-contract/index.js

@@ -15,7 +15,6 @@ export {
   prefixPathWithLocale,
   refineUrlPart,
   routeRemainder,
-  routeToContentPathCandidates,
   slugifyUrlSegment,
   stripLocalePrefix
 } from "./path.js";
@@ -50,8 +49,10 @@ export {
 } from "./hash.js";
 export { assertResolvedContentContract } from "./validate.js";
 export {
+  CMS_PROVIDER_WIRE_PROTOCOL,
   assertCmsRequestedFacts,
   cmsPublicEntryWireSchema,
+  createCmsProviderWireEnvelope,
   parseCmsListWireResult,
   parseCmsNavWireResult,
   parseCmsPageWireResult,

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

@@ -6,5 +6,5 @@
  *
  * All re-exports MUST be runtime-pure (no Node, no Nuxt, no h3). They are.
  */
-export { describeId, generatePath, generateCanonicalKey, generateTitle, isDraftPath, isPartialPath, normalizeContentPath, normalizeRouteMounts, routeRemainder, mountContentPath, prefixPathWithLocale, stripLocalePrefix, refineUrlPart, routeToContentPathCandidates, } from '../core/content/path.js';
+export { describeId, generatePath, generateCanonicalKey, generateTitle, isDraftPath, isPartialPath, normalizeContentPath, normalizeRouteMounts, routeRemainder, mountContentPath, prefixPathWithLocale, stripLocalePrefix, refineUrlPart, } from '../core/content/path.js';
 export { slugifyUrlSegment } from '../core/content/slug.js';

package/dist/cms-contract/path.js

@@ -11,7 +11,6 @@ export {
   mountContentPath,
   prefixPathWithLocale,
   stripLocalePrefix,
-  refineUrlPart,
-  routeToContentPathCandidates
+  refineUrlPart
 } from "../core/content/path.js";
 export { slugifyUrlSegment } from "../core/content/slug.js";

package/dist/cms-contract/provider-wire.d.ts

@@ -1,4 +1,12 @@
 import { z } from 'zod';
+/** Version shared by separately deployed CMS producers and Ginko Content consumers. */
+export declare const CMS_PROVIDER_WIRE_PROTOCOL: "ginko-content-cms/v1";
+export type CmsProviderWireEnvelope<T> = {
+    protocol: typeof CMS_PROVIDER_WIRE_PROTOCOL;
+    result: T;
+};
+/** Wrap a CMS result at the deployment boundary without exposing backend details. */
+export declare const createCmsProviderWireEnvelope: <T>(result: T) => CmsProviderWireEnvelope<T>;
 export declare const cmsPublicEntryWireSchema: z.ZodPipe<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodObject<{
     id: z.ZodString;
     collection: z.ZodString;

package/dist/cms-contract/provider-wire.js

@@ -10,6 +10,11 @@ const wireLimits = {
   totalStringBytes: 8 * 1024 * 1024
 };
 const encoder = new TextEncoder();
+export const CMS_PROVIDER_WIRE_PROTOCOL = "ginko-content-cms/v1";
+export const createCmsProviderWireEnvelope = (result) => ({
+  protocol: CMS_PROVIDER_WIRE_PROTOCOL,
+  result
+});
 const wireLimitError = (reason) => new TypeError(`CMS wire value exceeds its bounded ${reason} limit.`);
 function assertBoundedWireValue(root) {
   const stack = [{ value: root, depth: 0 }];
@@ -256,9 +261,13 @@ const parse = (schema, operation, value) => {
     const message = error instanceof Error ? error.message : "CMS wire value is not bounded.";
     throw new TypeError(`Invalid CMS ${operation} wire result at result: ${message}`);
   }
-  const result = schema.safeParse(value);
-  if (result.success) return result.data;
-  const issue = result.error.issues[0];
+  const envelopeSchema = z.object({
+    protocol: z.literal(CMS_PROVIDER_WIRE_PROTOCOL),
+    result: schema
+  }).strict();
+  const parsed = envelopeSchema.safeParse(value);
+  if (parsed.success) return parsed.data.result;
+  const issue = parsed.error.issues[0];
   const path = issue?.path.length ? issue.path.join(".") : "result";
   throw new TypeError(`Invalid CMS ${operation} wire result at ${path}: ${issue?.message || "invalid value"}`);
 };

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

@@ -1,9 +1,10 @@
 import type { ContentCmsCollectionConfig, ContentCmsFieldConfig, ContentCmsFieldType, ContentCmsRelationConfig, ContentCollectionConfig, ContentCollectionI18nConfig } from '../types/config.js';
+import type { ContentManagedMediaType } from '../types/fields.js';
 import type { PortableComponentPolicyV1 } from '../types/component-policy.js';
 import type { JsonValue } from './hash.js';
 export type { ContentCmsCollectionConfig, ContentCmsFieldConfig, ContentCmsFieldType, ContentCmsRelationConfig, ContentCollectionConfig, ContentCollectionI18nConfig, PortableComponentPolicyV1, };
-export type PortableMediaType = 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
-export type ResolvedContentFieldTypeV1 = 'text' | 'textarea' | 'richtext' | 'slug' | 'email' | 'url' | 'number' | 'range' | 'select' | 'multiselect' | 'radio' | 'checkbox' | 'toggle' | 'date' | 'datetime' | 'time' | 'json' | 'object' | 'array' | 'blocks' | 'relation' | 'relations' | 'image' | 'images' | 'file' | 'icon' | 'code' | 'color';
+export type PortableMediaType = ContentManagedMediaType;
+export type ResolvedContentFieldTypeV1 = 'text' | 'textarea' | 'richtext' | 'slug' | 'email' | 'url' | 'number' | 'range' | 'select' | 'multiselect' | 'radio' | 'checkbox' | 'toggle' | 'date' | 'datetime' | 'time' | 'json' | 'object' | 'array' | 'blocks' | 'relation' | 'relations' | 'image' | 'images' | 'icon' | 'code' | 'color';
 export type ResolvedContentValidationV1 = {
     kind: 'string';
     minLength: number | null;

package/dist/cms-contract/validate.js

@@ -29,7 +29,6 @@ const fieldTypes = /* @__PURE__ */ new Set([
   "relations",
   "image",
   "images",
-  "file",
   "icon",
   "code",
   "color"
@@ -159,7 +158,7 @@ function field(value, path) {
 }
 function validateFieldPolicy(input, path) {
   if (input.relation && (!["relation", "relations"].includes(input.type) || input.relation.multiple !== (input.type === "relations"))) throw new Error(`${path} has invalid relation policy.`);
-  if (input.media && !["image", "images", "file"].includes(input.type)) throw new Error(`${path} has invalid media policy.`);
+  if (input.media && !["image", "images"].includes(input.type)) throw new Error(`${path} has invalid media policy.`);
   if (input.fields && !["object", "array", "blocks"].includes(input.type)) throw new Error(`${path} has invalid nested field policy.`);
   if (input.options && !["select", "multiselect", "radio"].includes(input.type)) throw new Error(`${path} has invalid options policy.`);
   if ((input.min !== null || input.max !== null || input.step !== null) && !["number", "range"].includes(input.type)) throw new Error(`${path} has invalid numeric policy.`);

package/dist/cms-contract-node/artifact.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedContentContractV1 } from '../cms-contract/types.js';
+export declare const RESOLVED_CONTENT_CONTRACT_ARTIFACT: ".ginko/content-contract.json";
+export interface ResolvedContentContractArtifact {
+    contract: ResolvedContentContractV1;
+    sha256: string;
+}
+export interface ReadResolvedContentContractOptions {
+    root: string;
+}
+export declare function readResolvedContentContract(options: ReadResolvedContentContractOptions): Promise<ResolvedContentContractArtifact>;
+export declare function writeResolvedContentContractArtifact(root: string, contract: ResolvedContentContractV1): Promise<ResolvedContentContractArtifact>;

package/dist/cms-contract-node/artifact.js

@@ -0,0 +1,74 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, open, rename, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { canonicalJsonBytes, hashCanonicalJson } from "../cms-contract/hash.js";
+import { PORTABLE_CONTENT_LIMITS } from "../cms-contract/limits.js";
+import { assertResolvedContentContract } from "../cms-contract/validate.js";
+import { readStableRegularFile, StableFileError } from "./stable-file.js";
+export const RESOLVED_CONTENT_CONTRACT_ARTIFACT = ".ginko/content-contract.json";
+const artifactError = (message) => new TypeError(`Resolved Content contract artifact ${message}`);
+function artifactPath(root) {
+  if (!root) throw artifactError("requires a project root.");
+  return join(resolve(root), ".ginko", "content-contract.json");
+}
+export async function readResolvedContentContract(options) {
+  const path = artifactPath(options.root);
+  try {
+    const directory = join(resolve(options.root), ".ginko");
+    const directoryStats = await lstat(directory);
+    if (!directoryStats.isDirectory() || directoryStats.isSymbolicLink()) {
+      throw artifactError("directory is unsafe.");
+    }
+    const before = await lstat(path);
+    const bytes = await readStableRegularFile(path, before, PORTABLE_CONTENT_LIMITS.contractBytes);
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    const contract = assertResolvedContentContract(value);
+    return {
+      contract,
+      sha256: await hashCanonicalJson(contract)
+    };
+  } catch (error) {
+    if (error instanceof StableFileError) {
+      throw artifactError(error.reason === "limit" ? "exceeds its byte limit." : "is not a safe regular file.");
+    }
+    if (error instanceof Error && error.message.startsWith("Resolved Content contract artifact ")) throw error;
+    throw artifactError("is missing or invalid.");
+  }
+}
+export async function writeResolvedContentContractArtifact(root, contract) {
+  const validated = assertResolvedContentContract(contract);
+  const canonical = canonicalJsonBytes(validated);
+  if (canonical.byteLength + 1 > PORTABLE_CONTENT_LIMITS.contractBytes) {
+    throw artifactError("exceeds its byte limit.");
+  }
+  const directory = join(resolve(root), ".ginko");
+  const path = artifactPath(root);
+  const temporary = join(directory, `.content-contract.${process.pid}.${randomUUID()}.tmp`);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const directoryStats = await lstat(directory);
+  if (!directoryStats.isDirectory() || directoryStats.isSymbolicLink()) {
+    throw artifactError("directory is unsafe.");
+  }
+  const bytes = new Uint8Array(canonical.byteLength + 1);
+  bytes.set(canonical);
+  bytes[bytes.length - 1] = 10;
+  let handle;
+  try {
+    handle = await open(temporary, "wx", 384);
+    await handle.writeFile(bytes);
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await rename(temporary, path);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Resolved Content contract artifact ")) throw error;
+    throw artifactError("could not be written safely.");
+  } finally {
+    await handle?.close();
+    await rm(temporary, { force: true });
+  }
+  return {
+    contract: validated,
+    sha256: await hashCanonicalJson(validated)
+  };
+}

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

@@ -0,0 +1 @@
+export { RESOLVED_CONTENT_CONTRACT_ARTIFACT, readResolvedContentContract, type ReadResolvedContentContractOptions, type ResolvedContentContractArtifact, } from './artifact.js';

package/dist/cms-contract-node/index.js

@@ -0,0 +1,4 @@
+export {
+  RESOLVED_CONTENT_CONTRACT_ARTIFACT,
+  readResolvedContentContract
+} from "./artifact.js";

package/dist/cms-contract-node/stable-file.d.ts

@@ -0,0 +1,7 @@
+import { type Stats } from 'node:fs';
+export type StableFileFailure = 'limit' | 'unsafe';
+export declare class StableFileError extends Error {
+    readonly reason: StableFileFailure;
+    constructor(reason: StableFileFailure);
+}
+export declare function readStableRegularFile(path: string, before: Stats, maximumBytes: number): Promise<Uint8Array>;

package/dist/cms-contract-node/stable-file.js

@@ -0,0 +1,44 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+export class StableFileError extends Error {
+  constructor(reason) {
+    super(`Stable file ${reason}.`);
+    this.reason = reason;
+    this.name = "StableFileError";
+  }
+  reason;
+}
+export async function readStableRegularFile(path, before, maximumBytes) {
+  if (!before.isFile() || before.isSymbolicLink() || before.nlink !== 1) {
+    throw new StableFileError("unsafe");
+  }
+  if (before.size > maximumBytes) throw new StableFileError("limit");
+  let handle;
+  try {
+    handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const opened = await handle.stat();
+    assertSameFile(before, opened);
+    const buffer = new Uint8Array(maximumBytes + 1);
+    let offset = 0;
+    while (offset < buffer.byteLength) {
+      const { bytesRead } = await handle.read(buffer, offset, buffer.byteLength - offset, offset);
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+    }
+    const after = await handle.stat();
+    assertSameFile(opened, after);
+    if (offset !== after.size) throw new StableFileError("unsafe");
+    if (offset > maximumBytes) throw new StableFileError("limit");
+    return buffer.slice(0, offset);
+  } catch (error) {
+    if (error instanceof StableFileError) throw error;
+    throw new StableFileError("unsafe");
+  } finally {
+    await handle?.close();
+  }
+}
+function assertSameFile(left, right) {
+  if (left.dev !== right.dev || left.ino !== right.ino || left.size !== right.size || left.mtimeMs !== right.mtimeMs || !right.isFile() || right.nlink !== 1) {
+    throw new StableFileError("unsafe");
+  }
+}

package/dist/core/content/path.d.ts

@@ -51,21 +51,4 @@ export declare const lowerRouteToCanonicalCandidates: (route: string, requestedL
     locale: string;
     contentPath: string;
 }[];
-/**
- * Released CMS-contract adapter returning mounted provider coordinates.
- *
- * This function GUESSES: it unions locales from the mount map, the requested
- * chain, and the default locale, and it substitutes `/` for any locale with no
- * declared mount. The content engine deliberately does not call it — route
- * lowering goes through `lowerRouteToCandidates`
- * (`features/localization/route-projector.ts`), which validates the resolved
- * locale's configured mount and fails instead of substituting one.
- *
- * It exists only so CMS adapters compiled against the released contract keep
- * working. New code should use the resolved collection locale policy.
- */
-export declare const routeToContentPathCandidates: (route: string, requestedLocale: string | undefined, localeChain: string[], defaultLocale?: string, mounts?: RouteMounts) => {
-    locale: string;
-    path: string;
-}[];
 export declare const pathHasLocalePrefix: (path: string, locales: string[]) => boolean;

package/dist/core/content/path.js

@@ -193,22 +193,4 @@ export const lowerRouteToCanonicalCandidates = (route, requestedLocale, localeCh
     contentPath
   }));
 };
-export const routeToContentPathCandidates = (route, requestedLocale, localeChain, defaultLocale, mounts) => {
-  const locales = Array.from(new Set([...Object.keys(mounts || {}), ...localeChain, defaultLocale].filter(Boolean)));
-  if (!mounts) {
-    const stripped = stripLocalePrefix(route, locales, defaultLocale, requestedLocale);
-    return localeChain.map((locale) => ({ locale, path: stripped.path }));
-  }
-  return lowerRouteToCanonicalCandidates(
-    route,
-    requestedLocale,
-    localeChain,
-    defaultLocale || localeChain[0] || "",
-    locales,
-    (locale) => mounts[locale] || "/"
-  ).map((candidate) => ({
-    locale: candidate.locale,
-    path: mountContentPath(candidate.contentPath, candidate.locale, mounts)
-  }));
-};
 export const pathHasLocalePrefix = isLocalePrefixedPath;

package/dist/core/data-source-error.d.ts

@@ -1,4 +1,4 @@
-export type ContentDataSourceErrorCode = 'QUERY_CURSOR_INVALID' | 'BACKEND_FAILURE';
+export type ContentDataSourceErrorCode = 'QUERY_CURSOR_INVALID' | 'QUERY_UNSUPPORTED' | 'BACKEND_FAILURE';
 export declare const createContentDataSourceError: (code: ContentDataSourceErrorCode) => Error;
 export declare const isContentDataSourceError: (value: unknown) => value is Error & {
     code: ContentDataSourceErrorCode;

package/dist/core/data-source-error.js

@@ -1,7 +1,7 @@
 class ContentDataSourceError extends Error {
   code;
   constructor(code) {
-    super(code === "QUERY_CURSOR_INVALID" ? "Content data-source query cursor is invalid." : "Content data-source operation failed.");
+    super(code === "QUERY_CURSOR_INVALID" ? "Content data-source query cursor is invalid." : code === "QUERY_UNSUPPORTED" ? "Content data-source query is unsupported." : "Content data-source operation failed.");
     this.name = "ContentDataSourceError";
     this.code = code;
   }

package/dist/core/query/execute.js

@@ -4,6 +4,21 @@ import { getGraphCanonicalVariants, resolveGraphCanonicalKey, resolveGraphRouteV
 import { ensureArray, get, projectDocumentFields, sortList } from "./operators.js";
 import { createCoreProviderError } from "../provider-errors.js";
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const regexFlags = /* @__PURE__ */ new Set(["d", "g", "i", "m", "s", "u", "y"]);
+const parseRegexLiteral = (value) => {
+  if (!value.startsWith("/")) return null;
+  const closingSlash = value.lastIndexOf("/");
+  if (closingSlash === 0) return null;
+  const flags = value.slice(closingSlash + 1);
+  if ([...flags].some((flag) => !regexFlags.has(flag)) || new Set(flags).size !== flags.length) {
+    throw createCoreProviderError(
+      "unsupported_query_shape",
+      "The query contains a malformed regular-expression literal.",
+      { field: "where.$regex" }
+    );
+  }
+  return [value.slice(1, closingSlash), flags];
+};
 const reviveRegex = (value) => isPlanRegex(value) ? new RegExp(value.source, value.flags) : value;
 const includesEntry = (haystack, entry) => typeof haystack === "string" ? isPlanRegex(entry) ? reviveRegex(entry).test(haystack) : haystack.includes(String(entry)) : haystack.some((value) => compareOperators.eq(value, entry));
 const compareOperators = {
@@ -48,8 +63,9 @@ const compareOperators = {
         "$regex operand must be a plain string or a tagged { __ginkoContentQueryValue: 'RegExp', source, flags } wire value produced by the current PROVIDER_QUERY_VERSION lowering; received an untagged object (likely an old-wire { source, flags } regex predating PROVIDER_QUERY_VERSION)"
       );
     }
-    const matched = String(operand).match(/\/(.*)\/([dgimsuy]*)$/);
-    const regex = matched?.[1] ? new RegExp(matched[1], matched[2] || "") : new RegExp(String(operand));
+    const serialized = String(operand);
+    const literal = parseRegexLiteral(serialized);
+    const regex = literal ? new RegExp(literal[0], literal[1]) : new RegExp(serialized);
     return regex.test(String(item || ""));
   }
 };

package/dist/core/references/resolve.js

@@ -1,7 +1,14 @@
 import { isMarkdownRoot, mapMarkdownNode } from "../markdown/tree.js";
 export const CONTENT_REF_LINK_PREFIX = "$";
 const MARKDOWN_LINK_PROP_KEYS = ["href", "to"];
-export const normalizeReferenceValue = (value) => String(value).replace(/^\/+|\/+$/g, "");
+export const normalizeReferenceValue = (value) => {
+  const normalized = String(value);
+  let start = 0;
+  let end = normalized.length;
+  while (start < end && normalized[start] === "/") start += 1;
+  while (end > start && normalized[end - 1] === "/") end -= 1;
+  return normalized.slice(start, end);
+};
 export const parseRefLink = (value) => {
   if (typeof value !== "string" || !value.startsWith(CONTENT_REF_LINK_PREFIX)) {
     return null;

package/dist/features/localization/path.d.ts

@@ -1,6 +1,6 @@
 import { type RuntimeContentI18nInput } from './config';
-import { mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale, routeRemainder, routeToContentPathCandidates, stripLocalePrefix, type RouteMounts } from '../../core/content/path';
-export { mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale, routeRemainder, routeToContentPathCandidates, stripLocalePrefix, type RouteMounts };
+import { mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale, routeRemainder, stripLocalePrefix, type RouteMounts } from '../../core/content/path';
+export { mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale, routeRemainder, stripLocalePrefix, type RouteMounts };
 export declare const fallbackStem: (path: string) => string;
 export declare const getContentStem: (path: string, file?: string) => string;
 export declare const resolveCollectionI18n: (collection: string, content: RuntimeContentI18nInput) => {

package/dist/features/localization/path.js

@@ -6,7 +6,6 @@ import {
   pathHasLocalePrefix,
   prefixPathWithLocale,
   routeRemainder,
-  routeToContentPathCandidates,
   stripLocalePrefix
 } from "../../core/content/path.js";
 export {
@@ -15,7 +14,6 @@ export {
   normalizeRouteMounts,
   prefixPathWithLocale,
   routeRemainder,
-  routeToContentPathCandidates,
   stripLocalePrefix
 };
 const NON_LOCALIZED_PREFIXES = ["/api", "/llms", "/raw"];

package/dist/features/query/query-plan-boundary.d.ts

@@ -6,4 +6,4 @@ export declare const toCanonicalQueryPlan: (plan: LoweredQueryPlan, policy: Reso
 /** Convert a closed canonical plan to the mounted provider wire exactly once. */
 export declare const toContentProviderQueryPlan: (plan: CanonicalQueryPlan, policy: ResolvedCollectionLocalePolicy | undefined) => ContentProviderQueryPlan;
 /** Filesystem-provider boundary: mounted public wire back to canonical graph coordinates. */
-export declare const fromContentProviderQueryPlan: (plan: ContentProviderQueryPlan, policy: ResolvedCollectionLocalePolicy | undefined) => CanonicalQueryPlan;
+export declare const fromContentProviderQueryPlan: (plan: ContentProviderQueryPlan, collection: string | null, policy: ResolvedCollectionLocalePolicy | undefined) => CanonicalQueryPlan;

package/dist/features/query/query-plan-boundary.js

@@ -62,9 +62,10 @@ export const toCanonicalQueryPlan = (plan, policy) => {
   };
 };
 export const toContentProviderQueryPlan = (plan, policy) => {
+  const { collection: _collection, ...withoutCollection } = plan;
   const selector = plan.variant;
   if (!selector) {
-    const { variant: _variant, ...provider } = plan;
+    const { variant: _variant, ...provider } = withoutCollection;
     return provider;
   }
   const resolvedPolicy = requirePolicy(policy);
@@ -93,12 +94,16 @@ export const toContentProviderQueryPlan = (plan, policy) => {
   } else {
     variant = selector;
   }
-  return { ...plan, variant };
+  return { ...withoutCollection, variant };
 };
-export const fromContentProviderQueryPlan = (plan, policy) => {
+export const fromContentProviderQueryPlan = (plan, collection, policy) => {
+  const planWithCollection = {
+    ...plan,
+    ...collection ? { collection } : {}
+  };
   const selector = plan.variant;
   if (!selector) {
-    const { variant: _variant, ...canonical } = plan;
+    const { variant: _variant, ...canonical } = planWithCollection;
     return canonical;
   }
   const resolvedPolicy = requirePolicy(policy);
@@ -106,7 +111,7 @@ export const fromContentProviderQueryPlan = (plan, policy) => {
     const operation = operationLocales(selector, resolvedPolicy);
     const { path, ...options } = selector;
     return {
-      ...plan,
+      ...planWithCollection,
       variant: {
         ...options,
         canonicalPath: unmountProviderContentPath(
@@ -119,7 +124,7 @@ export const fromContentProviderQueryPlan = (plan, policy) => {
   }
   if (selector.by === "route") {
     return {
-      ...plan,
+      ...planWithCollection,
       variant: {
         ...selector,
         candidates: selector.candidates.map((candidate) => ({
@@ -133,5 +138,5 @@ export const fromContentProviderQueryPlan = (plan, policy) => {
       }
     };
   }
-  return { ...plan, variant: selector };
+  return { ...planWithCollection, variant: selector };
 };

package/dist/module.d.mts

@@ -46,7 +46,7 @@ type ContentCollectionSource = string | string[];
  */
 type ContentCollectionRouteConfig = string | Record<string, string>;
 type ContentCollectionKind = 'page' | 'data';
-type ContentCmsFieldType = 'text' | 'textarea' | 'richtext' | 'slug' | 'email' | 'url' | 'number' | 'range' | 'select' | 'multiselect' | 'radio' | 'checkbox' | 'toggle' | 'date' | 'datetime' | 'time' | 'json' | 'object' | 'array' | 'blocks' | 'relation' | 'relations' | 'image' | 'images' | 'file' | 'icon' | 'code' | 'color' | 'divider' | 'section';
+type ContentCmsFieldType = 'text' | 'textarea' | 'richtext' | 'slug' | 'email' | 'url' | 'number' | 'range' | 'select' | 'multiselect' | 'radio' | 'checkbox' | 'toggle' | 'date' | 'datetime' | 'time' | 'json' | 'object' | 'array' | 'blocks' | 'relation' | 'relations' | 'image' | 'images' | 'icon' | 'code' | 'color' | 'divider' | 'section';
 interface ContentCmsRelationConfig {
     collectionId: string;
     multiple?: boolean;

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/ginko-content",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
   "configKey": "content",
   "compatibility": {
     "nuxt": ">=4.5.1 <5"

package/dist/module.mjs

@@ -2,6 +2,7 @@ import { addTypeTemplate, addImports, addServerImports, addComponentsDir, getLay
 import { readFile, readdir, rm } from 'node:fs/promises';
 import { join as join$1, basename, resolve as resolve$1, dirname, isAbsolute as isAbsolute$1 } from 'node:path';
 import { buildResolvedContentContract } from '../dist/cms-contract/index.js';
+import { writeResolvedContentContractArtifact } from '../dist/cms-contract-node/artifact.js';
 import fs, { existsSync } from 'fs';
 import { createRequire } from 'node:module';
 import { join, relative, isAbsolute, resolve } from 'pathe';
@@ -33,7 +34,7 @@ import { assertCanonicalHighlightOptionNames } from '../dist/parsers/markdown-pl
 import { BUILTIN_MARKDOWN_RENDER_CONTRACTS } from '../dist/core/markdown/builtin-render-contracts.js';
 
 const name = "@lupinum/ginko-content";
-const version = "1.0.0-beta.2";
+const version = "1.0.0-beta.3";
 const peerDependencies = {
 	nuxt: ">=4.5.1 <5"};
 
@@ -2155,6 +2156,7 @@ const module$1 = defineNuxtModule({
       getSearchRuntime,
       siteUrl: resolveNuxtSiteUrl(nuxt)
     });
+    await writeResolvedContentContractArtifact(nuxt.options.rootDir, contentContext.contract);
     registerContentContextFinalization({
       nuxt,
       options,