@fedify/adonisjs 2.4.0-dev.0

package/dist/src/unusable_authority.js

@@ -0,0 +1,76 @@
+//#region src/unusable_authority.ts
+/**
+* The host used when the request carries no usable authority.
+*
+* `FederationOptions.origin` covers the URLs Fedify *mints* — actor URIs,
+* activity IDs, collection URLs — so the placeholder never reaches a peer
+* through them, and only the path has to survive for routing.  It does not
+* cover verification: RFC 9421's `@authority`, `@target-uri` and `@scheme`
+* are derived from this URL, so a request signed over `@authority` fails to
+* verify while the placeholder stands in.  That is the cost of answering
+* instead of failing, and why the fallback is logged.
+*/
+const PLACEHOLDER_HOST = "localhost";
+/**
+* Unusable authorities already warned about in the current window.  Any
+* client can trigger the warning through `Host`, so each distinct value is
+* reported once and the set is capped, leaving neither it nor the log
+* unbounded.  The key is the whole value, since two hostile values can share
+* a 128-character prefix.
+*/
+const warnedAuthorities = new Set();
+/**
+* How many distinct values one window reports.
+*/
+const WARNED_AUTHORITIES_LIMIT = 16;
+/**
+* How long the cap holds before the budget starts over.
+*
+* Without a window the cap is spent for the life of the process, and the
+* values that spend it are the client's to choose: sixteen junk `Host`
+* headers would silence the warning for good, so a proxy misconfigured an
+* hour later—every request falling back to {@link PLACEHOLDER_HOST}, every
+* signature over `@authority` failing to verify—would never be reported.
+* Starting over bounds the log at {@link WARNED_AUTHORITIES_LIMIT} lines per
+* window instead of over all time, which is what the log has to be protected
+* from, and leaves a standing misconfiguration visible.
+*/
+const WARNED_AUTHORITIES_WINDOW_MS = 60 * 60 * 1e3;
+/**
+* When the current window began; `0` so the first warning opens one.  It
+* advances lazily, on the first warning after the window has elapsed, rather
+* than from a timer that would hold the event loop open on a quiet process.
+*/
+let warnedAuthoritiesWindowStart = 0;
+/**
+* Whether the cap has already been reported in this window.  Reaching it
+* silences every later distinct value, which should not happen invisibly.
+*/
+let warnedAuthoritiesCapReported = false;
+/**
+* Reports an authority the request URL could not be built from, once per
+* distinct value and window.
+*/
+function warnUnusableAuthority(logger, host) {
+	const now = Date.now();
+	if (now < warnedAuthoritiesWindowStart || now - warnedAuthoritiesWindowStart >= 36e5) {
+		warnedAuthoritiesWindowStart = now;
+		warnedAuthorities.clear();
+		warnedAuthoritiesCapReported = false;
+	}
+	if (warnedAuthorities.has(host)) return;
+	if (warnedAuthorities.size >= 16) {
+		if (warnedAuthoritiesCapReported) return;
+		warnedAuthoritiesCapReported = true;
+		logger.warn("Reached %d distinct unusable request authorities within %d minutes; " + "further distinct values are not reported until that window ends", 16, WARNED_AUTHORITIES_WINDOW_MS / 6e4);
+		return;
+	}
+	warnedAuthorities.add(host);
+	const points = Array.from(host);
+	const shown = points.length > 128 ? `${points.slice(0, 128).join("")}…` : host;
+	logger.warn("Unusable request authority \"%s\"; the URL Fedify sees falls back to " + "\"%s\", so signatures covering the authority will not verify. Behind a " + "proxy this is a misbehaving X-Forwarded-Host; otherwise a client sent " + "it directly. Each distinct value is reported once per %d minutes, up " + "to %d values in that window", shown, PLACEHOLDER_HOST, WARNED_AUTHORITIES_WINDOW_MS / 6e4, 16);
+}
+
+//#endregion
+export { PLACEHOLDER_HOST, WARNED_AUTHORITIES_WINDOW_MS, warnUnusableAuthority };
+//# sourceMappingURL=unusable_authority.js.map

package/dist/src/unusable_authority.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unusable_authority.js","names":[],"sources":["../../src/unusable_authority.ts"],"sourcesContent":["/**\n * The warning for a request whose authority cannot be used, and the budget\n * that keeps it from flooding the log.\n *\n * Internal to the package: this module is reachable through none of the\n * published subpaths.  The two constants are exported for the tests, which\n * have to spend exactly this budget.\n *\n * @module\n */\nimport type { HttpContext } from \"@adonisjs/core/http\";\n\n/**\n * The host used when the request carries no usable authority.\n *\n * `FederationOptions.origin` covers the URLs Fedify *mints* — actor URIs,\n * activity IDs, collection URLs — so the placeholder never reaches a peer\n * through them, and only the path has to survive for routing.  It does not\n * cover verification: RFC 9421's `@authority`, `@target-uri` and `@scheme`\n * are derived from this URL, so a request signed over `@authority` fails to\n * verify while the placeholder stands in.  That is the cost of answering\n * instead of failing, and why the fallback is logged.\n */\nexport const PLACEHOLDER_HOST: string = \"localhost\";\n\n/**\n * Unusable authorities already warned about in the current window.  Any\n * client can trigger the warning through `Host`, so each distinct value is\n * reported once and the set is capped, leaving neither it nor the log\n * unbounded.  The key is the whole value, since two hostile values can share\n * a 128-character prefix.\n */\nconst warnedAuthorities = new Set<string>();\n\n/**\n * How many distinct values one window reports.\n */\nexport const WARNED_AUTHORITIES_LIMIT: number = 16;\n\n/**\n * How long the cap holds before the budget starts over.\n *\n * Without a window the cap is spent for the life of the process, and the\n * values that spend it are the client's to choose: sixteen junk `Host`\n * headers would silence the warning for good, so a proxy misconfigured an\n * hour later—every request falling back to {@link PLACEHOLDER_HOST}, every\n * signature over `@authority` failing to verify—would never be reported.\n * Starting over bounds the log at {@link WARNED_AUTHORITIES_LIMIT} lines per\n * window instead of over all time, which is what the log has to be protected\n * from, and leaves a standing misconfiguration visible.\n */\nexport const WARNED_AUTHORITIES_WINDOW_MS: number = 60 * 60 * 1000;\n\n/**\n * When the current window began; `0` so the first warning opens one.  It\n * advances lazily, on the first warning after the window has elapsed, rather\n * than from a timer that would hold the event loop open on a quiet process.\n */\nlet warnedAuthoritiesWindowStart = 0;\n\n/**\n * Whether the cap has already been reported in this window.  Reaching it\n * silences every later distinct value, which should not happen invisibly.\n */\nlet warnedAuthoritiesCapReported = false;\n\n/**\n * Reports an authority the request URL could not be built from, once per\n * distinct value and window.\n */\nexport function warnUnusableAuthority(\n  logger: HttpContext[\"logger\"],\n  host: string,\n): void {\n  const now = Date.now();\n  // `<` as well as the elapsed check: a backwards clock step (an NTP\n  // correction) would otherwise freeze the window until real time caught up\n  // with a start that lies in the future.\n  if (\n    now < warnedAuthoritiesWindowStart ||\n    now - warnedAuthoritiesWindowStart >= WARNED_AUTHORITIES_WINDOW_MS\n  ) {\n    warnedAuthoritiesWindowStart = now;\n    warnedAuthorities.clear();\n    warnedAuthoritiesCapReported = false;\n  }\n\n  if (warnedAuthorities.has(host)) return;\n  if (warnedAuthorities.size >= WARNED_AUTHORITIES_LIMIT) {\n    if (warnedAuthoritiesCapReported) return;\n    warnedAuthoritiesCapReported = true;\n    logger.warn(\n      \"Reached %d distinct unusable request authorities within %d minutes; \" +\n        \"further distinct values are not reported until that window ends\",\n      WARNED_AUTHORITIES_LIMIT,\n      WARNED_AUTHORITIES_WINDOW_MS / 60_000,\n    );\n    return;\n  }\n  warnedAuthorities.add(host);\n  // By code point, so an emoji straddling the boundary cannot leave a lone\n  // surrogate in the key or the log line.\n  const points = Array.from(host);\n  const shown = points.length > 128\n    ? `${points.slice(0, 128).join(\"\")}…`\n    : host;\n  logger.warn(\n    'Unusable request authority \"%s\"; the URL Fedify sees falls back to ' +\n      '\"%s\", so signatures covering the authority will not verify. Behind a ' +\n      \"proxy this is a misbehaving X-Forwarded-Host; otherwise a client sent \" +\n      \"it directly. Each distinct value is reported once per %d minutes, up \" +\n      \"to %d values in that window\",\n    shown,\n    PLACEHOLDER_HOST,\n    WARNED_AUTHORITIES_WINDOW_MS / 60_000,\n    WARNED_AUTHORITIES_LIMIT,\n  );\n}\n"],"mappings":";;;;;;;;;;;;AAuBA,MAAa,mBAA2B;;;;;;;;AASxC,MAAM,oBAAoB,IAAI,IAAY;;;;AAK1C,MAAa,2BAAmC;;;;;;;;;;;;;AAchD,MAAa,+BAAuC,KAAK,KAAK;;;;;;AAO9D,IAAI,+BAA+B;;;;;AAMnC,IAAI,+BAA+B;;;;;AAMnC,SAAgB,sBACd,QACA,MACM;CACN,MAAM,MAAM,KAAK,IAAI;CAIrB,IACE,MAAM,gCACN,MAAM,sCACN;EACA,+BAA+B;EAC/B,kBAAkB,MAAM;EACxB,+BAA+B;CACjC;CAEA,IAAI,kBAAkB,IAAI,IAAI,GAAG;CACjC,IAAI,kBAAkB,YAAkC;EACtD,IAAI,8BAA8B;EAClC,+BAA+B;EAC/B,OAAO,KACL,yEACE,uEAEF,+BAA+B,GACjC;EACA;CACF;CACA,kBAAkB,IAAI,IAAI;CAG1B,MAAM,SAAS,MAAM,KAAK,IAAI;CAC9B,MAAM,QAAQ,OAAO,SAAS,MAC1B,GAAG,OAAO,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,KACjC;CACJ,OAAO,KACL,0EACE,4EACA,2EACA,0EACA,+BACF,OACA,kBACA,+BAA+B,OAEjC;AACF"}

package/dist/stubs/config/fedify.stub

@@ -0,0 +1,105 @@
+{{{
+  exports({ to: app.configPath('fedify.ts') })
+}}}
+import { defineConfig } from '@fedify/adonisjs'
+import env from '#start/env'
+
+/**
+ * The domain that fediverse handles live on, if it differs from the web origin.
+ * Leave FEDERATION_HANDLE_HOST unset when handles and pages share a domain.
+ */
+const handleHost = env.get('FEDERATION_HANDLE_HOST')
+
+export default defineConfig({
+  /**
+   * The canonical public origin of this server.
+   *
+   * Fedify builds actor URIs, activity IDs and collection URLs from this value,
+   * so it must be the address remote servers can reach. When developing behind
+   * "fedify tunnel" or ngrok, set PUBLIC_URL to the tunnel URL.
+   */
+  origin: handleHost
+    ? { handleHost, webOrigin: env.get('PUBLIC_URL') }
+    : env.get('PUBLIC_URL'),
+
+  /**
+   * Where Fedify caches remote documents, tracks inbox idempotency and keeps
+   * outbox state.
+   *
+   * Defaults to an in-memory store, which is fine for development but is lost
+   * on restart and cannot be shared between processes. Install one of
+   * "@fedify/sqlite", "@fedify/postgres", "@fedify/redis" or "@fedify/mysql"
+   * before going to production, then uncomment the lines below:
+   *
+   *     import { DatabaseSync } from 'node:sqlite'
+   *     import { SqliteKvStore, SqliteMessageQueue } from '@fedify/sqlite'
+   *     import app from '@adonisjs/core/services/app'
+   *
+   *     const database = new DatabaseSync(app.tmpPath('fedify.sqlite3'))
+   */
+  // kv: new SqliteKvStore(database),
+
+  /**
+   * The queue used to deliver outgoing activities and to process incoming ones.
+   *
+   * Without a queue, delivery happens inline: the request that triggered it
+   * blocks until every recipient server has answered, and a failed delivery is
+   * never retried. Production deployments should always configure one.
+   *
+   * A "queue" needs "queueContextData" below to say who drains it, and is
+   * refused at boot without it.
+   */
+  // queue: new SqliteMessageQueue(database),
+
+  /**
+   * Who drains the queue.
+   *
+   * A callback means this process does, and the context data it returns is what
+   * background jobs see -- there is no HTTP request behind them. Use "false"
+   * when a separate worker process owns the queue.
+   *
+   * A callback without a "queue" above is accepted with a warning: unless a
+   * task registers its own queue through defineTask(), there is nothing to
+   * drain. "false" is accepted either way, since "this process does not drain
+   * the queue" stays true when there is none -- which is what enabling the
+   * queue in production only needs:
+   *
+   *     queue: app.inProduction ? new SqliteMessageQueue(database) : undefined,
+   *     queueContextData: app.inProduction ? () => null : false,
+   */
+  // queueContextData: () => null,
+
+  /**
+   * URL path prefixes that skip Fedify entirely.
+   *
+   * A pure performance escape hatch for paths that can never be federation
+   * endpoints. Accessing "ctx.federation" on such a request throws.
+   */
+  ignoreRoutePrefixes: ['/@vite/', '/resources/', '/node_modules/'],
+})
+
+/**
+ * The value Fedify threads through every dispatcher and inbox listener as
+ * "ctx.data".
+ *
+ * It defaults to "HttpContext | null" -- null when Fedify is working outside a
+ * request, such as in a queue worker. Augment it here to carry something more
+ * specific, and set "contextDataFactory" above to build it -- the option becomes
+ * required once you do:
+ *
+ *     declare module '@fedify/adonisjs/types' {
+ *       interface FedifyTypes {
+ *         contextData: { requestId: string | undefined }
+ *       }
+ *     }
+ *
+ *     contextDataFactory: (ctx) => ({ requestId: ctx.request.id() }),
+ *
+ * The factory runs in the server middleware stack, before route matching and
+ * before every router middleware, so only "ctx.request", "ctx.response",
+ * "ctx.logger" and "ctx.containerResolver" are available to it. "ctx.auth",
+ * "ctx.session", "ctx.bouncer", "ctx.params" and "ctx.route" are still
+ * undefined there ("ctx.params" is "{}"). Look users up inside the
+ * dispatcher that needs them instead -- a federation request comes from a
+ * remote server and has no session behind it.
+ */

package/dist/stubs/federation/main.stub

@@ -0,0 +1,64 @@
+{{{
+  exports({ to: app.makePath('app/federation/main.ts') })
+}}}
+/*
+|--------------------------------------------------------------------------
+| Federation dispatchers
+|--------------------------------------------------------------------------
+|
+| Registered on the Fedify builder while the application boots, from the
+| "start/federation.ts" preload file.
+|
+| Registration happens exactly once per process. Do not add this directory
+| to "hotHook.boundaries" in package.json: re-importing the module on a hot
+| reload would register the same dispatcher twice and Fedify would throw.
+| Restart the dev server after changing a dispatcher.
+|
+| See https://fedify.dev/manual/actor and https://fedify.dev/manual/inbox
+|
+*/
+
+import federation from '@fedify/adonisjs/services/builder'
+import { Endpoints, Person } from '@fedify/vocab'
+
+/**
+ * Serves the actor document at "/actors/<identifier>", and -- through the key
+ * pairs dispatcher -- the keys that sign this actor's outgoing activities.
+ */
+federation
+  .setActorDispatcher('/actors/{identifier}', async (ctx, identifier) => {
+    // Look the actor up in your database and return null when it is unknown.
+    if (identifier !== 'me') return null
+
+    const keys = await ctx.getActorKeyPairs(identifier)
+
+    return new Person({
+      id: ctx.getActorUri(identifier),
+      preferredUsername: identifier,
+      name: 'Me',
+      inbox: ctx.getInboxUri(identifier),
+      endpoints: new Endpoints({ sharedInbox: ctx.getInboxUri() }),
+      url: new URL('/', ctx.url),
+
+      // Two keys, two purposes: the RSA key signs HTTP Signatures (what
+      // Mastodon verifies), the Ed25519 key signs Object Integrity Proofs.
+      publicKeys: keys.map((keyPair) => keyPair.cryptographicKey),
+      assertionMethods: keys.map((keyPair) => keyPair.multikey),
+    })
+  })
+  .setKeyPairsDispatcher(async (_ctx, _identifier) => {
+    // Load the actor's key pairs from your database, generating and persisting
+    // them the first time. Private keys are secrets: never log them, never
+    // expose them through an endpoint.
+    //
+    // See https://fedify.dev/manual/actor#public-keys-of-an-actor
+    return []
+  })
+
+/**
+ * Receives activities from other servers.
+ *
+ * The second path is the shared inbox, which servers use to deliver one
+ * activity destined for many local actors.
+ */
+federation.setInboxListeners('/actors/{identifier}/inbox', '/inbox')

package/dist/stubs/main.cjs

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let node_path = require("node:path");
+let node_url = require("node:url");
+
+//#region stubs/main.ts
+/**
+* The root of the stub templates shipped with this package.
+*
+* Used by `configure.ts` and by `node ace eject <stub> --pkg=@fedify/adonisjs`
+* when an application wants to customise a generated file.
+*/
+const stubsRoot = (0, node_path.dirname)((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+
+//#endregion
+exports.stubsRoot = stubsRoot;
+//# sourceMappingURL=main.cjs.map

package/dist/stubs/main.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.cjs","names":[],"sources":["../../stubs/main.ts"],"sourcesContent":["import { dirname } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\n/**\n * The root of the stub templates shipped with this package.\n *\n * Used by `configure.ts` and by `node ace eject <stub> --pkg=@fedify/adonisjs`\n * when an application wants to customise a generated file.\n */\nexport const stubsRoot: string = dirname(fileURLToPath(import.meta.url));\n"],"mappings":";;;;;;;;;;;AASA,MAAa,4GAAyD,CAAC"}

package/dist/stubs/main.d.cts

@@ -0,0 +1,11 @@
+//#region stubs/main.d.ts
+/**
+* The root of the stub templates shipped with this package.
+*
+* Used by `configure.ts` and by `node ace eject <stub> --pkg=@fedify/adonisjs`
+* when an application wants to customise a generated file.
+*/
+declare const stubsRoot: string;
+//#endregion
+export { stubsRoot };
+//# sourceMappingURL=main.d.cts.map

package/dist/stubs/main.d.ts

@@ -0,0 +1,11 @@
+//#region stubs/main.d.ts
+/**
+* The root of the stub templates shipped with this package.
+*
+* Used by `configure.ts` and by `node ace eject <stub> --pkg=@fedify/adonisjs`
+* when an application wants to customise a generated file.
+*/
+declare const stubsRoot: string;
+//#endregion
+export { stubsRoot };
+//# sourceMappingURL=main.d.ts.map

package/dist/stubs/main.js

@@ -0,0 +1,15 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region stubs/main.ts
+/**
+* The root of the stub templates shipped with this package.
+*
+* Used by `configure.ts` and by `node ace eject <stub> --pkg=@fedify/adonisjs`
+* when an application wants to customise a generated file.
+*/
+const stubsRoot = dirname(fileURLToPath(import.meta.url));
+
+//#endregion
+export { stubsRoot };
+//# sourceMappingURL=main.js.map

package/dist/stubs/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","names":[],"sources":["../../stubs/main.ts"],"sourcesContent":["import { dirname } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\n/**\n * The root of the stub templates shipped with this package.\n *\n * Used by `configure.ts` and by `node ace eject <stub> --pkg=@fedify/adonisjs`\n * when an application wants to customise a generated file.\n */\nexport const stubsRoot: string = dirname(fileURLToPath(import.meta.url));\n"],"mappings":";;;;;;;;;;AASA,MAAa,YAAoB,QAAQ,cAAc,OAAO,KAAK,GAAG,CAAC"}

package/dist/stubs/start/federation.stub

@@ -0,0 +1,20 @@
+{{{
+  exports({ to: app.makePath('start/federation.ts') })
+}}}
+/*
+|--------------------------------------------------------------------------
+| Federation preload file
+|--------------------------------------------------------------------------
+|
+| Imported while the application boots, after every service provider has
+| booted and before the HTTP server starts accepting connections. This is
+| where Fedify's actor dispatchers, collection dispatchers and inbox
+| listeners get registered.
+|
+| Import each of your federation modules here. They register themselves on
+| the builder exported by "@fedify/adonisjs/services/builder", and the
+| builder is sealed into a Federation object once this file has run.
+|
+*/
+
+import '../app/federation/main.js'

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "@fedify/adonisjs",
+  "version": "2.4.0-dev.0",
+  "description": "Integration package for Fedify with AdonisJS",
+  "keywords": [
+    "Fedify",
+    "Federation",
+    "ActivityPub",
+    "AdonisJS",
+    "fediverse"
+  ],
+  "author": {
+    "name": "scammo",
+    "email": "pfannkuchensack.ae@gmail.com"
+  },
+  "homepage": "https://fedify.dev/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fedify-dev/fedify.git",
+    "directory": "packages/adonisjs"
+  },
+  "bugs": {
+    "url": "https://github.com/fedify-dev/fedify/issues"
+  },
+  "funding": [
+    "https://opencollective.com/fedify",
+    "https://github.com/sponsors/dahlia"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts",
+        "default": "./dist/index.d.ts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./types": {
+      "types": {
+        "import": "./dist/src/types.d.ts",
+        "require": "./dist/src/types.d.cts",
+        "default": "./dist/src/types.d.ts"
+      },
+      "import": "./dist/src/types.js",
+      "require": "./dist/src/types.cjs",
+      "default": "./dist/src/types.js"
+    },
+    "./fedify_provider": {
+      "types": {
+        "import": "./dist/providers/fedify_provider.d.ts",
+        "require": "./dist/providers/fedify_provider.d.cts",
+        "default": "./dist/providers/fedify_provider.d.ts"
+      },
+      "import": "./dist/providers/fedify_provider.js",
+      "require": "./dist/providers/fedify_provider.cjs",
+      "default": "./dist/providers/fedify_provider.js"
+    },
+    "./fedify_middleware": {
+      "types": {
+        "import": "./dist/src/fedify_middleware.d.ts",
+        "require": "./dist/src/fedify_middleware.d.cts",
+        "default": "./dist/src/fedify_middleware.d.ts"
+      },
+      "import": "./dist/src/fedify_middleware.js",
+      "require": "./dist/src/fedify_middleware.cjs",
+      "default": "./dist/src/fedify_middleware.js"
+    },
+    "./services/builder": {
+      "types": {
+        "import": "./dist/services/builder.d.ts",
+        "require": "./dist/services/builder.d.cts",
+        "default": "./dist/services/builder.d.ts"
+      },
+      "import": "./dist/services/builder.js",
+      "require": "./dist/services/builder.cjs",
+      "default": "./dist/services/builder.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "package.json"
+  ],
+  "peerDependencies": {
+    "@adonisjs/assembler": "^8.0.0",
+    "@adonisjs/core": "^7.4.0",
+    "@fedify/fedify": "^2.4.0"
+  },
+  "peerDependenciesMeta": {
+    "@adonisjs/assembler": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@logtape/logtape": "^2.2.0"
+  },
+  "devDependencies": {
+    "@adonisjs/assembler": "^8.0.0",
+    "@adonisjs/core": "^7.4.0",
+    "@types/node": "^22.17.0",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.0",
+    "@fedify/fedify": "^2.4.0",
+    "@fedify/vocab": "^2.4.0"
+  },
+  "scripts": {
+    "build:self": "tsdown",
+    "build": "pnpm --filter @fedify/adonisjs... run build:self",
+    "prepublish": "pnpm build",
+    "pretest": "pnpm run build:self",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test \"src/**/*.test.ts\""
+  }
+}