@harperfast/harper 5.0.30 → 5.1.0-beta.2

package/resources/Resource.ts

@@ -1,5 +1,5 @@
 import type { User } from '../security/user.ts';
-import type { RecordObject } from './RecordEncoder.js';
+import type { RecordObject } from './RecordEncoder.ts';
 import {
 	ResourceInterface,
 	SubscriptionRequest,
@@ -13,11 +13,12 @@ import { randomUUID } from 'crypto';
 import { DatabaseTransaction, type Transaction } from './DatabaseTransaction.ts';
 import { IterableEventQueue } from './IterableEventQueue.ts';
 import { _assignPackageExport } from '../globals.js';
-import { ClientError, AccessViolation } from '../utility/errors/hdbError.js';
+import { ClientError, AccessViolation } from '../utility/errors/hdbError.ts';
 import { transaction, contextStorage } from './transaction.ts';
 import { parseQuery } from './search.ts';
 import { RequestTarget } from './RequestTarget.ts';
 import { when, promiseNormalize } from '../utility/when.ts';
+import type { JsonSchemaFragment } from './jsonSchemaTypes.ts';
 
 const EXTENSION_TYPES = {
 	json: 'application/json',
@@ -45,17 +46,38 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	static transactions: Transaction[] & { timestamp: number };
 	static directURLMapping = false;
 	static loadAsInstance: boolean;
+	static description?: string;
+	static properties?: { [name: string]: JsonSchemaFragment };
+	static outputSchemas?: { [verb: string]: JsonSchemaFragment };
+	static mcp?: { annotations?: { [verb: string]: { [key: string]: unknown } } };
+	static hidden?: boolean;
 	constructor(identifier: Id, source: any) {
 		this.#id = identifier;
 		const context = source?.getContext ? (source.getContext() ?? null) : undefined;
 		this.#context = context !== undefined ? context : source || null;
 	}
 
+	doesExist(): boolean {
+		return true; // Subclasses should override if needed
+	}
+
+	wasLoadedFromSource(): boolean | void {
+		// Subclasses should override if needed
+	}
+
+	addTo(_property: keyof Record, _value: Record[keyof Record]): void {
+		throw new Error('Not implemented');
+	}
+
+	subtractFrom(_property: keyof Record, _value: Record[keyof Record]): void {
+		throw new Error('Not implemented');
+	}
+
 	/**
 	 * The get methods are for directly getting a resource, and called for HTTP GET requests.
 	 */
 	static get = transactional(
-		function (resource: Resource, query: RequestTarget, _request: Context, _data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, _data: any) {
 			const result = resource.get?.(query);
 			// for the new API we always apply select in the instance method
 			if (!resource.constructor.loadAsInstance) return result;
@@ -89,7 +111,7 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	 * Store the provided record by the provided id. If no id is provided, it is auto-generated.
 	 */
 	static put = transactional(
-		function (resource: Resource, query: RequestTarget, request: Context, data: any) {
+		function (resource: any, query: RequestTarget, request: Context, data: any) {
 			if (Array.isArray(data) && resource.#isCollection && resource.constructor.loadAsInstance !== false) {
 				const results = [];
 				for (const element of data) {
@@ -115,7 +137,7 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	);
 
 	static patch = transactional(
-		function (resource: Resource, query: RequestTarget, _request: Context, data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, data: any) {
 			// TODO: Allow array like put?
 			return resource.patch
 				? resource.constructor.loadAsInstance === false
@@ -127,7 +149,7 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	);
 
 	static delete = transactional(
-		function (resource: Resource, query: RequestTarget, _request: Context, _data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, _data: any) {
 			return resource.delete ? resource.delete(query) : missingMethod(resource, 'delete');
 		},
 		{ hasContent: false, type: 'delete', method: 'delete' }
@@ -150,7 +172,7 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	static create(idPrefix: Id, record: any, context: Context): Promise<Id>;
 	static create(record: any, context: Context): Promise<Id>;
 	static create(idPrefix: any, record: any, context?: Context): Promise<Id> {
-		let id: Id;
+		let id: any;
 		if (this.loadAsInstance === false) {
 			if (typeof idPrefix === 'object' && idPrefix && !context) {
 				// two argument form (record, context), shift the arguments
@@ -160,44 +182,45 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 				id.isCollection = true;
 			} else id = idPrefix;
 		} else {
-			if (idPrefix == null) id = record?.[this.primaryKey] ?? this.getNewId();
+			const primaryKey = (this as any).primaryKey;
+			if (idPrefix == null) id = record?.[primaryKey] ?? this.getNewId();
 			else if (Array.isArray(idPrefix) && typeof idPrefix[0] !== 'object')
-				id = record?.[this.primaryKey] ?? [...idPrefix, this.getNewId()];
-			else if (typeof idPrefix !== 'object') id = record?.[this.primaryKey] ?? [idPrefix, this.getNewId()];
+				id = record?.[primaryKey] ?? [...idPrefix, this.getNewId()];
+			else if (typeof idPrefix !== 'object') id = record?.[primaryKey] ?? [idPrefix, this.getNewId()];
 			else {
 				// two argument form, shift the arguments
-				id = idPrefix?.[this.primaryKey] ?? this.getNewId();
+				id = idPrefix?.[primaryKey] ?? this.getNewId();
 				context = record || {};
 				record = idPrefix;
 			}
 		}
 		if (context) {
-			if (context.getContext) context = context.getContext();
+			if ((context as any).getContext) context = (context as any).getContext();
 		} else {
 			// try to get the context from the async context if possible
 			context = contextStorage.getStore() ?? {};
 		}
 		return transaction(context, async () => {
-			context.transaction.startedFrom ??= {
+			(context as any).transaction.startedFrom ??= {
 				resourceName: this.name,
 				method: 'create',
 			};
-			const resource = new this(id, context);
+			const resource = new (this as any)(id, context);
 			const results = resource.create ? await resource.create(id, record) : missingMethod(resource, 'create');
-			context.newLocation = id ?? results?.[this.primaryKey];
-			context.createdResource = true;
+			(context as any).newLocation = id ?? results?.[(this as any).primaryKey];
+			(context as any).createdResource = true;
 			return this.loadAsInstance === false ? results : resource;
 		});
 	}
 	static invalidate = transactional(
-		function (resource: Resource, query: RequestTarget, _request: Context, _data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, _data: any) {
 			return resource.invalidate ? resource.invalidate(query) : missingMethod(resource, 'invalidate');
 		},
 		{ hasContent: false, type: 'update', method: 'invalidate' }
 	);
 
 	static post = transactional(
-		function (resource: Resource, query: RequestTarget, _request: Context, data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, data: any) {
 			if (resource.#id != null) resource.update?.(); // save any changes made during post
 			return resource.constructor.loadAsInstance === false ? resource.post(query, data) : resource.post(data, query);
 		},
@@ -205,14 +228,14 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	);
 
 	static update = transactional(
-		function (resource: Resource, query: RequestTarget, _request: Context, data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, data: any) {
 			return resource.update(query, data);
 		},
 		{ type: 'update', method: 'update' }
 	);
 
 	static connect = transactional(
-		function (resource: Resource, query: RequestTarget, _request: Context, data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, data: any) {
 			return resource.connect
 				? resource.constructor.loadAsInstance === false
 					? resource.connect(query, data)
@@ -223,14 +246,14 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	);
 
 	static subscribe = transactional(
-		function (resource: Resource, query: RequestTarget, _request: Context, _data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, _data: any) {
 			return resource.subscribe ? resource.subscribe(query) : missingMethod(resource, 'subscribe');
 		},
 		{ type: 'read', method: 'subscribe', syncAllowed: true }
 	);
 
 	static publish = transactional(
-		function (resource: Resource, query: Map, _request: Context, data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, data: any) {
 			if (resource.#id != null) resource.update?.(); // save any changes made during publish
 			return resource.publish
 				? resource.constructor.loadAsInstance === false
@@ -242,9 +265,9 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	);
 
 	static search = transactional(
-		function (resource: Resource, query: Query, request: Context) {
+		function (resource: any, query: Query, request: Context) {
 			const result = resource.search ? resource.search(query) : missingMethod(resource, 'search');
-			const select = request.select;
+			const select = (request as any).select;
 			if (select && request.hasOwnProperty('select') && result != null && !result.selectApplied) {
 				const transform = transformForSelect(select, resource.constructor);
 				return result.map(transform);
@@ -255,7 +278,7 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	);
 
 	static query = transactional(
-		function (resource: Resource, query: Map, _request: Context, data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, data: any) {
 			return resource.search
 				? resource.constructor.loadAsInstance === false
 					? resource.search(query, data)
@@ -266,7 +289,7 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	);
 
 	static copy = transactional(
-		function (resource: Resource, query: Map, _request: Context, data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, data: any) {
 			return resource.copy
 				? resource.constructor.loadAsInstance === false
 					? resource.copy(query, data)
@@ -277,7 +300,7 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	);
 
 	static move = transactional(
-		function (resource: Resource, query: Map, _request: Context, data: any) {
+		function (resource: any, query: RequestTarget, _request: Context, data: any) {
 			return resource.move
 				? resource.constructor.loadAsInstance === false
 					? resource.move(query, data)
@@ -291,14 +314,14 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 		target: RequestTargetOrId,
 		newRecord: Partial<Record & RecordObject>
 	): Promise<Record & Partial<RecordObject>> {
-		if (this.constructor.loadAsInstance === false) {
-			if (target.isCollection && this.create) {
-				newRecord = await this.create(target, newRecord);
-				return newRecord?.[this.constructor.primaryKey];
+		if ((this.constructor as any).loadAsInstance === false) {
+			if ((target as any).isCollection && this.create) {
+				newRecord = (await this.create(target as any, newRecord)) as any;
+				return newRecord?.[(this.constructor as any).primaryKey as keyof typeof newRecord] as any;
 			}
 		} else {
 			if (this.#isCollection) {
-				const resource = await this.constructor.create(this.#id, target, this.#context);
+				const resource = await (this.constructor as any).create(this.#id, target, this.#context);
 				return resource.#id;
 			}
 		}
@@ -327,7 +350,7 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 				// handle path.json, path.cbor, etc. for requesting a specific content type using just the URL
 				context.requestedContentType = requestedContentType;
 				path = path.slice(0, dotIndex); // remove the property from the path
-			} else if (this.attributes?.find((attribute) => attribute.name === property)) {
+			} else if ((this as any).attributes?.find((attribute) => attribute.name === property)) {
 				// handle path.attribute for requesting a specific attribute using just the URL
 				path = path.slice(0, dotIndex); // remove the property from the path
 				if (query) query.property = property;
@@ -355,13 +378,13 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	): Resource | Promise<Resource> {
 		let resource;
 		const id = target.id;
-		let context = request.getContext?.();
+		let context = (request as any).getContext?.();
 		let isCollection;
-		if (typeof request.isCollection === 'boolean' && request.hasOwnProperty('isCollection'))
-			isCollection = request.isCollection;
+		if (typeof (request as any).isCollection === 'boolean' && request.hasOwnProperty('isCollection'))
+			isCollection = (request as any).isCollection;
 		else isCollection = options?.isCollection;
 		// if it is a collection and we have a collection class defined, use it
-		const constructor = (isCollection && this.Collection) || this;
+		const constructor = (isCollection && (this as any).Collection) || this;
 		if (!context) context = context === undefined ? request : {};
 		resource = new constructor(id, context); // outside of a transaction, just create an instance
 		if (isCollection) resource.#isCollection = true;
@@ -374,16 +397,19 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	 * but implementors can call send with
 	 */
 	// eslint-disable-next-line no-unused-vars
-	subscribe(request: SubscriptionRequest): AsyncIterable<Record> {
+	subscribe(request: SubscriptionRequest): AsyncIterable<Record> | Promise<AsyncIterable<Record>> {
 		return new IterableEventQueue();
 	}
 
-	connect(target: RequestTarget, incomingMessages: IterableEventQueue<Record>): AsyncIterable<Record> {
+	connect(
+		target: RequestTarget,
+		incomingMessages: IterableEventQueue<Record>
+	): AsyncIterable<Record> | Promise<AsyncIterable<Record>> {
 		// convert subscription to an (async) iterator
-		const query = this.constructor.loadAsInstance === false ? target : incomingMessages;
-		if (query?.subscribe !== false) {
+		const query = (this.constructor as any).loadAsInstance === false ? target : incomingMessages;
+		if ((query as any)?.subscribe !== false) {
 			// subscribing is the default action, but can be turned off
-			return this.subscribe?.(query);
+			return this.subscribe?.(query as any) as any;
 		}
 		return new IterableEventQueue();
 	}
@@ -439,9 +465,9 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	search?(target: RequestTargetOrId): AsyncIterable<Record & Partial<RecordObject>>;
 
 	create?(
-		newRecord: Partial<Record & RecordObject>,
-		target: RequestTargetOrId
-	): Promise<Record & Partial<RecordObject>>;
+		target: RequestTargetOrId,
+		newRecord: Partial<Record & RecordObject>
+	): void | (Record & Partial<RecordObject>) | Promise<Record & Partial<RecordObject>>;
 	put?(
 		record: Record & RecordObject,
 		target: RequestTargetOrId
@@ -452,7 +478,9 @@ export class Resource<Record extends object = any> implements ResourceInterface<
 	): void | (Record & Partial<RecordObject>) | Promise<void | (Record & Partial<RecordObject>)>;
 
 	delete?(target: RequestTargetOrId): boolean | Promise<boolean>;
-	invalidate?(target: RequestTargetOrId): void | Promise<void>;
+	invalidate(_target: RequestTargetOrId): void | Promise<void> {
+		missingMethod(this, 'invalidate');
+	}
 
 	publish?(target: RequestTargetOrId, record: Record, options?: any): void;
 }
@@ -473,12 +501,15 @@ export function snakeCase(camelCase: string) {
  * @returns
  */
 function transactional(
-	action: (resource: ResourceInterface, query: RequestTarget, context: Context, data: any) => any,
+	action: (resource: any, query: RequestTarget, context: Context, data: any) => any,
 	options: {
-		hasContent: boolean;
+		hasContent?: boolean;
 		type: 'read' | 'update' | 'create' | 'delete';
 		async?: boolean;
 		ensureLoaded?: boolean;
+		letItLinger?: boolean;
+		method?: string;
+		syncAllowed?: boolean;
 	}
 ) {
 	applyContext.reliesOnPrototype = true;
@@ -493,18 +524,23 @@ function transactional(
 			if (context) {
 				// if there are three arguments, it is id, data, context
 				data = dataOrContext;
-				context = context.getContext?.() || context;
+				context = (context as any).getContext?.() || context;
 			} else if (dataOrContext) {
 				// two arguments, more possibilities:
 				if (
 					typeof idOrQuery === 'object' &&
 					idOrQuery &&
+					!(idOrQuery instanceof URLSearchParams) &&
 					(!Array.isArray(idOrQuery) || typeof idOrQuery[0] === 'object')
 				) {
 					// (data, context) form
 					data = idOrQuery;
 					id = data[this.primaryKey] ?? null;
-					context = dataOrContext.getContext?.() || dataOrContext;
+					context = (dataOrContext as any).getContext?.() || dataOrContext;
+					if (context instanceof DatabaseTransaction) context = { transaction: context };
+				} else if (dataOrContext instanceof DatabaseTransaction) {
+					// (id, txn) form
+					context = { transaction: dataOrContext };
 				} else if (dataOrContext?.transaction instanceof DatabaseTransaction) {
 					// (id, context) form
 					context = dataOrContext;
@@ -517,6 +553,10 @@ function transactional(
 				data = idOrQuery;
 				idOrQuery = undefined;
 				id = data.getId?.() ?? data[this.primaryKey];
+			} else if (idOrQuery != null && typeof idOrQuery !== 'object') {
+				// single argument form, just id
+				id = idOrQuery;
+				data = undefined;
 			} else {
 				throw new ClientError(`Invalid argument for data, must be an object, but got ${idOrQuery}`);
 			}
@@ -527,13 +567,13 @@ function transactional(
 			if (context) {
 				// (id, data, context), this a method that doesn't normally have a body/data, but with the three arguments, we have explicit data
 				data = dataOrContext;
-				context = context.getContext?.() || context;
+				context = (context as any).getContext?.() || context;
 			} else if (hasContent === false) {
 				// (id, context), preferred form used for methods that are explicitly without a body
-				context = dataOrContext.getContext?.() || dataOrContext;
+				context = (dataOrContext as any).getContext?.() || dataOrContext;
 			} else if (dataOrContext.transaction || dataOrContext.getContext) {
 				// or if it looks like a context
-				context = dataOrContext.getContext?.() || dataOrContext;
+				context = (dataOrContext as any).getContext?.() || dataOrContext;
 			} else {
 				data = dataOrContext;
 			}
@@ -582,7 +622,7 @@ function transactional(
 						}
 					}
 				} else if (id === undefined) {
-					id = idOrQuery.id ?? null;
+					id = (idOrQuery as any).id ?? null;
 					if (id == null) query.isCollection = true;
 				}
 			} else {
@@ -660,8 +700,8 @@ function transactional(
 								: options.type === 'create'
 									? resource.allowCreate(context.user, data, context)
 									: resource.allowDelete(context.user, query, context);
-					if (allowed?.then) {
-						return allowed.then((allowed) => {
+					if ((allowed as any)?.then) {
+						return (allowed as any).then((allowed) => {
 							query.checkPermission = false;
 							if (!allowed) {
 								throw new AccessViolation(context.user);

package/resources/ResourceInterface.ts

@@ -19,8 +19,8 @@ export interface ResourceInterface<Record extends object = any>
 
 	allowCreate(user: User, record: Promise<Record & RecordObject>, context: Context): boolean | Promise<boolean>;
 	create?(
-		newRecord: Partial<Record & RecordObject>,
-		target: RequestTargetOrId
+		target: RequestTargetOrId,
+		newRecord: Partial<Record & RecordObject>
 	): void | (Record & Partial<RecordObject>) | Promise<Record & Partial<RecordObject>>;
 	post?(
 		target: RequestTargetOrId,
@@ -32,10 +32,6 @@ export interface ResourceInterface<Record extends object = any>
 		record: Record & RecordObject,
 		target?: RequestTargetOrId
 	): void | (Record & Partial<RecordObject>) | Promise<void | (Record & Partial<RecordObject>)>;
-	patch?(
-		record: Partial<Record & RecordObject>,
-		target: RequestTargetOrId
-	): void | (Record & Partial<RecordObject>) | Promise<void | (Record & Partial<RecordObject>)>;
 	update?(updates: Record & RecordObject, fullUpdate: true): ResourceInterface<Record & Partial<RecordObject>>;
 	update?(
 		updates: Partial<Record & RecordObject>,
@@ -101,6 +97,20 @@ export interface Context {
 	resourceCache?: Map<Id, any>;
 	_freezeRecords?: boolean; // until v5, we conditionally freeze records for back-compat
 	timestamp?: number;
+	includeExpensiveRecordCountEstimates?: boolean;
+	/**
+	 * Matched route path of the calling Resource, populated by the HTTP/WS entry points
+	 * before they hand the request into `transaction()`. Populated on the Request that
+	 * becomes the ALS-bound Context for that path; absent for ops-API, internal jobs,
+	 * and replication-driven contexts.
+	 */
+	handlerPath?: string;
+	/**
+	 * Abort signal carried through ALS so generator bodies can forward cancellation to
+	 * external work (e.g. `scope.models.generateStream({ signal })`). Populated on the
+	 * Request that becomes the ALS-bound Context for HTTP/WS paths via #513.
+	 */
+	signal?: AbortSignal;
 }
 
 export interface SourceContext<TRequestContext = Context, Record extends object = any> {
@@ -128,19 +138,27 @@ export interface SourceContext<TRequestContext = Context, Record extends object
 
 export type Operator = 'and' | 'or';
 
-export type Comparator =
-	| 'between'
-	| 'contains'
-	| 'ends_with'
-	| 'eq'
-	| 'equals'
-	| 'greater_than'
-	| 'greater_than_equal'
-	| 'less_than'
-	| 'less_than_equal'
-	| 'ne'
-	| 'not_equal'
-	| 'starts_with';
+export const COMPARATORS = [
+	'between',
+	'contains',
+	'ends_with',
+	'eq',
+	'equals',
+	'gt',
+	'ge',
+	'lt',
+	'le',
+	'greater_than',
+	'greater_than_equal',
+	'in',
+	'less_than',
+	'less_than_equal',
+	'ne',
+	'not_equal',
+	'starts_with',
+] as const;
+
+export type Comparator = (typeof COMPARATORS)[number];
 
 export type DirectCondition<Record extends object = any> = TypedDirectCondition<Record, keyof Record>;
 
@@ -149,8 +167,13 @@ interface TypedDirectCondition<Record extends object, Property extends keyof Rec
 	search_attribute?: keyof Record | Array<keyof Record> | string | string[];
 	comparator?: Comparator;
 	search_type?: Comparator;
-	value?: Record[Property];
-	search_value?: Record[Property];
+	value?: Record[Property] | Record[Property][];
+	search_value?: Record[Property] | Record[Property][];
+	/**
+	 * If true, the condition is negated. Phase 1: filter-only — forces a
+	 * full scan unless paired with another indexed condition.
+	 */
+	negated?: boolean;
 }
 
 interface ConditionGroup<Record extends object = any> {

package/resources/Resources.ts

@@ -1,12 +1,10 @@
-import { Resource } from './Resource.ts';
 import { transaction } from './transaction.ts';
-import { ErrorResource } from './ErrorResource.ts';
-import logger from '../utility/logging/harper_logger.js';
-import { ServerError } from '../utility/errors/hdbError.js';
+import logger from '../utility/logging/harper_logger.ts';
+import { ServerError } from '../utility/errors/hdbError.ts';
 import { server } from '../server/Server.ts';
 
 interface ResourceEntry {
-	Resource: typeof Resource;
+	Resource: any;
 	path: string;
 	exportTypes: any;
 	hasSubPaths: boolean;
@@ -18,11 +16,12 @@ interface ResourceEntry {
  */
 export class Resources extends Map<string, ResourceEntry> {
 	isWorker = true;
-	loginPath?: (request) => string;
+	loginPath?: (request: any) => string;
 
 	allTypes: Map<any, any> = new Map();
 
-	set(path, resource, exportTypes?: { [key: string]: boolean }, force?: boolean): void {
+	// @ts-expect-error override with different signature
+	set(path: string, resource: any, exportTypes?: { [key: string]: boolean }, force?: boolean): void {
 		if (!resource) throw new Error('Must provide a resource');
 		if (path.startsWith('/')) path = path.replace(/^\/+/, '');
 		const entry = {
@@ -45,6 +44,7 @@ export class Resources extends Map<string, ResourceEntry> {
 			// don't provide anything more descriptive.
 			const error = new ServerError(`Conflicting paths for ${path}`);
 			logger.error(error);
+			const { ErrorResource } = require('./ErrorResource');
 			entry.Resource = new ErrorResource(error);
 		}
 		super.set(path, entry);
@@ -131,7 +131,7 @@ export class Resources extends Map<string, ResourceEntry> {
 		const entry = this.getMatch(path);
 		if (entry) {
 			path = entry.relativeURL;
-			return entry.Resource.getResource(this.pathToId(path, entry.Resource), resourceInfo);
+			return entry.Resource.getResource((this as any).pathToId(path, entry.Resource), resourceInfo);
 		}
 	}
 	call(path: string, request, callback: Function) {

package/resources/RocksIndexStore.ts

@@ -46,6 +46,7 @@ export class RocksIndexStore extends RocksDatabase {
 	 * @param primaryKey
 	 * @param txnId
 	 */
+	// @ts-ignore
 	put(indexedValue: any, primaryKey: Id, options: StorePutOptions) {
 		return super.putSync([indexedValue, primaryKey], null, options);
 	}
@@ -54,10 +55,12 @@ export class RocksIndexStore extends RocksDatabase {
 		return super.putSync([indexedValue, primaryKey], null, options);
 	}
 
+	// @ts-ignore
 	remove(indexedValue: any, primaryKey: Id, options?: StoreRemoveOptions) {
 		return super.removeSync([indexedValue, primaryKey], options);
 	}
 
+	// @ts-ignore
 	removeSync(indexedValue: any, primaryKey: Id, options?: StoreRemoveOptions) {
 		super.removeSync([indexedValue, primaryKey], options);
 	}

package/resources/RocksTransactionLogStore.ts

@@ -2,6 +2,7 @@ import { TransactionLog, RocksDatabase, shutdown, type TransactionEntry } from '
 import { ExtendedIterable } from '@harperfast/extended-iterable';
 import { getIdOfRemoteNode } from './nodeIdMapping.ts';
 import { Decoder, readAuditEntry, ENTRY_DATAVIEW, AuditRecord, createAuditEntry } from './auditStore.ts';
+import { endIteratorOnCorruptFrame } from './replayLogsGuards.ts';
 import { isMainThread } from 'node:worker_threads';
 import { EventEmitter } from 'node:events';
 import { asBinary } from 'lmdb';
@@ -21,6 +22,13 @@ type TransactionLogIterator = Iterator<TransactionEntry | number> & {
 	removeLog(logName: string);
 };
 
+// Logs (once per log) when a corrupt frame ends a query iterator early; see
+// endIteratorOnCorruptFrame in replayLogsGuards.ts for why this is end-of-log, not a crash.
+function warnCorruptFrame(logName: string) {
+	return (error: RangeError) =>
+		harperLogger.warn(`Stopping transaction log "${logName}" at a corrupt entry during replay`, error);
+}
+
 /**
  * Represents a transaction log store backed by RocksDB.
  * This class provides methods that conform to a standard store interface
@@ -125,7 +133,8 @@ export class RocksTransactionLogStore extends EventEmitter {
 		throw new Error('Not implemented');
 	}
 	addLogToMaps(logName: string, log: TransactionLog) {
-		const nodeId = (getIdOfRemoteNode(logName, this) ?? 0) as number;
+		// 'local' is always the local node's log, which maps to nodeId 0
+		const nodeId = (logName === 'local' ? 0 : getIdOfRemoteNode(logName, this)) as number;
 		if (this.nodeLogs) {
 			this.nodeLogs![nodeId] ??= log;
 		}
@@ -189,7 +198,7 @@ export class RocksTransactionLogStore extends EventEmitter {
 					log = this.rootStore.useLog(options.log);
 				}
 			}
-			const queryIterator = log.query(options);
+			const queryIterator = endIteratorOnCorruptFrame(log.query(options), warnCorruptFrame(log.name));
 			iterable.iterate = () => queryIterator;
 		} else {
 			const onlyKeys = options.onlyKeys;
@@ -240,7 +249,7 @@ export class RocksTransactionLogStore extends EventEmitter {
 								// condition of potentially missing an initial update
 								queryOptions = { ...options, start: options.start ?? 0 };
 							}
-							iterators.push(log.query(queryOptions));
+							iterators.push(endIteratorOnCorruptFrame(log.query(queryOptions), warnCorruptFrame(log.name)));
 						}
 					}
 					latestUpdates = this.updates;
@@ -409,7 +418,7 @@ export class RocksTransactionLogStore extends EventEmitter {
 	getUserSharedBuffer(key: string | symbol, defaultBuffer: ArrayBuffer, options?: { callback?: () => void }) {
 		return this.rootStore.getUserSharedBuffer(key, defaultBuffer, options);
 	}
-	on(eventName: string, listener: any) {
+	on(eventName: string, listener: any): any {
 		if (eventName === 'aftercommit') {
 			return super.on('aftercommit', listener);
 		} else {