alchemy 0.10.0 → 0.10.2

package/lib/alchemy.js

@@ -30,7 +30,10 @@ async function _alchemy(...args) {
             ? secondLine.match(/^(\s*)/)?.[1]?.length || 0
             : 0;
         const indent = " ".repeat(leadingSpaces);
-        const { isFileCollection, isFileRef } = await import("./fs");
+        const [{ isFileRef }, { isFileCollection }] = await Promise.all([
+            import("./fs/file-ref"),
+            import("./fs/file-collection"),
+        ]);
         const appendices = {};
         const stringValues = await Promise.all(values.map(async function resolve(value) {
             if (typeof value === "string") {

package/lib/cloudflare/api.js

@@ -79,7 +79,7 @@ export class CloudflareApi {
                 errorMsg.includes("ECONNRESET") ||
                 errorMsg.includes("ETIMEDOUT") ||
                 errorMsg.includes("ECONNREFUSED");
-            return isNetworkError;
+            return isNetworkError || error.status?.toString().startsWith("5");
         }, 5, // Maximum 5 attempts (1 initial + 4 retries)
         1000 // Start with 1s delay, will exponentially increase
         );

package/lib/cloudflare/assets.js

@@ -1,5 +1,5 @@
-import * as fs from "fs/promises";
-import * as path from "path";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { Resource } from "../resource";
 import { getContentType } from "../util/content-type";
 /**

package/lib/cloudflare/d1-database.d.ts

@@ -40,6 +40,25 @@ export interface D1DatabaseProps extends CloudflareApiOptions {
      * @default false
      */
     adopt?: boolean;
+    /**
+     * These files will be generated internally with the D1Database wrapper function when migrationsDir is specified
+     *
+     * @private
+     */
+    migrationsFiles?: Array<{
+        id: string;
+        sql: string;
+    }>;
+    /**
+     * Name of the table used to track migrations. Only used if migrationsDir is specified. Defaults to 'd1_migrations'
+     * This is analogous to wrangler's `migrations_table`.
+     */
+    migrationsTable?: string;
+    /**
+     * Directory containing migration SQL files. If not set, no migrations will be applied.
+     * This is analogous to wrangler's `migrations_dir`.
+     */
+    migrationsDir?: string;
 }
 /**
  * Output returned after D1 Database creation/update
@@ -72,6 +91,7 @@ export interface D1Database extends Resource<"cloudflare::D1Database">, D1Databa
         mode: "auto" | "disabled";
     };
 }
+export declare function D1Database(id: string, props: Omit<D1DatabaseProps, "migrationsFiles">): Promise<D1Database>;
 /**
  * Creates and manages Cloudflare D1 Databases.
  *
@@ -101,9 +121,16 @@ export interface D1Database extends Resource<"cloudflare::D1Database">, D1Databa
  *   }
  * });
  *
+ * @example
+ * // Create a database with migrations
+ * const dbWithMigrations = await D1Database("mydb", {
+ *   name: "mydb",
+ *   migrationsDir: "./migrations",
+ * });
+ *
  * @see https://developers.cloudflare.com/d1/
  */
-export declare const D1Database: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<D1Database>, id: string, props: D1DatabaseProps) => Promise<D1Database>);
+export declare const D1DatabaseResource: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<D1Database>, id: string, props: D1DatabaseProps) => Promise<D1Database>);
 interface CloudflareD1Response {
     result: {
         uuid?: string;

package/lib/cloudflare/d1-database.js

@@ -1,6 +1,16 @@
 import { Resource } from "../resource";
 import { CloudflareApi, createCloudflareApi, } from "./api";
 import { CloudflareApiError, handleApiError } from "./api-error";
+import { applyMigrations, listMigrationsFiles } from "./d1-migrations";
+export async function D1Database(id, props) {
+    const migrationsFiles = props.migrationsDir
+        ? await listMigrationsFiles(props.migrationsDir)
+        : [];
+    return D1DatabaseResource(id, {
+        ...props,
+        migrationsFiles,
+    });
+}
 /**
  * Creates and manages Cloudflare D1 Databases.
  *
@@ -30,9 +40,16 @@ import { CloudflareApiError, handleApiError } from "./api-error";
  *   }
  * });
  *
+ * @example
+ * // Create a database with migrations
+ * const dbWithMigrations = await D1Database("mydb", {
+ *   name: "mydb",
+ *   migrationsDir: "./migrations",
+ * });
+ *
  * @see https://developers.cloudflare.com/d1/
  */
-export const D1Database = Resource("cloudflare::D1Database", async function (id, props) {
+export const D1DatabaseResource = Resource("cloudflare::D1Database", async function (id, props) {
     const api = await createCloudflareApi(props);
     const databaseName = props.name || id;
     if (this.phase === "delete") {
@@ -91,6 +108,27 @@ export const D1Database = Resource("cloudflare::D1Database", async function (id,
                 dbData = await createDatabase(api, databaseName, props);
             }
         }
+        // Run migrations if provided
+        if (props.migrationsFiles && props.migrationsFiles.length > 0) {
+            try {
+                const migrationsTable = props.migrationsTable || "d1_migrations";
+                const databaseId = dbData.result.uuid || this.output?.id;
+                if (!databaseId) {
+                    throw new Error("Database ID not found for migrations");
+                }
+                await applyMigrations({
+                    migrationsFiles: props.migrationsFiles,
+                    migrationsTable,
+                    accountId: api.accountId,
+                    databaseId,
+                    api,
+                });
+            }
+            catch (migrationErr) {
+                console.error("Failed to apply D1 migrations:", migrationErr);
+                throw migrationErr;
+            }
+        }
         return this({
             type: "d1",
             id: dbData.result.uuid || "",

package/lib/cloudflare/d1-migrations.d.ts

@@ -0,0 +1,46 @@
+import { CloudflareApi } from "./api";
+export interface D1MigrationOptions {
+    migrationsFiles: Array<{
+        id: string;
+        sql: string;
+    }>;
+    migrationsTable: string;
+    accountId: string;
+    databaseId: string;
+    api: CloudflareApi;
+}
+/**
+ * Reads migration SQL files from the migrationsDir, sorted by filename.
+ * @param migrationsDir Directory containing .sql migration files
+ */
+export declare function listMigrationsFiles(migrationsDir: string): Promise<Array<{
+    id: string;
+    sql: string;
+}>>;
+/**
+ * Ensures the migrations table exists in the D1 database.
+ */
+export declare function ensureMigrationsTable(options: D1MigrationOptions): Promise<void>;
+/**
+ * Gets the list of applied migration IDs from the migrations table.
+ */
+export declare function getAppliedMigrations(options: D1MigrationOptions): Promise<Set<string>>;
+/**
+ * Executes a SQL statement against the D1 database using the HTTP API.
+ */
+export declare function executeD1SQL(options: D1MigrationOptions, sql: string): Promise<{
+    result: [
+        {
+            results: Array<unknown>;
+            success: boolean;
+            meta: any;
+        }
+    ];
+    errors: Array<any>;
+    messages: Array<any>;
+    success: boolean;
+}>;
+/**
+ * Applies all pending migrations from the provided files to the D1 database.
+ */
+export declare function applyMigrations(options: D1MigrationOptions): Promise<void>;

package/lib/cloudflare/d1-migrations.js

@@ -0,0 +1,82 @@
+import * as fs from "fs/promises";
+import * as path from "node:path";
+import { CloudflareApi } from "./api";
+import { handleApiError } from "./api-error";
+const getPrefix = (name) => {
+    const prefix = name.split("_")[0];
+    const num = parseInt(prefix, 10);
+    return isNaN(num) ? null : num;
+};
+async function readMigrationFile(filePath) {
+    return fs.readFile(filePath, "utf-8");
+}
+/**
+ * Reads migration SQL files from the migrationsDir, sorted by filename.
+ * @param migrationsDir Directory containing .sql migration files
+ */
+export async function listMigrationsFiles(migrationsDir) {
+    const entries = await fs.readdir(migrationsDir);
+    const sqlFiles = entries
+        .filter((f) => f.endsWith(".sql"))
+        .sort((a, b) => {
+        const aNum = getPrefix(a);
+        const bNum = getPrefix(b);
+        if (aNum !== null && bNum !== null)
+            return aNum - bNum;
+        if (aNum !== null)
+            return -1;
+        if (bNum !== null)
+            return 1;
+        return a.localeCompare(b);
+    });
+    const files = [];
+    for (const file of sqlFiles) {
+        const sql = await readMigrationFile(path.join(migrationsDir, file));
+        files.push({ id: file, sql });
+    }
+    return files;
+}
+/**
+ * Ensures the migrations table exists in the D1 database.
+ */
+export async function ensureMigrationsTable(options) {
+    const createTableSQL = `CREATE TABLE IF NOT EXISTS ${options.migrationsTable} (id TEXT PRIMARY KEY, applied_at TEXT);`;
+    await executeD1SQL(options, createTableSQL);
+}
+/**
+ * Gets the list of applied migration IDs from the migrations table.
+ */
+export async function getAppliedMigrations(options) {
+    const sql = `SELECT id FROM ${options.migrationsTable};`;
+    const result = await executeD1SQL(options, sql);
+    const ids = (result?.result[0]?.results || []).map((row) => row.id);
+    return new Set(ids);
+}
+/**
+ * Executes a SQL statement against the D1 database using the HTTP API.
+ */
+export async function executeD1SQL(options, sql) {
+    const response = await options.api.post(`/accounts/${options.accountId}/d1/database/${options.databaseId}/query`, { sql });
+    if (!response.ok) {
+        await handleApiError(response, "executing migration SQL", "D1 database", options.databaseId);
+    }
+    return response.json();
+}
+/**
+ * Applies all pending migrations from the provided files to the D1 database.
+ */
+export async function applyMigrations(options) {
+    await ensureMigrationsTable(options);
+    const applied = await getAppliedMigrations(options);
+    for (const migration of options.migrationsFiles) {
+        const migrationId = migration.id;
+        if (applied.has(migrationId))
+            continue;
+        // Run the migration
+        await executeD1SQL(options, migration.sql);
+        // Record as applied
+        const insertSQL = `INSERT INTO ${options.migrationsTable} (id, applied_at) VALUES ('${migrationId.replace("'", "''")}', datetime('now'));`;
+        await executeD1SQL(options, insertSQL);
+        console.log(`Applied migration: ${migrationId}`);
+    }
+}

package/lib/cloudflare/worker.js

@@ -1,5 +1,5 @@
-import * as crypto from "crypto";
-import * as fs from "fs/promises";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs/promises";
 import { Bundle } from "../esbuild/bundle";
 import { Resource } from "../resource";
 import { getContentType } from "../util/content-type";

package/lib/cloudflare/wrangler.json.js

@@ -1,4 +1,4 @@
-import { StaticJsonFile } from "../fs";
+import { StaticJsonFile } from "../fs/static-json-file";
 import { Resource } from "../resource";
 /**
  * Resource for managing wrangler.json configuration files

package/lib/esbuild/bundle.d.ts

@@ -95,7 +95,8 @@ export interface Bundle extends Resource<"esbuild::Bundle"> {
 export declare const Bundle: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<Bundle>, id: string, props: BundleProps) => Promise<Bundle>);
 export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<{
     entryPoints: string[];
-    outfile: string;
+    outdir: string | undefined;
+    outfile: string | undefined;
     bundle: true;
     format: "iife" | "cjs" | "esm" | undefined;
     target: string | string[] | undefined;
@@ -107,7 +108,6 @@ export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<
     write: true;
     splitting?: boolean;
     preserveSymlinks?: boolean;
-    outdir?: string;
     outbase?: string;
     packages?: "bundle" | "external";
     alias?: Record<string, string>;

package/lib/esbuild/bundle.js

@@ -23,34 +23,51 @@ export const Bundle = Resource("esbuild::Bundle", {
     alwaysUpdate: true,
 }, async function (id, props) {
     // Determine output path
-    const outputPath = getOutputPath(props);
+    const outDirPath = props.outfile != null ? path.dirname(props.outfile) : props.outdir;
+    if (outDirPath == null) {
+        throw new Error(`You need to specify either outfile or outdir in your bundle configuration ${JSON.stringify(props)}`);
+    }
     // Ensure output directory exists
-    await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.promises.mkdir(path.dirname(outDirPath), { recursive: true });
     if (this.phase === "delete") {
-        await fs.promises.unlink(outputPath).catch(() => { });
-        // Also clean up sourcemap if it exists
-        await fs.promises.unlink(outputPath + ".map").catch(() => { });
-        return this.destroy();
+        await fs.promises.rm(outDirPath, { recursive: true });
     }
     const result = await bundle(props);
+    // Check that bundle created output an file for the given entrypoint
+    // Use bundle metada data to retrieve its content
+    const bundleOutputPath = Object.entries(result.metafile.outputs).find(([file, output]) => {
+        if (output.entryPoint === undefined) {
+            return false;
+        }
+        // resolve to absolute and then relative to ensure consistent result (e.g. ./src/handler.ts instead of src/handler.ts)
+        const relativeOutput = path.relative(process.cwd(), path.resolve(output.entryPoint));
+        return (relativeOutput ===
+            path.relative(process.cwd(), path.resolve(process.cwd(), props.entryPoint)));
+    })?.[0];
+    if (!bundleOutputPath) {
+        throw new Error(`Unable to find a compiled file`);
+    }
     // Calculate hash of the output
-    const contents = await fs.promises.readFile(outputPath);
-    const hash = crypto.createHash("sha256").update(contents).digest("hex");
+    const bundleOutputContent = await fs.promises.readFile(bundleOutputPath);
+    const hash = crypto
+        .createHash("sha256")
+        .update(bundleOutputContent)
+        .digest("hex");
     // Store metadata in context
     await this.set("metafile", result.metafile);
     await this.set("hash", hash);
     // Return output info
     return this({
-        path: outputPath,
+        path: bundleOutputPath,
         hash,
     });
 });
 export async function bundle(props) {
-    const outputPath = getOutputPath(props);
     return await esbuild.build({
         ...props.options,
         entryPoints: [props.entryPoint],
-        outfile: outputPath,
+        outdir: props.outdir,
+        outfile: props.outfile,
         bundle: true,
         format: props.format,
         target: props.target,
@@ -66,7 +83,3 @@ export async function bundle(props) {
         write: true,
     });
 }
-function getOutputPath(props) {
-    return (props.outfile ||
-        path.join(props.outdir || "dist", path.basename(props.entryPoint, path.extname(props.entryPoint)) + ".js"));
-}

package/lib/internal/docs/providers.d.ts

@@ -1,5 +1,5 @@
-import { Document } from "../../ai";
-import { Folder } from "../../fs";
+import { Document } from "../../ai/document";
+import { Folder } from "../../fs/folder";
 export interface DocsProps {
     /**
      * The output directory for the docs.

package/lib/internal/docs/providers.js

@@ -1,9 +1,10 @@
 import { type } from "arktype";
-import fs from "fs/promises";
-import path from "path";
-import { Data, Document } from "../../ai";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Data } from "../../ai/data";
+import { Document } from "../../ai/document";
 import { alchemy } from "../../alchemy";
-import { Folder } from "../../fs";
+import { Folder } from "../../fs/folder";
 export async function Providers({ srcDir, outDir, filter, parallel = true, }) {
     outDir = typeof outDir === "string" ? outDir : outDir.path;
     const exclude = [

package/lib/test/bun.js

@@ -2,7 +2,7 @@
 import { afterAll, beforeAll, it } from "bun:test";
 import path from "node:path";
 import { alchemy } from "../alchemy";
-import { R2RestStateStore } from "../cloudflare";
+import { R2RestStateStore } from "../cloudflare/r2-rest-state-store";
 import { Scope } from "../scope";
 /**
  * Add test functionality to alchemy instance

package/lib/test/prune.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Runs only tests that have changed dependencies
+ * @param directory Directory to scan for test files
+ * @param baseCommit Optional base commit to compare against
+ */
+export declare function runChangedTests(directory: string, baseCommit?: string): Promise<void>;
+/**
+ * Identifies test files that have changed or depend on changed files
+ * @param directory Directory to scan for test files
+ * @param baseCommit Optional base commit to compare against (defaults to HEAD~1)
+ * @returns Array of changed test files
+ */
+export declare function findChangedTestFiles(directory: string, baseCommit?: string): Promise<string[]>;

package/lib/test/prune.js

@@ -0,0 +1,130 @@
+import { exec } from "child_process";
+import * as esbuild from "esbuild";
+import { glob } from "glob";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+/**
+ * Runs only tests that have changed dependencies
+ * @param directory Directory to scan for test files
+ * @param baseCommit Optional base commit to compare against
+ */
+export async function runChangedTests(directory, baseCommit) {
+    const changedTests = await findChangedTestFiles(directory, baseCommit);
+    if (changedTests.length === 0) {
+        console.log("No tests affected by recent changes.");
+        return;
+    }
+    // Run the tests with bun using spawn for stdio inheritance
+    return new Promise((resolve, reject) => {
+        console.log(`bun test ${changedTests.join(" ")}`);
+        // resolve();
+        const child = spawn("bun", ["test", ...changedTests], { stdio: "inherit" });
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Tests exited with code ${code}`));
+        });
+        child.on("error", reject);
+    });
+}
+/**
+ * Identifies test files that have changed or depend on changed files
+ * @param directory Directory to scan for test files
+ * @param baseCommit Optional base commit to compare against (defaults to HEAD~1)
+ * @returns Array of changed test files
+ */
+export async function findChangedTestFiles(directory, baseCommit = "HEAD~1") {
+    // 1. Find all test files
+    const testFiles = await findTestFiles(directory);
+    // 2. Get git changed files
+    const changedFiles = await getChangedFiles(baseCommit);
+    // 3. Process each test file
+    const changedTestFiles = [];
+    for (const testFile of testFiles) {
+        // Get dependency tree for the test file
+        const dependencies = await getDependencies(testFile);
+        // Check if any dependencies have changed
+        const changedDependencies = [...dependencies].filter((dep) => changedFiles.has(dep));
+        if (changedDependencies.length > 0) {
+            changedTestFiles.push(testFile);
+        }
+    }
+    return changedTestFiles.map((p) => path.relative(process.cwd(), p));
+}
+/**
+ * Finds all test files in a directory
+ * @param directory Directory to scan
+ * @returns Array of test file paths
+ */
+async function findTestFiles(directory) {
+    return await glob(path.join(directory, "**/*.test.ts"));
+}
+/**
+ * Gets list of files changed since a base commit
+ * @param baseCommit Base commit to compare against
+ * @returns Set of changed file paths
+ */
+async function getChangedFiles(baseCommit) {
+    // Get changed files from git
+    const { stdout: gitOutput } = await execAsync(`git diff --name-only ${baseCommit}`);
+    // Convert to set of absolute paths
+    const changedFiles = new Set();
+    const { stdout: workDir } = await execAsync("git rev-parse --show-toplevel");
+    const rootDir = workDir.trim();
+    gitOutput
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .forEach((file) => {
+        changedFiles.add(path.resolve(rootDir, file));
+    });
+    return changedFiles;
+}
+/**
+ * Gets dependency tree for a test file
+ * @param testFile Path to test file
+ * @returns Set of dependency file paths
+ */
+async function getDependencies(testFile) {
+    const dependencies = new Set();
+    // Add the test file itself to dependencies
+    const absTestPath = path.resolve(testFile);
+    dependencies.add(absTestPath);
+    try {
+        // Use esbuild with metafile to get dependencies
+        const result = await esbuild.build({
+            entryPoints: [testFile],
+            write: false,
+            platform: "node",
+            format: "esm",
+            bundle: true,
+            metafile: true,
+            external: ["@cloudflare/workers-types", "bun:test"],
+        });
+        if (!result.metafile) {
+            return dependencies;
+        }
+        // Function to normalize paths for comparison
+        const normalizePath = (p) => path.resolve(p).replace(/\\/g, "/");
+        // Process imports from the metafile
+        const { inputs } = result.metafile;
+        for (const filePath in inputs) {
+            // Skip node_modules and non-local imports
+            if (filePath.includes("node_modules") ||
+                filePath.includes("bun:") ||
+                !filePath.endsWith(".ts")) {
+                continue;
+            }
+            const absolutePath = normalizePath(filePath);
+            dependencies.add(absolutePath);
+        }
+        return dependencies;
+    }
+    catch (error) {
+        console.error(`Error analyzing dependencies for ${testFile}:`, error);
+        // Return at least the test file itself
+        return dependencies;
+    }
+}

package/lib/util/content-type.js

@@ -1,4 +1,4 @@
-import path from "path";
+import path from "node:path";
 // Common MIME types
 const mimeTypes = {
     ".html": "text/html",

package/lib/util/rm.js

@@ -1,4 +1,4 @@
-import fs from "fs/promises";
+import fs from "node:fs/promises";
 export async function rm(path) {
     try {
         await fs.rm(path, { recursive: true, force: true });

package/lib/web/astro.js

@@ -1,8 +1,11 @@
 import { exec } from "child_process";
-import fs from "fs/promises";
-import path from "path";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { promisify } from "util";
-import { Folder, StaticJsonFile, StaticTextFile, StaticTypeScriptFile, } from "../fs";
+import { Folder } from "../fs/folder";
+import { StaticJsonFile } from "../fs/static-json-file";
+import { StaticTextFile } from "../fs/static-text-file";
+import { StaticTypeScriptFile } from "../fs/static-typescript-file";
 import { Resource } from "../resource";
 import { ShadcnUI } from "./shadcn";
 const execAsync = promisify(exec);

package/lib/web/shadcn-component.js

@@ -1,6 +1,6 @@
 import { exec } from "child_process";
-import fs from "fs/promises";
-import path from "path";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { promisify } from "util";
 import { Resource } from "../resource";
 import { ignore } from "../util/ignore";

package/lib/web/shadcn.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from "../context";
-import { Folder } from "../fs";
+import { Folder } from "../fs/folder";
 import { Resource } from "../resource";
 /**
  * Properties for initializing Shadcn UI

package/lib/web/shadcn.js

@@ -1,7 +1,8 @@
 import { exec } from "child_process";
-import path from "path";
+import path from "node:path";
 import { promisify } from "util";
-import { Folder, StaticJsonFile } from "../fs";
+import { Folder } from "../fs/folder";
+import { StaticJsonFile } from "../fs/static-json-file";
 import { StaticTypeScriptFile } from "../fs/static-typescript-file";
 import { Resource } from "../resource";
 import { ShadcnComponent } from "./shadcn-component";

package/lib/web/tailwind.js

@@ -1,7 +1,8 @@
 import { exec } from "child_process";
-import path from "path";
+import path from "node:path";
 import { promisify } from "util";
-import { Folder, StaticTextFile } from "../fs";
+import { Folder } from "../fs/folder";
+import { StaticTextFile } from "../fs/static-text-file";
 import { Resource } from "../resource";
 const execAsync = promisify(exec);
 /**

package/lib/web/vite.js

@@ -1,7 +1,9 @@
 import { exec } from "child_process";
-import path from "path";
+import path from "node:path";
 import { promisify } from "util";
-import { Folder, StaticJsonFile, StaticTypeScriptFile } from "../fs";
+import { Folder } from "../fs/folder";
+import { StaticJsonFile } from "../fs/static-json-file";
+import { StaticTypeScriptFile } from "../fs/static-typescript-file";
 import { Resource } from "../resource";
 import { rm } from "../util/rm";
 import { ShadcnComponent } from "./shadcn-component";
@@ -74,7 +76,7 @@ export const ViteProject = Resource("project::ViteProject", {
                 cwd: props.name,
                 framework: "vite",
             });
-            await StaticTypeScriptFile(path.join(props.name, "vite.config.ts"), `import path from "path";
+            await StaticTypeScriptFile(path.join(props.name, "vite.config.ts"), `import path from "node:path";
 import react from "@vitejs/plugin-react";
 import { defineConfig } from "vite";
 ${tailwind ? "import tailwindcss from '@tailwindcss/vite';" : ""}

package/lib/web/vitepress/config.js

@@ -1,4 +1,4 @@
-import path from "path";
+import path from "node:path";
 import { StaticTypeScriptFile } from "../../fs/static-typescript-file";
 export function VitePressConfig(props) {
     return StaticTypeScriptFile(path.join(props.cwd, ".vitepress", "config.mts"), `import { transformerTwoslash } from "@shikijs/vitepress-twoslash";