@gaganref/confect-server 10.3.1-fork.8 → 10.3.1-fork.80

package/dist/internal/httpBody.d.ts

@@ -0,0 +1,13 @@
+import type * as ByteSize from "effect/ByteSize";
+import * as Effect from "effect/Effect";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
+/**
+ * Count the body before downstream middleware or decoding. Configure maxBytes
+ * from the endpoint's policy. Non-identity Content-Encoding receives 415. Read
+ * arrayBuffer in the wrapped effect to verify the same bytes the decoder uses.
+ */
+export declare const withBodyLimit: <A, E, R>(effect: Effect.Effect<A, E, R>, options: {
+    readonly maxBytes: ByteSize.ByteSize;
+}) => Effect.Effect<A | HttpServerResponse.HttpServerResponse, E, HttpServerRequest.HttpServerRequest | Exclude<R, HttpServerRequest.HttpServerRequest>>;
+//# sourceMappingURL=httpBody.d.ts.map

package/dist/internal/httpBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpBody.d.ts","sourceRoot":"","sources":["../../src/internal/httpBody.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,iBAAiB,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,kBAAkB,MAAM,gCAAgC,CAAC;AAOrE;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,UAC3B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,WACrB;IAAE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAA;CAAE,uJAoD/C,CAAC"}

package/dist/internal/httpBody.js

@@ -0,0 +1,47 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
+//#region src/internal/httpBody.ts
+var BodyTooLarge = class extends Schema.TaggedError()("BodyTooLarge", {}) {};
+/**
+* Count the body before downstream middleware or decoding. Configure maxBytes
+* from the endpoint's policy. Non-identity Content-Encoding receives 415. Read
+* arrayBuffer in the wrapped effect to verify the same bytes the decoder uses.
+*/
+const withBodyLimit = (effect, options) => Effect.gen(function* () {
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const encoding = request.headers["content-encoding"]?.trim().toLowerCase();
+	if (encoding !== void 0 && encoding !== "identity") return HttpServerResponse.empty({ status: 415 });
+	let size = 0;
+	const chunks = [];
+	if (yield* (request.source instanceof Request && request.source.body === null ? Effect.void : Stream.runForEach(request.stream, (chunk) => {
+		size += chunk.byteLength;
+		if (BigInt(size) > options.maxBytes) return Effect.fail(new BodyTooLarge());
+		chunks.push(chunk);
+		return Effect.void;
+	})).pipe(Effect.as(false), Effect.catchTag("BodyTooLarge", () => Effect.succeed(true)), Effect.orDie)) return HttpServerResponse.empty({ status: 413 });
+	const bytes = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	const source = new Request(request.originalUrl, {
+		method: request.method,
+		headers: request.headers,
+		...request.method === "GET" || request.method === "HEAD" ? {} : { body: bytes }
+	});
+	source.arrayBuffer = () => Promise.resolve(bytes.buffer);
+	source.text = () => Promise.resolve(new TextDecoder().decode(bytes));
+	const buffered = HttpServerRequest.fromWeb(source).modify({
+		url: request.url,
+		remoteAddress: request.remoteAddress
+	});
+	return yield* Effect.provideService(effect, HttpServerRequest.HttpServerRequest, buffered);
+});
+//#endregion
+export { withBodyLimit };
+
+//# sourceMappingURL=httpBody.js.map

package/dist/internal/httpBody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpBody.js","names":[],"sources":["../../src/internal/httpBody.ts"],"sourcesContent":["import type * as ByteSize from \"effect/ByteSize\";\nimport * as Effect from \"effect/Effect\";\nimport * as Schema from \"effect/Schema\";\nimport * as Stream from \"effect/Stream\";\nimport * as HttpServerRequest from \"effect/http/HttpServerRequest\";\nimport * as HttpServerResponse from \"effect/http/HttpServerResponse\";\n\nclass BodyTooLarge extends Schema.TaggedError<BodyTooLarge>()(\n  \"BodyTooLarge\",\n  {},\n) {}\n\n/**\n * Count the body before downstream middleware or decoding. Configure maxBytes\n * from the endpoint's policy. Non-identity Content-Encoding receives 415. Read\n * arrayBuffer in the wrapped effect to verify the same bytes the decoder uses.\n */\nexport const withBodyLimit = <A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  options: { readonly maxBytes: ByteSize.ByteSize },\n) =>\n  Effect.gen(function* () {\n    const request = yield* HttpServerRequest.HttpServerRequest;\n    const encoding = request.headers[\"content-encoding\"]?.trim().toLowerCase();\n    if (encoding !== undefined && encoding !== \"identity\")\n      return HttpServerResponse.empty({ status: 415 });\n    let size = 0;\n    const chunks: Array<Uint8Array> = [];\n    const empty =\n      request.source instanceof Request && request.source.body === null;\n    const read = empty\n      ? Effect.void\n      : Stream.runForEach(request.stream, (chunk) => {\n          size += chunk.byteLength;\n          if (BigInt(size) > options.maxBytes)\n            return Effect.fail(new BodyTooLarge());\n          chunks.push(chunk);\n          return Effect.void;\n        });\n    const limited = yield* read.pipe(\n      Effect.as(false),\n      Effect.catchTag(\"BodyTooLarge\", () => Effect.succeed(true)),\n      Effect.orDie,\n    );\n    if (limited) return HttpServerResponse.empty({ status: 413 });\n    const bytes = new Uint8Array(size);\n    let offset = 0;\n    for (const chunk of chunks) {\n      bytes.set(chunk, offset);\n      offset += chunk.byteLength;\n    }\n    const source = new Request(request.originalUrl, {\n      method: request.method,\n      headers: request.headers,\n      ...(request.method === \"GET\" || request.method === \"HEAD\"\n        ? {}\n        : { body: bytes }),\n    });\n    // WORKAROUND: Effect 4.0.4 caches text and bytes independently. Remove these\n    // overrides when the minimum Effect version shares text and byte reads.\n    source.arrayBuffer = () => Promise.resolve(bytes.buffer);\n    source.text = () => Promise.resolve(new TextDecoder().decode(bytes));\n    const buffered = HttpServerRequest.fromWeb(source).modify({\n      url: request.url,\n      remoteAddress: request.remoteAddress,\n    });\n    return yield* Effect.provideService(\n      effect,\n      HttpServerRequest.HttpServerRequest,\n      buffered,\n    );\n  });\n"],"mappings":";;;;;;AAOA,IAAM,eAAN,cAA2B,OAAO,YAA0B,CAAC,CAC3D,gBACA,CAAC,CACH,CAAC,CAAC,CAAC;;;;;;AAOH,MAAa,iBACX,QACA,YAEA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO,kBAAkB;CACzC,MAAM,WAAW,QAAQ,QAAQ,mBAAmB,EAAE,KAAK,CAAC,CAAC,YAAY;CACzE,IAAI,aAAa,KAAA,KAAa,aAAa,YACzC,OAAO,mBAAmB,MAAM,EAAE,QAAQ,IAAI,CAAC;CACjD,IAAI,OAAO;CACX,MAAM,SAA4B,CAAC;CAiBnC,IAAI,QAfF,QAAQ,kBAAkB,WAAW,QAAQ,OAAO,SAAS,OAE3D,OAAO,OACP,OAAO,WAAW,QAAQ,SAAS,UAAU;EAC3C,QAAQ,MAAM;EACd,IAAI,OAAO,IAAI,IAAI,QAAQ,UACzB,OAAO,OAAO,KAAK,IAAI,aAAa,CAAC;EACvC,OAAO,KAAK,KAAK;EACjB,OAAO,OAAO;CAChB,CAAC,EAAA,CACuB,KAC1B,OAAO,GAAG,KAAK,GACf,OAAO,SAAS,sBAAsB,OAAO,QAAQ,IAAI,CAAC,GAC1D,OAAO,KACT,GACa,OAAO,mBAAmB,MAAM,EAAE,QAAQ,IAAI,CAAC;CAC5D,MAAM,QAAQ,IAAI,WAAW,IAAI;CACjC,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,IAAI,OAAO,MAAM;EACvB,UAAU,MAAM;CAClB;CACA,MAAM,SAAS,IAAI,QAAQ,QAAQ,aAAa;EAC9C,QAAQ,QAAQ;EAChB,SAAS,QAAQ;EACjB,GAAI,QAAQ,WAAW,SAAS,QAAQ,WAAW,SAC/C,CAAC,IACD,EAAE,MAAM,MAAM;CACpB,CAAC;CAGD,OAAO,oBAAoB,QAAQ,QAAQ,MAAM,MAAM;CACvD,OAAO,aAAa,QAAQ,QAAQ,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK,CAAC;CACnE,MAAM,WAAW,kBAAkB,QAAQ,MAAM,CAAC,CAAC,OAAO;EACxD,KAAK,QAAQ;EACb,eAAe,QAAQ;CACzB,CAAC;CACD,OAAO,OAAO,OAAO,eACnB,QACA,kBAAkB,mBAClB,QACF;AACF,CAAC"}

package/dist/internal/httpOptions.d.ts

@@ -0,0 +1,4 @@
+import * as Layer from "effect/Layer";
+import * as HttpRouter from "effect/http/HttpRouter";
+export declare const withOptions: <A, E, R>(routes: Layer.Layer<A, E, R>, endpoints: ReadonlySet<string>) => Layer.Layer<A, E, HttpRouter.HttpRouter | Exclude<R, HttpRouter.HttpRouter> | Exclude<HttpRouter.Request<"Error", any>, A> | Exclude<HttpRouter.Request<"Requires", any>, A>>;
+//# sourceMappingURL=httpOptions.d.ts.map

package/dist/internal/httpOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpOptions.d.ts","sourceRoot":"","sources":["../../src/internal/httpOptions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,UAAU,MAAM,wBAAwB,CAAC;AA2CrD,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,UACzB,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,aACjB,WAAW,CAAC,MAAM,CAAC,kLAwG7B,CAAC"}

package/dist/internal/httpOptions.js

@@ -0,0 +1,83 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Exit from "effect/Exit";
+import * as HttpRouter from "effect/http/HttpRouter";
+import * as HttpServerError from "effect/http/HttpServerError";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+//#region src/internal/httpOptions.ts
+const notFound = Effect.flatMap(HttpServerRequest.HttpServerRequest, (request) => Effect.fail(new HttpServerError.HttpServerError({ reason: new HttpServerError.RouteNotFound({ request }) })));
+const optional = /(\/:[^/()]*?)\?(\/?)/;
+const forms = (path) => optional.test(path) ? [path.replace(optional, "$1$2"), path.replace(optional, "$2") || "/"] : [path];
+const missingRouteContext = `Service not found: ${HttpRouter.RouteContext.key}`;
+const preflight = (handler) => handler.pipe(Effect.updateContext(Context.omit(HttpRouter.RouteContext)), Effect.catchDefect((defect) => defect instanceof Error && defect.message === missingRouteContext ? notFound : Effect.die(defect)));
+const withOptions = (routes, endpoints) => Layer.unwrap(Effect.gen(function* () {
+	const router = yield* HttpRouter.HttpRouter;
+	const registered = [];
+	const wrap = (target, prefix) => {
+		const addAll = (entries) => Effect.contextWith((context) => {
+			for (const route of entries) registered.push({
+				route,
+				prefix,
+				context
+			});
+			return target.addAll(entries);
+		});
+		return HttpRouter.HttpRouter.of({
+			...target,
+			addAll,
+			add: (method, path, handler, options) => addAll([HttpRouter.route(method, path, handler, options)]),
+			prefixed: (next) => wrap(target.prefixed(next), `${prefix}${next.replace(/\/$/, "")}`)
+		});
+	};
+	const register = Effect.gen(function* () {
+		const byMethod = /* @__PURE__ */ new Map();
+		const first = yield* HttpRouter.make;
+		const explicit = yield* HttpRouter.make;
+		for (const { route, prefix, context } of registered) {
+			const at = (target) => prefix === "" ? target : target.prefixed(prefix);
+			if (route.method === "OPTIONS" || route.method === "*") {
+				yield* at(explicit).addAll([{
+					...route,
+					handler: notFound
+				}]);
+				continue;
+			}
+			const copy = {
+				...route,
+				method: "OPTIONS",
+				handler: endpoints.has(`${route.method} ${route.path}`) ? preflight(route.handler) : notFound
+			};
+			const candidate = byMethod.get(route.method) ?? (yield* HttpRouter.make);
+			byMethod.set(route.method, candidate);
+			yield* Effect.provideContext(at(candidate).addAll([copy]), context);
+			const placed = prefix === "" ? copy : HttpRouter.prefixRoute(copy, prefix);
+			for (const path of forms(placed.path)) {
+				const form = first.addAll([{
+					...placed,
+					path
+				}]);
+				yield* Effect.exit(Effect.provideContext(form, context));
+			}
+		}
+		const get = byMethod.get("GET");
+		if (get !== void 0) {
+			const head = byMethod.get("HEAD") ?? (yield* HttpRouter.make);
+			byMethod.set("HEAD", head);
+			yield* Effect.exit(head.add("OPTIONS", "*", get.asHttpEffect()));
+		}
+		const claimed = yield* Effect.exit(explicit.add("OPTIONS", "*", notFound));
+		if (Exit.isFailure(claimed)) return;
+		const candidates = new Map(Array.from(byMethod, ([method, candidate]) => [method, candidate.asHttpEffect()]));
+		const fallback = first.asHttpEffect();
+		yield* router.add("OPTIONS", "*", Effect.flatMap(HttpServerRequest.HttpServerRequest, (request) => {
+			const method = request.headers["access-control-request-method"];
+			return method === void 0 ? fallback : candidates.get(method) ?? notFound;
+		}));
+	});
+	return Layer.effectDiscard(register).pipe(Layer.provideMerge(routes.pipe(Layer.provide(Layer.succeed(HttpRouter.HttpRouter, wrap(router, ""))))));
+}));
+//#endregion
+export { withOptions };
+
+//# sourceMappingURL=httpOptions.js.map

package/dist/internal/httpOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpOptions.js","names":[],"sources":["../../src/internal/httpOptions.ts"],"sourcesContent":["import * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Exit from \"effect/Exit\";\nimport * as Layer from \"effect/Layer\";\nimport * as HttpRouter from \"effect/http/HttpRouter\";\nimport * as HttpServerError from \"effect/http/HttpServerError\";\nimport * as HttpServerRequest from \"effect/http/HttpServerRequest\";\n\n/* oxlint-disable effecttsgo/any-unknown-in-error-context -- Preserve the router's erased request errors at the routing boundary. */\n\ntype Route = Parameters<HttpRouter.HttpRouter[\"addAll\"]>[0][number];\n\nconst notFound = Effect.flatMap(\n  HttpServerRequest.HttpServerRequest,\n  (request) =>\n    Effect.fail(\n      new HttpServerError.HttpServerError({\n        reason: new HttpServerError.RouteNotFound({ request }),\n      }),\n    ),\n);\n\n// Effect's router adds `/a/:b` and `/a` for `/a/:b?` in one call, so an earlier\n// `/a/:id` rejects both. Split the same way, each form claims `first` alone.\nconst optional = /(\\/:[^/()]*?)\\?(\\/?)/;\nconst forms = (path: Route[\"path\"]) =>\n  (optional.test(path)\n    ? [path.replace(optional, \"$1$2\"), path.replace(optional, \"$2\") || \"/\"]\n    : [path]) as ReadonlyArray<Route[\"path\"]>;\n\nconst missingRouteContext = `Service not found: ${HttpRouter.RouteContext.key}`;\n\n// WORKAROUND: Effect 4.0.4 compiles endpoint middleware, decoding and the\n// handler into one route handler. Its endpoint body reads RouteContext before\n// decoding or calling the handler, so without RouteContext a preflight that\n// middleware passes on stops there. Remove when Effect can run an endpoint's\n// middleware around another handler.\nconst preflight = (handler: Route[\"handler\"]) =>\n  handler.pipe(\n    Effect.updateContext(Context.omit(HttpRouter.RouteContext)),\n    Effect.catchDefect((defect) =>\n      defect instanceof Error && defect.message === missingRouteContext\n        ? notFound\n        : Effect.die(defect),\n    ),\n  );\n\nexport const withOptions = <A, E, R>(\n  routes: Layer.Layer<A, E, R>,\n  endpoints: ReadonlySet<string>,\n) =>\n  Layer.unwrap(\n    Effect.gen(function* () {\n      const router = yield* HttpRouter.HttpRouter;\n      const registered: Array<{\n        readonly route: Route;\n        readonly prefix: string;\n        readonly context: Context.Context<never>;\n      }> = [];\n      const wrap = (\n        target: HttpRouter.HttpRouter,\n        prefix: string,\n      ): HttpRouter.HttpRouter => {\n        const addAll: HttpRouter.HttpRouter[\"addAll\"] = (entries) =>\n          Effect.contextWith((context: Context.Context<never>) => {\n            for (const route of entries)\n              registered.push({ route, prefix, context });\n            return target.addAll(entries);\n          });\n        return HttpRouter.HttpRouter.of({\n          ...target,\n          addAll,\n          add: (method, path, handler, options) =>\n            addAll([HttpRouter.route(method, path, handler, options)]),\n          prefixed: (next) =>\n            wrap(target.prefixed(next), `${prefix}${next.replace(/\\/$/, \"\")}`),\n        });\n      };\n      const register = Effect.gen(function* () {\n        // Effect's routers decide which paths match: one per declared method,\n        // and `first`, which refuses a path equivalent to an earlier one.\n        const byMethod = new Map<string, HttpRouter.HttpRouter>();\n        const first = yield* HttpRouter.make;\n        const explicit = yield* HttpRouter.make;\n        for (const { route, prefix, context } of registered) {\n          const at = (target: HttpRouter.HttpRouter) =>\n            prefix === \"\" ? target : target.prefixed(prefix);\n          if (route.method === \"OPTIONS\" || route.method === \"*\") {\n            yield* at(explicit).addAll([{ ...route, handler: notFound }]);\n            continue;\n          }\n          const copy: Route = {\n            ...route,\n            method: \"OPTIONS\",\n            handler: endpoints.has(`${route.method} ${route.path}`)\n              ? preflight(route.handler)\n              : notFound,\n          };\n          const candidate =\n            byMethod.get(route.method) ?? (yield* HttpRouter.make);\n          byMethod.set(route.method, candidate);\n          // Route registration erases request requirements, as in Effect's router.\n          yield* Effect.provideContext(at(candidate).addAll([copy]), context);\n          // Split the prefixed path: an optional parameter may sit in the prefix.\n          const placed =\n            prefix === \"\" ? copy : HttpRouter.prefixRoute(copy, prefix);\n          for (const path of forms(placed.path)) {\n            const form = first.addAll([{ ...placed, path }]);\n            yield* Effect.exit(Effect.provideContext(form, context));\n          }\n        }\n        // Effect's router answers HEAD from GET where no HEAD route matches. The\n        // root wildcard matches last, unless a HEAD route already claims it.\n        const get = byMethod.get(\"GET\");\n        if (get !== undefined) {\n          const head = byMethod.get(\"HEAD\") ?? (yield* HttpRouter.make);\n          byMethod.set(\"HEAD\", head);\n          yield* Effect.exit(head.add(\"OPTIONS\", \"*\", get.asHttpEffect()));\n        }\n        // An explicit OPTIONS route on the root wildcard answers every path.\n        const claimed = yield* Effect.exit(\n          explicit.add(\"OPTIONS\", \"*\", notFound),\n        );\n        if (Exit.isFailure(claimed)) return;\n        const candidates = new Map(\n          Array.from(byMethod, ([method, candidate]) => [\n            method,\n            candidate.asHttpEffect(),\n          ]),\n        );\n        const fallback = first.asHttpEffect();\n        // The root wildcard matches last, so explicit OPTIONS routes still win.\n        yield* router.add(\n          \"OPTIONS\",\n          \"*\",\n          Effect.flatMap(HttpServerRequest.HttpServerRequest, (request) => {\n            const method = request.headers[\"access-control-request-method\"];\n            return method === undefined\n              ? fallback\n              : (candidates.get(method) ?? notFound);\n          }),\n        );\n      });\n      return Layer.effectDiscard(register).pipe(\n        Layer.provideMerge(\n          routes.pipe(\n            Layer.provide(\n              Layer.succeed(HttpRouter.HttpRouter, wrap(router, \"\")),\n            ),\n          ),\n        ),\n      );\n    }),\n  );\n"],"mappings":"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"}

package/dist/internal/observability.d.ts

@@ -0,0 +1,5 @@
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+export declare const scope: Scope.Closeable;
+export declare const memoized: (layer: Layer.Layer<never>) => Layer.Layer<never>;
+//# sourceMappingURL=observability.d.ts.map

package/dist/internal/observability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability.d.ts","sourceRoot":"","sources":["../../src/internal/observability.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAItC,eAAO,MAAM,KAAK,iBAAqB,CAAC;AAGxC,eAAO,MAAM,QAAQ,UAAW,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAerE,CAAC"}

package/dist/internal/observability.js

@@ -0,0 +1,21 @@
+import { layer } from "../ConvexConfigProvider.js";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+import * as Scope from "effect/Scope";
+//#region src/internal/observability.ts
+const memoMap = Layer.makeMemoMapUnsafe();
+const scope = Scope.makeUnsafe();
+const layers = /* @__PURE__ */ new WeakMap();
+const memoized = (layer$1) => {
+	const cached = layers.get(layer$1);
+	if (cached !== void 0) return cached;
+	const built = Layer.buildWithMemoMap(layer$1, memoMap, scope).pipe(Effect.provide(layer), Effect.cachedWithTTL((exit) => Exit.isSuccess(exit) ? Duration.infinity : Duration.zero), Effect.runSync, Effect.uninterruptible, Layer.effectContext);
+	layers.set(layer$1, built);
+	return built;
+};
+//#endregion
+export { memoized, scope };
+
+//# sourceMappingURL=observability.js.map

package/dist/internal/observability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability.js","names":["layer","ConvexConfigProvider.layer"],"sources":["../../src/internal/observability.ts"],"sourcesContent":["import * as Duration from \"effect/Duration\";\nimport * as Effect from \"effect/Effect\";\nimport * as Exit from \"effect/Exit\";\nimport * as Layer from \"effect/Layer\";\nimport * as Scope from \"effect/Scope\";\nimport * as ConvexConfigProvider from \"../ConvexConfigProvider.js\";\n\nconst memoMap = Layer.makeMemoMapUnsafe();\nexport const scope = Scope.makeUnsafe();\nconst layers = new WeakMap<Layer.Layer<never>, Layer.Layer<never>>();\n\nexport const memoized = (layer: Layer.Layer<never>): Layer.Layer<never> => {\n  const cached = layers.get(layer);\n  if (cached !== undefined) return cached;\n  const built = Layer.buildWithMemoMap(layer, memoMap, scope).pipe(\n    Effect.provide(ConvexConfigProvider.layer),\n    // A failed first build is retried on the next invocation instead of failing every later one.\n    Effect.cachedWithTTL((exit) =>\n      Exit.isSuccess(exit) ? Duration.infinity : Duration.zero,\n    ),\n    Effect.runSync,\n    Effect.uninterruptible,\n    Layer.effectContext,\n  );\n  layers.set(layer, built);\n  return built;\n};\n"],"mappings":";;;;;;;AAOA,MAAM,UAAU,MAAM,kBAAkB;AACxC,MAAa,QAAQ,MAAM,WAAW;AACtC,MAAM,yBAAS,IAAI,QAAgD;AAEnE,MAAa,YAAY,YAAkD;CACzE,MAAM,SAAS,OAAO,IAAIA,OAAK;CAC/B,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,MAAM,QAAQ,MAAM,iBAAiBA,SAAO,SAAS,KAAK,CAAC,CAAC,KAC1D,OAAO,QAAQC,KAA0B,GAEzC,OAAO,eAAe,SACpB,KAAK,UAAU,IAAI,IAAI,SAAS,WAAW,SAAS,IACtD,GACA,OAAO,SACP,OAAO,iBACP,MAAM,aACR;CACA,OAAO,IAAID,SAAO,KAAK;CACvB,OAAO;AACT"}

package/dist/internal/reservedArgument.d.ts

@@ -0,0 +1,8 @@
+import * as Ref from "@confect/core/Ref";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Tracer from "effect/Tracer";
+export declare const Forward: Context.Reference<((span: Tracer.Span) => unknown) | undefined>;
+export declare const runWithCodec: <Ref_ extends Ref.Any>(ref: Ref_, args: Ref.Args<Ref_>, call: (native: Ref.FunctionReference<Ref_>, encoded: unknown) => PromiseLike<unknown>) => Effect.Effect<Ref.Returns<Ref_>, import("effect/Schema").SchemaError | Ref.Error<Ref_>, never>;
+export declare const encodeArgs: <Ref_ extends Ref.Any>(ref: Ref_, args: Ref.Args<Ref_>) => Effect.Effect<unknown, never, never>;
+//# sourceMappingURL=reservedArgument.d.ts.map

package/dist/internal/reservedArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reservedArgument.d.ts","sourceRoot":"","sources":["../../src/internal/reservedArgument.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,mBAAmB,CAAC;AACzC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,eAAO,MAAM,OAAO,4BACV,MAAM,CAAC,IAAI,KAAK,OAAO,cAG/B,CAAC;AAyBH,eAAO,MAAM,YAAY,GAAI,IAAI,SAAS,GAAG,CAAC,GAAG,OAC1C,IAAI,QACH,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,QACd,CACJ,MAAM,EAAE,GAAG,CAAC,iBAAiB,CAAC,IAAI,CAAC,EACnC,OAAO,EAAE,OAAO,KACb,WAAW,CAAC,OAAO,CAAC,mGAMxB,CAAC;AAEJ,eAAO,MAAM,UAAU,GAAI,IAAI,SAAS,GAAG,CAAC,GAAG,OACxC,IAAI,QACH,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,yCAInB,CAAC"}

package/dist/internal/reservedArgument.js

@@ -0,0 +1,30 @@
+import { convexToJson } from "convex/values";
+import * as Ref from "@confect/core/Ref";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Tracer from "effect/Tracer";
+//#region src/internal/reservedArgument.ts
+const Forward = Context.Reference("@confect/server/RegisteredFunction/Forward", { defaultValue: () => void 0 });
+const inject = (ref, encoded, context) => {
+	if (ref.reservedArgument === void 0 || ref.functionType === "query") return encoded;
+	const forward = Context.get(context, Forward);
+	const span = Context.getOrUndefined(context, Tracer.ParentSpan);
+	if (forward === void 0 || span?._tag !== "Span") return encoded;
+	try {
+		const value = forward(span);
+		if (value === void 0) return encoded;
+		convexToJson(value);
+		return {
+			...encoded,
+			[ref.reservedArgument]: value
+		};
+	} catch {
+		return encoded;
+	}
+};
+const runWithCodec = (ref, args, call) => Effect.withFiber((fiber) => Ref.runWithCodec(ref, args, (native, encoded) => call(native, inject(ref, encoded, fiber.context))));
+const encodeArgs = (ref, args) => Effect.withFiberSucceed((fiber) => inject(ref, Ref.encodeArgsSync(ref, args), fiber.context));
+//#endregion
+export { Forward, encodeArgs, runWithCodec };
+
+//# sourceMappingURL=reservedArgument.js.map

package/dist/internal/reservedArgument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reservedArgument.js","names":[],"sources":["../../src/internal/reservedArgument.ts"],"sourcesContent":["import { convexToJson, type Value } from \"convex/values\";\nimport * as Ref from \"@confect/core/Ref\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Tracer from \"effect/Tracer\";\n\nexport const Forward = Context.Reference<\n  ((span: Tracer.Span) => unknown) | undefined\n>(\"@confect/server/RegisteredFunction/Forward\", {\n  defaultValue: () => undefined,\n});\n\nconst inject = (\n  ref: Ref.Any,\n  encoded: unknown,\n  context: Context.Context<never>,\n): unknown => {\n  if (ref.reservedArgument === undefined || ref.functionType === \"query\")\n    return encoded;\n  const forward = Context.get(context, Forward);\n  const span = Context.getOrUndefined(context, Tracer.ParentSpan);\n  if (forward === undefined || span?._tag !== \"Span\") return encoded;\n  try {\n    const value = forward(span);\n    if (value === undefined) return encoded;\n    convexToJson(value as Value);\n    return {\n      ...(encoded as Record<string, unknown>),\n      [ref.reservedArgument]: value,\n    };\n  } catch {\n    return encoded;\n  }\n};\n\nexport const runWithCodec = <Ref_ extends Ref.Any>(\n  ref: Ref_,\n  args: Ref.Args<Ref_>,\n  call: (\n    native: Ref.FunctionReference<Ref_>,\n    encoded: unknown,\n  ) => PromiseLike<unknown>,\n) =>\n  Effect.withFiber((fiber) =>\n    Ref.runWithCodec(ref, args, (native, encoded) =>\n      call(native, inject(ref, encoded, fiber.context)),\n    ),\n  );\n\nexport const encodeArgs = <Ref_ extends Ref.Any>(\n  ref: Ref_,\n  args: Ref.Args<Ref_>,\n) =>\n  Effect.withFiberSucceed((fiber) =>\n    inject(ref, Ref.encodeArgsSync(ref, args), fiber.context),\n  );\n"],"mappings":";;;;;;AAMA,MAAa,UAAU,QAAQ,UAE7B,8CAA8C,EAC9C,oBAAoB,KAAA,EACtB,CAAC;AAED,MAAM,UACJ,KACA,SACA,YACY;CACZ,IAAI,IAAI,qBAAqB,KAAA,KAAa,IAAI,iBAAiB,SAC7D,OAAO;CACT,MAAM,UAAU,QAAQ,IAAI,SAAS,OAAO;CAC5C,MAAM,OAAO,QAAQ,eAAe,SAAS,OAAO,UAAU;CAC9D,IAAI,YAAY,KAAA,KAAa,MAAM,SAAS,QAAQ,OAAO;CAC3D,IAAI;EACF,MAAM,QAAQ,QAAQ,IAAI;EAC1B,IAAI,UAAU,KAAA,GAAW,OAAO;EAChC,aAAa,KAAc;EAC3B,OAAO;GACL,GAAI;IACH,IAAI,mBAAmB;EAC1B;CACF,QAAQ;EACN,OAAO;CACT;AACF;AAEA,MAAa,gBACX,KACA,MACA,SAKA,OAAO,WAAW,UAChB,IAAI,aAAa,KAAK,OAAO,QAAQ,YACnC,KAAK,QAAQ,OAAO,KAAK,SAAS,MAAM,OAAO,CAAC,CAClD,CACF;AAEF,MAAa,cACX,KACA,SAEA,OAAO,kBAAkB,UACvB,OAAO,KAAK,IAAI,eAAe,KAAK,IAAI,GAAG,MAAM,OAAO,CAC1D"}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@gaganref/confect-server",
-  "version": "10.3.1-fork.8",
+  "version": "10.3.1-fork.80",
   "dependencies": {
     "@effect/ai-openai-compat": "4.0.4",
     "@effect/ai-openrouter": "4.0.4"
   },
   "peerDependencies": {
-    "@confect/core": "npm:@gaganref/confect-core@10.3.1-fork.8",
-    "@effect/platform-node": "^4.0.0",
-    "convex": "^1.45.0",
-    "effect": "^4.0.4"
+    "@confect/core": "npm:@gaganref/confect-core@10.3.1-fork.80",
+    "@effect/platform-node": ">=4.0.0 <4.1.0",
+    "convex": "^1.49.0",
+    "effect": ">=4.0.4 <4.1.0"
   },
   "description": "Backend bindings to the Convex platform",
   "author": "RJ Dellecese",

package/src/ActionCall.ts

@@ -0,0 +1,83 @@
+import * as ReservedArgument from "./internal/reservedArgument.js";
+import * as ActionCall from "@confect/core/ActionCall";
+import type * as Ref from "@confect/core/Ref";
+import type { FunctionReference } from "convex/server";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as ActionCtx from "./ActionCtx.js";
+import * as ActionRunner from "./ActionRunner.js";
+import type * as DatabaseSchema from "./DatabaseSchema.js";
+import type * as DataModel from "./DataModel.js";
+import type * as Handler from "./Handler.js";
+import * as MiddlewareImpl from "./MiddlewareImpl.js";
+import * as MutationRunner from "./MutationRunner.js";
+import * as QueryRunner from "./QueryRunner.js";
+import * as Scheduler from "./Scheduler.js";
+
+export class ActionCallAlreadyUsed extends Data.TaggedError(
+  "ActionCallAlreadyUsed",
+)<{}> {}
+export class ActionCallNotUsed extends Data.TaggedError(
+  "ActionCallNotUsed",
+)<{}> {}
+export class MissingFunctionType extends Data.TaggedError(
+  "MissingFunctionType",
+)<{}> {}
+export class NestedActionNotAllowed extends Data.TaggedError(
+  "NestedActionNotAllowed",
+)<{}> {}
+
+export class SchedulingNotAllowed extends Data.TaggedError(
+  "SchedulingNotAllowed",
+)<{}> {}
+
+export const layer = <S extends DatabaseSchema.AnyWithProps>(schema: S) =>
+  MiddlewareImpl.make(schema, ActionCall.Middleware, (effect) =>
+    Effect.gen(function* () {
+      const ctx = yield* ActionCtx.ActionCtx<
+        DataModel.ToConvex<DataModel.FromSchema<S>>,
+        DatabaseSchema.Scope<S>
+      >();
+      let claimed = false;
+      const call: ActionCall.Call = <
+        Target extends Ref.AnyQuery | Ref.AnyMutation,
+      >(
+        ref: Target,
+        ...args: Ref.OptionalArgs<NoInfer<Target>>
+      ) =>
+        Effect.suspend(() => {
+          if (claimed) return Effect.die(new ActionCallAlreadyUsed());
+          claimed = true;
+          if (ref.functionType !== "query" && ref.functionType !== "mutation")
+            return Effect.die(new MissingFunctionType());
+          return ReservedArgument.runWithCodec(
+            ref,
+            (args[0] ?? {}) as Ref.Args<Target>,
+            (native, encoded) =>
+              ref.functionType === "query"
+                ? ctx.runQuery(
+                    native as FunctionReference<"query">,
+                    encoded as never,
+                  )
+                : ctx.runMutation(
+                    native as FunctionReference<"mutation">,
+                    encoded as never,
+                  ),
+          );
+        }).pipe(Effect.withSpan("ActionCall.call"));
+      return yield* effect.pipe(
+        Effect.provideService(ActionCall.ActionCall, call),
+        Effect.updateContext(
+          (context: Context.Context<Handler.ActionServices<S>>) =>
+            Context.omit(
+              QueryRunner.QueryRunner,
+              MutationRunner.MutationRunner,
+              ActionRunner.ActionRunner,
+              ActionCtx.ActionCtx(),
+              Scheduler.Scheduler,
+            )(context),
+        ),
+      );
+    }),
+  );

package/src/ActionRunner.ts

@@ -1,4 +1,5 @@
-import * as Ref from "@confect/core/Ref";
+import * as ReservedArgument from "./internal/reservedArgument.js";
+import type * as Ref from "@confect/core/Ref";
 import { type GenericActionCtx } from "convex/server";
 import * as Effect from "effect/Effect";
 import * as Context from "effect/Context";
@@ -18,7 +19,7 @@ const make = (runAction: GenericActionCtx<any>["runAction"]) => ({
     Ref.Error<Action> | Schema.SchemaError
   > =>
     run(
-      Ref.runWithCodec(
+      ReservedArgument.runWithCodec(
         action,
         (args[0] ?? {}) as Ref.Args<Action>,
         (functionReference, encodedArgs) =>

package/src/Auth.ts

@@ -1,4 +1,9 @@
-import type { Auth as ConvexAuth } from "convex/server";
+import type {
+  Auth as ConvexAuth,
+  MutationAuth as ConvexMutationAuth,
+  SignJwtOptions,
+  UserIdentity,
+} from "convex/server";
 import * as Context from "effect/Context";
 import { flow } from "effect/Function";
 import * as Effect from "effect/Effect";
@@ -26,8 +31,51 @@ export class Auth extends Context.Service<Auth, ReturnType<typeof make>>()(
   "@confect/server/Auth",
 ) {}
 
+/**
+ * The outcome of Convex's identity verification for the current request.
+ */
+export type Identity =
+  | { readonly _tag: "Absent" }
+  | { readonly _tag: "Valid"; readonly identity: UserIdentity }
+  | { readonly _tag: "Invalid" };
+
+/**
+ * Read HTTP identity without failing for missing or rejected credentials.
+ * Convex verifies the credential. Rejected reads expose no token or error
+ * detail.
+ */
+export const getUserIdentity: Effect.Effect<Identity, never, Auth> = Auth.pipe(
+  Effect.flatMap((auth) =>
+    auth.getUserIdentity.pipe(
+      Effect.map((identity): Identity => ({ _tag: "Valid", identity })),
+      Effect.catchTag("NoUserIdentityFoundError", () =>
+        Effect.succeed<Identity>({ _tag: "Absent" }),
+      ),
+      Effect.catchDefect(() => Effect.succeed<Identity>({ _tag: "Invalid" })),
+    ),
+  ),
+);
+
 export const layer = (auth: ConvexAuth) => Layer.succeed(Auth, make(auth));
 
+/**
+ * Mutation-only deployment signing, available in applications and components.
+ */
+export class MutationAuth extends Context.Service<
+  MutationAuth,
+  {
+    readonly signJwt: (options: SignJwtOptions) => Effect.Effect<string>;
+  }
+>()("@confect/server/Auth/MutationAuth") {}
+
+/**
+ * SDK rejections remain defects, as with the other native auth operations.
+ */
+export const mutationLayer = (auth: ConvexMutationAuth) =>
+  Layer.succeed(MutationAuth, {
+    signJwt: (options) => Effect.promise(() => auth.signJwt(options)),
+  });
+
 export type ForTarget<Target extends DatabaseSchema.Target> =
   Target["kind"] extends "component" ? never : Auth;
 

package/src/Callback.ts

@@ -1,6 +1,7 @@
 import * as Callback from "@confect/core/Callback";
 import * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
-import * as Ref from "@confect/core/Ref";
+import type * as Ref from "@confect/core/Ref";
+import { getFunctionReference } from "@confect/core/RefInternal";
 import {
   compileAst,
   UnsupportedPropertySignatureKeyTypeError,
@@ -305,7 +306,7 @@ export const create = Effect.fn("Callback.create")(function* <
     yield* Effect.fromResult(verify(contract, ref));
   }
   const text = yield* Effect.promise(() =>
-    createFunctionHandle(Ref.getFunctionReference(ref)),
+    createFunctionHandle(getFunctionReference(ref)),
   );
   return yield* Schema.decodeEffect(Callback.handle(contract))(text).pipe(
     Effect.orDie,

package/src/ConvexFunctionDefinitions.ts

@@ -63,7 +63,7 @@ export const buildForGroup = <Group extends GroupSpec.AnyWithProps>(
   databaseSchema: DatabaseSchema.AnyWithProps,
   groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>,
 ): ForGroup<Group> => {
-  const { functionRegistryItems, middlewareRegistryItems } =
+  const { functionRegistryItems, middlewareRegistryItems, observability } =
     GroupRegistry.make(groupLayer);
   return mapLeaves<
     FunctionRegistryItem.AnyWithProps,
@@ -83,6 +83,7 @@ export const buildForGroup = <Group extends GroupSpec.AnyWithProps>(
             databaseSchema,
             confect,
             ResolvedMiddleware.resolve(confect, middlewareRegistryItems),
+            observability,
           ),
         ),
         Match.exhaustive,

package/src/CronJobs.ts

@@ -1,4 +1,5 @@
 import { Ref } from "@confect/core";
+import { getFunctionReference } from "@confect/core/RefInternal";
 import type { CronJob as ConvexCronJob } from "convex/server";
 import { cronJobs as makeConvexCrons, type Crons } from "convex/server";
 import { pipe } from "effect/Function";
@@ -35,7 +36,7 @@ const Proto = {
       crons: { ...this.convexCronJobs.crons },
     });
 
-    const functionReference = Ref.getFunctionReference(cronJob.ref);
+    const functionReference = getFunctionReference(cronJob.ref);
     const encodedArgs = Ref.encodeArgsSync(cronJob.ref, cronJob.args);
 
     Match.value(cronJob.schedule).pipe(