@nanobpm/urban 0.1.0 → 0.2.0

package/README.md

@@ -1,7 +1,13 @@
 # `@nanobpm/urban`
 
-The `urban` command-line tool: scaffold, validate, generate and run an Urban app
-from your terminal — on **Node or Deno**.
+Build and run **code-first apps on Nano** — the runtime, the derivation toolkit,
+and the `urban` CLI in one package, on **Node or Deno**.
+
+An Urban app is a directory with a `nano.app.json` manifest that declares its
+processes, forms, datasources, workers, HTTP surfaces and triggers. This package
+brings it to life and gives you a library API to embed or extend it. Author your
+durable processes in code with [`@nanobpm/workflow`](../workflow)
+(`defineFlow`) — re-exported from here for convenience.
 
 ## Install
 
@@ -9,30 +15,26 @@ from your terminal — on **Node or Deno**.
 npm i -g @nanobpm/urban      # install the `urban` command
 # or run without installing:
 npx @nanobpm/urban new my-app
-```
-
-Requires Node ≥ 22.6 or Deno. On Node < 23.6 the `urban` command re-executes with
-`--experimental-strip-types` so its TypeScript source runs directly.
-
-Under Deno you can run it without installing:
-
-```bash
+# or on Deno:
 deno run -A npm:@nanobpm/urban run
 ```
 
-## Commands
+Requires Node ≥ 22.6 or Deno. It ships as TypeScript source with no build step;
+on Node < 23.6 the `urban` command re-executes with `--experimental-strip-types`.
+
+## The `urban` CLI
 
 | Command | What it does |
 |---|---|
 | `urban new <name>` | scaffold a new app in a new directory |
 | `urban check` | validate the app's `nano.app.json` manifest |
-| `urban gen` | generate the `nano-generated/` artifacts (migrations, worker I/O, models) |
+| `urban gen` | generate the `nano-generated/` artifacts (migrations, worker I/O) |
 | `urban gen --check` | fail if the generated artifacts are out of date (a CI drift gate) |
 | `urban run` | generate, then run the app — starts its workers and serves its surfaces |
 | `urban dev` | run the app (hot-reload is not yet implemented) |
 | `urban deploy` | deploy the app's models to the engine, then exit |
 
-## Options
+### Options
 
 | Flag | Purpose | Default |
 |---|---|---|
@@ -46,7 +48,7 @@ The engine address comes from `$CAMUNDA_REST_ADDRESS` (default
 `http://localhost:8080/v2`). Set `$CAMUNDA_TRANSPORT` to a non-`rest` value to use
 the `@nanobpm/nano-sdk` transport when it is installed.
 
-## A typical session
+### A typical session
 
 ```bash
 urban new invoices && cd invoices
@@ -55,8 +57,83 @@ urban check      # validate the manifest
 urban run        # start workers and serve surfaces
 ```
 
+## Library API
+
+Everything the CLI does is available programmatically. Import the whole surface
+from `@nanobpm/urban`, or the focused subpaths `@nanobpm/urban/runtime` and
+`@nanobpm/urban/toolkit`.
+
+### Runtime — run an app
+
+```ts
+import { runFromEnv } from "@nanobpm/urban";
+
+const app = await runFromEnv();          // reads ./nano.app.json and the environment
+console.log(app.inspect());              // { app, name, httpPort, ... }
+```
+
+`runFromEnv` reads the engine address and transport from the environment, starts
+the app (validate → deploy → provision datasources → start workers → serve
+surfaces and webhook triggers), and installs SIGINT/SIGTERM handlers for a
+graceful shutdown. For full control, assemble the pieces yourself:
+
+```ts
+import { createUrbanApp, selectHost, RestEngineClient } from "@nanobpm/urban";
+
+const host = selectHost();                       // picks the Node or Deno adapter
+const engine = new RestEngineClient({ baseUrl: process.env.CAMUNDA_REST_ADDRESS! });
+const app = await createUrbanApp({ host, engine, root: "." });
+await app.start();
+// ... later:
+await app.stop();                                // releases workers, server, datasources
+```
+
+Two engine transports are built in: `RestEngineClient` (default, no extra
+dependencies) and `createNanoSdkEngineClient` (used when `CAMUNDA_TRANSPORT` is
+anything other than `rest`; needs the optional `@nanobpm/nano-sdk`).
+
+### Toolkit — derive artifacts (`urban gen`)
+
+```ts
+import { runGen, createNodeGenIO } from "@nanobpm/urban";
+
+const io = createNodeGenIO();
+await runGen({ root: ".", io });                 // writes nano-generated/
+const { drift } = await runGen({ root: ".", io, check: true });  // CI drift gate
+```
+
+Each deriver is a pure `(input) → artifacts` function you can also call directly:
+
+| Deriver | Input | Output |
+|---|---|---|
+| `deriveMigrations` | the manifest's datasource types | `nano-generated/<source>.schema.sql` (`CREATE TABLE` per type) |
+| `deriveWorkerBindings` | BPMN service tasks + their data-envelope I/O | `nano-generated/worker-io.d.ts` (typed worker input/output) |
+
+Derivers are deterministic — the same input produces byte-identical output — so
+generated files are safe to commit and to gate in CI.
+
+### Code-first processes
+
+Author durable processes in code with `defineFlow`, re-exported from
+[`@nanobpm/workflow`](../workflow):
+
+```ts
+import { defineFlow, WorkflowClient, Worker } from "@nanobpm/urban";
+
+const flow = defineFlow("pr-review", (w) => {
+  w.run("fetchDiff", async (job) => ({ files: 3 }));
+  w.signal("humanApproval", { correlationKey: "prId" }); // durable human wait
+  w.run("merge", async (job) => ({ merged: true }));
+});
+```
+
+The SDK derives the executable BPMN, the job types, and the message/correlation
+wiring; `WorkflowClient` deploys and starts, `Worker` hosts your `run` steps.
+`deploy` emits an auto-generated diagram (DI) so the deployed model is
+inspectable in a modeller/Operate — `@nanobpm/urban` bundles `bpmn-auto-layout`
+so this works out of the box.
+
 ## Related packages
 
+- [`@nanobpm/workflow`](../workflow) — the code-first process surface (`defineFlow`).
 - [`create-urban-app`](../create-urban-app) — the scaffolder behind `urban new`.
-- [`@nanobpm/urban-toolkit`](../urban-toolkit) — the generation behind `urban gen`.
-- [`@nanobpm/urban-runtime`](../urban-runtime) — the runtime behind `urban run`.

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@nanobpm/urban",
-  "version": "0.1.0",
-  "description": "The Urban CLI: scaffold, check, run, dev, and deploy Urban apps (nano.app.json) on Node or Deno. Thin command surface over @nanobpm/urban-runtime (ADR 0052).",
+  "version": "0.2.0",
+  "description": "Urban: build and run code-first apps on Nano — runtime, derivation toolkit, and CLI in one. Author durable processes with @nanobpm/workflow (defineFlow), a typed datasource, forms, triggers and surfaces from a nano.app.json manifest, on Node or Deno.",
   "license": "Apache-2.0",
   "type": "module",
   "keywords": [
     "nanobpm",
     "urban",
-    "urban-cli",
     "cli",
+    "runtime",
+    "codegen",
+    "derivation",
     "nano-app",
     "rad"
   ],
@@ -18,7 +20,7 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/jwulf/nano-ide.git",
-    "directory": "packages/urban-cli"
+    "directory": "packages/urban"
   },
   "engines": {
     "node": ">=22.6"
@@ -26,10 +28,12 @@
   "bin": {
     "urban": "./src/bin.mjs"
   },
-  "main": "./src/cli.ts",
-  "types": "./src/cli.ts",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
   "exports": {
-    ".": "./src/cli.ts"
+    ".": "./src/index.ts",
+    "./runtime": "./src/runtime/index.ts",
+    "./toolkit": "./src/toolkit/index.ts"
   },
   "files": [
     "src",
@@ -37,12 +41,13 @@
   ],
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json",
-    "test": "node --test --experimental-strip-types \"src/**/*.test.ts\""
+    "test": "node --test --experimental-strip-types \"src/**/*.test.ts\"",
+    "test:deno": "deno test -A --no-check src/"
   },
   "dependencies": {
-    "@nanobpm/urban-runtime": "^0.1.0",
-    "@nanobpm/urban-toolkit": "^0.1.0",
-    "create-urban-app": "^0.1.0"
+    "@nanobpm/workflow": "^0.5.0",
+    "bpmn-auto-layout": "^2.0.0-alpha.2",
+    "create-urban-app": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",

package/src/cli.ts

@@ -1,7 +1,8 @@
-// The `urban` CLI — a thin command surface over @nanobpm/urban-runtime.
+// The `urban` CLI — a thin command surface over the Urban runtime + toolkit.
 //
 //   urban new <name>     scaffold a new app (delegates to create-urban-app)
 //   urban check          load + validate the manifest, report issues
+//   urban gen            derive generated artifacts (migrations, worker I/O)
 //   urban run            materialize + serve the app (deploy, data, workers, surfaces, triggers)
 //   urban dev            like run (hot-reload is not yet implemented; documented below)
 //   urban deploy         deploy models only, then exit
@@ -14,12 +15,12 @@ import {
   loadManifest,
   runFromEnv,
   selectHost,
-} from "@nanobpm/urban-runtime";
+} from "./runtime/index.ts";
 import { scaffold, slugify } from "create-urban-app";
-import { createNodeGenIO, runGen } from "@nanobpm/urban-toolkit";
+import { createNodeGenIO, runGen } from "./toolkit/index.ts";
 import { pathToFileURL } from "node:url";
 
-const VERSION = "0.1.0";
+const VERSION = "0.2.0";
 
 interface Flags {
   root: string;
@@ -63,7 +64,7 @@ const USAGE = `urban — build and run Urban apps (nano.app.json)
 Usage:
   urban new <name> [--root <path>]    scaffold a new Urban app
   urban check                       validate the manifest
-  urban gen [--check]               derive artifacts (migrations, worker-io, models)
+  urban gen [--check]               derive artifacts (migrations, worker-io)
   urban run                         materialize + serve the app
   urban dev                         run (hot-reload not yet implemented)
   urban deploy                      deploy models only, then exit

package/src/index.ts

@@ -0,0 +1,46 @@
+// @nanobpm/urban — the code-first Urban stack in one package (ADR 0054):
+//
+//   • runtime — materialize and serve an app from a nano.app.json manifest
+//     (datasource, workers, surfaces, triggers) on Node or Deno.
+//   • toolkit — pure derivers (`urban gen`) that emit generated artifacts
+//     (SQL migrations, worker I/O bindings) from the model.
+//   • workflow — the code-first process surface, re-exported from
+//     `@nanobpm/workflow`: author durable flows with `defineFlow` and the SDK
+//     derives the executable BPMN, job types, and correlation wiring.
+//
+// The CLI (`urban`) is a separate entrypoint (bin) over this same API.
+// Subpath imports are also available: `@nanobpm/urban/runtime` and
+// `@nanobpm/urban/toolkit`.
+
+// Runtime — app materialization + hosting
+export * from "./runtime/index.ts";
+
+// Toolkit — derivation library (`urban gen`)
+export * from "./toolkit/index.ts";
+
+// Code-first process surface (re-exported from @nanobpm/workflow)
+export {
+  defineFlow,
+  declarativeToBpmn,
+  declarativeToLayoutedBpmn,
+  externalJobTypes,
+  envelope,
+  layoutBpmn,
+  toBpmn,
+  toDeployableBpmn,
+  Worker,
+  WorkflowClient,
+  WorkflowError,
+} from "@nanobpm/workflow";
+export type {
+  FlowBuilder,
+  Envelope,
+  EnvelopeType,
+  EnvelopeField,
+  FieldSpec,
+  ScalarType,
+  WorkflowClientOptions,
+  ActivateOptions,
+  WorkerOptions,
+  ActivityEvent,
+} from "@nanobpm/workflow";

package/src/runtime/adapters/deno.ts

@@ -0,0 +1,124 @@
+// Deno adapter — implements HostContext against the `Deno` global (plus `node:*` compat
+// modules Deno supports). This and node.ts are the only files that touch a concrete runtime.
+// A minimal ambient `Deno` declaration lets this compile under Node's tsc; at runtime the
+// adapter is only ever selected when the real `Deno` global is present (see detect.ts).
+
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { DatabaseSync } from "node:sqlite";
+import type {
+  HostContext,
+  HttpHandler,
+  HttpRequest,
+  HttpServer,
+  SqliteDb,
+} from "../core/host.ts";
+
+interface DenoHttpServer {
+  finished: Promise<void>;
+  shutdown(): Promise<void>;
+}
+interface DenoGlobal {
+  env: { get(name: string): string | undefined };
+  cwd(): string;
+  readTextFile(path: string): Promise<string>;
+  readDir(path: string): AsyncIterable<{ name: string; isFile: boolean }>;
+  stat(path: string): Promise<unknown>;
+  serve(
+    opts: { port: number; onListen?: (a: { port: number }) => void },
+    handler: (req: Request) => Response | Promise<Response>,
+  ): DenoHttpServer;
+}
+declare const Deno: DenoGlobal;
+
+export interface DenoHostOptions {
+  cwd?: string;
+  log?: HostContext["log"];
+}
+
+export function createDenoHost(opts: DenoHostOptions = {}): HostContext {
+  const cwd = opts.cwd ?? Deno.cwd();
+  const abs = (p: string) => (isAbsolute(p) ? p : resolve(cwd, p));
+  const log: HostContext["log"] =
+    opts.log ??
+    ((level, msg, fields) => {
+      const line = fields ? `${msg} ${JSON.stringify(fields)}` : msg;
+      (level === "error" ? console.error : level === "warn" ? console.warn : console.log)(
+        `[urban] ${line}`,
+      );
+    });
+
+  return {
+    runtime: "deno",
+    env: (name) => Deno.env.get(name),
+    readTextFile: (p) => Deno.readTextFile(abs(p)),
+    async listDir(dir) {
+      try {
+        const names: string[] = [];
+        for await (const e of Deno.readDir(abs(dir))) {
+          if (e.isFile) names.push(e.name);
+        }
+        return names;
+      } catch {
+        return [];
+      }
+    },
+    async exists(p) {
+      try {
+        await Deno.stat(abs(p));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    openSqlite(path) {
+      const db = new DatabaseSync(abs(path));
+      return wrapSqlite(db);
+    },
+    importModule: (p) => import(pathToFileURL(abs(p)).href) as Promise<Record<string, unknown>>,
+    async serveHttp(port, handler) {
+      return startDenoServer(port, handler);
+    },
+    now: () => Date.now(),
+    log,
+  };
+}
+
+function wrapSqlite(db: DatabaseSync): SqliteDb {
+  return {
+    exec: (sql) => db.exec(sql),
+    run: (sql, params = []) => {
+      const stmt = db.prepare(sql);
+      const r = stmt.run(...(params as never[]));
+      return { changes: Number(r.changes), lastInsertRowid: r.lastInsertRowid };
+    },
+    all: <T>(sql: string, params: unknown[] = []) => {
+      const stmt = db.prepare(sql);
+      return stmt.all(...(params as never[])) as T[];
+    },
+    close: () => db.close(),
+  };
+}
+
+function startDenoServer(port: number, handler: HttpHandler): Promise<HttpServer> {
+  return new Promise<HttpServer>((resolveServer) => {
+    const server = Deno.serve({ port, onListen: ({ port: p }) => {
+      resolveServer({
+        port: p,
+        stop: () => server.shutdown(),
+      });
+    } }, async (request: Request): Promise<Response> => {
+      const url = new URL(request.url);
+      const bodyText = request.body ? await request.text() : "";
+      const req: HttpRequest = {
+        method: request.method,
+        path: url.pathname,
+        query: url.searchParams,
+        headers: request.headers,
+        text: () => Promise.resolve(bodyText),
+      };
+      const res = await handler(req);
+      return new Response(res.body ?? "", { status: res.status ?? 200, headers: res.headers });
+    });
+  });
+}

package/src/runtime/adapters/detect.ts

@@ -0,0 +1,22 @@
+// Runtime detection: pick the Node or Deno host at load time. Importing both adapter
+// modules is safe — neither touches its runtime's globals at module top level.
+
+import type { HostContext } from "../core/host.ts";
+import { createNodeHost } from "./node.ts";
+import { createDenoHost } from "./deno.ts";
+
+/** True when running under Deno. */
+export function isDeno(): boolean {
+  const g = globalThis as { Deno?: { version?: unknown } };
+  return typeof g.Deno !== "undefined" && typeof g.Deno.version !== "undefined";
+}
+
+export interface SelectHostOptions {
+  cwd?: string;
+  log?: HostContext["log"];
+}
+
+/** Select and construct the host for the current runtime. */
+export function selectHost(opts: SelectHostOptions = {}): HostContext {
+  return isDeno() ? createDenoHost(opts) : createNodeHost(opts);
+}

package/src/runtime/adapters/node.ts

@@ -0,0 +1,119 @@
+// Node adapter — implements HostContext against `node:*`. This is one of only two files
+// (with deno.ts) allowed to touch a concrete runtime.
+
+import { readFile, readdir, stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { DatabaseSync } from "node:sqlite";
+import type {
+  HostContext,
+  HttpHandler,
+  HttpRequest,
+  HttpServer,
+  SqliteDb,
+} from "../core/host.ts";
+
+export interface NodeHostOptions {
+  /** Base directory relative paths resolve against. Default process.cwd(). */
+  cwd?: string;
+  log?: HostContext["log"];
+}
+
+export function createNodeHost(opts: NodeHostOptions = {}): HostContext {
+  const cwd = opts.cwd ?? process.cwd();
+  const abs = (p: string) => (isAbsolute(p) ? p : resolve(cwd, p));
+  const log: HostContext["log"] =
+    opts.log ??
+    ((level, msg, fields) => {
+      const line = fields ? `${msg} ${JSON.stringify(fields)}` : msg;
+      (level === "error" ? console.error : level === "warn" ? console.warn : console.log)(
+        `[urban] ${line}`,
+      );
+    });
+
+  return {
+    runtime: "node",
+    env: (name) => process.env[name],
+    readTextFile: (p) => readFile(abs(p), "utf8"),
+    async listDir(dir) {
+      try {
+        const entries = await readdir(abs(dir), { withFileTypes: true });
+        return entries.filter((e) => e.isFile()).map((e) => e.name);
+      } catch {
+        return [];
+      }
+    },
+    async exists(p) {
+      try {
+        await stat(abs(p));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    openSqlite(path) {
+      const db = new DatabaseSync(abs(path));
+      return wrapNodeSqlite(db);
+    },
+    importModule: (p) => import(pathToFileURL(abs(p)).href) as Promise<Record<string, unknown>>,
+    async serveHttp(port, handler) {
+      return await startNodeServer(port, handler);
+    },
+    now: () => Date.now(),
+    log,
+  };
+}
+
+function wrapNodeSqlite(db: DatabaseSync): SqliteDb {
+  return {
+    exec: (sql) => db.exec(sql),
+    run: (sql, params = []) => {
+      const stmt = db.prepare(sql);
+      const r = stmt.run(...(params as never[]));
+      return { changes: Number(r.changes), lastInsertRowid: r.lastInsertRowid };
+    },
+    all: <T>(sql: string, params: unknown[] = []) => {
+      const stmt = db.prepare(sql);
+      return stmt.all(...(params as never[])) as T[];
+    },
+    close: () => db.close(),
+  };
+}
+
+async function startNodeServer(port: number, handler: HttpHandler): Promise<HttpServer> {
+  const server = createServer(async (nreq, nres) => {
+    const chunks: Buffer[] = [];
+    for await (const c of nreq) chunks.push(c as Buffer);
+    const bodyText = Buffer.concat(chunks).toString("utf8");
+    const url = new URL(nreq.url ?? "/", "http://localhost");
+    const headers = new Headers();
+    for (const [k, v] of Object.entries(nreq.headers)) {
+      if (typeof v === "string") headers.set(k, v);
+      else if (Array.isArray(v)) headers.set(k, v.join(", "));
+    }
+    const req: HttpRequest = {
+      method: nreq.method ?? "GET",
+      path: url.pathname,
+      query: url.searchParams,
+      headers,
+      text: () => Promise.resolve(bodyText),
+    };
+    try {
+      const res = await handler(req);
+      nres.statusCode = res.status ?? 200;
+      for (const [k, v] of Object.entries(res.headers ?? {})) nres.setHeader(k, v);
+      nres.end(res.body ?? "");
+    } catch (err) {
+      nres.statusCode = 500;
+      nres.end(String(err));
+    }
+  });
+  await new Promise<void>((res) => server.listen(port, res));
+  const addr = server.address();
+  const actualPort = typeof addr === "object" && addr ? addr.port : port;
+  return {
+    port: actualPort,
+    stop: () => new Promise<void>((res) => server.close(() => res())),
+  };
+}

package/src/runtime/core/context.ts

@@ -0,0 +1,35 @@
+import type { AppManifest } from "./manifest.ts";
+import type { EngineClient, HostContext } from "./host.ts";
+
+/** Everything a runtime module needs. Passed to each module's mount function. */
+export interface RuntimeContext {
+  manifest: AppManifest;
+  host: HostContext;
+  engine: EngineClient;
+  /** App root directory (paths in the manifest are relative to this). */
+  root: string;
+}
+
+/** A mounted module returns a disposer so the runtime can tear it down cleanly. */
+export interface Mounted {
+  readonly name: string;
+  stop(): Promise<void>;
+  /** Optional human-readable summary for `inspect()`. */
+  describe?(): Record<string, unknown>;
+}
+
+// AppApi is imported lazily to avoid a cycle; declared here as the injected handler surface.
+import type { DataLayer } from "./modules/datasource.ts";
+
+/**
+ * The surface injected into worker/trigger/surface handlers — the app's runtime API.
+ * This is how a handler reaches the datasource (typed accessors), the engine, and host
+ * utilities without hard-coding any of them.
+ */
+export interface AppApi {
+  manifest: AppManifest;
+  data: DataLayer;
+  engine: EngineClient;
+  env(name: string): string | undefined;
+  log(level: "info" | "warn" | "error", msg: string, fields?: Record<string, unknown>): void;
+}

package/src/runtime/core/glob.test.ts

@@ -0,0 +1,45 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { expandPattern, expandPatterns } from "./glob.ts";
+import type { HostContext } from "./host.ts";
+
+function fakeHost(files: Record<string, string[]>): HostContext {
+  // files: dir -> file names
+  return {
+    runtime: "node",
+    env: () => undefined,
+    readTextFile: async () => "",
+    listDir: async (dir) => files[dir.replace(/\/+$/, "")] ?? [],
+    exists: async (p) => {
+      const slash = p.lastIndexOf("/");
+      const dir = slash >= 0 ? p.slice(0, slash) : "";
+      const name = slash >= 0 ? p.slice(slash + 1) : p;
+      return (files[dir] ?? []).includes(name);
+    },
+    openSqlite: () => {
+      throw new Error("n/a");
+    },
+    importModule: async () => ({}),
+    serveHttp: async () => ({ port: 0, stop: async () => {} }),
+    now: () => 0,
+    log: () => {},
+  };
+}
+
+test("expandPattern: *.ext filters by extension and sorts", async () => {
+  const host = fakeHost({ "root/processes": ["b.bpmn", "a.bpmn", "note.md"] });
+  const out = await expandPattern(host, "root", "processes/*.bpmn");
+  assert.deepEqual(out, ["root/processes/a.bpmn", "root/processes/b.bpmn"]);
+});
+
+test("expandPattern: literal path resolves only if it exists", async () => {
+  const host = fakeHost({ "root/dir": ["x.dmn"] });
+  assert.deepEqual(await expandPattern(host, "root", "dir/x.dmn"), ["root/dir/x.dmn"]);
+  assert.deepEqual(await expandPattern(host, "root", "dir/missing.dmn"), []);
+});
+
+test("expandPatterns de-duplicates preserving order", async () => {
+  const host = fakeHost({ "root/d": ["a.form", "b.form"] });
+  const out = await expandPatterns(host, "root", ["d/*.form", "d/a.form"]);
+  assert.deepEqual(out, ["root/d/a.form", "root/d/b.form"]);
+});