arcane-os 0.57.0 → 0.59.0

package/src/native/portable-layout.mjs

@@ -149,7 +149,7 @@ export async function copyCoreRuntime(root, files, signal, {
     return metadata;
 }
 
-export function coreEntrySource(application, version, services, {localAI, runtimes = []} = {}) {
+export function coreEntrySource(application, version, services, {localAI, runtimes = [], packagedWeb = false} = {}) {
     const imports = services.map(function serviceImport(service, index) {
         const specifier = '../app/' + service.module.split('/').map(encodeURIComponent).join('/');
         return `import createService${index} from ${JSON.stringify(specifier)};`;
@@ -162,6 +162,10 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         imports.push("import {createLocalAIService} from 'arcane-os/core/local-ai';");
         definitions.push(`    createLocalAIService(JSON.parse(${JSON.stringify(JSON.stringify(localAI))}), context)`);
     }
+    if (packagedWeb) {
+        imports.push("import {createPackagedWebService} from 'arcane-os/core/packaged-web';");
+        definitions.push("    createPackagedWebService({artifactRoot: fileURLToPath(new URL('../', import.meta.url))}, context)");
+    }
     return [
         "import {fileURLToPath} from 'node:url';",
         "import {readCoreLaunchContext, startCoreHost} from 'arcane-os/core/host';",
@@ -180,7 +184,11 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         "    appRoot: fileURLToPath(new URL('../app/', import.meta.url)),",
         ...(localAI === undefined ? [] : [
             `    runtimes: JSON.parse(${JSON.stringify(JSON.stringify(runtimes))}).map(function runtimeLocation(runtime) {`,
-            '        return {...runtime, root: runtimePath(runtime.root), executable: runtimePath(runtime.executable)};',
+            '        const resolved = {...runtime};',
+            "        for (const field of ['root', 'executable', 'modulePath', 'includeDirectory', 'libraryDirectory', 'binaryDirectory', 'cmakeDirectory']) {",
+            '            if (runtime[field] !== undefined) resolved[field] = runtimePath(runtime[field]);',
+            '        }',
+            '        return resolved;',
             '    }),'
         ]),
         '    ...await readCoreLaunchContext()',

package/src/native/portable-provider.mjs

@@ -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, packagedWeb = false, webKitDocumentLifecycle = false} = {}) {
     return {
         protocol: PROTOCOL,
         async describe() {
@@ -138,7 +138,7 @@ export function createPortableNativeProvider({services} = {}) {
                         runtimes: localAI.runtimes,
                         directory: path.join(output, 'local-ai-runtimes'),
                         outputRoot: root,
-                        platform: target.platform === 'windows' ? 'win32' : target.platform,
+                        platform: target.platform === 'windows' ? 'win32' : target.platform === 'macos' ? 'darwin' : target.platform,
                         architecture: target.architecture,
                         signal,
                         onEvent
@@ -183,8 +183,10 @@ export function createPortableNativeProvider({services} = {}) {
                 }
                 await writeOutput(root, 'package.json', '{"type":"module"}\n', 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);
+                    {localAI, runtimes: bundled.runtimes, packagedWeb}), files, signal);
+                await writeOutput(root, 'runtime/arcane-api.js', await createCoreClassicSource({
+                    eventOwnerModuleURL, replayRuntimeState: true, webKitDocumentLifecycle
+                }), files, signal);
                 const manifest = {
                     schemaVersion: 1,
                     kind: 'arcane-portable-native',
@@ -198,7 +200,10 @@ export function createPortableNativeProvider({services} = {}) {
                         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},
+                    client: {
+                        source: 'runtime/arcane-api.js', injection: 'document-created', eventOwnerModuleURL, replayRuntimeState: true,
+                        ...(webKitDocumentLifecycle ? {webKitDocumentLifecycle: true} : {})
+                    },
                     dependencies,
                     minimumCoreVersion: request.minimumCoreVersion ?? null,
                     files: [...files, MANIFEST]

package/src/native-plan.mjs

@@ -12,7 +12,7 @@ export const NATIVE_BUILDER_PROTOCOL='arcane-native-builder/1';
 
 const NATIVE_TARGETS={
     portable:{
-        platforms:new Set(['windows','linux']),
+        platforms:new Set(['windows','linux','macos']),
         architectures:new Set(['x64','arm64']),
         format:'portable',
         signingMode:'unsigned-local-test',
@@ -22,6 +22,14 @@ const NATIVE_TARGETS={
         platforms:new Set(['windows']),architectures:new Set(['x64']),format:'exe',
         signingMode:'unsigned-local-test',signingProfileId:null
     },
+    'macos-arm64':{
+        platforms:new Set(['macos']),architectures:new Set(['arm64']),format:'app',
+        signingMode:'unsigned-local-test',signingProfileId:null
+    },
+    'macos-x64':{
+        platforms:new Set(['macos']),architectures:new Set(['x64']),format:'app',
+        signingMode:'unsigned-local-test',signingProfileId:null
+    },
     'linux-x64':{
         platforms:new Set(['linux']),architectures:new Set(['x64']),format:'deb',
         signingMode:'unsigned-local-test',signingProfileId:null

package/src/native-provider-loader.mjs

@@ -24,7 +24,9 @@ const FIXED_NATIVE_PROVIDER_PATHS={
 
 const SDK_NATIVE_PROVIDER_PATHS={
     portable:'./native/portable-provider.mjs',
-    'windows-x64':'./native/windows-provider.mjs'
+    'windows-x64':'./native/windows-provider.mjs',
+    'macos-arm64':'./native/macos-provider.mjs',
+    'macos-x64':'./native/macos-provider.mjs'
 };
 
 export const ARCANE_NATIVE_PROVIDER_PATHS={

package/src/process.mjs

@@ -45,10 +45,30 @@ async function emitLines(events,type,text){
     }
 }
 
-function deliverChunk(stream,events,type,text){
+function outputSelected(option,stream){
+    return is.boolean(option)?option:option?.[stream]??true;
+}
+
+function outputEncodingSelected(option,stream){
+    const selected=option!==null&&is.object(option)?option[stream]:option;
+    const encoding=selected===undefined?'utf8':selected;
+    if(encoding!=='utf8'&&encoding!==null){
+        throw new TypeError(`The ${stream} outputEncoding must be 'utf8' or null.`);
+    }
+    return encoding;
+}
+
+function deliverChunk(stream,events,type,chunk,{onOutput,emitOutput,onFailure}){
     stream.pause();
-    return emitLines(events,type,text).catch(()=>{
-        // The queue owns and propagates the first callback failure.
+    return (async function deliverOutput(){
+        try{
+            if(onOutput)await onOutput({stream:type==='process.stdout'?'stdout':'stderr',chunk});
+        }catch(error){
+            onFailure(error);
+        }
+        if(emitOutput)await emitLines(events,type,chunk);
+    })().catch(()=>{
+        // The event queue separately owns and propagates observer failures.
     }).finally(()=>{
         if(!stream.destroyed){
             stream.resume();
@@ -121,6 +141,10 @@ export async function runProcess(command,args=[],{
     env,
     signal,
     onEvent,
+    onOutput,
+    captureOutput=true,
+    emitOutputEvents=true,
+    outputEncoding='utf8',
     heartbeatMs=5000,
     terminationGraceMs=DEFAULT_TERMINATION_GRACE_MS,
     allowNonzero=false,
@@ -128,6 +152,23 @@ export async function runProcess(command,args=[],{
     cancellationMode='terminate-tree'
 }={}){
     throwIfAborted(signal);
+    if(onOutput!==undefined&&!is.function(onOutput)){
+        throw new TypeError('onOutput must be a function.');
+    }
+    const outputEncodings={
+        stdout:outputEncodingSelected(outputEncoding,'stdout'),
+        stderr:outputEncodingSelected(outputEncoding,'stderr')
+    };
+    for(const stream of ['stdout','stderr']){
+        if(outputEncodings[stream]===null&&(!onOutput
+            ||outputSelected(captureOutput,stream)!==false
+            ||outputSelected(emitOutputEvents,stream)!==false)){
+            throw new TypeError(`Raw ${stream} requires onOutput, captureOutput:false and emitOutputEvents:false for that stream.`);
+        }
+    }
+    if(!onOutput&&(!outputSelected(captureOutput,'stdout')||!outputSelected(captureOutput,'stderr'))){
+        throw new TypeError('Uncaptured process output requires an onOutput consumer.');
+    }
     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.');
     }
@@ -155,8 +196,8 @@ export async function runProcess(command,args=[],{
     throwIfAborted(signal);
 
     return new Promise((resolve,reject)=>{
-        let stdout='';
-        let stderr='';
+        let stdout=outputEncodings.stdout!==null&&outputSelected(captureOutput,'stdout')?'':null;
+        let stderr=outputEncodings.stderr!==null&&outputSelected(captureOutput,'stderr')?'':null;
         let childClosed=false;
         let closedResult=null;
         let settlementStarted=false;
@@ -166,12 +207,28 @@ export async function runProcess(command,args=[],{
         let escalation=null;
         let spawnError=null;
         let inputError=null;
+        let inputIterator=null;
+        let inputPump=null;
+        let inputReturn=null;
+        let inputDone=false;
+        const outputErrors=[];
         let child;
         let heartbeat=null;
         const deliveries=new Set();
 
         const ownDelivery=(stream,type,chunk)=>{
-            const delivery=deliverChunk(stream,events,type,chunk);
+            const name=type==='process.stdout'?'stdout':'stderr';
+            const delivery=deliverChunk(stream,events,type,chunk,{
+                onOutput,
+                emitOutput:outputEncodings[name]!==null&&outputSelected(emitOutputEvents,name),
+                onFailure:function outputFailed(error){
+                    // Preserve complete failed callback input even when the
+                    // caller elected not to retain successful protocol output.
+                    outputErrors.push(new ArcaneError(ERROR_CODES.operationFailed,
+                        `The ${name} output callback failed.`,{cause:error,details:{stream:name,chunk}}));
+                    stopTree();
+                }
+            });
             deliveries.add(delivery);
             void delivery.then(()=>deliveries.delete(delivery));
         };
@@ -182,6 +239,26 @@ export async function runProcess(command,args=[],{
             }
         };
 
+        function stopInput(){
+            if(inputIterator&&!inputDone&&!inputReturn){
+                inputReturn=Promise.resolve().then(async function returnInput(){
+                    await inputIterator.return?.();
+                }).catch(function inputReturnFailed(error){
+                    inputError=inputError&&inputError!==error
+                        ?new AggregateError([inputError,error],'Process input and its cleanup failed.'):error;
+                });
+            }
+            child?.stdin.end();
+        }
+
+        async function drainInput(){
+            stopInput();
+            // AsyncIterable producers own cancellation of an outstanding next().
+            // Their return() must cooperate so owned cleanup can really finish.
+            await inputPump;
+            await inputReturn;
+        }
+
         const finish=(callback,value)=>{
             if(settlementStarted){
                 return;
@@ -191,16 +268,17 @@ export async function runProcess(command,args=[],{
             clearTimeout(escalation);
             signal?.removeEventListener('abort',abort);
             void (async()=>{
+                await drainInput();
                 let callbackFailure=null;
                 try{
                     await events.drain();
                 }catch(error){
                     callbackFailure=error;
                 }
-                if(cancellationMode==='close-input'&&closedResult){
+                if((cancellationMode==='close-input'&&closedResult)||inputIterator||onOutput){
                     const failures=[...new Set([
                         callback===reject?value:null,
-                        callbackFailure,inputError,cancellationError,spawnError
+                        callbackFailure,inputError,cancellationError,spawnError,...outputErrors
                     ].filter(error=>error!==null))];
                     if(failures.length>0){
                         const primary=failures[0];
@@ -234,10 +312,10 @@ export async function runProcess(command,args=[],{
                 return;
             }
             terminationRequested=true;
+            stopInput();
             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);
@@ -306,16 +384,16 @@ export async function runProcess(command,args=[],{
             return;
         }
 
-        // Each readable retains split UTF-8 sequences and flushes at EOF.
-        // Capture and events consume the same decoded text.
-        child.stdout.setEncoding('utf8');
-        child.stderr.setEncoding('utf8');
+        // Text streams retain split UTF-8 sequences and flush at EOF. Explicit
+        // raw streams bypass decoding and deliver native Buffers only to onOutput.
+        if(outputEncodings.stdout!==null)child.stdout.setEncoding(outputEncodings.stdout);
+        if(outputEncodings.stderr!==null)child.stderr.setEncoding(outputEncodings.stderr);
         child.stdout.on('data',chunk=>{
-            stdout=appendOutput(stdout,chunk);
+            if(stdout!==null)stdout=appendOutput(stdout,chunk);
             ownDelivery(child.stdout,'process.stdout',chunk);
         });
         child.stderr.on('data',chunk=>{
-            stderr=appendOutput(stderr,chunk);
+            if(stderr!==null)stderr=appendOutput(stderr,chunk);
             ownDelivery(child.stderr,'process.stderr',chunk);
         });
         child.on('error',error=>{
@@ -335,6 +413,7 @@ export async function runProcess(command,args=[],{
             signal?.removeEventListener('abort',abort);
             clearInterval(heartbeat);
             void (async()=>{
+                await drainInput();
                 await drainDeliveries();
                 if(settlementStarted)return;
                 const result={
@@ -359,7 +438,7 @@ export async function runProcess(command,args=[],{
                         });
                     }
                     if(cancellationError)cancellationError.details=result;
-                    finish(reject,events.error??inputError??cancellationError??new ArcaneError(
+                    finish(reject,events.error??inputError??outputErrors[0]??cancellationError??new ArcaneError(
                         ERROR_CODES.operationFailed,
                         `Stopped ${command} after its event callback failed.`
                     ));
@@ -379,6 +458,10 @@ export async function runProcess(command,args=[],{
                         {cause:inputError,details:result}));
                     return;
                 }
+                if(outputErrors.length){
+                    finish(reject,outputErrors[0]);
+                    return;
+                }
                 await events.enqueue({
                     type:'process.completed',
                     message:`${command} exited with code ${String(result.code)}.`,
@@ -401,7 +484,30 @@ export async function runProcess(command,args=[],{
             abort();
         }
 
-        if(cancellationMode==='close-input'){
+        if(input&&is.function(input[Symbol.asyncIterator])){
+            child.stdin.on('error',error=>{inputError=error;stopTree();});
+            inputPump=(async function pumpInput(){
+                try{
+                    inputIterator=input[Symbol.asyncIterator]();
+                    while(!terminationRequested&&!childClosed){
+                        const next=await inputIterator.next();
+                        if(next.done){inputDone=true;break;}
+                        if(terminationRequested||childClosed)break;
+                        await new Promise(function writeChunk(resolve,reject){
+                            child.stdin.write(next.value,function written(error){
+                                if(error)reject(error);
+                                else resolve();
+                            });
+                        });
+                    }
+                    child.stdin.end();
+                }catch(error){
+                    inputError=inputError&&inputError!==error
+                        ?new AggregateError([inputError,error],'Process input failed.'):error;
+                    stopTree();
+                }
+            })();
+        }else if(cancellationMode==='close-input'){
             child.stdin.on('error',error=>{inputError=error;stopTree();});
             if(input!==undefined&&!terminationRequested)child.stdin.write(input);
         }else if(input!==undefined){

package/src/scaffold.mjs

@@ -44,7 +44,7 @@ function validateInputs(appId,displayName){
 }
 
 function validateScaffoldTarget(target){
-    const targets=['browser','portable','windows-x64','linux-x64','linux-arm64','android-arm64'];
+    const targets=['browser','portable','windows-x64','macos-arm64','macos-x64','linux-x64','linux-arm64','android-arm64'];
     if(!targets.includes(target)){
         fail(`Invalid scaffold target: ${String(target)}. Expected one of ${targets.join(', ')}.`,'ARCANE_USAGE');
     }

package/src/targets/index.mjs

@@ -19,7 +19,7 @@ const DEFINITIONS=[
     },
     {
         id:'portable',displayName:'Portable native application',status:'pairing-required',
-        platforms:['windows','linux'],architectures:['x64','arm64'],formats:['portable'],
+        platforms:['windows','linux','macos'],architectures:['x64','arm64'],formats:['portable'],
         signingModes:['unsigned-local-test'],
         reason:'Portable app payloads use the SDK package provider by default; explicit provider pairing remains available.'
     },
@@ -28,6 +28,16 @@ const DEFINITIONS=[
         platforms:['windows'],architectures:['x64'],formats:['exe'],signingModes:['unsigned-local-test'],
         reason:'Windows output requires an Arcane OS native provider.'
     },
+    {
+        id:'macos-arm64',displayName:'macOS Apple silicon application',status:'pairing-required',
+        platforms:['macos'],architectures:['arm64'],formats:['app'],signingModes:['unsigned-local-test'],
+        reason:'macOS output uses the SDK provider with the selected architecture host asset.'
+    },
+    {
+        id:'macos-x64',displayName:'macOS Intel application',status:'pairing-required',
+        platforms:['macos'],architectures:['x64'],formats:['app'],signingModes:['unsigned-local-test'],
+        reason:'macOS output uses the SDK provider with the selected architecture host asset.'
+    },
     {
         id:'linux-x64',displayName:'Linux x64 executable',status:'pairing-required',
         platforms:['linux'],architectures:['x64'],formats:['deb'],signingModes:['unsigned-local-test'],

package/src/templates/workspace-template.mjs

@@ -84,7 +84,7 @@ export function workspaceTemplate({
         ||(!canonicalSpecifier&&!aliasSpecifier)){
         throw new Error('Invalid scaffold SDK installation authority.');
     }
-    const supportedTargets=['browser','portable','windows-x64','linux-x64','linux-arm64','android-arm64'];
+    const supportedTargets=['browser','portable','windows-x64','macos-arm64','macos-x64','linux-x64','linux-arm64','android-arm64'];
     if(!supportedTargets.includes(target)){
         throw new Error(`Unsupported scaffold target: ${String(target)}.`);
     }
@@ -105,17 +105,18 @@ export function workspaceTemplate({
     const packageInclude=[`${appId}.css`,'index.html'];
     if(native)packageInclude.push('img/icon.png');
     packageInclude.push('manifest.json','modules');
+    const macosTarget=target==='macos-arm64'||target==='macos-x64';
     const nativeGuide=native?`
 ## ${target} native target
 
 This scaffold declares both the browser and ${target} targets and includes the
 required raster application icon.
-Pair it with one explicit Arcane OS checkout:
+${macosTarget?'Use the installed SDK provider and its matching macOS release host asset:':'Pair it with one explicit Arcane OS checkout:'}
 
 \`\`\`sh
-npm exec -- arcane native-doctor --target ${target} --arcane-root "<path-to-Arcane-OS>"
-npm run build -- --arcane-root "<path-to-Arcane-OS>"
-${target==='portable'?'':`npm run run -- --arcane-root "<path-to-Arcane-OS>"\n`}
+npm exec -- arcane native-doctor --target ${target}${macosTarget?'':' --arcane-root "<path-to-Arcane-OS>"'}
+npm run build${macosTarget?'':' -- --arcane-root "<path-to-Arcane-OS>"'}
+${target==='portable'?'':`npm run run${macosTarget?'':' -- --arcane-root "<path-to-Arcane-OS>"'}\n`}
 \`\`\`
 
 The selected Arcane provider must support this target or the command fails without

package/src/toolchain.mjs

@@ -1,7 +1,7 @@
 import Is from 'strong-type';
 import path from 'node:path';
 import {resolveAppRoot,resolvePackageOutputRoot} from './app-layout.mjs';
-import {readdir,lstat,realpath,mkdir,readFile,writeFile} from 'node:fs/promises';
+import {readdir,lstat,realpath,mkdir,readFile,writeFile,unlink} from 'node:fs/promises';
 import {createWorkspace,initWorkspace} from './scaffold.mjs';
 import {
     discoverApps as discoverWorkspaceApps,
@@ -12,8 +12,14 @@ import {
 } from './workspace.mjs';
 import {loadArcaneIntegratedProvider} from './integrated-provider-loader.mjs';
 import {collectSourcePwaAssets,startDevServer} from './dev-server.mjs';
-import {applyPwaEntryReferences,generateImportMap,readApplicationTestImportMapContext} from './import-map.mjs';
-import {createPwaArtifacts} from './pwa.mjs';
+import {applyPwaEntryReferences,generateImportMap,readApplicationTestImportMapContext,removePwaEntryReferences} from './import-map.mjs';
+import {
+    createPwaArtifacts,
+    PWA_MANIFEST_NAME,
+    PWA_OFFLINE_MANIFEST_NAME,
+    PWA_WORKER_NAME,
+    PWA_BOOTSTRAP_NAME
+} from './pwa.mjs';
 import {readInstalledSdkLayout} from './sdk-runtime-layout.mjs';
 import {withWorkspaceOperationLock} from './workspace-operation-lock.mjs';
 import {refreshAppPackageProjection} from './app-descriptor.mjs';
@@ -293,7 +299,7 @@ async function validatePreparedRuntime(prepared,{signal}={}){
     return validation;
 }
 
-async function refreshPreparedImportMap(prepared,{signal,onEvent,workspaceOperationLease}={}){
+async function refreshPreparedImportMap(prepared,{signal,onEvent,workspaceOperationLease}={},retireGeneratedPwa=false){
     const manifest=prepared.validation.app.manifest;
     const inspected=await inspectPackagedApp({
         workspaceRoot:prepared.workspaceRoot,
@@ -322,12 +328,12 @@ async function refreshPreparedImportMap(prepared,{signal,onEvent,workspaceOperat
         onEvent
     });
     if(prepared.validation.config.appsRoot==='.'){
-        await refreshRootApplicationFiles(prepared,inspected,importMap,{signal,onEvent});
+        await refreshRootApplicationFiles(prepared,inspected,importMap,{signal,onEvent,retireGeneratedPwa});
     }
     return importMap;
 }
 
-async function refreshRootApplicationFiles(prepared,inspected,importMap,{signal,onEvent}){
+async function refreshRootApplicationFiles(prepared,inspected,importMap,{signal,onEvent,retireGeneratedPwa=false}){
     const {workspaceRoot,appId}=prepared;
     const manifest=prepared.validation.app.manifest;
     const installed=await readInstalledSdkLayout(workspaceRoot,prepared.validation.config);
@@ -385,21 +391,44 @@ async function refreshRootApplicationFiles(prepared,inspected,importMap,{signal,
         await mkdir(path.dirname(filePath),{recursive:true});
         await writeFile(filePath,file.content,'utf8');
     }
-    if(pwa){
+    const pwaDisabled=manifest.pwa?.enabled===false;
+    const retireConfirmedOutput=pwaDisabled&&retireGeneratedPwa===true;
+    if(pwa||pwaDisabled){
         for(const document of inspected.browserDocuments){
             throwIfAborted(signal);
             const filePath=path.join(prepared.appRoot,...document.path.split('/'));
             const content=await readFile(filePath,'utf8');
-            await writeFile(filePath,applyPwaEntryReferences(content,{
+            const updated=pwa?applyPwaEntryReferences(content,{
                 manifestUrl:`/${pwa.entryAssets.manifest}`,
-                bootstrapUrl:`/${pwa.entryAssets.bootstrap}`
-            }),'utf8');
+                bootstrapUrl:`/${pwa.entryAssets.bootstrap}`,
+                markGeneratedManifest:true
+            }):removePwaEntryReferences(content,{
+                documentUrl:new URL(`/${document.path.split('/').map(encodeURIComponent).join('/')}`,sourceOrigin),
+                manifestUrl:`/${PWA_MANIFEST_NAME}`,
+                markedManifestOnly:!retireConfirmedOutput
+            });
+            if(updated!==content)await writeFile(filePath,updated,'utf8');
+        }
+    }
+    const retiredPwa=[];
+    if(retireConfirmedOutput){
+        // The caller declares these standard outputs generated, not merely same-named authored files.
+        // Remove selected references before retiring their targets; browser storage is untouched.
+        for(const relative of [PWA_MANIFEST_NAME,PWA_OFFLINE_MANIFEST_NAME,PWA_WORKER_NAME,PWA_BOOTSTRAP_NAME]){
+            throwIfAborted(signal);
+            try{
+                await unlink(path.join(workspaceRoot,relative));
+                retiredPwa.push(relative);
+            }catch(error){
+                if(error.code!=='ENOENT')throw error;
+            }
         }
     }
     await emit(onEvent,{
         type:'import-map.root-files.completed',appId,
         navigation:[],
-        pwa:pwa?.files.map(file=>file.path)??[]
+        pwa:pwa?.files.map(file=>file.path)??[],
+        retiredPwa
     });
 }
 
@@ -408,7 +437,7 @@ async function importMapApplication(options={}){
     const prepared=await preparedWorkspace({...options,allowMissingManagedImportMap:true});
     const importMap=await ownedWork(
         'import-map',
-        context=>refreshPreparedImportMap(prepared,context),
+        context=>refreshPreparedImportMap(prepared,context,options.retireGeneratedPwa===true),
         {...options,workspaceRoot:prepared.workspaceRoot}
     );
     await validatePreparedRuntime(prepared,{signal:options.signal});
@@ -868,7 +897,7 @@ export function assertIntegratedNativeToolchain({
     workspaceMode,workspaceRoot,toolchainRoot,target,providerSource='arcane-checkout'
 }={}){
     if(workspaceMode!=='integrated')return;
-    if(providerSource==='sdk-package'&&(target==='portable'||target==='windows-x64'))return;
+    if(providerSource==='sdk-package'&&['portable','windows-x64','macos-arm64','macos-x64'].includes(target))return;
     if(!is.string(toolchainRoot)||!sameCanonicalPath(workspaceRoot,toolchainRoot)){
         throw new ArcaneError(
             ERROR_CODES.policyDenied,