@harperfast/harper-pro 5.1.0-beta.3 → 5.1.0

package/core/DESIGN.md

@@ -107,3 +107,27 @@ Adding a new system table (e.g. `hdb_deployment` in #641 Slice A) requires three
 System tables replicate by default. To opt out, add the name to `NON_REPLICATING_SYSTEM_TABLES` in `resources/databases.ts`. The check happens after table init and sets `table.replicate = false` per-node.
 
 If the table needs `audit: true`, set it both in the schema (for fresh installs) **and** on the `CreateTableObject` instance in the directive (for upgrades) — otherwise the two paths diverge.
+
+## Table drops, the `dropping` tombstone, and ghost tables
+
+A table is a set of RocksDB column families (`T/` plus `T/<attr>`) and a set of catalog rows
+in the `__dbis__` store, with no transaction spanning the two. `Table.dropTable()` therefore
+persists a `dropping: true` flag on the table's primary catalog entry (`T/`) before any
+destructive work, then drops the column families (awaited - a failed drop must surface as the
+operation's error, never a swallowed rejection), then removes the catalog rows. If the process
+dies or a drop fails partway, the tombstone survives; both the boot-time schema load in
+`databases.ts` (`completeInterruptedDrop`) and a same-name `table()` create complete the
+interrupted drop instead of resurrecting the table. Without this, surviving catalog rows are
+silently re-opened with create-if-missing on the next start, which resurrects "deleted" tables
+(with their data, if the column families were never actually removed).
+
+Two related traps: the create path's exclusive `update-attributes` lock is a synchronous spin
+lock (`while (!tryLock()) {}`), so any throw inside the create window must release it or every
+subsequent create on that database pins a worker at 100% CPU. And dropping then recreating a
+same-named table within one process requires @harperfast/rocksdb-js >= the column-family
+eviction fix (1.4.3 / rocksdb-js#<main PR>): older bindings keep the dropped column family's
+by-name registry entry alive whenever other worker threads hold handles, so the recreate
+silently reuses a dangling handle and every write fails with "Invalid column family specified
+in write batch", poisoning the whole database env until restart. The regression suite for all
+of this is `unitTests/resources/dropTableGhost.test.js` (it fails by design on pre-fix
+bindings).

package/core/bin/copyDb.ts

@@ -381,20 +381,33 @@ export async function copyDbToRocks(sourceRootStore, sourceDatabase: string, tar
 	const sourceDbisDb = sourceRootStore.dbisDb;
 
 	const targetRootStore = openRocksDb(targetPath, { disableWAL: false });
+	// sharedStructuresKey wires the rocksdb-js getStructures/saveStructures closures
+	// so that the plain msgpackr.Encoder used here persists structures within the
+	// __dbis__ CF at Symbol.for('structures'). The runtime attributesDbi RecordEncoder
+	// takes the non-isRocksDB path (handleLocalTimeForGets is never called on it) and
+	// reads from the same CF key via superGetStructures. Without this, own structure
+	// IDs starting at 0x40 are minted in-memory and silently lost on restart →
+	// runtime decoder interprets 0x40 as fixint 64 → "Data read, but end of buffer
+	// not reached 64" (harper#1260).
 	const targetDbisDb = openRocksDb(targetPath, {
 		disableWAL: false,
 		name: INTERNAL_DBIS_NAME,
+		sharedStructuresKey: Symbol.for('structures'),
 	});
 
 	const STRUCTURES_KEY = Symbol.for('structures');
-	const copyStructures = (sourceDbi, storeName: string) => {
+	const copyStructures = (sourceDbi, storeName: string, extraTarget?: RocksDatabase) => {
 		const buffer = sourceDbi.getBinary?.(STRUCTURES_KEY);
 		if (buffer) {
-			targetRootStore.putSync([STRUCTURES_KEY, storeName], asBinary(buffer));
+			const binaryBuffer = asBinary(buffer);
+			targetRootStore.putSync([STRUCTURES_KEY, storeName], binaryBuffer);
+			// Also write to the extra target CF when provided (e.g. __dbis__ CF,
+			// which the runtime RecordEncoder reads via its superGetStructures path).
+			extraTarget?.putSync(STRUCTURES_KEY, binaryBuffer);
 		}
 	};
 
-	copyStructures(sourceDbisDb, INTERNAL_DBIS_NAME);
+	copyStructures(sourceDbisDb, INTERNAL_DBIS_NAME, targetDbisDb);
 
 	let written;
 	let outstandingWrites = 0;

package/core/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "harper",
-	"version": "5.1.0-beta.2",
+	"version": "5.1.0-beta.3",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "harper",
-			"version": "5.1.0-beta.2",
+			"version": "5.1.0-beta.3",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"@aws-sdk/client-s3": "^3.1012.0",
@@ -17,7 +17,7 @@
 				"@fastify/cors": "^11.2.0",
 				"@fastify/static": "^9.1.3",
 				"@harperfast/extended-iterable": "^1.0.1",
-				"@harperfast/rocksdb-js": "^2.0.0",
+				"@harperfast/rocksdb-js": "^2.1.0",
 				"@turf/area": "6.5.0",
 				"@turf/boolean-contains": "6.5.0",
 				"@turf/boolean-disjoint": "6.5.0",
@@ -95,7 +95,7 @@
 			},
 			"devDependencies": {
 				"@harperdb/code-guidelines": "^0.0.6",
-				"@harperfast/integration-testing": "^0.3.1",
+				"@harperfast/integration-testing": "^0.5.1",
 				"@modelcontextprotocol/sdk": "^1.29.0",
 				"@types/busboy": "^1.5.4",
 				"@types/fs-extra": "^11.0.4",
@@ -130,8 +130,7 @@
 				"why-is-node-still-running": "^1.0.0"
 			},
 			"engines": {
-				"minimum-node": "20.0.0",
-				"node": ">=20"
+				"node": "^22.18.0 || >=24.0.0"
 			},
 			"optionalDependencies": {
 				"bufferutil": "^4.0.9",
@@ -2898,9 +2897,9 @@
 			"license": "Apache-2.0"
 		},
 		"node_modules/@harperfast/integration-testing": {
-			"version": "0.3.1",
-			"resolved": "https://registry.npmjs.org/@harperfast/integration-testing/-/integration-testing-0.3.1.tgz",
-			"integrity": "sha512-hW7XsSTRWv38pK0nY4GZhGmmWAeQg/2eSSHAdwOO+niL7QORLExGjKCYxySylpKbWRdORQ7JjG5RMkFH+LQc9g==",
+			"version": "0.5.1",
+			"resolved": "https://registry.npmjs.org/@harperfast/integration-testing/-/integration-testing-0.5.1.tgz",
+			"integrity": "sha512-hHkDf9mgxdKFPqnlc1Dtz9je9WafUWGIofyzgfpmPWECxWqEo4NIa5CesJANtdKHSVsUtSiEt0E05y6+ZsBtPw==",
 			"dev": true,
 			"license": "Apache-2.0",
 			"dependencies": {
@@ -2923,13 +2922,13 @@
 			}
 		},
 		"node_modules/@harperfast/rocksdb-js": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js/-/rocksdb-js-2.0.0.tgz",
-			"integrity": "sha512-70ibZ4bg1kWaGnftsI/yRxPMzdwgLNJcryz3NtiZTywtlwpqcd9Q3wedXbQooayE7PYJmDJXIRDQj3KYkvud9w==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js/-/rocksdb-js-2.1.0.tgz",
+			"integrity": "sha512-1E6Yiu7U0HHVPzJQE3t3ifwyfqXjmmhaoBahN6JWzswu6TMkY3EpCNDozpZ2MVom/4b/7sUG9IRKUpX8h9XK/Q==",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"@harperfast/extended-iterable": "1.0.3",
-				"msgpackr": "2.0.2",
+				"msgpackr": "2.0.4",
 				"ordered-binary": "1.6.1"
 			},
 			"bin": {
@@ -2939,20 +2938,20 @@
 				"node": "^22.18.0 || >=24.0.0"
 			},
 			"optionalDependencies": {
-				"@harperfast/rocksdb-js-darwin-arm64": "2.0.0",
-				"@harperfast/rocksdb-js-darwin-x64": "2.0.0",
-				"@harperfast/rocksdb-js-linux-arm64-glibc": "2.0.0",
-				"@harperfast/rocksdb-js-linux-arm64-musl": "2.0.0",
-				"@harperfast/rocksdb-js-linux-x64-glibc": "2.0.0",
-				"@harperfast/rocksdb-js-linux-x64-musl": "2.0.0",
-				"@harperfast/rocksdb-js-win32-arm64": "2.0.0",
-				"@harperfast/rocksdb-js-win32-x64": "2.0.0"
+				"@harperfast/rocksdb-js-darwin-arm64": "2.1.0",
+				"@harperfast/rocksdb-js-darwin-x64": "2.1.0",
+				"@harperfast/rocksdb-js-linux-arm64-glibc": "2.1.0",
+				"@harperfast/rocksdb-js-linux-arm64-musl": "2.1.0",
+				"@harperfast/rocksdb-js-linux-x64-glibc": "2.1.0",
+				"@harperfast/rocksdb-js-linux-x64-musl": "2.1.0",
+				"@harperfast/rocksdb-js-win32-arm64": "2.1.0",
+				"@harperfast/rocksdb-js-win32-x64": "2.1.0"
 			}
 		},
 		"node_modules/@harperfast/rocksdb-js-darwin-arm64": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-darwin-arm64/-/rocksdb-js-darwin-arm64-2.0.0.tgz",
-			"integrity": "sha512-1Ed3XVekAFdoJJfDsrjBYJT1B85Zj91gQcC7fQq/CnhRdEk/D1ZdCsg7q9cg++mpZ5Ksnx+BsfiyqO67bTmKpQ==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-darwin-arm64/-/rocksdb-js-darwin-arm64-2.1.0.tgz",
+			"integrity": "sha512-KATHEEcKv1sBsuqaxgAd5ZqRNN63f/dedl5ilE0aZKubDjPHJFWLl1USZZXd4FMR7bYHzCV823S9RxZII1UTjA==",
 			"cpu": [
 				"arm64"
 			],
@@ -2966,9 +2965,9 @@
 			}
 		},
 		"node_modules/@harperfast/rocksdb-js-darwin-x64": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-darwin-x64/-/rocksdb-js-darwin-x64-2.0.0.tgz",
-			"integrity": "sha512-dK85CtR9RXhN5GF7Ndpt7krO5zImAl5pGyrx3QmepI72uT8ncppYurDEPZZ0z/A3LrBidXbaznUp2iGFVdYUYg==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-darwin-x64/-/rocksdb-js-darwin-x64-2.1.0.tgz",
+			"integrity": "sha512-8PgipGp9uviZ+c8amA1MiKthekL4Qxmd/wPGbaa2P5MEj7cW3nXwuwuLrXFtj0plfbGJZDKHAoHH1MQc63JiHQ==",
 			"cpu": [
 				"x64"
 			],
@@ -2982,9 +2981,9 @@
 			}
 		},
 		"node_modules/@harperfast/rocksdb-js-linux-arm64-glibc": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-linux-arm64-glibc/-/rocksdb-js-linux-arm64-glibc-2.0.0.tgz",
-			"integrity": "sha512-au7qK8VCkc6uU2lp2cRcO7HLML0ehfKFBimFYnxdwIHo6wZ1lPW5YVxKnuKIBKThMxdV6Dn2XJ3pu3ub8KtPrA==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-linux-arm64-glibc/-/rocksdb-js-linux-arm64-glibc-2.1.0.tgz",
+			"integrity": "sha512-kzlN++3RaECDeKLYP7a3A/7D1IrTu8DzVRdvQ90rjNi67ZhiTfPGLwkEJgSheGRaKOkvtXOcqaG+G0uLCmY2qg==",
 			"cpu": [
 				"arm64"
 			],
@@ -3001,9 +3000,9 @@
 			}
 		},
 		"node_modules/@harperfast/rocksdb-js-linux-arm64-musl": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-linux-arm64-musl/-/rocksdb-js-linux-arm64-musl-2.0.0.tgz",
-			"integrity": "sha512-x3F2h7fVwH1IHYlQDFOO5YJ9NH3pPkZybjPOaV1Vo8BiE9A72BabcVbQeV98/3STcMP2k20YpoggsI8QjcdCzQ==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-linux-arm64-musl/-/rocksdb-js-linux-arm64-musl-2.1.0.tgz",
+			"integrity": "sha512-Wm3GCuII2+2wUdpF14qMJpFBvYMS5LCNmqYqc8PLQdM9+1C0pp2xp/YlXz295lSJwDRBGpZQ4tT/fCIhQb3RZg==",
 			"cpu": [
 				"arm64"
 			],
@@ -3020,9 +3019,9 @@
 			}
 		},
 		"node_modules/@harperfast/rocksdb-js-linux-x64-glibc": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-linux-x64-glibc/-/rocksdb-js-linux-x64-glibc-2.0.0.tgz",
-			"integrity": "sha512-RDinS/7loqA7WuKQvfB73yc5dveTrOpdP/pXlFepWG1P586/0kpp0abRgCpkuSZyhmqIoWX9n9ooZvh03pvZ3A==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-linux-x64-glibc/-/rocksdb-js-linux-x64-glibc-2.1.0.tgz",
+			"integrity": "sha512-JOR19bhySF+fwFoxsR1JOURSxUySL1NE6wLBtWfLSA4SEQZXi/Xzkkq7Up92JuL9E4ATcEkVJjPy52azUUE4VA==",
 			"cpu": [
 				"x64"
 			],
@@ -3039,9 +3038,9 @@
 			}
 		},
 		"node_modules/@harperfast/rocksdb-js-linux-x64-musl": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-linux-x64-musl/-/rocksdb-js-linux-x64-musl-2.0.0.tgz",
-			"integrity": "sha512-gswLCyzqPUoB2HlTE+DMOd2Nr7H9uUg/pgtZpIvTpHU6ewV2O8mANT6qV/DLN9uPKWrBSp77b92PxXYtPRyPsA==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-linux-x64-musl/-/rocksdb-js-linux-x64-musl-2.1.0.tgz",
+			"integrity": "sha512-HhUeWFqlEdjDPQecO1Exp3zm4LmXV2biyWPycXWBwXpitaI3YbDaUkiZHLT5QmGdYMHQou9s9RrcJ0B0xBpaYA==",
 			"cpu": [
 				"x64"
 			],
@@ -3058,9 +3057,9 @@
 			}
 		},
 		"node_modules/@harperfast/rocksdb-js-win32-arm64": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-win32-arm64/-/rocksdb-js-win32-arm64-2.0.0.tgz",
-			"integrity": "sha512-vwVMVS/Nw5Mw17whMVQG7eJfBXqS2NeABiCxgsd2SoV6ovvm0TbSg9D8z2hsJlSJGy8BSYxK8i+xgqf1oh1ogA==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-win32-arm64/-/rocksdb-js-win32-arm64-2.1.0.tgz",
+			"integrity": "sha512-pUxyRGlyx+o0zU/ioUb4Z7ZQPy01iDU0gr7YQnOn9gCyDo1ibeeZVKDYZJ+WEpQCWEdea5YJVrSt597BQPAJiQ==",
 			"cpu": [
 				"arm64"
 			],
@@ -3074,9 +3073,9 @@
 			}
 		},
 		"node_modules/@harperfast/rocksdb-js-win32-x64": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-win32-x64/-/rocksdb-js-win32-x64-2.0.0.tgz",
-			"integrity": "sha512-WzaatIsLBjWrmRHHCcOeQ3TqUpBiEoaKBI6SbG6UQRO41gI7Ts0LVHtYF195Luldc8XsibSic1VztEPh2ubVAQ==",
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/@harperfast/rocksdb-js-win32-x64/-/rocksdb-js-win32-x64-2.1.0.tgz",
+			"integrity": "sha512-C0XFhYIUAJxYKUV+P12lgzEhsH7NMzlSBq8WtEQun8PLI2WJIWpeo/UI7Z/YLKcO8dR8mYh1w/uui/vBC86sRg==",
 			"cpu": [
 				"x64"
 			],
@@ -3089,15 +3088,6 @@
 				"node": "^22.18.0 || >=24.0.0"
 			}
 		},
-		"node_modules/@harperfast/rocksdb-js/node_modules/msgpackr": {
-			"version": "2.0.2",
-			"resolved": "https://registry.npmjs.org/msgpackr/-/msgpackr-2.0.2.tgz",
-			"integrity": "sha512-c5hYOXFbP79Slh6Dzd2wzk+jnV7mX1UxfMYtilnY1NmalXPqG8DGb5cYCMBrW4AsH3zekBBZd4QrKz9NhtvYLQ==",
-			"license": "MIT",
-			"optionalDependencies": {
-				"msgpackr-extract": "^3.0.4"
-			}
-		},
 		"node_modules/@hono/node-server": {
 			"version": "1.19.14",
 			"resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.14.tgz",

package/core/resources/Table.ts

@@ -1017,6 +1017,29 @@ export function makeTable(options) {
 		}
 
 		static async dropTable() {
+			if (databaseName === databasePath) {
+				// Persist a drop tombstone on the primary catalog entry BEFORE any
+				// destructive work. If the process dies or a column family drop fails
+				// partway through, the tombstone survives with the catalog rows, and
+				// the next startup (or a same-name create) completes the drop via
+				// completeInterruptedDrop in databases.ts instead of resurrecting
+				// the table.
+				const primaryCatalogKey = TableResource.tableName + '/';
+				const primaryMeta = (dbisDb as any).getSync(primaryCatalogKey);
+				if (primaryMeta && !primaryMeta.dropping) {
+					primaryMeta.dropping = true;
+					// put is rebound to putSync on RocksDB stores; on LMDB it returns
+					// a promise, so await it to make the tombstone durable before the
+					// destructive work below
+					const tombstoneWrite = (dbisDb as any).put(primaryCatalogKey, primaryMeta);
+					if (tombstoneWrite?.then) await tombstoneWrite;
+				}
+			}
+			// Remove the table from the in-memory schema immediately so concurrent
+			// requests get "table does not exist" instead of racing the column
+			// family drops below. If a drop fails past this point the table stays
+			// invisible, and the tombstone guarantees the drop completes on the
+			// next startup (or on a same-name create).
 			delete databases[databaseName][tableName];
 			for (const entry of primaryStore.getRange({ versions: true, snapshot: false, lazy: true })) {
 				if (entry.metadataFlags & HAS_BLOBS && entry.value) {
@@ -1024,14 +1047,28 @@ export function makeTable(options) {
 				}
 			}
 			if (databaseName === databasePath) {
-				// part of a database
+				// part of a database.
+				// Drop the column families and AWAIT them. Previously the catalog
+				// metadata was removed (synchronous removeSync) before primaryStore.drop(),
+				// and the drops were fire-and-forget (their rejections swallowed). If a
+				// column family was corrupt/half-initialized the drop would fail, yet the
+				// catalog entry was already gone - an orphaned "ghost" column family that
+				// poisons same-name recreates. By awaiting the drops before touching the
+				// catalog, a failed drop surfaces as the operation's error and the
+				// tombstoned catalog rows survive for the startup reconcile.
+				const drops = [];
 				for (const attribute of attributes) {
-					dbisDb.remove(TableResource.tableName + '/' + attribute.name);
 					const index = indices[attribute.name];
-					index?.drop();
+					if (index) drops.push(index.drop());
+				}
+				drops.push(primaryStore.drop());
+				await Promise.all(drops);
+				// Column families are gone; remove the catalog metadata (including
+				// the tombstoned primary entry).
+				for (const attribute of attributes) {
+					dbisDb.remove(TableResource.tableName + '/' + attribute.name);
 				}
 				dbisDb.remove(TableResource.tableName + '/');
-				primaryStore.drop();
 				await dbisDb.committed;
 			} else {
 				// legacy table per database

package/core/resources/databases.ts

@@ -521,6 +521,27 @@ function initStores(
 		Object.defineProperty(value, 'key', { value: key, configurable: true });
 	}
 
+	// Complete any drops that were interrupted mid-flight. dropTable persists a
+	// `dropping` tombstone on the table's primary catalog entry before removing
+	// column families; if the process died or a column family drop failed
+	// partway, the tombstone survives alongside the catalog rows. Without this
+	// reconcile, those rows would silently resurrect the table below
+	// (recreating any missing column families as empty stores).
+	for (const [tableName, tableDef] of tablesToLoad) {
+		if (!tableDef.primary?.dropping) continue;
+		try {
+			completeInterruptedDrop(rootStore, attributesDbi, databaseName, tableName);
+			definedTables?.delete(tableName);
+		} catch (error) {
+			logger.error(
+				`Failed to complete interrupted drop of table ${databaseName}.${tableName}; will retry on next start`,
+				error
+			);
+		}
+		// whether or not cleanup succeeded, never load a table that was being dropped
+		tablesToLoad.delete(tableName);
+	}
+
 	for (const [tableName, tableDef] of tablesToLoad) {
 		let { attributes, primary: primaryAttribute } = tableDef;
 		if (!primaryAttribute) {
@@ -1067,7 +1088,8 @@ export function table<TableResourceType>(tableDefinition: TableDefinition): Tabl
 		}
 
 		exclusiveLock(); // get an exclusive lock on the database so we can verify that we are the only thread creating the table (and assigning the table id)
-		if ((attributesDbi as any).getSync(dbiName)) {
+		const existingTableMeta = (attributesDbi as any).getSync(dbiName);
+		if (existingTableMeta && !existingTableMeta.dropping) {
 			// table was created while we were setting up
 			if (releaseExclusiveLock) releaseExclusiveLock();
 			resetDatabases();
@@ -1075,50 +1097,69 @@ export function table<TableResourceType>(tableDefinition: TableDefinition): Tabl
 		}
 
 		let primaryStore;
-		if (rootStore instanceof RocksDatabase) {
-			primaryStore = openRocksDatabase(rootStore.path, { ...dbiInit, name: dbiName } as any);
-		} else {
-			primaryStore = (rootStore as any).openDB(dbiName, dbiInit as any);
-		}
-		primaryStore = handleLocalTimeForGets(primaryStore, rootStore);
-		rootStore.databaseName = databaseName;
-		primaryStore.tableId = attributesDbi.getSync(NEXT_TABLE_ID);
-		logger.trace(`Assigning new table id ${primaryStore.tableId} for ${tableName}`);
-		if (!primaryStore.tableId) primaryStore.tableId = 1;
-		attributesDbi.put(NEXT_TABLE_ID, primaryStore.tableId + 1);
+		try {
+			if (existingTableMeta?.dropping) {
+				// A previous drop of this table was interrupted after its tombstone
+				// was written. Complete it now (under the exclusive lock) so the
+				// create below starts from a clean slate; treating the tombstoned
+				// entry as an existing table would recurse forever on the stale
+				// catalog row.
+				completeInterruptedDrop(rootStore, attributesDbi, databaseName, tableName);
+			}
+			if (rootStore instanceof RocksDatabase) {
+				primaryStore = openRocksDatabase(rootStore.path, { ...dbiInit, name: dbiName } as any);
+			} else {
+				primaryStore = (rootStore as any).openDB(dbiName, dbiInit as any);
+			}
+			primaryStore = handleLocalTimeForGets(primaryStore, rootStore);
+			rootStore.databaseName = databaseName;
+			primaryStore.tableId = attributesDbi.getSync(NEXT_TABLE_ID);
+			logger.trace(`Assigning new table id ${primaryStore.tableId} for ${tableName}`);
+			if (!primaryStore.tableId) primaryStore.tableId = 1;
+			attributesDbi.put(NEXT_TABLE_ID, primaryStore.tableId + 1);
 
-		primaryKeyAttribute.tableId = primaryStore.tableId;
-		Table = setTable(
-			tables,
-			tableName,
-			makeTable({
-				primaryStore,
-				auditStore,
-				audit,
-				sealed,
-				splitSegments,
-				replicate,
-				trackDeletes,
-				expirationMS: expiration && expiration * 1000,
-				evictionMS: eviction && eviction * 1000,
-				primaryKey,
+			primaryKeyAttribute.tableId = primaryStore.tableId;
+			Table = setTable(
+				tables,
 				tableName,
-				tableId: primaryStore.tableId,
-				databasePath: databaseName,
-				databaseName,
-				indices: {},
-				attributes,
-				schemaDefined,
-				dbisDB: attributesDbi,
-				description,
-				properties,
-				hidden,
-			})
-		);
-		Table.schemaVersion = 1;
-		hasChanges = true;
+				makeTable({
+					primaryStore,
+					auditStore,
+					audit,
+					sealed,
+					splitSegments,
+					replicate,
+					trackDeletes,
+					expirationMS: expiration && expiration * 1000,
+					evictionMS: eviction && eviction * 1000,
+					primaryKey,
+					tableName,
+					tableId: primaryStore.tableId,
+					databasePath: databaseName,
+					databaseName,
+					indices: {},
+					attributes,
+					schemaDefined,
+					dbisDB: attributesDbi,
+					description,
+					properties,
+					hidden,
+				})
+			);
+			Table.schemaVersion = 1;
+			hasChanges = true;
 
-		attributesDbi.put(dbiName, primaryKeyAttribute);
+			attributesDbi.put(dbiName, primaryKeyAttribute);
+		} catch (error) {
+			// A failure while opening/creating the column family or writing the
+			// table id / catalog entry (e.g. into an env poisoned by a prior
+			// dangling column family) must NOT leak the exclusive
+			// 'update-attributes' spin lock. If it leaks, every subsequent
+			// create_table / attribute update on this database spins forever
+			// (a hard wedge that pins a worker at 100% CPU). Release before rethrow.
+			if (releaseExclusiveLock) releaseExclusiveLock();
+			throw error;
+		}
 	}
 	const indices = Table.indices;
 	if (!attributesDbi) {
@@ -1171,8 +1212,14 @@ export function table<TableResourceType>(tableDefinition: TableDefinition): Tabl
 			let attributeDescriptor = attributesDbi.getSync(dbiKey);
 			if (attribute.isPrimaryKey) {
 				attributeDescriptor = attributeDescriptor || attributesDbi.getSync((dbiKey = tableName + '/')) || {};
+				// Persist schemaDefined when the explicit live value disagrees with disk. Without this,
+				// a stale `false` (from a v4-era write or replicated event) survives every reload: the
+				// in-memory re-assert in the existing-Table branch only fixes the worker that ran @table,
+				// but other workers' next disk-load re-reads the stale value.
+				const schemaDefinedMismatch = schemaDefinedExplicit && attributeDescriptor.schemaDefined !== schemaDefined;
 				// primary key can't change indexing, but settings can change
 				if (
+					schemaDefinedMismatch ||
 					(audit !== undefined && audit !== Table.audit) ||
 					(sealed !== undefined && sealed !== Table.sealed) ||
 					(replicate !== undefined && replicate !== Table.replicate) ||
@@ -1190,6 +1237,7 @@ export function table<TableResourceType>(tableDefinition: TableDefinition): Tabl
 					if (sealed !== undefined) updatedPrimaryAttribute.sealed = sealed;
 					if (replicate !== undefined) updatedPrimaryAttribute.replicate = replicate;
 					if (attribute.type) updatedPrimaryAttribute.type = attribute.type;
+					if (schemaDefinedMismatch) updatedPrimaryAttribute.schemaDefined = schemaDefined;
 					hasChanges = true; // send out notification of the change
 					exclusiveLock();
 					attributesDbi.put(dbiKey, updatedPrimaryAttribute);
@@ -1538,6 +1586,50 @@ async function runIndexing(Table, attributes, indicesToRemove) {
 	}
 }
 
+/**
+ * Completes a table drop that was interrupted after its `dropping` tombstone
+ * was written: drops any surviving table stores and removes the table's
+ * catalog rows. Called from the boot-time schema load and from the create
+ * path when a same-named table is created over a tombstoned entry. Callers
+ * are expected to hold the database's exclusive lock or be in single-threaded
+ * startup; the per-store drops tolerate races (another worker may be
+ * completing the same drop concurrently).
+ */
+function completeInterruptedDrop(rootStore, attributesDbi, databaseName: string, tableName: string) {
+	logger.warn(`Completing interrupted drop of table ${databaseName}.${tableName}`);
+	if (rootStore instanceof RocksDatabase) {
+		for (const columnName of (rootStore as any).columns) {
+			if (columnName.startsWith(tableName + '/')) {
+				try {
+					const columnStore = openRocksDatabase(rootStore.path, { name: columnName } as any);
+					columnStore.dropSync();
+					columnStore.close();
+				} catch (error) {
+					logger.warn(`Failed dropping column family ${columnName} of ${databaseName}.${tableName}`, error);
+				}
+			}
+		}
+	} else {
+		// LMDB reuses an existing named sub-database on open, so the stores must
+		// be dropped too; removing only the catalog rows would let a same-name
+		// recreate silently inherit the previous table's records.
+		for (const { key, value } of attributesDbi.getRange({ start: tableName + '/', end: tableName + '0' })) {
+			try {
+				const objectStorage =
+					value?.isPrimaryKey || (value?.indexed?.type && CUSTOM_INDEXES[value.indexed.type]?.useObjectStore);
+				const store = (rootStore as any).openDB(key, createOpenDBIObject(!objectStorage, objectStorage) as any);
+				// lmdb drop commits with the env's next transaction
+				store.drop?.();
+			} catch (error) {
+				logger.warn(`Failed dropping store ${key} of ${databaseName}.${tableName}`, error);
+			}
+		}
+	}
+	for (const key of attributesDbi.getKeys({ start: tableName + '/', end: tableName + '0' })) {
+		attributesDbi.remove(key);
+	}
+}
+
 export function dropTableMeta({ table: tableName, database: databaseName }) {
 	const rootStore = database({ database: databaseName, table: tableName });
 	const removals = [];

package/core/resources/graphql.ts

@@ -109,6 +109,9 @@ async function processGraphQLSchema(gqlContent, urlPath, filePath, resources) {
 						for (const arg of directive.arguments) {
 							typeDef[arg.name.value] = coerceDirectiveValue(arg.value);
 						}
+						// @table is the canonical schema-defined declaration; pass the flag explicitly so
+						// the existing-Table re-assert in databases.ts::table() fires on every reload.
+						typeDef.schemaDefined = true;
 						if (typeDef.schema) typeDef.database = typeDef.schema;
 						if (!typeDef.table) typeDef.table = typeName;
 						if (typeDef.audit) typeDef.audit = typeDef.audit !== 'false';