@confect/cli 9.0.0-next.7 → 9.0.0-next.9

package/src/LeafModule.ts

@@ -1,8 +1,14 @@
 import { GroupSpec, Registry } from "@confect/core";
 import * as GroupImpl from "@confect/server/GroupImpl";
-import { FileSystem, Path } from "@effect/platform";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
 import type { Context } from "effect";
-import { Array, Effect, Layer, Option, Ref, String } from "effect";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import * as String from "effect/String";
 import { fromBundlerError } from "./BuildError";
 import * as Bundler from "./Bundler";
 import {
@@ -11,7 +17,6 @@ import {
   ImplMissingSpecImportError,
   ImplNotFinalizedError,
   SpecMissingDefaultGroupSpecError,
-  SpecRuntimeMismatchError,
 } from "./CodegenError";
 import { ConfectDirectory } from "./ConfectDirectory";
 import { removePathExtension } from "./utils";
@@ -20,9 +25,15 @@ export interface LeafModule {
   readonly relativePath: string;
   readonly pathSegments: readonly [string, ...string[]];
   readonly groupPathDot: string;
-  readonly registryGroupPathDot: string;
   readonly exportName: string;
-  readonly runtime: "Convex" | "Node";
+  /**
+   * The runtime declared by the group's spec — `"Node"` for
+   * `GroupSpec.makeNode()`, `"Convex"` for `GroupSpec.make()`. `None` while the
+   * runtime is unknown: discovery (`toLeafModule`) works from the file path alone,
+   * which does not determine the runtime, so this is filled in once the spec has
+   * been bundled and validated (see `validateSpec`).
+   */
+  readonly runtime: Option.Option<"Convex" | "Node">;
   readonly specImportPath: string;
 }
 
@@ -98,24 +109,10 @@ export const specPathForImpl = (implRelativePath: string) =>
 export const implPathForSpec = (specRelativePath: string) =>
   swapModuleSuffix(specRelativePath, SPEC_SUFFIX, IMPL_SUFFIX);
 
-export const isNodeLeafModule = (relativePath: string) =>
-  relativePath.startsWith("node/") || relativePath.startsWith("node\\");
-
-export const toNodeRegistryLeaf = (leaf: LeafModule): LeafModule => ({
-  ...leaf,
-  pathSegments: [leaf.exportName],
-  groupPathDot: leaf.exportName,
-});
-
 export const registeredFunctionsRelativePath = (leaf: LeafModule) =>
   Effect.gen(function* () {
     const path = yield* Path.Path;
-    return (
-      path.join(
-        "registeredFunctions",
-        ...leaf.pathSegments.slice(leaf.runtime === "Node" ? 1 : 0),
-      ) + ".ts"
-    );
+    return path.join("registeredFunctions", ...leaf.pathSegments) + ".ts";
   });
 
 export const discoverLeafSpecFiles = Effect.gen(function* () {
@@ -171,15 +168,14 @@ export const toLeafModule = (specRelativePath: string) =>
     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,
+      // Unknown until the spec is bundled; see `LeafModule.runtime`.
+      runtime: Option.none(),
       specImportPath,
     } satisfies LeafModule;
   });
@@ -192,11 +188,11 @@ const absoluteModulePath = (relativePath: string) =>
   });
 
 /**
- * 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). Returns the validated
- * `GroupSpec` so callers can avoid re-bundling for later inspection (e.g.
- * parent/child name-collision checks at codegen time).
+ * Validate that the leaf's spec file default-exports a `GroupSpec`. Returns the
+ * validated `GroupSpec` so callers can read its runtime and avoid re-bundling for
+ * later inspection (e.g. stamping `leaf.runtime` and parent/child name-collision
+ * checks at codegen time). The group's runtime (`Convex` vs `Node`) is whatever
+ * the spec declares — it is not constrained by the file's location.
  */
 export const validateSpec = (leaf: LeafModule) =>
   Effect.gen(function* () {
@@ -213,14 +209,6 @@ export const validateSpec = (leaf: LeafModule) =>
       });
     }
 
-    if (groupSpec.runtime !== leaf.runtime) {
-      return yield* new SpecRuntimeMismatchError({
-        specPath: leaf.relativePath,
-        expectedRuntime: leaf.runtime,
-        actualRuntime: groupSpec.runtime,
-      });
-    }
-
     return groupSpec;
   });
 

package/src/ProjectRoot.ts

@@ -1,6 +1,11 @@
-import { FileSystem, Path } from "@effect/platform";
-import { NodeFileSystem } from "@effect/platform-node";
-import { Array, Effect, Option, Ref, Schema } from "effect";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import * as Schema from "effect/Schema";
 
 export class ProjectRoot extends Effect.Service<ProjectRoot>()(
   "@confect/cli/ProjectRoot",

package/src/SpecAssemblyNode.ts

@@ -1,5 +1,9 @@
 import type { LeafModule } from "./LeafModule";
-import { Array, Option, Order, pipe, Record } from "effect";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as Option from "effect/Option";
+import * as Order from "effect/Order";
+import * as Record from "effect/Record";
 
 export interface SpecImportBinding {
   readonly importPath: string;
@@ -48,19 +52,6 @@ export const assemblyNodesFromLeaves = (
   leaves: ReadonlyArray<LeafModule>,
 ): ReadonlyArray<SpecAssemblyNode> => assemblyNodesAtDepth(leaves, 0);
 
-export const partitionByRuntime = (
-  leaves: ReadonlyArray<LeafModule>,
-): {
-  readonly convex: ReadonlyArray<LeafModule>;
-  readonly node: ReadonlyArray<LeafModule>;
-} => {
-  const [node, convex] = Array.partition(
-    leaves,
-    (leaf) => leaf.runtime === "Convex",
-  );
-  return { convex, node };
-};
-
 const importBindingsForNode = (
   node: SpecAssemblyNode,
 ): ReadonlyArray<SpecImportBinding> =>

package/src/TableModule.ts

@@ -1,7 +1,11 @@
 import { Identifier } from "@confect/core";
 import * as Table from "@confect/server/Table";
-import { FileSystem, Path } from "@effect/platform";
-import { Array, Effect, Order, pipe } from "effect";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Order from "effect/Order";
 import { fromBundlerError } from "./BuildError";
 import * as Bundler from "./Bundler";
 import {

package/src/cliApp.ts

@@ -1,4 +1,4 @@
-import { Command } from "@effect/cli";
+import * as Command from "@effect/cli/Command";
 import packageJson from "../package.json" with { type: "json" };
 import { confect } from "./confect";
 

package/src/confect/codegen.ts

@@ -1,7 +1,14 @@
 import { Spec, type GroupSpec } from "@confect/core";
-import { Command } from "@effect/cli";
-import { FileSystem, Path } from "@effect/platform";
-import { Array, Effect, Either, HashSet, Match, Option, Ref } from "effect";
+import * as Command from "@effect/cli/Command";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Either from "effect/Either";
+import * as HashSet from "effect/HashSet";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
 import * as Bundler from "../Bundler";
 import * as CodegenError from "../CodegenError";
 import {
@@ -20,7 +27,6 @@ import {
   registeredFunctionsRelativePath,
   specPathForImpl,
   toLeafModule,
-  toNodeRegistryLeaf,
   validateImpl,
   validateSpec,
   type LeafModule,
@@ -35,7 +41,6 @@ import {
 } from "../log";
 import {
   assemblyNodesFromLeaves,
-  partitionByRuntime,
   type SpecAssemblyNode,
 } from "../SpecAssemblyNode";
 import * as TableModule from "../TableModule";
@@ -57,9 +62,6 @@ const GENERATED_DIRNAME = "_generated";
 const GENERATED_SPEC_PATH = Effect.andThen(Path.Path, (path) =>
   path.join(GENERATED_DIRNAME, "spec.ts"),
 );
-const GENERATED_NODE_SPEC_PATH = Effect.andThen(Path.Path, (path) =>
-  path.join(GENERATED_DIRNAME, "nodeSpec.ts"),
-);
 const GENERATED_SCHEMA_PATH = Effect.andThen(Path.Path, (path) =>
   path.join(GENERATED_DIRNAME, "schema.ts"),
 );
@@ -85,6 +87,9 @@ const LEGACY_PATHS = Effect.gen(function* () {
     path.join(GENERATED_DIRNAME, "nodeRegisteredFunctions.ts"),
     path.join(GENERATED_DIRNAME, "impl.ts"),
     path.join(GENERATED_DIRNAME, "nodeImpl.ts"),
+    // `_generated/nodeSpec.ts` is not part of the generated output (all groups
+    // live in `_generated/spec.ts`); delete any copy left by an older version.
+    path.join(GENERATED_DIRNAME, "nodeSpec.ts"),
   ];
 });
 
@@ -191,8 +196,13 @@ const loadAndValidateLeafModules = Effect.gen(function* () {
 
   const results = yield* Effect.forEach(specFiles, (specRelativePath) =>
     Effect.gen(function* () {
-      const leaf = yield* toLeafModule(specRelativePath);
-      const groupSpec = yield* validateSpec(leaf);
+      const discovered = yield* toLeafModule(specRelativePath);
+      const groupSpec = yield* validateSpec(discovered);
+      // Fill in the runtime now that the spec is bundled; discovery left it `None`.
+      const leaf = {
+        ...discovered,
+        runtime: Option.some(groupSpec.runtime),
+      };
 
       const implRelativePath = yield* implPathForSpec(specRelativePath);
       const implAbsolutePath = path.join(confectDirectory, implRelativePath);
@@ -230,15 +240,11 @@ export const validateNoParentChildNameCollisions = (
   groupSpecsByRelativePath: ReadonlyMap<string, GroupSpec.AnyWithProps>,
 ) =>
   Effect.gen(function* () {
-    const { convex, node } = partitionByRuntime(leaves);
-    const convexNodes = assemblyNodesFromLeaves(convex);
-    const nodeNodes = assemblyNodesFromLeaves(
-      Array.map(node, toNodeRegistryLeaf),
-    );
-    yield* Effect.forEach(convexNodes, (n) =>
-      checkAssemblyNodeForCollisions(n, groupSpecsByRelativePath),
-    );
-    yield* Effect.forEach(nodeNodes, (n) =>
+    // Convex and Node groups share one namespace, so they assemble into a
+    // single tree. A Node group nested under a Convex parent (or vice versa) is
+    // caught here by the parent/child collision check.
+    const nodes = assemblyNodesFromLeaves(leaves);
+    yield* Effect.forEach(nodes, (n) =>
       checkAssemblyNodeForCollisions(n, groupSpecsByRelativePath),
     );
   });
@@ -377,34 +383,17 @@ const generateAssembledSpecs = (leaves: ReadonlyArray<LeafModule>) =>
     const path = yield* Path.Path;
     const confectDirectory = yield* ConfectDirectory.get;
     const generatedSpecPath = yield* GENERATED_SPEC_PATH;
-    const generatedNodeSpecPath = yield* GENERATED_NODE_SPEC_PATH;
-    const { convex, node } = partitionByRuntime(leaves);
-
-    if (convex.length > 0) {
-      const nodes = assemblyNodesFromLeaves(convex);
-      const specContents = yield* templates.assembledSpec({
-        nodes,
-        runtime: "Convex",
-      });
-      yield* writeFileStringAndLog(
-        path.join(confectDirectory, generatedSpecPath),
-        specContents,
-      );
-    }
 
-    if (node.length > 0) {
-      const nodes = assemblyNodesFromLeaves(
-        Array.map(node, toNodeRegistryLeaf),
-      );
-      const nodeSpecContents = yield* templates.assembledSpec({
-        nodes,
-        runtime: "Node",
-      });
-      yield* writeFileStringAndLog(
-        path.join(confectDirectory, generatedNodeSpecPath),
-        nodeSpecContents,
-      );
-    }
+    // A single assembled spec holds every group regardless of runtime — a Node
+    // group's `makeNode()` lives in its imported leaf spec, so the assembled
+    // file is runtime-agnostic. Always emit it (even empty) so downstream
+    // readers (`loadGeneratedSpec`, `generateRefs`) always find a spec module.
+    const nodes = assemblyNodesFromLeaves(leaves);
+    const specContents = yield* templates.assembledSpec({ nodes });
+    yield* writeFileStringAndLog(
+      path.join(confectDirectory, generatedSpecPath),
+      specContents,
+    );
   });
 
 const validateImplModules = (leaves: ReadonlyArray<LeafModule>) =>
@@ -452,12 +441,23 @@ const generateGroupRegisteredFunctions = (leaves: ReadonlyArray<LeafModule>) =>
           ),
         );
 
+        // Every leaf reaching this point came through
+        // `loadAndValidateLeafModules`, which stamps the runtime from the
+        // validated spec — so `None` here means that invariant was broken.
+        const runtime = yield* Option.match(leaf.runtime, {
+          onNone: () =>
+            Effect.dieMessage(
+              `Runtime for '${leaf.relativePath}' was not resolved before registry generation.`,
+            ),
+          onSome: Effect.succeed,
+        });
+
         const contents = yield* templates.registeredFunctionsForGroup({
           schemaImportPath,
           specImportPath,
           implImportPath,
           layerExportName: leaf.exportName,
-          useNode: leaf.runtime === "Node",
+          useNode: runtime === "Node",
         });
 
         yield* writeFileStringAndLog(registryPath, contents);
@@ -512,47 +512,20 @@ const getGeneratedSpecPath = Effect.gen(function* () {
   return path.join(confectDirectory, generatedSpecPath);
 });
 
-const getGeneratedNodeSpecPath = Effect.gen(function* () {
-  const path = yield* Path.Path;
-  const confectDirectory = yield* ConfectDirectory.get;
-  const generatedNodeSpecPath = yield* GENERATED_NODE_SPEC_PATH;
-  return path.join(confectDirectory, generatedNodeSpecPath);
-});
-
 const loadGeneratedSpec = Effect.gen(function* () {
   const specPath = yield* getGeneratedSpecPath;
   const { module: specModule } = yield* Bundler.bundle(specPath);
   const spec = specModule.default;
 
-  if (!Spec.isConvexSpec(spec)) {
+  if (!Spec.isSpec(spec)) {
     return yield* Effect.dieMessage(
-      "_generated/spec.ts does not export a valid Convex Spec",
+      "_generated/spec.ts does not export a valid 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<Spec.AnyWithPropsWithRuntime<"Node">>();
-  }
-
-  const { module: nodeSpecModule } = yield* Bundler.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.FunctionPaths.make(HashSet.empty());
 
 export const loadPreviousFunctionPaths = Effect.gen(function* () {
@@ -565,17 +538,9 @@ export const loadPreviousFunctionPaths = Effect.gen(function* () {
 
   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 FunctionPaths.make(mergedSpec);
-      }),
+  return Either.match(specEither, {
+    onLeft: () => emptyFunctionPaths,
+    onRight: (spec) => FunctionPaths.make(spec),
   });
 });
 
@@ -606,14 +571,7 @@ const removeGeneratedNodeApi = removeObsoleteGeneratedFile("nodeApi.ts");
 
 const generateFunctionModules = Effect.gen(function* () {
   const spec = yield* loadGeneratedSpec;
-  const nodeSpecOption = yield* loadGeneratedNodeSpec;
-
-  const mergedSpec = Option.match(nodeSpecOption, {
-    onNone: () => spec,
-    onSome: (nodeSpec) => Spec.merge(spec, nodeSpec),
-  });
-
-  return yield* generateFunctions(mergedSpec);
+  return yield* generateFunctions(spec);
 });
 
 /**
@@ -855,7 +813,6 @@ const generateServices = Effect.gen(function* () {
 });
 
 const generateRefs = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const confectDirectory = yield* ConfectDirectory.get;
 
@@ -868,18 +825,7 @@ const generateRefs = Effect.gen(function* () {
     path.relative(refsDir, path.join(confectDirectory, generatedSpecPath)),
   );
 
-  const nodeSpecPath = yield* getGeneratedNodeSpecPath;
-  const nodeSpecExists = yield* fs.exists(nodeSpecPath);
-  const nodeSpecImportPath = nodeSpecExists
-    ? Option.some(
-        yield* toModuleImportPath(path.relative(refsDir, nodeSpecPath)),
-      )
-    : Option.none<string>();
-
-  const refsContents = yield* templates.refs({
-    specImportPath,
-    nodeSpecImportPath,
-  });
+  const refsContents = yield* templates.refs({ specImportPath });
 
   yield* writeFileStringAndLog(refsPath, refsContents);
 });

package/src/confect/dev.ts

@@ -1,27 +1,27 @@
-import { Command } from "@effect/cli";
-import { FileSystem, Path } from "@effect/platform";
-import { Ansi, AnsiDoc } from "@effect/printer-ansi";
-import {
-  Array,
-  Chunk,
-  Clock,
-  Console,
-  Duration,
-  Effect,
-  Equal,
-  ExecutionStrategy,
-  Exit,
-  HashSet,
-  Match,
-  Option,
-  Order,
-  pipe,
-  Queue,
-  Ref,
-  Scope,
-  Stream,
-  String,
-} from "effect";
+import * as Command from "@effect/cli/Command";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as Ansi from "@effect/printer-ansi/Ansi";
+import * as AnsiDoc from "@effect/printer-ansi/AnsiDoc";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as Chunk from "effect/Chunk";
+import * as Clock from "effect/Clock";
+import * as Console from "effect/Console";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import * as ExecutionStrategy from "effect/ExecutionStrategy";
+import * as Exit from "effect/Exit";
+import * as HashSet from "effect/HashSet";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Order from "effect/Order";
+import * as Queue from "effect/Queue";
+import * as Ref from "effect/Ref";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as String from "effect/String";
 import {
   externalPlugin,
   loadTsConfig,
@@ -54,9 +54,6 @@ const GENERATED_DIRNAME = "_generated";
 const GENERATED_SPEC_PATH = Effect.andThen(Path.Path, (path) =>
   path.join(GENERATED_DIRNAME, "spec.ts"),
 );
-const GENERATED_NODE_SPEC_PATH = Effect.andThen(Path.Path, (path) =>
-  path.join(GENERATED_DIRNAME, "nodeSpec.ts"),
-);
 
 // Quiescence window: the sync loop waits this long for further signals
 // after each batch. One user edit fires `onEnd` on every esbuild
@@ -421,11 +418,9 @@ const discoverEntryPoints = Effect.gen(function* () {
     });
 
   const generatedSpecPath = yield* GENERATED_SPEC_PATH;
-  const generatedNodeSpecPath = yield* GENERATED_NODE_SPEC_PATH;
 
   const fixedEntryOptions = yield* Effect.all([
     tryEntry(generatedSpecPath, "specDirty"),
-    tryEntry(generatedNodeSpecPath, "specDirty"),
     // `confect/schema.ts` is no longer user-authored; the runtime
     // `DatabaseSchema` lives at `_generated/schema.ts` (codegen-written,
     // so not an entry point — wiring it through esbuild would form a

package/src/confect.ts

@@ -1,5 +1,5 @@
-import { Command } from "@effect/cli";
-import { Layer } from "effect";
+import * as Command from "@effect/cli/Command";
+import * as Layer from "effect/Layer";
 import { codegen } from "./confect/codegen";
 import { dev } from "./confect/dev";
 import { ConfectDirectory } from "./ConfectDirectory";

package/src/index.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
-import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { Effect } from "effect";
+import * as NodeContext from "@effect/platform-node/NodeContext";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as Effect from "effect/Effect";
 import { cliApp } from "./cliApp";
 
 // Track if we received SIGINT so we can re-raise it after cleanup.

package/src/log.ts

@@ -1,6 +1,10 @@
-import { Path } from "@effect/platform";
-import { Ansi, AnsiDoc } from "@effect/printer-ansi";
-import { Console, Effect, pipe, String } from "effect";
+import * as Path from "@effect/platform/Path";
+import * as Ansi from "@effect/printer-ansi/Ansi";
+import * as AnsiDoc from "@effect/printer-ansi/AnsiDoc";
+import { pipe } from "effect/Function";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as String from "effect/String";
 import type * as FunctionPath from "./FunctionPath";
 import * as GroupPath from "./GroupPath";
 import { ProjectRoot } from "./ProjectRoot";

package/src/templates.ts

@@ -1,4 +1,6 @@
-import { Array, Effect, Option } from "effect";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 import { CodeBlockWriter } from "./CodeBlockWriter";
 import {
   collectImportBindings,
@@ -263,30 +265,14 @@ export const authConfig = ({ authImportPath }: { authImportPath: string }) =>
     return yield* cbw.toString();
   });
 
-export const refs = ({
-  specImportPath,
-  nodeSpecImportPath,
-}: {
-  specImportPath: string;
-  nodeSpecImportPath: Option.Option<string>;
-}) =>
+export const refs = ({ specImportPath }: { specImportPath: string }) =>
   Effect.gen(function* () {
     const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
 
     yield* cbw.writeLine(`import { Refs } from "@confect/core";`);
     yield* cbw.writeLine(`import spec from "${specImportPath}";`);
-    yield* Option.match(nodeSpecImportPath, {
-      onNone: () => Effect.void,
-      onSome: (nodeSpecImportPath_) =>
-        cbw.writeLine(`import nodeSpec from "${nodeSpecImportPath_}";`),
-    });
     yield* cbw.blankLine();
-    yield* cbw.writeLine(
-      Option.match(nodeSpecImportPath, {
-        onSome: () => `export default Refs.make(spec, nodeSpec);`,
-        onNone: () => `export default Refs.make(spec);`,
-      }),
-    );
+    yield* cbw.writeLine(`export default Refs.make(spec);`);
 
     return yield* cbw.toString();
   });
@@ -588,10 +574,8 @@ const writeRootAddAt = (
 
 export const assembledSpec = ({
   nodes,
-  runtime,
 }: {
   nodes: ReadonlyArray<SpecAssemblyNode>;
-  runtime: "Convex" | "Node";
 }) =>
   Effect.gen(function* () {
     const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
@@ -615,14 +599,13 @@ export const assembledSpec = ({
 
     yield* cbw.blankLine();
 
-    const specFactory =
-      runtime === "Convex" ? "Spec.make()" : "Spec.makeNode()";
-    const groupFactory =
-      runtime === "Convex" ? "GroupSpec.makeAt" : "GroupSpec.makeNodeAt";
-
-    yield* cbw.write(`export default ${specFactory}`);
+    // The assembled spec is runtime-agnostic: a Node group's `makeNode()` is
+    // already baked into its imported leaf spec, so the root is always
+    // `Spec.make()` and binding-less container groups always use
+    // `GroupSpec.makeAt` (containers register no functions and carry no runtime).
+    yield* cbw.write(`export default Spec.make()`);
     yield* Effect.forEach(nodes, (node) =>
-      writeRootAddAt(cbw, node, groupFactory),
+      writeRootAddAt(cbw, node, "GroupSpec.makeAt"),
     );
     yield* cbw.write(";");
     yield* cbw.newLine();