@valbuild/server 0.146.4 → 0.148.0

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

@@ -4,7 +4,8 @@ import { JSONValue, ParentRef, Patch, PatchError } from "@valbuild/core/patch";
 import type { HistoryError } from "./history/HistoryError.js";
 import type { PlanRefusalErrorT } from "@valbuild/shared/internal";
 import type { AffectedFile, StoredModuleVersion, CommitPage, CommitPatch, HistoricalCommit } from "./history/types.js";
-import { ValSyntaxError, ValSyntaxErrorTree } from "./patch/ts/syntax.js";
+import { type RemoteFilesCheck, type RemoteNetwork } from "./remoteFileCheck.js";
+import type { ValSyntaxError, ValSyntaxErrorTree } from "./patch/ts/syntax.js";
 import { ParentPatchId } from "@valbuild/core";
 import type { ReifiedPreview } from "@valbuild/core";
 import { ValCommit, ValDeployment } from "@valbuild/shared/internal";
@@ -382,7 +383,14 @@ export declare abstract class ValOps {
      * are absent. `/sources/~` overlays the two for exactly this reason.
      */
     getSourcesWithPatchesApplied(analysis: PatchAnalysis & OrderedPatches): Promise<Awaited<ReturnType<ValOps["getSources"]>>>;
-    validateSources(schemas: Schemas, sources: Sources, patchesByModule?: PatchAnalysis["patchesByModule"]): Promise<{
+    validateSources(schemas: Schemas, sources: Sources, patchesByModule?: PatchAnalysis["patchesByModule"], 
+    /**
+     * Validate only these modules. The snapshot the cross-module checks read
+     * (a keyOf's keys, a route, a set's directory) is still built from every
+     * module, which is what makes checking one module at a time give the same
+     * answer for it as checking them all. Wins over `patchesByModule`.
+     */
+    onlyModules?: readonly ModuleFilePath[]): Promise<{
         errors: Record<ModuleFilePath, {
             invalidSource?: {
                 message: string;
@@ -392,7 +400,19 @@ export declare abstract class ValOps {
         files: Record<SourcePath, FileSource>;
         remoteFiles: Record<SourcePath, MediaSource>;
     }>;
-    validateRemoteFiles(schemas: Schemas, sources: Sources, remoteFiles: Record<SourcePath, MediaSource>): Promise<Record<SourcePath, ValidationError[]>>;
+    /**
+     * The remote values `validateSources` set aside, checked: is each ref
+     * sound, and does its host serve it. See `checkRemoteFiles`.
+     *
+     * `fileLastUpdatedByPatchId` names the refs whose bytes are still in a
+     * pending patch, which the host will not have until publish.
+     */
+    validateRemoteFiles(schemas: Schemas, sources: Sources, remoteFiles: Record<SourcePath, MediaSource>, fileLastUpdatedByPatchId?: PatchAnalysis["fileLastUpdatedByPatchId"], network?: RemoteNetwork): Promise<RemoteFilesCheck>;
+    /**
+     * Is a remote file's bytes in a pending patch? `not-pending` when no patch
+     * wrote it; `missing` when one did and its bytes are not there.
+     */
+    pendingBytesOf(fileLastUpdatedByPatchId: PatchAnalysis["fileLastUpdatedByPatchId"]): (ref: string) => Promise<"present" | "missing" | "not-pending">;
     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.
@@ -598,6 +618,17 @@ export declare abstract class ValOps {
      * the ones that create patches and publish.
      */
     abstract readonly requiresAuth: boolean;
+    /**
+     * Which implementation this is, for the routes that differ by mode.
+     *
+     * A tag rather than `instanceof`, because `instanceof ValOpsFS` needs the
+     * class itself, and importing the class imports `fs`: `ValServer` asking
+     * which mode it is in was what put the filesystem and the content-service
+     * client in the module graph of a server that runs in a browser tab (the
+     * demo, `@valbuild/server/browser`). `isFsOps` and friends in `opsKind.ts`
+     * narrow on it with type-only imports.
+     */
+    abstract readonly kind: "fs" | "http" | "memory";
     abstract onInit(baseSha: BaseSha, schemaSha: SchemaSha): Promise<void>;
     abstract fetchPatches<ExcludePatchOps extends boolean>(filters: {
         patchIds?: PatchId[];
@@ -629,13 +660,13 @@ export declare abstract class ValOps {
      * gets this for free; a backend that can take bytes straight through should
      * override it.
      */
-    saveBinaryFileFromPatch(filePath: string, parentRef: ParentRef, patchId: PatchId, bytes: Buffer, mimeType: string, type: "file" | "image", metadata: MetadataOfType<"file" | "image"> | undefined): Promise<WithGenericError<{
+    saveBinaryFileFromPatch(filePath: string, parentRef: ParentRef, patchId: PatchId, bytes: Uint8Array, mimeType: string, type: "file" | "image", metadata: MetadataOfType<"file" | "image"> | undefined): Promise<WithGenericError<{
         patchId: PatchId;
         filePath: string;
     }>>;
-    abstract getBase64EncodedBinaryFileFromPatch(filePath: string, patchId: PatchId, remote: boolean): Promise<Buffer | null>;
+    abstract getBase64EncodedBinaryFileFromPatch(filePath: string, patchId: PatchId, remote: boolean): Promise<Uint8Array | null>;
     protected abstract getBase64EncodedBinaryFileMetadataFromPatch<T extends "file" | "image">(filePath: string, type: T, patchId: PatchId, remote: boolean): Promise<OpsMetadata<T>>;
-    abstract getBinaryFile(filePathOrRef: string): Promise<Buffer | null>;
+    abstract getBinaryFile(filePathOrRef: string): Promise<Uint8Array | null>;
     /**
      * A file's bytes as something a `Range` request can be answered from
      * without reading the rest: a video is seeked in by many small ranges, and
@@ -698,7 +729,7 @@ export declare abstract class ValOps {
     /** Which files the commit touched, and how. Names them; does not fetch them. */
     abstract getCommitAffectedFiles(commitSha: string): Promise<result.Result<AffectedFile[], HistoryError>>;
     /** One file's bytes as they were at one commit. */
-    abstract getFileAtCommit(commitSha: string, filePath: string, remote: boolean): Promise<result.Result<Buffer, HistoryError>>;
+    abstract getFileAtCommit(commitSha: string, filePath: string, remote: boolean): Promise<result.Result<Uint8Array, HistoryError>>;
     /**
      * Where a module lives in the REPOSITORY, as `getFileAtCommit` wants it.
      *
@@ -1007,13 +1038,15 @@ export type OrderedPatchesMetadata = {
     networkError?: boolean;
 };
 export declare function getFieldsForType<T extends BinaryFileType>(type: T): (keyof MetadataOfType<T> & string)[];
-export declare function createMetadataFromBuffer<T extends BinaryFileType>(type: BinaryFileType, mimeType: string, buffer: Buffer): OpsMetadata<T>;
+export declare function createMetadataFromBuffer<T extends BinaryFileType>(type: BinaryFileType, mimeType: string, buffer: Uint8Array): OpsMetadata<T>;
 export declare function guessMimeTypeFromPath(filePath: string): string | null;
-export declare function bufferFromDataUrl(dataUrl: string): Buffer | undefined;
+export declare function bufferFromDataUrl(dataUrl: string, 
+/** Node passes `Buffer`'s, which is faster: this is a whole upload. */
+decodeBase64?: (base64: string) => Uint8Array): Uint8Array | undefined;
 /** A file of known size whose bytes are read a range at a time. */
 export type BinaryFileReader = {
     readonly size: number;
     /** Bytes `start` to `end`, both inclusive, as an HTTP range is. */
-    read(start: number, end: number): Promise<Buffer>;
+    read(start: number, end: number): Promise<Uint8Array>;
 };
-export declare function bufferReader(buffer: Buffer): BinaryFileReader;
+export declare function bufferReader(buffer: Uint8Array): BinaryFileReader;

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

@@ -12,6 +12,7 @@ export declare class ValOpsFS extends ValOps {
     private readonly host;
     /** The developer's own working tree. See {@link ValOps.patchesAreLocal}. */
     readonly patchesAreLocal = true;
+    readonly kind = "fs";
     /**
      * The developer's own machine, where there is no credential to require and
      * nothing to protect it from. See {@link ValOps.requiresAuth}.

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

@@ -43,6 +43,7 @@ export declare class ValOpsHttp extends ValOps {
     private readonly root;
     /** Val's content service owns the store. See {@link ValOps.patchesAreLocal}. */
     readonly patchesAreLocal = false;
+    readonly kind = "http";
     /** See {@link ValOps.requiresAuth}. */
     readonly requiresAuth = true;
     /**

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

@@ -34,7 +34,7 @@ export type StoredFile = {
      * has resolved that before it asks.
      */
     filePath: string;
-    data: Buffer;
+    data: Uint8Array;
     metadata: MetadataOfType<"file" | "image"> | undefined;
 };
 /**
@@ -121,6 +121,14 @@ export type ValOpsMemoryOptions = ValOpsOptions & {
      * startup.
      */
     unsafelyAllowUnauthenticated?: boolean;
+    /**
+     * Whether to warn that the server is unauthenticated. On by default, because
+     * a deployed server serving without authentication is a server anyone can
+     * write to. Off only where nobody else CAN reach it: a server running in a
+     * browser tab (`@valbuild/server/browser`), where the warning would be
+     * printed into a visitor's console about a port that does not exist.
+     */
+    warnUnauthenticated?: boolean;
     /**
      * Val's content host, for pushing remote files at publish.
      *
@@ -168,6 +176,7 @@ export declare class ValOpsMemory extends ValOps {
      * in. Where the two differ is not something a route asks about.
      */
     readonly patchesAreLocal = true;
+    readonly kind = "memory";
     /**
      * Required, unless the host explicitly takes the boundary itself.
      *
@@ -285,9 +294,9 @@ export declare class ValOpsMemory extends ValOps {
         patchId: PatchId;
         filePath: string;
     }>>;
-    getBase64EncodedBinaryFileFromPatch(filePath: string, patchId: PatchId, _remote?: boolean): Promise<Buffer | null>;
+    getBase64EncodedBinaryFileFromPatch(filePath: string, patchId: PatchId, _remote?: boolean): Promise<Uint8Array | null>;
     protected getBase64EncodedBinaryFileMetadataFromPatch<T extends "file" | "image">(filePath: string, type: T, patchId: PatchId, _remote?: boolean): Promise<OpsMetadata<T>>;
-    getBinaryFile(_filePathOrRef: string): Promise<Buffer | null>;
+    getBinaryFile(_filePathOrRef: string): Promise<Uint8Array | null>;
     protected getBinaryFileMetadata<T extends "file" | "image">(_filePath: string, _type: T): Promise<OpsMetadata<T>>;
     listCommits(): Promise<result.Result<CommitPage, HistoryError>>;
     getCommitPatches(): Promise<result.Result<{
@@ -299,7 +308,7 @@ export declare class ValOpsMemory extends ValOps {
         complete: boolean;
     }, HistoryError>>;
     getCommitAffectedFiles(): Promise<result.Result<AffectedFile[], HistoryError>>;
-    getFileAtCommit(): Promise<result.Result<Buffer, HistoryError>>;
+    getFileAtCommit(): Promise<result.Result<Uint8Array, HistoryError>>;
     gitPathOfModule(_moduleFilePath: ModuleFilePath): result.Result<string, HistoryError>;
 }
 /** Kept exported so a host can name the error shape it may get back. */

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

@@ -1,5 +1,5 @@
 import { ValConfig, ValModules } from "@valbuild/core";
-import { ValServerGenericResult } from "@valbuild/shared/internal";
+import type { ValServerGenericResult } from "@valbuild/shared/internal";
 import { ValServer, ValServerCallbacks } from "./ValServer.js";
 type Versions = {
     versions?: {

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

@@ -3,7 +3,8 @@ import { ValModules, ValConfig } from "@valbuild/core";
 import { Api, ServerOf } from "@valbuild/shared/internal";
 import { z } from "zod";
 import { AuthorId, CommitSha, type GenericErrorMessage, type PreparedCommit } from "./ValOps.js";
-import { type ValPatchStore } from "./ValOpsMemory.js";
+import type { ValPatchStore } from "./ValOpsMemory.js";
+import type { ValServerPlatform } from "./platform.js";
 export type ValServerOptions = {
     route: string;
     valEnableRedirectUrl?: string;
@@ -169,7 +170,12 @@ export type ValServerConfig = ValServerOptions & ({
     config: ValConfig;
 });
 export type ValServer = ServerOf<Api>;
-export declare const ValServer: (valModules: ValModules, options: ValServerConfig, callbacks: ValServerCallbacks) => ServerOf<Api>;
+export declare const ValServer: (valModules: ValModules, options: ValServerConfig, callbacks: ValServerCallbacks, 
+/**
+ * The Node-only parts, passed in. `createValServer` passes `nodePlatform`;
+ * the demo passes the browser one. See {@link ValServerPlatform}.
+ */
+platform: ValServerPlatform) => ServerOf<Api>;
 export type ValServerCallbacks = {
     isEnabled: () => Promise<boolean>;
     onEnable: (success: boolean) => Promise<void>;
@@ -190,7 +196,7 @@ export declare const ENABLE_COOKIE_VALUE: {
         readonly sameSite: "lax";
     };
 };
-export declare function bufferToReadableStream(buffer: Buffer): ReadableStream<any>;
+export declare function bufferToReadableStream(buffer: Uint8Array): ReadableStream<any>;
 export declare function getRedirectUrl(query: {
     redirect_to?: string | undefined;
 }, overrideHost: string | undefined): string | {

package/dist/declarations/src/browser/inTabFetch.d.ts

@@ -0,0 +1,27 @@
+import { type ValConfig, type ValModules } from "@valbuild/core";
+import type { ValPatchStore } from "../ValOpsMemory.js";
+/** A `fetch`, as far as the Studio's client calls one. */
+export type InTabFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Val's API, served in this tab: a `fetch` that never touches the network.
+ *
+ * The whole server -- the router's request parsing, `ValServer`'s routes,
+ * memory mode's patch chain -- runs here, exactly as it runs on a server.
+ * What is removed is the hop between them, and nothing else, which is why the
+ * demo built on it cannot drift from the product: there is no second
+ * implementation to drift. See `docs/plans/demo-mode.md`.
+ *
+ * Memory mode with no source files, because nothing here publishes (only a
+ * publish reads `.val.ts` text), and without authentication, because the only
+ * caller is the page this runs in.
+ */
+export declare function createInTabValFetch(valModules: ValModules, options: {
+    config: ValConfig;
+    /**
+     * Where edits live. Memory by default, which is what the demo wants: the
+     * edits last as long as the tab's page does, and a reload starts over.
+     */
+    patchStore?: ValPatchStore;
+    /** The path the Studio's client calls. */
+    route?: string;
+}): InTabFetch;

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

@@ -0,0 +1,9 @@
+/**
+ * `@valbuild/server/browser`: Val's server, for a browser tab.
+ *
+ * Nothing reachable from here may import a Node builtin --
+ * `noNodeFromBrowser.test.ts` walks the graph and fails if one appears. The
+ * Node-only parts of the server reach it through `ValServerPlatform`, and this
+ * entry passes the browser's.
+ */
+export { createInTabValFetch, type InTabFetch } from "./inTabFetch.js";

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

@@ -1,5 +1,16 @@
 import { FileMetadata, ImageMetadata, SerializedFileSchema, SerializedImageSchema } from "@valbuild/core";
-export declare function checkRemoteRef(remoteHost: string, ref: string, projectRoot: string, schema: SerializedImageSchema | SerializedFileSchema, metadata: Record<string, unknown> | undefined): Promise<{
+export declare function checkRemoteRef(
+/**
+ * Unused: a re-derived ref keeps the host it already names (see below).
+ * Kept so the exported signature does not change.
+ */
+_remoteHost: string, ref: string, projectRoot: string, schema: SerializedImageSchema | SerializedFileSchema, metadata: Record<string, unknown> | undefined, 
+/**
+ * Where the bytes come from when the ref has to be re-derived. Defaults to
+ * a download cached under `projectRoot`; the Studio passes one that keeps
+ * nothing on disk (`FixFiles.readRemoteFile`).
+ */
+readRemote?: ReadRemoteFile): Promise<{
     status: "success";
 } | {
     status: "fix-required";
@@ -11,10 +22,37 @@ export declare function checkRemoteRef(remoteHost: string, ref: string, projectR
 }>;
 export declare function getCachedRemoteFileDir(projectRoot: string): string;
 export declare function getCachedRemoteFilePath(fileExt: string, currentFileHash: string, remoteFileCacheDir: string): string;
-export declare function downloadFileFromRemote(ref: string, filePath: string): Promise<{
+/**
+ * A remote file's bytes, and the hash they actually have — which is the one a
+ * re-derived ref is made from, whatever hash the old ref claimed.
+ */
+export type ReadRemoteFile = (ref: string, fileExt: string, expectedFileHash: string) => Promise<{
+    status: "success";
+    fileBuffer: Buffer;
+    fileHash: string;
+    /** Where a download was kept, when it was kept: for error messages. */
+    cachedFilePath?: string;
+} | {
+    status: "error";
+    error: string;
+}>;
+export declare function getFileBufferFromRemote(ref: string, fileExt: string, currentFileHash: string, projectRoot: string): ReturnType<ReadRemoteFile>;
+/**
+ * Download a remote file to `filePath`, from where its ref says -- and, for a
+ * platform ref whose host fails, from the same file on the project's own
+ * `valstart.dev` address, which always serves it (`fallbackRefOf`). The bytes
+ * from the fallback are checked against the ref's file hash before they are
+ * kept: a different host answering is only safe because of that check.
+ *
+ * Rejects with the FIRST host's error when both fail: that is the one the ref
+ * names, and the one a person can recognise.
+ */
+export declare function downloadFileFromRemote(ref: string, filePath: string): ReturnType<typeof downloadFromUrl>;
+declare function downloadFromUrl(ref: string, filePath: string): Promise<{
     status: "success";
     filePath: string;
 } | {
     status: "error";
     error: string;
 }>;
+export {};

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

@@ -1,5 +1,7 @@
 import { FileMetadata, ImageMetadata, VideoMetadata, SerializedSchema, Source, SourcePath, ValidationError } from "@valbuild/core";
 import { JSONValue, Patch } from "@valbuild/core/patch";
+import { type AskHostProject } from "./remoteHostCheck.js";
+import { FixFiles } from "./fixFiles.js";
 export type FixPatchRemainingError = ValidationError & {
     sourcePath?: SourcePath;
 };
@@ -17,6 +19,16 @@ export declare function mediaValue(path: string, metadata: unknown): Record<stri
 export declare function createFixPatch(config: {
     projectRoot: string;
     remoteHost: string;
+    /**
+     * Where a fix reads a file's bytes and puts a downloaded one. Defaults to
+     * the disk under `projectRoot`; see {@link FixFiles}.
+     */
+    files?: FixFiles;
+    /**
+     * How a platform ref's host is asked which project it serves. Defaults
+     * to `GET <host>/_val/project`; tests replace it.
+     */
+    askHostProject?: AskHostProject;
 }, apply: boolean, sourcePath: SourcePath, validationError: ValidationError, remoteFiles: {
     [sourcePath: SourcePath]: {
         ref: string;
@@ -27,6 +39,16 @@ export declare function createFixPatch(config: {
     patch: Patch;
     remainingErrors: FixPatchRemainingError[];
 } | undefined>;
-export declare function getVideoMetadata(projectRoot: string, fileRef: string): Promise<VideoMetadata>;
-export declare function getImageMetadata(projectRoot: string, validationError: ValidationError): Promise<ImageMetadata>;
-export declare function getFileMetadata(projectRoot: string, validationError: ValidationError): Promise<FileMetadata>;
+export declare function getVideoMetadata(files: FixFiles, fileRef: string): Promise<VideoMetadata>;
+export declare function getImageMetadata(files: FixFiles, validationError: ValidationError): Promise<ImageMetadata>;
+export declare function getFileMetadata(files: FixFiles, validationError: ValidationError): Promise<FileMetadata>;
+/**
+ * What an image or file directory's entry records that its bytes disagree
+ * with, as `[field, recorded, actual]`. The one comparison: the CLI's
+ * `*:check-all-files` fix and the Studio's full check both ask it.
+ */
+export declare function mediaDirEntryMismatches(type: "images" | "files", stored: Record<string, unknown>, actual: {
+    width?: number;
+    height?: number;
+    mimeType?: string;
+}): [field: string, recorded: unknown, actual: unknown][];

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

@@ -0,0 +1,42 @@
+import { VideoMetadata } from "@valbuild/core";
+import { type ReadRemoteFile } from "./checkRemoteRef.js";
+/**
+ * Where `createFixPatch` reads a project file's bytes, and where it puts a
+ * remote file it was asked to download.
+ *
+ * Every path is the file's path from the project root, the way a source names
+ * it: `/public/val/logo.png`, never an absolute path on some disk. That is the
+ * point: a project in http mode, or one the platform serves from a Worker, has
+ * no disk to join a path onto, and a fix that reads a file has to work there
+ * too. `diskFixFiles` is the one the CLI and the language server use, and does
+ * exactly what `createFixPatch` did with `fs` before this existed.
+ *
+ * Not yet covered, and still read from `projectRoot` directly: the CLI's
+ * listing of a media directory for files it does not track, and
+ * `videos:check-all-files` (`videosetCheckAllFilesPatch`), which lists one.
+ * See `docs/plans/studio-validate.md`.
+ */
+export type FixFiles = {
+    /** A project file's bytes. Rejects when it cannot be read. */
+    readFile(filePath: string): Promise<Buffer>;
+    /**
+     * A project video's size, length and mime type. Its own method rather than
+     * `readFile` because a video is mostly frames, and the disk reader reads
+     * only the headers.
+     */
+    readVideoMetadata(filePath: string): Promise<VideoMetadata>;
+    /**
+     * A remote file's bytes, for re-deriving a stale ref (`*:check-remote`).
+     * Nothing is stored in the project.
+     */
+    readRemoteFile: ReadRemoteFile;
+    /** Downloads `url` and stores it in the project at `filePath`. */
+    saveRemoteFile(url: string, filePath: string): Promise<{
+        status: "success";
+    } | {
+        status: "error";
+        error: string;
+    }>;
+};
+/** {@link FixFiles} over a project on disk. */
+export declare function diskFixFiles(projectRoot: string): FixFiles;

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

@@ -44,6 +44,8 @@ export type IValRemote = {
             remoteFileBuckets: {
                 bucket: string;
             }[];
+            /** See `getSettings`: the host new refs name. */
+            remoteHost?: string;
         };
     } | {
         success: false;
@@ -134,12 +136,16 @@ export type ValidationEvent = {
     sourcePath: string;
     message: string;
     keyError?: boolean;
+    /** See `isRepairedOnSave`: the Studio would not hold a publish for it. */
+    repairedOnSave?: boolean;
 } | {
     type: "validation-fixable-error";
     sourcePath: string;
     message: string;
     fixable: boolean;
     keyError?: boolean;
+    /** See `isRepairedOnSave`: the Studio would not hold a publish for it. */
+    repairedOnSave?: boolean;
 } | {
     type: "unknown-fix";
     sourcePath: string;
@@ -246,7 +252,15 @@ export declare function handleJsonValuesExtractEntry(ctx: FixHandlerContext): Pr
  * exists to send it there, and to say what `--fix` would do when it is off.
  */
 export declare function handleViewCheckModule(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+/**
+ * `remote:rewrite-host`: a platform ref whose host no longer serves its
+ * project. The server's full check reports it, and so does `createFixPatch`'s
+ * `image:check-remote` branch, which is how `val validate` finds it: that
+ * branch asks the host first. Either way the patch is `createFixPatch`'s, and
+ * needs nothing but the ref -- the new host is derived from it.
+ */
+export declare function handleRemoteRewriteHost(ctx: FixHandlerContext): Promise<FixHandlerResult>;
 export declare function handleExternalUpload(): Promise<FixHandlerResult>;
-export declare const currentFixHandlers: Record<Exclude<ValidationFix, "keyof:check-keys" | "image:check-gallery" | "file:check-gallery" | "video:check-gallery" | "router:check-route" | "locale:check-locale" | "record:fill-keys">, FixHandler>;
+export declare const currentFixHandlers: Record<Exclude<ValidationFix, "keyof:check-keys" | "image:check-gallery" | "file:check-gallery" | "video:check-gallery" | "router:check-route" | "locale:check-locale" | "router:check-locale-param" | "record:fill-keys">, FixHandler>;
 export declare const fixHandlers: Record<string, FixHandler>;
 export declare function createDefaultValFSHost(): IValFSHost;

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

@@ -4,6 +4,7 @@ declare const SettingsSchema: z.ZodObject<{
     remoteFileBuckets: z.ZodArray<z.ZodObject<{
         bucket: z.ZodString;
     }, z.core.$strip>>;
+    remoteHost: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type Settings = z.infer<typeof SettingsSchema>;
 export declare function getSettings(projectName: string, auth: {

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

@@ -19,6 +19,7 @@ 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 { askOncePerHost } from "./remoteHostCheck.js";
 export { fixHandlers, currentFixHandlers, createDefaultValFSHost, handleFileMetadata, handleRemoteFileUpload, handleRemoteGalleryFileUpload, handleRemoteFileDownload, handleRemoteFileCheck, handleUniqueFolderCheck, handleCheckAllFiles, handleJsonValuesExtractEntry, handleExternalUpload, } from "./fixHandlers.js";
 export { handleVideosetMetadata, handleVideosetUploadRemote, handleVideosetCheckRemote, handleVideosetCheckAllFiles, videosetEntryVideoSchema, filesOfVideosetEntry, } from "./videosetFixes.js";
 export type { FixHandler, ModulePatch, FixHandlerContext, FixHandlerResult, IValRemote, ValidationEvent, ValidationError, ValModule, } from "./fixHandlers.js";

package/dist/declarations/src/linkCheck/probeUrl.d.ts

@@ -0,0 +1,40 @@
+import https from "node:https";
+import { type LookupFunction } from "node:net";
+/**
+ * Opening one external URL and reporting what answered.
+ *
+ * Mirrors `ExternalUrlProbeResult` in the Studio - the two are checked against
+ * each other by the API route's zod schema, which is the only place they meet.
+ */
+export type ProbeResult = {
+    kind: "answered";
+    code: number;
+    finalUrl: string;
+    ms: number;
+} | {
+    kind: "unreachable";
+    message: string;
+} | {
+    kind: "timeout";
+    ms: number;
+} | {
+    kind: "skipped";
+    message: string;
+};
+export type ProbeOptions = {
+    /** The whole check, redirects included. */
+    timeoutMs?: number;
+    /** How many redirects to follow before calling it a loop. */
+    maxRedirects?: number;
+    /**
+     * The transport, injected so the redirect and status logic can be tested
+     * without a network. Production passes nothing and gets `node:https`.
+     */
+    request?: typeof https.request;
+    /** Injected for the same reason, and never to relax the address guard. */
+    now?: () => number;
+};
+export declare const DEFAULT_TIMEOUT_MS = 5000;
+export declare const DEFAULT_MAX_REDIRECTS = 5;
+export declare function guardedLookup(lookup: LookupFunction): LookupFunction;
+export declare function probeUrl(rawUrl: string, options?: ProbeOptions): Promise<ProbeResult>;

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

@@ -0,0 +1,55 @@
+import type { ValModules } from "@valbuild/core";
+import type { ValOpsFS } from "./ValOpsFS.js";
+import type { ValOpsHttp } from "./ValOpsHttp.js";
+import type { ValOpsMemory } from "./ValOpsMemory.js";
+import type { ValServerConfig } from "./ValServer.js";
+import type { ResolveRemoteFileAuthResult } from "./valServerConfig.js";
+import type { JwtResult } from "./jwt.js";
+import type { ProbeResult } from "./linkCheck/probeUrl.js";
+import type { checkModuleForStudio, fixForStudio } from "./studioValidation.js";
+/**
+ * What `ValServer` needs from the machine it runs on.
+ *
+ * Everything else in `ValServer` is request handling, and runs anywhere. These
+ * are the parts that reach for Node -- a filesystem, a socket, a keyed hash --
+ * and they are passed in rather than imported so that the same server can run
+ * in a browser tab: the demo (`@valbuild/server/browser`) serves a memory-mode
+ * server to the Studio with no network in between.
+ *
+ * `nodePlatform` is the real one, and `createValServer` passes it. A function
+ * here is whatever an implementation can honestly answer: the browser one has
+ * no filesystem to read a token from, so it answers as a server without one
+ * does.
+ */
+export type ValServerPlatform = {
+    /** Builds the data layer the config asks for. See `createValOps`. */
+    createOps: (valModules: ValModules, options: ValServerConfig) => ValOpsFS | ValOpsHttp | ValOpsMemory;
+    /** Whether an external URL answers. See `linkCheck/probeUrl`. */
+    probeUrl: (url: string) => Promise<ProbeResult>;
+    /** The session cookie's signature. See `jwt.ts`. */
+    jwt: {
+        verifyJwt: (token: string, secretKey: string) => JwtResult;
+        decodeJwtWithoutVerifying: (token: string) => JwtResult;
+        encodeJwt: (payload: object, sessionKey: string) => string;
+        getExpire: () => number;
+    };
+    /**
+     * `bytes` as base64. For the paths that encode every file a publish commits:
+     * Node's `Buffer` is ten times faster than `btoa`, and a browser has only
+     * `btoa` (`bytesToBase64` in `bytes.ts`). Same answer either way.
+     */
+    bytesToBase64: (bytes: Uint8Array) => string;
+    /** The developer's `val login` token. See `readValLoginToken`. */
+    readValLoginToken: (options: ValServerConfig) => Promise<string | null>;
+    /** Which credential talks to the content host. See `resolveRemoteFileAuth`. */
+    resolveRemoteFileAuth: (options: ValServerConfig) => Promise<ResolveRemoteFileAuthResult>;
+    /**
+     * The Studio's full check (`/validate`, `/validate/fix`). It reads files'
+     * bytes and asks remote hosts, so it needs Node; absent in a browser, where
+     * both routes answer that it is not available.
+     */
+    studioValidation?: {
+        checkModuleForStudio: typeof checkModuleForStudio;
+        fixForStudio: typeof fixForStudio;
+    };
+};