rimecms 0.31.5 → 0.32.1

package/dist/core/rime.server.js

@@ -1,79 +1,16 @@
-// import type { Adapter } from '../adapter-sqlite/index.server.js';
-import { dev } from '$app/environment';
-import devCache from './dev/cache/index.server.js';
-import { betterAuth } from 'better-auth';
-import { AreaAPI } from './areas/local-api.server.js';
-import { CollectionAPI } from './collections/local-api.server.js';
-import { getBaseAuthConfig } from './config/auth/better-auth.server.js';
-import { createConfigContext } from './config/config-context.server.js';
-import validate from './config/server/validate.server.js';
-import writeMemo from './config/server/write.server.js';
-import { regenerateDrizzleConfig, regenerateHooks } from './dev/cli/init/templates.js';
-import generateRoutes from './dev/generate/routes/index.server.js';
-import generateTypes from './dev/generate/types/index.server.js';
-import { RimeError } from './errors/index.js';
-import i18n from './i18n/index.js';
-import { registerTranslation } from './i18n/register.server.js';
-import { logger } from './logger/index.server.js';
+import { bootRime } from './boot.server.js';
+import { logger } from './logger.server.js';
+import { areaApi } from './prototype/area/api.server.js';
+import { collectionApi } from './prototype/collection/api.server.js';
+import { createRoutesContext } from './routes/context.server.js';
 /**
  * Creates the main Rime object
  * that provides access to cms API
  */
 export async function createRime(config) {
-    // Normalize plugins to a simple name->actions map
-    const serverPlugins = config.$plugins;
-    const plugins = Object.fromEntries(serverPlugins.map((plugin) => [plugin.name, plugin.actions ?? {}]));
-    // Creat config interface
-    const configCtx = createConfigContext(config);
-    // Init adapter to get the generateSchema
-    const { createAdapter, generateSchema } = config.$adapter;
-    // Generate schema, types, routes
-    if (dev) {
-        // A `rime generate` CLI run may be regenerating the same .rime cache
-        // concurrently (e.g. a running dev server reloading off the CLI's file
-        // writes). Skip our own generation this cycle instead of racing it or
-        // blocking this request on it — the next natural reload will pick up
-        // what the CLI produced.
-        if (process.env.RIME_CLI !== 'true' && devCache.get('.cli')) {
-            logger.debug('Skipping generation, `rime generate` is already running');
-        }
-        else {
-            const changed = writeMemo(config);
-            const valid = validate(config);
-            if (!valid) {
-                throw new RimeError('Config not valid');
-            }
-            if (changed) {
-                generateRoutes(config);
-                // Before generateSchema(): it shells out to drizzle-kit generate/migrate, which read
-                // drizzle.config.ts's schema path straight off disk — stale here means the wrong (or
-                // missing) schema file.
-                regenerateDrizzleConfig();
-                await generateSchema(config);
-                await generateTypes(config);
-                regenerateHooks();
-            }
-            else {
-                logger.debug('Nothing to generate');
-            }
-        }
-    }
-    // Create adapter, consume the generated schema
-    const adapter = await createAdapter(configCtx);
-    // Create auth
-    const baseAuthconfig = getBaseAuthConfig({ mailer: plugins.mailer, config: configCtx });
-    const betterAuthPlugins = Array.isArray(config.$auth?.plugins)
-        ? [...baseAuthconfig.plugins, ...config.$auth.plugins]
-        : baseAuthconfig.plugins;
-    const auth = betterAuth({
-        ...baseAuthconfig,
-        plugins: betterAuthPlugins,
-        database: adapter.auth.betterAuthAdapter
-    });
-    // Register translation
-    // Register dictionaries for panel Language
-    const dictionnaries = await registerTranslation(config.panel.language);
-    i18n.init(dictionnaries);
+    // Phases 1 and 2 — codegen (dev only) then boot, in that order, written out in
+    // boot.server.ts. Everything below is phase 3: what a request gets.
+    const { plugins, configCtx, adapter, auth } = await bootRime(config);
     /**
      * Function that define the locale to use in a request event
      * based on this priority, high to low :
@@ -103,6 +40,25 @@ export async function createRime(config) {
         }
         return (event.locals.locale = defaultLocale);
     }
+    /**
+     * Builds `rime.collection(slug)` / `rime.area(slug)`.
+     *
+     * The cast is what makes writing it out safe: these types cannot be derived from the values —
+     * each accessor carries its own slug literals and document types — so they are declared, on
+     * `RimeContext` above, from each prototype's `api.server.ts`. That is rule 1's boundary.
+     */
+    const buildAccessors = (event) => ({
+        collection: (slug) => collectionApi({
+            config: configCtx.getCollection(slug),
+            event,
+            defaultLocale: configCtx.getDefaultLocale()
+        }),
+        area: (slug) => areaApi({
+            config: configCtx.getArea(slug),
+            event,
+            defaultLocale: configCtx.getDefaultLocale()
+        })
+    });
     return {
         defineLocale,
         get auth() {
@@ -119,6 +75,11 @@ export async function createRime(config) {
         },
         createRimeContext(event) {
             defineLocale(event);
+            // The cast covers the plugin spread only. `plugins` is already `as
+            // typeof config.$InferPluginsServer` where bootRime builds it — a runtime
+            // `Object.fromEntries` cannot be checked against a mapped type — so re-deriving the same
+            // relationship here would only restate that cast, not verify it. Every other member is
+            // checked against the declaration above.
             return {
                 logger,
                 ...plugins,
@@ -132,7 +93,7 @@ export async function createRime(config) {
                  *
                  * @example
                  * rime.adapter.db.query.pages.findFirst()
-                 * rime.adatpter.auth.getUserAttributes({ authUserId: '12345', slug: 'users' })
+                 * rime.adapter.collection('users').findMany({ query: { where: { id: { equals: '1' } } } })
                  */
                 get adapter() {
                     return adapter;
@@ -148,6 +109,14 @@ export async function createRime(config) {
                 get config() {
                     return configCtx;
                 },
+                /**
+                 * Route facts for this request — which surface it is on, and the paths that go with it.
+                 *
+                 * @example
+                 * rime.routes.isAPI
+                 * rime.routes.panelUrl('pages', id)
+                 */
+                routes: createRoutesContext(event),
                 /**
                  * This overrides the event.locals.locale.
                  */
@@ -161,31 +130,14 @@ export async function createRime(config) {
                     return event.locals.locale;
                 },
                 /**
-                 * Get a collection api
-                 * @example
+                 * One accessor per registered prototype, each handing back that prototype's own local
+                 * API for this request.
                  *
+                 * @example
                  * rime.collection('pages').find({ query: 'where[isHome][equals]=true' })
-                 */
-                collection(slug) {
-                    const collectionConfig = configCtx.collections[slug];
-                    return new CollectionAPI({
-                        event,
-                        config: collectionConfig,
-                        defaultLocale: configCtx.getDefaultLocale()
-                    });
-                },
-                /**
-                 * Get an area api
                  * rime.area('settings').find()
                  */
-                area(slug) {
-                    const areaConfig = configCtx.areas[slug];
-                    return new AreaAPI({
-                        event,
-                        config: areaConfig,
-                        defaultLocale: configCtx.getDefaultLocale()
-                    });
-                }
+                ...buildAccessors(event)
             };
         }
     };

package/dist/core/routes/constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Route identity, shared by client and server. Route ids carry the literal folder names, never
+ * the configured `RIME_PANEL_ROUTE` segment, so comparing them cannot leak the panel's location.
+ */
+/** Pathname prefix every rime endpoint sits under. */
+export declare const API_PREFIX = "/api";
+export declare const PANEL_ROUTE_ID = "/(rime)/[panel=panel]";
+export declare const PANEL_SIGN_IN_ROUTE_ID = "/(rime)/[panel=panel]/sign-in";
+export declare const PANEL_FORGOT_PASSWORD_ROUTE_ID = "/(rime)/[panel=panel]/forgot-password";
+export declare const PANEL_RESET_PASSWORD_ROUTE_ID = "/(rime)/[panel=panel]/reset-password";
+/** Must stay reachable without a session — a locked-out visitor still needs these. */
+export declare const PANEL_PUBLIC_AUTH_ROUTE_IDS: Set<string>;

package/dist/core/routes/constants.js

@@ -0,0 +1,16 @@
+/**
+ * Route identity, shared by client and server. Route ids carry the literal folder names, never
+ * the configured `RIME_PANEL_ROUTE` segment, so comparing them cannot leak the panel's location.
+ */
+/** Pathname prefix every rime endpoint sits under. */
+export const API_PREFIX = '/api';
+export const PANEL_ROUTE_ID = '/(rime)/[panel=panel]';
+export const PANEL_SIGN_IN_ROUTE_ID = `${PANEL_ROUTE_ID}/sign-in`;
+export const PANEL_FORGOT_PASSWORD_ROUTE_ID = `${PANEL_ROUTE_ID}/forgot-password`;
+export const PANEL_RESET_PASSWORD_ROUTE_ID = `${PANEL_ROUTE_ID}/reset-password`;
+/** Must stay reachable without a session — a locked-out visitor still needs these. */
+export const PANEL_PUBLIC_AUTH_ROUTE_IDS = new Set([
+    PANEL_SIGN_IN_ROUTE_ID,
+    PANEL_FORGOT_PASSWORD_ROUTE_ID,
+    PANEL_RESET_PASSWORD_ROUTE_ID
+]);

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

@@ -0,0 +1,5 @@
+/** The panel's URL segment (e.g. "panel" -> /panel/...). Kept as a bare segment, never a
+ * PUBLIC_-prefixed env var: SvelteKit ships every PUBLIC_ value into the JS bundle of every
+ * page (including the public site), which would defeat the point of letting an operator hide
+ * this path from automated CMS-admin scanners. */
+export declare const PANEL_ROUTE: string;

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

@@ -0,0 +1,9 @@
+import { isValidSlug } from '../../util/string.js';
+/** The panel's URL segment (e.g. "panel" -> /panel/...). Kept as a bare segment, never a
+ * PUBLIC_-prefixed env var: SvelteKit ships every PUBLIC_ value into the JS bundle of every
+ * page (including the public site), which would defeat the point of letting an operator hide
+ * this path from automated CMS-admin scanners. */
+export const PANEL_ROUTE = (process.env.RIME_PANEL_ROUTE || 'panel').replace(/^\/+|\/+$/g, '');
+if (!isValidSlug(PANEL_ROUTE)) {
+    throw new Error(`RIME_PANEL_ROUTE must be a single URL segment (letters, numbers, "_"/"-", starting with a letter) — got "${PANEL_ROUTE}"`);
+}

package/dist/core/routes/context.server.d.ts

@@ -0,0 +1,17 @@
+import type { RequestEvent } from '@sveltejs/kit';
+import * as routes from './util.js';
+/**
+ * Built once per request, in `createRimeContext`.
+ *
+ * Getters, not values — `handleRoutes` rewrites `event.params.slug`, so these read `event` when
+ * asked.
+ */
+export declare function createRoutesContext(event: RequestEvent): {
+    readonly isAPI: boolean;
+    readonly isPublicAuthRoute: boolean;
+    readonly isPanel: boolean;
+    readonly panel: string;
+    panelUrl(...args: string[]): string;
+    apiUrl: typeof routes.apiUrl;
+    absolute: typeof routes.absolute;
+};

package/dist/core/routes/context.server.js

@@ -0,0 +1,29 @@
+import { PANEL_ROUTE } from './constants.server.js';
+import * as routes from './util.js';
+/**
+ * Built once per request, in `createRimeContext`.
+ *
+ * Getters, not values — `handleRoutes` rewrites `event.params.slug`, so these read `event` when
+ * asked.
+ */
+export function createRoutesContext(event) {
+    return {
+        get isAPI() {
+            return routes.isApiPathname(event.url.pathname);
+        },
+        get isPublicAuthRoute() {
+            return routes.isPublicPanelAuthRoute(event.route.id);
+        },
+        get isPanel() {
+            return event.params.panel !== undefined && !routes.isPublicPanelAuthRoute(event.route.id);
+        },
+        get panel() {
+            return PANEL_ROUTE;
+        },
+        panelUrl(...args) {
+            return routes.joinPath(PANEL_ROUTE, ...args);
+        },
+        apiUrl: routes.apiUrl,
+        absolute: routes.absolute
+    };
+}

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

@@ -0,0 +1,58 @@
+import { areaLoad } from '../../panel/pages/area/load.server.js';
+import { documentLoad } from '../../panel/pages/collection-document/load.server.js';
+import { collectionLoad } from '../../panel/pages/collection/load.server.js';
+import { liveLoad } from '../../panel/pages/live/load.server.js';
+import { checkLiveRedirect } from '../../panel/util/live.server.js';
+import { type Handle, type RequestEvent } from '@sveltejs/kit';
+/**
+ * What the generated `/panel/[slug]/...` and `/api/[slug]/...` routes call.
+ *
+ * Each generated file passes `event` straight through and imports nothing — slug and id are real
+ * route params, and the matchers under `src/params/` have already sorted out which prototype the
+ * URL names.
+ *
+ * Lives here rather than on `rime.server.ts`, because these handlers read `event.locals.rime`.
+ * Naming them there would make `RimeContext` depend on its own type.
+ */
+export declare const routeHandlers: {
+    checkLiveRedirect: typeof checkLiveRedirect;
+    panel: {
+        load: {
+            collection: typeof collectionLoad;
+            document: typeof documentLoad;
+            area: typeof areaLoad;
+            dashboard: (event: import("@sveltejs/kit").ServerLoadEvent) => Promise<{
+                entries: import("../../panel/pages/dashboard/types.js").DashboardEntry[];
+                aria: import("../../types.js").Route[];
+            }>;
+            live: typeof liveLoad;
+            signIn: ({ locals }: import("@sveltejs/kit").ServerLoadEvent) => Promise<{
+                forgotPasswordEnabled: boolean;
+                image: string | null;
+                form: {};
+            }>;
+            forgotPassword: ({ locals }: import("@sveltejs/kit").ServerLoadEvent) => Promise<{
+                form: {};
+                image: string | null;
+            }>;
+            resetPassword: ({ locals, url }: import("@sveltejs/kit").ServerLoadEvent) => Promise<{
+                image: string | null;
+                token: string;
+            }>;
+        };
+        actions: {
+            document: import("@sveltejs/kit").Actions;
+            area: import("@sveltejs/kit").Actions;
+            signIn: (event: RequestEvent) => any;
+        };
+    };
+    /**
+     * Finds the handler a prototype declared for this sub-path and method.
+     *
+     * Takes the prototype name and sub-path as strings, so a generated route file names its own
+     * and needs no types of its own. A prototype gets an endpoint by declaring it, nothing else.
+     */
+    rest: (name: string, path: string, event: RequestEvent) => Response | Promise<Response>;
+};
+export declare const handleRoutes: Handle;
+export type RouteHandlers = typeof routeHandlers;

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

@@ -0,0 +1,107 @@
+import { area } from '../prototype/area/definition.server.js';
+import { collection } from '../prototype/collection/definition.server.js';
+import buildNavigation from './panel-navigation.js';
+import { areaFormActions } from '../../panel/pages/area/actions.server.js';
+import { areaLoad } from '../../panel/pages/area/load.server.js';
+import { forgotPasswordLoad } from '../../panel/pages/auth/forgot-password/load.server.js';
+import { resetPasswordLoad } from '../../panel/pages/auth/reset-password/load.server.js';
+import { signInActions } from '../../panel/pages/auth/sign-in/actions.server.js';
+import { signInLoad } from '../../panel/pages/auth/sign-in/load.server.js';
+import { collectionFormActions } from '../../panel/pages/collection-document/actions.server.js';
+import { documentLoad } from '../../panel/pages/collection-document/load.server.js';
+import { collectionLoad } from '../../panel/pages/collection/load.server.js';
+import { dashboardLoad } from '../../panel/pages/dashboard/load.server.js';
+import { liveLoad } from '../../panel/pages/live/load.server.js';
+import { checkLiveRedirect } from '../../panel/util/live.server.js';
+import {} from '@sveltejs/kit';
+import { ERROR_CONTEXT, handleError } from '../errors/handler.server.js';
+import { RimeError } from '../errors/index.js';
+/** Every prototype's declared REST routes, by prototype name then by sub-path. */
+const restRoutes = {
+    collection: collection.rest ?? {},
+    area: area.rest ?? {}
+};
+/**
+ * What the generated `/panel/[slug]/...` and `/api/[slug]/...` routes call.
+ *
+ * Each generated file passes `event` straight through and imports nothing — slug and id are real
+ * route params, and the matchers under `src/params/` have already sorted out which prototype the
+ * URL names.
+ *
+ * Lives here rather than on `rime.server.ts`, because these handlers read `event.locals.rime`.
+ * Naming them there would make `RimeContext` depend on its own type.
+ */
+export const routeHandlers = {
+    checkLiveRedirect,
+    panel: {
+        load: {
+            collection: collectionLoad,
+            document: documentLoad,
+            area: areaLoad,
+            dashboard: dashboardLoad,
+            live: liveLoad,
+            signIn: signInLoad,
+            forgotPassword: forgotPasswordLoad,
+            resetPassword: resetPasswordLoad
+        },
+        actions: {
+            document: collectionFormActions,
+            area: areaFormActions,
+            signIn: signInActions.default
+        }
+    },
+    /**
+     * Finds the handler a prototype declared for this sub-path and method.
+     *
+     * Takes the prototype name and sub-path as strings, so a generated route file names its own
+     * and needs no types of its own. A prototype gets an endpoint by declaring it, nothing else.
+     */
+    rest: (name, path, event) => {
+        const handler = restRoutes[name]?.[path]?.[event.request.method];
+        // Unreachable while the generated routes match the config — SvelteKit answers an undeclared
+        // method with its own 405 first. Here so a route left behind by a config change 404s
+        // instead of throwing.
+        if (!handler) {
+            return handleError(new RimeError(RimeError.NOT_FOUND), { context: ERROR_CONTEXT.API });
+        }
+        return handler(event);
+    }
+};
+export const handleRoutes = async ({ event, resolve }) => {
+    const { rime } = event.locals;
+    const { isAPI, isPanel } = rime.routes;
+    // The URL carries a kebab slug, the config carries a camelCase one:
+    //
+    //   /api/medias-directories -> $mediasDirectories
+    //
+    // Swapped once here so every panel load, action and REST handler reads `event.params.slug` and
+    // compares it to `config.slug` directly. Only on rime's own routes: a front-end route may have
+    // a `slug` param too, and that one is none of our business.
+    if ((isAPI || isPanel) && event.params.slug) {
+        // Found in the config rather than converted back. `medias-directories` is what both
+        // `$mediasDirectories` and a collection named `mediasDirectories` kebab to, so the URL alone
+        // cannot say which one it means — only the config can.
+        //
+        // The route matchers are generated from these same kebabs, so a request that got this far
+        // always finds its prototype.
+        const kebab = event.params.slug;
+        const prototype = rime.config.prototypes.find((p) => p.kebab === kebab);
+        if (prototype)
+            event.params.slug = prototype.slug;
+    }
+    // The panel sidebar, rebuilt on every page load.
+    if (isPanel && event.request.method === 'GET') {
+        event.locals.navigation = buildNavigation(rime.config.raw, event);
+    }
+    event.locals.routes = routeHandlers;
+    // Routes declared by a config or a plugin, each keyed by its full pathname.
+    const routes = '$routes' in rime.config.raw ? rime.config.raw.$routes : null;
+    if (routes && event.url.pathname in routes) {
+        const route = routes[event.url.pathname];
+        const method = event.request.method;
+        if (method in route && !!route[method]) {
+            return route[method](event);
+        }
+    }
+    return resolve(event);
+};

package/dist/core/routes/panel-navigation.d.ts

@@ -0,0 +1,18 @@
+import type { BuildConfig } from '../config/index.server.js';
+import type { Config } from '../../types.js';
+import type { Dic } from '../../util/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * Builds navigation structure based on config and user permissions. Called
+ * directly from the routes handle hook, before resolve() — page.params isn't
+ * populated yet at that point, so the panel segment is passed in explicitly
+ * (from the same event.params.panel the caller already has) rather than
+ * relying on panelUrl()'s page-based default.
+ * @param config - Compiled configuration object
+ * @param user - Current user object (optional)
+ * @param panelSegment - The resolved [panel=panel] segment for this request
+ * @returns Dictionary of navigation groups
+ */
+declare const buildNavigation: <C extends Config>(config: BuildConfig<C>, event: RequestEvent) => Dic;
+export default buildNavigation;
+export type Navigation = ReturnType<typeof buildNavigation>;

package/dist/core/routes/panel-navigation.js

@@ -0,0 +1,64 @@
+/**
+ * Builds navigation structure based on config and user permissions. Called
+ * directly from the routes handle hook, before resolve() — page.params isn't
+ * populated yet at that point, so the panel segment is passed in explicitly
+ * (from the same event.params.panel the caller already has) rather than
+ * relying on panelUrl()'s page-based default.
+ * @param config - Compiled configuration object
+ * @param user - Current user object (optional)
+ * @param panelSegment - The resolved [panel=panel] segment for this request
+ * @returns Dictionary of navigation groups
+ */
+const buildNavigation = (config, event) => {
+    const groups = {};
+    const { user, rime } = event.locals;
+    /**
+     * Adds a route to the appropriate navigation group
+     */
+    const addRouteToGroup = (route, group) => {
+        if (group) {
+            if (!(group in groups)) {
+                groups[group] = [];
+            }
+            groups[group].push(route);
+        }
+        else {
+            groups.none.push(route);
+        }
+    };
+    // Process collections
+    config.collections
+        .filter((collection) => collection.panel !== false)
+        .forEach((collection) => {
+        if (user && collection.access.read(user, {})) {
+            const route = {
+                title: collection.label.plural,
+                icon: collection.slug,
+                url: rime.routes.panelUrl(collection.kebab)
+            };
+            addRouteToGroup(route, (collection.panel && collection.panel?.group) || 'collections');
+        }
+    });
+    // Process areas
+    config.areas.forEach((area) => {
+        if (user && area.access.read(user, {})) {
+            const route = {
+                title: area.label,
+                icon: area.slug,
+                url: rime.routes.panelUrl(area.kebab)
+            };
+            addRouteToGroup(route, (area.panel && area.panel?.group) || 'areas');
+        }
+    });
+    // Process custom panel routes
+    Object.entries(config.panel.routes).forEach(([routePath, routeConfig]) => {
+        const route = {
+            title: routeConfig.label,
+            icon: `custom-${routePath}`,
+            url: rime.routes.panelUrl(routePath)
+        };
+        addRouteToGroup(route, routeConfig.group);
+    });
+    return groups;
+};
+export default buildNavigation;

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

@@ -0,0 +1,24 @@
+import type { ResolvedPathname } from '$app/types';
+/**
+ * Joins segments into a root-relative path.
+ * @example
+ * joinPath('panel', 'pages', '123') // -> /panel/pages/123
+ */
+export declare function joinPath(...args: string[]): string;
+/**
+ * @example
+ * apiUrl('pages', '123') // -> /api/pages/123
+ */
+export declare function apiUrl(...args: string[]): string;
+/** Prefixes the configured site origin. For links that leave the app: emails, CORS, `_live`. */
+export declare function absolute(path: string): string;
+export declare function isApiPathname(pathname: string): boolean;
+export declare function isPublicPanelAuthRoute(routeId: string | null): boolean;
+/**
+ * Panel-only. Reads `page.params.panel`, which is undefined server-side
+ */
+export declare function panelPath(...args: string[]): ResolvedPathname;
+/**
+ * Panel-only. Reads `page.params.panel`, which is undefined server-side
+ */
+export declare function panelUrl(...args: string[]): ResolvedPathname;

package/dist/core/routes/util.js

@@ -0,0 +1,44 @@
+import { page } from '$app/state';
+import { env } from '$env/dynamic/public';
+import { API_PREFIX, PANEL_PUBLIC_AUTH_ROUTE_IDS } from './constants.js';
+/**
+ * Joins segments into a root-relative path.
+ * @example
+ * joinPath('panel', 'pages', '123') // -> /panel/pages/123
+ */
+export function joinPath(...args) {
+    if (!Array.isArray(args))
+        return '/';
+    return `/${args.join('/')}`;
+}
+/**
+ * @example
+ * apiUrl('pages', '123') // -> /api/pages/123
+ */
+export function apiUrl(...args) {
+    return `${API_PREFIX}/${args.join('/')}`;
+}
+/** Prefixes the configured site origin. For links that leave the app: emails, CORS, `_live`. */
+export function absolute(path) {
+    return `${env.PUBLIC_RIME_URL}${path}`;
+}
+export function isApiPathname(pathname) {
+    return pathname.startsWith(API_PREFIX);
+}
+export function isPublicPanelAuthRoute(routeId) {
+    return !!routeId && PANEL_PUBLIC_AUTH_ROUTE_IDS.has(routeId);
+}
+/**
+ * Panel-only. Reads `page.params.panel`, which is undefined server-side
+ */
+export function panelPath(...args) {
+    if (!page.params.panel)
+        throw new Error('panelPath called outside of component environment, page.params.panel is not defined');
+    return joinPath(page.params.panel, ...args);
+}
+/**
+ * Panel-only. Reads `page.params.panel`, which is undefined server-side
+ */
+export function panelUrl(...args) {
+    return absolute(panelPath(...args));
+}

package/dist/fields/blocks/component/AddBlockButton.svelte

@@ -2,7 +2,7 @@
   import { env } from '$env/dynamic/public';
   import { emptyValuesFromFieldConfig, isFormField } from '../../../core/fields/util.js';
   import { t__ } from '../../../core/i18n/index.js';
-  import type { GenericBlock } from '../../../core/types/doc.js';
+  import type { GenericBlock } from '../../../core/prototype/types.js';
   import Button from '../../../panel/components/ui/button/button.svelte';
   import * as Command from '../../../panel/components/ui/command/index.js';
   import { capitalize } from '../../../util/string.js';

package/dist/fields/blocks/component/AddBlockButton.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { GenericBlock } from '../../../core/types/doc.js';
+import type { GenericBlock } from '../../../core/prototype/types.js';
 import type { BlocksBuilder } from '../index.js';
 type AddBlock = (options: Omit<GenericBlock, 'id' | 'path'>) => void;
 type Props = {

package/dist/fields/blocks/component/Block.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import type { GenericBlock } from '../../../core/types/doc.js';
+  import type { GenericBlock } from '../../../core/prototype/types.js';
   import type { BlocksFieldBlock } from '../../types';
   import RenderFields from '../../../panel/components/fields/RenderFields.svelte';
   import { type DocumentFormContext } from '../../../panel/context/documentForm.svelte.js';

package/dist/fields/blocks/component/Blocks.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
   import { t__ } from '../../../core/i18n/index.js';
-  import type { GenericBlock } from '../../../core/types/doc.js';
+  import type { GenericBlock } from '../../../core/prototype/types.js';
   import type { BlocksFieldBlock } from '../../types';
   import { fieldset } from '../../../panel/components/fields/fieldset.svelte.js';
   import { Field } from '../../../panel/components/fields/index.js';

package/dist/fields/blocks/index.d.ts

@@ -1,7 +1,8 @@
 import type { FieldBuilder } from '../../core/fields/builders/field-builder.js';
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import type { WithoutBuilders } from '../../core/fields/types.js';
 import type { Field, FormField } from '../types.js';
-import type { Dic, WithoutBuilders } from '../../util/types.js';
+import type { Dic } from '../../util/types.js';
 import type { IconProps } from '@lucide/svelte';
 import type { Component } from 'svelte';
 export declare const blocks: (name: string, blocks: BlockBuilder[]) => BlocksBuilder;