@valbuild/server 0.146.4 → 0.147.0

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

@@ -1,10 +1,11 @@
+import { Buffer } from "buffer";
 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 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 { 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";
@@ -598,6 +599,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[];

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

@@ -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.
      *

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

@@ -1,9 +1,11 @@
+import { Buffer } from "buffer";
 import type { ValContentVersion, ValProposal } from "./proposal.js";
 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 +171,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>;

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/fixHandlers.d.ts

@@ -247,6 +247,6 @@ export declare function handleJsonValuesExtractEntry(ctx: FixHandlerContext): Pr
  */
 export declare function handleViewCheckModule(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/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,39 @@
+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";
+/**
+ * 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;
+    };
+    /** 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>;
+};

package/dist/getJsonEntryAtCommit-1e08d724.esm.js

@@ -0,0 +1,136 @@
+import ts from 'typescript';
+import { x as posixPath } from './ValRouterCore-f5004f8f.esm.js';
+import { result } from '@valbuild/core/fp';
+import { a as analyzeValModule, c as analyzeJsonValuesEntries } from './jsonValuesModule-427d68c8.esm.js';
+import 'buffer';
+import '@valbuild/core';
+import '@valbuild/shared/internal';
+import 'zod';
+import 'zod-validation-error';
+import '@valbuild/core/patch';
+import 'image-size';
+
+/**
+ * One `.jsonValues()` entry's content, as it was at a commit.
+ *
+ * The history pane renders a commit through the real field components, and a
+ * `.jsonValues()` record's source is only `{_type:"json"}` markers - the
+ * content lives in a separate `*.val.json` per entry, fetched on demand. The
+ * live Studio fetches it from `GET /json`; the commit pane had nothing to
+ * fetch from, so every entry stayed a marker and rendered as though the field
+ * were empty. Which is worse than an error: an empty value is a claim, and it
+ * was a false one.
+ *
+ * ## Why this needs the module's own `.val.ts`
+ *
+ * There is no derivable relationship between a record key and its entry file.
+ * From the example app:
+ *
+ *   "/support/getting-started": c.json(() => import("./content/getting-started.val.json"))
+ *   "/support/faq":             c.json(() => import("./content/faq.val.json"))
+ *
+ * The key is a route and the path is whatever the author wrote. The only place
+ * the two are related is the `import()` literal inside the `.val.ts`, which is
+ * why `findJsonEntryFilePathsInSource` reads them out of the AST too. The
+ * commit archive stores the module's SOURCE (the markers) and its schema, not
+ * its text - so the text is fetched from git at that commit and parsed here.
+ *
+ * Two round trips per entry, then: the module, and the entry. The module's
+ * parse is worth caching per (commit, module) by the caller; nothing here does,
+ * because a `ValOps` is not a cache and the endpoint above it is the layer that
+ * knows how long a commit stays interesting.
+ */
+async function getJsonEntryAtCommit(ops, commitSha, moduleFilePath, key) {
+  const moduleGitPath = ops.gitPathOfModule(moduleFilePath);
+  if (result.isErr(moduleGitPath)) {
+    return moduleGitPath;
+  }
+  const moduleRes = await ops.getFileAtCommit(commitSha, moduleGitPath.value, false);
+  if (result.isErr(moduleRes)) {
+    return moduleRes;
+  }
+  const entryPath = findEntryImportPath(moduleFilePath, moduleGitPath.value, moduleRes.value.toString("utf-8"), key);
+  if (result.isErr(entryPath)) {
+    return entryPath;
+  }
+  // The entry path resolved above is PROJECT-relative, like the module path it
+  // came from; the git path needs the root in front of it, and the ops are what
+  // know the root. Reusing gitPathOfModule rather than re-deriving the prefix:
+  // a `.val.json` is not a module, but "project-relative path -> repo path" is
+  // the same question and one implementation of it is the point.
+  const entryGitPath = ops.gitPathOfModule(entryPath.value);
+  if (result.isErr(entryGitPath)) {
+    return entryGitPath;
+  }
+  const entryRes = await ops.getFileAtCommit(commitSha, entryGitPath.value, false);
+  if (result.isErr(entryRes)) {
+    return entryRes;
+  }
+  try {
+    return result.ok(JSON.parse(entryRes.value.toString("utf-8")));
+  } catch (err) {
+    return result.err({
+      kind: "file-unavailable",
+      gitPath: entryGitPath.value,
+      message: `not valid JSON at this commit: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+}
+
+/**
+ * The `import()` path a key's entry is behind, from the module's text.
+ *
+ * Exported for its own test: this is the part with a real chance of being
+ * wrong, and it is pure.
+ */
+function findEntryImportPath(moduleFilePath,
+/**
+ * The same module, repository-relative, for error reporting only.
+ *
+ * A `gitPath` in a HistoryError is a REPOSITORY path - that is what every
+ * other history helper reports, and what a reader can paste into a `git show`
+ * - so reporting the project-relative ModuleFilePath here named a file that
+ * does not exist at that path for any project not rooted at the repo root.
+ */
+moduleGitPath, valTsSource, key) {
+  const sourceFile = ts.createSourceFile(moduleFilePath, valTsSource, ts.ScriptTarget.ES2015, true);
+  let analysis;
+  try {
+    analysis = analyzeValModule(sourceFile);
+  } catch (err) {
+    // `file-unavailable` rather than a kind of its own: the module's TEXT is
+    // the file we could not use, and adding a wire kind for "unparseable"
+    // would be a new case every reader has to handle to say the same thing.
+    return result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: `could not parse the module at this commit: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  if (result.isErr(analysis)) {
+    return result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: "could not read the module at this commit"
+    });
+  }
+  const entries = analyzeJsonValuesEntries(analysis.value.source);
+  const entry = entries.get(key);
+  if (entry === undefined) {
+    /*
+     * Reported, not treated as empty. A key with no entry at this commit means
+     * the entry was added later - so "there is nothing to show for it here" is
+     * the true answer, and rendering an empty field instead would say the
+     * author had left it blank.
+     */
+    return result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: `'${key}' had no entry at this commit`
+    });
+  }
+  const moduleDir = posixPath.dirname(moduleFilePath);
+  return result.ok(posixPath.join(moduleDir, entry.importPath));
+}
+
+export { findEntryImportPath, getJsonEntryAtCommit };

package/dist/getJsonEntryAtCommit-df65d861.cjs.prod.js

@@ -0,0 +1,143 @@
+'use strict';
+
+var ts = require('typescript');
+var ValRouterCore = require('./ValRouterCore-7ffcc08c.cjs.prod.js');
+var fp = require('@valbuild/core/fp');
+var jsonValuesModule = require('./jsonValuesModule-d1bb8d8f.cjs.prod.js');
+require('buffer');
+require('@valbuild/core');
+require('@valbuild/shared/internal');
+require('zod');
+require('zod-validation-error');
+require('@valbuild/core/patch');
+require('image-size');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+/**
+ * One `.jsonValues()` entry's content, as it was at a commit.
+ *
+ * The history pane renders a commit through the real field components, and a
+ * `.jsonValues()` record's source is only `{_type:"json"}` markers - the
+ * content lives in a separate `*.val.json` per entry, fetched on demand. The
+ * live Studio fetches it from `GET /json`; the commit pane had nothing to
+ * fetch from, so every entry stayed a marker and rendered as though the field
+ * were empty. Which is worse than an error: an empty value is a claim, and it
+ * was a false one.
+ *
+ * ## Why this needs the module's own `.val.ts`
+ *
+ * There is no derivable relationship between a record key and its entry file.
+ * From the example app:
+ *
+ *   "/support/getting-started": c.json(() => import("./content/getting-started.val.json"))
+ *   "/support/faq":             c.json(() => import("./content/faq.val.json"))
+ *
+ * The key is a route and the path is whatever the author wrote. The only place
+ * the two are related is the `import()` literal inside the `.val.ts`, which is
+ * why `findJsonEntryFilePathsInSource` reads them out of the AST too. The
+ * commit archive stores the module's SOURCE (the markers) and its schema, not
+ * its text - so the text is fetched from git at that commit and parsed here.
+ *
+ * Two round trips per entry, then: the module, and the entry. The module's
+ * parse is worth caching per (commit, module) by the caller; nothing here does,
+ * because a `ValOps` is not a cache and the endpoint above it is the layer that
+ * knows how long a commit stays interesting.
+ */
+async function getJsonEntryAtCommit(ops, commitSha, moduleFilePath, key) {
+  const moduleGitPath = ops.gitPathOfModule(moduleFilePath);
+  if (fp.result.isErr(moduleGitPath)) {
+    return moduleGitPath;
+  }
+  const moduleRes = await ops.getFileAtCommit(commitSha, moduleGitPath.value, false);
+  if (fp.result.isErr(moduleRes)) {
+    return moduleRes;
+  }
+  const entryPath = findEntryImportPath(moduleFilePath, moduleGitPath.value, moduleRes.value.toString("utf-8"), key);
+  if (fp.result.isErr(entryPath)) {
+    return entryPath;
+  }
+  // The entry path resolved above is PROJECT-relative, like the module path it
+  // came from; the git path needs the root in front of it, and the ops are what
+  // know the root. Reusing gitPathOfModule rather than re-deriving the prefix:
+  // a `.val.json` is not a module, but "project-relative path -> repo path" is
+  // the same question and one implementation of it is the point.
+  const entryGitPath = ops.gitPathOfModule(entryPath.value);
+  if (fp.result.isErr(entryGitPath)) {
+    return entryGitPath;
+  }
+  const entryRes = await ops.getFileAtCommit(commitSha, entryGitPath.value, false);
+  if (fp.result.isErr(entryRes)) {
+    return entryRes;
+  }
+  try {
+    return fp.result.ok(JSON.parse(entryRes.value.toString("utf-8")));
+  } catch (err) {
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: entryGitPath.value,
+      message: `not valid JSON at this commit: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+}
+
+/**
+ * The `import()` path a key's entry is behind, from the module's text.
+ *
+ * Exported for its own test: this is the part with a real chance of being
+ * wrong, and it is pure.
+ */
+function findEntryImportPath(moduleFilePath,
+/**
+ * The same module, repository-relative, for error reporting only.
+ *
+ * A `gitPath` in a HistoryError is a REPOSITORY path - that is what every
+ * other history helper reports, and what a reader can paste into a `git show`
+ * - so reporting the project-relative ModuleFilePath here named a file that
+ * does not exist at that path for any project not rooted at the repo root.
+ */
+moduleGitPath, valTsSource, key) {
+  const sourceFile = ts__default["default"].createSourceFile(moduleFilePath, valTsSource, ts__default["default"].ScriptTarget.ES2015, true);
+  let analysis;
+  try {
+    analysis = jsonValuesModule.analyzeValModule(sourceFile);
+  } catch (err) {
+    // `file-unavailable` rather than a kind of its own: the module's TEXT is
+    // the file we could not use, and adding a wire kind for "unparseable"
+    // would be a new case every reader has to handle to say the same thing.
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: `could not parse the module at this commit: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  if (fp.result.isErr(analysis)) {
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: "could not read the module at this commit"
+    });
+  }
+  const entries = jsonValuesModule.analyzeJsonValuesEntries(analysis.value.source);
+  const entry = entries.get(key);
+  if (entry === undefined) {
+    /*
+     * Reported, not treated as empty. A key with no entry at this commit means
+     * the entry was added later - so "there is nothing to show for it here" is
+     * the true answer, and rendering an empty field instead would say the
+     * author had left it blank.
+     */
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: `'${key}' had no entry at this commit`
+    });
+  }
+  const moduleDir = ValRouterCore.posixPath.dirname(moduleFilePath);
+  return fp.result.ok(ValRouterCore.posixPath.join(moduleDir, entry.importPath));
+}
+
+exports.findEntryImportPath = findEntryImportPath;
+exports.getJsonEntryAtCommit = getJsonEntryAtCommit;

package/dist/getJsonEntryAtCommit-e96beb9e.cjs.dev.js

@@ -0,0 +1,143 @@
+'use strict';
+
+var ts = require('typescript');
+var ValRouterCore = require('./ValRouterCore-3fd3d444.cjs.dev.js');
+var fp = require('@valbuild/core/fp');
+var jsonValuesModule = require('./jsonValuesModule-8ae503a8.cjs.dev.js');
+require('buffer');
+require('@valbuild/core');
+require('@valbuild/shared/internal');
+require('zod');
+require('zod-validation-error');
+require('@valbuild/core/patch');
+require('image-size');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+/**
+ * One `.jsonValues()` entry's content, as it was at a commit.
+ *
+ * The history pane renders a commit through the real field components, and a
+ * `.jsonValues()` record's source is only `{_type:"json"}` markers - the
+ * content lives in a separate `*.val.json` per entry, fetched on demand. The
+ * live Studio fetches it from `GET /json`; the commit pane had nothing to
+ * fetch from, so every entry stayed a marker and rendered as though the field
+ * were empty. Which is worse than an error: an empty value is a claim, and it
+ * was a false one.
+ *
+ * ## Why this needs the module's own `.val.ts`
+ *
+ * There is no derivable relationship between a record key and its entry file.
+ * From the example app:
+ *
+ *   "/support/getting-started": c.json(() => import("./content/getting-started.val.json"))
+ *   "/support/faq":             c.json(() => import("./content/faq.val.json"))
+ *
+ * The key is a route and the path is whatever the author wrote. The only place
+ * the two are related is the `import()` literal inside the `.val.ts`, which is
+ * why `findJsonEntryFilePathsInSource` reads them out of the AST too. The
+ * commit archive stores the module's SOURCE (the markers) and its schema, not
+ * its text - so the text is fetched from git at that commit and parsed here.
+ *
+ * Two round trips per entry, then: the module, and the entry. The module's
+ * parse is worth caching per (commit, module) by the caller; nothing here does,
+ * because a `ValOps` is not a cache and the endpoint above it is the layer that
+ * knows how long a commit stays interesting.
+ */
+async function getJsonEntryAtCommit(ops, commitSha, moduleFilePath, key) {
+  const moduleGitPath = ops.gitPathOfModule(moduleFilePath);
+  if (fp.result.isErr(moduleGitPath)) {
+    return moduleGitPath;
+  }
+  const moduleRes = await ops.getFileAtCommit(commitSha, moduleGitPath.value, false);
+  if (fp.result.isErr(moduleRes)) {
+    return moduleRes;
+  }
+  const entryPath = findEntryImportPath(moduleFilePath, moduleGitPath.value, moduleRes.value.toString("utf-8"), key);
+  if (fp.result.isErr(entryPath)) {
+    return entryPath;
+  }
+  // The entry path resolved above is PROJECT-relative, like the module path it
+  // came from; the git path needs the root in front of it, and the ops are what
+  // know the root. Reusing gitPathOfModule rather than re-deriving the prefix:
+  // a `.val.json` is not a module, but "project-relative path -> repo path" is
+  // the same question and one implementation of it is the point.
+  const entryGitPath = ops.gitPathOfModule(entryPath.value);
+  if (fp.result.isErr(entryGitPath)) {
+    return entryGitPath;
+  }
+  const entryRes = await ops.getFileAtCommit(commitSha, entryGitPath.value, false);
+  if (fp.result.isErr(entryRes)) {
+    return entryRes;
+  }
+  try {
+    return fp.result.ok(JSON.parse(entryRes.value.toString("utf-8")));
+  } catch (err) {
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: entryGitPath.value,
+      message: `not valid JSON at this commit: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+}
+
+/**
+ * The `import()` path a key's entry is behind, from the module's text.
+ *
+ * Exported for its own test: this is the part with a real chance of being
+ * wrong, and it is pure.
+ */
+function findEntryImportPath(moduleFilePath,
+/**
+ * The same module, repository-relative, for error reporting only.
+ *
+ * A `gitPath` in a HistoryError is a REPOSITORY path - that is what every
+ * other history helper reports, and what a reader can paste into a `git show`
+ * - so reporting the project-relative ModuleFilePath here named a file that
+ * does not exist at that path for any project not rooted at the repo root.
+ */
+moduleGitPath, valTsSource, key) {
+  const sourceFile = ts__default["default"].createSourceFile(moduleFilePath, valTsSource, ts__default["default"].ScriptTarget.ES2015, true);
+  let analysis;
+  try {
+    analysis = jsonValuesModule.analyzeValModule(sourceFile);
+  } catch (err) {
+    // `file-unavailable` rather than a kind of its own: the module's TEXT is
+    // the file we could not use, and adding a wire kind for "unparseable"
+    // would be a new case every reader has to handle to say the same thing.
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: `could not parse the module at this commit: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  if (fp.result.isErr(analysis)) {
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: "could not read the module at this commit"
+    });
+  }
+  const entries = jsonValuesModule.analyzeJsonValuesEntries(analysis.value.source);
+  const entry = entries.get(key);
+  if (entry === undefined) {
+    /*
+     * Reported, not treated as empty. A key with no entry at this commit means
+     * the entry was added later - so "there is nothing to show for it here" is
+     * the true answer, and rendering an empty field instead would say the
+     * author had left it blank.
+     */
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: `'${key}' had no entry at this commit`
+    });
+  }
+  const moduleDir = ValRouterCore.posixPath.dirname(moduleFilePath);
+  return fp.result.ok(ValRouterCore.posixPath.join(moduleDir, entry.importPath));
+}
+
+exports.findEntryImportPath = findEntryImportPath;
+exports.getJsonEntryAtCommit = getJsonEntryAtCommit;