@adaas/a-concept 0.2.7 → 0.2.9

package/jest.config.ts

@@ -10,6 +10,7 @@ const config: Config.InitialOptions = {
     },
     moduleNameMapper: {
         "@adaas/a-concept/constants/(.*)": ["<rootDir>/src/constants/$1"],
+        "@adaas/a-concept/env": ["<rootDir>/src/env/index.node.ts"],
         "@adaas/a-concept/global/(.*)": ["<rootDir>/src/global/$1"],
         "@adaas/a-concept/types/(.*)": ["<rootDir>/src/types/$1"],
         "@adaas/a-concept/helpers/(.*)": ["<rootDir>/src/helpers/$1"],

package/package.json

@@ -1,11 +1,23 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "A-Concept is a framework of the new generation that is tailored to use AI, enabling developers to create AI-powered applications with ease. It provides a structured approach to building, managing, and deploying AI-driven solutions.",
   "license": "Apache-2.0",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/node/index.cjs",
+  "module": "./dist/node/index.mjs",
+  "types": "./dist/node/index.d.ts",
+  "exports": {
+    ".": {
+      "browser": "./dist/browser/index.mjs",
+      "import": "./dist/node/index.mjs",
+      "require": "./dist/node/index.cjs"
+    },
+    "./env": {
+      "browser": "./dist/browser/env.mjs",
+      "import": "./dist/node/env.mjs",
+      "require": "./dist/node/env.cjs"
+    }
+  },
   "author": {
     "name": "ADAAS YAZILIM LİMİTED ŞİRKETİ",
     "email": "contact-us@adaas.org"
@@ -24,12 +36,6 @@
     "url": "https://github.com/ADAAS-org/adaas-a-concept/issues"
   },
   "sideEffects": false,
-  "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
-    }
-  },
   "nodemonConfig": {
     "ignore": [
       "**/*.test.ts",

package/src/constants/env.constants.ts

@@ -24,6 +24,10 @@ export const A_CONSTANTS__DEFAULT_ENV_VARIABLES = {
      * Environment of the application e.g. development, production, staging
      */
     A_CONCEPT_ENVIRONMENT: 'A_CONCEPT_ENVIRONMENT',
+    /**
+     * Runtime environment of the application e.g. browser, node
+     */
+    A_CONCEPT_RUNTIME_ENVIRONMENT: 'A_CONCEPT_RUNTIME_ENVIRONMENT',
     /**
      * Root folder of the application
      * [!] Automatically set by A-Concept when the application starts
@@ -44,6 +48,7 @@ export const A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY = [
     A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME,
     A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE,
     A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ENVIRONMENT,
+    A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_RUNTIME_ENVIRONMENT,
     A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_FOLDER,
 
     A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_ERROR_DEFAULT_DESCRIPTION,

package/src/env/env-browser.ts

@@ -0,0 +1,24 @@
+import { A_TYPES__ContextEnvironment } from "../global/A-Context/A-Context.types";
+import { A_CONCEPT_BASE_ENV } from "./env.base";
+
+
+export class ENV extends A_CONCEPT_BASE_ENV {
+    static get A_CONCEPT_ENVIRONMENT() {
+        return window.__A_CONCEPT_ENVIRONMENT_ENV__?.A_CONCEPT_ENVIRONMENT || super.A_CONCEPT_ENVIRONMENT;
+    }
+    static get A_CONCEPT_RUNTIME_ENVIRONMENT(): A_TYPES__ContextEnvironment {
+        return 'browser';
+    }
+    static get A_CONCEPT_NAME() {
+        return window.__A_CONCEPT_ENVIRONMENT_ENV__?.A_CONCEPT_NAME || super.A_CONCEPT_NAME;
+    }
+    static get A_CONCEPT_ROOT_FOLDER() {
+        return window.__A_CONCEPT_ENVIRONMENT_ENV__?.A_CONCEPT_ROOT_FOLDER || super.A_CONCEPT_ROOT_FOLDER;
+    }
+    static get A_CONCEPT_ROOT_SCOPE() {
+        return window.__A_CONCEPT_ENVIRONMENT_ENV__?.A_CONCEPT_ROOT_SCOPE || super.A_CONCEPT_ROOT_SCOPE;
+    }
+    static get A_ERROR_DEFAULT_DESCRIPTION() {
+        return window.__A_CONCEPT_ENVIRONMENT_ENV__?.A_ERROR_DEFAULT_DESCRIPTION || super.A_ERROR_DEFAULT_DESCRIPTION;
+    }
+};

package/src/env/env-node.ts

@@ -0,0 +1,58 @@
+import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "../constants/env.constants";
+import { A_TYPES__ContextEnvironment } from "../global/A-Context/A-Context.types";
+import { A_CONCEPT_BASE_ENV } from "./env.base";
+
+export class ENV extends A_CONCEPT_BASE_ENV {
+    // ----------------------------------------------------------
+    // A-Concept Core Environment Variables
+    // ----------------------------------------------------------
+    // These environment variables are used by A-Concept core to configure the application
+    // ----------------------------------------------------------
+    /**
+     * Name of the application
+     * 
+     * DEFAULT value is 'a-concept'
+     * 
+     * [!] Provided name will be used for all aseids in the application by default
+     */
+    static get A_CONCEPT_NAME() {
+        return process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME] || super.A_CONCEPT_NAME
+    }
+    /**
+     * Root scope of the application
+     * 
+     * DEFAULT value is 'root'
+     * 
+     * [!] Provided name will be used for all aseids in the application by default
+     */
+    static get A_CONCEPT_ROOT_SCOPE() {
+        return process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] || super.A_CONCEPT_ROOT_SCOPE;
+    }
+    /**
+     * Environment of the application e.g. development, production, staging
+     */
+    static get A_CONCEPT_ENVIRONMENT() {
+        return process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ENVIRONMENT] || super.A_CONCEPT_ENVIRONMENT;
+    }
+    /**
+     * Runtime environment of the application e.g. browser, node
+     */
+    static get A_CONCEPT_RUNTIME_ENVIRONMENT():A_TYPES__ContextEnvironment {
+        return  'server';
+    }
+
+    /**
+     * Root folder of the application
+     * [!] Automatically set by A-Concept when the application starts
+     */
+    static get A_CONCEPT_ROOT_FOLDER() {
+        return process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_FOLDER] || super.A_CONCEPT_ROOT_FOLDER;
+    }
+
+    /**
+     * Allows to define a default error description for errors thrown without a description
+     */
+    static get A_ERROR_DEFAULT_DESCRIPTION() {
+        return process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_ERROR_DEFAULT_DESCRIPTION] || super.A_ERROR_DEFAULT_DESCRIPTION;
+    }
+} 

package/src/env/env.base.ts

@@ -0,0 +1,56 @@
+import { A_TYPES__ContextEnvironment } from "../global/A-Context/A-Context.types";
+
+export class A_CONCEPT_BASE_ENV {
+  // ----------------------------------------------------------
+  // A-Concept Core Environment Variables
+  // ----------------------------------------------------------
+  // These environment variables are used by A-Concept core to configure the application
+  // ----------------------------------------------------------
+  /**
+   * Name of the application
+   * 
+   * DEFAULT value is 'a-concept'
+   * 
+   * [!] Provided name will be used for all aseids in the application by default
+   */
+  static get A_CONCEPT_NAME() {
+    return "a-concept";
+  }
+  /**
+   * Root scope of the application
+   * 
+   * DEFAULT value is 'root'
+   * 
+   * [!] Provided name will be used for all aseids in the application by default
+   */
+  static get A_CONCEPT_ROOT_SCOPE() {
+    return "root";
+  }
+  /**
+   * Environment of the application e.g. development, production, staging
+   */
+  static get A_CONCEPT_ENVIRONMENT() {
+    return "production";
+  }
+  /**
+   * Runtime environment of the application e.g. browser, node
+   */
+  static get A_CONCEPT_RUNTIME_ENVIRONMENT():A_TYPES__ContextEnvironment {
+    return "unknown";
+  }
+
+  /**
+   * Root folder of the application
+   * [!] Automatically set by A-Concept when the application starts
+   */
+  static get A_CONCEPT_ROOT_FOLDER() {
+    return "/app";
+  }
+
+  /**
+   * Allows to define a default error description for errors thrown without a description
+   */
+  static get A_ERROR_DEFAULT_DESCRIPTION() {
+    return "If you see this error please let us know.";
+  }
+} 

package/src/env/global.browser.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeEnv } from "./env.base";
+
+declare global {
+    interface Window {
+        __A_CONCEPT_ENVIRONMENT_ENV__?: Partial<RuntimeEnv> & {
+        };
+    }
+}

package/src/env/index.browser.ts

@@ -0,0 +1 @@
+export { ENV } from "./env-browser";

package/src/env/index.node.ts

@@ -0,0 +1 @@
+export { ENV } from "./env-node";

package/src/global/A-Context/A-Context.class.ts

@@ -22,7 +22,6 @@ import { A_ContainerMeta } from "../A-Container/A-Container.meta";
 import { A_Entity } from "../A-Entity/A-Entity.class";
 import { A_EntityMeta } from "../A-Entity/A-Entity.meta";
 import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
-import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/env.constants";
 import { A_TYPES__EntityMetaKey } from "../A-Entity/A-Entity.constants";
 import { A_TYPES__ContainerMetaKey } from "../A-Container/A-Container.constants";
 import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.constants";
@@ -40,6 +39,7 @@ import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 import { A_TYPES__Fragment_Constructor } from "../A-Fragment/A-Fragment.types";
 import { A_Dependency } from "../A-Dependency/A-Dependency.class";
 import { A_TYPES__Ctor } from "@adaas/a-concept/types/A_Common.types";
+import { ENV } from "@adaas/a-concept/env";
 
 
 
@@ -53,7 +53,7 @@ export class A_Context {
      * [!] If environment variable is not set, it will default to 'a-concept'
      */
     static get concept() {
-        return process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME] || 'a-concept';
+        return ENV.A_CONCEPT_NAME || 'a-concept';
     }
     /**
      * Root scope of the application from environment variable A_CONCEPT_ROOT_SCOPE
@@ -66,18 +66,10 @@ export class A_Context {
     /**
      * Environment the application is running in.
      * Can be either 'server' or 'browser'.
-     * [!] Determined by checking if 'window' object is available.
+     * [!] Determined by environment variable A_CONCEPT_RUNTIME_ENVIRONMENT that comes from the build tool or is set manually in the environment.
      */
     static get environment(): A_TYPES__ContextEnvironment {
-        let testEnvironment: A_TYPES__ContextEnvironment = 'browser';
-
-        try {
-            testEnvironment = window.location ? 'browser' : 'server';
-        } catch (error) {
-            testEnvironment = 'server';
-        }
-
-        return testEnvironment;
+        return ENV.A_CONCEPT_RUNTIME_ENVIRONMENT
     }
 
     /**
@@ -129,13 +121,7 @@ export class A_Context {
      * [!] This class should not be instantiated directly. Use A_Context.getInstance() instead.
      */
     private constructor() {
-        let name = 'root';
-
-        if (A_Context.environment === 'server')
-            name = process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] || 'root';
-
-        if (A_Context.environment === 'browser')
-            name = (window as any)[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] || 'root';
+        const name = String(ENV.A_CONCEPT_ROOT_SCOPE) || 'root';
 
         this._root = new A_Scope({ name });
     }
@@ -1063,13 +1049,7 @@ export class A_Context {
 
         instance._registry = new WeakMap();
 
-        let name = 'root';
-
-        if (A_Context.environment === 'server')
-            name = process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] || 'root';
-
-        if (A_Context.environment === 'browser')
-            name = (window as any)[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] || 'root';
+        const name = String(ENV.A_CONCEPT_ROOT_SCOPE) || 'root';
 
         instance._root = new A_Scope({ name });
     }

package/src/global/A-Error/A_Error.class.ts

@@ -10,7 +10,7 @@ import { A_FormatterHelper } from '@adaas/a-concept/helpers/A_Formatter.helper';
 import { A_Context } from '../A-Context/A-Context.class';
 import { A_TypeGuards } from '@adaas/a-concept/helpers/A_TypeGuards.helper';
 import { ASEID } from '../ASEID/ASEID.class';
-import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from '@adaas/a-concept/constants/env.constants';
+import { ENV } from '@adaas/a-concept/env';
 
 
 export class A_Error<
@@ -286,7 +286,7 @@ export class A_Error<
      * [!] Note: This description is intended to provide more context about the error and can be used for debugging or logging purposes
      */
     get description(): string {
-        return this._description || process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_ERROR_DEFAULT_DESCRIPTION] || A_CONSTANTS__ERROR_DESCRIPTION;
+        return this._description || String(ENV.A_ERROR_DEFAULT_DESCRIPTION) || A_CONSTANTS__ERROR_DESCRIPTION;
     }
     /**
      * Returns the original error if any

package/src/global/A-Scope/A-Scope.class.ts

@@ -1814,6 +1814,13 @@ export class A_Scope<
                 this._components.delete(param1.constructor as _ComponentType[number]);
                 A_Context.deregister(param1);
 
+                const ctor = param1.constructor as _ComponentType[number];
+
+                const hasComponent = this._components.has(ctor);
+                if (!hasComponent) {
+                    this.allowedComponents.delete(ctor);
+                }
+
                 break;
             }
             // 3) In case when it's a A-Entity instance
@@ -1821,14 +1828,28 @@ export class A_Scope<
 
                 this._entities.delete(param1.aseid.toString());
                 A_Context.deregister(param1);
+
+                const ctor = param1.constructor as _EntityType[number];
+
+                const hasEntity = Array.from(this._entities.values()).some(entity => entity instanceof ctor);
+                if (!hasEntity) {
+                    this.allowedEntities.delete(ctor);
+                }
+
                 break;
             }
             // 4) In case when it's a A-Fragment instance
             case A_TypeGuards.isFragmentInstance(param1): {
-
                 this._fragments.delete(param1.constructor as A_TYPES__Fragment_Constructor<_FragmentType[number]>);
                 A_Context.deregister(param1);
 
+                const ctor = param1.constructor as A_TYPES__Fragment_Constructor<_FragmentType[number]>;
+
+                const hasFragment = Array.from(this._fragments.values()).some(fragment => fragment instanceof ctor);
+                if (!hasFragment) {
+                    this.allowedFragments.delete(ctor);
+                }
+
                 break;
             }
             // 5) In case when it's a A-Error instance
@@ -1836,6 +1857,14 @@ export class A_Scope<
 
                 this._errors.delete(param1.code);
                 A_Context.deregister(param1);
+
+                const ctor = param1.constructor as _ErrorType[number];
+
+                const hasError = Array.from(this._errors.values()).some(error => error instanceof ctor);
+                if (!hasError) {
+                    this.allowedErrors.delete(ctor);
+                }
+
                 break;
             }
 
@@ -1850,16 +1879,40 @@ export class A_Scope<
             // 8) In case when it's a A-Fragment constructor
             case A_TypeGuards.isFragmentConstructor(param1): {
                 this.allowedFragments.delete(param1 as A_TYPES__Fragment_Constructor<_FragmentType[number]>);
+                // and then deregister all instances of this fragment
+                Array.from(this._fragments.entries()).forEach(([ctor, instance]) => {
+                    if (A_CommonHelper.isInheritedFrom(ctor, param1)) {
+                        this._fragments.delete(ctor);
+                        A_Context.deregister(instance);
+                    }
+                });
+
                 break;
             }
             // 9) In case when it's a A-Entity constructor
             case A_TypeGuards.isEntityConstructor(param1): {
                 this.allowedEntities.delete(param1 as _EntityType[number]);
+                //  and then deregister all instances of this entity
+                Array.from(this._entities.entries()).forEach(([aseid, instance]) => {
+                    if (A_CommonHelper.isInheritedFrom(instance.constructor, param1)) {
+                        this._entities.delete(aseid);
+                        A_Context.deregister(instance);
+                    }
+                });
+
                 break;
             }
             // 10) In case when it's a A-Error constructor
             case A_TypeGuards.isErrorConstructor(param1): {
                 this.allowedErrors.delete(param1 as _ErrorType[number]);
+                // and then deregister all instances of this error
+                Array.from(this._errors.entries()).forEach(([code, instance]) => {
+                    if (A_CommonHelper.isInheritedFrom(instance.constructor, param1)) {
+                        this._errors.delete(code);
+                        A_Context.deregister(instance);
+                    }
+                });
+
                 break;
             }
 
@@ -1875,6 +1928,7 @@ export class A_Scope<
                     `Cannot deregister ${componentName} from the scope ${this.name}`
                 );
         }
+
     }
 
     /**

package/tests/A-Scope.test.ts

@@ -705,4 +705,109 @@ describe('A-Scope tests', () => {
         expect(resolvedA).toBeInstanceOf(MyEntity_B);
         expect(resolvedA?.name).toBe('Entity1');
     });
+
+    it('Should deregister entities properly', async () => {
+
+        class MyEntity extends A_Entity { }
+
+        class MyFragment extends A_Fragment { }
+
+        class MyComponent extends A_Component { }
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+
+
+        const entity = new MyEntity();
+        const fragment = new MyFragment();
+
+        scope.register(entity);
+        scope.register(fragment);
+        scope.register(MyComponent);
+
+        expect(scope.has(MyEntity)).toBe(true);
+        expect(scope.has(MyFragment)).toBe(true);
+        expect(scope.has(MyComponent)).toBe(true);
+
+        scope.deregister(entity);
+        scope.deregister(fragment);
+        scope.deregister(MyComponent);
+
+        expect(scope.has(MyEntity)).toBe(false);
+        expect(scope.has(MyFragment)).toBe(false);
+        expect(scope.has(MyComponent)).toBe(false);
+    });
+
+    it('Should deregister all entities by class', async () => {
+
+        class BaseEntity extends A_Entity { }
+
+        class MyEntityA extends A_Entity { }
+        class MyEntityB extends BaseEntity { }
+
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+
+
+        const entityA1 = new MyEntityA();
+        const entityA2 = new MyEntityA();
+        const entityB1 = new MyEntityB();
+
+        scope.register(entityA1);
+        scope.register(entityA2);
+        scope.register(entityB1);
+
+        expect(scope.resolveAll(MyEntityA).length).toBe(2);
+        expect(scope.resolveAll(BaseEntity).length).toBe(1);
+
+        scope.deregister(MyEntityA);
+
+        expect(scope.resolveAll(MyEntityA).length).toBe(0);
+        expect(scope.resolveAll(BaseEntity).length).toBe(1);
+
+        const entityB2 = new MyEntityB();
+        scope.register(entityB2);
+
+        expect(scope.resolveAll(BaseEntity).length).toBe(2);
+
+        scope.deregister(BaseEntity);
+
+        expect(scope.resolveAll(BaseEntity).length).toBe(0);
+    });
+    it('Should register/deregister fragments with the same names', async () => {
+
+        class MyFragment extends A_Fragment {
+
+            array: string[] = [];
+
+            constructor(name: string) {
+                super({ name });
+            }
+        }
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+        const fragmentA1 = new MyFragment('fragmentA');
+
+        scope.register(fragmentA1);
+
+        expect(scope.has(MyFragment)).toBe(true);
+        expect(scope.resolve(MyFragment)).toBe(fragmentA1);
+
+        scope.deregister(fragmentA1);
+
+        fragmentA1.array.push('newData');
+
+
+        expect(scope.has(MyFragment)).toBe(false);
+
+        const fragmentA2 = new MyFragment('fragmentA');
+
+        scope.register(fragmentA2);
+
+        expect(scope.has(MyFragment)).toBe(true);
+        expect(scope.resolve(MyFragment)).toBe(fragmentA2);
+        expect(fragmentA2.array.length).toBe(0);
+    });
 });

package/tsconfig.json

@@ -31,6 +31,7 @@
     ],
     "paths": {
       "@adaas/a-concept/constants/*": ["src/constants/*"],
+      "@adaas/a-concept/env": ["src/env/index.node.ts"],
       "@adaas/a-concept/global/*": ["src/global/*"],
       "@adaas/a-concept/types/*": ["src/types/*"],
       "@adaas/a-concept/helpers/*": ["src/helpers/*"],
@@ -50,7 +51,8 @@
     "src/**/*",
     "tests/**/*", 
     "examples/**/*", 
-    "src/index.ts"  
+    "src/index.ts",
+    "src/env/global.browser.d.ts"  
   ],
   "exclude": [
     "node_modules/**/*",

package/tsup.config.ts

@@ -1,32 +1,95 @@
 import { defineConfig } from "tsup";
 
-export default defineConfig((options) => ({
-  entry: ["src/index.ts"],
-  format: ["esm", "cjs"],
-  dts: true,
-  clean: !options.watch,
-  sourcemap: true,
-  target: "es2020",
-  minify: !options.watch,
-  treeshake: "recommended",
-  skipNodeModulesBundle: true,
-  splitting: false,
-  silent: false,
-  platform: "neutral",
-  // Add hash to filenames for cache busting in production builds
-  outExtension({ format }) {
-    return {
-      js: format === "esm" ? `.mjs` : `.cjs`,
-    };
-  },
-  // Extra optimization options (for 2025 esbuild)
-  esbuildOptions(options) {
-    options.keepNames = true; // Preserve class/function names for better debugging
-    options.charset = "utf8";
+export default defineConfig([
+  /**
+   * ============================
+   * Browser build
+   * ============================
+   *
+   * Produces:
+   *   dist/browser/index.mjs
+   *   dist/browser/env.mjs
+   *
+   * - No Node globals
+   * - No `process`
+   * - Used by bundlers (Vite, Webpack, Rollup)
+   */
+  {
+    entry: {
+      // Public library entry
+      index: "src/index.ts",
+
+      // Public env entry (browser implementation)
+      env: "src/env/index.browser.ts",
+    },
+
+    // Output directory for browser bundle
+    outDir: "dist/browser",
+
+    // Browser consumers expect ESM
+    format: ["esm"],
+
+    // Tells esbuild this is browser-safe code
+    platform: "browser",
+
+    // Reasonable baseline for modern browsers
+    target: "es2020",
+
+    // Smaller bundles
+    treeshake: true,
+
+    // Useful for debugging in bundlers
+    sourcemap: true,
+
+    // Emit .d.ts files
+    dts: true,
+
+    /**
+     * IMPORTANT:
+     * We do NOT define process.env here.
+     * Browser env must never reference process at all.
+     */
   },
 
-  // Enable minification for output size (production only)
-  minifyWhitespace: !options.watch,
-  minifyIdentifiers: !options.watch,
-  minifySyntax: !options.watch,
-}));
+  /**
+   * ============================
+   * Node build
+   * ============================
+   *
+   * Produces:
+   *   dist/node/index.mjs
+   *   dist/node/index.cjs
+   *   dist/node/env.mjs
+   *   dist/node/env.cjs
+   *
+   * - Can use process.env
+   * - Used by Node (ESM + CJS)
+   */
+  {
+    entry: {
+      // Same public API as browser
+      index: "src/index.ts",
+
+      // Node-specific env implementation
+      env: "src/env/index.node.ts",
+    },
+
+    // Output directory for node bundle
+    outDir: "dist/node",
+
+    // Support both module systems
+    format: ["esm", "cjs"],
+
+    // Enables Node globals and resolution
+    platform: "node",
+
+    // Node 16+ safe baseline
+    target: "es2020",
+
+    treeshake: true,
+    sourcemap: true,
+
+    // Emit .d.ts files (shared shape)
+    dts: true,
+  },
+]);