arcane-os 0.67.0 → 0.69.0

package/runtime/arcane/components/theme-switcher.html

@@ -1,11 +1,62 @@
 <style>
-    :host{display:inline-block;color:inherit}
-    .switcher{align-items:center;display:flex;gap:.15rem;padding:.2rem;border:1px solid var(--app-bar-border,var(--border-color,rgba(255,255,255,.25)));border-radius:999px;background:color-mix(in srgb,currentColor 8%,transparent)}
-    button{appearance:none;border:0;border-radius:999px;background:transparent;color:inherit;cursor:pointer;font:700 .68rem/1 system-ui,sans-serif;min-height:1.85rem;padding:.42rem .58rem}
-    button:hover{background:color-mix(in srgb,currentColor 14%,transparent)}
-    button[aria-pressed="true"]{background:var(--app-bar-accent,var(--secondary-color,#c49a52));color:var(--app-bar-active-text,var(--primary-color,#172238))}
-    button:focus-visible{outline:.18rem solid var(--focus-color,currentColor);outline-offset:.12rem}
-    @media(max-width:32rem){button{font-size:0;padding-inline:.5rem}button::first-letter{font-size:.72rem}}
+    :host {
+        display:inline-block;
+        min-inline-size:0;
+        max-inline-size:100%;
+        color:inherit;
+    }
+
+    .switcher {
+        display:flex;
+        flex-wrap:wrap;
+        align-items:center;
+        gap:.15rem;
+        box-sizing:border-box;
+        max-inline-size:100%;
+        padding:.2rem;
+        border:1px solid var(--app-bar-border,var(--border-color,rgba(255,255,255,.25)));
+        border-radius:1.6rem;
+        background:color-mix(in srgb,currentColor 8%,transparent);
+    }
+
+    button {
+        appearance:none;
+        flex:1 0 auto;
+        box-sizing:border-box;
+        min-inline-size:2.75rem;
+        max-inline-size:100%;
+        min-block-size:2.75rem;
+        padding:.5rem .75rem;
+        border:0;
+        border-radius:1.4rem;
+        background:transparent;
+        color:inherit;
+        cursor:pointer;
+        font:700 .875rem/1.25 system-ui,sans-serif;
+        text-align:center;
+        white-space:normal;
+        overflow-wrap:anywhere;
+    }
+
+    button:hover:not(:disabled):not([aria-pressed="true"]) {
+        background:color-mix(in srgb,currentColor 14%,transparent);
+    }
+
+    button[aria-pressed="true"] {
+        background:var(--app-bar-accent,var(--secondary-color,rgb(196,154,82)));
+        color:var(--app-bar-active-text,var(--primary-color,rgb(23,34,56)));
+        box-shadow:inset 0 0 0 .1rem currentColor;
+    }
+
+    button:disabled {
+        cursor:not-allowed;
+        opacity:.55;
+    }
+
+    button:focus-visible {
+        outline:.18rem solid var(--focus-color,currentColor);
+        outline-offset:.12rem;
+    }
 </style>
 <div class="switcher" role="group" aria-label="Color scheme">
     <button type="button" data-scheme="system" aria-pressed="false" title="Use device theme">Auto</button>
@@ -16,31 +67,79 @@
 <script type="module">
     const host=this;
     const root=host.shadowRoot;
+    const group=root.querySelector('.switcher');
     const buttons=Array.from(root.querySelectorAll('[data-scheme]'));
+    let modes=buttons.map(function scheme(button){return button.dataset.scheme;});
+    let labels=Object.fromEntries(buttons.map(function label(button){
+        return [button.dataset.scheme,button.textContent];
+    }));
+    let busy=false;
+
+    host.configure=configure;
+    configure({
+        modes:host.dataset.modes===undefined?modes:host.dataset.modes.split(/\s+/u).filter(Boolean),
+        labels:host.dataset.systemLabel===undefined?{}:{system:host.dataset.systemLabel}
+    });
+
     const {default:ThemeManager}=await import('../modules/ThemeManager.js');
     const manager=new ThemeManager();
 
     host.setMode=setMode;
     host.refresh=refresh;
-    root.querySelector('.switcher').addEventListener('click',async event=>{
+    group.addEventListener('click',async function selectScheme(event){
         const button=event.target.closest('[data-scheme]');
-        if(!button) return;
+        if(!button||button.disabled) return;
         setBusy(true);
         try{
             const state=button.dataset.scheme==='custom'?await manager.activateCustom():await manager.setScheme(button.dataset.scheme);
             setMode(state.mode);setCustomAvailable(Boolean(state.theme));
         }finally{setBusy(false);setCustomAvailable(Boolean(manager.customTheme));}
     });
-    globalThis.addEventListener('arcane-theme-change',()=>refresh().catch(()=>{}));
+    globalThis.addEventListener('arcane-theme-change',function themeChanged(){
+        refresh().catch(function refreshRejected(){});
+    });
+
+    function configure(options={}){
+        const nextModes=options.modes===undefined?modes:[...options.modes];
+        const nextLabels={...labels,...options.labels};
+        const visible=[];
+        for(const mode of nextModes){
+            const button=buttons.find(function matchingScheme(candidate){return candidate.dataset.scheme===mode;});
+            if(!button) throw new TypeError(`Unknown theme-switcher mode: ${mode}`);
+            if(visible.includes(button)) throw new TypeError(`Repeated theme-switcher mode: ${mode}`);
+            visible.push(button);
+        }
+        for(const button of buttons){
+            const label=nextLabels[button.dataset.scheme];
+            if(typeof label!=='string') throw new TypeError('Theme-switcher labels must be strings.');
+        }
+        modes=nextModes;
+        labels=nextLabels;
+        for(const button of buttons) button.textContent=labels[button.dataset.scheme];
+        const reordered=group.children.length!==visible.length||visible.some(function moved(button,index){
+            return group.children[index]!==button;
+        });
+        if(reordered){
+            const focused=root.activeElement;
+            group.replaceChildren(...visible);
+            if(visible.includes(focused)&&!focused.disabled) focused.focus({preventScroll:true});
+        }
+        return {modes:[...modes],labels:{...labels}};
+    }
 
     function setMode(mode='system'){
         for(const button of buttons) button.setAttribute('aria-pressed',String(button.dataset.scheme===mode));
         host.dataset.mode=mode;
         return mode;
     }
-    function setBusy(value){for(const button of buttons) button.disabled=Boolean(value);}
-    function setCustomAvailable(value){root.querySelector('[data-scheme="custom"]').disabled=!value;}
+    function setBusy(value){
+        busy=Boolean(value);
+        for(const button of buttons) button.disabled=busy;
+    }
+    function setCustomAvailable(value){
+        buttons.find(function customScheme(button){return button.dataset.scheme==='custom';}).disabled=busy||!value;
+    }
     async function refresh(){const state=await manager.load();setMode(state.mode);setCustomAvailable(Boolean(state.theme));return state;}
 
-    refresh().catch(()=>setMode('system'));
+    refresh().catch(function refreshRejected(){setMode('system');});
 </script>

package/runtime/arcane/modules/AI.js

@@ -6336,7 +6336,7 @@ class AI {
         return result;
     }
 
-    prepareTTS({parts, storage = null, identity = null, signal = null, onState = null} = {}) {
+    prepareTTS({parts, textFormat, storage = null, identity = null, signal = null, onState = null} = {}) {
         if(this.#providerSpeechModel()?.speech?.playback==='native'){
             const error=new Error('Native browser speech has no audio file to prepare or store; use prepareTTSPlayback.');
             error.code='ARCANE_AI_TTS_AUDIO_EXPORT_UNAVAILABLE';
@@ -6384,7 +6384,7 @@ class AI {
             if(!is.finite(pauseAfterMs) || pauseAfterMs < 0) {
                 throw new RangeError('Prepared speech pauses must be nonnegative milliseconds.');
             }
-            const cleaned = stripSpeechFormatting(source.input);
+            const cleaned = textFormat === 'plain' ? source.input : stripSpeechFormatting(source.input);
             const {segments: outputs} = this.#segmentSpeechText(cleaned, true, segmentation);
             for(const [index, input] of outputs.entries()) {
                 if(!input.trim()) continue;
@@ -7175,6 +7175,7 @@ class AI {
                 'model',
                 'voice',
                 'input',
+                'textFormat',
                 'responseFormat',
                 'speed'
             ]);
@@ -7183,7 +7184,7 @@ class AI {
                     ||!acceptedKeys.has(key)
                     ||!Object.hasOwn(descriptors[key],'value')){
                     const error=new TypeError(
-                        'AI.fetchTTS accepts only model, voice, input, responseFormat, and speed data properties.'
+                        'AI.fetchTTS accepts only model, voice, input, textFormat, responseFormat, and speed data properties.'
                     );
                     error.code='ARCANE_AI_TTS_REQUEST_INVALID';
                     throw error;
@@ -7208,7 +7209,7 @@ class AI {
                 error.code='ARCANE_AI_TTS_INPUT_INVALID';
                 throw error;
             }
-            const input=speechInputPrepared===true
+            const input=speechInputPrepared===true||descriptors.textFormat?.value==='plain'
                 ?suppliedInput
                 :stripSpeechFormatting(suppliedInput);
             const selection=this.#providerRuntime.selection('tts');

package/runtime/arcane/modules/AIProviderRuntime.js

@@ -3386,15 +3386,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,

package/runtime/arcane/modules/PreferenceStore.js

@@ -153,21 +153,26 @@ function nativeAdapter(){
     return preferences;
 }
 
-function isUnsupportedNativeAdapter(error){
-    return error?.code==='ANDROID_CAPABILITY_UNSUPPORTED';
+function isUnsupportedNativeAdapter(error,method){
+    return error?.code==='ANDROID_CAPABILITY_UNSUPPORTED'
+        ||(error?.code==='METHOD_NOT_ALLOWED'
+            &&error.reason==='core-namespace-unavailable'
+            &&error.namespace==='preferences'
+            &&error.method===`preferences.${method}`);
 }
 
-function preferenceAdapter(){
+function preferenceAdapter(assertActive){
     const local=localAdapter('arcane.preferences');
     if(is.function(globalThis.arcaneAndroid?.postMessage)) return local;
     const native=nativeAdapter();
     if(!native) return local;
     let active=native;
-    async function call(method,args){
+    async function call(method,args,context){
         try{
             return await active[method](...args);
         }catch(error){
-            if(active!==native||!isUnsupportedNativeAdapter(error)) throw error;
+            if(active!==native||!isUnsupportedNativeAdapter(error,method)) throw error;
+            assertActive(context?.signal);
             active=local;
             delete adapter.setMany;
             if(!is.function(active[method])) throw error;
@@ -175,19 +180,19 @@ function preferenceAdapter(){
         }
     }
     const adapter={
-        async get(key){
-            return call('get',[key]);
+        async get(key,context){
+            return call('get',[key,context],context);
         },
-        async set(key,value){
-            return call('set',[key,value]);
+        async set(key,value,context){
+            return call('set',[key,value,context],context);
         },
-        async delete(key){
-            return call('delete',[key]);
+        async delete(key,context){
+            return call('delete',[key,context],context);
         }
     };
     if(is.function(native.setMany)){
         adapter.setMany=async function setMany(entries,context){
-            return call('setMany',[entries,context]);
+            return call('setMany',[entries,context],context);
         };
     }
     return adapter;
@@ -204,7 +209,7 @@ export default class PreferenceStore extends EventTarget{
         super();
         this.namespace=String(namespace||'arcane');
         this.schema=preferenceSchema(schema);
-        this.adapter=validateAdapter(adapter||preferenceAdapter());
+        this.adapter=validateAdapter(adapter||preferenceAdapter(this.#assertOperationActive.bind(this)));
         this.values=this.defaults();
         this.#events=createArcaneEventSource(
             this,

package/runtime/arcane/modules/SystemAppearance.js

@@ -8,16 +8,34 @@ export default class SystemAppearance{
 
     async current(){
         if(!this.api||!is.function(this.api.current)) return {supported:false,platform:'browser'};
-        return this.api.current();
+        try{
+            return await this.api.current();
+        }catch(error){
+            return unsupportedNamespace(error,'current');
+        }
     }
 
     async apply(input={}){
         if(!this.available()) return {supported:false,platform:'browser'};
         const scheme=['system','light','dark'].includes(input.scheme)?input.scheme:'system';
-        return this.api.apply({
-            scheme,
-            captionColor:scheme==='system'?null:input.captionColor||null,
-            textColor:scheme==='system'?null:input.textColor||null
-        });
+        try{
+            return await this.api.apply({
+                scheme,
+                captionColor:scheme==='system'?null:input.captionColor||null,
+                textColor:scheme==='system'?null:input.textColor||null
+            });
+        }catch(error){
+            return unsupportedNamespace(error,'apply');
+        }
     }
 }
+
+function unsupportedNamespace(error,method){
+    if(error?.code==='METHOD_NOT_ALLOWED'
+        &&error.reason==='core-namespace-unavailable'
+        &&error.namespace==='appearance'
+        &&error.method===`appearance.${method}`){
+        return {supported:false,reason:'core-namespace-unavailable',error};
+    }
+    throw error;
+}

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/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

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

@@ -48,6 +48,7 @@ namespace Arcane.Core.Hosts.Windows
                 Dictionary<string, object> manifest = ReadRecord(Path.Combine(directory, "arcane-native.json"));
                 Dictionary<string, object> app = RequiredRecord(manifest, "app");
                 Dictionary<string, object> client = RequiredRecord(manifest, "client");
+                Dictionary<string, object> windowOptions = manifest.ContainsKey("window") ? RequiredRecord(manifest, "window") : null;
                 string appId = RequiredString(app, "id");
                 object title;
                 string name = app.TryGetValue("displayName", out title) && title is string ? (string)title : appId;
@@ -71,6 +72,9 @@ namespace Arcane.Core.Hosts.Windows
                     OriginHost = "arcane.local",
                     ProfileDirectory = Path.Combine(profileParent, "WebView2"),
                     Title = name,
+                    InitialClientWidth = OptionalWindowDimension(windowOptions, "width"),
+                    InitialClientHeight = OptionalWindowDimension(windowOptions, "height"),
+                    Resizable = OptionalWindowResizable(windowOptions),
                     IconPath = String.IsNullOrEmpty(icon) ? null : Path.Combine(directory, icon),
                     ClassicClientSource = File.ReadAllText(Path.Combine(directory, RequiredString(client, "source"))),
                     CoreExecutable = Path.Combine(directory, "runtime", "ArcaneCore.exe"),
@@ -164,6 +168,23 @@ namespace Arcane.Core.Hosts.Windows
             return text;
         }
 
+        private static double? OptionalWindowDimension(Dictionary<string, object> window, string name)
+        {
+            object value;
+            if (window == null || !window.TryGetValue(name, out value)) return null;
+            if (value is int || value is long || value is decimal || value is double)
+                return Convert.ToDouble(value, System.Globalization.CultureInfo.InvariantCulture);
+            throw new FormatException("The native manifest needs a number at window." + name + ".");
+        }
+
+        private static bool? OptionalWindowResizable(Dictionary<string, object> window)
+        {
+            object value;
+            if (window == null || !window.TryGetValue("resizable", out value)) return null;
+            if (value is bool) return (bool)value;
+            throw new FormatException("The native manifest needs a boolean at window.resizable.");
+        }
+
         private static string QuoteArgument(string value)
         {
             // Windows command-line escaping is transport-local. The child

package/src/core/runtime.mjs

@@ -267,7 +267,21 @@ class CoreRuntime {
 
     #request(frame) {
         const registration = this.#methods.get(frame.method);
-        if (!registration) throw failure('METHOD_NOT_ALLOWED', `Core does not expose ${frame.method}.`);
+        if (!registration) {
+            const namespace = frame.method.split('.')[0];
+            const prefix = `${namespace}.`;
+            const namespacePresent = this.#services.has(namespace)
+                || [...this.#methods.keys(), 'system.ping', 'app.current', 'version.current'].some(
+                    function inNamespace(method) { return method.startsWith(prefix); }
+                );
+            throw new CoreError({
+                code: 'METHOD_NOT_ALLOWED',
+                message: `Core does not expose ${frame.method}.`,
+                reason: namespacePresent ? 'core-method-unavailable' : 'core-namespace-unavailable',
+                namespace,
+                method: frame.method
+            });
+        }
         const {service, handle, lifetime} = registration;
         const controller = new AbortController();
         const request = {id: frame.id, method: frame.method, lifetime, controller, task: null};

package/src/native/portable-provider.mjs

@@ -196,6 +196,7 @@ export function createPortableNativeProvider({services, packagedWeb = false, web
                     target,
                     webRoot: 'app',
                     start: release.manifest?.app?.start ?? './index.html',
+                    ...(appDescriptor.native?.window === undefined ? {} : {window: {...appDescriptor.native.window}}),
                     core: {
                         entry: 'runtime/arcane-core.mjs', transport: 'stdio', protocol: 'arcane/1', services: selectedServices,
                         ...(localAI === undefined ? {} : {localAIRuntimes: bundled.runtimes})