arcane-os 0.57.0 → 0.59.0

package/src/core/services/packaged-web.mjs

@@ -0,0 +1,89 @@
+import {mkdir, readFile, writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {startDevServer} from '../../dev-server.mjs';
+import {serializeCoreError} from '../../../browser-runtime/core/contracts.mjs';
+
+/** Serve one packaged web root inside its existing Core lifetime. */
+export function createPackagedWebService({artifactRoot}, context = {}) {
+    let server;
+    let closing = false;
+    let lifetime;
+    return {
+        name: 'packaged-web',
+        async start(runtime) {
+            const manifest = JSON.parse(await readFile(path.join(artifactRoot, 'arcane-native.json'), 'utf8'));
+            // The launcher chooses app state independently of its installation.
+            // Forward the application's launch file unchanged; the fallback is
+            // a separate native argument, not a rewritten application payload.
+            const stateFlag = process.argv.indexOf('--arcane-host-state-root');
+            const stateRoot = context.stateRoot ?? (stateFlag < 0 ? undefined : process.argv[stateFlag + 1]);
+            if (typeof stateRoot !== 'string' || !stateRoot) {
+                throw new TypeError('Packaged web serving requires the launcher-selected stateRoot.');
+            }
+            await mkdir(stateRoot, {recursive: true});
+            const originFile = path.join(stateRoot, 'packaged-web-origin.json');
+            let port = 0;
+            let saved = false;
+            try {
+                const origin = JSON.parse(await readFile(originFile, 'utf8'));
+                port = origin.port;
+                if (!Number.isInteger(port) || port < 1 || port > 65535) {
+                    throw new TypeError('The saved packaged origin needs its previously selected listener port.');
+                }
+                saved = true;
+            } catch (error) {
+                if (error.code !== 'ENOENT') throw error;
+            }
+            try {
+                server = await startDevServer({
+                    mode: 'packaged', http: true,
+                    releaseRoot: path.resolve(artifactRoot, manifest.webRoot),
+                    host: '127.0.0.1', port
+                });
+                // Only a first successful listener selects a port. A later bind
+                // conflict remains an error instead of moving saved browser data
+                // to a different origin. Concurrent first launches cannot replace
+                // one another's selection.
+                if (!saved) {
+                    await writeFile(originFile, JSON.stringify({host: '127.0.0.1', port: server.port}) + '\n', {flag: 'wx'});
+                }
+                const url = new URL(manifest.start, server.origin).href;
+                runtime.emit('core.web.ready', {origin: server.origin, url, port: server.port});
+                lifetime = server.lifecycle.then(
+                    function packagedServerEnded() {
+                        if (!closing) {
+                            runtime.emit('core.web.failed', serializeCoreError(
+                                new Error('The packaged application listener closed unexpectedly.')
+                            ));
+                        }
+                    },
+                    function packagedServerFailed(error) {
+                        if (!closing) runtime.emit('core.web.failed', serializeCoreError(error));
+                        throw error;
+                    }
+                );
+                // Retain the original rejection for drain while observing it
+                // now; the native diagnostic event owns immediate reporting.
+                lifetime.catch(function observePackagedServerFailure() {});
+            } catch (error) {
+                closing = true;
+                if (server) {
+                    try { await server.close(); }
+                    catch (closeError) {
+                        throw new AggregateError([error, closeError], 'Packaged application startup and shutdown failed.');
+                    }
+                }
+                throw error;
+            }
+        },
+        async drain() {
+            closing = true;
+            if (!server) return;
+            const results = await Promise.allSettled([server.close(), server.closed, lifetime]);
+            const failures = [...new Set(results.filter(function rejected(result) {
+                return result.status === 'rejected';
+            }).map(function reason(result) {return result.reason;}))];
+            if (failures.length) throw new AggregateError(failures, 'Packaged application serving shutdown failed.');
+        }
+    };
+}

package/src/core/services/preferences.mjs

@@ -0,0 +1,201 @@
+import {mkdir, mkdtemp, open, readFile, rename, rmdir, unlink} from 'node:fs/promises';
+import path from 'node:path';
+import Is from 'strong-type';
+
+const is = new Is(false);
+
+// A selected file has one read/modify/write order within this Core process,
+// including when separate service instances select the same file.
+const fileOperations = new Map();
+
+/**
+ * Native implementation of the existing Arcane.preferences methods.
+ * The application selects its file; namespaces, defaults and preference schemas
+ * remain with the caller. Factory construction performs no I/O.
+ *
+ * Writes have service lifetime. Once accepted, renderer cancellation cannot
+ * discard them. drain()/dispose() stop acceptance and await owned operations.
+ * Success follows a flushed file replacement, not a promise of filesystem
+ * survival across every possible operating-system or hardware failure.
+ */
+export function createPreferencesService({file} = {}) {
+    if (!is.string(file) || file === '') {
+        throw new TypeError('Preferences require an application-selected file path.');
+    }
+    const filename = path.resolve(file);
+    const pending = new Set();
+    let closing = null;
+
+    function accept(operation) {
+        if (closing) {
+            const error = new Error('The preferences service is closing.');
+            error.code = 'CORE_CLOSING';
+            return Promise.reject(error);
+        }
+        const result = orderFileOperation(filename, operation);
+        pending.add(result);
+        function releaseOperation() { pending.delete(result); }
+        result.then(releaseOperation, releaseOperation);
+        return result;
+    }
+
+    function list(parameters, {signal} = {}) {
+        return accept(async function readKeys() {
+            const document = await readPreferences(filename, signal);
+            return {keys: Object.keys(document.entries).sort()};
+        });
+    }
+
+    function get({key}, {signal} = {}) {
+        return accept(async function readValue() {
+            requireKey(key);
+            const document = await readPreferences(filename, signal);
+            const found = Object.hasOwn(document.entries, key);
+            return {key, found, value: found ? document.entries[key] : null};
+        });
+    }
+
+    function set({key, value}) {
+        return accept(async function saveValue() {
+            requireKey(key);
+            const document = await readPreferences(filename);
+            setEntry(document.entries, key, value);
+            await writePreferences(filename, document);
+            return {key, value};
+        });
+    }
+
+    function setMany({entries}) {
+        return accept(async function saveBatch() {
+            if (!entries || !is.object(entries) || is.array(entries)) {
+                throw new TypeError('Preference entries must be a JSON object.');
+            }
+            const document = await readPreferences(filename);
+            const batch = Object.entries(entries);
+            for (const [key, value] of batch) setEntry(document.entries, key, value);
+            await writePreferences(filename, document);
+            return {keys: batch.map(function entryKey([key]) { return key; }).sort(), count: batch.length};
+        });
+    }
+
+    function deletePreference({key}) {
+        return accept(async function removeValue() {
+            requireKey(key);
+            const document = await readPreferences(filename);
+            const deleted = Object.hasOwn(document.entries, key);
+            if (deleted) {
+                delete document.entries[key];
+                await writePreferences(filename, document);
+            }
+            return {key, deleted};
+        });
+    }
+
+    function drain() {
+        if (closing) return closing;
+        closing = Promise.allSettled([...pending]).then(function operationsDrained(results) {
+            const failures = results.filter(function failed(result) {
+                return result.status === 'rejected';
+            }).map(function reason(result) { return result.reason; });
+            if (failures.length) throw new AggregateError(failures, 'Preference operations failed while draining.');
+        });
+        return closing;
+    }
+
+    return {
+        name: 'preferences',
+        methods: {
+            'preferences.list': list,
+            'preferences.get': get,
+            'preferences.set': {lifetime: 'service', handle: set},
+            'preferences.setMany': {lifetime: 'service', handle: setMany},
+            'preferences.delete': {lifetime: 'service', handle: deletePreference}
+        },
+        drain,
+        dispose: drain
+    };
+}
+
+function orderFileOperation(file, operation) {
+    const previous = fileOperations.get(file) ?? Promise.resolve();
+    const result = previous.then(operation, operation);
+    function releaseQueue() {
+        if (fileOperations.get(file) === tail) fileOperations.delete(file);
+    }
+    // The caller retains the rejecting result. This fulfilled scheduling tail
+    // lets a later operation proceed after an earlier reported failure.
+    const tail = result.then(releaseQueue, releaseQueue);
+    fileOperations.set(file, tail);
+    return result;
+}
+
+async function readPreferences(file, signal) {
+    signal?.throwIfAborted();
+    let source;
+    try {
+        source = await readFile(file, {encoding: 'utf8', signal});
+    } catch (error) {
+        if (error.code !== 'ENOENT') throw error;
+        signal?.throwIfAborted();
+        return {schemaVersion: 1, entries: {}};
+    }
+    const document = JSON.parse(source);
+    if (!document || document.schemaVersion !== 1 || !document.entries
+        || !is.object(document.entries) || is.array(document.entries)) {
+        throw new TypeError(`Preferences at ${file} do not contain the existing schemaVersion 1 entries record.`);
+    }
+    return document;
+}
+
+function requireKey(key) {
+    if (!is.string(key)) throw new TypeError('A preference key must be a string.');
+}
+
+function setEntry(entries, key, value) {
+    // Define an ordinary own data property: "__proto__" is a preference key,
+    // not an instruction to change the entries object's prototype.
+    Object.defineProperty(entries, key, {value, enumerable: true, writable: true, configurable: true});
+}
+
+function jsonValue(key, value) {
+    const kind = typeof value;
+    if (value === undefined || kind === 'function' || kind === 'symbol'
+        || (kind === 'number' && !Number.isFinite(value))) {
+        throw new TypeError(`Preference value at ${JSON.stringify(key)} cannot be represented completely in JSON.`);
+    }
+    return value;
+}
+
+async function writePreferences(file, document) {
+    // Serialization happens before any filesystem write. The JSON boundary
+    // reports unrepresentable values instead of silently omitting them.
+    const source = JSON.stringify(document, jsonValue);
+    const directory = path.dirname(file);
+    await mkdir(directory, {recursive: true});
+    const temporaryDirectory = await mkdtemp(path.join(directory, '.arcane-preferences-'));
+    const temporary = path.join(temporaryDirectory, 'preferences.json');
+    const failures = [];
+    let handle = null;
+    try {
+        handle = await open(temporary, 'w');
+        await handle.writeFile(source, 'utf8');
+        await handle.sync();
+        await handle.close();
+        handle = null;
+        await rename(temporary, file);
+    } catch (error) {
+        failures.push(error);
+    } finally {
+        if (handle) {
+            try { await handle.close(); } catch (error) { failures.push(error); }
+        }
+        try { await unlink(temporary); } catch (error) {
+            if (error.code !== 'ENOENT') failures.push(error);
+        }
+        try { await rmdir(temporaryDirectory); } catch (error) { failures.push(error); }
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) throw new AggregateError(failures, 'Preference replacement and cleanup failed.');
+}
+
+export default createPreferencesService;

package/src/core-classic-source.mjs

@@ -5,7 +5,7 @@ import {readFile} from 'node:fs/promises';
  * The two owned modules have declaration exports and two explicit imports;
  * this projection is deliberately not a general JavaScript bundler.
  */
-export async function createCoreClassicSource({eventOwnerModuleURL,replayRuntimeState=false}={}){
+export async function createCoreClassicSource({eventOwnerModuleURL,replayRuntimeState=false,webKitDocumentLifecycle=false}={}){
     if(typeof eventOwnerModuleURL!=='string'||!eventOwnerModuleURL){
         throw new TypeError('The classic Core client needs the served SDK event-manager module URL.');
     }
@@ -37,7 +37,7 @@ ${implementation}
                 },{once:true});
             })
             :loadSharedEventOwner();
-    installCoreClient(global,{eventOwner:arcaneEvents,eventOwnerReady,replayRuntimeState:${replayRuntimeState===true}});
+    installCoreClient(global,{eventOwner:arcaneEvents,eventOwnerReady,replayRuntimeState:${replayRuntimeState===true}${webKitDocumentLifecycle===true?',webKitDocumentLifecycle:true':''}});
 })(globalThis);
 `;
 }

package/src/dev-server.mjs

@@ -831,7 +831,7 @@ async function resolveDevelopmentTls({workspaceRoot,tls,certPath,keyPath,signal}
     }catch(error){
         if(error.code==='ENOENT'){
             fail(
-                `Arcane development and packaged previews require HTTPS. `
+                `Arcane development and packaged previews default to HTTPS. `
                 +`Provide a certificate at ${certificatePath} and a key at ${privateKeyPath}, `
                 +'or select existing files with --cert and --key.',
                 'ARCANE_DEV_TLS_MISSING'
@@ -873,12 +873,9 @@ async function startOwnedDevServer({
     if (!is.boolean(http)) {
         fail('http must be a boolean.', 'ARCANE_USAGE');
     }
-    if (http && mode !== 'source') {
-        fail('HTTP serving is supported only in source development mode.', 'ARCANE_USAGE');
-    }
     if (http && (requestedHttps === true || (tls !== undefined && tls !== null && tls !== false)
         || certPath !== undefined || keyPath !== undefined || httpPort !== 0)) {
-        fail('HTTP development cannot combine TLS options or a separate httpPort; select its listener with port.', 'ARCANE_USAGE');
+        fail('HTTP serving cannot combine TLS options or a separate httpPort; select its listener with port.', 'ARCANE_USAGE');
     }
     const protocol = http ? 'http:' : 'https:';
     const requestedRuntimeMode=mode==='source'&&sdkRuntimeSourceRoot!==undefined

package/src/diarization/build.mjs

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {mkdir} from 'node:fs/promises';
+import Is from 'strong-type';
+import {runProcess} from '../process.mjs';
+
+const is = new Is(false);
+
+/** Build this host's first-party helper against its selected upstream runtime. */
+export async function buildDiarizationHelper({runtime, outputRoot, signal, onEvent} = {}) {
+    if (!is.string(runtime?.cmakeDirectory) || !is.string(outputRoot)) {
+        throw new TypeError('The selected NeMo runtime cmakeDirectory and helper outputRoot are required.');
+    }
+    const root = path.resolve(outputRoot);
+    const build = path.join(root, 'build');
+    const source = fileURLToPath(new URL('./native/', import.meta.url));
+    await mkdir(root, {recursive: true});
+    const options = {signal, onEvent};
+    const configure = await runProcess('cmake', [
+        '-S', source,
+        '-B', build,
+        `-DNeMoSpeech_DIR=${path.resolve(runtime.cmakeDirectory)}`,
+        `-DCMAKE_INSTALL_PREFIX=${root}`,
+        '-DCMAKE_BUILD_TYPE=Release'
+    ], options);
+    const compile = await runProcess('cmake', ['--build', build, '--config', 'Release'], options);
+    const install = await runProcess('cmake', ['--install', build, '--config', 'Release'], options);
+    return {
+        platform: process.platform,
+        architecture: process.arch,
+        root,
+        executable: path.join(root, 'bin', process.platform === 'win32' ? 'arcane-diarization.exe' : 'arcane-diarization'),
+        diagnostics: {configure, compile, install}
+    };
+}