@gregorlohaus/tdir 0.1.2 → 0.1.4

package/README.md

@@ -1,6 +1,6 @@
 # tdir
 
-Treat a directory as a template. File paths and contents support conditionals (`@if`/`@elseif`/`@else`) and variable substitution (`@var`). Provide a Zod schema and tdir validates it matches the template at setup time, then validates context at render time.
+Treat a directory as a template. File paths and text file contents support conditionals (`@if`/`@elseif`/`@else`) and variable substitution (`@var`). Provide a Zod schema and tdir validates it matches the template at setup time, then validates context at render time. Binary files are copied through unchanged.
 
 ## Install
 
@@ -32,7 +32,7 @@ Where `index.html` contains:
 Render it:
 
 ```ts
-import { initRenderer } from "tdir"
+import { initRenderer } from "@gregorlohaus/tdir"
 import { z } from "zod"
 
 const createRenderer = initRenderer("./templates")
@@ -58,7 +58,7 @@ render("./output", {
 
 | Directive | Description |
 |---|---|
-| `<@if(context.x)>` | Conditional block — truthy check (must end with `<@endif>`) |
+| `<@if(context.x)>` | Conditional block — boolean check (must end with `<@endif>`) |
 | `<@if(eq(context.x,"value"))>` | Conditional block — string equality check |
 | `<@elseif(context.y)>` | Else-if branch (same forms as `@if`) |
 | `<@else>` | Else branch |
@@ -70,7 +70,7 @@ render("./output", {
 
 | Directive | Description |
 |---|---|
-| `<@if(context.x)>dirname` | Conditionally include directory/file (truthy check) |
+| `<@if(context.x)>dirname` | Conditionally include directory/file (boolean check) |
 | `<@if(eq(context.x,"value"))>dirname` | Conditionally include by string equality |
 | `<@var(context.x)>` | Dynamic directory/file name |
 
@@ -81,7 +81,7 @@ These can be combined: `<@if(context.web.create)><@var(context.web.dir)>` create
 `createRenderer` validates that your Zod schema matches the template variables. Mismatches throw `SchemaMismatchError`:
 
 ```ts
-import { initRenderer, SchemaMismatchError } from "tdir"
+import { initRenderer, SchemaMismatchError } from "@gregorlohaus/tdir"
 import { z } from "zod"
 
 const createRenderer = initRenderer("./templates")
@@ -92,14 +92,14 @@ createRenderer(z.object({
   web: z.string(), // wrong type
   header: z.object({ show: z.boolean(), title: z.string() })
 }))
-// SchemaMismatchError: Shema doesnt match used template variables: web: expected z.boolean() but schema has z.string()
+// SchemaMismatchError: Schema doesn't match used template variables: web: expected z.boolean() but schema has z.string()
 
 // Schema is missing fields used in templates -- throws SchemaMismatchError
 createRenderer(z.object({
   web: z.boolean()
   // missing header
 }))
-// SchemaMismatchError: Shema doesnt match used template variables: header: missing in schema
+// SchemaMismatchError: Schema doesn't match used template variables: header: missing in schema
 ```
 
 ## Context validation
@@ -123,12 +123,99 @@ render("./output", { web: "not a boolean", header: { show: true, title: "Hi" } }
 
 `render(target, context)` clears `target` before writing, so rendering the same template into the same directory with different contexts always produces a clean result (files/paths excluded by conditionals won't linger from a previous run).
 
+For safety, tdir refuses to render into the filesystem root, the current working directory, the home directory, or any directory that overlaps the template source. Dynamic file and directory names are also resolved against the output directory and cannot write outside it.
+
+## Reverse maps
+
+Pass `{ reverseMap: true }` as the third render argument to write `.tdir-map.json` into the output directory:
+
+```ts
+render("./output", {
+  web: true,
+  header: { show: true, title: "Hello" }
+}, { reverseMap: true })
+```
+
+Pass a string to choose a custom JSON path inside the output directory:
+
+```ts
+render("./output", context, { reverseMap: "meta/reverse-map.json" })
+```
+
+The map contains a flat lookup from rendered strings to template tokens, per-file occurrences with path/range context, inline conditional blocks, and template files skipped by path conditionals:
+
+```json
+{
+  "version": 1,
+  "files": [
+    {
+      "outputPath": "web/index.html",
+      "templatePath": "<@if(context.web)>web/index.html",
+      "tokens": [
+        {
+          "kind": "content",
+          "result": "Hello",
+          "token": "<@var(context.header.title)>",
+          "contextPath": "header.title",
+          "outputPath": "web/index.html",
+          "templatePath": "<@if(context.web)>web/index.html",
+          "range": { "start": 16, "end": 21 }
+        },
+        {
+          "kind": "conditional",
+          "result": "<head><@var(context.header.title)></head>",
+          "token": "<@if(context.header.show)><head><@var(context.header.title)></head><@endif>",
+          "outputPath": "web/index.html",
+          "templatePath": "<@if(context.web)>web/index.html",
+          "range": { "start": 9, "end": 53 },
+          "activeRange": { "start": 27, "end": 71 }
+        }
+      ]
+    }
+  ],
+  "skipped": [
+    {
+      "kind": "file",
+      "templatePath": "<@if(context.docs)>docs/readme.md",
+      "encoding": "utf8",
+      "content": "# Docs"
+    }
+  ],
+  "tokens": {
+    "Hello": ["<@var(context.header.title)>"]
+  }
+}
+```
+
+## Reverse CLI
+
+Use the reverse map to rebuild template files from an edited rendered directory:
+
+```sh
+tdir reverse ./output ./templates
+```
+
+Without installing the package first, run the published CLI through Bun:
+
+```sh
+bunx @gregorlohaus/tdir reverse ./output ./templates
+```
+
+By default, the command reads `./output/.tdir-map.json`. Use `--map` for a custom map path relative to the rendered directory:
+
+```sh
+tdir reverse ./output ./templates --map meta/reverse-map.json
+bunx @gregorlohaus/tdir reverse ./output ./templates --map meta/reverse-map.json
+```
+
+The command writes files at their original template paths, restores recorded `<@var(...)>` tokens, wraps edited inline conditional output back in the original conditional block, and restores template files that were skipped by path conditionals.
+
 ## Unmatched directives
 
-A `<@if>` without a matching `<@endif>` throws at render time:
+A `<@if>` without a matching `<@endif>` throws when the renderer is initialized:
 
 ```ts
 // If a template file contains <@if(context.x)> with no <@endif>
-render("./output", { x: true })
+initRenderer("./templates")
 // Error: Unmatched <@if> without <@endif>
 ```

package/dist/cli.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+// reverse.ts
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, isAbsolute, relative, resolve as resolvePath } from "node:path";
+import { TextDecoder } from "node:util";
+function isInsidePath(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function resolveInside(root, path) {
+  const resolved = resolvePath(root, path);
+  if (!isInsidePath(root, resolved)) {
+    throw new Error(`Refusing to write outside target directory: ${path}`);
+  }
+  return resolved;
+}
+function isUtf8Text(buffer) {
+  if (buffer.indexOf(0) !== -1)
+    return false;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readManifest(mapPath) {
+  const manifest = JSON.parse(readFileSync(mapPath, "utf-8"));
+  if (manifest.version !== 1 || !Array.isArray(manifest.files)) {
+    throw new Error(`Unsupported reverse map: ${mapPath}`);
+  }
+  return manifest;
+}
+function replaceAtRange(content, token) {
+  if (!token.range)
+    return null;
+  const { start, end } = token.range;
+  if (start < 0 || end < start || end > content.length)
+    return null;
+  if (content.slice(start, end) !== token.result)
+    return null;
+  return `${content.slice(0, start)}${token.token}${content.slice(end)}`;
+}
+function replaceFirst(content, token) {
+  const index = content.indexOf(token.result);
+  if (index === -1)
+    return null;
+  return `${content.slice(0, index)}${token.token}${content.slice(index + token.result.length)}`;
+}
+function applyActiveBranch(token, branchContent) {
+  if (!token.activeRange)
+    return token.token;
+  return [
+    token.token.slice(0, token.activeRange.start),
+    branchContent,
+    token.token.slice(token.activeRange.end)
+  ].join("");
+}
+function findPrefixEnd(content, before) {
+  if (before === "")
+    return 0;
+  let candidate = before;
+  while (candidate.length >= 8) {
+    const index = content.indexOf(candidate);
+    if (index !== -1)
+      return index + candidate.length;
+    candidate = candidate.slice(-Math.max(1, Math.floor(candidate.length / 2)));
+  }
+  return -1;
+}
+function findSuffixStart(content, after, from) {
+  if (after === "")
+    return content.length;
+  let candidate = after;
+  while (candidate.length >= 8) {
+    const index = content.indexOf(candidate, from);
+    if (index !== -1)
+      return index;
+    candidate = candidate.slice(0, Math.floor(candidate.length / 2));
+  }
+  return -1;
+}
+function replaceConditional(content, token) {
+  const exactIndex = content.indexOf(token.result);
+  if (exactIndex !== -1) {
+    return [
+      content.slice(0, exactIndex),
+      token.token,
+      content.slice(exactIndex + token.result.length)
+    ].join("");
+  }
+  if (token.before === undefined || token.after === undefined)
+    return null;
+  const branchStart = findPrefixEnd(content, token.before);
+  if (branchStart === -1)
+    return null;
+  const afterIndex = findSuffixStart(content, token.after, branchStart);
+  if (afterIndex === -1)
+    return null;
+  return [
+    content.slice(0, branchStart),
+    applyActiveBranch(token, content.slice(branchStart, afterIndex)),
+    content.slice(afterIndex)
+  ].join("");
+}
+function reverseContent(content, file, warnings) {
+  const contentTokens = file.tokens.filter((token) => token.kind === "content").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
+  let reversed = content;
+  for (const token of contentTokens) {
+    const rangeResult = replaceAtRange(reversed, token);
+    if (rangeResult !== null) {
+      reversed = rangeResult;
+      continue;
+    }
+    const fallbackResult = replaceFirst(reversed, token);
+    if (fallbackResult !== null) {
+      reversed = fallbackResult;
+      continue;
+    }
+    warnings.push({
+      outputPath: file.outputPath,
+      token: token.token,
+      result: token.result,
+      message: "Rendered value was not found; token was not restored"
+    });
+  }
+  const conditionalTokens = file.tokens.filter((token) => token.kind === "conditional").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
+  for (const token of conditionalTokens) {
+    const result = replaceConditional(reversed, token);
+    if (result !== null) {
+      reversed = result;
+      continue;
+    }
+    warnings.push({
+      outputPath: file.outputPath,
+      token: token.token,
+      result: token.result,
+      message: "Rendered conditional block was not found; block was not restored"
+    });
+  }
+  return reversed;
+}
+function writeSkippedTemplate(templateRoot, skipped) {
+  const templatePath = resolveInside(templateRoot, skipped.templatePath);
+  if (skipped.kind === "directory") {
+    mkdirSync(templatePath, { recursive: true });
+    return 0;
+  }
+  mkdirSync(dirname(templatePath), { recursive: true });
+  const content = skipped.encoding === "base64" ? Buffer.from(skipped.content ?? "", "base64") : skipped.content ?? "";
+  writeFileSync(templatePath, content);
+  return 1;
+}
+function reverseDir(renderedDir, templateDir, options = {}) {
+  const renderedRoot = resolvePath(renderedDir);
+  const templateRoot = resolvePath(templateDir);
+  const mapPath = options.mapPath ? resolvePath(renderedRoot, options.mapPath) : resolvePath(renderedRoot, ".tdir-map.json");
+  const manifest = readManifest(mapPath);
+  const warnings = [];
+  let filesWritten = 0;
+  for (const file of manifest.files) {
+    const renderedPath = resolveInside(renderedRoot, file.outputPath);
+    const templatePath = resolveInside(templateRoot, file.templatePath);
+    if (!existsSync(renderedPath)) {
+      warnings.push({
+        outputPath: file.outputPath,
+        token: "",
+        result: "",
+        message: "Rendered path does not exist; skipped"
+      });
+      continue;
+    }
+    const stat = statSync(renderedPath);
+    if (stat.isDirectory()) {
+      mkdirSync(templatePath, { recursive: true });
+      continue;
+    }
+    if (!stat.isFile())
+      continue;
+    mkdirSync(dirname(templatePath), { recursive: true });
+    const content = readFileSync(renderedPath);
+    if (!isUtf8Text(content)) {
+      copyFileSync(renderedPath, templatePath);
+      filesWritten += 1;
+      continue;
+    }
+    writeFileSync(templatePath, reverseContent(content.toString("utf-8"), file, warnings));
+    filesWritten += 1;
+  }
+  for (const skipped of manifest.skipped ?? []) {
+    filesWritten += writeSkippedTemplate(templateRoot, skipped);
+  }
+  return { filesWritten, warnings };
+}
+
+// cli.ts
+function printHelp() {
+  console.log(`tdir
+
+Usage:
+  tdir reverse <rendered-dir> <template-dir> [--map <path>]
+
+Commands:
+  reverse   Rebuild template files from a rendered directory and reverse map
+
+Options:
+  --map     Reverse map path. Defaults to <rendered-dir>/.tdir-map.json.
+            Relative paths are resolved from <rendered-dir>.
+  --help    Show this help message.
+`);
+}
+function parseReverseArgs(args) {
+  const positional = [];
+  let mapPath;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      return { help: true, positional, mapPath };
+    }
+    if (arg === "--map") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("Missing value for --map");
+      mapPath = value;
+      continue;
+    }
+    positional.push(arg);
+  }
+  return { help: false, positional, mapPath };
+}
+function main(argv) {
+  const [command, ...args] = argv;
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    return 0;
+  }
+  if (command !== "reverse") {
+    throw new Error(`Unknown command: ${command}`);
+  }
+  const parsed = parseReverseArgs(args);
+  if (parsed.help) {
+    printHelp();
+    return 0;
+  }
+  const [renderedDir, templateDir] = parsed.positional;
+  if (!renderedDir || !templateDir || parsed.positional.length > 2) {
+    throw new Error("Usage: tdir reverse <rendered-dir> <template-dir> [--map <path>]");
+  }
+  const result = reverseDir(renderedDir, templateDir, { mapPath: parsed.mapPath });
+  console.log(`Wrote ${result.filesWritten} file${result.filesWritten === 1 ? "" : "s"}`);
+  for (const warning of result.warnings) {
+    console.warn(`Warning: ${warning.outputPath}: ${warning.message}`);
+  }
+  return result.warnings.length > 0 ? 2 : 0;
+}
+try {
+  process.exitCode = main(process.argv.slice(2));
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 import { z } from "zod";
+import { type RenderOptions } from "./render";
+export type { RenderOptions, ReverseMapFile, ReverseMapManifest, ReverseMapStoredTemplate, ReverseMapToken } from "./render";
+export { reverseDir, type ReverseOptions, type ReverseResult, type ReverseWarning } from "./reverse";
 interface Stringable {
     toString: () => string;
 }
@@ -9,5 +12,4 @@ interface Issue {
 export declare class SchemaMismatchError extends Error {
     constructor(issue: Issue);
 }
-export declare const initRenderer: (dirPath: string) => <S extends z.ZodType>(userSchema: S) => (targetPath: string, context: z.infer<S>) => void;
-export {};
+export declare const initRenderer: (dirPath: string) => <S extends z.ZodType>(userSchema: S) => (targetPath: string, context: z.infer<S>, options?: RenderOptions) => void;

package/dist/index.js

@@ -1,11 +1,18 @@
+// index.ts
+import { z } from "zod";
+
 // parser.ts
 import { readdirSync, statSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { TextDecoder } from "node:util";
 var IF_RE = /<@(?:if|elseif)\((.+?)\)>/g;
 var VAR_RE = /<@var\(context\.(.+?)(?::(\w+))?\)>/g;
+var DIRECTIVE_RE = /<@(if|elseif|else|endif)(?:\((.+?)\))?>/g;
 var EQ_RE = /^eq\(context\.(.+?),\s*"(.*)"\)$/;
 var PATH_RE = /^context\.(.+)$/;
 function extractCondition(expr, vars) {
+  if (!expr)
+    throw new Error("Missing condition expression");
   const eqMatch = expr.match(EQ_RE);
   if (eqMatch) {
     vars.push({ path: eqMatch[1], type: "string" });
@@ -14,7 +21,9 @@ function extractCondition(expr, vars) {
   const pathMatch = expr.match(PATH_RE);
   if (pathMatch) {
     vars.push({ path: pathMatch[1], type: "boolean" });
+    return;
   }
+  throw new Error(`Invalid condition expression: ${expr}`);
 }
 function extractFromString(text, vars) {
   for (const match of text.matchAll(IF_RE)) {
@@ -24,6 +33,48 @@ function extractFromString(text, vars) {
     vars.push({ path: match[1], type: match[2] ?? "string" });
   }
 }
+function validateIfBlocks(content, vars) {
+  const stack = [];
+  for (const match of content.matchAll(DIRECTIVE_RE)) {
+    const directive = match[1];
+    const condition = match[2];
+    if (directive === "if") {
+      extractCondition(condition, vars);
+      stack.push({ sawElse: false });
+    } else if (directive === "elseif") {
+      const frame = stack[stack.length - 1];
+      if (!frame)
+        throw new Error("Unexpected <@elseif> without <@if>");
+      if (frame.sawElse)
+        throw new Error("Unexpected <@elseif> after <@else>");
+      extractCondition(condition, vars);
+    } else if (directive === "else") {
+      const frame = stack[stack.length - 1];
+      if (!frame)
+        throw new Error("Unexpected <@else> without <@if>");
+      if (frame.sawElse)
+        throw new Error("Unexpected duplicate <@else>");
+      frame.sawElse = true;
+    } else if (directive === "endif") {
+      if (stack.length === 0)
+        throw new Error("Unexpected <@endif> without <@if>");
+      stack.pop();
+    }
+  }
+  if (stack.length > 0) {
+    throw new Error("Unmatched <@if> without <@endif>");
+  }
+}
+function isUtf8Text(buffer) {
+  if (buffer.indexOf(0) !== -1)
+    return false;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function walkDir(dirPath, vars) {
   const entries = readdirSync(dirPath).sort();
   for (const entry of entries) {
@@ -33,8 +84,12 @@ function walkDir(dirPath, vars) {
     if (stat.isDirectory()) {
       walkDir(fullPath, vars);
     } else if (stat.isFile()) {
-      const content = readFileSync(fullPath, "utf-8");
-      extractFromString(content, vars);
+      const content = readFileSync(fullPath);
+      if (isUtf8Text(content)) {
+        const text = content.toString("utf-8");
+        extractFromString(text, vars);
+        validateIfBlocks(text, vars);
+      }
     }
   }
 }
@@ -52,25 +107,37 @@ function parse(dirPath) {
 }
 
 // render.ts
-import { readdirSync as readdirSync2, statSync as statSync2, readFileSync as readFileSync2, mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join as join2 } from "node:path";
+import {
+  copyFileSync,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync
+} from "node:fs";
+import { dirname, isAbsolute, relative, resolve as resolvePath } from "node:path";
+import { homedir } from "node:os";
+import { TextDecoder as TextDecoder2 } from "node:util";
 var IF_PATH_RE = /^<@if\((.+?)\)>(.*)$/;
 var VAR_RE2 = /<@var\(context\.(.+?)(?::(\w+))?\)>/g;
-var DIRECTIVE_RE = /<@(if|elseif|else|endif)(?:\((.+?)\))?>/g;
+var DIRECTIVE_RE2 = /<@(if|elseif|else|endif)(?:\((.+?)\))?>/g;
 var EQ_RE2 = /^eq\(context\.(.+?),\s*"(.*)"\)$/;
 var PATH_RE2 = /^context\.(.+)$/;
 function evalCondition(expr, context) {
+  if (!expr)
+    throw new Error("Missing condition expression");
   const eqMatch = expr.match(EQ_RE2);
   if (eqMatch) {
-    return resolve(context, eqMatch[1]) === eqMatch[2];
+    return resolveContext(context, eqMatch[1]) === eqMatch[2];
   }
   const pathMatch = expr.match(PATH_RE2);
   if (pathMatch) {
-    return !!resolve(context, pathMatch[1]);
+    return !!resolveContext(context, pathMatch[1]);
   }
   throw new Error(`Invalid condition expression: ${expr}`);
 }
-function resolve(context, path) {
+function resolveContext(context, path) {
   const segments = path.split(".");
   let current = context;
   for (const seg of segments) {
@@ -80,107 +147,580 @@ function resolve(context, path) {
   }
   return current;
 }
-function processIfBlocks(content, context) {
-  let result = "";
-  let pos = 0;
-  const stack = [];
-  const re = new RegExp(DIRECTIVE_RE.source, "g");
-  let match;
-  function isEmitting() {
-    return stack.every((f) => f.active);
+function isInsidePath(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function assertSafeRenderTarget(srcDir, destDir) {
+  const sourceRoot = resolvePath(srcDir);
+  const destRoot = resolvePath(destDir);
+  if (destRoot === resolvePath(destRoot, "..")) {
+    throw new Error("Refusing to render into filesystem root");
   }
-  while ((match = re.exec(content)) !== null) {
-    const directive = match[1];
-    const condPath = match[2];
-    if (directive === "if") {
-      if (isEmitting())
-        result += content.slice(pos, match.index);
-      const truthy = evalCondition(condPath, context);
-      stack.push({ matched: truthy, active: truthy });
-      pos = re.lastIndex;
-    } else if (directive === "elseif") {
-      if (stack.length === 0)
-        throw new Error("Unexpected <@elseif> without <@if>");
-      const top = stack[stack.length - 1];
-      if (isEmitting())
-        result += content.slice(pos, match.index);
-      if (top.matched) {
-        top.active = false;
-      } else {
-        const truthy = evalCondition(condPath, context);
-        top.matched = truthy;
-        top.active = truthy;
-      }
-      pos = re.lastIndex;
-    } else if (directive === "else") {
-      if (stack.length === 0)
-        throw new Error("Unexpected <@else> without <@if>");
-      const top = stack[stack.length - 1];
-      if (isEmitting())
-        result += content.slice(pos, match.index);
-      top.active = !top.matched;
-      top.matched = true;
-      pos = re.lastIndex;
-    } else if (directive === "endif") {
-      if (stack.length === 0)
-        throw new Error("Unexpected <@endif> without <@if>");
-      if (isEmitting())
-        result += content.slice(pos, match.index);
-      stack.pop();
-      pos = re.lastIndex;
+  if (destRoot === resolvePath(process.cwd())) {
+    throw new Error("Refusing to render into the current working directory");
+  }
+  if (destRoot === resolvePath(homedir())) {
+    throw new Error("Refusing to render into the home directory");
+  }
+  if (isInsidePath(sourceRoot, destRoot) || isInsidePath(destRoot, sourceRoot)) {
+    throw new Error("Refusing to render when source and target directories overlap");
+  }
+}
+function resolveOutputPath(destRoot, outputName) {
+  const outputPath = resolvePath(destRoot, outputName);
+  if (!isInsidePath(destRoot, outputPath)) {
+    throw new Error(`Refusing to write outside target directory: ${outputName}`);
+  }
+  return outputPath;
+}
+function createReverseMapManifest() {
+  return { version: 1, files: [], skipped: [], tokens: {} };
+}
+function addReverseMapToken(state, file, token) {
+  if (!state?.manifest || !file)
+    return;
+  file.tokens.push(token);
+  const tokens = state.manifest.tokens[token.result] ?? [];
+  if (!tokens.includes(token.token))
+    tokens.push(token.token);
+  state.manifest.tokens[token.result] = tokens;
+}
+function getReverseMapPath(destRoot, reverseMap) {
+  if (reverseMap === true)
+    return resolveOutputPath(destRoot, ".tdir-map.json");
+  return resolveOutputPath(destRoot, reverseMap);
+}
+function getOutputName(entry, context, state, file) {
+  const ifMatch = entry.match(IF_PATH_RE);
+  let outputName = entry;
+  if (ifMatch) {
+    if (!evalCondition(ifMatch[1], context))
+      return null;
+    outputName = ifMatch[2];
+    if (ifMatch[0] !== outputName) {
+      addReverseMapToken(state, file, {
+        kind: "path",
+        result: outputName,
+        token: ifMatch[0],
+        outputPath: file?.outputPath ?? "",
+        templatePath: file?.templatePath ?? ""
+      });
     }
   }
-  if (stack.length > 0) {
-    throw new Error("Unmatched <@if> without <@endif>");
+  return outputName.replace(VAR_RE2, (_match, path) => {
+    const result = String(resolveContext(context, path) ?? "");
+    addReverseMapToken(state, file, {
+      kind: "path",
+      result,
+      token: _match,
+      contextPath: path,
+      outputPath: file?.outputPath ?? "",
+      templatePath: file?.templatePath ?? ""
+    });
+    return result;
+  });
+}
+function isUtf8Text2(buffer) {
+  if (buffer.indexOf(0) !== -1)
+    return false;
+  try {
+    new TextDecoder2("utf-8", { fatal: true }).decode(buffer);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDirectiveTokens(content) {
+  return Array.from(content.matchAll(DIRECTIVE_RE2), (match) => ({
+    type: match[1],
+    condition: match[2],
+    index: match.index,
+    end: match.index + match[0].length
+  }));
+}
+function parseNodes(content, tokens, tokenIndex, pos, stopTypes) {
+  const nodes = [];
+  while (tokenIndex < tokens.length) {
+    const token = tokens[tokenIndex];
+    if (stopTypes.includes(token.type)) {
+      if (token.index > pos)
+        nodes.push({ type: "text", text: content.slice(pos, token.index) });
+      return { nodes, pos: token.index, tokenIndex, stop: token };
+    }
+    if (token.type !== "if") {
+      throw new Error(`Unexpected <@${token.type}> without <@if>`);
+    }
+    if (token.index > pos)
+      nodes.push({ type: "text", text: content.slice(pos, token.index) });
+    const parsed = parseIfNode(content, tokens, tokenIndex);
+    nodes.push(parsed.node);
+    tokenIndex = parsed.tokenIndex;
+    pos = parsed.pos;
+  }
+  if (pos < content.length)
+    nodes.push({ type: "text", text: content.slice(pos) });
+  return { nodes, pos: content.length, tokenIndex };
+}
+function parseIfNode(content, tokens, tokenIndex) {
+  const firstToken = tokens[tokenIndex];
+  const sourceStart = firstToken.index;
+  const branches = [];
+  let branchType = "if";
+  let branchCondition = firstToken.condition;
+  let branchContentStart = firstToken.end;
+  tokenIndex += 1;
+  while (true) {
+    const parsed = parseNodes(content, tokens, tokenIndex, branchContentStart, ["elseif", "else", "endif"]);
+    if (!parsed.stop)
+      throw new Error("Unmatched <@if> without <@endif>");
+    branches.push({
+      type: branchType,
+      condition: branchCondition,
+      nodes: parsed.nodes,
+      contentStart: branchContentStart,
+      contentEnd: parsed.pos
+    });
+    if (parsed.stop.type === "endif") {
+      const sourceEnd = parsed.stop.end;
+      return {
+        node: {
+          type: "if",
+          sourceStart,
+          sourceEnd,
+          source: content.slice(sourceStart, sourceEnd),
+          branches
+        },
+        pos: sourceEnd,
+        tokenIndex: parsed.tokenIndex + 1
+      };
+    }
+    branchType = parsed.stop.type;
+    branchCondition = parsed.stop.condition;
+    branchContentStart = parsed.stop.end;
+    tokenIndex = parsed.tokenIndex + 1;
+  }
+}
+function getActiveBranch(node, context) {
+  for (const branch of node.branches) {
+    if (branch.type === "else" || evalCondition(branch.condition, context))
+      return branch;
+  }
+  return;
+}
+function renderNodes(nodes, context, conditionalTokens, outputStart = 0) {
+  let result = "";
+  for (const node of nodes) {
+    if (node.type === "text") {
+      result += node.text;
+      continue;
+    }
+    const activeBranch = getActiveBranch(node, context);
+    const start = outputStart + result.length;
+    const renderedBranch = activeBranch ? renderNodes(activeBranch.nodes, context, conditionalTokens, start) : "";
+    result += renderedBranch;
+    conditionalTokens.push({
+      result: renderedBranch,
+      token: node.source,
+      range: { start, end: start + renderedBranch.length },
+      activeRange: activeBranch ? {
+        start: activeBranch.contentStart - node.sourceStart,
+        end: activeBranch.contentEnd - node.sourceStart
+      } : { start: node.source.length, end: node.source.length }
+    });
   }
-  result += content.slice(pos);
   return result;
 }
-function renderContent(content, context) {
-  const processed = processIfBlocks(content, context);
-  return processed.replace(VAR_RE2, (_match, path) => {
-    return String(resolve(context, path) ?? "");
-  });
+function processIfBlocksWithMap(content, context) {
+  const tokens = getDirectiveTokens(content);
+  const parsed = parseNodes(content, tokens, 0, 0, []);
+  const conditionalTokens = [];
+  return {
+    content: renderNodes(parsed.nodes, context, conditionalTokens),
+    conditionalTokens
+  };
 }
-function renderDir(srcDir, destDir, context) {
+function renderContentWithMap(content, context, state, file) {
+  const processedResult = processIfBlocksWithMap(content, context);
+  const processed = processedResult.content;
+  for (const token of processedResult.conditionalTokens) {
+    addReverseMapToken(state, file, {
+      kind: "conditional",
+      result: token.result,
+      token: token.token,
+      outputPath: file?.outputPath ?? "",
+      templatePath: file?.templatePath ?? "",
+      range: token.range,
+      activeRange: token.activeRange,
+      before: processed.slice(0, token.range.start),
+      after: processed.slice(token.range.end)
+    });
+  }
+  let result = "";
+  let pos = 0;
+  for (const match of processed.matchAll(VAR_RE2)) {
+    const token = match[0];
+    const path = match[1];
+    const rendered = String(resolveContext(context, path) ?? "");
+    result += processed.slice(pos, match.index);
+    const start = result.length;
+    result += rendered;
+    addReverseMapToken(state, file, {
+      kind: "content",
+      result: rendered,
+      token,
+      contextPath: path,
+      outputPath: file?.outputPath ?? "",
+      templatePath: file?.templatePath ?? "",
+      range: { start, end: start + rendered.length }
+    });
+    pos = match.index + token.length;
+  }
+  result += processed.slice(pos);
+  return result;
+}
+function renderDir(srcDir, destDir, context, options = {}) {
+  const destRoot = resolvePath(destDir);
+  const sourceRoot = resolvePath(srcDir);
+  const state = {
+    sourceRoot,
+    destRoot,
+    manifest: options.reverseMap ? createReverseMapManifest() : undefined
+  };
+  const mapPath = options.reverseMap ? getReverseMapPath(destRoot, options.reverseMap) : undefined;
+  assertSafeRenderTarget(srcDir, destDir);
+  validateOutputPaths(srcDir, destRoot, context);
   rmSync(destDir, { recursive: true, force: true });
-  renderDirInner(srcDir, destDir, context);
+  renderDirInner(srcDir, destRoot, context, state);
+  if (state.manifest && mapPath) {
+    mkdirSync(dirname(mapPath), { recursive: true });
+    writeFileSync(mapPath, `${JSON.stringify(state.manifest, null, 2)}
+`);
+  }
 }
-function renderDirInner(srcDir, destDir, context) {
-  mkdirSync(destDir, { recursive: true });
+function validateOutputPaths(srcDir, destDir, context) {
   const entries = readdirSync2(srcDir).sort();
   for (const entry of entries) {
-    const srcPath = join2(srcDir, entry);
+    const srcPath = resolvePath(srcDir, entry);
     const stat = statSync2(srcPath);
-    const ifMatch = entry.match(IF_PATH_RE);
-    let outputName = entry;
-    if (ifMatch) {
-      if (!evalCondition(ifMatch[1], context))
-        continue;
-      outputName = ifMatch[2];
-    }
-    outputName = outputName.replace(VAR_RE2, (_match, path) => {
-      return String(resolve(context, path) ?? "");
+    const outputName = getOutputName(entry, context);
+    if (outputName === null)
+      continue;
+    const destPath = resolveOutputPath(destDir, outputName);
+    if (stat.isDirectory()) {
+      validateOutputPaths(srcPath, destPath, context);
+    }
+  }
+}
+function storeSkippedTemplate(srcPath, state) {
+  if (!state.manifest)
+    return;
+  const stat = statSync2(srcPath);
+  const templatePath = relative(state.sourceRoot, srcPath);
+  if (stat.isDirectory()) {
+    state.manifest.skipped.push({ kind: "directory", templatePath });
+    for (const entry of readdirSync2(srcPath).sort()) {
+      storeSkippedTemplate(resolvePath(srcPath, entry), state);
+    }
+    return;
+  }
+  if (!stat.isFile())
+    return;
+  const content = readFileSync2(srcPath);
+  if (isUtf8Text2(content)) {
+    state.manifest.skipped.push({
+      kind: "file",
+      templatePath,
+      encoding: "utf8",
+      content: content.toString("utf-8")
+    });
+  } else {
+    state.manifest.skipped.push({
+      kind: "file",
+      templatePath,
+      encoding: "base64",
+      content: content.toString("base64")
     });
-    const destPath = join2(destDir, outputName);
+  }
+}
+function renderDirInner(srcDir, destDir, context, state) {
+  mkdirSync(destDir, { recursive: true });
+  const entries = readdirSync2(srcDir).sort();
+  for (const entry of entries) {
+    const srcPath = resolvePath(srcDir, entry);
+    const stat = statSync2(srcPath);
+    const templatePath = relative(state.sourceRoot, srcPath);
+    const tempFile = {
+      outputPath: "",
+      templatePath,
+      tokens: []
+    };
+    const outputName = getOutputName(entry, context, state, tempFile);
+    if (outputName === null) {
+      storeSkippedTemplate(srcPath, state);
+      continue;
+    }
+    const destPath = resolveOutputPath(destDir, outputName);
+    const outputPath = relative(state.destRoot, destPath);
+    tempFile.outputPath = outputPath;
+    for (const token of tempFile.tokens) {
+      token.outputPath = outputPath;
+      token.templatePath = templatePath;
+    }
     if (stat.isDirectory()) {
-      renderDirInner(srcPath, destPath, context);
+      if (tempFile.tokens.length > 0)
+        state.manifest?.files.push(tempFile);
+      renderDirInner(srcPath, destPath, context, state);
     } else {
-      mkdirSync(destDir, { recursive: true });
-      const content = readFileSync2(srcPath, "utf-8");
-      writeFileSync(destPath, renderContent(content, context));
+      mkdirSync(dirname(destPath), { recursive: true });
+      const content = readFileSync2(srcPath);
+      if (isUtf8Text2(content)) {
+        const rendered = renderContentWithMap(content.toString("utf-8"), context, state, tempFile);
+        writeFileSync(destPath, rendered);
+      } else {
+        copyFileSync(srcPath, destPath);
+      }
+      if (state.manifest)
+        state.manifest.files.push(tempFile);
+    }
+  }
+}
+
+// reverse.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  statSync as statSync3,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, relative as relative2, resolve as resolvePath2 } from "node:path";
+import { TextDecoder as TextDecoder3 } from "node:util";
+function isInsidePath2(parent, child) {
+  const rel = relative2(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+}
+function resolveInside(root, path) {
+  const resolved = resolvePath2(root, path);
+  if (!isInsidePath2(root, resolved)) {
+    throw new Error(`Refusing to write outside target directory: ${path}`);
+  }
+  return resolved;
+}
+function isUtf8Text3(buffer) {
+  if (buffer.indexOf(0) !== -1)
+    return false;
+  try {
+    new TextDecoder3("utf-8", { fatal: true }).decode(buffer);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readManifest(mapPath) {
+  const manifest = JSON.parse(readFileSync3(mapPath, "utf-8"));
+  if (manifest.version !== 1 || !Array.isArray(manifest.files)) {
+    throw new Error(`Unsupported reverse map: ${mapPath}`);
+  }
+  return manifest;
+}
+function replaceAtRange(content, token) {
+  if (!token.range)
+    return null;
+  const { start, end } = token.range;
+  if (start < 0 || end < start || end > content.length)
+    return null;
+  if (content.slice(start, end) !== token.result)
+    return null;
+  return `${content.slice(0, start)}${token.token}${content.slice(end)}`;
+}
+function replaceFirst(content, token) {
+  const index = content.indexOf(token.result);
+  if (index === -1)
+    return null;
+  return `${content.slice(0, index)}${token.token}${content.slice(index + token.result.length)}`;
+}
+function applyActiveBranch(token, branchContent) {
+  if (!token.activeRange)
+    return token.token;
+  return [
+    token.token.slice(0, token.activeRange.start),
+    branchContent,
+    token.token.slice(token.activeRange.end)
+  ].join("");
+}
+function findPrefixEnd(content, before) {
+  if (before === "")
+    return 0;
+  let candidate = before;
+  while (candidate.length >= 8) {
+    const index = content.indexOf(candidate);
+    if (index !== -1)
+      return index + candidate.length;
+    candidate = candidate.slice(-Math.max(1, Math.floor(candidate.length / 2)));
+  }
+  return -1;
+}
+function findSuffixStart(content, after, from) {
+  if (after === "")
+    return content.length;
+  let candidate = after;
+  while (candidate.length >= 8) {
+    const index = content.indexOf(candidate, from);
+    if (index !== -1)
+      return index;
+    candidate = candidate.slice(0, Math.floor(candidate.length / 2));
+  }
+  return -1;
+}
+function replaceConditional(content, token) {
+  const exactIndex = content.indexOf(token.result);
+  if (exactIndex !== -1) {
+    return [
+      content.slice(0, exactIndex),
+      token.token,
+      content.slice(exactIndex + token.result.length)
+    ].join("");
+  }
+  if (token.before === undefined || token.after === undefined)
+    return null;
+  const branchStart = findPrefixEnd(content, token.before);
+  if (branchStart === -1)
+    return null;
+  const afterIndex = findSuffixStart(content, token.after, branchStart);
+  if (afterIndex === -1)
+    return null;
+  return [
+    content.slice(0, branchStart),
+    applyActiveBranch(token, content.slice(branchStart, afterIndex)),
+    content.slice(afterIndex)
+  ].join("");
+}
+function reverseContent(content, file, warnings) {
+  const contentTokens = file.tokens.filter((token) => token.kind === "content").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
+  let reversed = content;
+  for (const token of contentTokens) {
+    const rangeResult = replaceAtRange(reversed, token);
+    if (rangeResult !== null) {
+      reversed = rangeResult;
+      continue;
+    }
+    const fallbackResult = replaceFirst(reversed, token);
+    if (fallbackResult !== null) {
+      reversed = fallbackResult;
+      continue;
     }
+    warnings.push({
+      outputPath: file.outputPath,
+      token: token.token,
+      result: token.result,
+      message: "Rendered value was not found; token was not restored"
+    });
+  }
+  const conditionalTokens = file.tokens.filter((token) => token.kind === "conditional").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
+  for (const token of conditionalTokens) {
+    const result = replaceConditional(reversed, token);
+    if (result !== null) {
+      reversed = result;
+      continue;
+    }
+    warnings.push({
+      outputPath: file.outputPath,
+      token: token.token,
+      result: token.result,
+      message: "Rendered conditional block was not found; block was not restored"
+    });
+  }
+  return reversed;
+}
+function writeSkippedTemplate(templateRoot, skipped) {
+  const templatePath = resolveInside(templateRoot, skipped.templatePath);
+  if (skipped.kind === "directory") {
+    mkdirSync2(templatePath, { recursive: true });
+    return 0;
   }
+  mkdirSync2(dirname2(templatePath), { recursive: true });
+  const content = skipped.encoding === "base64" ? Buffer.from(skipped.content ?? "", "base64") : skipped.content ?? "";
+  writeFileSync2(templatePath, content);
+  return 1;
+}
+function reverseDir(renderedDir, templateDir, options = {}) {
+  const renderedRoot = resolvePath2(renderedDir);
+  const templateRoot = resolvePath2(templateDir);
+  const mapPath = options.mapPath ? resolvePath2(renderedRoot, options.mapPath) : resolvePath2(renderedRoot, ".tdir-map.json");
+  const manifest = readManifest(mapPath);
+  const warnings = [];
+  let filesWritten = 0;
+  for (const file of manifest.files) {
+    const renderedPath = resolveInside(renderedRoot, file.outputPath);
+    const templatePath = resolveInside(templateRoot, file.templatePath);
+    if (!existsSync(renderedPath)) {
+      warnings.push({
+        outputPath: file.outputPath,
+        token: "",
+        result: "",
+        message: "Rendered path does not exist; skipped"
+      });
+      continue;
+    }
+    const stat = statSync3(renderedPath);
+    if (stat.isDirectory()) {
+      mkdirSync2(templatePath, { recursive: true });
+      continue;
+    }
+    if (!stat.isFile())
+      continue;
+    mkdirSync2(dirname2(templatePath), { recursive: true });
+    const content = readFileSync3(renderedPath);
+    if (!isUtf8Text3(content)) {
+      copyFileSync2(renderedPath, templatePath);
+      filesWritten += 1;
+      continue;
+    }
+    writeFileSync2(templatePath, reverseContent(content.toString("utf-8"), file, warnings));
+    filesWritten += 1;
+  }
+  for (const skipped of manifest.skipped ?? []) {
+    filesWritten += writeSkippedTemplate(templateRoot, skipped);
+  }
+  return { filesWritten, warnings };
 }
 
 // index.ts
 class SchemaMismatchError extends Error {
   constructor(issue) {
-    super(`Shema doesnt match used template variables: ${issue.path}: ${issue.message}`);
+    super(`Schema doesn't match used template variables: ${issue.path}: ${issue.message}`);
+    this.name = "SchemaMismatchError";
   }
 }
+function zodTypeName(schema) {
+  if (schema instanceof z.ZodObject)
+    return "object";
+  if (schema instanceof z.ZodString)
+    return "string";
+  if (schema instanceof z.ZodBoolean)
+    return "boolean";
+  if (schema instanceof z.ZodNumber)
+    return "number";
+  return schema.constructor.name;
+}
+function zodDisplayName(schema) {
+  const type = zodTypeName(schema);
+  return type.startsWith("Zod") ? type : `z.${type}()`;
+}
+function setExpectedType(expected, path, type) {
+  const existing = expected.get(path);
+  if (existing && existing !== type) {
+    throw new SchemaMismatchError({
+      path,
+      message: `conflicting template variable types: expected both z.${existing}() and z.${type}()`
+    });
+  }
+  expected.set(path, type);
+}
 function validateSchemaMatchesTemplates(userSchema, variables) {
-  if (userSchema._zod.def.type !== "object") {
+  if (!(userSchema instanceof z.ZodObject)) {
     throw new SchemaMismatchError({ path: "", message: "Schema must be a z.object()" });
   }
   const expected = new Map;
@@ -188,11 +728,9 @@ function validateSchemaMatchesTemplates(userSchema, variables) {
     const segments = v.path.split(".");
     for (let i = 0;i < segments.length - 1; i++) {
       const intermediate = segments.slice(0, i + 1).join(".");
-      if (!expected.has(intermediate)) {
-        expected.set(intermediate, "object");
-      }
+      setExpectedType(expected, intermediate, "object");
     }
-    expected.set(v.path, v.type);
+    setExpectedType(expected, v.path, v.type);
   }
   for (const [path, expectedType] of expected) {
     const segments = path.split(".");
@@ -200,8 +738,8 @@ function validateSchemaMatchesTemplates(userSchema, variables) {
     let currentPath = "";
     for (const seg of segments) {
       currentPath = currentPath ? `${currentPath}.${seg}` : seg;
-      if (current._zod.def.type !== "object") {
-        throw new SchemaMismatchError({ path: currentPath, message: `expected z.object() but schema has z.${current._zod.def.type}()` });
+      if (!(current instanceof z.ZodObject)) {
+        throw new SchemaMismatchError({ path: currentPath, message: `expected z.object() but schema has ${zodDisplayName(current)}` });
       }
       const shape = current.shape;
       if (!(seg in shape)) {
@@ -209,9 +747,9 @@ function validateSchemaMatchesTemplates(userSchema, variables) {
       }
       current = shape[seg];
     }
-    const actual = current._zod.def.type;
+    const actual = zodTypeName(current);
     if (actual !== expectedType) {
-      throw new SchemaMismatchError({ path, message: `expected z.${expectedType}() but schema has z.${actual}()` });
+      throw new SchemaMismatchError({ path, message: `expected z.${expectedType}() but schema has ${zodDisplayName(current)}` });
     }
   }
 }
@@ -219,14 +757,15 @@ var initRenderer = (dirPath) => {
   const variables = parse(dirPath);
   const createRenderer = (userSchema) => {
     validateSchemaMatchesTemplates(userSchema, variables);
-    return (targetPath, context) => {
+    return (targetPath, context, options) => {
       userSchema.parse(context);
-      renderDir(dirPath, targetPath, context);
+      renderDir(dirPath, targetPath, context, options);
     };
   };
   return createRenderer;
 };
 export {
+  reverseDir,
   initRenderer,
   SchemaMismatchError
 };

package/dist/render.d.ts

@@ -1,3 +1,41 @@
+export type ReverseMapToken = {
+    kind: "path" | "content" | "conditional";
+    result: string;
+    token: string;
+    contextPath?: string;
+    outputPath: string;
+    templatePath: string;
+    range?: {
+        start: number;
+        end: number;
+    };
+    activeRange?: {
+        start: number;
+        end: number;
+    };
+    before?: string;
+    after?: string;
+};
+export type ReverseMapFile = {
+    outputPath: string;
+    templatePath: string;
+    tokens: ReverseMapToken[];
+};
+export type ReverseMapStoredTemplate = {
+    kind: "directory" | "file";
+    templatePath: string;
+    encoding?: "utf8" | "base64";
+    content?: string;
+};
+export type ReverseMapManifest = {
+    version: 1;
+    files: ReverseMapFile[];
+    skipped: ReverseMapStoredTemplate[];
+    tokens: Record<string, string[]>;
+};
+export type RenderOptions = {
+    reverseMap?: boolean | string;
+};
 declare function renderContent(content: string, context: Record<string, unknown>): string;
-declare function renderDir(srcDir: string, destDir: string, context: Record<string, unknown>): void;
+declare function renderDir(srcDir: string, destDir: string, context: Record<string, unknown>, options?: RenderOptions): void;
 export { renderDir, renderContent };

package/dist/reverse.d.ts

@@ -0,0 +1,14 @@
+export type ReverseOptions = {
+    mapPath?: string;
+};
+export type ReverseWarning = {
+    outputPath: string;
+    token: string;
+    result: string;
+    message: string;
+};
+export type ReverseResult = {
+    filesWritten: number;
+    warnings: ReverseWarning[];
+};
+export declare function reverseDir(renderedDir: string, templateDir: string, options?: ReverseOptions): ReverseResult;

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@gregorlohaus/tdir",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "tdir": "./dist/cli.js"
+  },
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -13,7 +16,7 @@
   },
   "files": ["dist"],
   "scripts": {
-    "build": "bun build ./index.ts --outdir ./dist --target node --external zod && bunx tsc --project tsconfig.build.json",
+    "build": "bun build ./index.ts ./cli.ts --outdir ./dist --target node --external zod && bunx tsc --project tsconfig.build.json",
     "test": "bun test"
   },
   "devDependencies": {