write-language 0.1.210 → 0.1.211

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "write-language",
-  "version": "0.1.210",
+  "version": "0.1.211",
   "description": "Multi-provider language generation toolkit using Vercel AI SDK - generate responses with 10+ LLM providers including OpenAI, Anthropic, Google, and more.",
   "author": "vtempest <grokthiscontact@gmail.com>",
   "license": "rights.institute/PROSPER",

package/src/utils/prism-global.ts

@@ -1,21 +1,81 @@
 /**
- * @fileoverview Publishes Prism on `globalThis` so the `prismjs/components/*`
- * grammar scripts can find it.
+ * @fileoverview Owns the Prism instance: publishes it on `globalThis`, then
+ * registers the language grammars that prismjs' own entry point leaves out —
+ * without ever depending on module evaluation order.
  *
- * Those grammar files are plain browser scripts, not modules — `prism-markup.js`
- * literally opens with `Prism.languages.markup = {...}`, resolving `Prism` as a
- * free variable off the global object. Prism's core only publishes that global
- * when it can see `window` (browser), a `WorkerGlobalScope` `self`, or Node's
- * `global`. On Cloudflare Workers / edge runtimes none of the three exist, so
- * the first grammar file throws `ReferenceError: Prism is not defined` while the
- * module graph is still evaluating, taking the whole SSR render down with it.
+ * The `prismjs/components/*` files are plain browser scripts, not modules:
+ * `prism-markup.js` literally opens with `Prism.languages.markup = {...}`,
+ * resolving `Prism` as a free variable off the global object. Someone has to
+ * put it there first. prismjs' own entry point does that for `window`
+ * (browser) and `global` (Node); on Cloudflare Workers / edge runtimes it sees
+ * neither, which is what the assignment below is for.
  *
- * Import this module *before* any `prismjs/components/*` import. ES modules are
- * evaluated in import order, so this file's body runs — and the global lands —
- * before the grammars reference it.
+ * Publishing it is only half the job, though: it has to happen *before* the
+ * grammar scripts run, and a static `import "prismjs/components/..."` cannot
+ * promise that once a bundler is in the loop. Those files declare no
+ * dependency on Prism — reading a global is invisible to the module graph — so
+ * nothing pins them after whoever publishes it, and a bundler is free to hoist
+ * them, split them into another chunk, or drop the publishing statement as a
+ * dead `globalThis` write. When that happens the chunk dies on load with
+ * `ReferenceError: Prism is not defined`, which takes down the whole route
+ * that lazily imported it rather than just the syntax highlighting.
+ *
+ * So the grammars are loaded with `import()` from inside `loadPrismGrammars()`
+ * instead. The global is published by a statement earlier in that same
+ * function body, which makes the ordering a runtime fact rather than a promise
+ * the bundler has to keep.
  */
 import Prism from "prismjs";
 
-(globalThis as typeof globalThis & { Prism?: unknown }).Prism ??= Prism;
+/**
+ * The grammars to register, in order — several extend an earlier one, so this
+ * list is loaded sequentially rather than in parallel (`tsx` needs `jsx` and
+ * `typescript`; `cpp` needs `c`). Markup, CSS, C-like and JavaScript are
+ * absent because prismjs' entry point already bundles them.
+ */
+const GRAMMARS: ReadonlyArray<() => Promise<unknown>> = [
+  () => import("prismjs/components/prism-typescript.js"),
+  () => import("prismjs/components/prism-jsx.js"),
+  () => import("prismjs/components/prism-tsx.js"),
+  () => import("prismjs/components/prism-python.js"),
+  () => import("prismjs/components/prism-bash.js"),
+  () => import("prismjs/components/prism-json.js"),
+  () => import("prismjs/components/prism-yaml.js"),
+  () => import("prismjs/components/prism-markdown.js"),
+  () => import("prismjs/components/prism-sql.js"),
+  () => import("prismjs/components/prism-rust.js"),
+  () => import("prismjs/components/prism-go.js"),
+  () => import("prismjs/components/prism-java.js"),
+  () => import("prismjs/components/prism-c.js"),
+  () => import("prismjs/components/prism-cpp.js"),
+];
+
+/** Puts Prism where the grammar scripts look for it. Idempotent. */
+function publishPrismGlobal(): void {
+  (globalThis as typeof globalThis & { Prism?: typeof Prism }).Prism ??= Prism;
+}
+
+publishPrismGlobal();
+
+let loading: Promise<void> | undefined;
+
+/**
+ * Registers the grammars above, once per runtime. Cheap to call repeatedly —
+ * callers are meant to invoke it wherever they are about to highlight, so that
+ * the work does not hinge on a module-level statement surviving tree-shaking.
+ *
+ * Never rejects: a grammar that fails to load just leaves its language out of
+ * `Prism.languages`, which every caller already treats as "render this block
+ * unhighlighted".
+ */
+export function loadPrismGrammars(): Promise<void> {
+  loading ??= (async () => {
+    publishPrismGlobal();
+    for (const load of GRAMMARS) {
+      await load();
+    }
+  })().catch(() => {});
+  return loading;
+}
 
 export default Prism;

package/src/utils/prism.ts

@@ -1,30 +1,17 @@
 /**
- * @fileoverview Configures Prism.js with a fixed set of language grammars and exposes
- * a small `highlightCode` helper used by markdown-to-html.ts for code-block syntax
- * highlighting.
+ * @fileoverview Exposes a small `highlightCode` helper used by
+ * markdown-to-html.ts for code-block syntax highlighting. The Prism instance
+ * and its language grammars are owned by `prism-global.ts`.
  */
-// Must precede every `prismjs/components/*` import: the grammar scripts read
-// `Prism` off the global object, which this module publishes (see its docs).
-import Prism from "./prism-global";
-import "prismjs/components/prism-markup";
-import "prismjs/components/prism-css";
-import "prismjs/components/prism-javascript";
-import "prismjs/components/prism-typescript";
-import "prismjs/components/prism-jsx";
-import "prismjs/components/prism-tsx";
-import "prismjs/components/prism-python";
-import "prismjs/components/prism-bash";
-import "prismjs/components/prism-json";
-import "prismjs/components/prism-yaml";
-import "prismjs/components/prism-markdown";
-import "prismjs/components/prism-sql";
-import "prismjs/components/prism-rust";
-import "prismjs/components/prism-go";
-import "prismjs/components/prism-java";
-import "prismjs/components/prism-c";
-import "prismjs/components/prism-cpp";
+import Prism, { loadPrismGrammars } from "./prism-global";
+
+// Start the grammars loading now, and again from `highlightCode` below — the
+// second call is what guarantees they are requested at all, since a bundler is
+// free to drop this one as a side effect of a module it thinks is pure.
+void loadPrismGrammars();
 
 export function highlightCode(code: string, lang: string): string | null {
+  void loadPrismGrammars();
   const grammar = Prism.languages[lang];
   if (!grammar) return null;
   return Prism.highlight(code, grammar, lang);