@decohere/forge 0.0.1-dev.130 → 0.0.1-dev.131

package/README.md

@@ -6,6 +6,8 @@ Build system (SWC). `forge build --configuration debug` rewrites workspace impor
 
 `forge build` transpiles without waiting for a whole-workspace typecheck. Run `forge typecheck` independently (including in the background) and require it before shipping. Why executable tests come before static contracts: [testing principles](../../docs/testing/#executable-behavior-before-type-contracts).
 
+With no `tsconfig.json`, `forge typecheck` reads a project as plain `tsc` would, with decorators on because forge and flux compile them by default. Add a `tsconfig.json` to choose your own options; forge then limits `lib` to ES2022 and turns off `@types` discovery unless it sets them (`types: ["node"]`).
+
 ## Debug path aliases (not `node_modules` links)
 
 Forge debug (`aliasPaths: true`) asks the workspace package for a map of `package.json` `name` → source `main` (`Workspace.getPackageAliases`) and feeds it to SWC as `jsc.paths`. Flux uses the same map in its resolve hook only, and compiles without `jsc.paths` or `resolveFully`, so imports are resolved once.

package/commonjs/src/services/incremental-watch.js

@@ -8,9 +8,9 @@ Object.defineProperty(exports, "IncrementalWatch", {
         return IncrementalWatch;
     }
 });
-const _rxjs = require("rxjs");
+const _system = require("@decohere/core/system");
 class IncrementalWatch {
-    #results = new _rxjs.Subject();
+    #results = new _system.Subject();
     get results$() {
         return this.#results.asObservable();
     }

package/commonjs/src/services/ts-compiler-options.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "tsCompilerOptions", {
+    enumerable: true,
+    get: function() {
+        return tsCompilerOptions;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _typescript = /*#__PURE__*/ _interop_require_default(require("typescript"));
+const _errors = require("../errors.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const host = {
+    ..._typescript.default.sys,
+    readFile: (file)=>_nodefs.default.readFileSync(file, {
+            encoding: "utf8"
+        }),
+    readDirectory: (directoryName)=>_nodefs.default.readdirSync(directoryName, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory()).map((entry)=>entry.name)
+};
+/**
+ * No tsconfig means no choices made, so this reads the project as plain tsc would: it clears
+ * the `lib` and `types` limits forge sets to keep monorepos fast, which a project opts out of
+ * in its tsconfig. Decorators are on because forge and flux compile them by default.
+ */ const DEFAULT_TS_OPTIONS = {
+    emitDeclarationOnly: true,
+    declaration: true,
+    lib: undefined,
+    types: undefined,
+    experimentalDecorators: true
+};
+function tsCompilerOptions(tsconfig) {
+    const { filePath } = tsconfig;
+    if (filePath == null) return {
+        ...DEFAULT_TS_OPTIONS
+    };
+    const result = _typescript.default.parseConfigFileTextToJson(filePath, _nodefs.default.readFileSync(filePath, "utf8"));
+    if (result.error) {
+        throw new _errors.ForgeError(`Error parsing ${filePath}. ${_typescript.default.flattenDiagnosticMessageText(result.error.messageText, "\n")}`);
+    }
+    return _typescript.default.parseJsonConfigFileContent(result.config, host, _nodepath.default.dirname(filePath)).options;
+}

package/commonjs/src/services/type-emission-program.js

@@ -42,7 +42,7 @@ class TypeEmissionProgram {
         this.#targetsByDtsPath = targets.byDtsPath;
         this.#targetsByEmittedPath = targets.byEmittedPath;
         this.#host = hostFactory;
-        this.#compilerOptions = group[0].tsconfig.compilerOptions;
+        this.#compilerOptions = group[0].compilerOptions;
         this.#requiredOptions = requiredOptions;
         this.#allFiles = group.flatMap(({ files })=>files);
         this.#compilerHost = hostFactory.createHost(this.#compilerOptions);

package/commonjs/src/services/type-emitter.js

@@ -28,6 +28,7 @@ const _io = require("@decohere/devkit/io");
 require("../extensions/project.extensions.js");
 const _incrementalwatch = require("./incremental-watch.js");
 const _outputcache = require("./output-cache.js");
+const _tscompileroptions = require("./ts-compiler-options.js");
 const _tsprogramhost = require("./ts-program-host.js");
 const _typeemissionprogram = require("./type-emission-program.js");
 const _buildtargettype = require("../types/build-target.type.js");
@@ -121,17 +122,21 @@ class TypeEmitter {
             return [];
         }
         // Pre-fetch all files and tsconfigs in parallel across all projects
-        const projectData = await Promise.all(projects.map(async (proj)=>({
+        const projectData = await Promise.all(projects.map(async (proj)=>{
+            const tsconfig = await proj.getTsConfig();
+            return {
                 project: proj,
                 files: await proj.getAllFiles(),
-                tsconfig: await proj.getTsConfig()
-            })));
+                tsconfig,
+                compilerOptions: (0, _tscompileroptions.tsCompilerOptions)(tsconfig)
+            };
+        }));
         // Group projects by the resolved compiler options that affect the compiler
         // host (lib loading, module resolution, path aliases). Projects sharing the
         // same resolved values get one shared host AND one shared program — all their
         // files are compiled together, matching v1's single-program approach which
         // avoids re-parsing lib/node_modules .d.ts files per project.
-        const groups = Map.groupBy(projectData, ({ tsconfig })=>this.#host.hostKey(tsconfig.compilerOptions));
+        const groups = Map.groupBy(projectData, ({ compilerOptions })=>this.#host.hostKey(compilerOptions));
         const requiredCompilerOptions = options.requiredCompilerOptions ?? REQUIRED_TYPE_EMITTER_OPTIONS;
         return [
             ...groups.values()

package/commonjs/src/transpile/index.js

@@ -0,0 +1,30 @@
+// What compiling one file needs (flux, the vitest plugin), without forge's commands: those
+// load the TypeScript compiler, which a plain `flux run` never uses.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get BuildTargets () {
+        return _buildtargettype.BuildTargets;
+    },
+    get SwcTranspiler () {
+        return _swctranspiler.SwcTranspiler;
+    },
+    get createWorkspace () {
+        return _createworkspace.createWorkspace;
+    },
+    get transpileCache () {
+        return _transpilecache.transpileCache;
+    }
+});
+const _createworkspace = require("../create-workspace.js");
+const _swctranspiler = require("../services/swc-transpiler.js");
+const _transpilecache = require("../services/transpile-cache.js");
+const _buildtargettype = require("../types/build-target.type.js");

package/es6/src/services/incremental-watch.js

@@ -1,4 +1,4 @@
-import { Subject } from "rxjs";
+import { Subject } from "@decohere/core/system";
 /**
  * Runs a transformer's handler for every workspace file change and emits what it built. The
  * handler invalidates the transformer's own caches, rebuilds, and returns the responses (empty

package/es6/src/services/ts-compiler-options.js

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import { ForgeError } from "../errors.js";
+const host = {
+    ...ts.sys,
+    readFile: (file)=>fs.readFileSync(file, {
+            encoding: "utf8"
+        }),
+    readDirectory: (directoryName)=>fs.readdirSync(directoryName, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory()).map((entry)=>entry.name)
+};
+/**
+ * No tsconfig means no choices made, so this reads the project as plain tsc would: it clears
+ * the `lib` and `types` limits forge sets to keep monorepos fast, which a project opts out of
+ * in its tsconfig. Decorators are on because forge and flux compile them by default.
+ */ const DEFAULT_TS_OPTIONS = {
+    emitDeclarationOnly: true,
+    declaration: true,
+    lib: undefined,
+    types: undefined,
+    experimentalDecorators: true
+};
+/**
+ * A project's compiler options as the TypeScript compiler parses its `tsconfig.json`: what
+ * type emission needs (enums, every option, tsc's own defaults). The workspace reads only
+ * what transpiling needs, without loading the compiler.
+ */ export function tsCompilerOptions(tsconfig) {
+    const { filePath } = tsconfig;
+    if (filePath == null) return {
+        ...DEFAULT_TS_OPTIONS
+    };
+    const result = ts.parseConfigFileTextToJson(filePath, fs.readFileSync(filePath, "utf8"));
+    if (result.error) {
+        throw new ForgeError(`Error parsing ${filePath}. ${ts.flattenDiagnosticMessageText(result.error.messageText, "\n")}`);
+    }
+    return ts.parseJsonConfigFileContent(result.config, host, path.dirname(filePath)).options;
+}

package/es6/src/services/type-emission-program.js

@@ -27,7 +27,7 @@ export class TypeEmissionProgram {
         this.#targetsByDtsPath = targets.byDtsPath;
         this.#targetsByEmittedPath = targets.byEmittedPath;
         this.#host = hostFactory;
-        this.#compilerOptions = group[0].tsconfig.compilerOptions;
+        this.#compilerOptions = group[0].compilerOptions;
         this.#requiredOptions = requiredOptions;
         this.#allFiles = group.flatMap(({ files })=>files);
         this.#compilerHost = hostFactory.createHost(this.#compilerOptions);

package/es6/src/services/type-emitter.js

@@ -13,6 +13,7 @@ import { WatchEvents } from "@decohere/devkit/io";
 import "../extensions/project.extensions.js";
 import { IncrementalWatch } from "./incremental-watch.js";
 import { OutputCache } from "./output-cache.js";
+import { tsCompilerOptions } from "./ts-compiler-options.js";
 import { TsProgramHost } from "./ts-program-host.js";
 import { TypeEmissionProgram } from "./type-emission-program.js";
 import { BuildTargets } from "../types/build-target.type.js";
@@ -111,17 +112,21 @@ export class TypeEmitter {
             return [];
         }
         // Pre-fetch all files and tsconfigs in parallel across all projects
-        const projectData = await Promise.all(projects.map(async (proj)=>({
+        const projectData = await Promise.all(projects.map(async (proj)=>{
+            const tsconfig = await proj.getTsConfig();
+            return {
                 project: proj,
                 files: await proj.getAllFiles(),
-                tsconfig: await proj.getTsConfig()
-            })));
+                tsconfig,
+                compilerOptions: tsCompilerOptions(tsconfig)
+            };
+        }));
         // Group projects by the resolved compiler options that affect the compiler
         // host (lib loading, module resolution, path aliases). Projects sharing the
         // same resolved values get one shared host AND one shared program — all their
         // files are compiled together, matching v1's single-program approach which
         // avoids re-parsing lib/node_modules .d.ts files per project.
-        const groups = Map.groupBy(projectData, ({ tsconfig })=>this.#host.hostKey(tsconfig.compilerOptions));
+        const groups = Map.groupBy(projectData, ({ compilerOptions })=>this.#host.hostKey(compilerOptions));
         const requiredCompilerOptions = options.requiredCompilerOptions ?? REQUIRED_TYPE_EMITTER_OPTIONS;
         return [
             ...groups.values()

package/es6/src/transpile/index.js

@@ -0,0 +1,6 @@
+// What compiling one file needs (flux, the vitest plugin), without forge's commands: those
+// load the TypeScript compiler, which a plain `flux run` never uses.
+export { createWorkspace } from "../create-workspace.js";
+export { SwcTranspiler } from "../services/swc-transpiler.js";
+export { transpileCache } from "../services/transpile-cache.js";
+export { BuildTargets } from "../types/build-target.type.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/forge",
-  "version": "0.0.1-dev.130",
+  "version": "0.0.1-dev.131",
   "description": "TypeScript monorepo build system — zero config, fast compilation, streamlined developer workflow",
   "keywords": [
     "typescript",
@@ -28,6 +28,11 @@
       "import": "./es6/src/index.js",
       "require": "./commonjs/src/index.js"
     },
+    "./transpile": {
+      "types": "./types/src/transpile/index.d.ts",
+      "import": "./es6/src/transpile/index.js",
+      "require": "./commonjs/src/transpile/index.js"
+    },
     "./vitest": {
       "types": "./types/src/vitest/index.d.ts",
       "import": "./es6/src/vitest/index.js",
@@ -38,15 +43,14 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/core": "0.0.1-dev.130",
-    "@decohere/crucible": "0.0.1-dev.130",
-    "@decohere/devkit": "0.0.1-dev.130",
-    "@decohere/scribe": "0.0.1-dev.130",
-    "@decohere/workspace": "0.0.1-dev.130",
+    "@decohere/core": "0.0.1-dev.131",
+    "@decohere/crucible": "0.0.1-dev.131",
+    "@decohere/devkit": "0.0.1-dev.131",
+    "@decohere/scribe": "0.0.1-dev.131",
+    "@decohere/workspace": "0.0.1-dev.131",
     "@swc/core": "^1.11.11",
     "async": "^3.2.6",
     "parse-imports": "^2.2.1",
-    "rxjs": "^7.8.2",
     "typescript": "^6.0.3"
   },
   "devDependencies": {}

package/types/src/services/incremental-watch.d.ts

@@ -1,5 +1,5 @@
 import type { ProjectFileEvent, Workspace } from "@decohere/workspace";
-import type { Observable } from "rxjs";
+import type { Observable } from "@decohere/core/system";
 import type { TransformResponse } from "../types/transform-response.model.js";
 /**
  * Runs a transformer's handler for every workspace file change and emits what it built. The

package/types/src/services/swc-transpiler.d.ts

@@ -1,7 +1,7 @@
 import { type Project, type Tsconfig, type Workspace } from "@decohere/workspace";
 import type { FileEx } from "@decohere/core/io";
 import { type Options } from "@swc/core";
-import type { Observable } from "rxjs";
+import type { Observable } from "@decohere/core/system";
 import { type BuildTarget, type TranspileTarget } from "../types/build-target.type.js";
 import "../extensions/project.extensions.js";
 import type { SwcConfig } from "../types/swc-config.type.js";

package/types/src/services/ts-compiler-options.d.ts

@@ -0,0 +1,8 @@
+import type { Tsconfig } from "@decohere/workspace";
+import ts from "typescript";
+/**
+ * A project's compiler options as the TypeScript compiler parses its `tsconfig.json`: what
+ * type emission needs (enums, every option, tsc's own defaults). The workspace reads only
+ * what transpiling needs, without loading the compiler.
+ */
+export declare function tsCompilerOptions(tsconfig: Tsconfig): ts.CompilerOptions;

package/types/src/services/type-emission-program.d.ts

@@ -7,6 +7,8 @@ export type TypeProgramProject = {
     project: Project;
     files: FileEx[];
     tsconfig: Tsconfig;
+    /** The compiler's parse of `tsconfig`. */
+    compilerOptions: ts.CompilerOptions;
 };
 export declare class TypeEmissionProgram {
     #private;

package/types/src/services/type-emitter.d.ts

@@ -1,6 +1,6 @@
 import type { Project, Workspace } from "@decohere/workspace";
 import type { FileEx } from "@decohere/core/io";
-import type { Observable } from "rxjs";
+import type { Observable } from "@decohere/core/system";
 import type ts from "typescript";
 import "../extensions/project.extensions.js";
 import { type BuildTarget } from "../types/build-target.type.js";

package/types/src/transpile/index.d.ts

@@ -0,0 +1,6 @@
+export { createWorkspace } from "../create-workspace.js";
+export type { TranspileOptions } from "../services/swc-transpiler.js";
+export { SwcTranspiler } from "../services/swc-transpiler.js";
+export { transpileCache } from "../services/transpile-cache.js";
+export type { BuildTarget, TranspileTarget } from "../types/build-target.type.js";
+export { BuildTargets } from "../types/build-target.type.js";

package/types/src/types/transformer.type.d.ts

@@ -1,6 +1,6 @@
 import type { Project, Workspace } from "@decohere/workspace";
 import type { FileEx } from "@decohere/core/io";
-import type { Observable } from "rxjs";
+import type { Observable } from "@decohere/core/system";
 import type { BuildTarget } from "../types/build-target.type.js";
 import type { TransformResponse } from "./transform-response.model.js";
 export declare const TransformerKey: unique symbol;