@sproutboat/toolchain 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @sproutboat/toolchain
 
+## 0.8.1
+
+### Patch Changes
+
+- 742e61c: A CLI compiled with `bun build --compile` builds again. 0.8.0 embedded the patch sources with text imports to fingerprint them, but Bun bundles a text import of `patch.ts` as the module `patch.ts` is everywhere else, so compiling failed with `No matching export ... for import "default"`. The fingerprint now hashes the sources when they are on disk, and falls back to the fingerprint they were released with (`RELEASED_FINGERPRINT`, kept current by a test). The value is unchanged, so existing caches stay valid.
+
 ## 0.8.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/toolchain",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/fingerprint.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import { readdir } from "node:fs/promises";
-import { PATCH_FINGERPRINT, PATCH_SOURCES } from "./fingerprint";
+import { PATCH_FINGERPRINT, PATCH_SOURCES, RELEASED_FINGERPRINT, sourceFingerprint } from "./fingerprint";
 
 // Not part of the patched compiler: acquisition, the barrel, generators and this module.
 const NOT_PATCH_SOURCES = new Set(["acquire.ts", "index.ts", "fingerprint.ts"]);
@@ -9,8 +9,20 @@ test("the patch fingerprint covers every toolchain module that shapes the compil
   const modules = (await readdir(import.meta.dir)).filter(
     (name) => name.endsWith(".ts") && !name.endsWith(".test.ts") && !name.startsWith("gen-") && !NOT_PATCH_SOURCES.has(name),
   );
-  expect(Object.keys(PATCH_SOURCES).sort()).toEqual(modules.sort());
-  const embedded = new Map<string, string>(Object.entries(PATCH_SOURCES));
-  for (const name of modules) expect(embedded.get(name)).toBe(await Bun.file(`${import.meta.dir}/${name}`).text());
+  expect(modules.sort()).toEqual(PATCH_SOURCES.map(String).sort());
   expect(PATCH_FINGERPRINT).toMatch(/^[0-9a-f]{12}$/);
+  expect(PATCH_FINGERPRINT).toBe(sourceFingerprint(import.meta.dir)!);
+  expect(sourceFingerprint("/nonexistent")).toBeNull();
+});
+
+// A compiled CLI falls back to RELEASED_FINGERPRINT, so it must match the sources.
+test("RELEASED_FINGERPRINT matches the sources", async () => {
+  const actual = sourceFingerprint(import.meta.dir)!;
+  if (process.env.UPDATE_FINGERPRINT && actual !== RELEASED_FINGERPRINT) {
+    const file = `${import.meta.dir}/fingerprint.ts`;
+    const text = await Bun.file(file).text();
+    await Bun.write(file, text.replace(`RELEASED_FINGERPRINT = "${RELEASED_FINGERPRINT}"`, `RELEASED_FINGERPRINT = "${actual}"`));
+    return;
+  }
+  expect(RELEASED_FINGERPRINT, "run UPDATE_FINGERPRINT=1 bun test packages/toolchain/src/fingerprint.test.ts").toBe(actual);
 });

package/src/fingerprint.ts

@@ -1,48 +1,44 @@
 import { createHash } from "node:crypto";
-// The patch chain's own source text, embedded by Bun's text loader (it survives
-// `bun build --compile`, where these files do not exist on disk). TypeScript sees
-// a module, not a string, hence the expect-errors.
-// @ts-expect-error text import
-import caseMap from "./case-map.ts" with { type: "text" };
-// @ts-expect-error text import
-import fetchClasses from "./fetch-classes.ts" with { type: "text" };
-// @ts-expect-error text import
-import headersClass from "./headers-class.ts" with { type: "text" };
-// @ts-expect-error text import
-import patch from "./patch.ts" with { type: "text" };
-// @ts-expect-error text import
-import pin from "./pin.ts" with { type: "text" };
-// @ts-expect-error text import
-import streaming from "./streaming.ts" with { type: "text" };
-// @ts-expect-error text import
-import textDecoder from "./text-decoder.ts" with { type: "text" };
-// @ts-expect-error text import
-import unicode from "./unicode.ts" with { type: "text" };
-// @ts-expect-error text import
-import urlClass from "./url-class.ts" with { type: "text" };
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 
 /** Every module that shapes the patched compiler. fingerprint.test.ts fails when one is missing. */
-export const PATCH_SOURCES = {
-  "case-map.ts": caseMap,
-  "fetch-classes.ts": fetchClasses,
-  "headers-class.ts": headersClass,
-  "patch.ts": patch,
-  "pin.ts": pin,
-  "streaming.ts": streaming,
-  "text-decoder.ts": textDecoder,
-  "unicode.ts": unicode,
-  "url-class.ts": urlClass,
-} satisfies Record<string, string>;
+export const PATCH_SOURCES = [
+  "case-map.ts",
+  "fetch-classes.ts",
+  "headers-class.ts",
+  "patch.ts",
+  "pin.ts",
+  "streaming.ts",
+  "text-decoder.ts",
+  "unicode.ts",
+  "url-class.ts",
+] as const;
+
+/**
+ * The fingerprint of the sources as released. A compiled CLI (`bun build --compile`) has
+ * no source files to hash, and cannot embed them either: Bun bundles a text import of
+ * patch.ts as the module patch.ts is everywhere else. Kept current by fingerprint.test.ts
+ * (UPDATE_FINGERPRINT=1 bun test packages/toolchain/src/fingerprint.test.ts).
+ */
+export const RELEASED_FINGERPRINT = "f0ff426f97b0";
+
+/** The fingerprint of the sources in dir, or null where they are not on disk. */
+export function sourceFingerprint(dir: string): string | null {
+  const hash = createHash("sha256");
+  try {
+    for (const name of PATCH_SOURCES) hash.update(`${name}\0${readFileSync(join(dir, name), "utf8")}\0`);
+  } catch {
+    return null;
+  }
+  return hash.digest("hex").slice(0, 12);
+}
 
 /**
  * Identifies the patch chain, not just the toolchain release. A cache entry is keyed by it, so
  * an edited patch gets a fresh, fully patched compiler instead of one a same-version build
  * already marked complete (B19: the prelude began calling sb_stream_*, which only the new
- * chain defines, and every build against an older entry failed to link).
+ * chain defines, and every build against an older entry failed to link). From the sources
+ * when they are on disk, so an unreleased edit counts at once; else as released.
  */
-export const PATCH_FINGERPRINT = (() => {
-  const hash = createHash("sha256");
-  for (const [name, source] of Object.entries(PATCH_SOURCES).sort(([a], [b]) => a.localeCompare(b)))
-    hash.update(`${name}\0${source}\0`);
-  return hash.digest("hex").slice(0, 12);
-})();
+export const PATCH_FINGERPRINT = sourceFingerprint(import.meta.dir) ?? RELEASED_FINGERPRINT;