feat: context-aware lua_init (web + extension) + extension sync script

- scripts/lua_init.js detects the extension (chrome.runtime.getURL) and
  loads Lua modules from chrome-extension:// URLs; otherwise keeps the web
  app's ../wiktionary_pron/ HTTP path. Removes debug print noise.
- utils/sync_extension.cjs copies languages.js/lexicon.js/utils.js/
  lua_init.js into utils/ext_tmp/scripts (npm run build:ext) so the
  extension can be rebuilt from the app without drift.

The extension itself lives in utils/ext_tmp/ and will move to its own repo.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: hellpanderrr

wiktionary_pron/package.json

@@ -8,7 +8,8 @@
     "test:unit": "mocha scripts/tests/unit/*.test.js --require scripts/tests/setup.cjs --timeout 20000",
     "test:e2e": "playwright test --grep-invert macronizer",
     "test:e2e:macronizer": "playwright test e2e/macronizer.spec.js",
-    "serve": "http-server .. -p 8993 -s"
+    "serve": "http-server .. -p 8993 -s",
+    "build:ext": "node utils/sync_extension.cjs"
   },
   "devDependencies": {
     "@playwright/test": "^1.49.0",

wiktionary_pron/scripts/lua_init.js

@@ -7,70 +7,70 @@ import {
 const factory = await lb.factory;
 const lua = await factory.createEngine();
 
-// Set a JS function to be a global lua function
-
-lua.global.set("fetch", (url) => fetchWithCache(url));
-lua.global.set("fetchMultiple", (url) => fetchWithCacheMultiple(url));
+// Detect extension context: chrome.runtime.getURL exists only in extensions.
+const isExtension = typeof chrome !== "undefined" && chrome.runtime && chrome.runtime.getURL;
+const LUA_BASE = isExtension
+  ? chrome.runtime.getURL("lua_modules/")
+  : "../wiktionary_pron/lua_modules/";
 
+// Mount initial Lua files from the right place
 async function mountFile(file_path, lua_path) {
   const content = await fetch(file_path).then((data) => data.text());
   await factory.mountFile(lua_path, content);
 }
 
+// Set a JS function to be a global lua function.
+// In the web app we use the HTTP-caching fetch; in the extension we use a
+// direct fetch that resolves chrome-extension:// URLs.
+lua.global.set("fetch", isExtension
+  ? (url) => fetch(url)
+  : (url) => fetchWithCache(url),
+);
+lua.global.set("fetchMultiple", isExtension
+  ? (url) => fetch(url)
+  : (url) => fetchWithCacheMultiple(url),
+);
+
 lua.global.set("updateLoadingText", (file_path, extension) =>
   updateLoadingText(file_path, extension),
 );
 
-await mountFile("../wiktionary_pron/lua_modules/memoize.lua", "memoize.lua");
-//await mountFile("lua_modules/memoize.lua", "memoize.lua");
+await mountFile(isExtension
+  ? chrome.runtime.getURL("lua_modules/memoize.lua")
+  : "../wiktionary_pron/lua_modules/memoize.lua",
+  "memoize.lua");
 
+// The require shim Lua code is identical in both contexts; only the URL it
+// passes to JS-side fetch() changes via LUA_BASE.
 await lua.doString(`
           memoize = require('memoize')
           t = {}
           function require(path, extension)
               extension = extension or 'lua'
-              print('     required '..path,'from:', debug.getinfo(2).name)
               table.insert(t, 'lua_modules'..string.char(92)..path)
               if select(2,string.gsub(path, "%.", "")) > 0 then
                    new_path = string.gsub(path,"%.", "/",1)
-                   print('replacing ', path,'->', new_path)
                    path = new_path
               end
-              
-              
               updateLoadingText(path, extension)
-             
-             resp = fetch(string.format('../wiktionary_pron/lua_modules/%s.%s',path,extension)):await()
-             
-            
-              
+              resp = fetch('${LUA_BASE}' .. string.format('%s.%s',path,extension)):await()
               updateLoadingText("", "")
-              
               local text = resp:text():await()
               local module =  load(text)()
-              print('    loaded '..path)
               return module
           end
-
-
-
           require = memoize(require)
           require('debug/track')
           require('ustring/charsets')
           require('ustring/lower')
           require('mw-title')
           mw = require('mw')
         `);
-console.log(lua);
 
 async function loadLanguage(code) {
-  console.log(lua);
-
   await lua.doString(`t = {}
   ${code} = require("${code}-pron_wasm")`);
-  // Get a global lua function as a JS function
   window[code + "_ipa"] = lua.global.get(code);
-  // Set a JS function to be a global lua function
 }
 
 export { loadLanguage, updateLoadingText };

wiktionary_pron/utils/sync_extension.cjs

@@ -0,0 +1,41 @@
+/**
+ * One-way sync: copies shared scripts from the main app into the extension's
+ * scripts/ directory. Run this after any change to the shared files so the
+ * extension doesn't drift.
+ *
+ * Usage:  node utils/sync_extension.cjs
+ * Add to package.json as `npm run build:ext`.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const ROOT = path.resolve(__dirname, "..");
+const EXT = path.join(ROOT, "utils", "ext_tmp");
+
+// Only files that are identical between the main app and the extension.
+// tts_engine.js is extension-specific (not scripts/tts.js) — skip it.
+const FILES = [
+  "scripts/languages.js",
+  "scripts/lexicon.js",
+  "scripts/utils.js",
+  "scripts/lua_init.js",
+  // Classic script — must stay extension-side, but rebuilt alongside the sync
+  "utils/ext_tmp/options_lexicon_shim.js",
+];
+
+let copied = 0;
+for (const rel of FILES) {
+  const src = path.join(ROOT, rel);
+  const dest = path.join(EXT, rel);
+  if (!fs.existsSync(src)) {
+    console.warn(`  SKIP ${rel} — source not found`);
+    continue;
+  }
+  const content = fs.readFileSync(src, "utf8");
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, content, "utf8");
+  console.log(`  ${rel} -> utils/ext_tmp/${rel}`);
+  copied++;
+}
+console.log(`Synced ${copied} file(s).`);