@thomasfosterau/effect-sveltekit 0.0.0 → 0.1.0

package/dist/remote.server.js

@@ -1,37 +1,37 @@
 import { SvelteKitRuntime } from "./runtime.js";
+import { isBareHandler as isBareHandler$1, toStandardValidator } from "./internal/remote-validators.js";
+import { defaultTranslate, makeRunHelpers } from "./internal/remote-run.js";
 import "effect";
 import "effect/unstable/http/HttpClient";
 import * as AppServer from "$app/server";
 //#region src/remote.server.ts
-function runRemoteEffect(effect) {
+/** The default helpers: a fresh SvelteKit per-request runtime, passthrough translation. */
+const defaultHelpers = makeRunHelpers(() => {
 	const event = AppServer.getRequestEvent();
-	return SvelteKitRuntime.forRequest(event).runPromise(effect);
-}
+	return { runExit: (effect) => SvelteKitRuntime.forRequest(event).runPromiseExit(effect) };
+}, defaultTranslate);
+/** Build helpers from a {@link RequestRuntimeProvider}, translator, and form-error mapper. */
+const helpersFromProvider = (provider, translate, formError) => makeRunHelpers(() => {
+	const event = AppServer.getRequestEvent();
+	return {
+		runExit: (effect) => provider.run(event).runPromiseExit(effect),
+		dispose: () => provider.disposeAfterResponse?.(event)
+	};
+}, translate, formError);
 function unavailable(name) {
 	throw new Error(`${name} is not available in the installed SvelteKit version. Update @sveltejs/kit to use this API.`);
 }
-/**
-* Detects a Standard Schema validator via its `~standard` marker property.
-*
-* This cannot be a simple `typeof value === "function"` check on the handler
-* position: some Standard Schema implementations (such as Effect's
-* `Schema.toStandardSchemaV1`) return callable class values, which would be
-* mistaken for handler functions.
-*/
-const isStandardSchema = (value) => value !== null && (typeof value === "object" || typeof value === "function") && "~standard" in value;
-/** True when the argument is the no-validation handler overload. */
-const isBareHandler = (value) => typeof value === "function" && !isStandardSchema(value);
-function query(arg1, arg2) {
+/** True when the argument is the no-validation handler overload (typed narrowing). */
+const isBareHandler = (value) => isBareHandler$1(value);
+const makeQuery = (run) => ((arg1, arg2) => {
 	if (isBareHandler(arg1)) {
 		const handler = arg1;
-		return AppServer.query(() => runRemoteEffect(handler()));
+		return AppServer.query(() => run(handler()));
 	}
 	if (!arg2) throw new Error("query requires a handler function when a schema is provided");
-	return AppServer.query(arg1, (arg) => runRemoteEffect(arg2(arg)));
-}
-function queryBatch(validate, fn) {
-	return AppServer.query.batch(validate, (args) => runRemoteEffect(fn(args)));
-}
+	return AppServer.query(toStandardValidator(arg1), (arg) => run(arg2(arg)));
+});
+const makeQueryBatch = (run) => ((validate, fn) => AppServer.query.batch(toStandardValidator(validate), (args) => run(fn(args))));
 const appServerCompat = AppServer;
 const queryCompat = AppServer.query;
 function getQueryLive() {
@@ -44,45 +44,100 @@ function getRequested() {
 	if (typeof requestedFn !== "function") unavailable("requested");
 	return requestedFn;
 }
-function queryLive(validate, fn) {
-	return getQueryLive()(validate, (arg) => runRemoteEffect(fn(arg)));
-}
-function form(arg1, arg2) {
+const makeQueryLive = (run) => ((validate, fn) => {
+	return getQueryLive()(toStandardValidator(validate), (arg) => run(fn(arg)));
+});
+const makeForm = (helpers) => ((arg1, arg2) => {
 	if (isBareHandler(arg1)) {
 		const handler = arg1;
-		return AppServer.form(() => runRemoteEffect(handler()));
+		return AppServer.form(() => helpers.run(handler()));
 	}
 	if (!arg2) throw new Error("form requires a handler function when a schema is provided");
-	return AppServer.form(arg1, (data, issue) => runRemoteEffect(arg2(data, issue)));
-}
-function command(arg1, arg2) {
+	return AppServer.form(toStandardValidator(arg1), (data, issue) => helpers.runForm(arg2(data, issue), {
+		issue,
+		data
+	}));
+});
+const makeCommand = (run) => ((arg1, arg2) => {
 	if (isBareHandler(arg1)) {
 		const handler = arg1;
-		return AppServer.command(() => runRemoteEffect(handler()));
+		return AppServer.command(() => run(handler()));
 	}
 	if (!arg2) throw new Error("command requires a handler function when a schema is provided");
-	return AppServer.command(arg1, (arg) => runRemoteEffect(arg2(arg)));
-}
-function prerender(arg1, arg2, arg3) {
+	return AppServer.command(toStandardValidator(arg1), (arg) => run(arg2(arg)));
+});
+const makePrerender = (run) => ((arg1, arg2, arg3) => {
 	if (isBareHandler(arg1)) {
 		const handler = arg1;
-		return AppServer.prerender(() => runRemoteEffect(handler()), arg2);
+		return AppServer.prerender(() => run(handler()), arg2);
 	}
 	if (typeof arg2 !== "function") throw new Error("prerender requires a handler function when a schema is provided");
-	return AppServer.prerender(arg1, (arg) => runRemoteEffect(arg2(arg)), arg3);
-}
+	return AppServer.prerender(toStandardValidator(arg1), (arg) => run(arg2(arg)), arg3);
+});
 function requested(...args) {
 	return getRequested()(...args);
 }
+const makeQueryNamespace = (run) => Object.assign(makeQuery(run), {
+	batch: makeQueryBatch(run),
+	live: makeQueryLive(run)
+});
+const query = makeQueryNamespace(defaultHelpers.run);
+query.batch;
+query.live;
+const form = makeForm(defaultHelpers);
+const command = makeCommand(defaultHelpers.run);
+const prerender = makePrerender(defaultHelpers.run);
+/**
+* Bind the remote-function helpers to a {@link RequestRuntimeProvider} (and an
+* optional boundary error translator), so their handlers run on the provider's
+* services `Env` — your own application catalogue — instead of the fixed
+* {@link SvelteKitServices}. The Standard-Schema / `"unchecked"` validation
+* argument and the native return types (`RemoteQueryFunction`, `RemoteForm`,
+* ...) are exactly as the standalone helpers.
+*
+* For remote forms, the failure path runs `opts.formError` when provided —
+* mapping a structured/nested error shape into SvelteKit's field issues (via the
+* `issue` helper / `invalid()`) so a domain validation failure drives
+* field-level invalidation rather than a generic failure. Otherwise the form
+* falls back to `translateError`.
+*
+* @example
+* ```ts
+* const { query, form, command } = RemoteFunction.withRuntime(
+*   RequestRuntime.fromLocals((event) => event.locals.runtime),
+*   {
+*     translateError: toSvelteKit,
+*     formError: (error, { issue }) => {
+*       if (error instanceof ValidationFailure) issue.field(error.field, error.message);
+*       invalid();
+*     },
+*   },
+* );
+*
+* export const items = query(() =>
+*   Effect.gen(function* () {
+*     const db = yield* Database;
+*     return yield* db.list();
+*   }),
+* );
+* ```
+*/
+function withRuntime(provider, opts) {
+	const helpers = helpersFromProvider(provider, opts?.translateError ?? defaultTranslate, opts?.formError);
+	return {
+		query: makeQueryNamespace(helpers.run),
+		form: makeForm(helpers),
+		command: makeCommand(helpers.run),
+		prerender: makePrerender(helpers.run)
+	};
+}
 const RemoteFunction = {
-	query: Object.assign(query, {
-		batch: queryBatch,
-		live: queryLive
-	}),
+	query,
 	form,
 	command,
 	prerender,
-	requested
+	requested,
+	withRuntime
 };
 //#endregion
 export { RemoteFunction };

package/dist/remote.server.js.map

@@ -1 +1 @@
-{"version":3,"file":"remote.server.js","names":[],"sources":["../src/remote.server.ts"],"sourcesContent":["import * as AppServer from \"$app/server\";\nimport type {\n  RemoteCommand,\n  RemoteForm,\n  RemoteFormInput,\n  RemotePrerenderFunction,\n  RemoteQueryFunction,\n  InvalidField,\n} from \"@sveltejs/kit\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport * as HttpClient from \"effect/unstable/http/HttpClient\";\nimport { Effect } from \"effect\";\nimport { SvelteKitRuntime, SvelteKitRequestEvent } from \"./runtime.js\";\n\ntype SvelteKitEffectEnv = HttpClient.HttpClient | SvelteKitRequestEvent;\n\nfunction runRemoteEffect<A, E, R extends SvelteKitEffectEnv>(\n  effect: Effect.Effect<A, E, R>,\n): Promise<A> {\n  const event = AppServer.getRequestEvent();\n  const runtime = SvelteKitRuntime.forRequest(event);\n  return runtime.runPromise(effect);\n}\n\nfunction unavailable(name: string): never {\n  throw new Error(\n    `${name} is not available in the installed SvelteKit version. Update @sveltejs/kit to use this API.`,\n  );\n}\n\ntype UnknownEffect = Effect.Effect<unknown, unknown, SvelteKitEffectEnv>;\ntype EffectHandler = (arg: unknown) => UnknownEffect;\ntype EffectFormHandler = (data: unknown, issue: unknown) => UnknownEffect;\ntype EffectVoidHandler = () => UnknownEffect;\n\n/**\n * Detects a Standard Schema validator via its `~standard` marker property.\n *\n * This cannot be a simple `typeof value === \"function\"` check on the handler\n * position: some Standard Schema implementations (such as Effect's\n * `Schema.toStandardSchemaV1`) return callable class values, which would be\n * mistaken for handler functions.\n */\nconst isStandardSchema = (value: unknown): value is StandardSchemaV1 =>\n  value !== null &&\n  (typeof value === \"object\" || typeof value === \"function\") &&\n  \"~standard\" in value;\n\n/** True when the argument is the no-validation handler overload. */\nconst isBareHandler = (value: unknown): value is EffectVoidHandler =>\n  typeof value === \"function\" && !isStandardSchema(value);\n\nexport function query<Output>(\n  fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<void, Output>;\nexport function query<Input, Output>(\n  validate: \"unchecked\",\n  fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<Input, Output>;\nexport function query<Schema extends StandardSchemaV1, Output>(\n  schema: Schema,\n  fn: (\n    arg: StandardSchemaV1.InferOutput<Schema>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function query(\n  arg1: unknown,\n  arg2?: (arg: unknown) => Effect.Effect<unknown, unknown, SvelteKitEffectEnv>,\n): any {\n  if (isBareHandler(arg1)) {\n    const handler = arg1;\n    return AppServer.query(() => runRemoteEffect(handler()));\n  }\n\n  if (!arg2) {\n    throw new Error(\"query requires a handler function when a schema is provided\");\n  }\n\n  return AppServer.query(arg1 as \"unchecked\", (arg: unknown) => runRemoteEffect(arg2(arg)));\n}\n\nexport function queryBatch<Input, Output>(\n  validate: \"unchecked\",\n  fn: (\n    args: Input[],\n  ) => Effect.Effect<(arg: Input, idx: number) => Output, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<Input, Output>;\nexport function queryBatch<Schema extends StandardSchemaV1, Output>(\n  schema: Schema,\n  fn: (\n    args: StandardSchemaV1.InferOutput<Schema>[],\n  ) => Effect.Effect<\n    (arg: StandardSchemaV1.InferOutput<Schema>, idx: number) => Output,\n    unknown,\n    SvelteKitEffectEnv\n  >,\n): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function queryBatch(\n  validate: unknown,\n  fn: (\n    args: unknown[],\n  ) => Effect.Effect<(arg: unknown, idx: number) => unknown, unknown, SvelteKitEffectEnv>,\n): any {\n  return AppServer.query.batch(validate as \"unchecked\", (args: unknown[]) =>\n    runRemoteEffect(fn(args)),\n  );\n}\n\ntype QueryLiveFactory = (\n  validate: unknown,\n  fn: (arg: unknown) => Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>,\n) => unknown;\n\ntype QueryWithCompat = typeof AppServer.query & {\n  live?: QueryLiveFactory;\n};\n\ntype AppServerWithCompat = typeof AppServer & {\n  requested?: (...args: unknown[]) => unknown;\n};\n\nconst appServerCompat = AppServer as AppServerWithCompat;\nconst queryCompat = AppServer.query as QueryWithCompat;\n\nfunction getQueryLive(): QueryLiveFactory {\n  const live = queryCompat.live;\n\n  if (typeof live !== \"function\") {\n    unavailable(\"query.live\");\n  }\n\n  return live;\n}\n\nfunction getRequested(): (...args: unknown[]) => unknown {\n  const requestedFn = appServerCompat.requested;\n\n  if (typeof requestedFn !== \"function\") {\n    unavailable(\"requested\");\n  }\n\n  return requestedFn;\n}\n\nexport function queryLive<Input, Output>(\n  validate: \"unchecked\",\n  fn: (arg: Input) => Effect.Effect<AsyncIterable<Output>, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<Input, Output>;\nexport function queryLive<Schema extends StandardSchemaV1, Output>(\n  schema: Schema,\n  fn: (\n    arg: StandardSchemaV1.InferOutput<Schema>,\n  ) => Effect.Effect<AsyncIterable<Output>, unknown, SvelteKitEffectEnv>,\n): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function queryLive(\n  validate: unknown,\n  fn: (arg: unknown) => Effect.Effect<AsyncIterable<unknown>, unknown, SvelteKitEffectEnv>,\n): any {\n  const live = getQueryLive();\n  return live(validate, (arg) => runRemoteEffect(fn(arg)));\n}\n\nexport function form<Output>(\n  fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteForm<void, Output>;\nexport function form<Input extends RemoteFormInput, Output>(\n  validate: \"unchecked\",\n  fn: (\n    data: Input,\n    issue: InvalidField<Input>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteForm<Input, Output>;\nexport function form<Schema extends StandardSchemaV1<RemoteFormInput, Record<string, any>>, Output>(\n  validate: Schema,\n  fn: (\n    data: StandardSchemaV1.InferOutput<Schema>,\n    issue: InvalidField<StandardSchemaV1.InferInput<Schema>>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function form(arg1: unknown, arg2?: unknown): any {\n  if (isBareHandler(arg1)) {\n    const handler = arg1;\n    return AppServer.form(() => runRemoteEffect(handler()));\n  }\n\n  if (!arg2) {\n    throw new Error(\"form requires a handler function when a schema is provided\");\n  }\n\n  return AppServer.form(arg1 as \"unchecked\", (data: unknown, issue: unknown) =>\n    runRemoteEffect((arg2 as EffectFormHandler)(data, issue)),\n  );\n}\n\nexport function command<Output>(\n  fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteCommand<void, Output>;\nexport function command<Input, Output>(\n  validate: \"unchecked\",\n  fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteCommand<Input, Output>;\nexport function command<Schema extends StandardSchemaV1, Output>(\n  validate: Schema,\n  fn: (\n    arg: StandardSchemaV1.InferOutput<Schema>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n): RemoteCommand<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function command(\n  arg1: unknown,\n  arg2?: (arg: unknown) => Effect.Effect<unknown, unknown, SvelteKitEffectEnv>,\n): any {\n  if (isBareHandler(arg1)) {\n    const handler = arg1;\n    return AppServer.command(() => runRemoteEffect(handler()));\n  }\n\n  if (!arg2) {\n    throw new Error(\"command requires a handler function when a schema is provided\");\n  }\n\n  return AppServer.command(arg1 as \"unchecked\", (arg: unknown) => runRemoteEffect(arg2(arg)));\n}\n\nexport function prerender<Output>(\n  fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  options?: {\n    inputs?: () => Promise<void[]> | void[];\n    dynamic?: boolean;\n  },\n): RemotePrerenderFunction<void, Output>;\nexport function prerender<Input, Output>(\n  validate: \"unchecked\",\n  fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  options?: {\n    inputs?: () => Promise<Input[]> | Input[];\n    dynamic?: boolean;\n  },\n): RemotePrerenderFunction<Input, Output>;\nexport function prerender<Schema extends StandardSchemaV1, Output>(\n  schema: Schema,\n  fn: (\n    arg: StandardSchemaV1.InferOutput<Schema>,\n  ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  options?: {\n    inputs?: () =>\n      | Promise<StandardSchemaV1.InferInput<Schema>[]>\n      | StandardSchemaV1.InferInput<Schema>[];\n    dynamic?: boolean;\n  },\n): RemotePrerenderFunction<StandardSchemaV1.InferInput<Schema>, Output>;\nexport function prerender(\n  arg1: unknown,\n  arg2?:\n    | ((arg: unknown) => Effect.Effect<unknown, unknown, SvelteKitEffectEnv>)\n    | {\n        inputs?: () => Promise<unknown[]> | unknown[];\n        dynamic?: boolean;\n      },\n  arg3?: {\n    inputs?: () => Promise<unknown[]> | unknown[];\n    dynamic?: boolean;\n  },\n): any {\n  if (isBareHandler(arg1)) {\n    const handler = arg1;\n    return AppServer.prerender(\n      () => runRemoteEffect(handler()),\n      arg2 as { inputs?: () => Promise<void[]> | void[]; dynamic?: boolean } | undefined,\n    );\n  }\n\n  if (typeof arg2 !== \"function\") {\n    throw new Error(\"prerender requires a handler function when a schema is provided\");\n  }\n\n  return AppServer.prerender(\n    arg1 as \"unchecked\",\n    (arg: unknown) => runRemoteEffect((arg2 as EffectHandler)(arg)),\n    arg3,\n  );\n}\n\nexport function requested<Result = unknown>(...args: unknown[]): Result {\n  const requestedFn = getRequested();\n  return requestedFn(...args) as Result;\n}\n\ntype QueryNamespace = {\n  <Output>(\n    fn: () => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  ): RemoteQueryFunction<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Schema extends StandardSchemaV1, Output>(\n    schema: Schema,\n    fn: (\n      arg: StandardSchemaV1.InferOutput<Schema>,\n    ) => Effect.Effect<Output, unknown, SvelteKitEffectEnv>,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;\n  batch: typeof queryBatch;\n  live: typeof queryLive;\n};\n\nconst queryWithHelpers = Object.assign(query, {\n  batch: queryBatch,\n  live: queryLive,\n}) as QueryNamespace;\n\nexport const RemoteFunction = {\n  query: queryWithHelpers,\n  form,\n  command,\n  prerender,\n  requested,\n};\n"],"mappings":";;;;;AAgBA,SAAS,gBACP,QACY;CACZ,MAAM,QAAQ,UAAU,gBAAgB;CAExC,OADgB,iBAAiB,WAAW,KAC/B,EAAE,WAAW,MAAM;AAClC;AAEA,SAAS,YAAY,MAAqB;CACxC,MAAM,IAAI,MACR,GAAG,KAAK,4FACV;AACF;;;;;;;;;AAeA,MAAM,oBAAoB,UACxB,UAAU,SACT,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,eAAe;;AAGjB,MAAM,iBAAiB,UACrB,OAAO,UAAU,cAAc,CAAC,iBAAiB,KAAK;AAexD,SAAgB,MACd,MACA,MACK;CACL,IAAI,cAAc,IAAI,GAAG;EACvB,MAAM,UAAU;EAChB,OAAO,UAAU,YAAY,gBAAgB,QAAQ,CAAC,CAAC;CACzD;CAEA,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,6DAA6D;CAG/E,OAAO,UAAU,MAAM,OAAsB,QAAiB,gBAAgB,KAAK,GAAG,CAAC,CAAC;AAC1F;AAkBA,SAAgB,WACd,UACA,IAGK;CACL,OAAO,UAAU,MAAM,MAAM,WAA0B,SACrD,gBAAgB,GAAG,IAAI,CAAC,CAC1B;AACF;AAeA,MAAM,kBAAkB;AACxB,MAAM,cAAc,UAAU;AAE9B,SAAS,eAAiC;CACxC,MAAM,OAAO,YAAY;CAEzB,IAAI,OAAO,SAAS,YAClB,YAAY,YAAY;CAG1B,OAAO;AACT;AAEA,SAAS,eAAgD;CACvD,MAAM,cAAc,gBAAgB;CAEpC,IAAI,OAAO,gBAAgB,YACzB,YAAY,WAAW;CAGzB,OAAO;AACT;AAYA,SAAgB,UACd,UACA,IACK;CAEL,OADa,aACH,EAAE,WAAW,QAAQ,gBAAgB,GAAG,GAAG,CAAC,CAAC;AACzD;AAmBA,SAAgB,KAAK,MAAe,MAAqB;CACvD,IAAI,cAAc,IAAI,GAAG;EACvB,MAAM,UAAU;EAChB,OAAO,UAAU,WAAW,gBAAgB,QAAQ,CAAC,CAAC;CACxD;CAEA,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,4DAA4D;CAG9E,OAAO,UAAU,KAAK,OAAsB,MAAe,UACzD,gBAAiB,KAA2B,MAAM,KAAK,CAAC,CAC1D;AACF;AAeA,SAAgB,QACd,MACA,MACK;CACL,IAAI,cAAc,IAAI,GAAG;EACvB,MAAM,UAAU;EAChB,OAAO,UAAU,cAAc,gBAAgB,QAAQ,CAAC,CAAC;CAC3D;CAEA,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,+DAA+D;CAGjF,OAAO,UAAU,QAAQ,OAAsB,QAAiB,gBAAgB,KAAK,GAAG,CAAC,CAAC;AAC5F;AA6BA,SAAgB,UACd,MACA,MAMA,MAIK;CACL,IAAI,cAAc,IAAI,GAAG;EACvB,MAAM,UAAU;EAChB,OAAO,UAAU,gBACT,gBAAgB,QAAQ,CAAC,GAC/B,IACF;CACF;CAEA,IAAI,OAAO,SAAS,YAClB,MAAM,IAAI,MAAM,iEAAiE;CAGnF,OAAO,UAAU,UACf,OACC,QAAiB,gBAAiB,KAAuB,GAAG,CAAC,GAC9D,IACF;AACF;AAEA,SAAgB,UAA4B,GAAG,MAAyB;CAEtE,OADoB,aACH,EAAE,GAAG,IAAI;AAC5B;AAyBA,MAAa,iBAAiB;CAC5B,OANuB,OAAO,OAAO,OAAO;EAC5C,OAAO;EACP,MAAM;CACR,CAGS;CACP;CACA;CACA;CACA;AACF"}
+{"version":3,"file":"remote.server.js","names":["isBareHandlerValue"],"sources":["../src/remote.server.ts"],"sourcesContent":["import * as AppServer from \"$app/server\";\nimport type {\n  RemoteCommand,\n  RemoteForm,\n  RemoteFormInput,\n  RemotePrerenderFunction,\n  RemoteQueryFunction,\n  InvalidField,\n} from \"@sveltejs/kit\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport * as HttpClient from \"effect/unstable/http/HttpClient\";\nimport { Effect, type Schema } from \"effect\";\nimport { SvelteKitRuntime, SvelteKitRequestEvent } from \"./runtime.js\";\nimport {\n  isBareHandler as isBareHandlerValue,\n  toStandardValidator,\n} from \"./internal/remote-validators.js\";\nimport {\n  defaultTranslate,\n  makeRunHelpers,\n  type FormErrorMapper,\n  type RunHelpers,\n  type Runner,\n} from \"./internal/remote-run.js\";\nimport type { ErrorTranslator, RequestRuntimeProvider } from \"./request-runtime.js\";\n\nexport type { FormErrorMapper } from \"./internal/remote-run.js\";\n\ntype SvelteKitEffectEnv = HttpClient.HttpClient | SvelteKitRequestEvent;\n\n/** The default helpers: a fresh SvelteKit per-request runtime, passthrough translation. */\nconst defaultHelpers: RunHelpers = makeRunHelpers(() => {\n  const event = AppServer.getRequestEvent();\n  return { runExit: (effect) => SvelteKitRuntime.forRequest(event).runPromiseExit(effect) };\n}, defaultTranslate);\n\n/** Build helpers from a {@link RequestRuntimeProvider}, translator, and form-error mapper. */\nconst helpersFromProvider = (\n  provider: RequestRuntimeProvider<any, any>,\n  translate: ErrorTranslator,\n  formError?: FormErrorMapper,\n): RunHelpers =>\n  makeRunHelpers(\n    () => {\n      const event = AppServer.getRequestEvent();\n      return {\n        runExit: (effect) => provider.run(event).runPromiseExit(effect),\n        dispose: () => provider.disposeAfterResponse?.(event),\n      };\n    },\n    translate,\n    formError,\n  );\n\nfunction unavailable(name: string): never {\n  throw new Error(\n    `${name} is not available in the installed SvelteKit version. Update @sveltejs/kit to use this API.`,\n  );\n}\n\ntype EffectHandler<Env> = (arg: unknown) => Effect.Effect<unknown, unknown, Env>;\ntype EffectFormHandler<Env> = (\n  data: unknown,\n  issue: unknown,\n) => Effect.Effect<unknown, unknown, Env>;\ntype EffectVoidHandler<Env> = () => Effect.Effect<unknown, unknown, Env>;\n\n/** True when the argument is the no-validation handler overload (typed narrowing). */\nconst isBareHandler = <Env>(value: unknown): value is EffectVoidHandler<Env> =>\n  isBareHandlerValue(value);\n\n/** The public shape of the `query` helper, parameterised by its handler env. */\nexport interface QueryFn<Env> {\n  <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteQueryFunction<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteQueryFunction<S[\"Encoded\"], Output>;\n}\n\nconst makeQuery = <Env>(run: Runner): QueryFn<Env> =>\n  ((arg1: unknown, arg2?: (arg: unknown) => Effect.Effect<unknown, unknown, Env>): any => {\n    if (isBareHandler<Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.query(() => run(handler()));\n    }\n\n    if (!arg2) {\n      throw new Error(\"query requires a handler function when a schema is provided\");\n    }\n\n    return AppServer.query(toStandardValidator(arg1) as \"unchecked\", (arg: unknown) =>\n      run(arg2(arg)),\n    );\n  }) as QueryFn<Env>;\n\nexport interface QueryBatchFn<Env> {\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (args: Input[]) => Effect.Effect<(arg: Input, idx: number) => Output, unknown, Env>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (\n      args: StandardSchemaV1.InferOutput<Sch>[],\n    ) => Effect.Effect<\n      (arg: StandardSchemaV1.InferOutput<Sch>, idx: number) => Output,\n      unknown,\n      Env\n    >,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (args: S[\"Type\"][]) => Effect.Effect<(arg: S[\"Type\"], idx: number) => Output, unknown, Env>,\n  ): RemoteQueryFunction<S[\"Encoded\"], Output>;\n}\n\nconst makeQueryBatch = <Env>(run: Runner): QueryBatchFn<Env> =>\n  ((\n    validate: unknown,\n    fn: (args: unknown[]) => Effect.Effect<(arg: unknown, idx: number) => unknown, unknown, Env>,\n  ): any =>\n    AppServer.query.batch(toStandardValidator(validate) as \"unchecked\", (args: unknown[]) =>\n      run(fn(args)),\n    )) as QueryBatchFn<Env>;\n\ntype QueryLiveFactory = (\n  validate: unknown,\n  fn: (arg: unknown) => Promise<AsyncIterable<unknown>> | AsyncIterable<unknown>,\n) => unknown;\n\ntype QueryWithCompat = typeof AppServer.query & {\n  live?: QueryLiveFactory;\n};\n\ntype AppServerWithCompat = typeof AppServer & {\n  requested?: (...args: unknown[]) => unknown;\n};\n\nconst appServerCompat = AppServer as AppServerWithCompat;\nconst queryCompat = AppServer.query as QueryWithCompat;\n\nfunction getQueryLive(): QueryLiveFactory {\n  const live = queryCompat.live;\n\n  if (typeof live !== \"function\") {\n    unavailable(\"query.live\");\n  }\n\n  return live;\n}\n\nfunction getRequested(): (...args: unknown[]) => unknown {\n  const requestedFn = appServerCompat.requested;\n\n  if (typeof requestedFn !== \"function\") {\n    unavailable(\"requested\");\n  }\n\n  return requestedFn;\n}\n\nexport interface QueryLiveFn<Env> {\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<AsyncIterable<Output>, unknown, Env>,\n  ): RemoteQueryFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (\n      arg: StandardSchemaV1.InferOutput<Sch>,\n    ) => Effect.Effect<AsyncIterable<Output>, unknown, Env>,\n  ): RemoteQueryFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<AsyncIterable<Output>, unknown, Env>,\n  ): RemoteQueryFunction<S[\"Encoded\"], Output>;\n}\n\nconst makeQueryLive = <Env>(run: Runner): QueryLiveFn<Env> =>\n  ((\n    validate: unknown,\n    fn: (arg: unknown) => Effect.Effect<AsyncIterable<unknown>, unknown, Env>,\n  ): any => {\n    const live = getQueryLive();\n    return live(toStandardValidator(validate), (arg) => run(fn(arg)));\n  }) as QueryLiveFn<Env>;\n\nexport interface FormFn<Env> {\n  <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteForm<void, Output>;\n  <Input extends RemoteFormInput, Output>(\n    validate: \"unchecked\",\n    fn: (data: Input, issue: InvalidField<Input>) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteForm<Input, Output>;\n  <Sch extends StandardSchemaV1<RemoteFormInput, Record<string, any>>, Output>(\n    validate: Sch,\n    fn: (\n      data: StandardSchemaV1.InferOutput<Sch>,\n      issue: InvalidField<StandardSchemaV1.InferInput<Sch>>,\n    ) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteForm<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top & { readonly Encoded: RemoteFormInput }, Output>(\n    validate: S,\n    fn: (data: S[\"Type\"], issue: InvalidField<S[\"Encoded\"]>) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteForm<S[\"Encoded\"], Output>;\n}\n\nconst makeForm = <Env>(helpers: RunHelpers): FormFn<Env> =>\n  ((arg1: unknown, arg2?: unknown): any => {\n    if (isBareHandler<Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.form(() => helpers.run(handler()));\n    }\n\n    if (!arg2) {\n      throw new Error(\"form requires a handler function when a schema is provided\");\n    }\n\n    return AppServer.form(\n      toStandardValidator(arg1) as \"unchecked\",\n      (data: unknown, issue: unknown) =>\n        helpers.runForm((arg2 as EffectFormHandler<Env>)(data, issue), {\n          issue: issue as InvalidField<any>,\n          data,\n        }),\n    );\n  }) as FormFn<Env>;\n\nexport interface CommandFn<Env> {\n  <Output>(fn: () => Effect.Effect<Output, unknown, Env>): RemoteCommand<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteCommand<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    validate: Sch,\n    fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteCommand<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    validate: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<Output, unknown, Env>,\n  ): RemoteCommand<S[\"Encoded\"], Output>;\n}\n\nconst makeCommand = <Env>(run: Runner): CommandFn<Env> =>\n  ((arg1: unknown, arg2?: (arg: unknown) => Effect.Effect<unknown, unknown, Env>): any => {\n    if (isBareHandler<Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.command(() => run(handler()));\n    }\n\n    if (!arg2) {\n      throw new Error(\"command requires a handler function when a schema is provided\");\n    }\n\n    return AppServer.command(toStandardValidator(arg1) as \"unchecked\", (arg: unknown) =>\n      run(arg2(arg)),\n    );\n  }) as CommandFn<Env>;\n\nexport interface PrerenderFn<Env> {\n  <Output>(\n    fn: () => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () => Promise<void[]> | void[];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<void, Output>;\n  <Input, Output>(\n    validate: \"unchecked\",\n    fn: (arg: Input) => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () => Promise<Input[]> | Input[];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<Input, Output>;\n  <Sch extends StandardSchemaV1, Output>(\n    schema: Sch,\n    fn: (arg: StandardSchemaV1.InferOutput<Sch>) => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () =>\n        | Promise<StandardSchemaV1.InferInput<Sch>[]>\n        | StandardSchemaV1.InferInput<Sch>[];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<StandardSchemaV1.InferInput<Sch>, Output>;\n  <S extends Schema.Top, Output>(\n    schema: S,\n    fn: (arg: S[\"Type\"]) => Effect.Effect<Output, unknown, Env>,\n    options?: {\n      inputs?: () => Promise<S[\"Encoded\"][]> | S[\"Encoded\"][];\n      dynamic?: boolean;\n    },\n  ): RemotePrerenderFunction<S[\"Encoded\"], Output>;\n}\n\nconst makePrerender = <Env>(run: Runner): PrerenderFn<Env> =>\n  ((\n    arg1: unknown,\n    arg2?:\n      | ((arg: unknown) => Effect.Effect<unknown, unknown, Env>)\n      | {\n          inputs?: () => Promise<unknown[]> | unknown[];\n          dynamic?: boolean;\n        },\n    arg3?: {\n      inputs?: () => Promise<unknown[]> | unknown[];\n      dynamic?: boolean;\n    },\n  ): any => {\n    if (isBareHandler<Env>(arg1)) {\n      const handler = arg1;\n      return AppServer.prerender(\n        () => run(handler()),\n        arg2 as { inputs?: () => Promise<void[]> | void[]; dynamic?: boolean } | undefined,\n      );\n    }\n\n    if (typeof arg2 !== \"function\") {\n      throw new Error(\"prerender requires a handler function when a schema is provided\");\n    }\n\n    return AppServer.prerender(\n      toStandardValidator(arg1) as \"unchecked\",\n      (arg: unknown) => run((arg2 as EffectHandler<Env>)(arg)),\n      arg3,\n    );\n  }) as PrerenderFn<Env>;\n\nexport function requested<Result = unknown>(...args: unknown[]): Result {\n  const requestedFn = getRequested();\n  return requestedFn(...args) as Result;\n}\n\n/** A `query` with its `batch` / `live` helpers attached. */\nexport type QueryNamespace<Env> = QueryFn<Env> & {\n  batch: QueryBatchFn<Env>;\n  live: QueryLiveFn<Env>;\n};\n\nconst makeQueryNamespace = <Env>(run: Runner): QueryNamespace<Env> =>\n  Object.assign(makeQuery<Env>(run), {\n    batch: makeQueryBatch<Env>(run),\n    live: makeQueryLive<Env>(run),\n  }) as QueryNamespace<Env>;\n\n// ── Standalone exports (default SvelteKit per-request runtime) ──────────────\n\nexport const query: QueryNamespace<SvelteKitEffectEnv> = makeQueryNamespace(defaultHelpers.run);\nexport const queryBatch: QueryBatchFn<SvelteKitEffectEnv> = query.batch;\nexport const queryLive: QueryLiveFn<SvelteKitEffectEnv> = query.live;\nexport const form: FormFn<SvelteKitEffectEnv> = makeForm(defaultHelpers);\nexport const command: CommandFn<SvelteKitEffectEnv> = makeCommand(defaultHelpers.run);\nexport const prerender: PrerenderFn<SvelteKitEffectEnv> = makePrerender(defaultHelpers.run);\n\n/** The set of remote-function helpers bound to a particular runner. */\nexport interface RemoteFunctions<Env> {\n  readonly query: QueryNamespace<Env>;\n  readonly form: FormFn<Env>;\n  readonly command: CommandFn<Env>;\n  readonly prerender: PrerenderFn<Env>;\n}\n\n/**\n * Bind the remote-function helpers to a {@link RequestRuntimeProvider} (and an\n * optional boundary error translator), so their handlers run on the provider's\n * services `Env` — your own application catalogue — instead of the fixed\n * {@link SvelteKitServices}. The Standard-Schema / `\"unchecked\"` validation\n * argument and the native return types (`RemoteQueryFunction`, `RemoteForm`,\n * ...) are exactly as the standalone helpers.\n *\n * For remote forms, the failure path runs `opts.formError` when provided —\n * mapping a structured/nested error shape into SvelteKit's field issues (via the\n * `issue` helper / `invalid()`) so a domain validation failure drives\n * field-level invalidation rather than a generic failure. Otherwise the form\n * falls back to `translateError`.\n *\n * @example\n * ```ts\n * const { query, form, command } = RemoteFunction.withRuntime(\n *   RequestRuntime.fromLocals((event) => event.locals.runtime),\n *   {\n *     translateError: toSvelteKit,\n *     formError: (error, { issue }) => {\n *       if (error instanceof ValidationFailure) issue.field(error.field, error.message);\n *       invalid();\n *     },\n *   },\n * );\n *\n * export const items = query(() =>\n *   Effect.gen(function* () {\n *     const db = yield* Database;\n *     return yield* db.list();\n *   }),\n * );\n * ```\n */\nexport function withRuntime<R>(\n  provider: RequestRuntimeProvider<R, any>,\n  opts?: { translateError?: ErrorTranslator; formError?: FormErrorMapper },\n): RemoteFunctions<R> {\n  const helpers = helpersFromProvider(\n    provider,\n    opts?.translateError ?? defaultTranslate,\n    opts?.formError,\n  );\n  return {\n    query: makeQueryNamespace<R>(helpers.run),\n    form: makeForm<R>(helpers),\n    command: makeCommand<R>(helpers.run),\n    prerender: makePrerender<R>(helpers.run),\n  };\n}\n\nexport const RemoteFunction = {\n  query,\n  form,\n  command,\n  prerender,\n  requested,\n  withRuntime,\n};\n"],"mappings":"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"}

package/dist/request-runtime.d.ts

@@ -0,0 +1,138 @@
+import { Cause, Context, Effect, Exit, Fiber, Layer, ManagedRuntime } from "effect";
+import { Action, Actions, RequestEvent, RequestHandler, ServerLoad } from "@sveltejs/kit";
+
+//#region src/request-runtime.d.ts
+/**
+ * The runners a {@link RequestRuntimeProvider} resolves for a single request:
+ * a way to run an `Effect<A, unknown, R>` that requires the provider's services
+ * `R`. The error channel is `unknown` because a boundary translator (see
+ * {@link makeRuntimeAdapter}) decides how failures surface.
+ */
+interface RequestRuntimeRunners<in R> {
+  /** Run the request's effect, keeping its `Exit` (never rejects). */
+  readonly runPromiseExit: <A>(effect: Effect.Effect<A, unknown, R>) => Promise<Exit.Exit<A, unknown>>;
+  /** Fork the request's effect, returning the running fiber. */
+  readonly runFork: <A>(effect: Effect.Effect<A, unknown, R>) => Fiber.Fiber<A, unknown>;
+}
+/**
+ * How to execute a request's effects. Resolved per request, at call time, so a
+ * runtime the consumer rebuilds mid-request is honoured automatically.
+ *
+ * Implementations own the scope/lifecycle of whatever they build. `R` is the
+ * set of services the handler effect may require; `E` is the layer construction
+ * error type (informational — failures surface through the translator).
+ */
+interface RequestRuntimeProvider<R, E = never> {
+  /** Resolve the runners for a request. Consulted per call, never cached. */
+  readonly run: (event: RequestEvent) => RequestRuntimeRunners<R>;
+  /**
+   * Optional teardown to run after the response is produced. Called by
+   * {@link makeRuntimeAdapter} once the handler has settled — e.g. to route a
+   * per-request resource's disposal through `ctx.waitUntil` on Workers.
+   */
+  readonly disposeAfterResponse?: (event: RequestEvent) => void;
+  /** Phantom marker so `E` participates in inference. */
+  readonly _E?: (_: never) => E;
+}
+/** Options for {@link RequestRuntime.fromLayerPerRequest}. */
+interface FromLayerPerRequestOptions {
+  /**
+   * Defer teardown of the per-request runtime to after the response is
+   * produced, instead of awaiting `dispose()` inline. On Workers, route it
+   * through `ctx.waitUntil` so disposal does not fight response streaming or
+   * socket pinning:
+   *
+   * ```ts
+   * { afterResponse: (event, dispose) => event.platform!.ctx.waitUntil(dispose()) }
+   * ```
+   */
+  readonly afterResponse?: (event: RequestEvent, dispose: () => Promise<void>) => void;
+}
+/**
+ * Constructors for {@link RequestRuntimeProvider}. Each expresses one way to
+ * obtain a request's execution context; the wrappers don't care which.
+ */
+declare const RequestRuntime: {
+  /**
+   * Adopt a `ManagedRuntime` the consumer already built (the build-once model,
+   * expressed as a provider).
+   */
+  fromManagedRuntime: <R, E>(rt: ManagedRuntime.ManagedRuntime<R, E>) => RequestRuntimeProvider<R, E>;
+  /**
+   * Let the package build a single `ManagedRuntime` from a layer, lazily on
+   * first use and shared across requests (the existing build-once-per-process
+   * model).
+   */
+  fromLayer: <R, E>(layer: Layer.Layer<R, E>) => RequestRuntimeProvider<R, E>;
+  /**
+   * Adopt a runtime the consumer stashed on the request (e.g. on
+   * `event.locals`). Resolved at call time, so a runtime rebuilt mid-request is
+   * honoured automatically. The getter may return a `ManagedRuntime` or a
+   * built service `Context`.
+   */
+  fromLocals: <R>(get: (event: RequestEvent) => ManagedRuntime.ManagedRuntime<R, unknown> | Context.Context<R>) => RequestRuntimeProvider<R>;
+  /**
+   * Let the package build *and dispose* a `ManagedRuntime` per request from a
+   * layer factory. Each handler invocation builds its own runtime from
+   * `layer(event)` and disposes it once the effect settles — so a per-request
+   * resource (a DB pool) dies with the request. Use `opts.afterResponse` to
+   * defer disposal to after the response (Workers `ctx.waitUntil`).
+   *
+   * For sharing one runtime across every load/action of a request, prefer
+   * {@link RequestRuntime.fromLocals} with a runtime the consumer builds in
+   * `hooks.server.ts`.
+   */
+  fromLayerPerRequest: <R, E>(layer: (event: RequestEvent) => Layer.Layer<R, E>, opts?: FromLayerPerRequestOptions) => RequestRuntimeProvider<R, E>;
+};
+/** A boundary translator: turn a failed `Cause` into a thrown value. */
+type ErrorTranslator = (cause: Cause.Cause<unknown>) => never;
+/** Options shared by {@link makeRuntimeAdapter}. */
+interface RuntimeAdapterOptions {
+  /**
+   * Translate a failed `Cause` into SvelteKit control flow at the boundary.
+   * Called for `serverLoad` / `action` / `actions` failures; it may throw
+   * `redirect()` / `error()` (and, for remote forms, call `invalid()`).
+   * Defaults to the package's passthrough: SvelteKit's own `redirect()` /
+   * `error()` are rethrown, anything else becomes an `EffectCauseError` (a 500).
+   */
+  readonly translateError?: ErrorTranslator;
+}
+/** Options for the adapter's `endpoint` wrapper. */
+interface AdapterEndpointOptions {
+  /**
+   * Include full error details (`Cause.pretty`) in the default 500 JSON body.
+   * Ignored when a `translateError` is configured. Defaults to `false`.
+   */
+  readonly exposeErrors?: boolean;
+}
+/** The wrappers produced by {@link makeRuntimeAdapter}, bound to a provider. */
+interface RuntimeAdapter<R> {
+  readonly serverLoad: <Params extends Record<string, string> = any, ParentData extends Record<string, any> = any, OutputData extends Record<string, any> | void = any, RouteId extends string | null = any>(fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>) => ServerLoad<Params, ParentData, OutputData, RouteId>;
+  readonly action: <Params extends Record<string, string> = any, OutputData extends Record<string, any> | void = any, RouteId extends string | null = any>(fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>) => Action<Params, OutputData, RouteId>;
+  readonly actions: <Params extends Record<string, string> = any, OutputData extends Record<string, any> | void = any, RouteId extends string | null = any>(map: Record<string, (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>>) => Actions<Params, OutputData, RouteId>;
+  readonly endpoint: <Params extends Record<string, string> = any, RouteId extends string | null = any>(fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<Response, unknown, R>, options?: AdapterEndpointOptions) => RequestHandler<Params, RouteId>;
+}
+/**
+ * Bind the SvelteKit server wrappers to a {@link RequestRuntimeProvider} (and an
+ * optional boundary error translator).
+ *
+ * Unlike the standalone `serverLoad` / `action` / `endpoint`, the handler
+ * effect's required services `R` come from the provider — your own application
+ * catalogue — not the fixed {@link SvelteKitServices}. The package does not
+ * merge `HttpClient` / `SvelteKitRequestEvent` onto this path; add them to your
+ * own layer if you want them.
+ *
+ * @example
+ * ```ts
+ * // Package owns the runtime per request on Workers, disposed via waitUntil.
+ * const { serverLoad } = makeRuntimeAdapter(
+ *   RequestRuntime.fromLayerPerRequest((event) => AppLayer(event.platform!.env), {
+ *     afterResponse: (event, dispose) => event.platform!.ctx.waitUntil(dispose()),
+ *   }),
+ * );
+ * ```
+ */
+declare const makeRuntimeAdapter: <R>(provider: RequestRuntimeProvider<R, any>, opts?: RuntimeAdapterOptions) => RuntimeAdapter<R>;
+//#endregion
+export { AdapterEndpointOptions, ErrorTranslator, FromLayerPerRequestOptions, RequestRuntime, RequestRuntimeProvider, RequestRuntimeRunners, RuntimeAdapter, RuntimeAdapterOptions, makeRuntimeAdapter };
+//# sourceMappingURL=request-runtime.d.ts.map

package/dist/request-runtime.js

@@ -0,0 +1,186 @@
+import { causeToThrowable } from "./internal/error.js";
+import { Cause, Effect, Exit, ManagedRuntime } from "effect";
+import { isHttpError, isRedirect } from "@sveltejs/kit";
+//#region src/request-runtime.ts
+/**
+* A general, Effect-idiomatic way to provide the per-request execution context
+* for SvelteKit server wrappers.
+*
+* Where {@link makeServerRuntime} bakes in "the package owns a runtime, built
+* once per process," this module factors out the single decision *how to obtain
+* the execution context for this request* behind one open abstraction — a
+* {@link RequestRuntimeProvider}. Existing models (a build-once
+* `ManagedRuntime`, a layer built once), a consumer-owned runtime resolved from
+* `event.locals`, and a package-built per-request runtime are all just
+* {@link RequestRuntime} constructors of the same provider, not separate code
+* paths.
+*
+* {@link makeRuntimeAdapter} binds the `serverLoad` / `action` / `actions` /
+* `endpoint` wrappers to a provider (and an optional boundary error
+* translator), so the handler effect's requirement channel `R` is the
+* *provider's* services — your own application catalogue — rather than the fixed
+* {@link SvelteKitServices}.
+*
+* @example
+* ```ts
+* // The consumer owns a per-request ManagedRuntime on event.locals.runtime
+* // (rebuilt mid-request); the package adopts it, resolved at call time.
+* import { makeRuntimeAdapter, RequestRuntime } from "@thomasfosterau/effect-sveltekit/server";
+*
+* const { serverLoad, action, actions, endpoint } = makeRuntimeAdapter(
+*   RequestRuntime.fromLocals((event) => event.locals.runtime),
+*   { translateError: toSvelteKit },
+* );
+*
+* export const load = serverLoad((event) =>
+*   Effect.gen(function* () {
+*     const db = yield* Database; // app service from locals.runtime
+*     return { items: yield* db.list() };
+*   }),
+* );
+* ```
+*/
+/** Runners backed by an existing `ManagedRuntime`. */
+const runnersFromManagedRuntime = (rt) => ({
+	runPromiseExit: (effect) => rt.runPromiseExit(effect),
+	runFork: (effect) => rt.runFork(effect)
+});
+/** Runners backed by a built service `Context` (run on the default scheduler). */
+const runnersFromContext = (context) => ({
+	runPromiseExit: (effect) => Effect.runPromiseExitWith(context)(effect),
+	runFork: (effect) => Effect.runForkWith(context)(effect)
+});
+/** Runners for a target that is either a `ManagedRuntime` or a `Context`. */
+const runnersFor = (target) => ManagedRuntime.isManagedRuntime(target) ? runnersFromManagedRuntime(target) : runnersFromContext(target);
+/**
+* Constructors for {@link RequestRuntimeProvider}. Each expresses one way to
+* obtain a request's execution context; the wrappers don't care which.
+*/
+const RequestRuntime = {
+	/**
+	* Adopt a `ManagedRuntime` the consumer already built (the build-once model,
+	* expressed as a provider).
+	*/
+	fromManagedRuntime: (rt) => {
+		const runners = runnersFromManagedRuntime(rt);
+		return { run: () => runners };
+	},
+	/**
+	* Let the package build a single `ManagedRuntime` from a layer, lazily on
+	* first use and shared across requests (the existing build-once-per-process
+	* model).
+	*/
+	fromLayer: (layer) => {
+		let runners;
+		return { run: () => runners ??= runnersFromManagedRuntime(ManagedRuntime.make(layer)) };
+	},
+	/**
+	* Adopt a runtime the consumer stashed on the request (e.g. on
+	* `event.locals`). Resolved at call time, so a runtime rebuilt mid-request is
+	* honoured automatically. The getter may return a `ManagedRuntime` or a
+	* built service `Context`.
+	*/
+	fromLocals: (get) => ({ run: (event) => runnersFor(get(event)) }),
+	/**
+	* Let the package build *and dispose* a `ManagedRuntime` per request from a
+	* layer factory. Each handler invocation builds its own runtime from
+	* `layer(event)` and disposes it once the effect settles — so a per-request
+	* resource (a DB pool) dies with the request. Use `opts.afterResponse` to
+	* defer disposal to after the response (Workers `ctx.waitUntil`).
+	*
+	* For sharing one runtime across every load/action of a request, prefer
+	* {@link RequestRuntime.fromLocals} with a runtime the consumer builds in
+	* `hooks.server.ts`.
+	*/
+	fromLayerPerRequest: (layer, opts) => ({ run: (event) => {
+		const dispose = (rt) => () => rt.dispose();
+		const teardown = (rt) => {
+			if (opts?.afterResponse) {
+				opts.afterResponse(event, dispose(rt));
+				return Promise.resolve();
+			}
+			return rt.dispose();
+		};
+		return {
+			runPromiseExit: async (effect) => {
+				const rt = ManagedRuntime.make(layer(event));
+				try {
+					return await rt.runPromiseExit(effect);
+				} finally {
+					await teardown(rt);
+				}
+			},
+			runFork: (effect) => {
+				const rt = ManagedRuntime.make(layer(event));
+				const fiber = rt.runFork(effect);
+				fiber.addObserver(() => void teardown(rt));
+				return fiber;
+			}
+		};
+	} })
+};
+/**
+* Bind the SvelteKit server wrappers to a {@link RequestRuntimeProvider} (and an
+* optional boundary error translator).
+*
+* Unlike the standalone `serverLoad` / `action` / `endpoint`, the handler
+* effect's required services `R` come from the provider — your own application
+* catalogue — not the fixed {@link SvelteKitServices}. The package does not
+* merge `HttpClient` / `SvelteKitRequestEvent` onto this path; add them to your
+* own layer if you want them.
+*
+* @example
+* ```ts
+* // Package owns the runtime per request on Workers, disposed via waitUntil.
+* const { serverLoad } = makeRuntimeAdapter(
+*   RequestRuntime.fromLayerPerRequest((event) => AppLayer(event.platform!.env), {
+*     afterResponse: (event, dispose) => event.platform!.ctx.waitUntil(dispose()),
+*   }),
+* );
+* ```
+*/
+const makeRuntimeAdapter = (provider, opts) => {
+	const translateError = opts?.translateError ?? ((cause) => {
+		throw causeToThrowable(cause);
+	});
+	const runSettle = async (event, effect) => {
+		const exit = await provider.run(event).runPromiseExit(effect);
+		try {
+			if (Exit.isSuccess(exit)) return exit.value;
+			return translateError(exit.cause);
+		} finally {
+			provider.disposeAfterResponse?.(event);
+		}
+	};
+	const action = (fn) => (event) => runSettle(event, fn(event));
+	return {
+		serverLoad: (fn) => (event) => runSettle(event, fn(event)),
+		action,
+		actions: (map) => {
+			const wrapped = {};
+			for (const [key, fn] of Object.entries(map)) wrapped[key] = action(fn);
+			return wrapped;
+		},
+		endpoint: (fn, options) => async (event) => {
+			const exit = await provider.run(event).runPromiseExit(fn(event));
+			try {
+				if (Exit.isSuccess(exit)) return exit.value;
+				if (opts?.translateError) return opts.translateError(exit.cause);
+				const squashed = Cause.squash(exit.cause);
+				if (isRedirect(squashed) || isHttpError(squashed)) throw squashed;
+				console.error("Endpoint error:", Cause.pretty(exit.cause));
+				const message = options?.exposeErrors ? Cause.pretty(exit.cause) : "Internal server error";
+				return new Response(JSON.stringify({ error: message }), {
+					status: 500,
+					headers: { "Content-Type": "application/json" }
+				});
+			} finally {
+				provider.disposeAfterResponse?.(event);
+			}
+		}
+	};
+};
+//#endregion
+export { RequestRuntime, makeRuntimeAdapter };
+
+//# sourceMappingURL=request-runtime.js.map

package/dist/request-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-runtime.js","names":[],"sources":["../src/request-runtime.ts"],"sourcesContent":["/**\n * A general, Effect-idiomatic way to provide the per-request execution context\n * for SvelteKit server wrappers.\n *\n * Where {@link makeServerRuntime} bakes in \"the package owns a runtime, built\n * once per process,\" this module factors out the single decision *how to obtain\n * the execution context for this request* behind one open abstraction — a\n * {@link RequestRuntimeProvider}. Existing models (a build-once\n * `ManagedRuntime`, a layer built once), a consumer-owned runtime resolved from\n * `event.locals`, and a package-built per-request runtime are all just\n * {@link RequestRuntime} constructors of the same provider, not separate code\n * paths.\n *\n * {@link makeRuntimeAdapter} binds the `serverLoad` / `action` / `actions` /\n * `endpoint` wrappers to a provider (and an optional boundary error\n * translator), so the handler effect's requirement channel `R` is the\n * *provider's* services — your own application catalogue — rather than the fixed\n * {@link SvelteKitServices}.\n *\n * @example\n * ```ts\n * // The consumer owns a per-request ManagedRuntime on event.locals.runtime\n * // (rebuilt mid-request); the package adopts it, resolved at call time.\n * import { makeRuntimeAdapter, RequestRuntime } from \"@thomasfosterau/effect-sveltekit/server\";\n *\n * const { serverLoad, action, actions, endpoint } = makeRuntimeAdapter(\n *   RequestRuntime.fromLocals((event) => event.locals.runtime),\n *   { translateError: toSvelteKit },\n * );\n *\n * export const load = serverLoad((event) =>\n *   Effect.gen(function* () {\n *     const db = yield* Database; // app service from locals.runtime\n *     return { items: yield* db.list() };\n *   }),\n * );\n * ```\n */\n\nimport {\n  isHttpError,\n  isRedirect,\n  type Action,\n  type Actions,\n  type RequestEvent,\n  type RequestHandler,\n  type ServerLoad,\n} from \"@sveltejs/kit\";\nimport { Cause, Context, Effect, Exit, type Fiber, Layer, ManagedRuntime } from \"effect\";\nimport { causeToThrowable } from \"./internal/error.js\";\n\n/**\n * The runners a {@link RequestRuntimeProvider} resolves for a single request:\n * a way to run an `Effect<A, unknown, R>` that requires the provider's services\n * `R`. The error channel is `unknown` because a boundary translator (see\n * {@link makeRuntimeAdapter}) decides how failures surface.\n */\nexport interface RequestRuntimeRunners<in R> {\n  /** Run the request's effect, keeping its `Exit` (never rejects). */\n  readonly runPromiseExit: <A>(\n    effect: Effect.Effect<A, unknown, R>,\n  ) => Promise<Exit.Exit<A, unknown>>;\n  /** Fork the request's effect, returning the running fiber. */\n  readonly runFork: <A>(effect: Effect.Effect<A, unknown, R>) => Fiber.Fiber<A, unknown>;\n}\n\n/**\n * How to execute a request's effects. Resolved per request, at call time, so a\n * runtime the consumer rebuilds mid-request is honoured automatically.\n *\n * Implementations own the scope/lifecycle of whatever they build. `R` is the\n * set of services the handler effect may require; `E` is the layer construction\n * error type (informational — failures surface through the translator).\n */\nexport interface RequestRuntimeProvider<R, E = never> {\n  /** Resolve the runners for a request. Consulted per call, never cached. */\n  readonly run: (event: RequestEvent) => RequestRuntimeRunners<R>;\n  /**\n   * Optional teardown to run after the response is produced. Called by\n   * {@link makeRuntimeAdapter} once the handler has settled — e.g. to route a\n   * per-request resource's disposal through `ctx.waitUntil` on Workers.\n   */\n  readonly disposeAfterResponse?: (event: RequestEvent) => void;\n  /** Phantom marker so `E` participates in inference. */\n  readonly _E?: (_: never) => E;\n}\n\n/** Runners backed by an existing `ManagedRuntime`. */\nconst runnersFromManagedRuntime = <R>(\n  rt: ManagedRuntime.ManagedRuntime<R, unknown>,\n): RequestRuntimeRunners<R> => ({\n  runPromiseExit: (effect) => rt.runPromiseExit(effect) as Promise<Exit.Exit<never, unknown>>,\n  runFork: (effect) => rt.runFork(effect) as Fiber.Fiber<never, unknown>,\n});\n\n/** Runners backed by a built service `Context` (run on the default scheduler). */\nconst runnersFromContext = <R>(context: Context.Context<R>): RequestRuntimeRunners<R> => ({\n  runPromiseExit: (effect) => Effect.runPromiseExitWith(context)(effect),\n  runFork: (effect) => Effect.runForkWith(context)(effect),\n});\n\n/** Runners for a target that is either a `ManagedRuntime` or a `Context`. */\nconst runnersFor = <R>(\n  target: ManagedRuntime.ManagedRuntime<R, unknown> | Context.Context<R>,\n): RequestRuntimeRunners<R> =>\n  ManagedRuntime.isManagedRuntime(target)\n    ? runnersFromManagedRuntime(target as ManagedRuntime.ManagedRuntime<R, unknown>)\n    : runnersFromContext(target as Context.Context<R>);\n\n/** Options for {@link RequestRuntime.fromLayerPerRequest}. */\nexport interface FromLayerPerRequestOptions {\n  /**\n   * Defer teardown of the per-request runtime to after the response is\n   * produced, instead of awaiting `dispose()` inline. On Workers, route it\n   * through `ctx.waitUntil` so disposal does not fight response streaming or\n   * socket pinning:\n   *\n   * ```ts\n   * { afterResponse: (event, dispose) => event.platform!.ctx.waitUntil(dispose()) }\n   * ```\n   */\n  readonly afterResponse?: (event: RequestEvent, dispose: () => Promise<void>) => void;\n}\n\n/**\n * Constructors for {@link RequestRuntimeProvider}. Each expresses one way to\n * obtain a request's execution context; the wrappers don't care which.\n */\nexport const RequestRuntime = {\n  /**\n   * Adopt a `ManagedRuntime` the consumer already built (the build-once model,\n   * expressed as a provider).\n   */\n  fromManagedRuntime: <R, E>(\n    rt: ManagedRuntime.ManagedRuntime<R, E>,\n  ): RequestRuntimeProvider<R, E> => {\n    const runners = runnersFromManagedRuntime(rt as ManagedRuntime.ManagedRuntime<R, unknown>);\n    return { run: () => runners };\n  },\n\n  /**\n   * Let the package build a single `ManagedRuntime` from a layer, lazily on\n   * first use and shared across requests (the existing build-once-per-process\n   * model).\n   */\n  fromLayer: <R, E>(layer: Layer.Layer<R, E>): RequestRuntimeProvider<R, E> => {\n    let runners: RequestRuntimeRunners<R> | undefined;\n    return {\n      run: () =>\n        (runners ??= runnersFromManagedRuntime(\n          ManagedRuntime.make(layer) as ManagedRuntime.ManagedRuntime<R, unknown>,\n        )),\n    };\n  },\n\n  /**\n   * Adopt a runtime the consumer stashed on the request (e.g. on\n   * `event.locals`). Resolved at call time, so a runtime rebuilt mid-request is\n   * honoured automatically. The getter may return a `ManagedRuntime` or a\n   * built service `Context`.\n   */\n  fromLocals: <R>(\n    get: (event: RequestEvent) => ManagedRuntime.ManagedRuntime<R, unknown> | Context.Context<R>,\n  ): RequestRuntimeProvider<R> => ({\n    run: (event) => runnersFor(get(event)),\n  }),\n\n  /**\n   * Let the package build *and dispose* a `ManagedRuntime` per request from a\n   * layer factory. Each handler invocation builds its own runtime from\n   * `layer(event)` and disposes it once the effect settles — so a per-request\n   * resource (a DB pool) dies with the request. Use `opts.afterResponse` to\n   * defer disposal to after the response (Workers `ctx.waitUntil`).\n   *\n   * For sharing one runtime across every load/action of a request, prefer\n   * {@link RequestRuntime.fromLocals} with a runtime the consumer builds in\n   * `hooks.server.ts`.\n   */\n  fromLayerPerRequest: <R, E>(\n    layer: (event: RequestEvent) => Layer.Layer<R, E>,\n    opts?: FromLayerPerRequestOptions,\n  ): RequestRuntimeProvider<R, E> => ({\n    run: (event) => {\n      const dispose = (rt: ManagedRuntime.ManagedRuntime<R, E>) => () => rt.dispose();\n      const teardown = (rt: ManagedRuntime.ManagedRuntime<R, E>): Promise<void> => {\n        if (opts?.afterResponse) {\n          opts.afterResponse(event, dispose(rt));\n          return Promise.resolve();\n        }\n        return rt.dispose();\n      };\n      return {\n        runPromiseExit: async (effect) => {\n          const rt = ManagedRuntime.make(layer(event));\n          try {\n            return (await rt.runPromiseExit(effect)) as Exit.Exit<never, unknown>;\n          } finally {\n            await teardown(rt);\n          }\n        },\n        runFork: (effect) => {\n          const rt = ManagedRuntime.make(layer(event));\n          const fiber = rt.runFork(effect) as Fiber.Fiber<never, unknown>;\n          fiber.addObserver(() => void teardown(rt));\n          return fiber;\n        },\n      };\n    },\n  }),\n};\n\n/** A boundary translator: turn a failed `Cause` into a thrown value. */\nexport type ErrorTranslator = (cause: Cause.Cause<unknown>) => never;\n\n/** Options shared by {@link makeRuntimeAdapter}. */\nexport interface RuntimeAdapterOptions {\n  /**\n   * Translate a failed `Cause` into SvelteKit control flow at the boundary.\n   * Called for `serverLoad` / `action` / `actions` failures; it may throw\n   * `redirect()` / `error()` (and, for remote forms, call `invalid()`).\n   * Defaults to the package's passthrough: SvelteKit's own `redirect()` /\n   * `error()` are rethrown, anything else becomes an `EffectCauseError` (a 500).\n   */\n  readonly translateError?: ErrorTranslator;\n}\n\n/** Options for the adapter's `endpoint` wrapper. */\nexport interface AdapterEndpointOptions {\n  /**\n   * Include full error details (`Cause.pretty`) in the default 500 JSON body.\n   * Ignored when a `translateError` is configured. Defaults to `false`.\n   */\n  readonly exposeErrors?: boolean;\n}\n\n/** The wrappers produced by {@link makeRuntimeAdapter}, bound to a provider. */\nexport interface RuntimeAdapter<R> {\n  readonly serverLoad: <\n    Params extends Record<string, string> = any,\n    ParentData extends Record<string, any> = any,\n    OutputData extends Record<string, any> | void = any,\n    RouteId extends string | null = any,\n  >(\n    fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>,\n  ) => ServerLoad<Params, ParentData, OutputData, RouteId>;\n  readonly action: <\n    Params extends Record<string, string> = any,\n    OutputData extends Record<string, any> | void = any,\n    RouteId extends string | null = any,\n  >(\n    fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>,\n  ) => Action<Params, OutputData, RouteId>;\n  readonly actions: <\n    Params extends Record<string, string> = any,\n    OutputData extends Record<string, any> | void = any,\n    RouteId extends string | null = any,\n  >(\n    map: Record<\n      string,\n      (event: RequestEvent<Params, RouteId>) => Effect.Effect<OutputData, unknown, R>\n    >,\n  ) => Actions<Params, OutputData, RouteId>;\n  readonly endpoint: <\n    Params extends Record<string, string> = any,\n    RouteId extends string | null = any,\n  >(\n    fn: (event: RequestEvent<Params, RouteId>) => Effect.Effect<Response, unknown, R>,\n    options?: AdapterEndpointOptions,\n  ) => RequestHandler<Params, RouteId>;\n}\n\n/**\n * Bind the SvelteKit server wrappers to a {@link RequestRuntimeProvider} (and an\n * optional boundary error translator).\n *\n * Unlike the standalone `serverLoad` / `action` / `endpoint`, the handler\n * effect's required services `R` come from the provider — your own application\n * catalogue — not the fixed {@link SvelteKitServices}. The package does not\n * merge `HttpClient` / `SvelteKitRequestEvent` onto this path; add them to your\n * own layer if you want them.\n *\n * @example\n * ```ts\n * // Package owns the runtime per request on Workers, disposed via waitUntil.\n * const { serverLoad } = makeRuntimeAdapter(\n *   RequestRuntime.fromLayerPerRequest((event) => AppLayer(event.platform!.env), {\n *     afterResponse: (event, dispose) => event.platform!.ctx.waitUntil(dispose()),\n *   }),\n * );\n * ```\n */\nexport const makeRuntimeAdapter = <R>(\n  provider: RequestRuntimeProvider<R, any>,\n  opts?: RuntimeAdapterOptions,\n): RuntimeAdapter<R> => {\n  const translateError: ErrorTranslator =\n    opts?.translateError ??\n    ((cause) => {\n      throw causeToThrowable(cause);\n    });\n\n  const runSettle = async <A>(\n    event: RequestEvent,\n    effect: Effect.Effect<A, unknown, R>,\n  ): Promise<A> => {\n    const exit = await provider.run(event).runPromiseExit(effect);\n    try {\n      if (Exit.isSuccess(exit)) return exit.value;\n      return translateError(exit.cause);\n    } finally {\n      provider.disposeAfterResponse?.(event);\n    }\n  };\n\n  const action: RuntimeAdapter<R>[\"action\"] = (fn) => (event) => runSettle(event, fn(event));\n\n  return {\n    serverLoad: (fn) => (event) => runSettle(event, fn(event)),\n    action,\n    actions: (map) => {\n      const wrapped: Record<string, Action<any, any, any>> = {};\n      for (const [key, fn] of Object.entries(map)) wrapped[key] = action(fn);\n      return wrapped as never;\n    },\n    endpoint: (fn, options) => async (event) => {\n      const exit = await provider.run(event as RequestEvent).runPromiseExit(fn(event));\n      try {\n        if (Exit.isSuccess(exit)) return exit.value;\n        // A configured translator owns the whole failure path (control flow,\n        // structured error bodies, ...).\n        if (opts?.translateError) return opts.translateError(exit.cause);\n        // Default: pass SvelteKit control flow through, otherwise a 500.\n        const squashed = Cause.squash(exit.cause);\n        if (isRedirect(squashed) || isHttpError(squashed)) throw squashed;\n        console.error(\"Endpoint error:\", Cause.pretty(exit.cause));\n        const message = options?.exposeErrors ? Cause.pretty(exit.cause) : \"Internal server error\";\n        return new Response(JSON.stringify({ error: message }), {\n          status: 500,\n          headers: { \"Content-Type\": \"application/json\" },\n        });\n      } finally {\n        provider.disposeAfterResponse?.(event as RequestEvent);\n      }\n    },\n  };\n};\n"],"mappings":"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"}