Package portable headless runtime with independent Node and browser consumers
This commit is contained in:
@@ -8,6 +8,7 @@ import { stripTypeScriptTypes } from 'node:module';
|
||||
import { setTimeout as pause } from 'node:timers/promises';
|
||||
|
||||
const root = resolve(import.meta.dirname, '../..'), profile = await mkdtemp(join(tmpdir(), 'endoleap-storage-browser-'));
|
||||
const packageMode=process.argv.includes('--package');
|
||||
const readStreams=new Map();
|
||||
const server = createServer(async (request, response) => {
|
||||
try {
|
||||
@@ -25,8 +26,9 @@ const server = createServer(async (request, response) => {
|
||||
response.setHeader('Content-Type','application/json');response.end(JSON.stringify({reads:state.reads}));return;
|
||||
}
|
||||
if (path === '/') { response.setHeader('Content-Type', 'text/html'); response.end('<title>Headless storage checks</title>'); return; }
|
||||
const filename = resolve(root, `.${path}`);
|
||||
if (!filename.startsWith(`${root}/src/lib/`) && !filename.startsWith(`${root}/tests/headless/`)) { response.writeHead(404).end(); return; }
|
||||
const isPackage=packageMode&&path.startsWith('/package/');
|
||||
const filename = isPackage?resolve(root,'.headless-dist',path.slice('/package/'.length)):resolve(root, `.${path}`);
|
||||
if (!(isPackage&&filename.startsWith(`${root}/.headless-dist/`)) && !filename.startsWith(`${root}/src/lib/`) && !filename.startsWith(`${root}/tests/headless/`)) { response.writeHead(404).end(); return; }
|
||||
let source = await readFile(filename, 'utf8');
|
||||
if (filename.endsWith('.ts')) source = stripTypeScriptTypes(source);
|
||||
response.setHeader('Content-Type', 'text/javascript'); response.end(source);
|
||||
@@ -56,7 +58,7 @@ try {
|
||||
await pause(50);
|
||||
}
|
||||
if (!loaded) throw new Error('browser test origin did not finish loading');
|
||||
const result = await call('Runtime.evaluate', { expression: "import('/tests/headless/browser-storage-cases.mjs').then(module => module.run())", awaitPromise: true, returnByValue: true, timeout: 30000 });
|
||||
const result = await call('Runtime.evaluate', { expression: `import('/tests/headless/${packageMode?'package-browser-cases':'browser-storage-cases'}.mjs').then(module => module.run())`, awaitPromise: true, returnByValue: true, timeout: 30000 });
|
||||
if (result.exceptionDetails) throw new Error(result.exceptionDetails.exception?.description ?? result.exceptionDetails.text);
|
||||
for (const message of result.result.value) console.log(`PASS ${message}`);
|
||||
} finally {
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
/** Imports compiled ESM directly: no TypeScript stripping or application bundler. */
|
||||
import {createRegistry,builtinComponents,createDocument} from '/package/modules/canvas-core/index.js';
|
||||
import {openProjectEngine} from '/package/modules/canvas-runtime/index.js';
|
||||
import {createFoundryPersistence} from '/package/modules/canvas-service/index.js';
|
||||
import {createBrowserStorage,createBrowserDigests,createBrowserImageDecoder} from '/package/modules/canvas-runtime/browser.js';
|
||||
export async function run(){
|
||||
const assert=(condition,message)=>{if(!condition)throw Error(message);},results=[];
|
||||
const name=`headless-package-${crypto.randomUUID()}`,storage=createBrowserStorage({name}),digests=createBrowserDigests(),images=createBrowserImageDecoder();
|
||||
const scope={accountId:crypto.randomUUID(),workspaceId:crypto.randomUUID(),projectId:crypto.randomUUID()},registry=createRegistry(builtinComponents()),document=createDocument(scope.projectId,[{id:scope.projectId,parent:null}],[]);
|
||||
const workerUrls=[],NativeWorker=globalThis.Worker;let active=0;
|
||||
globalThis.Worker=class extends NativeWorker{constructor(url,...args){super(url,...args);workerUrls.push(String(url));active++;this.live=true;}terminate(){if(this.live){this.live=false;active--;}super.terminate();}};
|
||||
let engine;
|
||||
try{
|
||||
const canvas=new OffscreenCanvas(4,2);canvas.getContext('2d').fillRect(0,0,4,2);const bytes=await canvas.convertToBlob({type:'image/png'});
|
||||
const dimensions=await images.decode(bytes);assert(dimensions.width===4&&dimensions.height===2,'compiled image Worker dimensions');
|
||||
const digest=await digests.digest(bytes),expected=[...new Uint8Array(await crypto.subtle.digest('SHA-256',await bytes.arrayBuffer()))].map(value=>value.toString(16).padStart(2,'0')).join('');assert(digest===expected,'compiled digest Worker SHA256');
|
||||
assert(workerUrls.some(url=>url.endsWith('/image.worker.js'))&&workerUrls.some(url=>url.endsWith('/digest.worker.js')),'Worker URLs did not resolve emitted JS');assert(active===0,'compiled Workers leaked');
|
||||
results.push('compiled image and digest module Workers load emitted JS, decode a real PNG, match native SHA256 and terminate');
|
||||
// Keep networking explicitly held: verify the actual browser durability adapter
|
||||
// independently of an invented backend protocol implementation.
|
||||
const persistence={...createFoundryPersistence({registry,rootId:scope.projectId,workspaceId:scope.workspaceId,transport:async()=>{throw Error('unexpected network');}}),supportsRequest:()=>false};
|
||||
const open=()=>openProjectEngine({scope,registry,document,versions:new Map([[scope.projectId,1]]),storage,persistence,createId:()=>crypto.randomUUID()});
|
||||
engine=await open();
|
||||
const target={id:crypto.randomUUID(),incarnation:1};
|
||||
assert(engine.editor.dispatch({type:'element.create',element:{...target,ownerCanvasId:scope.projectId,componentId:'text',dataVersion:1,structure:'node',data:{title:'Packed recovery',text:'persisted'},geometry:{x:12,y:24,width:160,height:80,rotation:0}}}).status==='applied','compiled command rejected');
|
||||
engine.sessions.attach('temporary-view');
|
||||
await engine.settle();const revision=engine.getSnapshot().rootRevision;await engine.close();engine=await open();
|
||||
assert(engine.getSnapshot().rootRevision>=revision,'compiled IndexedDB recovery revision regressed');assert(engine.getSnapshot().document.elements.get(target.id)?.data.text==='persisted','compiled durable document lost');assert(engine.getSnapshot().history.undo.length===1,'compiled durable history lost');assert(engine.sessions.getSnapshot().views.size===0,'transient sessions persisted');await engine.settle();
|
||||
results.push('compiled browser storage and engine claim/release Web Locks and recover an edited document/history from IndexedDB without persisting views');
|
||||
return results;
|
||||
}finally{await engine?.close();images.close();digests.close();storage.close();globalThis.Worker=NativeWorker;indexedDB.deleteDatabase(name);}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import { mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { dirname, join, resolve } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
const root=resolve(dirname(fileURLToPath(import.meta.url)),'../..');
|
||||
const temporary=await realpath(await mkdtemp(join(tmpdir(),'endoleap-headless-package-')));
|
||||
const run=(program,args,options={})=>execFileSync(program,args,{cwd:root,encoding:'utf8',stdio:['ignore','pipe','pipe'],...options});
|
||||
try {
|
||||
run(process.execPath,['scripts/build-headless.mjs']);
|
||||
const packed=JSON.parse(run('npm',['pack','--offline','--ignore-scripts','--json','--pack-destination',temporary],{cwd:join(root,'.headless-dist'),env:{...process.env,npm_config_cache:join(temporary,'npm-cache')}}));
|
||||
assert.equal(packed.length,1);
|
||||
run('tar',['-xzf',join(temporary,packed[0].filename),'-C',temporary]);
|
||||
const packageRoot=join(temporary,'package');
|
||||
const metadata=JSON.parse(await readFile(join(packageRoot,'package.json'),'utf8'));
|
||||
assert.equal(metadata.private,true);assert.equal(metadata.type,'module');
|
||||
assert.equal(Object.keys(metadata.dependencies??{}).length,0);
|
||||
assert.equal(Object.keys(metadata.peerDependencies??{}).length,0);
|
||||
// Resolve every import through the packed artifact, never checkout node_modules.
|
||||
await writeFile(join(temporary,'guard-loader.mjs'),`
|
||||
import {fileURLToPath} from 'node:url';
|
||||
import {sep} from 'node:path';
|
||||
const root=${JSON.stringify(packageRoot)};
|
||||
export async function resolve(specifier,context,next){
|
||||
if(specifier.startsWith('node:'))return next(specifier,context);
|
||||
const result=await next(specifier,context);
|
||||
if(!result.url.startsWith('file:')||!fileURLToPath(result.url).startsWith(root+sep))throw Error('External dependency: '+specifier);
|
||||
return result;
|
||||
}
|
||||
`);
|
||||
await writeFile(join(temporary,'guard.mjs'),`
|
||||
import {register} from 'node:module';
|
||||
register('./guard-loader.mjs',import.meta.url);
|
||||
for(const name of ['window','document','navigator','indexedDB','Worker'])Object.defineProperty(globalThis,name,{configurable:true,get(){throw Error('Browser global: '+name);}});
|
||||
`);
|
||||
const report=JSON.parse(run(process.execPath,['--import',join(temporary,'guard.mjs'),join(packageRoot,'consumer.mjs')],{cwd:temporary}));
|
||||
assert.equal(report.status,'ok');assert.equal(report.reopened,true);assert.equal(report.elements,2);
|
||||
// No DOM library: browser adapter declarations must not leak into portable ports.
|
||||
await writeFile(join(packageRoot,'consumer-types.mts'),`
|
||||
import {createRegistry,builtinComponents,createDocument} from '@endoleap/headless-canvas/core';
|
||||
import {openProjectEngine,type StoragePort,type StorageScope} from '@endoleap/headless-canvas/runtime';
|
||||
import {createFoundryPersistence,type ServiceTransport} from '@endoleap/headless-canvas/service';
|
||||
const registry=createRegistry(builtinComponents());
|
||||
export function open(scope:StorageScope,storage:StoragePort,transport:ServiceTransport){
|
||||
return openProjectEngine({scope,storage,registry,document:createDocument(scope.projectId,[{id:scope.projectId,parent:null}],[]),versions:new Map([[scope.projectId,1]]),persistence:createFoundryPersistence({registry,transport,rootId:scope.projectId,workspaceId:scope.workspaceId})});
|
||||
}
|
||||
`);
|
||||
run(process.execPath,[join(root,'node_modules/typescript/bin/tsc'),'--noEmit','--strict','--target','ES2022','--module','NodeNext','--moduleResolution','NodeNext','--lib','ES2022','--types','node','--typeRoots',join(root,'node_modules/@types'),join(packageRoot,'consumer-types.mts')],{cwd:temporary});
|
||||
const browser=run(process.execPath,['tests/headless/browser-storage.mjs','--package']);
|
||||
process.stdout.write(browser);
|
||||
console.log(JSON.stringify({compiledBrowserAdapters:true,status:'ok',packedFiles:packed[0].files.length,consumer:report,nodeTypes:true,browserGlobalsBlocked:true,externalRuntimeDependenciesBlocked:true}));
|
||||
} catch(error){
|
||||
if(error.stdout)process.stderr.write(error.stdout);
|
||||
if(error.stderr)process.stderr.write(error.stderr);
|
||||
throw error;
|
||||
} finally {
|
||||
await rm(temporary,{recursive:true,force:true});
|
||||
}
|
||||
Reference in New Issue
Block a user