@visiolab/effect-firebase 0.0.0-stage → 0.3.0

package/dist/functions/FunctionGroup.d.mts

@@ -0,0 +1,175 @@
+import { Any as Any$1, Handler } from "./FirebaseFunction.mjs";
+import { Pipeable } from "effect";
+declare namespace FunctionGroup_d_exports {
+  export { Any, FunctionGroup, Handlers, Member, Members, Names, isFunctionGroup, make };
+}
+declare const TypeId = "~@visiolab/effect-firebase/functions/FunctionGroup";
+/**
+ * A Function Group: a name and the Functions it deploys under that name.
+ *
+ * **Details**
+ *
+ * A group is a class, so `class Users extends FunctionGroup.make("users")`
+ * gives it a name of its own in types and in hovers. Its name is
+ * `identifier`, since a class already has a `name` of its own.
+ *
+ * A group holds Functions of any kind, so a group can follow a domain, such
+ * as `posts`, rather than a kind. A Function's name is unique within its
+ * group. `.add` checks this when the module loads; the types don't. A
+ * Function can be in more than one group, and each group serves and
+ * implements it separately. Groups don't nest.
+ *
+ * A group is only a name and its members. It carries no middleware: attach a
+ * Callable Middleware to each Callable that needs it with
+ * {@link Callable.Callable.middleware}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface FunctionGroup<out Identifier extends string, in out Functions extends Any$1 = never> extends Pipeable.Pipeable {
+  new (_: never): {};
+  readonly [TypeId]: typeof TypeId;
+  /** The group's name: the prefix its members deploy under. */
+  readonly identifier: Identifier;
+  /** The group's members, keyed by their names. */
+  readonly functions: { readonly [F in Functions as F["name"]]: F; };
+  /**
+   * Adds Functions of any kind to the group.
+   *
+   * **Details**
+   *
+   * Returns a new group. Throws when a Function's name is already taken in
+   * the group, so a clash fails when the module loads, before anything
+   * deploys. The types don't catch a clash.
+   */
+  add<const A extends ReadonlyArray<Any$1>>(...functions: A): FunctionGroup<Identifier, Functions | A[number]>;
+}
+/**
+ * Any {@link FunctionGroup}, whatever its name and members.
+ *
+ * @stability unstable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Any {
+  readonly [TypeId]: typeof TypeId;
+  readonly identifier: string;
+  readonly functions: {
+    readonly [name: string]: Any$1;
+  };
+}
+/**
+ * The members of a {@link FunctionGroup}, as a union of Functions.
+ *
+ * **When to use**
+ *
+ * Use to read every member of a group. Pass the `Any` of a kind as `K`, such
+ * as `Members<typeof Users, Callable.Any>`, to keep only the members of that
+ * kind.
+ *
+ * @see {@link Names} for the names of the members
+ * @see {@link Member} for the member of one name
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Members<G, K extends Any$1 = Any$1> = G extends {
+  readonly functions: infer Record;
+} ? Extract<Record[keyof Record], K> : never;
+/**
+ * The names of the members of a {@link FunctionGroup}.
+ *
+ * **When to use**
+ *
+ * Use to key something on a group's members. Pass the `Any` of a kind as `K`
+ * to keep only the names of the members of that kind.
+ *
+ * @see {@link Members} for the members themselves
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Names<G, K extends Any$1 = Any$1> = Members<G, K>["name"];
+/**
+ * The member of a {@link FunctionGroup} named `Name`.
+ *
+ * **When to use**
+ *
+ * Use to read one member's type by its name. Pass the `Any` of a kind as `K`
+ * to get `never` unless the member is of that kind.
+ *
+ * @see {@link Members} for every member
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Member<G, Name extends string, K extends Any$1 = Any$1> = Extract<Members<G, K>, {
+  readonly name: Name;
+}>;
+/**
+ * The {@link FirebaseFunction.Handler}s that serving a {@link FunctionGroup}
+ * needs: one per member, keyed by the group.
+ *
+ * @stability unstable
+ * @category type-level
+ * @since 0.3.0
+ */
+export type Handlers<G extends Any> = Names<G> extends (infer Name) ? Name extends string ? Handler<G["identifier"], Name> : never : never;
+/**
+ * Checks whether a value is a {@link FunctionGroup}. A building block for the
+ * functions and client packages, which take a Function or a group. Most apps
+ * don't need it.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 0.3.0
+ */
+export declare const isFunctionGroup: (u: unknown) => u is Any;
+/**
+ * Starts a Function Group with no members.
+ *
+ * **When to use**
+ *
+ * Use to collect related Functions, of any kind, under one prefix, and to
+ * deploy them as one. A Function that stands alone needs no group.
+ *
+ * **Details**
+ *
+ * Add members with `.add`. Extend the result as a class, so the group has a
+ * name of its own. Each member deploys as `<identifier>-<name>`.
+ *
+ * A client built from a Callable on its own, rather than from its group,
+ * calls the name without the prefix and fails with `not-found`. Nothing
+ * checks this at runtime.
+ *
+ * @example Serving one Callable in two groups
+ * ```ts
+ * import { Schema } from "effect";
+ * import { Callable, FunctionGroup } from "@visiolab/effect-firebase/functions";
+ *
+ * const GetUser = Callable.make("get", {
+ *   payload: { id: Schema.String },
+ *   success: Schema.String,
+ * });
+ *
+ * // Deploys as `users-get` and `admins-get`, each with a handler of its own.
+ * class Users extends FunctionGroup.make("users").add(GetUser) {}
+ * class Admins extends FunctionGroup.make("admins").add(GetUser) {}
+ * ```
+ *
+ * @see {@link Callable.make} for declaring a Callable member
+ * @see {@link Callable.toLayer} for implementing a Callable member
+ * @see {@link DocumentTrigger.created} for declaring a Document Trigger member
+ * @see {@link DocumentTrigger.toLayer} for implementing a Document Trigger member
+ * @see {@link Functions.group} for deploying the group
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const make: <const Identifier extends string>(identifier: Identifier) => FunctionGroup<Identifier>;
+export { FunctionGroup_d_exports };

package/dist/functions/FunctionGroup.mjs

@@ -0,0 +1,64 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { isFunctionGroup as isFunctionGroup$1, make as make$1 } from "./internal/functionGroup.mjs";
+// src/functions/FunctionGroup.ts
+var FunctionGroup_exports = /* @__PURE__ */ __exportAll({
+	isFunctionGroup: () => isFunctionGroup,
+	make: () => make
+});
+/**
+* Checks whether a value is a {@link FunctionGroup}. A building block for the
+* functions and client packages, which take a Function or a group. Most apps
+* don't need it.
+*
+* @stability unstable
+* @category guards
+* @since 0.3.0
+*/
+const isFunctionGroup = isFunctionGroup$1;
+/**
+* Starts a Function Group with no members.
+*
+* **When to use**
+*
+* Use to collect related Functions, of any kind, under one prefix, and to
+* deploy them as one. A Function that stands alone needs no group.
+*
+* **Details**
+*
+* Add members with `.add`. Extend the result as a class, so the group has a
+* name of its own. Each member deploys as `<identifier>-<name>`.
+*
+* A client built from a Callable on its own, rather than from its group,
+* calls the name without the prefix and fails with `not-found`. Nothing
+* checks this at runtime.
+*
+* @example Serving one Callable in two groups
+* ```ts
+* import { Schema } from "effect";
+* import { Callable, FunctionGroup } from "@visiolab/effect-firebase/functions";
+*
+* const GetUser = Callable.make("get", {
+*   payload: { id: Schema.String },
+*   success: Schema.String,
+* });
+*
+* // Deploys as `users-get` and `admins-get`, each with a handler of its own.
+* class Users extends FunctionGroup.make("users").add(GetUser) {}
+* class Admins extends FunctionGroup.make("admins").add(GetUser) {}
+* ```
+*
+* @see {@link Callable.make} for declaring a Callable member
+* @see {@link Callable.toLayer} for implementing a Callable member
+* @see {@link DocumentTrigger.created} for declaring a Document Trigger member
+* @see {@link DocumentTrigger.toLayer} for implementing a Document Trigger member
+* @see {@link Functions.group} for deploying the group
+*
+* @stability unstable
+* @category constructors
+* @since 0.3.0
+*/
+const make = (identifier) => make$1({
+	identifier,
+	functions: {}
+});
+export { FunctionGroup_exports, isFunctionGroup, make };

package/dist/functions/index.d.mts

@@ -0,0 +1,9 @@
+import { CallableError_d_exports } from "./CallableError.mjs";
+import { CallableRequest_d_exports } from "./CallableRequest.mjs";
+import { CallableMiddleware_d_exports } from "./CallableMiddleware.mjs";
+import { FirebaseFunction_d_exports } from "./FirebaseFunction.mjs";
+import { FunctionGroup_d_exports } from "./FunctionGroup.mjs";
+import { Callable_d_exports } from "./Callable.mjs";
+import { Caller_d_exports } from "./Caller.mjs";
+import { DocumentTrigger_d_exports } from "./DocumentTrigger.mjs";
+export { Callable_d_exports as Callable, CallableError_d_exports as CallableError, CallableMiddleware_d_exports as CallableMiddleware, CallableRequest_d_exports as CallableRequest, Caller_d_exports as Caller, DocumentTrigger_d_exports as DocumentTrigger, FirebaseFunction_d_exports as FirebaseFunction, FunctionGroup_d_exports as FunctionGroup };

package/dist/functions/index.mjs

@@ -0,0 +1,9 @@
+import { CallableError_exports } from "./CallableError.mjs";
+import { Callable_exports } from "./Callable.mjs";
+import { CallableMiddleware_exports } from "./CallableMiddleware.mjs";
+import { CallableRequest_exports } from "./CallableRequest.mjs";
+import { Caller_exports } from "./Caller.mjs";
+import { DocumentTrigger_exports } from "./DocumentTrigger.mjs";
+import { FirebaseFunction_exports } from "./FirebaseFunction.mjs";
+import { FunctionGroup_exports } from "./FunctionGroup.mjs";
+export { Callable_exports as Callable, CallableError_exports as CallableError, CallableMiddleware_exports as CallableMiddleware, CallableRequest_exports as CallableRequest, Caller_exports as Caller, DocumentTrigger_exports as DocumentTrigger, FirebaseFunction_exports as FirebaseFunction, FunctionGroup_exports as FunctionGroup };

package/dist/functions/internal/callable.mjs

@@ -0,0 +1,167 @@
+import { CallableError, ResponseError } from "../CallableError.mjs";
+import { CallableRequest } from "./callableRequest.mjs";
+import { deployedName as deployedName$1, handlerKey as handlerKey$1 } from "./firebaseFunction.mjs";
+import { Context, Effect, Layer, Pipeable, Schema } from "effect";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+// src/functions/internal/callable.ts
+/** @internal */
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/functions/Callable";
+/** @internal */
+const kind = "Callable";
+const Proto = {
+	[TypeId]: TypeId,
+	middleware(middleware) {
+		return make({
+			kind,
+			name: this.name,
+			payload: this.payload,
+			success: this.success,
+			error: this.error,
+			middlewares: /* @__PURE__ */ new Set([...this.middlewares, middleware])
+		});
+	},
+	pipe() {
+		return Pipeable.pipeArguments(this, arguments);
+	}
+};
+/** @internal */
+const make = (fields) => Object.assign(Object.create(Proto), fields);
+/**
+* The key of the handler of the Callable `name` in `group`, or in no group.
+*
+* @internal
+*/
+const handlerKey = (group, name) => handlerKey$1(group, name);
+/** @internal */
+const toLayer = (group, name, handler) => Layer.effect(handlerKey(group, name), Effect.gen(function* () {
+	const run = Effect.isEffect(handler) ? yield* handler : handler;
+	const built = yield* Effect.context();
+	return (payload) => Effect.updateContext(run(payload), (call) => Context.merge(built, call));
+}));
+/**
+* Schemas with their services erased: a Callable's codecs need none that the
+* types track, and `Schema.Top` leaves them `unknown`.
+*/
+const codec = (schema) => Schema.toCodecJson(schema);
+/** @internal */
+const getErrorCode = (schema) => Schema.resolveAnnotations(schema)?.callableErrorCode ?? "internal";
+/**
+* The name `callable` is deployed under: its own in no group, or
+* `<group>-<name>` in `group`. The server exports it under this name, and the
+* client calls it.
+*
+* @internal
+*/
+const deployedName = deployedName$1;
+/**
+* The attributes of the server's and the client's span of a call to
+* `callable` in `group`, or in no group.
+*
+* @internal
+*/
+const spanAttributes = (group, callable) => ({
+	"rpc.system": "firebase_callable",
+	"rpc.method": callable.name,
+	...group === void 0 ? {} : { "rpc.service": group.identifier },
+	"faas.name": deployedName(group, callable)
+});
+/**
+* The schemas of every error a call to `callable` can be answered with: its
+* declared errors, then those of its middleware.
+*
+* @internal
+*/
+const errorSchemas = (callable) => [...callable.error, ...[...callable.middlewares].flatMap((middleware) => [...middleware.error])];
+/**
+* Turns a failure of the call into the answer that carries it: the code of
+* the error schema it matches, a readable message, and the encoded error. A
+* failure no schema matches, or one that doesn't encode, is a defect.
+*/
+const encodeFailure = (schemas, error) => Effect.gen(function* () {
+	for (const schema of schemas) {
+		if (!Schema.is(schema)(error)) continue;
+		const code = getErrorCode(schema);
+		const details = yield* Effect.orDie(Schema.encodeUnknownEffect(codec(schema))(error));
+		const fields = error;
+		const message = typeof fields.message === "string" && fields.message !== "" ? fields.message : typeof fields._tag === "string" ? fields._tag : code;
+		return new ResponseError({
+			code,
+			message,
+			details
+		});
+	}
+	return yield* Effect.die(error);
+});
+/**
+* The failure of a raw Payload that doesn't decode, as it leaves the chain.
+* Middleware sees it like any other failure.
+*/
+var PayloadDecodeError = class {
+	cause;
+	constructor(cause) {
+		this.cause = cause;
+	}
+};
+/**
+* The middleware chain of `callable` in `group`, or in no group, around the
+* Payload's decoding and the handler. `serve`, which `Functions` runs,
+* and `handler` both run this one chain.
+*
+* The middleware implementations are read from the context once. The context
+* the chain was read in sits under that of each call, and the call's request
+* on top of both.
+*
+* @internal
+*/
+const chain = (group, callable) => Effect.gen(function* () {
+	const handler = yield* Effect.service(handlerKey(group?.identifier, callable.name));
+	const context = yield* Effect.context();
+	const implementations = [...callable.middlewares].map((key) => Context.getUnsafe(context, key));
+	const decode = Schema.decodeUnknownEffect(codec(callable.payload));
+	return (request) => {
+		let effect = decode(request.data).pipe(Effect.mapError((cause) => new PayloadDecodeError(cause)), Effect.flatMap(handler));
+		for (const implementation of implementations) effect = implementation(effect, { callable });
+		return effect.pipe(Effect.provideService(CallableRequest, request), Effect.updateContext((call) => Context.merge(context, call)));
+	};
+});
+/** @internal */
+const serve = (group, callable) => Effect.map(chain(group, callable), (run) => {
+	const encode = Schema.encodeUnknownEffect(codec(callable.success));
+	const schemas = errorSchemas(callable);
+	const fail = (reason) => new CallableError({
+		callable: deployedName(group, callable),
+		reason
+	});
+	return (request) => run(request).pipe(Effect.catch((error) => error instanceof PayloadDecodeError ? Effect.logDebug("The Payload of a Callable didn't decode", error.cause).pipe(Effect.andThen(Effect.fail(fail(new ResponseError({
+		code: "invalid-argument",
+		message: "The Payload didn't decode",
+		details: void 0
+	}))))) : Effect.flatMap(encodeFailure(schemas, error), (reason) => Effect.fail(fail(reason)))), Effect.flatMap((value) => Effect.orDie(encode(value))));
+});
+/**
+* The HTTP request of a call `handler` runs with no request given: a JSON
+* `POST` of the encoded Payload to the deployed name.
+*/
+const syntheticRequest = (name, data) => HttpServerRequest.fromWeb(new Request(`http://localhost/${name}`, {
+	method: "POST",
+	headers: { "content-type": "application/json" },
+	body: JSON.stringify(data)
+}));
+/** @internal */
+const handler = (group, callable) => Effect.map(chain(group, callable), (run) => {
+	const encode = Schema.encodeUnknownEffect(codec(callable.payload));
+	const name = deployedName(group, callable);
+	return (payload, input) => encode(payload).pipe(Effect.orDie, Effect.flatMap((data) => run({
+		auth: input.auth === void 0 ? void 0 : {
+			uid: input.auth.uid,
+			token: input.auth.token,
+			rawToken: input.auth.rawToken ?? ""
+		},
+		app: input.app,
+		instanceIdToken: input.instanceIdToken,
+		data,
+		rawRequest: input.rawRequest ?? syntheticRequest(name, data)
+	})), Effect.catchIf((error) => error instanceof PayloadDecodeError, (error) => Effect.die(error.cause)));
+});
+export { TypeId, chain, deployedName, errorSchemas, getErrorCode, handler, handlerKey, kind, make, serve, spanAttributes, toLayer };

package/dist/functions/internal/callableMiddleware.d.mts

@@ -0,0 +1,19 @@
+import { Context, Effect, Schema } from "effect";
+/**
+ * The middleware attached to a Callable, as a union, from its phantom
+ * `~Middleware` field.
+ *
+ * @internal
+ */
+export type Attached<X> = X extends {
+  readonly "~Middleware": infer M;
+} ? M : never;
+/**
+ * What the middleware attached to a Callable still requires, from its phantom
+ * `~MiddlewareServices` field.
+ *
+ * @internal
+ */
+export type AttachedServices<X> = X extends {
+  readonly "~MiddlewareServices": infer R;
+} ? R : never;

package/dist/functions/internal/callableMiddleware.mjs

@@ -0,0 +1,15 @@
+import { Context } from "effect";
+// src/functions/internal/callableMiddleware.ts
+/** @internal */
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/functions/CallableMiddleware";
+/** @internal */
+const Service = (id, options) => {
+	class Service extends Context.Service()(id) {}
+	const self = Service;
+	self[TypeId] = TypeId;
+	const error = options?.error;
+	self.error = new Set(error === void 0 ? [] : Array.isArray(error) ? error : [error]);
+	return self;
+};
+export { Service, TypeId };

package/dist/functions/internal/callableRequest.mjs

@@ -0,0 +1,6 @@
+import { Context } from "effect";
+// src/functions/internal/callableRequest.ts
+/** @internal */
+/** @internal */
+const CallableRequest = Context.Service("@visiolab/effect-firebase/functions/CallableRequest");
+export { CallableRequest };

package/dist/functions/internal/documentTrigger.d.mts

@@ -0,0 +1,10 @@
+import "../../firestore/DocumentSnapshot.mjs";
+import "../../firestore/Collection.mjs";
+import "./firebaseFunction.mjs";
+import { Context, Effect, Layer } from "effect";
+/**
+ * The changes to a document a trigger can listen to.
+ *
+ * @internal
+ */
+export type EventKind = "created" | "deleted" | "updated" | "written";

package/dist/functions/internal/documentTrigger.mjs

@@ -0,0 +1,73 @@
+import { deployedName, handlerKey as handlerKey$1 } from "./firebaseFunction.mjs";
+import { Context, Effect, Layer, Pipeable } from "effect";
+// src/functions/internal/documentTrigger.ts
+/** @internal */
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/functions/DocumentTrigger";
+/** @internal */
+const kind = "DocumentTrigger";
+const Proto = {
+	[TypeId]: TypeId,
+	pipe() {
+		return Pipeable.pipeArguments(this, arguments);
+	}
+};
+/** @internal */
+const make = (fields) => Object.assign(Object.create(Proto), fields);
+/**
+* The key of the handler of the Document Trigger `name` in `group`, or in no
+* group.
+*
+* @internal
+*/
+const handlerKey = (group, name) => handlerKey$1(group, name);
+/** @internal */
+const toLayer = (group, name, handler) => Layer.effect(handlerKey(group, name), Effect.gen(function* () {
+	const run = Effect.isEffect(handler) ? yield* handler : handler;
+	const built = yield* Effect.context();
+	return (event) => Effect.updateContext(run(event), (call) => Context.merge(built, call));
+}));
+/** @internal */
+const serve = (group, trigger) => Effect.service(handlerKey(group?.identifier, trigger.name));
+/**
+* The path pattern of the documents of `collection`, with a wildcard of its
+* own for each ancestor id and for the document id:
+* `users/{id0}/posts/{id1}`. The wildcards are only ever read back through
+* the event's document path, so their names are free.
+*
+* @internal
+*/
+const documentPattern = (collection) => collection.path.map((segment, i) => `${segment}/{id${i}}`).join("/");
+/** @internal */
+const deployment = (group, trigger) => ({
+	name: deployedName(group, trigger),
+	document: documentPattern(trigger.collection)
+});
+/** @internal */
+const createdEvent = (input) => ({
+	id: input.id,
+	time: input.time,
+	ref: input.snapshot.ref,
+	snapshot: input.snapshot
+});
+/**
+* A `deleted` event has the shape of a `created` one, with the document as it
+* was just before it was deleted.
+*
+* @internal
+*/
+const deletedEvent = createdEvent;
+/**
+* The event of a change with a document on each side. Both sides are at the
+* same reference; `ref` is taken from `after`.
+*
+* @internal
+*/
+const changeEvent = (input) => ({
+	id: input.id,
+	time: input.time,
+	ref: input.after.ref,
+	before: input.before,
+	after: input.after
+});
+export { TypeId, changeEvent, createdEvent, deletedEvent, deployment, documentPattern, handlerKey, kind, make, serve, toLayer };

package/dist/functions/internal/firebaseFunction.d.mts

@@ -0,0 +1,5 @@
+import { Context } from "effect";
+/** @internal */
+export declare const NoGroupTypeId = "~@visiolab/effect-firebase/functions/FirebaseFunction/NoGroup";
+/** @internal */
+export declare const HandlerTypeId = "~@visiolab/effect-firebase/functions/FirebaseFunction/Handler";

package/dist/functions/internal/firebaseFunction.mjs

@@ -0,0 +1,24 @@
+import { Context } from "effect";
+// src/functions/internal/firebaseFunction.ts
+/** @internal */
+/**
+* The key of the handler of the Function `name` in `group`, or in no group,
+* whatever its kind. A kind decides what it holds.
+*
+* Context keys are compared by their string, so every call with the same group
+* and name reaches the same service. Deployed names can't contain `/`, so the
+* two forms can't collide. Names are unique within a group, and a Function in
+* no group is deployed under its name, so two kinds never share a key they
+* could both be served under.
+*
+* @internal
+*/
+const handlerKey = (group, name) => Context.Service(group === void 0 ? `@visiolab/effect-firebase/functions/Handler/${name}` : `@visiolab/effect-firebase/functions/Handler/${group}/${name}`);
+/**
+* The name `fn` is deployed under: its own in no group, or `<group>-<name>`
+* in `group`.
+*
+* @internal
+*/
+const deployedName = (group, fn) => group === void 0 ? fn.name : `${group.identifier}-${fn.name}`;
+export { deployedName, handlerKey };

package/dist/functions/internal/functionGroup.mjs

@@ -0,0 +1,36 @@
+import { Pipeable } from "effect";
+// src/functions/internal/functionGroup.ts
+/** @internal */
+/** @internal */
+const TypeId = "~@visiolab/effect-firebase/functions/FunctionGroup";
+/** @internal */
+const isFunctionGroup = (u) => (typeof u === "function" || typeof u === "object" && u !== null) && "~@visiolab/effect-firebase/functions/FunctionGroup" in u;
+const Proto = {
+	[TypeId]: TypeId,
+	add(...toAdd) {
+		const functions = { ...this.functions };
+		for (const fn of toAdd) {
+			if (Object.hasOwn(functions, fn.name)) throw new Error(`The Function Group "${this.identifier}" already has a Function named "${fn.name}"`);
+			functions[fn.name] = fn;
+		}
+		return make({
+			identifier: this.identifier,
+			functions
+		});
+	},
+	pipe() {
+		return Pipeable.pipeArguments(this, arguments);
+	}
+};
+/**
+* A function, so that a group can be the base of a class. Its `name` is the
+* function's own, so the group's name is its `identifier`.
+*
+* @internal
+*/
+const make = (fields) => {
+	function FunctionGroup() {}
+	Object.setPrototypeOf(FunctionGroup, Proto);
+	return Object.assign(FunctionGroup, fields);
+};
+export { TypeId, isFunctionGroup, make };