emdash 0.20.0 → 0.22.0

package/dist/astro/index.mjs

@@ -1,12 +1,12 @@
-import { t as INTERNAL_MEDIA_PREFIX } from "../normalize-CK5o04zr.mjs";
-import { t as defaultSeed } from "../default-IlBaTFxM.mjs";
-import { n as validateAllowedOrigins, r as validateOriginShape } from "../allowed-origins-B1u7Qnvg.mjs";
-import { n as VERSION, t as COMMIT } from "../version-D-5txk2m.mjs";
+import { t as INTERNAL_MEDIA_PREFIX } from "../normalize-Uam4_Vkr.mjs";
+import { t as defaultSeed } from "../default-CpBEPn6a.mjs";
+import { n as validateAllowedOrigins, r as validateOriginShape } from "../allowed-origins-DjlhyfNN.mjs";
+import { n as VERSION, t as COMMIT } from "../version-RnYXYjzD.mjs";
 import { createRequire } from "node:module";
 import { fontProviders } from "astro/config";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync, readFileSync } from "node:fs";
 
 //#region src/astro/storage/adapters.ts
 /**
@@ -66,6 +66,28 @@ function local(config) {
 	};
 }
 
+//#endregion
+//#region src/astro/object-cache/adapters.ts
+/**
+* In-isolate memory object cache.
+*
+* Caches query results across requests within a single isolate/process. On
+* Node (one long-lived process) this is a genuine cross-request cache; on
+* multi-isolate platforms (Cloudflare) prefer `kvCache()` so the cache is
+* shared. Useful for local development regardless of target.
+*
+* @example
+* ```ts
+* emdash({ objectCache: memoryCache({ defaultTtl: 600 }) })
+* ```
+*/
+function memoryCache(options = {}) {
+	return {
+		entrypoint: "emdash/object-cache/memory",
+		config: { ...options }
+	};
+}
+
 //#endregion
 //#region src/astro/integration/font-provider.ts
 /**
@@ -235,10 +257,29 @@ function resolveRoute(route) {
 		return isAstro ? resolve(__dirname, "../routes", route) : resolve(__dirname, "../routes", `${specifier}.mjs`);
 	}
 }
+const ROUTE_OVERRIDE_EXTENSIONS = [
+	".astro",
+	".js",
+	".ts",
+	".jsx",
+	".tsx",
+	".mjs",
+	".mts",
+	".md",
+	".mdx",
+	".html"
+];
+/**
+* Detect whether the host site defines its own root-level public route file.
+*/
+function hasUserDefinedPublicRoute(srcDir, basename) {
+	const srcDirPath = fileURLToPath(srcDir);
+	return ROUTE_OVERRIDE_EXTENSIONS.some((extension) => existsSync(resolve(srcDirPath, "pages", `${basename}${extension}`)) || existsSync(resolve(srcDirPath, "pages", basename, `index${extension}`)));
+}
 /**
 * Injects all core EmDash routes.
 */
-function injectCoreRoutes(injectRoute) {
+function injectCoreRoutes(injectRoute, options = {}) {
 	injectRoute({
 		pattern: "/_emdash/admin/[...path]",
 		entrypoint: resolveRoute("admin.astro")
@@ -743,6 +784,10 @@ function injectCoreRoutes(injectRoute) {
 		pattern: "/_emdash/api/comments/[collection]/[contentId]",
 		entrypoint: resolveRoute("api/comments/[collection]/[contentId]/index.ts")
 	});
+	injectRoute({
+		pattern: "/_emdash/api/comments/[collection]/[contentId]/reactions",
+		entrypoint: resolveRoute("api/comments/[collection]/[contentId]/reactions.ts")
+	});
 	injectRoute({
 		pattern: "/_emdash/api/admin/comments",
 		entrypoint: resolveRoute("api/admin/comments/index.ts")
@@ -763,7 +808,7 @@ function injectCoreRoutes(injectRoute) {
 		pattern: "/_emdash/api/admin/comments/[id]",
 		entrypoint: resolveRoute("api/admin/comments/[id].ts")
 	});
-	injectRoute({
+	if (!options.srcDir || !hasUserDefinedPublicRoute(options.srcDir, "sitemap.xml")) injectRoute({
 		pattern: "/sitemap.xml",
 		entrypoint: resolveRoute("sitemap.xml.ts")
 	});
@@ -771,7 +816,7 @@ function injectCoreRoutes(injectRoute) {
 		pattern: "/sitemap-[collection].xml",
 		entrypoint: resolveRoute("sitemap-[collection].xml.ts")
 	});
-	injectRoute({
+	if (!options.srcDir || !hasUserDefinedPublicRoute(options.srcDir, "robots.txt")) injectRoute({
 		pattern: "/robots.txt",
 		entrypoint: resolveRoute("robots.txt.ts")
 	});
@@ -941,6 +986,8 @@ const VIRTUAL_DIALECT_ID = "virtual:emdash/dialect";
 const RESOLVED_VIRTUAL_DIALECT_ID = "\0" + VIRTUAL_DIALECT_ID;
 const VIRTUAL_STORAGE_ID = "virtual:emdash/storage";
 const RESOLVED_VIRTUAL_STORAGE_ID = "\0" + VIRTUAL_STORAGE_ID;
+const VIRTUAL_OBJECT_CACHE_ID = "virtual:emdash/object-cache";
+const RESOLVED_VIRTUAL_OBJECT_CACHE_ID = "\0" + VIRTUAL_OBJECT_CACHE_ID;
 const VIRTUAL_ADMIN_REGISTRY_ID = "virtual:emdash/admin-registry";
 const RESOLVED_VIRTUAL_ADMIN_REGISTRY_ID = "\0" + VIRTUAL_ADMIN_REGISTRY_ID;
 const VIRTUAL_PLUGINS_ID = "virtual:emdash/plugins";
@@ -1011,6 +1058,22 @@ export const createStorage = _createStorage;
 `;
 }
 /**
+* Generates the object-cache virtual module.
+*
+* Statically imports the configured object-cache backend's `createObjectCache`
+* factory and embeds its serializable config. When no object cache is
+* configured, exports `undefined` so the runtime read-through layer becomes a
+* transparent passthrough (cache off by default).
+*/
+function generateObjectCacheModule(entrypoint, config) {
+	if (!entrypoint) return [`export const createObjectCache = undefined;`, `export const objectCacheConfig = undefined;`].join("\n");
+	return `
+import { createObjectCache as _createObjectCache } from "${entrypoint}";
+export const createObjectCache = _createObjectCache;
+export const objectCacheConfig = ${JSON.stringify(config ?? {})};
+`;
+}
+/**
 * Generates the auth virtual module.
 * Statically imports the configured auth provider.
 */
@@ -1081,7 +1144,9 @@ function generatePluginsModule(descriptors) {
 				allowedHosts: descriptor.allowedHosts,
 				storage: descriptor.storage,
 				adminPages: descriptor.adminPages,
-				adminWidgets: descriptor.adminWidgets
+				adminWidgets: descriptor.adminWidgets,
+				portableTextBlocks: descriptor.portableTextBlocks,
+				fieldWidgets: descriptor.fieldWidgets
 			})})`);
 		} else {
 			const varName = `createPlugin${index}`;
@@ -1331,6 +1396,8 @@ export const sandboxedPlugins = [];
     storage: ${JSON.stringify(descriptor.storage ?? {})},
     adminPages: ${JSON.stringify(descriptor.adminPages ?? [])},
     adminWidgets: ${JSON.stringify(descriptor.adminWidgets ?? [])},
+    portableTextBlocks: ${JSON.stringify(descriptor.portableTextBlocks ?? [])},
+    fieldWidgets: ${JSON.stringify(descriptor.fieldWidgets ?? [])},
     adminEntry: ${JSON.stringify(descriptor.adminEntry)},
     // Code read from: ${filePath}
     code: ${JSON.stringify(code)},
@@ -1434,6 +1501,7 @@ function createVirtualModulesPlugin(options) {
 			if (id === VIRTUAL_CONFIG_ID) return RESOLVED_VIRTUAL_CONFIG_ID;
 			if (id === VIRTUAL_DIALECT_ID) return RESOLVED_VIRTUAL_DIALECT_ID;
 			if (id === VIRTUAL_STORAGE_ID) return RESOLVED_VIRTUAL_STORAGE_ID;
+			if (id === VIRTUAL_OBJECT_CACHE_ID) return RESOLVED_VIRTUAL_OBJECT_CACHE_ID;
 			if (id === VIRTUAL_ADMIN_REGISTRY_ID) return RESOLVED_VIRTUAL_ADMIN_REGISTRY_ID;
 			if (id === VIRTUAL_PLUGINS_ID) return RESOLVED_VIRTUAL_PLUGINS_ID;
 			if (id === VIRTUAL_SANDBOX_RUNNER_ID) return RESOLVED_VIRTUAL_SANDBOX_RUNNER_ID;
@@ -1454,6 +1522,7 @@ function createVirtualModulesPlugin(options) {
 				supportsRequestScope: resolvedConfig.database?.supportsRequestScope ?? false
 			});
 			if (id === RESOLVED_VIRTUAL_STORAGE_ID) return generateStorageModule(resolvedConfig.storage?.entrypoint);
+			if (id === RESOLVED_VIRTUAL_OBJECT_CACHE_ID) return generateObjectCacheModule(resolvedConfig.objectCache?.entrypoint, resolvedConfig.objectCache?.config);
 			if (id === RESOLVED_VIRTUAL_PLUGINS_ID) return generatePluginsModule(pluginDescriptors);
 			if (id === RESOLVED_VIRTUAL_ADMIN_REGISTRY_ID) return generateAdminRegistryModule([...pluginDescriptors, ...resolvedConfig.sandboxed ?? []]);
 			if (id === RESOLVED_VIRTUAL_SANDBOX_RUNNER_ID) return generateSandboxRunnerModule(resolvedConfig.sandboxRunner, resolvedConfig.sandbox);
@@ -1578,6 +1647,7 @@ function createViteConfig(options, command) {
 					"react-dom/server",
 					"astro > zod/v4",
 					"astro > zod/v4/core",
+					"emdash > zod",
 					"@emdash-cms/cloudflare > kysely-d1",
 					"astro/virtual-modules/middleware.js",
 					"astro/virtual-modules/live-config",
@@ -1647,26 +1717,21 @@ const DEFAULT_STORAGE = local({
 /**
 * Build `image.remotePatterns` entries so Astro will optimize EmDash media.
 *
-* Astro's image services only transform **absolute** URLs whose host is
-* authorized; everything else is passed through unoptimized. We authorize the
-* media sources automatically:
+* Astro's image services only build a transform URL for sources allowed via
+* `image.domains` / `image.remotePatterns` (relative URLs are never optimized —
+* see `isRemoteAllowed`). We authorize the media sources automatically:
 *
-*  1. The storage adapter's public URL host (R2 custom domain, S3/CDN), so
-*     media served directly from a public bucket is optimized.
+*  1. The storage adapter's public URL host (R2 custom domain, S3/CDN).
 *  2. The site's own origin, scoped to the media proxy route
-*     (`/_emdash/api/media/file/**`), so same-origin proxied media (local
-*     storage, or R2 without a public URL) is optimized too. The pathname
-*     scope keeps Astro's image endpoint from acting as an open proxy for the
-*     whole origin. Only registered when `siteUrl` is known at build time;
-*     `getPublicOrigin` resolves the matching origin at render time.
-*  3. In `astro dev` the dev-server origin (`localhost:<port>`) isn't known at
-*     build time, so we register a host-agnostic pattern scoped to the media
-*     route. This is dev-only — it never ships in a production build — so the
-*     missing host check can't be abused on a deployed site.
+*     (`/_emdash/api/media/file/**`), so same-origin proxied media is optimized.
+*     The components absolutize the media URL against this origin; EmDash's
+*     wrapped image endpoint then serves the bytes from storage (so the absolute
+*     URL is never fetched). Only registered when `siteUrl` is known at build.
+*  3. In `astro dev` the dev-server origin isn't known at build time, so we
+*     register a host-agnostic pattern scoped to the media route. Dev-only.
 *
-* Returns an empty array when no source is statically known (e.g. a production
-* build using local storage with no `siteUrl`), in which case media renders as
-* a plain `<img>`.
+* Returns an empty array when no source is statically known (production build,
+* local storage, no `siteUrl`), in which case media renders as a plain `<img>`.
 *
 * @internal Exported for unit testing.
 */
@@ -1695,6 +1760,41 @@ function buildImageRemotePatterns(storage, siteUrl, command) {
 	if (command === "dev") patterns.push({ pathname: `${INTERNAL_MEDIA_PREFIX}**` });
 	return patterns;
 }
+/**
+* Stock image endpoints EmDash may safely replace with its storage-backed
+* wrapper. Our wrapper delegates non-EmDash images to the platform's transform
+* endpoint, so we only override endpoints whose transform we can delegate to.
+*/
+const OVERRIDABLE_IMAGE_ENDPOINTS = new Set([
+	"astro/assets/endpoint/generic",
+	"astro/assets/endpoint/node",
+	"astro/assets/endpoint/dev",
+	"@astrojs/cloudflare/image-transform-endpoint"
+]);
+/**
+* Stock endpoints that deliberately don't transform (the user opted into
+* passthrough). We leave these untouched -- and without a warning, since it's a
+* supported choice, not a custom endpoint. Overriding would route non-EmDash
+* images through a transformer the passthrough setup doesn't provide.
+*/
+const PASSTHROUGH_IMAGE_ENDPOINTS = new Set(["@astrojs/cloudflare/image-passthrough-endpoint"]);
+/**
+* Decide which image endpoint to install (if any). EmDash wraps Astro's image
+* endpoint so EmDash media bytes load from storage; the wrapper delegates other
+* images back to the platform's stock endpoint.
+*
+* Returns `{ entrypoint }` to install, `{ warn }` to skip with a warning (a
+* custom endpoint we can't delegate to), or `{}` to skip silently (opted out).
+*
+* @internal Exported for unit testing.
+*/
+function resolveImageEndpoint(opts) {
+	if (opts.imagesDisabled) return {};
+	const current = opts.currentEntrypoint;
+	if (current === void 0 || OVERRIDABLE_IMAGE_ENDPOINTS.has(current)) return { entrypoint: opts.isCloudflare ? "@emdash-cms/cloudflare/image-endpoint" : "emdash/image-endpoint" };
+	if (PASSTHROUGH_IMAGE_ENDPOINTS.has(current)) return {};
+	return { warn: `A custom image.endpoint (${current}) is configured; EmDash will not wrap it, so storage-backed media may render unoptimized.` };
+}
 const dim = (s) => `\x1b[2m${s}\x1b[22m`;
 const bold = (s) => `\x1b[1m${s}\x1b[22m`;
 const cyan = (s) => `\x1b[36m${s}\x1b[39m`;
@@ -1702,14 +1802,21 @@ const cyan = (s) => `\x1b[36m${s}\x1b[39m`;
 function printBanner(_logger) {
 	const banner = `
 
-  ${bold(cyan("— E M D A S H —"))}
+  ${bold(cyan("— E M D A S H —"))}  ${dim(`v${VERSION}`)}
    `;
 	console.log(banner);
 }
-/** Print route injection summary */
-function printRoutesSummary(_logger) {
-	console.log(`\n  ${dim("›")} Admin UI    ${cyan("/_emdash/admin")}`);
-	console.log(`  ${dim("›")} API         ${cyan("/_emdash/api/*")}`);
+/**
+* Print dev-server route info with absolute (clickable) URLs, including the
+* dev-bypass shortcut that skips passkey auth. Dev only -- the dev-bypass
+* endpoint returns 403 in production.
+*/
+function printDevServerInfo(baseUrl, mcpEnabled) {
+	const devBypassUrl = `${baseUrl}/_emdash/api/setup/dev-bypass?redirect=/_emdash/admin`;
+	console.log(`\n  ${dim("›")} Admin UI    ${cyan(`${baseUrl}/_emdash/admin`)}`);
+	if (mcpEnabled) console.log(`  ${dim("›")} MCP server  ${cyan(`${baseUrl}/_emdash/api/mcp`)}`);
+	console.log(`  ${dim("›")} Dev bypass  ${cyan(devBypassUrl)}`);
+	console.log(`    ${dim("Skips passkey setup/auth and signs you in as a dev admin")}`);
 	console.log("");
 }
 /**
@@ -1770,10 +1877,12 @@ function emdash(config = {}) {
 		admin: resolvedConfig.admin
 	};
 	const useExternalAuth = !!(resolvedConfig.auth && "entrypoint" in resolvedConfig.auth);
+	let astroCommand;
 	return {
 		name: "emdash",
 		hooks: {
 			"astro:config:setup": ({ injectRoute, addMiddleware, logger, updateConfig, config: astroConfig, command }) => {
+				astroCommand = command;
 				printBanner(logger);
 				const astroVersion = resolveAstroVersion();
 				if (astroVersion !== void 0) serializableConfig.astroVersion = astroVersion;
@@ -1814,9 +1923,18 @@ function emdash(config = {}) {
 					]
 				}];
 				const imageRemotePatterns = buildImageRemotePatterns(resolvedConfig.storage, resolvedConfig.siteUrl, command);
+				const { entrypoint: imageEndpoint, warn: imageEndpointWarning } = resolveImageEndpoint({
+					imagesDisabled: resolvedConfig.images === false,
+					currentEntrypoint: astroConfig.image?.endpoint?.entrypoint,
+					isCloudflare: astroConfig.adapter?.name === "@astrojs/cloudflare"
+				});
+				if (imageEndpointWarning) logger.warn(imageEndpointWarning);
+				const imageConfig = {};
+				if (imageRemotePatterns.length) imageConfig.remotePatterns = imageRemotePatterns;
+				if (imageEndpoint) imageConfig.endpoint = { entrypoint: imageEndpoint };
 				updateConfig({
 					security: securityConfig,
-					...imageRemotePatterns.length ? { image: { remotePatterns: imageRemotePatterns } } : {},
+					...Object.keys(imageConfig).length ? { image: imageConfig } : {},
 					fonts: emdashFonts,
 					vite: createViteConfig({
 						serializableConfig,
@@ -1825,7 +1943,7 @@ function emdash(config = {}) {
 						astroConfig
 					}, command)
 				});
-				injectCoreRoutes(injectRoute);
+				injectCoreRoutes(injectRoute, { srcDir: astroConfig.srcDir });
 				if (resolvedConfig.authProviders?.length) injectAuthProviderRoutes(injectRoute, resolvedConfig.authProviders);
 				if (!useExternalAuth) injectBuiltinAuthRoutes(injectRoute);
 				if (resolvedConfig.mcp !== false) injectMcpRoute(injectRoute);
@@ -1855,9 +1973,16 @@ function emdash(config = {}) {
 					entrypoint: "emdash/middleware/request-context",
 					order: "pre"
 				});
-				printRoutesSummary(logger);
 			},
 			"astro:server:setup": ({ server, logger }) => {
+				if (astroCommand === "dev") server.httpServer?.once("listening", () => {
+					const address = server.httpServer?.address();
+					if (!address || typeof address === "string") return;
+					let host = address.address;
+					if (host === "::1" || host === "::" || host === "0.0.0.0") host = "localhost";
+					else if (address.family === "IPv6") host = `[${host}]`;
+					printDevServerInfo(`http://${host}:${address.port}`, resolvedConfig.mcp !== false);
+				});
 				server.httpServer?.once("listening", async () => {
 					const { writeFile, readFile } = await import("node:fs/promises");
 					const { resolve } = await import("node:path");
@@ -1898,5 +2023,5 @@ function emdash(config = {}) {
 }
 
 //#endregion
-export { emdash as default, getStoredConfig, local, s3 };
+export { emdash as default, getStoredConfig, local, memoryCache, s3 };
 //# sourceMappingURL=index.mjs.map