emdash-header-footer-code 0.1.0

package/dist/plugin.mjs

@@ -0,0 +1,608 @@
+import { n as PLUGIN_VERSION, t as PLUGIN_ID } from "./version-iEzwHCKh.mjs";
+import { PluginRouteError, definePlugin } from "emdash";
+
+//#region src/core/paths.ts
+const WHITESPACE = /\s/;
+const TRAILING_SLASHES = /\/+$/;
+/** Returns an error message, or null when the pattern is valid. */
+function validatePattern(pattern) {
+	if (!pattern.startsWith("/")) return "Path must start with /";
+	if (WHITESPACE.test(pattern)) return "Path must not contain whitespace";
+	const star = pattern.indexOf("*");
+	if (star !== -1 && star !== pattern.length - 1) return "* is only allowed at the end of a path";
+	return null;
+}
+/** Strip trailing slashes, keeping "/" for the root. Case-sensitive. */
+function normalizePath(path) {
+	if (path === "/") return path;
+	const stripped = path.replace(TRAILING_SLASHES, "");
+	return stripped === "" ? "/" : stripped;
+}
+/**
+* Decode a percent-encoded path (page paths come from url.pathname, so `café` arrives as
+* `caf%C3%A9`). Malformed escapes fall back to the raw path instead of throwing.
+*/
+function safeDecodePath(path) {
+	try {
+		return decodeURI(path);
+	} catch {
+		return path;
+	}
+}
+/**
+* Compile a validated pattern into a matcher. Throws on invalid patterns.
+* Matching runs on decoded paths: both the page path and the pattern are decoded, so an
+* admin can type `/blog/café/*` (or the encoded form) and it matches `/blog/caf%C3%A9/x`.
+*/
+function compilePattern(pattern) {
+	const error = validatePattern(pattern);
+	if (error) throw new Error(error);
+	if (pattern.endsWith("*")) {
+		const prefix = safeDecodePath(pattern.slice(0, -1));
+		return (path) => normalizePath(safeDecodePath(path)).startsWith(prefix);
+	}
+	const exact = normalizePath(safeDecodePath(pattern));
+	return (path) => normalizePath(safeDecodePath(path)) === exact;
+}
+
+//#endregion
+//#region src/core/match.ts
+function isAdminPath(path) {
+	return path.startsWith("/_emdash/");
+}
+function compileSnippet(snippet) {
+	return {
+		snippet,
+		include: snippet.includePaths.map(compilePattern),
+		exclude: snippet.excludePaths.map(compilePattern)
+	};
+}
+function compareSnippets(a, b) {
+	if (a.priority !== b.priority) return a.priority - b.priority;
+	if (a.createdAt !== b.createdAt) return a.createdAt < b.createdAt ? -1 : 1;
+	return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+/** Enabled snippets, sorted, with compiled matchers. Invalid ones are skipped and logged. */
+function prepareSnippets(list, log) {
+	const out = [];
+	for (const snippet of [...list].sort(compareSnippets)) {
+		if (!snippet.enabled) continue;
+		try {
+			out.push(compileSnippet(snippet));
+		} catch (error) {
+			log.warn("Skipping snippet with an invalid path pattern", {
+				snippetId: snippet.id,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	return out;
+}
+function matchesPage(c, page) {
+	const { snippet } = c;
+	if (snippet.pageKind !== "all" && snippet.pageKind !== page.kind) return false;
+	if (snippet.locales.length > 0 && (page.locale === null || !snippet.locales.includes(page.locale))) return false;
+	if (c.include.length > 0 && !c.include.some((m) => m(page.path))) return false;
+	if (c.exclude.some((m) => m(page.path))) return false;
+	return true;
+}
+
+//#endregion
+//#region src/core/types.ts
+const PLACEMENTS = [
+	"head",
+	"body:start",
+	"body:end"
+];
+const PAGE_KINDS = [
+	"all",
+	"content",
+	"custom"
+];
+const DEFAULT_STATE = {
+	rev: 0,
+	disabled: false
+};
+
+//#endregion
+//#region src/core/validate.ts
+const LIMITS = {
+	maxSnippetBytes: 64 * 1024,
+	maxTotalBytes: 512 * 1024,
+	maxSnippets: 100,
+	maxNameLength: 200
+};
+const encoder = new TextEncoder();
+function byteLength(s) {
+	return encoder.encode(s).length;
+}
+function formatKB(bytes) {
+	return `${(bytes / 1024).toFixed(1)} KB`;
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function stringList(v) {
+	if (v === void 0) return [];
+	if (!Array.isArray(v) || !v.every((x) => typeof x === "string")) return null;
+	return v.map((x) => x.trim()).filter((x) => x !== "");
+}
+function pathListError(list) {
+	for (const p of list) {
+		const err = validatePattern(p);
+		if (err) return `${p}: ${err}`;
+	}
+	return null;
+}
+function validateSnippetInput(input) {
+	if (!isPlainObject(input)) return {
+		ok: false,
+		errors: { _form: "Invalid request body" }
+	};
+	const errors = {};
+	const name = typeof input.name === "string" ? input.name.trim() : "";
+	if (!name) errors.name = "Name is required";
+	else if (name.length > LIMITS.maxNameLength) errors.name = "Name must be at most 200 characters";
+	const code = typeof input.code === "string" ? input.code : "";
+	if (code.trim() === "") errors.code = "Code is required";
+	const placement = input.placement ?? "head";
+	if (!PLACEMENTS.includes(placement)) errors.placement = `Placement must be one of ${PLACEMENTS.join(", ")}`;
+	const pageKind = input.pageKind ?? "all";
+	if (!PAGE_KINDS.includes(pageKind)) errors.pageKind = `Page kind must be one of ${PAGE_KINDS.join(", ")}`;
+	const enabled = input.enabled ?? true;
+	if (typeof enabled !== "boolean") errors.enabled = "Enabled must be true or false";
+	const priority = input.priority ?? 10;
+	if (typeof priority !== "number" || !Number.isInteger(priority)) errors.priority = "Priority must be a whole number";
+	const includePaths = stringList(input.includePaths);
+	if (includePaths === null) errors.includePaths = "Include paths must be a list of paths";
+	else {
+		const err = pathListError(includePaths);
+		if (err) errors.includePaths = err;
+	}
+	const excludePaths = stringList(input.excludePaths);
+	if (excludePaths === null) errors.excludePaths = "Exclude paths must be a list of paths";
+	else {
+		const err = pathListError(excludePaths);
+		if (err) errors.excludePaths = err;
+	}
+	let locales = [];
+	if (input.locales !== void 0) if (!Array.isArray(input.locales) || !input.locales.every((l) => typeof l === "string" && l.trim() !== "")) errors.locales = "Locales must be non-empty strings";
+	else locales = input.locales.map((l) => l.trim());
+	let meta;
+	if (input.meta !== void 0) if (!isPlainObject(input.meta)) errors.meta = "Meta must be an object";
+	else meta = input.meta;
+	if (Object.keys(errors).length > 0) return {
+		ok: false,
+		errors
+	};
+	return {
+		ok: true,
+		value: {
+			name,
+			code,
+			placement,
+			enabled,
+			priority,
+			includePaths,
+			excludePaths,
+			pageKind,
+			locales,
+			meta
+		}
+	};
+}
+/** Size and count limits. `candidate.id` set = update of an existing snippet. */
+function checkLimits(candidate, existing) {
+	if (!(candidate.id !== void 0 && existing.some((s) => s.id === candidate.id)) && existing.length >= LIMITS.maxSnippets) return { _form: `You can have at most ${LIMITS.maxSnippets} snippets` };
+	const size = byteLength(candidate.code);
+	if (size > LIMITS.maxSnippetBytes) return { code: `Code is ${formatKB(size)}; the limit is 64 KB per snippet` };
+	const total = existing.filter((s) => s.id !== candidate.id).reduce((sum, s) => sum + byteLength(s.code), 0) + size;
+	if (total > LIMITS.maxTotalBytes) return { code: `Total code would be ${formatKB(total)}; the limit is 512 KB across all snippets` };
+	return null;
+}
+
+//#endregion
+//#region src/repo.ts
+/**
+* All snippets in one query. The 100-snippet cap keeps this to a single page.
+* The cap check (checkLimits) and the write are not atomic, so concurrent creates can push
+* the stored count past 100; snippets beyond the first 100 (by createdAt) are then not
+* loaded. Acceptable for v0.1.
+*/
+async function loadAllSnippets(c) {
+	const { items } = await c.query({
+		orderBy: { createdAt: "asc" },
+		limit: LIMITS.maxSnippets
+	});
+	return items.map((i) => i.data);
+}
+function userRef(user) {
+	return user ? {
+		id: user.id,
+		name: user.name,
+		email: user.email
+	} : {
+		id: "unknown",
+		name: null,
+		email: null
+	};
+}
+async function appendLog(c, entry, newId) {
+	const full = {
+		id: newId(),
+		...entry
+	};
+	await c.put(full.id, full);
+	return full;
+}
+async function listLog(c) {
+	const { items } = await c.query({
+		orderBy: { at: "desc" },
+		limit: 100
+	});
+	return items.map((i) => i.data);
+}
+
+//#endregion
+//#region src/state.ts
+const STATE_KEY = "state";
+const MAX_ATTEMPTS = 5;
+async function readState(kv) {
+	return await kv.get(STATE_KEY) ?? { ...DEFAULT_STATE };
+}
+/** Atomically bump `rev` (and optionally set `disabled`). Retries on conflict. */
+async function bumpState(kv, change = {}) {
+	for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+		const current = await kv.getVersioned(STATE_KEY);
+		const base = current?.value ?? DEFAULT_STATE;
+		const next = {
+			...base,
+			...change,
+			rev: base.rev + 1
+		};
+		if ((await kv.compareAndSet(STATE_KEY, current?.revision ?? null, next)).applied) return next;
+	}
+	throw new Error(`Could not update plugin state after ${MAX_ATTEMPTS} attempts`);
+}
+
+//#endregion
+//#region src/cache.ts
+/**
+* Per-isolate cache. The kv `state` read is shared for `stateTtlMs`. This covers
+* the up-to-3 page:fragments calls per request and bursts of concurrent requests.
+* The compiled snippet list is rebuilt only when `state.rev` changes.
+*/
+function createSnippetCache(opts = {}) {
+	const now = opts.now ?? Date.now;
+	const ttl = opts.stateTtlMs ?? 1e3;
+	let statePromise = null;
+	let stateReadAt = 0;
+	let cachedRev = null;
+	let compiled = [];
+	function getState(ctx) {
+		const t = now();
+		if (!statePromise || t - stateReadAt >= ttl) {
+			stateReadAt = t;
+			const p = readState(ctx.kv);
+			statePromise = p;
+			p.catch(() => {
+				if (statePromise === p) statePromise = null;
+			});
+		}
+		return statePromise;
+	}
+	return {
+		async load(ctx) {
+			const state = await getState(ctx);
+			if (state.disabled) return {
+				disabled: true,
+				snippets: []
+			};
+			if (cachedRev !== state.rev) {
+				compiled = prepareSnippets(await loadAllSnippets(ctx.storage.snippets), ctx.log);
+				cachedRev = state.rev;
+			}
+			return {
+				disabled: false,
+				snippets: compiled
+			};
+		},
+		invalidate() {
+			statePromise = null;
+		}
+	};
+}
+
+//#endregion
+//#region src/core/pipeline.ts
+/** match → (already sorted) → transform → emit */
+function renderFragments(compiled, page, transforms, log) {
+	const snippetFragments = [];
+	const extraFragments = [];
+	const seenExtraKeys = /* @__PURE__ */ new Set();
+	for (const c of compiled) {
+		if (!matchesPage(c, page)) continue;
+		const { snippet } = c;
+		let html = snippet.code;
+		for (let i = 0; i < transforms.length && html !== null; i++) {
+			const transform = transforms[i];
+			try {
+				const result = transform({
+					snippet,
+					html,
+					page
+				});
+				if (result === null || typeof result === "string") html = result;
+				else {
+					html = result.html;
+					for (const fragment of result.fragments ?? []) {
+						if (fragment.key !== void 0) {
+							if (seenExtraKeys.has(fragment.key)) continue;
+							seenExtraKeys.add(fragment.key);
+						}
+						extraFragments.push(fragment);
+					}
+				}
+			} catch (error) {
+				log.error("Snippet transform failed; skipping snippet", {
+					snippetId: snippet.id,
+					transformIndex: i,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				html = null;
+			}
+		}
+		if (html !== null) snippetFragments.push({
+			kind: "html",
+			placement: snippet.placement,
+			html,
+			key: `hfc-${snippet.id}`
+		});
+	}
+	return [...snippetFragments, ...extraFragments];
+}
+
+//#endregion
+//#region src/hook.ts
+function createFragmentsHandler(cache, transforms) {
+	return async function handlePageFragments(event, ctx) {
+		const { page } = event;
+		if (isAdminPath(page.path)) return null;
+		try {
+			const { disabled, snippets } = await cache.load(ctx);
+			if (disabled || snippets.length === 0) return null;
+			const fragments = renderFragments(snippets, page, transforms, ctx.log);
+			return fragments.length > 0 ? fragments : null;
+		} catch (error) {
+			ctx.log.error("Header & Footer Code: failed to render snippets", { error: error instanceof Error ? error.message : String(error) });
+			return null;
+		}
+	};
+}
+
+//#endregion
+//#region src/routes.ts
+/** Mirrors Role.ADMIN in @emdash-cms/auth (plugins:manage). */
+const ROLE_ADMIN = 50;
+const SCHEMA_VERSION = 1;
+function cols(ctx) {
+	return {
+		snippets: ctx.storage.snippets,
+		changelog: ctx.storage.changelog
+	};
+}
+function body(ctx) {
+	const input = ctx.input;
+	return typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
+}
+function requireId(ctx) {
+	const id = body(ctx).id;
+	if (typeof id !== "string" || id === "") throw PluginRouteError.badRequest("Missing snippet id");
+	return id;
+}
+async function requireSnippet(ctx, id) {
+	const snippet = await cols(ctx).snippets.get(id);
+	if (!snippet) throw new PluginRouteError("NOT_FOUND", "Snippet not found", 404);
+	return snippet;
+}
+/**
+* 400 with field errors. EmDash 1.0.1's HTTP dispatch forwards only `code` and `message`
+* (it drops `details`), so the message itself must be the readable error text.
+*/
+function validationError(errors) {
+	return PluginRouteError.badRequest(Object.values(errors).join("; "), { errors });
+}
+function assertWritable(snippet) {
+	if (snippet.schemaVersion > SCHEMA_VERSION) throw new PluginRouteError("UNSUPPORTED_SCHEMA", "This snippet was saved by a newer version of the plugin. Upgrade the plugin to edit it.", 409);
+}
+function createRoutes(deps) {
+	/**
+	* Bump rev, invalidate, then log. Runs after every successful record write.
+	*
+	* Rev moves first so a failed change-log write can never leave isolates serving stale
+	* output (e.g. a deleted snippet still rendering). A failed log write is reported via
+	* ctx.log.error and does not fail the request: the record write already happened, so a
+	* 5xx would mislead the admin into retrying (a duplicate create, or a 404 on delete).
+	* A lost audit row is the lesser harm.
+	*/
+	async function afterWrite(ctx, action, snippet, change) {
+		const state = await bumpState(ctx.kv, change);
+		deps.cache.invalidate();
+		try {
+			await appendLog(cols(ctx).changelog, {
+				at: deps.now(),
+				user: userRef(ctx.user),
+				action,
+				snippetId: snippet?.id ?? null,
+				snippetName: snippet?.name ?? null
+			}, deps.newId);
+		} catch (error) {
+			ctx.log.error("header-footer-code: could not write change-log entry", {
+				action,
+				snippetId: snippet?.id ?? null,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+		return state;
+	}
+	return {
+		"snippets/list": {
+			permission: "plugins:read",
+			handler: async (ctx) => {
+				const canManage = (ctx.user?.role ?? 0) >= ROLE_ADMIN;
+				const [state, all] = await Promise.all([readState(ctx.kv), loadAllSnippets(cols(ctx).snippets)]);
+				const snippets = canManage ? all : all.map(({ code: _code, ...rest }) => rest);
+				return {
+					disabled: state.disabled,
+					canManage,
+					snippets
+				};
+			}
+		},
+		"snippets/get": {
+			permission: "plugins:manage",
+			handler: async (ctx) => ({ snippet: await requireSnippet(ctx, requireId(ctx)) })
+		},
+		"snippets/save": {
+			permission: "plugins:manage",
+			handler: async (ctx) => {
+				const input = body(ctx);
+				const id = typeof input.id === "string" && input.id !== "" ? input.id : void 0;
+				const result = validateSnippetInput(input);
+				if (!result.ok) throw validationError(result.errors);
+				const all = await loadAllSnippets(cols(ctx).snippets);
+				const existing = id ? all.find((s) => s.id === id) : void 0;
+				if (id && !existing) throw new PluginRouteError("NOT_FOUND", "Snippet not found", 404);
+				if (existing) assertWritable(existing);
+				const limitErrors = checkLimits({
+					id,
+					code: result.value.code
+				}, all);
+				if (limitErrors) throw validationError(limitErrors);
+				const now = deps.now();
+				const user = userRef(ctx.user);
+				const { meta, ...fields } = result.value;
+				const snippet = existing ? {
+					...existing,
+					...fields,
+					meta: meta ?? existing.meta,
+					updatedAt: now,
+					updatedBy: user
+				} : {
+					id: deps.newId(),
+					schemaVersion: SCHEMA_VERSION,
+					...fields,
+					meta: meta ?? {},
+					createdAt: now,
+					updatedAt: now,
+					createdBy: user,
+					updatedBy: user
+				};
+				await cols(ctx).snippets.put(snippet.id, snippet);
+				await afterWrite(ctx, existing ? "update" : "create", snippet);
+				return { snippet };
+			}
+		},
+		"snippets/toggle": {
+			permission: "plugins:manage",
+			handler: async (ctx) => {
+				const id = requireId(ctx);
+				const enabled = body(ctx).enabled;
+				if (typeof enabled !== "boolean") throw PluginRouteError.badRequest("enabled must be true or false");
+				const current = await requireSnippet(ctx, id);
+				assertWritable(current);
+				const snippet = {
+					...current,
+					enabled,
+					updatedAt: deps.now(),
+					updatedBy: userRef(ctx.user)
+				};
+				await cols(ctx).snippets.put(id, snippet);
+				await afterWrite(ctx, enabled ? "enable" : "disable", snippet);
+				return { snippet };
+			}
+		},
+		"snippets/duplicate": {
+			permission: "plugins:manage",
+			handler: async (ctx) => {
+				const source = await requireSnippet(ctx, requireId(ctx));
+				const all = await loadAllSnippets(cols(ctx).snippets);
+				const limitErrors = checkLimits({ code: source.code }, all);
+				if (limitErrors) throw validationError(limitErrors);
+				const now = deps.now();
+				const user = userRef(ctx.user);
+				const snippet = {
+					...structuredClone(source),
+					id: deps.newId(),
+					name: `${source.name} (copy)`.slice(0, 200),
+					enabled: false,
+					createdAt: now,
+					updatedAt: now,
+					createdBy: user,
+					updatedBy: user
+				};
+				await cols(ctx).snippets.put(snippet.id, snippet);
+				await afterWrite(ctx, "duplicate", snippet);
+				return { snippet };
+			}
+		},
+		"snippets/delete": {
+			permission: "plugins:manage",
+			handler: async (ctx) => {
+				const snippet = await requireSnippet(ctx, requireId(ctx));
+				await cols(ctx).snippets.delete(snippet.id);
+				await afterWrite(ctx, "delete", snippet);
+				return { deleted: true };
+			}
+		},
+		"killswitch/set": {
+			permission: "plugins:manage",
+			handler: async (ctx) => {
+				const disabled = body(ctx).disabled;
+				if (typeof disabled !== "boolean") throw PluginRouteError.badRequest("disabled must be true or false");
+				return { disabled: (await afterWrite(ctx, disabled ? "killswitch_on" : "killswitch_off", null, { disabled })).disabled };
+			}
+		},
+		"changelog/list": {
+			permission: "plugins:manage",
+			handler: async (ctx) => ({ entries: await listLog(cols(ctx).changelog) })
+		}
+	};
+}
+
+//#endregion
+//#region src/plugin.ts
+const BUILTIN_TRANSFORMS = [];
+const ADMIN_ENTRY = "emdash-header-footer-code/admin";
+const ADMIN_PAGES = [{
+	path: "/snippets",
+	label: "Header & Footer Code",
+	icon: "code"
+}];
+function createPlugin(options = {}) {
+	const transforms = [...BUILTIN_TRANSFORMS, ...options.transforms ?? []];
+	const cache = createSnippetCache();
+	const fragments = createFragmentsHandler(cache, transforms);
+	return definePlugin({
+		id: PLUGIN_ID,
+		version: PLUGIN_VERSION,
+		capabilities: ["hooks.page-fragments:register"],
+		storage: {
+			snippets: { indexes: ["createdAt"] },
+			changelog: { indexes: ["at"] }
+		},
+		admin: {
+			entry: ADMIN_ENTRY,
+			pages: ADMIN_PAGES
+		},
+		hooks: { "page:fragments": { handler: (event, ctx) => fragments(event, ctx) } },
+		routes: createRoutes({
+			cache,
+			now: () => (/* @__PURE__ */ new Date()).toISOString(),
+			newId: () => crypto.randomUUID()
+		})
+	});
+}
+
+//#endregion
+export { ADMIN_ENTRY, ADMIN_PAGES, createPlugin };

package/dist/types-CNDv5vQX.d.mts

@@ -0,0 +1,46 @@
+import { PageFragmentContribution, PublicPageContext } from "emdash";
+
+//#region src/core/types.d.ts
+declare const PLACEMENTS: readonly ["head", "body:start", "body:end"];
+type Placement = (typeof PLACEMENTS)[number];
+declare const PAGE_KINDS: readonly ["all", "content", "custom"];
+type PageKind = (typeof PAGE_KINDS)[number];
+interface UserRef {
+  id: string;
+  name: string | null;
+  email: string | null;
+}
+/** Fields an admin edits. */
+interface EditableSnippet {
+  name: string;
+  code: string;
+  placement: Placement;
+  enabled: boolean;
+  priority: number;
+  includePaths: string[];
+  excludePaths: string[];
+  pageKind: PageKind;
+  locales: string[];
+  meta: Record<string, unknown>;
+}
+interface Snippet extends EditableSnippet {
+  id: string;
+  schemaVersion: number;
+  createdAt: string;
+  updatedAt: string;
+  createdBy: UserRef;
+  updatedBy: UserRef;
+}
+type PageInfo = PublicPageContext;
+interface TransformContext {
+  snippet: Readonly<Snippet>;
+  html: string;
+  page: Readonly<PageInfo>;
+}
+type TransformResult = string | null | {
+  html: string | null;
+  fragments?: PageFragmentContribution[];
+};
+type Transform = (ctx: TransformContext) => TransformResult;
+//#endregion
+export { TransformResult as i, Transform as n, TransformContext as r, Snippet as t };

package/dist/version-iEzwHCKh.mjs

@@ -0,0 +1,6 @@
+//#region src/version.ts
+const PLUGIN_ID = "header-footer-code";
+const PLUGIN_VERSION = "0.1.0";
+
+//#endregion
+export { PLUGIN_VERSION as n, PLUGIN_ID as t };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "emdash-header-footer-code",
+  "version": "0.1.0",
+  "description": "Add custom code snippets (analytics, verification tags, chat widgets, CSS/JS) to the head or body of EmDash pages — no theme edits.",
+  "repository": { "type": "git", "url": "git+https://github.com/jithinsk/emdash-header-footer-code.git" },
+  "homepage": "https://github.com/jithinsk/emdash-header-footer-code#readme",
+  "bugs": { "url": "https://github.com/jithinsk/emdash-header-footer-code/issues" },
+  "type": "module",
+  "license": "MIT",
+  "keywords": ["emdash", "emdash-plugin", "cms", "header", "footer", "snippets", "analytics"],
+  "exports": {
+    ".": { "types": "./dist/index.d.mts", "default": "./dist/index.mjs" },
+    "./plugin": { "types": "./dist/plugin.d.mts", "default": "./dist/plugin.mjs" },
+    "./admin": "./src/admin/index.tsx"
+  },
+  "files": ["dist", "src/admin", "src/core", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "e2e": "pnpm build && playwright test -c e2e/playwright.config.ts",
+    "smoke": "node scripts/smoke-pack.mjs"
+  },
+  "peerDependencies": {
+    "emdash": "^1.0.1",
+    "react": "^18.0.0 || ^19.0.0",
+    "@cloudflare/kumo": "^2.6.0"
+  },
+  "devDependencies": {
+    "@axe-core/playwright": "^4.13.0",
+    "@astrojs/react": "^6.0.5",
+    "@cloudflare/kumo": "2.6.0",
+    "@playwright/test": "^1.56.0",
+    "@types/react": "19.2.14",
+    "better-sqlite3": "^12.4.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "emdash": "1.0.1",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "tsdown": "0.20.3",
+    "typescript": "^6.0.3",
+    "vitest": "4.1.10"
+  },
+  "packageManager": "pnpm@10.33.0",
+  "pnpm": { "onlyBuiltDependencies": ["better-sqlite3", "esbuild"] }
+}