@kineviz/ladybug-lite 0.15.3 → 0.16.1

package/package.json

@@ -1,27 +1,30 @@
-{
-  "name": "@kineviz/ladybug-lite",
-  "version": "0.15.3",
-  "description": "A lightweight fork of the Ladybug (formerly Kùzu) embedded graph database, optimized for faster installation and broader compatibility.",
-  "main": "index.js",
-  "homepage": "https://ladybugdb.com/",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Kineviz/ladybug-lite.git"
-  },
-  "scripts": {
-    "build:ladybug": "bash ./util/buildLadybugWithDocker.sh",
-    "build": "node util/build.js",
-    "install": "node util/install.js",
-    "copy": "node util/copy.js",
-    "test": "node util/test.js",
-    "release": "npm publish --access public --registry https://registry.npmjs.org"
-  },
-  "author": "Ladybug Team",
-  "license": "MIT",
-  "devDependencies": {
-    "@ladybugdb/core": "^0.15.3"
-  },
-  "dependencies": {
-    "https-proxy-agent": "^7.0.6"
-  }
-}
+{
+  "name": "@kineviz/ladybug-lite",
+  "version": "0.16.1",
+  "description": "A lightweight fork of the Ladybug (formerly Kùzu) embedded graph database, optimized for faster installation and broader compatibility.",
+  "main": "index.js",
+  "homepage": "https://ladybugdb.com/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kineviz/ladybug-lite.git"
+  },
+  "scripts": {
+    "build:ladybug": "bash ./util/buildLadybugWithDocker.sh",
+    "build": "node util/build.js",
+    "build:native": "bash ./util/buildLbugjsNode.sh",
+    "build:extensions": "bash ./util/buildLadybugExtensions.sh",
+    "clone:source": "bash ./util/cloneLbugSource.sh",
+    "install": "node util/install.js",
+    "copy": "node util/copy.js",
+    "test": "node util/test.js",
+    "release": "npm publish --access public --registry https://registry.npmjs.org"
+  },
+  "author": "Ladybug Team",
+  "license": "MIT",
+  "devDependencies": {
+    "@ladybugdb/core": "^0.16.1"
+  },
+  "dependencies": {
+    "https-proxy-agent": "^7.0.6"
+  }
+}

package/util/build.js

@@ -1,248 +1,284 @@
-
-
-const fs = require("fs");
-const path = require("path");
-
-
-/**
- * Install packages
- */
-
-const installPackage = (packageName, group = 'dev') => {
-
-  console.log(
-    `Install package ${packageName}...`
-  );
-  const childProcess = require("child_process");
-  childProcess.execSync(`npm install ${packageName} --save-dev`, {
-    cwd: rootDir,
-    stdio: "inherit",
-  });
-
-}
-
-
-/**
- * Copies files from the 'node_modules/@ladybugdb/core' directory to the current directory.
- * Excludes specific directories ('lbug-source', 'node_modules') and specific files ('lbugjs.node', 'package.json').
- */
-
-const copyDir = (src, dest, excludeEntries = []) => {
-  if (!fs.existsSync(dest)) {
-    fs.mkdirSync(dest, { recursive: true });
-  }
-
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-
-    if (entry.isDirectory()) {
-      if (!excludeEntries.includes(entry.name)) {
-        copyDir(srcPath, destPath);
-      }
-    } else if (!excludeEntries.includes(entry.name)) {
-      fs.copyFileSync(srcPath, destPath);
-      console.log(`Copied: ${srcPath} -> ${destPath}`);
-    }
-  }
-};
-
-/**
- * Deletes all files and directories in the current directory
- * except for 'copy.js', 'package.json', and the 'node_modules' directory.
- */
-const deleteFiles = (directory, excludeEntries = []) => {
-  const entries = fs.readdirSync(directory, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(directory, entry.name);
-
-    // Skip if the entry is in the exclusion list
-    if (excludeEntries.includes(entry.name)) {
-      continue;
-    }
-
-    if (entry.isDirectory()) {
-      // Recursively delete directory contents then the directory itself
-      fs.rmSync(fullPath, { recursive: true, force: true });
-      console.log(`Deleted directory: ${fullPath}`);
-    } else {
-      // Delete file
-      fs.unlinkSync(fullPath);
-      console.log(`Deleted file: ${fullPath}`);
-    }
-  }
-};
-
-const npmPublish = (package) => {
-  console.log(
-    `Publishing package ${package.name}(${package.version})... to npm`
-  );
-  const npmrcPath = path.join(rootDir, ".npmrc");
-  fs.writeFileSync(
-    npmrcPath,
-    `//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}\n`,
-    { encoding: "utf-8" }
-  );
-
-  const childProcess = require("child_process");
-  try {
-    childProcess.execSync("npm publish --access public --registry https://registry.npmjs.org", {
-      cwd: rootDir,
-      stdio: "inherit",
-    });
-  } catch (err) {
-    console.error("npm publish failed:", err);
-  }
-};
-
-/**
- * Fetches platform-specific prebuilt binaries from the scoped @ladybugdb/core-*
- * packages and copies each one's lbugjs.node into ./prebuilt/, remapping x64
- * filenames to amd64 so the runtime loader can find them.
- */
-const copyPrebuiltBinaries = () => {
-  const corePackageJsonPath = path.join(srcDir, "package.json");
-  if (!fs.existsSync(corePackageJsonPath)) {
-    console.error("@ladybugdb/core package.json not found, skipping prebuilt fetch");
-    return;
-  }
-  const lbugVersion = JSON.parse(fs.readFileSync(corePackageJsonPath, "utf8")).version;
-
-  const platformPackages = [
-    "core-darwin-arm64",
-    "core-linux-arm64",
-    "core-linux-x64",
-    "core-win32-x64",
-  ];
-
-  const installArgs = platformPackages
-    .map((pkg) => `@ladybugdb/${pkg}@${lbugVersion}`)
-    .join(" ");
-
-  console.log(`Installing platform-specific prebuilt packages: ${installArgs}`);
-  const childProcess = require("child_process");
-  childProcess.execSync(`npm install --force --no-save ${installArgs}`, {
-    cwd: rootDir,
-    stdio: "inherit",
-  });
-
-  const prebuiltDir = path.join(rootDir, "prebuilt");
-  if (!fs.existsSync(prebuiltDir)) {
-    fs.mkdirSync(prebuiltDir, { recursive: true });
-  }
-
-  for (const pkg of platformPackages) {
-    const suffix = pkg.replace(/^core-/, "").replace(/-x64$/, "-amd64");
-    const srcBin = path.join(rootDir, "node_modules", "@ladybugdb", pkg, "lbugjs.node");
-    const destBin = path.join(prebuiltDir, `lbugjs-${suffix}.node`);
-    if (fs.existsSync(srcBin)) {
-      fs.copyFileSync(srcBin, destBin);
-      console.log(`Copied: ${srcBin} -> ${destBin}`);
-    } else {
-      console.warn(`Source binary not found: ${srcBin}`);
-    }
-  }
-};
-
-const asyncVersion = () => {
-  // Copy version from node_modules/@ladybugdb/core/package.json to ./package.json
-  const lbugPackageJsonPath = path.join(srcDir, "package.json");
-  const projectPackageJsonPath = path.join(rootDir, "package.json");
-
-  if (
-    !fs.existsSync(lbugPackageJsonPath) ||
-    !fs.existsSync(projectPackageJsonPath)
-  ) {
-    console.error("the package.json file not found");
-  }
-
-  let lbugPackageJson = {};
-  let projectPackageJson = {};
-  try {
-    // Read both package.json files
-    lbugPackageJson = JSON.parse(fs.readFileSync(lbugPackageJsonPath, "utf8"));
-    projectPackageJson = JSON.parse(
-      fs.readFileSync(projectPackageJsonPath, "utf8")
-    );
-  } catch (error) {
-    console.error("Can not parse the package.json version:", error);
-  }
-
-  if (projectPackageJson.version != lbugPackageJson.version) {
-    projectPackageJson.version = lbugPackageJson.version;
-    projectPackageJson.devDependencies["@ladybugdb/core"] = lbugPackageJson.version;
-    // Write the updated package.json back
-    fs.writeFileSync(
-      projectPackageJsonPath,
-      JSON.stringify(projectPackageJson, null, 2)
-    );
-    console.log(`Updated package.json version to ${lbugPackageJson.version}`);
-    npmPublish(projectPackageJson);
-  } else {
-    console.log(
-      `Package.json version is already up to date: ${lbugPackageJson.version}`
-    );
-  }
-};
-
-const rootDir = path.join(__dirname, "..");
-
-// already install @ladybugdb/core with docker or action
-// installPackage("@ladybugdb/core");
-
-// Delete files before copying new ones
-deleteFiles(rootDir, [
-  "package.json",
-  "util",
-  "node_modules",
-  "README.md",
-  "test",
-  ".git",
-  ".vscode",
-  ".gitignore",
-  ".github",
-  ".dockerignore",
-  "Dockerfile",
-  ".npmignore",
-  "docs",
-  "prebuilt"
-]);
-
-const srcDir = path.join(rootDir, "node_modules", "@ladybugdb", "core");
-const destDir = path.join(rootDir);
-
-if (fs.existsSync(srcDir)) {
-  copyDir(srcDir, destDir, [
-    "lbug-source",
-    "node_modules",
-    "lbugjs.node",
-    "package.json",
-    "install.js",
-    "README.md",
-    "test",
-    ".gitignore",
-    ".github",
-    ".dockerignore",
-    ".npmignore",
-    "Dockerfile",
-    "prebuilt",
-  ]);
-  console.log("Copying completed!");
-} else {
-  console.error("Source directory not found:", srcDir);
-}
-
-// Fetch platform-specific prebuilt binaries only on linux-x64 so a single CI
-// runner produces them (matches the former `if: matrix.arch == 'amd64'` gate).
-if (process.platform === "win32" || (process.platform === "linux" && process.arch === "x64")) {
-  copyPrebuiltBinaries();
-} else {
-  console.log(
-    `Skipping platform-specific prebuilt fetch on ${process.platform}-${process.arch}`
-  );
-}
-
-asyncVersion();
+
+
+const fs = require("fs");
+const path = require("path");
+
+
+/**
+ * Install packages
+ */
+
+const installPackage = (packageName, group = 'dev') => {
+
+  console.log(
+    `Install package ${packageName}...`
+  );
+  const childProcess = require("child_process");
+  childProcess.execSync(`npm install ${packageName} --save-dev`, {
+    cwd: rootDir,
+    stdio: "inherit",
+  });
+
+}
+
+
+/**
+ * Copies files from the 'node_modules/@ladybugdb/core' directory to the current directory.
+ * Excludes specific directories ('lbug-source', 'node_modules') and specific files ('lbugjs.node', 'package.json').
+ */
+
+const copyDir = (src, dest, excludeEntries = []) => {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      if (!excludeEntries.includes(entry.name)) {
+        copyDir(srcPath, destPath);
+      }
+    } else if (!excludeEntries.includes(entry.name)) {
+      fs.copyFileSync(srcPath, destPath);
+      console.log(`Copied: ${srcPath} -> ${destPath}`);
+    }
+  }
+};
+
+/**
+ * Deletes all files and directories in the current directory
+ * except for 'copy.js', 'package.json', and the 'node_modules' directory.
+ */
+const deleteFiles = (directory, excludeEntries = []) => {
+  const entries = fs.readdirSync(directory, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(directory, entry.name);
+
+    // Skip if the entry is in the exclusion list
+    if (excludeEntries.includes(entry.name)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      // Recursively delete directory contents then the directory itself
+      fs.rmSync(fullPath, { recursive: true, force: true });
+      console.log(`Deleted directory: ${fullPath}`);
+    } else {
+      // Delete file
+      fs.unlinkSync(fullPath);
+      console.log(`Deleted file: ${fullPath}`);
+    }
+  }
+};
+
+const npmPublish = (package) => {
+  console.log(
+    `Publishing package ${package.name}(${package.version})... to npm`
+  );
+  const npmrcPath = path.join(rootDir, ".npmrc");
+  fs.writeFileSync(
+    npmrcPath,
+    `//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}\n`,
+    { encoding: "utf-8" }
+  );
+
+  const childProcess = require("child_process");
+  try {
+    childProcess.execSync("npm publish --access public --registry https://registry.npmjs.org", {
+      cwd: rootDir,
+      stdio: "inherit",
+    });
+  } catch (err) {
+    console.error("npm publish failed:", err);
+  }
+};
+
+/**
+ * Copies any lbugjs-*.node binaries that CI wrote into
+ * node_modules/@ladybugdb/core/prebuilt/ up into ./prebuilt/ at the repo root.
+ * This covers freshly-built artifacts on every platform (darwin-amd64 and the
+ * Alpine arm64 build would otherwise never make it to the committed prebuilt/
+ * directory, since copyPrebuiltBinaries below is gated to linux-x64/win32).
+ */
+const copyLocalPrebuiltBinaries = () => {
+  const localPrebuiltDir = path.join(srcDir, "prebuilt");
+  if (!fs.existsSync(localPrebuiltDir)) {
+    return;
+  }
+  const rootPrebuiltDir = path.join(rootDir, "prebuilt");
+  if (!fs.existsSync(rootPrebuiltDir)) {
+    fs.mkdirSync(rootPrebuiltDir, { recursive: true });
+  }
+  const entries = fs
+    .readdirSync(localPrebuiltDir)
+    .filter((f) => f.endsWith(".node"));
+  for (const file of entries) {
+    const src = path.join(localPrebuiltDir, file);
+    const dest = path.join(rootPrebuiltDir, file);
+    fs.copyFileSync(src, dest);
+    console.log(`Copied: ${src} -> ${dest}`);
+  }
+};
+
+/**
+ * Fetches platform-specific prebuilt binaries from the scoped @ladybugdb/core-*
+ * packages and copies each one's lbugjs.node into ./prebuilt/, remapping x64
+ * filenames to amd64 so the runtime loader can find them.
+ */
+const copyPrebuiltBinaries = () => {
+  const corePackageJsonPath = path.join(srcDir, "package.json");
+  if (!fs.existsSync(corePackageJsonPath)) {
+    console.error("@ladybugdb/core package.json not found, skipping prebuilt fetch");
+    return;
+  }
+  const lbugVersion = JSON.parse(fs.readFileSync(corePackageJsonPath, "utf8")).version;
+
+  const platformPackages = [
+    "core-darwin-arm64",
+    "core-linux-arm64",
+    "core-linux-x64",
+    "core-win32-x64",
+  ];
+
+  const installArgs = platformPackages
+    .map((pkg) => `@ladybugdb/${pkg}@${lbugVersion}`)
+    .join(" ");
+
+  console.log(`Installing platform-specific prebuilt packages: ${installArgs}`);
+  const childProcess = require("child_process");
+  childProcess.execSync(`npm install --force --no-save ${installArgs}`, {
+    cwd: rootDir,
+    stdio: "inherit",
+  });
+
+  const prebuiltDir = path.join(rootDir, "prebuilt");
+  if (!fs.existsSync(prebuiltDir)) {
+    fs.mkdirSync(prebuiltDir, { recursive: true });
+  }
+
+  for (const pkg of platformPackages) {
+    const suffix = pkg.replace(/^core-/, "").replace(/-x64$/, "-amd64");
+    const srcBin = path.join(rootDir, "node_modules", "@ladybugdb", pkg, "lbugjs.node");
+    const destBin = path.join(prebuiltDir, `lbugjs-${suffix}.node`);
+    if (fs.existsSync(srcBin)) {
+      fs.copyFileSync(srcBin, destBin);
+      console.log(`Copied: ${srcBin} -> ${destBin}`);
+    } else {
+      console.warn(`Source binary not found: ${srcBin}`);
+    }
+  }
+};
+
+const asyncVersion = () => {
+  // Copy version from node_modules/@ladybugdb/core/package.json to ./package.json
+  const lbugPackageJsonPath = path.join(srcDir, "package.json");
+  const projectPackageJsonPath = path.join(rootDir, "package.json");
+
+  if (
+    !fs.existsSync(lbugPackageJsonPath) ||
+    !fs.existsSync(projectPackageJsonPath)
+  ) {
+    console.error("the package.json file not found");
+  }
+
+  let lbugPackageJson = {};
+  let projectPackageJson = {};
+  try {
+    // Read both package.json files
+    lbugPackageJson = JSON.parse(fs.readFileSync(lbugPackageJsonPath, "utf8"));
+    projectPackageJson = JSON.parse(
+      fs.readFileSync(projectPackageJsonPath, "utf8")
+    );
+  } catch (error) {
+    console.error("Can not parse the package.json version:", error);
+  }
+
+  if (projectPackageJson.version != lbugPackageJson.version) {
+    projectPackageJson.version = lbugPackageJson.version;
+    projectPackageJson.devDependencies["@ladybugdb/core"] = lbugPackageJson.version;
+    // Write the updated package.json back
+    fs.writeFileSync(
+      projectPackageJsonPath,
+      JSON.stringify(projectPackageJson, null, 2)
+    );
+    console.log(`Updated package.json version to ${lbugPackageJson.version}`);
+    npmPublish(projectPackageJson);
+  } else {
+    console.log(
+      `Package.json version is already up to date: ${lbugPackageJson.version}`
+    );
+  }
+};
+
+const rootDir = path.join(__dirname, "..");
+
+// already install @ladybugdb/core with docker or action
+// installPackage("@ladybugdb/core");
+
+// Delete files before copying new ones. lbug-src is the upstream clone
+// fetched by util/cloneLbugSource.sh; on Linux CI it contains files created
+// by root inside the Alpine build container and rmdir fails with EACCES, so
+// leave it alone (and it's .gitignored anyway).
+deleteFiles(rootDir, [
+  "package.json",
+  "util",
+  "node_modules",
+  "README.md",
+  "test",
+  ".git",
+  ".vscode",
+  ".gitignore",
+  ".github",
+  ".dockerignore",
+  "Dockerfile",
+  ".npmignore",
+  "docs",
+  "prebuilt",
+  "lbug-src"
+]);
+
+const srcDir = path.join(rootDir, "node_modules", "@ladybugdb", "core");
+const destDir = path.join(rootDir);
+
+if (fs.existsSync(srcDir)) {
+  copyDir(srcDir, destDir, [
+    "lbug-source",
+    "node_modules",
+    "lbugjs.node",
+    "package.json",
+    "install.js",
+    "README.md",
+    "test",
+    ".gitignore",
+    ".github",
+    ".dockerignore",
+    ".npmignore",
+    "Dockerfile",
+    "prebuilt",
+  ]);
+  console.log("Copying completed!");
+} else {
+  console.error("Source directory not found:", srcDir);
+}
+
+// Promote any freshly-built .node files from
+// node_modules/@ladybugdb/core/prebuilt/ into the repo's ./prebuilt/ dir so
+// they get committed/published. Runs on every platform.
+copyLocalPrebuiltBinaries();
+
+// Fetch platform-specific prebuilt binaries only on linux-x64 so a single CI
+// runner produces them (matches the former `if: matrix.arch == 'amd64'` gate).
+if (process.platform === "win32" || (process.platform === "linux" && process.arch === "x64")) {
+  copyPrebuiltBinaries();
+} else {
+  console.log(
+    `Skipping platform-specific prebuilt fetch on ${process.platform}-${process.arch}`
+  );
+}
+
+asyncVersion();

package/util/build.md

@@ -15,7 +15,7 @@ docker run -it \
 --name qemu-aarch64-alpine \
 -v ./:/app \
 --platform linux/arm64 \
-node:18-alpine
+node:22-alpine
 
 
  
@@ -25,7 +25,7 @@ docker run -it \
 --platform linux/amd64 \
 -v ./:/app \
 --name qemu-amd64-alpine \
-node:18-alpine
+node:22-alpine
 
 
 

package/util/buildLadybugExtensions.sh

@@ -1,79 +1,143 @@
-#!/bin/bash
-
-# Script that only compiles Ladybug extensions, supports LBUG_DIR environment variable
-# apk add --no-cache openssl openssl-dev
-APP_ROOT_DIR=$(cd $(dirname "${BASH_SOURCE[0]}")/..; pwd)
-LBUG_SOURCE_DIR="$APP_ROOT_DIR/node_modules/@ladybugdb/core/lbug-source"
-EXTENSION_DIR="${LBUG_SOURCE_DIR}/extension"
-
-
-SYSTEM="$(uname -o)"
-if [ "$SYSTEM" = "Msys" ]; then
-    export MSYS2_ARG_CONV_EXCL="*"
-    echo "Msys"
-    APP_ROOT_DIR="$(cygpath -w $APP_ROOT_DIR)"
-    LBUG_SOURCE_DIR="$(cygpath -w $LBUG_SOURCE_DIR)"
-    EXTENSION_DIR="$(cygpath -w $EXTENSION_DIR)"
-fi
-
-#EXTENSION_LIST="$(find "${EXTENSION_DIR}" -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | grep -v '^duckdb$' | sort | tr '\n' ';' | sed 's/;$//')"
-EXTENSION_LIST="httpfs;json;fts;vector;neo4j;algo"
-echo "Automatically detected extension list: ${EXTENSION_LIST}"
-
-if [ ! -f "${LBUG_SOURCE_DIR}/CMakeLists.txt" ] || [ ! -d "${LBUG_SOURCE_DIR}/extension" ]; then
-    echo "Error: Please run this script in the root directory of the ladybug repository, or set the LBUG_DIR environment variable to point to the ladybug source directory"
-    echo "Current LBUG_SOURCE_DIR: ${LBUG_SOURCE_DIR}"
-    exit 1
-fi
-
-BUILD_DIR="${LBUG_SOURCE_DIR}/build_extensions"
-if [ ! -d "$BUILD_DIR" ]; then
-    mkdir "$BUILD_DIR"
-fi
-
-cd "$BUILD_DIR" || exit 1
-
-# Check if already compiled, if so delete it
-if [ -d "extension" ]; then
-    echo "Detected existing extension directory, deleting..."
-    rm -rf extension
-fi
-
-echo "Configuring CMake to build only extensions..."
-echo "Source directory: ${LBUG_SOURCE_DIR}"
-cmake "${LBUG_SOURCE_DIR}" \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DBUILD_EXTENSIONS="${EXTENSION_LIST}" \
-    -DOPENSSL_CRYPTO_LIBRARY=/usr/lib/libcrypto.so \
-    -DOPENSSL_SSL_LIBRARY=/usr/lib/libssl.so \
-    -DOPENSSL_USE_STATIC_LIBS=OFF \
-    -DBUILD_LBUG=FALSE
-
-CORES=$(nproc --all)
-echo "Using $CORES cores for compilation..."
-
-# Use all target for compilation (more generic)
-cmake --build . -- -j"$CORES"
-
-echo "All extensions compiled successfully!"
-
-#check cpu architecture
-ARCH=$(uname -m)
-if [ "$ARCH" = "x86_64" ]; then
-    echo "Detected x86_64 architecture"
-    ARCH="amd64"
-elif [ "$ARCH" = "aarch64" ]; then
-    echo "Detected aarch64 architecture"
-    ARCH="arm64"
-else
-    echo "Unsupported architecture: $ARCH"
-    exit 1
-fi
-
-EXTENSION_DIST_DIR="${LBUG_SOURCE_DIR}/extension/alpine-${ARCH}"
-mkdir -p $EXTENSION_DIST_DIR
-find "${LBUG_SOURCE_DIR}/extension" -type f \( -path "*/build/*.lbug_extension" -o -path "*/build/*.kuzu_extension" \) -exec cp {} $EXTENSION_DIST_DIR \;
-
-# find "/app/node_modules/@ladybugdb/core/lbug-source/extension" -type f -path "*/build/*.lbug_extension" -exec cp {} /app/extensions/alpine-amd64 \;
-
-echo "All extensions have been copied to the $EXTENSION_DIST_DIR directory"
+#!/bin/bash
+
+# Script that only compiles Ladybug extensions, supports LBUG_DIR environment variable
+# apk add --no-cache openssl openssl-dev
+
+# Fail fast on any error. Without this, a failed `cmake --build` would let the
+# script continue and print "All extensions copied" even though nothing was
+# produced, making CI silently report success while committing nothing.
+set -e
+
+APP_ROOT_DIR=$(cd $(dirname "${BASH_SOURCE[0]}")/..; pwd)
+# Upstream @ladybugdb/core@0.15.x no longer ships lbug-source/ in the tarball;
+# CI clones the source separately and passes LBUG_SOURCE_DIR. Fall back to the
+# old in-node_modules path for local dev against older cores.
+LBUG_SOURCE_DIR="${LBUG_SOURCE_DIR:-$APP_ROOT_DIR/node_modules/@ladybugdb/core/lbug-source}"
+EXTENSION_DIR="${LBUG_SOURCE_DIR}/extension"
+
+
+SYSTEM="$(uname -o)"
+if [ "$SYSTEM" = "Msys" ]; then
+    export MSYS2_ARG_CONV_EXCL="*"
+    echo "Msys"
+    APP_ROOT_DIR="$(cygpath -w $APP_ROOT_DIR)"
+    LBUG_SOURCE_DIR="$(cygpath -w $LBUG_SOURCE_DIR)"
+    EXTENSION_DIR="$(cygpath -w $EXTENSION_DIR)"
+fi
+
+# Architecture detection (moved above the cache check so $EXTENSION_DIST_DIR
+# can be computed before deciding whether to skip the build).
+ARCH=$(uname -m)
+if [ "$ARCH" = "x86_64" ]; then
+    echo "Detected x86_64 architecture"
+    ARCH="amd64"
+elif [ "$ARCH" = "aarch64" ]; then
+    echo "Detected aarch64 architecture"
+    ARCH="arm64"
+else
+    echo "Unsupported architecture: $ARCH"
+    exit 1
+fi
+EXTENSION_DIST_DIR="${EXTENSION_OUTPUT_DIR:-$APP_ROOT_DIR/extensions/alpine-$ARCH}"
+VERSION_FILE="$APP_ROOT_DIR/extensions/version"
+CORE_PKG_JSON="$APP_ROOT_DIR/node_modules/@ladybugdb/core/package.json"
+
+# Cache check: if extensions/version matches the target @ladybugdb/core
+# version and $EXTENSION_DIST_DIR already contains at least one built
+# artifact, skip the 4-8 minute cmake build. Set LBUG_FORCE_REBUILD=1 to
+# bypass.
+if [ "${LBUG_FORCE_REBUILD:-0}" != "1" ] \
+    && [ -d "$EXTENSION_DIST_DIR" ] \
+    && [ -f "$VERSION_FILE" ] \
+    && [ -f "$CORE_PKG_JSON" ]; then
+    cached_ver=$(head -n 1 "$VERSION_FILE" | tr -d '[:space:]')
+    target_ver=$(node -p "require('$CORE_PKG_JSON').version")
+    existing=$(find "$EXTENSION_DIST_DIR" -maxdepth 1 -type f \( -name "*.lbug_extension" -o -name "*.kuzu_extension" \) 2>/dev/null | wc -l)
+    if [ "$cached_ver" = "$target_ver" ] && [ "$existing" -gt 0 ]; then
+        echo "Cache hit: $existing extension artifact(s) in $EXTENSION_DIST_DIR for v$target_ver, skipping rebuild."
+        exit 0
+    fi
+    echo "Cache miss (extensions/version=$cached_ver, target=$target_ver, artifacts=$existing); rebuilding."
+fi
+
+#EXTENSION_LIST="$(find "${EXTENSION_DIR}" -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | grep -v '^duckdb$' | sort | tr '\n' ';' | sed 's/;$//')"
+EXTENSION_LIST="httpfs;json;fts;vector;neo4j;algo"
+echo "Automatically detected extension list: ${EXTENSION_LIST}"
+
+if [ ! -f "${LBUG_SOURCE_DIR}/CMakeLists.txt" ] || [ ! -d "${LBUG_SOURCE_DIR}/extension" ]; then
+    echo "Error: Please run this script in the root directory of the ladybug repository, or set the LBUG_DIR environment variable to point to the ladybug source directory"
+    echo "Current LBUG_SOURCE_DIR: ${LBUG_SOURCE_DIR}"
+    exit 1
+fi
+
+BUILD_DIR="${LBUG_SOURCE_DIR}/build_extensions"
+if [ ! -d "$BUILD_DIR" ]; then
+    mkdir "$BUILD_DIR"
+fi
+
+cd "$BUILD_DIR" || exit 1
+
+# Check if already compiled, if so delete it
+if [ -d "extension" ]; then
+    echo "Detected existing extension directory, deleting..."
+    rm -rf extension
+fi
+
+echo "Configuring CMake to build only extensions..."
+echo "Source directory: ${LBUG_SOURCE_DIR}"
+# BUILD_LBUG=FALSE alone still pulls in tools/shell, whose printer target has
+# a broken include path (upstream cmake doesn't add src/include when shell is
+# built standalone). BUILD_SHELL=FALSE skips it; upstream install.js uses
+# both flags for the nodejs native addon build.
+cmake "${LBUG_SOURCE_DIR}" \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DBUILD_EXTENSIONS="${EXTENSION_LIST}" \
+    -DOPENSSL_CRYPTO_LIBRARY=/usr/lib/libcrypto.so \
+    -DOPENSSL_SSL_LIBRARY=/usr/lib/libssl.so \
+    -DOPENSSL_USE_STATIC_LIBS=OFF \
+    -DBUILD_LBUG=FALSE \
+    -DBUILD_SHELL=FALSE
+
+CORES=$(nproc --all)
+echo "Using $CORES cores for compilation..."
+
+# Use all target for compilation (more generic)
+cmake --build . -- -j"$CORES"
+
+echo "All extensions compiled successfully!"
+
+#check cpu architecture
+ARCH=$(uname -m)
+if [ "$ARCH" = "x86_64" ]; then
+    echo "Detected x86_64 architecture"
+    ARCH="amd64"
+elif [ "$ARCH" = "aarch64" ]; then
+    echo "Detected aarch64 architecture"
+    ARCH="arm64"
+else
+    echo "Unsupported architecture: $ARCH"
+    exit 1
+fi
+
+# Collect the built extensions into an output dir the publish pipeline can
+# pick up. Default to $APP_ROOT_DIR/extensions/alpine-$ARCH.
+EXTENSION_DIST_DIR="${EXTENSION_OUTPUT_DIR:-$APP_ROOT_DIR/extensions/alpine-$ARCH}"
+mkdir -p "$EXTENSION_DIST_DIR"
+
+# Use -name rather than -path with globbing. The prior -path "*/build/*.ext"
+# pattern silently matched zero files under Alpine's busybox find even though
+# the artifacts existed at extension/<name>/build/lib<name>.lbug_extension.
+# -name is simpler and produced the same result set on the test run.
+copied=0
+for ext in $(find "${LBUG_SOURCE_DIR}/extension" -type f \( -name "*.lbug_extension" -o -name "*.kuzu_extension" \)); do
+    cp -f "$ext" "$EXTENSION_DIST_DIR/"
+    echo "Copied: $ext -> $EXTENSION_DIST_DIR/"
+    copied=$((copied + 1))
+done
+
+if [ "$copied" -eq 0 ]; then
+    echo "Error: No .lbug_extension or .kuzu_extension artifacts found under ${LBUG_SOURCE_DIR}/extension. Did the cmake build produce any?" >&2
+    exit 1
+fi
+
+echo "$copied extension artifact(s) have been copied to the $EXTENSION_DIST_DIR directory"

package/util/buildLadybugWithDocker.sh

@@ -42,7 +42,7 @@ run_test() {
     docker run --rm \
         --platform linux/$arch \
         -v "${APP_ROOT_DIR}:/ladybug-lite" \
-        node:18-alpine /bin/sh -c "
+        node:22-alpine /bin/sh -c "
             cd /ladybug-lite && \
             cp -f /ladybug-lite/prebuilt/$node_file /ladybug-lite/lbugjs.node && \
             cd /ladybug-lite/util && \

package/util/buildLbugjsNode.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# Build the native Node.js addon (lbugjs.node) from a Ladybug source checkout
+# and copy the result to OUTPUT_PATH.
+#
+# Inputs (env):
+#   LBUG_SOURCE_DIR  Path to a checkout of github.com/LadybugDB/ladybug (required)
+#   OUTPUT_PATH      Absolute path for the produced .node file (required)
+
+set -euo pipefail
+
+: "${LBUG_SOURCE_DIR:?LBUG_SOURCE_DIR is required}"
+: "${OUTPUT_PATH:?OUTPUT_PATH is required}"
+
+APP_ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.."; pwd)
+CORE_PKG_JSON="$APP_ROOT_DIR/node_modules/@ladybugdb/core/package.json"
+
+# Cache check: if prebuilt/<target> already exists in the repo checkout and
+# prebuilt/version matches the currently-installed @ladybugdb/core version,
+# skip the 15-20 minute compile and just copy the cached binary to the
+# expected OUTPUT_PATH. Lets same-version re-runs (e.g. CI reruns triggered
+# by a sibling job's push) finish in seconds instead of ~20 min.
+# Set LBUG_FORCE_REBUILD=1 to bypass.
+CACHED_BIN="$APP_ROOT_DIR/prebuilt/$(basename "$OUTPUT_PATH")"
+VERSION_FILE="$APP_ROOT_DIR/prebuilt/version"
+if [ "${LBUG_FORCE_REBUILD:-0}" != "1" ] \
+    && [ -f "$CACHED_BIN" ] \
+    && [ -f "$VERSION_FILE" ] \
+    && [ -f "$CORE_PKG_JSON" ]; then
+    cached_ver=$(head -n 1 "$VERSION_FILE" | tr -d '[:space:]')
+    target_ver=$(node -p "require('$CORE_PKG_JSON').version")
+    if [ "$cached_ver" = "$target_ver" ]; then
+        echo "Cache hit: $CACHED_BIN already built for v$target_ver, skipping compile."
+        mkdir -p "$(dirname "$OUTPUT_PATH")"
+        cp -f "$CACHED_BIN" "$OUTPUT_PATH"
+        echo "Copied cached binary -> $OUTPUT_PATH"
+        exit 0
+    fi
+    echo "Cache miss (prebuilt/version=$cached_ver, target=$target_ver); rebuilding."
+fi
+
+NODEJS_API_DIR="$LBUG_SOURCE_DIR/tools/nodejs_api"
+
+if [ ! -d "$NODEJS_API_DIR" ]; then
+    echo "Error: $NODEJS_API_DIR not found. Is LBUG_SOURCE_DIR a valid ladybug checkout?" >&2
+    exit 1
+fi
+
+# tools/nodejs_api is a git submodule upstream. If the clone forgot
+# --recurse-submodules the directory exists but is empty, and yarn silently
+# walks up the tree to the repo-root package.json, running the wrong scripts.
+# Refuse to proceed.
+if [ ! -f "$NODEJS_API_DIR/package.json" ]; then
+    echo "Error: $NODEJS_API_DIR/package.json missing. Did the submodule fail to init? Try re-running with 'git submodule update --init --recursive' in $LBUG_SOURCE_DIR." >&2
+    exit 1
+fi
+
+cd "$NODEJS_API_DIR"
+yarn install
+yarn build
+
+BUILT_NODE="$NODEJS_API_DIR/build/lbugjs.node"
+if [ ! -f "$BUILT_NODE" ]; then
+    echo "Error: build did not produce $BUILT_NODE" >&2
+    exit 1
+fi
+
+mkdir -p "$(dirname "$OUTPUT_PATH")"
+cp -f "$BUILT_NODE" "$OUTPUT_PATH"
+echo "Wrote $OUTPUT_PATH"
+file "$OUTPUT_PATH" || true

package/util/cloneLbugSource.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# Clone the upstream LadybugDB/ladybug repo at the tag matching the installed
+# @ladybugdb/core version, with selective submodule initialization.
+#
+# Upstream has 8 submodules (extension, benchmark, dataset, tools/{java,
+# nodejs,python,rust,wasm}_api); each CI job only needs 1. Cloning all eight
+# shallow clones wastes bandwidth and, in the macOS-native job, looked like a
+# 6h hang. Inspect lbug-src/.gitmodules for the full list.
+#
+# Inputs (env):
+#   LBUG_SOURCE_DIR   Destination directory (default: $APP_ROOT_DIR/lbug-src)
+#   LBUG_SUBMODULES   Which submodules to init, space-separated. Controls
+#                     submodule selection:
+#                       unset → recurse ALL submodules (local-dev default)
+#                       ""    → no submodules (main repo only)
+#                       "extension"           → only extension/
+#                       "tools/nodejs_api"    → only tools/nodejs_api
+#   LBUG_REPO_URL         Override upstream repo URL (default:
+#                         https://github.com/LadybugDB/ladybug.git)
+#   LBUG_SHALLOW_SUBMODULES  1 (default) to shallow-clone submodules, 0 for full.
+
+set -euo pipefail
+
+APP_ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.."; pwd)
+LBUG_SOURCE_DIR="${LBUG_SOURCE_DIR:-$APP_ROOT_DIR/lbug-src}"
+CORE_PKG_JSON="$APP_ROOT_DIR/node_modules/@ladybugdb/core/package.json"
+REPO_URL="${LBUG_REPO_URL:-https://github.com/LadybugDB/ladybug.git}"
+SHALLOW_SUBMODULES="${LBUG_SHALLOW_SUBMODULES:-1}"
+
+if [ ! -f "$CORE_PKG_JSON" ]; then
+    echo "Error: $CORE_PKG_JSON not found. Run 'yarn add @ladybugdb/core' first." >&2
+    exit 1
+fi
+
+VER=$(node -p "require('$CORE_PKG_JSON').version")
+TAG="v${VER}"
+
+if [ -d "$LBUG_SOURCE_DIR/.git" ]; then
+    echo "LBUG_SOURCE_DIR already exists at $LBUG_SOURCE_DIR; skipping clone."
+    exit 0
+fi
+
+shallow_args=()
+if [ "$SHALLOW_SUBMODULES" = "1" ]; then
+    shallow_args=(--shallow-submodules)
+fi
+
+if [ -z "${LBUG_SUBMODULES+x}" ]; then
+    # Unset: recurse all submodules (convenient for local dev).
+    echo "Cloning $REPO_URL @ $TAG with ALL submodules -> $LBUG_SOURCE_DIR"
+    git clone --depth 1 --branch "$TAG" --recurse-submodules "${shallow_args[@]}" "$REPO_URL" "$LBUG_SOURCE_DIR"
+    exit 0
+fi
+
+# Set (possibly empty): clone main repo, then selectively init.
+echo "Cloning $REPO_URL @ $TAG (main repo only) -> $LBUG_SOURCE_DIR"
+git clone --depth 1 --branch "$TAG" "$REPO_URL" "$LBUG_SOURCE_DIR"
+
+if [ -z "$LBUG_SUBMODULES" ]; then
+    echo "LBUG_SUBMODULES is empty; skipping submodule init."
+    exit 0
+fi
+
+submodule_shallow=()
+if [ "$SHALLOW_SUBMODULES" = "1" ]; then
+    submodule_shallow=(--depth 1)
+fi
+
+# Split on whitespace to feed multiple paths; --recursive handles nested
+# submodules inside the selected ones.
+# shellcheck disable=SC2086
+(
+    cd "$LBUG_SOURCE_DIR"
+    echo "Initializing submodules: $LBUG_SUBMODULES"
+    git submodule update --init --recursive "${submodule_shallow[@]}" -- $LBUG_SUBMODULES
+)

package/util/dev.md

@@ -301,9 +301,9 @@ There are three workflows in [`.github/workflows/`](../.github/workflows/):
 
 | Workflow | Trigger | What it does |
 | --- | --- | --- |
-| [`build.yaml`](../.github/workflows/build.yaml) | push / PR to `release`, manual | Matrix `{amd64, arm64}` on Ubuntu runners. Builds Alpine `.node` inside `node:18-alpine` container, copies to `prebuilt/`, runs `util/test.js` smoke test in Alpine, commits `prebuilt/*.node + *.js + package.json` to the release branch, tags with the upstream version (`0.15.3` etc.), publishes via `yarn build`. |
-| [`buildMacOsIntel.yaml`](../.github/workflows/buildMacOsIntel.yaml) | push / PR to `release`, manual | Single job on `macos-26-intel`. Compiles `lbug-source/tools/nodejs_api` from source (upstream ships no darwin-x64), copies the result to `prebuilt/lbugjs-darwin-x64.node`, runs `util/test.js` natively, commits/tags/publishes the same way `build.yaml` does. Races with `build.yaml` on push/tag — the `merge -X ours` strategy and `npm publish` no-op-on-existing handle this safely. |
-| [`buildExtension.yaml`](../.github/workflows/buildExtension.yaml) | push / PR to `release`, manual | Matrix `{amd64, arm64}`. Runs `util/buildLadybugExtensions.sh` inside `node:18-alpine`, force-pushes the resulting `extensions/*/*.lbug_extension` files. |
+| [`build.yaml`](../.github/workflows/build.yaml) | push / PR to `release`, manual | Matrix `{amd64, arm64}` on Ubuntu runners. Builds Alpine `.node` inside `node:22-alpine` container, copies to `prebuilt/`, runs `util/test.js` smoke test in Alpine, commits `prebuilt/*.node + *.js + package.json` to the release branch, tags with the upstream version (`0.15.3` etc.), publishes via `yarn build`. |
+| [`buildMacOsIntel.yaml`](../.github/workflows/buildMacOsIntel.yaml) | push / PR to `release`, manual | Single job on `macos-26-intel`. Compiles `tools/nodejs_api` from source (upstream ships no darwin-amd64/x64 prebuilt), copies the result to `prebuilt/lbugjs-darwin-amd64.node`, runs `util/test.js` natively, commits/tags/publishes the same way `build.yaml` does. Races with `build.yaml` on push/tag — the `merge -X ours` strategy and `npm publish` no-op-on-existing handle this safely. |
+| [`buildExtension.yaml`](../.github/workflows/buildExtension.yaml) | push / PR to `release`, manual | Matrix `{amd64, arm64}`. Runs `util/buildLadybugExtensions.sh` inside `node:22-alpine`, force-pushes the resulting `extensions/*/*.lbug_extension` files. |
 | [`daily.yaml`](../.github/workflows/daily.yaml) | cron `0 0 * * *` | Compares `npm view @ladybugdb/core version` vs `npm view @kineviz/ladybug-lite version`. If upstream is newer, opens an issue and triggers `build.yaml` via `workflow_dispatch`. **Note:** does not currently dispatch `buildMacOsIntel.yaml` — Intel Mac binaries piggyback on the next manual or PR-triggered run. |
 
 So the **normal release cadence** is: upstream bumps → `daily.yaml` notices →
@@ -332,21 +332,24 @@ runtime and want to avoid rewriting the repo root.
 
 | File | Built by | Notes |
 | --- | --- | --- |
-| `lbugjs-linux-x64.node` | upstream `@ladybugdb/core` | Copied from `node_modules/@ladybugdb/core/prebuilt/` |
-| `lbugjs-linux-arm64.node` | upstream | same |
+All `-amd64` filenames cover x86_64 / Node's `x64` arch; the `amd64` spelling
+is canonical throughout this repo (install.js, copy.js, and build.js all
+normalize Node's `x64` to `amd64` before path lookups).
+
+| File | Built by | Notes |
+| --- | --- | --- |
+| `lbugjs-linux-amd64.node` | upstream `@ladybugdb/core` sub-package `core-linux-x64` | Copied from `node_modules/@ladybugdb/core-linux-x64/`, renamed `-x64` → `-amd64` by `build.js` |
+| `lbugjs-linux-arm64.node` | upstream | same, no rename needed |
 | `lbugjs-darwin-arm64.node` | upstream | Apple Silicon |
-| `lbugjs-darwin-x64.node` | **us** (`buildMacOsIntel.yaml`, `macos-26-intel` runner) | Built from source; upstream does not ship Intel Mac for 0.15.x |
-| `lbugjs-win32-x64.node` | upstream | |
+| `lbugjs-darwin-amd64.node` | **us** (`buildMacOsIntel.yaml`, `macos-26-intel` runner) | Built from source; upstream does not ship Intel Mac for 0.15.x |
+| `lbugjs-win32-amd64.node` | upstream | same rename as linux |
 | `lbugjs-alpine-amd64.node` | **us** (`buildLadybugWithDocker.sh` / `build.yaml`) | musl libc |
 | `lbugjs-alpine-arm64.node` | **us** | musl libc |
 
-**Time-bounded support:** `darwin-x64` (Intel Mac) depends on the
+**Time-bounded support:** Intel Mac (`darwin-amd64`) depends on the
 `macos-26-intel` GitHub-hosted runner, which Apple/GitHub will retire in
 Fall 2027. After that, Intel Mac users must build from source locally.
 
-The naming inconsistency between `linux-x64` (Node arch) and `alpine-amd64`
-(Docker arch) is historical and is normalized by `install.js` — see §5.2.
-
 ---
 
 ## 8. Engine extensions