@rebasepro/app 0.11.1-canary.gfd39654 → 0.12.1-canary.g009ed95

package/README.md

@@ -8,7 +8,7 @@ Framework-agnostic runtime for data-driven admin panels — React hooks, provide
 pnpm add @rebasepro/app
 ```
 
-**Peer dependencies:** `react >= 19`, `react-dom >= 19`, `react-router ^7`, `react-router-dom ^7`
+**Peer dependencies:** `react >= 19.2.7`, `react-dom >= 19.2.7`, `react-router ^8`
 
 ## What This Package Does
 

package/dist/auth/api.d.ts

@@ -8,13 +8,6 @@
  * here is the unauthenticated `/api/auth/config` probe used to detect
  * bootstrap mode and enabled providers before a session exists.
  */
-import { RebaseApiError } from "@rebasepro/types";
-/**
- * @deprecated Use {@link RebaseApiError} (from `@rebasepro/types`, re-exported by
- * `@rebasepro/client`). Kept as an alias so `instanceof` / imports keep working;
- * errors thrown here now carry `.code` and `.status` on the unified type.
- */
-export declare const AuthApiError: typeof RebaseApiError;
 /**
  * Auth config response from the backend
  */
@@ -59,7 +52,9 @@ export declare function createAuthConfigCache(): AuthConfigCache;
  * Concurrent calls are deduplicated: only one network request is made
  * and all callers share the same promise.
  */
-export declare function fetchAuthConfig(apiUrl: string, cache: AuthConfigCache): Promise<AuthConfigResponse>;
+export declare function fetchAuthConfig(apiUrl: string, cache: AuthConfigCache, 
+/** The backend's `basePath`; only needed if it is not the default. */
+apiPath?: string): Promise<AuthConfigResponse>;
 /**
  * Clear the cached auth config (e.g. on logout or for testing).
  */

package/dist/auth/index.d.ts

@@ -8,7 +8,7 @@
  * controller are in `../components`. Both are re-exported from the package
  * root, which is where applications should import them from.
  */
-export type { RebaseAuthController, RebaseAuthControllerProps, AuthTokens, DeviceSession, UserInfo, AuthResponse, RefreshResponse } from "./types";
+export type { RebaseAuthController, RebaseAuthControllerProps, User, AuthTokens, DeviceSession, AuthResponse, RefreshResponse } from "./types";
 export { useRebaseAuthController } from "./useRebaseAuthController";
-export { fetchAuthConfig, clearAuthConfigCache, createAuthConfigCache, AuthApiError } from "./api";
+export { fetchAuthConfig, clearAuthConfigCache, createAuthConfigCache } from "./api";
 export type { AuthConfigResponse, AuthConfigCache } from "./api";

package/dist/auth/types.d.ts

@@ -1,11 +1,7 @@
 import { User, AuthTokens, DeviceSession, RebaseSession, AuthChangeEvent } from "@rebasepro/types";
 import { AuthController } from "@rebasepro/admin-types";
 import type { AuthConfigResponse } from "./api";
-/** @deprecated Use `User` from `@rebasepro/types` instead. */
-export type UserInfo = User;
-/** @deprecated Use `DeviceSession` from `@rebasepro/types` instead. */
-export type Session = DeviceSession;
-export type { AuthTokens, DeviceSession };
+export type { User, AuthTokens, DeviceSession };
 /**
  * Auth controller that extends the base AuthController
  * with additional methods for email/password and Google login

package/dist/collections/filter-operator-resolution.d.ts

@@ -1,4 +1,28 @@
 import { Property, WhereFilterOp } from "@rebasepro/types";
+/**
+ * Whether a relation is one the collection's engine can compile into a
+ * `WHERE`.
+ *
+ * Which kinds those are is the *driver's* answer, not this function's, so it
+ * comes from {@link DataSourceCapabilities.filterableRelationKinds}. The admin
+ * is one UI over Postgres, MongoDB, Firestore and whatever a developer
+ * registers, and "a many-to-many compiles to an `EXISTS` over the junction" is
+ * a fact about the Postgres driver — true today, and not the sort of thing to
+ * assert on an engine's behalf.
+ *
+ * Offering an uncompilable filter is not a cosmetic bug. The Postgres driver
+ * used to drop a filter key it could not resolve, which *widened* the result
+ * set — filtering a many-to-many column returned every row instead of none.
+ * That now fails closed with a 400, which is correct for a real schema drift
+ * and wrong as the answer to a control the admin itself put on screen.
+ *
+ * A relation whose kind cannot be determined at all — no inline `relation`
+ * block and no stamped `resolvedRelation` — stays filterable. The server
+ * resolves relations before the config reaches the admin, so this is the
+ * hand-built-property case, and silently dropping a working filter there would
+ * be its own regression.
+ */
+export declare function isFilterableRelation(property: Property, engine?: string): boolean;
 export interface ResolveFilterOperatorsParams {
     /**
      * The property to filter on. For array properties, pass the **item**
@@ -24,8 +48,9 @@ export interface ResolveFilterOperatorsParams {
  * 2. what makes sense for the property type (e.g. no `>` on booleans);
  * 3. the developer's optional narrowing — `property.admin.filterOperators`.
  *
- * Returns an empty array when the property is not filterable (either by
- * type, or because the developer disabled it with `filterOperators: []`).
+ * Returns an empty array when the property is not filterable — by type, by
+ * developer narrowing (`filterOperators: []`), or because it is a relation the
+ * query layer has no column for (see {@link isFilterableRelation}).
  *
  * @group Models
  */

package/dist/collections/form-layout.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Form layout resolution.
+ *
+ * Turns a collection into the shape the entity form renders: an ordered list of
+ * sections holding grid-spanned fields, plus the metadata rail beside them.
+ *
+ * The reason this is a pure function rather than logic inside the form is that
+ * the *defaults* are the interesting part. A collection that never writes an
+ * `admin.form` block still has to get a two-column layout out of this — the flat
+ * run of full-width fields it produced before was the single biggest cost in the
+ * form, and no amount of config would have fixed it for collections nobody
+ * hand-tunes. Deriving it here means it is testable in isolation, which matters
+ * because "what span does a date get" is exactly the kind of rule that rots.
+ */
+import type { AdminCollection, PropertySpan } from "@rebasepro/admin-types";
+import type { Property } from "@rebasepro/types";
+/** A field placed on the grid. */
+export interface ResolvedFormField {
+    key: string;
+    /** Columns occupied, out of `GRID_COLUMNS`. Ignored in the rail. */
+    span: PropertySpan;
+    /** True for an `additionalFields` entry rather than a property. */
+    additional: boolean;
+    /**
+     * The span was written on the property rather than derived from its type.
+     * Row filling leaves these alone: an author who wrote a width meant it.
+     */
+    spanExplicit?: boolean;
+}
+export interface ResolvedFormSection {
+    key: string;
+    title?: string;
+    collapsible: boolean;
+    /** Initial state only; the form owns it after first interaction. */
+    collapsed: boolean;
+    fields: ResolvedFormField[];
+}
+export interface ResolvedFormLayout {
+    sections: ResolvedFormSection[];
+    /** Fields shown in the rail. Empty means no rail fields. */
+    sidebar: ResolvedFormField[];
+    /** Show the read-only id/created/updated block at the foot of the rail. */
+    showRecordMeta: boolean;
+    /** True when there is anything at all to put in the rail. */
+    hasRail: boolean;
+}
+export interface ResolveFormLayoutParams<M extends Record<string, unknown>> {
+    collection: AdminCollection<M>;
+    /**
+     * Field keys in render order, already filtered by `propertiesOrder` — i.e.
+     * the output of `getFormFieldKeys`. Passed in rather than recomputed so the
+     * form and the layout can never disagree about which fields exist.
+     */
+    fieldKeys: string[];
+    /**
+     * Which fields the user may edit right now. A manual id is editable while
+     * creating and frozen afterwards, and that decides whether it belongs in the
+     * form at all or only in the record block.
+     */
+    status: "new" | "existing" | "copy";
+}
+/**
+ * The span a property gets when nothing is declared.
+ *
+ * Deliberately coarse: three buckets, chosen by how much room the *editor*
+ * needs, not by how important the field is. Importance is what `admin.form`
+ * sections are for.
+ */
+export declare function deriveSpan(property: Property, isTitleProperty: boolean): PropertySpan;
+/**
+ * Can the user still type this id?
+ *
+ * A `manual` id is a real field while creating and frozen once the row exists.
+ * Every generated strategy (`uuid`, `cuid`, a raw SQL default) is never typed.
+ * Getting this wrong in the "frozen" direction would make manual-id collections
+ * uncreatable, so it fails towards showing the field.
+ */
+export declare function isIdPropertyEditable(property: Property, status: "new" | "existing" | "copy"): boolean;
+/**
+ * An audit timestamp the database maintains — `created_at`, `updated_at`.
+ *
+ * Not a guess from the name: `autoValue` says the column is written by the
+ * system on create or update, so the field is never typed. Rendering it as an
+ * input in the middle of the form promised an edit that cannot happen, and the
+ * record block already shows both values — the same two dates twice on one
+ * screen.
+ */
+export declare function isAuditTimestamp(property: Property | undefined): boolean;
+/**
+ * Close the trailing gap in each row.
+ *
+ * Without this a section of half-width fields with an odd count leaves a hole —
+ * `name | sku` then `brand | ␣␣` — a field stranded beside half a row of
+ * nothing, which reads as a mistake rather than a layout. The remainder is
+ * spread across the row's derived fields rather than dumped on the last one, so
+ * a lone half-width field becomes full width and a pair grows evenly. Fields
+ * with an explicit span are never resized.
+ */
+export declare function fillRows(fields: ResolvedFormField[]): ResolvedFormField[];
+/**
+ * Resolve the layout for a collection's generated form.
+ *
+ * Never drops a field: anything not named by a section lands in a trailing
+ * group, so adding a column to the database cannot make it silently invisible
+ * in the panel.
+ */
+export declare function resolveFormLayout<M extends Record<string, unknown>>({ collection, fieldKeys, status }: ResolveFormLayoutParams<M>): ResolvedFormLayout;

package/dist/collections/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./collection_view_config";
 export * from "./entity_image_preview";
 export * from "./filter-operator-resolution";
+export * from "./form-layout";
 export * from "./navigation_from_path";
 export * from "./navigation_utils";
 export * from "./parent_references_from_path";

package/dist/collections/title-property.d.ts

@@ -14,6 +14,28 @@ import type { AdminCollection } from "@rebasepro/admin-types";
  * @group Collections
  */
 export declare function getTitlePropertyCandidates<M extends Record<string, unknown>>(collection: AdminCollection<M>): string[];
+/**
+ * The relation a collection *leads* with, if it leads with one.
+ *
+ * A junction-shaped collection — a pipeline entry, a membership, a booking —
+ * holds no label of its own: it is "this candidate, for that vacancy". The
+ * general ranking puts relations last (they only read once the target
+ * resolves), so the title slot would otherwise fall to whatever free text
+ * happens to follow: a note, a comment. Preview surfaces that render one row
+ * per entity (list, cards, board) prefer the leading relation instead.
+ *
+ * The decision is structural — the first property that could be a title, in the
+ * order the developer declared (or ordered) them. Declaration order is a
+ * statement about what the collection is about; property *names* are not
+ * consulted here.
+ *
+ * Returns `undefined` when that first property is anything but a
+ * single-cardinality relation, or when the collection states its own
+ * `titleProperty`.
+ *
+ * @group Collections
+ */
+export declare function getLeadingRelationTitleKey<M extends Record<string, unknown>>(collection: AdminCollection<M>): string | undefined;
 /**
  * The property that should fill the title slot for a collection, ignoring any
  * concrete values. Prefer {@link getTitlePropertyKeyForValues} when an entity

package/dist/components/Debug/collection-views/sample_data.d.ts

@@ -1,3 +1,4 @@
+import type { ChipColorKey } from "@rebasepro/ui";
 export type ProjectStatus = "backlog" | "in_progress" | "in_review" | "done";
 export type ProjectPriority = "low" | "medium" | "high" | "critical";
 export interface SampleProject {
@@ -14,10 +15,10 @@ export interface SampleProject {
 }
 export declare const STATUS_CONFIG: Record<ProjectStatus, {
     label: string;
-    color: string;
+    color: ChipColorKey;
 }>;
 export declare const PRIORITY_CONFIG: Record<ProjectPriority, {
     label: string;
-    color: string;
+    color: ChipColorKey;
 }>;
 export declare const SAMPLE_PROJECTS: SampleProject[];

package/dist/components/LoginView/LoginView.d.ts

@@ -104,10 +104,18 @@ export interface LoginViewProps {
      * Pre-fill the password field (e.g. for demo or testing environments).
      */
     defaultPassword?: string;
+    /**
+     * When set, the email/password forms render a "Join the newsletter"
+     * opt-in checkbox. Called with the address that just authenticated —
+     * sign-in or registration — if the box was ticked. Wire it to whatever
+     * stores the subscription; failures are the callback's problem, the
+     * login flow never waits on it.
+     */
+    onNewsletterOptIn?: (email: string) => void;
 }
 /**
  * Generic login view component that works with any AuthControllerExtended.
  * Feature-detects capabilities to show/hide login methods.
  * @group Core
  */
-export declare function LoginView({ logo, authController, noUserComponent, disableSignupScreen, disabled, notAllowedError, googleClientId, githubClientId, linkedinClientId, title, subtitle, needsSetup, registrationEnabled, additionalComponent, topComponent, defaultEmail, defaultPassword }: LoginViewProps): React.JSX.Element;
+export declare function LoginView({ logo, authController, noUserComponent, disableSignupScreen, disabled, notAllowedError, googleClientId, githubClientId, linkedinClientId, title, subtitle, needsSetup, registrationEnabled, additionalComponent, topComponent, defaultEmail, defaultPassword, onNewsletterOptIn }: LoginViewProps): React.JSX.Element;

package/dist/components/RebaseAuth.d.ts

@@ -1,10 +1,10 @@
-import type { RebaseAuthConfig } from "@rebasepro/admin-types";
+import type { RebaseAuthViewConfig } from "@rebasepro/admin-types";
 /**
  * Declarative component to configure authentication in Rebase.
  * Renders nothing — purely registers config into the RebaseRegistry.
  *
  * This is a framework-level component that lives in core since
- * authentication is cross-cutting (CMS, Studio, any app area).
+ * authentication is cross-cutting (admin, Studio, any app area).
  * @group Core
  */
-export declare function RebaseAuth({ loginView }: RebaseAuthConfig): null;
+export declare function RebaseAuth({ loginView }: RebaseAuthViewConfig): null;

package/dist/core/Rebase.d.ts

@@ -2,7 +2,7 @@ import type { RebaseProps } from "./RebaseProps";
 import React from "react";
 import { User } from "@rebasepro/types";
 /**
- * If you are using independent components of the CMS
+ * If you are using independent components of the admin
  * you need to wrap them with this main component, so the internal hooks work.
  *
  * This is the main component of Rebase. It acts as the provider of all the

package/dist/core/RebaseProps.d.ts

@@ -43,10 +43,8 @@ type DeepPartial<T> = T extends object ? {
  * Controller to simulate different roles when dev mode is active.
  * @group Models
  */
-export interface EffectiveRoleController {
-    effectiveRole: string | null;
-    setEffectiveRole: (role: string | null) => void;
-}
+export type { EffectiveRoleController } from "@rebasepro/types";
+import type { EffectiveRoleController } from "@rebasepro/types";
 /**
  * Props for the main {@link Rebase} component.
  *
@@ -116,7 +114,7 @@ export type RebaseProps<USER extends User> = {
      */
     basePath?: string;
     /**
-     * Optional base path for the CMS collections.
+     * Optional base path for the admin collections.
      * Defaults to "/c"
      */
     baseCollectionPath?: string;
@@ -127,12 +125,12 @@ export type RebaseProps<USER extends User> = {
      */
     apiUrl?: string;
     /**
-     * Format of the dates in the CMS.
+     * Format of the dates in the admin.
      * Defaults to 'MMMM dd, yyyy, HH:mm:ss'
      */
     dateTimeFormat?: string;
     /**
-     * Locale of the CMS, currently only affecting dates
+     * Locale of the admin, currently only affecting dates
      */
     locale?: Locale;
     /**
@@ -228,7 +226,7 @@ export type RebaseProps<USER extends User> = {
      */
     userConfigPersistence?: UserConfigurationPersistence;
     /**
-     * Callback used to get analytics events from the CMS
+     * Callback used to get analytics events from the admin
      */
     onAnalyticsEvent?: (event: AnalyticsEvent, data?: object) => void;
     /**
@@ -237,11 +235,11 @@ export type RebaseProps<USER extends User> = {
      */
     entityLinkBuilder?: EntityLinkBuilder;
     /**
-     * Plugins loaded in the CMS
+     * Plugins loaded in the admin
      */
     plugins?: RebasePlugin[];
     /**
-     * Extra slots for the CMS
+     * Extra slots for the admin
      */
     slots?: SlotContribution[];
     /**
@@ -289,4 +287,3 @@ export type RebaseProps<USER extends User> = {
      */
     components?: ComponentOverrideMap;
 };
-export {};

package/dist/hooks/ApiConfigContext.d.ts

@@ -8,17 +8,51 @@ import React from "react";
  */
 export interface ApiConfig {
     apiUrl: string;
+    /**
+     * The path the backend mounts its API under, appended to {@link apiUrl}.
+     *
+     * `"/api"` by default, which is the server's default `basePath`. It is
+     * carried here because a good deal of UI builds request URLs by hand
+     * instead of going through the client's typed methods, and every one of
+     * those sites used to write `/api` as a literal — so a backend configured
+     * with any other `basePath` served an admin panel whose auth-provider
+     * discovery, storage browser, history panel, user picker and Studio tools
+     * all requested paths that did not exist.
+     */
+    apiPath: string;
     getAuthToken?: () => Promise<string | null>;
 }
+/** What the server uses when `basePath` is not configured. */
+export declare const DEFAULT_API_PATH = "/api";
 /**
  * Read the API config from context. Returns `undefined` if no provider is present,
  * allowing hooks to fall back to their own props.
  */
 export declare function useApiConfig(): ApiConfig | undefined;
 /**
- * Provide API configuration (apiUrl, getAuthToken) to the entire subtree.
+ * `apiUrl` and `apiPath` joined, with no trailing slash — the prefix to build a
+ * request URL from.
+ *
+ * Returns `undefined` when there is no provider, so a caller can keep its own
+ * fallback rather than silently requesting a relative path.
+ */
+export declare function useApiBase(): string | undefined;
+/**
+ * The same prefix, derived from a client rather than from context.
+ *
+ * For the code that holds a `RebaseClient` but sits outside (or above) an
+ * `ApiConfigProvider`. Returns `undefined` when the client has no base URL,
+ * which is the signal every caller already treats as "cannot build a request".
+ */
+export declare function apiBaseOf(client?: {
+    baseUrl?: string;
+    apiPath?: string;
+}): string | undefined;
+/**
+ * Provide API configuration (apiUrl, apiPath, getAuthToken) to the entire subtree.
  * Typically rendered inside `<Rebase>` or at the app root.
  */
-export declare function ApiConfigProvider({ apiUrl, getAuthToken, children }: ApiConfig & {
+export declare function ApiConfigProvider({ apiUrl, apiPath, getAuthToken, children }: Omit<ApiConfig, "apiPath"> & {
+    apiPath?: string;
     children: React.ReactNode;
 }): React.JSX.Element;

package/dist/hooks/useBackendStorageSource.d.ts

@@ -7,6 +7,11 @@ export interface BackendStorageSourceProps {
      * Backend API URL (e.g., 'http://localhost:3001')
      */
     apiUrl: string;
+    /**
+     * The path the backend mounts its API under. Defaults to the server's own
+     * default; pass the backend's `basePath` if it was configured otherwise.
+     */
+    apiPath?: string;
     /**
      * Function to get the current auth token
      */
@@ -27,4 +32,4 @@ export interface BackendStorageSourceProps {
  * <Rebase storageSource={storageSource} ... />
  * ```
  */
-export declare function useBackendStorageSource({ apiUrl, getAuthToken }: BackendStorageSourceProps): StorageSource;
+export declare function useBackendStorageSource({ apiUrl, apiPath, getAuthToken }: BackendStorageSourceProps): StorageSource;

package/dist/hooks/useBuildModeController.d.ts

@@ -1,6 +1,6 @@
 import type { ModeController } from "./useModeController";
 /**
  * Use this hook to build a color mode controller that determines
- * the theme of the CMS
+ * the theme of the admin
  */
 export declare function useBuildModeController(): ModeController;

package/dist/hooks/useCustomizationController.d.ts

@@ -2,7 +2,7 @@ import type { CustomizationController } from "@rebasepro/admin-types";
 /**
  * Use this hook to retrieve the customization controller.
  * This hook includes all the customization options that can be used
- * to customize the CMS.
+ * to customize the admin.
  *
  * You will likely not need to use this hook directly.
  *

package/dist/hooks/useNavigationBlocker.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { Blocker, BlockerFunction } from "react-router-dom";
+import { Blocker, BlockerFunction } from "react-router";
 /**
  * Owns the single React Router blocker for the whole app.
  *

package/dist/hooks/useRebaseRegistry.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, RebaseAuthConfig } from "@rebasepro/admin-types";
+import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, RebaseAuthViewConfig } from "@rebasepro/admin-types";
 /**
  * Split into two contexts to prevent infinite re-render loops:
  * - DispatchContext: stable register/unregister functions (never changes identity)
@@ -10,11 +10,11 @@ import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, R
  * RebaseShell consumes state context to read the collected configs.
  */
 interface RegistryDispatch {
-    registerCMS: (config: RebaseAdminConfig) => void;
-    unregisterCMS: () => void;
+    registerAdmin: (config: RebaseAdminConfig) => void;
+    unregisterAdmin: () => void;
     registerStudio: (config: RebaseStudioConfig) => void;
     unregisterStudio: () => void;
-    registerAuth: (config: RebaseAuthConfig) => void;
+    registerAuth: (config: RebaseAuthViewConfig) => void;
     unregisterAuth: () => void;
 }
 export declare function RebaseRegistryProvider({ children }: {

package/dist/hooks/useSnackbarController.d.ts

@@ -1,4 +1,4 @@
-import type { SnackbarMessageType } from "@rebasepro/admin-types";
+import type { SnackbarAction, SnackbarMessageType } from "@rebasepro/admin-types";
 import React from "react";
 /**
  * Hook to retrieve the SnackbarContext.
@@ -15,6 +15,7 @@ export declare const useSnackbarController: () => {
         title?: string;
         message: React.ReactNode;
         autoHideDuration?: number;
+        action?: SnackbarAction;
     }) => void;
     close: () => void;
 };

package/dist/hooks/useStudioBridge.d.ts

@@ -3,9 +3,9 @@ import type { CollectionRegistryController } from "@rebasepro/types";
 import type { SidePanelController, UrlController, NavigationStateController, BreadcrumbEntry, BreadcrumbsController } from "@rebasepro/admin-types";
 export type { BreadcrumbEntry, BreadcrumbsController };
 /**
- * StudioBridge provides optional CMS capabilities to Studio components.
- * When CMS is present, a bridge provider injects real implementations.
- * When CMS is absent, noop defaults ensure Studio works standalone.
+ * StudioBridge provides optional admin capabilities to Studio components.
+ * When the admin is present, a bridge provider injects real implementations.
+ * When the admin is absent, noop defaults ensure Studio works standalone.
  */
 export interface StudioBridge {
     collectionRegistry: CollectionRegistryController;
@@ -13,13 +13,38 @@ export interface StudioBridge {
     urlController: UrlController;
     navigationState: NavigationStateController;
     breadcrumbs: BreadcrumbsController;
+    capabilities: StudioCapabilities;
+}
+/**
+ * What the *host* of these tools can do, as opposed to what the backend can.
+ *
+ * Studio is mounted in two very different places. In a project's own admin
+ * panel it runs next to the collection source files and can edit them through
+ * the schema-editor routes. In the hosted console it runs against somebody
+ * else's deployed container: there is no source to edit — the container is
+ * rebuilt from the customer's repository on every deploy — and the routes that
+ * would edit it are not mounted at all, because the framework switches the
+ * schema editor off under `NODE_ENV=production`.
+ *
+ * Tools that would otherwise offer a write into the codebase read this to
+ * decide whether that write is even meaningful.
+ */
+export interface StudioCapabilities {
+    /**
+     * Whether the host has the project's collection source at hand and can
+     * write to it.
+     *
+     * Defaults to `true`, which is what an admin panel running beside its own
+     * `collectionsDir` has always assumed.
+     */
+    codebase: boolean;
 }
 export declare const StudioBridgeContext: React.Context<StudioBridge>;
 /**
- * Provider that injects CMS capabilities into Studio.
+ * Provider that injects admin capabilities into Studio.
  * Accepts partial overrides — any field not provided falls back to noop.
  *
- * Usage (in app wiring, when CMS is present):
+ * Usage (in app wiring, when the admin is present):
  * ```tsx
  * <StudioBridgeProvider value={{
  *     collectionRegistry: useCollectionRegistryController(),
@@ -36,16 +61,18 @@ export declare function StudioBridgeProvider({ value, children }: {
     value: Partial<StudioBridge>;
     children: React.ReactNode;
 }): React.JSX.Element;
-/** Collection registry — returns noop if CMS is not present. */
+/** Collection registry — returns noop if the admin is not present. */
 export declare function useStudioCollectionRegistry(): CollectionRegistryController;
-/** Side panel controller — returns noop if CMS is not present. */
+/** Side panel controller — returns noop if the admin is not present. */
 export declare function useStudioSidePanelController(): SidePanelController;
-/** URL controller — returns noop if CMS is not present. */
+/** URL controller — returns noop if the admin is not present. */
 export declare function useStudioUrlController(): UrlController;
-/** Navigation state — returns noop if CMS is not present. */
+/** Navigation state — returns noop if the admin is not present. */
 export declare function useStudioNavigationState(): NavigationStateController;
-/** Breadcrumbs controller — returns noop if CMS is not present. */
+/** Breadcrumbs controller — returns noop if the admin is not present. */
 export declare function useStudioBreadcrumbs(): BreadcrumbsController;
+/** What the host can do — see {@link StudioCapabilities}. */
+export declare function useStudioCapabilities(): StudioCapabilities;
 /**
  * Registry that controllers use to self-register their implementations
  * into the Studio bridge. Each controller calls `register(key, value)`

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export * from "./auth";
 export * from "./components";
 export * from "./util";
 export * from "./contexts";
-export { CONTAINER_FULL_WIDTH, ADDITIONAL_TAB_WIDTH, FORM_CONTAINER_WIDTH } from "./internal/common";
+export { CONTAINER_FULL_WIDTH, FORM_CONTAINER_WIDTH, SIDE_PANEL_DEFAULT_WIDTH } from "./internal/common";
 export { useRestoreScroll } from "./internal/useRestoreScroll";
 export { useUnsavedChangesDialog } from "./hooks/useUnsavedChangesDialog";
 export { NavigationBlockerProvider, useNavigationBlocker } from "./hooks/useNavigationBlocker";