emdash 0.32.0 → 0.34.0

package/src/taxonomies/term-counts.ts

@@ -5,10 +5,8 @@
  * and are never pruned on unpublish/trash, so counting the pivot directly
  * inflates counts with drafts and soft-deleted entries. Every user-facing
  * count (public widget, single-term page, admin term list) must instead count
- * only entries that are currently visible on the public site:
- * `status = 'published'` OR (`status = 'scheduled'` AND due), AND
- * `deleted_at IS NULL` — via `buildStatusCondition`, which computes scheduled
- * visibility at query time rather than trusting a literal status value.
+ * only entries that have completed publication:
+ * `status = 'published'` AND `deleted_at IS NULL`.
  *
  * The public render path is latency-sensitive on D1, so per-collection counts
  * are combined with UNION ALL — one query per taxonomy, never one per
@@ -32,7 +30,8 @@ interface CountRow {
 /**
  * Per-collection count branch. `taxonomy_id` stores the term's
  * translation_group, so results are keyed by group (locale-independent) and
- * each assignment is counted once no matter how many locales the term has.
+ * each assignment is counted once per content translation group. When a
+ * locale is provided, only that group's matching content row contributes.
  *
  * Scoping to the taxonomy uses `translation_group IN (...)` rather than a
  * join on `taxonomies.id` — the anchor row (id == group) can be deleted while
@@ -41,20 +40,23 @@ interface CountRow {
  *
  * CROSS JOIN with the join predicate in WHERE keeps stats-blind SQLite/D1 from
  * reordering content_taxonomies out of the outer position; it touches ec_* only
- * by primary key. Postgres treats this as an ordinary inner join and plans freely.
+ * through the translation-group index. Postgres treats this as an ordinary
+ * inner join and plans freely.
  */
 function collectionBranch(
 	db: Kysely<Database>,
 	taxonomyName: string,
 	collection: string,
+	locale?: string,
 ): ReturnType<typeof sql> {
 	return sql`
-		SELECT ct.taxonomy_id AS taxonomy_id, COUNT(*) AS count
+		SELECT ct.taxonomy_id AS taxonomy_id, COUNT(DISTINCT e.translation_group) AS count
 		FROM content_taxonomies AS ct
 		CROSS JOIN ${sql.ref(`ec_${collection}`)} AS e
-		WHERE e.id = ct.entry_id
+		WHERE e.translation_group = ct.entry_id
 			AND ct.collection = ${collection}
 			AND ct.taxonomy_id IN (SELECT translation_group FROM taxonomies WHERE name = ${taxonomyName})
+			${locale ? sql`AND e.locale = ${locale}` : sql``}
 			AND ${buildStatusCondition(db, "published", "e")}
 			AND e.deleted_at IS NULL
 		GROUP BY ct.taxonomy_id`;
@@ -64,8 +66,11 @@ async function runCounts(
 	db: Kysely<Database>,
 	taxonomyName: string,
 	collections: string[],
+	locale?: string,
 ): Promise<Map<string, number>> {
-	const branches = collections.map((collection) => collectionBranch(db, taxonomyName, collection));
+	const branches = collections.map((collection) =>
+		collectionBranch(db, taxonomyName, collection, locale),
+	);
 	const union = sql.join(branches, sql` UNION ALL `);
 	const result = await sql<CountRow>`
 		SELECT taxonomy_id, SUM(count) AS count
@@ -89,9 +94,10 @@ async function runBatch(
 	db: Kysely<Database>,
 	taxonomyName: string,
 	collections: string[],
+	locale?: string,
 ): Promise<Map<string, number>> {
 	try {
-		return await runCounts(db, taxonomyName, collections);
+		return await runCounts(db, taxonomyName, collections, locale);
 	} catch (error) {
 		if (!isMissingTableError(error)) throw error;
 	}
@@ -99,7 +105,7 @@ async function runBatch(
 	const counts = new Map<string, number>();
 	for (const collection of collections) {
 		try {
-			addCounts(counts, await runCounts(db, taxonomyName, [collection]));
+			addCounts(counts, await runCounts(db, taxonomyName, [collection], locale));
 		} catch (error) {
 			if (!isMissingTableError(error)) throw error;
 		}
@@ -110,6 +116,8 @@ async function runBatch(
 /**
  * Count publicly-visible term assignments for one taxonomy, keyed by the
  * term's translation_group (what `content_taxonomies.taxonomy_id` stores).
+ * When `locale` is provided, only entries in that locale contribute. Omitting
+ * it preserves the locale-agnostic API used by legacy callers.
  *
  * Counts are scoped to the taxonomy's declared collections — pass
  * `TaxonomyDef.collections` (`_emdash_taxonomy_defs.collections`). Collections
@@ -132,6 +140,7 @@ export async function fetchVisibleTermCounts(
 	db: Kysely<Database>,
 	taxonomyName: string,
 	collections: string[],
+	locale?: string,
 ): Promise<Map<string, number>> {
 	const unique = [...new Set(collections)];
 	for (const collection of unique) validateIdentifier(collection, "collection slug");
@@ -139,7 +148,9 @@ export async function fetchVisibleTermCounts(
 
 	const limit = compoundSelectLimit(db);
 	const batched = limit === null ? [unique] : chunks(unique, limit);
-	const batches = await Promise.all(batched.map((batch) => runBatch(db, taxonomyName, batch)));
+	const batches = await Promise.all(
+		batched.map((batch) => runBatch(db, taxonomyName, batch, locale)),
+	);
 
 	const counts = new Map<string, number>();
 	for (const batch of batches) addCounts(counts, batch);

package/src/ui-comments.ts

@@ -0,0 +1,19 @@
+/**
+ * EmDash comment components
+ *
+ * Kept out of the main `emdash/ui` barrel so their styles are only loaded on
+ * pages that actually render comments. Importing from `emdash/ui` pulls the
+ * whole barrel into Astro's CSS module graph, which put comment CSS on every
+ * page that used e.g. `PortableText` (#2039).
+ *
+ * ```astro
+ * ---
+ * import { Comments, CommentForm } from "emdash/ui/comments";
+ * ---
+ * <Comments collection="posts" contentId={post.data.id} threaded />
+ * <CommentForm collection="posts" contentId={post.data.id} />
+ * ```
+ */
+
+export { default as Comments } from "./components/Comments.astro";
+export { default as CommentForm } from "./components/CommentForm.astro";

package/src/ui.ts

@@ -52,9 +52,6 @@ export {
 	// Shares the name with the `type Block` re-export above; the
 	// type and the component live in different namespaces.
 	Block,
-	// Comment components
-	Comments,
-	CommentForm,
 	// Widget components
 	WidgetArea,
 	// Components object for manual use
@@ -78,3 +75,14 @@ export {
 	EmDashBodyStart,
 	EmDashBodyEnd,
 } from "./components/index.js";
+
+/**
+ * @deprecated Import from `emdash/ui/comments` instead. Barrel re-exports pull
+ * comment CSS into every page that imports `emdash/ui` (#2039). Will be removed in 1.0.
+ */
+export { Comments } from "./components/index.js";
+/**
+ * @deprecated Import from `emdash/ui/comments` instead. Barrel re-exports pull
+ * comment CSS into every page that imports `emdash/ui` (#2039). Will be removed in 1.0.
+ */
+export { CommentForm } from "./components/index.js";

package/src/utils/slugify.ts

@@ -1,17 +1,5 @@
-// Regex patterns for slug normalization
-const DIACRITICS_PATTERN = /[\u0300-\u036f]/g;
-const WHITESPACE_UNDERSCORE_PATTERN = /[\s_]+/g;
-const NON_ALPHANUMERIC_HYPHEN_PATTERN = /[^a-z0-9-]/g;
-const MULTIPLE_HYPHENS_PATTERN = /-+/g;
-const LEADING_TRAILING_HYPHEN_PATTERN = /^-|-$/g;
-const TRAILING_HYPHEN_PATTERN = /-$/;
+export { slugify } from "@emdash-cms/admin/slugify";
 
-/**
- * Convert a string to a URL-friendly slug.
- *
- * Handles unicode by normalizing to NFD and stripping diacritics,
- * so "café" becomes "cafe", "naïve" becomes "naive", etc.
- */
 /**
  * Decode a URI-encoded slug parameter.
  *
@@ -22,19 +10,3 @@ const TRAILING_HYPHEN_PATTERN = /-$/;
 export function decodeSlug(raw: string | undefined): string | undefined {
 	return raw ? decodeURIComponent(raw) : undefined;
 }
-
-export function slugify(text: string, maxLength: number = 80): string {
-	return (
-		text
-			.toLowerCase()
-			.normalize("NFD")
-			.replace(DIACRITICS_PATTERN, "")
-			.replace(WHITESPACE_UNDERSCORE_PATTERN, "-")
-			.replace(NON_ALPHANUMERIC_HYPHEN_PATTERN, "")
-			.replace(MULTIPLE_HYPHENS_PATTERN, "-")
-			.replace(LEADING_TRAILING_HYPHEN_PATTERN, "")
-			.slice(0, maxLength)
-			// Clean trailing hyphen from truncation
-			.replace(TRAILING_HYPHEN_PATTERN, "")
-	);
-}

package/src/virtual-modules.d.ts

@@ -35,6 +35,7 @@ declare module "virtual:emdash/dialect" {
 	import type { Dialect, Kysely } from "kysely";
 
 	import type { DatabaseDialectType } from "./db/adapters.js";
+	import type { ExecuteCollectionDeletionGuard } from "./db/adapters.js";
 
 	// Can be undefined if no database configured, or the actual function
 	export const createDialect: ((config: unknown) => Dialect) | undefined;
@@ -54,11 +55,19 @@ declare module "virtual:emdash/dialect" {
 		config: unknown;
 		isAuthenticated: boolean;
 		isWrite: boolean;
+		/** Whether core routing allows this request to use an anonymous public-read cache. */
+		canUseCachedBinding?: boolean;
 		cookies: {
 			get(name: string): { value: string } | undefined;
 			set(name: string, value: string, options: Record<string, unknown>): void;
 		};
 		url: URL;
+		/**
+		 * ms-epoch of the last content-namespace object-cache invalidation.
+		 * Hyperdrive uses this (with `preferUncachedAfterWriteMs`) to briefly
+		 * prefer the primary uncached binding after a publish.
+		 */
+		lastContentWriteAt?: number;
 	}
 	export interface RequestScopedDb {
 		db: Kysely<unknown>;
@@ -74,6 +83,7 @@ declare module "virtual:emdash/dialect" {
 		close?: () => void;
 	}
 	export const createRequestScopedDb: (opts: RequestScopedDbOpts) => RequestScopedDb | null;
+	export const executeCollectionDeletionGuard: ExecuteCollectionDeletionGuard | undefined;
 }
 
 declare module "virtual:emdash/storage" {
@@ -170,6 +180,16 @@ declare module "virtual:emdash/env" {
 	export const env: Record<string, unknown> | undefined;
 }
 
+declare module "virtual:emdash/build" {
+	/**
+	 * Epoch milliseconds at which this build's virtual modules were generated.
+	 * Folded into the route cache validator so a code-only deploy — which
+	 * renames `/_astro/*` without touching content — still invalidates HTML a
+	 * browser cached from an earlier deployment.
+	 */
+	export const buildTime: number;
+}
+
 declare module "virtual:emdash/scheduler" {
 	import type { CreateSchedulerFn } from "./emdash-runtime.js";
 	/**
@@ -189,6 +209,8 @@ declare module "virtual:emdash/admin-registry" {
 	 *   - pages: Record<pageId, ComponentType>
 	 *   - widgets: Record<widgetId, ComponentType>
 	 *   - fields: Record<widgetName, ComponentType> (field widget renderers)
+	 *   - contentEditorPanels: Trusted content editor sidebar panels
+	 *   - contentListColumns: trusted-plugin content list column definitions
 	 */
 	export const pluginAdmins: Record<
 		string,
@@ -196,6 +218,8 @@ declare module "virtual:emdash/admin-registry" {
 			pages?: Record<string, unknown>;
 			widgets?: Record<string, unknown>;
 			fields?: Record<string, unknown>;
+			contentEditorPanels?: readonly unknown[];
+			contentListColumns?: readonly unknown[];
 		}
 	>;
 }

package/dist/adapters-C0ONzkUP.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapters-C0ONzkUP.d.mts","names":[],"sources":["../src/db/adapters.ts"],"mappings":";;AA0BA;;;;;AAKA;;;;;;;;;;;;AA8BA;;;;;AAOA;;KA1CY,mBAAA;;;AA+DZ;UA1DiB,kBAAA;EAChB,UAAA;EACA,MAAA;EACA,IAAA,EAAM,mBAAA;EAuDgB;;;;AAqBvB;;;;;;;;;AAWA;EAxEC,oBAAA;;;;;;;;;EASA,kBAAA;AAAA;AAAA,UAGgB,YAAA;EAoEO;;;EAhEvB,GAAA;AAAA;AAAA,UAGgB,YAAA;EA0EmD;;;EAtEnE,GAAA;EAsEmE;;;EAlEnE,SAAA;AAAA;;;;;;;;;;;iBAae,MAAA,CAAO,MAAA,EAAQ,YAAA,GAAe,kBAAA;;;;;;;;;;;;;;iBAqB9B,MAAA,CAAO,MAAA,EAAQ,YAAA,GAAe,kBAAA;;;;UAW7B,cAAA;EAChB,gBAAA;EACA,IAAA;EACA,IAAA;EACA,QAAA;EACA,IAAA;EACA,QAAA;EACA,GAAA;EACA,IAAA;IAAS,GAAA;IAAc,GAAA;EAAA;AAAA;;;;;;;;;;;iBAaR,QAAA,CAAS,MAAA,EAAQ,cAAA,GAAiB,kBAAA"}

package/dist/after-B1IIdH3Y.mjs

@@ -1,29 +0,0 @@
-//#region src/after.ts
-const waitUntilReady = (async () => {
-	try {
-		return (await import("virtual:emdash/wait-until")).waitUntil ?? null;
-	} catch {
-		return null;
-	}
-})();
-waitUntilReady.catch(() => {});
-/**
-* Schedule `fn` to run without blocking the response.
-*
-* Errors are caught and logged — a deferred task should never surface
-* as an unhandled rejection because the response is long gone. Callers
-* that care about errors should handle them inside `fn`.
-*/
-function after(fn) {
-	const promise = Promise.resolve().then(fn).catch((error) => {
-		console.error("[emdash] deferred task failed:", error);
-	});
-	waitUntilReady.then((waitUntil) => {
-		if (waitUntil) waitUntil(promise);
-		return null;
-	});
-}
-
-//#endregion
-export { after as t };
-//# sourceMappingURL=after-B1IIdH3Y.mjs.map

package/dist/after-B1IIdH3Y.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"after-B1IIdH3Y.mjs","names":[],"sources":["../src/after.ts"],"sourcesContent":["/**\n * Defer work past the HTTP response.\n *\n * Use for bookkeeping that doesn't need to complete before the client\n * gets bytes — writes that record state, maintenance queries, cache\n * refreshes. `after()` hands the promise to the host's lifetime\n * extender when one is available (Cloudflare's `waitUntil` under\n * workerd), or fires-and-forgets on Node (the process lives for the\n * next request anyway).\n *\n * Host binding is resolved lazily via a dynamic import of the\n * `virtual:emdash/wait-until` virtual module. Lazy — rather than a\n * static top-level import — so tools that walk the dist in a plain\n * Node loader (`astro check`, Vitest, etc.) don't trip over the\n * `virtual:` scheme: they'd only fail if they actually called\n * `after()`, which they don't during type-checking.\n */\n\nexport type WaitUntilFn = (promise: Promise<unknown>) => void;\n\n// Resolves to the host's waitUntil if the adapter provided one, or\n// null otherwise. Kicked off once at module load; subsequent `after()`\n// calls see the cached result without re-importing.\nconst waitUntilReady: Promise<WaitUntilFn | null> = (async () => {\n\ttry {\n\t\t// @ts-ignore - virtual module, generated by the Astro integration\n\t\tconst mod = (await import(\"virtual:emdash/wait-until\")) as {\n\t\t\twaitUntil?: WaitUntilFn;\n\t\t};\n\t\treturn mod.waitUntil ?? null;\n\t} catch {\n\t\t// No virtual module available (Node-side tooling, tests without the\n\t\t// integration in scope). Fire-and-forget is the safe fallback.\n\t\treturn null;\n\t}\n})();\n// Surface rejections without making the module-load fail.\nwaitUntilReady.catch(() => {});\n\n/**\n * Schedule `fn` to run without blocking the response.\n *\n * Errors are caught and logged — a deferred task should never surface\n * as an unhandled rejection because the response is long gone. Callers\n * that care about errors should handle them inside `fn`.\n */\nexport function after(fn: () => void | Promise<void>): void {\n\tconst promise = Promise.resolve()\n\t\t.then(fn)\n\t\t.catch((error) => {\n\t\t\tconsole.error(\"[emdash] deferred task failed:\", error);\n\t\t});\n\n\t// Defer the lifetime-extender handoff to the microtask that resolves\n\t// waitUntilReady. On workerd this is effectively instant (the virtual\n\t// module is already loaded in the bundle); on Node the promise\n\t// resolves to null, so this is just one extra microtask and no-op.\n\tvoid waitUntilReady.then((waitUntil) => {\n\t\tif (waitUntil) waitUntil(promise);\n\t\treturn null;\n\t});\n}\n"],"mappings":";AAuBA,MAAM,kBAA+C,YAAY;AAChE,KAAI;AAKH,UAHa,MAAM,OAAO,8BAGf,aAAa;SACjB;AAGP,SAAO;;IAEL;AAEJ,eAAe,YAAY,GAAG;;;;;;;;AAS9B,SAAgB,MAAM,IAAsC;CAC3D,MAAM,UAAU,QAAQ,SAAS,CAC/B,KAAK,GAAG,CACR,OAAO,UAAU;AACjB,UAAQ,MAAM,kCAAkC,MAAM;GACrD;AAMH,CAAK,eAAe,MAAM,cAAc;AACvC,MAAI,UAAW,WAAU,QAAQ;AACjC,SAAO;GACN"}