bun-plugin-stx 0.2.0 → 0.2.3

package/dist/chunk-eecw9x2f.js

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };

package/dist/chunk-ymdk9x8z.js

@@ -0,0 +1,458 @@
+// @bun
+// src/index.ts
+import path2 from "path";
+import { buildWebComponents, cacheTemplate, checkCache, defaultConfig, extractVariables, processClientScript, processDirectives, readMarkdownFile } from "@stacksjs/stx";
+
+// src/watch.ts
+import fs from "fs";
+import path from "path";
+import process from "process";
+function debounce(fn, delay) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay);
+  };
+}
+function shouldWatch(filePath, options) {
+  const ext = path.extname(filePath);
+  const extensions = options.extensions || [".stx", ".md"];
+  const ignore = options.ignore || ["node_modules", ".git", "dist", ".stx"];
+  if (!extensions.includes(ext)) {
+    return false;
+  }
+  for (const ignorePath of ignore) {
+    if (filePath.includes(ignorePath)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createWatcher(options = {}) {
+  const watchedPaths = new Set;
+  const watchers = new Map;
+  let isActive = true;
+  const paths = options.paths || [process.cwd()];
+  const debounceDelay = options.debounce ?? 100;
+  const pendingChanges = [];
+  const handleChanges = debounce(() => {
+    if (pendingChanges.length > 0 && options.onChange) {
+      for (const event of pendingChanges) {
+        options.onChange(event);
+      }
+      pendingChanges.length = 0;
+    }
+  }, debounceDelay);
+  function watchDirectory(dirPath) {
+    if (watchers.has(dirPath)) {
+      return;
+    }
+    try {
+      const watcher = fs.watch(dirPath, { recursive: true }, (eventType, filename) => {
+        if (!isActive || !filename) {
+          return;
+        }
+        const fullPath = path.join(dirPath, filename);
+        if (!shouldWatch(fullPath, options)) {
+          return;
+        }
+        const event = {
+          type: eventType,
+          path: fullPath,
+          timestamp: Date.now()
+        };
+        if (options.verbose) {
+          console.log(`[stx-watch] ${eventType}: ${fullPath}`);
+        }
+        pendingChanges.push(event);
+        handleChanges();
+      });
+      watcher.on("error", (error) => {
+        if (options.onError) {
+          options.onError(error);
+        } else {
+          console.error(`[stx-watch] Error watching ${dirPath}:`, error);
+        }
+      });
+      watchers.set(dirPath, watcher);
+      watchedPaths.add(dirPath);
+      if (options.verbose) {
+        console.log(`[stx-watch] Watching: ${dirPath}`);
+      }
+    } catch (error) {
+      if (options.onError) {
+        options.onError(error);
+      }
+    }
+  }
+  for (const watchPath of paths) {
+    const absolutePath = path.resolve(watchPath);
+    if (fs.existsSync(absolutePath)) {
+      watchDirectory(absolutePath);
+    }
+  }
+  return {
+    close: () => {
+      isActive = false;
+      for (const watcher of watchers.values()) {
+        watcher.close();
+      }
+      watchers.clear();
+      watchedPaths.clear();
+      if (options.verbose) {
+        console.log("[stx-watch] Stopped watching");
+      }
+    },
+    getWatchedPaths: () => Array.from(watchedPaths),
+    addPath: (newPath) => {
+      const absolutePath = path.resolve(newPath);
+      if (fs.existsSync(absolutePath) && !watchers.has(absolutePath)) {
+        watchDirectory(absolutePath);
+      }
+    },
+    removePath: (pathToRemove) => {
+      const absolutePath = path.resolve(pathToRemove);
+      const watcher = watchers.get(absolutePath);
+      if (watcher) {
+        watcher.close();
+        watchers.delete(absolutePath);
+        watchedPaths.delete(absolutePath);
+      }
+    },
+    isWatching: () => isActive && watchers.size > 0
+  };
+}
+async function watchAndBuild(options) {
+  const {
+    entrypoints,
+    outdir = "./dist",
+    buildConfig = {},
+    stxOptions,
+    onRebuild,
+    ...watchOptions
+  } = options;
+  let triggeredBy = [];
+  async function build() {
+    const startTime = Date.now();
+    const currentTriggers = [...triggeredBy];
+    triggeredBy = [];
+    try {
+      const result = await Bun.build({
+        entrypoints,
+        outdir,
+        plugins: [stxPlugin(stxOptions)],
+        ...buildConfig
+      });
+      const duration = Date.now() - startTime;
+      const outputs = result.outputs.map((o) => o.path);
+      if (!result.success) {
+        const errors = result.logs.filter((log) => log.level === "error").map((log) => new Error(log.message));
+        return {
+          success: false,
+          errors,
+          duration,
+          triggeredBy: currentTriggers
+        };
+      }
+      return {
+        success: true,
+        outputs,
+        duration,
+        triggeredBy: currentTriggers
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errors: [error],
+        duration: Date.now() - startTime,
+        triggeredBy: currentTriggers
+      };
+    }
+  }
+  if (options.verbose) {
+    console.log("[stx-watch] Performing initial build...");
+  }
+  const initialResult = await build();
+  if (onRebuild) {
+    onRebuild(initialResult);
+  }
+  const dirsToWatch = new Set;
+  for (const entrypoint of entrypoints) {
+    const dir = path.dirname(path.resolve(entrypoint));
+    dirsToWatch.add(dir);
+  }
+  const commonDirs = ["src", "pages", "components", "layouts", "partials"];
+  for (const dir of commonDirs) {
+    const fullPath = path.resolve(dir);
+    if (fs.existsSync(fullPath)) {
+      dirsToWatch.add(fullPath);
+    }
+  }
+  const watcher = createWatcher({
+    ...watchOptions,
+    paths: watchOptions.paths || Array.from(dirsToWatch),
+    onChange: async (event) => {
+      triggeredBy.push(event.path);
+      if (watchOptions.onChange) {
+        watchOptions.onChange(event);
+      }
+      if (options.verbose) {
+        console.log(`[stx-watch] Rebuilding due to change in ${event.path}...`);
+      }
+      const result = await build();
+      if (onRebuild) {
+        onRebuild(result);
+      }
+    }
+  });
+  if (options.verbose) {
+    console.log(`[stx-watch] Watching for changes in: ${watcher.getWatchedPaths().join(", ")}`);
+  }
+  return watcher;
+}
+async function startWatchMode(args) {
+  console.log("\x1B[36m[stx]\x1B[0m Starting watch mode...");
+  const watcher = await watchAndBuild({
+    entrypoints: args.entrypoints,
+    outdir: args.outdir,
+    verbose: args.verbose,
+    stxOptions: args.stxOptions,
+    onRebuild: (result) => {
+      if (result.success) {
+        const files = result.triggeredBy.length > 0 ? ` (${result.triggeredBy.map((f) => path.basename(f)).join(", ")})` : "";
+        console.log(`\x1B[32m[stx]\x1B[0m Built in ${result.duration}ms${files}`);
+      } else {
+        console.error("\x1B[31m[stx]\x1B[0m Build failed:");
+        for (const error of result.errors || []) {
+          console.error(`  ${error.message}`);
+        }
+      }
+    }
+  });
+  process.on("SIGINT", () => {
+    console.log(`
+\x1B[36m[stx]\x1B[0m Stopping watch mode...`);
+    watcher.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    watcher.close();
+    process.exit(0);
+  });
+  return watcher;
+}
+
+// src/index.ts
+import { createMiddleware, createRoute, readMarkdownFile as readMarkdownFile2 } from "@stacksjs/stx";
+function escapeHtmlForError(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function generateErrorPage(title, message, filePath) {
+  const escapedMessage = escapeHtmlForError(message);
+  const escapedPath = filePath ? escapeHtmlForError(filePath) : "";
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>stx Error</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; padding: 2rem; background: #1a1a2e; color: #eee; }
+    h1 { color: #ff6b6b; }
+    pre { background: #16213e; padding: 1rem; border-radius: 4px; overflow-x: auto; border-left: 4px solid #ff6b6b; }
+    .file-path { color: #888; font-size: 0.9rem; margin-bottom: 1rem; }
+  </style>
+</head>
+<body>
+  <h1>${title}</h1>
+  ${escapedPath ? `<div class="file-path">File: ${escapedPath}</div>` : ""}
+  <pre>${escapedMessage}</pre>
+</body>
+</html>`;
+}
+function stxPlugin(userOptions) {
+  return {
+    name: "bun-plugin-stx",
+    async setup(build) {
+      const options = {
+        ...defaultConfig,
+        ...userOptions
+      };
+      const allDependencies = new Set;
+      const webComponentsPath = options.webComponents?.enabled ? `./${path2.relative(path2.dirname(build.config?.outdir || "dist"), options.webComponents.outputDir || "dist/web-components")}` : "/web-components";
+      const builtComponents = [];
+      if (options.webComponents?.enabled) {
+        try {
+          const components = await buildWebComponents(options, allDependencies);
+          builtComponents.push(...components);
+          if (options.debug && components.length > 0) {
+            console.log(`Successfully built ${components.length} web components`);
+          }
+        } catch (error) {
+          console.error("Failed to build web components:", error);
+        }
+      }
+      build.onLoad({ filter: /\.md$/ }, async ({ path: filePath }) => {
+        try {
+          const { content: htmlContent, data: frontmatter } = await readMarkdownFile(filePath, options);
+          const jsContent = `// ${filePath}
+var content = ${JSON.stringify(htmlContent)};
+var data = ${JSON.stringify(frontmatter)};
+
+export { content, data };
+export { content as default };
+`;
+          return {
+            contents: jsContent,
+            loader: "js"
+          };
+        } catch (error) {
+          console.error("Markdown Processing Error:", error);
+          const errorContent = generateErrorPage("Markdown Processing Error", error.message || "Unknown error", filePath);
+          const jsContent = `// ${filePath}
+var content = ${JSON.stringify(errorContent)};
+var data = {};
+
+export { content, data };
+export { content as default };
+`;
+          return {
+            contents: jsContent,
+            loader: "js"
+          };
+        }
+      });
+      build.onLoad({ filter: /\.(jsx|tsx)$/ }, async ({ path: filePath }) => {
+        try {
+          const source = await Bun.file(filePath).text();
+          const loader = filePath.endsWith(".tsx") ? "tsx" : "jsx";
+          const transpiler = new Bun.Transpiler({
+            loader,
+            jsxOptimizationInline: true
+          });
+          const code = transpiler.transformSync(source);
+          return {
+            contents: code,
+            loader: "js"
+          };
+        } catch (error) {
+          console.error("JSX Processing Error:", error);
+          return {
+            contents: `export default function() { return null; }`,
+            loader: "js"
+          };
+        }
+      });
+      build.onLoad({ filter: /\.stx$/ }, async ({ path: filePath }) => {
+        try {
+          const dependencies = new Set;
+          if (options.cache && options.cachePath) {
+            const cachedOutput = await checkCache(filePath, options);
+            if (cachedOutput) {
+              if (options.debug) {
+                console.log(`Using cached version of ${filePath}`);
+              }
+              return {
+                contents: cachedOutput,
+                loader: "html"
+              };
+            }
+          }
+          const content = await Bun.file(filePath).text();
+          let workingContent = content;
+          const templateTagMatch = content.match(/<template\b[^>]*>([\s\S]*?)<\/template>/i);
+          if (templateTagMatch) {
+            workingContent = templateTagMatch[1].trim();
+          }
+          const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+          const clientScripts = [];
+          const serverScripts = [];
+          const signalsScripts = [];
+          let scriptMatch;
+          const usesSignalsAPI = (content2) => /\b(?:state|derived|effect|batch)\s*\(/.test(content2);
+          while ((scriptMatch = scriptRegex.exec(content)) !== null) {
+            const attrs = scriptMatch[1];
+            const scriptContent = scriptMatch[2];
+            const fullScript = scriptMatch[0];
+            const isClientScript = attrs.includes("client") || attrs.includes('type="module"') || attrs.includes("src=");
+            const isSignalsScript = usesSignalsAPI(scriptContent);
+            if (isSignalsScript) {
+              signalsScripts.push(fullScript);
+            } else if (isClientScript) {
+              clientScripts.push(fullScript);
+            } else {
+              serverScripts.push(scriptContent);
+            }
+          }
+          let templateContent = workingContent;
+          for (const script of serverScripts) {
+            const escapedScript = script.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            templateContent = templateContent.replace(new RegExp(`<script\\b[^>]*>${escapedScript}<\\/script>`, "gi"), "");
+          }
+          for (const script of clientScripts) {
+            const escapedScript = script.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            templateContent = templateContent.replace(escapedScript, "");
+          }
+          const context = {
+            __filename: filePath,
+            __dirname: path2.dirname(filePath),
+            __stx: {
+              webComponentsPath,
+              builtComponents
+            },
+            __stx_options: options,
+            __stx_sfc_mode: true
+          };
+          for (const scriptContent of serverScripts) {
+            await extractVariables(scriptContent, context, filePath);
+          }
+          let output = templateContent;
+          output = await processDirectives(output, context, filePath, options, dependencies);
+          if (clientScripts.length > 0) {
+            const eventBindings = context.__stx_event_bindings || [];
+            const transformedScripts = clientScripts.map((fullScript) => {
+              const contentMatch = fullScript.match(/<script\b[^>]*>([\s\S]*?)<\/script>/);
+              if (!contentMatch)
+                return fullScript;
+              return processClientScript(contentMatch[1], { eventBindings });
+            });
+            const scriptsHtml = transformedScripts.join(`
+`);
+            const bodyEndMatch = output.match(/(<\/body>)/i);
+            if (bodyEndMatch) {
+              output = output.replace(/(<\/body>)/i, `${scriptsHtml}
+$1`);
+            } else {
+              output += `
+${scriptsHtml}`;
+            }
+            context.__stx_event_bindings = [];
+          }
+          dependencies.forEach((dep) => allDependencies.add(dep));
+          if (options.cache && options.cachePath) {
+            await cacheTemplate(filePath, output, dependencies, options);
+            if (options.debug) {
+              console.log(`Cached template ${filePath} with ${dependencies.size} dependencies`);
+            }
+          }
+          return {
+            contents: output,
+            loader: "html"
+          };
+        } catch (error) {
+          console.error("stx Plugin Error:", error);
+          return {
+            contents: generateErrorPage("stx Rendering Error", error.message || String(error), filePath),
+            loader: "html"
+          };
+        }
+      });
+    }
+  };
+}
+var src_default = stxPlugin;
+
+export { createWatcher, watchAndBuild, startWatchMode, stxPlugin, createMiddleware, createRoute, readMarkdownFile2 as readMarkdownFile, src_default };

package/dist/client.js

@@ -1,2 +1,117 @@
 // @bun
-import"./chunk-h0s48z3v.js";var R="1.0.0",L=typeof window<"u"&&typeof document<"u";async function N(x,E,G){if(!L)return;try{let j=x.getAttribute("data-island-id"),q=document.querySelector(`script[data-island-props="${j}"]`),C=q?JSON.parse(q.textContent||"{}"):{},J=await G(),K=J.default||J.hydrate;if(typeof K!=="function"){console.error(`Island handler for "${E}" does not export a valid hydration function`);return}await K(x,C),x.setAttribute("data-hydrated","true")}catch(j){console.error(`Failed to hydrate island "${E}":`,j)}}function P(x){if(!L)return;let E=document.querySelectorAll("[data-island]"),G=[];if(E.forEach((j)=>{let q=j.getAttribute("data-island"),C=j.getAttribute("data-priority")||"lazy";if(!q||!x[q]||j.getAttribute("data-hydrated")==="true")return;if(C==="eager")N(j,q,x[q]);else G.push([j,q])}),G.length>0&&"IntersectionObserver"in window){let j=new IntersectionObserver((q)=>{q.forEach((C)=>{if(C.isIntersecting){let J=C.target,K=J.getAttribute("data-island");if(K&&x[K]&&J.getAttribute("data-hydrated")!=="true")N(J,K,x[K]),j.unobserve(J)}})},{rootMargin:"200px",threshold:0});G.forEach(([q])=>{j.observe(q)})}else setTimeout(()=>{G.forEach(([j,q])=>{if(j.getAttribute("data-hydrated")!=="true")N(j,q,x[q])})},1000)}function Q(x){if(!L)return;Object.entries(x).forEach(([E,G])=>{try{let q=G.toString().match(/import\(['"](.+)['"]\)/);if(q&&q[1]){let C=document.createElement("link");C.rel="modulepreload",C.href=q[1],C.setAttribute("data-island-module",E),document.head.appendChild(C)}}catch(j){console.warn(`Failed to preload island handler for "${E}":`,j)}})}function T(x,E={}){if(!L)return;let j={...{autoStart:!0,preload:"lazy"},...E};if(j.preload!=="none")Q(x);if(j.autoStart)if(document.readyState==="loading")document.addEventListener("DOMContentLoaded",()=>{P(x)});else P(x)}export{R as version,Q as preloadIslandHandlers,T as initIslands,P as hydrateIslands};
+import"./chunk-eecw9x2f.js";
+
+// src/client.ts
+var version = "1.0.0";
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+async function hydrateIsland(element, name, handler) {
+  if (!isBrowser)
+    return;
+  try {
+    const id = element.getAttribute("data-island-id");
+    const propsScript = document.querySelector(`script[data-island-props="${id}"]`);
+    const props = propsScript ? JSON.parse(propsScript.textContent || "{}") : {};
+    const module = await handler();
+    const hydrateFn = module.default || module.hydrate;
+    if (typeof hydrateFn !== "function") {
+      console.error(`Island handler for "${name}" does not export a valid hydration function`);
+      return;
+    }
+    await hydrateFn(element, props);
+    element.setAttribute("data-hydrated", "true");
+  } catch (error) {
+    console.error(`Failed to hydrate island "${name}":`, error);
+  }
+}
+function hydrateIslands(handlers) {
+  if (!isBrowser)
+    return;
+  const islands = document.querySelectorAll("[data-island]");
+  const lazyIslands = [];
+  islands.forEach((island) => {
+    const name = island.getAttribute("data-island");
+    const priority = island.getAttribute("data-priority") || "lazy";
+    if (!name || !handlers[name] || island.getAttribute("data-hydrated") === "true") {
+      return;
+    }
+    if (priority === "eager") {
+      hydrateIsland(island, name, handlers[name]);
+    } else {
+      lazyIslands.push([island, name]);
+    }
+  });
+  if (lazyIslands.length > 0 && "IntersectionObserver" in window) {
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        if (entry.isIntersecting) {
+          const element = entry.target;
+          const name = element.getAttribute("data-island");
+          if (name && handlers[name] && element.getAttribute("data-hydrated") !== "true") {
+            hydrateIsland(element, name, handlers[name]);
+            observer.unobserve(element);
+          }
+        }
+      });
+    }, {
+      rootMargin: "200px",
+      threshold: 0
+    });
+    lazyIslands.forEach(([element]) => {
+      observer.observe(element);
+    });
+  } else {
+    setTimeout(() => {
+      lazyIslands.forEach(([element, name]) => {
+        if (element.getAttribute("data-hydrated") !== "true") {
+          hydrateIsland(element, name, handlers[name]);
+        }
+      });
+    }, 1000);
+  }
+}
+function preloadIslandHandlers(handlers) {
+  if (!isBrowser)
+    return;
+  Object.entries(handlers).forEach(([name, getHandler]) => {
+    try {
+      const handlerString = getHandler.toString();
+      const moduleMatch = handlerString.match(/import\(['"](.+)['"]\)/);
+      if (moduleMatch && moduleMatch[1]) {
+        const link = document.createElement("link");
+        link.rel = "modulepreload";
+        link.href = moduleMatch[1];
+        link.setAttribute("data-island-module", name);
+        document.head.appendChild(link);
+      }
+    } catch (error) {
+      console.warn(`Failed to preload island handler for "${name}":`, error);
+    }
+  });
+}
+function initIslands(handlers, config = {}) {
+  if (!isBrowser)
+    return;
+  const defaultConfig = {
+    autoStart: true,
+    preload: "lazy"
+  };
+  const options = { ...defaultConfig, ...config };
+  if (options.preload !== "none") {
+    preloadIslandHandlers(handlers);
+  }
+  if (options.autoStart) {
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => {
+        hydrateIslands(handlers);
+      });
+    } else {
+      hydrateIslands(handlers);
+    }
+  }
+}
+export {
+  version,
+  preloadIslandHandlers,
+  initIslands,
+  hydrateIslands
+};

package/dist/index.d.ts

@@ -1,7 +1,34 @@
 import type { BunPlugin } from 'bun';
 import { readMarkdownFile } from '@stacksjs/stx';
 import type { StxOptions } from '@stacksjs/stx';
-export type { ServeOptions, ServeResult, StxOptions } from '@stacksjs/stx';
+export type {
+  WatchAndBuildOptions,
+  WatchBuildResult,
+  WatcherInstance,
+  WatchEvent,
+  WatchOptions,
+} from './watch';
+export type { CustomDirective, CustomDirectiveHandler, ServeOptions, ServeResult, StxOptions } from '@stacksjs/stx';
+/**
+ * Create a Bun plugin for processing .stx and .md files
+ *
+ * @param userOptions - Optional configuration to override defaults
+ * @returns BunPlugin instance
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const plugin = stxPlugin()
+ *
+ * // With options
+ * const plugin = stxPlugin({
+ *   debug: true,
+ *   cache: true,
+ *   cachePath: '.stx/cache'
+ * })
+ * ```
+ */
 export declare function stxPlugin(userOptions?: StxOptions): BunPlugin;
-export { createMiddleware, createRoute, readMarkdownFile, serve } from '@stacksjs/stx';
+export { createWatcher, startWatchMode, watchAndBuild } from './watch';
+export { createMiddleware, createRoute, readMarkdownFile } from '@stacksjs/stx';
 export default stxPlugin;

package/dist/index.js

@@ -1,20 +1,22 @@
 // @bun
-import{b as E,c as M,d as F,e as g,f as P,g as N}from"./chunk-mjj2b826.js";import"./chunk-h0s48z3v.js";import u from"path";import q from"fs";import L from"path";var i=new Map;async function b(z,j){try{let Z=L.resolve(j.cachePath),V=L.join(Z,`${w(z)}.html`),K=L.join(Z,`${w(z)}.meta.json`);if(!await M(V)||!await M(K))return null;let _=await Bun.file(K).text(),Q=JSON.parse(_);if(Q.cacheVersion!==j.cacheVersion)return null;if((await q.promises.stat(z)).mtime.getTime()>Q.mtime)return null;for(let J of Q.dependencies)if(await M(J)){if((await q.promises.stat(J)).mtime.getTime()>Q.mtime)return null}else return null;return await Bun.file(V).text()}catch(Z){return console.warn(`Cache error for ${z}:`,Z),null}}async function C(z,j,Z,V){try{let K=L.resolve(V.cachePath);await q.promises.mkdir(K,{recursive:!0});let _=L.join(K,`${w(z)}.html`),Q=L.join(K,`${w(z)}.meta.json`),H=await q.promises.stat(z);await Bun.write(_,j);let J={sourcePath:z,mtime:H.mtime.getTime(),dependencies:Array.from(Z),cacheVersion:V.cacheVersion,generatedAt:Date.now()};await Bun.write(Q,JSON.stringify(J,null,2)),i.set(z,{output:j,mtime:H.mtime.getTime(),dependencies:Z})}catch(K){console.warn(`Failed to cache template ${z}:`,K)}}function w(z){return new Bun.CryptoHasher("sha1").update(z).digest("hex").substring(0,16)}var{serve:n}=globalThis.Bun;import k from"fs";import S from"path";async function r(z={}){let{port:j=3000,root:Z=".",stxOptions:V={},watch:K=!0,onRequest:_,routes:Q={},middleware:H=[],on404:J,onError:W}=z,y=S.resolve(Z),A=new Map;async function T($){let G=k.statSync($),U=`${$}:${G.mtimeMs}`,Y=A.get(U);if(Y)return Y.content;let X=await Bun.file($).text(),B=X.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i),m=B?B[1]:"",p=X.match(/<script\b[^>]*>[\s\S]*?<\/script>/gi)||[],l=X.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi,""),f={__filename:$,__dirname:S.dirname($)};await F(m,f,$);let R=await E(l,f,$,V,new Set),D=[...p];if(D.length>0)if(R.match(/(<\/body>)/i)){let c=D.join(`
-`);R=R.replace(/(<\/body>)/i,`${c}
-$1`)}else R+=`
-${D.join(`
-`)}`;return A.set(U,{content:R,mtime:G.mtimeMs}),R}async function O($){let G=k.statSync($),U=`${$}:${G.mtimeMs}`,Y=A.get(U);if(Y)return Y.content;let{content:X}=await N($,V);return A.set(U,{content:X,mtime:G.mtimeMs}),X}function I($){let G=$.startsWith("/")?$.slice(1):$,U=[G,`${G}.stx`,`${G}.md`,`${G}.html`,S.join(G,"index.stx"),S.join(G,"index.md"),S.join(G,"index.html")];for(let Y of U){let X=S.join(y,Y);if(k.existsSync(X)&&k.statSync(X).isFile())return X}return null}async function h($){let G=new URL($.url),U=async()=>{if(Q[G.pathname])return await Q[G.pathname]($);if(_){let X=await _($);if(X)return X}let Y=I(G.pathname);if(!Y){if(J)return await J($);return new Response("Not Found",{status:404})}try{let X,B="text/html";if(Y.endsWith(".stx"))X=await T(Y);else if(Y.endsWith(".md"))X=await O(Y);else if(Y.endsWith(".html"))X=await Bun.file(Y).text();else if(Y.endsWith(".css"))X=await Bun.file(Y).text(),B="text/css";else if(Y.endsWith(".js"))X=await Bun.file(Y).text(),B="text/javascript";else if(Y.endsWith(".json"))X=await Bun.file(Y).text(),B="application/json";else return new Response(Bun.file(Y));return new Response(X,{headers:{"Content-Type":B}})}catch(X){if(W)return await W(X,$);return new Response(`<h1>Error</h1><pre>${X.message}
-${X.stack}</pre>`,{status:500,headers:{"Content-Type":"text/html"}})}};for(let Y=H.length-1;Y>=0;Y--){let X=H[Y],B=U;U=async()=>await X($,B)}return await U()}let x=n({port:j,fetch:h}),v=null;if(K)v=k.watch(y,{recursive:!0},($,G)=>{if(G&&(G.endsWith(".stx")||G.endsWith(".md")||G.endsWith(".html")))A.clear()});return{server:x,url:x.url.toString(),stop(){if(v)v.close();x.stop()}}}function s(z){return z}function o(z){return z}function e(z){return{name:"bun-plugin-stx",async setup(j){let Z={...P,...z},V=new Set,K=Z.webComponents?.enabled?`./${u.relative(u.dirname(j.config?.outdir||"dist"),Z.webComponents.outputDir||"dist/web-components")}`:"/web-components",_=[];if(Z.webComponents?.enabled)try{let Q=await g(Z,V);if(_.push(...Q),Z.debug&&Q.length>0)console.log(`Successfully built ${Q.length} web components`)}catch(Q){console.error("Failed to build web components:",Q)}j.onLoad({filter:/\.md$/},async({path:Q})=>{try{let{content:H,data:J}=await N(Q,Z);return{contents:`// ${Q}
-var content = ${JSON.stringify(H)};
-var data = ${JSON.stringify(J)};
-
-export { content, data };
-export { content as default };
-`,loader:"js"}}catch(H){console.error("Markdown Processing Error:",H);let J=`<!DOCTYPE html><html><body><h1>Markdown Error</h1><pre>${H.message||"Unknown error"}</pre></body></html>`;return{contents:`// ${Q}
-var content = ${JSON.stringify(J)};
-var data = {};
-
-export { content, data };
-export { content as default };
-`,loader:"js"}}}),j.onLoad({filter:/\.stx$/},async({path:Q})=>{try{let H=new Set;if(Z.cache&&Z.cachePath){let I=await b(Q,Z);if(I){if(Z.debug)console.log(`Using cached version of ${Q}`);return{contents:I,loader:"html"}}}let J=await Bun.file(Q).text(),W=J.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i),y=W?W[1]:"",A=J.replace(/<script\b[^>]*>[\s\S]*?<\/script>/i,""),T={__filename:Q,__dirname:u.dirname(Q),__stx:{webComponentsPath:K,builtComponents:_}};await F(y,T,Q);let O=A;if(O=await E(O,T,Q,Z,H),H.forEach((I)=>V.add(I)),Z.cache&&Z.cachePath){if(await C(Q,O,H,Z),Z.debug)console.log(`Cached template ${Q} with ${H.size} dependencies`)}return{contents:O,loader:"html"}}catch(H){return console.error("stx Plugin Error:",H),{contents:`<!DOCTYPE html><html><body><h1>stx Rendering Error</h1><pre>${H.message||String(H)}</pre></body></html>`,loader:"html"}}})}}}var X7=e;export{e as stxPlugin,r as serve,N as readMarkdownFile,X7 as default,o as createRoute,s as createMiddleware};
-export{X7 as a};
+import {
+  createMiddleware,
+  createRoute,
+  createWatcher,
+  readMarkdownFile,
+  src_default,
+  startWatchMode,
+  stxPlugin,
+  watchAndBuild
+} from "./chunk-ymdk9x8z.js";
+import"./chunk-eecw9x2f.js";
+export {
+  watchAndBuild,
+  stxPlugin,
+  startWatchMode,
+  readMarkdownFile,
+  src_default as default,
+  createWatcher,
+  createRoute,
+  createMiddleware
+};

package/dist/preload.js

@@ -1,2 +1,10 @@
 // @bun
-import{a as c}from"./index.js";import"./chunk-mjj2b826.js";import"./chunk-h0s48z3v.js";var{plugin:j}=globalThis.Bun;j(c());console.log("\u2705 stx plugin loaded - .stx files can now be imported");
+import {
+  src_default
+} from "./chunk-ymdk9x8z.js";
+import"./chunk-eecw9x2f.js";
+
+// src/preload.ts
+var {plugin } = globalThis.Bun;
+plugin(src_default());
+console.log("\u2705 stx plugin loaded - .stx files can now be imported");