taximeter 0.1.0

package/dist/chunk-I7YXGTRZ.js

@@ -0,0 +1,1167 @@
+// src/model.ts
+import { z } from "zod";
+var integerStringSchema = z.string().regex(/^(0|[1-9][0-9]*)$/);
+var amountSchema = integerStringSchema.max(78);
+var httpUrlSchema = z.url().refine((value) => {
+  const url = new URL(value);
+  return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password;
+}, "Expected an HTTP(S) URL without credentials");
+var labelSchema = z.string().min(1).max(256);
+var headersSchema = z.record(z.string(), z.string());
+var requestSchema = z.object({
+  url: httpUrlSchema,
+  method: z.string().min(1).max(64),
+  headers: headersSchema
+});
+var responseSchema = z.object({
+  status: z.number().int().min(100).max(599),
+  headers: headersSchema,
+  body: z.instanceof(Uint8Array).optional()
+});
+var paymentEventSchema = z.object({
+  id: z.uuidv7(),
+  ts: z.iso.datetime(),
+  rail: z.literal("x402"),
+  attemptedAt: z.iso.datetime().optional(),
+  status: z.enum(["observed", "blocked"]),
+  reason: z.string().optional(),
+  amount: amountSchema,
+  decimals: z.number().int().min(0).max(255),
+  decimalsKnown: z.boolean(),
+  asset: labelSchema,
+  assetSymbol: labelSchema.optional(),
+  network: labelSchema,
+  payTo: labelSchema,
+  payer: labelSchema.optional(),
+  resource: httpUrlSchema,
+  host: labelSchema,
+  txHash: z.string().optional(),
+  taskId: labelSchema.optional(),
+  agentId: labelSchema.optional(),
+  raw: z.string(),
+  paymentKey: z.string().min(1),
+  settlementStatus: z.enum(["unknown", "confirmed", "failed"]).default("unknown"),
+  settlement_unknown: z.boolean().default(true)
+});
+var outcomeSchema = z.object({
+  id: z.uuidv7(),
+  ts: z.iso.datetime(),
+  paymentId: z.uuidv7(),
+  attemptId: z.uuidv7().optional(),
+  attemptedAt: z.iso.datetime().optional(),
+  status: z.enum(["unknown", "confirmed", "failed"]),
+  txHash: z.string().optional(),
+  reason: z.string().optional()
+});
+var diagnosticSchema = z.object({
+  id: z.uuidv7(),
+  ts: z.iso.datetime(),
+  code: z.enum(["parse_failed", "settlement_unknown", "tls_unmetered", "storage_failed"]),
+  resource: z.string(),
+  message: z.string()
+});
+var blockedBodySchema = z.object({
+  error: z.literal("blocked_by_taximeter"),
+  reason: z.string(),
+  budget: amountSchema.nullable(),
+  spent: integerStringSchema,
+  remaining: amountSchema.nullable()
+});
+
+// src/config.ts
+import { z as z2 } from "zod";
+var budgetSchema = z2.strictObject({
+  amount: amountSchema,
+  asset: labelSchema,
+  network: labelSchema.optional(),
+  window: z2.enum(["1h", "24h", "7d", "30d"]).optional()
+});
+var policySchema = z2.strictObject({
+  allowHosts: z2.array(labelSchema).default([]),
+  denyHosts: z2.array(labelSchema).default([]),
+  allowPayTo: z2.array(labelSchema).default([]),
+  maxSinglePayment: amountSchema.nullable().default("1000000"),
+  maxSingleAsset: labelSchema.default("USDC")
+});
+var portsSchema = z2.strictObject({
+  proxy: z2.number().int().min(0).max(65535).default(8402),
+  dashboard: z2.number().int().min(0).max(65535).default(8403)
+});
+var configSchema = z2.strictObject({
+  budgets: z2.strictObject({
+    perTask: budgetSchema.nullable().default({ amount: "5000000", asset: "USDC" }),
+    perAgent: budgetSchema.nullable().default({ amount: "50000000", asset: "USDC", window: "24h" }),
+    global: budgetSchema.nullable().default({ amount: "100000000", asset: "USDC", window: "24h" })
+  }).prefault({}),
+  policy: policySchema.prefault({}),
+  ports: portsSchema.prefault({}),
+  db: z2.string().min(1).default("~/.taximeter/ledger.db"),
+  upstream: httpUrlSchema.optional()
+});
+var configPatchSchema = z2.strictObject({
+  budgets: z2.strictObject({
+    perTask: budgetSchema.partial().nullable().optional(),
+    perAgent: budgetSchema.partial().nullable().optional(),
+    global: budgetSchema.partial().nullable().optional()
+  }).optional(),
+  policy: z2.strictObject({
+    allowHosts: z2.array(labelSchema).optional(),
+    denyHosts: z2.array(labelSchema).optional(),
+    allowPayTo: z2.array(labelSchema).optional(),
+    maxSinglePayment: amountSchema.nullable().optional(),
+    maxSingleAsset: labelSchema.optional()
+  }).optional(),
+  ports: z2.strictObject({
+    proxy: z2.number().int().min(0).max(65535).optional(),
+    dashboard: z2.number().int().min(0).max(65535).optional()
+  }).optional(),
+  db: z2.string().min(1).optional(),
+  upstream: httpUrlSchema.optional()
+});
+function parseConfig(...layers) {
+  let current = configSchema.parse({});
+  for (const input of layers) {
+    const layer = configPatchSchema.parse(input);
+    const budgets = { ...current.budgets };
+    for (const key of ["perTask", "perAgent", "global"]) {
+      const next = layer.budgets?.[key];
+      if (next !== void 0)
+        budgets[key] = next === null ? null : budgetSchema.parse({ ...budgets[key], ...next });
+    }
+    current = configSchema.parse({
+      ...current,
+      ...layer,
+      budgets,
+      policy: { ...current.policy, ...layer.policy },
+      ports: { ...current.ports, ...layer.ports }
+    });
+  }
+  return current;
+}
+
+// src/config/io.ts
+import { existsSync, readFileSync, realpathSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute, join, resolve } from "path";
+import { z as z3 } from "zod";
+function expandPath(input, home = homedir(), cwd = process.cwd()) {
+  let path = z3.string().min(1).parse(input);
+  if (path === ":memory:") return path;
+  if (path === "~") path = home;
+  else if (path.startsWith("~/") || path.startsWith("~\\")) path = join(home, path.slice(2));
+  const absolute = isAbsolute(path) ? path : resolve(cwd, path);
+  return existsSync(absolute) ? realpathSync(absolute) : existsSync(dirname(absolute)) ? join(realpathSync(dirname(absolute)), basename(absolute)) : absolute;
+}
+function readConfig(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return configPatchSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+  } catch {
+    throw new Error(`Invalid Taximeter configuration: ${path}`);
+  }
+}
+var portInputSchema = z3.string().regex(/^[0-9]{1,5}$/).pipe(z3.coerce.number().int().min(0).max(65535));
+var environmentSchema = z3.object({
+  TAXIMETER_DB: z3.string().min(1).optional(),
+  TAXIMETER_PORT: portInputSchema.optional(),
+  TAXIMETER_DASHBOARD_PORT: portInputSchema.optional()
+});
+function loadConfig(flags = {}, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const home = options.home ?? homedir();
+  const env = environmentSchema.parse(options.env ?? process.env);
+  const environment = {
+    ...env.TAXIMETER_DB ? { db: env.TAXIMETER_DB } : {},
+    ports: {
+      ...env.TAXIMETER_PORT !== void 0 ? { proxy: env.TAXIMETER_PORT } : {},
+      ...env.TAXIMETER_DASHBOARD_PORT !== void 0 ? { dashboard: env.TAXIMETER_DASHBOARD_PORT } : {}
+    }
+  };
+  if (options.configFile && !existsSync(resolve(cwd, options.configFile)))
+    throw new Error(`Configuration file not found: ${options.configFile}`);
+  const config = parseConfig(
+    readConfig(join(home, ".taximeter", "config.json")),
+    readConfig(join(cwd, "taximeter.config.json")),
+    ...options.configFile ? [readConfig(resolve(cwd, options.configFile))] : [],
+    environment,
+    flags
+  );
+  return { ...config, db: expandPath(config.db, home, cwd) };
+}
+
+// src/ledger/derive.ts
+import { z as z4 } from "zod";
+var totalSchema = z4.object({
+  network: z4.string(),
+  asset: z4.string(),
+  assetSymbol: z4.string().optional(),
+  decimals: z4.number().int(),
+  decimalsKnown: z4.boolean(),
+  amount: integerStringSchema,
+  confirmedAmount: integerStringSchema,
+  unknownAmount: integerStringSchema
+});
+function assetKey(event) {
+  return `${event.network}/${event.asset.toLowerCase()}`;
+}
+function order(a, b) {
+  return a.ts.localeCompare(b.ts) || a.id.localeCompare(b.id);
+}
+function deriveEvents(events, outcomes = []) {
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenPayments = /* @__PURE__ */ new Set();
+  const latest = /* @__PURE__ */ new Map();
+  const attempted = /* @__PURE__ */ new Map();
+  for (const outcome of [...outcomes].sort(order)) {
+    const attempts = latest.get(outcome.paymentId) ?? /* @__PURE__ */ new Map();
+    const attemptId = outcome.attemptId ?? outcome.paymentId;
+    if (attempts.get(attemptId)?.status !== "confirmed" || outcome.status === "confirmed") {
+      attempts.set(attemptId, outcome);
+    }
+    latest.set(outcome.paymentId, attempts);
+    if (outcome.attemptedAt && outcome.attemptedAt > (attempted.get(outcome.paymentId) ?? ""))
+      attempted.set(outcome.paymentId, outcome.attemptedAt);
+  }
+  const result = [];
+  for (const event of [...events].sort(order)) {
+    if (seenIds.has(event.id)) continue;
+    seenIds.add(event.id);
+    if (event.status === "observed") {
+      if (seenPayments.has(event.paymentKey)) continue;
+      seenPayments.add(event.paymentKey);
+    }
+    const attempts = [...latest.get(event.id)?.values() ?? []];
+    const outcome = attempts.find((value) => value.status === "confirmed") ?? attempts.find((value) => value.status === "unknown") ?? attempts.at(-1);
+    const status = event.settlementStatus === "confirmed" ? "confirmed" : outcome?.status ?? event.settlementStatus;
+    result.push({
+      ...event,
+      ...attempted.has(event.id) ? { attemptedAt: attempted.get(event.id) } : {},
+      settlementStatus: status,
+      settlement_unknown: event.status === "observed" && status === "unknown",
+      ...outcome?.txHash ? { txHash: outcome.txHash } : {}
+    });
+  }
+  return result;
+}
+function countsAsSpend(event) {
+  return event.status === "observed" && event.settlementStatus !== "failed";
+}
+function totals(events) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of deriveEvents(events)) {
+    if (!countsAsSpend(event)) continue;
+    const key = assetKey(event);
+    const current = groups.get(key) ?? {
+      network: event.network,
+      asset: event.asset.toLowerCase(),
+      assetSymbol: event.assetSymbol,
+      decimals: event.decimals,
+      decimalsKnown: event.decimalsKnown,
+      amount: "0",
+      confirmedAmount: "0",
+      unknownAmount: "0"
+    };
+    const amount = BigInt(event.amount);
+    current.amount = (BigInt(current.amount) + amount).toString();
+    if (event.settlementStatus === "confirmed") {
+      current.confirmedAmount = (BigInt(current.confirmedAmount) + amount).toString();
+    } else {
+      current.unknownAmount = (BigInt(current.unknownAmount) + amount).toString();
+    }
+    groups.set(key, current);
+  }
+  return [...groups.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([, total]) => total);
+}
+function formatAmount(amount, decimals) {
+  const integer = BigInt(amount).toString();
+  if (decimals === 0) return integer;
+  const padded = integer.padStart(decimals + 1, "0");
+  return `${padded.slice(0, -decimals)}.${padded.slice(-decimals)}`;
+}
+
+// src/assets.ts
+var usdc = {
+  "eip155:8453": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+  "eip155:84532": "0x036cbd53842c5426634e7929541ec2318f3dcf7e"
+};
+function assetMetadata(network, asset) {
+  return usdc[network] === asset.toLowerCase() ? { decimals: 6, decimalsKnown: true, assetSymbol: "USDC" } : { decimals: 0, decimalsKnown: false };
+}
+function matchesAsset(selector, payment) {
+  return selector.toLowerCase() === payment.asset.toLowerCase() || selector === "USDC" && assetMetadata(payment.network, payment.asset).assetSymbol === "USDC";
+}
+
+// src/policy/index.ts
+var windows = { "1h": 36e5, "24h": 864e5, "7d": 6048e5, "30d": 2592e6 };
+function deny(reason, budget = null, spent = "0") {
+  const difference = budget === null ? null : BigInt(budget) - BigInt(spent);
+  return {
+    allowed: false,
+    body: {
+      error: "blocked_by_taximeter",
+      reason,
+      budget,
+      spent,
+      remaining: difference === null ? null : (difference < 0n ? 0n : difference).toString()
+    }
+  };
+}
+function spentForBudget(proposed, events, budget, scope, now) {
+  const start = budget.window ? now - windows[budget.window] : -Infinity;
+  let spent = 0n;
+  for (const event of deriveEvents(events)) {
+    if (!countsAsSpend(event) || assetKey(event) !== assetKey(proposed)) continue;
+    const ts = Date.parse(event.attemptedAt ?? event.ts);
+    if (ts < start || ts > now) continue;
+    if (scope === "perTask" && event.taskId !== proposed.taskId) continue;
+    if (scope === "perAgent" && event.agentId !== proposed.agentId) continue;
+    spent += BigInt(event.amount);
+  }
+  return spent.toString();
+}
+function evaluate(proposed, events, config, now) {
+  const { policy } = config;
+  const host = proposed.host.toLowerCase();
+  if (policy.denyHosts.some((value) => value.toLowerCase() === host)) return deny("host_denied");
+  if (policy.allowHosts.length > 0 && !policy.allowHosts.some((value) => value.toLowerCase() === host))
+    return deny("host_not_allowed");
+  if (policy.allowPayTo.length > 0 && !policy.allowPayTo.some((value) => value.toLowerCase() === proposed.payTo.toLowerCase()))
+    return deny("recipient_not_allowed");
+  if (policy.maxSinglePayment !== null && matchesAsset(policy.maxSingleAsset, proposed) && BigInt(proposed.amount) > BigInt(policy.maxSinglePayment))
+    return deny("max_single_payment", policy.maxSinglePayment);
+  const reserved = events.find(
+    (event) => event.paymentKey === proposed.paymentKey && countsAsSpend(event)
+  );
+  for (const scope of ["perTask", "perAgent", "global"]) {
+    const budget = config.budgets[scope];
+    if (!budget || !matchesAsset(budget.asset, proposed) || budget.network && budget.network !== proposed.network)
+      continue;
+    const spent = spentForBudget(proposed, events, budget, scope, now);
+    const reservedTime = reserved ? Date.parse(reserved.attemptedAt ?? reserved.ts) : -Infinity;
+    const inWindow = reservedTime <= now && (!budget.window || reservedTime >= now - windows[budget.window]);
+    const increment = reserved && (reserved.settlementStatus === "confirmed" || inWindow) ? 0n : BigInt(proposed.amount);
+    if (BigInt(spent) + increment > BigInt(budget.amount)) {
+      const reason = scope === "perTask" ? "per_task_budget" : scope === "perAgent" ? "per_agent_budget" : "global_budget";
+      return deny(reason, budget.amount, spent);
+    }
+  }
+  return { allowed: true };
+}
+
+// src/rails/x402.ts
+import { createHash } from "crypto";
+import { v7 } from "uuid";
+import { z as z6 } from "zod";
+
+// src/rails/schemas.ts
+import { z as z5 } from "zod";
+var metadata = z5.record(z5.string(), z5.unknown()).nullish();
+var text = z5.string().nullish();
+var wireAmountSchema = z5.string().max(256).regex(/^[0-9]+$/).transform((value) => BigInt(value).toString());
+var addressSchema = z5.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var authorizationSchema = z5.looseObject({
+  from: addressSchema,
+  to: addressSchema,
+  value: wireAmountSchema,
+  validAfter: wireAmountSchema,
+  validBefore: wireAmountSchema,
+  nonce: z5.string().regex(/^0x[0-9a-fA-F]{64}$/)
+});
+var eip3009Schema = z5.looseObject({
+  signature: z5.string().regex(/^0x(?:[0-9a-fA-F]{2})*$/).optional(),
+  authorization: authorizationSchema
+});
+var resourceSchema = z5.looseObject({
+  url: z5.string().min(1),
+  description: text,
+  mimeType: text
+});
+var common = {
+  scheme: z5.string(),
+  network: z5.string(),
+  asset: z5.string().min(1),
+  payTo: z5.string().min(1),
+  maxTimeoutSeconds: z5.number().positive(),
+  extra: metadata
+};
+var requirementsV1Schema = z5.looseObject({
+  ...common,
+  maxAmountRequired: wireAmountSchema,
+  resource: z5.string().min(1),
+  description: z5.string(),
+  mimeType: text,
+  outputSchema: metadata
+});
+var requirementsV2Schema = z5.looseObject({ ...common, amount: wireAmountSchema });
+var requiredV1Schema = z5.looseObject({
+  x402Version: z5.literal(1),
+  error: text,
+  accepts: z5.array(requirementsV1Schema).min(1)
+});
+var requiredV2Schema = z5.looseObject({
+  x402Version: z5.literal(2),
+  error: text,
+  resource: resourceSchema,
+  accepts: z5.array(requirementsV2Schema).min(1),
+  extensions: metadata
+});
+var payloadV1Schema = z5.looseObject({
+  x402Version: z5.literal(1),
+  scheme: z5.literal("exact"),
+  network: z5.string(),
+  payload: eip3009Schema
+});
+var payloadV2Schema = z5.looseObject({
+  x402Version: z5.literal(2),
+  accepted: requirementsV2Schema.extend({ scheme: z5.literal("exact") }),
+  resource: resourceSchema.nullish(),
+  payload: eip3009Schema,
+  extensions: metadata
+});
+var settlementSchema = z5.looseObject({
+  success: z5.boolean(),
+  transaction: z5.string(),
+  network: z5.string(),
+  payer: z5.string().optional(),
+  errorReason: z5.string().optional(),
+  errorMessage: z5.string().optional(),
+  amount: wireAmountSchema.optional()
+});
+
+// src/rails/x402.ts
+var headerSchema = z6.string().max(65536).regex(/^[A-Za-z0-9+/]+={0,2}$/);
+function decodeHeader(input) {
+  const encoded = headerSchema.parse(input);
+  const bytes = Buffer.from(encoded, "base64");
+  if (bytes.toString("base64").replace(/=+$/, "") !== encoded.replace(/=+$/, ""))
+    throw new Error("Invalid base64");
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+}
+function normalizeNetwork(input) {
+  if (input === "base") return "eip155:8453";
+  if (input === "base-sepolia") return "eip155:84532";
+  return /^eip155:[1-9][0-9]*$/.test(input) ? input : null;
+}
+function contextKey(request) {
+  return createHash("sha256").update(
+    JSON.stringify([
+      request.method,
+      request.url,
+      request.headers["taximeter-task"],
+      request.headers["taximeter-agent"],
+      request.headers.authorization,
+      request.headers.cookie
+    ])
+  ).digest("hex");
+}
+var X402Rail = class {
+  name = "x402";
+  cache = /* @__PURE__ */ new Map();
+  now;
+  diagnostic;
+  constructor(options = {}) {
+    this.now = options.now ?? Date.now;
+    this.diagnostic = options.diagnostic ?? (() => {
+    });
+  }
+  report(resource, message, code = "parse_failed") {
+    try {
+      this.diagnostic(code, resource, message);
+    } catch {
+    }
+  }
+  detect(request, response) {
+    return Boolean(
+      request.headers["payment-signature"] !== void 0 || request.headers["x-payment"] !== void 0 || response?.status === 402 || response?.headers["payment-required"] || response?.headers["payment-response"] || response?.headers["x-payment-response"]
+    );
+  }
+  attribution(request, header) {
+    const value = labelSchema.optional().safeParse(request.headers[header]);
+    if (value.success) return value.data;
+    this.report(
+      request.url,
+      "Invalid attribution label; payment assigned to the unattributed bucket."
+    );
+    return void 0;
+  }
+  parse(input, reply) {
+    try {
+      const request = requestSchema.parse(input);
+      if (reply) {
+        const response = responseSchema.parse(reply);
+        if (response.status !== 402) return null;
+        if (response.headers["payment-required"]) {
+          const challenge = requiredV2Schema.parse(
+            decodeHeader(response.headers["payment-required"])
+          );
+          if (!challenge.accepts.some(
+            (option) => option.scheme === "exact" && normalizeNetwork(option.network)
+          ))
+            this.report(request.url, "Unsupported payment requirements; forwarded unchanged.");
+        } else {
+          if (!response.body || response.body.byteLength > 65536 || response.headers["content-encoding"])
+            throw new Error("Unavailable v1 body");
+          const challenge = requiredV1Schema.parse(
+            JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(response.body))
+          );
+          const key = contextKey(request);
+          this.cache.delete(key);
+          this.cache.set(key, { challenge, expires: this.now() + 3e5 });
+          if (this.cache.size > 1e3) {
+            const oldest = this.cache.keys().next().value;
+            if (oldest !== void 0) this.cache.delete(oldest);
+          }
+        }
+        return null;
+      }
+      const v2Header = request.headers["payment-signature"];
+      const v1Header = request.headers["x-payment"];
+      if (v2Header === void 0 && v1Header === void 0) return null;
+      if (v2Header !== void 0 && v1Header !== void 0)
+        throw new Error("Ambiguous payment headers");
+      const original = decodeHeader(v2Header ?? v1Header);
+      const raw = JSON.stringify(original);
+      const parsed = v2Header ? payloadV2Schema.parse(original) : payloadV1Schema.parse(original);
+      const payload = parsed.payload;
+      if ("permit2Authorization" in payload || "delegationManager" in payload)
+        throw new Error("Unsupported mixed transfer methods");
+      const auth = payload.authorization;
+      let asset;
+      let payTo;
+      let amount;
+      let network;
+      let extra;
+      if (parsed.x402Version === 2) {
+        if (!/^eip155:[1-9][0-9]*$/.test(parsed.accepted.network))
+          throw new Error("Unsupported v2 network");
+        network = parsed.accepted.network;
+        ({ asset, payTo, amount, extra } = parsed.accepted);
+      } else {
+        if (!["base", "base-sepolia"].includes(parsed.network))
+          throw new Error("Unsupported v1 network");
+        network = normalizeNetwork(parsed.network);
+        const cached = this.cache.get(contextKey(request));
+        if (!cached || cached.expires < this.now()) throw new Error("Missing v1 challenge");
+        const matches = cached.challenge.accepts.filter(
+          (option) => option.scheme === "exact" && option.network === parsed.network && option.payTo.toLowerCase() === auth.to.toLowerCase() && option.maxAmountRequired === auth.value
+        );
+        const identities = new Set(matches.map((option) => option.asset.toLowerCase()));
+        const selected = matches[0];
+        if (!selected || identities.size !== 1) throw new Error("Ambiguous v1 requirements");
+        ({ asset, payTo, extra } = selected);
+        amount = selected.maxAmountRequired;
+      }
+      if (extra?.assetTransferMethod !== void 0 && extra.assetTransferMethod !== "eip3009")
+        throw new Error("Unsupported transfer method");
+      if (!network || amount !== auth.value || payTo.toLowerCase() !== auth.to.toLowerCase())
+        throw new Error("Inconsistent exact authorization");
+      asset = addressSchema.parse(asset).toLowerCase();
+      const payer = auth.from.toLowerCase();
+      payTo = auth.to.toLowerCase();
+      const paymentKey = createHash("sha256").update(
+        JSON.stringify([
+          network,
+          asset,
+          payer,
+          auth.nonce.toLowerCase(),
+          amount,
+          payTo,
+          auth.validAfter,
+          auth.validBefore
+        ])
+      ).digest("hex");
+      return paymentEventSchema.parse({
+        id: v7(),
+        ts: new Date(this.now()).toISOString(),
+        rail: "x402",
+        status: "observed",
+        amount,
+        asset,
+        network,
+        payTo,
+        payer,
+        ...assetMetadata(network, asset),
+        resource: request.url,
+        host: new URL(request.url).hostname.toLowerCase(),
+        taskId: this.attribution(request, "taximeter-task"),
+        agentId: this.attribution(request, "taximeter-agent"),
+        paymentKey,
+        raw
+      });
+    } catch {
+      const context = z6.object({ url: z6.string() }).safeParse(input);
+      this.report(
+        context.data?.url ?? "unknown",
+        "Unrecognized or inconsistent x402 data; forwarded unchanged."
+      );
+      return null;
+    }
+  }
+  settlement(event, input) {
+    try {
+      const response = responseSchema.parse(input);
+      const header = response.headers["payment-response"] ?? response.headers["x-payment-response"];
+      if (!header) return { status: "unknown", reason: "settlement_unknown" };
+      const settlement = settlementSchema.parse(decodeHeader(header));
+      if (normalizeNetwork(settlement.network) !== event.network || settlement.payer && settlement.payer.toLowerCase() !== event.payer || settlement.amount && settlement.amount !== event.amount)
+        throw new Error("Settlement mismatch");
+      if (settlement.success && settlement.transaction)
+        return { status: "confirmed", txHash: settlement.transaction };
+      if (!settlement.success && response.status < 500)
+        return { status: "failed", reason: settlement.errorReason ?? "settlement_failed" };
+      return { status: "unknown", reason: "settlement_unknown" };
+    } catch {
+      this.report(
+        event.resource,
+        "Unrecognized settlement evidence; authorization remains reserved."
+      );
+      return { status: "unknown", reason: "settlement_unknown" };
+    }
+  }
+};
+
+// src/core.ts
+import { v7 as v72 } from "uuid";
+var Meter = class {
+  constructor(ledger, config) {
+    this.ledger = ledger;
+    this.config = parseConfig(config);
+    this.rail = new X402Rail({
+      diagnostic: (code, resource, message) => this.diagnose(code, resource, message)
+    });
+  }
+  ledger;
+  rail;
+  config;
+  diagnose(code, resource, message) {
+    try {
+      this.ledger.diagnose(code, resource, message);
+    } catch {
+      process.stderr.write(
+        "Taximeter: storage unavailable; traffic is passing without reliable budget enforcement.\n"
+      );
+    }
+  }
+  begin(request) {
+    const proposed = this.rail.parse(request);
+    if (!proposed) return {};
+    try {
+      return this.ledger.transaction(() => {
+        const events = this.ledger.view();
+        const decision = evaluate(proposed, events, this.config, Date.now());
+        if (!decision.allowed) {
+          this.ledger.append(
+            paymentEventSchema.parse({
+              ...proposed,
+              status: "blocked",
+              reason: decision.body.reason,
+              settlement_unknown: false
+            })
+          );
+          return { body: decision.body };
+        }
+        const previous = events.find(
+          (event) => event.status === "observed" && event.paymentKey === proposed.paymentKey
+        );
+        const payment = previous ?? proposed;
+        if (!previous) this.ledger.append(payment);
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        const attempt = {
+          id: v72(),
+          ts,
+          paymentId: payment.id,
+          attemptId: v72(),
+          status: "unknown",
+          attemptedAt: previous?.settlementStatus === "confirmed" ? previous.attemptedAt ?? previous.ts : ts
+        };
+        this.ledger.appendOutcome(attempt);
+        return { payment, attempt };
+      });
+    } catch {
+      this.diagnose(
+        "storage_failed",
+        request.url,
+        "Could not reserve budget; request forwarded without metering."
+      );
+      return {};
+    }
+  }
+  observe(request, response) {
+    this.rail.parse(request, response);
+  }
+  complete(intake, response) {
+    if (!intake.payment || !intake.attempt) return;
+    const result = response ? this.rail.settlement(intake.payment, response) : { status: "unknown", reason: "settlement_unknown" };
+    try {
+      this.ledger.appendOutcome({
+        ...intake.attempt,
+        ...result,
+        id: v72(),
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (result.status === "unknown")
+        this.diagnose(
+          "settlement_unknown",
+          intake.payment.resource,
+          "No conclusive settlement response; authorization remains reserved."
+        );
+    } catch {
+      this.diagnose(
+        "storage_failed",
+        intake.payment.resource,
+        "Could not record settlement outcome; original authorization remains reserved."
+      );
+    }
+  }
+};
+
+// src/export/index.ts
+function csvCell(value) {
+  const safe = /^[\s]*[=+@-]/.test(value) || /^[\t\r\n]/.test(value) ? `'${value}` : value;
+  return `"${safe.replaceAll('"', '""')}"`;
+}
+function toCsv(input) {
+  const columns = [
+    "id",
+    "ts",
+    "rail",
+    "status",
+    "settlementStatus",
+    "amount",
+    "authorizedAmount",
+    "asset",
+    "network",
+    "decimals",
+    "decimalsKnown",
+    "assetSymbol",
+    "payTo",
+    "payer",
+    "resource",
+    "host",
+    "taskId",
+    "agentId",
+    "txHash",
+    "reason"
+  ];
+  const rows = deriveEvents(input).map((event) => [
+    event.id,
+    event.ts,
+    event.rail,
+    event.status,
+    event.settlementStatus,
+    countsAsSpend(event) ? event.amount : "0",
+    event.amount,
+    event.asset.toLowerCase(),
+    event.network,
+    event.decimals.toString(),
+    event.decimalsKnown.toString(),
+    event.assetSymbol ?? "",
+    event.payTo,
+    event.payer ?? "",
+    event.resource,
+    event.host,
+    event.taskId ?? "",
+    event.agentId ?? "",
+    event.txHash ?? "",
+    event.reason ?? ""
+  ]);
+  return `${[columns, ...rows].map((row) => row.map(csvCell).join(",")).join("\r\n")}\r
+`;
+}
+function toJson(input) {
+  const events = deriveEvents(input);
+  return `${JSON.stringify({ events, totals: totals(events) }, null, 2)}
+`;
+}
+function html(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function toInvoice(input) {
+  const events = deriveEvents(input);
+  const totalRows = totals(events).map(
+    (total) => `<tr><td>${html(total.assetSymbol ?? total.asset)}<small>${html(total.network)} \xB7 ${html(total.asset)}</small></td><td class="number">${total.decimalsKnown ? formatAmount(total.amount, total.decimals) : `${total.amount} atomic units`}</td><td class="number">${total.unknownAmount}</td></tr>`
+  ).join("");
+  const rows = events.map(
+    (event) => `<tr><td>${html(event.ts)}</td><td>${html(event.taskId ?? "Unattributed")}</td><td>${html(event.host)}</td><td>${html(event.status === "blocked" ? "Blocked" : event.settlementStatus)}</td><td class="number">${countsAsSpend(event) ? event.amount : "0"}</td><td>${html(event.network)} / ${html(event.asset)}</td></tr>`
+  ).join("");
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Taximeter payment statement</title><style>
+body{font:14px Arial,Helvetica,sans-serif;color:#182b27;background:#fff;margin:40px}h1{font-size:30px;font-weight:500}p,small{color:#4a5e58}small{display:block;font-size:11px;overflow-wrap:anywhere}table{border-collapse:collapse;width:100%;margin:24px 0}th,td{text-align:left;vertical-align:top;padding:8px 4px;border-bottom:1px solid #d5e0db;font-size:12px;overflow-wrap:anywhere}th{font-weight:600}.number{text-align:right;font-family:Consolas,monospace;font-variant-numeric:tabular-nums}@media print{body{margin:12mm}thead{display:table-header-group}}
+</style></head><body><h1>Taximeter payment statement</h1><p>Local ledger \xB7 ${events.length} recorded events</p><p>Amounts remain separate by network and asset. Totals include unresolved authorizations; settlement is reported by the upstream and is not independently verified.</p><table><thead><tr><th>Asset / network</th><th>Total</th><th>Uncertain (atomic units)</th></tr></thead><tbody>${totalRows || '<tr><td colspan="3">No payments recorded.</td></tr>'}</tbody></table><table><thead><tr><th>Observed (UTC)</th><th>Task</th><th>Host</th><th>State</th><th>Counted amount (atomic units)</th><th>Network / asset</th></tr></thead><tbody>${rows}</tbody></table><p>Blocked and explicitly failed payments contribute zero. Taximeter never holds funds, signs a payment, or settles a transaction.</p></body></html>
+`;
+}
+
+// src/ledger/store.ts
+import { mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+import Database from "better-sqlite3";
+import { v7 as v73 } from "uuid";
+import { z as z7 } from "zod";
+
+// migrations/001.sql
+var __default = "CREATE TABLE schema_version (version INTEGER PRIMARY KEY);\nINSERT INTO schema_version VALUES (1);\nCREATE TABLE events (\n  id TEXT PRIMARY KEY,\n  ts TEXT NOT NULL,\n  taskId TEXT,\n  agentId TEXT,\n  host TEXT NOT NULL,\n  status TEXT NOT NULL CHECK (status IN ('observed', 'blocked')),\n  paymentKey TEXT NOT NULL,\n  payload TEXT NOT NULL CHECK (json_valid(payload))\n);\nCREATE INDEX events_ts ON events(ts);\nCREATE INDEX events_task ON events(taskId);\nCREATE INDEX events_agent ON events(agentId);\nCREATE INDEX events_host ON events(host);\nCREATE UNIQUE INDEX events_payment ON events(paymentKey) WHERE status = 'observed';\nCREATE TABLE outcomes (\n  id TEXT PRIMARY KEY,\n  ts TEXT NOT NULL,\n  paymentId TEXT NOT NULL REFERENCES events(id),\n  payload TEXT NOT NULL CHECK (json_valid(payload))\n);\nCREATE INDEX outcomes_payment ON outcomes(paymentId);\nCREATE TABLE diagnostics (\n  id TEXT PRIMARY KEY,\n  ts TEXT NOT NULL,\n  payload TEXT NOT NULL CHECK (json_valid(payload))\n);\nCREATE TRIGGER events_no_update BEFORE UPDATE ON events BEGIN SELECT RAISE(ABORT, 'append-only events'); END;\nCREATE TRIGGER events_no_delete BEFORE DELETE ON events BEGIN SELECT RAISE(ABORT, 'append-only events'); END;\nCREATE TRIGGER outcomes_no_update BEFORE UPDATE ON outcomes BEGIN SELECT RAISE(ABORT, 'append-only outcomes'); END;\nCREATE TRIGGER outcomes_no_delete BEFORE DELETE ON outcomes BEGIN SELECT RAISE(ABORT, 'append-only outcomes'); END;\nCREATE TRIGGER diagnostics_no_update BEFORE UPDATE ON diagnostics BEGIN SELECT RAISE(ABORT, 'append-only diagnostics'); END;\nCREATE TRIGGER diagnostics_no_delete BEFORE DELETE ON diagnostics BEGIN SELECT RAISE(ABORT, 'append-only diagnostics'); END;\n";
+
+// src/ledger/store.ts
+var rowSchema = z7.object({ payload: z7.string() });
+var Ledger = class {
+  database;
+  constructor(input) {
+    const path = z7.string().min(1).parse(input);
+    if (path !== ":memory:") mkdirSync(dirname2(path), { recursive: true, mode: 448 });
+    this.database = new Database(path);
+    try {
+      this.database.pragma("journal_mode = WAL");
+      this.database.pragma("foreign_keys = ON");
+      this.database.pragma("busy_timeout = 5000");
+      this.database.transaction(() => {
+        const table = this.database.prepare(
+          "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'schema_version'"
+        ).get();
+        if (!table) this.database.exec(__default);
+        const version = z7.object({ version: z7.literal(1) }).parse(
+          this.database.prepare("SELECT MAX(version) AS version FROM schema_version").get()
+        );
+        return version.version;
+      }).immediate();
+    } catch (error) {
+      this.database.close();
+      throw error;
+    }
+  }
+  transaction(operation) {
+    return this.database.transaction(operation).immediate();
+  }
+  append(input) {
+    const event = paymentEventSchema.parse(input);
+    return this.database.prepare(
+      "INSERT OR IGNORE INTO events (id, ts, taskId, agentId, host, status, paymentKey, payload) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+    ).run(
+      event.id,
+      event.ts,
+      event.taskId ?? null,
+      event.agentId ?? null,
+      event.host,
+      event.status,
+      event.paymentKey,
+      JSON.stringify(event)
+    ).changes > 0;
+  }
+  appendOutcome(input) {
+    const outcome = outcomeSchema.parse(input);
+    return this.database.prepare("INSERT OR IGNORE INTO outcomes (id, ts, paymentId, payload) VALUES (?, ?, ?, ?)").run(outcome.id, outcome.ts, outcome.paymentId, JSON.stringify(outcome)).changes > 0;
+  }
+  events() {
+    return this.database.prepare("SELECT payload FROM events ORDER BY ts, id").all().map((row) => paymentEventSchema.parse(JSON.parse(rowSchema.parse(row).payload)));
+  }
+  outcomes() {
+    return this.database.prepare("SELECT payload FROM outcomes ORDER BY ts, id").all().map((row) => outcomeSchema.parse(JSON.parse(rowSchema.parse(row).payload)));
+  }
+  view() {
+    return deriveEvents(this.events(), this.outcomes());
+  }
+  diagnose(code, resource, message) {
+    const diagnostic = diagnosticSchema.parse({
+      id: v73(),
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      code,
+      resource,
+      message
+    });
+    this.database.prepare("INSERT INTO diagnostics (id, ts, payload) VALUES (?, ?, ?)").run(diagnostic.id, diagnostic.ts, JSON.stringify(diagnostic));
+  }
+  diagnostics() {
+    return this.database.prepare("SELECT payload FROM diagnostics ORDER BY ts, id").all().map((row) => diagnosticSchema.parse(JSON.parse(rowSchema.parse(row).payload)));
+  }
+  close() {
+    this.database.close();
+  }
+};
+
+// src/proxy/index.ts
+import {
+  createServer,
+  request as httpRequest,
+  ServerResponse
+} from "http";
+import { request as httpsRequest } from "https";
+import { connect, Socket } from "net";
+import { z as z8 } from "zod";
+var incomingHeadersSchema = z8.record(
+  z8.string(),
+  z8.union([z8.string(), z8.array(z8.string()), z8.undefined()])
+);
+var sockets = /* @__PURE__ */ new WeakMap();
+function normalizedHeaders(input) {
+  const result = {};
+  for (const [name, value] of Object.entries(incomingHeadersSchema.parse(input))) {
+    if (value !== void 0)
+      result[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return result;
+}
+function forwardingHeaders(message, host, upgrade = false) {
+  const headers = normalizedHeaders(message.headers);
+  const connectionTokens = (headers.connection ?? "").toLowerCase().split(",").map((value) => value.trim());
+  const remove = /* @__PURE__ */ new Set([
+    "proxy-authorization",
+    "proxy-authenticate",
+    "proxy-connection",
+    "keep-alive",
+    "transfer-encoding",
+    "te",
+    ...!upgrade ? ["connection", "upgrade", ...connectionTokens] : [],
+    ...host ? ["host"] : []
+  ]);
+  const result = [];
+  for (let i = 0; i < message.rawHeaders.length; i += 2) {
+    const name = message.rawHeaders[i];
+    const value = message.rawHeaders[i + 1];
+    if (name && value !== void 0 && !remove.has(name.toLowerCase())) result.push(name, value);
+  }
+  if (host) result.push("Host", host);
+  return result;
+}
+function targetFor(request, config) {
+  const reference = z8.string().min(1).parse(request.url);
+  const absolute = /^https?:\/\//i.test(reference);
+  const url = new URL(
+    httpUrlSchema.parse(
+      absolute ? reference : config.upstream ? reference.startsWith("/") ? `${new URL(config.upstream).origin}${reference}` : new URL(reference, config.upstream).href : ""
+    )
+  );
+  const suffix = absolute ? reference.replace(/^https?:\/\/[^/?#]*/i, "") : reference.startsWith("/") ? reference : `${url.pathname}${url.search}`;
+  const withoutFragment = suffix.split("#", 1)[0] ?? "";
+  const path = z8.string().min(1).parse(withoutFragment.startsWith("/") ? withoutFragment : `/${withoutFragment}`);
+  return { url, path, resource: httpUrlSchema.parse(`${url.origin}${path}`) };
+}
+function wire(request, target) {
+  return {
+    url: target.resource,
+    method: z8.string().parse(request.method),
+    headers: normalizedHeaders(request.headers)
+  };
+}
+function json(response, status, body) {
+  response.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+  response.end(JSON.stringify(body));
+}
+function createProxy(options) {
+  const config = parseConfig(options.config);
+  const meter = new Meter(options.ledger, config);
+  const server = createServer({ requestTimeout: 0 }, (request, response) => {
+    let target;
+    try {
+      target = targetFor(request, config);
+    } catch {
+      json(response, 400, {
+        error: "upstream_required",
+        hint: "Use an HTTP forward-proxy client or start with --upstream https://your-api.example."
+      });
+      request.resume();
+      return;
+    }
+    const input = wire(request, target);
+    const intake = meter.begin(input);
+    if (intake.body) {
+      json(response, 402, intake.body);
+      request.resume();
+      return;
+    }
+    const transport = target.url.protocol === "https:" ? httpsRequest : httpRequest;
+    const outgoing = transport(
+      target.url,
+      {
+        method: request.method,
+        path: target.path,
+        headers: forwardingHeaders(request, target.url.host)
+      },
+      (reply) => {
+        const headers = normalizedHeaders(reply.headers);
+        const status = reply.statusCode ?? 502;
+        const upstream = { status, headers };
+        meter.complete(intake, upstream);
+        const needsBody = status === 402 && !headers["payment-required"];
+        const chunks = [];
+        let length = 0;
+        if (status === 402 && !needsBody) meter.observe(input, upstream);
+        if (needsBody)
+          reply.on("data", (chunk) => {
+            const bytes = z8.instanceof(Buffer).parse(chunk);
+            length += bytes.length;
+            if (length <= 65536) chunks.push(bytes);
+            else chunks.length = 0;
+          });
+        response.writeHead(status, reply.statusMessage, forwardingHeaders(reply));
+        reply.on("end", () => {
+          if (needsBody)
+            meter.observe(input, {
+              ...upstream,
+              body: length <= 65536 ? Buffer.concat(chunks) : void 0
+            });
+          response.addTrailers(reply.trailers);
+          response.end();
+        });
+        reply.on("error", () => response.destroy());
+        reply.on("aborted", () => response.destroy());
+        reply.pipe(response, { end: false });
+      }
+    );
+    outgoing.on("error", () => {
+      meter.complete(intake);
+      if (!response.headersSent) json(response, 502, { error: "upstream_unavailable" });
+      else response.destroy();
+    });
+    request.on("aborted", () => outgoing.destroy());
+    request.on("error", () => outgoing.destroy());
+    request.on("end", () => outgoing.addTrailers(request.trailers));
+    response.on("close", () => {
+      if (!response.writableEnded) outgoing.destroy();
+    });
+    request.pipe(outgoing);
+  });
+  const connections = /* @__PURE__ */ new Set();
+  sockets.set(server, connections);
+  server.on("connection", (socket) => {
+    connections.add(socket);
+    socket.on("close", () => connections.delete(socket));
+  });
+  server.on("connect", (request, client, head) => {
+    try {
+      const address = z8.string().regex(/^(?:\[[0-9a-fA-F:]+\]|[^\s/:?#@]+):[0-9]+$/).parse(request.url);
+      const target = new URL(`http://${address}`);
+      const port = z8.coerce.number().int().min(1).max(65535).parse(target.port || "80");
+      const host = target.hostname.replace(/^\[|\]$/g, "");
+      meter.diagnose(
+        "tls_unmetered",
+        address,
+        "Encrypted CONNECT tunnel forwarded without payment visibility. Use the SDK or explicit upstream mode to meter HTTPS."
+      );
+      const upstream = connect(port, host, () => {
+        client.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+        upstream.write(head);
+        upstream.pipe(client);
+        client.pipe(upstream);
+      });
+      upstream.on("error", () => client.destroy());
+      client.on("error", () => upstream.destroy());
+      client.on("close", () => upstream.destroy());
+      upstream.on("close", () => client.destroy());
+    } catch {
+      client.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    }
+  });
+  server.on("upgrade", (request, client, head) => {
+    try {
+      const target = targetFor(request, config);
+      const input = wire(request, target);
+      const intake = meter.begin(input);
+      if (intake.body) {
+        client.end(
+          `HTTP/1.1 402 Payment Required\r
+Content-Type: application/json\r
+Connection: close\r
+\r
+${JSON.stringify(intake.body)}`
+        );
+        return;
+      }
+      meter.diagnose(
+        "parse_failed",
+        target.resource,
+        "HTTP upgrade forwarded; subsequent stream frames are unmetered."
+      );
+      const outgoing = (target.url.protocol === "https:" ? httpsRequest : httpRequest)(target.url, {
+        method: request.method,
+        path: target.path,
+        headers: forwardingHeaders(request, target.url.host, true)
+      });
+      const handshake = (reply, stream, responseHead) => {
+        meter.complete(intake, {
+          status: reply.statusCode ?? 101,
+          headers: normalizedHeaders(reply.headers)
+        });
+        const headers = forwardingHeaders(reply, void 0, true);
+        let text2 = `HTTP/1.1 ${reply.statusCode} ${reply.statusMessage}\r
+`;
+        for (let i = 0; i < headers.length; i += 2) text2 += `${headers[i]}: ${headers[i + 1]}\r
+`;
+        client.write(`${text2}\r
+`);
+        client.write(responseHead);
+        stream.write(head);
+        stream.pipe(client);
+        client.pipe(stream);
+        stream.on("error", () => client.destroy());
+        client.on("error", () => stream.destroy());
+        client.on("close", () => stream.destroy());
+        stream.on("close", () => client.destroy());
+      };
+      outgoing.on("upgrade", handshake);
+      outgoing.on("response", (reply) => {
+        meter.complete(intake, {
+          status: reply.statusCode ?? 502,
+          headers: normalizedHeaders(reply.headers)
+        });
+        const response = new ServerResponse(request);
+        if (!(client instanceof Socket)) {
+          client.destroy();
+          return;
+        }
+        response.assignSocket(client);
+        response.writeHead(reply.statusCode ?? 502, reply.statusMessage, forwardingHeaders(reply));
+        reply.on("end", () => {
+          response.addTrailers(reply.trailers);
+          response.end();
+        });
+        reply.on("error", () => response.destroy());
+        reply.on("aborted", () => response.destroy());
+        reply.pipe(response, { end: false });
+      });
+      outgoing.on("error", () => {
+        meter.complete(intake);
+        client.destroy();
+      });
+      client.on("close", () => outgoing.destroy());
+      outgoing.end();
+    } catch {
+      client.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    }
+  });
+  return server;
+}
+async function closeProxy(server) {
+  for (const socket of sockets.get(server) ?? []) socket.destroy();
+  await new Promise(
+    (resolve2, reject) => server.close((error) => error ? reject(error) : resolve2())
+  );
+}
+
+export {
+  integerStringSchema,
+  httpUrlSchema,
+  labelSchema,
+  paymentEventSchema,
+  diagnosticSchema,
+  budgetSchema,
+  configPatchSchema,
+  parseConfig,
+  expandPath,
+  portInputSchema,
+  loadConfig,
+  matchesAsset,
+  totalSchema,
+  deriveEvents,
+  countsAsSpend,
+  totals,
+  formatAmount,
+  spentForBudget,
+  evaluate,
+  X402Rail,
+  Meter,
+  toCsv,
+  toJson,
+  toInvoice,
+  Ledger,
+  createProxy,
+  closeProxy
+};