@t09tanaka/stoneage 0.1.0

package/dist/agent-skill.d.ts

@@ -0,0 +1 @@
+export declare const stoneAgeAgentSkill = "---\nname: stoneage\ndescription: Use when working on a StoneAge static data-site, adding routes or artifacts, debugging generated output, validating publish readiness, or helping an agent use StoneAge in a project.\n---\n\n# StoneAge\n\nUse this skill when a project uses StoneAge or asks to generate, validate, inspect, optimize, or serve a StoneAge static data-site.\n\n## Project Direction\n\nStoneAge is a TypeScript static site generator for large data sites. Optimize for plain HTML output, explicit data flow, typed route generation, incremental generation from dependency hashes, publish validation, and small assets. Do not turn StoneAge into a general web application framework.\n\n## Minimal Example\n\nUse these real API names and import paths; do not invent others. Core build: `buildSite`. HTML pages: `defineRouteFamily`. Public data outputs: `defineArtifactFamily` with `jsonArtifact` / `csvArtifact`. Deferred HTML fragments: `defineFragmentFamily` plus `deferredFragment` from the `/fragment` subpath. HTML rendering: `html` / `renderToString` from the `/html` subpath.\n\n```ts\nimport {\n  buildSite,\n  defineRouteFamily,\n  defineArtifactFamily,\n  defineFragmentFamily,\n  jsonArtifact,\n  csvArtifact,\n  type SiteConfig,\n} from \"@t09tanaka/stoneage\";\nimport { deferredFragment } from \"@t09tanaka/stoneage/fragment\";\nimport { html, renderToString } from \"@t09tanaka/stoneage/html\";\n\nconst members = [{ id: \"m1\", slug: \"ada\", name: \"Ada\", district: \"Central\" }];\n\nconst site: SiteConfig = {\n  baseUrl: \"https://example.com\",\n  title: \"Example\",\n  description: \"A generated data-site.\",\n};\n\nconst memberDetails = defineFragmentFamily({\n  name: \"memberDetails\",\n  pattern: \"members/:slug/details\",\n  entries: () =>\n    members.map((member) => ({\n      params: { slug: member.slug },\n      dependencies: [\"member:\" + member.id],\n      render: () => renderToString(html(\"section\", null, member.name + \" details\")),\n    })),\n});\n\nconst memberPages = defineRouteFamily({\n  name: \"members\",\n  pattern: \"/members/:slug/\",\n  entries: () =>\n    members.map((member) => ({\n      params: { slug: member.slug },\n      dependencies: [\"member:\" + member.id],\n      metadata: { title: member.name, description: member.name + \" (\" + member.district + \")\" },\n      render: () =>\n        renderToString(\n          html(\n            \"main\",\n            null,\n            html(\"h1\", null, member.name),\n            deferredFragment({\n              src: memberDetails.path({ slug: member.slug }),\n              fallback: html(\"a\", { href: \"/members/\" + member.slug + \"/\" }, \"Read details\"),\n            }),\n          ),\n        ),\n    })),\n});\n\nconst memberData = defineArtifactFamily({\n  name: \"memberData\",\n  pattern: \"/data/members.json\",\n  entries: () => [\n    {\n      params: {},\n      dependencies: members.map((member) => \"member:\" + member.id),\n      render: () => jsonArtifact(members),\n    },\n  ],\n});\n\nawait buildSite({\n  outDir: \"dist\",\n  site,\n  routes: [memberPages],\n  artifacts: [memberData],\n  fragments: [memberDetails],\n});\n```\n\n`render` must return a string (wrap TSX or nodes with `renderToString`). Use `csvArtifact(text)` for CSV outputs. `dependencies` is a `Dependency[]`: a plain `\"key\"` string, or `{ key, hash }` / `{ key, value }` / `{ key, file }` when the site computes its own fingerprints.\n\n## Before Editing\n\n- Search existing buildSite usage before changing a site.\n- Read the local site build entrypoint, route families, artifact families, data normalization modules, and validation config.\n- Keep public data artifacts separate from HTML-only view models.\n- Prefer structured data models and parsers over ad hoc string manipulation.\n- If changing shared types, route patterns, artifact patterns, or build config contracts, inspect references and run TypeScript diagnostics.\n\n## Implementation Rules\n\n- Use route families for HTML pages and artifact families for public JSON, CSV, XML, text, or endpoint-style outputs.\n- Use fragment families for supplemental HTML that may load after the initial page. `deferredFragment()` provides a fragment self-link fallback by default; override it with a canonical page link when one exists, or pass `fallback: null` only when no-JS omission is acceptable. Do not defer the only copy of primary page content.\n- Attach dependencies to generated pages and artifacts so incremental rebuilds can skip unchanged output.\n- Use stable hashes for normalized data or source fingerprints when the site already computes them.\n- Keep rendering functions focused on HTML; keep normalization outside rendering.\n- Add metadata, sitemap, assets, redirects, headers, and validation settings explicitly in the build config.\n- Avoid browser runtime assumptions in core rendering code.\n\n## Useful Commands\n\n- `stoneage dev --out-dir <dir> --watch <path> --build-command \"<command>\"`: serve generated output with hot reload after successful rebuilds.\n- `stoneage validate --out-dir <dir>`: validate generated output before publishing.\n- `stoneage inspect --out-dir <dir> --dependency <key>`: list generated outputs depending on one dependency key.\n- `stoneage plan --out-dir <dir> --dependency <key>`: plan outputs affected by dependency keys.\n- `stoneage optimize --out-dir <dir>`: write precompressed public output sidecars.\n- `stoneage deploy --out-dir <dir> --provider netlify`: emit deploy artifacts.\n\n## Verification\n\n- Run the project's build command after route, artifact, or data-flow changes.\n- Run `stoneage validate` for publish-facing output changes.\n- Run targeted tests for changed data, routes, artifacts, CLI behavior, or validation logic.\n- For package changes in the StoneAge repository, run `npm run typecheck`, relevant `npm test -- <files>`, and `npm run check:package`.\n\n## Avoid\n\n- Do not mix public data exports into HTML-only view models.\n- Do not hide metadata or sitemap decisions inside templates.\n- Do not add compatibility layers, runtime hydration, or app-framework abstractions unless the user explicitly asks.\n- Do not rewrite generated output paths, route contracts, or dependency keys without checking existing manifests and callers.\n\n## References\n\nWhen a detail is not covered here, read the package docs instead of guessing the API: `getting-started.md` (minimal site), `site-build.md` (route families, artifact families, metadata, assets, validation, publishing), `fragments.md` (deferred fragments and triggers), `components.md` (`html()`, `renderToString()`, TSX, islands), `data-flow.md` (normalized data, dependencies, incremental rebuilds), and `migration.md` (SvelteKit). The public API is exported from `@t09tanaka/stoneage`, `@t09tanaka/stoneage/html`, and `@t09tanaka/stoneage/fragment`.\n";

package/dist/agent-skill.js

@@ -0,0 +1,140 @@
+export const stoneAgeAgentSkill = `---
+name: stoneage
+description: Use when working on a StoneAge static data-site, adding routes or artifacts, debugging generated output, validating publish readiness, or helping an agent use StoneAge in a project.
+---
+
+# StoneAge
+
+Use this skill when a project uses StoneAge or asks to generate, validate, inspect, optimize, or serve a StoneAge static data-site.
+
+## Project Direction
+
+StoneAge is a TypeScript static site generator for large data sites. Optimize for plain HTML output, explicit data flow, typed route generation, incremental generation from dependency hashes, publish validation, and small assets. Do not turn StoneAge into a general web application framework.
+
+## Minimal Example
+
+Use these real API names and import paths; do not invent others. Core build: \`buildSite\`. HTML pages: \`defineRouteFamily\`. Public data outputs: \`defineArtifactFamily\` with \`jsonArtifact\` / \`csvArtifact\`. Deferred HTML fragments: \`defineFragmentFamily\` plus \`deferredFragment\` from the \`/fragment\` subpath. HTML rendering: \`html\` / \`renderToString\` from the \`/html\` subpath.
+
+\`\`\`ts
+import {
+  buildSite,
+  defineRouteFamily,
+  defineArtifactFamily,
+  defineFragmentFamily,
+  jsonArtifact,
+  csvArtifact,
+  type SiteConfig,
+} from "@t09tanaka/stoneage";
+import { deferredFragment } from "@t09tanaka/stoneage/fragment";
+import { html, renderToString } from "@t09tanaka/stoneage/html";
+
+const members = [{ id: "m1", slug: "ada", name: "Ada", district: "Central" }];
+
+const site: SiteConfig = {
+  baseUrl: "https://example.com",
+  title: "Example",
+  description: "A generated data-site.",
+};
+
+const memberDetails = defineFragmentFamily({
+  name: "memberDetails",
+  pattern: "members/:slug/details",
+  entries: () =>
+    members.map((member) => ({
+      params: { slug: member.slug },
+      dependencies: ["member:" + member.id],
+      render: () => renderToString(html("section", null, member.name + " details")),
+    })),
+});
+
+const memberPages = defineRouteFamily({
+  name: "members",
+  pattern: "/members/:slug/",
+  entries: () =>
+    members.map((member) => ({
+      params: { slug: member.slug },
+      dependencies: ["member:" + member.id],
+      metadata: { title: member.name, description: member.name + " (" + member.district + ")" },
+      render: () =>
+        renderToString(
+          html(
+            "main",
+            null,
+            html("h1", null, member.name),
+            deferredFragment({
+              src: memberDetails.path({ slug: member.slug }),
+              fallback: html("a", { href: "/members/" + member.slug + "/" }, "Read details"),
+            }),
+          ),
+        ),
+    })),
+});
+
+const memberData = defineArtifactFamily({
+  name: "memberData",
+  pattern: "/data/members.json",
+  entries: () => [
+    {
+      params: {},
+      dependencies: members.map((member) => "member:" + member.id),
+      render: () => jsonArtifact(members),
+    },
+  ],
+});
+
+await buildSite({
+  outDir: "dist",
+  site,
+  routes: [memberPages],
+  artifacts: [memberData],
+  fragments: [memberDetails],
+});
+\`\`\`
+
+\`render\` must return a string (wrap TSX or nodes with \`renderToString\`). Use \`csvArtifact(text)\` for CSV outputs. \`dependencies\` is a \`Dependency[]\`: a plain \`"key"\` string, or \`{ key, hash }\` / \`{ key, value }\` / \`{ key, file }\` when the site computes its own fingerprints.
+
+## Before Editing
+
+- Search existing buildSite usage before changing a site.
+- Read the local site build entrypoint, route families, artifact families, data normalization modules, and validation config.
+- Keep public data artifacts separate from HTML-only view models.
+- Prefer structured data models and parsers over ad hoc string manipulation.
+- If changing shared types, route patterns, artifact patterns, or build config contracts, inspect references and run TypeScript diagnostics.
+
+## Implementation Rules
+
+- Use route families for HTML pages and artifact families for public JSON, CSV, XML, text, or endpoint-style outputs.
+- Use fragment families for supplemental HTML that may load after the initial page. \`deferredFragment()\` provides a fragment self-link fallback by default; override it with a canonical page link when one exists, or pass \`fallback: null\` only when no-JS omission is acceptable. Do not defer the only copy of primary page content.
+- Attach dependencies to generated pages and artifacts so incremental rebuilds can skip unchanged output.
+- Use stable hashes for normalized data or source fingerprints when the site already computes them.
+- Keep rendering functions focused on HTML; keep normalization outside rendering.
+- Add metadata, sitemap, assets, redirects, headers, and validation settings explicitly in the build config.
+- Avoid browser runtime assumptions in core rendering code.
+
+## Useful Commands
+
+- \`stoneage dev --out-dir <dir> --watch <path> --build-command "<command>"\`: serve generated output with hot reload after successful rebuilds.
+- \`stoneage validate --out-dir <dir>\`: validate generated output before publishing.
+- \`stoneage inspect --out-dir <dir> --dependency <key>\`: list generated outputs depending on one dependency key.
+- \`stoneage plan --out-dir <dir> --dependency <key>\`: plan outputs affected by dependency keys.
+- \`stoneage optimize --out-dir <dir>\`: write precompressed public output sidecars.
+- \`stoneage deploy --out-dir <dir> --provider netlify\`: emit deploy artifacts.
+
+## Verification
+
+- Run the project's build command after route, artifact, or data-flow changes.
+- Run \`stoneage validate\` for publish-facing output changes.
+- Run targeted tests for changed data, routes, artifacts, CLI behavior, or validation logic.
+- For package changes in the StoneAge repository, run \`npm run typecheck\`, relevant \`npm test -- <files>\`, and \`npm run check:package\`.
+
+## Avoid
+
+- Do not mix public data exports into HTML-only view models.
+- Do not hide metadata or sitemap decisions inside templates.
+- Do not add compatibility layers, runtime hydration, or app-framework abstractions unless the user explicitly asks.
+- Do not rewrite generated output paths, route contracts, or dependency keys without checking existing manifests and callers.
+
+## References
+
+When a detail is not covered here, read the package docs instead of guessing the API: \`getting-started.md\` (minimal site), \`site-build.md\` (route families, artifact families, metadata, assets, validation, publishing), \`fragments.md\` (deferred fragments and triggers), \`components.md\` (\`html()\`, \`renderToString()\`, TSX, islands), \`data-flow.md\` (normalized data, dependencies, incremental rebuilds), and \`migration.md\` (SvelteKit). The public API is exported from \`@t09tanaka/stoneage\`, \`@t09tanaka/stoneage/html\`, and \`@t09tanaka/stoneage/fragment\`.
+`;

package/dist/assets.d.ts

@@ -0,0 +1,125 @@
+export type ClientAssetAttributeValue = string | number | boolean | null | undefined;
+export type AssetFetchResponse = {
+    ok: boolean;
+    status: number;
+    text: () => Promise<string>;
+    arrayBuffer: () => Promise<ArrayBuffer>;
+};
+export type AssetFetch = (url: string, init?: {
+    headers?: Record<string, string>;
+}) => Promise<AssetFetchResponse>;
+export type GoogleFontsStylesheetOptions = {
+    families: string[];
+    text?: string;
+    display?: string;
+    endpoint?: string;
+    fontBasePath?: string;
+    userAgent?: string;
+    fetch?: AssetFetch;
+};
+export type ClientStylesheetAsset = string | {
+    href: string;
+    source: string;
+    immutable?: boolean;
+} | {
+    href: string;
+    googleFonts: GoogleFontsStylesheetOptions;
+    immutable?: boolean;
+};
+export type ClientScriptAsset = {
+    src: string;
+    source?: string;
+    immutable?: boolean;
+    module?: boolean;
+    defer?: boolean;
+    async?: boolean;
+    attributes?: Record<string, ClientAssetAttributeValue>;
+};
+export type ClientAssetDeclaration = {
+    stylesheets?: ClientStylesheetAsset[];
+    scripts?: ClientScriptAsset[];
+};
+export type ClientAssetRegistry = Record<string, ClientAssetDeclaration | ClientAssetDeclaration[]>;
+export type ResolvedClientAssets = {
+    stylesheets: ClientStylesheetAsset[];
+    scripts: ClientScriptAsset[];
+};
+export type ViteManifestChunk = {
+    file: string;
+    css?: string[];
+    imports?: string[];
+    assets?: string[];
+    isEntry?: boolean;
+};
+export type ViteManifest = Record<string, ViteManifestChunk>;
+export type ViteManifestAssetOptions = {
+    base?: string;
+    entriesOnly?: boolean;
+};
+export type ViteManifestPublicAssetOptions = {
+    sourceDir: string;
+    base?: string;
+};
+export type ViteBuildAssetOptions = ViteManifestPublicAssetOptions & ViteManifestAssetOptions;
+export type ViteBuildAssets = {
+    client: ClientAssetRegistry;
+    public: PublicAssetInput[];
+};
+export type TailwindUtilitiesInput = {
+    candidates: string[];
+    css?: string;
+};
+export type PublicAssetInput = {
+    source: string;
+    publicPath: string;
+} | {
+    content: string | Buffer | Uint8Array;
+    publicPath: string;
+};
+export type CopyPublicAssetsOptions = {
+    outDir: string;
+    assets: PublicAssetInput[];
+};
+export type CopyPublicAssetsResult = {
+    copied: string[];
+    skipped: string[];
+};
+export type ExpandPublicDirOptions = {
+    base?: string;
+};
+export declare function defineClientAssets<T extends ClientAssetRegistry>(assets: T): T;
+export type StylesheetAssetOptions = {
+    source: string;
+    immutable?: boolean;
+};
+export declare function stylesheet(href: string, options?: StylesheetAssetOptions): ClientAssetDeclaration;
+export declare function googleFontsStylesheet(href: string, options: GoogleFontsStylesheetOptions): ClientStylesheetAsset;
+export declare function script(src: string, options?: Omit<ClientScriptAsset, "src">): ClientAssetDeclaration;
+export declare function island(src: string, options?: Omit<ClientScriptAsset, "src" | "module">): ClientAssetDeclaration;
+export declare function resolveClientAssets(registry: ClientAssetRegistry, ids: string[]): ResolvedClientAssets;
+export declare function assetsFromViteManifest(manifest: ViteManifest, options?: ViteManifestAssetOptions): ClientAssetRegistry;
+export declare function loadAssetsFromViteManifest(path: string, options?: ViteManifestAssetOptions): Promise<ClientAssetRegistry>;
+export declare function publicAssetsFromViteManifest(manifest: ViteManifest, options: ViteManifestPublicAssetOptions): PublicAssetInput[];
+export declare function loadPublicAssetsFromViteManifest(path: string, options: ViteManifestPublicAssetOptions): Promise<PublicAssetInput[]>;
+export declare function viteBuildAssetsFromManifest(manifest: ViteManifest, options: ViteBuildAssetOptions): ViteBuildAssets;
+export declare function loadViteBuildAssetsFromManifest(path: string, options: ViteBuildAssetOptions): Promise<ViteBuildAssets>;
+/**
+ * Recursively walk a directory and expand every file into a `PublicAssetInput`
+ * whose `publicPath` mirrors the file's location relative to `dir`. The base of
+ * `dir` is the output root, so `public/images/logo.png` becomes
+ * `/images/logo.png` and `public/CNAME` becomes `/CNAME`.
+ *
+ * - Dotfiles and extensionless files (CNAME, .nojekyll) are included.
+ * - Nested subdirectories are walked to any depth.
+ * - Empty directories produce no entries (only regular files are copied).
+ * - Symlinks are not followed: a symlinked directory is not traversed (avoids
+ *   cycles) and a symlinked file is skipped (its `Dirent` is neither a
+ *   directory nor a regular file). Materialize the target into `dir` if you
+ *   need it copied.
+ * - A missing `dir` yields an empty list so a build can run before the
+ *   directory exists.
+ */
+export declare function expandPublicDir(dir: string, options?: ExpandPublicDirOptions): Promise<PublicAssetInput[]>;
+export declare function copyPublicAssets(options: CopyPublicAssetsOptions): Promise<CopyPublicAssetsResult>;
+export declare function buildTailwindUtilitiesCss(input: TailwindUtilitiesInput): Promise<string>;
+export declare function writeTailwindUtilitiesCss(path: string, input: TailwindUtilitiesInput): Promise<boolean>;

package/dist/assets.js

@@ -0,0 +1,341 @@
+import { copyFile, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+import { publicAssetOutputPath } from "./paths.js";
+export function defineClientAssets(assets) {
+    return assets;
+}
+export function stylesheet(href, options) {
+    return {
+        stylesheets: [options ? { href, ...options } : href],
+    };
+}
+export function googleFontsStylesheet(href, options) {
+    return {
+        href,
+        googleFonts: options,
+    };
+}
+export function script(src, options = {}) {
+    return {
+        scripts: [{ src, ...options }],
+    };
+}
+export function island(src, options = {}) {
+    return script(src, { module: true, ...options });
+}
+export function resolveClientAssets(registry, ids) {
+    const stylesheets = [];
+    const scripts = [];
+    const stylesheetSet = new Set();
+    const scriptSet = new Set();
+    for (const id of [...new Set(ids)]) {
+        const declarations = registry[id];
+        if (!declarations) {
+            throw new Error(`Unknown client asset: ${id}`);
+        }
+        for (const declaration of Array.isArray(declarations) ? declarations : [declarations]) {
+            for (const item of declaration.stylesheets ?? []) {
+                const key = stableStylesheetKey(item);
+                if (!stylesheetSet.has(key)) {
+                    stylesheetSet.add(key);
+                    stylesheets.push(item);
+                }
+            }
+            for (const item of declaration.scripts ?? []) {
+                const key = stableScriptKey(item);
+                if (!scriptSet.has(key)) {
+                    scriptSet.add(key);
+                    scripts.push(item);
+                }
+            }
+        }
+    }
+    return {
+        stylesheets,
+        scripts,
+    };
+}
+export function assetsFromViteManifest(manifest, options = {}) {
+    const base = options.base ?? "/";
+    return defineClientAssets(Object.fromEntries(Object.entries(manifest)
+        .filter(([, chunk]) => !options.entriesOnly || chunk.isEntry === true)
+        .map(([id, chunk]) => [
+        id,
+        {
+            stylesheets: collectViteChunkCss(manifest, chunk, base),
+            scripts: [
+                {
+                    src: joinPublicPath(base, chunk.file),
+                    module: true,
+                },
+            ],
+        },
+    ])));
+}
+export async function loadAssetsFromViteManifest(path, options = {}) {
+    const manifest = JSON.parse(await readFile(path, "utf8"));
+    return assetsFromViteManifest(manifest, options);
+}
+export function publicAssetsFromViteManifest(manifest, options) {
+    const base = options.base ?? "/";
+    const seen = new Set();
+    const assets = [];
+    for (const chunk of Object.values(manifest)) {
+        for (const file of [chunk.file, ...(chunk.css ?? []), ...(chunk.assets ?? [])]) {
+            if (seen.has(file)) {
+                continue;
+            }
+            seen.add(file);
+            assets.push({
+                source: join(options.sourceDir, file),
+                publicPath: joinPublicPath(base, file),
+            });
+        }
+    }
+    return assets;
+}
+export async function loadPublicAssetsFromViteManifest(path, options) {
+    const manifest = JSON.parse(await readFile(path, "utf8"));
+    return publicAssetsFromViteManifest(manifest, options);
+}
+export function viteBuildAssetsFromManifest(manifest, options) {
+    return {
+        client: assetsFromViteManifest(manifest, options),
+        public: publicAssetsFromViteManifest(manifest, options),
+    };
+}
+export async function loadViteBuildAssetsFromManifest(path, options) {
+    const manifest = JSON.parse(await readFile(path, "utf8"));
+    return viteBuildAssetsFromManifest(manifest, options);
+}
+/**
+ * Recursively walk a directory and expand every file into a `PublicAssetInput`
+ * whose `publicPath` mirrors the file's location relative to `dir`. The base of
+ * `dir` is the output root, so `public/images/logo.png` becomes
+ * `/images/logo.png` and `public/CNAME` becomes `/CNAME`.
+ *
+ * - Dotfiles and extensionless files (CNAME, .nojekyll) are included.
+ * - Nested subdirectories are walked to any depth.
+ * - Empty directories produce no entries (only regular files are copied).
+ * - Symlinks are not followed: a symlinked directory is not traversed (avoids
+ *   cycles) and a symlinked file is skipped (its `Dirent` is neither a
+ *   directory nor a regular file). Materialize the target into `dir` if you
+ *   need it copied.
+ * - A missing `dir` yields an empty list so a build can run before the
+ *   directory exists.
+ */
+export async function expandPublicDir(dir, options = {}) {
+    const base = options.base ?? "/";
+    const assets = [];
+    const walk = async (current) => {
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+        for (const entry of entries) {
+            const absolutePath = join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(absolutePath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                // Skip symlinks (dir or file), sockets, FIFOs, etc. readdir does not
+                // follow symlinks, so a symlinked file's Dirent reports neither
+                // isDirectory() nor isFile().
+                continue;
+            }
+            const relativePath = relative(dir, absolutePath).split(sep).join("/");
+            assets.push({
+                source: absolutePath,
+                publicPath: joinPublicPath(base, relativePath),
+            });
+        }
+    };
+    await walk(dir);
+    assets.sort((left, right) => left.publicPath.localeCompare(right.publicPath));
+    return assets;
+}
+export async function copyPublicAssets(options) {
+    const copied = [];
+    const skipped = [];
+    const outputPathsByPublicPath = new Map();
+    for (const asset of options.assets) {
+        const outputPath = publicAssetOutputPath(asset.publicPath);
+        const normalizedPublicPath = `/${outputPath}`;
+        if (outputPathsByPublicPath.has(normalizedPublicPath)) {
+            throw new Error(`Duplicate public asset path: ${normalizedPublicPath}`);
+        }
+        outputPathsByPublicPath.set(normalizedPublicPath, outputPath);
+    }
+    for (const asset of options.assets) {
+        const normalizedPublicPath = `/${publicAssetOutputPath(asset.publicPath)}`;
+        const outputPath = outputPathsByPublicPath.get(normalizedPublicPath);
+        const absoluteOutputPath = join(options.outDir, outputPath);
+        if (await publicAssetContentsEqual(asset, absoluteOutputPath)) {
+            skipped.push(asset.publicPath);
+            continue;
+        }
+        await mkdir(dirname(absoluteOutputPath), { recursive: true });
+        if ("source" in asset) {
+            await copyFile(asset.source, absoluteOutputPath);
+        }
+        else {
+            await writeFile(absoluteOutputPath, publicAssetContentBytes(asset.content));
+        }
+        copied.push(asset.publicPath);
+    }
+    return { copied, skipped };
+}
+export async function buildTailwindUtilitiesCss(input) {
+    const candidates = [...new Set(input.candidates)].sort();
+    const { compile } = await import("tailwindcss");
+    const compiler = await compile(`@tailwind utilities;${input.css ?? ""}`);
+    return minifyCss(compiler.build(candidates));
+}
+export async function writeTailwindUtilitiesCss(path, input) {
+    const css = await buildTailwindUtilitiesCss(input);
+    const current = await readOptionalText(path);
+    if (current === css) {
+        return false;
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, css, { flag: "w" });
+    return true;
+}
+function minifyCss(css) {
+    return css
+        .replace(/\/\*!.*?\*\//gs, "")
+        .replace(/\s+/g, " ")
+        .replace(/\s*([{}:;,>])\s*/g, "$1")
+        .replace(/;}/g, "}")
+        .trim();
+}
+async function readOptionalText(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function publicAssetContentsEqual(asset, outputPath) {
+    return "source" in asset
+        ? fileContentsEqual(asset.source, outputPath)
+        : bytesEqual(publicAssetContentBytes(asset.content), outputPath);
+}
+function publicAssetContentBytes(content) {
+    return typeof content === "string" ? Buffer.from(content) : Buffer.from(content);
+}
+async function fileContentsEqual(leftPath, rightPath) {
+    let leftStat;
+    let rightStat;
+    try {
+        [leftStat, rightStat] = await Promise.all([stat(leftPath), stat(rightPath)]);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+    if (leftStat.size !== rightStat.size) {
+        return false;
+    }
+    const [left, right] = await Promise.all([readFile(leftPath), readFile(rightPath)]);
+    return left.equals(right);
+}
+async function bytesEqual(left, rightPath) {
+    let rightStat;
+    try {
+        rightStat = await stat(rightPath);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+    if (left.byteLength !== rightStat.size) {
+        return false;
+    }
+    const right = await readFile(rightPath);
+    return left.equals(right);
+}
+function stableStylesheetKey(stylesheet) {
+    return typeof stylesheet === "string"
+        ? stylesheet
+        : "source" in stylesheet
+            ? JSON.stringify({
+                href: stylesheet.href,
+                source: stylesheet.source,
+                immutable: stylesheet.immutable !== false,
+            })
+            : JSON.stringify({
+                href: stylesheet.href,
+                googleFonts: {
+                    families: stylesheet.googleFonts.families,
+                    text: stylesheet.googleFonts.text,
+                    display: stylesheet.googleFonts.display,
+                    endpoint: stylesheet.googleFonts.endpoint,
+                    fontBasePath: stylesheet.googleFonts.fontBasePath,
+                    userAgent: stylesheet.googleFonts.userAgent,
+                },
+                immutable: stylesheet.immutable !== false,
+            });
+}
+function stableScriptKey(script) {
+    return JSON.stringify({
+        src: script.src,
+        source: script.source,
+        immutable: script.immutable !== false,
+        module: script.module === true,
+        defer: script.defer === true,
+        async: script.async === true,
+        attributes: Object.entries(script.attributes ?? {})
+            .filter(([, value]) => value !== null && value !== undefined && value !== false)
+            .sort(([left], [right]) => left.localeCompare(right)),
+    });
+}
+function collectViteChunkCss(manifest, chunk, base) {
+    const stylesheets = [];
+    const stylesheetSet = new Set();
+    const chunkSet = new Set();
+    const visit = (item) => {
+        if (chunkSet.has(item)) {
+            return;
+        }
+        chunkSet.add(item);
+        for (const importId of item.imports ?? []) {
+            const importedChunk = manifest[importId];
+            if (importedChunk) {
+                visit(importedChunk);
+            }
+        }
+        for (const href of item.css ?? []) {
+            const publicHref = joinPublicPath(base, href);
+            if (!stylesheetSet.has(publicHref)) {
+                stylesheetSet.add(publicHref);
+                stylesheets.push(publicHref);
+            }
+        }
+    };
+    visit(chunk);
+    return stylesheets;
+}
+function joinPublicPath(base, file) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(file) || file.startsWith("//")) {
+        return file;
+    }
+    const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+    const normalizedFile = file.replace(/^\/+/, "");
+    return `${normalizedBase}${normalizedFile}`;
+}