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

package/dist/Refs.d.ts

@@ -1,22 +1,22 @@
 import { AnyWithProps, GetFunctionVisibility, GetRuntimeAndFunctionType, Name as Name$1, WithName } from "./FunctionSpec.js";
-import { AnyWithProps as AnyWithProps$1, Functions, GroupSpec, Groups, Name as Name$2, WithName as WithName$1 } from "./GroupSpec.js";
-import { Any, AnyInternal, AnyPublic, FromFunctionSpec, Ref as Ref$1 } from "./Ref.js";
-import { AnyWithPropsWithRuntime, Groups as Groups$1 } from "./Spec.js";
+import { AnyWithProps as AnyWithProps$1, Functions, Groups, Name as Name$2, WithName as WithName$1 } from "./GroupSpec.js";
+import { Any, AnyInternal, AnyPublic, FromFunctionSpec, Ref } from "./Ref.js";
+import { AnyWithProps as AnyWithProps$2, Groups as Groups$1 } from "./Spec.js";
 import { Types } from "effect";
 
 //#region src/Refs.d.ts
 declare namespace Refs_d_exports {
   export { Refs, make };
 }
-type Refs<ConvexSpec extends AnyWithPropsWithRuntime<"Convex">, NodeSpec extends AnyWithPropsWithRuntime<"Node"> = never, Predicate extends Any = Any> = Types.Simplify<OmitEmpty<Helper<Groups$1<ConvexSpec> | (NodeSpec extends never ? never : GroupSpec<"Node", "node", never, NodeSpec["groups"][keyof NodeSpec["groups"]]>), Predicate>>>;
+type Refs<Spec_ extends AnyWithProps$2, Predicate extends Any = Any> = Types.Simplify<OmitEmpty<Helper<Groups$1<Spec_>, Predicate>>>;
 type GroupRefs<Group extends AnyWithProps$1, Predicate extends Any> = Types.Simplify<OmitEmpty<Helper<Groups<Group>, Predicate>> & FilteredFunctions<Functions<Group>, Predicate>>;
 type OmitEmpty<T> = { [K in keyof T as keyof T[K] extends never ? never : K]: T[K] };
-type FunctionSpecMatchesPredicate<FunctionSpec_ extends AnyWithProps, Predicate extends Any> = Ref$1<GetRuntimeAndFunctionType<FunctionSpec_>, GetFunctionVisibility<FunctionSpec_>, any, any> extends Predicate ? true : false;
+type FunctionSpecMatchesPredicate<FunctionSpec_ extends AnyWithProps, Predicate extends Any> = Ref<GetRuntimeAndFunctionType<FunctionSpec_>, GetFunctionVisibility<FunctionSpec_>, any, any> extends Predicate ? true : false;
 type FilteredFunctions<FunctionSpecs extends AnyWithProps, Predicate extends Any> = { [Name in Name$1<FunctionSpecs> as WithName<FunctionSpecs, Name> extends infer FunctionSpec_ extends AnyWithProps ? FunctionSpecMatchesPredicate<FunctionSpec_, Predicate> extends true ? Name : never : never]: WithName<FunctionSpecs, Name> extends infer F extends AnyWithProps ? FromFunctionSpec<F> : never };
 type Helper<Groups extends AnyWithProps$1, Predicate extends Any> = { [GroupName in Name$2<Groups>]: WithName$1<Groups, GroupName> extends infer Group extends AnyWithProps$1 ? GroupRefs<Group, Predicate> : never };
-declare const make: <ConvexSpec extends AnyWithPropsWithRuntime<"Convex">, NodeSpec extends AnyWithPropsWithRuntime<"Node"> = never>(convexSpec: ConvexSpec, nodeSpec?: NodeSpec) => {
-  public: Refs<ConvexSpec, NodeSpec, AnyPublic>;
-  internal: Refs<ConvexSpec, NodeSpec, AnyInternal>;
+declare const make: <Spec_ extends AnyWithProps$2>(spec: Spec_) => {
+  public: Refs<Spec_, AnyPublic>;
+  internal: Refs<Spec_, AnyInternal>;
 };
 //#endregion
 export { Refs, Refs_d_exports, make };

package/dist/Refs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Refs.d.ts","names":[],"sources":["../src/Refs.ts"],"mappings":";;;;;;;;;;KAOY,IAAA,oBACS,uBAAA,6BACF,uBAAA,oCACC,GAAA,GAAU,GAAA,IAC1B,KAAA,CAAM,QAAA,CACR,SAAA,CACE,MAAA,CACI,QAAA,CAAY,UAAA,KACX,QAAA,yBAEG,SAAA,wBAIE,QAAA,iBAAyB,QAAA,eAEjC,SAAA;AAAA,KAKD,SAAA,eACW,cAAA,oBACI,GAAA,IAChB,KAAA,CAAM,QAAA,CACR,SAAA,CAAU,MAAA,CAAO,MAAA,CAAiB,KAAA,GAAQ,SAAA,KACxC,iBAAA,CAAkB,SAAA,CAAoB,KAAA,GAAQ,SAAA;AAAA,KAG7C,SAAA,oBACS,CAAA,UAAW,CAAA,CAAE,CAAA,0BAA2B,CAAA,GAAI,CAAA,CAAE,CAAA;AAAA,KAGvD,4BAAA,uBACmB,YAAA,oBACJ,GAAA,IAElB,KAAA,CACE,yBAAA,CAAuC,aAAA,GACvC,qBAAA,CAAmC,aAAA,qBAG3B,SAAA;AAAA,KAIP,iBAAA,uBACmB,YAAA,oBACJ,GAAA,eAET,MAAA,CAAkB,aAAA,KAAkB,QAAA,CAC3C,aAAA,EACA,IAAA,sCACoC,YAAA,GAClC,4BAAA,CAA6B,aAAA,EAAe,SAAA,iBAC1C,IAAA,mBAEM,QAAA,CAAsB,aAAA,EAAe,IAAA,0BAC/C,YAAA,GACE,gBAAA,CAAqB,CAAA;AAAA,KAItB,MAAA,gBACY,cAAA,oBACG,GAAA,oBAEJ,MAAA,CAAe,MAAA,IAAU,UAAA,CACrC,MAAA,EACA,SAAA,8BAC4B,cAAA,GAC1B,SAAA,CAAU,KAAA,EAAO,SAAA;AAAA,cAUV,IAAA,sBACQ,uBAAA,6BACF,uBAAA,kBAEjB,UAAA,EAAY,UAAA,EACZ,QAAA,GAAW,QAAA;EAEX,MAAA,EAAQ,IAAA,CAAK,UAAA,EAAY,QAAA,EAAU,SAAA;EACnC,QAAA,EAAU,IAAA,CAAK,UAAA,EAAY,QAAA,EAAU,WAAA;AAAA"}
+{"version":3,"file":"Refs.d.ts","names":[],"sources":["../src/Refs.ts"],"mappings":";;;;;;;;;;KASY,IAAA,eACI,cAAA,oBACI,GAAA,GAAU,GAAA,IAC1B,KAAA,CAAM,QAAA,CAAS,SAAA,CAAU,MAAA,CAAO,QAAA,CAAY,KAAA,GAAQ,SAAA;AAAA,KAEnD,SAAA,eACW,cAAA,oBACI,GAAA,IAChB,KAAA,CAAM,QAAA,CACR,SAAA,CAAU,MAAA,CAAO,MAAA,CAAiB,KAAA,GAAQ,SAAA,KACxC,iBAAA,CAAkB,SAAA,CAAoB,KAAA,GAAQ,SAAA;AAAA,KAG7C,SAAA,oBACS,CAAA,UAAW,CAAA,CAAE,CAAA,0BAA2B,CAAA,GAAI,CAAA,CAAE,CAAA;AAAA,KAGvD,4BAAA,uBACmB,YAAA,oBACJ,GAAA,IAElB,GAAA,CACE,yBAAA,CAAuC,aAAA,GACvC,qBAAA,CAAmC,aAAA,qBAG3B,SAAA;AAAA,KAIP,iBAAA,uBACmB,YAAA,oBACJ,GAAA,eAET,MAAA,CAAkB,aAAA,KAAkB,QAAA,CAC3C,aAAA,EACA,IAAA,sCACoC,YAAA,GAClC,4BAAA,CAA6B,aAAA,EAAe,SAAA,iBAC1C,IAAA,mBAEM,QAAA,CAAsB,aAAA,EAAe,IAAA,0BAC/C,YAAA,GACE,gBAAA,CAAqB,CAAA;AAAA,KAItB,MAAA,gBACY,cAAA,oBACG,GAAA,oBAEJ,MAAA,CAAe,MAAA,IAAU,UAAA,CACrC,MAAA,EACA,SAAA,8BAC4B,cAAA,GAC1B,SAAA,CAAU,KAAA,EAAO,SAAA;AAAA,cAUV,IAAA,iBAAsB,cAAA,EACjC,IAAA,EAAM,KAAA;EAEN,MAAA,EAAQ,IAAA,CAAK,KAAA,EAAO,SAAA;EACpB,QAAA,EAAU,IAAA,CAAK,KAAA,EAAO,WAAA;AAAA"}

package/dist/Refs.js

@@ -1,18 +1,13 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { makeNodeAt } from "./GroupSpec.js";
 import { getConvexFunctionName, make as make$1 } from "./Ref.js";
-import { Array, Option, Record, pipe } from "effect";
+import * as Record from "effect/Record";
+import * as Option from "effect/Option";
+import { pipe } from "effect/Function";
 
 //#region src/Refs.ts
 var Refs_exports = /* @__PURE__ */ __exportAll({ make: () => make });
-const make = (convexSpec, nodeSpec) => {
-	const refs = makeHelper(Option.fromNullable(nodeSpec).pipe(Option.map((nodeSpec_) => Array.reduce(Record.toEntries(nodeSpec_.groups), makeNodeAt("node"), (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group))), Option.match({
-		onNone: () => convexSpec.groups,
-		onSome: (nodeGroup) => ({
-			...convexSpec.groups,
-			node: nodeGroup
-		})
-	})));
+const make = (spec) => {
+	const refs = makeHelper(spec.groups);
 	return {
 		public: refs,
 		internal: refs

package/dist/Refs.js.map

@@ -1 +1 @@
-{"version":3,"file":"Refs.js","names":["GroupSpec.makeNodeAt","Ref.make","Ref.getConvexFunctionName"],"sources":["../src/Refs.ts"],"sourcesContent":["import type { Types } from \"effect\";\nimport { Array, Option, pipe, Record } from \"effect\";\nimport type * as FunctionSpec from \"./FunctionSpec\";\nimport * as GroupSpec from \"./GroupSpec\";\nimport * as Ref from \"./Ref\";\nimport type * as Spec from \"./Spec\";\n\nexport type Refs<\n  ConvexSpec extends Spec.AnyWithPropsWithRuntime<\"Convex\">,\n  NodeSpec extends Spec.AnyWithPropsWithRuntime<\"Node\"> = never,\n  Predicate extends Ref.Any = Ref.Any,\n> = Types.Simplify<\n  OmitEmpty<\n    Helper<\n      | Spec.Groups<ConvexSpec>\n      | (NodeSpec extends never\n          ? never\n          : GroupSpec.GroupSpec<\n              \"Node\",\n              \"node\",\n              never,\n              NodeSpec[\"groups\"][keyof NodeSpec[\"groups\"]]\n            >),\n      Predicate\n    >\n  >\n>;\n\ntype GroupRefs<\n  Group extends GroupSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> = Types.Simplify<\n  OmitEmpty<Helper<GroupSpec.Groups<Group>, Predicate>> &\n    FilteredFunctions<GroupSpec.Functions<Group>, Predicate>\n>;\n\ntype OmitEmpty<T> = {\n  [K in keyof T as keyof T[K] extends never ? never : K]: T[K];\n};\n\ntype FunctionSpecMatchesPredicate<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> =\n  Ref.Ref<\n    FunctionSpec.GetRuntimeAndFunctionType<FunctionSpec_>,\n    FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n    any,\n    any\n  > extends Predicate\n    ? true\n    : false;\n\ntype FilteredFunctions<\n  FunctionSpecs extends FunctionSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> = {\n  [Name in FunctionSpec.Name<FunctionSpecs> as FunctionSpec.WithName<\n    FunctionSpecs,\n    Name\n  > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n    ? FunctionSpecMatchesPredicate<FunctionSpec_, Predicate> extends true\n      ? Name\n      : never\n    : never]: FunctionSpec.WithName<FunctionSpecs, Name> extends infer F extends\n    FunctionSpec.AnyWithProps\n    ? Ref.FromFunctionSpec<F>\n    : never;\n};\n\ntype Helper<\n  Groups extends GroupSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupRefs<Group, Predicate>\n    : never;\n};\n\ntype Any =\n  | {\n      readonly [key: string]: Any;\n    }\n  | Ref.Any;\n\nexport const make = <\n  ConvexSpec extends Spec.AnyWithPropsWithRuntime<\"Convex\">,\n  NodeSpec extends Spec.AnyWithPropsWithRuntime<\"Node\"> = never,\n>(\n  convexSpec: ConvexSpec,\n  nodeSpec?: NodeSpec,\n): {\n  public: Refs<ConvexSpec, NodeSpec, Ref.AnyPublic>;\n  internal: Refs<ConvexSpec, NodeSpec, Ref.AnyInternal>;\n} => {\n  const groups = Option.fromNullable(nodeSpec).pipe(\n    Option.map((nodeSpec_) =>\n      Array.reduce(\n        Record.toEntries(nodeSpec_.groups),\n        GroupSpec.makeNodeAt(\"node\"),\n        (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group),\n      ),\n    ),\n    Option.match({\n      onNone: () => convexSpec.groups,\n      onSome: (nodeGroup) => ({ ...convexSpec.groups, node: nodeGroup }),\n    }),\n  );\n  const refs = makeHelper(groups);\n  return {\n    public: refs as Refs<ConvexSpec, NodeSpec, Ref.AnyPublic>,\n    internal: refs as Refs<ConvexSpec, NodeSpec, Ref.AnyInternal>,\n  };\n};\n\nconst makeHelper = (\n  groups: Record.ReadonlyRecord<string, GroupSpec.Any>,\n  functionNamespace: Option.Option<string> = Option.none(),\n): Any =>\n  pipe(\n    groups as Record.ReadonlyRecord<string, GroupSpec.AnyWithProps>,\n    Record.map((group, name) => {\n      const currentFunctionNamespace = Option.match(functionNamespace, {\n        onNone: () => name,\n        onSome: (parentNamespace) => `${parentNamespace}/${name}`,\n      });\n\n      return Record.union(\n        makeHelper(group.groups, Option.some(currentFunctionNamespace)),\n        Record.map(group.functions, (function_) =>\n          Ref.make(currentFunctionNamespace, function_),\n        ),\n        (_subGroup, _function) => {\n          throw new Error(\n            `Group and function at same level have same name ('${Ref.getConvexFunctionName(_function)}')`,\n          );\n        },\n      );\n    }),\n  );\n"],"mappings":";;;;;;;AAwFA,MAAa,QAIX,YACA,aAIG;CAcH,MAAM,OAAO,WAbE,OAAO,aAAa,SAAS,CAAC,KAC3C,OAAO,KAAK,cACV,MAAM,OACJ,OAAO,UAAU,UAAU,OAAO,EAClCA,WAAqB,OAAO,GAC3B,eAAe,CAAC,MAAM,WAAW,cAAc,WAAW,MAAM,MAAM,CACxE,CACF,EACD,OAAO,MAAM;EACX,cAAc,WAAW;EACzB,SAAS,eAAe;GAAE,GAAG,WAAW;GAAQ,MAAM;GAAW;EAClE,CAAC,CACH,CAC8B;AAC/B,QAAO;EACL,QAAQ;EACR,UAAU;EACX;;AAGH,MAAM,cACJ,QACA,oBAA2C,OAAO,MAAM,KAExD,KACE,QACA,OAAO,KAAK,OAAO,SAAS;CAC1B,MAAM,2BAA2B,OAAO,MAAM,mBAAmB;EAC/D,cAAc;EACd,SAAS,oBAAoB,GAAG,gBAAgB,GAAG;EACpD,CAAC;AAEF,QAAO,OAAO,MACZ,WAAW,MAAM,QAAQ,OAAO,KAAK,yBAAyB,CAAC,EAC/D,OAAO,IAAI,MAAM,YAAY,cAC3BC,OAAS,0BAA0B,UAAU,CAC9C,GACA,WAAW,cAAc;AACxB,QAAM,IAAI,MACR,qDAAqDC,sBAA0B,UAAU,CAAC,IAC3F;GAEJ;EACD,CACH"}
+{"version":3,"file":"Refs.js","names":["Ref.make","Ref.getConvexFunctionName"],"sources":["../src/Refs.ts"],"sourcesContent":["import type { Types } from \"effect\";\nimport { pipe } from \"effect/Function\";\nimport * as Option from \"effect/Option\";\nimport * as Record from \"effect/Record\";\nimport type * as FunctionSpec from \"./FunctionSpec\";\nimport type * as GroupSpec from \"./GroupSpec\";\nimport * as Ref from \"./Ref\";\nimport type * as Spec from \"./Spec\";\n\nexport type Refs<\n  Spec_ extends Spec.AnyWithProps,\n  Predicate extends Ref.Any = Ref.Any,\n> = Types.Simplify<OmitEmpty<Helper<Spec.Groups<Spec_>, Predicate>>>;\n\ntype GroupRefs<\n  Group extends GroupSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> = Types.Simplify<\n  OmitEmpty<Helper<GroupSpec.Groups<Group>, Predicate>> &\n    FilteredFunctions<GroupSpec.Functions<Group>, Predicate>\n>;\n\ntype OmitEmpty<T> = {\n  [K in keyof T as keyof T[K] extends never ? never : K]: T[K];\n};\n\ntype FunctionSpecMatchesPredicate<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> =\n  Ref.Ref<\n    FunctionSpec.GetRuntimeAndFunctionType<FunctionSpec_>,\n    FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n    any,\n    any\n  > extends Predicate\n    ? true\n    : false;\n\ntype FilteredFunctions<\n  FunctionSpecs extends FunctionSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> = {\n  [Name in FunctionSpec.Name<FunctionSpecs> as FunctionSpec.WithName<\n    FunctionSpecs,\n    Name\n  > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n    ? FunctionSpecMatchesPredicate<FunctionSpec_, Predicate> extends true\n      ? Name\n      : never\n    : never]: FunctionSpec.WithName<FunctionSpecs, Name> extends infer F extends\n    FunctionSpec.AnyWithProps\n    ? Ref.FromFunctionSpec<F>\n    : never;\n};\n\ntype Helper<\n  Groups extends GroupSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupRefs<Group, Predicate>\n    : never;\n};\n\ntype Any =\n  | {\n      readonly [key: string]: Any;\n    }\n  | Ref.Any;\n\nexport const make = <Spec_ extends Spec.AnyWithProps>(\n  spec: Spec_,\n): {\n  public: Refs<Spec_, Ref.AnyPublic>;\n  internal: Refs<Spec_, Ref.AnyInternal>;\n} => {\n  const refs = makeHelper(spec.groups);\n  return {\n    public: refs as Refs<Spec_, Ref.AnyPublic>,\n    internal: refs as Refs<Spec_, Ref.AnyInternal>,\n  };\n};\n\nconst makeHelper = (\n  groups: Record.ReadonlyRecord<string, GroupSpec.Any>,\n  functionNamespace: Option.Option<string> = Option.none(),\n): Any =>\n  pipe(\n    groups as Record.ReadonlyRecord<string, GroupSpec.AnyWithProps>,\n    Record.map((group, name) => {\n      const currentFunctionNamespace = Option.match(functionNamespace, {\n        onNone: () => name,\n        onSome: (parentNamespace) => `${parentNamespace}/${name}`,\n      });\n\n      return Record.union(\n        makeHelper(group.groups, Option.some(currentFunctionNamespace)),\n        Record.map(group.functions, (function_) =>\n          Ref.make(currentFunctionNamespace, function_),\n        ),\n        (_subGroup, _function) => {\n          throw new Error(\n            `Group and function at same level have same name ('${Ref.getConvexFunctionName(_function)}')`,\n          );\n        },\n      );\n    }),\n  );\n"],"mappings":";;;;;;;;AA0EA,MAAa,QACX,SAIG;CACH,MAAM,OAAO,WAAW,KAAK,OAAO;AACpC,QAAO;EACL,QAAQ;EACR,UAAU;EACX;;AAGH,MAAM,cACJ,QACA,oBAA2C,OAAO,MAAM,KAExD,KACE,QACA,OAAO,KAAK,OAAO,SAAS;CAC1B,MAAM,2BAA2B,OAAO,MAAM,mBAAmB;EAC/D,cAAc;EACd,SAAS,oBAAoB,GAAG,gBAAgB,GAAG;EACpD,CAAC;AAEF,QAAO,OAAO,MACZ,WAAW,MAAM,QAAQ,OAAO,KAAK,yBAAyB,CAAC,EAC/D,OAAO,IAAI,MAAM,YAAY,cAC3BA,OAAS,0BAA0B,UAAU,CAC9C,GACA,WAAW,cAAc;AACxB,QAAM,IAAI,MACR,qDAAqDC,sBAA0B,UAAU,CAAC,IAC3F;GAEJ;EACD,CACH"}

package/dist/Registry.d.ts

@@ -1,4 +1,5 @@
-import { Context, Ref } from "effect";
+import * as Context from "effect/Context";
+import * as Ref from "effect/Ref";
 
 //#region src/Registry.d.ts
 declare namespace Registry_d_exports {

package/dist/Registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Registry.d.ts","names":[],"sources":["../src/Registry.ts"],"mappings":";;;;;;;;;;;;;AAUA;UAAiB,aAAA;EAAA,UACL,GAAA,qBAAwB,aAAA;AAAA;AAAA,cACnC,aAAA;AAAA;;;;;;;;;AAAA,cAWY,QAAA,SAAiB,aAAA"}
+{"version":3,"file":"Registry.d.ts","names":[],"sources":["../src/Registry.ts"],"mappings":";;;;;;;;;;;;;;AAWA;UAAiB,aAAA;EAAA,UACL,GAAA,qBAAwB,aAAA;AAAA;AAAA,cACnC,aAAA;AAAA;;;;;;;;;AAAA,cAWY,QAAA,SAAiB,aAAA"}

package/dist/Registry.js

@@ -1,5 +1,6 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Context, Ref } from "effect";
+import * as Context from "effect/Context";
+import * as Ref from "effect/Ref";
 
 //#region src/Registry.ts
 var Registry_exports = /* @__PURE__ */ __exportAll({ Registry: () => Registry });

package/dist/Registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"Registry.js","names":[],"sources":["../src/Registry.ts"],"sourcesContent":["import { Context, Ref } from \"effect\";\n\n/**\n * Recursive tree that mirrors a `Spec`'s group structure. Leaves are the\n * per-function items written by each `FunctionImpl`'s layer initializer. The\n * leaf type is intentionally `unknown` here so `@confect/core` does not need\n * to know about `@confect/server`'s `RegistryItem` shape; producers and\n * consumers (the server runtime and the CLI's `implValidation`) narrow as\n * needed.\n */\nexport interface RegistryItems {\n  readonly [key: string]: unknown | RegistryItems;\n}\n\n/**\n * Effect `Context.Reference` keyed by `@confect/core/Registry`. Lives in\n * `@confect/core` so `@confect/server` (which writes to it from\n * `FunctionImpl` initializers and reads it from `RegisteredFunctions`) and\n * `@confect/cli` (which inspects it during impl validation) can share the\n * exact same `Ref` instance by importing the same tag — without relying on\n * Effect's global default-value cache to align two separately-defined tags\n * by string key.\n */\nexport class Registry extends Context.Reference<Registry>()(\n  \"@confect/core/Registry\",\n  {\n    defaultValue: () => Ref.unsafeMake<RegistryItems>({}),\n  },\n) {}\n"],"mappings":";;;;;;;;;;;;;;AAuBA,IAAa,WAAb,cAA8B,QAAQ,WAAqB,CACzD,0BACA,EACE,oBAAoB,IAAI,WAA0B,EAAE,CAAC,EACtD,CACF,CAAC"}
+{"version":3,"file":"Registry.js","names":[],"sources":["../src/Registry.ts"],"sourcesContent":["import * as Context from \"effect/Context\";\nimport * as Ref from \"effect/Ref\";\n\n/**\n * Recursive tree that mirrors a `Spec`'s group structure. Leaves are the\n * per-function items written by each `FunctionImpl`'s layer initializer. The\n * leaf type is intentionally `unknown` here so `@confect/core` does not need\n * to know about `@confect/server`'s `RegistryItem` shape; producers and\n * consumers (the server runtime and the CLI's `implValidation`) narrow as\n * needed.\n */\nexport interface RegistryItems {\n  readonly [key: string]: unknown | RegistryItems;\n}\n\n/**\n * Effect `Context.Reference` keyed by `@confect/core/Registry`. Lives in\n * `@confect/core` so `@confect/server` (which writes to it from\n * `FunctionImpl` initializers and reads it from `RegisteredFunctions`) and\n * `@confect/cli` (which inspects it during impl validation) can share the\n * exact same `Ref` instance by importing the same tag — without relying on\n * Effect's global default-value cache to align two separately-defined tags\n * by string key.\n */\nexport class Registry extends Context.Reference<Registry>()(\n  \"@confect/core/Registry\",\n  {\n    defaultValue: () => Ref.unsafeMake<RegistryItems>({}),\n  },\n) {}\n"],"mappings":";;;;;;;;;;;;;;;AAwBA,IAAa,WAAb,cAA8B,QAAQ,WAAqB,CACzD,0BACA,EACE,oBAAoB,IAAI,WAA0B,EAAE,CAAC,EACtD,CACF,CAAC"}

package/dist/Spec.d.ts

@@ -1,37 +1,31 @@
-import { Runtime } from "./RuntimeAndFunctionType.js";
-import { AnyWithProps as AnyWithProps$1, AnyWithPropsWithRuntime as AnyWithPropsWithRuntime$1, Name, NamedAt, WithName } from "./GroupSpec.js";
+import { AnyWithProps as AnyWithProps$1, Name, NamedAt, WithName } from "./GroupSpec.js";
 
 //#region src/Spec.d.ts
 declare namespace Spec_d_exports {
-  export { Any, AnyWithProps, AnyWithPropsWithRuntime, Groups, Spec, TypeId, isConvexSpec, isNodeSpec, isSpec, make, makeNode, merge };
+  export { Any, AnyWithProps, Groups, Spec, TypeId, isSpec, make };
 }
 declare const TypeId = "@confect/core/Spec";
 type TypeId = typeof TypeId;
 declare const isSpec: (u: unknown) => u is AnyWithProps;
-declare const isConvexSpec: (u: unknown) => u is AnyWithPropsWithRuntime<"Convex">;
-declare const isNodeSpec: (u: unknown) => u is AnyWithPropsWithRuntime<"Node">;
-interface Spec<Runtime$2 extends Runtime, Groups_ extends AnyWithPropsWithRuntime$1<Runtime$2> = never> {
+/**
+ * A Confect spec: a flat container of function groups. Groups may be of any
+ * runtime — a group built with `GroupSpec.makeNode()` (a Node action group) sits
+ * alongside `GroupSpec.make()` groups in the same namespace. The runtime of a
+ * group lives on the group itself (`GroupSpec.runtime`) and on each function's
+ * `RuntimeAndFunctionType`; the spec does not carry a runtime of its own.
+ */
+interface Spec<Groups_ extends AnyWithProps$1 = never> {
   readonly [TypeId]: TypeId;
-  readonly runtime: Runtime$2;
   readonly groups: { [GroupName in Name<Groups_>]: WithName<Groups_, GroupName> };
-  add<Group extends AnyWithPropsWithRuntime$1<Runtime$2>>(group: Group): Spec<Runtime$2, Groups_ | Group>;
-  addAt<const Name$1 extends string, Group extends AnyWithPropsWithRuntime$1<Runtime$2>>(name: Name$1, group: Group): Spec<Runtime$2, Groups_ | NamedAt<Group, Name$1>>;
+  add<Group extends AnyWithProps$1>(group: Group): Spec<Groups_ | Group>;
+  addAt<const Name$1 extends string, Group extends AnyWithProps$1>(name: Name$1, group: Group): Spec<Groups_ | NamedAt<Group, Name$1>>;
 }
 interface Any {
   readonly [TypeId]: TypeId;
 }
-interface AnyWithProps extends Spec<Runtime, AnyWithProps$1> {}
-interface AnyWithPropsWithRuntime<Runtime$1 extends Runtime> extends Spec<Runtime$1, AnyWithPropsWithRuntime$1<Runtime$1>> {}
+interface AnyWithProps extends Spec<AnyWithProps$1> {}
 type Groups<Spec_ extends AnyWithProps> = Spec_["groups"][keyof Spec_["groups"]];
-declare const make: () => Spec<"Convex">;
-declare const makeNode: () => Spec<"Node">;
-/**
- * Merges a Convex spec with an optional Node spec into a single assembled
- * spec (used by codegen to build `Refs.make` and to enumerate function paths).
- * When `nodeSpec` is provided, its groups are merged under a "node" namespace,
- * mirroring the structure used by `Refs.make`.
- */
-declare const merge: <ConvexSpec extends AnyWithPropsWithRuntime<"Convex">, NodeSpec extends AnyWithPropsWithRuntime<"Node">>(convexSpec: ConvexSpec, nodeSpec?: NodeSpec) => AnyWithProps;
+declare const make: () => Spec;
 //#endregion
-export { Any, AnyWithProps, AnyWithPropsWithRuntime, Groups, Spec, Spec_d_exports, TypeId, isConvexSpec, isNodeSpec, isSpec, make, makeNode, merge };
+export { Any, AnyWithProps, Groups, Spec, Spec_d_exports, TypeId, isSpec, make };
 //# sourceMappingURL=Spec.d.ts.map

package/dist/Spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Spec.d.ts","names":[],"sources":["../src/Spec.ts"],"mappings":";;;;;;;cAIa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,MAAA,GAAU,CAAA,cAAa,CAAA,IAAK,YAAA;AAAA,cAG5B,YAAA,GACX,CAAA,cACC,CAAA,IAAK,uBAAA;AAAA,cAKK,UAAA,GAAc,CAAA,cAAa,CAAA,IAAK,uBAAA;AAAA,UAK5B,IAAA,mBACC,OAAA,kBACA,yBAAA,CAAkC,SAAA;EAAA,UAExC,MAAA,GAAS,MAAA;EAAA,SACV,OAAA,EAAS,SAAA;EAAA,SACT,MAAA,kBACO,IAAA,CAAe,OAAA,IAAW,QAAA,CACtC,OAAA,EACA,SAAA;EAIJ,GAAA,eAAkB,yBAAA,CAAkC,SAAA,GAClD,KAAA,EAAO,KAAA,GACN,IAAA,CAAK,SAAA,EAAS,OAAA,GAAU,KAAA;EAE3B,KAAA,4CAEgB,yBAAA,CAAkC,SAAA,GAEhD,IAAA,EAAM,MAAA,EACN,KAAA,EAAO,KAAA,GACN,IAAA,CAAK,SAAA,EAAS,OAAA,GAAU,OAAA,CAAkB,KAAA,EAAO,MAAA;AAAA;AAAA,UAGrC,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,UAGJ,YAAA,SAAqB,IAAA,CACpC,OAAA,EACA,cAAA;AAAA,UAGe,uBAAA,mBACC,OAAA,UACR,IAAA,CAAK,SAAA,EAAS,yBAAA,CAAkC,SAAA;AAAA,KAE9C,MAAA,eAAqB,YAAA,IAC/B,KAAA,iBAAsB,KAAA;AAAA,cAuCX,IAAA,QAAW,IAAA;AAAA,cAGX,QAAA,QAAe,IAAA;;;;AAjG5B;;;cA0Ga,KAAA,sBACQ,uBAAA,6BACF,uBAAA,UAEjB,UAAA,EAAY,UAAA,EACZ,QAAA,GAAW,QAAA,KACV,YAAA"}
+{"version":3,"file":"Spec.d.ts","names":[],"sources":["../src/Spec.ts"],"mappings":";;;;;;cAIa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,MAAA,GAAU,CAAA,cAAa,CAAA,IAAK,YAAA;;;;;;;;UAUxB,IAAA,iBAAqB,cAAA;EAAA,UAC1B,MAAA,GAAS,MAAA;EAAA,SACV,MAAA,kBACO,IAAA,CAAe,OAAA,IAAW,QAAA,CACtC,OAAA,EACA,SAAA;EAIJ,GAAA,eAAkB,cAAA,EAChB,KAAA,EAAO,KAAA,GACN,IAAA,CAAK,OAAA,GAAU,KAAA;EAElB,KAAA,4CAA+C,cAAA,EAC7C,IAAA,EAAM,MAAA,EACN,KAAA,EAAO,KAAA,GACN,IAAA,CAAK,OAAA,GAAU,OAAA,CAAkB,KAAA,EAAO,MAAA;AAAA;AAAA,UAG5B,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,UAGJ,YAAA,SAAqB,IAAA,CAAK,cAAA;AAAA,KAE/B,MAAA,eAAqB,YAAA,IAC/B,KAAA,iBAAsB,KAAA;AAAA,cA+BX,IAAA,QAAW,IAAA"}

package/dist/Spec.js

@@ -1,68 +1,28 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { makeNodeAt, withName } from "./GroupSpec.js";
-import { Array, Option, Predicate, Record } from "effect";
+import { withName } from "./GroupSpec.js";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
 
 //#region src/Spec.ts
 var Spec_exports = /* @__PURE__ */ __exportAll({
 	TypeId: () => TypeId,
-	isConvexSpec: () => isConvexSpec,
-	isNodeSpec: () => isNodeSpec,
 	isSpec: () => isSpec,
-	make: () => make,
-	makeNode: () => makeNode,
-	merge: () => merge
+	make: () => make
 });
 const TypeId = "@confect/core/Spec";
 const isSpec = (u) => Predicate.hasProperty(u, TypeId);
-const isConvexSpec = (u) => Predicate.hasProperty(u, TypeId) && Predicate.hasProperty(u, "runtime") && u.runtime === "Convex";
-const isNodeSpec = (u) => Predicate.hasProperty(u, TypeId) && Predicate.hasProperty(u, "runtime") && u.runtime === "Node";
 const Proto = {
 	[TypeId]: TypeId,
 	add(group) {
-		return makeProto({
-			runtime: this.runtime,
-			groups: Record.set(this.groups, group.name, group)
-		});
+		return makeProto({ groups: Record.set(this.groups, group.name, group) });
 	},
 	addAt(name, group) {
-		return makeProto({
-			runtime: this.runtime,
-			groups: Record.set(this.groups, name, withName(name, group))
-		});
+		return makeProto({ groups: Record.set(this.groups, name, withName(name, group)) });
 	}
 };
-const makeProto = ({ runtime, groups }) => Object.assign(Object.create(Proto), {
-	runtime,
-	groups
-});
-const make = () => makeProto({
-	runtime: "Convex",
-	groups: {}
-});
-const makeNode = () => makeProto({
-	runtime: "Node",
-	groups: {}
-});
-/**
-* Merges a Convex spec with an optional Node spec into a single assembled
-* spec (used by codegen to build `Refs.make` and to enumerate function paths).
-* When `nodeSpec` is provided, its groups are merged under a "node" namespace,
-* mirroring the structure used by `Refs.make`.
-*/
-const merge = (convexSpec, nodeSpec) => {
-	const groups = Option.fromNullable(nodeSpec).pipe(Option.map((nodeSpec_) => Array.reduce(Record.toEntries(nodeSpec_.groups), makeNodeAt("node"), (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group))), Option.match({
-		onNone: () => convexSpec.groups,
-		onSome: (nodeGroup) => ({
-			...convexSpec.groups,
-			node: nodeGroup
-		})
-	}));
-	return Object.assign(Object.create(Proto), {
-		runtime: "Convex",
-		groups
-	});
-};
+const makeProto = ({ groups }) => Object.assign(Object.create(Proto), { groups });
+const make = () => makeProto({ groups: {} });
 
 //#endregion
-export { Spec_exports, TypeId, isConvexSpec, isNodeSpec, isSpec, make, makeNode, merge };
+export { Spec_exports, TypeId, isSpec, make };
 //# sourceMappingURL=Spec.js.map

package/dist/Spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"Spec.js","names":["GroupSpec.withName","GroupSpec.makeNodeAt"],"sources":["../src/Spec.ts"],"sourcesContent":["import { Array, Option, Predicate, Record } from \"effect\";\nimport * as GroupSpec from \"./GroupSpec\";\nimport type * as RuntimeAndFunctionType from \"./RuntimeAndFunctionType\";\n\nexport const TypeId = \"@confect/core/Spec\";\nexport type TypeId = typeof TypeId;\n\nexport const isSpec = (u: unknown): u is AnyWithProps =>\n  Predicate.hasProperty(u, TypeId);\n\nexport const isConvexSpec = (\n  u: unknown,\n): u is AnyWithPropsWithRuntime<\"Convex\"> =>\n  Predicate.hasProperty(u, TypeId) &&\n  Predicate.hasProperty(u, \"runtime\") &&\n  u.runtime === \"Convex\";\n\nexport const isNodeSpec = (u: unknown): u is AnyWithPropsWithRuntime<\"Node\"> =>\n  Predicate.hasProperty(u, TypeId) &&\n  Predicate.hasProperty(u, \"runtime\") &&\n  u.runtime === \"Node\";\n\nexport interface Spec<\n  Runtime extends RuntimeAndFunctionType.Runtime,\n  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime> = never,\n> {\n  readonly [TypeId]: TypeId;\n  readonly runtime: Runtime;\n  readonly groups: {\n    [GroupName in GroupSpec.Name<Groups_>]: GroupSpec.WithName<\n      Groups_,\n      GroupName\n    >;\n  };\n\n  add<Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>>(\n    group: Group,\n  ): Spec<Runtime, Groups_ | Group>;\n\n  addAt<\n    const Name extends string,\n    Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,\n  >(\n    name: Name,\n    group: Group,\n  ): Spec<Runtime, Groups_ | GroupSpec.NamedAt<Group, Name>>;\n}\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport interface AnyWithProps extends Spec<\n  RuntimeAndFunctionType.Runtime,\n  GroupSpec.AnyWithProps\n> {}\n\nexport interface AnyWithPropsWithRuntime<\n  Runtime extends RuntimeAndFunctionType.Runtime,\n> extends Spec<Runtime, GroupSpec.AnyWithPropsWithRuntime<Runtime>> {}\n\nexport type Groups<Spec_ extends AnyWithProps> =\n  Spec_[\"groups\"][keyof Spec_[\"groups\"]];\n\nconst Proto = {\n  [TypeId]: TypeId,\n\n  add<Group extends GroupSpec.AnyWithProps>(this: AnyWithProps, group: Group) {\n    return makeProto({\n      runtime: this.runtime,\n      groups: Record.set(this.groups, group.name, group),\n    });\n  },\n\n  addAt<Group extends GroupSpec.AnyWithProps>(\n    this: AnyWithProps,\n    name: string,\n    group: Group,\n  ) {\n    return makeProto({\n      runtime: this.runtime,\n      groups: Record.set(this.groups, name, GroupSpec.withName(name, group)),\n    });\n  },\n};\n\nconst makeProto = <\n  Runtime extends RuntimeAndFunctionType.Runtime,\n  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,\n>({\n  runtime,\n  groups,\n}: {\n  runtime: Runtime;\n  groups: Record.ReadonlyRecord<string, Groups_>;\n}): Spec<Runtime, Groups_> =>\n  Object.assign(Object.create(Proto), {\n    runtime,\n    groups,\n  });\n\nexport const make = (): Spec<\"Convex\"> =>\n  makeProto({ runtime: \"Convex\", groups: {} });\n\nexport const makeNode = (): Spec<\"Node\"> =>\n  makeProto({ runtime: \"Node\", groups: {} });\n\n/**\n * Merges a Convex spec with an optional Node spec into a single assembled\n * spec (used by codegen to build `Refs.make` and to enumerate function paths).\n * When `nodeSpec` is provided, its groups are merged under a \"node\" namespace,\n * mirroring the structure used by `Refs.make`.\n */\nexport const merge = <\n  ConvexSpec extends AnyWithPropsWithRuntime<\"Convex\">,\n  NodeSpec extends AnyWithPropsWithRuntime<\"Node\">,\n>(\n  convexSpec: ConvexSpec,\n  nodeSpec?: NodeSpec,\n): AnyWithProps => {\n  const groups = Option.fromNullable(nodeSpec).pipe(\n    Option.map((nodeSpec_) =>\n      Array.reduce(\n        Record.toEntries(nodeSpec_.groups),\n        GroupSpec.makeNodeAt(\"node\"),\n        (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group),\n      ),\n    ),\n    Option.match({\n      onNone: () => convexSpec.groups,\n      onSome: (nodeGroup) => ({ ...convexSpec.groups, node: nodeGroup }),\n    }),\n  );\n\n  return Object.assign(Object.create(Proto), {\n    runtime: \"Convex\" as const,\n    groups,\n  }) as AnyWithProps;\n};\n"],"mappings":";;;;;;;;;;;;;;AAIA,MAAa,SAAS;AAGtB,MAAa,UAAU,MACrB,UAAU,YAAY,GAAG,OAAO;AAElC,MAAa,gBACX,MAEA,UAAU,YAAY,GAAG,OAAO,IAChC,UAAU,YAAY,GAAG,UAAU,IACnC,EAAE,YAAY;AAEhB,MAAa,cAAc,MACzB,UAAU,YAAY,GAAG,OAAO,IAChC,UAAU,YAAY,GAAG,UAAU,IACnC,EAAE,YAAY;AA4ChB,MAAM,QAAQ;EACX,SAAS;CAEV,IAA8D,OAAc;AAC1E,SAAO,UAAU;GACf,SAAS,KAAK;GACd,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,MAAM;GACnD,CAAC;;CAGJ,MAEE,MACA,OACA;AACA,SAAO,UAAU;GACf,SAAS,KAAK;GACd,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAMA,SAAmB,MAAM,MAAM,CAAC;GACvE,CAAC;;CAEL;AAED,MAAM,aAGJ,EACA,SACA,aAKA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;CAClC;CACA;CACD,CAAC;AAEJ,MAAa,aACX,UAAU;CAAE,SAAS;CAAU,QAAQ,EAAE;CAAE,CAAC;AAE9C,MAAa,iBACX,UAAU;CAAE,SAAS;CAAQ,QAAQ,EAAE;CAAE,CAAC;;;;;;;AAQ5C,MAAa,SAIX,YACA,aACiB;CACjB,MAAM,SAAS,OAAO,aAAa,SAAS,CAAC,KAC3C,OAAO,KAAK,cACV,MAAM,OACJ,OAAO,UAAU,UAAU,OAAO,EAClCC,WAAqB,OAAO,GAC3B,eAAe,CAAC,MAAM,WAAW,cAAc,WAAW,MAAM,MAAM,CACxE,CACF,EACD,OAAO,MAAM;EACX,cAAc,WAAW;EACzB,SAAS,eAAe;GAAE,GAAG,WAAW;GAAQ,MAAM;GAAW;EAClE,CAAC,CACH;AAED,QAAO,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;EACzC,SAAS;EACT;EACD,CAAC"}
+{"version":3,"file":"Spec.js","names":["GroupSpec.withName"],"sources":["../src/Spec.ts"],"sourcesContent":["import * as Predicate from \"effect/Predicate\";\nimport * as Record from \"effect/Record\";\nimport * as GroupSpec from \"./GroupSpec\";\n\nexport const TypeId = \"@confect/core/Spec\";\nexport type TypeId = typeof TypeId;\n\nexport const isSpec = (u: unknown): u is AnyWithProps =>\n  Predicate.hasProperty(u, TypeId);\n\n/**\n * A Confect spec: a flat container of function groups. Groups may be of any\n * runtime — a group built with `GroupSpec.makeNode()` (a Node action group) sits\n * alongside `GroupSpec.make()` groups in the same namespace. The runtime of a\n * group lives on the group itself (`GroupSpec.runtime`) and on each function's\n * `RuntimeAndFunctionType`; the spec does not carry a runtime of its own.\n */\nexport interface Spec<Groups_ extends GroupSpec.AnyWithProps = never> {\n  readonly [TypeId]: TypeId;\n  readonly groups: {\n    [GroupName in GroupSpec.Name<Groups_>]: GroupSpec.WithName<\n      Groups_,\n      GroupName\n    >;\n  };\n\n  add<Group extends GroupSpec.AnyWithProps>(\n    group: Group,\n  ): Spec<Groups_ | Group>;\n\n  addAt<const Name extends string, Group extends GroupSpec.AnyWithProps>(\n    name: Name,\n    group: Group,\n  ): Spec<Groups_ | GroupSpec.NamedAt<Group, Name>>;\n}\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport interface AnyWithProps extends Spec<GroupSpec.AnyWithProps> {}\n\nexport type Groups<Spec_ extends AnyWithProps> =\n  Spec_[\"groups\"][keyof Spec_[\"groups\"]];\n\nconst Proto = {\n  [TypeId]: TypeId,\n\n  add<Group extends GroupSpec.AnyWithProps>(this: AnyWithProps, group: Group) {\n    return makeProto({\n      groups: Record.set(this.groups, group.name, group),\n    });\n  },\n\n  addAt<Group extends GroupSpec.AnyWithProps>(\n    this: AnyWithProps,\n    name: string,\n    group: Group,\n  ) {\n    return makeProto({\n      groups: Record.set(this.groups, name, GroupSpec.withName(name, group)),\n    });\n  },\n};\n\nconst makeProto = <Groups_ extends GroupSpec.AnyWithProps>({\n  groups,\n}: {\n  groups: Record.ReadonlyRecord<string, Groups_>;\n}): Spec<Groups_> =>\n  Object.assign(Object.create(Proto), {\n    groups,\n  });\n\nexport const make = (): Spec => makeProto({ groups: {} });\n"],"mappings":";;;;;;;;;;;AAIA,MAAa,SAAS;AAGtB,MAAa,UAAU,MACrB,UAAU,YAAY,GAAG,OAAO;AAqClC,MAAM,QAAQ;EACX,SAAS;CAEV,IAA8D,OAAc;AAC1E,SAAO,UAAU,EACf,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,MAAM,EACnD,CAAC;;CAGJ,MAEE,MACA,OACA;AACA,SAAO,UAAU,EACf,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAMA,SAAmB,MAAM,MAAM,CAAC,EACvE,CAAC;;CAEL;AAED,MAAM,aAAqD,EACzD,aAIA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE,EAClC,QACD,CAAC;AAEJ,MAAa,aAAmB,UAAU,EAAE,QAAQ,EAAE,EAAE,CAAC"}

package/dist/SystemFields.d.ts

@@ -1,5 +1,5 @@
 import { GenericId } from "./GenericId.js";
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 import { Expand, IdField, SystemFields as SystemFields$1 } from "convex/server";
 
 //#region src/SystemFields.d.ts

package/dist/SystemFields.js

@@ -1,6 +1,6 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { GenericId } from "./GenericId.js";
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 //#region src/SystemFields.ts
 var SystemFields_exports = /* @__PURE__ */ __exportAll({

package/dist/SystemFields.js.map

@@ -1 +1 @@
-{"version":3,"file":"SystemFields.js","names":["GenericId.GenericId"],"sources":["../src/SystemFields.ts"],"sourcesContent":["import type {\n  Expand,\n  IdField,\n  SystemFields as NonIdSystemFields,\n} from \"convex/server\";\nimport { Schema } from \"effect\";\nimport * as GenericId from \"./GenericId\";\n\ntype SystemFieldsSchema<TableName extends string> = Schema.Struct<{\n  _id: Schema.Schema<\n    GenericId.GenericId<TableName>,\n    GenericId.GenericId<TableName>,\n    never\n  >;\n  _creationTime: typeof Schema.Number;\n}>;\n\n/**\n * Produces a schema for Convex system fields.\n */\nexport const SystemFields = <TableName extends string>(\n  tableName: TableName,\n): SystemFieldsSchema<TableName> =>\n  Schema.Struct({\n    _id: GenericId.GenericId(tableName),\n    _creationTime: Schema.Number,\n  });\n\n/**\n * Extend a table schema with Convex system fields.\n */\nexport const extendWithSystemFields = <\n  TableName extends string,\n  TableSchema extends Schema.Schema.AnyNoContext,\n>(\n  tableName: TableName,\n  schema: TableSchema,\n): ExtendWithSystemFields<TableName, TableSchema> =>\n  Schema.extend(SystemFields(tableName), schema);\n\n/**\n * Extend a table schema with Convex system fields at the type level.\n */\nexport type ExtendWithSystemFields<\n  TableName extends string,\n  TableSchema extends Schema.Schema.AnyNoContext,\n> = Schema.extend<SystemFieldsSchema<TableName>, TableSchema>;\n\nexport type WithSystemFields<TableName extends string, Document> = Expand<\n  Readonly<IdField<TableName>> & Readonly<NonIdSystemFields> & Document\n>;\n"],"mappings":";;;;;;;;;;;;AAoBA,MAAa,gBACX,cAEA,OAAO,OAAO;CACZ,KAAKA,UAAoB,UAAU;CACnC,eAAe,OAAO;CACvB,CAAC;;;;AAKJ,MAAa,0BAIX,WACA,WAEA,OAAO,OAAO,aAAa,UAAU,EAAE,OAAO"}
+{"version":3,"file":"SystemFields.js","names":["GenericId.GenericId"],"sources":["../src/SystemFields.ts"],"sourcesContent":["import type {\n  Expand,\n  IdField,\n  SystemFields as NonIdSystemFields,\n} from \"convex/server\";\nimport * as Schema from \"effect/Schema\";\nimport * as GenericId from \"./GenericId\";\n\ntype SystemFieldsSchema<TableName extends string> = Schema.Struct<{\n  _id: Schema.Schema<\n    GenericId.GenericId<TableName>,\n    GenericId.GenericId<TableName>,\n    never\n  >;\n  _creationTime: typeof Schema.Number;\n}>;\n\n/**\n * Produces a schema for Convex system fields.\n */\nexport const SystemFields = <TableName extends string>(\n  tableName: TableName,\n): SystemFieldsSchema<TableName> =>\n  Schema.Struct({\n    _id: GenericId.GenericId(tableName),\n    _creationTime: Schema.Number,\n  });\n\n/**\n * Extend a table schema with Convex system fields.\n */\nexport const extendWithSystemFields = <\n  TableName extends string,\n  TableSchema extends Schema.Schema.AnyNoContext,\n>(\n  tableName: TableName,\n  schema: TableSchema,\n): ExtendWithSystemFields<TableName, TableSchema> =>\n  Schema.extend(SystemFields(tableName), schema);\n\n/**\n * Extend a table schema with Convex system fields at the type level.\n */\nexport type ExtendWithSystemFields<\n  TableName extends string,\n  TableSchema extends Schema.Schema.AnyNoContext,\n> = Schema.extend<SystemFieldsSchema<TableName>, TableSchema>;\n\nexport type WithSystemFields<TableName extends string, Document> = Expand<\n  Readonly<IdField<TableName>> & Readonly<NonIdSystemFields> & Document\n>;\n"],"mappings":";;;;;;;;;;;;AAoBA,MAAa,gBACX,cAEA,OAAO,OAAO;CACZ,KAAKA,UAAoB,UAAU;CACnC,eAAe,OAAO;CACvB,CAAC;;;;AAKJ,MAAa,0BAIX,WACA,WAEA,OAAO,OAAO,aAAa,UAAU,EAAE,OAAO"}

package/dist/Types.d.ts

@@ -1,6 +1,6 @@
-import { Brand } from "effect";
 import { DocumentByName, FieldTypeFromFieldPath, GenericDataModel, GenericDatabaseReader, TableNamesInDataModel } from "convex/server";
 import { GenericId } from "convex/values";
+import { Brand } from "effect";
 
 //#region src/Types.d.ts
 declare namespace Types_d_exports {

package/dist/UserIdentity.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 //#region src/UserIdentity.d.ts
 declare namespace UserIdentity_d_exports {

package/dist/UserIdentity.js

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 //#region src/UserIdentity.ts
 var UserIdentity_exports = /* @__PURE__ */ __exportAll({ UserIdentity: () => UserIdentity });

package/dist/UserIdentity.js.map

@@ -1 +1 @@
-{"version":3,"file":"UserIdentity.js","names":[],"sources":["../src/UserIdentity.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport const UserIdentity = <CustomClaimsFields extends Schema.Struct.Fields>(\n  customClaimsFields: CustomClaimsFields,\n) =>\n  Schema.Struct({\n    ...customClaimsFields,\n    tokenIdentifier: Schema.String,\n    subject: Schema.String,\n    issuer: Schema.String,\n    name: Schema.optionalWith(Schema.String, { exact: true }),\n    givenName: Schema.optionalWith(Schema.String, { exact: true }),\n    familyName: Schema.optionalWith(Schema.String, { exact: true }),\n    nickname: Schema.optionalWith(Schema.String, { exact: true }),\n    preferredUsername: Schema.optionalWith(Schema.String, { exact: true }),\n    profileUrl: Schema.optionalWith(Schema.String, { exact: true }),\n    pictureUrl: Schema.optionalWith(Schema.String, { exact: true }),\n    email: Schema.optionalWith(Schema.String, { exact: true }),\n    emailVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),\n    gender: Schema.optionalWith(Schema.String, { exact: true }),\n    birthday: Schema.optionalWith(Schema.String, { exact: true }),\n    timezone: Schema.optionalWith(Schema.String, { exact: true }),\n    language: Schema.optionalWith(Schema.String, { exact: true }),\n    phoneNumber: Schema.optionalWith(Schema.String, { exact: true }),\n    phoneNumberVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),\n    address: Schema.optionalWith(Schema.String, { exact: true }),\n    updatedAt: Schema.optionalWith(Schema.String, { exact: true }),\n  });\n"],"mappings":";;;;;AAEA,MAAa,gBACX,uBAEA,OAAO,OAAO;CACZ,GAAG;CACH,iBAAiB,OAAO;CACxB,SAAS,OAAO;CAChB,QAAQ,OAAO;CACf,MAAM,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CACzD,WAAW,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC9D,YAAY,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,mBAAmB,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CACtE,YAAY,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,YAAY,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,OAAO,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC1D,eAAe,OAAO,aAAa,OAAO,SAAS,EAAE,OAAO,MAAM,CAAC;CACnE,QAAQ,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC3D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,aAAa,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAChE,qBAAqB,OAAO,aAAa,OAAO,SAAS,EAAE,OAAO,MAAM,CAAC;CACzE,SAAS,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC5D,WAAW,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,CAAC"}
+{"version":3,"file":"UserIdentity.js","names":[],"sources":["../src/UserIdentity.ts"],"sourcesContent":["import * as Schema from \"effect/Schema\";\n\nexport const UserIdentity = <CustomClaimsFields extends Schema.Struct.Fields>(\n  customClaimsFields: CustomClaimsFields,\n) =>\n  Schema.Struct({\n    ...customClaimsFields,\n    tokenIdentifier: Schema.String,\n    subject: Schema.String,\n    issuer: Schema.String,\n    name: Schema.optionalWith(Schema.String, { exact: true }),\n    givenName: Schema.optionalWith(Schema.String, { exact: true }),\n    familyName: Schema.optionalWith(Schema.String, { exact: true }),\n    nickname: Schema.optionalWith(Schema.String, { exact: true }),\n    preferredUsername: Schema.optionalWith(Schema.String, { exact: true }),\n    profileUrl: Schema.optionalWith(Schema.String, { exact: true }),\n    pictureUrl: Schema.optionalWith(Schema.String, { exact: true }),\n    email: Schema.optionalWith(Schema.String, { exact: true }),\n    emailVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),\n    gender: Schema.optionalWith(Schema.String, { exact: true }),\n    birthday: Schema.optionalWith(Schema.String, { exact: true }),\n    timezone: Schema.optionalWith(Schema.String, { exact: true }),\n    language: Schema.optionalWith(Schema.String, { exact: true }),\n    phoneNumber: Schema.optionalWith(Schema.String, { exact: true }),\n    phoneNumberVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),\n    address: Schema.optionalWith(Schema.String, { exact: true }),\n    updatedAt: Schema.optionalWith(Schema.String, { exact: true }),\n  });\n"],"mappings":";;;;;AAEA,MAAa,gBACX,uBAEA,OAAO,OAAO;CACZ,GAAG;CACH,iBAAiB,OAAO;CACxB,SAAS,OAAO;CAChB,QAAQ,OAAO;CACf,MAAM,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CACzD,WAAW,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC9D,YAAY,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,mBAAmB,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CACtE,YAAY,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,YAAY,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,OAAO,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC1D,eAAe,OAAO,aAAa,OAAO,SAAS,EAAE,OAAO,MAAM,CAAC;CACnE,QAAQ,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC3D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,aAAa,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAChE,qBAAqB,OAAO,aAAa,OAAO,SAAS,EAAE,OAAO,MAAM,CAAC;CACzE,SAAS,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC5D,WAAW,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@confect/core",
   "description": "Shared specs and schemas used by all Confect packages",
-  "version": "9.0.0-next.7",
+  "version": "9.0.0-next.9",
   "author": "RJ Dellecese",
   "bugs": {
     "url": "https://github.com/rjdellecese/confect/issues"

package/src/FunctionProvenance.ts

@@ -1,6 +1,6 @@
 import type { DefaultFunctionArgs } from "convex/server";
 import type { Schema } from "effect";
-import { Data } from "effect";
+import * as Data from "effect/Data";
 import * as Lazy from "./Lazy";
 
 export type FunctionProvenance = Data.TaggedEnum<{

package/src/FunctionSpec.ts

@@ -6,7 +6,7 @@ import type {
   RegisteredQuery,
 } from "convex/server";
 import type { Schema } from "effect";
-import { Predicate } from "effect";
+import * as Predicate from "effect/Predicate";
 import * as FunctionProvenance from "./FunctionProvenance";
 import { validateConfectFunctionIdentifier } from "./Identifier";
 import * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";

package/src/GenericId.ts

@@ -1,5 +1,7 @@
 import type { GenericId as ConvexGenericId } from "convex/values";
-import { type Option, Schema, SchemaAST } from "effect";
+import type { Option } from "effect";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
 
 const ConvexId = Symbol.for("ConvexId");
 

package/src/GroupSpec.ts

@@ -1,4 +1,5 @@
-import { Predicate, Record } from "effect";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
 import type * as FunctionSpec from "./FunctionSpec";
 import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 import { validateConfectFunctionIdentifier } from "./Identifier";
@@ -13,7 +14,11 @@ export interface GroupSpec<
   Runtime extends RuntimeAndFunctionType.Runtime,
   Name_ extends string,
   Functions_ extends FunctionSpec.AnyWithPropsWithRuntime<Runtime> = never,
-  Groups_ extends AnyWithPropsWithRuntime<Runtime> = never,
+  // Subgroups may be of any runtime, independent of this group's own runtime: a
+  // group is only a namespace for its children, which are otherwise-independent
+  // modules. Functions, by contrast, stay homogeneous (a Node group only accepts
+  // Node actions) — `addFunction` keeps the `<Runtime>` bound below.
+  Groups_ extends AnyWithProps = never,
 > {
   readonly [TypeId]: TypeId;
   readonly runtime: Runtime;
@@ -31,14 +36,11 @@ export interface GroupSpec<
     function_: Function,
   ): GroupSpec<Runtime, Name_, Functions_ | Function, Groups_>;
 
-  addGroup<Group extends AnyWithPropsWithRuntime<Runtime>>(
+  addGroup<Group extends AnyWithProps>(
     group: Group,
   ): GroupSpec<Runtime, Name_, Functions_, Groups_ | Group>;
 
-  addGroupAt<
-    const AtName extends string,
-    Group extends AnyWithPropsWithRuntime<Runtime>,
-  >(
+  addGroupAt<const AtName extends string, Group extends AnyWithProps>(
     name: AtName,
     group: Group,
   ): GroupSpec<Runtime, Name_, Functions_, Groups_ | NamedAt<Group, AtName>>;

package/src/PaginationResult.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 export const PaginationResult = <Doc extends Schema.Schema.AnyNoContext>(
   Doc: Doc,

package/src/Ref.ts

@@ -6,7 +6,10 @@ import { makeFunctionReference } from "convex/server";
 import type { Value } from "convex/values";
 import { ConvexError } from "convex/values";
 import type { ParseResult } from "effect";
-import { Effect, Match, Option, Schema } from "effect";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
 import type * as FunctionSpec from "./FunctionSpec";
 import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 

package/src/Refs.ts

@@ -1,30 +1,16 @@
 import type { Types } from "effect";
-import { Array, Option, pipe, Record } from "effect";
+import { pipe } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Record from "effect/Record";
 import type * as FunctionSpec from "./FunctionSpec";
-import * as GroupSpec from "./GroupSpec";
+import type * as GroupSpec from "./GroupSpec";
 import * as Ref from "./Ref";
 import type * as Spec from "./Spec";
 
 export type Refs<
-  ConvexSpec extends Spec.AnyWithPropsWithRuntime<"Convex">,
-  NodeSpec extends Spec.AnyWithPropsWithRuntime<"Node"> = never,
+  Spec_ extends Spec.AnyWithProps,
   Predicate extends Ref.Any = Ref.Any,
-> = Types.Simplify<
-  OmitEmpty<
-    Helper<
-      | Spec.Groups<ConvexSpec>
-      | (NodeSpec extends never
-          ? never
-          : GroupSpec.GroupSpec<
-              "Node",
-              "node",
-              never,
-              NodeSpec["groups"][keyof NodeSpec["groups"]]
-            >),
-      Predicate
-    >
-  >
->;
+> = Types.Simplify<OmitEmpty<Helper<Spec.Groups<Spec_>, Predicate>>>;
 
 type GroupRefs<
   Group extends GroupSpec.AnyWithProps,
@@ -86,33 +72,16 @@ type Any =
     }
   | Ref.Any;
 
-export const make = <
-  ConvexSpec extends Spec.AnyWithPropsWithRuntime<"Convex">,
-  NodeSpec extends Spec.AnyWithPropsWithRuntime<"Node"> = never,
->(
-  convexSpec: ConvexSpec,
-  nodeSpec?: NodeSpec,
+export const make = <Spec_ extends Spec.AnyWithProps>(
+  spec: Spec_,
 ): {
-  public: Refs<ConvexSpec, NodeSpec, Ref.AnyPublic>;
-  internal: Refs<ConvexSpec, NodeSpec, Ref.AnyInternal>;
+  public: Refs<Spec_, Ref.AnyPublic>;
+  internal: Refs<Spec_, Ref.AnyInternal>;
 } => {
-  const groups = Option.fromNullable(nodeSpec).pipe(
-    Option.map((nodeSpec_) =>
-      Array.reduce(
-        Record.toEntries(nodeSpec_.groups),
-        GroupSpec.makeNodeAt("node"),
-        (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group),
-      ),
-    ),
-    Option.match({
-      onNone: () => convexSpec.groups,
-      onSome: (nodeGroup) => ({ ...convexSpec.groups, node: nodeGroup }),
-    }),
-  );
-  const refs = makeHelper(groups);
+  const refs = makeHelper(spec.groups);
   return {
-    public: refs as Refs<ConvexSpec, NodeSpec, Ref.AnyPublic>,
-    internal: refs as Refs<ConvexSpec, NodeSpec, Ref.AnyInternal>,
+    public: refs as Refs<Spec_, Ref.AnyPublic>,
+    internal: refs as Refs<Spec_, Ref.AnyInternal>,
   };
 };
 

package/src/Registry.ts

@@ -1,4 +1,5 @@
-import { Context, Ref } from "effect";
+import * as Context from "effect/Context";
+import * as Ref from "effect/Ref";
 
 /**
  * Recursive tree that mirrors a `Spec`'s group structure. Leaves are the