@gjsify/runtime 0.36.0 → 0.38.0

package/lib/esm/_virtual/_rolldown/runtime.js

@@ -0,0 +1 @@
+var e=Object.defineProperty,__name=(t,n)=>e(t,`name`,{value:n,configurable:!0});export{__name};

package/lib/esm/detect.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";const e={gjs:`GJS`,node:`Node.js`,bun:`Bun`,deno:`Deno`};function detectRuntime(t){let n=detectTarget(t);return n===void 0?{target:void 0,name:`Unknown`,version:void 0}:{target:n,name:e[n],version:versionOf(t,n)}}function detectTarget(e){if(e.Bun!==void 0)return`bun`;if(e.Deno!==void 0)return`deno`;if(typeof e.process?.versions?.gjs==`string`||e.process===void 0&&e.imports?.gi!==void 0)return`gjs`;if(typeof e.process?.versions?.node==`string`)return`node`}function versionOf(e,t){switch(t){case`bun`:return e.Bun?.version;case`deno`:return e.Deno?.version?.deno;case`gjs`:return e.process?.versions?.gjs;case`node`:return e.process?.versions?.node}}export{detectRuntime};

package/lib/esm/index.js

@@ -1 +1 @@
-const e=typeof process<`u`?process:void 0,t=globalThis.Bun!==void 0,n=globalThis.Deno!==void 0,r=globalThis.imports?.gi!==void 0||!t&&!n&&typeof e?.versions?.gjs==`string`,i=!t&&!n&&!r&&typeof e?.versions?.node==`string`,a=t?`Bun`:n?`Deno`:r?`GJS`:i?`Node.js`:`Unknown`,o=t?`bun`:n?`deno`:r?`gjs`:i?`node`:void 0,s=t?globalThis.Bun?.version:n?globalThis.Deno?.version?.deno:r?e?.versions?.gjs:i?e?.versions?.node:void 0;export{t as isBun,n as isDeno,r as isGJS,i as isNode,a as runtimeName,o as runtimeTarget,s as runtimeVersion};
+import{detectRuntime as e}from"./detect.js";const t=e(globalThis),n=t.target===`bun`,r=t.target===`deno`,i=t.target===`gjs`,a=t.target===`node`,o=t.name,s=t.target,c=t.version;export{e as detectRuntime,n as isBun,r as isDeno,i as isGJS,a as isNode,o as runtimeName,s as runtimeTarget,c as runtimeVersion};

package/lib/types/detect.d.ts

@@ -0,0 +1,48 @@
+/** The host globals the detection rule reads, all optional by construction. */
+export interface RuntimeHost {
+    Bun?: {
+        version?: string;
+    };
+    Deno?: {
+        version?: {
+            deno?: string;
+        };
+    };
+    imports?: {
+        gi?: unknown;
+    };
+    process?: {
+        versions?: {
+            gjs?: string;
+            node?: string;
+        };
+    };
+}
+/** The runtime as the CLI vocabulary spells it (`--runtime`, `gjsify.example.runtimes`). */
+export type RuntimeTarget = 'gjs' | 'node' | 'bun' | 'deno';
+/** Prose name for a user interface. `'Unknown'` where no branch matched. */
+export type RuntimeLabel = 'GJS' | 'Node.js' | 'Bun' | 'Deno' | 'Unknown';
+export interface RuntimeIdentity {
+    target: RuntimeTarget | undefined;
+    name: RuntimeLabel;
+    /** The version OF THIS RUNTIME, never the Node version Bun/Deno emulate. */
+    version: string | undefined;
+}
+/**
+ * Which runtime do these globals describe?
+ *
+ * PROBE ORDER IS LOAD-BEARING, and each step earns its position:
+ *
+ *   1. `Bun` / `Deno` — the only globals unique to those two. Both fake
+ *      `process.versions.node` for npm compatibility, so any version-table read
+ *      before this point is a false Node positive on two of the four runtimes.
+ *   2. GJS via `process.versions.gjs`, which only `@gjsify/process` sets.
+ *   3. GJS via ambient `imports.gi`, but ONLY where there is no `process` at all
+ *      — a bare GJS program that never pulled the Node globals in. It must not
+ *      come earlier: `@gjsify/node-gi` provides `imports.gi` ON NODE, so an
+ *      unconditional read names a V8 process `'GJS'`, and callers branch on this
+ *      to pick a run/exit strategy (`@gjsify/unit` would take the blocking
+ *      main-loop path and never return).
+ *   4. real Node.
+ */
+export declare function detectRuntime(host: RuntimeHost): RuntimeIdentity;

package/lib/types/index.d.ts

@@ -1,14 +1,15 @@
+import { type RuntimeTarget } from './detect.js';
+export type { RuntimeHost, RuntimeIdentity, RuntimeLabel, RuntimeTarget } from './detect.js';
+export { detectRuntime } from './detect.js';
 /** `true` when running on Bun. */
 export declare const isBun: boolean;
 /** `true` when running on Deno. */
 export declare const isDeno: boolean;
 /**
- * `true` when running on GJS (GNOME JavaScript).
+ * `true` when running on GJS (GNOME JavaScript) — the ENGINE, not the bindings.
  *
- * Checks the ambient GJS host (`imports.gi`) as well as `process.versions.gjs`:
- * the latter is set by `@gjsify/process` via `@gjsify/node-globals`, so a bare
- * GJS program that does not pull the Node globals in has no `process` at all
- * and used to report `'Unknown'` about itself.
+ * `@gjsify/node-gi` gives a Node process `imports.gi` and GObject introspection;
+ * that process is still V8 and reports `isNode`. See `./detect.js`.
  */
 export declare const isGJS: boolean;
 /** `true` when running on Node.js — and NOT on Bun, Deno or GJS. */
@@ -22,20 +23,18 @@ export declare const isNode: boolean;
  */
 export declare const runtimeName: string;
 /**
- * The runtime as the CLI spells it — `'gjs' | 'node' | 'bun' | 'deno'`, the
- * vocabulary of `--runtime` and of `gjsify.example.runtimes`. `undefined` on an
- * unrecognised host.
+ * The runtime as the CLI spells it — the vocabulary of `--runtime` and of
+ * `gjsify.example.runtimes`; `undefined` on an unrecognised host.
  *
- * Kept distinct from {@link runtimeName}, which is prose for a user interface:
- * one of these two is safe to pass back to the tooling and the other is not.
+ * Distinct from {@link runtimeName}, which is prose for a user interface: only this
+ * one is safe to pass back to the tooling.
  */
-export declare const runtimeTarget: 'gjs' | 'node' | 'bun' | 'deno' | undefined;
+export declare const runtimeTarget: RuntimeTarget | undefined;
 /**
- * Runtime version string, e.g. `'1.86.0'` (GJS), `'24.1.0'` (Node.js),
- * `'1.2.0'` (Bun), `'2.1.0'` (Deno). `undefined` if it cannot be determined.
+ * Runtime version string, or `undefined` if it cannot be determined.
  *
- * Bun and Deno are read from their own globals rather than
- * `process.versions.node`, which on both reports the Node version they emulate
- * — a real number, about a runtime you are not on.
+ * Bun and Deno are read from their own globals, not `process.versions.node`, which
+ * on both reports the Node version they emulate — a real number about a runtime you
+ * are not on.
  */
 export declare const runtimeVersion: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/runtime",
-    "version": "0.36.0",
+    "version": "0.38.0",
     "description": "Platform-independent runtime detection for GJS, Node.js, Bun and Deno",
     "keywords": [
         "gjs",
@@ -27,7 +27,7 @@
         "check": "gjsify tsc --noEmit",
         "build": "gjsify run build:gjsify && gjsify run build:types",
         "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
-        "build:types": "gjsify tsc",
+        "build:types": "gjsify tsc -p tsconfig.build.json",
         "build:test": "gjsify run build:test:gjs && gjsify run build:test:node",
         "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
         "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
@@ -39,8 +39,8 @@
         "test:cross-runtime": "gjsify run build:test:node && gjsify run test:node && gjsify run test:bun && gjsify run test:deno"
     },
     "devDependencies": {
-        "@gjsify/cli": "^0.36.0",
-        "@gjsify/unit": "^0.36.0",
+        "@gjsify/cli": "^0.38.0",
+        "@gjsify/unit": "^0.38.0",
         "@types/node": "^25.9.2",
         "typescript": "^6.0.3"
     },

package/lib/types/index.spec.d.ts

@@ -1,2 +0,0 @@
-declare const _default: () => Promise<void>;
-export default _default;