@frdt/frdt 0.2.0

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@frdt/frdt",
+  "version": "0.2.0",
+  "description": "Read and edit Resonite .brson (FrDT) files without expanding them into JSON",
+  "license": "MIT",
+  "keywords": [
+    "resonite",
+    "brson",
+    "bson",
+    "frdt",
+    "napi-rs"
+  ],
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "frdt.wasi.cjs",
+    "frdt.wasm32-wasi.wasm",
+    "wasi-worker.mjs",
+    "README.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md"
+  ],
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=23.5.0"
+  },
+  "dependencies": {
+    "@emnapi/core": "2.0.0-alpha.5",
+    "@emnapi/runtime": "2.0.0-alpha.5",
+    "@napi-rs/wasm-runtime": "^1.2.4"
+  },
+  "optionalDependencies": {
+    "@frdt/binding-win32-x64-msvc": "0.2.0",
+    "@frdt/binding-linux-x64-gnu": "0.2.0",
+    "@frdt/binding-linux-x64-musl": "0.2.0",
+    "@frdt/binding-darwin-arm64": "0.2.0"
+  }
+}

package/wasi-worker.mjs

@@ -0,0 +1,186 @@
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import { parse } from 'node:path'
+import { WASI } from 'node:wasi'
+import { parentPort, threadId, Worker, workerData } from 'node:worker_threads'
+
+const require = createRequire(import.meta.url)
+
+// The thread spawn that created this worker has already returned, so the loader
+// thread may be waiting on this thread. A failure before the crash hook below is
+// in place (a missing '@napi-rs/wasm-runtime', say) has to raise the crash flags
+// too, then fail the worker as before.
+let handler
+try {
+  const {
+    instantiateNapiModuleSync,
+    MessageHandler,
+    getDefaultContext,
+    emnapiAsyncWorkPlugin,
+    emnapiTSFNPlugin,
+  } = require('@napi-rs/wasm-runtime')
+
+  if (parentPort) {
+    parentPort.on('message', (data) => {
+      globalThis.onmessage({ data })
+    })
+  }
+
+  Object.assign(globalThis, {
+    self: globalThis,
+    require,
+    Worker,
+    importScripts: function (f) {
+      // oxlint-disable-next-line no-eval -- WASI importScripts polyfill
+      ;(0, eval)(fs.readFileSync(f, 'utf8') + '//# sourceURL=' + f)
+    },
+    postMessage: function (msg) {
+      if (parentPort) {
+        parentPort.postMessage(msg)
+      }
+    },
+  })
+
+  const emnapiContext = getDefaultContext()
+
+  const __cwd = process.cwd()
+  const __rootDir =
+    (workerData && typeof workerData.rootDir === 'string' && workerData.rootDir) ||
+    parse(__cwd).root
+  const __hostRoot =
+    (workerData && typeof workerData.hostRoot === 'string' && workerData.hostRoot) ||
+    (process.platform === 'android' ? __cwd : __rootDir)
+
+  handler = new MessageHandler({
+    onLoad({ wasmModule, wasmMemory }) {
+      const wasi = new WASI({
+        version: 'preview1',
+        env: process.env,
+        preopens: {
+          [__rootDir]: __hostRoot,
+          [__hostRoot]: __hostRoot,
+        },
+      })
+
+      return instantiateNapiModuleSync(wasmModule, {
+        childThread: true,
+        wasi,
+        context: emnapiContext,
+        // The wasm links a "basic" emnapi archive (no C async-work /
+        // threadsafe-function implementations), so every thread that
+        // instantiates it must provide the JavaScript implementations
+        // through the emnapi plugins.
+        plugins: [emnapiAsyncWorkPlugin, emnapiTSFNPlugin],
+        overwriteImports(importObject) {
+          importObject.env = {
+            ...importObject.env,
+            ...importObject.napi,
+            ...importObject.emnapi,
+            memory: wasmMemory,
+          }
+        },
+      })
+    },
+  })
+} catch (error) {
+  if (workerData && workerData.crashFlag instanceof Int32Array) {
+    __raiseWasiThreadCrashFlags(error)
+  }
+  throw error
+}
+
+// Tell the loader thread synchronously that this wasm thread died, so its 'exit'
+// teardown does not re-enter wasm and wait on this thread forever. emnapi calls
+// beforeReportError (which runs emnapi_thread_crashed, so the main thread may
+// throw 'unwind' and start exiting) before the 'error' event is even posted.
+// A loader that predates the flag passes none.
+if (workerData && workerData.crashFlag instanceof Int32Array) {
+  const __beforeReportError = handler.beforeReportError
+  handler.beforeReportError = function (...args) {
+    if (!__raiseWasiThreadCrashFlags(args[0])) {
+      // No view (the thread was spawned before the loader read the address,
+      // say): the export stores into the same word, but only a worker that
+      // loaded has an instance to call it on.
+      try {
+        const __napiThreadCrashed = this.instance?.exports?.napi_wasm_thread_crashed
+        if (typeof __napiThreadCrashed === 'function') {
+          __napiThreadCrashed()
+        }
+      } catch {}
+    }
+    return __beforeReportError.apply(this, args)
+  }
+}
+
+// The error goes into the shared crash report first. The 'error' event that
+// would carry it is dropped when the loader terminates this worker before the
+// event is sent, so the report is the only copy the loader can count on.
+// Layout: three Int32 words — state (0 empty, 1 writing, 2 written), byte
+// length, threadId — then the UTF-8 JSON of { name, message, stack }. Only the
+// first worker to crash writes it, and it is complete before the flag is raised.
+//
+// Then the loader's flag, then the addon's. The loader thread may already be
+// inside wasm, in a cleanup call that waits on this thread; the addon's flag is
+// what those waits check between short slices. It is a word in the shared wasm
+// memory (the loader passes a view of it, see napi_wasm_thread_crash_flag_address),
+// so no instance is needed: a worker that failed while loading raises it too.
+// Once it is up the waits trap, and the loader, whose flag is already up, turns
+// the throw into its crash rejection. Returns whether the addon's flag was raised.
+function __raiseWasiThreadCrashFlags(error) {
+  try {
+    __writeCrashReport(workerData.crashReport, error)
+  } catch {}
+  try {
+    Atomics.store(workerData.crashFlag, 0, 1)
+  } catch {}
+  const addonCrashFlag = workerData.addonCrashFlag
+  if (!(addonCrashFlag instanceof Int32Array)) {
+    return false
+  }
+  try {
+    Atomics.store(addonCrashFlag, 0, 1)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function __writeCrashReport(report, error) {
+  if (!(report instanceof SharedArrayBuffer) || report.byteLength <= 12) {
+    return
+  }
+  const header = new Int32Array(report, 0, 3)
+  if (Atomics.compareExchange(header, 0, 0, 1) !== 0) {
+    return
+  }
+  let length = 0
+  try {
+    const body = new Uint8Array(report, 12)
+    const isObject =
+      error !== null && (typeof error === 'object' || typeof error === 'function')
+    const name = isObject && typeof error.name === 'string' ? error.name : 'Error'
+    const message = isObject && typeof error.message === 'string'
+      ? error.message
+      : String(error)
+    const stack = isObject && typeof error.stack === 'string' ? error.stack : undefined
+    const encoder = new TextEncoder()
+    let bytes = encoder.encode(JSON.stringify({ name, message, stack }))
+    if (bytes.length > body.length) {
+      bytes = encoder.encode(
+        JSON.stringify({ name, message: message.slice(0, body.length >> 3) }),
+      )
+    }
+    if (bytes.length <= body.length) {
+      body.set(bytes)
+      length = bytes.length
+    }
+    Atomics.store(header, 2, threadId)
+  } finally {
+    Atomics.store(header, 1, length)
+    Atomics.store(header, 0, 2)
+  }
+}
+
+globalThis.onmessage = function (e) {
+  handler.handle(e)
+}