@effected/tsconfig-json 0.1.0 → 0.2.1

package/JsxConfig.js

@@ -0,0 +1,41 @@
+import { Option, Schema } from "effect";
+
+//#region src/JsxConfig.ts
+/**
+* The JSX transform configuration a `jsx` compiler option implies: which
+* runtime (`"automatic"` for `react-jsx` / `react-jsxdev`, `"classic"` for
+* `react`) and, for the automatic runtime, the import source the transform
+* emits (`jsxImportSource`, defaulting to `"react"` per tsc).
+*
+* @public
+*/
+var JsxConfig = class JsxConfig extends Schema.Class("JsxConfig")({
+	/** The JSX transform runtime: `"automatic"` (`react-jsx` / `react-jsxdev`) or `"classic"` (`react`). */
+	runtime: Schema.Literals(["automatic", "classic"]),
+	/** The automatic runtime's import source (`jsxImportSource`, defaulted to `"react"`); absent for classic. */
+	importSource: Schema.optionalKey(Schema.String)
+}) {
+	/**
+	* Project decoded compiler options to their implied JSX transform
+	* configuration. `"react-jsx"` and `"react-jsxdev"` yield the automatic
+	* runtime with `importSource` taken from `jsxImportSource` (defaulting to
+	* `"react"`, tsc's own default); `"react"` yields the classic runtime with
+	* no `importSource`. `"preserve"`, `"react-native"` and an absent `jsx`
+	* yield `Option.none()` — JSX is left untransformed (or absent entirely),
+	* so there is nothing for a bundler to configure.
+	*/
+	static fromCompilerOptions(options) {
+		switch (options.jsx) {
+			case "react-jsx":
+			case "react-jsxdev": return Option.some(JsxConfig.make({
+				runtime: "automatic",
+				importSource: options.jsxImportSource ?? "react"
+			}));
+			case "react": return Option.some(JsxConfig.make({ runtime: "classic" }));
+			default: return Option.none();
+		}
+	}
+};
+
+//#endregion
+export { JsxConfig };

package/README.md

@@ -37,6 +37,8 @@ pnpm add @effected/tsconfig-json @effected/jsonc @effected/walker effect
 
 Requires Node.js >=24.11.0. `effect` v4, `@effected/jsonc` and `@effected/walker` are peer dependencies; there are no runtime dependencies of its own.
 
+All `@effected/*` packages are ESM-only: the exports maps publish only `import` conditions, so `require()` — including tools that resolve in CJS mode — fails with Node's `ERR_PACKAGE_PATH_NOT_EXPORTED` rather than loading a CJS build that does not exist. Import from an ES module.
+
 All IO goes through `FileSystem` and `Path` from `effect` core, not a platform package, so a consumer provides them once at the edge (`@effect/platform-node` on Node, `@effect/platform-bun` on Bun) and a test provides `Path.layer` and `FileSystem.layerNoop` straight from core with nothing else installed.
 
 ## Quick start
@@ -58,6 +60,8 @@ console.log(resolved.compilerOptions);
 // the merged options after folding the whole chain — later configs win per field, paths replaced wholesale
 ```
 
+`TsconfigLoader.compilerOptions("./tsconfig.json")` is the same pipeline projected down to the merged options, for when the effective options are all you want.
+
 Find the nearest config first when you only have a starting directory:
 
 ```ts
@@ -80,15 +84,37 @@ console.log(PortableTsconfig.make(resolved).compilerOptions.noEmit);
 // true — always forced, whatever the source config declared
 ```
 
+## Synchronous loading
+
+Bundler plugin hooks and config factories often cannot await. `TsconfigLoaderSync` runs the unchanged loader pipeline synchronously over file and path operations you supply — the package still imports no `node:*` module, and Node's built-ins satisfy the operations directly:
+
+```ts
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+import { TsconfigLoaderSync } from "@effected/tsconfig-json";
+
+const options = {
+  fileSystem: { exists: existsSync, readFile: (p: string) => readFileSync(p, "utf8") },
+  path, // node:path satisfies SyncPath verbatim; path.win32 / path.posix force a convention
+};
+
+const compilerOptions = TsconfigLoaderSync.compilerOptions("./tsconfig.json", options);
+// the merged options for the full extends chain — the same result TsconfigLoader.resolve computes
+```
+
+`load` and `resolve` have the same synchronous forms. Failures are the async pipeline's own typed errors thrown as themselves — `TsconfigParseError`, `TsconfigExtendsError` or a `PlatformError` wrapping whatever your `readFile` threw — never a fiber-failure wrapper.
+
 ## Features
 
 - `TsconfigJson` / `TsconfigJsonFromString` — the document schema and its JSONC string codec. Comments and trailing commas are legal in every parse; there is no JSON-strict path.
 - `CompilerOptions` — string-level schemas for `compilerOptions`: enum values decode case-insensitively and encode to canonical lowercase, and unknown or removed options survive a round trip as passthrough.
-- `TsconfigLoader.load` / `TsconfigLoader.resolve` — read and decode one config, or resolve its full `extends` chain depth-first with per-branch cycle stacks (diamond chains are legal), a depth guard and tsc's target resolution for relative, rooted and bare-specifier targets including `exports` maps.
+- `TsconfigLoader.load` / `TsconfigLoader.resolve` / `TsconfigLoader.compilerOptions` — read and decode one config, resolve its full `extends` chain depth-first with per-branch cycle stacks (diamond chains are legal), a depth guard and tsc's target resolution for relative, rooted and bare-specifier targets including `exports` maps, or project the resolved chain straight down to its merged options.
+- `TsconfigLoaderSync` — the synchronous facade for sync-only hosts: `load`, `resolve` and `compilerOptions` over consumer-supplied `{ fileSystem, path }` operations, running the same pipeline and throwing the same typed errors.
 - `ResolvedTsconfig` — the pure merge engine behind `resolve`: per-field merge semantics, path-option absolutization against the declaring config's directory, final `${configDir}` substitution and `pathsBase` provenance, with no filesystem access at all.
 - `TsconfigDiscovery.findNearest` — the nearest `tsconfig.json` (or any filename via `options.filename`) at or above a starting directory, over `@effected/walker`; one unreadable ancestor cannot hide a config above it.
 - `TsEnumCodec` — the string↔numeric enum tables as plain data with zero `typescript` imports. `encodeCompilerOptions` produces the numeric shape `ts.CompilerOptions` expects, with `lib` entries in the file-name form the compiler resolves verbatim; `decodeCompilerOptions` reverses it.
 - `PortableTsconfig.make` — an allow-list projection down to machine-independent type-semantics options, with `composite: false` and `noEmit: true` forced: the slice a virtual TypeScript environment (Twoslash, API Extractor, an in-memory language service) can safely inherit.
+- `JsxConfig.fromCompilerOptions` — the JSX transform a bundler can configure, projected from decoded options: `react-jsx` / `react-jsxdev` select the automatic runtime with its import source (defaulting to `react`, tsc's own default), `react` selects classic, and `preserve`, `react-native` or an absent `jsx` yield `Option.none()`.
 - Typed failures everywhere: a malformed file is a `TsconfigParseError` carrying its path, a broken chain is a `TsconfigExtendsError` with a `not-found` / `cycle` / `depth` / `empty` reason and the full resolution chain, and IO errors flow through as `PlatformError`. Nothing fails as a defect.
 
 ## License

package/TsconfigLoader.js

@@ -66,7 +66,7 @@ const loadAbs = (abs) => Effect.gen(function* () {
 *
 * @public
 */
-const load = (configPath) => Effect.gen(function* () {
+const load = Effect.fn("TsconfigLoader.load")(function* (configPath) {
 	const path = yield* Path.Path;
 	return yield* loadAbs(normalizeSlashes(path.resolve(configPath)));
 });
@@ -132,7 +132,7 @@ const collect = (configPath, chain) => Effect.gen(function* () {
 *
 * @public
 */
-const resolve = (configPath) => Effect.gen(function* () {
+const resolve = Effect.fn("TsconfigLoader.resolve")(function* (configPath) {
 	const path = yield* Path.Path;
 	const topAbs = normalizeSlashes(path.resolve(configPath));
 	const layers = yield* collect(topAbs, []);
@@ -145,15 +145,28 @@ const resolve = (configPath) => Effect.gen(function* () {
 	return ResolvedTsconfig.substituteConfigDir(acc, path.dirname(topAbs));
 });
 /**
+* Resolve a tsconfig.json's full `extends` chain and project out the merged
+* `compilerOptions` — a thin projection of {@link TsconfigLoader.resolve} for
+* the common "just give me the effective options" query. Same pipeline, same
+* typed failures.
+*
+* @public
+*/
+const compilerOptions = Effect.fn("TsconfigLoader.compilerOptions")(function* (configPath) {
+	return (yield* resolve(configPath)).compilerOptions;
+});
+/**
 * The tsconfig.json loader: {@link TsconfigLoader.load} reads and decodes one
 * config file, {@link TsconfigLoader.resolve} runs the full load -\> extends -\>
-* merge -\> `${configDir}` pipeline.
+* merge -\> `${configDir}` pipeline, and {@link TsconfigLoader.compilerOptions}
+* projects the resolved result down to its merged `compilerOptions`.
 *
 * @public
 */
 const TsconfigLoader = {
 	load,
-	resolve
+	resolve,
+	compilerOptions
 };
 
 //#endregion

package/TsconfigLoaderSync.js

@@ -0,0 +1,131 @@
+import { TsconfigLoader } from "./TsconfigLoader.js";
+import { Cause, Effect, Exit, FileSystem, Option, Path, PlatformError, Result } from "effect";
+
+//#region src/TsconfigLoaderSync.ts
+/** A `Path.Path` member the loader pipeline never calls: throw an informative defect if something reaches it. */
+const unsupported = (member) => {
+	throw new Error(`Path.${member} is not supported by TsconfigLoaderSync — its SyncPath adapter only carries resolve/dirname/join/isAbsolute/basename`);
+};
+/** Adapt the consumer's `SyncPath` into a core `Path.Path` service value. */
+const makePathService = (path) => Path.Path.of({
+	[Path.TypeId]: Path.TypeId,
+	get sep() {
+		return unsupported("sep");
+	},
+	basename: (p) => path.basename(p),
+	dirname: (p) => path.dirname(p),
+	extname: () => unsupported("extname"),
+	format: () => unsupported("format"),
+	fromFileUrl: () => unsupported("fromFileUrl"),
+	isAbsolute: (p) => path.isAbsolute(p),
+	join: (...segments) => path.join(...segments),
+	normalize: () => unsupported("normalize"),
+	parse: () => unsupported("parse"),
+	relative: () => unsupported("relative"),
+	resolve: (...segments) => path.resolve(...segments),
+	toFileUrl: () => unsupported("toFileUrl"),
+	toNamespacedPath: () => unsupported("toNamespacedPath")
+});
+/**
+* Adapt the consumer's `SyncFileSystem` into a core `FileSystem` service
+* value. A `readFile` throw is wrapped exactly as a platform filesystem would
+* report it: a `PlatformError` whose `SystemError` reason carries module
+* `"FileSystem"`, method `"readFileString"`, and the original throw as
+* `cause`.
+*
+* NOTE the deliberate asymmetry with `makePathService`: an unsupported `Path`
+* member throws a named defect, but an unsupported `FileSystem` member
+* inherits `FileSystem.makeNoop`'s behavior — a TYPED `NotFound` failure. If
+* a future loader change reaches for a filesystem operation not overridden
+* here, it surfaces as a spurious `NotFound` (not a crash), and this adapter
+* must be extended to cover the new operation.
+*/
+const makeFileSystemService = (fileSystem) => FileSystem.makeNoop({
+	exists: (path) => Effect.sync(() => fileSystem.exists(path)),
+	readFileString: (path) => Effect.try({
+		try: () => fileSystem.readFile(path),
+		catch: (cause) => PlatformError.systemError({
+			_tag: "Unknown",
+			module: "FileSystem",
+			method: "readFileString",
+			pathOrDescriptor: path,
+			cause
+		})
+	})
+});
+/**
+* Run one loader effect synchronously against the consumer-supplied services,
+* unwrapping the result: a typed failure is thrown as itself, a defect is
+* rethrown as-is — never a fiber-failure wrapper.
+*/
+const runWith = (options, effect) => {
+	const exit = Effect.runSyncExit(effect.pipe(Effect.provideService(FileSystem.FileSystem, makeFileSystemService(options.fileSystem)), Effect.provideService(Path.Path, makePathService(options.path))));
+	if (Exit.isSuccess(exit)) return exit.value;
+	const failure = Cause.findErrorOption(exit.cause);
+	if (Option.isSome(failure)) throw failure.value;
+	const defect = Cause.findDefect(exit.cause);
+	if (Result.isSuccess(defect)) throw defect.success;
+	throw Cause.squash(exit.cause);
+};
+/**
+* {@link TsconfigLoader.load}, synchronously: read and decode one config file
+* through the consumer-supplied operations. Throws `TsconfigParseError` or a
+* `PlatformError` — the async pipeline's exact typed failures.
+*
+* @public
+*/
+const load = (configPath, options) => runWith(options, TsconfigLoader.load(configPath));
+/**
+* {@link TsconfigLoader.resolve}, synchronously: the full load -\> extends -\>
+* merge -\> `${configDir}` pipeline through the consumer-supplied operations.
+* Throws `TsconfigParseError`, `TsconfigExtendsError` or a `PlatformError` —
+* the async pipeline's exact typed failures.
+*
+* @public
+*/
+const resolve = (configPath, options) => runWith(options, TsconfigLoader.resolve(configPath));
+/**
+* {@link TsconfigLoader.compilerOptions}, synchronously: resolve the full
+* `extends` chain and project out the merged `compilerOptions`. Throws the
+* same typed failures as {@link TsconfigLoaderSync.resolve}.
+*
+* @public
+*/
+const compilerOptions = (configPath, options) => resolve(configPath, options).compilerOptions;
+/**
+* The synchronous tsconfig.json loader facade: the {@link TsconfigLoader}
+* pipeline run under `Effect.runSyncExit` against consumer-supplied
+* {@link SyncFileSystem} and {@link SyncPath} operations. For sync-only host
+* APIs (bundler plugin hooks, config factories); everything else should use
+* {@link TsconfigLoader} with real platform layers.
+*
+* @remarks
+* The two adapters treat unsupported members asymmetrically: a `Path` member
+* the loader pipeline never calls throws a named defect on contact, while a
+* `FileSystem` member outside the two overridden here (`exists`,
+* `readFileString`) inherits `FileSystem.makeNoop`'s typed `NotFound`
+* failure. A loader change that starts using a new filesystem operation
+* therefore surfaces as a `NotFound` rather than a defect — extend the
+* adapter when that happens.
+*
+* ```ts
+* import { existsSync, readFileSync } from "node:fs";
+* import * as path from "node:path";
+* import { TsconfigLoaderSync } from "@effected/tsconfig-json";
+*
+* const resolved = TsconfigLoaderSync.resolve("./tsconfig.json", {
+* 	fileSystem: { exists: existsSync, readFile: (p) => readFileSync(p, "utf8") },
+* 	path,
+* });
+* ```
+*
+* @public
+*/
+const TsconfigLoaderSync = {
+	load,
+	resolve,
+	compilerOptions
+};
+
+//#endregion
+export { TsconfigLoaderSync };

package/index.d.ts

@@ -190,6 +190,34 @@ declare namespace CompilerOptions {
   type Encoded = typeof CompilerOptions.Encoded;
 }
 //#endregion
+//#region src/JsxConfig.d.ts
+declare const JsxConfig_base: Schema.Class<JsxConfig, Schema.Struct<{
+  /** The JSX transform runtime: `"automatic"` (`react-jsx` / `react-jsxdev`) or `"classic"` (`react`). */
+  readonly runtime: Schema.Literals<readonly ["automatic", "classic"]>;
+  /** The automatic runtime's import source (`jsxImportSource`, defaulted to `"react"`); absent for classic. */
+  readonly importSource: Schema.optionalKey<Schema.String>;
+}>, {}>;
+/**
+ * The JSX transform configuration a `jsx` compiler option implies: which
+ * runtime (`"automatic"` for `react-jsx` / `react-jsxdev`, `"classic"` for
+ * `react`) and, for the automatic runtime, the import source the transform
+ * emits (`jsxImportSource`, defaulting to `"react"` per tsc).
+ *
+ * @public
+ */
+declare class JsxConfig extends JsxConfig_base {
+  /**
+   * Project decoded compiler options to their implied JSX transform
+   * configuration. `"react-jsx"` and `"react-jsxdev"` yield the automatic
+   * runtime with `importSource` taken from `jsxImportSource` (defaulting to
+   * `"react"`, tsc's own default); `"react"` yields the classic runtime with
+   * no `importSource`. `"preserve"`, `"react-native"` and an absent `jsx`
+   * yield `Option.none()` — JSX is left untransformed (or absent entirely),
+   * so there is nothing for a bundler to configure.
+   */
+  static fromCompilerOptions(options: CompilerOptions.Type): Option.Option<JsxConfig>;
+}
+//#endregion
 //#region src/TsconfigJson.d.ts
 /** `watchOptions.watchFile`. @public */
 declare const WatchFile: Schema.decodeTo<Schema.Literals<readonly ["fixedpollinginterval", "prioritypollinginterval", "dynamicprioritypolling", "fixedchunksizepolling", "usefsevents", "usefseventsonparentdirectory"]>, Schema.String, never, never>;
@@ -609,13 +637,385 @@ declare class TsconfigExtendsError extends TsconfigExtendsError_base {
 /**
  * The tsconfig.json loader: {@link TsconfigLoader.load} reads and decodes one
  * config file, {@link TsconfigLoader.resolve} runs the full load -\> extends -\>
- * merge -\> `${configDir}` pipeline.
+ * merge -\> `${configDir}` pipeline, and {@link TsconfigLoader.compilerOptions}
+ * projects the resolved result down to its merged `compilerOptions`.
  *
  * @public
  */
 declare const TsconfigLoader: {
-  readonly load: (configPath: string) => Effect.Effect<TsconfigJson.Type, TsconfigParseError | PlatformError.PlatformError, FileSystem.FileSystem | Path.Path>;
-  readonly resolve: (configPath: string) => Effect.Effect<ResolvedTsconfig, TsconfigParseError | TsconfigExtendsError | PlatformError.PlatformError, FileSystem.FileSystem | Path.Path>;
+  readonly load: (configPath: string) => Effect.Effect<{
+    readonly [x: string]: unknown;
+    readonly compilerOptions?: {
+      readonly [x: string]: unknown;
+      readonly target?: "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "es2023" | "es2024" | "es2025" | "es5" | "es6" | "esnext" | undefined;
+      readonly module?: "amd" | "commonjs" | "es2015" | "es2020" | "es2022" | "es6" | "esnext" | "node16" | "node18" | "node20" | "nodenext" | "none" | "preserve" | "system" | "umd" | undefined;
+      readonly moduleResolution?: "bundler" | "classic" | "node" | "node10" | "node16" | "nodenext" | undefined;
+      readonly jsx?: "preserve" | "react" | "react-jsx" | "react-jsxdev" | "react-native" | undefined;
+      readonly newLine?: "crlf" | "lf" | undefined;
+      readonly moduleDetection?: "auto" | "force" | "legacy" | undefined;
+      readonly lib?: readonly ("decorators" | "decorators.legacy" | "dom" | "dom.asynciterable" | "dom.iterable" | "es2015" | "es2015.collection" | "es2015.core" | "es2015.generator" | "es2015.iterable" | "es2015.promise" | "es2015.proxy" | "es2015.reflect" | "es2015.symbol" | "es2015.symbol.wellknown" | "es2016" | "es2016.array.include" | "es2016.intl" | "es2017" | "es2017.arraybuffer" | "es2017.date" | "es2017.intl" | "es2017.object" | "es2017.sharedmemory" | "es2017.string" | "es2017.typedarrays" | "es2018" | "es2018.asyncgenerator" | "es2018.asynciterable" | "es2018.intl" | "es2018.promise" | "es2018.regexp" | "es2019" | "es2019.array" | "es2019.intl" | "es2019.object" | "es2019.string" | "es2019.symbol" | "es2020" | "es2020.bigint" | "es2020.date" | "es2020.intl" | "es2020.number" | "es2020.promise" | "es2020.sharedmemory" | "es2020.string" | "es2020.symbol.wellknown" | "es2021" | "es2021.intl" | "es2021.promise" | "es2021.string" | "es2021.weakref" | "es2022" | "es2022.array" | "es2022.error" | "es2022.intl" | "es2022.object" | "es2022.regexp" | "es2022.string" | "es2023" | "es2023.array" | "es2023.collection" | "es2023.intl" | "es2024" | "es2024.arraybuffer" | "es2024.collection" | "es2024.object" | "es2024.promise" | "es2024.regexp" | "es2024.sharedmemory" | "es2024.string" | "es2025" | "es2025.collection" | "es2025.float16" | "es2025.intl" | "es2025.iterator" | "es2025.promise" | "es2025.regexp" | "es5" | "es6" | "es7" | "esnext" | "esnext.array" | "esnext.asynciterable" | "esnext.bigint" | "esnext.collection" | "esnext.date" | "esnext.decorators" | "esnext.disposable" | "esnext.error" | "esnext.float16" | "esnext.intl" | "esnext.iterator" | "esnext.object" | "esnext.promise" | "esnext.regexp" | "esnext.sharedmemory" | "esnext.string" | "esnext.symbol" | "esnext.temporal" | "esnext.typedarrays" | "esnext.weakref" | "scripthost" | "webworker" | "webworker.asynciterable" | "webworker.importscripts" | "webworker.iterable")[] | undefined;
+      readonly ignoreDeprecations?: "5.0" | "6.0" | undefined;
+      readonly strict?: boolean | undefined;
+      readonly noImplicitAny?: boolean | undefined;
+      readonly strictNullChecks?: boolean | undefined;
+      readonly strictFunctionTypes?: boolean | undefined;
+      readonly strictBindCallApply?: boolean | undefined;
+      readonly strictPropertyInitialization?: boolean | undefined;
+      readonly strictBuiltinIteratorReturn?: boolean | undefined;
+      readonly noImplicitThis?: boolean | undefined;
+      readonly useUnknownInCatchVariables?: boolean | undefined;
+      readonly alwaysStrict?: boolean | undefined;
+      readonly noUnusedLocals?: boolean | undefined;
+      readonly noUnusedParameters?: boolean | undefined;
+      readonly exactOptionalPropertyTypes?: boolean | undefined;
+      readonly noImplicitReturns?: boolean | undefined;
+      readonly noFallthroughCasesInSwitch?: boolean | undefined;
+      readonly noUncheckedIndexedAccess?: boolean | undefined;
+      readonly noImplicitOverride?: boolean | undefined;
+      readonly noPropertyAccessFromIndexSignature?: boolean | undefined;
+      readonly allowUnusedLabels?: boolean | undefined;
+      readonly allowUnreachableCode?: boolean | undefined;
+      readonly noUncheckedSideEffectImports?: boolean | undefined;
+      readonly allowJs?: boolean | undefined;
+      readonly checkJs?: boolean | undefined;
+      readonly resolveJsonModule?: boolean | undefined;
+      readonly allowArbitraryExtensions?: boolean | undefined;
+      readonly allowImportingTsExtensions?: boolean | undefined;
+      readonly rewriteRelativeImportExtensions?: boolean | undefined;
+      readonly resolvePackageJsonExports?: boolean | undefined;
+      readonly resolvePackageJsonImports?: boolean | undefined;
+      readonly allowSyntheticDefaultImports?: boolean | undefined;
+      readonly esModuleInterop?: boolean | undefined;
+      readonly preserveSymlinks?: boolean | undefined;
+      readonly allowUmdGlobalAccess?: boolean | undefined;
+      readonly verbatimModuleSyntax?: boolean | undefined;
+      readonly isolatedModules?: boolean | undefined;
+      readonly isolatedDeclarations?: boolean | undefined;
+      readonly erasableSyntaxOnly?: boolean | undefined;
+      readonly forceConsistentCasingInFileNames?: boolean | undefined;
+      readonly declaration?: boolean | undefined;
+      readonly declarationMap?: boolean | undefined;
+      readonly emitDeclarationOnly?: boolean | undefined;
+      readonly sourceMap?: boolean | undefined;
+      readonly inlineSourceMap?: boolean | undefined;
+      readonly inlineSources?: boolean | undefined;
+      readonly removeComments?: boolean | undefined;
+      readonly importHelpers?: boolean | undefined;
+      readonly downlevelIteration?: boolean | undefined;
+      readonly emitBOM?: boolean | undefined;
+      readonly noEmit?: boolean | undefined;
+      readonly noEmitHelpers?: boolean | undefined;
+      readonly noEmitOnError?: boolean | undefined;
+      readonly preserveConstEnums?: boolean | undefined;
+      readonly stripInternal?: boolean | undefined;
+      readonly experimentalDecorators?: boolean | undefined;
+      readonly emitDecoratorMetadata?: boolean | undefined;
+      readonly useDefineForClassFields?: boolean | undefined;
+      readonly noCheck?: boolean | undefined;
+      readonly composite?: boolean | undefined;
+      readonly incremental?: boolean | undefined;
+      readonly disableSourceOfProjectReferenceRedirect?: boolean | undefined;
+      readonly disableSolutionSearching?: boolean | undefined;
+      readonly disableReferencedProjectLoad?: boolean | undefined;
+      readonly assumeChangesOnlyAffectDirectDependencies?: boolean | undefined;
+      readonly noErrorTruncation?: boolean | undefined;
+      readonly noLib?: boolean | undefined;
+      readonly noResolve?: boolean | undefined;
+      readonly skipDefaultLibCheck?: boolean | undefined;
+      readonly skipLibCheck?: boolean | undefined;
+      readonly diagnostics?: boolean | undefined;
+      readonly extendedDiagnostics?: boolean | undefined;
+      readonly listFiles?: boolean | undefined;
+      readonly listFilesOnly?: boolean | undefined;
+      readonly listEmittedFiles?: boolean | undefined;
+      readonly explainFiles?: boolean | undefined;
+      readonly traceResolution?: boolean | undefined;
+      readonly preserveWatchOutput?: boolean | undefined;
+      readonly pretty?: boolean | undefined;
+      readonly disableSizeLimit?: boolean | undefined;
+      readonly libReplacement?: boolean | undefined;
+      readonly stableTypeOrdering?: boolean | undefined;
+      readonly outFile?: string | undefined;
+      readonly outDir?: string | undefined;
+      readonly rootDir?: string | undefined;
+      readonly declarationDir?: string | undefined;
+      readonly sourceRoot?: string | undefined;
+      readonly mapRoot?: string | undefined;
+      readonly tsBuildInfoFile?: string | undefined;
+      readonly baseUrl?: string | undefined;
+      readonly generateCpuProfile?: string | undefined;
+      readonly generateTrace?: string | undefined;
+      readonly typeRoots?: readonly string[] | undefined;
+      readonly rootDirs?: readonly string[] | undefined;
+      readonly jsxFactory?: string | undefined;
+      readonly jsxFragmentFactory?: string | undefined;
+      readonly jsxImportSource?: string | undefined;
+      readonly reactNamespace?: string | undefined;
+      readonly types?: readonly string[] | undefined;
+      readonly customConditions?: readonly string[] | undefined;
+      readonly moduleSuffixes?: readonly string[] | undefined;
+      readonly paths?: {
+        readonly [x: string]: readonly string[];
+      } | undefined;
+      readonly plugins?: readonly {
+        readonly [x: string]: unknown;
+        readonly name: string;
+      }[] | undefined;
+      readonly maxNodeModuleJsDepth?: number | undefined;
+    } | undefined;
+    readonly extends?: string | readonly string[] | undefined;
+    readonly files?: readonly string[] | undefined;
+    readonly include?: readonly string[] | undefined;
+    readonly exclude?: readonly string[] | undefined;
+    readonly references?: readonly {
+      readonly [x: string]: unknown;
+      readonly path: string;
+    }[] | undefined;
+    readonly watchOptions?: {
+      readonly [x: string]: unknown;
+      readonly watchFile?: "dynamicprioritypolling" | "fixedchunksizepolling" | "fixedpollinginterval" | "prioritypollinginterval" | "usefsevents" | "usefseventsonparentdirectory" | undefined;
+      readonly watchDirectory?: "dynamicprioritypolling" | "fixedchunksizepolling" | "fixedpollinginterval" | "usefsevents" | undefined;
+      readonly fallbackPolling?: "dynamicpriority" | "fixedchunksize" | "fixedinterval" | "priorityinterval" | undefined;
+      readonly synchronousWatchDirectory?: boolean | undefined;
+      readonly excludeDirectories?: readonly string[] | undefined;
+      readonly excludeFiles?: readonly string[] | undefined;
+    } | undefined;
+    readonly typeAcquisition?: {
+      readonly [x: string]: unknown;
+      readonly enable?: boolean | undefined;
+      readonly include?: readonly string[] | undefined;
+      readonly exclude?: readonly string[] | undefined;
+      readonly disableFilenameBasedTypeAcquisition?: boolean | undefined;
+    } | undefined;
+    readonly compileOnSave?: boolean | undefined;
+    readonly $schema?: string | undefined;
+  }, PlatformError.PlatformError | TsconfigParseError, FileSystem.FileSystem | Path.Path>;
+  readonly resolve: (configPath: string) => Effect.Effect<ResolvedTsconfig, PlatformError.PlatformError | TsconfigExtendsError | TsconfigParseError, FileSystem.FileSystem | Path.Path>;
+  readonly compilerOptions: (configPath: string) => Effect.Effect<{
+    readonly [x: string]: unknown;
+    readonly target?: "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "es2023" | "es2024" | "es2025" | "es5" | "es6" | "esnext" | undefined;
+    readonly module?: "amd" | "commonjs" | "es2015" | "es2020" | "es2022" | "es6" | "esnext" | "node16" | "node18" | "node20" | "nodenext" | "none" | "preserve" | "system" | "umd" | undefined;
+    readonly moduleResolution?: "bundler" | "classic" | "node" | "node10" | "node16" | "nodenext" | undefined;
+    readonly jsx?: "preserve" | "react" | "react-jsx" | "react-jsxdev" | "react-native" | undefined;
+    readonly newLine?: "crlf" | "lf" | undefined;
+    readonly moduleDetection?: "auto" | "force" | "legacy" | undefined;
+    readonly lib?: readonly ("decorators" | "decorators.legacy" | "dom" | "dom.asynciterable" | "dom.iterable" | "es2015" | "es2015.collection" | "es2015.core" | "es2015.generator" | "es2015.iterable" | "es2015.promise" | "es2015.proxy" | "es2015.reflect" | "es2015.symbol" | "es2015.symbol.wellknown" | "es2016" | "es2016.array.include" | "es2016.intl" | "es2017" | "es2017.arraybuffer" | "es2017.date" | "es2017.intl" | "es2017.object" | "es2017.sharedmemory" | "es2017.string" | "es2017.typedarrays" | "es2018" | "es2018.asyncgenerator" | "es2018.asynciterable" | "es2018.intl" | "es2018.promise" | "es2018.regexp" | "es2019" | "es2019.array" | "es2019.intl" | "es2019.object" | "es2019.string" | "es2019.symbol" | "es2020" | "es2020.bigint" | "es2020.date" | "es2020.intl" | "es2020.number" | "es2020.promise" | "es2020.sharedmemory" | "es2020.string" | "es2020.symbol.wellknown" | "es2021" | "es2021.intl" | "es2021.promise" | "es2021.string" | "es2021.weakref" | "es2022" | "es2022.array" | "es2022.error" | "es2022.intl" | "es2022.object" | "es2022.regexp" | "es2022.string" | "es2023" | "es2023.array" | "es2023.collection" | "es2023.intl" | "es2024" | "es2024.arraybuffer" | "es2024.collection" | "es2024.object" | "es2024.promise" | "es2024.regexp" | "es2024.sharedmemory" | "es2024.string" | "es2025" | "es2025.collection" | "es2025.float16" | "es2025.intl" | "es2025.iterator" | "es2025.promise" | "es2025.regexp" | "es5" | "es6" | "es7" | "esnext" | "esnext.array" | "esnext.asynciterable" | "esnext.bigint" | "esnext.collection" | "esnext.date" | "esnext.decorators" | "esnext.disposable" | "esnext.error" | "esnext.float16" | "esnext.intl" | "esnext.iterator" | "esnext.object" | "esnext.promise" | "esnext.regexp" | "esnext.sharedmemory" | "esnext.string" | "esnext.symbol" | "esnext.temporal" | "esnext.typedarrays" | "esnext.weakref" | "scripthost" | "webworker" | "webworker.asynciterable" | "webworker.importscripts" | "webworker.iterable")[] | undefined;
+    readonly ignoreDeprecations?: "5.0" | "6.0" | undefined;
+    readonly strict?: boolean | undefined;
+    readonly noImplicitAny?: boolean | undefined;
+    readonly strictNullChecks?: boolean | undefined;
+    readonly strictFunctionTypes?: boolean | undefined;
+    readonly strictBindCallApply?: boolean | undefined;
+    readonly strictPropertyInitialization?: boolean | undefined;
+    readonly strictBuiltinIteratorReturn?: boolean | undefined;
+    readonly noImplicitThis?: boolean | undefined;
+    readonly useUnknownInCatchVariables?: boolean | undefined;
+    readonly alwaysStrict?: boolean | undefined;
+    readonly noUnusedLocals?: boolean | undefined;
+    readonly noUnusedParameters?: boolean | undefined;
+    readonly exactOptionalPropertyTypes?: boolean | undefined;
+    readonly noImplicitReturns?: boolean | undefined;
+    readonly noFallthroughCasesInSwitch?: boolean | undefined;
+    readonly noUncheckedIndexedAccess?: boolean | undefined;
+    readonly noImplicitOverride?: boolean | undefined;
+    readonly noPropertyAccessFromIndexSignature?: boolean | undefined;
+    readonly allowUnusedLabels?: boolean | undefined;
+    readonly allowUnreachableCode?: boolean | undefined;
+    readonly noUncheckedSideEffectImports?: boolean | undefined;
+    readonly allowJs?: boolean | undefined;
+    readonly checkJs?: boolean | undefined;
+    readonly resolveJsonModule?: boolean | undefined;
+    readonly allowArbitraryExtensions?: boolean | undefined;
+    readonly allowImportingTsExtensions?: boolean | undefined;
+    readonly rewriteRelativeImportExtensions?: boolean | undefined;
+    readonly resolvePackageJsonExports?: boolean | undefined;
+    readonly resolvePackageJsonImports?: boolean | undefined;
+    readonly allowSyntheticDefaultImports?: boolean | undefined;
+    readonly esModuleInterop?: boolean | undefined;
+    readonly preserveSymlinks?: boolean | undefined;
+    readonly allowUmdGlobalAccess?: boolean | undefined;
+    readonly verbatimModuleSyntax?: boolean | undefined;
+    readonly isolatedModules?: boolean | undefined;
+    readonly isolatedDeclarations?: boolean | undefined;
+    readonly erasableSyntaxOnly?: boolean | undefined;
+    readonly forceConsistentCasingInFileNames?: boolean | undefined;
+    readonly declaration?: boolean | undefined;
+    readonly declarationMap?: boolean | undefined;
+    readonly emitDeclarationOnly?: boolean | undefined;
+    readonly sourceMap?: boolean | undefined;
+    readonly inlineSourceMap?: boolean | undefined;
+    readonly inlineSources?: boolean | undefined;
+    readonly removeComments?: boolean | undefined;
+    readonly importHelpers?: boolean | undefined;
+    readonly downlevelIteration?: boolean | undefined;
+    readonly emitBOM?: boolean | undefined;
+    readonly noEmit?: boolean | undefined;
+    readonly noEmitHelpers?: boolean | undefined;
+    readonly noEmitOnError?: boolean | undefined;
+    readonly preserveConstEnums?: boolean | undefined;
+    readonly stripInternal?: boolean | undefined;
+    readonly experimentalDecorators?: boolean | undefined;
+    readonly emitDecoratorMetadata?: boolean | undefined;
+    readonly useDefineForClassFields?: boolean | undefined;
+    readonly noCheck?: boolean | undefined;
+    readonly composite?: boolean | undefined;
+    readonly incremental?: boolean | undefined;
+    readonly disableSourceOfProjectReferenceRedirect?: boolean | undefined;
+    readonly disableSolutionSearching?: boolean | undefined;
+    readonly disableReferencedProjectLoad?: boolean | undefined;
+    readonly assumeChangesOnlyAffectDirectDependencies?: boolean | undefined;
+    readonly noErrorTruncation?: boolean | undefined;
+    readonly noLib?: boolean | undefined;
+    readonly noResolve?: boolean | undefined;
+    readonly skipDefaultLibCheck?: boolean | undefined;
+    readonly skipLibCheck?: boolean | undefined;
+    readonly diagnostics?: boolean | undefined;
+    readonly extendedDiagnostics?: boolean | undefined;
+    readonly listFiles?: boolean | undefined;
+    readonly listFilesOnly?: boolean | undefined;
+    readonly listEmittedFiles?: boolean | undefined;
+    readonly explainFiles?: boolean | undefined;
+    readonly traceResolution?: boolean | undefined;
+    readonly preserveWatchOutput?: boolean | undefined;
+    readonly pretty?: boolean | undefined;
+    readonly disableSizeLimit?: boolean | undefined;
+    readonly libReplacement?: boolean | undefined;
+    readonly stableTypeOrdering?: boolean | undefined;
+    readonly outFile?: string | undefined;
+    readonly outDir?: string | undefined;
+    readonly rootDir?: string | undefined;
+    readonly declarationDir?: string | undefined;
+    readonly sourceRoot?: string | undefined;
+    readonly mapRoot?: string | undefined;
+    readonly tsBuildInfoFile?: string | undefined;
+    readonly baseUrl?: string | undefined;
+    readonly generateCpuProfile?: string | undefined;
+    readonly generateTrace?: string | undefined;
+    readonly typeRoots?: readonly string[] | undefined;
+    readonly rootDirs?: readonly string[] | undefined;
+    readonly jsxFactory?: string | undefined;
+    readonly jsxFragmentFactory?: string | undefined;
+    readonly jsxImportSource?: string | undefined;
+    readonly reactNamespace?: string | undefined;
+    readonly types?: readonly string[] | undefined;
+    readonly customConditions?: readonly string[] | undefined;
+    readonly moduleSuffixes?: readonly string[] | undefined;
+    readonly paths?: {
+      readonly [x: string]: readonly string[];
+    } | undefined;
+    readonly plugins?: readonly {
+      readonly [x: string]: unknown;
+      readonly name: string;
+    }[] | undefined;
+    readonly maxNodeModuleJsDepth?: number | undefined;
+  }, PlatformError.PlatformError | TsconfigExtendsError | TsconfigParseError, FileSystem.FileSystem | Path.Path>;
+};
+//#endregion
+//#region src/TsconfigLoaderSync.d.ts
+/**
+ * The synchronous file operations {@link TsconfigLoaderSync} needs, supplied
+ * by the consumer. Node's built-ins satisfy it directly:
+ *
+ * ```ts
+ * import { existsSync, readFileSync } from "node:fs";
+ *
+ * const fileSystem: SyncFileSystem = {
+ * 	exists: existsSync,
+ * 	readFile: (p) => readFileSync(p, "utf8"),
+ * };
+ * ```
+ *
+ * `readFile` returns the file's text and may throw on failure (a missing
+ * file, a permission error); the throw is wrapped in a `PlatformError` and
+ * rethrown through the loader's typed channel.
+ *
+ * @public
+ */
+interface SyncFileSystem {
+  /** Whether a file exists at `path`. Directory hits follow the loader's documented file-only contract. */
+  readonly exists: (path: string) => boolean;
+  /** Read the file at `path` as text. May throw; the throw surfaces as a `PlatformError`. */
+  readonly readFile: (path: string) => string;
+}
+/**
+ * The synchronous path operations {@link TsconfigLoaderSync} needs, supplied
+ * by the consumer. Deliberately a structural subset of `node:path`, so the
+ * built-in module (and its `win32` / `posix` variants, or a Bun / Deno
+ * equivalent) satisfies it verbatim:
+ *
+ * ```ts
+ * import * as path from "node:path";
+ *
+ * const options: TsconfigLoaderSyncOptions = {
+ * 	fileSystem: { exists: existsSync, readFile: (p) => readFileSync(p, "utf8") },
+ * 	path, // node:path IS a SyncPath
+ * };
+ * ```
+ *
+ * The loader passes these through untouched — Windows correctness comes from
+ * supplying a win32-appropriate implementation, not from anything here.
+ *
+ * @public
+ */
+interface SyncPath {
+  /** Resolve segments to an absolute path (rightmost-wins, like `path.resolve`). */
+  readonly resolve: (...segments: ReadonlyArray<string>) => string;
+  /** The directory portion of `p` (like `path.dirname`). */
+  readonly dirname: (p: string) => string;
+  /** Join segments with the implementation's separator (like `path.join`). */
+  readonly join: (...segments: ReadonlyArray<string>) => string;
+  /** Whether `p` is absolute under this implementation's convention. */
+  readonly isAbsolute: (p: string) => boolean;
+  /** The final segment of `p` (like `path.basename`). */
+  readonly basename: (p: string) => string;
+}
+/**
+ * The consumer-supplied operations backing one {@link TsconfigLoaderSync}
+ * call: the file operations and the path implementation. Both are required —
+ * this package never imports `node:*` and never assumes posix, so the
+ * platform binding is entirely the caller's.
+ *
+ * @public
+ */
+interface TsconfigLoaderSyncOptions {
+  /** The synchronous file operations (Node: `existsSync` / `readFileSync`). */
+  readonly fileSystem: SyncFileSystem;
+  /** The synchronous path implementation (Node: the `node:path` module itself). */
+  readonly path: SyncPath;
+}
+/**
+ * The synchronous tsconfig.json loader facade: the {@link TsconfigLoader}
+ * pipeline run under `Effect.runSyncExit` against consumer-supplied
+ * {@link SyncFileSystem} and {@link SyncPath} operations. For sync-only host
+ * APIs (bundler plugin hooks, config factories); everything else should use
+ * {@link TsconfigLoader} with real platform layers.
+ *
+ * @remarks
+ * The two adapters treat unsupported members asymmetrically: a `Path` member
+ * the loader pipeline never calls throws a named defect on contact, while a
+ * `FileSystem` member outside the two overridden here (`exists`,
+ * `readFileString`) inherits `FileSystem.makeNoop`'s typed `NotFound`
+ * failure. A loader change that starts using a new filesystem operation
+ * therefore surfaces as a `NotFound` rather than a defect — extend the
+ * adapter when that happens.
+ *
+ * ```ts
+ * import { existsSync, readFileSync } from "node:fs";
+ * import * as path from "node:path";
+ * import { TsconfigLoaderSync } from "@effected/tsconfig-json";
+ *
+ * const resolved = TsconfigLoaderSync.resolve("./tsconfig.json", {
+ * 	fileSystem: { exists: existsSync, readFile: (p) => readFileSync(p, "utf8") },
+ * 	path,
+ * });
+ * ```
+ *
+ * @public
+ */
+declare const TsconfigLoaderSync: {
+  readonly load: (configPath: string, options: TsconfigLoaderSyncOptions) => TsconfigJson.Type;
+  readonly resolve: (configPath: string, options: TsconfigLoaderSyncOptions) => ResolvedTsconfig;
+  readonly compilerOptions: (configPath: string, options: TsconfigLoaderSyncOptions) => CompilerOptions.Type;
 };
 //#endregion
 //#region src/TsEnumCodec.d.ts
@@ -641,5 +1041,5 @@ declare const TsEnumCodec: {
   readonly decodeCompilerOptions: (numeric: Readonly<Record<string, unknown>>) => Record<string, unknown>;
 };
 //#endregion
-export { CompilerOptions, type EnumFamily, FallbackPolling, type FindNearestOptions, Jsx, Lib, Module, ModuleDetection, ModuleResolution, NewLine, PortableTsconfig, Reference, ResolvedTsconfig, Target, TsEnumCodec, TsconfigDiscovery, TsconfigExtendsError, TsconfigJson, TsconfigJsonFromString, TsconfigLoader, TsconfigParseError, TypeAcquisition, WatchDirectory, WatchFile, WatchOptions };
+export { CompilerOptions, type EnumFamily, FallbackPolling, type FindNearestOptions, Jsx, JsxConfig, Lib, Module, ModuleDetection, ModuleResolution, NewLine, PortableTsconfig, Reference, ResolvedTsconfig, type SyncFileSystem, type SyncPath, Target, TsEnumCodec, TsconfigDiscovery, TsconfigExtendsError, TsconfigJson, TsconfigJsonFromString, TsconfigLoader, TsconfigLoaderSync, type TsconfigLoaderSyncOptions, TsconfigParseError, TypeAcquisition, WatchDirectory, WatchFile, WatchOptions };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,9 +1,11 @@
 import { CompilerOptions, Jsx, Lib, Module, ModuleDetection, ModuleResolution, NewLine, Target } from "./CompilerOptions.js";
+import { JsxConfig } from "./JsxConfig.js";
 import { PortableTsconfig } from "./PortableTsconfig.js";
 import { ResolvedTsconfig } from "./ResolvedTsconfig.js";
 import { TsconfigDiscovery } from "./TsconfigDiscovery.js";
 import { FallbackPolling, Reference, TsconfigJson, TsconfigJsonFromString, TsconfigParseError, TypeAcquisition, WatchDirectory, WatchFile, WatchOptions } from "./TsconfigJson.js";
 import { TsconfigExtendsError, TsconfigLoader } from "./TsconfigLoader.js";
+import { TsconfigLoaderSync } from "./TsconfigLoaderSync.js";
 import { TsEnumCodec } from "./TsEnumCodec.js";
 
-export { CompilerOptions, FallbackPolling, Jsx, Lib, Module, ModuleDetection, ModuleResolution, NewLine, PortableTsconfig, Reference, ResolvedTsconfig, Target, TsEnumCodec, TsconfigDiscovery, TsconfigExtendsError, TsconfigJson, TsconfigJsonFromString, TsconfigLoader, TsconfigParseError, TypeAcquisition, WatchDirectory, WatchFile, WatchOptions };
+export { CompilerOptions, FallbackPolling, Jsx, JsxConfig, Lib, Module, ModuleDetection, ModuleResolution, NewLine, PortableTsconfig, Reference, ResolvedTsconfig, Target, TsEnumCodec, TsconfigDiscovery, TsconfigExtendsError, TsconfigJson, TsconfigJsonFromString, TsconfigLoader, TsconfigLoaderSync, TsconfigParseError, TypeAcquisition, WatchDirectory, WatchFile, WatchOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/tsconfig-json",
-	"version": "0.1.0",
+	"version": "0.2.1",
 	"private": false,
 	"description": "Composable tsconfig.json handling for Effect: schemas, extends-chain resolution, and config discovery.",
 	"keywords": [
@@ -38,8 +38,8 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"@effected/jsonc": "0.1.0",
-		"@effected/walker": "0.1.0",
+		"@effected/jsonc": "0.2.0",
+		"@effected/walker": "0.2.0",
 		"effect": "4.0.0-beta.98"
 	},
 	"engines": {

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.9"
+      "packageVersion": "7.58.10"
     }
   ]
 }