ignotum 0.0.13 → 0.0.15

package/src/cli/dev.ts

@@ -1,26 +1,37 @@
+import { fileURLToPath } from "node:url";
 import prefresh from "@prefresh/vite";
 import tailwindcss from "@tailwindcss/vite";
-import { Effect, FileSystem, Path, Schema } from "effect";
-import { createServer } from "vite";
-import type { ViteDevServer } from "vite";
-
-import { generate } from "./codegen.js";
+import { Crypto, Effect, FileSystem, Option, Path, Schema, Scope } from "effect";
+import { createServer, normalizePath, type Plugin, type ViteDevServer } from "vite";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { ExecutionSelection, RuntimeRequirements } from "@ignotum/contracts/platform";
+import { managedSelectionPath } from "@ignotum/contracts/managed-sync";
+import { renderDocument } from "@ignotum/shared/document";
+import { compilePatterns, matchLocation, resolveMetadata } from "@ignotum/shared/routing";
+import { sha256 } from "@ignotum/versions";
+import { InvalidClientFile } from "./client-config.js";
+import { clientStylesSource } from "./client-styles.js";
+import { generateClientRoutes, type ClientRouteDiscovery } from "./route-codegen.js";
+import { createImageAssetsPlugin } from "./image-assets.js";
+import { managedClientBoundariesPlugin } from "./managed-client-boundaries.js";
+import { moduleBoundariesPlugin } from "./module-boundaries.js";
+import { managedBrowserExports, managedPreactPeerPlugin } from "./managed-exports.js";
+import { localManagedReleaseProvider } from "./managed-release.js";
 import {
-  resolveClientBuildConfig,
-  validateClientFiles,
-  type ClientFiles,
-} from "./client-config.js";
-import { loadClientEntryTitle } from "./client-entry.js";
-import { ignotumClientPlugin } from "./client-plugin.js";
+  buildLocalBrowserTools,
+  localExecutionSelection,
+  localPlatformRelease,
+  localPlatformUrl,
+  type LocalManagedRelease,
+} from "./managed-dev-platform.js";
 import { acquireDevDatabaseLock, devDatabasePath } from "../dev-runtime/dev-database.js";
-import { ignotumSyncPlugin } from "../dev-runtime/sync.js";
-
+import { ignotumManagedSyncPlugin } from "../dev-runtime/sync.js";
+import { createManagedFunctionLoader } from "../dev-runtime/managed-functions.js";
+import { buildManagedServer } from "./build/server.js";
+import { generate } from "./codegen.js";
 export class ViteStartupFailed extends Schema.TaggedError<ViteStartupFailed>()(
   "ViteStartupFailed",
-  {
-    cause: Schema.Defect(),
-    message: Schema.String,
-  },
+  { cause: Schema.Defect(), message: Schema.String },
 ) {}
 
 export interface DevOptions {
@@ -30,111 +41,499 @@ export interface DevOptions {
   readonly appDirectory: string;
 }
 
-const acquireViteServer = Effect.fn("Dev.acquireViteServer")(function* (
-  options: DevOptions,
-  clientFiles: ClientFiles,
+const registrationId = "virtual:ignotum/dev-registration";
+const stylesId = "virtual:ignotum/dev-styles.css";
+const moduleUrl = (id: string) => `/@id/__x00__${id}`;
+const toolingPrefix = "/_ignotum/development/tools/";
+
+export interface ManagedDevOptions extends DevOptions {
+  readonly applicationName?: string;
+  readonly sdkDirectory?: string;
+  readonly provider?: LocalManagedRelease;
+}
+
+export const renderDevRegistration = (discovery: ClientRouteDiscovery, applicationName: string) => `
+import { mountClient } from "ignotum/internal/bootstrap";
+import ${JSON.stringify(`${toolingPrefix}debug.js`)};
+import ${JSON.stringify(stylesId)};
+const registration = {
+  applicationName: ${JSON.stringify(applicationName)},
+  routes: ${JSON.stringify(discovery.routes)},
+  layouts: ${JSON.stringify(discovery.layouts)},
+  modules: new Map([${discovery.modules.map((module) => `[${JSON.stringify(module.id)}, { load: () => import(${JSON.stringify(`/@fs/${normalizePath(module.path)}`)}) }]`).join(",\n")}]),
+};
+let mounted;
+export default function mount(selection) {
+  import.meta.hot.data.selection = selection;
+  mounted?.dispose();
+  mounted = mountClient(registration, selection);
+  return mounted;
+}
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  import.meta.hot.dispose(() => mounted?.dispose());
+  if (import.meta.hot.data.selection) mount(import.meta.hot.data.selection);
+}
+`;
+
+/** Internal assembly until all CLI producers switch together. The caller owns its Effect scope. */
+export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(function* (
+  options: ManagedDevOptions,
 ) {
-  const fileSystem = yield* FileSystem.FileSystem;
+  const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const runPromise = Effect.runPromiseWith(yield* Effect.context<never>());
-  const clientConfig = yield* resolveClientBuildConfig(true);
-  const clientDirectory = clientFiles.clientDirectory;
-  const databasePath = yield* devDatabasePath(options.appDirectory);
-  const stateDirectory = path.dirname(databasePath);
-  yield* fileSystem.makeDirectory(stateDirectory, { recursive: true });
-
-  return yield* Effect.acquireRelease(
-    Effect.tryPromise({
-      try: () =>
-        prefresh().then((prefreshPlugin) =>
-          createServer({
-            appType: "spa",
-            configFile: false,
-            mode: "development",
-            root: clientDirectory,
-            plugins: [
-              ignotumSyncPlugin(options.appDirectory, databasePath),
-              ignotumClientPlugin({
-                development: true,
-                icon: clientFiles.iconPath === undefined ? undefined : "/icon.svg",
-                loadTitle: () =>
-                  runPromise(
-                    loadClientEntryTitle(clientFiles.entryPath).pipe(
-                      Effect.provideService(FileSystem.FileSystem, fileSystem),
-                    ),
-                  ),
-              }),
-              prefreshPlugin,
-              tailwindcss(),
-            ],
-            oxc: {
-              jsx: {
-                importSource: "ignotum/client",
-                runtime: "automatic",
-              },
-            },
-            optimizeDeps: {
-              include: [
-                "preact",
-                "preact/hooks",
-                "preact/jsx-runtime",
-                "ignotum/client",
-                "ignotum/client/jsx-dev-runtime",
-              ],
-            },
-            resolve: {
-              alias: clientConfig.aliases,
-              conditions: [...clientConfig.conditions],
-              dedupe: ["preact", "preact/hooks"],
-              tsconfigPaths: true,
+  const appDirectory = yield* fs.realPath(options.appDirectory);
+  const appName = options.applicationName ?? path.basename(appDirectory);
+  const clientDirectory = path.join(appDirectory, "client");
+  const sdkDirectory = options.sdkDirectory ?? fileURLToPath(new URL("../../", import.meta.url));
+  const validateFiles = Effect.fn("ManagedDev.validateFiles")(function* () {
+    for (const publicPath of [
+      path.join(appDirectory, "public"),
+      path.join(clientDirectory, "public"),
+    ]) {
+      if (
+        (yield* fs.exists(publicPath)) ||
+        Option.isSome(yield* Effect.option(fs.readLink(publicPath)))
+      )
+        return yield* InvalidClientFile.make({
+          path: publicPath,
+          message:
+            "App public directories are not supported. Import supported images from client/_assets instead.",
+        });
+    }
+    const iconPath = path.join(clientDirectory, "icon.svg");
+    if (!(yield* fs.exists(iconPath))) return undefined;
+    if ((yield* fs.stat(iconPath)).type !== "File")
+      return yield* InvalidClientFile.make({
+        path: iconPath,
+        message: "The client icon must be a regular file.",
+      });
+    const bytes = yield* fs.readFile(iconPath);
+    return { bytes, url: `/_ignotum/assets/${yield* sha256(bytes)}/icon.svg` };
+  });
+  let icon = yield* validateFiles();
+  let discovery = yield* generateClientRoutes(appDirectory);
+  let patterns = yield* compilePatterns(discovery.routes, discovery.layouts);
+  let provider = options.provider ?? (yield* localManagedReleaseProvider(sdkDirectory));
+  let selection = localExecutionSelection(appDirectory, provider);
+  let tools = yield* buildLocalBrowserTools(provider, selection);
+  const runPromise = Effect.runPromiseWith(
+    yield* Effect.context<
+      | FileSystem.FileSystem
+      | Path.Path
+      | Crypto.Crypto
+      | Scope.Scope
+      | ChildProcessSpawner.ChildProcessSpawner
+    >(),
+  );
+  let diagnostic: unknown;
+  let serverDiagnostic: unknown;
+  let serverWork = Promise.resolve();
+  let viteServer: ViteDevServer | undefined;
+  let work = Promise.resolve();
+  const images = yield* createImageAssetsPlugin(appDirectory);
+  const boundaries = yield* moduleBoundariesPlugin("Client", appDirectory);
+  const platform = yield* managedClientBoundariesPlugin(appDirectory);
+  const peers = yield* managedPreactPeerPlugin({ resolvePeer: (specifier) => specifier });
+  // These checks run before the resolver turns supported externals into selected graph URLs.
+  const originalPlatformResolve = platform.resolveId;
+  platform.resolveId = function (specifier, importer) {
+    if (importer === `\0${registrationId}` && specifier === "ignotum/internal/bootstrap")
+      return {
+        id: localPlatformUrl(selection.platformReleaseId, provider.resolve("Browser", specifier)!),
+        external: true as const,
+      };
+    const resolved = originalPlatformResolve.call(this, specifier, importer);
+    if (resolved !== undefined && resolved.external) {
+      const module = provider.resolve("Browser", specifier);
+      if (module === undefined) this.error(`The local platform does not supply ${specifier}.`);
+      return { id: localPlatformUrl(selection.platformReleaseId, module), external: true as const };
+    }
+    return resolved;
+  };
+  const originalPeerResolve = peers.resolveId;
+  peers.resolveId = async function (specifier, importer) {
+    const resolved = await originalPeerResolve.call(this, specifier, importer);
+    return resolved === undefined
+      ? undefined
+      : {
+          id: localPlatformUrl(
+            selection.platformReleaseId,
+            provider.resolve("Browser", specifier)!,
+          ),
+          external: true as const,
+        };
+  };
+  const databasePath = yield* devDatabasePath(appDirectory);
+  yield* fs.makeDirectory(path.dirname(databasePath), { recursive: true });
+  yield* acquireDevDatabaseLock(appDirectory);
+  let loader = yield* createManagedFunctionLoader(appDirectory, {
+    guest: provider.guest,
+    release: localPlatformRelease(provider, selection),
+    requirements: Schema.decodeUnknownSync(RuntimeRequirements)({
+      clientApiVersion: 1,
+      serverApiVersion: 1,
+      capabilities: ["operations", "routing", "images"],
+    }),
+  });
+  const compileServer = Effect.fn("ManagedDev.compileServer")(function* () {
+    const generated = yield* generate(appDirectory);
+    const build = yield* buildManagedServer(
+      appDirectory,
+      path.join(appDirectory, ".ignotum/dev/server"),
+      generated.functionModules,
+    );
+    yield* loader.reload(build);
+  });
+  yield* compileServer();
+  const sync = ignotumManagedSyncPlugin(appDirectory, databasePath, {
+    selection: () => selection,
+    isServerDependency: (file) => {
+      const relative = normalizePath(path.relative(appDirectory, file));
+      return (
+        !relative.startsWith("../") &&
+        !path.isAbsolute(relative) &&
+        !relative.startsWith("client/") &&
+        !relative.startsWith("_generated/") &&
+        !relative.startsWith(".ignotum/") &&
+        !relative.includes("node_modules/") &&
+        /\.(ts|tsx|js|mjs)$/.test(relative)
+      );
+    },
+    loadModule: async (filename) => {
+      await serverWork;
+      return loader.ssrLoadModule(filename);
+    },
+    beforeReload: () => {
+      const compile = () => runPromise(compileServer());
+      serverWork = serverWork.then(compile, compile).then(
+        () => {
+          const recovered = serverDiagnostic !== undefined;
+          serverDiagnostic = undefined;
+          if (recovered) viteServer?.ws.send({ type: "full-reload" });
+        },
+        (cause) => {
+          loader.invalidate(cause);
+          serverDiagnostic = cause;
+          viteServer?.ws.send({ type: "error", err: { message: String(cause), stack: "" } });
+          throw cause;
+        },
+      );
+      return serverWork;
+    },
+  });
+  const plugin: Plugin = {
+    name: "ignotum:managed-development",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === registrationId || id === stylesId) return `\0${id}`;
+      if (id === "@prefresh/core" || id === "@prefresh/utils")
+        return {
+          id: `${toolingPrefix}${id.slice("@prefresh/".length)}.js`,
+          external: true as const,
+        };
+      if (id.startsWith(toolingPrefix) || id.startsWith("/_ignotum/platform/"))
+        return { id, external: true as const };
+    },
+    load(id) {
+      if (id === `\0${registrationId}`) {
+        if (diagnostic !== undefined) throw diagnostic;
+        if (serverDiagnostic !== undefined) throw serverDiagnostic;
+        return renderDevRegistration(discovery, appName);
+      }
+      if (id === `\0${stylesId}`) return clientStylesSource;
+    },
+    configResolved(config) {
+      // Prefresh adds optimizer entries. Its tools are already compiled against the managed renderer.
+      config.optimizeDeps.include = [];
+      config.optimizeDeps.noDiscovery = true;
+      config.optimizeDeps.exclude = [
+        ...managedBrowserExports.map((entry) => entry.specifier),
+        "@prefresh/core",
+        "@prefresh/utils",
+      ];
+    },
+    configureServer(server) {
+      viteServer = server;
+      server.watcher.add([clientDirectory, path.join(appDirectory, "_shared")]);
+      const regenerate = async () => {
+        try {
+          const nextIcon = await runPromise(validateFiles());
+          const next = await runPromise(generateClientRoutes(appDirectory));
+          const nextPatterns = await runPromise(compilePatterns(next.routes, next.layouts));
+          const changed =
+            JSON.stringify({
+              routes: next.routes,
+              layouts: next.layouts,
+              modules: next.modules,
+              icon: nextIcon?.url,
+            }) !==
+            JSON.stringify({
+              routes: discovery.routes,
+              layouts: discovery.layouts,
+              modules: discovery.modules,
+              icon: icon?.url,
+            });
+          discovery = next;
+          patterns = nextPatterns;
+          icon = nextIcon;
+          const recovered = diagnostic !== undefined;
+          diagnostic = undefined;
+          server.watcher.add(discovery.dependencies);
+          if (changed || recovered) {
+            const module = server.moduleGraph.getModuleById(`\0${registrationId}`);
+            if (module !== undefined) await server.reloadModule(module);
+          }
+        } catch (error) {
+          diagnostic = error;
+          server.ws.send({
+            type: "error",
+            err: {
+              message: String(error),
+              stack: error instanceof Error ? (error.stack ?? "") : "",
             },
-            server: {
-              forwardConsole: {
-                logLevels: ["warn", "error"],
-                unhandledErrors: true,
+          });
+        }
+      };
+      const onChange = (file: string) => {
+        const relative = normalizePath(path.relative(appDirectory, file));
+        if (
+          relative.startsWith("_generated/") ||
+          relative.startsWith(".ignotum/") ||
+          relative.includes("node_modules/")
+        )
+          return;
+        work = work.then(regenerate);
+      };
+      server.watcher.on("addDir", onChange);
+      server.watcher.on("unlinkDir", onChange);
+      server.watcher.on("add", onChange);
+      server.watcher.on("unlink", onChange);
+      server.watcher.on("change", onChange);
+      server.httpServer?.once("close", () => {
+        server.watcher.off("addDir", onChange);
+        server.watcher.off("unlinkDir", onChange);
+        server.watcher.off("add", onChange);
+        server.watcher.off("unlink", onChange);
+        server.watcher.off("change", onChange);
+      });
+      server.middlewares.use((request, response, next) => {
+        const url = new URL(
+          request.url ?? "/",
+          `http://${request.headers.host ?? "ignotum.local"}`,
+        );
+        const send = (body: string | Uint8Array, contentType: string, immutable = false) => {
+          response.setHeader("content-type", contentType);
+          response.setHeader(
+            "cache-control",
+            immutable ? "public, max-age=31536000, immutable" : "no-store",
+          );
+          response.setHeader("x-content-type-options", "nosniff");
+          response.end(request.method === "HEAD" ? undefined : body);
+        };
+        if (url.pathname === managedSelectionPath) {
+          send(JSON.stringify({ protocolVersion: 1, selection }), "application/json");
+          return;
+        }
+        const platformPrefix = `/_ignotum/platform/${selection.platformReleaseId}/`;
+        if (url.pathname.startsWith(platformPrefix)) {
+          const modulePath = url.pathname.slice(platformPrefix.length);
+          const allowed = provider.browser.manifest.modules.some(
+            (module) => module.path === modulePath,
+          );
+          const bytes = allowed ? provider.read("Browser", modulePath) : undefined;
+          if (bytes === undefined) {
+            response.statusCode = 404;
+            response.end();
+          } else send(bytes, "text/javascript", true);
+          return;
+        }
+        if (url.pathname.startsWith(toolingPrefix)) {
+          const code = tools.get(url.pathname.slice(toolingPrefix.length));
+          if (code === undefined) {
+            response.statusCode = 404;
+            response.end();
+          } else send(code, "text/javascript");
+          return;
+        }
+        if (icon !== undefined && url.pathname === icon.url) {
+          send(icon.bytes, "image/svg+xml", true);
+          return;
+        }
+        if (
+          url.pathname === "/icon.svg" ||
+          url.pathname.startsWith("/server/") ||
+          url.pathname.startsWith("/.")
+        ) {
+          response.statusCode = 404;
+          response.end();
+          return;
+        }
+        const isDocument =
+          (request.method === "GET" || request.method === "HEAD") &&
+          !url.pathname.startsWith("/_ignotum/") &&
+          !url.pathname.startsWith("/@") &&
+          !url.searchParams.has("import") &&
+          (request.headers.accept?.includes("text/html") ?? false);
+        if (!isDocument) {
+          next();
+          return;
+        }
+        void work
+          .then(async () => {
+            if (diagnostic !== undefined) throw diagnostic;
+            if (serverDiagnostic !== undefined) throw serverDiagnostic;
+            const outcome = await runPromise(matchLocation(patterns, request.url ?? "/"));
+            const metadata = await runPromise(
+              resolveMetadata({
+                applicationName: appName,
+                layouts: outcome.layouts.map((layout) => layout.metadata),
+                page: outcome._tag === "NotFound" ? undefined : outcome.route?.metadata,
+                outcome: outcome._tag,
+              }),
+            );
+            const imports = Object.fromEntries(
+              Object.entries(provider.browser.manifest.entries).map(([specifier, module]) => [
+                specifier,
+                localPlatformUrl(selection.platformReleaseId, module),
+              ]),
+            );
+            const html = renderDocument({
+              metadata,
+              selection,
+              importMap: { imports },
+              browserEntry: imports["ignotum/internal/bootstrap"]!,
+              registration: { module: moduleUrl(registrationId), exportName: "default" },
+              styles: [],
+              icon: icon?.url,
+            });
+            response.statusCode =
+              outcome._tag === "NotFound" ? 404 : outcome._tag === "Invalid" ? 400 : 200;
+            send(
+              html.replace("</head>", '<script type="module" src="/@vite/client"></script></head>'),
+              "text/html; charset=utf-8",
+            );
+          })
+          .catch(next);
+      });
+    },
+  };
+  const server = yield* Effect.acquireRelease(
+    Effect.tryPromise({
+      try: async () =>
+        createServer({
+          appType: "custom",
+          configFile: false,
+          envDir: false,
+          mode: "development",
+          root: appDirectory,
+          publicDir: false,
+          plugins: [
+            plugin,
+            images.plugin,
+            boundaries,
+            platform,
+            peers,
+            sync,
+            await prefresh(),
+            tailwindcss(),
+          ],
+          oxc: { jsx: { importSource: "ignotum/client", runtime: "automatic" } },
+          optimizeDeps: { noDiscovery: true, include: [] },
+          resolve: {
+            alias: [
+              {
+                find: /^tailwindcss$/,
+                replacement: fileURLToPath(import.meta.resolve("tailwindcss/index.css")),
               },
-              host: options.host,
-              open: options.open,
-              port: options.port,
-              strictPort: true,
-            },
-          }),
-        ),
+            ],
+            tsconfigPaths: true,
+          },
+          server: {
+            preTransformRequests: false,
+            host: options.host,
+            port: options.port,
+            open: options.open,
+            strictPort: true,
+            forwardConsole: { logLevels: ["warn", "error"], unhandledErrors: true },
+          },
+        }),
       catch: (cause) =>
         ViteStartupFailed.make({
           cause,
-          message: "Ignotum could not create the Vite development server.",
+          message: "Ignotum could not create the managed development server.",
         }),
     }),
-    (server) => Effect.promise(() => server.close()),
-  );
-});
-
-const listen = Effect.fn("Dev.listen")(function* (server: ViteDevServer) {
-  yield* Effect.tryPromise({
-    try: () => server.listen(),
-    catch: (cause) =>
-      ViteStartupFailed.make({
-        cause,
-        message: "Ignotum could not start the Vite development server.",
+    (server) =>
+      Effect.promise(async () => {
+        const closing = server.close();
+        await sync.api.dispose();
+        await closing;
+        await Promise.allSettled([work, serverWork]);
       }),
-  });
+  );
+  return {
+    server,
+    selection: () => selection,
+    settled: () => work,
+    replacePlatform: (next: LocalManagedRelease) => {
+      const replace = async () => {
+        const nextSelection = Schema.decodeUnknownSync(ExecutionSelection)({
+          ...localExecutionSelection(appDirectory, next),
+          platformGeneration: selection.platformGeneration + 1,
+        });
+        const nextTools = await runPromise(buildLocalBrowserTools(next, nextSelection));
+        const nextLoader = await runPromise(
+          createManagedFunctionLoader(appDirectory, {
+            guest: next.guest,
+            release: localPlatformRelease(next, nextSelection),
+            requirements: Schema.decodeUnknownSync(RuntimeRequirements)({
+              clientApiVersion: 1,
+              serverApiVersion: 1,
+              capabilities: ["operations", "routing", "images"],
+            }),
+          }),
+        );
+        const generated = await runPromise(generate(appDirectory));
+        const nextBuild = await runPromise(
+          buildManagedServer(
+            appDirectory,
+            path.join(appDirectory, ".ignotum/dev/server"),
+            generated.functionModules,
+          ),
+        );
+        await runPromise(nextLoader.reload(nextBuild));
+        loader = nextLoader;
+        provider = next;
+        tools = nextTools;
+        selection = Schema.decodeUnknownSync(ExecutionSelection)(nextSelection);
+        serverDiagnostic = undefined;
+        server.environments.client.moduleGraph.invalidateAll();
+        // Managed sync checks the new selection even for sockets with no active queries.
+        await sync.api.invalidate();
+      };
+      const replacement = serverWork.then(replace, replace);
+      // A rejected candidate leaves the current platform available to subsequent loads.
+      serverWork = replacement.catch(() => {});
+      return replacement;
+    },
+  };
 });
 
-export const dev = Effect.fn("Dev.run")(function* (options: DevOptions) {
-  const clientFiles = yield* validateClientFiles(options.appDirectory);
-  yield* generate(options.appDirectory);
-
+export const dev = Effect.fn("ManagedDev.run")(function* (options: ManagedDevOptions) {
   return yield* Effect.scoped(
     Effect.gen(function* () {
-      yield* acquireDevDatabaseLock(options.appDirectory);
-      const server = yield* acquireViteServer(options, clientFiles);
-
-      yield* listen(server);
-      yield* Effect.sync(() => {
-        server.printUrls();
-        server.bindCLIShortcuts({ print: true });
+      const { server } = yield* acquireManagedDevServer(options);
+      yield* Effect.tryPromise({
+        try: () => server.listen(),
+        catch: (cause) =>
+          ViteStartupFailed.make({
+            cause,
+            message: "Ignotum could not start the development server.",
+          }),
       });
+      server.printUrls();
+      server.bindCLIShortcuts({ print: true });
       return yield* Effect.never;
     }),
   );