@gaganref/confect-cli 0.0.0-stage → 10.3.1-fork.10

package/dist/GenerationSnapshot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenerationSnapshot.mjs","names":["GroupPath.GroupPath","GroupPath.make","GroupPath.append"],"sources":["../src/GenerationSnapshot.ts"],"sourcesContent":["import { type GroupSpec, Identifier } from \"@confect/core\";\nimport * as Array from \"effect/Array\";\nimport * as Effect from \"effect/Effect\";\nimport * as HashMap from \"effect/HashMap\";\nimport * as HashSet from \"effect/HashSet\";\nimport * as Match from \"effect/Match\";\nimport * as Option from \"effect/Option\";\nimport * as Record from \"effect/Record\";\nimport * as Result from \"effect/Result\";\nimport * as Schema from \"effect/Schema\";\nimport * as SchemaGetter from \"effect/SchemaGetter\";\nimport * as SchemaIssue from \"effect/SchemaIssue\";\nimport * as String from \"effect/String\";\nimport { ParentChildNameCollisionError } from \"./CodegenError.js\";\nimport * as FunctionPath from \"./FunctionPath.js\";\nimport * as FunctionPaths from \"./FunctionPaths.js\";\nimport * as GroupPath from \"./GroupPath.js\";\nimport type { LoadedLeafModule } from \"./LeafModule.js\";\nimport * as SpecModulePath from \"./SpecModulePath.js\";\nimport { SnapshotError } from \"./SnapshotError.js\";\n\nexport { SnapshotError } from \"./SnapshotError.js\";\n\nexport const GroupSummary = Schema.Struct({\n  path: GroupPath.GroupPath,\n  runtime: Schema.Literals([\"Convex\", \"Node\"]),\n  functionNames: Schema.Array(Schema.NonEmptyString),\n});\nexport interface GroupSummary extends Schema.Schema.Type<typeof GroupSummary> {}\n\nexport interface GroupTree {\n  readonly runtime: \"Convex\" | \"Node\";\n  readonly functionNames: ReadonlyArray<string>;\n  readonly groups: { readonly [name: string]: GroupTree };\n}\n\nexport const GroupTree: Schema.Codec<GroupTree> = Schema.Struct({\n  runtime: GroupSummary.fields.runtime,\n  functionNames: GroupSummary.fields.functionNames,\n  groups: Schema.Record(\n    Schema.String,\n    Schema.suspend(() => GroupTree),\n  ),\n});\n\nclass Snapshot {\n  readonly #leaves: HashMap.HashMap<SpecModulePath.SpecModulePath, GroupTree>;\n\n  private constructor(\n    leaves: HashMap.HashMap<SpecModulePath.SpecModulePath, GroupTree>,\n  ) {\n    this.#leaves = leaves;\n  }\n\n  static parseLeaves(\n    leaves: HashMap.HashMap<SpecModulePath.SpecModulePath, GroupTree>,\n  ): Result.Result<GenerationSnapshot, ParentChildNameCollisionError> {\n    return Result.map(\n      parseNoParentChildNameCollisions(leaves),\n      (parsed) => new Snapshot(parsed),\n    );\n  }\n\n  get leaves(): HashMap.HashMap<SpecModulePath.SpecModulePath, GroupTree> {\n    return this.#leaves;\n  }\n}\n\nexport interface GenerationSnapshot extends Snapshot {}\n\nconst Entries = Schema.Array(Schema.Tuple([Schema.String, GroupTree]));\nconst CanonicalSpecPath = SpecModulePath.SpecModulePath.check(\n  Schema.makeFilter((path) => !path.includes(\"\\\\\")),\n);\nconst rootPath = (path: SpecModulePath.SpecModulePath) =>\n  GroupPath.make(String.split(path.slice(0, -\".spec.ts\".length), \"/\"));\n\nconst parseTree = (\n  relativePath: SpecModulePath.SpecModulePath,\n  path: GroupPath.GroupPath,\n  tree: GroupTree,\n): Result.Result<GroupTree, SnapshotError> =>\n  Result.gen(function* () {\n    yield* Result.try({\n      try: () => {\n        for (const name of tree.functionNames)\n          Identifier.validateConfectFunctionIdentifier(name);\n      },\n      catch: () =>\n        new SnapshotError({\n          reason: \"NoncanonicalFunctionNames\",\n          relativePath,\n          pathSegments: path.pathSegments,\n        }),\n    });\n    if (\n      HashSet.size(HashSet.fromIterable(tree.functionNames)) !==\n      tree.functionNames.length\n    ) {\n      return yield* Result.fail(\n        new SnapshotError({\n          reason: \"NoncanonicalFunctionNames\",\n          relativePath,\n          pathSegments: path.pathSegments,\n        }),\n      );\n    }\n    for (const [name, child] of Object.entries(tree.groups)) {\n      yield* Result.try({\n        try: () => Identifier.validateConfectFunctionIdentifier(name),\n        catch: () =>\n          new SnapshotError({\n            reason: \"NoncanonicalPath\",\n            relativePath,\n            pathSegments: [...path.pathSegments, name],\n          }),\n      });\n      yield* parseTree(relativePath, GroupPath.append(path, name), child);\n    }\n    return tree;\n  });\n\nconst fromEntries = (\n  entries: ReadonlyArray<readonly [string, GroupTree]>,\n): Result.Result<\n  GenerationSnapshot,\n  SnapshotError | ParentChildNameCollisionError\n> =>\n  Result.gen(function* () {\n    let leaves = HashMap.empty<SpecModulePath.SpecModulePath, GroupTree>();\n    for (const [key, tree] of entries) {\n      const relativePath = yield* Schema.decodeResult(CanonicalSpecPath)(\n        key,\n      ).pipe(\n        Result.mapError(\n          (cause) =>\n            new SnapshotError({\n              reason: \"NoncanonicalPath\",\n              relativePath: key,\n              pathSegments: [],\n              cause,\n            }),\n        ),\n      );\n      const path = rootPath(relativePath);\n      yield* Result.try({\n        try: () => {\n          for (const segment of path.pathSegments)\n            Identifier.validateConfectFunctionIdentifier(segment);\n        },\n        catch: () =>\n          new SnapshotError({\n            reason: \"NoncanonicalPath\",\n            relativePath,\n            pathSegments: path.pathSegments,\n          }),\n      });\n      if (HashMap.has(leaves, relativePath)) {\n        return yield* Result.fail(\n          new SnapshotError({\n            reason: \"DuplicateLeaf\",\n            relativePath,\n            pathSegments: path.pathSegments,\n          }),\n        );\n      }\n      const parsed = yield* parseTree(relativePath, path, tree);\n      leaves = HashMap.set(leaves, relativePath, parsed);\n    }\n    return yield* Snapshot.parseLeaves(leaves);\n  });\n\nexport const parse = (\n  input: unknown,\n): Result.Result<\n  GenerationSnapshot,\n  SnapshotError | ParentChildNameCollisionError\n> =>\n  Schema.decodeUnknownResult(Entries)(input).pipe(\n    Result.mapError(\n      (cause) =>\n        new SnapshotError({\n          reason: \"InvalidShape\",\n          relativePath: \"\",\n          pathSegments: [],\n          cause,\n        }),\n    ),\n    Result.flatMap(fromEntries),\n  );\n\nexport const GenerationSnapshot = Entries.pipe(\n  Schema.decodeTo(\n    Schema.declare<GenerationSnapshot>((input) => input instanceof Snapshot),\n    {\n      decode: SchemaGetter.transformEffect((entries, options) =>\n        Effect.fromResult(fromEntries(entries)).pipe(\n          Effect.mapError(\n            (error) =>\n              new SchemaIssue.InvalidValue(\n                {\n                  message: Match.value(error).pipe(\n                    Match.tagsExhaustive({\n                      SnapshotError: (failure) => failure.message,\n                      ParentChildNameCollisionError: (failure) =>\n                        `${failure.parentSpecPath} declares a ${failure.collisionKind} named ${failure.collisionName} that collides with ${failure.childSpecPath}`,\n                    }),\n                  ),\n                },\n                entries,\n                options,\n              ),\n          ),\n        ),\n      ),\n      encode: SchemaGetter.transform((snapshot) =>\n        HashMap.toEntries(snapshot.leaves),\n      ),\n    },\n  ),\n);\n\nconst summarize = (group: GroupSpec.AnyWithProps): GroupTree => ({\n  runtime: group.runtime,\n  functionNames: Record.keys(group.functions),\n  groups: Record.map(group.groups, summarize),\n});\n\nexport const update = (\n  snapshot: GenerationSnapshot,\n  leaves: ReadonlyArray<LoadedLeafModule>,\n): Result.Result<\n  GenerationSnapshot,\n  SnapshotError | ParentChildNameCollisionError\n> =>\n  Result.gen(function* () {\n    if (leaves.length === 0) return snapshot;\n    const replacement = yield* fromLoadedLeaves(leaves);\n    return yield* Snapshot.parseLeaves(\n      HashMap.union(snapshot.leaves, replacement.leaves),\n    );\n  });\n\nexport const fromLoadedLeaves = (\n  leaves: ReadonlyArray<LoadedLeafModule>,\n): Result.Result<\n  GenerationSnapshot,\n  SnapshotError | ParentChildNameCollisionError\n> =>\n  parse(\n    leaves.map(\n      (leaf) =>\n        [\n          leaf.relativePath.replaceAll(\"\\\\\", \"/\"),\n          summarize(leaf.spec),\n        ] as const,\n    ),\n  );\n\nconst groups = (snapshot: GenerationSnapshot): ReadonlyArray<GroupSummary> => {\n  const visit = (\n    path: GroupPath.GroupPath,\n    tree: GroupTree,\n  ): ReadonlyArray<GroupSummary> => [\n    {\n      path,\n      runtime: tree.runtime,\n      functionNames: Array.sort(tree.functionNames, String.Order),\n    },\n    ...Array.flatMap(\n      Array.sort(Object.keys(tree.groups), String.Order),\n      (name: string) => visit(GroupPath.append(path, name), tree.groups[name]!),\n    ),\n  ];\n  return Array.flatMap(Array.fromIterable(snapshot.leaves), ([path, tree]) =>\n    visit(rootPath(path), tree),\n  );\n};\n\nexport const functionPaths = (\n  snapshot: GenerationSnapshot,\n): FunctionPaths.FunctionPaths =>\n  FunctionPaths.FunctionPaths.make(\n    HashSet.fromIterable(\n      Array.flatMap(groups(snapshot), (group) =>\n        group.functionNames.map((name) =>\n          FunctionPath.FunctionPath.make({ groupPath: group.path, name }),\n        ),\n      ),\n    ),\n  );\n\nconst generatedGroups = (snapshot: GenerationSnapshot) =>\n  HashMap.fromIterable(\n    Array.filterMap(groups(snapshot), (group) =>\n      group.functionNames.length === 0\n        ? Result.fail(undefined)\n        : Result.succeed([group.path, group] as const),\n    ),\n  );\n\nexport interface ModulePlan {\n  readonly removed: ReadonlyArray<GroupPath.GroupPath>;\n  readonly changed: ReadonlyArray<GroupSummary>;\n}\n\nexport const plan = (\n  snapshot: GenerationSnapshot,\n  existing: Iterable<GroupPath.GroupPath>,\n): ModulePlan => {\n  const current = generatedGroups(snapshot);\n  return {\n    removed: Array.fromIterable(existing).filter(\n      (path) => !HashMap.has(current, path),\n    ),\n    changed: Array.fromIterable(HashMap.values(current)),\n  };\n};\n\nconst equivalentGroup = Schema.toEquivalence(GroupSummary);\n\nexport const diff = (\n  before: GenerationSnapshot,\n  after: GenerationSnapshot,\n): ModulePlan => {\n  const previous = generatedGroups(before);\n  const current = generatedGroups(after);\n  return {\n    removed: Array.filter(\n      HashMap.keys(previous),\n      (path) => !HashMap.has(current, path),\n    ),\n    changed: Array.filter(HashMap.values(current), (group) => {\n      const old = HashMap.get(previous, group.path);\n      return Option.isNone(old) || !equivalentGroup(old.value, group);\n    }),\n  };\n};\n\nconst parseNoParentChildNameCollisions = (\n  leaves: HashMap.HashMap<SpecModulePath.SpecModulePath, GroupTree>,\n): Result.Result<\n  HashMap.HashMap<SpecModulePath.SpecModulePath, GroupTree>,\n  ParentChildNameCollisionError\n> => {\n  for (const childPath of HashMap.keys(leaves)) {\n    const segments = rootPath(childPath).pathSegments;\n    for (let depth = 1; depth < segments.length; depth++) {\n      const parentPath = SpecModulePath.SpecModulePath.make(\n        `${segments.slice(0, depth).join(\"/\")}.spec.ts`,\n      );\n      const parent = HashMap.get(leaves, parentPath);\n      if (Option.isNone(parent)) continue;\n      const collisionName = segments[depth]!;\n      const collisionKind = parent.value.functionNames.includes(collisionName)\n        ? \"function\"\n        : Object.hasOwn(parent.value.groups, collisionName)\n          ? \"group\"\n          : undefined;\n      if (collisionKind !== undefined) {\n        return Result.fail(\n          new ParentChildNameCollisionError({\n            parentSpecPath: parentPath,\n            childSpecPath: childPath,\n            collisionName,\n            collisionKind,\n          }),\n        );\n      }\n    }\n  }\n  return Result.succeed(leaves);\n};\n"],"mappings":"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"}

package/dist/GroupPath.mjs

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect";
+import "@confect/core";
+import * as Path from "effect/Path";
+import * as Array from "effect/Array";
+import "effect/Function";
+import "effect/Option";
+import "effect/Record";
+import * as Schema from "effect/Schema";
+import * as String from "effect/String";
+//#region src/GroupPath.ts
+/**
+* The path to a group in the Confect API.
+*/
+var GroupPath = class extends Schema.Class("GroupPath")({ pathSegments: Schema.NonEmptyArray(Schema.NonEmptyString) }) {};
+/**
+* Create a GroupPath from path segments.
+*/
+const make = (pathSegments) => GroupPath.make({ pathSegments });
+/**
+* Append a group name to a GroupPath to create a new GroupPath.
+*/
+const append = (groupPath, groupName) => make([...groupPath.pathSegments, groupName]);
+/**
+* Expects a path string of the form `./group1/group2.ts`, relative to the
+* Convex functions directory.
+*/
+const fromGroupModulePath = Effect.fnUntraced(function* (groupModulePath) {
+	const path = yield* Path.Path;
+	const { dir, name, ext } = path.parse(groupModulePath);
+	if (ext === ".ts") {
+		const dirSegments = Array.filter(String.split(dir, path.sep), String.isNonEmpty);
+		yield* Effect.logDebug(Array.append(dirSegments, name));
+		return make(Array.append(dirSegments, name));
+	} else return yield* new GroupModulePathIsNotATypeScriptFileError({ path: groupModulePath });
+});
+/**
+* Get the module path for a group, relative to the Convex functions directory.
+*/
+const modulePath = Effect.fnUntraced(function* (groupPath) {
+	return (yield* Path.Path).join(...groupPath.pathSegments) + ".ts";
+});
+const toString = (groupPath) => Array.join(groupPath.pathSegments, ".");
+var GroupModulePathIsNotATypeScriptFileError = class extends Schema.TaggedError()("GroupModulePathIsNotATypeScriptFileError", { path: Schema.NonEmptyString }) {
+	get message() {
+		return `Expected group module path to end with .ts, got ${this.path}`;
+	}
+};
+//#endregion
+export { GroupModulePathIsNotATypeScriptFileError, GroupPath, append, fromGroupModulePath, make, modulePath, toString };
+
+//# sourceMappingURL=GroupPath.mjs.map

package/dist/GroupPath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupPath.mjs","names":[],"sources":["../src/GroupPath.ts"],"sourcesContent":["import { type GroupSpec, Spec } from \"@confect/core\";\nimport * as Path from \"effect/Path\";\nimport { pipe } from \"effect/Function\";\nimport * as Array from \"effect/Array\";\nimport * as Effect from \"effect/Effect\";\nimport * as Option from \"effect/Option\";\nimport * as Record from \"effect/Record\";\nimport * as Schema from \"effect/Schema\";\nimport * as String from \"effect/String\";\n\n/**\n * The path to a group in the Confect API.\n */\nexport class GroupPath extends Schema.Class<GroupPath>(\"GroupPath\")({\n  pathSegments: Schema.NonEmptyArray(Schema.NonEmptyString),\n}) {}\n\n/**\n * Create a GroupPath from path segments.\n */\nexport const make = (pathSegments: readonly [string, ...string[]]): GroupPath =>\n  GroupPath.make({ pathSegments });\n\n/**\n * Append a group name to a GroupPath to create a new GroupPath.\n */\nexport const append = (groupPath: GroupPath, groupName: string): GroupPath =>\n  make([...groupPath.pathSegments, groupName]);\n\n/**\n * Expects a path string of the form `./group1/group2.ts`, relative to the\n * Convex functions directory.\n */\nexport const fromGroupModulePath = Effect.fnUntraced(function* (\n  groupModulePath: string,\n) {\n  const path = yield* Path.Path;\n\n  const { dir, name, ext } = path.parse(groupModulePath);\n\n  if (ext === \".ts\") {\n    const dirSegments = Array.filter(\n      String.split(dir, path.sep),\n      String.isNonEmpty,\n    );\n    yield* Effect.logDebug(Array.append(dirSegments, name));\n    return make(Array.append(dirSegments, name));\n  } else {\n    return yield* new GroupModulePathIsNotATypeScriptFileError({\n      path: groupModulePath,\n    });\n  }\n});\n\n/**\n * Get the module path for a group, relative to the Convex functions directory.\n */\nexport const modulePath = Effect.fnUntraced(function* (groupPath: GroupPath) {\n  const path = yield* Path.Path;\n\n  return path.join(...groupPath.pathSegments) + \".ts\";\n});\n\nexport const getGroupSpec = (\n  spec: Spec.AnyWithProps,\n  groupPath: GroupPath,\n): Option.Option<GroupSpec.AnyWithProps> =>\n  pipe(\n    groupPath.pathSegments,\n    Array.matchLeft({\n      onEmpty: () => Option.none(),\n      onNonEmpty: (head, tail) =>\n        pipe(\n          Record.get(Spec.groups(spec), head),\n          Option.flatMap((group) =>\n            Array.isArrayNonEmpty(tail)\n              ? getGroupSpecHelper(group, tail)\n              : Option.some(group),\n          ),\n        ),\n    }),\n  );\n\nconst getGroupSpecHelper = (\n  group: GroupSpec.AnyWithProps,\n  remainingPath: ReadonlyArray<string>,\n): Option.Option<GroupSpec.AnyWithProps> =>\n  pipe(\n    remainingPath,\n    Array.matchLeft({\n      onEmpty: () => Option.some(group),\n      onNonEmpty: (head, tail) =>\n        pipe(\n          Record.get(group.groups, head),\n          Option.flatMap((subGroup) =>\n            Array.isArrayNonEmpty(tail)\n              ? getGroupSpecHelper(subGroup, tail)\n              : Option.some(subGroup),\n          ),\n        ),\n    }),\n  );\n\nexport const toString = (groupPath: GroupPath) =>\n  Array.join(groupPath.pathSegments, \".\");\n\nexport class GroupModulePathIsNotATypeScriptFileError extends Schema.TaggedError<GroupModulePathIsNotATypeScriptFileError>()(\n  \"GroupModulePathIsNotATypeScriptFileError\",\n  {\n    path: Schema.NonEmptyString,\n  },\n) {\n  override get message(): string {\n    return `Expected group module path to end with .ts, got ${this.path}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,IAAa,YAAb,cAA+B,OAAO,MAAiB,WAAW,CAAC,CAAC,EAClE,cAAc,OAAO,cAAc,OAAO,cAAc,EAC1D,CAAC,CAAC,CAAC,CAAC;;;;AAKJ,MAAa,QAAQ,iBACnB,UAAU,KAAK,EAAE,aAAa,CAAC;;;;AAKjC,MAAa,UAAU,WAAsB,cAC3C,KAAK,CAAC,GAAG,UAAU,cAAc,SAAS,CAAC;;;;;AAM7C,MAAa,sBAAsB,OAAO,WAAW,WACnD,iBACA;CACA,MAAM,OAAO,OAAO,KAAK;CAEzB,MAAM,EAAE,KAAK,MAAM,QAAQ,KAAK,MAAM,eAAe;CAErD,IAAI,QAAQ,OAAO;EACjB,MAAM,cAAc,MAAM,OACxB,OAAO,MAAM,KAAK,KAAK,GAAG,GAC1B,OAAO,UACT;EACA,OAAO,OAAO,SAAS,MAAM,OAAO,aAAa,IAAI,CAAC;EACtD,OAAO,KAAK,MAAM,OAAO,aAAa,IAAI,CAAC;CAC7C,OACE,OAAO,OAAO,IAAI,yCAAyC,EACzD,MAAM,gBACR,CAAC;AAEL,CAAC;;;;AAKD,MAAa,aAAa,OAAO,WAAW,WAAW,WAAsB;CAG3E,QAAO,OAFa,KAAK,KAAA,CAEb,KAAK,GAAG,UAAU,YAAY,IAAI;AAChD,CAAC;AA0CD,MAAa,YAAY,cACvB,MAAM,KAAK,UAAU,cAAc,GAAG;AAExC,IAAa,2CAAb,cAA8D,OAAO,YAAsD,CAAC,CAC1H,4CACA,EACE,MAAM,OAAO,eACf,CACF,CAAC,CAAC;CACA,IAAa,UAAkB;EAC7B,OAAO,mDAAmD,KAAK;CACjE;AACF"}

package/dist/GroupPaths.mjs

@@ -0,0 +1,8 @@
+import { GroupPath } from "./GroupPath.mjs";
+import * as Schema from "effect/Schema";
+//#region src/GroupPaths.ts
+const GroupPaths = Schema.HashSet(GroupPath).pipe(Schema.brand("@confect/cli/GroupPaths"));
+//#endregion
+export { GroupPaths };
+
+//# sourceMappingURL=GroupPaths.mjs.map

package/dist/GroupPaths.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupPaths.mjs","names":["GroupPath.GroupPath"],"sources":["../src/GroupPaths.ts"],"sourcesContent":["import * as Schema from \"effect/Schema\";\nimport * as GroupPath from \"./GroupPath.js\";\n\nexport const GroupPaths = Schema.HashSet(GroupPath.GroupPath).pipe(\n  Schema.brand(\"@confect/cli/GroupPaths\"),\n);\nexport type GroupPaths = typeof GroupPaths.Type;\n"],"mappings":";;;AAGA,MAAa,aAAa,OAAO,QAAQA,SAAmB,CAAC,CAAC,KAC5D,OAAO,MAAM,yBAAyB,CACxC"}

package/dist/ImplModulePath.mjs

@@ -0,0 +1,8 @@
+import { withSuffix } from "./RelativeModulePath.mjs";
+import * as Schema from "effect/Schema";
+//#region src/ImplModulePath.ts
+const ImplModulePath = withSuffix(".impl.ts").pipe(Schema.brand("@confect/cli/ImplModulePath"));
+//#endregion
+export { ImplModulePath };
+
+//# sourceMappingURL=ImplModulePath.mjs.map

package/dist/ImplModulePath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImplModulePath.mjs","names":["RelativeModulePath.withSuffix"],"sources":["../src/ImplModulePath.ts"],"sourcesContent":["import * as Schema from \"effect/Schema\";\nimport * as RelativeModulePath from \"./RelativeModulePath.js\";\n\nexport const ImplModulePath = RelativeModulePath.withSuffix(\".impl.ts\").pipe(\n  Schema.brand(\"@confect/cli/ImplModulePath\"),\n);\n\nexport type ImplModulePath = typeof ImplModulePath.Type;\n"],"mappings":";;;AAGA,MAAa,iBAAiBA,WAA8B,UAAU,CAAC,CAAC,KACtE,OAAO,MAAM,6BAA6B,CAC5C"}

package/dist/LeafModule.mjs

@@ -0,0 +1,285 @@
+import { fromBundlerError } from "./BuildError.mjs";
+import { bundle, directlyImports, importersOfPackage, withBatch } from "./Bundler.mjs";
+import { ImplMissingDefaultLayerError, ImplMissingFunctionsError, ImplMissingMiddlewareError, ImplMissingSpecImportError, ImplNotFinalizedError, InvalidMiddlewareAttachmentError, MissingImplFileError, MissingSpecFileError, SpecImportsServerError, SpecMissingDefaultGroupSpecError } from "./CodegenError.mjs";
+import { ConfectDirectory } from "./ConfectDirectory.mjs";
+import { removePathExtension, toPosixPath } from "./utils.mjs";
+import { ImplModulePath } from "./ImplModulePath.mjs";
+import * as Effect from "effect/Effect";
+import { GroupSpec, MiddlewareAttachment } from "@confect/core";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Array from "effect/Array";
+import * as HashSet from "effect/HashSet";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import * as Schema from "effect/Schema";
+import * as String from "effect/String";
+import * as Layer from "effect/Layer";
+import * as Brand from "effect/Brand";
+import { Registry } from "@confect/server";
+import * as GroupImpl from "@confect/server/GroupImpl";
+//#region src/LeafModule.ts
+const LoadedLeafModule = Brand.nominal();
+const VALIDATION_CONCURRENCY = 4;
+const SPEC_SUFFIX = ".spec.ts";
+const IMPL_SUFFIX = ".impl.ts";
+const swapModuleSuffix = Effect.fnUntraced(function* (relativePath, fromSuffix, toSuffix) {
+	const path = yield* Path.Path;
+	const { dir, name, ext } = path.parse(relativePath);
+	if (ext !== ".ts" || !name.endsWith(fromSuffix.slice(0, -3))) return relativePath;
+	const nextName = `${name.slice(0, -fromSuffix.slice(0, -3).length)}${toSuffix.slice(0, -3)}`;
+	return dir.length > 0 ? path.join(dir, `${nextName}${ext}`) : `${nextName}${ext}`;
+});
+const isLeafSpecPath = (relativePath) => relativePath.endsWith(SPEC_SUFFIX);
+const exportNameFromModulePath = Effect.fnUntraced(function* (relativePath) {
+	const { name, ext } = (yield* Path.Path).parse(relativePath);
+	if (ext !== ".ts") return name;
+	return name.endsWith(".spec") ? name.slice(0, -5) : name;
+});
+const groupPathFromRelativeModulePath = Effect.fnUntraced(function* (relativePath) {
+	const path = yield* Path.Path;
+	const { dir, name, ext } = path.parse(relativePath);
+	const stem = ext === ".ts" && name.endsWith(".spec") ? name.slice(0, -5) : name;
+	const dirSegments = Array.filter(String.split(dir, path.sep), String.isNonEmpty);
+	const pathSegments = Array.append(dirSegments, stem);
+	return {
+		pathSegments,
+		groupPathDot: Array.join(pathSegments, ".")
+	};
+});
+const specImportPathFromGenerated = Effect.fnUntraced(function* (specRelativePath) {
+	const path = yield* Path.Path;
+	return `../${toPosixPath(path, yield* removePathExtension(specRelativePath))}.js`;
+});
+const specPathForImpl = (implRelativePath) => swapModuleSuffix(implRelativePath, IMPL_SUFFIX, SPEC_SUFFIX);
+const implPathForSpec = (specRelativePath) => swapModuleSuffix(specRelativePath, SPEC_SUFFIX, IMPL_SUFFIX);
+const registeredFunctionsRelativePath = Effect.fnUntraced(function* (leaf) {
+	return (yield* Path.Path).join("registeredFunctions", ...leaf.pathSegments) + ".ts";
+});
+const discoverLeafSpecFiles = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const excludedDirs = HashSet.make("_generated", "tables", "middleware");
+	const excludedFiles = HashSet.make("nodeSpec.ts", "spec.ts");
+	const allPaths = yield* fs.readDirectory(confectDirectory, { recursive: true });
+	return Array.filter(allPaths, (relativePath) => {
+		if (!isLeafSpecPath(relativePath)) return false;
+		if (HashSet.has(excludedFiles, relativePath)) return false;
+		const segments = String.split(relativePath, path.sep);
+		return !Array.some(segments, (segment) => HashSet.has(excludedDirs, segment));
+	});
+});
+const discoverLeafImplFiles = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const excludedDirs = HashSet.make("_generated", "tables", "middleware");
+	const allPaths = yield* fs.readDirectory(confectDirectory, { recursive: true });
+	return Array.filter(Array.filterMap(allPaths, (relativePath) => Schema.decodeResult(ImplModulePath)(relativePath)), (relativePath) => {
+		const segments = String.split(relativePath, path.sep);
+		return !Array.some(segments, (segment) => HashSet.has(excludedDirs, segment));
+	});
+});
+const toLeafModule = Effect.fnUntraced(function* (specRelativePath) {
+	const exportName = yield* exportNameFromModulePath(specRelativePath);
+	const { pathSegments, groupPathDot } = yield* groupPathFromRelativeModulePath(specRelativePath);
+	return {
+		relativePath: specRelativePath,
+		pathSegments,
+		groupPathDot,
+		exportName,
+		specImportPath: yield* specImportPathFromGenerated(specRelativePath)
+	};
+});
+const absoluteModulePath = Effect.fnUntraced(function* (relativePath) {
+	const confectDirectory = yield* ConfectDirectory.get;
+	return (yield* Path.Path).resolve(confectDirectory, relativePath);
+});
+/**
+* Every `*.spec.ts` is reachable from `_generated/spec.ts`, which the client
+* imports through `_generated/refs.ts`—so a spec's whole import graph is
+* bundled into the browser whether or not the client calls those functions.
+* Server logic co-located with a declaration therefore ships to users,
+* silently.
+*
+* `@confect/server` is a sound proxy for "server logic lives here": an
+* implementation can't be written without `FunctionImpl`/`MiddlewareImpl`, both
+* of which live there. Table `Doc`/`Fields` schemas live in `@confect/core`, so
+* the documented `notes.Doc` pattern in a spec must not reach `@confect/server`
+* even through `tables/` or `_generated/`. The check runs over the spec
+* bundle's transitive inputs rather than the spec module alone, so it also
+* covers middleware declarations under `confect/middleware/` (which codegen
+* otherwise never visits) and any shared helper a spec pulls in—while only ever
+* flagging modules that genuinely reach the client.
+*/
+const validateClientSafety = Effect.fnUntraced(function* (leaf, bundled) {
+	const path = yield* Path.Path;
+	const confectDirectory = path.resolve(yield* ConfectDirectory.get);
+	const isCheckedUserModule = (absolutePath) => {
+		const relative = path.relative(confectDirectory, absolutePath);
+		return !relative.startsWith("..") && !path.isAbsolute(relative);
+	};
+	const importers = importersOfPackage(bundled, "@confect/server", isCheckedUserModule);
+	if (importers.length > 0) return yield* new SpecImportsServerError({
+		specPath: leaf.relativePath,
+		importerPaths: Array.map(importers, (absolutePath) => toPosixPath(path, path.relative(confectDirectory, absolutePath)))
+	});
+});
+/**
+* Validate that the leaf's spec file default-exports a `GroupSpec`, and that
+* nothing it reaches drags server code into the client (see
+* {@link validateClientSafety}). Returns the leaf paired with its validated
+* spec, so subsequent operations reuse that association without re-bundling.
+* The runtime is declared by the spec, not its file location.
+*/
+const loadSpec = Effect.fn("LeafModule.loadSpec")(function* (leaf) {
+	const absolutePath = yield* absoluteModulePath(leaf.relativePath);
+	const bundled = yield* bundle(absolutePath).pipe(Effect.mapError((error) => fromBundlerError(leaf.relativePath, error)));
+	const groupSpec = bundled.module.default;
+	if (!GroupSpec.isGroupSpec(groupSpec)) return yield* new SpecMissingDefaultGroupSpecError({ specPath: leaf.relativePath });
+	yield* validateClientSafety(leaf, bundled);
+	yield* Effect.fromResult(GroupSpec.validateMiddleware(groupSpec)).pipe(Effect.mapError((error) => new InvalidMiddlewareAttachmentError({
+		specPath: leaf.relativePath,
+		message: MiddlewareAttachment.formatValidationError(error)
+	})));
+	return LoadedLeafModule({
+		...leaf,
+		spec: groupSpec
+	});
+});
+/**
+* Walk the built `Context` for a `Finalized` `GroupImpl` service value. The
+* lookup is value-shaped (via `GroupImpl.isFinalizedGroupImpl`) so we don't
+* need to know the group's path up front to construct a typed tag for it.
+*/
+const findFinalizedGroupImpl = (context) => Array.findFirst(context.mapUnsafe.values(), GroupImpl.isFinalizedGroupImpl);
+/**
+* Build the impl layer with a fresh `Registry` so each validation is isolated
+* from prior validations' `FunctionImpl.make` writes. The CLI no longer reads
+* the registry directly—`GroupImpl.finalize` snapshots the registered function
+* names onto the produced `Finalized` `GroupImpl` service value—but a fresh
+* `Ref` is still required because the default `Context.Reference` is cached
+* globally and would otherwise accumulate items across impls.
+*/
+const buildImplLayer = Effect.fnUntraced(function* (implLayer) {
+	const registry = Ref.makeUnsafe({});
+	return yield* Layer.build(implLayer).pipe(Effect.provideService(Registry.Registry, registry));
+}, Effect.scoped);
+/**
+* Validate that the leaf's sibling impl file imports the spec, default-exports
+* a finalized `GroupImpl` layer, and provides a `FunctionImpl` for every
+* function declared by the spec.
+*/
+const validateImpl = Effect.fn("LeafModule.validateImpl")(function* (leaf) {
+	const implRelativePath = yield* implPathForSpec(leaf.relativePath);
+	const implAbsolutePath = yield* absoluteModulePath(implRelativePath);
+	const specAbsolutePath = yield* absoluteModulePath(leaf.relativePath);
+	const bundled = yield* bundle(implAbsolutePath).pipe(Effect.mapError((error) => fromBundlerError(implRelativePath, error)));
+	if (!(yield* directlyImports(bundled, implAbsolutePath, specAbsolutePath))) return yield* new ImplMissingSpecImportError({
+		implPath: implRelativePath,
+		expectedSpecPath: leaf.relativePath
+	});
+	if (!Layer.isLayer(bundled.module.default)) return yield* new ImplMissingDefaultLayerError({ implPath: implRelativePath });
+	const groupSpec = leaf.spec;
+	const expectedFunctionNames = Object.keys(groupSpec.functions);
+	const context = yield* buildImplLayer(bundled.module.default);
+	const finalizedGroupImpl = yield* Option.match(findFinalizedGroupImpl(context), {
+		onNone: () => new ImplNotFinalizedError({ implPath: implRelativePath }),
+		onSome: Effect.succeed
+	});
+	const registeredSet = HashSet.fromIterable(finalizedGroupImpl.registeredFunctionNames);
+	const missing = expectedFunctionNames.filter((name) => !HashSet.has(registeredSet, name));
+	if (missing.length > 0) return yield* new ImplMissingFunctionsError({
+		implPath: implRelativePath,
+		groupPath: leaf.groupPathDot,
+		missingFunctionNames: missing
+	});
+	const expectedMiddlewareKeys = Array.dedupe([...(groupSpec.middlewareSpecs ?? []).map((middlewareSpec) => middlewareSpec.key), ...Object.values(groupSpec.functions).flatMap((function_) => (function_.middlewareSpecs ?? []).map((middlewareSpec) => middlewareSpec.key))]);
+	const registeredMiddlewareKeys = HashSet.fromIterable(finalizedGroupImpl.registeredMiddlewareKeys ?? []);
+	const missingMiddleware = Array.filter(expectedMiddlewareKeys, (key) => !HashSet.has(registeredMiddlewareKeys, key));
+	if (missingMiddleware.length > 0) return yield* new ImplMissingMiddlewareError({
+		implPath: implRelativePath,
+		groupPath: leaf.groupPathDot,
+		missingMiddlewareKeys: missingMiddleware
+	});
+});
+const withImplFiles = Effect.fnUntraced(function* (relativePaths, use) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const pairs = yield* Effect.forEach(relativePaths, (implRelativePath) => specPathForImpl(implRelativePath).pipe(Effect.map((specRelativePath) => ({
+		implRelativePath,
+		specRelativePath
+	}))));
+	return yield* withBatch(pairs.flatMap(({ implRelativePath, specRelativePath }) => [path.resolve(confectDirectory, implRelativePath), path.resolve(confectDirectory, specRelativePath)]), Effect.gen(function* () {
+		return yield* use(yield* Effect.forEach(pairs, Effect.fnUntraced(function* ({ implRelativePath, specRelativePath }) {
+			if (!(yield* fs.exists(path.join(confectDirectory, specRelativePath)))) return yield* new MissingSpecFileError({
+				implPath: implRelativePath,
+				expectedSpecPath: specRelativePath
+			});
+			if (!(yield* fs.exists(path.join(confectDirectory, implRelativePath)))) return yield* new MissingImplFileError({
+				specPath: specRelativePath,
+				expectedImplPath: implRelativePath
+			});
+			return yield* loadSpec(yield* toLeafModule(specRelativePath));
+		}), { concurrency: VALIDATION_CONCURRENCY }));
+	}));
+});
+const validateImplFiles = Effect.fn("LeafModule.validateImplFiles")((relativePaths) => withImplFiles(relativePaths, validateAllImpls));
+const validateAllImpls = Effect.fnUntraced(function* (leaves) {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const implementationPaths = yield* Effect.forEach(leaves, ({ relativePath }) => implPathForSpec(relativePath).pipe(Effect.map((implPath) => path.resolve(confectDirectory, implPath))));
+	yield* withBatch(implementationPaths, Effect.forEach(leaves, validateImpl, {
+		concurrency: VALIDATION_CONCURRENCY,
+		discard: true
+	}));
+});
+const loadAll = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const specFiles = yield* discoverLeafSpecFiles;
+	const results = yield* withBatch(specFiles.map((relativePath) => path.resolve(confectDirectory, relativePath)), Effect.forEach(specFiles, Effect.fnUntraced(function* (specRelativePath) {
+		const discovered = yield* toLeafModule(specRelativePath);
+		const leaf = yield* loadSpec(discovered);
+		const implRelativePath = yield* implPathForSpec(specRelativePath);
+		const implAbsolutePath = path.join(confectDirectory, implRelativePath);
+		if (!(yield* fs.exists(implAbsolutePath))) return yield* new MissingImplFileError({
+			specPath: specRelativePath,
+			expectedImplPath: implRelativePath
+		});
+		return leaf;
+	}), { concurrency: VALIDATION_CONCURRENCY }));
+	yield* validateOrphanImpls(specFiles);
+	return results;
+});
+/**
+* Walk leaf ancestors and fail with a {@link ParentChildNameCollisionError} when
+* a parent leaf declares a function or subgroup whose name matches a sibling
+* subdirectory spec's segment. Without this check the colliding descendant
+* would overwrite the parent's entry in the assembled `GroupSpec.groups` map at
+* runtime, surfacing as a confusing `Refs.make` error rather than a
+* codegen-time diagnostic.
+*/
+const validateOrphanImpls = Effect.fnUntraced(function* (specFiles) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const implFiles = yield* discoverLeafImplFiles;
+	const specPaths = HashSet.fromIterable(specFiles);
+	yield* Effect.forEach(implFiles, Effect.fnUntraced(function* (implRelativePath) {
+		const specRelativePath = yield* specPathForImpl(implRelativePath);
+		if (HashSet.has(specPaths, specRelativePath)) return;
+		const specAbsolutePath = path.join(confectDirectory, specRelativePath);
+		if (!(yield* fs.exists(specAbsolutePath))) return yield* new MissingSpecFileError({
+			implPath: implRelativePath,
+			expectedSpecPath: specRelativePath
+		});
+	}));
+});
+//#endregion
+export { IMPL_SUFFIX, SPEC_SUFFIX, discoverLeafImplFiles, discoverLeafSpecFiles, exportNameFromModulePath, groupPathFromRelativeModulePath, implPathForSpec, isLeafSpecPath, loadAll, loadSpec, registeredFunctionsRelativePath, specImportPathFromGenerated, specPathForImpl, toLeafModule, validateAllImpls, validateImpl, validateImplFiles, withImplFiles };
+
+//# sourceMappingURL=LeafModule.mjs.map

package/dist/LeafModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeafModule.mjs","names":["Bundler.importersOfPackage","Bundler.bundle","Bundler.directlyImports","Bundler.withBatch"],"sources":["../src/LeafModule.ts"],"sourcesContent":["import { GroupSpec, MiddlewareAttachment } from \"@confect/core\";\nimport { Registry, type RegistryItems } from \"@confect/server\";\nimport * as GroupImpl from \"@confect/server/GroupImpl\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as Path from \"effect/Path\";\nimport type { Context } from \"effect\";\nimport * as Array from \"effect/Array\";\nimport * as Brand from \"effect/Brand\";\nimport * as Effect from \"effect/Effect\";\nimport * as HashSet from \"effect/HashSet\";\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport * as Ref from \"effect/Ref\";\nimport * as Schema from \"effect/Schema\";\nimport * as String from \"effect/String\";\nimport { fromBundlerError } from \"./BuildError.js\";\nimport * as Bundler from \"./Bundler.js\";\nimport {\n  MissingImplFileError,\n  MissingSpecFileError,\n  ImplMissingDefaultLayerError,\n  ImplMissingFunctionsError,\n  ImplMissingMiddlewareError,\n  ImplMissingSpecImportError,\n  ImplNotFinalizedError,\n  InvalidMiddlewareAttachmentError,\n  SpecImportsServerError,\n  SpecMissingDefaultGroupSpecError,\n} from \"./CodegenError.js\";\nimport { ConfectDirectory } from \"./ConfectDirectory.js\";\nimport { ImplModulePath } from \"./ImplModulePath.js\";\nimport { removePathExtension, toPosixPath } from \"./utils.js\";\n\nexport interface LeafModule {\n  readonly relativePath: string;\n  readonly pathSegments: readonly [string, ...string[]];\n  readonly groupPathDot: string;\n  readonly exportName: string;\n  readonly specImportPath: string;\n}\n\nexport type LoadedLeafModule = LeafModule & {\n  readonly spec: GroupSpec.AnyWithProps;\n} & Brand.Brand<\"@confect/cli/LoadedLeafModule\">;\n\nconst LoadedLeafModule = Brand.nominal<LoadedLeafModule>();\n\nconst VALIDATION_CONCURRENCY = 4;\n\nexport const SPEC_SUFFIX = \".spec.ts\";\nexport const IMPL_SUFFIX = \".impl.ts\";\n\nconst swapModuleSuffix = Effect.fnUntraced(function* (\n  relativePath: string,\n  fromSuffix: string,\n  toSuffix: string,\n) {\n  const path = yield* Path.Path;\n  const { dir, name, ext } = path.parse(relativePath);\n  if (ext !== \".ts\" || !name.endsWith(fromSuffix.slice(0, -\".ts\".length))) {\n    return relativePath;\n  }\n\n  const stem = name.slice(0, -fromSuffix.slice(0, -\".ts\".length).length);\n  const nextName = `${stem}${toSuffix.slice(0, -\".ts\".length)}`;\n  return dir.length > 0\n    ? path.join(dir, `${nextName}${ext}`)\n    : `${nextName}${ext}`;\n});\n\nexport const isLeafSpecPath = (relativePath: string) =>\n  relativePath.endsWith(SPEC_SUFFIX);\n\nexport const exportNameFromModulePath = Effect.fnUntraced(function* (\n  relativePath: string,\n) {\n  const path = yield* Path.Path;\n  const { name, ext } = path.parse(relativePath);\n  if (ext !== \".ts\") {\n    return name;\n  }\n  return name.endsWith(\".spec\") ? name.slice(0, -\".spec\".length) : name;\n});\n\nexport const groupPathFromRelativeModulePath = Effect.fnUntraced(function* (\n  relativePath: string,\n) {\n  const path = yield* Path.Path;\n  const { dir, name, ext } = path.parse(relativePath);\n  const stem =\n    ext === \".ts\" && name.endsWith(\".spec\")\n      ? name.slice(0, -\".spec\".length)\n      : name;\n  const dirSegments = Array.filter(\n    String.split(dir, path.sep),\n    String.isNonEmpty,\n  );\n  const pathSegments = Array.append(dirSegments, stem) as [string, ...string[]];\n  return {\n    pathSegments,\n    groupPathDot: Array.join(pathSegments, \".\"),\n  };\n});\n\nexport const specImportPathFromGenerated = Effect.fnUntraced(function* (\n  specRelativePath: string,\n) {\n  const path = yield* Path.Path;\n  const withoutExt = toPosixPath(\n    path,\n    yield* removePathExtension(specRelativePath),\n  );\n  return `../${withoutExt}.js`;\n});\n\nexport const specPathForImpl = (implRelativePath: string) =>\n  swapModuleSuffix(implRelativePath, IMPL_SUFFIX, SPEC_SUFFIX);\n\nexport const implPathForSpec = (specRelativePath: string) =>\n  swapModuleSuffix(specRelativePath, SPEC_SUFFIX, IMPL_SUFFIX);\n\nexport const registeredFunctionsRelativePath = Effect.fnUntraced(function* (\n  leaf: LeafModule,\n) {\n  const path = yield* Path.Path;\n  return path.join(\"registeredFunctions\", ...leaf.pathSegments) + \".ts\";\n});\n\nexport const discoverLeafSpecFiles = Effect.gen(function* () {\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n\n  const excludedDirs = HashSet.make(\"_generated\", \"tables\", \"middleware\");\n  const excludedFiles = HashSet.make(\"nodeSpec.ts\", \"spec.ts\");\n\n  const allPaths = yield* fs.readDirectory(confectDirectory, {\n    recursive: true,\n  });\n\n  return Array.filter(allPaths, (relativePath) => {\n    if (!isLeafSpecPath(relativePath)) {\n      return false;\n    }\n\n    if (HashSet.has(excludedFiles, relativePath)) {\n      return false;\n    }\n\n    const segments = String.split(relativePath, path.sep);\n    return !Array.some(segments, (segment) =>\n      HashSet.has(excludedDirs, segment),\n    );\n  });\n});\n\nexport const discoverLeafImplFiles = Effect.gen(function* () {\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n\n  const excludedDirs = HashSet.make(\"_generated\", \"tables\", \"middleware\");\n\n  const allPaths = yield* fs.readDirectory(confectDirectory, {\n    recursive: true,\n  });\n\n  return Array.filter(\n    Array.filterMap(allPaths, (relativePath) =>\n      Schema.decodeResult(ImplModulePath)(relativePath),\n    ),\n    (relativePath) => {\n      const segments = String.split(relativePath, path.sep);\n      return !Array.some(segments, (segment) =>\n        HashSet.has(excludedDirs, segment),\n      );\n    },\n  );\n});\n\nexport const toLeafModule = Effect.fnUntraced(function* (\n  specRelativePath: string,\n) {\n  const exportName = yield* exportNameFromModulePath(specRelativePath);\n  const { pathSegments, groupPathDot } =\n    yield* groupPathFromRelativeModulePath(specRelativePath);\n  const specImportPath = yield* specImportPathFromGenerated(specRelativePath);\n\n  return {\n    relativePath: specRelativePath,\n    pathSegments,\n    groupPathDot,\n    exportName,\n    specImportPath,\n  } satisfies LeafModule;\n});\n\nconst absoluteModulePath = Effect.fnUntraced(function* (relativePath: string) {\n  const confectDirectory = yield* ConfectDirectory.get;\n  const path = yield* Path.Path;\n  return path.resolve(confectDirectory, relativePath);\n});\n\n/**\n * Every `*.spec.ts` is reachable from `_generated/spec.ts`, which the client\n * imports through `_generated/refs.ts`—so a spec's whole import graph is\n * bundled into the browser whether or not the client calls those functions.\n * Server logic co-located with a declaration therefore ships to users,\n * silently.\n *\n * `@confect/server` is a sound proxy for \"server logic lives here\": an\n * implementation can't be written without `FunctionImpl`/`MiddlewareImpl`, both\n * of which live there. Table `Doc`/`Fields` schemas live in `@confect/core`, so\n * the documented `notes.Doc` pattern in a spec must not reach `@confect/server`\n * even through `tables/` or `_generated/`. The check runs over the spec\n * bundle's transitive inputs rather than the spec module alone, so it also\n * covers middleware declarations under `confect/middleware/` (which codegen\n * otherwise never visits) and any shared helper a spec pulls in—while only ever\n * flagging modules that genuinely reach the client.\n */\nconst validateClientSafety = Effect.fnUntraced(function* (\n  leaf: LeafModule,\n  bundled: Bundler.Bundled,\n) {\n  const path = yield* Path.Path;\n  const confectDirectory = path.resolve(yield* ConfectDirectory.get);\n\n  const isCheckedUserModule = (absolutePath: string) => {\n    const relative = path.relative(confectDirectory, absolutePath);\n    return !relative.startsWith(\"..\") && !path.isAbsolute(relative);\n  };\n\n  const importers = Bundler.importersOfPackage(\n    bundled,\n    \"@confect/server\",\n    isCheckedUserModule,\n  );\n\n  if (importers.length > 0) {\n    return yield* new SpecImportsServerError({\n      specPath: leaf.relativePath,\n      importerPaths: Array.map(importers, (absolutePath) =>\n        toPosixPath(path, path.relative(confectDirectory, absolutePath)),\n      ),\n    });\n  }\n});\n\n/**\n * Validate that the leaf's spec file default-exports a `GroupSpec`, and that\n * nothing it reaches drags server code into the client (see\n * {@link validateClientSafety}). Returns the leaf paired with its validated\n * spec, so subsequent operations reuse that association without re-bundling.\n * The runtime is declared by the spec, not its file location.\n */\nexport const loadSpec = Effect.fn(\"LeafModule.loadSpec\")(function* (\n  leaf: LeafModule,\n) {\n  const absolutePath = yield* absoluteModulePath(leaf.relativePath);\n  const bundled = yield* Bundler.bundle(absolutePath).pipe(\n    Effect.mapError((error) => fromBundlerError(leaf.relativePath, error)),\n  );\n\n  const groupSpec = bundled.module.default;\n\n  if (!GroupSpec.isGroupSpec(groupSpec)) {\n    return yield* new SpecMissingDefaultGroupSpecError({\n      specPath: leaf.relativePath,\n    });\n  }\n\n  yield* validateClientSafety(leaf, bundled);\n\n  yield* Effect.fromResult(GroupSpec.validateMiddleware(groupSpec)).pipe(\n    Effect.mapError(\n      (error) =>\n        new InvalidMiddlewareAttachmentError({\n          specPath: leaf.relativePath,\n          message: MiddlewareAttachment.formatValidationError(error),\n        }),\n    ),\n  );\n\n  return LoadedLeafModule({\n    ...leaf,\n    spec: groupSpec,\n  });\n});\n\n/**\n * Walk the built `Context` for a `Finalized` `GroupImpl` service value. The\n * lookup is value-shaped (via `GroupImpl.isFinalizedGroupImpl`) so we don't\n * need to know the group's path up front to construct a typed tag for it.\n */\nconst findFinalizedGroupImpl = <S>(\n  context: Context.Context<S>,\n): Option.Option<GroupImpl.AnyFinalized> =>\n  Array.findFirst(context.mapUnsafe.values(), GroupImpl.isFinalizedGroupImpl);\n\n/**\n * Build the impl layer with a fresh `Registry` so each validation is isolated\n * from prior validations' `FunctionImpl.make` writes. The CLI no longer reads\n * the registry directly—`GroupImpl.finalize` snapshots the registered function\n * names onto the produced `Finalized` `GroupImpl` service value—but a fresh\n * `Ref` is still required because the default `Context.Reference` is cached\n * globally and would otherwise accumulate items across impls.\n */\nconst buildImplLayer = Effect.fnUntraced(function* (\n  implLayer: Layer.Layer<unknown>,\n) {\n  const registry = Ref.makeUnsafe<RegistryItems.RegistryItems>({});\n  return yield* Layer.build(\n    implLayer as Layer.Layer<unknown, never, never>,\n  ).pipe(Effect.provideService(Registry.Registry, registry));\n}, Effect.scoped);\n\n/**\n * Validate that the leaf's sibling impl file imports the spec, default-exports\n * a finalized `GroupImpl` layer, and provides a `FunctionImpl` for every\n * function declared by the spec.\n */\nexport const validateImpl = Effect.fn(\"LeafModule.validateImpl\")(function* (\n  leaf: LoadedLeafModule,\n) {\n  const implRelativePath = yield* implPathForSpec(leaf.relativePath);\n  const implAbsolutePath = yield* absoluteModulePath(implRelativePath);\n  const specAbsolutePath = yield* absoluteModulePath(leaf.relativePath);\n\n  const bundled = yield* Bundler.bundle(implAbsolutePath).pipe(\n    Effect.mapError((error) => fromBundlerError(implRelativePath, error)),\n  );\n\n  if (\n    !(yield* Bundler.directlyImports(\n      bundled,\n      implAbsolutePath,\n      specAbsolutePath,\n    ))\n  ) {\n    return yield* new ImplMissingSpecImportError({\n      implPath: implRelativePath,\n      expectedSpecPath: leaf.relativePath,\n    });\n  }\n\n  if (!Layer.isLayer(bundled.module.default)) {\n    return yield* new ImplMissingDefaultLayerError({\n      implPath: implRelativePath,\n    });\n  }\n\n  const groupSpec = leaf.spec;\n  const expectedFunctionNames = Object.keys(groupSpec.functions);\n\n  const context = yield* buildImplLayer(\n    bundled.module.default as Layer.Layer<unknown>,\n  );\n  const finalizedGroupImpl = yield* Option.match(\n    findFinalizedGroupImpl(context),\n    {\n      onNone: () => new ImplNotFinalizedError({ implPath: implRelativePath }),\n      onSome: Effect.succeed,\n    },\n  );\n\n  const registeredSet = HashSet.fromIterable(\n    finalizedGroupImpl.registeredFunctionNames,\n  );\n  const missing = expectedFunctionNames.filter(\n    (name) => !HashSet.has(registeredSet, name),\n  );\n\n  if (missing.length > 0) {\n    return yield* new ImplMissingFunctionsError({\n      implPath: implRelativePath,\n      groupPath: leaf.groupPathDot,\n      missingFunctionNames: missing,\n    });\n  }\n\n  const expectedMiddlewareKeys = Array.dedupe([\n    ...(groupSpec.middlewareSpecs ?? []).map(\n      (middlewareSpec) => middlewareSpec.key,\n    ),\n    ...Object.values(groupSpec.functions).flatMap((function_) =>\n      (function_.middlewareSpecs ?? []).map(\n        (middlewareSpec) => middlewareSpec.key,\n      ),\n    ),\n  ]);\n  const registeredMiddlewareKeys = HashSet.fromIterable(\n    finalizedGroupImpl.registeredMiddlewareKeys ?? [],\n  );\n  const missingMiddleware = Array.filter(\n    expectedMiddlewareKeys,\n    (key) => !HashSet.has(registeredMiddlewareKeys, key),\n  );\n\n  if (missingMiddleware.length > 0) {\n    return yield* new ImplMissingMiddlewareError({\n      implPath: implRelativePath,\n      groupPath: leaf.groupPathDot,\n      missingMiddlewareKeys: missingMiddleware,\n    });\n  }\n});\n\nexport const withImplFiles = Effect.fnUntraced(function* <A, E, R>(\n  relativePaths: ReadonlyArray<ImplModulePath>,\n  use: (leaves: ReadonlyArray<LoadedLeafModule>) => Effect.Effect<A, E, R>,\n) {\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n  const pairs = yield* Effect.forEach(relativePaths, (implRelativePath) =>\n    specPathForImpl(implRelativePath).pipe(\n      Effect.map((specRelativePath) => ({\n        implRelativePath,\n        specRelativePath,\n      })),\n    ),\n  );\n\n  return yield* Bundler.withBatch(\n    pairs.flatMap(({ implRelativePath, specRelativePath }) => [\n      path.resolve(confectDirectory, implRelativePath),\n      path.resolve(confectDirectory, specRelativePath),\n    ]),\n    Effect.gen(function* () {\n      const leaves = yield* Effect.forEach(\n        pairs,\n        Effect.fnUntraced(function* ({ implRelativePath, specRelativePath }) {\n          if (\n            !(yield* fs.exists(path.join(confectDirectory, specRelativePath)))\n          ) {\n            return yield* new MissingSpecFileError({\n              implPath: implRelativePath,\n              expectedSpecPath: specRelativePath,\n            });\n          }\n          if (\n            !(yield* fs.exists(path.join(confectDirectory, implRelativePath)))\n          ) {\n            return yield* new MissingImplFileError({\n              specPath: specRelativePath,\n              expectedImplPath: implRelativePath,\n            });\n          }\n          const leaf = yield* loadSpec(yield* toLeafModule(specRelativePath));\n          return leaf;\n        }),\n        { concurrency: VALIDATION_CONCURRENCY },\n      );\n      return yield* use(leaves);\n    }),\n  );\n});\n\nexport const validateImplFiles = Effect.fn(\"LeafModule.validateImplFiles\")(\n  (relativePaths: ReadonlyArray<ImplModulePath>) =>\n    withImplFiles(relativePaths, validateAllImpls),\n);\n\nexport const validateAllImpls = Effect.fnUntraced(function* (\n  leaves: ReadonlyArray<LoadedLeafModule>,\n) {\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n  const implementationPaths = yield* Effect.forEach(\n    leaves,\n    ({ relativePath }) =>\n      implPathForSpec(relativePath).pipe(\n        Effect.map((implPath) => path.resolve(confectDirectory, implPath)),\n      ),\n  );\n  yield* Bundler.withBatch(\n    implementationPaths,\n    Effect.forEach(leaves, validateImpl, {\n      concurrency: VALIDATION_CONCURRENCY,\n      discard: true,\n    }),\n  );\n});\n\nexport const loadAll = Effect.gen(function* () {\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n  const specFiles = yield* discoverLeafSpecFiles;\n\n  const results = yield* Bundler.withBatch(\n    specFiles.map((relativePath) =>\n      path.resolve(confectDirectory, relativePath),\n    ),\n    Effect.forEach(\n      specFiles,\n      Effect.fnUntraced(function* (specRelativePath: string) {\n        const discovered = yield* toLeafModule(specRelativePath);\n        const leaf = yield* loadSpec(discovered);\n\n        const implRelativePath = yield* implPathForSpec(specRelativePath);\n        const implAbsolutePath = path.join(confectDirectory, implRelativePath);\n        if (!(yield* fs.exists(implAbsolutePath))) {\n          return yield* new MissingImplFileError({\n            specPath: specRelativePath,\n            expectedImplPath: implRelativePath,\n          });\n        }\n\n        return leaf;\n      }),\n      { concurrency: VALIDATION_CONCURRENCY },\n    ),\n  );\n\n  yield* validateOrphanImpls(specFiles);\n\n  return results;\n});\n\n/**\n * Walk leaf ancestors and fail with a {@link ParentChildNameCollisionError} when\n * a parent leaf declares a function or subgroup whose name matches a sibling\n * subdirectory spec's segment. Without this check the colliding descendant\n * would overwrite the parent's entry in the assembled `GroupSpec.groups` map at\n * runtime, surfacing as a confusing `Refs.make` error rather than a\n * codegen-time diagnostic.\n */\nconst validateOrphanImpls = Effect.fnUntraced(function* (\n  specFiles: ReadonlyArray<string>,\n) {\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n  const implFiles = yield* discoverLeafImplFiles;\n  const specPaths = HashSet.fromIterable(specFiles);\n\n  yield* Effect.forEach(\n    implFiles,\n    Effect.fnUntraced(function* (implRelativePath: string) {\n      const specRelativePath = yield* specPathForImpl(implRelativePath);\n      if (HashSet.has(specPaths, specRelativePath)) {\n        return;\n      }\n\n      const specAbsolutePath = path.join(confectDirectory, specRelativePath);\n      if (!(yield* fs.exists(specAbsolutePath))) {\n        return yield* new MissingSpecFileError({\n          implPath: implRelativePath,\n          expectedSpecPath: specRelativePath,\n        });\n      }\n    }),\n  );\n});\n"],"mappings":"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"}

package/dist/ProjectRoot.mjs

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Array from "effect/Array";
+import * as Option from "effect/Option";
+import * as Context from "effect/Context";
+import * as Ref from "effect/Ref";
+import * as Schema from "effect/Schema";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import * as Layer from "effect/Layer";
+//#region src/ProjectRoot.ts
+var ProjectRoot = class ProjectRoot extends Context.Service()("@confect/cli/ProjectRoot") {
+	static get = ProjectRoot.use((service) => service.get);
+};
+const findProjectRootFrom = Effect.fnUntraced(function* (directory) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const startDir = path.resolve(directory);
+	const root = path.parse(startDir).root;
+	const directories = Array.unfold(startDir, (dir) => dir === root ? Option.none() : Option.some([dir, path.dirname(dir)]));
+	const projectRoot = yield* Effect.findFirst(directories, (dir) => fs.exists(path.join(dir, "package.json")));
+	return yield* Effect.fromOption(projectRoot, () => new ProjectRootNotFoundError());
+});
+const findProjectRoot = findProjectRootFrom(".");
+const layer = Layer.effect(ProjectRoot, Effect.gen(function* () {
+	const projectRoot = yield* findProjectRoot;
+	const ref = yield* Ref.make(projectRoot);
+	return { get: Ref.get(ref) };
+})).pipe(Layer.provide(NodeFileSystem.layer));
+var ProjectRootNotFoundError = class extends Schema.TaggedError()("ProjectRootNotFoundError", {}) {
+	get message() {
+		return "Could not find project root (no 'package.json' found)";
+	}
+};
+//#endregion
+export { ProjectRoot, ProjectRootNotFoundError, findProjectRoot, findProjectRootFrom, layer };
+
+//# sourceMappingURL=ProjectRoot.mjs.map

package/dist/ProjectRoot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectRoot.mjs","names":[],"sources":["../src/ProjectRoot.ts"],"sourcesContent":["import * as NodeFileSystem from \"@effect/platform-node/NodeFileSystem\";\nimport * as Array from \"effect/Array\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport * as Path from \"effect/Path\";\nimport * as Ref from \"effect/Ref\";\nimport * as Schema from \"effect/Schema\";\n\nexport class ProjectRoot extends Context.Service<\n  ProjectRoot,\n  { readonly get: Effect.Effect<string> }\n>()(\"@confect/cli/ProjectRoot\") {\n  static readonly get = ProjectRoot.use((service) => service.get);\n}\n\nexport const findProjectRootFrom = Effect.fnUntraced(function* (\n  directory: string,\n) {\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n\n  const startDir = path.resolve(directory);\n  const root = path.parse(startDir).root;\n\n  const directories = Array.unfold(startDir, (dir) =>\n    dir === root\n      ? Option.none()\n      : Option.some([dir, path.dirname(dir)] as const),\n  );\n\n  const projectRoot = yield* Effect.findFirst(directories, (dir) =>\n    fs.exists(path.join(dir, \"package.json\")),\n  );\n\n  return yield* Effect.fromOption(\n    projectRoot,\n    () => new ProjectRootNotFoundError(),\n  );\n});\n\nexport const findProjectRoot = findProjectRootFrom(\".\");\n\nexport const layer = Layer.effect(\n  ProjectRoot,\n  Effect.gen(function* () {\n    const projectRoot = yield* findProjectRoot;\n\n    const ref = yield* Ref.make<string>(projectRoot);\n\n    return { get: Ref.get(ref) } as const;\n  }),\n).pipe(Layer.provide(NodeFileSystem.layer));\n\nexport class ProjectRootNotFoundError extends Schema.TaggedError<ProjectRootNotFoundError>()(\n  \"ProjectRootNotFoundError\",\n  {},\n) {\n  override get message(): string {\n    return \"Could not find project root (no 'package.json' found)\";\n  }\n}\n"],"mappings":";;;;;;;;;;;AAWA,IAAa,cAAb,MAAa,oBAAoB,QAAQ,QAGvC,CAAC,CAAC,0BAA0B,CAAC,CAAC;CAC9B,OAAgB,MAAM,YAAY,KAAK,YAAY,QAAQ,GAAG;AAChE;AAEA,MAAa,sBAAsB,OAAO,WAAW,WACnD,WACA;CACA,MAAM,KAAK,OAAO,WAAW;CAC7B,MAAM,OAAO,OAAO,KAAK;CAEzB,MAAM,WAAW,KAAK,QAAQ,SAAS;CACvC,MAAM,OAAO,KAAK,MAAM,QAAQ,CAAC,CAAC;CAElC,MAAM,cAAc,MAAM,OAAO,WAAW,QAC1C,QAAQ,OACJ,OAAO,KAAK,IACZ,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,GAAG,CAAC,CAAU,CACnD;CAEA,MAAM,cAAc,OAAO,OAAO,UAAU,cAAc,QACxD,GAAG,OAAO,KAAK,KAAK,KAAK,cAAc,CAAC,CAC1C;CAEA,OAAO,OAAO,OAAO,WACnB,mBACM,IAAI,yBAAyB,CACrC;AACF,CAAC;AAED,MAAa,kBAAkB,oBAAoB,GAAG;AAEtD,MAAa,QAAQ,MAAM,OACzB,aACA,OAAO,IAAI,aAAa;CACtB,MAAM,cAAc,OAAO;CAE3B,MAAM,MAAM,OAAO,IAAI,KAAa,WAAW;CAE/C,OAAO,EAAE,KAAK,IAAI,IAAI,GAAG,EAAE;AAC7B,CAAC,CACH,CAAC,CAAC,KAAK,MAAM,QAAQ,eAAe,KAAK,CAAC;AAE1C,IAAa,2BAAb,cAA8C,OAAO,YAAsC,CAAC,CAC1F,4BACA,CAAC,CACH,CAAC,CAAC;CACA,IAAa,UAAkB;EAC7B,OAAO;CACT;AACF"}

package/dist/RelativeModulePath.mjs

@@ -0,0 +1,13 @@
+import * as Array from "effect/Array";
+import * as Schema from "effect/Schema";
+import * as String from "effect/String";
+//#region src/RelativeModulePath.ts
+const RelativeModulePath = Schema.String.check(Schema.makeFilter((value) => !/^[A-Za-z]:/.test(value) && !String.includes("\0")(value) && Array.every(String.split(value, /[/\\]/), (segment) => String.isNonEmpty(segment) && segment !== "." && segment !== ".."))).pipe(Schema.brand("@confect/cli/RelativeModulePath"));
+const withSuffix = (suffix) => RelativeModulePath.check(Schema.makeFilter((value) => {
+	const filename = Array.lastNonEmpty(String.split(value, /[/\\]/));
+	return String.endsWith(suffix)(filename) && filename.length > suffix.length;
+}));
+//#endregion
+export { RelativeModulePath, withSuffix };
+
+//# sourceMappingURL=RelativeModulePath.mjs.map

package/dist/RelativeModulePath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelativeModulePath.mjs","names":[],"sources":["../src/RelativeModulePath.ts"],"sourcesContent":["import * as Array from \"effect/Array\";\nimport * as Schema from \"effect/Schema\";\nimport * as String from \"effect/String\";\n\nexport const RelativeModulePath = Schema.String.check(\n  Schema.makeFilter(\n    (value) =>\n      !/^[A-Za-z]:/.test(value) &&\n      !String.includes(\"\\0\")(value) &&\n      Array.every(\n        String.split(value, /[/\\\\]/),\n        (segment) =>\n          String.isNonEmpty(segment) && segment !== \".\" && segment !== \"..\",\n      ),\n  ),\n).pipe(Schema.brand(\"@confect/cli/RelativeModulePath\"));\n\nexport type RelativeModulePath = typeof RelativeModulePath.Type;\n\nexport const withSuffix = (suffix: string) =>\n  RelativeModulePath.check(\n    Schema.makeFilter((value) => {\n      const filename = Array.lastNonEmpty(String.split(value, /[/\\\\]/));\n      return (\n        String.endsWith(suffix)(filename) && filename.length > suffix.length\n      );\n    }),\n  );\n"],"mappings":";;;;AAIA,MAAa,qBAAqB,OAAO,OAAO,MAC9C,OAAO,YACJ,UACC,CAAC,aAAa,KAAK,KAAK,KACxB,CAAC,OAAO,SAAS,IAAI,CAAC,CAAC,KAAK,KAC5B,MAAM,MACJ,OAAO,MAAM,OAAO,OAAO,IAC1B,YACC,OAAO,WAAW,OAAO,KAAK,YAAY,OAAO,YAAY,IACjE,CACJ,CACF,CAAC,CAAC,KAAK,OAAO,MAAM,iCAAiC,CAAC;AAItD,MAAa,cAAc,WACzB,mBAAmB,MACjB,OAAO,YAAY,UAAU;CAC3B,MAAM,WAAW,MAAM,aAAa,OAAO,MAAM,OAAO,OAAO,CAAC;CAChE,OACE,OAAO,SAAS,MAAM,CAAC,CAAC,QAAQ,KAAK,SAAS,SAAS,OAAO;AAElE,CAAC,CACH"}

package/dist/Remove.mjs

@@ -0,0 +1,24 @@
+import { RemoveBusyError } from "./CodegenError.mjs";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Schedule from "effect/Schedule";
+//#region src/Remove.ts
+const MAX_ATTEMPTS = 4;
+const remove = Effect.fn("Remove.remove")(function* (path) {
+	yield* (yield* FileSystem.FileSystem).remove(path, {
+		recursive: true,
+		force: true
+	}).pipe(Effect.retry({
+		while: (error) => error.reason._tag === "Busy",
+		times: 3,
+		schedule: Schedule.exponential("25 millis")
+	}), Effect.mapError((error) => error.reason._tag === "Busy" ? new RemoveBusyError({
+		path,
+		attempts: MAX_ATTEMPTS,
+		cause: error
+	}) : error));
+});
+//#endregion
+export { remove };
+
+//# sourceMappingURL=Remove.mjs.map

package/dist/Remove.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Remove.mjs","names":[],"sources":["../src/Remove.ts"],"sourcesContent":["import * as Effect from \"effect/Effect\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as Schedule from \"effect/Schedule\";\nimport { RemoveBusyError } from \"./CodegenError.js\";\n\nconst MAX_ATTEMPTS = 4;\n\nexport const remove = Effect.fn(\"Remove.remove\")(function* (path: string) {\n  const fs = yield* FileSystem.FileSystem;\n  yield* fs.remove(path, { recursive: true, force: true }).pipe(\n    Effect.retry({\n      while: (error) => error.reason._tag === \"Busy\",\n      times: MAX_ATTEMPTS - 1,\n      schedule: Schedule.exponential(\"25 millis\"),\n    }),\n    Effect.mapError((error) =>\n      error.reason._tag === \"Busy\"\n        ? new RemoveBusyError({ path, attempts: MAX_ATTEMPTS, cause: error })\n        : error,\n    ),\n  );\n});\n"],"mappings":";;;;;AAKA,MAAM,eAAe;AAErB,MAAa,SAAS,OAAO,GAAG,eAAe,CAAC,CAAC,WAAW,MAAc;CAExE,QAAO,OADW,WAAW,WAAA,CACnB,OAAO,MAAM;EAAE,WAAW;EAAM,OAAO;CAAK,CAAC,CAAC,CAAC,KACvD,OAAO,MAAM;EACX,QAAQ,UAAU,MAAM,OAAO,SAAS;EACxC,OAAO;EACP,UAAU,SAAS,YAAY,WAAW;CAC5C,CAAC,GACD,OAAO,UAAU,UACf,MAAM,OAAO,SAAS,SAClB,IAAI,gBAAgB;EAAE;EAAM,UAAU;EAAc,OAAO;CAAM,CAAC,IAClE,KACN,CACF;AACF,CAAC"}

package/dist/RestoreWatcher.mjs

@@ -0,0 +1,31 @@
+import * as Effect from "effect/Effect";
+import * as Cause from "effect/Cause";
+import * as Scope from "effect/Scope";
+import * as Deferred from "effect/Deferred";
+import * as Exit from "effect/Exit";
+//#region src/RestoreWatcher.ts
+/**
+* Run a directory watch that a restore can pause: Windows refuses to remove a
+* directory while a recursive watch holds it open.
+*/
+const make = Effect.fnUntraced(function* (watch) {
+	const parent = yield* Effect.scope;
+	const context = yield* Effect.context();
+	const failed = yield* Deferred.make();
+	const start = Effect.gen(function* () {
+		const scope = yield* Scope.fork(parent, "sequential");
+		yield* watch.pipe(Effect.provide(context), Effect.onExit((exit) => Exit.isFailure(exit) && !Cause.hasInterruptsOnly(exit.cause) ? Deferred.failCause(failed, exit.cause) : Effect.void), Effect.forkIn(scope, { startImmediately: true }));
+		return scope;
+	});
+	let scope = yield* start;
+	return {
+		failure: Deferred.await(failed),
+		duringRestore: Effect.acquireRelease(Effect.suspend(() => Scope.close(scope, Exit.void)), () => start.pipe(Effect.tap((next) => Effect.sync(() => {
+			scope = next;
+		}))))
+	};
+});
+//#endregion
+export { make };
+
+//# sourceMappingURL=RestoreWatcher.mjs.map

package/dist/RestoreWatcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RestoreWatcher.mjs","names":[],"sources":["../src/RestoreWatcher.ts"],"sourcesContent":["import * as Cause from \"effect/Cause\";\nimport * as Deferred from \"effect/Deferred\";\nimport * as Effect from \"effect/Effect\";\nimport * as Exit from \"effect/Exit\";\nimport * as Scope from \"effect/Scope\";\n\n/**\n * Run a directory watch that a restore can pause: Windows refuses to remove a\n * directory while a recursive watch holds it open.\n */\n// Untraced, because restarts run in the captured context and would carry this\n// constructor's stack frame into their failures.\nexport const make = Effect.fnUntraced(function* <E, R>(\n  watch: Effect.Effect<void, E, R>,\n) {\n  const parent = yield* Effect.scope;\n  const context = yield* Effect.context<R>();\n  const failed = yield* Deferred.make<never, E>();\n  const start = Effect.gen(function* () {\n    const scope = yield* Scope.fork(parent, \"sequential\");\n    yield* watch.pipe(\n      Effect.provide(context),\n      Effect.onExit((exit) =>\n        Exit.isFailure(exit) && !Cause.hasInterruptsOnly(exit.cause)\n          ? Deferred.failCause(failed, exit.cause)\n          : Effect.void,\n      ),\n      Effect.forkIn(scope, { startImmediately: true }),\n    );\n    return scope;\n  });\n  let scope = yield* start;\n  return {\n    failure: Deferred.await(failed),\n    duringRestore: Effect.acquireRelease(\n      Effect.suspend(() => Scope.close(scope, Exit.void)),\n      () =>\n        start.pipe(\n          Effect.tap((next) =>\n            Effect.sync(() => {\n              scope = next;\n            }),\n          ),\n        ),\n    ),\n  };\n});\n"],"mappings":";;;;;;;;;;AAYA,MAAa,OAAO,OAAO,WAAW,WACpC,OACA;CACA,MAAM,SAAS,OAAO,OAAO;CAC7B,MAAM,UAAU,OAAO,OAAO,QAAW;CACzC,MAAM,SAAS,OAAO,SAAS,KAAe;CAC9C,MAAM,QAAQ,OAAO,IAAI,aAAa;EACpC,MAAM,QAAQ,OAAO,MAAM,KAAK,QAAQ,YAAY;EACpD,OAAO,MAAM,KACX,OAAO,QAAQ,OAAO,GACtB,OAAO,QAAQ,SACb,KAAK,UAAU,IAAI,KAAK,CAAC,MAAM,kBAAkB,KAAK,KAAK,IACvD,SAAS,UAAU,QAAQ,KAAK,KAAK,IACrC,OAAO,IACb,GACA,OAAO,OAAO,OAAO,EAAE,kBAAkB,KAAK,CAAC,CACjD;EACA,OAAO;CACT,CAAC;CACD,IAAI,QAAQ,OAAO;CACnB,OAAO;EACL,SAAS,SAAS,MAAM,MAAM;EAC9B,eAAe,OAAO,eACpB,OAAO,cAAc,MAAM,MAAM,OAAO,KAAK,IAAI,CAAC,SAEhD,MAAM,KACJ,OAAO,KAAK,SACV,OAAO,WAAW;GAChB,QAAQ;EACV,CAAC,CACH,CACF,CACJ;CACF;AACF,CAAC"}