@valbuild/cli 0.102.0 → 0.103.1

package/cli/dist/valbuild-cli-cli.cjs.dev.js

@@ -9,8 +9,8 @@ var fastGlob = require('fast-glob');
 var core = require('@valbuild/core');
 var server = require('@valbuild/server');
 var internal = require('@valbuild/shared/internal');
-var ts = require('typescript');
 var fs = require('fs');
+var ts = require('typescript');
 var JSZip = require('jszip');
 var readline = require('readline');
 
@@ -39,8 +39,8 @@ var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var path__default = /*#__PURE__*/_interopDefault(path);
 var pc__default = /*#__PURE__*/_interopDefault(pc);
 var fs__default$1 = /*#__PURE__*/_interopDefault(fs$1);
-var ts__default = /*#__PURE__*/_interopDefault(ts);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
+var ts__default = /*#__PURE__*/_interopDefault(ts);
 var JSZip__default = /*#__PURE__*/_interopDefault(JSZip);
 var readline__default = /*#__PURE__*/_interopDefault(readline);
 
@@ -59,543 +59,6 @@ function info(message, opts = {}) {
   console.log(chalk__default["default"].blue("️ℹ️ : ") + message);
 }
 
-function getFileExt(filePath) {
-  // NOTE: We do not import the path module. This code is copied in different projects. We want the same implementation and which means that this might running in browser where path is not available).
-  return filePath.split(".").pop() || "";
-}
-
-const textEncoder = new TextEncoder();
-
-// Types for handler system
-
-// Handler functions
-async function handleFileMetadata(ctx) {
-  var _fileSource$source;
-  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
-  if (!ctx.valModule.source || !ctx.valModule.schema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
-    };
-  }
-  const fileSource = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const fileRefProp = (_fileSource$source = fileSource.source) === null || _fileSource$source === void 0 ? void 0 : _fileSource$source[core.FILE_REF_PROP];
-  if (!fileRefProp) {
-    return {
-      success: false,
-      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
-    };
-  }
-  const filePath = path__default["default"].join(ctx.projectRoot, fileRefProp);
-  if (!ctx.fs.fileExists(filePath)) {
-    return {
-      success: false,
-      errorMessage: `File ${filePath} does not exist`
-    };
-  }
-  return {
-    success: true,
-    shouldApplyPatch: true
-  };
-}
-
-// Shared upload core used by both the single-field (handleRemoteFileUpload)
-// and gallery (handleRemoteGalleryFileUpload) handlers. The two differ only in
-// how they derive the local file ref, metadata and serialized image/file
-// schema; everything from auth through upload is identical.
-async function uploadRemoteFileCore(ctx, fileRef, metadata, schema) {
-  const filePath = path__default["default"].join(ctx.projectRoot, fileRef);
-  if (!ctx.fs.fileExists(filePath)) {
-    return {
-      success: false,
-      errorMessage: `File ${filePath} does not exist`
-    };
-  }
-  const patFile = server.getPersonalAccessTokenPath(ctx.projectRoot);
-  if (!ctx.fs.fileExists(patFile)) {
-    return {
-      success: false,
-      errorMessage: `File: ${path__default["default"].join(ctx.projectRoot, ctx.file)} has remote images that are not uploaded and you are not logged in.\n\nFix this error by logging in:\n\t"npx val login"\n`
-    };
-  }
-  const patFileContent = ctx.fs.readFile(patFile);
-  if (patFileContent === undefined) {
-    return {
-      success: false,
-      errorMessage: `Could not read personal access token file at ${patFile}`
-    };
-  }
-  const parsedPatFile = server.parsePersonalAccessTokenFile(patFileContent);
-  if (!parsedPatFile.success) {
-    return {
-      success: false,
-      errorMessage: `Error parsing personal access token file: ${parsedPatFile.error}. You need to login again.`
-    };
-  }
-  const {
-    pat
-  } = parsedPatFile.data;
-  if (ctx.remoteFiles[ctx.sourcePath]) {
-    return {
-      success: true,
-      events: [{
-        type: "remote-already-uploaded",
-        filePath
-      }]
-    };
-  }
-  const projectName = ctx.project;
-  let publicProjectId = ctx.publicProjectId;
-  let remoteFileBuckets = ctx.remoteFileBuckets;
-  let remoteFilesCounter = ctx.remoteFilesCounter;
-  if (!publicProjectId || !remoteFileBuckets) {
-    if (!projectName) {
-      return {
-        success: false,
-        errorMessage: "Project name not found. Add project name to val.config or set the VAL_PROJECT environment variable"
-      };
-    }
-    const settingsRes = await ctx.remote.getSettings(projectName, {
-      pat
-    });
-    if (!settingsRes.success) {
-      return {
-        success: false,
-        errorMessage: `Could not get public project id: ${settingsRes.message}.`
-      };
-    }
-    publicProjectId = settingsRes.data.publicProjectId;
-    remoteFileBuckets = settingsRes.data.remoteFileBuckets.map(b => b.bucket);
-  }
-  if (!publicProjectId) {
-    return {
-      success: false,
-      errorMessage: "Could not get public project id"
-    };
-  }
-  if (!projectName) {
-    return {
-      success: false,
-      errorMessage: `Could not get project. Check that your val.config has the 'project' field set, or set it using the VAL_PROJECT environment variable`
-    };
-  }
-  remoteFilesCounter += 1;
-  const bucket = remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length];
-  if (!bucket) {
-    return {
-      success: false,
-      errorMessage: `Internal error: could not allocate a bucket for the remote file located at ${ctx.sourcePath}`
-    };
-  }
-  const fileBuffer = ctx.fs.readBuffer(filePath);
-  if (fileBuffer === undefined) {
-    return {
-      success: false,
-      errorMessage: `Error reading file: ${filePath}`
-    };
-  }
-  const relativeFilePath = path__default["default"].relative(ctx.projectRoot, filePath).split(path__default["default"].sep).join("/");
-  if (!relativeFilePath.startsWith("public/")) {
-    return {
-      success: false,
-      errorMessage: `File path must be within the public/ directory (e.g. public/path/to/file.txt). Got: ${relativeFilePath}`
-    };
-  }
-  const fileHash = core.Internal.remote.getFileHash(fileBuffer);
-  const coreVersion = core.Internal.VERSION.core || "unknown";
-  const fileExt = getFileExt(filePath);
-  const ref = core.Internal.remote.createRemoteRef(ctx.remote.remoteHost, {
-    publicProjectId,
-    coreVersion,
-    bucket,
-    validationHash: core.Internal.remote.getValidationHash(coreVersion, schema, fileExt, metadata, fileHash, textEncoder),
-    fileHash,
-    filePath: relativeFilePath
-  });
-  const remoteFileUpload = await ctx.remote.uploadFile(projectName, bucket, fileHash, fileExt, fileBuffer, {
-    pat
-  });
-  if (!remoteFileUpload.success) {
-    return {
-      success: false,
-      errorMessage: `Could not upload remote file: '${ref}'. Error: ${remoteFileUpload.error}`
-    };
-  }
-  ctx.remoteFiles[ctx.sourcePath] = {
-    ref,
-    metadata
-  };
-  return {
-    success: true,
-    shouldApplyPatch: true,
-    publicProjectId,
-    remoteFileBuckets,
-    remoteFilesCounter,
-    events: [{
-      type: "remote-uploading",
-      ref
-    }, {
-      type: "remote-uploaded",
-      ref
-    }]
-  };
-}
-async function handleRemoteFileUpload(ctx) {
-  var _resolvedRemoteFileAt;
-  if (!ctx.fix) {
-    return {
-      success: false,
-      // No sourcePath in the message: the reported location already points at it.
-      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
-    };
-  }
-  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
-  if (!ctx.valModule.source || !ctx.valModule.schema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
-    };
-  }
-  const resolvedRemoteFileAtSourcePath = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const fileRefProp = (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[core.FILE_REF_PROP];
-  if (!fileRefProp) {
-    return {
-      success: false,
-      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
-    };
-  }
-  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
-  if (!resolveRemoteFileSchema) {
-    return {
-      success: false,
-      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
-    };
-  }
-  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
-    return {
-      success: false,
-      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
-    };
-  }
-  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
-  const fileSourceMetadata = core.Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
-  return uploadRemoteFileCore(ctx, fileRefProp, fileSourceMetadata, resolveRemoteFileSchema);
-}
-
-// Gallery (s.images({ remote: true }) / s.files({ remote: true })) upload.
-// Unlike a single image/file field, a gallery entry is keyed by its local file
-// path and the value is bare metadata (no FileSource), so we derive the file
-// ref from the key and synthesize the image/file schema from the record's
-// media options.
-async function handleRemoteGalleryFileUpload(ctx) {
-  var _ctx$validationError$;
-  if (!ctx.fix) {
-    return {
-      success: false,
-      // No sourcePath in the message: the reported location already points at it.
-      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`
-    };
-  }
-  const fix = (_ctx$validationError$ = ctx.validationError.fixes) === null || _ctx$validationError$ === void 0 ? void 0 : _ctx$validationError$[0];
-  const mediaType = fix === "files:upload-remote" ? "file" : "image";
-
-  // The gallery entry is keyed by its local file path; validateMediaKey carries
-  // that key as the error value.
-  const fileRef = ctx.validationError.value;
-  if (typeof fileRef !== "string") {
-    return {
-      success: false,
-      errorMessage: `Expected a local file path for gallery entry at ${ctx.sourcePath}`
-    };
-  }
-  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
-  if (!ctx.valModule.source || !ctx.valModule.schema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
-    };
-  }
-  const resolved = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
-  const entrySource = resolved.source;
-  const metadata = entrySource && typeof entrySource === "object" && !Array.isArray(entrySource) ? entrySource : undefined;
-
-  // The gallery item schema is an ObjectSchema, not an image/file schema, so
-  // synthesize the serialized image/file schema (matching how single fields
-  // serialize) for the remote ref's validation hash.
-  //
-  // `accept`/`directory` come from the RECORD that holds the entry, resolved
-  // from the entry's PARENT path - not from the module root, which is only the
-  // record when the gallery is the whole module. A nested gallery
-  // (s.object({ gallery: s.images(...) })) would otherwise synthesize a schema
-  // with no options and bake a validation hash into the remote ref that can
-  // never validate, so a mismatch fails fast instead of uploading.
-  const [, parentModulePath] = core.Internal.splitModuleFilePathAndModulePath(core.Internal.parentOfSourcePath(ctx.sourcePath));
-  const recordSchema = core.Internal.resolvePath(parentModulePath, ctx.valModule.source, ctx.valModule.schema).schema;
-  if ((recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) !== "record") {
-    return {
-      success: false,
-      errorMessage: `Expected a gallery record at the parent of ${ctx.sourcePath}, got ${(recordSchema === null || recordSchema === void 0 ? void 0 : recordSchema.type) ?? "nothing"}`
-    };
-  }
-  const {
-    accept,
-    directory
-  } = recordSchema;
-  const schema = mediaType === "image" ? {
-    type: "image",
-    opt: false,
-    options: {
-      ...(accept ? {
-        accept
-      } : {}),
-      ...(directory ? {
-        directory
-      } : {})
-    }
-  } : {
-    type: "file",
-    opt: false,
-    options: {
-      ...(accept ? {
-        accept
-      } : {})
-    }
-  };
-  return uploadRemoteFileCore(ctx, fileRef, metadata, schema);
-}
-async function handleRemoteFileDownload(ctx) {
-  if (ctx.fix) {
-    return {
-      success: true,
-      shouldApplyPatch: true,
-      events: [{
-        type: "remote-downloading",
-        sourcePath: ctx.sourcePath
-      }]
-    };
-  } else {
-    return {
-      success: false,
-      errorMessage: `Remote file ${ctx.sourcePath} needs to be downloaded (use --fix to download)`
-    };
-  }
-}
-async function handleRemoteFileCheck() {
-  // Skip - no action needed
-  return {
-    success: true,
-    shouldApplyPatch: true
-  };
-}
-async function handleUniqueFolderCheck(ctx) {
-  const value = ctx.validationError.value;
-  if (!value || typeof value.directory !== "string") {
-    return {
-      success: false,
-      errorMessage: `Unexpected value in unique folder check for ${ctx.sourcePath}`
-    };
-  }
-  const {
-    directory
-  } = value;
-  const conflicts = [];
-  for (const file of ctx.valFiles) {
-    const otherModuleFilePath = `/${file}`;
-    if (otherModuleFilePath === ctx.moduleFilePath) continue;
-    const otherModule = await ctx.service.get(otherModuleFilePath, "", {
-      validate: false
-    });
-    const schema = otherModule.schema;
-    if ((schema === null || schema === void 0 ? void 0 : schema.type) === "record" && schema.directory === directory && schema.mediaType) {
-      conflicts.push(otherModuleFilePath);
-    }
-  }
-  if (conflicts.length > 0) {
-    return {
-      success: false,
-      errorMessage: `Gallery directory '${directory}' in ${ctx.moduleFilePath} is also used by: ${conflicts.join(", ")}. Each gallery must use a unique directory.`
-    };
-  }
-  return {
-    success: true
-  };
-}
-
-// Maps a gallery key to its on-disk local path. Remote galleries key uploaded
-// entries by a remote URL while keeping the file on disk; everything else is
-// already a local path and is returned unchanged.
-function remoteKeyToLocalPath(key) {
-  const remoteRefRes = core.Internal.remote.splitRemoteRef(key);
-  if (remoteRefRes.status === "success") {
-    return `/${remoteRefRes.filePath}`;
-  }
-  return key;
-}
-async function handleCheckAllFiles(ctx) {
-  const value = ctx.validationError.value;
-  if (!value || typeof value.directory !== "string") {
-    return {
-      success: false,
-      errorMessage: `Unexpected value in check-all-files for ${ctx.sourcePath}`
-    };
-  }
-  const {
-    directory
-  } = value;
-  const source = ctx.valModule.source;
-  if (!source || typeof source !== "object" || Array.isArray(source)) {
-    return {
-      success: false,
-      errorMessage: `Could not get source for ${ctx.sourcePath}`
-    };
-  }
-  // Gallery entries are keyed by their file path. Remote galleries key uploaded
-  // entries by a remote URL, but the file is kept on disk at its local path, so
-  // normalize remote-URL keys back to that local path for the on-disk checks.
-  const trackedFiles = new Set(Object.keys(source).map(remoteKeyToLocalPath));
-
-  // Check that all tracked files exist on disk
-  const missingTrackedFiles = [...trackedFiles].filter(f => {
-    return !ctx.fs.fileExists(path__default["default"].join(ctx.projectRoot, f));
-  });
-  if (missingTrackedFiles.length > 0) {
-    if (!ctx.fix) {
-      return {
-        success: false,
-        errorMessage: `Gallery in ${ctx.moduleFilePath} has tracked files that do not exist on disk: ${missingTrackedFiles.join(", ")}. Add the files or remove them from the gallery.`
-      };
-    }
-    // fix: true — let createFixPatch remove the missing entries
-    return {
-      success: true,
-      shouldApplyPatch: true
-    };
-  }
-  const dirPath = path__default["default"].join(ctx.projectRoot, directory);
-  const filesInDir = [];
-  try {
-    const entries = ctx.fs.readDirectory(dirPath, undefined, undefined, ["**/*"]);
-    for (const entry of entries) {
-      const relPath = "/" + path__default["default"].relative(ctx.projectRoot, entry).split(path__default["default"].sep).join("/");
-      filesInDir.push(relPath);
-    }
-  } catch {
-    // directory doesn't exist — no untracked files possible
-  }
-  const untrackedFiles = filesInDir.filter(f => !trackedFiles.has(f));
-  if (untrackedFiles.length > 0) {
-    return {
-      success: false,
-      errorMessage: `Gallery in ${ctx.moduleFilePath} has files not tracked: ${untrackedFiles.join(", ")}. Add these files to the gallery or remove them from the directory.`
-    };
-  }
-
-  // All files accounted for — trigger metadata verification via createFixPatch
-  return {
-    success: true,
-    shouldApplyPatch: true
-  };
-}
-async function handleJsonValuesExtractEntry(ctx) {
-  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
-  const parts = core.Internal.splitModulePath(modulePath);
-  // Root-only by contract (see findNestedJsonValuesRecords): the entry is a
-  // direct child of the module's root record/router, so the path is one segment.
-  if (parts.length !== 1) {
-    return {
-      success: false,
-      errorMessage: `Cannot extract .jsonValues() entry at ${ctx.sourcePath}: expected a root record entry`
-    };
-  }
-  const entryKey = parts[0];
-  const source = ctx.valModule.source;
-  if (source === null || typeof source !== "object" || Array.isArray(source)) {
-    return {
-      success: false,
-      errorMessage: `Could not get source for ${ctx.moduleFilePath}`
-    };
-  }
-  const content = source[entryKey];
-  if (content === undefined) {
-    return {
-      success: false,
-      errorMessage: `Could not find .jsonValues() entry '${entryKey}' in ${ctx.moduleFilePath}`
-    };
-  }
-  if (!ctx.fix) {
-    return {
-      success: true,
-      fixableErrorMessage: ctx.validationError.message
-    };
-  }
-  try {
-    server.extractJsonValuesEntry(ctx.moduleFilePath, ctx.projectRoot, entryKey, content, ctx.service.sourceFileHandler);
-  } catch (err) {
-    return {
-      success: false,
-      errorMessage: err instanceof Error ? err.message : String(err)
-    };
-  }
-  return {
-    success: true,
-    appliedFix: true
-  };
-}
-
-// Fix handler registry. `keyof:check-keys` and `router:check-route` are
-// resolved upfront by the shared resolveSchemaSourceFixes — they never reach
-// this registry, so they're excluded from the key set.
-const currentFixHandlers = {
-  "image:check-metadata": handleFileMetadata,
-  "image:add-metadata": handleFileMetadata,
-  "file:check-metadata": handleFileMetadata,
-  "file:add-metadata": handleFileMetadata,
-  "image:upload-remote": handleRemoteFileUpload,
-  "file:upload-remote": handleRemoteFileUpload,
-  "images:upload-remote": handleRemoteGalleryFileUpload,
-  "files:upload-remote": handleRemoteGalleryFileUpload,
-  "image:download-remote": handleRemoteFileDownload,
-  "file:download-remote": handleRemoteFileDownload,
-  "image:check-remote": handleRemoteFileCheck,
-  "images:check-remote": handleRemoteFileCheck,
-  "file:check-remote": handleRemoteFileCheck,
-  "files:check-remote": handleRemoteFileCheck,
-  "images:check-unique-folder": handleUniqueFolderCheck,
-  "files:check-unique-folder": handleUniqueFolderCheck,
-  "images:check-all-files": handleCheckAllFiles,
-  "files:check-all-files": handleCheckAllFiles,
-  "jsonValues:extract-entry": handleJsonValuesExtractEntry
-};
-const deprecatedFixHandlers = {
-  "image:replace-metadata": handleFileMetadata
-};
-const fixHandlers = {
-  ...deprecatedFixHandlers,
-  ...currentFixHandlers
-};
-function createDefaultValFSHost() {
-  return {
-    ...ts__default["default"].sys,
-    writeFile: (fileName, data, encoding) => {
-      fs__default["default"].mkdirSync(path__default["default"].dirname(fileName), {
-        recursive: true
-      });
-      fs__default["default"].writeFileSync(fileName, typeof data === "string" ? data : new Uint8Array(data), encoding);
-    },
-    rmFile: fs__default["default"].rmSync,
-    readBuffer: fileName => {
-      try {
-        return fs__default["default"].readFileSync(fileName);
-      } catch {
-        return undefined;
-      }
-    }
-  };
-}
 async function* runValidation({
   root,
   fix,
@@ -682,7 +145,7 @@ async function* runValidation({
 
               // Find and execute appropriate handler
               const fixType = v.fixes[0]; // Take first fix
-              const handler = fixHandlers[fixType];
+              const handler = server.fixHandlers[fixType];
               if (!handler) {
                 yield {
                   type: "unknown-fix",
@@ -1136,7 +599,7 @@ async function validate({
         getSettings: (projectName, options) => server.getSettings(projectName, options),
         uploadFile: (project, bucket, fileHash, fileExt, fileBuffer, options) => server.uploadRemoteFile(process.env.VAL_CONTENT_URL || core.DEFAULT_CONTENT_HOST, project, bucket, fileHash, fileExt ?? "", fileBuffer, options)
       },
-      fs: createDefaultValFSHost()
+      fs: server.createDefaultValFSHost()
     })) {
       switch (event.type) {
         case "file-valid":
@@ -1413,7 +876,7 @@ async function listUnusedFiles({
           for (const error of validationError) {
             const value = error.value;
             if (isFileRef(value)) {
-              const absoluteFilePathUsedByVal = path__default["default"].join(projectRoot, ...value[core.FILE_REF_PROP].split("/"));
+              const absoluteFilePathUsedByVal = path__default["default"].join(projectRoot, ...value.path.split("/"));
               filesUsedByVal.push(absoluteFilePathUsedByVal);
             }
           }
@@ -1438,15 +901,15 @@ async function listUnusedFiles({
   service.dispose();
   return;
 }
+
+/**
+ * Whether a flagged validation value names a file.
+ *
+ * A `ValidationError` carries no schema, so the shape is all there is to go on —
+ * the same heuristic this whole function documents as a TODO.
+ */
 function isFileRef(value) {
-  if (!value) return false;
-  if (typeof value !== "object") return false;
-  if (core.FILE_REF_PROP in value && core.VAL_EXTENSION in value) {
-    if (value[core.VAL_EXTENSION] === "file" && typeof value[core.FILE_REF_PROP] === "string") {
-      return true;
-    }
-  }
-  return false;
+  return !!value && typeof value === "object" && "path" in value && typeof value.path === "string";
 }
 
 const getVersions = () => {
@@ -2037,8 +1500,11 @@ async function buildSnapshot(ctx, options = {}) {
         path: p
       });
     }
-    entries[`.val/patches/${patch.parentPatchId ?? "head"}/patch.json`] = JSON.stringify(toFsPatch(patch), null, 2);
+    entries[`.val/patches/${patch.patchId}/patch.json`] = JSON.stringify(toFsPatch(patch), null, 2);
   }
+  // The order lives in the log, not in the records, so it has to be written too
+  // or the unzipped snapshot is a store with no order at all.
+  entries[".val/patches/patches.log"] = ["val-patch-log v1", ...patches.map(patch => `${patch.patchId} ${patch.createdAt} ${patch.path}`), ""].join("\n");
   let includesBinaryFiles = false;
   if (options.includeFiles) {
     includesBinaryFiles = await writeBinaryFiles(ctx, analysis.fileLastUpdatedByPatchId, patches, entries);
@@ -2105,34 +1571,29 @@ async function validateSnapshotSources(ctx, analysis) {
   return validationRes.errors;
 }
 function toSnapshotPatches(orderedPatches) {
-  return orderedPatches.map((patch, i) => ({
+  return orderedPatches.map(patch => ({
     patchId: patch.patchId,
     path: patch.path,
     createdAt: patch.createdAt,
     authorId: patch.authorId,
     baseSha: patch.baseSha,
     appliedAt: patch.appliedAt,
-    parentPatchId: i === 0 ? null : orderedPatches[i - 1].patchId,
     patch: patch.patch
   }));
 }
 
 /**
  * The shape ValOpsFS writes per patch, so an unzipped snapshot is a patch store
- * a plain ValOpsFS can read. The directory is named after the PARENT, and
- * createPatchChain walks the linked list from "head".
+ * a plain ValOpsFS can read.
+ *
+ * The directory is named after the patch itself and the record points at
+ * nothing: the order is in `patches.log` beside it. A record that named its
+ * parent is how a snapshot could carry a chain that had already lost a link.
  */
 function toFsPatch(patch) {
   return {
     patch: patch.patch,
     patchId: patch.patchId,
-    parentRef: patch.parentPatchId === null ? {
-      type: "head",
-      headBaseSha: patch.baseSha
-    } : {
-      type: "patch",
-      patchId: patch.parentPatchId
-    },
     path: patch.path,
     authorId: patch.authorId,
     sessionId: null,
@@ -2142,14 +1603,13 @@ function toFsPatch(patch) {
   };
 }
 async function writeBinaryFiles(ctx, fileLastUpdatedByPatchId, patches, entries) {
-  const parentByPatchId = new Map(patches.map(p => [p.patchId, p.parentPatchId ?? "head"]));
+  const known = new Set(patches.map(p => p.patchId));
   let wrote = false;
   for (const [filePath, data] of Object.entries(fileLastUpdatedByPatchId)) {
     if (data.isDelete) {
       continue;
     }
-    const parentPatchId = parentByPatchId.get(data.patchId);
-    if (parentPatchId === undefined) {
+    if (!known.has(data.patchId)) {
       continue;
     }
     const buffer = await ctx.serverOps.getBase64EncodedBinaryFileFromPatch(filePath, data.patchId, data.remote);
@@ -2157,7 +1617,7 @@ async function writeBinaryFiles(ctx, fileLastUpdatedByPatchId, patches, entries)
       continue;
     }
     // Base64 so the snapshot stays a text-only entry map; the replay decodes it.
-    entries[`.val/patches/${parentPatchId}/files${filePath}/${path__default["default"].posix.basename(filePath)}.base64`] = buffer.toString("base64");
+    entries[`.val/patches/${data.patchId}/files${filePath}/${path__default["default"].posix.basename(filePath)}.base64`] = buffer.toString("base64");
     wrote = true;
   }
   return wrote;