diff --git a/src/libarchive/lib.rs b/src/libarchive/lib.rs
index 556fbcc36cc9..966e23082302 100644
--- a/src/libarchive/lib.rs
+++ b/src/libarchive/lib.rs
@@ -1277,7 +1277,9 @@ pub mod archiver {
     pub struct Plucker {
         pub contents: MutableString,
         pub(crate) filename_hash: u64,
+        /// The entry was read into `contents`.
         pub found: bool,
+        /// The entry's file, open for writing, once it holds `contents`.
         pub fd: Fd,
     }
 
@@ -1290,6 +1292,15 @@ pub mod archiver {
                 found: false,
             })
         }
+
+        /// Writes `contents` to `file`, the entry's file, and keeps `file`.
+        #[cold]
+        #[inline(never)]
+        pub(crate) fn take_file(&mut self, file: Fd) -> bun_sys::Result<()> {
+            bun_sys::File::borrow(&file).pwrite_all(self.contents.list.as_slice(), 0)?;
+            self.fd = file;
+            Ok(())
+        }
     }
 
     #[derive(Clone, Copy)]
@@ -1897,7 +1908,7 @@ impl Archiver {
                                                 return Err(crate::Error::Fail);
                                             }
                                             plucker_.found = !plucker_.contents.list.is_empty();
-                                            plucker_.fd = output.fd;
+                                            plucker_.take_file(output.fd)?;
                                             output.close = false;
                                             continue 'loop_;
                                         }
diff --git a/src/runtime/cli/create_command.rs b/src/runtime/cli/create_command.rs
index ec8679815aae..4509ea9b9adc 100644
--- a/src/runtime/cli/create_command.rs
+++ b/src/runtime/cli/create_command.rs
@@ -332,6 +332,12 @@ fn exit_with_conflicts<'a>(destination: &[u8], paths: impl Iterator<Item = &'a [
     Global::exit(1);
 }
 
+#[cold]
+fn exit_package_json_not_written(error: impl core::fmt::Display) -> ! {
+    pretty_errorln!("package.json failed to write due to error {}", error);
+    Global::exit(1);
+}
+
 pub(crate) struct CreateCommand;
 
 impl CreateCommand {
@@ -576,7 +582,7 @@ impl CreateCommand {
                     }
                 }
 
-                let _ = Archiver::extract_to_disk(
+                if let Err(err) = Archiver::extract_to_disk(
                     &tarball_buf_list,
                     destination,
                     Some(&mut archive_context),
@@ -585,16 +591,30 @@ impl CreateCommand {
                         depth_to_skip: 1,
                         ..Default::default()
                     },
-                )?;
+                ) {
+                    // The extractor read package.json and did not get it into its file.
+                    if archive_context
+                        .pluckers
+                        .first()
+                        .is_some_and(|plucker| plucker.found && !plucker.fd.is_valid())
+                    {
+                        node.end();
+                        progress.refresh();
+                        exit_package_json_not_written(bstr::BStr::new(
+                            bun_core::output::ErrName::name(&err),
+                        ));
+                    }
+                    return Err(err.into());
+                }
 
                 if !create_options.skip_package_json {
-                    let plucker = &archive_context.pluckers[0];
+                    let plucker = &mut archive_context.pluckers[0];
 
                     if plucker.found && plucker.fd.is_valid() {
                         node.name = b"Updating package.json";
                         progress.refresh();
 
-                        package_json_contents = plucker.contents.clone()?;
+                        package_json_contents = core::mem::take(&mut plucker.contents);
                         package_json_file = Some(bun_sys::File::from_fd(plucker.fd));
                     }
                 }
@@ -706,7 +726,9 @@ impl CreateCommand {
 
                 template_has_dot_gitignore =
                     bun_sys::exists_at(&template_dir, bun_core::zstr!(".gitignore"));
-                if bun_sys::exists_at(&template_dir, bun_core::zstr!("package.json")) {
+                if !create_options.skip_package_json
+                    && bun_sys::exists_at(&template_dir, bun_core::zstr!("package.json"))
+                {
                     package_json_file = destination_dir
                         .open_file(b"package.json", bun_sys::O::RDWR, 0)
                         .ok();
@@ -756,9 +778,6 @@ impl CreateCommand {
                         let cap = package_json_contents.list.capacity();
                         package_json_contents.list.resize(cap, 0);
 
-                        #[cfg(windows)]
-                        let prev_file_pos = pkg.get_pos()?;
-
                         if let Err(err) =
                             pkg.pread_all(package_json_contents.list.as_mut_slice(), 0)
                         {
@@ -772,10 +791,6 @@ impl CreateCommand {
                             );
                             break 'read_package_json;
                         }
-                        #[cfg(windows)]
-                        pkg.seek_to(prev_file_pos)?;
-                        // The printer doesn't truncate, so we must do so manually
-                        let _ = bun_sys::ftruncate(pkg.handle(), 0);
 
                         bun_ast::initialize_store();
                     }
@@ -827,21 +842,18 @@ impl CreateCommand {
 
         let mut start_command: &[u8] = b"bun dev";
 
-        'process_package_json: {
-            if create_options.skip_package_json {
-                package_json_file = None;
-            }
-
+        {
             if let Some(package_json_file) = &package_json_file {
                 bun_ast::initialize_store();
 
                 let source = bun_ast::Source::init_path_string(
-                    b"package.json",
+                    crate::cli::cli_dupe(bun_paths::resolve_path::join_abs::<
+                        bun_paths::platform::Auto,
+                    >(destination, b"package.json")),
                     package_json_contents.list.as_slice(),
                 );
 
-                // SAFETY: single-threaded CLI dispatch; no other borrow of `Cli::LOG_` is live in this scope.
-                let log: &mut bun_ast::Log = unsafe { ctx.log_mut() };
+                let mut log = bun_ast::Log::init();
                 let bump: &'static bun_alloc::Arena = crate::cli::cli_arena();
                 let parsed = match JSON::parse_package_json_utf8_with_opts(
                     JSON::JSONOptions {
@@ -849,30 +861,28 @@ impl CreateCommand {
                         ..JSON::JSONOptions::DEFAULT
                     },
                     &source,
-                    log,
+                    &mut log,
                     bump,
                 ) {
-                    Ok(r) => r,
-                    Err(_) => {
-                        if log.errors > 0 {
-                            let _ = log.print(std::ptr::from_mut(Output::error_writer()));
+                    Ok(parsed) if parsed.root.data.is_e_object() => parsed,
+                    result => {
+                        if let Ok(parsed) = result {
+                            log.add_error(
+                                Some(&source),
+                                parsed.root.loc,
+                                "package.json root must be an object",
+                            );
                         }
-                        break 'process_package_json;
+                        let _ = log.print(std::ptr::from_mut(Output::error_writer()));
+                        pretty_errorln!(
+                            "<blue>note<r><d>:<r> template files were written. <b>package.json<r> is as the template has it",
+                        );
+                        Global::exit(1);
                     }
                 };
                 let indentation = parsed.indentation;
                 let mut package_json_expr = parsed.root;
 
-                if package_json_expr.data.e_object().is_none() {
-                    break 'process_package_json;
-                }
-
-                if log.errors > 0 {
-                    let _ = log.print(std::ptr::from_mut(Output::error_writer()));
-
-                    break 'process_package_json;
-                }
-
                 if let Some(name_expr) = package_json_expr.as_property(b"name")
                     && let Some(mut s) = name_expr.expr.data.e_string()
                 {
@@ -1025,17 +1035,13 @@ impl CreateCommand {
                         ..Default::default()
                     },
                 ) {
-                    bun_core::pretty_errorln!("package.json failed to write due to error {}", err,);
-                    break 'process_package_json;
+                    exit_package_json_not_written(err);
                 }
                 let written = package_json_writer.ctx.get_written();
-                if let Err(err) = package_json_file.write_all(written).and_then(|()| {
+                if let Err(err) = package_json_file.pwrite_all(written, 0).and_then(|()| {
                     bun_sys::ftruncate(package_json_file.handle, written.len() as i64)
                 }) {
-                    bun_core::pretty_errorln!(
-                        "package.json failed to write due to error {}",
-                        bstr::BStr::new(err.name()),
-                    );
+                    exit_package_json_not_written(bstr::BStr::new(err.name()));
                 }
             }
         }
diff --git a/test/cli/install/bun-create.test.ts b/test/cli/install/bun-create.test.ts
index 4a1c095847b4..520be249a46b 100644
--- a/test/cli/install/bun-create.test.ts
+++ b/test/cli/install/bun-create.test.ts
@@ -2,7 +2,7 @@ import { spawn, spawnSync } from "bun";
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "bun:test";
 import { chmodSync, lstatSync, mkdirSync, readdirSync, statSync, symlinkSync } from "fs";
 import { exists, stat } from "fs/promises";
-import { bunExe, bunEnv as env, githubTarball, isASAN, isPosix, tempDir, tls, tmpdirSync } from "harness";
+import { bunExe, bunEnv as env, githubTarball, isASAN, isMacOS, isPosix, tempDir, tls, tmpdirSync } from "harness";
 import { once } from "node:events";
 import * as nodetls from "node:tls";
 import { delimiter, join } from "path";
@@ -338,11 +338,16 @@ const gitIdentity = {
   GIT_COMMITTER_EMAIL: "t@t.t",
 };
 
-/** `bun create ...args` in `cwd`; local templates are looked up in `<cwd>/bun-create`. */
-async function create(cwd: string, args: string[], extraEnv: Record<string, string | undefined> = {}) {
+/** `bun create ...args` in `cwd`; local templates are looked up in `<cwd>/bun-create`. `wrapper` is a command that runs it. */
+async function create(
+  cwd: string,
+  args: string[],
+  extraEnv: Record<string, string | undefined> = {},
+  wrapper: string[] = [],
+) {
   const merged = { ...env, BUN_CREATE_DIR: join(cwd, "bun-create"), ...extraEnv };
   await using proc = spawn({
-    cmd: [bunExe(), "create", ...args],
+    cmd: [...wrapper, bunExe(), "create", ...args],
     cwd,
     env: merged,
     stdin: "ignore",
@@ -350,9 +355,15 @@ async function create(cwd: string, args: string[], extraEnv: Record<string, stri
     stderr: "pipe",
   });
   const [out, err, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
-  return { out, err, exitCode };
+  return { out, err, exitCode, signalCode: proc.signalCode };
 }
 
+/**
+ * A wrapper for `create`: a write past 2048 bytes of a file fails with EFBIG. POSIX only.
+ * The sh of macOS (bash 3.2) counts blocks of 1024 bytes, the others count blocks of 512.
+ */
+const fileSizeLimit = ["sh", "-c", `trap '' XFSZ; ulimit -f ${isMacOS ? 2 : 4} && exec "$@"`, "sh"];
+
 async function git(cwd: string, ...args: string[]) {
   await using proc = spawn({
     cmd: ["git", ...args],
@@ -897,9 +908,9 @@ for (const [status, expected] of [
   });
 }
 
-/** Serves `files` as the tarball of every GitHub repository. `env` points `bun create` at it and at the test registry. */
-async function serveGithub(files: Record<string, string>) {
-  const tarball = await githubTarball("dylan-conway-create-test-0123abc", files);
+/** Serves `files`, or a gzipped tarball as it is, as the tarball of every GitHub repository. `env` points `bun create` at it and at the test registry. */
+async function serveGithub(files: Record<string, string> | Uint8Array) {
+  const tarball = files instanceof Uint8Array ? files : await githubTarball("dylan-conway-create-test-0123abc", files);
   const requests: string[] = [];
   const server = Bun.serve({
     tls,
@@ -1155,6 +1166,162 @@ describe.concurrent.each(["local", "GitHub"])("a link in the destination of a %s
   });
 });
 
+// Every exit that did not print package.json again left it with 0 bytes, and most of them exited 0.
+describe.concurrent.each(["local", "GitHub"])("the package.json of a %s template", kind => {
+  const withSection = `{\n  "name": "a-long-template-name",\n  "version": "1.0.0",\n  "bun-create": {\n    "start": "bun run ok"\n  }\n}\n`;
+  const missingValue = `{\n  "name": "tpl",\n  "version": \n}\n`;
+  const mine = `{\n  "name": "mine"\n}\n`;
+  const note = "note: template files were written. package.json is as the template has it\n";
+  /** One line with `keys` keys. bun create prints each key on a line of its own, which is 4 bytes more. */
+  const oneLine = (keys: number) =>
+    JSON.stringify({ name: "tpl", ...Object.fromEntries(Array.from({ length: keys }, (_, i) => [`k${1000 + i}`, 0])) });
+
+  /** `bun create <template of files> dest --no-install ...args`, next to the files of `existing`. `dest` is what it holds afterwards. */
+  async function createFrom(
+    files: Record<string, string>,
+    existing: Record<string, string>,
+    args: string[] = [],
+    wrapper: string[] = [],
+  ) {
+    using github = await serveGithub(files);
+    using dir = tempDir("create-package-json", { "bun-create/tpl": files, ...existing });
+    const result = await create(
+      String(dir),
+      [kind === "local" ? "tpl" : "dylan-conway/create-test", "dest", "--no-install", ...args],
+      github.env,
+      wrapper,
+    );
+    return { ...result, dest: await tree(join(String(dir), "dest")) };
+  }
+
+  it("is printed again over the longer text of the template", async () => {
+    const { out, err, exitCode, dest } = await createFrom({ "package.json": withSection }, {}, ["--no-git"]);
+
+    expect(dest).toEqual({ "package.json": `{\n  "name": "dest",\n  "version": "1.0.0"\n}\n` });
+    expect(err).not.toContain("error");
+    expect(out).toContain("\n  cd dest\n  bun run ok\n");
+    expect(exitCode).toBe(0);
+  });
+
+  it("is the template's with --no-package-json", async () => {
+    const { out, err, exitCode, dest } = await createFrom({ "package.json": withSection }, {}, [
+      "--no-git",
+      "--no-package-json",
+    ]);
+
+    expect(dest).toEqual({ "package.json": withSection });
+    expect(err).not.toContain("error");
+    expect(out).toContain("\n  cd dest\n  bun dev\n");
+    expect(exitCode).toBe(0);
+  });
+
+  it("is the destination's own when the template has none", async () => {
+    const { err, exitCode, dest } = await createFrom({ "index.js": "// hi\n" }, { "dest/package.json": mine }, [
+      "--no-git",
+    ]);
+
+    expect(dest).toEqual({ "index.js": "// hi\n", "package.json": mine });
+    expect(err).not.toContain("error");
+    expect(exitCode).toBe(0);
+  });
+
+  // The command stops before git: `dest` holds no repository.
+  it.each([
+    ["does not parse", missingValue, "error: Unexpected }"],
+    ["has a root that is not an object", "[1, 2, 3]\n", "error: package.json root must be an object"],
+  ])("is the template's when it %s, and the command fails", async (_, text, error) => {
+    const { out, err, exitCode, dest } = await createFrom({ "package.json": text, "index.js": "// hi\n" }, {});
+
+    expect(dest).toEqual({ "index.js": "// hi\n", "package.json": text });
+    expect(err).toContain(error);
+    expect(err).toContain(note);
+    expect(err).not.toContain("] git");
+    expect(out).toBe("");
+    expect(exitCode).toBe(1);
+  });
+
+  it("is the template's when --force put it over the destination's own and it does not parse", async () => {
+    const { err, exitCode, dest } = await createFrom(
+      { "package.json": missingValue, "index.js": "// hi\n" },
+      { "dest/package.json": mine, "dest/keep.txt": "mine" },
+      ["--force"],
+    );
+
+    expect(dest).toEqual({ "index.js": "// hi\n", "keep.txt": "mine", "package.json": missingValue });
+    expect(err).toContain(note);
+    expect(exitCode).toBe(1);
+  });
+
+  it("is the template's when the command stops at a .gitignore it cannot replace", async () => {
+    const { err, exitCode, dest } = await createFrom(
+      { "package.json": withSection, "gitignore": "template" },
+      { "dest/.gitignore/inner.txt": "mine" },
+      ["--no-git"],
+    );
+
+    expect(dest).toEqual({ ".gitignore/inner.txt": "mine", "gitignore": "template", "package.json": withSection });
+    expect(err).toContain(": renaming gitignore to .gitignore\n");
+    expect(exitCode).toBe(1);
+  });
+
+  it.skipIf(!isPosix)("stops the command when its new text cannot be written", async () => {
+    // 1.6 KB on one line, and 2.3 KB with a line for each key.
+    const text = oneLine(180);
+    const { out, err, exitCode, signalCode } = await createFrom(
+      { "package.json": text },
+      {},
+      ["--no-git"],
+      fileSizeLimit,
+    );
+
+    expect(text.length).toBeLessThan(2048);
+    expect(err).toContain("package.json failed to write due to error EFBIG\n");
+    expect(out).toBe("");
+    expect({ exitCode, signalCode }).toEqual({ exitCode: 1, signalCode: null });
+  });
+
+  if (kind === "GitHub") {
+    it("is the template's when a later entry of the tarball is cut short", async () => {
+      using github = await serveGithub(
+        gzipSync(
+          Buffer.concat([
+            tarEntry("pkg/package.json", Buffer.from(withSection)),
+            // The header declares 4096 bytes. The archive ends after it.
+            tarEntry("pkg/zz.txt", Buffer.alloc(4096)).subarray(0, 512),
+          ]),
+        ),
+      );
+      using dir = tempDir("create-package-json-cut", {});
+      const { out, err, exitCode } = await create(
+        String(dir),
+        ["dylan-conway/create-test", "dest", "--no-git", "--no-install"],
+        github.env,
+      );
+
+      expect(await Bun.file(join(String(dir), "dest", "package.json")).text()).toBe(withSection);
+      expect(err).toContain("Unexpected");
+      expect(out).not.toContain("Success!");
+      expect(exitCode).toBe(1);
+    });
+
+    it.skipIf(!isPosix)("is the start of the template's when the extractor cannot write all of it", async () => {
+      const text = oneLine(400);
+      const { out, err, exitCode, signalCode, dest } = await createFrom(
+        { "package.json": text },
+        {},
+        ["--no-git"],
+        fileSizeLimit,
+      );
+
+      expect(text.length).toBeGreaterThan(2048);
+      expect(dest).toEqual({ "package.json": text.slice(0, 2048) });
+      expect(err).toContain("package.json failed to write due to error EFBIG\n");
+      expect(out).toBe("");
+      expect({ exitCode, signalCode }).toEqual({ exitCode: 1, signalCode: null });
+    });
+  }
+});
+
 it.concurrent("should preserve package.json indentation from the template", async () => {
   using dir = tempDir("create-tabs", {
     "bun-create/tabs/package.json": `{\n\t"name": "tabs",\n\t"version": "1.0.0",\n\t"scripts": {\n\t\t"start": "bun index.js"\n\t}\n}\n`,