crossbind 2.0.0-beta.69 → 2.0.0-beta.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crossbind",
-  "version": "2.0.0-beta.69",
+  "version": "2.0.0-beta.73",
   "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.73"
   },
   "keywords": [
     "webassembly",

package/src/actions/addExtension.js

@@ -4,6 +4,8 @@ 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 { assertAppProject } from '../utils/appProject.js';
 import resolveAppHostRoot from '../utils/resolveAppHost.js';
 
 // The lockfiles by which a project names the package manager it is installed with.
@@ -108,9 +110,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();
@@ -139,9 +145,7 @@ function installedName(spec, before, after, manifest) {
 export default function addExtension(spec, {
     config, env = process.env, platform = process.platform, spawn = spawnSync,
 }) {
-    if (config.target.runtimeEnv !== 'app') {
-        throw new Error("crossbind: an extension builds into an app, which this project is not: set target: { runtimeEnv: 'app' } in crossbind.config.js, as the desktop-app template does.");
-    }
+    assertAppProject(config, 'an extension builds into an app');
     assertSpec(spec, platform);
     assertNotOwn(spec);
     const { project, base } = config.paths;

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() {
@@ -389,6 +393,33 @@ export function clearAppOutputs() {
     else fs.rmSync(appOutputsFile(), { force: true });
 }
 
+// The app target an entry of the folder the bundler builds into was written for, by its name: the target's app, or what
+// packages it.
+function outputTarget(entry) {
+    const { name } = state.config.general;
+    return state.targets.filter((t) => t.runtimeEnv === 'app').find((t) => [appOutputName(t), `${name}-${t.platform}-${t.arch}`]
+        .some((app) => entry === app || entry.startsWith(`${app}.`) || entry.startsWith(`${app}-`)));
+}
+
+// The paths a recorded output names: each desktop app with its installers' files, or a mobile app's project with its APK,
+// bundle and debug symbols.
+const outputPaths = (output) => (Array.isArray(output)
+    ? output.flatMap(({ app, installers = [] }) => [app, ...installers.flatMap(({ files }) => files)])
+    : Object.values(output)).filter(Boolean);
+
+// Empties the folder the bundler builds an app into, as the bundler would, but for git's own folder and what builds for the
+// app's other platforms wrote there: their apps, named after their targets, and the files their installers recorded.
+export function emptyAppOutDir(dir, platform = appPlatform()) {
+    if (!fs.existsSync(dir)) return;
+    const others = new Set(Object.entries(readAppOutputs()).filter(([name]) => name !== platform)
+        .flatMap(([, output]) => outputPaths(output)).map((file) => path.resolve(file)));
+    for (const entry of fs.readdirSync(dir)) {
+        const target = outputTarget(entry);
+        const isOthers = target ? (DESKTOP_PLATFORMS[target.platform] ?? target.platform) !== platform : others.has(path.resolve(dir, entry));
+        if (entry !== '.git' && !isOthers) fs.rmSync(path.join(dir, entry), { recursive: true, force: true });
+    }
+}
+
 // What a publisher's upload gets of the app the build wrote for a platform: a desktop platform's apps, one for each arch.
 export function appOutputOf(platform) {
     const output = readAppOutputs()[platform];
@@ -441,8 +472,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 +486,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');
@@ -470,11 +502,8 @@ export function publishApp(target, { to = appOutputPath(target), page = null } =
         // The app may land inside the page's own directory, which it then leaves out, with every app built there and what
         // packages it: what is named after a target of the app, and every installer's files as a build recorded them, which
         // a folder the bundler left as it was holds still.
-        const apps = state.targets.filter((t) => t.runtimeEnv === 'app')
-            .flatMap((t) => [appOutputName(t), `${state.config.general.name}-${t.platform}-${t.arch}`]).filter((name) => !name.endsWith('.app'));
         const shipped = shippedFiles();
-        const isApp = (entry) => entry === path.basename(to) || entry.endsWith('.app')
-            || apps.some((app) => entry === app || entry.startsWith(`${app}.`) || entry.startsWith(`${app}-`))
+        const isApp = (entry) => entry === path.basename(to) || entry.endsWith('.app') || Boolean(outputTarget(entry))
             || shipped.has(path.resolve(page, entry));
         fs.readdirSync(page).filter((entry) => !isApp(entry)).forEach((entry) => {
             fs.cpSync(`${page}/${entry}`, `${to}/${appLayout(target).resources}/page/${entry}`, { recursive: true });

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/extensionCommands.js

@@ -3,6 +3,7 @@ import extensionApi from './extensionApi.js';
 import state from '../state/index.js';
 import { hasTerminal } from '../utils/ask.js';
 import { extensionStep, ownExtensions, withoutNamed } from '../utils/appExtensions.js';
+import { isAppProject } from '../utils/appProject.js';
 import resolveAppHostRoot from '../utils/resolveAppHost.js';
 
 const kebab = (name) => name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
@@ -23,7 +24,7 @@ function ownOf(listed, app) {
 // Adds to crossbind app the commands of an app's extensions, crossbind's own and those crossbind.config.js lists: a name
 // another has stops the run, naming both.
 export default function addExtensionCommands(parent, config = state.config) {
-    if (config?.target?.runtimeEnv !== 'app') return;
+    if (!config?.target || !isAppProject(config)) return;
     const listed = config.extensions ?? [];
     const owners = new Map(parent.commands.map((command) => [command.name(), 'crossbind']));
     for (const { name: extension, commands = {} } of [...ownOf(listed, config.app), ...listed]) {

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

@@ -1,4 +1,5 @@
 import findFiles from '../utils/findFiles.js';
+import xcframeworkSliceOf from '../utils/xcframeworkSlice.js';
 import state from '../state/index.js';
 import { getFilteredTargetSpec } from './target.js';
 
@@ -21,6 +22,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: the one of this package, as a project
+                // can list the port's packages of other platforms, whose libraries share the name.
+                if (libPaths.length === 0 && target.platform === 'ios') {
+                    libPaths = findFiles(`${xcframeworkSliceOf(d.paths.project, fileName, target)}/lib${fileName}.a`, { 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));
         }