@zerotal/inertia 1.0.0

package/src/provider/InertiaProvider.ts

@@ -0,0 +1,154 @@
+import { ServiceProvider, Router, ConfigError, ThrottleMiddleware } from "@zerotal/core";
+import { registerDevBuildHook, pruneBuildOutput, DEV_RELOAD_CLIENT } from "@zerotal/core/dev";
+import type { AppEnvironment } from "@zerotal/core";
+import type { ConfigManager } from "@zerotal/core/config";
+import { _setHtmlTemplate, _setPagesDir } from "../inertia.ts";
+import { DEFAULT_PAGES_DIR } from "../config.ts";
+import { setAssetVersion } from "../version.ts";
+import { setHistoryEncryptionDefault } from "../historyState.ts";
+import { generatePageRegistry } from "../PageRegistry.ts";
+import { SsrHandler } from "../SsrHandler.ts";
+import { detectCssPlugins } from "../css.ts";
+import { detectVuePlugin, registerVueRuntimeLoader } from "../vuePlugin.ts";
+import { InertiaMiddleware } from "../middleware/InertiaMiddleware.ts";
+import { inertiaRoute } from "../route.ts";
+
+export class InertiaProvider extends ServiceProvider {
+  static override environments: AppEnvironment[] = ["web", "console", "test"];
+
+  override onRegister(): void {
+    // Make Router.inertia() available before routes load.
+    Router.macro("inertia", inertiaRoute);
+  }
+
+  override async onBooting(): Promise<void> {
+    this.app.useOnce(InertiaMiddleware as never);
+
+    const config = this.app.container.makeSync("config") as ConfigManager;
+
+    // 1. Load HTML template into memory — one disk read at boot, never per-request
+    const templatePath = config.get<string>(
+      "inertia.htmlTemplate",
+      `${process.cwd()}/resources/app.html`,
+    );
+
+    try {
+      let html = await Bun.file(templatePath).text();
+
+      // In dev-worker mode bake the live-reload client into the cached template.
+      // DevReloadMiddleware would inject it for us, but only by buffering the
+      // response body — and Inertia.stream() exists precisely to avoid that. The
+      // middleware skips any page that already embeds a /__dev/ws client, so the
+      // two never double-inject.
+      if (process.argv.includes("--dev-worker")) {
+        html = html.replace("</body>", DEV_RELOAD_CLIENT + "\n</body>");
+      }
+
+      _setHtmlTemplate(html);
+    } catch {
+      // Template not found — warn in development, throw in production
+      const isDev = config.get<string>("app.env", "production") !== "production";
+      if (!isDev) {
+        throw new ConfigError(
+          `[Zerotal Inertia] HTML template not found at: ${templatePath}\n` +
+            `Create the template there, then run \`bun zt inertia:build\` to generate the page registry ` +
+            `(scaffold new pages with \`bun zt make:page\`).`,
+        );
+      }
+      console.warn(
+        `[Zerotal Inertia] HTML template not found at: ${templatePath}. ` +
+          `Using empty fallback for development.`,
+      );
+      _setHtmlTemplate(_defaultHtmlTemplate());
+    }
+
+    // 2. Set asset version (used for 409 cache-busting)
+    const version = config.get<string>("inertia.version", "1");
+    setAssetVersion(version);
+
+    // 2a. Resolve the pages directory (used by SSR / inertiaStream to load
+    // components from disk). Configurable via `inertia.pagesDir`.
+    const pagesDir = config.get<string>("inertia.pagesDir", DEFAULT_PAGES_DIR);
+    _setPagesDir(`${process.cwd()}/${pagesDir}`);
+
+    // 2b. History-encryption default (per-request overrides via Inertia.encryptHistory()).
+    setHistoryEncryptionDefault(config.get<boolean>("inertia.encryptHistory", false));
+
+    // 2c. Register the .vue runtime loader so server-side `import('*.vue')`
+    // works for SSR and Inertia.stream(). No-op unless @vue/compiler-sfc is
+    // installed, so React apps are unaffected.
+    await registerVueRuntimeLoader(process.cwd());
+
+    // 3. Register SSR endpoint when enabled
+    if (config.get<boolean>("inertia.ssr", false)) {
+      // Throttled as well as loopback-gated: rendering a page is real CPU, and this route
+      // sits outside every application guard.
+      Router.post(
+        "/__ssr",
+        SsrHandler as unknown as new (...args: unknown[]) => unknown,
+        "handle",
+        [ThrottleMiddleware.with({ maxAttempts: 120, windowSeconds: 60 })],
+      );
+    }
+  }
+
+  override async onBooted(): Promise<void> {
+    // Register the dev build hook so DevOrchestrator (in @zerotal/core) can
+    // trigger a full pages-manifest sync + asset rebuild without @zerotal/core
+    // importing @zerotal/inertia (which would create a circular dependency).
+    const cwd = process.cwd();
+    registerDevBuildHook("inertia", async () => {
+      await generatePageRegistry(cwd);
+      const plugins = [...(await detectCssPlugins(cwd)), ...(await detectVuePlugin(cwd))];
+      const outdir = `${cwd}/public/assets`;
+      const result = await Bun.build({
+        entrypoints: [`${cwd}/resources/js/app.tsx`],
+        outdir,
+        target: "browser",
+        splitting: true,
+        minify: false,
+        sourcemap: "external",
+        ...(plugins.length > 0 ? { plugins } : {}),
+      });
+
+      // Each rebuild renames every split chunk, so without this the directory
+      // collects a full set of dead chunks per edit for the whole session.
+      if (result.success) await pruneBuildOutput(outdir, result.outputs);
+      return result;
+    });
+
+    // Register CLI commands when in console mode
+    const runner = this.app.container.tryMake("commands");
+    if (!runner) return;
+
+    (runner as { registerLazy(name: string, thunk: () => Promise<unknown>): void }).registerLazy(
+      "inertia:build",
+      () =>
+        import("../commands/InertiaBuildCommand.ts").then(
+          (m) => (m as { InertiaBuildCommand: unknown }).InertiaBuildCommand,
+        ),
+    );
+    (runner as { registerLazy(name: string, thunk: () => Promise<unknown>): void }).registerLazy(
+      "make:page",
+      () =>
+        import("../commands/MakePageCommand.ts").then(
+          (m) => (m as { MakePageCommand: unknown }).MakePageCommand,
+        ),
+    );
+  }
+}
+
+// Used as fallback when resources/app.html does not exist yet
+function _defaultHtmlTemplate(): string {
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Zerotal App</title>
+  </head>
+  <body>
+    <!-- @inertia -->
+  </body>
+</html>`;
+}

package/src/route.ts

@@ -0,0 +1,47 @@
+import { Router } from "@zerotal/core";
+import type { MiddlewareClass, RouteRegistration } from "@zerotal/core";
+import { inertia } from "./inertia.ts";
+
+/**
+ * Register a GET route that renders an Inertia page directly — no controller
+ * needed for controller-less pages.
+ *
+ * Useful for static/simple pages (about, dashboards) that need no controller logic —
+ * the generated handler just calls {@link inertia} with the given component and props.
+ *
+ * @param path - The URL path to register (GET).
+ * @param component - The page component name/path (relative to the pages dir, no extension).
+ * @param props - Static props object, **or** a middleware array as a shorthand (when it's an array it's treated as middleware, not props).
+ * @param middleware - Middleware to apply (ignored when `props` is used as the middleware-array shorthand).
+ * @returns The route registration from the underlying `Router.get`.
+ *
+ * @example
+ * ```ts
+ * Router.inertia('/about', 'About/Index');
+ * Router.inertia('/home',  'Home/Index', { greeting: 'Hello' });
+ * Router.inertia('/admin', 'Admin/Dashboard', [AuthMiddleware]);
+ * ```
+ */
+export function inertiaRoute(
+  path: string,
+  component: string,
+  props?: Record<string, unknown> | MiddlewareClass[],
+  middleware: MiddlewareClass[] = [],
+): RouteRegistration {
+  let resolvedProps: Record<string, unknown> = {};
+  let resolvedMiddleware: MiddlewareClass[] = middleware;
+
+  if (Array.isArray(props)) {
+    resolvedMiddleware = props; // shorthand: Router.inertia('/x', 'X', [AuthMiddleware])
+  } else if (props) {
+    resolvedProps = props;
+  }
+
+  const handler = class InertiaRouteHandler {
+    async handle(): Promise<void> {
+      await inertia(component, resolvedProps);
+    }
+  };
+
+  return Router.get(path, handler, "handle", resolvedMiddleware);
+}

package/src/share.ts

@@ -0,0 +1,65 @@
+/**
+ * App-registered shared props (`Inertia.share(...)`).
+ *
+ * Registered once (typically in a provider's boot or middleware) and merged into every page's
+ * props by {@link sharedProps}. Values may be plain values, factory functions (evaluated lazily per
+ * request), or prop wrappers — the resolver handles each.
+ */
+const _shared = new Map<string, unknown>();
+
+/** The always-present built-in shared keys. */
+const BUILTIN_SHARED_KEYS = ["auth", "flash", "errors", "old"] as const;
+
+/**
+ * Register shared prop(s) that Zerotal includes on **every** Inertia page, so page
+ * components can read them without each controller passing them explicitly.
+ *
+ * @remarks
+ * Call once at boot (typically in a service provider) — a later `share()` of the
+ * same key overwrites the previous value. Values may be plain data, a factory
+ * function (re-evaluated lazily per request, e.g. to read the current user), or a
+ * prop wrapper. The built-in shared keys (`auth`, `flash`, `errors`, `old`) are
+ * always present in addition to whatever you register here; see {@link sharedProps}.
+ *
+ * Two call styles: a single `key`/`value` pair, or an object of many at once.
+ *
+ * @param key - The shared prop name (single-key overload) — or, in the object overload, the map of names to values.
+ * @param value - The value for `key` (single-key overload only); a plain value, a per-request factory, or a prop wrapper.
+ *
+ * @example
+ * ```ts
+ * // In a service provider's boot() — available on every page (auth/flash/errors/old
+ * // are already built in; register your own extras here).
+ * Inertia.share({
+ *   appName: 'Acme',
+ *   permissions: () => Auth.user()?.permissions ?? [],  // factory re-runs each request
+ * });
+ *
+ * // Or a single key:
+ * Inertia.share('year', () => new Date().getFullYear());
+ * ```
+ */
+export function share(key: string, value: unknown): void;
+export function share(values: Record<string, unknown>): void;
+export function share(keyOrValues: string | Record<string, unknown>, value?: unknown): void {
+  if (typeof keyOrValues === "string") {
+    _shared.set(keyOrValues, value);
+  } else {
+    for (const [k, v] of Object.entries(keyOrValues)) _shared.set(k, v);
+  }
+}
+
+/** @internal The raw registered shared map (factories/wrappers left unresolved for the resolver). */
+export function registeredShared(): Record<string, unknown> {
+  return Object.fromEntries(_shared);
+}
+
+/** @internal All shared prop keys (built-ins + registered), for the page object's `sharedProps`. */
+export function allSharedKeys(): string[] {
+  return [...BUILTIN_SHARED_KEYS, ..._shared.keys()];
+}
+
+/** @internal Clear registered shared props (tests). */
+export function flushShared(): void {
+  _shared.clear();
+}

package/src/ssr/renderPage.ts

@@ -0,0 +1,114 @@
+/**
+ * Framework-aware server-side rendering for Inertia pages.
+ *
+ * Inertia's SSR contract is `{ component, props, url } → { head, body }`. Pages
+ * may be authored as React `.tsx` or Vue `.vue` components, so this module
+ * detects the framework from the page file on disk and renders with the matching
+ * runtime — React via `react-dom/server`, Vue via `@inertiajs/vue3`'s SSR mode +
+ * `vue/server-renderer`.
+ *
+ * Every framework runtime is resolved from the *app's* node_modules (not
+ * @zerotal/inertia's), so an app only needs the libraries for the framework it
+ * actually uses. Vue `.vue` files additionally require the `.vue` runtime loader
+ * registered by InertiaProvider (see `registerVueRuntimeLoader`).
+ */
+
+export type Framework = "vue" | "react";
+
+export interface SsrPage {
+  component: string;
+  props: Record<string, unknown>;
+  url: string;
+}
+
+export interface SsrResult {
+  head: string[];
+  body: string;
+}
+
+/**
+ * Resolve a page component's module path and which frontend framework it targets,
+ * preferring a `.vue` SFC when present and falling back to `.tsx`.
+ *
+ * @param pagesDir - Absolute path to the pages directory.
+ * @param component - Page component name/path (no extension).
+ * @returns The absolute module path and its detected {@link Framework}.
+ * @internal
+ */
+export async function resolvePageModule(
+  pagesDir: string,
+  component: string,
+): Promise<{ modPath: string; framework: Framework }> {
+  const vuePath = `${pagesDir}/${component}.vue`;
+  if (await Bun.file(vuePath).exists()) {
+    return { modPath: vuePath, framework: "vue" };
+  }
+  return { modPath: `${pagesDir}/${component}.tsx`, framework: "react" };
+}
+
+/**
+ * Render an Inertia page to an HTML body string + head tags on the server.
+ * `modPath` is an absolute path to the page module; `framework` selects the
+ * rendering runtime (use {@link resolvePageModule} to derive both).
+ *
+ * @param page - The `{ component, props, url }` page to render.
+ * @param modPath - Absolute path to the page component module.
+ * @param framework - Which runtime to render with (`"vue"` or `"react"`).
+ * @returns The rendered `{ head, body }` HTML.
+ * @internal
+ */
+export async function renderInertiaPage(
+  page: SsrPage,
+  modPath: string,
+  framework: Framework,
+): Promise<SsrResult> {
+  if (framework === "vue") return _renderVue(page, modPath);
+  return _renderReact(page, modPath);
+}
+
+async function _renderVue(page: SsrPage, modPath: string): Promise<SsrResult> {
+  const cwd = process.cwd();
+
+  // Resolve Vue + the Inertia Vue adapter from the app's install.
+  const [inertiaVue, serverRenderer, vue, pageMod] = await Promise.all([
+    import(Bun.resolveSync("@inertiajs/vue3", cwd)) as Promise<{
+      createInertiaApp: (options: Record<string, unknown>) => Promise<SsrResult>;
+    }>,
+    import(Bun.resolveSync("vue/server-renderer", cwd)) as Promise<{
+      renderToString: (app: unknown) => Promise<string>;
+    }>,
+    import(Bun.resolveSync("vue", cwd)) as Promise<{
+      createSSRApp: (options: unknown) => { use: (plugin: unknown) => unknown };
+      h: (type: unknown, props: unknown) => unknown;
+    }>,
+    import(modPath) as Promise<{ default: unknown }>,
+  ]);
+
+  const { createSSRApp, h } = vue;
+
+  const result = await inertiaVue.createInertiaApp({
+    page,
+    render: (app: unknown) => serverRenderer.renderToString(app),
+    resolve: () => pageMod.default,
+    setup({ App, props, plugin }: { App: unknown; props: unknown; plugin: unknown }) {
+      return createSSRApp({ render: () => h(App, props) }).use(plugin);
+    },
+  });
+
+  return { head: result.head ?? [], body: result.body };
+}
+
+async function _renderReact(page: SsrPage, modPath: string): Promise<SsrResult> {
+  const pageMod = (await import(modPath)) as { default: unknown };
+  if (typeof pageMod.default !== "function") {
+    throw new Error(`SSR component "${page.component}" has no default export`);
+  }
+
+  const [reactMod, serverMod] = await Promise.all([
+    import("react") as Promise<{ createElement: (type: unknown, props: unknown) => unknown }>,
+    import("react-dom/server") as Promise<{ renderToString: (element: unknown) => string }>,
+  ]);
+
+  const element = reactMod.createElement(pageMod.default, { ...page.props, url: page.url });
+  return { head: [], body: serverMod.renderToString(element) };
+}

package/src/types.ts

@@ -0,0 +1,53 @@
+/**
+ * The Inertia "page object" — the serialisable payload that describes a page.
+ *
+ * On a first load it is embedded into the HTML shell's `data-page` script; on
+ * subsequent visits it is the JSON response body. The Inertia client reads it to
+ * mount/swap the page component and to drive partial-reload, merge, defer, once, and
+ * history behaviour. Built by {@link buildPageObject}; the optional fields are only
+ * present when the corresponding prop feature is in use.
+ */
+export interface PageObject {
+  /** Page component name/path (relative to the pages dir, no extension), e.g. `"Users/Index"`. */
+  component: string;
+  /** The resolved props for the page. */
+  props: Record<string, unknown>;
+  /** The request URL (pathname + query) this page was rendered for. */
+  url: string;
+  /** Asset version; a mismatch triggers a full reload so the client picks up new assets. */
+  version: string;
+  /** Encrypt this page's history state in the browser (only set when true). */
+  encryptHistory?: boolean;
+  /** Clear any previously encrypted history state (only set when true). */
+  clearHistory?: boolean;
+  /** Preserve the URL fragment across a redirect. */
+  preserveFragment?: boolean;
+  /** Prop keys (or `key.path`) the client should append-merge instead of replacing. */
+  mergeProps?: string[];
+  /** Prop keys (or `key.path`) the client should prepend-merge. */
+  prependProps?: string[];
+  /** Prop keys (or `key.path`) the client should deep-merge. */
+  deepMergeProps?: string[];
+  /** `key.path` entries whose last segment is the field used to match items when merging. */
+  matchPropsOn?: string[];
+  /** Infinite-scroll pagination config, keyed by prop name. */
+  scrollProps?: Record<string, unknown>;
+  /** Deferred props grouped by request group; the client fetches them after first render. */
+  deferredProps?: Record<string, string[]>;
+  /** Deferred prop keys that threw and were rescued server-side. */
+  rescuedProps?: string[];
+  /** Once props, keyed by once-key → { prop, expiresAt }. */
+  onceProps?: Record<string, { prop: string; expiresAt: number | null }>;
+  /** Top-level shared prop keys, for instant-visit carry-over. */
+  sharedProps?: string[];
+}
+
+/** Options passed to `InertiaProvider` to configure the adapter at boot. */
+export interface InertiaProviderOptions {
+  /** Path to the HTML template. Default: 'resources/app.html' */
+  htmlTemplate?: string;
+  /** Current asset version string. Used for cache-busting (409 responses). */
+  version?: string;
+  /** Public URL prefix for built assets. Default: '/assets' */
+  assetsUrl?: string;
+}

package/src/version.ts

@@ -0,0 +1,22 @@
+let _version = "";
+
+/**
+ * Set the current asset version. Called by InertiaProvider during onBooting().
+ *
+ * @param v - The asset version string (from `inertia.version` config).
+ * @internal
+ */
+export function setAssetVersion(v: string): void {
+  _version = v;
+}
+
+/**
+ * Returns the current asset version.
+ * Used in every PageObject response so the client can detect
+ * asset changes and trigger a full reload (409 Conflict response).
+ *
+ * @returns The asset version string (empty until set at boot).
+ */
+export function assetVersion(): string {
+  return _version;
+}

package/src/vuePlugin.ts

@@ -0,0 +1,144 @@
+/**
+ * Vue Single-File Component (`.vue`) support for Inertia's Bun.build() pipeline.
+ *
+ * Bun's bundler has no native `.vue` loader, so this module compiles SFCs with
+ * `@vue/compiler-sfc` inside a Bun plugin. The compiler is resolved from the
+ * *app's* node_modules (not @zerotal/inertia's), exactly like the Tailwind CSS
+ * plugin — so React apps that never install it are completely unaffected.
+ *
+ * `detectVuePlugin()` returns an empty array when `@vue/compiler-sfc` is not
+ * installed, making `.vue` support fully opt-in.
+ */
+import type { BunPlugin } from "bun";
+
+// Minimal structural type for the slice of @vue/compiler-sfc we use. Imported
+// dynamically from the app's install, so we avoid a hard dependency here.
+interface SfcCompiler {
+  parse(
+    source: string,
+    options: { filename: string },
+  ): { descriptor: SfcDescriptor; errors: unknown[] };
+  compileScript(
+    descriptor: SfcDescriptor,
+    options: Record<string, unknown>,
+  ): { content: string; bindings?: unknown };
+  compileTemplate(options: Record<string, unknown>): { code: string; errors: unknown[] };
+  compileStyle(options: Record<string, unknown>): { code: string };
+  rewriteDefault(input: string, as: string): string;
+}
+
+interface SfcDescriptor {
+  scriptSetup: unknown | null;
+  script: { content: string } | null;
+  template: { content: string } | null;
+  styles: { content: string; scoped: boolean }[];
+  slotted: boolean;
+}
+
+/**
+ * Resolve `@vue/compiler-sfc` from `cwd` and return a Bun plugin that compiles
+ * `.vue` files. Returns `[]` when the compiler is not installed.
+ */
+export async function detectVuePlugin(cwd: string): Promise<BunPlugin[]> {
+  let compilerPath: string;
+  try {
+    compilerPath = Bun.resolveSync("@vue/compiler-sfc", cwd);
+  } catch {
+    return [];
+  }
+  const sfc = (await import(compilerPath)) as unknown as SfcCompiler;
+  return [vueSfcPlugin(sfc)];
+}
+
+let _runtimeLoaderRegistered = false;
+
+/**
+ * Register the `.vue` compiler as a *runtime* Bun loader so server-side
+ * `import('*.vue')` works (used by SSR and `Inertia.stream()`). Build-time
+ * plugins only affect `Bun.build`, not the runtime module loader.
+ *
+ * No-op (and harmless) when `@vue/compiler-sfc` is not installed, and safe to
+ * call more than once — only the first call registers.
+ */
+export async function registerVueRuntimeLoader(cwd: string): Promise<void> {
+  if (_runtimeLoaderRegistered) return;
+  const plugins = await detectVuePlugin(cwd);
+  if (plugins.length === 0) return;
+  for (const plugin of plugins) Bun.plugin(plugin);
+  _runtimeLoaderRegistered = true;
+}
+
+function vueSfcPlugin(sfc: SfcCompiler): BunPlugin {
+  return {
+    name: "zerotal-vue-sfc",
+    setup(build) {
+      build.onLoad({ filter: /\.vue$/ }, async (args) => {
+        const source = await Bun.file(args.path).text();
+        const { descriptor, errors } = sfc.parse(source, { filename: args.path });
+        if (errors.length > 0) {
+          throw new Error(`[Zerotal Vue] Failed to parse ${args.path}:\n${errors.join("\n")}`);
+        }
+
+        // Stable per-file id used for scoped-style hashing (data-v-<id>).
+        const id = Bun.hash(args.path).toString(16).slice(0, 8);
+        const hasScoped = descriptor.styles.some((s) => s.scoped);
+
+        let code: string;
+
+        if (descriptor.scriptSetup) {
+          // `<script setup>`: inline the template render fn straight into setup().
+          const script = sfc.compileScript(descriptor, {
+            id,
+            inlineTemplate: true,
+            templateOptions: hasScoped ? { id, scoped: true } : { id },
+          });
+          code = script.content; // already contains `export default ...`
+        } else {
+          // Plain `<script>` (or none) + separate template compile.
+          const scriptContent = descriptor.script
+            ? sfc.compileScript(descriptor, { id }).content
+            : "export default {}";
+          code = sfc.rewriteDefault(scriptContent, "__sfc_main__");
+
+          if (descriptor.template) {
+            const tpl = sfc.compileTemplate({
+              source: descriptor.template.content,
+              filename: args.path,
+              id,
+              scoped: hasScoped,
+              slotted: descriptor.slotted,
+              compilerOptions: { bindingMetadata: sfc.compileScript(descriptor, { id }).bindings },
+            });
+            if (tpl.errors.length > 0) {
+              throw new Error(
+                `[Zerotal Vue] Template error in ${args.path}:\n${tpl.errors.join("\n")}`,
+              );
+            }
+            code += `\n${tpl.code}\n__sfc_main__.render = render;`;
+          }
+          code += "\nexport default __sfc_main__;";
+        }
+
+        if (hasScoped) {
+          code += `\nif (typeof __sfc_main__ !== 'undefined') __sfc_main__.__scopeId = ${JSON.stringify(`data-v-${id}`)};`;
+        }
+
+        // Compile and runtime-inject any <style> blocks (Tailwind apps have none).
+        if (descriptor.styles.length > 0) {
+          let css = "";
+          for (const style of descriptor.styles) {
+            css += sfc.compileStyle({
+              source: style.content,
+              filename: args.path,
+              id: `data-v-${id}`,
+              scoped: style.scoped,
+            }).code;
+          }
+          code += `\n(function(){if(typeof document!=='undefined'){var s=document.createElement('style');s.setAttribute('data-vue-id',${JSON.stringify(id)});s.textContent=${JSON.stringify(css)};document.head.appendChild(s);}})();`;
+        }
+
+        return { contents: code, loader: "ts" };
+      });
+    },
+  };
+}