@gjsify/napi 0.22.0

package/README.md

@@ -0,0 +1,203 @@
+# @gjsify/napi
+
+**Node-API (N-API) host for GJS** — implements the Node-API C ABI over GJS's
+SpiderMonkey (mozjs-140) so GJS can load unmodified compiled `.node` addons.
+
+It is the forward mirror of [`@gjsify/node-gi`](../../node-gi/node-gi) ("GI in
+Node"): where node-gi runs GObject-Introspection code IN Node via Node's N-API,
+this runs Node's **N-API `.node` addons IN GJS** ("N-API in GJS"). A consumer
+addon built with stock `node-gyp` — including its bundled native code — loads and
+runs inside GJS byte-identically to Node (see the gjsify `AGENTS.md`
+`### N-API host in GJS`).
+
+> **Status: experimental (Tier 3 — [ADR 0011](../../../docs/adr/0011-napi-host-in-gjs.md)).**
+> No stability promise; new axes start here. **Phase 0 is complete:** the full
+> `js_native_api.h` surface + the module loader/version/fatal bits are
+> implemented; the async / threadsafe-function / event-loop group of
+> `node_api.h` is intentionally loud-stubbed and deferred. First consumer:
+> **better-sqlite3 v13.0.1 (incl. its bundled SQLite) runs unmodified, byte-identical
+> to Node**, valgrind-clean. Conformance oracle (node's own `js-native-api`
+> addons, golden-diff vs Node): **13 pass / 8 Phase-0-deferred ledgered / 0 fail**.
+
+## How it works
+
+Packaged like the `@gjsify/*-native` bridges (`@gjsify/tls-native`): meson builds
+a thin Vala GI surface (`GjsifyNapi.init()`) plus the C++ napi-over-mozjs-140
+implementation into ONE `.so` + `.gir` + `.typelib`, loaded from GJS via
+`imports.gi`. `init()` reaches the running `JSContext`
+(`gjs_context_get_current` / `gjs_context_get_native_context`) and installs one
+JSNative, `loadAddon(path)`; thereafter the addon's `exports` is a normal JS
+return value and load failures are normal JS exceptions. `napi_value` is a
+GC-traced `JS::Heap<JS::Value>` arena slot (SpiderMonkey's moving GC forbids the
+raw-boxed-value trick and `JS::Rooted` scopes). The shim `dlopen`s the addon
+`RTLD_LOCAL` and self-promotes its own `napi_*` / `node_api_*` into global scope,
+so an addon's undefined napi symbols bind to ours — exactly as Node/Bun export
+the ABI from the main binary, which is why **consumers need no special build**.
+
+## Install
+
+```bash
+gjsify install @gjsify/napi
+```
+
+Published on the `@gjsify/*` release train. The tarball ships the shim
+**prebuilt** for the platforms in [Platforms](#platforms) below —
+`prebuilds/linux-x86_64/` and `prebuilds/darwin-arm64/`, each a `.so`/`.dylib`
+plus its `.gir` and `.typelib`, rebuilt from the released source by the
+`napi-prebuild-*` jobs in `.github/workflows/release.yml` — so an install brings
+the shim itself, not just a build recipe. Installing through the `gjsify` CLI
+puts the prebuild dir on `GI_TYPELIB_PATH`/`LD_LIBRARY_PATH` for you.
+
+The tarball ALSO ships the build inputs (`meson.build`, `src/vala`, `src/cc`,
+`src/napi-headers`), so on a platform with no prebuild — or against a GJS built
+on a different SpiderMonkey major (see [the mozjs-140 pin](#the-mozjs-140-pin))
+— you can rebuild in place: `cd node_modules/@gjsify/napi && meson setup build .
+&& meson compile -C build`, then point `GI_TYPELIB_PATH` (plus
+`LD_LIBRARY_PATH`, or `DYLD_LIBRARY_PATH` on macOS) at `build/`. See
+[Requirements](#requirements) for the toolchain that needs.
+
+## Usage — transparent (primary)
+
+After `gjsify install @gjsify/napi`, a normal native-addon import **just works**
+in a `gjsify build --app gjs` build — no wrapper, no manual `loadAddon`:
+
+```ts
+import Database from 'better-sqlite3'; // require('bufferutil') / etc.
+
+const db = new Database(':memory:');
+db.exec('CREATE TABLE t (n INT)');
+```
+
+The `napiNodeAddonPlugin` in `@gjsify/rolldown-plugin-gjsify` (the forward mirror
+of the `gjsGiNodePlugin` `gi://`→`requireGi` rewrite) intercepts the addon's own
+acquisition helper — `bindings`, `node-gyp-build`, a direct `.node` import, a
+napi-rs `@scope/pkg-<triple>` platform sibling, or a napi-rs **generated loader
+entry** (`@node-rs/*`) — and rewrites it to `loadAddon('<abs .node>')`. For the
+node-gyp-build/bindings case it locates the compiled `.node` using
+node-gyp-build's own probe order (`build/Release` → `build/Debug` →
+`prebuilds/<platform>-<arch>`), so the GJS build routes the SAME binary Node
+loads; for a napi-rs package it detects the generated loader (package.json
+`napi`/optionalDependencies signal + native-`main` match) and replaces the whole
+module with `module.exports = loadAddon(<current-platform sibling .node>)`, so the
+generated `createRequire` loader body never reaches the bundle. Always-on for
+`--app gjs`, inert when no native addon is in the graph.
+
+**Escape hatch — explicit `loadAddon`.** When you want to load a `.node` by an
+arbitrary runtime path (not a static import), call it directly:
+
+```ts
+import { loadAddon, hasNapi } from '@gjsify/napi';
+
+if (hasNapi()) {
+    const addon = loadAddon('/abs/path/to/build/Release/addon.node');
+}
+```
+
+All four addon conventions — node-gyp-build, bindings, a direct `.node`, and
+napi-rs generated loaders (`@node-rs/*`) — are transparent; the explicit
+`loadAddon` escape hatch remains for loading a `.node` by an arbitrary runtime
+path.
+
+## Requirements
+
+- A C++ toolchain (`g++`/`clang`), `meson`, `vala`, `g-ir-compiler`
+- Development headers for `glib-2.0`, `gobject-2.0`, `gio-2.0`, **`gjs-1.0`** and
+  **`mozjs-140`**
+  - Fedora: `gjs-devel mozjs140-devel glib2-devel gobject-introspection-devel
+    vala meson gcc-c++`
+  - macOS (Homebrew): `brew install gjs gobject-introspection vala meson ninja
+    pkgconf` — `gjs` pulls `spidermonkey` (mozjs-140) transitively, the SAME
+    pairing Fedora pins (gjs 1.88.x ↔ mozjs-140)
+- Node.js + `node-gyp` to build the test/consumer addons (`.node` files)
+
+## Platforms
+
+Ships as a prebuilt `.dylib`/`.so` + `.gir` + `.typelib` per platform. Both
+supported triples are rebuilt on their own native runner for every release
+(`napi-prebuild-linux` / `napi-prebuild-darwin-arm64` in `release.yml`) and
+staged into the one published tarball, so a single `@gjsify/napi` version serves
+both:
+
+| Platform | Prebuild dir | Status |
+| --- | --- | --- |
+| Linux x86_64 | `prebuilds/linux-x86_64/` | Supported (full gate + conformance + consumer CI) |
+| macOS arm64 | `prebuilds/darwin-arm64/` | Supported (build + load + P0.x value-model + **P1 tsfn** gates); the earlier tsfn exit-segfault (a UAF — the tsfn was freed while foreign claimants still held claims) is **fixed** (join-before-free, both abort + teardown paths); conformance/consumer/valgrind widening deferred |
+| Windows x64 | — | **Attempted, blocked at gjs-on-Windows** (shim-side portability done; see below) |
+
+**Windows is attempted, blocked at gjs-on-Windows.** The shim-side portability
+is complete and Linux-verified: `meson.build` has a `windows` branch (a `.def`
+EXPORTS file — MSVC `link.exe` takes no globs — plus the `gjsifynapi.dll` leaf
+and MSVC-syntax cpp_args), and `src/cc/module.cc`'s POSIX `dlfcn` loader is
+`#ifdef _WIN32`-ported to `LoadLibraryEx`/`GetProcAddress`/`GetModuleHandleEx`.
+A manual-dispatch (`workflow_dispatch`) `windows` job in `napi.yml` drives the
+from-source attempt. **Re-checking the blocker harder overturned one half:** a
+prebuilt MSVC-ABI **mozjs-140 now exists** — `servo/mozjs` ships
+`libmozjs-x86_64-pc-windows-msvc` at `mozjs-sys-v140.13.0-0` (SpiderMonkey ESR
+140.13). **The remaining wall is `libgjs` itself:** no prebuilt libgjs exists for
+Windows (gvsbuild has no gjs/spidermonkey module, GNOME/gjs CI is Linux-only),
+and the servo prebuilt is a patched Rust static-lib layout, not the pkg-config
+`mozjs-140` gjs's meson wants — so gjs must still be source-built with clang-cl.
+A **second wall** waits behind it: an unmodified node-gyp `.node` on Windows
+binds `napi_*` via a delay-load hook against the host `.exe`, which `gjs.exe`
+does not export (there is no POSIX global-namespace self-promotion analog). See
+`STATUS.md` → *N-API host in GJS* → cross-platform prebuilds. This is the key
+difference from [`@gjsify/node-gi`](../../node-gi/node-gi), which links the
+portable girepository stack and so runs on all three OSes.
+
+## Build
+
+```bash
+meson setup build .              # or: gjsify run init:meson
+meson compile -C build           # builds libgjsifynapi.so + GjsifyNapi-1.0.{gir,typelib}
+
+# stage the prebuild the loader/gates resolve from:
+gjsify run build:prebuilds       # meson build + copy into prebuilds/linux-x86_64/
+```
+
+## Test
+
+The gates, conformance oracle and consumer proof all load the addon through the
+staged shim, with `GI_TYPELIB_PATH`/`LD_LIBRARY_PATH` pointed at `build/`. Build
+the addons first, then run the legs:
+
+```bash
+gjsify run build:test-addons     # node-gyp rebuild of test/*-addon/*.node
+
+gjsify run test:gate             # smoke: load a minimal addon under gjs
+gjsify run test:gate:p01         # env + value model + scopes
+gjsify run test:gate:p02         # js_native_api core
+gjsify run test:gate:p03         # wrap + lifetime
+gjsify run test:mem              # valgrind leak/UAF leg for the gates
+
+gjsify run test:conformance      # golden-diff vs Node over node's js-native-api addons
+gjsify run test:consumer         # better-sqlite3 v13.0.1 runs on GJS, byte-vs-Node
+
+gjsify run test:addons:setup     # vendor + source-build the real-addon matrix
+gjsify run test:addons           # pinned baseline: loadAddon({addonPath}), byte-vs-Node
+gjsify run test:addons:transparent  # transparent: napiNodeAddonPlugin auto-resolves, byte-vs-Node
+```
+
+`test:addons:transparent` is the end-to-end proof of the transparent path: it
+builds each real addon `--app gjs` through `napiNodeAddonPlugin`'s
+auto-resolution (no hand-pinned addonPath) and requires byte-identical output vs
+Node. All four pass byte-identical: bufferutil + utf-8-validate (node-gyp-build),
+sqlite3 (bindings), and `@node-rs/argon2` (napi-rs generated-loader
+entry-replacement).
+
+`gjsify run test:conformance:update` regenerates the golden files;
+`conformance/ledger.json` records each Phase-0-deferred program with a precise
+reason (an unlisted failure fails the harness; a listed program that starts
+passing also fails — stale entry). `test:conformance:mem` / `test:consumer:mem`
+are the valgrind variants.
+
+## The mozjs-140 pin
+
+The pin is intrinsic and by design: the **shim** links GJS's SpiderMonkey (built
+`-fno-rtti -fno-exceptions`, matching GJS) and must be rebuilt when GJS bumps its
+mozjs major — mozjs has no stable C++ ABI. The **addon** is untouched by mozjs
+churn: it speaks only the stable napi C ABI. That asymmetry is the whole point.
+
+## License
+
+MIT. See [ADR 0011](../../../docs/adr/0011-napi-host-in-gjs.md) for the full
+rationale, alternatives, and consequences.

package/lib/esm/_virtual/_rolldown/runtime.js

@@ -0,0 +1 @@
+var e=Object.defineProperty,__name=(t,n)=>e(t,`name`,{value:n,configurable:!0});export{__name};

package/lib/esm/index.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";let e=null;const t=globalThis.imports?.gi;if(t)try{e=t.GjsifyNapi}catch{}const n=e;function hasNapi(){return e!==null}let r=null;function ensureInstalled(){if(r)return r;if(!e)throw Error(`@gjsify/napi: native typelib not loaded. Check hasNapi() first.`);if(!e.init())throw Error(`@gjsify/napi: GjsifyNapi.init() failed — no running GJS JSContext.`);let t=globalThis,n=t.__gjsifyNapiLoadAddon;if(typeof n!=`function`)throw Error(`@gjsify/napi: bootstrap native __gjsifyNapiLoadAddon was not installed.`);return delete t.__gjsifyNapiLoadAddon,r=n,n}function loadAddon(e){return ensureInstalled()(e)}export{hasNapi,loadAddon,n as nativeNapi};

package/lib/types/index.d.ts

@@ -0,0 +1,25 @@
+/** Introspected shape of the `GjsifyNapi` GI namespace (GjsifyNapi-1.0.gir). */
+export interface GjsifyNapiModule {
+    /**
+     * Install the N-API host into the running GJS context. Idempotent.
+     * Returns `false` when there is no current GjsContext/JSContext.
+     */
+    init(): boolean;
+    /** Probe that the native typelib is loaded. */
+    is_available(): boolean;
+}
+/** The native GjsifyNapi module, or `null` if not installed. */
+export declare const nativeNapi: GjsifyNapiModule | null;
+/** Returns `true` when the GjsifyNapi native shim is available. */
+export declare function hasNapi(): boolean;
+/**
+ * Load a compiled Node-API addon (`.node`) into the running GJS context.
+ *
+ * The addon must be a pure Node-API module (e.g. a stock node-gyp build);
+ * legacy NAN/V8 addons are rejected with a clear error. A second load of the
+ * same (real)path returns the cached `exports` object.
+ *
+ * @param path  Filesystem path to the `.node` shared object.
+ * @returns     The addon's `exports` object.
+ */
+export declare function loadAddon(path: string): Record<string, unknown>;

package/meson.build

@@ -0,0 +1,126 @@
+# SPDX-License-Identifier: MIT
+# @gjsify/napi — N-API host shim over GJS's SpiderMonkey (mozjs-140).
+# Mirrors the @gjsify/tls-native meson pipeline: Vala (GI surface) + native
+# code compiled into ONE shared library + GIR + typelib. The native part here
+# is C++ (JSAPI is C++); the shim is intrinsically pinned to GJS's mozjs
+# major and must be rebuilt when GJS bumps (ADR 0011).
+project('GjsifyNapi', ['c', 'cpp', 'vala'],
+    version: '1.0',
+    # Match GJS's own build (refs/gjs/meson.build): C++17, no RTTI, no
+    # exceptions — mozjs-140 has no stable C++ ABI and is built the same way.
+    default_options: ['cpp_std=c++17'])
+
+dependencies = [
+    dependency('glib-2.0'),
+    dependency('gobject-2.0'),
+    dependency('gio-2.0'),
+    dependency('gjs-1.0'),      # gjs_context_get_current / get_native_context
+    dependency('mozjs-140'),    # JSAPI
+]
+
+cc = meson.get_compiler('c')
+dl_dep = cc.find_library('dl', required: false)  # dlopen/dlsym/dladdr
+if dl_dep.found()
+    dependencies += dl_dep
+endif
+
+vala_sources = files(
+    'src/vala/napi.vala',
+)
+
+# node-gi TU-split idiom: one common.h owning cross-TU decls, functional
+# .cc slices. The vendored Node-API headers live in src/napi-headers/.
+cc_sources = files(
+    'src/cc/arraybuffer.cc',
+    'src/cc/async_work.cc',
+    'src/cc/env.cc',
+    'src/cc/error.cc',
+    'src/cc/function.cc',
+    'src/cc/module.cc',
+    'src/cc/object.cc',
+    'src/cc/ref.cc',
+    'src/cc/stubs.cc',
+    'src/cc/tsfn.cc',
+    'src/cc/value.cc',
+    'src/cc/wrap.cc',
+)
+
+# §3b export hygiene: only napi_*/node_api_* (the ABI) + gjsify_napi_* (the
+# GI/Vala surface) are visible; everything else is local. The mechanism is
+# linker-specific, so branch on the host toolchain:
+#   - GNU ld / lld (Linux): --version-script (glob patterns, ABI-only export)
+#   - ld64 (macOS):         -exported_symbols_list (leading-underscore globs)
+#   - MSVC link.exe / lld-link (Windows): a .def EXPORTS file (no glob support).
+# On Windows the napi_*/node_api_* ABI is already exported via the vendored
+# headers' __declspec(dllexport) (js_native_api.h NAPI_EXTERN on _WIN32), and
+# MSVC hides every non-dllexport symbol by DEFAULT — so the .def only has to add
+# the Vala GI surface (gjsify_napi_init/is_available/install) that g_module
+# resolves from the typelib. That closes the same hygiene contract the
+# version-script/exported-symbols-list enforce elsewhere. The Windows build
+# still requires a from-source gjs + mozjs-140 toolchain (clang-cl/MSVC; see
+# STATUS.md "N-API host in GJS" cross-platform prebuilds + the `windows` job in
+# napi.yml) — mozjs-140 is now obtainable (servo/mozjs prebuilt
+# libmozjs-x86_64-pc-windows-msvc), the open wall is gjs-on-Windows itself.
+host_system = host_machine.system()
+if host_system == 'darwin'
+    export_symbols = meson.current_source_dir() / 'src/cc/napi.exported-symbols.txt'
+    export_link_args = ['-Wl,-exported_symbols_list,' + export_symbols]
+    export_link_depends = files('src/cc/napi.exported-symbols.txt')
+    # meson names the shared library libgjsifynapi.dylib on macOS; the typelib
+    # must record that exact leaf so gjs' g_module_open resolves it at load.
+    shared_lib_name = 'libgjsifynapi.dylib'
+elif host_system == 'windows'
+    # MSVC/clang-cl consume /DEF:<file>; the DLL has no `lib` prefix, so the
+    # typelib must record `gjsifynapi.dll` as the leaf g_module_open resolves.
+    def_file = meson.current_source_dir() / 'src/cc/napi.def'
+    export_link_args = ['/DEF:' + def_file]
+    export_link_depends = files('src/cc/napi.def')
+    shared_lib_name = 'gjsifynapi.dll'
+else
+    version_script = meson.current_source_dir() / 'src/cc/napi.export.map'
+    export_link_args = ['-Wl,--version-script,' + version_script]
+    export_link_depends = files('src/cc/napi.export.map')
+    shared_lib_name = 'libgjsifynapi.so'
+endif
+
+# GJS/mozjs-140 are built C++17, no RTTI, no exceptions (mozjs has no stable
+# C++ ABI and is built the same way — ADR 0011). Spell that per argument syntax
+# so the shim matches on every toolchain: GNU/Clang take -fno-*, MSVC/clang-cl
+# take /GR- (no RTTI) and default to no C++ exceptions (no /EHsc).
+cpp = meson.get_compiler('cpp')
+if cpp.get_argument_syntax() == 'msvc'
+    shim_cpp_args = ['/GR-']
+else
+    shim_cpp_args = ['-fno-rtti', '-fno-exceptions']
+endif
+
+libGjsifyNapi = library('gjsifynapi', vala_sources + cc_sources,
+    dependencies: dependencies,
+    include_directories: include_directories('src/napi-headers'),
+    cpp_args: shim_cpp_args,
+    # Stub vapis for the C++-only deps (mozjs-140, gjs-1.0): meson forwards
+    # every dependency() to valac as --pkg; Vala itself never uses them.
+    vala_args: [
+        '--vapidir=' + meson.current_source_dir() / 'src/vala',
+    ],
+    link_args: export_link_args,
+    link_depends: export_link_depends,
+    vala_gir: meson.project_name() + '-1.0.gir',
+    install: true,
+    install_dir: [true, true, true, true],
+)
+
+g_ir_compiler = find_program('g-ir-compiler')
+
+custom_target(meson.project_name() + '-1.0.typelib',
+    command: [
+        g_ir_compiler,
+        '--shared-library', shared_lib_name,
+        '--output', '@OUTPUT@',
+        meson.current_build_dir() / meson.project_name() + '-1.0.gir',
+    ],
+    output: meson.project_name() + '-1.0.typelib',
+    depends: libGjsifyNapi,
+    install: true,
+    install_dir: get_option('libdir') / 'girepository-1.0',
+)

package/package.json

@@ -0,0 +1,100 @@
+{
+    "name": "@gjsify/napi",
+    "version": "0.22.0",
+    "description": "Node-API (N-API) host for GJS — implements the napi C ABI over SpiderMonkey (mozjs-140) so GJS can load unmodified compiled .node addons. The forward mirror of @gjsify/node-gi (GI in Node); this is N-API in GJS. Vala/C++ shim as .so+.gir+.typelib prebuild, loaded via imports.gi.",
+    "type": "module",
+    "main": "lib/esm/index.js",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "default": "./lib/esm/index.js"
+        }
+    },
+    "files": [
+        "lib",
+        "prebuilds",
+        "meson.build",
+        "src/vala",
+        "src/cc",
+        "src/napi-headers"
+    ],
+    "gjsify": {
+        "platforms": [
+            "linux-x86_64",
+            "darwin-arm64"
+        ],
+        "prebuilds": "prebuilds",
+        "runtimes": {
+            "gjs": "polyfill",
+            "node": "none",
+            "browser": "none",
+            "nativescript": "none"
+        },
+        "tier": 3
+    },
+    "keywords": [
+        "gjs",
+        "napi",
+        "node-api",
+        "n-api",
+        "native-addon",
+        "node",
+        "spidermonkey",
+        "mozjs",
+        "vala",
+        "native"
+    ],
+    "scripts": {
+        "clear": "rm -rf lib build tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs || exit 0",
+        "check": "gjsify tsc --noEmit",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/ts/**/*.{ts,js}'",
+        "build:types": "gjsify tsc",
+        "init:meson": "meson setup build .",
+        "init:meson:wipe": "gjsify run init:meson --wipe",
+        "build:meson": "gjsify run init:meson && meson compile -C build",
+        "build:prebuilds": "gjsify run build:meson && mkdir -p prebuilds/linux-x86_64 && cp build/libgjsifynapi.so build/GjsifyNapi-1.0.gir build/GjsifyNapi-1.0.typelib prebuilds/linux-x86_64/",
+        "build:test-addons": "for d in test/*-addon; do (cd \"$d\" && npm exec -- node-gyp rebuild) || exit 1; done",
+        "build:stubs": "python3 scripts/gen-stubs.py",
+        "test:gate": "GI_TYPELIB_PATH=build LD_LIBRARY_PATH=build gjs test/load-gate.js test/hello-addon/build/Release/hello.node",
+        "test:gate:p01": "GI_TYPELIB_PATH=build LD_LIBRARY_PATH=build gjs test/p01-gate.js",
+        "test:gate:p02": "GI_TYPELIB_PATH=build LD_LIBRARY_PATH=build gjs test/p02-gate.js",
+        "test:gate:p03": "sh test/run-p03-gate.sh",
+        "test:gate:p1": "GI_TYPELIB_PATH=build LD_LIBRARY_PATH=build gjs test/p1-tsfn-gate.js",
+        "test:nodegi": "node test/nodegi-gate.mjs",
+        "test:nodegi:mem": "node test/nodegi-gate.mjs --valgrind",
+        "test:mem": "sh test/p03-mem.sh",
+        "test:consumer": "node test/consumer-gate.mjs",
+        "test:consumer:mem": "sh test/consumer-mem.sh",
+        "test:addons:setup": "sh test/addons/setup.sh",
+        "test:addons": "sh test/run-addon-matrix.sh",
+        "test:addons:transparent": "sh test/run-transparent-matrix.sh",
+        "test:conformance": "node scripts/conformance.mjs",
+        "test:conformance:update": "node scripts/conformance.mjs --update-golden",
+        "test:conformance:mem": "sh scripts/conformance-mem.sh"
+    },
+    "dependencies": {
+        "@girs/glib-2.0": "^4.1.0",
+        "@girs/gobject-2.0": "^4.1.0"
+    },
+    "devDependencies": {
+        "@girs/gjs": "^4.1.0",
+        "@gjsify/cli": "^0.22.0",
+        "@gjsify/unit": "^0.22.0",
+        "@ts-for-gir/cli": "^4.1.0",
+        "@types/node": "^25.9.2",
+        "typescript": "^6.0.3"
+    },
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gjsify/gjsify.git",
+        "directory": "packages/napi/napi"
+    },
+    "bugs": {
+        "url": "https://github.com/gjsify/gjsify/issues"
+    },
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/napi/napi#readme"
+}

package/prebuilds/linux-x86_64/GjsifyNapi-1.0.gir

@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<!-- GjsifyNapi-1.0.gir generated by valac 0.56.19, do not modify. -->
+<repository version="1.2" xmlns="http://www.gtk.org/introspection/core/1.0" xmlns:c="http://www.gtk.org/introspection/c/1.0" xmlns:doc="http://www.gtk.org/introspection/doc/1.0" xmlns:glib="http://www.gtk.org/introspection/glib/1.0">
+<package name="gjsifynapi"/>
+<c:include name="gjsifynapi.h"/>
+<doc:format name="unknown"/>
+<namespace name="GjsifyNapi" version="1.0" shared-library="libgjsifynapi.so" c:prefix="GjsifyNapi" c:identifier-prefixes="GjsifyNapi" c:symbol-prefixes="gjsify_napi">
+	<function name="init" c:identifier="gjsify_napi_init">
+		<return-value transfer-ownership="full">
+			<type name="gboolean" c:type="gboolean"/>
+		</return-value>
+	</function>
+	<function name="is_available" c:identifier="gjsify_napi_is_available">
+		<return-value transfer-ownership="full">
+			<type name="gboolean" c:type="gboolean"/>
+		</return-value>
+	</function>
+</namespace>
+</repository>