@confect/cli 1.0.0-next.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @confect/cli
+
+## 1.0.0-next.0
+
+### Major Changes
+
+- 2ff70a7: Initial release.
+
+### Patch Changes
+
+- Updated dependencies [2ff70a7]
+  - @confect/server@1.0.0-next.0

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright 2024 RJ Dellecese
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/dist/FunctionPath.mjs

@@ -0,0 +1,19 @@
+import { GroupPath } from "./GroupPath.mjs";
+import { Schema } from "effect";
+
+//#region src/FunctionPath.ts
+/**
+* The path to a function in the Confect API.
+*/
+var FunctionPath = class extends Schema.Class("FunctionPath")({
+	groupPath: GroupPath,
+	name: Schema.NonEmptyString
+}) {};
+/**
+* Get the group path from a function path.
+*/
+const groupPath = (functionPath) => functionPath.groupPath;
+
+//#endregion
+export { FunctionPath, groupPath };
+//# sourceMappingURL=FunctionPath.mjs.map

package/dist/FunctionPath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionPath.mjs","names":["GroupPath.GroupPath"],"sources":["../src/FunctionPath.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport * as GroupPath from \"./GroupPath\";\n\n/**\n * The path to a function in the Confect API.\n */\nexport class FunctionPath extends Schema.Class<FunctionPath>(\"FunctionPath\")({\n  // TODO: Support root-level functions (also must be supported in the other packages, e.g. `core` and `server`)\n  groupPath: GroupPath.GroupPath,\n  name: Schema.NonEmptyString,\n}) {}\n\n/**\n * Get the group path from a function path.\n */\nexport const groupPath = (functionPath: FunctionPath): GroupPath.GroupPath =>\n  functionPath.groupPath;\n\n/**\n * Get the function name from a function path.\n */\nexport const name = (functionPath: FunctionPath): string => functionPath.name;\n\n/**\n * Get the function path as a string.\n */\nexport const toString = (functionPath: FunctionPath): string =>\n  `${GroupPath.toString(functionPath.groupPath)}.${functionPath.name}`;\n"],"mappings":";;;;;;;AAMA,IAAa,eAAb,cAAkC,OAAO,MAAoB,eAAe,CAAC;CAE3E,WAAWA;CACX,MAAM,OAAO;CACd,CAAC,CAAC;;;;AAKH,MAAa,aAAa,iBACxB,aAAa"}

package/dist/FunctionPaths.mjs

@@ -0,0 +1,41 @@
+import { append, make as make$1 } from "./GroupPath.mjs";
+import { FunctionPath, groupPath } from "./FunctionPath.mjs";
+import { GroupPaths } from "./GroupPaths.mjs";
+import { HashSet, Option, Record, Schema, pipe } from "effect";
+
+//#region src/FunctionPaths.ts
+const FunctionPaths = Schema.HashSetFromSelf(FunctionPath).pipe(Schema.brand("@confect/cli/FunctionPaths"));
+const make = (spec) => makeHelper(spec.groups, Option.none(), FunctionPaths.make(HashSet.empty()));
+const makeHelper = (groups, currentGroupPath, apiPaths) => Record.reduce(groups, apiPaths, (acc, group, groupName) => {
+	const groupPath$1 = Option.match(currentGroupPath, {
+		onNone: () => make$1([groupName]),
+		onSome: (path) => append(path, groupName)
+	});
+	const accWithFunctions = Record.reduce(group.functions, acc, (acc_, _fn, functionName) => FunctionPaths.make(HashSet.add(acc_, FunctionPath.make({
+		groupPath: groupPath$1,
+		name: functionName
+	}))));
+	return makeHelper(group.groups, Option.some(groupPath$1), accWithFunctions);
+});
+const groupPaths = (functionPaths) => pipe(functionPaths, HashSet.map(groupPath), GroupPaths.make);
+const diff = (previousFunctions, currentFunctions) => {
+	const currentGroups = groupPaths(currentFunctions);
+	const previousGroups = groupPaths(previousFunctions);
+	const groupsAdded = GroupPaths.make(HashSet.difference(currentGroups, previousGroups));
+	const groupsRemoved = GroupPaths.make(HashSet.difference(previousGroups, currentGroups));
+	const functionsAdded = FunctionPaths.make(HashSet.difference(currentFunctions, previousFunctions));
+	const existingGroupsToWhichFunctionsWereAdded = GroupPaths.make(HashSet.intersection(currentGroups, groupPaths(functionsAdded)));
+	const functionsRemoved = FunctionPaths.make(HashSet.difference(previousFunctions, currentFunctions));
+	const existingGroupsToWhichFunctionsWereRemoved = GroupPaths.make(HashSet.intersection(previousGroups, groupPaths(functionsRemoved)));
+	return {
+		functionsAdded,
+		functionsRemoved,
+		groupsRemoved,
+		groupsAdded,
+		groupsChanged: pipe(existingGroupsToWhichFunctionsWereAdded, HashSet.union(existingGroupsToWhichFunctionsWereRemoved), HashSet.difference(HashSet.union(groupsAdded, groupsRemoved)), GroupPaths.make)
+	};
+};
+
+//#endregion
+export { diff, groupPaths, make };
+//# sourceMappingURL=FunctionPaths.mjs.map

package/dist/FunctionPaths.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionPaths.mjs","names":["FunctionPath.FunctionPath","groupPath","GroupPath.make","GroupPath.append","FunctionPath.groupPath"],"sources":["../src/FunctionPaths.ts"],"sourcesContent":["import type { GroupSpec, Spec } from \"@confect/core\";\nimport { HashSet, Option, pipe, Record, Schema } from \"effect\";\nimport * as FunctionPath from \"./FunctionPath\";\nimport * as GroupPath from \"./GroupPath\";\nimport * as GroupPaths from \"./GroupPaths\";\n\nexport const FunctionPaths = Schema.HashSetFromSelf(\n  FunctionPath.FunctionPath,\n).pipe(Schema.brand(\"@confect/cli/FunctionPaths\"));\nexport type FunctionPaths = typeof FunctionPaths.Type;\n\nexport const make = (spec: Spec.AnyWithProps): FunctionPaths =>\n  makeHelper(spec.groups, Option.none(), FunctionPaths.make(HashSet.empty()));\n\nconst makeHelper = (\n  groups: {\n    [key: string]: GroupSpec.AnyWithProps;\n  },\n  currentGroupPath: Option.Option<GroupPath.GroupPath>,\n  apiPaths: FunctionPaths,\n): FunctionPaths =>\n  Record.reduce(groups, apiPaths, (acc, group, groupName) => {\n    const groupPath = Option.match(currentGroupPath, {\n      onNone: () => GroupPath.make([groupName]),\n      onSome: (path) => GroupPath.append(path, groupName),\n    });\n\n    const accWithFunctions = Record.reduce(\n      group.functions,\n      acc,\n      (acc_, _fn, functionName) =>\n        FunctionPaths.make(\n          HashSet.add(\n            acc_,\n            FunctionPath.FunctionPath.make({\n              groupPath,\n              name: functionName,\n            }),\n          ),\n        ),\n    );\n\n    return makeHelper(group.groups, Option.some(groupPath), accWithFunctions);\n  });\n\nexport const groupPaths = (\n  functionPaths: FunctionPaths,\n): GroupPaths.GroupPaths =>\n  pipe(\n    functionPaths,\n    HashSet.map(FunctionPath.groupPath),\n    GroupPaths.GroupPaths.make,\n  );\n\nexport const diff = (\n  previousFunctions: FunctionPaths,\n  currentFunctions: FunctionPaths,\n): {\n  functionsAdded: FunctionPaths;\n  functionsRemoved: FunctionPaths;\n  groupsRemoved: GroupPaths.GroupPaths;\n  groupsAdded: GroupPaths.GroupPaths;\n  groupsChanged: GroupPaths.GroupPaths;\n} => {\n  const currentGroups = groupPaths(currentFunctions);\n  const previousGroups = groupPaths(previousFunctions);\n\n  const groupsAdded = GroupPaths.GroupPaths.make(\n    HashSet.difference(currentGroups, previousGroups),\n  );\n  const groupsRemoved = GroupPaths.GroupPaths.make(\n    HashSet.difference(previousGroups, currentGroups),\n  );\n\n  const functionsAdded = FunctionPaths.make(\n    HashSet.difference(currentFunctions, previousFunctions),\n  );\n  const existingGroupsToWhichFunctionsWereAdded = GroupPaths.GroupPaths.make(\n    HashSet.intersection(currentGroups, groupPaths(functionsAdded)),\n  );\n\n  const functionsRemoved = FunctionPaths.make(\n    HashSet.difference(previousFunctions, currentFunctions),\n  );\n  const existingGroupsToWhichFunctionsWereRemoved = GroupPaths.GroupPaths.make(\n    HashSet.intersection(previousGroups, groupPaths(functionsRemoved)),\n  );\n\n  const groupsChanged = pipe(\n    existingGroupsToWhichFunctionsWereAdded,\n    HashSet.union(existingGroupsToWhichFunctionsWereRemoved),\n    HashSet.difference(HashSet.union(groupsAdded, groupsRemoved)),\n    GroupPaths.GroupPaths.make,\n  );\n\n  return {\n    functionsAdded,\n    functionsRemoved,\n    groupsRemoved,\n    groupsAdded,\n    groupsChanged,\n  };\n};\n"],"mappings":";;;;;;AAMA,MAAa,gBAAgB,OAAO,gBAClCA,aACD,CAAC,KAAK,OAAO,MAAM,6BAA6B,CAAC;AAGlD,MAAa,QAAQ,SACnB,WAAW,KAAK,QAAQ,OAAO,MAAM,EAAE,cAAc,KAAK,QAAQ,OAAO,CAAC,CAAC;AAE7E,MAAM,cACJ,QAGA,kBACA,aAEA,OAAO,OAAO,QAAQ,WAAW,KAAK,OAAO,cAAc;CACzD,MAAMC,cAAY,OAAO,MAAM,kBAAkB;EAC/C,cAAcC,OAAe,CAAC,UAAU,CAAC;EACzC,SAAS,SAASC,OAAiB,MAAM,UAAU;EACpD,CAAC;CAEF,MAAM,mBAAmB,OAAO,OAC9B,MAAM,WACN,MACC,MAAM,KAAK,iBACV,cAAc,KACZ,QAAQ,IACN,mBAC0B,KAAK;EAC7B;EACA,MAAM;EACP,CAAC,CACH,CACF,CACJ;AAED,QAAO,WAAW,MAAM,QAAQ,OAAO,KAAKF,YAAU,EAAE,iBAAiB;EACzE;AAEJ,MAAa,cACX,kBAEA,KACE,eACA,QAAQ,IAAIG,UAAuB,aACb,KACvB;AAEH,MAAa,QACX,mBACA,qBAOG;CACH,MAAM,gBAAgB,WAAW,iBAAiB;CAClD,MAAM,iBAAiB,WAAW,kBAAkB;CAEpD,MAAM,yBAAoC,KACxC,QAAQ,WAAW,eAAe,eAAe,CAClD;CACD,MAAM,2BAAsC,KAC1C,QAAQ,WAAW,gBAAgB,cAAc,CAClD;CAED,MAAM,iBAAiB,cAAc,KACnC,QAAQ,WAAW,kBAAkB,kBAAkB,CACxD;CACD,MAAM,qDAAgE,KACpE,QAAQ,aAAa,eAAe,WAAW,eAAe,CAAC,CAChE;CAED,MAAM,mBAAmB,cAAc,KACrC,QAAQ,WAAW,mBAAmB,iBAAiB,CACxD;CACD,MAAM,uDAAkE,KACtE,QAAQ,aAAa,gBAAgB,WAAW,iBAAiB,CAAC,CACnE;AASD,QAAO;EACL;EACA;EACA;EACA;EACA,eAZoB,KACpB,yCACA,QAAQ,MAAM,0CAA0C,EACxD,QAAQ,WAAW,QAAQ,MAAM,aAAa,cAAc,CAAC,aACvC,KACvB;EAQA"}

package/dist/GroupPath.mjs

@@ -0,0 +1,52 @@
+import { Array, Data, Effect, Option, Record, Schema, String, pipe } from "effect";
+import { Path } from "@effect/platform";
+
+//#region src/GroupPath.ts
+/**
+* The path to a group in the Confect API.
+*/
+var GroupPath = class extends Schema.Class("GroupPath")({ pathSegments: Schema.Data(Schema.NonEmptyArray(Schema.NonEmptyString)) }) {};
+/**
+* Create a GroupPath from path segments.
+*/
+const make = (pathSegments) => GroupPath.make({ pathSegments: Data.array(pathSegments) });
+/**
+* Append a group name to a GroupPath to create a new GroupPath.
+*/
+const append = (groupPath, groupName) => make([...groupPath.pathSegments, groupName]);
+/**
+* Expects a path string of the form `./group1/group2.ts`, relative to the Convex functions directory.
+*/
+const fromGroupModulePath = (groupModulePath) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const { dir, name, ext } = path.parse(groupModulePath);
+	if (ext === ".ts") {
+		const dirSegments = Array.filter(String.split(dir, path.sep), String.isNonEmpty);
+		yield* Effect.logDebug(Array.append(dirSegments, name));
+		return make(Array.append(dirSegments, name));
+	} else return yield* Effect.fail(new GroupModulePathIsNotATypeScriptFileError({ path: groupModulePath }));
+});
+/**
+* Get the module path for a group, relative to the Convex functions directory.
+*/
+const modulePath = (groupPath) => Effect.gen(function* () {
+	return (yield* Path.Path).join(...groupPath.pathSegments) + ".ts";
+});
+const getGroupSpec = (spec, groupPath) => pipe(groupPath.pathSegments, Array.matchLeft({
+	onEmpty: () => Option.none(),
+	onNonEmpty: (head, tail) => pipe(Record.get(spec.groups, head), Option.flatMap((group) => Array.isNonEmptyArray(tail) ? getGroupSpecHelper(group, tail) : Option.some(group)))
+}));
+const getGroupSpecHelper = (group, remainingPath) => pipe(remainingPath, Array.matchLeft({
+	onEmpty: () => Option.some(group),
+	onNonEmpty: (head, tail) => pipe(Record.get(group.groups, head), Option.flatMap((subGroup) => Array.isNonEmptyArray(tail) ? getGroupSpecHelper(subGroup, tail) : Option.some(subGroup)))
+}));
+const toString = (groupPath) => Array.join(groupPath.pathSegments, ".");
+var GroupModulePathIsNotATypeScriptFileError = class extends Schema.TaggedError("GroupModulePathIsNotATypeScriptFileError")("GroupModulePathIsNotATypeScriptFileError", { path: Schema.NonEmptyString }) {
+	get message() {
+		return `Expected group module path to end with .ts, got ${this.path}`;
+	}
+};
+
+//#endregion
+export { GroupPath, append, fromGroupModulePath, getGroupSpec, make, modulePath, toString };
+//# sourceMappingURL=GroupPath.mjs.map

package/dist/GroupPath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupPath.mjs","names":[],"sources":["../src/GroupPath.ts"],"sourcesContent":["import { type GroupSpec, type Spec } from \"@confect/core\";\nimport { Path } from \"@effect/platform\";\nimport {\n  Array,\n  Data,\n  Effect,\n  Option,\n  pipe,\n  Record,\n  Schema,\n  String,\n} from \"effect\";\n\n/**\n * The path to a group in the Confect API.\n */\nexport class GroupPath extends Schema.Class<GroupPath>(\"GroupPath\")({\n  pathSegments: Schema.Data(Schema.NonEmptyArray(Schema.NonEmptyString)),\n}) {}\n\n/**\n * Create a GroupPath from path segments.\n */\nexport const make = (pathSegments: readonly [string, ...string[]]): GroupPath =>\n  GroupPath.make({ pathSegments: Data.array(pathSegments) });\n\n/**\n * Append a group name to a GroupPath to create a new GroupPath.\n */\nexport const append = (groupPath: GroupPath, groupName: string): GroupPath =>\n  make([...groupPath.pathSegments, groupName]);\n\n/**\n * Expects a path string of the form `./group1/group2.ts`, relative to the Convex functions directory.\n */\nexport const fromGroupModulePath = (groupModulePath: string) =>\n  Effect.gen(function* () {\n    const path = yield* Path.Path;\n\n    const { dir, name, ext } = path.parse(groupModulePath);\n\n    if (ext === \".ts\") {\n      const dirSegments = Array.filter(\n        String.split(dir, path.sep),\n        String.isNonEmpty,\n      );\n      yield* Effect.logDebug(Array.append(dirSegments, name));\n      return make(Array.append(dirSegments, name));\n    } else {\n      return yield* Effect.fail(\n        new GroupModulePathIsNotATypeScriptFileError({ path: groupModulePath }),\n      );\n    }\n  });\n\n/**\n * Get the module path for a group, relative to the Convex functions directory.\n */\nexport const modulePath = (groupPath: GroupPath) =>\n  Effect.gen(function* () {\n    const path = yield* Path.Path;\n\n    return path.join(...groupPath.pathSegments) + \".ts\";\n  });\n\nexport const getGroupSpec = (\n  spec: Spec.AnyWithProps,\n  groupPath: GroupPath,\n): Option.Option<GroupSpec.AnyWithProps> =>\n  pipe(\n    groupPath.pathSegments,\n    Array.matchLeft({\n      onEmpty: () => Option.none(),\n      onNonEmpty: (head, tail) =>\n        pipe(\n          Record.get(spec.groups, head),\n          Option.flatMap((group) =>\n            Array.isNonEmptyArray(tail)\n              ? getGroupSpecHelper(group, tail)\n              : Option.some(group),\n          ),\n        ),\n    }),\n  );\n\nconst getGroupSpecHelper = (\n  group: GroupSpec.AnyWithProps,\n  remainingPath: ReadonlyArray<string>,\n): Option.Option<GroupSpec.AnyWithProps> =>\n  pipe(\n    remainingPath,\n    Array.matchLeft({\n      onEmpty: () => Option.some(group),\n      onNonEmpty: (head, tail) =>\n        pipe(\n          Record.get(group.groups, head),\n          Option.flatMap((subGroup) =>\n            Array.isNonEmptyArray(tail)\n              ? getGroupSpecHelper(subGroup, tail)\n              : Option.some(subGroup),\n          ),\n        ),\n    }),\n  );\n\nexport const toString = (groupPath: GroupPath) =>\n  Array.join(groupPath.pathSegments, \".\");\n\nexport class GroupModulePathIsNotATypeScriptFileError extends Schema.TaggedError<GroupModulePathIsNotATypeScriptFileError>(\n  \"GroupModulePathIsNotATypeScriptFileError\",\n)(\"GroupModulePathIsNotATypeScriptFileError\", {\n  path: Schema.NonEmptyString,\n}) {\n  override get message(): string {\n    return `Expected group module path to end with .ts, got ${this.path}`;\n  }\n}\n"],"mappings":";;;;;;;AAgBA,IAAa,YAAb,cAA+B,OAAO,MAAiB,YAAY,CAAC,EAClE,cAAc,OAAO,KAAK,OAAO,cAAc,OAAO,eAAe,CAAC,EACvE,CAAC,CAAC;;;;AAKH,MAAa,QAAQ,iBACnB,UAAU,KAAK,EAAE,cAAc,KAAK,MAAM,aAAa,EAAE,CAAC;;;;AAK5D,MAAa,UAAU,WAAsB,cAC3C,KAAK,CAAC,GAAG,UAAU,cAAc,UAAU,CAAC;;;;AAK9C,MAAa,uBAAuB,oBAClC,OAAO,IAAI,aAAa;CACtB,MAAM,OAAO,OAAO,KAAK;CAEzB,MAAM,EAAE,KAAK,MAAM,QAAQ,KAAK,MAAM,gBAAgB;AAEtD,KAAI,QAAQ,OAAO;EACjB,MAAM,cAAc,MAAM,OACxB,OAAO,MAAM,KAAK,KAAK,IAAI,EAC3B,OAAO,WACR;AACD,SAAO,OAAO,SAAS,MAAM,OAAO,aAAa,KAAK,CAAC;AACvD,SAAO,KAAK,MAAM,OAAO,aAAa,KAAK,CAAC;OAE5C,QAAO,OAAO,OAAO,KACnB,IAAI,yCAAyC,EAAE,MAAM,iBAAiB,CAAC,CACxE;EAEH;;;;AAKJ,MAAa,cAAc,cACzB,OAAO,IAAI,aAAa;AAGtB,SAFa,OAAO,KAAK,MAEb,KAAK,GAAG,UAAU,aAAa,GAAG;EAC9C;AAEJ,MAAa,gBACX,MACA,cAEA,KACE,UAAU,cACV,MAAM,UAAU;CACd,eAAe,OAAO,MAAM;CAC5B,aAAa,MAAM,SACjB,KACE,OAAO,IAAI,KAAK,QAAQ,KAAK,EAC7B,OAAO,SAAS,UACd,MAAM,gBAAgB,KAAK,GACvB,mBAAmB,OAAO,KAAK,GAC/B,OAAO,KAAK,MAAM,CACvB,CACF;CACJ,CAAC,CACH;AAEH,MAAM,sBACJ,OACA,kBAEA,KACE,eACA,MAAM,UAAU;CACd,eAAe,OAAO,KAAK,MAAM;CACjC,aAAa,MAAM,SACjB,KACE,OAAO,IAAI,MAAM,QAAQ,KAAK,EAC9B,OAAO,SAAS,aACd,MAAM,gBAAgB,KAAK,GACvB,mBAAmB,UAAU,KAAK,GAClC,OAAO,KAAK,SAAS,CAC1B,CACF;CACJ,CAAC,CACH;AAEH,MAAa,YAAY,cACvB,MAAM,KAAK,UAAU,cAAc,IAAI;AAEzC,IAAa,2CAAb,cAA8D,OAAO,YACnE,2CACD,CAAC,4CAA4C,EAC5C,MAAM,OAAO,gBACd,CAAC,CAAC;CACD,IAAa,UAAkB;AAC7B,SAAO,mDAAmD,KAAK"}

package/dist/GroupPaths.mjs

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

package/dist/GroupPaths.mjs.map

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

package/dist/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,28 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export {  };

package/dist/cliApp.mjs

@@ -0,0 +1,13 @@
+import { version } from "./packages/cli/package.mjs";
+import { confect } from "./confect.mjs";
+import { Command } from "@effect/cli";
+
+//#region src/cliApp.ts
+const cliApp = Command.run(confect, {
+	name: "Confect",
+	version
+});
+
+//#endregion
+export { cliApp };
+//# sourceMappingURL=cliApp.mjs.map

package/dist/cliApp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cliApp.mjs","names":["packageJson.version"],"sources":["../src/cliApp.ts"],"sourcesContent":["import { Command } from \"@effect/cli\";\nimport packageJson from \"../package.json\" with { type: \"json\" };\nimport { confect } from \"./confect\";\n\nexport const cliApp = Command.run(confect, {\n  name: \"Confect\",\n  version: packageJson.version,\n});\n"],"mappings":";;;;;AAIA,MAAa,SAAS,QAAQ,IAAI,SAAS;CACzC,MAAM;CACGA;CACV,CAAC"}

package/dist/confect/codegen.mjs

@@ -0,0 +1,111 @@
+import { Spec_exports } from "../packages/core/dist/Spec.mjs";
+import { logCompleted, logFileAdded, logFileModified } from "../log.mjs";
+import { ConvexDirectory } from "../services/ConvexDirectory.mjs";
+import { ConfectDirectory } from "../services/ConfectDirectory.mjs";
+import { api, refs, registeredFunctions, schema, services } from "../templates.mjs";
+import { generateAuthConfig, generateConvexConfig, generateCrons, generateFunctions, generateHttp, removePathExtension, writeFileStringAndLog } from "../utils.mjs";
+import { Effect, Match, Option } from "effect";
+import { Command } from "@effect/cli";
+import { DatabaseSchema } from "@confect/server";
+import { FileSystem, Path } from "@effect/platform";
+import * as tsx from "tsx/esm/api";
+
+//#region src/confect/codegen.ts
+const codegen = Command.make("codegen", {}, () => Effect.gen(function* () {
+	yield* codegenHandler;
+	yield* logCompleted("Generated files are up-to-date");
+})).pipe(Command.withDescription("Generate `confect/_generated` files and the contents of the `convex` directory (except `tsconfig.json`)"));
+const codegenHandler = Effect.gen(function* () {
+	yield* generateConfectGeneratedDirectory;
+	yield* Effect.all([
+		generateApi,
+		generateRefs,
+		generateRegisteredFunctions,
+		generateServices
+	], { concurrency: "unbounded" });
+	const [functionPaths] = yield* Effect.all([
+		generateFunctionModules,
+		generateSchema,
+		logGenerated(generateHttp),
+		logGenerated(generateConvexConfig),
+		logGenerated(generateCrons),
+		logGenerated(generateAuthConfig)
+	], { concurrency: "unbounded" });
+	return functionPaths;
+});
+const generateConfectGeneratedDirectory = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	if (!(yield* fs.exists(path.join(confectDirectory, "_generated")))) {
+		yield* fs.makeDirectory(path.join(confectDirectory, "_generated"), { recursive: true });
+		yield* logFileAdded(path.join(confectDirectory, "_generated") + "/");
+	}
+});
+const generateApi = Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const apiPath = path.join(confectDirectory, "_generated", "api.ts");
+	const schemaImportPath = yield* removePathExtension(path.relative(path.dirname(apiPath), path.join(confectDirectory, "schema.ts")));
+	const specImportPath = yield* removePathExtension(path.relative(path.dirname(apiPath), path.join(confectDirectory, "spec.ts")));
+	yield* writeFileStringAndLog(apiPath, yield* api({
+		schemaImportPath,
+		specImportPath
+	}));
+});
+const generateFunctionModules = Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const specPath = path.join(confectDirectory, "spec.ts");
+	const specPathUrl = yield* path.toFileUrl(specPath);
+	const spec = (yield* Effect.promise(() => tsx.tsImport(specPathUrl.href, import.meta.url))).default;
+	if (!Spec_exports.isSpec(spec)) return yield* Effect.die("spec.ts does not export a valid Spec");
+	return yield* generateFunctions(spec);
+});
+const generateSchema = Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const convexDirectory = yield* ConvexDirectory.get;
+	const confectSchemaPath = path.join(confectDirectory, "schema.ts");
+	const confectSchemaUrl = yield* path.toFileUrl(confectSchemaPath);
+	yield* Effect.promise(() => tsx.tsImport(confectSchemaUrl.href, import.meta.url)).pipe(Effect.andThen((schemaModule) => {
+		const defaultExport = schemaModule.default;
+		return DatabaseSchema.isSchema(defaultExport) ? Effect.succeed(defaultExport) : Effect.die("Invalid schema module");
+	}));
+	const convexSchemaPath = path.join(convexDirectory, "schema.ts");
+	const importPathWithoutExt = yield* removePathExtension(path.relative(path.dirname(convexSchemaPath), confectSchemaPath));
+	yield* writeFileStringAndLog(convexSchemaPath, yield* schema({ schemaImportPath: importPathWithoutExt }));
+});
+const generateServices = Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
+	const servicesPath = path.join(confectGeneratedDirectory, "services.ts");
+	const schemaImportPath = path.relative(path.dirname(servicesPath), path.join(confectDirectory, "schema"));
+	yield* writeFileStringAndLog(servicesPath, yield* services({ schemaImportPath }));
+});
+const generateRegisteredFunctions = Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
+	const registeredFunctionsPath = path.join(confectGeneratedDirectory, "registeredFunctions.ts");
+	const implImportPath = yield* removePathExtension(path.relative(path.dirname(registeredFunctionsPath), path.join(confectDirectory, "impl.ts")));
+	yield* writeFileStringAndLog(registeredFunctionsPath, yield* registeredFunctions({ implImportPath }));
+});
+const generateRefs = Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
+	const confectSpecPath = path.join(confectDirectory, "spec.ts");
+	const refsPath = path.join(confectGeneratedDirectory, "refs.ts");
+	const importPathWithoutExt = yield* removePathExtension(path.relative(path.dirname(refsPath), confectSpecPath));
+	yield* writeFileStringAndLog(refsPath, yield* refs({ specImportPath: importPathWithoutExt }));
+});
+const logGenerated = (effect) => effect.pipe(Effect.tap(Option.match({
+	onNone: () => Effect.void,
+	onSome: ({ change, convexFilePath }) => Match.value(change).pipe(Match.when("Added", () => logFileAdded(convexFilePath)), Match.when("Modified", () => logFileModified(convexFilePath)), Match.when("Unchanged", () => Effect.void), Match.exhaustive)
+})));
+
+//#endregion
+export { codegen, codegenHandler };
+//# sourceMappingURL=codegen.mjs.map

package/dist/confect/codegen.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.mjs","names":["templates.api","Spec","templates.schema","templates.services","templates.registeredFunctions","templates.refs"],"sources":["../../src/confect/codegen.ts"],"sourcesContent":["import { Spec } from \"@confect/core\";\nimport { DatabaseSchema } from \"@confect/server\";\nimport { Command } from \"@effect/cli\";\nimport { FileSystem, Path } from \"@effect/platform\";\nimport { Effect, Match, Option } from \"effect\";\nimport * as tsx from \"tsx/esm/api\";\nimport { logCompleted, logFileAdded, logFileModified } from \"../log\";\nimport { ConfectDirectory } from \"../services/ConfectDirectory\";\nimport { ConvexDirectory } from \"../services/ConvexDirectory\";\nimport * as templates from \"../templates\";\nimport {\n  generateAuthConfig,\n  generateConvexConfig,\n  generateCrons,\n  generateFunctions,\n  generateHttp,\n  removePathExtension,\n  writeFileStringAndLog,\n} from \"../utils\";\n\nexport const codegen = Command.make(\"codegen\", {}, () =>\n  Effect.gen(function* () {\n    yield* codegenHandler;\n    yield* logCompleted(\"Generated files are up-to-date\");\n  }),\n).pipe(\n  Command.withDescription(\n    \"Generate `confect/_generated` files and the contents of the `convex` directory (except `tsconfig.json`)\",\n  ),\n);\n\nexport const codegenHandler = Effect.gen(function* () {\n  yield* generateConfectGeneratedDirectory;\n  yield* Effect.all(\n    [generateApi, generateRefs, generateRegisteredFunctions, generateServices],\n    { concurrency: \"unbounded\" },\n  );\n  const [functionPaths] = yield* Effect.all(\n    [\n      generateFunctionModules,\n      generateSchema,\n      logGenerated(generateHttp),\n      logGenerated(generateConvexConfig),\n      logGenerated(generateCrons),\n      logGenerated(generateAuthConfig),\n    ],\n    { concurrency: \"unbounded\" },\n  );\n  return functionPaths;\n});\n\nconst generateConfectGeneratedDirectory = Effect.gen(function* () {\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n\n  if (!(yield* fs.exists(path.join(confectDirectory, \"_generated\")))) {\n    yield* fs.makeDirectory(path.join(confectDirectory, \"_generated\"), {\n      recursive: true,\n    });\n    yield* logFileAdded(path.join(confectDirectory, \"_generated\") + \"/\");\n  }\n});\n\nconst generateApi = Effect.gen(function* () {\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n\n  const apiPath = path.join(confectDirectory, \"_generated\", \"api.ts\");\n\n  const schemaImportPath = yield* removePathExtension(\n    path.relative(\n      path.dirname(apiPath),\n      path.join(confectDirectory, \"schema.ts\"),\n    ),\n  );\n\n  const specImportPath = yield* removePathExtension(\n    path.relative(\n      path.dirname(apiPath),\n      path.join(confectDirectory, \"spec.ts\"),\n    ),\n  );\n\n  const apiContents = yield* templates.api({\n    schemaImportPath,\n    specImportPath,\n  });\n\n  yield* writeFileStringAndLog(apiPath, apiContents);\n});\n\nconst generateFunctionModules = Effect.gen(function* () {\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n\n  const specPath = path.join(confectDirectory, \"spec.ts\");\n  const specPathUrl = yield* path.toFileUrl(specPath);\n\n  const specModule = yield* Effect.promise(() =>\n    tsx.tsImport(specPathUrl.href, import.meta.url),\n  );\n  const spec = specModule.default;\n\n  if (!Spec.isSpec(spec)) {\n    return yield* Effect.die(\"spec.ts does not export a valid Spec\");\n  }\n\n  return yield* generateFunctions(spec);\n});\n\nconst generateSchema = Effect.gen(function* () {\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n  const convexDirectory = yield* ConvexDirectory.get;\n\n  const confectSchemaPath = path.join(confectDirectory, \"schema.ts\");\n  const confectSchemaUrl = yield* path.toFileUrl(confectSchemaPath);\n\n  yield* Effect.promise(() =>\n    tsx.tsImport(confectSchemaUrl.href, import.meta.url),\n  ).pipe(\n    Effect.andThen((schemaModule) => {\n      const defaultExport = schemaModule.default;\n\n      return DatabaseSchema.isSchema(defaultExport)\n        ? Effect.succeed(defaultExport)\n        : Effect.die(\"Invalid schema module\");\n    }),\n  );\n\n  const convexSchemaPath = path.join(convexDirectory, \"schema.ts\");\n\n  const relativeImportPath = path.relative(\n    path.dirname(convexSchemaPath),\n    confectSchemaPath,\n  );\n  const importPathWithoutExt = yield* removePathExtension(relativeImportPath);\n  const schemaContents = yield* templates.schema({\n    schemaImportPath: importPathWithoutExt,\n  });\n\n  yield* writeFileStringAndLog(convexSchemaPath, schemaContents);\n});\n\nconst generateServices = Effect.gen(function* () {\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n\n  const confectGeneratedDirectory = path.join(confectDirectory, \"_generated\");\n\n  const servicesPath = path.join(confectGeneratedDirectory, \"services.ts\");\n  const schemaImportPath = path.relative(\n    path.dirname(servicesPath),\n    path.join(confectDirectory, \"schema\"),\n  );\n\n  const servicesContentsString = yield* templates.services({\n    schemaImportPath,\n  });\n\n  yield* writeFileStringAndLog(servicesPath, servicesContentsString);\n});\n\nconst generateRegisteredFunctions = Effect.gen(function* () {\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n\n  const confectGeneratedDirectory = path.join(confectDirectory, \"_generated\");\n\n  const registeredFunctionsPath = path.join(\n    confectGeneratedDirectory,\n    \"registeredFunctions.ts\",\n  );\n  const implImportPath = yield* removePathExtension(\n    path.relative(\n      path.dirname(registeredFunctionsPath),\n      path.join(confectDirectory, \"impl.ts\"),\n    ),\n  );\n\n  const registeredFunctionsContents = yield* templates.registeredFunctions({\n    implImportPath,\n  });\n\n  yield* writeFileStringAndLog(\n    registeredFunctionsPath,\n    registeredFunctionsContents,\n  );\n});\n\nconst generateRefs = Effect.gen(function* () {\n  const path = yield* Path.Path;\n  const confectDirectory = yield* ConfectDirectory.get;\n\n  const confectGeneratedDirectory = path.join(confectDirectory, \"_generated\");\n\n  const confectSpecPath = path.join(confectDirectory, \"spec.ts\");\n  const refsPath = path.join(confectGeneratedDirectory, \"refs.ts\");\n\n  const relativeImportPath = path.relative(\n    path.dirname(refsPath),\n    confectSpecPath,\n  );\n  const importPathWithoutExt = yield* removePathExtension(relativeImportPath);\n\n  const refsContents = yield* templates.refs({\n    specImportPath: importPathWithoutExt,\n  });\n\n  yield* writeFileStringAndLog(refsPath, refsContents);\n});\n\nconst logGenerated = (effect: typeof generateHttp) =>\n  effect.pipe(\n    Effect.tap(\n      Option.match({\n        onNone: () => Effect.void,\n        onSome: ({ change, convexFilePath }) =>\n          Match.value(change).pipe(\n            Match.when(\"Added\", () => logFileAdded(convexFilePath)),\n            Match.when(\"Modified\", () => logFileModified(convexFilePath)),\n            Match.when(\"Unchanged\", () => Effect.void),\n            Match.exhaustive,\n          ),\n      }),\n    ),\n  );\n"],"mappings":"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"}

package/dist/confect/dev.mjs

@@ -0,0 +1,253 @@
+import { Spec_exports } from "../packages/core/dist/Spec.mjs";
+import { modulePath, toString } from "../GroupPath.mjs";
+import { ProjectRoot } from "../services/ProjectRoot.mjs";
+import { logCompleted, logFailed } from "../log.mjs";
+import { ConvexDirectory } from "../services/ConvexDirectory.mjs";
+import { ConfectDirectory } from "../services/ConfectDirectory.mjs";
+import { diff, make } from "../FunctionPaths.mjs";
+import { generateAuthConfig, generateConvexConfig, generateCrons, generateHttp, removeGroups, writeGroups } from "../utils.mjs";
+import { codegenHandler } from "./codegen.mjs";
+import { Array, Console, Data, Duration, Effect, Equal, HashSet, Match, Option, Queue, Ref, Schema, Stream, String, pipe } from "effect";
+import { Command } from "@effect/cli";
+import { FileSystem, Path } from "@effect/platform";
+import * as tsx from "tsx/esm/api";
+import { Ansi, AnsiDoc } from "@effect/printer-ansi";
+import * as esbuild from "esbuild";
+
+//#region src/confect/dev.ts
+const pendingInit = {
+	specDirty: false,
+	httpDirty: false,
+	appDirty: false,
+	cronsDirty: false,
+	authDirty: false
+};
+const FileChange = Data.taggedEnum();
+const logChangeReport = (changes) => Effect.gen(function* () {
+	yield* logCompleted("Generated files are up-to-date");
+	yield* Effect.when(Effect.forEach(changes, (change) => FileChange.$match(change, {
+		OptionalFile: ({ change: c, filePath }) => logFileChangeIndented(c, filePath),
+		GroupModule: ({ change: c, filePath, functionsAdded, functionsRemoved }) => Effect.gen(function* () {
+			yield* logFileChangeIndented(c, filePath);
+			yield* Effect.forEach(functionsAdded, logFunctionAddedIndented);
+			yield* Effect.forEach(functionsRemoved, logFunctionRemovedIndented);
+		})
+	})), () => Array.isNonEmptyReadonlyArray(changes));
+});
+const changeChar = (change) => Match.value(change).pipe(Match.when("Added", () => ({
+	char: "+",
+	color: Ansi.green
+})), Match.when("Removed", () => ({
+	char: "-",
+	color: Ansi.red
+})), Match.when("Modified", () => ({
+	char: "~",
+	color: Ansi.yellow
+})), Match.exhaustive);
+const logFileChangeIndented = (change, fullPath) => Effect.gen(function* () {
+	const prefix = (yield* ProjectRoot.get) + (yield* Path.Path).sep;
+	const suffix = pipe(fullPath, String.startsWith(prefix)) ? pipe(fullPath, String.slice(prefix.length)) : fullPath;
+	const { char, color } = changeChar(change);
+	yield* Console.log(pipe(AnsiDoc.text("  "), AnsiDoc.cat(pipe(AnsiDoc.char(char), AnsiDoc.annotate(color))), AnsiDoc.catWithSpace(AnsiDoc.hcat([pipe(AnsiDoc.text(prefix), AnsiDoc.annotate(Ansi.blackBright)), pipe(AnsiDoc.text(suffix), AnsiDoc.annotate(color))])), AnsiDoc.render({ style: "pretty" })));
+});
+const logFunctionAddedIndented = (functionPath) => Console.log(pipe(AnsiDoc.text("    "), AnsiDoc.cat(pipe(AnsiDoc.char("+"), AnsiDoc.annotate(Ansi.green))), AnsiDoc.catWithSpace(AnsiDoc.hcat([pipe(AnsiDoc.text(toString(functionPath.groupPath) + "."), AnsiDoc.annotate(Ansi.blackBright)), pipe(AnsiDoc.text(functionPath.name), AnsiDoc.annotate(Ansi.green))])), AnsiDoc.render({ style: "pretty" })));
+const logFunctionRemovedIndented = (functionPath) => Console.log(pipe(AnsiDoc.text("    "), AnsiDoc.cat(pipe(AnsiDoc.char("-"), AnsiDoc.annotate(Ansi.red))), AnsiDoc.catWithSpace(AnsiDoc.hcat([pipe(AnsiDoc.text(toString(functionPath.groupPath) + "."), AnsiDoc.annotate(Ansi.blackBright)), pipe(AnsiDoc.text(functionPath.name), AnsiDoc.annotate(Ansi.red))])), AnsiDoc.render({ style: "pretty" })));
+const dev = Command.make("dev", {}, () => Effect.gen(function* () {
+	const initialFunctionPaths = yield* codegenHandler;
+	const pendingRef = yield* Ref.make(pendingInit);
+	const signal = yield* Queue.sliding(1);
+	yield* Effect.all([
+		specFileWatcher(signal, pendingRef),
+		confectDirectoryWatcher(signal, pendingRef),
+		syncLoop(signal, pendingRef, initialFunctionPaths)
+	], { concurrency: "unbounded" });
+})).pipe(Command.withDescription("Start the Confect development server"));
+const syncLoop = (signal, pendingRef, initialFunctionPaths) => Effect.gen(function* () {
+	const functionPathsRef = yield* Ref.make(initialFunctionPaths);
+	const changesRef = yield* Ref.make([]);
+	return yield* Effect.forever(Effect.gen(function* () {
+		yield* Effect.logDebug("Running sync loop...");
+		yield* Queue.take(signal);
+		const pending = yield* Ref.getAndSet(pendingRef, pendingInit);
+		const specResult = yield* Effect.if(pending.specDirty, {
+			onTrue: () => loadSpec.pipe(Effect.andThen(Effect.fn(function* (spec) {
+				yield* Effect.logDebug("Spec loaded");
+				const previous = yield* Ref.get(functionPathsRef);
+				const path = yield* Path.Path;
+				const convexDirectory = yield* ConvexDirectory.get;
+				const current = make(spec);
+				const { functionsAdded, functionsRemoved, groupsRemoved, groupsAdded, groupsChanged } = diff(previous, current);
+				yield* removeGroups(groupsRemoved);
+				const removedChanges = yield* Effect.forEach(groupsRemoved, (gp) => Effect.gen(function* () {
+					const relativeModulePath = yield* modulePath(gp);
+					return FileChange.GroupModule({
+						change: "Removed",
+						filePath: path.join(convexDirectory, relativeModulePath),
+						functionsAdded: [],
+						functionsRemoved: Array.fromIterable(HashSet.filter(functionsRemoved, (fp) => Equal.equals(fp.groupPath, gp)))
+					});
+				}));
+				yield* writeGroups(spec, groupsAdded);
+				const addedChanges = yield* Effect.forEach(groupsAdded, (gp) => Effect.gen(function* () {
+					const relativeModulePath = yield* modulePath(gp);
+					return FileChange.GroupModule({
+						change: "Added",
+						filePath: path.join(convexDirectory, relativeModulePath),
+						functionsAdded: Array.fromIterable(HashSet.filter(functionsAdded, (fp) => Equal.equals(fp.groupPath, gp))),
+						functionsRemoved: []
+					});
+				}));
+				yield* writeGroups(spec, groupsChanged);
+				const changedChanges = yield* Effect.forEach(groupsChanged, (gp) => Effect.gen(function* () {
+					const relativeModulePath = yield* modulePath(gp);
+					return FileChange.GroupModule({
+						change: "Modified",
+						filePath: path.join(convexDirectory, relativeModulePath),
+						functionsAdded: Array.fromIterable(HashSet.filter(functionsAdded, (fp) => Equal.equals(fp.groupPath, gp))),
+						functionsRemoved: Array.fromIterable(HashSet.filter(functionsRemoved, (fp) => Equal.equals(fp.groupPath, gp)))
+					});
+				}));
+				yield* Ref.set(functionPathsRef, current);
+				return Option.some([
+					...removedChanges,
+					...addedChanges,
+					...changedChanges
+				]);
+			})), Effect.catchTag("SpecImportFailedError", () => logFailed("Spec import failed").pipe(Effect.as(Option.none()))), Effect.catchTag("SpecFileDoesNotExportSpecError", () => logFailed("Spec file does not default export a spec").pipe(Effect.as(Option.none())))),
+			onFalse: () => Effect.succeed(Option.some([]))
+		});
+		const specChanges = Option.getOrElse(specResult, () => []);
+		const dirtyOptionalFiles = [
+			...pending.httpDirty ? [syncOptionalFile(generateHttp, "http.ts")] : [],
+			...pending.appDirty ? [syncOptionalFile(generateConvexConfig, "convex.config.ts")] : [],
+			...pending.cronsDirty ? [syncOptionalFile(generateCrons, "crons.ts")] : [],
+			...pending.authDirty ? [syncOptionalFile(generateAuthConfig, "auth.config.ts")] : []
+		];
+		const optionalChanges = Array.isNonEmptyReadonlyArray(dirtyOptionalFiles) ? yield* pipe(Effect.all(dirtyOptionalFiles, { concurrency: "unbounded" }), Effect.map(Array.getSomes)) : [];
+		yield* Ref.update(changesRef, (prev) => [
+			...prev,
+			...specChanges,
+			...optionalChanges
+		]);
+		yield* Option.match(specResult, {
+			onSome: () => Effect.gen(function* () {
+				const pendingSize = yield* Queue.size(signal);
+				yield* Effect.when(Effect.gen(function* () {
+					yield* logChangeReport(yield* Ref.getAndSet(changesRef, []));
+				}), () => pendingSize === 0);
+			}),
+			onNone: () => Ref.set(changesRef, [])
+		});
+	}));
+});
+const loadSpec = Effect.gen(function* () {
+	const specPathUrl = yield* (yield* Path.Path).toFileUrl(yield* getSpecPath);
+	const spec = (yield* Effect.tryPromise({
+		try: () => tsx.tsImport(specPathUrl.href, import.meta.url),
+		catch: (error) => new SpecImportFailedError({ error })
+	})).default;
+	if (Spec_exports.isSpec(spec)) return spec;
+	else return yield* Effect.fail(new SpecFileDoesNotExportSpecError());
+});
+const getSpecPath = Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	return path.join(confectDirectory, "spec.ts");
+});
+const specFileWatcher = (signal, pendingRef) => Effect.gen(function* () {
+	const specPath = yield* getSpecPath;
+	yield* pipe(Stream.asyncPush((emit) => Effect.acquireRelease(Effect.promise(async () => {
+		const ctx = await esbuild.context({
+			entryPoints: [specPath],
+			bundle: true,
+			write: false,
+			metafile: true,
+			platform: "node",
+			format: "esm",
+			logLevel: "silent",
+			external: [
+				"@confect/core",
+				"@confect/server",
+				"effect",
+				"@effect/*"
+			],
+			plugins: [{
+				name: "notify-rebuild",
+				setup(build) {
+					build.onEnd((result) => {
+						if (result.errors.length === 0) emit.single();
+						else Effect.runPromise(Effect.gen(function* () {
+							yield* logFailed("Build errors");
+							const formattedMessages = yield* Effect.promise(() => esbuild.formatMessages(result.errors, {
+								kind: "error",
+								color: true,
+								terminalWidth: 80
+							}));
+							const output = formatBuildErrors(result.errors, formattedMessages);
+							yield* Console.error("\n" + output + "\n");
+						}));
+					});
+				}
+			}]
+		});
+		await ctx.watch();
+		return ctx;
+	}), (ctx) => Effect.promise(() => ctx.dispose()).pipe(Effect.tap(() => Effect.logDebug("esbuild watcher disposed")))), {
+		bufferSize: 1,
+		strategy: "sliding"
+	}), Stream.debounce(Duration.millis(200)), Stream.runForEach(() => Ref.update(pendingRef, (pending) => ({
+		...pending,
+		specDirty: true
+	})).pipe(Effect.andThen(Queue.offer(signal, void 0)))));
+});
+const formatBuildError = (error, formattedMessage) => {
+	const lines = String.split(formattedMessage, "\n");
+	const redErrorText = pipe(AnsiDoc.text(error?.text ?? ""), AnsiDoc.annotate(Ansi.red), AnsiDoc.render({ style: "pretty" }));
+	return pipe(pipe(Array.findFirstIndex(lines, (l) => pipe(l, String.trim, String.isNonEmpty)), Option.match({
+		onNone: () => lines,
+		onSome: (idx) => Array.modify(lines, idx, () => redErrorText)
+	})), Array.map((l) => pipe(l, String.trim, String.isNonEmpty) ? `  ${l}` : l), Array.join("\n"));
+};
+const formatBuildErrors = (errors, formattedMessages) => pipe(formattedMessages, Array.map((message, i) => formatBuildError(errors[i], message)), Array.join(""), String.trimEnd);
+var SpecFileDoesNotExportSpecError = class extends Schema.TaggedError("SpecFileDoesNotExportSpecError")("SpecFileDoesNotExportSpecError", {}) {};
+var SpecImportFailedError = class extends Schema.TaggedError("SpecImportFailedError")("SpecImportFailedError", { error: Schema.Unknown }) {};
+const syncOptionalFile = (generate, convexFile) => pipe(generate, Effect.andThen(Option.match({
+	onSome: ({ change, convexFilePath }) => Match.value(change).pipe(Match.when("Unchanged", () => Effect.succeed(Option.none())), Match.whenOr("Added", "Modified", (addedOrModified) => Effect.succeed(Option.some(FileChange.OptionalFile({
+		change: addedOrModified,
+		filePath: convexFilePath
+	})))), Match.exhaustive),
+	onNone: () => Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const convexDirectory = yield* ConvexDirectory.get;
+		const convexFilePath = path.join(convexDirectory, convexFile);
+		if (yield* fs.exists(convexFilePath)) {
+			yield* fs.remove(convexFilePath);
+			return Option.some(FileChange.OptionalFile({
+				change: "Removed",
+				filePath: convexFilePath
+			}));
+		} else return Option.none();
+	})
+})));
+const optionalConfectFiles = {
+	"http.ts": "httpDirty",
+	"app.ts": "appDirty",
+	"crons.ts": "cronsDirty",
+	"auth.ts": "authDirty"
+};
+const confectDirectoryWatcher = (signal, pendingRef) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const confectDirectory = yield* ConfectDirectory.get;
+	yield* pipe(fs.watch(confectDirectory), Stream.runForEach((event) => pipe(Option.fromNullable(optionalConfectFiles[event.path]), Option.match({
+		onNone: () => Effect.void,
+		onSome: (pendingKey) => pipe(pendingRef, Ref.update((pending) => ({
+			...pending,
+			[pendingKey]: true
+		})), Effect.andThen(Queue.offer(signal, void 0)))
+	}))));
+});
+
+//#endregion
+export { dev };
+//# sourceMappingURL=dev.mjs.map