@emplugins/emprivacy 1.0.0

package/LICENSE

@@ -0,0 +1,23 @@
+SPDX-License-Identifier: MIT
+
+MIT License
+
+Copyright (c) 2026 EmPrivacy contributors
+
+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

@@ -0,0 +1,145 @@
+<!-- SPDX-License-Identifier: MIT -->
+![EmPrivacy Logo](./artwork/logo/EmPrivacy.png)
+# EmPrivacy
+
+**EmPrivacy** is an open source [EmDash](https://github.com/emdash-cms/emdash) plugin that adds a cookie consent banner, category-based choices (essential / analytics / marketing), and **client-side** loading of third-party scripts only after consent. It aligns with common regulatory expectations when you configure it honestly and pair it with proper legal documents—but **this software is not legal advice** (see [Disclaimer](#legal-disclaimer)).
+
+## Requirements
+
+- **EmDash** `>=0.14.0` (**tested with `0.14.0` and `0.29.0`**; see [EMDASH_COMPAT.md](./EMDASH_COMPAT.md)). Sites on EmDash 0.9–0.13: use **emprivacy 0.2.x**.
+- Plugins registered in **`astro.config`** in **trusted** mode (the `plugins: []` array).  
+  **Sandboxed** marketplace plugins **cannot** use `page:fragments`; EmPrivacy needs the `hooks.page-fragments:register` capability so head/body contributions run on public pages. See [Plugin System Overview](https://docs.emdashcms.com/plugins/overview/).
+
+## Install
+
+```bash
+npm install @emplugins/emprivacy
+```
+
+Published under the [emplugins](https://www.npmjs.com/org/emplugins) npm org. Source: [github.com/EmPlugins/EmPrivacy](https://github.com/EmPlugins/EmPrivacy).
+
+Use a **semver range** if you want controlled upgrades, for example `@emplugins/emprivacy@^1.0.0`. Versioning policy and maintainer release steps: [docs/RELEASES.md](docs/RELEASES.md). Org publish / `NPM_TOKEN` setup: [docs/NPM_ORG_PUBLISH.md](docs/NPM_ORG_PUBLISH.md).
+
+The legacy unscoped package `emprivacy` is deprecated; migrate imports to `@emplugins/emprivacy`.
+
+## Quick start
+
+1. **Register the plugin** in `astro.config.mjs` (or `.ts`) **before** other plugins that inject marketing or analytics, so consent runs first:
+
+   ```ts
+   import { defineConfig } from "astro/config";
+   import { emdash } from "emdash/astro";
+   import { emprivacyPlugin } from "@emplugins/emprivacy";
+
+   export default defineConfig({
+     integrations: [
+       emdash({
+         plugins: [emprivacyPlugin()],
+       }),
+     ],
+   });
+   ```
+
+2. **Use EmDash page integration** in your layout so fragments render: include `<EmDashHead />`, `<EmDashBodyStart />`, `<EmDashBodyEnd />` (or your theme’s equivalents). See [EmDash docs](https://docs.emdashcms.com/).
+
+3. **Configure EmPrivacy in the admin** (shield → **EmPrivacy**):
+   - **Privacy policy** — Point to your existing EmDash **Page** using its **public path** (what you see in the address bar when that Page is open, e.g. `/privacy`), **or** a full `https://…` URL if the policy is hosted elsewhere. Root-relative paths are resolved with EmDash `ctx.url()` so links stay correct across environments.
+   - **Cookie policy** (optional) — Same rules: EmDash Page path or `https://…`.
+   - Set banner copy, **Policy / consent version**, **Analytics** (Cloudflare site token, **None**, or **Custom** `https` URLs), and **Marketing** script URLs (`https`, one per line). See [GETTING_STARTED](docs/GETTING_STARTED.md#step-5--configure-emprivacy-in-the-admin).
+
+See [docs/GETTING_STARTED.md](docs/GETTING_STARTED.md) for a step-by-step path from “create a Page” to “verify the link in the banner.”
+
+Visitors see a banner on first visit (or when you bump **Policy / consent version**). Configured analytics (e.g. Cloudflare beacon) and marketing scripts load only **after** the user consents to the matching category.
+
+## Features
+
+| Feature | Description |
+|--------|-------------|
+| Categories | Essential (informational), **Analytics**, **Marketing** |
+| Privacy / cookie links | EmDash **Page** as a root path (e.g. `/privacy`) or external `https://` URL; paths resolve via `ctx.url()` in hooks so public URLs stay correct when the site origin changes |
+| Analytics platforms | **Cloudflare Web Analytics** — enter your site token; the beacon is injected with `data-cf-beacon` after consent. **None** / **Custom** (`https` URLs) also supported; more platforms can be added over time |
+| Marketing scripts | Only **https** URLs you list are injected as `<script src>` after marketing consent—no arbitrary admin HTML |
+| Re-open preferences | After the first choice, a **cookie button** (bottom-left) re-opens the same options; saving from that panel **reloads** the page so script loading matches the latest consent (including revoking) |
+| Consent cookie | `emprivacy_cc` (`path=/`, `SameSite=Lax`, `Secure` on HTTPS), JSON `{ v, a, m }` (version, analytics, marketing) |
+| Optional server log | POST consent snapshots to `/_emdash/api/plugins/emprivacy/record` + optional storage rows (no IP in v1) |
+| Google Consent Mode v2 | Optional denied defaults in `<head>` + `gtag('consent','update',…)` — validate with [Google’s docs](https://support.google.com/tagmanager/answer/13695607) |
+
+## Legal disclaimer
+
+EmPrivacy helps you implement **technical** consent UX and script loading patterns used for regulations such as **GDPR** and **CCPA/CIPA**. **You** remain responsible for:
+
+- Privacy notices, cookie policies, and lawful bases  
+- What data your analytics/marketing vendors collect  
+- Whether your configuration meets obligations in your jurisdictions  
+
+**This project does not provide legal advice.** If you need certainty, consult a qualified attorney or privacy professional.
+
+## Registration order
+
+Put **`emprivacyPlugin()` early** in the `plugins` array so `page:metadata` / `page:fragments` run before other plugins that add trackers or metadata.
+
+## Development
+
+```bash
+npm install
+npm run typecheck   # TypeScript
+npm run build       # ESM + types in dist/
+npm test            # Unit tests (see Testing)
+npm run test:watch  # Vitest in watch mode (optional)
+```
+
+Outputs ESM under `dist/` with typings, matching the [plugin layout](https://www.npmjs.com/package/@emdash-cms/plugin-audit-log) used by other EmDash packages.
+
+Dependency, audit, and deprecation context (Kysely override, `npm audit`): [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md).
+
+## Testing
+
+### Automated (local or CI)
+
+| Command | Purpose |
+|---------|---------|
+| `npm run typecheck` | Types against `emdash` and this package |
+| `npm run build` | `tsdown` → `dist/` and `exports` |
+| `npm test` | [Vitest](https://vitest.dev/) tests for `src/config.ts`: URL lists, `normalizeConfig`, policy **path vs https** validation, `resolvePolicyHref`, `jsonForHtmlScript` |
+
+Automation does **not** start EmDash or a browser; it guards packaging and validation logic.
+
+**Suggested CI:**
+
+```bash
+npm ci
+npm run typecheck
+npm run build
+npm test
+```
+
+### Staging / manual (before production)
+
+EmPrivacy uses EmDash KV, admin Block Kit, `page:fragments`, and plugin routes. Validate on a **real EmDash site** (staging) at the EmDash version you deploy.
+
+- **[docs/TESTING.md](docs/TESTING.md)** — Full pre-deploy checklist, flows to exercise, limits of automation.  
+- **No E2E in this repo** — nothing here launches EmDash or drives a browser.
+
+### Acceptance checklist (manual QA)
+
+Details: [docs/TESTING.md](docs/TESTING.md).
+
+- [ ] `typecheck`, `build`, and `npm test` pass
+- [ ] Banner when no cookie or **Policy / consent version** mismatch
+- [ ] **Privacy (and cookie) links** open the right EmDash Page or external URL; paths match what you see in the browser for that Page
+- [ ] Strict mode: no analytics/marketing scripts until consent (Network tab)
+- [ ] Cookie persists; bumping policy version shows the banner again
+- [ ] Admin save updates the public banner
+- [ ] Optional: server logging + recent records in admin
+- [ ] Optional: Google Consent Mode (Tag Assistant / [Google](https://support.google.com/tagmanager/answer/13695607))
+- [ ] **Trusted** `plugins: []` (see [Requirements](#requirements))
+
+## Releases
+
+npm releases follow **[Semantic Versioning](https://semver.org/)** (`MAJOR.MINOR.PATCH`). Tags are `v`-prefixed (e.g. `v0.1.0`). See [docs/RELEASES.md](docs/RELEASES.md).
+
+**EmDash upgrades:** say `update to latest emdash release` in Cursor (skill: [`.cursor/skills/emdash-release`](.cursor/skills/emdash-release/SKILL.md)) to bump, test, and publish to npm + GitHub without a manual merge gate.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/config-BJ1LHuri.mjs

@@ -0,0 +1,166 @@
+//#region src/config.ts
+/**
+* EmPrivacy KV document (`consent:config`) and shared helpers.
+*/
+const KV_KEY = "consent:config";
+const COOKIE_NAME = "emprivacy_cc";
+const PLUGIN_ID = "emprivacy";
+const DEFAULT_CONFIG = {
+	bannerTitle: "Cookies & privacy",
+	bannerMessage: "We use cookies to run this site and optionally for analytics and marketing. You can accept or customize your choices.",
+	privacyPolicyUrl: "/privacy",
+	cookiePolicyUrl: "",
+	strictDefaults: true,
+	policyVersion: "1",
+	cloudflareWebAnalyticsToken: "",
+	analyticsProvider: "cloudflare",
+	analyticsScriptUrls: [],
+	marketingScriptUrls: [],
+	googleConsentMode: false,
+	logConsentToServer: false
+};
+function hasUnsafeUrlChars(s) {
+	return /[\u0000-\u001F\u007F\s]/.test(s);
+}
+function isHttpsUrl(s) {
+	try {
+		const t = s.trim();
+		if (!t) return false;
+		if (hasUnsafeUrlChars(t)) return false;
+		if (/%0d|%0a|%09|%0b|%0c|%20/i.test(t)) return false;
+		const u = new URL(t);
+		if (u.protocol !== "https:") return false;
+		if (u.username || u.password) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+function invalidScriptUrlError(kind, u) {
+	if (u.includes("<") || u.includes(">")) return `Invalid ${kind} script URL (https only). Paste one full https:// URL per line (the script src only), not a <script> tag or HTML comment. Example: https://static.cloudflareinsights.com/beacon.min.js. The invalid line was: ${u}`;
+	return `Invalid ${kind} script URL (https only): ${u}`;
+}
+function isAnalyticsProvider(s) {
+	return s === "cloudflare" || s === "none" || s === "custom";
+}
+/** Reject characters that would break JSON or attributes; allow typical Cloudflare site token strings. */
+function assertValidCloudflareToken(t) {
+	const s = t.trim();
+	if (s.length === 0) return;
+	if (s.length > 256) throw new Error("Cloudflare site token is too long.");
+	if (/[\s<>'"&]/.test(s)) throw new Error("Cloudflare site token contains invalid characters.");
+}
+/**
+* Root-relative public path (EmDash page route), e.g. `/privacy`.
+* Rejects protocol-relative URLs (`//…`) and whitespace.
+*/
+function isRootRelativeSitePath(s) {
+	const t = s.trim();
+	if (t.length === 0) return false;
+	if (!t.startsWith("/")) return false;
+	if (t.startsWith("//")) return false;
+	if (hasUnsafeUrlChars(t)) return false;
+	return true;
+}
+/** For hooks: turn stored path or absolute URL into a public absolute URL. */
+function resolvePolicyHref(stored, ctx) {
+	const t = stored.trim();
+	if (!t) return t;
+	if (isRootRelativeSitePath(t)) return ctx.url(t);
+	return t;
+}
+function isValidPolicyHrefInput(s) {
+	const t = s.trim();
+	if (!t) return false;
+	return isHttpsUrl(t) || isRootRelativeSitePath(t);
+}
+function parseUrlList(text) {
+	const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+	return [...new Set(lines)];
+}
+function assertLength(label, s, min, max) {
+	const t = s.trim();
+	if (t.length < min) throw new Error(`${label} is required.`);
+	if (t.length > max) throw new Error(`${label} is too long.`);
+}
+function assertOptionalLength(label, s, max) {
+	if (s.trim().length > max) throw new Error(`${label} is too long.`);
+}
+function normalizeConfig(raw) {
+	if (typeof raw !== "object" || raw === null) return { ...DEFAULT_CONFIG };
+	const o = raw;
+	const analytics = Array.isArray(o.analyticsScriptUrls) ? o.analyticsScriptUrls.filter((x) => typeof x === "string") : DEFAULT_CONFIG.analyticsScriptUrls;
+	const marketing = Array.isArray(o.marketingScriptUrls) ? o.marketingScriptUrls.filter((x) => typeof x === "string") : DEFAULT_CONFIG.marketingScriptUrls;
+	const cfTok = typeof o.cloudflareWebAnalyticsToken === "string" ? o.cloudflareWebAnalyticsToken : "";
+	const apCandidate = typeof o.analyticsProvider === "string" ? o.analyticsProvider.trim() : "";
+	let analyticsProvider;
+	if (isAnalyticsProvider(apCandidate)) analyticsProvider = apCandidate;
+	else if (analytics.length > 0) analyticsProvider = "custom";
+	else analyticsProvider = DEFAULT_CONFIG.analyticsProvider;
+	return {
+		bannerTitle: typeof o.bannerTitle === "string" ? o.bannerTitle : DEFAULT_CONFIG.bannerTitle,
+		bannerMessage: typeof o.bannerMessage === "string" ? o.bannerMessage : DEFAULT_CONFIG.bannerMessage,
+		privacyPolicyUrl: typeof o.privacyPolicyUrl === "string" ? o.privacyPolicyUrl : DEFAULT_CONFIG.privacyPolicyUrl,
+		cookiePolicyUrl: typeof o.cookiePolicyUrl === "string" ? o.cookiePolicyUrl : DEFAULT_CONFIG.cookiePolicyUrl,
+		strictDefaults: typeof o.strictDefaults === "boolean" ? o.strictDefaults : DEFAULT_CONFIG.strictDefaults,
+		policyVersion: typeof o.policyVersion === "string" && o.policyVersion.length > 0 ? o.policyVersion : DEFAULT_CONFIG.policyVersion,
+		cloudflareWebAnalyticsToken: cfTok,
+		analyticsProvider,
+		analyticsScriptUrls: analytics,
+		marketingScriptUrls: marketing,
+		googleConsentMode: typeof o.googleConsentMode === "boolean" ? o.googleConsentMode : DEFAULT_CONFIG.googleConsentMode,
+		logConsentToServer: typeof o.logConsentToServer === "boolean" ? o.logConsentToServer : DEFAULT_CONFIG.logConsentToServer
+	};
+}
+/** Validate admin-submitted fields; throws an Error with a short message on failure */
+function assertValidSavedConfig(input) {
+	assertLength("Policy version", input.policyVersion, 1, 64);
+	assertOptionalLength("Banner title", input.bannerTitle, 120);
+	assertOptionalLength("Short notice", input.bannerMessage, 600);
+	const privacyPolicyUrl = input.privacyPolicyUrl.trim();
+	if (!isValidPolicyHrefInput(privacyPolicyUrl)) throw new Error("Privacy policy must be a full https:// URL or a site path to your EmDash Page (e.g. /privacy).");
+	if (privacyPolicyUrl.length > 2048) throw new Error("Privacy policy URL/path is too long.");
+	let cookiePolicyUrl = input.cookiePolicyUrl.trim();
+	if (cookiePolicyUrl && !isValidPolicyHrefInput(cookiePolicyUrl)) throw new Error("Cookie policy must be a valid https:// URL or a root-relative path (e.g. /cookies), or empty.");
+	if (cookiePolicyUrl.length > 2048) throw new Error("Cookie policy URL/path is too long.");
+	if (!cookiePolicyUrl) cookiePolicyUrl = DEFAULT_CONFIG.cookiePolicyUrl;
+	const ap = input.analyticsPlatform.trim() || "cloudflare";
+	if (!isAnalyticsProvider(ap)) throw new Error("Analytics: choose a supported option (Cloudflare, None, or Custom).");
+	const tokenTrim = input.cloudflareToken.trim();
+	if (ap === "cloudflare") assertValidCloudflareToken(tokenTrim);
+	const analyticsScriptUrls = [];
+	if (ap === "custom") {
+		const list = parseUrlList(input.analyticsUrlsText);
+		if (list.length > 50) throw new Error("Analytics script URL list is too long (max 50).");
+		for (const u of list) {
+			if (u.length > 2048) throw new Error(invalidScriptUrlError("analytics", u));
+			if (!isHttpsUrl(u)) throw new Error(invalidScriptUrlError("analytics", u));
+			analyticsScriptUrls.push(u);
+		}
+	}
+	const marketingScriptUrls = [];
+	const mlist = parseUrlList(input.marketingUrlsText);
+	if (mlist.length > 50) throw new Error("Marketing script URL list is too long (max 50).");
+	for (const u of mlist) {
+		if (u.length > 2048) throw new Error(invalidScriptUrlError("marketing", u));
+		if (!isHttpsUrl(u)) throw new Error(invalidScriptUrlError("marketing", u));
+		marketingScriptUrls.push(u);
+	}
+	return normalizeConfig({
+		bannerTitle: input.bannerTitle.trim() || DEFAULT_CONFIG.bannerTitle,
+		bannerMessage: input.bannerMessage.trim() || DEFAULT_CONFIG.bannerMessage,
+		privacyPolicyUrl,
+		cookiePolicyUrl,
+		strictDefaults: input.strictDefaults,
+		policyVersion: input.policyVersion.trim(),
+		analyticsProvider: ap,
+		cloudflareWebAnalyticsToken: ap === "cloudflare" ? tokenTrim : "",
+		analyticsScriptUrls: ap === "custom" ? analyticsScriptUrls : [],
+		marketingScriptUrls,
+		googleConsentMode: input.googleConsentMode,
+		logConsentToServer: input.logConsentToServer
+	});
+}
+
+//#endregion
+export { assertValidCloudflareToken as a, isValidPolicyHrefInput as c, PLUGIN_ID as i, normalizeConfig as l, DEFAULT_CONFIG as n, assertValidSavedConfig as o, KV_KEY as r, isRootRelativeSitePath as s, COOKIE_NAME as t, resolvePolicyHref as u };

package/dist/config-CqOtRoQR.d.mts

@@ -0,0 +1,63 @@
+//#region src/config.d.ts
+/**
+ * EmPrivacy KV document (`consent:config`) and shared helpers.
+ */
+declare const KV_KEY: "consent:config";
+declare const COOKIE_NAME: "emprivacy_cc";
+/** How analytics scripts are chosen after the user consents to analytics. */
+type AnalyticsProvider = "cloudflare" | "none" | "custom";
+interface EmprivacyConfig {
+  bannerTitle: string;
+  bannerMessage: string;
+  /**
+   * Privacy policy location: full `https://…` URL **or** a root-relative path to an EmDash **Page**
+   * (e.g. `/privacy`) resolved with `ctx.url()` on the server.
+   */
+  privacyPolicyUrl: string;
+  /** Optional cookie policy: same rules as `privacyPolicyUrl` (https URL or path like `/cookies`) */
+  cookiePolicyUrl: string;
+  /** When true, analytics/marketing require explicit opt-in in the UI */
+  strictDefaults: boolean;
+  /** Bump to invalidate client consent cookies and re-show the banner */
+  policyVersion: string;
+  /**
+   * Analytics when `cloudflare` — **site token** from Cloudflare → Web Analytics (injected with `data-cf-beacon`).
+   * Public in the same way as a normal site embed. Empty means no Cloudflare script until a token is saved.
+   */
+  cloudflareWebAnalyticsToken: string;
+  /**
+   * Which analytics load path to use after consent. `cloudflare` = beacon + `cloudflareWebAnalyticsToken`;
+   * `custom` = `analyticsScriptUrls` only; `none` = no third-party analytics scripts.
+   */
+  analyticsProvider: AnalyticsProvider;
+  /** When `analyticsProvider` is `custom`, these https script URLs load after analytics consent. */
+  analyticsScriptUrls: string[];
+  /** Third-party script URLs loaded only after marketing consent (https only) */
+  marketingScriptUrls: string[];
+  /** Emit Google Consent Mode v2 defaults (denied) in head; updates after choice */
+  googleConsentMode: boolean;
+  /** POST consent snapshots to the plugin record route and optional storage */
+  logConsentToServer: boolean;
+}
+declare const DEFAULT_CONFIG: EmprivacyConfig;
+/** Reject characters that would break JSON or attributes; allow typical Cloudflare site token strings. */
+declare function assertValidCloudflareToken(t: string): void;
+/**
+ * Root-relative public path (EmDash page route), e.g. `/privacy`.
+ * Rejects protocol-relative URLs (`//…`) and whitespace.
+ */
+declare function isRootRelativeSitePath(s: string): boolean;
+/** For hooks: turn stored path or absolute URL into a public absolute URL. */
+declare function resolvePolicyHref(stored: string, ctx: {
+  url: (path: string) => string;
+}): string;
+declare function isValidPolicyHrefInput(s: string): boolean;
+declare function normalizeConfig(raw: unknown): EmprivacyConfig;
+interface ConsentRecordPayload {
+  createdAt: string;
+  policyVersion: string;
+  analytics: boolean;
+  marketing: boolean;
+}
+//#endregion
+export { EmprivacyConfig as a, isRootRelativeSitePath as c, resolvePolicyHref as d, DEFAULT_CONFIG as i, isValidPolicyHrefInput as l, COOKIE_NAME as n, KV_KEY as o, ConsentRecordPayload as r, assertValidCloudflareToken as s, AnalyticsProvider as t, normalizeConfig as u };

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import { a as EmprivacyConfig, c as isRootRelativeSitePath, d as resolvePolicyHref, i as DEFAULT_CONFIG, l as isValidPolicyHrefInput, n as COOKIE_NAME, o as KV_KEY, r as ConsentRecordPayload, s as assertValidCloudflareToken, t as AnalyticsProvider, u as normalizeConfig } from "./config-CqOtRoQR.mjs";
+import { PluginDescriptor } from "emdash";
+
+//#region src/index.d.ts
+/**
+ * EmDash plugin descriptor — add to `plugins: []` in `emdash({ ... })` inside `astro.config`.
+ * Requires **trusted** registration so `page:metadata` / `page:fragments` run (sandboxed plugins cannot inject fragments).
+ */
+declare function emprivacyPlugin(): PluginDescriptor;
+//#endregion
+export { type AnalyticsProvider, COOKIE_NAME, type ConsentRecordPayload, DEFAULT_CONFIG, type EmprivacyConfig, KV_KEY, assertValidCloudflareToken, emprivacyPlugin, isRootRelativeSitePath, isValidPolicyHrefInput, normalizeConfig, resolvePolicyHref };

package/dist/index.mjs

@@ -0,0 +1,29 @@
+import { a as assertValidCloudflareToken, c as isValidPolicyHrefInput, i as PLUGIN_ID, l as normalizeConfig, n as DEFAULT_CONFIG, r as KV_KEY, s as isRootRelativeSitePath, t as COOKIE_NAME, u as resolvePolicyHref } from "./config-BJ1LHuri.mjs";
+
+//#region src/version.ts
+const VERSION = "1.0.0";
+
+//#endregion
+//#region src/index.ts
+/**
+* EmDash plugin descriptor — add to `plugins: []` in `emdash({ ... })` inside `astro.config`.
+* Requires **trusted** registration so `page:metadata` / `page:fragments` run (sandboxed plugins cannot inject fragments).
+*/
+function emprivacyPlugin() {
+	return {
+		id: PLUGIN_ID,
+		version: VERSION,
+		format: "standard",
+		entrypoint: "@emplugins/emprivacy/sandbox",
+		capabilities: ["hooks.page-fragments:register"],
+		storage: { consentEvents: { indexes: ["createdAt", "policyVersion"] } },
+		adminPages: [{
+			path: "/settings",
+			label: "EmPrivacy",
+			icon: "shield"
+		}]
+	};
+}
+
+//#endregion
+export { COOKIE_NAME, DEFAULT_CONFIG, KV_KEY, assertValidCloudflareToken, emprivacyPlugin, isRootRelativeSitePath, isValidPolicyHrefInput, normalizeConfig, resolvePolicyHref };