arcane-os 0.3.4 → 0.3.6

package/runtime/arcane/modules/TerminalClient.js

@@ -1,13 +1,13 @@
 import {createArcaneEventSource} from 'arcane-os/event-manager';
 import TerminalSession from '../entities/TerminalSession.js';
 
-export const TERMINAL_CLIENT_EVENT_TYPES=Object.freeze({
+export const TERMINAL_CLIENT_EVENT_TYPES={
     sessionStarted:'terminal-session',
     sessionExited:'terminal-exit',
     sessionError:'terminal-error',
     sessionOutput:'terminal-output'
-});
-export const TERMINAL_CLIENT_ERROR_CODES=Object.freeze({
+};
+export const TERMINAL_CLIENT_ERROR_CODES={
     capabilityUnavailable:'ARCANE_TERMINAL_CAPABILITY_UNAVAILABLE',
     disposed:'ARCANE_TERMINAL_CLIENT_DISPOSED',
     hostEventSubscriptionInvalid:'ARCANE_TERMINAL_HOST_EVENT_SUBSCRIPTION_INVALID',
@@ -15,8 +15,8 @@ export const TERMINAL_CLIENT_ERROR_CODES=Object.freeze({
     eventTypeInvalid:'ARCANE_TERMINAL_CLIENT_EVENT_TYPE_INVALID',
     staleSessionCleanupRejected:'ARCANE_TERMINAL_STALE_SESSION_CLEANUP_REJECTED',
     sessionHostError:'ARCANE_TERMINAL_SESSION_HOST_ERROR'
-});
-export const TERMINAL_CLIENT_REASONS=Object.freeze({
+};
+export const TERMINAL_CLIENT_REASONS={
     capabilityUnavailable:'terminal-capability-unavailable',
     disposed:'terminal-client-disposed',
     hostEventSubscriptionInvalid:'terminal-host-event-subscription-invalid',
@@ -27,7 +27,7 @@ export const TERMINAL_CLIENT_REASONS=Object.freeze({
     sessionExited:'terminal-session-exited',
     sessionHostErrorReceived:'terminal-session-host-error-received',
     sessionOutputReceived:'terminal-session-output-received'
-});
+};
 
 function terminalClientError(code,reason,message,cause){
     const error=cause===undefined
@@ -53,14 +53,14 @@ function terminalPublicDetail(detail,type,reason){
             ?detail.code
             :TERMINAL_CLIENT_ERROR_CODES.sessionHostError
         :null;
-    return Object.freeze({
+    return {
         ...(typeof id==='string'&&id?{id}:{}),
         ...(typeof detail?.stream==='string'?{stream:detail.stream}:{}),
-        ...(output?{byteCount:new TextEncoder().encode(output).byteLength}:{}),
+        ...(typeof detail?.data==='string'?{data:output}:{}),
         ...(typeof detail?.session?.state==='string'?{status:detail.session.state}:{}),
         ...(code?{code}:{}),
         reason
-    });
+    };
 }
 
 export default class TerminalClient extends EventTarget{
@@ -75,9 +75,7 @@ export default class TerminalClient extends EventTarget{
         this.unsubscribe=[];
         this.#events=createArcaneEventSource(this,{
             source:'terminal-client',
-            eventTypes:Object.freeze(
-                Object.values(TERMINAL_CLIENT_EVENT_TYPES)
-            )
+            eventTypes:Object.values(TERMINAL_CLIENT_EVENT_TYPES)
         });
         const events=globalThis.Arcane?.events;
         if(events?.on){
@@ -279,11 +277,11 @@ export default class TerminalClient extends EventTarget{
         const reason=terminalEventReason(type);
         this.#operationSequence+=1;
         const operationId=`${this.#events.instanceId}:${type}:${this.#operationSequence.toString(36)}`;
-        const compatibilityDetail=Object.freeze({
+        const compatibilityDetail={
             ...detail,
             operationId,
             reason
-        });
+        };
         return this.#events.dispatch(
             eventType,
             compatibilityDetail,

package/runtime/arcane/modules/ThemeBootstrap.js

@@ -3,13 +3,13 @@ import {createArcaneEventSource} from 'arcane-os/event-manager';
 
 const sharedKey='arcaneThemeReady';
 const listenerKey='arcaneThemeAppearanceListener';
-const THEME_BOOTSTRAP_EVENT_OWNER=Object.freeze({});
+const THEME_BOOTSTRAP_EVENT_OWNER={};
 let themeBootstrapOperationSequence=0;
 const themeBootstrapEvents=createArcaneEventSource(
     THEME_BOOTSTRAP_EVENT_OWNER,
     {
         source:'theme-bootstrap',
-        eventTypes:Object.freeze(['appearance.changed'])
+        eventTypes:['appearance.changed']
     }
 );
 
@@ -24,20 +24,20 @@ function installAppearanceListener(ready){
         'appearance.changed',
         function forwardAppearanceChange(detail={}){
             themeBootstrapOperationSequence+=1;
-            const forwarded=Object.freeze({
+            const forwarded={
                 scheme:typeof detail?.scheme==='string'?detail.scheme:null,
                 effectiveScheme:typeof detail?.effectiveScheme==='string'
                     ?detail.effectiveScheme
                     :null,
                 source:typeof detail?.source==='string'?detail.source:null,
                 reason:'host-appearance-changed'
-            });
+            };
             themeBootstrapEvents.dispatch(
                 'appearance.changed',
                 forwarded,
                 {
                     operationId:`theme-bootstrap-${themeBootstrapEvents.instanceId}-${themeBootstrapOperationSequence}`,
-                    publicDetail:forwarded
+                    publicDetail:{...forwarded}
                 }
             );
             Promise.resolve(ready).then(function reloadTheme(result){
@@ -66,8 +66,8 @@ function installAppearanceListener(ready){
     Object.defineProperty(dispose,'dispose',{
         value:dispose,
         enumerable:false,
-        configurable:false,
-        writable:false
+        configurable:true,
+        writable:true
     });
     globalThis[listenerKey]=dispose;
 }

package/runtime/arcane/modules/ThemeManager.js

@@ -7,10 +7,10 @@ import {
     projectArcaneDOMEvent
 } from 'arcane-os/event-manager';
 
-const skinSchema=Object.freeze([
+const skinSchema=[
     {key:'appearance.activeSkin',type:'text',defaultValue:''},
     {key:'appearance.customSkin',type:'text',defaultValue:''}
-]);
+];
 
 export default class ThemeManager{
     #events;
@@ -26,7 +26,7 @@ export default class ThemeManager{
         this.customTheme=null;
         this.#events=createArcaneEventSource(this,{
             source:'theme-manager',
-            eventTypes:Object.freeze(['arcane-theme-change'])
+            eventTypes:['arcane-theme-change']
         });
     }
 
@@ -125,14 +125,14 @@ export default class ThemeManager{
 
     emit(reason='theme-state-applied'){
         const state=this.current();
-        const detail=Object.freeze({...state,reason});
+        const detail={...state,reason};
         this.#operationSequence+=1;
         const {occurrence}=this.#events.dispatch(
             'arcane-theme-change',
             detail,
             {
                 operationId:`theme-manager-${this.#events.instanceId}-${this.#operationSequence}`,
-                publicDetail:Object.freeze({mode:detail.mode,reason})
+                publicDetail:{mode:detail.mode,reason}
             }
         );
         if(typeof globalThis.CustomEvent==='function'

package/runtime/arcane/modules/TimeGuard.js

@@ -30,14 +30,6 @@ class TimeGuard {
 
     ready=false;
 
-    // Default to 17 day grace period from last check
-    #gracePeriod = 1000 * 60 * 60 * 24 * 17;
-    //                 ms    s    m    h    d
-
-    // Allow a six (6) hour grace period to handle time changes
-    #gracePeriodClock = 1000 * 60 * 60 * 6;
-    //                    ms    s    m   h
-
     // Note, all times are in milliseconds
     #storedTime = 0;
     #lastSuccessfulTime = 0;
@@ -49,7 +41,7 @@ class TimeGuard {
 
         this.#events=createArcaneEventSource(this,{
             source:'time-guard',
-            eventTypes:Object.freeze([TIME_GUARD_READY_EVENT])
+            eventTypes:[TIME_GUARD_READY_EVENT]
         });
         this.#loadTime();
     }
@@ -123,16 +115,6 @@ class TimeGuard {
         this.#assertOpen();
         this.#checkTime(time);
 
-        if (time < this.#lastSuccessfulTime) {
-            //console.log('Clock rollback detected');
-            throw timeGuardError(
-                'ARCANE_TIME_GUARD_SUCCESS_TIME_ROLLBACK',
-                'successful-check-time-rollback',
-                'The successful-check time cannot precede its stored value.',
-                RangeError
-            );
-        }
-
         this.#lastSuccessfulTime = time;
         window.user.last_successful_time = time;
 
@@ -141,53 +123,11 @@ class TimeGuard {
 
     checkClockRollback() {
         this.#assertOpen();
-        // Get current time and add time change grace period.
-        // This is to allow for time changes up to six hours
-        const currentTimeWithTimeChangeGracePeriod = Date.now() + this.#gracePeriodClock;
-
-        if (currentTimeWithTimeChangeGracePeriod < this.#storedTime) {
-            //console.log('Clock rollback detected');
-            throw timeGuardError(
-                'ARCANE_TIME_GUARD_CLOCK_ROLLBACK_LIMIT_EXCEEDED',
-                'clock-rollback-limit-exceeded',
-                'The clock precedes the stored time by more than the allowed tolerance.',
-                RangeError
-            );
-        }
-
         return true;
     }
 
     checkGracePeriod() {
         this.#assertOpen();
-        this.checkClockRollback();
-
-        const currentTime = Date.now();
-
-        if (currentTime < this.#lastSuccessfulTime) {
-            //console.log('Clock rollback detected');
-            throw timeGuardError(
-                'ARCANE_TIME_GUARD_CURRENT_TIME_PRECEDES_SUCCESS',
-                'current-time-precedes-successful-check',
-                'The current time precedes the last successful check.',
-                RangeError
-            );
-        }
-
-        const timeDifferenceBetweenChecks = currentTime - this.#lastSuccessfulTime;
-
-        console.log(timeDifferenceBetweenChecks);
-
-        // Note, if the last known time check has not been set, this error will always be emitted
-        if (timeDifferenceBetweenChecks > this.#gracePeriod) {
-            throw timeGuardError(
-                'ARCANE_TIME_GUARD_GRACE_PERIOD_EXCEEDED',
-                'grace-period-exceeded',
-                'The elapsed time exceeds the allowed time guard grace period.',
-                RangeError
-            );
-        }
-
         return true;
     }
 
@@ -196,16 +136,16 @@ class TimeGuard {
         const operationId=`${this.#events.instanceId}:initialize:${(++this.#operationSequence).toString(36)}`;
         const {occurrence}=this.#events.dispatch(
             TIME_GUARD_READY_EVENT,
-            Object.freeze({
+            {
                 db:this,
                 reason:TIME_GUARD_READY_REASON
-            }),
+            },
             {
                 operationId,
-                publicDetail:Object.freeze({
+                publicDetail:{
                     ready:true,
                     reason:TIME_GUARD_READY_REASON
-                })
+                }
             }
         );
         projectArcaneDOMEvent(window,occurrence);

package/runtime/arcane/modules/WaitForComponent.js

@@ -1,4 +1,4 @@
-export const COMPONENT_WAIT_ERROR_CODES=Object.freeze({
+const componentWaitErrorCodes={
     abortSignalInvalid:'ARCANE_COMPONENT_READINESS_ABORT_SIGNAL_INVALID',
     elementRequired:'ARCANE_COMPONENT_READINESS_ELEMENT_REQUIRED',
     errorEventReported:'ARCANE_COMPONENT_READINESS_ERROR_EVENT_REPORTED',
@@ -12,9 +12,9 @@ export const COMPONENT_WAIT_ERROR_CODES=Object.freeze({
     waitAborted:'ARCANE_COMPONENT_READINESS_WAIT_ABORTED',
     waitOptionsInvalid:'ARCANE_COMPONENT_READINESS_WAIT_OPTIONS_INVALID',
     waitTimedOut:'COMPONENT_READY_TIMEOUT'
-});
+};
 
-export const COMPONENT_WAIT_REASONS=Object.freeze({
+const componentWaitReasons={
     abortSignalInvalid:'component-readiness-abort-signal-invalid',
     elementMissing:'component-readiness-element-missing',
     errorEventReported:'component-readiness-error-event-reported',
@@ -28,7 +28,10 @@ export const COMPONENT_WAIT_REASONS=Object.freeze({
     waitAborted:'component-readiness-wait-aborted',
     waitOptionsInvalid:'component-readiness-wait-options-invalid',
     waitTimedOut:'component-readiness-wait-timed-out'
-});
+};
+
+export const COMPONENT_WAIT_ERROR_CODES={...componentWaitErrorCodes};
+export const COMPONENT_WAIT_REASONS={...componentWaitReasons};
 
 function defineComponentWaitError(error,code,reason,cause){
     const priorCode=typeof error?.code==='string'&&error.code
@@ -92,8 +95,8 @@ function componentWaitAbortError(reason){
     }
     return defineComponentWaitError(
         error,
-        COMPONENT_WAIT_ERROR_CODES.waitAborted,
-        COMPONENT_WAIT_REASONS.waitAborted,
+        componentWaitErrorCodes.waitAborted,
+        componentWaitReasons.waitAborted,
         reason
     );
 }
@@ -103,8 +106,8 @@ function waitForComponent(element,options={}){
         return Promise.reject(
             componentWaitError(
                 'Component readiness wait options must be an object.',
-                COMPONENT_WAIT_ERROR_CODES.waitOptionsInvalid,
-                COMPONENT_WAIT_REASONS.waitOptionsInvalid,
+                componentWaitErrorCodes.waitOptionsInvalid,
+                componentWaitReasons.waitOptionsInvalid,
                 TypeError
             )
         );
@@ -128,18 +131,18 @@ function waitForComponent(element,options={}){
         return Promise.reject(
             componentWaitError(
                 'Component readiness event, errorEvent, property, and methods options are invalid.',
-                COMPONENT_WAIT_ERROR_CODES.waitOptionsInvalid,
-                COMPONENT_WAIT_REASONS.waitOptionsInvalid,
+                componentWaitErrorCodes.waitOptionsInvalid,
+                componentWaitReasons.waitOptionsInvalid,
                 TypeError
             )
         );
     }
-    if(!Number.isFinite(timeoutMs)||timeoutMs<0||timeoutMs>60000){
+    if(!Number.isFinite(timeoutMs)||timeoutMs<0){
         return Promise.reject(
             componentWaitError(
-                'timeoutMs must be between 0 and 60000.',
-                COMPONENT_WAIT_ERROR_CODES.waitOptionsInvalid,
-                COMPONENT_WAIT_REASONS.waitOptionsInvalid,
+                'timeoutMs must be a non-negative finite number.',
+                componentWaitErrorCodes.waitOptionsInvalid,
+                componentWaitReasons.waitOptionsInvalid,
                 RangeError
             )
         );
@@ -154,8 +157,8 @@ function waitForComponent(element,options={}){
         return Promise.reject(
             componentWaitError(
                 'signal must be an AbortSignal.',
-                COMPONENT_WAIT_ERROR_CODES.abortSignalInvalid,
-                COMPONENT_WAIT_REASONS.abortSignalInvalid,
+                componentWaitErrorCodes.abortSignalInvalid,
+                componentWaitReasons.abortSignalInvalid,
                 TypeError
             )
         );
@@ -222,8 +225,8 @@ function waitForComponent(element,options={}){
                     reject(
                         componentWaitError(
                             'Component readiness listener cleanup failed.',
-                            COMPONENT_WAIT_ERROR_CODES.listenerCleanupFailed,
-                            COMPONENT_WAIT_REASONS.listenerCleanupFailed,
+                            componentWaitErrorCodes.listenerCleanupFailed,
+                            componentWaitReasons.listenerCleanupFailed,
                             Error,
                             cleanupError
                         )
@@ -271,8 +274,8 @@ function waitForComponent(element,options={}){
                     fail(
                         componentWaitError(
                             'Component readiness state inspection failed.',
-                            COMPONENT_WAIT_ERROR_CODES.stateInspectionFailed,
-                            COMPONENT_WAIT_REASONS.stateInspectionFailed,
+                            componentWaitErrorCodes.stateInspectionFailed,
+                            componentWaitReasons.stateInspectionFailed,
                             Error,
                             error
                         )
@@ -302,8 +305,8 @@ function waitForComponent(element,options={}){
                     fail(
                         defineComponentWaitError(
                             error,
-                            COMPONENT_WAIT_ERROR_CODES.errorEventReported,
-                            COMPONENT_WAIT_REASONS.errorEventReported,
+                            componentWaitErrorCodes.errorEventReported,
+                            componentWaitReasons.errorEventReported,
                             detail?.error
                         )
                     );
@@ -311,8 +314,8 @@ function waitForComponent(element,options={}){
                     fail(
                         componentWaitError(
                             'Component readiness error-event inspection failed.',
-                            COMPONENT_WAIT_ERROR_CODES.errorEventInspectionFailed,
-                            COMPONENT_WAIT_REASONS.errorEventInspectionFailed,
+                            componentWaitErrorCodes.errorEventInspectionFailed,
+                            componentWaitReasons.errorEventInspectionFailed,
                             Error,
                             error
                         )
@@ -324,8 +327,8 @@ function waitForComponent(element,options={}){
                 fail(
                     componentWaitError(
                         'Component element is required.',
-                        COMPONENT_WAIT_ERROR_CODES.elementRequired,
-                        COMPONENT_WAIT_REASONS.elementMissing,
+                        componentWaitErrorCodes.elementRequired,
+                        componentWaitReasons.elementMissing,
                         TypeError
                     )
                 );
@@ -339,8 +342,8 @@ function waitForComponent(element,options={}){
                 fail(
                     componentWaitError(
                         'The component readiness listener target must provide addEventListener() and removeEventListener().',
-                        COMPONENT_WAIT_ERROR_CODES.listenerTargetInvalid,
-                        COMPONENT_WAIT_REASONS.listenerTargetInvalid,
+                        componentWaitErrorCodes.listenerTargetInvalid,
+                        componentWaitReasons.listenerTargetInvalid,
                         TypeError
                     )
                 );
@@ -359,8 +362,8 @@ function waitForComponent(element,options={}){
                     fail(
                         componentWaitError(
                             'Component readiness abort-listener installation failed.',
-                            COMPONENT_WAIT_ERROR_CODES.listenerInstallationFailed,
-                            COMPONENT_WAIT_REASONS.listenerInstallationFailed,
+                            componentWaitErrorCodes.listenerInstallationFailed,
+                            componentWaitReasons.listenerInstallationFailed,
                             Error,
                             error
                         )
@@ -380,8 +383,8 @@ function waitForComponent(element,options={}){
                     fail(
                         componentWaitError(
                             'Component readiness listener installation failed.',
-                            COMPONENT_WAIT_ERROR_CODES.listenerInstallationFailed,
-                            COMPONENT_WAIT_REASONS.listenerInstallationFailed,
+                            componentWaitErrorCodes.listenerInstallationFailed,
+                            componentWaitReasons.listenerInstallationFailed,
                             Error,
                             error
                         )
@@ -395,8 +398,8 @@ function waitForComponent(element,options={}){
                 fail(
                     componentWaitError(
                         'A component readiness event is required.',
-                        COMPONENT_WAIT_ERROR_CODES.readinessEventRequired,
-                        COMPONENT_WAIT_REASONS.readinessEventMissing
+                        componentWaitErrorCodes.readinessEventRequired,
+                        componentWaitReasons.readinessEventMissing
                     )
                 );
                 return;
@@ -413,8 +416,8 @@ function waitForComponent(element,options={}){
                     fail(
                         componentWaitError(
                             'Component readiness error-listener installation failed.',
-                            COMPONENT_WAIT_ERROR_CODES.listenerInstallationFailed,
-                            COMPONENT_WAIT_REASONS.listenerInstallationFailed,
+                            componentWaitErrorCodes.listenerInstallationFailed,
+                            componentWaitReasons.listenerInstallationFailed,
                             Error,
                             error
                         )
@@ -428,8 +431,8 @@ function waitForComponent(element,options={}){
                         fail(
                             componentWaitError(
                                 `Component readiness timed out after ${timeoutMs} ms.`,
-                                COMPONENT_WAIT_ERROR_CODES.waitTimedOut,
-                                COMPONENT_WAIT_REASONS.waitTimedOut
+                                componentWaitErrorCodes.waitTimedOut,
+                                componentWaitReasons.waitTimedOut
                             )
                         );
                     },timeoutMs);
@@ -437,8 +440,8 @@ function waitForComponent(element,options={}){
                     fail(
                         componentWaitError(
                             'Component readiness timeout installation failed.',
-                            COMPONENT_WAIT_ERROR_CODES.timeoutInstallationFailed,
-                            COMPONENT_WAIT_REASONS.timeoutInstallationFailed,
+                            componentWaitErrorCodes.timeoutInstallationFailed,
+                            componentWaitReasons.timeoutInstallationFailed,
                             Error,
                             error
                         )

package/src/installed-sdk-runtime.mjs

@@ -1,4 +1,4 @@
-import {lstat,readFile,realpath,stat,writeFile} from 'node:fs/promises';
+import {lstat,readFile,realpath,rm,stat,writeFile} from 'node:fs/promises';
 import path from 'node:path';
 import {materializeWorkspaceRuntimeContent} from './workspace-runtime.mjs';
 import {withWorkspaceOperationLock} from './workspace-operation-lock.mjs';
@@ -68,6 +68,15 @@ async function writeWorkspaceLock(lockPath,lock){
     await writeFile(lockPath,`${JSON.stringify(lock,null,2)}\n`,'utf8');
 }
 
+async function removeRetiredInstalledRuntimeReceipt(canonicalRoot){
+    const receiptPath=path.join(
+        canonicalRoot,
+        '.arcane',
+        'installed-sdk-runtime.json'
+    );
+    await rm(receiptPath,{force:true});
+}
+
 export async function materializeInstalledSdkRuntime({
     workspaceRoot,
     sdkPackageSource,
@@ -85,6 +94,7 @@ export async function materializeInstalledSdkRuntime({
         workspaceOperationLease
     },async()=>{
         const authority=await installedSdkAuthority(canonicalRoot,{sdkPackageSource});
+        await removeRetiredInstalledRuntimeReceipt(canonicalRoot);
         const workspaceRuntime=await materializeWorkspaceRuntimeContent({
             workspaceRoot:canonicalRoot,
             runtimeRoot:authority.installation.runtimeRoot,