@kinotic-ai/spawn 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,126 +1,6 @@
-// packages/spawn/src/api/SpawnEngine.ts
-import { Liquid } from "liquidjs";
-import { z } from "zod";
-var PropertySchemaSchema = z.object({
-  type: z.enum(["string", "number", "integer", "boolean"]).optional(),
-  description: z.string().optional(),
-  default: z.union([z.string(), z.number(), z.boolean()]).optional(),
-  enum: z.array(z.string()).optional()
-});
-var SpawnConfigSchema = z.object({
-  inherits: z.string().optional(),
-  globals: z.record(z.string(), z.unknown()).optional(),
-  propertySchema: z.record(z.string(), PropertySchemaSchema).optional()
-});
-var IGNORED_FILE_NAMES = ["spawn.json", ".DS_Store"];
-function upperFirst(s) {
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}
-function camelCase(s) {
-  return s.replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toLowerCase());
-}
-
-class SpawnEngine {
-  engine;
-  constructor() {
-    this.engine = new Liquid({ cache: true, strictVariables: true });
-    this.engine.registerFilter("packageToPath", (v) => v.replaceAll(".", "/"));
-    this.engine.registerFilter("encodePackage", (v) => {
-      v = v.replaceAll("-", "_");
-      v = v.replace(/\.(\d+)/g, "._$1");
-      return v;
-    });
-    this.engine.registerFilter("camelCase", (v) => camelCase(v));
-    this.engine.registerFilter("upperFirst", (v) => upperFirst(v));
-  }
-  async renderSpawn(spawn, options) {
-    const trees = [spawn];
-    const configs = [];
-    let currentConfig = this.parseConfig(spawn);
-    if (currentConfig) {
-      configs.push(currentConfig);
-    }
-    while (currentConfig?.inherits) {
-      if (!options?.loadInherited) {
-        throw new Error(`Spawn inherits '${currentConfig.inherits}' but no loadInherited callback was provided`);
-      }
-      const inherited = await options.loadInherited(currentConfig.inherits);
-      trees.push(inherited);
-      currentConfig = this.parseConfig(inherited);
-      if (currentConfig) {
-        configs.push(currentConfig);
-      }
-    }
-    let globals = {};
-    let propertySchemas = {};
-    for (const config of [...configs].reverse()) {
-      if (config.globals) {
-        globals = { ...globals, ...config.globals };
-      }
-      if (config.propertySchema) {
-        propertySchemas = { ...propertySchemas, ...config.propertySchema };
-      }
-    }
-    let context = { ...globals, ...options?.context };
-    context = await this.resolveMissingProperties(propertySchemas, context, options?.propertyResolver);
-    const files = {};
-    const sources = {};
-    for (const tree of [...trees].reverse()) {
-      for (const source of Object.keys(tree).sort()) {
-        const fileName = source.substring(source.lastIndexOf("/") + 1);
-        if (IGNORED_FILE_NAMES.includes(fileName)) {
-          continue;
-        }
-        let destination = source;
-        if (destination.includes("{{")) {
-          destination = await this.engine.parseAndRender(destination, context);
-        }
-        let content = tree[source];
-        if (destination.endsWith(".liquid")) {
-          destination = destination.substring(0, destination.length - 7);
-          if (typeof content !== "string") {
-            throw new Error(`Template ${source} must contain text content`);
-          }
-          content = await this.engine.parseAndRender(content, context);
-        }
-        files[destination] = content;
-        sources[destination] = source;
-      }
-    }
-    return { files, sources, context };
-  }
-  parseConfig(tree) {
-    const raw = tree["spawn.json"];
-    if (raw === undefined) {
-      return;
-    }
-    const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
-    return SpawnConfigSchema.parse(JSON.parse(text));
-  }
-  async resolveMissingProperties(propertySchemas, context, resolver) {
-    const ret = { ...context };
-    for (const key in propertySchemas) {
-      if (!Object.prototype.hasOwnProperty.call(ret, key)) {
-        if (!resolver) {
-          throw new Error(`No value provided for required property '${key}'`);
-        }
-        const schema = propertySchemas[key];
-        let message;
-        if (schema.description?.includes("{{")) {
-          message = this.engine.parseAndRenderSync(schema.description, ret);
-        } else {
-          message = schema.description ?? key;
-        }
-        let defaultValue = schema.default;
-        if (typeof schema.default === "string" && schema.default.includes("{{")) {
-          defaultValue = this.engine.parseAndRenderSync(schema.default, ret);
-        }
-        ret[key] = await resolver.resolve(key, schema, message, defaultValue);
-      }
-    }
-    return ret;
-  }
-}
+import {
+  SpawnEngine
+} from "./shared/spawn-1h1k8w8r.js";
 export {
   SpawnEngine
 };

package/dist/node/index.cjs

@@ -0,0 +1,311 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/spawn/src/node/index.ts
+var exports_node = {};
+__export(exports_node, {
+  lintSpawnDir: () => lintSpawnDir,
+  assertPathWithin: () => assertPathWithin,
+  NodeSpawnRenderer: () => NodeSpawnRenderer
+});
+module.exports = __toCommonJS(exports_node);
+var import_node_fs = __toESM(require("node:fs"));
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_path = __toESM(require("node:path"));
+
+// packages/spawn/src/api/SpawnEngine.ts
+var import_liquidjs = require("liquidjs");
+var import_zod = require("zod");
+var PropertySchemaSchema = import_zod.z.object({
+  type: import_zod.z.enum(["string", "number", "integer", "boolean"]).optional(),
+  description: import_zod.z.string().optional(),
+  default: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]).optional(),
+  enum: import_zod.z.array(import_zod.z.string()).optional()
+});
+var SpawnConfigSchema = import_zod.z.object({
+  inherits: import_zod.z.string().optional(),
+  globals: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  propertySchema: import_zod.z.record(import_zod.z.string(), PropertySchemaSchema).optional()
+});
+var IGNORED_FILE_NAMES = ["spawn.json", ".DS_Store"];
+function upperFirst(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function camelCase(s) {
+  return s.replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toLowerCase());
+}
+
+class SpawnEngine {
+  engine;
+  constructor() {
+    this.engine = new import_liquidjs.Liquid({ cache: true, strictVariables: true });
+    this.engine.registerFilter("packageToPath", (v) => v.replaceAll(".", "/"));
+    this.engine.registerFilter("encodePackage", (v) => {
+      v = v.replaceAll("-", "_");
+      v = v.replace(/\.(\d+)/g, "._$1");
+      return v;
+    });
+    this.engine.registerFilter("camelCase", (v) => camelCase(v));
+    this.engine.registerFilter("upperFirst", (v) => upperFirst(v));
+  }
+  async renderSpawn(spawn, options) {
+    const { trees, configs } = await this.walkInheritance(spawn, options?.loadInherited);
+    let globals = {};
+    let propertySchemas = {};
+    for (const config of [...configs].reverse()) {
+      if (config.globals) {
+        globals = { ...globals, ...config.globals };
+      }
+      if (config.propertySchema) {
+        propertySchemas = { ...propertySchemas, ...config.propertySchema };
+      }
+    }
+    let context = { ...globals, ...options?.context };
+    context = await this.resolveMissingProperties(propertySchemas, context, options?.propertyResolver);
+    const files = {};
+    const sources = {};
+    for (const tree of [...trees].reverse()) {
+      for (const source of Object.keys(tree).sort()) {
+        const fileName = source.substring(source.lastIndexOf("/") + 1);
+        if (IGNORED_FILE_NAMES.includes(fileName)) {
+          continue;
+        }
+        let destination = source;
+        if (destination.includes("{{")) {
+          destination = await this.engine.parseAndRender(destination, context);
+        }
+        let content = tree[source];
+        if (destination.endsWith(".liquid")) {
+          destination = destination.substring(0, destination.length - 7);
+          if (typeof content !== "string") {
+            throw new Error(`Template ${source} must contain text content`);
+          }
+          content = await this.engine.parseAndRender(content, context);
+        }
+        files[destination] = content;
+        sources[destination] = source;
+      }
+    }
+    return { files, sources, context };
+  }
+  async lint(spawn, options) {
+    const { trees, configs } = await this.walkInheritance(spawn, options?.loadInherited);
+    const declared = new Set;
+    for (const config of configs) {
+      if (config.globals) {
+        Object.keys(config.globals).forEach((key) => declared.add(key));
+      }
+      if (config.propertySchema) {
+        Object.keys(config.propertySchema).forEach((key) => declared.add(key));
+      }
+    }
+    const usedIn = new Map;
+    const record = (name, file) => {
+      let files = usedIn.get(name);
+      if (!files) {
+        files = new Set;
+        usedIn.set(name, files);
+      }
+      files.add(file);
+    };
+    const externalVars = (template) => Object.keys(this.engine.parseAndAnalyzeSync(template, undefined, { partials: false }).globals);
+    for (const tree of trees) {
+      for (const source of Object.keys(tree)) {
+        const fileName = source.substring(source.lastIndexOf("/") + 1);
+        if (IGNORED_FILE_NAMES.includes(fileName)) {
+          continue;
+        }
+        externalVars(source).forEach((name) => record(name, source));
+        const content = tree[source];
+        if (source.endsWith(".liquid") && typeof content === "string") {
+          externalVars(content).forEach((name) => record(name, source));
+        }
+      }
+    }
+    const undeclared = [];
+    for (const [name, files] of usedIn) {
+      if (!declared.has(name)) {
+        undeclared.push({ name, files: [...files].sort() });
+      }
+    }
+    undeclared.sort((a, b) => a.name.localeCompare(b.name));
+    return { undeclared };
+  }
+  async walkInheritance(spawn, loadInherited) {
+    const trees = [spawn];
+    const configs = [];
+    let currentConfig = this.parseConfig(spawn);
+    if (currentConfig) {
+      configs.push(currentConfig);
+    }
+    while (currentConfig?.inherits) {
+      if (!loadInherited) {
+        throw new Error(`Spawn inherits '${currentConfig.inherits}' but no loadInherited callback was provided`);
+      }
+      const inherited = await loadInherited(currentConfig.inherits);
+      trees.push(inherited);
+      currentConfig = this.parseConfig(inherited);
+      if (currentConfig) {
+        configs.push(currentConfig);
+      }
+    }
+    return { trees, configs };
+  }
+  parseConfig(tree) {
+    const raw = tree["spawn.json"];
+    if (raw === undefined) {
+      return;
+    }
+    const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+    return SpawnConfigSchema.parse(JSON.parse(text));
+  }
+  async resolveMissingProperties(propertySchemas, context, resolver) {
+    const ret = { ...context };
+    for (const key in propertySchemas) {
+      if (!Object.prototype.hasOwnProperty.call(ret, key)) {
+        if (!resolver) {
+          throw new Error(`No value provided for required property '${key}'`);
+        }
+        const schema = propertySchemas[key];
+        let message;
+        if (schema.description?.includes("{{")) {
+          message = this.engine.parseAndRenderSync(schema.description, ret);
+        } else {
+          message = schema.description ?? key;
+        }
+        let defaultValue = schema.default;
+        if (typeof schema.default === "string" && schema.default.includes("{{")) {
+          defaultValue = this.engine.parseAndRenderSync(schema.default, ret);
+        }
+        ret[key] = await resolver.resolve(key, schema, message, defaultValue);
+      }
+    }
+    return ret;
+  }
+}
+
+// packages/spawn/src/node/index.ts
+function assertContained(root, resolved) {
+  const rel = import_node_path.default.relative(root, resolved);
+  if (rel.startsWith("..") || import_node_path.default.isAbsolute(rel)) {
+    throw new Error(`Path escapes ${root}: ${resolved}`);
+  }
+  return resolved;
+}
+function assertPathWithin(root, target) {
+  return assertContained(root, import_node_path.default.resolve(root, target));
+}
+async function loadSpawnTree(dir) {
+  const tree = {};
+  const entries = await import_promises.default.readdir(dir, { recursive: true, withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    const filePath = import_node_path.default.join(entry.parentPath, entry.name);
+    const treePath = import_node_path.default.relative(dir, filePath).split(import_node_path.default.sep).join("/");
+    if (treePath.endsWith(".liquid")) {
+      tree[treePath] = await import_promises.default.readFile(filePath, { encoding: "utf8" });
+    } else {
+      tree[treePath] = await import_promises.default.readFile(filePath);
+    }
+  }
+  return tree;
+}
+function diskInheritanceLoader(spawnRoot) {
+  let currentDir = spawnRoot;
+  return async (ref) => {
+    currentDir = assertContained(spawnRoot, import_node_path.default.resolve(currentDir, ref));
+    if (!import_node_fs.default.existsSync(import_node_path.default.resolve(currentDir, "spawn.json"))) {
+      throw new Error(`Inherited spawn ${import_node_path.default.resolve(currentDir, "spawn.json")} does not exist`);
+    }
+    return loadSpawnTree(currentDir);
+  };
+}
+async function lintSpawnDir(dir) {
+  return new SpawnEngine().lint(await loadSpawnTree(dir), { loadInherited: diskInheritanceLoader(dir) });
+}
+
+class NodeSpawnRenderer {
+  engine = new SpawnEngine;
+  async render(spawnDir, destination, options) {
+    if (import_node_fs.default.existsSync(destination)) {
+      throw new Error(`The target directory ${destination} already exists`);
+    }
+    const result = await this.engine.renderSpawn(await loadSpawnTree(spawnDir), {
+      context: options?.context,
+      propertyResolver: options?.propertyResolver,
+      loadInherited: diskInheritanceLoader(spawnDir)
+    });
+    await this.writeSpawnTree(result.files, destination);
+    return result.context;
+  }
+  async writeSpawnTree(tree, destination) {
+    await import_promises.default.mkdir(destination, { recursive: true });
+    for (const [treePath, content] of Object.entries(tree)) {
+      const filePath = assertPathWithin(destination, treePath);
+      await import_promises.default.mkdir(import_node_path.default.dirname(filePath), { recursive: true });
+      await import_promises.default.writeFile(filePath, content);
+    }
+  }
+}

package/dist/node/index.d.cts

@@ -0,0 +1,102 @@
+/**
+* Declares a single property a spawn needs to render, as found in a
+* spawn.json propertySchema. Descriptions and defaults may contain liquid
+* expressions, which are rendered against the context resolved so far before
+* the property is requested from a {@link PropertyResolver}.
+*/
+interface PropertySchema {
+	type?: "string" | "number" | "integer" | "boolean";
+	description?: string;
+	default?: string | number | boolean;
+	enum?: string[];
+}
+/**
+* Supplies values for properties declared in a spawn's propertySchema that are
+* absent from the render context. An interactive host can prompt the user; a
+* non-interactive host can omit the resolver entirely, in which case rendering
+* fails on the first missing property.
+*/
+interface PropertyResolver {
+	/**
+	* Returns the value to use for {@code key}.
+	*
+	* @param key the property name as declared in the propertySchema
+	* @param schema the declaration for the property (type, enum, etc.)
+	* @param message the property description with any liquid expressions already
+	*        rendered against the context resolved so far, or the key when the
+	*        schema has no description
+	* @param defaultValue the schema default with any liquid expressions already
+	*        rendered, or undefined when the schema has no default
+	*/
+	resolve(key: string, schema: PropertySchema, message: string, defaultValue?: unknown): Promise<unknown>;
+}
+/**
+* A variable referenced in a spawn's templates that is declared neither in
+* propertySchema nor in globals, reported by {@link SpawnEngine#lint}.
+*
+* @see SpawnLintResult
+*/
+interface UndeclaredVariable {
+	/** The variable name as referenced in the templates. */
+	name: string;
+	/**
+	* The spawn paths where the variable appears — file contents for
+	* {@code .liquid} files, and path templates for any file whose path contains
+	* the variable.
+	*/
+	files: string[];
+}
+/**
+* The outcome of {@link SpawnEngine#lint}: the variables a spawn's templates
+* reference that are not declared in propertySchema or globals. A spawn is
+* lint-clean when {@code undeclared} is empty.
+*/
+interface SpawnLintResult {
+	/** Referenced-but-undeclared variables, sorted by name. */
+	undeclared: UndeclaredVariable[];
+}
+/**
+* Resolves {@code target} against {@code root} and asserts the result stays at or
+* below {@code root}, so a path can't escape the directory being operated in via
+* {@code ..} (whether authored that way or injected through a property value).
+* Internal {@code ../} that stays within {@code root} is allowed.
+*/
+declare function assertPathWithin(root: string, target: string): string;
+/**
+* Reports the variables a spawn directory's templates reference that are
+* declared neither in propertySchema nor in globals (following inheritance on
+* disk, confined to {@code dir}). See {@link SpawnEngine#lint}.
+*/
+declare function lintSpawnDir(dir: string): Promise<SpawnLintResult>;
+/**
+* Options for {@link NodeSpawnRenderer#render}.
+*/
+interface NodeRenderOptions {
+	/** Values made available to the templates. */
+	context?: Record<string, unknown>;
+	/**
+	* Supplies values for propertySchema entries missing from the context. With no
+	* resolver, a missing required property fails the render.
+	*/
+	propertyResolver?: PropertyResolver;
+}
+/**
+* Renders a Spawn from a directory on disk to another directory, using the
+* host-agnostic {@link SpawnEngine} for the rendering and confining all reads
+* (inheritance) to the source and all writes to the destination. The reusable
+* filesystem adapter so node/bun callers don't reimplement the disk load/write
+* or the directory-traversal guards.
+*/
+declare class NodeSpawnRenderer {
+	private engine;
+	/**
+	* Renders the spawn at {@code spawnDir} into {@code destination}, which must not
+	* exist yet, and returns the full context used.
+	*
+	* @throws Error when {@code destination} already exists, an inheritance ref or a
+	*         rendered path escapes its root, or a required property has no value
+	*/
+	render(spawnDir: string, destination: string, options?: NodeRenderOptions): Promise<Record<string, unknown>>;
+	private writeSpawnTree;
+}
+export { lintSpawnDir, assertPathWithin, NodeSpawnRenderer, NodeRenderOptions };

package/dist/node/index.d.ts

@@ -0,0 +1,102 @@
+/**
+* Declares a single property a spawn needs to render, as found in a
+* spawn.json propertySchema. Descriptions and defaults may contain liquid
+* expressions, which are rendered against the context resolved so far before
+* the property is requested from a {@link PropertyResolver}.
+*/
+interface PropertySchema {
+	type?: "string" | "number" | "integer" | "boolean";
+	description?: string;
+	default?: string | number | boolean;
+	enum?: string[];
+}
+/**
+* Supplies values for properties declared in a spawn's propertySchema that are
+* absent from the render context. An interactive host can prompt the user; a
+* non-interactive host can omit the resolver entirely, in which case rendering
+* fails on the first missing property.
+*/
+interface PropertyResolver {
+	/**
+	* Returns the value to use for {@code key}.
+	*
+	* @param key the property name as declared in the propertySchema
+	* @param schema the declaration for the property (type, enum, etc.)
+	* @param message the property description with any liquid expressions already
+	*        rendered against the context resolved so far, or the key when the
+	*        schema has no description
+	* @param defaultValue the schema default with any liquid expressions already
+	*        rendered, or undefined when the schema has no default
+	*/
+	resolve(key: string, schema: PropertySchema, message: string, defaultValue?: unknown): Promise<unknown>;
+}
+/**
+* A variable referenced in a spawn's templates that is declared neither in
+* propertySchema nor in globals, reported by {@link SpawnEngine#lint}.
+*
+* @see SpawnLintResult
+*/
+interface UndeclaredVariable {
+	/** The variable name as referenced in the templates. */
+	name: string;
+	/**
+	* The spawn paths where the variable appears — file contents for
+	* {@code .liquid} files, and path templates for any file whose path contains
+	* the variable.
+	*/
+	files: string[];
+}
+/**
+* The outcome of {@link SpawnEngine#lint}: the variables a spawn's templates
+* reference that are not declared in propertySchema or globals. A spawn is
+* lint-clean when {@code undeclared} is empty.
+*/
+interface SpawnLintResult {
+	/** Referenced-but-undeclared variables, sorted by name. */
+	undeclared: UndeclaredVariable[];
+}
+/**
+* Resolves {@code target} against {@code root} and asserts the result stays at or
+* below {@code root}, so a path can't escape the directory being operated in via
+* {@code ..} (whether authored that way or injected through a property value).
+* Internal {@code ../} that stays within {@code root} is allowed.
+*/
+declare function assertPathWithin(root: string, target: string): string;
+/**
+* Reports the variables a spawn directory's templates reference that are
+* declared neither in propertySchema nor in globals (following inheritance on
+* disk, confined to {@code dir}). See {@link SpawnEngine#lint}.
+*/
+declare function lintSpawnDir(dir: string): Promise<SpawnLintResult>;
+/**
+* Options for {@link NodeSpawnRenderer#render}.
+*/
+interface NodeRenderOptions {
+	/** Values made available to the templates. */
+	context?: Record<string, unknown>;
+	/**
+	* Supplies values for propertySchema entries missing from the context. With no
+	* resolver, a missing required property fails the render.
+	*/
+	propertyResolver?: PropertyResolver;
+}
+/**
+* Renders a Spawn from a directory on disk to another directory, using the
+* host-agnostic {@link SpawnEngine} for the rendering and confining all reads
+* (inheritance) to the source and all writes to the destination. The reusable
+* filesystem adapter so node/bun callers don't reimplement the disk load/write
+* or the directory-traversal guards.
+*/
+declare class NodeSpawnRenderer {
+	private engine;
+	/**
+	* Renders the spawn at {@code spawnDir} into {@code destination}, which must not
+	* exist yet, and returns the full context used.
+	*
+	* @throws Error when {@code destination} already exists, an inheritance ref or a
+	*         rendered path escapes its root, or a required property has no value
+	*/
+	render(spawnDir: string, destination: string, options?: NodeRenderOptions): Promise<Record<string, unknown>>;
+	private writeSpawnTree;
+}
+export { lintSpawnDir, assertPathWithin, NodeSpawnRenderer, NodeRenderOptions };