kopular 0.6.1 → 0.9.0

package/LLM.md

@@ -1,17 +1,18 @@
 # Kopular — LLM reference
 
 Complete reference for generating correct Kopular code. This is a spec, not a tutorial —
-see `README.md` for narrative/rationale. Kopular is 7 files total; this covers all of
+see `README.md` for narrative/rationale. Kopular is 8 files total; this covers all of
 them. For the host language, see KopScript's own `LLM.md` in the `Kop` repo (or its
 published `LLM.md` on the `kopscript` npm package) — that reference is a prerequisite,
 not repeated here.
 
 Published as npm `kopular`. Entry points: `kopular` / `kopular/component` (Component),
 `kopular/router` (Router), `kopular/dom` (ambient DOM bindings), `kopular/directives`
-(If), `kopular/http` (Http), `kopular/forms` (FormField, Validators). Also ships a bin,
-`kp` — `npx kp new <dir>` scaffolds a new project (the `extern` bindings below, plus the
-vendor/serve scripts needed to run in a browser) rather than requiring it be reconstructed
-by hand; prefer it over hand-writing the section below for a new project.
+(If), `kopular/http` (Http), `kopular/forms` (FormField, Validators), `kopular/testing`
+(runKopularApp, runKopularFixture — see below). Also ships a bin, `kp` — `npx kp new
+<dir>` scaffolds a new project (the `extern` bindings below, plus the vendor/serve
+scripts needed to run in a browser) rather than requiring it be reconstructed by hand;
+prefer it over hand-writing the section below for a new project.
 
 ## Consuming Kopular from your own KopScript project
 
@@ -58,21 +59,20 @@ extern class Validators {
 } from "kopular/forms";
 ```
 
-**`extern class` has no `<T>` syntax** — `extern class FormField<T> { ... }` is a parse
-error (`ExternClassDecl` has no `typeParam`, unlike a real `ClassDecl`/`InterfaceDecl`).
-Describe one concrete instantiation per `T` you actually need instead, aliasing the same
-real export with `as` (the same trust-based, per-shape approach `Http`'s typed-JSON gap
-above already uses) — e.g. for a `FormField<string>`:
+`extern class` supports its own `<T>` (kopscript >= 0.5.0), the same rules as a real
+generic class — describe `FormField<T>` generically instead of per concrete type:
 
 ```ks
-extern class StringField {
-  constructor(string initial, (string) => string? validate);
-  state<string> Value;
+extern class FormField<T> {
+  constructor(T initial, (T) => string? validate);
+  state<T> Value;
   state<string?> Error;
   state<bool> Touched;
   void Touch();
   bool Valid();
-} from "kopular/forms" as "FormField";
+} from "kopular/forms";
+
+FormField<string> email = new FormField<string>("", (string v) => Validators.Email(v));
 ```
 
 `Value`/`Error`/`Touched` are declared as bare properties (`state<T> Value;`, no
@@ -158,6 +158,31 @@ nav.Navigate("/about");                          // pushState + immediate re-ren
 - `Navigate(path)` calls `history.pushState` then re-renders immediately. A browser
   back/forward triggers re-render via a `popstate` listener registered in the
   constructor — `Navigate()` itself doesn't rely on that event.
+- **Dynamic route segments**: a pattern segment written `:name` (e.g. `AddRoute("/dogs/:id",
+  ...)`) matches any single non-empty path segment; every other segment must match
+  literally (same segment count required too — `/dogs` does NOT match `/dogs/:id`).
+  The captured value is `Router.Param` — a plain `string` field (**not** `state<T>`; no
+  `Subscribe()` needed — see below), `""` when the matched route has no `:` segment.
+  Just one dynamic segment per route in v1: no `/dogs/:id/toys/:toyId`, no wildcards, no
+  query string parsing.
+- **Why `Param` is a plain field, not `state<T>`**: `Render()` already rebuilds a fresh
+  outlet and re-`Mount()`s the matched page on every `Navigate()`/`popstate`, which
+  re-runs that page's own `Render()` (reading the fresh `Param`) with no extra step.
+  Making it `state<T>` and having a page `Subscribe()` to it — the pattern every *other*
+  piece of state in this framework uses — actually crashes: `Match()` sets it *before*
+  `Render()` finishes swapping the matched page into the outlet, so the very first route
+  that matches a page nothing has `Mount()`ed yet fires that page's subscribed listener
+  while its inherited `Update()` still has no `ParentElement` to `replaceChild` into.
+- **Navigation guards**: `SetGuard(redirectPath, (string) => bool guard)` — `guard` is
+  called with the target path before every navigation (including a direct load/refresh);
+  returning `false` redirects to `redirectPath` (via `pushState`, so the URL updates too —
+  a refresh on the blocked path lands on the redirect again, not back on the rejected
+  page). One guard for the whole `Router`, not per-route — `guard` itself decides which
+  paths it cares about (`if (path == "/admin") { return loggedIn.Value; } return true;`).
+  Defaults to always-allow (a real `(string path) => true` function, not `null` — a
+  nullable *function type* has the same "can't parenthesize for postfix `?`" problem as
+  an array of one) until `SetGuard` is called. `redirectPath` is never itself
+  guard-checked — pick one `guard` always allows.
 - **Every deployment target needs its own SPA/history-fallback config — this is
   unavoidable, not a Kopular gap.** A direct load or refresh at `/about` is a plain HTTP
   request that reaches your host *before* any JS (Router included) has run, so no
@@ -270,6 +295,35 @@ function, not a list.
 call in your own `Render()`, the same as any other event handler; there is no
 `[(ngModel)]`-equivalent.
 
+## `kopular/testing` (`testing.js`, hand-written JS, not compiled from `.ks`)
+
+```ts
+import { runKopularApp } from "kopular/testing";
+
+const { window, cleanup } = await runKopularApp(srcDir, "app.ks", {
+  includeKopularPackage: true,   // app consumes Kopular via `extern`, not relative `using`
+  extraFiles: ["http_runtime.js"], // non-.ks/.html siblings a `using` graph needs at runtime
+  fetchMock: (...args) => Promise.resolve({ ok: true, status: 200, text: () => Promise.resolve("body") }),
+  url: "http://localhost/",
+});
+try {
+  window.document.querySelector(...)
+} finally {
+  cleanup();  // always call, even on a thrown assertion — restores globalThis + deletes the temp dir
+}
+```
+
+Compiles `entryFileName` (plus everything else in `srcDir` it `using`s) via kopscript's
+`compileGraph`, binds jsdom onto `globalThis` (`document`/`Element`/`Event`/`location`/
+`history`/`window`/`fetch`) for the compiled ambient `extern` declarations to find, and
+runs it. `runKopularFixture(source, options)` is the sibling export for an inline fixture
+string instead of a real file (used by Kopular's own test suite; copies Kopular's *own*
+`.ks` sources alongside the fixture, so `using "./component"` resolves — only meaningful
+for testing Kopular itself, not an external consumer, which should use `runKopularApp`
+with `includeKopularPackage: true` instead).
+
+`jsdom` is an optional peer dependency — add it to your own project to use this.
+
 ## Dependency injection — no container, no decorators
 
 There is no injector, no `@Injectable`, no provider tokens. "Injecting" a service is

package/README.md

@@ -50,11 +50,13 @@ Generating Kopular code with an AI coding assistant? Point it at **[`LLM.md`](./
   is its one companion file — the single hand-written (not compiled from `.ks`) file in
   Kopular, and why is explained in its own header comment.
 - `src/forms.ks` — `FormField<T>` and `Validators` (see "Forms" below).
-- `bin/kp.mjs` — the `kp new` scaffolding CLI (see "Starting a new project" below); the
-  one hand-written (not compiled from `.ks`) file besides `http_runtime.js`, for the same
-  reason — filesystem scaffolding isn't a Kopular `Component`.
+- `src/testing.js` — `runKopularApp`/`runKopularFixture` (see "Testing your own app"
+  below); hand-written for the same reason as `http_runtime.js` — filesystem/process
+  orchestration isn't a Kopular `Component`.
+- `bin/kp.mjs` — the `kp new` scaffolding CLI (see "Starting a new project" below); also
+  hand-written, same reason.
 
-That's the whole framework — seven files, plus the scaffolding CLI. Everything else (a
+That's the whole framework — eight files, plus the scaffolding CLI. Everything else (a
 real app built on top of it)
 lives in a separate consumer repo, [KopularDemo](https://dev.azure.com/koppinator/Koppindependence/_git/KopularDemo).
 
@@ -141,6 +143,40 @@ Real URLs via the History API (`pushState`/`popstate`), not `#/about` hash routi
 `state<T>` survives navigating away and back — see "Dependency injection" above for how
 the whole page graph typically gets built once, in a composition root.
 
+**Dynamic route segments**: a path segment written `:name` (e.g. `/dogs/:id`) matches any
+single non-empty segment, captured into `Router.Param`:
+
+```ks
+nav.AddRoute("/dogs/:id", new DogPage(nav));
+// inside DogPage.Render():
+el.textContent = "Dog #" + this.Nav.Param;
+```
+
+`Param` is a plain `string`, deliberately not `state<T>` — Router's own `Render()`
+already rebuilds a fresh outlet and re-`Mount()`s the matched page on every
+`Navigate()`/`popstate`, which re-runs that page's `Render()` (reading the fresh `Param`)
+with no extra step. No `Subscribe()` needed on it. Deliberately just one dynamic segment
+per route for now — no multiple params (`/dogs/:id/toys/:toyId`), no wildcards, no query
+string parsing — each a real, separate extension, not an oversight.
+
+**Navigation guards**: protect a route (or any set of routes) behind a check —
+`SetGuard` takes a redirect path plus a single `(string) => bool` checked before every
+navigation, including a direct load/refresh:
+
+```ks
+nav.SetGuard("/login", (string path) => {
+  if (path == "/admin") { return authService.IsLoggedIn.Value; }
+  return true;
+});
+```
+
+One guard for the whole `Router`, not per-route — the guard function itself decides which
+paths it cares about, the same "a function, not a config object" style `Http`/DI already
+use. Defaults to always-allow when `SetGuard` is never called. Redirecting updates the URL
+too (via `pushState`), so refreshing a blocked path lands on the redirect again rather than
+back on the page the guard just rejected — pick a `redirectPath` the guard itself always
+allows, or it loops.
+
 **Deploying a Router-based app needs SPA/history-fallback configured on whatever you
 deploy to — this is true of every client-side router in every framework, not a Kopular
 gap.** A direct load or a refresh at `/about` is a plain HTTP request that reaches your
@@ -377,10 +413,40 @@ Marking `Render()` `virtual` in the `extern` declaration is what lets a real sub
 for a full working example (components, a service, and routing, all consuming Kopular
 this way).
 
-`extern class` has no `<T>` syntax, so a generic export like `FormField<T>` can't be
-described directly this way — see `LLM.md`'s `FormField<T>`/`Validators` section for the
-per-concrete-type workaround (the same trust-based, per-shape approach the "HTTP" section
-above uses for typed JSON).
+`extern class` can carry its own `<T>` (kopscript >= 0.5.0), so a generic export like
+`FormField<T>` describes the same way a real generic class does — see `LLM.md`'s
+`FormField<T>`/`Validators` section for the full example.
+
+## Testing your own app: `kopular/testing`
+
+A `Component`/`Router` graph can only be exercised end-to-end by actually compiling its
+`.ks` sources and running the result against a real DOM — there's no way to unit test one
+otherwise. Doing that by hand is a real ~50-line dance (a fresh temp dir per test, since
+Node's ESM module cache means re-importing the same compiled path twice never re-runs an
+ambient extern binding's top-level code — silently binding every later test to the first
+test's jsdom instance — compiling via `kopscript`'s `compileGraph`, binding jsdom onto
+`globalThis` for `document`/`Element`/... to find, then restoring it). Both Kopular's own
+test suite and KopularDemo's used to hand-roll this independently; `kopular/testing` is
+that dance, written once:
+
+```ts
+import { runKopularApp } from "kopular/testing";
+
+const { window, cleanup } = await runKopularApp(join(__dirname, "..", "src"), "app.ks", {
+  includeKopularPackage: true, // your app consumes Kopular via `extern`, not relative `using`
+});
+try {
+  expect(window.document.querySelector("h1")?.textContent).toBe("Hello");
+} finally {
+  cleanup(); // always — even on a thrown assertion — or the next test inherits these globals
+}
+```
+
+`jsdom` is an **optional peer dependency** — installing `kopular` alone doesn't pull it
+in; only a project that actually calls `runKopularApp` needs it added too. See
+`Kopular/test/kopular.test.ts` (`runKopularFixture`, the sibling export used for testing
+Kopular's own source against inline fixtures) and KopularDemo's
+`test/routed_app.test.ts` for two real, different call sites.
 
 ## Getting started (developing Kopular itself)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kopular",
-  "version": "0.6.1",
+  "version": "0.9.0",
   "description": "Kopular: a small component framework for KopScript — components, reactive state, constructor-injected services, routing, structural directives, and HTTP, with no template DSL and no DI container",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,8 @@
     "./dom": "./src/dom.js",
     "./directives": "./src/directives.js",
     "./http": "./src/http.js",
-    "./forms": "./src/forms.js"
+    "./forms": "./src/forms.js",
+    "./testing": "./src/testing.js"
   },
   "files": [
     "src",
@@ -40,8 +41,16 @@
     "test": "vitest run",
     "test:watch": "vitest"
   },
+  "peerDependencies": {
+    "jsdom": "^25.0.0"
+  },
+  "peerDependenciesMeta": {
+    "jsdom": {
+      "optional": true
+    }
+  },
   "devDependencies": {
-    "kopscript": "^0.4.1",
+    "kopscript": "^0.5.0",
     "@types/jsdom": "^30.0.0",
     "@types/node": "^20.14.0",
     "jsdom": "^25.0.1",

package/src/router.js

@@ -7,6 +7,9 @@ export class Router extends Component {
     (this.Paths = []);
     (this.Pages = []);
     (this.NotFoundPage = notFoundPage);
+    (this.Param = "");
+    (this.Guard = (path) => (true));
+    (this.RedirectPath = "");
     window.addEventListener("popstate", (e) => (this.Update()));
   }
 
@@ -15,18 +18,47 @@ export class Router extends Component {
     (this.Pages = [...this.Pages, page]);
   }
 
+  SetGuard(redirectPath, guard) {
+    (this.RedirectPath = redirectPath);
+    (this.Guard = guard);
+  }
+
   Navigate(path) {
     history.pushState("", "", path);
     this.Update();
   }
 
   Match(path) {
+    let effectivePath = path;
+    if (!this.Guard(path)) {
+      history.pushState("", "", this.RedirectPath);
+      (effectivePath = this.RedirectPath);
+    }
+    let pathSegments = effectivePath.split("/");
     let found = this.NotFoundPage;
+    let param = "";
     for (let i = 0; (i < this.Paths.length); (i = (i + 1))) {
-      if ((this.Paths[i] === path)) {
+      let patternSegments = this.Paths[i].split("/");
+      if ((patternSegments.length !== pathSegments.length)) {
+        continue;
+      }
+      let matched = true;
+      let capturedParam = "";
+      for (let j = 0; (j < patternSegments.length); (j = (j + 1))) {
+        if (patternSegments[j].startsWith(":")) {
+          (capturedParam = pathSegments[j]);
+        } else if ((patternSegments[j] !== pathSegments[j])) {
+          (matched = false);
+          break;
+        }
+      }
+      if (matched) {
         (found = this.Pages[i]);
+        (param = capturedParam);
+        break;
       }
     }
+    (this.Param = param);
     return found;
   }
 

package/src/router.ks

@@ -28,10 +28,41 @@ class Router : Component {
   private Component[] Pages;
   private Component NotFoundPage;
 
+  // The current route's dynamic segment (e.g. "42" for a "/dogs/:id" route
+  // matching "/dogs/42"), or "" if the matched route has none.
+  //
+  // A plain field, deliberately **not** state<T> — Render() below always
+  // rebuilds a fresh outlet and re-Mount()s the matched page into it on
+  // every Navigate()/popstate, which already re-runs that page's own
+  // Render() (reading the fresh Param) with no extra step. Subscribing to
+  // it, the way a page reacts to its *own* state<T>, would fire during
+  // Match() itself — before Render() has finished swapping the matched page
+  // in — which crashes the very first time a route no page has been
+  // Mount()ed into yet matches, since a not-yet-mounted Component's
+  // inherited Update() has no ParentElement to replaceChild into.
+  public string Param;
+
+  // Checked before every navigation, including a direct load/refresh — not
+  // just Navigate()/popstate. Deliberately one guard for the whole Router,
+  // not per-route: the guard function itself decides which paths it cares
+  // about (typically `path.StartsWith("/admin")`-style checks), the same
+  // "no config object, just a function" style Http/DI already use, rather
+  // than a parallel array of per-route guards (which also can't be written
+  // as a type anyway — see AddRoute's own comment on array-of-function
+  // types). Defaults to always-allow, not null — a nullable function TYPE
+  // has the same "can't parenthesize for a postfix `?`" problem as an
+  // array of one, so "no guard configured" is a real function that always
+  // returns true, not a null check.
+  private (string) => bool Guard;
+  private string RedirectPath;
+
   constructor(Component notFoundPage) : base() {
     this.Paths = [];
     this.Pages = [];
     this.NotFoundPage = notFoundPage;
+    this.Param = "";
+    this.Guard = (string path) => true;
+    this.RedirectPath = "";
     // 'popstate' only fires on browser back/forward (or history.go/back/
     // forward) — never on pushState itself, unlike hashchange firing
     // whenever location.hash is set. Navigate() below calls Update()
@@ -40,23 +71,63 @@ class Router : Component {
     window.addEventListener("popstate", (Event e) => this.Update());
   }
 
+  // A path segment written ":name" (e.g. "dogs/:id") matches any single
+  // non-empty segment; every other segment must match literally. Comparing
+  // segment-by-segment (rather than the whole string at once) is what makes
+  // a static route's own matching still exactly as strict as a plain `==`
+  // was before — same segment count, same literal text throughout.
   public void AddRoute(string path, Component page) {
     this.Paths = this.Paths.Push(path);
     this.Pages = this.Pages.Push(page);
   }
 
+  // `guard` is called with the path being navigated to; returning false
+  // redirects to `redirectPath` instead (updating the URL via pushState, so
+  // a refresh on the blocked path lands on the redirect too, not back on
+  // the page the guard just rejected). `redirectPath` itself is never
+  // guard-checked — pick one the guard always allows, or it'll loop.
+  public void SetGuard(string redirectPath, (string) => bool guard) {
+    this.RedirectPath = redirectPath;
+    this.Guard = guard;
+  }
+
   public void Navigate(string path) {
     history.pushState("", "", path);
     this.Update();
   }
 
   private Component Match(string path) {
+    string effectivePath = path;
+    if (!this.Guard(path)) {
+      history.pushState("", "", this.RedirectPath);
+      effectivePath = this.RedirectPath;
+    }
+
+    string[] pathSegments = effectivePath.Split("/");
     Component found = this.NotFoundPage;
+    string param = "";
     for (number i = 0; i < this.Paths.Length; i = i + 1) {
-      if (this.Paths[i] == path) {
+      string[] patternSegments = this.Paths[i].Split("/");
+      if (patternSegments.Length != pathSegments.Length) { continue; }
+
+      bool matched = true;
+      string capturedParam = "";
+      for (number j = 0; j < patternSegments.Length; j = j + 1) {
+        if (patternSegments[j].StartsWith(":")) {
+          capturedParam = pathSegments[j];
+        } else if (patternSegments[j] != pathSegments[j]) {
+          matched = false;
+          break;
+        }
+      }
+
+      if (matched) {
         found = this.Pages[i];
+        param = capturedParam;
+        break;
       }
     }
+    this.Param = param;
     return found;
   }
 

package/src/testing.js

@@ -0,0 +1,166 @@
+// A real Kopular app can only be exercised end-to-end by actually compiling
+// its .ks sources and running the result in a DOM — there's no way to unit
+// test a Component/Router graph without one. Every test suite that's tried
+// this so far (Kopular's own, and KopularDemo's) ended up hand-rolling the
+// same ~50-line dance: a fresh temp dir per test (Node's ESM module cache
+// means re-importing the same compiled path twice never re-runs an ambient
+// extern binding's top-level code — silently binding every test after the
+// first to the first test's jsdom instance), compiling via kopscript's
+// compileGraph, binding jsdom onto globalThis for the ambient `document`/
+// `Element`/... extern declarations to find, then restoring/cleaning up.
+// This is that dance, written once.
+//
+// Hand-written plain JS, not compiled from a .ks source, the same as
+// http_runtime.js and bin/kp.mjs: filesystem/process orchestration isn't a
+// Kopular Component.
+//
+// `jsdom` is a peer dependency (optional) — only installed by a consumer
+// who actually calls this, not a weight every `kopular` install pays.
+import { JSDOM } from "jsdom";
+import { compileGraph } from "kopscript";
+import { cpSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const GLOBAL_KEYS = ["document", "Element", "Event", "location", "history", "window", "fetch"];
+const OWN_SRC_DIR = dirname(fileURLToPath(import.meta.url));
+
+// Copies every .ks/.html file from `srcDir` into `dir`, plus any filename
+// listed in `extraFiles` (e.g. http_runtime.js — a hand-written sibling a
+// compiled `using` graph needs at runtime, which the compiler wouldn't know
+// to copy on its own).
+function copySources(srcDir, dir, extraFiles) {
+  for (const name of readdirSync(srcDir)) {
+    if (name.endsWith(".ks") || name.endsWith(".html") || extraFiles.includes(name)) {
+      cpSync(join(srcDir, name), join(dir, name));
+    }
+  }
+}
+
+// kopscript's compiled output is genuine ESM (`export class ...`), which
+// Node only interprets correctly given a ".mjs" extension or an ancestor
+// package.json declaring "type": "module" — a bare os.tmpdir() has neither,
+// so the dynamic `import()` below would otherwise fail with "Cannot use
+// import statement outside a module" the moment anything outside this
+// file's own module graph (a real npm package, not code vitest/vite-node
+// itself transforms) tries to load it.
+function mkTempDir() {
+  const dir = mkdtempSync(join(tmpdir(), "kopular-testing-"));
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ type: "module" }), "utf-8");
+  return dir;
+}
+
+// Copies this real, installed `kopular` package into the temp dir's own
+// node_modules — for an entry that consumes Kopular the way a separate
+// project does, through `extern ... from "kopular/..."` bare specifiers,
+// not via relative `using`. Resolved off this very file's own location, so
+// it's always the real package as installed in the *caller's*
+// node_modules, not a guess at a path.
+function copyKopularPackage(dir) {
+  mkdirSync(join(dir, "node_modules"), { recursive: true });
+  cpSync(join(OWN_SRC_DIR, ".."), join(dir, "node_modules", "kopular"), { recursive: true });
+}
+
+// Shared by both exports below: compiles `entryFileName` (already written
+// into `dir`, alongside everything it `using`s) and runs it against a fresh
+// jsdom instance.
+async function compileAndRun(dir, entryFileName, options) {
+  const entry = join(dir, entryFileName);
+  const result = compileGraph(entry);
+  if (!result.success) {
+    rmSync(dir, { recursive: true, force: true });
+    const messages = [...result.modules.values()]
+      .filter((m) => m.diagnostics.hasErrors)
+      .map((m) => m.diagnostics.format(m.source, m.absPath))
+      .join("\n\n");
+    throw new Error(messages || "Compilation failed");
+  }
+  for (const [absPath, js] of result.outputs) {
+    writeFileSync(absPath.replace(/\.ks$/, ".js"), js, "utf-8");
+  }
+
+  const dom = new JSDOM("<!doctype html><html><body></body></html>", { url: options.url ?? "http://localhost/" });
+  const g = globalThis;
+  const previous = {};
+  for (const key of GLOBAL_KEYS) previous[key] = g[key];
+  g.document = dom.window.document;
+  g.Element = dom.window.Element;
+  g.Event = dom.window.Event;
+  g.location = dom.window.location;
+  g.history = dom.window.history;
+  g.window = dom.window;
+  if (options.fetchMock) g.fetch = options.fetchMock;
+
+  let cleanedUp = false;
+  const cleanup = () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    for (const key of GLOBAL_KEYS) g[key] = previous[key];
+    rmSync(dir, { recursive: true, force: true });
+  };
+
+  try {
+    await import(entry.replace(/\.ks$/, ".js"));
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+
+  return { window: dom.window, cleanup };
+}
+
+/**
+ * Compiles a real KopScript app — `entryFileName` plus everything else in
+ * `srcDir` it `using`s — and runs it against a fresh jsdom instance. For a
+ * real project's own src/ directory, the way KopularDemo's test suite (or
+ * any app consuming `kopular/...` via `extern`) would use it.
+ *
+ * @param {string} srcDir - directory containing the entry file and
+ *   everything it `using`s.
+ * @param {string} entryFileName - the entry .ks file's name within srcDir.
+ * @param {object} [options]
+ * @param {boolean} [options.includeKopularPackage] - copy the real
+ *   installed `kopular` package into a temp node_modules/, for an entry
+ *   that consumes Kopular via `extern ... from "kopular/..."` rather than
+ *   relative `using`. Default false.
+ * @param {string[]} [options.extraFiles] - extra filenames (not .ks/.html)
+ *   to copy from srcDir, e.g. ["http_runtime.js"].
+ * @param {(...args: unknown[]) => unknown} [options.fetchMock] - replaces
+ *   the global `fetch` for the duration of the run, for testing `Http`.
+ * @param {string} [options.url] - the jsdom document's URL. Default
+ *   "http://localhost/".
+ * @returns {Promise<{ window: import("jsdom").DOMWindow, cleanup: () => void }>}
+ *   `cleanup()` restores globals and deletes the temp dir — call it in an
+ *   `afterEach`/`finally`, always, even on a thrown error, or the next test
+ *   silently inherits this one's globals.
+ */
+export async function runKopularApp(srcDir, entryFileName, options = {}) {
+  const dir = mkTempDir();
+  copySources(srcDir, dir, options.extraFiles ?? []);
+  if (options.includeKopularPackage) copyKopularPackage(dir);
+  return compileAndRun(dir, entryFileName, options);
+}
+
+/**
+ * Like `runKopularApp`, but for a fixture written inline as a string rather
+ * than a real file on disk — for testing Kopular's *own* source files
+ * (`using "./component"`, `using "./router"`, ...) against a tiny
+ * throwaway component, the way Kopular's own test suite does. Copies
+ * Kopular's own .ks sources (resolved from this very file's own directory)
+ * alongside the fixture, so a relative `using "./dom"` in `source` resolves
+ * correctly — this only makes sense for testing Kopular itself, not for an
+ * external consumer (which would `extern ... from "kopular/..."` instead;
+ * see `runKopularApp` for that case).
+ *
+ * @param {string} source - the entry file's full KopScript source.
+ * @param {object} [options] - same as `runKopularApp`, plus:
+ * @param {string} [options.entryFileName] - default "main.ks".
+ */
+export async function runKopularFixture(source, options = {}) {
+  const dir = mkTempDir();
+  copySources(OWN_SRC_DIR, dir, options.extraFiles ?? ["http_runtime.js"]);
+  const entryFileName = options.entryFileName ?? "main.ks";
+  writeFileSync(join(dir, entryFileName), source, "utf-8");
+  return compileAndRun(dir, entryFileName, options);
+}