rimecms 0.31.4 → 0.32.0

package/dist/core/dev/codegen/types/contributions.server.d.ts

@@ -0,0 +1,37 @@
+import type { FieldBuilder } from '../../../fields/builders/field-builder.js';
+import type { BuiltArea, BuiltCollection } from '../../../config/types.js';
+/**
+ * What each config's generated doc type gains beyond its own fields.
+ *
+ * Two contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
+ * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with.
+ * The `fields` predicates are **ANDed** — each says which fields it still wants generated, and
+ * a field has to survive both.
+ *
+ */
+export declare const contributionsFor: (config: BuiltArea | BuiltCollection) => Required<DocTypeContribution>;
+/**
+ * What a feature adds to a prototype's **generated document type**.
+ *
+ * `dev/codegen/types` wrote these itself: `if (collection.versions) push('versionId: string')`,
+ * and three reads of `collection.upload`. Two features named by config member in the one place
+ * that decides what a consumer's `PagesDoc` looks like.
+ *
+ * Nothing here is drizzle or SQL — a `DocTypeContribution` is TypeScript source, which is what
+ * this generator emits. `extends` names a type by the name it is exported under from the package's
+ * `/types` entry, and codegen adds the import.
+ */
+export type DocTypeContribution = {
+    /** Types the generated doc intersects with — upload's `UploadDoc`. */
+    extends?: string[];
+    /** Extra members, one per line, in `name: type` form. No trailing separator. */
+    members?: string[];
+    /**
+     * Which of the config's own fields still generate a member.
+     *
+     * For a feature whose fields are described by something other than their builders: upload's
+     * image sizes become one `sizes` object, so the per-size fields must not also appear.
+     * Absent means every field, and several features' predicates are ANDed.
+     */
+    fields?: (field: FieldBuilder) => boolean;
+};

package/dist/core/dev/codegen/types/contributions.server.js

@@ -0,0 +1,25 @@
+import { isVersioned } from '../../../prototype/shared/versions/enabled.js';
+import { versionsDocType } from '../../../prototype/shared/versions/doc-type.js';
+import { isUpload } from '../../../prototype/collection/upload/enabled.js';
+import { uploadDocType } from '../../../prototype/collection/upload/doc-type.js';
+/**
+ * What each config's generated doc type gains beyond its own fields.
+ *
+ * Two contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
+ * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with.
+ * The `fields` predicates are **ANDed** — each says which fields it still wants generated, and
+ * a field has to survive both.
+ *
+ */
+export const contributionsFor = (config) => 
+// Upload before versions: the prototype's feature list has upload first, and the members land
+// in that order in the generated type.
+[isUpload(config) ? uploadDocType(config) : null, isVersioned(config) ? versionsDocType() : null]
+    .filter((c) => c !== null)
+    .reduce((current, contribution) => ({
+    extends: [...current.extends, ...(contribution.extends ?? [])],
+    members: [...current.members, ...(contribution.members ?? [])],
+    fields: contribution.fields
+        ? (field) => current.fields(field) && contribution.fields(field)
+        : current.fields
+}), { extends: [], members: [], fields: () => true });

package/dist/core/dev/codegen/types/index.server.js

@@ -0,0 +1,132 @@
+import { contributionsFor } from './contributions.server.js';
+import { IS_RIME_REPO, PACKAGE_NAME } from '../../../constants.server.js';
+import cache from '../../cache.server.js';
+import { logger } from '../../../logger.server.js';
+import { trycatchSync } from '../../../../util/function.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { GENERATED_DIR, relativeImportSpecifier } from '../../constants.server.js';
+import { templateDeclareVirtualModule, templateDocType, templateLocals, templateRegister } from './templates.server.js';
+/**
+ * Generates the complete TypeScript type definitions string based on the built configuration
+ * @returns A string containing all type definitions
+ */
+export async function generateTypesString(config) {
+    logger.info('Types generation...');
+    // const registeredBlocks: string[] = [];
+    // const registeredTreeBlocks: string[] = [];
+    let imports = new Set(['BaseDoc', 'Navigation', 'RouteHandlers', 'User']);
+    const addImport = (string) => {
+        imports = new Set([...imports, string]);
+    };
+    /**
+     * Generates fields type definitions string based on a list of field
+     * @returns An array of string containing fields type definitions
+     */
+    const buildFieldsTypes = async (fields) => {
+        return fields.map((field) => field.use.generateType()).filter(Boolean);
+    };
+    /**
+     * One prototype's document type.
+     *
+     * Was two functions, `processCollection` and `processArea`, differing only in the feature
+     * branches the first one carried: `isUploadConfig(collection)` three times and
+     * `if (collection.versions)` once. Both are `docType` contributions now, so what is left is the
+     * same for either kind — which is why there is one function.
+     */
+    const processPrototype = async (config) => {
+        const contribution = contributionsFor(config);
+        const fieldsTypesList = await buildFieldsTypes(config.fields.filter(contribution.fields));
+        contribution.extends.forEach(addImport);
+        return templateDocType(config.slug, [...fieldsTypesList, ...contribution.members].join('\n\t'), contribution.extends);
+    };
+    const generated = (configs) => (configs ?? []).filter((c) => c._generateTypes !== false);
+    const collectionsTypes = (await Promise.all(generated(config.collections).map((c) => processPrototype(c)))).join('\n');
+    const areasTypes = (await Promise.all(generated(config.areas).map((a) => processPrototype(a)))).join('\n');
+    const typeImports = `import type { ${Array.from(imports).join(', ')} } from '${PACKAGE_NAME}/types'`;
+    // app.generated.d.ts always sits at src/app.generated.d.ts (see generateTypes() below).
+    const rimeConfigServerPath = relativeImportSpecifier(path.resolve(process.cwd(), 'src'), path.resolve(process.cwd(), GENERATED_DIR, 'rime.config.server.ts'));
+    function parseSharedTypes(content) {
+        // Field builders emit reusable type definitions wrapped between `//@shared:start <name>` and
+        // `//@shared:end`, each on its own line. Extracted once per name, deduped, and hoisted above
+        // the doc types that reference them.
+        //
+        // One pair can sit inside another — a relation field inside a block emits its own:
+        //
+        //   //@shared:start BlockImage
+        //   export type BlockImage = {
+        //     //@shared:start RelationValue
+        //     ...
+        //     //@shared:end
+        //   }
+        //   //@shared:end
+        //
+        // So the innermost pair is taken first and the pass repeats until none is left. Matching the
+        // outer start against the first `//@shared:end` would hoist half of BlockImage and leave the
+        // other half inline in the doc type. Innermost-first also emits RelationValue above the block
+        // that names it.
+        //
+        // Neither marker is anchored to the start of a line, because a start marker does not always
+        // get one — a blocks field inside a group emits `layout: {//@shared:start BlockParagraph`.
+        // Only the text from the marker to its `//@shared:end` is taken, so whatever sits in front of
+        // it stays where it is.
+        const innermost = /\/\/@shared:start[ \t]+(\S+)[ \t]*\r?\n((?:(?!\/\/@shared:start[ \t])[\s\S])*?)\r?\n[ \t]*\/\/@shared:end[ \t]*(?=\r?\n|$)/;
+        const seen = new Set();
+        const shared = [];
+        let remaining = content;
+        for (let match = innermost.exec(remaining); match; match = innermost.exec(remaining)) {
+            const [whole, name, body] = match;
+            if (!seen.has(name)) {
+                seen.add(name);
+                shared.push(body.trim());
+            }
+            remaining = remaining.slice(0, match.index) + remaining.slice(match.index + whole.length);
+        }
+        return {
+            content: remaining,
+            shared: shared.join('\n\n')
+        };
+    }
+    const { shared: sharedTypes, content: prototypesTypes } = parseSharedTypes([collectionsTypes, areasTypes].join('\n'));
+    const content = [
+        ...(IS_RIME_REPO ? ['// eslint-disable-next-line no-restricted-imports'] : []),
+        `import '${PACKAGE_NAME}';`,
+        `import type { Session } from 'better-auth';`,
+        ...(IS_RIME_REPO ? ['// eslint-disable-next-line no-restricted-imports'] : []),
+        typeImports,
+        '',
+        `declare global {`,
+        sharedTypes,
+        prototypesTypes,
+        `}`,
+        templateLocals(rimeConfigServerPath),
+        templateRegister(config)
+    ].join('\n');
+    return content;
+}
+/**
+ * Writes the generated types to the app.generated.d.ts file
+ * @param content The string containing all type definitions
+ */
+function write(key, content, filePath) {
+    if (cache.matches(key, content))
+        return;
+    cache.remember(key, content);
+    const [error] = trycatchSync(() => fs.writeFileSync(filePath, content));
+    if (error) {
+        logger.error(error);
+    }
+}
+/**
+ * Generates and writes TypeScript type definitions based on the built configuration
+ * @param config The built configuration containing collections, areas, and fields
+ */
+async function generateTypes(config) {
+    const mainTypes = await generateTypesString(config);
+    const declarations = templateDeclareVirtualModule();
+    const appGeneratedPath = path.resolve(process.cwd(), 'src', 'app.generated.d.ts');
+    const virtualModuleGeneratedPath = path.resolve(process.cwd(), 'src', 'rime.generated.d.ts');
+    write('app.generated', mainTypes, appGeneratedPath);
+    write('rime.generated', declarations, virtualModuleGeneratedPath);
+}
+export default generateTypes;

package/dist/core/dev/codegen/types/templates.server.d.ts

@@ -0,0 +1,13 @@
+import type { Config } from '../../../config/types.js';
+/**
+ * Generate the document's type definition
+ * @returns the full document type
+ */
+export declare const templateDocType: (slug: string, content: string, extendsTypes?: string[]) => string;
+/**
+ * Generates the module declaration for registering document types
+ * @returns A string containing the module declaration for type registration
+ */
+export declare const templateRegister: <T extends Config>(config: T) => string;
+export declare const templateDeclareVirtualModule: () => string;
+export declare const templateLocals: (rimeConfigServerPath: string) => string;

package/dist/core/dev/codegen/types/templates.server.js

@@ -0,0 +1,134 @@
+import { IS_RIME_REPO, PACKAGE_NAME } from '../../../constants.server.js';
+import { capitalize } from '../../../../util/string.js';
+/**
+ * Generate document's type name
+ * @example
+ * makeDocTypeName('pages')
+ * // return PagesDoc
+ */
+const makeDocTypeName = (slug) => `${capitalize(slug.replace('$', ''))}Doc`;
+/**
+ * Generate the document's type definition
+ * @returns the full document type
+ */
+export const templateDocType = (slug, content, extendsTypes = []) => `
+export type ${makeDocTypeName(slug)} = BaseDoc & ${extendsTypes.map((name) => `${name} & `).join('')} {
+  ${content};
+	[x: string]: unknown;
+}`;
+/**
+ * Generates the module declaration for registering document types
+ * @returns A string containing the module declaration for type registration
+ */
+export const templateRegister = (config) => {
+    const collections = (config.collections || []).filter((c) => c._generateTypes !== false);
+    const areas = (config.areas || []).filter((c) => c._generateTypes !== false);
+    /**
+     * The slug a config's content lives under, when a feature gives it a second table.
+     *
+     * A versions is registered as a collection in its own right but carries `_generateTypes: false`,
+     * because it has no doc type of its own — it shares its parent's. So it is filtered out above
+     * and its `RegisterCollection` entry added back here, pointing at the parent's type.
+     *
+     * Asked of the features that extend a collection, the way the schema generator asks. It was
+     * `collection.versions` plus the versions feature's own `withVersionsSuffix`, which is codegen
+     * naming a feature's table for it — and which would have registered nothing for a second
+     * feature that declared a versions table.
+     *
+     * Collections only: a versions table is registered as a collection in its own right, and this map is
+     * read nowhere but in `RegisterCollection` below.
+     */
+    const versionsSlugs = new Map((config.collections ?? []).map((c) => [c.slug, c._versions?.slug]));
+    const registerCollections = collections.length
+        ? [
+            '\tinterface RegisterCollection {',
+            `${collections
+                .map((collection) => {
+                let collectionRegister = `\t\t'${collection.slug}': ${makeDocTypeName(collection.slug)}`;
+                const versionsSlug = versionsSlugs.get(collection.slug);
+                if (versionsSlug) {
+                    collectionRegister += `\n\t\t'${versionsSlug}': ${makeDocTypeName(collection.slug)}`;
+                }
+                return collectionRegister;
+            })
+                .join('\n')};`,
+            '\t}'
+        ]
+        : [];
+    const registerAreas = areas.length
+        ? [
+            '\tinterface RegisterArea {',
+            `${areas
+                .map((area) => {
+                const areaRegister = `\t\t'${area.slug}': ${makeDocTypeName(area.slug)}`;
+                return areaRegister;
+            })
+                .join('\n')};`,
+            '\t}'
+        ]
+        : [];
+    return ["declare module 'rimecms' {", ...registerCollections, ...registerAreas, '}'].join('\n');
+};
+export const templateDeclareVirtualModule = () => [
+    `declare module '$rime/config' {`,
+    ...(IS_RIME_REPO ? ['\t// eslint-disable-next-line no-restricted-imports'] : []),
+    `\texport * from '${PACKAGE_NAME}/config/server';`,
+    `}`,
+    `declare module '$rime/schema' {`,
+    `\texport * from '$lib/rime.schema.server.js';`,
+    `}`
+].join('\n');
+export const templateLocals = (rimeConfigServerPath) => `declare global {
+  namespace App {
+    interface Locals {
+			/** Flag only ON when create the first panel user */
+			isInit?: boolean;
+			/** The better auth session */
+      session: Session | undefined;
+			/** The rime user document when authenticated */
+      user: User | undefined;
+			/**
+			 * Flag enabled when a create operation is triggered
+			 * by a auth/sign-up api call.
+			 */
+			pendingSignInAfterSignUp?: boolean;
+			/** The full better-auth user */
+			betterAuthUser:
+			| {
+					id: string;
+					name: string;
+					email: string;
+					emailVerified: boolean;
+					createdAt: Date;
+					updatedAt: Date;
+					role?: string | null | undefined;
+					banned: boolean | null | undefined;
+					banReason?: string | null | undefined;
+					banExpires?: Date | null | undefined;
+					type: string;
+				}
+			| undefined;
+			/** Singleton providing access to auth, config and the local API */
+      rime: ReturnType<
+				Awaited<
+					typeof import('${rimeConfigServerPath}').default
+				>['createRimeContext']
+			>;
+      /** Flag enabled by the core plugin rime.cache when the API cache is ON */
+      cacheEnabled: boolean;
+      /** Available in panel, nav routes for sidebar */
+      navigation: Navigation;
+      /** Dispatch facade backing the fixed /panel/[slug]/... and /api/[slug]/... routes */
+      routes: RouteHandlers;
+			/**
+			 * Current locale if applicable
+			 * set following this prioroty :
+			 * - locale inside the url from your front-end ex: /en/foo
+			 * - locale from searchParams ex : ?locale=en
+			 * - locale from cookie
+			 * - default locale
+			*/
+      locale: string | undefined;
+    }
+  }
+}`;

package/dist/core/dev/config-memo.server.js

@@ -0,0 +1,85 @@
+import { flatten } from 'flat';
+import cache from './cache.server.js';
+import { CONFIG_DIR } from './constants.server.js';
+import { restSurface } from './prototype-routes.server.js';
+import { rimeVersion } from './version.server.js';
+/**
+ * We actually need to serialize config values that will trigger
+ * types, routes, or schema generations, meaning that for now
+ * a basic serialization approach is sufficient.
+ */
+const serializeValue = (value) => {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    switch (typeof value) {
+        case 'function':
+            // Handle functions
+            if (Object.prototype.hasOwnProperty.call(value, 'render')) {
+                return `func:${value.name}`;
+            }
+            return `func:${value.toString()}`;
+        case 'object':
+            try {
+                // Builder instances (fields, tabs, blocks, ...) may hold their real state behind
+                // private class fields (e.g. TabBuilder's #tab), invisible to Object.keys()/
+                // JSON.stringify() — flatten() then treats them as leaf objects with zero own keys,
+                // silently serializing as `{}` regardless of actual content. compile() is the same
+                // method already calls to get a plain, fully-resolved representation, so
+                // reuse it here instead of reflecting blindly.
+                if (typeof value.compile === 'function') {
+                    return serializeValue(value.compile());
+                }
+                if (Array.isArray(value)) {
+                    return `array:${JSON.stringify(value)}`;
+                }
+                // Handle Date objects
+                if (value instanceof Date) {
+                    return `date:${value.toISOString()}`;
+                }
+                // Handle regular objects
+                return `object:${JSON.stringify(value)}`;
+            }
+            catch (err) {
+                return `error:${err.message}`;
+            }
+        default:
+            // Handle primitive values
+            return `${typeof value}:${value}`;
+    }
+};
+const writeMemo = (config) => {
+    const memo = flatten(config);
+    // const memoStr = JSON.stringify(config);
+    const memoStr = Object.entries(memo)
+        .map(([key, value]) => {
+        try {
+            const serializedValue = serializeValue(value);
+            return `${key}:${serializedValue}`;
+        }
+        catch (err) {
+            throw new Error(`Config error : Unable to parse value for key ${key}: ${err.message}`);
+        }
+    })
+        // Not part of the user's config object, but generated output (routes, schema, hooks) is
+        // relative to it — a RIME_CONFIG_DIR change must invalidate the memo just like a config
+        // change does, even when the config content itself is byte-identical.
+        .concat(`CONFIG_DIR:${CONFIG_DIR}`)
+        // Nor is rime's own version, and generated output belongs to it as much as to the config:
+        // routes, the drizzle schema and app.generated.d.ts are all written from templates that ship
+        // with the package. Without this an upgrade that changes one of them regenerates nothing for
+        // a project whose config did not also change, and the new code runs against the old files —
+        // a panel calling a form action the generated route never exported, and no error saying so.
+        .concat(`RIME_VERSION:${rimeVersion()}`)
+        // Nor are the /api routes the prototypes declare. This gate runs before every codegen step,
+        // `generateRoutes` included, so a route added to a prototype has to move it — a version bump
+        // does not, inside this repo, and the config never mentions those paths at all.
+        .concat(`REST_SURFACE:${restSurface()}`)
+        .join('\n');
+    if (cache.matches('config', memoStr))
+        return false;
+    cache.remember('config', memoStr);
+    return true;
+};
+export default writeMemo;

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

@@ -0,0 +1,20 @@
+export declare const CONFIG_DIR: string;
+export declare const GENERATED_DIR: string;
+export declare const INPUT_DIR: string;
+export declare const OUTPUT_DIR: string;
+/** Turns an absolute path into an import specifier relative to `fromDir`, always prefixed
+ * with `./` or `../` so it never gets mistaken for a bare package specifier. */
+export declare function relativeImportSpecifier(fromDir: string, toAbsolutePath: string): string;
+export declare function generatedConfigServerPath(): string;
+/** Where the panel/live route templates (common.server.ts) and the generated hooks.server.ts
+ * should import the client/server config from — a relative import specifier computed from
+ * `fromDir` (the absolute directory of the file doing the importing), so it resolves whether
+ * GENERATED_DIR lives under src/lib or elsewhere. One source of truth instead of hardcoding the
+ * path (or relying on the $lib alias, which only ever points at src/lib) at each call site. */
+export declare function configImportPaths(fromDir: string): {
+    client: string;
+    server: string;
+};
+/** Same idea as configImportPaths — one source of truth for where the generated schema
+ * lives instead of hardcoding the path at each call site. */
+export declare function schemaPath(projectRoot?: string): string;

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

@@ -0,0 +1,63 @@
+import dotenv from 'dotenv';
+import path from 'node:path';
+// Must run before RIME_CONFIG_DIR is read below. ES import hoisting evaluates this module's
+// top-level code before any *importing* file's own top-level statements — including a
+// dotenv.config() call there — so loading .env here, first, is the only way every entry point
+// (CLI, dev-server, drizzle.config.ts, etc.) reliably sees it. override:true so .env is the
+// explicit source of truth, not whatever a shell plugin (autoenv, direnv, ...) already exported
+// from some other project's .env. The only dotenv.config() call in the codebase — a second one
+// elsewhere would race this one.
+dotenv.config({ override: true });
+const root = process.cwd();
+const SRC_ROOT = path.resolve(root, 'src');
+export const CONFIG_DIR = process.env.RIME_CONFIG_DIR || 'src/+rime';
+export const GENERATED_DIR = `${CONFIG_DIR}.generated`;
+export const INPUT_DIR = path.basename(CONFIG_DIR);
+export const OUTPUT_DIR = `${INPUT_DIR}.generated`;
+// Reserved SvelteKit folders where config should never lands inside.
+const RESERVED_DIRS = new Set(['lib', 'routes', 'static', 'params'].map((d) => path.resolve(SRC_ROOT, d)));
+/** Prevent user CONFIG_DIR to be set :
+ * - on a SvelteKit folder by mistake
+ * - outside of src */
+for (const dir of [CONFIG_DIR, GENERATED_DIR]) {
+    const resolved = path.resolve(root, dir);
+    if (resolved === SRC_ROOT || !resolved.startsWith(SRC_ROOT + path.sep)) {
+        throw new Error(`RIME_CONFIG_DIR must resolve to a subdirectory of ${SRC_ROOT} (got "${dir}")`);
+    }
+    if (RESERVED_DIRS.has(resolved)) {
+        throw new Error(`RIME_CONFIG_DIR must not be src/lib, src/routes, src/static, or src/params (got "${dir}")`);
+    }
+}
+/** Turns an absolute path into an import specifier relative to `fromDir`, always prefixed
+ * with `./` or `../` so it never gets mistaken for a bare package specifier. */
+export function relativeImportSpecifier(fromDir, toAbsolutePath) {
+    const rel = path.relative(fromDir, toAbsolutePath).split(path.sep).join('/');
+    return rel.startsWith('.') ? rel : `./${rel}`;
+}
+/** Root-relative filesystem path (posix-style) to a file inside the generated config dir —
+ * for Vite's ssrLoadModule, which wants a real file path, not an import specifier. */
+function generatedFilePath(file) {
+    return path
+        .relative(root, path.resolve(root, GENERATED_DIR, file))
+        .split(path.sep)
+        .join('/');
+}
+export function generatedConfigServerPath() {
+    return generatedFilePath('rime.config.server.ts');
+}
+/** Where the panel/live route templates (common.server.ts) and the generated hooks.server.ts
+ * should import the client/server config from — a relative import specifier computed from
+ * `fromDir` (the absolute directory of the file doing the importing), so it resolves whether
+ * GENERATED_DIR lives under src/lib or elsewhere. One source of truth instead of hardcoding the
+ * path (or relying on the $lib alias, which only ever points at src/lib) at each call site. */
+export function configImportPaths(fromDir) {
+    return {
+        client: relativeImportSpecifier(fromDir, path.resolve(root, GENERATED_DIR, 'rime.config.js')),
+        server: relativeImportSpecifier(fromDir, path.resolve(root, GENERATED_DIR, 'rime.config.server.js'))
+    };
+}
+/** Same idea as configImportPaths — one source of truth for where the generated schema
+ * lives instead of hardcoding the path at each call site. */
+export function schemaPath(projectRoot = process.cwd()) {
+    return path.resolve(projectRoot, GENERATED_DIR, 'schema.server.ts');
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Ensure sanitize config exists — the generated server config inside the generated config dir.
+ */
+export declare function ensureGeneratedConfig(): string;
+/**
+ * Ensure user config exists — the CONFIG_DIR folder convention.
+ */
+export declare function ensureUserConfigExist(): void;
+/**
+ * Ensure schema exists (see adapter-sqlite/generate-schema/write.server.ts, which writes to
+ * the same path).
+ */
+export declare function ensureSchema(): void;
+/**
+ * Ensure .env exists
+ */
+export declare function ensureEnv(): void;
+/**
+ * Ensure drizzle config exists
+ */
+export declare function ensureDirzzle(): void;
+/**
+ * Ensure hooks.server exists
+ */
+export declare function ensureHooks(): void;
+/**
+ * Ensure db directory exists
+ */
+export declare function ensureDatabase(): void;
+export declare const ensureHasInit: () => void;

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

@@ -0,0 +1,82 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { CONFIG_DIR, GENERATED_DIR, generatedConfigServerPath, schemaPath } from './constants.server.js';
+const projectRoot = process.cwd();
+/**
+ * Ensure sanitize config exists — the generated server config inside the generated config dir.
+ */
+export function ensureGeneratedConfig() {
+    const configGeneratedPath = path.resolve(projectRoot, GENERATED_DIR, 'rime.config.server.ts');
+    if (!existsSync(configGeneratedPath)) {
+        throw new Error('Unable to find generated config');
+    }
+    return generatedConfigServerPath();
+}
+/**
+ * Ensure user config exists — the CONFIG_DIR folder convention.
+ */
+export function ensureUserConfigExist() {
+    const folderConfig = path.resolve(projectRoot, CONFIG_DIR, 'rime.config.server.ts');
+    if (existsSync(folderConfig))
+        return;
+    // Every project set up before RIME_CONFIG_DIR existed has its config here — if it's there
+    // but not at CONFIG_DIR, this is almost certainly an upgrade whose .env predates the env
+    // var, not a missing init, so say that instead of the generic message.
+    const LEGACY_DEFAULT = 'src/lib/+rime';
+    if (CONFIG_DIR !== LEGACY_DEFAULT &&
+        existsSync(path.resolve(projectRoot, LEGACY_DEFAULT, 'rime.config.server.ts'))) {
+        throw new Error(`Unable to find config at ${CONFIG_DIR} — found one at ${LEGACY_DEFAULT} instead. ` +
+            `Set RIME_CONFIG_DIR=${LEGACY_DEFAULT} in your .env to keep using it there, or move it to ${CONFIG_DIR} to match the current default.`);
+    }
+    throw new Error('Unable to find config, did you run rime init');
+}
+/**
+ * Ensure schema exists (see adapter-sqlite/generate-schema/write.server.ts, which writes to
+ * the same path).
+ */
+export function ensureSchema() {
+    if (!existsSync(schemaPath(projectRoot))) {
+        throw new Error('Unable to find schema, did you run rime init');
+    }
+}
+/**
+ * Ensure .env exists
+ */
+export function ensureEnv() {
+    const envFile = path.resolve(projectRoot, './.env');
+    if (!existsSync(envFile))
+        throw new Error('Missing .env file');
+}
+/**
+ * Ensure drizzle config exists
+ */
+export function ensureDirzzle() {
+    const drizzleConfigFile = path.resolve(projectRoot, './drizzle.config.ts');
+    if (!existsSync(drizzleConfigFile))
+        throw new Error('Missing drizzle.config.ts file');
+}
+/**
+ * Ensure hooks.server exists
+ */
+export function ensureHooks() {
+    const hooksServerFile = path.resolve(projectRoot, './src/hooks.server.ts');
+    if (!existsSync(hooksServerFile))
+        throw new Error('Missing src/hooks.server.ts file');
+}
+/**
+ * Ensure db directory exists
+ */
+export function ensureDatabase() {
+    const dbDirectory = path.resolve(projectRoot, './db');
+    if (!existsSync(dbDirectory))
+        throw new Error('Missing db directory');
+}
+export const ensureHasInit = () => {
+    ensureEnv();
+    ensureDirzzle();
+    ensureHooks();
+    ensureDatabase();
+    ensureUserConfigExist();
+    ensureGeneratedConfig();
+    ensureSchema();
+};

package/dist/core/dev/prototype-routes.server.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare const restSurface: () => string;