crossbind 2.0.0-beta.68 → 2.0.0-beta.72

package/src/actions/linuxPackages.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { downloadFile, verifyIntegrity } from '../utils/downloadAndExtractFile.js';
+
+// The Ubuntu 22.04 packages a Linux extension lists beside crossbind's sysroot: each downloaded once into the build's
+// folder from Launchpad, as the sysroot's own are, checked against its SHA-256 and unpacked into a sysroot of the
+// extension's own for the target, whose headers its sources include and whose libraries the host links against. Its
+// users' systems load the libraries at run time, as the app's Debian package's Depends asks for them.
+
+const DEBIAN_ARCH = { x64: 'amd64', arm64: 'arm64' };
+const MULTIARCH = { x64: 'x86_64-linux-gnu', arm64: 'aarch64-linux-gnu' };
+
+export const packageUrl = (file) => `https://launchpad.net/ubuntu/+archive/primary/+files/${file}`;
+
+// The packages of the target's architecture among the lines an extension lists.
+export function packagesFor(target, lines) {
+    return lines.map((line) => line.split(' ')).filter(([arch]) => arch === DEBIAN_ARCH[target.arch]).map(([, file, sha256]) => ({ file, sha256 }));
+}
+
+// What a sysroot gives the target: the folders its sources include, usr/include and each folder in it, as a library's
+// headers sit in one of its own, and the folder the host links from.
+export function sysrootDirs(target, root) {
+    const include = path.join(root, 'usr', 'include');
+    const nested = fs.existsSync(include)
+        ? fs.readdirSync(include, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(include, entry.name))
+        : [];
+    return { includes: [include, ...nested], libDir: path.join(root, 'usr', 'lib', MULTIARCH[target.arch]) };
+}
+
+// Unpacks each extension's packages for the target, with unpack(deb, folder), which crossbind's Linux image runs.
+export async function unpackPackages(target, compiled, { cache, workDir, unpack }) {
+    const sysroots = [];
+    for (const { name, packages } of compiled.filter((part) => part.packages.length > 0)) {
+        const own = packagesFor(target, packages);
+        if (own.length === 0) throw new Error(`crossbind: the extension ${name} lists Linux packages, but none of ${DEBIAN_ARCH[target.arch]}, which an ${target.arch} app takes.`);
+        const root = path.join(workDir, 'sysroot', name);
+        fs.rmSync(root, { recursive: true, force: true });
+        fs.mkdirSync(root, { recursive: true });
+        for (const { file, sha256 } of own) {
+            const url = packageUrl(file);
+            const deb = await downloadFile(url, cache);
+            verifyIntegrity(deb, url, sha256);
+            unpack(deb, root);
+        }
+        sysroots.push({ name, ...sysrootDirs(target, root) });
+    }
+    return sysroots;
+}

package/src/actions/mavenVerification.js

@@ -0,0 +1,37 @@
+// The verification metadata of an Android app whose extensions ask Maven for libraries: the android-app image's, which
+// lists all crossbind's own project resolves, with each extension's components, as Gradle's
+// --write-verification-metadata lists them. Gradle then checks every file it resolves, from the image's cache or online.
+
+const COMPONENT = /<component group="([^"]+)" name="([^"]+)" version="([^"]+)"[^>]*>([\s\S]*?)<\/component>/g;
+const ARTIFACT = /<artifact name="([^"]+)">[\s\S]*?<\/artifact>/g;
+// What would leave a file unchecked, which an extension's metadata may not add to the app's.
+const TRUST = /<(trusted-artifacts|trust|ignored-keys|trusted-keys)\b/;
+
+export function mergedVerification(base, fragments) {
+    const components = new Map();
+    const add = (xml, owner) => {
+        for (const [, group, name, version, body] of xml.matchAll(COMPONENT)) {
+            const key = `${group}:${name}:${version}`;
+            const artifacts = components.get(key) ?? new Map();
+            for (const [block, artifact] of body.matchAll(ARTIFACT)) {
+                const known = artifacts.get(artifact);
+                if (known && known.block !== block) throw new Error(`crossbind: ${owner} gives ${artifact} of ${key} other checksums than ${known.owner} does.`);
+                if (!known) artifacts.set(artifact, { block, owner });
+            }
+            components.set(key, artifacts);
+        }
+    };
+    add(base, "the android-app image's verification metadata");
+    for (const { name, xml } of fragments) {
+        const owner = `the extension ${name}`;
+        if (TRUST.test(xml)) throw new Error(`crossbind: ${owner}'s verification metadata trusts files Gradle would then leave unchecked, which no extension's may.`);
+        if ([...xml.matchAll(COMPONENT)].length === 0) throw new Error(`crossbind: ${owner}'s verification metadata lists no component, as Gradle's --write-verification-metadata sha256 writes them.`);
+        add(xml, owner);
+    }
+    const listed = [...components.entries()].sort(([one], [other]) => (one < other ? -1 : 1)).map(([key, artifacts]) => {
+        const [group, name, version] = key.split(':');
+        const blocks = [...artifacts.values()].map(({ block }) => `         ${block}\n`).join('');
+        return `      <component group="${group}" name="${name}" version="${version}">\n${blocks}      </component>\n`;
+    });
+    return `${base.slice(0, base.indexOf('<components>'))}<components>\n${listed.join('')}   </components>\n</verification-metadata>\n`;
+}

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

@@ -0,0 +1,220 @@
+import state from '../state/index.js';
+import loadConfig from '../state/loadConfig.js';
+import {
+    DESKTOP_PLATFORMS, MAX_VERSION_CODE, appOutputOf, clearAppOutputs,
+} from './buildApp.js';
+import extensionApi from './extensionApi.js';
+import {
+    PUBLISH_PLATFORMS, extensionStep, isJsonValue, ownExtensions, withListed, withoutNamed,
+} from '../utils/appExtensions.js';
+import { CONFIG_CHANGES } from '../utils/configChanges.js';
+import { hasTerminal } from '../utils/ask.js';
+import resolveAppHostRoot from '../utils/resolveAppHost.js';
+
+const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const possessive = (name) => (name.endsWith('s') ? `${name}'` : `${name}'s`);
+const listed = (names, word = 'or') => (names.length > 1 ? `${names.slice(0, -1).join(', ')} ${word} ${names.at(-1)}` : names[0]);
+const kebab = (name) => name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+const camel = (name) => name.replace(/-([a-z0-9])/g, (dash, letter) => letter.toUpperCase());
+const storeName = ({ name, publisher }) => publisher.store ?? name;
+// How many builds a publish makes at most, as its first publisher may ask for another.
+const MAX_BUILDS = 4;
+
+// A step of the publisher's, which its publisher may lack.
+const step = ({ name, publisher }, which, ...args) => extensionStep(name, which, () => publisher[which]?.(...args));
+
+// crossbind's own publishers, which the host brings as it brings its other extensions.
+export const builtInPublishers = () => withoutNamed(ownExtensions(resolveAppHostRoot()), state.config?.app).filter(({ publisher }) => publisher);
+
+// The publishers an app has: crossbind's own, each in the place of the app's extension of its name that has a
+// publisher, then those of the app's other extensions.
+export const publishersOf = (extensions) => withListed(builtInPublishers(), extensions.filter((extension) => extension.publisher));
+
+// The store the command names first, before the options, else the last publisher that says it is the one of the platform
+// -p, or CROSSBIND_APP_PLATFORM, names, and the arguments after it. A store named after the options, of those crossbind
+// knows, is refused, as Vite would take it.
+export function storeOf(args, platform, envPlatform, publishers = []) {
+    const [first, ...rest] = args;
+    const named = first !== undefined && !first.startsWith('-') ? first : null;
+    const late = named ? null : args.find((arg) => publishers.some(({ name }) => name === arg));
+    if (late) throw new Error(`crossbind: crossbind app publish takes the store first, before the options: crossbind app publish ${late} ${args.filter((arg) => arg !== late).join(' ')}.`);
+    const where = platform ?? envPlatform;
+    const usual = publishers.findLast(({ publisher }) => publisher.isDefault && publisher.platforms.includes(where));
+    return { store: named ?? usual?.name ?? null, rest: named ? rest : args };
+}
+
+// The publisher of a store, after those it comes after, first to last.
+export function publishChain(publishers, store) {
+    if (!publishers.some(({ name }) => name === store)) {
+        throw new Error(`crossbind: crossbind app publish takes the store it sends the app to first: ${listed(publishers.map(({ name }) => name))}${store ? `, not ${store}` : ''}.`);
+    }
+    const chain = [];
+    for (let current = store; current;) {
+        const extension = publishers.find(({ name }) => name === current);
+        if (!extension) throw new Error(`crossbind: ${chain[0].name} comes after ${current}, which no publisher is named.`);
+        if (chain.includes(extension)) throw new Error(`crossbind: ${listed([extension, ...chain].map(({ name }) => name), 'and')} come after one another in a circle.`);
+        chain.unshift(extension);
+        current = extension.publisher.after;
+    }
+    return chain;
+}
+
+// The platform a publish builds for: the one -p names, which every publisher of it takes, else the only one they take,
+// else CROSSBIND_APP_PLATFORM's, else this machine's desktop one.
+export function publishPlatform(chain, platform, envPlatform, host = process.platform) {
+    const store = chain.at(-1).name;
+    const platforms = chain.reduce((taken, { publisher }) => taken.filter((one) => publisher.platforms.includes(one)), PUBLISH_PLATFORMS);
+    if (platforms.length === 0) throw new Error(`crossbind: ${store} comes after ${chain[0].name}, which takes apps of none of its platforms.`);
+    const takes = `${store} takes ${listed(platforms)} apps`;
+    if (platform) {
+        if (!platforms.includes(platform)) throw new Error(`crossbind: ${takes}, not ${possessive(platform)}, which -p names.`);
+        return platform;
+    }
+    if (platforms.length === 1) return platforms[0];
+    if (envPlatform) {
+        if (!platforms.includes(envPlatform)) throw new Error(`crossbind: ${takes}, not ${possessive(envPlatform)}, which CROSSBIND_APP_PLATFORM names.`);
+        return envPlatform;
+    }
+    if (platforms.includes(DESKTOP_PLATFORMS[host])) return DESKTOP_PLATFORMS[host];
+    throw new Error(`crossbind: ${takes}: name one with -p.`);
+}
+
+// The options of each publisher of a publish, as the command line gives them, and the arguments Vite takes. An option
+// that another publisher takes is refused, naming whose it is; any other goes on to Vite.
+export function publishOptions(chain, args, publishers) {
+    const kinds = new Map();
+    chain.forEach(({ name, publisher }) => Object.entries(publisher.options).forEach(([option, { value }]) => {
+        const first = kinds.get(option);
+        if (first && (first.value === null) !== (value === null)) {
+            throw new Error(`crossbind: ${first.name} and ${name} both take --${kebab(option)}, one as a flag and one with a value: one of them names it otherwise.`);
+        }
+        if (!first) kinds.set(option, { name, value });
+    }));
+    const given = new Map(chain.map(({ name }) => [name, new Map()]));
+    const foreign = new Map();
+    const viteArgs = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const match = /^--([a-z][a-z0-9-]*)(?:=(.*))?$/s.exec(args[index]);
+        const option = match && camel(match[1]);
+        const owners = match ? chain.filter(({ publisher }) => Object.hasOwn(publisher.options, option)) : [];
+        if (owners.length === 0) {
+            const other = match && publishers.find(({ publisher }) => Object.hasOwn(publisher.options, option));
+            if (other) foreign.set(other.name, [...(foreign.get(other.name) ?? []), `--${match[1]}`]);
+            else viteArgs.push(args[index]);
+            continue;
+        }
+        const { value: placeholder } = owners.at(-1).publisher.options[option];
+        let value = true;
+        if (placeholder !== null && match[2] === undefined) {
+            value = args[index + 1];
+            index += 1;
+            if (value === undefined || value.startsWith('-')) throw new Error(`crossbind: --${match[1]} takes a value, as ${placeholder}.`);
+        } else if (placeholder !== null) {
+            value = match[2];
+        } else if (match[2] !== undefined) {
+            throw new Error(`crossbind: --${match[1]} takes no value.`);
+        }
+        owners.forEach(({ name }) => given.get(name).set(option, value));
+    }
+    if (foreign.size > 0) {
+        const whose = [...foreign].map(([owner, names]) => `${listed(names, 'and')} ${names.length > 1 ? 'are' : 'is'} ${possessive(owner)}`);
+        throw new Error(`crossbind: ${listed(whose, 'and')}, which ${chain.at(-1).name} takes none of.`);
+    }
+    const options = Object.fromEntries(chain.map(({ name, publisher }) => [name, Object.fromEntries(Object.entries(publisher.options)
+        .map(([option, { value, default: fallback }]) => [option, given.get(name).get(option) ?? (value === null ? false : fallback)]))]));
+    return { options, viteArgs };
+}
+
+// The help of the stores crossbind publishes to itself, with the options each takes after its name.
+export function publishHelp(publishers = builtInPublishers()) {
+    const signature = (option, { value }) => `--${kebab(option)}${value ? ` ${value}` : ''}`;
+    const width = Math.max(...publishers.flatMap(({ publisher }) => Object.entries(publisher.options).map(([option, declared]) => signature(option, declared).length)));
+    return [
+        '',
+        'Stores, each with the options it takes after its name:',
+        ...publishers.flatMap(({ name, publisher }) => [
+            `  ${name}: ${storeName({ name, publisher })}, for ${listed(publisher.platforms)} apps${publisher.isDefault ? ', which goes first for them' : ''}`,
+            ...Object.entries(publisher.options).map(([option, declared]) => `    ${signature(option, declared).padEnd(width)}  ${declared.help}${declared.default ? ` (default: ${declared.default})` : ''}`),
+        ]),
+        "An app's extensions add stores of their own, each with the options its package gives.",
+    ].join('\n');
+}
+
+// The changes the first publisher makes to the config for its build: a JSON merge patch of crossbind.config.js's
+// export.
+async function buildChanges(extension, api) {
+    const { name } = extension;
+    const changes = await step(extension, 'build', api);
+    if (changes === null || changes === undefined) return null;
+    if (!isObject(changes) || !isJsonValue(changes)) {
+        throw new Error(`crossbind: ${name}'s build gives no changes to crossbind.config.js, which are an object of JSON values merged into its export, where null removes a key.`);
+    }
+    return changes;
+}
+
+// Hands the build's output to the uploads of the publishers after the first, each with what the one before it put out.
+async function uploadAfter(chain, apis, sessions, output, firstPublished) {
+    let published = firstPublished;
+    for (const [index, extension] of chain.entries()) {
+        const { name } = extension;
+        if (index > 0) {
+            const answer = await step(extension, 'upload', apis[index], sessions[index], output, published);
+            if (answer?.isRebuildAsked) throw new Error(`crossbind: ${name} asks for another build, which ${chain[0].name}, whose build it publishes from, alone can ask for.`);
+            published = answer?.published;
+        }
+    }
+}
+
+// Sends an app to a store through its publisher, after those it comes after. All they need is checked before the build,
+// which takes minutes: on a terminal they ask for what is missing and set it up; without one, as in CI, every missing
+// piece is named at once. crossbind then builds the app once, with the first publisher's changes to the config, build
+// number and environment, and hands its output to each one's upload in turn. The first may ask for another build, as
+// an iOS app's does once its user has given Apple's reasons for an API it calls.
+export default async function publish(args, { platform, envPlatform, runVite }) {
+    const publishers = publishersOf(state.config.extensions);
+    const { store, rest } = storeOf(args, platform, envPlatform, publishers);
+    const chain = publishChain(publishers, store);
+    const own = builtInPublishers().map(({ name }) => name);
+    chain.filter((extension) => own.includes(extension.name) && state.config.extensions.includes(extension))
+        .forEach(({ name, root }) => console.log(`crossbind: the extension ${name} of ${root} replaces crossbind's own publisher of its name.`));
+    const target = publishPlatform(chain, platform, envPlatform);
+    const { options, viteArgs } = publishOptions(chain, rest, publishers);
+    const run = { buildNumber: undefined };
+    const isGuided = hasTerminal();
+    const apis = chain.map(({ name }) => extensionApi(name, {
+        platform: target, options: options[name], isGuided, run,
+    }));
+    const [first] = chain;
+    const changes = await buildChanges(first, apis[0]);
+    if (changes) state.config = await loadConfig(undefined, undefined, { changes });
+    const checked = [];
+    for (const [index, extension] of chain.entries()) checked.push((await step(extension, 'check', apis[index])) ?? {});
+    const missing = checked.flatMap((result) => result.missing ?? []);
+    if (missing.length > 0) throw new Error(missing.join('\n'));
+    const sessions = checked.map(({ session }) => session);
+    run.buildNumber = (await step(first, 'buildNumber', apis[0], sessions[0])) ?? null;
+    if (run.buildNumber !== null && !(Number.isInteger(run.buildNumber) && run.buildNumber >= 1 && run.buildNumber <= MAX_VERSION_CODE)) {
+        throw new Error(`crossbind: ${first.name}'s buildNumber gives ${JSON.stringify(run.buildNumber)}, which is no build number: a whole number from 1 to ${MAX_VERSION_CODE}, as both stores take, or null for the app's own.`);
+    }
+    for (let builds = 1; ; builds += 1) {
+        clearAppOutputs();
+        const buildEnv = await step(first, 'buildEnv', apis[0], sessions[0]);
+        const exitCode = await runVite(['build', ...viteArgs], {
+            ...process.env,
+            ...(changes ? { [CONFIG_CHANGES]: JSON.stringify(changes) } : {}),
+            ...buildEnv,
+            CROSSBIND_APP_PLATFORM: target,
+            ...(run.buildNumber === null ? {} : { CROSSBIND_APP_BUILD_NUMBER: String(run.buildNumber) }),
+        });
+        if (exitCode !== 0) {
+            throw Object.assign(new Error(`crossbind: the build ended with exit code ${exitCode}, so nothing went to ${storeName(first)}.`), { exitCode });
+        }
+        const output = appOutputOf(target);
+        const answer = await step(first, 'upload', apis[0], sessions[0], output);
+        if (!answer?.isRebuildAsked) {
+            await uploadAfter(chain, apis, sessions, output, answer?.published);
+            return;
+        }
+        if (builds === MAX_BUILDS) throw new Error(`crossbind: ${first.name} asks for another build after ${MAX_BUILDS}, as many as a publish makes.`);
+    }
+}

package/src/actions/windowsSigning.js

@@ -49,7 +49,7 @@ export function windowsSigning(env = process.env) {
         return null;
     }
     if (TOKENS.includes(storetype)) {
-        throw new Error(`crossbind: ${WINDOWS_SIGNING.storetype} ${storetype} is a hardware token, which crossbind's windows container does not reach. Sign with a cloud's key service, as Azure Trusted Signing (TRUSTEDSIGNING) or Azure Key Vault (AZUREKEYVAULT), or with a PKCS#12 file.`);
+        throw new Error(`crossbind: ${WINDOWS_SIGNING.storetype} ${storetype} is a hardware token, which crossbind's windows container does not reach. Sign with a cloud's key service, as Azure Artifact Signing (TRUSTEDSIGNING) or Azure Key Vault (AZUREKEYVAULT), or with a PKCS#12 file.`);
     }
     if (![...FILE_STORES, ...CLOUDS].includes(storetype)) {
         throw new Error(`crossbind: ${WINDOWS_SIGNING.storetype} ${storetype} is no store type jsign takes: ${[...FILE_STORES, ...CLOUDS].join(', ')}.`);

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'));
 }

package/src/actions/xcodeProject.js

@@ -3,13 +3,15 @@ import { spawnSync } from 'node:child_process';
 import state from '../state/index.js';
 import { IOS_DEPLOYMENT_TARGET } from '../utils/iosToolchain.js';
 import { textPlist, xmlPlist } from '../utils/plist.js';
-import { PRIVACY_CATEGORIES } from '../utils/appOptions.js';
+import { mergedPlist } from '../utils/appExtensions.js';
+import { appLinkParts, iosDocumentTypes, iosShortcutItems } from '../utils/appLaunches.js';
+import { privacyManifest, writeTargets } from './xcodeTargets.js';
 
 // The SDKs an iOS app builds for, one target each, and the slice of Hermes' release each takes.
 export const IOS_SDKS = ['iphoneos', 'iphonesimulator'];
 export const HERMES_SLICES = { iphoneos: 'ios-arm64', iphonesimulator: 'ios-arm64_x86_64-simulator' };
 // What the host's own code needs from the system: Xcode adds it only for the sources it compiles itself.
-const SYSTEM_LIBS = ['-framework', 'UIKit', '-framework', 'WebKit', '-framework', 'CoreGraphics', '-lc++'];
+const SYSTEM_LIBS = ['-framework', 'UIKit', '-framework', 'WebKit', '-framework', 'CoreGraphics', '-framework', 'Security', '-framework', 'UserNotifications', '-lc++'];
 
 const MAIN = `// crossbind writes this project anew on every build: the app comes prebuilt in lib/, and its files are in app/.
 int crossbind_app_main(int argc, char *argv[]);
@@ -19,7 +21,7 @@ int main(int argc, char *argv[]) { return crossbind_app_main(argc, argv); }
 
 const OBJECT_NAMES = ['project', 'mainGroup', 'products', 'target', 'product', 'main', 'info', 'app', 'hermes', 'mainBuild',
     'appBuild', 'hermesLink', 'hermesEmbed', 'sources', 'frameworks', 'resources', 'embed', 'projectDebug', 'projectRelease',
-    'targetDebug', 'targetRelease', 'projectConfigs', 'targetConfigs', 'assets', 'assetsBuild', 'privacy', 'privacyBuild'];
+    'targetDebug', 'targetRelease', 'projectConfigs', 'targetConfigs', 'assets', 'assetsBuild', 'privacy', 'privacyBuild', 'embedTargets'];
 // Xcode names its objects by 24 hex digits. Fixed ones leave the project unchanged while what it holds is.
 const ID = Object.fromEntries(OBJECT_NAMES.map((name, index) => [name, `CB${(index + 1).toString(16).toUpperCase().padStart(22, '0')}`]));
 
@@ -40,7 +42,14 @@ const ORIENTATIONS = ['UIInterfaceOrientationPortrait', 'UIInterfaceOrientationL
 // The color set of app.window.backgroundColor, which the launch screen shows.
 const LAUNCH_COLOR = 'LaunchBackground';
 
-const infoPlist = (name, urlSchemes, hasBackground, usage, encryption) => xmlPlist({
+// The entitlement of the domains whose sites' links iOS hands the app, once each site's apple-app-site-association names
+// it, and the one of the App Groups it shares with the targets of its extensions'.
+const ASSOCIATED_DOMAINS = 'com.apple.developer.associated-domains';
+const APP_GROUPS = 'com.apple.security.application-groups';
+
+// The app's Info.plist, with the keys its extensions give, and the App Group its native code reads where the targets of
+// its extensions' share one.
+const infoPlist = (name, urlSchemes, fileTypes, activityTypes, shortcutItems, hasBackground, usage, encryption, multipleWindows, appGroup, plist) => xmlPlist(mergedPlist({
     CFBundleDevelopmentRegion: 'en',
     CFBundleDisplayName: name,
     CFBundleExecutable: '$(EXECUTABLE_NAME)',
@@ -53,15 +62,20 @@ const infoPlist = (name, urlSchemes, hasBackground, usage, encryption) => xmlPli
     CFBundleVersion: '$(CURRENT_PROJECT_VERSION)',
     ...(encryption === null ? {} : { ITSAppUsesNonExemptEncryption: encryption }),
     LSRequiresIPhoneOS: true,
-    UIApplicationSceneManifest: { UIApplicationSupportsMultipleScenes: false },
+    UIApplicationSceneManifest: { UIApplicationSupportsMultipleScenes: multipleWindows },
     UILaunchScreen: hasBackground ? { UIColorName: LAUNCH_COLOR } : {},
     UISupportedInterfaceOrientations: ORIENTATIONS,
     'UISupportedInterfaceOrientations~ipad': [...ORIENTATIONS, 'UIInterfaceOrientationPortraitUpsideDown'],
+    ...iosDocumentTypes(fileTypes, '$(PRODUCT_BUNDLE_IDENTIFIER)'),
+    ...(activityTypes.length > 0 ? { NSUserActivityTypes: activityTypes } : {}),
+    ...(shortcutItems.length > 0 ? { UIApplicationShortcutItems: iosShortcutItems(shortcutItems) } : {}),
     // The reasons of app.permissions, without which iOS lets the app use none of those devices.
     ...usage,
-});
+    ...(appGroup ? { CrossbindAppGroup: appGroup } : {}),
+}, plist));
 
-function objects(name, targetSettings, hasAssets, hasPrivacy) {
+// The project's objects: the app's target, and the targets its extensions add, which the app depends on and embeds.
+function objects(name, targetSettings, hasAssets, hasPrivacy, added) {
     const file = (path, type) => ({ isa: 'PBXFileReference', lastKnownFileType: type, path, sourceTree: '<group>' });
     const phase = (isa, files, extra = {}) => ({ isa, buildActionMask: 2147483647, files, runOnlyForDeploymentPostprocessing: 0, ...extra });
     const configuration = (configurationName, buildSettings) => ({ isa: 'XCBuildConfiguration', buildSettings, name: configurationName });
@@ -77,9 +91,11 @@ function objects(name, targetSettings, hasAssets, hasPrivacy) {
         [ID.privacy]: file('PrivacyInfo.xcprivacy', 'text.xml'),
         [ID.privacyBuild]: { isa: 'PBXBuildFile', fileRef: ID.privacy },
     } : {};
+    const hasTargets = added.targets.length > 0;
     return {
         ...assets,
         ...privacy,
+        ...added.objects,
         [ID.main]: file('main.m', 'sourcecode.c.objc'),
         [ID.info]: file('Info.plist', 'text.plist.xml'),
         [ID.app]: file('app', 'folder'),
@@ -95,18 +111,19 @@ function objects(name, targetSettings, hasAssets, hasPrivacy) {
         [ID.frameworks]: phase('PBXFrameworksBuildPhase', [ID.hermesLink]),
         [ID.resources]: phase('PBXResourcesBuildPhase', [ID.appBuild, ...(hasAssets ? [ID.assetsBuild] : []), ...(hasPrivacy ? [ID.privacyBuild] : [])]),
         [ID.embed]: phase('PBXCopyFilesBuildPhase', [ID.hermesEmbed], { dstPath: '', dstSubfolderSpec: 10, name: 'Embed Frameworks' }),
+        ...(hasTargets ? { [ID.embedTargets]: phase('PBXCopyFilesBuildPhase', added.embedded, { dstPath: '', dstSubfolderSpec: 13, name: 'Embed Foundation Extensions' }) } : {}),
         [ID.mainGroup]: {
             isa: 'PBXGroup',
-            children: [ID.main, ID.info, ID.app, ...(hasAssets ? [ID.assets] : []), ...(hasPrivacy ? [ID.privacy] : []), ID.hermes, ID.products],
+            children: [ID.main, ID.info, ID.app, ...(hasAssets ? [ID.assets] : []), ...(hasPrivacy ? [ID.privacy] : []), ID.hermes, ...added.groups, ID.products],
             sourceTree: '<group>',
         },
-        [ID.products]: { isa: 'PBXGroup', children: [ID.product], name: 'Products', sourceTree: '<group>' },
+        [ID.products]: { isa: 'PBXGroup', children: [ID.product, ...added.products], name: 'Products', sourceTree: '<group>' },
         [ID.target]: {
             isa: 'PBXNativeTarget',
             buildConfigurationList: ID.targetConfigs,
-            buildPhases: [ID.sources, ID.frameworks, ID.resources, ID.embed],
+            buildPhases: [ID.sources, ID.frameworks, ID.resources, ID.embed, ...(hasTargets ? [ID.embedTargets] : [])],
             buildRules: [],
-            dependencies: [],
+            dependencies: added.dependencies,
             name,
             productName: name,
             productReference: ID.product,
@@ -123,7 +140,7 @@ function objects(name, targetSettings, hasAssets, hasPrivacy) {
             productRefGroup: ID.products,
             projectDirPath: '',
             projectRoot: '',
-            targets: [ID.target],
+            targets: [ID.target, ...added.targets],
         },
         [ID.projectDebug]: configuration('Debug', PROJECT_SETTINGS),
         [ID.projectRelease]: configuration('Release', PROJECT_SETTINGS),
@@ -134,8 +151,9 @@ function objects(name, targetSettings, hasAssets, hasPrivacy) {
     };
 }
 
-// The asset catalog: the app's icon, from which Xcode makes every size, and the launch screen's color.
-function writeAssets(catalog, icon, background) {
+// The asset catalog: the app's icon, from which Xcode makes every size, and the launch screen's color, with the one of
+// the dark appearance where there is one.
+function writeAssets(catalog, icon, background, darkBackground) {
     const info = { author: 'xcode', version: 1 };
     const assetSet = (set, contents) => {
         fs.mkdirSync(`${catalog}/${set}`, { recursive: true });
@@ -146,28 +164,37 @@ function writeAssets(catalog, icon, background) {
         assetSet('AppIcon.appiconset', { images: [{ filename: 'icon.png', idiom: 'universal', platform: 'ios', size: '1024x1024' }] });
         fs.writeFileSync(`${catalog}/AppIcon.appiconset/icon.png`, icon);
     }
+    const colorOf = (rgb) => {
+        const [red, green, blue] = [1, 3, 5].map((at) => `0x${rgb.slice(at, at + 2).toUpperCase()}`);
+        return { 'color-space': 'srgb', components: { alpha: '1.000', red, green, blue } };
+    };
     if (background) {
-        const [red, green, blue] = [1, 3, 5].map((at) => `0x${background.slice(at, at + 2).toUpperCase()}`);
-        assetSet(`${LAUNCH_COLOR}.colorset`, { colors: [{ color: { 'color-space': 'srgb', components: { alpha: '1.000', red, green, blue } }, idiom: 'universal' }] });
+        const dark = darkBackground ? [{ appearances: [{ appearance: 'luminosity', value: 'dark' }], color: colorOf(darkBackground), idiom: 'universal' }] : [];
+        assetSet(`${LAUNCH_COLOR}.colorset`, { colors: [{ color: colorOf(background), idiom: 'universal' }, ...dark] });
     }
 }
 
-// The privacy manifest of app.privacy, without which App Store Connect refuses an app that calls required reason API.
-const privacyManifest = (privacy) => xmlPlist({
-    NSPrivacyAccessedAPITypes: Object.entries(privacy).map(([name, reasons]) => ({
-        NSPrivacyAccessedAPIType: PRIVACY_CATEGORIES[name].type,
-        NSPrivacyAccessedAPITypeReasons: reasons,
-    })),
-});
-
 // An iOS app as an Xcode project, written anew from the parts its SDK targets built: each brings its archives and
 // their link line, and its slice of Hermes; the first also the app's files. Xcode signs the app and runs it, in the
-// Simulator or on a device, and makes every size of its icon from the one PNG given.
+// Simulator or on a device, with the entitlements given, and makes every size of its icon from the one PNG given. The
+// targets of Apple's app extensions its extensions add build with it, the App Group in the app's entitlements as well
+// where one of them asks for it.
 export default function writeXcodeProject(to, {
-    parts, identity, label, version, build = version, icon = null, urlSchemes = [], background = null, usage = {}, encryption = null, privacy = {},
+    parts, identity, label, version, build = version, icon = null, urlSchemes = [], fileTypes = [], links = [], activityTypes = [], shortcutItems = [],
+    background = null, darkBackground = null, usage = {}, encryption = null, multipleWindows = false, privacy = {}, entitlements = {}, plist = [], targets = [],
+    appGroup = null,
 }) {
     const { name } = state.config.general;
     if (parts.length === 0) throw new Error(`crossbind: no part of the iOS app ${name} is built, so there is no Xcode project to write.`);
+    // Xcode keeps what it builds of each target by the target's name, which a Mac's file system takes in either case.
+    const named = targets.find((target) => target.name.toLowerCase() === name.toLowerCase());
+    if (named) throw new Error(`crossbind: the extension ${named.owner} names an iOS target ${named.name}, as the app itself is named: Xcode builds no two targets of one name.`);
+    // The extensions' keys merge before the project goes, which a conflict between them then leaves as it was.
+    const group = appGroup && targets.some((target) => target.appGroup) ? appGroup : null;
+    const info = infoPlist(label, urlSchemes, fileTypes, activityTypes, shortcutItems, Boolean(background), usage, encryption, multipleWindows, group, plist);
+    const domains = links.map((link) => `applinks:${appLinkParts(link).host}`);
+    const joinedTo = (given, key, values) => (values.length > 0 ? { ...given, [key]: [...new Set([...(given[key] ?? []), ...values])] } : given);
+    const signed = joinedTo(joinedTo(entitlements, ASSOCIATED_DOMAINS, domains), APP_GROUPS, group ? [group] : []);
     fs.rmSync(to, { recursive: true, force: true });
     fs.mkdirSync(`${to}/${name}.xcodeproj`, { recursive: true });
     const linkFlags = {};
@@ -184,24 +211,28 @@ export default function writeXcodeProject(to, {
     if (result.status !== 0) throw new Error(`crossbind: cannot make Hermes' xcframework for ${to}: ${result.stderr || result.error?.message}`);
 
     fs.writeFileSync(`${to}/main.m`, MAIN);
-    fs.writeFileSync(`${to}/Info.plist`, infoPlist(label, urlSchemes, Boolean(background), usage, encryption));
-    writeAssets(`${to}/Assets.xcassets`, icon, background);
+    fs.writeFileSync(`${to}/Info.plist`, info);
+    writeAssets(`${to}/Assets.xcassets`, icon, background, darkBackground);
     const hasPrivacy = Object.keys(privacy).length > 0;
     if (hasPrivacy) fs.writeFileSync(`${to}/PrivacyInfo.xcprivacy`, privacyManifest(privacy));
+    const hasEntitlements = Object.keys(signed).length > 0;
+    if (hasEntitlements) fs.writeFileSync(`${to}/${name}.entitlements`, xmlPlist(signed));
     const targetSettings = {
         ...(icon ? { ASSETCATALOG_COMPILER_APPICON_NAME: 'AppIcon' } : {}),
         PRODUCT_NAME: name,
         PRODUCT_BUNDLE_IDENTIFIER: identity.id,
         DEVELOPMENT_TEAM: identity.team,
         CODE_SIGN_STYLE: 'Automatic',
+        ...(hasEntitlements ? { CODE_SIGN_ENTITLEMENTS: `${name}.entitlements` } : {}),
         INFOPLIST_FILE: 'Info.plist',
         MARKETING_VERSION: version,
         CURRENT_PROJECT_VERSION: build,
         LD_RUNPATH_SEARCH_PATHS: ['$(inherited)', '@executable_path/Frameworks'],
         ...linkFlags,
     };
+    const added = writeTargets(to, targets, { project: ID.project, identity, label, version, build, appGroup });
     fs.writeFileSync(`${to}/${name}.xcodeproj/project.pbxproj`, textPlist({
-        archiveVersion: 1, classes: {}, objectVersion: 56, objects: objects(name, targetSettings, Boolean(icon || background), hasPrivacy), rootObject: ID.project,
+        archiveVersion: 1, classes: {}, objectVersion: 56, objects: objects(name, targetSettings, Boolean(icon || background), hasPrivacy, added), rootObject: ID.project,
     }));
     return to;
 }