@volter/editor-core 0.5.57

package/server/adapter-region-includes.ts

@@ -0,0 +1,47 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { AdapterRegionIncludes } from '../src/ui-source/adapter-region-includes';
+import {
+  ADAPTER_MODULE_FILENAME,
+  EMPTY_REGION_INCLUDES,
+  parseAdapterRegionIncludes,
+} from '../src/ui-source/adapter-region-includes';
+
+/**
+ * The dev server's filesystem half of the adapter's region `include`
+ * globs — the pure parse lives in `../src/ui-source/adapter-region-includes.ts`
+ * (browser-safe, because Content's component index reads the same declaration
+ * through a storage backend), and this adds only "read the file beside the
+ * manifest, once, and cache it".
+ */
+
+/** Cache: project directory -> its adapter's region includes. Same
+ *  no-invalidation bar as the manifest-roots cache beside it — editing
+ *  `vgai.adapter.ts` already restarts the dev session. */
+const cache = new Map<string, AdapterRegionIncludes>();
+
+/** Region includes declared by the `vgai.adapter.ts` beside `manifestDir`. A
+ *  project with no adapter module gets the native default: no includes. */
+export function adapterRegionIncludes(manifestDir: string): AdapterRegionIncludes {
+  const cached = cache.get(manifestDir);
+  if (cached !== undefined) return cached;
+  let result = EMPTY_REGION_INCLUDES;
+  try {
+    result = parseAdapterRegionIncludes(
+      readFileSync(join(manifestDir, ADAPTER_MODULE_FILENAME), 'utf8'),
+    );
+  } catch (err) {
+    // No adapter module is the DECLARED native default. Any other fs error is a
+    // real environment problem and is not swallowed into "declares nothing".
+    if ((err as NodeJS.ErrnoException)?.code !== 'ENOENT') throw err;
+  }
+  cache.set(manifestDir, result);
+  return result;
+}
+
+/** Test-only: forget what has been read. */
+export function resetAdapterRegionIncludesCacheForTest(): void {
+  cache.clear();
+}
+
+export { ADAPTER_MODULE_FILENAME };

package/server/asset-catalog-v2.ts

@@ -0,0 +1,175 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import {
+  type AssetCatalog,
+  type AssetFamily,
+  AssetFileSchema,
+  type AssetVariant,
+  parseAssetCatalog,
+} from '../src/asset-workflow/asset-types';
+
+/**
+ * ONE catalog record — the generator's intermediate representation, produced
+ * by `scripts/sync-asset-library.ts` while it walks the SSD library and
+ * folded into families by `buildAssetCatalogV2`. It is NOT a persisted format:
+ * the only on-disk catalog is v2 (`AssetCatalogEnvelopeSchema`).
+ */
+export const CatalogRecordSchema = z
+  .object({
+    id: z.string().regex(/^[a-f0-9]{24}$/),
+    source: z.string().min(1),
+    name: z.string().min(1),
+    type: z.enum(['model', 'animation', 'source']),
+    categories: z.array(z.string()),
+    tags: z.array(z.string()),
+    license: z.string().min(1),
+    author: z.string().min(1),
+    sourceUrl: z.string().url(),
+    thumbnail: z.string().min(1).optional(),
+    files: z.array(AssetFileSchema).min(1),
+    animationCount: z.number().int().nonnegative().optional(),
+    clipNames: z.array(z.string()).optional(),
+  })
+  .strict();
+
+export type CatalogRecord = z.infer<typeof CatalogRecordSchema>;
+
+/**
+ * REMOVED-FORMAT guard. `catalog.json` v1 — `{ version: 1, generatedAt,
+ * assets: [...] }`, a flat variant list with no families — was accepted on
+ * read and migrated in memory by `migrateLegacyAssetCatalog`. Both are
+ * deleted: v2 is the only catalog format, and `scripts/sync-asset-library.ts`
+ * writes v2 directly.
+ *
+ * Zod's envelope would reject a v1 file anyway, but with `version: expected 2,
+ * received 1` and no hint about what happened — so this runs FIRST and names
+ * the removal, the same way every other retired on-disk format in this repo
+ * does.
+ */
+export function assertNoRemovedAssetCatalogV1(input: unknown, path: string): void {
+  if (
+    input &&
+    typeof input === 'object' &&
+    'version' in input &&
+    (input as { version: unknown }).version !== 2
+  ) {
+    throw new Error(
+      `Asset catalog "${path}" declares version ` +
+        `${JSON.stringify((input as { version: unknown }).version)}. The v1 catalog format ` +
+        '(`{ version: 1, assets: [...] }`) and its read-time migration ' +
+        '(`migrateLegacyAssetCatalog`) were REMOVED — v2 (`{ version: 2, families: [...] }`) ' +
+        'is the only format. Re-run `scripts/sync-asset-library.ts`, which writes v2 directly.',
+    );
+  }
+}
+
+function normalizeFamilyName(name: string): string {
+  return name
+    .trim()
+    .toLocaleLowerCase('en-US')
+    .replace(/\s+/g, ' ')
+    .replace(/\s+\(final\)$/, '');
+}
+
+/**
+ * Generator-only semantic key. It is persisted as an explicit family id in v2;
+ * search/preview code never reconstructs it. Collection segments prevent two
+ * unrelated packs with the same display name from aliasing.
+ */
+export function catalogFamilyKey(asset: CatalogRecord): string {
+  const segments = asset.files[0]!.path.replaceAll('\\', '/').split('/');
+  return JSON.stringify([
+    asset.source,
+    segments[1] ?? '',
+    segments[2] ?? '',
+    normalizeFamilyName(asset.name),
+  ]);
+}
+
+export function makeCatalogFamilyId(key: string): string {
+  return createHash('sha256').update(`family\0${key}`).digest('hex').slice(0, 24);
+}
+
+function uniqueSorted(values: Iterable<string>): string[] {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+
+function familyType(records: readonly CatalogRecord[]): AssetFamily['type'] {
+  if (records.some((record) => record.type === 'model')) return 'model';
+  if (records.some((record) => record.type === 'animation')) return 'animation';
+  return 'source';
+}
+
+function variantFromRecord(record: CatalogRecord): AssetVariant {
+  return {
+    id: record.id,
+    label: record.files.map((file) => file.label).join(' + '),
+    type: record.type,
+    files: record.files,
+    deliveries: [
+      {
+        id: `local:${record.id}`,
+        kind: 'local-ssd',
+        available: true,
+        fileIndexes: record.files.map((_, index) => index),
+      },
+    ],
+    thumbnail: {
+      path: record.thumbnail ?? `thumbnails/${record.id}.webp`,
+      state: 'generated',
+      profileVersion: 'thumbnail-v1',
+    },
+    ...(record.animationCount !== undefined ? { animationCount: record.animationCount } : {}),
+    ...(record.clipNames !== undefined ? { clipNames: record.clipNames } : {}),
+  };
+}
+
+export function buildAssetCatalogV2(
+  records: readonly CatalogRecord[],
+  generatedAt: string,
+): AssetCatalog {
+  const grouped = new Map<string, CatalogRecord[]>();
+  for (const record of records) {
+    const key = catalogFamilyKey(record);
+    const siblings = grouped.get(key);
+    if (siblings) siblings.push(record);
+    else grouped.set(key, [record]);
+  }
+
+  const seenFamilyIds = new Map<string, string>();
+  const seenVariantIds = new Set<string>();
+  const families: AssetFamily[] = [];
+  for (const [key, siblings] of grouped) {
+    siblings.sort((left, right) => left.id.localeCompare(right.id));
+    const first = siblings[0]!;
+    const id = makeCatalogFamilyId(key);
+    const priorKey = seenFamilyIds.get(id);
+    if (priorKey && priorKey !== key) throw new Error(`Catalog family id collision: ${id}`);
+    seenFamilyIds.set(id, key);
+    for (const sibling of siblings) {
+      if (seenVariantIds.has(sibling.id))
+        throw new Error(`Duplicate catalog variant id: ${sibling.id}`);
+      seenVariantIds.add(sibling.id);
+    }
+    families.push({
+      id,
+      source: first.source,
+      name: first.name.replace(/\s+\(final\)$/, ''),
+      type: familyType(siblings),
+      categories: uniqueSorted(siblings.flatMap((record) => record.categories)),
+      tags: uniqueSorted(siblings.flatMap((record) => record.tags)),
+      license: first.license,
+      author: first.author,
+      sourceUrl: first.sourceUrl,
+      variants: siblings.map(variantFromRecord),
+    });
+  }
+  families.sort(
+    (left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id),
+  );
+  return parseAssetCatalog({ version: 2, generatedAt, families });
+}
+
+export function serializableAssetCatalog(catalog: AssetCatalog): object {
+  return { version: 2, generatedAt: catalog.generatedAt, families: catalog.families };
+}

package/server/asset-history-snapshots.ts

@@ -0,0 +1,196 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import {
+  cp,
+  mkdir,
+  mkdtemp,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile,
+} from 'node:fs/promises';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { PROJECT_PROVENANCE_PATH } from './support/project/provenance';
+import { isPathInside } from './server-utils';
+
+interface AssetHistorySnapshotMetadata {
+  version: 1;
+  assetPath: string;
+  destination: string;
+  assetPresent: boolean;
+  provenancePresent: boolean;
+}
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+function normalizedAssetPath(assetPath: string): string {
+  const normalized = assetPath.replaceAll('\\', '/').replace(/^\/+/, '');
+  if (
+    !normalized.startsWith('asset-library/') ||
+    normalized.includes('\0') ||
+    normalized.split('/').includes('..') ||
+    basename(normalized) === ''
+  ) {
+    throw new Error('Asset history paths must name a file under public/asset-library/.');
+  }
+  return normalized;
+}
+
+async function hashFile(hash: ReturnType<typeof createHash>, path: string): Promise<void> {
+  const info = await stat(path);
+  hash.update(`file:${info.size}:`);
+  for await (const chunk of createReadStream(path)) hash.update(chunk as Buffer);
+}
+
+async function hashDirectory(
+  hash: ReturnType<typeof createHash>,
+  root: string,
+  directory: string,
+): Promise<void> {
+  const entries = (await readdir(directory, { withFileTypes: true })).sort((left, right) =>
+    left.name.localeCompare(right.name),
+  );
+  for (const entry of entries) {
+    const absolute = join(directory, entry.name);
+    const path = relative(root, absolute).split(sep).join('/');
+    if (entry.isDirectory()) {
+      hash.update(`directory:${path}\0`);
+      await hashDirectory(hash, root, absolute);
+    } else if (entry.isFile()) {
+      hash.update(`path:${path}\0`);
+      await hashFile(hash, absolute);
+    } else {
+      throw new Error(`Asset history cannot snapshot special filesystem entry ${absolute}.`);
+    }
+  }
+}
+
+/**
+ * Content-addressed, server-resident snapshots for one imported asset directory.
+ * History stores only the stable digest token in browser memory; exact model,
+ * dependency, recipe, thumbnail, and provenance bytes stay under `.vgai/tmp`.
+ */
+export class AssetHistorySnapshots {
+  private readonly projectRoot: string;
+  private readonly snapshotRoot: string;
+
+  constructor(private readonly publicRoot: string) {
+    this.projectRoot = dirname(publicRoot);
+    this.snapshotRoot = resolve(this.projectRoot, '.vgai', 'tmp', 'asset-history-snapshots');
+  }
+
+  async capture(assetPath: string): Promise<string> {
+    const normalized = normalizedAssetPath(assetPath);
+    const destination = resolve(this.publicRoot, dirname(normalized));
+    if (!isPathInside(this.publicRoot, destination)) {
+      throw new Error('Asset history destination escapes public/.');
+    }
+    const provenance = resolve(this.projectRoot, PROJECT_PROVENANCE_PATH);
+    const metadata: AssetHistorySnapshotMetadata = {
+      version: 1,
+      assetPath: normalized,
+      destination: relative(this.projectRoot, destination).split(sep).join('/'),
+      assetPresent: await pathExists(destination),
+      provenancePresent: await pathExists(provenance),
+    };
+    const hash = createHash('sha256');
+    hash.update(JSON.stringify(metadata));
+    if (metadata.assetPresent) await hashDirectory(hash, destination, destination);
+    if (metadata.provenancePresent) {
+      hash.update('provenance\0');
+      await hashFile(hash, provenance);
+    }
+    const token = hash.digest('hex');
+    const snapshot = resolve(this.snapshotRoot, token);
+    if (await pathExists(snapshot)) return token;
+
+    await mkdir(this.snapshotRoot, { recursive: true });
+    const staging = await mkdtemp(resolve(this.snapshotRoot, `.capture-${randomUUID()}-`));
+    try {
+      if (metadata.assetPresent)
+        await cp(destination, resolve(staging, 'asset'), { recursive: true });
+      if (metadata.provenancePresent) await cp(provenance, resolve(staging, 'provenance.json'));
+      await writeFile(resolve(staging, 'metadata.json'), `${JSON.stringify(metadata, null, 2)}\n`);
+      try {
+        await rename(staging, snapshot);
+      } catch (error) {
+        if (!(await pathExists(snapshot))) throw error;
+      }
+    } finally {
+      await rm(staging, { recursive: true, force: true });
+    }
+    return token;
+  }
+
+  async restore(assetPath: string, token: string): Promise<void> {
+    const normalized = normalizedAssetPath(assetPath);
+    if (!/^[a-f0-9]{64}$/.test(token)) throw new Error('Invalid asset history snapshot token.');
+    const snapshot = resolve(this.snapshotRoot, token);
+    const metadata = JSON.parse(
+      await readFile(resolve(snapshot, 'metadata.json'), 'utf8'),
+    ) as AssetHistorySnapshotMetadata;
+    if (metadata.version !== 1 || metadata.assetPath !== normalized) {
+      throw new Error('Asset history snapshot identity does not match the selected asset.');
+    }
+    const destination = resolve(this.projectRoot, metadata.destination);
+    const expectedDestination = resolve(this.publicRoot, dirname(normalized));
+    if (destination !== expectedDestination || !isPathInside(this.publicRoot, destination)) {
+      throw new Error('Asset history snapshot destination is invalid.');
+    }
+    const provenance = resolve(this.projectRoot, PROJECT_PROVENANCE_PATH);
+    const transaction = await mkdtemp(
+      resolve(this.projectRoot, '.vgai', 'tmp', `.asset-history-restore-${randomUUID()}-`),
+    );
+    const stagedAsset = resolve(transaction, 'staged-asset');
+    const backupAsset = resolve(transaction, 'backup-asset');
+    const stagedProvenance = resolve(transaction, 'staged-provenance.json');
+    const backupProvenance = resolve(transaction, 'backup-provenance.json');
+    let assetBackedUp = false;
+    let assetInstalled = false;
+    let provenanceBackedUp = false;
+    let provenanceInstalled = false;
+    try {
+      if (metadata.assetPresent)
+        await cp(resolve(snapshot, 'asset'), stagedAsset, { recursive: true });
+      if (metadata.provenancePresent) {
+        await cp(resolve(snapshot, 'provenance.json'), stagedProvenance);
+      }
+      await mkdir(dirname(destination), { recursive: true });
+      if (await pathExists(destination)) {
+        await rename(destination, backupAsset);
+        assetBackedUp = true;
+      }
+      if (metadata.assetPresent) {
+        await rename(stagedAsset, destination);
+        assetInstalled = true;
+      }
+      await mkdir(dirname(provenance), { recursive: true });
+      if (await pathExists(provenance)) {
+        await rename(provenance, backupProvenance);
+        provenanceBackedUp = true;
+      }
+      if (metadata.provenancePresent) {
+        await rename(stagedProvenance, provenance);
+        provenanceInstalled = true;
+      }
+    } catch (error) {
+      if (provenanceInstalled) await rm(provenance, { force: true });
+      if (provenanceBackedUp) await rename(backupProvenance, provenance);
+      if (assetInstalled) await rm(destination, { recursive: true, force: true });
+      if (assetBackedUp) await rename(backupAsset, destination);
+      throw error;
+    } finally {
+      await rm(transaction, { recursive: true, force: true });
+    }
+  }
+}

package/server/asset-ledger-store.ts

@@ -0,0 +1,195 @@
+/**
+ * Filesystem side of the asset provenance ledger (D-AP3).
+ *
+ * The shape, validation and merge rules live in the pure module
+ * `../src/asset-workflow/asset-ledger.ts`; this file is only read-modify-write
+ * of `<projectRoot>/.vgai/assets.json`.
+ *
+ * That read-modify-write is CONCURRENT-SAFE, and both halves are load-bearing
+ * (see `../src/asset-workflow/ledger-write-lock.ts` for why neither alone is
+ * enough):
+ *
+ *   - Same process: a promise chain per ledger path, so two overlapping
+ *     `recordAssetMaterialization` calls do not both read the pre-write object
+ *     and lose the earlier record.
+ *   - Other processes: an exclusive `assets.json.lock` beside the ledger.
+ *     Two `vgai edit` sessions, or `asset-packs:sync` racing an editor, are
+ *     separate processes and the in-process chain cannot see them.
+ *
+ * The write itself is ATOMIC — staging file then `rename` — so a crash or a
+ * concurrent READER never observes a half-serialized ledger. A truncated
+ * provenance record reads as "these assets were never materialized", which is
+ * exactly the silent-drop failure D-AP3 exists to prevent.
+ */
+
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import {
+  ASSET_LEDGER_PATH,
+  type AssetLedger,
+  type AssetLedgerEntry,
+  normalizeLedgerPath,
+  parseAssetLedgerJson,
+  serializeAssetLedger,
+  sourceHashFromSha256,
+  upsertAssetLedgerEntry,
+} from '../src/asset-workflow/asset-ledger';
+import {
+  createSerializer,
+  type ExclusiveLockIO,
+  type ExclusiveLockOptions,
+  removeIfHeldByTakeover,
+  withExclusiveLock,
+} from '../src/asset-workflow/ledger-write-lock';
+
+export function assetLedgerFile(projectRoot: string): string {
+  return join(projectRoot, ...ASSET_LEDGER_PATH.split('/'));
+}
+
+/** Read the ledger. Absent → `{}`. Corrupt → throws, never silently reset. */
+export async function readAssetLedger(projectRoot: string): Promise<AssetLedger> {
+  let text: string;
+  try {
+    text = await readFile(assetLedgerFile(projectRoot), 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return {};
+    throw error;
+  }
+  return parseAssetLedgerJson(text);
+}
+
+export async function writeAssetLedger(projectRoot: string, ledger: AssetLedger): Promise<void> {
+  const file = assetLedgerFile(projectRoot);
+  await mkdir(dirname(file), { recursive: true });
+  // Staging + rename: `rename` within one directory is atomic, so a reader sees
+  // either the old ledger or the new one, never a partial write.
+  const staging = `${file}.writing-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+  await writeFile(staging, serializeAssetLedger(ledger), 'utf8');
+  try {
+    await rename(staging, file);
+  } catch (error) {
+    await rm(staging, { force: true });
+    throw error;
+  }
+}
+
+/**
+ * Run `work` while holding the ledger's CROSS-PROCESS lock.
+ *
+ * Exported for the concurrency test, which needs the on-disk half without the
+ * in-process chain in front of it — a file lock cannot exclude its own holder,
+ * so the two halves can only be proven separately.
+ */
+export async function withAssetLedgerFileLock<T>(
+  projectRoot: string,
+  work: () => Promise<T>,
+  options: ExclusiveLockOptions = {},
+): Promise<T> {
+  const lockFile = `${assetLedgerFile(projectRoot)}.lock`;
+  await mkdir(dirname(lockFile), { recursive: true });
+  return withExclusiveLock(ledgerLockIo(lockFile), work, {
+    owner: `pid ${process.pid}`,
+    ...options,
+  });
+}
+
+/**
+ * The `node:fs` lock I/O for ANY ledger file, exported for the lock's own tests
+ * — the interesting behavior here is per-operation (who may break a corpse,
+ * what a release leaves behind) and is not reachable through
+ * `withAssetLedgerFileLock`.
+ *
+ * Nothing in it is asset-specific: it takes the lock PATH. The project's
+ * central provenance ledger (`.vgai/provenance.json`, another whole-document
+ * read-modify-write, now written by the editor server AND by `vgai blender-mcp`)
+ * takes the same lock through `server/project-output-writer.ts`.
+ */
+export function ledgerLockIo(lockFile: string): ExclusiveLockIO {
+  /** `wx` = create-or-fail: the one primitive here that is a true atomic CAS. */
+  const createExclusive = async (path: string, content: string): Promise<boolean> => {
+    try {
+      await writeFile(path, content, { encoding: 'utf8', flag: 'wx' });
+      return true;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'EEXIST') return false;
+      throw error;
+    }
+  };
+  const readOrNull = async (path: string): Promise<string | null> => {
+    try {
+      return await readFile(path, 'utf8');
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+      throw error;
+    }
+  };
+
+  return {
+    createIfAbsent: (content) => createExclusive(lockFile, content),
+    read: () => readOrNull(lockFile),
+    // A filesystem has no atomic compare-and-delete, so this is a TAKEOVER:
+    // `rename` (one syscall) decides which racer may break a given lock, and
+    // the comparison happens after the seize rather than before it. See
+    // `removeIfHeldByTakeover` for why read-then-unlink is not good enough and
+    // for the residual window this still leaves.
+    removeIfHeldBy: (expected) => {
+      // Private to this attempt, so concurrent attempts never collide here.
+      const aside = `${lockFile}.breaking-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+      return removeIfHeldByTakeover(
+        {
+          moveAside: async () => {
+            try {
+              await rename(lockFile, aside);
+              return true;
+            } catch (error) {
+              // ENOENT — another racer seized it first, or it is simply gone.
+              if ((error as NodeJS.ErrnoException).code === 'ENOENT') return false;
+              throw error;
+            }
+          },
+          readAside: () => readOrNull(aside),
+          deleteAside: () => rm(aside, { force: true }),
+          restoreIfAbsent: (content) => createExclusive(lockFile, content),
+        },
+        expected,
+      );
+    },
+  };
+}
+
+export interface MaterializationRecord {
+  /** Project root — the directory that owns `.vgai/`. */
+  readonly projectRoot: string;
+  /** Project-relative destination, e.g. `public/asset-library/local/x/y.glb`. */
+  readonly destPath: string;
+  /** `source:id` — the library's identity for this asset. */
+  readonly key: string;
+  /** License string as the library reported it, if it reported one. */
+  readonly license?: string | undefined;
+  /** The LIBRARY's sha256 of the source bytes. Omit when the library has none —
+   *  never substitute a hash of the bytes we just wrote (anti-shim). */
+  readonly sourceSha256?: string | undefined;
+  readonly materializedAt?: string;
+}
+
+/** In-process serialization, keyed by the ledger file each record targets. */
+const serializeLedgerWrite = createSerializer();
+
+/** Record one materialization in the project's ledger. */
+export async function recordAssetMaterialization(record: MaterializationRecord): Promise<void> {
+  const entry: AssetLedgerEntry = {
+    key: record.key,
+    ...(record.license ? { license: record.license } : {}),
+    ...(record.sourceSha256 ? { sourceHash: sourceHashFromSha256(record.sourceSha256) } : {}),
+    materializedAt: record.materializedAt ?? new Date().toISOString(),
+  };
+  await serializeLedgerWrite(assetLedgerFile(record.projectRoot), () =>
+    withAssetLedgerFileLock(record.projectRoot, async () => {
+      const ledger = await readAssetLedger(record.projectRoot);
+      await writeAssetLedger(
+        record.projectRoot,
+        upsertAssetLedgerEntry(ledger, normalizeLedgerPath(record.destPath), entry),
+      );
+    }),
+  );
+}