@effect/tsgo 0.17.0 → 0.18.1

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`: `typescript` >= 7 (e.g. `typescript@latest` or `typescript@next`). `effect-tsgo patch` selects the packaged Effect binary whose TypeScript git head matches the installed `typescript` package.
+> 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,13 +204655,13 @@ var FileReadError = class extends TaggedError("FileReadError") {
 //#endregion
 //#region package.json
 var name = "@effect/tsgo";
-var version = "0.17.0";
+var version = "0.18.1";
 
 //#endregion
 //#region src/setup/consts.ts
 const LSP_PACKAGE_NAME = name;
 const LSP_PLUGIN_NAME = "@effect/language-service";
-const TYPESCRIPT_PACKAGE_NAME = "typescript";
+const defaultTypescriptPackageNames = ["typescript", "@typescript/native"];
 const PATCH_COMMAND = "effect-tsgo patch";
 const TSCONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/Effect-TS/tsgo/refs/heads/main/schema.json";
 /**
@@ -204455,13 +204673,6 @@ const isNativeTypescriptVersion = (version) => {
 	const match = /\d+/.exec(version.trim());
 	return match !== null && Number(match[0]) >= 7;
 };
-/** The `typescript` >= 7 backend. */
-const typescriptBackend = {
-	packageName: TYPESCRIPT_PACKAGE_NAME,
-	platformPackagePrefix: "@typescript/typescript",
-	binaryName: "tsc",
-	versionCheck: (pkg) => isNativeTypescriptVersion(pkg.version ?? "0")
-};
 /**
 * Resolve the VS Code TypeScript 7 tsdk folder.
 */
@@ -204521,11 +204732,17 @@ const assessPackageJson = (input) => {
 		return none$3();
 	};
 	const lspVersion = assessDependency(LSP_PACKAGE_NAME);
-	const typescriptDep = assessDependency(TYPESCRIPT_PACKAGE_NAME);
-	const typescriptVersion = isSome(typescriptDep) && isNativeTypescriptVersion(typescriptDep.value.version) ? some({
-		...typescriptDep.value,
-		packageName: TYPESCRIPT_PACKAGE_NAME
-	}) : 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)
@@ -204876,12 +205093,19 @@ const computePackageJsonChanges = (current, target) => {
 	const ctx = createTrackerContext();
 	const fileChange = tsInternal.textChanges.ChangeTracker.with(ctx, (tracker) => {
 		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 ${TYPESCRIPT_PACKAGE_NAME}@${targetTypescript.version} to ${targetTypescript.dependencyType}`);
-			upsertDependency(tracker, current.sourceFile, rootObj, TYPESCRIPT_PACKAGE_NAME, targetTypescript);
+			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;
@@ -204899,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 (shouldAddTypescriptWithDependencyType(targetDepType)) {
-							const targetTypescript = target.typescriptVersion.pipe(getOrUndefined);
-							if (targetTypescript) dependencyProperties.push(import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(TYPESCRIPT_PACKAGE_NAME), import_typescript.factory.createStringLiteral(targetTypescript.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)));
@@ -204919,10 +205140,7 @@ 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 (shouldAddTypescriptWithDependencyType(targetDepType)) {
-						const targetTypescript = target.typescriptVersion.pipe(getOrUndefined);
-						if (targetTypescript) dependencyProperties.push(import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(TYPESCRIPT_PACKAGE_NAME), import_typescript.factory.createStringLiteral(targetTypescript.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)));
@@ -207359,8 +207577,9 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 			}
 		]
 	});
+	const defaultTypescriptPackageName = defaultTypescriptPackageNames[0];
 	const vscodeSettings = editors.includes("vscode") ? some({ settings: {
-		"typescript.native-preview.tsdk": nativeBackendTsdkPath(TYPESCRIPT_PACKAGE_NAME),
+		"typescript.native-preview.tsdk": nativeBackendTsdkPath(defaultTypescriptPackageName),
 		"typescript.experimental.useTsgo": true,
 		"js/ts.experimental.useTsgo": true
 	} }) : none$3();
@@ -207373,7 +207592,7 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 			typescriptVersion: orElse(assessment.packageJson.typescriptVersion, () => some({
 				dependencyType: lspDependencyType,
 				version: context.defaultTypescriptVersion,
-				packageName: TYPESCRIPT_PACKAGE_NAME
+				packageName: defaultTypescriptPackageName
 			})),
 			prepareScript: true
 		},
@@ -207406,7 +207625,17 @@ 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 `typescript` >= 7 first (e.g. `typescript@latest` or `typescript@next`).";
+		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 MissingTypeScriptMetadataError = class extends TaggedError("MissingTypeScriptMetadataError") {
@@ -207414,6 +207643,16 @@ var MissingTypeScriptMetadataError = class extends TaggedError("MissingTypeScrip
 		return `Installed ${this.packageName} package.json does not contain a gitHead. Unable to select a compatible Effect binary.`;
 	}
 };
+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") {
 	get message() {
 		return `Unable to resolve ${this.packageName}. Your platform may not be supported by the installed native TypeScript backend.`;
@@ -207465,63 +207704,90 @@ var VerificationFailedError = class extends TaggedError("VerificationFailedError
 		return "Warning: verification failed for " + this.targetPath + ", but binary was patched. The binary may still work correctly.";
 	}
 };
+const PackageJsonMetadataSchema = Struct({
+	name: String$1,
+	version: String$1,
+	gitHead: optionalKey(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 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 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,
-		packageJson: mainPkg
+		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 supported upstream package
-* is `typescript` >= 7, whose platform package exposes a `tsc` executable.
-*/
-const getNativeBackendBinaryPath = gen(function* () {
+});
+const resolvePackageJson = (cwd, packageName) => gen(function* () {
 	const path = yield* Path;
-	const typescriptResult = probeBackend(typescriptBackend, node_module.createRequire(path.join(process.cwd(), "noop.js")), path);
-	if (typescriptResult._tag === "resolved") {
-		const installedGitHead = typescriptResult.packageJson.gitHead;
-		if (installedGitHead === void 0) return yield* fail(new MissingTypeScriptMetadataError({ packageName: typescriptBackend.packageName }));
-		return {
-			targetPath: typescriptResult.path,
-			installedTypeScript: {
-				version: typescriptResult.packageJson.version ?? "unknown",
-				gitHead: installedGitHead
-			}
-		};
+	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 packageGitHead = typescriptPackage.gitHead;
+	if (packageGitHead === void 0) return yield* fail(new MissingTypeScriptMetadataError({ packageName: typescriptPackage.requestedPackageName }));
+	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,
+		platformPackageName,
+		platformPackageJsonPath,
+		platformGitHead: platformPackage.gitHead,
+		binaryPath: path.join(path.dirname(platformPackageJsonPath), "lib", binaryName)
+	};
+});
+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);
 	}
-	if (typescriptResult._tag === "unsupportedPlatform") return yield* fail(new UnsupportedPlatformPackageError({ packageName: typescriptResult.packageName }));
-	return yield* fail(new NativeBackendNotInstalledError({ details: "no native backend found" }));
+	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 `lib/tsc` (built from
@@ -207542,7 +207808,6 @@ const getPackagedBinaryPath = (installedTypeScript, force) => gen(function* () {
 	for (const binaryName of packagedTypeScriptBinaryNames) {
 		const exeName = binaryName + (process.platform === "win32" ? ".exe" : "");
 		const exePath = path.join(packageDir, "lib", exeName);
-		const metadataPath = exePath + ".json";
 		if (!(yield* fs.exists(exePath))) {
 			candidates.push({
 				binaryName,
@@ -207550,40 +207815,40 @@ const getPackagedBinaryPath = (installedTypeScript, force) => gen(function* () {
 			});
 			continue;
 		}
-		if (!(yield* fs.exists(metadataPath))) {
+		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: "metadata not packaged"
+				reason: metadataResult.error.message
 			});
 			continue;
 		}
-		const metadata = yield* fs.readFileString(metadataPath).pipe(flatMap((text) => try_({
-			try: () => {
-				const parsed = JSON.parse(text);
-				if (typeof parsed.tsVersion !== "string" || typeof parsed.tsGitHead !== "string") throw new Error("invalid metadata");
-				return {
-					tsVersion: parsed.tsVersion,
-					tsGitHead: parsed.tsGitHead
-				};
-			},
-			catch: () => new ResolvePackagedBinaryError({ reason: "Invalid binary metadata: " + metadataPath })
-		})));
+		const metadata = metadataResult.metadata;
 		const candidate = {
 			binaryName,
 			path: exePath,
 			metadata,
 			...metadata
 		};
-		if (metadata.tsGitHead === installedTypeScript.gitHead) return exePath;
+		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.version,
-				installedGitHead: installedTypeScript.gitHead,
+				installedVersion: installedTypeScript.packageVersion,
+				installedGitHead: installedTypeScript.packageGitHead,
 				candidates
 			}).message);
 			yield* warn("Forcing patch with " + fallback.binaryName + ". This may be incompatible.");
@@ -207592,15 +207857,16 @@ const getPackagedBinaryPath = (installedTypeScript, force) => gen(function* () {
 	}
 	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.version,
-		installedGitHead: installedTypeScript.gitHead,
+		installedVersion: installedTypeScript.packageVersion,
+		installedGitHead: installedTypeScript.packageGitHead,
 		candidates
 	}));
 });
-const patch = (force) => gen(function* () {
+const patch = (force, packageNames) => gen(function* () {
 	const fs = yield* FileSystem;
 	const path = yield* Path;
-	const { targetPath, installedTypeScript } = 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(installedTypeScript, force);
 	if (!(yield* fs.exists(targetPath))) return yield* fail(new MissingTargetBinaryError({ targetPath }));
@@ -207632,7 +207898,7 @@ const patch = (force) => 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.");
@@ -207649,9 +207915,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", { force: boolean("force") }).pipe(withDescription("Patch the Effect Language Service binary"), withHandler(({ force }) => patch(force)));
+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(() => getNativeBackendBinaryPath.pipe(flatMap(({ installedTypeScript }) => getPackagedBinaryPath(installedTypeScript, false)), 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.17.0",
+  "version": "0.18.1",
   "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.17.0",
-    "@effect/tsgo-win32-arm64": "0.17.0",
-    "@effect/tsgo-linux-x64": "0.17.0",
-    "@effect/tsgo-linux-arm64": "0.17.0",
-    "@effect/tsgo-linux-arm": "0.17.0",
-    "@effect/tsgo-darwin-x64": "0.17.0",
-    "@effect/tsgo-darwin-arm64": "0.17.0"
+    "@effect/tsgo-win32-x64": "0.18.1",
+    "@effect/tsgo-win32-arm64": "0.18.1",
+    "@effect/tsgo-linux-x64": "0.18.1",
+    "@effect/tsgo-linux-arm64": "0.18.1",
+    "@effect/tsgo-linux-arm": "0.18.1",
+    "@effect/tsgo-darwin-x64": "0.18.1",
+    "@effect/tsgo-darwin-arm64": "0.18.1"
   },
   "devDependencies": {
     "@effect/platform-node": "^4.0.0-beta.83",