@telepapo/sdk 0.0.0-stage → 0.2.0

package/signal/telepapo_signal.js

@@ -0,0 +1,434 @@
+/* @ts-self-types="./telepapo_signal.d.ts" */
+
+class Signal {
+    static __wrap(ptr) {
+        const obj = Object.create(Signal.prototype);
+        obj.__wbg_ptr = ptr;
+        SignalFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignalFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signal_free(ptr, 0);
+    }
+    /**
+     * X3DH + Kyber (PQXDH): o libsignal confere as assinaturas e recusa pacote forjado.
+     * @param {string} usuario
+     * @param {string} pacote_json
+     * @param {number} ms
+     */
+    abrirSessao(usuario, pacote_json, ms) {
+        const ptr0 = passStringToWasm0(usuario, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(pacote_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.signal_abrirSessao(this.__wbg_ptr, ptr0, len0, ptr1, len1, ms);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} usuario
+     * @param {number} dispositivo
+     */
+    apagarSessao(usuario, dispositivo) {
+        const ptr0 = passStringToWasm0(usuario, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.signal_apagarSessao(this.__wbg_ptr, ptr0, len0, dispositivo);
+    }
+    /**
+     * @param {string} json
+     * @returns {Signal}
+     */
+    static carregar(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signal_carregar(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Signal.__wrap(ret[0]);
+    }
+    /**
+     * Pacote inicial (o `chaves` do pedido de vínculo), no formato da API.
+     * @param {number} ms
+     * @returns {string}
+     */
+    chavesIniciais(ms) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.signal_chavesIniciais(this.__wbg_ptr, ms);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Cifra para um aparelho: `{tipo: PREKEY|WHISPER, conteudo, registrationId}`.
+     * @param {string} usuario
+     * @param {number} dispositivo
+     * @param {Uint8Array} claro
+     * @param {number} ms
+     * @returns {string}
+     */
+    cifrar(usuario, dispositivo, claro, ms) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(usuario, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(claro, wasm.__wbindgen_malloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.signal_cifrar(this.__wbg_ptr, ptr0, len0, dispositivo, ptr1, len1, ms);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Decifra um envelope. Erro com "duplicate" no texto = mensagem repetida.
+     * @param {string} usuario
+     * @param {number} dispositivo
+     * @param {string} tipo
+     * @param {string} conteudo_b64
+     * @returns {Uint8Array}
+     */
+    decifrar(usuario, dispositivo, tipo, conteudo_b64) {
+        const ptr0 = passStringToWasm0(usuario, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(tipo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(conteudo_b64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.signal_decifrar(this.__wbg_ptr, ptr0, len0, dispositivo, ptr1, len1, ptr2, len2);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v4;
+    }
+    /**
+     * Depois do vínculo: o endereço deste navegador.
+     * @param {string} usuario
+     * @param {number} dispositivo
+     */
+    definirEndereco(usuario, dispositivo) {
+        const ptr0 = passStringToWasm0(usuario, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signal_definirEndereco(this.__wbg_ptr, ptr0, len0, dispositivo);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Números dos aparelhos de alguém com quem há sessão.
+     * @param {string} usuario
+     * @returns {Uint32Array}
+     */
+    dispositivosComSessao(usuario) {
+        const ptr0 = passStringToWasm0(usuario, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signal_dispositivosComSessao(this.__wbg_ptr, ptr0, len0);
+        var v2 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v2;
+    }
+    /**
+     * @returns {string}
+     */
+    exportar() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.signal_exportar(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Chave pública de identidade (base64): vai no QR para o celular conferir.
+     * @returns {string}
+     */
+    identidadePublica() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.signal_identidadePublica(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Contatos que trocaram de identidade desde a última leitura.
+     * @returns {string[]}
+     */
+    lerTrocas() {
+        const ret = wasm.signal_lerTrocas(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Identidade nova (navegador nunca vinculado).
+     * @returns {Signal}
+     */
+    static novo() {
+        const ret = wasm.signal_novo();
+        return Signal.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    registrationId() {
+        const ret = wasm.signal_registrationId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Reposição de pré-chaves (`PUT /v1/chaves`).
+     * @param {number} ms
+     * @param {number} pre_keys
+     * @param {number} kyber
+     * @returns {string}
+     */
+    reposicao(ms, pre_keys, kyber) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.signal_reposicao(this.__wbg_ptr, ms, pre_keys, kyber);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Signal.prototype[Symbol.dispose] = Signal.prototype.free;
+exports.Signal = Signal;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_getRandomValues_a608c4436c19407a: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./telepapo_signal_bg.js": import0,
+    };
+}
+
+const SignalFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signal_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/telepapo_signal_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/signal/telepapo_signal_bg.wasm.d.ts

@@ -0,0 +1,27 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_signal_free: (a: number, b: number) => void;
+export const signal_abrirSessao: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+export const signal_apagarSessao: (a: number, b: number, c: number, d: number) => void;
+export const signal_carregar: (a: number, b: number) => [number, number, number];
+export const signal_chavesIniciais: (a: number, b: number) => [number, number, number, number];
+export const signal_cifrar: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
+export const signal_decifrar: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
+export const signal_definirEndereco: (a: number, b: number, c: number, d: number) => [number, number];
+export const signal_dispositivosComSessao: (a: number, b: number, c: number) => [number, number];
+export const signal_exportar: (a: number) => [number, number, number, number];
+export const signal_identidadePublica: (a: number) => [number, number, number, number];
+export const signal_lerTrocas: (a: number) => [number, number];
+export const signal_novo: () => number;
+export const signal_registrationId: (a: number) => number;
+export const signal_reposicao: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __externref_drop_slice: (a: number, b: number) => void;
+export const __wbindgen_start: () => void;

package/src/anexos.js

@@ -0,0 +1,38 @@
+// Anexos no mesmo esquema do app e do TelePapo Web (o do Signal):
+// AES-256-CBC + HMAC-SHA256. A chave (64 bytes: 32 de AES, 32 de HMAC) e o
+// digest viajam só dentro da mensagem cifrada; o servidor guarda
+// `iv | cifrado | mac` e nada mais.
+import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+
+export function cifrarAnexo(dado, chave) {
+  const iv = randomBytes(16);
+  const c = createCipheriv('aes-256-cbc', chave.subarray(0, 32), iv);
+  const corpo = Buffer.concat([iv, c.update(dado), c.final()]);
+  const mac = createHmac('sha256', chave.subarray(32, 64)).update(corpo).digest();
+  return Buffer.concat([corpo, mac]);
+}
+
+export function decifrarAnexo(blob, chave) {
+  if (blob.length < 16 + 16 + 32) throw new Error('Anexo curto demais.');
+  const corpo = blob.subarray(0, blob.length - 32);
+  // MAC conferido ANTES de decifrar: CBC sem MAC aceita blob adulterado.
+  const mac = createHmac('sha256', chave.subarray(32, 64)).update(corpo).digest();
+  if (!timingSafeEqual(mac, blob.subarray(blob.length - 32))) throw new Error('Anexo adulterado (MAC).');
+  const d = createDecipheriv('aes-256-cbc', chave.subarray(0, 32), corpo.subarray(0, 16));
+  return Buffer.concat([d.update(corpo.subarray(16)), d.final()]);
+}
+
+/** Cifra e devolve o blob e o que vai na mensagem ({chave, digest} em base64). */
+export function prepararAnexo(dado) {
+  const chave = randomBytes(64);
+  const blob = cifrarAnexo(Buffer.from(dado), chave);
+  return { blob, chave: chave.toString('base64'), digest: createHash('sha256').update(blob).digest('base64') };
+}
+
+/** Confere o digest (vindo da mensagem cifrada) e decifra. */
+export function abrirAnexo(blob, anexo) {
+  const digest = createHash('sha256').update(blob).digest();
+  const esperado = Buffer.from(anexo.digest ?? '', 'base64');
+  if (digest.length !== esperado.length || !timingSafeEqual(digest, esperado)) throw new Error('Anexo adulterado (digest).');
+  return decifrarAnexo(blob, Buffer.from(anexo.chave, 'base64'));
+}

package/src/armazenamento.js

@@ -0,0 +1,57 @@
+// Onde o SDK guarda o estado de cada conta autorizada: tokens e o estado do
+// Signal (chaves PRIVADAS do aparelho do app e as sessões). Guarde em lugar
+// seguro (disco cifrado, banco com controle de acesso): quem tem esse estado
+// lê as mensagens das contas.
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+/** Para testes e protótipos: some ao reiniciar o processo. */
+export class ArmazenamentoMemoria {
+  constructor() {
+    this.dados = new Map();
+  }
+
+  async ler(chave) {
+    return this.dados.get(chave) ?? null;
+  }
+
+  async gravar(chave, valor) {
+    this.dados.set(chave, valor);
+  }
+
+  async apagar(chave) {
+    this.dados.delete(chave);
+  }
+}
+
+/** Um arquivo JSON por chave, numa pasta (gravação atômica). */
+export class ArmazenamentoArquivo {
+  constructor(pasta) {
+    this.pasta = pasta;
+  }
+
+  caminho(chave) {
+    return join(this.pasta, encodeURIComponent(chave) + '.json');
+  }
+
+  async ler(chave) {
+    try {
+      return JSON.parse(await readFile(this.caminho(chave), 'utf8'));
+    } catch (e) {
+      if (e.code === 'ENOENT') return null;
+      throw e;
+    }
+  }
+
+  async gravar(chave, valor) {
+    await mkdir(this.pasta, { recursive: true, mode: 0o700 });
+    const tmp = this.caminho(chave) + '.tmp';
+    await writeFile(tmp, JSON.stringify(valor), { mode: 0o600 });
+    await rename(tmp, this.caminho(chave));
+  }
+
+  async apagar(chave) {
+    const { rm } = await import('node:fs/promises');
+    await rm(this.caminho(chave), { force: true });
+  }
+}

package/src/categoria.js

@@ -0,0 +1,43 @@
+// Categoria e impressão que vão em claro para o servidor (estatística e
+// detecção de spam). Precisam dar EXATAMENTE o que o app Android calcula: o
+// app de quem recebe confere e, se não bater, avisa o servidor que o
+// remetente mentiu. Ver Mensageiro.kt (categoria, impressao).
+
+// Mesmo padrão de link do app (Previas.kt).
+const LINK = /\b((?:https?:\/\/|www\.)[^\s<>"']+[^\s<>"'.,;:!?)\]])/i;
+// `\s` do Java é só ASCII; o do JavaScript pega espaços Unicode. Igual ao app:
+const ESPACOS = /[ \t\n\x0B\f\r]+/g;
+const SEM_ACENTO = /\p{M}+/gu;
+
+export function categoria(c) {
+  switch (c.tipo) {
+    case 'texto':
+      return c.previa || LINK.test(c.texto ?? '') ? 'link' : 'texto';
+    case 'midia': {
+      const mime = c.anexo?.mime ?? '';
+      if (c.figurinha) return 'figurinha';
+      if (c.gif) return 'gif';
+      if (c.recado) return 'recado_video';
+      if (c.unica) return 'visualizacao_unica';
+      if (mime.startsWith('image/')) return 'foto';
+      if (mime.startsWith('video/')) return 'video';
+      if (mime.startsWith('audio/')) return 'audio';
+      return 'documento';
+    }
+    case 'localizacao': case 'contato': case 'produto': case 'reacao': case 'recibo': case 'apagar': case 'chamada': case 'animacao':
+      return c.tipo;
+    default:
+      return 'controle';
+  }
+}
+
+/** 20 bits de SHA-256 do texto normalizado, em 5 dígitos hexadecimais. */
+export async function impressao(c) {
+  const cat = categoria(c);
+  if (cat !== 'texto' && cat !== 'link') return null;
+  const normal = (c.texto ?? '').normalize('NFKD').replace(SEM_ACENTO, '').toLowerCase().replace(ESPACOS, ' ').trim();
+  if (!normal) return null;
+  const h = new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode('telepapo-impressao-v1\n' + normal)));
+  const v = (h[0] << 12) | (h[1] << 4) | (h[2] >> 4);
+  return v.toString(16).padStart(5, '0');
+}