@confect/cli 8.0.0 → 9.0.0-next.0

package/dist/LeafModule.mjs

@@ -0,0 +1,167 @@
+import { fromBundlerError } from "./BuildError.mjs";
+import { ImplMissingDefaultLayerError, ImplMissingFunctionsError, ImplMissingSpecImportError, ImplNotFinalizedError, SpecMissingDefaultGroupSpecError, SpecRuntimeMismatchError } from "./CodegenError.mjs";
+import { ConfectDirectory } from "./ConfectDirectory.mjs";
+import { bundle, directlyImports } from "./Bundler.mjs";
+import { removePathExtension } from "./utils.mjs";
+import { Array, Effect, Layer, Option, Ref, String } from "effect";
+import { GroupSpec, Registry } from "@confect/core";
+import { FileSystem, Path } from "@effect/platform";
+import * as GroupImpl from "@confect/server/GroupImpl";
+
+//#region src/LeafModule.ts
+const SPEC_SUFFIX = ".spec.ts";
+const IMPL_SUFFIX = ".impl.ts";
+const swapModuleSuffix = (relativePath, fromSuffix, toSuffix) => Effect.gen(function* () {
+	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 isLeafImplPath = (relativePath) => relativePath.endsWith(IMPL_SUFFIX);
+const exportNameFromModulePath = (relativePath) => Effect.gen(function* () {
+	const { name, ext } = (yield* Path.Path).parse(relativePath);
+	if (ext !== ".ts") return name;
+	return name.endsWith(".spec") ? name.slice(0, -5) : name;
+});
+const groupPathFromRelativeModulePath = (relativePath) => Effect.gen(function* () {
+	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 = (specRelativePath) => Effect.gen(function* () {
+	return `../${yield* removePathExtension(specRelativePath)}`;
+});
+const specPathForImpl = (implRelativePath) => swapModuleSuffix(implRelativePath, IMPL_SUFFIX, SPEC_SUFFIX);
+const implPathForSpec = (specRelativePath) => swapModuleSuffix(specRelativePath, SPEC_SUFFIX, IMPL_SUFFIX);
+const isNodeLeafModule = (relativePath) => relativePath.startsWith("node/") || relativePath.startsWith("node\\");
+const toNodeRegistryLeaf = (leaf) => ({
+	...leaf,
+	pathSegments: [leaf.exportName],
+	groupPathDot: leaf.exportName
+});
+const registeredFunctionsRelativePath = (leaf) => Effect.gen(function* () {
+	return (yield* Path.Path).join("registeredFunctions", ...leaf.pathSegments.slice(leaf.runtime === "Node" ? 1 : 0)) + ".ts";
+});
+const discoverLeafSpecFiles = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const excludedDirs = new Set(["_generated", "tables"]);
+	const excludedFiles = new Set(["nodeSpec.ts", "spec.ts"]);
+	const allPaths = yield* fs.readDirectory(confectDirectory, { recursive: true });
+	return Array.filter(allPaths, (relativePath) => {
+		if (!isLeafSpecPath(relativePath)) return false;
+		if (excludedFiles.has(relativePath)) return false;
+		const segments = String.split(relativePath, path.sep);
+		return !Array.some(segments, (segment) => excludedDirs.has(segment));
+	});
+});
+const discoverLeafImplFiles = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const excludedDirs = new Set(["_generated", "tables"]);
+	const allPaths = yield* fs.readDirectory(confectDirectory, { recursive: true });
+	return Array.filter(allPaths, (relativePath) => {
+		if (!isLeafImplPath(relativePath)) return false;
+		const segments = String.split(relativePath, path.sep);
+		return !Array.some(segments, (segment) => excludedDirs.has(segment));
+	});
+});
+const toLeafModule = (specRelativePath) => Effect.gen(function* () {
+	const exportName = yield* exportNameFromModulePath(specRelativePath);
+	const { pathSegments, groupPathDot } = yield* groupPathFromRelativeModulePath(specRelativePath);
+	const specImportPath = yield* specImportPathFromGenerated(specRelativePath);
+	const runtime = isNodeLeafModule(specRelativePath) ? "Node" : "Convex";
+	return {
+		relativePath: specRelativePath,
+		pathSegments,
+		groupPathDot,
+		exportName,
+		runtime,
+		registryGroupPathDot: runtime === "Node" ? exportName : groupPathDot,
+		specImportPath
+	};
+});
+const absoluteModulePath = (relativePath) => Effect.gen(function* () {
+	const confectDirectory = yield* ConfectDirectory.get;
+	return (yield* Path.Path).resolve(confectDirectory, relativePath);
+});
+/**
+* Validate that the leaf's spec file default-exports a `GroupSpec` whose
+* runtime matches the leaf's location (`Convex` for files outside
+* `confect/node/`, `Node` for files inside it).
+*/
+const validateSpec = (leaf) => Effect.gen(function* () {
+	const absolutePath = yield* absoluteModulePath(leaf.relativePath);
+	const { module } = yield* bundle(absolutePath).pipe(Effect.mapError((error) => fromBundlerError(leaf.relativePath, error)));
+	const groupSpec = module.default;
+	if (!GroupSpec.isGroupSpec(groupSpec)) return yield* new SpecMissingDefaultGroupSpecError({ specPath: leaf.relativePath });
+	if (groupSpec.runtime !== leaf.runtime) return yield* new SpecRuntimeMismatchError({
+		specPath: leaf.relativePath,
+		expectedRuntime: leaf.runtime,
+		actualRuntime: groupSpec.runtime
+	});
+});
+/**
+* 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.unsafeMap.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 = (implLayer) => Effect.gen(function* () {
+	const registry = Ref.unsafeMake({});
+	return yield* Layer.build(implLayer).pipe(Effect.provideService(Registry.Registry, registry));
+}).pipe(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 = (leaf) => Effect.gen(function* () {
+	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 { module: specModule } = yield* bundle(specAbsolutePath).pipe(Effect.mapError((error) => fromBundlerError(leaf.relativePath, error)));
+	const groupSpec = specModule.default;
+	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 = new Set(finalizedGroupImpl.registeredFunctionNames);
+	const missing = expectedFunctionNames.filter((name) => !registeredSet.has(name));
+	if (missing.length > 0) return yield* new ImplMissingFunctionsError({
+		implPath: implRelativePath,
+		groupPath: finalizedGroupImpl.groupPath,
+		missingFunctionNames: missing
+	});
+});
+
+//#endregion
+export { discoverLeafImplFiles, discoverLeafSpecFiles, implPathForSpec, isLeafImplPath, isLeafSpecPath, registeredFunctionsRelativePath, specPathForImpl, toLeafModule, toNodeRegistryLeaf, validateImpl, validateSpec };
+//# sourceMappingURL=LeafModule.mjs.map

package/dist/LeafModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeafModule.mjs","names":["Bundler.bundle","Bundler.directlyImports"],"sources":["../src/LeafModule.ts"],"sourcesContent":["import { GroupSpec, Registry } from \"@confect/core\";\nimport * as GroupImpl from \"@confect/server/GroupImpl\";\nimport { FileSystem, Path } from \"@effect/platform\";\nimport type { Context } from \"effect\";\nimport { Array, Effect, Layer, Option, Ref, String } from \"effect\";\nimport { fromBundlerError } from \"./BuildError\";\nimport * as Bundler from \"./Bundler\";\nimport {\n  ImplMissingDefaultLayerError,\n  ImplMissingFunctionsError,\n  ImplMissingSpecImportError,\n  ImplNotFinalizedError,\n  SpecMissingDefaultGroupSpecError,\n  SpecRuntimeMismatchError,\n} from \"./CodegenError\";\nimport { ConfectDirectory } from \"./ConfectDirectory\";\nimport { removePathExtension } from \"./utils\";\n\nexport interface LeafModule {\n  readonly relativePath: string;\n  readonly pathSegments: readonly [string, ...string[]];\n  readonly groupPathDot: string;\n  readonly registryGroupPathDot: string;\n  readonly exportName: string;\n  readonly runtime: \"Convex\" | \"Node\";\n  readonly specImportPath: string;\n}\n\nexport const SPEC_SUFFIX = \".spec.ts\";\nexport const IMPL_SUFFIX = \".impl.ts\";\n\nconst swapModuleSuffix = (\n  relativePath: string,\n  fromSuffix: string,\n  toSuffix: string,\n) =>\n  Effect.gen(function* () {\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 isLeafImplPath = (relativePath: string) =>\n  relativePath.endsWith(IMPL_SUFFIX);\n\nexport const exportNameFromModulePath = (relativePath: string) =>\n  Effect.gen(function* () {\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 = (relativePath: string) =>\n  Effect.gen(function* () {\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 [\n      string,\n      ...string[],\n    ];\n    return {\n      pathSegments,\n      groupPathDot: Array.join(pathSegments, \".\"),\n    };\n  });\n\nexport const specImportPathFromGenerated = (specRelativePath: string) =>\n  Effect.gen(function* () {\n    const withoutExt = yield* removePathExtension(specRelativePath);\n    return `../${withoutExt}`;\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 isNodeLeafModule = (relativePath: string) =>\n  relativePath.startsWith(\"node/\") || relativePath.startsWith(\"node\\\\\");\n\nexport const toNodeRegistryLeaf = (leaf: LeafModule): LeafModule => ({\n  ...leaf,\n  pathSegments: [leaf.exportName],\n  groupPathDot: leaf.exportName,\n});\n\nexport const registeredFunctionsRelativePath = (leaf: LeafModule) =>\n  Effect.gen(function* () {\n    const path = yield* Path.Path;\n    return (\n      path.join(\n        \"registeredFunctions\",\n        ...leaf.pathSegments.slice(leaf.runtime === \"Node\" ? 1 : 0),\n      ) + \".ts\"\n    );\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 = new Set([\"_generated\", \"tables\"]);\n  const excludedFiles = new Set([\"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 (excludedFiles.has(relativePath)) {\n      return false;\n    }\n\n    const segments = String.split(relativePath, path.sep);\n    return !Array.some(segments, (segment) => excludedDirs.has(segment));\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 = new Set([\"_generated\", \"tables\"]);\n\n  const allPaths = yield* fs.readDirectory(confectDirectory, {\n    recursive: true,\n  });\n\n  return Array.filter(allPaths, (relativePath) => {\n    if (!isLeafImplPath(relativePath)) {\n      return false;\n    }\n\n    const segments = String.split(relativePath, path.sep);\n    return !Array.some(segments, (segment) => excludedDirs.has(segment));\n  });\n});\n\nexport const toLeafModule = (specRelativePath: string) =>\n  Effect.gen(function* () {\n    const exportName = yield* exportNameFromModulePath(specRelativePath);\n    const { pathSegments, groupPathDot } =\n      yield* groupPathFromRelativeModulePath(specRelativePath);\n    const specImportPath = yield* specImportPathFromGenerated(specRelativePath);\n    const runtime = isNodeLeafModule(specRelativePath) ? \"Node\" : \"Convex\";\n\n    return {\n      relativePath: specRelativePath,\n      pathSegments,\n      groupPathDot,\n      exportName,\n      runtime,\n      registryGroupPathDot: runtime === \"Node\" ? exportName : groupPathDot,\n      specImportPath,\n    } satisfies LeafModule;\n  });\n\nconst absoluteModulePath = (relativePath: string) =>\n  Effect.gen(function* () {\n    const confectDirectory = yield* ConfectDirectory.get;\n    const path = yield* Path.Path;\n    return path.resolve(confectDirectory, relativePath);\n  });\n\n/**\n * Validate that the leaf's spec file default-exports a `GroupSpec` whose\n * runtime matches the leaf's location (`Convex` for files outside\n * `confect/node/`, `Node` for files inside it).\n */\nexport const validateSpec = (leaf: LeafModule) =>\n  Effect.gen(function* () {\n    const absolutePath = yield* absoluteModulePath(leaf.relativePath);\n    const { module } = yield* Bundler.bundle(absolutePath).pipe(\n      Effect.mapError((error) => fromBundlerError(leaf.relativePath, error)),\n    );\n\n    const groupSpec = module.default;\n\n    if (!GroupSpec.isGroupSpec(groupSpec)) {\n      return yield* new SpecMissingDefaultGroupSpecError({\n        specPath: leaf.relativePath,\n      });\n    }\n\n    if (groupSpec.runtime !== leaf.runtime) {\n      return yield* new SpecRuntimeMismatchError({\n        specPath: leaf.relativePath,\n        expectedRuntime: leaf.runtime,\n        actualRuntime: groupSpec.runtime,\n      });\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.unsafeMap.values(), GroupImpl.isFinalizedGroupImpl);\n\n/**\n * Build the impl layer with a fresh `Registry` so each validation is\n * isolated from prior validations' `FunctionImpl.make` writes. The CLI no\n * longer reads the registry directly — `GroupImpl.finalize` snapshots the\n * registered function names onto the produced `Finalized` `GroupImpl`\n * service value — but a fresh `Ref` is still required because the default\n * `Context.Reference` is cached globally and would otherwise accumulate\n * items across impls.\n */\nconst buildImplLayer = (implLayer: Layer.Layer<unknown>) =>\n  Effect.gen(function* () {\n    const registry = Ref.unsafeMake<Registry.RegistryItems>({});\n    return yield* Layer.build(\n      implLayer as Layer.Layer<unknown, never, never>,\n    ).pipe(Effect.provideService(Registry.Registry, registry));\n  }).pipe(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 = (leaf: LeafModule) =>\n  Effect.gen(function* () {\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 { module: specModule } = yield* Bundler.bundle(specAbsolutePath).pipe(\n      Effect.mapError((error) => fromBundlerError(leaf.relativePath, error)),\n    );\n    const groupSpec = specModule.default as GroupSpec.AnyWithProps;\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 = new Set(finalizedGroupImpl.registeredFunctionNames);\n    const missing = expectedFunctionNames.filter(\n      (name) => !registeredSet.has(name),\n    );\n\n    if (missing.length > 0) {\n      return yield* new ImplMissingFunctionsError({\n        implPath: implRelativePath,\n        groupPath: finalizedGroupImpl.groupPath,\n        missingFunctionNames: missing,\n      });\n    }\n  });\n"],"mappings":"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"}

package/dist/SpecAssemblyNode.mjs

@@ -0,0 +1,33 @@
+import { Array, Option, Order, Record, pipe } from "effect";
+
+//#region src/SpecAssemblyNode.ts
+const importBindingFromLeaf = (leaf) => ({
+	importPath: leaf.specImportPath,
+	exportName: leaf.exportName
+});
+const assemblyNodesAtDepth = (leaves, depth) => pipe(Array.groupBy(leaves, (leaf) => leaf.pathSegments[depth]), Record.toEntries, Array.sortBy(Order.mapInput(Order.string, ([segment]) => segment)), Array.map(([segment, groupLeaves]) => {
+	const terminal = Array.findFirst(groupLeaves, (leaf) => leaf.pathSegments.length === depth + 1);
+	const descendants = Array.filter(groupLeaves, (leaf) => leaf.pathSegments.length > depth + 1);
+	return {
+		segment,
+		importBinding: Option.map(terminal, importBindingFromLeaf),
+		children: assemblyNodesAtDepth(descendants, depth + 1)
+	};
+}));
+const assemblyNodesFromLeaves = (leaves) => assemblyNodesAtDepth(leaves, 0);
+const partitionByRuntime = (leaves) => {
+	const [node, convex] = Array.partition(leaves, (leaf) => leaf.runtime === "Convex");
+	return {
+		convex,
+		node
+	};
+};
+const importBindingsForNode = (node) => pipe(node.children, Array.flatMap(importBindingsForNode), (childBindings) => Option.match(node.importBinding, {
+	onNone: () => childBindings,
+	onSome: (binding) => Array.prepend(childBindings, binding)
+}));
+const collectImportBindings = (nodes) => pipe(Array.flatMap(nodes, importBindingsForNode), (bindings) => Record.fromIterableBy(bindings, (binding) => binding.exportName), Record.toEntries, Array.sortBy(Order.mapInput(Order.string, ([exportName]) => exportName)), Array.map(([, binding]) => binding));
+
+//#endregion
+export { assemblyNodesFromLeaves, collectImportBindings, partitionByRuntime };
+//# sourceMappingURL=SpecAssemblyNode.mjs.map

package/dist/SpecAssemblyNode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecAssemblyNode.mjs","names":[],"sources":["../src/SpecAssemblyNode.ts"],"sourcesContent":["import type { LeafModule } from \"./LeafModule\";\nimport { Array, Option, Order, pipe, Record } from \"effect\";\n\nexport interface SpecImportBinding {\n  readonly importPath: string;\n  readonly exportName: string;\n}\n\nexport interface SpecAssemblyNode {\n  readonly segment: string;\n  readonly importBinding: Option.Option<SpecImportBinding>;\n  readonly children: ReadonlyArray<SpecAssemblyNode>;\n}\n\nconst importBindingFromLeaf = (leaf: LeafModule): SpecImportBinding => ({\n  importPath: leaf.specImportPath,\n  exportName: leaf.exportName,\n});\n\nconst assemblyNodesAtDepth = (\n  leaves: ReadonlyArray<LeafModule>,\n  depth: number,\n): ReadonlyArray<SpecAssemblyNode> =>\n  pipe(\n    Array.groupBy(leaves, (leaf) => leaf.pathSegments[depth]!),\n    Record.toEntries,\n    Array.sortBy(Order.mapInput(Order.string, ([segment]) => segment)),\n    Array.map(([segment, groupLeaves]) => {\n      const terminal = Array.findFirst(\n        groupLeaves,\n        (leaf) => leaf.pathSegments.length === depth + 1,\n      );\n      const descendants = Array.filter(\n        groupLeaves,\n        (leaf) => leaf.pathSegments.length > depth + 1,\n      );\n      return {\n        segment,\n        importBinding: Option.map(terminal, importBindingFromLeaf),\n        children: assemblyNodesAtDepth(descendants, depth + 1),\n      };\n    }),\n  );\n\nexport const assemblyNodesFromLeaves = (\n  leaves: ReadonlyArray<LeafModule>,\n): ReadonlyArray<SpecAssemblyNode> => assemblyNodesAtDepth(leaves, 0);\n\nexport const partitionByRuntime = (\n  leaves: ReadonlyArray<LeafModule>,\n): {\n  readonly convex: ReadonlyArray<LeafModule>;\n  readonly node: ReadonlyArray<LeafModule>;\n} => {\n  const [node, convex] = Array.partition(\n    leaves,\n    (leaf) => leaf.runtime === \"Convex\",\n  );\n  return { convex, node };\n};\n\nconst importBindingsForNode = (\n  node: SpecAssemblyNode,\n): ReadonlyArray<SpecImportBinding> =>\n  pipe(node.children, Array.flatMap(importBindingsForNode), (childBindings) =>\n    Option.match(node.importBinding, {\n      onNone: () => childBindings,\n      onSome: (binding) => Array.prepend(childBindings, binding),\n    }),\n  );\n\nexport const collectImportBindings = (\n  nodes: ReadonlyArray<SpecAssemblyNode>,\n): ReadonlyArray<SpecImportBinding> =>\n  pipe(\n    Array.flatMap(nodes, importBindingsForNode),\n    (bindings) =>\n      Record.fromIterableBy(bindings, (binding) => binding.exportName),\n    Record.toEntries,\n    Array.sortBy(Order.mapInput(Order.string, ([exportName]) => exportName)),\n    Array.map(([, binding]) => binding),\n  );\n"],"mappings":";;;AAcA,MAAM,yBAAyB,UAAyC;CACtE,YAAY,KAAK;CACjB,YAAY,KAAK;CAClB;AAED,MAAM,wBACJ,QACA,UAEA,KACE,MAAM,QAAQ,SAAS,SAAS,KAAK,aAAa,OAAQ,EAC1D,OAAO,WACP,MAAM,OAAO,MAAM,SAAS,MAAM,SAAS,CAAC,aAAa,QAAQ,CAAC,EAClE,MAAM,KAAK,CAAC,SAAS,iBAAiB;CACpC,MAAM,WAAW,MAAM,UACrB,cACC,SAAS,KAAK,aAAa,WAAW,QAAQ,EAChD;CACD,MAAM,cAAc,MAAM,OACxB,cACC,SAAS,KAAK,aAAa,SAAS,QAAQ,EAC9C;AACD,QAAO;EACL;EACA,eAAe,OAAO,IAAI,UAAU,sBAAsB;EAC1D,UAAU,qBAAqB,aAAa,QAAQ,EAAE;EACvD;EACD,CACH;AAEH,MAAa,2BACX,WACoC,qBAAqB,QAAQ,EAAE;AAErE,MAAa,sBACX,WAIG;CACH,MAAM,CAAC,MAAM,UAAU,MAAM,UAC3B,SACC,SAAS,KAAK,YAAY,SAC5B;AACD,QAAO;EAAE;EAAQ;EAAM;;AAGzB,MAAM,yBACJ,SAEA,KAAK,KAAK,UAAU,MAAM,QAAQ,sBAAsB,GAAG,kBACzD,OAAO,MAAM,KAAK,eAAe;CAC/B,cAAc;CACd,SAAS,YAAY,MAAM,QAAQ,eAAe,QAAQ;CAC3D,CAAC,CACH;AAEH,MAAa,yBACX,UAEA,KACE,MAAM,QAAQ,OAAO,sBAAsB,GAC1C,aACC,OAAO,eAAe,WAAW,YAAY,QAAQ,WAAW,EAClE,OAAO,WACP,MAAM,OAAO,MAAM,SAAS,MAAM,SAAS,CAAC,gBAAgB,WAAW,CAAC,EACxE,MAAM,KAAK,GAAG,aAAa,QAAQ,CACpC"}

package/dist/confect/codegen.mjs

@@ -1,40 +1,59 @@
 import { logFileAdded, logFileModified, logFileRemoved, logPending, logSuccess } from "../log.mjs";
+import { fromBundlerError } from "../BuildError.mjs";
+import { MissingImplFileError, MissingSchemaFileError, MissingSpecFileError, SchemaInvalidDefaultExportError, tapAndLog } from "../CodegenError.mjs";
 import { ConvexDirectory } from "../ConvexDirectory.mjs";
 import { ConfectDirectory } from "../ConfectDirectory.mjs";
-import { api, nodeApi, nodeRegisteredFunctions, refs, registeredFunctions, schema, services } from "../templates.mjs";
-import { bundleAndImport, generateAuthConfig, generateCrons, generateFunctions, generateHttp, removePathExtension, writeFileStringAndLog } from "../utils.mjs";
-import { Effect, Match, Option } from "effect";
+import { FunctionPaths, make } from "../FunctionPaths.mjs";
+import { bundle } from "../Bundler.mjs";
+import { assemblyNodesFromLeaves, partitionByRuntime } from "../SpecAssemblyNode.mjs";
+import { api, assembledSpec, nodeApi, refs, registeredFunctionsForGroup, schema, services } from "../templates.mjs";
+import { WriteTracker, generateAuthConfig, generateCrons, generateFunctions, generateHttp, removePathExtension, removePathIfExists, toModuleImportPath, touchConvexSchema, writeFileStringAndLog } from "../utils.mjs";
+import { discoverLeafImplFiles, discoverLeafSpecFiles, implPathForSpec, registeredFunctionsRelativePath, specPathForImpl, toLeafModule, toNodeRegistryLeaf, validateImpl, validateSpec } from "../LeafModule.mjs";
+import { Array, Effect, Either, HashSet, Match, Option, Ref } from "effect";
 import { Command } from "@effect/cli";
-import { DatabaseSchema, Spec } from "@confect/core";
+import { Spec } from "@confect/core";
+import * as DatabaseSchema from "@confect/server/DatabaseSchema";
 import { FileSystem, Path } from "@effect/platform";
 
 //#region src/confect/codegen.ts
-const getNodeSpecPath = Effect.gen(function* () {
-	const path = yield* Path.Path;
-	const confectDirectory = yield* ConfectDirectory.get;
-	return path.join(confectDirectory, "nodeSpec.ts");
-});
-const loadNodeSpec = Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const nodeSpecPath = yield* getNodeSpecPath;
-	if (!(yield* fs.exists(nodeSpecPath))) return Option.none();
-	const nodeSpec = (yield* bundleAndImport(nodeSpecPath)).default;
-	if (!Spec.isNodeSpec(nodeSpec)) return yield* Effect.die("nodeSpec.ts does not export a valid Node Spec");
-	return Option.some(nodeSpec);
-});
+const GENERATED_SPEC_PATH = "_generated/spec.ts";
+const GENERATED_NODE_SPEC_PATH = "_generated/nodeSpec.ts";
+const LEGACY_PATHS = [
+	"spec.ts",
+	"nodeSpec.ts",
+	"impl.ts",
+	"nodeImpl.ts",
+	"notesAndRandom.impl.ts",
+	"groups.impl.ts",
+	"_generated/registeredFunctions.ts",
+	"_generated/nodeRegisteredFunctions.ts",
+	"_generated/impl.ts",
+	"_generated/nodeImpl.ts"
+];
 const codegen = Command.make("codegen", {}, () => Effect.gen(function* () {
 	yield* logPending("Performing initial sync…");
-	yield* codegenHandler;
-	yield* logSuccess("Generated files are up-to-date");
-})).pipe(Command.withDescription("Generate `confect/_generated` files and the contents of the `convex` directory (except `tsconfig.json`)"));
+	yield* codegenHandler.pipe(Effect.asVoid, Effect.tap(() => logSuccess("Generated files are up-to-date")), tapAndLog);
+})).pipe(Command.withDescription("Generate `confect/_generated` files and the contents of the `convex` directory (except `convex.config.ts` and `tsconfig.json`)"));
 const codegenHandler = Effect.gen(function* () {
+	const tracker = yield* Ref.make(false);
+	return {
+		functionPaths: yield* runCodegen.pipe(Effect.provideService(WriteTracker, tracker)),
+		anyWritesHappened: yield* Ref.get(tracker)
+	};
+});
+const runCodegen = Effect.gen(function* () {
 	yield* generateConfectGeneratedDirectory;
+	yield* validateSchema;
+	const leaves = yield* loadAndValidateLeafModules;
+	yield* removeLegacyFiles;
+	yield* generateAssembledSpecs(leaves);
+	yield* validateImplModules(leaves);
+	yield* generateGroupRegisteredFunctions(leaves);
+	yield* removeObsoleteRegisteredFunctions(leaves);
 	yield* Effect.all([
 		generateApi,
 		generateRefs,
-		generateRegisteredFunctions,
 		generateNodeApi,
-		generateNodeRegisteredFunctions,
 		generateServices
 	], { concurrency: "unbounded" });
 	const [functionPaths] = yield* Effect.all([
@@ -44,6 +63,7 @@ const codegenHandler = Effect.gen(function* () {
 		logGenerated(generateCrons),
 		logGenerated(generateAuthConfig)
 	], { concurrency: "unbounded" });
+	yield* touchConvexSchema;
 	return functionPaths;
 });
 const generateConfectGeneratedDirectory = Effect.gen(function* () {
@@ -55,13 +75,169 @@ const generateConfectGeneratedDirectory = Effect.gen(function* () {
 		yield* logFileAdded(path.join(confectDirectory, "_generated") + "/");
 	}
 });
+const loadAndValidateLeafModules = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const specFiles = yield* discoverLeafSpecFiles;
+	const leaves = yield* Effect.forEach(specFiles, (specRelativePath) => Effect.gen(function* () {
+		const leaf = yield* toLeafModule(specRelativePath);
+		yield* validateSpec(leaf);
+		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;
+	}));
+	yield* validateOrphanImpls(specFiles);
+	return leaves;
+});
+const validateOrphanImpls = (specFiles) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const implFiles = yield* discoverLeafImplFiles;
+	const specPaths = new Set(specFiles);
+	yield* Effect.forEach(implFiles, (implRelativePath) => Effect.gen(function* () {
+		const specRelativePath = yield* specPathForImpl(implRelativePath);
+		if (specPaths.has(specRelativePath)) return;
+		const specAbsolutePath = path.join(confectDirectory, specRelativePath);
+		if (!(yield* fs.exists(specAbsolutePath))) return yield* new MissingSpecFileError({
+			implPath: implRelativePath,
+			expectedSpecPath: specRelativePath
+		});
+	}));
+});
+const removeLegacyFiles = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	yield* Effect.forEach(LEGACY_PATHS, (relativePath) => Effect.gen(function* () {
+		const absolutePath = path.join(confectDirectory, relativePath);
+		if (yield* fs.exists(absolutePath)) {
+			yield* removePathIfExists(absolutePath);
+			yield* logFileRemoved(absolutePath);
+		}
+	}));
+});
+const generateAssembledSpecs = (leaves) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const { convex, node } = partitionByRuntime(leaves);
+	if (convex.length > 0) {
+		const nodes = assemblyNodesFromLeaves(convex);
+		const specContents = yield* assembledSpec({
+			nodes,
+			runtime: "Convex"
+		});
+		yield* writeFileStringAndLog(path.join(confectDirectory, GENERATED_SPEC_PATH), specContents);
+	}
+	if (node.length > 0) {
+		const nodes = assemblyNodesFromLeaves(Array.map(node, toNodeRegistryLeaf));
+		const nodeSpecContents = yield* assembledSpec({
+			nodes,
+			runtime: "Node"
+		});
+		yield* writeFileStringAndLog(path.join(confectDirectory, GENERATED_NODE_SPEC_PATH), nodeSpecContents);
+	}
+});
+const validateImplModules = (leaves) => Effect.forEach(leaves, validateImpl);
+const generateGroupRegisteredFunctions = (leaves) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	yield* Effect.forEach(leaves, (leaf) => Effect.gen(function* () {
+		const registryRelativePath = yield* registeredFunctionsRelativePath(leaf);
+		const registryPath = path.join(confectDirectory, "_generated", registryRelativePath);
+		const registryDir = path.dirname(registryPath);
+		const fs = yield* FileSystem.FileSystem;
+		if (!(yield* fs.exists(registryDir))) yield* fs.makeDirectory(registryDir, { recursive: true });
+		const implRelativePath = yield* implPathForSpec(leaf.relativePath);
+		const apiFileName = leaf.runtime === "Node" ? "nodeApi.ts" : "api.ts";
+		const apiImportPath = yield* toModuleImportPath(path.relative(path.dirname(registryPath), path.join(confectDirectory, "_generated", apiFileName)));
+		const implImportPath = yield* toModuleImportPath(path.relative(path.dirname(registryPath), path.join(confectDirectory, implRelativePath)));
+		yield* writeFileStringAndLog(registryPath, yield* registeredFunctionsForGroup({
+			apiImportPath,
+			groupPathDot: leaf.registryGroupPathDot,
+			implImportPath,
+			layerExportName: leaf.exportName,
+			useNode: leaf.runtime === "Node"
+		}));
+	}));
+});
+const removeObsoleteRegisteredFunctions = (leaves) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const registryRoot = path.join(confectDirectory, "_generated", "registeredFunctions");
+	if (!(yield* fs.exists(registryRoot))) return;
+	const expected = new Set(yield* Effect.forEach(leaves, (leaf) => registeredFunctionsRelativePath(leaf)));
+	const existing = yield* fs.readDirectory(registryRoot, { recursive: true });
+	yield* Effect.forEach(existing, (relativePath) => {
+		if (path.extname(relativePath) !== ".ts") return Effect.void;
+		const normalized = path.join("registeredFunctions", relativePath);
+		if (!expected.has(normalized)) return Effect.gen(function* () {
+			const absolutePath = path.join(registryRoot, relativePath);
+			if (yield* fs.exists(absolutePath)) {
+				yield* removePathIfExists(absolutePath);
+				yield* logFileRemoved(absolutePath);
+			}
+		});
+		return Effect.void;
+	});
+});
+const getGeneratedSpecPath = Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	return path.join(confectDirectory, GENERATED_SPEC_PATH);
+});
+const getGeneratedNodeSpecPath = Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	return path.join(confectDirectory, GENERATED_NODE_SPEC_PATH);
+});
+const loadGeneratedSpec = Effect.gen(function* () {
+	const specPath = yield* getGeneratedSpecPath;
+	const { module: specModule } = yield* bundle(specPath);
+	const spec = specModule.default;
+	if (!Spec.isConvexSpec(spec)) return yield* Effect.dieMessage("_generated/spec.ts does not export a valid Convex Spec");
+	return spec;
+});
+const loadGeneratedNodeSpec = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const nodeSpecPath = yield* getGeneratedNodeSpecPath;
+	if (!(yield* fs.exists(nodeSpecPath))) return Option.none();
+	const { module: nodeSpecModule } = yield* bundle(nodeSpecPath);
+	const nodeSpec = nodeSpecModule.default;
+	if (!Spec.isNodeSpec(nodeSpec)) return yield* Effect.dieMessage("_generated/nodeSpec.ts does not export a valid Node Spec");
+	return Option.some(nodeSpec);
+});
+const emptyFunctionPaths = FunctionPaths.make(HashSet.empty());
+const loadPreviousFunctionPaths = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const specPath = yield* getGeneratedSpecPath;
+	if (!(yield* fs.exists(specPath))) return emptyFunctionPaths;
+	const specEither = yield* loadGeneratedSpec.pipe(Effect.either);
+	return yield* Either.match(specEither, {
+		onLeft: () => Effect.succeed(emptyFunctionPaths),
+		onRight: (spec) => Effect.gen(function* () {
+			const nodeSpecOption = yield* loadGeneratedNodeSpec;
+			const mergedSpec = Option.match(nodeSpecOption, {
+				onNone: () => spec,
+				onSome: (nodeSpec) => Spec.merge(spec, nodeSpec)
+			});
+			return make(mergedSpec);
+		})
+	});
+});
 const generateApi = Effect.gen(function* () {
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
 	const apiPath = path.join(confectDirectory, "_generated", "api.ts");
 	const apiDir = path.dirname(apiPath);
-	const schemaImportPath = yield* removePathExtension(path.relative(apiDir, path.join(confectDirectory, "schema.ts")));
-	const specImportPath = yield* removePathExtension(path.relative(apiDir, path.join(confectDirectory, "spec.ts")));
+	const schemaImportPath = yield* toModuleImportPath(path.relative(apiDir, path.join(confectDirectory, "schema.ts")));
+	const specImportPath = yield* toModuleImportPath(path.relative(apiDir, path.join(confectDirectory, GENERATED_SPEC_PATH)));
 	yield* writeFileStringAndLog(apiPath, yield* api({
 		schemaImportPath,
 		specImportPath
@@ -71,35 +247,40 @@ const generateNodeApi = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
-	const nodeSpecPath = yield* getNodeSpecPath;
+	const nodeSpecPath = yield* getGeneratedNodeSpecPath;
 	const nodeApiPath = path.join(confectDirectory, "_generated", "nodeApi.ts");
 	if (!(yield* fs.exists(nodeSpecPath))) {
 		if (yield* fs.exists(nodeApiPath)) {
-			yield* fs.remove(nodeApiPath);
+			yield* removePathIfExists(nodeApiPath);
 			yield* logFileRemoved(nodeApiPath);
 		}
 		return;
 	}
 	const nodeApiDir = path.dirname(nodeApiPath);
-	const schemaImportPath = yield* removePathExtension(path.relative(nodeApiDir, path.join(confectDirectory, "schema.ts")));
-	const nodeSpecImportPath = yield* removePathExtension(path.relative(nodeApiDir, nodeSpecPath));
+	const schemaImportPath = yield* toModuleImportPath(path.relative(nodeApiDir, path.join(confectDirectory, "schema.ts")));
+	const nodeSpecImportPath = yield* toModuleImportPath(path.relative(nodeApiDir, nodeSpecPath));
 	yield* writeFileStringAndLog(nodeApiPath, yield* nodeApi({
 		schemaImportPath,
 		nodeSpecImportPath
 	}));
 });
 const generateFunctionModules = Effect.gen(function* () {
+	const spec = yield* loadGeneratedSpec;
+	const nodeSpecOption = yield* loadGeneratedNodeSpec;
+	return yield* generateFunctions(Option.match(nodeSpecOption, {
+		onNone: () => spec,
+		onSome: (nodeSpec) => Spec.merge(spec, nodeSpec)
+	}));
+});
+const validateSchema = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
-	const spec = (yield* bundleAndImport(path.join(confectDirectory, "spec.ts"))).default;
-	if (!Spec.isConvexSpec(spec)) return yield* Effect.die("spec.ts does not export a valid Convex Spec");
-	const nodeImplPath = path.join(confectDirectory, "nodeImpl.ts");
-	const nodeImplExists = yield* fs.exists(nodeImplPath);
-	const nodeSpecOption = yield* loadNodeSpec;
-	return yield* generateFunctions(Option.match(nodeSpecOption, {
-		onNone: () => spec,
-		onSome: (nodeSpec) => nodeImplExists ? Spec.merge(spec, nodeSpec) : spec
+	const confectSchemaPath = path.join(confectDirectory, "schema.ts");
+	if (!(yield* fs.exists(confectSchemaPath))) return yield* new MissingSchemaFileError({ schemaPath: "schema.ts" });
+	yield* bundle(confectSchemaPath).pipe(Effect.mapError((error) => fromBundlerError("schema.ts", error)), Effect.andThen(({ module: schemaModule }) => {
+		const defaultExport = schemaModule.default;
+		return DatabaseSchema.isDatabaseSchema(defaultExport) ? Effect.succeed(defaultExport) : Effect.fail(new SchemaInvalidDefaultExportError({ schemaPath: "schema.ts" }));
 	}));
 });
 const generateSchema = Effect.gen(function* () {
@@ -107,10 +288,6 @@ const generateSchema = Effect.gen(function* () {
 	const confectDirectory = yield* ConfectDirectory.get;
 	const convexDirectory = yield* ConvexDirectory.get;
 	const confectSchemaPath = path.join(confectDirectory, "schema.ts");
-	yield* bundleAndImport(confectSchemaPath).pipe(Effect.andThen((schemaModule) => {
-		const defaultExport = schemaModule.default;
-		return DatabaseSchema.isDatabaseSchema(defaultExport) ? Effect.succeed(defaultExport) : Effect.die("Invalid schema module");
-	}));
 	const convexSchemaPath = path.join(convexDirectory, "schema.ts");
 	const importPathWithoutExt = yield* removePathExtension(path.relative(path.dirname(convexSchemaPath), confectSchemaPath));
 	yield* writeFileStringAndLog(convexSchemaPath, yield* schema({ schemaImportPath: importPathWithoutExt }));
@@ -123,33 +300,6 @@ const generateServices = Effect.gen(function* () {
 	const schemaImportPath = path.relative(path.dirname(servicesPath), path.join(confectDirectory, "schema"));
 	yield* writeFileStringAndLog(servicesPath, yield* services({ schemaImportPath }));
 });
-const generateRegisteredFunctions = Effect.gen(function* () {
-	const path = yield* Path.Path;
-	const confectDirectory = yield* ConfectDirectory.get;
-	const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
-	const registeredFunctionsPath = path.join(confectGeneratedDirectory, "registeredFunctions.ts");
-	const implImportPath = yield* removePathExtension(path.relative(path.dirname(registeredFunctionsPath), path.join(confectDirectory, "impl.ts")));
-	yield* writeFileStringAndLog(registeredFunctionsPath, yield* registeredFunctions({ implImportPath }));
-});
-const generateNodeRegisteredFunctions = Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const confectDirectory = yield* ConfectDirectory.get;
-	const nodeImplPath = path.join(confectDirectory, "nodeImpl.ts");
-	const nodeSpecPath = yield* getNodeSpecPath;
-	const nodeRegisteredFunctionsPath = path.join(confectDirectory, "_generated", "nodeRegisteredFunctions.ts");
-	const nodeImplExists = yield* fs.exists(nodeImplPath);
-	const nodeSpecExists = yield* fs.exists(nodeSpecPath);
-	if (!nodeImplExists || !nodeSpecExists) {
-		if (yield* fs.exists(nodeRegisteredFunctionsPath)) {
-			yield* fs.remove(nodeRegisteredFunctionsPath);
-			yield* logFileRemoved(nodeRegisteredFunctionsPath);
-		}
-		return;
-	}
-	const nodeImplImportPath = yield* removePathExtension(path.relative(path.dirname(nodeRegisteredFunctionsPath), nodeImplPath));
-	yield* writeFileStringAndLog(nodeRegisteredFunctionsPath, yield* nodeRegisteredFunctions({ nodeImplImportPath }));
-});
 const generateRefs = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -157,12 +307,12 @@ const generateRefs = Effect.gen(function* () {
 	const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
 	const refsPath = path.join(confectGeneratedDirectory, "refs.ts");
 	const refsDir = path.dirname(refsPath);
-	const specImportPath = yield* removePathExtension(path.relative(refsDir, path.join(confectDirectory, "spec.ts")));
-	const nodeSpecPath = yield* getNodeSpecPath;
-	const nodeSpecImportPath = (yield* fs.exists(nodeSpecPath)) ? yield* removePathExtension(path.relative(refsDir, nodeSpecPath)) : null;
+	const specImportPath = yield* toModuleImportPath(path.relative(refsDir, path.join(confectDirectory, GENERATED_SPEC_PATH)));
+	const nodeSpecPath = yield* getGeneratedNodeSpecPath;
+	const nodeSpecImportPath = (yield* fs.exists(nodeSpecPath)) ? Option.some(yield* toModuleImportPath(path.relative(refsDir, nodeSpecPath))) : Option.none();
 	yield* writeFileStringAndLog(refsPath, yield* refs({
 		specImportPath,
-		...nodeSpecImportPath === null ? {} : { nodeSpecImportPath }
+		nodeSpecImportPath
 	}));
 });
 const logGenerated = (effect) => effect.pipe(Effect.tap(Option.match({
@@ -171,5 +321,5 @@ const logGenerated = (effect) => effect.pipe(Effect.tap(Option.match({
 })));
 
 //#endregion
-export { codegen, codegenHandler, generateNodeApi, generateNodeRegisteredFunctions };
+export { codegen, codegenHandler, loadPreviousFunctionPaths };
 //# sourceMappingURL=codegen.mjs.map