@master/css-astro 0.0.0-site.1793659883.g69c9aebcf628

package/README.md

@@ -0,0 +1,110 @@
+<br>
+<div align="center">
+
+<p align="center">
+  <a href="https://css.master.co">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/33840671/201701649-3bb7d698-abec-4d5f-ac30-ccc4d7bafcd4.svg">
+      <source media="(prefers-color-scheme: light)" srcset="https://user-images.githubusercontent.com/33840671/201703010-77bf2373-9899-40cc-98f5-30cf9b546941.svg">
+      <img alt="Master CSS" src="https://user-images.githubusercontent.com/33840671/201703010-77bf2373-9899-40cc-98f5-30cf9b546941.svg" width="100%">
+    </picture>
+  </a>
+</p>
+<p align="center">Astro integration for Master CSS</p>
+
+<p align="center">
+  <a aria-label="GitHub release (latest by date including pre-releases)" href="https://github.com/master-co/css/releases">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=212022&label=&style=for-the-badge&logo=github&logoColor=fff">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=f6f7f8&label=&style=for-the-badge&logo=github&logoColor=%23000">
+      <img alt="NPM Version" src="https://img.shields.io/github/v/release/master-co/css?include_prereleases&color=f6f7f8&label=&style=for-the-badge&logo=github">
+    </picture>
+  </a>
+  <a aria-label="NPM Package" href="https://www.npmjs.com/package/@master/css-astro">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/npm/dm/@master/css-astro?color=212022&label=%20&logo=npm&style=for-the-badge">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/npm/dm/@master/css-astro?color=f6f7f8&label=%20&logo=npm&style=for-the-badge">
+      <img alt="NPM package ( download / month )" src="https://img.shields.io/npm/dm/@master/css-astro?color=f6f7f8&label=%20&logo=npm&style=for-the-badge">
+    </picture>
+  </a>
+  <a aria-label="Discord Community" href="https://discord.gg/sZNKpAAAw6">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/discord/917780624314613760?color=212022&label=%20&logo=discord&style=for-the-badge">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/discord/917780624314613760?color=f6f7f8&label=%20&logo=discord&style=for-the-badge">
+      <img alt="Discord online" src="https://img.shields.io/discord/917780624314613760?color=f6f7f8&label=%20&logo=discord&style=for-the-badge">
+    </picture>
+  </a>
+  <a aria-label="Follow @mastercorg" href="https://twitter.com/mastercorg">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/static/v1?label=%20&message=twitter&color=212022&logo=twitter&style=for-the-badge">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/static/v1?label=%20&message=twitter&color=f6f7f8&logo=twitter&style=for-the-badge">
+      <img alt="Follow @mastercorg" src="https://img.shields.io/static/v1?label=%20&message=twitter&color=f6f7f8&logo=twitter&style=for-the-badge">
+    </picture>
+  </a>
+  <a aria-label="Github Actions" href="https://github.com/master-co/css/actions/workflows/ci-release.yml">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/github/actions/workflow/status/master-co/css/ci-release.yml?branch=rc&label=%20&message=twitter&color=212022&logo=githubactions&style=for-the-badge">
+      <source media="(prefers-color-scheme: light)" srcset="https://img.shields.io/github/actions/workflow/status/master-co/css/ci-release.yml?branch=rc&label=%20&message=twitter&color=f6f7f8&logo=githubactions&style=for-the-badge&logoColor=%23000">
+      <img alt="Github release actions" src="https://img.shields.io/github/actions/workflow/status/master-co/css/ci-release.yml?branch=rc&label=%20&message=twitter&color=f6f7f8&logo=githubactions&style=for-the-badge&logoColor=%23000">
+    </picture>
+  </a>
+</p>
+
+</div>
+
+## Installation
+
+```bash
+npm install @master/css-astro
+```
+
+## Usage
+
+```js
+import { defineConfig } from 'astro/config'
+import masterCSS from '@master/css-astro'
+
+export default defineConfig({
+  integrations: [
+    masterCSS()
+  ]
+})
+```
+
+The integration uses `static` mode by default, generating CSS at build time without injecting the browser runtime. Choose `mode: 'progressive'` to register Astro middleware that pre-renders initial CSS into `<style id="master-css">` and injects the runtime script for browser hydration. The runtime downloads its engine and the runtime program only when a page introduces a class that was not pre-rendered. Source extraction for `.astro` files is handled automatically by `@master/css-tooling/source`.
+
+In static builds with `mode: 'runtime'`, the integration modulepreloads the runtime script and preloads the emitted runtime program with `<link rel="preload" as="fetch">` when it also injects the runtime script. To omit the browser runtime, choose `static` or `pre-render`; `runtime: false` conflicts with `runtime` and `progressive` modes and is rejected. SSR-only Astro output does not receive these preloads because the integration cannot reliably resolve the final client program asset URL at build time.
+
+```css
+@import '@master/css';
+```
+
+## Options
+
+The `options` object extends `@master/css-vite` plugin options and is passed to the Astro integration.
+
+```js
+import { defineConfig } from 'astro/config'
+import masterCSS from '@master/css-astro'
+
+export default defineConfig({
+  integrations: [
+    masterCSS({
+      mode: 'progressive'
+    })
+  ]
+})
+```
+
+For `pre-render` and `progressive` modes, Astro owns the HTML rendering step through `@master/css-astro/middleware`, so you do not need to add `@master/css-server` manually.
+
+Default options:
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `enabled` | `true` | Enables the integration. |
+| `mode` | `'static'` | Selects static, pre-render, runtime, or progressive rendering. |
+| `scanner` | `{}` | Scanner configuration passed through to the shared Vite pipeline. |
+| `runtime` | `{ enabled: false }` | Enabled by runtime/progressive modes; optional FOUC protection. Explicit enabled values must agree with the mode. |
+
+See the [Astro installation guide](https://rc.css.master.co/guide/installation/astro) for a full project setup.

package/dist/core.d.ts

@@ -0,0 +1,35 @@
+import { MasterCSSVitePluginOptions, createMasterCSSVitePlugin } from "@master/css-vite";
+import { AstroIntegration } from "astro";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+import { MasterCSSAstroIntegrationOptions } from "./options.js";
+declare const ASTRO_MIDDLEWARE_ENTRYPOINT = "@master/css-astro/middleware";
+declare const ASTRO_SSR_EXTERNAL: string[];
+declare const ASTRO_RUNTIME_INJECTION = "import \"virtual:master-css-runtime\";";
+type Plugin = ReturnType<typeof createMasterCSSVitePlugin>[number];
+type BuildEnvironment = {
+  name: string;
+  config: {
+    consumer?: string;
+  };
+};
+/** The emitted-globals plugin's `api` from @master/css-vite. */
+type EmittedGlobalsPluginAPI = {
+  finalize?: (environment: BuildEnvironment, emittedGlobals: Required<MasterCSSEmittedGlobals>) => MasterCSSEmittedGlobals;
+};
+/**
+ * Astro renders server asset URLs as public paths and moves server assets into
+ * the client output before prerendering, so a server bundle cannot import an
+ * emitted manifest asset. Server environments therefore receive inline manifests;
+ * client environments keep the emitted asset and its preload.
+ */
+declare function inlineServerManifests(plugin: Plugin): Plugin;
+/**
+ * Astro links the CSS its server environments process on pages whose runtime
+ * the client environment bundles without importing that CSS. Astro builds the
+ * server environments first, so the client bundle also counts their emitted
+ * globals, as a Vite runtime bundle counts the CSS delivered beside it.
+ */
+declare function deliverServerEmittedGlobals(plugins: readonly Plugin[]): void;
+declare function createAstroVitePlugins(options: MasterCSSVitePluginOptions): import("vite").Plugin<any>[];
+declare function createMasterCSSAstroIntegration(specifiedOptions?: MasterCSSAstroIntegrationOptions): AstroIntegration;
+export { ASTRO_MIDDLEWARE_ENTRYPOINT, ASTRO_RUNTIME_INJECTION, ASTRO_SSR_EXTERNAL, EmittedGlobalsPluginAPI, createAstroVitePlugins, createMasterCSSAstroIntegration, createMasterCSSAstroIntegration as default, deliverServerEmittedGlobals, inlineServerManifests };

package/dist/core.js

@@ -0,0 +1,147 @@
+import { providePrerenderStylesheets } from "./prerender-stylesheets.js";
+import { mergeEmittedGlobals } from "./internal/src/emitted-globals-module.js";
+import { externalizeAstroHydrationManifests } from "./external-hydration-manifest.js";
+import { preloadAstroRuntimeAssets } from "./runtime-preload.js";
+import { describeOutputStylesheets } from "./output-stylesheets.js";
+import { resolveMasterCSSAstroIntegrationOptions } from "./options.js";
+import { createMasterCSSVitePlugin } from "@master/css-vite";
+// src/core.ts
+const ASTRO_MIDDLEWARE_ENTRYPOINT = "@master/css-astro/middleware";
+const ASTRO_SSR_EXTERNAL = ["@master/css-server"];
+const ASTRO_RUNTIME_INJECTION = "import \"virtual:master-css-runtime\";";
+const ASTRO_OMITTED_VITE_PLUGINS = /* @__PURE__ */ new Set([
+	"master-css:pre-render",
+	"master-css:inject-runtime",
+	"master-css:inject-runtime:serve",
+	"master-css:runtime-preload",
+	"master-css:manifest-preload"
+]);
+const MANIFEST_MODULE_PLUGINS = /* @__PURE__ */ new Set(["master-css:virtual-module:manifest", "master-css:manifest-loader"]);
+const EMITTED_GLOBALS_PLUGIN = "master-css:virtual-module:emitted-globals";
+function withoutAssetEmission(context) {
+	return new Proxy(context, { get(target, key) {
+		if (key === "emitFile") return void 0;
+		const value = Reflect.get(target, key, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
+function inlineServerManifestLoad(plugin) {
+	const load = plugin.load;
+	if (!load) return plugin;
+	const handler = typeof load === "function" ? load : load.handler;
+	const inlineLoad = function(...args) {
+		return handler.apply(this.environment?.config.consumer === "server" ? withoutAssetEmission(this) : this, args);
+	};
+	return {
+		...plugin,
+		load: typeof load === "function" ? inlineLoad : {
+			...load,
+			handler: inlineLoad
+		}
+	};
+}
+/**
+* Astro renders server asset URLs as public paths and moves server assets into
+* the client output before prerendering, so a server bundle cannot import an
+* emitted manifest asset. Server environments therefore receive inline manifests;
+* client environments keep the emitted asset and its preload.
+*/
+function inlineServerManifests(plugin) {
+	if (!MANIFEST_MODULE_PLUGINS.has(plugin.name)) return plugin;
+	const applyToEnvironment = plugin.applyToEnvironment;
+	const applyInlineServerManifests = async function(environment) {
+		const applied = applyToEnvironment ? await applyToEnvironment.call(this, environment) : true;
+		if (!applied || applied === true || Array.isArray(applied)) return applied;
+		return environment.config.consumer === "server" ? inlineServerManifestLoad(applied) : applied;
+	};
+	return {
+		...inlineServerManifestLoad(plugin),
+		applyToEnvironment: applyInlineServerManifests
+	};
+}
+/**
+* Astro links the CSS its server environments process on pages whose runtime
+* the client environment bundles without importing that CSS. Astro builds the
+* server environments first, so the client bundle also counts their emitted
+* globals, as a Vite runtime bundle counts the CSS delivered beside it.
+*/
+function deliverServerEmittedGlobals(plugins) {
+	const api = plugins.find((plugin) => plugin.name === EMITTED_GLOBALS_PLUGIN)?.api;
+	if (!api) return;
+	const server = /* @__PURE__ */ new Map();
+	api.finalize = (environment, emittedGlobals) => {
+		if (environment.config.consumer === "client") return mergeEmittedGlobals(emittedGlobals, ...server.values());
+		server.set(environment.name, emittedGlobals);
+		return emittedGlobals;
+	};
+}
+function createAstroVitePlugins(options) {
+	const plugins = createMasterCSSVitePlugin(options);
+	if (options.mode === "runtime") deliverServerEmittedGlobals(plugins);
+	return plugins.filter((plugin) => !ASTRO_OMITTED_VITE_PLUGINS.has(plugin.name)).map(inlineServerManifests);
+}
+function getViteOptions(options) {
+	return {
+		enabled: options.enabled,
+		mode: options.mode,
+		scanner: options.scanner,
+		pruneNativeCSS: options.pruneNativeCSS,
+		runtime: options.runtime
+	};
+}
+function createMasterCSSAstroIntegration(specifiedOptions = {}) {
+	const options = resolveMasterCSSAstroIntegrationOptions(specifiedOptions);
+	if (!options.enabled) return {
+		name: "@master/css-astro",
+		hooks: {}
+	};
+	let astroBase;
+	let buildOutput;
+	let clientDir;
+	let outputStylesheets;
+	return {
+		name: "@master/css-astro",
+		hooks: {
+			"astro:config:setup": async ({ addMiddleware, injectScript, updateConfig }) => {
+				switch (options.mode) {
+					case "progressive":
+					case "runtime": if (options.injectRuntime) injectScript("page", ASTRO_RUNTIME_INJECTION);
+				}
+				switch (options.mode) {
+					case "pre-render":
+					case "progressive": addMiddleware({
+						order: "pre",
+						entrypoint: ASTRO_MIDDLEWARE_ENTRYPOINT
+					});
+				}
+				updateConfig({
+					build: { inlineStylesheets: "never" },
+					vite: {
+						define: { __MASTER_CSS_ASTRO_PROGRESSIVE__: JSON.stringify(options.mode === "progressive") },
+						plugins: createAstroVitePlugins(getViteOptions(options)),
+						ssr: { external: ASTRO_SSR_EXTERNAL },
+						build: { rollupOptions: { external: ASTRO_SSR_EXTERNAL } }
+					}
+				});
+			},
+			"astro:config:done": async ({ config, buildOutput: output }) => {
+				astroBase = config.base;
+				buildOutput = output;
+				clientDir = output === "static" ? config.outDir : config.build?.client;
+			},
+			"astro:build:start": () => {
+				outputStylesheets = void 0;
+				if (options.mode !== "pre-render" && options.mode !== "progressive") return;
+				providePrerenderStylesheets({ stylesheets: () => outputStylesheets ??= describeOutputStylesheets(clientDir, astroBase) });
+			},
+			"astro:build:done": async ({ dir }) => {
+				providePrerenderStylesheets(void 0);
+				if (options.mode === "runtime" && options.injectRuntime && buildOutput !== "server") await preloadAstroRuntimeAssets(dir, astroBase);
+				switch (options.mode) {
+					case "progressive": await externalizeAstroHydrationManifests(dir, astroBase);
+				}
+			}
+		}
+	};
+}
+export { ASTRO_MIDDLEWARE_ENTRYPOINT, ASTRO_RUNTIME_INJECTION, ASTRO_SSR_EXTERNAL, createAstroVitePlugins, createMasterCSSAstroIntegration, createMasterCSSAstroIntegration as default, deliverServerEmittedGlobals, inlineServerManifests };

package/dist/external-hydration-manifest.d.ts

@@ -0,0 +1,2 @@
+declare function externalizeAstroHydrationManifests(dir: URL | string, base?: string): Promise<string[]>;
+export { externalizeAstroHydrationManifests };

package/dist/external-hydration-manifest.js

@@ -0,0 +1,68 @@
+import { toHashedManifestAssetFileName } from "./internal/src/node.js";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MASTER_CSS_RUNTIME_STYLE_ID } from "@master/css-schema/runtime-style";
+import { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID } from "@master/css-schema/hydration-manifest";
+// src/external-hydration-manifest.ts
+function isMasterCSSRenderedHTML(html) {
+	return new RegExp(String.raw`<style\b(?=[^>]*\bid=(["'])${MASTER_CSS_RUNTIME_STYLE_ID}\1)`, "i").test(html);
+}
+function escapeRegExp(source) {
+	return source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeAttributeValue(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function createHydrationManifestScriptPattern(flags) {
+	return new RegExp(String.raw`<script\b(?=[^>]*\bid=(["'])${escapeRegExp(MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID)}\1)[^>]*>([\s\S]*?)<\/script>`, flags);
+}
+function getInlineMasterCSSHydrationManifestJSON(html) {
+	return html.match(createHydrationManifestScriptPattern("i"))?.[2]?.trim();
+}
+function externalizeMasterCSSHydrationManifest(html, source) {
+	const stylePattern = new RegExp(String.raw`<style\b(?=[^>]*\bid=(["'])${escapeRegExp(MASTER_CSS_RUNTIME_STYLE_ID)}\1)[^>]*>`, "i");
+	const attributePattern = new RegExp(String.raw`\s${escapeRegExp(MASTER_CSS_HYDRATION_MANIFEST_ATTR)}(?:=(?:"[^"]*"|'[^']*'|[^\s>]*))?`, "i");
+	return html.replace(createHydrationManifestScriptPattern("gi"), "").replace(stylePattern, (openingTag) => openingTag.replace(attributePattern, "").replace(/>$/, ` ${MASTER_CSS_HYDRATION_MANIFEST_ATTR}="${escapeAttributeValue(source)}">`));
+}
+function toHydrationManifestAssetURL(fileName, base = MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE) {
+	return `${base.replace(/\/?$/, "/")}${fileName}`;
+}
+function toPublicAssetBase(base = "/") {
+	return `${base.replace(/\/?$/, "/")}_master-css/hydration/`;
+}
+async function collectHTMLFiles(dir, files = []) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const filePath = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name !== "_master-css") await collectHTMLFiles(filePath, files);
+		} else if (entry.isFile() && entry.name.endsWith(".html")) files.push(filePath);
+	}
+	return files;
+}
+async function externalizeAstroHydrationManifests(dir, base) {
+	const root = typeof dir === "string" ? dir : fileURLToPath(dir);
+	const htmlFiles = await collectHTMLFiles(root);
+	const writtenFiles = [];
+	for (const htmlFile of htmlFiles) {
+		const html = await readFile(htmlFile, "utf8");
+		if (!isMasterCSSRenderedHTML(html)) continue;
+		const json = getInlineMasterCSSHydrationManifestJSON(html);
+		if (!json) continue;
+		try {
+			JSON.parse(json);
+		} catch {
+			continue;
+		}
+		const fileName = toHashedManifestAssetFileName(json, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME);
+		const outputDir = join(root, "_master-css", "hydration");
+		const outputFile = join(outputDir, fileName);
+		await mkdir(outputDir, { recursive: true });
+		await writeFile(outputFile, json);
+		await writeFile(htmlFile, externalizeMasterCSSHydrationManifest(html, toHydrationManifestAssetURL(fileName, toPublicAssetBase(base))));
+		writtenFiles.push(outputFile);
+	}
+	return writtenFiles;
+}
+export { externalizeAstroHydrationManifests };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { MasterCSSAstroIntegrationOptions } from "./options.js";
+import { createMasterCSSAstroIntegration, createMasterCSSAstroIntegration as core_default } from "./core.js";
+export { type MasterCSSAstroIntegrationOptions, createMasterCSSAstroIntegration, core_default as default };

package/dist/index.js

@@ -0,0 +1 @@
+export { createMasterCSSAstroIntegration, createMasterCSSAstroIntegration as default } from "./core.js";

package/dist/internal/src/emitted-globals-module.js

@@ -0,0 +1,11 @@
+// ../internal/src/emitted-globals-module.ts
+/** Count globals that separate stylesheet hosts emit, as runtime engines register them. */
+function mergeEmittedGlobals(...sources) {
+	const merged = {
+		variables: {},
+		keyframes: {}
+	};
+	for (const source of sources) for (const kind of ["variables", "keyframes"]) for (const [name, count] of Object.entries(source[kind] || {})) if (count) merged[kind][name] = Math.min(4294967295, (merged[kind][name] || 0) + count);
+	return merged;
+}
+export { mergeEmittedGlobals };

package/dist/internal/src/node.js

@@ -0,0 +1,7 @@
+import "node:path";
+import { createHash } from "node:crypto";
+// ../internal/src/node.ts
+function toHashedManifestAssetFileName(json, basename = "master-css-manifest") {
+	return `${basename}.${createHash("sha256").update(json).digest("hex").slice(0, 8)}.json`;
+}
+export { toHashedManifestAssetFileName };

package/dist/internal/src/program-module.js

@@ -0,0 +1,25 @@
+// ../internal/src/program-module.ts
+const MASTER_CSS_PROGRAM_PRELOAD_REL = "preload";
+const MASTER_CSS_PROGRAM_PRELOAD_AS = "fetch";
+function escapeAttributeValue(value) {
+	return value.replace(/&/g, "&").replace(/"/g, """);
+}
+function toProgramPreloadLinkAttrs(href) {
+	return {
+		rel: MASTER_CSS_PROGRAM_PRELOAD_REL,
+		as: MASTER_CSS_PROGRAM_PRELOAD_AS,
+		crossorigin: "",
+		href
+	};
+}
+function toProgramPreloadLinkTag(href) {
+	const attrs = toProgramPreloadLinkAttrs(href);
+	return [
+		"<link",
+		`rel="${attrs.rel}"`,
+		`as="${attrs.as}"`,
+		"crossorigin",
+		`href="${escapeAttributeValue(attrs.href)}">`
+	].join(" ");
+}
+export { MASTER_CSS_PROGRAM_PRELOAD_AS, MASTER_CSS_PROGRAM_PRELOAD_REL, toProgramPreloadLinkAttrs, toProgramPreloadLinkTag };

package/dist/internal/src/runtime-bootstrap.js

@@ -0,0 +1,12 @@
+// ../internal/src/runtime-bootstrap.ts
+/** Resolve the public delivery contract before any adapter injects code. */
+function resolveIntegrationRuntime(mode, runtime) {
+	const options = typeof runtime === "object" ? runtime : { enabled: runtime };
+	const enabled = mode === "runtime" || mode === "progressive";
+	if (options.enabled !== void 0 && options.enabled !== enabled) throw new TypeError(`Master CSS mode "${mode}" requires runtime.enabled=${enabled}. Select a consistent rendering mode.`);
+	return {
+		...options,
+		enabled
+	};
+}
+export { resolveIntegrationRuntime };

package/dist/middleware.d.ts

@@ -0,0 +1,2 @@
+declare const onRequest: import("astro").MiddlewareHandler;
+export { onRequest };

package/dist/middleware.js

@@ -0,0 +1,6 @@
+import { createMasterCSSMiddleware } from "./server.js";
+import manifest from "virtual:master-css-manifest";
+import emittedGlobals from "virtual:master-css-emitted-globals";
+// src/middleware.ts
+const onRequest = createMasterCSSMiddleware(manifest, emittedGlobals, __MASTER_CSS_ASTRO_PROGRESSIVE__);
+export { onRequest };

package/dist/options.d.ts

@@ -0,0 +1,11 @@
+import { MasterCSSVitePluginOptions } from "@master/css-vite";
+import { MasterCSSIntegrationRuntimeOptions } from "@master/css-schema/integration";
+type MasterCSSAstroIntegrationOptions = MasterCSSVitePluginOptions;
+interface ResolvedMasterCSSAstroIntegrationOptions extends Omit<MasterCSSAstroIntegrationOptions, 'runtime'> {
+  enabled: boolean;
+  mode: NonNullable<MasterCSSAstroIntegrationOptions['mode']>;
+  injectRuntime: boolean;
+  runtime: MasterCSSIntegrationRuntimeOptions;
+}
+declare function resolveMasterCSSAstroIntegrationOptions(options?: MasterCSSAstroIntegrationOptions): ResolvedMasterCSSAstroIntegrationOptions;
+export { MasterCSSAstroIntegrationOptions, ResolvedMasterCSSAstroIntegrationOptions, resolveMasterCSSAstroIntegrationOptions };

package/dist/options.js

@@ -0,0 +1,14 @@
+import { resolveIntegrationRuntime } from "./internal/src/runtime-bootstrap.js";
+// src/options.ts
+function resolveMasterCSSAstroIntegrationOptions(options = {}) {
+	const mode = options.mode ?? "static";
+	const runtime = resolveIntegrationRuntime(mode, options.runtime);
+	return {
+		...options,
+		enabled: options.enabled ?? true,
+		mode,
+		runtime,
+		injectRuntime: runtime.enabled
+	};
+}
+export { resolveMasterCSSAstroIntegrationOptions };

package/dist/output-stylesheets.d.ts

@@ -0,0 +1,4 @@
+import { MasterCSSServerStylesheet } from "@master/css-server";
+/** Describe every final stylesheet in Astro's client output for server rendering. */
+declare function describeOutputStylesheets(dir: URL | string, base?: string): Promise<MasterCSSServerStylesheet[]>;
+export { describeOutputStylesheets };

package/dist/output-stylesheets.js

@@ -0,0 +1,24 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describeLinkedStylesheet } from "@master/css-compiler/stylesheet";
+// src/output-stylesheets.ts
+async function collectStylesheetFiles(dir, files = []) {
+	for (const entry of await readdir(dir, { withFileTypes: true })) {
+		const file = join(dir, entry.name);
+		if (entry.isDirectory()) await collectStylesheetFiles(file, files);
+		else if (entry.isFile() && entry.name.endsWith(".css")) files.push(file);
+	}
+	return files;
+}
+/** Describe every final stylesheet in Astro's client output for server rendering. */
+async function describeOutputStylesheets(dir, base = "/") {
+	const root = typeof dir === "string" ? dir : fileURLToPath(dir);
+	const files = (await collectStylesheetFiles(root)).sort();
+	if (!files.length) return [];
+	const prefix = base.replace(/\/?$/, "/");
+	const hrefs = files.map((file) => prefix + relative(root, file).split(sep).join("/"));
+	const sources = await Promise.all(files.map((file) => readFile(file, "utf8")));
+	return files.map((_, index) => describeLinkedStylesheet(sources[index], hrefs[index], hrefs));
+}
+export { describeOutputStylesheets };

package/dist/prerender-stylesheets.d.ts

@@ -0,0 +1,14 @@
+import { MasterCSSServerStylesheet } from "@master/css-server";
+interface PrerenderStylesheets {
+  /** Final stylesheets in the client output. */
+  stylesheets(): Promise<readonly MasterCSSServerStylesheet[]>;
+}
+/**
+ * Astro prerenders after it moves the final CSS into the client output, inside
+ * the building process. The integration lends the middleware those stylesheets
+ * there, keeping the compiler and filesystem out of server bundles; deployed
+ * server routes render without them.
+ */
+declare function providePrerenderStylesheets(provider: PrerenderStylesheets | undefined): void;
+declare function prerenderStylesheets(): PrerenderStylesheets | undefined;
+export { PrerenderStylesheets, prerenderStylesheets, providePrerenderStylesheets };

package/dist/prerender-stylesheets.js

@@ -0,0 +1,15 @@
+// src/prerender-stylesheets.ts
+const PRERENDER_STYLESHEETS = Symbol.for("@master/css-astro:prerender-stylesheets");
+/**
+* Astro prerenders after it moves the final CSS into the client output, inside
+* the building process. The integration lends the middleware those stylesheets
+* there, keeping the compiler and filesystem out of server bundles; deployed
+* server routes render without them.
+*/
+function providePrerenderStylesheets(provider) {
+	globalThis[PRERENDER_STYLESHEETS] = provider;
+}
+function prerenderStylesheets() {
+	return globalThis[PRERENDER_STYLESHEETS];
+}
+export { prerenderStylesheets, providePrerenderStylesheets };

package/dist/runtime-preload.d.ts

@@ -0,0 +1,2 @@
+declare function preloadAstroRuntimeAssets(dir: URL | string, base?: string): Promise<string[]>;
+export { preloadAstroRuntimeAssets };

package/dist/runtime-preload.js

@@ -0,0 +1,96 @@
+import { toProgramPreloadLinkTag } from "./internal/src/program-module.js";
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+// src/runtime-preload.ts
+const RUNTIME_PROGRAM_REFERENCE_PATTERN = /new URL\((["'])([^"']*master-css-program[^"']*\.bin)\1\s*,\s*import\.meta\.url\)\.href/g;
+function escapeRegExp(source) {
+	return source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function toRootPath(dir) {
+	return typeof dir === "string" ? dir : fileURLToPath(dir);
+}
+function toPublicBase(base = "/") {
+	return `${base || "/"}`.replace(/\/?$/, "/");
+}
+function toPublicAssetHref(root, file, base) {
+	const outputPath = relative(root, file).split(sep).join("/");
+	return `${toPublicBase(base)}${outputPath.replace(/^\/+/, "")}`;
+}
+function hasProgramPreloadLink(html, href) {
+	const quotedHref = escapeRegExp(href);
+	return new RegExp(String.raw`<link\b(?=[^>]*\brel=(["'])preload\1)(?=[^>]*\bas=(["'])fetch\2)(?=[^>]*\bhref=(["'])${quotedHref}\3)[^>]*>`, "i").test(html);
+}
+function escapeAttributeValue(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function hasRuntimeScriptPreloadLink(html, href) {
+	const quotedHref = escapeRegExp(href);
+	return new RegExp(String.raw`<link\b(?=[^>]*\brel=(["'])modulepreload\1)(?=[^>]*\bhref=(["'])${quotedHref}\2)[^>]*>`, "i").test(html);
+}
+function toRuntimeScriptPreloadLinkTag(href) {
+	return `<link rel="modulepreload" crossorigin href="${escapeAttributeValue(href)}">`;
+}
+function injectRuntimePreloads(html, runtimeScriptHref, programHref) {
+	const tags = [];
+	if (runtimeScriptHref && !hasRuntimeScriptPreloadLink(html, runtimeScriptHref)) tags.push(toRuntimeScriptPreloadLinkTag(runtimeScriptHref));
+	if (!hasProgramPreloadLink(html, programHref)) tags.push(toProgramPreloadLinkTag(programHref));
+	if (!tags.length) return html;
+	return html.replace(/<head\b[^>]*>/i, (openingTag) => `${openingTag}${tags.join("")}`);
+}
+async function pathExists(file) {
+	try {
+		return (await stat(file)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function collectOutputFiles(dir, files = []) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+		const filePath = join(dir, entry.name);
+		if (entry.isDirectory()) await collectOutputFiles(filePath, files);
+		else if (entry.isFile()) files.push(filePath);
+	}
+	return files;
+}
+function isProgramAssetFile(file) {
+	const name = basename(file);
+	return name.startsWith("master-css-program") && name.endsWith(".bin");
+}
+async function findRuntimePreloadAssets(files) {
+	for (const file of files) {
+		if (!file.endsWith(".js")) continue;
+		const source = await readFile(file, "utf8");
+		for (const match of source.matchAll(RUNTIME_PROGRAM_REFERENCE_PATTERN)) {
+			const specifier = match[2];
+			if (!specifier) continue;
+			const programFile = join(dirname(file), specifier);
+			if (await pathExists(programFile)) return {
+				programFile,
+				runtimeScriptFile: file
+			};
+		}
+	}
+	const programFile = files.find(isProgramAssetFile);
+	if (!programFile) return;
+	return { programFile };
+}
+async function preloadAstroRuntimeAssets(dir, base) {
+	const root = toRootPath(dir);
+	const files = await collectOutputFiles(root);
+	const assets = await findRuntimePreloadAssets(files);
+	if (!assets) return [];
+	const programHref = toPublicAssetHref(root, assets.programFile, base);
+	const runtimeScriptHref = assets.runtimeScriptFile ? toPublicAssetHref(root, assets.runtimeScriptFile, base) : void 0;
+	const updatedFiles = [];
+	for (const htmlFile of files.filter((file) => file.endsWith(".html"))) {
+		const html = await readFile(htmlFile, "utf8");
+		const nextHTML = injectRuntimePreloads(html, runtimeScriptHref, programHref);
+		if (nextHTML === html) continue;
+		await writeFile(htmlFile, nextHTML);
+		updatedFiles.push(htmlFile);
+	}
+	return updatedFiles;
+}
+export { preloadAstroRuntimeAssets };

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { MiddlewareHandler } from "astro";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+declare function isHTMLResponse(response: Response): boolean;
+declare function createResponse(response: Response, body: BodyInit | null): Response;
+declare function renderResponse(response: Response, manifest: MasterCSSManifest): Promise<Response>;
+declare function createMasterCSSMiddleware(manifest: MasterCSSManifest, emittedGlobals?: MasterCSSEmittedGlobals, hydrate?: boolean): MiddlewareHandler;
+export { createMasterCSSMiddleware, createResponse, isHTMLResponse, renderResponse };

package/dist/server.js

@@ -0,0 +1,43 @@
+import { prerenderStylesheets } from "./prerender-stylesheets.js";
+import { createServerRenderer, renderHTML } from "@master/css-server";
+// src/server.ts
+const BODYLESS_STATUSES = /* @__PURE__ */ new Set([
+	204,
+	205,
+	304
+]);
+function isHTMLResponse(response) {
+	return response.headers.get("content-type")?.toLowerCase().includes("text/html") || false;
+}
+function createResponse(response, body) {
+	const headers = new Headers(response.headers);
+	headers.delete("content-length");
+	return new Response(body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+async function renderResponse(response, manifest) {
+	if (BODYLESS_STATUSES.has(response.status) || !isHTMLResponse(response)) return response;
+	return createResponse(response, renderHTML(await response.text(), {
+		manifest,
+		hydrationManifest: "inject"
+	}).html);
+}
+function createMasterCSSMiddleware(manifest, emittedGlobals = {}, hydrate = true) {
+	const renderer = createServerRenderer({
+		manifest,
+		emittedGlobals
+	});
+	return async (context, next) => {
+		const response = await next();
+		if (BODYLESS_STATUSES.has(response.status) || !isHTMLResponse(response)) return response;
+		const prerender = context.isPrerendered ? prerenderStylesheets() : void 0;
+		return createResponse(response, renderer.renderHTML(await response.text(), {
+			hydrationManifest: hydrate ? "inject" : false,
+			stylesheets: await prerender?.stylesheets()
+		}).html);
+	};
+}
+export { createMasterCSSMiddleware, createResponse, isHTMLResponse, renderResponse };

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@master/css-astro",
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "license": "MIT",
+    "description": "Astro integration for Master CSS",
+    "author": "Aoyue Design LLC.",
+    "homepage": "https://css.master.co",
+    "bugs": {
+        "url": "https://github.com/master-co/css/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/master-co/css.git",
+        "directory": "packages/astro"
+    },
+    "keywords": [
+        "plugin",
+        "integration",
+        "astro",
+        "build tools",
+        "static rendering",
+        "static",
+        "runtime",
+        "css runtime",
+        "css",
+        "mastercss",
+        "astro-plugin"
+    ],
+    "sideEffects": false,
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        },
+        "./middleware": {
+            "types": "./dist/middleware.d.ts",
+            "import": "./dist/middleware.js",
+            "default": "./dist/middleware.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "peerDependencies": {
+        "astro": ">=5",
+        "vite": ">=6"
+    },
+    "dependencies": {
+        "@master/css": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-compiler": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-server": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-vite": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-schema": "0.0.0-site.1793659883.g69c9aebcf628"
+    },
+    "version": "0.0.0-site.1793659883.g69c9aebcf628",
+    "gitHead": "69c9aebcf628eb529001b9fa1b3536306f1b139e"
+}