fix: use globalThis instead of window for non-browser compatibility (#150)

## Summary

- Replace `window` with `globalThis` in the ESM loader so `arboriumHost`
works in Node.js, Deno, and workers (not just browsers)
- Add `registerGrammar()` API that lets users pre-load grammar modules,
bypassing CDN/dynamic-import resolution entirely

## `registerGrammar` usage

```ts
// Deno
import * as pythonGrammar from "npm:@arborium/python";
import { readFile } from "node:fs/promises";
const wasm = await readFile("node_modules/@arborium/python/grammar_bg.wasm");
const grammar = await registerGrammar(pythonGrammar, wasm);
const html = await grammar.highlight("print('hello')");
```

## Test plan

- [ ] Verify browser behavior unchanged (`globalThis === window` in
browsers)
- [ ] Verify `registerGrammar` works in Deno with `npm:` specifiers

Fixes #148
Fixes #149

Author: fasterthanlime

crates/arborium-host/src/lib.rs

@@ -9,10 +9,10 @@
 //!
 //! ## JS Interface
 //!
-//! The host expects these functions to be available on `window.arboriumHost`:
+//! The host expects these functions to be available on `globalThis.arboriumHost`:
 //!
 //! ```javascript
-//! window.arboriumHost = {
+//! globalThis.arboriumHost = {
 //!     // Check if a language is available (sync, for fast rejection).
 //!     isLanguageAvailable(language) { ... },
 //!

packages/arborium/src/index.ts

@@ -9,6 +9,7 @@ export {
   getConfig,
   highlight,
   loadGrammar,
+  registerGrammar,
   setConfig,
   getAvailableLanguages,
   isLanguageAvailable,

packages/arborium/src/loader.ts

@@ -273,9 +273,9 @@ async function loadGrammarPluginInner(
 const handleToPlugin = new Map<number, GrammarPlugin>();
 let nextHandle = 1;
 
-/** Setup window.arboriumHost for the Rust host to call into */
+/** Setup globalThis.arboriumHost for the Rust host to call into */
 function setupHostInterface(config: Required<ArboriumConfig>): void {
-  (window as any).arboriumHost = {
+  (globalThis as any).arboriumHost = {
     /** Check if a language is available (sync) */
     isLanguageAvailable(language: string): boolean {
       return knownLanguages.has(language) || grammarCache.has(language);
@@ -427,6 +427,82 @@ export async function loadGrammar(
   };
 }
 
+/**
+ * Register a pre-loaded grammar module, bypassing CDN resolution.
+ *
+ * Use this in Node.js, Deno, or other non-browser environments where
+ * dynamic `import()` of CDN URLs isn't available.
+ *
+ * @example
+ * ```ts
+ * // Deno
+ * import * as pythonGrammar from "npm:@arborium/python";
+ * import { readFile } from "node:fs/promises";
+ * const wasm = await readFile("node_modules/@arborium/python/grammar_bg.wasm");
+ * const grammar = await registerGrammar(pythonGrammar, wasm);
+ * const html = await grammar.highlight("print('hello')");
+ * ```
+ */
+export async function registerGrammar(
+  jsModule: unknown,
+  wasmSource: Response | BufferSource | WebAssembly.Module,
+  configOverrides?: ArboriumConfig,
+): Promise<Grammar> {
+  const config = getConfig(configOverrides);
+  const module = jsModule as WasmBindgenPlugin;
+
+  await module.default({ module_or_path: wasmSource });
+
+  const language = module.language_id();
+  const injectionLanguages = module.injection_languages();
+
+  const plugin: GrammarPlugin = {
+    languageId: language,
+    injectionLanguages,
+    module,
+    parseUtf8: (text: string) => {
+      const session = module.create_session();
+      try {
+        module.set_text(session, text);
+        const result = module.parse(session);
+        return {
+          spans: result.spans || [],
+          injections: result.injections || [],
+        };
+      } catch (e) {
+        config.logger.error(`[arborium] Parse error:`, e);
+        return { spans: [], injections: [] };
+      } finally {
+        module.free_session(session);
+      }
+    },
+    parseUtf16: (text: string) => {
+      const session = module.create_session();
+      try {
+        module.set_text(session, text);
+        const result = module.parse_utf16(session);
+        return {
+          spans: result.spans || [],
+          injections: result.injections || [],
+        };
+      } catch (e) {
+        config.logger.error(`[arborium] Parse error:`, e);
+        return { spans: [], injections: [] };
+      } finally {
+        module.free_session(session);
+      }
+    },
+  };
+
+  grammarCache.set(language, plugin);
+  knownLanguages.add(language);
+  config.logger.debug(`[arborium] Grammar '${language}' registered`);
+
+  // loadGrammar will find it in the cache and wrap it as a public Grammar
+  const grammar = await loadGrammar(language, configOverrides);
+  return grammar!;
+}
+
 /** Get current config, optionally merging with overrides */
 export function getConfig(overrides?: Partial<ArboriumConfig>): Required<ArboriumConfig> {
   if (overrides) {

xtask/src/generate.rs

@@ -2542,10 +2542,10 @@ Uses wasm-bindgen for JavaScript interop.
 
 ## How It Works
 
-The host expects these functions on `window.arboriumHost`:
+The host expects these functions on `globalThis.arboriumHost`:
 
 ```javascript
-window.arboriumHost = {
+globalThis.arboriumHost = {
     // Check if a language is available (sync)
     isLanguageAvailable(language) { ... },