@danieljvdm/dev-kit 0.11.3 → 0.12.0

package/src/effect-tsgo.ts

@@ -5,7 +5,7 @@ import { printStatus, withSpinner } from "./cli-ui.ts";
 import { acquireProjectProcessLock } from "./project-process-lock.ts";
 import { isTypeScriptPackageName } from "./typescript-package-name.ts";
 
-export const EFFECT_TSGO_VERSION = "0.24.3";
+export const EFFECT_TSGO_VERSION = "0.33.0";
 export const EFFECT_TSGO_TYPESCRIPT_VERSION = "7.0.2";
 export const EFFECT_TSGO_PLUGIN_NAME = "@effect/language-service";
 
@@ -18,6 +18,7 @@ export type EffectTsgoPatchOptions = {
 
 export type EffectTsgoPatchPlan = {
   readonly alreadyPatched: boolean;
+  readonly unpatchArgs?: ReadonlyArray<string>;
   readonly projectDir: string;
   readonly executable: string;
   readonly args: ReadonlyArray<string>;
@@ -26,7 +27,7 @@ export type EffectTsgoPatchPlan = {
   readonly typescriptVersion: string;
 };
 
-export class EffectTsgoDependencyError extends Schema.TaggedErrorClass<EffectTsgoDependencyError>()(
+export class EffectTsgoDependencyError extends Schema.TaggedError<EffectTsgoDependencyError>()(
   "EffectTsgoDependencyError",
   {
     packageName: Schema.String,
@@ -41,7 +42,7 @@ export class EffectTsgoDependencyError extends Schema.TaggedErrorClass<EffectTsg
   }
 }
 
-export class EffectTsgoPatchCommandError extends Schema.TaggedErrorClass<EffectTsgoPatchCommandError>()(
+export class EffectTsgoPatchCommandError extends Schema.TaggedError<EffectTsgoPatchCommandError>()(
   "EffectTsgoPatchCommandError",
   {
     command: Schema.String,
@@ -56,7 +57,7 @@ export class EffectTsgoPatchCommandError extends Schema.TaggedErrorClass<EffectT
   }
 }
 
-export class InvalidEffectTsgoPackageNameError extends Schema.TaggedErrorClass<InvalidEffectTsgoPackageNameError>()(
+export class InvalidEffectTsgoPackageNameError extends Schema.TaggedError<InvalidEffectTsgoPackageNameError>()(
   "InvalidEffectTsgoPackageNameError",
   { packageName: Schema.String },
 ) {
@@ -82,15 +83,15 @@ const readExactPackageVersion = Effect.fn("readExactEffectTsgoPackageVersion")(f
     .readFileString(manifestPath)
     .pipe(
       Effect.catchReason("PlatformError", "NotFound", () =>
-        Effect.fail(new EffectTsgoDependencyError({ packageName, expectedVersion })),
+        Effect.fail(EffectTsgoDependencyError.make({ packageName, expectedVersion })),
       ),
     );
-  const manifest = yield* Schema.decodeUnknownEffect(PackageVersionSchema)(contents).pipe(
-    Effect.mapError(() => new EffectTsgoDependencyError({ packageName, expectedVersion })),
+  const manifest = yield* Schema.decodeEffect(PackageVersionSchema)(contents).pipe(
+    Effect.mapError(() => EffectTsgoDependencyError.make({ packageName, expectedVersion })),
   );
 
   if (manifest.version !== expectedVersion) {
-    return yield* new EffectTsgoDependencyError({
+    return yield* EffectTsgoDependencyError.make({
       packageName,
       expectedVersion,
       actualVersion: manifest.version,
@@ -115,7 +116,7 @@ const resolveEffectTsgoExecutable = Effect.fn("resolveEffectTsgoExecutable")(fun
     if (yield* fs.exists(candidate)) return candidate;
   }
 
-  return yield* new EffectTsgoDependencyError({
+  return yield* EffectTsgoDependencyError.make({
     packageName: "@effect/tsgo",
     expectedVersion: EFFECT_TSGO_VERSION,
   });
@@ -140,7 +141,7 @@ const findNodeModulesRoot = (path: Path.Path, packageJsonPath: string): string |
   }
 };
 
-const isEffectTsgoPatched = Effect.fn("isEffectTsgoPatched")(function* (
+const inspectEffectTsgoPatch = Effect.fn("inspectEffectTsgoPatch")(function* (
   projectDir: string,
   typescriptPackage: string,
 ) {
@@ -153,22 +154,28 @@ const isEffectTsgoPatched = Effect.fn("isEffectTsgoPatched")(function* (
   const typescriptNodeModules = findNodeModulesRoot(path, typescriptPackageJson);
   const effectNodeModules = findNodeModulesRoot(path, effectTsgoPackageJson);
 
-  if (typescriptNodeModules === undefined || effectNodeModules === undefined) return false;
+  if (typescriptNodeModules === undefined || effectNodeModules === undefined) {
+    return { alreadyPatched: false, hasBackup: false };
+  }
 
   const typescriptScope = path.join(typescriptNodeModules, "@typescript");
   const effectScope = path.join(effectNodeModules, "@effect");
 
-  if (!(yield* fs.exists(typescriptScope)) || !(yield* fs.exists(effectScope))) return false;
+  if (!(yield* fs.exists(typescriptScope)) || !(yield* fs.exists(effectScope))) {
+    return { alreadyPatched: false, hasBackup: false };
+  }
 
   const executableName = path.sep === "\\" ? "tsc.exe" : "tsc";
   const effectExecutableNames =
     path.sep === "\\" ? ["tsc.exe", "tsc-next.exe"] : ["tsc", "tsc-next"];
+  let hasBackup = false;
 
   for (const entry of yield* fs.readDirectory(typescriptScope)) {
     if (!entry.startsWith("typescript-")) continue;
     const platform = entry.slice("typescript-".length);
     const installedPath = path.join(typescriptScope, entry, "lib", executableName);
 
+    if (yield* fs.exists(`${installedPath}.original`)) hasBackup = true;
     if (!(yield* fs.exists(installedPath))) continue;
     const installedDigest = yield* digestFileContents(installedPath);
 
@@ -184,12 +191,12 @@ const isEffectTsgoPatched = Effect.fn("isEffectTsgoPatched")(function* (
         (yield* fs.exists(effectBinaryPath)) &&
         installedDigest === (yield* digestFileContents(effectBinaryPath))
       ) {
-        return true;
+        return { alreadyPatched: true, hasBackup };
       }
     }
   }
 
-  return false;
+  return { alreadyPatched: false, hasBackup };
 });
 
 export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
@@ -201,7 +208,7 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
   const typescriptPackage = options.typescriptPackage ?? "typescript";
 
   if (!isTypeScriptPackageName(typescriptPackage)) {
-    return yield* new InvalidEffectTsgoPackageNameError({ packageName: typescriptPackage });
+    return yield* InvalidEffectTsgoPackageNameError.make({ packageName: typescriptPackage });
   }
   const effectTsgoVersion = yield* readExactPackageVersion(
     projectDir,
@@ -214,15 +221,22 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
     EFFECT_TSGO_TYPESCRIPT_VERSION,
   );
   const executable = yield* resolveEffectTsgoExecutable(projectDir);
+  const patchState = yield* inspectEffectTsgoPatch(projectDir, typescriptPackage);
+  const typescriptPackageArgs =
+    typescriptPackage === "typescript" ? [] : ["--typescript-package", typescriptPackage];
 
   return {
-    alreadyPatched: yield* isEffectTsgoPatched(projectDir, typescriptPackage),
+    alreadyPatched: patchState.alreadyPatched,
+    ...(patchState.hasBackup && !patchState.alreadyPatched
+      ? { unpatchArgs: ["unpatch", "--typescript", ...typescriptPackageArgs] }
+      : {}),
     projectDir,
     executable,
     args: [
       "patch",
+      "--typescript",
       ...(options.force ? ["--force"] : []),
-      ...(typescriptPackage === "typescript" ? [] : ["--typescript-package", typescriptPackage]),
+      ...typescriptPackageArgs,
     ],
     effectTsgoVersion,
     typescriptPackage,
@@ -230,12 +244,13 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
   } satisfies EffectTsgoPatchPlan;
 });
 
-export const applyEffectTsgoPatchPlan = Effect.fn("applyEffectTsgoPatchPlan")(function* (
-  plan: EffectTsgoPatchPlan,
+const runEffectTsgoCommand = Effect.fn("runEffectTsgoCommand")(function* (
+  executable: string,
+  args: ReadonlyArray<string>,
+  projectDir: string,
 ) {
-  if (plan.alreadyPatched) return;
-  const child = yield* ChildProcess.make(plan.executable, plan.args, {
-    cwd: plan.projectDir,
+  const child = yield* ChildProcess.make(executable, args, {
+    cwd: projectDir,
     stderr: "pipe",
     stdout: "pipe",
   });
@@ -246,14 +261,24 @@ export const applyEffectTsgoPatchPlan = Effect.fn("applyEffectTsgoPatchPlan")(fu
   const trimmed = output.trim();
 
   if (exitCode !== 0) {
-    return yield* new EffectTsgoPatchCommandError({
-      command: [plan.executable, ...plan.args].join(" "),
+    return yield* EffectTsgoPatchCommandError.make({
+      command: [executable, ...args].join(" "),
       exitCode,
       output: trimmed,
     });
   }
 });
 
+export const applyEffectTsgoPatchPlan = Effect.fn("applyEffectTsgoPatchPlan")(function* (
+  plan: EffectTsgoPatchPlan,
+) {
+  if (plan.alreadyPatched) return;
+  if (plan.unpatchArgs !== undefined) {
+    yield* runEffectTsgoCommand(plan.executable, plan.unpatchArgs, plan.projectDir);
+  }
+  yield* runEffectTsgoCommand(plan.executable, plan.args, plan.projectDir);
+});
+
 export const patchEffectTsgo = Effect.fn("patchEffectTsgo")(function* (
   options: EffectTsgoPatchOptions = {},
 ) {

package/src/gitignore.ts

@@ -22,7 +22,7 @@ export type GitignorePatch = {
   readonly added: ReadonlyArray<string>;
 };
 
-export class UnsafeGitignorePathError extends Schema.TaggedErrorClass<UnsafeGitignorePathError>()(
+export class UnsafeGitignorePathError extends Schema.TaggedError<UnsafeGitignorePathError>()(
   "UnsafeGitignorePathError",
   {
     path: Schema.String,
@@ -34,7 +34,7 @@ export class UnsafeGitignorePathError extends Schema.TaggedErrorClass<UnsafeGiti
   }
 }
 
-export class GitignoreConflictError extends Schema.TaggedErrorClass<GitignoreConflictError>()(
+export class GitignoreConflictError extends Schema.TaggedError<GitignoreConflictError>()(
   "GitignoreConflictError",
   { path: Schema.String },
 ) {
@@ -94,7 +94,7 @@ const planGitignorePatch = Effect.fn("planGitignorePatch")(function* (
   const observation = yield* observeSymbolicLink(gitignorePath);
 
   if (observation.kind === "symlink") {
-    return yield* new UnsafeGitignorePathError({
+    return yield* UnsafeGitignorePathError.make({
       path: gitignorePath,
       reason: "the file is a symlink",
     });
@@ -107,7 +107,7 @@ const planGitignorePatch = Effect.fn("planGitignorePatch")(function* (
     const info = yield* fs.stat(gitignorePath);
 
     if (info.type !== "File") {
-      return yield* new UnsafeGitignorePathError({
+      return yield* UnsafeGitignorePathError.make({
         path: gitignorePath,
         reason: "the path is not a regular file",
       });
@@ -152,7 +152,7 @@ const applyGitignorePatch = Effect.fn("applyGitignorePatch")(function* (
     : currentObservation.kind !== "missing";
 
   if (changed) {
-    return yield* new GitignoreConflictError({ path: patch.path });
+    return yield* GitignoreConflictError.make({ path: patch.path });
   }
 
   let backedUp = false;

package/src/index.ts

@@ -11,20 +11,14 @@ export {
   EffectTsgoSetupSchema,
   type HarnessTarget,
   TargetConfigSchema,
-  type VitePlusQualityConfigSetup,
-  VitePlusQualityConfigSetupSchema,
   type VitePlusQualitySetup,
   VitePlusQualitySetupSchema,
-  type VitePlusQualityTypecheckSetup,
-  VitePlusQualityTypecheckSetupSchema,
   type VitePlusQualityWorkflowSetup,
   VitePlusQualityWorkflowSetupSchema,
   type VitePlusQualityWorkflowStep,
   VitePlusQualityWorkflowStepSchema,
   type VitePlusSetup,
   VitePlusSetupSchema,
-  type VitePlusTypecheckStrategy,
-  VitePlusTypecheckStrategySchema,
 } from "./manifest.ts";
 export {
   applyEffectSourcePlan,

package/src/manifest.ts

@@ -53,22 +53,6 @@ export const VitePlusHooksSetupSchema = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean),
 });
 
-export const VitePlusTypecheckStrategySchema = Schema.Literals(["single-project", "workspace"]);
-export type VitePlusTypecheckStrategy = typeof VitePlusTypecheckStrategySchema.Type;
-
-export const VitePlusQualityTypecheckSetupSchema = Schema.Struct({
-  strategy: Schema.optional(VitePlusTypecheckStrategySchema),
-  concurrency: Schema.optional(Schema.Int),
-  packages: Schema.optional(Schema.Array(Schema.String)),
-});
-export type VitePlusQualityTypecheckSetup = typeof VitePlusQualityTypecheckSetupSchema.Type;
-
-export const VitePlusQualityConfigSetupSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-  typecheck: Schema.optional(VitePlusQualityTypecheckSetupSchema),
-});
-export type VitePlusQualityConfigSetup = typeof VitePlusQualityConfigSetupSchema.Type;
-
 export const VitePlusQualityWorkflowStepSchema = Schema.Struct({
   name: Schema.String,
   run: Schema.Array(Schema.String),
@@ -83,7 +67,6 @@ export const VitePlusQualityWorkflowSetupSchema = Schema.Struct({
 export type VitePlusQualityWorkflowSetup = typeof VitePlusQualityWorkflowSetupSchema.Type;
 
 export const VitePlusQualitySetupSchema = Schema.Struct({
-  config: Schema.optional(VitePlusQualityConfigSetupSchema),
   workflow: Schema.optional(VitePlusQualityWorkflowSetupSchema),
 });
 export type VitePlusQualitySetup = typeof VitePlusQualitySetupSchema.Type;
@@ -153,14 +136,6 @@ export type NormalizedManifest = {
         readonly enabled: boolean;
       };
       readonly quality: {
-        readonly config: {
-          readonly enabled: boolean;
-          readonly typecheck: {
-            readonly strategy: VitePlusTypecheckStrategy;
-            readonly concurrency: number;
-            readonly packages: ReadonlyArray<string>;
-          };
-        };
         readonly workflow: {
           readonly enabled: boolean;
           readonly beforeChecks: ReadonlyArray<VitePlusQualityWorkflowStep>;
@@ -201,7 +176,6 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
     }
   }
   const quality = manifest.setup?.vitePlus?.quality;
-  const typecheck = quality?.config?.typecheck;
 
   return {
     exclude: manifest.exclude ?? [],
@@ -230,14 +204,6 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
           enabled: manifest.setup?.vitePlus?.hooks?.enabled ?? false,
         },
         quality: {
-          config: {
-            enabled: quality?.config?.enabled ?? false,
-            typecheck: {
-              strategy: typecheck?.strategy ?? "single-project",
-              concurrency: typecheck?.concurrency ?? 4,
-              packages: typecheck?.packages ?? [],
-            },
-          },
           workflow: {
             enabled: quality?.workflow?.enabled ?? false,
             beforeChecks: quality?.workflow?.beforeChecks ?? [],

package/src/node-symbolic-link.ts

@@ -4,8 +4,8 @@ export type SymbolicLinkObservation =
   | { readonly kind: "missing" | "not-symlink" }
   | { readonly kind: "symlink"; readonly target: string };
 
-// Effect beta.102's Node FileSystem adapter maps readlink(2) EINVAL to Unknown.
-// Keep that runtime-specific normalization at this narrow adapter boundary.
+// Effect's Node FileSystem adapter maps readlink(2) EINVAL to Unknown. Keep
+// that runtime-specific normalization at this narrow adapter boundary.
 const isNotSymbolicLink = (error: PlatformError.PlatformError): boolean => {
   if (error.reason._tag !== "Unknown") return false;
   const cause = error.reason.cause;

package/src/oxfmt.js

@@ -4,9 +4,14 @@
  * This file is intentionally plain JavaScript because Node does not strip
  * TypeScript from packages in node_modules when tools load their config.
  */
+import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
+
+export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
+
 export const recommendedOxfmtConfig = {
   arrowParens: "always",
   endOfLine: "lf",
+  ignorePatterns: [...devKitToolIgnorePatterns],
   printWidth: 100,
   semi: true,
   singleQuote: false,

package/src/oxfmt.ts

@@ -1,5 +1,9 @@
 import type { OxfmtConfig } from "oxfmt";
 
+import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
+
+export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
+
 /**
  * Canonical formatting defaults for standalone Oxfmt and Vite+ projects.
  *
@@ -9,6 +13,7 @@ import type { OxfmtConfig } from "oxfmt";
 export const recommendedOxfmtConfig = {
   arrowParens: "always",
   endOfLine: "lf",
+  ignorePatterns: [...devKitToolIgnorePatterns],
   printWidth: 100,
   semi: true,
   singleQuote: false,

package/src/oxlint.js

@@ -4,7 +4,12 @@
  * This file is intentionally plain JavaScript because Node does not strip
  * TypeScript from packages in node_modules when Vite+ loads vite.config.ts.
  */
+import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
+
+export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
+
 export const recommendedOxlintConfig = {
+  ignorePatterns: [...devKitToolIgnorePatterns],
   options: {
     typeAware: true,
   },

package/src/oxlint.ts

@@ -1,5 +1,9 @@
 import type { OxlintConfig } from "oxlint";
 
+import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
+
+export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
+
 /**
  * High-signal Oxlint defaults for TypeScript projects.
  *
@@ -8,6 +12,7 @@ import type { OxlintConfig } from "oxlint";
  * without losing nested configuration.
  */
 export const recommendedOxlintConfig = {
+  ignorePatterns: [...devKitToolIgnorePatterns],
   options: {
     typeAware: true,
   },

package/src/package-skill-source.ts

@@ -5,7 +5,7 @@ import { readDirectDependencyNames } from "./project-package.ts";
 import { isSkillName, parseSkillSelector } from "./skill-selector.ts";
 import { isTypeScriptPackageName } from "./typescript-package-name.ts";
 
-export class PackageSkillSourceError extends Schema.TaggedErrorClass<PackageSkillSourceError>()(
+export class PackageSkillSourceError extends Schema.TaggedError<PackageSkillSourceError>()(
   "PackageSkillSourceError",
   { message: Schema.String },
 ) {}
@@ -121,26 +121,24 @@ const rejectNestedSymlinks = Effect.fn("rejectPackageSkillSymlinks")(function* (
 
     if (current === undefined) continue;
     if ((yield* observeSymbolicLink(current)).kind === "symlink") {
-      return yield* new PackageSkillSourceError({
+      return yield* PackageSkillSourceError.make({
         message: `package skill contains a symlink: ${current}`,
       });
     }
-    const info = yield* fs
-      .stat(current)
-      .pipe(
-        Effect.mapError(
-          () =>
-            new PackageSkillSourceError({ message: `could not inspect package skill: ${current}` }),
-        ),
-      );
+    const info = yield* fs.stat(current).pipe(
+      Effect.mapError(() =>
+        PackageSkillSourceError.make({
+          message: `could not inspect package skill: ${current}`,
+        }),
+      ),
+    );
 
     if (info.type !== "Directory") continue;
     for (const entry of yield* fs
       .readDirectory(current)
       .pipe(
-        Effect.mapError(
-          () =>
-            new PackageSkillSourceError({ message: `could not read package skill: ${current}` }),
+        Effect.mapError(() =>
+          PackageSkillSourceError.make({ message: `could not read package skill: ${current}` }),
         ),
       ))
       pending.push(path.join(current, entry));
@@ -163,80 +161,75 @@ const loadInstalledPackageSkills = Effect.fn("loadInstalledPackageSkills")(funct
   const path = yield* Path.Path;
   const packageLink = path.join(projectDir, "node_modules", ...packageName.split("/"));
   const packageRoot = yield* fs.realPath(packageLink).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `package skill package is not installed: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `package skill package is not installed: ${packageName}`,
+      }),
     ),
   );
   const packageInfo = yield* fs.stat(packageRoot).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `could not inspect package skill package: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `could not inspect package skill package: ${packageName}`,
+      }),
     ),
   );
 
   if (packageInfo.type !== "Directory")
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill package is not a directory: ${packageName}`,
     });
   const metadata = yield* fs.readFileString(path.join(packageRoot, "package.json")).pipe(
     Effect.flatMap(Schema.decodeUnknownEffect(PackageMetadataSchema)),
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `invalid package.json for package skill package: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `invalid package.json for package skill package: ${packageName}`,
+      }),
     ),
   );
 
   if (metadata.name !== packageName)
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package.json name does not match package skill package: ${packageName}`,
     });
   if (!isSafePackageVersion(metadata.version))
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package.json has an invalid version for package skill package: ${packageName}`,
     });
   if (!hasIntentDiscoveryMetadata(metadata))
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package does not declare Intent-compatible discovery metadata: ${packageName}`,
     });
   const skillsPath = "skills";
   const skillsLink = path.join(packageLink, skillsPath);
 
   if ((yield* observeSymbolicLink(skillsLink)).kind === "symlink")
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skills path is a symlink: ${packageName}/${skillsPath}`,
     });
   const skillsRoot = yield* fs.realPath(skillsLink).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `package skill package has no skills directory: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `package skill package has no skills directory: ${packageName}`,
+      }),
     ),
   );
 
   if (!isContained(path, packageRoot, skillsRoot))
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skills path resolves outside package root: ${packageName}/${skillsPath}`,
     });
   const skillsInfo = yield* fs.stat(skillsRoot);
 
   if (skillsInfo.type !== "Directory")
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skills path is not a directory: ${packageName}/${skillsPath}`,
     });
   const names = (yield* fs.readDirectory(skillsRoot).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `package skill package has no readable skills directory: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `package skill package has no readable skills directory: ${packageName}`,
+      }),
     ),
   ))
     .filter(isSkillName)
@@ -259,21 +252,21 @@ const inspectPackageSkill = Effect.fn("inspectInstalledPackageSkill")(function*
   const path = yield* Path.Path;
 
   if (!isSkillName(name)) {
-    return yield* new PackageSkillSourceError({ message: `invalid package skill name: ${name}` });
+    return yield* PackageSkillSourceError.make({ message: `invalid package skill name: ${name}` });
   }
   const selector = `${installed.package}#${name}`;
   const linkPath = path.join(installed.packageLink, "skills", name);
 
   if ((yield* observeSymbolicLink(linkPath)).kind === "symlink") {
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill contains a symlink: ${selector}`,
     });
   }
   const skillRoot = yield* fs
     .realPath(linkPath)
     .pipe(
-      Effect.mapError(
-        () => new PackageSkillSourceError({ message: `package skill does not exist: ${selector}` }),
+      Effect.mapError(() =>
+        PackageSkillSourceError.make({ message: `package skill does not exist: ${selector}` }),
       ),
     );
 
@@ -281,29 +274,28 @@ const inspectPackageSkill = Effect.fn("inspectInstalledPackageSkill")(function*
     !isContained(path, installed.skillsRoot, skillRoot) ||
     (yield* fs.stat(skillRoot)).type !== "Directory"
   ) {
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill is not a contained directory: ${selector}`,
     });
   }
   yield* rejectNestedSymlinks(skillRoot);
   const document = yield* fs.readFileString(path.join(skillRoot, "SKILL.md")).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `package skill is missing SKILL.md: ${selector}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `package skill is missing SKILL.md: ${selector}`,
+      }),
     ),
   );
 
   if (skillName(document) !== name) {
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill SKILL.md name must match directory: ${selector}`,
     });
   }
   const description = skillDescription(document);
 
   if (description === undefined) {
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill SKILL.md must declare a description: ${selector}`,
     });
   }
@@ -370,13 +362,13 @@ export const resolvePackageSkillSelector = Effect.fn("resolvePackageSkillSelecto
   const parsed = parseSkillSelector(selector);
 
   if (parsed?.type !== "package")
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `invalid package skill selector: ${selector}`,
     });
   const directDependencies = yield* readDirectDependencyNames(projectDir);
 
   if (!directDependencies.includes(parsed.package))
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill package is not a direct dependency: ${parsed.package}`,
     });