pi-posthorse 0.10.5 → 0.10.6

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-posthorse",
-	"version": "0.10.5",
+	"version": "0.10.6",
 	"type": "module",
 	"description": "Posthorse: fresh context, same journey. No-summary context rollover for Pi, with sparse budget reminders, handoffs, notes, and history.",
 	"keywords": [

package/src/note-discovery.ts

@@ -3,7 +3,13 @@ import { join, relative } from "node:path";
 import { isRecord } from "./contracts.ts";
 import { sessionNoteTouches } from "./note-evidence.ts";
 import { notesUnder, type NoteFile } from "./note-inventory.ts";
-import { fileDigest, fileIdentity, readManifest, sameIdentity } from "./note-snapshots.ts";
+import {
+	fileDigest,
+	fileIdentity,
+	mapBatch,
+	readManifest,
+	sameIdentity,
+} from "./note-snapshots.ts";
 import {
 	sameScope,
 	scopeDirectory,
@@ -47,12 +53,13 @@ async function projectScopes(
 		}
 		throw error;
 	});
-	for (const entry of entries) {
+	const candidates = entries.filter((entry) => !entry.name.startsWith(".staging-"));
+	const manifests = await mapBatch(candidates, async (entry) =>
+		entry.isDirectory() ? readManifest(join(directory, entry.name, "notes")) : undefined,
+	);
+	for (const [index, entry] of candidates.entries()) {
 		const path = join(directory, entry.name);
-		if (entry.name.startsWith(".staging-")) {
-			continue;
-		}
-		const manifest = entry.isDirectory() ? await readManifest(join(path, "notes")) : undefined;
+		const manifest = manifests[index];
 		if (manifest === undefined || manifest.root !== session.binding.root) {
 			notice(`Not indexed: unmanaged or incomplete notes data at ${path}.`);
 		} else {
@@ -199,9 +206,19 @@ export class NoteDiscovery {
 					Number(sameScope(b.address, session.binding)) -
 					Number(sameScope(a.address, session.binding)),
 			);
-			for (const file of group) {
+			const results = await mapBatch(group, async (file) => {
+				const fileNotices: string[] = [];
+				const digest = await this.#digest(file, session, {
+					...options,
+					notice: (text) => {
+						fileNotices.push(text);
+					},
+				});
+				return { file, digest, fileNotices };
+			});
+			for (const { file, digest, fileNotices } of results) {
+				fileNotices.forEach(options.notice);
 				// Only same-lineage, same-size candidates need content comparison.
-				const digest = await this.#digest(file, session, options);
 				const previous = digest === undefined ? undefined : matches.get(digest);
 				if (previous === undefined || digest === undefined) {
 					matches.set(digest ?? noteKey(file.address), file);
@@ -229,22 +246,17 @@ export class NoteDiscovery {
 			directories: new Set(session.scopes.map(scopeDirectory)),
 		});
 		const paths = new Set(touches.map((touch) => touch.notePath));
-		const files: DiscoveredNote[] = [];
-		for (const path of paths) {
-			if (
-				session.owns(path) ||
-				(options.path !== undefined &&
-					path !== options.path &&
-					!path.startsWith(`${options.path}/`))
-			) {
-				continue;
-			}
-			const file = await readReference(session, path, options.signal);
-			if (file !== undefined) {
-				files.push(file);
-			}
-		}
-		return files;
+		const candidates = [...paths].filter(
+			(path) =>
+				!session.owns(path) &&
+				(options.path === undefined ||
+					path === options.path ||
+					path.startsWith(`${options.path}/`)),
+		);
+		const resolved = await mapBatch(candidates, (path) =>
+			readReference(session, path, options.signal),
+		);
+		return resolved.filter((file): file is DiscoveredNote => file !== undefined);
 	}
 	async list(
 		session: SessionNotes,
@@ -258,21 +270,32 @@ export class NoteDiscovery {
 		const notice = (text: string) => {
 			notices.push(text);
 		};
-		const scopes =
-			options.scope === undefined
-				? await projectScopes(session, notice)
-				: [
+		const requestedScope = options.scope;
+		const [scopes, references] = await Promise.all([
+			requestedScope === undefined
+				? projectScopes(session, notice)
+				: (async () => [
 						{
-							scope: await session.selectScope(options.scope),
-							manifest: await readManifest(options.scope),
+							scope: await session.selectScope(requestedScope),
+							manifest: await readManifest(requestedScope),
 						},
-					];
+					])(),
+			this.#references(session, options),
+		]);
+		const scoped = await mapBatch(scopes, async (scope) => {
+			const scopeNotices: string[] = [];
+			const scopeFiles = await scopedFiles(scope, options, (text) => {
+				scopeNotices.push(text);
+			});
+			return { scopeFiles, scopeNotices };
+		});
 		const files: DiscoveredNote[] = [];
-		for (const scope of scopes) {
+		for (const { scopeFiles, scopeNotices } of scoped) {
 			// Preserve native listing order while walking each scope independently.
-			files.push(...(await scopedFiles(scope, options, notice)));
+			notices.push(...scopeNotices);
+			files.push(...scopeFiles);
 		}
-		for (const reference of await this.#references(session, options)) {
+		for (const reference of references) {
 			if (!files.some((file) => noteKey(file.address) === noteKey(reference.address))) {
 				files.push(reference);
 			}

package/src/note-guards.ts

@@ -12,6 +12,7 @@ import {
 	type NoteAddress,
 	type NoteTouchRecord,
 } from "./note-scopes.ts";
+import { mapBatch } from "./note-snapshots.ts";
 import { noteOperations, verifiedNoteOperations, type NoteOperation } from "./note-tool-effects.ts";
 import type { NoteCall, NotesStore, SessionNotes } from "./note-store.ts";
 
@@ -115,12 +116,12 @@ async function recordedFiles(
 	captured: CapturedCall,
 ): Promise<NoteTouchRecord["files"]> {
 	const files: NoteTouchRecord["files"][number][] = [];
-	for (const operation of operations) {
+	const addresses = await mapBatch(operations, (operation) =>
+		noteAddress(toolPath(captured.tool, operation.path, captured.cwd), captured.session),
+	);
+	for (const [index, operation] of operations.entries()) {
 		// Each result belongs to the scope captured before execution, even after /tree.
-		const address = await noteAddress(
-			toolPath(captured.tool, operation.path, captured.cwd),
-			captured.session,
-		);
+		const address = addresses[index];
 		if (address === undefined) {
 			continue;
 		}

package/src/note-provenance.ts

@@ -5,7 +5,7 @@ import { isRecord, type EntryLike } from "./contracts.ts";
 import { sessionLines } from "./session-lines.ts";
 import { parseSessionLine } from "./session-files.ts";
 import { sessionNoteTouches } from "./note-evidence.ts";
-import { readManifest, snapshot, type SnapshotNote } from "./note-snapshots.ts";
+import { mapBatch, readManifest, snapshot, type SnapshotNote } from "./note-snapshots.ts";
 import {
 	addressOf,
 	bindingsOf,
@@ -227,9 +227,12 @@ async function forkBinding(
 	const entries = [...manager.getEntries(), ...source.entries];
 	const files: SnapshotNote[] = [];
 	const absent: string[] = [];
-	for (const candidate of candidates) {
+	const addresses = await mapBatch(candidates, (candidate) =>
+		resolveReference(scope ?? candidate.source, candidate.path, entries),
+	);
+	for (const [index, candidate] of candidates.entries()) {
 		// Resolve against the immediate parent's files, not a historical ancestor's version.
-		const address = await resolveReference(scope ?? candidate.source, candidate.path, entries);
+		const address = addresses[index];
 		if (address !== undefined) {
 			files.push({
 				path: candidate.path,

package/src/note-snapshots.ts

@@ -89,18 +89,39 @@ export type SnapshotNote = {
 	readonly lineage: NoteAddress;
 	readonly anchors: readonly string[];
 };
+const NOTE_IO_BATCH = 16;
+export async function mapBatch<Input, Output>(
+	items: readonly Input[],
+	fn: (item: Input) => Promise<Output>,
+): Promise<Output[]> {
+	const results: Output[] = [];
+	for (let start = 0; start < items.length; start += NOTE_IO_BATCH) {
+		const settled = await Promise.allSettled(
+			items.slice(start, start + NOTE_IO_BATCH).map((item) => fn(item)),
+		);
+		for (const item of settled) {
+			if (item.status === "rejected") {
+				throw item.reason instanceof Error ? item.reason : new Error(String(item.reason));
+			}
+			results.push(item.value);
+		}
+	}
+	return results;
+}
 async function copyNote(note: SnapshotNote, destination: string): Promise<NoteSeed> {
 	const source = notePath(note.source, note.source.path);
-	const before = await stat(source);
-	await mkdir(dirname(destination), { recursive: true });
+	const [before] = await Promise.all([
+		stat(source),
+		mkdir(dirname(destination), { recursive: true }),
+	]);
 	await copyFile(source, destination, constants.COPYFILE_EXCL);
 	const after = await stat(source);
 	if (!sameIdentity(before, after)) {
 		throw new Error(`Source note changed during snapshot: ${source}. Retry initialization.`);
 	}
 	await utimes(destination, before.atimeMs / 1000, before.mtimeMs / 1000);
-	const digest = await fileDigest(destination);
-	return { ...note, digest, identity: fileIdentity(await stat(destination)) };
+	const [digest, destInfo] = await Promise.all([fileDigest(destination), stat(destination)]);
+	return { ...note, digest, identity: fileIdentity(destInfo) };
 }
 /** Publication is the ownership boundary. An existing unrelated directory is never overwritten. */
 export async function snapshot(
@@ -129,11 +150,10 @@ export async function snapshot(
 	await mkdir(dirname(container), { recursive: true });
 	const stage = await mkdtemp(join(dirname(container), ".staging-"));
 	try {
-		const seeds: NoteSeed[] = [];
-		for (const note of notes) {
-			// Keep each file's identity and digest paired with the bytes actually copied.
-			seeds.push(await copyNote(note, notePath({ root: stage, scope: "notes" }, note.path)));
-		}
+		// Keep each file's identity and digest paired with the bytes actually copied.
+		const seeds = await mapBatch(notes, (note) =>
+			copyNote(note, notePath({ root: stage, scope: "notes" }, note.path)),
+		);
 		const complete: ForkBinding = { ...binding, seeds };
 		await writeFile(join(stage, "manifest.json"), JSON.stringify(complete), { flag: "wx" });
 		await rename(stage, container);

package/src/notes.ts

@@ -55,16 +55,17 @@ async function listNotes(
 ): Promise<TextResult> {
 	const { host, pages, signal } = access;
 	const folder = params.path;
-	const inventory = await access.discovery.list(session, {
-		path: folder,
-		scope: params.scope,
-		signal,
-	});
+	const [inventory, selectedScope] = await Promise.all([
+		access.discovery.list(session, {
+			path: folder,
+			scope: params.scope,
+			signal,
+		}),
+		(async () =>
+			params.scope === undefined ? undefined : session.selectScope(params.scope))(),
+	]);
 	const { files } = inventory;
-	const dir =
-		params.scope === undefined
-			? session.directory
-			: scopeDirectory(await session.selectScope(params.scope));
+	const dir = selectedScope === undefined ? session.directory : scopeDirectory(selectedScope);
 	const rows: string[] = [];
 	for (let start = 0; start < files.length; start += FORMAT_BATCH) {
 		// Pi gets an event-loop turn before each batch of rows.