rimecms 0.31.4 → 0.32.0

package/dist/core/prototype/collection/upload/util/converter.server.js

@@ -0,0 +1,127 @@
+import { RimeError } from '../../../../errors/index.js';
+import { logger } from '../../../../logger.server.js';
+import { fileSizeToString } from '../../../../../util/file.js';
+import { readFile } from 'fs/promises';
+import fs from 'fs';
+import path from 'path';
+import { getExtensionFromMimeType, getMimeTypeFromExtension } from './mime.js';
+export const jsonFileToFile = (jsonFile) => {
+    // Convert base64 to Blob
+    const base64String = jsonFile.base64;
+    // Extract the actual base64 content after the data URI prefix
+    const base64Content = base64String.split(',')[1];
+    if (!base64Content) {
+        throw new RimeError(RimeError.UPLOAD, 'Invalid base64 data format');
+    }
+    try {
+        const byteCharacters = atob(base64Content);
+        const byteNumbers = new Array(byteCharacters.length);
+        for (let i = 0; i < byteCharacters.length; i++) {
+            byteNumbers[i] = byteCharacters.charCodeAt(i);
+        }
+        const byteArray = new Uint8Array(byteNumbers);
+        // Guess file type if not provided
+        let mimeType = jsonFile.mimeType;
+        if (!mimeType) {
+            const base64Header = base64String.split(';')[0].split(':')[1];
+            if (base64Header) {
+                mimeType = base64Header;
+            }
+            else {
+                mimeType = 'application/octet-stream';
+            }
+        }
+        const extension = getExtensionFromMimeType(mimeType);
+        if (!extension) {
+            throw new RimeError(RimeError.UPLOAD, 'File type not supported');
+        }
+        const blob = new Blob([byteArray], { type: mimeType });
+        const filename = jsonFile.filename || `file-${Date.now()}.${extension}`;
+        const lastModified = jsonFile.lastModified || Date.now();
+        const filesize = fileSizeToString(jsonFile.filesize || blob.size);
+        return {
+            filename,
+            mimeType,
+            filesize,
+            file: new File([blob], filename, {
+                type: mimeType,
+                lastModified: lastModified
+            })
+        };
+    }
+    catch (err) {
+        logger.error('Error converting base64 to File:', err.message);
+        throw new RimeError(RimeError.UPLOAD, 'Invalid base64 content');
+    }
+};
+/** Used by the e2e suites — each fixture's `api.test.ts` — to post an upload as base64. */
+export async function filePathToBase64(filePath) {
+    try {
+        const data = await readFile(filePath);
+        const ext = filePath.split('.').pop()?.toLowerCase() || '';
+        const mimeType = getMimeTypeFromExtension(ext);
+        if (!mimeType) {
+            throw new Error(`Unsupported file extension: ${ext}`);
+        }
+        const base64 = data.toString('base64');
+        return `data:${mimeType};base64,${base64}`;
+    }
+    catch (error) {
+        logger.error('Error converting file path to base64:', error.message);
+        throw error;
+    }
+}
+/**
+ * Convert a filepath to a File like object
+ * @param filePath - Absolute path to the file
+ * @returns A File-like object with necessary properties and methods
+ * @example
+ * const file = await filePathToFile('/path/to/image.jpg');
+ */
+export async function filePathToFile(filePath) {
+    try {
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            throw new RimeError(RimeError.UPLOAD, `File not found: ${filePath}`);
+        }
+        // Read file stats and content
+        const fileStats = fs.statSync(filePath);
+        const buffer = fs.readFileSync(filePath);
+        // Get filename and extension
+        const filename = path.basename(filePath);
+        const ext = path.extname(filePath).slice(1).toLowerCase();
+        const mimeType = getMimeTypeFromExtension(ext) || 'application/octet-stream';
+        // Create a Blob with the file content
+        const blob = new Blob([new Uint8Array(buffer)], { type: mimeType });
+        // Create and return a File object
+        return new File([blob], filename, {
+            type: mimeType,
+            lastModified: fileStats.mtimeMs
+        });
+    }
+    catch (error) {
+        logger.error('Error creating File from path:', error.message);
+        throw new RimeError(RimeError.UPLOAD, `Failed to create File from path: ${error.message}`);
+    }
+}
+/**
+ * The file a stored document already has, as a `File`.
+ *
+ * One call, so a caller never spells out where upload keeps its files —
+ * `disk/save.server.ts` and `disk/delete.server.ts` own that convention.
+ *
+ * `undefined` when the document has no file, so a caller asking "does it have one?" and "give it
+ * to me" makes one call, not two.
+ */
+export async function fileForDocument(doc) {
+    if (typeof doc.filename !== 'string' || !doc.filename)
+        return undefined;
+    const filePath = path.resolve(process.cwd(), 'static', 'medias', doc.filename);
+    try {
+        return await filePathToFile(filePath);
+    }
+    catch (err) {
+        logger.error(`Failed to create file from path: ${filePath}`, err);
+        return undefined;
+    }
+}

package/dist/core/prototype/collection/upload/util/path.d.ts

@@ -0,0 +1,69 @@
+import { UPLOAD_PATH } from '../constant.js';
+import type { CollectionSlug } from '../../../types.js';
+import type { Route } from '../../../../../panel/types.js';
+export type UploadPath = `${typeof UPLOAD_PATH.ROOT_NAME}${string}`;
+/**
+ * Validates that a path string follows the required format:
+ * - Must start with ROOT_NAME
+ * - Only allows alphanumeric characters, hyphens, underscores, spaces, and the separator
+ * - Can only use the defined separator
+ * @example
+ * validatePath("root:folder:subfolder") // valid
+ * validatePath("root:folder with spaces:sub-folder_name") // valid
+ * validatePath("root/folder") // throws Error
+ * validatePath("root:folder$") // throws Error
+ */
+/**
+ * Given an optional path string
+ * this returns:
+ * - the name (last part of the segment)
+ * - the parent path (path without the name)
+ * - the normalized path
+ * @example
+ * getSegments("root:foo:bar") // { name: "bar", parent: "root:foo", path: "root:foo:bar" }
+ * getSegments("root") // { name: "root", parent: null, path: "root" }
+ */
+export declare function getSegments(path?: UploadPath | null): {
+    name: string;
+    path: UploadPath;
+    parent: UploadPath | null;
+};
+/**
+ * Get the parent path for a given path
+ * or return null if path is ROOT_NAME
+ * @example
+ * // returns 'root'
+ * getParentPath('root:foo')
+ */
+export declare function getParentPath(path: UploadPath): string | null;
+/**
+ * One breadcrumb per folder in the path, each linking to the collection list filtered to that
+ * folder. The root segment is dropped — it is the collection itself.
+ *
+ * Every entry carries a url, the last one included. `removePathFromLastAria` strips it.
+ *
+ * @example
+ * buildUploadAria({ path: 'root:foo:bar', slug: 'medias', panelSegment: 'panel' })
+ * // [
+ * //   { title: 'foo', url: '/panel/medias?uploadPath=root:foo' },
+ * //   { title: 'bar', url: '/panel/medias?uploadPath=root:foo:bar' }
+ * // ]
+ */
+export declare function buildUploadAria({ path, slug, panelSegment }: {
+    path: UploadPath;
+    slug: CollectionSlug;
+    panelSegment: string;
+}): Partial<Route>[];
+export declare function removePathFromLastAria(aria: Partial<Route>[]): Partial<Route>[];
+/**
+ * Validates that a path string follows the required format:
+ * - Must start with ROOT_NAME
+ * - Only allows alphanumeric characters, hyphens, underscores, spaces, and the separator
+ * - Can only use the defined separator
+ * @example
+ * validatePath("root:folder:subfolder") // valid
+ * validatePath("root:folder with spaces:sub-folder_name") // valid
+ * validatePath("root/folder") // invalid
+ * validatePath("root:folder$") // invalid
+ */
+export declare const validatePath: (value: unknown) => string | true;

package/dist/core/prototype/collection/upload/util/path.js

@@ -0,0 +1,143 @@
+import { PARAMS } from '../../../../constants.js';
+import { RimeError } from '../../../../errors/index.js';
+import { UPLOAD_PATH } from '../constant.js';
+import { joinPath } from '../../../../routes/util.js';
+import { toKebabCase } from '../../../../../util/string.js';
+/**
+ * Validates that a path string follows the required format:
+ * - Must start with ROOT_NAME
+ * - Only allows alphanumeric characters, hyphens, underscores, spaces, and the separator
+ * - Can only use the defined separator
+ * @example
+ * validatePath("root:folder:subfolder") // valid
+ * validatePath("root:folder with spaces:sub-folder_name") // valid
+ * validatePath("root/folder") // throws Error
+ * validatePath("root:folder$") // throws Error
+ */
+/**
+ * Given an optional path string
+ * this returns:
+ * - the name (last part of the segment)
+ * - the parent path (path without the name)
+ * - the normalized path
+ * @example
+ * getSegments("root:foo:bar") // { name: "bar", parent: "root:foo", path: "root:foo:bar" }
+ * getSegments("root") // { name: "root", parent: null, path: "root" }
+ */
+export function getSegments(path) {
+    // Use nullish coalescing to handle both undefined and null
+    const safePath = path ?? UPLOAD_PATH.ROOT_NAME;
+    // Validate and normalize the path
+    const isValid = validatePath(safePath);
+    if (typeof isValid === 'string') {
+        throw new RimeError(RimeError.BAD_REQUEST, isValid);
+    }
+    const segments = safePath
+        .split(UPLOAD_PATH.SEPARATOR)
+        .filter((s) => s !== UPLOAD_PATH.SEPARATOR)
+        .filter((s) => !!s);
+    if (segments.length <= 1) {
+        return {
+            name: UPLOAD_PATH.ROOT_NAME,
+            path: UPLOAD_PATH.ROOT_NAME,
+            parent: null
+        };
+    }
+    const name = segments[segments.length - 1];
+    // Only create parent if we have more than one segment
+    const parent = segments.length > 1 ? segments.slice(0, -1).join(UPLOAD_PATH.SEPARATOR) : null;
+    // Reconstruct the normalized path from filtered segments
+    const normalizedPath = segments.join(UPLOAD_PATH.SEPARATOR);
+    return {
+        name,
+        parent: parent,
+        path: normalizedPath
+    };
+}
+/**
+ * Get the parent path for a given path
+ * or return null if path is ROOT_NAME
+ * @example
+ * // returns 'root'
+ * getParentPath('root:foo')
+ */
+export function getParentPath(path) {
+    if (path === UPLOAD_PATH.ROOT_NAME)
+        return null;
+    return path.split(UPLOAD_PATH.SEPARATOR).slice(0, -1).join(UPLOAD_PATH.SEPARATOR);
+}
+/**
+ * One breadcrumb per folder in the path, each linking to the collection list filtered to that
+ * folder. The root segment is dropped — it is the collection itself.
+ *
+ * Every entry carries a url, the last one included. `removePathFromLastAria` strips it.
+ *
+ * @example
+ * buildUploadAria({ path: 'root:foo:bar', slug: 'medias', panelSegment: 'panel' })
+ * // [
+ * //   { title: 'foo', url: '/panel/medias?uploadPath=root:foo' },
+ * //   { title: 'bar', url: '/panel/medias?uploadPath=root:foo:bar' }
+ * // ]
+ */
+export function buildUploadAria({ path, slug, panelSegment }) {
+    const segments = path.split(':');
+    const result = [];
+    let currentPath = '';
+    for (const segment of segments) {
+        if (!segment)
+            continue;
+        currentPath = currentPath ? `${currentPath}:${segment}` : segment;
+        if (currentPath !== segments[0]) {
+            result.push({
+                title: segment,
+                url: `${joinPath(panelSegment, toKebabCase(slug))}?${PARAMS.UPLOAD_PATH}=${currentPath}`
+            });
+        }
+    }
+    return result;
+}
+export function removePathFromLastAria(aria) {
+    return aria.map((route, index) => {
+        if (index === aria.length - 1) {
+            return { title: route.title };
+        }
+        return route;
+    });
+}
+/**
+ * Validates that a path string follows the required format:
+ * - Must start with ROOT_NAME
+ * - Only allows alphanumeric characters, hyphens, underscores, spaces, and the separator
+ * - Can only use the defined separator
+ * @example
+ * validatePath("root:folder:subfolder") // valid
+ * validatePath("root:folder with spaces:sub-folder_name") // valid
+ * validatePath("root/folder") // invalid
+ * validatePath("root:folder$") // invalid
+ */
+export const validatePath = (value) => {
+    if (typeof value !== 'string') {
+        return 'path should be a string';
+    }
+    // Check if path starts with ROOT_NAME
+    const STARTS_WITH_ROOT = value === UPLOAD_PATH.ROOT_NAME || value.startsWith(`${UPLOAD_PATH.ROOT_NAME}:`);
+    if (!STARTS_WITH_ROOT) {
+        return `Path must start with "${UPLOAD_PATH.ROOT_NAME}"`;
+    }
+    // Create a mutable copy for normalization
+    let normalizedPath = value;
+    // Remove trailing separator if present
+    while (normalizedPath !== UPLOAD_PATH.ROOT_NAME &&
+        normalizedPath.endsWith(UPLOAD_PATH.SEPARATOR)) {
+        normalizedPath = normalizedPath.slice(0, -1);
+    }
+    // Only allow alphanumeric characters, hyphens, underscores, spaces, and the separator
+    // The regex ensures:
+    // 1. Starts with ROOT_NAME
+    // 2. Followed by zero or more segments (each segment starts with separator followed by valid chars)
+    const validPathRegex = new RegExp(`^${UPLOAD_PATH.ROOT_NAME}(${UPLOAD_PATH.SEPARATOR}[a-zA-Z0-9\\-_ ]+)*$`);
+    if (!validPathRegex.test(normalizedPath)) {
+        return 'Path contains invalid characters. Only alphanumeric characters, hyphens, underscores, and spaces are allowed.';
+    }
+    return true;
+};

package/dist/core/prototype/define.d.ts

@@ -0,0 +1,112 @@
+import type { Adapter } from '../adapter.js';
+import type { BuiltArea, BuiltCollection, RouteConfig } from '../config/types.js';
+import type { AnyHook, HookTiming, OperationQuery } from '../pipeline/types.js';
+import type { Dic } from '../../util/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+import type { GenericDoc } from './types.js';
+/**
+ * A prototype **defines** a kind of thing rime stores, and brings its own surface with it.
+ *
+ * | layer         | verb                   | scale                        |
+ * | ------------- | ---------------------- | ---------------------------- |
+ * | **prototype** | *defines*              | the base thing itself        |
+ * | **feature**   | *augments and extends* | large — across prototypes    |
+ * | **plugin**    | *augments*             | small                        |
+ *
+ * So `collection` and `area` are two definitions built to the same pattern, not one
+ * implementation with a discriminator. Nothing here knows there are two of them, which is what
+ * makes a third cost only its own folder.
+ *
+ * A definition carries no config — it is the kind, not an instance. `config.type` is the name it
+ * is registered under, and that is what pairs the two.
+ */
+export type BuiltPrototype = BuiltArea | BuiltCollection;
+export type PrototypeDefinition<C extends BuiltPrototype = BuiltPrototype> = {
+    /** The kind's name, and the `type` every config it builds carries. */
+    name: string;
+    /**
+     * Every augment this prototype runs, in order — its own and its features', one written list.
+     *
+     * ```ts
+     * augments: () => [augmentLabel, when(isAuth, augmentAuth), augmentTitle]
+     * ```
+     *
+     * **A function returning the list, not the list.** Several steps come from `$rime/modules`, and
+     * a feature reached through the barrel imports `create` back out of this definition —
+     * `auth/staff/configure.ts` and `versions/configure.server.ts` both do. Entered from the
+     * feature's side, an array literal captures bindings the barrel has not initialised, and the
+     * config builds without those fields: no error, no type change, just a document with no title.
+     * Building the list on first `create` reads every binding after every module has finished.
+     *
+     * `any` because each augment names the shape it needs, and a list holding several cannot
+     * promise any of them that shape.
+     */
+    augments?: () => readonly ((config: any) => any)[];
+    /**
+     * Every hook this prototype can run, in the order it runs them — including its features'.
+     *
+     * The order is written down, not computed; see `collection/hooks.server.ts`. `buildPipeline`
+     * decides only *which* of them a config runs, from the feature each hook names.
+     */
+    hooks?: Partial<Record<HookTiming, AnyHook[]>>;
+    /**
+     * The config factory. **Composed by `definePrototype`, never passed in**: `augments`, then
+     * `features`, then the shaping every prototype does the same way.
+     *
+     * Typed loosely here and narrowed where it is re-exported — a prototype's authoring type is
+     * generic in the slug and no type parameter can carry a generic type, so
+     * `collection/definition.ts` re-exports a one-line `create` stating its own signature.
+     */
+    create: (slug: string, config: Dic) => C;
+    /** Run once per process, per config of this kind, before any request is served. */
+    boot?: (args: PrototypeBootArgs<C>) => Promise<void>;
+    /**
+     * The REST surface, keyed by sub-path **under `/api/[slug=<name>]`** — `''`, `'[id]'`,
+     * `'[id]/duplicate'`. Not an absolute pathname like a plugin's: a prototype has no URL of its
+     * own, only slugs the author's config supplies.
+     *
+     * `dev/codegen/routes/` writes the `+server.ts` files from this and `handlers/routes.server.ts`
+     * dispatches through it, so an endpoint exists by being declared here and nowhere else.
+     */
+    rest?: Record<string, RouteConfig>;
+};
+export type PrototypeBootArgs<C extends BuiltPrototype = BuiltPrototype> = {
+    /** A config of this definition's own kind — boot.server.ts pairs them by name. */
+    config: C;
+    adapter: Adapter;
+    defaultLocale?: string;
+};
+/**
+ * What a definition's operations are handed: the request, the config, and the plumbing that would
+ * otherwise be written out once per prototype.
+ *
+ * Per-call, not per-process — `isSystemOperation` is part of it, so `.system()` is a second
+ * context rather than a flag anybody has to remember to forward.
+ */
+export type PrototypeApiContext<C extends BuiltPrototype = BuiltPrototype> = {
+    config: C;
+    event: RequestEvent;
+    defaultLocale: string | undefined;
+    /** True when rime itself is the caller: access checks and some hooks stand down. */
+    isSystemOperation: boolean;
+    /** The locale to act in: the one asked for, else the request's, else the config's default. */
+    fallbackLocale(locale?: string): string | undefined;
+    /** A document of this config's shape with every default applied, and no id. */
+    blank(): GenericDoc;
+    /**
+     * Which **version row** a read means. `undefined` for a config that is not versioned, which is
+     * "the document's own row". See `versionsReadQuery`.
+     */
+    versionQuery(params: {
+        latest?: boolean;
+        versionId?: string;
+    }): OperationQuery | undefined;
+    /**
+     * Read through the API cache when it is on and this is not a system call. `key` is merged on top
+     * of what every read shares — the slug and who is asking.
+     */
+    cached<T>(operation: string, key: Dic, read: () => Promise<T>): Promise<T>;
+};
+type PrototypeOptions<C extends BuiltPrototype> = Partial<Omit<PrototypeDefinition<C>, 'create'>>;
+export declare const definePrototype: <C extends BuiltPrototype = BuiltPrototype>(options?: PrototypeOptions<C>) => PrototypeDefinition<C>;
+export {};

package/dist/core/prototype/define.js

@@ -0,0 +1,50 @@
+import { isStaff } from '../auth/access.js';
+import { FileText } from '@lucide/svelte';
+import { prototypeKebab } from './naming.js';
+export const definePrototype = (options = {}) => {
+    const name = options.name ?? '';
+    // Defaulted rather than optional: `buildPipeline` filters it on every config, and a prototype
+    // with no features is a real case. `hooks` stays optional — a missing timing is already none.
+    const augments = options.augments ?? (() => []);
+    /**
+     * One chain, stated once for every prototype: `_titleFallback` first, then every augment the
+     * prototype lists, in the order it lists them — which is column order.
+     *
+     * `_titleFallback` seeds `'id'`; `auth` and `upload` override it in their own augments, which is
+     * where a preference about what names a document belongs.
+     *
+     * No hooks step. A config's pipeline is resolved once the whole config exists — see
+     * `pipeline/build.server.ts` — so a derived config resolves by the same line as an authored one.
+     */
+    const create = (slug, incomingConfig) => {
+        const initial = { ...incomingConfig, slug, _titleFallback: 'id' };
+        const augmented = augments().reduce((current, augment) => augment(current), initial);
+        return {
+            ...augmented,
+            type: name,
+            slug,
+            kebab: prototypeKebab(slug),
+            fields: augmented.fields || [],
+            icon: augmented.icon || FileText,
+            live: augmented.live || false,
+            /**
+             * Staff-only until the author says otherwise, and the policy is auth's own `isStaff`.
+             */
+            access: {
+                create: isStaff,
+                read: isStaff,
+                update: isStaff,
+                delete: isStaff,
+                ...augmented.access
+            }
+        };
+    };
+    return {
+        name,
+        augments,
+        create,
+        hooks: options.hooks,
+        boot: options.boot,
+        rest: options.rest
+    };
+};

package/dist/core/prototype/doc.d.ts

@@ -0,0 +1,31 @@
+import type { GenericDoc } from './types.js';
+import type { BuiltArea, BuiltCollection } from '../../types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * Creates a blank document based on a collection or area configuration.
+ * Initializes all fields with appropriate default values based on their type.
+ *
+ * @returns A new blank document with default values for all fields
+ *
+ * @example
+ * // Create a blank document for the 'pages' collection
+ * const blankPage = createBlankDocument(config.getCollection('pages'));
+ */
+export declare const createBlankDocument: <C extends BuiltCollection | BuiltArea, T extends GenericDoc = GenericDoc>(config: C, event?: RequestEvent) => T;
+/**
+ * Converts a flat array of documents into a nested tree structure based on parent-child relationships.
+ * Documents are organized hierarchically with each document containing its children in the _children property.
+ *
+ * @param documents - Array of documents with parent properties indicating their relationships
+ * @returns A nested tree structure where each document contains its children
+ *
+ * @example
+ * // Convert a flat list of pages into a hierarchical structure
+ * const pageTree = toNestedStructure(pagesList);
+ * // Result: [{ id: '1', _children: [{ id: '2', _children: [] }] }]
+ */
+/**
+ * Converts a flat array of documents into a nested tree structure
+ * based on _parent and _position fields
+ */
+export declare const toNestedStructure: (documents: GenericDoc[]) => GenericDoc[];

package/dist/core/prototype/doc.js

@@ -0,0 +1,118 @@
+import { FormFieldBuilder } from '../fields/builders/form-field-builder.js';
+import { GroupFieldBuilder } from '../../fields/group/index.js';
+import { TabsBuilder } from '../../fields/tabs/index.js';
+import { snapshot } from '../../util/state.js';
+/**
+ * Creates a blank document based on a collection or area configuration.
+ * Initializes all fields with appropriate default values based on their type.
+ *
+ * @returns A new blank document with default values for all fields
+ *
+ * @example
+ * // Create a blank document for the 'pages' collection
+ * const blankPage = createBlankDocument(config.getCollection('pages'));
+ */
+export const createBlankDocument = (config, event) => {
+    /**
+     * Recursively processes field definitions to create a blank document structure.
+     * Handles special field types like tabs, blocks, relations, and nested fields.
+     */
+    function reduceFieldsToBlankDocument(prev, curr) {
+        try {
+            if (curr instanceof TabsBuilder) {
+                curr.get.tabs.forEach((tab) => {
+                    prev[tab.name] = tab.get.fields.reduce(reduceFieldsToBlankDocument, {});
+                });
+            }
+            else if (['blocks', 'relation', 'tree'].includes(curr.type)) {
+                prev[curr.name] = [];
+            }
+            else if (curr instanceof GroupFieldBuilder) {
+                prev[curr.name] = curr.get.fields.reduce(reduceFieldsToBlankDocument, {});
+            }
+            else if (curr instanceof FormFieldBuilder) {
+                // Presentational fields (separator, bare component()) are plain
+                // FieldBuilder, never FormFieldBuilder, and get skipped here rather
+                // than assigned `prev['']` (they never got a real name) — that used
+                // to corrupt the parent object into looking array-like once
+                // flattened/unflattened.
+                const defaultValue = curr.use.defaultValue({ event });
+                prev[curr.name] = defaultValue !== undefined ? defaultValue : null;
+            }
+        }
+        catch (err) {
+            console.error(curr);
+            throw err;
+        }
+        return prev;
+    }
+    const fields = config.fields.reduce(reduceFieldsToBlankDocument, {});
+    /**
+     * The fields, plus what every document has regardless of kind. Nothing feature-shaped: a
+     * feature adds to this through `FeatureDefinition.blank`, which the local API folds — see
+     * `prototype/api.server.ts`.
+     *
+     * An `isUploadConfig(config) && 'imageSizes' in config` branch used to seed `sizes: {}` here.
+     * It never once ran: `imageSizes` is a member of `UploadConfig`, so it lives at
+     * `config.upload.imageSizes` and never at `config.imageSizes` — every other reader in the repo
+     * uses the former. Removed rather than moved to `upload.blank`, because reviving a branch that
+     * has never executed is a behaviour change, not a relocation.
+     */
+    return {
+        ...fields,
+        _type: config.slug,
+        _prototype: config.type
+    };
+};
+/**
+ * Converts a flat array of documents into a nested tree structure based on parent-child relationships.
+ * Documents are organized hierarchically with each document containing its children in the _children property.
+ *
+ * @param documents - Array of documents with parent properties indicating their relationships
+ * @returns A nested tree structure where each document contains its children
+ *
+ * @example
+ * // Convert a flat list of pages into a hierarchical structure
+ * const pageTree = toNestedStructure(pagesList);
+ * // Result: [{ id: '1', _children: [{ id: '2', _children: [] }] }]
+ */
+/**
+ * Converts a flat array of documents into a nested tree structure
+ * based on _parent and _position fields
+ */
+export const toNestedStructure = (documents) => {
+    const incomingDocs = snapshot(documents);
+    // Create a map for quick document lookup by ID
+    const docById = new Map();
+    incomingDocs.forEach((doc) => docById.set(doc.id, doc));
+    // Track processed documents to prevent infinite recursion
+    const processed = new Set();
+    // Process documents recursively
+    const processDocument = (doc) => {
+        if (!doc || processed.has(doc.id)) {
+            return doc;
+        }
+        processed.add(doc.id);
+        const result = { ...doc };
+        // Process children first (depth-first)
+        if (Array.isArray(result._children)) {
+            result._children = result._children
+                .map((id) => {
+                const childDoc = docById.get(id);
+                return childDoc ? processDocument(childDoc) : null;
+            })
+                .filter(Boolean);
+        }
+        // Only set the parent ID, don't process it recursively
+        if (result._parent && typeof result._parent === 'string') {
+            result._parent = docById.get(result._parent)?.id || null;
+        }
+        return result;
+    };
+    const output = incomingDocs
+        .filter((doc) => !doc._parent)
+        .map(processDocument)
+        .sort((a, b) => (a._position || 0) - (b._position || 0));
+    // Filter to get root documents and process them
+    return output;
+};

package/dist/core/prototype/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The two prototypes, isomorphic halves.
+ *
+ * There was a registry here — `prototypeNames`, `protos`, `prototypes`, plus folds over them. It
+ * bought core the ability never to write the words `collection` and `area`, and it cost the folder
+ * its entry point: three exports that were three views of the same two objects, and callers that
+ * merged both lists only to split them apart again further down.
+ *
+ * The server halves are **not** re-exported here. They carry `api`, `rest` and `boot`, they are
+ * different objects under the same two names, and a caller that needs one names
+ * `collection/definition.server.js` — the path says which half, where the name could not.
+ */
+export { collection } from './collection/index.js';
+export { area } from './area/index.js';