rimecms 0.31.4 → 0.32.0

package/dist/core/dev/prototype-routes.server.js

@@ -0,0 +1,23 @@
+import { area } from '../prototype/area/definition.server.js';
+import { collection } from '../prototype/collection/definition.server.js';
+/**
+ * Every `/api` route the installed prototypes declare, as one string.
+ *
+ * ```
+ * collection[:GET|POST|DELETE,[id]:DELETE|GET|PATCH,[id]/duplicate:POST,[id]/lock:DELETE|POST];area[...]
+ * ```
+ *
+ * A cache key, not a route table — `generateRoutes` writes the files from the declarations
+ * themselves. It is here because both memos that gate codegen need it and neither owns it: the
+ * paths come from the package, so nothing in a project's own config moves when one is added, and
+ * a version bump is no help inside this repo, where the version stands still between commits.
+ *
+ * Sorted, because `Object.keys` order is insertion order and reordering a declaration is not a
+ * change to what gets written.
+ */
+export const restSurface = () => [collection, area]
+    .map((prototype) => `${prototype.name}[${Object.entries(prototype.rest || {})
+    .map(([routePath, methods]) => `${routePath}:${Object.keys(methods).sort().join('|')}`)
+    .sort()
+    .join(',')}]`)
+    .join(';');

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

@@ -0,0 +1,12 @@
+/**
+ * The rime version currently installed, as its own `package.json` states it.
+ *
+ * Read off disk rather than baked in, so it is the version actually present in the consuming
+ * project — which is the point: this is a cache key, and it has to change when the package does.
+ *
+ * In this repo rime is the project, so the manifest is the one at the root; in a consumer it is
+ * the installed package's, found the way `$rime/modules` finds it. An unreadable manifest returns
+ * a value nobody matches, which regenerates every time rather than never — the safe direction for
+ * a cache key to fail in.
+ */
+export declare const rimeVersion: () => string;

package/dist/core/dev/version.server.js

@@ -0,0 +1,27 @@
+import { IS_RIME_REPO, PACKAGE_NAME } from '../constants.server.js';
+import { findInstalledPackageRoot } from './codegen/runtime/index.server.js';
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * The rime version currently installed, as its own `package.json` states it.
+ *
+ * Read off disk rather than baked in, so it is the version actually present in the consuming
+ * project — which is the point: this is a cache key, and it has to change when the package does.
+ *
+ * In this repo rime is the project, so the manifest is the one at the root; in a consumer it is
+ * the installed package's, found the way `$rime/modules` finds it. An unreadable manifest returns
+ * a value nobody matches, which regenerates every time rather than never — the safe direction for
+ * a cache key to fail in.
+ */
+export const rimeVersion = () => {
+    try {
+        const root = IS_RIME_REPO
+            ? process.cwd()
+            : findInstalledPackageRoot(PACKAGE_NAME, process.cwd());
+        const manifest = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8'));
+        return manifest.version ?? 'unknown';
+    }
+    catch {
+        return `unresolved:${Date.now()}`;
+    }
+};

package/dist/core/dev/vite.server.js

@@ -0,0 +1,237 @@
+import { existsSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { IS_RIME_REPO, RIME_DEV_CACHE_DIR } from '../constants.server.js';
+import { logger } from '../logger.server.js';
+import { findModulePair, scanModulePairs } from './codegen/runtime/index.server.js';
+import { parseExportNames } from './codegen/runtime/parse-exports.server.js';
+import { sanitize } from './codegen/sanitize/index.server.js';
+import { CONFIG_DIR, GENERATED_DIR, generatedConfigServerPath, schemaPath } from './constants.server.js';
+import { ensureHasInit } from './ensure.server.js';
+const dev = process.env.NODE_ENV === 'development';
+export function regenerateModulesDeclaration() {
+    const libDir = path.resolve(process.cwd(), 'src/lib');
+    const blocks = Array.from(scanModulePairs(libDir))
+        .map(([subpath, entry]) => {
+        // The server half where there is one: a pair's two halves share their export names, and a
+        // name only one side declares is always the server's (`uploadHooks`, and every other piece
+        // a browser has no use for).
+        const file = entry.server || entry.client;
+        if (!file)
+            return null;
+        const aliased = `$lib/${path.relative(libDir, file).split(path.sep).join('/')}`.replace(/\.ts$/, '.js');
+        return `declare module '$rime/modules:${subpath}' {\n  export * from '${aliased}';\n}`;
+    })
+        .filter((block) => block !== null)
+        .join('\n\n');
+    writeFileSync(path.resolve(process.cwd(), 'src/rime.modules.generated.d.ts'), `${blocks}\n`);
+}
+export function rime() {
+    /** Two reserved names, always resolved to *the currently running app's* generated
+     *  config/schema, independent of who's asking — a third-party plugin importing
+     *  `$rime/config` gets the host app's config, never its own. Unrelated to the modules
+     *  mechanism below (a package's own client/server split): different problem, same `$rime/`
+     *  namespace only by convention. */
+    const VCoreId = '$rime/config';
+    const VSchemaId = '$rime/schema';
+    /**
+     * `$rime/modules:<path>` picks the client or server half of one module pair.
+     *
+     * ```ts
+     * import { augmentAuth } from '$rime/modules:core/auth';   // rooted at src/lib
+     * import { Boooz }       from '$rime/modules:../nested';   // relative to the importer
+     * import { populate }    from '$rime/modules:.';           // the importer's own folder
+     * ```
+     *
+     * The path is part of the specifier, so a name is unique per pair rather than per package, and
+     * a name the pair does not export is an error at that path instead of `undefined` at link time.
+     *
+     * This hook only ever answers for *this* project's own `src/lib`. A dependency's halves were
+     * rewritten to real package subpaths by its own prepack, so nothing here crosses into
+     * `node_modules` — which is what used to put a raw file path in the browser's module graph
+     * (see notes/isomorphic-module.md).
+     */
+    const VModulesPrefix = '$rime/modules:';
+    const libDir = () => path.resolve(process.cwd(), 'src/lib');
+    /** `$rime/modules:<path>` -> the pair's subpath under src/lib, or null if it names nothing. */
+    const subpathOf = (id, importer) => {
+        const spec = id.slice(VModulesPrefix.length);
+        const base = spec.startsWith('.')
+            ? path.resolve(path.dirname(importer ?? libDir()), spec)
+            : path.resolve(libDir(), spec);
+        return path.relative(libDir(), base).split(path.sep).join('/');
+    };
+    const resolvedVModule = (name) => '\0' + name;
+    return {
+        name: 'virtual-rime',
+        configureServer(server) {
+            // Add a listener for when the server starts
+            server.httpServer?.once('listening', () => {
+                dev && ensureHasInit();
+                regenerateModulesDeclaration();
+                // Check if we need to rebuild
+                const shouldRebuild = process.argv.includes('--rebuild');
+                if (shouldRebuild && existsSync(RIME_DEV_CACHE_DIR)) {
+                    rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
+                    logger.info('--rebuild : node_modules/.rime folder deleted');
+                }
+            });
+            // module.ts/module.server.ts appearing, changing, or disappearing under this project's
+            // own src/lib — regenerate the $rime/modules declaration above so the IDE picks up the
+            // new/changed/removed split immediately. Listens on add/unlink too, unlike the config
+            // watcher below (change-only) — a new split is exactly as likely to be a brand new file
+            // as an edit to an existing one.
+            const isModuleFile = (p) => /[/\\]module(\.server)?\.ts$/.test(p) &&
+                p.includes(`${path.sep}src${path.sep}lib${path.sep}`);
+            server.watcher.on('add', (p) => isModuleFile(p) && regenerateModulesDeclaration());
+            server.watcher.on('unlink', (p) => isModuleFile(p) && regenerateModulesDeclaration());
+            server.watcher.on('change', (p) => isModuleFile(p) && regenerateModulesDeclaration());
+            // Add a watcher for sanitizing config changes and triggering schema/routes/types
+            // generation. Debounced + single-flight: a config change is rarely one file (e.g. a
+            // plugin swap copying several files under +rime/ at once) — without this, each file
+            // fires its own overlapping sanitize()+generate()+migrate() run against the same db/
+            // and sqlite file, racing each other.
+            let reloadTimer = null;
+            let reloadInFlight = null;
+            let reloadQueued = false;
+            async function runConfigReload() {
+                if (reloadInFlight) {
+                    reloadQueued = true;
+                    return;
+                }
+                reloadInFlight = (async () => {
+                    // Sanitize the config client/server
+                    try {
+                        await sanitize();
+                    }
+                    catch (error) {
+                        logger.error('Error while sanitizing config:', error.message);
+                        return;
+                    }
+                    // Trigger generation
+                    try {
+                        // ssrLoadModule wants the real .ts file path, not a $lib/*.js-style import
+                        // specifier — different consumer than configImportPaths() (used for generated
+                        // source code).
+                        const mod = await server.ssrLoadModule(generatedConfigServerPath());
+                        // The config's default export is the createRime() promise; ssrLoadModule
+                        // only awaits the module's synchronous evaluation, so we must await it
+                        // directly to observe init errors (e.g. invalid config) here instead of
+                        // letting them become unhandled rejections that crash the dev server.
+                        await mod.default;
+                    }
+                    catch (error) {
+                        logger.error('Failed to reload the config', error.message);
+                    }
+                })();
+                await reloadInFlight;
+                reloadInFlight = null;
+                if (reloadQueued) {
+                    reloadQueued = false;
+                    await runConfigReload();
+                }
+            }
+            server.watcher.on('change', (modulePath) => {
+                const isConfigChange = modulePath.includes(CONFIG_DIR) && !modulePath.includes(GENERATED_DIR);
+                if (!isConfigChange)
+                    return;
+                if (reloadTimer)
+                    clearTimeout(reloadTimer);
+                reloadTimer = setTimeout(() => {
+                    reloadTimer = null;
+                    runConfigReload();
+                }, 150);
+            });
+        },
+        config() {
+            return {
+                ssr: {
+                    external: ['sharp']
+                },
+                optimizeDeps: {
+                    exclude: ['sharp'],
+                    include: ['@lucide/svelte']
+                },
+                build: {
+                    rollupOptions: {
+                        external: ['sharp']
+                    },
+                    target: 'es2022'
+                },
+                server: {
+                    watch: {
+                        ignored: ['**/db/**', '**/logs/**']
+                    }
+                }
+            };
+        },
+        async handleHotUpdate({ server, file }) {
+            function invalidateVModule(moduleId) {
+                const module = server.moduleGraph.getModuleById(resolvedVModule(moduleId));
+                if (module) {
+                    server.moduleGraph.invalidateModule(module);
+                    return module;
+                }
+                return null;
+            }
+            if (IS_RIME_REPO && file.includes('src/lib/core/config')) {
+                logger.info('reload core config');
+                const module = invalidateVModule(VCoreId);
+                if (module)
+                    return [module];
+            }
+        },
+        resolveId(id, importer) {
+            if (id === VCoreId) {
+                return resolvedVModule(id);
+            }
+            if (id === VSchemaId) {
+                return resolvedVModule(id);
+            }
+            if (id.startsWith(VModulesPrefix)) {
+                const subpath = subpathOf(id, importer);
+                const pair = findModulePair(libDir(), subpath);
+                if (!pair) {
+                    throw new Error(`${id}: no module.ts or module.server.ts under src/lib/${subpath}` +
+                        (importer ? ` (imported by ${importer})` : ''));
+                }
+                const wanted = this.environment?.config?.consumer === 'server' ? pair.server : pair.client;
+                // The half this build wants — a real source file, so the bundler sees it and everything
+                // it imports. Only the *missing* half of a half pair stays virtual, and that module is
+                // nothing but `undefined` bindings: it reaches no other file.
+                return wanted || resolvedVModule(`${VModulesPrefix}${subpath}`);
+            }
+            return null;
+        },
+        async load(id) {
+            const isServer = this.environment?.config?.consumer === 'server';
+            if (id === resolvedVModule(VCoreId)) {
+                const corePath = isServer ? 'rimecms/config/server' : 'rimecms/config';
+                return `export * from '${corePath}';`;
+            }
+            if (id === resolvedVModule(VSchemaId) && isServer) {
+                // Mirrors write.server.ts (adapter-sqlite/generate-schema) — the adapter itself never
+                // needed to change for this, it already goes through this virtual module instead of a
+                // hardcoded path.
+                const schemaFilePath = schemaPath();
+                if (existsSync(schemaFilePath)) {
+                    const modulePath = schemaFilePath.replace('.ts', '.js');
+                    return `export * from '${modulePath}'; export { default } from '${modulePath}';`;
+                }
+            }
+            // The missing half of a half pair. ESM binds named exports statically, so an empty module
+            // is not enough — `import { x }` throws a SyntaxError at link time if `x` is absent, it
+            // does not lazily become `undefined`. Stub each of the other half's names instead.
+            if (id.startsWith(resolvedVModule(VModulesPrefix))) {
+                const subpath = id.slice(resolvedVModule(VModulesPrefix).length);
+                const pair = findModulePair(libDir(), subpath);
+                const other = isServer ? pair?.client : pair?.server;
+                if (!other)
+                    return '';
+                return parseExportNames(other)
+                    .map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`)
+                    .join('\n');
+            }
+            return null;
+        }
+    };
+}

package/dist/core/errors/handler.server.d.ts

@@ -30,7 +30,23 @@ type ErrorHandlerOptions = {
  * const [err] = await trycatch(() => save(data));
  * if (err) return handleError(err, { context: ERROR_CONTEXT.ACTION, formData: data });
  */
-export declare function handleError(err: Error, options: ErrorHandlerOptions): import("@sveltejs/kit").ActionFailure<{
+/**
+ * Every branch below either throws — `error()` and `redirect()` are declared `never` — or, in an
+ * action context only, returns `fail()`. So the return type depends entirely on the context, and
+ * the overloads say so: an api/load call contributes nothing to its caller's return type, which
+ * is what lets a `+server.ts` handler be a real `RequestHandler` while still ending
+ * `return handleError(...)`.
+ *
+ * Inferred as one union instead, every REST handler in the repo was typed as possibly returning
+ * an `ActionFailure`, which no api-context call can produce.
+ */
+export declare function handleError(err: Error, options: ErrorHandlerOptions & {
+    context: typeof ERROR_CONTEXT.ACTION;
+}): ReturnType<typeof handleErrorImpl>;
+export declare function handleError(err: Error, options: ErrorHandlerOptions & {
+    context: typeof ERROR_CONTEXT.API | typeof ERROR_CONTEXT.LOAD;
+}): never;
+declare function handleErrorImpl(err: Error, options: ErrorHandlerOptions): import("@sveltejs/kit").ActionFailure<{
     form: Record<string, any>;
     errors: import("../../types.js").FormErrors;
 }> | import("@sveltejs/kit").ActionFailure<{

package/dist/core/errors/handler.server.js

@@ -1,5 +1,5 @@
 import { getRequestEvent } from '$app/server';
-import { logger } from '../logger/index.server.js';
+import { logger } from '../logger.server.js';
 import { error, fail, isRedirect, redirect } from '@sveltejs/kit';
 import { APIError } from 'better-auth/api';
 import { RimeError, RimeFormError } from './index.js';
@@ -8,29 +8,10 @@ export const ERROR_CONTEXT = {
     API: 'api',
     LOAD: 'load'
 };
-/**
- * Only called at the route boundary: +server.ts handlers, load functions,
- * form actions. Everywhere else, just `throw new RimeError(...)` (centralizes
- * error codes/messages) — it bubbles up and gets caught here, where `context`
- * tells this function which SvelteKit primitive to translate it into:
- * `error()` (api/load), `redirect()`, or `fail()` (action form errors).
- *
- * Always call it as `return handleError(...)`. Most branches throw internally
- * (`error`/`redirect`), so `return` never runs — but the `fail()` branch (form
- * errors in actions) is a real return value, so `return` is required there.
- *
- * @example +server.ts endpoint
- * if (!id) return handleError(new RimeError(RimeError.NOT_FOUND), { context: ERROR_CONTEXT.API });
- *
- * @example load function
- * const [err, doc] = await trycatch(() => getDoc(id));
- * if (err) return handleError(err, { context: ERROR_CONTEXT.LOAD });
- *
- * @example form action
- * const [err] = await trycatch(() => save(data));
- * if (err) return handleError(err, { context: ERROR_CONTEXT.ACTION, formData: data });
- */
 export function handleError(err, options) {
+    return handleErrorImpl(err, options);
+}
+function handleErrorImpl(err, options) {
     const { context, formData } = options;
     /****************************************************/
     /* FormError Errors

package/dist/core/fields/builders/boolean-builder.d.ts

@@ -10,7 +10,7 @@ export declare class BooleanFieldBuilder<T extends BooleanField = BooleanField>
     constructor(name: string, type: string);
     defaultValue(value: boolean | DefaultValueFn<boolean>): this;
     get dataType(): 'boolean';
-    compile(): import("../../../util/types.js").WithoutBuilders<T> & {
+    compile(): import("./field-builder.js").WithoutBuilders<T> & {
         component: import("svelte").Component<any>;
         cell?: import("svelte").Component<{
             value: any;

package/dist/core/fields/builders/field-builder.d.ts

@@ -1,6 +1,17 @@
-import type { WithoutBuilders } from '../../../util/types.js';
 import type { Component } from 'svelte';
 import type { Field, FieldAccess } from '../../../fields/types.js';
+/**
+ * Strips FieldBuilder wrappers off a config tree, yielding the compiled field shape.
+ *
+ * Defined here rather than in ../types.ts because it is mutually recursive with FieldBuilder
+ * below — separating them would only mean the two files importing each other. ../types.ts
+ * re-exports it, so the concept still has one public entry point.
+ */
+export type WithoutBuilders<T> = T extends FieldBuilder<infer F> ? WithoutBuilders<F> : T extends Array<infer U> ? U extends FieldBuilder<infer F> ? F[] : U extends {
+    compile(): infer R;
+} ? R[] : Array<WithoutBuilders<U>> : T extends object ? T extends Function ? T : {
+    [K in keyof T]: WithoutBuilders<T[K]>;
+} : T;
 /** Method-syntax (not `foo: () => ...` property syntax) so subtype checks
  *  like `FormFieldBuilder<SlugField> -> FormFieldBuilder<FormField>` — used
  *  all over the panel, where a concrete field builder flows into a

package/dist/core/fields/builders/form-field-builder.d.ts

@@ -33,6 +33,17 @@ export type FieldReferenceOptions = {
     /** Referenced table is this field's own table (self-FK); adapters need this
      *  to emit a `(): any =>` accessor and avoid a TS circular-declaration error. */
     selfReferencing?: boolean;
+    /**
+     * Read back as the referenced document instead of its id, joined by the adapter. Written as
+     * the id either way: a save may send the document back as it came.
+     *
+     * ```ts
+     * text('updatedBy').$references('staff', { resolve: true });
+     * // reads  { updatedBy: { id: 'abc', name: 'Ann', email: 'ann@x.io' } }
+     * // writes { updatedBy: 'abc' }
+     * ```
+     */
+    resolve?: boolean;
 };
 export type FieldReference = FieldReferenceOptions & {
     table: string;
@@ -52,12 +63,10 @@ export declare class FormFieldBuilder<T extends FormField = FormField> extends F
     width(value: FieldWidth): this;
     required(bool?: boolean): this;
     /**
-     * Force the field to be on the root table — usefull for fields that
-     * should not be versioned (ex: _parent for nested structures should
-     * always be on the root table to prevent different versions from having
-     * different parents).
+     * Keeps the field on the base row of a versioned config, so every version shares it.
+     * `_parent` on a nested collection is the typical case: the site tree must not fork per version.
      */
-    _root(): this;
+    $root(): this;
     /** `label`/`localized`/`root`/`required` are the only properties that need
      *  anything beyond a plain `this.field` read (a fallback default, or a
      *  boolean coercion) — everything else a concrete field type adds
@@ -78,6 +87,8 @@ export declare class FormFieldBuilder<T extends FormField = FormField> extends F
     /** Behavior the builder runs on your behalf — invoking a stored function or
      *  hook list, not a data read (see `.get` for that). */
     get use(): FormFieldUse<T>;
+    /** The document a resolved reference reads as, whatever the field's own type says. */
+    private resolvedReferenceType;
     hint(hint: string): this;
     clone(): typeof this;
     /** Server-side schema concern, same family as $beforeRead/$beforeSave. */

package/dist/core/fields/builders/form-field-builder.js

@@ -62,13 +62,11 @@ export class FormFieldBuilder extends FieldBuilder {
         return this;
     }
     /**
-     * Force the field to be on the root table — usefull for fields that
-     * should not be versioned (ex: _parent for nested structures should
-     * always be on the root table to prevent different versions from having
-     * different parents).
+     * Keeps the field on the base row of a versioned config, so every version shares it.
+     * `_parent` on a nested collection is the typical case: the site tree must not fork per version.
      */
-    _root() {
-        this.field._root = true;
+    $root() {
+        this.field.root = true;
         return this;
     }
     /** `label`/`localized`/`root`/`required` are the only properties that need
@@ -80,7 +78,7 @@ export class FormFieldBuilder extends FieldBuilder {
         return {
             ...this.field,
             localized: !!this.field.localized,
-            root: !!this.field._root,
+            root: !!this.field.root,
             label: this.field.label || capitalize(this.field.name),
             required: !!this.field.required
         };
@@ -150,9 +148,22 @@ export class FormFieldBuilder extends FieldBuilder {
                 const value = this.field.defaultValue;
                 return typeof value === 'function' ? value(context) : value;
             },
-            generateType: () => this.generateType()
+            generateType: () => this._references?.resolve ? this.resolvedReferenceType() : this.generateType()
         };
     }
+    /** The document a resolved reference reads as, whatever the field's own type says. */
+    resolvedReferenceType() {
+        const shared = [
+            '//@shared:start ResolvedReference',
+            "export type ResolvedReference<T> = (Pick<T, 'id'> & Partial<T>) | null;",
+            '//@shared:end'
+        ].join('\n');
+        const target = `${capitalize(this._references.table)}Doc`;
+        return [
+            shared,
+            `${this.field.name}${this.get.required ? '' : '?'}: ResolvedReference<${target}>`
+        ].join('\n');
+    }
     hint(hint) {
         this.field.hint = hint;
         return this;

package/dist/core/fields/builders/select-builder.d.ts

@@ -10,7 +10,7 @@ type FieldWithOptions = FormField & {
 declare class PickFieldBuilder<T extends FieldWithOptions = FieldWithOptions> extends FormFieldBuilder<T> {
     constructor(name: string, type: string);
     options(...options: (Option | string)[]): this;
-    compile(): import("../../../util/types").WithoutBuilders<T> & {
+    compile(): import("./field-builder").WithoutBuilders<T> & {
         component: import("svelte").Component<any>;
         cell?: import("svelte").Component<{
             value: any;

package/dist/core/fields/types.d.ts

@@ -0,0 +1,16 @@
+import type { RelationValue } from '../../fields/types.js';
+/**
+ * Type utilities that know about fields.
+ *
+ * They lived in util/types.ts, but both name a rime type — a relation value and a field
+ * builder — so by the placement rule they belong with the concept, not with the generic
+ * helpers.
+ */
+export type WithRelationPopulated<T> = {
+    [K in keyof T]: Required<T>[K] extends string ? T[K] : Required<T>[K] extends number ? T[K] : Required<T>[K] extends boolean ? T[K] : Required<T>[K] extends null ? T[K] : T[K] extends undefined ? undefined : NonNullable<T[K]> extends RelationValue<infer U> ? T[K] extends undefined ? undefined : U[] : T[K] extends Array<infer E> ? Array<WithRelationPopulated<E>> : T[K] extends object ? WithRelationPopulated<T[K]> : T[K];
+};
+/**
+ * Re-exported from where it is defined: WithoutBuilders and FieldBuilder are mutually
+ * recursive, so they have to share a file or import each other in a cycle.
+ */
+export type { WithoutBuilders } from './builders/field-builder.js';

package/dist/core/fields/util.d.ts

@@ -70,3 +70,63 @@ export declare function getFieldListAtPath(fieldPath: string, fields: FieldBuild
     fields: FieldBuilder[];
     path: string;
 };
+/**
+ * The fields a config keeps on its base row rather than on its versions table — whatever is marked
+ * `$root()`.
+ *
+ * Read off the config, never a list of names, because the schema generator splits the two tables
+ * by the same flag: the base table gets `filter((f) => f.get.root)`, the versions table gets the rest. A
+ * name-matching list would silently drop any field marked by something other than the two features
+ * whose names happened to be in it — there is no versions column to fall back to.
+ *
+ * Top-level only, matching the generator: a nested field cannot be split off its parent.
+ */
+export declare const baseFieldNames: (config: {
+    fields: FieldBuilder[];
+}) => string[];
+export type ResolvedReference = {
+    /** The document path: `meta.owner`. */
+    path: string;
+    /** The column it is stored in: `meta__owner`. */
+    column: string;
+    /** Whether the column sits on the base row of a versioned config. */
+    root: boolean;
+    /** The collection it points at. */
+    to: string;
+};
+/**
+ * The fields a read resolves into the document they reference, with the column each one is
+ * stored in. A field opts in with `$references(slug, { resolve: true })`.
+ *
+ * ```
+ * text('updatedBy').$references('staff', { resolve: true })
+ * // { path: 'updatedBy', column: 'updatedBy', root: false, to: 'staff' }
+ *
+ * group('meta').fields(text('owner').$references('staff', { resolve: true }))
+ * // { path: 'meta.owner', column: 'meta__owner', root: false, to: 'staff' }
+ * ```
+ *
+ * Walks tabs and groups, whose columns sit on the owner's row. Blocks and tree rows are their
+ * own tables and are not walked.
+ */
+export declare const resolvedReferencesOf: (fields: FieldBuilder[], parentPath?: string) => ResolvedReference[];
+/**
+ * Splits a write into the half that belongs on the base row and the half that belongs on the
+ * content row.
+ *
+ * Lived in `adapter-sqlite/util.server.ts` as `extractRootData`, which is one layer too low: which
+ * fields are base fields is a fact about the field configs, and every adapter would have to
+ * re-derive it. It is also where the write plan needs it (core/pipeline/write-plan.ts), which is
+ * above any adapter.
+ *
+ * Non-mutating, unlike the version it replaces — that one deleted the base keys out of the
+ * caller's own `data`, which `runUpdate` then went on to hand to `persistRelational`. Nothing
+ * depended on that (blocks, tree and relations resolve against `incomingPaths`, and no base field
+ * is one), but a write that quietly empties its argument is a trap either way.
+ */
+export declare const splitRootData: (data: Dic, config: {
+    fields: FieldBuilder[];
+}) => {
+    base: Dic;
+    content: Dic;
+};