emdash 0.32.0 → 0.33.0

package/src/search/types.ts

@@ -7,11 +7,17 @@
 /**
  * Search configuration for a collection
  */
+export const SEARCH_TOKENIZERS = ["porter unicode61", "unicode61", "trigram"] as const;
+
+export type SearchTokenizer = (typeof SEARCH_TOKENIZERS)[number];
+
 export interface SearchConfig {
 	/** Whether search is enabled for this collection */
 	enabled: boolean;
 	/** Field weights for ranking (higher = more important) */
 	weights?: Record<string, number>;
+	/** FTS5 tokenizer configuration (defaults to English Porter stemming) */
+	tokenize?: SearchTokenizer;
 }
 
 /**

package/src/seed/apply.ts

@@ -179,6 +179,8 @@ export async function applySeed(
 						icon: collection.icon,
 						supports: collection.supports || [],
 						urlPattern: collection.urlPattern,
+						hidden: collection.hidden,
+						sortOrder: collection.sortOrder,
 						commentsEnabled: collection.commentsEnabled,
 					});
 					result.collections.updated++;
@@ -247,6 +249,8 @@ export async function applySeed(
 					icon: collection.icon,
 					supports: collection.supports || [],
 					urlPattern: collection.urlPattern,
+					hidden: collection.hidden,
+					sortOrder: collection.sortOrder,
 					commentsEnabled: collection.commentsEnabled,
 				},
 				fields,
@@ -523,8 +527,24 @@ export async function applySeed(
 											entryId: existing.id,
 											data: resolvedData,
 										});
-										await trxContentRepo.setDraftRevision(collectionSlug, existing.id, draft.id);
-										await trxContentRepo.publish(collectionSlug, existing.id);
+										try {
+											await trxContentRepo.setDraftRevision(collectionSlug, existing.id, draft.id);
+											await trxContentRepo.publish(collectionSlug, existing.id);
+										} catch (error) {
+											try {
+												await trxRevisionRepo.deleteIfUnreferenced(
+													collectionSlug,
+													existing.id,
+													draft.id,
+												);
+											} catch (cleanupError) {
+												console.error(
+													`[seed] Failed to clean up unstaged revision ${draft.id}:`,
+													cleanupError,
+												);
+											}
+											throw error;
+										}
 									}
 								});
 							} catch (error) {

package/src/seed/types.ts

@@ -74,6 +74,16 @@ export interface SeedCollection {
 	icon?: string;
 	supports?: ("drafts" | "revisions" | "preview" | "scheduling" | "search" | "seo")[];
 	urlPattern?: string;
+	/**
+	 * Omit this collection from the admin sidebar. It stays reachable through
+	 * the API, MCP, plugin hooks, and direct `/content/:collection` URLs.
+	 */
+	hidden?: boolean;
+	/**
+	 * Explicit position in the admin sidebar (ascending). Collections without
+	 * a `sortOrder` keep the alphabetical order and follow the ordered ones.
+	 */
+	sortOrder?: number;
 	/** Enable comments on this collection */
 	commentsEnabled?: boolean;
 	fields: SeedField[];

package/src/taxonomies/index.ts

@@ -16,7 +16,7 @@ import { getDb, resetTaxonomyNamesCache } from "../loader.js";
 import {
 	cachedQuery,
 	CacheNamespace,
-	contentNamespace,
+	contentCacheNamespaces,
 	invalidateTaxonomyObjectCache,
 	isObjectCacheActive,
 } from "../object-cache/index.js";
@@ -228,12 +228,14 @@ export async function getTaxonomyDef(
  * Object-cache namespaces for values that embed visible term counts: the
  * taxonomy epoch (term/assignment writes) plus each counted collection's
  * content epoch, so publishing, unpublishing, or trashing an entry
- * invalidates the cached count promptly. A scheduled entry becoming due
- * flips visibility without a write, so that staleness stays bounded by the
- * cache entry's TTL.
+ * invalidates the cached count promptly. Both content namespace generations
+ * participate so rolling deployments preserve invalidation in either direction.
  */
 function termCountNamespaces(collections: string[]): string[] {
-	return [...Array.from(new Set(collections), contentNamespace), CacheNamespace.TAXONOMIES];
+	return [
+		...[...new Set(collections)].flatMap((collection) => contentCacheNamespaces(collection)),
+		CacheNamespace.TAXONOMIES,
+	];
 }
 
 /**
@@ -299,6 +301,7 @@ async function loadTaxonomyTerms(
 		.selectFrom("taxonomies")
 		.selectAll()
 		.where("name", "=", def.name)
+		.orderBy("sort_order", "asc")
 		.orderBy("label", "asc");
 	if (locale !== undefined) termsQuery = termsQuery.where("locale", "=", locale);
 
@@ -417,6 +420,7 @@ async function loadTerm(
 		// Children store the parent's translation_group in parent_id (not a row
 		// id), so a translated parent still owns its children in its own locale.
 		.where("parent_id", "=", row.translation_group ?? row.id)
+		.orderBy("sort_order", "asc")
 		.orderBy("label", "asc");
 	const termLocale = row.locale;
 	if (termLocale) childrenQuery = childrenQuery.where("locale", "=", termLocale);
@@ -475,7 +479,7 @@ export function getEntryTerms(
 		`terms:${collection}:${entryId}:${taxonomyName ?? "*"}:${locale ?? "*"}`,
 		() =>
 			cachedQuery({
-				namespace: [contentNamespace(collection), CacheNamespace.TAXONOMIES],
+				namespace: [...contentCacheNamespaces(collection), CacheNamespace.TAXONOMIES],
 				key: `entryTerms:${collection}:${entryId}:${taxonomyName ?? "*"}:${locale ?? "*"}`,
 				load: async () => {
 					const db = await getDb();
@@ -631,7 +635,7 @@ export async function getTermsForEntries(
 	const pairs =
 		idKey.length <= 256
 			? await cachedQuery({
-					namespace: [contentNamespace(collection), CacheNamespace.TAXONOMIES],
+					namespace: [...contentCacheNamespaces(collection), CacheNamespace.TAXONOMIES],
 					key: `termsForEntries:${collection}:${taxonomyName}:${locale ?? "*"}:${idKey}`,
 					load,
 				})

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

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/virtual-modules.d.ts

@@ -54,11 +54,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>;

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"}