jsgui3-server 0.0.151 → 0.0.152

package/labs/website-design/001-base-class-overhead/check.js

@@ -0,0 +1,162 @@
+/**
+ * Lab 001: Base Class Overhead
+ * Book Chapter: 03-base-class
+ *
+ * Question: Does Evented_Class add meaningful overhead vs. a plain class?
+ *
+ * Run: node labs/website-design/001-base-class-overhead/check.js
+ */
+
+'use strict';
+
+let pass = 0, fail = 0;
+function check(label, ok) {
+    if (ok) { console.log(`  ✅ ${label}`); pass++; }
+    else    { console.log(`  ❌ ${label}`); fail++; }
+}
+
+// ── Option A: Plain class ──────────────────────────────
+class Plain_Webpage {
+    constructor(spec = {}) {
+        this.name = spec.name;
+        this.title = spec.title;
+        this.path = spec.path;
+        this.content = spec.content;
+        this.meta = spec.meta || {};
+    }
+    toJSON() {
+        return { name: this.name, title: this.title, path: this.path, meta: this.meta };
+    }
+}
+
+// ── Option B: Evented_Class ────────────────────────────
+const { Evented_Class } = require('jsgui3-html');
+
+class Evented_Webpage extends Evented_Class {
+    constructor(spec = {}) {
+        super();
+        this.name = spec.name;
+        this.title = spec.title;
+        this.path = spec.path;
+        this.content = spec.content;
+        this.meta = spec.meta || {};
+    }
+    toJSON() {
+        return { name: this.name, title: this.title, path: this.path, meta: this.meta };
+    }
+}
+
+const N = 10000;
+
+// ── TEST 1: Construction time ──────────────────────────
+console.log('\n═══ 001: Base Class Overhead ═══\n');
+console.log('TEST 1: Construction time (' + N + ' instances)');
+console.log('────────────────────────────────');
+
+const spec = { name: 'Home', title: 'Home Page', path: '/', meta: { description: 'test' } };
+
+// warmup
+for (let i = 0; i < 100; i++) { new Plain_Webpage(spec); new Evented_Webpage(spec); }
+
+const t1 = process.hrtime.bigint();
+for (let i = 0; i < N; i++) new Plain_Webpage(spec);
+const t2 = process.hrtime.bigint();
+for (let i = 0; i < N; i++) new Evented_Webpage(spec);
+const t3 = process.hrtime.bigint();
+
+const plainMs  = Number(t2 - t1) / 1e6;
+const eventMs  = Number(t3 - t2) / 1e6;
+const ratio = eventMs / plainMs;
+
+console.log(`  Plain class:    ${plainMs.toFixed(2)} ms`);
+console.log(`  Evented_Class:  ${eventMs.toFixed(2)} ms`);
+console.log(`  Ratio:          ${ratio.toFixed(1)}x`);
+
+// Even 10x is fine if absolute time is <50ms for 10k objects
+check('Evented_Class < 50ms for 10k constructions', eventMs < 50);
+check('Ratio < 20x (acceptable overhead)', ratio < 20);
+
+// ── TEST 2: Memory per instance ────────────────────────
+console.log('\nTEST 2: Memory per instance');
+console.log('────────────────────────────────');
+
+global.gc && global.gc();
+const mem0 = process.memoryUsage().heapUsed;
+const plainArr = [];
+for (let i = 0; i < N; i++) plainArr.push(new Plain_Webpage(spec));
+const mem1 = process.memoryUsage().heapUsed;
+const eventArr = [];
+for (let i = 0; i < N; i++) eventArr.push(new Evented_Webpage(spec));
+const mem2 = process.memoryUsage().heapUsed;
+
+const plainBytes  = (mem1 - mem0) / N;
+const eventBytes  = (mem2 - mem1) / N;
+
+console.log(`  Plain class:    ~${Math.round(plainBytes)} bytes/instance`);
+console.log(`  Evented_Class:  ~${Math.round(eventBytes)} bytes/instance`);
+console.log(`  Delta:          ~${Math.round(eventBytes - plainBytes)} bytes extra`);
+
+// For page objects (dozens, not millions), even 1KB extra is fine
+check('Evented_Class < 1KB per instance', eventBytes < 1024);
+check('Delta < 500 bytes extra per instance', (eventBytes - plainBytes) < 500);
+
+// Keep references alive to prevent GC
+plainArr.length; eventArr.length;
+
+// ── TEST 3: Event capability ───────────────────────────
+console.log('\nTEST 3: Event capability (what you gain)');
+console.log('────────────────────────────────');
+
+const ew = new Evented_Webpage({ path: '/test' });
+let eventCount = 0;
+
+ew.on('finalized', () => eventCount++);
+ew.raise('finalized');
+
+check('Events fire correctly', eventCount === 1);
+
+// Can we add lifecycle events?
+let lifecycleLog = [];
+ew.on('property-changed', (e) => lifecycleLog.push(e));
+ew.raise('property-changed', { name: 'title', old: 'Old', value: 'New' });
+
+check('Custom events carry data', lifecycleLog.length === 1 && lifecycleLog[0].name === 'title');
+
+// Plain class can't do this without adding an EventEmitter
+const pw = new Plain_Webpage({ path: '/test' });
+check('Plain class has no .on()', typeof pw.on === 'undefined');
+check('Plain class has no .raise()', typeof pw.raise === 'undefined');
+
+// ── TEST 4: toJSON parity ──────────────────────────────
+console.log('\nTEST 4: toJSON parity');
+console.log('────────────────────────────────');
+
+const pj = new Plain_Webpage(spec).toJSON();
+const ej = new Evented_Webpage(spec).toJSON();
+
+check('toJSON output is identical', JSON.stringify(pj) === JSON.stringify(ej));
+
+// Does Evented_Class add hidden enumerable properties that leak into serialization?
+const eKeys = Object.keys(new Evented_Webpage(spec));
+const pKeys = Object.keys(new Plain_Webpage(spec));
+const extraKeys = eKeys.filter(k => !pKeys.includes(k));
+console.log(`  Plain keys:    [${pKeys.join(', ')}]`);
+console.log(`  Evented keys:  [${eKeys.join(', ')}]`);
+console.log(`  Extra keys:    [${extraKeys.join(', ')}]`);
+
+check('No unexpected enumerable properties leaked', extraKeys.length === 0 || extraKeys.every(k => k.startsWith('_')));
+
+// ── VERDICT ────────────────────────────────────────────
+console.log('\n═══════════════════════════════════════════');
+console.log(`RESULTS: ${pass} passed, ${fail} failed`);
+
+if (fail === 0) {
+    console.log('\n✅ VERDICT: Evented_Class adds acceptable overhead');
+    console.log('   and provides event capability for free.');
+    console.log('   → Recommend Evented_Class as base (Ch.3 confirmed)');
+} else {
+    console.log('\n⚠️  VERDICT: Some checks failed — review results above');
+}
+console.log('═══════════════════════════════════════════\n');
+
+process.exit(fail > 0 ? 1 : 0);

package/labs/website-design/002-pages-storage/check.js

@@ -0,0 +1,244 @@
+/**
+ * Lab 002: Pages Storage Comparison
+ * Book Chapter: 06-pages-storage
+ *
+ * Question: Array vs Map vs Array+Index — which is best for page storage?
+ *
+ * Run: node labs/website-design/002-pages-storage/check.js
+ */
+
+'use strict';
+
+let pass = 0, fail = 0;
+function check(label, ok) {
+    if (ok) { console.log(`  ✅ ${label}`); pass++; }
+    else { console.log(`  ❌ ${label}`); fail++; }
+}
+
+// ── Simulated page objects ─────────────────────────────
+function makePage(path, name) {
+    return { path, name, title: name, content: function () { }, meta: {} };
+}
+
+const samplePages = [
+    makePage('/', 'Home'),
+    makePage('/about', 'About'),
+    makePage('/contact', 'Contact'),
+    makePage('/blog', 'Blog'),
+    makePage('/blog/post-1', 'Post 1'),
+    makePage('/docs', 'Documentation'),
+    makePage('/docs/api', 'API Reference'),
+    makePage('/pricing', 'Pricing'),
+    makePage('/login', 'Login'),
+    makePage('/signup', 'Sign Up'),
+];
+
+console.log('\n═══ 002: Pages Storage Comparison ═══\n');
+
+// ── APPROACH A: Plain Array ────────────────────────────
+class ArrayStore {
+    constructor() { this._pages = []; }
+    add(page) { this._pages.push(page); }
+    get(path) { return this._pages.find(p => p.path === path); }
+    has(path) { return this._pages.some(p => p.path === path); }
+    remove(path) {
+        const idx = this._pages.findIndex(p => p.path === path);
+        if (idx >= 0) this._pages.splice(idx, 1);
+    }
+    get routes() { return this._pages.map(p => p.path); }
+    get size() { return this._pages.length; }
+    [Symbol.iterator]() { return this._pages[Symbol.iterator](); }
+    toJSON() { return this._pages.map(p => ({ path: p.path, name: p.name })); }
+}
+
+// ── APPROACH B: Map ────────────────────────────────────
+class MapStore {
+    constructor() { this._pages = new Map(); }
+    add(page) {
+        if (this._pages.has(page.path)) {
+            throw new Error(`Duplicate page path: ${page.path}`);
+        }
+        this._pages.set(page.path, page);
+    }
+    get(path) { return this._pages.get(path); }
+    has(path) { return this._pages.has(path); }
+    remove(path) { this._pages.delete(path); }
+    get routes() { return [...this._pages.keys()]; }
+    get size() { return this._pages.size; }
+    [Symbol.iterator]() { return this._pages.values(); }
+    toJSON() { return [...this._pages.values()].map(p => ({ path: p.path, name: p.name })); }
+}
+
+// ── APPROACH C: Array + Index ──────────────────────────
+class IndexedArrayStore {
+    constructor() { this._pages = []; this._index = {}; }
+    add(page) {
+        if (this._index[page.path] !== undefined) {
+            throw new Error(`Duplicate page path: ${page.path}`);
+        }
+        this._index[page.path] = this._pages.length;
+        this._pages.push(page);
+    }
+    get(path) {
+        const idx = this._index[path];
+        return idx !== undefined ? this._pages[idx] : undefined;
+    }
+    has(path) { return this._index[path] !== undefined; }
+    remove(path) {
+        const idx = this._index[path];
+        if (idx !== undefined) {
+            this._pages.splice(idx, 1);
+            delete this._index[path];
+            // Rebuild index after splice
+            for (let i = idx; i < this._pages.length; i++) {
+                this._index[this._pages[i].path] = i;
+            }
+        }
+    }
+    get routes() { return this._pages.map(p => p.path); }
+    get size() { return this._pages.length; }
+    [Symbol.iterator]() { return this._pages[Symbol.iterator](); }
+    toJSON() { return this._pages.map(p => ({ path: p.path, name: p.name })); }
+}
+
+const stores = {
+    'Array': () => new ArrayStore(),
+    'Map': () => new MapStore(),
+    'Array+Index': () => new IndexedArrayStore(),
+};
+
+// ── TEST 1: Basic operations ───────────────────────────
+console.log('TEST 1: Basic operations');
+console.log('────────────────────────────────');
+
+for (const [name, factory] of Object.entries(stores)) {
+    const store = factory();
+    samplePages.forEach(p => store.add(p));
+
+    check(`${name}: add 10 pages → size is 10`, store.size === 10);
+    check(`${name}: get('/about') works`, store.get('/about')?.name === 'About');
+    check(`${name}: has('/contact') is true`, store.has('/contact') === true);
+    check(`${name}: has('/missing') is false`, store.has('/missing') === false);
+
+    store.remove('/blog');
+    check(`${name}: remove('/blog') → size is 9`, store.size === 9);
+    check(`${name}: get('/blog') is undefined after remove`, store.get('/blog') === undefined);
+}
+
+// ── TEST 2: Duplicate detection ────────────────────────
+console.log('\nTEST 2: Duplicate detection');
+console.log('────────────────────────────────');
+
+// Array allows duplicates (silent bug)
+const arrStore = new ArrayStore();
+arrStore.add(makePage('/dup', 'First'));
+arrStore.add(makePage('/dup', 'Second'));
+check('Array: allows duplicates (silent bug)', arrStore.size === 2);
+
+// Map catches duplicates
+const mapStore = new MapStore();
+mapStore.add(makePage('/dup', 'First'));
+let mapThrew = false;
+try { mapStore.add(makePage('/dup', 'Second')); } catch (e) { mapThrew = true; }
+check('Map: throws on duplicate', mapThrew === true);
+check('Map: only first page stored', mapStore.size === 1);
+
+// Array+Index catches duplicates
+const idxStore = new IndexedArrayStore();
+idxStore.add(makePage('/dup', 'First'));
+let idxThrew = false;
+try { idxStore.add(makePage('/dup', 'Second')); } catch (e) { idxThrew = true; }
+check('Array+Index: throws on duplicate', idxThrew === true);
+
+// ── TEST 3: Insertion order ────────────────────────────
+console.log('\nTEST 3: Iteration preserves insertion order');
+console.log('────────────────────────────────');
+
+for (const [name, factory] of Object.entries(stores)) {
+    const store = factory();
+    const ordered = ['/z-last', '/a-first', '/m-middle'];
+    ordered.forEach(p => store.add(makePage(p, p)));
+
+    const iterated = [...store].map(p => p.path);
+    const orderPreserved = iterated[0] === '/z-last' && iterated[1] === '/a-first' && iterated[2] === '/m-middle';
+    check(`${name}: insertion order preserved`, orderPreserved);
+}
+
+// ── TEST 4: Lookup benchmark ───────────────────────────
+console.log('\nTEST 4: Lookup benchmark');
+console.log('────────────────────────────────');
+
+const bigN = 1000;
+const bigPages = [];
+for (let i = 0; i < bigN; i++) bigPages.push(makePage(`/page-${i}`, `Page ${i}`));
+
+const lookupTarget = `/page-${bigN - 1}`; // worst case for array
+const ITERS = 100000;
+
+for (const [name, factory] of Object.entries(stores)) {
+    const store = factory();
+    bigPages.forEach(p => store.add(p));
+
+    const start = process.hrtime.bigint();
+    for (let i = 0; i < ITERS; i++) store.get(lookupTarget);
+    const elapsed = Number(process.hrtime.bigint() - start) / 1e6;
+
+    console.log(`  ${name}: ${ITERS} lookups in ${bigN} pages → ${elapsed.toFixed(2)} ms`);
+}
+
+// Map should be fastest for large N
+const mapBench = stores['Map']();
+const arrBench = stores['Array']();
+bigPages.forEach(p => { mapBench.add(p); arrBench.add(p); });
+
+const mapStart = process.hrtime.bigint();
+for (let i = 0; i < ITERS; i++) mapBench.get(lookupTarget);
+const mapElapsed = Number(process.hrtime.bigint() - mapStart) / 1e6;
+
+const arrStart = process.hrtime.bigint();
+for (let i = 0; i < ITERS; i++) arrBench.get(lookupTarget);
+const arrElapsed = Number(process.hrtime.bigint() - arrStart) / 1e6;
+
+check('Map lookup faster than Array.find() at 1000 pages', mapElapsed < arrElapsed);
+console.log(`  Map: ${mapElapsed.toFixed(2)} ms vs Array: ${arrElapsed.toFixed(2)} ms (${(arrElapsed / mapElapsed).toFixed(1)}x faster)`);
+
+// ── TEST 5: toJSON output ──────────────────────────────
+console.log('\nTEST 5: toJSON output');
+console.log('────────────────────────────────');
+
+for (const [name, factory] of Object.entries(stores)) {
+    const store = factory();
+    samplePages.slice(0, 3).forEach(p => store.add(p));
+    const json = store.toJSON();
+
+    check(`${name}: toJSON returns array`, Array.isArray(json));
+    check(`${name}: toJSON entries have path+name`, json[0].path === '/' && json[0].name === 'Home');
+}
+
+// ── TEST 6: Replace page ───────────────────────────────
+console.log('\nTEST 6: Replace page (remove + add)');
+console.log('────────────────────────────────');
+
+for (const [name, factory] of Object.entries(stores)) {
+    const store = factory();
+    store.add(makePage('/about', 'About v1'));
+    store.remove('/about');
+    store.add(makePage('/about', 'About v2'));
+
+    check(`${name}: replace works`, store.get('/about')?.name === 'About v2');
+    check(`${name}: size stays 1`, store.size === 1);
+}
+
+// ── VERDICT ────────────────────────────────────────────
+console.log('\n═══════════════════════════════════════════');
+console.log(`RESULTS: ${pass} passed, ${fail} failed`);
+
+console.log('\n📊 SUMMARY:');
+console.log('  Array:       Simple but no duplicate detection, O(n) lookup');
+console.log('  Map:         O(1) lookup, duplicate detection, insertion order ✓');
+console.log('  Array+Index: O(1) lookup, duplicate detection, but remove is O(n) to reindex');
+console.log('\n✅ VERDICT: Map is the best balance of performance and API cleanliness.');
+console.log('   → Ch.6 recommendation confirmed');
+console.log('═══════════════════════════════════════════\n');
+
+process.exit(fail > 0 ? 1 : 0);

package/labs/website-design/003-type-detection/check.js

@@ -0,0 +1,193 @@
+/**
+ * Lab 003: Type Detection Strategies
+ * Book Chapter: 08-server-integration
+ *
+ * Question: instanceof vs duck typing vs Symbol.for() — which is reliable?
+ *
+ * Run: node labs/website-design/003-type-detection/check.js
+ */
+
+'use strict';
+
+let pass = 0, fail = 0;
+function check(label, ok) {
+    if (ok) { console.log(`  ✅ ${label}`); pass++; }
+    else { console.log(`  ❌ ${label}`); fail++; }
+}
+
+console.log('\n═══ 003: Type Detection Strategies ═══\n');
+
+// ── Setup: real Website/Webpage from node_modules ──────
+const Website = require('jsgui3-website');
+const Webpage = require('jsgui3-webpage');
+
+const site = new Website({ name: 'Test Site' });
+const page = new Webpage({ path: '/', title: 'Home' });
+
+// ── STRATEGY A: instanceof ─────────────────────────────
+console.log('TEST 1: instanceof detection');
+console.log('────────────────────────────────');
+
+check('site instanceof Website', site instanceof Website);
+check('page instanceof Webpage', page instanceof Webpage);
+check('plain object is NOT instanceof Website', !({} instanceof Website));
+
+// Simulate cross-install: different constructor with same shape
+function FakeWebsite(spec) { Object.assign(this, spec); }
+FakeWebsite.prototype.toJSON = function () { return this; };
+const fake = new FakeWebsite({ name: 'Fake', pages: new Map() });
+
+check('FakeWebsite fails instanceof (correct rejection)', !(fake instanceof Website));
+
+// Simulate a re-evaluation scenario (like loading same module from different path)
+// This tests whether two copies of the same class share instanceof
+const Website2 = Website; // same reference = same constructor
+const site2 = new Website2({ name: 'Test 2' });
+check('Same-reference require: instanceof works', site2 instanceof Website);
+
+console.log('  ⚠️  Note: instanceof breaks if jsgui3-website is installed');
+console.log('     in two different node_modules trees (npm link, workspaces)');
+
+// ── STRATEGY B: Duck typing ────────────────────────────
+console.log('\nTEST 2: Duck typing detection');
+console.log('────────────────────────────────');
+
+function isWebsite_duck(obj) {
+    return obj != null
+        && typeof obj === 'object'
+        && typeof obj.name === 'string';
+    // Current Website is too minimal for meaningful duck typing
+    // With the proposed API: check for add_page, get_page, etc.
+}
+
+function isWebsite_duck_proposed(obj) {
+    return obj != null
+        && typeof obj === 'object'
+        && typeof obj.add_page === 'function'
+        && typeof obj.get_page === 'function'
+        && typeof obj.toJSON === 'function';
+}
+
+function isWebpage_duck(obj) {
+    return obj != null
+        && typeof obj === 'object'
+        && 'path' in obj
+        && typeof obj.path === 'string';
+}
+
+check('Duck typing: site detected (current)', isWebsite_duck(site));
+check('Duck typing: page detected', isWebpage_duck(page));
+
+// False positive: plain object with a name
+const plainObj = { name: 'Just an object' };
+check('Duck typing (current): plain object FALSE POSITIVE', isWebsite_duck(plainObj));
+console.log('  ⚠️  Current Website is too minimal — duck typing produces false positives');
+
+// With proposed API (add_page, get_page), false positive is much harder
+check('Duck typing (proposed): plain object correctly rejected',
+    !isWebsite_duck_proposed(plainObj));
+
+// With proposed API: FakeWebsite correctly rejected
+check('Duck typing (proposed): FakeWebsite correctly rejected',
+    !isWebsite_duck_proposed(fake));
+
+// Simulate a correct duck-typed object (not instanceof but has the right shape)
+const duckSite = {
+    name: 'Duck Site',
+    add_page(p) { this._pages = this._pages || new Map(); this._pages.set(p.path, p); },
+    get_page(path) { return (this._pages || new Map()).get(path); },
+    toJSON() { return { name: this.name }; }
+};
+check('Duck typing (proposed): shape-correct object accepted',
+    isWebsite_duck_proposed(duckSite));
+
+// ── STRATEGY C: Symbol.for() marker ───────────────────
+console.log('\nTEST 3: Symbol.for() marker');
+console.log('────────────────────────────────');
+
+const WEBSITE_MARKER = Symbol.for('jsgui3.website');
+const WEBPAGE_MARKER = Symbol.for('jsgui3.webpage');
+
+// Simulate adding markers to prototypes
+class MarkedWebsite {
+    constructor(spec = {}) { Object.assign(this, spec); }
+    get [WEBSITE_MARKER]() { return true; }
+}
+
+class MarkedWebpage {
+    constructor(spec = {}) { Object.assign(this, spec); }
+    get [WEBPAGE_MARKER]() { return true; }
+}
+
+function isWebsite_symbol(obj) {
+    return obj != null && obj[Symbol.for('jsgui3.website')] === true;
+}
+
+function isWebpage_symbol(obj) {
+    return obj != null && obj[Symbol.for('jsgui3.webpage')] === true;
+}
+
+const ms = new MarkedWebsite({ name: 'Marked' });
+const mp = new MarkedWebpage({ path: '/' });
+
+check('Symbol: MarkedWebsite detected', isWebsite_symbol(ms));
+check('Symbol: MarkedWebpage detected', isWebpage_symbol(mp));
+check('Symbol: plain object correctly rejected', !isWebsite_symbol({}));
+check('Symbol: wrong type correctly rejected', !isWebsite_symbol(mp));
+
+// Cross-realm: Symbol.for() is global, survives across different module loads
+const markerFromOtherContext = Symbol.for('jsgui3.website');
+check('Symbol.for() is globally unique', markerFromOtherContext === WEBSITE_MARKER);
+
+// ── STRATEGY D: Combined (recommended) ────────────────
+console.log('\nTEST 4: Combined detection (duck + optional symbol)');
+console.log('────────────────────────────────');
+
+function detectWebsite(obj) {
+    if (obj == null || typeof obj !== 'object') return false;
+    // Fast path: symbol marker
+    if (obj[Symbol.for('jsgui3.website')] === true) return true;
+    // Fallback: duck typing on proposed API
+    return typeof obj.add_page === 'function'
+        && typeof obj.get_page === 'function'
+        && typeof obj.toJSON === 'function';
+}
+
+check('Combined: symbol-marked object detected', detectWebsite(ms));
+check('Combined: duck-typed object detected', detectWebsite(duckSite));
+check('Combined: plain object rejected', !detectWebsite({}));
+check('Combined: null rejected', !detectWebsite(null));
+
+// ── Benchmark ──────────────────────────────────────────
+console.log('\nTEST 5: Detection speed comparison');
+console.log('────────────────────────────────');
+
+const ITERS = 1000000;
+const target = ms; // has both symbol and duck interface
+
+const t1 = process.hrtime.bigint();
+for (let i = 0; i < ITERS; i++) target instanceof MarkedWebsite;
+const t2 = process.hrtime.bigint();
+for (let i = 0; i < ITERS; i++) isWebsite_symbol(target);
+const t3 = process.hrtime.bigint();
+for (let i = 0; i < ITERS; i++) detectWebsite(target);
+const t4 = process.hrtime.bigint();
+
+console.log(`  instanceof:  ${(Number(t2 - t1) / 1e6).toFixed(2)} ms (${ITERS} checks)`);
+console.log(`  Symbol:      ${(Number(t3 - t2) / 1e6).toFixed(2)} ms`);
+console.log(`  Combined:    ${(Number(t4 - t3) / 1e6).toFixed(2)} ms`);
+
+// ── VERDICT ────────────────────────────────────────────
+console.log('\n═══════════════════════════════════════════');
+console.log(`RESULTS: ${pass} passed, ${fail} failed`);
+
+console.log('\n📊 SUMMARY:');
+console.log('  instanceof:  Fast, but breaks across npm link/workspaces');
+console.log('  Duck typing: Works cross-install, but current Website too minimal');
+console.log('  Symbol.for:  Cross-realm safe, no false positives, explicit');
+console.log('  Combined:    Best reliability — symbol fast path + duck fallback');
+console.log('\n✅ VERDICT: Use combined detection (symbol + duck typing).');
+console.log('   → Ch.8 recommendation: capability checks with optional marker');
+console.log('═══════════════════════════════════════════\n');
+
+process.exit(fail > 0 ? 1 : 0);