crossbind 2.0.0-beta.62 → 2.0.0-beta.63

package/src/utils/swigInterface.js

@@ -16,6 +16,29 @@ export function findIgnoredDeclarations(headerFile, configs, headerPath) {
     return findHeaderOption('ignoredDeclarations', headerFile, configs, headerPath);
 }
 
+// SWIG preprocessor lines a package puts right before one of its public headers, in export.swigPreamble: GDAL hides
+// its C SRS API behind `#ifndef SWIG` for its own bindings, and picks VSIStatBufL's typedef by whether VSI_STAT64_T is
+// defined, which a macro defined as itself answers while each platform's compiler still resolves the name.
+export function findSwigPreamble(headerFile, configs, headerPath) {
+    return findHeaderOption('swigPreamble', headerFile, configs, headerPath);
+}
+
+// Includes SWIG reads inlined into one of a package's headers, in export.swigInlineIncludes. SWIG reads no #include, and
+// libgeotiff fills its key and code enums from .inc files included inside the enum bodies, where the file markers
+// -includeall wraps around an included file do not parse.
+export function findSwigInlineIncludes(headerFile, configs, headerPath) {
+    return findHeaderOption('swigInlineIncludes', headerFile, configs, headerPath);
+}
+
+const INCLUDE_LINE = /^[ \t]*#[ \t]*include[ \t]*"([^"]+)"[^\n]*$/gm;
+
+export function inlineIncludes(headerText, names, readInclude) {
+    const included = new Set([...headerText.matchAll(INCLUDE_LINE)].map(([, name]) => name));
+    const missing = names.filter((name) => !included.has(name));
+    if (missing.length) throw new Error(`crossbind: swigInlineIncludes lists ${missing.join(', ')}, which the header does not include.`);
+    return headerText.replace(INCLUDE_LINE, (line, name) => (names.includes(name) ? readInclude(name) : line));
+}
+
 function findHeaderOption(option, headerFile, configs, headerPath) {
     const file = upath.normalize(headerFile);
     let owner = null;
@@ -40,26 +63,35 @@ export function interfaceIncludes(headerPath, prelude = []) {
 
 // The prelude and the completing includes reach only the compiled wrapper and swigMacros only SWIG's parse: SWIG still
 // wraps just the imported header. The ignored declarations follow the macros, so the retry without macros keeps them.
-export function buildInterfaceContent({ moduleName, headerPath, prelude = [], completing = [], swigMacros = [], ignored = [], constants = [] }) {
+export function buildInterfaceContent({
+    moduleName, headerPath, prelude = [], completing = [], swigMacros = [], ignored = [], constants = [], preamble = [], functions = ALL_NAMES,
+    extras = [],
+}) {
     const includes = [...new Set([...interfaceIncludes(headerPath, prelude), ...completing])]
         .map((header) => `#include "${header}"`)
         .join('\n');
     const macros = swigMacros.length ? `${swigMacros.join('\n')}\n\n` : '';
     const ignores = ignored.length ? `${ignored.map((name) => `%ignore ${name};`).join('\n')}\n\n` : '';
+    // The marker keeps a preamble that starts with #define apart from the macro block the retry drops.
+    const preambleBlock = preamble.length ? `// package preamble\n${preamble.join('\n')}\n\n` : '';
+    const extraBlock = extras.length ? `${extras.join('\n')}\n\n` : '';
+    // Named constants are asked for ahead of the macros, which may define one. Every constant is asked for after them:
+    // SWIG binds an interface's own #define lines, and the prelude only carries other headers' values for the parse.
+    const everyConstant = constants === ALL_NAMES;
     const module = moduleName.replace(/\W/g, '_');
     return `#ifndef _${module}_I
 #define _${module}_I
 
 %module ${module}
 
-%{
+${extraBlock}%{
 ${includes}
 %}
 
-${constantRequests(constants)}%feature("shared_ptr");
+${everyConstant ? '' : constantRequests(constants)}%feature("shared_ptr");
 %feature("polymorphic_shared_ptr");
 
-${macros}${ignores}%include "${headerPath}"
+${macros}${functionRequests(functions)}${ignores}${preambleBlock}${everyConstant ? constantRequests(constants) : ''}%include "${headerPath}"
 
 #endif
 `;
@@ -71,6 +103,19 @@ function constantRequests(constants) {
     return constants.length ? `${constants.map((name) => `%feature("embind:constant") ${name};`).join('\n')}\n\n` : '';
 }
 
+// SWIG ignores every global function, then wraps the listed names again: class members, enums and constants stay. The
+// package's own ignores come after, since SWIG applies the later of two renames of a name.
+function functionRequests(functions) {
+    if (functions === ALL_NAMES) return '';
+    const names = [...new Set(functions)].sort();
+    return `%rename($ignore, %$isfunction, %$isglobal) "";\n${names.map((name) => `%rename("%s") ${name};\n`).join('')}\n`;
+}
+
+// Editor declarations need the whole header even when the compiled bridge selects functions by import.
+export function interfaceWithAllFunctions(content) {
+    return content.replace(/%rename\(\$ignore, %\$isfunction, %\$isglobal\) "";\n(?:%rename\("%s"\) [A-Za-z_]\w*;\n)*\n/g, '');
+}
+
 export function withoutSwigMacros(content) {
     return content.replace(/(%feature\("polymorphic_shared_ptr"\);\n\n)(?:#define [^\n]*\n)+\n/, '$1');
 }
@@ -333,6 +378,26 @@ function walkScopes(text, visit) {
     });
 }
 
+// Whether the token at `index` sits inside the parentheses of the declaration it belongs to: a prototype's parameter.
+function isInsideParentheses(tokens, index) {
+    let depth = 0;
+    for (let at = index - 1; at >= 0 && ![';', '{', '}'].includes(tokens[at]); at -= 1) {
+        if (tokens[at] === '(') depth += 1;
+        else if (tokens[at] === ')') depth -= 1;
+    }
+    return depth > 0;
+}
+
+// Whether a variable `name` is declared outside every class, namespace and block, as `extern int name;` is.
+export function declaresAtFileScope(text, name) {
+    let found = false;
+    walkScopes(text, (token, index, tokens, scopes) => {
+        if (token === name && scopes.every((scope) => scope.kind === 'extern') && [';', '=', '[', ','].includes(tokens[index + 1])
+            && !isInsideParentheses(tokens, index)) found = true;
+    });
+    return found;
+}
+
 // Classes, structs and enums by qualified name, including the names C typedefs give them, each mapped to the first header
 // defining it. Preprocessor branches are all read.
 export function indexTypeDefinitions(files) {

package/src/utils/systemKeys.js

@@ -4,12 +4,36 @@ const systemKeys = {
         default: '',
     },
     RUNNER: {
-        description: 'The execution environment for running the application.',
-        options: ['DOCKER_RUN', 'DOCKER_EXEC', 'LOCAL'],
+        description: 'Where toolchain steps run: DOCKER_RUN, DOCKER_EXEC, LOCAL, or REMOTE on the runners REMOTE_URL and REMOTE_URL_<IMAGE> name; a machine that names none builds on crossbind cloud once signed in with crossbind login. The CROSSBIND_RUNNER environment variable overrides it.',
+        options: ['DOCKER_RUN', 'DOCKER_EXEC', 'LOCAL', 'REMOTE'],
         default: 'DOCKER_RUN',
     },
+    REMOTE_URL: {
+        description: 'Under RUNNER=REMOTE, the runner of every image without an address of its own. Its token comes from the CROSSBIND_TOKEN environment variable. The CROSSBIND_REMOTE_URL environment variable overrides it.',
+        default: '',
+    },
+    REMOTE_URL_WEB: {
+        description: 'Under RUNNER=REMOTE, the runner of the web image: wasm builds, wasi builds and the bridge steps of every platform but android. Token: CROSSBIND_TOKEN_WEB. The CROSSBIND_REMOTE_URL_WEB environment variable overrides it.',
+        default: '',
+    },
+    REMOTE_URL_ANDROID: {
+        description: 'Under RUNNER=REMOTE, the runner of the android image. Token: CROSSBIND_TOKEN_ANDROID. The CROSSBIND_REMOTE_URL_ANDROID environment variable overrides it.',
+        default: '',
+    },
+    REMOTE_URL_LINUX: {
+        description: 'Under RUNNER=REMOTE, the runner of the linux image (linux and linuxmusl builds). Token: CROSSBIND_TOKEN_LINUX. The CROSSBIND_REMOTE_URL_LINUX environment variable overrides it.',
+        default: '',
+    },
+    REMOTE_URL_WINDOWS: {
+        description: 'Under RUNNER=REMOTE, the runner of the windows image (win32 builds). Token: CROSSBIND_TOKEN_WINDOWS. The CROSSBIND_REMOTE_URL_WINDOWS environment variable overrides it.',
+        default: '',
+    },
+    CLOUD_URL: {
+        description: 'The crossbind cloud that crossbind login, logout and usage talk to. The CROSSBIND_CLOUD_URL environment variable overrides it.',
+        default: 'https://api.crossbind.dev',
+    },
     WASI_SDK_PATH: {
-        description: 'Path to an extracted wasi-sdk (>= 34, wasm32-wasip3 sysroot) used by platform:\'wasi\' builds. The CROSSBIND_WASI_SDK_PATH environment variable overrides it.',
+        description: 'Path to an extracted wasi-sdk (>= 34, wasm32-wasip3 sysroot) that platform:\'wasi\' builds use under RUNNER=LOCAL; the other runners use the sdk in the image. The CROSSBIND_WASI_SDK_PATH environment variable overrides it.',
         default: '',
     },
     DOCKER_REGISTRY_MIRROR: {
@@ -35,3 +59,11 @@ const systemKeys = {
 };
 
 export default systemKeys;
+
+// Read as LOCAL, a runner crossbind does not know would run recipes and build scripts on the host.
+export function assertRunner(runner, name = 'RUNNER') {
+    if (!systemKeys.RUNNER.options.includes(runner)) {
+        throw new Error(`crossbind: the runner ${runner} is invalid; ${name} is one of ${systemKeys.RUNNER.options.join(', ')}.`);
+    }
+    return runner;
+}

package/src/utils/targets.js

@@ -1,7 +1,7 @@
 // Single source for the build-target matrix and its naming; state/ copies (and then
 // decorates) these entries, and consumer runtimes read them without touching CLI state.
 
-export const TARGETS = [
+const BASE_TARGETS = [
     {
         platform: 'wasm', arch: 'wasm32', runtime: 'st', buildType: 'release', runtimeEnv: 'browser',
     },
@@ -63,10 +63,10 @@ export const TARGETS = [
         platform: 'wasm', arch: 'wasm64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
     },
     {
-        platform: 'wasi', arch: 'wasm32', runtime: 'st', buildType: 'release',
+        platform: 'wasi', arch: 'wasm32', runtime: 'st', buildType: 'release', runtimeEnv: 'wasi',
     },
     {
-        platform: 'wasi', arch: 'wasm32', runtime: 'st', buildType: 'debug',
+        platform: 'wasi', arch: 'wasm32', runtime: 'st', buildType: 'debug', runtimeEnv: 'wasi',
     },
     {
         platform: 'android', arch: 'arm64-v8a', runtime: 'mt', buildType: 'release',
@@ -116,6 +116,18 @@ export const TARGETS = [
     {
         platform: 'linux', arch: 'x64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
     },
+    {
+        platform: 'linuxmusl', arch: 'arm64', runtime: 'mt', buildType: 'release', runtimeEnv: 'node',
+    },
+    {
+        platform: 'linuxmusl', arch: 'arm64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
+    },
+    {
+        platform: 'linuxmusl', arch: 'x64', runtime: 'mt', buildType: 'release', runtimeEnv: 'node',
+    },
+    {
+        platform: 'linuxmusl', arch: 'x64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
+    },
     {
         platform: 'win32', arch: 'arm64', runtime: 'mt', buildType: 'release', runtimeEnv: 'node',
     },
@@ -130,17 +142,43 @@ export const TARGETS = [
     },
 ];
 
+// A native executable links the same archives as the Node-API addon of its platform and arch.
+export const TARGETS = [
+    ...BASE_TARGETS,
+    ...BASE_TARGETS
+        .filter((target) => target.runtimeEnv === 'node' && target.platform !== 'wasm')
+        .map((target) => ({ ...target, runtimeEnv: 'native' })),
+];
+
 // Built only when named with -p: a plain `crossbind build` keeps producing what it did before
 // native Node.js addons existed.
-export const OPT_IN_PLATFORMS = ['darwin', 'linux', 'win32'];
+export const OPT_IN_PLATFORMS = ['darwin', 'linux', 'linuxmusl', 'win32'];
 
 // Built on the host itself: Apple's linker and SDKs exist in no toolchain image.
 export const HOST_BUILT_PLATFORMS = ['ios', 'darwin'];
 
+// The runtime environment names the binary a build makes; android and ios have none, since
+// React Native links them.
+export const runtimeEnvsOf = (platform) => [
+    ...new Set(TARGETS.filter((target) => target.platform === platform && target.runtimeEnv).map((target) => target.runtimeEnv)),
+];
+
+export const RUNTIME_ENVS = [...new Set(TARGETS.map((target) => target.runtimeEnv).filter(Boolean))];
+
+// A build makes only the binaries it is asked for: -e first, then the config's target.runtimeEnv.
+// Bundler plugins ask through getTargetParams instead.
+export function selectRuntimeEnvs(cliRuntimeEnvs, configRuntimeEnv) {
+    if (cliRuntimeEnvs?.length) return cliRuntimeEnvs;
+    return configRuntimeEnv ? [configRuntimeEnv] : [];
+}
+
 export function targetPathOf(target) {
     return `${target.platform}-${target.arch}-${target.runtime}-${target.buildType}`;
 }
 
+// The release build of a target, whose prebuilts a debug build of it falls back to.
+export const releaseTargetOf = (target) => ({ ...target, buildType: 'release', path: target.releasePath });
+
 // Every platform/arch addon of one build type sits next to a single loader, which fills in
 // {platform} and {arch} from the running process. The loader is CommonJS whatever the package
 // "type" says, since it needs __dirname and process.dlopen.
@@ -154,6 +192,13 @@ export function nodeAddonNamesOf(target, projectName) {
     };
 }
 
+// One executable per platform, arch and build type, named like the addons it replaces.
+export function nativeCommandNamesOf(target, projectName) {
+    const suffix = target.buildType === 'debug' ? '.debug' : '';
+    const extension = target.platform === 'win32' ? '.exe' : '';
+    return { commandName: `${projectName}.${target.platform}-${target.arch}${suffix}${extension}` };
+}
+
 export function filterTargetSpecs(targetSpecs, target) {
     return targetSpecs?.filter(t => (
         (!t.platform || t.platform === target.platform)

package/src/utils/toolchainNotices.js

@@ -0,0 +1,5 @@
+// Where a build keeps the notices of the runtime a toolchain image linked into its binaries,
+// relative to the build directory; crossbind licenses reads them from there.
+export default function toolchainNoticesDir(platform) {
+    return `toolchain-licenses/${platform}`;
+}

package/src/utils/wasiToolchain.js

@@ -1,5 +1,7 @@
 // Toolchain surface for platform:'wasi' (wasm32-wasip3, wasi-sdk >= 34; run under `wasmtime`).
 
+import { isLocalRunner } from './selectRunner.js';
+
 export const WASI_TARGET_TRIPLE = 'wasm32-wasip3';
 // The sdk's clang still defaults to wasip1, so every compile/link carries --target explicitly.
 export const WASI_TARGET_FLAGS = [`--target=${WASI_TARGET_TRIPLE}`];
@@ -31,6 +33,7 @@ export const WASI_LINK_LIBS = [
     '-lunwind',
     '-lsetjmp',
     ...WASI_EMULATION_LIBS,
+    '-Wl,--wrap=lseek',
 ];
 
 export function wasiCFlags() {
@@ -41,7 +44,17 @@ export function wasiCxxFlags() {
     return [...WASI_TARGET_FLAGS, ...WASI_COMPILE_DEFINES, '-fwasm-exceptions', ...WASI_EH_CFLAGS];
 }
 
-// Env override first, then persistent ~/.crossbind.json; null when unset.
+// The host sdk of a RUNNER=LOCAL build: env override first, then persistent ~/.crossbind.json; null when
+// unset, and under the other runners, whose builds use the sdk in the image.
 export function resolveWasiSdkPath(system, env = process.env) {
+    if (!isLocalRunner(system, env)) return null;
     return env.CROSSBIND_WASI_SDK_PATH || system?.WASI_SDK_PATH || null;
 }
+
+// Recipes read the wasi-sdk location from the environment (lazily, in getBuildParams), so it names
+// the sdk the build uses: the host's under RUNNER=LOCAL, none (the image's) under the other runners.
+export function exportWasiSdkPath(system, env = process.env) {
+    const sdk = resolveWasiSdkPath(system, env);
+    if (sdk) env.CROSSBIND_WASI_SDK_PATH = sdk;
+    else delete env.CROSSBIND_WASI_SDK_PATH;
+}

package/src/utils/windowsToolchain.js

@@ -0,0 +1,18 @@
+// The windows image's llvm-mingw and its CMake toolchain files, one per target triple: port archives and
+// Conan packages link into the same addon, so they move together.
+const LLVM_MINGW = '/opt/llvm-mingw';
+const WINDOWS_TOOLCHAIN = '/opt/crossbind/windows';
+const WINDOWS_TRIPLES = { x64: 'x86_64-w64-mingw32', arm64: 'aarch64-w64-mingw32' };
+
+export const windowsTriple = (target) => WINDOWS_TRIPLES[target.arch];
+export const windowsToolchainFile = (target) => `${WINDOWS_TOOLCHAIN}/${windowsTriple(target)}.cmake`;
+export const windowsTool = (target, name) => `${LLVM_MINGW}/bin/${windowsTriple(target)}-${name}`;
+
+// The compilers, archive and resource tools of the target's triple, by the variables build systems read
+// them from. The image's own .pc files describe its libraries, not the target's, so pkg-config reads none.
+export const windowsBuildEnv = (target) => ({
+    ...Object.fromEntries(Object.entries({
+        CC: 'clang', CXX: 'clang++', AR: 'ar', RANLIB: 'ranlib', NM: 'nm', STRIP: 'strip', RC: 'windres', WINDRES: 'windres',
+    }).map(([variable, tool]) => [variable, windowsTool(target, tool)])),
+    PKG_CONFIG_LIBDIR: '',
+});

package/vitest.config.js

@@ -12,6 +12,17 @@ export default defineConfig({
     test: {
         include: ['test/**/*.test.js'],
         environment: 'node',
+        // A developer's own runner settings must not decide where the tested steps run, and neither must their
+        // crossbind login: no one signs in to a cloud at this address.
+        env: {
+            CROSSBIND_RUNNER: '',
+            CROSSBIND_REMOTE_URL: '',
+            CROSSBIND_REMOTE_URL_WEB: '',
+            CROSSBIND_REMOTE_URL_ANDROID: '',
+            CROSSBIND_REMOTE_URL_LINUX: '',
+            CROSSBIND_REMOTE_URL_WINDOWS: '',
+            CROSSBIND_CLOUD_URL: 'http://127.0.0.1:9',
+        },
         coverage: {
             provider: 'v8',
             reporter: ['text', 'html'],