@verimago/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+import { Certificate, Manifest, ManifestMetadata, VerifyResult, UGCAnalysis, UGCPlatform, Environment, PaginatedResponse } from '@verimago/shared';
+export * from '@verimago/shared';
+export interface VerimagoOptions {
+    apiKey: string;
+    env?: Environment;
+    baseUrl?: string;
+    timeout?: number;
+}
+export interface SignOptions {
+    certId: string;
+    privateKey: string;
+    metadata: ManifestMetadata;
+}
+export interface PublishResult {
+    id: string;
+    registryUrl: string;
+    certId: string;
+    videoHash: string;
+}
+export interface UGCSubmitOptions {
+    platform?: UGCPlatform;
+    claimedAt?: string;
+    claimedLocation?: string;
+}
+export declare class Verimago {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly timeout;
+    constructor(opts: VerimagoOptions);
+    private request;
+    /** Compute SHA-256 hash of a video file buffer */
+    hashFile(file: Buffer | Uint8Array): Promise<string>;
+    /**
+     * Verify a video file or hash against the Verimago registry.
+     * Accepts a Buffer, Uint8Array, or a pre-computed 'sha256:hex' string.
+     * Results are cached at the CDN layer for 4 hours.
+     */
+    verify(fileOrHash: Buffer | Uint8Array | string): Promise<VerifyResult>;
+    /**
+     * Sign a video locally and return a manifest object.
+     * Does NOT publish — call publish() separately.
+     * The private key never leaves your environment.
+     */
+    sign(file: Buffer | Uint8Array, opts: SignOptions): Promise<Manifest>;
+    /** Publish a signed manifest to the Verimago registry */
+    publish(manifest: Manifest): Promise<PublishResult>;
+    /**
+     * Submit a social media URL for UGC corroboration analysis.
+     * Returns immediately with an analysis ID; poll /v1/ugc/:id for results.
+     */
+    analyzeUGC(url: string, opts?: UGCSubmitOptions): Promise<{
+        id: string;
+        status: 'QUEUED';
+    }>;
+    /** Poll for UGC analysis results */
+    getUGCAnalysis(id: string): Promise<UGCAnalysis>;
+    /** List all verified publisher certificates */
+    listCertificates(page?: number, pageSize?: number): Promise<PaginatedResponse<Certificate>>;
+    /** Get a single certificate by ID */
+    getCertificate(certId: string): Promise<Certificate>;
+    /** Check API health — useful in health-check scripts */
+    health(): Promise<{
+        status: 'ok';
+        version: string;
+        db: string;
+        redis: string;
+    }>;
+}
+export default Verimago;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,WAAW,EAAE,QAAQ,EAAE,gBAAgB,EAAE,YAAY,EACrD,WAAW,EAAE,WAAW,EAAE,WAAW,EAAW,iBAAiB,EAClE,MAAM,kBAAkB,CAAC;AAE1B,cAAc,kBAAkB,CAAC;AAIjC,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAID,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,IAAI,EAAE,eAAe;YASnB,OAAO;IA6BrB,kDAAkD;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAM1D;;;;OAIG;IACG,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAS7E;;;;OAIG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IA8B3E,yDAAyD;IACnD,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,aAAa,CAAC;IASzD;;;OAGG;IACG,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,QAAQ,CAAA;KAAE,CAAC;IAOrG,oCAAoC;IAC9B,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAMtD,+CAA+C;IACzC,gBAAgB,CAAC,IAAI,SAAI,EAAE,QAAQ,SAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAMxF,qCAAqC;IAC/B,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAM1D,wDAAwD;IAClD,MAAM,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,IAAI,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAGtF;AAGD,eAAe,QAAQ,CAAC"}

package/dist/index.js

@@ -0,0 +1,167 @@
+"use strict";
+// packages/sdk/src/index.ts
+// @verimago/sdk — official Verimago Node.js + Browser SDK
+// Usage: const vi = new Verimago({ apiKey: process.env.VERIMAGO_KEY })
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Verimago = void 0;
+const crypto_1 = require("crypto");
+const shared_1 = require("@verimago/shared");
+__exportStar(require("@verimago/shared"), exports);
+// ── CLIENT ─────────────────────────────────────────────────────────────────
+class Verimago {
+    constructor(opts) {
+        const urls = (0, shared_1.getUrls)(opts.env ?? 'production');
+        this.baseUrl = opts.baseUrl ?? urls.api;
+        this.apiKey = opts.apiKey;
+        this.timeout = opts.timeout ?? 10000;
+    }
+    // ── PRIVATE ────────────────────────────────────────────────────────────
+    async request(path, init = {}) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const res = await fetch(`${this.baseUrl}${path}`, {
+                ...init,
+                signal: controller.signal,
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'verimago-sdk/1.0.0',
+                    ...init.headers,
+                },
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => '');
+                throw new Error(`Verimago API ${res.status}: ${body || res.statusText}`);
+            }
+            return res.json();
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    // ── HASHING ────────────────────────────────────────────────────────────
+    /** Compute SHA-256 hash of a video file buffer */
+    async hashFile(file) {
+        return 'sha256:' + (0, crypto_1.createHash)('sha256').update(file).digest('hex');
+    }
+    // ── VERIFY ─────────────────────────────────────────────────────────────
+    /**
+     * Verify a video file or hash against the Verimago registry.
+     * Accepts a Buffer, Uint8Array, or a pre-computed 'sha256:hex' string.
+     * Results are cached at the CDN layer for 4 hours.
+     */
+    async verify(fileOrHash) {
+        const hash = typeof fileOrHash === 'string'
+            ? fileOrHash
+            : await this.hashFile(fileOrHash);
+        return this.request(`/v1/verify/${encodeURIComponent(hash)}`);
+    }
+    // ── SIGN ───────────────────────────────────────────────────────────────
+    /**
+     * Sign a video locally and return a manifest object.
+     * Does NOT publish — call publish() separately.
+     * The private key never leaves your environment.
+     */
+    async sign(file, opts) {
+        const videoHash = await this.hashFile(file);
+        const signedAt = new Date().toISOString();
+        // Assemble the canonical payload — order matters for deterministic signing
+        const payload = JSON.stringify({
+            videoHash,
+            certId: opts.certId,
+            metadata: opts.metadata,
+            signedAt,
+        });
+        // Dynamic import of @noble/ed25519 to support both Node and browser
+        const ed = await Promise.resolve().then(() => __importStar(require('@noble/ed25519')));
+        const privBytes = Buffer.from(opts.privateKey, 'base64');
+        const sigBytes = await ed.signAsync(new TextEncoder().encode(payload), privBytes);
+        const signature = Buffer.from(sigBytes).toString('base64');
+        return {
+            id: '', // assigned by registry on publish
+            videoHash,
+            certId: opts.certId,
+            signature,
+            metadata: opts.metadata,
+            signedAt,
+        };
+    }
+    // ── PUBLISH ────────────────────────────────────────────────────────────
+    /** Publish a signed manifest to the Verimago registry */
+    async publish(manifest) {
+        return this.request('/v1/manifests', {
+            method: 'POST',
+            body: JSON.stringify(manifest),
+        });
+    }
+    // ── UGC ────────────────────────────────────────────────────────────────
+    /**
+     * Submit a social media URL for UGC corroboration analysis.
+     * Returns immediately with an analysis ID; poll /v1/ugc/:id for results.
+     */
+    async analyzeUGC(url, opts = {}) {
+        return this.request('/v1/ugc/analyze', {
+            method: 'POST',
+            body: JSON.stringify({ url, ...opts }),
+        });
+    }
+    /** Poll for UGC analysis results */
+    async getUGCAnalysis(id) {
+        return this.request(`/v1/ugc/${id}`);
+    }
+    // ── CERTIFICATES ───────────────────────────────────────────────────────
+    /** List all verified publisher certificates */
+    async listCertificates(page = 1, pageSize = 50) {
+        return this.request(`/v1/certs?page=${page}&pageSize=${pageSize}`);
+    }
+    /** Get a single certificate by ID */
+    async getCertificate(certId) {
+        return this.request(`/v1/certs/${certId}`);
+    }
+    // ── HEALTH ─────────────────────────────────────────────────────────────
+    /** Check API health — useful in health-check scripts */
+    async health() {
+        return this.request('/v1/health');
+    }
+}
+exports.Verimago = Verimago;
+// ── DEFAULT EXPORT ─────────────────────────────────────────────────────────
+exports.default = Verimago;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,739 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../shared/dist/index.js
+var require_dist = __commonJS({
+  "../shared/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LOCAL_URLS = exports.STAGING_URLS = exports.VERIMAGO_URLS = exports.CONTENT_TYPE_DESCRIPTIONS = exports.CONTENT_TYPE_COLORS = exports.CONTENT_TYPE_LABELS = void 0;
+    exports.getUrls = getUrls2;
+    exports.formatCertId = formatCertId;
+    exports.truncateHash = truncateHash;
+    exports.CONTENT_TYPE_LABELS = {
+      AUTHENTIC: "Authentic",
+      AI_ENHANCED: "AI Enhanced",
+      AI_CREATED: "AI Created"
+    };
+    exports.CONTENT_TYPE_COLORS = {
+      AUTHENTIC: "#00b894",
+      // green
+      AI_ENHANCED: "#f39c12",
+      // amber
+      AI_CREATED: "#8b5cf6"
+      // purple
+    };
+    exports.CONTENT_TYPE_DESCRIPTIONS = {
+      AUTHENTIC: "Original, unaltered content. No AI modifications applied.",
+      AI_ENHANCED: "Real content enhanced with AI tools (e.g. noise reduction, upscaling, color grading).",
+      AI_CREATED: "Fully or substantially generated by AI. Not a recording of real events."
+    };
+    exports.VERIMAGO_URLS = {
+      api: "https://api.verimago.io",
+      registry: "https://registry.verimago.io",
+      publisher: "https://publisher.verimago.io",
+      cdn: "https://cdn.verimago.io",
+      ocsp: "https://ocsp.verimago.io",
+      status: "https://status.verimago.io",
+      corporate: "https://verimago.com"
+    };
+    exports.STAGING_URLS = {
+      ...exports.VERIMAGO_URLS,
+      api: "https://staging-api.verimago.io",
+      registry: "https://staging-registry.verimago.io",
+      publisher: "https://staging-publisher.verimago.io"
+    };
+    exports.LOCAL_URLS = {
+      ...exports.VERIMAGO_URLS,
+      api: "http://localhost:3000",
+      registry: "http://localhost:3001",
+      publisher: "http://localhost:3002"
+    };
+    function getUrls2(env = "production") {
+      if (env === "staging")
+        return exports.STAGING_URLS;
+      if (env === "local")
+        return exports.LOCAL_URLS;
+      return exports.VERIMAGO_URLS;
+    }
+    function formatCertId(id) {
+      return `VMGO-${id.slice(0, 8).toUpperCase()}`;
+    }
+    function truncateHash(hash, len = 12) {
+      const hex = hash.replace("sha256:", "");
+      return `${hex.slice(0, len)}\u2026`;
+    }
+  }
+});
+
+// ../../node_modules/@noble/ed25519/index.js
+var ed25519_exports = {};
+__export(ed25519_exports, {
+  CURVE: () => ed25519_CURVE,
+  ExtendedPoint: () => Point,
+  Point: () => Point,
+  etc: () => etc,
+  getPublicKey: () => getPublicKey,
+  getPublicKeyAsync: () => getPublicKeyAsync,
+  sign: () => sign,
+  signAsync: () => signAsync,
+  utils: () => utils,
+  verify: () => verify,
+  verifyAsync: () => verifyAsync
+});
+var ed25519_CURVE, P, N, Gx, Gy, _a, _d, h, L, L2, err, isBig, isStr, isBytes, abytes, u8n, u8fr, padh, bytesToHex, C, _ch, hexToBytes, toU8, cr, subtle, concatBytes, randomBytes, big, arange, M, modN, invert, callHash, apoint, B256, Point, G, I, numTo32bLE, bytesToNumLE, pow2, pow_2_252_3, RM1, uvRatio, modL_LE, sha512a, sha512s, hash2extK, getExtendedPublicKeyAsync, getExtendedPublicKey, getPublicKeyAsync, getPublicKey, hashFinishA, hashFinishS, _sign, signAsync, sign, veriOpts, _verify, verifyAsync, verify, etc, utils, W, scalarBits, pwindows, pwindowSize, precompute, Gpows, ctneg, wNAF;
+var init_ed25519 = __esm({
+  "../../node_modules/@noble/ed25519/index.js"() {
+    ed25519_CURVE = {
+      p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
+      n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
+      h: 8n,
+      a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
+      d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
+      Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
+      Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n
+    };
+    ({ p: P, n: N, Gx, Gy, a: _a, d: _d } = ed25519_CURVE);
+    h = 8n;
+    L = 32;
+    L2 = 64;
+    err = (m = "") => {
+      throw new Error(m);
+    };
+    isBig = (n) => typeof n === "bigint";
+    isStr = (s) => typeof s === "string";
+    isBytes = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+    abytes = (a, l) => !isBytes(a) || typeof l === "number" && l > 0 && a.length !== l ? err("Uint8Array expected") : a;
+    u8n = (len) => new Uint8Array(len);
+    u8fr = (buf) => Uint8Array.from(buf);
+    padh = (n, pad) => n.toString(16).padStart(pad, "0");
+    bytesToHex = (b) => Array.from(abytes(b)).map((e) => padh(e, 2)).join("");
+    C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+    _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;
+    };
+    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;
+    };
+    toU8 = (a, len) => abytes(isStr(a) ? hexToBytes(a) : u8fr(abytes(a)), len);
+    cr = () => globalThis?.crypto;
+    subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined");
+    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;
+    };
+    randomBytes = (len = L) => {
+      const c = cr();
+      return c.getRandomValues(u8n(len));
+    };
+    big = BigInt;
+    arange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
+    M = (a, b = P) => {
+      const r = a % b;
+      return r >= 0n ? r : b + r;
+    };
+    modN = (a) => M(a, N);
+    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");
+    };
+    callHash = (name) => {
+      const fn = etc[name];
+      if (typeof fn !== "function")
+        err("hashes." + name + " not set");
+      return fn;
+    };
+    apoint = (p) => p instanceof Point ? p : err("Point expected");
+    B256 = 2n ** 256n;
+    Point = class _Point {
+      static BASE;
+      static ZERO;
+      ex;
+      ey;
+      ez;
+      et;
+      constructor(ex, ey, ez, 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();
+      }
+    };
+    G = new Point(Gx, Gy, 1n, M(Gx * Gy));
+    I = new Point(0n, 1n, 1n, 0n);
+    Point.BASE = G;
+    Point.ZERO = I;
+    numTo32bLE = (num) => hexToBytes(padh(arange(num, 0n, B256), L2)).reverse();
+    bytesToNumLE = (b) => big("0x" + bytesToHex(u8fr(abytes(b)).reverse()));
+    pow2 = (x, power) => {
+      let r = x;
+      while (power-- > 0n) {
+        r *= r;
+        r %= P;
+      }
+      return r;
+    };
+    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 };
+    };
+    RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
+    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 };
+    };
+    modL_LE = (hash) => modN(bytesToNumLE(hash));
+    sha512a = (...m) => etc.sha512Async(...m);
+    sha512s = (...m) => callHash("sha512Sync")(...m);
+    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 };
+    };
+    getExtendedPublicKeyAsync = (priv) => sha512a(toU8(priv, L)).then(hash2extK);
+    getExtendedPublicKey = (priv) => hash2extK(sha512s(toU8(priv, L)));
+    getPublicKeyAsync = (priv) => getExtendedPublicKeyAsync(priv).then((p) => p.pointBytes);
+    getPublicKey = (priv) => getExtendedPublicKey(priv).pointBytes;
+    hashFinishA = (res) => sha512a(res.hashable).then(res.finish);
+    hashFinishS = (res) => res.finish(sha512s(res.hashable));
+    _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 };
+    };
+    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));
+    };
+    sign = (msg, privKey) => {
+      const m = toU8(msg);
+      const e = getExtendedPublicKey(privKey);
+      const rBytes = sha512s(e.prefix, m);
+      return hashFinishS(_sign(e, rBytes, m));
+    };
+    veriOpts = { zip215: true };
+    _verify = (sig, msg, pub, opts = veriOpts) => {
+      sig = toU8(sig, L2);
+      msg = toU8(msg);
+      pub = toU8(pub, L);
+      const { zip215 } = opts;
+      let A;
+      let R;
+      let s;
+      let SB;
+      let hashable = Uint8Array.of();
+      try {
+        A = Point.fromHex(pub, zip215);
+        R = Point.fromHex(sig.slice(0, L), zip215);
+        s = bytesToNumLE(sig.slice(L, L2));
+        SB = G.multiply(s, false);
+        hashable = concatBytes(R.toBytes(), A.toBytes(), msg);
+      } catch (error) {
+      }
+      const finish = (hashed) => {
+        if (SB == null)
+          return false;
+        if (!zip215 && A.isSmallOrder())
+          return false;
+        const k = modL_LE(hashed);
+        const RkA = R.add(A.multiply(k, false));
+        return RkA.add(SB.negate()).clearCofactor().is0();
+      };
+      return { hashable, finish };
+    };
+    verifyAsync = async (s, m, p, opts = veriOpts) => hashFinishA(_verify(s, m, p, opts));
+    verify = (s, m, p, opts = veriOpts) => hashFinishS(_verify(s, m, p, opts));
+    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
+    };
+    utils = {
+      getExtendedPublicKeyAsync,
+      getExtendedPublicKey,
+      randomPrivateKey: () => randomBytes(L),
+      precompute: (w = 8, p = G) => {
+        p.multiply(3n);
+        w;
+        return p;
+      }
+      // no-op
+    };
+    W = 8;
+    scalarBits = 256;
+    pwindows = Math.ceil(scalarBits / W) + 1;
+    pwindowSize = 2 ** (W - 1);
+    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;
+    };
+    Gpows = void 0;
+    ctneg = (cnd, p) => {
+      const n = p.negate();
+      return cnd ? n : p;
+    };
+    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 };
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Verimago: () => Verimago,
+  default: () => src_default
+});
+var import_shared = __toESM(require_dist());
+__reExport(src_exports, __toESM(require_dist()));
+import { createHash } from "crypto";
+var Verimago = class {
+  constructor(opts) {
+    const urls = (0, import_shared.getUrls)(opts.env ?? "production");
+    this.baseUrl = opts.baseUrl ?? urls.api;
+    this.apiKey = opts.apiKey;
+    this.timeout = opts.timeout ?? 1e4;
+  }
+  // ── PRIVATE ────────────────────────────────────────────────────────────
+  async request(path, init = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        signal: controller.signal,
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": "verimago-sdk/1.0.0",
+          ...init.headers
+        }
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`Verimago API ${res.status}: ${body || res.statusText}`);
+      }
+      return res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ── HASHING ────────────────────────────────────────────────────────────
+  /** Compute SHA-256 hash of a video file buffer */
+  async hashFile(file) {
+    return "sha256:" + createHash("sha256").update(file).digest("hex");
+  }
+  // ── VERIFY ─────────────────────────────────────────────────────────────
+  /**
+   * Verify a video file or hash against the Verimago registry.
+   * Accepts a Buffer, Uint8Array, or a pre-computed 'sha256:hex' string.
+   * Results are cached at the CDN layer for 4 hours.
+   */
+  async verify(fileOrHash) {
+    const hash = typeof fileOrHash === "string" ? fileOrHash : await this.hashFile(fileOrHash);
+    return this.request(`/v1/verify/${encodeURIComponent(hash)}`);
+  }
+  // ── SIGN ───────────────────────────────────────────────────────────────
+  /**
+   * Sign a video locally and return a manifest object.
+   * Does NOT publish — call publish() separately.
+   * The private key never leaves your environment.
+   */
+  async sign(file, opts) {
+    const videoHash = await this.hashFile(file);
+    const signedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const payload = JSON.stringify({
+      videoHash,
+      certId: opts.certId,
+      metadata: opts.metadata,
+      signedAt
+    });
+    const ed = await Promise.resolve().then(() => (init_ed25519(), ed25519_exports));
+    const privBytes = Buffer.from(opts.privateKey, "base64");
+    const sigBytes = await ed.signAsync(new TextEncoder().encode(payload), privBytes);
+    const signature = Buffer.from(sigBytes).toString("base64");
+    return {
+      id: "",
+      // assigned by registry on publish
+      videoHash,
+      certId: opts.certId,
+      signature,
+      metadata: opts.metadata,
+      signedAt
+    };
+  }
+  // ── PUBLISH ────────────────────────────────────────────────────────────
+  /** Publish a signed manifest to the Verimago registry */
+  async publish(manifest) {
+    return this.request("/v1/manifests", {
+      method: "POST",
+      body: JSON.stringify(manifest)
+    });
+  }
+  // ── UGC ────────────────────────────────────────────────────────────────
+  /**
+   * Submit a social media URL for UGC corroboration analysis.
+   * Returns immediately with an analysis ID; poll /v1/ugc/:id for results.
+   */
+  async analyzeUGC(url, opts = {}) {
+    return this.request("/v1/ugc/analyze", {
+      method: "POST",
+      body: JSON.stringify({ url, ...opts })
+    });
+  }
+  /** Poll for UGC analysis results */
+  async getUGCAnalysis(id) {
+    return this.request(`/v1/ugc/${id}`);
+  }
+  // ── CERTIFICATES ───────────────────────────────────────────────────────
+  /** List all verified publisher certificates */
+  async listCertificates(page = 1, pageSize = 50) {
+    return this.request(
+      `/v1/certs?page=${page}&pageSize=${pageSize}`
+    );
+  }
+  /** Get a single certificate by ID */
+  async getCertificate(certId) {
+    return this.request(`/v1/certs/${certId}`);
+  }
+  // ── HEALTH ─────────────────────────────────────────────────────────────
+  /** Check API health — useful in health-check scripts */
+  async health() {
+    return this.request("/v1/health");
+  }
+};
+var src_default = Verimago;
+export {
+  Verimago,
+  src_default as default
+};
+/*! Bundled license information:
+
+@noble/ed25519/index.js:
+  (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
+*/

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@verimago/sdk",
+  "version": "1.0.0",
+  "description": "Official Verimago SDK — verify, sign, and publish video authenticity certificates",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import":  "./dist/index.mjs",
+      "types":   "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc && npm run build:esm",
+    "build:esm": "esbuild src/index.ts --bundle --format=esm --platform=browser --outfile=dist/index.mjs --external:crypto",
+    "test":  "jest --passWithNoTests",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "@noble/ed25519": "^2.0.0",
+    "@noble/hashes":  "^1.3.0",
+    "@verimago/shared": "*"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "esbuild":     "^0.20.0",
+    "jest":        "^29.0.0",
+    "ts-jest":     "^29.0.0",
+    "typescript":  "^5.3.0"
+  },
+  "publishConfig": { "access": "public" },
+  "repository": { "type": "git", "url": "https://github.com/verimago/verimago" },
+  "license": "MIT",
+  "keywords": ["video", "authenticity", "certificate", "provenance", "deepfake", "c2pa"]
+}