@valbuild/server 0.97.3 → 0.97.5

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

@@ -1,5 +1,8 @@
 import { FileMetadata, ImageMetadata, SerializedSchema, Source, SourcePath, ValidationError } from "@valbuild/core";
 import { Patch } from "@valbuild/core/patch";
+export type FixPatchRemainingError = ValidationError & {
+    sourcePath?: SourcePath;
+};
 export declare function createFixPatch(config: {
     projectRoot: string;
     remoteHost: string;
@@ -10,7 +13,7 @@ export declare function createFixPatch(config: {
     };
 }, moduleSource?: Source, moduleSchema?: SerializedSchema): Promise<{
     patch: Patch;
-    remainingErrors: ValidationError[];
+    remainingErrors: FixPatchRemainingError[];
 } | undefined>;
 export declare function getImageMetadata(projectRoot: string, validationError: ValidationError): Promise<ImageMetadata>;
 export declare function getFileMetadata(projectRoot: string, validationError: ValidationError): Promise<FileMetadata>;

package/dist/declarations/src/debug/replaySnapshot.d.ts

@@ -0,0 +1,54 @@
+import { ModuleFilePath, PatchId } from "@valbuild/core";
+/**
+ * Replays a `val debug` snapshot: applies its patches the way /save does and
+ * validates the result.
+ *
+ * A snapshot is a minimal Val project (the modules the patches touch plus the
+ * ones they reference, a generated val.modules.ts, and the patch chain under
+ * .val/patches), so replaying it is just a ValOpsFS pointed at the directory -
+ * no snapshot-specific code paths, which is the point: if the replay reproduces
+ * the bug, the bug is in the ordinary code.
+ */
+export type ReplayResult = {
+    patches: {
+        patchId: PatchId;
+        moduleFilePath: ModuleFilePath;
+        createdAt: string;
+        authorId: string | null;
+        /** The error, if this patch could not be applied. */
+        error?: string;
+    }[];
+    unappliablePatches: Record<PatchId, {
+        moduleFilePath: ModuleFilePath;
+        message: string;
+    }>;
+    sourceFilePatchErrors: Record<ModuleFilePath, string[]>;
+    binaryFilePatchErrors: Record<string, {
+        message: string;
+    }>;
+    validationErrors: Record<string, unknown>;
+    /** What the source files look like with the appliable patches applied. */
+    patchedSourceFiles: Record<string, string>;
+    hasErrors: boolean;
+};
+export type ReplayComparison = {
+    /** Patch ids that failed at capture time and still fail. */
+    stillFailing: string[];
+    /** Patch ids that failed at capture time but apply now (a fix, or a drift). */
+    nowApplying: string[];
+    /** Patch ids that apply at capture time but fail now (a regression). */
+    newlyFailing: string[];
+    reproduced: boolean;
+};
+export declare function replaySnapshot(snapshotDir: string): Promise<ReplayResult>;
+/**
+ * Compares a replay against the report captured when the snapshot was taken, so
+ * "reproduced the customer's bug" is distinguishable from "behaves differently
+ * on this version".
+ */
+export declare function compareWithCapturedReport(result: ReplayResult, capturedReport: {
+    unappliablePatches?: Record<string, unknown>;
+}): ReplayComparison;
+export declare function readCapturedReport(snapshotDir: string): {
+    unappliablePatches?: Record<string, unknown>;
+} | null;

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

@@ -1,4 +1,3 @@
-export type { ServiceOptions } from "./Service.js";
 export { createService, Service } from "./Service.js";
 export { createValApiRouter, createValServer, safeReadGit } from "./ValRouter.js";
 export { ValModuleLoader } from "./ValModuleLoader.js";
@@ -15,3 +14,12 @@ export type { ValServer } from "./ValServer.js";
 export { getSettings } from "./getSettings.js";
 export { getPersonalAccessTokenPath, parsePersonalAccessTokenFile, } from "./personalAccessTokens.js";
 export { uploadRemoteFile } from "./uploadRemoteFile.js";
+export { createModulePathMap, getModulePathRange } from "./modulePathMap.js";
+export type { ModulePathMap } from "./modulePathMap.js";
+export { ValOpsFS } from "./ValOpsFS.js";
+export { ValOpsHttp } from "./ValOpsHttp.js";
+export { loadValModules } from "./loadValModules.js";
+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";

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

@@ -0,0 +1,23 @@
+import type { ValModules } from "@valbuild/core";
+/**
+ * Loads the project's root `val.modules.ts` (or `.js`) using Node's `vm`
+ * module and returns its default export (a `ValModules` registry).
+ *
+ * This is a recursive CommonJS loader: the root modules file and every
+ * relative `*.val.ts` / `val.config.ts` it (dynamically) imports are
+ * transpiled to CommonJS and evaluated in a `vm` sandbox. Bare specifiers
+ * (e.g. `@valbuild/core`) are resolved with the real Node `require` so the
+ * user modules share the exact same `@valbuild/core` instance that
+ * `extractValModules` uses.
+ *
+ * Mirrors the pattern already used by the CLI's `evalValConfigFile`.
+ *
+ * SECURITY: The `vm` context is NOT a security sandbox. It deliberately exposes
+ * `process` and a `require` that falls back to the real Node resolver (so user
+ * modules share the same `@valbuild/core` instance). This loader must therefore
+ * only ever be used to evaluate the project's own first-party, trusted files
+ * (`val.modules` and the local `*.val.ts`/`val.config.ts` it imports) — i.e. the
+ * same trust level as running the project's build. It must never be used to
+ * evaluate untrusted or third-party modules.
+ */
+export declare function loadValModules(projectRoot: string): ValModules;

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

@@ -0,0 +1,25 @@
+import ts from "typescript";
+export type ModulePathMap = {
+    [modulePath: string]: {
+        children: ModulePathMap;
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+};
+export declare function getModulePathRange(modulePath: string, modulePathMap: ModulePathMap, target?: "key" | "value"): {
+    start: {
+        line: number;
+        character: number;
+    };
+    end: {
+        line: number;
+        character: number;
+    };
+} | undefined;
+export declare function createModulePathMap(sourceFile: ts.SourceFile): ModulePathMap | undefined;

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

@@ -2,7 +2,6 @@ import { Patch, PatchError } from "@valbuild/core/patch";
 import { result } from "@valbuild/core/fp";
 import { type ValSyntaxErrorTree } from "./patch/ts/syntax.js";
 import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
-import { QuickJSRuntime } from "quickjs-emscripten";
 import ts from "typescript";
-export declare const patchValFile: (id: string, rootDir: string, patch: Patch, sourceFileHandler: ValSourceFileHandler, runtime: QuickJSRuntime) => Promise<void>;
+export declare const patchValFile: (id: string, rootDir: string, patch: Patch, sourceFileHandler: ValSourceFileHandler) => Promise<void>;
 export declare const patchSourceFile: (sourceFile: ts.SourceFile | string, patch: Patch) => result.Result<ts.SourceFile, ValSyntaxErrorTree | PatchError>;