@valbuild/server 0.97.2 → 0.97.4

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

@@ -1,29 +1,23 @@
-import { QuickJSRuntime } from "quickjs-emscripten";
 import { Patch } from "@valbuild/core/patch";
-import { ValModuleLoader } from "./ValModuleLoader.js";
 import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
 import { IValFSHost } from "./ValFSHost.js";
 import { SerializedModuleContent } from "./SerializedModuleContent.js";
-import { ModuleFilePath, ModulePath } from "@valbuild/core";
-export type ServiceOptions = {
-    /**
-     * Disable cache for transpilation
-     *
-     * @default false
-     */
-    disableCache?: boolean;
-};
-export declare function createService(projectRoot: string, opts: ServiceOptions, host?: IValFSHost, loader?: ValModuleLoader): Promise<Service>;
+import { ModuleFilePath, ModulePath, extractValModules } from "@valbuild/core";
+export declare function createService(projectRoot: string, host?: IValFSHost): Promise<Service>;
+type ExtractedModules = Awaited<ReturnType<typeof extractValModules>>;
 export declare class Service {
     readonly sourceFileHandler: ValSourceFileHandler;
-    private readonly runtime;
+    private readonly extracted;
     readonly projectRoot: string;
-    constructor(projectRoot: string, sourceFileHandler: ValSourceFileHandler, runtime: QuickJSRuntime);
+    constructor(projectRoot: string, sourceFileHandler: ValSourceFileHandler, extracted: ExtractedModules);
+    /**
+     * The module file paths that are registered in the project's val.modules.
+     */
+    getModuleFilePaths(): ModuleFilePath[];
     get(moduleFilePath: ModuleFilePath, modulePath: ModulePath, options?: {
         validate: boolean;
-        source: boolean;
-        schema: boolean;
     }): Promise<SerializedModuleContent>;
     patch(moduleFilePath: ModuleFilePath, patch: Patch): Promise<void>;
     dispose(): void;
 }
+export {};

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

@@ -0,0 +1,349 @@
+import { FileMetadata, FileSource, ImageMetadata, ModuleFilePath, PatchId, RemoteSource, Schema, SelectorSource, SerializedSchema, Source, SourcePath, ValConfig, ValModules, ValidationError } from "@valbuild/core";
+import { result } from "@valbuild/core/fp";
+import { ParentRef, Patch, PatchError } from "@valbuild/core/patch";
+import { ValSyntaxError, ValSyntaxErrorTree } from "./patch/ts/syntax.js";
+import { ParentPatchId } from "@valbuild/core";
+import { ValCommit, ValDeployment } from "@valbuild/shared/internal";
+import { ReifiedRender } from "@valbuild/core";
+export type BaseSha = string & {
+    readonly _tag: unique symbol;
+};
+export type ConfigSha = string & {
+    readonly _tag: unique symbol;
+};
+export type SourcesSha = string & {
+    readonly _tag: unique symbol;
+};
+export type SchemaSha = string & {
+    readonly _tag: unique symbol;
+};
+export type CommitSha = string & {
+    readonly _tag: unique symbol;
+};
+export type AuthorId = string & {
+    readonly _tag: unique symbol;
+};
+export type ModulesError = {
+    message: string;
+    path?: ModuleFilePath;
+};
+export type Schemas = {
+    [key: ModuleFilePath]: Schema<SelectorSource>;
+};
+export type Sources = {
+    [key: ModuleFilePath]: Source;
+};
+export type ValOpsOptions = {
+    formatter?: (code: string, filePath: string) => string | Promise<string>;
+    statPollingInterval?: number;
+    statFilePollingInterval?: number;
+    disableFilePolling?: boolean;
+    disableFileWatcher?: boolean;
+    config: ValConfig;
+};
+export declare abstract class ValOps {
+    private readonly valModules;
+    protected readonly options?: ValOpsOptions | undefined;
+    /** Sources from val modules, immutable (without patches or anything)  */
+    private sources;
+    /** The sha256 / hash of all sources + all schemas + config */
+    private baseSha;
+    /** The sha256 / hash of all sources */
+    private sourcesSha;
+    /** The sha256 / hash of config */
+    private configSha;
+    /** Schema from val modules, immutable  */
+    private schemas;
+    /** The sha256 / hash of schema + config - if this changes users needs to reload */
+    private schemaSha;
+    private modulesErrors;
+    constructor(valModules: ValModules, options?: ValOpsOptions | undefined);
+    /**
+     * Get the status from Val
+     *
+     * This works differently in ValOpsFS and ValOpsHttp:
+     * - In ValOpsFS (for dev mode) works using long-polling operations since we cannot use WebSockets in the host Next.js server and we do not want to hammer the server with requests (though we could argue that it would be ok in dev, it is not up to our standards as a kick-ass CMS).
+     * - In ValOpsHttp (in production) it returns a WebSocket URL so that the client can connect directly.
+     *
+     * The reason we do not use long polling in production is that Vercel (a very likely host for Next.js), bills by wall time and long polling would therefore be very expensive.
+     */
+    abstract getStat(params: {
+        baseSha: BaseSha;
+        schemaSha: SchemaSha;
+        patches?: PatchId[];
+        profileId?: AuthorId;
+    } | null): Promise<{
+        type: "request-again" | "no-change" | "did-change";
+        baseSha: BaseSha;
+        schemaSha: SchemaSha;
+        sourcesSha: SourcesSha;
+        patches: PatchId[];
+    } | {
+        type: "use-websocket";
+        url: string;
+        nonce: string;
+        baseSha: BaseSha;
+        schemaSha: SchemaSha;
+        commitSha: CommitSha;
+        sourcesSha: SourcesSha;
+        patches: PatchId[];
+    } | {
+        type: "error";
+        error: GenericErrorMessage;
+        unauthorized?: boolean;
+        networkError?: boolean;
+    }>;
+    private initSources;
+    init(): Promise<void>;
+    getBaseSources(): Promise<Sources>;
+    getSchemas(): Promise<Schemas>;
+    getSerializedSchemas(): Promise<Record<ModuleFilePath, SerializedSchema>>;
+    getModuleErrors(): Promise<ModulesError[]>;
+    getBaseSha(): Promise<BaseSha>;
+    getConfigSha(): Promise<ConfigSha>;
+    getSourcesSha(): Promise<SourcesSha>;
+    getSchemaSha(): Promise<SchemaSha>;
+    analyzePatches(sortedPatches: OrderedPatches["patches"], commits?: ValCommit[], currentCommitSha?: CommitSha): PatchAnalysis;
+    getRenders(schemas: Schemas, sources: Sources): Promise<{
+        renders: Record<ModuleFilePath, ReifiedRender | null>;
+    }>;
+    getSources(analysis?: PatchAnalysis & OrderedPatches): Promise<{
+        sources: Sources;
+        errors: Record<ModuleFilePath, {
+            patchId: PatchId;
+            skipped: boolean;
+            error: GenericErrorMessage;
+        }[]>;
+    }>;
+    /**
+     * Every module's source, with the pending patches applied.
+     *
+     * `getSources(analysis)` returns ONLY the modules that had patches, which is
+     * not enough to validate with: cross-module checks (keyOf, router routes)
+     * resolve against other modules' sources and report spurious errors when they
+     * 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<{
+        errors: Record<ModuleFilePath, {
+            invalidSource?: {
+                message: string;
+            };
+            validations: Record<SourcePath, ValidationError[]>;
+        }>;
+        files: Record<SourcePath, FileSource>;
+        remoteFiles: Record<SourcePath, RemoteSource>;
+    }>;
+    validateRemoteFiles(schemas: Schemas, sources: Sources, remoteFiles: Record<SourcePath, RemoteSource>): 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.
+     *
+     * @param options.continueOnError Diagnosis only. By default a patch that
+     * cannot be applied aborts the rest of that module's chain, which is what
+     * /save requires: the commit is refused and nothing is written. With this
+     * flag the failing patch is recorded in `unappliablePatches` and the chain
+     * continues on the unchanged source file, so a single run reports *every*
+     * unappliable patch instead of only the first one per module. The commit is
+     * still refused (`hasErrors` stays true) - this only makes the report
+     * complete.
+     */
+    prepare(patchAnalysis: PatchAnalysis & OrderedPatches, options?: {
+        continueOnError?: boolean;
+    }): Promise<PreparedCommit>;
+    /**
+     * Reads a project file as text at whatever revision this ops instance points
+     * at: the deployed commit in http mode, the working tree in fs mode.
+     *
+     * Public counterpart of `getSourceFile`, for the CLI's debug snapshot. The
+     * snapshot has to capture the exact text `prepare` patches, which in http mode
+     * is NOT the local working copy.
+     */
+    readProjectFile(path: string): Promise<WithGenericError<{
+        data: string;
+    }>>;
+    createPatch(path: ModuleFilePath, patch: Patch, patchId: PatchId, parentRef: ParentRef, sessionId: string | null, authorId: AuthorId | null): Promise<result.Result<{
+        error?: undefined;
+        patchId: PatchId;
+        createdAt: string;
+    }, {
+        errorType: "other";
+        error: GenericErrorMessage;
+    } | {
+        errorType: "patch-head-conflict";
+    }>>;
+    abstract getCommitSummary(preparedCommit: PreparedCommit): Promise<{
+        commitSummary: string | null;
+        error?: undefined;
+    } | {
+        commitSummary?: undefined;
+        error: GenericErrorMessage;
+    }>;
+    abstract onInit(baseSha: BaseSha, schemaSha: SchemaSha): Promise<void>;
+    abstract fetchPatches<ExcludePatchOps extends boolean>(filters: {
+        patchIds?: PatchId[];
+        excludePatchOps: ExcludePatchOps;
+    }): Promise<ExcludePatchOps extends true ? OrderedPatchesMetadata : OrderedPatches>;
+    protected abstract saveSourceFilePatch(path: ModuleFilePath, patch: Patch, patchId: PatchId, parentRef: ParentRef | null, authorId: AuthorId | null, sessionId: string | null): Promise<SaveSourceFilePatchResult>;
+    protected abstract getSourceFile(path: string): Promise<WithGenericError<{
+        data: string;
+    }>>;
+    abstract saveBase64EncodedBinaryFileFromPatch(filePath: string, parentRef: ParentRef, patchId: PatchId, data: string | null, 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>;
+    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>;
+    protected abstract getBinaryFileMetadata<T extends "file" | "image">(filePath: string, type: T): Promise<OpsMetadata<T>>;
+    abstract deletePatches(patchIds: PatchId[]): Promise<{
+        deleted: PatchId[];
+        errors?: undefined;
+        error?: undefined;
+    } | {
+        deleted: PatchId[];
+        errors: Record<PatchId, GenericErrorMessage>;
+    } | {
+        error: GenericErrorMessage;
+        errors?: undefined;
+        deleted?: undefined;
+    }>;
+}
+export type WithGenericError<T extends Record<string, unknown>> = (T & {
+    error?: undefined;
+}) | GenericError;
+export type GenericError = {
+    error: {
+        message: string;
+    };
+};
+export type GenericErrorMessage = {
+    message: string;
+    details?: unknown;
+};
+export type SaveSourceFilePatchResult = result.Result<{
+    patchId: PatchId;
+}, ({
+    errorType: "other";
+} & GenericErrorMessage) | {
+    errorType: "patch-head-conflict";
+}>;
+export type PatchAnalysis = {
+    patchesByModule: {
+        [path: ModuleFilePath]: {
+            patchId: PatchId;
+        }[];
+    };
+    fileLastUpdatedByPatchId: Record<string, {
+        patchId: PatchId;
+        remote: boolean;
+        isDelete: boolean;
+    }>;
+};
+export type PatchSourceError = {
+    message: string;
+    filePath?: string;
+} | PatchError | ValSyntaxError | ValSyntaxErrorTree;
+export declare function formatPatchSourceError(error: PatchSourceError): string;
+export type MetadataOfType<T extends "file" | "image"> = T extends "image" ? Omit<ImageMetadata, "hotspot"> : FileMetadata;
+export type OpsMetadata<T extends "file" | "image"> = {
+    metadata: MetadataOfType<T>;
+    errors?: undefined;
+} | {
+    errors: ((GenericErrorMessage & {
+        field: string;
+    }) | (GenericErrorMessage & {
+        filePath?: string;
+    }))[];
+};
+export type BinaryFileType = "file" | "image";
+export type PreparedCommit = {
+    /**
+     * Updated / new source files that are ready to be committed / saved.
+     * A null value signals that the file at that path should be deleted.
+     */
+    patchedSourceFiles: Record<string, string | null>;
+    /**
+     * Previous source files that were patched
+     */
+    previousSourceFiles: Record<ModuleFilePath, string>;
+    /**
+     * Diagnosis only: what the source file looks like with the appliable patches
+     * applied, for modules that had at least one unappliable patch. Populated
+     * only when `prepare` is called with `continueOnError`. Never committed.
+     */
+    partiallyPatchedSourceFiles: Record<ModuleFilePath, string>;
+    /**
+     * The file path and patch id in which they appear of binary files that are ready to be committed / saved
+     */
+    patchedBinaryFilesDescriptors: Record<string, {
+        patchId: PatchId;
+        remote: boolean;
+    }>;
+    /**
+     * Source file patches that were successfully applied to get to this result
+     */
+    appliedPatches: Record<ModuleFilePath, PatchId[]>;
+    hasErrors: boolean;
+    sourceFilePatchErrors: Record<ModuleFilePath, PatchSourceError[]>;
+    binaryFilePatchErrors: Record<string, {
+        message: string;
+    }>;
+    /**
+     * The patches that could not be applied, keyed by patch id.
+     *
+     * Same information as `sourceFilePatchErrors`, but attributed to the patch
+     * that caused it, which is what a caller needs in order to report or remove
+     * it. Without `continueOnError` this holds the first failing patch of each
+     * module (the rest of that module's chain is never tried); with it, all of
+     * them.
+     */
+    unappliablePatches: Record<PatchId, {
+        moduleFilePath: ModuleFilePath;
+        message: string;
+    }>;
+    skippedPatches: Record<ModuleFilePath, PatchId[]>;
+    triedPatches: Record<ModuleFilePath, PatchId[]>;
+};
+export type PatchErrors = Record<PatchId, GenericErrorMessage>;
+export type PatchReadError = {
+    patchId: PatchId;
+    message: string;
+} | {
+    parentPatchId: ParentPatchId;
+    message: string;
+};
+export type OrderedPatches = {
+    patches: {
+        path: ModuleFilePath;
+        patchId: PatchId;
+        patch: Patch;
+        createdAt: string;
+        authorId: AuthorId | null;
+        baseSha: BaseSha;
+        appliedAt: {
+            commitSha: CommitSha;
+        } | null;
+    }[];
+    commits?: ValCommit[];
+    error?: GenericErrorMessage;
+    errors?: PatchReadError[];
+    unauthorized?: boolean;
+    networkError?: boolean;
+};
+export type OrderedPatchesMetadata = {
+    patches: (Omit<OrderedPatches["patches"][number], "patch"> & {
+        patch?: undefined;
+    })[];
+    commits?: ValCommit[];
+    deployments?: ValDeployment[];
+    error?: GenericErrorMessage;
+    errors?: OrderedPatches["errors"];
+    unauthorized?: boolean;
+    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 getMimeTypeFromBase64(content: string): string | null;
+export declare function guessMimeTypeFromPath(filePath: string): string | null;
+export declare function bufferFromDataUrl(dataUrl: string): Buffer | undefined;

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

@@ -0,0 +1,143 @@
+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 { 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;
+    private readonly rootDir;
+    private static readonly VAL_DIR;
+    private readonly host;
+    constructor(contentUrl: string, rootDir: string, valModules: ValModules, options?: ValOpsOptions);
+    onInit(): Promise<void>;
+    getPresignedAuthNonce(project: string, corsOrigin: string, auth: {
+        pat: string;
+    } | {
+        apiKey: string;
+    }): Promise<{
+        status: "success";
+        data: {
+            nonce: string;
+            baseUrl: string;
+        };
+    } | {
+        status: "error";
+        statusCode: 401 | 500;
+        error: GenericErrorMessage;
+    }>;
+    getCommitSummary(): Promise<{
+        commitSummary: string | null;
+        error?: undefined;
+    } | {
+        commitSummary?: undefined;
+        error: GenericErrorMessage;
+    }>;
+    getStat(params: {
+        baseSha: BaseSha;
+        schemaSha: SchemaSha;
+        sourcesSha: SourcesSha;
+        patches: PatchId[];
+        profileId?: AuthorId;
+    } | null): Promise<{
+        type: "request-again" | "no-change" | "did-change";
+        baseSha: BaseSha;
+        schemaSha: SchemaSha;
+        sourcesSha: SourcesSha;
+        patches: PatchId[];
+    } | {
+        type: "use-websocket";
+        url: string;
+        nonce: string;
+        baseSha: BaseSha;
+        schemaSha: SchemaSha;
+        sourcesSha: SourcesSha;
+        commitSha: CommitSha;
+        commits: ValCommit[];
+        patches: PatchId[];
+    } | {
+        type: "error";
+        error: GenericErrorMessage;
+        unauthorized?: boolean;
+        networkError?: boolean;
+    }>;
+    private readPatches;
+    getParentPatchIdFromParentRef(parentRef: ParentRef): ParentPatchId;
+    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 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<{
+        patchId: PatchId;
+        filePath: string;
+    }>>;
+    protected getBase64EncodedBinaryFileMetadataFromPatch<T extends BinaryFileType>(filePath: string, type: T, patchId: PatchId): Promise<OpsMetadata<T>>;
+    getBase64EncodedBinaryFileFromPatch(filePath: string, patchId: PatchId): Promise<Buffer | null>;
+    deletePatches(patchIds: PatchId[]): Promise<{
+        deleted: PatchId[];
+        errors?: undefined;
+        error?: undefined;
+    } | {
+        deleted: PatchId[];
+        errors: Record<PatchId, GenericErrorMessage>;
+    } | {
+        error: GenericErrorMessage;
+        errors?: undefined;
+        deleted?: undefined;
+    }>;
+    deleteAllPatches(): Promise<{
+        error?: GenericErrorMessage;
+    }>;
+    private updateOrderedPatches;
+    saveOrUploadFiles(preparedCommit: PreparedCommit, mode: "skip-remote" | "upload-remote", auth?: {
+        apiKey: string;
+    } | {
+        pat: string;
+    }): Promise<{
+        updatedFiles: string[];
+        uploadedRemoteRefs: string[];
+        errors: Record<string, GenericErrorMessage & {
+            filePath?: string;
+        }>;
+    }>;
+    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;
+}
+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/ValOpsHttp.d.ts

@@ -0,0 +1,147 @@
+import { type PatchId, type ModuleFilePath, ValModules } from "@valbuild/core";
+import type { Patch as PatchT, ParentRef as ParentRefT } from "@valbuild/core/patch";
+import { type AuthorId, type BaseSha, BinaryFileType, type CommitSha, GenericErrorMessage, MetadataOfType, OpsMetadata, PreparedCommit, ValOps, ValOpsOptions, WithGenericError, SaveSourceFilePatchResult, SchemaSha, OrderedPatchesMetadata, OrderedPatches, SourcesSha } from "./ValOps.js";
+import { z } from "zod";
+import { ParentRef, ValCommit, ValDeployment } from "@valbuild/shared/internal";
+declare const PatchId: z.ZodString & z.ZodType<PatchId, string, z.core.$ZodTypeInternals<PatchId, string>>;
+declare const CommitSha: z.ZodString & z.ZodType<CommitSha, string, z.core.$ZodTypeInternals<CommitSha, string>>;
+declare const BaseSha: z.ZodString & z.ZodType<BaseSha, string, z.core.$ZodTypeInternals<BaseSha, string>>;
+declare const AuthorId: z.ZodString & z.ZodType<AuthorId, string, z.core.$ZodTypeInternals<AuthorId, string>>;
+declare const ModuleFilePath: z.ZodString & z.ZodType<ModuleFilePath, string, z.core.$ZodTypeInternals<ModuleFilePath, string>>;
+export declare class ValOpsHttp extends ValOps {
+    private readonly contentUrl;
+    private readonly project;
+    private readonly commitSha;
+    private readonly branch;
+    private readonly authHeaders;
+    private readonly root;
+    constructor(contentUrl: string, project: string, commitSha: string, // TODO: CommitSha
+    branch: string, 
+    /**
+     * An api key (how the app itself authenticates) or a personal access token
+     * (how the CLI authenticates after `val login`). Same two shapes as
+     * getSettings / uploadRemoteFile / getPresignedAuthNonce.
+     */
+    auth: {
+        apiKey: string;
+    } | {
+        pat: string;
+    }, valModules: ValModules, options?: ValOpsOptions & {
+        /**
+         * Root of project relative to repository.
+         * E.g. if this is a monorepo and the current app is in the /apps/my-app folder,
+         * the root would be /apps/my-app
+         */
+        root?: string;
+    });
+    onInit(): Promise<void>;
+    getPresignedAuthNonce(profileId: string, corsOrigin: string): Promise<{
+        status: "success";
+        data: {
+            nonce: string;
+            baseUrl: string;
+        };
+    } | {
+        status: "error";
+        statusCode: 401 | 500;
+        error: GenericErrorMessage;
+    }>;
+    getCommitSummary(preparedCommit: PreparedCommit): Promise<{
+        commitSummary: string | null;
+        error?: undefined;
+    } | {
+        commitSummary?: undefined;
+        error: GenericErrorMessage;
+    }>;
+    getStat(params: {
+        baseSha: BaseSha;
+        schemaSha: SchemaSha;
+        patches?: PatchId[];
+        profileId?: AuthorId;
+    } | null): Promise<{
+        type: "request-again" | "no-change";
+        baseSha: BaseSha;
+        schemaSha: SchemaSha;
+        sourcesSha: SourcesSha;
+        patches: PatchId[];
+    } | {
+        type: "use-websocket";
+        url: string;
+        nonce: string;
+        baseSha: BaseSha;
+        schemaSha: SchemaSha;
+        sourcesSha: SourcesSha;
+        commitSha: CommitSha;
+        commits: ValCommit[];
+        deployments: ValDeployment[];
+        patches: PatchId[];
+    } | {
+        type: "error";
+        error: GenericErrorMessage;
+        unauthorized?: boolean;
+        networkError?: boolean;
+    }>;
+    getWebSocketNonce(profileId: string): Promise<{
+        status: "success";
+        data: {
+            nonce: string;
+            url: string;
+        };
+    } | {
+        status: "error";
+        error: GenericErrorMessage;
+    }>;
+    fetchPatches<ExcludePatchOps extends boolean>(filters: {
+        patchIds?: PatchId[];
+        excludePatchOps: ExcludePatchOps;
+    }): Promise<ExcludePatchOps extends true ? OrderedPatchesMetadata : OrderedPatches>;
+    fetchPatchesInternal<ExcludePatchOps extends boolean>(filters: {
+        patchIds?: PatchId[];
+        excludePatchOps: ExcludePatchOps;
+    }): Promise<ExcludePatchOps extends true ? OrderedPatchesMetadata : OrderedPatches>;
+    protected saveSourceFilePatch(path: ModuleFilePath, patch: PatchT, patchId: PatchId, parentRef: ParentRefT, authorId: AuthorId | null, sessionId: string | null): Promise<SaveSourceFilePatchResult>;
+    /**
+     * @deprecated For HTTP ops use direct upload instead (i.e. client should upload the files directly) since hosting platforms (Vercel) might have low limits on the size of the request body.
+     */
+    saveBase64EncodedBinaryFileFromPatch(filePathOrRef: string, parentRef: ParentRef, patchId: PatchId, data: string | null, type: BinaryFileType, metadata: MetadataOfType<BinaryFileType> | undefined): Promise<WithGenericError<{
+        patchId: PatchId;
+        filePath: string;
+    }>>;
+    private getHttpFiles;
+    protected getSourceFile(path: string): Promise<WithGenericError<{
+        data: string;
+    }>>;
+    getBinaryFile(filePath: string): Promise<Buffer | null>;
+    getBase64EncodedBinaryFileFromPatch(filePath: string, patchId: PatchId, remote: boolean): Promise<Buffer | null>;
+    protected getBase64EncodedBinaryFileMetadataFromPatch<T extends "file" | "image">(filePath: string, type: T, patchId: PatchId, remote: boolean): Promise<OpsMetadata<T>>;
+    protected getBinaryFileMetadata<T extends "file" | "image">(filePath: string, type: T): Promise<OpsMetadata<T>>;
+    deletePatches(patchIds: PatchId[]): Promise<{
+        deleted: PatchId[];
+        errors?: undefined;
+        error?: undefined;
+    } | {
+        deleted: PatchId[];
+        errors: Record<PatchId, GenericErrorMessage>;
+    } | {
+        error: GenericErrorMessage;
+        errors?: undefined;
+        deleted?: undefined;
+    }>;
+    getCommitMessage(preparedCommit: PreparedCommit): Promise<{
+        commitSummary: string;
+        error?: undefined;
+    } | {
+        error: GenericErrorMessage;
+    }>;
+    commit(prepared: PreparedCommit, message: string, committer: AuthorId, filesDirectory: string, newBranch?: string): Promise<{
+        isNotFastForward?: boolean;
+        updatedFiles: string[];
+        commit: CommitSha;
+        branch: string;
+        error?: undefined;
+    } | {
+        isNotFastForward?: boolean;
+        error: GenericErrorMessage;
+    }>;
+}
+export {};