@harperfast/harper 5.3.0-beta.4 → 5.3.0

package/dist/resources/Table.d.ts

@@ -3,16 +3,19 @@
  * tables through the interface defined by the Resource class. This module is responsible for handling these
  * table-level interactions, loading records, updating records, querying, and more.
  */
-import { type Database } from 'lmdb';
-import type { ResourceInterface, SubscriptionRequest, Id, Context, Sort, SubSelect, RequestTargetOrId } from './ResourceInterface.ts';
+import { type Database, type Transaction as LMDBReadTransaction } from 'lmdb';
+import type { ResourceInterface, SubscriptionRequest, Id, Context, Sort, SubSelect, RequestTargetOrId, Query, SourceContext } from './ResourceInterface.ts';
 import type { User } from '../security/user.ts';
-import { type WriteGeneration } from './DatabaseTransaction.ts';
-import { type RecordLockHandle, type RecordLockOptions } from './recordLock.ts';
+import type { IterableEventQueue } from './IterableEventQueue.ts';
+import type { Contract, SchemaClass } from './defineResource.ts';
+import { type WriteGeneration, type Transaction as DatabaseTransactionRecord } from './DatabaseTransaction.ts';
+import { type RecordLockOptions } from './recordLock.ts';
 import { ASSERT_TRACKED_WRITABLE, GET_TRACKED_WRITE_GENERATION } from './tracked.ts';
 import { LockCoordinator, type LockControlEntry } from './recordLockCoordinator.ts';
 import { type EmbedAttribute, type Embedder } from './models/embedHook.ts';
 import { type DecideAttribute, type DecideConfig, type Decider } from './models/decideHook.ts';
 import { RecordObject, type Entry, type StructureCounts } from './RecordEncoder.ts';
+import { type StorageSpaceStats } from '../server/storageReclamation.ts';
 import { RequestTarget } from './RequestTarget.ts';
 import { RocksDatabase, Transaction as RocksTransaction } from '@harperfast/rocksdb-js';
 import { type JsonSchemaFragment } from './jsonSchemaTypes.ts';
@@ -81,135 +84,112 @@ export interface Table {
     hidden?: boolean;
 }
 type ResidencyDefinition = number | string[] | void;
-export declare function makeTable(options: any): {
-    new <Record extends object = any>(identifier: Id, source: any): {
-        "__#private@#record": any;
-        "__#private@#changes": any;
-        "__#private@#version"?: number;
-        "__#private@#entry"?: Entry;
-        "__#private@#savingOperation"?: any;
-        "__#private@#lockHandle"?: RecordLockHandle;
-        "__#private@#lockWritable"?: boolean;
-        "__#private@#writeGeneration"?: WriteGeneration;
-        getProperty: (name: string) => any;
-        /**
-         * Shared guard: if this instance is lock-writable but the handle is gone (expired or
-         * released), throw 409 before staging any write. Covers update/invalidate/relocate/delete
-         * in addition to the save() path. Every lock-writable instance carries its own handle in
-         * #lockHandle (scoped and hold alike), so we never need to search the registry here.
-         */
-        "__#private@#assertLiveHandle"(id: Id, allowClosed?: boolean): void;
-        _loadRecord(target: RequestTarget, request: Context, resourceOptions?: any): MaybePromise</*elided*/ any>;
-        /**
-         * 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.
-         * @returns
-         */
-        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;
-        "__#private@#saveOperation"(operation: any): any;
-        "__#private@#closeWriteChain"(operation: any): void;
-        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>;
-        "__#private@#reloadLocked"(id: Id, holdHandle?: RecordLockHandle | null, preserveChanges?: boolean): 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.
-         * @param id
-         * @param message
-         * @param options
-         */
-        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;
-        readonly "__#private@#id": Id;
-        readonly "__#private@#context": Context | import("./ResourceInterface.ts").SourceContext;
-        "__#private@#isCollection": boolean;
-        post(target: RequestTargetOrId, newRecord: Partial<Record & RecordObject>): Promise<Record & Partial<RecordObject>>;
-        get isCollection(): boolean;
-        connect(target: RequestTarget, incomingMessages: import("./IterableEventQueue.ts").IterableEventQueue<Record>): AsyncIterable<Record> | Promise<AsyncIterable<Record>>;
-        getId(): Id;
-        getContext(): Context | import("./ResourceInterface.ts").SourceContext;
-        getCurrentUser(): User | undefined;
-    };
+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;
@@ -222,19 +202,23 @@ export declare function makeTable(options: any): {
         close(dropping?: boolean): Promise<void>;
         fullTextDefinitions?(): readonly FullTextDefinition[];
         matchesCurrent?(): boolean;
-        restoreAfterFailedDrop?(): {
-            close(dropping?: boolean): Promise<void>;
-            fullTextDefinitions?(): readonly FullTextDefinition[];
-            matchesCurrent?(): boolean;
-            restoreAfterFailedDrop?(): /*elided*/ any;
-            retireAfterConfirmedDrop?(definitions?: readonly Pick<FullTextDefinition, "name">[]): Promise<boolean>;
-            completeDrop?(dropped?: boolean): void;
-        };
-        retireAfterConfirmedDrop?(definitions?: readonly Pick<FullTextDefinition, "name">[]): Promise<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>;
@@ -272,7 +256,7 @@ export declare function makeTable(options: any): {
     };
     userSetDeciders: Set<string>;
     decideAttributes: DecideAttribute[];
-    source?: /*elided*/ any;
+    source?: any;
     sourceOptions: any;
     intermediateSource: boolean;
     getResidencyById: (id: Id) => number | void;
@@ -284,11 +268,8 @@ export declare function makeTable(options: 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.
-     * @param source
-     * @param options
-     * @returns
      */
-    sourcedFrom(source: any, options: any): /*elided*/ any;
+    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 */
@@ -296,266 +277,9 @@ export declare function makeTable(options: any): {
     /**
      * 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 target
-     * @param request
      * @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).
-     * @returns
-     */
-    getResource<Record extends object = any>(target: RequestTarget, request: Context, resourceOptions?: any): Promise<{
-        "__#private@#record": any;
-        "__#private@#changes": any;
-        "__#private@#version"?: number;
-        "__#private@#entry"?: Entry;
-        "__#private@#savingOperation"?: any;
-        "__#private@#lockHandle"?: RecordLockHandle;
-        "__#private@#lockWritable"?: boolean;
-        "__#private@#writeGeneration"?: WriteGeneration;
-        getProperty: (name: string) => any;
-        /**
-         * Shared guard: if this instance is lock-writable but the handle is gone (expired or
-         * released), throw 409 before staging any write. Covers update/invalidate/relocate/delete
-         * in addition to the save() path. Every lock-writable instance carries its own handle in
-         * #lockHandle (scoped and hold alike), so we never need to search the registry here.
-         */
-        "__#private@#assertLiveHandle"(id: Id, allowClosed?: boolean): void;
-        _loadRecord(target: RequestTarget, request: Context, resourceOptions?: any): MaybePromise</*elided*/ any>;
-        /**
-         * 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.
-         * @returns
-         */
-        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;
-        "__#private@#saveOperation"(operation: any): any;
-        "__#private@#closeWriteChain"(operation: any): void;
-        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>;
-        "__#private@#reloadLocked"(id: Id, holdHandle?: RecordLockHandle | null, preserveChanges?: boolean): 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.
-         * @param id
-         * @param message
-         * @param options
-         */
-        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;
-        readonly "__#private@#id": Id;
-        readonly "__#private@#context": Context | import("./ResourceInterface.ts").SourceContext;
-        "__#private@#isCollection": boolean;
-        post(target: RequestTargetOrId, newRecord: Partial<Record & RecordObject>): Promise<Record & Partial<RecordObject>>;
-        get isCollection(): boolean;
-        connect(target: RequestTarget, incomingMessages: import("./IterableEventQueue.ts").IterableEventQueue<Record>): AsyncIterable<Record> | Promise<AsyncIterable<Record>>;
-        getId(): Id;
-        getContext(): Context | import("./ResourceInterface.ts").SourceContext;
-        getCurrentUser(): User | undefined;
-    }> | {
-        "__#private@#record": any;
-        "__#private@#changes": any;
-        "__#private@#version"?: number;
-        "__#private@#entry"?: Entry;
-        "__#private@#savingOperation"?: any;
-        "__#private@#lockHandle"?: RecordLockHandle;
-        "__#private@#lockWritable"?: boolean;
-        "__#private@#writeGeneration"?: WriteGeneration;
-        getProperty: (name: string) => any;
-        /**
-         * Shared guard: if this instance is lock-writable but the handle is gone (expired or
-         * released), throw 409 before staging any write. Covers update/invalidate/relocate/delete
-         * in addition to the save() path. Every lock-writable instance carries its own handle in
-         * #lockHandle (scoped and hold alike), so we never need to search the registry here.
-         */
-        "__#private@#assertLiveHandle"(id: Id, allowClosed?: boolean): void;
-        _loadRecord(target: RequestTarget, request: Context, resourceOptions?: any): MaybePromise</*elided*/ any>;
-        /**
-         * 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.
-         * @returns
-         */
-        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;
-        "__#private@#saveOperation"(operation: any): any;
-        "__#private@#closeWriteChain"(operation: any): void;
-        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>;
-        "__#private@#reloadLocked"(id: Id, holdHandle?: RecordLockHandle | null, preserveChanges?: boolean): 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.
-         * @param id
-         * @param message
-         * @param options
-         */
-        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;
-        readonly "__#private@#id": Id;
-        readonly "__#private@#context": Context | import("./ResourceInterface.ts").SourceContext;
-        "__#private@#isCollection": boolean;
-        post(target: RequestTargetOrId, newRecord: Partial<Record & RecordObject>): Promise<Record & Partial<RecordObject>>;
-        get isCollection(): boolean;
-        connect(target: RequestTarget, incomingMessages: import("./IterableEventQueue.ts").IterableEventQueue<Record>): AsyncIterable<Record> | Promise<AsyncIterable<Record>>;
-        getId(): Id;
-        getContext(): Context | import("./ResourceInterface.ts").SourceContext;
-        getCurrentUser(): User | undefined;
-    };
+     */
+    getResource<Record extends object = any>(target: RequestTarget, request: Context, resourceOptions?: any): Promise<TableResourceInstance<Record>> | TableResourceInstance<Record>;
     _updateResource(resource: any, entry: any): void;
     getNewId(): any;
     /**
@@ -583,8 +307,6 @@ export declare function makeTable(options: any): {
     enableAuditing(): void;
     /**
      * Coerce the id as a string to the correct type for the primary key
-     * @param id
-     * @returns
      */
     coerceId(id: string): number | string;
     /**
@@ -598,8 +320,6 @@ export declare function makeTable(options: any): {
     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
-     * @param existingEntry
-     * @param entry
      */
     _recordRelocate(existingEntry: any, entry: any): boolean;
     /**
@@ -620,34 +340,20 @@ export declare function makeTable(options: any): {
     operation(operation: any, context: any): any;
     /**
      * This is responsible for ordering and select()ing the attributes/properties from returned entries
-     * @param select
-     * @param context
-     * @param filtered
-     * @param ensure_loaded
-     * @param canSkip
-     * @returns
      */
     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 select
-     * @param context
-     * @param filtered
-     * @param ensure_loaded
-     * @param canSkip
      * @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
-     * @returns
      */
     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
-     * @param workerIndex
-     * @param options
      */
     subscribeOnThisThread(workerIndex: any, options: any): boolean;
     /**
@@ -689,7 +395,6 @@ export declare function makeTable(options: any): {
     removeAttributes(names: string[]): Promise<any>;
     /**
      * Get the size of the table in bytes (based on amount of pages stored in the database)
-     * @param options
      */
     getSize(): number;
     /** Sizes of this table's durable record-structure dictionaries. */
@@ -700,7 +405,7 @@ export declare function makeTable(options: any): {
      * this may need to read quota-status.json (#1976); getSize/getAuditSize stay sync because
      * they only read in-memory store stats.
      */
-    getStorageStats(): Promise<import("../server/storageReclamation.ts").StorageSpaceStats>;
+    getStorageStats(): Promise<StorageSpaceStats>;
     getRecordCount(options?: any): Promise<{
         recordCount: number;
         estimatedRange?: undefined;
@@ -744,88 +449,89 @@ export declare function makeTable(options: any): {
     cleanup(): void;
     closeMaintenance(deadline?: number): Promise<void>;
     resumeMaintenance(): void;
-    _readTxnForContext(context: any): (import("lmdb").Transaction | RocksTransaction) & {
+    _readTxnForContext(context: any): (LMDBReadTransaction | RocksTransaction) & {
         openTimer?: number;
         retryRisk?: number;
         isDone?: boolean;
         isCommitted?: boolean;
     };
-    transactions: import("./DatabaseTransaction.ts").Transaction[] & {
+    transactions: DatabaseTransactionRecord[] & {
         timestamp: number;
     };
     path?: string;
     directURLMapping: boolean;
     loadAsInstance: boolean;
-    requestContract?: import("./defineResource.ts").Contract;
+    requestContract?: Contract;
     inputSchemas?: {
         [verb: string]: {
             query?: JsonSchemaFragment;
             body?: JsonSchemaFragment;
         };
     };
-    withSchema<Base extends new (...args: any[]) => any, const C extends import("./defineResource.ts").Contract>(this: Base, contract: C): import("./defineResource.ts").SchemaClass<Base, C>;
+    withSchema<Base extends new (...args: any[]) => any, const C extends Contract>(this: Base, contract: C): SchemaClass<Base, C>;
     get: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     put: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     patch: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     delete: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (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 | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     post: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     update: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     connect: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     subscribe: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     publish: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     search: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     query: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     copy: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (idOrQuery: string | Id | Query, dataOrContext?: any, context?: Context): any;
         reliesOnPrototype: boolean;
     };
     move: {
-        (idOrQuery: string | Id | import("./ResourceInterface.ts").Query, dataOrContext?: any, context?: Context): any;
+        (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;
-};
+}
+export declare function makeTable(options: any): TableResourceClass;
 /**
  * Coerce a string to the type defined by the attribute
  * @param value