@jant/core 0.6.15 → 0.7.0

package/README.md

@@ -21,7 +21,7 @@ npm run dev
 For a traditional server deployment, use the official Docker image:
 
 - [`owenyoung/jant`](https://hub.docker.com/r/owenyoung/jant)
-- [Docker deployment guide](https://github.com/jant-me/jant/blob/main/docs/deployment-docker.md)
+- [Docker deployment guide](https://jant.me/docs/deployment-docker)
 
 ## Tech Stack
 
@@ -35,16 +35,16 @@ For a traditional server deployment, use the official Docker image:
 
 ## Documentation
 
-- [Overview](https://github.com/jant-me/jant/blob/main/docs/overview.md)
-- [Getting Started](https://github.com/jant-me/jant/blob/main/docs/getting-started.md)
-- [Writing and Organizing Posts](https://github.com/jant-me/jant/blob/main/docs/writing-and-organizing.md)
-- [Deploy on Cloudflare](https://github.com/jant-me/jant/blob/main/docs/deployment.md)
-- [Deploy with Docker](https://github.com/jant-me/jant/blob/main/docs/deployment-docker.md)
-- [Configuration](https://github.com/jant-me/jant/blob/main/docs/configuration.md)
-- [Export and Import](https://github.com/jant-me/jant/blob/main/docs/export-and-import.md)
-- [Backups and Recovery](https://github.com/jant-me/jant/blob/main/docs/backups.md)
-- [Theming](https://github.com/jant-me/jant/blob/main/docs/theming.md)
-- [API Reference](https://github.com/jant-me/jant/blob/main/docs/API.md)
+- [Overview](https://jant.me/docs)
+- [Getting Started](https://jant.me/docs/getting-started)
+- [Writing and Organizing Posts](https://jant.me/docs/writing-and-organizing)
+- [Deploy on Cloudflare](https://jant.me/docs/deployment)
+- [Deploy with Docker](https://jant.me/docs/deployment-docker)
+- [Configuration](https://jant.me/docs/configuration)
+- [Export and Import](https://jant.me/docs/export-and-import)
+- [Backups and Recovery](https://jant.me/docs/backups)
+- [Theming](https://jant.me/docs/theming)
+- [API Reference](https://jant.me/docs/api)
 
 ## Contributing
 

package/bin/commands/assets/upload.js

@@ -6,14 +6,25 @@
  * Uses the same S3_* environment variables as media storage. Files with
  * content-hashed names (JS, fonts) are skipped if already present in the
  * bucket — they are immutable. Non-hashed files (e.g. CSS in older builds)
- * are always uploaded.
+ * are always uploaded. An object stored without the compression it should
+ * have is re-uploaded even though its key exists, so a change to the
+ * compression policy reaches assets whose content never changed.
+ *
+ * Text assets are uploaded brotli-compressed at maximum quality, with
+ * `Content-Encoding: br`. The CDN in front of the bucket compresses at a fixed
+ * low quality — measured as brotli q4, which is worse than its own gzip — and
+ * offers no way to raise it, so the only route to q11 is to compress here and
+ * store the result. A client that cannot take brotli is unaffected: the edge
+ * decompresses and re-encodes for it (verified against R2 behind a Cloudflare
+ * custom domain: `br` is passed through, `gzip` is re-encoded, `identity` is
+ * decompressed, all three byte-identical after decoding).
  *
  * Intended CI order: build → upload-assets → deploy container
  */
 
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join, relative, extname } from "node:path";
-import { createReadStream } from "node:fs";
+import { brotliCompressSync, constants } from "node:zlib";
 import { parseArgs } from "node:util";
 import { fileURLToPath } from "node:url";
 import { dirname, resolve } from "node:path";
@@ -41,6 +52,59 @@ function getContentType(filePath) {
   );
 }
 
+/**
+ * Extensions worth pre-compressing. Fonts (woff2), images and icons already
+ * carry their own compression, and running brotli over them costs build time
+ * for nothing — usually for a slightly larger file.
+ */
+const COMPRESSIBLE_EXTENSIONS = new Set([
+  ".js",
+  ".css",
+  ".json",
+  ".map",
+  ".svg",
+  ".txt",
+  ".html",
+]);
+
+/**
+ * Brotli-compress an asset for storage, at a quality only a build can afford.
+ *
+ * Quality 11 is far too slow to run per request, which is why CDNs compress
+ * lower. Here it runs once per file per release, and every visitor gets the
+ * result.
+ *
+ * @param {string} filePath - Source path, used only for its extension.
+ * @param {Buffer} body - The file's bytes.
+ * @returns {Buffer | null} The compressed body, or `null` when the type is not
+ * worth compressing or compression failed to shrink it — upload `body` as-is
+ * and omit `Content-Encoding` in that case.
+ * @example
+ * const packed = compressForUpload("client.css", body);
+ * // packed.length < body.length, or null for a .woff2
+ */
+export function compressForUpload(filePath, body) {
+  if (!COMPRESSIBLE_EXTENSIONS.has(extname(filePath).toLowerCase())) {
+    return null;
+  }
+  const compressed = brotliCompressSync(body, {
+    params: {
+      [constants.BROTLI_PARAM_QUALITY]: constants.BROTLI_MAX_QUALITY,
+      [constants.BROTLI_PARAM_SIZE_HINT]: body.length,
+    },
+  });
+  // Tiny or already-dense files can come back bigger. Storing that would make
+  // every request pay for the encoding header and gain nothing.
+  return compressed.length < body.length ? compressed : null;
+}
+
+/** Human-readable byte count for the upload log. */
+function formatBytes(bytes) {
+  return bytes >= 1024 * 1024
+    ? `${(bytes / 1024 / 1024).toFixed(1)} MB`
+    : `${(bytes / 1024).toFixed(1)} KB`;
+}
+
 /**
  * Resolve the default source directory: packages/core/dist/client/_assets
  * relative to this file's location in packages/core/bin/commands/assets/.
@@ -64,8 +128,12 @@ async function walkDir(dir) {
 }
 
 async function loadS3(config) {
-  const { S3Client, PutObjectCommand, ListObjectsV2Command } =
-    await import("@aws-sdk/client-s3");
+  const {
+    S3Client,
+    PutObjectCommand,
+    ListObjectsV2Command,
+    HeadObjectCommand,
+  } = await import("@aws-sdk/client-s3");
   const forcePathStyle = !config.endpoint.includes("amazonaws.com");
   const client = new S3Client({
     endpoint: config.endpoint,
@@ -80,6 +148,7 @@ async function loadS3(config) {
     client,
     PutObjectCommand,
     ListObjectsV2Command,
+    HeadObjectCommand,
     bucket: config.bucket,
   };
 }
@@ -107,6 +176,53 @@ async function listExistingKeys(s3, prefix) {
   return keys;
 }
 
+/**
+ * Of the keys that already exist, the ones stored without the compression they
+ * should have.
+ *
+ * Objects are content-addressed, so a key that exists is assumed to hold the
+ * right bytes and is skipped. That assumption breaks when the *encoding*
+ * changes rather than the content: every asset uploaded before compression was
+ * introduced keeps its key, keeps being skipped, and never picks it up. The
+ * CDN then compresses those at its own low quality on every request, which is
+ * the whole thing compression was meant to avoid.
+ *
+ * Only worth asking about types we would compress, and only when compression
+ * is on. A file that brotli cannot shrink is stored raw on purpose, so its
+ * missing `Content-Encoding` is correct and must not read as stale — otherwise
+ * it would be re-uploaded on every run, forever.
+ *
+ * @param {object} s3 - The client bundle from `loadS3`.
+ * @param {Array<{filePath: string, key: string}>} candidates - Local files
+ * whose key already exists in the bucket.
+ * @returns {Promise<Set<string>>} Keys to upload again.
+ * @example
+ * const stale = await findStaleEncodingKeys(s3, existing);
+ * // Set { "_assets/client-cjk-B7Z0snDu.css" }
+ */
+async function findStaleEncodingKeys(s3, candidates) {
+  const { client, HeadObjectCommand, bucket } = s3;
+  const stale = new Set();
+  const CONCURRENCY = 25;
+
+  for (let i = 0; i < candidates.length; i += CONCURRENCY) {
+    await Promise.all(
+      candidates.slice(i, i + CONCURRENCY).map(async ({ filePath, key }) => {
+        const head = await client.send(
+          new HeadObjectCommand({ Bucket: bucket, Key: key }),
+        );
+        if (head.ContentEncoding === "br") return;
+        // Read it only now: the answer is only interesting for the few objects
+        // that are missing the encoding.
+        const body = await readFile(filePath);
+        if (compressForUpload(filePath, body) !== null) stale.add(key);
+      }),
+    );
+  }
+
+  return stale;
+}
+
 export async function run(argv) {
   const { values } = parseArgs({
     args: argv,
@@ -115,6 +231,8 @@ export async function run(argv) {
       prefix: { type: "string", default: "_assets" },
       "source-dir": { type: "string" },
       "dry-run": { type: "boolean", default: false },
+      force: { type: "boolean", default: false },
+      "no-compress": { type: "boolean", default: false },
     },
   });
 
@@ -135,6 +253,12 @@ export async function run(argv) {
     console.log(
       "      --dry-run             Print what would be uploaded without uploading",
     );
+    console.log(
+      "      --force               Re-upload every key, including ones already compressed",
+    );
+    console.log(
+      "      --no-compress         Upload raw bytes instead of brotli-compressed",
+    );
     process.exit(0);
   }
 
@@ -171,6 +295,8 @@ export async function run(argv) {
   const sourceDir = values["source-dir"] ?? resolveDefaultSourceDir();
   const prefix = values.prefix.replace(/^\/+|\/+$/g, "");
   const dryRun = values["dry-run"];
+  const force = values.force;
+  const compress = !values["no-compress"];
 
   // Verify source directory exists
   try {
@@ -181,10 +307,12 @@ export async function run(argv) {
     process.exit(1);
   }
 
-  console.log(`Source:  ${sourceDir}`);
-  console.log(`Bucket:  ${bucket}`);
-  console.log(`Prefix:  ${prefix}`);
-  if (dryRun) console.log("Dry run: no files will be uploaded");
+  console.log(`Source:   ${sourceDir}`);
+  console.log(`Bucket:   ${bucket}`);
+  console.log(`Prefix:   ${prefix}`);
+  console.log(`Encoding: ${compress ? "brotli (quality 11)" : "raw"}`);
+  if (force) console.log("Force:    re-uploading keys that already exist");
+  if (dryRun) console.log("Dry run:  no files will be uploaded");
   console.log("");
 
   const s3 = await loadS3({
@@ -205,19 +333,57 @@ export async function run(argv) {
   let skipped = 0;
 
   const toUpload = [];
+  const alreadyThere = [];
   for (const filePath of files) {
     const relPath = relative(sourceDir, filePath).replace(/\\/g, "/");
     const key = prefix ? `${prefix}/${relPath}` : relPath;
-    if (existingKeys.has(key)) {
-      skipped++;
+    if (existingKeys.has(key) && !force) {
+      alreadyThere.push({ filePath, key });
     } else {
       toUpload.push({ filePath, key });
     }
   }
 
+  // A key that exists is normally left alone, but that skips objects stored
+  // before compression was introduced — they would keep their old encoding
+  // forever. Re-upload those, and only those.
+  let restored = 0;
+  if (compress && alreadyThere.length > 0) {
+    process.stdout.write("Checking stored encodings... ");
+    const stale = await findStaleEncodingKeys(s3, alreadyThere);
+    for (const entry of alreadyThere) {
+      if (stale.has(entry.key)) toUpload.push(entry);
+      else skipped++;
+    }
+    restored = stale.size;
+    console.log(
+      stale.size === 0
+        ? "all compressed"
+        : `${stale.size} stored uncompressed, re-uploading`,
+    );
+  } else {
+    skipped += alreadyThere.length;
+  }
+
+  // Bytes as stored, against bytes as built — what the compression bought.
+  let rawTotal = 0;
+  let storedTotal = 0;
+
+  /** Read a file and decide how it should be stored. */
+  async function prepare(filePath) {
+    const body = await readFile(filePath);
+    const packed = compress ? compressForUpload(filePath, body) : null;
+    rawTotal += body.length;
+    storedTotal += (packed ?? body).length;
+    return { body: packed ?? body, encoded: packed !== null };
+  }
+
   if (dryRun) {
-    for (const { key } of toUpload) {
-      console.log(`  [dry-run] upload ${key}`);
+    for (const { filePath, key } of toUpload) {
+      const { body, encoded } = await prepare(filePath);
+      console.log(
+        `  [dry-run] upload ${key} (${formatBytes(body.length)}${encoded ? ", br" : ""})`,
+      );
     }
     uploaded = toUpload.length;
   } else {
@@ -226,16 +392,17 @@ export async function run(argv) {
       const batch = toUpload.slice(i, i + CONCURRENCY);
       await Promise.all(
         batch.map(async ({ filePath, key }) => {
-          const body = await readFile(filePath);
+          const { body, encoded } = await prepare(filePath);
           const command = new s3.PutObjectCommand({
             Bucket: s3.bucket,
             Key: key,
             Body: body,
             ContentType: getContentType(filePath),
             CacheControl: "public, max-age=31536000, immutable",
+            ...(encoded ? { ContentEncoding: "br" } : {}),
           });
           await s3.client.send(command);
-          process.stdout.write(`  uploaded ${key}\n`);
+          process.stdout.write(`  uploaded ${key}${encoded ? " (br)" : ""}\n`);
           uploaded++;
         }),
       );
@@ -243,5 +410,15 @@ export async function run(argv) {
   }
 
   console.log("");
-  console.log(`Done. ${uploaded} uploaded, ${skipped} skipped.`);
+  console.log(
+    `Done. ${uploaded} uploaded, ${skipped} skipped` +
+      `${restored > 0 ? `, ${restored} re-uploaded for compression` : ""}.`,
+  );
+  if (compress && rawTotal > 0) {
+    const saved = rawTotal - storedTotal;
+    console.log(
+      `Stored ${formatBytes(storedTotal)} of ${formatBytes(rawTotal)} built ` +
+        `(${formatBytes(saved)} saved, ${((saved / rawTotal) * 100).toFixed(1)}%).`,
+    );
+  }
 }

package/bin/commands/import-site.js

@@ -1290,10 +1290,12 @@ async function apiCall(method, path, apiUrl, token, body) {
       cause === "UNABLE_TO_VERIFY_LEAF_SIGNATURE" ||
       cause?.includes("certificate")
     ) {
-      console.error(`\nSSL certificate error connecting to ${apiUrl}`);
-      console.error("If using a local/self-signed certificate, run with:");
-      console.error("  NODE_TLS_REJECT_UNAUTHORIZED=0 jant import-site ...");
-      console.error("Or use: node --use-system-ca bin/jant.js import-site ...");
+      console.error(`\nCertificate error connecting to ${apiUrl}`);
+      console.error(
+        "The certificate is not signed by a CA that Node trusts. For a local",
+      );
+      console.error("or self-signed target, trust this machine's CA store:");
+      console.error("  NODE_OPTIONS=--use-system-ca jant site import ...");
       process.exit(1);
     }
     throw new Error(
@@ -1462,6 +1464,15 @@ function createRemoteTarget(apiUrl, token) {
         toRemotePostPayload(data),
       );
     },
+    async linkTranslation(postId, otherPostId) {
+      return apiCall(
+        "POST",
+        `/api/posts/${postId}/translations`,
+        apiUrl,
+        token,
+        { postId: otherPostId },
+      );
+    },
     async createAlias(path, targetSlug) {
       return apiCall("POST", "/api/custom-urls", apiUrl, token, {
         path,
@@ -1743,6 +1754,13 @@ function getImportedPostStatus(frontMatter) {
 function shouldImportReplyQuietly(rootFrontMatter, replyFrontMatter) {
   if (getImportedPostStatus(replyFrontMatter) !== "published") return false;
 
+  // Exports since quiet_reply became a stored column say so explicitly.
+  if (typeof replyFrontMatter.quiet_reply === "boolean") {
+    return replyFrontMatter.quiet_reply;
+  }
+
+  // Older bundles: a reply published after the root's recorded last activity
+  // can only have gotten there by skipping the bump, so it was quiet.
   const rootLastActivityAt = getImportedRootLastActivityAt(rootFrontMatter);
   const replyPublishedAt = parseImportTimestamp(replyFrontMatter.date);
   return (
@@ -1817,6 +1835,12 @@ function buildPostPayloadFromBundle(bundle, options) {
         : undefined,
     rating:
       typeof frontMatter.rating === "number" ? frontMatter.rating : undefined,
+    // Roots only: replies take the root's language from the service, and a
+    // reply bundle has no language of its own in the export.
+    language:
+      !options.replyToId && typeof frontMatter.language === "string"
+        ? frontMatter.language
+        : undefined,
     quietReply: options.quietReply ? true : undefined,
   };
 
@@ -1954,6 +1978,8 @@ export async function run(argv) {
   const apiUrl = url.replace(/\/$/, "");
   const skipRemoteMedia = values["skip-remote-media"];
   const target = dryRun ? null : createRemoteTarget(apiUrl, token);
+  /** Exported translation-group ID → IDs of the posts created for it. */
+  const translationGroups = new Map();
 
   // 1. Read source — directory or ZIP
   const inputPath = resolve(process.cwd(), values.path);
@@ -2318,6 +2344,18 @@ export async function run(argv) {
       try {
         post = await target.createPost(postData);
         postsCreated++;
+        // Translation groups are rebuilt after every post exists: the group ID
+        // in the export is opaque and its members can appear in any order, so
+        // there is nothing to link to until the whole run is done.
+        const groupKey =
+          typeof rootFm.translation_group === "string"
+            ? rootFm.translation_group.trim()
+            : "";
+        if (groupKey && post?.id) {
+          const members = translationGroups.get(groupKey) ?? [];
+          members.push(post.id);
+          translationGroups.set(groupKey, members);
+        }
         const replyInfo =
           rootBundle.children.length > 0
             ? ` (+${rootBundle.children.length} replies)`
@@ -2476,6 +2514,28 @@ export async function run(argv) {
       }
     }
 
+    // Rebuild translation groups. Each member is linked to the first one, so a
+    // group of N takes N-1 calls and never asks the server to merge two groups
+    // — which it refuses, on purpose.
+    let translationsLinked = 0;
+    for (const [groupKey, members] of translationGroups) {
+      if (members.length < 2) continue;
+      const [anchor, ...rest] = members;
+      for (const memberId of rest) {
+        try {
+          await target.linkTranslation(anchor, memberId);
+          translationsLinked++;
+        } catch (err) {
+          // A clash here means the export itself held two posts in the same
+          // language for one group. Say so and keep going: the posts are
+          // imported either way, they are just not linked.
+          console.warn(
+            `Warning: could not link a translation in group "${groupKey}": ${err.message}`,
+          );
+        }
+      }
+    }
+
     await target?.close();
 
     // 5. Summary
@@ -2484,6 +2544,9 @@ export async function run(argv) {
     console.log(`  Posts created: ${postsCreated}`);
     console.log(`  Replies created: ${repliesCreated}`);
     console.log(`  Media uploaded: ${mediaUploaded}`);
+    if (translationsLinked > 0) {
+      console.log(`  Translations linked: ${translationsLinked}`);
+    }
     if (aliasesCreated > 0) {
       console.log(`  Aliases created: ${aliasesCreated}`);
     }

package/bin/commands/reset-password.js

@@ -7,7 +7,7 @@ import {
   bootstrapCliRuntime,
   getCliRuntimeLabel,
 } from "../lib/runtime-target.js";
-import { resolveCliSite } from "../lib/site-selection.js";
+import { parseCliSiteSelector, resolveCliSite } from "../lib/site-selection.js";
 
 export async function run(argv) {
   const { values } = parseArgs({
@@ -29,7 +29,9 @@ export async function run(argv) {
   });
 
   if (values.help) {
-    console.log("Usage: jant reset-password [--local | --remote | --node]");
+    console.log(
+      "Usage: jant reset-password [--local | --remote | --node] [--site <key|id> | --host <host> | --url <url>]",
+    );
     console.log("");
     console.log("Generate a password reset token (expires in 15 minutes).");
     console.log("");
@@ -37,7 +39,7 @@ export async function run(argv) {
     console.log("  --local   Force local D1 instead of DATABASE_URL");
     console.log("  --remote  Run against remote D1 database (default: local)");
     console.log("  --node    Force Node runtime even if DATABASE_URL is unset");
-    console.log("  --site    Target site id");
+    console.log("  --site    Target site key or id");
     console.log("  --host    Target site host");
     console.log("  --url     Target site URL");
     console.log("  --path-prefix Path prefix used with --host");
@@ -53,10 +55,20 @@ export async function run(argv) {
       "If DATABASE_URL or DATA_DIR is then set and no runtime flag is passed,",
     );
     console.log("this command uses the Node database runtime.");
+    console.log("");
+    console.log(
+      "With SITE_RESOLUTION_MODE=host-based, pass one of --site, --host, or --url.",
+    );
     process.exit(0);
   }
 
   const { runtime } = bootstrapCliRuntime(values);
+  const siteFlags = {
+    host: values.host,
+    pathPrefix: values["path-prefix"],
+    site: values.site,
+    url: values.url,
+  };
 
   const token = randomBytes(32).toString("hex");
   const hash = createHash("sha256").update(token).digest("hex");
@@ -65,11 +77,15 @@ export async function run(argv) {
   const timestamp = Math.floor(Date.now() / 1000);
 
   if (runtime === "node") {
+    const siteSelector = parseCliSiteSelector(siteFlags);
     const { createNodeCliRuntime } = await loadNodeRuntime();
     const nodeDatabase = await openNodeDatabase(process.env);
 
     try {
-      const nodeRuntime = await createNodeCliRuntime(nodeDatabase.bindings);
+      const nodeRuntime = await createNodeCliRuntime(
+        nodeDatabase.bindings,
+        siteSelector,
+      );
       await nodeRuntime.services.settings.set("PASSWORD_RESET_TOKEN", value);
     } finally {
       await nodeDatabase.close();
@@ -95,10 +111,7 @@ export async function run(argv) {
       },
       {
         env: process.env,
-        host: values.host,
-        pathPrefix: values["path-prefix"],
-        site: values.site,
-        url: values.url,
+        ...siteFlags,
       },
     );
 

package/bin/commands/site/snapshot/export.js

@@ -215,7 +215,7 @@ export async function run(argv) {
     console.log(
       "  --output, -o           Output directory or .zip file (default: jant-site-snapshot)",
     );
-    console.log("  --site                  Target site id");
+    console.log("  --site                  Target site key or id");
     console.log("  --host                  Target site host");
     console.log("  --url                   Target site URL");
     console.log("  --path-prefix           Path prefix used with --host");

package/bin/commands/site/snapshot/import.js

@@ -204,7 +204,7 @@ export async function run(argv) {
     console.log(
       "  --replace               Replace the current content scope before importing",
     );
-    console.log("  --site                  Target site id");
+    console.log("  --site                  Target site key or id");
     console.log("  --host                  Target site host");
     console.log("  --url                   Target site URL");
     console.log("  --path-prefix           Path prefix used with --host");

package/bin/lib/d1-query.js

@@ -1,4 +1,5 @@
 import { runLocalWrangler } from "./wrangler-cli.js";
+import { extractWranglerJson } from "./wrangler-json.js";
 
 const DEFAULT_RETRY_ATTEMPTS = 4;
 const DEFAULT_RETRY_DELAY_MS = 500;
@@ -35,7 +36,7 @@ export function parseWranglerError(output) {
   }
 
   try {
-    const parsed = JSON.parse(output.trim());
+    const parsed = JSON.parse(extractWranglerJson(output).trim());
     const error = Array.isArray(parsed) ? parsed[0]?.error : parsed?.error;
     if (!error?.text) {
       return undefined;
@@ -75,18 +76,6 @@ export function isRetryableWranglerD1Failure(output, error) {
   ].some((fragment) => combined.includes(fragment));
 }
 
-/**
- * Strip non-JSON preamble that Wrangler sometimes writes to stdout
- * (e.g. "Proxy environment variables detected…") before the actual JSON payload.
- */
-function extractJson(raw) {
-  const idx = raw.indexOf("[");
-  const idx2 = raw.indexOf("{");
-  if (idx === -1 && idx2 === -1) return raw;
-  const start = idx === -1 ? idx2 : idx2 === -1 ? idx : Math.min(idx, idx2);
-  return raw.slice(start);
-}
-
 function getWranglerExecutionOptions(options) {
   const executionOptions = { ...options };
   for (const key of [
@@ -153,7 +142,7 @@ export function executeD1(sql, runtime, options = {}) {
 
   if (options.quiet) {
     const output = runWrangler([...args, "--json"], options);
-    const parsed = JSON.parse(extractJson(output));
+    const parsed = JSON.parse(extractWranglerJson(output));
     const statements = Array.isArray(parsed) ? parsed : [parsed];
 
     for (const statement of statements) {
@@ -183,7 +172,7 @@ export function queryD1(sql, runtime, options = {}) {
     ),
     options,
   );
-  const parsed = JSON.parse(extractJson(output));
+  const parsed = JSON.parse(extractWranglerJson(output));
   const statement = Array.isArray(parsed) ? parsed[0] : parsed;
 
   if (statement?.error?.text) {
@@ -208,7 +197,7 @@ export function executeD1File(filePath, runtime, options = {}) {
 
   if (options.quiet) {
     const output = runWrangler([...args, "--json"], options);
-    const parsed = JSON.parse(extractJson(output));
+    const parsed = JSON.parse(extractWranglerJson(output));
     const statements = Array.isArray(parsed) ? parsed : [parsed];
 
     for (const statement of statements) {