@bolt-foundry/gambit 0.5.3-dev.1 → 0.6.0

package/CHANGELOG.md

@@ -5,10 +5,30 @@ since = "b0ddcc2ba4e861e0879dc92cc713e8cde30d230f"
 
 # Changelog
 
-## Unreleased (v0.6.0)
+## Unreleased (v0.6.1)
 
 - TBD
 
+## v0.6.0
+
+### Release and packaging
+
+- Add an npm CLI wrapper that downloads prebuilt Gambit binaries with checksum
+  verification.
+- Normalize release binary asset names and checksum generation for predictable
+  npm downloads.
+- Fix the npm build to resolve gambit-core in the mirror layout and derive
+  import-map targets from the detected path.
+- Add `@deno/dnt` to the Gambit package and refresh release/npm docs.
+
+## v0.5.5
+
+### Release and packaging
+
+- Publish a minimal `@bolt-foundry/gambit` npm package alongside gambit-core
+  (runtime-only; no CLI/bin yet).
+- Document DNT/npm status and release notes for the npm publish flow.
+
 ## v0.5.0
 
 ### Runtime and API

package/bin/gambit.cjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const https = require("https");
+const http = require("http");
+const crypto = require("crypto");
+const { spawnSync } = require("child_process");
+
+const MAX_REDIRECTS = 5;
+
+const readJson = (filePath) => {
+  const raw = fs.readFileSync(filePath, "utf8");
+  return JSON.parse(raw);
+};
+
+const getPackageVersion = () => {
+  const pkgPath = path.join(__dirname, "..", "package.json");
+  const pkg = readJson(pkgPath);
+  if (!pkg.version) {
+    throw new Error(`Missing version in ${pkgPath}`);
+  }
+  return pkg.version;
+};
+
+const getPlatformAsset = () => {
+  const { platform, arch } = process;
+  if (platform === "darwin" && arch === "arm64") {
+    return "gambit-darwin-arm64";
+  }
+  if (platform === "darwin" && arch === "x64") {
+    return "gambit-darwin-x64";
+  }
+  if (platform === "linux" && arch === "x64") {
+    return "gambit-linux-x64";
+  }
+  if (platform === "linux" && arch === "arm64") {
+    return "gambit-linux-arm64";
+  }
+  return "";
+};
+
+const getCacheDir = (version) => {
+  const cacheRoot = process.env.XDG_CACHE_HOME ||
+    (process.env.HOME ? path.join(process.env.HOME, ".cache") : os.tmpdir());
+  return path.join(cacheRoot, "bolt-foundry", "gambit", version);
+};
+
+const request = (url, redirectCount = 0) =>
+  new Promise((resolve, reject) => {
+    const client = url.startsWith("https:") ? https : http;
+    const req = client.get(url, (res) => {
+      const status = res.statusCode || 0;
+      if (
+        status >= 300 && status < 400 && res.headers.location &&
+        redirectCount < MAX_REDIRECTS
+      ) {
+        const nextUrl = new URL(res.headers.location, url).toString();
+        res.resume();
+        resolve(request(nextUrl, redirectCount + 1));
+        return;
+      }
+      if (status !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${status} for ${url}`));
+        return;
+      }
+      resolve(res);
+    });
+    req.on("error", reject);
+  });
+
+const downloadFile = async (url, dest) => {
+  const tmpDest = `${dest}.tmp-${process.pid}`;
+  await fs.promises.mkdir(path.dirname(dest), { recursive: true });
+  const res = await request(url);
+  await new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(tmpDest, { mode: 0o755 });
+    res.pipe(file);
+    res.on("error", (err) => {
+      file.close(() => reject(err));
+    });
+    file.on("finish", () => file.close(resolve));
+    file.on("error", reject);
+  });
+  await fs.promises.rename(tmpDest, dest);
+};
+
+const fetchText = async (url) => {
+  const res = await request(url);
+  const chunks = [];
+  for await (const chunk of res) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
+
+const sha256File = (filePath) =>
+  new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+
+const allowUnverified = process.env.GAMBIT_ALLOW_UNVERIFIED === "1";
+
+const verifyChecksum = async (checksumUrl, assetName, filePath) => {
+  let text;
+  try {
+    text = await fetchText(checksumUrl);
+  } catch (err) {
+    if (allowUnverified) {
+      console.warn(`Warning: unable to fetch checksums: ${err.message}`);
+      return;
+    }
+    throw new Error(`Unable to fetch checksums: ${err.message}`);
+  }
+  const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
+  const match = lines
+    .map((line) => line.match(/^([a-f0-9]{64})\s+(.+)$/i))
+    .find((result) => result && path.posix.basename(result[2]) === assetName);
+  if (!match) {
+    if (allowUnverified) {
+      console.warn(`Warning: checksum for ${assetName} not found.`);
+      return;
+    }
+    throw new Error(`Checksum for ${assetName} not found.`);
+  }
+  const expected = match[1].toLowerCase();
+  const actual = (await sha256File(filePath)).toLowerCase();
+  if (expected !== actual) {
+    throw new Error(`Checksum mismatch for ${assetName}`);
+  }
+};
+
+const main = async () => {
+  const version = getPackageVersion();
+  const assetName = process.env.GAMBIT_BINARY_NAME || getPlatformAsset();
+  if (!assetName) {
+    console.error(
+      `Unsupported platform ${process.platform}/${process.arch}.`,
+    );
+    process.exit(1);
+  }
+
+  const baseUrl = process.env.GAMBIT_BINARY_BASE_URL ||
+    `https://github.com/bolt-foundry/gambit/releases/download/v${version}`;
+  const binaryUrl = process.env.GAMBIT_BINARY_URL || `${baseUrl}/${assetName}`;
+  const checksumUrl = process.env.GAMBIT_BINARY_CHECKSUM_URL ||
+    `${baseUrl}/SHA256SUMS`;
+
+  const cacheDir = getCacheDir(version);
+  const binPath = path.join(cacheDir, assetName);
+  const ensureBinary = async () => {
+    if (fs.existsSync(binPath)) {
+      try {
+        await verifyChecksum(checksumUrl, assetName, binPath);
+        return;
+      } catch (err) {
+        console.warn(
+          `Cached binary failed checksum; deleting and re-downloading.`,
+        );
+        try {
+          await fs.promises.unlink(binPath);
+        } catch {
+          // ignore
+        }
+      }
+    }
+    console.log(`Downloading ${binaryUrl}...`);
+    await downloadFile(binaryUrl, binPath);
+    try {
+      await verifyChecksum(checksumUrl, assetName, binPath);
+    } catch (err) {
+      try {
+        await fs.promises.unlink(binPath);
+      } catch {
+        // ignore
+      }
+      throw err;
+    }
+  };
+
+  try {
+    await ensureBinary();
+  } catch (err) {
+    console.error(`Checksum verification failed: ${err.message}`);
+    process.exit(1);
+  }
+
+  try {
+    await fs.promises.chmod(binPath, 0o755);
+  } catch {
+    // ignore
+  }
+
+  const result = spawnSync(binPath, process.argv.slice(2), {
+    stdio: "inherit",
+  });
+  if (result.error) {
+    console.error(`Failed to launch gambit: ${result.error.message}`);
+    process.exit(1);
+  }
+  process.exit(result.status ?? 1);
+};
+
+main().catch((err) => {
+  console.error(err.stack || err.message || String(err));
+  process.exit(1);
+});

package/esm/_dnt.polyfills.d.ts

@@ -1,5 +1,49 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+import { createRequire } from "node:module";
+import { type URL } from "node:url";
 declare global {
     interface ImportMeta {
+        /** A string representation of the fully qualified module URL. When the
+         * module is loaded locally, the value will be a file URL (e.g.
+         * `file:///path/module.ts`).
+         *
+         * You can also parse the string as a URL to determine more information about
+         * how the current module was loaded. For example to determine if a module was
+         * local or not:
+         *
+         * ```ts
+         * const url = new URL(import.meta.url);
+         * if (url.protocol === "file:") {
+         *   console.log("this module was loaded locally");
+         * }
+         * ```
+         */
+        url: string;
+        /**
+         * A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         *
+         * @param specifier The module specifier to resolve relative to `parent`.
+         * @param parent The absolute parent module URL to resolve from.
+         * @returns The absolute (`file:`) URL string for the resolved module.
+         */
+        resolve(specifier: string, parent?: string | URL | undefined): string;
         /** A flag that indicates if the current module is the main module that was
          * called when starting the program under Deno.
          *
@@ -10,16 +54,48 @@ declare global {
          * ```
          */
         main: boolean;
-        /** A function that returns resolved specifier as if it would be imported
-         * using `import(specifier)`.
+        /** The absolute path of the current module.
          *
-         * ```ts
-         * console.log(import.meta.resolve("./foo.js"));
-         * // file:///dev/foo.js
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.filename); // /home/alice/my_module.ts
+         *
+         * // Windows
+         * console.log(import.meta.filename); // C:\alice\my_module.ts
          * ```
          */
-        resolve(specifier: string): string;
+        filename: string;
+        /** The absolute path of the directory containing the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.dirname); // /home/alice
+         *
+         * // Windows
+         * console.log(import.meta.dirname); // C:\alice
+         * ```
+         */
+        dirname: string;
     }
 }
+type NodeRequest = ReturnType<typeof createRequire>;
+type NodeModule = NonNullable<NodeRequest["main"]>;
+interface ImportMetaPonyfillCommonjs {
+    (require: NodeRequest, module: NodeModule): ImportMeta;
+}
+interface ImportMetaPonyfillEsmodule {
+    (importMeta: ImportMeta): ImportMeta;
+}
+interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyfillEsmodule {
+}
+export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
+export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
+export declare let import_meta_ponyfill: ImportMetaPonyfill;
 export {};
 //# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;WAOG;QAEH,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;KACpC;CACF;AAED,OAAO,EAAE,CAAA"}
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;;;;;;;WAcG;QACH,GAAG,EAAE,MAAM,CAAC;QACZ;;;;;;;;;;;;WAYG;QACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,CAAC;QACtE;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;;;;;;WAYG;QACH,QAAQ,EAAE,MAAM,CAAC;QAEjB;;;;;;;;;;;;WAYG;QACH,OAAO,EAAE,MAAM,CAAC;KACjB;CACF;AAED,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;AACnD,UAAU,0BAA0B;IAClC,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACxD;AACD,UAAU,0BAA0B;IAClC,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AACD,UAAU,kBACR,SAAQ,0BAA0B,EAAE,0BAA0B;CAC/D;AAiBD,eAAO,IAAI,6BAA6B,EA2BnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,6BAA6B,EA4DnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,oBAAoB,EAoB1B,kBAAkB,CAAC"}

package/esm/_dnt.polyfills.js

@@ -1 +1,127 @@
-export {};
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+//@ts-ignore
+import { createRequire } from "node:module";
+//@ts-ignore
+import { fileURLToPath, pathToFileURL } from "node:url";
+//@ts-ignore
+import { dirname } from "node:path";
+const defineGlobalPonyfill = (symbolFor, fn) => {
+    if (!Reflect.has(globalThis, Symbol.for(symbolFor))) {
+        Object.defineProperty(globalThis, Symbol.for(symbolFor), {
+            configurable: true,
+            get() {
+                return fn;
+            },
+        });
+    }
+};
+export let import_meta_ponyfill_commonjs = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-commonjs")) ??
+    (() => {
+        const moduleImportMetaWM = new WeakMap();
+        return (require, module) => {
+            let importMetaCache = moduleImportMetaWM.get(module);
+            if (importMetaCache == null) {
+                const importMeta = Object.assign(Object.create(null), {
+                    url: pathToFileURL(module.filename).href,
+                    main: require.main == module,
+                    resolve: (specifier, parentURL = importMeta.url) => {
+                        return pathToFileURL((importMeta.url === parentURL
+                            ? require
+                            : createRequire(parentURL))
+                            .resolve(specifier)).href;
+                    },
+                    filename: module.filename,
+                    dirname: module.path,
+                });
+                moduleImportMetaWM.set(module, importMeta);
+                importMetaCache = importMeta;
+            }
+            return importMetaCache;
+        };
+    })());
+defineGlobalPonyfill("import-meta-ponyfill-commonjs", import_meta_ponyfill_commonjs);
+export let import_meta_ponyfill_esmodule = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-esmodule")) ??
+    ((importMeta) => {
+        const resolveFunStr = String(importMeta.resolve);
+        const shimWs = new WeakSet();
+        //@ts-ignore
+        const mainUrl = ("file:///" + process.argv[1].replace(/\\/g, "/"))
+            .replace(/\/{3,}/, "///");
+        const commonShim = (importMeta) => {
+            if (typeof importMeta.main !== "boolean") {
+                importMeta.main = importMeta.url === mainUrl;
+            }
+            if (typeof importMeta.filename !== "string") {
+                importMeta.filename = fileURLToPath(importMeta.url);
+                importMeta.dirname = dirname(importMeta.filename);
+            }
+        };
+        if (
+        // v16.2.0+, v14.18.0+: Add support for WHATWG URL object to parentURL parameter.
+        resolveFunStr === "undefined" ||
+            // v20.0.0+, v18.19.0+"" This API now returns a string synchronously instead of a Promise.
+            resolveFunStr.startsWith("async")
+        // enable by --experimental-import-meta-resolve flag
+        ) {
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    const importMetaUrlRequire = {
+                        url: importMeta.url,
+                        require: createRequire(importMeta.url),
+                    };
+                    importMeta.resolve = function resolve(specifier, parentURL = importMeta.url) {
+                        return pathToFileURL((importMetaUrlRequire.url === parentURL
+                            ? importMetaUrlRequire.require
+                            : createRequire(parentURL)).resolve(specifier)).href;
+                    };
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        else {
+            /// native support
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        return import_meta_ponyfill_esmodule(importMeta);
+    }));
+defineGlobalPonyfill("import-meta-ponyfill-esmodule", import_meta_ponyfill_esmodule);
+export let import_meta_ponyfill = ((...args) => {
+    const _MODULE = (() => {
+        if (typeof require === "function" && typeof module === "object") {
+            return "commonjs";
+        }
+        else {
+            // eval("typeof import.meta");
+            return "esmodule";
+        }
+    })();
+    if (_MODULE === "commonjs") {
+        //@ts-ignore
+        import_meta_ponyfill = (r, m) => import_meta_ponyfill_commonjs(r, m);
+    }
+    else {
+        //@ts-ignore
+        import_meta_ponyfill = (im) => import_meta_ponyfill_esmodule(im);
+    }
+    //@ts-ignore
+    return import_meta_ponyfill(...args);
+});

package/esm/deps/jsr.io/@std/path/1.1.4/constants.d.ts

@@ -7,7 +7,7 @@ export declare const DELIMITER: ";" | ":";
  * The character used to separate components of a file path.
  * On Windows, this is `\`. On all other platforms, this is `/`.
  */
-export declare const SEPARATOR: "\\" | "/";
+export declare const SEPARATOR: "/" | "\\";
 /**
  * A regular expression that matches one or more path separators.
  */

package/esm/deps/jsr.io/@std/path/1.1.4/posix/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/posix/constants.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,SAAS,KAAe,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,SAAS,KAAe,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAQ,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/posix/constants.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,SAAS,EAAG,GAAY,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,SAAS,EAAG,GAAY,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAQ,CAAC"}

package/esm/deps/jsr.io/@std/path/1.1.4/windows/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/constants.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,SAAS,KAAe,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,SAAS,MAAgB,CAAC;AACvC;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAW,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/constants.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,SAAS,EAAG,GAAY,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,SAAS,EAAG,IAAa,CAAC;AACvC;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAW,CAAC"}