@nanorail/sdk 0.1.0

package/dist/nanorail.js

@@ -0,0 +1,1668 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // ../shared/dist/money.js
+  var MICROS_PER_USD = 1e6;
+  var MICRO_DECIMALS = 6;
+  function toMicros(decimal) {
+    const s = typeof decimal === "number" ? decimal.toString() : decimal.trim();
+    if (!/^-?\d+(\.\d+)?$/.test(s)) {
+      throw new Error(`Invalid money string: "${decimal}"`);
+    }
+    const negative = s.startsWith("-");
+    const unsigned = negative ? s.slice(1) : s;
+    const [whole, frac = ""] = unsigned.split(".");
+    const fracPadded = (frac + "0".repeat(MICRO_DECIMALS)).slice(0, MICRO_DECIMALS);
+    const micros = Number(whole) * MICROS_PER_USD + Number(fracPadded || "0");
+    return negative ? -micros : micros;
+  }
+  function fromMicros(micros) {
+    const negative = micros < 0;
+    const abs = Math.abs(Math.round(micros));
+    const whole = Math.floor(abs / MICROS_PER_USD);
+    const frac = abs % MICROS_PER_USD;
+    let out;
+    if (frac === 0) {
+      out = `${whole}`;
+    } else {
+      const fracStr = frac.toString().padStart(MICRO_DECIMALS, "0").replace(/0+$/, "");
+      out = `${whole}.${fracStr}`;
+    }
+    return negative ? `-${out}` : out;
+  }
+
+  // ../shared/dist/policy.js
+  function evaluatePurchase(policy, ctx) {
+    const { publisherId, chunkType, amountMicros, articleSpentMicros, sessionSpentMicros } = ctx;
+    if (policy.blockedContentTypes.includes(chunkType)) {
+      return block(`${chunkType} content is not allowed`);
+    }
+    if (!policy.allowedContentTypes.includes(chunkType)) {
+      return block(`content type "${chunkType}" is not in the allow-list`);
+    }
+    if (policy.allowedPublishers.length > 0 && !policy.allowedPublishers.includes(publisherId)) {
+      return block(`publisher "${publisherId}" is not allowed`);
+    }
+    const perChunk = toMicros(policy.maxSpendPerChunk);
+    if (amountMicros > perChunk) {
+      return block(`amount ${fromMicros(amountMicros)} exceeds per-chunk limit ${policy.maxSpendPerChunk}`);
+    }
+    const perArticle = toMicros(policy.maxSpendPerArticle);
+    if (articleSpentMicros + amountMicros > perArticle) {
+      return block(`would exceed per-article limit ${policy.maxSpendPerArticle}`);
+    }
+    const sessionBudget = toMicros(policy.sessionBudget);
+    if (sessionSpentMicros + amountMicros > sessionBudget) {
+      return block(`would exceed session budget ${policy.sessionBudget}`);
+    }
+    const manualThreshold = toMicros(policy.requireManualApprovalAbove);
+    const requiresManualApproval = !policy.autoPayEnabled || amountMicros > manualThreshold;
+    return { allowed: true, requiresManualApproval };
+  }
+  function block(reason) {
+    return { allowed: false, requiresManualApproval: false, reason };
+  }
+
+  // ../../node_modules/@noble/ed25519/index.js
+  var ed25519_CURVE = {
+    p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
+    n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
+    h: 8n,
+    a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
+    d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
+    Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
+    Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n
+  };
+  var { p: P, n: N, Gx, Gy, a: _a, d: _d } = ed25519_CURVE;
+  var h = 8n;
+  var L = 32;
+  var L2 = 64;
+  var err = (m = "") => {
+    throw new Error(m);
+  };
+  var isBig = (n) => typeof n === "bigint";
+  var isStr = (s) => typeof s === "string";
+  var isBytes = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+  var abytes = (a, l) => !isBytes(a) || typeof l === "number" && l > 0 && a.length !== l ? err("Uint8Array expected") : a;
+  var u8n = (len) => new Uint8Array(len);
+  var u8fr = (buf) => Uint8Array.from(buf);
+  var padh = (n, pad) => n.toString(16).padStart(pad, "0");
+  var bytesToHex = (b) => Array.from(abytes(b)).map((e) => padh(e, 2)).join("");
+  var C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+  var _ch = (ch) => {
+    if (ch >= C._0 && ch <= C._9)
+      return ch - C._0;
+    if (ch >= C.A && ch <= C.F)
+      return ch - (C.A - 10);
+    if (ch >= C.a && ch <= C.f)
+      return ch - (C.a - 10);
+    return;
+  };
+  var hexToBytes = (hex) => {
+    const e = "hex invalid";
+    if (!isStr(hex))
+      return err(e);
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+      return err(e);
+    const array = u8n(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+      const n1 = _ch(hex.charCodeAt(hi));
+      const n2 = _ch(hex.charCodeAt(hi + 1));
+      if (n1 === void 0 || n2 === void 0)
+        return err(e);
+      array[ai] = n1 * 16 + n2;
+    }
+    return array;
+  };
+  var toU8 = (a, len) => abytes(isStr(a) ? hexToBytes(a) : u8fr(abytes(a)), len);
+  var cr = () => globalThis?.crypto;
+  var subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined");
+  var concatBytes = (...arrs) => {
+    const r = u8n(arrs.reduce((sum, a) => sum + abytes(a).length, 0));
+    let pad = 0;
+    arrs.forEach((a) => {
+      r.set(a, pad);
+      pad += a.length;
+    });
+    return r;
+  };
+  var randomBytes = (len = L) => {
+    const c = cr();
+    return c.getRandomValues(u8n(len));
+  };
+  var big = BigInt;
+  var arange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
+  var M = (a, b = P) => {
+    const r = a % b;
+    return r >= 0n ? r : b + r;
+  };
+  var modN = (a) => M(a, N);
+  var invert = (num, md) => {
+    if (num === 0n || md <= 0n)
+      err("no inverse n=" + num + " mod=" + md);
+    let a = M(num, md), b = md, x = 0n, y = 1n, u = 1n, v = 0n;
+    while (a !== 0n) {
+      const q = b / a, r = b % a;
+      const m = x - u * q, n = y - v * q;
+      b = a, a = r, x = u, y = v, u = m, v = n;
+    }
+    return b === 1n ? M(x, md) : err("no inverse");
+  };
+  var callHash = (name) => {
+    const fn = etc[name];
+    if (typeof fn !== "function")
+      err("hashes." + name + " not set");
+    return fn;
+  };
+  var apoint = (p) => p instanceof Point ? p : err("Point expected");
+  var B256 = 2n ** 256n;
+  var _Point = class _Point {
+    constructor(ex, ey, ez, et) {
+      __publicField(this, "ex");
+      __publicField(this, "ey");
+      __publicField(this, "ez");
+      __publicField(this, "et");
+      const max = B256;
+      this.ex = arange(ex, 0n, max);
+      this.ey = arange(ey, 0n, max);
+      this.ez = arange(ez, 1n, max);
+      this.et = arange(et, 0n, max);
+      Object.freeze(this);
+    }
+    static fromAffine(p) {
+      return new _Point(p.x, p.y, 1n, M(p.x * p.y));
+    }
+    /** RFC8032 5.1.3: Uint8Array to Point. */
+    static fromBytes(hex, zip215 = false) {
+      const d = _d;
+      const normed = u8fr(abytes(hex, L));
+      const lastByte = hex[31];
+      normed[31] = lastByte & ~128;
+      const y = bytesToNumLE(normed);
+      const max = zip215 ? B256 : P;
+      arange(y, 0n, max);
+      const y2 = M(y * y);
+      const u = M(y2 - 1n);
+      const v = M(d * y2 + 1n);
+      let { isValid, value: x } = uvRatio(u, v);
+      if (!isValid)
+        err("bad point: y not sqrt");
+      const isXOdd = (x & 1n) === 1n;
+      const isLastByteOdd = (lastByte & 128) !== 0;
+      if (!zip215 && x === 0n && isLastByteOdd)
+        err("bad point: x==0, isLastByteOdd");
+      if (isLastByteOdd !== isXOdd)
+        x = M(-x);
+      return new _Point(x, y, 1n, M(x * y));
+    }
+    /** Checks if the point is valid and on-curve. */
+    assertValidity() {
+      const a = _a;
+      const d = _d;
+      const p = this;
+      if (p.is0())
+        throw new Error("bad point: ZERO");
+      const { ex: X, ey: Y, ez: Z, et: T } = p;
+      const X2 = M(X * X);
+      const Y2 = M(Y * Y);
+      const Z2 = M(Z * Z);
+      const Z4 = M(Z2 * Z2);
+      const aX2 = M(X2 * a);
+      const left = M(Z2 * M(aX2 + Y2));
+      const right = M(Z4 + M(d * M(X2 * Y2)));
+      if (left !== right)
+        throw new Error("bad point: equation left != right (1)");
+      const XY = M(X * Y);
+      const ZT = M(Z * T);
+      if (XY !== ZT)
+        throw new Error("bad point: equation left != right (2)");
+      return this;
+    }
+    /** Equality check: compare points P&Q. */
+    equals(other) {
+      const { ex: X1, ey: Y1, ez: Z1 } = this;
+      const { ex: X2, ey: Y2, ez: Z2 } = apoint(other);
+      const X1Z2 = M(X1 * Z2);
+      const X2Z1 = M(X2 * Z1);
+      const Y1Z2 = M(Y1 * Z2);
+      const Y2Z1 = M(Y2 * Z1);
+      return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+    }
+    is0() {
+      return this.equals(I);
+    }
+    /** Flip point over y coordinate. */
+    negate() {
+      return new _Point(M(-this.ex), this.ey, this.ez, M(-this.et));
+    }
+    /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
+    double() {
+      const { ex: X1, ey: Y1, ez: Z1 } = this;
+      const a = _a;
+      const A = M(X1 * X1);
+      const B = M(Y1 * Y1);
+      const C2 = M(2n * M(Z1 * Z1));
+      const D = M(a * A);
+      const x1y1 = X1 + Y1;
+      const E = M(M(x1y1 * x1y1) - A - B);
+      const G2 = D + B;
+      const F = G2 - C2;
+      const H = D - B;
+      const X3 = M(E * F);
+      const Y3 = M(G2 * H);
+      const T3 = M(E * H);
+      const Z3 = M(F * G2);
+      return new _Point(X3, Y3, Z3, T3);
+    }
+    /** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
+    add(other) {
+      const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
+      const { ex: X2, ey: Y2, ez: Z2, et: T2 } = apoint(other);
+      const a = _a;
+      const d = _d;
+      const A = M(X1 * X2);
+      const B = M(Y1 * Y2);
+      const C2 = M(T1 * d * T2);
+      const D = M(Z1 * Z2);
+      const E = M((X1 + Y1) * (X2 + Y2) - A - B);
+      const F = M(D - C2);
+      const G2 = M(D + C2);
+      const H = M(B - a * A);
+      const X3 = M(E * F);
+      const Y3 = M(G2 * H);
+      const T3 = M(E * H);
+      const Z3 = M(F * G2);
+      return new _Point(X3, Y3, Z3, T3);
+    }
+    /**
+     * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+     * Uses {@link wNAF} for base point.
+     * Uses fake point to mitigate side-channel leakage.
+     * @param n scalar by which point is multiplied
+     * @param safe safe mode guards against timing attacks; unsafe mode is faster
+     */
+    multiply(n, safe = true) {
+      if (!safe && (n === 0n || this.is0()))
+        return I;
+      arange(n, 1n, N);
+      if (n === 1n)
+        return this;
+      if (this.equals(G))
+        return wNAF(n).p;
+      let p = I;
+      let f = G;
+      for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
+        if (n & 1n)
+          p = p.add(d);
+        else if (safe)
+          f = f.add(d);
+      }
+      return p;
+    }
+    /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+    toAffine() {
+      const { ex: x, ey: y, ez: z } = this;
+      if (this.equals(I))
+        return { x: 0n, y: 1n };
+      const iz = invert(z, P);
+      if (M(z * iz) !== 1n)
+        err("invalid inverse");
+      return { x: M(x * iz), y: M(y * iz) };
+    }
+    toBytes() {
+      const { x, y } = this.assertValidity().toAffine();
+      const b = numTo32bLE(y);
+      b[31] |= x & 1n ? 128 : 0;
+      return b;
+    }
+    toHex() {
+      return bytesToHex(this.toBytes());
+    }
+    // encode to hex string
+    clearCofactor() {
+      return this.multiply(big(h), false);
+    }
+    isSmallOrder() {
+      return this.clearCofactor().is0();
+    }
+    isTorsionFree() {
+      let p = this.multiply(N / 2n, false).double();
+      if (N % 2n)
+        p = p.add(this);
+      return p.is0();
+    }
+    static fromHex(hex, zip215) {
+      return _Point.fromBytes(toU8(hex), zip215);
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    toRawBytes() {
+      return this.toBytes();
+    }
+  };
+  __publicField(_Point, "BASE");
+  __publicField(_Point, "ZERO");
+  var Point = _Point;
+  var G = new Point(Gx, Gy, 1n, M(Gx * Gy));
+  var I = new Point(0n, 1n, 1n, 0n);
+  Point.BASE = G;
+  Point.ZERO = I;
+  var numTo32bLE = (num) => hexToBytes(padh(arange(num, 0n, B256), L2)).reverse();
+  var bytesToNumLE = (b) => big("0x" + bytesToHex(u8fr(abytes(b)).reverse()));
+  var pow2 = (x, power) => {
+    let r = x;
+    while (power-- > 0n) {
+      r *= r;
+      r %= P;
+    }
+    return r;
+  };
+  var pow_2_252_3 = (x) => {
+    const x2 = x * x % P;
+    const b2 = x2 * x % P;
+    const b4 = pow2(b2, 2n) * b2 % P;
+    const b5 = pow2(b4, 1n) * x % P;
+    const b10 = pow2(b5, 5n) * b5 % P;
+    const b20 = pow2(b10, 10n) * b10 % P;
+    const b40 = pow2(b20, 20n) * b20 % P;
+    const b80 = pow2(b40, 40n) * b40 % P;
+    const b160 = pow2(b80, 80n) * b80 % P;
+    const b240 = pow2(b160, 80n) * b80 % P;
+    const b250 = pow2(b240, 10n) * b10 % P;
+    const pow_p_5_8 = pow2(b250, 2n) * x % P;
+    return { pow_p_5_8, b2 };
+  };
+  var RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
+  var uvRatio = (u, v) => {
+    const v3 = M(v * v * v);
+    const v7 = M(v3 * v3 * v);
+    const pow = pow_2_252_3(u * v7).pow_p_5_8;
+    let x = M(u * v3 * pow);
+    const vx2 = M(v * x * x);
+    const root1 = x;
+    const root2 = M(x * RM1);
+    const useRoot1 = vx2 === u;
+    const useRoot2 = vx2 === M(-u);
+    const noRoot = vx2 === M(-u * RM1);
+    if (useRoot1)
+      x = root1;
+    if (useRoot2 || noRoot)
+      x = root2;
+    if ((M(x) & 1n) === 1n)
+      x = M(-x);
+    return { isValid: useRoot1 || useRoot2, value: x };
+  };
+  var modL_LE = (hash) => modN(bytesToNumLE(hash));
+  var sha512a = (...m) => etc.sha512Async(...m);
+  var sha512s = (...m) => callHash("sha512Sync")(...m);
+  var hash2extK = (hashed) => {
+    const head = hashed.slice(0, L);
+    head[0] &= 248;
+    head[31] &= 127;
+    head[31] |= 64;
+    const prefix = hashed.slice(L, L2);
+    const scalar = modL_LE(head);
+    const point = G.multiply(scalar);
+    const pointBytes = point.toBytes();
+    return { head, prefix, scalar, point, pointBytes };
+  };
+  var getExtendedPublicKeyAsync = (priv) => sha512a(toU8(priv, L)).then(hash2extK);
+  var getExtendedPublicKey = (priv) => hash2extK(sha512s(toU8(priv, L)));
+  var getPublicKeyAsync = (priv) => getExtendedPublicKeyAsync(priv).then((p) => p.pointBytes);
+  var hashFinishA = (res) => sha512a(res.hashable).then(res.finish);
+  var _sign = (e, rBytes, msg) => {
+    const { pointBytes: P2, scalar: s } = e;
+    const r = modL_LE(rBytes);
+    const R = G.multiply(r).toBytes();
+    const hashable = concatBytes(R, P2, msg);
+    const finish = (hashed) => {
+      const S = modN(r + modL_LE(hashed) * s);
+      return abytes(concatBytes(R, numTo32bLE(S)), L2);
+    };
+    return { hashable, finish };
+  };
+  var signAsync = async (msg, privKey) => {
+    const m = toU8(msg);
+    const e = await getExtendedPublicKeyAsync(privKey);
+    const rBytes = await sha512a(e.prefix, m);
+    return hashFinishA(_sign(e, rBytes, m));
+  };
+  var etc = {
+    sha512Async: async (...messages) => {
+      const s = subtle();
+      const m = concatBytes(...messages);
+      return u8n(await s.digest("SHA-512", m.buffer));
+    },
+    sha512Sync: void 0,
+    bytesToHex,
+    hexToBytes,
+    concatBytes,
+    mod: M,
+    invert,
+    randomBytes
+  };
+  var utils = {
+    getExtendedPublicKeyAsync,
+    getExtendedPublicKey,
+    randomPrivateKey: () => randomBytes(L),
+    precompute: (w = 8, p = G) => {
+      p.multiply(3n);
+      w;
+      return p;
+    }
+    // no-op
+  };
+  var W = 8;
+  var scalarBits = 256;
+  var pwindows = Math.ceil(scalarBits / W) + 1;
+  var pwindowSize = 2 ** (W - 1);
+  var precompute = () => {
+    const points = [];
+    let p = G;
+    let b = p;
+    for (let w = 0; w < pwindows; w++) {
+      b = p;
+      points.push(b);
+      for (let i = 1; i < pwindowSize; i++) {
+        b = b.add(p);
+        points.push(b);
+      }
+      p = b.double();
+    }
+    return points;
+  };
+  var Gpows = void 0;
+  var ctneg = (cnd, p) => {
+    const n = p.negate();
+    return cnd ? n : p;
+  };
+  var wNAF = (n) => {
+    const comp = Gpows || (Gpows = precompute());
+    let p = I;
+    let f = G;
+    const pow_2_w = 2 ** W;
+    const maxNum = pow_2_w;
+    const mask = big(pow_2_w - 1);
+    const shiftBy = big(W);
+    for (let w = 0; w < pwindows; w++) {
+      let wbits = Number(n & mask);
+      n >>= shiftBy;
+      if (wbits > pwindowSize) {
+        wbits -= maxNum;
+        n += 1n;
+      }
+      const off = w * pwindowSize;
+      const offF = off;
+      const offP = off + Math.abs(wbits) - 1;
+      const isEven = w % 2 !== 0;
+      const isNeg = wbits < 0;
+      if (wbits === 0) {
+        f = f.add(ctneg(isEven, comp[offF]));
+      } else {
+        p = p.add(ctneg(isNeg, comp[offP]));
+      }
+    }
+    return { p, f };
+  };
+
+  // ../shared/dist/voucher.js
+  var { bytesToHex: bytesToHex2, hexToBytes: hexToBytes2 } = etc;
+  function canonicalVoucherBytes(p) {
+    const canonical = [
+      "nanorail-voucher/v1",
+      p.sessionId,
+      p.challengeId,
+      p.articleId,
+      p.publisherId,
+      p.chunkId,
+      p.chunkType,
+      p.amount,
+      p.currency,
+      p.recipient,
+      p.nonce,
+      String(p.expiresAt)
+    ].join("\n");
+    return new TextEncoder().encode(canonical);
+  }
+  function generatePrivateKeyHex() {
+    return bytesToHex2(utils.randomPrivateKey());
+  }
+  async function getPublicKeyHex(privateKeyHex) {
+    const pub = await getPublicKeyAsync(hexToBytes2(privateKeyHex));
+    return bytesToHex2(pub);
+  }
+  async function signVoucher(payload, privateKeyHex) {
+    const msg = canonicalVoucherBytes(payload);
+    const sig = await signAsync(msg, hexToBytes2(privateKeyHex));
+    const publicKey = await getPublicKeyHex(privateKeyHex);
+    return { payload, signature: bytesToHex2(sig), publicKey };
+  }
+
+  // ../shared/dist/content.js
+  var PUBLISHER_ID = "agentic-chronicle";
+  var DEFAULT_POLICY = {
+    autoPayEnabled: true,
+    maxSpendPerArticle: "0.05",
+    maxSpendPerChunk: "0.025",
+    allowedPublishers: [PUBLISHER_ID],
+    allowedContentTypes: ["text", "chart", "citation_pack"],
+    blockedContentTypes: ["video"],
+    requireManualApprovalAbove: "0.025",
+    sessionBudget: "1.00",
+    sessionExpiryMinutes: 10
+  };
+  var DEFAULT_SESSION_BUDGET = DEFAULT_POLICY.sessionBudget;
+
+  // src/events.ts
+  function eventName(label) {
+    return `nanorail:${label.replace(/\s+/g, "-")}`;
+  }
+  var NanoRailEvents = class {
+    constructor(target) {
+      this.target = target;
+    }
+    emit(detail) {
+      const full = { ...detail, at: Date.now() };
+      this.target.dispatchEvent(new CustomEvent("nanorail:lifecycle", { detail: full }));
+      this.target.dispatchEvent(new CustomEvent(eventName(detail.label), { detail: full }));
+    }
+    on(label, handler) {
+      const name = label === "lifecycle" ? "nanorail:lifecycle" : eventName(label);
+      const wrapped = (e) => handler(e.detail);
+      this.target.addEventListener(name, wrapped);
+      return () => this.target.removeEventListener(name, wrapped);
+    }
+  };
+
+  // src/client.ts
+  var NanoRailClient = class {
+    constructor(config = {}) {
+      __publicField(this, "events");
+      __publicField(this, "gatewayUrl");
+      __publicField(this, "fetchImpl");
+      __publicField(this, "policy");
+      __publicField(this, "defaultActor");
+      __publicField(this, "privateKeyHex");
+      __publicField(this, "publicKeyHex");
+      __publicField(this, "session");
+      __publicField(this, "spentMicros", 0);
+      __publicField(this, "receipts", []);
+      __publicField(this, "blocked", []);
+      /** Chunk ids the user has manually approved (for amounts above the threshold). */
+      __publicField(this, "approvals", /* @__PURE__ */ new Set());
+      __publicField(this, "sessionPromise");
+      __publicField(this, "settlementWatch");
+      __publicField(this, "lastBatchCount", 0);
+      this.gatewayUrl = (config.gatewayUrl ?? "http://localhost:4020").replace(/\/$/, "");
+      this.fetchImpl = config.fetchImpl ?? globalThis.fetch.bind(globalThis);
+      this.policy = config.policy ?? DEFAULT_POLICY;
+      this.defaultActor = config.actor ?? "human";
+      const target = config.eventTarget ?? (typeof document !== "undefined" ? document : new EventTarget());
+      this.events = new NanoRailEvents(target);
+    }
+    getPolicy() {
+      return this.policy;
+    }
+    /** Fetch the agent-readable manifest for an article. */
+    async getManifest(articleId) {
+      const res = await this.fetchImpl(`${this.gatewayUrl}/api/articles/${articleId}/manifest`);
+      const { manifest } = await res.json();
+      return manifest;
+    }
+    /**
+     * Ask the publisher's discovery endpoint "what paid content is about X?".
+     * Returns ranked, publicly-safe matches (no gated content). This is a
+     * recommendation layer — the publisher is as trustworthy as the matches.
+     */
+    async discover(articleId, query, actor = this.defaultActor) {
+      const res = await this.fetchImpl(`${this.gatewayUrl}/api/articles/${articleId}/discover`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ query, actor })
+      });
+      const body = await res.json().catch(() => ({ matches: [] }));
+      return body.matches ?? [];
+    }
+    /** Register an SDK-generated manifest so agents can discover this article. */
+    async registerManifest(manifest) {
+      const res = await this.fetchImpl(`${this.gatewayUrl}/api/articles/${manifest.articleId}/manifest`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ manifest })
+      });
+      return await res.json().catch(() => ({ ok: false }));
+    }
+    /** Open a funded session once; concurrent callers share the same promise. */
+    async ensureSession() {
+      if (this.session) return this.session;
+      if (this.sessionPromise) return this.sessionPromise;
+      this.sessionPromise = this.openSession();
+      return this.sessionPromise;
+    }
+    async openSession() {
+      this.privateKeyHex = generatePrivateKeyHex();
+      this.publicKeyHex = await getPublicKeyHex(this.privateKeyHex);
+      const res = await this.fetchImpl(`${this.gatewayUrl}/api/session/open`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ payerPublicKey: this.publicKeyHex, policy: this.policy })
+      });
+      const { session } = await res.json();
+      this.session = session;
+      this.events.emit({
+        label: "session opened",
+        detail: `funded session ${session.sessionId} \xB7 budget ${this.policy.sessionBudget} USD`
+      });
+      return session;
+    }
+    /** Pure client-side policy check using locally-tracked spend. */
+    evaluate(chunk) {
+      return evaluatePurchase(this.policy, {
+        publisherId: chunk.publisherId,
+        chunkType: chunk.type,
+        amountMicros: toMicros(chunk.price),
+        articleSpentMicros: this.spentMicros,
+        sessionSpentMicros: this.spentMicros
+      });
+    }
+    /**
+     * Full unlock flow for one chunk:
+     *  1. evaluate client policy — if blocked, record + emit `policy blocked`, never sign.
+     *  2. if manual approval needed and not granted, return needsApproval.
+     *  3. request challenge, sign voucher, POST unlock.
+     *  4. on success record receipt + reveal content.
+     */
+    async unlock(chunk, opts = {}) {
+      const actor = opts.actor ?? this.defaultActor;
+      const decision = this.evaluate(chunk);
+      if (!decision.allowed) {
+        const reason = decision.reason ?? "blocked by policy";
+        await this.recordClientBlock(chunk, reason, actor);
+        return { ok: false, blocked: true, reason };
+      }
+      if (decision.requiresManualApproval && !opts.approved && !this.approvals.has(chunk.chunkId)) {
+        return { ok: false, needsApproval: true, reason: `manual approval required above ${this.policy.requireManualApprovalAbove} USD` };
+      }
+      if (opts.approved) this.approvals.add(chunk.chunkId);
+      const session = await this.ensureSession();
+      const challenge = await this.requestChallenge(chunk, session.sessionId, actor);
+      this.events.emit({
+        label: "chunk challenge issued",
+        chunkId: chunk.chunkId,
+        chunkType: chunk.type,
+        amount: chunk.price,
+        detail: `challenge ${challenge.challengeId}`,
+        actor
+      });
+      const payload = {
+        sessionId: challenge.sessionId,
+        challengeId: challenge.challengeId,
+        articleId: challenge.articleId,
+        publisherId: challenge.publisherId,
+        chunkId: challenge.chunkId,
+        chunkType: challenge.chunkType,
+        amount: challenge.amount,
+        currency: challenge.currency,
+        recipient: challenge.recipient,
+        nonce: challenge.nonce,
+        expiresAt: challenge.expiresAt
+      };
+      const voucher = await signVoucher(payload, this.privateKeyHex);
+      this.events.emit({
+        label: "voucher signed",
+        chunkId: chunk.chunkId,
+        chunkType: chunk.type,
+        amount: chunk.price,
+        detail: `voucher signed for ${chunk.title}`,
+        actor
+      });
+      const res = await this.fetchImpl(`${this.gatewayUrl}/api/chunks/${chunk.chunkId}/unlock`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ voucher, actor, viaDiscovery: opts.viaDiscovery === true })
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        const reason = body.error ?? `unlock failed (${res.status})`;
+        this.blocked.push({ chunkId: chunk.chunkId, reason, at: Date.now() });
+        this.events.emit({ label: "policy blocked", chunkId: chunk.chunkId, chunkType: chunk.type, reason, detail: reason, actor });
+        return { ok: false, blocked: true, reason };
+      }
+      const out = await res.json();
+      this.receipts.push(out.receipt);
+      this.spentMicros = toMicros(out.session.spent);
+      if (this.session) this.session.spentMicros = this.spentMicros;
+      this.events.emit({
+        label: "receipt returned",
+        chunkId: chunk.chunkId,
+        chunkType: chunk.type,
+        amount: chunk.price,
+        receiptId: out.receipt.receiptId,
+        detail: `receipt ${out.receipt.receiptId}`,
+        actor
+      });
+      return { ok: true, content: out.content, title: out.title, receipt: out.receipt };
+    }
+    async requestChallenge(chunk, sessionId, actor = this.defaultActor) {
+      const res = await this.fetchImpl(`${this.gatewayUrl}/api/chunks/${chunk.chunkId}/challenge`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ sessionId, actor })
+      });
+      const { challenge } = await res.json();
+      return challenge;
+    }
+    /** Record a client-side policy block (no voucher signed) and emit the event. */
+    async recordClientBlock(chunk, reason, actor = this.defaultActor) {
+      this.blocked.push({ chunkId: chunk.chunkId, reason, at: Date.now() });
+      this.events.emit({
+        label: "policy blocked",
+        chunkId: chunk.chunkId,
+        chunkType: chunk.type,
+        amount: chunk.price,
+        reason,
+        detail: `blocked before signing: ${reason}`,
+        actor
+      });
+      try {
+        await this.fetchImpl(`${this.gatewayUrl}/api/policy/blocked`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            sessionId: this.session?.sessionId,
+            articleId: chunk.articleId,
+            publisherId: chunk.publisherId,
+            chunkId: chunk.chunkId,
+            chunkType: chunk.type,
+            amount: chunk.price,
+            reason,
+            actor
+          })
+        });
+      } catch {
+      }
+    }
+    /** Trigger the server-side forced-rejection demo path for a chunk. */
+    async forceServerRejection(chunk, actor = this.defaultActor) {
+      const session = await this.ensureSession();
+      const res = await this.fetchImpl(`${this.gatewayUrl}/api/policy/attempt-rejected`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ sessionId: session.sessionId, chunkId: chunk.chunkId, actor })
+      });
+      const body = await res.json().catch(() => ({}));
+      return { rejected: !!body.rejected, reason: body.reason };
+    }
+    /**
+     * Unlock the premium snippet via the REAL Tempo MPP path (HTTP 402 → payment →
+     * receipt). This is settled by the gateway's PaymentProvider (real Tempo testnet
+     * when configured, offline fallback otherwise) and is intentionally separate from
+     * the mock Ed25519 voucher flow. Emits a `Real Tempo MPP unlock` event on success.
+     */
+    async unlockTempoSnippet() {
+      const res = await this.fetchImpl(`${this.gatewayUrl}/api/premium/tempo-snippet`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({})
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) return { ok: false, reason: body.error ?? `tempo unlock failed (${res.status})` };
+      this.events.emit({
+        label: "Real Tempo MPP unlock",
+        amount: void 0,
+        detail: body.error ? `real-network failed \u2192 offline \xB7 ${body.error}` : `tempo snippet \xB7 ${body.mode} \xB7 ${body.settlementRef ?? ""}`.trim(),
+        actor: "agent"
+      });
+      return {
+        ok: true,
+        snippet: body.snippet,
+        receipt: body.receipt,
+        settlementRef: body.settlementRef,
+        mode: body.mode,
+        error: body.error,
+        recipient: body.recipient,
+        explorerUrl: body.explorerUrl
+      };
+    }
+    /** Poll settlements so the widget timeline shows `batch settled` events. */
+    startSettlementWatch(intervalMs = 2e3) {
+      if (this.settlementWatch) return;
+      this.settlementWatch = setInterval(async () => {
+        try {
+          const res = await this.fetchImpl(`${this.gatewayUrl}/api/settlements`);
+          const { batches } = await res.json();
+          if (batches.length > this.lastBatchCount) {
+            const fresh = batches.slice(0, batches.length - this.lastBatchCount);
+            for (const b of fresh) {
+              this.events.emit({ label: "batch settled", batchId: b.batchId, detail: `settlement batch ${b.batchId}` });
+            }
+            this.lastBatchCount = batches.length;
+          }
+        } catch {
+        }
+      }, intervalMs);
+    }
+    stopSettlementWatch() {
+      if (this.settlementWatch) clearInterval(this.settlementWatch);
+      this.settlementWatch = void 0;
+    }
+    /** Snapshot of state for the widget. */
+    snapshot() {
+      return {
+        sessionId: this.session?.sessionId,
+        publicKey: this.publicKeyHex,
+        policy: this.policy,
+        budget: this.policy.sessionBudget,
+        spent: this.spentMicros,
+        receipts: this.receipts,
+        blocked: this.blocked,
+        approvalsPending: this.policy.requireManualApprovalAbove
+      };
+    }
+  };
+
+  // src/widget.ts
+  var nrMark = (fill, size = 15) => `<svg width="${size}" height="${size}" viewBox="0 0 64 64" style="vertical-align:-3px;flex:none"><g fill="${fill}"><circle cx="14" cy="12" r="4"/><circle cx="14" cy="22" r="4"/><circle cx="14" cy="32" r="4"/><circle cx="14" cy="42" r="4"/><circle cx="14" cy="52" r="4"/><circle cx="54" cy="12" r="4"/><circle cx="54" cy="22" r="4"/><circle cx="54" cy="42" r="4"/><circle cx="54" cy="52" r="4"/><circle cx="24" cy="22" r="4"/><circle cx="34" cy="32" r="4"/><circle cx="44" cy="42" r="4"/></g></svg>`;
+  var LABEL_DOT = {
+    "discovery query": "#e879f9",
+    "discovery match": "#d946ef",
+    "session opened": "#8b5cf6",
+    "chunk challenge issued": "#0ea5e9",
+    "voucher signed": "#f59e0b",
+    "receipt returned": "#22c55e",
+    "policy blocked": "#ef4444",
+    "batch settled": "#FFC247",
+    "Real Tempo MPP unlock": "#E2A12F"
+  };
+  var TYPE_PLURAL = {
+    text: "Articles",
+    chart: "Charts",
+    citation_pack: "Citations",
+    video: "Video",
+    audio: "Audio",
+    image: "Images",
+    download: "Downloads"
+  };
+  var typePlural = (t) => TYPE_PLURAL[t] ?? t.replace(/_/g, " ").replace(/^\w/, (c) => c.toUpperCase());
+  var TYPE_NOUN = {
+    text: "an article",
+    chart: "a chart",
+    citation_pack: "a citation pack",
+    video: "a video",
+    audio: "audio",
+    image: "an image"
+  };
+  var typeNoun = (t) => t && TYPE_NOUN[t] || "content";
+  var esc = (s) => s.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
+  function blockReason(e) {
+    const raw = e.reason ?? e.detail ?? "not allowed by your policy";
+    return raw.replace(/^(no voucher signed|server rejected|blocked by policy):\s*/i, "");
+  }
+  var NanoRailWidget = class {
+    constructor(client) {
+      this.client = client;
+      __publicField(this, "root");
+      /** Human-readable recent purchases / blocks. */
+      __publicField(this, "activity", []);
+      /** Raw protocol events for the Technical details drawer. */
+      __publicField(this, "tech", []);
+      __publicField(this, "collapsed", false);
+      __publicField(this, "showTech", false);
+      injectStyles();
+      this.root = document.createElement("div");
+      this.root.id = "nanorail-widget";
+      document.body.appendChild(this.root);
+      this.client.events.on("lifecycle", (e) => {
+        this.tech.unshift(e);
+        this.tech = this.tech.slice(0, 16);
+        if (e.label === "receipt returned" || e.label === "policy blocked") {
+          this.activity.unshift(e);
+          this.activity = this.activity.slice(0, 5);
+        }
+        this.render();
+      });
+      this.render();
+    }
+    toggle() {
+      this.collapsed = !this.collapsed;
+      this.render();
+    }
+    render() {
+      const s = this.client.snapshot();
+      const p = s.policy;
+      const budgetMicros = toMicros(s.budget);
+      const remaining = fromMicros(Math.max(0, budgetMicros - s.spent));
+      const pct2 = Math.min(100, Math.round(s.spent / Math.max(1, budgetMicros) * 100));
+      if (this.collapsed) {
+        this.root.className = "nr-widget nr-collapsed";
+        this.root.innerHTML = `<button class="nr-w-fab" title="Agent Wallet">${nrMark("#0A0A0A", 14)} Agent Wallet \xB7 $${remaining}</button>`;
+        this.root.querySelector(".nr-w-fab").onclick = () => this.toggle();
+        return;
+      }
+      const allowed = p.allowedContentTypes.map((t) => `<span class="nr-perm ok">\u2713 ${esc(typePlural(t))}</span>`).join("");
+      const blocked = p.blockedContentTypes.length ? p.blockedContentTypes.map((t) => `<span class="nr-perm no">\u2717 ${esc(typePlural(t))}</span>`).join("") : '<span class="nr-perm muted">none</span>';
+      const publishers = p.allowedPublishers.length ? "Verified only" : "Any";
+      const activityRows = this.activity.length ? this.activity.map((e) => {
+        if (e.label === "receipt returned") {
+          const who = e.actor === "agent" ? "Agent" : "You";
+          return `<div class="nr-act ok"><span class="nr-act-dot"></span><span class="nr-act-txt">${who} purchased ${esc(typeNoun(e.chunkType))}</span><span class="nr-act-amt">$${esc(e.amount ?? "0")}</span></div>`;
+        }
+        return `<div class="nr-act no"><span class="nr-act-dot"></span><span class="nr-act-txt">Blocked \u2014 ${esc(blockReason(e))}</span></div>`;
+      }).join("") : '<div class="nr-w-empty">No purchases yet \u2014 scroll the page or run Agent Mode.</div>';
+      const techRows = this.tech.length ? this.tech.map(
+        (e) => `<div class="nr-tl-row"><i style="background:${LABEL_DOT[e.label]}"></i><span class="nr-tl-label">${e.label}</span>${e.amount ? `<span class="nr-tl-amt">$${e.amount}</span>` : ""}</div>`
+      ).join("") : '<div class="nr-w-empty">No protocol events yet.</div>';
+      this.root.className = "nr-widget";
+      this.root.innerHTML = `
+      <div class="nr-w-head">
+        <span class="nr-w-brand">${nrMark("#FFC247", 16)} Agent Wallet</span>
+        <button class="nr-w-min" title="Minimize">\u2013</button>
+      </div>
+
+      <div class="nr-w-budget">
+        <div class="nr-w-budget-top"><span class="nr-w-budget-label">Remaining today</span><span class="nr-w-budget-val">$${remaining}</span></div>
+        <div class="nr-w-bar"><i style="width:${pct2}%"></i></div>
+        <div class="nr-w-budget-foot"><span>Daily budget $${esc(s.budget)}</span><span>Spent $${fromMicros(s.spent)}</span></div>
+      </div>
+
+      <div class="nr-w-sec">
+        <div class="nr-w-sec-h">Permissions <em>\u2014 what your agent may buy</em></div>
+        <div class="nr-w-perms">
+          <div class="nr-perm-col"><div class="nr-perm-lab">Allowed</div>${allowed}</div>
+          <div class="nr-perm-col"><div class="nr-perm-lab">Blocked</div>${blocked}</div>
+        </div>
+      </div>
+
+      <div class="nr-w-sec">
+        <div class="nr-w-sec-h">Purchase rules</div>
+        <div class="nr-w-row"><span>Auto-pay</span><strong class="${p.autoPayEnabled ? "nr-on" : "nr-off"}">${p.autoPayEnabled ? "ON" : "OFF"}</strong></div>
+        <div class="nr-w-row nr-muted"><span>Maximum purchase</span><span class="nr-mono">$${esc(p.maxSpendPerChunk)}</span></div>
+        <div class="nr-w-row nr-muted"><span>Manual approval above</span><span class="nr-mono">$${esc(p.requireManualApprovalAbove)}</span></div>
+        <div class="nr-w-row nr-muted"><span>Publishers</span><span>${publishers}</span></div>
+      </div>
+
+      <div class="nr-w-stats">
+        <div class="nr-stat"><b>${s.receipts.length}</b><span>receipts</span></div>
+        <div class="nr-stat"><b>${s.blocked.length}</b><span>blocked</span></div>
+        <div class="nr-stat"><b>$${fromMicros(s.spent)}</b><span>spent</span></div>
+      </div>
+
+      <div class="nr-w-sec">
+        <div class="nr-w-sec-h">Recent purchases</div>
+        ${activityRows}
+      </div>
+
+      <div class="nr-w-tech">
+        <button class="nr-w-tech-toggle">${this.showTech ? "\u25BE" : "\u25B8"} Technical details <em>(MPP protocol)</em></button>
+        ${this.showTech ? `<div class="nr-w-tech-body">
+                 <div class="nr-w-row nr-muted"><span>Session</span><span class="nr-mono">${s.sessionId ? esc(s.sessionId.slice(0, 14)) + "\u2026" : "none"}</span></div>
+                 ${techRows}
+               </div>` : ""}
+      </div>`;
+      this.root.querySelector(".nr-w-min").onclick = () => this.toggle();
+      this.root.querySelector(".nr-w-tech-toggle").onclick = () => {
+        this.showTech = !this.showTech;
+        this.render();
+      };
+    }
+  };
+  var stylesInjected = false;
+  function injectStyles() {
+    if (stylesInjected || typeof document === "undefined") return;
+    stylesInjected = true;
+    const css = `
+  #nanorail-widget{position:fixed;right:20px;bottom:20px;width:312px;max-height:calc(100vh - 40px);overflow:auto;z-index:99999;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;font-size:12px;color:#EDEDED;background:#0E0E0E;border:1px solid #1E1E1E;border-radius:14px;box-shadow:0 12px 40px rgba(0,0,0,.55)}
+  #nanorail-widget.nr-collapsed{width:auto;overflow:visible;background:none;border:none;box-shadow:none}
+  .nr-w-fab{display:flex;align-items:center;gap:7px;background:#FFC247;color:#0A0A0A;border:none;border-radius:999px;padding:10px 16px;font-weight:800;cursor:pointer;box-shadow:0 8px 24px rgba(255,194,71,.45)}
+  .nr-w-head{display:flex;align-items:center;gap:8px;padding:11px 13px;background:#161616;border-bottom:1px solid #1E1E1E;position:sticky;top:0}
+  .nr-w-brand{display:flex;align-items:center;gap:7px;font-weight:800;font-size:14px;color:#F2E2BE}
+  .nr-w-min{margin-left:auto;background:none;border:none;color:#8A8A8A;cursor:pointer;font-size:18px;line-height:1}
+  /* Section 1 \u2014 budget, most prominent */
+  .nr-w-budget{padding:14px 14px 12px;border-bottom:1px solid #1A1A1A;background:linear-gradient(180deg,#121212,#0E0E0E)}
+  .nr-w-budget-top{display:flex;justify-content:space-between;align-items:baseline}
+  .nr-w-budget-label{color:#8A8A8A;font-size:11px;text-transform:uppercase;letter-spacing:.06em}
+  .nr-w-budget-val{font-family:ui-monospace,monospace;font-size:28px;font-weight:800;color:#FFC247}
+  .nr-w-bar{height:7px;background:#1E1E1E;border-radius:4px;overflow:hidden;margin:9px 0 7px}
+  .nr-w-bar i{display:block;height:100%;background:linear-gradient(90deg,#FFC247,#E2A12F)}
+  .nr-w-budget-foot{display:flex;justify-content:space-between;color:#8A8A8A;font-size:11px}
+  /* generic section */
+  .nr-w-sec{padding:11px 14px;border-bottom:1px solid #1A1A1A}
+  .nr-w-sec-h{font-weight:700;color:#D4D4D4;margin-bottom:9px;font-size:12px}
+  .nr-w-sec-h em{color:#7A7A7A;font-style:normal;font-weight:400}
+  .nr-w-row{display:flex;justify-content:space-between;align-items:center;margin:4px 0}
+  .nr-muted{color:#8A8A8A}.nr-mono{font-family:ui-monospace,monospace}
+  .nr-on{color:#57E389}.nr-off{color:#ef4444}
+  /* permissions */
+  .nr-w-perms{display:flex;gap:10px}
+  .nr-perm-col{flex:1;display:flex;flex-direction:column;gap:5px}
+  .nr-perm-lab{font-size:10px;text-transform:uppercase;letter-spacing:.06em;color:#7A7A7A;margin-bottom:1px}
+  .nr-perm{font-size:12px}
+  .nr-perm.ok{color:#86efac}.nr-perm.no{color:#fca5a5}.nr-perm.muted{color:#6E6E6E}
+  /* activity summary */
+  .nr-w-stats{display:flex;gap:8px;padding:11px 14px;border-bottom:1px solid #1A1A1A}
+  .nr-stat{flex:1;text-align:center;background:#161616;border-radius:8px;padding:7px 4px}
+  .nr-stat b{display:block;font-size:16px;font-family:ui-monospace,monospace;color:#EDEDED}
+  .nr-stat span{color:#8A8A8A;font-size:10px}
+  /* recent purchases */
+  .nr-act{display:flex;align-items:center;gap:7px;padding:4px 0;font-size:12px}
+  .nr-act-dot{width:7px;height:7px;border-radius:50%;flex:none}
+  .nr-act.ok .nr-act-dot{background:#57E389}.nr-act.no .nr-act-dot{background:#ef4444}
+  .nr-act.no .nr-act-txt{color:#fca5a5}
+  .nr-act-txt{flex:1}
+  .nr-act-amt{font-family:ui-monospace,monospace;color:#FFC247;font-weight:700}
+  .nr-w-empty{color:#7A7A7A;font-size:11px}
+  /* technical drawer */
+  .nr-w-tech{padding:8px 14px 12px}
+  .nr-w-tech-toggle{width:100%;text-align:left;background:none;border:none;color:#8A8A8A;cursor:pointer;font-size:11px;padding:4px 0}
+  .nr-w-tech-toggle em{font-style:normal;opacity:.7}
+  .nr-w-tech-body{margin-top:6px;border-top:1px dashed #1E1E1E;padding-top:8px}
+  .nr-tl-row{display:flex;align-items:center;gap:6px;padding:2px 0;font-size:11px;color:#B9B9B9}
+  .nr-tl-row i{width:8px;height:8px;border-radius:50%;flex:none}
+  .nr-tl-label{flex:1}.nr-tl-amt{color:#FFC247;font-family:ui-monospace,monospace}
+  `;
+    const style = document.createElement("style");
+    style.textContent = css;
+    document.head.appendChild(style);
+  }
+
+  // src/render.ts
+  function escapeHtml(s) {
+    return s.replace(/[&<>"']/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[ch]);
+  }
+  function renderChart(json) {
+    const data = JSON.parse(json);
+    const max = Math.max(...data.series.flatMap((s) => s.points), 1);
+    const colors = ["#4f8cff", "#22c55e", "#f59e0b"];
+    const cols = data.xLabels.map((x, i) => {
+      const bars = data.series.map((s, si) => {
+        const h2 = Math.round(s.points[i] / max * 100);
+        return `<div class="nr-bar" style="height:${h2}%;background:${colors[si % colors.length]}" title="${escapeHtml(s.label)}: ${s.points[i]}${data.unit ?? ""}"></div>`;
+      }).join("");
+      return `<div class="nr-col"><div class="nr-bars">${bars}</div><span class="nr-xlabel">${escapeHtml(x)}</span></div>`;
+    }).join("");
+    const legend = data.series.map((s, si) => `<span class="nr-legend"><i style="background:${colors[si % colors.length]}"></i>${escapeHtml(s.label)}</span>`).join("");
+    return `<figure class="nr-chart"><figcaption>${escapeHtml(data.title)}</figcaption><div class="nr-chart-body">${cols}</div><div class="nr-legends">${legend}</div></figure>`;
+  }
+  function renderCitations(json) {
+    const items = JSON.parse(json);
+    const lis = items.map((c) => `<li>${escapeHtml(c.text)}</li>`).join("");
+    return `<div class="nr-citations"><h4>Sources &amp; further reading</h4><ol>${lis}</ol></div>`;
+  }
+  function renderVideo(json) {
+    const v = JSON.parse(json);
+    return `<div class="nr-video"><div class="nr-video-frame">\u25B6</div><div class="nr-video-meta"><strong>${escapeHtml(v.title)}</strong><span>${escapeHtml(v.duration)} \xB7 ${escapeHtml(v.src)}</span></div></div>`;
+  }
+  function renderContent(content) {
+    if (content.startsWith("CHART::")) return renderChart(content.slice("CHART::".length));
+    if (content.startsWith("CITATIONS::")) return renderCitations(content.slice("CITATIONS::".length));
+    if (content.startsWith("VIDEO::")) return renderVideo(content.slice("VIDEO::".length));
+    return `<p>${escapeHtml(content)}</p>`;
+  }
+
+  // src/scan.ts
+  var PUBLISHER_DEFAULT = "agentic-chronicle";
+  var ARTICLE_DEFAULT = "the-agentic-chronicle";
+  var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  function readChunk(el) {
+    return {
+      chunkId: el.dataset.nanorailChunk ?? el.id ?? "unknown",
+      type: el.dataset.nanorailType ?? "text",
+      price: el.dataset.nanorailPrice ?? "0",
+      publisherId: el.dataset.nanorailPublisher ?? PUBLISHER_DEFAULT,
+      articleId: el.dataset.nanorailArticle ?? ARTICLE_DEFAULT,
+      recipient: el.dataset.nanorailRecipient ?? "",
+      title: el.dataset.nanorailTitle ?? el.dataset.nanorailChunk ?? "Premium chunk",
+      teaser: el.dataset.nanorailTeaser,
+      tags: parseTags(el.dataset.nanorailTags)
+    };
+  }
+  function parseTags(raw) {
+    if (!raw) return [];
+    return raw.split(/[,|]/).map((t) => t.trim()).filter(Boolean);
+  }
+  function shouldAutoUnlock(decision) {
+    return decision.allowed && !decision.requiresManualApproval;
+  }
+  var autoHandlers = /* @__PURE__ */ new WeakMap();
+  var autoObserver;
+  function ensureAutoObserver() {
+    if (typeof IntersectionObserver === "undefined") return void 0;
+    if (!autoObserver) {
+      autoObserver = new IntersectionObserver(
+        (entries, obs) => {
+          for (const entry of entries) {
+            if (!entry.isIntersecting) continue;
+            const handler = autoHandlers.get(entry.target);
+            if (!handler) continue;
+            obs.unobserve(entry.target);
+            autoHandlers.delete(entry.target);
+            handler();
+          }
+        },
+        { threshold: 0.6 }
+      );
+    }
+    return autoObserver;
+  }
+  function scanAndLock(client, root = document, opts = {}) {
+    const els = Array.from(root.querySelectorAll("[data-nanorail-price]"));
+    for (const el of els) {
+      if (el.dataset.nanorailLocked === "true") continue;
+      lockChunk(client, el, opts.autoUnlock === true);
+    }
+    return els;
+  }
+  function lockChunk(client, el, autoUnlock) {
+    const chunk = readChunk(el);
+    el.dataset.nanorailLocked = "true";
+    el.classList.add("nr-chunk", "nr-locked");
+    const panel = document.createElement("div");
+    panel.className = "nr-lock-panel";
+    panel.innerHTML = `
+    <div class="nr-lock-head">
+      <span class="nr-type nr-type-${chunk.type}">${chunk.type.replace("_", " ")}</span>
+      <span class="nr-price">$${chunk.price}</span>
+    </div>
+    <div class="nr-lock-title">${chunk.title}</div>
+    <div class="nr-lock-actions"></div>
+    <div class="nr-lock-msg" role="status"></div>`;
+    const actions = panel.querySelector(".nr-lock-actions");
+    const msg = panel.querySelector(".nr-lock-msg");
+    const button = document.createElement("button");
+    button.className = "nr-unlock-btn";
+    button.textContent = `Unlock \xB7 $${chunk.price}`;
+    actions.appendChild(button);
+    const reveal = (html, auto) => {
+      el.classList.remove("nr-locked", "nr-auto");
+      el.classList.add("nr-unlocked");
+      const badge = auto ? `metered as you read \xB7 $${chunk.price}` : `unlocked via NanoRail \xB7 $${chunk.price}`;
+      el.innerHTML = `<div class="nr-content">${html}</div><div class="nr-content-badge">${badge}</div>`;
+    };
+    const runUnlock = async (approved = false, auto = false) => {
+      button.disabled = true;
+      if (auto) {
+        el.classList.add("nr-auto");
+        button.textContent = "Metering\u2026";
+        msg.className = "nr-lock-msg nr-metering";
+        msg.innerHTML = `<span class="nr-step">\u2713 Policy check passed</span>`;
+        const advancing = sleep(420).then(() => {
+          msg.innerHTML = `<span class="nr-step">\u2713 MPP payment authorized</span>`;
+        });
+        const out2 = await client.unlock(chunk, { approved });
+        await advancing;
+        if (out2.ok && out2.content) {
+          msg.innerHTML = `<span class="nr-step nr-step-paid">\u2713 Auto-paid $${chunk.price} \xB7 receipt ${out2.receipt?.receiptId?.slice(0, 10) ?? "issued"}</span>`;
+          await sleep(850);
+          reveal(renderContent(out2.content), true);
+          return;
+        }
+        el.classList.remove("nr-auto");
+        button.disabled = false;
+        if (out2.needsApproval) {
+          msg.textContent = out2.reason ?? "Manual approval required";
+          msg.className = "nr-lock-msg nr-warn";
+          button.textContent = `Approve & unlock \xB7 $${chunk.price}`;
+          button.onclick = () => runUnlock(true);
+          return;
+        }
+        msg.textContent = `Blocked by policy: ${out2.reason}`;
+        msg.className = "nr-lock-msg nr-blocked";
+        button.textContent = "Blocked by policy";
+        button.disabled = true;
+        el.classList.add("nr-chunk-blocked");
+        return;
+      }
+      button.textContent = "Unlocking\u2026";
+      const out = await client.unlock(chunk, { approved });
+      if (out.ok && out.content) {
+        reveal(renderContent(out.content), auto);
+        return;
+      }
+      el.classList.remove("nr-auto");
+      button.disabled = false;
+      if (out.needsApproval) {
+        msg.textContent = out.reason ?? "Manual approval required";
+        msg.className = "nr-lock-msg nr-warn";
+        button.textContent = `Approve & unlock \xB7 $${chunk.price}`;
+        button.onclick = () => runUnlock(true);
+        return;
+      }
+      msg.textContent = `Blocked by policy: ${out.reason}`;
+      msg.className = "nr-lock-msg nr-blocked";
+      button.textContent = "Blocked by policy";
+      button.disabled = true;
+      el.classList.add("nr-chunk-blocked");
+    };
+    button.onclick = () => runUnlock(false);
+    el.replaceChildren(panel);
+    if (autoUnlock) {
+      const observer = ensureAutoObserver();
+      if (observer) {
+        autoHandlers.set(el, () => {
+          const decision = client.evaluate(chunk);
+          if (shouldAutoUnlock(decision)) {
+            void runUnlock(false, true);
+          } else if (decision.requiresManualApproval) {
+            msg.textContent = "Premium \u2014 approve to unlock";
+            msg.className = "nr-lock-msg nr-warn";
+          } else {
+            msg.textContent = `Held back by your policy: ${decision.reason ?? "not permitted"}`;
+            msg.className = "nr-lock-msg nr-blocked";
+          }
+        });
+        observer.observe(el);
+      }
+    }
+  }
+
+  // src/manifest.ts
+  function generateManifest(opts = {}) {
+    const root = opts.root ?? document;
+    const els = Array.from(root.querySelectorAll("[data-nanorail-price]"));
+    const chunks = els.map((el) => {
+      const c = readChunk(el);
+      return {
+        chunkId: c.chunkId,
+        type: c.type,
+        title: c.title,
+        price: c.price,
+        currency: "USD",
+        recipient: c.recipient,
+        teaser: c.teaser ?? c.title,
+        tags: c.tags ?? [],
+        endpoints: {
+          challenge: `/api/chunks/${c.chunkId}/challenge`,
+          unlock: `/api/chunks/${c.chunkId}/unlock`
+        }
+      };
+    });
+    const articleId = opts.articleId ?? els[0]?.dataset.nanorailArticle ?? "unknown-article";
+    const publisherId = opts.publisherId ?? els[0]?.dataset.nanorailPublisher ?? "unknown-publisher";
+    const title = opts.title ?? (root instanceof Document ? root.querySelector("h1")?.textContent?.trim() : void 0) ?? (typeof document !== "undefined" ? document.title : void 0) ?? articleId;
+    return {
+      articleId,
+      publisherId,
+      title,
+      currency: "USD",
+      source: "sdk-scan",
+      generatedAt: Date.now(),
+      endpoints: {
+        challenge: "/api/chunks/:chunkId/challenge",
+        unlock: "/api/chunks/:chunkId/unlock"
+      },
+      chunks
+    };
+  }
+
+  // src/agent.ts
+  var DEFAULT_TASK = "Summarize MPP payments and receipts";
+  var DEFAULT_QUERY = "MPP payments and receipts";
+  var sleep2 = (ms) => ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
+  function descriptor(manifest, m) {
+    return {
+      chunkId: m.chunkId,
+      type: m.type,
+      price: m.price,
+      publisherId: manifest.publisherId,
+      articleId: manifest.articleId,
+      recipient: m.recipient,
+      title: m.title,
+      teaser: m.teaser,
+      tags: m.tags
+    };
+  }
+  async function runAgentSummary(client, articleId = "the-agentic-chronicle", opts = {}) {
+    const emit = opts.onProgress ?? (() => {
+    });
+    const delay = opts.stepDelayMs ?? 0;
+    const task = opts.task ?? DEFAULT_TASK;
+    const query = opts.query ?? DEFAULT_QUERY;
+    emit({ phase: "task", task, query });
+    const manifest = await client.getManifest(articleId);
+    const matches = await client.discover(articleId, query, "agent");
+    emit({ phase: "discovery", query, matches });
+    await sleep2(delay);
+    const confidenceById = new Map(matches.map((m) => [m.chunkId, m.confidence]));
+    const plan = manifest.chunks.map((m) => {
+      const chunk = descriptor(manifest, m);
+      const decision = client.evaluate(chunk);
+      const confidence = confidenceById.get(m.chunkId);
+      if (!decision.allowed) {
+        return { chunkId: m.chunkId, type: m.type, title: m.title, price: m.price, action: "block", reason: decision.reason ?? "blocked by policy", confidence };
+      }
+      if (confidence !== void 0) {
+        return { chunkId: m.chunkId, type: m.type, title: m.title, price: m.price, action: "buy", reason: `discovery match (confidence ${confidence})`, confidence };
+      }
+      return { chunkId: m.chunkId, type: m.type, title: m.title, price: m.price, action: "skip", reason: "not surfaced by discovery" };
+    });
+    emit({ phase: "plan", plan });
+    await sleep2(delay);
+    const steps = [];
+    const receiptIds = [];
+    const purchased = [];
+    const boughtText = [];
+    let totalMicros = 0;
+    for (const item of plan) {
+      const m = manifest.chunks.find((c) => c.chunkId === item.chunkId);
+      const chunk = descriptor(manifest, m);
+      emit({ phase: "chunk-start", item });
+      await sleep2(delay);
+      if (item.action === "skip") {
+        steps.push({ chunkId: item.chunkId, type: item.type, decision: "skipped", reason: item.reason });
+        emit({ phase: "skipped", chunkId: item.chunkId, reason: item.reason });
+        continue;
+      }
+      if (item.action === "block") {
+        await client.recordClientBlock(chunk, item.reason, "agent");
+        steps.push({ chunkId: item.chunkId, type: item.type, decision: "blocked", reason: item.reason });
+        emit({ phase: "blocked", chunkId: item.chunkId, reason: item.reason });
+        continue;
+      }
+      const out = await client.unlock(chunk, { actor: "agent", viaDiscovery: true });
+      if (out.ok && out.receipt) {
+        receiptIds.push(out.receipt.receiptId);
+        purchased.push({ chunkId: item.chunkId, title: item.title, type: item.type, price: item.price, receiptId: out.receipt.receiptId });
+        totalMicros += toMicros(item.price);
+        steps.push({ chunkId: item.chunkId, type: item.type, decision: "bought", receiptId: out.receipt.receiptId, content: out.content });
+        if (item.type === "text" && out.content) boughtText.push(out.content);
+        emit({ phase: "bought", chunkId: item.chunkId, receiptId: out.receipt.receiptId, content: out.content });
+      } else {
+        const reason = out.reason ?? "unlock failed";
+        steps.push({ chunkId: item.chunkId, type: item.type, decision: "blocked", reason });
+        emit({ phase: "blocked", chunkId: item.chunkId, reason });
+      }
+      await sleep2(delay);
+    }
+    const summary = `Task: ${task}
+Discovered ${matches.length} relevant chunk(s); bought ${receiptIds.length}; skipped the rest; video blocked by policy.
+
+` + boughtText.map((t) => `\u2022 ${t}`).join("\n\n") + `
+
+Receipts: ${receiptIds.join(", ") || "none"}`;
+    const result = {
+      task,
+      query,
+      matches,
+      plan,
+      steps,
+      receiptIds,
+      purchased,
+      totalCost: fromMicros(totalMicros),
+      summary
+    };
+    emit({ phase: "done", result });
+    return result;
+  }
+
+  // src/agent-console.ts
+  var DEFAULT_AGENT_TASKS = [
+    { label: "Find evidence supporting MPP receipts", query: "MPP receipts and payment verification" },
+    { label: "Explain Tempo session payments", query: "Tempo session payments and vouchers" },
+    { label: "Summarize machine vs human readership", query: "machine vs human read trends data chart" }
+  ];
+  var esc2 = (s) => s.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
+  var pct = (c) => `${Math.round(c * 100)}%`;
+  function mountAgentConsole(instance, opts = {}) {
+    injectStyles2();
+    const tasks = opts.tasks ?? DEFAULT_AGENT_TASKS;
+    const stepDelayMs = opts.stepDelayMs ?? 750;
+    const fab = document.createElement("button");
+    fab.className = "nr-ac-fab";
+    fab.innerHTML = `${markSvg("#0A0A0A")} Agent Mode`;
+    document.body.appendChild(fab);
+    const overlay = document.createElement("div");
+    overlay.className = "nr-ac-overlay";
+    overlay.innerHTML = `
+    <div class="nr-ac-modal" role="dialog" aria-label="NanoRail Agent Mode">
+      <div class="nr-ac-head">
+        <span class="nr-ac-title">${markSvg()} Agent Mode <em>\u2014 buy only what the task needs</em></span>
+        <button class="nr-ac-close" title="Close">\xD7</button>
+      </div>
+      <div class="nr-ac-body">
+        <div class="nr-ac-setup">
+          <div class="nr-ac-label">1 \xB7 Give the agent a task</div>
+          <div class="nr-ac-tasks"></div>
+          <div class="nr-ac-label">Your buyer policy (the agent must obey it)</div>
+          <div class="nr-ac-policy"></div>
+          <button class="nr-ac-run" disabled>Run Agent</button>
+        </div>
+        <div class="nr-ac-run-views" hidden>
+          <div class="nr-ac-block nr-ac-discovery"></div>
+          <div class="nr-ac-block nr-ac-timeline-wrap"><div class="nr-ac-label">Agent activity \u2014 watch it make economic decisions</div><div class="nr-ac-timeline"></div></div>
+          <div class="nr-ac-block nr-ac-output"></div>
+        </div>
+      </div>
+    </div>`;
+    document.body.appendChild(overlay);
+    const q = (sel) => overlay.querySelector(sel);
+    const tasksEl = q(".nr-ac-tasks");
+    const policyEl = q(".nr-ac-policy");
+    const runBtn = q(".nr-ac-run");
+    const runViews = q(".nr-ac-run-views");
+    const discoveryEl = q(".nr-ac-discovery");
+    const timelineEl = q(".nr-ac-timeline");
+    const outputEl = q(".nr-ac-output");
+    let selected = -1;
+    tasksEl.innerHTML = tasks.map((t, i) => `<button class="nr-ac-task" data-i="${i}">${esc2(t.label)}</button>`).join("");
+    tasksEl.querySelectorAll(".nr-ac-task").forEach((b) => {
+      b.onclick = () => {
+        selected = Number(b.dataset.i);
+        tasksEl.querySelectorAll(".nr-ac-task").forEach((x) => x.classList.remove("on"));
+        b.classList.add("on");
+        runBtn.disabled = false;
+      };
+    });
+    const p = instance.client.getPolicy();
+    policyEl.innerHTML = `<div class="nr-ac-pol-row"><span>Budget</span><strong>$${esc2(p.sessionBudget)}</strong></div><div class="nr-ac-pol-row"><span>Allowed</span><span class="nr-ac-allow">${p.allowedContentTypes.map((t) => esc2(t)).join(", ")}</span></div><div class="nr-ac-pol-row"><span>Blocked</span><span class="nr-ac-block-types">${p.blockedContentTypes.map((t) => esc2(t)).join(", ") || "\u2014"}</span></div>`;
+    const open = () => overlay.classList.add("open");
+    const close = () => overlay.classList.remove("open");
+    fab.onclick = open;
+    q(".nr-ac-close").onclick = close;
+    overlay.onclick = (e) => {
+      if (e.target === overlay) close();
+    };
+    const titleOf = /* @__PURE__ */ new Map();
+    const priceOf = /* @__PURE__ */ new Map();
+    const row = (cls, html) => {
+      const d = document.createElement("div");
+      d.className = `nr-ac-tl ${cls}`;
+      d.innerHTML = html;
+      timelineEl.appendChild(d);
+      timelineEl.scrollTop = timelineEl.scrollHeight;
+    };
+    runBtn.onclick = async () => {
+      if (selected < 0) return;
+      const task = tasks[selected];
+      runBtn.disabled = true;
+      runBtn.textContent = "Agent working\u2026";
+      runViews.hidden = false;
+      discoveryEl.innerHTML = "";
+      timelineEl.innerHTML = "";
+      outputEl.innerHTML = "";
+      titleOf.clear();
+      priceOf.clear();
+      const onProgress = (ev) => {
+        if (ev.phase === "task") {
+          row("q", `<span class="nr-ac-dot"></span> Querying the Publisher Discovery Agent: <em>\u201C${esc2(ev.query)}\u201D</em>`);
+        } else if (ev.phase === "discovery") {
+          for (const m of ev.matches) {
+            titleOf.set(m.chunkId, m.title);
+            priceOf.set(m.chunkId, m.price);
+          }
+          discoveryEl.innerHTML = `<div class="nr-ac-label">Publisher Discovery Agent \u2014 found ${ev.matches.length} relevant paid chunk${ev.matches.length === 1 ? "" : "s"} (no premium content revealed)</div>` + (ev.matches.length ? ev.matches.map(
+            (m, i) => `<div class="nr-ac-disc"><span class="nr-ac-disc-n">${i + 1}</span><div class="nr-ac-disc-main"><b>${esc2(m.title)}</b><span class="nr-ac-disc-teaser">${esc2(m.teaser)}</span><span class="nr-ac-disc-tags">${m.tags.map((t) => `#${esc2(t)}`).join(" ")}</span></div><div class="nr-ac-disc-meta"><span class="nr-ac-type t-${m.type}">${esc2(m.type)}</span><span class="nr-ac-price">$${esc2(m.price)}</span><span class="nr-ac-conf">${pct(m.confidence)} match</span></div></div>`
+          ).join("") : '<div class="nr-ac-empty">No relevant paid content \u2014 the agent will not spend.</div>');
+          row("found", `<span class="nr-ac-dot"></span> Found <strong>${ev.matches.length}</strong> purchasable chunk${ev.matches.length === 1 ? "" : "s"}`);
+        } else if (ev.phase === "plan") {
+          for (const it of ev.plan) {
+            titleOf.set(it.chunkId, it.title);
+            priceOf.set(it.chunkId, it.price);
+          }
+          row("eval", `<span class="nr-ac-dot"></span> Evaluating relevance, price &amp; policy\u2026`);
+        } else if (ev.phase === "chunk-start") {
+          if (ev.item.action === "buy") row("buy", `<span class="nr-ac-dot"></span> Purchasing <b>${esc2(ev.item.title)}</b> <span class="nr-ac-cost">$${esc2(ev.item.price)}</span>\u2026`);
+        } else if (ev.phase === "bought") {
+          row("receipt", `<span class="nr-ac-dot ok"></span> Receipt issued \xB7 <code>${esc2(ev.receiptId)}</code>`);
+        } else if (ev.phase === "blocked") {
+          row("blocked", `<span class="nr-ac-dot no"></span> Skipped <b>${esc2(titleOf.get(ev.chunkId) ?? ev.chunkId)}</b> \u2014 ${esc2(ev.reason)}`);
+        } else if (ev.phase === "skipped") {
+          row("skip", `<span class="nr-ac-dot"></span> Skipped <b>${esc2(titleOf.get(ev.chunkId) ?? ev.chunkId)}</b> \u2014 not relevant to the task`);
+        } else if (ev.phase === "done") {
+          row("gen", `<span class="nr-ac-dot"></span> Generating answer\u2026`);
+          row("done", `<span class="nr-ac-dot ok"></span> Done`);
+          renderOutput(outputEl, ev.result.purchased, ev.result.receiptIds, ev.result.totalCost);
+        }
+      };
+      try {
+        await instance.runAgent({ task: task.label, query: task.query, onProgress, stepDelayMs });
+      } catch {
+        row("blocked", `<span class="nr-ac-dot no"></span> Agent run failed \u2014 is the gateway running?`);
+      }
+      runBtn.textContent = "Run again";
+      runBtn.disabled = false;
+    };
+    return { open, close };
+  }
+  function renderOutput(el, purchased, receiptIds, totalCost) {
+    const sources = purchased.length ? purchased.map((s) => `<li>${esc2(s.title)} <span class="nr-ac-cost">$${esc2(s.price)}</span></li>`).join("") : '<li class="nr-ac-empty">None \u2014 nothing met the task + policy bar.</li>';
+    el.innerHTML = `<div class="nr-ac-out-h">Generated answer</div><div class="nr-ac-out-grid"><div><div class="nr-ac-out-label">Sources purchased</div><ul class="nr-ac-sources">${sources}</ul></div><div><div class="nr-ac-out-label">Receipts</div><div class="nr-ac-receipts">${receiptIds.map((r) => `<code>${esc2(r)}</code>`).join(" ") || "\u2014"}</div><div class="nr-ac-out-label" style="margin-top:12px">Total cost</div><div class="nr-ac-total">$${esc2(totalCost)}</div></div></div><div class="nr-ac-thesis">The agent discovered what was available, decided what was worth buying, and paid \u2014 on Tempo, with receipts.</div>`;
+  }
+  function markSvg(fill = "#FFC247") {
+    return `<svg width="15" height="15" viewBox="0 0 64 64" style="vertical-align:-2px;flex:none"><g fill="${fill}"><circle cx="14" cy="12" r="4"/><circle cx="14" cy="22" r="4"/><circle cx="14" cy="32" r="4"/><circle cx="14" cy="42" r="4"/><circle cx="14" cy="52" r="4"/><circle cx="54" cy="12" r="4"/><circle cx="54" cy="22" r="4"/><circle cx="54" cy="42" r="4"/><circle cx="54" cy="52" r="4"/><circle cx="24" cy="22" r="4"/><circle cx="34" cy="32" r="4"/><circle cx="44" cy="42" r="4"/></g></svg>`;
+  }
+  function injectStyles2() {
+    if (document.getElementById("nr-ac-styles")) return;
+    const css = `
+  .nr-ac-fab{position:fixed;left:50%;transform:translateX(-50%);bottom:22px;z-index:99998;display:flex;align-items:center;gap:7px;background:#FFC247;color:#0A0A0A;border:none;border-radius:999px;padding:11px 20px;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;font-size:14px;font-weight:800;cursor:pointer;box-shadow:0 10px 30px rgba(255,194,71,.35)}
+  .nr-ac-fab:hover{background:#E2A12F}
+  .nr-ac-overlay{position:fixed;inset:0;z-index:100000;background:rgba(7,7,7,.66);backdrop-filter:blur(4px);display:none;align-items:flex-start;justify-content:center;padding:5vh 16px;overflow:auto}
+  .nr-ac-overlay.open{display:flex}
+  .nr-ac-modal{width:100%;max-width:660px;background:#0B0B0B;border:1px solid #1E1E1E;border-radius:16px;color:#EDEDED;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;box-shadow:0 24px 70px rgba(0,0,0,.6);overflow:hidden}
+  .nr-ac-head{display:flex;align-items:center;justify-content:space-between;padding:16px 18px;border-bottom:1px solid #1E1E1E;background:#0E0E0E}
+  .nr-ac-title{display:flex;align-items:center;gap:8px;font-weight:700;font-size:15px}
+  .nr-ac-title em{color:#8A8A8A;font-style:normal;font-weight:400;font-size:13px}
+  .nr-ac-close{background:none;border:none;color:#8A8A8A;font-size:22px;line-height:1;cursor:pointer}
+  .nr-ac-close:hover{color:#EDEDED}
+  .nr-ac-body{padding:18px;max-height:78vh;overflow:auto}
+  .nr-ac-label{font-family:ui-monospace,monospace;font-size:11px;letter-spacing:.06em;text-transform:uppercase;color:#8A8A8A;margin:0 0 8px}
+  .nr-ac-tasks{display:flex;flex-direction:column;gap:8px;margin-bottom:18px}
+  .nr-ac-task{text-align:left;background:#0E0E0E;border:1px solid #1E1E1E;border-radius:10px;padding:11px 14px;color:#EDEDED;font-size:14px;cursor:pointer}
+  .nr-ac-task:hover{border-color:#3A3A3A}
+  .nr-ac-task.on{border-color:#FFC247;background:rgba(255,194,71,.08);box-shadow:0 0 0 1px rgba(255,194,71,.25)}
+  .nr-ac-policy{background:#0E0E0E;border:1px solid #1E1E1E;border-radius:10px;padding:10px 14px;margin-bottom:18px}
+  .nr-ac-pol-row{display:flex;justify-content:space-between;align-items:center;padding:4px 0;font-size:13px;color:#B9B9B9}
+  .nr-ac-pol-row strong{color:#FFC247;font-family:ui-monospace,monospace}
+  .nr-ac-allow{color:#86efac}.nr-ac-block-types{color:#fca5a5}
+  .nr-ac-run{width:100%;background:#FFC247;color:#0A0A0A;border:none;border-radius:10px;padding:12px;font-weight:800;font-size:15px;cursor:pointer}
+  .nr-ac-run:disabled{opacity:.45;cursor:default}
+  .nr-ac-run:not(:disabled):hover{background:#E2A12F}
+  .nr-ac-block{margin-top:20px}
+  .nr-ac-disc{display:flex;gap:10px;align-items:flex-start;background:#0E0E0E;border:1px solid #1E1E1E;border-radius:10px;padding:11px 13px;margin-bottom:8px}
+  .nr-ac-disc-n{width:20px;height:20px;flex:none;border-radius:6px;background:#161616;color:#FFC247;font-family:ui-monospace,monospace;font-size:11px;display:flex;align-items:center;justify-content:center;font-weight:700}
+  .nr-ac-disc-main{flex:1;display:flex;flex-direction:column;gap:2px;min-width:0}
+  .nr-ac-disc-main b{font-size:14px}
+  .nr-ac-disc-teaser{color:#9A9A9A;font-size:12px}
+  .nr-ac-disc-tags{color:#6E6E6E;font-size:11px;font-family:ui-monospace,monospace}
+  .nr-ac-disc-meta{display:flex;flex-direction:column;align-items:flex-end;gap:3px;flex:none}
+  .nr-ac-price{font-family:ui-monospace,monospace;font-weight:700;color:#EDEDED;font-size:13px}
+  .nr-ac-conf{font-size:11px;color:#FFC247;font-family:ui-monospace,monospace}
+  .nr-ac-type{font-size:10px;text-transform:uppercase;letter-spacing:.5px;padding:1px 6px;border-radius:999px;background:#161616;color:#C4C4C4}
+  .nr-ac-type.t-video{background:#3b1d1d;color:#fca5a5}.nr-ac-type.t-chart{background:#14321f;color:#86efac}.nr-ac-type.t-citation_pack{background:#332b12;color:#fde68a}
+  .nr-ac-timeline{background:#0E0E0E;border:1px solid #1E1E1E;border-radius:10px;padding:10px 14px;max-height:240px;overflow:auto;font-size:13px}
+  .nr-ac-tl{display:flex;align-items:center;gap:8px;padding:5px 0;animation:nr-ac-in .25s ease;color:#D4D4D4}
+  @keyframes nr-ac-in{from{opacity:0;transform:translateX(-5px)}to{opacity:1;transform:none}}
+  .nr-ac-tl code{font-family:ui-monospace,monospace;font-size:11px;color:#FFC247;background:#161616;padding:1px 5px;border-radius:4px}
+  .nr-ac-tl em{color:#9A9A9A;font-style:normal}
+  .nr-ac-cost{font-family:ui-monospace,monospace;color:#FFC247;font-weight:700}
+  .nr-ac-dot{width:8px;height:8px;border-radius:50%;flex:none;background:#5C5C5C}
+  .nr-ac-dot.ok{background:#57E389}.nr-ac-dot.no{background:#ef4444}
+  .nr-ac-tl.buy{color:#EDEDED}.nr-ac-tl.blocked{color:#fca5a5}
+  .nr-ac-output{background:linear-gradient(180deg,#0E0E0E,#0B0B0B);border:1px solid #FFC247;border-radius:12px;padding:16px 18px}
+  .nr-ac-out-h{font-weight:800;color:#FFC247;margin-bottom:12px}
+  .nr-ac-out-grid{display:grid;grid-template-columns:1fr 1fr;gap:18px}
+  .nr-ac-out-label{font-family:ui-monospace,monospace;font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:#8A8A8A;margin-bottom:6px}
+  .nr-ac-sources{margin:0;padding-left:16px;font-size:13px}.nr-ac-sources li{margin:3px 0}
+  .nr-ac-receipts code{font-family:ui-monospace,monospace;font-size:11px;color:#FFC247;background:#161616;padding:1px 5px;border-radius:4px;margin-right:4px}
+  .nr-ac-total{font-family:ui-monospace,monospace;font-size:22px;font-weight:800;color:#FFC247}
+  .nr-ac-thesis{margin-top:14px;padding-top:12px;border-top:1px solid #1E1E1E;color:#9A9A9A;font-size:13px}
+  .nr-ac-empty{color:#8A8A8A}
+  @media (max-width:560px){.nr-ac-out-grid{grid-template-columns:1fr}}
+  `;
+    const style = document.createElement("style");
+    style.id = "nr-ac-styles";
+    style.textContent = css;
+    document.head.appendChild(style);
+  }
+
+  // src/mount.ts
+  function initNanoRail(config = {}) {
+    const gatewayUrl = config.gatewayUrl ?? "http://localhost:4020";
+    const articleId = config.articleId ?? "the-agentic-chronicle";
+    const client = new NanoRailClient({ gatewayUrl, actor: config.actor ?? "human" });
+    const widget = config.mountWidget === false ? void 0 : new NanoRailWidget(client);
+    client.ensureSession().then(() => widget?.render());
+    client.startSettlementWatch();
+    const buildAndRegister = async () => {
+      const m = generateManifest({ articleId });
+      if (m.chunks.length > 0) await client.registerManifest(m).catch(() => {
+      });
+      return m;
+    };
+    const instance = {
+      client,
+      widget,
+      manifest: generateManifest({ articleId }),
+      rescan: () => scanAndLock(client, document, { autoUnlock: config.autoUnlockOnScroll === true }),
+      regenerateManifest: async () => {
+        instance.manifest = await buildAndRegister();
+        return instance.manifest;
+      },
+      runAgent: (opts) => runAgentSummary(client, articleId, opts),
+      forceVideoRejection: async () => {
+        const el = document.querySelector('[data-nanorail-type="video"]');
+        const chunk = el ? readChunk(el) : void 0;
+        if (!chunk) return { rejected: false, reason: "no video chunk on page" };
+        return client.forceServerRejection(chunk, "human");
+      },
+      unlockTempoSnippet: () => client.unlockTempoSnippet()
+    };
+    buildAndRegister().then((m) => {
+      instance.manifest = m;
+    });
+    if (config.autoScan !== false) {
+      scanAndLock(client, document, { autoUnlock: config.autoUnlockOnScroll === true });
+    }
+    if (config.agentConsole) {
+      const console_ = mountAgentConsole(instance, { tasks: config.agentTasks });
+      instance.openAgentConsole = console_.open;
+    }
+    return instance;
+  }
+
+  // src/browser.ts
+  function init() {
+    const nr = initNanoRail(window.NANORAIL_CONFIG ?? {});
+    window.NanoRail = nr;
+    document.dispatchEvent(new CustomEvent("nanorail:ready"));
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();
+/*! Bundled license information:
+
+@noble/ed25519/index.js:
+  (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=nanorail.js.map