arcane-os 0.55.0 → 0.57.0

package/src/native/portable-provider.mjs

@@ -61,7 +61,7 @@ function serviceSelection(services, release) {
         if (!is.string(service?.module) || !release.files.includes(service.module)) {
             throw new ArcaneError(ERROR_CODES.prerequisiteMissing, `The selected release does not contain service module ${String(service?.module)}.`);
         }
-        return {module: service.module, options: service.options === undefined ? {} : service.options};
+        return {...service, options: service.options === undefined ? {} : service.options};
     });
 }
 
@@ -81,7 +81,7 @@ function eventOwnerPath(release) {
 }
 
 /** Package-owned assembly; never imports an OS checkout or application service. */
-export function createPortableNativeProvider({services = []} = {}) {
+export function createPortableNativeProvider({services} = {}) {
     return {
         protocol: PROTOCOL,
         async describe() {
@@ -120,7 +120,8 @@ export function createPortableNativeProvider({services = []} = {}) {
             const {appDescriptor, release, signal, onEvent} = request;
             throwIfAborted(signal);
             const target = portableTarget(request.targetRequest);
-            const selectedServices = serviceSelection(services, release);
+            const localAI = appDescriptor.native?.localAI;
+            const selectedServices = serviceSelection(services ?? appDescriptor.native?.services ?? [], release);
             const eventOwnerModuleURL = eventOwnerPath(release);
             const output = await outputDirectory(request);
             throwIfAborted(signal);
@@ -130,7 +131,33 @@ export function createPortableNativeProvider({services = []} = {}) {
             const files = [];
             try {
                 await emit(onEvent, {type: 'native.payload.started', appId: appDescriptor.id, outputRoot: root});
-                await copyRelease({...request, releaseRoot: request.appReleaseRoot}, 'app', root, files, signal);
+                async function bundleSelectedRuntimes() {
+                    if (localAI === undefined) return {runtimes: [], files: []};
+                    const {bundleLocalAIRuntimes} = await import('../local-ai/install.mjs');
+                    return bundleLocalAIRuntimes({
+                        runtimes: localAI.runtimes,
+                        directory: path.join(output, 'local-ai-runtimes'),
+                        outputRoot: root,
+                        platform: target.platform === 'windows' ? 'win32' : target.platform,
+                        architecture: target.architecture,
+                        signal,
+                        onEvent
+                    });
+                }
+                // These outputs have separate directories. Join both owners
+                // before cleanup so neither can keep writing a removed assembly.
+                const preparation = await Promise.allSettled([
+                    copyRelease({...request, releaseRoot: request.appReleaseRoot}, 'app', root, files, signal),
+                    bundleSelectedRuntimes()
+                ]);
+                const failures = preparation.filter(function failedPreparation(result) { return result.status === 'rejected'; });
+                if (failures.length === 1) throw failures[0].reason;
+                if (failures.length > 1) {
+                    throw new AggregateError(failures.map(function preparationError(result) { return result.reason; }),
+                        'Portable application and local runtime preparation failed.');
+                }
+                const bundled = preparation[1].value;
+                files.push(...bundled.files);
                 const dependencies = [];
                 for (const [index, dependency] of (request.dependencies ?? []).entries()) {
                     const directory = `dependencies/${index}`;
@@ -155,8 +182,9 @@ export function createPortableNativeProvider({services = []} = {}) {
                     appSdk = {name: metadata.name, version: metadata.version, root: destination};
                 }
                 await writeOutput(root, 'package.json', '{"type":"module"}\n', files, signal);
-                await writeOutput(root, 'runtime/arcane-core.mjs', coreEntrySource(appDescriptor, sdk.version, selectedServices), files, signal);
-                await writeOutput(root, 'runtime/arcane-api.js', await createCoreClassicSource({eventOwnerModuleURL}), files, signal);
+                await writeOutput(root, 'runtime/arcane-core.mjs', coreEntrySource(appDescriptor, sdk.version, selectedServices,
+                    {localAI, runtimes: bundled.runtimes}), files, signal);
+                await writeOutput(root, 'runtime/arcane-api.js', await createCoreClassicSource({eventOwnerModuleURL, replayRuntimeState: true}), files, signal);
                 const manifest = {
                     schemaVersion: 1,
                     kind: 'arcane-portable-native',
@@ -166,8 +194,11 @@ export function createPortableNativeProvider({services = []} = {}) {
                     target,
                     webRoot: 'app',
                     start: release.manifest?.app?.start ?? './index.html',
-                    core: {entry: 'runtime/arcane-core.mjs', transport: 'stdio', protocol: 'arcane/1', services: selectedServices},
-                    client: {source: 'runtime/arcane-api.js', injection: 'document-created', eventOwnerModuleURL},
+                    core: {
+                        entry: 'runtime/arcane-core.mjs', transport: 'stdio', protocol: 'arcane/1', services: selectedServices,
+                        ...(localAI === undefined ? {} : {localAIRuntimes: bundled.runtimes})
+                    },
+                    client: {source: 'runtime/arcane-api.js', injection: 'document-created', eventOwnerModuleURL, replayRuntimeState: true},
                     dependencies,
                     minimumCoreVersion: request.minimumCoreVersion ?? null,
                     files: [...files, MANIFEST]

package/src/native/windows-provider.mjs

@@ -0,0 +1,262 @@
+import {createWriteStream} from 'node:fs';
+import {mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {Readable} from 'node:stream';
+import {pipeline} from 'node:stream/promises';
+import Is from 'strong-type';
+import {ArcaneError, ERROR_CODES, throwIfAborted} from '../errors.mjs';
+import {runProcess} from '../process.mjs';
+import {createPortableNativeProvider} from './portable-provider.mjs';
+import {writeOutput} from './portable-layout.mjs';
+
+const is = new Is(false);
+const PROTOCOL = 'arcane-native-builder/1';
+const MANIFEST = 'arcane-native.json';
+const HOST_ASSET = 'arcane-native-windows-x64.tar.gz';
+const HOST_FILES = [
+    'Arcane.exe',
+    'Arcane.exe.config',
+    'Microsoft.Web.WebView2.Core.dll',
+    'Microsoft.Web.WebView2.WinForms.dll',
+    'WebView2Loader.dll',
+    'runtime/ArcaneCore.exe',
+    'runtime/arcane-core-loader.cjs',
+    'runtime/NODE-LICENSE',
+    'WEBVIEW2-LICENSE',
+    'LICENSE',
+    'COMMERCIAL-LICENSE.md',
+    'NOTICE'
+];
+
+function windowsTarget(value) {
+    if (value?.target !== 'windows-x64' || value.platform !== 'windows'
+        || value.architecture !== 'x64' || value.format !== 'exe') {
+        throw new ArcaneError(ERROR_CODES.targetUnavailable, 'The Windows provider assembles windows-x64 executables.');
+    }
+    return {...value};
+}
+
+function portableRequest(target) {
+    return {...target, target: 'portable', format: 'portable'};
+}
+
+async function emit(onEvent, event) {
+    if (is.function(onEvent)) await onEvent(event);
+}
+
+async function hostFilesMissing(directory) {
+    const missing = [];
+    for (const relative of HOST_FILES) {
+        try {
+            if (!(await stat(path.join(directory, relative))).isFile()) missing.push(relative);
+        } catch (error) {
+            if (error.code !== 'ENOENT') throw error;
+            missing.push(relative);
+        }
+    }
+    return missing;
+}
+
+async function requireHostDirectory(directory) {
+    const resolved = await realpath(directory);
+    const missing = await hostFilesMissing(resolved);
+    if (missing.length) {
+        throw new ArcaneError(ERROR_CODES.prerequisiteMissing, 'The selected Windows host assets are incomplete.', {
+            details: {hostDirectory: resolved, missing}
+        });
+    }
+    return resolved;
+}
+
+async function removeOwnedDirectory(directory, error) {
+    try { await rm(directory, {recursive: true, force: true}); }
+    catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], `Windows preparation failed; incomplete output remains at ${directory}.`);
+    }
+    throw error;
+}
+
+async function releasedHostDirectory(outputRoot, version, {signal, onEvent}) {
+    const cache = path.join(outputRoot, '.arcane-native-hosts', version);
+    const destination = path.join(cache, 'windows-x64');
+    try { return await requireHostDirectory(destination); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    throwIfAborted(signal);
+    await mkdir(cache, {recursive: true});
+    const temporary = await mkdtemp(path.join(cache, 'preparing-windows-x64-'));
+    const archive = path.join(temporary, HOST_ASSET);
+    const extracted = path.join(temporary, 'host');
+    const url = `https://github.com/TheWizardNexus/arcane-os-sdk/releases/download/${version}/${HOST_ASSET}`;
+    try {
+        await emit(onEvent, {type: 'native.host.download.started', target: 'windows-x64', version, url});
+        throwIfAborted(signal);
+        const response = await fetch(url, {signal});
+        if (!response.ok) {
+            throw new ArcaneError(ERROR_CODES.prerequisiteMissing, `The SDK Windows host download returned HTTP ${response.status}.`, {
+                details: {url, status: response.status, response: await response.text()}
+            });
+        }
+        if (!response.body) throw new ArcaneError(ERROR_CODES.operationFailed, 'The SDK Windows host download returned no content.', {details: {url}});
+        await pipeline(Readable.fromWeb(response.body), createWriteStream(archive, {flags: 'wx'}), {signal});
+        throwIfAborted(signal);
+        await mkdir(extracted);
+        await runProcess('tar', ['-xzf', archive, '-C', extracted], {cwd: temporary, signal, onEvent});
+        await requireHostDirectory(extracted);
+        throwIfAborted(signal);
+        try { await rename(extracted, destination); }
+        catch (error) {
+            // Another preparation may have finished this exact version while
+            // this download was in flight. Preserve its complete asset tree.
+            if (!['EEXIST', 'ENOTEMPTY', 'EPERM'].includes(error.code)) throw error;
+            try { await requireHostDirectory(destination); }
+            catch { throw error; }
+        }
+        await rm(temporary, {recursive: true, force: true});
+        await emit(onEvent, {type: 'native.host.download.completed', target: 'windows-x64', version, hostDirectory: destination});
+        throwIfAborted(signal);
+        return destination;
+    } catch (error) {
+        return removeOwnedDirectory(temporary, error);
+    }
+}
+
+function contains(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`));
+}
+
+async function copyHostAssets(source, root, files, signal, relative = '', ancestors = new Set()) {
+    throwIfAborted(signal);
+    const canonical = await realpath(source);
+    const output = await realpath(root);
+    if (contains(canonical, output) || contains(output, canonical) || ancestors.has(canonical)) {
+        throw new ArcaneError(ERROR_CODES.usage, 'Windows host assets overlap their output or contain a directory cycle.', {
+            details: {source, outputRoot: root}
+        });
+    }
+    const parents = new Set([...ancestors, canonical]);
+    for (const entry of await readdir(source, {withFileTypes: true})) {
+        throwIfAborted(signal);
+        const selected = path.join(source, entry.name);
+        const destination = relative ? `${relative}/${entry.name}` : entry.name;
+        const information = await stat(selected);
+        if (information.isDirectory()) {
+            await mkdir(path.join(root, destination), {recursive: true});
+            await copyHostAssets(selected, root, files, signal, destination, parents);
+        } else if (information.isFile()) {
+            await writeOutput(root, destination, await readFile(selected, {signal}), files, signal);
+        } else {
+            throw new ArcaneError(ERROR_CODES.operationFailed, `Cannot copy Windows host asset ${selected}.`);
+        }
+    }
+}
+
+/** Compose app-owned services with the SDK's precompiled Windows host. */
+export function createWindowsNativeProvider({services, hostDirectory} = {}) {
+    const portable = createPortableNativeProvider(services === undefined ? {} : {services});
+    return {
+        protocol: PROTOCOL,
+        async describe() {
+            return {
+                protocol: PROTOCOL,
+                id: 'arcane-sdk-windows-x64',
+                targets: ['windows-x64'],
+                executable: true,
+                serviceConfiguration: 'explicit release module factories'
+            };
+        },
+        async doctor({targetRequest, signal, onEvent} = {}) {
+            throwIfAborted(signal);
+            const target = windowsTarget(targetRequest);
+            const core = await portable.doctor({targetRequest: portableRequest(target), signal});
+            const missing = hostDirectory === undefined ? [] : await hostFilesMissing(path.resolve(hostDirectory));
+            const result = {
+                target: 'windows-x64', executable: true, ready: core.ready && missing.length === 0,
+                sdkRoot: core.sdkRoot, missing: [...core.missing, ...missing],
+                hostDirectory: hostDirectory === undefined ? null : path.resolve(hostDirectory),
+                hostSource: hostDirectory === undefined ? 'sdk-release' : 'selected-directory',
+                downloadRequired: hostDirectory === undefined,
+                runtimePrerequisite: 'Microsoft Edge WebView2 Runtime',
+                buildPrerequisite: hostDirectory === undefined ? 'tar' : null
+            };
+            await emit(onEvent, {type: 'native.doctor.completed', ...result});
+            throwIfAborted(signal);
+            return result;
+        },
+        async prepare({targetRequest, signal, onEvent} = {}) {
+            throwIfAborted(signal);
+            const target = windowsTarget(targetRequest);
+            const selection = await portable.prepare({targetRequest: portableRequest(target), signal});
+            const selected = hostDirectory === undefined ? undefined : await requireHostDirectory(hostDirectory);
+            // Downloads belong to build(), which has the caller's selected
+            // outputRoot. Preparation never invents a machine-wide cache.
+            const result = {...selection, target, executable: true, ...(selected ? {hostDirectory: selected} : {})};
+            await emit(onEvent, {type: 'native.prepared', target: 'windows-x64', sdkVersion: selection.sdkVersion});
+            throwIfAborted(signal);
+            return result;
+        },
+        async build(request = {}) {
+            const {signal, onEvent} = request;
+            throwIfAborted(signal);
+            const target = windowsTarget(request.targetRequest);
+            const selected = hostDirectory ?? request.toolchain?.hostDirectory;
+            const selectedHost = selected === undefined ? null : await requireHostDirectory(selected);
+            const artifact = await portable.build({
+                ...request,
+                targetRequest: portableRequest(target),
+                async onEvent(event) {
+                    if (event.type !== 'native.payload.completed') await emit(onEvent, {...event, target: 'windows-x64'});
+                }
+            });
+            const root = artifact.target.rootDir;
+            try {
+                const host = selectedHost ?? await releasedHostDirectory(path.resolve(request.outputRoot), artifact.manifest.sdk.version, {signal, onEvent});
+                const files = [...artifact.manifest.files];
+                await copyHostAssets(host, root, files, signal);
+                const manifest = {
+                    ...artifact.manifest,
+                    kind: 'arcane-windows-native',
+                    target,
+                    host: {
+                        executable: 'Arcane.exe',
+                        platform: 'windows', architecture: 'x64', runtime: 'webview2',
+                        coreExecutable: 'runtime/ArcaneCore.exe',
+                        coreLoader: 'runtime/arcane-core-loader.cjs'
+                    },
+                    files
+                };
+                await writeFile(path.join(root, MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`, {signal});
+                throwIfAborted(signal);
+                await emit(onEvent, {type: 'native.payload.completed', target: 'windows-x64', appId: request.appDescriptor.id, outputRoot: root});
+                throwIfAborted(signal);
+                return {...artifact, target: {...target, rootDir: root}, manifest};
+            } catch (error) {
+                return removeOwnedDirectory(root, error);
+            }
+        },
+        async verify({artifact, targetRequest, signal, onEvent} = {}) {
+            throwIfAborted(signal);
+            const target = windowsTarget(targetRequest);
+            const result = await portable.verify({artifact, targetRequest: portableRequest(target), signal});
+            await requireHostDirectory(result.outputRoot);
+            const verified = {...result, target: 'windows-x64', executable: true};
+            await emit(onEvent, {type: 'native.verified', target: 'windows-x64', outputRoot: result.outputRoot});
+            throwIfAborted(signal);
+            return verified;
+        },
+        async run({artifact, targetRequest, signal, onEvent} = {}) {
+            throwIfAborted(signal);
+            windowsTarget(targetRequest);
+            if (process.platform !== 'win32' || process.arch !== 'x64') {
+                throw new ArcaneError(ERROR_CODES.nativeRunUnsupported, 'Running this Windows x64 artifact requires a Windows x64 host.');
+            }
+            const root = await requireHostDirectory(artifact?.target?.rootDir);
+            return runProcess(path.join(root, 'Arcane.exe'), ['--close-on-stdin-eof'], {
+                cwd: root, signal, onEvent, cancellationMode: 'close-input'
+            });
+        }
+    };
+}
+
+export const arcaneNativeBuilderProvider = createWindowsNativeProvider();
+export default arcaneNativeBuilderProvider;

package/src/native-provider-loader.mjs

@@ -22,6 +22,11 @@ const FIXED_NATIVE_PROVIDER_PATHS={
     'android-arm64':providerPath('android-native-provider.mjs')
 };
 
+const SDK_NATIVE_PROVIDER_PATHS={
+    portable:'./native/portable-provider.mjs',
+    'windows-x64':'./native/windows-provider.mjs'
+};
+
 export const ARCANE_NATIVE_PROVIDER_PATHS={
     portable:[...FIXED_NATIVE_PROVIDER_PATHS.portable],
     'windows-x64':[...FIXED_NATIVE_PROVIDER_PATHS['windows-x64']],
@@ -133,10 +138,11 @@ export async function loadArcaneNativeProvider(options={}){
         target,
         message:`Loading the Arcane ${String(target)} provider.`
     });
-    const location=arcaneRoot===undefined&&target==='portable'
+    const sdkProvider=SDK_NATIVE_PROVIDER_PATHS[target];
+    const location=arcaneRoot===undefined&&sdkProvider
         ?{
             canonicalRoot:path.resolve(fileURLToPath(new URL('../',import.meta.url))),
-            providerPath:fileURLToPath(new URL('./native/portable-provider.mjs',import.meta.url)),
+            providerPath:fileURLToPath(new URL(sdkProvider,import.meta.url)),
             providerSource:'sdk-package'
         }
         :await resolveProviderLocation({arcaneRoot,target,inspect,canonicalize});

package/src/packager/core.mjs

@@ -13,6 +13,8 @@ import {
 import path from 'node:path';
 import {pathToFileURL} from 'node:url';
 import {appRelativeRoot,resolveAppRoot,resolvePackageOutputRoot} from '../app-layout.mjs';
+import {TARGET_IDS} from '../constants.mjs';
+import {normalizeLocalAIConfig} from '../local-ai/config.mjs';
 import {readInstalledSdkLayout} from '../sdk-runtime-layout.mjs';
 import {withWorkspaceOperationLock} from '../workspace-operation-lock.mjs';
 import {materializeNativeModules} from './native-modules.mjs';
@@ -320,7 +322,7 @@ function normalizeOptionalRecord(value,label){
 export function validateAppConfig(value,appId,rootConfig,configPath=path.posix.join(appRelativeRoot(rootConfig,appId),APP_CONFIG_NAME)){
     assertOnlyKeys(value,new Set([
         'schemaVersion','id','displayName','version','entry','strategy','security',
-        'localAIModelPolicy','include','exclude','shared','adapter','pwa','outputDirectory','documents'
+        'localAIModelPolicy','localAI','include','exclude','shared','adapter','pwa','outputDirectory','documents','nativeResources'
     ]),`${appId}/${APP_CONFIG_NAME}`);
     if(value.schemaVersion!==1)fail(`${appId}/${APP_CONFIG_NAME}.schemaVersion must be 1.`);
     if(!is.string(value.id)||value.id!==appId||!APP_ID_PATTERN.test(value.id)){
@@ -335,6 +337,15 @@ export function validateAppConfig(value,appId,rootConfig,configPath=path.posix.j
     );
     const include=validatePathList(value.include,`${appId}/${APP_CONFIG_NAME}.include`,{required:true});
     const exclude=validatePathList(value.exclude??[],`${appId}/${APP_CONFIG_NAME}.exclude`);
+    let nativeResources;
+    if(value.nativeResources!==undefined){
+        const label=`${appId}/${APP_CONFIG_NAME}.nativeResources`;
+        assertOnlyKeys(value.nativeResources,new Set(['include','exclude']),label);
+        nativeResources={
+            include:validatePathList(value.nativeResources.include,`${label}.include`),
+            exclude:validatePathList(value.nativeResources.exclude??[],`${label}.exclude`)
+        };
+    }
     if(include.some(allowed=>sameOrDescendant(APP_CONFIG_NAME,allowed))){
         fail(`${appId}/${APP_CONFIG_NAME}.include must not expose the authored package configuration.`);
     }
@@ -380,8 +391,10 @@ export function validateAppConfig(value,appId,rootConfig,configPath=path.posix.j
             value.localAIModelPolicy,
             `${appId}/${APP_CONFIG_NAME}.localAIModelPolicy`
         )}),
+        ...(value.localAI===undefined?{}:{localAI:normalizeLocalAIConfig(value.localAI)}),
         include,
         exclude,
+        ...(nativeResources===undefined?{}:{nativeResources}),
         shared:[...value.shared],
         ...(adapter===undefined?{}:{adapter}),
         configPath
@@ -423,7 +436,8 @@ async function assertContainedRealPath(root,candidate,label){
     }
 }
 
-async function loadContext(requestedWorkspaceRoot,appId,{outputDirectory}={}){
+async function loadContext(requestedWorkspaceRoot,appId,{outputDirectory,target='browser'}={}){
+    if(!TARGET_IDS.includes(target))fail(`Unsupported package target: ${String(target)}.`);
     const workspaceRoot=await realDirectory(normalizeWorkspaceRoot(requestedWorkspaceRoot),'Workspace root');
     const rootConfigPath=path.join(workspaceRoot,ROOT_CONFIG_NAME);
     const rootConfig=validateRootConfig(await readJson(rootConfigPath,ROOT_CONFIG_NAME),rootConfigPath);
@@ -436,14 +450,19 @@ async function loadContext(requestedWorkspaceRoot,appId,{outputDirectory}={}){
     if(outputDirectory!==undefined){
         config.outputDirectory=normalizeRelativePath(outputDirectory,'package outputDirectory');
     }
+    const outputRoot=resolvePackageOutputRoot(workspaceRoot,rootConfig,config,{target,outputDirectory});
+    if(target!=='browser'&&config.nativeResources?.include.length>0){
+        config.outputDirectory=path.relative(workspaceRoot,outputRoot).split(path.sep).join('/');
+    }
     return {
         workspaceRoot,
         rootConfig,
         appsRoot,
         appRoot,
         appId,
+        target,
         config,
-        outputRoot:resolvePackageOutputRoot(workspaceRoot,rootConfig,config)
+        outputRoot
     };
 }
 
@@ -494,6 +513,11 @@ async function assertPackageOutputLocation(context){
     for(const selected of context.config.include){
         assertSelectedInput(context.appRoot,selected,context.config.exclude,context.appId);
     }
+    if(context.target!=='browser'&&context.config.nativeResources){
+        for(const selected of context.config.nativeResources.include){
+            assertSelectedInput(context.appRoot,selected,context.config.nativeResources.exclude,`${context.appId} native`);
+        }
+    }
     for(const sharedId of context.config.shared){
         for(const route of context.rootConfig.sharedPayloads[sharedId]){
             const sourceRoot=path.resolve(context.workspaceRoot,route.source);
@@ -526,6 +550,7 @@ async function collectSelectedPath({
     reject,
     records,
     destinations,
+    coalescedRecords,
     signal,
     label,
     allowRoot=false
@@ -555,6 +580,7 @@ async function collectSelectedPath({
                 reject,
                 records,
                 destinations,
+                coalescedRecords,
                 signal,
                 label
             });
@@ -567,9 +593,15 @@ async function collectSelectedPath({
         fail(`${label} overlaps the generated release manifest.`);
     }
     const key=pathKey(normalizedDestination);
-    if(destinations.has(key))fail(`Package destination collision: ${normalizedDestination}.`);
+    if(destinations.has(key)){
+        const existing=coalescedRecords?.get(key);
+        if(existing?.source===absolute&&existing.destination===normalizedDestination)return;
+        fail(`Package destination collision: ${normalizedDestination}.`);
+    }
     destinations.add(key);
-    records.push({source:absolute,destination:normalizedDestination});
+    const record={source:absolute,destination:normalizedDestination};
+    records.push(record);
+    coalescedRecords?.set(key,record);
 }
 
 async function collectPackageRecords(context,{signal}={}){
@@ -613,6 +645,29 @@ async function collectPackageRecords(context,{signal}={}){
             }
         }
     }
+    if(context.target!=='browser'&&context.config.nativeResources){
+        const nativeRecords=[];
+        const coalescedRecords=new Map(records.map(record=>[pathKey(record.destination),record]));
+        for(const selected of context.config.nativeResources.include){
+            await collectSelectedPath({
+                sourceRoot:context.appRoot,
+                selected,
+                destination:appPackagePath(context,selected),
+                excludes:context.config.nativeResources.exclude,
+                reject:isAppSourceForbidden,
+                records:nativeRecords,
+                destinations,
+                coalescedRecords,
+                signal,
+                label:`${context.appId} nativeResources`
+            });
+        }
+        for(const record of nativeRecords){
+            record.appRelativePath=path.relative(context.appRoot,record.source).split(path.sep).join('/');
+            record.nativeOnly=true;
+            records.push(record);
+        }
+    }
     records.sort((left,right)=>compareText(left.destination,right.destination));
     if(!records.some(record=>pathKey(record.destination)===pathKey(appPackagePath(context, context.config.entry)))){
         fail(`Package entry is missing from the selected files: ${context.config.entry}.`);
@@ -671,7 +726,7 @@ async function optionalDescriptor(context){
 
 async function inspectContext(context,{signal,records}={}){
     const selectedRecords=records??await collectPackageRecords(context,{signal});
-    const documents=await browserDocuments(selectedRecords,context.config.entry,context.config.documents);
+    const documents=await browserDocuments(selectedRecords.filter(record=>!record.nativeOnly),context.config.entry,context.config.documents);
     return {
         appId:context.appId,
         displayName:context.config.displayName,
@@ -683,11 +738,13 @@ async function inspectContext(context,{signal,records}={}){
         ...(context.config.pwa===undefined?{}:{pwa:copyJson(context.config.pwa)}),
         include:[...context.config.include],
         exclude:[...context.config.exclude],
+        ...(context.config.nativeResources===undefined?{}:{nativeResources:copyJson(context.config.nativeResources)}),
         shared:[...context.config.shared],
         ...(context.config.security===undefined?{}:{security:copyJson(context.config.security)}),
         ...(context.config.localAIModelPolicy===undefined?{}:{
             localAIModelPolicy:copyJson(context.config.localAIModelPolicy)
         }),
+        ...(context.config.localAI===undefined?{}:{localAI:copyJson(context.config.localAI)}),
         ...(context.config.adapter===undefined?{}:{adapter:context.config.adapter}),
         descriptor:await optionalDescriptor(context),
         browserDocuments:documents,
@@ -724,9 +781,9 @@ export async function discoverApps({workspaceRoot:requestedWorkspaceRoot}={}){
     return apps;
 }
 
-export async function inspectApp({workspaceRoot,appId,signal}={}){
+export async function inspectApp({workspaceRoot,appId,signal,target,outputDirectory}={}){
     throwIfAborted(signal);
-    const context=await loadContext(workspaceRoot,appId);
+    const context=await loadContext(workspaceRoot,appId,{target,outputDirectory});
     return inspectContext(context,{signal});
 }
 
@@ -817,7 +874,8 @@ function releaseManifest(context,files,pwaArtifacts,rootDocument){
             ...(context.config.security===undefined?{}:{security:copyJson(context.config.security)}),
             ...(context.config.localAIModelPolicy===undefined?{}:{
                 localAIModelPolicy:copyJson(context.config.localAIModelPolicy)
-            })
+            }),
+            ...(context.config.localAI===undefined?{}:{localAI:copyJson(context.config.localAI)})
         },
         files:[...files]
     };
@@ -846,7 +904,8 @@ async function replaceDirectory(stagingRoot,outputRoot){
 }
 
 async function packageWithContext(context,options={}){
-    const {signal,onEvent,browserPwa=true,moduleFormat='import-map'}=options;
+    const {signal,onEvent,moduleFormat='import-map',browserPwa:requestedBrowserPwa=true}=options;
+    const browserPwa=context.target==='browser'&&requestedBrowserPwa;
     if(!['import-map','native'].includes(moduleFormat)){
         throw new TypeError('packageApp moduleFormat must be "import-map" or "native".');
     }
@@ -854,7 +913,9 @@ async function packageWithContext(context,options={}){
     const appPath=appRelativeRoot(context.rootConfig,context.appId);
     const entryPath=appPackagePath(context,context.config.entry);
     const records=await collectPackageRecords(context,{signal});
-    const rootDocument = records.some(
+    const browserRecords=records.filter(record=>!record.nativeOnly);
+    const nativeRecords=records.filter(record=>record.nativeOnly);
+    const rootDocument = browserRecords.some(
         function selectedRootIndex(record) {
             return record.destination === 'index.html';
         }
@@ -901,7 +962,7 @@ async function packageWithContext(context,options={}){
     let promoted=false;
     try{
         async function copyBase() {
-            await copyRecords(records,stagingRoot,{signal,onEvent});
+            await copyRecords(browserRecords,stagingRoot,{signal,onEvent});
             if (!rootDocument) {
                 await writePackageLauncher(context, stagingRoot);
             }
@@ -913,6 +974,8 @@ async function packageWithContext(context,options={}){
                 workspaceRoot:context.workspaceRoot,
                 appRoot:context.appRoot,
                 outputRoot:stagingRoot,
+                target:context.target,
+                browserPwa,
                 copyBase,
                 signal,
                 onEvent
@@ -971,7 +1034,7 @@ async function packageWithContext(context,options={}){
                 stagingRoot,
                 files,
                 documents:inspected.browserDocuments.map(function documentPath(document){return document.packagePath;}),
-                sharedFiles:records.filter(function sharedRecord(record){return record.appRelativePath===undefined;})
+                sharedFiles:browserRecords.filter(function sharedRecord(record){return record.appRelativePath===undefined;})
                     .map(function sharedPath(record){return record.destination;}),
                 signal,
                 onEvent
@@ -1007,8 +1070,8 @@ async function packageWithContext(context,options={}){
         const documentUrl=entryDocument?.bases[0]?.href
             ?new URL(entryDocument.bases[0].href,entryUrl):entryUrl;
         const pending=[{file:entryPath,documentUrl}];
-        const sharedFiles=new Set(records.filter(record=>record.appRelativePath===undefined).map(record=>record.destination));
-        const applicationFiles=new Set(records.filter(function applicationRecord(record){
+        const sharedFiles=new Set(browserRecords.filter(record=>record.appRelativePath===undefined).map(record=>record.destination));
+        const applicationFiles=new Set(browserRecords.filter(function applicationRecord(record){
             return record.appRelativePath!==undefined;
         }).map(function applicationDestination(record){return record.destination;}));
         for(const file of files){
@@ -1132,6 +1195,17 @@ async function packageWithContext(context,options={}){
             }
             files.sort(compareText);
         }
+        // Native resources bypass browser rewriting, module projection and PWA generation.
+        // The app's browser selection remains authoritative wherever both select a file.
+        const finalDestinations=new Set(files.map(pathKey));
+        for(const record of nativeRecords){
+            if(finalDestinations.has(pathKey(record.destination))){
+                fail(`Native resource overlaps generated package content: ${record.destination}.`);
+            }
+        }
+        await copyRecords(nativeRecords,stagingRoot,{signal,onEvent});
+        files.push(...nativeRecords.map(record=>record.destination));
+        files.sort(compareText);
         const manifest=releaseManifest(context,files,pwaArtifacts,rootDocument);
         await writeFile(
             path.join(stagingRoot,RELEASE_MANIFEST_NAME),