arcane-os 0.56.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

@@ -14,6 +14,7 @@ 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';
@@ -321,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','nativeResources'
+        '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)){
@@ -390,6 +391,7 @@ 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}),
@@ -742,6 +744,7 @@ async function inspectContext(context,{signal,records}={}){
         ...(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,
@@ -871,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]
     };

package/src/process.mjs

@@ -124,12 +124,16 @@ export async function runProcess(command,args=[],{
     heartbeatMs=5000,
     terminationGraceMs=DEFAULT_TERMINATION_GRACE_MS,
     allowNonzero=false,
-    input
+    input,
+    cancellationMode='terminate-tree'
 }={}){
     throwIfAborted(signal);
     if(!is.array(args)||args.some(argument=>!is.string(argument))){
         throw new ArcaneError(ERROR_CODES.usage,'Process arguments must be a fixed array of strings.');
     }
+    if(cancellationMode!=='terminate-tree'&&cancellationMode!=='close-input'){
+        throw new ArcaneError(ERROR_CODES.usage,'Unknown process cancellation mode.');
+    }
     if(!is.integer(terminationGraceMs)||terminationGraceMs<100||terminationGraceMs>30_000){
         throw new ArcaneError(
             ERROR_CODES.usage,
@@ -153,12 +157,15 @@ export async function runProcess(command,args=[],{
     return new Promise((resolve,reject)=>{
         let stdout='';
         let stderr='';
+        let childClosed=false;
+        let closedResult=null;
         let settlementStarted=false;
         let cancellationRequested=false;
         let cancellationError=null;
         let terminationRequested=false;
         let escalation=null;
         let spawnError=null;
+        let inputError=null;
         let child;
         let heartbeat=null;
         const deliveries=new Set();
@@ -184,9 +191,37 @@ export async function runProcess(command,args=[],{
             clearTimeout(escalation);
             signal?.removeEventListener('abort',abort);
             void (async()=>{
+                let callbackFailure=null;
                 try{
                     await events.drain();
-                }catch(callbackFailure){
+                }catch(error){
+                    callbackFailure=error;
+                }
+                if(cancellationMode==='close-input'&&closedResult){
+                    const failures=[...new Set([
+                        callback===reject?value:null,
+                        callbackFailure,inputError,cancellationError,spawnError
+                    ].filter(error=>error!==null))];
+                    if(failures.length>0){
+                        const primary=failures[0];
+                        // Owned cancellation/exit errors already carry this exact
+                        // result. Other errors retain their identity and cause in
+                        // the complete failure record instead of being rewritten.
+                        if(failures.length===1&&primary?.details===closedResult){
+                            reject(primary);
+                            return;
+                        }
+                        const failure=new ArcaneError(
+                            primary?.code??ERROR_CODES.operationFailed,
+                            primary?.message??`Could not complete ${command}.`,
+                            {cause:primary,details:closedResult,exitCode:primary?.exitCode}
+                        );
+                        failure.errors=failures;
+                        reject(failure);
+                        return;
+                    }
+                }
+                if(callbackFailure){
                     reject(callbackFailure);
                     return;
                 }
@@ -195,10 +230,16 @@ export async function runProcess(command,args=[],{
         };
 
         const stopTree=()=>{
-            if(terminationRequested||settlementStarted){
+            if(terminationRequested||settlementStarted||childClosed){
                 return;
             }
             terminationRequested=true;
+            if(cancellationMode==='close-input'){
+                // The selected host owns shutdown after EOF. Keep observing its
+                // complete output and exit; accepted durable work may outlive UI.
+                child?.stdin.end();
+                return;
+            }
             terminateProcessTree(child);
             escalation=setTimeout(()=>{
                 if(childIsRunning(child)){
@@ -214,7 +255,7 @@ export async function runProcess(command,args=[],{
         };
 
         const abort=()=>{
-            if(cancellationRequested||settlementStarted){
+            if(cancellationRequested||settlementStarted||childClosed){
                 return;
             }
             cancellationRequested=true;
@@ -225,7 +266,9 @@ export async function runProcess(command,args=[],{
             );
             void events.enqueue({
                 type:'process.cancellation.requested',
-                message:`Stopping ${command} and its child processes.`,
+                message:cancellationMode==='close-input'
+                    ?`Closing ${command} input and waiting for its owned shutdown.`
+                    :`Stopping ${command} and its child processes.`,
                 data:{command,pid:child?.pid??null}
             });
             stopTree();
@@ -286,6 +329,10 @@ export async function runProcess(command,args=[],{
             }
         });
         child.on('close',(code,terminationSignal)=>{
+            // The child lifetime has ended even while its output/event callbacks
+            // are still draining. A later abort cannot cancel that completed work.
+            childClosed=true;
+            signal?.removeEventListener('abort',abort);
             clearInterval(heartbeat);
             void (async()=>{
                 await drainDeliveries();
@@ -299,10 +346,11 @@ export async function runProcess(command,args=[],{
                     stdout,
                     stderr
                 };
+                closedResult=result;
                 if(terminationRequested){
                     // The direct child has exited. Make one final tree-wide attempt so
                     // a descendant that ignored the graceful request cannot outlive it.
-                    terminateProcessTree(child,{force:true});
+                    if(cancellationMode!=='close-input')terminateProcessTree(child,{force:true});
                     if(cancellationRequested){
                         await events.enqueue({
                             type:'process.cancelled',
@@ -310,7 +358,8 @@ export async function runProcess(command,args=[],{
                             data:{command,code:result.code,signal:terminationSignal}
                         });
                     }
-                    finish(reject,events.error??cancellationError??new ArcaneError(
+                    if(cancellationError)cancellationError.details=result;
+                    finish(reject,events.error??inputError??cancellationError??new ArcaneError(
                         ERROR_CODES.operationFailed,
                         `Stopped ${command} after its event callback failed.`
                     ));
@@ -324,6 +373,12 @@ export async function runProcess(command,args=[],{
                     ));
                     return;
                 }
+                if(inputError){
+                    finish(reject,new ArcaneError(ERROR_CODES.operationFailed,
+                        `Could not write ${command} input: ${inputError.message}`,
+                        {cause:inputError,details:result}));
+                    return;
+                }
                 await events.enqueue({
                     type:'process.completed',
                     message:`${command} exited with code ${String(result.code)}.`,
@@ -346,7 +401,10 @@ export async function runProcess(command,args=[],{
             abort();
         }
 
-        if(input!==undefined){
+        if(cancellationMode==='close-input'){
+            child.stdin.on('error',error=>{inputError=error;stopTree();});
+            if(input!==undefined&&!terminationRequested)child.stdin.write(input);
+        }else if(input!==undefined){
             child.stdin.end(input);
         }else{
             child.stdin.end();

package/src/toolchain.mjs

@@ -1,6 +1,6 @@
 import Is from 'strong-type';
 import path from 'node:path';
-import {resolvePackageOutputRoot} from './app-layout.mjs';
+import {resolveAppRoot,resolvePackageOutputRoot} from './app-layout.mjs';
 import {readdir,lstat,realpath,mkdir,readFile,writeFile} from 'node:fs/promises';
 import {createWorkspace,initWorkspace} from './scaffold.mjs';
 import {
@@ -17,6 +17,8 @@ import {createPwaArtifacts} from './pwa.mjs';
 import {readInstalledSdkLayout} from './sdk-runtime-layout.mjs';
 import {withWorkspaceOperationLock} from './workspace-operation-lock.mjs';
 import {refreshAppPackageProjection} from './app-descriptor.mjs';
+import {configureDevelopmentLocalAI} from './local-ai/config.mjs';
+import {createDevelopmentLocalAI} from './local-ai/dev.mjs';
 import {
     discoverApps as discoverPackagerApps,
     inspectApp as inspectPackagedApp,
@@ -566,6 +568,11 @@ export async function developApplication(options = {}) {
             onEvent: options.onEvent
         },
         async function refreshDevelopmentWorkspace(workspaceOperationLease) {
+            await configureDevelopmentLocalAI({
+                appRoot: resolveAppRoot(profile.workspaceRoot, profile.config, appId),
+                runtimes: options.localAI,
+                signal: options.signal
+            });
             await refreshAppPackageProjection(
                 {
                     workspaceRoot: profile.workspaceRoot,
@@ -589,7 +596,19 @@ export async function developApplication(options = {}) {
             return current;
         }
     );
-    const server=await startDevServer({
+    const localAIConfig = prepared.descriptor?.native?.localAI;
+    const localAI = localAIConfig?.runtimes.length ? createDevelopmentLocalAI({
+        config: localAIConfig,
+        appRoot: prepared.appRoot,
+        directory: path.join(prepared.appRoot, '.arcane', 'local-ai', 'runtimes'),
+        application: prepared.descriptor,
+        version: prepared.descriptor.version,
+        signal: options.signal,
+        onEvent: options.onEvent
+    }) : undefined;
+    let server;
+    try {
+        server=await startDevServer({
         workspaceRoot:prepared.workspaceRoot,
         appId:prepared.appId,
         mode:'source',
@@ -605,10 +624,19 @@ export async function developApplication(options = {}) {
         tls:options.tls,
         certPath:options.certPath,
         keyPath:options.keyPath,
+        localAI,
         signal:options.signal,
         onEvent:options.onEvent
-    });
-    return {...server,appId:prepared.appId,mode:'source'};
+        });
+    } catch (error) {
+        try {
+            await localAI?.close(error);
+        } catch (closeError) {
+            throw new AggregateError([error, closeError], 'Development startup and local AI shutdown failed.');
+        }
+        throw error;
+    }
+    return {...server,appId:prepared.appId,mode:'source',...(localAI ? {localAI} : {})};
 }
 
 export async function packageApplication(options={}){
@@ -840,7 +868,7 @@ export function assertIntegratedNativeToolchain({
     workspaceMode,workspaceRoot,toolchainRoot,target,providerSource='arcane-checkout'
 }={}){
     if(workspaceMode!=='integrated')return;
-    if(providerSource==='sdk-package'&&target==='portable')return;
+    if(providerSource==='sdk-package'&&(target==='portable'||target==='windows-x64'))return;
     if(!is.string(toolchainRoot)||!sameCanonicalPath(workspaceRoot,toolchainRoot)){
         throw new ArcaneError(
             ERROR_CODES.policyDenied,