@blinkk/root-cms 3.0.2 → 3.0.4

package/dist/core/security.d.ts

@@ -0,0 +1,6 @@
+export declare const FIRESTORE_RULES = "rules_version = '2';\nservice cloud.firestore {\n  match /databases/{database}/documents {\n    match /{document=**} {\n      allow read, write: if false;\n    }\n\n    match /Projects/{project} {\n      allow write:\n        if isSignedIn() && userIsAdmin();\n      allow read:\n        if isSignedIn() && userCanRead();\n\n      match /{collection}/{document=**} {\n        allow write:\n          if isSignedIn() && userCanPublish();\n        allow read:\n          if isSignedIn() && userCanRead();\n      }\n\n      match /Collections/{collectionId}/Drafts/{document=**} {\n        allow write:\n          if isSignedIn() && userCanEdit();\n      }\n\n      function isSignedIn() {\n        return request.auth != null;\n      }\n\n      function getRoles() {\n        return get(/databases/$(database)/documents/Projects/$(project)).data.roles;\n      }\n\n      function userCanRead() {\n        let roles = getRoles();\n        let email = request.auth.token.email;\n        let domain = '*@' + email.split('@')[1];\n        return (roles[email] in ['ADMIN', 'EDITOR', 'CONTRIBUTOR', 'VIEWER']) || (roles[domain] in ['ADMIN', 'EDITOR', 'CONTRIBUTOR', 'VIEWER']);\n      }\n\n      function userCanPublish() {\n        let roles = getRoles();\n        let email = request.auth.token.email;\n        let domain = '*@' + email.split('@')[1];\n        return (roles[email] in ['ADMIN', 'EDITOR']) || (roles[domain] in ['ADMIN', 'EDITOR']);\n      }\n\n      function userCanEdit() {\n        let roles = getRoles();\n        let email = request.auth.token.email;\n        let domain = '*@' + email.split('@')[1];\n        return (roles[email] in ['ADMIN', 'EDITOR', 'CONTRIBUTOR']) || (roles[domain] in ['ADMIN', 'EDITOR', 'CONTRIBUTOR']);\n      }\n\n      function userIsAdmin() {\n        let roles = getRoles();\n        let email = request.auth.token.email;\n        let domain = '*@' + email.split('@')[1];\n        return (roles[email] == 'ADMIN') || (roles[domain] == 'ADMIN');\n      }\n    }\n  }\n}\n";
+/**
+ * Adds the root-cms security rules to a Firebase project.
+ * NOTE: This function will overwrite any existing rules.
+ */
+export declare function applySecurityRules(projectId: string): Promise<void>;

package/dist/core/server-version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a string that represents the server version. On local dev, the
+ * current timestamp is returned. On prod, the package.json version is returned.
+ */
+export declare function getServerVersion(): string;

package/dist/core/services-notifications.d.ts

@@ -0,0 +1,57 @@
+import type { Action } from './client.js';
+import type { CMSService, CMSServiceContext } from './services.js';
+/** Result returned by a notification service `onAction` handler. */
+export interface NotificationResult {
+    /**
+     * Delivery status.
+     * - `'success'`: the notification was delivered.
+     * - `'error'`: delivery failed; `message` should describe why.
+     * - `'info'` (default): the service handled the action but did not
+     *   deliver a notification (e.g. the action was filtered out).
+     */
+    status?: 'success' | 'info' | 'error';
+    /** Optional human-readable message describing the result. */
+    message?: string;
+}
+/** Context passed to notification service handler functions. */
+export interface NotificationServiceContext extends CMSServiceContext {
+}
+/**
+ * Configuration for defining a CMS notification service.
+ *
+ * Notification services react to actions in the CMS (publishes, schema
+ * changes, comments, etc.) and dispatch them to an external channel.
+ * Initially this is intended for email, with Slack, webhooks, and other
+ * transports planned.
+ *
+ * Multiple notification services may be registered; each independently
+ * decides whether and how to handle a given action.
+ *
+ * Example:
+ * ```ts
+ * cmsPlugin({
+ *   services: {
+ *     notifications: [
+ *       {
+ *         id: 'sendgrid',
+ *         label: 'SendGrid',
+ *         onAction: async (ctx, action) => {
+ *           if (action.action === 'doc.publish') {
+ *             await sendgrid.send({ ... });
+ *           }
+ *         },
+ *       },
+ *     ],
+ *   },
+ * });
+ * ```
+ */
+export interface CMSNotificationService extends CMSService {
+    /**
+     * Async function called when an action occurs in the CMS. Receives the
+     * action and may dispatch a notification (e.g. send email, post to Slack)
+     * via the service's underlying transport. Can optionally return a
+     * `NotificationResult` describing delivery status.
+     */
+    onAction?: (ctx: NotificationServiceContext, action: Action) => Promise<void | NotificationResult>;
+}

package/dist/core/services.d.ts

@@ -0,0 +1,44 @@
+import type { RootConfig } from '@blinkk/root';
+import type { RootCMSClient } from './client.js';
+/**
+ * Base shape for a service registered with the CMS plugin.
+ *
+ * Services are extension points that let plugins provide capabilities
+ * (e.g. email delivery, cache, translations) that root-cms can call into.
+ * Every service shares the same identifying fields — `id`, `label`, optional
+ * `icon` — and is registered via the `services` option on `cmsPlugin()`.
+ *
+ * Concrete service interfaces (e.g. `CMSEmailService`,
+ * `CMSTranslationService`) extend this base and add the handler functions
+ * specific to their capability.
+ */
+export interface CMSService {
+    /** Unique ID for the service (e.g. `'sendgrid'`, `'crowdin'`). */
+    id: string;
+    /** Human-readable label displayed in the UI (e.g. "SendGrid"). */
+    label: string;
+    /**
+     * Optional icon URL displayed in the UI next to the label. Similar to the
+     * sidebar tools `icon` option, this should be a URL to an image.
+     */
+    icon?: string;
+}
+/**
+ * Base context passed to service handler functions. Concrete services may
+ * extend this with additional fields specific to the call site (e.g. the
+ * translation context adds `docId`, `collectionId`, etc.).
+ */
+export interface CMSServiceContext {
+    /** The Root.js config. */
+    rootConfig: RootConfig;
+    /** The Root CMS client for accessing the database. */
+    cmsClient: RootCMSClient;
+    /**
+     * Email of the user that triggered the action, if any. Some service calls
+     * are initiated by the system rather than a user, in which case this is
+     * undefined.
+     */
+    user?: {
+        email: string;
+    };
+}

package/dist/core/sse.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Library for handling server-sent events.
+ * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events
+ */
+import { Server, Response } from '@blinkk/root';
+export type SSEBroadcastFn = (event: string, data?: any) => void;
+export type SSEClient = Response;
+export declare function sse(server: Server): {
+    sseBroadcast: SSEBroadcastFn;
+};

package/dist/core/translations-manager.d.ts

@@ -0,0 +1,187 @@
+import { WriteBatch } from 'firebase-admin/firestore';
+import type { RootCMSClient } from './client.js';
+export type Locale = string;
+export type SourceString = string;
+export type TranslatedString = string;
+export type TranslationsDocMode = 'draft' | 'published';
+export interface TranslationsLocaleDocHashMap {
+    /**
+     * A hash map of a source string's hash fingerprint to the source string and
+     * translated string.
+     */
+    [hash: string]: TranslationsLocaleDocEntry;
+}
+export interface TranslationsLocaleDocEntry {
+    source: SourceString;
+    translation: TranslatedString;
+}
+interface TranslationsDbPathOptions {
+    project: string;
+    mode: TranslationsDocMode;
+}
+type TranslationsLocaleDocDbPathOptions = TranslationsDbPathOptions & {
+    id: string;
+    locale: string;
+};
+/**
+ * A translations map containing translations for multiple locales.
+ *
+ * Example:
+ * ```
+ * {
+ *   "one": {"es": "uno", "fr": "un"},
+ *   "two": {"es": "dos", "fr": "deux"}
+ * }
+ * ```
+ */
+export interface MultiLocaleTranslationsMap {
+    [source: SourceString]: {
+        [locale: Locale]: TranslatedString;
+    };
+}
+/**
+ * A translations map containing translations for a single locale.
+ *
+ * Example:
+ * ```
+ * {
+ *   "one": "uno",
+ *   "two": "dos"
+ * }
+ * ```
+ */
+export interface SingleLocaleTranslationsMap {
+    [source: SourceString]: TranslatedString;
+}
+export declare class TranslationsManager {
+    cmsClient: RootCMSClient;
+    constructor(cmsClient: RootCMSClient);
+    /**
+     * Saves draft translations for a translations doc id.
+     *
+     * Example:
+     * ```
+     * const strings = {
+     *   'one': {es: 'uno', fr: 'un'},
+     *   'two': {es: 'dos', fr: 'deux'},
+     * };
+     * await tm.saveTranslations('Pages/index', strings);
+     * ```
+     */
+    saveTranslations(id: string, strings: MultiLocaleTranslationsMap, options?: {
+        tags?: string[];
+        modifiedBy?: string;
+    }): Promise<void>;
+    /**
+     * Publishes a translations doc.
+     */
+    publishTranslations(id: string, options?: {
+        batch?: WriteBatch;
+        publishedBy?: string;
+    }): Promise<void>;
+    /**
+     * Fetches translations from one or more translations docs in the translations
+     * manager.
+     *
+     * Example:
+     * ```
+     * await tm.loadTranslations();
+     * // =>
+     * // {
+     * //   "one": {"es": "uno", "fr": "un"},
+     * //   "two": {"es": "dos", "fr": "deux"}
+     * // }
+     * ```
+     *
+     * To load a specific set of translations docs by id:
+     * ```
+     * const translationsToLoad = ['Global/strings', 'Global/header', 'Global/footer', 'Pages/index'];
+     * await tm.loadTranslations({ids: translationsToLoad});
+     * // =>
+     * // {
+     * //   "one": {"es": "uno", "fr": "un"},
+     * //   "two": {"es": "dos", "fr": "deux"}
+     * // }
+     * ```
+     *
+     * To load a subset of locales (more performant):
+     * ```
+     * await tm.loadTranslations({locales: ['es']});
+     * // =>
+     * // {
+     * //   "one": {"es": "uno"},
+     * //   "two": {"es": "dos"}
+     * // }
+     * ```
+     */
+    loadTranslations(options?: {
+        ids?: string[];
+        tags?: string[];
+        locales?: Locale[];
+        mode?: TranslationsDocMode;
+    }): Promise<MultiLocaleTranslationsMap>;
+    /**
+     * Fetches translations for a given locale, with optional fallbacks.
+     * The return value is a map of source string to translated string.
+     *
+     * Example:
+     * ```
+     * await translationsDoc.loadTranslationsForLocale('es');
+     * // =>
+     * // {
+     * //   "one": "uno",
+     * //   "two": "dos",
+     * // }
+     * ```
+     */
+    loadTranslationsForLocale(locale: Locale, options?: {
+        mode?: TranslationsDocMode;
+        fallbackLocales?: Locale[];
+    }): Promise<SingleLocaleTranslationsMap>;
+    /**
+     * Converts a multi-locale translations map to a flat single-locale map,
+     * with optional support for fallback locales.
+     *
+     * ```
+     * const multiLocaleStrings = {
+     *   'one': {es: 'uno', fr: 'un'},
+     *   'two': {es: 'dos', fr: 'deux'}
+     * };
+     * translationsDoc.toSingleLocaleMap(multiLocaleStrings, ['es']);
+     * // =>
+     * // {
+     * //   "one": "uno",
+     * //   "two": "dos",
+     * // }
+     * ```
+     */
+    private toSingleLocaleMap;
+    /**
+     * Converts a multi-locale translations map to a single-locale hashed version,
+     * used for storage in in the DB.
+     *
+     * ```
+     * const multiLocaleStrings = {
+     *   'one': {es: 'uno', fr: 'un'},
+     *   'two': {es: 'dos', fr: 'deux'}
+     * };
+     * translationsDoc.toLocaleDocHashMap(multiLocaleStrings, 'es');
+     * // =>
+     * // {
+     * //   "<hash1>": {"source": "one", "translation": "uno"},
+     * //   "<hash2>": {"source": "two", "translation": "dos"},
+     * // }
+     * ```
+     *
+     * One reason for using hashes is because the DB has limits on the number of
+     * chars that can be used as the "key" in a object map.
+     */
+    private toLocaleDocHashMap;
+    /**
+     * Import translations from the v1 system to the TranslationsManager.
+     */
+    importTranslationsFromV1(): Promise<void>;
+}
+export declare function buildTranslationsDbPath(options: TranslationsDbPathOptions): string;
+export declare function buildTranslationsLocaleDocDbPath(options: TranslationsLocaleDocDbPathOptions): string;
+export {};

package/dist/core/translations.d.ts

@@ -0,0 +1,83 @@
+import type { CMSService, CMSServiceContext } from './services.js';
+/** A row of translation data keyed by locale. */
+export interface TranslationRow {
+    /** The source string. */
+    source: string;
+    /** Map of locale code to translated string. */
+    translations: Record<string, string>;
+    /** Optional translator notes/context for the source string. */
+    description?: string;
+}
+/** Context passed to translation service import/export functions. */
+export interface TranslationServiceContext extends CMSServiceContext {
+    /** The document ID, e.g. `Pages/index`. */
+    docId: string;
+    /** The collection ID, e.g. `Pages`. */
+    collectionId: string;
+    /** The slug, e.g. `index`. */
+    slug: string;
+    /** The locales configured for the project. */
+    locales: string[];
+    /** The email of the user performing the action. */
+    user: {
+        email: string;
+    };
+}
+/** Result returned by an onExport handler. */
+export interface TranslationExportResult {
+    /** Optional title displayed in the notification after export. */
+    title?: string;
+    /** Optional message displayed in the notification after export. */
+    message?: string;
+    /** Optional link displayed in the notification (e.g. to the translation service). */
+    link?: {
+        /** The URL to link to. */
+        url: string;
+        /** Optional label for the link. Defaults to "Open". */
+        label?: string;
+    };
+    /**
+     * Notification status controlling the color of the notification.
+     * - `'success'`: green
+     * - `'error'`: red
+     * - `'info'` (default): neutral
+     */
+    status?: 'success' | 'info' | 'error';
+}
+/** Result returned by an onImport handler when no rows are imported. */
+export interface TranslationImportResult {
+    /** Optional title displayed in the notification after import. */
+    title?: string;
+    /** Optional message displayed in the notification after import. */
+    message?: string;
+    /** Optional link displayed in the notification (e.g. to the translation service). */
+    link?: {
+        /** The URL to link to. */
+        url: string;
+        /** Optional label for the link. Defaults to "Open". */
+        label?: string;
+    };
+    /**
+     * Notification status controlling the color of the notification.
+     * - `'success'`: green
+     * - `'error'`: red
+     * - `'info'` (default): neutral
+     */
+    status?: 'success' | 'info' | 'error';
+}
+/** Configuration for defining a CMS translation service. */
+export interface CMSTranslationService extends CMSService {
+    /**
+     * Async function to import translations from the service. Should return an
+     * array of translation rows that will be merged into the CMS translations
+     * database, or a `TranslationImportResult` object to display a notification
+     * without importing any rows.
+     */
+    onImport?: (ctx: TranslationServiceContext, data: TranslationRow[]) => Promise<TranslationRow[] | TranslationImportResult>;
+    /**
+     * Async function to export translations to the service. Receives the
+     * current translation rows for the document. Can optionally return an object
+     * with a `message` to display in the success notification.
+     */
+    onExport?: (ctx: TranslationServiceContext, data: TranslationRow[]) => Promise<void | TranslationExportResult>;
+}

package/dist/core/url-safety.d.ts

@@ -0,0 +1,19 @@
+export interface AssertUrlOptions {
+    /** Allowed URL schemes. Defaults to `['https:']`. */
+    allowedSchemes?: string[];
+}
+export declare class UnsafeUrlError extends Error {
+    constructor(message: string);
+}
+/**
+ * Throws `UnsafeUrlError` if `input` is a URL that could be used to reach
+ * an internal/cloud-metadata endpoint via SSRF. Validation covers the
+ * scheme, the literal hostname, and the resolved DNS addresses.
+ *
+ * Caveats: this does NOT defend against time-of-check / time-of-use races
+ * (a hostname that resolves to a public IP at check time and a private IP
+ * milliseconds later), nor against redirects followed by the downstream
+ * HTTP client. Callers that follow redirects must re-validate each hop, or
+ * use an HTTP client configured to refuse private IPs at the socket layer.
+ */
+export declare function assertPublicHttpUrl(input: string, options?: AssertUrlOptions): Promise<URL>;

package/dist/core/validation.d.ts

@@ -0,0 +1,30 @@
+import type { FieldWithId, Schema } from './schema.js';
+/**
+ * Represents a validation error for a field.
+ */
+export interface ValidationError {
+    /** The path to the field, e.g., "meta.title" or "content.blocks[0].text". */
+    path: string;
+    /** Human-readable error message. */
+    message: string;
+    /** Expected type or value. */
+    expected?: string;
+    /** Actual value received. */
+    received?: any;
+}
+/**
+ * Validates field data against a schema.
+ *
+ * This function validates `fieldsData` against the provided `schema`. It
+ * supports both partial validation (validates only fields present in the data)
+ * and full document validation.
+ *
+ * @param fieldsData - The data to validate.
+ * @param schema - The schema defining the expected structure.
+ * @returns An array of validation errors. Empty array if validation passes.
+ */
+export declare function validateFields(fieldsData: any, schema: Schema): ValidationError[];
+/**
+ * Validates a single value against a field definition.
+ */
+export declare function validateValue(value: any, field: FieldWithId, path: string): ValidationError[];

package/dist/core/values.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sets a value at a JSON path in an object.
+ * Supports dot notation for nested objects and array indices.
+ * Examples:
+ *   setValueAtPath(obj, 'title', 'New Title')
+ *   setValueAtPath(obj, 'hero.title', 'New Title')
+ *   setValueAtPath(obj, 'content.0.text', 'First item')
+ */
+export declare function setValueAtPath(obj: any, path: string, value: any): void;

package/dist/core/versions.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Document verion history.
+ *
+ * Verions save the state of a document at different moments in time, allowing
+ * users to revert back to a version if/when needed.
+ *
+ * The saveVersions() function is meant to be run within a cron job (e.g using
+ * firebase functions). Every minute, the runner checks for all documents that
+ * have been edited since the last run. To avoid saving "partial" versions
+ * (when the user might be in the middle of editing a document), versions only
+ * run on documents that haven't been edited within the last 5 mins to ensure
+ * that version is "stable".
+ *
+ * In the database, versions are stored as:
+ * /Projects/<projectId>/Collections/<collectionId>/Drafts/<docId>/Versions/<timestamp>
+ *
+ * Where <timestamp> is the unix timestamp (millis) that the document was last
+ * edited.
+ */
+import { RootConfig } from '@blinkk/root';
+export declare class VersionsService {
+    private readonly rootConfig;
+    private readonly projectId;
+    private readonly db;
+    constructor(rootConfig: RootConfig);
+    /**
+     * Saves a version of all documents that have been edited since the last run.
+     */
+    saveVersions(): Promise<void>;
+    private saveVersionsToFirestore;
+    /**
+     * Returns the last time (in millis) saveVersions() was run, or 0 if has
+     * never been run.
+     */
+    private getLastRun;
+    /**
+     * Saves {versionLastRun: <timestamp>} to the Projects/<projectId> doc.
+     */
+    private saveLastRun;
+    /**
+     * Returns a list of all docs that were edited after a certain time.
+     */
+    private getDocsModifiedAfter;
+    /**
+     * Returns a list of collection ids for the Root project.
+     */
+    private listCollections;
+}

package/dist/core.js

@@ -16,7 +16,7 @@ import {
   translationsForLocale,
   unmarshalArray,
   unmarshalData
-} from "./chunk-2BSW7SIH.js";
+} from "./chunk-N4K6ICFR.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";

package/dist/edit-M4PN4SGX.js

@@ -0,0 +1,7 @@
+import "./chunk-MLKGABMK.js";
+
+// shared/ai/prompts/edit.txt
+var edit_default = 'Role: You are a highly accurate AI assistant specializing in converting unstructured documents into JSON files compatible with Root CMS. Root CMS is a web-based CMS for building websites and landing pages, storing its content as JSON files in a Firebase Firestore database.\n\nObjective: To edit and/or generate highly accurate JSON files compatible with Root CMS, based on user input (screenshots, chat messages, etc.) and, when editing JSON files, the original JSON file you are editing. The resulting content should contain all of the marketing content provided by the user input (and none of the annotations or superfluous content). The JSON files should be perfectly compatible with Root CMS.\n\nInput Requirements & Handling:\n\n- You will receive unstructured documents and you must convert them into JSON files compatible with Root CMS by either editing the existing JSON files or generating new ones from scratch. The JSON files you produce will typically represent a single section of a page of the website, such as a hero section, a feature section, or a footer.\n\n- When editing an existing JSON file, it will be annotated with a key `_type` that indicates the type of section it is, such as `Hero`, `Feature`, or `Footer`. You must ensure that the resulting JSON file is compatible with Root CMS and contains all of the marketing content provided by the user input. You will also be given a TypeScript interface in `root-cms.d.ts` that describes the structure of the JSON file you are editing. You must ensure that the resulting JSON file is compatible with this interface.\n\n- The input you receive will be broken into three parts. (1) `root-cms-d.ts` (the TypeScript interface), (2) the existing JSON file you are editing (or an empty JSON file when generating new content), and (3) the user input (screenshots, chat messages, instructions, etc.). You must ensure that the resulting JSON file is compatible with the structure defined by the TypeScript interface and contains all of the marketing content provided by the user input.\n\n- When you provide your response, if the user instructs you to only edit one part of the original JSON, make sure to leave the rest of the JSON file untouched. You must return the entire JSON document after applying changes. Never omit, rename, reorder or invent top-level keys. Copy all unmodified fields exactly as they appear in the input.\n\nRoot CMS JSON File Structure:\n\n1. Root CMS JSON files are standard JSON files described by the TypeScript interface in `root-cms.d.ts`. However, there is one critical syntax rule that you must understand and always follow regarding **Array fields**. An Array field is a list of repeated items \u2014 for example, a list of modules on a page, or a list of items within a module. The items in an Array field are always objects (e.g. `[{"foo": 1}, {"foo": 2}]`); an Array field never contains primitive values like `[1, 2, 3]` or `["a", "b"]`. Array fields are NOT stored as plain JSON arrays; instead they are expressed as hash maps. The order of the resulting data when Root CMS unmarshals the data is provided by a special key called `_array`. For example, to represent an Array field whose items are `[{"foo": 1}, {"foo": 2}]`, the JSON data may look like this. For each key, autogenerate a random 6-letter string (e.g. `kxmfqa`); never use human-readable names or numbers as keys.\n\n```json\n{\n  "_array": ["kxmfqa", "wnzrbh"],\n  "kxmfqa": {"foo": 1},\n  "wnzrbh": {"foo": 2}\n}\n```\n\nWhen creating an Array field in your JSON output, you must _never_ forget to add an `_array` key. If you forget to add an `_array` key to an Array field, the output will NOT work with Root CMS. When adding new array items, autogenerate a new random 6-letter key for each item.\n\nThe `_array` object notation applies ONLY to Array fields. Every OTHER array-shaped value is a plain JSON array and MUST NEVER be wrapped in an `_array` object. In particular:\n\n(a) Multiselect fields (typed as `string[]` in `root-cms.d.ts`) hold a list of selected option values and are stored as a plain JSON array of strings. For example, a multiselect value looks like `["option-a", "option-b"]`, NOT `{"_array": ["k1", "k2"], "k1": "option-a", "k2": "option-b"}`.\n\n(b) Reference fields that hold multiple references store a plain JSON array of reference objects, e.g. `[{"id": "Pages/home", "collection": "Pages", "slug": "home"}]`, never an `_array` object.\n\n(c) The `blocks` array inside a Rich Text field (see #3 below). Rich Text data is stored as-is and is NOT marshaled, so `blocks` MUST always be a plain JSON array, never an `_array` object.\n\nWrapping any of these in `_array` notation will corrupt the data when it is saved. Rule of thumb: never change the existing shape of an array in the JSON you are editing \u2014 if a value is already a plain JSON array, keep it a plain array; if it is already an `_array` object, keep it as an `_array` object.\n\n2. Images and file fields have system-provided metadata, that looks like this example:\n\n```\n{\n    "src": "https://storage.googleapis.com/rootjs-dev.appspot.com/www/uploads/2cad5d65bb7690bad5dcd4a041cf2fef46361678.svg",\n    "filename": "600x400.svg",\n    "uploadedAt": "1754023634564",\n    "alt": "",\n    "width": "600",\n    "uploadedBy": "user@example.com",\n    "height": "400"\n}\n```\n\n3. Rich Text fields are stored as Editor.js / Lexical documents, which look like this. You may generate your own UIDs for the `id` fields. Note that `blocks` MUST be a plain JSON array \u2014 do NOT use the `_array` object notation here.\n\n```\n{\n  "version": "2.28.2",\n  "time": 1754024041637,\n  "blocks": [\n    {\n      "type": "paragraph",\n      "data": {\n        "text": "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. <a href=\\"https://example.com\\">This accepts HTML</a>."\n      },\n      "id": "_8PEf3kBx2"\n    },\n    {\n      "data": {\n        "style": "unordered",\n        "items": [\n          {\n            "content": "This is list item 1.",\n            "items": []\n          },\n          {\n            "items": [],\n            "content": "This is list item 2."\n          }\n        ]\n      },\n      "id": "G5zMDP1ytM",\n      "type": "unorderedList"\n    }\n  ]\n}\n```\n\n4. Root CMS supports "oneOf" fields, where values can be "one of" another schema. These are typically used as array values or object values, where the user can from one of other schema types to structure the data value. For example, each module in a page\'s module list is "one of" the modules available in the library. One of values have a system-provided `_type` key that describes the type of the value. For example, this is a hero module, whose type is "TemplateHeadline", one of the available templates from the module library:\n\n```\n{\n  "eyebrow": "Lorem ipsum",\n  "_type": "TemplateHeadline",\n  "body": {\n    "time": 1754023554170,\n    "version": "2.28.2",\n    "blocks": [\n      {\n        "type": "paragraph",\n        "data": {\n          "text": "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat."\n        },\n        "id": "IVmxEVsxmt"\n      },\n      {\n        "id": "aMiHiywkQD",\n        "type": "paragraph",\n        "data": {\n          "text": "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."\n        }\n      }\n    ]\n  },\n  "title": "Welcome to our website"\n}\n```\n\nWhen adding new items to arrays that use `oneOf` fields, try your best to figure out which content type would best satisfy the user\'s request. You must never _invent_ new content types, for example, if "TemplateFoo" doesn\'t exist in `root-cms.d.ts`, you must never add a value with `{"_type": "TemplateFoo"}`. If none of the available content types within `root-cms.d.ts` satisfy the user\'s request, avoid creating the new array item and inform the user that there is no existing template compatible.\n\nAdditionally, when adding new items to existing JSON data, you must carefully check the structure of those items as defined by `root-cms.d.ts`. Avoid inventing new fields for content types, use only those defined by the `root-cms.d.ts`. For example, if you are adding a button to a module, carefully check the button structure defined in `root-cms.d.ts` and only populate fields that are defined there.\n';
+export {
+  edit_default as default
+};

package/dist/functions.js

@@ -1,12 +1,12 @@
 import {
   runCronJobs
-} from "./chunk-BGTUWIV6.js";
-import "./chunk-C245C557.js";
-import "./chunk-2BSW7SIH.js";
+} from "./chunk-PNLLZXVY.js";
+import "./chunk-RXWDB3K4.js";
+import "./chunk-N4K6ICFR.js";
 import "./chunk-MLKGABMK.js";
 
 // core/functions.ts
-import path from "path";
+import path from "node:path";
 import { loadBundledConfig } from "@blinkk/root/node";
 import { onSchedule } from "firebase-functions/v2/scheduler";
 function cron(options) {

package/dist/{generate-types-SPV7I3A5.js → generate-types-JWIG4QVI.js}

@@ -1,7 +1,7 @@
 import {
   generateSchemaDts,
   generateTypes
-} from "./chunk-XLX37FRL.js";
+} from "./chunk-TEKMLYXS.js";
 import "./chunk-MLKGABMK.js";
 export {
   generateSchemaDts,