@rebasepro/server 0.23.0 → 0.24.1-canary.g19596ef

package/dist/api/rest/field-ops.d.ts

@@ -1,4 +1,4 @@
-import { CollectionConfig, FieldOperation, FIELD_OPERATORS, isFieldOperation } from "@rebasepro/types";
+import { CollectionConfig, FieldOperation, FIELD_OPERATORS, isFieldOperation, Properties, Property } from "@rebasepro/types";
 /**
  * Writes expressed as a change to the column's current value.
  *
@@ -38,23 +38,32 @@ export interface ParsedFieldOp {
  * this package.
  */
 export declare const looksLikeFieldOp: typeof isFieldOperation;
-/** True when any value in the payload is (or is attempting to be) an operation. */
-export declare function hasFieldOps(values: Record<string, unknown> | undefined): boolean;
+/**
+ * True when any value in the payload is (or is attempting to be) an operation.
+ * With `properties`, a `map` value is one only when it is `{ <operator>: … }`;
+ * see `isFieldOperation`.
+ */
+export declare function hasFieldOps(values: Record<string, unknown> | undefined, properties?: Properties): boolean;
 /**
  * Parse one value as an operation, or report why it is not a legal one.
  *
  * Returns `undefined` for an ordinary value. Throws for a value that reads as
- * an operation and is malformed, so a typo cannot be written as data.
+ * an operation and is malformed, so a typo cannot be written as data. Given
+ * the field's `property`, a `map` value with `$` keys is data unless it is a
+ * single real operator.
  */
-export declare function parseFieldOp(key: string, value: unknown): ParsedFieldOp | undefined;
+export declare function parseFieldOp(key: string, value: unknown, property?: Property): ParsedFieldOp | undefined;
 /**
  * Split a write payload into ordinary values and field operations.
  *
  * The two travel together in one body — `{ title: "x", views: { $inc: 1 } }` is
  * a single `PATCH` — and are applied in one statement, so a caller never has to
  * choose between setting a column and incrementing another.
+ *
+ * Pass the collection's `properties`: without them a `map` value carrying `$`
+ * keys reads as a (malformed) operation rather than as the document it is.
  */
-export declare function splitFieldOps(values: Record<string, unknown>): {
+export declare function splitFieldOps(values: Record<string, unknown>, properties?: Properties): {
     values: Record<string, unknown>;
     fieldOps: Record<string, ParsedFieldOp>;
 };
@@ -79,8 +88,11 @@ export declare function assertFieldOpsValid(values: Record<string, unknown>, col
  * are meaningless on an insert — `views + 1` over a row that does not exist yet
  * is just `1`, and accepting it would make `$inc` mean two different things
  * depending on a race the caller cannot observe.
+ *
+ * `collection` decides how a `map` value is read (see {@link splitFieldOps});
+ * every request boundary has it and passes it.
  */
-export declare function assertNoFieldOpsOnCreate(values: Record<string, unknown>, context: string): void;
+export declare function assertNoFieldOpsOnCreate(values: Record<string, unknown>, context: string, collection?: CollectionConfig): void;
 /** Re-exported so callers type against one definition of the wire shape. */
 export type { FieldOperation };
 export { FIELD_OPERATORS };

package/dist/api/rest/query-body.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The body of a `POST /<collection>/query`, as the dictionary the `GET`
+ * listing reads off its URL.
+ *
+ * @param body the parsed JSON body — already known to be an object
+ * @param urlParams the names of any parameters on the request's own URL, which
+ *   are refused: two places to put one parameter is two answers to "which one
+ *   applied", and the listing would silently answer one of them
+ */
+export declare function queryDictFromBody(body: Record<string, unknown>, urlParams?: readonly string[]): Record<string, string[]>;

package/dist/api/rest/write-validation.d.ts

@@ -1,4 +1,4 @@
-import { CollectionConfig } from "@rebasepro/types";
+import { CollectionConfig, type IncludeSpec } from "@rebasepro/types";
 import { type FieldViewer } from "@rebasepro/common";
 /**
  * Refuse a write naming a field this caller may not set.
@@ -91,11 +91,13 @@ export interface WriteViolation {
  * from that spec believed the server was checking. Enum membership, `email` and
  * `url` were published the same way and enforced the same amount.
  *
- * `required` is checked only when `options.status` says this write creates a
- * row. A `PATCH` legitimately omits keys — this function sees one request's
- * values, not the row they land on — so demanding them there would refuse every
- * partial update. Callers that do not pass a status get the old behaviour and
- * leave `required` to the database's NOT NULL.
+ * A missing `required` key is checked only when `options.status` says this
+ * write creates a row. A `PATCH` legitimately omits keys — this function sees
+ * one request's values, not the row they land on — so demanding them there
+ * would refuse every partial update. Callers that do not pass a status get the
+ * old behaviour and leave a missing key to the database's NOT NULL. A required
+ * string sent as `""` is refused on every write, whatever the status: NOT NULL
+ * would store it.
  *
  * A value of the wrong *type* is not this function's business — that reaches
  * Postgres, which types every column and gives a 400 through the driver's
@@ -151,7 +153,7 @@ export declare function assertWriteValuesValid(values: Record<string, unknown>,
  * assuming one.
  */
 export declare function projectResponseFields<T extends Record<string, unknown>>(rows: T[], fields: readonly string[] | undefined, collection: CollectionConfig, options?: {
-    include?: readonly string[];
+    include?: IncludeSpec;
 }): T[];
 /**
  * Both write checks, as one call, for a transport that is not the REST router.

package/dist/api/schema-editor-routes.d.ts

@@ -1,3 +1,12 @@
 import { Hono } from "hono";
+import { SchemaSourceEditor } from "../schema-edit/source-editor.js";
 import { HonoEnv } from "./types.js";
-export declare function createSchemaEditorRoutes(collectionsDir: string): Hono<HonoEnv>;
+/**
+ * The editor for `collectionsDir`: one per process, shared by these routes
+ * and live schema editing's `/apply`. See {@link SchemaSourceEditor}.
+ *
+ * Here rather than beside the class because building it loads `ts-morph`, an
+ * optional peer dependency this module is imported to probe for.
+ */
+export declare function createSchemaSourceEditor(collectionsDir: string): SchemaSourceEditor;
+export declare function createSchemaEditorRoutes(source: SchemaSourceEditor): Hono<HonoEnv>;

package/dist/api/sql-export-routes.d.ts

@@ -0,0 +1,8 @@
+import { Hono } from "hono";
+import { type DatabaseAdmin } from "@rebasepro/types";
+import type { HonoEnv } from "./types.js";
+export interface SqlExportRoutesOptions {
+    /** The default data source's admin capabilities, read per request. */
+    getAdmin: () => DatabaseAdmin | undefined;
+}
+export declare function createSqlExportRoutes(options: SqlExportRoutesOptions): Hono<HonoEnv>;

package/dist/api/types.d.ts

@@ -2,6 +2,7 @@ import type { VectorSearchParams, IncludeSpec, LogicalCondition, FilterValues, N
 import type { DecodedCursor } from "@rebasepro/common";
 import type { AuthResult } from "../auth/middleware.js";
 import type { ApiKeyMasked } from "../auth/api-keys/api-key-types.js";
+import type { BackendServices } from "../backend/services.js";
 /**
  * Hono Environment Variables
  * Passed to generic Hono<HonoEnv> to type `c.get()`
@@ -31,10 +32,32 @@ export type HonoEnv = {
          */
         recipientEmail?: string;
         driver?: DataDriver;
-        /** Set when the request is authenticated via a Service API Key. */
+        /** Set when the request is authenticated with an API key (`rk_`). */
         apiKey?: ApiKeyMasked;
+        /**
+         * What the caller may do, when its credential is narrower than its
+         * person — an API key or an MCP token. Absent for a person's own
+         * session, who holds what their roles hold. Read it through
+         * `callerScopes` / `hasScope`, which fill in that second case.
+         */
+        scopes?: string[];
+        /**
+         * Who asked, when an administrator's request runs as another user
+         * (`x-rebase-impersonate`). `user` and `driver` are then the
+         * impersonated user's; this is the only place the administrator
+         * remains. See `auth/impersonation.ts`.
+         */
+        impersonator?: {
+            uid: string;
+        };
         /** Unique request correlation ID (generated or propagated from X-Request-ID header). */
         requestId?: string;
+        /**
+         * Aborted when a custom function's request outlasts its timeout and is
+         * answered 504. Read it with `getSignal(c)` from
+         * `@rebasepro/server/functions`. See `functions/request-timeout.ts`.
+         */
+        functionSignal?: AbortSignal;
         /**
          * The collection this request is about, when it is about one.
          *
@@ -81,6 +104,29 @@ export type HonoEnv = {
             client: string;
             server: string;
         };
+        /**
+         * Where the route group answering this request is mounted, e.g.
+         * `/api/data` or `/api/functions` — wherever the application put it.
+         *
+         * Set by the group's first middleware from the request itself, so a
+         * group mounted at a path of the caller's choosing still knows which
+         * collection a path names and which URL a function answers at. See
+         * `api/mount-path.ts`.
+         */
+        mountPath?: string;
+        /**
+         * The backend answering this request: its JWT keys, access model,
+         * API-key store and rate limiters.
+         *
+         * Set by the first middleware of every route group a backend builds,
+         * so a group verifies tokens and checks scopes against its own
+         * backend wherever it is mounted, and two backends mounted on one app
+         * stay two. Absent on a route mounted outside any backend, where the
+         * helpers that read it (`requireScope`, `callerScopes`, `requireAuth`,
+         * …) answer for the process default. Set it yourself to make such a
+         * route answer for a backend: `c.set("services", backend.services)`.
+         */
+        services?: BackendServices;
     };
 };
 /**
@@ -141,4 +187,9 @@ export interface QueryOptions {
      * the point of the feature.
      */
     withDeleted?: boolean | "only";
+    /**
+     * From `?count=exact|none` — whether a listing counts `meta.total`. See
+     * `FindParams.count`. Unset is `"exact"`.
+     */
+    count?: "exact" | "none";
 }

package/dist/{ast-schema-editor-Mvr50v_S.js → ast-schema-editor-mCeSC03x.js}

@@ -2,8 +2,8 @@ import { createRequire as __rebaseCreateRequire } from "module";
 import __rebaseProcess from "process";
 globalThis.process ??= __rebaseProcess;
 __rebaseCreateRequire(import.meta.url);
-import "./src-vkcwKXbT.js";
-import { i as nestAdminPropertyKeys, r as nestAdminCollectionKeys } from "./admin_block-DxKLmdiv.js";
+import "./src-D5Y3N-S4.js";
+import { a as nestCollectionPatchPaths, l as nestAdminCollectionKeys, n as collectionPatchProblems, o as runtimeOnlyKeyIn, u as nestAdminPropertyKeys } from "./collection_patch-BRu-BvDv.js";
 import * as fs$1 from "fs";
 import * as path$1 from "path";
 import { IndentationText, Node, Project, SyntaxKind } from "ts-morph";
@@ -130,6 +130,26 @@ var AstSchemaEditor = class AstSchemaEditor {
 		if (!resolved.startsWith(this.collectionsDir + path$1.sep) && resolved !== this.collectionsDir) throw new Error("Path traversal detected: resolved path is outside the collections directory.");
 		return resolved;
 	}
+	/**
+	* Bring the in-memory project back in line with the disk.
+	*
+	* The source-only editor builds ONE of these at boot and serves every
+	* request with it, and ts-morph reads a file once and then trusts its
+	* copy. `project.save()` writes that copy back whole, so anything that
+	* reached the disk in between — the live editor's committed change (it
+	* builds a fresh editor per request), or the developer's own edit in the
+	* IDE — was overwritten by the boot-time copy plus this edit. In `rebase
+	* dev` the tsx-watch restart usually closed the window; outside watch mode
+	* the loss was permanent.
+	*
+	* Called at the top of every public method, so each edit applies to what
+	* is on disk now.
+	*/
+	syncWithDisk() {
+		for (const file of this.project.getSourceFiles()) if (!fs$1.existsSync(file.getFilePath())) this.project.removeSourceFile(file);
+		else file.refreshFromFileSystemSync();
+		if (fs$1.existsSync(this.collectionsDir)) this.project.addSourceFilesAtPaths(`${this.collectionsDir}/**/*.ts`);
+	}
 	getCollectionFile(collectionId) {
 		const safeId = this.sanitizeCollectionId(collectionId);
 		const filePath = this.safePath(`${safeId}.ts`);
@@ -212,6 +232,39 @@ var AstSchemaEditor = class AstSchemaEditor {
 	static isPlainObject(value) {
 		return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof RawExpression);
 	}
+	/**
+	* The field that identifies each element of an array of objects, so an
+	* old element can be found again in the new array.
+	*
+	* Arrays travel whole (see `collection_patch.ts`), and an element's
+	* position is not its identity — adding an entity action at the front
+	* shifts every other one. `key`, `id`, `relationName`, `name`: the first
+	* one every new element carries, distinct, wins.
+	*/
+	static identityField(items) {
+		for (const field of [
+			"key",
+			"id",
+			"relationName",
+			"name",
+			"slug"
+		]) {
+			const values = items.map((item) => AstSchemaEditor.isPlainObject(item) ? item[field] : void 0);
+			if (values.every((value) => typeof value === "string" || typeof value === "number") && new Set(values).size === values.length) return field;
+		}
+	}
+	/** The old array's object elements, keyed by `field`'s literal value. */
+	oldElementsBy(oldArray, field) {
+		const byKey = /* @__PURE__ */ new Map();
+		const array = oldArray.asKind(SyntaxKind.ArrayLiteralExpression);
+		for (const element of array?.getElements() ?? []) {
+			const object = element.asKind(SyntaxKind.ObjectLiteralExpression);
+			const value = object ? this.initializerOf(object, field) : void 0;
+			const literal = value?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue() ?? value?.asKind(SyntaxKind.NoSubstitutionTemplateLiteral)?.getLiteralValue() ?? value?.asKind(SyntaxKind.NumericLiteral)?.getText();
+			if (object && literal !== void 0) byKey.set(String(literal), object);
+		}
+		return byKey;
+	}
 	convertJsonToAstString(obj, indentLevel = 0, oldAstNode) {
 		const indentStr = "    ";
 		const indent = indentStr.repeat(indentLevel);
@@ -222,14 +275,17 @@ var AstSchemaEditor = class AstSchemaEditor {
 		if (typeof obj === "number" || typeof obj === "boolean") return String(obj);
 		if (Array.isArray(obj)) {
 			if (obj.length === 0) return "[]";
-			return `[\n${innerIndent}${obj.map((item) => this.convertJsonToAstString(item, indentLevel + 1)).join(`,\n${innerIndent}`)}\n${indent}]`;
+			const field = oldAstNode ? AstSchemaEditor.identityField(obj) : void 0;
+			const old = oldAstNode && field ? this.oldElementsBy(oldAstNode, field) : void 0;
+			return `[\n${innerIndent}${obj.map((item) => this.convertJsonToAstString(item, indentLevel + 1, old && field && AstSchemaEditor.isPlainObject(item) ? old.get(String(item[field])) : void 0)).join(`,\n${innerIndent}`)}\n${indent}]`;
 		}
 		if (typeof obj === "object") {
 			const record = obj;
 			const keys = Object.keys(record);
+			const oldObject = oldAstNode?.asKind(SyntaxKind.ObjectLiteralExpression);
 			const preservedProps = [];
-			if (oldAstNode) {
-				const oldProps = oldAstNode.getProperties();
+			if (oldObject) {
+				const oldProps = oldObject.getProperties();
 				for (const oldProp of oldProps) if (oldProp.isKind(SyntaxKind.PropertyAssignment)) {
 					let name = oldProp.getNameNode().getText();
 					if (name.startsWith("\"") && name.endsWith("\"")) name = name.slice(1, -1);
@@ -247,9 +303,9 @@ var AstSchemaEditor = class AstSchemaEditor {
 			return `{\n${innerIndent}${[...keys.map((key) => {
 				const keyStr = AstSchemaEditor.quoteKey(key);
 				let childAstNode;
-				if (oldAstNode && AstSchemaEditor.isPlainObject(record[key])) {
-					const oldProp = this.findProperty(oldAstNode, key);
-					if (oldProp && oldProp.isKind(SyntaxKind.PropertyAssignment)) childAstNode = oldProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+				if (oldObject && (AstSchemaEditor.isPlainObject(record[key]) || Array.isArray(record[key]))) {
+					const oldProp = this.findProperty(oldObject, key);
+					if (oldProp && oldProp.isKind(SyntaxKind.PropertyAssignment)) childAstNode = oldProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression) ?? oldProp.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression);
 				}
 				return `${keyStr}: ${this.convertJsonToAstString(record[key], indentLevel + 1, childAstNode)}`;
 			}), ...preservedProps].join(`,\n${innerIndent}`)}\n${indent}}`;
@@ -296,6 +352,7 @@ var AstSchemaEditor = class AstSchemaEditor {
 		else this.project.removeSourceFile(file);
 	}
 	async saveProperty(collectionId, propertyKey, propertyConfig) {
+		this.syncWithDisk();
 		try {
 			await this.writeProperty(collectionId, propertyKey, propertyConfig);
 		} catch (err) {
@@ -330,6 +387,7 @@ var AstSchemaEditor = class AstSchemaEditor {
 		}
 	}
 	async deleteProperty(collectionId, propertyKey) {
+		this.syncWithDisk();
 		const propertiesProp = this.requireCollectionObject(collectionId).getProperty("properties");
 		if (propertiesProp) {
 			const propsObj = propertiesProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
@@ -356,6 +414,9 @@ var AstSchemaEditor = class AstSchemaEditor {
 	* default, which in the scaffold is `access: "public"`.
 	*/
 	async saveCollection(collectionId, collectionData, options = {}) {
+		this.syncWithDisk();
+		const runtimeOnly = runtimeOnlyKeyIn(collectionData);
+		if (runtimeOnly) throw new Error(`Refusing to write "${collectionId}": it holds "${runtimeOnly}", which the runtime adds to a collection it has loaded and a collection file must not hold. Save what changed instead.`);
 		try {
 			await this.writeCollection(collectionId, collectionData, options);
 		} catch (err) {
@@ -363,6 +424,180 @@ var AstSchemaEditor = class AstSchemaEditor {
 			throw err;
 		}
 	}
+	/**
+	* Write what changed about a collection, and nothing else.
+	*
+	* The patch is the difference between the collection the panel loaded and
+	* the one it is saving (`diffCollections` in `@rebasepro/types`), so it
+	* names only keys the person changed. Each is written where it is; every
+	* other byte of the file — imports, comments, formatting, handlers,
+	* properties shared from another module — is left as it was.
+	*
+	* A key whose value in the file is code — `status: statusProperty`,
+	* `enum: LOCALE_ENUM`, a spread — is not overwritten with the JSON the
+	* panel saw of it, which is what the whole-collection save did. The edit
+	* is refused, naming the code, so it can be made where that code lives.
+	*
+	* All or nothing: a refused operation leaves the file as it was, including
+	* the operations before it.
+	*/
+	async applyPatch(collectionId, patch) {
+		this.syncWithDisk();
+		const problems = collectionPatchProblems(patch);
+		if (problems.length > 0) throw new Error(`Refusing to edit "${collectionId}": ${problems.join(" ")}`);
+		try {
+			await this.writePatch(collectionId, nestCollectionPatchPaths(patch));
+		} catch (err) {
+			this.forgetUnsaved(collectionId);
+			throw err;
+		}
+	}
+	async writePatch(collectionId, patch) {
+		this.requireCollectionObject(collectionId);
+		const file = this.getCollectionFile(collectionId);
+		for (const op of patch) this.applyPatchOp(collectionId, file, this.requireCollectionObject(collectionId), op);
+		await this.project.save();
+	}
+	applyPatchOp(collectionId, file, collectionObj, op) {
+		const { path: keys } = op;
+		const dotted = (end) => keys.slice(0, end).join(".");
+		let target = collectionObj;
+		for (let depth = 0; depth < keys.length - 1; depth++) {
+			const key = keys[depth];
+			const member = this.findMember(target, key);
+			if (!member) {
+				const spread = this.spreadIn(target);
+				if (spread) throw this.codeRefusal(collectionId, file, dotted(depth + 1), spread, "comes from");
+				if (op.op === "remove") return;
+				target = target.addPropertyAssignment({
+					name: AstSchemaEditor.quoteKey(key),
+					initializer: "{}"
+				}).getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+				continue;
+			}
+			const value = member.isKind(SyntaxKind.PropertyAssignment) ? AstSchemaEditor.unwrapExpression(member.getInitializer()) : void 0;
+			const next = value?.asKind(SyntaxKind.ObjectLiteralExpression);
+			if (!next) throw this.codeRefusal(collectionId, file, dotted(depth + 1), value ?? member, "is");
+			target = next;
+		}
+		const key = keys[keys.length - 1];
+		const member = this.findMember(target, key);
+		if (op.op === "remove") {
+			if (member) {
+				member.remove();
+				return;
+			}
+			const spread = this.spreadIn(target);
+			if (spread) throw this.codeRefusal(collectionId, file, dotted(keys.length), spread, "comes from");
+			return;
+		}
+		if (keys.length === 1 && key === "relations") {
+			this.writeRelations(collectionId, file, collectionObj, op.value);
+			this.findMember(collectionObj, "relations")?.formatText();
+			return;
+		}
+		const old = member?.isKind(SyntaxKind.PropertyAssignment) ? member.getInitializer() : void 0;
+		if (member && (!old || !AstSchemaEditor.isLiteralValue(old))) throw this.codeRefusal(collectionId, file, dotted(keys.length), old ?? member, "is");
+		if (old?.isKind(SyntaxKind.ArrayLiteralExpression)) {
+			const code = old.getElements().find((element) => !AstSchemaEditor.isLiteralValue(element));
+			if (code) throw this.codeRefusal(collectionId, file, dotted(keys.length), code, "holds");
+		}
+		const value = this.patchValueAsSource(collectionId, file, keys, op.value, old);
+		const text = this.convertJsonToAstString(value, 0, old);
+		(member?.isKind(SyntaxKind.PropertyAssignment) ? member.setInitializer(text) : target.addPropertyAssignment({
+			name: AstSchemaEditor.quoteKey(key),
+			initializer: text
+		})).formatText();
+	}
+	/**
+	* A patched value with every relation target it carries turned back into
+	* source — `() => xCollection` plus its import — according to where the
+	* path lands: a relation's `target`, a relation, a property, or a map of
+	* properties.
+	*/
+	patchValueAsSource(collectionId, file, keys, value, old) {
+		let position = "collection";
+		for (const key of keys) switch (position) {
+			case "collection":
+				position = key === "properties" ? "properties" : "other";
+				break;
+			case "properties":
+				position = "property";
+				break;
+			case "property":
+				position = key === "properties" ? "properties" : key === "of" ? "property" : key === "oneOf" ? "oneOf" : key === "relation" ? "relation" : "other";
+				break;
+			case "oneOf":
+				position = key === "properties" ? "properties" : "other";
+				break;
+			case "relation":
+				if (key === "target" && typeof value === "string" && value.trim().length > 0) {
+					const trimmed = value.trim();
+					return new RawExpression(ARROW_TO_IDENTIFIER.test(trimmed) ? trimmed : this.targetThunk(file, trimmed));
+				}
+				position = "other";
+				break;
+			default: position = "other";
+		}
+		const oldObject = old?.asKind(SyntaxKind.ObjectLiteralExpression);
+		const where = keys.join(".");
+		if (position === "property") return this.propertyRelationTargetsAsSource(collectionId, file, value, oldObject, where);
+		if (position === "properties") return this.relationTargetsAsSource(collectionId, file, value, oldObject, where);
+		if (position === "relation" && AstSchemaEditor.isPlainObject(value)) {
+			const wrapped = this.propertyRelationTargetsAsSource(collectionId, file, {
+				type: "relation",
+				relation: value
+			}, oldObject ? void 0 : void 0, where);
+			const relation = AstSchemaEditor.isPlainObject(wrapped) ? wrapped.relation : value;
+			if (AstSchemaEditor.isPlainObject(relation) && !("target" in relation) && !(oldObject && this.findProperty(oldObject, "target"))) throw new Error(`Relation "${where}" on collection "${collectionId}" has no target collection. Pick one before saving.`);
+			return relation;
+		}
+		return value;
+	}
+	/** A member of an object literal by name: an assignment, a shorthand, a method. */
+	findMember(obj, name) {
+		return obj.getProperties().find((member) => {
+			if (member.isKind(SyntaxKind.SpreadAssignment)) return false;
+			const memberName = member.getName();
+			return memberName === name || memberName === JSON.stringify(name) || memberName === `'${name}'`;
+		});
+	}
+	spreadIn(obj) {
+		return obj.getProperties().find((member) => member.isKind(SyntaxKind.SpreadAssignment));
+	}
+	/** `x as const`, `x satisfies T`, `(x)` — the value inside. */
+	static unwrapExpression(node) {
+		if (!node) return void 0;
+		if (Node.isAsExpression(node) || Node.isSatisfiesExpression(node) || Node.isParenthesizedExpression(node)) return AstSchemaEditor.unwrapExpression(node.getExpression());
+		return node;
+	}
+	/**
+	* Whether a value in the file is data the panel's JSON fully describes —
+	* a literal — rather than code it saw only the result of.
+	*/
+	static isLiteralValue(node) {
+		const value = AstSchemaEditor.unwrapExpression(node);
+		if (!value) return false;
+		switch (value.getKind()) {
+			case SyntaxKind.ObjectLiteralExpression:
+			case SyntaxKind.ArrayLiteralExpression:
+			case SyntaxKind.StringLiteral:
+			case SyntaxKind.NoSubstitutionTemplateLiteral:
+			case SyntaxKind.NumericLiteral:
+			case SyntaxKind.TrueKeyword:
+			case SyntaxKind.FalseKeyword:
+			case SyntaxKind.NullKeyword: return true;
+			case SyntaxKind.PrefixUnaryExpression: return value.asKindOrThrow(SyntaxKind.PrefixUnaryExpression).getOperand().isKind(SyntaxKind.NumericLiteral);
+			case SyntaxKind.Identifier: return value.getText() === "undefined";
+			default: return false;
+		}
+	}
+	/** "`properties.status` is `statusProperty` in posts.ts…" */
+	codeRefusal(collectionId, file, where, code, verb) {
+		const text = code.getText();
+		const shown = text.length > 60 ? `${text.slice(0, 57)}…` : text;
+		return /* @__PURE__ */ new Error(`\`${where}\` ${verb} \`${shown}\` in ${path$1.basename(file.getFilePath())}, which is code the editor cannot change without losing what it does. Change "${collectionId}" there instead.`);
+	}
 	async writeCollection(collectionId, collectionData, options) {
 		const partial = options.partial === true;
 		let file = this.getCollectionFile(collectionId);
@@ -554,12 +789,75 @@ var AstSchemaEditor = class AstSchemaEditor {
 		if (expr && expr.getKind() === SyntaxKind.Identifier) return expr.getText();
 		for (const varDecl of file.getVariableDeclarations()) if (this.unwrapCollectionObject(varDecl.getInitializer())) return varDecl.getName();
 	}
+	/**
+	* Delete a collection's file, and take it out of `index.ts`.
+	*
+	* This used to unlink `<slug>.ts` and stop. Every scaffold's `index.ts`
+	* imports every collection, so the next boot failed for the whole project
+	* ("Cannot find module …/tags"), and a collection another one linked to
+	* took that one down with it. Now:
+	*
+	* - a file any other module imports is refused, naming the importers — a
+	*   relation to it has to go first, and that is a change the person makes;
+	* - `index.ts`'s import of it is removed, and so is each place it is listed
+	*   in an array; any other use there is refused, naming the line;
+	* - the file is deleted.
+	*
+	* Only the source. The table and its rows are not touched.
+	*
+	* Returns what changed, as absolute paths, so the caller can commit it.
+	*/
 	async deleteCollection(collectionId) {
-		const file = this.getCollectionFile(collectionId);
-		if (file) file.deleteImmediatelySync();
+		this.syncWithDisk();
+		const target = this.getCollectionFile(collectionId);
+		if (!target) throw new Error(`Collection "${collectionId}" has no file at ${path$1.join(this.collectionsDir, `${collectionId}.ts`)}.`);
+		const targetPath = target.getFilePath();
+		const indexPath = path$1.join(this.collectionsDir, "index.ts");
+		const importers = this.project.getSourceFiles().filter((file) => file !== target && this.declarationsOf(file, targetPath).length > 0);
+		const others = importers.filter((file) => file.getFilePath() !== indexPath);
+		if (others.length > 0) throw new Error(`Cannot delete "${collectionId}": ${others.map((file) => path$1.basename(file.getFilePath())).join(", ")} ${others.length === 1 ? "imports" : "import"} it — a relation to it, most likely. Remove that first; deleting the file would stop every collection from loading.`);
+		const changed = [];
+		const index = importers.find((file) => file.getFilePath() === indexPath);
+		try {
+			if (index) {
+				for (const declaration of this.declarationsOf(index, targetPath)) {
+					const names = declaration.isKind(SyntaxKind.ImportDeclaration) ? [declaration.getDefaultImport()?.getText(), ...declaration.getNamedImports().map((named) => (named.getAliasNode() ?? named.getNameNode()).getText())].filter((name) => Boolean(name)) : [];
+					for (const name of names) {
+						const uses = index.getDescendantsOfKind(SyntaxKind.Identifier).filter((identifier) => identifier.getText() === name && !identifier.getFirstAncestorByKind(SyntaxKind.ImportDeclaration));
+						for (const use of uses) {
+							const array = use.getParentIfKind(SyntaxKind.ArrayLiteralExpression);
+							if (!array) throw new Error(`Cannot delete "${collectionId}": index.ts uses \`${name}\` at line ${use.getStartLineNumber()} in a way the editor cannot remove. Remove it there first.`);
+							array.removeElement(use);
+						}
+					}
+					declaration.remove();
+				}
+				changed.push(index.getFilePath());
+			}
+			target.delete();
+			await this.project.save();
+		} catch (err) {
+			if (index && !index.isSaved()) index.refreshFromFileSystemSync();
+			this.syncWithDisk();
+			throw err;
+		}
+		return {
+			deleted: targetPath,
+			changed
+		};
+	}
+	/** The import and export declarations in `file` whose relative specifier resolves to `targetPath`. */
+	declarationsOf(file, targetPath) {
+		const stem = (absolute) => absolute.replace(/\.(ts|tsx|js|mjs|cjs)$/, "");
+		const target = stem(targetPath);
+		return [...file.getImportDeclarations(), ...file.getExportDeclarations()].filter((declaration) => {
+			const specifier = declaration.getModuleSpecifierValue();
+			if (!specifier || !specifier.startsWith(".")) return false;
+			return stem(path$1.resolve(path$1.dirname(file.getFilePath()), specifier)) === target;
+		});
 	}
 };
 //#endregion
-export { AstSchemaEditor };
+export { AstSchemaEditor, nestAdminKeys, nestAdminKeysDeep };
 
-//# sourceMappingURL=ast-schema-editor-Mvr50v_S.js.map
+//# sourceMappingURL=ast-schema-editor-mCeSC03x.js.map