@danieljvdm/dev-kit 0.11.3 → 0.12.0

package/src/tool-ignore-patterns.js

@@ -0,0 +1,9 @@
+/** Tool-owned paths excluded by Dev Kit's lint and format presets. */
+export const devKitToolIgnorePatterns = [
+  ".agents/**",
+  ".claude/**",
+  ".dev-kit/**",
+  ".opencode/**",
+  ".repos/**",
+  ".vite-hooks/_/**",
+];

package/src/tool-ignore-patterns.ts

@@ -0,0 +1,15 @@
+/**
+ * Tool-owned paths that should not be linted or formatted.
+ *
+ * Skill copies remain tracked project inputs, while symlinked harness targets
+ * and local Dev Kit state may duplicate or contain third-party source. Keep
+ * these exclusions in tool configuration rather than `.gitignore`.
+ */
+export const devKitToolIgnorePatterns = [
+  ".agents/**",
+  ".claude/**",
+  ".dev-kit/**",
+  ".opencode/**",
+  ".repos/**",
+  ".vite-hooks/_/**",
+] as const;

package/src/vendor.ts

@@ -1,4 +1,4 @@
-import { Effect, FileSystem, Path, Schema, Stream } from "effect";
+import { Effect, FileSystem, Path, Schema, SchemaGetter, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 import { parse as parseJsonc, printParseErrorCode, type ParseError } from "jsonc-parser";
 
@@ -51,39 +51,30 @@ type PreparedSource = {
   readonly licenseSource?: string;
 };
 
-class SourceManifestError extends Schema.TaggedErrorClass<SourceManifestError>()(
-  "SourceManifestError",
-  {
-    path: Schema.String,
-    message: Schema.String,
-  },
-) {}
+class SourceManifestError extends Schema.TaggedError<SourceManifestError>()("SourceManifestError", {
+  path: Schema.String,
+  message: Schema.String,
+}) {}
 
-class InvalidSourceError extends Schema.TaggedErrorClass<InvalidSourceError>()(
-  "InvalidSourceError",
-  {
-    source: Schema.String,
-    reason: Schema.String,
-  },
-) {
+class InvalidSourceError extends Schema.TaggedError<InvalidSourceError>()("InvalidSourceError", {
+  source: Schema.String,
+  reason: Schema.String,
+}) {
   override get message(): string {
     return `invalid source "${this.source}": ${this.reason}`;
   }
 }
 
-class SkillCollisionError extends Schema.TaggedErrorClass<SkillCollisionError>()(
-  "SkillCollisionError",
-  {
-    skill: Schema.String,
-    owners: Schema.Array(Schema.String),
-  },
-) {
+class SkillCollisionError extends Schema.TaggedError<SkillCollisionError>()("SkillCollisionError", {
+  skill: Schema.String,
+  owners: Schema.Array(Schema.String),
+}) {
   override get message() {
     return `skill "${this.skill}" is owned by more than one source: ${this.owners.join(", ")}`;
   }
 }
 
-class CommandError extends Schema.TaggedErrorClass<CommandError>()("CommandError", {
+class CommandError extends Schema.TaggedError<CommandError>()("CommandError", {
   command: Schema.String,
   exitCode: Schema.Int,
   output: Schema.String,
@@ -95,6 +86,16 @@ class CommandError extends Schema.TaggedErrorClass<CommandError>()("CommandError
   }
 }
 
+const SkillSourcesLockJsonSchema = Schema.fromJsonString(SkillSourcesLockSchema);
+const SkillSourcesLockPrettyJsonSchema = Schema.String.pipe(
+  Schema.decodeTo(Schema.toCodecJson(SkillSourcesLockSchema), {
+    decode: SchemaGetter.parseJson(),
+    encode: SchemaGetter.stringifyJson({ space: 2 }),
+  }),
+);
+const encodeSkillSourcesLockJson = Schema.encodeSync(SkillSourcesLockJsonSchema);
+const encodeSkillSourcesLockPrettyJson = Schema.encodeSync(SkillSourcesLockPrettyJsonSchema);
+
 const DEFAULT_SOURCES_PATH = "skill-sources.jsonc";
 const DEFAULT_LOCKFILE_PATH = "skill-sources.lock.json";
 const SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -131,7 +132,7 @@ const normalizeRepositoryLocator = (
 > => {
   if (containsControlCharacter(repository)) {
     return Effect.fail(
-      new InvalidSourceError({
+      InvalidSourceError.make({
         source: repository,
         reason: "repository contains control characters",
       }),
@@ -142,7 +143,7 @@ const normalizeRepositoryLocator = (
 
     if ((url.protocol === "http:" || url.protocol === "https:") && (url.username || url.password)) {
       return Effect.fail(
-        new InvalidSourceError({
+        InvalidSourceError.make({
           source: repository,
           reason: "repository URLs must not contain credentials",
         }),
@@ -184,7 +185,7 @@ const runCommand = Effect.fn("runVendorCommand")(function* (
   const trimmed = output.trim();
 
   if (exitCode !== 0) {
-    return yield* new CommandError({ command: formatted, exitCode, output: trimmed });
+    return yield* CommandError.make({ command: formatted, exitCode, output: trimmed });
   }
 
   return trimmed;
@@ -201,7 +202,7 @@ const readJsonc = Effect.fn("readVendorJsonc")(function* <A>(
   const fs = yield* FileSystem.FileSystem;
 
   if (!(yield* fs.exists(filePath))) {
-    return yield* new SourceManifestError({ path: filePath, message: "file not found" });
+    return yield* SourceManifestError.make({ path: filePath, message: "file not found" });
   }
 
   const raw = yield* fs.readFileString(filePath);
@@ -211,14 +212,16 @@ const readJsonc = Effect.fn("readVendorJsonc")(function* <A>(
   const first = errors[0];
 
   if (first !== undefined) {
-    return yield* new SourceManifestError({
+    return yield* SourceManifestError.make({
       path: filePath,
       message: `${printParseErrorCode(first.error)} at offset ${first.offset}`,
     });
   }
 
   return yield* Schema.decodeUnknownEffect(schema)(parsed).pipe(
-    Effect.mapError((cause) => new SourceManifestError({ path: filePath, message: cause.message })),
+    Effect.mapError((cause) =>
+      SourceManifestError.make({ path: filePath, message: cause.message }),
+    ),
   );
 });
 
@@ -239,7 +242,7 @@ const resolveInside = (
     path.isAbsolute(relative)
   ) {
     return Effect.fail(
-      new InvalidSourceError({
+      InvalidSourceError.make({
         source: sourceId,
         reason: `${field} must be a relative path inside the source repository`,
       }),
@@ -264,7 +267,7 @@ const ensureCanonicalPathInside = Effect.fn("ensureCanonicalSourcePathInside")(f
   const relative = path.relative(canonicalRoot, canonicalTarget);
 
   if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: sourceId,
       reason: `${field} resolves outside the source repository`,
     });
@@ -287,7 +290,7 @@ const rejectGitSymlinks = Effect.fn("rejectGitSymlinks")(function* (
   const symlink = entries.split(/\r?\n/).find((line) => line.startsWith("120000 "));
 
   if (symlink) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: sourceId,
       reason: `symlinks are not allowed in catalog paths: ${symlink.slice(symlink.indexOf("\t") + 1)}`,
     });
@@ -302,7 +305,7 @@ const discoverSkills = Effect.fn("discoverVendoredSkills")(function* (
   const path = yield* Path.Path;
 
   if (!(yield* fs.exists(skillsDir))) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: source.id,
       reason: `skillsPath does not exist: ${source.skillsPath}`,
     });
@@ -327,7 +330,7 @@ const discoverSkills = Effect.fn("discoverVendoredSkills")(function* (
         .replace(/^(['"])(.*)\1$/, "$2");
 
       if (declaredName !== entry) {
-        return yield* new InvalidSourceError({
+        return yield* InvalidSourceError.make({
           source: source.id,
           reason: `${source.skillsPath}/${entry}/SKILL.md must declare name: ${entry}`,
         });
@@ -340,7 +343,7 @@ const discoverSkills = Effect.fn("discoverVendoredSkills")(function* (
   const includeAll = source.include.length === 1 && source.include[0] === "*";
 
   if (source.include.includes("*") && !includeAll) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: source.id,
       reason: 'include must contain either "*" or explicit skill names, not both',
     });
@@ -351,7 +354,7 @@ const discoverSkills = Effect.fn("discoverVendoredSkills")(function* (
   );
 
   if (selected.length === 0) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: source.id,
       reason: "include must select at least one skill",
     });
@@ -359,13 +362,13 @@ const discoverSkills = Effect.fn("discoverVendoredSkills")(function* (
 
   for (const skill of selected) {
     if (!SKILL_NAME_PATTERN.test(skill)) {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: source.id,
         reason: `invalid skill name "${skill}"`,
       });
     }
     if (!discovered.includes(skill)) {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: source.id,
         reason: `skill not found under ${source.skillsPath}: ${skill}`,
       });
@@ -386,19 +389,19 @@ const prepareSource = Effect.fn("prepareSkillSource")(function* (
   const path = yield* Path.Path;
 
   if (!SOURCE_ID_PATTERN.test(source.id)) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: source.id,
       reason: "id must use lowercase letters, numbers, and hyphens",
     });
   }
   if (RESERVED_SOURCE_IDS.has(source.id)) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: source.id,
       reason: "id conflicts with a built-in skill family",
     });
   }
   if (source.repository.length === 0 || source.ref.length === 0) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: source.id,
       reason: "repository and ref must not be empty",
     });
@@ -417,7 +420,7 @@ const prepareSource = Effect.fn("prepareSkillSource")(function* (
       [...(lockedSource.stripFrontmatter ?? [])].sort().join("\0") !==
         [...(source.stripFrontmatter ?? [])].sort().join("\0"))
   ) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: source.id,
       reason: "no matching lockfile entry; run catalog refresh without --locked first",
     });
@@ -431,7 +434,7 @@ const prepareSource = Effect.fn("prepareSkillSource")(function* (
   const fetchRef = useLock ? lockedSource?.resolved : source.ref;
 
   if (fetchRef === undefined) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: source.id,
       reason: "no matching lockfile entry; run catalog refresh without --locked first",
     });
@@ -469,7 +472,7 @@ const prepareSource = Effect.fn("prepareSkillSource")(function* (
     );
     yield* rejectGitSymlinks(checkoutDir, source.licensePath, source.id);
     if (!(yield* fs.exists(licenseSource))) {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: source.id,
         reason: `licensePath does not exist: ${source.licensePath}`,
       });
@@ -483,7 +486,7 @@ const prepareSource = Effect.fn("prepareSkillSource")(function* (
     const licenseInfo = yield* fs.stat(licenseSource);
 
     if (licenseInfo.type !== "File") {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: source.id,
         reason: `licensePath must be a file: ${source.licensePath}`,
       });
@@ -520,33 +523,33 @@ const validateCurrentLock = Effect.fn("validateCurrentSkillSourcesLock")(functio
 
   for (const source of lock.sources) {
     if (!SOURCE_ID_PATTERN.test(source.id) || RESERVED_SOURCE_IDS.has(source.id)) {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: source.id,
         reason: "lockfile contains an invalid source id",
       });
     }
     if (sourceIds.has(source.id)) {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: source.id,
         reason: "lockfile source ids must be unique",
       });
     }
     sourceIds.add(source.id);
     if (!/^[0-9a-f]{40,64}$/.test(source.resolved)) {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: source.id,
         reason: "lockfile resolved commit must be a full hexadecimal object id",
       });
     }
     for (const skill of source.skills) {
       if (!SKILL_NAME_PATTERN.test(skill)) {
-        return yield* new InvalidSourceError({
+        return yield* InvalidSourceError.make({
           source: source.id,
           reason: `lockfile contains an invalid skill name: ${skill}`,
         });
       }
       if (skills.has(skill)) {
-        return yield* new SkillCollisionError({
+        return yield* SkillCollisionError.make({
           skill,
           owners: ["multiple lockfile sources"],
         });
@@ -590,12 +593,12 @@ const validateOwnership = Effect.fn("validateSkillOwnership")(function* (
   }
   for (const [skill, skillOwners] of owners) {
     if (skillOwners.length > 1) {
-      return yield* new SkillCollisionError({ skill, owners: skillOwners });
+      return yield* SkillCollisionError.make({ skill, owners: skillOwners });
     }
   }
   for (const preparedSource of prepared) {
     if (owners.has(preparedSource.source.id)) {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: preparedSource.source.id,
         reason: "id conflicts with a skill name",
       });
@@ -603,7 +606,7 @@ const validateOwnership = Effect.fn("validateSkillOwnership")(function* (
   }
   for (const reservedFamily of RESERVED_SOURCE_IDS) {
     if (owners.has(reservedFamily)) {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: reservedFamily,
         reason: "skill name conflicts with a built-in skill family",
       });
@@ -703,7 +706,7 @@ const buildLock = Effect.fn("buildSkillCatalogLock")(function* (
       const observation = yield* observePath(stagedSkill);
 
       if (observation.kind !== "directory") {
-        return yield* new InvalidSourceError({
+        return yield* InvalidSourceError.make({
           source: source.id,
           reason: `could not digest ${skill}`,
         });
@@ -740,7 +743,7 @@ export const inspectCatalogRepository = Effect.fn("inspectCatalogRepository")(fu
   const id = options.id ?? inferSourceId(repository);
 
   if (id.length === 0) {
-    return yield* new InvalidSourceError({
+    return yield* InvalidSourceError.make({
       source: repository,
       reason: "could not infer a source id; pass --id",
     });
@@ -844,7 +847,7 @@ export const refreshSkillCatalog = Effect.fn("refreshSkillCatalog")(function* (
 
   for (const source of manifest.sources) {
     if (sourceIds.has(source.id)) {
-      return yield* new InvalidSourceError({
+      return yield* InvalidSourceError.make({
         source: source.id,
         reason: "source ids must be unique",
       });
@@ -853,7 +856,7 @@ export const refreshSkillCatalog = Effect.fn("refreshSkillCatalog")(function* (
   }
   if (options.locked) {
     if (!currentLock) {
-      return yield* new SourceManifestError({
+      return yield* SourceManifestError.make({
         path: lockfilePath,
         message: "lockfile is required with --locked",
       });
@@ -863,7 +866,7 @@ export const refreshSkillCatalog = Effect.fn("refreshSkillCatalog")(function* (
     const missingFromLock = manifest.sources.find((source) => !lockedIds.has(source.id));
 
     if (missingFromManifest || missingFromLock) {
-      return yield* new SourceManifestError({
+      return yield* SourceManifestError.make({
         path: lockfilePath,
         message: "source ids differ from skill-sources.jsonc; run catalog refresh without --locked",
       });
@@ -906,8 +909,11 @@ export const refreshSkillCatalog = Effect.fn("refreshSkillCatalog")(function* (
   const summary = `${skillCount} skill${skillCount === 1 ? "" : "s"} from ${nextLock.sources.length} source${nextLock.sources.length === 1 ? "" : "s"}`;
 
   if (options.locked) {
-    if (JSON.stringify(currentLock) !== JSON.stringify(nextLock)) {
-      return yield* new SourceManifestError({
+    if (
+      currentLock === undefined ||
+      encodeSkillSourcesLockJson(currentLock) !== encodeSkillSourcesLockJson(nextLock)
+    ) {
+      return yield* SourceManifestError.make({
         path: lockfilePath,
         message:
           "approved catalog metadata differs from the lock; run catalog refresh and review it",
@@ -926,7 +932,7 @@ export const refreshSkillCatalog = Effect.fn("refreshSkillCatalog")(function* (
 
   const nextLockPath = path.join(tempDir, "next-catalog-lock.json");
 
-  yield* fs.writeFileString(nextLockPath, `${JSON.stringify(nextLock, null, 2)}\n`);
+  yield* fs.writeFileString(nextLockPath, `${encodeSkillSourcesLockPrettyJson(nextLock)}\n`);
   yield* fs.rename(nextLockPath, lockfilePath);
   yield* printStatus("success", "Catalog refreshed", summary);
 });

package/src/vite-plus-dependency.ts

@@ -8,7 +8,7 @@ const InstalledVitePlusPackageSchema = Schema.fromJsonString(
   Schema.Struct({ version: Schema.String }),
 );
 
-export class VitePlusDependencyError extends Schema.TaggedErrorClass<VitePlusDependencyError>()(
+export class VitePlusDependencyError extends Schema.TaggedError<VitePlusDependencyError>()(
   "VitePlusDependencyError",
   { message: Schema.String },
 ) {}
@@ -26,42 +26,41 @@ export const validateInstalledVitePlus = Effect.fn("validateInstalledVitePlus")(
   const dependencies = yield* readDirectDependencyNames(projectDir);
 
   if (!dependencies.includes("vite-plus")) {
-    return yield* new VitePlusDependencyError({
+    return yield* VitePlusDependencyError.make({
       message: "vite-plus must be a direct project dependency",
     });
   }
   const packagePath = path.join(projectDir, "node_modules", "vite-plus", "package.json");
 
   if (!(yield* fs.exists(packagePath))) {
-    return yield* new VitePlusDependencyError({
+    return yield* VitePlusDependencyError.make({
       message:
         "vite-plus must be installed before enabling this setup: node_modules/vite-plus/package.json is missing",
     });
   }
   const installed = yield* fs.readFileString(packagePath).pipe(
     Effect.flatMap(Schema.decodeUnknownEffect(InstalledVitePlusPackageSchema)),
-    Effect.mapError(
-      () =>
-        new VitePlusDependencyError({
-          message: "installed vite-plus package metadata has no valid version",
-        }),
+    Effect.mapError(() =>
+      VitePlusDependencyError.make({
+        message: "installed vite-plus package metadata has no valid version",
+      }),
     ),
   );
 
   if (!semver.valid(installed.version)) {
-    return yield* new VitePlusDependencyError({
+    return yield* VitePlusDependencyError.make({
       message: `installed vite-plus package metadata has invalid version: ${installed.version}`,
     });
   }
   if (!semver.satisfies(installed.version, VITE_PLUS_SUPPORTED_RANGE)) {
-    return yield* new VitePlusDependencyError({
+    return yield* VitePlusDependencyError.make({
       message: `installed vite-plus ${installed.version} is incompatible with @danieljvdm/dev-kit; supported range: ${VITE_PLUS_SUPPORTED_RANGE}`,
     });
   }
   const vpBin = path.join(projectDir, "node_modules", ".bin", "vp");
 
   if (!(yield* fs.exists(vpBin))) {
-    return yield* new VitePlusDependencyError({
+    return yield* VitePlusDependencyError.make({
       message: "vite-plus is installed but node_modules/.bin/vp is missing",
     });
   }

package/src/vite-plus-hooks.ts

@@ -14,12 +14,12 @@ export type VitePlusHooksPlan = {
   readonly vpBin: string;
 };
 
-export class VitePlusHooksDependencyError extends Schema.TaggedErrorClass<VitePlusHooksDependencyError>()(
+export class VitePlusHooksDependencyError extends Schema.TaggedError<VitePlusHooksDependencyError>()(
   "VitePlusHooksDependencyError",
   { message: Schema.String },
 ) {}
 
-export class VitePlusHooksConflictError extends Schema.TaggedErrorClass<VitePlusHooksConflictError>()(
+export class VitePlusHooksConflictError extends Schema.TaggedError<VitePlusHooksConflictError>()(
   "VitePlusHooksConflictError",
   { hooksPath: Schema.String },
 ) {
@@ -28,7 +28,7 @@ export class VitePlusHooksConflictError extends Schema.TaggedErrorClass<VitePlus
   }
 }
 
-class VitePlusHooksCommandError extends Schema.TaggedErrorClass<VitePlusHooksCommandError>()(
+class VitePlusHooksCommandError extends Schema.TaggedError<VitePlusHooksCommandError>()(
   "VitePlusHooksCommandError",
   { command: Schema.String, exitCode: Schema.Int, output: Schema.String },
 ) {
@@ -39,7 +39,7 @@ class VitePlusHooksCommandError extends Schema.TaggedErrorClass<VitePlusHooksCom
   }
 }
 
-class VitePlusHooksConvergenceError extends Schema.TaggedErrorClass<VitePlusHooksConvergenceError>()(
+class VitePlusHooksConvergenceError extends Schema.TaggedError<VitePlusHooksConvergenceError>()(
   "VitePlusHooksConvergenceError",
   { message: Schema.String },
 ) {}
@@ -62,7 +62,7 @@ const runCommand = Effect.fn("runVitePlusHooksCommand")(function* (
   const trimmed = output.trim();
 
   if (!allowedExitCodes.includes(exitCode)) {
-    return yield* new VitePlusHooksCommandError({
+    return yield* VitePlusHooksCommandError.make({
       command: [command, ...args].join(" "),
       exitCode,
       output: trimmed,
@@ -108,25 +108,35 @@ const inspectVitePlusHooks = Effect.fn("inspectVitePlusHooks")(function* (projec
     hooksPath !== ".husky" &&
     !hooksPath.startsWith(".husky/")
   ) {
-    return yield* new VitePlusHooksConflictError({ hooksPath });
+    return yield* VitePlusHooksConflictError.make({ hooksPath });
   }
   const internalDir = path.join(projectDir, VITE_PLUS_HOOKS_DIR, "_");
-  const [hasLauncher, hasDispatcher, hasPreCommit] = yield* Effect.all([
+  const [hasLauncher, hasDispatcher, hasPreCommit, hasInternalIgnore] = yield* Effect.all([
     hasExecutableFile(path.join(internalDir, "h")),
     hasExecutableFile(path.join(internalDir, "pre-commit")),
     hasVitePlusPreCommitHook(path.join(projectDir, VITE_PLUS_HOOKS_DIR, "pre-commit")),
+    FileSystem.FileSystem.pipe(
+      Effect.flatMap((fs) => fs.readFileString(path.join(internalDir, ".gitignore"))),
+      Effect.map((contents) => contents.split(/\r?\n/).includes("*")),
+      Effect.orElseSucceed(() => false),
+    ),
   ]);
 
-  return hooksPath === VITE_PLUS_HOOKS_PATH && hasLauncher && hasDispatcher && hasPreCommit;
+  return (
+    hooksPath === VITE_PLUS_HOOKS_PATH &&
+    hasLauncher &&
+    hasDispatcher &&
+    hasPreCommit &&
+    hasInternalIgnore
+  );
 });
 
 export const planVitePlusHooks = Effect.fn("planVitePlusHooks")(function* (projectDir: string) {
   const { vpBin } = yield* validateInstalledVitePlus(projectDir).pipe(
-    Effect.mapError(
-      (error) =>
-        new VitePlusHooksDependencyError({
-          message: `${error.message} before enabling setup.vitePlus.hooks`,
-        }),
+    Effect.mapError((error) =>
+      VitePlusHooksDependencyError.make({
+        message: `${error.message} before enabling setup.vitePlus.hooks`,
+      }),
     ),
   );
   const viteGitHooks = yield* Config.string("VITE_GIT_HOOKS").pipe(Config.withDefault(""));
@@ -158,7 +168,7 @@ export const applyVitePlusHooksPlan = Effect.fn("applyVitePlusHooksPlan")(functi
     plan.hooksDir,
   ]);
   if (!(yield* inspectVitePlusHooks(plan.projectDir))) {
-    return yield* new VitePlusHooksConvergenceError({
+    return yield* VitePlusHooksConvergenceError.make({
       message: `Vite+ hook setup did not converge at ${plan.hooksPath}`,
     });
   }