arcane-os 0.5.16 → 0.5.18

package/runtime/strong-type/package.json

@@ -1,45 +1,69 @@
-{
-  "name": "strong-type",
-  "version": "1.1.0",
-  "type": "module",
-  "description": "allows easy type enforcement for all JS types objects and classes. it is also extensible and provides simple to use type checks for your own custom classes and types",
-  "main": "index.js",
-  "directories": {
-    "example": "example"
-  },
-  "engines": {
-    "node": ">=12.21.0"
-  },
-  "scripts": {
-    "test": "npm i && c8 -r lcov -r html node test/CI.js && c8 report && node ./lcov.js",
-    "start": "npm run emulate && node-http-server port=8000 verbose=true",
-    "emulate": "npm i && copyfiles -V \"./!(node_modules)/*\" \"./**!(node_modules)\"  \"./example/node_modules/strong-type/\" && copyfiles -V \"./node_modules/**/*\" \"./example/\" && copyfiles -V \"./!(node_modules)/*\" \"./**!(node_modules)\"",
-    "nodeExample": "node ./example/node/typecheck.js",
-    "coverage": "echo 'See your coverage report at http://localhost:8080' && node-http-server port=8080 root=./coverage/"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/RIAEvangelist/strong-type.git"
-  },
-  "keywords": [
-    "strong",
-    "type",
-    "validation",
-    "validate",
-    "check",
-    "checking"
-  ],
-  "author": "Brandon Nozaki Miller",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/RIAEvangelist/strong-type/issues"
-  },
-  "homepage": "https://github.com/RIAEvangelist/strong-type#readme",
-  "devDependencies": {
-    "c8": "^7.6.0",
-    "copyfiles": "*",
-    "lcov2badge": "^0.1.2",
-    "node-http-server": "^8.1.3",
-    "vanilla-test": "*"
-  }
-}
+{
+  "name": "strong-type",
+  "version": "2.0.1",
+  "type": "module",
+  "description": "Dependency-free native ESM type enforcement for JavaScript values, objects, classes, browsers, and Node.",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./index.js": "./index.js",
+    "./node": "./node.js",
+    "./node.js": "./node.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "node.js",
+    "benchmark/core.js",
+    "assets/strong-type-header.png",
+    "README.md",
+    "licence"
+  ],
+  "sideEffects": false,
+  "directories": {
+    "example": "example"
+  },
+  "engines": {
+    "node": ">=12.21.0"
+  },
+  "scripts": {
+    "benchmark": "node benchmark/core.js",
+    "benchmark:baseline": "node benchmark/core.js --baseline",
+    "benchmark:historical": "node benchmark/core.js --historical",
+    "test": "node scripts/test.js",
+    "test:unit": "node scripts/test.js unit",
+    "test:functional": "node scripts/test.js functional",
+    "test:integration": "node scripts/test.js integration",
+    "test:regression": "node scripts/test.js regression",
+    "test:legacy": "node scripts/test.js legacy",
+    "coverage": "vanilla-test coverage node",
+    "start": "node scripts/serve.js",
+    "nodeExample": "node ./example/node/typecheck.js",
+    "check": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RIAEvangelist/strong-type.git"
+  },
+  "keywords": [
+    "strong",
+    "type",
+    "validation",
+    "validate",
+    "check",
+    "checking",
+    "esm",
+    "isomorphic",
+    "browser",
+    "node"
+  ],
+  "author": "Roshi _ _",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/RIAEvangelist/strong-type/issues"
+  },
+  "homepage": "https://riaevangelist.github.io/strong-type/",
+  "devDependencies": {
+    "vanilla-test": "2.1.0"
+  }
+}

package/src/app-descriptor.mjs

@@ -1,3 +1,4 @@
+import Is from 'strong-type';
 import {isDeepStrictEqual} from 'node:util';
 import {readFile} from 'node:fs/promises';
 import path from 'node:path';
@@ -12,6 +13,8 @@ import {
     validateAppConfig as validateAppPackageConfig
 } from './packager/core.mjs';
 
+const is = new Is(false);
+
 export const APP_DESCRIPTOR_NAME='arcane-app.json';
 export const APP_DESCRIPTOR_SCHEMA_VERSION=2;
 
@@ -35,7 +38,7 @@ function fail(message){
 }
 
 function isObject(value){
-    return value!==null&&typeof value==='object'&&!Array.isArray(value);
+    return value!==null&&is.object(value)&&!is.array(value);
 }
 
 function assertOnlyKeys(value,allowed,label){
@@ -46,7 +49,7 @@ function assertOnlyKeys(value,allowed,label){
 }
 
 function safeText(value,label){
-    if(typeof value!=='string'||value!==value.trim()||!value
+    if(!is.string(value)||value!==value.trim()||!value
         ||/[<>\u0000-\u001f\u007f]/u.test(value)){
         fail(`${label} must be nonempty, trimmed presentation text.`);
     }
@@ -54,11 +57,11 @@ function safeText(value,label){
 }
 
 function uniqueSortedStrings(value,label,{pattern,required=false}={}){
-    if(!Array.isArray(value)||(required&&value.length===0)){
+    if(!is.array(value)||(required&&value.length===0)){
         fail(`${label} must be ${required?'a nonempty':'an'} array.`);
     }
     const normalized=value.map((entry,index)=>{
-        if(typeof entry!=='string'||entry!==entry.trim()||!entry
+        if(!is.string(entry)||entry!==entry.trim()||!entry
             ||(pattern&&!pattern.test(entry))){
             fail(`${label}[${index}] is invalid.`);
         }
@@ -68,7 +71,7 @@ function uniqueSortedStrings(value,label,{pattern,required=false}={}){
 }
 
 function relativePaths(value,label,{required=false}={}){
-    if(!Array.isArray(value)||(required&&value.length===0)){
+    if(!is.array(value)||(required&&value.length===0)){
         fail(`${label} must be ${required?'a nonempty':'an'} array.`);
     }
     const normalized=value.map((entry,index)=>normalizeRelativePath(entry,`${label}[${index}]`));
@@ -76,9 +79,9 @@ function relativePaths(value,label,{required=false}={}){
 }
 
 function validateOrigins(value,label){
-    if(!Array.isArray(value))fail(`${label} must be an array of origins.`);
+    if(!is.array(value))fail(`${label} must be an array of origins.`);
     const origins=value.map((origin,index)=>{
-        if(typeof origin!=='string'||!origin.trim())fail(`${label}[${index}] is invalid.`);
+        if(!is.string(origin)||!origin.trim())fail(`${label}[${index}] is invalid.`);
         return origin;
     });
     return completeValue(origins);
@@ -87,14 +90,14 @@ function validateOrigins(value,label){
 function validateLocalAIModelPolicy(value,label){
     if(value===undefined)return undefined;
     assertOnlyKeys(value,new Set(['verified_only','models']),label);
-    if(typeof value.verified_only!=='boolean'||!Array.isArray(value.models)){
+    if(!is.boolean(value.verified_only)||!is.array(value.models)){
         fail(`${label} is invalid.`);
     }
     const models=value.models.map((model,index)=>{
         const itemLabel=`${label}.models[${index}]`;
         assertOnlyKeys(model,new Set(['name','definition']),itemLabel);
-        if(typeof model.name!=='string'||!model.name
-            ||typeof model.definition!=='string'||!model.definition.endsWith('Modelfile')){
+        if(!is.string(model.name)||!model.name
+            ||!is.string(model.definition)||!model.definition.endsWith('Modelfile')){
             fail(`${itemLabel} is invalid.`);
         }
         return completeValue({name:model.name,definition:normalizeRelativePath(model.definition,`${itemLabel}.definition`)});
@@ -144,7 +147,7 @@ function validatePackage(value,appId){
 
 function validatePublisher(value){
     assertOnlyKeys(value,new Set(['id','name']),'descriptor.publisher');
-    if(typeof value.id!=='string'||!PUBLISHER_PATTERN.test(value.id)){
+    if(!is.string(value.id)||!PUBLISHER_PATTERN.test(value.id)){
         fail('descriptor.publisher.id must be a lowercase publisher identifier.');
     }
     return completeValue({id:value.id,name:safeText(value.name,'descriptor.publisher.name')});
@@ -191,7 +194,7 @@ function validateDocumentCatalog(value){
     assertOnlyKeys(value,new Set([
         'policy','release','destination','originals','manifest','expectedCount'
     ]),label);
-    if(value.policy!=='public-only'||!Number.isInteger(value.expectedCount)
+    if(value.policy!=='public-only'||!is.integer(value.expectedCount)
         ||value.expectedCount<1){
         fail(`${label} has unsupported policy or expectedCount.`);
     }
@@ -219,7 +222,7 @@ function validateNative(value,appId){
     assertOnlyKeys(value,new Set(['type','icon','order','bundledApps','documentCatalog']),'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(!Number.isInteger(value.order)||value.order<0){
+    if(!is.integer(value.order)||value.order<0){
         fail('descriptor.native.order must be a nonnegative integer.');
     }
     const bundledApps=uniqueSortedStrings(value.bundledApps,'descriptor.native.bundledApps',{
@@ -392,7 +395,7 @@ function synthesizedDescriptor(packageManifest,nativeDescriptor){
         native:{
             type:native.type??'app',
             icon:native.icon??null,
-            order:Number.isInteger(native.order)?native.order:100,
+            order:is.integer(native.order)?native.order:100,
             bundledApps:[...(native.bundledApps??[])],
             ...(native.documentCatalog?{documentCatalog:native.documentCatalog}:{})
         },

package/src/application-tests.mjs

@@ -1,14 +1,17 @@
+import Is from 'strong-type';
 import {lstat,readdir,realpath} from 'node:fs/promises';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 import {ArcaneError,ERROR_CODES,throwIfAborted} from './errors.mjs';
 import {runProcess} from './process.mjs';
 
+const is = new Is(false);
+
 const TEST_RUNNER_PATH=fileURLToPath(new URL('../bin/arcane-test.mjs',import.meta.url));
 const MANAGED_IMPORT_MAP_ENV='ARCANE_TEST_IMPORT_MAP_CONTEXT';
 
 function normalizedTestOutput(value){
-    return typeof value==='string'?value:'';
+    return is.string(value)?value:'';
 }
 
 function captureFailedTest(testFile,result,workspaceRoot){

package/src/cli/main.mjs

@@ -1,3 +1,4 @@
+import Is from 'strong-type';
 import path from 'node:path';
 import {createReporter} from '../events.mjs';
 import {executeOperation} from '../toolchain.mjs';
@@ -6,6 +7,8 @@ import {CLI_NAME,SDK_NAME,SDK_VERSION,OUTPUT_MODES} from '../constants.mjs';
 import {loadArcaneNativeProvider} from '../native-provider-loader.mjs';
 import {APP_BUNDLE_EXTENSION} from '../release-bundle.mjs';
 
+const is = new Is(false);
+
 const VALUE_OPTIONS=new Set([
     'path',
     'display-name',
@@ -169,7 +172,7 @@ function readPort(value,defaultValue){
         usage(`Invalid port: ${value}.`);
     }
     const port=Number(value);
-    if(!Number.isSafeInteger(port)||port<0||port>65535){
+    if(!is.safeInteger(port)||port<0||port>65535){
         usage(`Invalid port: ${value}.`);
     }
     return port;
@@ -181,7 +184,7 @@ function readRequestTimeout(value){
         usage(`Invalid request timeout: ${value}.`);
     }
     const timeout=Number(value);
-    if(!Number.isSafeInteger(timeout)||timeout<1||timeout>MAX_NODE_TIMER_DELAY_MS){
+    if(!is.safeInteger(timeout)||timeout<1||timeout>MAX_NODE_TIMER_DELAY_MS){
         usage(
             `Mail request timeout must be an integer from 1 through ${MAX_NODE_TIMER_DELAY_MS} `
             +'milliseconds, the Node timer range.'
@@ -253,7 +256,7 @@ function readPipedMailSecret(input,signal){
 }
 
 function readMaskedMailSecret(input,output,signal,label,stdinOption){
-    if(!input?.isTTY||typeof input.setRawMode!=='function'||typeof output?.write!=='function'){
+    if(!input?.isTTY||!is.function(input.setRawMode)||!is.function(output?.write)){
         usage(`Interactive mail credential entry requires a terminal; use ${stdinOption} for piped input.`);
     }
     return new Promise((resolve,reject)=>{
@@ -353,7 +356,7 @@ function readPipedMailReport(input,signal){
                 }catch{
                     usage('Mail report input must be one valid JSON object.');
                 }
-                if(!report||typeof report!=='object'||Array.isArray(report)){
+                if(!report||!is.object(report)||is.array(report)){
                     usage('Mail report input must be one valid JSON object.');
                 }
                 finish(resolve,report);
@@ -839,7 +842,7 @@ function serverSummary(result){
 
 async function waitForServer(result,signal,reporter){
     reporter.emit('server.ready',serverSummary(result),`Development server ready at ${result.url}`);
-    if(result.lifecycle&&typeof result.lifecycle.then==='function'){
+    if(result.lifecycle&&is.function(result.lifecycle.then)){
         const abort=()=>{
             void Promise.resolve().then(()=>result.close?.()).catch(()=>{});
         };

package/src/constants.mjs

@@ -1,8 +1,11 @@
+import Is from 'strong-type';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 import packageDocument from '../package.json' with {type:'json'};
 
-if(packageDocument.name!=='arcane-os'||typeof packageDocument.version!=='string'
+const is = new Is(false);
+
+if(packageDocument.name!=='arcane-os'||!is.string(packageDocument.version)
     ||!/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/u.test(packageDocument.version)){
     throw new Error('The Arcane SDK package identity is invalid.');
 }

package/src/dev-server.mjs

@@ -1,3 +1,4 @@
+import Is from 'strong-type';
 import {constants as FS_CONSTANTS} from 'node:fs';
 import {lstat,open,readFile,realpath} from 'node:fs/promises';
 import http from 'node:http';
@@ -9,6 +10,8 @@ import {
     readWorkspaceAssetVersion,rewriteAssetReferences
 } from './import-map.mjs';
 
+const is = new Is(false);
+
 const MIME_TYPES=new Map([
     ['.css','text/css; charset=utf-8'],
     ['.gif','image/gif'],
@@ -165,12 +168,12 @@ function sdkBrowserSourcePathAllowed(relative){
 }
 
 async function emitRuntimeSourceEvent(onEvent,event){
-    if(typeof onEvent==='function')await onEvent(event);
+    if(is.function(onEvent))await onEvent(event);
 }
 
 async function verifySdkRuntimeSourceRoot(sourceRoot,workspaceRoot,appId,{signal,onEvent}={}){
     throwIfAborted(signal);
-    if(typeof sourceRoot!=='string'||!sourceRoot.trim()){
+    if(!is.string(sourceRoot)||!sourceRoot.trim()){
         fail('sdkRuntimeSourceRoot must name an Arcane SDK directory.',
             'ARCANE_DEV_RUNTIME_SOURCE_INVALID');
     }
@@ -449,7 +452,7 @@ async function sourceRoutes(workspaceRoot,appId,{
 }
 
 async function packagedRoutes(releaseRoot){
-    if(typeof releaseRoot!=='string'||!releaseRoot.trim())fail('releaseRoot is required in packaged mode.','ARCANE_USAGE');
+    if(!is.string(releaseRoot)||!releaseRoot.trim())fail('releaseRoot is required in packaged mode.','ARCANE_USAGE');
     const requested=path.resolve(releaseRoot);
     const canonical=await canonicalRealDirectory(requested,'Packaged release root');
     return {
@@ -504,7 +507,7 @@ async function startOwnedDevServer({
     if(host!=='127.0.0.1'&&host!=='::1'){
         fail('Development server host must be a numeric loopback address (127.0.0.1 or ::1).','ARCANE_POLICY_DENIED');
     }
-    if(!Number.isInteger(port)||port<0||port>65535)fail('port must be an integer from 0 through 65535.','ARCANE_USAGE');
+    if(!is.integer(port)||port<0||port>65535)fail('port must be an integer from 0 through 65535.','ARCANE_USAGE');
     const requestedRuntimeMode=mode==='source'&&sdkRuntimeSourceRoot!==undefined
         ?'sdk-source'
         :null;
@@ -624,7 +627,7 @@ async function startOwnedDevServer({
     });
     await listen(server,{host,port,signal});
     const address=server.address();
-    if(!address||typeof address==='string'){
+    if(!address||is.string(address)){
         server.close();
         fail('Development server did not expose a TCP address.');
     }

package/src/doctor.mjs

@@ -1,3 +1,4 @@
+import Is from 'strong-type';
 import path from 'node:path';
 import {access,lstat,readdir,realpath} from 'node:fs/promises';
 import {loadRuntimeRelease} from './runtime.mjs';
@@ -7,6 +8,8 @@ import {runProcess} from './process.mjs';
 import {ARCANE_PROTOCOL,SDK_VERSION} from './constants.mjs';
 import {ERROR_CODES,ArcaneError,throwIfAborted} from './errors.mjs';
 
+const is = new Is(false);
+
 const WINDOWS_SERVICE_NAME='ArcaneOllama';
 const WINDOWS_SERVICE_HOST='C:\\Program Files\\Ollama\\ArcaneOllamaService.exe';
 
@@ -47,8 +50,8 @@ function parseProbe(text){
     }catch{
         return null;
     }
-    if(!value||typeof value!=='object'||Array.isArray(value)
-        ||Object.getPrototypeOf(value)!==Object.prototype||typeof value.ready!=='boolean'){
+    if(!value||!is.object(value)||is.array(value)
+        ||Object.getPrototypeOf(value)!==Object.prototype||!is.boolean(value.ready)){
         return null;
     }
     return {...value};

package/src/dom-event-instrumentation.mjs

@@ -1,3 +1,7 @@
+import Is from 'strong-type';
+
+const is = new Is(false);
+
 export const DOM_INTERACTION_EVENT='arcane.dom.interaction';
 export const DOM_MUTATION_EVENT='arcane.dom.mutation';
 export const DOM_OBSERVATION_STARTED_EVENT='arcane.dom.observation.started';
@@ -25,13 +29,13 @@ function capturedString(value){
 }
 
 function cssEscape(value){
-    if(typeof globalThis.CSS?.escape==='function')return globalThis.CSS.escape(value);
+    if(is.function(globalThis.CSS?.escape))return globalThis.CSS.escape(value);
     return String(value).replaceAll(/[^a-zA-Z0-9_-]/gu,character=>`\\${character.codePointAt(0).toString(16)} `);
 }
 
 function readAttribute(target,name){
     try{
-        return typeof target?.getAttribute==='function'?target.getAttribute(name):null;
+        return is.function(target?.getAttribute)?target.getAttribute(name):null;
     }catch{
         return null;
     }
@@ -67,7 +71,7 @@ function selectorSegment(target){
 }
 
 export function domSelector(target,root){
-    if(!target||typeof target!=='object')return null;
+    if(!target||!is.object(target))return null;
     if(target.nodeType===9)return ':document';
     if(target.nodeType===11)return ':shadow-root';
     if(target.nodeType===3)return domSelector(target.parentElement??target.parentNode,root);
@@ -111,7 +115,7 @@ export function domSelector(target,root){
 }
 
 export function describeDOMTarget(target,root){
-    if(!target||typeof target!=='object')return null;
+    if(!target||!is.object(target))return null;
     if(target.nodeType===9){
         return {kind:'document',selector:':document'};
     }
@@ -145,7 +149,7 @@ export function describeDOMTarget(target,root){
 }
 
 function targetValue(target){
-    if(!target||typeof target!=='object')return undefined;
+    if(!target||!is.object(target))return undefined;
     const type=String(target.type??'').toLowerCase();
     if(type==='checkbox'||type==='radio')return Boolean(target.checked);
     if(type==='file'){
@@ -156,24 +160,24 @@ function targetValue(target){
 }
 
 function safeEventDetail(value){
-    if(typeof value==='string')return capturedString(value);
-    if(value===null||typeof value==='number'||typeof value==='boolean')return value;
+    if(is.string(value))return capturedString(value);
+    if(value===null||is.number(value)||is.boolean(value))return value;
     return value;
 }
 
 function interactionRecord(event,root){
-    const path=typeof event?.composedPath==='function'?event.composedPath():[event?.target];
-    const target=path.find(item=>item&&typeof item==='object')??event?.target??null;
+    const path=is.function(event?.composedPath)?event.composedPath():[event?.target];
+    const target=path.find(item=>item&&is.object(item))??event?.target??null;
     const eventType=String(event?.type??'');
     const details={};
     const fields=new Set([
         ...EVENT_FIELDS,
-        ...Reflect.ownKeys(event??{}).filter(field=>typeof field==='string')
+        ...Reflect.ownKeys(event??{}).filter(field=>is.string(field))
     ]);
     for(const field of fields){
         let value;
         try{value=event?.[field];}catch{continue;}
-        if(value!==undefined&&typeof value!=='function'){
+        if(value!==undefined&&!is.function(value)){
             details[field]=safeEventDetail(value);
         }
     }
@@ -254,7 +258,7 @@ function collectOpenShadowRoots(root){
     const roots=[];
     const candidates=[];
     try{
-        if(typeof root?.querySelectorAll==='function')candidates.push(...root.querySelectorAll('*'));
+        if(is.function(root?.querySelectorAll))candidates.push(...root.querySelectorAll('*'));
     }catch{}
     for(const candidate of candidates){
         if(candidate?.shadowRoot)roots.push(candidate.shadowRoot,...collectOpenShadowRoots(candidate.shadowRoot));
@@ -270,18 +274,18 @@ export function createDOMInstrumentation({
     captureMutations=true,
     observeOpenShadowRoots=true
 }={}){
-    if(!eventManager||typeof eventManager.emit!=='function'){
+    if(!eventManager||!is.function(eventManager.emit)){
         throw new TypeError('DOM instrumentation requires an event manager.');
     }
-    if(!root||typeof root.addEventListener!=='function'||typeof root.removeEventListener!=='function'){
+    if(!root||!is.function(root.addEventListener)||!is.function(root.removeEventListener)){
         throw new TypeError('DOM instrumentation requires an EventTarget-compatible root.');
     }
-    if(!Array.isArray(eventTypes)||eventTypes.some(type=>typeof type!=='string'||!type)){
+    if(!is.array(eventTypes)||eventTypes.some(type=>!is.string(type)||!type)){
         throw new TypeError('DOM event types must be non-empty strings.');
     }
     eventTypes=[...new Set(eventTypes)];
     for(const [name,value] of Object.entries({captureMutations,observeOpenShadowRoots})){
-        if(typeof value!=='boolean')throw new TypeError(`${name} must be boolean.`);
+        if(!is.boolean(value))throw new TypeError(`${name} must be boolean.`);
     }
     const observedRoots=new Set();
     const listenerRegistrations=new Map();
@@ -351,7 +355,7 @@ export function createDOMInstrumentation({
 
     const publish=(type,payload,metadata)=>{
         const before=Number(eventManager.eventCount??0);
-        if(typeof eventManager.instrument==='function'){
+        if(is.function(eventManager.instrument)){
             eventManager.instrument(type,payload,{source:'dom',...metadata});
         }else{
             eventManager.emit(type,payload);
@@ -365,7 +369,7 @@ export function createDOMInstrumentation({
     const interaction=(event,observedRoot)=>{
         let path=[];
         try{
-            if(typeof event?.composedPath==='function')path=event.composedPath();
+            if(is.function(event?.composedPath))path=event.composedPath();
         }catch{}
         const outermostObservedRoot=path.reduce(
             (selected,item)=>observedRoots.has(item)?item:selected,
@@ -446,7 +450,7 @@ export function createDOMInstrumentation({
         if(active)return api;
         try{
             if(captureMutations){
-                if(typeof MutationObserverImpl!=='function'){
+                if(!is.function(MutationObserverImpl)){
                     throw new TypeError('MutationObserver is required when DOM mutation capture is enabled.');
                 }
                 observer=new MutationObserverImpl(mutations);
@@ -473,7 +477,7 @@ export function createDOMInstrumentation({
     }
 
     function stop({emitLifecycle=true}={}){
-        if(typeof emitLifecycle!=='boolean')throw new TypeError('emitLifecycle must be boolean.');
+        if(!is.boolean(emitLifecycle))throw new TypeError('emitLifecycle must be boolean.');
         if(!active)return api;
         const shouldEmitLifecycle=emitLifecycle&&lifecycleStarted;
         if(!emitLifecycle)lifecycleStarted=false;

package/src/errors.mjs

@@ -1,3 +1,7 @@
+import Is from 'strong-type';
+
+const is = new Is(false);
+
 export const ERROR_CODES={
     usage:'ARCANE_USAGE',
     workspaceInvalid:'ARCANE_WORKSPACE_INVALID',
@@ -17,7 +21,7 @@ export class ArcaneError extends Error{
         this.name='ArcaneError';
         this.code=code||ERROR_CODES.operationFailed;
         this.details=details;
-        this.exitCode=Number.isInteger(exitCode)?exitCode:1;
+        this.exitCode=is.integer(exitCode)?exitCode:1;
     }
 }
 
@@ -49,7 +53,7 @@ export function normalizeError(error,fallbackCode=ERROR_CODES.operationFailed){
         );
     }
 
-    const reportedCode=typeof error?.code==='string'&&/^ARCANE_[A-Z0-9_]+$/u.test(error.code)
+    const reportedCode=is.string(error?.code)&&/^ARCANE_[A-Z0-9_]+$/u.test(error.code)
         ?error.code
         :fallbackCode;
 
@@ -59,7 +63,7 @@ export function normalizeError(error,fallbackCode=ERROR_CODES.operationFailed){
         {
             cause:error,
             details:error?.details,
-            exitCode:Number.isInteger(error?.exitCode)?error.exitCode:undefined
+            exitCode:is.integer(error?.exitCode)?error.exitCode:undefined
         }
     );
 }