@replohq/sdk 0.13.0 → 0.15.0

package/_vendor/replo-utils/lib/json.mjs

@@ -1,43 +1,3 @@
+export { jsonStringifyOrNull, omitJsonObjectFieldsOrNull, parseJsonOrNull } from '../../../chunk-VKO7P3ED.mjs';
+import '../../../chunk-GV5FY7ZZ.mjs';
 import '../../../chunk-UJCSKKID.mjs';
-
-// ../replo-utils/lib/object.ts
-function omit(obj, keysToOmit) {
-  const result = { ...obj };
-  for (const key of keysToOmit) {
-    delete result[key];
-  }
-  return result;
-}
-
-// ../replo-utils/lib/json.ts
-function parseJsonOrNull(json) {
-  try {
-    return JSON.parse(json);
-  } catch {
-    return null;
-  }
-}
-function omitJsonObjectFieldsOrNull({
-  json,
-  fields
-}) {
-  const parsedJson = parseJsonOrNull(json);
-  if (typeof parsedJson !== "object" || parsedJson === null || Array.isArray(parsedJson)) {
-    return null;
-  }
-  return jsonStringifyOrNull(
-    omit(Object.fromEntries(Object.entries(parsedJson)), fields)
-  );
-}
-function jsonStringifyOrNull(value) {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return null;
-  }
-}
-
-export { jsonStringifyOrNull, omitJsonObjectFieldsOrNull, parseJsonOrNull };

package/_vendor/replo-utils/lib/misc.mjs

@@ -0,0 +1,3 @@
+export { coerceNumberToString, deepCloneAndMergeReplacingArrays, errorMessage, exhaustiveSwitch, formatFileSize, getFromRecordOrNull, hasOwnProperty, invariant, isEmpty, isFunction_default as isFunction, isNotNullish, isNullish, isPrimitive, mergeReplacingArrays, mergeReplacingObjects, noop, preventDefault, sleep, warning } from '../../../chunk-AL3F36PH.mjs';
+export { isNumber_default as isNumber, isString_default as isString } from '../../../chunk-GV5FY7ZZ.mjs';
+import '../../../chunk-UJCSKKID.mjs';

package/_vendor/schemas/contentCollection.d.ts

@@ -0,0 +1,231 @@
+import { z } from "zod";
+/**
+ * The shared app-root manifest that bundles `content/**` for production
+ * builds (published Workers have no filesystem). Scaffolded as a placeholder
+ * by the coordinator, imported by the generated templates, and populated by
+ * the harness publish tool before `next build` — one constant so those three
+ * can never drift.
+ */
+export declare const CONTENT_MANIFEST_FILENAME = "content-manifest.generated.json";
+/** Site-relative directory that holds all content. */
+export declare const CONTENT_DIRNAME = "content";
+/** Per-collection schema file inside `content/<collection>/`. */
+export declare const CONTENT_COLLECTION_SCHEMA_FILENAME = "_collection.json";
+/** Extension of entry files inside `content/<collection>/`. */
+export declare const CONTENT_ENTRY_FILE_EXTENSION = ".mdx";
+/**
+ * Frontmatter key that stores the `relatedContent` field's value (an array of
+ * `<collection>/<entry>` paths). The storage key predates the field id; both
+ * the editor's serializer and the SDK renderer map between them through this
+ * constant.
+ */
+export declare const CONTENT_RELATED_VALUE_STORAGE_KEY = "related";
+/**
+ * One slug contract for collection and entry slugs: they become directory
+ * names, file names, and public URL segments in every consumer. The pattern
+ * is ASCII-only, so the length cap counts bytes and characters identically.
+ */
+export declare const CONTENT_SLUG_PATTERN: RegExp;
+export declare const CONTENT_MAX_SLUG_LENGTH = 100;
+export declare const contentSlugSchema: z.ZodString;
+export declare function isValidContentSlug(slug: string): boolean;
+export declare const CONTENT_ENTRY_STATUSES: readonly ["draft", "published", "archived"];
+export type ContentEntryStatus = (typeof CONTENT_ENTRY_STATUSES)[number];
+export declare const contentEntryStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+    archived: "archived";
+}>;
+/**
+ * The one public-visibility rule: only published, non-archived entries render
+ * on the published site. The sandbox preview (`next dev`) and the website
+ * builder pass `allowDrafts: true` so drafts are previewable before publish.
+ */
+export declare function isContentEntryPubliclyVisible({ status, archivedAt, allowDrafts, }: {
+    status: ContentEntryStatus;
+    archivedAt: unknown;
+    allowDrafts: boolean;
+}): boolean;
+export declare const contentCollectionFieldTypeSchema: z.ZodEnum<{
+    boolean: "boolean";
+    status: "status";
+    image: "image";
+    url: "url";
+    date: "date";
+    tags: "tags";
+    related: "related";
+    "short-text": "short-text";
+    "long-text": "long-text";
+    "rich-text": "rich-text";
+}>;
+export type ContentCollectionFieldType = z.infer<typeof contentCollectionFieldTypeSchema>;
+export declare const contentCollectionColorSchema: z.ZodEnum<{
+    seashell: "seashell";
+    yellow: "yellow";
+    lightGreen: "lightGreen";
+    darkGreen: "darkGreen";
+    lightPink: "lightPink";
+    magenta: "magenta";
+    purple: "purple";
+    blue: "blue";
+}>;
+export declare const contentCollectionFieldSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        boolean: "boolean";
+        status: "status";
+        image: "image";
+        url: "url";
+        date: "date";
+        tags: "tags";
+        related: "related";
+        "short-text": "short-text";
+        "long-text": "long-text";
+        "rich-text": "rich-text";
+    }>;
+    required: z.ZodBoolean;
+    enabled: z.ZodBoolean;
+    helpText: z.ZodOptional<z.ZodString>;
+    builtin: z.ZodBoolean;
+}, z.core.$strip>;
+export type ContentCollectionField = z.infer<typeof contentCollectionFieldSchema>;
+/**
+ * The `_collection.json` file contract. `passthrough` keeps unknown keys so
+ * editor round-trips never drop data another writer added.
+ */
+export declare const contentCollectionFileSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    icon: z.ZodString;
+    color: z.ZodEnum<{
+        seashell: "seashell";
+        yellow: "yellow";
+        lightGreen: "lightGreen";
+        darkGreen: "darkGreen";
+        lightPink: "lightPink";
+        magenta: "magenta";
+        purple: "purple";
+        blue: "blue";
+    }>;
+    tags: z.ZodArray<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodEnum<{
+            boolean: "boolean";
+            status: "status";
+            image: "image";
+            url: "url";
+            date: "date";
+            tags: "tags";
+            related: "related";
+            "short-text": "short-text";
+            "long-text": "long-text";
+            "rich-text": "rich-text";
+        }>;
+        required: z.ZodBoolean;
+        enabled: z.ZodBoolean;
+        helpText: z.ZodOptional<z.ZodString>;
+        builtin: z.ZodBoolean;
+    }, z.core.$strip>>;
+    archivedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    hasListingPage: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * Whether a URL is renderable on a published page. Relative URLs resolve
+ * against a dummy base so path-only values pass; only http(s) may be an
+ * image source, while links additionally allow mailto/tel.
+ */
+export declare function isSafeContentUrl(value: string, { image }: {
+    image: boolean;
+}): boolean;
+/**
+ * Validity of a present (non-empty) value for a field type. This decides both
+ * editor-side validation errors and whether the SDK renders the entry at all,
+ * so the two can never disagree about what a valid value is.
+ */
+export declare function getContentFieldValueSchema(fieldType: ContentCollectionFieldType): z.ZodType;
+/**
+ * Slugs a collection may never claim even when the segment doesn't exist yet:
+ * conventional Next.js route namespaces every site is expected to grow into.
+ * Segments the site already owns are rejected separately at scaffold time.
+ */
+export declare const CONTENT_RESERVED_COLLECTION_SLUGS: readonly ["api", "new"];
+export declare const CONTENT_RESERVED_ENTRY_SLUGS: readonly ["new"];
+export declare function isContentReservedEntrySlug(slug: string): boolean;
+/**
+ * - `content`: rendered on the published page and ordered by collection
+ *   settings (all custom fields are content).
+ * - `publishing`: publish controls (never rendered as page content).
+ * - `seo`: head metadata, not body content.
+ * - `private`: never leaves the editor.
+ */
+export type ContentFieldRole = "content" | "publishing" | "seo" | "private";
+/**
+ * Role of every builtin collection field. `satisfies` makes adding a builtin
+ * without classifying it a compile error wherever field ids are typed as
+ * `ContentBuiltinFieldId`.
+ */
+export declare const CONTENT_BUILTIN_FIELD_ROLES: {
+    readonly title: "content";
+    readonly author: "content";
+    readonly excerpt: "content";
+    readonly coverImage: "content";
+    readonly body: "content";
+    readonly tags: "content";
+    readonly relatedContent: "content";
+    readonly slug: "publishing";
+    readonly status: "publishing";
+    readonly publishedAt: "publishing";
+};
+export type ContentBuiltinFieldId = keyof typeof CONTENT_BUILTIN_FIELD_ROLES;
+/** Entry-level frontmatter keys that are head metadata, not collection fields. */
+export declare const CONTENT_SEO_VALUE_KEYS: readonly ["seoTitle", "seoDescription"];
+/** Entry-level frontmatter keys that must never be publicly rendered. */
+export declare const CONTENT_PRIVATE_VALUE_KEYS: readonly ["scratchpad", "backlinks"];
+/**
+ * Values that render and edit with a parent content field instead of owning
+ * an ordered slot of their own.
+ */
+export declare const CONTENT_COUPLED_VALUE_PARENTS: {
+    readonly coverImageAlt: "coverImage";
+    readonly authorInitials: "author";
+};
+/**
+ * A related-content reference as stored in `related` frontmatter:
+ * `<collectionSlug>/<entrySlug>`. Producer and consumer share this pair so
+ * the written form and the published renderer can't drift apart.
+ */
+export declare function formatContentEntryRef({ collectionSlug, entrySlug, }: {
+    collectionSlug: string;
+    entrySlug: string;
+}): string;
+/** Null when the ref isn't a `<collectionSlug>/<entrySlug>` pair. */
+export declare function parseContentEntryRef(ref: string): {
+    collectionSlug: string;
+    entrySlug: string;
+} | null;
+export declare function isContentPrivateValueKey(key: string): boolean;
+export declare function isContentSeoValueKey(key: string): boolean;
+export declare function isContentReservedCollectionSlug(slug: string): boolean;
+/** Custom (non-builtin) collection fields are always content. */
+export declare function getContentFieldRole(fieldId: string): ContentFieldRole;
+/**
+ * Enabled fields in collection-settings order, for the published page. The
+ * "Visible" toggle is authoritative here — including lifecycle fields like
+ * status and the slug, which the entry editor renders as dedicated controls
+ * rather than ordered fields. Private keys never publish.
+ */
+export declare function getPublishedContentFields<Field extends {
+    id: string;
+    enabled: boolean;
+}>(fields: Field[]): Field[];
+/**
+ * Enabled content-role fields in collection-settings order — what the entry
+ * editor renders as the ordered field list.
+ */
+export declare function getOrderedContentFields<Field extends {
+    id: string;
+    enabled: boolean;
+}>(fields: Field[]): Field[];

package/_vendor/schemas/contentCollection.mjs

@@ -0,0 +1,2 @@
+export { CONTENT_BUILTIN_FIELD_ROLES, CONTENT_COLLECTION_SCHEMA_FILENAME, CONTENT_COUPLED_VALUE_PARENTS, CONTENT_DIRNAME, CONTENT_ENTRY_FILE_EXTENSION, CONTENT_ENTRY_STATUSES, CONTENT_MANIFEST_FILENAME, CONTENT_MAX_SLUG_LENGTH, CONTENT_PRIVATE_VALUE_KEYS, CONTENT_RELATED_VALUE_STORAGE_KEY, CONTENT_RESERVED_COLLECTION_SLUGS, CONTENT_RESERVED_ENTRY_SLUGS, CONTENT_SEO_VALUE_KEYS, CONTENT_SLUG_PATTERN, contentCollectionColorSchema, contentCollectionFieldSchema, contentCollectionFieldTypeSchema, contentCollectionFileSchema, contentEntryStatusSchema, contentSlugSchema, formatContentEntryRef, getContentFieldRole, getContentFieldValueSchema, getOrderedContentFields, getPublishedContentFields, isContentEntryPubliclyVisible, isContentPrivateValueKey, isContentReservedCollectionSlug, isContentReservedEntrySlug, isContentSeoValueKey, isSafeContentUrl, isValidContentSlug, parseContentEntryRef } from '../../chunk-IQ5GRTXO.mjs';
+import '../../chunk-UJCSKKID.mjs';

package/_vendor/schemas/contentEntry.d.ts

@@ -0,0 +1,53 @@
+import { contentCollectionFieldSchema } from "./contentCollection";
+import { z } from "zod";
+export declare const CONTENT_MANAGED_ENTRY_VALUE_KEYS: readonly ["slug", "title", "status", "author", "authorInitials", "excerpt", "coverImage", "coverImageAlt", "tags", "updatedAt", "publishedAt", "archivedAt", "seoTitle", "seoDescription", "related", "scratchpad", "backlinks"];
+export declare const contentEntryFrontmatterSchema: z.ZodObject<{
+    slug: z.ZodOptional<z.ZodUnknown>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>;
+    author: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    authorInitials: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    excerpt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    coverImage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    coverImageAlt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    publishedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    archivedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    seoTitle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    seoDescription: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    related: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    scratchpad: z.ZodOptional<z.ZodUnknown>;
+    backlinks: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+export type ContentEntryFrontmatter = z.infer<typeof contentEntryFrontmatterSchema>;
+export interface ContentEntryDocument {
+    values: ContentEntryFrontmatter;
+    body: string;
+}
+export type ParsedContentEntryDocument = {
+    status: "ready";
+    document: ContentEntryDocument;
+} | {
+    status: "invalid";
+    message: string;
+};
+export declare function parseContentEntryDocument(raw: string): ParsedContentEntryDocument;
+export declare function serializeContentEntryDocument({ values, body, }: ContentEntryDocument): string;
+export declare function getContentRenderableEntryValues({ document, slug, }: {
+    document: ContentEntryDocument;
+    slug: string;
+}): Record<string, unknown>;
+export interface ContentEntryFieldValidationIssue {
+    fieldId: string;
+    message: string;
+}
+export declare function getContentEntryFieldValidationIssues({ fields, values, requireRequiredFields, }: {
+    fields: z.infer<typeof contentCollectionFieldSchema>[];
+    values: Record<string, unknown>;
+    requireRequiredFields: boolean;
+}): ContentEntryFieldValidationIssue[];

package/_vendor/schemas/contentEntry.mjs

@@ -0,0 +1,3 @@
+export { CONTENT_MANAGED_ENTRY_VALUE_KEYS, contentEntryFrontmatterSchema, getContentEntryFieldValidationIssues, getContentRenderableEntryValues, parseContentEntryDocument, serializeContentEntryDocument } from '../../chunk-I23U2PUI.mjs';
+import '../../chunk-IQ5GRTXO.mjs';
+import '../../chunk-UJCSKKID.mjs';

package/_vendor/schemas/contentFrontmatter.d.ts

@@ -0,0 +1,18 @@
+/** Matches a leading `---` frontmatter block, tolerating CRLF and EOF. */
+export declare const CONTENT_FRONTMATTER_PATTERN: RegExp;
+/**
+ * Strictly parse a frontmatter YAML block into a plain object, or null when
+ * it isn't valid. Strictness (unique keys, no merge, bounded aliases) is part
+ * of the format contract: a file the published runtime would reject must be
+ * rejected by every editor surface too.
+ */
+export declare function parseContentFrontmatterYaml(yamlText: string): Record<string, unknown> | null;
+/**
+ * Parse a full entry file that must start with a frontmatter block. Returns
+ * null when the block is missing or invalid; the remainder of the file is the
+ * markdown body.
+ */
+export declare function parseContentFrontmatter(raw: string): {
+    values: Record<string, unknown>;
+    body: string;
+} | null;

package/_vendor/schemas/contentManifest.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare const contentManifestSchema: z.ZodObject<{
+    files: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export type ContentManifest = z.infer<typeof contentManifestSchema>;
+export type ContentFilePath = {
+    type: "collection";
+    collection: string;
+} | {
+    type: "entry";
+    collection: string;
+    entry: string;
+};
+export interface ContentValidationIssue {
+    path: string;
+    message: string;
+}
+export interface ContentIndexEntry {
+    slug: string;
+    title: string;
+    status: "draft" | "published";
+}
+export interface ContentIndexCollection {
+    slug: string;
+    name: string;
+    entries: ContentIndexEntry[];
+}
+export declare function createContentManifest({ files, }: {
+    files: {
+        path: string;
+        content: string;
+    }[];
+}): ContentManifest;
+export declare function getContentFilePath(filePath: string): ContentFilePath | null;
+export declare function getContentManifestCollectionSlugs(contentManifest: ContentManifest): string[];
+export declare function getContentManifestEntrySlugs({ collection, contentManifest, }: {
+    collection: string;
+    contentManifest: ContentManifest;
+}): string[];
+export declare function getContentIndex({ files, allowDrafts, }: {
+    files: Record<string, string | null>;
+    allowDrafts: boolean;
+}): ContentIndexCollection[];
+export declare function validateContentManifest(contentManifest: ContentManifest): ContentValidationIssue[];

package/_vendor/schemas/contentManifest.mjs

@@ -0,0 +1,197 @@
+import { parseContentEntryDocument, getContentRenderableEntryValues, getContentEntryFieldValidationIssues } from '../../chunk-I23U2PUI.mjs';
+import { isValidContentSlug, CONTENT_COLLECTION_SCHEMA_FILENAME, CONTENT_ENTRY_FILE_EXTENSION, contentCollectionFileSchema, isContentEntryPubliclyVisible } from '../../chunk-IQ5GRTXO.mjs';
+import { parseJsonOrNull } from '../../chunk-VKO7P3ED.mjs';
+import '../../chunk-GV5FY7ZZ.mjs';
+import '../../chunk-UJCSKKID.mjs';
+import { z } from 'zod';
+
+var contentManifestSchema = z.object({
+  files: z.record(z.string(), z.string())
+});
+function createContentManifest({
+  files
+}) {
+  const sortedFiles = [...files].sort((left, right) => {
+    return left.path.localeCompare(right.path);
+  });
+  return {
+    files: Object.fromEntries(
+      sortedFiles.map((file) => [file.path, file.content])
+    )
+  };
+}
+function getContentFilePath(filePath) {
+  const segments = filePath.split("/").filter(Boolean);
+  const filename = segments.at(-1);
+  const collection = segments.at(-2);
+  if (!filename || !collection || !isValidContentSlug(collection)) {
+    return null;
+  }
+  if (filename === CONTENT_COLLECTION_SCHEMA_FILENAME) {
+    return { type: "collection", collection };
+  }
+  if (!filename.endsWith(CONTENT_ENTRY_FILE_EXTENSION)) {
+    return null;
+  }
+  const entry = filename.slice(0, -CONTENT_ENTRY_FILE_EXTENSION.length);
+  return isValidContentSlug(entry) ? { type: "entry", collection, entry } : null;
+}
+function getContentManifestCollectionSlugs(contentManifest) {
+  return Object.keys(contentManifest.files).flatMap((relativePath) => {
+    const parsedPath = getContentManifestFilePath(relativePath);
+    return parsedPath?.type === "collection" ? [parsedPath.collection] : [];
+  });
+}
+function getContentManifestEntrySlugs({
+  collection,
+  contentManifest
+}) {
+  return Object.keys(contentManifest.files).flatMap((relativePath) => {
+    const parsedPath = getContentManifestFilePath(relativePath);
+    return parsedPath?.type === "entry" && parsedPath.collection === collection ? [parsedPath.entry] : [];
+  });
+}
+function getContentIndex({
+  files,
+  allowDrafts
+}) {
+  const collectionsBySlug = /* @__PURE__ */ new Map();
+  for (const [filePath, content] of Object.entries(files)) {
+    const parsedPath = getContentFilePath(filePath);
+    if (parsedPath?.type !== "collection" || content === null) {
+      continue;
+    }
+    const parsedCollection = contentCollectionFileSchema.safeParse(
+      parseJsonOrNull(content)
+    );
+    if (!parsedCollection.success || parsedCollection.data.archivedAt) {
+      continue;
+    }
+    collectionsBySlug.set(parsedPath.collection, {
+      schema: parsedCollection.data,
+      collection: {
+        slug: parsedPath.collection,
+        name: parsedCollection.data.name,
+        entries: []
+      }
+    });
+  }
+  for (const [filePath, content] of Object.entries(files)) {
+    const parsedPath = getContentFilePath(filePath);
+    if (parsedPath?.type !== "entry" || content === null) {
+      continue;
+    }
+    const collection = collectionsBySlug.get(parsedPath.collection);
+    if (!collection) {
+      continue;
+    }
+    const parsedDocument = parseContentEntryDocument(content);
+    if (parsedDocument.status === "invalid") {
+      continue;
+    }
+    const document = parsedDocument.document;
+    const status = document.values.status;
+    if (status === "archived" || !isContentEntryPubliclyVisible({
+      status,
+      archivedAt: document.values.archivedAt,
+      allowDrafts
+    })) {
+      continue;
+    }
+    const values = getContentRenderableEntryValues({
+      document,
+      slug: parsedPath.entry
+    });
+    const validationIssues = getContentEntryFieldValidationIssues({
+      fields: collection.schema.fields,
+      values,
+      requireRequiredFields: document.values.status === "published"
+    });
+    if (validationIssues.length > 0) {
+      continue;
+    }
+    const trimmedTitle = document.values.title?.trim();
+    collection.collection.entries.push({
+      slug: parsedPath.entry,
+      title: trimmedTitle && trimmedTitle.length > 0 ? trimmedTitle : parsedPath.entry,
+      status
+    });
+  }
+  const collections = [...collectionsBySlug.values()].map(({ collection }) => {
+    collection.entries.sort((left, right) => {
+      return left.title.localeCompare(right.title);
+    });
+    return collection;
+  });
+  return collections.sort((left, right) => {
+    return left.name.localeCompare(right.name);
+  });
+}
+function validateContentManifest(contentManifest) {
+  const collectionSchemas = /* @__PURE__ */ new Map();
+  const issues = [];
+  for (const [relativePath, content] of Object.entries(contentManifest.files)) {
+    const parsedPath = getContentManifestFilePath(relativePath);
+    if (!parsedPath) {
+      issues.push({
+        path: relativePath,
+        message: "The collection or entry slug is not valid."
+      });
+      continue;
+    }
+    if (parsedPath.type !== "collection") {
+      continue;
+    }
+    const parsedCollection = contentCollectionFileSchema.safeParse(
+      parseJsonOrNull(content)
+    );
+    if (!parsedCollection.success) {
+      issues.push({
+        path: relativePath,
+        message: parsedCollection.error.issues[0]?.message ?? "The collection settings are invalid."
+      });
+      continue;
+    }
+    collectionSchemas.set(parsedPath.collection, parsedCollection.data);
+  }
+  for (const [relativePath, content] of Object.entries(contentManifest.files)) {
+    const parsedPath = getContentManifestFilePath(relativePath);
+    if (parsedPath?.type !== "entry") {
+      continue;
+    }
+    const collectionSchema = collectionSchemas.get(parsedPath.collection);
+    if (!collectionSchema) {
+      issues.push({
+        path: relativePath,
+        message: `Collection "${parsedPath.collection}" has no valid ${CONTENT_COLLECTION_SCHEMA_FILENAME}.`
+      });
+      continue;
+    }
+    const parsedDocument = parseContentEntryDocument(content);
+    if (parsedDocument.status === "invalid") {
+      issues.push({ path: relativePath, message: parsedDocument.message });
+      continue;
+    }
+    const document = parsedDocument.document;
+    const fieldIssues = getContentEntryFieldValidationIssues({
+      fields: collectionSchema.fields,
+      values: getContentRenderableEntryValues({
+        document,
+        slug: parsedPath.entry
+      }),
+      requireRequiredFields: document.values.status === "published"
+    });
+    issues.push(
+      ...fieldIssues.map((issue) => ({
+        path: relativePath,
+        message: `${issue.fieldId}: ${issue.message}`
+      }))
+    );
+  }
+  return issues;
+}
+function getContentManifestFilePath(relativePath) {
+  return relativePath.split("/").length === 2 ? getContentFilePath(relativePath) : null;
+}
+
+export { contentManifestSchema, createContentManifest, getContentFilePath, getContentIndex, getContentManifestCollectionSlugs, getContentManifestEntrySlugs, validateContentManifest };

package/_vendor/schemas/money.mjs

@@ -1,4 +1,6 @@
 import { ReploError } from '../../chunk-5M7VU32I.mjs';
+import '../../chunk-AL3F36PH.mjs';
+import '../../chunk-GV5FY7ZZ.mjs';
 import { __commonJS, __toESM } from '../../chunk-UJCSKKID.mjs';
 import { z } from 'zod';
 

package/_vendor/schemas/routing/locale.mjs

@@ -1,4 +1,6 @@
 import { ReploError } from '../../../chunk-5M7VU32I.mjs';
+import '../../../chunk-AL3F36PH.mjs';
+import '../../../chunk-GV5FY7ZZ.mjs';
 import '../../../chunk-UJCSKKID.mjs';
 import { z } from 'zod';
 

package/_vendor/schemas/routing/rules.mjs

@@ -1,5 +1,7 @@
 import { getParamSegment, getRouteParams, hasRouteParam, matchSource } from '../../../chunk-VPEVERWE.mjs';
 import { ReploError } from '../../../chunk-5M7VU32I.mjs';
+import '../../../chunk-AL3F36PH.mjs';
+import '../../../chunk-GV5FY7ZZ.mjs';
 import '../../../chunk-UJCSKKID.mjs';
 import { z } from 'zod';
 

package/cart/cart-provider.d.ts

@@ -53,8 +53,7 @@ export interface CartContextType {
 }
 /**
  * Provider component that manages global cart state and operations. Handles both
- * server-side cart synchronization and client-side optimistic updates. Supports
- * editor mode for preview environments.
+ * server-side cart synchronization and client-side optimistic updates.
  *
  * @returns A context provider wrapping the children with cart functionality
  */

package/cart/cart-provider.js

@@ -17,12 +17,6 @@ import { recalculateCartCost } from "./utils/cart-utils";
 import { createOptimisticSellingPlanAllocation } from "./utils/variant-to-cart-line";
 class CartContextError extends CanopyError {
 }
-const isEditorMode = () => {
-  if (typeof window === "undefined") {
-    return false;
-  }
-  return window.parent !== window;
-};
 let cartCreationPromise = null;
 function addLineToCart(cart, line) {
   const existingLineIndex = cart.lines.findIndex((existingLine) => {
@@ -312,12 +306,7 @@ function CartProvider({
       return null;
     }
   };
-  const checkoutUrl = (() => {
-    if (isEditorMode()) {
-      return "/";
-    }
-    return cartData?.checkoutUrl ?? "/";
-  })();
+  const checkoutUrl = cartData?.checkoutUrl ?? "/";
   return /* @__PURE__ */ jsx(
     CartContext.Provider,
     {