@sjohansson/astro-plausible 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stefan Johansson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,203 @@
-# Temporary Holding Version
+# Astro Plausible
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+First-party [Plausible](https://plausible.io) analytics for Astro sites.
+
+- The official Plausible tracker (the `@plausible-analytics/tracker` package) is bundled into your site's own
+  JavaScript. There is no third-party script tag for a blocker to recognise.
+- Events go to `/api/event` on your own domain. A small relay there forwards them to Plausible with the visitor's
+  IP and user agent. Plausible drops events that arrive without a real visitor IP, so the relay is not optional.
+- `astro-plausible init` writes that relay for Azure Static Web Apps. On other hosts it is a few lines around
+  `createRelay()`.
+
+## Installation
+
+```bash
+pnpm add @sjohansson/astro-plausible
+```
+
+## Usage
+
+### 1. Add the integration
+
+```js
+// astro.config.mjs
+import { defineConfig } from "astro/config";
+import plausible from "@sjohansson/astro-plausible/integration";
+
+export default defineConfig({
+  integrations: [plausible({ domain: "example.com" })],
+});
+```
+
+It adds one script to every page that starts the tracker. Options:
+
+| Option                 | Default        | Notes                                                                     |
+| ---------------------- | -------------- | ------------------------------------------------------------------------- |
+| `domain`               |                | Required. The site domain as entered in Plausible.                        |
+| `endpoint`             | `"/api/event"` | Where events go. Set `https://plausible.io/api/event` to skip the relay. |
+| `enabled`              |                | Defaults to on for `astro build` and off for `astro dev`.                 |
+| `autoCapturePageviews` | `true`         | Send a pageview on load and on history navigation.                        |
+| `hashBasedRouting`     | `false`        | Track `#` paths as separate pages.                                        |
+| `outboundLinks`        | `false`        | Track clicks on links to other sites.                                     |
+| `fileDownloads`        | `false`        | `true` for Plausible's default file types, or `{ fileExtensions: [...] }`. |
+| `formSubmissions`      | `false`        | Track form submissions.                                                   |
+| `captureOnLocalhost`   | `false`        | Also track on localhost.                                                  |
+| `logging`              | `true`         | Log ignored events to the console.                                        |
+| `customProperties`     |                | Custom properties added to every event.                                   |
+| `bindToWindow`         | `true`         | Expose `window.plausible`. Plausible's installation check looks for it.   |
+
+### 2. Add the relay
+
+#### Azure Static Web Apps
+
+```bash
+pnpm exec astro-plausible init --domain example.com
+```
+
+This writes `api/event/index.mjs` and `api/event/function.json`, plus `api/host.json` and `api/package.json` when
+they are missing. The function is one file with no imports, so the `api/` folder has no dependencies and the deploy
+can skip the API build. Commit the files. Re-run the command after upgrading the package; it rewrites the function
+and leaves the other files alone.
+
+Deploy settings:
+
+```json
+// public/staticwebapp.config.json
+{ "platform": { "apiRuntime": "node:22" } }
+```
+
+```yaml
+# The deploy step
+- uses: Azure/static-web-apps-deploy@v1
+  with:
+    app_location: "dist"
+    api_location: "api"
+    skip_app_build: true
+    skip_api_build: true
+```
+
+CLI options:
+
+```text
+--target <name>      Hosting target. "swa" is the only one today.
+--domain <domain>    Site domain as entered in Plausible (or PLAUSIBLE_DOMAIN). Repeat it for several sites.
+--upstream <url>     Plausible host, default https://plausible.io. Self-hosted: https://plausible.example.com
+--dir <path>         API folder, default "api"
+--rule <spec>        Validate a custom event: <event>:<property>=<regex>. Repeatable.
+--max-body <bytes>   Reject bodies larger than this, default 16384
+--dry-run            Print the files instead of writing them
+```
+
+#### Other hosts
+
+The relay works on the web standard `Request` and `Response`. Give it the visitor IP when the platform provides one;
+otherwise it reads the usual headers (`x-azure-clientip`, `cf-connecting-ip`, `x-real-ip`, `x-forwarded-for`, and
+so on).
+
+```ts
+// src/pages/api/event.ts, an Astro server endpoint
+import { createRelay } from "@sjohansson/astro-plausible/relay";
+import type { APIRoute } from "astro";
+
+export const prerender = false;
+
+const relay = createRelay({ domain: "example.com" });
+
+export const POST: APIRoute = ({ request, clientAddress }) => relay.handle(request, { clientIp: clientAddress });
+```
+
+```ts
+// functions/api/event.ts, a Cloudflare Pages function
+import { createRelay } from "@sjohansson/astro-plausible/relay";
+
+const relay = createRelay({ domain: "example.com" });
+
+export const onRequestPost = ({ request }) => relay.handle(request);
+```
+
+Relay options:
+
+| Option          | Default                  | Notes                                                                     |
+| --------------- | ------------------------ | ------------------------------------------------------------------------- |
+| `domain`        |                          | Required. One domain or several. Events for other domains get a 400.      |
+| `upstream`      | `"https://plausible.io"` | Events are posted to `<upstream>/api/event`.                              |
+| `maxBodyLength` | `16384`                  | Largest request body accepted, in bytes.                                  |
+| `events`        |                          | Validation for custom events, see below.                                  |
+| `onError`       |                          | Called when Plausible cannot be reached. The response is a 502 either way. |
+
+The relay answers 405 for anything but POST, 413 for a body over the limit, 400 for anything it will not forward,
+and otherwise passes Plausible's status and body through. The visitor IP goes in `X-Forwarded-For`.
+
+### Validating custom events
+
+If you build anything on custom events, say vote counts, the relay can make sure only well-formed ones get through.
+A rule lists the properties an event may carry and a pattern for each. Events with a rule are forwarded only with
+those properties, each matching its pattern. Events without a rule pass through untouched.
+
+```ts
+import { voteRelayRule } from "@sjohansson/astro-votes";
+
+const relay = createRelay({
+  domain: "example.com",
+  events: {
+    ...voteRelayRule(),
+    signup: { plan: /^(free|pro)$/ },
+  },
+});
+```
+
+The same for the CLI:
+
+```bash
+pnpm exec astro-plausible init --domain example.com \
+  --rule "vote:vote=^[A-Za-z0-9._/-]{1,200}:(?:up|down)(?:-undo)?$" \
+  --rule "signup:plan=^(free|pro)$"
+```
+
+### Tracking events
+
+`window.plausible("signup")` works as in any Plausible setup. The typed way is the tracker's own `track`:
+
+```ts
+import { track } from "@sjohansson/astro-plausible/client";
+
+track("signup", { props: { plan: "pro" } });
+```
+
+### Without the integration
+
+Start the tracker yourself when you want a function for `customProperties`, a `transformRequest` hook, or control
+over where it runs.
+
+```ts
+import { startPlausible } from "@sjohansson/astro-plausible/client";
+
+startPlausible({
+  domain: "example.com",
+  transformRequest: (payload) => (payload.u.includes("/admin") ? null : payload),
+});
+```
+
+The first call wins; later calls do nothing. The tracker itself allows a single `init()`.
+
+### A path other than `/api/event`
+
+Set `endpoint` to wherever the relay answers, for example `/stats/api/event`. Static Web Apps managed functions
+always live under `/api`; a rewrite from another path to `/api/event` in `staticwebapp.config.json` may do it, but
+that is untested and the Static Web Apps documentation says route rules for the API only support redirects and
+roles.
+
+### Local development
+
+The integration leaves the tracker out of `astro dev`, and the tracker ignores localhost unless
+`captureOnLocalhost` is set. To test the whole chain locally, set both and run the site through something that
+serves the relay too, such as the Static Web Apps CLI.
+
+## Keeping the tracker current
+
+The tracker is a normal dependency, so Renovate or a routine upgrade brings new Plausible releases to your site.
+Nothing is vendored.
+
+## License
+
+MIT

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/bin.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+import { DEFAULT_MAX_BODY_LENGTH, DEFAULT_UPSTREAM } from "./relay.js";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+//#region src/cli.ts
+/**
+* astro-plausible - writes the relay that forwards tracker events to Plausible.
+*
+* Static Web Apps managed functions must be real files in the repo, and nothing in node_modules is picked up, so
+* the relay is written out as one self-contained file. Re-run the command to update it after a package upgrade.
+*/
+const HELP = `Usage: astro-plausible init [options]
+
+Writes a relay function that forwards Plausible tracker events from your domain to Plausible.
+
+Options:
+  --target <name>      Hosting target. "swa" (Azure Static Web Apps managed functions) is the only one today.
+  --domain <domain>    Site domain as entered in Plausible (or PLAUSIBLE_DOMAIN). Repeat it for several sites.
+  --upstream <url>     Plausible host, default ${DEFAULT_UPSTREAM}. Self-hosted: https://plausible.example.com
+  --dir <path>         API folder, default "api"
+  --rule <spec>        Validate a custom event: <event>:<property>=<regex>. Repeatable. Events with a rule are
+                       forwarded only with the listed properties, each matching its pattern.
+  --max-body <bytes>   Reject bodies larger than this, default ${DEFAULT_MAX_BODY_LENGTH}
+  --dry-run            Print the files instead of writing them
+  -h, --help           Show this help
+
+Writes <dir>/event/index.mjs and <dir>/event/function.json every time, and <dir>/host.json and <dir>/package.json
+when they are missing. Deploy with api_location set to <dir>.
+`;
+const CONFIG_PLACEHOLDER = "__ASTRO_PLAUSIBLE_RELAY_CONFIG__";
+const RULE_PATTERN = /^([\w.-]+):([\w.-]+)=(.+)$/s;
+/** Parses `<event>:<property>=<regex>` specs into relay rules. Throws on a bad spec or pattern. */
+function parseRules(specs) {
+	const events = {};
+	for (const spec of specs) {
+		const match = spec.match(RULE_PATTERN);
+		if (!match) throw new Error(`--rule must look like <event>:<property>=<regex>, got "${spec}"`);
+		const [, event = "", property = "", pattern = ""] = match;
+		try {
+			new RegExp(pattern);
+		} catch (error) {
+			throw new Error(`--rule pattern for ${event}:${property} is not a valid regex: ${error}`);
+		}
+		events[event] = {
+			...events[event],
+			[property]: pattern
+		};
+	}
+	return events;
+}
+/** The files `init --target swa` produces for a relay config. */
+function swaFiles(template, config, dir, context) {
+	if (!template.includes(CONFIG_PLACEHOLDER)) throw new Error("The relay template is missing its config placeholder.");
+	const banner = [
+		`// Written by astro-plausible init (@sjohansson/astro-plausible ${context.version}) on ${context.now.toISOString().slice(0, 10)}.`,
+		"// Forwards Plausible tracker events to Plausible so the tracker runs first party and is not dropped by ad blockers.",
+		"// Do not edit: re-run the command to change the config or pick up a new package version.",
+		""
+	].join("\n");
+	const code = template.replace(/^\/\/# sourceMappingURL=.*$/m, "").replaceAll(CONFIG_PLACEHOLDER, JSON.stringify(config, null, 2)).trimEnd();
+	return [
+		{
+			path: join(dir, "event", "index.mjs"),
+			content: `${banner}${code}\n`,
+			keepExisting: false
+		},
+		{
+			path: join(dir, "event", "function.json"),
+			content: `${JSON.stringify({
+				scriptFile: "index.mjs",
+				entryPoint: "default",
+				bindings: [{
+					authLevel: "anonymous",
+					type: "httpTrigger",
+					direction: "in",
+					name: "req",
+					methods: ["post"]
+				}, {
+					type: "http",
+					direction: "out",
+					name: "res"
+				}]
+			}, null, 2)}\n`,
+			keepExisting: false
+		},
+		{
+			path: join(dir, "host.json"),
+			content: "{\n  \"version\": \"2.0\"\n}\n",
+			keepExisting: true
+		},
+		{
+			path: join(dir, "package.json"),
+			content: `${JSON.stringify({
+				name: "site-api",
+				private: true,
+				description: "Static Web Apps managed functions. No dependencies on purpose, so the deploy skips the API build."
+			}, null, 2)}\n`,
+			keepExisting: true
+		}
+	];
+}
+async function exists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function packageVersion() {
+	try {
+		const pkg = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+		return typeof pkg.version === "string" ? pkg.version : "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+async function main(argv, env, context = {}) {
+	const { values, positionals } = parseArgs({
+		args: argv,
+		allowPositionals: true,
+		options: {
+			target: { type: "string" },
+			domain: {
+				type: "string",
+				multiple: true
+			},
+			upstream: { type: "string" },
+			dir: { type: "string" },
+			rule: {
+				type: "string",
+				multiple: true
+			},
+			"max-body": { type: "string" },
+			"dry-run": { type: "boolean" },
+			help: {
+				type: "boolean",
+				short: "h"
+			}
+		}
+	});
+	if (values.help || positionals.length === 0) {
+		process.stdout.write(HELP);
+		return values.help ? 0 : 1;
+	}
+	if (positionals[0] !== "init") return fail(`Unknown command "${positionals[0]}". Only "init" exists.`);
+	const target = values.target ?? "swa";
+	if (target !== "swa") return fail(`Unknown target "${target}". Only "swa" exists.`);
+	const domains = values.domain ?? (env["PLAUSIBLE_DOMAIN"] ? [env["PLAUSIBLE_DOMAIN"]] : []);
+	if (domains.length === 0) return fail("No domain. Pass --domain or set PLAUSIBLE_DOMAIN.");
+	const maxBodyLength = values["max-body"] === void 0 ? void 0 : Number(values["max-body"]);
+	if (maxBodyLength !== void 0 && !(Number.isInteger(maxBodyLength) && maxBodyLength > 0)) return fail(`--max-body must be a positive whole number, got "${values["max-body"]}".`);
+	let events;
+	try {
+		events = parseRules(values.rule ?? []);
+	} catch (error) {
+		return fail(error instanceof Error ? error.message : String(error));
+	}
+	const config = {
+		domain: domains.length === 1 ? domains[0] : domains,
+		...values.upstream ? { upstream: values.upstream } : {},
+		...maxBodyLength ? { maxBodyLength } : {},
+		...Object.keys(events).length > 0 ? { events } : {}
+	};
+	const templateDir = context.templateDir ?? new URL("./templates/", import.meta.url);
+	const files = swaFiles(await readFile(new URL("swa.mjs", templateDir), "utf8"), config, values.dir ?? "api", {
+		version: context.version ?? await packageVersion(),
+		now: context.now ?? /* @__PURE__ */ new Date()
+	});
+	for (const file of files) {
+		if (values["dry-run"]) {
+			process.stdout.write(`--- ${file.path}\n${file.content}\n`);
+			continue;
+		}
+		const present = await exists(file.path);
+		if (present && file.keepExisting) {
+			process.stdout.write(`kept     ${file.path}\n`);
+			continue;
+		}
+		await mkdir(join(file.path, ".."), { recursive: true });
+		await writeFile(file.path, file.content);
+		process.stdout.write(`${present ? "updated" : "created"}  ${file.path}\n`);
+	}
+	return 0;
+}
+function fail(message) {
+	process.stderr.write(`astro-plausible: ${message}\n`);
+	return 1;
+}
+//#endregion
+//#region src/bin.ts
+main(process.argv.slice(2), process.env).then((code) => {
+	process.exitCode = code;
+}, (error) => {
+	process.exitCode = fail(error instanceof Error ? error.message : String(error));
+});
+//#endregion
+
+//# sourceMappingURL=bin.js.map

package/dist/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","names":[],"sources":["../src/cli.ts","../src/bin.ts"],"sourcesContent":["/**\n * astro-plausible - writes the relay that forwards tracker events to Plausible.\n *\n * Static Web Apps managed functions must be real files in the repo, and nothing in node_modules is picked up, so\n * the relay is written out as one self-contained file. Re-run the command to update it after a package upgrade.\n */\nimport { access, mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { parseArgs } from \"node:util\";\nimport { DEFAULT_MAX_BODY_LENGTH, DEFAULT_UPSTREAM, type RelayOptions, type RelayRule } from \"./relay\";\n\nconst HELP = `Usage: astro-plausible init [options]\n\nWrites a relay function that forwards Plausible tracker events from your domain to Plausible.\n\nOptions:\n  --target <name>      Hosting target. \"swa\" (Azure Static Web Apps managed functions) is the only one today.\n  --domain <domain>    Site domain as entered in Plausible (or PLAUSIBLE_DOMAIN). Repeat it for several sites.\n  --upstream <url>     Plausible host, default ${DEFAULT_UPSTREAM}. Self-hosted: https://plausible.example.com\n  --dir <path>         API folder, default \"api\"\n  --rule <spec>        Validate a custom event: <event>:<property>=<regex>. Repeatable. Events with a rule are\n                       forwarded only with the listed properties, each matching its pattern.\n  --max-body <bytes>   Reject bodies larger than this, default ${DEFAULT_MAX_BODY_LENGTH}\n  --dry-run            Print the files instead of writing them\n  -h, --help           Show this help\n\nWrites <dir>/event/index.mjs and <dir>/event/function.json every time, and <dir>/host.json and <dir>/package.json\nwhen they are missing. Deploy with api_location set to <dir>.\n`;\n\nconst CONFIG_PLACEHOLDER = \"__ASTRO_PLAUSIBLE_RELAY_CONFIG__\";\nconst RULE_PATTERN = /^([\\w.-]+):([\\w.-]+)=(.+)$/s;\n\nexport interface CliContext {\n  /** Where the built templates live, as a directory URL. Defaults to the package's own dist/templates. */\n  templateDir?: URL;\n  version?: string;\n  now?: Date;\n}\n\nexport interface ScaffoldFile {\n  path: string;\n  content: string;\n  /** Written only when the file does not exist yet. */\n  keepExisting: boolean;\n}\n\n/** Parses `<event>:<property>=<regex>` specs into relay rules. Throws on a bad spec or pattern. */\nexport function parseRules(specs: string[]): Record<string, RelayRule> {\n  const events: Record<string, RelayRule> = {};\n  for (const spec of specs) {\n    const match = spec.match(RULE_PATTERN);\n    if (!match) throw new Error(`--rule must look like <event>:<property>=<regex>, got \"${spec}\"`);\n    const [, event = \"\", property = \"\", pattern = \"\"] = match;\n    try {\n      new RegExp(pattern);\n    } catch (error) {\n      throw new Error(`--rule pattern for ${event}:${property} is not a valid regex: ${error}`);\n    }\n    events[event] = { ...events[event], [property]: pattern };\n  }\n  return events;\n}\n\n/** The files `init --target swa` produces for a relay config. */\nexport function swaFiles(\n  template: string,\n  config: RelayOptions,\n  dir: string,\n  context: Required<Pick<CliContext, \"version\" | \"now\">>,\n): ScaffoldFile[] {\n  if (!template.includes(CONFIG_PLACEHOLDER)) throw new Error(\"The relay template is missing its config placeholder.\");\n  const banner = [\n    `// Written by astro-plausible init (@sjohansson/astro-plausible ${context.version}) on ${context.now.toISOString().slice(0, 10)}.`,\n    \"// Forwards Plausible tracker events to Plausible so the tracker runs first party and is not dropped by ad blockers.\",\n    \"// Do not edit: re-run the command to change the config or pick up a new package version.\",\n    \"\",\n  ].join(\"\\n\");\n  const code = template\n    .replace(/^\\/\\/# sourceMappingURL=.*$/m, \"\")\n    .replaceAll(CONFIG_PLACEHOLDER, JSON.stringify(config, null, 2))\n    .trimEnd();\n\n  const functionJson = {\n    scriptFile: \"index.mjs\",\n    entryPoint: \"default\",\n    bindings: [\n      { authLevel: \"anonymous\", type: \"httpTrigger\", direction: \"in\", name: \"req\", methods: [\"post\"] },\n      { type: \"http\", direction: \"out\", name: \"res\" },\n    ],\n  };\n  const packageJson = {\n    name: \"site-api\",\n    private: true,\n    description: \"Static Web Apps managed functions. No dependencies on purpose, so the deploy skips the API build.\",\n  };\n\n  return [\n    { path: join(dir, \"event\", \"index.mjs\"), content: `${banner}${code}\\n`, keepExisting: false },\n    {\n      path: join(dir, \"event\", \"function.json\"),\n      content: `${JSON.stringify(functionJson, null, 2)}\\n`,\n      keepExisting: false,\n    },\n    { path: join(dir, \"host.json\"), content: '{\\n  \"version\": \"2.0\"\\n}\\n', keepExisting: true },\n    { path: join(dir, \"package.json\"), content: `${JSON.stringify(packageJson, null, 2)}\\n`, keepExisting: true },\n  ];\n}\n\nasync function exists(path: string): Promise<boolean> {\n  try {\n    await access(path);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function packageVersion(): Promise<string> {\n  try {\n    const pkg = JSON.parse(await readFile(new URL(\"../package.json\", import.meta.url), \"utf8\"));\n    return typeof pkg.version === \"string\" ? pkg.version : \"unknown\";\n  } catch {\n    return \"unknown\";\n  }\n}\n\nexport async function main(\n  argv: string[],\n  env: Record<string, string | undefined>,\n  context: CliContext = {},\n): Promise<number> {\n  const { values, positionals } = parseArgs({\n    args: argv,\n    allowPositionals: true,\n    options: {\n      target: { type: \"string\" },\n      domain: { type: \"string\", multiple: true },\n      upstream: { type: \"string\" },\n      dir: { type: \"string\" },\n      rule: { type: \"string\", multiple: true },\n      \"max-body\": { type: \"string\" },\n      \"dry-run\": { type: \"boolean\" },\n      help: { type: \"boolean\", short: \"h\" },\n    },\n  });\n\n  if (values.help || positionals.length === 0) {\n    process.stdout.write(HELP);\n    return values.help ? 0 : 1;\n  }\n  if (positionals[0] !== \"init\") return fail(`Unknown command \"${positionals[0]}\". Only \"init\" exists.`);\n\n  const target = values.target ?? \"swa\";\n  if (target !== \"swa\") return fail(`Unknown target \"${target}\". Only \"swa\" exists.`);\n\n  const domains = values.domain ?? (env[\"PLAUSIBLE_DOMAIN\"] ? [env[\"PLAUSIBLE_DOMAIN\"]] : []);\n  if (domains.length === 0) return fail(\"No domain. Pass --domain or set PLAUSIBLE_DOMAIN.\");\n\n  const maxBodyLength = values[\"max-body\"] === undefined ? undefined : Number(values[\"max-body\"]);\n  if (maxBodyLength !== undefined && !(Number.isInteger(maxBodyLength) && maxBodyLength > 0)) {\n    return fail(`--max-body must be a positive whole number, got \"${values[\"max-body\"]}\".`);\n  }\n\n  let events: Record<string, RelayRule>;\n  try {\n    events = parseRules(values.rule ?? []);\n  } catch (error) {\n    return fail(error instanceof Error ? error.message : String(error));\n  }\n\n  const config: RelayOptions = {\n    domain: domains.length === 1 ? (domains[0] as string) : domains,\n    ...(values.upstream ? { upstream: values.upstream } : {}),\n    ...(maxBodyLength ? { maxBodyLength } : {}),\n    ...(Object.keys(events).length > 0 ? { events } : {}),\n  };\n\n  const templateDir = context.templateDir ?? new URL(\"./templates/\", import.meta.url);\n  const template = await readFile(new URL(\"swa.mjs\", templateDir), \"utf8\");\n  const files = swaFiles(template, config, values.dir ?? \"api\", {\n    version: context.version ?? (await packageVersion()),\n    now: context.now ?? new Date(),\n  });\n\n  for (const file of files) {\n    if (values[\"dry-run\"]) {\n      process.stdout.write(`--- ${file.path}\\n${file.content}\\n`);\n      continue;\n    }\n    const present = await exists(file.path);\n    if (present && file.keepExisting) {\n      process.stdout.write(`kept     ${file.path}\\n`);\n      continue;\n    }\n    await mkdir(join(file.path, \"..\"), { recursive: true });\n    await writeFile(file.path, file.content);\n    process.stdout.write(`${present ? \"updated\" : \"created\"}  ${file.path}\\n`);\n  }\n  return 0;\n}\n\nexport function fail(message: string): number {\n  process.stderr.write(`astro-plausible: ${message}\\n`);\n  return 1;\n}\n","#!/usr/bin/env node\nimport { fail, main } from \"./cli\";\n\nmain(process.argv.slice(2), process.env).then(\n  (code) => {\n    process.exitCode = code;\n  },\n  (error: unknown) => {\n    process.exitCode = fail(error instanceof Error ? error.message : String(error));\n  },\n);\n"],"mappings":"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"}

package/dist/client.d.ts

@@ -0,0 +1,17 @@
+import { n as PlausibleOptions } from "./options-WE-C48Ul.js";
+import { CustomProperties, PlausibleConfig, PlausibleEventOptions, PlausibleRequestPayload, track } from "@plausible-analytics/tracker";
+//#region src/client.d.ts
+export interface PlausibleClientOptions extends Omit<PlausibleOptions, "customProperties"> {
+  /** Custom properties for every event, or a function of the event name that returns them. */
+  customProperties?: PlausibleConfig["customProperties"];
+  /** Change or drop a request before it is sent. Return null to drop it. */
+  transformRequest?: PlausibleConfig["transformRequest"];
+}
+/**
+ * Starts the tracker. The first call wins; later calls do nothing, so it is safe in a script that runs on every
+ * page. The tracker itself allows a single `init()`.
+ */
+export declare function startPlausible(options: PlausibleClientOptions): void;
+//#endregion
+export { type CustomProperties, type PlausibleEventOptions, type PlausibleRequestPayload, track };
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","names":[],"sources":["../src/client.ts"],"mappings":";;;iBAUiB,+BAA+B,KAAK;;EAEnD,mBAAmB;;EAEnB,mBAAmB;;;;;;wBASL,eAAe,SAAS"}

package/dist/client.js

@@ -0,0 +1,28 @@
+import { n as plausibleConfig } from "./options-CZaM-Wb7.js";
+import { init, track } from "@plausible-analytics/tracker";
+//#region src/client.ts
+/**
+* Browser side. Starts the official Plausible tracker (the `@plausible-analytics/tracker` package, bundled into the
+* site) pointed at the relay on your own domain.
+*/
+let started = false;
+/**
+* Starts the tracker. The first call wins; later calls do nothing, so it is safe in a script that runs on every
+* page. The tracker itself allows a single `init()`.
+*/
+function startPlausible(options) {
+	if (started || typeof window === "undefined") return;
+	started = true;
+	const { customProperties, transformRequest, ...rest } = options;
+	const config = plausibleConfig(typeof customProperties === "function" || customProperties === void 0 ? rest : {
+		...rest,
+		customProperties
+	});
+	if (typeof customProperties === "function") config.customProperties = customProperties;
+	if (transformRequest) config.transformRequest = transformRequest;
+	init(config);
+}
+//#endregion
+export { startPlausible, track };
+
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":[],"sources":["../src/client.ts"],"sourcesContent":["/**\n * Browser side. Starts the official Plausible tracker (the `@plausible-analytics/tracker` package, bundled into the\n * site) pointed at the relay on your own domain.\n */\nimport { init, type PlausibleConfig, track } from \"@plausible-analytics/tracker\";\nimport { type PlausibleOptions, plausibleConfig } from \"./options\";\n\nexport type { CustomProperties, PlausibleEventOptions, PlausibleRequestPayload } from \"@plausible-analytics/tracker\";\nexport { track };\n\nexport interface PlausibleClientOptions extends Omit<PlausibleOptions, \"customProperties\"> {\n  /** Custom properties for every event, or a function of the event name that returns them. */\n  customProperties?: PlausibleConfig[\"customProperties\"];\n  /** Change or drop a request before it is sent. Return null to drop it. */\n  transformRequest?: PlausibleConfig[\"transformRequest\"];\n}\n\nlet started = false;\n\n/**\n * Starts the tracker. The first call wins; later calls do nothing, so it is safe in a script that runs on every\n * page. The tracker itself allows a single `init()`.\n */\nexport function startPlausible(options: PlausibleClientOptions): void {\n  if (started || typeof window === \"undefined\") return;\n  started = true;\n\n  const { customProperties, transformRequest, ...rest } = options;\n  const config = plausibleConfig(\n    typeof customProperties === \"function\" || customProperties === undefined ? rest : { ...rest, customProperties },\n  );\n  if (typeof customProperties === \"function\") config.customProperties = customProperties;\n  if (transformRequest) config.transformRequest = transformRequest;\n  init(config);\n}\n"],"mappings":";;;;;;;AAiBA,IAAI,UAAU;;;;;AAMd,SAAgB,eAAe,SAAuC;CACpE,IAAI,WAAW,OAAO,WAAW,aAAa;CAC9C,UAAU;CAEV,MAAM,EAAE,kBAAkB,kBAAkB,GAAG,SAAS;CACxD,MAAM,SAAS,gBACb,OAAO,qBAAqB,cAAc,qBAAqB,KAAA,IAAY,OAAO;EAAE,GAAG;EAAM;CAAiB,CAChH;CACA,IAAI,OAAO,qBAAqB,YAAY,OAAO,mBAAmB;CACtE,IAAI,kBAAkB,OAAO,mBAAmB;CAChD,KAAK,MAAM;AACb"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { n as PlausibleOptions, r as plausibleConfig, t as DEFAULT_ENDPOINT } from "./options-WE-C48Ul.js";
+import { PlausibleIntegrationOptions, clientScript } from "./integration.js";
+export { DEFAULT_ENDPOINT, type PlausibleIntegrationOptions, type PlausibleOptions, clientScript, plausibleConfig };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { n as plausibleConfig, t as DEFAULT_ENDPOINT } from "./options-CZaM-Wb7.js";
+import { clientScript } from "./integration.js";
+export { DEFAULT_ENDPOINT, clientScript, plausibleConfig };

package/dist/integration.d.ts

@@ -0,0 +1,31 @@
+import { n as PlausibleOptions } from "./options-WE-C48Ul.js";
+import { AstroIntegration } from "astro";
+//#region src/integration.d.ts
+export interface PlausibleIntegrationOptions extends PlausibleOptions {
+  /**
+   * Whether to add the tracker to pages. Default is to add it for `astro build` and leave it out of `astro dev`,
+   * so local browsing does not show up in the dashboard. Set `true` to track in dev too (with
+   * `captureOnLocalhost: true`, or the tracker ignores localhost anyway).
+   */
+  enabled?: boolean;
+}
+/** The client script injected on every page. Exported for tests. */
+export declare function clientScript(options: PlausibleOptions): string;
+/**
+ * Astro integration. Bundles the Plausible tracker into every page and points it at `endpoint`, which defaults to
+ * `/api/event` on the site itself. Pair it with the relay from `astro-plausible init` so events reach Plausible
+ * from your own domain.
+ *
+ * @example
+ * ```js
+ * // astro.config.mjs
+ * import plausible from "@sjohansson/astro-plausible/integration";
+ *
+ * export default defineConfig({
+ *   integrations: [plausible({ domain: "example.com" })],
+ * });
+ * ```
+ */
+export default function plausibleIntegration(options: PlausibleIntegrationOptions): AstroIntegration;
+//#endregion
+//# sourceMappingURL=integration.d.ts.map

package/dist/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","names":[],"sources":["../src/integration.ts"],"mappings":";;;iBAGiB,oCAAoC;;;;;;EAMnD;;;wBAIc,aAAa,SAAS;;;;;;;;;;;;;;;;wBAsBd,qBAAqB,SAAS,8BAA8B"}

package/dist/integration.js

@@ -0,0 +1,41 @@
+import { n as plausibleConfig } from "./options-CZaM-Wb7.js";
+//#region src/integration.ts
+/** The client script injected on every page. Exported for tests. */
+function clientScript(options) {
+	return ["import { startPlausible } from \"@sjohansson/astro-plausible/client\";", `startPlausible(${JSON.stringify(plausibleConfig(options))});`].join("\n");
+}
+/**
+* Astro integration. Bundles the Plausible tracker into every page and points it at `endpoint`, which defaults to
+* `/api/event` on the site itself. Pair it with the relay from `astro-plausible init` so events reach Plausible
+* from your own domain.
+*
+* @example
+* ```js
+* // astro.config.mjs
+* import plausible from "@sjohansson/astro-plausible/integration";
+*
+* export default defineConfig({
+*   integrations: [plausible({ domain: "example.com" })],
+* });
+* ```
+*/
+function plausibleIntegration(options) {
+	const { enabled, ...tracker } = options ?? {};
+	if (enabled !== void 0 && typeof enabled !== "boolean") throw new Error("[@sjohansson/astro-plausible] enabled must be a boolean.");
+	plausibleConfig(tracker);
+	return {
+		name: "@sjohansson/astro-plausible",
+		hooks: { "astro:config:setup": ({ command, injectScript, logger }) => {
+			if (!(enabled ?? command === "build")) {
+				logger.info(`Plausible tracker left out of this ${command}. Set enabled: true to include it.`);
+				return;
+			}
+			injectScript("page", clientScript(tracker));
+			logger.debug(`Plausible tracker added, sending to ${tracker.endpoint ?? "/api/event"}`);
+		} }
+	};
+}
+//#endregion
+export { clientScript, plausibleIntegration as default };
+
+//# sourceMappingURL=integration.js.map

package/dist/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.js","names":[],"sources":["../src/integration.ts"],"sourcesContent":["import type { AstroIntegration } from \"astro\";\nimport { type PlausibleOptions, plausibleConfig } from \"./options\";\n\nexport interface PlausibleIntegrationOptions extends PlausibleOptions {\n  /**\n   * Whether to add the tracker to pages. Default is to add it for `astro build` and leave it out of `astro dev`,\n   * so local browsing does not show up in the dashboard. Set `true` to track in dev too (with\n   * `captureOnLocalhost: true`, or the tracker ignores localhost anyway).\n   */\n  enabled?: boolean;\n}\n\n/** The client script injected on every page. Exported for tests. */\nexport function clientScript(options: PlausibleOptions): string {\n  return [\n    'import { startPlausible } from \"@sjohansson/astro-plausible/client\";',\n    `startPlausible(${JSON.stringify(plausibleConfig(options))});`,\n  ].join(\"\\n\");\n}\n\n/**\n * Astro integration. Bundles the Plausible tracker into every page and points it at `endpoint`, which defaults to\n * `/api/event` on the site itself. Pair it with the relay from `astro-plausible init` so events reach Plausible\n * from your own domain.\n *\n * @example\n * ```js\n * // astro.config.mjs\n * import plausible from \"@sjohansson/astro-plausible/integration\";\n *\n * export default defineConfig({\n *   integrations: [plausible({ domain: \"example.com\" })],\n * });\n * ```\n */\nexport default function plausibleIntegration(options: PlausibleIntegrationOptions): AstroIntegration {\n  const { enabled, ...tracker } = options ?? {};\n  if (enabled !== undefined && typeof enabled !== \"boolean\") {\n    throw new Error(\"[@sjohansson/astro-plausible] enabled must be a boolean.\");\n  }\n  // Validate now so a bad config fails at startup, not on the first page.\n  plausibleConfig(tracker);\n\n  return {\n    name: \"@sjohansson/astro-plausible\",\n    hooks: {\n      \"astro:config:setup\": ({ command, injectScript, logger }) => {\n        const on = enabled ?? command === \"build\";\n        if (!on) {\n          logger.info(`Plausible tracker left out of this ${command}. Set enabled: true to include it.`);\n          return;\n        }\n        injectScript(\"page\", clientScript(tracker));\n        logger.debug(`Plausible tracker added, sending to ${tracker.endpoint ?? \"/api/event\"}`);\n      },\n    },\n  };\n}\n"],"mappings":";;;AAaA,SAAgB,aAAa,SAAmC;CAC9D,OAAO,CACL,0EACA,kBAAkB,KAAK,UAAU,gBAAgB,OAAO,CAAC,EAAE,GAC7D,CAAC,CAAC,KAAK,IAAI;AACb;;;;;;;;;;;;;;;;AAiBA,SAAwB,qBAAqB,SAAwD;CACnG,MAAM,EAAE,SAAS,GAAG,YAAY,WAAW,CAAC;CAC5C,IAAI,YAAY,KAAA,KAAa,OAAO,YAAY,WAC9C,MAAM,IAAI,MAAM,0DAA0D;CAG5E,gBAAgB,OAAO;CAEvB,OAAO;EACL,MAAM;EACN,OAAO,EACL,uBAAuB,EAAE,SAAS,cAAc,aAAa;GAE3D,IAAI,EADO,WAAW,YAAY,UACzB;IACP,OAAO,KAAK,sCAAsC,QAAQ,mCAAmC;IAC7F;GACF;GACA,aAAa,QAAQ,aAAa,OAAO,CAAC;GAC1C,OAAO,MAAM,uCAAuC,QAAQ,YAAY,cAAc;EACxF,EACF;CACF;AACF"}

package/dist/options-CZaM-Wb7.js

@@ -0,0 +1,51 @@
+//#region src/options.ts
+const DEFAULT_ENDPOINT = "/api/event";
+const DOMAIN_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*(\/[\w.-]+)*$/i;
+const BOOLEAN_KEYS = [
+	"autoCapturePageviews",
+	"hashBasedRouting",
+	"outboundLinks",
+	"formSubmissions",
+	"captureOnLocalhost",
+	"logging",
+	"bindToWindow"
+];
+function fail(message) {
+	throw new Error(`[@sjohansson/astro-plausible] ${message}`);
+}
+/** Validates the options and returns the config for the tracker's `init()`. Only keys that were set are included. */
+function plausibleConfig(options) {
+	if (typeof options?.domain !== "string" || options.domain.length > 253 || !DOMAIN_PATTERN.test(options.domain)) fail("domain must be the site domain as entered in Plausible, like example.com.");
+	const endpoint = options.endpoint ?? "/api/event";
+	if (typeof endpoint !== "string" || endpoint.length === 0) fail("endpoint must be a non-empty string.");
+	const config = {
+		domain: options.domain,
+		endpoint
+	};
+	for (const key of BOOLEAN_KEYS) {
+		const value = options[key];
+		if (value === void 0) continue;
+		if (typeof value !== "boolean") fail(`${key} must be a boolean.`);
+		config[key] = value;
+	}
+	if (options.fileDownloads !== void 0) {
+		const value = options.fileDownloads;
+		const custom = typeof value === "object" && value !== null && Array.isArray(value.fileExtensions);
+		if (typeof value !== "boolean" && !custom) fail("fileDownloads must be a boolean or { fileExtensions: [...] }.");
+		config.fileDownloads = value;
+	}
+	if (options.customProperties !== void 0) {
+		const value = options.customProperties;
+		if (!(typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((v) => [
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof v)))) fail("customProperties must be an object of strings, numbers and booleans.");
+		config.customProperties = value;
+	}
+	return config;
+}
+//#endregion
+export { plausibleConfig as n, DEFAULT_ENDPOINT as t };
+
+//# sourceMappingURL=options-CZaM-Wb7.js.map

package/dist/options-CZaM-Wb7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options-CZaM-Wb7.js","names":[],"sources":["../src/options.ts"],"sourcesContent":["import type { PlausibleConfig } from \"@plausible-analytics/tracker\";\n\n/** Tracker settings that can be written down as JSON. These go straight to the tracker's `init()`. */\nexport interface PlausibleOptions {\n  /** Your site's domain, as entered in Plausible. */\n  domain: string;\n\n  /**\n   * Where events go. `/api/event` is the relay from `astro-plausible init` on your own domain. Set the full\n   * Plausible URL, `https://plausible.io/api/event`, to skip the relay.\n   * @default \"/api/event\"\n   */\n  endpoint?: string;\n\n  /**\n   * Send a pageview on load and on history navigation.\n   * @default true\n   */\n  autoCapturePageviews?: boolean;\n\n  /**\n   * Track `#` paths as separate pages.\n   * @default false\n   */\n  hashBasedRouting?: boolean;\n\n  /**\n   * Track clicks on links to other sites.\n   * @default false\n   */\n  outboundLinks?: boolean;\n\n  /**\n   * Track file downloads, with Plausible's default file types or the ones given.\n   * @default false\n   */\n  fileDownloads?: boolean | { fileExtensions: string[] };\n\n  /**\n   * Track form submissions.\n   * @default false\n   */\n  formSubmissions?: boolean;\n\n  /**\n   * Also track on localhost.\n   * @default false\n   */\n  captureOnLocalhost?: boolean;\n\n  /**\n   * Log ignored events to the console.\n   * @default true\n   */\n  logging?: boolean;\n\n  /** Custom properties added to every event. */\n  customProperties?: Record<string, string | number | boolean>;\n\n  /**\n   * Expose the tracker as `window.plausible`. Plausible's installation check looks for it.\n   * @default true\n   */\n  bindToWindow?: boolean;\n}\n\nexport const DEFAULT_ENDPOINT = \"/api/event\";\n\nconst DOMAIN_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*(\\/[\\w.-]+)*$/i;\nconst BOOLEAN_KEYS = [\n  \"autoCapturePageviews\",\n  \"hashBasedRouting\",\n  \"outboundLinks\",\n  \"formSubmissions\",\n  \"captureOnLocalhost\",\n  \"logging\",\n  \"bindToWindow\",\n] as const;\n\nfunction fail(message: string): never {\n  throw new Error(`[@sjohansson/astro-plausible] ${message}`);\n}\n\n/** Validates the options and returns the config for the tracker's `init()`. Only keys that were set are included. */\nexport function plausibleConfig(options: PlausibleOptions): PlausibleConfig {\n  if (typeof options?.domain !== \"string\" || options.domain.length > 253 || !DOMAIN_PATTERN.test(options.domain)) {\n    fail(\"domain must be the site domain as entered in Plausible, like example.com.\");\n  }\n  const endpoint = options.endpoint ?? DEFAULT_ENDPOINT;\n  if (typeof endpoint !== \"string\" || endpoint.length === 0) fail(\"endpoint must be a non-empty string.\");\n\n  const config: PlausibleConfig = { domain: options.domain, endpoint };\n\n  for (const key of BOOLEAN_KEYS) {\n    const value = options[key];\n    if (value === undefined) continue;\n    if (typeof value !== \"boolean\") fail(`${key} must be a boolean.`);\n    config[key] = value;\n  }\n  if (options.fileDownloads !== undefined) {\n    const value = options.fileDownloads;\n    const custom = typeof value === \"object\" && value !== null && Array.isArray(value.fileExtensions);\n    if (typeof value !== \"boolean\" && !custom) fail(\"fileDownloads must be a boolean or { fileExtensions: [...] }.\");\n    config.fileDownloads = value;\n  }\n  if (options.customProperties !== undefined) {\n    const value = options.customProperties;\n    const plain =\n      typeof value === \"object\" &&\n      value !== null &&\n      !Array.isArray(value) &&\n      Object.values(value).every((v) => [\"string\", \"number\", \"boolean\"].includes(typeof v));\n    if (!plain) fail(\"customProperties must be an object of strings, numbers and booleans.\");\n    config.customProperties = value;\n  }\n  return config;\n}\n"],"mappings":";AAkEA,MAAa,mBAAmB;AAEhC,MAAM,iBAAiB;AACvB,MAAM,eAAe;CACnB;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,SAAS,KAAK,SAAwB;CACpC,MAAM,IAAI,MAAM,iCAAiC,SAAS;AAC5D;;AAGA,SAAgB,gBAAgB,SAA4C;CAC1E,IAAI,OAAO,SAAS,WAAW,YAAY,QAAQ,OAAO,SAAS,OAAO,CAAC,eAAe,KAAK,QAAQ,MAAM,GAC3G,KAAK,2EAA2E;CAElF,MAAM,WAAW,QAAQ,YAAA;CACzB,IAAI,OAAO,aAAa,YAAY,SAAS,WAAW,GAAG,KAAK,sCAAsC;CAEtG,MAAM,SAA0B;EAAE,QAAQ,QAAQ;EAAQ;CAAS;CAEnE,KAAK,MAAM,OAAO,cAAc;EAC9B,MAAM,QAAQ,QAAQ;EACtB,IAAI,UAAU,KAAA,GAAW;EACzB,IAAI,OAAO,UAAU,WAAW,KAAK,GAAG,IAAI,oBAAoB;EAChE,OAAO,OAAO;CAChB;CACA,IAAI,QAAQ,kBAAkB,KAAA,GAAW;EACvC,MAAM,QAAQ,QAAQ;EACtB,MAAM,SAAS,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,MAAM,cAAc;EAChG,IAAI,OAAO,UAAU,aAAa,CAAC,QAAQ,KAAK,+DAA+D;EAC/G,OAAO,gBAAgB;CACzB;CACA,IAAI,QAAQ,qBAAqB,KAAA,GAAW;EAC1C,MAAM,QAAQ,QAAQ;EAMtB,IAAI,EAJF,OAAO,UAAU,YACjB,UAAU,QACV,CAAC,MAAM,QAAQ,KAAK,KACpB,OAAO,OAAO,KAAK,CAAC,CAAC,OAAO,MAAM;GAAC;GAAU;GAAU;EAAS,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,IAC1E,KAAK,sEAAsE;EACvF,OAAO,mBAAmB;CAC5B;CACA,OAAO;AACT"}

package/dist/options-WE-C48Ul.d.ts

@@ -0,0 +1,63 @@
+import { PlausibleConfig } from "@plausible-analytics/tracker";
+//#region src/options.d.ts
+/** Tracker settings that can be written down as JSON. These go straight to the tracker's `init()`. */
+interface PlausibleOptions {
+  /** Your site's domain, as entered in Plausible. */
+  domain: string;
+  /**
+   * Where events go. `/api/event` is the relay from `astro-plausible init` on your own domain. Set the full
+   * Plausible URL, `https://plausible.io/api/event`, to skip the relay.
+   * @default "/api/event"
+   */
+  endpoint?: string;
+  /**
+   * Send a pageview on load and on history navigation.
+   * @default true
+   */
+  autoCapturePageviews?: boolean;
+  /**
+   * Track `#` paths as separate pages.
+   * @default false
+   */
+  hashBasedRouting?: boolean;
+  /**
+   * Track clicks on links to other sites.
+   * @default false
+   */
+  outboundLinks?: boolean;
+  /**
+   * Track file downloads, with Plausible's default file types or the ones given.
+   * @default false
+   */
+  fileDownloads?: boolean | {
+    fileExtensions: string[];
+  };
+  /**
+   * Track form submissions.
+   * @default false
+   */
+  formSubmissions?: boolean;
+  /**
+   * Also track on localhost.
+   * @default false
+   */
+  captureOnLocalhost?: boolean;
+  /**
+   * Log ignored events to the console.
+   * @default true
+   */
+  logging?: boolean;
+  /** Custom properties added to every event. */
+  customProperties?: Record<string, string | number | boolean>;
+  /**
+   * Expose the tracker as `window.plausible`. Plausible's installation check looks for it.
+   * @default true
+   */
+  bindToWindow?: boolean;
+}
+declare const DEFAULT_ENDPOINT = "/api/event";
+/** Validates the options and returns the config for the tracker's `init()`. Only keys that were set are included. */
+declare function plausibleConfig(options: PlausibleOptions): PlausibleConfig;
+//#endregion
+export { PlausibleOptions as n, plausibleConfig as r, DEFAULT_ENDPOINT as t };
+//# sourceMappingURL=options-WE-C48Ul.d.ts.map

package/dist/options-WE-C48Ul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options-WE-C48Ul.d.ts","names":[],"sources":["../src/options.ts"],"mappings":";;;UAGiB;;EAEf;;;;;;EAOA;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;EAMA;IAA4B;;;;;;EAM5B;;;;;EAMA;;;;;EAMA;;EAGA,mBAAmB;;;;;EAMnB;;cAGW;;iBAkBG,gBAAgB,SAAS,mBAAmB"}

package/dist/relay.d.ts

@@ -0,0 +1,82 @@
+//#region src/relay.d.ts
+/**
+ * The relay forwards tracker events from your domain to Plausible. It is written against the web standard Request
+ * and Response, so it runs anywhere fetch does: an Astro endpoint, Cloudflare, Netlify, Vercel, or through the
+ * `swaHandler` adapter, Azure Static Web Apps managed functions.
+ *
+ * It checks the domain so the endpoint only relays for your sites, passes the visitor's IP in `X-Forwarded-For`
+ * and their user agent (Plausible drops events without a real visitor IP), caps the body size, and can validate
+ * custom events.
+ */
+/** Per property pattern that an event's props must match. Only the listed properties are forwarded. */
+export type RelayRule = Record<string, RegExp | string>;
+export interface RelayOptions {
+  /** Site domain as entered in Plausible, or several when one relay serves several sites. */
+  domain: string | string[];
+  /**
+   * The Plausible host. Events are posted to `<upstream>/api/event`. Self-hosted: `https://plausible.example.com`.
+   * @default "https://plausible.io"
+   */
+  upstream?: string;
+  /**
+   * Largest request body accepted, in bytes.
+   * @default 16384
+   */
+  maxBodyLength?: number;
+  /**
+   * Validation for custom events, by event name. An event with a rule is forwarded only if every listed property
+   * is a string matching its pattern, and with only those properties. Events without a rule pass through as is.
+   */
+  events?: Record<string, RelayRule>;
+  /** Called when Plausible cannot be reached. */
+  onError?: (error: unknown) => void;
+}
+/** Incoming request headers with lowercased names, as Node and most platforms give them. */
+export type RelayHeaders = Record<string, string | string[] | undefined>;
+export interface RelayForward {
+  url: string;
+  body: string;
+  headers: Record<string, string>;
+}
+export interface RelayResult {
+  status: number;
+  contentType: string;
+  body: string;
+}
+export interface Relay {
+  /** Builds the upstream request, or null when the event is not for this relay or not valid. */
+  forward(rawBody: unknown, headers: RelayHeaders, clientIp?: string): RelayForward | null;
+  /** Sends a forward to Plausible. Throws when Plausible cannot be reached. */
+  send(forward: RelayForward): Promise<RelayResult>;
+  /** Handles a web standard request end to end. Pass the visitor IP when the platform gives it to you. */
+  handle(request: Request, context?: {
+    clientIp?: string;
+  }): Promise<Response>;
+}
+export declare const DEFAULT_UPSTREAM = "https://plausible.io";
+export declare const DEFAULT_MAX_BODY_LENGTH: number;
+/** Visitor IP from platform headers, without any port. Undefined when no header carries one. */
+export declare function clientIp(headers: RelayHeaders): string | undefined;
+export declare function createRelay(options: RelayOptions): Relay;
+/** The subset of the Azure Functions v3 context the adapter uses. */
+export interface SwaContext {
+  log: {
+    warn(message: string): void;
+  };
+  res?: {
+    status: number;
+    headers?: Record<string, string>;
+    body?: string;
+  };
+}
+export interface SwaRequest {
+  rawBody?: unknown;
+  headers?: RelayHeaders;
+}
+/**
+ * Adapter for Azure Static Web Apps managed functions (Node, `function.json` model). `astro-plausible init` writes
+ * a function that uses this.
+ */
+export declare function swaHandler(relay: Relay): (context: SwaContext, req: SwaRequest) => Promise<void>;
+//#endregion
+//# sourceMappingURL=relay.d.ts.map

package/dist/relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay.d.ts","names":[],"sources":["../src/relay.ts"],"mappings":";;;;;;;;;;;YAWY,YAAY,eAAe;iBAEtB;;EAEf;;;;;EAMA;;;;;EAMA;;;;;EAMA,SAAS,eAAe;;EAGxB,WAAW;;;YAID,eAAe;iBAEV;EACf;EACA;EACA,SAAS;;iBAGM;EACf;EACA;EACA;;iBAGe;;EAEf,QAAQ,kBAAkB,SAAS,cAAc,oBAAoB;;EAErE,KAAK,SAAS,eAAe,QAAQ;;EAErC,OAAO,SAAS,SAAS;IAAY;MAAsB,QAAQ;;qBAGxD;qBACA;;wBAmBG,SAAS,SAAS;wBA+ClB,YAAY,SAAS,eAAe;;iBAwEnC;EACf;IAAO,KAAK;;EACZ;IAAQ;IAAgB,UAAU;IAAwB;;;iBAG3C;EACf;EACA,UAAU;;;;;;wBAOI,WAAW,OAAO,SAAS,SAAS,YAAY,KAAK,eAAe"}

package/dist/relay.js

@@ -0,0 +1,156 @@
+//#region src/relay.ts
+const DEFAULT_UPSTREAM = "https://plausible.io";
+const DEFAULT_MAX_BODY_LENGTH = 16384;
+const IP_HEADERS = [
+	"x-azure-clientip",
+	"x-client-ip",
+	"cf-connecting-ip",
+	"x-nf-client-connection-ip",
+	"x-real-ip",
+	"x-forwarded-for"
+];
+function header(headers, name) {
+	const value = headers[name];
+	return Array.isArray(value) ? value[0] : value;
+}
+/** Visitor IP from platform headers, without any port. Undefined when no header carries one. */
+function clientIp(headers) {
+	for (const name of IP_HEADERS) {
+		const raw = header(headers, name)?.split(",")[0]?.trim();
+		if (!raw) continue;
+		const bracketed = raw.match(/^\[(.+)\]:\d+$/);
+		if (bracketed) return bracketed[1];
+		const ipv4WithPort = raw.match(/^(\d{1,3}(?:\.\d{1,3}){3}):\d+$/);
+		return ipv4WithPort ? ipv4WithPort[1] : raw;
+	}
+}
+function compileRules(events = {}) {
+	const compiled = /* @__PURE__ */ new Map();
+	for (const [name, rule] of Object.entries(events)) {
+		const entries = Object.entries(rule).map(([property, pattern]) => [property, pattern instanceof RegExp ? pattern : new RegExp(pattern)]);
+		if (entries.length === 0) throw new Error(`[@sjohansson/astro-plausible] Rule for event "${name}" lists no properties.`);
+		compiled.set(name, entries);
+	}
+	return compiled;
+}
+/** Applies the rule for an event. Returns the props to forward, or null when the event is not valid. */
+function applyRule(rules, props) {
+	const source = props && typeof props === "object" ? props : {};
+	const kept = {};
+	for (const [property, pattern] of rules) {
+		const value = source[property];
+		if (typeof value !== "string" || !pattern.test(value)) return null;
+		kept[property] = value;
+	}
+	return kept;
+}
+function headersToRecord(headers) {
+	const record = {};
+	headers.forEach((value, name) => {
+		record[name.toLowerCase()] = value;
+	});
+	return record;
+}
+function createRelay(options) {
+	const domains = new Set(Array.isArray(options.domain) ? options.domain : [options.domain]);
+	if (domains.size === 0 || [...domains].some((d) => typeof d !== "string" || d.length === 0)) throw new Error("[@sjohansson/astro-plausible] domain is required.");
+	const upstream = `${(options.upstream ?? "https://plausible.io").replace(/\/$/, "")}/api/event`;
+	const maxBodyLength = options.maxBodyLength ?? 16384;
+	const rules = compileRules(options.events);
+	const relay = {
+		forward(rawBody, headers, ip) {
+			if (typeof rawBody !== "string" || rawBody.length === 0 || rawBody.length > maxBodyLength) return null;
+			let event;
+			try {
+				event = JSON.parse(rawBody);
+			} catch {
+				return null;
+			}
+			if (!event || typeof event !== "object" || Array.isArray(event)) return null;
+			if (typeof event["d"] !== "string" || !domains.has(event["d"])) return null;
+			const name = event["n"];
+			if (typeof name !== "string" || name.length === 0) return null;
+			if (rules.has(name)) {
+				const kept = applyRule(rules.get(name) ?? [], event["p"]);
+				if (!kept) return null;
+				event["p"] = kept;
+			}
+			const forwardHeaders = { "content-type": "application/json" };
+			const userAgent = header(headers, "user-agent");
+			if (userAgent) forwardHeaders["user-agent"] = userAgent;
+			const visitorIp = ip ?? clientIp(headers);
+			if (visitorIp) forwardHeaders["x-forwarded-for"] = visitorIp;
+			return {
+				url: upstream,
+				body: JSON.stringify(event),
+				headers: forwardHeaders
+			};
+		},
+		async send(forward) {
+			const res = await fetch(forward.url, {
+				method: "POST",
+				headers: forward.headers,
+				body: forward.body
+			});
+			return {
+				status: res.status,
+				contentType: res.headers.get("content-type") ?? "text/plain",
+				body: await res.text()
+			};
+		},
+		async handle(request, context = {}) {
+			if (request.method !== "POST") return new Response(null, {
+				status: 405,
+				headers: { allow: "POST" }
+			});
+			if (Number(request.headers.get("content-length")) > maxBodyLength) return new Response(null, { status: 413 });
+			const forward = relay.forward(await request.text(), headersToRecord(request.headers), context.clientIp);
+			if (!forward) return new Response(null, { status: 400 });
+			try {
+				const result = await relay.send(forward);
+				return new Response(result.body, {
+					status: result.status,
+					headers: {
+						"content-type": result.contentType,
+						"cache-control": "no-store"
+					}
+				});
+			} catch (error) {
+				options.onError?.(error);
+				return new Response(null, { status: 502 });
+			}
+		}
+	};
+	return relay;
+}
+/**
+* Adapter for Azure Static Web Apps managed functions (Node, `function.json` model). `astro-plausible init` writes
+* a function that uses this.
+*/
+function swaHandler(relay) {
+	return async (context, req) => {
+		const forward = relay.forward(req.rawBody, req.headers ?? {});
+		if (!forward) {
+			context.res = { status: 400 };
+			return;
+		}
+		try {
+			const result = await relay.send(forward);
+			context.res = {
+				status: result.status,
+				headers: {
+					"content-type": result.contentType,
+					"cache-control": "no-store"
+				},
+				body: result.body
+			};
+		} catch (error) {
+			context.log.warn(`Plausible forward failed: ${error}`);
+			context.res = { status: 502 };
+		}
+	};
+}
+//#endregion
+export { DEFAULT_MAX_BODY_LENGTH, DEFAULT_UPSTREAM, clientIp, createRelay, swaHandler };
+
+//# sourceMappingURL=relay.js.map

package/dist/relay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay.js","names":[],"sources":["../src/relay.ts"],"sourcesContent":["/**\n * The relay forwards tracker events from your domain to Plausible. It is written against the web standard Request\n * and Response, so it runs anywhere fetch does: an Astro endpoint, Cloudflare, Netlify, Vercel, or through the\n * `swaHandler` adapter, Azure Static Web Apps managed functions.\n *\n * It checks the domain so the endpoint only relays for your sites, passes the visitor's IP in `X-Forwarded-For`\n * and their user agent (Plausible drops events without a real visitor IP), caps the body size, and can validate\n * custom events.\n */\n\n/** Per property pattern that an event's props must match. Only the listed properties are forwarded. */\nexport type RelayRule = Record<string, RegExp | string>;\n\nexport interface RelayOptions {\n  /** Site domain as entered in Plausible, or several when one relay serves several sites. */\n  domain: string | string[];\n\n  /**\n   * The Plausible host. Events are posted to `<upstream>/api/event`. Self-hosted: `https://plausible.example.com`.\n   * @default \"https://plausible.io\"\n   */\n  upstream?: string;\n\n  /**\n   * Largest request body accepted, in bytes.\n   * @default 16384\n   */\n  maxBodyLength?: number;\n\n  /**\n   * Validation for custom events, by event name. An event with a rule is forwarded only if every listed property\n   * is a string matching its pattern, and with only those properties. Events without a rule pass through as is.\n   */\n  events?: Record<string, RelayRule>;\n\n  /** Called when Plausible cannot be reached. */\n  onError?: (error: unknown) => void;\n}\n\n/** Incoming request headers with lowercased names, as Node and most platforms give them. */\nexport type RelayHeaders = Record<string, string | string[] | undefined>;\n\nexport interface RelayForward {\n  url: string;\n  body: string;\n  headers: Record<string, string>;\n}\n\nexport interface RelayResult {\n  status: number;\n  contentType: string;\n  body: string;\n}\n\nexport interface Relay {\n  /** Builds the upstream request, or null when the event is not for this relay or not valid. */\n  forward(rawBody: unknown, headers: RelayHeaders, clientIp?: string): RelayForward | null;\n  /** Sends a forward to Plausible. Throws when Plausible cannot be reached. */\n  send(forward: RelayForward): Promise<RelayResult>;\n  /** Handles a web standard request end to end. Pass the visitor IP when the platform gives it to you. */\n  handle(request: Request, context?: { clientIp?: string }): Promise<Response>;\n}\n\nexport const DEFAULT_UPSTREAM = \"https://plausible.io\";\nexport const DEFAULT_MAX_BODY_LENGTH = 16 * 1024;\n\n// Platform headers that carry the visitor IP, most specific first. x-forwarded-for is last because proxies append\n// to it and some let the client seed it.\nconst IP_HEADERS = [\n  \"x-azure-clientip\",\n  \"x-client-ip\",\n  \"cf-connecting-ip\",\n  \"x-nf-client-connection-ip\",\n  \"x-real-ip\",\n  \"x-forwarded-for\",\n];\n\nfunction header(headers: RelayHeaders, name: string): string | undefined {\n  const value = headers[name];\n  return Array.isArray(value) ? value[0] : value;\n}\n\n/** Visitor IP from platform headers, without any port. Undefined when no header carries one. */\nexport function clientIp(headers: RelayHeaders): string | undefined {\n  for (const name of IP_HEADERS) {\n    const raw = header(headers, name)?.split(\",\")[0]?.trim();\n    if (!raw) continue;\n    const bracketed = raw.match(/^\\[(.+)\\]:\\d+$/);\n    if (bracketed) return bracketed[1];\n    const ipv4WithPort = raw.match(/^(\\d{1,3}(?:\\.\\d{1,3}){3}):\\d+$/);\n    return ipv4WithPort ? ipv4WithPort[1] : raw;\n  }\n  return undefined;\n}\n\nfunction compileRules(events: Record<string, RelayRule> = {}): Map<string, [string, RegExp][]> {\n  const compiled = new Map<string, [string, RegExp][]>();\n  for (const [name, rule] of Object.entries(events)) {\n    const entries = Object.entries(rule).map(([property, pattern]): [string, RegExp] => [\n      property,\n      pattern instanceof RegExp ? pattern : new RegExp(pattern),\n    ]);\n    if (entries.length === 0) {\n      throw new Error(`[@sjohansson/astro-plausible] Rule for event \"${name}\" lists no properties.`);\n    }\n    compiled.set(name, entries);\n  }\n  return compiled;\n}\n\n/** Applies the rule for an event. Returns the props to forward, or null when the event is not valid. */\nfunction applyRule(rules: [string, RegExp][], props: unknown): Record<string, string> | null {\n  const source = props && typeof props === \"object\" ? (props as Record<string, unknown>) : {};\n  const kept: Record<string, string> = {};\n  for (const [property, pattern] of rules) {\n    const value = source[property];\n    if (typeof value !== \"string\" || !pattern.test(value)) return null;\n    kept[property] = value;\n  }\n  return kept;\n}\n\nfunction headersToRecord(headers: Headers): RelayHeaders {\n  const record: RelayHeaders = {};\n  headers.forEach((value, name) => {\n    record[name.toLowerCase()] = value;\n  });\n  return record;\n}\n\nexport function createRelay(options: RelayOptions): Relay {\n  const domains = new Set(Array.isArray(options.domain) ? options.domain : [options.domain]);\n  if (domains.size === 0 || [...domains].some((d) => typeof d !== \"string\" || d.length === 0)) {\n    throw new Error(\"[@sjohansson/astro-plausible] domain is required.\");\n  }\n  const upstream = `${(options.upstream ?? DEFAULT_UPSTREAM).replace(/\\/$/, \"\")}/api/event`;\n  const maxBodyLength = options.maxBodyLength ?? DEFAULT_MAX_BODY_LENGTH;\n  const rules = compileRules(options.events);\n\n  const relay: Relay = {\n    forward(rawBody, headers, ip) {\n      if (typeof rawBody !== \"string\" || rawBody.length === 0 || rawBody.length > maxBodyLength) return null;\n\n      let event: Record<string, unknown>;\n      try {\n        event = JSON.parse(rawBody);\n      } catch {\n        return null;\n      }\n      if (!event || typeof event !== \"object\" || Array.isArray(event)) return null;\n      if (typeof event[\"d\"] !== \"string\" || !domains.has(event[\"d\"])) return null;\n      const name = event[\"n\"];\n      if (typeof name !== \"string\" || name.length === 0) return null;\n\n      if (rules.has(name)) {\n        const kept = applyRule(rules.get(name) ?? [], event[\"p\"]);\n        if (!kept) return null;\n        event[\"p\"] = kept;\n      }\n\n      const forwardHeaders: Record<string, string> = { \"content-type\": \"application/json\" };\n      const userAgent = header(headers, \"user-agent\");\n      if (userAgent) forwardHeaders[\"user-agent\"] = userAgent;\n      const visitorIp = ip ?? clientIp(headers);\n      if (visitorIp) forwardHeaders[\"x-forwarded-for\"] = visitorIp;\n\n      return { url: upstream, body: JSON.stringify(event), headers: forwardHeaders };\n    },\n\n    async send(forward) {\n      const res = await fetch(forward.url, { method: \"POST\", headers: forward.headers, body: forward.body });\n      return {\n        status: res.status,\n        contentType: res.headers.get(\"content-type\") ?? \"text/plain\",\n        body: await res.text(),\n      };\n    },\n\n    async handle(request, context = {}) {\n      if (request.method !== \"POST\") return new Response(null, { status: 405, headers: { allow: \"POST\" } });\n      const length = Number(request.headers.get(\"content-length\"));\n      if (length > maxBodyLength) return new Response(null, { status: 413 });\n\n      const forward = relay.forward(await request.text(), headersToRecord(request.headers), context.clientIp);\n      if (!forward) return new Response(null, { status: 400 });\n\n      try {\n        const result = await relay.send(forward);\n        return new Response(result.body, {\n          status: result.status,\n          headers: { \"content-type\": result.contentType, \"cache-control\": \"no-store\" },\n        });\n      } catch (error) {\n        options.onError?.(error);\n        return new Response(null, { status: 502 });\n      }\n    },\n  };\n  return relay;\n}\n\n/** The subset of the Azure Functions v3 context the adapter uses. */\nexport interface SwaContext {\n  log: { warn(message: string): void };\n  res?: { status: number; headers?: Record<string, string>; body?: string };\n}\n\nexport interface SwaRequest {\n  rawBody?: unknown;\n  headers?: RelayHeaders;\n}\n\n/**\n * Adapter for Azure Static Web Apps managed functions (Node, `function.json` model). `astro-plausible init` writes\n * a function that uses this.\n */\nexport function swaHandler(relay: Relay): (context: SwaContext, req: SwaRequest) => Promise<void> {\n  return async (context, req) => {\n    const forward = relay.forward(req.rawBody, req.headers ?? {});\n    if (!forward) {\n      context.res = { status: 400 };\n      return;\n    }\n    try {\n      const result = await relay.send(forward);\n      context.res = {\n        status: result.status,\n        headers: { \"content-type\": result.contentType, \"cache-control\": \"no-store\" },\n        body: result.body,\n      };\n    } catch (error) {\n      context.log.warn(`Plausible forward failed: ${error}`);\n      context.res = { status: 502 };\n    }\n  };\n}\n"],"mappings":"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"}

package/dist/templates/swa.mjs

@@ -0,0 +1,155 @@
+const IP_HEADERS = [
+	"x-azure-clientip",
+	"x-client-ip",
+	"cf-connecting-ip",
+	"x-nf-client-connection-ip",
+	"x-real-ip",
+	"x-forwarded-for"
+];
+function header(headers, name) {
+	const value = headers[name];
+	return Array.isArray(value) ? value[0] : value;
+}
+/** Visitor IP from platform headers, without any port. Undefined when no header carries one. */
+function clientIp(headers) {
+	for (const name of IP_HEADERS) {
+		const raw = header(headers, name)?.split(",")[0]?.trim();
+		if (!raw) continue;
+		const bracketed = raw.match(/^\[(.+)\]:\d+$/);
+		if (bracketed) return bracketed[1];
+		const ipv4WithPort = raw.match(/^(\d{1,3}(?:\.\d{1,3}){3}):\d+$/);
+		return ipv4WithPort ? ipv4WithPort[1] : raw;
+	}
+}
+function compileRules(events = {}) {
+	const compiled = /* @__PURE__ */ new Map();
+	for (const [name, rule] of Object.entries(events)) {
+		const entries = Object.entries(rule).map(([property, pattern]) => [property, pattern instanceof RegExp ? pattern : new RegExp(pattern)]);
+		if (entries.length === 0) throw new Error(`[@sjohansson/astro-plausible] Rule for event "${name}" lists no properties.`);
+		compiled.set(name, entries);
+	}
+	return compiled;
+}
+/** Applies the rule for an event. Returns the props to forward, or null when the event is not valid. */
+function applyRule(rules, props) {
+	const source = props && typeof props === "object" ? props : {};
+	const kept = {};
+	for (const [property, pattern] of rules) {
+		const value = source[property];
+		if (typeof value !== "string" || !pattern.test(value)) return null;
+		kept[property] = value;
+	}
+	return kept;
+}
+function headersToRecord(headers) {
+	const record = {};
+	headers.forEach((value, name) => {
+		record[name.toLowerCase()] = value;
+	});
+	return record;
+}
+function createRelay(options) {
+	const domains = new Set(Array.isArray(options.domain) ? options.domain : [options.domain]);
+	if (domains.size === 0 || [...domains].some((d) => typeof d !== "string" || d.length === 0)) throw new Error("[@sjohansson/astro-plausible] domain is required.");
+	const upstream = `${(options.upstream ?? "https://plausible.io").replace(/\/$/, "")}/api/event`;
+	const maxBodyLength = options.maxBodyLength ?? 16384;
+	const rules = compileRules(options.events);
+	const relay = {
+		forward(rawBody, headers, ip) {
+			if (typeof rawBody !== "string" || rawBody.length === 0 || rawBody.length > maxBodyLength) return null;
+			let event;
+			try {
+				event = JSON.parse(rawBody);
+			} catch {
+				return null;
+			}
+			if (!event || typeof event !== "object" || Array.isArray(event)) return null;
+			if (typeof event["d"] !== "string" || !domains.has(event["d"])) return null;
+			const name = event["n"];
+			if (typeof name !== "string" || name.length === 0) return null;
+			if (rules.has(name)) {
+				const kept = applyRule(rules.get(name) ?? [], event["p"]);
+				if (!kept) return null;
+				event["p"] = kept;
+			}
+			const forwardHeaders = { "content-type": "application/json" };
+			const userAgent = header(headers, "user-agent");
+			if (userAgent) forwardHeaders["user-agent"] = userAgent;
+			const visitorIp = ip ?? clientIp(headers);
+			if (visitorIp) forwardHeaders["x-forwarded-for"] = visitorIp;
+			return {
+				url: upstream,
+				body: JSON.stringify(event),
+				headers: forwardHeaders
+			};
+		},
+		async send(forward) {
+			const res = await fetch(forward.url, {
+				method: "POST",
+				headers: forward.headers,
+				body: forward.body
+			});
+			return {
+				status: res.status,
+				contentType: res.headers.get("content-type") ?? "text/plain",
+				body: await res.text()
+			};
+		},
+		async handle(request, context = {}) {
+			if (request.method !== "POST") return new Response(null, {
+				status: 405,
+				headers: { allow: "POST" }
+			});
+			if (Number(request.headers.get("content-length")) > maxBodyLength) return new Response(null, { status: 413 });
+			const forward = relay.forward(await request.text(), headersToRecord(request.headers), context.clientIp);
+			if (!forward) return new Response(null, { status: 400 });
+			try {
+				const result = await relay.send(forward);
+				return new Response(result.body, {
+					status: result.status,
+					headers: {
+						"content-type": result.contentType,
+						"cache-control": "no-store"
+					}
+				});
+			} catch (error) {
+				options.onError?.(error);
+				return new Response(null, { status: 502 });
+			}
+		}
+	};
+	return relay;
+}
+/**
+* Adapter for Azure Static Web Apps managed functions (Node, `function.json` model). `astro-plausible init` writes
+* a function that uses this.
+*/
+function swaHandler(relay) {
+	return async (context, req) => {
+		const forward = relay.forward(req.rawBody, req.headers ?? {});
+		if (!forward) {
+			context.res = { status: 400 };
+			return;
+		}
+		try {
+			const result = await relay.send(forward);
+			context.res = {
+				status: result.status,
+				headers: {
+					"content-type": result.contentType,
+					"cache-control": "no-store"
+				},
+				body: result.body
+			};
+		} catch (error) {
+			context.log.warn(`Plausible forward failed: ${error}`);
+			context.res = { status: 502 };
+		}
+	};
+}
+//#endregion
+//#region src/templates/swa.ts
+const relay = createRelay(__ASTRO_PLAUSIBLE_RELAY_CONFIG__);
+var swa_default = swaHandler(relay);
+//#endregion
+export { swa_default as default, relay };

package/package.json

@@ -1,6 +1,72 @@
 {
   "name": "@sjohansson/astro-plausible",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "First-party Plausible analytics for Astro sites. The official tracker is bundled into your site's own JavaScript and events go through a relay on your domain, so ad blockers do not drop them.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./integration": {
+      "types": "./dist/integration.d.ts",
+      "import": "./dist/integration.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./relay": {
+      "types": "./dist/relay.d.ts",
+      "import": "./dist/relay.js"
+    }
+  },
+  "bin": {
+    "astro-plausible": "./dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "astro",
+    "astro-integration",
+    "plausible",
+    "analytics",
+    "privacy",
+    "proxy",
+    "static-site"
+  ],
+  "author": "sjohansson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sjohansson/astro-components.git",
+    "directory": "packages/astro-plausible"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@plausible-analytics/tracker": "^0.4.7"
+  },
+  "peerDependencies": {
+    "astro": "^5.0.0 || ^6.0.0 || ^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "astro": {
+      "optional": true
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
+    "test": "vitest"
+  }
 }