@feasibleone/blong-gogo 1.13.8 → 1.14.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.14.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.13.8...blong-gogo-v1.14.0) (2026-03-20)
+
+
+### Features
+
+* realm loading and sim improvements ([a2c0ebe](https://github.com/feasibleone/blong/commit/a2c0ebe1fa1608ab4af5ffdc26e7518219710bdb))
+
 ## [1.13.8](https://github.com/feasibleone/blong/compare/blong-gogo-v1.13.7...blong-gogo-v1.13.8) (2026-03-18)
 
 

package/bin/blong-dev.ts

@@ -1,9 +1,47 @@
 #!/usr/bin/env -S node --watch --inspect
 
 import minimist from 'minimist';
-import {resolve} from 'node:path';
+import {existsSync} from 'node:fs';
+import {basename, resolve} from 'node:path';
 import load from '../src/load.ts';
 
 const argv: {_: string[]} = minimist(process.argv.slice(2));
+const cwd = process.cwd();
+const target = argv._[0];
 
-(await import(resolve(argv._[0] ?? 'index.ts'))).default(load);
+if (target) {
+    // Explicit file provided — load it directly (existing behavior)
+    (await import(resolve(target))).default(load);
+} else {
+    // Auto-detect what to run based on available files in the current directory.
+    const indexFile = resolve(cwd, 'index.ts');
+    const serverFile = resolve(cwd, 'server.ts');
+    const browserFile = resolve(cwd, 'browser.ts');
+
+    if (existsSync(indexFile)) {
+        (await import(indexFile)).default(load);
+    } else if (existsSync(serverFile) && existsSync(browserFile)) {
+        const {default: server} = await import(serverFile);
+        const {default: browser} = await import(browserFile);
+        const name = basename(cwd);
+        const platforms: Awaited<ReturnType<typeof load>>[] = await Promise.all([
+            load(server, name, name, ['microservice', 'integration', 'dev']),
+            load(browser, name, name, ['microservice', 'integration', 'dev']),
+        ]);
+        for (const platform of platforms) await platform.start();
+        await platforms[1].test();
+        if (process.env.CI) for (const platform of platforms) await platform.stop();
+    } else if (existsSync(serverFile)) {
+        const {default: server} = await import(serverFile);
+        const name = basename(cwd);
+        const platform = await load(server, name, name, ['microservice', 'integration', 'dev']);
+        await platform.start();
+        await platform.test();
+        if (process.env.CI) await platform.stop();
+    } else {
+        throw new Error(
+            `No index.ts, server.ts, or browser.ts found in ${cwd}. ` +
+                'Run blong from a suite or realm folder, or provide a file path.',
+        );
+    }
+}

package/bin/blong.ts

@@ -1,9 +1,48 @@
 #!/usr/bin/env -S node
 
 import minimist from 'minimist';
-import {resolve} from 'node:path';
+import { existsSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
 import load from '../src/load.ts';
 
 const argv: {_: string[]} = minimist(process.argv.slice(2));
+const cwd = process.cwd();
+const target = argv._[0];
 
-(await import(resolve(argv._[0] ?? 'index.ts'))).default(load);
+if (target) {
+    // Explicit file provided — load it directly
+    (await import(resolve(target))).default(load);
+} else {
+    const indexFile = join(cwd, 'index.ts');
+    const serverFile = join(cwd, 'server.ts');
+    const browserFile = join(cwd, 'browser.ts');
+    const name = basename(cwd);
+
+    if (existsSync(indexFile)) {
+        // index.ts exists — use it directly (suite or realm with a custom runner)
+        (await import(indexFile)).default(load);
+    } else if (existsSync(serverFile) && existsSync(browserFile)) {
+        // Both server.ts and browser.ts — two-platform (suite or realm with browser)
+        const {default: serverDef} = await import(serverFile);
+        const {default: browserDef} = await import(browserFile);
+        const platforms: Awaited<ReturnType<typeof load>>[] = await Promise.all([
+            load(serverDef, name, name, ['microservice', 'integration', 'dev']),
+            load(browserDef, name, name, ['microservice', 'integration', 'dev']),
+        ]);
+        for (const platform of platforms) await platform.start();
+        await platforms[1].test();
+        if (process.env.CI) for (const platform of platforms) await platform.stop();
+    } else if (existsSync(serverFile)) {
+        // Only server.ts — suite or realm (loadRealm detects and wraps realms automatically)
+        const {default: serverDef} = await import(serverFile);
+        const platform = await load(serverDef, name, name, ['microservice', 'integration', 'dev']);
+        await platform.start();
+        await platform.test();
+        if (process.env.CI) await platform.stop();
+    } else {
+        throw new Error(
+            `No index.ts or server.ts found in ${cwd}. ` +
+                'Run blong from a suite or realm folder, or provide a file path.',
+        );
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.13.8",
+  "version": "1.14.0",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },

package/src/load.ts

@@ -1,7 +1,9 @@
 import load from '@feasibleone/blong-config';
 import {
     Internal,
+    browser as browserFactory,
     kind,
+    server as serverFactory,
     type IApiSchema,
     type IErrorFactory,
     type ILog,
@@ -12,17 +14,19 @@ import {
     type Kinds,
     type SolutionFactory,
 } from '@feasibleone/blong/types';
-import {existsSync} from 'fs';
-import {readdir} from 'fs/promises';
-import {createRequire} from 'node:module';
-import {basename, dirname, join} from 'path';
-import {Type, type TSchema} from 'typebox';
+import { existsSync } from 'fs';
+import { readdir } from 'fs/promises';
+import { createRequire } from 'node:module';
+import { basename, dirname, extname, join } from 'path';
+
+import { Type, type TSchema } from 'typebox';
 import merge from 'ut-function.merge';
+import { methodParts } from './lib.ts';
 
-import type {Dirent} from 'fs';
+import type { Dirent } from 'fs';
 import layerProxy from './layerProxy.ts';
-import RealmImpl, {type IRealm} from './Realm.ts';
-import type {IWatch} from './Watch.ts';
+import RealmImpl, { type IRealm } from './Realm.ts';
+import type { IWatch } from './Watch.ts';
 
 const LAYER_FILE = 'layer' as const;
 
@@ -72,6 +76,50 @@ async function discoverLayerFolders(
     return result;
 }
 
+/**
+ * Discover test method names from a realm's test/test/ folder.
+ * Imports each handler file with a null proxy to extract method names.
+ */
+async function discoverRealmTestMethods(base: string): Promise<string[]> {
+    const testDir = join(base, 'test', 'test');
+    if (!existsSync(testDir)) return [];
+    const nullFn: unknown = new Proxy(function () {
+        return nullFn;
+    } as unknown as object, {
+        get(_, key) {
+            if (typeof key === 'symbol') return undefined;
+            return nullFn;
+        },
+        apply() {
+            return nullFn;
+        },
+    });
+    const files = (await readdir(testDir, {withFileTypes: true})).filter(
+        f => f.isFile() && /\.(ts|mts|js|mjs)$/i.test(f.name) && !f.name.startsWith('~'),
+    );
+    const methods: string[] = [];
+    for (const file of files) {
+        const filePath = join(testDir, file.name);
+        try {
+            const mod = await import(filePath);
+            const fn = mod?.default;
+            if (typeof fn === 'function') {
+                const result = fn({lib: nullFn, handler: nullFn, errors: nullFn, config: {}, remote: nullFn, local: nullFn});
+                if (result && typeof result === 'object' && !Array.isArray(result)) {
+                    for (const key of Object.keys(result)) methods.push(methodParts(key));
+                } else {
+                    methods.push(methodParts(basename(file.name, extname(file.name))));
+                }
+            } else {
+                methods.push(methodParts(basename(file.name, extname(file.name))));
+            }
+        } catch {
+            methods.push(methodParts(basename(file.name, extname(file.name))));
+        }
+    }
+    return methods;
+}
+
 const scan = async (...path: string[]): Promise<Dirent[]> =>
     (await readdir(join(...path), {withFileTypes: true})).sort((a, b) =>
         a < b ? -1 : a > b ? 1 : 0,
@@ -125,7 +173,65 @@ export default async function loadRealm<T extends TSchema>(
     const defKind = kind(def);
     if (!rootKind) {
         if (defKind === 'server' || defKind === 'browser') rootKind = defKind;
-        else throw new Error(`Root realm must be of kind "server" or "browser", got "${defKind}"`);
+        else if (defKind === 'solution') {
+            // Realm passed directly as root — wrap in a minimal suite for isolated testing
+            const realmMod = await def({type: Type});
+            const realmUrl = realmMod.url as string;
+            const realmFilePath = realmUrl.startsWith('file://') ? realmUrl.slice(7) : realmUrl;
+            const realmBase = dirname(realmFilePath);
+            const realmFileName = basename(realmFilePath);
+            const realmName = basename(realmBase);
+            let pkg: {name: string; version: string};
+            try {
+                pkg = createRequire(realmUrl)('./package.json') as {name: string; version: string};
+            } catch {
+                pkg = {name: realmName, version: '0.0.0'};
+            }
+            const testMethods = await discoverRealmTestMethods(realmBase);
+            const realmChild = Object.defineProperty(
+                async function () {
+                    return {default: def};
+                },
+                'name',
+                {value: realmName, configurable: true},
+            );
+            if (realmFileName.startsWith('browser')) {
+                // Browser realm — wrap in a minimal browser suite
+                const wrapper = browserFactory((() => ({
+                    url: '',
+                    pkg,
+                    children: [realmChild],
+                    config: {
+                        default: {remote: {canSkipSocket: true}, [realmName]: {}},
+                        integration: {watch: {test: testMethods}},
+                    },
+                })) as () => any);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return loadRealm(wrapper as any, name, parentConfig, configNames);
+            } else {
+                // Server realm — single platform if no browser.ts alongside, else two-platform server half
+                const hasBrowser = existsSync(join(realmBase, 'browser.ts'));
+                const wrapper = serverFactory((() => ({
+                    url: '',
+                    pkg,
+                    children: [realmChild],
+                    config: {
+                        default: {
+                            rpcServer: {port: 0},
+                            gateway: {port: hasBrowser ? 8080 : 0},
+                            [realmName]: {},
+                        },
+                        integration: hasBrowser
+                            ? {default: {}} // browser side handles watch.test and canSkipSocket
+                            : {default: {}, remote: {canSkipSocket: true}, watch: {test: testMethods}},
+                    },
+                })) as () => any);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return loadRealm(wrapper as any, name, parentConfig, configNames);
+            }
+        } else {
+            throw new Error(`Root realm must be of kind "server" or "browser", got "${defKind}"`);
+        }
     }
     const mod = await def({type: Type});
     if (!('pkg' in mod)) mod.pkg = createRequire(mod.url)('./package.json');