Pular para o conteúdo
jsonW Início GitHub

jsonW 1.4.2 · provas medidas

Transparência de testes

Wortic Tecnologia · atualizada em 19 de novembro de 2026

Cada número que publicamos sobre o jsonW saiu de uma medida registrada. Aqui está cada uma: o que medimos, o resultado, a data, a máquina, o método, o comando para você refazer e a saída bruta.

Provas
  1. 1. Velocidade e tamanho
  2. 2. Base real do INPI
  3. 3. Busca por chave
  4. 4. Leitura remota parcial
  5. 5. Custódia
  6. 6. Visão por permissão
  7. 7. Cifra em repouso
  8. 8. Medida, dinheiro e documentos
  9. 9. Perfis de protocolos
  10. 10. Transmissão pós-quântica
  11. 11. SuperVendor sobre jsonW
  12. 12. Modelos de IA da Wortic
  13. 13. Como refazer tudo

Em números

6,6×menor que o JSONL, 100 mil registros
1.886×mais rápido para ler uma coluna (mediana de 10)
613×busca por chave com índice contra a varredura, 1 milhão de linhas
12,8×menor que o XML na base inteira do INPI
49 de 49objetos de protocolos com ida e volta igual
100%de acerto em 2 modelos de IA da Wortic

1Velocidade e tamanho: 100 mil registros

O jsonW contra o mesmo conjunto em JSONL: 100 mil cartões de base de conhecimento, com texto, decimal, lista e um vetor de 384 dimensões. O .jsw grava 124 vezes mais rápido, lê tudo 48 vezes mais rápido, lê uma coluna 1.886 vezes mais rápido e ocupa 6,6 vezes menos. Em toda execução a ferramenta confere que as duas leituras contaram 100 mil linhas com a mesma soma.

Tempo. Mediana de 10 execuções; razão = JSONL ÷ jsonW em cada execução, com a mediana e a faixa das 10.
OperaçãoJSONLjsonW 1.4.2Razão (faixa)
Gravar15.312 ms130 ms124× (94 a 136)
Ler tudo, todos os campos3.756 ms79 ms48× (35 a 51)
Ler tudo, 8 threads (o JSONL em uma)3.756 ms8,4 ms453× (262 a 598)
Ler uma coluna3.756 ms2,00 ms1.886× (1.487 a 2.542)
Ir direto à linha N, um campoler do começo0,075 µs
Uma mensagem na forma linha5.157 B1.073 B4,8× (nas 10)
Tamanho. Os mesmos 100 mil registros, em MB (106 bytes); razão = JSONL ÷ o arquivo.
ArquivoTamanhoRazão
JSONL519,31,0×
.jsw, vetor vf16, nível padrão79,16,6×
.jsw, vetor vq841,112,6×
.jsw, vetor vf16, --max1,36381×
.jsw sem a coluna de vetor, --max0,01752.185× (contra 38,2 MB)
  • Data: 19/11/2026, entre 23:00 e 23:06 UTC (tempos); tamanhos às 23:06 UTC.
  • Versão: jsonW 1.4.2 público, bin/linux-x86_64/wjsw da tag v1.4.2, SHA-256 3e4e587b7153e69875c6e946a1596d99207ace61c41f016603f966a924e43e55.
  • Máquina: servidor virtual AMD EPYC 9355P, 8 vCPUs, 18 GB de memória, Linux 7.3; arquivos num tmpfs.
  • Método: wjsw medir com 100 mil linhas, 10 execuções seguidas; tamanhos pelo gerar-cartoes.awk e wjsw de-texto, custódia dos 6 arquivos conferida (ok: 100000 linhas em todos). O lado JSON é gravado e lido pelo leitor de texto do próprio jsonW.
  • Saídas brutas: medir-01 a medir-10, tamanhos, custódia e máquina.
git clone --branch v1.4.2 https://github.com/developer-wortic/jsonw && cd jsonw
export JSONW_SEM_PING=1
for i in $(seq 1 10); do bin/linux-x86_64/wjsw medir /tmp 100000; done

2Base real do INPI: 55,3 milhões de linhas

Os sete arquivos dos dados abertos de marcas do INPI, convertidos 1:1, sem cortar nada: 55.278.212 linhas e 12,53 GB de CSV. Em .jsw a base ficou 4,9 vezes menor que o CSV no nível padrão, 6,5 vezes no nível máximo e 12,8 vezes menor que o XML, com o SHA-256 e o CRC32C de todos os blocos dos sete arquivos conferidos. Na contagem dos registros em vigor, o .jsw respondeu em 43 ms, à frente do Parquet lido pelo DuckDB, do DuckDB lendo o CSV, do grep e do CSV comprimido, com a resposta certa: 2.343.607.

Contar os registros em vigor (codigo_situacao = IPAS023, 6,7 milhões de processos), em ms, o menor de 5, todos na mesma hora.
Formato e leitorTempoResposta
.jsw --max 1.3.11, wjsw calcular --onde432.343.607
.jsw 1.3.11, wjsw calcular --onde442.343.607
Parquet, DuckDB 2.0.0, 8 núcleos542.343.607
CSV, DuckDB 2.0.0, 8 núcleos3752.343.607
CSV, grep -c5192.343.607
CSV + zstd, zstd -dc | grep -c7982.343.607
  • Data: 13/11/2026, 06:21 UTC (quinta rodada); dados do INPI baixados em 12/11/2026.
  • Versão: wjsw 1.3.11 do lançamento; a 1.4.2 lê os mesmos arquivos.
  • Máquina: servidor de 8 núcleos, 31 GB de memória, Linux 7.3.
  • Método: esquema escrito à mão para cada arquivo; o conversor em C confere cada número e data contra o texto do CSV; cada consulta rodou 5 vezes com o arquivo em cache e vale a menor; Parquet gravado e lido pelo DuckDB 2.0.0 com zstd.
  • Onde está: Tabelas 5C e 5D do paper.
curl -O https://dadosabertos.inpi.gov.br/download/marcas/marcas.zip
# cada CSV convertido para .jsw com um esquema escrito à mão, como na Seção 5.4 do paper
wjsw calcular MARCAS_DADOS_BIBLIOGRAFICOS.jsw --onde "codigo_situacao = IPAS023"
wjsw conferir MARCAS_DADOS_BIBLIOGRAFICOS.jsw

3Busca por chave: 1 milhão de linhas

A busca por chave da ABI, num arquivo de um milhão de linhas, mediana de 200 buscas por id: 77,4 ms varrendo a coluna e 0,126 ms pelo índice, 613 vezes mais rápido, com 0 respostas erradas nas 400 buscas. O índice levou 160 ms para montar, uma vez. O mesmo programa roda os casos de prova (chave única, repetida, ausente, tipo errado e a visão por tenant) e termina com TUDO CERTO (0 falhas).

  • Data: 19/11/2026, 23:07 UTC.
  • Versão: sdk/prova_chave.c do repositório, ligado à libjsonw.a 1.4.2 pública.
  • Máquina: a mesma da prova 1.
  • Resultado: varredura mediana 77,3590 ms, p95 88,8815 ms; índice mediana 0,1263 ms, p95 0,2122 ms; gravar o milhão de linhas, 535 ms.
  • Saída bruta: saidas-1.4.2.txt, seção "busca por chave".
cc -O2 -Isdk -o prova_chave sdk/prova_chave.c bin/linux-x86_64/libjsonw.a -lpthread -lm
./prova_chave                 # os casos de prova
./prova_chave --medir 1000000 # a medida

4Leitura remota parcial

O wremoto abre um .jsw de 79,1 MB baixando 8,7 KB (cabeçalho e rodapé). Para ler a linha 50.000 baixa 0,98% do arquivo; para o filtro id > 99990, 0,84%, porque as zonas descartam os outros blocos antes do download. Na leitura local, o mesmo filtro pula 102 de 103 blocos e responde em 0,9 ms.

  • Data: 19/11/2026, 23:07 UTC. Versão: wremoto e wjsw 1.4.2. Máquina: a mesma da prova 1.
  • Método: o arquivo de 100 mil registros da prova 1, lido pelo endereço file://, com os mesmos pedidos por faixa de bytes que o wremoto faz a um servidor HTTP, ao R2 ou ao S3; o próprio wremoto conta os bytes baixados.
  • Saída bruta: saidas-1.4.2.txt, "Listagem 6".
$ wremoto ver file://$PWD/com.jsw 50000 1
baixado no total: 777.8 KB em 5 pedidos (0.98% do arquivo)
$ wremoto filtrar file://$PWD/com.jsw 'id > 99990'
baixado no total: 667.7 KB em 5 pedidos (0.84% do arquivo)

5Custódia: nenhum byte muda sem aviso

Um byte trocado no meio do arquivo falha no conferir; um arquivo cortado no fim, como numa gravação interrompida, é apontado e o reparar o devolve inteiro; a cadeia funciona com SHA-256 e com BLAKE3.

$ wjsw conferir vendas.jsw
ok: 2 linhas, 1 blocos, sha256 e crc32c conferidos
$ wjsw conferir adulterado.jsw
FALHOU: bloco 0: nao veio ou nao confere
$ wjsw conferir cortado.jsw
FALHOU: sem rodape: rode wjsw reparar
$ wjsw reparar cortado.jsw && wjsw conferir cortado.jsw
ok
ok: 2 linhas, 1 blocos, sha256 e crc32c conferidos
$ wjsw regravar vendas.jsw vendas-b3.jsw --hash blake3 && wjsw conferir vendas-b3.jsw
2 linhas: 708 -> 708 bytes (100.0%), 0.0 s
ok: 2 linhas, 1 blocos, blake3 e crc32c conferidos
  • Data: 19/11/2026, 23:07 UTC. Versão: wjsw 1.4.2. Máquina: a mesma da prova 1.
  • Método: adulterado.jsw = um X gravado no terço do arquivo com dd; cortado.jsw = o arquivo sem os 20 últimos bytes. Entradas em jsonw.org/paper/exemplos.
  • Saída bruta: saidas-1.4.2.txt, "Listagem 7".

6Visão por permissão em todo comando

Num arquivo de clínica com CPF marcado +pessoal, valor marcado +escopo(financeiro) e uma coluna tenant, cada credencial vê só o que pode: a recepção da unidade 1 vê a agenda da unidade 1 sem CPF e sem valor; o financeiro vê o valor; ninguém da unidade 1 vê a unidade 2. Sem escopo, o para-texto entrega CPF e valor nulos, e o filtro pelo CPF é recusado. Na nossa prova da visão por linha de comando, a 1.4.1 passa as 37 verificações.

$ WJSW_ESCOPOS="tenant:1" wjsw ver clin.jsw
{paciente:"Ana Souza",cpf:null,valor:null,data:t"2026-11-12T13:00:00.000000Z",tenant:1}
{paciente:"Carla Dias",cpf:null,valor:null,data:t"2026-11-12T15:30:00.000000Z",tenant:1}
$ WJSW_ESCOPOS="financeiro tenant:1" wjsw ver clin.jsw
{paciente:"Ana Souza",cpf:null,valor:180.00 BRL,data:t"2026-11-12T13:00:00.000000Z",tenant:1}
{paciente:"Carla Dias",cpf:null,valor:180.00 BRL,data:t"2026-11-12T15:30:00.000000Z",tenant:1}
$ wjsw filtrar clin.jsw "cpf = 012.345.678-90"
coluna sem permissao: cpf (exige escopo)
  • Data: 19/11/2026, 23:07 UTC, com o wjsw 1.4.2 (as listagens); 37 de 37 com a 1.4.1 em macOS arm64, na publicação da 1.4.1 em 15/11/2026, registrado no README do pacote.
  • Máquina: a mesma da prova 1. Dados da clínica fictícios, em clin.jsonl.
  • Saída bruta: saidas-1.4.2.txt, "Listagem 8".

7Cifra em repouso

Um .jsw cifrado com XChaCha20-Poly1305 e uma chave de 256 bits fora do arquivo não abre sem a chave, nem para conferir nem para ler; com a chave, a custódia confere e as linhas voltam. Trocamos um byte do arquivo cifrado em três posições: nas três, o conferir e o para-texto recusaram o arquivo.

$ wjsw cifrar cifrado.jsw --chave chave.hex
$ wjsw conferir cifrado.jsw
FALHOU: arquivo cifrado: falta a chave do tenant (WJSW_CHAVE_ARQ ou credencial wjsw-chave)
$ wjsw conferir cifrado.jsw --chave chave.hex
ok: 1 linhas, 1 blocos, sha256 e crc32c conferidos
# um byte trocado na posição 238 de 716
$ wjsw conferir troca.jsw --chave chave.hex
FALHOU: bloco cifrado nao e o que o indice assinou
  • Data: 19/11/2026, 23:13 UTC. Versão: wjsw 1.4.2. Máquina: a mesma da prova 1.
  • Método: chave de teste gerada na hora com /dev/urandom, nunca impressa e apagada no fim; posições 238, 358 e 477 de 716 bytes.
  • Roteiro e saída bruta: provar-cifra.sh e saidas-cifra-1.4.2.txt.

8Medida, dinheiro e documentos

A coluna de medida guarda o valor convertido sem perda: 1 lb vira 0.45359237 kg numa coluna medida[kg], e 1 mi vira 1609.344 m numa medida[m]. O calcular --valor soma dinheiro em centavos inteiros e devolve a moeda: 12,50 + 0,25 = 12.75 BRL. A coluna mascara(cpf) aceita o CPF com e sem pontuação, guarda a mesma forma canônica e recusa o CPF com dígito verificador errado.

$ wjsw de-texto "id:i64,peso:medida[kg],preco:dinheiro" m.jsonl m.jsw && wjsw ver m.jsw
2 linhas -> m.jsw
{id:1,peso:0.45359237 kg,preco:12.50 BRL}
{id:2,peso:0.90718474 kg,preco:0.25 BRL}
$ wjsw calcular m.jsw --valor preco
1 grupo(s) em 0.4 ms
total: 2 linha(s) · soma 12.75 BRL · min 0.25 · max 12.5 · media 6.375
$ wjsw de-texto "id:i64,cpf:mascara(cpf),cnpj:mascara(cnpj)" docs.jsonl docs.jsw && wjsw para-texto docs.jsw
2 linhas -> docs.jsw
{id:1,cpf:"12345678909",cnpj:"11222333000181"}
{id:2,cpf:"12345678909",cnpj:"11222333000181"}
  • Data: 19/11/2026, 23:07 UTC. Versão: wjsw 1.4.2. Máquina: a mesma da prova 1.
  • Saída bruta: saidas-1.4.2.txt, seções "1.4.2" e "1.4.0: máscaras".

9Perfis de protocolos de agentes e de comércio

49 objetos de A2A, UCP, ACP, AP2, Verifiable Intent, x402, MPP, AG-UI, OpenTelemetry, L402 e Pix, cada um gravado em .jsw com o esquema do perfil, conferido pela custódia e devolvido em JSON byte a byte igual à amostra: 49 ok, 0 falhas.

$ bash perfis/provar-perfis.sh bin/linux-x86_64/wjsw | tail -1
perfis: 49 ok, 0 falhas
  • Data: 19/11/2026, 23:07 UTC. Versão: wjsw 1.4.2 e a pasta perfis/ da tag v1.4.2. Máquina: a mesma da prova 1.

10Transmissão pós-quântica

A conexão com jsonw.org negocia a troca de chaves híbrida X25519MLKEM768 (X25519 com o ML-KEM-768 da FIPS 203), com TLS 1.3 e a cifra TLS_AES_256_GCM_SHA384.

$ openssl version
OpenSSL 4.1.0 23 Oct 2026 (Library: OpenSSL 4.1.0 23 Oct 2026)
$ echo | openssl s_client -connect jsonw.org:443 -servername jsonw.org 2>&1 | grep -E "Negotiated|Cipher is"
Negotiated TLS1.3 group: X25519MLKEM768
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
  • Data: 19/11/2026, 23:04 UTC. Máquina: servidor Linux no Brasil, OpenSSL 4.1.0.

11SuperVendor: a busca em C sobre jsonW

A busca de empresas do SuperVendor, reescrita em C sobre arquivos jsonW, devolveu a mesma resposta que a busca antiga no banco de dados em 18 de 18 pedidos, inclusive 4 pedidos de WhatsApp. Tempo da busca em C: de 55 a 1.562 ms por pedido; no banco: de 83 a 90.010 ms.

  • Data: 13/11/2026, 13:45. Máquina: o servidor de produção da Wortic, numa instância paralela com o SHA-256 do processo conferido antes da prova.
  • Método: o mesmo pedido mandado às duas buscas e as respostas comparadas uma a uma; roteiro prova-sv-busca.sh, registrado no relatório da sessão de 13/11/2026.

12Modelos de IA da Wortic

Os modelos de IA da Wortic respondem a partir de bases de conhecimento em jsonW. Cada um é medido contra o seu gabarito: uma pergunta conta como certa quando o modelo decide e a primeira resposta está entre as aceitas no gabarito; numa pergunta fora do conhecimento, conta como certa quando o modelo diz que não sabe.

Acerto por modelo. Régua de 16/11/2026; tempo de resposta por pergunta em microssegundos (mediana e p95).
ModeloPerguntasCertasAcertoMedianap95
Adam ESG96795799,0%546 µs729 µs
Gestão SaaS22021999,5%191 µs436 µs
Roteiro181181100%378 µs593 µs
Site Construtor16415795,7%233 µs415 µs
SuperVendor151151100%379 µs642 µs
  • Data: 16/11/2026, cerca de 22:45. Máquina: o contêiner de compilação da Wortic no servidor de 8 núcleos, gcc 15.3.
  • Método: a régua roda todas as perguntas do gabarito de cada modelo e registra perguntas, porcentagem de acerto, top 3, top 10 e os tempos; as certas são a porcentagem aplicada ao total de perguntas.
  • Registro: arquivo da régua regua/depois.jsw.txt, em jsonW-texto, de 16/11/2026.

13Como refazer tudo

As provas 1 e 3 a 9 rodam com o pacote público, numa máquina Linux x86_64, com dois roteiros:

git clone --branch v1.4.2 https://github.com/developer-wortic/jsonw jsonw
mkdir -p exemplos-142/entradas && cd exemplos-142
for f in clin dup hoje leite marcas ontem prod termos vendas; do curl -s -o entradas/$f.jsonl https://jsonw.org/paper/exemplos/$f.jsonl; done
curl -O https://jsonw.org/paper/exemplos/rodar-exemplos.sh -O https://jsonw.org/paper/exemplos/provar-cifra.sh
bash rodar-exemplos.sh ../jsonw saidas.txt
bash provar-cifra.sh ../jsonw saidas-cifra.txt

O rodar-exemplos.sh refaz cada listagem do paper e as provas novas da 1.4.0 à 1.4.2, e escreve cada comando com a saída real embaixo. Os tempos mudam com a máquina; os resultados, as contagens e as mensagens são os mesmos. Correções e medidas de terceiros são bem-vindas pelo repositório público.