zignapi 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # zignapi
 
-The CLI for [zigbind](https://github.com/zigbind/zigbind): scaffold and build
+The CLI for [zignapi](https://github.com/zignapi/zignapi): scaffold and build
 native Node.js addons written in Zig. Written in TypeScript, compiled to ESM with
 **zero runtime dependencies**, no `node-gyp`. Requires **Zig 0.16.0** on `PATH`
 and **Node >= 18**.
@@ -17,7 +17,7 @@ zignapi build [--release]   # run `zig build` in the cwd, emit ./<name>.node
 ```
 
 - `new` copies the template tree (substituting the project name) and pins the
-  `zigbind` Zig dependency with `zig fetch --save`.
+  `zignapi` Zig dependency with `zig fetch --save`.
 - `build` runs `zig build` (adding `-Doptimize=ReleaseFast` with `--release`),
   then copies the produced shared library to `./<name>.node`. If `build.zig.zon`
   is missing a fingerprint, it fills in the value Zig suggests and retries.

package/dist/build.js

@@ -1,8 +1,9 @@
 import { parseArgs } from "node:util";
-import { existsSync, copyFileSync, readdirSync } from "node:fs";
+import { existsSync, copyFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join, basename, extname } from "node:path";
+import { createRequire } from "node:module";
 import process from "node:process";
-import { runZig } from "./zig.js";
+import { runZig, errMessage } from "./zig.js";
 const BUILD_HELP = `zignapi build — build the addon in the current directory
 
 Usage:
@@ -12,8 +13,9 @@ Options:
   --release   Optimize the build (-Doptimize=ReleaseFast)
   -h, --help  Show this help
 
-Runs "zig build" in the current directory, then copies the resulting shared
-library to ./<name>.node (renaming a plain .dylib/.so/.dll if needed).
+Runs "zig build" in the current directory, copies the resulting shared library
+to ./<name>.node (renaming a plain .dylib/.so/.dll if needed), then generates
+index.js and index.d.ts from the addon's embedded type declarations.
 `;
 export async function runBuild(argv) {
     const { values } = parseArgs({
@@ -36,13 +38,42 @@ export async function runBuild(argv) {
         zigArgs.push("-Doptimize=ReleaseFast");
     runZig(cwd, zigArgs, { repairZon: join(cwd, "build.zig.zon") });
     // Locate the freshly built addon and copy it to ./<name>.node.
-    const addon = findAddon(join(cwd, "zig-out"));
-    if (!addon) {
+    const addonPath = findAddon(join(cwd, "zig-out"));
+    if (!addonPath) {
         throw new Error("build succeeded but no addon (.node or shared library) was found under zig-out");
     }
-    const dest = join(cwd, addonName(addon));
-    copyFileSync(addon, dest);
-    process.stdout.write(`✔ built ${basename(dest)}\n`);
+    const nodeFile = addonName(addonPath);
+    copyFileSync(addonPath, join(cwd, nodeFile));
+    process.stdout.write(`✔ built ${nodeFile}\n`);
+    generateBindings(cwd, nodeFile);
+}
+/**
+ * Emit `index.js` (a loader that re-exports the addon) and `index.d.ts` (the
+ * TypeScript declarations) from the type info the addon embeds as
+ * `__zignapi_dts__`. Non-fatal: a build that can't be introspected still counts
+ * as a successful build.
+ */
+function generateBindings(cwd, nodeFile) {
+    const require = createRequire(import.meta.url);
+    let addon;
+    try {
+        addon = require(join(cwd, nodeFile));
+    }
+    catch (err) {
+        process.stderr.write(`note: skipped type generation (could not load ${nodeFile}: ${errMessage(err)})\n`);
+        return;
+    }
+    const dts = addon.__zignapi_dts__;
+    if (typeof dts !== "string" || dts.length === 0) {
+        process.stderr.write("note: addon has no embedded type info; skipping index.d.ts\n");
+        return;
+    }
+    writeFileSync(join(cwd, "index.d.ts"), `// Generated by zignapi — do not edit.\n\n${dts}`);
+    writeFileSync(join(cwd, "index.js"), `"use strict";\n` +
+        `const addon = require("./${nodeFile}");\n` +
+        `const { __zignapi_dts__, ...api } = addon;\n` +
+        `module.exports = api;\n`);
+    process.stdout.write("✔ generated index.js + index.d.ts\n");
 }
 /**
  * Find the built addon under zig-out. Prefers an already-named `.node`,

package/dist/new.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import process from "node:process";
-import { releaseUrl, resolveZigbindSources, runZig } from "./zig.js";
+import { releaseUrl, resolveZignapiSources, runZig, errMessage } from "./zig.js";
 // The template tree lives at the package root (as `templates/`), so it resolves
 // the same whether we run from the compiled `dist/` or the source `src/`.
 const TEMPLATES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "templates");
@@ -14,7 +14,7 @@ Usage:
   zignapi new <name> [--local]
 
 Creates ./<name> from the built-in template, substituting the project name,
-then wires up the zigbind Zig dependency with "zig fetch --save" (pinned by
+then wires up the zignapi Zig dependency with "zig fetch --save" (pinned by
 content hash). By default it fetches the hosted release tarball, so the project
 is portable across machines/CI; if that's unreachable it falls back to the Zig
 sources bundled with the CLI.
@@ -46,7 +46,7 @@ export async function runNew(argv) {
         throw new Error(`directory '${name}' already exists`);
     }
     copyTemplate(TEMPLATES_DIR, target, name);
-    addZigbindDependency(target, { local: values.local ?? false });
+    addZignapiDependency(target, { local: values.local ?? false });
     process.stdout.write(`✔ created ${name}/\n\n` +
         `Next steps:\n` +
         `  cd ${name}\n` +
@@ -54,36 +54,36 @@ export async function runNew(argv) {
         `  node --test\n`);
 }
 /**
- * Add the `zigbind` Zig dependency to the freshly scaffolded project via
+ * Add the `zignapi` Zig dependency to the freshly scaffolded project via
  * `zig fetch --save`, pinning it by content hash. Prefers the hosted release
  * tarball (portable across machines) and falls back to the Zig sources bundled
  * with the CLI if that's unreachable or `local` is set. Non-fatal: if Zig isn't
  * available at all, tell the user how to finish the wiring later.
  */
-function addZigbindDependency(target, { local }) {
+function addZignapiDependency(target, { local }) {
     const repairZon = join(target, "build.zig.zon");
     if (!local) {
         const url = releaseUrl();
         try {
-            runZig(target, ["fetch", "--save=zigbind", url], { repairZon });
-            process.stdout.write(`✔ added zigbind dependency from ${url}\n`);
+            runZig(target, ["fetch", "--save=zignapi", url], { repairZon });
+            process.stdout.write(`✔ added zignapi dependency from ${url}\n`);
             return;
         }
         catch (err) {
-            process.stderr.write(`note: could not fetch the hosted zigbind release (${errMessage(err)}); ` +
+            process.stderr.write(`note: could not fetch the hosted zignapi release (${errMessage(err)}); ` +
                 `falling back to the bundled sources.\n`);
         }
     }
     let sources;
     try {
-        sources = resolveZigbindSources();
-        runZig(target, ["fetch", "--save=zigbind", sources], { repairZon });
-        process.stdout.write("✔ added zigbind dependency from bundled sources\n");
+        sources = resolveZignapiSources();
+        runZig(target, ["fetch", "--save=zignapi", sources], { repairZon });
+        process.stdout.write("✔ added zignapi dependency from bundled sources\n");
     }
     catch (err) {
-        process.stderr.write(`warning: could not add the zigbind dependency automatically ` +
+        process.stderr.write(`warning: could not add the zignapi dependency automatically ` +
             `(${errMessage(err)}).\nRun this inside the project once Zig 0.16.0 is ` +
-            `available:\n  zig fetch --save=zigbind ${sources ?? releaseUrl()}\n`);
+            `available:\n  zig fetch --save=zignapi ${sources ?? releaseUrl()}\n`);
     }
 }
 /**
@@ -113,6 +113,3 @@ function validateName(name) {
             `must not start with a digit)`);
     }
 }
-function errMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/zig.js

@@ -7,25 +7,25 @@ import process from "node:process";
 // up is the package root.
 const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
 /**
- * The hosted release tarball of the zigbind Zig package, used as the default
- * (portable, shareable) dependency source. Overridable via ZIGBIND_RELEASE_URL
+ * The hosted release tarball of the zignapi Zig package, used as the default
+ * (portable, shareable) dependency source. Overridable via ZIGNAPI_RELEASE_URL
  * — handy for testing against a local `file://` tarball or a mirror. The
  * version is taken from this CLI's package.json and must match the release tag.
  */
 export function releaseUrl() {
-    const override = process.env.ZIGBIND_RELEASE_URL;
+    const override = process.env.ZIGNAPI_RELEASE_URL;
     if (override)
         return override;
     const pkg = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
     const v = pkg.version;
-    return `https://github.com/zigbind/zigbind/releases/download/v${v}/zigbind-${v}.tar.gz`;
+    return `https://github.com/zignapi/zignapi/releases/download/v${v}/zignapi-${v}.tar.gz`;
 }
 /**
- * Locate the zigbind Zig sources (the `native/` directory) that ship with this
+ * Locate the zignapi Zig sources (the `native/` directory) that ship with this
  * CLI. Works both from the published npm package (bundled at `<pkg>/native`)
- * and from the monorepo checkout (`packages/zigbind` -> `../../native`).
+ * and from the monorepo checkout (`packages/zignapi` -> `../../native`).
  */
-export function resolveZigbindSources() {
+export function resolveZignapiSources() {
     const candidates = [
         join(PKG_ROOT, "native"), // bundled inside the published package
         join(PKG_ROOT, "..", "..", "native"), // monorepo layout
@@ -34,7 +34,7 @@ export function resolveZigbindSources() {
         if (existsSync(join(dir, "build.zig.zon")))
             return dir;
     }
-    throw new Error("could not locate the zigbind Zig sources (native/) shipped with the CLI");
+    throw new Error("could not locate the zignapi Zig sources (native/) shipped with the CLI");
 }
 /**
  * Run `zig` with the given args in `cwd`. If the run fails because
@@ -64,6 +64,10 @@ export function runZig(cwd, args, { repairZon } = {}) {
     }
     return res;
 }
+/** Extract a human-readable message from an unknown thrown value. */
+export function errMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 /** Insert or replace the `.fingerprint` field in a build.zig.zon. */
 export function patchFingerprint(zonPath, value) {
     if (!existsSync(zonPath))

package/native/build.zig

@@ -1,9 +1,9 @@
 const std = @import("std");
 
-/// Build script for the `zigbind` Zig library.
+/// Build script for the `zignapi` Zig library.
 ///
 /// This is a Zig package, not an npm package. Its main product is the Zig
-/// module named "zigbind" (exposed via `b.addModule`), which addons import to
+/// module named "zignapi" (exposed via `b.addModule`), which addons import to
 /// register their functions with Node. Building here also runs two local
 /// checks so `zig build` in this directory validates the library on its own:
 ///
@@ -16,12 +16,12 @@ pub fn build(b: *std.Build) void {
 
     const headers = b.path("vendor/node-api-headers");
 
-    // The module consumers import as `@import("zigbind")`. It links libc (for
+    // The module consumers import as `@import("zignapi")`. It links libc (for
     // the C allocator used to marshal string arguments, and to make the N-API
     // headers available to `@cImport`). Target/optimize are left unset here so
     // each consumer picks them; the include path travels with the module.
-    const mod = b.addModule("zigbind", .{
-        .root_source_file = b.path("src/zigbind.zig"),
+    const mod = b.addModule("zignapi", .{
+        .root_source_file = b.path("src/zignapi.zig"),
         .link_libc = true,
     });
     mod.addIncludePath(headers);
@@ -37,22 +37,23 @@ pub fn build(b: *std.Build) void {
     });
     check_mod.addIncludePath(headers);
     const check_obj = b.addObject(.{
-        .name = "zigbind-check",
+        .name = "zignapi-check",
         .root_module = check_mod,
     });
     b.getInstallStep().dependOn(&check_obj.step);
 
-    // Unit tests: only the pure-comptime conversions (no N-API runtime calls),
-    // so the test binary links without Node present.
-    const tests_mod = b.createModule(.{
-        .root_source_file = b.path("src/convert.zig"),
-        .target = target,
-        .optimize = optimize,
-        .link_libc = true,
-    });
-    tests_mod.addIncludePath(headers);
-    const unit_tests = b.addTest(.{ .root_module = tests_mod });
-    const run_tests = b.addRunArtifact(unit_tests);
-    const test_step = b.step("test", "Run zigbind unit tests");
-    test_step.dependOn(&run_tests.step);
+    // Unit tests: only pure-comptime code (no N-API runtime calls), so the test
+    // binaries link without Node present.
+    const test_step = b.step("test", "Run zignapi unit tests");
+    for ([_][]const u8{ "src/convert.zig", "src/typedefs.zig" }) |root| {
+        const tests_mod = b.createModule(.{
+            .root_source_file = b.path(root),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+        });
+        tests_mod.addIncludePath(headers);
+        const unit_tests = b.addTest(.{ .root_module = tests_mod });
+        test_step.dependOn(&b.addRunArtifact(unit_tests).step);
+    }
 }

package/native/build.zig.zon

@@ -1,7 +1,7 @@
 .{
-    .name = .zigbind,
-    .version = "0.1.0",
-    .fingerprint = 0xb615899b08c4e528, // Changing this has security and trust implications.
+    .name = .zignapi,
+    .version = "0.2.0",
+    .fingerprint = 0x582024f92c57df77, // Changing this has security and trust implications.
     .minimum_zig_version = "0.16.0",
     .dependencies = .{},
     .paths = .{

package/native/src/_check.zig

@@ -1,13 +1,13 @@
 //! Build-only compile check (never shipped to consumers, not imported by
-//! `zigbind.zig`). Building this as an *object* forces the whole comptime
+//! `zignapi.zig`). Building this as an *object* forces the whole comptime
 //! pipeline — `register` → the per-function callback trampolines → `convert`
 //! for every supported type, including an error union — to be analyzed, so
 //! `zig build` in `native/` fails loudly on any API or type mistake. The
 //! N-API symbols it references stay undefined in the object file; they are
 //! resolved when a real addon links, exactly as in production.
 
-const zigbind = @import("zigbind.zig");
-const napi = zigbind.napi;
+const zignapi = @import("zignapi.zig");
+const napi = zignapi.napi;
 
 // Reference the concrete (non-generic) wrappers so they are compiled too.
 comptime {
@@ -35,7 +35,7 @@ fn checked(x: i32) !i32 {
 }
 
 comptime {
-    zigbind.register(.{
+    zignapi.register(.{
         .add = add,
         .negate = negate,
         .scale = scale,

package/native/src/convert.zig

@@ -31,7 +31,7 @@ pub fn classify(comptime T: type) Kind {
 /// Compile-time guard that fails with a readable message for unsupported types.
 fn assertSupported(comptime T: type) void {
     if (classify(T) == .unsupported) {
-        @compileError("zigbind: unsupported type '" ++ @typeName(T) ++
+        @compileError("zignapi: unsupported type '" ++ @typeName(T) ++
             "' (supported: integers, floats, bool, []const u8)");
     }
 }

package/native/src/napi.zig

@@ -60,3 +60,10 @@ pub fn createFunction(env: Env, name: [:0]const u8, cb: Callback) Error!Value {
     try check(c.napi_create_function(env, name.ptr, name.len, cb, null, &result));
     return result;
 }
+
+/// Create a JS UTF-8 string from a Zig slice.
+pub fn createString(env: Env, s: []const u8) Error!Value {
+    var result: Value = undefined;
+    try check(c.napi_create_string_utf8(env, s.ptr, s.len, &result));
+    return result;
+}

package/native/src/register.zig

@@ -4,14 +4,15 @@
 //! Usage from an addon's root source file:
 //!
 //! ```zig
-//! const zigbind = @import("zigbind");
+//! const zignapi = @import("zignapi");
 //! pub fn add(a: i32, b: i32) i32 { return a + b; }
-//! comptime { zigbind.register(.{ .add = add }); }
+//! comptime { zignapi.register(.{ .add = add }); }
 //! ```
 
 const std = @import("std");
 const napi = @import("napi.zig");
 const convert = @import("convert.zig");
+const typedefs = @import("typedefs.zig");
 const c = napi.c;
 
 /// Export `napi_register_module_v1` for the given set of functions.
@@ -24,18 +25,27 @@ pub fn register(comptime defs: anytype) void {
     const Defs = @TypeOf(defs);
     switch (@typeInfo(Defs)) {
         .@"struct" => {},
-        else => @compileError("zigbind.register expects a struct literal, e.g. .{ .add = add }"),
+        else => @compileError("zignapi.register expects a struct literal, e.g. .{ .add = add }"),
     }
 
+    // TypeScript declarations for this module, generated at comptime and
+    // embedded so `zignapi build` can emit `index.d.ts` / `index.js`.
+    const dts = typedefs.declarations(defs);
+
     const Registrar = struct {
         fn entry(env: napi.Env, exports: napi.Value) callconv(.c) napi.Value {
             inline for (@typeInfo(Defs).@"struct".fields) |field| {
                 const func = @field(defs, field.name);
                 registerOne(env, exports, field.name, func) catch {
-                    napi.throwError(env, "zigbind: failed to register '" ++ field.name ++ "'");
+                    napi.throwError(env, "zignapi: failed to register '" ++ field.name ++ "'");
                     return null;
                 };
             }
+            // Best-effort: attach the type declarations. Failure here must not
+            // break a working module, so ignore errors.
+            if (napi.createString(env, dts)) |v| {
+                napi.setNamedProperty(env, exports, "__zignapi_dts__", v) catch {};
+            } else |_| {}
             return exports;
         }
     };
@@ -67,7 +77,7 @@ fn Wrap(comptime func: anytype) type {
             // Collect the JS arguments (one slot per Zig parameter).
             var argv: [fn_info.params.len]napi.Value = undefined;
             _ = napi.getCallbackInfo(env, info, &argv) catch {
-                napi.throwError(env, "zigbind: failed to read arguments");
+                napi.throwError(env, "zignapi: failed to read arguments");
                 return null;
             };
 
@@ -81,7 +91,7 @@ fn Wrap(comptime func: anytype) type {
             var args: std.meta.ArgsTuple(@TypeOf(func)) = undefined;
             inline for (fn_info.params, 0..) |param, i| {
                 args[i] = convert.fromJs(param.type.?, env, argv[i], allocator) catch {
-                    napi.throwError(env, "zigbind: failed to convert argument");
+                    napi.throwError(env, "zignapi: failed to convert argument");
                     return null;
                 };
             }
@@ -108,7 +118,7 @@ fn Wrap(comptime func: anytype) type {
 
         fn toJs(env: napi.Env, comptime T: type, value: T) napi.Value {
             return convert.toJs(T, env, value) catch {
-                napi.throwError(env, "zigbind: failed to convert return value");
+                napi.throwError(env, "zignapi: failed to convert return value");
                 return null;
             };
         }

package/native/src/typedefs.zig

@@ -0,0 +1,77 @@
+//! Comptime generation of TypeScript declarations for the registered functions.
+//!
+//! The mapping reuses `convert.classify`, so the `.d.ts` and the runtime
+//! conversions can never drift apart. `register.zig` embeds the produced string
+//! in the addon (as the `__zignapi_dts__` export); `zignapi build` reads it back
+//! and writes `index.d.ts` / `index.js`.
+
+const std = @import("std");
+const convert = @import("convert.zig");
+
+/// The TypeScript type string for a Zig type. Error unions map to their payload
+/// (Zig errors surface as thrown JS exceptions, which don't appear in the type);
+/// `void` maps to `void`.
+pub fn tsType(comptime T: type) []const u8 {
+    return switch (@typeInfo(T)) {
+        .void => "void",
+        .error_union => |eu| tsType(eu.payload),
+        else => switch (convert.classify(T)) {
+            .int, .float => "number",
+            .bool => "boolean",
+            .string => "string",
+            .unsupported => @compileError(
+                "zignapi: no TypeScript mapping for '" ++ @typeName(T) ++ "'",
+            ),
+        },
+    };
+}
+
+/// Build the `.d.ts` body: one `export function` line per registered function.
+/// Parameter names aren't available from `@typeInfo`, so they're `arg0`, `arg1`, …
+pub fn declarations(comptime defs: anytype) []const u8 {
+    comptime var out: []const u8 = "";
+    inline for (@typeInfo(@TypeOf(defs)).@"struct".fields) |field| {
+        const fn_info = @typeInfo(@TypeOf(@field(defs, field.name))).@"fn";
+        comptime var params: []const u8 = "";
+        inline for (fn_info.params, 0..) |param, i| {
+            const sep = if (i == 0) "" else ", ";
+            params = params ++ sep ++ std.fmt.comptimePrint(
+                "arg{d}: {s}",
+                .{ i, tsType(param.type.?) },
+            );
+        }
+        out = out ++ "export function " ++ field.name ++ "(" ++ params ++
+            "): " ++ tsType(fn_info.return_type.?) ++ ";\n";
+    }
+    return out;
+}
+
+test "declarations render one export per function" {
+    const S = struct {
+        fn add(a: i32, b: i32) i32 {
+            return a + b;
+        }
+        fn greet(name: []const u8) []const u8 {
+            return name;
+        }
+        fn toggle(x: bool) bool {
+            return !x;
+        }
+        fn checked(x: i32) !i32 {
+            return x;
+        }
+    };
+    const dts = comptime declarations(.{
+        .add = S.add,
+        .greet = S.greet,
+        .toggle = S.toggle,
+        .checked = S.checked,
+    });
+    try std.testing.expectEqualStrings(
+        \\export function add(arg0: number, arg1: number): number;
+        \\export function greet(arg0: string): string;
+        \\export function toggle(arg0: boolean): boolean;
+        \\export function checked(arg0: number): number;
+        \\
+    , dts);
+}

package/native/src/{zigbind.zig → zignapi.zig}

@@ -1,7 +1,7 @@
-//! zigbind — write native Node.js addons in Zig.
+//! zignapi — write native Node.js addons in Zig.
 //!
 //! This is the public entry point of the Zig module consumers import with
-//! `@import("zigbind")`. It re-exports the pieces an addon author needs:
+//! `@import("zignapi")`. It re-exports the pieces an addon author needs:
 //!
 //!   - `register` : expose Zig functions to JS and emit `napi_register_module_v1`.
 //!   - `napi`     : the raw N-API bindings and thin wrappers, for escape hatches.
@@ -12,6 +12,7 @@ const std = @import("std");
 
 pub const napi = @import("napi.zig");
 pub const convert = @import("convert.zig");
+pub const typedefs = @import("typedefs.zig");
 pub const async_ = @import("async.zig");
 
 /// Register Zig functions as a Node addon. See `register.zig`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zignapi",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "CLI to scaffold and build native Node.js addons written in Zig (the `zignapi` command)",
   "keywords": [
     "zig",
@@ -8,13 +8,13 @@
     "node-api",
     "native",
     "addon",
-    "zigbind"
+    "zignapi"
   ],
-  "homepage": "https://github.com/zigbind/zigbind",
+  "homepage": "https://github.com/zignapi/zignapi",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/zigbind/zigbind.git",
-    "directory": "packages/zigbind"
+    "url": "git+https://github.com/zignapi/zignapi.git",
+    "directory": "packages/zignapi"
   },
   "type": "module",
   "bin": {

package/templates/README.md

@@ -1,17 +1,17 @@
 # __NAME__
 
 A native Node.js addon written in [Zig](https://ziglang.org/) with
-[zigbind](https://github.com/) — requires **Zig 0.16.0** and **Node >= 18**.
+[zignapi](https://github.com/) — requires **Zig 0.16.0** and **Node >= 18**.
 
 ```sh
 zignapi build      # compiles src/main.zig into __NAME__.node (and zig-out/lib/)
 node --test        # runs test.js
 ```
 
-Edit `src/main.zig` to add functions, then list them in the `zigbind.register`
+Edit `src/main.zig` to add functions, then list them in the `zignapi.register`
 call at the bottom of that file.
 
-## The zigbind dependency
+## The zignapi dependency
 
 `zignapi new` added the `zignapi` Zig module to `build.zig.zon` with
 `zig fetch --save`, which pins it by content hash:

package/templates/build.zig

@@ -2,13 +2,13 @@ const std = @import("std");
 
 /// Builds the addon into `zig-out/lib/__NAME__.node`.
 ///
-/// The addon is a dynamic library importing the `zigbind` module. N-API symbols
+/// The addon is a dynamic library importing the `zignapi` module. N-API symbols
 /// are left undefined at link time and resolved by Node when it loads the addon.
 pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const zigbind = b.dependency("zigbind", .{}).module("zigbind");
+    const zignapi = b.dependency("zignapi", .{}).module("zignapi");
 
     const addon = b.addLibrary(.{
         .name = "__NAME__",
@@ -19,7 +19,7 @@ pub fn build(b: *std.Build) void {
             .optimize = optimize,
             .link_libc = true,
             .imports = &.{
-                .{ .name = "zigbind", .module = zigbind },
+                .{ .name = "zignapi", .module = zignapi },
             },
         }),
     });

package/templates/build.zig.zon

@@ -2,8 +2,8 @@
     .name = .__NAME__,
     .version = "0.1.0",
     .minimum_zig_version = "0.16.0",
-    // `zignapi new` fills in `.fingerprint` and adds the `zigbind` dependency
-    // below via `zig fetch --save` (which pins zigbind by content hash).
+    // `zignapi new` fills in `.fingerprint` and adds the `zignapi` dependency
+    // below via `zig fetch --save` (which pins zignapi by content hash).
     .dependencies = .{},
     .paths = .{
         "build.zig",

package/templates/dot-gitignore

@@ -2,3 +2,7 @@ node_modules/
 zig-out/
 .zig-cache/
 *.node
+
+# Generated by `zignapi build`
+index.js
+index.d.ts

package/templates/package.json

@@ -2,6 +2,8 @@
   "name": "__NAME__",
   "version": "0.1.0",
   "private": true,
+  "main": "index.js",
+  "types": "index.d.ts",
   "scripts": {
     "build": "zignapi build",
     "test": "node --test"

package/templates/src/main.zig

@@ -1,4 +1,4 @@
-const zigbind = @import("zigbind");
+const zignapi = @import("zignapi");
 
 /// Exposed to JS as `addon.add(a, b)`.
 pub fn add(a: i32, b: i32) i32 {
@@ -14,7 +14,7 @@ pub fn greet(name: []const u8) []const u8 {
 // Emits `napi_register_module_v1`. Each field becomes a property on the addon's
 // `exports`. Add your own Zig functions here.
 comptime {
-    zigbind.register(.{
+    zignapi.register(.{
         .add = add,
         .greet = greet,
     });

package/templates/test.js

@@ -1,7 +1,10 @@
 const test = require("node:test");
 const assert = require("node:assert");
+const fs = require("node:fs");
 
-const addon = require("./zig-out/lib/__NAME__.node");
+// The generated loader (index.js) re-exports the addon; index.d.ts gives it types.
+// Both are produced by `zignapi build`, so build before running the tests.
+const addon = require("./index.js");
 
 test("add(2, 3) === 5", () => {
   assert.strictEqual(addon.add(2, 3), 5);
@@ -10,3 +13,9 @@ test("add(2, 3) === 5", () => {
 test("greet returns a string", () => {
   assert.strictEqual(addon.greet("world"), "hello from Zig");
 });
+
+test("index.d.ts declares the exports", () => {
+  const dts = fs.readFileSync("./index.d.ts", "utf8");
+  assert.match(dts, /export function add\(arg0: number, arg1: number\): number;/);
+  assert.match(dts, /export function greet\(arg0: string\): string;/);
+});