cosmemilton-acbr-node 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,1652 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/generator.ts
+var generator_exports = {};
+__export(generator_exports, {
+  buildModelIR: () => buildModelIR,
+  compareContracts: () => compareContracts,
+  generateModel: () => generateModel,
+  renderClientIndex: () => renderClientIndex,
+  renderPascal: () => renderPascal,
+  renderTypeScript: () => renderTypeScript
+});
+import { createHash as createHash3 } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4, readdir as readdir4 } from "node:fs/promises";
+import path2 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function buildModelIR(raw) {
+  const declarations = /* @__PURE__ */ new Map();
+  for (const unit of raw.units) for (const type of unit.types) declarations.set((unit.name + "." + type.name).toLowerCase(), { unit, type });
+  function find(name, unit) {
+    for (const key of [unit.name + "." + name, ...[...unit.uses].reverse().map((u) => u + "." + name), name]) {
+      const item = declarations.get(key.toLowerCase());
+      if (item) return item;
+    }
+    throw new Error("Tipo Pascal n\xE3o resolvido: " + unit.name + "." + name);
+  }
+  function resolve5(name, unit, trail = /* @__PURE__ */ new Set()) {
+    if (primitives[name.toLowerCase()]) return { primitive: name.toLowerCase() };
+    const found = find(name, unit), key = (found.unit.name + "." + found.type.name).toLowerCase();
+    if (trail.has(key)) throw new Error("Alias Pascal c\xEDclico: " + key);
+    if (found.type.kind === "alias") {
+      trail.add(key);
+      return resolve5(found.type.target, found.unit, trail);
+    }
+    return found;
+  }
+  const rootUnit = raw.units.find((u) => u.types.some((t) => t.name === raw.root));
+  if (!rootUnit) throw new Error("Modelo raiz ausente: " + raw.root);
+  const generated = /* @__PURE__ */ new Map();
+  function visit(name, unit) {
+    const found = resolve5(name, unit);
+    if ("primitive" in found) return primitives[found.primitive];
+    const { type, unit: declUnit } = found, key = type.name;
+    if (generated.has(key)) {
+      const node2 = generated.get(key);
+      if (node2.unit !== declUnit.name) throw new Error("Tipos hom\xF4nimos incompat\xEDveis: " + key);
+      return { kind: node2.kind === "object" ? "object" : node2.kind === "list" ? "list" : "enum", ref: key };
+    }
+    if (type.kind === "enum") {
+      const values = type.values.map((v) => v.name);
+      if (!values.length) throw new Error("Enum sem valores: " + key);
+      generated.set(key, { name: key, unit: declUnit.name, kind: "enum", values });
+      return { kind: "enum", ref: key };
+    }
+    if (type.kind !== "class") throw new Error("Declara\xE7\xE3o Pascal n\xE3o suportada: " + declUnit.name + "." + key + " (" + (type.declarationKind ?? type.kind) + ")");
+    const creator = type.methods?.find((m) => m.name.toLowerCase() === "new" && m.arguments === 0);
+    const indexed = type.properties?.find((p) => p.indexed && p.name.toLowerCase() === "items");
+    if (creator || indexed) {
+      if (!creator || !indexed || !indexed.readable) throw new Error("Cole\xE7\xE3o sem contrato New/Items tipado: " + key);
+      const item = resolve5(creator.result, declUnit), itemProperty = resolve5(indexed.type, declUnit);
+      if ("primitive" in item || "primitive" in itemProperty || item.type.name !== itemProperty.type.name) throw new Error("Cole\xE7\xE3o com tipos New/Items divergentes: " + key);
+      generated.set(key, { name: key, unit: declUnit.name, kind: "list", item: item.type.name, factory: creator.name });
+      if (visit(creator.result, declUnit).kind !== "object") throw new Error("Item de cole\xE7\xE3o n\xE3o \xE9 objeto: " + key);
+      return { kind: "list", ref: key };
+    }
+    const node = { name: key, unit: declUnit.name, kind: "object", properties: [] };
+    generated.set(key, node);
+    let inherited = [];
+    if (type.ancestor && !bases.has(type.ancestor.toLowerCase())) {
+      const ancestor = visit(type.ancestor, declUnit);
+      if (ancestor.kind !== "object") throw new Error("Heran\xE7a n\xE3o suportada: " + key);
+      inherited = generated.get(ancestor.ref).properties;
+    }
+    const props = new Map(inherited.map((p) => [p.name.toLowerCase(), p]));
+    for (const p of type.properties ?? []) {
+      if (p.indexed) throw new Error("Propriedade indexada fora de cole\xE7\xE3o: " + key + "." + p.name);
+      if (!p.readable) throw new Error("Propriedade sem leitura: " + key + "." + p.name);
+      const resolved = visit(p.type, declUnit);
+      const readonly = !p.writable && !["object", "list"].includes(resolved.kind) || key === raw.root && ["signature", "procnfe", "infnfesupl"].includes(p.name.toLowerCase());
+      props.set(p.name.toLowerCase(), { name: p.name, type: p.type, ...resolved, readonly, ...p.default ? { declaredDefault: p.default } : {} });
+    }
+    node.properties = [...props.values()].sort((a, b) => a.name.localeCompare(b.name, "en"));
+    return { kind: "object", ref: key };
+  }
+  visit(raw.root, rootUnit);
+  return { schemaVersion: 1, root: raw.root, types: [...generated.values()].sort((a, b) => a.name.localeCompare(b.name, "en")) };
+}
+function compareContracts(previous, current) {
+  const old = new Map(previous?.types.map((t) => [t.name, t]) ?? []), now = new Map(current.types.map((t) => [t.name, t]));
+  const additions = [], removals = [], changes = [];
+  for (const [name, type] of now) {
+    const before = old.get(name);
+    if (!before) {
+      additions.push(name);
+      continue;
+    }
+    if (type.kind !== before.kind) {
+      changes.push(name + ":kind");
+      continue;
+    }
+    if (type.kind === "object") {
+      const a = new Map(before.properties.map((p) => [p.name, p])), b = new Map(type.properties.map((p) => [p.name, p]));
+      for (const [field, p] of b) {
+        if (!a.has(field)) additions.push(name + "." + field);
+        else if (stable(a.get(field)) !== stable(p)) changes.push(name + "." + field);
+      }
+      for (const field of a.keys()) if (!b.has(field)) removals.push(name + "." + field);
+    } else if (type.kind === "enum") {
+      for (const v of type.values) if (!before.values.includes(v)) additions.push(name + "." + v);
+      for (const v of before.values) if (!type.values.includes(v)) removals.push(name + "." + v);
+    } else if (type.item !== before.item) changes.push(name + ":item");
+  }
+  for (const name of old.keys()) if (!now.has(name)) removals.push(name);
+  return { additions: additions.sort(), removals: removals.sort(), changes: changes.sort(), breaking: removals.length > 0 || changes.length > 0 };
+}
+function renderTypeScript(ir, revision2, contractHash) {
+  const out = ["// Generated from ACBr AST. LGPL-2.1-or-later. Do not edit.", "export const ACBR_CONTRACT = " + stable({ sourceRevision: revision2, contractHash }) + " as const;", "export const SOURCE_REVISION=ACBR_CONTRACT.sourceRevision;", "export const CONTRACT_HASH=ACBR_CONTRACT.contractHash;"];
+  for (const t of ir.types) {
+    if (t.kind === "enum") {
+      out.push("export const " + t.name + " = Object.freeze(" + stable(Object.fromEntries(t.values.map((v) => [v, v]))) + " as const);", "export type " + t.name + " = typeof " + t.name + "[keyof typeof " + t.name + "];");
+    } else if (t.kind === "list") {
+      out.push("export type " + t.name + "Input = " + t.item + "Input[];", "export class " + t.name + " extends Array<" + t.item + "> {", "  New(input: " + t.item + "Input = {}): " + t.item + " { const item=new " + t.item + "(input); this.push(item); return item; }", "}");
+    } else {
+      out.push("export interface " + t.name + "Input {");
+      for (const p of t.properties.filter((p2) => !p2.readonly)) out.push("  " + JSON.stringify(p.name) + "?: " + tsType(p) + ";");
+      out.push("}", "export class " + t.name + " {");
+      for (const p of t.properties) {
+        if (p.readonly) {
+          out.push("  readonly " + JSON.stringify(p.name) + "?: " + tsType(p) + ";");
+          continue;
+        }
+        if (p.declaredDefault) out.push("  /** Pascal streaming default: " + p.declaredDefault.replaceAll("*/", "") + ". Omission preserves the native constructor. */");
+        if (p.kind === "object" || p.kind === "list") out.push("  " + JSON.stringify(p.name) + " = new " + p.ref + "();");
+        else out.push("  " + JSON.stringify(p.name) + "?: " + tsType(p) + ";");
+      }
+      out.push("  constructor(input: " + t.name + "Input = {}) {", "    validateModel(" + JSON.stringify(t.name) + ", input);");
+      for (const p of t.properties.filter((p2) => !p2.readonly)) {
+        const access5 = "input[" + JSON.stringify(p.name) + "]", target = "this[" + JSON.stringify(p.name) + "]";
+        out.push("    if (" + access5 + " !== undefined) " + target + " = " + (p.kind === "object" ? "new " + p.ref + "(" + access5 + ")" : p.kind === "list" ? "Object.assign(new " + p.ref + "(), " + access5 + ".map(v=>new " + ir.types.find((t2) => t2.name === p.ref).item + "(v)))" : access5) + ";");
+      }
+      out.push("  }", "}");
+    }
+  }
+  out.push("const MODEL_SCHEMA: Record<string, any> = " + stable(Object.fromEntries(ir.types.map((t) => [t.name, t]))) + ";");
+  out.push(String.raw`
+export function validateModel(model: string, value: unknown, at=model): void {
+ const schema=MODEL_SCHEMA[model]; if(!schema)throw new TypeError('Modelo desconhecido: '+model);
+ if(schema.kind==='enum'){ if(typeof value!=='string'||!schema.values.includes(value))throw new TypeError(at+': enum inválido'); return; }
+ if(schema.kind==='list'){ if(!Array.isArray(value))throw new TypeError(at+': esperado array'); value.forEach((item,index)=>validateModel(schema.item,item,at+'['+index+']'));return; }
+ if(value===null||typeof value!=='object'||Array.isArray(value))throw new TypeError(at+': esperado objeto');
+ const fields=new Map<string,any>(schema.properties.filter((p:any)=>!p.readonly).map((p:any)=>[p.name,p]));
+ for(const [name,v] of Object.entries(value)){
+  if(v===undefined)continue;
+  const p=fields.get(name);if(!p)throw new TypeError(at+'.'+name+': propriedade desconhecida ou somente leitura');
+  if(v===undefined)continue;
+  const field=at+'.'+name;
+  if(p.ref){validateModel(p.ref,v,field);continue;}
+  if(p.kind==='integer'){if(typeof v!=='number'||!Number.isSafeInteger(v)||v<p.min||v>p.max)throw new TypeError(field+': inteiro fora do intervalo');}
+  else if(p.kind==='boolean'){if(typeof v!=='boolean')throw new TypeError(field+': esperado boolean');}
+  else if(p.kind==='decimal'){if(typeof v!=='string'||v.length>64||! /^-?\d+(?:\.\d+)?$/.test(v)||p.scale!==undefined&&(v.split('.')[1]?.length??0)>p.scale)throw new TypeError(field+': esperado decimal em string'+(p.scale!==undefined?' de até '+p.scale+' casas':''));}
+  else if(p.kind==='datetime'){
+   if(typeof v!=='string'||! /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)?$/.test(v)||Number.isNaN(Date.parse(v+(v.length===10?'T00:00:00Z':'Z'))))throw new TypeError(field+': esperado data/hora civil ISO (sem timezone)');
+   const date=new Date(v+(v.length===10?'T00:00:00Z':'Z'));if(date.toISOString().slice(0,10)!==v.slice(0,10))throw new TypeError(field+': data inválida');
+  }else if(typeof v!=='string')throw new TypeError(field+': esperado string');
+ }
+}
+export function validateTNFe(value: unknown): asserts value is TNFeInput { validateModel('TNFe',value); }
+`);
+  return out.join("\n") + "\n";
+}
+function renderPascal(ir, revision2, contractHash) {
+  const classes = ir.types.filter((t) => t.kind === "object"), byName = new Map(ir.types.map((t) => [t.name, t]));
+  const units = [...new Set(ir.types.map((t) => t.unit))].sort();
+  const out = ["{ Generated from ACBr AST. LGPL-2.1-or-later. Do not edit. }", "unit AcbrModels;", "{$mode delphi}{$H+}", "interface", "uses SysUtils, Classes, fpjson, DateUtils, Math, " + units.join(", ") + ";", "const SourceRevision = " + revision2 + ";", "      ContractHash = '" + contractHash + "';", "procedure preencherTNFe(documento:TJSONObject; destino:TNFe);", "implementation"];
+  out.push(String.raw`
+procedure Bad(const P,M:string); begin raise Exception.Create(P+': '+M) end;
+function Obj(D:TJSONData;const P:string):TJSONObject;
+begin if (D=nil) or (D.JSONType<>jtObject) then Bad(P,'esperado objeto');Result:=TJSONObject(D) end;
+function Arr(D:TJSONData;const P:string):TJSONArray;
+begin if (D=nil) or (D.JSONType<>jtArray) then Bad(P,'esperado array');Result:=TJSONArray(D) end;
+function Text(D:TJSONData;const P:string):string;
+begin if (D=nil) or (D.JSONType<>jtString) then Bad(P,'esperado string');Result:=D.AsString end;
+function IntValue(D:TJSONData;const P:string;MinV,MaxV:Int64):Int64;
+var V:Extended;
+begin
+ if (D=nil) or (D.JSONType<>jtNumber) then Bad(P,'esperado inteiro');
+ V:=D.AsFloat;if IsNan(V) or IsInfinite(V) or (Frac(V)<>0) or (V<MinV) or (V>MaxV) then Bad(P,'inteiro fora do intervalo');
+ Result:=D.AsInt64;
+end;
+function BoolValue(D:TJSONData;const P:string):boolean;
+begin if (D=nil) or (D.JSONType<>jtBoolean) then Bad(P,'esperado boolean');Result:=D.AsBoolean end;
+function DecimalText(D:TJSONData;const P:string;Scale:integer):string;
+var I,PointPos:integer;
+begin
+ Result:=Text(D,P);PointPos:=0;
+ if (Result='') or (Length(Result)>64) then Bad(P,'decimal inválido');
+ for I:=1 to Length(Result) do begin
+  if Result[I]='.' then begin if (PointPos>0) or (I=1) or ((I=2) and (Result[1]='-')) or (I=Length(Result)) then Bad(P,'decimal inválido');PointPos:=I end
+  else if (Result[I]='-') and (I=1) then begin if Length(Result)=1 then Bad(P,'decimal inválido') end
+  else if not (Result[I] in ['0'..'9']) then Bad(P,'decimal inválido');
+ end;
+ if (PointPos>0) and (Scale>=0) and (Length(Result)-PointPos>Scale) then Bad(P,'casas decimais excedidas');
+end;
+function FloatValue(D:TJSONData;const P:string):Extended;
+var F:TFormatSettings;S:string;
+begin F:=DefaultFormatSettings;F.DecimalSeparator:='.';F.ThousandSeparator:=#0;S:=DecimalText(D,P,-1);
+ if not TryStrToFloat(S,Result,F) or IsNan(Result) or IsInfinite(Result) then Bad(P,'decimal fora do intervalo');
+end;
+function CurrencyValue(D:TJSONData;const P:string):Currency;
+var F:TFormatSettings;S:string;
+begin F:=DefaultFormatSettings;F.DecimalSeparator:='.';F.ThousandSeparator:=#0;S:=DecimalText(D,P,4);
+ if not TryStrToCurr(S,Result,F) then Bad(P,'currency fora do intervalo');
+end;
+function DateValue(D:TJSONData;const P:string):TDateTime;
+var S:string;I:integer;
+begin
+ S:=Text(D,P);
+ if not (Length(S) in [10,19,21,22,23]) then Bad(P,'esperado data/hora civil ISO sem timezone');
+ for I:=1 to Length(S) do if not ((S[I] in ['0'..'9']) or ((I in [5,8]) and (S[I]='-')) or ((I=11) and (S[I]='T')) or ((I in [14,17]) and (S[I]=':')) or ((I=20) and (S[I]='.'))) then Bad(P,'data ISO inválida');
+ if not TryISO8601ToDate(S,Result,true) then Bad(P,'data ISO inválida');
+end;
+`);
+  const q = (s) => "'" + s.replaceAll("'", "''") + "'";
+  for (const t of classes) out.push("procedure Load_" + t.name + "(D:TJSONObject;destino:" + t.unit + "." + t.name + ";const P:string); forward;");
+  for (const t of classes) {
+    out.push("procedure Load_" + t.name + "(D:TJSONObject;destino:" + t.unit + "." + t.name + ";const P:string);", "var I,J:integer;V:TJSONData;A:TJSONArray;K,At:string;", "begin", " if destino=nil then Bad(P,'objeto ACBr n\xE3o inicializado');", " for I:=0 to D.Count-1 do begin", "  K:=D.Names[I];V:=D.Items[I];At:=P+'.'+K;");
+    let index = 0;
+    for (const p of t.properties.filter((p2) => !p2.readonly)) {
+      out.push("  " + (index++ ? "else " : "") + "if K=" + q(p.name) + " then begin");
+      const target = "destino." + p.name;
+      if (p.kind === "object") out.push("   Load_" + p.ref + "(Obj(V,At)," + target + ",At);");
+      else if (p.kind === "list") {
+        const list = byName.get(p.ref);
+        out.push("   A:=Arr(V,At);if " + target + "=nil then Bad(At,'cole\xE7\xE3o n\xE3o inicializada');" + target + ".Clear;", "   for J:=0 to A.Count-1 do Load_" + list.item + "(Obj(A.Items[J],At+'['+IntToStr(J)+']')," + target + "." + list.factory + ",At+'['+IntToStr(J)+']');");
+      } else if (p.kind === "enum") {
+        const enumeration = byName.get(p.ref);
+        out.push(...enumeration.values.map((v, i) => "   " + (i ? "else " : "") + "if Text(V,At)=" + q(v) + " then " + target + ":=" + enumeration.unit + "." + v), "   else Bad(At,'enum inv\xE1lido');");
+      } else out.push("   " + target + ":=" + { string: "Text(V,At)", integer: "IntValue(V,At," + p.min + "," + p.max + ")", boolean: "BoolValue(V,At)", datetime: "DateValue(V,At)", decimal: p.scale === 4 ? "CurrencyValue(V,At)" : "FloatValue(V,At)" }[p.kind] + ";");
+      out.push("  end");
+    }
+    out.push((index ? "  else " : "  ") + "Bad(At,'propriedade desconhecida ou somente leitura');", " end;", "end;");
+  }
+  out.push("procedure preencherTNFe(documento:TJSONObject;destino:TNFe);", "begin if documento=nil then Bad('TNFe','esperado objeto');Load_TNFe(documento,destino,'TNFe') end;", "end.");
+  return out.join("\n") + "\n";
+}
+function renderClientIndex() {
+  return [
+    "// Generated client bound to its own ACBr contract. Do not edit.",
+    "import { criarEmissor as criarRuntime, type OpcoesEmissor, type OpcoesOperacao } from " + JSON.stringify("cosmemilton-acbr-node/runtime") + ";",
+    "import { ACBR_CONTRACT, validateTNFe, type TNFeInput } from " + JSON.stringify("./models.js") + ";",
+    "export * from " + JSON.stringify("./models.js") + ";",
+    "export function criarEmissor(options: Omit<OpcoesEmissor, " + JSON.stringify("contrato") + " | " + JSON.stringify("validaDocumento") + ">) {",
+    " const emissor=criarRuntime({...options, contrato:ACBR_CONTRACT, validaDocumento:validateTNFe});",
+    " return {...emissor, gerarXml(documento:TNFeInput, opcoes?:OpcoesOperacao) { return emissor.gerarXml(documento as unknown as Record<string,unknown>, opcoes); }};",
+    "}"
+  ].join("\n") + "\n";
+}
+async function fingerprint(dir) {
+  const files = [];
+  async function walk(d) {
+    for (const entry of await readdir4(d, { withFileTypes: true })) {
+      const f = path2.join(d, entry.name);
+      if (entry.isDirectory()) await walk(f);
+      else if (/\.(pas|pp|inc|xsd)$/i.test(entry.name)) files.push(f);
+    }
+  }
+  await walk(dir);
+  const digest = createHash3("sha256");
+  for (const f of files.sort()) {
+    digest.update(path2.relative(dir, f).replaceAll("\\", "/"));
+    digest.update(await readFile5(f));
+  }
+  return digest.digest("hex");
+}
+async function generateModel(options) {
+  const root = path2.resolve(options.outputDir), cache = path2.join(root, ".acbr/generated"), bin = path2.join(root, ".acbr/bin");
+  const models = path2.resolve(root, options.modelOutputDir ?? "generated/acbr"), native = path2.resolve(root, options.nativeOutputDir ?? "native/generated");
+  await Promise.all([mkdir4(cache, { recursive: true }), mkdir4(bin, { recursive: true }), mkdir4(models, { recursive: true }), mkdir4(native, { recursive: true })]);
+  const extractor = options.extractorPath ?? fileURLToPath2(new URL("../tools/extract-model.lpr", import.meta.url));
+  const executable = path2.join(bin, "extract-model" + (process.platform === "win32" ? ".exe" : ""));
+  try {
+    await execute(options.fpcPath ?? "fpc", ["-Mobjfpc", "-Sh", "-FU" + bin, "-FE" + bin, extractor], { cwd: root, maxBuffer: 8 * 1024 * 1024 });
+    await execute(executable, [path2.resolve(options.acbrRoot), path2.join(cache, "raw-model.json"), process.platform === "win32" ? "win64" : "linux"], { cwd: root, maxBuffer: 8 * 1024 * 1024 });
+  } catch (error) {
+    const e = error;
+    throw new Error("Extra\xE7\xE3o FCL-passrc falhou: " + (e.stderr ?? "") + (e.stdout ?? "") + e.message);
+  }
+  const raw = JSON.parse(await readFile5(path2.join(cache, "raw-model.json"), "utf8"));
+  const ir = buildModelIR(raw), sourceRevision = Number(options.revision);
+  if (!Number.isSafeInteger(sourceRevision) || sourceRevision < 1) throw new Error("Revis\xE3o SVN inv\xE1lida");
+  const sourceHash = options.sourceHash ?? await fingerprint(options.acbrRoot), contractHash = hash(stable({ sourceRevision, sourceHash, ir }));
+  let previous;
+  try {
+    previous = JSON.parse(await readFile5(path2.join(cache, "model.ir.json"), "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const report = compareContracts(previous, ir), reportPath = path2.join(cache, "changes.json"), manifestPath = path2.join(cache, "manifest.json");
+  const files = [path2.relative(root, path2.join(models, "models.ts")), path2.relative(root, path2.join(models, "index.ts")), path2.relative(root, path2.join(native, "AcbrModels.pas"))].map((f) => f.replaceAll("\\", "/"));
+  const content = [renderTypeScript(ir, sourceRevision, contractHash), renderClientIndex(), renderPascal(ir, sourceRevision, contractHash)];
+  const fileHashes = Object.fromEntries(files.map((file, index) => [file, hash(content[index])]));
+  await Promise.all([
+    ...files.map((file, index) => writeFile4(path2.resolve(root, file), content[index], "utf8")),
+    writeFile4(path2.join(cache, "model.ir.json"), JSON.stringify(ir, null, 2) + "\n", "utf8"),
+    writeFile4(reportPath, JSON.stringify(report, null, 2) + "\n", "utf8"),
+    writeFile4(manifestPath, JSON.stringify({ schemaVersion: 1, sourceRevision, sourceHash, contractHash, root: ir.root, models: ir.types.length, files, fileHashes }, null, 2) + "\n", "utf8")
+  ]);
+  return { contractHash, sourceHash, models: ir.types.length, reportPath, manifestPath };
+}
+var execute, bases, primitives, stable, hash, tsType;
+var init_generator = __esm({
+  "src/generator.ts"() {
+    "use strict";
+    execute = promisify(execFile);
+    bases = /* @__PURE__ */ new Set(["tobject", "tpersistent", "tacbrobjectlist"]);
+    primitives = {
+      string: { kind: "string" },
+      ansistring: { kind: "string" },
+      unicodestring: { kind: "string" },
+      widestring: { kind: "string" },
+      boolean: { kind: "boolean" },
+      byte: { kind: "integer", min: 0, max: 255 },
+      word: { kind: "integer", min: 0, max: 65535 },
+      integer: { kind: "integer", min: -2147483648, max: 2147483647 },
+      longint: { kind: "integer", min: -2147483648, max: 2147483647 },
+      smallint: { kind: "integer", min: -32768, max: 32767 },
+      shortint: { kind: "integer", min: -128, max: 127 },
+      cardinal: { kind: "integer", min: 0, max: 4294967295 },
+      longword: { kind: "integer", min: 0, max: 4294967295 },
+      int64: { kind: "integer", min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+      qword: { kind: "integer", min: 0, max: Number.MAX_SAFE_INTEGER },
+      double: { kind: "decimal" },
+      extended: { kind: "decimal" },
+      single: { kind: "decimal" },
+      currency: { kind: "decimal", scale: 4 },
+      tdatetime: { kind: "datetime" },
+      tdate: { kind: "datetime" },
+      ttime: { kind: "datetime" }
+    };
+    stable = (value) => JSON.stringify(value);
+    hash = (value) => createHash3("sha256").update(value).digest("hex");
+    tsType = (p) => p.kind === "object" ? p.ref + "Input" : p.kind === "list" ? p.ref + "Input" : p.kind === "enum" ? p.ref : p.kind === "integer" ? "number" : p.kind === "boolean" ? "boolean" : "string";
+  }
+});
+
+// src/cli.ts
+import { access as access4 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// src/config.ts
+import { readFile, writeFile, mkdir, readdir, access } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+var OFFICIAL_ACBR_URL = "https://svn.code.sf.net/p/acbr/code/trunk2";
+var SOURCE_PARTS = ["Fontes", "Exemplos/ACBrDFe/Schemas/NFe", "Doctos/LICENSE.TXT"];
+var DEFAULT = {
+  formatVersion: 1,
+  source: { url: OFFICIAL_ACBR_URL, revision: "HEAD", directory: ".acbr/source" },
+  generator: { outputDir: "." },
+  native: { project: "native/acbr-worker.lpr", outputDir: ".acbr/runtime", fpc: "fpc" }
+};
+function defaultConfig() {
+  return structuredClone(DEFAULT);
+}
+function record(value, name) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} deve ser um objeto.`);
+  return value;
+}
+function keys(value, allowed, name) {
+  const unexpected = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (unexpected.length) throw new Error(`Campo desconhecido em ${name}: ${unexpected.join(", ")}.`);
+}
+function string(value, name) {
+  if (typeof value !== "string" || !value.trim() || value.includes("\0")) throw new Error(`${name} deve ser um texto n\xE3o vazio.`);
+  return value;
+}
+function parseConfig(input, configPath) {
+  const root = record(input, "configura\xE7\xE3o");
+  keys(root, ["formatVersion", "source", "generator", "native"], "configura\xE7\xE3o");
+  if (root.formatVersion !== 1) throw new Error("formatVersion deve ser 1.");
+  const source = record(root.source, "source");
+  keys(source, ["url", "revision", "directory"], "source");
+  const generator = record(root.generator, "generator");
+  keys(generator, ["outputDir"], "generator");
+  const native = record(root.native, "native");
+  keys(native, ["project", "outputDir", "fpc", "lazarusRoot", "libraryFiles", "providerFiles"], "native");
+  const url = string(source.url, "source.url").replace(/\/+$/, "");
+  if (url !== OFFICIAL_ACBR_URL) throw new Error(`source.url deve apontar ao reposit\xF3rio oficial ${OFFICIAL_ACBR_URL}.`);
+  const revision2 = source.revision;
+  if (revision2 !== "HEAD" && (!Number.isSafeInteger(revision2) || Number(revision2) < 1)) throw new Error("source.revision deve ser HEAD ou uma revis\xE3o SVN positiva.");
+  const absoluteConfig = resolve(configPath);
+  const projectRoot = dirname(absoluteConfig);
+  const localPath = (value, label) => resolve(projectRoot, string(value, label));
+  const fpcInput = string(native.fpc, "native.fpc");
+  const fpc = isAbsolute(fpcInput) || /[\\/]/.test(fpcInput) ? resolve(projectRoot, fpcInput) : fpcInput;
+  let libraryFiles;
+  if (native.libraryFiles !== void 0) {
+    if (!Array.isArray(native.libraryFiles)) throw new Error("native.libraryFiles deve ser uma lista de caminhos.");
+    libraryFiles = native.libraryFiles.map((item, i) => localPath(item, `native.libraryFiles[${i}]`));
+  }
+  let providerFiles;
+  if (native.providerFiles !== void 0) {
+    if (!Array.isArray(native.providerFiles)) throw new Error("native.providerFiles deve ser uma lista de caminhos.");
+    providerFiles = native.providerFiles.map((item, i) => localPath(item, `native.providerFiles[${i}]`));
+  }
+  return {
+    formatVersion: 1,
+    configPath: absoluteConfig,
+    projectRoot,
+    lockPath: resolve(projectRoot, "acbr.lock.json"),
+    source: { url, revision: revision2, directory: localPath(source.directory, "source.directory") },
+    generator: { outputDir: localPath(generator.outputDir, "generator.outputDir") },
+    native: {
+      project: localPath(native.project, "native.project"),
+      outputDir: localPath(native.outputDir, "native.outputDir"),
+      fpc,
+      ...native.lazarusRoot !== void 0 ? { lazarusRoot: localPath(native.lazarusRoot, "native.lazarusRoot") } : {},
+      ...libraryFiles !== void 0 ? { libraryFiles } : {},
+      ...providerFiles !== void 0 ? { providerFiles } : {}
+    }
+  };
+}
+async function loadConfig(path3 = "acbr.config.json") {
+  const configPath = resolve(path3);
+  let contents;
+  try {
+    contents = await readFile(configPath, "utf8");
+  } catch (error) {
+    throw new Error(`N\xE3o foi poss\xEDvel ler ${configPath}. Execute acbr-node init.`, { cause: error });
+  }
+  let value;
+  try {
+    value = JSON.parse(contents);
+  } catch (error) {
+    throw new Error(`JSON inv\xE1lido em ${configPath}.`, { cause: error });
+  }
+  return parseConfig(value, configPath);
+}
+async function initializeConfig(path3 = "acbr.config.json", revision2 = "HEAD", assetRoot) {
+  const configPath = resolve(path3);
+  const config = defaultConfig();
+  config.source.revision = revision2;
+  parseConfig(config, configPath);
+  await mkdir(dirname(configPath), { recursive: true });
+  try {
+    await access(configPath);
+    throw Object.assign(new Error(`EEXIST: configura\xE7\xE3o j\xE1 existe: ${configPath}`), { code: "EEXIST" });
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const resolved = parseConfig(config, configPath);
+  if (assetRoot) await copyInitAssets(assetRoot, resolved.projectRoot);
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, { flag: "wx" });
+  await mkdir(resolve(resolved.projectRoot, ".acbr/generated"), { recursive: true });
+  await mkdir(resolve(resolved.projectRoot, "generated/acbr"), { recursive: true });
+  return resolved;
+}
+async function copyInitAssets(assetRoot, targetRoot) {
+  const entries = [];
+  async function scan(current, target) {
+    for (const entry of await readdir(current, { withFileTypes: true })) {
+      if (entry.name === "generated" || entry.name.startsWith(".")) continue;
+      const source = resolve(current, entry.name);
+      const destination = resolve(target, entry.name);
+      if (entry.isDirectory()) await scan(source, destination);
+      else if (entry.isFile() && /\.(pas|lpr|inc|lpi)$/i.test(entry.name)) entries.push({ source, destination, content: await readFile(source) });
+    }
+  }
+  await scan(resolve(assetRoot, "native"), resolve(targetRoot, "native"));
+  if (!entries.some((entry) => entry.source.endsWith("acbr-worker.lpr"))) throw new Error("Assets do pacote n\xE3o cont\xEAm native/acbr-worker.lpr.");
+  entries.push({ source: resolve(assetRoot, "tools/extract-model.lpr"), destination: resolve(targetRoot, "tools/extract-model.lpr"), content: await readFile(resolve(assetRoot, "tools/extract-model.lpr")) });
+  for (const entry of entries) {
+    try {
+      const existing = await readFile(entry.destination);
+      if (!existing.equals(entry.content)) throw new Error(`init preservou arquivo existente divergente: ${entry.destination}.`);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  for (const entry of entries) {
+    await mkdir(dirname(entry.destination), { recursive: true });
+    try {
+      await writeFile(entry.destination, entry.content, { flag: "wx" });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  }
+}
+
+// src/native-build.ts
+import { copyFile as copyFile2, mkdir as mkdir3, readdir as readdir3, readFile as readFile3, rename as rename2, rm as rm2, stat as stat2, chmod, realpath, access as access3, writeFile as writeFile3 } from "node:fs/promises";
+import { basename, dirname as dirname3, join as join2, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+// src/source.ts
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { access as access2, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, rename, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join, relative, resolve as resolve2, sep } from "node:path";
+async function runCommand(command, args, options = {}) {
+  return new Promise((done, fail2) => {
+    const child = spawn(command, args, { cwd: options.cwd, env: options.env ?? process.env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true, shell: false });
+    let stdout = "";
+    let stderr = "";
+    let overflow = false;
+    const maximum = options.maxOutputBytes ?? 16 * 1024 * 1024;
+    const append = (kind, data) => {
+      if (overflow) return;
+      if (kind === "stdout") stdout += data.toString("utf8");
+      else stderr += data.toString("utf8");
+      if (Buffer.byteLength(stdout) + Buffer.byteLength(stderr) > maximum) {
+        overflow = true;
+        child.kill();
+      }
+    };
+    child.stdout.on("data", (data) => append("stdout", data));
+    child.stderr.on("data", (data) => append("stderr", data));
+    child.on("error", (error) => fail2(new Error(`N\xE3o foi poss\xEDvel executar ${command}: ${error.message}`, { cause: error })));
+    child.on("close", (code) => {
+      if (overflow) fail2(new Error(`Sa\xEDda de ${command} excedeu o limite de ${maximum} bytes.`));
+      else if (code !== 0) {
+        const diagnostic = (stderr || stdout).split("\n").slice(-80).join("\n").slice(-16e3);
+        fail2(Object.assign(new Error(`${command} terminou com c\xF3digo ${code}:
+${diagnostic}`), { stdout, stderr }));
+      } else done({ stdout, stderr });
+    });
+  });
+}
+async function fileHash(path3) {
+  const hash2 = createHash("sha256");
+  for await (const chunk of createReadStream(path3)) hash2.update(chunk);
+  return hash2.digest("hex");
+}
+async function snapshotSource(directory) {
+  const files = /* @__PURE__ */ Object.create(null);
+  async function scan(current) {
+    const entries = (await readdir2(current, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name, "en"));
+    for (const entry of entries) {
+      if (entry.name === ".svn") continue;
+      const path3 = join(current, entry.name);
+      if (entry.isSymbolicLink()) throw new Error(`Fonte ACBr cont\xE9m link simb\xF3lico: ${path3}.`);
+      if (entry.isDirectory()) await scan(path3);
+      else if (entry.isFile()) files[relative(directory, path3).split(sep).join("/")] = await fileHash(path3);
+      else throw new Error(`Fonte ACBr cont\xE9m arquivo especial: ${path3}.`);
+    }
+  }
+  await scan(resolve2(directory));
+  const sortedFiles = Object.fromEntries(Object.entries(files).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+  const treeHash = createHash("sha256").update(JSON.stringify(sortedFiles)).digest("hex");
+  return { treeHash, files: sortedFiles };
+}
+function validateLock(value) {
+  if (!value || typeof value !== "object") throw new Error("Lock ACBr inv\xE1lido.");
+  const lock = value;
+  if (lock.formatVersion !== 1 || !lock.source || !Number.isSafeInteger(lock.source.revision) || lock.source.revision < 1 || !Array.isArray(lock.source.parts) || !lock.source.files || typeof lock.source.files !== "object" || Array.isArray(lock.source.files) || !/^[a-f0-9]{64}$/.test(lock.source.treeHash)) throw new Error("Formato inv\xE1lido em acbr.lock.json.");
+  for (const [path3, hash2] of Object.entries(lock.source.files)) {
+    if (path3.startsWith("/") || path3.includes("\\") || path3.split("/").includes("..") || !/^[a-f0-9]{64}$/.test(hash2)) throw new Error("Caminho ou hash inv\xE1lido no lock ACBr.");
+  }
+  if (lock.source.parts.join("\n") !== SOURCE_PARTS.join("\n")) throw new Error("Partes ACBr divergentes no lock.");
+  return lock;
+}
+async function readSourceLock(config) {
+  let lock;
+  try {
+    lock = validateLock(JSON.parse(await readFile2(config.lockPath, "utf8")));
+  } catch (error) {
+    throw new Error(`N\xE3o foi poss\xEDvel ler ${config.lockPath}. Execute acbr-node source update.`, { cause: error });
+  }
+  if (lock.source.url !== config.source.url) throw new Error("URL ACBr do lock diverge da configura\xE7\xE3o.");
+  if (config.source.revision !== "HEAD" && lock.source.revision !== config.source.revision) throw new Error("Revis\xE3o ACBr do lock diverge da configura\xE7\xE3o. Execute source update explicitamente.");
+  return lock;
+}
+async function verifySource(config) {
+  try {
+    await access2(`${config.lockPath}.operation`);
+  } catch (error) {
+    if (error.code === "ENOENT") return verifySourceContents(config);
+    throw error;
+  }
+  throw new Error("Atualiza\xE7\xE3o de fontes ACBr em andamento. Aguarde o CLI concluir.");
+}
+async function verifySourceContents(config) {
+  const lock = await readSourceLock(config);
+  const snapshot = await snapshotSource(config.source.directory);
+  if (snapshot.treeHash !== lock.source.treeHash) {
+    const names = /* @__PURE__ */ new Set([...Object.keys(snapshot.files), ...Object.keys(lock.source.files)]);
+    const changed = [...names].filter((path3) => snapshot.files[path3] !== lock.source.files[path3]);
+    throw new Error(`Fontes ACBr divergem do lock (${changed.length} arquivo(s)): ${changed.slice(0, 10).join(", ")}. Preserve as altera\xE7\xF5es antes de atualizar.`);
+  }
+  return lock;
+}
+async function writeLock(config, snapshot, revision2) {
+  const lock = { formatVersion: 1, source: { url: config.source.url, revision: revision2, parts: [...SOURCE_PARTS], ...snapshot } };
+  await mkdir2(dirname2(config.lockPath), { recursive: true });
+  const temporary = `${config.lockPath}.${randomUUID()}.tmp`;
+  await writeFile2(temporary, `${JSON.stringify(lock, null, 2)}
+`, { flag: "wx" });
+  try {
+    await rename(temporary, config.lockPath);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+  return lock;
+}
+async function lockExistingSource(config, revision2) {
+  return withSourceOperation(config, () => performLockExistingSource(config, revision2));
+}
+async function performLockExistingSource(config, revision2) {
+  if (!Number.isSafeInteger(revision2) || revision2 < 1) throw new Error("Uma revis\xE3o SVN positiva \xE9 obrigat\xF3ria para registrar fontes existentes.");
+  try {
+    await access2(config.lockPath);
+  } catch {
+    return writeLock(config, await snapshotSource(config.source.directory), revision2);
+  }
+  throw new Error("O lock j\xE1 existe. Use source update para atualizar fontes e lock em conjunto.");
+}
+async function resolveSourceRevision(url, revision2, runner = runCommand) {
+  const { stdout } = await runner("svn", ["info", "--non-interactive", "--show-item", "revision", "-r", String(revision2), url]);
+  const resolved = Number(stdout.trim());
+  if (!Number.isSafeInteger(resolved) || resolved < 1) throw new Error("SVN n\xE3o retornou uma revis\xE3o v\xE1lida.");
+  return resolved;
+}
+async function withSourceOperation(config, operation) {
+  const marker = `${config.lockPath}.operation`;
+  try {
+    await writeFile2(marker, `${JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`, { flag: "wx" });
+  } catch (error) {
+    throw new Error("Outra opera\xE7\xE3o de fontes ACBr est\xE1 em andamento. Se o processo anterior terminou abruptamente, confira o PID do arquivo acbr.lock.json.operation antes de remov\xEA-lo.", { cause: error });
+  }
+  try {
+    return await operation();
+  } finally {
+    await rm(marker, { force: true });
+  }
+}
+async function updateSource(config, revision2 = "HEAD", runner = runCommand) {
+  return withSourceOperation(config, () => performUpdateSource(config, revision2, runner));
+}
+async function performUpdateSource(config, revision2, runner) {
+  const source = resolve2(config.source.directory);
+  if (source === config.projectRoot || source === dirname2(source)) throw new Error("O diret\xF3rio das fontes deve ser exclusivo e n\xE3o pode ser a raiz do projeto ou do sistema.");
+  let exists2 = false;
+  try {
+    const details = await stat(source);
+    exists2 = true;
+    if (!details.isDirectory()) throw new Error("O caminho das fontes n\xE3o \xE9 um diret\xF3rio.");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (exists2 && (await readdir2(source)).length) await verifySourceContents({ ...config, source: { ...config.source, revision: "HEAD" } });
+  const resolvedRevision = await resolveSourceRevision(config.source.url, revision2, runner);
+  const stage = join(dirname2(source), `.acbr-source-stage-${randomUUID()}`);
+  const backup = join(dirname2(source), `.acbr-source-backup-${randomUUID()}`);
+  await mkdir2(stage, { recursive: true });
+  let previousLock;
+  try {
+    previousLock = await readFile2(config.lockPath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  let backedUp = false;
+  let replaced = false;
+  let lockWritten = false;
+  try {
+    for (const part of SOURCE_PARTS) {
+      const destination = join(stage, ...part.split("/"));
+      await mkdir2(dirname2(destination), { recursive: true });
+      await runner("svn", ["export", "--non-interactive", "-q", "-r", String(resolvedRevision), `${config.source.url}/${part}`, destination], { maxOutputBytes: 4 * 1024 * 1024 });
+    }
+    const snapshot = await snapshotSource(stage);
+    if (exists2) {
+      await rename(source, backup);
+      backedUp = true;
+    }
+    await rename(stage, source);
+    replaced = true;
+    const lock = await writeLock(config, snapshot, resolvedRevision);
+    lockWritten = true;
+    await persistRevision(config, resolvedRevision);
+    config.source.revision = resolvedRevision;
+    if (backedUp) await rm(backup, { recursive: true, force: true }).catch(() => void 0);
+    return lock;
+  } catch (error) {
+    if (lockWritten) {
+      if (previousLock === void 0) await rm(config.lockPath, { force: true });
+      else await writeFile2(config.lockPath, previousLock);
+    }
+    if (replaced) await rm(source, { recursive: true, force: true });
+    if (backedUp) await rename(backup, source);
+    throw error;
+  } finally {
+    await rm(stage, { recursive: true, force: true });
+  }
+}
+async function persistRevision(config, revision2) {
+  const original = JSON.parse(await readFile2(config.configPath, "utf8"));
+  original.source.revision = revision2;
+  const temporary = `${config.configPath}.${randomUUID()}.tmp`;
+  await writeFile2(temporary, `${JSON.stringify(original, null, 2)}
+`, { flag: "wx" });
+  try {
+    await rename(temporary, config.configPath);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+
+// src/native-build.ts
+function runtimeDirectory(config) {
+  return join2(config.native.outputDir, `${process.platform}-${process.arch}`);
+}
+async function exists(path3) {
+  try {
+    await access3(path3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findLazarus(config) {
+  const candidates = config.native.lazarusRoot ? [config.native.lazarusRoot] : [process.env.LAZARUS_ROOT, "/usr/lib/lazarus/default", "/usr/lib/lazarus/3.0", "C:\\lazarus"].filter((path3) => Boolean(path3));
+  for (const candidate of candidates) if (await exists(join2(candidate, "components/lazutils"))) return realpath(candidate);
+  throw new Error("Lazarus n\xE3o encontrado. Defina native.lazarusRoot em acbr.config.json ou LAZARUS_ROOT.");
+}
+async function generatedManifest(config) {
+  const path3 = join2(config.generator.outputDir, ".acbr/generated/manifest.json");
+  let value;
+  try {
+    value = JSON.parse(await readFile3(path3, "utf8"));
+  } catch (error) {
+    throw new Error("Contrato gerado ausente ou inv\xE1lido. Execute acbr-node generate.", { cause: error });
+  }
+  if (!Number.isSafeInteger(value.sourceRevision) || !/^[a-f0-9]{64}$/.test(value.contractHash) || !/^[a-f0-9]{64}$/.test(value.sourceHash)) throw new Error("Manifesto gerado inv\xE1lido. Execute generate.");
+  if (!value.fileHashes || typeof value.fileHashes !== "object" || Array.isArray(value.fileHashes) || Object.keys(value.fileHashes).length !== 3 || ["generated/acbr/models.ts", "generated/acbr/index.ts", "native/generated/AcbrModels.pas"].some((name) => !Object.hasOwn(value.fileHashes, name))) throw new Error("Manifesto gerado n\xE3o cont\xE9m os hashes dos tr\xEAs arquivos. Execute generate.");
+  for (const [name, expected] of Object.entries(value.fileHashes)) {
+    const file = resolve3(config.generator.outputDir, name);
+    const location = relative2(config.generator.outputDir, file);
+    if (!name || name.startsWith("/") || name.includes("\\") || location === ".." || location.startsWith(`..${sep2}`) || !/^[a-f0-9]{64}$/.test(expected)) throw new Error("Caminho ou SHA256 inv\xE1lido no manifesto gerado.");
+    if (await fileHash(file) !== expected) throw new Error(`Arquivo gerado diverge do manifesto: ${name}. Execute generate para restaurar o contrato.`);
+  }
+  return value;
+}
+async function subdirectories(path3) {
+  const result = [path3];
+  for (const entry of (await readdir3(path3, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (entry.isDirectory()) result.push(...await subdirectories(join2(path3, entry.name)));
+  }
+  return result;
+}
+var REQUIRED_DYNAMIC = ["libssl.so.3", "libcrypto.so.3", "libxml2.so.2"];
+var CORE_SYSTEM = /^(?:lib(?:c|m|pthread|dl|rt|resolv|anl|util)\.so(?:\.|$)|ld-linux|linux-vdso)/;
+async function copyLinuxLibraries(stage) {
+  const { stdout } = await runCommand("ldconfig", ["-p"]);
+  const libraries = /* @__PURE__ */ new Map();
+  for (const name of REQUIRED_DYNAMIC) {
+    const line = stdout.split("\n").find((value) => value.trim().startsWith(`${name} `) && value.includes("x86-64"));
+    const path3 = line?.split("=>")[1]?.trim();
+    if (!path3) throw new Error(`Depend\xEAncia din\xE2mica ausente: ${name}. Instale OpenSSL 3 e libxml2 compat\xEDveis.`);
+    libraries.set(name, await realpath(path3));
+  }
+  const modules = "/usr/lib/x86_64-linux-gnu/ossl-modules";
+  if (!await exists(join2(modules, "legacy.so"))) throw new Error("Provider legacy OpenSSL 3 ausente. Instale o pacote libssl3/libssl3t64 completo.");
+  libraries.set("ossl-modules/legacy.so", await realpath(join2(modules, "legacy.so")));
+  const systemDependencies = /* @__PURE__ */ new Set();
+  const inspected = /* @__PURE__ */ new Set();
+  while (inspected.size < libraries.size) {
+    const [name, path3] = [...libraries].find(([name2]) => !inspected.has(name2));
+    inspected.add(name);
+    const dependencies = await runCommand("ldd", [path3]);
+    for (const line of dependencies.stdout.split("\n")) {
+      if (line.includes("not found")) throw new Error(`Depend\xEAncia transitiva ausente: ${line.trim()}.`);
+      const match = /^\s*(\S+)\s+=>\s+(\S+)/.exec(line);
+      if (match) {
+        const dependency = match[1];
+        const file = match[2];
+        if (CORE_SYSTEM.test(dependency)) systemDependencies.add(dependency);
+        else if (!libraries.has(dependency)) libraries.set(dependency, await realpath(file));
+      } else {
+        const direct = /^\s*(\/\S+)/.exec(line)?.[1];
+        if (direct) systemDependencies.add(basename(direct));
+      }
+    }
+  }
+  const licenseDir = join2(stage, "licenses");
+  await mkdir3(licenseDir, { recursive: true });
+  const provenance = {};
+  for (const [name, path3] of libraries) {
+    const destination = name.startsWith("ossl-modules/") ? join2(stage, name) : join2(stage, "lib", name);
+    await mkdir3(dirname3(destination), { recursive: true });
+    await copyFile2(path3, destination);
+    const aliases = name === "libssl.so.3" ? ["libssl.so"] : name === "libcrypto.so.3" ? ["libcrypto.so"] : name === "libxml2.so.2" ? ["libxml2.so"] : [];
+    for (const alias of aliases) await copyFile2(path3, join2(stage, "lib", alias));
+    let owner;
+    try {
+      owner = (await runCommand("dpkg-query", ["-S", path3])).stdout.split("\n")[0].split(": ")[0];
+    } catch (error) {
+      throw new Error(`N\xE3o foi poss\xEDvel identificar pacote/licen\xE7a de ${path3}. Build requer Debian/Ubuntu com depend\xEAncias registradas pelo dpkg.`, { cause: error });
+    }
+    const pkg = owner.split(":")[0];
+    const copyright = `/usr/share/doc/${pkg}/copyright`;
+    if (!await exists(copyright)) throw new Error(`Licen\xE7a da depend\xEAncia ${name} n\xE3o encontrada: ${copyright}.`);
+    await copyFile2(copyright, join2(licenseDir, `${name.replaceAll("/", "-")}.txt`));
+    const source = (await runCommand("dpkg-query", ["-W", "-f=${source:Package}|${source:Version}|${Version}", owner])).stdout.trim().split("|");
+    provenance[name] = {
+      binaryPackage: owner,
+      binaryVersion: source[2],
+      sourcePackage: source[0],
+      sourceVersion: source[1],
+      sourceUrl: `https://launchpad.net/ubuntu/+source/${encodeURIComponent(source[0])}/${encodeURIComponent(source[1])}`,
+      copyright: `licenses/${name.replaceAll("/", "-")}.txt`
+    };
+  }
+  await mkdir3(join2(stage, "sources"), { recursive: true });
+  await writeFile3(join2(stage, "sources/native-dependencies.json"), `${JSON.stringify(provenance, null, 2)}
+`);
+  await writeFile3(join2(stage, "openssl.cnf"), "openssl_conf = openssl_init\n[openssl_init]\nproviders = provider_sect\n[provider_sect]\ndefault = default_sect\nlegacy = legacy_sect\n[default_sect]\nactivate = 1\n[legacy_sect]\nactivate = 1\n");
+  return [...systemDependencies].sort();
+}
+async function copyExplicitLibraries(config, stage) {
+  if (!config.native.libraryFiles?.length) throw new Error("Windows exige native.libraryFiles com DLLs OpenSSL 3/libxml2 e arquivos .LICENSE adjacentes.");
+  await mkdir3(join2(stage, "lib"), { recursive: true });
+  await mkdir3(join2(stage, "licenses"), { recursive: true });
+  const sources = {};
+  const dependencyDirectories = new Set([...config.native.libraryFiles ?? [], ...config.native.providerFiles ?? []].map(dirname3));
+  for (const directory of dependencyDirectories) {
+    for (const entry of await readdir3(directory)) {
+      if (entry.endsWith(".LICENSE")) await copyFile2(join2(directory, entry), join2(stage, "licenses", entry));
+      else if (entry === "SOURCE.json") {
+        await mkdir3(join2(stage, "sources"), { recursive: true });
+        await copyFile2(join2(directory, entry), join2(stage, "sources", `${basename(directory)}-SOURCE.json`));
+      }
+    }
+  }
+  for (const [directory, files] of [["lib", config.native.libraryFiles], ["ossl-modules", config.native.providerFiles ?? []]]) {
+    await mkdir3(join2(stage, directory), { recursive: true });
+    for (const source of files) {
+      await copyFile2(source, join2(stage, directory, basename(source)));
+      await copyFile2(`${source}.LICENSE`, join2(stage, "licenses", `${basename(source)}.txt`));
+      if (await exists(`${source}.SOURCE.json`)) sources[`${directory}/${basename(source)}`] = JSON.parse(await readFile3(`${source}.SOURCE.json`, "utf8"));
+    }
+  }
+  if (!config.native.providerFiles?.some((path3) => basename(path3).toLowerCase() === "legacy.dll")) throw new Error("Windows requer native.providerFiles com o provider legacy.dll de OpenSSL 3 e licen\xE7a adjacente.");
+  await mkdir3(join2(stage, "sources"), { recursive: true });
+  await writeFile3(join2(stage, "sources/native-dependencies.json"), `${JSON.stringify(sources, null, 2)}
+`);
+  await writeFile3(join2(stage, "openssl.cnf"), "openssl_conf = openssl_init\n[openssl_init]\nproviders = provider_sect\n[provider_sect]\ndefault = default_sect\nlegacy = legacy_sect\n[default_sect]\nactivate = 1\n[legacy_sect]\nactivate = 1\n");
+}
+async function buildNative(config, options = {}) {
+  if (!["linux", "win32"].includes(process.platform) || process.arch !== "x64") throw new Error("Build inicial suporta Linux x64 e Windows x64.");
+  const lock = await verifySource(config);
+  const contract = await generatedManifest(config);
+  if (contract.sourceRevision !== lock.source.revision || contract.sourceHash !== lock.source.treeHash) throw new Error("Contrato gerado n\xE3o corresponde \xE0s fontes travadas. Execute generate.");
+  const lazarus = await findLazarus(config);
+  const source = config.source.directory;
+  const target = options.testOnly ? join2(config.projectRoot, ".acbr/test-runtime", `${process.platform}-${process.arch}`) : runtimeDirectory(config);
+  const stage = join2(dirname3(target), `.runtime-stage-${randomUUID2()}`);
+  const units = join2(stage, ".units");
+  await mkdir3(units, { recursive: true });
+  const executable = process.platform === "win32" ? "acbr-worker.exe" : "acbr-worker";
+  try {
+    const cpu = (await runCommand(config.native.fpc, ["-iTP"])).stdout.trim();
+    if (cpu !== "x86_64") throw new Error(`FPC deve compilar x86_64, encontrado ${cpu}.`);
+    const targetOs = process.platform === "win32" ? "win64" : "linux";
+    const fontPaths = await subdirectories(join2(source, "Fontes"));
+    const lazPaths = [join2(lazarus, "components/lazutils/lib", `x86_64-${targetOs}`), join2(lazarus, "lcl/units", `x86_64-${targetOs}`), join2(lazarus, "lcl/units", `x86_64-${targetOs}`, "nogui"), join2(lazarus, "packager/units", `x86_64-${targetOs}`)];
+    const searchPaths = [dirname3(config.native.project), join2(config.generator.outputDir, "native/generated"), ...fontPaths, ...lazPaths];
+    const args = [
+      "-vew",
+      "-Mdelphi",
+      "-Scghi",
+      "-O2",
+      "-g-",
+      "-dNOGUI",
+      "-dNOREPORT",
+      ...options.testOnly ? ["-dACBR_NODE_TEST"] : [],
+      `-FU${units}`,
+      `-FE${stage}`,
+      `-o${executable}`,
+      ...searchPaths.map((path3) => `-Fu${path3}`),
+      ...fontPaths.map((path3) => `-Fi${path3}`),
+      config.native.project
+    ];
+    const responseFile = join2(stage, ".compiler.rsp");
+    if (args.some((arg) => /[\"\r\n]/.test(arg))) throw new Error("Caminhos do build n\xE3o podem conter aspas ou quebras de linha.");
+    await writeFile3(responseFile, args.slice(0, -1).join("\n") + "\n");
+    const logPath = join2(config.projectRoot, ".acbr/build.log");
+    try {
+      const compilation = await runCommand(config.native.fpc, [`@${responseFile}`, config.native.project], { cwd: config.projectRoot, maxOutputBytes: 32 * 1024 * 1024 });
+      await writeFile3(logPath, compilation.stdout + compilation.stderr);
+    } catch (error) {
+      const compilation = error;
+      await writeFile3(logPath, (compilation.stdout ?? "") + (compilation.stderr ?? compilation.message));
+      throw new Error(`${compilation.message}
+Log completo: ${logPath}`, { cause: compilation });
+    }
+    const systemDependencies = process.platform === "linux" ? await copyLinuxLibraries(stage) : (await copyExplicitLibraries(config, stage), []);
+    const schemas = join2(source, "Exemplos/ACBrDFe/Schemas/NFe");
+    await copyTree(schemas, join2(stage, "schemas"));
+    const services = join2(source, "Fontes/ACBrDFe/ACBrNFe/ACBrNFeServicos.ini");
+    await copyFile2(services, join2(stage, "ACBrNFeServicos.ini"));
+    await mkdir3(join2(stage, "licenses"), { recursive: true });
+    await copyFile2(join2(source, "Doctos/LICENSE.TXT"), join2(stage, "licenses/ACBr-LICENSE.TXT"));
+    await mkdir3(join2(stage, "sources/native"), { recursive: true });
+    await copyNativeSources(dirname3(config.native.project), join2(stage, "sources/native"));
+    await copyFile2(join2(config.generator.outputDir, "native/generated/AcbrModels.pas"), join2(stage, "sources/native/AcbrModels.pas"));
+    for (const name of ["fp-compiler-3.2.2", "fp-units-rtl-3.2.2", "fpc"]) {
+      const license = `/usr/share/doc/${name}/copyright`;
+      if (await exists(license)) {
+        await copyFile2(license, join2(stage, "licenses/FPC-copyright.txt"));
+        break;
+      }
+    }
+    await copyCompilerLicenses(config, stage, lazarus);
+    const archive = join2(stage, "sources/acbr-source.tar.gz");
+    const tarArgs = process.platform === "linux" ? ["--sort=name", "--mtime=@0", "--owner=0", "--group=0", "--numeric-owner", "-I", "gzip -n"] : [];
+    await runCommand("tar", [...tarArgs, process.platform === "linux" ? "-cf" : "-czf", archive, "-C", source, "Fontes", "Exemplos/ACBrDFe/Schemas/NFe", "Doctos/LICENSE.TXT"]);
+    await writeFile3(join2(stage, "sources/build.json"), `${JSON.stringify({
+      sourceRevision: lock.source.revision,
+      sourceUrl: lock.source.url,
+      sourceTreeHash: lock.source.treeHash,
+      compiler: (await runCommand(config.native.fpc, ["-iV"])).stdout.trim(),
+      lazarusRoot: lazarus,
+      lazarusVersion: basename(lazarus),
+      compilerSourceUrl: "https://gitlab.com/freepascal.org/fpc/source/-/tree/release_3_2_2",
+      testOnly: options.testOnly ?? false,
+      platform: process.platform,
+      arch: process.arch,
+      flags: ["-Mdelphi", "-Scghi", "-O2", "-dNOGUI", "-dNOREPORT"],
+      sourceParts: lock.source.parts
+    }, null, 2)}
+`);
+    await rm2(units, { recursive: true, force: true });
+    await rm2(responseFile, { force: true });
+    if (process.platform !== "win32") await chmod(join2(stage, executable), 493);
+    const currentGenerated = await generatedManifest(config);
+    if (currentGenerated.contractHash !== contract.contractHash || currentGenerated.sourceHash !== contract.sourceHash || Object.entries(contract.fileHashes).some(([name, hash2]) => currentGenerated.fileHashes[name] !== hash2)) throw new Error("Arquivos gerados mudaram durante a compila\xE7\xE3o. Execute build novamente.");
+    const currentSource = await verifySource(config);
+    if (currentSource.source.revision !== lock.source.revision || currentSource.source.treeHash !== lock.source.treeHash) throw new Error("Fontes ACBr foram atualizadas durante a compila\xE7\xE3o. Execute generate e build novamente.");
+    const files = (await snapshotSource(stage)).files;
+    const manifest = {
+      formatVersion: 1,
+      sourceRevision: lock.source.revision,
+      contractHash: contract.contractHash,
+      platform: process.platform,
+      arch: process.arch,
+      executable,
+      files,
+      generatedFileHashes: contract.fileHashes,
+      systemDependencies,
+      ...options.testOnly ? { testOnly: true } : {}
+    };
+    await writeFile3(join2(stage, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+    await replaceRuntime(stage, target);
+    return manifest;
+  } finally {
+    await rm2(stage, { recursive: true, force: true });
+  }
+}
+async function copyNativeSources(source, target) {
+  await mkdir3(target, { recursive: true });
+  for (const entry of await readdir3(source, { withFileTypes: true })) {
+    if (entry.isDirectory() && !entry.name.startsWith(".")) await copyNativeSources(join2(source, entry.name), join2(target, entry.name));
+    else if (entry.isFile() && /\.(pas|lpr|inc|lpi)$/i.test(entry.name)) await copyFile2(join2(source, entry.name), join2(target, entry.name));
+  }
+}
+async function copyTree(source, target) {
+  await mkdir3(target, { recursive: true });
+  for (const entry of await readdir3(source, { withFileTypes: true })) {
+    if (entry.isSymbolicLink()) throw new Error(`Arquivo de distribui\xE7\xE3o n\xE3o pode ser link: ${entry.name}.`);
+    if (entry.isDirectory()) await copyTree(join2(source, entry.name), join2(target, entry.name));
+    else if (entry.isFile()) await copyFile2(join2(source, entry.name), join2(target, entry.name));
+  }
+}
+async function replaceRuntime(stage, target) {
+  const backup = `${target}.${randomUUID2()}.backup`;
+  const hadTarget = await exists(target);
+  if (hadTarget) await rename2(target, backup);
+  try {
+    await rename2(stage, target);
+  } catch (error) {
+    if (hadTarget) await rename2(backup, target);
+    throw error;
+  }
+  if (hadTarget) await rm2(backup, { recursive: true, force: true });
+}
+async function checkBuild(config) {
+  const lock = await verifySource(config);
+  const generated = await generatedManifest(config);
+  const directory = runtimeDirectory(config);
+  const manifest = JSON.parse(await readFile3(join2(directory, "manifest.json"), "utf8"));
+  if (manifest.formatVersion !== 1 || manifest.platform !== process.platform || manifest.arch !== process.arch || manifest.sourceRevision !== lock.source.revision || generated.sourceHash !== lock.source.treeHash || manifest.contractHash !== generated.contractHash || !manifest.generatedFileHashes || Object.entries(generated.fileHashes).some(([name, hash2]) => manifest.generatedFileHashes[name] !== hash2) || typeof manifest.executable !== "string" || !manifest.files || !Object.hasOwn(manifest.files, manifest.executable)) throw new Error("Runtime diverge das fontes ou contrato. Execute build.");
+  for (const [path3, expected] of Object.entries(manifest.files)) {
+    if (path3.startsWith("/") || path3.includes("\\") || path3.split("/").includes("..") || !/^[a-f0-9]{64}$/.test(expected)) throw new Error(`Caminho/hash inv\xE1lido no runtime: ${path3}.`);
+    if (await fileHash(join2(directory, path3)) !== expected) throw new Error(`Hash inv\xE1lido no runtime: ${path3}.`);
+  }
+  return manifest;
+}
+async function doctor(config) {
+  const items = [{ name: "Node.js", ok: Number(process.versions.node.split(".")[0]) > 22 || Number(process.versions.node.split(".")[0]) === 22 && Number(process.versions.node.split(".")[1]) >= 12, detail: process.versions.node }];
+  for (const [name, command, args] of [["SVN", "svn", ["--version", "--quiet"]], ["Free Pascal", config?.native.fpc ?? "fpc", ["-iV"]]]) {
+    try {
+      const result = await runCommand(command, [...args]);
+      items.push({ name, ok: true, detail: result.stdout.trim() });
+    } catch (error) {
+      items.push({ name, ok: false, detail: error.message });
+    }
+  }
+  if (config) {
+    try {
+      items.push({ name: "Lazarus", ok: true, detail: await findLazarus(config) });
+    } catch (error) {
+      items.push({ name: "Lazarus", ok: false, detail: error.message });
+    }
+    try {
+      const lock = await verifySource(config);
+      items.push({ name: "Fontes ACBr", ok: true, detail: `revis\xE3o ${lock.source.revision}, ${lock.source.treeHash}` });
+    } catch (error) {
+      items.push({ name: "Fontes ACBr", ok: false, detail: error.message });
+    }
+  }
+  if (process.platform === "linux") {
+    try {
+      const result = await runCommand("ldconfig", ["-p"]);
+      const missing = REQUIRED_DYNAMIC.filter((name) => !result.stdout.includes(name));
+      items.push({ name: "OpenSSL/libxml2 din\xE2micos", ok: missing.length === 0, detail: missing.length ? `Ausentes: ${missing.join(", ")}` : REQUIRED_DYNAMIC.join(", ") });
+    } catch (error) {
+      items.push({ name: "OpenSSL/libxml2 din\xE2micos", ok: false, detail: error.message });
+    }
+  }
+  return items;
+}
+async function copyCompilerLicenses(config, stage, lazarus) {
+  const packagedLazarus = fileURLToPath(new URL("../docs/licenses/lazarus/", import.meta.url));
+  const packagedFpc = fileURLToPath(new URL("../docs/licenses/fpc/", import.meta.url));
+  const notices = {};
+  async function copyNotice(name, candidates2) {
+    for (const source of candidates2) if (await exists(source)) {
+      await copyFile2(source, join2(stage, "licenses", name));
+      notices[name] = { source, sha256: await fileHash(source) };
+      return;
+    }
+    throw new Error(`Notice obrigat\xF3rio ausente: ${name}.`);
+  }
+  for (const name of ["COPYING.txt", "COPYING.LGPL.txt", "COPYING.modifiedLGPL.txt"]) {
+    await copyNotice(`Lazarus-${name}`, [join2(lazarus, name), join2(lazarus, "docs", name), join2(packagedLazarus, name)]);
+  }
+  if (await exists(join2(packagedLazarus, "ORIGIN.json"))) await copyFile2(join2(packagedLazarus, "ORIGIN.json"), join2(stage, "licenses/Lazarus-notice-origin.json"));
+  const fpcRoot = resolve3(dirname3(config.native.fpc), "../..");
+  const sourceRoots = [join2(fpcRoot, "source"), join2(lazarus, "fpc/3.2.2/source"), "/usr/share/fpcsrc/3.2.2"];
+  for (const [name, sourceRelative] of [["COPYING.GPL.txt", "compiler/COPYING.txt"], ["COPYING.LGPL.txt", "rtl/COPYING.txt"], ["COPYING.FPC", "rtl/COPYING.FPC"]]) {
+    await copyNotice(`FPC-${name}`, [...sourceRoots.map((directory) => join2(directory, sourceRelative)), join2(packagedFpc, name)]);
+  }
+  if (await exists(join2(packagedFpc, "ORIGIN.json"))) await copyFile2(join2(packagedFpc, "ORIGIN.json"), join2(stage, "licenses/FPC-notice-origin.json"));
+  const candidates = [join2(fpcRoot, "doc"), fpcRoot, join2(lazarus, "fpc"), "/usr/share/doc/fp-compiler-3.2.2", "/usr/share/doc/fp-units-rtl-3.2.2"];
+  for (const directory of candidates) {
+    if (!await exists(directory)) continue;
+    for (const name of await readdir3(directory)) {
+      if (/^(?:copying|license|copyright)/i.test(name) && (await stat2(join2(directory, name))).isFile()) await copyFile2(join2(directory, name), join2(stage, "licenses", `FPC-${basename(directory)}-${name}`));
+    }
+  }
+  await writeFile3(join2(stage, "licenses/toolchain-notices.json"), `${JSON.stringify(notices, null, 2)}
+`);
+}
+
+// src/runtime.ts
+import { spawn as spawn2 } from "node:child_process";
+import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
+import { TextDecoder } from "node:util";
+
+// src/types.ts
+var ErroAcbrNode = class extends Error {
+  constructor(codigo, mensagem, resultadoDesconhecido = false, xmlBase64) {
+    super(mensagem);
+    this.codigo = codigo;
+    this.resultadoDesconhecido = resultadoDesconhecido;
+    this.xmlBase64 = xmlBase64;
+  }
+  name = "ErroAcbrNode";
+};
+
+// src/runtime.ts
+var STATES = /* @__PURE__ */ new Set(["DENEGADO", "XML_GERADO", "VALIDADO", "ASSINADO", "AUTORIZADO", "REJEITADO", "PENDENTE", "INDETERMINADO", "CONSULTADO", "CANCELADO", "EVENTO_REGISTRADO", "INUTILIZADO", "ERRO"]);
+var UFS = new Set("AC AL AP AM BA CE DF ES GO MA MT MS MG PA PB PR PE PI RJ RN RS RO RR SC SP SE TO".split(" "));
+var MAX_BYTES = 8 * 1024 * 1024;
+var plain = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var validContract = (v) => plain(v) && Number.isInteger(v.sourceRevision) && Number(v.sourceRevision) > 0 && typeof v.contractHash === "string" && /^[a-f0-9]{64}$/.test(v.contractHash);
+var fail = (code, message, req, unknown = false) => new ErroAcbrNode(code, message, unknown, req?.comando === "transmitir" ? req.xmlBase64 : void 0);
+function confined(root, relative3) {
+  const file = path.resolve(root, relative3), part = path.relative(root, file);
+  if (!relative3 || path.isAbsolute(relative3) || part === ".." || part.startsWith(".." + path.sep)) throw fail("RUNTIME_INVALIDO", "Caminho inv\xE1lido no runtime.");
+  return file;
+}
+async function resolveRuntime(directory, contract) {
+  if (!validContract(contract)) throw fail("CONTRATO_INVALIDO", "Contrato gerado inv\xE1lido.");
+  let root = directory;
+  if (!root) {
+    if (!["linux", "win32"].includes(process.platform) || process.arch !== "x64") throw fail("PLATAFORMA_NAO_SUPORTADA", "Esta vers\xE3o exige Linux ou Windows x64.");
+    try {
+      const require2 = createRequire(typeof __filename !== "undefined" ? __filename : import.meta.url);
+      root = path.join(path.dirname(require2.resolve("cosmemilton-acbr-node-" + process.platform + "-x64/package.json")), "runtime");
+    } catch {
+      throw fail("RUNTIME_AUSENTE", "Instale o pacote de runtime da plataforma ou informe runtimeDirectory.");
+    }
+  }
+  root = path.resolve(root);
+  let m;
+  try {
+    m = JSON.parse(await readFile4(path.join(root, "manifest.json"), "utf8"));
+  } catch {
+    throw fail("RUNTIME_AUSENTE", "Manifesto do runtime n\xE3o encontrado.");
+  }
+  if (!validContract(m) || m.formatVersion !== 1 || !plain(m.files) || typeof m.executable !== "string" || m.platform !== process.platform || m.arch !== process.arch) throw fail("RUNTIME_INVALIDO", "Manifesto ou plataforma do runtime inv\xE1lidos.");
+  if (m.sourceRevision !== contract.sourceRevision || m.contractHash !== contract.contractHash) throw fail("CONTRATO_DIVERGENTE", "Cliente e motor foram gerados de contratos diferentes; regenere e recompile.");
+  for (const [name, hash2] of Object.entries(m.files)) {
+    if (typeof hash2 !== "string" || !/^[a-f0-9]{64}$/.test(hash2)) throw fail("RUNTIME_INVALIDO", "Hash inv\xE1lido no runtime.");
+    const file = confined(root, name);
+    let data;
+    try {
+      if (!(await stat3(file)).isFile()) throw Error();
+      data = await readFile4(file);
+    } catch {
+      throw fail("RUNTIME_INCOMPLETO", "Arquivo do runtime ausente.");
+    }
+    if (createHash2("sha256").update(data).digest("hex") !== hash2) throw fail("RUNTIME_ALTERADO", "O runtime n\xE3o corresponde ao manifesto distribu\xEDdo.");
+  }
+  if (!m.files[m.executable]) throw fail("RUNTIME_INVALIDO", "O execut\xE1vel n\xE3o consta no invent\xE1rio.");
+  return { directory: root, executable: confined(root, m.executable) };
+}
+function criarEmissor(options) {
+  if (!/^\d{14}$/.test(options.cnpj) || !UFS.has(options.uf) || ![55, 65].includes(options.modelo) || ![1, 2].includes(options.ambiente)) throw fail("CONFIGURACAO_INVALIDA", "Informe CNPJ, UF, modelo e ambiente v\xE1lidos.");
+  if (!validContract(options.contrato)) throw fail("CONTRATO_INVALIDO", "Contrato gerado inv\xE1lido.");
+  const cert = options.certificado;
+  if (cert && (typeof cert.senha !== "string" || !!cert.pfx === !!cert.arquivo || cert.pfx && !(cert.pfx instanceof Uint8Array))) throw fail("CERTIFICADO_INVALIDO", "Informe A1 em pfx ou arquivo e sua senha.");
+  if (options.csc && (!/^\d{1,6}$/.test(options.csc.id) || typeof options.csc.valor !== "string" || !options.csc.valor || options.csc.valor.length > 256)) throw fail("CSC_INVALIDO", "CSC inv\xE1lido.");
+  const cfg = { cnpj: options.cnpj, uf: options.uf, modelo: options.modelo, ambiente: options.ambiente, csc: options.csc ? { ...options.csc } : void 0 };
+  const certificate = cert ? { ...cert, pfx: cert.pfx ? Buffer.from(cert.pfx) : void 0 } : void 0;
+  const contract = { ...options.contrato };
+  const timeout = options.timeoutMs ?? 12e4, capacity = options.limiteFila ?? 32, bytesLimit = options.limiteBytes ?? MAX_BYTES;
+  if (!Number.isInteger(timeout) || timeout < 1 || timeout > 12e4 || !Number.isInteger(capacity) || capacity < 0 || capacity > 1e3 || !Number.isInteger(bytesLimit) || bytesLimit < 256 || bytesLimit > MAX_BYTES) throw fail("CONFIGURACAO_INVALIDA", "Limites de execu\xE7\xE3o inv\xE1lidos.");
+  const launch = options.criaProcesso ?? ((exe, args, config) => spawn2(exe, args, { ...config, stdio: ["pipe", "pipe", "pipe"] }));
+  let runtimePromise, closed = false, current;
+  const queue = [];
+  async function execute2(item) {
+    if (closed || item.signal?.aborted) throw fail("OPERACAO_CANCELADA", "Opera\xE7\xE3o cancelada antes da execu\xE7\xE3o.");
+    const runtime = await (runtimePromise ??= resolveRuntime(options.runtimeDirectory, contract));
+    if (closed || item.signal?.aborted) throw fail("OPERACAO_CANCELADA", "Opera\xE7\xE3o cancelada antes da execu\xE7\xE3o.");
+    await new Promise((done) => {
+      let stopError;
+      let child, finished = false, started = false, sending = false, total = 0, rest = Buffer.alloc(0), result;
+      let finishCurrent;
+      const doneCurrent = new Promise((r) => {
+        finishCurrent = r;
+      });
+      const uncertain = () => ["transmitir", "cancelar", "cartaCorrecao", "inutilizar"].includes(item.req.comando) && started || sending;
+      const finish = (error) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        item.signal?.removeEventListener("abort", abort);
+        item.bytes.fill(0);
+        if (current?.done === doneCurrent) current = void 0;
+        finishCurrent();
+        error ? item.reject(error) : item.resolve(result);
+        done();
+      };
+      const stop = (code, message) => {
+        if (finished || stopError) return;
+        stopError = fail(code, message, item.req, uncertain());
+        if (child?.pid) child.kill("SIGKILL");
+        else finish(stopError);
+      };
+      const abort = () => stop("OPERACAO_CANCELADA", "Opera\xE7\xE3o cancelada; confira a situa\xE7\xE3o fiscal quando o envio foi iniciado.");
+      const timer = setTimeout(() => stop("TIMEOUT_MOTOR", "O motor excedeu o prazo; consulte a situa\xE7\xE3o antes de transmitir novamente."), timeout);
+      current = { stop: () => stop("EMISSOR_FECHADO", "Emissor encerrado."), done: doneCurrent };
+      const env = {};
+      for (const key of ["PATH", "Path", "SystemRoot", "WINDIR", "TEMP", "TMP", "HOME", "LANG", "LC_ALL"]) if (process.env[key] !== void 0) env[key] = process.env[key];
+      if (process.platform === "linux") env.LD_LIBRARY_PATH = path.join(runtime.directory, "lib");
+      if (process.platform === "win32") {
+        const inheritedPath = env.Path ?? env.PATH ?? "";
+        delete env.Path;
+        env.PATH = path.join(runtime.directory, "lib") + ";" + runtime.directory + ";" + inheritedPath;
+      }
+      const modules = path.join(runtime.directory, "ossl-modules");
+      env.OPENSSL_MODULES = modules;
+      env.OPENSSL_CONF = path.join(runtime.directory, "openssl.cnf");
+      try {
+        child = launch(runtime.executable, ["--parent-pid", String(process.pid)], { cwd: runtime.directory, env, windowsHide: true, shell: false, stdio: ["pipe", "pipe", "pipe"] });
+        started = typeof child.pid === "number";
+      } catch {
+        finish(fail("FALHA_INICIAR_MOTOR", "N\xE3o foi poss\xEDvel iniciar o motor.", item.req));
+        return;
+      }
+      item.signal?.addEventListener("abort", abort, { once: true });
+      child.on("spawn", () => {
+        started = true;
+      });
+      child.on("error", () => finish(fail("FALHA_INICIAR_MOTOR", "N\xE3o foi poss\xEDvel iniciar o motor.", item.req, uncertain())));
+      child.stdin.on("error", () => stop("FALHA_PIPE", "N\xE3o foi poss\xEDvel comunicar com o motor."));
+      child.stderr.on("data", () => {
+      });
+      child.stdout.on("data", (chunk) => {
+        if (finished || stopError) return;
+        total += chunk.length;
+        if (total > bytesLimit) {
+          stop("RESPOSTA_EXCESSIVA", "Resposta do motor excede o limite.");
+          return;
+        }
+        rest = Buffer.concat([rest, chunk]);
+        let end;
+        while ((end = rest.indexOf(10)) >= 0) {
+          const line = rest.subarray(0, end);
+          rest = rest.subarray(end + 1);
+          if (!line.length) continue;
+          try {
+            const frame = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(line));
+            if (!plain(frame) || frame.id !== item.req.id) throw Error();
+            if (frame.tipo === "envioIniciado") {
+              sending = true;
+              continue;
+            }
+            if (result || frame.versao !== 1 || frame.sourceRevision !== contract.sourceRevision || frame.contractHash !== contract.contractHash || typeof frame.sucesso !== "boolean" || !STATES.has(String(frame.estado))) throw Error();
+            if (frame.xmlBase64 !== void 0 && (typeof frame.xmlBase64 !== "string" || !frame.xmlBase64.length || Buffer.from(frame.xmlBase64, "base64").toString("base64") !== frame.xmlBase64)) throw Error();
+            if (frame.cStat !== void 0 && (!Number.isInteger(frame.cStat) || Number(frame.cStat) < 1 || Number(frame.cStat) > 9999)) throw Error();
+            result = frame;
+          } catch {
+            stop("RESPOSTA_INVALIDA", "O motor retornou uma resposta inv\xE1lida.");
+            return;
+          }
+        }
+      });
+      child.on("close", (code) => {
+        if (finished) return;
+        if (stopError) {
+          finish(stopError);
+          return;
+        }
+        if (code !== 0 || rest.length || !result) {
+          finish(fail("FALHA_MOTOR", "O motor encerrou sem resposta fiscal v\xE1lida.", item.req, uncertain()));
+          return;
+        }
+        finish();
+      });
+      child.stdin.end(item.bytes);
+      if (item.signal?.aborted) abort();
+    });
+  }
+  let busy = false;
+  async function next() {
+    if (busy) return;
+    const item = queue.shift();
+    if (!item) return;
+    busy = true;
+    item.signal?.removeEventListener("abort", item.abort);
+    try {
+      await execute2(item);
+    } catch (e) {
+      item.bytes.fill(0);
+      item.reject(e);
+    } finally {
+      busy = false;
+      void next();
+    }
+  }
+  async function request(command, data, operation = {}) {
+    if (closed) throw fail("EMISSOR_FECHADO", "Emissor encerrado.");
+    if (operation.signal?.aborted) throw fail("OPERACAO_CANCELADA", "Opera\xE7\xE3o cancelada antes da execu\xE7\xE3o.");
+    if (["assinar", "transmitir", "consultar", "cancelar", "cartaCorrecao", "inutilizar"].includes(command) && !certificate) throw fail("CERTIFICADO_AUSENTE", "A opera\xE7\xE3o exige um certificado A1.");
+    if (command === "gerarXml") options.validaDocumento?.(data.documento);
+    const config = { ...cfg };
+    if (certificate) {
+      let pfx;
+      try {
+        pfx = certificate.pfx ?? await readFile4(certificate.arquivo);
+      } catch {
+        throw fail("CERTIFICADO_AUSENTE", "N\xE3o foi poss\xEDvel ler o A1 configurado.");
+      }
+      if (pfx.length > 2 * 1024 * 1024) throw fail("CERTIFICADO_EXCESSIVO", "Certificado excede o limite.");
+      config.certificado = { pfxBase64: pfx.toString("base64"), senha: certificate.senha };
+    }
+    let bytes, req;
+    try {
+      bytes = Buffer.from(JSON.stringify({ versao: 1, id: randomUUID3(), ...contract, comando: command, config, ...data }) + "\n", "utf8");
+      if (bytes.length > bytesLimit) throw Error();
+      req = JSON.parse(bytes.toString("utf8"));
+    } catch {
+      throw fail("REQUISICAO_INVALIDA", "Dados da opera\xE7\xE3o inv\xE1lidos ou acima do limite.");
+    }
+    return new Promise((resolve5, reject) => {
+      if (closed) {
+        bytes.fill(0);
+        reject(fail("EMISSOR_FECHADO", "Emissor encerrado."));
+        return;
+      }
+      if (busy && queue.length >= capacity) {
+        bytes.fill(0);
+        reject(fail("FILA_CHEIA", "A fila fiscal est\xE1 cheia."));
+        return;
+      }
+      const item = { req, bytes, signal: operation.signal, resolve: resolve5, reject };
+      item.abort = () => {
+        const i = queue.indexOf(item);
+        if (i >= 0) {
+          queue.splice(i, 1);
+          bytes.fill(0);
+          operation.signal?.removeEventListener("abort", item.abort);
+          reject(fail("OPERACAO_CANCELADA", "Opera\xE7\xE3o cancelada antes da execu\xE7\xE3o."));
+        }
+      };
+      operation.signal?.addEventListener("abort", item.abort, { once: true });
+      queue.push(item);
+      if (operation.signal?.aborted) item.abort();
+      void next();
+    });
+  }
+  const xmlData = (xml) => {
+    if (typeof xml !== "string" || !xml.trim() || Buffer.byteLength(xml, "utf8") > 2 * 1024 * 1024) throw fail("XML_INVALIDO", "XML vazio ou acima do limite.");
+    return { xmlBase64: Buffer.from(xml, "utf8").toString("base64") };
+  };
+  const checkKey = (key) => {
+    if (!/^\d{44}$/.test(key)) throw fail("CHAVE_INVALIDA", "Chave fiscal inv\xE1lida.");
+  };
+  const reason = (value) => {
+    if (typeof value !== "string" || value.length < 15 || value.length > 255) throw fail("JUSTIFICATIVA_INVALIDA", "Justificativa deve ter de 15 a 255 caracteres.");
+  };
+  return {
+    gerarXml: (documento, op) => request("gerarXml", { documento }, op),
+    validar: (xml, op) => request("validar", xmlData(xml), op),
+    assinar: (xml, op) => request("assinar", xmlData(xml), op),
+    transmitir: (xml, op) => request("transmitir", xmlData(xml), op),
+    consultar: (consulta, op) => {
+      checkKey(consulta.chave);
+      if (consulta.recibo && !/^\d{15}$/.test(consulta.recibo)) throw fail("RECIBO_INVALIDO", "Recibo inv\xE1lido.");
+      return request("consultar", consulta, op);
+    },
+    cancelar: (data, op) => {
+      checkKey(data.chave);
+      reason(data.justificativa);
+      if (!/^\d{15}$/.test(data.protocolo)) throw fail("PROTOCOLO_INVALIDO", "Protocolo inv\xE1lido.");
+      return request("cancelar", data, op);
+    },
+    cartaCorrecao: (data, op) => {
+      if (cfg.modelo !== 55) throw fail("OPERACAO_NAO_SUPORTADA", "Carta de corre\xE7\xE3o exige NF-e modelo 55.");
+      checkKey(data.chave);
+      if (typeof data.correcao !== "string" || data.correcao.length < 15 || data.correcao.length > 1e3 || !Number.isInteger(data.sequenciaEvento ?? 1) || (data.sequenciaEvento ?? 1) < 1 || (data.sequenciaEvento ?? 1) > 20) throw fail("CORRECAO_INVALIDA", "Dados da carta de corre\xE7\xE3o inv\xE1lidos.");
+      return request("cartaCorrecao", { ...data, sequenciaEvento: data.sequenciaEvento ?? 1 }, op);
+    },
+    inutilizar: (data, op) => {
+      reason(data.justificativa);
+      if (!Number.isInteger(data.ano) || data.ano < 0 || data.ano > 99 || !Number.isInteger(data.serie) || data.serie < 0 || data.serie > 999 || !Number.isInteger(data.numeroInicial) || data.numeroInicial < 1 || !Number.isInteger(data.numeroFinal) || data.numeroFinal < data.numeroInicial || data.numeroFinal > 999999999) throw fail("INUTILIZACAO_INVALIDA", "Faixa de inutiliza\xE7\xE3o inv\xE1lida.");
+      return request("inutilizar", { inutilizacao: { ano: data.ano, serie: data.serie, numeroInicial: data.numeroInicial, numeroFinal: data.numeroFinal }, justificativa: data.justificativa }, op);
+    },
+    async fechar() {
+      if (closed) return;
+      closed = true;
+      for (const item of queue.splice(0)) {
+        item.signal?.removeEventListener("abort", item.abort);
+        item.bytes.fill(0);
+        item.reject(fail("EMISSOR_FECHADO", "Emissor encerrado."));
+      }
+      const running = current;
+      running?.stop();
+      if (running) await running.done;
+      certificate?.pfx?.fill(0);
+    }
+  };
+}
+
+// src/offline-fixture.ts
+var OFFLINE_DOCUMENT = {
+  "infNFe": {
+    "Versao": "4.00"
+  },
+  "Ide": {
+    "cUF": 23,
+    "cNF": 12345678,
+    "natOp": "VENDA TESTE OFFLINE",
+    "modelo": 55,
+    "serie": 1,
+    "nNF": 1,
+    "dEmi": "2026-10-08T12:00:00",
+    "tpNF": "tnSaida",
+    "idDest": "doInterna",
+    "cMunFG": 2304400,
+    "tpImp": "tiRetrato",
+    "tpEmis": "teNormal",
+    "tpAmb": "taHomologacao",
+    "finNFe": "fnNormal",
+    "indFinal": "cfConsumidorFinal",
+    "indPres": "pcPresencial",
+    "procEmi": "peAplicativoContribuinte",
+    "verProc": "ACBR-NODE-OFFLINE"
+  },
+  "Emit": {
+    "CNPJCPF": "11222333000181",
+    "xNome": "Caf\xE9 S\xE3o Jos\xE9 TESTE OFFLINE SEM VALOR FISCAL",
+    "IE": "123456789",
+    "CRT": "crtSimplesNacional",
+    "EnderEmit": {
+      "xLgr": "RUA TESTE",
+      "nro": "1",
+      "xBairro": "TESTE",
+      "cMun": 2304400,
+      "xMun": "FORTALEZA",
+      "UF": "CE",
+      "CEP": 6e7,
+      "cPais": 1058,
+      "xPais": "BRASIL"
+    }
+  },
+  "Dest": {
+    "CNPJCPF": "12345678909",
+    "xNome": "NF-E EMITIDA EM AMBIENTE DE HOMOLOGACAO - SEM VALOR FISCAL",
+    "indIEDest": "inNaoContribuinte",
+    "EnderDest": {
+      "xLgr": "RUA TESTE",
+      "nro": "2",
+      "xBairro": "TESTE",
+      "cMun": 2304400,
+      "xMun": "FORTALEZA",
+      "UF": "CE",
+      "CEP": 6e7,
+      "cPais": 1058,
+      "xPais": "BRASIL"
+    }
+  },
+  "Det": [
+    {
+      "Prod": {
+        "nItem": 1,
+        "cProd": "TESTE",
+        "cEAN": "SEM GTIN",
+        "xProd": "Caf\xE9 S\xE3o Jos\xE9 PRODUTO SINT\xC9TICO OFFLINE",
+        "NCM": "22021000",
+        "CFOP": "5102",
+        "uCom": "UN",
+        "qCom": "1",
+        "vUnCom": "10",
+        "vProd": "10",
+        "cEANTrib": "SEM GTIN",
+        "uTrib": "UN",
+        "qTrib": "1",
+        "vUnTrib": "10",
+        "IndTot": "itSomaTotalNFe"
+      },
+      "Imposto": {
+        "ICMS": {
+          "orig": "oeNacional",
+          "CSOSN": "csosn102"
+        },
+        "PIS": {
+          "CST": "pis07"
+        },
+        "COFINS": {
+          "CST": "cof07"
+        }
+      }
+    }
+  ],
+  "Total": {
+    "ICMSTot": {
+      "vProd": "10",
+      "vNF": "10"
+    }
+  },
+  "Transp": {
+    "modFrete": "mfSemFrete"
+  },
+  "pag": [
+    {
+      "tPag": "fpDinheiro",
+      "indPag": "ipVista",
+      "vPag": "10"
+    }
+  ]
+};
+var OFFLINE_SIGNED_XML = '<?xml version="1.0" encoding="UTF-8"?><NFe xmlns="http://www.portalfiscal.inf.br/nfe"><infNFe Id="NFe23261011222333000181550010000000011123456780" versao="4.00"><ide><cUF>23</cUF><cNF>12345678</cNF><natOp>VENDA TESTE OFFLINE</natOp><mod>55</mod><serie>1</serie><nNF>1</nNF><dhEmi>2026-10-08T12:00:00-03:00</dhEmi><tpNF>1</tpNF><idDest>1</idDest><cMunFG>2304400</cMunFG><tpImp>1</tpImp><tpEmis>1</tpEmis><cDV>0</cDV><tpAmb>2</tpAmb><finNFe>1</finNFe><indFinal>1</indFinal><indPres>1</indPres><procEmi>0</procEmi><verProc>ACBR-NODE-OFFLINE</verProc></ide><emit><CNPJ>11222333000181</CNPJ><xNome>Caf\xE9 S\xE3o Jos\xE9 TESTE OFFLINE SEM VALOR FISCAL</xNome><enderEmit><xLgr>RUA TESTE</xLgr><nro>1</nro><xBairro>TESTE</xBairro><cMun>2304400</cMun><xMun>FORTALEZA</xMun><UF>CE</UF><CEP>60000000</CEP><cPais>1058</cPais><xPais>BRASIL</xPais></enderEmit><IE>123456789</IE><CRT>1</CRT></emit><dest><CPF>12345678909</CPF><xNome>NF-E EMITIDA EM AMBIENTE DE HOMOLOGACAO - SEM VALOR FISCAL</xNome><enderDest><xLgr>RUA TESTE</xLgr><nro>2</nro><xBairro>TESTE</xBairro><cMun>2304400</cMun><xMun>FORTALEZA</xMun><UF>CE</UF><CEP>60000000</CEP><cPais>1058</cPais><xPais>BRASIL</xPais></enderDest><indIEDest>9</indIEDest></dest><det nItem="1"><prod><cProd>TESTE</cProd><cEAN>SEM GTIN</cEAN><xProd>Caf\xE9 S\xE3o Jos\xE9 PRODUTO SINT\xC9TICO OFFLINE</xProd><NCM>22021000</NCM><CFOP>5102</CFOP><uCom>UN</uCom><qCom>1.0000</qCom><vUnCom>10.0000000000</vUnCom><vProd>10.00</vProd><cEANTrib>SEM GTIN</cEANTrib><uTrib>UN</uTrib><qTrib>1.0000</qTrib><vUnTrib>10.0000000000</vUnTrib><indTot>1</indTot></prod><imposto><ICMS><ICMSSN102><orig>0</orig><CSOSN>102</CSOSN></ICMSSN102></ICMS><PIS><PISNT><CST>07</CST></PISNT></PIS><COFINS><COFINSNT><CST>07</CST></COFINSNT></COFINS></imposto></det><total><ICMSTot><vBC>0.00</vBC><vICMS>0.00</vICMS><vICMSDeson>0.00</vICMSDeson><vFCP>0.00</vFCP><vBCST>0.00</vBCST><vST>0.00</vST><vFCPST>0.00</vFCPST><vFCPSTRet>0.00</vFCPSTRet><vProd>10.00</vProd><vFrete>0.00</vFrete><vSeg>0.00</vSeg><vDesc>0.00</vDesc><vII>0.00</vII><vIPI>0.00</vIPI><vIPIDevol>0.00</vIPIDevol><vPIS>0.00</vPIS><vCOFINS>0.00</vCOFINS><vOutro>0.00</vOutro><vNF>10.00</vNF></ICMSTot></total><transp><modFrete>9</modFrete></transp><pag><detPag><indPag>0</indPag><tPag>01</tPag><vPag>10.00</vPag></detPag></pag></infNFe><Signature xmlns="http://www.w3.org/2000/09/xmldsig#"><SignedInfo><CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"></CanonicalizationMethod><SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"></SignatureMethod><Reference URI="#NFe23261011222333000181550010000000011123456780"><Transforms><Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"></Transform><Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"></Transform></Transforms><DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"></DigestMethod><DigestValue>Ya5kXhcEibOVfcyOI0BzqcYzyMM=</DigestValue></Reference></SignedInfo><SignatureValue>mirdDvdV+VId/zsstW/6lVFsSVxdyWkdkY1NPd2ynLHpjtolFoIhaBGlfxxs7IhU/AzcNQmR6ivr9YkH1HXaMAypvvx9M6GR/T4du/Zqab4gx3YInVybjJTeQ7BKEDnLhde2TUKoXrxmfrrmBUw6K4nTNufVjUjFJBfGcwhJ57T72x7ssdoYuPvZCphb0IR8WxHRKhvKAQhjW61qfh33csTabelgVZSLuTC2I2k9+a+ARd88CLTlfhYNCAPItOdUnAjgrhAhtiDi2FjXKjywgRqx0zay8DxF9Y2iyTJd3IAoWOERGdI9whgsuzWiZUr2I0I5QGGBELVabfjXm/Bneg==</SignatureValue><KeyInfo><X509Data><X509Certificate>MIIDhjCCAm6gAwIBAgIBATANBgkqhkiG9w0BAQsFADBbMSswKQYDVQQDEyJBQ0JSIE5PREUgU1lOVEhFVElDOjExMjIyMzMzMDAwMTgxMQswCQYDVQQGEwJCUjEfMB0GA1UEChMWU1lOVEhFVElDIE9GRkxJTkUgVEVTVDAeFw0yNjEwMDYyMjIzMzNaFw0yNzEwMDgyMjIzMzNaMFsxKzApBgNVBAMTIkFDQlIgTk9ERSBTWU5USEVUSUM6MTEyMjIzMzMwMDAxODExCzAJBgNVBAYTAkJSMR8wHQYDVQQKExZTWU5USEVUSUMgT0ZGTElORSBURVNUMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsOwRzuW4de7jrv1IkcNgT311292NR5NNIHt6Fncarm2iJX6mYsIjPWriFQmrU88p7bfRI3EsXJrlK0oGCuMafbNf1nBZ6Tu8aV1ixbAIgu9ZIbWoDqDNbYJBucQRuKsI1ytFbY7eI0juhcdAlBHw3TNdgSbuv/8kEGgTTJ803wBcC+emGZHdpb4Bwx6Db0Fio0lWLlBaep9+MFNZZiEYmDA3dwgZF14MAr5MpzcNDUVYh/g95Ks8x+mhErOPdtmL1A6cDg+xtjiApeMJZqjMrdsXP4yQ34h5VRy03ZUJkXVAquOfWhXpQL/qjoSzXfHvij2wB0pVn89FzVZh7GzStQIDAQABo1UwUzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIF4DATBgNVHSUEDDAKBggrBgEFBQcDAjAkBgNVHREEHTAboBkGBWBMAQMDoBAMDjExMjIyMzMzMDAwMTgxMA0GCSqGSIb3DQEBCwUAA4IBAQBDhbpxphiuAUlQWXkcVt22Nc+g2UM6GCZyC3v9o21llLSCyK/nhkrRCQzM75/86kbnYZ1zdulC9N4XQFgATwm16Sf/nDZw8s5EsXqZ8mwbauDs/aQvWrbQnyawB7c+aXvlUDkcfNq+3hLQ5ep8/bmGh4eueiNoPD0fjf/jUVmrS6KyHb6/FyIZGP6fEYAO6XrqJPMSPxpJHnbPXZXKW2vcCh3qaG1vTSeN8PLfN2Q/mp1XUH8VqHgl3jzssx/zwb1NKuKEz9WL+6ilLc1ZfIqUakJyQNMqMz2KIjqGKGp7TtpNHZ7mz+kBX4Xw7D5fFVrXYb7DN6KylyKLmXoEzs1B</X509Certificate></X509Data></KeyInfo></Signature></NFe>';
+
+// src/offline-check.ts
+async function checkOffline(config, manifest) {
+  const emitter = criarEmissor({
+    cnpj: "11222333000181",
+    uf: "CE",
+    modelo: 55,
+    ambiente: 2,
+    contrato: { sourceRevision: manifest.sourceRevision, contractHash: manifest.contractHash },
+    runtimeDirectory: runtimeDirectory(config),
+    timeoutMs: 3e4
+  });
+  const report = [];
+  function expect(name, result, estado, codigo) {
+    if (result.estado !== estado || result.sucesso !== (estado !== "ERRO") || result.envioIniciado !== false || result.sourceRevision !== manifest.sourceRevision || codigo !== void 0 && result.codigo !== codigo) {
+      throw new Error(`Smoke offline ${name} falhou: ${result.estado}/${result.codigo ?? "sem c\xF3digo"}.`);
+    }
+    report.push({ name, estado: result.estado, codigo: result.codigo, envioIniciado: false });
+  }
+  try {
+    const generated = await emitter.gerarXml(OFFLINE_DOCUMENT);
+    expect("gerarXml sint\xE9tico", generated, "XML_GERADO");
+    const xml = generated.xmlBase64 ? Buffer.from(generated.xmlBase64, "base64").toString("utf8") : "";
+    const generatedKey = /Id="NFe(\d{44})"/.exec(xml)?.[1];
+    if (!generatedKey || !xml.includes("Caf\xE9 S\xE3o Jos\xE9 TESTE OFFLINE") || !xml.includes("<CNPJ>11222333000181</CNPJ>")) throw new Error("Smoke offline gerarXml perdeu chave, identidade ou UTF-8.");
+    const validated = await emitter.validar(OFFLINE_SIGNED_XML);
+    expect("validar XML assinado p\xFAblico", validated, "VALIDADO");
+    const signedKey = /Id="NFe(\d{44})"/.exec(OFFLINE_SIGNED_XML)?.[1];
+    if (validated.chave !== signedKey || generatedKey !== signedKey) throw new Error("Smoke offline validar retornou outra chave fiscal.");
+    expect("recusar XML malformado", await emitter.validar("<NFe><infNFe></NFe>"), "ERRO", "OPERACAO_FISCAL_FALHOU");
+    expect("recusar DTD/entidade externa", await emitter.validar('<!DOCTYPE NFe [<!ENTITY probe SYSTEM "file:///acbr-node-offline-check-does-not-exist">]><NFe>&probe;</NFe>'), "ERRO", "XML_INVALIDO");
+    return report;
+  } finally {
+    await emitter.fechar();
+  }
+}
+
+// src/cli.ts
+var HELP = `acbr-node \u2014 compila\xE7\xE3o e contrato Node/ACBr NF-e
+
+Uso:
+  acbr-node init [--config caminho] [--revision HEAD|n\xFAmero]
+  acbr-node source update [--config caminho] [--revision HEAD|n\xFAmero]
+  acbr-node source lock --revision n\xFAmero [--config caminho]
+  acbr-node generate [--config caminho]
+  acbr-node build [--config caminho]
+  acbr-node check [--config caminho]
+  acbr-node doctor [--config caminho]
+
+source update consulta o SVN oficial e substitui apenas fontes verificadas pelo lock.
+source lock registra um export existente cuja origem/revis\xE3o o operador j\xE1 conferiu.
+generate/build/check nunca atualizam fontes. Nenhum comando transmite NF-e.
+`;
+function revision(value) {
+  if (value === void 0) return void 0;
+  if (value === "HEAD") return value;
+  if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value))) throw new Error("--revision deve ser HEAD ou um n\xFAmero SVN positivo.");
+  return Number(value);
+}
+function parseArguments(args) {
+  const result = { command: [], config: "acbr.config.json", json: false, help: false };
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg.startsWith("-")) {
+      result.command.push(arg);
+      continue;
+    }
+    if (used.has(arg)) throw new Error(`Op\xE7\xE3o repetida: ${arg}.`);
+    used.add(arg);
+    if (arg === "--help" || arg === "-h") result.help = true;
+    else if (arg === "--json") result.json = true;
+    else if (arg === "--config" || arg === "--revision") {
+      const value = args[++i];
+      if (value === void 0 || value.startsWith("--")) throw new Error(`Valor obrigat\xF3rio para ${arg}.`);
+      if (arg === "--config") result.config = value;
+      else result.revision = revision(value);
+    } else throw new Error(`Op\xE7\xE3o desconhecida: ${arg}.`);
+  }
+  return result;
+}
+async function main(args = process.argv.slice(2), io = process) {
+  try {
+    const options = parseArguments(args);
+    const command = options.command.join(" ");
+    if (options.help || !command) {
+      io.stdout.write(HELP);
+      return 0;
+    }
+    const output = (value, text) => io.stdout.write(options.json ? `${JSON.stringify(value, null, 2)}
+` : `${text}
+`);
+    if (command === "init") {
+      const config2 = await initializeConfig(options.config, options.revision, fileURLToPath3(new URL("../", import.meta.url)));
+      output({ configPath: config2.configPath }, `Configura\xE7\xE3o criada: ${config2.configPath}
+Pr\xF3ximo passo: acbr-node source update.`);
+      return 0;
+    }
+    if (!["source update", "source lock", "generate", "build", "check", "doctor"].includes(command)) throw new Error(`Comando desconhecido: ${command}. Use --help.`);
+    if (options.revision !== void 0 && !command.startsWith("source ")) throw new Error("--revision \xE9 aceito somente em init e source.");
+    if (command === "doctor") {
+      let config2;
+      try {
+        await access4(resolve4(options.config));
+        config2 = await loadConfig(options.config);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      const report = await doctor(config2);
+      output(report, report.map((item) => `${item.ok ? "OK" : "FALHA"} ${item.name}: ${item.detail}`).join("\n"));
+      return report.every((item) => item.ok) ? 0 : 1;
+    }
+    const config = await loadConfig(options.config);
+    if (command === "source update") {
+      const lock = await updateSource(config, options.revision);
+      output(lock, `Fontes oficiais registradas na revis\xE3o ${lock.source.revision}.
+SHA256 da \xE1rvore: ${lock.source.treeHash}
+Execute generate para atualizar o contrato.`);
+    } else if (command === "source lock") {
+      if (typeof options.revision !== "number") throw new Error("source lock exige --revision com o n\xFAmero verificado do export SVN.");
+      if (config.source.revision !== "HEAD" && config.source.revision !== options.revision) throw new Error("Revis\xE3o do export diverge da configura\xE7\xE3o.");
+      const lock = await lockExistingSource(config, options.revision);
+      output(lock, `Export existente registrado na revis\xE3o ${lock.source.revision}; ${Object.keys(lock.source.files).length} arquivos protegidos por SHA256.`);
+    } else if (command === "generate") {
+      const lock = await verifySource(config);
+      const { generateModel: generateModel2 } = await Promise.resolve().then(() => (init_generator(), generator_exports));
+      const result = await generateModel2({ acbrRoot: config.source.directory, outputDir: config.generator.outputDir, revision: String(lock.source.revision), sourceHash: lock.source.treeHash, fpcPath: config.native.fpc });
+      output(result, `Contrato ${result.contractHash}; ${result.models} modelos gerados.
+Revise o relat\xF3rio: ${result.reportPath}`);
+    } else if (command === "build") {
+      const result = await buildNative(config);
+      output(result, `Runtime compilado: ${runtimeDirectory(config)}
+ACBr revis\xE3o ${result.sourceRevision}; contrato ${result.contractHash}.`);
+    } else {
+      const result = await checkBuild(config);
+      const offlineChecks = await checkOffline(config, result);
+      output({ ...result, offlineChecks }, `Fontes, contrato e ${Object.keys(result.files).length} arquivos do runtime conferidos por SHA256.
+${offlineChecks.length} verifica\xE7\xF5es offline do motor aprovadas; nenhuma transmiss\xE3o.`);
+    }
+    return 0;
+  } catch (error) {
+    io.stderr.write(`Erro: ${error.message}
+`);
+    return 1;
+  }
+}
+if (process.argv[1] && resolve4(process.argv[1]) === fileURLToPath3(import.meta.url)) {
+  main().then((code) => {
+    process.exitCode = code;
+  });
+}
+export {
+  HELP,
+  main,
+  parseArguments
+};
+//# sourceMappingURL=cli.js.map