@fedify/adonisjs 2.4.0-dev.0

package/dist/providers/fedify_provider.js

@@ -0,0 +1,269 @@
+import { E_FEDERATION_NOT_READY, E_INVALID_FEDIFY_CONFIG } from "../src/errors.js";
+import { installFederationGetter } from "../src/http_context.js";
+import FedifyMiddleware from "../src/fedify_middleware.js";
+import { configureFedifyLogging } from "../src/logging.js";
+import { builder } from "../src/builder.js";
+import { configProvider } from "@adonisjs/core";
+import { reset } from "@logtape/logtape";
+
+//#region providers/fedify_provider.ts
+/**
+* The `@fedify/adonisjs` service provider; see {@link FedifyProvider}.
+*
+* @module
+*/
+/**
+* How long a request that arrives before `ready()` waits for the federation.
+*
+* Generous, since it only needs to outlast earlier providers' `ready()` hooks.
+* It turns a `ready()` that never comes (an earlier provider waiting on this
+* server) into an error instead of a request that never completes.
+*/
+const READY_TIMEOUT_MS = 3e4;
+/**
+* Memoises an asynchronous factory, caching successes only.
+*
+* Used for the container bindings instead of `container.singleton()`, which
+* also caches *rejections*: one early, swallowed `make('fedify')` would pin
+* `E_FEDERATION_NOT_READY` for the life of the process.  A failed attempt is
+* forgotten instead, so the next caller runs the factory again.  `forget()`
+* drops a cached success once the caller knows it is stale.
+*/
+function memoizeSuccess(factory) {
+	let cached;
+	const memo = () => {
+		cached ??= factory().catch((error) => {
+			cached = undefined;
+			throw error;
+		});
+		return cached;
+	};
+	return Object.assign(memo, { forget: () => {
+		cached = undefined;
+	} });
+}
+/**
+* The service provider registered from `adonisrc.ts` as
+* `@fedify/adonisjs/fedify_provider`.
+*
+* Binds `fedify.builder`, `fedify.config`, `fedify` and
+* {@link FedifyMiddleware}, installs `ctx.federation`, bridges Fedify's logs
+* into the AdonisJS logger, builds the federation after the preload files
+* have run, and drains the task queue in the web process.
+*/
+var FedifyProvider = class {
+	/**
+	* Aborts the queue worker on shutdown.
+	*/
+	#queueController = new AbortController();
+	/**
+	* The `startQueue()` promise, settled once every listener has stopped.
+	* `shutdown()` returns it so AdonisJS waits for the workers.  Undefined when
+	* this process does not drain the queue.
+	*/
+	#queue;
+	/**
+	* Whether this provider configured LogTape and must undo it on shutdown.
+	*
+	* LogTape's configuration is process-global and its sink closes over *this*
+	* application's `Logger`.  Left in place, a second application in the same
+	* process (the test runner, a dev-server restart) would find LogTape already
+	* configured and keep logging into the terminated application's logger.
+	*/
+	#loggingConfigured = false;
+	/**
+	* Whether the builder may be sealed into a `Federation` object.
+	*
+	* Dispatchers are registered in preload files, which AdonisJS imports *after*
+	* every provider's `boot()` and `start()`.  Building earlier would yield a
+	* federation with no routes and 404s as the only symptom, so an early build
+	* fails with an explanatory error instead.
+	*/
+	#buildable = false;
+	/**
+	* Whether the HTTP server has started accepting connections.
+	*
+	* AdonisJS listens inside `start()` and runs `ready()` hooks afterwards, so a
+	* request (a health probe, `fedify tunnel`) can arrive before this provider
+	* is ready.  Such a request is the one caller allowed to *wait* for the
+	* federation, since `ready()` is on its way; any other caller (a `start()`
+	* hook, a preload file, an Ace command) fails fast because nothing would
+	* make it ready while they wait.
+	*/
+	#listening = false;
+	/**
+	* Settles once `ready()` has built the federation: resolved on success,
+	* rejected with the configuration error, or with `E_FEDERATION_NOT_READY`
+	* when the application shuts down first or {@link READY_TIMEOUT_MS} passes.
+	*/
+	#ready = Promise.withResolvers();
+	#readyTimer;
+	/**
+	* The memoised middleware binding, kept here so that a failed `ready()` can
+	* forget it.
+	*
+	* A request that arrives while `ready()` is running builds its middleware
+	* from a federation that is buildable at that moment.  Should `ready()` fail
+	* afterwards, that middleware would otherwise stay cached and keep serving
+	* federation traffic in an application whose `make('fedify')` fails fast and
+	* whose queue never started.
+	*/
+	#middleware;
+	app;
+	/**
+	* Longhand rather than a parameter property, which Node's type stripping
+	* does not support; the tests run these sources through it.
+	*/
+	constructor(app) {
+		this.app = app;
+		this.#ready.promise.catch(() => {});
+	}
+	/**
+	* Registers the container bindings.
+	*/
+	register() {
+		/**
+		* Bound as a value: the builder is a module-level singleton that
+		* application code also imports directly, and both routes must reach the
+		* same object.
+		*/
+		this.app.container.bindValue("fedify.builder", builder);
+		this.app.container.bind("fedify.config", memoizeSuccess(async () => {
+			const provider = this.app.config.get("fedify");
+			const config = await configProvider.resolve(this.app, provider);
+			if (!config) {
+				throw new E_INVALID_FEDIFY_CONFIG();
+			}
+			return config;
+		}));
+		const buildFederation = memoizeSuccess(async () => {
+			const config = await this.app.container.make("fedify.config");
+			const federationBuilder = await this.app.container.make("fedify.builder");
+			return federationBuilder.build(config);
+		});
+		this.app.container.bind("fedify", () => {
+			if (!this.#buildable) {
+				throw new E_FEDERATION_NOT_READY();
+			}
+			return buildFederation();
+		});
+		/**
+		* The middleware, built with the federation and configuration in scope, as
+		* `@adonisjs/cors` and `@adonisjs/session` do.  `server.use()` resolves
+		* the class through the container on every request, which lands here.
+		*
+		* A plain `bind()` plus {@link memoizeSuccess} rather than `singleton()`
+		* (see the helper), so every request shares one instance.
+		*
+		* A request that arrives after the server listens but before `ready()` has
+		* built the federation waits for it (see {@link #listening}); any other
+		* caller gets `E_FEDERATION_NOT_READY` at once.
+		*/
+		this.#middleware = memoizeSuccess(async () => {
+			if (!this.#buildable) {
+				if (!this.#listening) throw new E_FEDERATION_NOT_READY();
+				await this.#ready.promise;
+			}
+			const federation = await this.app.container.make("fedify");
+			const config = await this.app.container.make("fedify.config");
+			return new FedifyMiddleware(federation, config.contextDataFactory, { ignoreRoutePrefixes: config.ignoreRoutePrefixes });
+		});
+		this.app.container.bind(FedifyMiddleware, this.#middleware);
+	}
+	/**
+	* Installs `ctx.federation`, bridges Fedify's logs into the AdonisJS logger,
+	* and subscribes to the HTTP server's ready event.
+	*/
+	async boot() {
+		installFederationGetter();
+		const config = await this.app.container.make("fedify.config");
+		if (config.logging !== false) {
+			const logger = await this.app.container.make("logger");
+			this.#loggingConfigured = await configureFedifyLogging({
+				logger,
+				categories: config.logging === true ? undefined : config.logging.categories
+			});
+		}
+		if (this.app.container.hasBinding("emitter")) {
+			const emitter = await this.app.container.make("emitter");
+			emitter.on("http:server_ready", () => this.#serverStarted());
+		}
+	}
+	/**
+	* Runs after the preload files have registered every dispatcher.
+	*/
+	async ready() {
+		this.#buildable = true;
+		let federation;
+		let worker;
+		try {
+			federation = await this.app.container.make("fedify");
+			const config = await this.app.container.make("fedify.config");
+			if (typeof config.queueContextData === "function" && this.app.getEnvironment() === "web") {
+				worker = {
+					contextData: await config.queueContextData(),
+					logger: await this.app.container.make("logger")
+				};
+			}
+		} catch (error) {
+			this.#buildable = false;
+			this.#middleware?.forget();
+			this.#settle(error);
+			throw error;
+		}
+		this.#settle();
+		if (worker === undefined) return;
+		if (this.#queueController.signal.aborted) return;
+		const { contextData, logger } = worker;
+		this.#queue = federation.startQueue(contextData, { signal: this.#queueController.signal }).catch((error) => {
+			if (this.#queueController.signal.aborted) return;
+			logger.error({ err: error }, "The Fedify task queue stopped unexpectedly");
+		});
+	}
+	/**
+	* Stops the queue worker and waits for it, releases any request still
+	* waiting on `ready()`, and takes the LogTape configuration down.
+	*
+	* Aborting only *asks* the listeners to stop; `startQueue()` settles once
+	* they have, possibly one in-flight delivery later.  Returning that promise
+	* keeps the rest of the shutdown sequence (closing the database, most
+	* importantly) behind it.
+	*
+	* LogTape is reset after the queue stops, so an outgoing delivery can still
+	* log, and only if this provider configured it (see
+	* {@link #loggingConfigured}); resetting the application's own
+	* configuration would silence its logs.
+	*
+	* The return type stays a promise even with no queue to wait for: AdonisJS
+	* warns when a provider hook returns a non-thenable.
+	*/
+	shutdown() {
+		this.#settle(new E_FEDERATION_NOT_READY());
+		this.#queueController.abort();
+		const stopped = this.#queue ?? Promise.resolve();
+		if (!this.#loggingConfigured) return stopped;
+		this.#loggingConfigured = false;
+		return stopped.then(() => reset().catch(() => {}));
+	}
+	/**
+	* Called when the HTTP server starts listening and requests can arrive.
+	*/
+	#serverStarted() {
+		this.#listening = true;
+		if (this.#buildable) return;
+		this.#readyTimer = setTimeout(() => this.#settle(new E_FEDERATION_NOT_READY()), READY_TIMEOUT_MS);
+		this.#readyTimer.unref();
+	}
+	/**
+	* Settles the `ready()` promise once; later calls are no-ops.
+	*/
+	#settle(error) {
+		clearTimeout(this.#readyTimer);
+		if (error === undefined) this.#ready.resolve();
+		else this.#ready.reject(error);
+	}
+};
+
+//#endregion
+export { FedifyProvider as default };
+//# sourceMappingURL=fedify_provider.js.map

package/dist/providers/fedify_provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fedify_provider.js","names":["#ready","#buildable","#middleware","#listening","#loggingConfigured","#serverStarted","#settle","#queueController","#queue","resetLogging","#readyTimer"],"sources":["../../providers/fedify_provider.ts"],"sourcesContent":["/**\n * The `@fedify/adonisjs` service provider; see {@link FedifyProvider}.\n *\n * @module\n */\nimport { configProvider } from \"@adonisjs/core\";\nimport type { Logger } from \"@adonisjs/core/logger\";\nimport type { ApplicationService, ConfigProvider } from \"@adonisjs/core/types\";\nimport type { Federation } from \"@fedify/fedify\";\nimport { reset as resetLogging } from \"@logtape/logtape\";\n\nimport { builder } from \"../src/builder.ts\";\nimport {\n  E_FEDERATION_NOT_READY,\n  E_INVALID_FEDIFY_CONFIG,\n} from \"../src/errors.ts\";\nimport FedifyMiddleware from \"../src/fedify_middleware.ts\";\nimport { installFederationGetter } from \"../src/http_context.ts\";\nimport { configureFedifyLogging } from \"../src/logging.ts\";\nimport type { ContextData, ResolvedFedifyConfig } from \"../src/types.ts\";\n\n/**\n * How long a request that arrives before `ready()` waits for the federation.\n *\n * Generous, since it only needs to outlast earlier providers' `ready()` hooks.\n * It turns a `ready()` that never comes (an earlier provider waiting on this\n * server) into an error instead of a request that never completes.\n */\nconst READY_TIMEOUT_MS = 30_000;\n\n/**\n * A memoised factory: the value, plus a way to drop what was cached.\n */\ntype Memoized<T> = (() => Promise<T>) & { forget(): void };\n\n/**\n * Memoises an asynchronous factory, caching successes only.\n *\n * Used for the container bindings instead of `container.singleton()`, which\n * also caches *rejections*: one early, swallowed `make('fedify')` would pin\n * `E_FEDERATION_NOT_READY` for the life of the process.  A failed attempt is\n * forgotten instead, so the next caller runs the factory again.  `forget()`\n * drops a cached success once the caller knows it is stale.\n */\nfunction memoizeSuccess<T>(factory: () => Promise<T>): Memoized<T> {\n  let cached: Promise<T> | undefined;\n\n  const memo = (): Promise<T> => {\n    cached ??= factory().catch((error: unknown) => {\n      cached = undefined;\n      throw error;\n    });\n\n    return cached;\n  };\n\n  return Object.assign(memo, {\n    forget: (): void => {\n      cached = undefined;\n    },\n  });\n}\n\n/**\n * The service provider registered from `adonisrc.ts` as\n * `@fedify/adonisjs/fedify_provider`.\n *\n * Binds `fedify.builder`, `fedify.config`, `fedify` and\n * {@link FedifyMiddleware}, installs `ctx.federation`, bridges Fedify's logs\n * into the AdonisJS logger, builds the federation after the preload files\n * have run, and drains the task queue in the web process.\n */\nexport default class FedifyProvider {\n  /**\n   * Aborts the queue worker on shutdown.\n   */\n  #queueController = new AbortController();\n\n  /**\n   * The `startQueue()` promise, settled once every listener has stopped.\n   * `shutdown()` returns it so AdonisJS waits for the workers.  Undefined when\n   * this process does not drain the queue.\n   */\n  #queue?: Promise<void>;\n\n  /**\n   * Whether this provider configured LogTape and must undo it on shutdown.\n   *\n   * LogTape's configuration is process-global and its sink closes over *this*\n   * application's `Logger`.  Left in place, a second application in the same\n   * process (the test runner, a dev-server restart) would find LogTape already\n   * configured and keep logging into the terminated application's logger.\n   */\n  #loggingConfigured = false;\n\n  /**\n   * Whether the builder may be sealed into a `Federation` object.\n   *\n   * Dispatchers are registered in preload files, which AdonisJS imports *after*\n   * every provider's `boot()` and `start()`.  Building earlier would yield a\n   * federation with no routes and 404s as the only symptom, so an early build\n   * fails with an explanatory error instead.\n   */\n  #buildable = false;\n\n  /**\n   * Whether the HTTP server has started accepting connections.\n   *\n   * AdonisJS listens inside `start()` and runs `ready()` hooks afterwards, so a\n   * request (a health probe, `fedify tunnel`) can arrive before this provider\n   * is ready.  Such a request is the one caller allowed to *wait* for the\n   * federation, since `ready()` is on its way; any other caller (a `start()`\n   * hook, a preload file, an Ace command) fails fast because nothing would\n   * make it ready while they wait.\n   */\n  #listening = false;\n\n  /**\n   * Settles once `ready()` has built the federation: resolved on success,\n   * rejected with the configuration error, or with `E_FEDERATION_NOT_READY`\n   * when the application shuts down first or {@link READY_TIMEOUT_MS} passes.\n   */\n  #ready = Promise.withResolvers<void>();\n  #readyTimer?: ReturnType<typeof setTimeout>;\n\n  /**\n   * The memoised middleware binding, kept here so that a failed `ready()` can\n   * forget it.\n   *\n   * A request that arrives while `ready()` is running builds its middleware\n   * from a federation that is buildable at that moment.  Should `ready()` fail\n   * afterwards, that middleware would otherwise stay cached and keep serving\n   * federation traffic in an application whose `make('fedify')` fails fast and\n   * whose queue never started.\n   */\n  #middleware?: Memoized<FedifyMiddleware<ContextData>>;\n\n  protected app: ApplicationService;\n\n  /**\n   * Longhand rather than a parameter property, which Node's type stripping\n   * does not support; the tests run these sources through it.\n   */\n  constructor(app: ApplicationService) {\n    this.app = app;\n\n    // Only requests waiting on `ready()` observe the rejection; without this\n    // handler Node would report it as unhandled when nobody was.\n    this.#ready.promise.catch(() => {});\n  }\n\n  /**\n   * Registers the container bindings.\n   */\n  register(): void {\n    /**\n     * Bound as a value: the builder is a module-level singleton that\n     * application code also imports directly, and both routes must reach the\n     * same object.\n     */\n    this.app.container.bindValue(\"fedify.builder\", builder);\n\n    this.app.container.bind(\n      \"fedify.config\",\n      memoizeSuccess(async () => {\n        const provider = this.app.config.get<\n          ConfigProvider<ResolvedFedifyConfig>\n        >(\"fedify\");\n        const config = await configProvider.resolve<ResolvedFedifyConfig>(\n          this.app,\n          provider,\n        );\n\n        if (!config) {\n          throw new E_INVALID_FEDIFY_CONFIG();\n        }\n\n        return config;\n      }),\n    );\n\n    const buildFederation = memoizeSuccess(async () => {\n      const config = await this.app.container.make(\"fedify.config\");\n      const federationBuilder = await this.app.container.make(\"fedify.builder\");\n\n      return federationBuilder.build(config);\n    });\n\n    this.app.container.bind(\"fedify\", () => {\n      if (!this.#buildable) {\n        throw new E_FEDERATION_NOT_READY();\n      }\n\n      return buildFederation();\n    });\n\n    /**\n     * The middleware, built with the federation and configuration in scope, as\n     * `@adonisjs/cors` and `@adonisjs/session` do.  `server.use()` resolves\n     * the class through the container on every request, which lands here.\n     *\n     * A plain `bind()` plus {@link memoizeSuccess} rather than `singleton()`\n     * (see the helper), so every request shares one instance.\n     *\n     * A request that arrives after the server listens but before `ready()` has\n     * built the federation waits for it (see {@link #listening}); any other\n     * caller gets `E_FEDERATION_NOT_READY` at once.\n     */\n    this.#middleware = memoizeSuccess(async () => {\n      if (!this.#buildable) {\n        if (!this.#listening) throw new E_FEDERATION_NOT_READY();\n        await this.#ready.promise;\n      }\n\n      const federation = await this.app.container.make(\"fedify\");\n      const config = await this.app.container.make(\"fedify.config\");\n\n      return new FedifyMiddleware<ContextData>(\n        federation,\n        config.contextDataFactory,\n        { ignoreRoutePrefixes: config.ignoreRoutePrefixes },\n      );\n    });\n\n    this.app.container.bind(FedifyMiddleware, this.#middleware);\n  }\n\n  /**\n   * Installs `ctx.federation`, bridges Fedify's logs into the AdonisJS logger,\n   * and subscribes to the HTTP server's ready event.\n   */\n  async boot(): Promise<void> {\n    // `ctx.federation` as a Macroable getter on the `HttpContext` prototype.\n    // The middleware also installs it on each context's class (covering\n    // another `@adonisjs/core` copy); this covers requests the middleware\n    // never saw, which then get `E_FEDIFY_CONTEXT_UNAVAILABLE` rather than\n    // `undefined`.\n    installFederationGetter();\n\n    const config = await this.app.container.make(\"fedify.config\");\n\n    if (config.logging !== false) {\n      const logger = await this.app.container.make(\"logger\");\n      this.#loggingConfigured = await configureFedifyLogging({\n        logger,\n        categories: config.logging === true\n          ? undefined\n          : config.logging.categories,\n      });\n    }\n\n    // The core `app_provider` binds the emitter; a bare application in a test\n    // may lack it, and then has no HTTP server to hear from either.\n    if (this.app.container.hasBinding(\"emitter\")) {\n      const emitter = await this.app.container.make(\"emitter\");\n      emitter.on(\"http:server_ready\", () => this.#serverStarted());\n    }\n  }\n\n  /**\n   * Runs after the preload files have registered every dispatcher.\n   */\n  async ready(): Promise<void> {\n    this.#buildable = true;\n\n    // Build eagerly so a broken federation surfaces at startup rather than on\n    // the first federation request.  Requests waiting in the middleware\n    // binding get the same outcome.\n    let federation: Federation<ContextData>;\n    let worker: { contextData: ContextData; logger: Logger } | undefined;\n    try {\n      federation = await this.app.container.make(\"fedify\");\n      const config = await this.app.container.make(\"fedify.config\");\n\n      // Only the web process drains the queue: Ace commands, the REPL and the\n      // test runner also reach `ready()`, where a worker would outlive the\n      // command and compete for the queue.  The context data is built before\n      // the waiting requests are released, so a throwing callback fails\n      // startup like a broken federation instead of rejecting `ready()` with\n      // requests already being served.\n      if (\n        typeof config.queueContextData === \"function\" &&\n        this.app.getEnvironment() === \"web\"\n      ) {\n        worker = {\n          contextData: await config.queueContextData(),\n          logger: await this.app.container.make(\"logger\"),\n        };\n      }\n    } catch (error: unknown) {\n      // Back to failing fast: a surviving process (an Ace command, the REPL)\n      // must not have later `make('fedify')` calls re-run the configuration,\n      // nor keep the middleware a request built while this hook was still\n      // running (see {@link #middleware}).\n      this.#buildable = false;\n      this.#middleware?.forget();\n      this.#settle(error);\n      throw error;\n    }\n    this.#settle();\n\n    if (worker === undefined) return;\n\n    // `shutdown()` can have run while this hook was awaiting above: it settles\n    // and aborts, but finds no queue promise to wait for.  Starting a worker on\n    // the aborted signal now would leave one running that nothing awaits.\n    if (this.#queueController.signal.aborted) return;\n\n    // `startQueue` settles only when the queue stops, so it must not be\n    // awaited here.  The promise is kept for `shutdown()`, `catch` included,\n    // so awaiting it there never rejects.\n    const { contextData, logger } = worker;\n    this.#queue = federation\n      .startQueue(contextData, { signal: this.#queueController.signal })\n      .catch((error: unknown) => {\n        if (this.#queueController.signal.aborted) return;\n        logger.error(\n          { err: error },\n          \"The Fedify task queue stopped unexpectedly\",\n        );\n      });\n  }\n\n  /**\n   * Stops the queue worker and waits for it, releases any request still\n   * waiting on `ready()`, and takes the LogTape configuration down.\n   *\n   * Aborting only *asks* the listeners to stop; `startQueue()` settles once\n   * they have, possibly one in-flight delivery later.  Returning that promise\n   * keeps the rest of the shutdown sequence (closing the database, most\n   * importantly) behind it.\n   *\n   * LogTape is reset after the queue stops, so an outgoing delivery can still\n   * log, and only if this provider configured it (see\n   * {@link #loggingConfigured}); resetting the application's own\n   * configuration would silence its logs.\n   *\n   * The return type stays a promise even with no queue to wait for: AdonisJS\n   * warns when a provider hook returns a non-thenable.\n   */\n  shutdown(): Promise<void> {\n    this.#settle(new E_FEDERATION_NOT_READY());\n    this.#queueController.abort();\n\n    const stopped = this.#queue ?? Promise.resolve();\n    if (!this.#loggingConfigured) return stopped;\n\n    this.#loggingConfigured = false;\n    // A failing reset must not fail the shutdown queued behind it.  The queue\n    // promise never rejects, so only the reset is guarded.\n    return stopped.then(() => resetLogging().catch(() => {}));\n  }\n\n  /**\n   * Called when the HTTP server starts listening and requests can arrive.\n   */\n  #serverStarted(): void {\n    this.#listening = true;\n    if (this.#buildable) return;\n\n    this.#readyTimer = setTimeout(\n      () => this.#settle(new E_FEDERATION_NOT_READY()),\n      READY_TIMEOUT_MS,\n    );\n    // A pending timer must not keep the process alive.\n    this.#readyTimer.unref();\n  }\n\n  /**\n   * Settles the `ready()` promise once; later calls are no-ops.\n   */\n  #settle(error?: unknown): void {\n    clearTimeout(this.#readyTimer);\n    if (error === undefined) this.#ready.resolve();\n    else this.#ready.reject(error);\n  }\n}\n"],"mappings":"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"}

package/dist/services/builder.cjs

@@ -0,0 +1,9 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_src_builder = require('../src/builder.cjs');
+
+//#region services/builder.ts
+const federation = require_src_builder.builder;
+
+//#endregion
+exports.default = federation;
+//# sourceMappingURL=builder.cjs.map

package/dist/services/builder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.cjs","names":["builder"],"sources":["../../services/builder.ts"],"sourcesContent":["/**\n * Service module exposing the Fedify {@link FederationBuilder}.\n *\n * This is the module application code imports to register dispatchers and inbox\n * listeners:\n *\n * ```ts\n * // app/federation/actors.ts\n * import federation from '@fedify/adonisjs/services/builder'\n *\n * federation.setActorDispatcher('/actors/{identifier}', async (ctx, identifier) => {\n *   // ...\n * })\n * ```\n *\n * Registration must happen while the application boots — the generated\n * `start/federation.ts` preload file is the intended place — because the\n * builder is sealed into a `Federation` object once booting completes.\n *\n * @module\n */\nimport type { FederationBuilder } from \"@fedify/fedify\";\n\nimport { builder } from \"../src/builder.ts\";\nimport type { ContextData } from \"../src/types.ts\";\n\nconst federation: FederationBuilder<ContextData> = builder;\n\nexport default federation;\n"],"mappings":";;;;AA0BA,MAAM,aAA6CA"}

package/dist/services/builder.d.cts

@@ -0,0 +1,7 @@
+import { ContextData } from "../src/types.cjs";
+import { FederationBuilder } from "@fedify/fedify";
+
+//#region services/builder.d.ts
+declare const federation: FederationBuilder<ContextData>;
+export = federation;
+//# sourceMappingURL=builder.d.cts.map

package/dist/services/builder.d.ts

@@ -0,0 +1,8 @@
+import { ContextData } from "../src/types.js";
+import { FederationBuilder } from "@fedify/fedify";
+
+//#region services/builder.d.ts
+declare const federation: FederationBuilder<ContextData>;
+//#endregion
+export { federation as default };
+//# sourceMappingURL=builder.d.ts.map

package/dist/services/builder.js

@@ -0,0 +1,8 @@
+import { builder } from "../src/builder.js";
+
+//#region services/builder.ts
+const federation = builder;
+
+//#endregion
+export { federation as default };
+//# sourceMappingURL=builder.js.map

package/dist/services/builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.js","names":[],"sources":["../../services/builder.ts"],"sourcesContent":["/**\n * Service module exposing the Fedify {@link FederationBuilder}.\n *\n * This is the module application code imports to register dispatchers and inbox\n * listeners:\n *\n * ```ts\n * // app/federation/actors.ts\n * import federation from '@fedify/adonisjs/services/builder'\n *\n * federation.setActorDispatcher('/actors/{identifier}', async (ctx, identifier) => {\n *   // ...\n * })\n * ```\n *\n * Registration must happen while the application boots — the generated\n * `start/federation.ts` preload file is the intended place — because the\n * builder is sealed into a `Federation` object once booting completes.\n *\n * @module\n */\nimport type { FederationBuilder } from \"@fedify/fedify\";\n\nimport { builder } from \"../src/builder.ts\";\nimport type { ContextData } from \"../src/types.ts\";\n\nconst federation: FederationBuilder<ContextData> = builder;\n\nexport default federation;\n"],"mappings":";;;AA0BA,MAAM,aAA6C"}

package/dist/src/builder.cjs

@@ -0,0 +1,55 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _fedify_fedify = require("@fedify/fedify");
+
+//#region src/builder.ts
+/**
+* The application-wide {@link FederationBuilder}.
+*
+* Fedify's builder pattern separates *registering* dispatchers from *building*
+* the `Federation` object.  That separation is what makes an AdonisJS
+* integration possible at all: dispatcher registration happens while the
+* application boots (in preload files, which may import Lucid models and other
+* container services), while the `Federation` itself can only be built once
+* every registration is in — and once `config/fedify.ts` has been resolved.
+*
+* The builder is a process-wide singleton for the same reason AdonisJS's own
+* `router` and `server` service modules are: application code has to be able to
+* reach it from a plain `import` at module scope, without an `await`.
+*
+* Note that this module deliberately imports nothing from AdonisJS.  The
+* original prototype of this package bound the builder into the IoC container
+* as an import side effect, which meant the container binding existed only if
+* some other module happened to import this one first.  Binding is the service
+* provider's job instead; see `providers/fedify_provider.ts`.
+*
+* On the dual build: this is the one module with state, so the classic
+* dual-package hazard applies — a process that loaded both the ESM and the
+* CommonJS copy would otherwise hold two builders, and dispatchers registered
+* on one would be silently missing from the `Federation` built from the other.
+* The singleton therefore lives in a `globalThis` slot under a registered
+* symbol, which every copy of this module resolves to the same object.
+*
+* @module
+*/
+/**
+* The slot the singleton lives in, keyed by major version.
+*
+* Every copy of *this* package resolves the same key, which is the point — the
+* ESM and CommonJS builds have to agree.  A different major version of
+* `@fedify/adonisjs` hoisted into the same process gets a slot of its own
+* rather than inheriting dispatchers registered against another major's
+* `FederationBuilder`.
+*/
+const SLOT = Symbol.for("@fedify/adonisjs@2/builder");
+const registry = globalThis;
+/**
+* The builder that dispatchers and inbox listeners are registered on.
+*
+* Prefer importing it through the `@fedify/adonisjs/services/builder` service
+* module, which is the path the generated stubs and the documentation use.
+*/
+const builder = registry[SLOT] ??= (0, _fedify_fedify.createFederationBuilder)();
+
+//#endregion
+exports.builder = builder;
+//# sourceMappingURL=builder.cjs.map

package/dist/src/builder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.cjs","names":[],"sources":["../../src/builder.ts"],"sourcesContent":["/**\n * The application-wide {@link FederationBuilder}.\n *\n * Fedify's builder pattern separates *registering* dispatchers from *building*\n * the `Federation` object.  That separation is what makes an AdonisJS\n * integration possible at all: dispatcher registration happens while the\n * application boots (in preload files, which may import Lucid models and other\n * container services), while the `Federation` itself can only be built once\n * every registration is in — and once `config/fedify.ts` has been resolved.\n *\n * The builder is a process-wide singleton for the same reason AdonisJS's own\n * `router` and `server` service modules are: application code has to be able to\n * reach it from a plain `import` at module scope, without an `await`.\n *\n * Note that this module deliberately imports nothing from AdonisJS.  The\n * original prototype of this package bound the builder into the IoC container\n * as an import side effect, which meant the container binding existed only if\n * some other module happened to import this one first.  Binding is the service\n * provider's job instead; see `providers/fedify_provider.ts`.\n *\n * On the dual build: this is the one module with state, so the classic\n * dual-package hazard applies — a process that loaded both the ESM and the\n * CommonJS copy would otherwise hold two builders, and dispatchers registered\n * on one would be silently missing from the `Federation` built from the other.\n * The singleton therefore lives in a `globalThis` slot under a registered\n * symbol, which every copy of this module resolves to the same object.\n *\n * @module\n */\nimport {\n  createFederationBuilder,\n  type FederationBuilder,\n} from \"@fedify/fedify\";\n\nimport type { ContextData } from \"./types.ts\";\n\n/**\n * The slot the singleton lives in, keyed by major version.\n *\n * Every copy of *this* package resolves the same key, which is the point — the\n * ESM and CommonJS builds have to agree.  A different major version of\n * `@fedify/adonisjs` hoisted into the same process gets a slot of its own\n * rather than inheriting dispatchers registered against another major's\n * `FederationBuilder`.\n */\nconst SLOT: unique symbol = Symbol.for(\"@fedify/adonisjs@2/builder\");\n\nconst registry = globalThis as { [SLOT]?: FederationBuilder<ContextData> };\n\n/**\n * The builder that dispatchers and inbox listeners are registered on.\n *\n * Prefer importing it through the `@fedify/adonisjs/services/builder` service\n * module, which is the path the generated stubs and the documentation use.\n */\nexport const builder: FederationBuilder<ContextData> = registry[SLOT] ??=\n  createFederationBuilder<ContextData>();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,MAAM,OAAsB,OAAO,IAAI,4BAA4B;AAEnE,MAAM,WAAW;;;;;;;AAQjB,MAAa,UAA0C,SAAS,sDACzB"}

package/dist/src/builder.d.cts

@@ -0,0 +1,14 @@
+import { ContextData } from "./types.cjs";
+import { FederationBuilder } from "@fedify/fedify";
+
+//#region src/builder.d.ts
+/**
+* The builder that dispatchers and inbox listeners are registered on.
+*
+* Prefer importing it through the `@fedify/adonisjs/services/builder` service
+* module, which is the path the generated stubs and the documentation use.
+*/
+declare const builder: FederationBuilder<ContextData>;
+//#endregion
+export { builder };
+//# sourceMappingURL=builder.d.cts.map

package/dist/src/builder.d.ts

@@ -0,0 +1,14 @@
+import { ContextData } from "./types.js";
+import { FederationBuilder } from "@fedify/fedify";
+
+//#region src/builder.d.ts
+/**
+* The builder that dispatchers and inbox listeners are registered on.
+*
+* Prefer importing it through the `@fedify/adonisjs/services/builder` service
+* module, which is the path the generated stubs and the documentation use.
+*/
+declare const builder: FederationBuilder<ContextData>;
+//#endregion
+export { builder };
+//# sourceMappingURL=builder.d.ts.map

package/dist/src/builder.js

@@ -0,0 +1,54 @@
+import { createFederationBuilder } from "@fedify/fedify";
+
+//#region src/builder.ts
+/**
+* The application-wide {@link FederationBuilder}.
+*
+* Fedify's builder pattern separates *registering* dispatchers from *building*
+* the `Federation` object.  That separation is what makes an AdonisJS
+* integration possible at all: dispatcher registration happens while the
+* application boots (in preload files, which may import Lucid models and other
+* container services), while the `Federation` itself can only be built once
+* every registration is in — and once `config/fedify.ts` has been resolved.
+*
+* The builder is a process-wide singleton for the same reason AdonisJS's own
+* `router` and `server` service modules are: application code has to be able to
+* reach it from a plain `import` at module scope, without an `await`.
+*
+* Note that this module deliberately imports nothing from AdonisJS.  The
+* original prototype of this package bound the builder into the IoC container
+* as an import side effect, which meant the container binding existed only if
+* some other module happened to import this one first.  Binding is the service
+* provider's job instead; see `providers/fedify_provider.ts`.
+*
+* On the dual build: this is the one module with state, so the classic
+* dual-package hazard applies — a process that loaded both the ESM and the
+* CommonJS copy would otherwise hold two builders, and dispatchers registered
+* on one would be silently missing from the `Federation` built from the other.
+* The singleton therefore lives in a `globalThis` slot under a registered
+* symbol, which every copy of this module resolves to the same object.
+*
+* @module
+*/
+/**
+* The slot the singleton lives in, keyed by major version.
+*
+* Every copy of *this* package resolves the same key, which is the point — the
+* ESM and CommonJS builds have to agree.  A different major version of
+* `@fedify/adonisjs` hoisted into the same process gets a slot of its own
+* rather than inheriting dispatchers registered against another major's
+* `FederationBuilder`.
+*/
+const SLOT = Symbol.for("@fedify/adonisjs@2/builder");
+const registry = globalThis;
+/**
+* The builder that dispatchers and inbox listeners are registered on.
+*
+* Prefer importing it through the `@fedify/adonisjs/services/builder` service
+* module, which is the path the generated stubs and the documentation use.
+*/
+const builder = registry[SLOT] ??= createFederationBuilder();
+
+//#endregion
+export { builder };
+//# sourceMappingURL=builder.js.map

package/dist/src/builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.js","names":[],"sources":["../../src/builder.ts"],"sourcesContent":["/**\n * The application-wide {@link FederationBuilder}.\n *\n * Fedify's builder pattern separates *registering* dispatchers from *building*\n * the `Federation` object.  That separation is what makes an AdonisJS\n * integration possible at all: dispatcher registration happens while the\n * application boots (in preload files, which may import Lucid models and other\n * container services), while the `Federation` itself can only be built once\n * every registration is in — and once `config/fedify.ts` has been resolved.\n *\n * The builder is a process-wide singleton for the same reason AdonisJS's own\n * `router` and `server` service modules are: application code has to be able to\n * reach it from a plain `import` at module scope, without an `await`.\n *\n * Note that this module deliberately imports nothing from AdonisJS.  The\n * original prototype of this package bound the builder into the IoC container\n * as an import side effect, which meant the container binding existed only if\n * some other module happened to import this one first.  Binding is the service\n * provider's job instead; see `providers/fedify_provider.ts`.\n *\n * On the dual build: this is the one module with state, so the classic\n * dual-package hazard applies — a process that loaded both the ESM and the\n * CommonJS copy would otherwise hold two builders, and dispatchers registered\n * on one would be silently missing from the `Federation` built from the other.\n * The singleton therefore lives in a `globalThis` slot under a registered\n * symbol, which every copy of this module resolves to the same object.\n *\n * @module\n */\nimport {\n  createFederationBuilder,\n  type FederationBuilder,\n} from \"@fedify/fedify\";\n\nimport type { ContextData } from \"./types.ts\";\n\n/**\n * The slot the singleton lives in, keyed by major version.\n *\n * Every copy of *this* package resolves the same key, which is the point — the\n * ESM and CommonJS builds have to agree.  A different major version of\n * `@fedify/adonisjs` hoisted into the same process gets a slot of its own\n * rather than inheriting dispatchers registered against another major's\n * `FederationBuilder`.\n */\nconst SLOT: unique symbol = Symbol.for(\"@fedify/adonisjs@2/builder\");\n\nconst registry = globalThis as { [SLOT]?: FederationBuilder<ContextData> };\n\n/**\n * The builder that dispatchers and inbox listeners are registered on.\n *\n * Prefer importing it through the `@fedify/adonisjs/services/builder` service\n * module, which is the path the generated stubs and the documentation use.\n */\nexport const builder: FederationBuilder<ContextData> = registry[SLOT] ??=\n  createFederationBuilder<ContextData>();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,MAAM,OAAsB,OAAO,IAAI,4BAA4B;AAEnE,MAAM,WAAW;;;;;;;AAQjB,MAAa,UAA0C,SAAS,UAC9D,wBAAqC"}

package/dist/src/define_config.cjs

@@ -0,0 +1,114 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _adonisjs_core = require("@adonisjs/core");
+let _adonisjs_core_exceptions = require("@adonisjs/core/exceptions");
+
+//#region src/define_config.ts
+/**
+* The `defineConfig` helper used by `config/fedify.ts`.
+*
+* @module
+*/
+/**
+* Whether the `queue` option carries a queue at all.
+*
+* `FederationOptions.queue` takes either one `MessageQueue` for every role or
+* an object of per-role queues, and Fedify reads an object whose members are
+* all `undefined` as no queue.  Testing the option's presence would therefore
+* misfire in both directions: `queue: { outbox: app.inProduction ? q :
+* undefined }` looks configured in development, and `queue: {}` looks like a
+* queue that needs draining.
+*/
+function hasQueue(queue) {
+	if (queue == null) return false;
+	if ("enqueue" in queue && "listen" in queue) return true;
+	return Object.values(queue).some((role) => role != null);
+}
+/**
+* Defines the Fedify configuration of an AdonisJS application.
+*
+* The return value is an AdonisJS *config provider* rather than a plain object,
+* which lets the resolution step reach the application instance — needed to
+* detect production mode and to log through the application's logger — while
+* `config/fedify.ts` itself stays a simple, synchronous, statically analysable
+* module.
+*
+* @example
+* ```ts
+* // config/fedify.ts
+* import { defineConfig } from '@fedify/adonisjs'
+* import { SqliteKvStore } from '@fedify/sqlite'
+* import env from '#start/env'
+*
+* export default defineConfig({
+*   origin: env.get('PUBLIC_URL'),
+*   kv: new SqliteKvStore(database),
+* })
+* ```
+*/
+function defineConfig(config) {
+	return _adonisjs_core.configProvider.create(async (app) => {
+		if (!config.origin) {
+			throw new _adonisjs_core_exceptions.InvalidArgumentsException("Missing \"origin\" in config/fedify.ts. It must be the canonical public URL of this server, " + "usually read from the PUBLIC_URL environment variable");
+		}
+		let kv = config.kv;
+		if (kv === undefined) {
+			const { MemoryKvStore } = await import("@fedify/fedify");
+			kv = new MemoryKvStore();
+			if (app.inProduction) {
+				const logger = await app.container.make("logger");
+				logger.warn("Fedify is using an in-memory key-value store in production. Inbox idempotency, " + "the document cache and outbox state will be lost on restart and cannot be shared " + "between processes. Configure \"kv\" in config/fedify.ts with a persistent store such " + "as @fedify/sqlite, @fedify/postgres or @fedify/redis");
+			}
+		}
+		const { contextDataFactory, ignoreRoutePrefixes, logging, queueContextData, ...federationOptions } = config;
+		/**
+		* A configured queue forces the "who drains it" decision to be explicit.
+		*
+		* Fedify's own default starts the queue lazily on the first enqueued task,
+		* capturing that request's context data and reusing it for every background
+		* job thereafter. For this integration the captured value would be a single
+		* stale `HttpContext`, whose request has long since finished. Rather than
+		* pick a wrong default, refuse to guess.
+		*/
+		if (hasQueue(federationOptions.queue) && queueContextData === undefined) {
+			throw new _adonisjs_core_exceptions.InvalidArgumentsException("config/fedify.ts configures a \"queue\" but not \"queueContextData\". Set " + "\"queueContextData\" to a callback to have this process drain the queue, or to " + "\"false\" when a separate worker process owns it");
+		}
+		/**
+		* The mirror image: a drainer for a queue that does not exist.  Nothing
+		* fails on its own — `startQueue()` resolves over no queues and
+		* `sendActivity()` delivers inline without retry, so failed deliveries are
+		* silently lost.
+		*
+		* Only a warning, because a task registered with
+		* `defineTask(name, { queue })` from a preload file brings its own queue,
+		* which this configuration cannot see.  Refusing would break a valid
+		* application, and dropping the callback would hand that queue back to
+		* Fedify's lazy start.  Only a *callback* is reported: `false` stays valid
+		* without a queue, so `queue: app.inProduction ? … : undefined` still
+		* boots in development and test.
+		*/
+		if (!hasQueue(federationOptions.queue) && typeof queueContextData === "function") {
+			const logger = await app.container.make("logger");
+			logger.warn("config/fedify.ts sets \"queueContextData\" but no \"queue\". Unless a task registers its own " + "queue through defineTask(), there is nothing to drain and activity delivery stays " + "inline, with failed deliveries never retried. Configure \"queue\" with a message queue " + "such as @fedify/sqlite, @fedify/postgres, @fedify/redis or @fedify/amqp, or remove " + "\"queueContextData\"");
+		}
+		return {
+			...federationOptions,
+			kv,
+			manuallyStartQueue: queueContextData !== undefined ? true : config.manuallyStartQueue,
+			/**
+			* The cast is sound because `ContextDataFactoryOption` makes
+			* `contextDataFactory` a *required* key the moment an application
+			* augments `FedifyTypes`.  This branch is therefore only reachable while
+			* `ContextData` still includes `HttpContext`, which is exactly what it
+			* returns.
+			*/
+			contextDataFactory: contextDataFactory ?? ((ctx) => ctx),
+			ignoreRoutePrefixes: ignoreRoutePrefixes ?? [],
+			logging: logging ?? true,
+			queueContextData
+		};
+	});
+}
+
+//#endregion
+exports.defineConfig = defineConfig;
+//# sourceMappingURL=define_config.cjs.map

package/dist/src/define_config.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"define_config.cjs","names":["configProvider","InvalidArgumentsException"],"sources":["../../src/define_config.ts"],"sourcesContent":["/**\n * The `defineConfig` helper used by `config/fedify.ts`.\n *\n * @module\n */\nimport { configProvider } from \"@adonisjs/core\";\nimport { InvalidArgumentsException } from \"@adonisjs/core/exceptions\";\nimport type { ConfigProvider } from \"@adonisjs/core/types\";\nimport type { FederationOptions } from \"@fedify/fedify\";\n\nimport type {\n  ContextData,\n  FedifyConfig,\n  ResolvedFedifyConfig,\n} from \"./types.ts\";\n\n/**\n * Whether the `queue` option carries a queue at all.\n *\n * `FederationOptions.queue` takes either one `MessageQueue` for every role or\n * an object of per-role queues, and Fedify reads an object whose members are\n * all `undefined` as no queue.  Testing the option's presence would therefore\n * misfire in both directions: `queue: { outbox: app.inProduction ? q :\n * undefined }` looks configured in development, and `queue: {}` looks like a\n * queue that needs draining.\n */\nfunction hasQueue(queue: FederationOptions<unknown>[\"queue\"]): boolean {\n  if (queue == null) return false;\n  if (\"enqueue\" in queue && \"listen\" in queue) return true;\n  return Object.values(queue).some((role) => role != null);\n}\n\n/**\n * Defines the Fedify configuration of an AdonisJS application.\n *\n * The return value is an AdonisJS *config provider* rather than a plain object,\n * which lets the resolution step reach the application instance — needed to\n * detect production mode and to log through the application's logger — while\n * `config/fedify.ts` itself stays a simple, synchronous, statically analysable\n * module.\n *\n * @example\n * ```ts\n * // config/fedify.ts\n * import { defineConfig } from '@fedify/adonisjs'\n * import { SqliteKvStore } from '@fedify/sqlite'\n * import env from '#start/env'\n *\n * export default defineConfig({\n *   origin: env.get('PUBLIC_URL'),\n *   kv: new SqliteKvStore(database),\n * })\n * ```\n */\nexport function defineConfig(\n  config: FedifyConfig,\n): ConfigProvider<ResolvedFedifyConfig> {\n  return configProvider.create<ResolvedFedifyConfig>(async (app) => {\n    if (!config.origin) {\n      throw new InvalidArgumentsException(\n        'Missing \"origin\" in config/fedify.ts. It must be the canonical public URL of this server, ' +\n          \"usually read from the PUBLIC_URL environment variable\",\n      );\n    }\n\n    let kv = config.kv;\n    if (kv === undefined) {\n      const { MemoryKvStore } = await import(\"@fedify/fedify\");\n      kv = new MemoryKvStore();\n\n      if (app.inProduction) {\n        // Not fatal — an application may genuinely run a single process and\n        // accept the trade-off — but silently losing inbox idempotency and the\n        // document cache on every restart is worth shouting about.\n        const logger = await app.container.make(\"logger\");\n        logger.warn(\n          \"Fedify is using an in-memory key-value store in production. Inbox idempotency, \" +\n            \"the document cache and outbox state will be lost on restart and cannot be shared \" +\n            'between processes. Configure \"kv\" in config/fedify.ts with a persistent store such ' +\n            \"as @fedify/sqlite, @fedify/postgres or @fedify/redis\",\n        );\n      }\n    }\n\n    const {\n      contextDataFactory,\n      ignoreRoutePrefixes,\n      logging,\n      queueContextData,\n      ...federationOptions\n    } = config;\n\n    /**\n     * A configured queue forces the \"who drains it\" decision to be explicit.\n     *\n     * Fedify's own default starts the queue lazily on the first enqueued task,\n     * capturing that request's context data and reusing it for every background\n     * job thereafter. For this integration the captured value would be a single\n     * stale `HttpContext`, whose request has long since finished. Rather than\n     * pick a wrong default, refuse to guess.\n     */\n    if (hasQueue(federationOptions.queue) && queueContextData === undefined) {\n      throw new InvalidArgumentsException(\n        'config/fedify.ts configures a \"queue\" but not \"queueContextData\". Set ' +\n          '\"queueContextData\" to a callback to have this process drain the queue, or to ' +\n          '\"false\" when a separate worker process owns it',\n      );\n    }\n\n    /**\n     * The mirror image: a drainer for a queue that does not exist.  Nothing\n     * fails on its own — `startQueue()` resolves over no queues and\n     * `sendActivity()` delivers inline without retry, so failed deliveries are\n     * silently lost.\n     *\n     * Only a warning, because a task registered with\n     * `defineTask(name, { queue })` from a preload file brings its own queue,\n     * which this configuration cannot see.  Refusing would break a valid\n     * application, and dropping the callback would hand that queue back to\n     * Fedify's lazy start.  Only a *callback* is reported: `false` stays valid\n     * without a queue, so `queue: app.inProduction ? … : undefined` still\n     * boots in development and test.\n     */\n    if (\n      !hasQueue(federationOptions.queue) &&\n      typeof queueContextData === \"function\"\n    ) {\n      const logger = await app.container.make(\"logger\");\n      logger.warn(\n        'config/fedify.ts sets \"queueContextData\" but no \"queue\". Unless a task registers its own ' +\n          \"queue through defineTask(), there is nothing to drain and activity delivery stays \" +\n          'inline, with failed deliveries never retried. Configure \"queue\" with a message queue ' +\n          \"such as @fedify/sqlite, @fedify/postgres, @fedify/redis or @fedify/amqp, or remove \" +\n          '\"queueContextData\"',\n      );\n    }\n\n    return {\n      ...federationOptions,\n      kv,\n\n      // The queue is always started deliberately — by this package's service\n      // provider, or by a separate worker — never lazily by Fedify.\n      manuallyStartQueue: queueContextData !== undefined\n        ? true\n        : config.manuallyStartQueue,\n\n      /**\n       * The cast is sound because `ContextDataFactoryOption` makes\n       * `contextDataFactory` a *required* key the moment an application\n       * augments `FedifyTypes`.  This branch is therefore only reachable while\n       * `ContextData` still includes `HttpContext`, which is exactly what it\n       * returns.\n       */\n      contextDataFactory: contextDataFactory ?? ((ctx) => ctx as ContextData),\n      ignoreRoutePrefixes: ignoreRoutePrefixes ?? [],\n      logging: logging ?? true,\n      queueContextData,\n    };\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA0BA,SAAS,SAAS,OAAqD;CACrE,IAAI,SAAS,MAAM,OAAO;CAC1B,IAAI,aAAa,SAAS,YAAY,OAAO,OAAO;CACpD,OAAO,OAAO,OAAO,KAAK,CAAC,CAAC,MAAM,SAAS,QAAQ,IAAI;AACzD;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,aACd,QACsC;CACtC,OAAOA,8BAAe,OAA6B,OAAO,QAAQ;EAChE,IAAI,CAAC,OAAO,QAAQ;GAClB,MAAM,IAAIC,oDACR,iGACE,uDACJ;EACF;EAEA,IAAI,KAAK,OAAO;EAChB,IAAI,OAAO,WAAW;GACpB,MAAM,EAAE,kBAAkB,MAAM,OAAO;GACvC,KAAK,IAAI,cAAc;GAEvB,IAAI,IAAI,cAAc;IAIpB,MAAM,SAAS,MAAM,IAAI,UAAU,KAAK,QAAQ;IAChD,OAAO,KACL,oFACE,sFACA,0FACA,sDACJ;GACF;EACF;EAEA,MAAM,EACJ,oBACA,qBACA,SACA,kBACA,GAAG,sBACD;;;;;;;;;;EAWJ,IAAI,SAAS,kBAAkB,KAAK,KAAK,qBAAqB,WAAW;GACvE,MAAM,IAAIA,oDACR,+EACE,oFACA,kDACJ;EACF;;;;;;;;;;;;;;;EAgBA,IACE,CAAC,SAAS,kBAAkB,KAAK,KACjC,OAAO,qBAAqB,YAC5B;GACA,MAAM,SAAS,MAAM,IAAI,UAAU,KAAK,QAAQ;GAChD,OAAO,KACL,kGACE,uFACA,4FACA,wFACA,sBACJ;EACF;EAEA,OAAO;GACL,GAAG;GACH;GAIA,oBAAoB,qBAAqB,YACrC,OACA,OAAO;;;;;;;;GASX,oBAAoB,wBAAwB,QAAQ;GACpD,qBAAqB,uBAAuB,CAAC;GAC7C,SAAS,WAAW;GACpB;EACF;CACF,CAAC;AACH"}