arcane-os 0.3.1 → 0.3.3

package/src/templates/workspace-template.mjs

@@ -1,8 +1,10 @@
-import {SDK_NAME,SDK_VERSION} from '../constants.mjs';
 import {
-    SDK_BROWSER_RUNTIME_CONTENT_SHA256,
-    SDK_BROWSER_RUNTIME_MANIFEST_SHA256
-} from '../sdk-browser-runtime.mjs';
+    ARCANE_PROTOCOL,
+    CLI_EVENT_PROTOCOL,
+    SDK_NAME,
+    SDK_VERSION,
+    TARGET_ADAPTER_PROTOCOL
+} from '../constants.mjs';
 
 const NPM_PACKAGE_NAME_PATTERN=/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u;
 const LOCAL_TARBALL_PATTERN=/^file:.+\.tgz$/iu;
@@ -26,11 +28,35 @@ function titleCase(appId){
         .join(' ');
 }
 
+export function createWorkspaceLockDocument({
+    dependencyName=SDK_NAME,
+    packageName=SDK_NAME,
+    packageVersion=SDK_VERSION,
+    packageSource=`node_modules/${dependencyName}`
+}={}){
+    if(packageName!==SDK_NAME||typeof packageVersion!=='string'
+        ||!/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/u.test(packageVersion)
+        ||typeof dependencyName!=='string'||dependencyName.length>214
+        ||!NPM_PACKAGE_NAME_PATTERN.test(dependencyName)
+        ||packageSource!==`node_modules/${dependencyName}`){
+        throw new Error('Invalid workspace SDK lock authority.');
+    }
+    return {
+        schemaVersion:1,
+        sdk:{name:packageName,version:packageVersion},
+        runtime:{root:`${packageSource}/runtime`},
+        sdkBrowserRuntime:{root:`${packageSource}/browser-runtime`},
+        protocols:{
+            arcane:ARCANE_PROTOCOL,
+            cliEvents:CLI_EVENT_PROTOCOL,
+            targetAdapter:TARGET_ADAPTER_PROTOCOL
+        }
+    };
+}
+
 export function workspaceTemplate({
     appId,
     displayName,
-    runtimeRelease,
-    sdkBrowserRuntimeRelease,
     sdkDependencyName=SDK_NAME,
     sdkDependencySpecifier=SDK_VERSION,
     sdkPackageSource=`node_modules/${sdkDependencyName}`,
@@ -65,31 +91,6 @@ export function workspaceTemplate({
     }
     const name=displayName||`Arcane ${titleCase(appId)}`;
     const packageName=`arcane-${appId}`;
-    const runtimeContentSha256=runtimeRelease?.contentSha256;
-    const upstreamCommit=runtimeRelease?.source?.legacyProjection?.commit;
-    const browserManifestSha256=sdkBrowserRuntimeRelease?.manifestSha256;
-    const browserContentSha256=sdkBrowserRuntimeRelease?.contentSha256;
-    const browserSource=sdkBrowserRuntimeRelease?.source;
-    const expectedBrowserDependencies=[
-        {
-            name:'event-pubsub',
-            version:'6.1.0',
-            resolved:'https://registry.npmjs.org/event-pubsub/-/event-pubsub-6.1.0.tgz',
-            integrity:'sha512-FEMlhTxwqGM0hztTixG6FhVFXqp7Eq1ltk5mSreK6Mhy3xWWpLAzEUR6OMvMdNqT3jgSxA8JDhnhyAG3X4Xy7Q=='
-        },
-        {
-            name:'strong-type',
-            version:'2.0.0',
-            resolved:'https://registry.npmjs.org/strong-type/-/strong-type-2.0.0.tgz',
-            integrity:'sha512-HHrY9qYC7yn+5mlewiI3k9RQM9gZqGQsqbomZcd10Ks0h4RlX01nnkWbCe4AsVPCI6KaFvpkWm1nHMD+Ykup6g=='
-        },
-        {
-            name:'@wllama/wllama',
-            version:'3.6.0',
-            resolved:'https://registry.npmjs.org/@wllama/wllama/-/wllama-3.6.0.tgz',
-            integrity:'sha512-NN3ZBXqaaUwGXTQubkNvsCaLPjN2XVa0bVS40OYCE8zquYmRc2W3oHYEgwvuSWWDB8aUqTLyMioySCXNkcnD1w=='
-        }
-    ];
     const packageInclude=[`${appId}.css`,'index.html'];
     if(native)packageInclude.push('img/icon.png');
     packageInclude.push('manifest.json','modules');
@@ -114,34 +115,6 @@ the SDK's license terms; replace it with your own raster application icon when
 appropriate.
 `:'';
 
-    if(!appOnly&&(typeof runtimeContentSha256!=='string'||!/^[a-f0-9]{64}$/.test(runtimeContentSha256))){
-        throw new Error('The SDK runtime release does not contain a valid contentSha256.');
-    }
-    if(!appOnly&&(typeof upstreamCommit!=='string'||!/^[a-f0-9]{40}$/.test(upstreamCommit))){
-        throw new Error('The SDK runtime release does not contain a valid upstream commit.');
-    }
-    if(!appOnly&&(
-        browserManifestSha256!==SDK_BROWSER_RUNTIME_MANIFEST_SHA256
-        ||browserContentSha256!==SDK_BROWSER_RUNTIME_CONTENT_SHA256
-        ||sdkBrowserRuntimeRelease?.builder!=='arcane-sdk-browser-runtime-v1'
-        ||sdkBrowserRuntimeRelease?.sdkVersion!==SDK_VERSION
-        ||browserSource?.protocol!=='arcane-sdk-browser-runtime/1'
-        ||browserSource?.authority!=='arcane-os-sdk'
-        ||browserSource?.repository!=='https://github.com/TheWizardNexus/arcane-os-sdk.git'
-        ||browserSource?.browserEntry!=='arcane-os/event-manager'
-        ||!Array.isArray(browserSource?.dependencies)
-        ||browserSource.dependencies.length!==expectedBrowserDependencies.length
-        ||browserSource.dependencies.some((actual,index)=>{
-            const expected=expectedBrowserDependencies[index];
-            return !actual||Object.keys(actual).sort().join('\0')
-                    !==['name','version','resolved','integrity'].sort().join('\0')
-                ||actual.name!==expected.name||actual.version!==expected.version
-                ||actual.resolved!==expected.resolved||actual.integrity!==expected.integrity;
-        })
-    )){
-        throw new Error('The SDK browser runtime release does not contain a valid trusted identity.');
-    }
-
     const importMapMarkup=namedImports?`    <script type="importmap" data-arcane-import-map>
 {
   "imports": {}
@@ -176,28 +149,29 @@ appropriate.
 - Keep \`arcane/css/theme.css\` before app styles and import \`arcane/ThemeBootstrap\` before app code runs.
 - Use \`rgb(...)\` or \`rgba(...)\` for new CSS colors.
 - Build one named app and one explicit target at a time. Native targets may be unavailable until their adapters are installed.
+- Preserve complete application, model, document, message, log, diagnostic, process, and tool content. Do not truncate, clip, tail, elide, or silently discard it.
+- Do not make ordinary application behavior depend on byte counts, byte limits, byte identities, hashes, digests, or byte-based admission.
+- Optional hardening must remain inactive unless the user expressly selects secure: true for the exact operation. The ordinary path must remain fully functional.
 - Run tests and checks only when the user explicitly selects verification or a distribution artifact requires it.
 `);
     files.set('README.md',`# ${name}
 
-This repository contains the portable Arcane application \`${appId}\`. It embeds immutable SDK runtime bytes for distribution and has no runtime dependency on an Arcane OS source checkout.
+This repository contains the portable Arcane application \`${appId}\`. It includes the selected SDK runtime for distribution and has no runtime dependency on an Arcane OS source checkout.
 
 ## Start
 
 \`\`\`sh
 npm install
-npm run doctor
 npm run dev
 \`\`\`
 
-Open the loopback URL printed by the development server. The source server exposes this app and its authenticated physical \`arcane/\` runtime; it does not expose an Ollama HTTP endpoint.
+Open the loopback URL printed by the development server. The source server exposes this app and its physical \`arcane/\` runtime; it does not expose an Ollama HTTP endpoint.
 
 Commit the generated \`package-lock.json\` after dependency installation. CI intentionally uses \`npm ci\` and therefore requires that lock. Before the SDK is published, install a locally packed \`${SDK_NAME}\` \`.tgz\` with \`npm install --save-dev --save-exact <path-to-tarball>\`; keep that tarball at the lock file's relative path for repeatable local \`npm ci\` runs.
 
-## Check and release the browser package
+## Optional browser release commands
 
 \`\`\`sh
-npm run check
 npm run import-map
 npm run package
 npm run verify
@@ -207,12 +181,16 @@ npm run run
 
 The explicit \`import-map\` command refreshes
 \`apps/${appId}/modules/arcane.importmap.json\` and the managed inline browser
-import map in \`index.html\`. Development, package, and build refresh it
-automatically. Named \`arcane/*\` imports resolve against the physical workspace
-\`arcane/\` tree. Packaging copies the same authenticated bytes and specifier map
-to \`dist/${appId}\`, \`verify\` authenticates that directory, \`bundle\` creates
-its distributable archive, and \`run\` launches the verified packaged browser
-release.
+import map in every directly navigable descriptor-admitted \`.html\`/\`.htm\`
+document. HTML component fragments remain package files but do not receive a
+document-level base or managed import map.
+Development, package, and build refresh that shared inventory when the selected operation needs it.
+Named \`arcane/*\` imports resolve against the physical workspace \`arcane/\`
+tree. Packaging copies the complete selected application, runtime, and specifier
+map to \`dist/${appId}\` without running application tests. Run \`verify\` only when
+the user explicitly selects verification or a release artifact that requires it;
+\`bundle\` creates the distributable archive and \`run\` launches the selected
+packaged browser release.
 
 Native targets are provider-supplied and must be scaffolded and selected
 explicitly; this browser workflow does not imply a standalone native executable.
@@ -254,7 +232,7 @@ Every browser release also carries Arcane OS licensing material under \`licenses
                 {
                     source:'arcane',
                     destination:'arcane',
-                    include:['components','css','dependencies','entities','img','modules','sdk','security'],
+                    include:['components','css','dependencies','entities','img','modules','sdk'],
                     exclude:[]
                 },
                 {
@@ -266,54 +244,10 @@ Every browser release also carries Arcane OS licensing material under \`licenses
             ]
         }
     }));
-    files.set('arcane.lock.json',json({
-        schemaVersion:1,
-        sdk:{name:SDK_NAME,version:SDK_VERSION},
-        runtime:{
-            manifest:`${sdkPackageSource}/runtime/ARCANE_RUNTIME_RELEASE.json`,
-            contentSha256:runtimeContentSha256,
-            upstreamCommit
-        },
-        sdkBrowserRuntime:{
-            manifest:`${sdkPackageSource}/browser-runtime/ARCANE_SDK_BROWSER_RELEASE.json`,
-            manifestSha256:browserManifestSha256,
-            contentSha256:browserContentSha256,
-            builder:sdkBrowserRuntimeRelease?.builder,
-            sdkVersion:sdkBrowserRuntimeRelease?.sdkVersion,
-            source:sdkBrowserRuntimeRelease?.source
-        },
-        protocols:{
-            arcane:'arcane/1',
-            cliEvents:'arcane-cli-events/1',
-            targetAdapter:'arcane-target-adapter/1'
-        }
-    }));
-    files.set('.github/workflows/check.yml',`name: check
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  check:
-    runs-on: \${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          package-manager-cache: false
-      - run: npm ci --ignore-scripts
-      - run: npm run check
-`);
+    files.set('arcane.lock.json',json(createWorkspaceLockDocument({
+        dependencyName:sdkDependencyName,
+        packageSource:sdkPackageSource
+    })));
     files.set(`apps/${appId}/arcane-app.json`,json({
         schemaVersion:2,
         id:appId,
@@ -331,15 +265,6 @@ jobs:
             exclude:[],
             shared:['browser-runtime']
         },
-        permissions:{
-            capabilities:[],
-            methods:[]
-        },
-        security:{
-            connectOrigins:[],
-            frameOrigins:[],
-            mediaOrigins:[]
-        },
         native:{
             type:'app',
             icon:native?'img/icon.png':null,
@@ -348,7 +273,7 @@ jobs:
         },
         requirements:{
             arcaneProtocol:'arcane/1',
-            minimumCoreVersion,
+            ...(native?{minimumCoreVersion}:{}),
             features:[]
         },
         targets:native?['browser',target].sort():['browser']
@@ -360,18 +285,13 @@ jobs:
         version:'0.1.0',
         entry:'index.html',
         strategy:'static',
-        security:{
-            connectOrigins:[],
-            frameOrigins:[],
-            mediaOrigins:[]
-        },
         include:packageInclude,
         exclude:[],
         shared:['browser-runtime']
     }));
     files.set(`apps/${appId}/manifest.json`,json({
         name,
-        short_name:titleCase(appId).slice(0,30),
+        short_name:titleCase(appId),
         start_url:'./index.html',
         display:'standalone',
         background_color:'rgb(13, 18, 32)',

package/src/testing-loader.mjs

@@ -1,13 +1,177 @@
+import {lstatSync,realpathSync} from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
 const TESTING_SPECIFIER='arcane-os/testing';
 const TESTING_URL=new URL('./testing.mjs',import.meta.url).href;
 const RUNTIME_STRONG_TYPE_SPECIFIER='../../node_modules/strong-type/index.js';
 const RUNTIME_ARCANE_URL=new URL('../runtime/arcane/',import.meta.url).href;
 const STRONG_TYPE_URL=new URL('../runtime/strong-type/index.js',import.meta.url).href;
+const MANAGED_IMPORT_MAP_PROTOCOL='arcane-test-import-map/1';
+const MANAGED_IMPORT_MAP_BOUNDARIES=new Set(['source','dist','test']);
+
+let managedImports=null;
+let managedUrlImports=null;
+
+function loaderFailure(message,code='ARCANE_IMPORT_MAP_INVALID'){
+    const error=new Error(message);
+    error.code=code;
+    throw error;
+}
+
+function urlLikeSpecifier(specifier){
+    return specifier.startsWith('./')||specifier.startsWith('../')
+        ||specifier.startsWith('/')||/^[A-Za-z][A-Za-z0-9+.-]*:/u.test(specifier);
+}
+
+function safeManagedTarget(target){
+    return typeof target==='string'
+        &&target.startsWith('./')
+        &&target.length>2
+        &&!/[\\%?#\u0000-\u001f\u007f]/u.test(target)
+        &&target.slice(2).split('/').every(
+            segment=>segment!==''&&segment!=='.'&&segment!=='..'
+        );
+}
+
+function samePath(left,right){
+    const a=path.resolve(left);
+    const b=path.resolve(right);
+    return process.platform==='win32'?a.toLowerCase()===b.toLowerCase():a===b;
+}
+
+function pathInside(root,candidate){
+    const relative=path.relative(root,candidate);
+    return relative===''||(!path.isAbsolute(relative)&&relative!=='..'
+        &&!relative.startsWith(`..${path.sep}`));
+}
+
+function physicalDirectory(baseURL){
+    let parsed;
+    try{parsed=new URL(baseURL);}
+    catch{loaderFailure('Managed test import-map base URL is invalid.');}
+    if(parsed.protocol!=='file:'||parsed.username||parsed.password||parsed.search||parsed.hash
+        ||!parsed.pathname.endsWith('/')){
+        loaderFailure('Managed test import-map base URL must select one application directory.');
+    }
+    const root=fileURLToPath(parsed);
+    let info;
+    let canonical;
+    try{
+        info=lstatSync(root);
+        canonical=realpathSync(root);
+    }catch(error){
+        loaderFailure(`Managed test import-map application directory is unavailable: ${error.message}`);
+    }
+    if(info.isSymbolicLink()||!info.isDirectory()||!samePath(root,canonical)){
+        loaderFailure('Managed test import-map base must be one real application directory.');
+    }
+    return {url:parsed,root:canonical};
+}
+
+function physicalManagedTarget(target,specifier,boundary,boundaryName){
+    const relative=target.slice(2);
+    if(boundaryName==='source'&&/^(?:dist|test)\//u.test(relative)){
+        loaderFailure(
+            `Managed source import-map target selects a different application boundary: ${specifier}.`,
+            'ARCANE_IMPORT_MAP_UNRESOLVED'
+        );
+    }
+    let targetURL;
+    try{targetURL=new URL(target,boundary.url);}
+    catch{loaderFailure(`Managed test import-map target is invalid: ${specifier}.`);}
+    if(targetURL.protocol!=='file:'||targetURL.username||targetURL.password
+        ||targetURL.search||targetURL.hash){
+        loaderFailure(`Managed test import-map target is invalid: ${specifier}.`);
+    }
+    const targetPath=fileURLToPath(targetURL);
+    let info;
+    let canonical;
+    try{
+        info=lstatSync(targetPath);
+        canonical=realpathSync(targetPath);
+    }catch(error){
+        loaderFailure(
+            `Managed test import-map target is unavailable for ${specifier}: ${error.message}`,
+            'ARCANE_IMPORT_MAP_UNRESOLVED'
+        );
+    }
+    if(info.isSymbolicLink()||!info.isFile()||!samePath(targetPath,canonical)
+        ||!pathInside(boundary.root,canonical)){
+        loaderFailure(
+            `Managed test import-map target leaves its selected application directory: ${specifier}.`,
+            'ARCANE_IMPORT_MAP_UNRESOLVED'
+        );
+    }
+    return targetURL.href;
+}
+
+export function initialize({managedImportMap}={}){
+    if(managedImportMap==null){
+        managedImports=null;
+        managedUrlImports=null;
+        return;
+    }
+    const imports=managedImportMap.imports;
+    if(managedImportMap.protocol!==MANAGED_IMPORT_MAP_PROTOCOL
+        ||!MANAGED_IMPORT_MAP_BOUNDARIES.has(managedImportMap.boundary)
+        ||imports===null||typeof imports!=='object'||Array.isArray(imports)){
+        loaderFailure('Managed test import-map loader data is malformed.');
+    }
+    const boundary=physicalDirectory(managedImportMap.baseURL);
+    const exact=new Map();
+    const urls=new Map();
+    for(const [specifier,target] of Object.entries(imports)){
+        if(typeof specifier!=='string'||specifier===''||!safeManagedTarget(target)){
+            loaderFailure(`Managed test import-map entry is invalid: ${String(specifier)}.`);
+        }
+        const targetURL=physicalManagedTarget(
+            target,
+            specifier,
+            boundary,
+            managedImportMap.boundary
+        );
+        exact.set(specifier,targetURL);
+        if(urlLikeSpecifier(specifier)){
+            let keyURL;
+            try{keyURL=new URL(specifier,boundary.url).href;}
+            catch{loaderFailure(`Managed test import-map URL key is invalid: ${specifier}.`);}
+            if(urls.has(keyURL)&&urls.get(keyURL)!==targetURL){
+                loaderFailure(`Managed test import-map URL keys collide: ${specifier}.`);
+            }
+            urls.set(keyURL,targetURL);
+        }
+    }
+    managedImports=exact;
+    managedUrlImports=urls;
+}
+
+function managedResolution(specifier,context){
+    if(managedImports===null)return null;
+    if(managedImports.has(specifier))return managedImports.get(specifier);
+    if(urlLikeSpecifier(specifier)&&typeof context.parentURL==='string'){
+        let requested;
+        try{requested=new URL(specifier,context.parentURL).href;}
+        catch{requested=null;}
+        if(requested!==null&&managedUrlImports.has(requested)){
+            return managedUrlImports.get(requested);
+        }
+    }
+    if(specifier.startsWith('arcane/')||specifier.startsWith('#arcane/')){
+        loaderFailure(
+            `Managed test import map does not expose ${specifier}.`,
+            'ARCANE_IMPORT_MAP_UNRESOLVED'
+        );
+    }
+    return null;
+}
 
 export function resolve(specifier,context,nextResolve){
     if(specifier===TESTING_SPECIFIER){
         return {url:TESTING_URL,shortCircuit:true};
     }
+    const managed=managedResolution(specifier,context);
+    if(managed!==null)return {url:managed,shortCircuit:true};
     if(specifier===RUNTIME_STRONG_TYPE_SPECIFIER
         &&context.parentURL?.startsWith(RUNTIME_ARCANE_URL)){
         return {url:STRONG_TYPE_URL,shortCircuit:true};

package/src/testing.mjs

@@ -52,7 +52,7 @@ function definition(name,optionsOrCallback,maybeCallback){
     if(typeof callback!=='function'){
         throw new TypeError(`Test "${name}" requires a callback function.`);
     }
-    return Object.freeze({name,timeoutMs:testTimeout(options),callback});
+    return {name,timeoutMs:testTimeout(options),callback};
 }
 
 export function test(name,optionsOrCallback,maybeCallback){