emdash 0.5.0 → 0.7.0

package/dist/astro/index.d.mts

@@ -1,9 +1,9 @@
-import "../types-B6BzlZxx.mjs";
-import { Pi as MediaItem, dn as EmDashConfig, gn as StorageDescriptor, hn as S3StorageConfig, mn as LocalStorageConfig, pn as getStoredConfig } from "../index-CCWzlriB.mjs";
-import "../runner-DYv3rX8P.mjs";
-import { r as ContentItem } from "../types-BmkQR1En.mjs";
-import { X as ResolvedPlugin } from "../types-C3ronwXb.mjs";
-import "../validate-Db1yNL3i.mjs";
+import "../types-C2v0c34j.mjs";
+import { Ri as MediaItem, _n as S3StorageConfig, gn as LocalStorageConfig, hn as getStoredConfig, pn as EmDashConfig, vn as StorageDescriptor } from "../index-De6_Xv3v.mjs";
+import "../runner-BR2xKwhn.mjs";
+import { r as ContentItem } from "../types-6CUZRrZP.mjs";
+import { X as ResolvedPlugin } from "../types-DgrIP0tF.mjs";
+import "../validate-kM8Pjuf7.mjs";
 import { EmDashHandlers, EmDashManifest, ManifestCollection } from "./types.mjs";
 import { AstroIntegration } from "astro";
 

package/dist/astro/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/astro/storage/adapters.ts","../../src/astro/integration/index.ts"],"mappings":";;;;;;;;;;;;;;;;;AC2DA;;;;;;;;;;;;;;;;;;;;;;;iBDEgB,EAAA,CAAG,MAAA,GAAQ,OAAA,CAAQ,eAAA,IAAwB,iBAAA;;;;;;;;;;;;;;;iBAqB3C,KAAA,CAAM,MAAA,EAAQ,kBAAA,GAAqB,iBAAA;;;;;;iBCvBnC,MAAA,CAAO,MAAA,GAAQ,YAAA,GAAoB,gBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/astro/storage/adapters.ts","../../src/astro/integration/index.ts"],"mappings":";;;;;;;;;;;;;;;;;AC4DA;;;;;;;;;;;;;;;;;;;;;;;iBDCgB,EAAA,CAAG,MAAA,GAAQ,OAAA,CAAQ,eAAA,IAAwB,iBAAA;;;;;;;;;;;;;;;iBAqB3C,KAAA,CAAM,MAAA,EAAQ,kBAAA,GAAqB,iBAAA;;;;;;iBCtBnC,MAAA,CAAO,MAAA,GAAQ,YAAA,GAAoB,gBAAA"}

package/dist/astro/index.mjs

@@ -1,6 +1,7 @@
-import { t as defaultSeed } from "../default-PUx9RK6u.mjs";
-import { n as VERSION, t as COMMIT } from "../version-CMMjTuqu.mjs";
+import { t as defaultSeed } from "../default-CME5YdZ3.mjs";
+import { n as VERSION, t as COMMIT } from "../version-BnTKdfam.mjs";
 import { createRequire } from "node:module";
+import { fontProviders } from "astro/config";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { existsSync, readFileSync } from "node:fs";
@@ -63,6 +64,130 @@ function local(config) {
 	};
 }
 
+//#endregion
+//#region src/astro/integration/font-provider.ts
+/**
+* EmDash Noto Sans font provider
+*
+* A custom Astro font provider that wraps Google Fonts to resolve
+* multiple Noto Sans families (Latin, Arabic, JP, etc.) under a
+* single logical font entry. This lets all @font-face blocks share
+* the same font-family name, so the browser picks the right file
+* per character via unicode-range.
+*
+* Without this, registering "Noto Sans" and "Noto Sans Arabic" as
+* separate font entries on the same cssVariable triggers an Astro
+* warning and the last entry overwrites the first.
+*/
+/**
+* All subset names used by Google Fonts CSS responses.
+* Passed when resolving extra script families so the unifont
+* provider doesn't filter out any faces.
+*/
+const ALL_GOOGLE_SUBSETS = [
+	"arabic",
+	"armenian",
+	"bengali",
+	"chinese-simplified",
+	"chinese-traditional",
+	"chinese-hongkong",
+	"cyrillic",
+	"cyrillic-ext",
+	"devanagari",
+	"ethiopic",
+	"farsi",
+	"georgian",
+	"greek",
+	"greek-ext",
+	"gujarati",
+	"gurmukhi",
+	"hebrew",
+	"japanese",
+	"kannada",
+	"khmer",
+	"korean",
+	"lao",
+	"latin",
+	"latin-ext",
+	"malayalam",
+	"math",
+	"myanmar",
+	"oriya",
+	"sinhala",
+	"symbols",
+	"tamil",
+	"telugu",
+	"thai",
+	"tibetan",
+	"vietnamese"
+];
+/**
+* Known Noto Sans and Sans script families on Google Fonts.
+* Maps user-friendly script names to Google Fonts family names.
+*/
+const NOTO_SCRIPT_FAMILIES = {
+	arabic: "Noto Sans Arabic",
+	armenian: "Noto Sans Armenian",
+	bengali: "Noto Sans Bengali",
+	"chinese-simplified": "Noto Sans SC",
+	"chinese-traditional": "Noto Sans TC",
+	"chinese-hongkong": "Noto Sans HK",
+	devanagari: "Noto Sans Devanagari",
+	ethiopic: "Noto Sans Ethiopic",
+	farsi: "Vazirmatn",
+	georgian: "Noto Sans Georgian",
+	gujarati: "Noto Sans Gujarati",
+	gurmukhi: "Noto Sans Gurmukhi",
+	hebrew: "Noto Sans Hebrew",
+	japanese: "Noto Sans JP",
+	kannada: "Noto Sans Kannada",
+	khmer: "Noto Sans Khmer",
+	korean: "Noto Sans KR",
+	lao: "Noto Sans Lao",
+	malayalam: "Noto Sans Malayalam",
+	myanmar: "Noto Sans Myanmar",
+	oriya: "Noto Sans Oriya",
+	sinhala: "Noto Sans Sinhala",
+	tamil: "Noto Sans Tamil",
+	telugu: "Noto Sans Telugu",
+	thai: "Noto Sans Thai",
+	tibetan: "Noto Sans Tibetan"
+};
+/**
+* Create a font provider that resolves Noto Sans plus additional
+* script-specific Noto families from Google Fonts, all under one
+* font-family name.
+*/
+function notoSans(options) {
+	const googleProvider = fontProviders.google();
+	return {
+		name: "emdash-noto",
+		async init(context) {
+			await googleProvider.init?.(context);
+		},
+		async resolveFont(resolveFontOptions) {
+			const base = await googleProvider.resolveFont(resolveFontOptions);
+			const baseFonts = base?.fonts ?? [];
+			if (!options?.scripts?.length) return base;
+			const baseSubsets = new Set(baseFonts.map((f) => f.meta?.subset).filter(Boolean));
+			const extraFaces = (await Promise.all(options.scripts.map(async (script) => {
+				const family = NOTO_SCRIPT_FAMILIES[script];
+				if (!family) {
+					if (ALL_GOOGLE_SUBSETS.includes(script)) return;
+					console.warn(`[emdash] Unknown Noto Sans script "${script}". Available: ${Object.keys(NOTO_SCRIPT_FAMILIES).join(", ")}`);
+					return;
+				}
+				return googleProvider.resolveFont({
+					...resolveFontOptions,
+					familyName: family,
+					subsets: ALL_GOOGLE_SUBSETS
+				});
+			}))).flatMap((r) => (r?.fonts ?? []).filter((f) => !f.meta?.subset || !baseSubsets.has(f.meta.subset)));
+			return { fonts: [...baseFonts, ...extraFaces] };
+		}
+	};
+}
+
 //#endregion
 //#region src/astro/integration/routes.ts
 /**
@@ -447,6 +572,10 @@ function injectCoreRoutes(injectRoute) {
 		pattern: "/.well-known/oauth-authorization-server/_emdash",
 		entrypoint: resolveRoute("api/well-known/oauth-authorization-server.ts")
 	});
+	injectRoute({
+		pattern: "/_emdash/api/oauth/register",
+		entrypoint: resolveRoute("api/oauth/register.ts")
+	});
 	injectRoute({
 		pattern: "/_emdash/api/plugins/[pluginId]/[...path]",
 		entrypoint: resolveRoute("api/plugins/[pluginId]/[...path].ts")
@@ -741,6 +870,8 @@ const VIRTUAL_BLOCK_COMPONENTS_ID = "virtual:emdash/block-components";
 const RESOLVED_VIRTUAL_BLOCK_COMPONENTS_ID = "\0" + VIRTUAL_BLOCK_COMPONENTS_ID;
 const VIRTUAL_SEED_ID = "virtual:emdash/seed";
 const RESOLVED_VIRTUAL_SEED_ID = "\0" + VIRTUAL_SEED_ID;
+const VIRTUAL_WAIT_UNTIL_ID = "virtual:emdash/wait-until";
+const RESOLVED_VIRTUAL_WAIT_UNTIL_ID = "\0" + VIRTUAL_WAIT_UNTIL_ID;
 /**
 * Generates the config virtual module.
 */
@@ -749,42 +880,32 @@ function generateConfigModule(serializableConfig) {
 }
 /**
 * Generates the dialect virtual module.
-* Statically imports the configured database dialect and exports the dialect type.
 *
-* For D1 adapters, also re-exports session helpers (isSessionEnabled, getD1Binding,
-* getDefaultConstraint, getBookmarkCookieName, createSessionDialect) used by
-* middleware for per-request read replica sessions.
-*
-* For non-D1 adapters, session exports are no-ops.
+* Adapters that set `supportsRequestScope: true` on their descriptor are
+* expected to export `createRequestScopedDb` from their runtime entrypoint;
+* the generator re-exports it so middleware can ask for a per-request Kysely
+* (used for D1 Sessions API, bookmark cookies, read-replica routing). Other
+* adapters get a stub that returns null.
 */
-function generateDialectModule(dbEntrypoint, dbType, dbConfig) {
-	if (!dbEntrypoint) return [
+function generateDialectModule(opts) {
+	const { entrypoint, supportsRequestScope } = opts;
+	if (!entrypoint) return [
 		`export const createDialect = undefined;`,
 		`export const dialectType = "sqlite";`,
-		`export const isSessionEnabled = () => false;`,
-		`export const getD1Binding = () => null;`,
-		`export const getDefaultConstraint = () => "first-unconstrained";`,
-		`export const getBookmarkCookieName = () => "";`,
-		`export const createSessionDialect = undefined;`
+		`export const createRequestScopedDb = (_opts) => null;`
 	].join("\n");
-	const type = dbType ?? "sqlite";
-	const isD1 = dbEntrypoint.includes("cloudflare") && dbEntrypoint.includes("d1");
-	const sessionMode = isD1 && dbConfig && typeof dbConfig === "object" && "session" in dbConfig ? dbConfig.session : void 0;
-	if (isD1 && !!sessionMode && sessionMode !== "disabled") return `
-import { createDialect as _createDialect } from "${dbEntrypoint}";
-export { isSessionEnabled, getD1Binding, getDefaultConstraint, getBookmarkCookieName, createSessionDialect } from "${dbEntrypoint}";
+	const type = opts.type ?? "sqlite";
+	if (supportsRequestScope) return `
+import { createDialect as _createDialect } from "${entrypoint}";
+export { createRequestScopedDb } from "${entrypoint}";
 export const createDialect = _createDialect;
 export const dialectType = ${JSON.stringify(type)};
 `;
 	return `
-import { createDialect as _createDialect } from "${dbEntrypoint}";
+import { createDialect as _createDialect } from "${entrypoint}";
 export const createDialect = _createDialect;
 export const dialectType = ${JSON.stringify(type)};
-export const isSessionEnabled = () => false;
-export const getD1Binding = () => null;
-export const getDefaultConstraint = () => "first-unconstrained";
-export const getBookmarkCookieName = () => "";
-export const createSessionDialect = undefined;
+export const createRequestScopedDb = (_opts) => null;
 `;
 }
 /**
@@ -960,6 +1081,22 @@ function generateBlockComponentsModule(descriptors) {
 	return `${imports.join("\n")}\nexport const pluginBlockComponents = { ${spreads.join(", ")} };`;
 }
 /**
+* Generates the wait-until virtual module.
+*
+* Under @astrojs/cloudflare, re-exports `waitUntil` from `cloudflare:workers`
+* so `after(fn)` in core can extend the worker's lifetime past the response
+* for deferred bookkeeping. For any other adapter, exports `undefined` —
+* Node's long-lived event loop keeps deferred promises running without a
+* lifetime extender.
+*
+* Keeping the adapter check here — rather than in core — means core itself
+* has no Cloudflare-specific imports or code paths.
+*/
+function generateWaitUntilModule(adapterName) {
+	if (adapterName === "@astrojs/cloudflare") return `export { waitUntil } from "cloudflare:workers";`;
+	return `export const waitUntil = undefined;`;
+}
+/**
 * Generates the seed virtual module.
 * Reads the user's seed file at build time (in Node context) and embeds it,
 * so the runtime doesn't need filesystem access (required for workerd).
@@ -1117,10 +1254,15 @@ function createVirtualModulesPlugin(options) {
 			if (id === VIRTUAL_MEDIA_PROVIDERS_ID) return RESOLVED_VIRTUAL_MEDIA_PROVIDERS_ID;
 			if (id === VIRTUAL_BLOCK_COMPONENTS_ID) return RESOLVED_VIRTUAL_BLOCK_COMPONENTS_ID;
 			if (id === VIRTUAL_SEED_ID) return RESOLVED_VIRTUAL_SEED_ID;
+			if (id === VIRTUAL_WAIT_UNTIL_ID) return RESOLVED_VIRTUAL_WAIT_UNTIL_ID;
 		},
 		load(id) {
 			if (id === RESOLVED_VIRTUAL_CONFIG_ID) return generateConfigModule(serializableConfig);
-			if (id === RESOLVED_VIRTUAL_DIALECT_ID) return generateDialectModule(resolvedConfig.database?.entrypoint, resolvedConfig.database?.type, resolvedConfig.database?.config);
+			if (id === RESOLVED_VIRTUAL_DIALECT_ID) return generateDialectModule({
+				entrypoint: resolvedConfig.database?.entrypoint,
+				type: resolvedConfig.database?.type,
+				supportsRequestScope: resolvedConfig.database?.supportsRequestScope ?? false
+			});
 			if (id === RESOLVED_VIRTUAL_STORAGE_ID) return generateStorageModule(resolvedConfig.storage?.entrypoint);
 			if (id === RESOLVED_VIRTUAL_PLUGINS_ID) return generatePluginsModule(pluginDescriptors);
 			if (id === RESOLVED_VIRTUAL_ADMIN_REGISTRY_ID) return generateAdminRegistryModule([...pluginDescriptors, ...resolvedConfig.sandboxed ?? []]);
@@ -1137,6 +1279,7 @@ function createVirtualModulesPlugin(options) {
 			if (id === RESOLVED_VIRTUAL_MEDIA_PROVIDERS_ID) return generateMediaProvidersModule(resolvedConfig.mediaProviders ?? []);
 			if (id === RESOLVED_VIRTUAL_BLOCK_COMPONENTS_ID) return generateBlockComponentsModule(pluginDescriptors);
 			if (id === RESOLVED_VIRTUAL_SEED_ID) return generateSeedModule(fileURLToPath(astroConfig.root));
+			if (id === RESOLVED_VIRTUAL_WAIT_UNTIL_ID) return generateWaitUntilModule(astroConfig.adapter?.name);
 		}
 	};
 }
@@ -1320,7 +1463,10 @@ function emdash(config = {}) {
 		storage: resolvedConfig.storage,
 		auth: resolvedConfig.auth,
 		marketplace: resolvedConfig.marketplace,
-		siteUrl: resolvedConfig.siteUrl
+		siteUrl: resolvedConfig.siteUrl,
+		trustedProxyHeaders: resolvedConfig.trustedProxyHeaders,
+		maxUploadSize: resolvedConfig.maxUploadSize,
+		admin: resolvedConfig.admin
 	};
 	const useExternalAuth = !!(resolvedConfig.auth && "entrypoint" in resolvedConfig.auth);
 	return {
@@ -1337,11 +1483,35 @@ function emdash(config = {}) {
 						prefixDefaultLocale: typeof routing === "object" ? routing.prefixDefaultLocale ?? false : false
 					};
 				}
+				const securityConfig = {
+					checkOrigin: false,
+					...resolvedConfig.siteUrl ? { allowedDomains: [{ hostname: new URL(resolvedConfig.siteUrl).hostname }] } : {}
+				};
+				const fontsConfig = resolvedConfig.fonts;
 				updateConfig({
-					security: {
-						checkOrigin: false,
-						...resolvedConfig.siteUrl ? { allowedDomains: [{ hostname: new URL(resolvedConfig.siteUrl).hostname }] } : {}
-					},
+					security: securityConfig,
+					fonts: fontsConfig === false ? [] : [{
+						provider: notoSans({ scripts: fontsConfig?.scripts }),
+						name: "Noto Sans",
+						cssVariable: "--font-emdash",
+						weights: ["100 900"],
+						styles: ["normal", "italic"],
+						subsets: [
+							"latin",
+							"latin-ext",
+							"cyrillic",
+							"cyrillic-ext",
+							"devanagari",
+							"greek",
+							"greek-ext",
+							"vietnamese"
+						],
+						fallbacks: [
+							"ui-sans-serif",
+							"system-ui",
+							"sans-serif"
+						]
+					}],
 					vite: createViteConfig({
 						serializableConfig,
 						resolvedConfig,