@albertomarturelo/sii-core 0.13.0 → 0.14.0

package/dist/portal/gwt.js

@@ -1,5 +1,6 @@
-// In-house GWT-RPC codec for the SISPAD peticiones read (ADR-020). No third-party GWT
-// library — the request template and the response object-graph reader are derived
+// In-house GWT-RPC codecs (ADR-020). Protocol 5 below serves the SISPAD peticiones read;
+// protocol 7 at the end of the file serves rfiInternet, the F29 submit transport (ADR-029
+// amendment). No third-party GWT library — the request template and the response object-graph reader are derived
 // first-hand from the compiled permutation (strong-name A477…, module sispadinternet,
 // GWT 2.0.3, observed 2026-07-03); the per-type field schema lives in `gwt-schema.ts`.
 // Full wire contract: docs/sii-contract/peticiones.md.
@@ -203,4 +204,619 @@ function extractExceptionMessage(body) {
     }
     return 'SII rechazó la consulta de peticiones (error de servicio).';
 }
+const STRING_CLASS = 'java.lang.String';
+// A primitive parameter or array element, by its JVM code.
+const PRIMITIVE_OP = {
+    I: 'i',
+    Z: 'z',
+    S: 'h',
+    B: 'i',
+    C: 'i',
+    J: 'l',
+    D: 'd',
+    F: 'd',
+};
+const gwtClass = (sig) => sig.split('/')[0];
+// A Java array's element op. A `String[]` element is a bare string reference, not a String
+// object (observed in SdiAAInfoUsuario's response, 2026-10-19); other `[L…;` / `[[…` elements are
+// objects; a primitive array's elements are leaves.
+const arrayElementOp = (cls) => cls === '[Ljava.lang.String;'
+    ? 's'
+    : cls[1] === 'L' || cls[1] === '['
+        ? 'o'
+        : PRIMITIVE_OP[cls[1]];
+const GWT7_ROTO = 'No se pudo interpretar el formulario de SII (scraper roto)';
+/** The protocol-7 codec over one set of layouts and one permutation's signatures. `fail` builds
+ *  the error the caller's surface raises (the F29 facade passes `F29Error`). */
+export class Gwt7Codec {
+    layouts;
+    sigs;
+    fail;
+    constructor(layouts, sigs, fail) {
+        this.layouts = layouts;
+        this.sigs = sigs;
+        this.fail = fail;
+    }
+    /** Build the `text/x-gwt-rpc` body for `call`. A class missing from the layouts or the
+     *  permutation, or a value that does not fit its layout, throws: nothing is guessed. */
+    encodeRequest(call) {
+        const table = [];
+        const index = new Map();
+        const out = [];
+        const seen = new Map();
+        // In the client, a JS string IS its value, so GWT's identity map treats two String objects
+        // with the same text as one object and writes the second as a back-reference (observed:
+        // the browser's validation request shares them; without this the layout re-encodes ~11 KB
+        // larger). Other objects keep reference identity.
+        const seenStrings = new Map();
+        let count = 0;
+        const ref = (s) => {
+            if (s === null)
+                return '0';
+            let i = index.get(s);
+            if (i === undefined) {
+                table.push(s);
+                i = table.length;
+                index.set(s, i);
+            }
+            return String(i);
+        };
+        const where = (cls, k) => `${cls}[${k}]`;
+        const leaf = (op, v, at) => {
+            if (op === 's') {
+                if (v !== null && typeof v !== 'string')
+                    throw this.err(`${at} debe ser string`);
+                out.push(ref(v));
+            }
+            else if (op === 'l') {
+                if (typeof v !== 'string')
+                    throw this.err(`${at} debe ser long (token base64)`);
+                out.push(v);
+            }
+            else if (op === 'i' || op === 'z' || op === 'h' || op === 'd') {
+                if (typeof v !== 'number' || !Number.isFinite(v))
+                    throw this.err(`${at} debe ser número`);
+                out.push(String(v));
+            }
+            else
+                throw this.err(`op desconocida ${op}`);
+        };
+        const object = (v, at) => {
+            if (v === null) {
+                out.push('0');
+                return;
+            }
+            if (typeof v !== 'object' || Array.isArray(v))
+                throw this.err(`${at} debe ser objeto`);
+            const text = v.cls === STRING_CLASS && typeof v.values[0] === 'string' ? v.values[0] : null;
+            const back = text !== null ? seenStrings.get(text) : seen.get(v);
+            if (back !== undefined) {
+                out.push(String(-(back + 1)));
+                return;
+            }
+            if (text !== null)
+                seenStrings.set(text, count);
+            seen.set(v, count++);
+            out.push(ref(this.sig(v.cls)));
+            if (v.cls.startsWith('[')) {
+                out.push(String(v.values.length));
+                const op = arrayElementOp(v.cls);
+                if (op === undefined)
+                    throw this.err(`arreglo desconocido ${v.cls}`);
+                v.values.forEach((x, k) => op === 'o' ? object(x, where(v.cls, k)) : leaf(op, x, where(v.cls, k)));
+                return;
+            }
+            const ops = this.layout('write', v.cls);
+            if (v.values.length !== ops.length) {
+                throw this.err(`${v.cls} tiene ${v.values.length} valores; su esquema, ${ops.length}`);
+            }
+            [...ops].forEach((op, k) => {
+                const x = v.values[k];
+                const at = where(v.cls, k);
+                if (op === 'o')
+                    object(x, at);
+                else if (op === 'L') {
+                    const list = this.list(x, at);
+                    out.push(String(list.length));
+                    list.forEach((item, j) => object(item, `${at}[${j}]`));
+                }
+                else if (op === 'M') {
+                    const entries = this.list(x, at);
+                    out.push(String(entries.length));
+                    entries.forEach((e, j) => {
+                        const pair = this.list(e, `${at}{${j}}`);
+                        if (pair.length !== 2)
+                            throw this.err(`${at}{${j}} debe ser [clave, valor]`);
+                        object(pair[0], `${at}{${j}}.k`);
+                        object(pair[1], `${at}{${j}}.v`);
+                    });
+                }
+                else
+                    leaf(op, x, at);
+            });
+        };
+        for (const s of [call.moduleBase, call.policy, call.service, call.method])
+            out.push(ref(s));
+        out.push(String(call.params.length));
+        for (const p of call.params)
+            out.push(ref(PRIMITIVE_OP[p.type] ? p.type : this.sig(p.type)));
+        call.params.forEach((p, k) => {
+            const at = `${call.method}#${k}`;
+            const prim = PRIMITIVE_OP[p.type];
+            if (prim)
+                leaf(prim, p.value, at);
+            else if (p.type === STRING_CLASS)
+                leaf('s', p.value, at);
+            else
+                object(p.value, at);
+        });
+        return ['7', '0', String(table.length), ...table.map(escapeGwt7), ...out].join('|') + '|';
+    }
+    /** Parse a protocol-7 request body back into a call (class names, no CRCs). The inverse of
+     *  `encodeRequest`; used to verify the encoder, and to read a captured call. */
+    decodeRequest(text) {
+        const tok = splitGwt7Tokens(text);
+        if (tok[0] !== '7')
+            throw this.err(`protocolo ${String(tok[0])}, se esperaba 7`);
+        const n = Number(tok[2]);
+        const strings = tok.slice(3, 3 + n);
+        let p = 3 + n;
+        const seen = [];
+        const next = () => {
+            if (p >= tok.length)
+                throw this.err('fin de datos inesperado');
+            return tok[p++];
+        };
+        const int = () => {
+            const t = next();
+            if (!/^-?\d+$/.test(t))
+                throw this.err(`se esperaba un entero, llegó "${t.slice(0, 12)}"`);
+            return Number(t);
+        };
+        const str = () => {
+            const t = int();
+            if (t === 0)
+                return null;
+            const s = strings[t - 1];
+            if (s === undefined)
+                throw this.err('referencia de string inválida');
+            return s;
+        };
+        const leaf = (op) => {
+            if (op === 's')
+                return str();
+            if (op === 'l')
+                return next();
+            if (op === 'd') {
+                const d = Number(next());
+                if (!Number.isFinite(d))
+                    throw this.err('se esperaba un double');
+                return d;
+            }
+            return int();
+        };
+        const object = () => {
+            const t = int();
+            if (t === 0)
+                return null;
+            if (t < 0) {
+                const back = seen[-t - 1];
+                if (back === undefined)
+                    throw this.err('referencia inválida');
+                return back;
+            }
+            const sig = strings[t - 1];
+            if (sig === undefined || !isSig(sig))
+                throw this.err('se esperaba una firma de tipo');
+            const node = { cls: gwtClass(sig), values: [] };
+            seen.push(node);
+            this.readInto(node, 'write', object, leaf, int);
+            return node;
+        };
+        const head = [str(), str(), str(), str()];
+        if (head.some((h) => h === null))
+            throw this.err('cabecera incompleta');
+        const types = [];
+        const count = int();
+        for (let k = 0; k < count; k++) {
+            const t = str();
+            if (t === null)
+                throw this.err('tipo de parámetro nulo');
+            types.push(PRIMITIVE_OP[t] ? t : gwtClass(t));
+        }
+        const params = types.map((type) => {
+            const prim = PRIMITIVE_OP[type];
+            return { type, value: prim ? leaf(prim) : type === STRING_CLASS ? str() : object() };
+        });
+        if (p !== tok.length)
+            throw this.err(`datos sobrantes (${tok.length - p})`);
+        const [moduleBase, policy, service, method] = head;
+        return { moduleBase, policy, service, method, params };
+    }
+    /** Decode a `//OK[…]` response into its root value, with the READ layouts. `returns` is the
+     *  method's DECLARED return type: GWT writes a `java.lang.String` or primitive return bare
+     *  (`//OK[1,["…"],0,7]`), a `void` (`V`) as nothing (`//OK[[],0,7]`), anything else as an
+     *  object. A `//EX[…]` is SII refusing the call: its
+     *  message is raised verbatim (ADR-004). Anything else is "scraper roto"; never retried. */
+    decodeResponse(text, returns) {
+        const body = text.trimStart();
+        if (body.startsWith('//EX'))
+            throw this.fail(gwt7ExceptionMessage(body));
+        if (!body.startsWith('//OK'))
+            throw this.err('la respuesta no es //OK');
+        const { payload, strings } = this.envelope(body);
+        let p = payload.length - 1;
+        const seen = [];
+        const tok = () => {
+            if (p < 0)
+                throw this.err('fin de datos inesperado');
+            return payload[p--];
+        };
+        const int = () => {
+            const t = tok();
+            if (typeof t !== 'number')
+                throw this.err('se esperaba un número');
+            return t;
+        };
+        const leaf = (op) => {
+            if (op === 's') {
+                const t = int();
+                return t > 0 ? (strings[t - 1] ?? null) : null;
+            }
+            if (op === 'l') {
+                const t = tok();
+                if (typeof t !== 'string')
+                    throw this.err('se esperaba un long');
+                return t;
+            }
+            return int();
+        };
+        const object = () => {
+            const t = int();
+            if (t === 0)
+                return null;
+            if (t < 0) {
+                const back = seen[-t - 1];
+                if (back === undefined)
+                    throw this.err('referencia inválida');
+                return back;
+            }
+            const sig = strings[t - 1];
+            if (sig === undefined || !isSig(sig))
+                throw this.err('se esperaba una firma de tipo');
+            const node = { cls: gwtClass(sig), values: [] };
+            seen.push(node);
+            this.readInto(node, 'read', object, leaf, int);
+            return node;
+        };
+        const prim = returns === undefined ? undefined : PRIMITIVE_OP[returns];
+        const root = returns === 'V' ? null : prim ? leaf(prim) : returns === STRING_CLASS ? leaf('s') : object();
+        if (p !== -1)
+            throw this.err('datos sobrantes');
+        return root;
+    }
+    // Shared by both readers: fill `node` per its class (array, or layout ops).
+    readInto(node, side, object, leaf, int) {
+        if (node.cls.startsWith('[')) {
+            const n = int();
+            const op = arrayElementOp(node.cls);
+            if (op === undefined)
+                throw this.err(`arreglo desconocido ${node.cls}`);
+            for (let k = 0; k < n; k++)
+                node.values.push(op === 'o' ? object() : leaf(op));
+            return;
+        }
+        for (const op of this.layout(side, node.cls)) {
+            if (op === 'o')
+                node.values.push(object());
+            else if (op === 'L') {
+                const n = int();
+                const list = [];
+                for (let k = 0; k < n; k++)
+                    list.push(object());
+                node.values.push(list);
+            }
+            else if (op === 'M') {
+                const n = int();
+                const entries = [];
+                for (let k = 0; k < n; k++)
+                    entries.push([object(), object()]);
+                node.values.push(entries);
+            }
+            else
+                node.values.push(leaf(op));
+        }
+    }
+    envelope(body) {
+        let arr;
+        try {
+            arr = parseJsLiteral(body.slice(4));
+        }
+        catch {
+            throw this.err('literal inválido');
+        }
+        if (!Array.isArray(arr) || arr.length < 3 || arr[arr.length - 1] !== 7) {
+            throw this.err('sobre de respuesta inesperado');
+        }
+        const strings = arr[arr.length - 3];
+        if (!Array.isArray(strings) || strings.some((s) => typeof s !== 'string')) {
+            throw this.err('sin tabla de strings');
+        }
+        const payload = arr.slice(0, arr.length - 3);
+        if (payload.some((t) => typeof t !== 'number' && typeof t !== 'string')) {
+            throw this.err('datos con forma inesperada');
+        }
+        return { payload: payload, strings: strings };
+    }
+    layout(side, cls) {
+        const ops = this.layouts[side][cls];
+        if (ops === undefined)
+            throw this.err(`tipo sin esquema: ${cls}`);
+        return ops;
+    }
+    sig(cls) {
+        const sig = this.sigs[cls];
+        if (sig === undefined)
+            throw this.err(`tipo sin firma en la permutación: ${cls}`);
+        return sig;
+    }
+    list(v, at) {
+        if (!Array.isArray(v))
+            throw this.err(`${at} debe ser una lista`);
+        return v;
+    }
+    err(detail) {
+        return this.fail(`${GWT7_ROTO} (${detail})`);
+    }
+}
+// The client's string escaping, observed in the permutation (the writer's quoting fns): NUL,
+// '|' and '\' always, plus a user-agent-dependent set of ranges written as \uXXXX. The WebKit
+// set reproduces the captured Chromium requests byte for byte; the server reads any \uXXXX.
+const GWT7_ESCAPE = /[\u0000|\\\u0300-\u03ff\u0590-\u05FF\u0600-\u06ff\u0730-\u074A\u07eb-\u07f3\u0940-\u0963\u0980-\u09ff\u0a00-\u0a7f\u0b00-\u0b7f\u0e00-\u0e7f\u0f00-\u0fff\u1900-\u194f\u1a00-\u1a1f\u1b00-\u1b7f\u1cda-\u1cdc\u1dc0-\u1dff\u1f00-\u1fff\u2000-\u206f\u20d0-\u20ff\u2100-\u214f\u2300-\u23ff\u2a00-\u2aff\u3000-\u303f\uaab2-\uaab4\uD800-\uFFFF]/g;
+function escapeGwt7(s) {
+    return s.replace(GWT7_ESCAPE, (ch) => {
+        const c = ch.charCodeAt(0);
+        if (c === 0)
+            return '\\0';
+        if (c === 0x5c)
+            return '\\\\';
+        if (c === 0x7c)
+            return '\\!';
+        return '\\u' + c.toString(16).padStart(4, '0');
+    });
+}
+function splitGwt7Tokens(text) {
+    const out = [];
+    let cur = '';
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '\\') {
+            const n = text[++i];
+            if (n === 'u') {
+                cur += String.fromCharCode(parseInt(text.slice(i + 1, i + 5), 16));
+                i += 4;
+            }
+            else
+                cur += n === '!' ? '|' : n === '0' ? '\u0000' : (n ?? '');
+        }
+        else if (ch === '|') {
+            out.push(cur);
+            cur = '';
+        }
+        else
+            cur += ch;
+    }
+    if (cur !== '')
+        out.push(cur);
+    return out;
+}
+/** Parse the JS literal of a protocol-7 response: arrays, numbers, '…' / "…" strings (with
+ *  \xNN, \uNNNN and the usual escapes), plus GWT's two splits for large payloads: "…"+"…" and
+ *  […].concat([…],…). Exported for tests. */
+export function parseJsLiteral(src) {
+    let i = 0;
+    const ws = () => {
+        while (i < src.length && /\s/.test(src[i]))
+            i++;
+    };
+    const fail = (what) => {
+        throw new Error(`${what} at ${i}`);
+    };
+    const ESC = {
+        n: '\n',
+        t: '\t',
+        r: '\r',
+        b: '\b',
+        f: '\f',
+        v: '\v',
+        '0': '\0',
+    };
+    const string = () => {
+        const q = src[i++];
+        let s = '';
+        while (src[i] !== q) {
+            if (i >= src.length)
+                fail('unterminated string');
+            if (src[i] === '\\') {
+                const n = src[i + 1];
+                if (n === 'x') {
+                    s += String.fromCharCode(parseInt(src.slice(i + 2, i + 4), 16));
+                    i += 4;
+                }
+                else if (n === 'u') {
+                    s += String.fromCharCode(parseInt(src.slice(i + 2, i + 6), 16));
+                    i += 6;
+                }
+                else {
+                    s += ESC[n] ?? n;
+                    i += 2;
+                }
+            }
+            else
+                s += src[i++];
+        }
+        i++;
+        ws();
+        if (src[i] === '+') {
+            i++;
+            ws();
+            if (src[i] !== '"' && src[i] !== "'")
+                fail('bad string concatenation');
+            return s + string();
+        }
+        return s;
+    };
+    const value = () => {
+        ws();
+        const ch = src[i];
+        if (ch === '[') {
+            i++;
+            let arr = [];
+            ws();
+            if (src[i] === ']')
+                i++;
+            else {
+                for (;;) {
+                    arr.push(value());
+                    ws();
+                    if (src[i] === ',')
+                        i++;
+                    else if (src[i] === ']') {
+                        i++;
+                        break;
+                    }
+                    else
+                        fail('bad array');
+                }
+            }
+            ws();
+            while (src.startsWith('.concat(', i)) {
+                i += 8;
+                for (;;) {
+                    const part = value();
+                    if (!Array.isArray(part))
+                        fail('concat of a non-array');
+                    arr = arr.concat(part);
+                    ws();
+                    if (src[i] === ',')
+                        i++;
+                    else if (src[i] === ')') {
+                        i++;
+                        break;
+                    }
+                    else
+                        fail('bad concat');
+                }
+                ws();
+            }
+            return arr;
+        }
+        if (ch === '"' || ch === "'")
+            return string();
+        const m = /^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/.exec(src.slice(i, i + 40));
+        if (!m)
+            return fail('bad token');
+        i += m[0].length;
+        return Number(m[0]);
+    };
+    const v = value();
+    ws();
+    if (i !== src.length)
+        fail('trailing data');
+    return v;
+}
+// A protocol-7 `//EX` carries a serialized exception: its human message is in the string table,
+// among the entries that are not type signatures. Joined verbatim (ADR-004).
+function gwt7ExceptionMessage(body) {
+    try {
+        const arr = parseJsLiteral(body.slice(4));
+        const st = Array.isArray(arr) ? arr[arr.length - 3] : undefined;
+        if (Array.isArray(st)) {
+            const msgs = st.filter((s) => typeof s === 'string' && s.length > 0 && !isSig(s) && /\s/.test(s));
+            if (msgs.length)
+                return `SII rechazó la operación: ${msgs.join(' | ')}`;
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    return 'SII rechazó la operación (error de servicio).';
+}
+/** True when a protocol-7 response is GWT refusing the request's serialization policy or a
+ *  type signature: the trigger to re-read the permutation once (self-heal, ADR-020). The server
+ *  refuses before invoking the method, so nothing ran. */
+export function isGwt7PolicyError(text) {
+    const body = text.trimStart();
+    return (body.startsWith('//EX') &&
+        body.includes('com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException'));
+}
+// Each service proxy is built as `X.call(this, <moduleBase fn>(), '<entryPoint>', '<policy>', …)`
+// and every type signature is a `<var>='<class>/<crc>'` constant (observed in 543D42AD…,
+// 2026-10-19). Reading both from the JS needs no knowledge of the obfuscated names.
+const PROXY_RE = /\.call\(this,[\w$]+\(\),'([\w$]+)','([0-9A-F]{32})'/g;
+const SIG_RE = /[\w$]+='([a-zA-Z[][\w.$;[]*\/\d+)'/g;
+/** Extract the policy strong-names and the type signatures from a permutation's JS. */
+export function parseGwtPermutation(strongName, js) {
+    const policies = {};
+    for (const m of js.matchAll(PROXY_RE))
+        policies[m[1]] ??= m[2];
+    const sigs = {};
+    for (const m of js.matchAll(SIG_RE))
+        sigs[gwtClass(m[1])] ??= m[1];
+    return { strongName, policies, sigs };
+}
+const HEX32 = /\b[0-9A-F]{32}\b/g;
+// Process-wide, like the peticiones hash: the permutation belongs to SII's deploy, not to a user.
+const permutations = new Map();
+/** The module's permutation, from the cache or fetched (nocache.js → each listed permutation's
+ *  `.cache.html`, the first that declares `ref.entryPoint`). Both are authenticated GETs.
+ *  `refresh` bypasses the cache: the self-heal after a policy refusal. */
+export async function loadGwtPermutation(session, ref, fail, refresh = false) {
+    const key = `${ref.moduleBase}|${ref.entryPoint}`;
+    const cached = permutations.get(key);
+    if (cached && !refresh)
+        return cached;
+    const nocache = await session.requestText(`${ref.moduleBase}${ref.nocache}`, { method: 'GET' });
+    for (const name of new Set(nocache.body.match(HEX32) ?? [])) {
+        const js = await session.requestText(`${ref.moduleBase}${name}.cache.html`, { method: 'GET' });
+        const perm = parseGwtPermutation(name, js.body);
+        if (perm.policies[ref.entryPoint]) {
+            permutations.set(key, perm);
+            return perm;
+        }
+    }
+    throw fail(`No se encontró la política de serialización de ${ref.entryPoint} en el JS de SII (scraper roto).`);
+}
+/** Forget every cached permutation (tests). */
+export function clearGwtPermutations() {
+    permutations.clear();
+}
+/** POST one protocol-7 call and return the raw response text (the caller decodes it). `build`
+ *  gets the permutation, so the policy and the signatures always come from the same deploy. On
+ *  a policy/signature refusal the permutation is re-read ONCE and the call rebuilt and resent;
+ *  `heal: false` turns that off. */
+export async function postGwt7(session, ref, build, fail, opts = {}) {
+    const send = async (perm) => {
+        const resp = await session.requestText(`${ref.moduleBase}${ref.entryPoint}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'text/x-gwt-rpc; charset=utf-8',
+                'X-GWT-Module-Base': ref.moduleBase,
+                'X-GWT-Permutation': perm.strongName,
+            },
+            body: build(perm),
+        });
+        return resp.body;
+    };
+    const text = await send(await loadGwtPermutation(session, ref, fail));
+    if (opts.heal === false || !isGwt7PolicyError(text))
+        return text;
+    const healed = await send(await loadGwtPermutation(session, ref, fail, true));
+    // Still refused with a fresh permutation: our layouts or the extraction are stale, not SII's
+    // deploy — a broken scraper, never a business message to pass on.
+    if (isGwt7PolicyError(healed)) {
+        throw fail(`No se pudo usar la política de serialización de ${ref.entryPoint} tras releer la permutación de SII (scraper roto).`);
+    }
+    return healed;
+}
 //# sourceMappingURL=gwt.js.map