@valbuild/server 0.102.0 → 0.103.1

package/dist/declarations/src/ValOps.d.ts

@@ -1,4 +1,4 @@
-import { FileMetadata, FileSource, ImageMetadata, ModuleFilePath, PatchId, RemoteSource, Schema, SelectorSource, SerializedSchema, Source, SourcePath, ValConfig, ValModules, ValidationError } from "@valbuild/core";
+import { MediaSource, FileMetadata, FileSource, ImageMetadata, ModuleFilePath, PatchId, Schema, SelectorSource, SerializedSchema, Source, SourcePath, ValConfig, ValModules, ValidationError } from "@valbuild/core";
 import { result } from "@valbuild/core/fp";
 import { JSONValue, ParentRef, Patch, PatchError } from "@valbuild/core/patch";
 import { ValSyntaxError, ValSyntaxErrorTree } from "./patch/ts/syntax.js";
@@ -84,6 +84,15 @@ export declare abstract class ValOps {
         schemaSha: SchemaSha;
         sourcesSha: SourcesSha;
         patches: PatchId[];
+        /**
+         * Unpublished changes the store threw away because it could not read
+         * them. FS mode only: the content api owns its own patches and does not
+         * discard them behind the client's back.
+         */
+        removed?: {
+            patchId: PatchId;
+            reason: string;
+        }[];
         /** FS mode only — see the `params` counterpart. */
         jsonEntriesSha?: string;
     } | {
@@ -225,9 +234,9 @@ export declare abstract class ValOps {
             validations: Record<SourcePath, ValidationError[]>;
         }>;
         files: Record<SourcePath, FileSource>;
-        remoteFiles: Record<SourcePath, RemoteSource>;
+        remoteFiles: Record<SourcePath, MediaSource>;
     }>;
-    validateRemoteFiles(schemas: Schemas, sources: Sources, remoteFiles: Record<SourcePath, RemoteSource>): Promise<Record<SourcePath, ValidationError[]>>;
+    validateRemoteFiles(schemas: Schemas, sources: Sources, remoteFiles: Record<SourcePath, MediaSource>): Promise<Record<SourcePath, ValidationError[]>>;
     validateFiles(schemas: Schemas, sources: Sources, files: Record<SourcePath, FileSource>, fileLastUpdatedByPatchId?: PatchAnalysis["fileLastUpdatedByPatchId"]): Promise<Record<SourcePath, ValidationError[]>>;
     /**
      * Applies the pending patches to the source files so they can be committed.

package/dist/declarations/src/ValOpsFS.d.ts

@@ -1,7 +1,6 @@
 import { PatchId, ModuleFilePath, ValModules } from "@valbuild/core";
-import { AuthorId, BaseSha, BinaryFileType, GenericErrorMessage, MetadataOfType, OpsMetadata, PreparedCommit, ValOps, ValOpsOptions, WithGenericError, SaveSourceFilePatchResult, SchemaSha, CommitSha, OrderedPatches, OrderedPatchesMetadata, PatchReadError, SourcesSha } from "./ValOps.js";
+import { AuthorId, BaseSha, BinaryFileType, GenericErrorMessage, MetadataOfType, OpsMetadata, PreparedCommit, ValOps, ValOpsOptions, WithGenericError, SaveSourceFilePatchResult, SchemaSha, CommitSha, OrderedPatches, OrderedPatchesMetadata, SourcesSha } from "./ValOps.js";
 import { Patch, ParentRef, ValCommit } from "@valbuild/shared/internal";
-import { ParentPatchId } from "@valbuild/core";
 import { Buffer } from "buffer";
 export declare class ValOpsFS extends ValOps {
     private readonly contentUrl;
@@ -14,6 +13,20 @@ export declare class ValOpsFS extends ValOps {
      * content lives behind a thunk that `JSON.stringify` drops).
      */
     private readonly jsonEntryFilesFingerprint;
+    /**
+     * Unpublished changes repair threw away, waiting to be told to somebody.
+     *
+     * Held here and drained by the next `getStat`, because stat is the channel
+     * that always flows. The case worth reporting is a repair that removed
+     * EVERYTHING - which is what an old store looks like - and then there is
+     * nothing left for the studio to fetch, so a notice riding on `fetchPatches`
+     * would never be collected. Drained rather than kept, because this has to be
+     * said once: a permanent flag would put a toast on the screen forever.
+     *
+     * Held in memory only: a restart loses it, and that is the right trade. The
+     * durable record is `patches.repair.log`.
+     */
+    private readonly removedPatchNotices;
     onInit(): Promise<void>;
     getPresignedAuthNonce(project: string, corsOrigin: string, auth: {
         pat: string;
@@ -50,6 +63,10 @@ export declare class ValOpsFS extends ValOps {
         schemaSha: SchemaSha;
         sourcesSha: SourcesSha;
         patches: PatchId[];
+        removed?: {
+            patchId: PatchId;
+            reason: string;
+        }[];
         jsonEntriesSha?: string;
     } | {
         type: "use-websocket";
@@ -67,23 +84,39 @@ export declare class ValOpsFS extends ValOps {
         unauthorized?: boolean;
         networkError?: boolean;
     }>;
-    private readPatches;
-    getParentPatchIdFromParentRef(parentRef: ParentRef): ParentPatchId;
+    /**
+     * The one read every other read comes out of.
+     *
+     * `getStat` announces from this and `fetchPatches` delivers from this, so the
+     * two cannot disagree. They used to: `getStat` counted the directories on disk
+     * while `fetchPatches` walked the parent links between them, and when a single
+     * record went missing the first said 410 and the second said 359 — with no
+     * error anywhere, because a walk that runs out of links just stops.
+     *
+     * Anything wrong is reported, then repaired, and reset only if repair does not
+     * settle it. In that order, and never silently.
+     */
+    private readStore;
+    /**
+     * Report, repair, and reset only if repair did not take.
+     *
+     * Reached only when something is actually wrong, so the healthy path — which
+     * is every stat poll — never touches the lock.
+     */
+    private repairStore;
     fetchPatches<ExcludePatchOps extends boolean>(filters: {
         patchIds?: PatchId[];
         excludePatchOps: ExcludePatchOps;
     }): Promise<ExcludePatchOps extends true ? OrderedPatchesMetadata : OrderedPatches>;
-    fetchPatchesFromFS<ExcludePatchOps extends boolean>(excludePatchOps: ExcludePatchOps): Promise<ExcludePatchOps extends true ? FSPatchesMetadata : FSPatches>;
-    private createPatchChain;
     private parseJsonFile;
-    protected saveSourceFilePatch(path: ModuleFilePath, patch: Patch, patchId: PatchId, parentRef: ParentRef, authorId: AuthorId | null, sessionId: string | null): Promise<SaveSourceFilePatchResult>;
+    protected saveSourceFilePatch(path: ModuleFilePath, patch: Patch, patchId: PatchId, _parentRef: ParentRef, authorId: AuthorId | null, sessionId: string | null): Promise<SaveSourceFilePatchResult>;
     protected getSourceFile(path: string): Promise<WithGenericError<{
         data: string;
     }>>;
     protected saveSourceFile(path: ModuleFilePath, data: string): Promise<WithGenericError<{
         path: ModuleFilePath;
     }>>;
-    saveBase64EncodedBinaryFileFromPatch(filePath: string, parentRef: ParentRef, patchId: PatchId, data: string | null, _type: BinaryFileType, metadata: MetadataOfType<BinaryFileType> | undefined): Promise<WithGenericError<{
+    saveBase64EncodedBinaryFileFromPatch(filePath: string, _parentRef: ParentRef, patchId: PatchId, data: string | null, _type: BinaryFileType, metadata: MetadataOfType<BinaryFileType> | undefined): Promise<WithGenericError<{
         patchId: PatchId;
         filePath: string;
     }>>;
@@ -104,7 +137,6 @@ export declare class ValOpsFS extends ValOps {
     deleteAllPatches(): Promise<{
         error?: GenericErrorMessage;
     }>;
-    private updateOrderedPatches;
     saveOrUploadFiles(preparedCommit: PreparedCommit, mode: "skip-remote" | "upload-remote", auth?: {
         apiKey: string;
     } | {
@@ -118,33 +150,10 @@ export declare class ValOpsFS extends ValOps {
     }>;
     getBinaryFile(filePath: string): Promise<Buffer | null>;
     protected getBinaryFileMetadata<T extends BinaryFileType>(filePath: string, type: T): Promise<OpsMetadata<T>>;
-    private getParentPatchIdFromPatchId;
-    private getParentPatchIdFromPatchIdMap;
     private getPatchesDir;
-    private getFullPatchDir;
-    private getBinaryFilePath;
-    private getBinaryFileMetadataPath;
-    private getPatchFilePath;
-    private getPatchBaseFile;
+    /**
+     * Deliberately outside the patches directory: delete-all and reset rename that
+     * whole directory, and a lock that moves away with it is not holding anything.
+     */
+    private getPatchLockFile;
 }
-type FSPatches = {
-    patches: Record<PatchId, {
-        path: ModuleFilePath;
-        patch: Patch;
-        parentRef: ParentRef;
-        createdAt: string;
-        authorId: AuthorId | null;
-        baseSha: BaseSha;
-        appliedAt: null;
-    }>;
-    error?: GenericErrorMessage;
-    errors?: PatchReadError[];
-};
-type FSPatchesMetadata = {
-    patches: Record<PatchId, Omit<FSPatches["patches"][PatchId], "patch"> & {
-        patch?: undefined;
-    }>;
-    error?: GenericErrorMessage;
-    errors?: FSPatches["errors"];
-};
-export {};

package/dist/declarations/src/createFixPatch.d.ts

@@ -1,8 +1,19 @@
 import { FileMetadata, ImageMetadata, SerializedSchema, Source, SourcePath, ValidationError } from "@valbuild/core";
-import { Patch } from "@valbuild/core/patch";
+import { JSONValue, Patch } from "@valbuild/core/patch";
 export type FixPatchRemainingError = ValidationError & {
     sourcePath?: SourcePath;
 };
+/**
+ * A whole media value, for the fixes that replace one outright.
+ *
+ * The three remote fixes each wrote this shape out by hand, and one of them was
+ * left behind when the shape changed. One name, so the next change cannot miss a
+ * site.
+ *
+ * `path` last is deliberate: it is the field the fix is about, and a stray
+ * `path` inside the metadata must not win over it.
+ */
+export declare function mediaValue(path: string, metadata: unknown): Record<string, JSONValue>;
 export declare function createFixPatch(config: {
     projectRoot: string;
     remoteHost: string;

package/dist/declarations/src/fixHandlers.d.ts

@@ -0,0 +1,162 @@
+/**
+ * The fix handlers behind `val validate --fix`, and the editor quick fixes that
+ * must agree with it.
+ *
+ * ## Why this lives in `@valbuild/server`
+ *
+ * A fix is two layers. `createFixPatch` is the second: given a validation
+ * error it produces a patch. The first is everything that has to happen before a
+ * patch can be produced — read the file, check it is actually on disk, extract
+ * metadata, pick a remote bucket, upload the bytes, download them back. That
+ * layer used to live in `packages/cli/src/runValidation.ts`, which made it
+ * reachable only from the CLI: `@valbuild/cli` exports nothing but `./cli`, and
+ * `@valbuild/language-server` cannot depend on it anyway without creating a
+ * cycle (the CLI depends on the language server).
+ *
+ * The consequence was that an editor could offer the fixes needing no
+ * precondition and had to reimplement or skip the rest. Both happened: the
+ * VS Code extension grew its own remote-upload client, and the language server
+ * declined to offer remote fixes at all.
+ *
+ * So the layer sits here, next to `createFixPatch`, and the CLI and the language
+ * server are both callers. {@link FixHandlerContext} is deliberately made of
+ * things any caller already has — a `Service`, an `IValFSHost`, a project root —
+ * rather than of CLI concepts.
+ *
+ * What stays in the CLI is the driver: the `runValidation` async generator that
+ * walks every module, decides what to report, and renders it to a terminal.
+ */
+import { ModuleFilePath, SourcePath, ValidationFix } from "@valbuild/core";
+import type { Service } from "./Service.js";
+import type { IValFSHost } from "./ValFSHost.js";
+export type { IValFSHost };
+export type IValRemote = {
+    remoteHost: string;
+    getSettings(projectName: string, options: {
+        pat: string;
+    }): Promise<{
+        success: true;
+        data: {
+            publicProjectId: string;
+            remoteFileBuckets: {
+                bucket: string;
+            }[];
+        };
+    } | {
+        success: false;
+        message: string;
+    }>;
+    uploadFile(project: string, bucket: string, fileHash: string, fileExt: string | undefined, fileBuffer: Buffer, options: {
+        pat: string;
+    }): Promise<{
+        success: true;
+    } | {
+        success: false;
+        error: string;
+    }>;
+};
+export type ValModule = Awaited<ReturnType<Service["get"]>>;
+export type ValidationError = {
+    message: string;
+    value?: unknown;
+    fixes?: ValidationFix[];
+    keyError?: boolean;
+};
+export type FixHandlerContext = {
+    sourcePath: SourcePath;
+    validationError: ValidationError;
+    valModule: ValModule;
+    projectRoot: string;
+    fix: boolean;
+    service: Service;
+    valFiles: string[];
+    moduleFilePath: ModuleFilePath;
+    file: string;
+    fs: IValFSHost;
+    remoteFiles: Record<SourcePath, {
+        ref: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    publicProjectId?: string;
+    remoteFileBuckets?: string[];
+    remoteFilesCounter: number;
+    remote: IValRemote;
+    project: string | undefined;
+};
+export type FixHandlerResult = {
+    success: boolean;
+    errorMessage?: string;
+    shouldApplyPatch?: boolean;
+    appliedFix?: boolean;
+    fixableErrorMessage?: string;
+    publicProjectId?: string;
+    remoteFileBuckets?: string[];
+    remoteFilesCounter?: number;
+    events?: ValidationEvent[];
+};
+export type FixHandler = (ctx: FixHandlerContext) => Promise<FixHandlerResult>;
+export type ValidationEvent = {
+    type: "file-valid";
+    file: string;
+    durationMs: number;
+} | {
+    type: "file-error-count";
+    file: string;
+    errorCount: number;
+    durationMs: number;
+} | {
+    type: "validation-error";
+    sourcePath: string;
+    message: string;
+    keyError?: boolean;
+} | {
+    type: "validation-fixable-error";
+    sourcePath: string;
+    message: string;
+    fixable: boolean;
+    keyError?: boolean;
+} | {
+    type: "unknown-fix";
+    sourcePath: string;
+    fixes: string[];
+    keyError?: boolean;
+} | {
+    type: "unregistered-module";
+    file: string;
+} | {
+    type: "fix-applied";
+    file: string;
+    sourcePath: string;
+} | {
+    type: "fatal-error";
+    file: string;
+    message: string;
+} | {
+    type: "remote-uploading";
+    ref: string;
+} | {
+    type: "remote-uploaded";
+    ref: string;
+} | {
+    type: "remote-already-uploaded";
+    filePath: string;
+} | {
+    type: "remote-downloading";
+    sourcePath: string;
+} | {
+    type: "summary-errors";
+    count: number;
+} | {
+    type: "summary-success";
+};
+export declare function handleFileMetadata(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleRemoteFileUpload(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleRemoteGalleryFileUpload(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleRemoteFileDownload(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleRemoteFileCheck(): Promise<FixHandlerResult>;
+export declare function handleUniqueFolderCheck(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleCheckAllFiles(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleJsonValuesExtractEntry(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare const currentFixHandlers: Record<Exclude<ValidationFix, "keyof:check-keys" | "router:check-route">, FixHandler>;
+export declare const fixHandlers: Record<string, FixHandler>;
+export declare function createDefaultValFSHost(): IValFSHost;

package/dist/declarations/src/getValidationErrorFileRef.d.ts

@@ -1,2 +1,8 @@
 import { ValidationError } from "@valbuild/core";
+/**
+ * The media path a validation error is about, if it is about media at all.
+ *
+ * There is no schema in hand here — a `ValidationError` carries only the value
+ * it flagged — so the shape is all there is to go on.
+ */
 export declare function getValidationErrorFileRef(validationError: ValidationError): string | null;

package/dist/declarations/src/index.d.ts

@@ -11,6 +11,8 @@ export { formatSyntaxErrorTree } from "./patch/ts/syntax.js";
 export { analyzeValModule } from "./patch/ts/valModule.js";
 export type { ValModuleAnalysis } from "./patch/ts/valModule.js";
 export { createFixPatch } from "./createFixPatch.js";
+export { fixHandlers, currentFixHandlers, createDefaultValFSHost, handleFileMetadata, handleRemoteFileUpload, handleRemoteGalleryFileUpload, handleRemoteFileDownload, handleRemoteFileCheck, handleUniqueFolderCheck, handleCheckAllFiles, handleJsonValuesExtractEntry, } from "./fixHandlers.js";
+export type { FixHandler, FixHandlerContext, FixHandlerResult, IValRemote, ValidationEvent, ValidationError, ValModule, } from "./fixHandlers.js";
 export * from "./jwt.js";
 export type { ValServer } from "./ValServer.js";
 export { getSettings } from "./getSettings.js";
@@ -36,3 +38,10 @@ export { formatPatchSourceError } from "./ValOps.js";
 export { compareWithCapturedReport, readCapturedReport, replaySnapshot, } from "./debug/replaySnapshot.js";
 export type { ReplayComparison, ReplayResult } from "./debug/replaySnapshot.js";
 export type { OrderedPatches, PatchAnalysis, PatchSourceError, PreparedCommit, } from "./ValOps.js";
+/**
+ * The local-dev patch store, exported so the CLI's debug tooling can read a
+ * snapshot back with the same code the server uses rather than a second
+ * implementation of the layout.
+ */
+export { readPatchStore, describePatchStoreProblems } from "./patchStore.js";
+export type { PatchStoreEntry, PatchStoreProblem, ReadPatchStoreResult, } from "./patchStore.js";

package/dist/declarations/src/patch/ts/syntax.d.ts

@@ -37,19 +37,5 @@ export declare function deepValidateExpression(value: ts.Expression): result.Res
  */
 export declare function evaluateExpression(value: ts.Expression): result.Result<JSONValue, ValSyntaxErrorTree>;
 export declare function findObjectPropertyAssignment(value: ts.ObjectLiteralExpression, key: string): result.Result<LiteralPropertyAssignment | undefined, ValSyntaxErrorTree>;
-export declare function isValFileMethodCall(node: ts.Expression): node is ts.CallExpression;
-export declare function isValImageMethodCall(node: ts.Expression): node is ts.CallExpression;
-export declare function isValRemoteMethodCall(node: ts.Expression): node is ts.CallExpression;
-export declare function findValFileNodeArg(node: ts.CallExpression): result.Result<ts.StringLiteral, ValSyntaxErrorTree>;
-export declare function findValRemoteNodeArg(node: ts.CallExpression): result.Result<ts.StringLiteral, ValSyntaxErrorTree>;
-export declare function findValImageNodeArg(node: ts.CallExpression): result.Result<ts.StringLiteral, ValSyntaxErrorTree>;
-export declare function findValFileMetadataArg(node: ts.CallExpression): result.Result<ts.ObjectLiteralExpression | undefined, ValSyntaxErrorTree>;
-export declare function findValImageMetadataArg(node: ts.CallExpression): result.Result<ts.ObjectLiteralExpression | undefined, ValSyntaxErrorTree>;
-export declare function findValRemoteMetadataArg(node: ts.CallExpression): result.Result<ts.ObjectLiteralExpression | undefined, ValSyntaxErrorTree>;
-/**
- * Given a list of expressions, validates that all the expressions are not
- * spread elements. In other words, it ensures that the expressions are the
- * initializers of the values at their respective indices in the evaluated list.
- */
 export declare function validateInitializers(nodes: ReadonlyArray<ts.Expression>): ValSyntaxErrorTree | undefined;
 export {};

package/dist/declarations/src/patchLog.d.ts

@@ -0,0 +1,124 @@
+import { ModuleFilePath, PatchId } from "@valbuild/core";
+/**
+ * The order of the pending patches, held in one flat, append-only text file.
+ *
+ * ## Why a log and not links between the patches
+ *
+ * The store this replaces kept the order in the patches themselves: every record
+ * carried a `parentRef`, and the directory a record lived in was named after that
+ * parent. Reading the chain meant walking those links from `head`, and the walk
+ * stopped dead — silently — at the first id nothing on disk answered for.
+ *
+ * That is not a hypothetical. A store with 410 patches lost exactly one record,
+ * and the 51 patches written after it became unreachable: `/stat` counted the
+ * directories and announced 410, `GET /patches` walked the links and delivered
+ * 359, and the studio waited forever for 51 ids that no longer had a path back to
+ * `head`. One missing file cost every edit made after it.
+ *
+ * So the order lives in one place and the patches reference nothing. A patch
+ * directory is self-contained data; this file says what order the directories go
+ * in. Removing a line cannot orphan the lines below it, because there is nothing
+ * below it to orphan — the entry after a dropped one is simply next.
+ *
+ * ## Why text
+ *
+ * It is read by people during exactly the incidents that make it interesting, and
+ * `cat` should be enough. One entry per line, whitespace-separated, id first:
+ *
+ * ```
+ * val-patch-log v1
+ * 659b8cfa-065c-47d1-8d82-fc69a2ac72a9 2026-08-27T11:46:13.730Z /content/authors.val.ts
+ * ```
+ *
+ * Position in the file IS the order. There is deliberately no sequence number:
+ * a number stored beside the thing it describes is a number that can disagree
+ * with it, and then something has to decide which one lies.
+ *
+ * The timestamp and path are there to make the file readable, not to be believed
+ * — `patch.json` owns those fields. Nothing here is a second copy of state that
+ * anything reads back.
+ */
+export declare const PATCH_LOG_FILE_NAME = "patches.log";
+export type PatchLogEntry = {
+    patchId: PatchId;
+    createdAt: string;
+    path: ModuleFilePath;
+};
+/**
+ * Something that is wrong with the file but does not stop it being read.
+ *
+ * Reported rather than thrown, because a log that is 99% intact is worth reading
+ * and then repairing. Only a file that cannot be understood at all is fatal, and
+ * that is a `status` on the read result, not a problem in this list.
+ */
+export type PatchLogProblem = {
+    type: "missing-header";
+    /** What stood where the header should have been. */
+    firstLine: string;
+} | {
+    type: "unsupported-version";
+    header: string;
+} | {
+    type: "unparseable-line";
+    lineNumber: number;
+    line: string;
+} | {
+    type: "duplicate-entry";
+    patchId: PatchId;
+    lineNumber: number;
+}
+/**
+ * A final line with no newline after it: a write that did not finish.
+ *
+ * Discarded rather than guessed at, and only ever possible on the LAST line —
+ * appends are serialized by the patch lock, so no other writer can have got in
+ * behind an interrupted one.
+ */
+ | {
+    type: "torn-final-line";
+    line: string;
+};
+export type ReadPatchLogResult = {
+    status: "ok";
+    entries: PatchLogEntry[];
+    problems: PatchLogProblem[];
+}
+/** No log file at all — an empty store, not a broken one. */
+ | {
+    status: "absent";
+} | {
+    status: "unreadable";
+    message: string;
+};
+export declare function formatPatchLogLine(entry: PatchLogEntry): string;
+/**
+ * Split on the first two runs of whitespace only: a module file path may contain
+ * spaces, and it is last precisely so that it can.
+ */
+export declare function parsePatchLogLine(line: string): PatchLogEntry | null;
+export declare function serializePatchLog(entries: readonly PatchLogEntry[]): string;
+export declare function readPatchLog(logFilePath: string): ReadPatchLogResult;
+export declare function parsePatchLog(raw: string): ReadPatchLogResult;
+/**
+ * Add one entry to the end of the log.
+ *
+ * A single `writeSync` on an append-only descriptor, then fsync: the whole line
+ * reaches the file or none of it does, and a reader that catches it mid-flight
+ * discards the partial last line rather than misreading it.
+ *
+ * Callers must hold the patch lock. That is what makes "the torn line can only be
+ * the last one" true, and it is why this does not try to be safe against
+ * concurrent appends on its own.
+ */
+export declare function appendPatchLogEntry(logFilePath: string, entry: PatchLogEntry): void;
+/**
+ * Replace the log wholesale — used by delete and by repair.
+ *
+ * Write a sibling temp file, fsync it, then rename over the original: a rename is
+ * atomic, so a reader either sees the old log or the new one and never a
+ * half-rewritten file. In-place truncation would have a window where the log is
+ * short and the store looks like it lost patches.
+ *
+ * Callers must hold the patch lock.
+ */
+export declare function writePatchLogFile(logFilePath: string, entries: readonly PatchLogEntry[]): void;