arcane-os 0.5.16 → 0.5.18

package/runtime/arcane/entities/Chat.js

@@ -1,5 +1,5 @@
 import { arcaneLogging } from 'arcane-os/logging';
-import Is from '../../node_modules/strong-type/index.js';
+import Is from 'strong-type';
 import '../modules/DBOPFS.js';
 import '../modules/AI.js';
 import {
@@ -12,7 +12,7 @@ import {normalizeMemoryContent} from '../modules/MemoryRecords.js';
 const is = new Is(false);
 
 function plainRecord(value){
-    if(!value||typeof value!=='object'||Array.isArray(value))return false;
+    if(!value||!is.object(value)||is.array(value))return false;
     const prototype=Object.getPrototypeOf(value);
     return prototype===Object.prototype||prototype===null;
 }
@@ -23,9 +23,9 @@ function coded(error,code){
 }
 
 function copyCompleteValue(value,seen=new Map()){
-    if(value===null||typeof value!=='object')return value;
+    if(value===null||!is.object(value))return value;
     if(seen.has(value))return seen.get(value);
-    if(Array.isArray(value)){
+    if(is.array(value)){
         const result=[];
         seen.set(value,result);
         for(const item of value)result.push(copyCompleteValue(item,seen));
@@ -45,7 +45,7 @@ function copyCompleteValue(value,seen=new Map()){
 
 function copyToolCalls(value){
     if(value===undefined) return null;
-    if(!Array.isArray(value)){
+    if(!is.array(value)){
         const error=new TypeError('assistantMessage.tool_calls must be an array.');
         error.code='AI_CHAT_INVALID_TOOL_CALL';
         throw error;
@@ -61,12 +61,12 @@ function copyToolCalls(value){
         const name=call.function.name;
         const argumentValue=call.function.arguments;
         if(
-            typeof id!=='string'
+            !is.string(id)
             ||!id.trim()
             ||ids.has(id)
-            ||typeof name!=='string'
+            ||!is.string(name)
             ||!name.trim()
-            ||typeof argumentValue!=='string'
+            ||!is.string(argumentValue)
         ){
             const error=new TypeError(`assistantMessage.tool_calls[${index}] is invalid.`);
             error.code='AI_CHAT_INVALID_TOOL_CALL';
@@ -90,7 +90,7 @@ function copyToolCalls(value){
             error.code='AI_CHAT_INVALID_TOOL_CALL';
             throw error;
         }
-        if(typeof argumentRecord.message!=='string'||!argumentRecord.message.trim()){
+        if(!is.string(argumentRecord.message)||!argumentRecord.message.trim()){
             const error=new TypeError(
                 `assistantMessage.tool_calls[${index}].function.arguments.message must contain user-facing text.`
             );
@@ -114,7 +114,7 @@ function structuralToolMessage(call){
 
 function storedStructuralToolCalls(value){
     if(value===undefined) return [];
-    if(!Array.isArray(value)){
+    if(!is.array(value)){
         arcaneLogging.error('Arcane stored assistant tool calls were not an array and were not retained.');
         return [];
     }
@@ -133,12 +133,12 @@ function storedStructuralToolCalls(value){
 }
 
 function storedToolRecord({content,name,status,timestamp}){
-    if(typeof content!=='string'||!content.trim()) return [];
+    if(!is.string(content)||!content.trim()) return [];
     return [{
         role:'tool',
         content,
-        ...(typeof name==='string'&&name.trim()?{name}:{}),
-        ...(typeof status==='string'&&status.trim()?{status}:{}),
+        ...(is.string(name)&&name.trim()?{name}:{}),
+        ...(is.string(status)&&status.trim()?{status}:{}),
         ...(timestamp!==undefined?{timestamp}:{}),
     }];
 }
@@ -151,7 +151,7 @@ function storedChatRecords(messages,{memoryOnly=false}={}){
         if(memoryOnly&&message.memory_excluded===true) continue;
         const timestamp=message.timestamp;
         if(message.role==='user'){
-            if(typeof message.content!=='string') continue;
+            if(!is.string(message.content)) continue;
             result.push({
                 role:'user',
                 content:message.content,
@@ -181,7 +181,7 @@ function storedChatRecords(messages,{memoryOnly=false}={}){
             continue;
         }
         if(message.role==='tool'){
-            const protocolResult=typeof message.tool_call_id==='string'&&message.tool_call_id;
+            const protocolResult=is.string(message.tool_call_id)&&message.tool_call_id;
             result.push(...storedToolRecord({
                 content:protocolResult?message.persistence_message:message.content,
                 name:message.persistence_name??message.name,
@@ -198,12 +198,12 @@ function retainedChatMessages(messages){
 }
 
 function turnMessage(value,label){
-    if(!plainRecord(value)||!['tool','user'].includes(value.role)||typeof value.content!=='string'){
+    if(!plainRecord(value)||!['tool','user'].includes(value.role)||!is.string(value.content)){
         throw new TypeError(`${label} must be a user or tool message.`);
     }
     if(value.role==='tool'){
         const toolCallId=value.tool_call_id;
-        if(typeof toolCallId!=='string'||!toolCallId.trim()){
+        if(!is.string(toolCallId)||!toolCallId.trim()){
             throw coded(
                 new TypeError(`${label}.tool_call_id is invalid.`),
                 'AI_CHAT_INVALID_TOOL_MESSAGE'
@@ -277,13 +277,13 @@ function pendingToolCalls(messages){
             if(toolCallId===undefined){
                 continue;
             }
-            if(typeof toolCallId!=='string'||!toolCallId.trim()){
+            if(!is.string(toolCallId)||!toolCallId.trim()){
                 throw coded(
                     new TypeError(`Chat message ${index+1} has an invalid tool_call_id.`),
                     'AI_CHAT_INCOHERENT_PERSISTENCE'
                 );
             }
-            if(typeof message.content!=='string'||!message.content.trim()){
+            if(!is.string(message.content)||!message.content.trim()){
                 throw coded(
                     new TypeError(`Chat message ${index+1} has a blank tool result.`),
                     'AI_CHAT_INCOHERENT_PERSISTENCE'
@@ -308,7 +308,7 @@ function turnMessages(requestMessage,requestMessages){
         throw new TypeError('Provide exactly one of requestMessage or requestMessages.');
     }
     const values=hasMessages?requestMessages:[requestMessage];
-    if(!Array.isArray(values)||values.length===0){
+    if(!is.array(values)||values.length===0){
         throw new TypeError('requestMessages must be a nonempty array.');
     }
     const records=values.map((value,index)=>
@@ -513,7 +513,7 @@ class ChatEntity{
      * @returns {Array<*>}
      */
     set messages(v){
-        if(!Array.isArray(v)){
+        if(!is.array(v)){
             throw new TypeError('messages must be an array.');
         }
         this.#messages=v.map(message=>copyCompleteValue(message));
@@ -538,7 +538,7 @@ class ChatEntity{
      * @returns {boolean}
      */
     set saved(v){
-        if(typeof v!=='boolean'){
+        if(!is.boolean(v)){
             throw new TypeError('saved must be a boolean.');
         }
         this.#saved=v;
@@ -646,9 +646,9 @@ class ChatEntity{
         const toolCallId=id;
         const toolName=name;
         if(
-            typeof toolCallId!=='string'
+            !is.string(toolCallId)
             ||!toolCallId.trim()
-            ||typeof toolName!=='string'
+            ||!is.string(toolName)
             ||!toolName.trim()
         ){
             throw new TypeError('Tool exchanges require an id and name.');
@@ -663,13 +663,13 @@ class ChatEntity{
             );
         }
 
-        const serializedArguments=typeof argumentValue==='string'
+        const serializedArguments=is.string(argumentValue)
             ?argumentValue
             :JSON.stringify(argumentValue);
-        const serializedResult=typeof result==='string'
+        const serializedResult=is.string(result)
             ?result
             :JSON.stringify(result);
-        if(typeof serializedArguments!=='string'||typeof serializedResult!=='string'){
+        if(!is.string(serializedArguments)||!is.string(serializedResult)){
             throw new TypeError('Tool exchange arguments and results must be JSON-compatible.');
         }
         const toolCall=copyToolCalls([{
@@ -723,7 +723,7 @@ class ChatEntity{
         if(!is.boolean(messagePersist)||!is.boolean(responsePersist)||!is.boolean(extractMemory)){
             throw new TypeError('Turn persistence and memory options must be boolean.');
         }
-        if(typeof memoryRequest!=='function'){
+        if(!is.function(memoryRequest)){
             throw new TypeError('memoryRequest must be a function.');
         }
         if(messagePersist!==responsePersist){
@@ -762,7 +762,7 @@ class ChatEntity{
         const toolCalls=copyToolCalls(assistantMessage.tool_calls);
         const assistantContent=assistantMessage.content??'';
         const assistantReasoning=assistantMessage.reasoning_content;
-        if(assistantReasoning!==undefined&&typeof assistantReasoning!=='string'){
+        if(assistantReasoning!==undefined&&!is.string(assistantReasoning)){
             throw new TypeError('assistantMessage.reasoning_content must be a string when provided.');
         }
         if(
@@ -770,7 +770,7 @@ class ChatEntity{
             ||(
                 !String(assistantContent)
                 &&!toolCalls?.length
-                &&!(typeof assistantReasoning==='string'&&assistantReasoning.length)
+                &&!(is.string(assistantReasoning)&&assistantReasoning.length)
             )
         ){
             throw new TypeError(
@@ -823,7 +823,7 @@ class ChatEntity{
             this.fileName
         );
 
-        if(!content||(Array.isArray(content)&&content.length===0)){
+        if(!content||(is.array(content)&&content.length===0)){
             const systemMessage=this.#messages.find(message=>message.role==='system');
             this.#messages=systemMessage?[systemMessage]:[];
             this.#persistedMessageCount=0;
@@ -832,7 +832,7 @@ class ChatEntity{
             return this.transcript;
         }
 
-        const loadedMessages=Array.isArray(content)
+        const loadedMessages=is.array(content)
             ?content.map(message=>copyCompleteValue(message))
             :String(content)
                 .split('\n')
@@ -858,7 +858,7 @@ class ChatEntity{
     }
 
     async getMemoriesAboutUser({request=messages=>ai.fetch(messages)}={}){
-        if(typeof request!=='function'){
+        if(!is.function(request)){
             throw new TypeError('Memory request must be a function.');
         }
         return this.#writeMemory(

package/runtime/arcane/entities/CommunicationMessage.js

@@ -1,10 +1,13 @@
+import Is from 'strong-type';
+const is=new Is(false);
+
 const CHANNELS=new Set(['email','sms','mms','rcs','whatsapp','other']);
 const DIRECTIONS=new Set(['inbound','outbound']);
 const STATUSES=new Set(['draft','queued','sending','sent','delivered','read','failed','received']);
 
 function required(value,label){const text=String(value??'').trim();if(!text) throw new TypeError(`${label} is required.`);return text;}
 function strings(value){return Array.from(value||[],item=>String(item??'').trim()).filter(Boolean);}
-function instant(value){const date=value instanceof Date?value:new Date(value||Date.now());if(Number.isNaN(date.valueOf())) throw new TypeError('Message timestamp is invalid.');return date.toISOString();}
+function instant(value){const date=value instanceof Date?value:new Date(value||Date.now());if(is.NaN(date.valueOf())) throw new TypeError('Message timestamp is invalid.');return date.toISOString();}
 
 export default class CommunicationMessage{
     constructor(input={}){

package/runtime/arcane/entities/CommunicationThread.js

@@ -1,3 +1,6 @@
+import Is from 'strong-type';
+const is=new Is(false);
+
 import CommunicationMessage from './CommunicationMessage.js';
 
 function required(value,label){const text=String(value??'').trim();if(!text) throw new TypeError(`${label} is required.`);return text;}
@@ -11,7 +14,7 @@ export default class CommunicationThread{
         this.participants=Object.freeze(Array.from(input.participants||[],value=>String(value??'').trim()).filter(Boolean));
         this.preview=String(input.preview||'');
         const date=new Date(input.updatedAt||Date.now());
-        if(Number.isNaN(date.valueOf())) throw new TypeError('Thread update time is invalid.');
+        if(is.NaN(date.valueOf())) throw new TypeError('Thread update time is invalid.');
         this.updatedAt=date.toISOString();
         this.unreadCount=Math.max(0,Number.parseInt(input.unreadCount||0,10)||0);
         this.messages=Object.freeze(Array.from(input.messages||[],value=>value instanceof CommunicationMessage?value:new CommunicationMessage({...value,threadId:value.threadId||this.id,providerId:value.providerId||this.providerId,channel:value.channel||this.channel})));

package/runtime/arcane/entities/File.js

@@ -1,4 +1,4 @@
-import Is from '../../node_modules/strong-type/index.js';
+import Is from 'strong-type';
 import '../modules/DBOPFS.js';
 import MD from '../modules/MD.js';
 

package/runtime/arcane/entities/Image.js

@@ -1,3 +1,6 @@
+import Is from 'strong-type';
+const is=new Is(false);
+
 import FileEntity from './File.js';
 
 /**
@@ -34,11 +37,11 @@ class ImageEntity extends FileEntity {
 	 * @returns {boolean}
 	 */
 	static isImageFile(file) {
-		if (!file || typeof file.name !== 'string') {
+		if (!file || !is.string(file.name)) {
 			return false;
 		}
 
-		const hasImageMime = typeof file.type === 'string' && file.type.startsWith('image/');
+		const hasImageMime = is.string(file.type) && file.type.startsWith('image/');
 		const hasImageExt = /\.(png|jpe?g|svg)$/i.test(file.name);
 
 		return hasImageMime || hasImageExt;
@@ -51,12 +54,12 @@ class ImageEntity extends FileEntity {
 	 * @returns {boolean}
 	 */
 	static isPNGFile(file) {
-		if (!file || typeof file.name !== 'string') {
+		if (!file || !is.string(file.name)) {
 			return false;
 		}
 
 		const lowerName = file.name.toLowerCase();
-		const hasPngMime = typeof file.type === 'string' && file.type.toLowerCase() === 'image/png';
+		const hasPngMime = is.string(file.type) && file.type.toLowerCase() === 'image/png';
 		const hasPngExt = lowerName.endsWith('.png');
 
 		return hasPngMime || hasPngExt;
@@ -125,7 +128,7 @@ class ImageEntity extends FileEntity {
 	 * @returns {void}
 	 */
 	static revokeBlobURL(url = '') {
-		if (typeof url === 'string' && url.startsWith('blob:')) {
+		if (is.string(url) && url.startsWith('blob:')) {
 			URL.revokeObjectURL(url);
 		}
 	}

package/runtime/arcane/entities/IntentEnvelope.js

@@ -1,3 +1,6 @@
+import Is from 'strong-type';
+const is=new Is(false);
+
 const IDENTIFIER_MAXIMUM_CHARACTERS = 128;
 
 const SCHEMA = 'arcane.intent-envelope';
@@ -60,7 +63,7 @@ function fail(code, path, message, options) {
 }
 
 function isReservedKey(key) {
-    return typeof key === 'string' && RESERVED_KEYS.has(key);
+    return is.string(key) && RESERVED_KEYS.has(key);
 }
 
 function validateUnicode(value, path) {
@@ -86,7 +89,7 @@ function normalizedString(value, path, options = {}) {
     if (nullable && value === null) {
         return null;
     }
-    if (typeof value !== 'string') {
+    if (!is.string(value)) {
         fail('INTENT_ENVELOPE_INVALID', path, 'Intent envelope field has an invalid type.');
     }
     validateUnicode(value, path);
@@ -102,7 +105,7 @@ function identifier(value, path, options = {}) {
     if (nullable && value === null) {
         return null;
     }
-    if (typeof value !== 'string') {
+    if (!is.string(value)) {
         fail('INTENT_ENVELOPE_INVALID', path, 'Intent envelope identifier has an invalid type.');
     }
     validateUnicode(value, path);
@@ -113,14 +116,14 @@ function identifier(value, path, options = {}) {
 }
 
 function enumeration(value, path, values) {
-    if (typeof value !== 'string' || !values.has(value)) {
+    if (!is.string(value) || !values.has(value)) {
         fail('INTENT_ENVELOPE_INVALID', path, 'Intent envelope enum value is invalid.');
     }
     return value;
 }
 
 function plainRecord(value, path, allowedKeys, active) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    if (!value || !is.object(value) || is.array(value)) {
         fail('INTENT_ENVELOPE_INVALID', path, 'Intent envelope field must be a plain record.');
     }
     const prototype = Object.getPrototypeOf(value);
@@ -139,7 +142,7 @@ function plainRecord(value, path, allowedKeys, active) {
     const ownKeys = Reflect.ownKeys(value);
 
     for (const key of ownKeys) {
-        if (typeof key !== 'string' || isReservedKey(key) || !allowed.has(key)) {
+        if (!is.string(key) || isReservedKey(key) || !allowed.has(key)) {
             active.delete(value);
             fail('INTENT_ENVELOPE_UNKNOWN_FIELD', path, 'Intent envelope contains an unsupported field.');
         }
@@ -172,7 +175,7 @@ function ownValue(record, key, path, options = {}) {
 }
 
 function denseArray(value, path, active) {
-    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) {
+    if (!is.array(value) || Object.getPrototypeOf(value) !== Array.prototype) {
         fail('INTENT_ENVELOPE_INVALID', path, 'Intent envelope field must be an array.');
     }
     if (active.has(value)) {
@@ -184,7 +187,7 @@ function denseArray(value, path, active) {
         if (key === 'length') {
             continue;
         }
-        if (typeof key !== 'string' || isReservedKey(key) || !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length) {
+        if (!is.string(key) || isReservedKey(key) || !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length) {
             active.delete(value);
             fail('INTENT_ENVELOPE_UNKNOWN_FIELD', path, 'Intent envelope array contains an unsupported field.');
         }
@@ -208,24 +211,24 @@ function finishArray(value, active) {
 }
 
 function normalizeTimestamp(value, path) {
-    if (typeof value !== 'string') {
+    if (!is.string(value)) {
         fail('INTENT_ENVELOPE_INVALID', path, 'Intent envelope timestamp is invalid.');
     }
     const instant = new Date(value);
-    if (Number.isNaN(instant.valueOf()) || instant.toISOString() !== value) {
+    if (is.NaN(instant.valueOf()) || instant.toISOString() !== value) {
         fail('INTENT_ENVELOPE_INVALID', path, 'Intent envelope timestamp is invalid.');
     }
     return value;
 }
 
 function normalizeTrustedTimestamp(value, path) {
-    if (!(typeof value === 'string' || value instanceof Date)) {
+    if (!(is.string(value) || value instanceof Date)) {
         fail('INTENT_ENVELOPE_INVALID', path, 'Intent envelope timestamp is invalid.');
     }
 
     const instant = new Date(value);
 
-    if (Number.isNaN(instant.valueOf())) {
+    if (is.NaN(instant.valueOf())) {
         fail('INTENT_ENVELOPE_INVALID', path, 'Intent envelope timestamp is invalid.');
     }
 
@@ -245,7 +248,7 @@ function normalizeGoal(value, path, active) {
     const version = identifier(versionValue, `${path}.version`);
     const confidenceValue = ownValue(record, 'confidence', path);
     if (confidenceValue !== null && (
-        typeof confidenceValue !== 'number' || !Number.isFinite(confidenceValue) || confidenceValue < 0 || confidenceValue > 1
+        !is.number(confidenceValue) || !is.finite(confidenceValue) || confidenceValue < 0 || confidenceValue > 1
     )) {
         finishRecord(record, active);
         fail('INTENT_ENVELOPE_INVALID', `${path}.confidence`, 'Intent envelope confidence is invalid.');
@@ -256,15 +259,15 @@ function normalizeGoal(value, path, active) {
 }
 
 function normalizeScalar(value, path) {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
-        if (typeof value === 'string') {
+    if (value === null || is.string(value) || is.boolean(value)) {
+        if (is.string(value)) {
             validateUnicode(value, path);
         }
 
         return value;
     }
 
-    if (typeof value === 'number' && Number.isFinite(value)) {
+    if (is.number(value) && is.finite(value)) {
         return value;
     }
 
@@ -704,7 +707,7 @@ export function createIntentEnvelope(payload, trustedContext) {
 }
 
 export function rehydrateIntentEnvelope(canonical) {
-    if (typeof canonical === 'string') {
+    if (is.string(canonical)) {
         try {
             const parsed = JSON.parse(canonical);
             return buildEnvelope(parsed);

package/runtime/arcane/entities/Preference.js

@@ -1,3 +1,6 @@
+import Is from 'strong-type';
+const is=new Is(false);
+
 const KEY_PATTERN=/^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
 const TYPES=new Set(['boolean','number','select','text']);
 
@@ -18,9 +21,9 @@ export default class Preference{
         this.description=String(definition.description||'');
         this.defaultValue=this.normalize(definition.defaultValue);
         this.options=type==='select'?this.normalizeOptions(definition.options):[];
-        this.minimum=Number.isFinite(Number(definition.minimum))?Number(definition.minimum):undefined;
-        this.maximum=Number.isFinite(Number(definition.maximum))?Number(definition.maximum):undefined;
-        this.step=Number.isFinite(Number(definition.step))?Number(definition.step):undefined;
+        this.minimum=is.finite(Number(definition.minimum))?Number(definition.minimum):undefined;
+        this.maximum=is.finite(Number(definition.maximum))?Number(definition.maximum):undefined;
+        this.step=is.finite(Number(definition.step))?Number(definition.step):undefined;
 
         if(type==='select'&&!this.options.some(option=>Object.is(option.value,this.defaultValue))){
             throw new TypeError(`Preference ${key} has a default value outside its options.`);
@@ -28,9 +31,9 @@ export default class Preference{
     }
 
     normalizeOptions(options=[]){
-        if(!Array.isArray(options)||!options.length) throw new TypeError('Select preferences require options.');
+        if(!is.array(options)||!options.length) throw new TypeError('Select preferences require options.');
         return options.map(option=>{
-            const normalized=typeof option==='object'&&option!==null
+            const normalized=is.object(option)&&option!==null
                 ?{label:String(option.label??option.value),value:this.normalize(option.value)}
                 :{label:String(option),value:this.normalize(option)};
             return normalized;
@@ -47,7 +50,7 @@ export default class Preference{
             case 'boolean': return value===true||value==='true'||value===1;
             case 'number': {
                 const number=Number(value);
-                if(!Number.isFinite(number)) throw new TypeError('Numeric preferences require finite values.');
+                if(!is.finite(number)) throw new TypeError('Numeric preferences require finite values.');
                 return number;
             }
             default: return String(value);

package/runtime/arcane/entities/Theme.js

@@ -1,3 +1,6 @@
+import Is from 'strong-type';
+const is=new Is(false);
+
 const HEX_COLOR=/^#([0-9a-f]{6})$/i;
 const RGB_COLOR=/^(rgb|rgba)\(\s*(\d{1,3})(?:\s*,\s*|\s+)(\d{1,3})(?:\s*,\s*|\s+)(\d{1,3})(?:\s*(?:,|\/)\s*(0|1|0?\.\d+))?\s*\)$/i;
 
@@ -74,7 +77,7 @@ export default class Theme{
     constructor(input={}){
         this.name=normalizeName(input.name||'My Arcane skin');
         this.scheme=input.scheme==='dark'?'dark':'light';
-        const source=input.tokens&&typeof input.tokens==='object'?input.tokens:{};
+        const source=input.tokens&&is.object(input.tokens)?input.tokens:{};
         const defaults=this.scheme==='dark'?arcaneDarkThemeTokens:arcaneLightThemeTokens;
         this.tokens=Object.freeze(Object.fromEntries(themeTokens.map(token=>[
             token.key,
@@ -101,7 +104,7 @@ export default class Theme{
 
     static fromJSON(value){
         if(value instanceof Theme) return value;
-        const parsed=typeof value==='string'?JSON.parse(value):value;
+        const parsed=is.string(value)?JSON.parse(value):value;
         return new Theme(parsed);
     }
 }

package/runtime/arcane/entities/User.js

@@ -1,5 +1,5 @@
 import { arcaneLogging } from 'arcane-os/logging';
-import Is from '../../node_modules/strong-type/index.js';
+import Is from 'strong-type';
 import DBLS from '../modules/DBLS.js';
 import {
     arcaneEvents,
@@ -30,14 +30,14 @@ function createDefaultDashboard(){
 }
 
 function normalizeDashboard(dashboard={}){
-    const source=dashboard&&typeof dashboard==='object'&&!Array.isArray(dashboard)
-        &&dashboard.charts&&typeof dashboard.charts==='object'&&!Array.isArray(dashboard.charts)
+    const source=dashboard&&is.object(dashboard)&&!is.array(dashboard)
+        &&dashboard.charts&&is.object(dashboard.charts)&&!is.array(dashboard.charts)
         ? dashboard.charts
         : {};
     const charts={};
 
     for(const [key,value] of Object.entries(source)){
-        if(typeof value==='boolean'){
+        if(is.boolean(value)){
             charts[key]=value;
         }
     }
@@ -646,9 +646,9 @@ class UserEntity {
     /** @param {number} v */
     set firstBootUp(v){
         if(
-            typeof v!=='number'
-            ||!Number.isFinite(v)
-            ||!Number.isSafeInteger(v)
+            !is.number(v)
+            ||!is.finite(v)
+            ||!is.safeInteger(v)
             ||v<0
         ){
             throw new Error(
@@ -757,7 +757,7 @@ class UserEntity {
 
     /** @param {{charts:Object<string,boolean>}} v */
     set dashboard(v){
-        if(!v||typeof v!=='object'||Array.isArray(v)){
+        if(!v||!is.object(v)||is.array(v)){
             throw new Error('dashboard must be an object');
         }
 
@@ -885,7 +885,7 @@ class UserEntity {
     }
 
     withFreshExplicit(operation){
-        if(typeof operation!=='function'){
+        if(!is.function(operation)){
             throw new TypeError('A fresh UserEntity operation is required.');
         }
         const result=this.#explicitUpdateQueue.then(()=>
@@ -916,13 +916,13 @@ class UserEntity {
     #withExplicitLock(operation){
         const locks=globalThis.navigator?.locks;
 
-        if(typeof locks?.request==='function'){
+        if(is.function(locks?.request)){
             return locks.request(
                 `user-entity:${this.fileName}`,
                 operation
             );
         }
-        if(typeof globalThis.window==='object'){
+        if(is.object(globalThis.window)){
             const error=new Error(
                 'This browser cannot safely coordinate profile changes across tabs.'
             );

package/runtime/arcane/entities/Weather.js

@@ -1,6 +1,9 @@
-function number(value,label,{minimum=-Infinity,maximum=Infinity}={}){const result=Number(value);if(!Number.isFinite(result)||result<minimum||result>maximum)throw new TypeError(`${label} is invalid.`);return result;}
+import Is from 'strong-type';
+const is=new Is(false);
+
+function number(value,label,{minimum=-Infinity,maximum=Infinity}={}){const result=Number(value);if(!is.finite(result)||result<minimum||result>maximum)throw new TypeError(`${label} is invalid.`);return result;}
 function text(value,label){const result=String(value??'');if(!result.trim())throw new TypeError(`${label} is required.`);return result;}
-function instant(value,label){const date=new Date(value);if(Number.isNaN(date.valueOf()))throw new TypeError(`${label} is invalid.`);return date.toISOString();}
+function instant(value,label){const date=new Date(value);if(is.NaN(date.valueOf()))throw new TypeError(`${label} is invalid.`);return date.toISOString();}
 
 export class WeatherLocation{
     constructor({id='',name,region='',country='',latitude,longitude,timezone='auto'}={}){this.id=String(id||`${latitude},${longitude}`);this.name=text(name,'Weather location name');this.region=String(region||'');this.country=String(country||'');this.latitude=number(latitude,'Latitude',{minimum:-90,maximum:90});this.longitude=number(longitude,'Longitude',{minimum:-180,maximum:180});this.timezone=String(timezone||'auto');}