@atscript/db-memory 0.1.136 → 0.1.137

package/dist/index.cjs

@@ -539,12 +539,19 @@ function accumulatorFactory(expr) {
 //#endregion
 //#region src/lib/memory-adapter.ts
 /**
+* One database per {@link DbSpace}, shared by every adapter the space builds —
+* the administrative adapter schema sync drops tables through included. A
+* space is the lifetime of an in-memory database: a fresh space starts empty.
+*/
+const databases = /* @__PURE__ */ new WeakMap();
+/**
 * In-memory {@link BaseDbAdapter} implementation.
 *
 * Runs in one of two modes:
-* - STORED mode (default): storage is a plain `Map` living on the adapter
-*   instance — adapter instances are 1:1 with a readable (table/view), so the
-*   Map is this table's whole store. Documents are kept in their nested PHYSICAL
+* - STORED mode (default): rows live in a `Map` of the space's in-memory
+*   database, keyed by table name (see {@link databases}), so every adapter of
+*   the space that serves a name sees the same table, and the administrative
+*   adapter can drop it by name. Documents are kept in their nested PHYSICAL
 *   shape (no flattening), which is why {@link supportsNestedObjects} is `true`.
 *   Full CRUD surface: inserts, reads, update / replace / delete with
 *   optimistic-concurrency CAS.
@@ -556,12 +563,10 @@ function accumulatorFactory(expr) {
 */
 var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	/**
-	* The table's store, keyed by {@link pkKey}. Values are the stored rows in
-	* nested physical shape. An instance field — no `ensureTable` DDL needed.
+	* The in-memory database: the space's (see {@link databases}), resolved once
+	* in {@link registerSpace}; an adapter used without a space keeps this own one.
 	*/
-	rows = /* @__PURE__ */ new Map();
-	/** Unique indexes recorded by {@link syncIndexes}. Enforced on insert. */
-	uniqueIndexes = [];
+	_db = /* @__PURE__ */ new Map();
 	/** Memoized physical PK field names — stable for the adapter's lifetime. */
 	_pkFieldsCache;
 	/**
@@ -571,14 +576,6 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	*/
 	_incrementFieldsCache;
 	/**
-	* Running per-field auto-increment counters (PHYSICAL name → last value
-	* handed out). Lives on the adapter INSTANCE, so it resets whenever a new
-	* DbSpace/adapter is built — correct for an in-memory store (parity with
-	* SQLite `:memory:`, whose sequence also restarts with a fresh DB). Never
-	* persisted.
-	*/
-	_incrementCounters = /* @__PURE__ */ new Map();
-	/**
 	* Provider (read-through) backing closure. When set, this adapter is
 	* PROVIDER-BACKED: reads recompute rows from this closure per request and all
 	* writes are rejected (see {@link _assertWritable}). `undefined` ⇒ stored mode.
@@ -640,6 +637,43 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 		}
 		return String(id);
 	}
+	/** Joins the space's in-memory database (see {@link databases}), creating it on first use. */
+	registerSpace(space) {
+		let db = databases.get(space);
+		if (!db) {
+			db = /* @__PURE__ */ new Map();
+			databases.set(space, db);
+		}
+		this._db = db;
+	}
+	/**
+	* This table's state, or `undefined` while it does not exist (never synced,
+	* or dropped) — or when no readable is registered.
+	*/
+	_peekState() {
+		const table = this._table;
+		return table && this._db.get(table.tableName);
+	}
+	/**
+	* This table's state, created on first use — by `ensureTable`, or by a write
+	* to a table that was never synced (implicit create, like a MongoDB
+	* collection). Reads never create it.
+	*/
+	_state() {
+		const db = this._db;
+		const name = this._table.tableName;
+		let state = db.get(name);
+		if (!state) {
+			state = {
+				kind: this._table.isView ? "view" : "table",
+				rows: /* @__PURE__ */ new Map(),
+				uniqueIndexes: [],
+				incrementCounters: /* @__PURE__ */ new Map()
+			};
+			db.set(name, state);
+		}
+		return state;
+	}
 	/**
 	* Physical names of the primary-key field(s). Single `@meta.id` resolves via
 	* {@link AtscriptDbReadable.metaIdPhysical}; a composite key maps each logical
@@ -688,7 +722,9 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	* are computed so an increment PRIMARY KEY produces a real `insertedId` and
 	* stores under a real key. The memory analogue of the Mongo adapter's
 	* insert-time increment (Mongo uses an atomic `__atscript_counters`
-	* collection; an in-memory store just keeps the counter on the instance):
+	* collection; an in-memory store keeps the counter in the table's state, so
+	* it restarts with a fresh space or when the table is dropped — parity with
+	* SQLite `:memory:`; never persisted):
 	*
 	* - No value for the field → assign the next counter value. First use starts
 	*   at `start ?? 1` (`max(counter, (start ?? 1) - 1) + 1`); thereafter it is
@@ -698,18 +734,18 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	* - Explicit value present → keep it, but advance the counter to
 	*   `max(counter, value)` so a later auto value can never collide with it.
 	*/
-	_applyIncrements(row) {
+	_applyIncrements(counters, row) {
 		const fields = this._incrementFields();
 		if (fields.size === 0) return;
 		for (const [physical, start] of fields) {
 			const floor = (start ?? 1) - 1;
-			const base = this._incrementCounters.get(physical) ?? floor;
+			const base = counters.get(physical) ?? floor;
 			const current = row[physical];
 			if (current === void 0 || current === null) {
 				const next = base + 1;
 				row[physical] = next;
-				this._incrementCounters.set(physical, next);
-			} else if (typeof current === "number") this._incrementCounters.set(physical, Math.max(base, current));
+				counters.set(physical, next);
+			} else if (typeof current === "number") counters.set(physical, Math.max(base, current));
 		}
 	}
 	/**
@@ -785,7 +821,8 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	/**
 	* Snapshot seam for reads. Returns the current rows.
 	*
-	* - Stored mode reads the instance Map directly (insertion order preserved).
+	* - Stored mode reads the table's Map directly (insertion order preserved);
+	*   a table that does not exist reads as empty.
 	* - Provider (read-through) mode calls {@link _provider} to recompute a fresh
 	*   snapshot per read.
 	*
@@ -802,7 +839,7 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	*/
 	_loadRows() {
 		if (this._provider) return this._provider();
-		return [...this.rows.values()];
+		return [...this._peekState()?.rows.values() ?? []];
 	}
 	/**
 	* Clones the payload in, applies the version default, generates any
@@ -812,15 +849,15 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	* the store. Called once per item by both `insertOne` and `insertMany`, so
 	* increment values advance sequentially across a batch.
 	*/
-	_insertRow(data) {
+	_insertRow(state, data) {
 		const row = structuredClone(data);
 		const versionColumn = this._table.versionColumn;
 		if (versionColumn !== void 0 && !(versionColumn in row)) row[versionColumn] = 0;
-		this._applyIncrements(row);
+		this._applyIncrements(state.incrementCounters, row);
 		const key = this.pkKey(row);
-		if (this.rows.has(key)) throw this._pkConflict();
-		this._enforceUniqueIndexes(row);
-		this.rows.set(key, row);
+		if (state.rows.has(key)) throw this._pkConflict();
+		this._enforceUniqueIndexes(state, row);
+		state.rows.set(key, row);
 		const fallback = this._table.metaIdPhysical ? void 0 : this._compositeInsertedId(row);
 		return this._resolveInsertedId(row, fallback);
 	}
@@ -833,8 +870,8 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	* `excludeKey` (when given) skips the row stored under that {@link pkKey} — so
 	* a row updating its own unique value does not false-conflict with itself.
 	*/
-	_enforceUniqueIndexes(row, excludeKey) {
-		for (const index of this.uniqueIndexes) {
+	_enforceUniqueIndexes(state, row, excludeKey) {
+		for (const index of state.uniqueIndexes) {
 			const tuple = [];
 			let skip = false;
 			for (const field of index.fields) {
@@ -846,7 +883,7 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 				tuple.push(value);
 			}
 			if (skip) continue;
-			for (const [existingKey, existing] of this.rows) {
+			for (const [existingKey, existing] of state.rows) {
 				if (excludeKey !== void 0 && existingKey === excludeKey) continue;
 				let equal = true;
 				for (let i = 0; i < index.fields.length; i++) if (!valuesEqual(getPath(existing, index.fields[i]), tuple[i])) {
@@ -862,11 +899,12 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	}
 	async insertOne(data) {
 		this._assertWritable();
-		return { insertedId: this._insertRow(data) };
+		return { insertedId: this._insertRow(this._state(), data) };
 	}
 	async insertMany(data) {
 		this._assertWritable();
-		const insertedIds = data.map((item) => this._insertRow(item));
+		const state = this._state();
+		const insertedIds = data.map((item) => this._insertRow(state, item));
 		return {
 			insertedCount: data.length,
 			insertedIds
@@ -874,7 +912,7 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	}
 	/**
 	* Selects the stored rows a write should touch, as `{ key, row }` pairs so
-	* callers can mutate in place and re-key. Stored mode scans the instance Map
+	* callers can mutate in place and re-key. Stored mode scans the table's Map
 	* directly (writes are authoritative against the store, unlike reads which go
 	* through the {@link _loadRows} snapshot seam).
 	*
@@ -885,14 +923,15 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	* that has no version column is a misconfiguration and throws (mirrors the
 	* Mongo adapter's `_buildCasFilter`).
 	*
-	* When `many` is `false` at most the first match is returned.
+	* When `many` is `false` at most the first match is returned. A table that
+	* does not exist (`state` undefined) matches nothing and is not created.
 	*/
-	_selectForWrite(filter, expectedVersion, many) {
+	_selectForWrite(state, filter, expectedVersion, many) {
 		const versionColumn = this._table.versionColumn;
 		if (expectedVersion !== void 0 && versionColumn === void 0) throw new Error("expectedVersion requires a versioned table");
 		const match = buildMemoryPredicate(filter);
 		const matched = [];
-		for (const [key, row] of this.rows) {
+		for (const [key, row] of state?.rows ?? []) {
 			if (!match(row)) continue;
 			if (expectedVersion !== void 0 && row[versionColumn] !== expectedVersion) continue;
 			matched.push({
@@ -947,11 +986,11 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	* NEW key (some other row already owns it) throws `CONFLICT`. Throws BEFORE
 	* touching the Map so a failed re-key leaves the store unchanged.
 	*/
-	_commitRow(oldKey, next) {
+	_commitRow(rows, oldKey, next) {
 		const newKey = this.pkKey(next);
-		if (newKey !== oldKey && this.rows.has(newKey)) throw this._pkConflict();
-		if (newKey !== oldKey) this.rows.delete(oldKey);
-		this.rows.set(newKey, next);
+		if (newKey !== oldKey && rows.has(newKey)) throw this._pkConflict();
+		if (newKey !== oldKey) rows.delete(oldKey);
+		rows.set(newKey, next);
 	}
 	/**
 	* Update-then-commit for a single matched row: clones the pristine `row`,
@@ -961,25 +1000,26 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	* commits. Nothing is written to the store until both the unique and PK checks
 	* pass, so a conflict leaves the store untouched.
 	*/
-	_commitUpdate(oldKey, row, data, ops) {
+	_commitUpdate(state, oldKey, row, data, ops) {
 		const next = structuredClone(row);
 		this._applyUpdate(next, data, ops);
 		this._bumpVersion(next, row);
-		this._enforceUniqueIndexes(next, oldKey);
-		this._commitRow(oldKey, next);
+		this._enforceUniqueIndexes(state, next, oldKey);
+		this._commitRow(state.rows, oldKey, next);
 	}
 	async replaceOne(filter, data, expectedVersion) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, expectedVersion, false);
-		if (matched.length === 0) return {
+		const state = this._peekState();
+		const matched = this._selectForWrite(state, filter, expectedVersion, false);
+		if (!state || matched.length === 0) return {
 			matchedCount: 0,
 			modifiedCount: 0
 		};
 		const { key, row } = matched[0];
 		const next = structuredClone(data);
 		this._bumpVersion(next, row);
-		this._enforceUniqueIndexes(next, key);
-		this._commitRow(key, next);
+		this._enforceUniqueIndexes(state, next, key);
+		this._commitRow(state.rows, key, next);
 		return {
 			matchedCount: 1,
 			modifiedCount: 1
@@ -987,13 +1027,14 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	}
 	async updateOne(filter, data, ops, expectedVersion) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, expectedVersion, false);
-		if (matched.length === 0) return {
+		const state = this._peekState();
+		const matched = this._selectForWrite(state, filter, expectedVersion, false);
+		if (!state || matched.length === 0) return {
 			matchedCount: 0,
 			modifiedCount: 0
 		};
 		const { key, row } = matched[0];
-		this._commitUpdate(key, row, data, ops);
+		this._commitUpdate(state, key, row, data, ops);
 		return {
 			matchedCount: 1,
 			modifiedCount: 1
@@ -1001,9 +1042,10 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	}
 	async deleteOne(filter) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, void 0, false);
-		if (matched.length === 0) return { deletedCount: 0 };
-		this.rows.delete(matched[0].key);
+		const state = this._peekState();
+		const matched = this._selectForWrite(state, filter, void 0, false);
+		if (!state || matched.length === 0) return { deletedCount: 0 };
+		state.rows.delete(matched[0].key);
 		return { deletedCount: 1 };
 	}
 	/**
@@ -1113,8 +1155,13 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	}
 	async updateMany(filter, data, ops) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, void 0, true);
-		for (const { key, row } of matched) this._commitUpdate(key, row, data, ops);
+		const state = this._peekState();
+		if (!state) return {
+			matchedCount: 0,
+			modifiedCount: 0
+		};
+		const matched = this._selectForWrite(state, filter, void 0, true);
+		for (const { key, row } of matched) this._commitUpdate(state, key, row, data, ops);
 		return {
 			matchedCount: matched.length,
 			modifiedCount: matched.length
@@ -1122,8 +1169,13 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	}
 	async replaceMany(filter, data) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, void 0, true);
-		for (const { key, row } of matched) this._commitUpdate(key, row, data);
+		const state = this._peekState();
+		if (!state) return {
+			matchedCount: 0,
+			modifiedCount: 0
+		};
+		const matched = this._selectForWrite(state, filter, void 0, true);
+		for (const { key, row } of matched) this._commitUpdate(state, key, row, data);
 		return {
 			matchedCount: matched.length,
 			modifiedCount: matched.length
@@ -1131,8 +1183,10 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	}
 	async deleteMany(filter) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, void 0, true);
-		for (const { key } of matched) this.rows.delete(key);
+		const state = this._peekState();
+		if (!state) return { deletedCount: 0 };
+		const matched = this._selectForWrite(state, filter, void 0, true);
+		for (const { key } of matched) state.rows.delete(key);
 		return { deletedCount: matched.length };
 	}
 	/**
@@ -1141,21 +1195,54 @@ var MemoryAdapter = class extends _atscript_db.BaseDbAdapter {
 	* in-memory scan needs no plain/fulltext/geo index to answer queries.
 	*/
 	async syncIndexes() {
-		this.uniqueIndexes = [];
+		const uniqueIndexes = [];
 		for (const index of this._table.indexes.values()) {
 			if (index.type !== "unique") continue;
-			this.uniqueIndexes.push({
+			uniqueIndexes.push({
 				name: index.name,
 				fields: index.fields.map((f) => f.name),
 				optionalFields: new Set(index.fields.filter((f) => f.optional).map((f) => f.name))
 			});
 		}
+		this._state().uniqueIndexes = uniqueIndexes;
+	}
+	/** Creates the table's (empty) state when it does not exist. Idempotent. */
+	async ensureTable() {
+		this._state();
+	}
+	/**
+	* Whether the table exists in the space's in-memory database — created by
+	* {@link ensureTable} (or a first write) and not dropped since. Schema sync
+	* reports a table that does not exist as `create`. An external view always
+	* exists: nothing in memory creates one, its rows come from a provider.
+	* @since 0.1.137
+	*/
+	async tableExists() {
+		if ((0, _atscript_db.isAtscriptDbView)(this._table) && this._table.isExternal) return true;
+		return this._peekState() !== void 0;
 	}
 	/**
-	* No-op: the store is the instance-level {@link rows} Map, which already
-	* exists. Safe to call repeatedly.
+	* Drops a table by name: its rows, unique indexes and increment counters go,
+	* so the table added back starts empty. A missing table is not an error;
+	* a view under that name is (`dropViewByName` drops views).
+	* @since 0.1.137
 	*/
-	async ensureTable() {}
+	async dropTableByName(tableName) {
+		this._dropByName(tableName, "table");
+	}
+	/**
+	* Drops a view by name — its (empty) state; a view holds no rows here.
+	* A missing view is not an error; a table under that name is.
+	* @since 0.1.137
+	*/
+	async dropViewByName(viewName) {
+		this._dropByName(viewName, "view");
+	}
+	_dropByName(name, kind) {
+		const state = this._db.get(name);
+		if (state && state.kind !== kind) throw new Error(`Cannot drop ${kind} "${name}": it is a ${state.kind}`);
+		this._db.delete(name);
+	}
 };
 /**
 * Ergonomic late-binding entry point for provider (read-through) mode. Resolves
@@ -1177,7 +1264,8 @@ function setMemoryProvider(space, type, fn) {
 /**
 * Creates a {@link DbSpace} backed by an in-memory {@link MemoryAdapter}.
 *
-* Tables default to STORED mode (an instance-level `Map`). To make one table
+* Tables default to STORED mode (a `Map` per table in the space's in-memory
+* database, shared by every adapter of the space). To make one table
 * read-only and read-through from a runtime closure, call `setMemoryProvider`
 * (re-exported from {@link ./memory-adapter}) on the space AFTER the table's
 * adapter has been built.

package/dist/index.d.cts

@@ -12,9 +12,10 @@ type MemoryProviderFn = () => Array<Record<string, unknown>> | Promise<Array<Rec
  * In-memory {@link BaseDbAdapter} implementation.
  *
  * Runs in one of two modes:
- * - STORED mode (default): storage is a plain `Map` living on the adapter
- *   instance — adapter instances are 1:1 with a readable (table/view), so the
- *   Map is this table's whole store. Documents are kept in their nested PHYSICAL
+ * - STORED mode (default): rows live in a `Map` of the space's in-memory
+ *   database, keyed by table name (see {@link databases}), so every adapter of
+ *   the space that serves a name sees the same table, and the administrative
+ *   adapter can drop it by name. Documents are kept in their nested PHYSICAL
  *   shape (no flattening), which is why {@link supportsNestedObjects} is `true`.
  *   Full CRUD surface: inserts, reads, update / replace / delete with
  *   optimistic-concurrency CAS.
@@ -26,12 +27,10 @@ type MemoryProviderFn = () => Array<Record<string, unknown>> | Promise<Array<Rec
  */
 declare class MemoryAdapter extends BaseDbAdapter {
   /**
-   * The table's store, keyed by {@link pkKey}. Values are the stored rows in
-   * nested physical shape. An instance field — no `ensureTable` DDL needed.
+   * The in-memory database: the space's (see {@link databases}), resolved once
+   * in {@link registerSpace}; an adapter used without a space keeps this own one.
    */
-  private rows;
-  /** Unique indexes recorded by {@link syncIndexes}. Enforced on insert. */
-  private uniqueIndexes;
+  private _db;
   /** Memoized physical PK field names — stable for the adapter's lifetime. */
   private _pkFieldsCache?;
   /**
@@ -40,14 +39,6 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * {@link _incrementFields}).
    */
   private _incrementFieldsCache?;
-  /**
-   * Running per-field auto-increment counters (PHYSICAL name → last value
-   * handed out). Lives on the adapter INSTANCE, so it resets whenever a new
-   * DbSpace/adapter is built — correct for an in-memory store (parity with
-   * SQLite `:memory:`, whose sequence also restarts with a fresh DB). Never
-   * persisted.
-   */
-  private _incrementCounters;
   /**
    * Provider (read-through) backing closure. When set, this adapter is
    * PROVIDER-BACKED: reads recompute rows from this closure per request and all
@@ -100,6 +91,19 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * coerces via `Number(id)`, everything else via `String(id)`.
    */
   prepareId(id: unknown, _fieldType: unknown): unknown;
+  /** Joins the space's in-memory database (see {@link databases}), creating it on first use. */
+  registerSpace(space: DbSpace): void;
+  /**
+   * This table's state, or `undefined` while it does not exist (never synced,
+   * or dropped) — or when no readable is registered.
+   */
+  private _peekState;
+  /**
+   * This table's state, created on first use — by `ensureTable`, or by a write
+   * to a table that was never synced (implicit create, like a MongoDB
+   * collection). Reads never create it.
+   */
+  private _state;
   /**
    * Physical names of the primary-key field(s). Single `@meta.id` resolves via
    * {@link AtscriptDbReadable.metaIdPhysical}; a composite key maps each logical
@@ -133,7 +137,9 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * are computed so an increment PRIMARY KEY produces a real `insertedId` and
    * stores under a real key. The memory analogue of the Mongo adapter's
    * insert-time increment (Mongo uses an atomic `__atscript_counters`
-   * collection; an in-memory store just keeps the counter on the instance):
+   * collection; an in-memory store keeps the counter in the table's state, so
+   * it restarts with a fresh space or when the table is dropped — parity with
+   * SQLite `:memory:`; never persisted):
    *
    * - No value for the field → assign the next counter value. First use starts
    *   at `start ?? 1` (`max(counter, (start ?? 1) - 1) + 1`); thereafter it is
@@ -198,7 +204,8 @@ declare class MemoryAdapter extends BaseDbAdapter {
   /**
    * Snapshot seam for reads. Returns the current rows.
    *
-   * - Stored mode reads the instance Map directly (insertion order preserved).
+   * - Stored mode reads the table's Map directly (insertion order preserved);
+   *   a table that does not exist reads as empty.
    * - Provider (read-through) mode calls {@link _provider} to recompute a fresh
    *   snapshot per read.
    *
@@ -237,7 +244,7 @@ declare class MemoryAdapter extends BaseDbAdapter {
   insertMany(data: Array<Record<string, unknown>>): Promise<TDbInsertManyResult>;
   /**
    * Selects the stored rows a write should touch, as `{ key, row }` pairs so
-   * callers can mutate in place and re-key. Stored mode scans the instance Map
+   * callers can mutate in place and re-key. Stored mode scans the table's Map
    * directly (writes are authoritative against the store, unlike reads which go
    * through the {@link _loadRows} snapshot seam).
    *
@@ -248,7 +255,8 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * that has no version column is a misconfiguration and throws (mirrors the
    * Mongo adapter's `_buildCasFilter`).
    *
-   * When `many` is `false` at most the first match is returned.
+   * When `many` is `false` at most the first match is returned. A table that
+   * does not exist (`state` undefined) matches nothing and is not created.
    */
   private _selectForWrite;
   /**
@@ -378,11 +386,30 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * in-memory scan needs no plain/fulltext/geo index to answer queries.
    */
   syncIndexes(): Promise<void>;
+  /** Creates the table's (empty) state when it does not exist. Idempotent. */
+  ensureTable(): Promise<void>;
   /**
-   * No-op: the store is the instance-level {@link rows} Map, which already
-   * exists. Safe to call repeatedly.
+   * Whether the table exists in the space's in-memory database — created by
+   * {@link ensureTable} (or a first write) and not dropped since. Schema sync
+   * reports a table that does not exist as `create`. An external view always
+   * exists: nothing in memory creates one, its rows come from a provider.
+   * @since 0.1.137
    */
-  ensureTable(): Promise<void>;
+  tableExists(): Promise<boolean>;
+  /**
+   * Drops a table by name: its rows, unique indexes and increment counters go,
+   * so the table added back starts empty. A missing table is not an error;
+   * a view under that name is (`dropViewByName` drops views).
+   * @since 0.1.137
+   */
+  dropTableByName(tableName: string): Promise<void>;
+  /**
+   * Drops a view by name — its (empty) state; a view holds no rows here.
+   * A missing view is not an error; a table under that name is.
+   * @since 0.1.137
+   */
+  dropViewByName(viewName: string): Promise<void>;
+  private _dropByName;
 }
 /**
  * Ergonomic late-binding entry point for provider (read-through) mode. Resolves
@@ -482,7 +509,8 @@ declare function projectRow(row: Record<string, unknown>, projection?: Record<st
 /**
  * Creates a {@link DbSpace} backed by an in-memory {@link MemoryAdapter}.
  *
- * Tables default to STORED mode (an instance-level `Map`). To make one table
+ * Tables default to STORED mode (a `Map` per table in the space's in-memory
+ * database, shared by every adapter of the space). To make one table
  * read-only and read-through from a runtime closure, call `setMemoryProvider`
  * (re-exported from {@link ./memory-adapter}) on the space AFTER the table's
  * adapter has been built.

package/dist/index.d.mts

@@ -12,9 +12,10 @@ type MemoryProviderFn = () => Array<Record<string, unknown>> | Promise<Array<Rec
  * In-memory {@link BaseDbAdapter} implementation.
  *
  * Runs in one of two modes:
- * - STORED mode (default): storage is a plain `Map` living on the adapter
- *   instance — adapter instances are 1:1 with a readable (table/view), so the
- *   Map is this table's whole store. Documents are kept in their nested PHYSICAL
+ * - STORED mode (default): rows live in a `Map` of the space's in-memory
+ *   database, keyed by table name (see {@link databases}), so every adapter of
+ *   the space that serves a name sees the same table, and the administrative
+ *   adapter can drop it by name. Documents are kept in their nested PHYSICAL
  *   shape (no flattening), which is why {@link supportsNestedObjects} is `true`.
  *   Full CRUD surface: inserts, reads, update / replace / delete with
  *   optimistic-concurrency CAS.
@@ -26,12 +27,10 @@ type MemoryProviderFn = () => Array<Record<string, unknown>> | Promise<Array<Rec
  */
 declare class MemoryAdapter extends BaseDbAdapter {
   /**
-   * The table's store, keyed by {@link pkKey}. Values are the stored rows in
-   * nested physical shape. An instance field — no `ensureTable` DDL needed.
+   * The in-memory database: the space's (see {@link databases}), resolved once
+   * in {@link registerSpace}; an adapter used without a space keeps this own one.
    */
-  private rows;
-  /** Unique indexes recorded by {@link syncIndexes}. Enforced on insert. */
-  private uniqueIndexes;
+  private _db;
   /** Memoized physical PK field names — stable for the adapter's lifetime. */
   private _pkFieldsCache?;
   /**
@@ -40,14 +39,6 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * {@link _incrementFields}).
    */
   private _incrementFieldsCache?;
-  /**
-   * Running per-field auto-increment counters (PHYSICAL name → last value
-   * handed out). Lives on the adapter INSTANCE, so it resets whenever a new
-   * DbSpace/adapter is built — correct for an in-memory store (parity with
-   * SQLite `:memory:`, whose sequence also restarts with a fresh DB). Never
-   * persisted.
-   */
-  private _incrementCounters;
   /**
    * Provider (read-through) backing closure. When set, this adapter is
    * PROVIDER-BACKED: reads recompute rows from this closure per request and all
@@ -100,6 +91,19 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * coerces via `Number(id)`, everything else via `String(id)`.
    */
   prepareId(id: unknown, _fieldType: unknown): unknown;
+  /** Joins the space's in-memory database (see {@link databases}), creating it on first use. */
+  registerSpace(space: DbSpace): void;
+  /**
+   * This table's state, or `undefined` while it does not exist (never synced,
+   * or dropped) — or when no readable is registered.
+   */
+  private _peekState;
+  /**
+   * This table's state, created on first use — by `ensureTable`, or by a write
+   * to a table that was never synced (implicit create, like a MongoDB
+   * collection). Reads never create it.
+   */
+  private _state;
   /**
    * Physical names of the primary-key field(s). Single `@meta.id` resolves via
    * {@link AtscriptDbReadable.metaIdPhysical}; a composite key maps each logical
@@ -133,7 +137,9 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * are computed so an increment PRIMARY KEY produces a real `insertedId` and
    * stores under a real key. The memory analogue of the Mongo adapter's
    * insert-time increment (Mongo uses an atomic `__atscript_counters`
-   * collection; an in-memory store just keeps the counter on the instance):
+   * collection; an in-memory store keeps the counter in the table's state, so
+   * it restarts with a fresh space or when the table is dropped — parity with
+   * SQLite `:memory:`; never persisted):
    *
    * - No value for the field → assign the next counter value. First use starts
    *   at `start ?? 1` (`max(counter, (start ?? 1) - 1) + 1`); thereafter it is
@@ -198,7 +204,8 @@ declare class MemoryAdapter extends BaseDbAdapter {
   /**
    * Snapshot seam for reads. Returns the current rows.
    *
-   * - Stored mode reads the instance Map directly (insertion order preserved).
+   * - Stored mode reads the table's Map directly (insertion order preserved);
+   *   a table that does not exist reads as empty.
    * - Provider (read-through) mode calls {@link _provider} to recompute a fresh
    *   snapshot per read.
    *
@@ -237,7 +244,7 @@ declare class MemoryAdapter extends BaseDbAdapter {
   insertMany(data: Array<Record<string, unknown>>): Promise<TDbInsertManyResult>;
   /**
    * Selects the stored rows a write should touch, as `{ key, row }` pairs so
-   * callers can mutate in place and re-key. Stored mode scans the instance Map
+   * callers can mutate in place and re-key. Stored mode scans the table's Map
    * directly (writes are authoritative against the store, unlike reads which go
    * through the {@link _loadRows} snapshot seam).
    *
@@ -248,7 +255,8 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * that has no version column is a misconfiguration and throws (mirrors the
    * Mongo adapter's `_buildCasFilter`).
    *
-   * When `many` is `false` at most the first match is returned.
+   * When `many` is `false` at most the first match is returned. A table that
+   * does not exist (`state` undefined) matches nothing and is not created.
    */
   private _selectForWrite;
   /**
@@ -378,11 +386,30 @@ declare class MemoryAdapter extends BaseDbAdapter {
    * in-memory scan needs no plain/fulltext/geo index to answer queries.
    */
   syncIndexes(): Promise<void>;
+  /** Creates the table's (empty) state when it does not exist. Idempotent. */
+  ensureTable(): Promise<void>;
   /**
-   * No-op: the store is the instance-level {@link rows} Map, which already
-   * exists. Safe to call repeatedly.
+   * Whether the table exists in the space's in-memory database — created by
+   * {@link ensureTable} (or a first write) and not dropped since. Schema sync
+   * reports a table that does not exist as `create`. An external view always
+   * exists: nothing in memory creates one, its rows come from a provider.
+   * @since 0.1.137
    */
-  ensureTable(): Promise<void>;
+  tableExists(): Promise<boolean>;
+  /**
+   * Drops a table by name: its rows, unique indexes and increment counters go,
+   * so the table added back starts empty. A missing table is not an error;
+   * a view under that name is (`dropViewByName` drops views).
+   * @since 0.1.137
+   */
+  dropTableByName(tableName: string): Promise<void>;
+  /**
+   * Drops a view by name — its (empty) state; a view holds no rows here.
+   * A missing view is not an error; a table under that name is.
+   * @since 0.1.137
+   */
+  dropViewByName(viewName: string): Promise<void>;
+  private _dropByName;
 }
 /**
  * Ergonomic late-binding entry point for provider (read-through) mode. Resolves
@@ -482,7 +509,8 @@ declare function projectRow(row: Record<string, unknown>, projection?: Record<st
 /**
  * Creates a {@link DbSpace} backed by an in-memory {@link MemoryAdapter}.
  *
- * Tables default to STORED mode (an instance-level `Map`). To make one table
+ * Tables default to STORED mode (a `Map` per table in the space's in-memory
+ * database, shared by every adapter of the space). To make one table
  * read-only and read-through from a runtime closure, call `setMemoryProvider`
  * (re-exported from {@link ./memory-adapter}) on the space AFTER the table's
  * adapter has been built.

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { ALL_AGGREGATE_FNS, ALL_BUCKET_UNITS, BaseDbAdapter, DbError, DbSpace, walkFilter } from "@atscript/db";
+import { ALL_AGGREGATE_FNS, ALL_BUCKET_UNITS, BaseDbAdapter, DbError, DbSpace, isAtscriptDbView, walkFilter } from "@atscript/db";
 import { assertAggregateFn, resolveAlias } from "@atscript/db/agg";
 import { bucketer } from "@uniqu/core";
 //#region src/lib/memory-filter.ts
@@ -538,12 +538,19 @@ function accumulatorFactory(expr) {
 //#endregion
 //#region src/lib/memory-adapter.ts
 /**
+* One database per {@link DbSpace}, shared by every adapter the space builds —
+* the administrative adapter schema sync drops tables through included. A
+* space is the lifetime of an in-memory database: a fresh space starts empty.
+*/
+const databases = /* @__PURE__ */ new WeakMap();
+/**
 * In-memory {@link BaseDbAdapter} implementation.
 *
 * Runs in one of two modes:
-* - STORED mode (default): storage is a plain `Map` living on the adapter
-*   instance — adapter instances are 1:1 with a readable (table/view), so the
-*   Map is this table's whole store. Documents are kept in their nested PHYSICAL
+* - STORED mode (default): rows live in a `Map` of the space's in-memory
+*   database, keyed by table name (see {@link databases}), so every adapter of
+*   the space that serves a name sees the same table, and the administrative
+*   adapter can drop it by name. Documents are kept in their nested PHYSICAL
 *   shape (no flattening), which is why {@link supportsNestedObjects} is `true`.
 *   Full CRUD surface: inserts, reads, update / replace / delete with
 *   optimistic-concurrency CAS.
@@ -555,12 +562,10 @@ function accumulatorFactory(expr) {
 */
 var MemoryAdapter = class extends BaseDbAdapter {
 	/**
-	* The table's store, keyed by {@link pkKey}. Values are the stored rows in
-	* nested physical shape. An instance field — no `ensureTable` DDL needed.
+	* The in-memory database: the space's (see {@link databases}), resolved once
+	* in {@link registerSpace}; an adapter used without a space keeps this own one.
 	*/
-	rows = /* @__PURE__ */ new Map();
-	/** Unique indexes recorded by {@link syncIndexes}. Enforced on insert. */
-	uniqueIndexes = [];
+	_db = /* @__PURE__ */ new Map();
 	/** Memoized physical PK field names — stable for the adapter's lifetime. */
 	_pkFieldsCache;
 	/**
@@ -570,14 +575,6 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	*/
 	_incrementFieldsCache;
 	/**
-	* Running per-field auto-increment counters (PHYSICAL name → last value
-	* handed out). Lives on the adapter INSTANCE, so it resets whenever a new
-	* DbSpace/adapter is built — correct for an in-memory store (parity with
-	* SQLite `:memory:`, whose sequence also restarts with a fresh DB). Never
-	* persisted.
-	*/
-	_incrementCounters = /* @__PURE__ */ new Map();
-	/**
 	* Provider (read-through) backing closure. When set, this adapter is
 	* PROVIDER-BACKED: reads recompute rows from this closure per request and all
 	* writes are rejected (see {@link _assertWritable}). `undefined` ⇒ stored mode.
@@ -639,6 +636,43 @@ var MemoryAdapter = class extends BaseDbAdapter {
 		}
 		return String(id);
 	}
+	/** Joins the space's in-memory database (see {@link databases}), creating it on first use. */
+	registerSpace(space) {
+		let db = databases.get(space);
+		if (!db) {
+			db = /* @__PURE__ */ new Map();
+			databases.set(space, db);
+		}
+		this._db = db;
+	}
+	/**
+	* This table's state, or `undefined` while it does not exist (never synced,
+	* or dropped) — or when no readable is registered.
+	*/
+	_peekState() {
+		const table = this._table;
+		return table && this._db.get(table.tableName);
+	}
+	/**
+	* This table's state, created on first use — by `ensureTable`, or by a write
+	* to a table that was never synced (implicit create, like a MongoDB
+	* collection). Reads never create it.
+	*/
+	_state() {
+		const db = this._db;
+		const name = this._table.tableName;
+		let state = db.get(name);
+		if (!state) {
+			state = {
+				kind: this._table.isView ? "view" : "table",
+				rows: /* @__PURE__ */ new Map(),
+				uniqueIndexes: [],
+				incrementCounters: /* @__PURE__ */ new Map()
+			};
+			db.set(name, state);
+		}
+		return state;
+	}
 	/**
 	* Physical names of the primary-key field(s). Single `@meta.id` resolves via
 	* {@link AtscriptDbReadable.metaIdPhysical}; a composite key maps each logical
@@ -687,7 +721,9 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	* are computed so an increment PRIMARY KEY produces a real `insertedId` and
 	* stores under a real key. The memory analogue of the Mongo adapter's
 	* insert-time increment (Mongo uses an atomic `__atscript_counters`
-	* collection; an in-memory store just keeps the counter on the instance):
+	* collection; an in-memory store keeps the counter in the table's state, so
+	* it restarts with a fresh space or when the table is dropped — parity with
+	* SQLite `:memory:`; never persisted):
 	*
 	* - No value for the field → assign the next counter value. First use starts
 	*   at `start ?? 1` (`max(counter, (start ?? 1) - 1) + 1`); thereafter it is
@@ -697,18 +733,18 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	* - Explicit value present → keep it, but advance the counter to
 	*   `max(counter, value)` so a later auto value can never collide with it.
 	*/
-	_applyIncrements(row) {
+	_applyIncrements(counters, row) {
 		const fields = this._incrementFields();
 		if (fields.size === 0) return;
 		for (const [physical, start] of fields) {
 			const floor = (start ?? 1) - 1;
-			const base = this._incrementCounters.get(physical) ?? floor;
+			const base = counters.get(physical) ?? floor;
 			const current = row[physical];
 			if (current === void 0 || current === null) {
 				const next = base + 1;
 				row[physical] = next;
-				this._incrementCounters.set(physical, next);
-			} else if (typeof current === "number") this._incrementCounters.set(physical, Math.max(base, current));
+				counters.set(physical, next);
+			} else if (typeof current === "number") counters.set(physical, Math.max(base, current));
 		}
 	}
 	/**
@@ -784,7 +820,8 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	/**
 	* Snapshot seam for reads. Returns the current rows.
 	*
-	* - Stored mode reads the instance Map directly (insertion order preserved).
+	* - Stored mode reads the table's Map directly (insertion order preserved);
+	*   a table that does not exist reads as empty.
 	* - Provider (read-through) mode calls {@link _provider} to recompute a fresh
 	*   snapshot per read.
 	*
@@ -801,7 +838,7 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	*/
 	_loadRows() {
 		if (this._provider) return this._provider();
-		return [...this.rows.values()];
+		return [...this._peekState()?.rows.values() ?? []];
 	}
 	/**
 	* Clones the payload in, applies the version default, generates any
@@ -811,15 +848,15 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	* the store. Called once per item by both `insertOne` and `insertMany`, so
 	* increment values advance sequentially across a batch.
 	*/
-	_insertRow(data) {
+	_insertRow(state, data) {
 		const row = structuredClone(data);
 		const versionColumn = this._table.versionColumn;
 		if (versionColumn !== void 0 && !(versionColumn in row)) row[versionColumn] = 0;
-		this._applyIncrements(row);
+		this._applyIncrements(state.incrementCounters, row);
 		const key = this.pkKey(row);
-		if (this.rows.has(key)) throw this._pkConflict();
-		this._enforceUniqueIndexes(row);
-		this.rows.set(key, row);
+		if (state.rows.has(key)) throw this._pkConflict();
+		this._enforceUniqueIndexes(state, row);
+		state.rows.set(key, row);
 		const fallback = this._table.metaIdPhysical ? void 0 : this._compositeInsertedId(row);
 		return this._resolveInsertedId(row, fallback);
 	}
@@ -832,8 +869,8 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	* `excludeKey` (when given) skips the row stored under that {@link pkKey} — so
 	* a row updating its own unique value does not false-conflict with itself.
 	*/
-	_enforceUniqueIndexes(row, excludeKey) {
-		for (const index of this.uniqueIndexes) {
+	_enforceUniqueIndexes(state, row, excludeKey) {
+		for (const index of state.uniqueIndexes) {
 			const tuple = [];
 			let skip = false;
 			for (const field of index.fields) {
@@ -845,7 +882,7 @@ var MemoryAdapter = class extends BaseDbAdapter {
 				tuple.push(value);
 			}
 			if (skip) continue;
-			for (const [existingKey, existing] of this.rows) {
+			for (const [existingKey, existing] of state.rows) {
 				if (excludeKey !== void 0 && existingKey === excludeKey) continue;
 				let equal = true;
 				for (let i = 0; i < index.fields.length; i++) if (!valuesEqual(getPath(existing, index.fields[i]), tuple[i])) {
@@ -861,11 +898,12 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async insertOne(data) {
 		this._assertWritable();
-		return { insertedId: this._insertRow(data) };
+		return { insertedId: this._insertRow(this._state(), data) };
 	}
 	async insertMany(data) {
 		this._assertWritable();
-		const insertedIds = data.map((item) => this._insertRow(item));
+		const state = this._state();
+		const insertedIds = data.map((item) => this._insertRow(state, item));
 		return {
 			insertedCount: data.length,
 			insertedIds
@@ -873,7 +911,7 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	/**
 	* Selects the stored rows a write should touch, as `{ key, row }` pairs so
-	* callers can mutate in place and re-key. Stored mode scans the instance Map
+	* callers can mutate in place and re-key. Stored mode scans the table's Map
 	* directly (writes are authoritative against the store, unlike reads which go
 	* through the {@link _loadRows} snapshot seam).
 	*
@@ -884,14 +922,15 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	* that has no version column is a misconfiguration and throws (mirrors the
 	* Mongo adapter's `_buildCasFilter`).
 	*
-	* When `many` is `false` at most the first match is returned.
+	* When `many` is `false` at most the first match is returned. A table that
+	* does not exist (`state` undefined) matches nothing and is not created.
 	*/
-	_selectForWrite(filter, expectedVersion, many) {
+	_selectForWrite(state, filter, expectedVersion, many) {
 		const versionColumn = this._table.versionColumn;
 		if (expectedVersion !== void 0 && versionColumn === void 0) throw new Error("expectedVersion requires a versioned table");
 		const match = buildMemoryPredicate(filter);
 		const matched = [];
-		for (const [key, row] of this.rows) {
+		for (const [key, row] of state?.rows ?? []) {
 			if (!match(row)) continue;
 			if (expectedVersion !== void 0 && row[versionColumn] !== expectedVersion) continue;
 			matched.push({
@@ -946,11 +985,11 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	* NEW key (some other row already owns it) throws `CONFLICT`. Throws BEFORE
 	* touching the Map so a failed re-key leaves the store unchanged.
 	*/
-	_commitRow(oldKey, next) {
+	_commitRow(rows, oldKey, next) {
 		const newKey = this.pkKey(next);
-		if (newKey !== oldKey && this.rows.has(newKey)) throw this._pkConflict();
-		if (newKey !== oldKey) this.rows.delete(oldKey);
-		this.rows.set(newKey, next);
+		if (newKey !== oldKey && rows.has(newKey)) throw this._pkConflict();
+		if (newKey !== oldKey) rows.delete(oldKey);
+		rows.set(newKey, next);
 	}
 	/**
 	* Update-then-commit for a single matched row: clones the pristine `row`,
@@ -960,25 +999,26 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	* commits. Nothing is written to the store until both the unique and PK checks
 	* pass, so a conflict leaves the store untouched.
 	*/
-	_commitUpdate(oldKey, row, data, ops) {
+	_commitUpdate(state, oldKey, row, data, ops) {
 		const next = structuredClone(row);
 		this._applyUpdate(next, data, ops);
 		this._bumpVersion(next, row);
-		this._enforceUniqueIndexes(next, oldKey);
-		this._commitRow(oldKey, next);
+		this._enforceUniqueIndexes(state, next, oldKey);
+		this._commitRow(state.rows, oldKey, next);
 	}
 	async replaceOne(filter, data, expectedVersion) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, expectedVersion, false);
-		if (matched.length === 0) return {
+		const state = this._peekState();
+		const matched = this._selectForWrite(state, filter, expectedVersion, false);
+		if (!state || matched.length === 0) return {
 			matchedCount: 0,
 			modifiedCount: 0
 		};
 		const { key, row } = matched[0];
 		const next = structuredClone(data);
 		this._bumpVersion(next, row);
-		this._enforceUniqueIndexes(next, key);
-		this._commitRow(key, next);
+		this._enforceUniqueIndexes(state, next, key);
+		this._commitRow(state.rows, key, next);
 		return {
 			matchedCount: 1,
 			modifiedCount: 1
@@ -986,13 +1026,14 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async updateOne(filter, data, ops, expectedVersion) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, expectedVersion, false);
-		if (matched.length === 0) return {
+		const state = this._peekState();
+		const matched = this._selectForWrite(state, filter, expectedVersion, false);
+		if (!state || matched.length === 0) return {
 			matchedCount: 0,
 			modifiedCount: 0
 		};
 		const { key, row } = matched[0];
-		this._commitUpdate(key, row, data, ops);
+		this._commitUpdate(state, key, row, data, ops);
 		return {
 			matchedCount: 1,
 			modifiedCount: 1
@@ -1000,9 +1041,10 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async deleteOne(filter) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, void 0, false);
-		if (matched.length === 0) return { deletedCount: 0 };
-		this.rows.delete(matched[0].key);
+		const state = this._peekState();
+		const matched = this._selectForWrite(state, filter, void 0, false);
+		if (!state || matched.length === 0) return { deletedCount: 0 };
+		state.rows.delete(matched[0].key);
 		return { deletedCount: 1 };
 	}
 	/**
@@ -1112,8 +1154,13 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async updateMany(filter, data, ops) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, void 0, true);
-		for (const { key, row } of matched) this._commitUpdate(key, row, data, ops);
+		const state = this._peekState();
+		if (!state) return {
+			matchedCount: 0,
+			modifiedCount: 0
+		};
+		const matched = this._selectForWrite(state, filter, void 0, true);
+		for (const { key, row } of matched) this._commitUpdate(state, key, row, data, ops);
 		return {
 			matchedCount: matched.length,
 			modifiedCount: matched.length
@@ -1121,8 +1168,13 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async replaceMany(filter, data) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, void 0, true);
-		for (const { key, row } of matched) this._commitUpdate(key, row, data);
+		const state = this._peekState();
+		if (!state) return {
+			matchedCount: 0,
+			modifiedCount: 0
+		};
+		const matched = this._selectForWrite(state, filter, void 0, true);
+		for (const { key, row } of matched) this._commitUpdate(state, key, row, data);
 		return {
 			matchedCount: matched.length,
 			modifiedCount: matched.length
@@ -1130,8 +1182,10 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async deleteMany(filter) {
 		this._assertWritable();
-		const matched = this._selectForWrite(filter, void 0, true);
-		for (const { key } of matched) this.rows.delete(key);
+		const state = this._peekState();
+		if (!state) return { deletedCount: 0 };
+		const matched = this._selectForWrite(state, filter, void 0, true);
+		for (const { key } of matched) state.rows.delete(key);
 		return { deletedCount: matched.length };
 	}
 	/**
@@ -1140,21 +1194,54 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	* in-memory scan needs no plain/fulltext/geo index to answer queries.
 	*/
 	async syncIndexes() {
-		this.uniqueIndexes = [];
+		const uniqueIndexes = [];
 		for (const index of this._table.indexes.values()) {
 			if (index.type !== "unique") continue;
-			this.uniqueIndexes.push({
+			uniqueIndexes.push({
 				name: index.name,
 				fields: index.fields.map((f) => f.name),
 				optionalFields: new Set(index.fields.filter((f) => f.optional).map((f) => f.name))
 			});
 		}
+		this._state().uniqueIndexes = uniqueIndexes;
+	}
+	/** Creates the table's (empty) state when it does not exist. Idempotent. */
+	async ensureTable() {
+		this._state();
+	}
+	/**
+	* Whether the table exists in the space's in-memory database — created by
+	* {@link ensureTable} (or a first write) and not dropped since. Schema sync
+	* reports a table that does not exist as `create`. An external view always
+	* exists: nothing in memory creates one, its rows come from a provider.
+	* @since 0.1.137
+	*/
+	async tableExists() {
+		if (isAtscriptDbView(this._table) && this._table.isExternal) return true;
+		return this._peekState() !== void 0;
 	}
 	/**
-	* No-op: the store is the instance-level {@link rows} Map, which already
-	* exists. Safe to call repeatedly.
+	* Drops a table by name: its rows, unique indexes and increment counters go,
+	* so the table added back starts empty. A missing table is not an error;
+	* a view under that name is (`dropViewByName` drops views).
+	* @since 0.1.137
 	*/
-	async ensureTable() {}
+	async dropTableByName(tableName) {
+		this._dropByName(tableName, "table");
+	}
+	/**
+	* Drops a view by name — its (empty) state; a view holds no rows here.
+	* A missing view is not an error; a table under that name is.
+	* @since 0.1.137
+	*/
+	async dropViewByName(viewName) {
+		this._dropByName(viewName, "view");
+	}
+	_dropByName(name, kind) {
+		const state = this._db.get(name);
+		if (state && state.kind !== kind) throw new Error(`Cannot drop ${kind} "${name}": it is a ${state.kind}`);
+		this._db.delete(name);
+	}
 };
 /**
 * Ergonomic late-binding entry point for provider (read-through) mode. Resolves
@@ -1176,7 +1263,8 @@ function setMemoryProvider(space, type, fn) {
 /**
 * Creates a {@link DbSpace} backed by an in-memory {@link MemoryAdapter}.
 *
-* Tables default to STORED mode (an instance-level `Map`). To make one table
+* Tables default to STORED mode (a `Map` per table in the space's in-memory
+* database, shared by every adapter of the space). To make one table
 * read-only and read-through from a runtime closure, call `setMemoryProvider`
 * (re-exported from {@link ./memory-adapter}) on the space AFTER the table's
 * adapter has been built.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/db-memory",
-  "version": "0.1.136",
+  "version": "0.1.137",
   "description": "In-memory adapter for atscript-db.",
   "keywords": [
     "atscript",
@@ -45,7 +45,7 @@
     "@atscript/core": "^0.1.92",
     "@atscript/typescript": "^0.1.92",
     "@uniqu/core": "^0.1.11",
-    "@atscript/db": "^0.1.136"
+    "@atscript/db": "^0.1.137"
   },
   "scripts": {
     "postinstall": "asc -f dts",