@confect/server 8.0.0 → 9.0.0-next.1

package/src/GroupImpl.ts

@@ -1,60 +1,196 @@
-import type * as GroupPath from "@confect/core/GroupPath";
 import type * as GroupSpec from "@confect/core/GroupSpec";
-import { Context, Layer } from "effect";
+import * as Registry from "@confect/core/Registry";
+import {
+  Array,
+  Context,
+  Effect,
+  Layer,
+  Option,
+  pipe,
+  Predicate,
+  Record,
+  Ref,
+  String,
+} from "effect";
 import type * as Api from "./Api";
 import type * as FunctionImpl from "./FunctionImpl";
+import { resolveGroupPathUnsafe } from "./GroupPath";
 
-export interface GroupImpl<GroupPath_ extends string> {
+export const TypeId = "@confect/server/GroupImpl";
+export type TypeId = typeof TypeId;
+
+export type FinalizationStatus = "Unfinalized" | "Finalized";
+
+export interface GroupImpl<
+  GroupPath_ extends string,
+  FinalizationStatus_ extends FinalizationStatus = "Unfinalized",
+> {
+  readonly [TypeId]: TypeId;
   readonly groupPath: GroupPath_;
+  readonly finalizationStatus: FinalizationStatus_;
+  /**
+   * Names of every function registered into this group's layer scope by
+   * `FunctionImpl.make`. Authoritative only when `finalizationStatus` is
+   * `"Finalized"`; the `"Unfinalized"` value is set to `[]` at `make`-time
+   * since the list is only known once `finalize` snapshots the registry.
+   */
+  readonly registeredFunctionNames: ReadonlyArray<string>;
 }
 
-export const GroupImpl = <GroupPath_ extends string>({
+export interface Any extends GroupImpl<string, FinalizationStatus> {}
+
+export const isGroupImpl = (u: unknown): u is Any =>
+  Predicate.hasProperty(u, TypeId);
+
+export interface AnyFinalized extends GroupImpl<string, "Finalized"> {}
+export interface AnyUnfinalized extends GroupImpl<string, "Unfinalized"> {}
+
+export const isFinalizedGroupImpl = (u: unknown): u is AnyFinalized =>
+  isGroupImpl(u) && u.finalizationStatus === "Finalized";
+
+export const isUnfinalizedGroupImpl = (u: unknown): u is AnyUnfinalized =>
+  isGroupImpl(u) && u.finalizationStatus === "Unfinalized";
+
+/**
+ * Build the runtime tag for a `GroupImpl` service. The finalization status is
+ * embedded in the tag string so that `Unfinalized` and `Finalized` are distinct
+ * services at runtime; consumers of a finalized layer (the server's
+ * `RegisteredFunctions.buildForGroup` and the CLI's `implValidation`) retrieve
+ * the typed `Finalized` service directly rather than scanning the context.
+ */
+export const GroupImpl = <
+  GroupPath_ extends string,
+  FinalizationStatus_ extends FinalizationStatus,
+>({
   groupPath,
+  finalizationStatus,
 }: {
   groupPath: GroupPath_;
+  finalizationStatus: FinalizationStatus_;
 }) =>
-  Context.GenericTag<GroupImpl<GroupPath_>>(
-    `@confect/server/GroupImpl/${groupPath}`,
+  Context.GenericTag<GroupImpl<GroupPath_, FinalizationStatus_>>(
+    `@confect/server/GroupImpl/${finalizationStatus}/${groupPath}`,
   );
 
 export const make = <
   Api_ extends Api.AnyWithProps,
-  const GroupPath_ extends GroupPath.All<Api.Groups<Api_>>,
+  Group extends GroupSpec.AnyWithProps,
 >(
-  _api: Api_,
-  groupPath: GroupPath_,
+  api: Api_,
+  group: Group,
 ): Layer.Layer<
-  GroupImpl<GroupPath_>,
+  GroupImpl<string, "Unfinalized">,
   never,
-  | FromGroupWithPath<GroupPath_, Api.Groups<Api_>>
-  | FunctionImpl.FromGroupAtPath<GroupPath_, Api.Groups<Api_>>
-> =>
-  Layer.succeed(
-    GroupImpl<GroupPath_>({
+  FunctionImpl.FromGroupSpec<Group>
+> => {
+  const groupPath = resolveGroupPathUnsafe(api.spec, group);
+
+  return Layer.succeed(
+    GroupImpl<string, "Unfinalized">({
       groupPath,
+      finalizationStatus: "Unfinalized",
     }),
     {
+      [TypeId]: TypeId,
       groupPath,
+      finalizationStatus: "Unfinalized" as const,
+      registeredFunctionNames: [],
     },
   ) as Layer.Layer<
-    GroupImpl<GroupPath_>,
+    GroupImpl<string, "Unfinalized">,
     never,
-    | FromGroupWithPath<GroupPath_, Api.Groups<Api_>>
-    | FunctionImpl.FromGroupAtPath<GroupPath_, Api.Groups<Api_>>
+    FunctionImpl.FromGroupSpec<Group>
   >;
+};
 
-export type FromGroups<Groups extends GroupSpec.Any> = Groups extends never
-  ? never
-  : Groups extends GroupSpec.AnyWithProps
-    ? GroupImpl<GroupSpec.Name<Groups>>
-    : never;
+const isFunctionShaped = (value: unknown): boolean =>
+  Predicate.isRecord(value) && "functionSpec" in value;
 
-export type FromGroupWithPath<
-  GroupPath_ extends string,
-  Group extends GroupSpec.AnyWithProps,
-> =
-  GroupPath.SubGroupsAt<Group, GroupPath_> extends infer SubGroupPaths
-    ? SubGroupPaths extends string
-      ? GroupImpl<SubGroupPaths>
-      : never
-    : never;
+/**
+ * Walk a `RegistryItems` tree to the entries at `groupPath` and return the
+ * names of the function-shaped leaves directly underneath.
+ */
+const collectFunctionNamesAtPath = (
+  items: Registry.RegistryItems,
+  groupPath: string,
+): ReadonlyArray<string> =>
+  pipe(
+    String.split(groupPath, "."),
+    Array.reduce(Option.some<unknown>(items), (acc, segment) =>
+      acc.pipe(
+        Option.filter(Predicate.isRecord),
+        Option.flatMap((node) =>
+          segment in node ? Option.some(node[segment]) : Option.none(),
+        ),
+      ),
+    ),
+    Option.filter(Predicate.isRecord),
+    Option.map(Record.toEntries),
+    Option.map(
+      Array.filterMap(([name, value]) =>
+        isFunctionShaped(value) ? Option.some(name) : Option.none(),
+      ),
+    ),
+    Option.getOrElse((): ReadonlyArray<string> => []),
+  );
+
+const findUnfinalizedGroupImpl = <S>(
+  context: Context.Context<S>,
+): Option.Option<AnyUnfinalized> =>
+  Array.findFirst(context.unsafeMap.values(), isUnfinalizedGroupImpl);
+
+/**
+ * Mark a `GroupImpl` layer as fully implemented. The parameter type defaults
+ * `RIn = never`, so passing a layer that still requires any `FunctionImpl`
+ * service produces a type error at the impl author's site. The codegen
+ * boundary requires the resulting `"Finalized"` brand, so omitting this call
+ * is also rejected downstream.
+ *
+ * As a side effect of finalization, the names of every `FunctionImpl` that
+ * registered into this group's scope are snapshotted onto the produced
+ * service value's `registeredFunctionNames` field, so consumers can verify
+ * impl completeness against a `GroupSpec`'s expected functions without
+ * having to inspect the `Registry` themselves.
+ */
+export const finalize = <GroupPath_ extends string>(
+  group: Layer.Layer<GroupImpl<GroupPath_, "Unfinalized">>,
+): Layer.Layer<GroupImpl<GroupPath_, "Finalized">> =>
+  Layer.flatMap(
+    group,
+    (context): Layer.Layer<GroupImpl<GroupPath_, "Finalized">> =>
+      findUnfinalizedGroupImpl(context).pipe(
+        Option.match({
+          onNone: () =>
+            Layer.die(
+              new Error(
+                "GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.",
+              ),
+            ),
+          onSome: (unfinalized) => {
+            const groupPath = unfinalized.groupPath as GroupPath_;
+            return Layer.effect(
+              GroupImpl<GroupPath_, "Finalized">({
+                groupPath,
+                finalizationStatus: "Finalized",
+              }),
+              Effect.gen(function* () {
+                const registry = yield* Registry.Registry;
+                const items = yield* Ref.get(registry);
+                return {
+                  [TypeId]: TypeId,
+                  groupPath,
+                  finalizationStatus: "Finalized" as const,
+                  registeredFunctionNames: collectFunctionNamesAtPath(
+                    items,
+                    groupPath,
+                  ),
+                };
+              }),
+            );
+          },
+        }),
+      ),
+  );
+
+export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =
+  FunctionImpl.FromGroupSpec<Group>;

package/src/GroupPath.ts

@@ -0,0 +1,43 @@
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as Spec from "@confect/core/Spec";
+import { Array, Option, pipe, Record } from "effect";
+
+const resolveGroupPathInGroup = (
+  group: GroupSpec.AnyWithProps,
+  target: GroupSpec.AnyWithProps,
+  pathSegments: ReadonlyArray<string>,
+): Option.Option<string> =>
+  pipe(
+    Record.toEntries(group.groups),
+    Array.findFirst(([name, child]) =>
+      child === target
+        ? Option.some(Array.join([...pathSegments, name], "."))
+        : resolveGroupPathInGroup(child, target, [...pathSegments, name]),
+    ),
+  );
+
+const resolveGroupPath = (
+  spec: Spec.AnyWithProps,
+  target: GroupSpec.AnyWithProps,
+): Option.Option<string> =>
+  pipe(
+    Record.toEntries(spec.groups),
+    Array.findFirst(([name, group]) =>
+      group === target
+        ? Option.some(name)
+        : resolveGroupPathInGroup(group, target, [name]),
+    ),
+  );
+
+export const resolveGroupPathUnsafe = (
+  spec: Spec.AnyWithProps,
+  target: GroupSpec.AnyWithProps,
+): string =>
+  resolveGroupPath(spec, target).pipe(
+    Option.getOrThrowWith(
+      () =>
+        new Error(
+          "Could not resolve group path for the provided GroupSpec. Ensure the spec is part of the assembled API spec tree.",
+        ),
+    ),
+  );

package/src/RegisteredFunctions.ts

@@ -1,13 +1,22 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import type * as GroupSpec from "@confect/core/GroupSpec";
+import * as Registry from "@confect/core/Registry";
 import type * as Spec from "@confect/core/Spec";
-import type { Layer } from "effect";
-import { Effect, Match, Ref, type Types } from "effect";
+import {
+  Array,
+  Effect,
+  type Layer,
+  Option,
+  pipe,
+  Predicate,
+  Ref,
+  String,
+  type Types,
+} from "effect";
 import type * as Api from "./Api";
-import * as Impl from "./Impl";
+import type * as GroupImpl from "./GroupImpl";
 import { mapLeaves } from "./internal/utils";
 import type * as RegisteredFunction from "./RegisteredFunction";
-import * as Registry from "./Registry";
 import * as RegistryItem from "./RegistryItem";
 
 export type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =
@@ -49,34 +58,75 @@ export interface AnyWithProps {
   readonly [key: string]: RegisteredFunction.Any | AnyWithProps;
 }
 
-export const make = <Api_ extends Api.AnyWithProps>(
-  impl: Layer.Layer<Impl.Impl<Api_, "Finalized">>,
+type RegisteredFunctionsAtPath<
+  Tree,
+  Path extends string,
+> = Path extends `${infer Head}.${infer Tail}`
+  ? Head extends keyof Tree
+    ? Tree[Head] extends AnyWithProps
+      ? RegisteredFunctionsAtPath<Tree[Head], Tail>
+      : never
+    : never
+  : Path extends keyof Tree
+    ? Tree[Path]
+    : never;
+
+export type ForGroupPath<
+  Spec_ extends Spec.AnyWithProps,
+  Path extends string,
+> = RegisteredFunctionsAtPath<RegisteredFunctions<Spec_>, Path>;
+
+/**
+ * Build the registered Convex functions for a single group from its finalized
+ * `GroupImpl` layer.
+ *
+ * The `groupLayer` parameter requires `GroupImpl<string, "Finalized">`, so
+ * impls that were never piped through `GroupImpl.finalize` (and impls with
+ * unmet `FunctionImpl` requirements, which cannot be finalized) are rejected
+ * at the codegen boundary, not just deep inside Convex at runtime.
+ */
+export const buildForGroup = <
+  Api_ extends Api.AnyWithProps,
+  const GroupPath_ extends string,
+>(
+  api: Api_,
+  groupPath: GroupPath_,
+  groupLayer: Layer.Layer<GroupImpl.GroupImpl<string, "Finalized">>,
   makeRegisteredFunction: (
     api: Api_,
     registryItem: RegistryItem.AnyWithProps,
   ) => RegisteredFunction.Any,
-) =>
-  Effect.gen(function* () {
+): ForGroupPath<Api_["spec"], GroupPath_> => {
+  const registryItems = Effect.gen(function* () {
     const registry = yield* Registry.Registry;
-    const functionImplItems = yield* Ref.get(registry);
-    const { api, finalizationStatus } = yield* Impl.Impl<Api_, "Finalized">();
+    return yield* Ref.get(registry);
+  }).pipe(Effect.provide(groupLayer), Effect.runSync);
 
-    return yield* Match.value(
-      finalizationStatus as Impl.FinalizationStatus,
-    ).pipe(
-      Match.withReturnType<Effect.Effect<RegisteredFunctions<Api_["spec"]>>>(),
-      Match.when("Unfinalized", () =>
-        Effect.dieMessage("Impl is not finalized"),
-      ),
-      Match.when("Finalized", () =>
-        Effect.succeed(
-          mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction.Any>(
-            functionImplItems,
-            RegistryItem.isRegistryItem,
-            (registryItem) => makeRegisteredFunction(api, registryItem),
-          ) as RegisteredFunctions<Api_["spec"]>,
+  const registeredFunctions = mapLeaves<
+    RegistryItem.AnyWithProps,
+    RegisteredFunction.Any
+  >(
+    registryItems as { [key: string]: RegistryItem.AnyWithProps },
+    RegistryItem.isRegistryItem,
+    (registryItem) => makeRegisteredFunction(api, registryItem),
+  );
+
+  return pipe(
+    String.split(groupPath, "."),
+    Array.reduce(
+      Option.some<unknown>(registeredFunctions),
+      (currentNode, segment) =>
+        currentNode.pipe(
+          Option.filter(Predicate.isRecord),
+          Option.flatMap((nodeRecord) =>
+            segment in nodeRecord
+              ? Option.some(nodeRecord[segment])
+              : Option.none(),
+          ),
         ),
-      ),
-      Match.exhaustive,
-    );
-  }).pipe(Effect.provide(impl), Effect.runSync);
+    ),
+    Option.getOrThrowWith(
+      () => new Error(`No functions registered for group path "${groupPath}"`),
+    ),
+  ) as ForGroupPath<Api_["spec"], GroupPath_>;
+};

package/src/index.ts

@@ -15,7 +15,6 @@ export * as FunctionImpl from "./FunctionImpl";
 export * as GroupImpl from "./GroupImpl";
 export * as Handler from "./Handler";
 export * as HttpApi from "./HttpApi";
-export * as Impl from "./Impl";
 export * as MutationCtx from "./MutationCtx";
 export * as MutationRunner from "./MutationRunner";
 export * as OrderedQuery from "./OrderedQuery";
@@ -25,7 +24,6 @@ export * as QueryRunner from "./QueryRunner";
 export * as RegisteredConvexFunction from "./RegisteredConvexFunction";
 export * as RegisteredFunction from "./RegisteredFunction";
 export * as RegisteredFunctions from "./RegisteredFunctions";
-export * as Registry from "./Registry";
 export * as RegistryItem from "./RegistryItem";
 export * as Scheduler from "./Scheduler";
 export * as SchemaToValidator from "./SchemaToValidator";

package/dist/Impl.d.ts

@@ -1,24 +0,0 @@
-import { AnyWithProps as AnyWithProps$1, Groups } from "./Api.js";
-import { FromGroups } from "./GroupImpl.js";
-import { Context, Layer } from "effect";
-
-//#region src/Impl.d.ts
-declare namespace Impl_d_exports {
-  export { AnyWithProps, FinalizationStatus, Impl, TypeId, finalize, isImpl, make };
-}
-declare const TypeId = "@confect/server/Impl";
-type TypeId = typeof TypeId;
-declare const isImpl: (u: unknown) => u is AnyWithProps;
-interface Impl<Api_ extends AnyWithProps$1, FinalizationStatus_ extends FinalizationStatus> {
-  readonly [TypeId]: TypeId;
-  readonly api: Api_;
-  readonly finalizationStatus: FinalizationStatus_;
-}
-type FinalizationStatus = "Unfinalized" | "Finalized";
-interface AnyWithProps extends Impl<AnyWithProps$1, FinalizationStatus> {}
-declare const Impl: <Api_ extends AnyWithProps$1, FinalizationStatus_ extends FinalizationStatus>() => Context.Tag<Impl<Api_, FinalizationStatus_>, Impl<Api_, FinalizationStatus_>>;
-declare const make: <Api_ extends AnyWithProps$1>(api: Api_) => Layer.Layer<Impl<Api_, "Unfinalized">, never, FromGroups<Groups<Api_>>>;
-declare const finalize: <Api_ extends AnyWithProps$1>(impl: Layer.Layer<Impl<Api_, "Unfinalized">>) => Layer.Layer<Impl<Api_, "Finalized">>;
-//#endregion
-export { AnyWithProps, FinalizationStatus, Impl, Impl_d_exports, TypeId, finalize, isImpl, make };
-//# sourceMappingURL=Impl.d.ts.map

package/dist/Impl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Impl.d.ts","names":[],"sources":["../src/Impl.ts"],"mappings":";;;;;;;;cAKa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,MAAA,GAAU,CAAA,cAAa,CAAA,IAAK,YAAA;AAAA,UAGxB,IAAA,cACF,cAAA,8BACe,kBAAA;EAAA,UAElB,MAAA,GAAS,MAAA;EAAA,SACV,GAAA,EAAK,IAAA;EAAA,SACL,kBAAA,EAAoB,mBAAA;AAAA;AAAA,KAGnB,kBAAA;AAAA,UAEK,YAAA,SAAqB,IAAA,CACpC,cAAA,EACA,kBAAA;AAAA,cAGW,IAAA,gBACE,cAAA,8BACe,kBAAA,OAAkB,OAAA,CAAA,GAAA,CAAA,IAAA,CAAA,IAAA,EAAA,mBAAA,GAAA,IAAA,CAAA,IAAA,EAAA,mBAAA;AAAA,cAInC,IAAA,gBAAqB,cAAA,EAChC,GAAA,EAAK,IAAA,KACJ,KAAA,CAAM,KAAA,CACP,IAAA,CAAK,IAAA,yBAEL,UAAA,CAAqB,MAAA,CAAU,IAAA;AAAA,cAWpB,QAAA,gBAAyB,cAAA,EACpC,IAAA,EAAM,KAAA,CAAM,KAAA,CAAM,IAAA,CAAK,IAAA,sBACtB,KAAA,CAAM,KAAA,CAAM,IAAA,CAAK,IAAA"}

package/dist/Impl.js

@@ -1,28 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Context, Effect, Layer, Predicate } from "effect";
-
-//#region src/Impl.ts
-var Impl_exports = /* @__PURE__ */ __exportAll({
-	Impl: () => Impl,
-	TypeId: () => TypeId,
-	finalize: () => finalize,
-	isImpl: () => isImpl,
-	make: () => make
-});
-const TypeId = "@confect/server/Impl";
-const isImpl = (u) => Predicate.hasProperty(u, TypeId);
-const Impl = () => Context.GenericTag(`@confect/server/Impl`);
-const make = (api) => Layer.effect(Impl(), Effect.succeed({
-	[TypeId]: TypeId,
-	api,
-	finalizationStatus: "Unfinalized"
-}));
-const finalize = (impl) => Layer.map(impl, (context) => Context.make(Impl(), {
-	[TypeId]: TypeId,
-	api: Context.get(context, Impl()).api,
-	finalizationStatus: "Finalized"
-}));
-
-//#endregion
-export { Impl, Impl_exports, TypeId, finalize, isImpl, make };
-//# sourceMappingURL=Impl.js.map

package/dist/Impl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Impl.js","names":[],"sources":["../src/Impl.ts"],"sourcesContent":["import { Context, Effect, Layer, Predicate } from \"effect\";\nimport type * as Api from \"./Api\";\nimport type { Groups as ApiGroups } from \"./Api\";\nimport type * as GroupImpl from \"./GroupImpl\";\n\nexport const TypeId = \"@confect/server/Impl\";\nexport type TypeId = typeof TypeId;\n\nexport const isImpl = (u: unknown): u is AnyWithProps =>\n  Predicate.hasProperty(u, TypeId);\n\nexport interface Impl<\n  Api_ extends Api.AnyWithProps,\n  FinalizationStatus_ extends FinalizationStatus,\n> {\n  readonly [TypeId]: TypeId;\n  readonly api: Api_;\n  readonly finalizationStatus: FinalizationStatus_;\n}\n\nexport type FinalizationStatus = \"Unfinalized\" | \"Finalized\";\n\nexport interface AnyWithProps extends Impl<\n  Api.AnyWithProps,\n  FinalizationStatus\n> {}\n\nexport const Impl = <\n  Api_ extends Api.AnyWithProps,\n  FinalizationStatus_ extends FinalizationStatus,\n>() =>\n  Context.GenericTag<Impl<Api_, FinalizationStatus_>>(`@confect/server/Impl`);\n\nexport const make = <Api_ extends Api.AnyWithProps>(\n  api: Api_,\n): Layer.Layer<\n  Impl<Api_, \"Unfinalized\">,\n  never,\n  GroupImpl.FromGroups<ApiGroups<Api_>>\n> =>\n  Layer.effect(\n    Impl<Api_, \"Unfinalized\">(),\n    Effect.succeed({\n      [TypeId]: TypeId,\n      api,\n      finalizationStatus: \"Unfinalized\" as const,\n    }),\n  );\n\nexport const finalize = <Api_ extends Api.AnyWithProps>(\n  impl: Layer.Layer<Impl<Api_, \"Unfinalized\">>,\n): Layer.Layer<Impl<Api_, \"Finalized\">> =>\n  Layer.map(impl, (context) =>\n    Context.make(Impl<Api_, \"Finalized\">(), {\n      [TypeId]: TypeId,\n      api: Context.get(context, Impl<Api_, \"Unfinalized\">()).api,\n      finalizationStatus: \"Finalized\",\n    }),\n  );\n"],"mappings":";;;;;;;;;;;AAKA,MAAa,SAAS;AAGtB,MAAa,UAAU,MACrB,UAAU,YAAY,GAAG,OAAO;AAkBlC,MAAa,aAIX,QAAQ,WAA4C,uBAAuB;AAE7E,MAAa,QACX,QAMA,MAAM,OACJ,MAA2B,EAC3B,OAAO,QAAQ;EACZ,SAAS;CACV;CACA,oBAAoB;CACrB,CAAC,CACH;AAEH,MAAa,YACX,SAEA,MAAM,IAAI,OAAO,YACf,QAAQ,KAAK,MAAyB,EAAE;EACrC,SAAS;CACV,KAAK,QAAQ,IAAI,SAAS,MAA2B,CAAC,CAAC;CACvD,oBAAoB;CACrB,CAAC,CACH"}

package/dist/Registry.d.ts

@@ -1,15 +0,0 @@
-import { AnyWithProps } from "./RegistryItem.js";
-import { Context, Ref } from "effect";
-
-//#region src/Registry.d.ts
-declare namespace Registry_d_exports {
-  export { Registry, RegistryItems };
-}
-interface RegistryItems {
-  readonly [key: string]: AnyWithProps | RegistryItems;
-}
-declare const Registry_base: Context.ReferenceClass<Registry, "@confect/server/Registry", Ref.Ref<RegistryItems>>;
-declare class Registry extends Registry_base {}
-//#endregion
-export { Registry, RegistryItems, Registry_d_exports };
-//# sourceMappingURL=Registry.d.ts.map

package/dist/Registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Registry.d.ts","names":[],"sources":["../src/Registry.ts"],"mappings":";;;;;;;UAGiB,aAAA;EAAA,UACL,GAAA,WAAc,YAAA,GAA4B,aAAA;AAAA;AAAA,cACrD,aAAA;cAEY,QAAA,SAAiB,aAAA"}

package/dist/Registry.js

@@ -1,10 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Context, Ref } from "effect";
-
-//#region src/Registry.ts
-var Registry_exports = /* @__PURE__ */ __exportAll({ Registry: () => Registry });
-var Registry = class extends Context.Reference()("@confect/server/Registry", { defaultValue: () => Ref.unsafeMake({}) }) {};
-
-//#endregion
-export { Registry, Registry_exports };
-//# sourceMappingURL=Registry.js.map

package/dist/Registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Registry.js","names":[],"sources":["../src/Registry.ts"],"sourcesContent":["import { Context, Ref } from \"effect\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport interface RegistryItems {\n  readonly [key: string]: RegistryItem.AnyWithProps | RegistryItems;\n}\n\nexport class Registry extends Context.Reference<Registry>()(\n  \"@confect/server/Registry\",\n  {\n    defaultValue: () => Ref.unsafeMake<RegistryItems>({}),\n  },\n) {}\n"],"mappings":";;;;;AAOA,IAAa,WAAb,cAA8B,QAAQ,WAAqB,CACzD,4BACA,EACE,oBAAoB,IAAI,WAA0B,EAAE,CAAC,EACtD,CACF,CAAC"}

package/src/Impl.ts

@@ -1,59 +0,0 @@
-import { Context, Effect, Layer, Predicate } from "effect";
-import type * as Api from "./Api";
-import type { Groups as ApiGroups } from "./Api";
-import type * as GroupImpl from "./GroupImpl";
-
-export const TypeId = "@confect/server/Impl";
-export type TypeId = typeof TypeId;
-
-export const isImpl = (u: unknown): u is AnyWithProps =>
-  Predicate.hasProperty(u, TypeId);
-
-export interface Impl<
-  Api_ extends Api.AnyWithProps,
-  FinalizationStatus_ extends FinalizationStatus,
-> {
-  readonly [TypeId]: TypeId;
-  readonly api: Api_;
-  readonly finalizationStatus: FinalizationStatus_;
-}
-
-export type FinalizationStatus = "Unfinalized" | "Finalized";
-
-export interface AnyWithProps extends Impl<
-  Api.AnyWithProps,
-  FinalizationStatus
-> {}
-
-export const Impl = <
-  Api_ extends Api.AnyWithProps,
-  FinalizationStatus_ extends FinalizationStatus,
->() =>
-  Context.GenericTag<Impl<Api_, FinalizationStatus_>>(`@confect/server/Impl`);
-
-export const make = <Api_ extends Api.AnyWithProps>(
-  api: Api_,
-): Layer.Layer<
-  Impl<Api_, "Unfinalized">,
-  never,
-  GroupImpl.FromGroups<ApiGroups<Api_>>
-> =>
-  Layer.effect(
-    Impl<Api_, "Unfinalized">(),
-    Effect.succeed({
-      [TypeId]: TypeId,
-      api,
-      finalizationStatus: "Unfinalized" as const,
-    }),
-  );
-
-export const finalize = <Api_ extends Api.AnyWithProps>(
-  impl: Layer.Layer<Impl<Api_, "Unfinalized">>,
-): Layer.Layer<Impl<Api_, "Finalized">> =>
-  Layer.map(impl, (context) =>
-    Context.make(Impl<Api_, "Finalized">(), {
-      [TypeId]: TypeId,
-      api: Context.get(context, Impl<Api_, "Unfinalized">()).api,
-      finalizationStatus: "Finalized",
-    }),
-  );

package/src/Registry.ts

@@ -1,13 +0,0 @@
-import { Context, Ref } from "effect";
-import type * as RegistryItem from "./RegistryItem";
-
-export interface RegistryItems {
-  readonly [key: string]: RegistryItem.AnyWithProps | RegistryItems;
-}
-
-export class Registry extends Context.Reference<Registry>()(
-  "@confect/server/Registry",
-  {
-    defaultValue: () => Ref.unsafeMake<RegistryItems>({}),
-  },
-) {}