arcane-os 0.5.16 → 0.5.18

package/node_modules/event-pubsub/node_modules/strong-type/licence

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Brandon Nozaki Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/event-pubsub/node_modules/strong-type/node.js

@@ -0,0 +1,125 @@
+import Is from './index.js';
+import * as util from 'node:util';
+import * as stream from 'node:stream';
+import * as events from 'node:events';
+import * as crypto from 'node:crypto';
+
+let timeoutConstructor;
+let immediateConstructor;
+
+const instanceOf=function(value,constructor){
+    if(typeof constructor !== 'function'){
+        return false;
+    }
+
+    try{
+        return value instanceof constructor;
+    }catch(err){
+        return false;
+    }
+};
+
+const timerConstructor=function(type){
+    if(type === 'timeout' && !timeoutConstructor){
+        const timeout=setTimeout(()=>{},0);
+        clearTimeout(timeout);
+        timeoutConstructor=timeout.constructor;
+    }
+
+    if(type === 'immediate' && !immediateConstructor && typeof setImmediate === 'function'){
+        const immediate=setImmediate(()=>{});
+        clearImmediate(immediate);
+        immediateConstructor=immediate.constructor;
+    }
+
+    return type === 'timeout' ? timeoutConstructor : immediateConstructor;
+};
+
+class IsNode extends Is{
+    utilTypeCheck(value,method,typeName){
+        const check=util.types && util.types[method];
+        let pass=false;
+        try{
+            pass=typeof check === 'function' && check(value);
+        }catch(err){
+            pass=false;
+        }
+        return this.check(value,pass,typeName);
+    }
+
+    buffer(value){
+        return this.check(value,Buffer.isBuffer(value),'Buffer');
+    }
+
+    nodeStream(value){
+        return this.check(value,instanceOf(value,stream.Stream),'Node Stream');
+    }
+
+    nodeReadable(value){
+        return this.check(value,instanceOf(value,stream.Readable),'Node Readable');
+    }
+
+    nodeWritable(value){
+        return this.check(value,instanceOf(value,stream.Writable),'Node Writable');
+    }
+
+    nodeDuplex(value){
+        return this.check(value,instanceOf(value,stream.Duplex),'Node Duplex');
+    }
+
+    nodeTransform(value){
+        return this.check(value,instanceOf(value,stream.Transform),'Node Transform');
+    }
+
+    nodePassThrough(value){
+        return this.check(value,instanceOf(value,stream.PassThrough),'Node PassThrough');
+    }
+
+    eventEmitter(value){
+        return this.check(value,instanceOf(value,events.EventEmitter),'EventEmitter');
+    }
+
+    timeout(value){
+        const constructor=timerConstructor('timeout');
+        return this.check(value,instanceOf(value,constructor),'Timeout');
+    }
+
+    immediate(value){
+        const constructor=timerConstructor('immediate');
+        return this.check(value,instanceOf(value,constructor),'Immediate');
+    }
+
+    keyObject(value){
+        return this.check(value,instanceOf(value,crypto.KeyObject),'KeyObject');
+    }
+
+    x509Certificate(value){
+        return this.check(value,instanceOf(value,crypto.X509Certificate),'X509Certificate');
+    }
+
+    proxy(value){
+        return this.utilTypeCheck(value,'isProxy','Proxy');
+    }
+
+    moduleNamespaceObject(value){
+        return this.utilTypeCheck(value,'isModuleNamespaceObject','module namespace object');
+    }
+
+    external(value){
+        return this.utilTypeCheck(value,'isExternal','native external value');
+    }
+
+    nativeError(value){
+        return this.utilTypeCheck(value,'isNativeError','native Error');
+    }
+
+    mapIterator(value){
+        return this.utilTypeCheck(value,'isMapIterator','Map iterator');
+    }
+
+    setIterator(value){
+        return this.utilTypeCheck(value,'isSetIterator','Set iterator');
+    }
+}
+
+export {IsNode as default,IsNode};

package/node_modules/event-pubsub/node_modules/strong-type/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "strong-type",
+  "version": "2.0.0",
+  "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",
+    "assets/strong-type-header.png",
+    "README.md",
+    "licence"
+  ],
+  "sideEffects": false,
+  "directories": {
+    "example": "example"
+  },
+  "engines": {
+    "node": ">=12.21.0"
+  },
+  "scripts": {
+    "test": "node scripts/test.js",
+    "test:core": "node scripts/test.js core",
+    "test:node": "node scripts/test.js node",
+    "test:docs": "node scripts/test.js docs",
+    "test:legacy": "node scripts/test.js legacy",
+    "coverage": "node --test --experimental-test-coverage --test-coverage-include=index.js --test-coverage-include=node.js --test-coverage-lines=95 --test-coverage-branches=90 --test-coverage-functions=95 test/CI.js test/node.js test/docs.js",
+    "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/"
+}

package/node_modules/strong-type/README.md

@@ -4,7 +4,7 @@
 
 [Overview](https://riaevangelist.github.io/strong-type/) · [Validator reference](https://riaevangelist.github.io/strong-type/reference.html) · [Tests & coverage](https://riaevangelist.github.io/strong-type/testing.html) · [Playground](https://riaevangelist.github.io/strong-type/playground.html)
 
-[![npm version](https://img.shields.io/npm/v/strong-type.svg)](https://www.npmjs.com/package/strong-type) [![Node support](https://img.shields.io/node/v/strong-type.svg)](https://www.npmjs.com/package/strong-type) [![CI](https://github.com/RIAEvangelist/strong-type/actions/workflows/ci.yml/badge.svg)](https://github.com/RIAEvangelist/strong-type/actions/workflows/ci.yml) [![license](https://img.shields.io/github/license/RIAEvangelist/strong-type.svg)](./licence) [![dependencies](https://img.shields.io/badge/dependencies-0-70efa8)](./package.json)
+[![npm version](https://img.shields.io/npm/v/strong-type.svg)](https://www.npmjs.com/package/strong-type) [![Node support](https://img.shields.io/node/v/strong-type.svg)](https://www.npmjs.com/package/strong-type) [![CI](https://github.com/RIAEvangelist/strong-type/actions/workflows/ci.yml/badge.svg)](https://github.com/RIAEvangelist/strong-type/actions/workflows/ci.yml) [![license](https://img.shields.io/github/license/RIAEvangelist/strong-type.svg)](./licence) [![runtime dependencies](https://img.shields.io/badge/runtime_dependencies-0-70efa8)](./package.json)
 
 Native type enforcement for JavaScript. `strong-type` runs as the same untransformed ES module in browsers and Node. Strict checks throw a useful `TypeError`; non-strict checks return a boolean.
 
@@ -14,7 +14,7 @@ Native type enforcement for JavaScript. `strong-type` runs as the same untransfo
 |---|---|---|
 | Module format | Native ESM | The checked-in JavaScript is what the runtime executes. |
 | Runtime dependencies | None | No third-party production packages. |
-| Development dependencies | None | Tests and the local docs server use Node built-ins. |
+| Development dependencies | `vanilla-test` 2.1.0 | The exact test-runner pin is development-only; runtime installs remain dependency-free. |
 | Bundler | Not required | Browser and Node imports work directly. |
 | Transpiler | Not required | No generated CommonJS or compatibility copy. |
 | Default entry point | Isomorphic | `index.js` contains no `node:*` imports. |
@@ -361,45 +361,63 @@ Version 2 removes several coercive edge cases while retaining the original metho
 | `union(value,'toString')` | Could call an inherited method | Rejected |
 | Subclass validators in `union` | Lost by constructing base `Is` | Preserved |
 
+## Core benchmarks
+
+The dependency-free benchmark runner measures representative successful and rejecting core validator paths with rotating fixtures, calibrated samples, result verification, dedicated per-case loops, median timings, and median absolute deviation.
+
+```sh
+npm run benchmark
+npm run benchmark:baseline
+npm run benchmark:historical
+```
+
+The default command measures the current checkout. `benchmark:baseline` compares it with the pre-optimization `700059a` implementation, while `benchmark:historical` provides a same-realm throughput reference against 1.1.0. Both comparison commands require a Git checkout containing the referenced commits. Absolute timings are harness-specific JIT throughput references, and historical results are informational because 1.1.0 did not provide the current cross-realm and spoof-resistance guarantees.
+
 ## Tests and coverage
 
-The main suite runs with Node's built-in `node:test`. Node 12.21 uses the same registered cases through the small compatibility adapter because `node:test` did not exist in that release. There is no third-party test runner.
+One canonical registry runs through `vanilla-test` 2.1.0 on Node 22.12 or newer, with every expectation assigned once to Unit, Functional, Integration, or Regression. CI exercises both the minimum VanillaTest runtime and Node 24. Older supported Node releases run that same registry through the small dependency-free compatibility adapter, so the development runner does not change the package's runtime support or add production dependencies.
 
 | Test suite | Result on Node 24.18.0 | Covers |
 |---|---:|---|
-| Core validators | 533 passed · 13 guarded skips | 183 isomorphic validators, strict/non-strict behavior, hostile values, unions, and native brands |
-| Node adapter | 54 passed | 18 Node validators, cross-realm behavior, package entry points, streams, timers, crypto, and proxies |
-| Documentation | 10 passed | Complete method tables, local assets, zero dependencies, package paths, and bundle-free playground wiring |
-| **Total** | **597 passed · 0 failed · 13 skipped** | Runtime and documentation contract |
+| Unit | 586 passed · 13 guarded skips | Atomic validator contracts across all 201 core and Node validators, including guarded capabilities |
+| Functional | 15 passed | Strict and non-strict modes, unions, custom validators, and Node adapter inheritance |
+| Integration | 554 passed | Reference and README completeness, site links, package exports, coverage configuration, and CI wiring |
+| Regression | 23 passed | Coercion fixes, cross-realm brands, spoof resistance, revoked proxies, and cleanup resilience |
+| **Total** | **1,178 passed · 0 failed · 13 skipped** | Four exclusive suites from one non-duplicative registry |
 
 A guarded skip means the runtime does not expose that host API. It is a capability result, not an ignored failure.
 
-Coverage uses Node 24's built-in V8 reporter and includes only the two shipped runtime sources.
+Coverage uses VanillaTest's native Node V8 collector and includes only the two shipped runtime sources. Its executable-range and block-range metrics come directly from V8 and are not interchangeable with parser-derived statement or branch percentages.
 
-| Source | Lines | Branches | Functions |
-|---|---:|---:|---:|
-| `index.js` | 95.74% · 1102/1151 | 91.37% · 286/313 | 99.57% · 229/230 |
-| `node.js` | 96.80% · 121/125 | 93.75% · 30/32 | 91.30% · 21/23 |
-| **Total** | **95.85% · 1223/1276** | **91.59% · 316/345** | **98.81% · 250/253** |
+| Source | Executable ranges | Block ranges | Function ranges | Executable lines |
+|---|---:|---:|---:|---:|
+| `index.js` | 89.31% · 301/337 | 68.46% · 76/111 | 99.55% · 225/226 | 90.28% · 920/1019 |
+| `node.js` | 88.23% · 30/34 | 80.00% · 8/10 | 91.66% · 22/24 | 91.91% · 91/99 |
+| **Total** | **89.21% · 331/371** | **69.42% · 84/121** | **98.80% · 247/250** | **90.42% · 1011/1118** |
 
-| Metric | Current | CI floor |
+| Per-file gate | Lowest current file | Required |
 |---|---:|---:|
-| Lines | 95.85% | 95% |
-| Branches | 91.59% | 90% |
-| Functions | 98.81% | 95% |
+| Executable ranges | 88.23% | 85% |
+| Block ranges | 68.46% | 65% |
+| Function ranges | 91.66% | 90% |
+| Executable lines | 90.28% | 90% |
 
-Node's native reporter does not publish a statement metric. Test and documentation files are excluded from the percentages. See the [full test, coverage, and CI explanation](https://riaevangelist.github.io/strong-type/testing.html).
+Test and documentation files are excluded from the percentages. See the [full test, coverage, and CI explanation](https://riaevangelist.github.io/strong-type/testing.html).
 
 ## Commands
 
 | Command | What it does | Third-party tooling |
 |---|---|---|
-| `npm test` | Runs core, Node adapter, and documentation checks through `node:test` | None |
-| `npm run test:core` | Runs portable validator regression tests through `node:test` | None |
-| `npm run test:node` | Runs Node adapter and cross-realm tests through `node:test` | None |
-| `npm run test:docs` | Checks reference completeness and site integrity through `node:test` | None |
-| `npm run test:legacy` | Runs the same registered cases on Node 12.21 | None |
-| `npm run coverage` | Runs native V8 coverage and enforces the 95/90/95 release floors | None |
+| `npm run benchmark` | Measures current core validator throughput with verified results and dispersion | None |
+| `npm run benchmark:baseline` | Compares current core throughput with pre-optimization commit `700059a` | Git |
+| `npm run benchmark:historical` | Compares overlapping same-realm paths with 1.1.0 commit `3229b47` | Git |
+| `npm test` | Runs Unit, Functional, Integration, and Regression through one registry | `vanilla-test` 2.1.0 |
+| `npm run test:unit` | Runs atomic core and Node validator contracts | `vanilla-test` 2.1.0 |
+| `npm run test:functional` | Runs public mode, union, and adapter workflows | `vanilla-test` 2.1.0 |
+| `npm run test:integration` | Runs documentation, package, site, and tooling boundaries | `vanilla-test` 2.1.0 |
+| `npm run test:regression` | Runs corrected edge cases and hostile-value protections | `vanilla-test` 2.1.0 |
+| `npm run test:legacy` | Runs the same registered cases through the compatibility adapter | None |
+| `npm run coverage` | Runs the canonical registry through VanillaTest's native Node V8 coverage collector | `vanilla-test` 2.1.0 |
 | `npm start` | Serves the docs and playground at `http://localhost:8000/` | None |
 | `npm run nodeExample` | Runs the Node example | None |
 

package/node_modules/strong-type/benchmark/core.js

@@ -0,0 +1,324 @@
+import {execFileSync} from 'node:child_process';
+import Is from '../index.js';
+
+const targetSampleMs=100;
+const sampleCount=7;
+const minimumIterations=1_000;
+const maximumIterations=50_000_000;
+const fixtureCount=64;
+const fixtureMask=fixtureCount-1;
+const historical=process.argv.includes('--historical');
+const baseline=process.argv.includes('--baseline');
+const historicalCommit='3229b47';
+const baselineCommit='700059a';
+let sink=0;
+let compareConversions=0;
+let runnerSequence=0;
+
+const median=function(values){
+    const sorted=values.slice().sort((left,right)=>left-right);
+    return sorted[Math.floor(sorted.length/2)];
+};
+
+const medianAbsoluteDeviation=function(values,center){
+    return median(values.map(value=>Math.abs(value-center)));
+};
+
+const runnerFor=function(current){
+    // A separately compiled loop keeps V8 feedback local to one case and implementation.
+    const name=`strongTypeBenchmark${runnerSequence++}`;
+    const create=Function('check','expected','hrtime',`
+        return function ${name}(iterations){
+            let matches=0;
+            const start=hrtime();
+            for(let index=0;index<iterations;index++){
+                matches+=check(index) === expected ? 1 : 0;
+            }
+            return [matches,Number(hrtime()-start)];
+        };
+    `);
+    return create(current.check,current.expected,process.hrtime.bigint);
+};
+
+const elapsed=function(current,iterations){
+    const [matches,nanoseconds]=current.run(iterations);
+    if(matches !== iterations){
+        throw new Error(`${current.name} returned an unexpected result after ${matches.toLocaleString('en-US')} of ${iterations.toLocaleString('en-US')} iterations`);
+    }
+    sink=(sink+matches+iterations)|0;
+    return nanoseconds/1e6;
+};
+
+const calibrate=function(current){
+    let iterations=20_000;
+    let duration=elapsed(current,iterations);
+    let warmupDuration=duration;
+    while((duration < targetSampleMs/4 || warmupDuration < 50) && iterations < maximumIterations){
+        const scale=Math.max(2,Math.min(10,Math.ceil((targetSampleMs/Math.max(duration,0.01))/2)));
+        iterations=Math.min(maximumIterations,iterations*scale);
+        duration=elapsed(current,iterations);
+        warmupDuration+=duration;
+    }
+    const projected=Math.round(iterations*(targetSampleMs/Math.max(duration,0.01)));
+    return Math.max(minimumIterations,Math.min(maximumIterations,projected));
+};
+
+const summarize=function(name,iterations,samples){
+    const duration=median(samples);
+    const deviation=medianAbsoluteDeviation(samples,duration);
+    const nanoseconds=duration*1e6/iterations;
+    return {
+        name,
+        iterations,
+        nanoseconds,
+        operationsPerSecond:1e9/nanoseconds,
+        deviationPercent:duration ? deviation/duration*100 : 0
+    };
+};
+
+const benchmark=function(current){
+    const iterations=calibrate(current);
+    const samples=[];
+    for(let sample=0;sample<sampleCount;sample++){
+        samples.push(elapsed(current,iterations));
+    }
+    return summarize(current.name,iterations,samples);
+};
+
+const benchmarkPair=function(current,baseline,baselineFirst){
+    let currentIterations;
+    let baselineIterations;
+    if(baselineFirst){
+        baselineIterations=calibrate(baseline);
+        currentIterations=calibrate(current);
+    }else{
+        currentIterations=calibrate(current);
+        baselineIterations=calibrate(baseline);
+    }
+    const currentSamples=[];
+    const baselineSamples=[];
+    for(let sample=0;sample<sampleCount;sample++){
+        const runBaselineFirst=sample%2 === 0 ? baselineFirst : !baselineFirst;
+        if(runBaselineFirst){
+            baselineSamples.push(elapsed(baseline,baselineIterations));
+            currentSamples.push(elapsed(current,currentIterations));
+        }else{
+            currentSamples.push(elapsed(current,currentIterations));
+            baselineSamples.push(elapsed(baseline,baselineIterations));
+        }
+    }
+    return {
+        current:summarize(current.name,currentIterations,currentSamples),
+        baseline:summarize(baseline.name,baselineIterations,baselineSamples)
+    };
+};
+
+const fixtures=function(create){
+    return Array.from({length:fixtureCount},(_,index)=>create(index));
+};
+
+const numbers=fixtures(index=>index+0.25);
+const definedValues=fixtures(index=>index%2 ? index : null);
+const plainObjects=fixtures(index=>({index}));
+const arrays=fixtures(index=>[index]);
+const nullPrototypeObjects=fixtures(index=>Object.assign(Object.create(null),{index}));
+const dates=fixtures(index=>new Date(1_700_000_000_000+index));
+const maps=fixtures(index=>new Map([['index',index]]));
+const sets=fixtures(index=>new Set([index]));
+const regularExpressions=fixtures(index=>new RegExp(String(index),'u'));
+const arrayBuffers=fixtures(()=>new ArrayBuffer(8));
+const sharedArrayBuffers=typeof SharedArrayBuffer === 'function' ? fixtures(()=>new SharedArrayBuffer(8)) : [];
+const dataViews=arrayBuffers.map(buffer=>new DataView(buffer));
+const uint8Arrays=fixtures(index=>new Uint8Array([index]));
+const boxedValues=fixtures(index=>{
+    const type=index%5;
+    if(type === 0) return Object(Boolean(index%2));
+    if(type === 1) return Object(index);
+    if(type === 2) return Object(BigInt(index));
+    if(type === 3) return Object(String(index));
+    return Object(Symbol(String(index)));
+});
+const comparableValues=fixtures(()=>Object.freeze({
+    toString(){
+        compareConversions++;
+        return 'comparable';
+    }
+}));
+const baselineComparableValues=fixtures(()=>Object.freeze({
+    toString(){
+        return 'comparable';
+    }
+}));
+
+const makeCase=function(name,expected,check){
+    const current={name,expected,check};
+    current.run=runnerFor(current);
+    return current;
+};
+
+const currentCases=function(Class){
+    const is=new Class;
+    const weakIs=new Class(false);
+    const comparisonValues=Class === Is ? comparableValues : baselineComparableValues;
+    const cases=[
+        makeCase('number/pass',true,index=>weakIs.number(numbers[index&fixtureMask])),
+        makeCase('number/fail',false,index=>weakIs.number(plainObjects[index&fixtureMask])),
+        makeCase('compare/pass',true,index=>weakIs.compare(comparisonValues[index&fixtureMask],comparisonValues[index&fixtureMask])),
+        makeCase('array/pass',true,index=>weakIs.array(arrays[index&fixtureMask])),
+        makeCase('array/fail',false,index=>weakIs.array(plainObjects[index&fixtureMask])),
+        makeCase('nullPrototypeObject/pass',true,index=>weakIs.nullPrototypeObject(nullPrototypeObjects[index&fixtureMask])),
+        makeCase('nullPrototypeObject/fail',false,index=>weakIs.nullPrototypeObject(plainObjects[index&fixtureMask])),
+        makeCase('date/pass',true,index=>weakIs.date(dates[index&fixtureMask])),
+        makeCase('date/fail',false,index=>weakIs.date(plainObjects[index&fixtureMask])),
+        makeCase('validDate/pass',true,index=>weakIs.validDate(dates[index&fixtureMask])),
+        makeCase('map/pass',true,index=>weakIs.map(maps[index&fixtureMask])),
+        makeCase('map/fail',false,index=>weakIs.map(plainObjects[index&fixtureMask])),
+        makeCase('arrayBufferView/pass',true,index=>weakIs.arrayBufferView(uint8Arrays[index&fixtureMask])),
+        makeCase('typedArray/pass',true,index=>weakIs.typedArray(uint8Arrays[index&fixtureMask])),
+        makeCase('uint8Array/pass',true,index=>weakIs.uint8Array(uint8Arrays[index&fixtureMask])),
+        makeCase('uint8Array/reject-data-view',false,index=>weakIs.uint8Array(dataViews[index&fixtureMask])),
+        makeCase('boxedPrimitive/pass',true,index=>weakIs.boxedPrimitive(boxedValues[index&fixtureMask])),
+        makeCase('union/first',true,index=>is.union(numbers[index&fixtureMask],'number|string|boolean')),
+        makeCase('union/second',true,index=>is.union(String(index&fixtureMask),'number|string|boolean')),
+        makeCase('union/miss',false,index=>weakIs.union(plainObjects[index&fixtureMask],'number|string|boolean'))
+    ];
+
+    if(sharedArrayBuffers.length){
+        cases.push(makeCase('anyArrayBuffer/pass-shared',true,index=>weakIs.anyArrayBuffer(sharedArrayBuffers[index&fixtureMask])));
+    }
+
+    if(typeof Intl.DateTimeFormat === 'function'){
+        const formats=fixtures(index=>new Intl.DateTimeFormat(index%2 ? 'en' : 'fr'));
+        cases.push(makeCase('intlDateTimeFormat/pass',true,index=>weakIs.intlDateTimeFormat(formats[index&fixtureMask])));
+    }
+
+    if(typeof Intl.Segmenter === 'function'){
+        const segments=fixtures(index=>new Intl.Segmenter(index%2 ? 'en' : 'fr').segment(`strong type ${index}`));
+        cases.push(makeCase('intlSegments/pass',true,index=>weakIs.intlSegments(segments[index&fixtureMask])));
+    }
+
+    const resizableArrayBuffers=fixtures(()=>new ArrayBuffer(8,{maxByteLength:16}));
+    if(resizableArrayBuffers[0].resizable === true){
+        cases.push(makeCase('resizableArrayBuffer/pass',true,index=>weakIs.resizableArrayBuffer(resizableArrayBuffers[index&fixtureMask])));
+    }
+    return cases;
+};
+
+const comparableCases=function(Class){
+    const is=new Class;
+    const weakIs=new Class(false);
+    return [
+        makeCase('defined/pass',true,index=>weakIs.defined(definedValues[index&fixtureMask])),
+        makeCase('number/pass',true,index=>weakIs.number(numbers[index&fixtureMask])),
+        makeCase('array/pass',true,index=>weakIs.array(arrays[index&fixtureMask])),
+        makeCase('date/pass',true,index=>weakIs.date(dates[index&fixtureMask])),
+        makeCase('map/pass',true,index=>weakIs.map(maps[index&fixtureMask])),
+        makeCase('set/pass',true,index=>weakIs.set(sets[index&fixtureMask])),
+        makeCase('regExp/pass',true,index=>weakIs.regExp(regularExpressions[index&fixtureMask])),
+        makeCase('uint8Array/pass',true,index=>weakIs.uint8Array(uint8Arrays[index&fixtureMask])),
+        makeCase('arrayBuffer/pass',true,index=>weakIs.arrayBuffer(arrayBuffers[index&fixtureMask])),
+        makeCase('dataView/pass',true,index=>weakIs.dataView(dataViews[index&fixtureMask])),
+        makeCase('union/first',true,index=>is.union(numbers[index&fixtureMask],'number|string')),
+        makeCase('union/second',true,index=>is.union(String(index&fixtureMask),'number|string'))
+    ];
+};
+
+const git=function(args){
+    try{
+        return execFileSync('git',args,{encoding:'utf8',stdio:['ignore','pipe','ignore'],windowsHide:true}).trim();
+    }catch(err){
+        return '';
+    }
+};
+
+const classAtCommit=async function(targetCommit){
+    let source;
+    try{
+        source=execFileSync('git',['show',`${targetCommit}:index.js`],{encoding:'utf8',windowsHide:true});
+    }catch(err){
+        throw new Error(`unable to load benchmark source from ${targetCommit}`);
+    }
+    const module=await import(`data:text/javascript;base64,${Buffer.from(source).toString('base64')}#${targetCommit}`);
+    return module.default;
+};
+
+const commit=git(['rev-parse','--short','HEAD']) || 'unavailable';
+const revisionState=commit === 'unavailable' ? 'Git unavailable' : git(['status','--porcelain','--untracked-files=no']) ? 'dirty' : 'clean';
+
+console.log(`Runtime: Node ${process.version} | V8 ${process.versions.v8} | ${process.platform} ${process.arch}`);
+console.log(`Revision: ${commit} (${revisionState})`);
+console.log(`Method: ${targetSampleMs} ms target | ${sampleCount} samples | dedicated per-case loops | median and median absolute deviation`);
+console.log('Note: ns/op is harness-specific JIT throughput, not end-to-end application latency.');
+
+const diagnostics=[
+    ['number fail/pass','number/fail','number/pass'],
+    ['array fail/pass','array/fail','array/pass'],
+    ['null-prototype fail/pass','nullPrototypeObject/fail','nullPrototypeObject/pass'],
+    ['validDate/date','validDate/pass','date/pass'],
+    ['uint8Array/arrayBufferView','uint8Array/pass','arrayBufferView/pass'],
+    ['union second/first','union/second','union/first'],
+    ['union miss/first','union/miss','union/first']
+];
+
+const printCurrentResults=function(results){
+    const nameWidth=Math.max(...results.map(result=>result.name.length));
+    console.log(`\n${'case'.padEnd(nameWidth)}  ${'ns/op'.padStart(12)}  ${'ops/sec'.padStart(14)}  ${'MAD'.padStart(8)}  ${'iterations'.padStart(12)}`);
+    for(const result of results){
+        console.log(`${result.name.padEnd(nameWidth)}  ${result.nanoseconds.toFixed(2).padStart(12)}  ${Math.round(result.operationsPerSecond).toLocaleString('en-US').padStart(14)}  ${(result.deviationPercent.toFixed(2)+'%').padStart(8)}  ${result.iterations.toLocaleString('en-US').padStart(12)}`);
+    }
+
+    const byName=new Map(results.map(result=>[result.name,result]));
+    console.log('\nDiagnostic ratios');
+    for(const [label,numeratorName,denominatorName] of diagnostics){
+        const numerator=byName.get(numeratorName);
+        const denominator=byName.get(denominatorName);
+        if(numerator && denominator){
+            console.log(`${label}: ${(numerator.nanoseconds/denominator.nanoseconds).toFixed(2)}x`);
+        }
+    }
+};
+
+const printPairs=function(pairs,baselineLabel){
+    const nameWidth=Math.max(...pairs.map(pair=>pair.current.name.length));
+    console.log(`${'case'.padEnd(nameWidth)}  ${'current ns'.padStart(12)}  ${'current MAD'.padStart(11)}  ${baselineLabel.padStart(12)}  ${'base MAD'.padStart(9)}  ${'speedup'.padStart(10)}`);
+    for(const pair of pairs){
+        const speedup=pair.baseline.nanoseconds/pair.current.nanoseconds;
+        console.log(`${pair.current.name.padEnd(nameWidth)}  ${pair.current.nanoseconds.toFixed(2).padStart(12)}  ${(pair.current.deviationPercent.toFixed(2)+'%').padStart(11)}  ${pair.baseline.nanoseconds.toFixed(2).padStart(12)}  ${(pair.baseline.deviationPercent.toFixed(2)+'%').padStart(9)}  ${(speedup.toFixed(2)+'x').padStart(10)}`);
+    }
+};
+
+const runComparisons=async function(){
+    if(!baseline && !historical){
+        printCurrentResults(currentCases(Is).map(benchmark));
+    }
+
+    if(baseline){
+        const BaselineIs=await classAtCommit(baselineCommit);
+        const currentBaselineCases=currentCases(Is);
+        const baselineCases=currentCases(BaselineIs);
+        const pairs=currentBaselineCases.map((current,index)=>benchmarkPair(current,baselineCases[index],Boolean(index%2)));
+        console.log(`\nPre-optimization comparison: current vs ${baselineCommit}`);
+        printPairs(pairs,'baseline ns');
+    }
+
+    if(historical){
+        const HistoricalIs=await classAtCommit(historicalCommit);
+        const currentComparable=comparableCases(Is);
+        const baselineComparable=comparableCases(HistoricalIs);
+        const pairs=currentComparable.map((current,index)=>benchmarkPair(current,baselineComparable[index],Boolean(index%2)));
+        console.log(`\nHistorical throughput reference: current vs 1.1.0 (${historicalCommit})`);
+        console.log('These same-realm positive paths overlap behaviorally; 1.1.0 does not provide the current cross-realm and spoof guarantees.');
+        printPairs(pairs,'1.1.0 ns');
+    }
+
+    if(compareConversions){
+        throw new Error(`compare/pass stringified its successful target ${compareConversions.toLocaleString('en-US')} times`);
+    }
+
+    console.log(`\nCorrectness checksum: ${sink>>>0}`);
+};
+
+runComparisons().catch(err=>{
+    console.error(err && err.stack ? err.stack : err);
+    process.exitCode=1;
+});