solid-tag-runtime 0.0.11 → 0.0.13

package/examples/main.tsx

@@ -0,0 +1,318 @@
+import { render } from "@solidjs/web";
+import * as Solid from "solid-js";
+import * as SolidWeb from "@solidjs/web";
+import html from "@solidjs/html";
+import { createRuntime } from "solid-tag-runtime";
+import { createHTMLRuntime } from "solid-tag-runtime/html";
+
+// A tiny type helper for module exports returned by solid-tag-runtime.
+type Component<P = Record<string, unknown>> = (props: P) => any;
+
+async function main() {
+  const root = document.getElementById("root");
+  if (!root) throw new Error("Missing #root element");
+
+  // ---------------------------------------------------------------------------
+  // 1. Host application state
+  // ---------------------------------------------------------------------------
+  // These signals are created by the Solid runtime already bundled with the app.
+  // Runtime-created modules receive the exact same signal/accessor references.
+
+  const [hostCount, setHostCount] = Solid.createSignal(100);
+  const [hostMessage, setHostMessage] = Solid.createSignal(
+    "Hello from the host application",
+  );
+
+  // ---------------------------------------------------------------------------
+  // 2. Create the runtime and reuse this application's Solid modules
+  // ---------------------------------------------------------------------------
+  // This is important: dynamic components do NOT load another Solid runtime.
+
+  const runtime = createRuntime({
+    modules: {
+      "solid-js": Solid,
+      "@solidjs/web": SolidWeb,
+      "@solidjs/html": { default: html },
+    },
+  });
+
+  // ---------------------------------------------------------------------------
+  // 3. Expose host-owned state/services as a normal runtime module
+  // ---------------------------------------------------------------------------
+  // Runtime source can now use:
+  //
+  //   import { hostCount, setHostCount } from "@app/state";
+  //
+  // No serialization or global-variable rewriting is involved.
+
+  runtime.defineModule("@app/state", {
+    hostCount,
+    setHostCount,
+    hostMessage,
+    setHostMessage,
+  });
+
+  // ---------------------------------------------------------------------------
+  // 4. Observe runtime module scripts added to the document
+  // ---------------------------------------------------------------------------
+  // We already own registration in this demo, so only watch scripts added from
+  // this point forward. Each observed batch is fully defined before any entry
+  // in that batch executes.
+
+  const htmlRuntime = createHTMLRuntime(runtime, {
+    scope: "main",
+    root: document,
+    appendTo: document.body,
+    acceptUnscoped: false,
+  });
+
+  await htmlRuntime.observe({
+    registerExisting: false,
+    onError(error) {
+      console.error("Observed runtime module failed", error);
+    },
+  });
+
+  // This script is inert to the browser because its type is solid-jsx, but the
+  // solid-tag-runtime HTML adapter discovers it through MutationObserver.
+  const observedModuleScript = document.createElement("script");
+  observedModuleScript.type = "solid-jsx";
+  observedModuleScript.setAttribute("data-solid-runtime", "main");
+  observedModuleScript.setAttribute("module", "/observed/Badge.jsx");
+  observedModuleScript.textContent = `
+    export function ObservedBadge(props) {
+      return (
+        <small
+          style={{
+            display: "inline-block",
+            padding: "4px 8px",
+            border: "1px dashed #777",
+            "border-radius": "999px"
+          }}
+        >
+          Observed module: {props.children}
+        </small>
+      );
+    }
+  `;
+  document.body.append(observedModuleScript);
+
+  // MutationObserver is automatic; flush() is useful when the application wants
+  // to explicitly wait until discovered modules are ready before importing them.
+  await htmlRuntime.flush();
+
+  // ---------------------------------------------------------------------------
+  // 5. Define a reusable runtime JSX module
+  // ---------------------------------------------------------------------------
+
+  runtime.define(
+    "/ui/Button.jsx",
+    `
+      export function Button(props) {
+        return (
+          <button
+            type="button"
+            onClick={props.onClick}
+            style={{
+              padding: "8px 12px",
+              border: "1px solid #777",
+              "border-radius": "6px",
+              cursor: "pointer"
+            }}
+          >
+            {props.children}
+          </button>
+        );
+      }
+    `,
+  );
+
+  // ---------------------------------------------------------------------------
+  // 6. Define another runtime module that imports Button + host state + Solid
+  // ---------------------------------------------------------------------------
+
+  runtime.define(
+    "/features/Counter.jsx",
+    `
+      import { createSignal } from "solid-js";
+      import { Button } from "../ui/Button.jsx";
+      import { hostCount, setHostCount } from "@app/state";
+
+      export function Counter() {
+        const [localCount, setLocalCount] = createSignal(0);
+
+        return (
+          <section
+            style={{
+              display: "grid",
+              gap: "10px",
+              padding: "16px",
+              border: "1px solid #555",
+              "border-radius": "8px"
+            }}
+          >
+            <strong>Runtime Counter module</strong>
+
+            <div>Local runtime signal: {localCount()}</div>
+            <div>Host application signal: {hostCount()}</div>
+
+            <div style={{ display: "flex", gap: "8px", "flex-wrap": "wrap" }}>
+              <Button onClick={() => setLocalCount(value => value + 1)}>
+                Increment local
+              </Button>
+
+              <Button onClick={() => setHostCount(value => value + 1)}>
+                Increment host
+              </Button>
+            </div>
+          </section>
+        );
+      }
+    `,
+  );
+
+  // ---------------------------------------------------------------------------
+  // 7. toModule(): create an anonymous runtime module and get its exports
+  // ---------------------------------------------------------------------------
+
+  const greetingModule = await runtime.toModule(`
+    export function Greeting(props) {
+      return (
+        <p style={{ margin: 0, opacity: 0.8 }}>
+          Runtime module says: Hello {props.name}!
+        </p>
+      );
+    }
+  `);
+
+  // A compiled module namespace can itself be exposed as a named host module.
+  // That lets other runtime modules import it normally.
+  runtime.defineModule("@runtime/greeting", greetingModule);
+
+  // ---------------------------------------------------------------------------
+  // 8. Define the runtime application module
+  // ---------------------------------------------------------------------------
+  // It imports another runtime JSX module, an anonymous module namespace that we
+  // registered above, and host state.
+
+  runtime.define(
+    "/App.jsx",
+    `
+      import { Counter } from "./features/Counter.jsx";
+      import { Greeting } from "@runtime/greeting";
+      import { ObservedBadge } from "./observed/Badge.jsx";
+      import { hostMessage, setHostMessage } from "@app/state";
+
+      export function App(props) {
+        return (
+          <main
+            style={{
+              display: "grid",
+              gap: "16px",
+              width: "min(680px, calc(100% - 32px))",
+              margin: "40px auto",
+              "font-family": "system-ui, sans-serif"
+            }}
+          >
+            <h1 style={{ margin: 0 }}>{props.title}</h1>
+
+            <Greeting name={props.name} />
+
+            <ObservedBadge>
+              discovered through MutationObserver
+            </ObservedBadge>
+
+            <p style={{ margin: 0 }}>
+              Host message: {hostMessage()}
+            </p>
+
+            <button
+              type="button"
+              onClick={() =>
+                setHostMessage("The runtime App changed host-owned state")
+              }
+            >
+              Change host message from runtime code
+            </button>
+
+            <Counter />
+          </main>
+        );
+      }
+    `,
+  );
+
+  // ---------------------------------------------------------------------------
+  // 9. Import the runtime module and use its exported component in host JSX
+  // ---------------------------------------------------------------------------
+
+  const appModule = await runtime.import("/App.jsx");
+  const RuntimeApp = appModule.App as Component<{
+    title: string;
+    name: string;
+  }>;
+
+  const disposeRender = render(
+    () => (
+      <RuntimeApp
+        title="solid-tag-runtime demo"
+        name="Solid"
+      />
+    ),
+    root,
+  );
+
+  // ---------------------------------------------------------------------------
+  // 10. Runtime module graph introspection
+  // ---------------------------------------------------------------------------
+
+  console.table(runtime.modules());
+  console.log("/App.jsx dependencies:", runtime.dependencies("/App.jsx"));
+  console.log(
+    "/features/Counter.jsx dependencies:",
+    runtime.dependencies("/features/Counter.jsx"),
+  );
+  console.log(
+    "/ui/Button.jsx dependents:",
+    runtime.dependents("/ui/Button.jsx"),
+  );
+
+  // You can inspect the transformed module source too.
+  const compiledCounter = await runtime.compile("/features/Counter.jsx");
+  console.log("Compiled Counter module:\n", compiledCounter.code);
+
+  // Optional demo/debug handle from the browser console.
+  Object.assign(globalThis, {
+    solidTagDemo: {
+      runtime,
+      hostCount,
+      setHostCount,
+      hostMessage,
+      setHostMessage,
+      htmlRuntime,
+      dispose() {
+        htmlRuntime.disconnect();
+        observedModuleScript.remove();
+        disposeRender();
+        runtime.dispose();
+      },
+    },
+  });
+}
+
+main().catch(error => {
+  console.error("solid-tag-runtime demo failed", error);
+
+  const root = document.getElementById("root");
+  if (root) {
+    const pre = document.createElement("pre");
+    pre.style.whiteSpace = "pre-wrap";
+    pre.style.color = "crimson";
+    pre.textContent =
+      error instanceof Error
+        ? error.stack ?? error.message
+        : String(error);
+
+    root.replaceChildren(pre);
+  }
+});

package/examples/render.html

@@ -0,0 +1,79 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>solid-tag-runtime rendering</title>
+  </head>
+  <body>
+    <div id="app"></div>
+
+    <!-- Define a reusable runtime module. -->
+    <script type="solid-jsx" data-solid-runtime="main" module="/Counter.jsx">
+      import { createSignal } from "solid-js";
+
+      export default function Counter(props) {
+        const [count, setCount] = createSignal(0);
+        return (
+          <button onClick={() => setCount(value => value + 1)}>
+            {props.label}: {count()}
+          </button>
+        );
+      }
+    </script>
+
+    <!-- Define + mount one declaration-owned instance into #app. -->
+    <script
+      type="solid-jsx"
+      data-solid-runtime="main"
+      module="/App.jsx"
+      render="#app"
+    >
+      export default function App() {
+        return <h1>Mounted by &lt;script render&gt;</h1>;
+      }
+    </script>
+
+    <!-- Reference the already-defined Counter module and create independent instances. -->
+    <solid-render
+      data-solid-runtime="main"
+      module="/Counter.jsx"
+      prop:label="Counter A"
+    ></solid-render>
+
+    <solid-render
+      data-solid-runtime="main"
+      module="/Counter.jsx"
+      prop:label="Counter B"
+    ></solid-render>
+
+    <!--
+      This bootstrap is ordinary JavaScript. The surrounding application/import
+      map is responsible for resolving Solid and solid-tag-runtime bare imports.
+    -->
+    <script type="module">
+      import * as Solid from "solid-js";
+      import * as SolidWeb from "@solidjs/web";
+      import html from "@solidjs/html";
+      import { createRuntime } from "solid-tag-runtime";
+      import { createHTMLRuntime } from "solid-tag-runtime/html";
+
+      const runtime = createRuntime({
+        modules: {
+          "solid-js": Solid,
+          "@solidjs/web": SolidWeb,
+          "@solidjs/html": { default: html },
+        },
+      });
+
+      const htmlRuntime = createHTMLRuntime(runtime, {
+        scope: "main",
+        root: document,
+        appendTo: document.body,
+        acceptUnscoped: false,
+      });
+
+      await htmlRuntime.register();
+      await htmlRuntime.observe({ registerExisting: false });
+    </script>
+  </body>
+</html>

package/index.d.ts

@@ -1,30 +1,58 @@
 export type ModuleFormat = "jsx" | "js";
+export type CompileCacheMode = "use" | "refresh" | "bypass";
 
 export interface ModuleNamespaceLike {
   readonly [key: string]: unknown;
 }
 
+export interface CompileContext {
+  id?: string;
+  format?: ModuleFormat;
+}
+
 export interface CompilerImportReference {
   specifier: string;
   start: number;
   end: number;
-  kind?: string;
+  kind?: "static" | "dynamic" | "export" | string;
+}
+
+export interface CompiledArtifact {
+  schema?: number;
+  code: string;
+  imports: CompilerImportReference[];
+  diagnostics?: unknown[];
+  sourceMap?: string;
+  changed?: boolean;
 }
 
 export interface RuntimeCompiler {
-  analyze(source: string, context?: { id?: string; format?: ModuleFormat }): {
+  /** Stable identity required for persistent compile-cache reuse. */
+  fingerprint?: string | ((context: CompileContext) => string | Promise<string>);
+  /** Additional compile-affecting context to include in persistent cache identity. */
+  cacheContext?: (context: CompileContext) => unknown | Promise<unknown>;
+  /** Preferred compiler boundary: return a linker-ready pre-link artifact. */
+  compile?(source: string, context?: CompileContext): CompiledArtifact | Promise<CompiledArtifact>;
+  /** Transitional compiler API retained for compatibility. */
+  analyze?(source: string, context?: CompileContext): {
+    imports?: CompilerImportReference[];
+    needsHtmlRuntime?: boolean;
+  } | Promise<{
     imports?: CompilerImportReference[];
     needsHtmlRuntime?: boolean;
-  };
-  transform(source: string, context?: {
-    id?: string;
-    format?: ModuleFormat;
-    htmlImportSource?: string;
-  }): {
+  }>;
+  /** Transitional compiler API retained for compatibility. */
+  transform?(source: string, context?: CompileContext & { htmlImportSource?: string }): {
+    code: string;
+    diagnostics?: unknown[];
+    changed?: boolean;
+    sourceMap?: string;
+  } | Promise<{
     code: string;
     diagnostics?: unknown[];
     changed?: boolean;
-  };
+    sourceMap?: string;
+  }>;
 }
 
 export interface ModuleUrlBackend {
@@ -33,6 +61,53 @@ export interface ModuleUrlBackend {
   revoke?(url: string): void;
 }
 
+export interface CachedCompileRecord {
+  schema: number;
+  key: string;
+  artifactAbi: string;
+  sourceHash: string;
+  format: string;
+  compilerFingerprint: string;
+  compileContextHash: string;
+  artifact: CompiledArtifact;
+  createdAt: number;
+  lastUsedAt?: number;
+  byteSize?: number;
+  artifactHash?: string;
+}
+
+export interface CompileCacheStore {
+  readonly kind?: string;
+  get(key: string): Promise<CachedCompileRecord | undefined>;
+  set(key: string, value: CachedCompileRecord): Promise<void>;
+  delete(key: string): Promise<boolean | void>;
+  clear?(options?: { prefix?: string }): Promise<number | void>;
+  entries?(options?: { prefix?: string }): Promise<Array<[string, CachedCompileRecord]>>;
+}
+
+export interface CompileCacheOptions {
+  enabled?: boolean;
+  store: CompileCacheStore;
+  namespace?: string;
+  version?: string;
+  maxEntries?: number;
+  maxBytes?: number;
+  /** Maximum record age in milliseconds. */
+  maxAge?: number;
+}
+
+export interface LocalStorageLike {
+  readonly length: number;
+  key(index: number): string | null;
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+export interface IndexedDBFactoryLike {
+  open(name: string, version?: number): any;
+}
+
 export interface RuntimeOptions {
   compiler?: RuntimeCompiler;
   compilerOptions?: Record<string, unknown>;
@@ -41,6 +116,8 @@ export interface RuntimeOptions {
   allowNativeImports?: boolean;
   resolve?: (specifier: string, importer: string | null, runtime: SolidTagRuntime) => string | void;
   moduleUrlBackend?: ModuleUrlBackend;
+  /** Opt-in persistent pre-link compile artifact cache. */
+  compileCache?: CompileCacheOptions | false;
 }
 
 export interface DefineOptions {
@@ -55,6 +132,20 @@ export interface ToComponentOptions extends ToModuleOptions {
   exportName?: string;
 }
 
+export interface CompileOptions {
+  cache?: CompileCacheMode;
+}
+
+export interface CompileCacheInfo {
+  enabled: boolean;
+  status: "none" | "hit" | "miss" | "refresh" | "bypass";
+  source?: string;
+  key?: string;
+  compilerFingerprint?: string;
+  sourceHash?: string;
+  compileContextHash?: string;
+}
+
 export interface ModuleInfo {
   id: string;
   kind: "source" | "host" | "url";
@@ -65,6 +156,7 @@ export interface ModuleInfo {
   dependents: string[];
   url?: string;
   diagnostics: unknown[];
+  compileCache?: CompileCacheInfo;
 }
 
 export interface CompileResult {
@@ -91,6 +183,23 @@ export interface ClearRuntimeOptions {
   preserveHostModules?: boolean;
 }
 
+export interface InvalidateOptions {
+  dependents?: boolean;
+  /** Force only the requested source module to compile fresh on its next link. */
+  compile?: boolean;
+}
+
+export interface RuntimeCompileCache {
+  readonly enabled: boolean;
+  readonly namespace?: string;
+  readonly version?: string;
+  readonly store?: string;
+  /** Delete the current module's stored compiler artifact without graph invalidation. */
+  invalidate(id: string): Promise<boolean>;
+  /** Clear current namespace/version, or all versions within the current namespace. */
+  clear(options?: { allVersions?: boolean }): Promise<number>;
+}
+
 export type ModuleResolutionKind =
   | "custom"
   | "registered"
@@ -113,28 +222,57 @@ export interface LinkedDependency {
   resolvedId: string;
 }
 
+export type CompileCacheErrorOperation =
+  | "identity"
+  | "fingerprint"
+  | "read"
+  | "write"
+  | "delete"
+  | "clear"
+  | "prune";
+
+interface RuntimeEventBase {
+  runtimeId: string;
+  timestamp: number;
+}
+
+interface CompileCacheEventBase extends RuntimeEventBase {
+  id?: string;
+  key?: string;
+  store?: string;
+  source?: string;
+  durationMs?: number;
+  byteSize?: number;
+}
+
 export type RuntimeLifecycleEvent =
-  | { runtimeId: string; timestamp: number; type: "module-defined"; id: string; kind: ModuleInfo["kind"]; version: number; operation: "define" | "defineMany" | "update" | "defineModule" | "defineUrl"; replaced: boolean; module: ModuleInfo }
-  | { runtimeId: string; timestamp: number; type: "module-updated"; id: string; kind: ModuleInfo["kind"]; previousVersion: number; version: number; format?: ModuleFormat; module: ModuleInfo }
-  | { runtimeId: string; timestamp: number; type: "modules-defined"; ids: string[]; modules: ModuleInfo[] }
-  | { runtimeId: string; timestamp: number; type: "module-resolving"; specifier: string; importer: string | null }
-  | { runtimeId: string; timestamp: number; type: "module-resolved"; specifier: string; importer: string | null; resolvedId: string; resolutionKind: ModuleResolutionKind }
-  | { runtimeId: string; timestamp: number; type: "module-linking"; id: string; kind: ModuleInfo["kind"]; version: number }
-  | { runtimeId: string; timestamp: number; type: "module-linked"; id: string; kind: ModuleInfo["kind"]; version: number; dependencies: LinkedDependency[]; module: ModuleInfo }
-  | { runtimeId: string; timestamp: number; type: "module-invalidated"; id: string; kind: ModuleInfo["kind"]; version: number; reason: string }
-  | { runtimeId: string; timestamp: number; type: "module-compiled"; id: string; kind: ModuleInfo["kind"]; version: number; module: ModuleInfo }
-  | { runtimeId: string; timestamp: number; type: "module-evaluating"; id: string; kind: ModuleInfo["kind"]; version: number }
-  | { runtimeId: string; timestamp: number; type: "module-evaluated"; id: string; kind: ModuleInfo["kind"]; version: number; module: ModuleInfo }
-  | { runtimeId: string; timestamp: number; type: "module-removed"; id: string; kind: ModuleInfo["kind"]; version: number; invalidateDependents: boolean }
-  | { runtimeId: string; timestamp: number; type: "module-error"; id?: string; kind?: ModuleInfo["kind"]; version?: number; phase: ModuleErrorPhase; error: unknown }
-  | { runtimeId: string; timestamp: number; type: "runtime-cleared"; ids: string[]; preserveHostModules: boolean }
-  | { runtimeId: string; timestamp: number; type: "runtime-disposed" };
+  | (RuntimeEventBase & { type: "module-defined"; id: string; kind: ModuleInfo["kind"]; version: number; operation: "define" | "defineMany" | "update" | "defineModule" | "defineUrl"; replaced: boolean; module: ModuleInfo })
+  | (RuntimeEventBase & { type: "module-updated"; id: string; kind: ModuleInfo["kind"]; previousVersion: number; version: number; format?: ModuleFormat; module: ModuleInfo })
+  | (RuntimeEventBase & { type: "modules-defined"; ids: string[]; modules: ModuleInfo[] })
+  | (RuntimeEventBase & { type: "module-resolving"; specifier: string; importer: string | null })
+  | (RuntimeEventBase & { type: "module-resolved"; specifier: string; importer: string | null; resolvedId: string; resolutionKind: ModuleResolutionKind })
+  | (RuntimeEventBase & { type: "module-linking"; id: string; kind: ModuleInfo["kind"]; version: number })
+  | (RuntimeEventBase & { type: "module-linked"; id: string; kind: ModuleInfo["kind"]; version: number; dependencies: LinkedDependency[]; module: ModuleInfo })
+  | (RuntimeEventBase & { type: "module-invalidated"; id: string; kind: ModuleInfo["kind"]; version: number; reason: string })
+  | (RuntimeEventBase & { type: "module-compiled"; id: string; kind: ModuleInfo["kind"]; version: number; module: ModuleInfo })
+  | (RuntimeEventBase & { type: "module-evaluating"; id: string; kind: ModuleInfo["kind"]; version: number })
+  | (RuntimeEventBase & { type: "module-evaluated"; id: string; kind: ModuleInfo["kind"]; version: number; module: ModuleInfo })
+  | (RuntimeEventBase & { type: "module-removed"; id: string; kind: ModuleInfo["kind"]; version: number; invalidateDependents: boolean })
+  | (RuntimeEventBase & { type: "module-error"; id?: string; kind?: ModuleInfo["kind"]; version?: number; phase: ModuleErrorPhase; error: unknown })
+  | (RuntimeEventBase & { type: "runtime-cleared"; ids: string[]; preserveHostModules: boolean })
+  | (RuntimeEventBase & { type: "runtime-disposed" })
+  | (CompileCacheEventBase & { type: "compile-cache-hit" })
+  | (CompileCacheEventBase & { type: "compile-cache-miss" })
+  | (CompileCacheEventBase & { type: "compile-cache-write" })
+  | (CompileCacheEventBase & { type: "compile-cache-refresh" })
+  | (CompileCacheEventBase & { type: "compile-cache-bypass"; reason?: "requested" | "missing-compiler-fingerprint" | string })
+  | (CompileCacheEventBase & { type: "compile-cache-evict"; reason: "maxAge" | "maxEntries" | "maxBytes" | "invalid" | string })
+  | (CompileCacheEventBase & { type: "compile-cache-error"; operation: CompileCacheErrorOperation | string; error: unknown });
 
 export type RuntimeLifecycleEventType = RuntimeLifecycleEvent["type"];
 export type RuntimeLifecycleEventOfType<T extends RuntimeLifecycleEventType> =
   Extract<RuntimeLifecycleEvent, { type: T }>;
 
-
 export interface SolidTagRuntime {
   define(id: string, source: string, options?: DefineOptions): string;
   defineMany(definitions: SourceModuleDefinition[]): string[];
@@ -142,13 +280,15 @@ export interface SolidTagRuntime {
   defineModule(id: string, namespace: ModuleNamespaceLike | Function): string;
   defineUrl(id: string, url: string): string;
   import(id: string): Promise<ModuleNamespaceLike>;
-  compile(id: string): Promise<CompileResult>;
+  /** Returns the current linked/executable representation; cache controls affect compiler artifact lookup only. */
+  compile(id: string, options?: CompileOptions): Promise<CompileResult>;
   toModule(source: string, options?: ToModuleOptions): Promise<ModuleNamespaceLike>;
   toComponent<T extends Function = Function>(source: string, options?: ToComponentOptions): Promise<T>;
   has(id: string): boolean;
-  invalidate(id: string, options?: { dependents?: boolean }): string[];
+  invalidate(id: string, options?: InvalidateOptions): string[];
   remove(id: string, options?: RemoveModuleOptions): boolean;
   clear(options?: ClearRuntimeOptions): string[];
+  readonly compileCache: RuntimeCompileCache;
   subscribe(listener: (event: RuntimeLifecycleEvent) => void): () => boolean;
   subscribe<T extends RuntimeLifecycleEventType>(
     type: T,
@@ -173,6 +313,22 @@ export declare function createSolidTagCompiler(options?: {
   transformOptions?: Record<string, unknown>;
 }): RuntimeCompiler;
 
+export declare function createMemoryCompileCache(options?: {
+  records?: Map<string, CachedCompileRecord>;
+}): CompileCacheStore;
+
+export declare function createLocalStorageCompileCache(options?: {
+  storage?: LocalStorageLike;
+  prefix?: string;
+}): CompileCacheStore;
+
+export declare function createIndexedDBCompileCache(options?: {
+  database?: string;
+  storeName?: string;
+  databaseVersion?: number;
+  indexedDB?: IndexedDBFactoryLike;
+}): CompileCacheStore;
+
 export declare function createDefaultModuleUrlBackend(): ModuleUrlBackend;
 export declare function createBlobModuleUrlBackend(): ModuleUrlBackend;
 export declare function createDataModuleUrlBackend(): ModuleUrlBackend;