@noego/wood 0.4.9 → 0.5.0

package/dist/testing/test_wood_config.js

@@ -0,0 +1,247 @@
+import path from "node:path";
+import { ExecutionContext } from "@noego/ioc";
+import { testIoc, ENV_REGISTRY } from "@noego/testing";
+import { WoodRouter } from "../router/wood_router.js";
+import { TestWoodError } from "./test_wood.js";
+import {
+  defaultImporter,
+  importDefaultExport,
+  loadWoodConfigSource
+} from "./wood_config_source.js";
+import {
+  resolveSelection,
+  selectCatalog,
+  selectOperations
+} from "./wood_test_selection.js";
+import {
+  buildRendererTier
+} from "./wood_env_renderer.js";
+const CONTAINER_REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("@noego/wood.container.registry");
+function globalRegistrySize() {
+  const registry = globalThis[CONTAINER_REGISTRY_SYMBOL];
+  return registry instanceof Map ? registry.size : 0;
+}
+function tierMissing(tier, member) {
+  throw new TestWoodError(
+    `the ${member} is not available: this environment was built without { ${tier} } \u2014 add it to select()`
+  );
+}
+function buildRouter(root, source, operations, importer) {
+  const router = new WoodRouter({
+    container: root,
+    controllersDir: source.mainControllersDir,
+    middlewareDir: source.mainMiddlewareDir,
+    mode: "dev"
+  });
+  const bound = /* @__PURE__ */ new Set();
+  for (const operation of operations.values()) {
+    if (bound.has(operation.controller)) continue;
+    bound.add(operation.controller);
+    const file = source.mainControllerFile(operation.controller);
+    router.registerControllerLoader(operation.controller, () => importer(file));
+  }
+  router.loadOperations(operations);
+  router.validateControllers();
+  return router;
+}
+async function runCompose(root, source, context) {
+  const composePath = source.hookModule(source.config.main.testing?.compose);
+  if (!composePath) return null;
+  const compose = await importDefaultExport(context.importer, composePath, "main.testing.compose");
+  if (typeof compose !== "function") {
+    throw new TestWoodError(`main.testing.compose default export must be a function (${composePath})`);
+  }
+  return await ExecutionContext.run(root, () => compose(root, context)) ?? null;
+}
+async function disposeRoot(env) {
+  try {
+    await ExecutionContext.run(env.root, () => env.dispose());
+  } catch (error) {
+    const failures = error.failures;
+    if (!Array.isArray(failures)) throw error;
+    const detail = failures.map((failure) => `${failure.token}: ${failure.error instanceof Error ? failure.error.message : String(failure.error)}`).join("\n  ");
+    throw new TestWoodError(`main root disposal failed for ${failures.length} instance(s):
+  ${detail}`);
+  }
+}
+function assertNoGlobalContainerLeak(before, source) {
+  if (!process.env.VITEST) return;
+  const after = globalRegistrySize();
+  if (after > before) {
+    throw new TestWoodError(
+      `${source.config.main.testing?.compose ?? "the build"} registered ${after - before} process-global Wood container(s) (getContainer). Compose on the root the builder hands you so environments stay isolated.`
+    );
+  }
+}
+async function assembleEnvironment(state, selection) {
+  const source = loadWoodConfigSource(state.configPath);
+  const operations = selectOperations(source.operations, selection.main);
+  const catalog = selection.pages ? selectCatalog(source.views(), selection.pages) : null;
+  const registryBefore = globalRegistrySize();
+  let composed = null;
+  let renderer = null;
+  const controllerScopes = [];
+  let router = null;
+  const context = {
+    configPath: source.configPath,
+    configDir: source.configDir,
+    config: source.config,
+    selection,
+    operations,
+    importer: state.importer,
+    call: async (operation, input) => {
+      if (!router) throw new TestWoodError("compose context call() is available from start() onward, not during compose");
+      const live = router;
+      return await ExecutionContext.run(env.root, () => live.dispatch(operation, input));
+    }
+  };
+  const env = await state.ioc.build({
+    prepare: async (root2) => {
+      composed = await runCompose(root2, source, context);
+    }
+  });
+  const root = env.root;
+  const dispose = async () => {
+    if (renderer) await renderer.dispose();
+    for (const scope of controllerScopes.reverse()) await scope.dispose();
+    await composed?.drain?.();
+    try {
+      await disposeRoot(env);
+    } finally {
+      await composed?.dispose?.();
+    }
+  };
+  try {
+    router = buildRouter(root, source, operations, state.importer);
+    await ExecutionContext.run(root, () => composed?.start?.());
+    assertNoGlobalContainerLeak(registryBefore, source);
+    if (catalog) {
+      renderer = await buildRendererTier({
+        source,
+        router,
+        catalog,
+        operations,
+        importer: state.importer,
+        hooks: composed,
+        dom: selection.dom
+      });
+    }
+    return environmentSurface({ root, env, router, operations, renderer, controllerScopes, dispose });
+  } catch (error) {
+    await dispose().catch(() => {
+    });
+    throw error;
+  }
+}
+function environmentSurface(parts) {
+  const { root, env, router, operations, renderer, controllerScopes, dispose } = parts;
+  const dom = () => renderer?.dom ?? tierMissing("dom", "dom driver");
+  const pages = () => renderer ?? tierMissing("pages", "renderer");
+  return {
+    root,
+    router,
+    operations,
+    call: async (operation, input) => {
+      if (!operations.has(operation)) {
+        throw new TestWoodError(
+          `operation "${operation}" is not in the selected aperture; available operations:
+  ${[...operations.keys()].join("\n  ")}`
+        );
+      }
+      return await ExecutionContext.run(root, () => router.dispatch(operation, input));
+    },
+    controller: async (controller) => {
+      const scope = root.extend();
+      controllerScopes.push(scope);
+      if (!scope.isRegistered(controller)) scope.registerClass(controller);
+      return await scope.get(controller);
+    },
+    get: async (token) => await root.get(token),
+    get frontend() {
+      return pages().frontend;
+    },
+    get events() {
+      return pages().events;
+    },
+    get rendererRoot() {
+      return pages().rendererRoot;
+    },
+    open: async (page, params, query) => pages().open(page, params, query),
+    navigate: async (page, params, query) => pages().navigate(page, params, query),
+    current: () => pages().current(),
+    settle: async () => pages().settle(),
+    get target() {
+      return dom().target;
+    },
+    click: async (selector) => dom().click(selector),
+    type: async (selector, text) => dom().type(selector, text),
+    submit: async (selector) => dom().submit(selector),
+    text: async (selector) => dom().text(selector),
+    exists: async (selector) => dom().exists(selector),
+    // Method expectations only: `settle()` is the completion contract for
+    // owned renderer work, and a test may legitimately verify while a
+    // deliberately deferred stream is still in flight.
+    verify: () => env.verify(),
+    dispose,
+    [ENV_REGISTRY]: env[ENV_REGISTRY]
+  };
+}
+class TestWoodBuilder {
+  constructor(state) {
+    this.state = state;
+  }
+  static create(configPath) {
+    if (typeof configPath !== "string" || !configPath.length) {
+      throw new TestWoodError("testWood(configPath) requires the path to a wood.config.yml");
+    }
+    return new TestWoodBuilder({
+      configPath: path.resolve(configPath),
+      selection: null,
+      ioc: testIoc(),
+      importer: defaultImporter
+    });
+  }
+  /** Declare which tiers exist: `main`, `pages`, `dom`. Replaces any earlier selection. */
+  select(selection) {
+    resolveSelection(selection);
+    return this.derive({ selection });
+  }
+  /** Route hook/controller imports through a caller-owned importer (escape hatch). */
+  importer(importer) {
+    if (typeof importer !== "function") throw new TestWoodError("importer() expects a function");
+    return this.derive({ importer });
+  }
+  /* ---- Composition: exact @noego/testing semantics on the main root ---- */
+  use(preset) {
+    return this.derive({ ioc: this.state.ioc.use(preset) });
+  }
+  classes(config) {
+    return this.derive({ ioc: this.state.ioc.classes(config) });
+  }
+  functions(config) {
+    return this.derive({ ioc: this.state.ioc.functions(config) });
+  }
+  values(config) {
+    return this.derive({ ioc: this.state.ioc.values(config) });
+  }
+  methods(config) {
+    return this.derive({ ioc: this.state.ioc.methods(config) });
+  }
+  async build() {
+    if (!this.state.selection) {
+      throw new TestWoodError("select() a tier before build(): { main }, { pages }, or both");
+    }
+    return assembleEnvironment(this.state, resolveSelection(this.state.selection));
+  }
+  derive(patch) {
+    return new TestWoodBuilder({ ...this.state, ...patch });
+  }
+}
+function testWood(configPath) {
+  return TestWoodBuilder.create(configPath);
+}
+export {
+  TestWoodBuilder,
+  testWood
+};
+//# sourceMappingURL=test_wood_config.js.map

package/dist/testing/test_wood_config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/testing/test_wood_config.ts"],"sourcesContent":["/**\n * `testWood(configPath)` — the canonical Wood testing entry point.\n *\n * One persistent immutable builder over the production `wood.config.yml`:\n *\n *   const app = await testWood('wood.config.yml')\n *     .select({ main: { module: 'backend_service' }, pages: ['settings.backend-service'] })\n *     .classes([[BackendServiceLifecycleCoordinator, LifecycleStub]])\n *     .methods([[LifecycleStub, { getStatus: test.once(test.returns(status)) }]])\n *     .build();\n *\n * `select` decides what exists (main router, renderer pages, DOM); the\n * `@noego/testing` vocabulary (`use/classes/functions/values/methods`, exact\n * tokens) decides what is replaced — controllers included, since the router\n * resolves them through the same root. Controllers, middleware and views are\n * auto-bound from the config; the app composes its backend through the\n * optional `main.testing.compose` hook and mounts pages through\n * `renderer.testing.host`.\n *\n * Every build creates fresh `@noego/ioc` roots (main, and renderer when\n * pages are selected) — nothing global is touched, so environments coexist\n * in one process.\n */\nimport path from 'node:path';\nimport type { IContainer } from '@noego/ioc';\nimport { ExecutionContext } from '@noego/ioc';\nimport { testIoc, TestIocBuilder, ENV_REGISTRY } from '@noego/testing';\nimport type { ConfigMap, MethodsConfig, TestEnvironment, UseInput } from '@noego/testing';\nimport { WoodRouter } from '../router/wood_router.js';\nimport type { OperationDef } from '../types/index.js';\nimport type { WoodConfig } from '../types/config.js';\nimport type { FrontendApplicationSurface } from '../frontend/frontend_surface.js';\nimport type { FrontendPage } from '../frontend/frontend_page.js';\nimport type { RouterBridgeEvents } from './create_router_bridge.js';\nimport { TestWoodError } from './test_wood.js';\nimport {\n  defaultImporter,\n  importDefaultExport,\n  loadWoodConfigSource,\n  type ModuleImporter,\n  type WoodConfigSource,\n} from './wood_config_source.js';\nimport {\n  resolveSelection,\n  selectCatalog,\n  selectOperations,\n  type ResolvedWoodSelection,\n  type WoodTestSelection,\n} from './wood_test_selection.js';\nimport {\n  buildRendererTier,\n  type RendererTier,\n  type WoodDomDriver,\n  type WoodRendererHooks,\n} from './wood_env_renderer.js';\n\n/** What the app's `main.testing.compose` default export receives. */\nexport interface WoodComposeContext {\n  readonly configPath: string;\n  readonly configDir: string;\n  readonly config: WoodConfig;\n  readonly selection: ResolvedWoodSelection;\n  /** The selected operations (the router will serve exactly these). */\n  readonly operations: ReadonlyMap<string, OperationDef>;\n  readonly importer: ModuleImporter;\n  /**\n   * Dispatch through the environment's router. Available from `start()`\n   * onward (the router is built after compose returns); calling it during\n   * compose itself fails.\n   */\n  call<T = unknown>(operation: string, input?: unknown): Promise<T>;\n}\n\n/** What the compose hook may hand back; every member is optional. */\nexport interface WoodComposeResult extends WoodRendererHooks {\n  /**\n   * Runs AFTER the test's substitutions are installed on the root (compose\n   * itself runs before them, so production registrations never shadow a\n   * seam). Seed world state and warm caches here — through the seamed graph,\n   * exactly as the test will observe it.\n   */\n  start?(): void | Promise<void>;\n  /**\n   * Quiesce BEFORE the main root disposes its instances: silence push\n   * delivery, drain detached work — everything that still needs the live\n   * graph (database, tracer) the services' own dispose hooks run against.\n   */\n  drain?(): void | Promise<void>;\n  /** Release resources AFTER the roots are disposed (close files, remove dirs). */\n  dispose?(): void | Promise<void>;\n}\n\n/**\n * The app's backend composition on the root the builder hands it. Register\n * lazily: nothing expensive should run until a test resolves it.\n */\nexport type WoodComposeMain = (\n  root: IContainer,\n  context: WoodComposeContext,\n) => WoodComposeResult | void | Promise<WoodComposeResult | void>;\n\ntype Params = Record<string, string>;\n\nexport interface TestWoodEnvironment {\n  /** The main-process IoC root of this environment. */\n  readonly root: IContainer;\n  readonly router: WoodRouter;\n  /** The selected operations. */\n  readonly operations: ReadonlyMap<string, OperationDef>;\n  /** Execute a selected operation through the real pipeline. */\n  call<T = unknown>(operation: string, input?: unknown): Promise<T>;\n  /** Resolve a controller class through a fresh main scope (root seams apply). */\n  controller<T>(controller: new (...args: never[]) => T): Promise<T>;\n  /** Resolve any dependency from the main root. */\n  get<T>(token: unknown): Promise<T>;\n\n  /** Renderer surface — present only when `pages` was selected. */\n  readonly frontend: FrontendApplicationSurface;\n  /** Backend push emitter feeding renderer subscriptions (pages only). */\n  readonly events: RouterBridgeEvents;\n  readonly rendererRoot: IContainer;\n  open(page: string, params?: Params, query?: Params): Promise<FrontendPage>;\n  navigate(page: string, params?: Params, query?: Params): Promise<FrontendPage>;\n  current(): FrontendPage | null;\n  settle(): Promise<void>;\n\n  /** DOM driver — present only when `dom` was selected. */\n  readonly target: Element;\n  click(selector: string): Promise<void>;\n  type(selector: string, text: string): Promise<void>;\n  submit(selector: string): Promise<void>;\n  text(selector: string): Promise<string>;\n  exists(selector: string): Promise<boolean>;\n\n  /** Finalize `test.*` expectations; fails on undrained renderer work. */\n  verify(): Promise<void>;\n  dispose(): Promise<void>;\n  readonly [ENV_REGISTRY]: unknown;\n}\n\ninterface BuilderState {\n  readonly configPath: string;\n  readonly selection: WoodTestSelection | null;\n  readonly ioc: TestIocBuilder;\n  readonly importer: ModuleImporter;\n}\n\nconst CONTAINER_REGISTRY_SYMBOL = Symbol.for('@noego/wood.container.registry');\n\nfunction globalRegistrySize(): number {\n  const registry = (globalThis as Record<symbol, unknown>)[CONTAINER_REGISTRY_SYMBOL];\n  return registry instanceof Map ? registry.size : 0;\n}\n\nfunction tierMissing(tier: 'pages' | 'dom', member: string): never {\n  throw new TestWoodError(\n    `the ${member} is not available: this environment was built without { ${tier} } — add it to select()`,\n  );\n}\n\n/** A router over the selected aperture with every controller auto-bound from the config. */\nfunction buildRouter(\n  root: IContainer,\n  source: WoodConfigSource,\n  operations: Map<string, OperationDef>,\n  importer: ModuleImporter,\n): WoodRouter {\n  const router = new WoodRouter({\n    container: root,\n    controllersDir: source.mainControllersDir,\n    middlewareDir: source.mainMiddlewareDir,\n    mode: 'dev',\n  });\n  const bound = new Set<string>();\n  for (const operation of operations.values()) {\n    if (bound.has(operation.controller)) continue;\n    bound.add(operation.controller);\n    const file = source.mainControllerFile(operation.controller);\n    router.registerControllerLoader(operation.controller, () => importer(file));\n  }\n  router.loadOperations(operations);\n  router.validateControllers();\n  return router;\n}\n\nasync function runCompose(\n  root: IContainer,\n  source: WoodConfigSource,\n  context: WoodComposeContext,\n): Promise<WoodComposeResult | null> {\n  const composePath = source.hookModule(source.config.main.testing?.compose);\n  if (!composePath) return null;\n  const compose = await importDefaultExport<WoodComposeMain>(context.importer, composePath, 'main.testing.compose');\n  if (typeof compose !== 'function') {\n    throw new TestWoodError(`main.testing.compose default export must be a function (${composePath})`);\n  }\n  return (await ExecutionContext.run(root as never, () => compose(root, context))) ?? null;\n}\n\n/**\n * Dispose the main root under its own execution context (service teardown\n * hooks resolve collaborators such as tracers exactly like any other call),\n * naming every instance whose dispose hook failed.\n */\nasync function disposeRoot(env: TestEnvironment): Promise<void> {\n  try {\n    await ExecutionContext.run(env.root as never, () => env.dispose());\n  } catch (error) {\n    const failures = (error as { failures?: Array<{ token: string; error: unknown }> }).failures;\n    if (!Array.isArray(failures)) throw error;\n    const detail = failures\n      .map((failure) => `${failure.token}: ${failure.error instanceof Error ? failure.error.message : String(failure.error)}`)\n      .join('\\n  ');\n    throw new TestWoodError(`main root disposal failed for ${failures.length} instance(s):\\n  ${detail}`);\n  }\n}\n\nfunction assertNoGlobalContainerLeak(before: number, source: WoodConfigSource): void {\n  if (!process.env.VITEST) return;\n  const after = globalRegistrySize();\n  if (after > before) {\n    throw new TestWoodError(\n      `${source.config.main.testing?.compose ?? 'the build'} registered ${after - before} process-global ` +\n      'Wood container(s) (getContainer). Compose on the root the builder hands you so environments stay isolated.',\n    );\n  }\n}\n\n/** Build the environment from an already-resolved selection (split from the builder for budget). */\nasync function assembleEnvironment(\n  state: BuilderState,\n  selection: ResolvedWoodSelection,\n): Promise<TestWoodEnvironment> {\n  const source = loadWoodConfigSource(state.configPath);\n  const operations = selectOperations(source.operations, selection.main);\n  const catalog = selection.pages ? selectCatalog(source.views(), selection.pages) : null;\n\n  const registryBefore = globalRegistrySize();\n  let composed: WoodComposeResult | null = null;\n  let renderer: RendererTier | null = null;\n  const controllerScopes: Array<{ dispose(): Promise<void> }> = [];\n  let router: WoodRouter | null = null;\n  const context: WoodComposeContext = {\n    configPath: source.configPath,\n    configDir: source.configDir,\n    config: source.config,\n    selection,\n    operations,\n    importer: state.importer,\n    call: async <T>(operation: string, input?: unknown): Promise<T> => {\n      if (!router) throw new TestWoodError('compose context call() is available from start() onward, not during compose');\n      const live = router;\n      return (await ExecutionContext.run(env.root as never, () => live.dispatch(operation, input))) as T;\n    },\n  };\n\n  // Production composition lands on the fresh root FIRST; the test's\n  // substitutions are applied on top of it by the ioc builder, so a seam\n  // always shadows what the app registered for the same token.\n  const env: TestEnvironment = await state.ioc.build({\n    prepare: async (root) => {\n      composed = await runCompose(root, source, context);\n    },\n  });\n  const root = env.root;\n\n  const dispose = async (): Promise<void> => {\n    if (renderer) await renderer.dispose();\n    for (const scope of controllerScopes.reverse()) await scope.dispose();\n    await composed?.drain?.();\n    try {\n      await disposeRoot(env);\n    } finally {\n      await composed?.dispose?.();\n    }\n  };\n\n  try {\n    router = buildRouter(root, source, operations, state.importer);\n    await ExecutionContext.run(root as never, () => composed?.start?.());\n    assertNoGlobalContainerLeak(registryBefore, source);\n    if (catalog) {\n      renderer = await buildRendererTier({\n        source,\n        router,\n        catalog,\n        operations,\n        importer: state.importer,\n        hooks: composed,\n        dom: selection.dom,\n      });\n    }\n    return environmentSurface({ root, env, router, operations, renderer, controllerScopes, dispose });\n  } catch (error) {\n    await dispose().catch(() => {});\n    throw error;\n  }\n}\n\ninterface SurfaceParts {\n  root: IContainer;\n  env: TestEnvironment;\n  router: WoodRouter;\n  operations: Map<string, OperationDef>;\n  renderer: RendererTier | null;\n  controllerScopes: Array<{ dispose(): Promise<void> }>;\n  dispose(): Promise<void>;\n}\n\nfunction environmentSurface(parts: SurfaceParts): TestWoodEnvironment {\n  const { root, env, router, operations, renderer, controllerScopes, dispose } = parts;\n  const dom = (): WoodDomDriver => renderer?.dom ?? tierMissing('dom', 'dom driver');\n  const pages = (): RendererTier => renderer ?? tierMissing('pages', 'renderer');\n\n  return {\n    root,\n    router,\n    operations,\n    call: async <T>(operation: string, input?: unknown): Promise<T> => {\n      if (!operations.has(operation)) {\n        throw new TestWoodError(\n          `operation \"${operation}\" is not in the selected aperture; available operations:\\n  ${[...operations.keys()].join('\\n  ')}`,\n        );\n      }\n      return (await ExecutionContext.run(root as never, () => router.dispatch(operation, input))) as T;\n    },\n    controller: async <T>(controller: new (...args: never[]) => T): Promise<T> => {\n      const scope = root.extend();\n      controllerScopes.push(scope as unknown as { dispose(): Promise<void> });\n      if (!scope.isRegistered(controller)) scope.registerClass(controller);\n      return (await scope.get(controller)) as T;\n    },\n    get: async <T>(token: unknown): Promise<T> => (await root.get(token)) as T,\n\n    get frontend() { return pages().frontend; },\n    get events() { return pages().events; },\n    get rendererRoot() { return pages().rendererRoot; },\n    open: async (page, params, query) => pages().open(page, params, query),\n    navigate: async (page, params, query) => pages().navigate(page, params, query),\n    current: () => pages().current(),\n    settle: async () => pages().settle(),\n\n    get target() { return dom().target; },\n    click: async (selector) => dom().click(selector),\n    type: async (selector, text) => dom().type(selector, text),\n    submit: async (selector) => dom().submit(selector),\n    text: async (selector) => dom().text(selector),\n    exists: async (selector) => dom().exists(selector),\n\n    // Method expectations only: `settle()` is the completion contract for\n    // owned renderer work, and a test may legitimately verify while a\n    // deliberately deferred stream is still in flight.\n    verify: () => env.verify(),\n    dispose,\n    [ENV_REGISTRY]: (env as unknown as Record<symbol, unknown>)[ENV_REGISTRY],\n  };\n}\n\nexport class TestWoodBuilder {\n  private constructor(private readonly state: BuilderState) {}\n\n  static create(configPath: string): TestWoodBuilder {\n    if (typeof configPath !== 'string' || !configPath.length) {\n      throw new TestWoodError('testWood(configPath) requires the path to a wood.config.yml');\n    }\n    return new TestWoodBuilder({\n      configPath: path.resolve(configPath),\n      selection: null,\n      ioc: testIoc(),\n      importer: defaultImporter,\n    });\n  }\n\n  /** Declare which tiers exist: `main`, `pages`, `dom`. Replaces any earlier selection. */\n  select(selection: WoodTestSelection): TestWoodBuilder {\n    resolveSelection(selection);\n    return this.derive({ selection });\n  }\n\n  /** Route hook/controller imports through a caller-owned importer (escape hatch). */\n  importer(importer: ModuleImporter): TestWoodBuilder {\n    if (typeof importer !== 'function') throw new TestWoodError('importer() expects a function');\n    return this.derive({ importer });\n  }\n\n  /* ---- Composition: exact @noego/testing semantics on the main root ---- */\n\n  use(preset: UseInput): TestWoodBuilder {\n    return this.derive({ ioc: this.state.ioc.use(preset) });\n  }\n\n  classes(config: ConfigMap<new (...args: any[]) => unknown>): TestWoodBuilder {\n    return this.derive({ ioc: this.state.ioc.classes(config) });\n  }\n\n  functions(config: ConfigMap<(...args: any[]) => any>): TestWoodBuilder {\n    return this.derive({ ioc: this.state.ioc.functions(config) });\n  }\n\n  values(config: ConfigMap<unknown>): TestWoodBuilder {\n    return this.derive({ ioc: this.state.ioc.values(config) });\n  }\n\n  methods(config: MethodsConfig): TestWoodBuilder {\n    return this.derive({ ioc: this.state.ioc.methods(config) });\n  }\n\n  async build(): Promise<TestWoodEnvironment> {\n    if (!this.state.selection) {\n      throw new TestWoodError('select() a tier before build(): { main }, { pages }, or both');\n    }\n    return assembleEnvironment(this.state, resolveSelection(this.state.selection));\n  }\n\n  private derive(patch: Partial<BuilderState>): TestWoodBuilder {\n    return new TestWoodBuilder({ ...this.state, ...patch });\n  }\n}\n\nexport function testWood(configPath: string): TestWoodBuilder {\n  return TestWoodBuilder.create(configPath);\n}\n"],"mappings":"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","names":["root"]}

package/dist/testing/wood_config_source.cjs

@@ -0,0 +1,146 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wood_config_source_exports = {};
+__export(wood_config_source_exports, {
+  defaultImporter: () => defaultImporter,
+  expandOpenapiFiles: () => expandOpenapiFiles,
+  importDefaultExport: () => importDefaultExport,
+  loadWoodConfigSource: () => loadWoodConfigSource
+});
+module.exports = __toCommonJS(wood_config_source_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+var import_glob = require("glob");
+var import_config_parser = require("../config/config_parser.cjs");
+var import_operations_parser = require("../parser/operations_parser.cjs");
+var import_views_parser = require("../parser/views_parser.cjs");
+var import_controller_registration_generator = require("../codegen/controller_registration_generator.cjs");
+var import_test_wood = require("./test_wood.cjs");
+const defaultImporter = (absolutePath) => import(
+  /* @vite-ignore */
+  (0, import_node_url.pathToFileURL)(absolutePath).href
+);
+const GLOB_MAGIC = /[*?[\]{}]/;
+function expandOpenapiFiles(absolutePath) {
+  const doc = import_js_yaml.default.load(import_node_fs.default.readFileSync(absolutePath, "utf-8"));
+  if (!doc || typeof doc !== "object" || !("stitch" in doc)) return [absolutePath];
+  if (!Array.isArray(doc.stitch)) {
+    throw new import_test_wood.TestWoodError(`${absolutePath}: "stitch" must be a list of YAML files or globs`);
+  }
+  const manifestDir = import_node_path.default.dirname(absolutePath);
+  const files = [];
+  for (const entry of doc.stitch) {
+    if (typeof entry !== "string" || !entry.length) {
+      throw new import_test_wood.TestWoodError(`${absolutePath}: every "stitch" entry must be a non-empty string`);
+    }
+    files.push(...expandStitchEntry(entry, manifestDir));
+  }
+  return files;
+}
+function expandStitchEntry(entry, manifestDir) {
+  if (!GLOB_MAGIC.test(entry)) return [import_node_path.default.resolve(manifestDir, entry)];
+  return (0, import_glob.globSync)(entry, { cwd: manifestDir, absolute: true, nodir: true }).sort();
+}
+function loadOperations(files) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    for (const [channel, operation] of (0, import_operations_parser.parseOperations)(import_node_fs.default.readFileSync(file, "utf-8"))) {
+      if (!merged.has(channel)) merged.set(channel, operation);
+    }
+  }
+  return merged;
+}
+function loadViews(files) {
+  const views = [];
+  for (const file of files) {
+    const content = import_node_fs.default.readFileSync(file, "utf-8");
+    if (!/^view:/m.test(content)) continue;
+    views.push(...(0, import_views_parser.parseViews)(content));
+  }
+  return views;
+}
+function loadWoodConfigSource(configPath) {
+  if (typeof configPath !== "string" || !configPath.length) {
+    throw new import_test_wood.TestWoodError("testWood(configPath) requires the path to a wood.config.yml");
+  }
+  const resolvedConfigPath = import_node_path.default.resolve(configPath);
+  if (!import_node_fs.default.existsSync(resolvedConfigPath)) {
+    throw new import_test_wood.TestWoodError(`testWood(configPath): config file not found: ${resolvedConfigPath}`);
+  }
+  const config = (0, import_config_parser.parseConfig)(resolvedConfigPath);
+  const configDir = import_node_path.default.dirname(resolvedConfigPath);
+  const fromConfig = (relative) => import_node_path.default.resolve(configDir, relative);
+  const mainControllersDir = fromConfig(config.main.controllers);
+  const rendererComponentDir = fromConfig(config.renderer.componentDir);
+  let views = null;
+  return {
+    configPath: resolvedConfigPath,
+    configDir,
+    config,
+    operations: loadOperations(expandOpenapiFiles(fromConfig(config.main.openapi))),
+    mainControllersDir,
+    mainMiddlewareDir: fromConfig(config.main.middleware),
+    rendererComponentDir,
+    views: () => {
+      views ?? (views = loadViews(expandOpenapiFiles(fromConfig(config.renderer.openapi))));
+      return views;
+    },
+    mainControllerFile: (identity) => {
+      const file = (0, import_controller_registration_generator.resolveControllerFile)(identity, mainControllersDir);
+      if (file) return file;
+      throw new import_test_wood.TestWoodError(
+        `no controller file for identity "${identity}" under ${mainControllersDir}; looked for:
+  ` + (0, import_controller_registration_generator.controllerFileCandidates)(identity, mainControllersDir).join("\n  ")
+      );
+    },
+    rendererControllerFile: (reference) => {
+      const file = import_node_path.default.resolve(rendererComponentDir, reference);
+      if (import_node_fs.default.existsSync(file)) return file;
+      throw new import_test_wood.TestWoodError(`renderer controller "${reference}" not found at ${file}`);
+    },
+    hookModule: (relative) => relative ? fromConfig(relative) : null
+  };
+}
+async function importDefaultExport(importer, absolutePath, what) {
+  const mod = await importer(absolutePath);
+  if (mod.default === void 0) {
+    throw new import_test_wood.TestWoodError(`${what} module ${absolutePath} has no default export`);
+  }
+  return mod.default;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultImporter,
+  expandOpenapiFiles,
+  importDefaultExport,
+  loadWoodConfigSource
+});
+//# sourceMappingURL=wood_config_source.cjs.map

package/dist/testing/wood_config_source.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/testing/wood_config_source.ts"],"sourcesContent":["/**\n * Config-driven test source for `testWood(configPath)`.\n *\n * Everything a test environment binds is read from the production\n * `wood.config.yml`: operations from `main.openapi` (a single document or a\n * stitch manifest), views from `renderer.openapi`, controller files from\n * `main.controllers` (same candidate rules as codegen) and renderer\n * controllers relative to `renderer.componentDir`. Tests name nothing by\n * hand — a config path is the whole source.\n */\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport yaml from 'js-yaml';\nimport { globSync } from 'glob';\nimport { parseConfig } from '../config/config_parser.cjs';\nimport type { WoodConfig } from '../types/config.cjs';\nimport { parseOperations } from '../parser/operations_parser.cjs';\nimport { parseViews } from '../parser/views_parser.cjs';\nimport type { OperationDef, ViewDef } from '../types/index.cjs';\nimport {\n  controllerFileCandidates,\n  resolveControllerFile,\n} from '../codegen/controller_registration_generator.cjs';\nimport { TestWoodError } from './test_wood.cjs';\n\n/** Imports a module by absolute path; the default keeps the caller's module registry. */\nexport type ModuleImporter = (absolutePath: string) => Promise<unknown>;\n\nexport const defaultImporter: ModuleImporter = (absolutePath) =>\n  import(/* @vite-ignore */ pathToFileURL(absolutePath).href);\n\nexport interface WoodConfigSource {\n  readonly configPath: string;\n  readonly configDir: string;\n  readonly config: WoodConfig;\n  /** Every production operation, stitch order, first declaration wins. */\n  readonly operations: Map<string, OperationDef>;\n  readonly mainControllersDir: string;\n  readonly mainMiddlewareDir: string;\n  readonly rendererComponentDir: string;\n  /** Every production view (parsed on first use — main-only builds never read them). */\n  views(): ViewDef[];\n  /** Absolute file for a main controller identity, or a build error naming the candidates. */\n  mainControllerFile(identity: string): string;\n  /** Absolute file for a renderer controller reference (views `controller:`). */\n  rendererControllerFile(reference: string): string;\n  /** Absolute path of an optional config-relative hook module, if declared. */\n  hookModule(relative: string | undefined): string | null;\n}\n\ninterface StitchManifest {\n  stitch?: unknown;\n}\n\nconst GLOB_MAGIC = /[*?[\\]{}]/;\n\n/**\n * Expand an openapi reference into the ordered list of YAML files it names:\n * a stitch manifest (`stitch: [...]`, entries relative to the manifest, globs\n * allowed) or a single document.\n */\nexport function expandOpenapiFiles(absolutePath: string): string[] {\n  const doc = yaml.load(fs.readFileSync(absolutePath, 'utf-8')) as StitchManifest | null;\n  if (!doc || typeof doc !== 'object' || !('stitch' in doc)) return [absolutePath];\n  if (!Array.isArray(doc.stitch)) {\n    throw new TestWoodError(`${absolutePath}: \"stitch\" must be a list of YAML files or globs`);\n  }\n  const manifestDir = path.dirname(absolutePath);\n  const files: string[] = [];\n  for (const entry of doc.stitch) {\n    if (typeof entry !== 'string' || !entry.length) {\n      throw new TestWoodError(`${absolutePath}: every \"stitch\" entry must be a non-empty string`);\n    }\n    files.push(...expandStitchEntry(entry, manifestDir));\n  }\n  return files;\n}\n\nfunction expandStitchEntry(entry: string, manifestDir: string): string[] {\n  if (!GLOB_MAGIC.test(entry)) return [path.resolve(manifestDir, entry)];\n  return globSync(entry, { cwd: manifestDir, absolute: true, nodir: true }).sort();\n}\n\nfunction loadOperations(files: string[]): Map<string, OperationDef> {\n  const merged = new Map<string, OperationDef>();\n  for (const file of files) {\n    for (const [channel, operation] of parseOperations(fs.readFileSync(file, 'utf-8'))) {\n      if (!merged.has(channel)) merged.set(channel, operation);\n    }\n  }\n  return merged;\n}\n\n/** Views documents only; a stitched directory may hold other YAML kinds. */\nfunction loadViews(files: string[]): ViewDef[] {\n  const views: ViewDef[] = [];\n  for (const file of files) {\n    const content = fs.readFileSync(file, 'utf-8');\n    if (!/^view:/m.test(content)) continue;\n    views.push(...parseViews(content));\n  }\n  return views;\n}\n\nexport function loadWoodConfigSource(configPath: string): WoodConfigSource {\n  if (typeof configPath !== 'string' || !configPath.length) {\n    throw new TestWoodError('testWood(configPath) requires the path to a wood.config.yml');\n  }\n  const resolvedConfigPath = path.resolve(configPath);\n  if (!fs.existsSync(resolvedConfigPath)) {\n    throw new TestWoodError(`testWood(configPath): config file not found: ${resolvedConfigPath}`);\n  }\n  const config = parseConfig(resolvedConfigPath);\n  const configDir = path.dirname(resolvedConfigPath);\n  const fromConfig = (relative: string): string => path.resolve(configDir, relative);\n\n  const mainControllersDir = fromConfig(config.main.controllers);\n  const rendererComponentDir = fromConfig(config.renderer.componentDir);\n  let views: ViewDef[] | null = null;\n\n  return {\n    configPath: resolvedConfigPath,\n    configDir,\n    config,\n    operations: loadOperations(expandOpenapiFiles(fromConfig(config.main.openapi))),\n    mainControllersDir,\n    mainMiddlewareDir: fromConfig(config.main.middleware),\n    rendererComponentDir,\n    views: () => {\n      views ??= loadViews(expandOpenapiFiles(fromConfig(config.renderer.openapi)));\n      return views;\n    },\n    mainControllerFile: (identity) => {\n      const file = resolveControllerFile(identity, mainControllersDir);\n      if (file) return file;\n      throw new TestWoodError(\n        `no controller file for identity \"${identity}\" under ${mainControllersDir}; looked for:\\n  ` +\n        controllerFileCandidates(identity, mainControllersDir).join('\\n  '),\n      );\n    },\n    rendererControllerFile: (reference) => {\n      const file = path.resolve(rendererComponentDir, reference);\n      if (fs.existsSync(file)) return file;\n      throw new TestWoodError(`renderer controller \"${reference}\" not found at ${file}`);\n    },\n    hookModule: (relative) => (relative ? fromConfig(relative) : null),\n  };\n}\n\n/** Import a hook module declared in the config and return its default export. */\nexport async function importDefaultExport<T>(\n  importer: ModuleImporter,\n  absolutePath: string,\n  what: string,\n): Promise<T> {\n  const mod = (await importer(absolutePath)) as { default?: unknown };\n  if (mod.default === undefined) {\n    throw new TestWoodError(`${what} module ${absolutePath} has no default export`);\n  }\n  return mod.default as T;\n}\n"],"mappings":"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","names":["yaml","fs","path"]}

package/dist/testing/wood_config_source.d.cts

@@ -0,0 +1,36 @@
+import { WoodConfig } from '../types/config.cjs';
+import { OperationDef } from '../types/operations.cjs';
+import { ViewDef } from '../types/views.cjs';
+
+/** Imports a module by absolute path; the default keeps the caller's module registry. */
+type ModuleImporter = (absolutePath: string) => Promise<unknown>;
+declare const defaultImporter: ModuleImporter;
+interface WoodConfigSource {
+    readonly configPath: string;
+    readonly configDir: string;
+    readonly config: WoodConfig;
+    /** Every production operation, stitch order, first declaration wins. */
+    readonly operations: Map<string, OperationDef>;
+    readonly mainControllersDir: string;
+    readonly mainMiddlewareDir: string;
+    readonly rendererComponentDir: string;
+    /** Every production view (parsed on first use — main-only builds never read them). */
+    views(): ViewDef[];
+    /** Absolute file for a main controller identity, or a build error naming the candidates. */
+    mainControllerFile(identity: string): string;
+    /** Absolute file for a renderer controller reference (views `controller:`). */
+    rendererControllerFile(reference: string): string;
+    /** Absolute path of an optional config-relative hook module, if declared. */
+    hookModule(relative: string | undefined): string | null;
+}
+/**
+ * Expand an openapi reference into the ordered list of YAML files it names:
+ * a stitch manifest (`stitch: [...]`, entries relative to the manifest, globs
+ * allowed) or a single document.
+ */
+declare function expandOpenapiFiles(absolutePath: string): string[];
+declare function loadWoodConfigSource(configPath: string): WoodConfigSource;
+/** Import a hook module declared in the config and return its default export. */
+declare function importDefaultExport<T>(importer: ModuleImporter, absolutePath: string, what: string): Promise<T>;
+
+export { type ModuleImporter, type WoodConfigSource, defaultImporter, expandOpenapiFiles, importDefaultExport, loadWoodConfigSource };

package/dist/testing/wood_config_source.d.ts

@@ -0,0 +1,36 @@
+import { WoodConfig } from '../types/config.js';
+import { OperationDef } from '../types/operations.js';
+import { ViewDef } from '../types/views.js';
+
+/** Imports a module by absolute path; the default keeps the caller's module registry. */
+type ModuleImporter = (absolutePath: string) => Promise<unknown>;
+declare const defaultImporter: ModuleImporter;
+interface WoodConfigSource {
+    readonly configPath: string;
+    readonly configDir: string;
+    readonly config: WoodConfig;
+    /** Every production operation, stitch order, first declaration wins. */
+    readonly operations: Map<string, OperationDef>;
+    readonly mainControllersDir: string;
+    readonly mainMiddlewareDir: string;
+    readonly rendererComponentDir: string;
+    /** Every production view (parsed on first use — main-only builds never read them). */
+    views(): ViewDef[];
+    /** Absolute file for a main controller identity, or a build error naming the candidates. */
+    mainControllerFile(identity: string): string;
+    /** Absolute file for a renderer controller reference (views `controller:`). */
+    rendererControllerFile(reference: string): string;
+    /** Absolute path of an optional config-relative hook module, if declared. */
+    hookModule(relative: string | undefined): string | null;
+}
+/**
+ * Expand an openapi reference into the ordered list of YAML files it names:
+ * a stitch manifest (`stitch: [...]`, entries relative to the manifest, globs
+ * allowed) or a single document.
+ */
+declare function expandOpenapiFiles(absolutePath: string): string[];
+declare function loadWoodConfigSource(configPath: string): WoodConfigSource;
+/** Import a hook module declared in the config and return its default export. */
+declare function importDefaultExport<T>(importer: ModuleImporter, absolutePath: string, what: string): Promise<T>;
+
+export { type ModuleImporter, type WoodConfigSource, defaultImporter, expandOpenapiFiles, importDefaultExport, loadWoodConfigSource };

package/dist/testing/wood_config_source.js

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import yaml from "js-yaml";
+import { globSync } from "glob";
+import { parseConfig } from "../config/config_parser.js";
+import { parseOperations } from "../parser/operations_parser.js";
+import { parseViews } from "../parser/views_parser.js";
+import {
+  controllerFileCandidates,
+  resolveControllerFile
+} from "../codegen/controller_registration_generator.js";
+import { TestWoodError } from "./test_wood.js";
+const defaultImporter = (absolutePath) => import(
+  /* @vite-ignore */
+  pathToFileURL(absolutePath).href
+);
+const GLOB_MAGIC = /[*?[\]{}]/;
+function expandOpenapiFiles(absolutePath) {
+  const doc = yaml.load(fs.readFileSync(absolutePath, "utf-8"));
+  if (!doc || typeof doc !== "object" || !("stitch" in doc)) return [absolutePath];
+  if (!Array.isArray(doc.stitch)) {
+    throw new TestWoodError(`${absolutePath}: "stitch" must be a list of YAML files or globs`);
+  }
+  const manifestDir = path.dirname(absolutePath);
+  const files = [];
+  for (const entry of doc.stitch) {
+    if (typeof entry !== "string" || !entry.length) {
+      throw new TestWoodError(`${absolutePath}: every "stitch" entry must be a non-empty string`);
+    }
+    files.push(...expandStitchEntry(entry, manifestDir));
+  }
+  return files;
+}
+function expandStitchEntry(entry, manifestDir) {
+  if (!GLOB_MAGIC.test(entry)) return [path.resolve(manifestDir, entry)];
+  return globSync(entry, { cwd: manifestDir, absolute: true, nodir: true }).sort();
+}
+function loadOperations(files) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    for (const [channel, operation] of parseOperations(fs.readFileSync(file, "utf-8"))) {
+      if (!merged.has(channel)) merged.set(channel, operation);
+    }
+  }
+  return merged;
+}
+function loadViews(files) {
+  const views = [];
+  for (const file of files) {
+    const content = fs.readFileSync(file, "utf-8");
+    if (!/^view:/m.test(content)) continue;
+    views.push(...parseViews(content));
+  }
+  return views;
+}
+function loadWoodConfigSource(configPath) {
+  if (typeof configPath !== "string" || !configPath.length) {
+    throw new TestWoodError("testWood(configPath) requires the path to a wood.config.yml");
+  }
+  const resolvedConfigPath = path.resolve(configPath);
+  if (!fs.existsSync(resolvedConfigPath)) {
+    throw new TestWoodError(`testWood(configPath): config file not found: ${resolvedConfigPath}`);
+  }
+  const config = parseConfig(resolvedConfigPath);
+  const configDir = path.dirname(resolvedConfigPath);
+  const fromConfig = (relative) => path.resolve(configDir, relative);
+  const mainControllersDir = fromConfig(config.main.controllers);
+  const rendererComponentDir = fromConfig(config.renderer.componentDir);
+  let views = null;
+  return {
+    configPath: resolvedConfigPath,
+    configDir,
+    config,
+    operations: loadOperations(expandOpenapiFiles(fromConfig(config.main.openapi))),
+    mainControllersDir,
+    mainMiddlewareDir: fromConfig(config.main.middleware),
+    rendererComponentDir,
+    views: () => {
+      views ?? (views = loadViews(expandOpenapiFiles(fromConfig(config.renderer.openapi))));
+      return views;
+    },
+    mainControllerFile: (identity) => {
+      const file = resolveControllerFile(identity, mainControllersDir);
+      if (file) return file;
+      throw new TestWoodError(
+        `no controller file for identity "${identity}" under ${mainControllersDir}; looked for:
+  ` + controllerFileCandidates(identity, mainControllersDir).join("\n  ")
+      );
+    },
+    rendererControllerFile: (reference) => {
+      const file = path.resolve(rendererComponentDir, reference);
+      if (fs.existsSync(file)) return file;
+      throw new TestWoodError(`renderer controller "${reference}" not found at ${file}`);
+    },
+    hookModule: (relative) => relative ? fromConfig(relative) : null
+  };
+}
+async function importDefaultExport(importer, absolutePath, what) {
+  const mod = await importer(absolutePath);
+  if (mod.default === void 0) {
+    throw new TestWoodError(`${what} module ${absolutePath} has no default export`);
+  }
+  return mod.default;
+}
+export {
+  defaultImporter,
+  expandOpenapiFiles,
+  importDefaultExport,
+  loadWoodConfigSource
+};
+//# sourceMappingURL=wood_config_source.js.map