arcane-os 0.52.0 → 0.53.0

package/src/dev-server.mjs

@@ -543,11 +543,13 @@ async function packagedRoutes(releaseRoot){
     const canonical=await canonicalRealDirectory(requested,'Packaged release root');
     let pwa = false;
     let startPath = '/index.html';
+    let rootDocument = null;
     try {
         const release = JSON.parse(
             await readFile(path.join(canonical, 'ARCANE_APP_RELEASE.json'), 'utf8')
         );
         const start = release.app.start ?? release.app.entry;
+        if (release.app.rootDocument === './index.html') rootDocument = '/index.html';
         const startUrl = new URL(start, 'http://arcane.invalid/');
         startPath = `${startUrl.pathname}${startUrl.search}${startUrl.hash}`;
     } catch (error) {
@@ -564,6 +566,7 @@ async function packagedRoutes(releaseRoot){
         appId:null,
         pwa,
         startPath,
+        rootDocument,
         mappings:[{
             prefix:[],
             root:canonical
@@ -1026,19 +1029,30 @@ async function startOwnedDevServer({
     }
     async function readCurrentSourceRoutes() {
         throwIfAborted(signal);
+        function optionalSourceMetadata(error) {
+            if (error.code !== 'ENOENT') throw error;
+            return null;
+        }
         let manifestPath = path.join(appMapping.root, APP_DESCRIPTOR_NAME);
+        const [rootIndex, descriptorInput] = await Promise.all(
+            [
+                lstat(path.join(routeSet.workspaceRoot, 'index.html')).catch(optionalSourceMetadata),
+                lstat(manifestPath).catch(optionalSourceMetadata)
+            ]
+        );
+        const rootDocument = rootIndex?.isFile() ? '/index.html' : null;
         let authored = true;
-        let input;
-        try {
-            input = await lstat(manifestPath);
-        } catch (error) {
-            if (error.code !== 'ENOENT') throw error;
+        let input = descriptorInput;
+        if (!input) {
             authored = false;
             manifestPath = path.join(appMapping.root, APP_CONFIG_NAME);
             input = await lstat(manifestPath);
         }
         if (sourceManifestInput?.path === manifestPath
             && sourceManifestInput.modifiedAt === input.mtimeMs) {
+            if (currentSourceRoutes.rootDocument !== rootDocument) {
+                currentSourceRoutes = {...currentSourceRoutes, rootDocument};
+            }
             return currentSourceRoutes;
         }
         const value = JSON.parse(await readFile(manifestPath, 'utf8'));
@@ -1060,6 +1074,7 @@ async function startOwnedDevServer({
         currentSourceRoutes = {
             ...routeSet,
             app: manifest,
+            rootDocument,
             startPath: applicationSourcePath(routeSet.config,routeSet.appId,manifest.entry),
             mappings: mappings.map(
                 function currentSourceMapping(mapping) {
@@ -1076,7 +1091,7 @@ async function startOwnedDevServer({
     function developmentPwaArtifacts(selectedRoutes, assets = [], version = assetVersion) {
         const rootApp = selectedRoutes.config.appsRoot === '.';
         const appBase = applicationSourcePath(selectedRoutes.config,selectedRoutes.appId);
-        const navigationAliases = {'/': selectedRoutes.startPath};
+        const navigationAliases = selectedRoutes.rootDocument ? {} : {'/': selectedRoutes.startPath};
         return createPwaArtifacts(
             {
                 app: {
@@ -1104,12 +1119,21 @@ async function startOwnedDevServer({
     function rememberPwaArtifacts(state, artifacts, generatedAt = new Date()) {
         for (const file of artifacts.files) {
             const previous = state.metadata.get(file.path);
-            const lastModified = previous?.content === file.content
+            const previousTime = previous?.lastModified
+                ? Date.parse(previous.lastModified.toUTCString()) : previous?.ambiguousThrough;
+            let lastModified = previous?.content === file.content
                 ? previous.lastModified
                 : generatedAt;
+            if (!lastModified && generatedAt.getTime() >= previousTime + 1000) {
+                lastModified = generatedAt;
+            }
+            // A changed alias must not validate the prior body within one HTTP second.
+            const ambiguous = previous?.content !== file.content && previousTime !== undefined
+                && Date.parse(generatedAt.toUTCString()) <= previousTime;
+            if (ambiguous) lastModified = undefined;
             state.metadata.set(
                 file.path,
-                {content: file.content, lastModified}
+                {content: file.content, lastModified, ambiguousThrough: lastModified ? undefined : previousTime}
             );
         }
         state.artifacts = artifacts;
@@ -1277,22 +1301,29 @@ async function startOwnedDevServer({
                 );
                 return;
             }
-            if(segments.length===0){
+            const rootRequest = segments.length === 0;
+            if (rootRequest && !selectedRoutes.rootDocument) {
                 response.writeHead(302,{location:`${selectedRoutes.startPath}${target.search}`});
                 response.end();
                 return;
             }
-            const mapping = selectedRoutes.mappings.find(
-                function requestedSourceMapping(route) {
-                    return route.prefix.every(
-                        function matchingSourcePrefix(segment, index) {
-                            return segments[index] === segment;
-                        }
-                    );
-                }
-            );
+            const resourceSegments = rootRequest ? ['index.html'] : segments;
+            const hostRoot = rootRequest && mode === 'source'
+                && (selectedRoutes.config.appsRoot !== '.' || !sourcePathAllowed(resourceSegments, selectedRoutes.app));
+            // Only the host's exact root document is outside app selection.
+            // Its direct URL and every other resource keep the selected routes.
+            const mapping = hostRoot ? {kind: 'host', root: selectedRoutes.workspaceRoot, prefix: []}
+                : selectedRoutes.mappings.find(
+                    function requestedSourceMapping(route) {
+                        return route.prefix.every(
+                            function matchingSourcePrefix(segment, index) {
+                                return resourceSegments[index] === segment;
+                            }
+                        );
+                    }
+                );
             if(!mapping){deny(response,404,'Not found.');return;}
-            const relative=segments.slice(mapping.prefix.length);
+            const relative=resourceSegments.slice(mapping.prefix.length);
             if(relative.length===0){deny(response,404,'Not found.');return;}
             if(mapping.allow&&!mapping.allow(relative)){deny(response,404,'Not found.');return;}
             await runFileWork(async function serveMappedResource() {
@@ -1307,6 +1338,18 @@ async function startOwnedDevServer({
                     deny(response,404,'Not found.');
                     return;
                 }
+                if (hostRoot) {
+                    const representation = sourceRepresentation(opened, assetVersion, false, false);
+                    await serveSourceFile(
+                        fileServer,
+                        request,
+                        response,
+                        opened,
+                        {lastModified: representation.lastModified, representationTracked: true}
+                    );
+                    return;
+                }
+                const resourcePath = rootRequest ? selectedRoutes.rootDocument : target.path;
                 const extension=path.extname(opened.candidate).toLowerCase();
                 const html=extension==='.html'||extension==='.htm';
                 const explicitDocuments = mode === 'source' && mapping.kind === 'app'
@@ -1316,7 +1359,7 @@ async function startOwnedDevServer({
                 const selectedPwaDocument = mode === 'source' && pwaEnabled && html
                     && mapping.kind === 'app'
                     && !explicitDocuments && selectedRoutes.app.include.includes(relative.join('/'));
-                const selectedDocument = target.path === selectedRoutes.startPath || explicitDocument || selectedPwaDocument;
+                const selectedDocument = resourcePath === selectedRoutes.startPath || explicitDocument || selectedPwaDocument;
                 const managedDocument = !selectedDocument && !explicitDocuments && html && await isManagedDocument(opened);
                 const entryDocument = selectedDocument || managedDocument;
                 const managedMap=path.basename(opened.candidate)==='arcane.importmap.json';
@@ -1324,22 +1367,22 @@ async function startOwnedDevServer({
                 // version record on navigation, not on each resource request.
                 if(entryDocument||managedMap)rememberAssetVersion(await selectedAssetVersion());
                 const runtimeResource=mapping.kind!=='app';
-                if (runtimeResource && html) runtimeDocuments.add(target.path);
+                if (runtimeResource && html) runtimeDocuments.add(resourcePath);
                 const browserResource=['script','style','worker','sharedworker','serviceworker']
                     .includes(request.headers['sec-fetch-dest']);
                 // Selecting application pages does not turn retained originals
                 // into resources. HTML components remain owned by html-import.
                 const componentDocument=explicitDocuments&&html&&!selectedDocument
-                    &&await isCurrentComponent(target.path, selectedRoutes);
+                    &&await isCurrentComponent(resourcePath, selectedRoutes);
                 const retainedDocument=explicitDocuments&&html&&!selectedDocument&&!componentDocument;
                 const rewrite=!retainedDocument&&(runtimeResource||entryDocument||browserResource||managedMap
-                    ||componentDocument||resourcePaths.has(target.path));
+                    ||componentDocument||resourcePaths.has(resourcePath));
                 const onReference = function observeServedResource(reference) {
                     const {url,kind,baseKind}=reference;
                     if (pwaEnabled && kind !== 'fetch'
                         && !(kind === 'import' && !/^(?:\.{1,2}\/|\/)/u.test(url))) {
                         try {
-                            const documentUrl = new URL(target.path, 'http://arcane.invalid');
+                            const documentUrl = new URL(resourcePath, 'http://arcane.invalid');
                             const resource = resolveAssetReference(
                                 {...reference,url:versionAssetUrl(url,null)},
                                 {ownerUrl:documentUrl}
@@ -1354,7 +1397,7 @@ async function startOwnedDevServer({
                     if(baseKind==='document'||kind==='fetch'||(kind==='asset'&&!/\.css(?:[?#]|$)/iu.test(url))
                         ||(kind==='import'&&!/^(?:\.{1,2}\/|\/)/u.test(url)))return;
                     try{
-                        const documentUrl=new URL(target.path,'http://arcane.invalid');
+                        const documentUrl=new URL(resourcePath,'http://arcane.invalid');
                         const resource=resolveAssetReference(reference,{ownerUrl:documentUrl});
                         if(resource.origin===documentUrl.origin
                             &&/\.(?:m?js|html?|css)$/iu.test(resource.pathname)){

package/src/index.mjs

@@ -146,6 +146,7 @@ export {
 export {materializeInstalledSdkRuntime} from './installed-sdk-runtime.mjs';
 export {startDevServer} from './dev-server.mjs';
 export {startSourceExampleServer} from './source-server.mjs';
+export {acceptWebSocket} from './websocket.mjs';
 export {
     NATIVE_BUILD_PLAN_PROTOCOL,
     NATIVE_BUILDER_PROTOCOL,

package/src/packager/core.mjs

@@ -788,7 +788,7 @@ async function loadAdapter(context){
     return module;
 }
 
-function releaseManifest(context,files,pwaArtifacts){
+function releaseManifest(context,files,pwaArtifacts,rootDocument){
     return {
         schemaVersion:1,
         kind:'arcane-app-release',
@@ -799,6 +799,7 @@ function releaseManifest(context,files,pwaArtifacts){
             version:context.config.version,
             entry:context.config.entry,
             start:packageResourceUrl(appPackagePath(context, context.config.entry)),
+            ...(rootDocument ? {rootDocument} : {}),
             strategy:context.config.strategy,
             shared:[...context.config.shared],
             ...(pwaArtifacts?{pwa:{
@@ -845,6 +846,11 @@ async function packageWithContext(context,options={}){
     const appPath=appRelativeRoot(context.rootConfig,context.appId);
     const entryPath=appPackagePath(context,context.config.entry);
     const records=await collectPackageRecords(context,{signal});
+    const rootDocument = records.some(
+        function selectedRootIndex(record) {
+            return record.destination === 'index.html';
+        }
+    ) ? './index.html' : undefined;
     const inspected=await inspectContext(context,{signal,records});
     if(options.dryRun){
         return {
@@ -888,9 +894,7 @@ async function packageWithContext(context,options={}){
     try{
         async function copyBase() {
             await copyRecords(records,stagingRoot,{signal,onEvent});
-            if (!records.some(function selectedRootIndex(record) {
-                return record.destination === 'index.html';
-            })) {
+            if (!rootDocument) {
                 await writePackageLauncher(context, stagingRoot);
             }
         }
@@ -1050,6 +1054,7 @@ async function packageWithContext(context,options={}){
             sdkVersion:assetVersion,
             pwa:context.config.pwa,
             files,
+            navigationAliases: rootDocument ? {} : {'./': packageResourceUrl(entryPath)},
             assets:[...offlineReferences]
         }):null;
         if(pwaArtifacts){
@@ -1080,7 +1085,7 @@ async function packageWithContext(context,options={}){
             }
             files.sort(compareText);
         }
-        const manifest=releaseManifest(context,files,pwaArtifacts);
+        const manifest=releaseManifest(context,files,pwaArtifacts,rootDocument);
         await writeFile(
             path.join(stagingRoot,RELEASE_MANIFEST_NAME),
             `${JSON.stringify(manifest,null,2)}\n`,

package/src/pwa-worker.mjs

@@ -496,8 +496,10 @@ function installPwaWorker(manifest, clientUrl) {
 
     function staticNavigationResource(url) {
         const document = new URL(url);
-        if (document.origin !== scopeOrigin || !document.search
-            || !/\.html?$/iu.test(document.pathname)) {
+        if (document.origin !== scopeOrigin) return null;
+        if (document.pathname.endsWith('/')) {
+            document.pathname += 'index.html';
+        } else if (!document.search || !/\.html?$/iu.test(document.pathname)) {
             return null;
         }
         document.search = '';

package/src/toolchain.mjs

@@ -330,24 +330,41 @@ async function refreshRootApplicationFiles(prepared,inspected,importMap,{signal,
     const manifest=prepared.validation.app.manifest;
     const installed=await readInstalledSdkLayout(workspaceRoot,prepared.validation.config);
     const entry=`/${manifest.entry.split('/').map(encodeURIComponent).join('/')}`;
-    const navigationAliases={
-        '/':entry
-    };
+    const pwaEnabled = installed?.direct && manifest.pwa?.enabled;
+    let authoredRoot = false;
+    if (pwaEnabled) {
+        try {
+            authoredRoot = (await lstat(path.join(workspaceRoot, 'index.html'))).isFile();
+        } catch (error) {
+            if (error.code !== 'ENOENT') throw error;
+        }
+    }
+    // A host homepage need not belong to the selected application or its cache.
+    const navigationAliases = authoredRoot ? {} : {'/': entry};
+    function rootIndexPath(relative) {
+        return (process.platform === 'win32' ? relative.toLowerCase() : relative) === 'index.html';
+    }
+    const selectedRootIndex = authoredRoot && manifest.include.some(rootIndexPath)
+        && !manifest.exclude.some(rootIndexPath);
     // The source host serves the installed files in place. There is no runtime projection.
     const files=[...new Set([
-        ...inspected.files.filter(file=>file!=='index.html'||manifest.include.includes('index.html')),
+        ...inspected.files.filter(
+            function selectedSourceFile(file) {
+                return file !== 'index.html' || selectedRootIndex;
+            }
+        ),
         importMap.artifactRelativePath
     ])];
     const sourceOrigin='http://arcane.invalid';
     const selectedPaths=new Set(files.map(function selectedStaticPath(file){
         return new URL(`/${file.split('/').map(encodeURIComponent).join('/')}`,sourceOrigin).pathname;
     }));
-    const assets=installed?.direct&&manifest.pwa?.enabled
+    const assets=pwaEnabled
         ?(await collectSourcePwaAssets({workspaceRoot,appId,signal,onEvent})).filter(function selectedStaticVariant(value){
             const url=new URL(value,sourceOrigin);
             return url.origin===sourceOrigin&&selectedPaths.has(url.pathname);
         }):[];
-    const pwa=installed?.direct&&manifest.pwa?.enabled?createPwaArtifacts({
+    const pwa=pwaEnabled?createPwaArtifacts({
         app:{id:appId,displayName:manifest.displayName,version:manifest.version,entry},
         sdkVersion:installed.version,
         pwa:manifest.pwa,