fix(studio-server): history waits out a file a save has emptied, and rereads one written mid-copy (#7480)

* fix(studio-server): history waits out a file a save has emptied, and rereads one written mid-copy

* style(studio-server): state the history copy's null result in the present tense

* style(studio-server): wrap the put doc comment

* style(studio-server): shorten the put doc comment to one line

* fix(studio-server): a file still changing as history opens starts at its first whole copy
This commit is contained in:
Miguel Ángel
2026-11-10 07:02:11 +00:00
committed by GitHub
parent 88db83092a
commit e8416b2a41
4 changed files with 391 additions and 56 deletions
@@ -1,5 +1,14 @@
// @vitest-environment node
import { createReadStream, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { createHash } from "node:crypto";
import {
createReadStream,
mkdtempSync,
readdirSync,
readFileSync,
rmSync,
utimesSync,
writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -10,7 +19,12 @@ vi.mock("node:fs", async (importOriginal) => {
});
vi.mock("node:fs/promises", async (importOriginal) => {
const actual = await importOriginal<typeof import("node:fs/promises")>();
return { ...actual, rename: vi.fn(actual.rename), copyFile: vi.fn(actual.copyFile) };
return {
...actual,
rename: vi.fn(actual.rename),
copyFile: vi.fn(actual.copyFile),
open: vi.fn(actual.open),
};
});
import * as fs from "node:fs";
@@ -19,8 +33,11 @@ import { onRestoredInPlace, openBlobStore } from "./blobStore.js";
import { serveWhileOpen } from "../helpers/servedFiles.js";
const { renameSync: realRenameSync } = await vi.importActual<typeof import("node:fs")>("node:fs");
const { rename: realRename, copyFile: realCopyFile } =
await vi.importActual<typeof import("node:fs/promises")>("node:fs/promises");
const {
rename: realRename,
copyFile: realCopyFile,
open: realOpen,
} = await vi.importActual<typeof import("node:fs/promises")>("node:fs/promises");
const busy = () => Object.assign(new Error("EPERM: operation not permitted"), { code: "EPERM" });
const platform = process.platform;
@@ -190,3 +207,76 @@ describe("the history store's count of what it holds", () => {
}
});
});
describe("a file written to while the history reads it", () => {
let root: string;
beforeEach(() => {
root = mkdtempSync(join(tmpdir(), "hf-blob-moving-"));
});
afterEach(() => {
vi.mocked(fsp.open).mockImplementation(realOpen);
vi.mocked(fsp.copyFile).mockImplementation(realCopyFile);
rmSync(root, { recursive: true, force: true });
});
const sha = (text: string) => createHash("sha256").update(text).digest("hex");
const stored = () => readdirSync(join(root, "blobs"), { recursive: true }).map(String);
/** A saved file, dated a minute back, and the half and whole of the save about to replace it. */
function savedFile(name: string, size: number) {
const path = join(root, name);
writeFileSync(path, "a".repeat(size));
const minuteAgo = new Date(Date.now() - 60_000);
utimesSync(path, minuteAgo, minuteAgo);
return { path, half: "b".repeat(size / 2), whole: "b".repeat(size) };
}
it("reads a small file again when a save lands during the read, and files only the whole save", async () => {
const { path, half, whole } = savedFile("index.html", 1024);
vi.mocked(fsp.open).mockImplementationOnce(async (file, flags) => {
const handle = await realOpen(file, flags);
const read = handle.readFile.bind(handle);
handle.readFile = (async () => {
writeFileSync(path, half);
const bytes = await read();
writeFileSync(path, whole);
return bytes;
}) as typeof handle.readFile;
return handle;
});
const store = await openBlobStore(join(root, "blobs"));
expect(await store.put(path)).toBe(sha(whole));
expect(store.has(sha(half))).toBe(false);
});
it("copies a large file again when a save lands during the copy, and files only the whole save", async () => {
const { path, half, whole } = savedFile("clip.bin", 256 * 1024);
vi.mocked(fsp.copyFile).mockImplementationOnce(async (from, to) => {
writeFileSync(path, half);
await realCopyFile(from, to);
writeFileSync(path, whole);
});
const store = await openBlobStore(join(root, "blobs"));
expect(await store.put(path)).toBe(sha(whole));
expect(store.has(sha(half))).toBe(false);
expect(stored().filter((name) => name.includes("incoming-"))).toEqual([]);
});
it("files nothing, and leaves it for the next sweep, while every read is cut into", async () => {
const { path } = savedFile("clip.bin", 256 * 1024);
let saves = 0;
vi.mocked(fsp.copyFile).mockImplementation(async (from, to) => {
await realCopyFile(from, to);
saves += 1;
// A new size each time: a same-size rewrite within one clock tick of the disk keeps its stat.
writeFileSync(path, "b".repeat(256 * 1024 + saves));
});
const store = await openBlobStore(join(root, "blobs"));
expect(await store.put(path)).toBeNull();
expect(saves).toBe(3);
expect(stored()).toEqual([]);
});
});
+55 -24
View File
@@ -1,5 +1,5 @@
import { createHash, randomUUID } from "node:crypto";
import { constants, createReadStream, createWriteStream } from "node:fs";
import { constants, createReadStream, createWriteStream, type Stats } from "node:fs";
import {
chmod,
copyFile,
@@ -23,8 +23,8 @@ import { stopServingAndClose } from "../helpers/servedFiles.js";
/** File contents stored once by sha256, text and binary alike. */
export interface BlobStore {
/** Copies the file in (a clone where the file system can, for all but small files) and returns the copy's hash. */
put(absPath: string): Promise<string>;
/** Copies the file in (cloned where it can) and returns its hash; null while it keeps changing. */
put(absPath: string): Promise<string | null>;
reference(absPath: string): Promise<string>;
has(hash: string): boolean;
read(hash: string): Promise<Buffer>;
@@ -40,6 +40,18 @@ export interface BlobStore {
const BLOB_HASH = /^[0-9a-f]{64}$/;
const READ_ONCE_AT_MOST_BYTES = 64 * 1024;
const READS_BEFORE_LEAVING_IT = 3;
// Longer than the 20 ms a watcher gathers a burst for, so the sweep a save's first event starts sees it under way.
export const SETTLE_MS = 100;
export const isSettling = (file: { mtimeMs: number; ctimeMs: number }, now: number) =>
Math.abs(now - Math.max(file.mtimeMs, file.ctimeMs)) < SETTLE_MS;
const unchanged = (before: Stats, after: Stats) =>
before.size === after.size &&
before.mtimeMs === after.mtimeMs &&
before.ctimeMs === after.ctimeMs;
export function blobPath(dir: string, hash: string): string {
// Checked where the path is joined, so no caller can read or write outside the store.
@@ -55,11 +67,15 @@ async function hashFile(path: string): Promise<string> {
return hash.digest("hex");
}
async function readIfSmall(path: string): Promise<{ bytes: Buffer; mode: number } | null> {
async function readIfSmall(
path: string,
): Promise<{ bytes: Buffer; mode: number; moved: boolean } | null> {
const handle = await open(path, "r");
try {
const { size, mode } = await handle.stat();
return size > READ_ONCE_AT_MOST_BYTES ? null : { bytes: await handle.readFile(), mode };
const before = await handle.stat();
if (before.size > READ_ONCE_AT_MOST_BYTES) return null;
const bytes = await handle.readFile();
return { bytes, mode: before.mode, moved: !unchanged(before, await handle.stat()) };
} finally {
await handle.close();
}
@@ -194,28 +210,43 @@ export async function openBlobStore(dir: string): Promise<BlobStore> {
return hash;
};
return {
async put(absPath) {
const small = await readIfSmall(absPath);
if (small) return putBytes(small.bytes, small.mode);
// Hash the copy, not the source, so a write racing the copy can never file bytes under the wrong hash.
const temp = join(dir, `incoming-${randomUUID()}`);
// Recreated if removed while open, so a missing folder is never mistaken for a deleted project file.
await mkdir(dir, { recursive: true });
await cloneOrStream(absPath, temp).catch(async (error) => {
const putIfUnchanged = async (absPath: string): Promise<string | null> => {
const small = await readIfSmall(absPath);
if (small) return small.moved ? null : putBytes(small.bytes, small.mode);
// Hash the copy, not the source, so a write racing the copy can never file bytes under the wrong hash.
const temp = join(dir, `incoming-${randomUUID()}`);
// Recreated if removed while open, so a missing folder is never mistaken for a deleted project file.
await mkdir(dir, { recursive: true });
const before = await stat(absPath);
const moved = await cloneOrStream(absPath, temp)
.then(async () => !unchanged(before, await stat(absPath)))
.catch(async (error) => {
await rm(temp, { force: true });
throw error;
});
const hash = await hashFile(temp);
if (sizes.has(hash)) {
await rm(temp, { force: true });
return hash;
}
await mkdir(dirname(blobPath(dir, hash)), { recursive: true });
const size = (await stat(temp)).size;
await renameWithRetryAsync(temp, blobPath(dir, hash));
file(hash, size);
if (moved) {
await rm(temp, { force: true });
return null;
}
const hash = await hashFile(temp);
if (sizes.has(hash)) {
await rm(temp, { force: true });
return hash;
}
await mkdir(dirname(blobPath(dir, hash)), { recursive: true });
const size = (await stat(temp)).size;
await renameWithRetryAsync(temp, blobPath(dir, hash));
file(hash, size);
return hash;
};
return {
async put(absPath) {
for (let read = 0; read < READS_BEFORE_LEAVING_IT; read += 1) {
const hash = await putIfUnchanged(absPath);
if (hash !== null) return hash;
}
return null;
},
reference: (absPath) => hashFile(absPath),
has: (hash) => sizes.has(hash) || asideSizes.has(hash),
@@ -0,0 +1,175 @@
// @vitest-environment node
import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
import { open as openFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { basename, join } from "node:path";
import { afterEach, describe, expect, it, vi } from "vitest";
import { fileContentVersion, hashOfVersion } from "../helpers/fileVersion";
import { SETTLE_MS } from "./blobStore";
import { START, type HistoryWho } from "./historyLog";
import { openProjectHistory, type ProjectHistory } from "./projectHistory";
// Per file name, how many more copies find it changing during every read.
const changing = vi.hoisted(() => new Map<string, number>());
vi.mock("./blobStore", async (importOriginal) => {
const real = await importOriginal<typeof import("./blobStore")>();
return {
...real,
openBlobStore: async (dir: string) => {
const store = await real.openBlobStore(dir);
const put = async (path: string) => {
const left = changing.get(basename(path)) ?? 0;
if (left === 0) return store.put(path);
changing.set(basename(path), left - 1);
return null;
};
return { ...store, put };
},
};
});
const you: HistoryWho = { kind: "person", name: "You" };
const agent: HistoryWho = { kind: "agent", name: "Agent" };
const cleanup: Array<() => unknown> = [];
afterEach(async () => {
for (const step of cleanup.splice(0).reverse()) await step();
changing.clear();
});
function tempDir(prefix: string): string {
const dir = mkdtempSync(join(tmpdir(), prefix));
cleanup.push(() => rmSync(dir, { recursive: true, force: true }));
return dir;
}
async function project(options = {}) {
const projectDir = tempDir("hf-history-project-");
const historyRoot = tempDir("hf-history-root-");
writeFileSync(join(projectDir, "index.html"), "<h1>Hello</h1>");
const history = await openProjectHistory({ projectDir, historyRoot, ...options });
cleanup.push(() => history.close());
const write = (content: string) => writeFileSync(join(projectDir, "index.html"), content);
const read = () => readFileSync(join(projectDir, "index.html"), "utf-8");
return { projectDir, history, write, read, index: join(projectDir, "index.html") };
}
describe("a file an outside save has emptied but not yet written", () => {
const sha = (text: string) => hashOfVersion(fileContentVersion(text));
const kept = (history: ProjectHistory) =>
history.list().map((entry) => [entry.label, entry.files.map((file) => file.after)]);
const outside = "Changed outside the app";
/** A project whose clock stops at index.html's last change, as a sweep right after that change sees it. */
async function saving() {
let clock: number | undefined;
const opened = await project({ now: () => clock ?? Date.now() });
const changedNow = () => {
const { mtimeMs, ctimeMs } = statSync(opened.index);
clock = Math.max(mtimeMs, ctimeMs);
};
const later = (ms: number) => (clock = (clock ?? Date.now()) + ms);
return { ...opened, changedNow, later };
}
it("files no empty version for a save paused between emptying the file and writing it", async () => {
const { history, index, read, changedNow } = await saving();
const save = await openFile(index, "w");
changedNow();
await history.flush();
await history.claim(you, "Another file", []);
await save.write("<h1>Saved</h1>");
await save.close();
await history.claim(you, "Edited", ["index.html"]);
expect(kept(history)).toEqual([["Edited", [sha("<h1>Saved</h1>")]]]);
await history.step("back", you);
expect(read()).toBe("<h1>Hello</h1>");
});
it("files a save paused after its first bytes as it stands: only an empty file waits", async () => {
const { history, index, changedNow } = await saving();
const save = await openFile(index, "w");
await save.write("<h1>Sa");
changedNow();
await history.flush();
await save.write("ved</h1>");
await save.close();
await history.claim(you, "Edited", ["index.html"]);
expect(kept(history)).toEqual([
[outside, [sha("<h1>Sa")]],
["Edited", [sha("<h1>Saved</h1>")]],
]);
});
it("records a file emptied for good by the next sweep, once it has been quiet a moment", async () => {
const { history, index, changedNow, later } = await saving();
await (await openFile(index, "w")).close();
changedNow();
await history.flush();
expect(kept(history)).toEqual([]);
later(SETTLE_MS);
await vi.waitFor(
() => expect(history.next("back", you)?.files.map((file) => file.after)).toEqual([sha("")]),
{ timeout: 5000, interval: 20 },
);
});
it("records an empty save the moment a claim names it", async () => {
const { history, write, changedNow } = await saving();
write("");
changedNow();
await history.claim(you, "Cleared", ["index.html"]);
expect(kept(history)).toEqual([["Cleared", [sha("")]]]);
});
it("files a window's empty write in that window, ended at once by close or flush", async () => {
const { history, write, changedNow } = await saving();
const closed = await history.beginWindow(agent, "Closed turn");
write("");
changedNow();
await closed.close();
write("<h1>Two</h1>");
await history.claim(you, "Typed", ["index.html"]);
await history.beginWindow(agent, "Flushed turn");
write("");
changedNow();
await history.flush();
expect(kept(history)).toEqual([
["Closed turn", [sha("")]],
["Typed", [sha("<h1>Two</h1>")]],
["Flushed turn", [sha("")]],
]);
});
it("still sees a file emptied just before an undo, and refuses to write over it", async () => {
const { history, write, read, changedNow } = await saving();
const window = await history.beginWindow(you, "Your edit");
write("v2");
const mine = await window.close();
if (!mine) throw new Error("the window recorded nothing");
write("");
changedNow();
expect((await history.undo(mine.id, { who: you })).ok).toBe(false);
expect(read()).toBe("");
});
});
describe("a file still being written when the history first opens", () => {
it("is not filed as added outside: its first whole copy is where its history starts", async () => {
const projectDir = tempDir("hf-history-project-");
const historyRoot = tempDir("hf-history-root-");
const media = join(projectDir, "media.txt");
writeFileSync(media, "recorded");
changing.set("media.txt", 3);
const history = await openProjectHistory({ projectDir, historyRoot });
cleanup.push(() => history.close());
await vi.waitFor(() => expect(history.peek(START)).toHaveProperty("media.txt"), {
timeout: 5000,
interval: 20,
});
await history.flush();
expect(history.list()).toEqual([]);
await history.step("back", you);
expect(existsSync(media)).toBe(true);
});
});
@@ -28,7 +28,7 @@ import {
affectsProjectSignature,
listProjectFiles,
} from "../helpers/projectSignature.js";
import { openBlobStore, readBlob, type BlobStore } from "./blobStore.js";
import { isSettling, openBlobStore, readBlob, SETTLE_MS, type BlobStore } from "./blobStore.js";
import { isUncopied, uncopiedOnlyHashes } from "./uncopied.js";
import { pruneGoneProjectHistoriesDaily } from "./pruneHistories.js";
import {
@@ -212,6 +212,9 @@ const statKey = (file: { size: number; mtimeMs: number; ctimeMs: number }, swept
? ""
: `${file.size}:${file.mtimeMs}:${file.ctimeMs}`;
type Copied = { hash: string } | "gone" | "changing";
const ADOPT_RETRY_AT_MOST_MS = 30_000;
const FIRST_COPY_SLOTS_IN_PROCESS = 4;
let firstCopiesRunning = 0;
const firstCopiesWaiting: (() => void)[] = [];
@@ -551,12 +554,12 @@ class Engine {
async takeInUnnamedLedger(): Promise<void> {
const named = (path: string) =>
this.log.entries.some((entry) => entry.files.some((file) => file.path === path));
const listed = () => historyFiles(this.dir).some((file) => file.path === MEDIA_LEDGER);
const hash =
this.log.baseline.has(MEDIA_LEDGER) || named(MEDIA_LEDGER) || !listed()
? null
: await this.storeIfPresent(MEDIA_LEDGER);
if (hash !== null) this.log.baseline.set(MEDIA_LEDGER, hash);
const ledger = historyFiles(this.dir).find((file) => file.path === MEDIA_LEDGER);
if (ledger && !this.log.baseline.has(MEDIA_LEDGER) && !named(MEDIA_LEDGER)) {
const copied = await this.storeIfPresent(MEDIA_LEDGER);
if (typeof copied === "object") this.log.baseline.set(MEDIA_LEDGER, copied.hash);
else if (copied === "changing") this.adoptMediaInBackground([ledger], this.now());
}
this.log.keepsLedger = true;
this.persistLog();
}
@@ -570,18 +573,20 @@ class Engine {
);
// Nothing names these copies until the log below is written, so one look at the end covers the whole copy.
if (this.whereFolder() !== "here") throw this.replaced();
const owed: ListedFile[] = [];
copied.forEach((file, i) => {
const result = hashes[i]!;
if (result.status === "rejected") throw result.reason;
if (result.value !== null)
this.tracked.set(file.path, { hash: result.value, stat: statKey(file, sweptAt) });
if (result.value === "changing") owed.push(file);
else if (result.value !== "gone")
this.tracked.set(file.path, { hash: result.value.hash, stat: statKey(file, sweptAt) });
});
this.log.baseline = this.manifest();
this.log.keepsLedger = true;
this.persistLog();
this.saveStatCache();
this.adoptMediaInBackground(
files.filter((file) => file.size > COPY_LATER_ABOVE_BYTES),
[...owed, ...files.filter((file) => file.size > COPY_LATER_ABOVE_BYTES)],
sweptAt,
);
}
@@ -602,13 +607,14 @@ class Engine {
replaceFileAtomically(file, JSON.stringify([...this.adopting.keys()]), 0o644);
}
async adopt(file: ListedFile, sweptAt: number) {
async adopt(file: ListedFile, sweptAt: number, tries = 0) {
try {
if (this.whereFolder() !== "here") return;
const stored = await this.storeIfPresent(file.path);
const copied = await this.storeIfPresent(file.path);
await this.queue(async () => {
// Still named for the next open until recorded, so a failed record is never logged as added.
await this.recordAdopted(file, sweptAt, stored);
if ((await this.recordAdopted(file, sweptAt, copied)) === "changing")
return this.adoptLater(file, sweptAt, tries + 1);
this.adopting.delete(file.path);
this.saveAdopting();
});
@@ -617,12 +623,23 @@ class Engine {
}
}
async recordAdopted(file: ListedFile, sweptAt: number, stored: string | null) {
if (stored === null || this.whereFolder() !== "here") return;
/** A file still changing stays named until a whole copy of it lands; the next open retries it. */
adoptLater(file: ListedFile, sweptAt: number, tries: number): void {
if (this.closing) return;
const timer = setTimeout(
() => void this.adopt(file, sweptAt, tries),
Math.min(SETTLE_MS * 2 ** tries, ADOPT_RETRY_AT_MOST_MS),
);
timer.unref?.();
}
async recordAdopted(file: ListedFile, sweptAt: number, first: Copied): Promise<Copied> {
if (typeof first === "string" || this.whereFolder() !== "here") return first;
// A prune that ran while this copy waited for the queue may have taken its bytes.
const kept = this.blobs.has(stored) || isUncopied(file.path, file.size);
const hash = kept ? stored : await this.storeIfPresent(file.path);
if (hash === null) return;
const kept = this.blobs.has(first.hash) || isUncopied(file.path, file.size);
const copied = kept ? first : await this.storeIfPresent(file.path);
if (typeof copied === "string") return copied;
const { hash } = copied;
const change = { path: file.path, before: null, after: hash };
const found = this.overwrittenBy(change, undefined, new Set());
const start = found && this.blobs.has(found) ? found : hash;
@@ -631,6 +648,7 @@ class Engine {
if (start !== hash) addChange(this.outsideGroup(), file.path, start, hash);
this.persistLog(baselineRecord(this.log));
this.saveStatCache();
return copied;
}
manifest(): Manifest {
@@ -666,7 +684,7 @@ class Engine {
* Takes in every write since the last sweep and files each change to its writer. ponytail: always the whole
* project (a stat per file, a hash only when the stat moved); per-path sweeps if projects reach tens of thousands.
*/
async sweep(): Promise<void> {
async sweep(asItStands: "every" | ReadonlySet<string> = new Set()): Promise<void> {
// A folder moved or removed was not emptied, and another project at its path is none of this history's.
if (this.whereFolder() !== "here") return;
const sweptAt = this.now();
@@ -693,8 +711,20 @@ class Engine {
...removed,
...seen.map((file) => ({ at: appearedAt(file), path: file.path, file })),
].sort((a, b) => a.at - b.at);
// An emptied file may be a save not yet written; a window's write, a claimed path and an undo take it as it is.
const waitsForQuiet = (path: string, file: ListedFile, at: number) =>
file.size === 0 &&
asItStands !== "every" &&
!asItStands.has(path) &&
isSettling(file, sweptAt) &&
!this.windows.some((open) => takesWrite(open, at));
let changed = false;
let waiting = false;
for (const { at, path, file } of events) {
if (file && waitsForQuiet(path, file, at)) {
waiting = true;
continue;
}
if (file) {
changed = (await this.observe(path, statKey(file, sweptAt), at)) || changed;
continue;
@@ -706,16 +736,19 @@ class Engine {
changed = true;
}
if (changed) this.saveStatCache();
if (waiting) this.sweepIn(SETTLE_MS);
}
/** The file's hash once copied in; null when it was removed before the copy (the next sweep records that). */
async storeIfPresent(path: string): Promise<string | null> {
/** The file's hash once copied in, or why there is none: gone, or still changing through every read. */
async storeIfPresent(path: string): Promise<Copied> {
try {
const abs = join(this.dir, path);
const { size } = await stat(abs);
return await (isUncopied(path, size) ? this.blobs.reference(abs) : this.blobs.put(abs));
if (isUncopied(path, size)) return { hash: await this.blobs.reference(abs) };
const hash = await this.blobs.put(abs);
return hash === null ? "changing" : { hash };
} catch (error) {
if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
if ((error as NodeJS.ErrnoException).code === "ENOENT") return "gone";
throw error;
}
}
@@ -724,8 +757,9 @@ class Engine {
const known = this.tracked.get(path) ?? { hash: null, stat: null };
if (stat && known.stat === stat) return false;
const heard = this.overwritten.get(path);
const hash = await this.storeIfPresent(path);
if (hash === null || this.whereFolder() !== "here") return false;
const copied = await this.storeIfPresent(path);
if (typeof copied === "string" || this.whereFolder() !== "here") return false;
const { hash } = copied;
this.tracked.set(path, { hash, stat });
this.forgetWritesBefore(path, hash, heard);
if (known.hash !== hash) await this.record(path, known.hash, hash, at);
@@ -753,7 +787,7 @@ class Engine {
paths: readonly string[],
{ coalesceKey, idleMs, overwrote = {}, targets = [] }: ClaimOptions,
): Promise<{ id: string } | null> {
await this.sweep();
await this.sweep(new Set(paths.map((path) => this.logPath(path))));
const taken = await this.takeClaimed(who, paths, overwrote);
if (!taken.length) return this.claimNothing(coalesceKey);
const held = this.heldFor(coalesceKey, taken);
@@ -1000,7 +1034,7 @@ class Engine {
/** Before an operation or a window: every write is filed and every pending change committed, in write order. */
async settle(): Promise<void> {
await this.sweep();
await this.sweep("every");
await this.commitClaim();
await this.commitPending();
}
@@ -1010,10 +1044,15 @@ class Engine {
const absolute = resolve(this.dir, path);
if (this.notedTimer || !affectsProjectSignature(this.dir, absolute)) return;
if (!isHistoryPath(relative(this.dir, absolute).split(sep).join("/"))) return;
this.sweepIn(20);
}
sweepIn(ms: number): void {
if (this.notedTimer || this.closed) return;
this.notedTimer = setTimeout(() => {
this.notedTimer = null;
this.background(() => this.sweep());
}, 20);
}, ms);
this.notedTimer.unref?.();
}