@effect/tsgo 0.16.3 → 0.18.0

package/README.md

@@ -22,7 +22,7 @@ This will guide you through the installation process, which includes:
 4. Hinting at any additional editor configuration needed to ensure the LSP is active.
 
 > [!NOTE]
-> At the moment, you still need a native TypeScript install alongside `@effect/tsgo` — either `@typescript/native-preview` (nightlies) or `typescript` >= 7 (e.g. the 7.0 RC, `typescript@rc`). `effect-tsgo patch` and `effect-tsgo setup` detect and use whichever one is installed.
+> At the moment, you still need a native TypeScript install alongside `@effect/tsgo`: `typescript` >= 7 (e.g. `typescript@latest` or `typescript@next`) or an alias such as `@typescript/native`. `effect-tsgo patch` tries `typescript`, then `@typescript/native`, and accepts `--typescript-package <name>` to try a custom package name first.
 
 ## Diagnostic Status
 

package/dist/effect-tsgo.js

@@ -1158,15 +1158,15 @@ const symbol$3 = "~effect/interfaces/Hash";
 const hash = (self) => {
 	switch (typeof self) {
 		case "number": return number$2(self);
-		case "bigint": return string$2(self.toString(10));
-		case "boolean": return string$2(String(self));
-		case "symbol": return string$2(String(self));
-		case "string": return string$2(self);
-		case "undefined": return string$2("undefined");
+		case "bigint": return string$5(self.toString(10));
+		case "boolean": return string$5(String(self));
+		case "symbol": return string$5(String(self));
+		case "string": return string$5(self);
+		case "undefined": return string$5("undefined");
 		case "function":
-		case "object": if (self === null) return string$2("null");
-		else if (self instanceof Date) return string$2(self.toISOString());
-		else if (self instanceof RegExp) return string$2(self.toString());
+		case "object": if (self === null) return string$5("null");
+		else if (self instanceof Date) return string$5(self.toISOString());
+		else if (self instanceof RegExp) return string$5(self.toString());
 		else {
 			if (byReferenceInstances.has(self)) return random(self);
 			if (hashCache.has(self)) return hashCache.get(self);
@@ -1348,9 +1348,9 @@ const isHash = (u) => hasProperty(u, symbol$3);
 * @since 2.0.0
 */
 const number$2 = (n) => {
-	if (n !== n) return string$2("NaN");
-	if (n === Infinity) return string$2("Infinity");
-	if (n === -Infinity) return string$2("-Infinity");
+	if (n !== n) return string$5("NaN");
+	if (n === Infinity) return string$5("Infinity");
+	if (n === -Infinity) return string$5("-Infinity");
 	let h = n | 0;
 	if (h !== n) h ^= n * 4294967295;
 	while (n > 4294967295) h ^= n /= 4294967295;
@@ -1386,7 +1386,7 @@ const number$2 = (n) => {
 * @category hashing
 * @since 2.0.0
 */
-const string$2 = (str) => {
+const string$5 = (str) => {
 	let h = 5381, i = str.length;
 	while (i) h = h * 33 ^ str.charCodeAt(--i);
 	return optimize(h);
@@ -1510,13 +1510,13 @@ const iterableWith = (seed, f) => (iter) => {
 * @since 2.0.0
 */
 const array = /* @__PURE__ */ iterableWith(6151, hash);
-const hashMap = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string$2("Map"), ([k, v]) => combine$2(hash(k), hash(v)));
-const hashSet = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string$2("Set"), hash);
+const hashMap = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string$5("Map"), ([k, v]) => combine$2(hash(k), hash(v)));
+const hashSet = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string$5("Set"), hash);
 const randomHashCache = /* @__PURE__ */ new WeakMap();
 const hashCache = /* @__PURE__ */ new WeakMap();
 const visitedObjects = /* @__PURE__ */ new WeakSet();
 function withVisitedTracking$1(obj, fn) {
-	if (visitedObjects.has(obj)) return string$2("[Circular]");
+	if (visitedObjects.has(obj)) return string$5("[Circular]");
 	visitedObjects.add(obj);
 	const result = fn();
 	visitedObjects.delete(obj);
@@ -2632,7 +2632,7 @@ var Fail = class extends ReasonBase {
 		return isFailReason$1(that) && equals$2(this.error, that.error) && equals$2(this.annotations, that.annotations);
 	}
 	[symbol$3]() {
-		return combine$2(string$2(this._tag))(combine$2(hash(this.error))(hash(this.annotations)));
+		return combine$2(string$5(this._tag))(combine$2(hash(this.error))(hash(this.annotations)));
 	}
 };
 /** @internal */
@@ -2661,7 +2661,7 @@ var Die = class extends ReasonBase {
 		return isDieReason$1(that) && equals$2(this.defect, that.defect) && equals$2(this.annotations, that.annotations);
 	}
 	[symbol$3]() {
-		return combine$2(string$2(this._tag))(combine$2(hash(this.defect))(hash(this.annotations)));
+		return combine$2(string$5(this._tag))(combine$2(hash(this.defect))(hash(this.annotations)));
 	}
 };
 /** @internal */
@@ -2721,7 +2721,7 @@ const makeExit = (options) => {
 			return isExit$1(that) && that._tag === this._tag && equals$2(this[args], that[args]);
 		},
 		[symbol$3]() {
-			return combine$2(string$2(options.op), hash(this[args]));
+			return combine$2(string$5(options.op), hash(this[args]));
 		}
 	};
 	return function(value) {
@@ -6850,7 +6850,7 @@ const fromPredicate = (predicate) => (input) => predicate(input) ? succeed$4(inp
 * @category constructors
 * @since 4.0.0
 */
-const string$1 = /* @__PURE__ */ fromPredicate(isString);
+const string$4 = /* @__PURE__ */ fromPredicate(isString);
 /**
 * A predefined filter that only passes through number values.
 *
@@ -7536,7 +7536,7 @@ var Interrupt = class extends ReasonBase {
 		return isInterruptReason$1(that) && this.fiberId === that.fiberId && this.annotations === that.annotations;
 	}
 	[symbol$3]() {
-		return combine$2(string$2(`${this._tag}:${this.fiberId}`))(random(this.annotations));
+		return combine$2(string$5(`${this._tag}:${this.fiberId}`))(random(this.annotations));
 	}
 };
 /** @internal */
@@ -14187,7 +14187,7 @@ const ProtoTimeZoneNamed = {
 	...ProtoTimeZone,
 	_tag: "Named",
 	[symbol$3]() {
-		return string$2(`Named:${this.id}`);
+		return string$5(`Named:${this.id}`);
 	},
 	[symbol$2](that) {
 		return isTimeZone$1(that) && that._tag === "Named" && this.id === that.id;
@@ -14207,7 +14207,7 @@ const ProtoTimeZoneOffset = {
 	...ProtoTimeZone,
 	_tag: "Offset",
 	[symbol$3]() {
-		return string$2(`Offset:${this.offset}`);
+		return string$5(`Offset:${this.offset}`);
 	},
 	[symbol$2](that) {
 		return isTimeZone$1(that) && that._tag === "Offset" && this.offset === that.offset;
@@ -27499,6 +27499,51 @@ function BigInt$3() {
 function Date$2() {
 	return transform$2((u) => new globalThis.Date(u));
 }
+function parseJson(options) {
+	return onSome((input) => try_({
+		try: () => some(JSON.parse(input, options?.reviver)),
+		catch: (e) => new InvalidValue$1(some(input), { message: globalThis.String(e) })
+	}));
+}
+/**
+* Stringifies a present value using `JSON.stringify`.
+*
+* **When to use**
+*
+* Use when you need a schema getter to serialize a present decoded value to
+* JSON text during encoding.
+*
+* **Details**
+*
+* - Skips `None` inputs.
+* - On thrown stringify failures, such as circular references, fails with
+*   `SchemaIssue.InvalidValue`.
+* - Supports optional `replacer` and `space` options, matching
+*   `JSON.stringify`.
+* - If `JSON.stringify` returns `undefined`, such as for `undefined`,
+*   functions, symbols, or a replacer that removes the root value, that
+*   `undefined` result is returned rather than converted into an `Issue`.
+*
+* **Example** (Stringify JSON)
+*
+* ```ts
+* import { SchemaGetter } from "effect"
+*
+* const stringify = SchemaGetter.stringifyJson()
+* // Getter<string, unknown>
+* ```
+*
+* @see {@link parseJson} for the inverse operation
+*
+* @category JSON getters
+* @since 4.0.0
+*/
+function stringifyJson(options) {
+	return onSome((input) => try_({
+		try: () => some(JSON.stringify(input, options?.replacer, options?.space)),
+		catch: (e) => new InvalidValue$1(some(input), { message: globalThis.String(e) })
+	}));
+}
 /**
 * Splits a string into an array of strings by a separator.
 *
@@ -29298,6 +29343,38 @@ const stringFromHexString = /* @__PURE__ */ new Transformation(/* @__PURE__ */ d
 */
 const stringFromUriComponent = /* @__PURE__ */ new Transformation(/* @__PURE__ */ decodeUriComponent(), /* @__PURE__ */ encodeUriComponent());
 /**
+* Decodes a JSON string with `JSON.parse` and encodes a value with
+* `JSON.stringify`.
+*
+* **When to use**
+*
+* Use when you need a schema transformation to decode JSON stored or
+* transmitted as a string, usually before composing with another schema that
+* validates the parsed structure.
+*
+* **Details**
+*
+* Decode fails with `InvalidValue` for invalid JSON, and encode can fail with
+* `InvalidValue` when `JSON.stringify` cannot serialize the value.
+*
+* **Example** (Parsing JSON)
+*
+* ```ts
+* import { Schema, SchemaTransformation } from "effect"
+*
+* const schema = Schema.String.pipe(
+*   Schema.decodeTo(Schema.Unknown, SchemaTransformation.fromJsonString)
+* )
+* ```
+*
+* @see {@link uint8ArrayFromBase64String}
+* @see {@link fromFormData}
+*
+* @category decoding
+* @since 4.0.0
+*/
+const fromJsonString$1 = /* @__PURE__ */ new Transformation(/* @__PURE__ */ parseJson(), /* @__PURE__ */ stringifyJson());
+/**
 * Decodes a numeric time-zone offset in milliseconds into a
 * `DateTime.TimeZone.Offset` and encodes it back to the offset number.
 *
@@ -30006,7 +30083,7 @@ var String$2 = class extends Base {
 * @category constructors
 * @since 4.0.0
 */
-const string = /* @__PURE__ */ new String$2();
+const string$3 = /* @__PURE__ */ new String$2();
 /**
 * AST node matching any `number` value (including `NaN`, `Infinity`,
 * `-Infinity`).
@@ -31369,7 +31446,7 @@ function isStringFinite$1(annotations) {
 		...annotations
 	});
 }
-const finiteString = /* @__PURE__ */ appendChecks(string, [/* @__PURE__ */ isStringFinite$1()]);
+const finiteString = /* @__PURE__ */ appendChecks(string$3, [/* @__PURE__ */ isStringFinite$1()]);
 const finiteToString = /* @__PURE__ */ new Link(finiteString, numberFromString);
 const numberToString = /* @__PURE__ */ new Link(/* @__PURE__ */ new Union$1([finiteString, nonFiniteLiterals], "anyOf"), numberFromString);
 /**
@@ -31389,11 +31466,11 @@ function isStringBigInt$1(annotations) {
 	});
 }
 /** @internal */
-const bigIntString = /* @__PURE__ */ appendChecks(string, [/* @__PURE__ */ isStringBigInt$1({ expected: "a string representing a bigint" })]);
+const bigIntString = /* @__PURE__ */ appendChecks(string$3, [/* @__PURE__ */ isStringBigInt$1({ expected: "a string representing a bigint" })]);
 const bigIntToString = /* @__PURE__ */ new Link(bigIntString, bigintFromString);
 const isStringSymbolRegExp = /* @__PURE__ */ new globalThis.RegExp(`^Symbol\\((.*)\\)$`);
 /** @internal */
-const symbolString = /* @__PURE__ */ appendChecks(string, [/* @__PURE__ */ isStringSymbol$1()]);
+const symbolString = /* @__PURE__ */ appendChecks(string$3, [/* @__PURE__ */ isStringSymbol$1()]);
 /**
 * to distinguish between Symbol and String, we need to add a check to the string keyword
 */
@@ -38202,7 +38279,7 @@ const Undefined = /* @__PURE__ */ make$5(undefined_);
 * @category schemas
 * @since 4.0.0
 */
-const String$1 = /* @__PURE__ */ make$5(string);
+const String$1 = /* @__PURE__ */ make$5(string$3);
 /**
 * Schema for `number` values, including `NaN`, `Infinity`, and `-Infinity`.
 *
@@ -39759,6 +39836,79 @@ const BigDecimal = /* @__PURE__ */ declare(isBigDecimal, {
 */
 const BigDecimalFromString = /* @__PURE__ */ BigDecimalString.pipe(/* @__PURE__ */ decodeTo(BigDecimal, bigDecimalFromString));
 /**
+* Returns a schema that decodes a JSON string and then decodes the parsed value
+* using the given schema.
+*
+* **Details**
+*
+* This is useful when working with JSON-encoded strings where the actual
+* structure of the value is known and described by an existing schema.
+*
+* The resulting schema first parses the input string as JSON, and then runs the
+* provided schema on the parsed result.
+*
+* JSON Schema generation:
+*
+* When using `fromJsonString` with `draft-2020-12` or `openApi3.1`, the
+* resulting schema will be a JSON Schema with a `contentSchema` property that
+* contains the JSON Schema for the given schema.
+*
+* **Example** (Decoding JSON strings with a schema)
+*
+* ```ts
+* import { Schema } from "effect"
+*
+* const schema = Schema.Struct({ a: Schema.Number })
+* const schemaFromJsonString = Schema.fromJsonString(schema)
+*
+* Schema.decodeUnknownSync(schemaFromJsonString)(`{"a":1,"b":2}`)
+* // => { a: 1 }
+* ```
+*
+* **Example** (Emitting JSON Schema for a JSON string decoder)
+*
+* ```ts
+* import { Schema } from "effect"
+*
+* const original = Schema.Struct({ a: Schema.String })
+* const schema = Schema.fromJsonString(original)
+*
+* const document = Schema.toJsonSchemaDocument(schema)
+*
+* console.log(JSON.stringify(document, null, 2))
+* // {
+* //   "source": "draft-2020-12",
+* //   "schema": {
+* //     "type": "string",
+* //     "contentMediaType": "application/json",
+* //     "contentSchema": {
+* //       "type": "object",
+* //       "properties": {
+* //         "a": {
+* //           "type": "string"
+* //         }
+* //       },
+* //       "required": [
+* //         "a"
+* //       ],
+* //       "additionalProperties": false
+* //     }
+* //   },
+* //   "definitions": {}
+* // }
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+function fromJsonString(schema) {
+	return String$1.annotate({
+		expected: "a string that will be decoded as JSON",
+		contentMediaType: "application/json",
+		contentSchema: toEncoded(schema.ast)
+	}).pipe(decodeTo(schema, fromJsonString$1));
+}
+/**
 * Schema for JavaScript `File` objects.
 *
 * **Details**
@@ -40536,7 +40686,7 @@ const toCodecEnsureArray = /* @__PURE__ */ toCodec((ast) => {
 	if (isUnion(ast) && ast.annotations?.[SERIALIZER_ENSURE_ARRAY]) return ast;
 	const out = onSerializerEnsureArray(ast);
 	if (isArrays(out)) {
-		const ensure = new Union$1([out, decodeTo$1(string, out, new Transformation(split(), passthrough$1()))], "anyOf", { [SERIALIZER_ENSURE_ARRAY]: true });
+		const ensure = new Union$1([out, decodeTo$1(string$3, out, new Transformation(split(), passthrough$1()))], "anyOf", { [SERIALIZER_ENSURE_ARRAY]: true });
 		return isOptional(ast) ? optionalKey$1(ensure) : ensure;
 	}
 	return out;
@@ -53690,6 +53840,31 @@ const integer = /* @__PURE__ */ makeSchemaPrimitive("Integer", Int);
 */
 const date = /* @__PURE__ */ makeSchemaPrimitive("Date", DateValid);
 /**
+* Creates a primitive that accepts any string value without validation.
+*
+* **Example** (Parsing string values)
+*
+* ```ts
+* import { Effect } from "effect"
+* import { Primitive } from "effect/unstable/cli"
+*
+* const parseString = Effect.gen(function*() {
+*   const result1 = yield* Primitive.string.parse("hello world")
+*   console.log(result1) // "hello world"
+*
+*   const result2 = yield* Primitive.string.parse("")
+*   console.log(result2) // ""
+*
+*   const result3 = yield* Primitive.string.parse("123")
+*   console.log(result3) // "123"
+* })
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const string$2 = /* @__PURE__ */ makePrimitive("String", (value) => succeed(value));
+/**
 * Creates a primitive that accepts only specific choice values mapped to custom types.
 *
 * **Example** (Parsing choices)
@@ -54834,6 +55009,33 @@ const makeSingle = (params) => {
 	});
 };
 /**
+* Creates a string parameter.
+*
+* **Example** (Creating string parameters)
+*
+* ```ts
+* import { Param } from "effect/unstable/cli"
+*
+* // @internal - this module is not exported publicly
+*
+* // Create a string flag
+* const nameFlag = Param.string(Param.flagKind, "name")
+*
+* // Create a string argument
+* const fileArg = Param.string(Param.argumentKind, "file")
+*
+* // Usage in CLI: --name "John Doe" or as positional argument
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const string$1 = (kind, name) => makeSingle({
+	name,
+	primitiveType: string$2,
+	kind
+});
+/**
 * Creates a boolean parameter.
 *
 * **Example** (Creating boolean parameters)
@@ -55406,6 +55608,22 @@ const getParamMetadata = (param) => {
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.83/node_modules/effect/dist/unstable/cli/Flag.js
 /**
+* Creates a string flag that accepts text input.
+*
+* **Example** (Creating string flags)
+*
+* ```ts
+* import { Flag } from "effect/unstable/cli"
+*
+* const nameFlag = Flag.string("name")
+* // Usage: --name "John Doe"
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const string = (name) => string$1(flagKind, name);
+/**
 * Creates a boolean flag that can be enabled or disabled.
 *
 * **Example** (Creating boolean flags)
@@ -204437,17 +204655,14 @@ var FileReadError = class extends TaggedError("FileReadError") {
 //#endregion
 //#region package.json
 var name = "@effect/tsgo";
-var version = "0.16.3";
+var version = "0.18.0";
 
 //#endregion
 //#region src/setup/consts.ts
 const LSP_PACKAGE_NAME = name;
 const LSP_PLUGIN_NAME = "@effect/language-service";
-const NATIVE_PREVIEW_PACKAGE_NAME = "@typescript/native-preview";
-const TYPESCRIPT_PACKAGE_NAME = "typescript";
+const defaultTypescriptPackageNames = ["typescript", "@typescript/native"];
 const PATCH_COMMAND = "effect-tsgo patch";
-const DEFAULT_LSP_VERSION = version;
-const DEFAULT_NATIVE_PREVIEW_VERSION = "latest";
 const TSCONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/Effect-TS/tsgo/refs/heads/main/schema.json";
 /**
 * `typescript` package versions >= 7 ship the native Go-ported binary that this
@@ -204458,24 +204673,8 @@ const isNativeTypescriptVersion = (version) => {
 	const match = /\d+/.exec(version.trim());
 	return match !== null && Number(match[0]) >= 7;
 };
-/** The `@typescript/native-preview` nightly backend (back-compat default). */
-const nativePreviewBackend = {
-	packageName: NATIVE_PREVIEW_PACKAGE_NAME,
-	platformPackagePrefix: "@typescript/native-preview",
-	binaryName: "tsgo"
-};
-/** The `typescript` >= 7 backend (stable/RC releases). */
-const typescriptBackend = {
-	packageName: TYPESCRIPT_PACKAGE_NAME,
-	platformPackagePrefix: "@typescript/typescript",
-	binaryName: "tsc",
-	versionCheck: (pkg) => isNativeTypescriptVersion(pkg.version ?? "0")
-};
 /**
-* Resolve the VS Code `typescript.native-preview.tsdk` folder for a backend.
-* The "TypeScript (Native Preview)" extension reads the native install from
-* this path; for `@typescript/native-preview` it is `node_modules/<pkg>`, and
-* for `typescript` >= 7 it is `node_modules/typescript`.
+* Resolve the VS Code TypeScript 7 tsdk folder.
 */
 const nativeBackendTsdkPath = (packageName) => "node_modules/" + packageName;
 
@@ -204533,14 +204732,17 @@ const assessPackageJson = (input) => {
 		return none$3();
 	};
 	const lspVersion = assessDependency(LSP_PACKAGE_NAME);
-	const nativePreviewVersion = orElse(assessDependency(NATIVE_PREVIEW_PACKAGE_NAME), () => {
-		const typescriptDep = assessDependency(TYPESCRIPT_PACKAGE_NAME);
-		if (isSome(typescriptDep) && isNativeTypescriptVersion(typescriptDep.value.version)) return some({
-			...typescriptDep.value,
-			packageName: TYPESCRIPT_PACKAGE_NAME
-		});
-		return none$3();
-	});
+	let typescriptVersion = none$3();
+	for (const packageName of defaultTypescriptPackageNames) {
+		const typescriptDep = assessDependency(packageName);
+		if (isSome(typescriptDep) && isNativeTypescriptVersion(typescriptDep.value.version)) {
+			typescriptVersion = some({
+				...typescriptDep.value,
+				packageName
+			});
+			break;
+		}
+	}
 	const prepareScript = "prepare" in (parsed.scripts ?? {}) ? some({
 		script: parsed.scripts.prepare,
 		hasPatch: parsed.scripts.prepare.toLowerCase().includes(PATCH_COMMAND)
@@ -204551,7 +204753,7 @@ const assessPackageJson = (input) => {
 		parsed,
 		text: input.text,
 		lspVersion,
-		nativePreviewVersion,
+		typescriptVersion,
 		prepareScript
 	};
 };
@@ -204890,17 +205092,20 @@ const computePackageJsonChanges = (current, target) => {
 	if (!rootObj) return emptyFileChangesResult();
 	const ctx = createTrackerContext();
 	const fileChange = tsInternal.textChanges.ChangeTracker.with(ctx, (tracker) => {
-		const nativeBackendPackageName = match$8(target.nativePreviewVersion, {
-			onNone: () => NATIVE_PREVIEW_PACKAGE_NAME,
-			onSome: (dep) => dep.packageName ?? NATIVE_PREVIEW_PACKAGE_NAME
-		});
-		const shouldAddNativePreviewWithDependencyType = (dependencyType) => isSome(target.nativePreviewVersion) && isNone(current.nativePreviewVersion) && target.nativePreviewVersion.value.dependencyType === dependencyType;
-		const ensureNativePreviewDependency = () => {
-			if (isNone(target.nativePreviewVersion) || isSome(current.nativePreviewVersion)) return;
-			const targetNativePreview = target.nativePreviewVersion.value;
-			if (!findDependencyCollectionProperty(rootObj, targetNativePreview.dependencyType) && isSome(target.lspVersion) && target.lspVersion.value.dependencyType === targetNativePreview.dependencyType) return;
-			descriptions.push(`Add ${nativeBackendPackageName}@${targetNativePreview.version} to ${targetNativePreview.dependencyType}`);
-			upsertDependency(tracker, current.sourceFile, rootObj, nativeBackendPackageName, targetNativePreview);
+		const shouldAddTypescriptWithDependencyType = (dependencyType) => isSome(target.typescriptVersion) && isNone(current.typescriptVersion) && target.typescriptVersion.value.dependencyType === dependencyType;
+		const getTypescriptPackageName = (dependency) => dependency.packageName ?? defaultTypescriptPackageNames[0];
+		const appendTypescriptDependencyProperty = (dependencyProperties) => {
+			const targetTypescript = target.typescriptVersion.pipe(getOrUndefined);
+			if (!targetTypescript) return;
+			dependencyProperties.push(import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(getTypescriptPackageName(targetTypescript)), import_typescript.factory.createStringLiteral(targetTypescript.version)));
+		};
+		const ensureTypescriptDependency = () => {
+			if (isNone(target.typescriptVersion) || isSome(current.typescriptVersion)) return;
+			const targetTypescript = target.typescriptVersion.value;
+			const targetTypescriptPackageName = getTypescriptPackageName(targetTypescript);
+			if (!findDependencyCollectionProperty(rootObj, targetTypescript.dependencyType) && isSome(target.lspVersion) && target.lspVersion.value.dependencyType === targetTypescript.dependencyType) return;
+			descriptions.push(`Add ${targetTypescriptPackageName}@${targetTypescript.version} to ${targetTypescript.dependencyType}`);
+			upsertDependency(tracker, current.sourceFile, rootObj, targetTypescriptPackageName, targetTypescript);
 		};
 		if (isSome(target.lspVersion)) {
 			const targetDepType = target.lspVersion.value.dependencyType;
@@ -204918,10 +205123,7 @@ const computePackageJsonChanges = (current, target) => {
 					const newDepsProperty = findDependencyCollectionProperty(rootObj, targetDepType);
 					if (!newDepsProperty) {
 						const dependencyProperties = [import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(LSP_PACKAGE_NAME), import_typescript.factory.createStringLiteral(targetVersion))];
-						if (shouldAddNativePreviewWithDependencyType(targetDepType)) {
-							const targetNativePreview = target.nativePreviewVersion.pipe(getOrUndefined);
-							if (targetNativePreview) dependencyProperties.push(import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(nativeBackendPackageName), import_typescript.factory.createStringLiteral(targetNativePreview.version)));
-						}
+						if (shouldAddTypescriptWithDependencyType(targetDepType)) appendTypescriptDependencyProperty(dependencyProperties);
 						const newDepsProp = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(targetDepType), import_typescript.factory.createObjectLiteralExpression(dependencyProperties, false));
 						insertNodeAtEndOfList(tracker, current.sourceFile, rootObj.properties, newDepsProp);
 					} else if (import_typescript.isObjectLiteralExpression(newDepsProperty.initializer)) insertNodeAtEndOfList(tracker, current.sourceFile, newDepsProperty.initializer.properties, import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(LSP_PACKAGE_NAME), import_typescript.factory.createStringLiteral(targetVersion)));
@@ -204938,15 +205140,12 @@ const computePackageJsonChanges = (current, target) => {
 				const depsProperty = findDependencyCollectionProperty(rootObj, targetDepType);
 				if (!depsProperty) {
 					const dependencyProperties = [import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(LSP_PACKAGE_NAME), import_typescript.factory.createStringLiteral(targetVersion))];
-					if (shouldAddNativePreviewWithDependencyType(targetDepType)) {
-						const targetNativePreview = target.nativePreviewVersion.pipe(getOrUndefined);
-						if (targetNativePreview) dependencyProperties.push(import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(nativeBackendPackageName), import_typescript.factory.createStringLiteral(targetNativePreview.version)));
-					}
+					if (shouldAddTypescriptWithDependencyType(targetDepType)) appendTypescriptDependencyProperty(dependencyProperties);
 					const newDepsProp = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(targetDepType), import_typescript.factory.createObjectLiteralExpression(dependencyProperties, false));
 					insertNodeAtEndOfList(tracker, current.sourceFile, rootObj.properties, newDepsProp);
 				} else if (import_typescript.isObjectLiteralExpression(depsProperty.initializer)) insertNodeAtEndOfList(tracker, current.sourceFile, depsProperty.initializer.properties, import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(LSP_PACKAGE_NAME), import_typescript.factory.createStringLiteral(targetVersion)));
 			}
-			ensureNativePreviewDependency();
+			ensureTypescriptDependency();
 		} else if (isSome(current.lspVersion)) {
 			descriptions.push(`Remove ${LSP_PACKAGE_NAME} from dependencies`);
 			const currentDepType = current.lspVersion.value.dependencyType;
@@ -205230,7 +205429,7 @@ const computeChanges = (assessment, target) => {
 		if (target.editors.includes("vscode")) messages = [
 			...messages,
 			"VS Code / Cursor / VS Code-based editors:",
-			"  1. Install the @typescript/native-preview extension",
+			"  1. Install the TypeScript 7 extension",
 			"  2. Open a TypeScript file and ensure the native TS server is active",
 			"  3. The language service plugin will be loaded automatically",
 			""
@@ -207159,7 +207358,7 @@ function createRulePrompt(rules, initialSeverities) {
 const fromAssessment = (inputState) => ({
 	packageJson: {
 		lspVersion: inputState.packageJson.lspVersion,
-		nativePreviewVersion: inputState.packageJson.nativePreviewVersion,
+		typescriptVersion: inputState.packageJson.typescriptVersion,
 		prepareScript: map$10(inputState.packageJson.prepareScript, (_) => _.hasPatch).pipe(getOrElse$1(() => false))
 	},
 	tsconfig: { diagnosticSeverities: inputState.tsconfig.currentDiagnosticSeverities },
@@ -207331,7 +207530,7 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 	if (lspDependencyType === "no") return {
 		packageJson: {
 			lspVersion: none$3(),
-			nativePreviewVersion: assessment.packageJson.nativePreviewVersion,
+			typescriptVersion: assessment.packageJson.typescriptVersion,
 			prepareScript: false
 		},
 		tsconfig: { diagnosticSeverities: none$3() },
@@ -207378,12 +207577,9 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 			}
 		]
 	});
-	const nativeBackendPackage = match$8(assessment.packageJson.nativePreviewVersion, {
-		onNone: () => NATIVE_PREVIEW_PACKAGE_NAME,
-		onSome: (dep) => dep.packageName ?? NATIVE_PREVIEW_PACKAGE_NAME
-	});
+	const defaultTypescriptPackageName = defaultTypescriptPackageNames[0];
 	const vscodeSettings = editors.includes("vscode") ? some({ settings: {
-		"typescript.native-preview.tsdk": nativeBackendTsdkPath(nativeBackendPackage),
+		"typescript.native-preview.tsdk": nativeBackendTsdkPath(defaultTypescriptPackageName),
 		"typescript.experimental.useTsgo": true,
 		"js/ts.experimental.useTsgo": true
 	} }) : none$3();
@@ -207393,9 +207589,10 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 				dependencyType: lspDependencyType,
 				version: context.defaultLspVersion
 			}),
-			nativePreviewVersion: orElse(assessment.packageJson.nativePreviewVersion, () => some({
+			typescriptVersion: orElse(assessment.packageJson.typescriptVersion, () => some({
 				dependencyType: lspDependencyType,
-				version: DEFAULT_NATIVE_PREVIEW_VERSION
+				version: context.defaultTypescriptVersion,
+				packageName: defaultTypescriptPackageName
 			})),
 			prepareScript: true
 		},
@@ -207405,6 +207602,10 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 	};
 });
 
+//#endregion
+//#region upstream.json
+var tsVersion = "7.1.0-dev.20260708.3";
+
 //#endregion
 //#region src/setup/index.ts
 const setupCommand = make("setup").pipe(withDescription("Setup @effect/tsgo for the given project using an interactive CLI."), withHandler(() => gen(function* () {
@@ -207412,7 +207613,10 @@ const setupCommand = make("setup").pipe(withDescription("Setup @effect/tsgo for
 	const tsconfigInput = yield* selectTsConfigFile(currentDir);
 	const assessmentInput = yield* createAssessmentInput(currentDir, tsconfigInput);
 	const assessmentState = assess(assessmentInput);
-	const targetState = yield* gatherTargetState(assessmentState, { defaultLspVersion: DEFAULT_LSP_VERSION });
+	const targetState = yield* gatherTargetState(assessmentState, {
+		defaultLspVersion: version,
+		defaultTypescriptVersion: tsVersion
+	});
 	const result = computeChanges(assessmentState, targetState);
 	yield* reviewAndApplyChanges(result, assessmentState, { cancelMessage: "Setup cancelled. No changes were made." });
 })));
@@ -207421,7 +207625,27 @@ const setupCommand = make("setup").pipe(withDescription("Setup @effect/tsgo for
 //#region src/cli.ts
 var NativeBackendNotInstalledError = class extends TaggedError("NativeBackendNotInstalledError") {
 	get message() {
-		return "No native TypeScript backend is installed. Install one of the following first: `@typescript/native-preview` or `typescript` (>= 7, e.g. `typescript@rc`).";
+		return "No native TypeScript backend is installed. Install `typescript` >= 7 first (e.g. `typescript@latest` or `typescript@next`) or `@typescript/native` (e.g. `@typescript/native@npm:typescript@latest`). Tried: " + this.packageNames.join(", ") + ".";
+	}
+};
+var PackageNotFoundError = class extends TaggedError("PackageNotFoundError") {
+	get message() {
+		return `Unable to resolve ${this.packageName}.`;
+	}
+};
+var ParsePackageJsonError = class extends TaggedError("ParsePackageJsonError") {
+	get message() {
+		return `Unable to parse ${this.packageName} package.json at ${this.packageJsonPath}: ${this.reason}`;
+	}
+};
+var BinaryMetadataNotFoundError = class extends TaggedError("BinaryMetadataNotFoundError") {
+	get message() {
+		return `Binary metadata not found at ${this.metadataPath}.`;
+	}
+};
+var ParseBinaryMetadataError = class extends TaggedError("ParseBinaryMetadataError") {
+	get message() {
+		return `Unable to parse binary metadata at ${this.metadataPath}: ${this.reason}`;
 	}
 };
 var UnsupportedPlatformPackageError = class extends TaggedError("UnsupportedPlatformPackageError") {
@@ -207439,6 +207663,22 @@ var ResolvePackagedBinaryError = class extends TaggedError("ResolvePackagedBinar
 		return this.reason;
 	}
 };
+var PackagedBinaryVersionMismatchError = class extends TaggedError("PackagedBinaryVersionMismatchError") {
+	get message() {
+		const tried = this.candidates.length === 0 ? "  none" : this.candidates.map((candidate) => {
+			if (candidate.tsVersion !== void 0 && candidate.tsGitHead !== void 0) return `  ${candidate.binaryName}: TypeScript ${candidate.tsVersion}, gitHead ${candidate.tsGitHead}`;
+			return `  ${candidate.binaryName}: ${candidate.reason ?? "metadata unavailable"}`;
+		}).join("\n");
+		return [
+			`No packaged Effect TypeScript binary matches installed TypeScript ${this.installedVersion} gitHead ${this.installedGitHead}.`,
+			"",
+			"Tried:",
+			tried,
+			"",
+			"Install a matching @effect/tsgo release or a matching TypeScript version, or rerun with --force to use the newest packaged binary."
+		].join("\n");
+	}
+};
 var BackupRestoreError = class extends TaggedError("BackupRestoreError") {
 	get message() {
 		return this.reason;
@@ -207459,74 +207699,95 @@ var VerificationFailedError = class extends TaggedError("VerificationFailedError
 		return "Warning: verification failed for " + this.targetPath + ", but binary was patched. The binary may still work correctly.";
 	}
 };
-const probeBackend = (backend, cwdRequire, path) => {
-	const isWin = process.platform === "win32";
-	let mainPkg;
-	try {
-		mainPkg = cwdRequire(backend.packageName + "/package.json");
-	} catch {
-		return { _tag: "notInstalled" };
-	}
-	if (backend.versionCheck !== void 0 && !backend.versionCheck(mainPkg)) return { _tag: "notInstalled" };
-	let mainPackageJsonPath;
-	try {
-		mainPackageJsonPath = cwdRequire.resolve(backend.packageName + "/package.json");
-	} catch {
-		return { _tag: "notInstalled" };
-	}
-	const backendRequire = node_module.createRequire(mainPackageJsonPath);
-	const platformPackageName = backend.platformPackagePrefix + "-" + process.platform + "-" + process.arch;
-	let platformPackageJsonPath;
-	try {
-		platformPackageJsonPath = backendRequire.resolve(platformPackageName + "/package.json");
-	} catch {
-		return {
-			_tag: "unsupportedPlatform",
-			packageName: platformPackageName
-		};
-	}
-	const platformDir = path.dirname(platformPackageJsonPath);
-	const binaryName = backend.binaryName + (isWin ? ".exe" : "");
+const PackageJsonMetadataSchema = Struct({
+	name: String$1,
+	version: String$1,
+	gitHead: String$1
+});
+const PackageJsonMetadataFromStringSchema = fromJsonString(PackageJsonMetadataSchema);
+const BinaryMetadataSchema = Struct({
+	tsVersion: String$1,
+	tsGitHead: String$1
+});
+const BinaryMetadataFromStringSchema = fromJsonString(BinaryMetadataSchema);
+const packagedTypeScriptBinaryNames = ["tsc", "tsc-next"];
+const decodePackageJsonText = (packageName, packageJsonPath, text) => decodeUnknownEffect(PackageJsonMetadataFromStringSchema)(text).pipe(mapError((error) => new ParsePackageJsonError({
+	packageName,
+	packageJsonPath,
+	reason: error.message
+})));
+const readPackageJsonFile = (packageName, packageJsonPath) => gen(function* () {
 	return {
-		_tag: "resolved",
-		path: path.join(platformDir, "lib", binaryName),
-		binaryName: backend.binaryName
+		requestedPackageName: packageName,
+		packageJsonPath,
+		...yield* decodePackageJsonText(packageName, packageJsonPath, yield* (yield* FileSystem).readFileString(packageJsonPath).pipe(mapError((error) => new ParsePackageJsonError({
+			packageName,
+			packageJsonPath,
+			reason: error.message
+		}))))
 	};
-};
-/**
-* Resolve the native TypeScript binary to patch. The `@typescript/native-preview`
-* backend is tried first (back-compat), then the `typescript` >= 7 package so
-* that the TypeScript 7 RC/stable release is supported out of the box.
-*
-* Returns the target binary path plus the backend's base binary name (`tsgo` or
-* `tsc`); the latter selects the matching Effect-patched artifact from
-* `@effect/tsgo-*` (which ships separate `lib/tsgo` and `lib/tsc` builds).
-*/
-const getNativeBackendBinaryPath = gen(function* () {
+});
+const resolvePackageJson = (cwd, packageName) => gen(function* () {
 	const path = yield* Path;
-	const cwdRequire = node_module.createRequire(path.join(process.cwd(), "noop.js"));
-	const nativePreviewResult = probeBackend(nativePreviewBackend, cwdRequire, path);
-	if (nativePreviewResult._tag === "resolved") return {
-		targetPath: nativePreviewResult.path,
-		binaryName: nativePreviewResult.binaryName
-	};
-	if (nativePreviewResult._tag === "unsupportedPlatform") return yield* fail(new UnsupportedPlatformPackageError({ packageName: nativePreviewResult.packageName }));
-	const typescriptResult = probeBackend(typescriptBackend, cwdRequire, path);
-	if (typescriptResult._tag === "resolved") return {
-		targetPath: typescriptResult.path,
-		binaryName: typescriptResult.binaryName
+	const cwdRequire = node_module.createRequire(path.join(cwd, "noop.js"));
+	return yield* readPackageJsonFile(packageName, yield* try_({
+		try: () => cwdRequire.resolve(packageName + "/package.json"),
+		catch: () => new PackageNotFoundError({ packageName })
+	}));
+});
+const decodeBinaryMetadataText = (metadataPath, text) => decodeUnknownEffect(BinaryMetadataFromStringSchema)(text).pipe(mapError((error) => new ParseBinaryMetadataError({
+	metadataPath,
+	reason: error.message
+})));
+const readBinaryMetadata = (binaryPath) => gen(function* () {
+	const fs = yield* FileSystem;
+	const metadataPath = binaryPath + ".json";
+	if (!(yield* fs.exists(metadataPath))) return yield* fail(new BinaryMetadataNotFoundError({ metadataPath }));
+	return yield* decodeBinaryMetadataText(metadataPath, yield* fs.readFileString(metadataPath).pipe(mapError((error) => new ParseBinaryMetadataError({
+		metadataPath,
+		reason: error.message
+	}))));
+});
+const resolveOfficialTypeScriptBinary = (typescriptPackage) => gen(function* () {
+	const path = yield* Path;
+	const platformPackageName = "@typescript/typescript-" + process.platform + "-" + process.arch;
+	const packageRequire = node_module.createRequire(typescriptPackage.packageJsonPath);
+	const platformPackageJsonPath = yield* try_({
+		try: () => packageRequire.resolve(platformPackageName + "/package.json"),
+		catch: () => new UnsupportedPlatformPackageError({ packageName: platformPackageName })
+	});
+	const platformPackage = yield* readPackageJsonFile(platformPackageName, platformPackageJsonPath);
+	const binaryName = "tsc" + (process.platform === "win32" ? ".exe" : "");
+	return {
+		packageName: typescriptPackage.requestedPackageName,
+		packageJsonPath: typescriptPackage.packageJsonPath,
+		packageVersion: typescriptPackage.version,
+		packageGitHead: typescriptPackage.gitHead,
+		platformPackageName,
+		platformPackageJsonPath,
+		platformGitHead: platformPackage.gitHead,
+		binaryPath: path.join(path.dirname(platformPackageJsonPath), "lib", binaryName)
 	};
-	if (typescriptResult._tag === "unsupportedPlatform") return yield* fail(new UnsupportedPlatformPackageError({ packageName: typescriptResult.packageName }));
-	return yield* fail(new NativeBackendNotInstalledError({ details: "no native backend found" }));
 });
+const resolveInstalledTypeScriptBinary = (packageNames) => gen(function* () {
+	for (const packageName of packageNames) {
+		const packageResult = yield* resolvePackageJson(process.cwd(), packageName).pipe(catchTag("PackageNotFoundError", () => succeed(void 0)));
+		if (packageResult === void 0 || !isNativeTypescriptVersion(packageResult.version)) continue;
+		return yield* resolveOfficialTypeScriptBinary(packageResult);
+	}
+	return yield* fail(new NativeBackendNotInstalledError({ packageNames }));
+});
+const packageNamesWithPreferred = (preferredPackageName) => {
+	const preferred = getOrUndefined(preferredPackageName);
+	return preferred === void 0 || preferred === "" ? defaultTypescriptPackageNames : Array.from(new Set([preferred, ...defaultTypescriptPackageNames]));
+};
 /**
 * Resolve the Effect-patched binary to copy over the native target. The
-* `@effect/tsgo-*` platform package ships separate `lib/tsgo` (built from
-* `main`) and `lib/tsc` (built from `generated/stable`) artifacts; `binaryName`
-* selects the one matching the detected native backend so the correct build is
-* installed. Defaults to `tsgo` for the `get-exe-path` command.
+* `@effect/tsgo-*` platform package ships `lib/tsc` (built from
+* `generated/latest`) and `lib/tsc-next` (built from `main`). The adjacent JSON
+* metadata files identify the TypeScript gitHead each binary was built from.
 */
-const getPackagedBinaryPath = (binaryName = "tsgo") => gen(function* () {
+const getPackagedBinaryPath = (installedTypeScript, force) => gen(function* () {
 	const fs = yield* FileSystem;
 	const path = yield* Path;
 	const packageName = "@effect/tsgo-" + process.platform + "-" + process.arch;
@@ -207536,17 +207797,71 @@ const getPackagedBinaryPath = (binaryName = "tsgo") => gen(function* () {
 		catch: () => new ResolvePackagedBinaryError({ reason: `Unable to resolve ${packageName}. Either your platform is unsupported, or the platform package is not installed.` })
 	});
 	const packageDir = path.dirname(packageJsonPath);
-	const exeName = binaryName + (process.platform === "win32" ? ".exe" : "");
-	const exePath = path.join(packageDir, "lib", exeName);
-	if (!(yield* fs.exists(exePath))) return yield* fail(new ResolvePackagedBinaryError({ reason: "Executable not found: " + exePath }));
-	return exePath;
+	const candidates = [];
+	for (const binaryName of packagedTypeScriptBinaryNames) {
+		const exeName = binaryName + (process.platform === "win32" ? ".exe" : "");
+		const exePath = path.join(packageDir, "lib", exeName);
+		if (!(yield* fs.exists(exePath))) {
+			candidates.push({
+				binaryName,
+				reason: "binary not packaged"
+			});
+			continue;
+		}
+		const metadataResult = yield* readBinaryMetadata(exePath).pipe(match$1({
+			onFailure: (error) => ({
+				_tag: "failure",
+				error
+			}),
+			onSuccess: (metadata) => ({
+				_tag: "success",
+				metadata
+			})
+		}));
+		if (metadataResult._tag === "failure") {
+			candidates.push({
+				binaryName,
+				path: exePath,
+				reason: metadataResult.error.message
+			});
+			continue;
+		}
+		const metadata = metadataResult.metadata;
+		const candidate = {
+			binaryName,
+			path: exePath,
+			metadata,
+			...metadata
+		};
+		if (metadata.tsGitHead === installedTypeScript.packageGitHead) return exePath;
+		candidates.push(candidate);
+	}
+	if (force) {
+		const fallback = candidates.find((candidate) => candidate.binaryName === "tsc-next" && candidate.path !== void 0) ?? candidates.find((candidate) => candidate.binaryName === "tsc" && candidate.path !== void 0);
+		if (fallback?.path !== void 0) {
+			yield* warn(new PackagedBinaryVersionMismatchError({
+				installedVersion: installedTypeScript.packageVersion,
+				installedGitHead: installedTypeScript.packageGitHead,
+				candidates
+			}).message);
+			yield* warn("Forcing patch with " + fallback.binaryName + ". This may be incompatible.");
+			return fallback.path;
+		}
+	}
+	if (candidates.length === 0) return yield* fail(new ResolvePackagedBinaryError({ reason: "No packaged TypeScript binaries were found in " + path.join(packageDir, "lib") }));
+	return yield* fail(new PackagedBinaryVersionMismatchError({
+		installedVersion: installedTypeScript.packageVersion,
+		installedGitHead: installedTypeScript.packageGitHead,
+		candidates
+	}));
 });
-const patch = gen(function* () {
+const patch = (force, packageNames) => gen(function* () {
 	const fs = yield* FileSystem;
 	const path = yield* Path;
-	const { targetPath, binaryName } = yield* getNativeBackendBinaryPath;
+	const installedTypeScript = yield* resolveInstalledTypeScriptBinary(packageNames);
+	const targetPath = installedTypeScript.binaryPath;
 	const backupPath = path.join(path.dirname(targetPath), path.basename(targetPath) + ".original");
-	const ourBinaryPath = yield* getPackagedBinaryPath(binaryName);
+	const ourBinaryPath = yield* getPackagedBinaryPath(installedTypeScript, force);
 	if (!(yield* fs.exists(targetPath))) return yield* fail(new MissingTargetBinaryError({ targetPath }));
 	let actualBackupPath = backupPath;
 	let counter = 1;
@@ -207576,7 +207891,7 @@ const patch = gen(function* () {
 const unpatch = gen(function* () {
 	const fs = yield* FileSystem;
 	const path = yield* Path;
-	const { targetPath } = yield* getNativeBackendBinaryPath;
+	const { binaryPath: targetPath } = yield* resolveInstalledTypeScriptBinary(defaultTypescriptPackageNames);
 	const backupPath = path.join(path.dirname(targetPath), path.basename(targetPath) + ".original");
 	if (!(yield* fs.exists(backupPath))) {
 		yield* error("No backup found at " + backupPath + ". Nothing to restore.");
@@ -207593,9 +207908,12 @@ const unpatch = gen(function* () {
 	yield* fs.rename(backupPath, targetPath).pipe(mapError(() => new BackupRestoreError({ reason: `Failed to restore backup from ${backupPath} to ${targetPath}.` })));
 	yield* log("Restored original binary at " + targetPath);
 });
-const patchCommand = make("patch").pipe(withDescription("Patch the Effect Language Service binary"), withHandler(() => patch));
+const patchCommand = make("patch", {
+	force: boolean("force"),
+	typescriptPackage: optional(string("typescript-package").pipe(withDescription$1("Native TypeScript package name to try before the default package names")))
+}).pipe(withDescription("Patch the Effect Language Service binary"), withHandler(({ force, typescriptPackage }) => patch(force, packageNamesWithPreferred(typescriptPackage))));
 const unpatchCommand = make("unpatch").pipe(withDescription("Unpatch and restore the original TypeScript-Go binary"), withHandler(() => unpatch));
-const getExePathCommand = make("get-exe-path").pipe(withDescription("Print the Effect Language Service executable path"), withHandler(() => getPackagedBinaryPath().pipe(flatMap((exePath) => log(exePath)))));
+const getExePathCommand = make("get-exe-path").pipe(withDescription("Print the Effect Language Service executable path"), withHandler(() => resolveInstalledTypeScriptBinary(defaultTypescriptPackageNames).pipe(flatMap((installedTypeScript) => getPackagedBinaryPath(installedTypeScript, false)), flatMap((exePath) => log(exePath)))));
 make("tsgo").pipe(withSubcommands([
 	patchCommand,
 	unpatchCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/tsgo",
-  "version": "0.16.3",
+  "version": "0.18.0",
   "description": "Effect Language Service for TypeScript-Go — Effect-specific diagnostics and hover features.",
   "license": "MIT",
   "repository": {
@@ -22,13 +22,13 @@
     "README.md"
   ],
   "optionalDependencies": {
-    "@effect/tsgo-win32-x64": "0.16.3",
-    "@effect/tsgo-win32-arm64": "0.16.3",
-    "@effect/tsgo-linux-x64": "0.16.3",
-    "@effect/tsgo-linux-arm64": "0.16.3",
-    "@effect/tsgo-linux-arm": "0.16.3",
-    "@effect/tsgo-darwin-x64": "0.16.3",
-    "@effect/tsgo-darwin-arm64": "0.16.3"
+    "@effect/tsgo-win32-x64": "0.18.0",
+    "@effect/tsgo-win32-arm64": "0.18.0",
+    "@effect/tsgo-linux-x64": "0.18.0",
+    "@effect/tsgo-linux-arm64": "0.18.0",
+    "@effect/tsgo-linux-arm": "0.18.0",
+    "@effect/tsgo-darwin-x64": "0.18.0",
+    "@effect/tsgo-darwin-arm64": "0.18.0"
   },
   "devDependencies": {
     "@effect/platform-node": "^4.0.0-beta.83",