arcane-os 0.53.0 → 0.54.0

package/src/import-map.mjs

@@ -41,11 +41,13 @@ const STATIC_RUNTIME_PACKAGE_IMPORTS=new Map([
 ]);
 const SDK_BROWSER_SELF_IMPORTS=new Map([
     ['arcane-os/event-manager',SDK_BROWSER_ENTRY],
+    ['arcane-os/websocket-client','sdk/websocket-client.mjs'],
     ['arcane-os/logging','sdk/logging.mjs'],
     ['arcane-os/browser-device','sdk/browser-device.mjs'],
     ['arcane-os/pwa','sdk/pwa.mjs'],
     ['arcane-os/speech-text','sdk/speech-text.mjs'],
     ['arcane-os/ai/browser-wasm',SDK_BROWSER_AI_ENTRY],
+    ['arcane-os/ai/browser-decisions','sdk/ai/browser-decisions.mjs'],
     ['arcane-os/ai/tool-text-stream','sdk/ai/tool-text-stream.mjs'],
     ['arcane-os/ai/twin-cloud','sdk/ai/twin-cloud.mjs'],
     ['arcane-os/ai/browser-speech',SDK_BROWSER_SPEECH_ENTRY]
@@ -946,17 +948,234 @@ function literalExpressionResults(tokens){
     return [];
 }
 
-function globalResourceCallee(tokens,index){
-    if(!identifierIsProperty(tokens,index))return index;
-    if((tokens[index-1]?.value==='.'||tokens[index-1]?.value==='?.')
-        &&new Set(['globalThis','window','self']).has(tokens[index-2]?.value)
-        &&!identifierIsProperty(tokens,index-2))return index-2;
-    return -1;
+function resourceBindingScopes(tokens){
+    const relevant=new Set([
+        'fetch','URL','Worker','SharedWorker','importScripts',
+        'globalThis','window','self','document','location'
+    ]);
+    const bindings=new Map();
+    const closing=new Map();
+    const opening=new Map();
+    const delimiters=[];
+    for(let index=0;index<tokens.length;index+=1){
+        if(tokens[index].type!=='punctuator')continue;
+        const value=tokens[index].value;
+        if(['(','[','{'].includes(value))delimiters.push(index);
+        else if([')',']','}'].includes(value)){
+            const start=delimiters.pop();
+            if(start!==undefined){closing.set(start,index);opening.set(index,start);}
+        }
+    }
+
+    const root={start:0,end:tokens.length,kind:'module',parent:null};
+    const scopeAt=[];
+    let scope=root;
+    for(let index=0;index<tokens.length;index+=1){
+        scopeAt[index]=scope;
+        if(tokens[index].type!=='punctuator')continue;
+        if(tokens[index].value==='{'){
+            scope={
+                start:index,end:closing.get(index)??tokens.length,
+                kind:tokens[index].openingBraceKind,parent:scope
+            };
+        }else if(tokens[index].value==='}')scope=scope.parent??root;
+    }
+
+    function bind(index,owner){
+        const token=tokens[index];
+        if(token?.type!=='identifier'||!relevant.has(token.value))return;
+        const entries=bindings.get(token.value)??[];
+        entries.push({
+            start:tokens[owner.start]?.start??0,
+            end:tokens[owner.end]?.end??tokens.at(-1)?.end??0
+        });
+        bindings.set(token.value,entries);
+    }
+
+    function patterns(start,end,owner){
+        const boundaries=[start-1,...topLevelCommas(tokens,start,end),end];
+        for(let index=0;index<boundaries.length-1;index+=1){
+            pattern(boundaries[index]+1,boundaries[index+1],owner);
+        }
+    }
+
+    function pattern(start,end,owner){
+        if(start>=end)return;
+        if(tokens[start]?.value==='...')start+=1;
+        const token=tokens[start];
+        if(token?.type==='identifier'){bind(start,owner);return;}
+        const close=closing.get(start);
+        if(close===undefined||close>=end)return;
+        if(token.value==='['){patterns(start+1,close,owner);return;}
+        if(token.value!=='{')return;
+        const boundaries=[start,...topLevelCommas(tokens,start+1,close),close];
+        for(let index=0;index<boundaries.length-1;index+=1){
+            const entry=boundaries[index]+1;
+            const finish=boundaries[index+1];
+            const keyEnd=tokens[entry]?.value==='['?closing.get(entry):entry;
+            const value=tokens[keyEnd+1]?.value===':'?keyEnd+2:entry;
+            pattern(value,finish,owner);
+        }
+    }
+
+    function expressionEnd(start,{declaration=false}={}){
+        let index=start;
+        while(index<tokens.length){
+            const token=tokens[index];
+            if(token.type==='punctuator'){
+                if([';',')',']','}'].includes(token.value))break;
+                if(!declaration&&token.value===',')break;
+                if(closing.has(index)){index=closing.get(index)+1;continue;}
+            }
+            if(declaration&&token.type==='identifier'&&token.lineBreakBefore
+                &&['const','let','var','export','return'].includes(token.value))break;
+            index+=1;
+        }
+        return index;
+    }
+
+    function namedDefinitionEnd(start) {
+        let index = start + 1;
+        while (index < tokens.length) {
+            const token = tokens[index];
+            if (token.type === 'punctuator' && token.value === '{') return closing.get(index);
+            if (closing.has(index)) {
+                index = closing.get(index) + 1;
+                continue;
+            }
+            if (token.type === 'identifier' && ['function', 'class'].includes(token.value)
+                && !identifierIsProperty(tokens, index)) {
+                const end = namedDefinitionEnd(index);
+                if (end === undefined) return undefined;
+                index = end + 1;
+                continue;
+            }
+            index += 1;
+        }
+        return undefined;
+    }
+
+    function namedDefinitionIsDeclaration(index) {
+        const token = tokens[index];
+        const async = token.value === 'function' && tokens[index - 1]?.value === 'async'
+            && !token.lineBreakBefore && !identifierIsProperty(tokens, index - 1);
+        const start = async ? index - 1 : index;
+        if (declarationPosition(tokens, start)) return true;
+        const previous = tokens[start - 1];
+        if (previous?.value === ':' && previous.enclosingBraceKind !== 'object') {
+            if (declarationPosition(tokens, start - 2)) return true;
+            let conditionals = 0;
+            for (let cursor = start - 2; cursor >= scopeAt[index].start; cursor -= 1) {
+                if (opening.has(cursor)) {
+                    cursor = opening.get(cursor);
+                    continue;
+                }
+                const candidate = tokens[cursor];
+                const value = candidate.value;
+                if (value === ':') conditionals += 1;
+                else if (value === '?') {
+                    if (conditionals === 0) return false;
+                    conditionals -= 1;
+                } else if (candidate.type === 'identifier' && ['case', 'default'].includes(value)
+                    && !identifierIsProperty(tokens, cursor)) return conditionals === 0;
+                else if ([';', '{', '}'].includes(value)) break;
+            }
+        }
+        // An omitted semicolon must not turn a following declaration into an expression.
+        if (!tokens[start].lineBreakBefore || !previous) return false;
+        if (['string', 'number', 'regex', 'template'].includes(previous.type)) return true;
+        if (previous.type === 'identifier') {
+            if (identifierIsProperty(tokens, start - 1)) return true;
+            if (['return', 'throw', 'yield'].includes(previous.value)) return true;
+            if (previous.contextualRegexPrefix === true) return false;
+            if (previous.value === 'await' && previous.slashGoalAfter !== 'division') return false;
+            return !REGEX_PREFIX_KEYWORDS.has(previous.value);
+        }
+        return [')', ']', '++', '--'].includes(previous.value);
+    }
+
+    for(let index=0;index<tokens.length;index+=1){
+        const token=tokens[index];
+        if(token.type==='punctuator'&&token.value==='{'&&tokens[index-1]?.value===')'
+            &&tokens[index-1]?.closesControl!==true){
+            const start=opening.get(index-1);
+            if(start!==undefined){
+                patterns(start+1,index-1,{start,end:closing.get(index)??tokens.length});
+            }
+        }
+        if(token.type==='punctuator'&&token.value==='=>'){
+            const previous=index-1;
+            const parameterStart=tokens[previous]?.value===')'?opening.get(previous):previous;
+            if(parameterStart!==undefined){
+                const end=tokens[index+1]?.value==='{'?closing.get(index+1):expressionEnd(index+1);
+                const owner={start:parameterStart,end:end??tokens.length};
+                if(tokens[previous]?.value===')')patterns(parameterStart+1,previous,owner);
+                else pattern(parameterStart,index,owner);
+            }
+        }
+        if(token.type!=='identifier'||identifierIsProperty(tokens,index))continue;
+        if(['const','let','var'].includes(token.value)){
+            let owner=scopeAt[index];
+            if(token.value==='var'){
+                while(owner.parent&&owner.kind!=='function')owner=owner.parent;
+            }
+            // Loop bindings conservatively retain the enclosing lexical scope.
+            patterns(index+1,expressionEnd(index+1,{declaration:true}),owner);
+        }else if(token.value==='function'||token.value==='class'){
+            const name = tokens[index + 1]?.value === '*' ? index + 2 : index + 1;
+            if (tokens[name]?.type !== 'identifier' || !relevant.has(tokens[name].value)) continue;
+            const end = namedDefinitionIsDeclaration(index) ? undefined : namedDefinitionEnd(index);
+            // Expression names belong to their own parameters/heritage and body only.
+            const owner = end === undefined ? scopeAt[index] : {start: index, end};
+            bind(name, owner);
+        }else if(token.value==='catch'&&tokens[index+1]?.value==='('){
+            const close=closing.get(index+1);
+            const body=close+1;
+            if(close!==undefined&&tokens[body]?.value==='{'){
+                patterns(index+2,close,{start:index+1,end:closing.get(body)??tokens.length});
+            }
+        }else if(token.value==='import'&&!['(','.'].includes(tokens[index+1]?.value)
+            &&tokens[index+1]?.type!=='string'){
+            let cursor=index+1;
+            if(tokens[cursor]?.type==='identifier'){bind(cursor,root);cursor+=1;}
+            if(tokens[cursor]?.value===',')cursor+=1;
+            if(tokens[cursor]?.value==='*'&&tokens[cursor+1]?.value==='as')bind(cursor+2,root);
+            else if(tokens[cursor]?.value==='{'){
+                const close=closing.get(cursor)??cursor;
+                const boundaries=[cursor,...topLevelCommas(tokens,cursor+1,close),close];
+                for(let entry=0;entry<boundaries.length-1;entry+=1){
+                    const start=boundaries[entry]+1;
+                    bind(tokens[start+1]?.value==='as'?start+2:start,root);
+                }
+            }
+        }
+    }
+    return bindings;
+}
+
+function locallyBoundResource(token,bindings){
+    const owners=bindings.get(token.value)??[];
+    return owners.some(function containsReference(owner){
+        return token.start>=owner.start&&token.start<=owner.end;
+    });
+}
+
+function globalResourceCallee(tokens,index,bindings){
+    let root=index;
+    if(identifierIsProperty(tokens,index)){
+        if((tokens[index-1]?.value!=='.'&&tokens[index-1]?.value!=='?.')
+            ||!['globalThis','window','self'].includes(tokens[index-2]?.value)
+            ||identifierIsProperty(tokens,index-2))return -1;
+        root=index-2;
+    }
+    if(locallyBoundResource(tokens[root],bindings))return -1;
+    return root;
 }
 
-function localResourceBase(tokens){
+function localResourceBase(tokens,bindings){
     if(!tokens)return false;
     if(tokens.some(function nonExpressionToken(token){return !['identifier','punctuator'].includes(token.type);}))return false;
+    if(tokens[0]?.value!=='import'&&tokens[0]&&locallyBoundResource(tokens[0],bindings))return false;
     const base=tokens.map(function baseToken(token){return token.value;}).join('');
     return [
         'import.meta.url','document.baseURI','location.href','window.location.href',
@@ -984,8 +1203,9 @@ function reportAssetReference(onReference,url,kind,baseKind){
     if(is.function(onReference))onReference({url,kind,baseHref:null,...(baseKind?{baseKind}:{})});
 }
 
-function javascriptReferenceEdits(source,version,onReference){
+function javascriptReferenceEdits(source,version,onReference,resolveReference){
     const tokens=tokenize(source);
+    const resourceBindings=resourceBindingScopes(tokens);
     const selected=new Map();
     const imports=moduleImportsFromTokens(tokens,'asset source').imports;
     const byOffset=new Map(tokens.map(function tokenByOffset(token){
@@ -993,38 +1213,55 @@ function javascriptReferenceEdits(source,version,onReference){
     }));
     for(const entry of imports){
         reportAssetReference(onReference,entry.specifier,'import');
-        if(/^(?:\.{1,2}\/|\/)/u.test(entry.specifier)){
-            selected.set(entry.offset,byOffset.get(entry.offset));
+        if(resolveReference||/^(?:\.{1,2}\/|\/)/u.test(entry.specifier)){
+            selected.set(entry.offset,{token:byOffset.get(entry.offset),kind:'import'});
         }
     }
     for(let index=0;index<tokens.length;index+=1){
         const token=tokens[index];
+        if(resolveReference&&token.type==='identifier'&&token.value==='import'
+            &&!identifierIsProperty(tokens,index)&&tokens[index+1]?.value==='.'
+            &&tokens[index+2]?.value==='meta'&&tokens[index+3]?.value==='.'
+            &&tokens[index+4]?.value==='resolve'&&tokens[index+5]?.value==='('
+            &&tokens[index+6]?.type==='string'&&tokens[index+7]?.value===')'){
+            const literal=tokens[index+6];
+            selected.set(literal.start,{token:literal,kind:'import-resolve'});
+        }
         if(token.type!=='identifier'||tokens[index+1]?.value!=='(')continue;
         if(!['URL','Worker','SharedWorker','importScripts','fetch'].includes(token.value))continue;
-        const callee=globalResourceCallee(tokens,index);
+        const callee=globalResourceCallee(tokens,index,resourceBindings);
         if(callee<0)continue;
         const constructor=tokens[callee-1]?.value==='new';
         if(['URL','Worker','SharedWorker'].includes(token.value)&&!constructor)continue;
         const argumentsList=callArgumentTokens(tokens,index+1);
         if(token.value==='fetch'&&!literalResourceFetch(argumentsList))continue;
-        if(token.value==='URL'&&!localResourceBase(argumentsList[1]))continue;
+        if(token.value==='URL'&&!localResourceBase(argumentsList[1],resourceBindings))continue;
         const selectedArguments=token.value==='importScripts'?argumentsList:argumentsList.slice(0,1);
         for(const argument of selectedArguments){
             for(const literal of literalExpressionResults(argument)){
                 if((token.value==='fetch'||token.value==='URL')
                     &&!RESOURCE_EXTENSION.test(literal.value))continue;
                 if((token.value==='fetch'||token.value==='URL')
-                    &&/\.html?(?:[?#]|$)/iu.test(literal.value))continue;
+                    &&!resolveReference&&/\.html?(?:[?#]|$)/iu.test(literal.value))continue;
                 const kind=token.value==='fetch'?'fetch'
                     :token.value==='URL'&&!/\.(?:js|mjs)(?:[?#]|$)/iu.test(literal.value)?'asset':'script';
                 const documentBase=['Worker','SharedWorker','fetch'].includes(token.value)
                     ||(token.value==='URL'&&argumentsList[1]?.[0]?.value!=='import');
                 reportAssetReference(onReference,literal.value,kind,documentBase?'document':undefined);
-                selected.set(literal.start,literal);
+                selected.set(literal.start,{
+                    token:literal,
+                    kind,
+                    baseKind:documentBase?'document':undefined
+                });
             }
         }
     }
-    return [...selected.values()].map(function versionJavaScriptReference(token){
+    return [...selected.values()].map(function versionJavaScriptReference({token,kind,baseKind}){
+        if(resolveReference){
+            const value=resolveReference({url:token.value,kind,baseKind});
+            if(value===undefined||value===token.value)return null;
+            return stringReferenceEdit(source,token,null,[{start:0,end:token.value.length,value}]);
+        }
         return stringReferenceEdit(source,token,version);
     }).filter(Boolean);
 }
@@ -1061,7 +1298,7 @@ function cssReferenceEdits(source,version,onReference,versionReference=versionAs
         const original=source.slice(start,end);
         if(original.includes('\\'))return;
         reportAssetReference(onReference,original,kind);
-        const value=versionReference(original,version);
+        const value=versionReference(original,version,kind);
         if(value!==original)edits.push({start,end,value});
     }
     while(cursor<source.length){
@@ -1233,6 +1470,19 @@ function registerSpecifier(registry,specifier,target){
     registry.set(specifier,{specifier,target});
 }
 
+function translateImportMapScopes(scopes, translateUrl) {
+    if (scopes === undefined) return undefined;
+    const translated = {};
+    for (const [scope, entries] of Object.entries(scopes)) {
+        const imports = {};
+        for (const [specifier, target] of Object.entries(entries)) {
+            imports[translateUrl(specifier)] = translateUrl(target);
+        }
+        translated[translateUrl(scope)] = imports;
+    }
+    return translated;
+}
+
 function versionImportMapSpecifier(specifier,version){
     if(specifier.endsWith('/')||!/^(?:\.{1,2}\/|\/|[A-Za-z][A-Za-z0-9+.-]*:\/\/)/u.test(specifier))return specifier;
     return versionImportMapUrl(specifier,version);
@@ -1328,6 +1578,13 @@ export async function buildImportMap({files,signal,version=SDK_VERSION,encodePat
             './arcane/sdk/dependencies/event-pubsub/index.js'
         );
     }
+    if (inventory.has('sdk/dependencies/ws-share/WS.js')) {
+        registerSpecifier(
+            namedRegistry,
+            'ws-share',
+            './arcane/sdk/dependencies/ws-share/WS.js'
+        );
+    }
     for(const relative of [...inventory].sort(compareText)){
         if(JAVASCRIPT_EXTENSION.test(relative)){
             const target=runtimeTarget(relative);
@@ -1343,10 +1600,22 @@ export async function buildImportMap({files,signal,version=SDK_VERSION,encodePat
         imports[entry.specifier]=target;
         imports[versionImportMapSpecifier(entry.specifier,version)]=target;
     }
-    return {
+    const result = {
         imports,
         excludedModules:[]
     };
+    if (inventory.has('sdk/dependencies/event-pubsub/index.js')
+        && inventory.has('sdk/dependencies/event-pubsub/dependencies/strong-type/index.js')) {
+        result.scopes = {
+            './arcane/sdk/dependencies/event-pubsub/': {
+                'strong-type': versionAssetUrl(
+                    './arcane/sdk/dependencies/event-pubsub/dependencies/strong-type/index.js',
+                    version
+                )
+            }
+        };
+    }
+    return result;
 }
 
 function pathInside(root,target){
@@ -1426,8 +1695,13 @@ async function managedImportMapBuild(resolvedWorkspace,resolvedApp,signal){
             if(physicalCompatibilityUrl)imports[physicalCompatibilityUrl]=selected;
         }
         built.imports=imports;
+        if (built.scopes !== undefined) {
+            built.scopes = translateImportMapScopes(built.scopes, installedBrowserUrl);
+        }
     }
-    const json=`${JSON.stringify({imports:built.imports},null,2).replaceAll('<','\\u003c')}\n`;
+    const document = {imports:built.imports};
+    if (built.scopes !== undefined) document.scopes = built.scopes;
+    const json=`${JSON.stringify(document,null,2).replaceAll('<','\\u003c')}\n`;
     return {built,json,version};
 }
 
@@ -1512,10 +1786,16 @@ function parseTagAttributes(openTag){
             }
         }
         if(name){
-            if(attributes.has(name))duplicates.add(name);
+            const position={start:valueStart,end:valueEnd,quote,nameEnd,assigned};
+            if(attributes.has(name)){
+                duplicates.add(name);
+                const original=positions.get(name);
+                original.additional??=[];
+                original.additional.push(position);
+            }
             else{
                 attributes.set(name,value);
-                positions.set(name,{start:valueStart,end:valueEnd,quote,nameEnd,assigned});
+                positions.set(name,position);
             }
         }
     }
@@ -1954,11 +2234,12 @@ function htmlStyleReferenceEdits(source,version,onReference){
     });
 }
 
-function srcsetReferenceEdits(source,version,onReference){
+function srcsetReferenceEdits(source,version,onReference,versionReference=versionHtmlAttribute){
     const edits=[];
     let cursor=0;
     while(cursor<source.length){
         while(/[\t\n\f\r ,]/u.test(source[cursor]??''))cursor+=1;
+        if(cursor===source.length)break;
         const start=cursor;
         while(cursor<source.length&&!/[\t\n\f\r ]/u.test(source[cursor]))cursor+=1;
         let end=cursor;
@@ -1966,7 +2247,7 @@ function srcsetReferenceEdits(source,version,onReference){
         const original=source.slice(start,end);
         const view=htmlAttributeView(original);
         if(view)reportAssetReference(onReference,view.decoded,'asset');
-        const value=versionHtmlAttribute(original,version);
+        const value=versionReference(original,version);
         if(value!==original)edits.push({start,end,value});
         if(end<cursor)continue;
         while(cursor<source.length&&source[cursor]!==',')cursor+=1;
@@ -2150,6 +2431,52 @@ export function inspectImportMapHtml(html){
     };
 }
 
+// Packaging shares the same lexical and HTML owners as managed browser maps.
+// These internal helpers edit only executable/resource references, never prose.
+export function nativeModuleHtml(source){
+    const structure=scanHtmlStructure(source);
+    function withAttributes(element){
+        const attributes=parseTagAttributes(element.open);
+        return {
+            ...element,
+            attributes,
+            attribute:function attribute(name){
+                return structuralAttribute(attributes,name,element.tag??'script');
+            }
+        };
+    }
+    return {
+        ...structure,
+        scripts:structure.scripts.map(withAttributes),
+        elements:structure.elements.map(withAttributes),
+        bases:structure.bases.map(withAttributes)
+    };
+}
+
+export function rewriteNativeJavaScript(source,resolveReference){
+    return applyReferenceEdits(source,javascriptReferenceEdits(source,null,null,resolveReference));
+}
+
+export function rewriteNativeStylesheet(source,resolveReference){
+    return applyReferenceEdits(source,cssReferenceEdits(source,null,null,
+        function nativeStyleReference(url,_version,kind){
+            return resolveReference({url,kind})??url;
+        }
+    ));
+}
+
+export function rewriteNativeSrcset(source,resolveReference){
+    return applyReferenceEdits(source,srcsetReferenceEdits(source,null,null,
+        function nativeSrcsetReference(url){
+            return resolveReference({url,kind:'asset'})??url;
+        }
+    ));
+}
+
+export function applyNativeReferenceEdits(source,edits){
+    return applyReferenceEdits(source,edits);
+}
+
 function renderManagedHtml(html,json,baseHref='../../'){
     const structure=scanHtmlStructure(html);
     const activeBases=structure.bases.map(base=>({
@@ -2326,6 +2653,7 @@ export async function createApplicationTestImportMapContext({
     applicationRoot,
     boundary='source',
     imports={},
+    scopes,
     signal
 }={}){
     if(!is.string(applicationRoot)||applicationRoot.trim()===''){
@@ -2337,6 +2665,9 @@ export async function createApplicationTestImportMapContext({
     if(imports===null||!is.object(imports)||is.array(imports)){
         throw new TypeError('imports must be a plain object.');
     }
+    if (scopes !== undefined && (scopes === null || !is.object(scopes) || is.array(scopes))) {
+        throw new TypeError('scopes must be an object.');
+    }
     throwIfAborted(signal);
     const requestedApplicationRoot=path.resolve(applicationRoot);
     const applicationInfo=await lstat(requestedApplicationRoot);
@@ -2355,35 +2686,48 @@ export async function createApplicationTestImportMapContext({
         ||!pathInside(canonicalApplicationRoot,canonicalBase)){
         fail(`Application ${boundary} import-map base must be one physical app-owned directory.`);
     }
-    const selectedImports={};
-    for(const [specifier,target] of Object.entries(imports)){
-        throwIfAborted(signal);
-        if(!is.string(specifier)||specifier===''||!is.string(target)
-            ||!target.startsWith('./')){
-            fail(`Application test import-map entry is invalid: ${String(specifier)}.`);
-        }
-        const relative=safeRelativePath(
-            decodeURIComponent(target.slice(2).split(/[?#]/u)[0]),
-            `application test import-map target for ${specifier}`
-        );
-        if(boundary==='source'&&/^(?:dist|test)\//u.test(relative)){
-            fail(`Source import-map target selects another application boundary: ${specifier}.`);
-        }
-        const candidate=path.resolve(canonicalBase,...relative.split('/'));
-        const targetInfo=await lstat(candidate);
-        const canonicalTarget=await realpath(candidate);
-        if(targetInfo.isSymbolicLink()||!targetInfo.isFile()
-            ||!samePath(candidate,canonicalTarget)||!pathInside(canonicalBase,canonicalTarget)){
-            fail(`Application test import-map target leaves its physical ${boundary} directory: ${specifier}.`);
+    async function selectImports(entries) {
+        const selected = {};
+        for (const [specifier, target] of Object.entries(entries)) {
+            throwIfAborted(signal);
+            if (!is.string(specifier) || specifier === '' || !is.string(target)
+                || !target.startsWith('./')) {
+                fail(`Application test import-map entry is invalid: ${String(specifier)}.`);
+            }
+            const relative = safeRelativePath(
+                decodeURIComponent(target.slice(2).split(/[?#]/u)[0]),
+                `application test import-map target for ${specifier}`
+            );
+            if (boundary === 'source' && /^(?:dist|test)\//u.test(relative)) {
+                fail(`Source import-map target selects another application boundary: ${specifier}.`);
+            }
+            const candidate = path.resolve(canonicalBase, ...relative.split('/'));
+            const targetInfo = await lstat(candidate);
+            const canonicalTarget = await realpath(candidate);
+            if (targetInfo.isSymbolicLink() || !targetInfo.isFile()
+                || !samePath(candidate, canonicalTarget) || !pathInside(canonicalBase, canonicalTarget)) {
+                fail(`Application test import-map target leaves its physical ${boundary} directory: ${specifier}.`);
+            }
+            selected[specifier] = target;
         }
-        selectedImports[specifier]=target;
+        return selected;
     }
-    return {
+    const result = {
         protocol:'arcane-test-import-map/1',
         boundary,
         baseURL:pathToFileURL(`${canonicalBase}${path.sep}`).href,
-        imports:selectedImports
+        imports:await selectImports(imports)
     };
+    if (scopes !== undefined) {
+        result.scopes = {};
+        for (const [scope, entries] of Object.entries(scopes)) {
+            if (scope === '' || entries === null || !is.object(entries) || is.array(entries)) {
+                fail(`Application test import-map scope is invalid: ${scope}.`);
+            }
+            result.scopes[scope] = await selectImports(entries);
+        }
+    }
+    return result;
 }
 
 export async function readApplicationTestImportMapContext({
@@ -2428,16 +2772,20 @@ export async function readApplicationTestImportMapContext({
         fail('Application test import-map artifact must contain an imports object.');
     }
     const installed=await readInstalledSdkLayout(resolvedWorkspaceRoot);
-    const imports=installed?Object.fromEntries(Object.entries(document.imports).map(
+    function installedApplicationTestUrl(value) {
+        return installed && is.string(value) && value.startsWith('./')
+            ? `./${installedRuntimeTarget(value.slice(2), installed)}` : value;
+    }
+    const imports=Object.fromEntries(Object.entries(document.imports).map(
         function installedApplicationTestTarget([specifier,target]){
-            return [specifier,is.string(target)&&target.startsWith('./')
-                ?`./${installedRuntimeTarget(target.slice(2),installed)}`:target];
+            return [specifier,installedApplicationTestUrl(target)];
         }
-    )):document.imports;
+    ));
     return createApplicationTestImportMapContext({
         applicationRoot:resolvedWorkspaceRoot,
         boundary:'source',
         imports,
+        scopes:translateImportMapScopes(document.scopes, installedApplicationTestUrl),
         signal
     });
 }
@@ -2509,7 +2857,7 @@ function documentRelativeUrl(target, base) {
     return `${pathname}${target.search}${target.hash}`;
 }
 
-function documentImports(imports, context, baseHref, relative) {
+function documentImportMap(importMap, context, baseHref, relative) {
     const documentUrl = new URL(encodedUrlPath(relative), context.deployment);
     // Match URL parser normalization only for resolving the base; preserve authored HTML.
     const baseAddress = (baseHref ?? '').replace(/[\t\r\n]/gu, '').replace(
@@ -2545,16 +2893,20 @@ function documentImports(imports, context, baseHref, relative) {
         return value;
     }
     const rebased = {};
-    for (const [specifier, target] of Object.entries(imports)) {
+    for (const [specifier, target] of Object.entries(importMap.imports)) {
         rebased[rebaseUrl(specifier)] = rebaseUrl(target);
     }
-    return rebased;
+    const result = {imports:rebased};
+    if (importMap.scopes !== undefined) {
+        result.scopes = translateImportMapScopes(importMap.scopes, rebaseUrl);
+    }
+    return result;
 }
 
-function renderDocumentImportMap(html, imports, state) {
+function renderDocumentImportMap(html, importMap, state) {
     const {structure, managed, firstLoad, base} = state;
     const newline = html.includes('\r\n') ? '\r\n' : '\n';
-    const json = JSON.stringify({imports}, null, 2).replaceAll('<', '\\u003c');
+    const json = JSON.stringify(importMap, null, 2).replaceAll('<', '\\u003c');
     const block = `<script type="importmap" ${MANAGED_IMPORT_MAP_ATTRIBUTE}>${newline}${json}${newline}</script>`;
     const firstManaged = managed[0];
     const replaceInPlace = firstManaged
@@ -2691,13 +3043,15 @@ export async function generateDocumentImportMaps({
     const rendered = documentStates.map(
         function renderSelectedDocument(document) {
             throwIfAborted(signal);
-            const imports = documentImports(built.imports, context, document.state.base?.href, document.path);
-            return {
+            const importMap = documentImportMap(built, context, document.state.base?.href, document.path);
+            const result = {
                 path:document.path,
                 filePath:document.filePath,
-                imports,
-                html:renderDocumentImportMap(document.html, imports, document.state)
+                imports:importMap.imports,
+                html:renderDocumentImportMap(document.html, importMap, document.state)
             };
+            if (importMap.scopes !== undefined) result.scopes = importMap.scopes;
+            return result;
         }
     );
     const paths = [];
@@ -2721,11 +3075,13 @@ export async function generateDocumentImportMaps({
         documentCount:documentPaths.length,
         documents:rendered.map(
             function documentResult(document) {
-                return {
+                const result = {
                     path:document.path,
                     filePath:document.filePath,
                     imports:document.imports
                 };
+                if (document.scopes !== undefined) result.scopes = document.scopes;
+                return result;
             }
         ),
         committed:true
@@ -2836,6 +3192,7 @@ async function generateImportMapUnlocked({
         excludedModules:built.excludedModules,
         committed:true
     };
+    if (built.scopes !== undefined) result.scopes = built.scopes;
     const completedEventError=await emit(onEvent,{
         type:'import-map.completed',
         appId,