rimecms 0.31.5 → 0.32.1

package/dist/core/prototype/shared/title/find-title.js

@@ -0,0 +1,35 @@
+import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
+import { GroupFieldBuilder } from '../../../../fields/group/index.js';
+import { TabsBuilder } from '../../../../fields/tabs/index.js';
+export const hasMaybeTitle = (field) => ['text', 'date', 'slug', 'email', 'richText'].includes(field.type);
+export function findTitleField(fields = [], basePath = '') {
+    for (const field of fields) {
+        // Direct check for isTitle
+        if (field instanceof FormFieldBuilder &&
+            hasMaybeTitle(field.get) &&
+            'isTitle' in field.get &&
+            field.get.isTitle === true) {
+            const path = basePath ? `${basePath}.${field.name}` : field.name;
+            return { field, path };
+        }
+        // Check in group
+        if (field instanceof GroupFieldBuilder && field.get.fields) {
+            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
+            const found = findTitleField(field.get.fields, groupPath);
+            if (found)
+                return found;
+        }
+        // Check in tabs
+        if (field instanceof TabsBuilder && field.get.tabs) {
+            for (const tab of field.get.tabs) {
+                if (tab.get.fields) {
+                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
+                    const found = findTitleField(tab.get.fields, tabPath);
+                    if (found)
+                        return found;
+                }
+            }
+        }
+    }
+    return null;
+}

package/dist/core/prototype/shared/title/hooks/index.server.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `title.someHook`.
+ *
+ * A barrel and nothing else — `module.server.ts` beside it is the pair half `$rime/modules:` resolves, and
+ * only files named exactly `module(.server).ts` are, so this one is invisible to that mechanism.
+ * It exists because a prototype's `hooks.server.ts` writes the run order and would otherwise carry
+ * one import line per hook.
+ */
+export { setDocumentTitle } from './set-document-title.server.js';

package/dist/core/prototype/shared/title/hooks/index.server.js

@@ -0,0 +1,9 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `title.someHook`.
+ *
+ * A barrel and nothing else — `module.server.ts` beside it is the pair half `$rime/modules:` resolves, and
+ * only files named exactly `module(.server).ts` are, so this one is invisible to that mechanism.
+ * It exists because a prototype's `hooks.server.ts` writes the run order and would otherwise carry
+ * one import line per hook.
+ */
+export { setDocumentTitle } from './set-document-title.server.js';

package/dist/core/prototype/shared/title/hooks/set-document-title.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Puts `title` on the document, read from whichever field `asTitle` resolved to.
+ */
+export declare const setDocumentTitle: import("../../../../pipeline/types").Hook<"raw", "read", "before">;

package/dist/core/prototype/shared/title/hooks/set-document-title.server.js

@@ -0,0 +1,32 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { richTextJSONToText } from '../../../../../fields/rich-text/index.js';
+import { getValueAtPath, isObjectLiteral } from '../../../../../util/object.js';
+/**
+ * Puts `title` on the document, read from whichever field `asTitle` resolved to.
+ */
+export const setDocumentTitle = Hooks.beforeRead(async function setDocumentTitle(args) {
+    const config = args.config;
+    let doc = args.doc;
+    const paramSelect = args.context.params.select;
+    const hasSelect = Array.isArray(paramSelect) && paramSelect.length;
+    const shouldSetTitle = !doc.title && (!hasSelect || (hasSelect && paramSelect.includes('title')));
+    if (shouldSetTitle) {
+        function computeTitleFromValue(value) {
+            // Handle rich text value
+            if (isObjectLiteral(value) && 'content' in value) {
+                return richTextJSONToText(value);
+            }
+            if (typeof value === 'string') {
+                return value;
+            }
+            return doc.id;
+        }
+        const titleRaw = getValueAtPath(config.asTitle, doc);
+        const title = computeTitleFromValue(titleRaw);
+        doc = {
+            title,
+            ...doc
+        };
+    }
+    return { ...args, doc };
+});

package/dist/core/prototype/shared/title/select.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The `select` a request asked for, with the field behind `title` added when it asked for `title`.
+ *
+ * `title` is not a column. `setDocumentTitle` — `shared/title/hooks/set-document-title.server.ts`
+ * — reads it out of whatever `asTitle` resolved to, on a document the adapter has already
+ * narrowed. So a select naming `title` without naming that field narrows the read to columns the
+ * hook cannot see, `getValueAtPath(config.asTitle, doc)` comes back undefined, and the document is
+ * titled with its own id.
+ *
+ * Every REST endpoint that parses this param goes through here, so `?select=title` means the same
+ * thing on `/pages` and on `/pages/<id>`.
+ *
+ * @param raw The `select` search param as sent — comma separated, or null when absent.
+ * @param asTitle The config's resolved title path (`BuiltCollection`/`BuiltArea`).
+ */
+export declare const selectWithTitle: (raw: string | null, asTitle: string) => string[] | undefined;

package/dist/core/prototype/shared/title/select.js

@@ -0,0 +1,24 @@
+/**
+ * The `select` a request asked for, with the field behind `title` added when it asked for `title`.
+ *
+ * `title` is not a column. `setDocumentTitle` — `shared/title/hooks/set-document-title.server.ts`
+ * — reads it out of whatever `asTitle` resolved to, on a document the adapter has already
+ * narrowed. So a select naming `title` without naming that field narrows the read to columns the
+ * hook cannot see, `getValueAtPath(config.asTitle, doc)` comes back undefined, and the document is
+ * titled with its own id.
+ *
+ * Every REST endpoint that parses this param goes through here, so `?select=title` means the same
+ * thing on `/pages` and on `/pages/<id>`.
+ *
+ * @param raw The `select` search param as sent — comma separated, or null when absent.
+ * @param asTitle The config's resolved title path (`BuiltCollection`/`BuiltArea`).
+ */
+export const selectWithTitle = (raw, asTitle) => {
+    if (!raw)
+        return undefined;
+    const select = raw.split(',');
+    if (select.includes('title') && !select.includes(asTitle)) {
+        select.push(asTitle);
+    }
+    return select;
+};

package/dist/core/prototype/shared/url/augment.d.ts

@@ -0,0 +1,13 @@
+import type { Collection } from '../../../config/types.js';
+type Input = {
+    $url?: Collection<any>['$url'];
+    fields?: Collection<any>['fields'];
+};
+/**
+ * Adds the hidden `url` field a document's computed url is stored in.
+ *
+ * Applied only to configs that declare `$url`, which the feature's `enabled` decides, so there is
+ * no condition here. See features/url/index.ts.
+ */
+export declare const augmentUrl: <T extends Input>(config: T) => T;
+export {};

package/dist/core/prototype/shared/url/augment.js

@@ -0,0 +1,11 @@
+import { text } from '../../../../fields/text/index.js';
+/**
+ * Adds the hidden `url` field a document's computed url is stored in.
+ *
+ * Applied only to configs that declare `$url`, which the feature's `enabled` decides, so there is
+ * no condition here. See features/url/index.ts.
+ */
+export const augmentUrl = (config) => ({
+    ...config,
+    fields: [...(config.fields || []), text('url').localized().hidden()]
+});

package/dist/core/prototype/shared/url/enabled.d.ts

@@ -0,0 +1,8 @@
+import type { Dic } from '../../../../util/types.js';
+/**
+ * A config has a public URL by declaring `$url`.
+ *
+ * `Dic`, not a narrow shape: an area has no `$url` member at all, and every caller that guards
+ * a step here holds one config or the other.
+ */
+export declare const hasUrl: (config: Dic) => boolean;

package/dist/core/prototype/shared/url/enabled.js

@@ -0,0 +1,7 @@
+/**
+ * A config has a public URL by declaring `$url`.
+ *
+ * `Dic`, not a narrow shape: an area has no `$url` member at all, and every caller that guards
+ * a step here holds one config or the other.
+ */
+export const hasUrl = (config) => !!config.$url;

package/dist/core/prototype/shared/url/hooks/index.server.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `url.someHook`.
+ *
+ * A barrel and nothing else — `module.server.ts` beside it is the pair half `$rime/modules:` resolves, and
+ * only files named exactly `module(.server).ts` are, so this one is invisible to that mechanism.
+ * It exists because a prototype's `hooks.server.ts` writes the run order and would otherwise carry
+ * one import line per hook.
+ */
+export { populateURL } from './populate-url.server.js';

package/dist/core/prototype/shared/url/hooks/index.server.js

@@ -0,0 +1,9 @@
+/**
+ * This feature's hooks, by name, so a prototype can place them as `url.someHook`.
+ *
+ * A barrel and nothing else — `module.server.ts` beside it is the pair half `$rime/modules:` resolves, and
+ * only files named exactly `module(.server).ts` are, so this one is invisible to that mechanism.
+ * It exists because a prototype's `hooks.server.ts` writes the run order and would otherwise carry
+ * one import line per hook.
+ */
+export { populateURL } from './populate-url.server.js';

package/dist/core/prototype/shared/url/hooks/populate-url.server.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hook to populate _children property on document from a nested collection
+ */
+export declare const populateURL: import("../../../../pipeline/types").Hook<"generic", "read", "before">;

package/dist/core/prototype/shared/url/hooks/populate-url.server.js

@@ -0,0 +1,120 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { env } from '$env/dynamic/private';
+import { PARAMS } from '../../../../constants.js';
+import { logger } from '../../../../logger.server.js';
+import { getValueAtPath } from '../../../../../util/object.js';
+import validate from '../../../../fields/validate.js';
+/**
+ * Hook to populate _children property on document from a nested collection
+ */
+export const populateURL = Hooks.beforeRead(async function populateURL(args) {
+    const select = args.context.params.select && Array.isArray(args.context.params.select)
+        ? args.context.params.select
+        : [];
+    const HAS_SELECT = select.length > 0;
+    // If there is a select param, populate url only if included
+    if (HAS_SELECT)
+        return args;
+    // Else populate url
+    const { config, event, context } = args;
+    const locale = context.params.locale;
+    const document = args.doc;
+    if (config.$url) {
+        let url;
+        try {
+            url = config.$url(document);
+        }
+        catch (err) {
+            logger.error(`Error while generating url of ${config.slug} with id: ${args.doc.id}, ${err.message}`);
+            return args;
+        }
+        const isValidURL = validate.url(url);
+        if (typeof isValidURL === 'string') {
+            logger.warn(`Invalid URL generated for ${config.slug} with id: ${args.doc.id}, url: ${url}`);
+            return args;
+        }
+        const match = url.match(/\[\.\.\.parent\.(\w+(?:\.\w+)*)\]/);
+        if (match) {
+            const fullMatch = match[0];
+            const attributePath = match[1];
+            // Create array to store parent attributes
+            const attributesArray = [];
+            const MAX_DEPTH = 6;
+            let depth = 0;
+            let parent = document._parent;
+            while (parent && depth < MAX_DEPTH) {
+                depth++;
+                const docs = await event.locals.rime.collection(config.slug).find({
+                    query: `where[id][equals]=${parent}`,
+                    select: [attributePath, '_parent'],
+                    locale
+                });
+                // Check if there is a result
+                if (docs && docs.length > 0) {
+                    const parentDoc = docs[0];
+                    const parentAttribute = getValueAtPath(attributePath, parentDoc);
+                    if (parentAttribute && typeof parentAttribute === 'string') {
+                        attributesArray.push(parentAttribute);
+                    }
+                    else if (parentAttribute) {
+                        logger.warn('Bad URL property: not a string', { attributePath, parentAttribute });
+                    }
+                    // Move up to the next parent
+                    parent = parentDoc._parent;
+                }
+                else {
+                    parent = null;
+                }
+            }
+            if (attributesArray.length) {
+                // Replace the parent reference with the joined attributes
+                url = url.replace(fullMatch, attributesArray.reverse().join('/'));
+            }
+            else {
+                url = url.replace('/' + fullMatch, '');
+            }
+        }
+        else {
+            // replace "/[...parent.whatever.something.foo]" with ""
+            url = url.replace(/\/\[\.\.\.parent\.\w+(?:\.\w+)*\]/, '');
+        }
+        if (!url) {
+            return args;
+        }
+        if (url.includes('undefined')) {
+            logger.warn('Missing document properties to generate URL for : ' + document.id);
+            return args;
+        }
+        // Add the url if successfully generated
+        if (url) {
+            if (args.doc.url !== url) {
+                /**
+                 * The url is a field on the row the content is on, so this writes it there — which is
+                 * what `contentOwner` resolves. The two tables a localized field lives across are
+                 * `updateWhere`'s `locale` to sort out.
+                 *
+                 * `updateWhere` rather than `update` because a url is computed on read: it must not move
+                 * `updatedAt`.
+                 */
+                const contentId = config._versions ? args.doc.contentId : args.doc.id;
+                if (contentId) {
+                    args.event.locals.rime.adapter.contentOwner(config.slug).updateWhere({
+                        query: { where: { id: { equals: contentId } } },
+                        data: { url },
+                        locale
+                    });
+                }
+            }
+            args.doc = { ...args.doc, url };
+        }
+        // Add the live url if needed. Gated on isStaff, not mere session presence — this URL
+        // embeds the real, hideable RIME_PANEL_ROUTE segment, so it must not reach a non-staff
+        // authenticated session either.
+        if (config.live && event.locals.user?.isStaff && url) {
+            args.doc._live = `${process.env.PUBLIC_RIME_URL}/${env.RIME_PANEL_ROUTE || 'panel'}/live-edit?src=${url}&slug=${config.slug}&id=${args.doc.id}`;
+            args.doc._live += args.doc.contentId ? `&${PARAMS.VERSION_ID}=${args.doc.contentId}` : '';
+            args.doc._live += locale ? `&${PARAMS.LOCALE}=${locale}` : '';
+        }
+    }
+    return args;
+});

package/dist/core/prototype/shared/versions/augment.d.ts

@@ -0,0 +1,23 @@
+import type { VersionsConfig } from './types.js';
+import type { VersionsTable } from '../../../adapter.js';
+import type { Collection } from '../../../config/types.js';
+type Input = {
+    slug?: string;
+    versions?: Collection<any>['versions'];
+    fields?: Collection<any>['fields'];
+};
+export type WithVersionsConfig<T> = Omit<T, 'versions'> & {
+    versions?: Required<VersionsConfig>;
+    _versions?: VersionsTable;
+};
+/**
+ * Normalises `versions`, adds the `status` field when drafts are on and `isAutoSave` when
+ * auto-save is, and — when this config is versioned — states **where its content lives**.
+ *
+ * `_versions` is the answer five callers used to fold the feature list for, through a
+ * `FeatureDefinition.shadow` seam that only this feature ever implemented. Two of those callers
+ * are in `adapter-sqlite/`, so it has to be a config member rather than a call: reading data keeps
+ * the adapter naming no feature.
+ */
+export declare const augmentVersions: <T extends Input>(config: T) => WithVersionsConfig<T>;
+export {};

package/dist/core/prototype/shared/versions/augment.js

@@ -0,0 +1,47 @@
+import { withVersionsSuffix } from './naming.js';
+import { VERSIONS_STATUS } from './constant.js';
+import { text } from '../../../../fields/text/index.js';
+import { toggle } from '../../../../fields/toggle/index.js';
+/**
+ * Normalises `versions`, adds the `status` field when drafts are on and `isAutoSave` when
+ * auto-save is, and — when this config is versioned — states **where its content lives**.
+ *
+ * `_versions` is the answer five callers used to fold the feature list for, through a
+ * `FeatureDefinition.shadow` seam that only this feature ever implemented. Two of those callers
+ * are in `adapter-sqlite/`, so it has to be a config member rather than a call: reading data keeps
+ * the adapter naming no feature.
+ */
+export const augmentVersions = (config) => {
+    const fields = [...(config.fields || [])];
+    const { versions, ...rest } = config;
+    let normalizedVersions;
+    if (versions) {
+        normalizedVersions = {
+            draft: typeof versions === 'boolean' ? false : (versions.draft ?? false),
+            autoSave: typeof versions === 'boolean' ? false : (versions.autoSave ?? false),
+            maxVersions: typeof versions === 'boolean' ? 12 : (versions.maxVersions ?? 12)
+        };
+        if (normalizedVersions.draft) {
+            fields.push(text('status').defaultValue(VERSIONS_STATUS.DRAFT).hidden());
+        }
+        // `required()` makes the column not null with a default, so a migration backfills every
+        // existing row as `false`. Reads filter on `isAutoSave != true`, and SQLite does not count a
+        // null row as passing that.
+        if (normalizedVersions.draft && normalizedVersions.autoSave) {
+            fields.push(toggle('isAutoSave').defaultValue(false).required().hidden());
+        }
+    }
+    else {
+        normalizedVersions = undefined;
+    }
+    return {
+        ...rest,
+        versions: normalizedVersions,
+        fields,
+        // Only a versioned config has a second table. `slug` is always set by `create` before the
+        // augments run; the guard is for the derived configs that are built without one.
+        ...(normalizedVersions && config.slug
+            ? { _versions: { slug: withVersionsSuffix(config.slug) } }
+            : {})
+    };
+};

package/dist/core/prototype/shared/versions/auto-saves.server.d.ts

@@ -0,0 +1,16 @@
+import type { BuiltArea, BuiltCollection } from '../../../config/types.js';
+import type { GenericDoc } from '../../types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+import type { AutoSaves } from './types.js';
+/**
+ * The auto-saved rows of a document, newest first.
+ *
+ * Read as rime itself: the rows are staff-only, and the caller may hold the document open with
+ * read access alone. `undefined` on a config that does not auto-save, so a page can tell "none"
+ * from "not a thing here".
+ */
+export declare const autoSavesOf: (args: {
+    event: RequestEvent;
+    config: BuiltCollection | BuiltArea;
+    doc: GenericDoc;
+}) => Promise<AutoSaves | undefined>;

package/dist/core/prototype/shared/versions/auto-saves.server.js

@@ -0,0 +1,29 @@
+import { withVersionsSuffix } from './naming.js';
+/**
+ * The auto-saved rows of a document, newest first.
+ *
+ * Read as rime itself: the rows are staff-only, and the caller may hold the document open with
+ * read access alone. `undefined` on a config that does not auto-save, so a page can tell "none"
+ * from "not a thing here".
+ */
+export const autoSavesOf = async (args) => {
+    const { event, config, doc } = args;
+    if (!config.versions?.autoSave)
+        return undefined;
+    const versionsSlug = withVersionsSuffix(config.slug);
+    const rows = (await event.locals.rime
+        .collection(versionsSlug)
+        .system()
+        .find({
+        query: {
+            where: { and: [{ ownerId: { equals: doc.id } }, { isAutoSave: { equals: true } }] }
+        },
+        select: ['id', 'updatedAt', 'updatedBy'],
+        sort: '-updatedAt'
+    }));
+    return rows.map(({ id, updatedAt, updatedBy }) => ({
+        id,
+        updatedAt,
+        updatedBy: updatedBy ?? null
+    }));
+};

package/dist/core/prototype/shared/versions/blank.d.ts

@@ -0,0 +1,13 @@
+import type { Dic } from '../../../../util/types.js';
+/**
+ * A bootstrapped document's first version is the published one.
+ *
+ * Otherwise the row exists and no default read can see it, since a default read narrows to
+ * `status = published`. The `status` field's own default is `draft`, which is right for every
+ * version made after this one.
+ *
+ * There was a `BlankIntent` parameter saying which blank this is. It had one interesting value:
+ * only `boot` seeds a row, only an area is booted, and a create never publishes. So the caller is
+ * the answer — this one is `ensureExists`, and nothing else calls it.
+ */
+export declare const blankVersion: (doc: Dic, config: Dic) => Dic;

package/dist/core/prototype/shared/versions/blank.js

@@ -0,0 +1,15 @@
+import { VERSIONS_STATUS } from './constant.js';
+/**
+ * A bootstrapped document's first version is the published one.
+ *
+ * Otherwise the row exists and no default read can see it, since a default read narrows to
+ * `status = published`. The `status` field's own default is `draft`, which is right for every
+ * version made after this one.
+ *
+ * There was a `BlankIntent` parameter saying which blank this is. It had one interesting value:
+ * only `boot` seeds a row, only an area is booted, and a create never publishes. So the caller is
+ * the answer — this one is `ensureExists`, and nothing else calls it.
+ */
+export const blankVersion = (doc, config) => config.versions?.draft
+    ? { ...doc, status: VERSIONS_STATUS.PUBLISHED }
+    : doc;

package/dist/core/prototype/shared/versions/configure.server.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '../../../config/types.js';
+/**
+ * Derives the versions collection behind every versioned config — `$pages__versions` for a versioned
+ * `pages`, and one per versioned area, which is a collection because a single document still has
+ * many revisions.
+ */
+export declare function configureVersions<C extends Config>(config: C): C;

package/dist/core/prototype/shared/versions/configure.server.js

@@ -0,0 +1,75 @@
+import { withVersionsSuffix } from './naming.js';
+import { prototypeKebab } from '../../naming.js';
+import { isStaff } from '../../../auth/access.js';
+/**
+ * The versions holds the content half of a document, so it carries the content half of the fields:
+ * everything except what the base row keeps (`$root()`). The schema generator splits the two
+ * tables by the same flag, so a versions table config claiming a base field would name a column its table
+ * does not have.
+ */
+const contentFields = (config) => config.fields.filter((field) => !field.get.root);
+/**
+ * Version rows are the panel's history, and a document's auto-saved rows live among them. They
+ * read for staff who may read the document, and for nobody else — a public collection's drafts
+ * are not public.
+ */
+const versionsAccess = (access) => ({
+    ...access,
+    read: (user, options) => isStaff(user) && !!access.read?.(user, options)
+});
+/**
+ * Derives the versions collection behind every versioned config — `$pages__versions` for a versioned
+ * `pages`, and one per versioned area, which is a collection because a single document still has
+ * many revisions.
+ */
+export function configureVersions(config) {
+    for (const collection of config.collections || []) {
+        if (collection.versions) {
+            const versionedCollection = {
+                slug: withVersionsSuffix(collection.slug),
+                kebab: prototypeKebab(withVersionsSuffix(collection.slug)),
+                versions: undefined,
+                access: versionsAccess(collection.access),
+                $hooks: collection.$hooks,
+                fields: contentFields(collection),
+                auth: collection.auth,
+                upload: collection.upload,
+                label: collection.label,
+                type: collection.type,
+                asTitle: collection.asTitle,
+                asThumbnail: collection.asThumbnail,
+                icon: collection.icon,
+                panel: false,
+                _generateTypes: false,
+                _generateSchema: false,
+                // Whose content this holds. The feature that derives a versions table is the only thing that knows,
+                // and saying it is what stops anything downstream working it out from the slug.
+                _shadowOf: collection.slug
+            };
+            config.collections = [...(config.collections || []), versionedCollection];
+        }
+    }
+    for (const area of config.areas || []) {
+        if (area.versions) {
+            const versionedCollection = {
+                slug: withVersionsSuffix(area.slug),
+                kebab: prototypeKebab(withVersionsSuffix(area.slug)),
+                icon: area.icon,
+                versions: undefined,
+                access: versionsAccess(area.access),
+                asTitle: area.asTitle,
+                asThumbnail: null,
+                $hooks: area.$hooks,
+                fields: contentFields(area),
+                type: 'collection',
+                label: { plural: area.label, singular: area.label },
+                panel: false,
+                _generateTypes: false,
+                _generateSchema: false,
+                _shadowOf: area.slug
+            };
+            config.collections = [...(config.collections || []), versionedCollection];
+        }
+    }
+    return config;
+}

package/dist/core/prototype/shared/versions/constant.d.ts

@@ -0,0 +1,14 @@
+/**
+ * What a version row's `status` column holds.
+ *
+ * Lived in `core/constants.ts`, which is core declaring a feature's vocabulary. It is shared
+ * widely — six files in this feature, the panel's four version components — but shared is not the
+ * same as central: every one of those readers is asking this feature a question.
+ */
+export declare const VERSIONS_STATUS: {
+    readonly DRAFT: "draft";
+    readonly PUBLISHED: "published";
+};
+export type VersionsStatus = (typeof VERSIONS_STATUS)[keyof typeof VERSIONS_STATUS];
+/** How long the panel waits after the last change before auto-saving. */
+export declare const AUTO_SAVE_DELAY_MS = 1500;

package/dist/core/prototype/shared/versions/constant.js

@@ -0,0 +1,13 @@
+/**
+ * What a version row's `status` column holds.
+ *
+ * Lived in `core/constants.ts`, which is core declaring a feature's vocabulary. It is shared
+ * widely — six files in this feature, the panel's four version components — but shared is not the
+ * same as central: every one of those readers is asking this feature a question.
+ */
+export const VERSIONS_STATUS = {
+    DRAFT: 'draft',
+    PUBLISHED: 'published'
+};
+/** How long the panel waits after the last change before auto-saving. */
+export const AUTO_SAVE_DELAY_MS = 1500;

package/dist/core/prototype/shared/versions/doc-type.d.ts

@@ -0,0 +1,8 @@
+import type { DocTypeContribution } from '../../../dev/codegen/types/contributions.server.js';
+/**
+ * A versioned document carries the id of the version it was read as.
+ *
+ * `dev/codegen/types` pushed this itself, behind `if (collection.versions)` — twice, once per
+ * prototype kind. `exposeVersionId` is the hook that puts the value there; this is the type of it.
+ */
+export declare const versionsDocType: () => DocTypeContribution;

package/dist/core/prototype/shared/versions/doc-type.js

@@ -0,0 +1,9 @@
+/**
+ * A versioned document carries the id of the version it was read as.
+ *
+ * `dev/codegen/types` pushed this itself, behind `if (collection.versions)` — twice, once per
+ * prototype kind. `exposeVersionId` is the hook that puts the value there; this is the type of it.
+ */
+export const versionsDocType = () => ({
+    members: ['versionId: string']
+});

package/dist/core/prototype/shared/versions/enabled.d.ts

@@ -0,0 +1,10 @@
+import type { Dic } from '../../../../util/types.js';
+/**
+ * A config keeps history by declaring `versions`.
+ *
+ * `Dic`, not a narrow shape: an area has no `versions` member at all, and every caller that guards
+ * a step here holds one config or the other.
+ */
+export declare const isVersioned: (config: Dic) => boolean;
+/** A config whose documents are the version rows of another — the derived `$<slug>__versions`. */
+export declare const isVersionsCollection: (config: Dic) => boolean;

package/dist/core/prototype/shared/versions/enabled.js

@@ -0,0 +1,9 @@
+/**
+ * A config keeps history by declaring `versions`.
+ *
+ * `Dic`, not a narrow shape: an area has no `versions` member at all, and every caller that guards
+ * a step here holds one config or the other.
+ */
+export const isVersioned = (config) => !!config.versions;
+/** A config whose documents are the version rows of another — the derived `$<slug>__versions`. */
+export const isVersionsCollection = (config) => !!config._shadowOf;