@harperfast/harper 5.3.0-beta.4 → 5.3.0

package/resources/Table.ts

@@ -5,7 +5,7 @@
  */
 
 import { CONFIG_PARAMS, OPERATIONS_ENUM, MAX_SET_TIMEOUT_MS } from '../utility/hdbTerms.ts';
-import { type Database } from 'lmdb';
+import { type Database, type Transaction as LMDBReadTransaction } from 'lmdb';
 import { Script } from 'node:vm';
 import { randomUUID } from 'node:crypto';
 import { performance } from 'node:perf_hooks';
@@ -22,8 +22,13 @@ import type {
 	Sort,
 	SubSelect,
 	RequestTargetOrId,
+	Query,
+	SourceContext,
 } from './ResourceInterface.ts';
 import type { User } from '../security/user.ts';
+import type { AssertNoDrift, AssertTrue, ExactlyEqual, MemberDrift, ParitySentinel } from './typeParity.ts';
+import type { IterableEventQueue } from './IterableEventQueue.ts';
+import type { Contract, SchemaClass } from './defineResource.ts';
 import lmdbProcessRows from '../dataLayer/harperBridge/lmdbBridge/lmdbUtility/lmdbProcessRows.js';
 import { Resource, SEARCH_AUTHORIZATION, transformForSelect } from './Resource.ts';
 import { settleBeforeDeadline, when, promiseNormalize } from '../utility/when.ts';
@@ -40,6 +45,7 @@ import {
 	commitTrackedRocksTransaction,
 	getDatabaseCommitDrainTimeoutMilliseconds,
 	type WriteGeneration,
+	type Transaction as DatabaseTransactionRecord,
 } from './DatabaseTransaction.ts';
 import {
 	acquireRecordKey,
@@ -56,6 +62,7 @@ import { addSubscription } from './transactionBroadcast.ts';
 import { databaseDropPrepared } from './databaseDropPreparation.ts';
 import {
 	DerivedIndexLagError,
+	IndexRebuildingError,
 	DatabaseClosingError,
 	DatabaseDrainTimeoutError,
 	handleHDBError,
@@ -91,6 +98,7 @@ import {
 	COERCIBLE_OPERATORS,
 	executeConditions,
 	resolveComparator,
+	fullTextComparatorMode,
 } from './search.ts';
 import { logger } from '../utility/logging/logger.ts';
 import { isStaticResourceInstance } from './staticResourceDispatch.ts';
@@ -161,6 +169,7 @@ import {
 	recordUpdater,
 	removeEntry,
 	PENDING_LOCAL_TIME,
+	VERSION_REUSED,
 	RecordObject,
 	type Entry,
 	type StructureCounts,
@@ -177,6 +186,7 @@ import {
 	removeStorageReclamation,
 	removeStorageReclamationHandler,
 	getStorageSpaceStats,
+	type StorageSpaceStats,
 } from '../server/storageReclamation.ts';
 import { RequestTarget } from './RequestTarget.ts';
 import harperLogger from '../utility/logging/harper_logger.ts';
@@ -541,6 +551,7 @@ const MAX_OUT_OF_ORDER_AUDIT_DEPTH = 1000;
 const MAX_PREVIOUS_COUNT_SCAN = 10_000;
 const AUTHORIZATION_SELECT = Symbol.for('harper.authorizationSelect');
 const SEARCH_AUTHORIZATION_TRANSFORMS = Symbol.for('harper.searchAuthorizationTransforms');
+const FULL_TEXT_READ_PERMISSION = Symbol('fullTextReadPermission');
 const AUTHORIZATION_TRANSFORM_METHODS = ['map', 'filter', 'concat', 'flatMap', 'slice', 'mapError'];
 
 function propagateSearchAuthorization(iterable: any, authorization: Promise<any>, source?: any) {
@@ -593,6 +604,515 @@ export interface Table {
 }
 type ResidencyDefinition = number | string[] | void;
 
+interface TableResourceInstance<Record extends object = any> {
+	getProperty: (name: string) => any;
+	_loadRecord(
+		target: RequestTarget,
+		request: Context,
+		resourceOptions?: any
+	): MaybePromise<TableResourceInstance<Record>>;
+	/**
+	 * This is a request to explicitly ensure that the record is loaded from source, rather than only using the local record.
+	 * This will load from source if the current record is expired, missing, or invalidated.
+	 */
+	ensureLoaded(): void | Promise<void>;
+	/**
+	 * This retrieves the data of this resource.
+	 * @param target - If included, is an identifier/query that specifies the requested target to retrieve and query
+	 */
+	get(target?: any): any;
+	/**
+	 * Determine if the user is allowed to get/read data from the current resource
+	 * @deprecated Override the resource operation for application-specific authorization.
+	 */
+	allowRead(user: User, target: RequestTarget, context: Context): boolean;
+	/**
+	 * Determine if the user is allowed to update data from the current resource
+	 * @deprecated Override the resource operation for application-specific authorization.
+	 */
+	allowUpdate(user: User, updatedData: Record, context: Context): boolean;
+	/**
+	 * Determine if the user is allowed to create new data in the current resource
+	 * @deprecated Override the resource operation for application-specific authorization.
+	 */
+	allowCreate(user: User, newData: Record, context: Context): boolean;
+	/**
+	 * Determine if the user is allowed to delete from the current resource
+	 * @deprecated Override the resource operation for application-specific authorization.
+	 */
+	allowDelete(user: User, target: RequestTarget, context: Context): boolean;
+	/**
+	 * Start updating a record. The returned resource will record changes which are written
+	 * once the corresponding transaction is committed. These changes can (eventually) include CRDT type operations.
+	 */
+	update(updates: Record & RecordObject, fullUpdate: true): any;
+	update(updates: Partial<Record & RecordObject>, target?: RequestTarget): any;
+	update(target: RequestTarget, updates?: any): any;
+	/**
+	 * Save any changes into this instance to the current transaction
+	 */
+	save(): any;
+	addTo(property: any, value: any): void;
+	subtractFrom(property: any, value: any): void;
+	getMetadata(): Entry;
+	getRecord(): any;
+	getChanges(): any;
+	_setChanges(changes: any): void;
+	setRecord(record: any): void;
+	invalidate(target: RequestTargetOrId): void | Promise<void>;
+	_writeInvalidate(id: Id, partialRecord?: any, options?: any): void;
+	_writeRelocate(id: Id, options: any): void;
+	/**
+	 * Acquire an exclusive lock on this record (or on `target`'s) and return it ready for updates
+	 * (harper#483, Phase 0: exclusive across every worker thread of this node). The lock is held
+	 * in process memory only — no durable writes. Phase 0 contract: lock() is mutually exclusive
+	 * with other lock() calls on the same key; plain writes (put/patch/delete/create) are never
+	 * gated or blocked. The generation expires after `lease` if it is never released.
+	 *
+	 * Transaction-scoped (default): write through the returned record (or the table's static verbs
+	 * in the same transaction), and the commit or abort releases it. `{ hold: true }`: the lock
+	 * outlives the transaction; write through the returned record and release with `unlock()`, or
+	 * let the lease expire.
+	 */
+	lock(target?: RequestTargetOrId | RecordLockOptions, options?: RecordLockOptions): Promise<any>;
+	/**
+	 * Release the lock this instance holds. Resolves true when this call cleared the native key lock.
+	 * Works for both held (`{ hold: true }`) and transaction-scoped locks. After unlock() the
+	 * instance is no longer lock-writable; writes through it require a fresh lock.
+	 */
+	unlock(): Promise<boolean>;
+	/**
+	 * Store the provided record data into the current resource. This is not written
+	 * until the corresponding transaction is committed.
+	 */
+	put(
+		target: RequestTarget,
+		record: Record & RecordObject
+	): void | (Record & Partial<RecordObject>) | Promise<void | (Record & Partial<RecordObject>)>;
+	create(
+		target: RequestTargetOrId,
+		record: Partial<Record & RecordObject>
+	): void | (Record & Partial<RecordObject>) | Promise<Record & Partial<RecordObject>>;
+	patch(
+		target: RequestTarget,
+		recordUpdate: Partial<Record & RecordObject>
+	): void | (Record & Partial<RecordObject>) | Promise<void | (Record & Partial<RecordObject>)>;
+	_writeUpdate(id: Id, recordUpdate: any, fullUpdate: boolean, options?: any): any;
+	delete(target: RequestTargetOrId): Promise<boolean>;
+	_writeDelete(id: Id, options?: any): boolean;
+	search(target: RequestTarget): AsyncIterable<Record & Partial<RecordObject>>;
+	subscribe(request: SubscriptionRequest): Promise<AsyncIterable<Record>>;
+	doesExist(): boolean;
+	/**
+	 * Publishing a message to a record adds an (observable) entry in the audit log, but does not change
+	 * the record at all. This entries should be replicated and trigger subscription listeners.
+	 */
+	publish(target: RequestTarget, message: Record, options?: any): void | Promise<void>;
+	_writePublish(id: Id, message: any, options?: any): void;
+	validate(record: any, patch?: boolean): void;
+	getUpdatedTime(): number;
+	[ASSERT_TRACKED_WRITABLE](generation?: WriteGeneration): void;
+	[GET_TRACKED_WRITE_GENERATION](): WriteGeneration;
+	post(target: RequestTargetOrId, newRecord: Partial<Record & RecordObject>): Promise<Record & Partial<RecordObject>>;
+	get isCollection(): boolean;
+	connect(
+		target: RequestTarget,
+		incomingMessages: IterableEventQueue<Record>
+	): AsyncIterable<Record> | Promise<AsyncIterable<Record>>;
+	getId(): Id;
+	getContext(): Context | SourceContext;
+	getCurrentUser(): User | undefined;
+}
+
+interface TableResourceClass {
+	new <Record extends object = any>(identifier: Id, source: any): TableResourceInstance<Record>;
+	prototype: TableResourceInstance;
+	name: any;
+	primaryStore: any;
+	storageGeneration: any;
+	auditStore: any;
+	primaryKey: any;
+	tableName: any;
+	tableId: any;
+	indices: any;
+	derivedIndexRuntime:
+		| {
+				close(dropping?: boolean): Promise<void>;
+				fullTextDefinitions?(): readonly FullTextDefinition[];
+				matchesCurrent?(): boolean;
+				restoreAfterFailedDrop?(): TableResourceClass['derivedIndexRuntime'];
+				retireAfterConfirmedDrop?(definitions?: readonly Pick<FullTextDefinition, 'name'>[]): Promise<boolean>;
+				completeDrop?(dropped?: boolean): void;
+		  }
+		| undefined;
+	audit: any;
+	fullTextIndexes: FullTextDefinition[];
+	get fullTextFields(): readonly string[];
+	set fullTextFields(names: readonly string[]);
+	assertFullTextSelection(select: unknown, sort?: any): void;
+	assertFullTextRecordField(name: unknown): void;
+	isFullTextSearchEntryCurrent(entry: Entry): boolean;
+	fullTextQueryIndexes: {
+		[name: string]: {
+			customIndex: unknown;
+		};
+	};
+	hasFullTextQueryIndexes: boolean;
+	fullTextIndexGenerations: FullTextIndexGenerations;
+	fullTextIndexRetirements: string[];
+	hasCurrentFullTextIndexRetirements(names: readonly string[]): boolean | Promise<boolean>;
+	completeFullTextIndexRetirements(names: readonly string[]): void | Promise<void>;
+	databasePath: any;
+	databaseName: any;
+	attributes: Attribute[];
+	description: any;
+	properties: Record<string, JsonSchemaFragment>;
+	hidden: any;
+	cacheControl: any;
+	outputSchemas:
+		| {
+				[verb: string]: JsonSchemaFragment;
+		  }
+		| undefined;
+	mcp:
+		| {
+				annotations?: {
+					[verb: string]: any;
+				};
+		  }
+		| undefined;
+	replicate: any;
+	sealed: any;
+	splitSegments: any;
+	createdTimeProperty: Attribute;
+	updatedTimeProperty: Attribute;
+	propertyResolvers: any;
+	enumerableRelationDefs: any;
+	userResolvers: {};
+	userEmbedders: {
+		[name: string]: Embedder;
+	};
+	userSetEmbedders: Set<string>;
+	embedAttributes: EmbedAttribute[];
+	userDeciders: {
+		[name: string]: Decider;
+	};
+	userSetDeciders: Set<string>;
+	decideAttributes: DecideAttribute[];
+	source?: any;
+	sourceOptions: any;
+	intermediateSource: boolean;
+	getResidencyById: (id: Id) => number | void;
+	get expirationMS(): any;
+	get evictionMS(): any;
+	dbisDB: any;
+	schemaDefined: any;
+	/**
+	 * This defines a source for a table. This effectively makes a table into a cache, where the canonical
+	 * source of data (or source of truth) is provided here in the Resource argument. Additional options
+	 * can be provided to indicate how the caching should be handled.
+	 */
+	sourcedFrom(source: any, options: any): any;
+	get isCaching(): any;
+	/** Indicates if the events should be revalidated when they are received. By default we do this if the get
+	 * method is overriden */
+	get shouldRevalidateEvents(): boolean;
+	/**
+	 * Gets a resource instance, as defined by the Resource class, adding the table-specific handling
+	 * of also loading the stored record into the resource instance.
+	 * @param resourceOptions An important option is ensureLoaded, which can be used to indicate that it is necessary for a caching table to load data from the source if there is not a local copy of the data in the table (usually not necessary for a delete, for example).
+	 */
+	getResource<Record extends object = any>(
+		target: RequestTarget,
+		request: Context,
+		resourceOptions?: any
+	): Promise<TableResourceInstance<Record>> | TableResourceInstance<Record>;
+	_updateResource(resource: any, entry: any): void;
+	getNewId(): any;
+	/**
+	 * Set TTL expiration for records in this table. On retrieval, record timestamps are checked for expiration.
+	 * This also informs the scheduling for record eviction.
+	 * @param opts Time in seconds until records expire, or an options object with `expiration`, `eviction`,
+	 * and `scanInterval` (all in seconds, all optional). Number form preserves any previously configured
+	 * eviction/scanInterval; object form replaces all three. An internal schema ownership-only call with
+	 * none of those values preserves the settings already loaded from the catalog.
+	 */
+	setTTLExpiration(
+		opts:
+			| number
+			| {
+					expiration?: number;
+					eviction?: number;
+					scanInterval?: number;
+					fromSchema?: boolean;
+					isolatedApplicationOwner?: boolean;
+			  }
+	): void;
+	getResidencyRecord(id: Id): any;
+	setResidency(getResidency?: (record: object, context: Context) => ResidencyDefinition): void;
+	setResidencyById(getResidencyById?: (id: Id) => number | void): void;
+	getResidency(record: object, context: Context): number | void | string[];
+	/**
+	 * Turn on auditing at runtime
+	 */
+	enableAuditing(): void;
+	/**
+	 * Coerce the id as a string to the correct type for the primary key
+	 */
+	coerceId(id: string): number | string;
+	/**
+	 * A branch's Table classes deliberately carry the BASE's logical database name so an
+	 * application's schema and code resolve unchanged (harper#643). That makes every schema
+	 * mutation resolve against the global catalog — a `dropTable()` through a branch would delete
+	 * the live base table. Reads and writes are per-branch and unaffected; DDL is refused until a
+	 * branch owns a schema identity of its own.
+	 */
+	assertSchemaMutable(operation: string): void;
+	dropTable(): Promise<void>;
+	/**
+	 * Record the relocation of an entry (when a record is moved to a different node), return true if it is now located locally
+	 */
+	_recordRelocate(existingEntry: any, entry: any): boolean;
+	/**
+	 * Evicting a record will remove it from a caching table. This is not considered a canonical data change, and it is assumed that retrieving this record from the source will still yield the same record, this is only removing the local copy of the record.
+	 */
+	evict(id: any, existingRecord: any, existingVersion: any): Promise<unknown>;
+	/**
+	 * Static entry point: `Table.lock(id, options?, context?)` — creates an instance in the given,
+	 * ambient, or a fresh context and delegates to the instance lock(). This shadows Resource.static
+	 * lock so that both callers share the same transaction link (required for cross-instance upgrade
+	 * detection).  lock() is an in-process API with no authorization hook of its own; it is not
+	 * protocol-dispatched, so no allowUpdate/allowCreate check runs on acquisition.
+	 *
+	 * Dropping the trailing `context` leaks the key: the bare `{}` fallback is an
+	 * ImmediateTransaction, which releases no record locks.
+	 */
+	lock(target?: RequestTargetOrId | RecordLockOptions, options?: RecordLockOptions, context?: any): Promise<any>;
+	operation(operation: any, context: any): any;
+	/**
+	 * This is responsible for ordering and select()ing the attributes/properties from returned entries
+	 */
+	transformToOrderedSelect(
+		entries: any[],
+		select: (string | SubSelect)[],
+		sort: Sort,
+		context: Context,
+		readTxn: any,
+		transformToRecord: Function
+	): any;
+	/**
+	 * This is responsible for select()ing the attributes/properties from returned entries
+	 * @param rowFilter explicit row predicate applied to the record actually being
+	 * returned — i.e. AFTER any caching-source revalidation replaces a stale local copy — so an
+	 * authorization verdict can't be made on bytes that differ from what the caller receives.
+	 * @param includeExpired when true, a row past its TTL but not yet swept is treated as a live
+	 * match rather than gone (used by the SQL engine's UPDATE/DELETE row-finder).
+	 * @param sort post-ordering owned by this selection
+	 */
+	transformEntryForSelect(
+		select: any,
+		context: any,
+		readTxn: any,
+		filtered: any,
+		ensure_loaded?: any,
+		canSkip?: any,
+		rowFilter?: any,
+		includeExpired?: any,
+		sort?: any
+	): (entry: Entry) => any;
+	/**
+	 * Subscribe on one thread unless this is a per-thread subscription
+	 */
+	subscribeOnThisThread(workerIndex: any, options: any): boolean;
+	/**
+	 * Write a single table-reload marker for this table (harper-pro#489): a LOCAL_ONLY audit entry of
+	 * type 'reload' with no record, committed in its own transaction. Subscribers driven off the audit
+	 * stream — hdb_nodes peer discovery and hdb_certificate CA install — treat it as "this table was
+	 * bulk-reloaded, re-read it". It is needed after a copyApply base copy, whose per-row snapshot rows
+	 * carry no audit entry, so the per-row events those subscribers rely on never fire. The marker is
+	 * never replicated (its LOCAL_ONLY bit makes the send path skip it without decoding the
+	 * peers-may-not-know type), and a lost marker self-heals on restart because each subscriber re-scans
+	 * the table when it (re)subscribes.
+	 */
+	writeReloadMarker(context?: any): void;
+	/**
+	 * Write one cluster record-lock control entry (harper#483 Phase 1). Not local-only: replicating
+	 * it IS the send.
+	 *
+	 * `recordId` must stay null. An entry carrying the locked key would share
+	 * `(version, tableId, recordId, nodeId)` with the holder's own first write, which is stamped at
+	 * exactly `ts_R`, and `RocksTransactionLogStore.getSync` answers with the FIRST entry at a
+	 * timestamp and key — so `_writeUpdate`'s keyed dedup would find this one and drop that write.
+	 * The payload goes in as bytes rather than through `recordUpdater`, which would run it through
+	 * schema projection and the table's shared structure dictionary.
+	 */
+	writeLockControlEntry(entry: LockControlEntry): Promise<number | undefined>;
+	/**
+	 * The coordinator that holds this node's admissions, transport or not. Releasing and registering
+	 * go here rather than through `lockCoordinator`, which answers undefined while a transport is
+	 * momentarily unregistered — and a release dropped on that answer leaves the key's home holding
+	 * its grant until the delegation's own deadline.
+	 */
+	get admittingCoordinator(): LockCoordinator | undefined;
+	/**
+	 * This table's cluster lock coordinator, created on first use and only while a transport is
+	 * registered for the database. Nothing is allocated on the Phase 0 path.
+	 */
+	get lockCoordinator(): LockCoordinator | undefined;
+	addAttributes(attributesToAdd: Attribute[]): Promise<any>;
+	removeAttributes(names: string[]): Promise<any>;
+	/**
+	 * Get the size of the table in bytes (based on amount of pages stored in the database)
+	 */
+	getSize(): number;
+	/** Sizes of this table's durable record-structure dictionaries. */
+	getStructureCounts(): StructureCounts | undefined;
+	getAuditSize(): number;
+	/**
+	 * Get available/free/size storage stats for the table's underlying volume. Async because
+	 * this may need to read quota-status.json (#1976); getSize/getAuditSize stay sync because
+	 * they only read in-memory store stats.
+	 */
+	getStorageStats(): Promise<StorageSpaceStats>;
+	getRecordCount(options?: any): Promise<
+		| {
+				recordCount: number;
+				estimatedRange?: undefined;
+		  }
+		| {
+				recordCount: number;
+				estimatedRange: number[];
+		  }
+	>;
+	/**
+	 * When attributes have been changed, we update the accessors that are assigned to this table
+	 */
+	updatedAttributes(): void;
+	setComputedAttribute(attribute_name: any, resolver: any): void;
+	/**
+	 * Override the default embedder for an `@embed` attribute. Return the vector to
+	 * store at `attribute_name`. The embedder receives the write payload (the fields
+	 * present in the PUT/PATCH body), not the post-merge record, so multi-field
+	 * concatenation only works when all source fields are in the same write.
+	 */
+	setEmbedAttribute(attribute_name: string, embedder: Embedder): void;
+	/**
+	 * Override the default decider for a `@decide` attribute. Return `{ value, probability }`
+	 * to store at the attribute and its confidence attribute, or `null` to clear both. The
+	 * value must be one the directive allows, and the probability is required when the
+	 * directive names a confidence attribute. Like an embedder, the decider receives the write
+	 * payload, not the post-merge record, and a `signal` that aborts when a sibling hook fails.
+	 */
+	setDecideAttribute(attribute_name: string, decider: Decider): void;
+	deleteHistory(endTime?: number, cleanupDeletedRecords?: boolean): Promise<number>;
+	getHistory(
+		startTime?: number,
+		endTime?: number
+	): AsyncGenerator<
+		{
+			id: any;
+			localTime: any;
+			version: any;
+			type: any;
+			value: any;
+			user: any;
+			operation: any;
+		},
+		void,
+		unknown
+	>;
+	getHistoryOfRecord(id: any): Promise<any[]>;
+	clear(): any;
+	/** Release everything makeTable() registered process-wide; the class must not be used afterwards. */
+	cleanup(): void;
+	closeMaintenance(deadline?: number): Promise<void>;
+	resumeMaintenance(): void;
+	_readTxnForContext(context: any): (LMDBReadTransaction | RocksTransaction) & {
+		openTimer?: number;
+		retryRisk?: number;
+		isDone?: boolean;
+		isCommitted?: boolean;
+	};
+	transactions: DatabaseTransactionRecord[] & {
+		timestamp: number;
+	};
+	path?: string;
+	directURLMapping: boolean;
+	loadAsInstance: boolean;
+	requestContract?: Contract;
+	inputSchemas?: {
+		[verb: string]: {
+			query?: JsonSchemaFragment;
+			body?: JsonSchemaFragment;
+		};
+	};
+	withSchema<Base extends new (...args: any[]) => any, const C extends Contract>(
+		this: Base,
+		contract: C
+	): SchemaClass<Base, C>;
+	get: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	put: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	patch: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	delete: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	create(idPrefix: Id, record: any, context: Context): Promise<Id>;
+	create(record: any, context: Context): Promise<Id>;
+	invalidate: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	post: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	update: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	connect: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	subscribe: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	publish: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	search: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	query: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	copy: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	move: {
+		(idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
+		reliesOnPrototype: boolean;
+	};
+	isCollection(resource: any): any;
+	parseQuery(search: any, query: any): any;
+	parsePath(path: any, context: any, query: any): any;
+}
+
 /**
  * This returns a Table class for the given table settings (determined from the metadata table)
  * Instances of the returned class are Resource instances, intended to provide a consistent view or transaction of the table
@@ -617,6 +1137,31 @@ function cloneConditions(conditions: any[]): any[] {
 		return copy;
 	});
 }
+
+function selectRequestsProperty(select: any, propertyName: string): boolean {
+	if (!select) return false;
+	const selected = Array.isArray(select) ? select : [select];
+	return selected.some((property) => (typeof property === 'string' ? property : property?.name) === propertyName);
+}
+
+function appendSelectProperty(select: any, propertyName: string): any[] {
+	if (!Array.isArray(select)) return [select, propertyName];
+	return Object.assign([...select, propertyName], select);
+}
+
+function conditionsContainFullText(entries: any[], definitions: readonly FullTextDefinition[]): boolean {
+	for (const entry of entries) {
+		if (entry.conditions) {
+			if (conditionsContainFullText(entry.conditions, definitions)) return true;
+		} else if (
+			fullTextComparatorMode(entry.comparator) &&
+			typeof (entry[0] ?? entry.attribute) === 'string' &&
+			definitions.some(({ name }) => name === (entry[0] ?? entry.attribute))
+		)
+			return true;
+	}
+	return false;
+}
 // Ambient, path-scoped cycle guard for the enumerable-struct `toJSON` serialization path. A record on
 // a cyclically-enumerable table can (transitively) reference itself, which would recurse forever through
 // JSON.stringify. The struct getters resolve related records by id — and without a shared cache each
@@ -737,7 +1282,7 @@ setLockCoordinatorResolver(
 	}
 );
 
-export function makeTable(options) {
+export function makeTable(options): TableResourceClass {
 	const {
 		primaryKey,
 		indices,
@@ -757,9 +1302,12 @@ export function makeTable(options) {
 		cacheControl,
 		isBranch,
 		fullTextIndexes = [],
+		fullTextFields = [],
 		fullTextIndexGenerations = Object.create(null),
 		fullTextIndexRetirements = [],
 	} = options;
+	let declaredFullTextFields: readonly string[] = Object.freeze([...fullTextFields]);
+	let fullTextFieldNames = fullTextFields.length > 0 ? new Set<string>(fullTextFields) : undefined;
 	const tableRootStore = primaryStore.rootStore;
 	const tableRootPath = tableRootStore.path;
 	let { expirationMS: expirationMs, evictionMS: evictionMs, audit, trackDeletes } = options;
@@ -1084,13 +1632,32 @@ export function makeTable(options) {
 					close(dropping?: boolean): Promise<void>;
 					fullTextDefinitions?(): readonly FullTextDefinition[];
 					matchesCurrent?(): boolean;
-					restoreAfterFailedDrop?(): typeof TableResource.derivedIndexRuntime;
+					restoreAfterFailedDrop?(): TableResourceClass['derivedIndexRuntime'];
 					retireAfterConfirmedDrop?(definitions?: readonly Pick<FullTextDefinition, 'name'>[]): Promise<boolean>;
 					completeDrop?(dropped?: boolean): void;
 			  }
 			| undefined;
 		static audit = audit;
 		static fullTextIndexes: FullTextDefinition[] = fullTextIndexes;
+		static get fullTextFields(): readonly string[] {
+			return declaredFullTextFields;
+		}
+		static set fullTextFields(names: readonly string[]) {
+			declaredFullTextFields = Object.freeze([...names]);
+			fullTextFieldNames = names.length > 0 ? new Set(names) : undefined;
+		}
+		static assertFullTextSelection(select: unknown, sort?: any): void {
+			assertFullTextSelection(select);
+			for (let order = sort; order; order = order.next) assertRecordField(order.attribute);
+		}
+		static assertFullTextRecordField(name: unknown): void {
+			assertFullTextRecordField(name);
+		}
+		static isFullTextSearchEntryCurrent(entry: Entry): boolean {
+			return !(entry.metadataFlags & (INVALIDATED | EVICTED | VERSION_REUSED));
+		}
+		static fullTextQueryIndexes: { [name: string]: { customIndex: unknown } } = Object.create(null);
+		static hasFullTextQueryIndexes = false;
 		static fullTextIndexGenerations: FullTextIndexGenerations = fullTextIndexGenerations;
 		static fullTextIndexRetirements: string[] = fullTextIndexRetirements;
 		static hasCurrentFullTextIndexRetirements(names: readonly string[]): boolean | Promise<boolean> {
@@ -1153,7 +1720,7 @@ export function makeTable(options) {
 		static userDeciders: { [name: string]: Decider } = {};
 		static userSetDeciders: Set<string> = new Set();
 		static decideAttributes: DecideAttribute[] = (attributes as any[]).filter((a) => a?.decide);
-		static source?: typeof TableResource;
+		static source?: any;
 		declare static sourceOptions: any;
 		declare static intermediateSource: boolean;
 		static getResidencyById: (id: Id) => number | void;
@@ -1174,7 +1741,7 @@ export function makeTable(options) {
 		 * @returns
 		 */
 		// #section: resource-registry
-		static sourcedFrom(source, options) {
+		static sourcedFrom(source: any, options: any): any {
 			// define a source for retrieving invalidated entries for caching purposes
 			if (options) {
 				this.sourceOptions = options;
@@ -1305,7 +1872,7 @@ export function makeTable(options) {
 					}
 					if (Table && event.type === 'put' && value == null && !shouldRevalidateEvents)
 						await reportDroppedWrite(event, context, new Error('Source-applied put has no record content'));
-					const resource: TableResource = await Table.getResource(id, context, options);
+					const resource = await Table.getResource(id, context, options);
 					if (event.finished) await event.finished;
 					// an aborted source transaction's released context would otherwise commit this write on its own
 					if (context.sourceAborted) return;
@@ -1671,13 +2238,14 @@ export function makeTable(options) {
 												hasChanges = true;
 											}
 										}
-										if (hasChanges || event.fullTextIndexes !== undefined) {
+										if (hasChanges || event.fullTextIndexes !== undefined || event.fullTextFields !== undefined) {
 											const schemaVersion = (this as any).schemaVersion;
 											const definedTable: any = table({
 												table: tableName,
 												database: databaseName,
 												attributes: updatedAttributes,
 												fullTextIndexes: event.fullTextIndexes,
+												fullTextFields: event.fullTextFields,
 												origin: 'cluster',
 											});
 											if (definedTable.schemaVersion !== schemaVersion)
@@ -1762,7 +2330,7 @@ export function makeTable(options) {
 			target: RequestTarget,
 			request: Context,
 			resourceOptions?: any
-		): Promise<TableResource<Record>> | TableResource<Record> {
+		): Promise<TableResourceInstance<Record>> | TableResourceInstance<Record> {
 			if (databaseDropPrepared(tableRootPath) || databaseCommitsSuspended(tableRootStore))
 				throw new DatabaseClosingError(
 					databaseName,
@@ -1774,7 +2342,11 @@ export function makeTable(options) {
 			}
 			return resource;
 		}
-		_loadRecord(target: RequestTarget, request: Context, resourceOptions?: any): MaybePromise<TableResource<Record>> {
+		_loadRecord(
+			target: RequestTarget,
+			request: Context,
+			resourceOptions?: any
+		): MaybePromise<TableResourceInstance<Record>> {
 			const id = target && typeof target === 'object' ? target.id : target;
 			if (id == null) return this;
 			checkValidId(id);
@@ -2530,6 +3102,12 @@ export function makeTable(options) {
 		 */
 		get(target?: any): any {
 			const constructor: any = this.constructor;
+			if (fullTextFieldNames || hasRelationships) assertFullTextSelection(target?.select);
+			if (fullTextFieldNames) {
+				assertRecordField(
+					target?.property ?? (typeof target === 'string' && constructor.loadAsInstance !== false ? target : undefined)
+				);
+			}
 			if (typeof target === 'string' && constructor.loadAsInstance !== false) return this.getProperty(target);
 			if (isSearchTarget(target)) {
 				// go back to the static search method so it gets a chance to override
@@ -2643,6 +3221,9 @@ export function makeTable(options) {
 		 */
 		allowRead(user: User, target: RequestTarget, context: Context): boolean {
 			const tablePermission = getTablePermissions(user, target);
+			// Resource.search consumes checkPermission before full-text source-field authorization runs.
+			if (TableResource.fullTextIndexes.length > 0 && target?.checkPermission && tablePermission)
+				(target as any)[FULL_TEXT_READ_PERMISSION] = tablePermission;
 			if (tablePermission?.read) {
 				if (tablePermission.isSuperUser) return true;
 				const attribute_permissions = tablePermission.attribute_permissions;
@@ -2658,7 +3239,13 @@ export function makeTable(options) {
 						(target as any).select = selectArray
 							.map((property: any) => {
 								const propertyName = property.name || property;
-								if (!attrsForType || attrsForType[propertyName]) {
+								if (
+									!attrsForType ||
+									attrsForType[propertyName] ||
+									fullTextFieldNames?.has(propertyName) ||
+									propertyName === '$score' ||
+									propertyName === '$highlights'
+								) {
 									const relatedTable = propertyResolvers[propertyName]?.definition?.tableClass;
 									if (relatedTable) {
 										// if there is a related table, we need to ensure the user has permission to read from that table and that attributes are properly restricted
@@ -2677,7 +3264,12 @@ export function makeTable(options) {
 							.filter(Boolean);
 					} else {
 						target.select = attribute_permissions
-							.filter((attribute) => attribute.read && !propertyResolvers[attribute.attribute_name])
+							.filter(
+								(attribute) =>
+									attribute.read &&
+									!fullTextFieldNames?.has(attribute.attribute_name) &&
+									!propertyResolvers[attribute.attribute_name]
+							)
 							.map((attribute) => attribute.attribute_name);
 					}
 					(target as any)[AUTHORIZATION_SELECT] = true;
@@ -2708,7 +3300,7 @@ export function makeTable(options) {
 					// that the user doesn't have permission to remove
 					for (const permission of attribute_permissions) {
 						const key = permission.attribute_name;
-						if (!permission.update && !(key in updatedData)) {
+						if (!permission.update && !fullTextFieldNames?.has(key) && !(key in updatedData)) {
 							updatedData[key] = this.getProperty(key);
 						}
 					}
@@ -3836,6 +4428,7 @@ export function makeTable(options) {
 				captureChanges,
 				validate: (txnTime, committedBy = transaction) => {
 					write.captureChanges?.();
+					if ((context as any)?.source && !committedBy.isReplay) assertFullTextWrite(recordUpdate, true);
 					if (fullUpdate || (recordUpdate && hasChanges(this.#changes === recordUpdate ? this : recordUpdate))) {
 						if (!(context as any)?.source) {
 							committedBy.checkOverloaded();
@@ -4804,6 +5397,7 @@ export function makeTable(options) {
 			const txn = txnForContext(context);
 			if (!target) throw new Error('No query provided');
 			if (target.parseError) throw target.parseError; // if there was a parse error, we can throw it now
+			if (fullTextFieldNames || hasRelationships) assertFullTextSelection(target.select);
 			const getColumns = () => {
 				const select = target.select;
 				if (select) {
@@ -4952,6 +5546,7 @@ export function makeTable(options) {
 			conditions = cloneConditions(conditions);
 			let orderAlignedCondition;
 			let syntheticOrderCondition;
+			let includeFullTextHighlights = false;
 			const filtered = {};
 
 			function prepareConditions(conditions: any[], operator: string) {
@@ -4983,6 +5578,54 @@ export function makeTable(options) {
 						}
 					}
 					const attribute_name = condition[0] ?? condition.attribute;
+					const fullTextMode =
+						TableResource.fullTextIndexes.length > 0 ||
+						Array.isArray(attribute_name) ||
+						(typeof attribute_name === 'string' && fullTextFieldNames?.has(attribute_name))
+							? fullTextComparatorMode(condition.comparator)
+							: undefined;
+					if (!fullTextMode && (fullTextFieldNames || hasRelationships)) assertFullTextRecordField(attribute_name);
+					const fullTextDefinition =
+						fullTextMode && typeof attribute_name === 'string'
+							? TableResource.fullTextIndexes.find((definition) => definition.name === attribute_name)
+							: undefined;
+					if (fullTextMode && Array.isArray(attribute_name))
+						throw new ClientError('Full-text predicates must directly name an index on the queried table', 400);
+					if (fullTextMode && !fullTextDefinition) throwUnknownFullTextIndex(context, target, attribute_name);
+					if (fullTextDefinition) {
+						const fields = condition.fields;
+						if (fields !== undefined) {
+							if (!Array.isArray(fields) || fields.length === 0 || fields.some((field) => typeof field !== 'string'))
+								throw new ClientError(`Full-text index '${attribute_name}' requires a non-empty fields list`, 400);
+							assertFullTextReadAccess(context, target, fullTextDefinition, fields);
+						} else assertFullTextReadAccess(context, target, fullTextDefinition);
+						const value = condition[1] ?? condition.value;
+						if (typeof value !== 'string' || value.length === 0)
+							throw new ClientError(
+								`Full-text index '${attribute_name}' requires a full-text comparator and non-empty string value`,
+								400
+							);
+						if (fullTextMode === 'phrase' && !fullTextDefinition.positions)
+							throw new ClientError(`Full-text index '${attribute_name}' does not store phrase positions`, 400);
+						if ((fullTextMode === 'prefix' || fullTextMode === 'fuzzy-prefix') && !fullTextDefinition.surfaceTerms)
+							throw new ClientError(`Full-text index '${attribute_name}' does not store surface terms`, 400);
+						if (fields !== undefined) {
+							const sourceNames = new Set(fullTextDefinition.fields.map(({ name }) => name));
+							if (new Set(fields).size !== fields.length || fields.some((field) => !sourceNames.has(field)))
+								throw new ClientError(
+									`Full-text index '${attribute_name}' contains an unknown or duplicate field`,
+									400
+								);
+						}
+						condition.includeHighlights =
+							condition.includeHighlights === true || selectRequestsProperty(target.select, '$highlights');
+						if (condition.includeHighlights && !fullTextDefinition.highlighting)
+							throw new ClientError(`Full-text index '${attribute_name}' does not enable highlighting`, 400);
+						if (!TableResource.fullTextQueryIndexes[attribute_name]?.customIndex)
+							throw new IndexRebuildingError(`Full-text index '${attribute_name}' is not ready`);
+						includeFullTextHighlights ||= condition.includeHighlights;
+						continue;
+					}
 					let attribute = attribute_name == null ? primaryKeyAttribute : findAttribute(attributes, attribute_name);
 					if (!attribute && Array.isArray(attribute_name) && attribute_name.length > 1) {
 						// Plain JSON nested path: the leaf may not be declared in the
@@ -5058,8 +5701,19 @@ export function makeTable(options) {
 			}
 			const operator = target.operator;
 			if (conditions.length > 0 || operator) conditions = prepareConditions(conditions, operator);
-			const sort = typeof target.sort === 'object' && target.sort;
+			let sort = typeof target.sort === 'object' && target.sort;
+			if (
+				TableResource.fullTextIndexes.length > 0 &&
+				conditionsContainFullText(conditions, TableResource.fullTextIndexes)
+			) {
+				if ((target as any).reverse)
+					throw new ClientError('Full-text results can only use descending $score order', 400);
+				if (sort && (sort.attribute !== '$score' || sort.next || sort.descending !== true))
+					throw new ClientError('Full-text results can only use descending $score order', 400);
+				sort = undefined;
+			}
 			for (let order = sort; order; order = order.next) {
+				if (fullTextFieldNames) assertRecordField(order.attribute);
 				if (typeof order.attribute !== 'string') continue;
 				const customIndex = indices[order.attribute]?.customIndex;
 				if (customIndex?.exactDistance) customIndex.exactDistance(order, null);
@@ -5133,7 +5787,13 @@ export function makeTable(options) {
 					postOrdering = sort;
 				}
 			}
-			const select = target.select;
+			const select = includeFullTextHighlights
+				? target.select === undefined
+					? ['*', '$highlights']
+					: selectRequestsProperty(target.select, '$highlights')
+						? target.select
+						: appendSelectProperty(target.select, '$highlights')
+				: target.select;
 			// Whether the caller supplied real filter conditions — read from the raw request, NOT the
 			// planner-augmented `conditions` (which by now may carry a synthetic `sort` pseudo-condition and
 			// injected full-scan condition). Used to pick the count-estimate source below.
@@ -5263,7 +5923,10 @@ export function makeTable(options) {
 							if (!c) return false;
 							if (c.conditions) return touchesCustomIndex(c.conditions);
 							const attr = Array.isArray(c.attribute) ? c.attribute[0] : (c.attribute ?? c[0]);
-							return typeof attr === 'string' && Boolean(indices[attr]?.customIndex);
+							if (typeof attr !== 'string') return false;
+							return fullTextComparatorMode(c.comparator)
+								? Boolean(TableResource.fullTextQueryIndexes?.[attr]?.customIndex)
+								: Boolean(indices[attr]?.customIndex);
 						});
 					const approximateResultSet = typeof target.vectorFilter === 'function' || touchesCustomIndex(conditions);
 					return (async () => {
@@ -6512,6 +7175,7 @@ export function makeTable(options) {
 		}
 		// #section: validation
 		validate(record: any, patch?: boolean) {
+			if (fullTextFieldNames) assertFullTextWrite(record);
 			// Accumulate structured per-field issues so the 400 carries `{ path, code,
 			// message }[]` matching the emitted OpenAPI, instead of a single joined string. The joined
 			// message is still built for the HTTP title, preserving back-compat for callers that read it.
@@ -6955,6 +7619,8 @@ export function makeTable(options) {
 				$updatedTime: (object, context, entry) => entry.version,
 				$expiresAt: (object, context, entry) => entry.expiresAt,
 				$record: (object, context, entry) => (entry ? { value: object } : object),
+				$score: (object, context, entry) => entry?.$score,
+				$highlights: (object, context, entry) => entry?.$highlights,
 				$distance: (object, context, entry, returnEntry, sort) => {
 					if (!entry) return;
 					if (entry.distance !== undefined) return entry.distance;
@@ -6975,6 +7641,7 @@ export function makeTable(options) {
 					return customIndex.propertyResolver(vector, context, entry, distanceSort);
 				},
 			};
+			propertyResolvers.$highlights.directReturn = true;
 			for (const attribute of this.attributes) {
 				if (attribute.isPrimaryKey) primaryKeyAttribute = attribute;
 				attribute.resolve = null; // reset this
@@ -7515,6 +8182,13 @@ export function makeTable(options) {
 			return txnForContext(context).getReadTxn();
 		}
 	}
+	type _TableResourceMatchesItsDeclaredTypes = [
+		AssertNoDrift<MemberDrift<TableResource<ParitySentinel>, TableResourceInstance<ParitySentinel>>>,
+		AssertNoDrift<MemberDrift<Omit<typeof TableResource, 'prototype'>, Omit<TableResourceClass, 'prototype'>>>,
+		AssertTrue<ExactlyEqual<ConstructorParameters<typeof TableResource>, ConstructorParameters<TableResourceClass>>>,
+		AssertTrue<ExactlyEqual<InstanceType<TableResourceClass>, TableResourceInstance<object>>>,
+		AssertTrue<ExactlyEqual<TableResourceClass['prototype'], TableResourceInstance>>,
+	];
 	const throttledCallToSource = throttle(
 		async (source, id, sourceContext, existingEntry) => {
 			// call the data source if it exists and will fulfill our request for data
@@ -7809,13 +8483,86 @@ export function makeTable(options) {
 			return table;
 		}
 	}
+	function assertRecordField(name: unknown): void {
+		const field = Array.isArray(name) ? name[0] : name;
+		if (typeof field === 'string' && fullTextFieldNames?.has(field))
+			throw new ClientError(
+				`Full-text field "${field}" is query-only; use a full-text comparator and select $score or $highlights`,
+				400
+			);
+	}
+
+	function assertFullTextRecordField(name: unknown): void {
+		if (!Array.isArray(name)) return assertRecordField(name);
+		const [first, ...remaining] = name;
+		assertRecordField(first);
+		if (remaining.length === 0) return;
+		propertyResolvers[first]?.definition?.tableClass?.assertFullTextRecordField?.(
+			remaining.length === 1 ? remaining[0] : remaining
+		);
+	}
+
+	function assertFullTextSelection(select: unknown): void {
+		if (!fullTextFieldNames && !hasRelationships) return;
+		if (typeof select === 'string') assertRecordField(select);
+		else if (Array.isArray(select)) {
+			for (const property of select) {
+				const name = typeof property === 'object' ? property?.name : property;
+				assertRecordField(name);
+				if (property && typeof property === 'object')
+					propertyResolvers[name]?.definition?.tableClass?.assertFullTextSelection?.(
+						property.select || (Array.isArray(property) ? property : undefined),
+						property.sort
+					);
+			}
+		}
+	}
+
+	function assertFullTextWrite(record: any, sourceFill = false): void {
+		if (!fullTextFieldNames || !record || typeof record !== 'object') return;
+		for (const name in record) {
+			if (fullTextFieldNames.has(name)) {
+				if (sourceFill)
+					throw new ServerError(`Source for ${tableName} returned query-only full-text field "${name}"`, 502);
+				throw new ClientError(`Full-text field "${name}" is query-only and cannot be written`, 400);
+			}
+		}
+	}
+
+	function assertFullTextReadAccess(
+		context: Context | undefined,
+		target: RequestTarget,
+		definition: FullTextDefinition,
+		requestedFields?: string[]
+	) {
+		const user = (context as any)?.user;
+		const permission = (target as any)[FULL_TEXT_READ_PERMISSION] ?? getTablePermissions(user, target);
+		// Calls without a principal or explicit permission are trusted internal calls, matching allowRead.
+		if (!permission && !user) return;
+		if (permission?.isSuperUser || !permission?.attribute_permissions?.length) return;
+		const readable = attributesAsObject(permission.attribute_permissions, 'read');
+		const searched = requestedFields ?? definition.fields.map(({ name }) => name);
+		if (searched.some((name) => !readable[name])) throw new AccessViolation(user);
+	}
+	function throwUnknownFullTextIndex(
+		context: Context | undefined,
+		target: RequestTarget,
+		attributeName?: unknown
+	): never {
+		const user = (context as any)?.user;
+		const permission = (target as any)[FULL_TEXT_READ_PERMISSION] ?? getTablePermissions(user, target);
+		if (permission?.attribute_permissions?.length) throw new AccessViolation(user);
+		if (typeof attributeName === 'string' && fullTextFieldNames?.has(attributeName))
+			throw new IndexRebuildingError(`Full-text index '${attributeName}' is unavailable`);
+		throw new ClientError('Full-text comparator requires a declared @fullText index', 400);
+	}
 
 	function setLoadedFromSource(target: RequestTarget | undefined, loadedFromSource: boolean) {
 		// cache disposition is a per-get result, recorded on the RequestTarget of the get (#1576)
 		// target may be a primitive id on instance-API calls, which can't hold the flag
 		if (target && typeof target === 'object') target.loadedFromSource = loadedFromSource;
 	}
-	function ensureLoadedFromSource(source: typeof TableResource, id, entry, context, resource?, target?) {
+	function ensureLoadedFromSource(source: TableResourceClass, id, entry, context, resource?, target?) {
 		if (context?.onlyIfCached) {
 			if (!entry?.value) throw new ServerError('Entry is not cached', 504);
 			return;
@@ -8091,7 +8838,7 @@ export function makeTable(options) {
 	 * This is used to record that a retrieve a record from source
 	 */
 	async function getFromSource(
-		source: typeof TableResource,
+		source: TableResourceClass,
 		id: Id,
 		existingEntry: Entry,
 		context: Context,
@@ -8170,6 +8917,7 @@ export function makeTable(options) {
 			const commitPromise = transaction(sourceContext, async (_txn) => {
 				const start = performance.now();
 				let updatedRecord, assignCreatedTime, sourceVersion;
+				let reusedCachedRecord = false;
 				let hasChanges, invalidated;
 				try {
 					updatedRecord = await throttledCallToSource(source, id, sourceContext, existingEntry);
@@ -8213,6 +8961,7 @@ export function makeTable(options) {
 							if (status === 304) {
 								// revalidation of our current cached record
 								updatedRecord = existingRecord;
+								reusedCachedRecord = true;
 								sourceVersion = existingVersion;
 							} else if (!CACHEABLE_STATUS_CODES.has(status)) {
 								// non-cacheable status - propagate to client without caching
@@ -8281,6 +9030,7 @@ export function makeTable(options) {
 							}
 						}
 						updatedRecord = storedFieldsOnly(primaryStore.encoder, updatedRecord);
+						if (!reusedCachedRecord) assertFullTextWrite(updatedRecord, true);
 						if (primaryKey && updatedRecord[primaryKey] !== id) updatedRecord[primaryKey] = id;
 					}
 					assignCreatedTime = createdTimeProperty && updatedRecord?.[createdTimeProperty.name] == null;