zignapi 0.1.0 → 0.1.1

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/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 } 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`);
     }
 }
 /**

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

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,7 +37,7 @@ 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);
@@ -53,6 +53,6 @@ pub fn build(b: *std.Build) void {
     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");
+    const test_step = b.step("test", "Run zignapi unit tests");
     test_step.dependOn(&run_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.1.1",
+    .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/register.zig

@@ -4,9 +4,9 @@
 //! 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");
@@ -24,7 +24,7 @@ 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 }"),
     }
 
     const Registrar = struct {
@@ -32,7 +32,7 @@ pub fn register(comptime defs: anytype) void {
             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;
                 };
             }
@@ -67,7 +67,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 +81,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 +108,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/{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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zignapi",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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/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,
     });