@decocms/blocks-cli 7.0.0

package/scripts/deco-migrate-cli.ts

@@ -0,0 +1,444 @@
+#!/usr/bin/env tsx
+/**
+ * deco-migrate CLI — one command to clone, migrate, and verify a Deco site.
+ *
+ * Usage:
+ *   npx tsx scripts/deco-migrate-cli.ts <repo-or-dir> [options]
+ *
+ * Examples:
+ *   # Clone from GitHub, migrate, compare against golden reference:
+ *   npx tsx scripts/deco-migrate-cli.ts https://github.com/org/my-site \
+ *     --output ~/work/my-site-migrated \
+ *     --ref ~/work/my-site-storefront
+ *
+ *   # Migrate from local directory:
+ *   npx tsx scripts/deco-migrate-cli.ts ./old-site --output ./migrated-site
+ *
+ *   # Quick re-run (wipe + re-migrate):
+ *   npx tsx scripts/deco-migrate-cli.ts ./old-site --output ./migrated-site --clean
+ *
+ *   # Dry run:
+ *   npx tsx scripts/deco-migrate-cli.ts ./old-site --dry-run --verbose
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync, spawnSync } from "node:child_process";
+import { banner, stat, red, green, yellow, cyan, bold, dim, icons } from "./migrate/colors";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface CliOpts {
+  source: string;
+  output: string | null;
+  ref: string | null;
+  dryRun: boolean;
+  verbose: boolean;
+  clean: boolean;
+  skipBootstrap: boolean;
+  help: boolean;
+  branch: string | null;
+}
+
+function parseArgs(args: string[]): CliOpts {
+  const opts: CliOpts = {
+    source: "",
+    output: null,
+    ref: null,
+    dryRun: false,
+    verbose: false,
+    clean: false,
+    skipBootstrap: false,
+    help: false,
+    branch: null,
+  };
+
+  const positional: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--output":
+      case "-o":
+        opts.output = args[++i];
+        break;
+      case "--ref":
+      case "--reference":
+        opts.ref = args[++i];
+        break;
+      case "--branch":
+      case "-b":
+        opts.branch = args[++i];
+        break;
+      case "--dry-run":
+        opts.dryRun = true;
+        break;
+      case "--verbose":
+      case "-v":
+        opts.verbose = true;
+        break;
+      case "--clean":
+        opts.clean = true;
+        break;
+      case "--skip-bootstrap":
+        opts.skipBootstrap = true;
+        break;
+      case "--help":
+      case "-h":
+        opts.help = true;
+        break;
+      default:
+        if (!arg.startsWith("-")) positional.push(arg);
+    }
+  }
+
+  if (positional.length > 0) opts.source = positional[0];
+  return opts;
+}
+
+function showHelp() {
+  console.log(`
+  ${bold("deco-migrate")} — Clone, migrate, and verify a Deco storefront
+
+  ${bold("Usage:")}
+    npx tsx scripts/deco-migrate-cli.ts <repo-url-or-dir> [options]
+
+  ${bold("Arguments:")}
+    <repo-url-or-dir>     Git repo URL or local directory path
+
+  ${bold("Options:")}
+    -o, --output <dir>    Output directory (default: <name>-migrated)
+    --ref <dir>           Golden reference directory to diff against
+    -b, --branch <name>   Git branch to clone (default: main)
+    --dry-run             Preview changes without writing files
+    -v, --verbose         Show detailed output for every file
+    --clean               Wipe output dir before migrating (for re-runs)
+    --skip-bootstrap      Skip npm install + codegen after migration
+    -h, --help            Show this help message
+
+  ${bold("Examples:")}
+    ${dim("# Clone from GitHub and migrate:")}
+    npx tsx scripts/deco-migrate-cli.ts https://github.com/org/my-site
+
+    ${dim("# Migrate local dir, compare against golden reference:")}
+    npx tsx scripts/deco-migrate-cli.ts ./casaevideo \\
+      --ref ./casaevideo-storefront
+
+    ${dim("# Quick re-run (wipe previous output first):")}
+    npx tsx scripts/deco-migrate-cli.ts ./casaevideo \\
+      -o ./casaevideo-migrated --clean
+
+    ${dim("# Dry run to preview what would change:")}
+    npx tsx scripts/deco-migrate-cli.ts ./casaevideo --dry-run -v
+`);
+}
+
+function isGitUrl(source: string): boolean {
+  return (
+    source.startsWith("https://") ||
+    source.startsWith("git@") ||
+    source.startsWith("http://") ||
+    source.endsWith(".git")
+  );
+}
+
+function extractRepoName(source: string): string {
+  // https://github.com/org/my-site.git → my-site
+  // https://github.com/org/my-site → my-site
+  // ./path/to/my-site → my-site
+  const base = path.basename(source.replace(/\.git$/, ""));
+  return base || "site";
+}
+
+function run(cmd: string, cwd?: string, label?: string): boolean {
+  if (label) console.log(`  ${dim("$")} ${dim(cmd)}`);
+  try {
+    execSync(cmd, {
+      cwd,
+      stdio: label ? "pipe" : "inherit",
+      timeout: 120_000,
+    });
+    if (label) console.log(`  ${icons.success} ${label}`);
+    return true;
+  } catch (e: any) {
+    if (label) {
+      console.log(`  ${icons.error} ${label}: ${e.message?.split("\n")[0] || "failed"}`);
+    }
+    return false;
+  }
+}
+
+function cloneRepo(source: string, dest: string, branch: string | null): boolean {
+  console.log(`\n  Cloning ${cyan(source)}...`);
+  const branchArg = branch ? ` --branch ${branch}` : "";
+  const depthArg = " --depth 1";
+  const ok = run(
+    `git clone${depthArg}${branchArg} "${source}" "${dest}"`,
+    undefined,
+    "Clone repository",
+  );
+  if (!ok) return false;
+
+  // Strip remote to prevent accidental pushes
+  run(`git remote remove origin`, dest, "Remove git remote");
+  return true;
+}
+
+function copyLocal(source: string, dest: string): boolean {
+  console.log(`\n  Copying ${cyan(source)} → ${cyan(dest)}...`);
+  try {
+    // Use cp -r, excluding .git and node_modules
+    execSync(
+      `rsync -a --exclude='.git' --exclude='node_modules' --exclude='_fresh' --exclude='.wrangler' "${source}/" "${dest}/"`,
+      { stdio: "pipe", timeout: 120_000 },
+    );
+    console.log(`  ${icons.success} Copied source directory`);
+
+    // Init fresh git so the migration has a clean baseline
+    run(`git init`, dest);
+    run(`git add -A && git commit -m "pre-migration snapshot" --allow-empty`, dest);
+    return true;
+  } catch (e: any) {
+    console.log(`  ${icons.error} Copy failed: ${e.message?.split("\n")[0]}`);
+    return false;
+  }
+}
+
+function runMigration(
+  dest: string,
+  scriptDir: string,
+  opts: { dryRun: boolean; verbose: boolean; skipBootstrap: boolean },
+): boolean {
+  const migrateScript = path.join(scriptDir, "migrate.ts");
+  const args = ["tsx", migrateScript, "--source", dest];
+  if (opts.dryRun) args.push("--dry-run");
+  if (opts.verbose) args.push("--verbose");
+
+  console.log("");
+  const result = spawnSync("npx", args, {
+    cwd: scriptDir.replace(/\/scripts$/, ""),
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      SKIP_BOOTSTRAP: opts.skipBootstrap ? "1" : "",
+    },
+    timeout: 300_000,
+  });
+
+  return result.status === 0;
+}
+
+function diffAgainstRef(migrated: string, ref: string): void {
+  banner("Comparing against golden reference");
+  stat("Migrated", migrated);
+  stat("Reference", ref);
+
+  if (!fs.existsSync(ref)) {
+    console.log(`\n  ${icons.error} Reference dir does not exist: ${ref}`);
+    return;
+  }
+
+  const migratedSrc = path.join(migrated, "src");
+  const refSrc = path.join(ref, "src");
+
+  if (!fs.existsSync(migratedSrc) || !fs.existsSync(refSrc)) {
+    console.log(`\n  ${icons.error} One or both src/ directories missing`);
+    return;
+  }
+
+  // 1. File count comparison
+  console.log(`\n  ${bold("File counts:")}`);
+  const countFiles = (dir: string, ext: string): number => {
+    try {
+      const result = execSync(
+        `find "${dir}" -name "*${ext}" -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/server/*" | wc -l`,
+        { encoding: "utf-8" },
+      );
+      return parseInt(result.trim(), 10);
+    } catch {
+      return 0;
+    }
+  };
+
+  for (const [label, subdir] of [
+    ["sections", "sections"],
+    ["components", "components"],
+    ["loaders", "loaders"],
+    ["hooks", "hooks"],
+    ["sdk", "sdk"],
+    ["types", "types"],
+  ] as const) {
+    const mDir = path.join(migratedSrc, subdir);
+    const rDir = path.join(refSrc, subdir);
+    const mCount = fs.existsSync(mDir) ? countFiles(mDir, ".tsx") + countFiles(mDir, ".ts") : 0;
+    const rCount = fs.existsSync(rDir) ? countFiles(rDir, ".tsx") + countFiles(rDir, ".ts") : 0;
+    const delta = mCount - rCount;
+    const deltaStr = delta === 0 ? green("=") : delta > 0 ? yellow(`+${delta}`) : red(`${delta}`);
+    console.log(`    ${label.padEnd(14)} migrated: ${String(mCount).padStart(4)}  ref: ${String(rCount).padStart(4)}  (${deltaStr})`);
+  }
+
+  // 2. Key import pattern checks
+  console.log(`\n  ${bold("Remaining old imports (migrated):")}`);
+  const grepCount = (dir: string, pattern: string): number => {
+    try {
+      const result = execSync(
+        `grep -rl '${pattern}' "${dir}" --include='*.ts' --include='*.tsx' 2>/dev/null | grep -v node_modules | grep -v '/server/' | wc -l`,
+        { encoding: "utf-8" },
+      );
+      return parseInt(result.trim(), 10);
+    } catch {
+      return 0;
+    }
+  };
+
+  const patterns = [
+    ["from \"preact", "preact imports"],
+    ["from \"@preact/", "@preact/* imports"],
+    ["from \"@deco/deco", "@deco/deco imports"],
+    ["from \"$fresh/", "$fresh imports"],
+    ['from "apps/', "apps/* imports"],
+    ['from "site/', "site/* imports"],
+    ['from "$store/', "$store/* imports"],
+    ["export const cache", "old cache exports"],
+  ];
+
+  for (const [pattern, label] of patterns) {
+    const count = grepCount(migratedSrc, pattern);
+    const icon = count === 0 ? icons.success : icons.warning;
+    console.log(`    ${icon} ${label}: ${count} files`);
+  }
+
+  // 3. Missing scaffolded files
+  console.log(`\n  ${bold("Scaffolded file parity:")}`);
+  const checkFiles = [
+    "setup.ts",
+    "cache-config.ts",
+    "worker-entry.ts",
+    "server.ts",
+    "router.tsx",
+    "runtime.ts",
+    "setup/commerce-loaders.ts",
+    "setup/section-loaders.ts",
+    "hooks/useCart.ts",
+    "hooks/useUser.ts",
+    "hooks/useWishlist.ts",
+    "types/widgets.ts",
+    "types/deco.ts",
+    "components/ui/Image.tsx",
+    "components/ui/Picture.tsx",
+    "styles/app.css",
+    "routes/__root.tsx",
+    "routes/$.tsx",
+    "routes/index.tsx",
+  ];
+
+  for (const file of checkFiles) {
+    const mExists = fs.existsSync(path.join(migratedSrc, file));
+    const rExists = fs.existsSync(path.join(refSrc, file));
+    if (mExists && rExists) {
+      console.log(`    ${icons.success} ${file}`);
+    } else if (!mExists && rExists) {
+      console.log(`    ${icons.error} ${file} — ${red("missing in migrated")}`);
+    } else if (mExists && !rExists) {
+      console.log(`    ${icons.info} ${file} — ${dim("extra in migrated (not in ref)")}`);
+    }
+  }
+
+  // 4. public/ assets
+  console.log(`\n  ${bold("public/ assets:")}`);
+  const mPublic = path.join(migrated, "public");
+  const rPublic = path.join(ref, "public");
+  const mPubCount = fs.existsSync(mPublic) ? countFiles(mPublic, "") : 0;
+  const rPubCount = fs.existsSync(rPublic) ? countFiles(rPublic, "") : 0;
+  console.log(`    migrated: ${mPubCount} files, ref: ${rPubCount} files`);
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+
+  if (opts.help || !opts.source) {
+    showHelp();
+    process.exit(opts.help ? 0 : 1);
+  }
+
+  const scriptDir = path.resolve(__dirname, ".");
+  const repoName = extractRepoName(opts.source);
+  const outputDir = path.resolve(opts.output || `${repoName}-migrated`);
+
+  banner("deco-migrate CLI");
+  stat("Source", opts.source);
+  stat("Output", outputDir);
+  if (opts.ref) stat("Reference", path.resolve(opts.ref));
+  stat("Mode", opts.dryRun ? yellow("DRY RUN") : green("EXECUTE"));
+
+  // Clean output dir if requested
+  if (opts.clean && fs.existsSync(outputDir)) {
+    console.log(`\n  Cleaning ${outputDir}...`);
+    fs.rmSync(outputDir, { recursive: true, force: true });
+    console.log(`  ${icons.success} Cleaned output directory`);
+  }
+
+  // Check if output already exists
+  if (fs.existsSync(outputDir) && !opts.dryRun) {
+    const srcDir = path.join(outputDir, "src");
+    if (fs.existsSync(srcDir)) {
+      console.log(`\n  ${icons.error} Output directory already exists and has src/: ${outputDir}`);
+      console.log(`  ${dim("Use --clean to wipe it first, or choose a different --output")}`);
+      process.exit(1);
+    }
+  }
+
+  // Step 1: Get the source code
+  let acquired = false;
+  if (isGitUrl(opts.source)) {
+    acquired = cloneRepo(opts.source, outputDir, opts.branch);
+  } else {
+    const sourceDir = path.resolve(opts.source);
+    if (!fs.existsSync(sourceDir)) {
+      console.log(`\n  ${icons.error} Source directory not found: ${sourceDir}`);
+      process.exit(1);
+    }
+    acquired = copyLocal(sourceDir, outputDir);
+  }
+
+  if (!acquired) {
+    console.log(`\n  ${red("Failed to acquire source. Aborting.")}`);
+    process.exit(1);
+  }
+
+  // Step 2: Run migration
+  const migrationOk = runMigration(outputDir, scriptDir, {
+    dryRun: opts.dryRun,
+    verbose: opts.verbose,
+    skipBootstrap: opts.skipBootstrap || opts.dryRun,
+  });
+
+  // Step 3: Compare against reference (if provided)
+  if (opts.ref && !opts.dryRun) {
+    diffAgainstRef(outputDir, path.resolve(opts.ref));
+  }
+
+  // Final status
+  console.log("");
+  if (migrationOk) {
+    banner("Migration complete");
+    console.log(`\n  ${green("Output:")} ${outputDir}`);
+    if (!opts.dryRun) {
+      console.log(`\n  ${bold("Next steps:")}`);
+      console.log(`    cd ${outputDir}`);
+      console.log(`    npm install`);
+      console.log(`    npm run generate:blocks`);
+      console.log(`    npm run generate:schema`);
+      console.log(`    npx tsr generate`);
+      console.log(`    npm run dev`);
+    }
+  } else {
+    console.log(`  ${yellow("Migration completed with issues.")} Check the report above.`);
+    console.log(`  ${dim("Output:")} ${outputDir}`);
+  }
+  console.log("");
+}
+
+main();

package/scripts/fast-deploy-kv.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it, vi } from "vitest";
+import { computeRevision, KV_KEYS } from "@decocms/blocks/cms";
+import { createKvRestClient, kvConfigFromEnv } from "./lib/cf-kv-rest";
+import { buildSnapshot, verifySnapshotInKv, writeSnapshotToKv } from "./lib/kv-snapshot";
+import {
+  changedBlockFiles,
+  changedBlockKeys,
+  purgePathsForChangedKeys,
+} from "./lib/sync-helpers";
+
+describe("kvConfigFromEnv", () => {
+  it("reads the three CF vars", () => {
+    expect(
+      kvConfigFromEnv({ CF_ACCOUNT_ID: "a", CF_KV_NAMESPACE_ID: "n", CF_API_TOKEN: "t" }),
+    ).toEqual({ accountId: "a", namespaceId: "n", token: "t" });
+  });
+
+  it("throws listing all missing vars", () => {
+    expect(() => kvConfigFromEnv({ CF_ACCOUNT_ID: "a" })).toThrow(
+      /CF_KV_NAMESPACE_ID, CF_API_TOKEN/,
+    );
+  });
+});
+
+describe("createKvRestClient", () => {
+  const config = { accountId: "acc", namespaceId: "ns", token: "tok" };
+
+  it("PUTs to the values endpoint with auth + body", async () => {
+    const fetchImpl = vi.fn(async () => new Response("", { status: 200 })) as unknown as typeof fetch;
+    const client = createKvRestClient({ ...config, fetchImpl });
+    await client.put(KV_KEYS.REVISION, "rev1");
+
+    const [url, init] = (fetchImpl as unknown as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(url).toContain("/accounts/acc/storage/kv/namespaces/ns/values/");
+    expect(url).toContain(encodeURIComponent(KV_KEYS.REVISION));
+    expect(init.method).toBe("PUT");
+    expect(init.headers.Authorization).toBe("Bearer tok");
+    expect(init.body).toBe("rev1");
+  });
+
+  it("GET returns null on 404", async () => {
+    const fetchImpl = vi.fn(async () => new Response("nope", { status: 404 })) as unknown as typeof fetch;
+    const client = createKvRestClient({ ...config, fetchImpl });
+    await expect(client.get("missing")).resolves.toBeNull();
+  });
+
+  it("GET returns the body text on 200", async () => {
+    const fetchImpl = vi.fn(async () => new Response("hello", { status: 200 })) as unknown as typeof fetch;
+    const client = createKvRestClient({ ...config, fetchImpl });
+    await expect(client.get("k")).resolves.toBe("hello");
+  });
+
+  it("throws on a non-404 error status", async () => {
+    const fetchImpl = vi.fn(async () => new Response("boom", { status: 500 })) as unknown as typeof fetch;
+    const client = createKvRestClient({ ...config, fetchImpl });
+    await expect(client.get("k")).rejects.toThrow(/500/);
+  });
+});
+
+describe("kv-snapshot helpers", () => {
+  const blocks = { Site: { name: "x" }, "pages-home": { path: "/" } };
+
+  it("buildSnapshot uses the runtime computeRevision", () => {
+    const snap = buildSnapshot(blocks);
+    expect(snap.revision).toBe(computeRevision(blocks));
+    expect(snap.snapshot).toBe(JSON.stringify(blocks));
+    expect(snap.count).toBe(2);
+  });
+
+  it("writes snapshot before revision, then verifies round-trip", async () => {
+    const store = new Map<string, string>();
+    const order: string[] = [];
+    const client = {
+      get: (k: string) => Promise.resolve(store.get(k) ?? null),
+      put: (k: string, v: string) => {
+        order.push(k);
+        store.set(k, v);
+        return Promise.resolve();
+      },
+    };
+    const snap = buildSnapshot(blocks);
+    await writeSnapshotToKv(client, snap);
+
+    expect(order).toEqual([KV_KEYS.SNAPSHOT, KV_KEYS.REVISION]);
+    await expect(verifySnapshotInKv(client, snap.revision)).resolves.toEqual({ ok: true });
+  });
+
+  it("verify fails when the revision mismatches", async () => {
+    const store = new Map<string, string>([
+      [KV_KEYS.SNAPSHOT, "{}"],
+      [KV_KEYS.REVISION, "other"],
+    ]);
+    const client = { get: (k: string) => Promise.resolve(store.get(k) ?? null), put: () => Promise.resolve() };
+    const res = await verifySnapshotInKv(client, "expected");
+    expect(res.ok).toBe(false);
+  });
+});
+
+describe("sync-helpers", () => {
+  it("changedBlockFiles filters to the blocks dir and .json", () => {
+    const out = [
+      ".deco/blocks/pages-home.json",
+      ".deco/blocks/Site.json",
+      "src/components/Foo.tsx",
+      "README.md",
+      ".deco/blocks/notjson.txt",
+    ].join("\n");
+    expect(changedBlockFiles(out, ".deco/blocks")).toEqual([
+      ".deco/blocks/pages-home.json",
+      ".deco/blocks/Site.json",
+    ]);
+  });
+
+  it("changedBlockKeys decodes URL-encoded filenames", () => {
+    expect(changedBlockKeys([".deco/blocks/pages-Home%20-%20LB-1.json"])).toEqual([
+      "pages-Home - LB-1",
+    ]);
+  });
+
+  it("purgePathsForChangedKeys collects page paths + always '/'", () => {
+    const blocks = {
+      "pages-home": { path: "/" },
+      "pages-pdp": { path: "/produto/:slug/p" },
+      Site: { name: "x" }, // no path
+    };
+    const paths = purgePathsForChangedKeys(blocks, ["pages-pdp", "Site"]);
+    expect(paths).toContain("/");
+    expect(paths).toContain("/produto/:slug/p");
+    expect(paths).not.toContain(undefined);
+  });
+});

package/scripts/generate-blocks.test.ts

@@ -0,0 +1,94 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { readBlockDelta } from "./generate-blocks";
+
+describe("readBlockDelta", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(path.join(tmpdir(), "deco-blocks-"));
+  });
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const write = (name: string, value: unknown) =>
+    writeFileSync(path.join(dir, name), JSON.stringify(value), "utf-8");
+
+  it("upserts only the changed files, keyed by single-decoded name", () => {
+    write("Site.json", { __resolveType: "site" });
+    write("pages-Home.json", { path: "/" });
+
+    const delta = readBlockDelta({
+      blocksDir: dir,
+      files: [{ name: "pages-Home.json", isDelete: false }],
+      silent: true,
+    });
+
+    // Only the changed file is present — the untouched Site block is not read.
+    expect(delta).toEqual({ "pages-Home": { path: "/" } });
+  });
+
+  it("decodes the filename exactly once (matches the runtime block key)", () => {
+    // Studio round-trips encodeURIComponent(blockKey) -> filename, so a key
+    // with a space lands on disk single-encoded.
+    write("pages-Home%20-%20LB.json", { path: "/lb" });
+
+    const delta = readBlockDelta({
+      blocksDir: dir,
+      files: [{ name: "pages-Home%20-%20LB.json", isDelete: false }],
+      silent: true,
+    });
+
+    expect(delta).toEqual({ "pages-Home - LB": { path: "/lb" } });
+  });
+
+  it("maps deletes to null so applyDelta removes the block", () => {
+    const delta = readBlockDelta({
+      blocksDir: dir,
+      files: [{ name: "pages-Gone.json", isDelete: true }],
+      silent: true,
+    });
+
+    expect(delta).toEqual({ "pages-Gone": null });
+  });
+
+  it("skips files that fail to parse (partial write in progress)", () => {
+    writeFileSync(path.join(dir, "pages-Half.json"), "{ not valid json", "utf-8");
+    write("pages-Good.json", { path: "/good" });
+
+    const delta = readBlockDelta({
+      blocksDir: dir,
+      files: [
+        { name: "pages-Half.json", isDelete: false },
+        { name: "pages-Good.json", isDelete: false },
+      ],
+      silent: true,
+    });
+
+    // The unparseable file is dropped; the valid one still comes through.
+    expect(delta).toEqual({ "pages-Good": { path: "/good" } });
+  });
+
+  it("skips a missing upsert target without throwing", () => {
+    const delta = readBlockDelta({
+      blocksDir: dir,
+      files: [{ name: "pages-Missing.json", isDelete: false }],
+      silent: true,
+    });
+
+    expect(delta).toEqual({});
+  });
+
+  it("ignores non-json entries", () => {
+    const delta = readBlockDelta({
+      blocksDir: dir,
+      files: [{ name: "notes.txt", isDelete: false }],
+      silent: true,
+    });
+
+    expect(delta).toEqual({});
+  });
+});