@confect/core 1.0.0-next.3 → 1.0.0

package/dist/Refs.js

@@ -1,11 +1,16 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { makeNode } from "./GroupSpec.js";
 import { getConvexFunctionName, make as make$1 } from "./Ref.js";
-import { Record, pipe } from "effect";
+import { Array, Record, pipe } from "effect";
 
 //#region src/Refs.ts
 var Refs_exports = /* @__PURE__ */ __exportAll({ make: () => make });
-const make = (spec) => {
-	const refs = makeHelper(spec.groups);
+const make = (convexSpec, nodeSpec) => {
+	const nodeGroup = nodeSpec ? Array.reduce(Record.values(nodeSpec.groups), makeNode("node"), (nodeGroupSpec, group) => nodeGroupSpec.addGroup(group)) : null;
+	const refs = makeHelper(nodeGroup ? {
+		...convexSpec.groups,
+		node: nodeGroup
+	} : convexSpec.groups);
 	return {
 		public: refs,
 		internal: refs

package/dist/Refs.js.map

@@ -1 +1 @@
-{"version":3,"file":"Refs.js","names":["Ref.make","Ref.getConvexFunctionName"],"sources":["../src/Refs.ts"],"sourcesContent":["import type { Types } from \"effect\";\nimport { pipe, Record } from \"effect\";\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 FilteredFunctions<\n  Functions extends FunctionSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> = {\n  [Name in FunctionSpec.Name<Functions> as FunctionSpec.WithName<\n    Functions,\n    Name\n  > extends infer F extends FunctionSpec.AnyWithProps\n    ? Ref.FromFunctionSpec<F> extends Predicate\n      ? Name\n      : never\n    : never]: FunctionSpec.WithName<Functions, 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  groupPath: string | null = null,\n): Any =>\n  pipe(\n    groups as Record.ReadonlyRecord<string, GroupSpec.AnyWithProps>,\n    Record.map((group) => {\n      const currentGroupPath = groupPath\n        ? `${groupPath}/${group.name}`\n        : group.name;\n\n      return Record.union(\n        makeHelper(group.groups, currentGroupPath),\n        Record.map(group.functions, (function_) =>\n          Ref.make(`${currentGroupPath}:${function_.name}`, 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":";;;;;;AA2DA,MAAa,QACX,SAIG;CACH,MAAM,OAAO,WAAW,KAAK,OAAO;AACpC,QAAO;EACL,QAAQ;EACR,UAAU;EACX;;AAGH,MAAM,cACJ,QACA,YAA2B,SAE3B,KACE,QACA,OAAO,KAAK,UAAU;CACpB,MAAM,mBAAmB,YACrB,GAAG,UAAU,GAAG,MAAM,SACtB,MAAM;AAEV,QAAO,OAAO,MACZ,WAAW,MAAM,QAAQ,iBAAiB,EAC1C,OAAO,IAAI,MAAM,YAAY,cAC3BA,OAAS,GAAG,iBAAiB,GAAG,UAAU,QAAQ,UAAU,CAC7D,GACA,WAAW,cAAc;AACxB,QAAM,IAAI,MACR,qDAAqDC,sBAA0B,UAAU,CAAC,IAC3F;GAEJ;EACD,CACH"}
+{"version":3,"file":"Refs.js","names":["GroupSpec.makeNode","Ref.make","Ref.getConvexFunctionName"],"sources":["../src/Refs.ts"],"sourcesContent":["import type { Types } from \"effect\";\nimport { Array, 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 FilteredFunctions<\n  Functions extends FunctionSpec.AnyWithProps,\n  Predicate extends Ref.Any,\n> = {\n  [Name in FunctionSpec.Name<Functions> as FunctionSpec.WithName<\n    Functions,\n    Name\n  > extends infer F extends FunctionSpec.AnyWithProps\n    ? Ref.FromFunctionSpec<F> extends Predicate\n      ? Name\n      : never\n    : never]: FunctionSpec.WithName<Functions, 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 nodeGroup = nodeSpec\n    ? Array.reduce(\n        Record.values(nodeSpec.groups),\n        GroupSpec.makeNode(\"node\"),\n        (nodeGroupSpec, group) => nodeGroupSpec.addGroup(group),\n      )\n    : null;\n\n  const groups = nodeGroup\n    ? { ...convexSpec.groups, node: nodeGroup }\n    : convexSpec.groups;\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  groupPath: string | null = null,\n): Any =>\n  pipe(\n    groups as Record.ReadonlyRecord<string, GroupSpec.AnyWithProps>,\n    Record.map((group) => {\n      const currentGroupPath = groupPath\n        ? `${groupPath}/${group.name}`\n        : group.name;\n\n      return Record.union(\n        makeHelper(group.groups, currentGroupPath),\n        Record.map(group.functions, (function_) =>\n          Ref.make(`${currentGroupPath}:${function_.name}`, 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":";;;;;;;AA2EA,MAAa,QAIX,YACA,aAIG;CACH,MAAM,YAAY,WACd,MAAM,OACJ,OAAO,OAAO,SAAS,OAAO,EAC9BA,SAAmB,OAAO,GACzB,eAAe,UAAU,cAAc,SAAS,MAAM,CACxD,GACD;CAKJ,MAAM,OAAO,WAHE,YACX;EAAE,GAAG,WAAW;EAAQ,MAAM;EAAW,GACzC,WAAW,OACgB;AAC/B,QAAO;EACL,QAAQ;EACR,UAAU;EACX;;AAGH,MAAM,cACJ,QACA,YAA2B,SAE3B,KACE,QACA,OAAO,KAAK,UAAU;CACpB,MAAM,mBAAmB,YACrB,GAAG,UAAU,GAAG,MAAM,SACtB,MAAM;AAEV,QAAO,OAAO,MACZ,WAAW,MAAM,QAAQ,iBAAiB,EAC1C,OAAO,IAAI,MAAM,YAAY,cAC3BC,OAAS,GAAG,iBAAiB,GAAG,UAAU,QAAQ,UAAU,CAC7D,GACA,WAAW,cAAc;AACxB,QAAM,IAAI,MACR,qDAAqDC,sBAA0B,UAAU,CAAC,IAC3F;GAEJ;EACD,CACH"}

package/dist/RuntimeAndFunctionType.d.ts

@@ -0,0 +1,54 @@
+declare namespace RuntimeAndFunctionType_d_exports {
+  export { AnyAction, AnyMutation, AnyQuery, ConvexAction, ConvexMutation, ConvexQuery, GetFunctionType, GetRuntime, NodeAction, Runtime, RuntimeAndFunctionType, WithRuntime };
+}
+type RuntimeAndFunctionType = {
+  readonly runtime: "Convex";
+  readonly functionType: "query";
+} | {
+  readonly runtime: "Convex";
+  readonly functionType: "mutation";
+} | {
+  readonly runtime: "Convex";
+  readonly functionType: "action";
+} | {
+  readonly runtime: "Node";
+  readonly functionType: "action";
+};
+type Runtime = RuntimeAndFunctionType["runtime"];
+type AnyQuery = Extract<RuntimeAndFunctionType, {
+  readonly functionType: "query";
+}>;
+type AnyMutation = Extract<RuntimeAndFunctionType, {
+  readonly functionType: "mutation";
+}>;
+type AnyAction = Extract<RuntimeAndFunctionType, {
+  readonly functionType: "action";
+}>;
+type WithRuntime<Runtime_ extends Runtime> = Extract<RuntimeAndFunctionType, {
+  readonly runtime: Runtime_;
+}>;
+type GetRuntime<RuntimeAndFunctionType_ extends RuntimeAndFunctionType> = RuntimeAndFunctionType_["runtime"];
+type GetFunctionType<RuntimeAndFunctionType_ extends RuntimeAndFunctionType> = RuntimeAndFunctionType_["functionType"];
+declare const ConvexQuery: {
+  readonly runtime: "Convex";
+  readonly functionType: "query";
+};
+type ConvexQuery = typeof ConvexQuery;
+declare const ConvexMutation: {
+  readonly runtime: "Convex";
+  readonly functionType: "mutation";
+};
+type ConvexMutation = typeof ConvexMutation;
+declare const ConvexAction: {
+  readonly runtime: "Convex";
+  readonly functionType: "action";
+};
+type ConvexAction = typeof ConvexAction;
+declare const NodeAction: {
+  readonly runtime: "Node";
+  readonly functionType: "action";
+};
+type NodeAction = typeof NodeAction;
+//#endregion
+export { AnyAction, AnyMutation, AnyQuery, ConvexAction, ConvexMutation, ConvexQuery, GetFunctionType, GetRuntime, NodeAction, Runtime, RuntimeAndFunctionType, RuntimeAndFunctionType_d_exports, WithRuntime };
+//# sourceMappingURL=RuntimeAndFunctionType.d.ts.map

package/dist/RuntimeAndFunctionType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeAndFunctionType.d.ts","names":[],"sources":["../src/RuntimeAndFunctionType.ts"],"mappings":";;;KAAY,sBAAA;EAAA,SACG,OAAA;EAAA,SAA4B,YAAA;AAAA;EAAA,SAC5B,OAAA;EAAA,SAA4B,YAAA;AAAA;EAAA,SAC5B,OAAA;EAAA,SAA4B,YAAA;AAAA;EAAA,SAC5B,OAAA;EAAA,SAA0B,YAAA;AAAA;AAAA,KAE7B,OAAA,GAAU,sBAAA;AAAA,KAaV,QAAA,GAAW,OAAA,CACrB,sBAAA;EAAA,SACW,YAAA;AAAA;AAAA,KAGD,WAAA,GAAc,OAAA,CACxB,sBAAA;EAAA,SACW,YAAA;AAAA;AAAA,KAGD,SAAA,GAAY,OAAA,CACtB,sBAAA;EAAA,SACW,YAAA;AAAA;AAAA,KAGD,WAAA,kBAA6B,OAAA,IAAW,OAAA,CAClD,sBAAA;EAAA,SACW,OAAA,EAAS,QAAA;AAAA;AAAA,KAGV,UAAA,iCAA2C,sBAAA,IACrD,uBAAA;AAAA,KAEU,eAAA,iCACsB,sBAAA,IAC9B,uBAAA;AAAA,cAES,WAAA;EAAA,SAAqC,OAAA;EAAA,SAAA,YAAA;AAAA;AAAA,KACtC,WAAA,UAAqB,WAAA;AAAA,cAEpB,cAAA;EAAA,SAA2C,OAAA;EAAA,SAAA,YAAA;AAAA;AAAA,KAC5C,cAAA,UAAwB,cAAA;AAAA,cAEvB,YAAA;EAAA,SAAuC,OAAA;EAAA,SAAA,YAAA;AAAA;AAAA,KACxC,YAAA,UAAsB,YAAA;AAAA,cAErB,UAAA;EAAA,SAAmC,OAAA;EAAA,SAAA,YAAA;AAAA;AAAA,KACpC,UAAA,UAAoB,UAAA"}

package/dist/RuntimeAndFunctionType.js

@@ -0,0 +1,21 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+
+//#region src/RuntimeAndFunctionType.ts
+var RuntimeAndFunctionType_exports = /* @__PURE__ */ __exportAll({
+	ConvexAction: () => ConvexAction,
+	ConvexMutation: () => ConvexMutation,
+	ConvexQuery: () => ConvexQuery,
+	NodeAction: () => NodeAction
+});
+const make = (runtime, functionType) => ({
+	runtime,
+	functionType
+});
+const ConvexQuery = make("Convex", "query");
+const ConvexMutation = make("Convex", "mutation");
+const ConvexAction = make("Convex", "action");
+const NodeAction = make("Node", "action");
+
+//#endregion
+export { ConvexAction, ConvexMutation, ConvexQuery, NodeAction, RuntimeAndFunctionType_exports };
+//# sourceMappingURL=RuntimeAndFunctionType.js.map

package/dist/RuntimeAndFunctionType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeAndFunctionType.js","names":[],"sources":["../src/RuntimeAndFunctionType.ts"],"sourcesContent":["export type RuntimeAndFunctionType =\n  | { readonly runtime: \"Convex\"; readonly functionType: \"query\" }\n  | { readonly runtime: \"Convex\"; readonly functionType: \"mutation\" }\n  | { readonly runtime: \"Convex\"; readonly functionType: \"action\" }\n  | { readonly runtime: \"Node\"; readonly functionType: \"action\" };\n\nexport type Runtime = RuntimeAndFunctionType[\"runtime\"];\n\nconst make = <\n  Runtime_ extends Runtime,\n  FunctionType_ extends GetFunctionType<WithRuntime<Runtime_>>,\n>(\n  runtime: Runtime_,\n  functionType: FunctionType_,\n): { readonly runtime: Runtime_; readonly functionType: FunctionType_ } => ({\n  runtime,\n  functionType,\n});\n\nexport type AnyQuery = Extract<\n  RuntimeAndFunctionType,\n  { readonly functionType: \"query\" }\n>;\n\nexport type AnyMutation = Extract<\n  RuntimeAndFunctionType,\n  { readonly functionType: \"mutation\" }\n>;\n\nexport type AnyAction = Extract<\n  RuntimeAndFunctionType,\n  { readonly functionType: \"action\" }\n>;\n\nexport type WithRuntime<Runtime_ extends Runtime> = Extract<\n  RuntimeAndFunctionType,\n  { readonly runtime: Runtime_ }\n>;\n\nexport type GetRuntime<RuntimeAndFunctionType_ extends RuntimeAndFunctionType> =\n  RuntimeAndFunctionType_[\"runtime\"];\n\nexport type GetFunctionType<\n  RuntimeAndFunctionType_ extends RuntimeAndFunctionType,\n> = RuntimeAndFunctionType_[\"functionType\"];\n\nexport const ConvexQuery = make(\"Convex\", \"query\");\nexport type ConvexQuery = typeof ConvexQuery;\n\nexport const ConvexMutation = make(\"Convex\", \"mutation\");\nexport type ConvexMutation = typeof ConvexMutation;\n\nexport const ConvexAction = make(\"Convex\", \"action\");\nexport type ConvexAction = typeof ConvexAction;\n\nexport const NodeAction = make(\"Node\", \"action\");\nexport type NodeAction = typeof NodeAction;\n"],"mappings":";;;;;;;;;AAQA,MAAM,QAIJ,SACA,kBAC0E;CAC1E;CACA;CACD;AA6BD,MAAa,cAAc,KAAK,UAAU,QAAQ;AAGlD,MAAa,iBAAiB,KAAK,UAAU,WAAW;AAGxD,MAAa,eAAe,KAAK,UAAU,SAAS;AAGpD,MAAa,aAAa,KAAK,QAAQ,SAAS"}

package/dist/Spec.d.ts

@@ -1,23 +1,35 @@
-import { AnyWithProps as AnyWithProps$1, Name, WithName } from "./GroupSpec.js";
+import { Runtime } from "./RuntimeAndFunctionType.js";
+import { AnyWithProps as AnyWithProps$1, AnyWithPropsWithRuntime as AnyWithPropsWithRuntime$1, Name, WithName } from "./GroupSpec.js";
 
 //#region src/Spec.d.ts
 declare namespace Spec_d_exports {
-  export { Any, AnyWithProps, Groups, Spec, TypeId, isSpec, make };
+  export { Any, AnyWithProps, AnyWithPropsWithRuntime, Groups, Spec, TypeId, isConvexSpec, isNodeSpec, isSpec, make, makeNode, merge };
 }
-declare const TypeId = "@confect/core/api/Spec";
+declare const TypeId = "@confect/core/Spec";
 type TypeId = typeof TypeId;
 declare const isSpec: (u: unknown) => u is AnyWithProps;
-interface Spec<Groups_ extends AnyWithProps$1 = never> {
+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> {
   readonly [TypeId]: TypeId;
+  readonly runtime: Runtime$2;
   readonly groups: { [GroupName in Name<Groups_>]: WithName<Groups_, GroupName> };
-  add<Group extends AnyWithProps$1>(group: Group): Spec<Groups_ | Group>;
+  add<Group extends AnyWithPropsWithRuntime$1<Runtime$2>>(group: Group): Spec<Runtime$2, Groups_ | Group>;
 }
 interface Any {
   readonly [TypeId]: TypeId;
 }
-interface AnyWithProps extends Spec<AnyWithProps$1> {}
+interface AnyWithProps extends Spec<Runtime, AnyWithProps$1> {}
+interface AnyWithPropsWithRuntime<Runtime$1 extends Runtime> extends Spec<Runtime$1, AnyWithPropsWithRuntime$1<Runtime$1>> {}
 type Groups<Spec_ extends AnyWithProps> = Spec_["groups"][keyof Spec_["groups"]];
-declare const make: () => Spec;
+declare const make: () => Spec<"Convex">;
+declare const makeNode: () => Spec<"Node">;
+/**
+ * Merges a Convex spec with an optional Node spec for use with `Api.make`.
+ * 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;
 //#endregion
-export { Any, AnyWithProps, Groups, Spec, Spec_d_exports, TypeId, isSpec, make };
+export { Any, AnyWithProps, AnyWithPropsWithRuntime, Groups, Spec, Spec_d_exports, TypeId, isConvexSpec, isNodeSpec, isSpec, make, makeNode, merge };
 //# 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":";;;;;;cAGa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,MAAA,GAAU,CAAA,cAAa,CAAA,IAAK,YAAA;AAAA,UAGxB,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;AAAA;AAAA,UAGH,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,cAqBX,IAAA,QAAW,IAAA"}
+{"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;AAAA;AAAA,UAGZ,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,cA4BX,IAAA,QAAW,IAAA;AAAA,cAGX,QAAA,QAAe,IAAA;;;;;AA9E5B;cAsFa,KAAA,sBACQ,uBAAA,6BACF,uBAAA,UAEjB,UAAA,EAAY,UAAA,EACZ,QAAA,GAAW,QAAA,KACV,YAAA"}

package/dist/Spec.js

@@ -1,23 +1,59 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Predicate, Record } from "effect";
+import { makeNode as makeNode$1 } from "./GroupSpec.js";
+import { Array, Predicate, Record } from "effect";
 
 //#region src/Spec.ts
 var Spec_exports = /* @__PURE__ */ __exportAll({
 	TypeId: () => TypeId,
+	isConvexSpec: () => isConvexSpec,
+	isNodeSpec: () => isNodeSpec,
 	isSpec: () => isSpec,
-	make: () => make
+	make: () => make,
+	makeNode: () => makeNode,
+	merge: () => merge
 });
-const TypeId = "@confect/core/api/Spec";
+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({ groups: Record.set(this.groups, group.name, group) });
+		return makeProto({
+			runtime: this.runtime,
+			groups: Record.set(this.groups, group.name, group)
+		});
 	}
 };
-const makeProto = ({ groups }) => Object.assign(Object.create(Proto), { groups });
-const make = () => makeProto({ groups: {} });
+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 for use with `Api.make`.
+* When `nodeSpec` is provided, its groups are merged under a "node" namespace,
+* mirroring the structure used by `Refs.make`.
+*/
+const merge = (convexSpec, nodeSpec) => {
+	const nodeGroup = nodeSpec ? Array.reduce(Record.values(nodeSpec.groups), makeNode$1("node"), (nodeGroupSpec, group) => nodeGroupSpec.addGroup(group)) : null;
+	const groups = nodeGroup ? {
+		...convexSpec.groups,
+		node: nodeGroup
+	} : convexSpec.groups;
+	return Object.assign(Object.create(Proto), {
+		runtime: "Convex",
+		groups
+	});
+};
 
 //#endregion
-export { Spec_exports, TypeId, isSpec, make };
+export { Spec_exports, TypeId, isConvexSpec, isNodeSpec, isSpec, make, makeNode, merge };
 //# sourceMappingURL=Spec.js.map

package/dist/Spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"Spec.js","names":[],"sources":["../src/Spec.ts"],"sourcesContent":["import { Predicate, Record } from \"effect\";\nimport type * as GroupSpec from \"./GroupSpec\";\n\nexport const TypeId = \"@confect/core/api/Spec\";\nexport type TypeId = typeof TypeId;\n\nexport const isSpec = (u: unknown): u is AnyWithProps =>\n  Predicate.hasProperty(u, TypeId);\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\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\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":";;;;;;;;;AAGA,MAAa,SAAS;AAGtB,MAAa,UAAU,MACrB,UAAU,YAAY,GAAG,OAAO;AAyBlC,MAAM,QAAQ;EACX,SAAS;CAEV,IAA8D,OAAc;AAC1E,SAAO,UAAU,EACf,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,MAAM,EACnD,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"}
+{"version":3,"file":"Spec.js","names":["GroupSpec.makeNode"],"sources":["../src/Spec.ts"],"sourcesContent":["import { Array, 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\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\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 for use with `Api.make`.\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 nodeGroup = nodeSpec\n    ? Array.reduce(\n        Record.values(nodeSpec.groups),\n        GroupSpec.makeNode(\"node\"),\n        (nodeGroupSpec, group) => nodeGroupSpec.addGroup(group),\n      )\n    : null;\n\n  const groups = nodeGroup\n    ? { ...convexSpec.groups, node: nodeGroup }\n    : convexSpec.groups;\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;AAoChB,MAAM,QAAQ;EACX,SAAS;CAEV,IAA8D,OAAc;AAC1E,SAAO,UAAU;GACf,SAAS,KAAK;GACd,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,MAAM;GACnD,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;;;;;;AAO5C,MAAa,SAIX,YACA,aACiB;CACjB,MAAM,YAAY,WACd,MAAM,OACJ,OAAO,OAAO,SAAS,OAAO,EAC9BA,WAAmB,OAAO,GACzB,eAAe,UAAU,cAAc,SAAS,MAAM,CACxD,GACD;CAEJ,MAAM,SAAS,YACX;EAAE,GAAG,WAAW;EAAQ,MAAM;EAAW,GACzC,WAAW;AAEf,QAAO,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;EACzC,SAAS;EACT;EACD,CAAC"}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { RuntimeAndFunctionType_d_exports } from "./RuntimeAndFunctionType.js";
 import { FunctionSpec_d_exports } from "./FunctionSpec.js";
 import { GenericId_d_exports } from "./GenericId.js";
 import { GroupSpec_d_exports } from "./GroupSpec.js";
@@ -9,4 +10,4 @@ import { Refs_d_exports } from "./Refs.js";
 import { SystemFields_d_exports } from "./SystemFields.js";
 import { Types_d_exports } from "./Types.js";
 import { UserIdentity_d_exports } from "./UserIdentity.js";
-export { FunctionSpec_d_exports as FunctionSpec, GenericId_d_exports as GenericId, GroupPath_d_exports as GroupPath, GroupSpec_d_exports as GroupSpec, PaginationResult_d_exports as PaginationResult, Ref_d_exports as Ref, Refs_d_exports as Refs, Spec_d_exports as Spec, SystemFields_d_exports as SystemFields, Types_d_exports as Types, UserIdentity_d_exports as UserIdentity };
+export { FunctionSpec_d_exports as FunctionSpec, GenericId_d_exports as GenericId, GroupPath_d_exports as GroupPath, GroupSpec_d_exports as GroupSpec, PaginationResult_d_exports as PaginationResult, Ref_d_exports as Ref, Refs_d_exports as Refs, RuntimeAndFunctionType_d_exports as RuntimeAndFunctionType, Spec_d_exports as Spec, SystemFields_d_exports as SystemFields, Types_d_exports as Types, UserIdentity_d_exports as UserIdentity };

package/dist/index.js

@@ -1,3 +1,4 @@
+import { RuntimeAndFunctionType_exports } from "./RuntimeAndFunctionType.js";
 import { FunctionSpec_exports } from "./FunctionSpec.js";
 import { GenericId_exports } from "./GenericId.js";
 import { GroupPath_exports } from "./GroupPath.js";
@@ -10,4 +11,4 @@ import { SystemFields_exports } from "./SystemFields.js";
 import { Types_exports } from "./Types.js";
 import { UserIdentity_exports } from "./UserIdentity.js";
 
-export { FunctionSpec_exports as FunctionSpec, GenericId_exports as GenericId, GroupPath_exports as GroupPath, GroupSpec_exports as GroupSpec, PaginationResult_exports as PaginationResult, Ref_exports as Ref, Refs_exports as Refs, Spec_exports as Spec, SystemFields_exports as SystemFields, Types_exports as Types, UserIdentity_exports as UserIdentity };
+export { FunctionSpec_exports as FunctionSpec, GenericId_exports as GenericId, GroupPath_exports as GroupPath, GroupSpec_exports as GroupSpec, PaginationResult_exports as PaginationResult, Ref_exports as Ref, Refs_exports as Refs, RuntimeAndFunctionType_exports as RuntimeAndFunctionType, Spec_exports as Spec, SystemFields_exports as SystemFields, Types_exports as Types, UserIdentity_exports as UserIdentity };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@confect/core",
-  "version": "1.0.0-next.3",
+  "version": "1.0.0",
   "description": "Shared specs and schemas used by all Confect packages",
   "repository": {
     "type": "git",

package/src/FunctionSpec.ts

@@ -8,22 +8,23 @@ import type {
 import type { Schema } from "effect";
 import { Predicate } from "effect";
 import { validateConfectFunctionIdentifier } from "./internal/utils";
+import * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
-export const TypeId = "@confect/core/api/FunctionSpec";
+export const TypeId = "@confect/core/FunctionSpec";
 export type TypeId = typeof TypeId;
 
 export const isFunctionSpec = (u: unknown): u is AnyWithProps =>
   Predicate.hasProperty(u, TypeId);
 
 export interface FunctionSpec<
-  FunctionType_ extends FunctionType,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
   FunctionVisibility_ extends FunctionVisibility,
   Name_ extends string,
   Args_ extends Schema.Schema.AnyNoContext,
   Returns_ extends Schema.Schema.AnyNoContext,
 > {
   readonly [TypeId]: TypeId;
-  readonly functionType: FunctionType_;
+  readonly runtimeAndFunctionType: RuntimeAndFunctionType_;
   readonly functionVisibility: FunctionVisibility_;
   readonly name: Name_;
   readonly args: Args_;
@@ -35,7 +36,17 @@ export interface Any {
 }
 
 export interface AnyWithProps extends FunctionSpec<
-  FunctionType,
+  RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility,
+  string,
+  Schema.Schema.AnyNoContext,
+  Schema.Schema.AnyNoContext
+> {}
+
+export interface AnyWithPropsWithRuntime<
+  Runtime extends RuntimeAndFunctionType.Runtime,
+> extends FunctionSpec<
+  RuntimeAndFunctionType.WithRuntime<Runtime>,
   FunctionVisibility,
   string,
   Schema.Schema.AnyNoContext,
@@ -43,17 +54,17 @@ export interface AnyWithProps extends FunctionSpec<
 > {}
 
 export interface AnyWithPropsWithFunctionType<
-  FunctionType_ extends FunctionType,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
 > extends FunctionSpec<
-  FunctionType_,
+  RuntimeAndFunctionType_,
   FunctionVisibility,
   string,
   Schema.Schema.AnyNoContext,
   Schema.Schema.AnyNoContext
 > {}
 
-export type GetFunctionType<Function extends AnyWithProps> =
-  Function["functionType"];
+export type GetRuntimeAndFunctionType<Function extends AnyWithProps> =
+  Function["runtimeAndFunctionType"];
 
 export type GetFunctionVisibility<Function extends AnyWithProps> =
   Function["functionVisibility"];
@@ -69,30 +80,47 @@ export type WithName<
   Name_ extends string,
 > = Extract<Function, { readonly name: Name_ }>;
 
+export type WithRuntimeAndFunctionType<
+  Function extends AnyWithProps,
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+> = Extract<
+  Function,
+  { readonly runtimeAndFunctionType: RuntimeAndFunctionType_ }
+>;
+
 export type WithFunctionType<
   Function extends AnyWithProps,
   FunctionType_ extends FunctionType,
-> = Extract<Function, { readonly functionType: FunctionType_ }>;
+> = Extract<
+  Function,
+  { readonly runtimeAndFunctionType: { readonly functionType: FunctionType_ } }
+>;
 
-export type ExcludeName<
+export type WithoutName<
   Function extends AnyWithProps,
   Name_ extends Name<Function>,
 > = Exclude<Function, { readonly name: Name_ }>;
 
 export type RegisteredFunction<Function extends AnyWithProps> =
-  Function["functionType"] extends "query"
+  RuntimeAndFunctionType.GetFunctionType<
+    Function["runtimeAndFunctionType"]
+  > extends "Convex"
     ? RegisteredQuery<
         GetFunctionVisibility<Function>,
         Args<Function>["Encoded"],
         Promise<Returns<Function>["Encoded"]>
       >
-    : Function["functionType"] extends "mutation"
+    : RuntimeAndFunctionType.GetFunctionType<
+          Function["runtimeAndFunctionType"]
+        > extends "mutation"
       ? RegisteredMutation<
           GetFunctionVisibility<Function>,
           Args<Function>["Encoded"],
           Promise<Returns<Function>["Encoded"]>
         >
-      : Function["functionType"] extends "action"
+      : RuntimeAndFunctionType.GetFunctionType<
+            Function["runtimeAndFunctionType"]
+          > extends "action"
         ? RegisteredAction<
             GetFunctionVisibility<Function>,
             Args<Function>["Encoded"],
@@ -106,10 +134,11 @@ const Proto = {
 
 const make =
   <
-    FunctionType_ extends FunctionType,
+    RuntimeAndFunctionType_ extends
+      RuntimeAndFunctionType.RuntimeAndFunctionType,
     FunctionVisibility_ extends FunctionVisibility,
   >(
-    functionType: FunctionType_,
+    runtimeAndFunctionType: RuntimeAndFunctionType_,
     functionVisibility: FunctionVisibility_,
   ) =>
   <
@@ -125,7 +154,7 @@ const make =
     args: Args_;
     returns: Returns_;
   }): FunctionSpec<
-    FunctionType_,
+    RuntimeAndFunctionType_,
     FunctionVisibility_,
     Name_,
     Args_,
@@ -134,7 +163,7 @@ const make =
     validateConfectFunctionIdentifier(name);
 
     return Object.assign(Object.create(Proto), {
-      functionType,
+      runtimeAndFunctionType,
       functionVisibility,
       name,
       args,
@@ -142,11 +171,30 @@ const make =
     });
   };
 
-export const internalQuery = make("query", "internal");
-export const publicQuery = make("query", "public");
-
-export const internalMutation = make("mutation", "internal");
-export const publicMutation = make("mutation", "public");
-
-export const internalAction = make("action", "internal");
-export const publicAction = make("action", "public");
+export const publicQuery = make(RuntimeAndFunctionType.ConvexQuery, "public");
+export const internalQuery = make(
+  RuntimeAndFunctionType.ConvexQuery,
+  "internal",
+);
+export const publicMutation = make(
+  RuntimeAndFunctionType.ConvexMutation,
+  "public",
+);
+export const internalMutation = make(
+  RuntimeAndFunctionType.ConvexMutation,
+  "internal",
+);
+export const publicAction = make(RuntimeAndFunctionType.ConvexAction, "public");
+export const internalAction = make(
+  RuntimeAndFunctionType.ConvexAction,
+  "internal",
+);
+
+export const publicNodeAction = make(
+  RuntimeAndFunctionType.NodeAction,
+  "public",
+);
+export const internalNodeAction = make(
+  RuntimeAndFunctionType.NodeAction,
+  "internal",
+);

package/src/GroupSpec.ts

@@ -1,37 +1,39 @@
 import { Predicate, Record } from "effect";
 import type * as FunctionSpec from "./FunctionSpec";
+import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 import { validateConfectFunctionIdentifier } from "./internal/utils";
 
-export const TypeId = "@confect/core/api/GroupSpec";
+export const TypeId = "@confect/core/GroupSpec";
 export type TypeId = typeof TypeId;
 
 export const isGroupSpec = (u: unknown): u is Any =>
   Predicate.hasProperty(u, TypeId);
 
 export interface GroupSpec<
+  Runtime extends RuntimeAndFunctionType.Runtime,
   Name_ extends string,
-  Functions_ extends FunctionSpec.AnyWithProps = never,
-  Groups_ extends AnyWithProps = never,
+  Functions_ extends FunctionSpec.AnyWithPropsWithRuntime<Runtime> = never,
+  Groups_ extends AnyWithPropsWithRuntime<Runtime> = never,
 > {
   readonly [TypeId]: TypeId;
+  readonly runtime: Runtime;
   readonly name: Name_;
   readonly functions: {
-    [FunctionName in FunctionSpec.Name<Functions_>]: FunctionSpec.WithName<
-      Functions_,
-      FunctionName
-    >;
+    [FunctionName in FunctionSpec.Name<
+      FunctionSpec.AnyWithPropsWithRuntime<Runtime>
+    >]: FunctionSpec.WithName<Functions_, FunctionName>;
   };
   readonly groups: {
     [GroupName in Name<Groups_>]: WithName<Groups_, GroupName>;
   };
 
-  addFunction<Function extends FunctionSpec.AnyWithProps>(
+  addFunction<Function extends FunctionSpec.AnyWithPropsWithRuntime<Runtime>>(
     function_: Function,
-  ): GroupSpec<Name_, Functions_ | Function, Groups_>;
+  ): GroupSpec<Runtime, Name_, Functions_ | Function, Groups_>;
 
-  addGroup<Group extends AnyWithProps>(
+  addGroup<Group extends AnyWithPropsWithRuntime<Runtime>>(
     group: Group,
-  ): GroupSpec<Name_, Functions_, Groups_ | Group>;
+  ): GroupSpec<Runtime, Name_, Functions_, Groups_ | Group>;
 }
 
 export interface Any {
@@ -39,11 +41,21 @@ export interface Any {
 }
 
 export interface AnyWithProps extends GroupSpec<
+  RuntimeAndFunctionType.Runtime,
   string,
   FunctionSpec.AnyWithProps,
   AnyWithProps
 > {}
 
+export interface AnyWithPropsWithRuntime<
+  Runtime extends RuntimeAndFunctionType.Runtime,
+> extends GroupSpec<
+  Runtime,
+  string,
+  FunctionSpec.AnyWithPropsWithRuntime<Runtime>,
+  AnyWithPropsWithRuntime<Runtime>
+> {}
+
 export type Name<Group extends AnyWithProps> = Group["name"];
 
 export type Functions<Group extends AnyWithProps> =
@@ -73,6 +85,7 @@ const Proto = {
     const this_ = this as AnyWithProps;
 
     return makeProto({
+      runtime: this_.runtime,
       name: this_.name,
       functions: Record.set(this_.functions, function_.name, function_),
       groups: this_.groups,
@@ -84,6 +97,7 @@ const Proto = {
     const group_ = group as unknown as AnyWithProps;
 
     return makeProto({
+      runtime: this_.runtime,
       name: this_.name,
       functions: this_.functions,
       groups: Record.set(this_.groups, group_.name, group_),
@@ -92,19 +106,23 @@ const Proto = {
 };
 
 const makeProto = <
+  Runtime extends RuntimeAndFunctionType.Runtime,
   Name_ extends string,
-  Functions_ extends FunctionSpec.AnyWithProps,
-  Groups_ extends AnyWithProps,
+  Functions_ extends FunctionSpec.AnyWithPropsWithRuntime<Runtime>,
+  Groups_ extends AnyWithPropsWithRuntime<Runtime>,
 >({
+  runtime,
   name,
   functions,
   groups,
 }: {
+  runtime: Runtime;
   name: Name_;
   functions: Record.ReadonlyRecord<string, Functions_>;
   groups: Record.ReadonlyRecord<string, Groups_>;
-}): GroupSpec<Name_, Functions_, Groups_> =>
+}): GroupSpec<Runtime, Name_, Functions_, Groups_> =>
   Object.assign(Object.create(Proto), {
+    runtime,
     name,
     functions,
     groups,
@@ -112,10 +130,24 @@ const makeProto = <
 
 export const make = <const Name_ extends string>(
   name: Name_,
-): GroupSpec<Name_> => {
+): GroupSpec<"Convex", Name_> => {
+  validateConfectFunctionIdentifier(name);
+
+  return makeProto({
+    runtime: "Convex",
+    name,
+    functions: Record.empty(),
+    groups: Record.empty(),
+  });
+};
+
+export const makeNode = <const Name_ extends string>(
+  name: Name_,
+): GroupSpec<"Node", Name_> => {
   validateConfectFunctionIdentifier(name);
 
   return makeProto({
+    runtime: "Node",
     name,
     functions: Record.empty(),
     groups: Record.empty(),