@rebasepro/admin 0.16.0 → 0.16.1-canary.g2d1aec8

package/dist/collection_editor/liveSchemaClient.d.ts

@@ -0,0 +1,170 @@
+/**
+ * The panel's client for live schema editing.
+ *
+ * Three calls, mirroring the routes: ask whether this backend can do it, ask
+ * what a change would do, then do it. `plan` and `apply` are deliberately
+ * separate here as well as on the server, because a UI that could only
+ * try-and-see would be asking somebody to discover that their change is refused
+ * by pressing a button on a live database.
+ *
+ * ## Partial payloads are the caller's problem, not this module's
+ *
+ * Every call takes the **whole** collection. Live editing computes the proposed
+ * state by replacing one collection in the set, so a patch would read as a set
+ * of removals — every property it does not mention — and be refused.
+ *
+ * The editor's own save path posts partials (`saveProperty` follows up with a
+ * one-key `collection/save` carrying `partial: true`), so
+ * `useLocalCollectionsConfigController` assembles the whole collection before
+ * it gets here. Accepting a patch and merging it in this module would put that
+ * reconstruction one layer away from the collections it needs to read.
+ */
+/** A constraint the change asks for that the statements will not carry. */
+export interface WithheldConstraint {
+    target: string;
+    kind: "not-null";
+    reason: string;
+    remedy: string;
+}
+/** What the server says a change would do. Mirrors `SchemaChangePlan`. */
+export interface LiveSchemaPlan {
+    applicable: boolean;
+    verdict: "safe" | "diverges" | "needs-migration";
+    changes: Array<{
+        kind: string;
+        verdict: "safe" | "diverges" | "needs-migration";
+        collection: string;
+        property?: string;
+        detail: string;
+        remedy?: string;
+    }>;
+    statements: string[];
+    files: string[];
+    message: string;
+    /**
+     * Applicable, and still not fully enforced.
+     *
+     * Not a refusal, so it does not belong in `changes` — but it is the one
+     * thing on a plan somebody might want to stop and read, so the dialog gives
+     * it its own place rather than another bullet in the list.
+     */
+    withheldConstraints: WithheldConstraint[];
+}
+export interface LiveSchemaResult {
+    applied: boolean;
+    applyError?: string;
+    committed: {
+        sha: string;
+        branch: string;
+        files: string[];
+    };
+    statements: string[];
+    summary: string;
+    withheldConstraints: WithheldConstraint[];
+}
+/**
+ * Whether this backend can edit its schema, and what is missing when it cannot.
+ *
+ * `canPlan` is separate from `enabled` deliberately: previewing a change needs
+ * no repository, so a deployment running from a bundle can still show somebody
+ * exactly what their change would do. Greying out the preview as well would be
+ * a worse answer than the truth.
+ */
+export interface LiveSchemaStatus {
+    enabled: boolean;
+    canPlan: boolean;
+    /**
+     * Whether *this caller* may apply, as opposed to whether the server can.
+     *
+     * Applying commits to the repository under an author, and a credential is
+     * not an author — so an API key or the service key may preview a change and
+     * not make one. Reported here so the panel can grey out the button and say
+     * why, rather than letting somebody read a plan, decide, press, and only
+     * then be refused.
+     */
+    canApply: boolean;
+    applyRefusedBecause?: string;
+    applyRefusedCode?: string;
+    repository?: string;
+    code?: string;
+    reason?: string;
+}
+/**
+ * Why live editing is not available here.
+ *
+ * Distinguished from an ordinary failure because both are expected states with
+ * their own explanation, and a UI should say which rather than showing a
+ * stack: a Mongo backend will never support this, and a bundle deployment has
+ * no source to edit.
+ */
+export type LiveSchemaUnavailable = {
+    reason: "unsupported";
+    message: string;
+} | {
+    reason: "no-repository";
+    message: string;
+};
+export declare class LiveSchemaError extends Error {
+    readonly code: string | undefined;
+    readonly changes?: LiveSchemaPlan["changes"] | undefined;
+    constructor(message: string, code: string | undefined, changes?: LiveSchemaPlan["changes"] | undefined);
+}
+export interface LiveSchemaClientOptions {
+    /** Base for the routes, e.g. `https://api.example.com/api/schema`. */
+    baseUrl: string;
+    getAuthToken?: () => Promise<string | null> | string | null;
+    fetchImpl?: typeof fetch;
+}
+export interface ProposedCollectionChange {
+    collectionId: string;
+    /**
+     * The **whole** collection as it should end up — not a patch. See the
+     * module comment: a partial reads as a set of removals.
+     */
+    collection: Record<string, unknown>;
+}
+export declare function createLiveSchemaClient(options: LiveSchemaClientOptions): {
+    /**
+     * Whether this backend can edit its schema.
+     *
+     * Never throws. Every way of failing to get an answer — a backend too
+     * old to have the endpoint, an unreachable one, a session that is not
+     * an admin — means the same thing to a caller deciding whether to offer
+     * the control, and turning that into an exception each caller has to
+     * catch would only produce four copies of this `catch`.
+     */
+    status: () => Promise<LiveSchemaStatus>;
+    /** What the change would do. No side effects. */
+    plan: (change: ProposedCollectionChange) => Promise<LiveSchemaPlan>;
+    /** Commit the change, then apply it. */
+    apply: (change: ProposedCollectionChange) => Promise<LiveSchemaResult>;
+};
+/** The client's shape, for the hook and the tests that fake it. */
+export type LiveSchemaClient = ReturnType<typeof createLiveSchemaClient>;
+/**
+ * Whether an error means live editing is unavailable here, rather than that the
+ * change was wrong.
+ *
+ * Returns the reason so a caller can say which, and `undefined` for anything
+ * else — a refused change is not an unavailable feature, and conflating them
+ * would hide the refusal that the user needs to read.
+ */
+export declare function asUnavailable(err: unknown): LiveSchemaUnavailable | undefined;
+/** The person closed the dialog without applying. Not an error; an answer. */
+export declare class SchemaChangeCancelled extends Error {
+    constructor();
+}
+/**
+ * Was this rejection the person saying no?
+ *
+ * A save has to *reject* when it is cancelled — resolving would leave the form
+ * believing it saved. But a caller that treats every rejection as a failure
+ * then reports the user's own choice back to them as an error, which is what
+ * the collection editor did: a console error and a red snackbar reading "Error
+ * persisting collection: The schema change was not applied."
+ *
+ * Matched by name rather than `instanceof`, which is unreliable the moment two
+ * copies of this module end up in one bundle — the class is then a different
+ * identity and every check silently answers false.
+ */
+export declare function isSchemaChangeCancelled(err: unknown): boolean;

package/dist/collection_editor/serializable_utils.d.ts

@@ -9,7 +9,7 @@
  */
 import { type Properties, type Property } from "@rebasepro/types";
 import type { AdminCollection } from "@rebasepro/admin-types";
-import type { SerializableCollectionConfig, SerializableProperties, SerializableProperty } from "./serializable_types";
+import type { SerializableCollectionConfig, SerializableProperties, SerializableProperty } from "./serializable_types.js";
 /**
  * Resolves a collection slug to the collection it names.
  *

package/dist/collection_editor/types/collection_editor_controller.d.ts

@@ -1,4 +1,4 @@
-import { CollectionsConfigController } from "./config_controller";
+import { CollectionsConfigController } from "./config_controller.js";
 import { Entity, Property } from "@rebasepro/types";
 import type { AdminCollection } from "@rebasepro/admin-types";
 /**

package/dist/collection_editor/types/config_controller.d.ts

@@ -1,3 +1,4 @@
+import type React from "react";
 import { Property } from "@rebasepro/types";
 import { NavigationGroupMapping, AdminCollection } from "@rebasepro/admin-types";
 export interface CollectionsSetupInfo {
@@ -45,6 +46,16 @@ export interface CollectionsConfigController {
     updateKanbanColumnsOrder: (params: UpdateKanbanColumnsOrderParams) => Promise<void>;
     navigationEntries: NavigationGroupMapping[];
     saveNavigationEntries: (entries: NavigationGroupMapping[]) => Promise<void>;
+    /**
+     * UI this controller needs on screen in order to do its job.
+     *
+     * A controller whose writes require a confirmation has to be able to ask,
+     * and a hook cannot render. `ConfigControllerProvider` renders this beside
+     * its children, so the confirmation belongs to whoever supplied the
+     * controller rather than to every consumer of it. Optional: most
+     * controllers write without asking anybody.
+     */
+    dialog?: React.ReactNode;
 }
 export type UpdateCollectionParams<M extends Record<string, unknown> = Record<string, unknown>> = {
     id: string;

package/dist/collection_editor/ui/collection_editor/AICollectionGeneratorPopover.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { CollectionGenerationCallback, CollectionOperation } from "../../api/generateCollectionApi";
+import { CollectionGenerationCallback, CollectionOperation } from "../../api/generateCollectionApi.js";
 import type { AdminCollection } from "@rebasepro/admin-types";
 export interface AICollectionGeneratorPopoverProps {
     /**

package/dist/collection_editor/ui/collection_editor/AIModifiedPathsContext.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { CollectionOperation } from "../../api/generateCollectionApi";
+import { CollectionOperation } from "../../api/generateCollectionApi.js";
 export interface AIModifiedPathsContextType {
     /** Set of paths that were modified by AI */
     modifiedPaths: Set<string>;

package/dist/collection_editor/ui/collection_editor/CollectionEditorDialog.d.ts

@@ -1,10 +1,10 @@
 import * as React from "react";
 import { Entity, TableMetadata, User } from "@rebasepro/types";
 import { AdminCollection } from "@rebasepro/admin-types";
-import { CollectionsConfigController } from "../../types/config_controller";
-import { CollectionInference } from "../../types/collection_inference";
-import { CollectionGenerationCallback } from "../../api/generateCollectionApi";
-import type { CollectionEditorExtensionProps } from "../../extensibility_types";
+import { CollectionsConfigController } from "../../types/config_controller.js";
+import { CollectionInference } from "../../types/collection_inference.js";
+import { CollectionGenerationCallback } from "../../api/generateCollectionApi.js";
+import type { CollectionEditorExtensionProps } from "../../extensibility_types.js";
 export interface CollectionEditorDialogProps extends CollectionEditorExtensionProps {
     open: boolean;
     isNewCollection: boolean;

package/dist/collection_editor/ui/collection_editor/CollectionEditorWelcomeView.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { CollectionGenerationCallback } from "../../api/generateCollectionApi";
+import { CollectionGenerationCallback } from "../../api/generateCollectionApi.js";
 import type { AdminCollection } from "@rebasepro/admin-types";
 export declare function CollectionEditorWelcomeView({ path, parentCollection, onContinue, existingCollectionPaths, generateCollection, onAnalyticsEvent, unmappedTables, onImportFromTable }: {
     path: string;

package/dist/collection_editor/ui/collection_editor/CollectionPropertiesEditorForm.d.ts

@@ -1,8 +1,8 @@
 import React from "react";
 import { User } from "@rebasepro/types";
 import { PropertyConfig, AdminCollection } from "@rebasepro/admin-types";
-import type { PropertyTypePreset, PropertyType } from "../../extensibility_types";
-import type { SerializableProperty, SerializableCollectionConfig } from "../../serializable_types";
+import type { PropertyTypePreset, PropertyType } from "../../extensibility_types.js";
+import type { SerializableProperty, SerializableCollectionConfig } from "../../serializable_types.js";
 type CollectionEditorFormProps = {
     showErrors: boolean;
     isNewCollection: boolean;

package/dist/collection_editor/ui/collection_editor/CollectionStudioView.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { CollectionEditorDialogProps } from "./CollectionEditorDialog";
+import { CollectionEditorDialogProps } from "./CollectionEditorDialog.js";
 import type { AdminCollection } from "@rebasepro/admin-types";
 export type CollectionStudioViewProps = Omit<CollectionEditorDialogProps, "open" | "isNewCollection" | "editedCollectionId" | "handleClose" | "handleCancel"> & {
     collectionId?: string | "new";

package/dist/collection_editor/ui/collection_editor/CollectionsStudioView.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
-import { CollectionsConfigController } from "../../types/config_controller";
-import type { CollectionEditorExtensionProps } from "../../extensibility_types";
+import { CollectionsConfigController } from "../../types/config_controller.js";
+import type { CollectionEditorExtensionProps } from "../../extensibility_types.js";
 import type { AdminCollection } from "@rebasepro/admin-types";
 export interface CollectionsStudioViewProps extends CollectionEditorExtensionProps {
     configController: CollectionsConfigController;

package/dist/collection_editor/ui/collection_editor/GeneralSettingsForm.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import type { ExtraCollectionFieldsParams } from "../../extensibility_types";
+import type { ExtraCollectionFieldsParams } from "../../extensibility_types.js";
 import type { AdminCollection } from "@rebasepro/admin-types";
 export declare function GeneralSettingsForm({ isNewCollection, existingPaths, existingIds, parentCollection, renderExtraCollectionFields, standalone, }: {
     isNewCollection: boolean;

package/dist/collection_editor/ui/collection_editor/PropertyEditView.d.ts

@@ -2,8 +2,8 @@ import React from "react";
 import { FormexController } from "@rebasepro/forms";
 import { Property } from "@rebasepro/types";
 import { PropertyConfig, AdminCollection } from "@rebasepro/admin-types";
-import type { PropertyTypePreset, PropertyType } from "../../extensibility_types";
-import type { SerializableProperty, SerializableCollectionConfig } from "../../serializable_types";
+import type { PropertyTypePreset, PropertyType } from "../../extensibility_types.js";
+import type { SerializableProperty, SerializableCollectionConfig } from "../../serializable_types.js";
 export type PropertyWithId = Property & {
     id?: string;
     conditions?: import("@rebasepro/types").PropertyConditions;

package/dist/collection_editor/ui/collection_editor/RouterCollectionStudioView.d.ts

@@ -10,6 +10,6 @@
  * (which has no react-router dependency).
  */
 import React from "react";
-import { CollectionStudioViewProps } from "./CollectionStudioView";
+import { CollectionStudioViewProps } from "./CollectionStudioView.js";
 export type RouterCollectionStudioViewProps = Omit<CollectionStudioViewProps, "onSave" | "onCancel">;
 export declare function RouterCollectionStudioView(props: RouterCollectionStudioViewProps): React.JSX.Element;

package/dist/collection_editor/ui/collection_editor/RouterCollectionsStudioView.d.ts

@@ -9,6 +9,6 @@
  * (which has no react-router dependency).
  */
 import React from "react";
-import { CollectionsStudioViewProps } from "./CollectionsStudioView";
+import { CollectionsStudioViewProps } from "./CollectionsStudioView.js";
 export type RouterCollectionsStudioViewProps = Omit<CollectionsStudioViewProps, "activeCollectionId" | "onActiveCollectionChange">;
 export declare function RouterCollectionsStudioView(props: RouterCollectionsStudioViewProps): React.JSX.Element;

package/dist/collection_editor/ui/collection_editor/SchemaChangeDialog.d.ts

@@ -0,0 +1,66 @@
+/**
+ * What a schema change would do, before it does it.
+ *
+ * The dialog exists because a schema change has three possible verdicts and two
+ * of them are refusals. Without a preview, the only way to discover that a
+ * change is refused is to press a button on a live database and read what comes
+ * back — which is a fine way to learn and a poor way to work.
+ *
+ * ## What it shows, in the order somebody reads it
+ *
+ * The verdict first, in a sentence, because it decides whether the rest is
+ * worth reading. Then the changes, each with what it does and — when it is
+ * refused — what to do instead. Then the things that are easy to skip past and
+ * expensive to have skipped: constraints the change asks for that the database
+ * will not end up enforcing. The SQL and the file list come last, collapsed,
+ * for the reader who wants them; they are the evidence, not the summary.
+ *
+ * ## Why the button says "Commit and apply"
+ *
+ * Because that is the order, and the order is the feature. The commit lands
+ * first, so a failed apply leaves the repository ahead of the database — the
+ * ordinary state of every project between an edit and a deploy, which the next
+ * boot reconciles. A button labelled "Save" would be describing a different,
+ * worse thing.
+ */
+import React from "react";
+import type { LiveSchemaPlan, LiveSchemaResult } from "../../liveSchemaClient.js";
+export interface SchemaChangeDialogProps {
+    open: boolean;
+    /** The collection being changed, for the title. */
+    collectionId: string;
+    /** `undefined` while the plan is still being fetched. */
+    plan?: LiveSchemaPlan;
+    /** Set when planning itself failed — a network error, a refusal, a 500. */
+    planError?: string;
+    /** Set once the change has been applied, which turns this into a receipt. */
+    result?: LiveSchemaResult;
+    applying: boolean;
+    /** Set when the apply threw rather than returning a result. */
+    applyError?: string;
+    onConfirm: () => void;
+    /**
+     * Write the collection source and leave the database alone.
+     *
+     * Offered only when the change is refused, and it is what keeps the editor
+     * usable while it is. Removing a property is the ordinary case: the ensure
+     * path has no `DROP COLUMN`, so a removal can never be applied — and
+     * refusing the whole save over it would mean a dev could no longer delete a
+     * field from a collection they are still designing.
+     *
+     * This is exactly what the editor did before live editing existed, so it is
+     * not a new hazard; the difference is that it now says what it leaves
+     * behind instead of reporting success.
+     */
+    onSourceOnly?: () => void;
+    onClose: () => void;
+    /**
+     * Why this caller may preview but not apply, when that is the case.
+     *
+     * A person signed in with an API key, most often. Shown next to a disabled
+     * button so the refusal arrives while they are deciding rather than after
+     * they have decided.
+     */
+    applyRefusedBecause?: string;
+}
+export declare function SchemaChangeDialog({ open, collectionId, plan, planError, result, applying, applyError, onConfirm, onSourceOnly, onClose, applyRefusedBecause }: SchemaChangeDialogProps): React.JSX.Element;

package/dist/collection_editor/ui/collection_editor/SubcollectionsEditTab.d.ts

@@ -1,8 +1,8 @@
 import React from "react";
 import { User } from "@rebasepro/types";
 import { AdminCollection } from "@rebasepro/admin-types";
-import { CollectionsConfigController } from "../../types/config_controller";
-import { CollectionInference } from "../../types/collection_inference";
+import { CollectionsConfigController } from "../../types/config_controller.js";
+import { CollectionInference } from "../../types/collection_inference.js";
 export declare function SubcollectionsEditTab({ collection, parentCollection, configController, collectionInference, getUser, parentCollectionSlugs }: {
     collection: AdminCollection;
     parentCollection?: AdminCollection;

package/dist/collection_editor/ui/collection_editor/import/CollectionEditorImportDataPreview.d.ts

@@ -1,4 +1,4 @@
-import { ImportConfig } from "../../../_cms_internals";
+import { ImportConfig } from "../../../_cms_internals.js";
 import { Properties } from "@rebasepro/types";
 export declare function CollectionEditorImportDataPreview({ importConfig, properties, propertiesOrder }: {
     importConfig: ImportConfig;

package/dist/collection_editor/ui/collection_editor/import/CollectionEditorImportMapping.d.ts

@@ -1,4 +1,4 @@
-import { ImportConfig } from "../../../../data_import/types";
+import { ImportConfig } from "../../../../data_import/types/index.js";
 import { PropertyConfig } from "@rebasepro/admin-types";
 import React from "react";
 export declare function CollectionEditorImportMapping({ importConfig, propertyConfigs }: {

package/dist/collection_editor/ui/collection_editor/import/clean_import_data.d.ts

@@ -1,5 +1,5 @@
 import { Properties } from "@rebasepro/types";
-import { ImportConfig } from "../../../_cms_internals";
+import { ImportConfig } from "../../../_cms_internals.js";
 export declare function cleanPropertiesFromImport(properties: Properties, parentSlug?: string): {
     headersMapping: ImportConfig["headersMapping"];
     properties: Properties;

package/dist/collection_editor/ui/collection_editor/properties/conditions/index.d.ts

@@ -1,6 +1,6 @@
-export { ConditionsPanel } from "./ConditionsPanel";
-export { ConditionsEditor } from "./ConditionsEditor";
-export type { ConditionsEditorProps } from "./ConditionsEditor";
-export { EnumConditionsEditor } from "./EnumConditionsEditor";
-export type { EnumConditionsEditorProps } from "./EnumConditionsEditor";
-export { getPropertyPaths, getGroupedPropertyPaths } from "./property_paths";
+export { ConditionsPanel } from "./ConditionsPanel.js";
+export { ConditionsEditor } from "./ConditionsEditor.js";
+export type { ConditionsEditorProps } from "./ConditionsEditor.js";
+export { EnumConditionsEditor } from "./EnumConditionsEditor.js";
+export type { EnumConditionsEditorProps } from "./EnumConditionsEditor.js";
+export { getPropertyPaths, getGroupedPropertyPaths } from "./property_paths.js";

package/dist/collection_editor/useCollectionEditorController.d.ts

@@ -1,4 +1,4 @@
-import { CollectionEditorController } from "./types/collection_editor_controller";
+import { CollectionEditorController } from "./types/collection_editor_controller.js";
 /**
  * Hook to access the collection editor controller.
  * The methods in this controller can be used to open the collection editor dialog.

package/dist/collection_editor/useCollectionsConfigController.d.ts

@@ -1,4 +1,4 @@
-import { CollectionsConfigController } from "./types/config_controller";
+import { CollectionsConfigController } from "./types/config_controller.js";
 /**
  * Use this hook to access the configuration controller.
  * You can use it to get the list of collections, and to save/delete collections.

package/dist/collection_editor/useJsonCollectionsConfigController.d.ts

@@ -1,5 +1,5 @@
-import type { CollectionsConfigController } from "./types/config_controller";
-import type { JsonCollectionStore } from "./serializable_types";
+import type { CollectionsConfigController } from "./types/config_controller.js";
+import type { JsonCollectionStore } from "./serializable_types.js";
 export interface UseJsonCollectionsConfigControllerOptions {
     /**
      * The store adapter for persisting/loading collections.

package/dist/collection_editor/useLiveSchemaEditing.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The plan-then-confirm flow, as a hook.
+ *
+ * Owns three things that belong together and nothing else: whether the backend
+ * can edit its schema, the plan for the change somebody is making, and the
+ * dialog they confirm it in. The config controller calls `reviewChange` and
+ * awaits it; everything about *how* the confirmation happens stays here.
+ *
+ * ## Why `reviewChange` returns a promise that can reject
+ *
+ * Because the editor needs to know. A save that was cancelled must not leave
+ * the form thinking it succeeded — the collection on screen would then differ
+ * from the one on disk, and the next save would be computed from the wrong
+ * `before`. Rejecting with {@link SchemaChangeCancelled} is how "the person
+ * said no" reaches the caller as an outcome rather than as silence.
+ */
+import React from "react";
+import { type LiveSchemaClient, type LiveSchemaStatus, type ProposedCollectionChange } from "./liveSchemaClient.js";
+export { SchemaChangeCancelled, isSchemaChangeCancelled } from "./liveSchemaClient.js";
+export interface UseLiveSchemaEditingOptions {
+    /** Base for the routes, e.g. `https://api.example.com/api/admin/schema`. */
+    baseUrl: string;
+    getAuthToken?: () => Promise<string | null> | string | null;
+    /**
+     * Identity of the signed-in user.
+     *
+     * Only used to re-ask: whether this backend will accept a schema change
+     * depends on who is asking, and the answer to an anonymous probe does not
+     * survive a sign-in.
+     */
+    authKey?: string | null;
+    /**
+     * Write the collection source and leave the database alone — what the
+     * editor did before this existed. Offered in the dialog when a change is
+     * refused, so a dev can still delete a field from a collection they are
+     * designing. Omit it and the fallback is not offered.
+     */
+    writeSourceOnly?: (change: ProposedCollectionChange) => Promise<void>;
+    /** Swappable for the tests, which have no server. */
+    client?: LiveSchemaClient;
+}
+export interface LiveSchemaEditing {
+    /** `undefined` until the backend has answered. For rendering. */
+    status?: LiveSchemaStatus;
+    /**
+     * The same answer, for deciding.
+     *
+     * `status` is undefined for one round trip after mount, and a caller that
+     * read it to choose a code path would take the "not available" branch for
+     * that window — so a save issued quickly after a page load would silently
+     * skip the confirmation and write source only, while the same save a second
+     * later would not. Timing-dependent behaviour with no visible difference is
+     * the worst shape this could have.
+     *
+     * Resolves once, cached; never rejects, because every way of failing to get
+     * an answer means the same thing to whoever is deciding.
+     */
+    ready: () => Promise<LiveSchemaStatus>;
+    /**
+     * Plan the change, show it, and settle when the person has decided.
+     *
+     * Resolves once the change has been applied — or written source-only, if
+     * they chose that. Rejects with {@link SchemaChangeCancelled} if they
+     * closed the dialog, and with the underlying error if planning or applying
+     * failed in a way they did not choose.
+     */
+    reviewChange: (change: ProposedCollectionChange) => Promise<void>;
+    /** Render this once, high enough that a dialog over the editor is not clipped. */
+    dialog: React.ReactNode;
+}
+export declare function useLiveSchemaEditing(options: UseLiveSchemaEditingOptions): LiveSchemaEditing;

package/dist/collection_editor/useLocalCollectionsConfigController.d.ts

@@ -1,4 +1,4 @@
-import { CollectionsConfigController } from "./types/config_controller";
+import { CollectionsConfigController } from "./types/config_controller.js";
 import type { AdminCollection } from "@rebasepro/admin-types";
 export declare function useLocalCollectionsConfigController(clientOrUrl: any, baseCollections?: AdminCollection[], options?: {
     readOnly?: boolean;

package/dist/collection_editor_ui.d.ts

@@ -1,12 +1,12 @@
-export { CollectionEditorDialog } from "./collection_editor/ui/collection_editor/CollectionEditorDialog";
-export type { CollectionEditorDialogProps } from "./collection_editor/ui/collection_editor/CollectionEditorDialog";
-export { PropertyFormDialog, PropertyForm } from "./collection_editor/ui/collection_editor/PropertyEditView";
-export type { PropertyFormProps, OnPropertyChangedParams } from "./collection_editor/ui/collection_editor/PropertyEditView";
-export { CollectionStudioView } from "./collection_editor/ui/collection_editor/CollectionStudioView";
-export type { CollectionStudioViewProps } from "./collection_editor/ui/collection_editor/CollectionStudioView";
-export { CollectionsStudioView } from "./collection_editor/ui/collection_editor/CollectionsStudioView";
-export type { CollectionsStudioViewProps } from "./collection_editor/ui/collection_editor/CollectionsStudioView";
-export { RouterCollectionStudioView } from "./collection_editor/ui/collection_editor/RouterCollectionStudioView";
-export type { RouterCollectionStudioViewProps } from "./collection_editor/ui/collection_editor/RouterCollectionStudioView";
-export { RouterCollectionsStudioView } from "./collection_editor/ui/collection_editor/RouterCollectionsStudioView";
-export type { RouterCollectionsStudioViewProps } from "./collection_editor/ui/collection_editor/RouterCollectionsStudioView";
+export { CollectionEditorDialog } from "./collection_editor/ui/collection_editor/CollectionEditorDialog.js";
+export type { CollectionEditorDialogProps } from "./collection_editor/ui/collection_editor/CollectionEditorDialog.js";
+export { PropertyFormDialog, PropertyForm } from "./collection_editor/ui/collection_editor/PropertyEditView.js";
+export type { PropertyFormProps, OnPropertyChangedParams } from "./collection_editor/ui/collection_editor/PropertyEditView.js";
+export { CollectionStudioView } from "./collection_editor/ui/collection_editor/CollectionStudioView.js";
+export type { CollectionStudioViewProps } from "./collection_editor/ui/collection_editor/CollectionStudioView.js";
+export { CollectionsStudioView } from "./collection_editor/ui/collection_editor/CollectionsStudioView.js";
+export type { CollectionsStudioViewProps } from "./collection_editor/ui/collection_editor/CollectionsStudioView.js";
+export { RouterCollectionStudioView } from "./collection_editor/ui/collection_editor/RouterCollectionStudioView.js";
+export type { RouterCollectionStudioViewProps } from "./collection_editor/ui/collection_editor/RouterCollectionStudioView.js";
+export { RouterCollectionsStudioView } from "./collection_editor/ui/collection_editor/RouterCollectionsStudioView.js";
+export type { RouterCollectionsStudioViewProps } from "./collection_editor/ui/collection_editor/RouterCollectionsStudioView.js";

package/dist/collection_editor_ui.js

@@ -1,7 +1,7 @@
-import { un as useUrlController } from "./util-C4qsI1QV.js";
-import { n as CollectionEditorDialog } from "./CollectionEditorDialog-D2Vf4C3-.js";
-import { n as PropertyForm, r as PropertyFormDialog } from "./PropertyEditView-D3NBsK9_.js";
-import { i as CollectionStudioView, r as CollectionsStudioView, t as RouterCollectionsStudioView } from "./RouterCollectionsStudioView-hPB54l3Q.js";
+import { hn as useUrlController } from "./util-wrBH4QSB.js";
+import { n as CollectionEditorDialog } from "./CollectionEditorDialog-Cec5jU6R.js";
+import { n as PropertyForm, r as PropertyFormDialog } from "./PropertyEditView-BuSPZwnQ.js";
+import { i as CollectionStudioView, r as CollectionsStudioView, t as RouterCollectionsStudioView } from "./RouterCollectionsStudioView-BiNFpEii.js";
 import "react";
 import { useSnackbarController } from "@rebasepro/app";
 import { jsx } from "react/jsx-runtime";

package/dist/components/CollectionTableBinding/CollectionTableBinding.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import { User } from "@rebasepro/types";
-import { CollectionTableBindingProps } from "./CollectionTableBindingProps";
+import { CollectionTableBindingProps } from "./CollectionTableBindingProps.js";
 /**
  * This component is in charge of rendering a collection table with a high
  * degree of customization.

package/dist/components/CollectionTableBinding/PropertyTableCell.d.ts

@@ -1,7 +1,7 @@
 import type { Property } from "@rebasepro/types";
 import React from "react";
 import { Entity } from "@rebasepro/types";
-import { CustomFieldValidator } from "../../form/validation";
+import { CustomFieldValidator } from "../../form/validation.js";
 export interface PropertyTableCellProps<T> {
     propertyKey: string;
     columnIndex: number;

package/dist/components/CollectionTableBinding/fields/TableStorageUpload.d.ts

@@ -1,7 +1,7 @@
 import type { ArrayProperty, StringProperty } from "@rebasepro/types";
 import * as React from "react";
 import { Entity } from "@rebasepro/types";
-import { PreviewSize } from "../../../types";
+import { PreviewSize } from "../../../types/index.js";
 /**
  * Field that allows to upload files to Google Cloud Storage.
  *

package/dist/components/CollectionTableBinding/index.d.ts

@@ -1,6 +1,6 @@
-export { CollectionTableBinding } from "./CollectionTableBinding";
-export type { CollectionTableBindingProps } from "./CollectionTableBindingProps";
-export * from "./PropertyTableCell";
-export * from "./CollectionRowActions";
-export * from "./column_utils";
+export { CollectionTableBinding } from "./CollectionTableBinding.js";
+export type { CollectionTableBindingProps } from "./CollectionTableBindingProps.js";
+export * from "./PropertyTableCell.js";
+export * from "./CollectionRowActions.js";
+export * from "./column_utils.js";
 export { VirtualTableInput } from "@rebasepro/ui";

package/dist/components/CollectionTableBinding/internal/popup_field/PopupFormField.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import { Entity } from "@rebasepro/types";
-import { CustomFieldValidator } from "../../../../form/validation";
+import { CustomFieldValidator } from "../../../../form/validation.js";
 import type { OnCellValueChangeParams } from "@rebasepro/app";
 import type { AdminCollection } from "@rebasepro/admin-types";
 interface PopupFormFieldProps<M extends Record<string, unknown>> {