crossbind 2.0.0-beta.69 → 2.0.0-beta.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crossbind",
-  "version": "2.0.0-beta.69",
+  "version": "2.0.0-beta.72",
   "license": "MIT",
   "homepage": "https://crossbind.dev",
   "repository": {
@@ -34,6 +34,7 @@
     "vitest": "^5.0.1"
   },
   "dependencies": {
+    "@crossbind/extension-conan": "2.0.0-beta.72",
     "@rollup/plugin-commonjs": "^29.0.3",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
@@ -50,7 +51,7 @@
     "upath": "^3.0.8"
   },
   "optionalDependencies": {
-    "@crossbind/bridge-tools": "2.0.0-beta.69"
+    "@crossbind/bridge-tools": "2.0.0-beta.72"
   },
   "keywords": [
     "webassembly",

package/src/actions/addExtension.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { configFileOf, writeExtension } from '../utils/configWriter.js';
 import { isUnderBase } from '../utils/replaceBasePathForDocker.js';
 import { ownPackages } from '../utils/appExtensions.js';
+import { packagesOfCrossbind } from '../utils/packageSources.js';
 import resolveAppHostRoot from '../utils/resolveAppHost.js';
 
 // The lockfiles by which a project names the package manager it is installed with.
@@ -108,9 +109,13 @@ function assertSpec(spec, platform) {
     }
 }
 
-// An extension an app has by having the host is none to add. A project without a host yet has none of them.
+// An extension a project has by having crossbind, or an app by having the host, is none to add. A project without a
+// host yet has none of the host's.
 function assertNotOwn(spec) {
     const name = registryName(spec);
+    if (packagesOfCrossbind().includes(name)) {
+        throw new Error(`crossbind: every project has ${name} by having crossbind, which brings it, so there is nothing to add.`);
+    }
     let root;
     try {
         root = resolveAppHostRoot();

package/src/actions/buildApp.js

@@ -29,8 +29,8 @@ import findFiles from '../utils/findFiles.js';
 import { getContentHash, getFilesFingerprint } from '../utils/hash.js';
 import { xmlPlist } from '../utils/plist.js';
 import {
-    androidAppId, appBackgroundColor, appCategory, appCopyright, appDisplayName, appEncryption, appFiles, appHeader, appId, appPermissions, appPrivacy,
-    appUrlSchemes, iosAppGroup, iosMultipleWindows, urlSchemeOwners, usageDescriptions,
+    androidAppId, appBackgroundColor, appCategory, appCopyright, appDarkBackgroundColor, appDisplayName, appEncryption, appFiles, appHeader, appId,
+    appPermissions, appPrivacy, appUrlSchemes, iosAppGroup, iosMultipleWindows, urlSchemeOwners, usageDescriptions,
 } from '../utils/appOptions.js';
 import { carriedFilesOf, copyCarriedFiles } from '../utils/appFiles.js';
 import { activityTypeOwners, fileTypeOwners, linkOwners, macDocumentTypes, shortcutItemOwners } from '../utils/appLaunches.js';
@@ -381,6 +381,10 @@ const shippedFiles = () => new Set(Object.values(readAppOutputs()).filter(Array.
 // The command line's names of the desktop platforms.
 export const DESKTOP_PLATFORMS = { darwin: 'macos', linux: 'linux', win32: 'windows' };
 
+// The platform an app is built for, which its page reads as import.meta.env.CROSSBIND_APP_PLATFORM: CROSSBIND_APP_PLATFORM,
+// else this machine's desktop.
+export const appPlatform = (env = process.env) => env.CROSSBIND_APP_PLATFORM || DESKTOP_PLATFORMS[process.platform];
+
 // Forgets what the builds wrote, as a publish's own build writes it anew, but for the installers' files, which a folder the
 // bundler kept holds still, for the page to leave out.
 export function clearAppOutputs() {
@@ -441,8 +445,8 @@ export function publishApp(target, { to = appOutputPath(target), page = null } =
             build: build === null ? appVersion() : String(build), icon: icon && iosIcon(icon), urlSchemes: appUrlSchemes(state.config),
             fileTypes: fileTypeOwners(state.config), links: linkOwners(state.config).map(({ link }) => link),
             activityTypes: activityTypeOwners(state.config).map(({ type }) => type), shortcutItems: shortcutItemOwners(state.config),
-            background: appBackgroundColor(state.config), usage: usageDescriptions(state.config, 'ios'), encryption: appEncryption(state.config),
-            multipleWindows: iosMultipleWindows(state.config),
+            background: appBackgroundColor(state.config), darkBackground: appDarkBackgroundColor(state.config), usage: usageDescriptions(state.config, 'ios'),
+            encryption: appEncryption(state.config), multipleWindows: iosMultipleWindows(state.config),
         };
         const extensions = extensionsOf('ios');
         const privacy = mergedPrivacy(ownPrivacy, extensions.privacy);
@@ -455,7 +459,8 @@ export function publishApp(target, { to = appOutputPath(target), page = null } =
         const icon = readAppIcon(state.config);
         const options = {
             parts: appParts(target), id: androidAppId(state.config), label: appDisplayName(state.config), version: androidVersion(), icons: icon && androidIcons(icon),
-            urlSchemes: appUrlSchemes(state.config), background: appBackgroundColor(state.config), permissions: Object.keys(appPermissions(state.config)),
+            urlSchemes: appUrlSchemes(state.config), background: appBackgroundColor(state.config), darkBackground: appDarkBackgroundColor(state.config),
+            permissions: Object.keys(appPermissions(state.config)),
             fileTypes: fileTypeOwners(state.config), links: linkOwners(state.config).map(({ link }) => link), shortcutItems: shortcutItemOwners(state.config),
         };
         const extensions = extensionsOf('android');

package/src/actions/buildDependencies.js

@@ -14,7 +14,7 @@ import {
 } from '../utils/dependencyRebuild.js';
 import withDirLock from '../utils/dirLock.js';
 import { prepareRustSysroot } from '../utils/rustSysroot.js';
-import prepareConanDependencies from './prepareConanDependencies.js';
+import preparePackageSources from './preparePackageSources.js';
 import getAbsolutePath from '../utils/getAbsolutePath.js';
 import getCMakeListsFilePath from '../utils/getCMakeListsFilePath.js';
 import getParentPath from '../utils/getParentPath.js';
@@ -26,7 +26,7 @@ export default async function buildDependencies({ targetParams, rebuildOption })
     // sync cargo work downstream reads what it resolves. A project with nothing to rebuild still
     // needs its sysroot.
     await prepareRustSysroot(getBuildTargets(targetParams));
-    await prepareConanDependencies(getBuildTargets(targetParams));
+    await preparePackageSources(getBuildTargets(targetParams));
     await buildMissingCargoDependencies(getBuildTargets(targetParams), targetParams);
 
     const rebuildDeps = getRebuildDeps(state.config.allDependencies, rebuildOption);
@@ -78,7 +78,7 @@ async function buildMissingCargoDependencies(buildTargets, targetParams) {
     const appConfig = state.config;
     const cargoDependencies = (appConfig.allDependencies ?? []).filter((dep) => dep !== appConfig && dep.export?.type === 'cargo');
     if (cargoDependencies.length === 0) return;
-    // Bridges read every header for the first wasm target (see prepareConanDependencies), which an app configured for
+    // Bridges read every header for the first wasm target (see preparePackageSources), which an app configured for
     // another wasm runtime does not build: there a dependency built for the app's runtime alone counts as half built.
     const bridgeTarget = buildTargets.some(isWasm) ? state.targets.find(isWasm) : undefined;
     const extraTarget = bridgeTarget && !buildTargets.some((target) => target.path === bridgeTarget.path) ? bridgeTarget : undefined;

package/src/actions/createImportedBridges.js

@@ -5,9 +5,9 @@ import createBridgeFile from './createInterface.js';
 import getDependFilePath from '../integration/getDependFilePath.js';
 import resolveNativeImport from '../integration/resolveNativeImport.js';
 import { getRustSymbols } from '../integration/getCrossbindScript.js';
-import { findNativeImportsIn, nativeSpecifierTest } from '../utils/nativeImports.js';
+import { findNativeImportsIn, nativeSpecifierTest, schemeTest } from '../utils/nativeImports.js';
+import { importSchemesOf } from '../utils/packageSources.js';
 
-const SCHEME = /^(cargo|conan):/;
 const isBare = (specifier) => !specifier.startsWith('.') && !upath.isAbsolute(specifier);
 
 function realPath(file) {
@@ -18,13 +18,13 @@ function realPath(file) {
     }
 }
 
-// The first target whose packages ship the file. A cargo: or conan: import that none resolves fails the build with
-// what to declare or install, as it does in a bundler.
-function resolveImport(specifier, importer, targets) {
+// The first target whose packages ship the file. An import by a scheme, as cargo: and conan: are, that none resolves
+// fails the build with what to declare or install, as it does in a bundler.
+function resolveImport(specifier, importer, targets, hasScheme) {
     let failure = null;
     for (const target of targets) {
         try {
-            const file = SCHEME.test(specifier) ? getDependFilePath(specifier, target) : resolveNativeImport(specifier, importer, target);
+            const file = hasScheme(specifier) ? getDependFilePath(specifier, target) : resolveNativeImport(specifier, importer, target);
             if (file && fs.existsSync(file)) return { target, file };
         } catch (error) {
             failure ??= error;
@@ -47,8 +47,10 @@ export function findAppNativeImports(targets) {
     const projectDir = state.config.paths.project;
     const imports = new Map();
     if (!projectDir || !fs.existsSync(projectDir)) return imports;
-    for (const { importer, specifier } of findNativeImportsIn(projectDir, nativeSpecifierTest(state.config.ext))) {
-        const resolved = resolveImport(specifier, importer, targets);
+    const schemes = importSchemesOf(state.config);
+    const hasScheme = schemeTest(schemes);
+    for (const { importer, specifier } of findNativeImportsIn(projectDir, nativeSpecifierTest(state.config.ext, schemes))) {
+        const resolved = resolveImport(specifier, importer, targets, hasScheme);
         if (!resolved) {
             console.warn(`crossbind: ${upath.relative(projectDir, importer)} imports ${specifier}, which no dependency ships for ${targets.map((t) => t.path).join(', ')}.`);
             continue;

package/src/actions/createInterface.js

@@ -2,9 +2,9 @@
 import fs from 'node:fs';
 import upath from 'upath';
 import state, { saveCache } from '../state/index.js';
-import refreshConanDependencies from '../state/refreshConanDependencies.js';
+import refreshPackageSources from '../state/refreshPackageSources.js';
 import refreshBuiltDependencies from '../state/refreshBuiltDependencies.js';
-import { conanInputsOf } from '../utils/conanDependencies.js';
+import { packageSourceInputsOf, sourceNamesOf } from '../utils/packageSources.js';
 import { getContentHash, getFileHash } from '../utils/hash.js';
 import guardAsyncBindings from '../utils/bridgeAsyncGuard.js';
 import fixBridgeRuntime from '../utils/bridgeRuntimeFixes.js';
@@ -12,7 +12,7 @@ import {
     interfaceExtras, bridgeExtras, hasPointerRuntime, withPointerRuntimeAnchor, withoutBridgeExtras, POINTER_RUNTIME_ANCHOR,
 } from '../utils/bridgeExtras.js';
 import resolveNativeImport from '../integration/resolveNativeImport.js';
-import { writeHeaderDts, writeConanImportDts } from '../utils/cppDts.js';
+import { writeHeaderDts, writeSourceImportDts } from '../utils/cppDts.js';
 import { ALL_NAMES, findHeaderImportsIn } from '../utils/headerImports.js';
 import {
     buildInterfaceContent, completingIncludes, findHeaderPrelude, findIgnoredDeclarations, findSwigInlineIncludes, findSwigPreamble,
@@ -21,7 +21,7 @@ import {
 } from '../utils/swigInterface.js';
 import writeIfChanged from '../utils/writeIfChanged.js';
 import { withDirLockSync } from '../utils/dirLock.js';
-import { conanImportOfHeader } from '../utils/conanImport.js';
+import { sourceImportOfHeader } from '../utils/packageSourceImport.js';
 import run, { cxxPreprocessorFor } from './run.js';
 import isSourceCmakePackage from '../utils/isSourceCmakePackage.js';
 import {
@@ -53,9 +53,9 @@ export default function createBridgeFile(headerOrModuleFilePath, target = state.
 }
 
 function bindHeader(headerOrModuleFilePath, target, { withDependencies = true, wholeHeaders = [] } = {}) {
-    // A header can include a Conan package's headers that a build staged after this process loaded, or belong to a
-    // dependency built since.
-    refreshConanDependencies(state.config);
+    // A header can include the headers of a package source's package that a build staged after this process loaded,
+    // or belong to a dependency built since.
+    refreshPackageSources(state.config);
     refreshBuiltDependencies(state.config);
     // Without bridge-tools on a Mac the macro step would fail quietly, and its interface would be kept without macros.
     if (usesBridgeTools(target)) loadBridgeTools();
@@ -76,7 +76,7 @@ function bindHeader(headerOrModuleFilePath, target, { withDependencies = true, w
     const { headerPath } = includeLocation(interfaceFilePath, target);
     const inlined = findSwigInlineIncludes(interfaceFilePath, [state.config, ...state.config.allDependencies], headerPath);
     const swigView = inlined.length ? writeSwigView(interfaceFilePath, headerPath, inlined) : null;
-    const sourceHash = [getFileHash(interfaceFilePath), ...conanInputsHash()].join('\n');
+    const sourceHash = [getFileHash(interfaceFilePath), ...packageInputsHash()].join('\n');
     // The names imported by name decide what the bridge adds to SWIG's output, so another one makes another bridge.
     const bridgeSourceHash = names.named.length ? `${sourceHash}\nnamed:${names.named.join(',')}` : sourceHash;
     const extras = { named: names.named, headerText: () => fs.readFileSync(swigView ? upath.join(swigView.dir, headerPath) : interfaceFilePath, 'utf8') };
@@ -91,13 +91,14 @@ function bindHeader(headerOrModuleFilePath, target, { withDependencies = true, w
             exportsFile: `${bridgeFile}.exports.json`,
             projectPath: state.config.paths.project,
             cacheDir: state.config.paths.cache,
+            sources: sourceNamesOf(state.config),
             dtsMode: state.config.dts,
         };
         writeHeaderDts(dtsOptions);
-        if (conanImportOfHeader(interfaceFilePath, state.config.paths.cache)) {
-            dtsOptions.declarationsFile = createConanDeclarations(interfaceFile, target, sourceDir, sourceHash, swigView);
+        if (sourceImportOfHeader(interfaceFilePath, dtsOptions.cacheDir, dtsOptions.sources)) {
+            dtsOptions.declarationsFile = createSourceDeclarations(interfaceFile, target, sourceDir, sourceHash, swigView);
         }
-        writeConanImportDts(dtsOptions);
+        writeSourceImportDts(dtsOptions);
     }
     if (bridgeFile && withDependencies && !moduleRegex.test(interfaceFilePath)) {
         // A header's own bindings need the types its declarations use registered, which only their headers' bridges do.
@@ -115,11 +116,11 @@ function bindHeader(headerOrModuleFilePath, target, { withDependencies = true, w
     return bridgeFile;
 }
 
-// The Conan packages a header's includes may reach, for the interface and bridge caches: they are
-// staged after a header may already be bound, and restaged in place for another version.
-function conanInputsHash() {
-    const conan = conanInputsOf(state.config);
-    return conan ? [`conan:${getContentHash(JSON.stringify(conan))}`] : [];
+// The packages of package sources a header's includes may reach, for the interface and bridge caches: they
+// are staged after a header may already be bound, and restaged in place for another version.
+function packageInputsHash() {
+    const inputs = packageSourceInputsOf(state.config);
+    return inputs ? [`packages:${getContentHash(JSON.stringify(inputs))}`] : [];
 }
 
 // A header binds the constants the app imports from it, and so the free functions of a dependency's header: the project's
@@ -159,17 +160,18 @@ function createInterfaceFile(headerOrModuleFilePath, target, sourceDir, { consta
     const filePathWithoutExt = headerOrModuleFilePath.match(/^(.*)\..+?$/)?.[1];
     const interfaceFile = !isModule && filePathWithoutExt ? `${filePathWithoutExt}.i` : null;
     // A prelude or ignored-declaration change in the owning package, a completed class moving to another header, an
-    // interface the package ships beside the header changing or going away, another imported name, or Conan packages
-    // its includes may reach being staged or moving to another version must regenerate the interface as well.
+    // interface the package ships beside the header changing or going away, another imported name, packages of a
+    // package source its includes may reach being staged or moving to another version, or the header included by
+    // another path, as another target finds it, must regenerate the interface as well.
     const fileHash = [
-        INTERFACE_FORMAT, getFileHash(headerOrModuleFilePath), ...prelude,
+        INTERFACE_FORMAT, getFileHash(headerOrModuleFilePath), ...(headerPath ? [`include:${headerPath}`] : []), ...prelude,
         ...(ignored.length ? [`ignored:${ignored.join(',')}`] : []), ...(completing.length ? [`completing:${completing.join(',')}`] : []),
         ...(preamble.length ? [`preamble:${preamble.join('\n')}`] : []),
         ...(interfaceFile && fs.existsSync(interfaceFile) ? [`shipped:${getFileHash(interfaceFile)}`] : []),
         ...(constants.length ? [`constants:${constants === ALL_NAMES ? ALL_NAMES : constants.join(',')}`] : []),
         ...(functions === ALL_NAMES ? [] : [`functions:${functions.join(',')}`]),
         ...(named.length ? [`named:${named.join(',')}`] : []),
-        ...conanInputsHash(),
+        ...packageInputsHash(),
     ].join('\n');
     const cachedInterface = state.cache.interfaces[headerOrModuleFilePath];
     if (state.cache.hashes[headerOrModuleFilePath] === fileHash && cachedInterface && fs.existsSync(cachedInterface)
@@ -517,7 +519,7 @@ function createBridgeFileFromInterfaceFile(interfaceFilePath, target, sourceDir
 }
 
 // Generate a full export catalog for the editor, without compiling or linking these extra functions.
-function createConanDeclarations(interfaceFile, target, sourceDir, sourceHash, swigView) {
+function createSourceDeclarations(interfaceFile, target, sourceDir, sourceHash, swigView) {
     const dir = `${state.config.paths.build}/declarations`;
     fs.mkdirSync(dir, { recursive: true });
     const file = `${dir}/${upath.basename(interfaceFile)}`;

package/src/actions/createLib.js

@@ -16,7 +16,7 @@ import {
 import { getFilesFingerprint, getContentHash } from '../utils/hash.js';
 import { withDependencyBridges } from '../utils/dependencyBridges.js';
 import { targetArchiveFlags } from '../utils/archiveFlags.js';
-import { conanInputsOf } from '../utils/conanDependencies.js';
+import { packageSourceInputsOf } from '../utils/packageSources.js';
 import { nativeSourceStampChanged, writeNativeSourceStamp } from '../utils/nativeSourceStamp.js';
 import resetCMakeCacheForSource from '../utils/resetCMakeCacheForSource.js';
 
@@ -57,10 +57,10 @@ export default function createLib(target, fileType, options = {}) {
     const configEmccFlags = getData('binary', target)?.emccFlags || [];
     const compileOptions = getData('cmake', target)?.compileOptions || [];
     const flagsFingerprintFile = `${libdir}/crossbind-emccflags.fingerprint`;
-    const conanInputs = conanInputsOf(state.config);
+    const packageInputs = packageSourceInputsOf(state.config);
     const compileInputs = compileOptions.length ? { emccFlags: configEmccFlags, compileOptions } : configEmccFlags;
     const flagsInputs = sourceReplacements.length ? { compileInputs, sourceReplacements } : compileInputs;
-    const keyInputs = conanInputs ? [flagsInputs, conanInputs] : flagsInputs;
+    const keyInputs = packageInputs ? [flagsInputs, packageInputs] : flagsInputs;
     // An app's wasi source compiles against <crossbind/http.h>, so a new one misses this cache too.
     const httpHeader = target.platform === 'wasi' && !state.config.build.withBuildConfig
         ? getFilesFingerprint([wasiHttpHeader(state.config.paths.cli)])

package/src/actions/getAllBridges.js

@@ -2,19 +2,34 @@ import fs from 'node:fs';
 import path from 'node:path';
 import findFiles from '../utils/findFiles.js';
 import state from '../state/index.js';
+import { declarationOf, dependenciesOf, sourceImportOfHeader } from '../utils/packageSourceImport.js';
+
+// Why a bridge's header can no longer be included, or null. A package source's stage outlives the declaration, and
+// the source itself, so the header of a package the project no longer declares is still there while its include
+// directory is off the compile. The stage is named by the path, as the project may have dropped the source too.
+function staleReasonOf(header) {
+    if (!fs.existsSync(header)) return 'its header is gone';
+    const { config } = state;
+    const stages = `${config.paths.cache}/`;
+    const [source] = header.startsWith(stages) ? header.slice(stages.length).split('/') : [];
+    const staged = source ? sourceImportOfHeader(header, config.paths.cache, [source]) : null;
+    if (!staged || Object.hasOwn(dependenciesOf(config, source), staged.name)) return null;
+    return `${declarationOf(source)} no longer declares ${staged.name}`;
+}
 
 export default function getAllBridges(log = console.log) {
     return findFiles(`${state.config.paths.build}/bridge/*.i.cpp`).filter((bridge) => {
         // The .source sidecar records the header this bridge was generated from. When that
-        // header is gone, the stale .i.cpp would #include a missing file and break the native
-        // build - the same failure a deleted .rs used to cause. Bridges without a sidecar
-        // predate it and are left alone.
+        // header can no longer be included, the stale .i.cpp would #include a missing file and
+        // break the native build - the same failure a deleted .rs used to cause. Bridges without
+        // a sidecar predate it and are left alone.
         const sidecar = `${bridge}.source`;
         if (!fs.existsSync(sidecar)) return true;
         const source = fs.readFileSync(sidecar, 'utf8').trim();
-        if (!source || fs.existsSync(source)) return true;
+        const reason = source ? staleReasonOf(source) : null;
+        if (!reason) return true;
         [bridge, `${bridge}.exports.json`, `${bridge}.deps`, `${bridge}.warnings`, sidecar].forEach((f) => fs.rmSync(f, { force: true }));
-        log(`crossbind: pruned stale bridge '${path.basename(bridge)}' - its header is gone`);
+        log(`crossbind: pruned stale bridge '${path.basename(bridge)}' - ${reason}`);
         return false;
     });
 }

package/src/actions/getDependLibs.js

@@ -21,6 +21,11 @@ export default function getDependLibs(target) {
                 if (libPaths.length === 0) {
                     libPaths = libsIn(target.releasePath);
                 }
+                // A published port can leave its iOS archive to its xcframework, where the package's paths lead.
+                const xcframeworkLib = target.platform === 'ios' && state.config.allDependencyPaths?.[target.path]?.[fileName]?.lib;
+                if (libPaths.length === 0 && xcframeworkLib) {
+                    libPaths = findFiles(xcframeworkLib, { cwd: d.paths.project });
+                }
                 dependLibs.push(...libPaths);
             });
         }

package/src/actions/getLinkInputs.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import getDependLibs from './getDependLibs.js';
 import state from '../state/index.js';
 import buildAppRustCrates from '../utils/appRustCrates.js';
+import { cratesOf } from '../utils/packageSourceImport.js';
 
 // The archives of a final link (wasm, Node-API addon, native executable or app host) and which of them must
 // survive whole. keepFlag spells "keep this symbol" for the target's linker; a native executable
@@ -22,7 +23,7 @@ export default function getLinkInputs(target, { keepFlag, withBridge = true, bri
     const bridgeLibCandidates = builtLib(bridge);
     // App-local Rust surfaces (imported .rs files) arrive as ONE super staticlib; it is the
     // single fully-loaded Rust archive of the link (see the libstd rule below).
-    const appRustLibs = buildAppRustCrates(target, cache, state.config.cargoDependencies ?? {});
+    const appRustLibs = buildAppRustCrates(target, cache, cratesOf(state.config));
     const libs = [
         ...getDependLibs(target),
         ...appRustLibs,

package/src/actions/gradleProject.js

@@ -36,6 +36,13 @@ const backgroundValues = (color) => `<?xml version="1.0" encoding="utf-8"?>
 </resources>
 `;
 
+// The color while the system is dark, where app.window.backgroundColor gives one, which Android takes in place of the other.
+const darkBackgroundValues = (color) => `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="crossbind_background">${color}</color>
+</resources>
+`;
+
 // The devices of app.permissions, which alone the page may ask for, whatever an extension's Java asks Android for.
 const permissionValues = (permissions) => `<?xml version="1.0" encoding="utf-8"?>
 <resources>
@@ -269,8 +276,8 @@ ${libraries.map((library) => `    implementation '${library}'\n`).join('')}}
 // is an extension's folder of Java sources, by package, which the app's sources take beside the activity, and the
 // class in it the activity calls.
 export default function writeGradleProject(to, {
-    parts, id, label, version, icons = null, urlSchemes = [], fileTypes = [], links = [], shortcutItems = [], background = null, permissions = [],
-    java = [], extensionPermissions = [], manifests = [], resources = [], maven = [],
+    parts, id, label, version, icons = null, urlSchemes = [], fileTypes = [], links = [], shortcutItems = [], background = null, darkBackground = null,
+    permissions = [], java = [], extensionPermissions = [], manifests = [], resources = [], maven = [],
 }) {
     const { name } = state.config.general;
     if (parts.length === 0) throw new Error(`crossbind: no part of the Android app ${name} is built, so there is no Gradle project to write.`);
@@ -328,6 +335,10 @@ export default function writeGradleProject(to, {
     }
     fs.mkdirSync(path.join(main, 'res', 'values'), { recursive: true });
     fs.writeFileSync(path.join(main, 'res', 'values', 'background.xml'), backgroundValues(background));
+    if (background && darkBackground) {
+        fs.mkdirSync(path.join(main, 'res', 'values-night'), { recursive: true });
+        fs.writeFileSync(path.join(main, 'res', 'values-night', 'background.xml'), darkBackgroundValues(darkBackground));
+    }
     fs.writeFileSync(path.join(main, 'res', 'values', 'permissions.xml'), permissionValues(permissions));
     if (shortcutItems.length > 0) {
         fs.mkdirSync(path.join(main, 'res', 'xml'), { recursive: true });

package/src/actions/licenses.js

@@ -17,6 +17,7 @@ import { DESKTOP_PLATFORMS } from './buildApp.js';
 import extensionsInApp from './extensionsInApp.js';
 import { ANDROIDX_WEBKIT } from './gradleProject.js';
 import { extensionPackage, extensionPart } from '../utils/appExtensions.js';
+import { declaredSources, declarationOf, dependenciesOf } from '../utils/packageSources.js';
 import { shippedBundledLicense } from '../utils/bundledLicenses.js';
 import toolchainNoticesDir from '../utils/toolchainNotices.js';
 
@@ -458,9 +459,9 @@ async function buildRow(node) {
     };
 }
 
-// A Conan package's facts come from its recipe, and its texts from the licenses/ its package ships.
-function conanRow(node) {
-    const { conan } = node.general;
+// The facts of a package source's package come from its recipe, and its texts from the licenses/ its package ships.
+function sourcePackageRow(node) {
+    const { name: source, package: pkg } = node.general.packageSource;
     const licenseDir = `${node.paths.project}/licenses`;
     const files = fs.existsSync(licenseDir)
         ? fs.readdirSync(licenseDir, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile())
@@ -468,29 +469,32 @@ function conanRow(node) {
     const texts = files.map((entry) => path.join(entry.parentPath, entry.name)).sort()
         .map((file) => `=== ${path.relative(licenseDir, file)} ===\n\n${fs.readFileSync(file, 'utf8').trim()}`);
     return {
-        name: conan.name,
+        name: pkg.name,
         npmName: null,
         version: null,
-        nativeVersion: conan.version,
-        license: conan.license,
+        nativeVersion: pkg.version,
+        license: pkg.license,
         licenseDeclared: null,
         licenseSelected: null,
-        licenseNotes: `built from the ConanCenter recipe ${conan.ref}`,
-        sha256: conan.source?.sha256 ?? null,
-        sourceUrl: conan.source?.url ?? conan.homepage ?? null,
+        licenseNotes: `built from the ${source} package ${pkg.ref}`,
+        sha256: pkg.source?.sha256 ?? null,
+        sourceUrl: pkg.source?.url ?? pkg.homepage ?? null,
         licenseText: texts.length > 0 ? texts.join('\n\n') : null,
-        isCopyleft: isCopyleft(conan.license),
-        purl: `pkg:conan/${conan.name}@${conan.version}`,
+        isCopyleft: isCopyleft(pkg.license),
+        purl: `pkg:${source}/${pkg.name}@${pkg.version}`,
     };
 }
 
-// Conan packages join the graph from the stage a build makes; without it they would be left out unseen.
-function assertConanStaged() {
-    const attached = new Set(state.config.allDependencies.filter((d) => d.general.conan).map((d) => d.general.conan.name));
-    const missing = Object.keys(state.config.conanDependencies ?? {}).filter((name) => !attached.has(name));
-    if (missing.length > 0) {
-        throw new Error(`crossbind: the Conan packages ${missing.join(', ')} are not installed for the current conanDependencies, so their rows would be missing. Build the project first.`);
-    }
+// The packages of package sources join the graph from the stage a build makes; without it they would be left out unseen.
+function assertSourcesStaged() {
+    declaredSources(state.config).forEach(({ name }) => {
+        const attached = new Set(state.config.allDependencies.filter((d) => d.general.packageSource?.name === name)
+            .map((d) => d.general.packageSource.package.name));
+        const missing = Object.keys(dependenciesOf(state.config, name)).filter((pkg) => !attached.has(pkg));
+        if (missing.length > 0) {
+            throw new Error(`crossbind: the ${name} packages ${missing.join(', ')} are not installed for the current ${declarationOf(name)}, so their rows would be missing. Build the project first.`);
+        }
+    });
 }
 
 // platform (optional, e.g. 'wasi') additionally includes what that platform's
@@ -499,23 +503,25 @@ function assertConanStaged() {
 // addon of that platform compiles in, or without a platform the one its loader bundles;
 // runtimeEnv 'app' adds what an app's host carries.
 export default async function collectLicenseRows(platform = null, { runtimeEnv = null } = {}) {
-    assertConanStaged();
+    assertSourcesStaged();
     // The root package is a component too when it is a port: leaf -wasi packages have no deps but ship
     // their own upstream. A dependency that is no port, such as a library a project publishes, is one by
     // its package name; a private package is the project's own code, like the app.
-    const keyOf = (node) => (node.general.conan ? `conan:${node.general.conan.name}` : node.general.alias?.package ?? node.package?.name);
+    const keyOf = ({ general, package: manifest }) => (general.packageSource
+        ? `${general.packageSource.name}:${general.packageSource.package.name}`
+        : general.alias?.package ?? manifest?.name);
     const nodes = [state.config, ...state.config.allDependencies]
         .filter((node, index) => node?.paths?.project
-            && (node.general?.alias?.package || node.general?.conan || (index > 0 && node.package?.name && !node.package.private)));
+            && (node.general?.alias?.package || node.general?.packageSource || (index > 0 && node.package?.name && !node.package.private)));
     const rows = [];
     const seen = new Set();
     for (const node of nodes) {
         const key = keyOf(node);
         if (seen.has(key)) continue;
         seen.add(key);
-        rows.push(node.general.conan ? conanRow(node) : await buildRow(node));
-        // A Conan package's folder is written from what its recipe produced: nothing there is run.
-        if (platform && !node.general.conan) {
+        rows.push(node.general.packageSource ? sourcePackageRow(node) : await buildRow(node));
+        // A package source's package folder is written from what its recipe produced: nothing there is run.
+        if (platform && !node.general.packageSource) {
             const familyProjects = nodes.filter((other) => keyOf(other) === key).map((other) => other.paths.project);
             rows.push(...await bundledRowsOf(node, platform, familyProjects));
         }

package/src/actions/{prepareConanDependencies.js → preparePackageSources.js}

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import state, { setAllDependecyPaths } from '../state/index.js';
-import refreshConanDependencies from '../state/refreshConanDependencies.js';
-import installConanPackages from '../utils/conanInstall.js';
+import refreshPackageSources from '../state/refreshPackageSources.js';
+import installPackageSources from '../utils/packageSourceInstall.js';
+import { declaredSources } from '../utils/packageSources.js';
 import { releaseTargetOf, HOST_BUILT_PLATFORMS } from '../utils/targets.js';
 import createXCFramework from './createXCFramework.js';
 
@@ -11,11 +12,11 @@ const isBuiltHere = (target) => process.platform === 'darwin' || !HOST_BUILT_PLA
 
 // iOS headers and archives come out of an xcframework per library with a slice per SDK (state/index.js).
 // One older than an archive it wraps was made before the package was staged again.
-function makeConanXCFrameworks(iosTargets) {
+function makeXCFrameworks(iosTargets) {
     const archiveOf = (dependency, target, name) => `${dependency.paths.output}/prebuilt/${target.path}/lib/lib${name}.a`;
     const isFresh = (dependency, name) => mtimeOf(`${dependency.paths.project}/${name}.xcframework/Info.plist`)
         >= Math.max(...iosTargets.map((target) => mtimeOf(archiveOf(dependency, target, name))));
-    state.config.allDependencies.filter((dependency) => dependency.general.conan).forEach((dependency) => {
+    state.config.allDependencies.filter((dependency) => dependency.general.packageSource).forEach((dependency) => {
         // A library its recipe names on another platform only has no slice here.
         const libName = dependency.export.libName.filter((name) => iosTargets.every((target) => fs.existsSync(archiveOf(dependency, target, name))));
         if (libName.every((name) => isFresh(dependency, name))) return;
@@ -29,11 +30,11 @@ function makeConanXCFrameworks(iosTargets) {
     });
 }
 
-// Conan packages are staged before any header is read: SWIG parses headers that include theirs, and an
-// interface made without its includes stays that way until the header itself changes. Release trees
-// only - a debug build links them like any prebuilt.
-export default async function prepareConanDependencies(targets) {
-    if (Object.keys(state.config.conanDependencies ?? {}).length === 0) return;
+// The packages of a project's sources are staged before any header is read: SWIG parses headers that
+// include theirs, and an interface made without its includes stays that way until the header itself
+// changes. Release trees only - a debug build links them like any prebuilt.
+export default async function preparePackageSources(targets) {
+    if (declaredSources(state.config).length === 0) return;
     // createBridgeFile reads every header for the first wasm target unless it is told otherwise, as it
     // is by Metro, which builds the React Native bridges for the platform's own target, and by a Node
     // build, which reads them for one of its own (nodeBridgeTarget).
@@ -43,9 +44,9 @@ export default async function prepareConanDependencies(targets) {
     const releaseTargets = [...new Map([...targets, bridgeTarget, ...iosTargets].filter(Boolean).map((target) => [
         target.releasePath, releaseTargetOf(target),
     ])).values()].filter(isBuiltHere);
-    await installConanPackages(state.config, releaseTargets);
+    await installPackageSources(state.config, releaseTargets);
     // Also when another process did the staging: this one may have loaded before the manifests existed.
-    refreshConanDependencies(state.config);
+    refreshPackageSources(state.config);
     setAllDependecyPaths();
-    if (iosTargets.length > 0) makeConanXCFrameworks(releaseTargets.filter((target) => target.platform === 'ios'));
+    if (iosTargets.length > 0) makeXCFrameworks(releaseTargets.filter((target) => target.platform === 'ios'));
 }

package/src/actions/writeRuntimeEntry.js

@@ -50,7 +50,7 @@ function nativesOf(headers, imports, dir) {
 }
 
 // The module `node --import` loads ahead of the app, so the app imports the bound headers themselves.
-export function writeImportHooks(entry, headers, imports, extensions) {
+export function writeImportHooks(entry, headers, imports, extensions, schemes) {
     // Node runs the register file from its real path, so the files it names are relative to that.
     const dir = upath.normalize(fs.realpathSync(upath.dirname(entry)));
     const natives = nativesOf(headers, imports, dir);
@@ -59,7 +59,7 @@ export function writeImportHooks(entry, headers, imports, extensions) {
         '// Generated by crossbind - do not edit.',
         "import registerNativeImports from './hooks.mjs';",
         '',
-        `registerNativeImports(new URL('./${upath.basename(entry)}', import.meta.url), ${JSON.stringify({ extensions, natives }, null, 4)});`,
+        `registerNativeImports(new URL('./${upath.basename(entry)}', import.meta.url), ${JSON.stringify({ extensions, schemes, natives }, null, 4)});`,
         '',
     ].join('\n'));
 }