arcane-os 0.68.0 → 0.70.0

package/runtime/arcane/modules/AIProviderRuntime.js

@@ -1688,6 +1688,7 @@ export class AIProviderRuntime {
     #speechDesiredMuted = true;
     #speechTransition = Promise.resolve();
     #speechTransitionOwners = 0;
+    #speechActivation = null;
     #unsubscribeIntents = null;
     #closed = false;
     #closing = false;
@@ -2784,6 +2785,11 @@ export class AIProviderRuntime {
         }
         if (slot.loadPromise) {
             if (this.#sameSelection(slot.selection, targetSelection)) {
+                const activation = this.#speechActivation;
+                if (role === 'tts' && activation?.loadPromise === slot.loadPromise
+                    && signal !== activation.controller.signal) {
+                    return this.#observeSpeechActivation(activation, signal);
+                }
                 return slot.loadPromise;
             }
             return Promise.reject(
@@ -2957,6 +2963,10 @@ export class AIProviderRuntime {
             }
         );
         slot.loadPromise = loadOperation;
+        if (role === 'tts' && this.#speechActivation
+            && signal === this.#speechActivation.controller.signal) {
+            this.#speechActivation.loadPromise = loadOperation;
+        }
         publishAIRuntimeRoleState(
             role,
             roleRecord(
@@ -3386,15 +3396,19 @@ export class AIProviderRuntime {
         if (options.signal?.aborted) {
             return Promise.reject(normalizedAbort());
         }
-        if (role === 'tts' && !queued && speechInputPrepared !== true) {
+        if (role === 'tts' && !queued) {
             const payload = options.payload;
             const field = Object.hasOwn(payload ?? {}, 'input') ? 'input' : 'text';
             const text = Object.getOwnPropertyDescriptor(payload ?? {}, field)?.value;
             if (is.string(text)) {
-                const input = stripSpeechFormatting(text);
-                if (input !== text) {
+                const textFormat = Object.getOwnPropertyDescriptor(payload, 'textFormat')?.value;
+                const input = speechInputPrepared === true || textFormat === 'plain'
+                    ? text
+                    : stripSpeechFormatting(text);
+                if (input !== text || Object.hasOwn(payload, 'textFormat')) {
                     const payloadProperties = Object.getOwnPropertyDescriptors(payload);
                     payloadProperties[field] = {...payloadProperties[field], value: input};
+                    delete payloadProperties.textFormat;
                     const requestProperties = Object.getOwnPropertyDescriptors(options);
                     requestProperties.payload = {
                         ...requestProperties.payload,
@@ -4266,19 +4280,34 @@ export class AIProviderRuntime {
         return true;
     }
 
-    async setSpeechMuted(muted) {
+    async setSpeechMuted(muted, {signal = null} = {}) {
         arcaneLogging.debug('[Arcane speech runtime] setSpeechMuted', muted);
         this.#assertOpen();
         this.#assertNotConfiguring();
         if (!is.boolean(muted)) {
             fail('AI speech muted state must be a boolean.');
         }
+        assertAbortSignal(signal);
+        if (signal?.aborted) throw normalizedAbort(signal.reason);
+        if (!muted && !this.#speechDesiredMuted && this.#speechActivation
+            && !this.#speechActivation.controller.signal.aborted) {
+            return this.#observeSpeechActivation(this.#speechActivation, signal);
+        }
         this.#speechDesiredMuted = muted;
         if (muted) {
             this.#speechMuted = true;
+            this.#speechActivation?.controller.abort();
             this.#slots.tts.loadController?.abort();
             this.cancel('tts');
         }
+        const activation = muted ? null : {
+            controller: new AbortController(),
+            interests: new Set(),
+            promise: null,
+            loadPromise: null,
+            settled: false
+        };
+        this.#speechActivation = activation;
         const runtime = this;
         this.#speechTransitionOwners += 1;
         const transition = this.#speechTransition.catch(
@@ -4286,6 +4315,9 @@ export class AIProviderRuntime {
         ).then(
             async function reconcileLatestAISpeechPreference() {
                 while (true) {
+                    if (activation?.controller.signal.aborted) {
+                        throw normalizedAbort(activation.controller.signal.reason);
+                    }
                     const desiredMuted = runtime.#speechDesiredMuted;
                     if (desiredMuted) {
                         runtime.cancel('tts');
@@ -4302,7 +4334,11 @@ export class AIProviderRuntime {
                         if (runtime.#speechDesiredMuted) {
                             continue;
                         }
-                        await runtime.load('tts');
+                        const currentActivation = runtime.#speechActivation;
+                        if (currentActivation?.controller.signal.aborted) {
+                            throw normalizedAbort(currentActivation.controller.signal.reason);
+                        }
+                        await runtime.load('tts', {signal: currentActivation?.controller.signal ?? null});
                     }
                     if (runtime.#speechDesiredMuted === desiredMuted) {
                         runtime.#speechMuted = desiredMuted;
@@ -4314,10 +4350,52 @@ export class AIProviderRuntime {
         ).finally(
             function releaseAIProviderSpeechTransitionOwnership() {
                 runtime.#speechTransitionOwners -= 1;
+                if (activation) {
+                    activation.settled = true;
+                    if (runtime.#speechActivation === activation) {
+                        runtime.#speechActivation = null;
+                    }
+                }
             }
         );
         this.#speechTransition = transition;
-        return transition;
+        if (!activation) return transition;
+        activation.promise = transition;
+        return this.#observeSpeechActivation(activation, signal);
+    }
+
+    #observeSpeechActivation(activation, signal) {
+        return new Promise(function observeAIProviderSpeechActivation(resolve, reject) {
+            const interest = {};
+            let settled = false;
+            activation.interests.add(interest);
+            function releaseSpeechActivationInterest() {
+                activation.interests.delete(interest);
+                signal?.removeEventListener('abort', cancelSpeechActivationInterest);
+            }
+            function cancelSpeechActivationInterest() {
+                if (settled) return;
+                settled = true;
+                releaseSpeechActivationInterest();
+                if (!activation.settled && activation.interests.size === 0) {
+                    activation.controller.abort(signal?.reason);
+                }
+                reject(normalizedAbort(signal?.reason));
+            }
+            signal?.addEventListener('abort', cancelSpeechActivationInterest, {once: true});
+            activation.promise.then(function speechActivationReady(status) {
+                if (settled) return;
+                settled = true;
+                releaseSpeechActivationInterest();
+                resolve(status);
+            }, function speechActivationFailed(error) {
+                if (settled) return;
+                settled = true;
+                releaseSpeechActivationInterest();
+                reject(error);
+            });
+            if (signal?.aborted) cancelSpeechActivationInterest();
+        });
     }
 
     #providerFor(slot) {

package/runtime/arcane/modules/DBOPFS.js

@@ -8,7 +8,8 @@ import {
 const is=new Is(false);
 
 const dbopfsEventTypes={
-    ready:'dbopfs-ready'
+    ready:'dbopfs-ready',
+    change:'dbopfs-change'
 };
 const dbopfsReasons={
     ready:'opfs-database-ready'
@@ -117,6 +118,13 @@ if(navigator.storage?.persist){
 class DBOPFS {
 
     #events;
+    #changeChannel=null;
+    #changeOriginId=globalThis.crypto?.randomUUID?.()
+        ||`dbopfs-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    #changeSequence=0;
+    #changeWindow=window;
+    #changesSuspended=false;
+    #cacheStates=new Map();
 
     /** @type {FileSystemDirectoryHandle|Object} */
     #db={}
@@ -286,6 +294,113 @@ class DBOPFS {
         return `${tableName}:${fileName}`
     }
 
+    #fileCacheState(tableName,fileName){
+        const directoryName=directoryNameForTable(tableName);
+        let table=this.#cacheStates.get(directoryName);
+        if(!table){
+            table=new Map();
+            this.#cacheStates.set(directoryName,table);
+        }
+        let state=table.get(fileName);
+        if(!state){
+            state={revision:0};
+            table.set(fileName,state);
+        }
+        return state;
+    }
+
+    #forgetFile(tableName,fileName,retire=false){
+        const directoryName=directoryNameForTable(tableName);
+        const registeredTableName=tableNameForDirectory(directoryName);
+        const states=this.#cacheStates.get(directoryName);
+        const state=states?.get(fileName);
+        if(state)state.revision+=1;
+        if(retire&&states){
+            states.delete(fileName);
+            if(states.size===0)this.#cacheStates.delete(directoryName);
+        }
+        for(const name of new Set([tableName,directoryName,registeredTableName])){
+            if(this.#tables[name])delete this.#tables[name][fileName];
+        }
+    }
+
+    #openChangeChannel(){
+        if(this.#changesSuspended||this.#changeChannel||!this.#applicationId)return;
+        const Channel=this.#changeWindow.BroadcastChannel;
+        if(!is.function(Channel))return;
+        try{
+            const channel=new Channel(`arcane.dbopfs.changes:${this.#storagePath}`);
+            const database=this;
+            channel.onmessage=function receiveCommittedChange(event){
+                const change=event.data;
+                if(!change||change.applicationId!==database.#applicationId
+                    ||change.storagePath!==database.#storagePath
+                    ||change.originId===database.#changeOriginId)return;
+                if(!['write','append','delete','table-delete'].includes(change.action)
+                    ||typeof change.tableName!=='string'
+                    ||typeof change.directoryName!=='string'
+                    ||typeof change.changeId!=='string'
+                    ||(change.action!=='table-delete'&&typeof change.fileName!=='string'))return;
+                database.#receiveChange(change);
+            };
+            channel.onmessageerror=function reportChangeMessageError(event){
+                arcaneLogging.error('DBOPFS could not receive a committed-change notification.',event);
+            };
+            this.#changeChannel=channel;
+        }catch(error){
+            arcaneLogging.error('DBOPFS cross-document notifications are unavailable; local storage remains available.',error);
+        }
+    }
+
+    #closeChangeChannel(){
+        if(!this.#changeChannel)return;
+        this.#changeChannel.onmessage=null;
+        this.#changeChannel.onmessageerror=null;
+        this.#changeChannel.close();
+        this.#changeChannel=null;
+    }
+
+    #receiveChange(change){
+        if(change.action==='table-delete'){
+            this.#forgetTable(change.tableName,change.directoryName,tableNameForDirectory(change.directoryName));
+        }else{
+            this.#forgetFile(change.tableName,change.fileName,change.action==='delete');
+        }
+        this.#events.dispatch(dbopfsEventTypes.change,{...change,remote:true},{operationId:change.changeId});
+    }
+
+    #commitChange(tableName,fileName,action){
+        const directoryName=directoryNameForTable(tableName);
+        const registeredTableName=tableNameForDirectory(directoryName);
+        if(action==='table-delete'){
+            this.#forgetTable(tableName,directoryName,registeredTableName);
+        }else{
+            this.#forgetFile(tableName,fileName,action==='delete');
+        }
+        this.#changeSequence+=1;
+        const change={
+            applicationId:this.#applicationId,
+            storagePath:this.#storagePath,
+            tableName:registeredTableName,
+            directoryName,
+            fileName,
+            action,
+            originId:this.#changeOriginId,
+            sequence:this.#changeSequence,
+            changeId:`${this.#changeOriginId}:${this.#changeSequence}`
+        };
+        // Notify the remote transport before synchronous local observers can
+        // start another mutation. Transport failure cannot undo a saved record.
+        if(this.#changeChannel){
+            try{
+                this.#changeChannel.postMessage(change);
+            }catch(error){
+                arcaneLogging.error('DBOPFS saved a change whose cross-document notification failed.',error);
+            }
+        }
+        this.#events.dispatch(dbopfsEventTypes.change,{...change,remote:false},{operationId:change.changeId});
+    }
+
     /**
      * Invalidates every known cache key for one logical/physical table pair.
      * @private
@@ -294,6 +409,7 @@ class DBOPFS {
      * @param {string} registeredTableName
      */
     #forgetTable(tableName,directoryName,registeredTableName){
+        this.#cacheStates.delete(directoryName);
         for(const name of new Set([
             tableName,
             directoryName,
@@ -320,6 +436,22 @@ class DBOPFS {
             source:'dbopfs',
             eventTypes:Object.values(dbopfsEventTypes)
         });
+        const database=this;
+        this.#changeWindow.addEventListener('pagehide',function suspendDBOPFSChanges(){
+            database.#changesSuspended=true;
+            database.#closeChangeChannel();
+        });
+        this.#changeWindow.addEventListener('pageshow',function resumeDBOPFSChanges(){
+            if(!database.#changesSuspended)return;
+            database.#changesSuspended=false;
+            // Notifications have no history. Discard only this page's cached
+            // views after suspension; storage and committed events are unchanged.
+            database.#tables={};
+            database.#tableHandles={};
+            database.#tableHandlePromises={};
+            database.#cacheStates.clear();
+            database.#openChangeChannel();
+        });
         this.readyPromise=this.#init(options);
     }
 
@@ -340,6 +472,7 @@ class DBOPFS {
         this.#applicationId=scope.applicationId;
         this.#storagePath=scope.path;
         this.#db=scope.directory;
+        this.#openChangeChannel();
 
         this.ready=true;
 
@@ -382,6 +515,17 @@ class DBOPFS {
         return this.#storagePath;
     }
 
+    /**
+     * Observes committed record/table changes through the canonical event owner.
+     * Subscription is live-only; it does not replay records or load a table.
+     * @param {function} listener Receives an event whose detail is change metadata.
+     * @param {{signal?:AbortSignal,once?:boolean}} options
+     * @returns {function} Idempotent unsubscribe with a matching dispose method.
+     */
+    subscribeChanges(listener,options={}){
+        return this.#events.subscribe(dbopfsEventTypes.change,listener,options);
+    }
+
     /**
      * Returns in-memory table cache.
      *
@@ -444,7 +588,9 @@ class DBOPFS {
                 {create:true}
             ).then(
                 function registerRequestedTable(handle){
-                    this.#tableHandles[registeredTableName]=handle;
+                    if(this.#tableHandlePromises[registeredTableName]===handlePromise){
+                        this.#tableHandles[registeredTableName]=handle;
+                    }
                     return handle;
                 }.bind(this)
             );
@@ -489,6 +635,10 @@ class DBOPFS {
                     dataToWrite=JSON.stringify(dataToWrite)
                 }
 
+                const cacheState=this.#fileCacheState(tableName,fileName);
+                const cacheRevision=cacheState.revision;
+                const result=append?true:parseFileValue(fileName,String(dataToWrite));
+
                 try{
                     await this.writeFile(
                         tableName,
@@ -497,20 +647,20 @@ class DBOPFS {
                         append
                     );
 
-                    if(append){
-                        delete this.#tables[tableName][fileName];
-                    }else{
-                        this.#tables[tableName][fileName]=parseFileValue(
-                            fileName,
-                            String(dataToWrite)
-                        );
+                    if(!append&&this.#fileCacheState(tableName,fileName)===cacheState
+                        &&cacheState.revision<=cacheRevision+1){
+                        if(!this.#tables[tableName])this.#tables[tableName]={};
+                        this.#tables[tableName][fileName]=result;
+                    }
+                    if(append&&cacheState.revision===cacheRevision){
+                        this.#forgetFile(tableName,fileName);
                     }
                 }catch(error){
                     arcaneLogging.error(`Error writing file '${fileName}' to table '${tableName}':`,error)
                     throw error
                 }
 
-                return append?true:this.#tables[tableName][fileName]
+                return result
             }.bind(this)
         )
 
@@ -547,12 +697,14 @@ class DBOPFS {
         );
 
         if(!is.function(handle.createWritable)){
-            return this.#writeFileWithWorker(
+            await this.#writeFileWithWorker(
                 table.name,
                 fileName,
                 fileData,
                 append
             );
+            this.#commitChange(tableName,fileName,append?'append':'write');
+            return true;
         }
 
         const writable=await handle.createWritable(
@@ -572,6 +724,7 @@ class DBOPFS {
 
         await writable.write(blob);
         await writable.close();
+        this.#commitChange(tableName,fileName,append?'append':'write');
 
         return true
     }
@@ -669,6 +822,8 @@ class DBOPFS {
      */
     async get(tableName='',fileName='',force=false){
         if(force||!this.#tables[tableName]?.[fileName]){
+            const cacheState=this.#fileCacheState(tableName,fileName);
+            const cacheRevision=cacheState.revision;
             try{
                 const file=await this.readFile(tableName,fileName)
                 const textContent=await file.text()
@@ -677,12 +832,15 @@ class DBOPFS {
                     this.#tables[tableName]={}
                 }
 
-                this.#tables[tableName][fileName]=parseFileValue(
-                    fileName,
-                    textContent
-                );
+                const value=parseFileValue(fileName,textContent);
+                if(this.#fileCacheState(tableName,fileName)===cacheState
+                    &&cacheState.revision===cacheRevision){
+                    this.#tables[tableName][fileName]=value;
+                }
+                return value;
             }catch(error){
                 if(error.name==='NotFoundError'){
+                    this.#forgetFile(tableName,fileName,true);
                     return null
                 }
 
@@ -788,15 +946,13 @@ class DBOPFS {
 
         try{
             await table.removeEntry(fileName)
+            this.#commitChange(tableName,fileName,'delete');
         }catch(error){
             if(error.name!=='NotFoundError'){
                 arcaneLogging.error(error)
                 throw error
             }
-        }
-
-        if(this.#tables[tableName]){
-            delete this.#tables[tableName][fileName]
+            this.#forgetFile(tableName,fileName,true);
         }
 
         return true
@@ -831,13 +987,9 @@ class DBOPFS {
 
         try{
             await this.#db.removeEntry(directoryName,{recursive:true})
-
-            delete this.#tables[tableName]
-            delete this.#tables[directoryName]
-            delete this.#tables[registeredTableName]
-            delete this.#tableHandles[registeredTableName]
-            delete this.#tableHandlePromises[registeredTableName]
+            this.#commitChange(tableName,null,'table-delete');
         }catch(error){
+            if(error.name==='NotFoundError')this.#forgetTable(tableName,directoryName,registeredTableName);
             arcaneLogging.error(error)
         }
 
@@ -894,7 +1046,7 @@ class DBOPFS {
             }
         }
 
-        this.#forgetTable(tableName,directoryName,registeredTableName)
+        this.#commitChange(tableName,null,'table-delete');
 
         return {
             status:'removed',
@@ -916,11 +1068,13 @@ class DBOPFS {
 
         for await(const [name]of this.#db.entries()){
             await this.#db.removeEntry(name,{recursive:true})
+            this.#commitChange(name,null,'table-delete');
         }
 
         this.#tables={}
         this.#tableHandles={}
         this.#tableHandlePromises={}
+        this.#cacheStates.clear();
         this.#writeLocks={}
 
         return this

package/schemas/arcane-app.schema.json

@@ -132,6 +132,16 @@
           }
         },
         "localAI": { "$ref": "#/$defs/localAI" },
+        "window": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "Initial native client dimensions in logical pixels at 96 DPI, and whether the user can resize the window. Omitted fields retain the host defaults.",
+          "properties": {
+            "width": { "type": "integer", "minimum": 1 },
+            "height": { "type": "integer", "minimum": 1 },
+            "resizable": { "type": "boolean" }
+          }
+        },
         "bundledApps": {
           "type": "array",
           "uniqueItems": true,

package/src/app-descriptor.mjs

@@ -235,8 +235,26 @@ function validateDocumentCatalog(value){
     });
 }
 
+function validateNativeWindow(value){
+    if(value===undefined)return undefined;
+    assertOnlyKeys(value,new Set(['width','height','resizable']),'descriptor.native.window');
+    for(const dimension of ['width','height']){
+        if(value[dimension]!==undefined&&(!is.integer(value[dimension])||value[dimension]<=0)){
+            fail(`descriptor.native.window.${dimension} must be a positive integer.`);
+        }
+    }
+    if(value.resizable!==undefined&&!is.boolean(value.resizable)){
+        fail('descriptor.native.window.resizable must be a boolean.');
+    }
+    return completeValue({
+        ...(value.width===undefined?{}:{width:value.width}),
+        ...(value.height===undefined?{}:{height:value.height}),
+        ...(value.resizable===undefined?{}:{resizable:value.resizable})
+    });
+}
+
 function validateNative(value,appId){
-    assertOnlyKeys(value,new Set(['type','icon','order','bundledApps','documentCatalog','localAI','services']),'descriptor.native');
+    assertOnlyKeys(value,new Set(['type','icon','order','bundledApps','documentCatalog','localAI','services','window']),'descriptor.native');
     if(!NATIVE_TYPES.has(value.type))fail('descriptor.native.type is unsupported.');
     const icon=value.icon===null?null:normalizeRelativePath(value.icon,'descriptor.native.icon');
     if(!is.integer(value.order)||value.order<0){
@@ -246,6 +264,7 @@ function validateNative(value,appId){
         pattern:APP_ID_PATTERN
     });
     const documentCatalog=validateDocumentCatalog(value.documentCatalog);
+    const window=validateNativeWindow(value.window);
     let services;
     if(value.services!==undefined){
         if(!is.array(value.services))fail('descriptor.native.services must be an array.');
@@ -259,6 +278,7 @@ function validateNative(value,appId){
         icon,
         order:value.order,
         bundledApps,
+        ...(window===undefined?{}:{window}),
         ...(services===undefined?{}:{services}),
         ...(value.localAI===undefined?{}:{localAI:normalizeLocalAIConfig(value.localAI)}),
         ...(documentCatalog?{documentCatalog}:{})
@@ -395,6 +415,7 @@ export function projectNativeDescriptor(descriptor,{source}={}){
         ...(value.native.bundledApps.length?{bundledApps:[...value.native.bundledApps]}:{}),
         ...(value.native.documentCatalog?{documentCatalog:value.native.documentCatalog}:{}),
         ...(value.native.services===undefined?{}:{services:value.native.services}),
+        ...(value.native.window===undefined?{}:{window:value.native.window}),
         ...(value.native.localAI===undefined?{}:{localAI:value.native.localAI}),
         include:[...value.package.include]
     };
@@ -440,6 +461,7 @@ function synthesizedDescriptor(packageManifest,nativeDescriptor){
             order:is.integer(native.order)?native.order:100,
             bundledApps:[...(native.bundledApps??[])],
             ...(native.services===undefined?{}:{services:native.services}),
+            ...(native.window===undefined?{}:{window:native.window}),
             ...((packageManifest.localAI??native.localAI)===undefined?{}:{localAI:packageManifest.localAI??native.localAI}),
             ...(native.documentCatalog?{documentCatalog:native.documentCatalog}:{})
         },

package/src/core/host.mjs

@@ -3,6 +3,8 @@ import Is from 'strong-type';
 import {createCoreRuntime} from './runtime.mjs';
 import {startCoreStdio} from './stdio.mjs';
 
+export {startSharedCoreHost, connectSharedCoreHost, runSharedCoreHost, startSharedCoreBridge} from './shared-host.mjs';
+
 const is = new Is(false);
 
 /**

package/src/core/hosts/windows/ArcaneHost.cs

@@ -26,6 +26,10 @@ namespace Arcane.Core.Hosts.Windows
         public string CoreExecutable { get; set; }
         public string CoreArguments { get; set; }
         public string CoreWorkingDirectory { get; set; }
+        /// <summary>Optional initial client dimensions in logical pixels at 96 DPI.</summary>
+        public double? InitialClientWidth { get; set; }
+        public double? InitialClientHeight { get; set; }
+        public bool? Resizable { get; set; }
     }
 
     public static class ArcaneHost
@@ -128,6 +132,8 @@ namespace Arcane.Core.Hosts.Windows
         {
             if (options == null) throw new ArgumentNullException("options");
             if (onDiagnostic == null) throw new ArgumentNullException("onDiagnostic");
+            ValidateInitialDimension(options.InitialClientWidth, "InitialClientWidth");
+            ValidateInitialDimension(options.InitialClientHeight, "InitialClientHeight");
             this.options = options;
             this.onDiagnostic = onDiagnostic;
             this.onError = onError;
@@ -135,6 +141,11 @@ namespace Arcane.Core.Hosts.Windows
             completion.Task.ContinueWith(ObserveReportedFailure, TaskContinuationOptions.OnlyOnFaulted);
             Text = options.Title;
             AutoScaleMode = AutoScaleMode.Dpi;
+            if (options.Resizable.HasValue)
+            {
+                FormBorderStyle = options.Resizable.Value ? FormBorderStyle.Sizable : FormBorderStyle.FixedSingle;
+                MaximizeBox = options.Resizable.Value;
+            }
             webView = new WebView2 { Dock = DockStyle.Fill };
             Controls.Add(webView);
         }
@@ -145,6 +156,9 @@ namespace Arcane.Core.Hosts.Windows
 
         protected override void OnLoad(EventArgs args)
         {
+            // Apply the initial choice once. A composing launcher's Load handler
+            // can then restore its own saved state; later user sizing is untouched.
+            if (!started && !closing) ApplyInitialWindowSize();
             base.OnLoad(args);
             if (started || closing) return;
             started = true;
@@ -152,6 +166,38 @@ namespace Arcane.Core.Hosts.Windows
             initialization.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
         }
 
+        private static void ValidateInitialDimension(double? value, string name)
+        {
+            if (value.HasValue && (Double.IsNaN(value.Value) || Double.IsInfinity(value.Value)
+                || value.Value <= 0 || Math.Truncate(value.Value) != value.Value))
+                throw new ArgumentOutOfRangeException(name, "Select a positive integral logical client dimension.");
+        }
+
+        private void ApplyInitialWindowSize()
+        {
+            if ((!options.InitialClientWidth.HasValue && !options.InitialClientHeight.HasValue)
+                || WindowState != FormWindowState.Normal) return;
+
+            Rectangle workArea = Screen.FromControl(this).WorkingArea;
+            int availableWidth = Math.Max(1, workArea.Width - (Width - ClientSize.Width));
+            int availableHeight = Math.Max(1, workArea.Height - (Height - ClientSize.Height));
+            using (Graphics display = CreateGraphics())
+            {
+                double width = options.InitialClientWidth.HasValue
+                    ? options.InitialClientWidth.Value * display.DpiX / 96.0 : ClientSize.Width;
+                double height = options.InitialClientHeight.HasValue
+                    ? options.InitialClientHeight.Value * display.DpiY / 96.0 : ClientSize.Height;
+                // Fit before converting to native integer coordinates. This is
+                // an initial screen fit, not a persistent maximum window size.
+                ClientSize = new Size(
+                    (int)Math.Max(1, Math.Min(availableWidth, Math.Round(width))),
+                    (int)Math.Max(1, Math.Min(availableHeight, Math.Round(height))));
+            }
+            Location = new Point(
+                Math.Max(workArea.Left, Math.Min(Left, workArea.Right - Width)),
+                Math.Max(workArea.Top, Math.Min(Top, workArea.Bottom - Height)));
+        }
+
         private async Task InitializeAsync()
         {
             try