@noormdev/sdk 1.0.0-alpha.19 → 1.0.0-alpha.20

package/dist/chunk-3UDETNWW.js

@@ -0,0 +1,943 @@
+import { createRequire } from 'module';
+import { observer, attempt } from './chunk-UDUDHOIB.js';
+import { dist_default } from './chunk-TBRUDUBQ.js';
+import { readFile as readFile$1, readdir, stat } from 'fs/promises';
+import * as fs from 'fs';
+import { readFileSync, createReadStream, unlinkSync } from 'fs';
+import * as path from 'path';
+import path__default, { dirname, join } from 'path';
+import { pathToFileURL } from 'url';
+import { randomBytes, pbkdf2Sync, createCipheriv, createDecipheriv } from 'crypto';
+import { gunzipSync, createGunzip } from 'zlib';
+import { createInterface } from 'readline';
+import { PassThrough } from 'stream';
+
+createRequire(import.meta.url);
+var EtaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Eta Error";
+  }
+};
+var EtaParseError = class extends EtaError {
+  constructor(message) {
+    super(message);
+    this.name = "EtaParser Error";
+  }
+};
+var EtaRuntimeError = class extends EtaError {
+  constructor(message) {
+    super(message);
+    this.name = "EtaRuntime Error";
+  }
+};
+var EtaFileResolutionError = class extends EtaError {
+  constructor(message) {
+    super(message);
+    this.name = "EtaFileResolution Error";
+  }
+};
+var EtaNameResolutionError = class extends EtaError {
+  constructor(message) {
+    super(message);
+    this.name = "EtaNameResolution Error";
+  }
+};
+function ParseErr(message, str, indx) {
+  const whitespace = str.slice(0, indx).split(/\n/);
+  const lineNo = whitespace.length;
+  const colNo = whitespace[lineNo - 1].length + 1;
+  message += " at line " + lineNo + " col " + colNo + ":\n\n  " + str.split(/\n/)[lineNo - 1] + "\n  " + Array(colNo).join(" ") + "^";
+  throw new EtaParseError(message);
+}
+function RuntimeErr(originalError, str, lineNo, path$1) {
+  const lines = str.split("\n");
+  const start = Math.max(lineNo - 3, 0);
+  const end = Math.min(lines.length, lineNo + 3);
+  const filename = path$1;
+  const context = lines.slice(start, end).map((line, i) => {
+    const curr = i + start + 1;
+    return (curr === lineNo ? " >> " : "    ") + curr + "| " + line;
+  }).join("\n");
+  const err = new EtaRuntimeError((filename ? filename + ":" + lineNo + "\n" : "line " + lineNo + "\n") + context + "\n\n" + originalError.message);
+  err.name = originalError.name;
+  err.cause = originalError;
+  throw err;
+}
+function readFile(path$1) {
+  let res = "";
+  try {
+    res = fs.readFileSync(path$1, "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") throw new EtaFileResolutionError(`Could not find template: ${path$1}`);
+    else throw err;
+  }
+  return res;
+}
+function resolvePath(templatePath, options) {
+  let resolvedFilePath = "";
+  const views = this.config.views;
+  if (!views) throw new EtaFileResolutionError("Views directory is not defined");
+  const baseFilePath = options?.filepath;
+  const defaultExtension = this.config.defaultExtension === void 0 ? ".eta" : this.config.defaultExtension;
+  const cacheIndex = JSON.stringify({
+    filename: baseFilePath,
+    path: templatePath,
+    views: this.config.views
+  });
+  templatePath += path.extname(templatePath) ? "" : defaultExtension;
+  if (baseFilePath) {
+    if (this.config.cacheFilepaths && this.filepathCache[cacheIndex]) return this.filepathCache[cacheIndex];
+    if (absolutePathRegExp.exec(templatePath)?.length) {
+      const formattedPath = templatePath.replace(/^\/*|^\\*/, "");
+      resolvedFilePath = path.join(views, formattedPath);
+    } else resolvedFilePath = path.join(path.dirname(baseFilePath), templatePath);
+  } else resolvedFilePath = path.join(views, templatePath);
+  if (dirIsChild(views, resolvedFilePath)) {
+    if (baseFilePath && this.config.cacheFilepaths) this.filepathCache[cacheIndex] = resolvedFilePath;
+    return resolvedFilePath;
+  } else throw new EtaFileResolutionError(`Template '${templatePath}' is not in the views directory`);
+}
+function dirIsChild(parent, dir) {
+  const relative2 = path.relative(parent, dir);
+  return relative2 && !relative2.startsWith("..") && !path.isAbsolute(relative2);
+}
+var absolutePathRegExp = /^\\|^\//;
+var AsyncFunction = (async () => {
+}).constructor;
+function compile(str, options) {
+  const config = this.config;
+  const ctor = options?.async ? AsyncFunction : Function;
+  try {
+    return new ctor(config.varName, "options", this.compileToString.call(this, str, options));
+  } catch (e) {
+    if (e instanceof SyntaxError) throw new EtaParseError("Bad template syntax\n\n" + e.message + "\n" + Array(e.message.length + 1).join("=") + "\n" + this.compileToString.call(this, str, options) + "\n");
+    else throw e;
+  }
+}
+function compileToString(str, options) {
+  const config = this.config;
+  const isAsync = options?.async;
+  const compileBody$1 = this.compileBody;
+  const buffer = this.parse.call(this, str);
+  let res = `${config.functionHeader}
+let include = (__eta_t, __eta_d) => this.render(__eta_t, {...${config.varName}, ...(__eta_d ?? {})}, options);
+let includeAsync = (__eta_t, __eta_d) => this.renderAsync(__eta_t, {...${config.varName}, ...(__eta_d ?? {})}, options);
+
+let __eta = {res: "", e: this.config.escapeFunction, f: this.config.filterFunction${config.debug ? ', line: 1, templateStr: "' + str.replace(/\\|"/g, "\\$&").replace(/\r\n|\n|\r/g, "\\n") + '"' : ""}};
+
+function layout(path, data) {
+  __eta.layout = path;
+  __eta.layoutData = data;
+}${config.debug ? "try {" : ""}${config.useWith ? "with(" + config.varName + "||{}){" : ""}
+
+function ${config.outputFunctionName}(s){__eta.res+=s;}
+
+${compileBody$1.call(this, buffer)}
+if (__eta.layout) {
+  __eta.res = ${isAsync ? "await includeAsync" : "include"} (__eta.layout, {...${config.varName}, body: __eta.res, ...__eta.layoutData});
+}
+${config.useWith ? "}" : ""}${config.debug ? "} catch (e) { this.RuntimeErr(e, __eta.templateStr, __eta.line, options.filepath) }" : ""}
+return __eta.res;
+`;
+  if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+    const plugin = config.plugins[i];
+    if (plugin.processFnString) res = plugin.processFnString(res, config);
+  }
+  return res;
+}
+function compileBody(buff) {
+  const config = this.config;
+  let i = 0;
+  const buffLength = buff.length;
+  let returnStr = "";
+  for (; i < buffLength; i++) {
+    const currentBlock = buff[i];
+    if (typeof currentBlock === "string") returnStr += "__eta.res+='" + currentBlock + "';\n";
+    else {
+      const type = currentBlock.t;
+      let content = currentBlock.val || "";
+      if (config.debug) returnStr += "__eta.line=" + currentBlock.lineNo + "\n";
+      if (type === "r") {
+        if (config.autoFilter) content = "__eta.f(" + content + ")";
+        returnStr += "__eta.res+=" + content + ";\n";
+      } else if (type === "i") {
+        if (config.autoFilter) content = "__eta.f(" + content + ")";
+        if (config.autoEscape) content = "__eta.e(" + content + ")";
+        returnStr += "__eta.res+=" + content + ";\n";
+      } else if (type === "e") returnStr += content + "\n";
+    }
+  }
+  return returnStr;
+}
+function trimWS(str, config, wsLeft, wsRight) {
+  let leftTrim;
+  let rightTrim;
+  if (Array.isArray(config.autoTrim)) {
+    leftTrim = config.autoTrim[1];
+    rightTrim = config.autoTrim[0];
+  } else leftTrim = rightTrim = config.autoTrim;
+  if (wsLeft || wsLeft === false) leftTrim = wsLeft;
+  if (wsRight || wsRight === false) rightTrim = wsRight;
+  if (!rightTrim && !leftTrim) return str;
+  if (leftTrim === "slurp" && rightTrim === "slurp") return str.trim();
+  if (leftTrim === "_" || leftTrim === "slurp") str = str.trimStart();
+  else if (leftTrim === "-" || leftTrim === "nl") str = str.replace(/^(?:\r\n|\n|\r)/, "");
+  if (rightTrim === "_" || rightTrim === "slurp") str = str.trimEnd();
+  else if (rightTrim === "-" || rightTrim === "nl") str = str.replace(/(?:\r\n|\n|\r)$/, "");
+  return str;
+}
+var escMap = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function replaceChar(s) {
+  return escMap[s];
+}
+function XMLEscape(str) {
+  const newStr = String(str);
+  if (/[&<>"']/.test(newStr)) return newStr.replace(/[&<>"']/g, replaceChar);
+  else return newStr;
+}
+var defaultConfig = {
+  autoEscape: true,
+  autoFilter: false,
+  autoTrim: [false, "nl"],
+  cache: false,
+  cacheFilepaths: true,
+  debug: false,
+  escapeFunction: XMLEscape,
+  filterFunction: (val) => String(val),
+  outputFunctionName: "output",
+  functionHeader: "",
+  parse: {
+    exec: "",
+    interpolate: "=",
+    raw: "~"
+  },
+  plugins: [],
+  rmWhitespace: false,
+  tags: ["<%", "%>"],
+  useWith: false,
+  varName: "it",
+  defaultExtension: ".eta"
+};
+var templateLitReg = /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})*}|(?!\${)[^\\`])*`/g;
+var singleQuoteReg = /'(?:\\[\s\w"'\\`]|[^\n\r'\\])*?'/g;
+var doubleQuoteReg = /"(?:\\[\s\w"'\\`]|[^\n\r"\\])*?"/g;
+function escapeRegExp(string) {
+  return string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+}
+function getLineNo(str, index) {
+  return str.slice(0, index).split("\n").length;
+}
+function parse(str) {
+  const config = this.config;
+  let buffer = [];
+  let trimLeftOfNextStr = false;
+  let lastIndex = 0;
+  const parseOptions = config.parse;
+  if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+    const plugin = config.plugins[i];
+    if (plugin.processTemplate) str = plugin.processTemplate(str, config);
+  }
+  if (config.rmWhitespace) str = str.replace(/[\r\n]+/g, "\n").replace(/^\s+|\s+$/gm, "");
+  templateLitReg.lastIndex = 0;
+  singleQuoteReg.lastIndex = 0;
+  doubleQuoteReg.lastIndex = 0;
+  function pushString(strng, shouldTrimRightOfString) {
+    if (strng) {
+      strng = trimWS(strng, config, trimLeftOfNextStr, shouldTrimRightOfString);
+      if (strng) {
+        strng = strng.replace(/\\|'/g, "\\$&").replace(/\r\n|\n|\r/g, "\\n");
+        buffer.push(strng);
+      }
+    }
+  }
+  const prefixes = [
+    parseOptions.exec,
+    parseOptions.interpolate,
+    parseOptions.raw
+  ].reduce((accumulator, prefix) => {
+    if (accumulator && prefix) return accumulator + "|" + escapeRegExp(prefix);
+    else if (prefix) return escapeRegExp(prefix);
+    else return accumulator;
+  }, "");
+  const parseOpenReg = new RegExp(escapeRegExp(config.tags[0]) + "(-|_)?\\s*(" + prefixes + ")?\\s*", "g");
+  const parseCloseReg = new RegExp("'|\"|`|\\/\\*|(\\s*(-|_)?" + escapeRegExp(config.tags[1]) + ")", "g");
+  let m;
+  while (m = parseOpenReg.exec(str)) {
+    const precedingString = str.slice(lastIndex, m.index);
+    lastIndex = m[0].length + m.index;
+    const wsLeft = m[1];
+    const prefix = m[2] || "";
+    pushString(precedingString, wsLeft);
+    parseCloseReg.lastIndex = lastIndex;
+    let closeTag;
+    let currentObj = false;
+    while (closeTag = parseCloseReg.exec(str)) if (closeTag[1]) {
+      const content = str.slice(lastIndex, closeTag.index);
+      parseOpenReg.lastIndex = lastIndex = parseCloseReg.lastIndex;
+      trimLeftOfNextStr = closeTag[2];
+      currentObj = {
+        t: prefix === parseOptions.exec ? "e" : prefix === parseOptions.raw ? "r" : prefix === parseOptions.interpolate ? "i" : "",
+        val: content
+      };
+      break;
+    } else {
+      const char = closeTag[0];
+      if (char === "/*") {
+        const commentCloseInd = str.indexOf("*/", parseCloseReg.lastIndex);
+        if (commentCloseInd === -1) ParseErr("unclosed comment", str, closeTag.index);
+        parseCloseReg.lastIndex = commentCloseInd;
+      } else if (char === "'") {
+        singleQuoteReg.lastIndex = closeTag.index;
+        if (singleQuoteReg.exec(str)) parseCloseReg.lastIndex = singleQuoteReg.lastIndex;
+        else ParseErr("unclosed string", str, closeTag.index);
+      } else if (char === '"') {
+        doubleQuoteReg.lastIndex = closeTag.index;
+        if (doubleQuoteReg.exec(str)) parseCloseReg.lastIndex = doubleQuoteReg.lastIndex;
+        else ParseErr("unclosed string", str, closeTag.index);
+      } else if (char === "`") {
+        templateLitReg.lastIndex = closeTag.index;
+        if (templateLitReg.exec(str)) parseCloseReg.lastIndex = templateLitReg.lastIndex;
+        else ParseErr("unclosed string", str, closeTag.index);
+      }
+    }
+    if (currentObj) {
+      if (config.debug) currentObj.lineNo = getLineNo(str, m.index);
+      buffer.push(currentObj);
+    } else ParseErr("unclosed tag", str, m.index);
+  }
+  pushString(str.slice(lastIndex, str.length), false);
+  if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+    const plugin = config.plugins[i];
+    if (plugin.processAST) buffer = plugin.processAST(buffer, config);
+  }
+  return buffer;
+}
+function handleCache(template, options) {
+  const templateStore = options?.async ? this.templatesAsync : this.templatesSync;
+  if (this.resolvePath && this.readFile && !template.startsWith("@")) {
+    const templatePath = options.filepath;
+    const cachedTemplate = templateStore.get(templatePath);
+    if (this.config.cache && cachedTemplate) return cachedTemplate;
+    else {
+      const templateString = this.readFile(templatePath);
+      const templateFn = this.compile(templateString, options);
+      if (this.config.cache) templateStore.define(templatePath, templateFn);
+      return templateFn;
+    }
+  } else {
+    const cachedTemplate = templateStore.get(template);
+    if (cachedTemplate) return cachedTemplate;
+    else throw new EtaNameResolutionError(`Failed to get template '${template}'`);
+  }
+}
+function render(template, data, meta) {
+  let templateFn;
+  const options = {
+    ...meta,
+    async: false
+  };
+  if (typeof template === "string") {
+    if (this.resolvePath && this.readFile && !template.startsWith("@")) options.filepath = this.resolvePath(template, options);
+    templateFn = handleCache.call(this, template, options);
+  } else templateFn = template;
+  return templateFn.call(this, data, options);
+}
+function renderAsync(template, data, meta) {
+  let templateFn;
+  const options = {
+    ...meta,
+    async: true
+  };
+  if (typeof template === "string") {
+    if (this.resolvePath && this.readFile && !template.startsWith("@")) options.filepath = this.resolvePath(template, options);
+    templateFn = handleCache.call(this, template, options);
+  } else templateFn = template;
+  const res = templateFn.call(this, data, options);
+  return Promise.resolve(res);
+}
+function renderString(template, data) {
+  const templateFn = this.compile(template, { async: false });
+  return render.call(this, templateFn, data);
+}
+function renderStringAsync(template, data) {
+  const templateFn = this.compile(template, { async: true });
+  return renderAsync.call(this, templateFn, data);
+}
+var Cacher = class {
+  constructor(cache) {
+    this.cache = cache;
+  }
+  define(key, val) {
+    this.cache[key] = val;
+  }
+  get(key) {
+    return this.cache[key];
+  }
+  remove(key) {
+    delete this.cache[key];
+  }
+  reset() {
+    this.cache = {};
+  }
+  load(cacheObj) {
+    this.cache = {
+      ...this.cache,
+      ...cacheObj
+    };
+  }
+};
+var Eta$1 = class {
+  constructor(customConfig) {
+    if (customConfig) this.config = {
+      ...defaultConfig,
+      ...customConfig
+    };
+    else this.config = { ...defaultConfig };
+  }
+  config;
+  RuntimeErr = RuntimeErr;
+  compile = compile;
+  compileToString = compileToString;
+  compileBody = compileBody;
+  parse = parse;
+  render = render;
+  renderAsync = renderAsync;
+  renderString = renderString;
+  renderStringAsync = renderStringAsync;
+  filepathCache = {};
+  templatesSync = new Cacher({});
+  templatesAsync = new Cacher({});
+  resolvePath = null;
+  readFile = null;
+  configure(customConfig) {
+    this.config = {
+      ...this.config,
+      ...customConfig
+    };
+  }
+  withConfig(customConfig) {
+    return {
+      ...this,
+      config: {
+        ...this.config,
+        ...customConfig
+      }
+    };
+  }
+  loadTemplate(name, template, options) {
+    if (typeof template === "string") (options?.async ? this.templatesAsync : this.templatesSync).define(name, this.compile(template, options));
+    else {
+      let templates = this.templatesSync;
+      if (template.constructor.name === "AsyncFunction" || options?.async) templates = this.templatesAsync;
+      templates.define(name, template);
+    }
+  }
+};
+var Eta = class extends Eta$1 {
+  readFile = readFile;
+  resolvePath = resolvePath;
+};
+
+// src/core/template/types.ts
+var TEMPLATE_EXTENSION = ".tmpl";
+var HELPER_FILENAME = "$helpers";
+var HELPER_EXTENSIONS = [".ts", ".js", ".mjs"];
+var IS_COMPILED = import.meta.url.includes("$bunfs");
+async function loadJs(filepath) {
+  const mod = IS_COMPILED ? await loadWithBunBuild(filepath) : await loadWithImport(filepath);
+  return mod["default"] !== void 0 ? mod["default"] : mod;
+}
+async function loadWithBunBuild(filepath) {
+  const fileDir = dirname(filepath);
+  const tmpFile = join(fileDir, `.noorm-helper-${randomBytes(8).toString("hex")}.js`);
+  const result = await Bun.build({
+    entrypoints: [filepath],
+    outdir: fileDir,
+    naming: tmpFile.split("/").pop(),
+    target: "bun",
+    format: "esm"
+  });
+  if (!result.success) {
+    const messages = result.logs.map((l) => l.message).join("; ");
+    throw new Error(`Failed to bundle ${filepath}: ${messages}`);
+  }
+  const mod = await import(pathToFileURL(tmpFile).href);
+  unlinkSync(tmpFile);
+  return mod;
+}
+async function loadWithImport(filepath) {
+  const url = pathToFileURL(filepath).href;
+  const urlWithCacheBust = `${url}?t=${Date.now()}`;
+  return await import(urlWithCacheBust);
+}
+
+// src/core/template/helpers.ts
+async function findHelperFiles(fromDir, projectRoot) {
+  const helperPaths = [];
+  let currentDir = path__default.resolve(fromDir);
+  const root = path__default.resolve(projectRoot);
+  while (currentDir.startsWith(root)) {
+    const helperPath = await findHelperInDir(currentDir);
+    if (helperPath) {
+      helperPaths.unshift(helperPath);
+    }
+    const parentDir = path__default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return helperPaths;
+}
+async function findHelperInDir(dir) {
+  for (const ext of HELPER_EXTENSIONS) {
+    const filepath = path__default.join(dir, `${HELPER_FILENAME}${ext}`);
+    const [stats] = await attempt(() => stat(filepath));
+    if (stats?.isFile()) {
+      return filepath;
+    }
+  }
+  return null;
+}
+async function loadHelpers(fromDir, projectRoot) {
+  const helperPaths = await findHelperFiles(fromDir, projectRoot);
+  const merged = {};
+  const errors = [];
+  for (const filepath of helperPaths) {
+    const [mod, err] = await attempt(() => loadJs(filepath));
+    if (err) {
+      errors.push({ filepath, error: err });
+      observer.emit("error", {
+        source: "template",
+        error: err,
+        context: { filepath, operation: "load-helpers" }
+      });
+      continue;
+    }
+    if (mod && typeof mod === "object") {
+      const exports$1 = mod;
+      const exportCount = Object.keys(exports$1).length;
+      Object.assign(merged, exports$1);
+      observer.emit("template:helpers", {
+        filepath,
+        count: exportCount
+      });
+    }
+  }
+  return { helpers: merged, errors };
+}
+async function loadSql(filepath) {
+  return readFile$1(filepath, "utf-8");
+}
+
+// src/core/dt/constants.ts
+var FORMAT_VERSION = 1;
+var ENCODED_TYPES = {
+  json: true,
+  binary: true,
+  vector: true,
+  array: true,
+  text: true,
+  custom: true
+};
+var DT_EXTENSIONS = {
+  /** Raw .dt file (uncompressed JSON5 lines). */
+  RAW: ".dt",
+  /** Gzip-compressed .dt file. */
+  COMPRESSED: ".dtz",
+  /** Gzip-compressed and AES-256-GCM encrypted .dt file. */
+  ENCRYPTED: ".dtzx"
+};
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 16;
+var SALT_LENGTH = 32;
+var AUTH_TAG_LENGTH = 16;
+var KEY_LENGTH = 32;
+var PBKDF2_ITERATIONS = 1e5;
+var PBKDF2_DIGEST = "sha256";
+function encryptWithPassphrase(data, passphrase) {
+  const salt = randomBytes(SALT_LENGTH);
+  const iv = randomBytes(IV_LENGTH);
+  const key = pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, PBKDF2_DIGEST);
+  const cipher = createCipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return {
+    salt: salt.toString("base64"),
+    iv: iv.toString("base64"),
+    authTag: authTag.toString("base64"),
+    ciphertext: ciphertext.toString("base64")
+  };
+}
+function decryptWithPassphrase(payload, passphrase) {
+  const salt = Buffer.from(payload.salt, "base64");
+  const iv = Buffer.from(payload.iv, "base64");
+  const authTag = Buffer.from(payload.authTag, "base64");
+  const ciphertext = Buffer.from(payload.ciphertext, "base64");
+  const key = pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, PBKDF2_DIGEST);
+  const decipher = createDecipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  decipher.setAuthTag(authTag);
+  const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return decrypted;
+}
+
+// src/core/dt/reader.ts
+var DtReader = class {
+  #filepath;
+  #passphrase;
+  #extension;
+  #schema = null;
+  #lineReader = null;
+  #inputStream = null;
+  /**
+   * Create a new DtReader.
+   *
+   * @param options - File path and optional passphrase for .dtzx
+   */
+  constructor(options) {
+    this.#filepath = options.filepath;
+    this.#passphrase = options.passphrase;
+    this.#extension = path__default.extname(options.filepath).toLowerCase();
+  }
+  /** The parsed schema from line 1. Available after open(). */
+  get schema() {
+    return this.#schema;
+  }
+  /**
+   * Open the file and parse the schema header.
+   *
+   * Must be called before iterating rows.
+   */
+  async open() {
+    const readable = this.#createReadableStream();
+    this.#inputStream = readable;
+    const rl = createInterface({ input: readable, crlfDelay: Infinity });
+    const lines = rl[Symbol.asyncIterator]();
+    const firstLine = await lines.next();
+    if (firstLine.done || !firstLine.value) {
+      throw new Error("Empty .dt file \u2014 no schema line");
+    }
+    this.#schema = dist_default.parse(firstLine.value);
+    if (this.#schema.v !== 1) {
+      throw new Error(`Unsupported .dt format version: ${this.#schema.v}`);
+    }
+    this.#lineReader = this.#createRowIterator(lines);
+  }
+  /**
+   * Async generator yielding parsed row value arrays.
+   *
+   * Each yield is a `DtValue[]` in column order matching the schema.
+   *
+   * @example
+   * ```typescript
+   * for await (const values of reader.rows()) {
+   *     console.log(values); // [1, "alice@example.com", true, "2024-01-15T10:30:00Z"]
+   * }
+   * ```
+   */
+  async *rows() {
+    if (!this.#lineReader) {
+      throw new Error("Reader not opened \u2014 call open() first");
+    }
+    yield* this.#lineReader;
+  }
+  /**
+   * Close the reader and release resources.
+   */
+  close() {
+    if (this.#inputStream) {
+      this.#inputStream.destroy();
+      this.#inputStream = null;
+    }
+  }
+  /**
+   * Create the readable stream based on file extension.
+   */
+  #createReadableStream() {
+    if (this.#extension === DT_EXTENSIONS.ENCRYPTED) {
+      if (!this.#passphrase) {
+        throw new Error("Passphrase required for .dtzx files");
+      }
+      const encrypted = readFileSync(this.#filepath, "utf8");
+      const payload = JSON.parse(encrypted);
+      const compressed = decryptWithPassphrase(payload, this.#passphrase);
+      const raw = gunzipSync(compressed);
+      const stream = new PassThrough();
+      stream.end(raw);
+      return stream;
+    }
+    if (this.#extension === DT_EXTENSIONS.COMPRESSED) {
+      const fileStream = createReadStream(this.#filepath);
+      const gunzip = createGunzip();
+      fileStream.pipe(gunzip);
+      return gunzip;
+    }
+    return createReadStream(this.#filepath, { encoding: "utf8" });
+  }
+  /**
+   * Create async generator from remaining readline lines.
+   */
+  async *#createRowIterator(lines) {
+    for await (const line of { [Symbol.asyncIterator]: () => lines }) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      yield dist_default.parse(trimmed);
+    }
+  }
+};
+
+// src/core/template/loaders/dt.ts
+async function loadDt(filepath) {
+  const reader = new DtReader({ filepath });
+  await reader.open();
+  const schema = reader.schema;
+  if (!schema) {
+    throw new Error(`Failed to read .dt schema from: ${filepath}`);
+  }
+  const columnNames = schema.columns.map((c) => c.name);
+  const rows = [];
+  for await (const values of reader.rows()) {
+    const row = {};
+    for (let i = 0; i < columnNames.length; i++) {
+      row[columnNames[i]] = values[i] ?? null;
+    }
+    rows.push(row);
+  }
+  reader.close();
+  return rows;
+}
+
+// src/core/template/loaders/index.ts
+async function lazyLoadJson5(filepath) {
+  const { loadJson5: loadJson52 } = await import('./json5-LNT3RGJ7.js');
+  return loadJson52(filepath);
+}
+async function lazyLoadYaml(filepath) {
+  const { loadYaml: loadYaml2 } = await import('./yaml-XI7RQ2D5.js');
+  return loadYaml2(filepath);
+}
+async function lazyLoadCsv(filepath) {
+  const { loadCsv: loadCsv2 } = await import('./csv-T5P3IN4K.js');
+  return loadCsv2(filepath);
+}
+var loaders = {
+  ".json": lazyLoadJson5,
+  ".json5": lazyLoadJson5,
+  ".yaml": lazyLoadYaml,
+  ".yml": lazyLoadYaml,
+  ".csv": lazyLoadCsv,
+  ".js": loadJs,
+  ".mjs": loadJs,
+  ".ts": loadJs,
+  ".sql": loadSql,
+  ".dt": loadDt,
+  ".dtz": loadDt
+  // NO .dtzx — can't provide passphrase in template context
+};
+function hasLoader(ext) {
+  return ext in loaders;
+}
+function getLoader(ext) {
+  return loaders[ext];
+}
+async function loadDataFile(filepath) {
+  const ext = path__default.extname(filepath).toLowerCase();
+  const loader = getLoader(ext);
+  if (!loader) {
+    throw new Error(`No loader registered for extension: ${ext}`);
+  }
+  return loader(filepath);
+}
+function camelCase(str) {
+  const words = str.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[-_\s]+/).filter(Boolean);
+  if (words.length === 0) return "";
+  return words.map((w, i) => i === 0 ? w.toLowerCase() : w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function toContextKey(filename) {
+  const ext = path__default.extname(filename);
+  const base = path__default.basename(filename, ext);
+  return camelCase(base);
+}
+function sqlEscape(value) {
+  return value.replace(/'/g, "''");
+}
+function sqlQuote(value) {
+  if (value === null) {
+    return "NULL";
+  }
+  return `'${sqlEscape(String(value))}'`;
+}
+function generateUuid() {
+  return crypto.randomUUID();
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/core/template/context.ts
+async function buildContext(templatePath, options = {}) {
+  const templateDir = path__default.dirname(templatePath);
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const { helpers } = await loadHelpers(templateDir, projectRoot);
+  const dataFiles = await loadDataFilesInDir(templateDir);
+  const hasLocalConfig = "config" in dataFiles;
+  const ctx = {
+    // Inherited helpers (can be overridden by data files with same name)
+    ...helpers,
+    // Auto-loaded data files
+    ...dataFiles,
+    // Config (only if no local config.* file)
+    ...hasLocalConfig ? {} : { config: options.config },
+    // Secrets
+    secrets: options.secrets ?? {},
+    globalSecrets: options.globalSecrets ?? {},
+    // Environment
+    env: process.env,
+    // Built-in helpers
+    include: createIncludeHelper(templateDir, projectRoot, options),
+    escape: sqlEscape,
+    quote: sqlQuote,
+    json: (value) => JSON.stringify(value),
+    now: isoNow,
+    uuid: generateUuid
+  };
+  return ctx;
+}
+async function loadDataFilesInDir(dir) {
+  const data = {};
+  const [entries, readErr] = await attempt(() => readdir(dir, { withFileTypes: true }));
+  if (readErr || !entries) {
+    observer.emit("error", {
+      source: "template",
+      error: readErr ?? new Error("Failed to read directory"),
+      context: { dir, operation: "scan-data-files" }
+    });
+    return data;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (entry.name.startsWith(".") || entry.name.startsWith(HELPER_FILENAME)) {
+      continue;
+    }
+    if (entry.name.endsWith(".tmpl")) {
+      continue;
+    }
+    const ext = path__default.extname(entry.name).toLowerCase();
+    if (!hasLoader(ext)) {
+      continue;
+    }
+    if (ext === ".sql") {
+      continue;
+    }
+    const filepath = path__default.join(dir, entry.name);
+    const key = toContextKey(entry.name);
+    const [loaded, loadErr] = await attempt(() => loadDataFile(filepath));
+    if (loadErr) {
+      observer.emit("error", {
+        source: "template",
+        error: loadErr,
+        context: { filepath, operation: "load-data-file" }
+      });
+      continue;
+    }
+    data[key] = loaded;
+    observer.emit("template:load", {
+      filepath,
+      format: ext
+    });
+  }
+  return data;
+}
+function createIncludeHelper(templateDir, projectRoot, options) {
+  return async (includePath) => {
+    const resolved = path__default.resolve(templateDir, includePath);
+    if (!resolved.startsWith(projectRoot)) {
+      throw new Error(`Include path escapes project root: ${includePath}`);
+    }
+    if (resolved.endsWith(".tmpl")) {
+      const { processFile: processFile2 } = await import('./engine-27DNMF4T.js');
+      const result = await processFile2(resolved, options);
+      return result.sql;
+    }
+    const [content, err] = await attempt(() => loadDataFile(resolved));
+    if (err) {
+      throw new Error(`Failed to include '${includePath}': ${err.message}`);
+    }
+    if (typeof content === "string") {
+      return content;
+    }
+    return JSON.stringify(content);
+  };
+}
+
+// src/core/template/engine.ts
+var DIRECTIVE_LINE_RE = /^[ \t]*-- (\{%.*?%\})[ \t]*$(?:\r?\n)?/gm;
+var eta = new Eta({
+  // Custom tags for code blocks
+  tags: ["{%", "%}"],
+  // Variable name for context ($ instead of it)
+  varName: "$",
+  // Don't auto-escape (SQL doesn't need HTML escaping)
+  autoEscape: false,
+  // Disabled — directive-line stripping handles whitespace instead
+  autoTrim: [false, false],
+  // Allow async functions in templates
+  useWith: false,
+  // Don't cache templates (we handle caching at a higher level)
+  cache: false
+});
+function isTemplate(filepath) {
+  return filepath.endsWith(TEMPLATE_EXTENSION);
+}
+async function renderTemplate(template, context) {
+  const prepared = template.replace(DIRECTIVE_LINE_RE, "$1");
+  const result = await eta.renderStringAsync(prepared, context);
+  return result.replace(/^\n+|\n+$/g, "");
+}
+async function processFile(filepath, options = {}) {
+  const content = await readFile$1(filepath, "utf-8");
+  if (!isTemplate(filepath)) {
+    return {
+      sql: content,
+      isTemplate: false
+    };
+  }
+  const start = performance.now();
+  const context = await buildContext(filepath, options);
+  const sql = await renderTemplate(content, context);
+  const durationMs = performance.now() - start;
+  observer.emit("template:render", {
+    filepath,
+    durationMs
+  });
+  return {
+    sql,
+    isTemplate: true,
+    durationMs
+  };
+}
+async function processFiles(filepaths, options = {}) {
+  const results = [];
+  for (const filepath of filepaths) {
+    const result = await processFile(filepath, options);
+    results.push(result);
+  }
+  return results;
+}
+
+export { DT_EXTENSIONS, DtReader, ENCODED_TYPES, FORMAT_VERSION, encryptWithPassphrase, eta, isTemplate, processFile, processFiles, renderTemplate };
+//# sourceMappingURL=chunk-3UDETNWW.js.map
+//# sourceMappingURL=chunk-3UDETNWW.js.map