sabre-client 0.4.1 → 0.5.1

package/README.md

@@ -12,17 +12,32 @@ TypeScript SDK for the Sabre APIs.
 
 ## Status
 
-`0.4.0` is the current release of the rewrite. It covers Tier 1 and Tier 2 of the Air Booking
-flow over REST, and Tier 3 (SOAP sessions and queues). It adds `buildCredentials` and host
-commands (`session.command`) to `0.3.0`, with no breaking changes.
+`0.5.1` is published under the `next` dist-tag while it is tested; `latest` stays on `0.4.1`.
+It covers Tier 1 and Tier 2 of the Air Booking flow over REST, Tier 3 (SOAP sessions and queues)
+and Tier 4: queue activity, PNR history, the `S` message queue, `selection` in `list` and
+`onRawRequest`. The `0.5` line has three breaking changes (see
+[Upgrading from 0.4](#upgrading-from-04)).
 
 ```sh
-npm install sabre-client
+npm install sabre-client@next   # 0.5.1
+npm install sabre-client        # 0.4.1
 ```
 
 The package is still `0.x`: a minor version may include breaking changes, and the
 [CHANGELOG](./CHANGELOG.md) marks them.
 
+### Upgrading from 0.4
+
+- **`pcc` is no longer in the config.** Passing it to `new Sabre` or `new SabreLegacy` is a type
+  error, and in JavaScript it is ignored. The PCC you authenticate with goes in `credentials`
+  (see [Credentials](#credentials)); another PCC goes per operation, as `targetPcc` in REST or
+  `pcc` in the queue operations.
+- **`QueueRef` can be a `string`.** An alphabetic queue like `'S'` is `'S'`, and `count` and
+  `place` return it that way instead of `{ name: 'S' }`. Code that does
+  `typeof q === 'number' ? … : q.name` must handle the `string` case.
+- **A `QueueStep` that is not done has a `kind`.** Check `step.kind === 'pnr'` before reading
+  `step.item`; `kind: 'message'` carries a message of the `S` queue.
+
 Tier 1 covers the core Air Booking flow over REST:
 
 | Step | Service | Method |
@@ -45,11 +60,12 @@ Tier 3 adds the `SabreLegacy` SOAP client, with a stateful session and Queue Man
 | Step | Service | Method |
 | - | - | - |
 | Session | `SessionCreateRQ` 2.0.0 / 1.0.0, `OTA_PingRQ`, `SessionCloseRQ` | `legacy.withSession`, `legacy.openSession` |
-| Queues | Get Queue Count, Access Queue, Place Queue Message | `session.queue.count`, `list`, `access`, `ignore`, `remove`, `place`, `exit`, `process` |
-| Queue paragraph | — (pure function) | `parseQueueParagraph`, `resolveHostDate` |
+| Queues | Get Queue Count, Get Queue Activity, Access Queue, Place Queue Message | `session.queue.count`, `activity`, `list`, `access`, `ignore`, `remove`, `place`, `exit`, `process` |
+| Queue paragraph | — (pure function) | `parseQueueParagraph`, `parseQueuePlaceRemark`, `resolveHostDate` |
+| PNR history | `TravelItineraryHistoryLLSRQ` 2.4.0 | `session.reservation.history` |
 | Host commands | `SabreCommandLLSRQ` 2.0.0 | `session.command` |
 
-Planned after `0.4.0`: Get Ancillaries (NDC only).
+Planned after `0.5.0`: Get Ancillaries (NDC only).
 
 ## Requirements
 
@@ -88,11 +104,6 @@ const sabre = new Sabre({
 | `fetch` | global `fetch` | Custom `fetch` (proxies, tests, other runtimes) |
 | `tokenStore` | in-memory only | Shares the token between processes (see [Token reuse](#token-reuse)) |
 
-> **`pcc` is deprecated** since `0.4.1` and will be removed in `0.5.0`. It was a reserved field,
-> and no client reads it. The PCC you authenticate with goes in `credentials` (see
-> [Credentials](#credentials) and `buildCredentials`). To work in another PCC, pass it per
-> operation: `targetPcc` in REST, `pcc` in the queue operations.
-
 ### Credentials
 
 There is **one set of credentials** for REST and SOAP: the same `credentials` object works for
@@ -124,7 +135,9 @@ The object that `buildCredentials` returns carries its `authVersion`, so the con
 need to repeat it: with `authVersion: 'v2'` in `buildCredentials`, `{ environment, credentials }`
 is already a v2 config. If you pass `authVersion` in the config too, it must match, or the client
 throws a `TypeError`. Credentials you build by hand have no `authVersion`, so with v2 the config
-still needs `authVersion: 'v2'`.
+still needs `authVersion: 'v2'`. If the version is only known at runtime (for example, read
+from an environment variable into a `BuildCredentialsOptions`), the result of `buildCredentials`
+can still go straight into the config, with no `authVersion` there.
 
 The PCC in the credentials is the one you authenticate with. Working in another PCC is not a
 second set of credentials: pass it per operation, as `targetPcc` in `booking.create`, `get` and
@@ -360,6 +373,7 @@ const screen = await legacy.withSession((session) => session.command('W/PT¥*',
 // screen.text      → 'PSGR TYPE - ON' (as Sabre sends it, not trimmed)
 // screen.warnings  → the stl:Warning entries, if any
 // screen.messageId → eb:MessageId, for Sabre support
+// screen.respondedAt → eb:Timestamp in UTC, e.g. '2026-11-06T17:34:16Z'
 ```
 
 - **The command is sent as is.** In this service Sabre's `‡` separator is written `¥`
@@ -384,16 +398,71 @@ const screen = await legacy.withSession((session) => session.command('W/PT¥*',
   characters (`W/PT`, `DC`, `*IM`), never the whole command or the screen. The full response is
   available through `onRawResponse`.
 
+### PNR history
+
+`session.reservation.history(locator, options?)` reads the PNR history (Get Itinerary History,
+`TravelItineraryHistoryLLSRQ` 2.4.0, the host's `*H`), one entry per transaction:
+
+```ts
+const { transactions } = await legacy.withSession((session) => session.reservation.history('ABC123'));
+// transactions[0] → { rph, createdAt: '2026-11-04T17:15', agent, agentDutyCode, pcc, aaaPcc,
+//                     receivedFrom, flightSegments, generalInfo, remarks, accounting }
+```
+
+- **Who, when and from where**: `createdAt` (with a year, no time zone), the agent's sine and duty
+  code, the signing `pcc`, the AAA's `aaaPcc` and `receivedFrom`.
+- **What changed, with its `action`**: `flightSegments` with their status at that moment
+  (`AS` added, `XS` cancelled; dates without a year, as the host sends them), and SSR, ticketing,
+  phones, names and emails as text in `generalInfo` (`A4S`, `A7`, `A9`, `AN`, `APE`…). Sabre does
+  not publish the list of `action` values. Seats, cars, hotels, rail, insurance and invoices are
+  not typed: they stay in the raw response (`onRawResponse`).
+- **It carries passenger data** (names, phones, emails). The SDK never logs it.
+- **It does not record queue placements**, neither the system's nor a manual `place` (CERT): for that, use
+  `queue.list`/`access` or the `QUEUE_PLACE` remarks of Get Booking.
+- **Call it outside a queue walk.** Inside a queue, Sabre rejects the history of another PNR with
+  `NAK6 -NOT ALLOWED- FINISH OR IGNORE OTHER ACTIVITY`, a `SabreBusinessError` (CERT). The PNR in
+  the AAA does not change, `queue.state` stays `'inside'`, and the walk goes on with `ignore`.
+- It is a read: it is retried. A `locator` that is not 6 uppercase alphanumeric characters throws a
+  `TypeError` without calling the network. A PNR that does not exist throws a `SabreBusinessError`
+  (`service: 'itineraryHistory'`).
+
 ### Queues
 
 The queue operations live in `session.queue`. `pcc` is optional in every call and defaults to the
-session's PCC. A queue is a number from 0 to 511 or `{ name }` for alphabetic queues
-(`QueueRef`). The queues returned by `count` can be passed straight to the other operations.
+session's PCC. A queue (`QueueRef`) comes in three forms:
+
+| Queue | `QueueRef` | Sent as |
+| - | - | - |
+| Numeric, 0 to 511 | `400` | `Number="400"` |
+| Alphabetic, one or two uppercase letters | `'S'` | `Number="S"` |
+| Named (QN and QNB tables) | `{ name: 'HOTELS' }` | `Name="HOTELS"` |
+
+The queues returned by `count` can be passed straight to the other operations. `'S'` is the PCC's
+**message queue**: it holds messages, not PNRs, and Sabre does not list it, so `list({ queue: 'S' })`
+throws a `TypeError` without calling Sabre. Walk it by hand: `access({ queue: 'S' })` returns the
+first message (`kind: 'message'`) and `ignore()` the next one, leaving it in the queue. `process`
+and `place` inside `S` throw a `TypeError` without calling Sabre. `remove()` sends `QR`, but there
+is no evidence yet of what Sabre does with the message. To tell it apart, `isMessageQueue(queue)`
+returns `true` only for `'S'`, and `MESSAGE_QUEUE` is `'S'`:
+
+```ts
+import { isMessageQueue } from 'sabre-client';
+
+const { queues } = await session.queue.count();
+const pnrQueues = queues.filter(({ queue }) => !isMessageQueue(queue));
+```
+
+> **Migrating from 0.4.x**: `count` used to return the `S` queue as `{ name: 'S' }`, which Sabre
+> rejects (`INVALID QUEUE NAME FORMAT`). It now returns `'S'`. Code that does
+> `typeof q === 'number' ? … : q.name` no longer compiles, because `q` can be a `string`. A
+> `{ name }` of one or two uppercase letters now throws a `TypeError` that tells you to pass the
+> letter instead, and `'12'` or `'s'` throw too: each queue has a single form.
 
 | Method | Sabre service | Returns |
 | - | - | - |
 | `count({ pcc? })` | `QueueCountLLSRQ` | `{ queues: [{ queue, count }], totals, countedAt, warnings }` |
-| `list({ queue, pcc?, primaryPassenger? })` | `QueueAccessLLSRQ` (`List`) | `{ locators, entries, paragraph, warnings }`, without entering the queue |
+| `activity({ pcc? })` | `QueueAnalysisLLSRQ` | `{ queues: [{ queue, numMessages, ended, ignored, … }], totals, analyzedAt, warnings }` |
+| `list({ queue, pcc?, primaryPassenger?, selection? })` | `QueueAccessLLSRQ` (`List`) | `{ locators, entries, paragraph, warnings }`, without entering the queue |
 | `access({ queue, pcc?, selection? })` | `QueueAccessLLSRQ` | `QueueStep` |
 | `ignore()` | `QueueAccessLLSRQ` (`I`) | `QueueStep` |
 | `remove({ from? })` | `QueueAccessLLSRQ` (`QR`) | `QueueStep` |
@@ -402,10 +471,30 @@ session's PCC. A queue is a number from 0 to 511 or `{ name }` for alphabetic qu
 
 ```ts
 type QueueStep =
-  | { done: false; item: QueueItem; warnings: SabreWarning[] }
+  | { done: false; kind: 'pnr'; item: QueueItem; warnings: SabreWarning[] }
+  | { done: false; kind: 'message'; message: { text: string[] }; warnings: SabreWarning[] } // queue 'S'
   | { done: true; reason: 'end-of-display' | 'empty'; message: string; warnings: SabreWarning[] };
 ```
 
+> **Migrating from 0.4.x**: a step that is not done now has a `kind`. Check `step.kind === 'pnr'`
+> before reading `step.item`. Only the `S` queue returns `kind: 'message'`.
+
+- **`list` returns the whole queue in one response**: there is no paging, even with more than 1000
+  PNRs (1221 in about 279 KB, in production). `selection` narrows it, but in the list Sabre only
+  accepts `QD` (date placed on the queue, e.g. `{ function: 'QD', criteria: '05NOV' }`) or `AK`
+  (the agent who placed it, PCC plus sine, e.g. `'PCC1AAT'`; not tested in the list yet).
+  Any other code throws a `TypeError` without calling Sabre. The `placedAt` of a list entry is
+  when the PNR was placed on the queue, the date `QD` filters on.
+- **`activity`** returns, per queue, the eight counters of the host's `QA` screen: `numMessages`
+  (on the queue now), `ended`, `ignored`, `moved`, `removed`, `transferred`,
+  `leftMessageToContact` and `unableToReach`, plus `totals` for the PCC. Sabre also lists empty
+  queues that have counters. No source says since when the counters run, so the SDK returns them
+  as they come. Like `count`, it is a read: it is retried, it works inside or outside a queue, and
+  it does not need duty code 9.
+- **Every queue result carries `respondedAt`**: Sabre's `eb:Timestamp`, in ISO 8601 UTC
+  (`'2026-11-06T17:34:16Z'`). Unlike `countedAt` and `placedAt`, which come as the host sends them
+  (no year, PCC local time), it has a year and a zone. It is missing only if Sabre does not send it.
+
 - **The end of the queue is a result, not an error.** `END OF DISPLAY FOR REQUESTED DATA` gives
   `{ done: true, reason: 'end-of-display' }`, and an empty queue (`QUEUE SELECTED WAS EMPTY`)
   gives `reason: 'empty'`. In both cases the session is left outside the queue. Any other Sabre
@@ -425,7 +514,9 @@ type QueueStep =
   Production rejects a `place` without it, although the design says it is optional.
 - **`QueueItem`** has `locator`, the `placedAt` and `placedBy` of `Line`, `primaryPassenger` and
   `group` when Sabre sends them, and `paragraph`: the PNR in host format, line by line and
-  untouched. `placedAt` is the text that arrived, with or without the year. `resolveHostDate`
+  untouched. `placedAt` is the text that arrived, with or without the year. Inside a queue it is
+  the PNR's last change, not when it was placed on the queue: that one is the `placedAt` of
+  `list`, and the two differ for the same PNR. `resolveHostDate`
   turns it into a full date.
 - `count` inside a queue does not count the PNR on screen.
 
@@ -466,6 +557,20 @@ segments with their status, the ticketing field with an `issued` flag, and the r
 - It does not read deadlines that airlines write as free text in remarks, SSR or OSI. Their format
   belongs to each airline. The text is still in `paragraph`.
 
+### Reading a `QUEUE_PLACE` remark
+
+Get Booking returns where the PNR was placed as a remark with `type: 'QUEUE_PLACE'`. Its `text`
+packs the PCC, the date, the queue and the PIC with no separators. `parseQueuePlaceRemark(text)`
+splits it:
+
+```ts
+parseQueuePlaceRemark('MEX25SEP146/015'); // { pcc: 'MEX', date: '25SEP', queue: 146, pic: 15 }
+```
+
+It returns `null` if the text does not have that shape, or if the day, month, queue (0–511) or PIC
+(0–191, 200–254) are out of range. `date` has no year: resolve it with
+`resolveHostDate(date, referenceDate)`. Reading the remarks from the booking is up to you.
+
 ### Testing your queue logic: `sabre-client/testing`
 
 `sabre-client/testing` is a separate entry point with a fake of Sabre's sessions and queues. It is
@@ -496,16 +601,82 @@ fake.openSessions; // 0: the session was closed
   `{ locator, paragraph?, placedAt?, placedBy?, primaryPassenger? }`. A paragraph without a
   signature line gets a synthetic one. `pnrs` adds PNRs that are not in any queue, for
   `place({ locators })`. The fake has no AAA: outside a queue, `place` needs `locators`.
+- `queues['S']` is the message queue: each item is a message's text (`string[]`), not a PNR.
+  `access` shows it without `Line`, as Sabre does, and `fake.messages()` lists the ones left.
+  That `remove` takes a message out is an assumption of the fake, not tested against Sabre.
+- `queue.activity`: `numMessages` comes from the fake's queues (without the PNR on screen, as in
+  `count`, as CERT does). The other seven counters are 0 unless you seed them with
+  `activity: { '9': { ignored: 27 } }`. The fake's actions do **not** change them: no one has
+  tested which counter Sabre raises for each action.
+- `reservation.history`: `histories: { AAAAAA: [transactions] }` sets what each PNR returns, in
+  the shape of `ReservationHistoryTransaction` (missing lists come back empty). A PNR the fake
+  knows without a seeded history returns one synthetic transaction (its creation), and an unknown
+  locator gives a host error marked as not simulated. Inside a queue, the history of another PNR
+  is rejected with `NAK6 -NOT ALLOWED- FINISH OR IGNORE OTHER ACTIVITY` and the one on screen is
+  returned, as in CERT.
 - It answers like production: empty queues, the end of the queue, `place` moving the PNR, the
   required PIC, and an expired session with `fake.expireSessions()`. `fake.calls` lists what the
   SDK asked for.
 - **Not simulated**: PCCs (the queues are the same for any `pcc`) and `selection`, which gets an
-  error instead of the whole queue.
+  error instead of the whole queue, in `access` and in `list`.
 - `queueFixtures` holds the anonymized responses recorded in production (`walk`, `emptyQueue`,
-  `place`, …), as `{ operation, status, body }`.
+  `place`, …), as `{ operation, status, body }`. Each one has its own locator aliases (`walk`:
+  `AAAAAA`–`AAAAAD`, `place`: `AAAAAE`–`AAAAAF`, `placeWithoutInstructionCodeInside`:
+  `AAAAAG`–`AAAAAH`), and their signature lines keep their shape (`… <alias> H`).
+- `queueFakePnrs(fixture)` turns a recording into the fake's PNRs: those of `list` first, in
+  order, with their `Line`, and the paragraph `access`, `ignore`, `remove` or `place` showed for
+  each one. You choose the queue, and you can mix fixtures. The PNRs of `queueFixtures` have no
+  `primaryPassenger`: `list` was recorded without `primaryPassenger: true` (`/LN`), so Sabre did
+  not send the name. If you need one, add it with a `map`:
+
+  ```ts
+  const fake = createQueueFake({
+    queues: { '9': queueFakePnrs(queueFixtures.walk), '50': [] },
+    pnrs: queueFakePnrs(queueFixtures.place),
+  });
+
+  const withPassenger = queueFakePnrs(queueFixtures.walk).map((pnr, index) => ({
+    ...pnr,
+    primaryPassenger: `TEST/PASSENGER${index + 1}`,
+  }));
+  ```
 
 `examples/queue-review.mjs` is a full example, and its test runs it against the fake.
 
+#### Anonymizing recorded responses
+
+`createAnonymizer` applies the rule the SDK's fixtures were recorded with, so you can store
+Sabre's responses (for example from `onRawResponse`) without passenger data:
+
+```ts
+import { createAnonymizer } from 'sabre-client/testing';
+
+const anonymizer = createAnonymizer({ secrets: [pcc, username] });
+const safe = anonymizer.anonymize(raw.body); // a whole SOAP envelope
+anonymizer.maskParagraph(item.paragraph); // host-format lines
+if (anonymizer.leaks(safe).length > 0) throw new Error('real data left');
+```
+
+In a browser bundle, import it from `sabre-client/anonymize` instead. It has only
+`createAnonymizer`, `isSafeHostLine` and their types, without the fake or `queueFixtures`, which
+`sabre-client/testing` carries in a single module (about 230 KB) that bundlers cannot drop:
+
+```ts
+import { isSafeHostLine } from 'sabre-client/anonymize';
+```
+
+- Each locator gets an alias (`AAAAAA`, `AAAAAB`…), the same one everywhere it appears, also in
+  later texts passed to the same anonymizer. `PassengerName` becomes `PASAJERO/UNO`, `Group`
+  becomes `GRUPO`, `AgentSine` becomes `AAA` (except `SABRE`), `PseudoCityCode` becomes `XXXX`,
+  `LNIATA` becomes `XXXXXX`, and each `secret` becomes `XXXX`.
+- In host-format lines (`<Text>`, or `maskLine` and `maskParagraph`), only the lines of a
+  whitelist stay as they are (`isSafeHostLine`: empty lines, PIC notices like `011  SEE REMARKS`,
+  section titles, the end of the queue). In the others, letters become `X` and digits `9`. The
+  signature line keeps its shape, and its locator only if it is already an alias.
+- `leaks(text)` lists the real data still in `text` (`'secreto'`, `'localizador'`, `'nombre'`,
+  `'línea del PNR'`, `'token'`): use it before writing a file.
+- Use one anonymizer per recording. It is a rule, not a guarantee: check what you store.
+
 ## Error handling
 
 Every error thrown by the SDK extends `SabreError`:
@@ -576,6 +747,39 @@ In `SabreLegacy`, `protocol` is `'soap'`, `body` is the whole SOAP envelope, and
 > `body` is the raw response and **contains passenger data**. The SDK never sends it to the
 > logger. Where you store it is up to you.
 
+## Raw request
+
+The same operations accept `onRawRequest`, next to `onRawResponse`. It receives what the SDK sent
+over the network, for example to show the real request next to the response:
+
+```ts
+import type { SabreRawRequest } from 'sabre-client';
+
+let sent: SabreRawRequest | undefined;
+await sabre.booking.get({ confirmationId }, { onRawRequest: (r) => (sent = r) });
+// sent: { operation: 'booking.get', protocol: 'rest', method, url, headers, body, attempts }
+```
+
+- `operation` is the same value `onRawResponse` gets. `url` is the full URL, with its query
+  string. `headers` are the ones sent, **without `Authorization`** (the whole header is dropped).
+  `body` is the text sent, or `undefined` if there was none. In REST it is untouched; in
+  `SabreLegacy` it is the whole SOAP envelope with the `BinarySecurityToken` replaced by
+  `[REDACTED]`, as in the response.
+- It is called **once**, with the last attempt sent, before the operation returns or throws and
+  before `onRawResponse`. Unlike `onRawResponse`, it is also called when no attempt got an HTTP
+  response (network error, abort), as long as at least one was sent. It is not called if the
+  operation throws before sending anything (for example a `TypeError` from validation).
+- In SOAP, `eb:MessageId` and `eb:Timestamp` are new on every attempt, so the envelope you get is
+  the one of the last attempt.
+- It is not called for authentication: the OAuth token request, `openSession`
+  (`SessionCreateRQ`, whose envelope carries the EPR password) and `close` (`SessionCloseRQ`).
+- It is synchronous and its return value is ignored. If it throws, the SDK logs
+  `sabre.request.rawRequestHookFailed` without the body, and the operation carries on.
+
+> [!WARNING]
+> `body` and `url` **contain passenger data** (locators, names, contact details). The SDK never
+> sends them to the logger. Where you store them is up to you.
+
 ## Retries
 
 Only idempotent operations are retried: Bargain Finder Max and Revalidate Itinerary (both
@@ -632,7 +836,8 @@ const sabre = new Sabre({
 ```
 
 The SDK logs structured events (`sabre.request.start`, `sabre.request.end`,
-`sabre.request.retry`, `sabre.request.rawResponseHookFailed`, `sabre.auth.token.refresh`,
+`sabre.request.retry`, `sabre.request.rawResponseHookFailed`,
+`sabre.request.rawRequestHookFailed`, `sabre.auth.token.refresh`,
 `sabre.auth.token.store`, `sabre.booking.seat.priced`, `sabre.session.open`,
 `sabre.session.close`, `sabre.session.closeFailed`, `sabre.session.keepAliveFailed`,
 `sabre.session.command`, `sabre.queue.exitTolerated`, `sabre.queue.exitFailed`), never raw

package/dist/anonymize.d.ts

@@ -0,0 +1,54 @@
+/** Qué dato real quedó en un texto: lo que devuelve `Anonymizer.leaks`. */
+type AnonymizerLeak = 'secreto' | 'localizador' | 'nombre' | 'línea del PNR' | 'token';
+interface AnonymizerOptions {
+    /**
+     * Valores que nunca deben quedar: credenciales, usuario, PCC. Cada uno pasa a `XXXX` donde
+     * aparezca. Se ignoran los que no son string o tienen menos de 3 caracteres.
+     */
+    secrets?: ReadonlyArray<string | undefined>;
+}
+/**
+ * Una anonimización con memoria: el mismo localizador da siempre el mismo alias y el mismo
+ * pasajero el mismo nombre falso, en todos los textos que pasen por ella. Una por grabación.
+ */
+interface Anonymizer {
+    /**
+     * Un sobre SOAP o cualquier texto con su XML (también un JSON con XML adentro):
+     * - cada `UniqueID@ID` pasa a un alias (`AAAAAA`, `AAAAAB`…), y el localizador real se reemplaza
+     *   por su alias en todo el texto;
+     * - `PassengerName` a `PASAJERO/UNO`, `PASAJERO/DOS`…, y `Group` a `GRUPO`;
+     * - `AgentSine` a `AAA` (salvo `SABRE`), `PseudoCityCode` a `XXXX` y `LNIATA` a `XXXXXX`;
+     * - cada `<Text>` pasa por `maskLine`;
+     * - los `secrets`, a `XXXX`.
+     */
+    anonymize(text: string): string;
+    /**
+     * Una línea del PNR en formato de host. Las de la lista blanca (`isSafeHostLine`) quedan tal
+     * cual; en las demás, letras a `X` y dígitos a `9`. La cabecera `QUEUE LIST FOR <PCC>` solo
+     * tapa el PCC, y `RECEIVED FROM - ` conserva el prefijo. La línea de firma
+     * (`… HHMM/DDMMMYY <localizador> H`) conserva su forma, y el localizador solo si ya es un alias:
+     * de ella sale el localizador del PNR siguiente en `place` dentro de una cola. Llamarla después
+     * de dar alias a los localizadores.
+     */
+    maskLine(line: string): string;
+    /** `maskLine` sobre cada línea de un párrafo, p. ej. `QueueItem.paragraph`. */
+    maskParagraph(lines: readonly string[]): string[];
+    /** El alias de un localizador: lo asigna la primera vez, en orden (`AAAAAA`, `AAAAAB`…). */
+    aliasOf(locator: string): string;
+    /**
+     * Qué datos reales siguen en `text`, sin repetir: un `secret`, un localizador o un nombre que ya
+     * tienen alias, una línea del PNR que se enmascaró, o un token de sesión. Vacío si no queda
+     * ninguno. Sirve para no escribir una fixture que todavía trae datos reales.
+     */
+    leaks(text: string): AnonymizerLeak[];
+}
+/**
+ * Si una línea del PNR en formato de host queda tal cual al anonimizar: está en la lista blanca de
+ * #96 (líneas vacías, avisos PIC como `011  SEE REMARKS`, títulos de sección como `REMARKS`, el fin
+ * de cola).
+ */
+declare function isSafeHostLine(line: string): boolean;
+/** Ver `Anonymizer`. */
+declare function createAnonymizer(options?: AnonymizerOptions): Anonymizer;
+
+export { type Anonymizer, type AnonymizerLeak, type AnonymizerOptions, createAnonymizer, isSafeHostLine };

package/dist/anonymize.js

@@ -0,0 +1,111 @@
+// src/testing/anonymize.ts
+var NAMES = ["UNO", "DOS", "TRES", "CUATRO", "CINCO", "SEIS", "SIETE", "OCHO", "NUEVE", "DIEZ"];
+var SAFE_LINES = [
+  /^\s*$/,
+  // Aviso PIC: 011  SEE REMARKS. Sin dígitos después del número: una línea de `list`
+  // (`100  ABC123  PLT  MAM  01JUN26  1948`) también empieza con 3 dígitos y trae el sine.
+  /^\s*\d{3}\s{2,}[A-Z][A-Z ,./-]*$/,
+  /^\s*END OF DISPLAY FOR REQUESTED DATA\s*$/,
+  /^\s*(TKT\/TIME LIMIT|PHONES|REMARKS|ADDRESS|INVOICED|GENERAL FACTS|[A-Z0-9]{2} FACTS|NO ITIN)\s*$/,
+  /^\s*PASSENGER EMAIL DATA EXISTS\s+\*PE TO DISPLAY ALL\s*$/
+];
+function isSafeHostLine(line) {
+  return SAFE_LINES.some((pattern) => pattern.test(line));
+}
+var ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+var decode = (text) => text.replace(/&(amp|lt|gt|quot|apos);/g, (_, entity) => ENTITIES[entity] ?? "");
+var encode = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var masked = (text) => text.replace(/\p{L}/gu, "X").replace(/\p{N}/gu, "9");
+function createAnonymizer(options = {}) {
+  const secrets = (options.secrets ?? []).filter((value) => typeof value === "string" && value.length >= 3).sort((a, b) => b.length - a.length);
+  const redactSecrets = (text) => secrets.reduce((value, secret) => value.split(secret).join("XXXX"), text);
+  const locatorAliases = /* @__PURE__ */ new Map();
+  const realNames = /* @__PURE__ */ new Map();
+  const maskedLines = /* @__PURE__ */ new Set();
+  const aliasOf = (locator) => {
+    let alias = locatorAliases.get(locator);
+    if (alias === void 0) {
+      const n = locatorAliases.size;
+      const letters = [17576, 676, 26, 1].map((size) => String.fromCharCode(65 + Math.floor(n / size) % 26)).join("");
+      alias = `AA${letters}`;
+      locatorAliases.set(locator, alias);
+    }
+    return alias;
+  };
+  const fakeName = (name) => {
+    let fake = realNames.get(name);
+    if (fake === void 0) {
+      fake = `PASAJERO/${NAMES[realNames.size] ?? realNames.size + 1}`;
+      realNames.set(name, fake);
+    }
+    return fake;
+  };
+  function anonymizeLine(line) {
+    if (isSafeHostLine(line)) return line;
+    const header = /^(\s*QUEUE LIST FOR )\S+(\s+QUEUE )(\S+)\s*$/.exec(line);
+    if (header !== null) return `${header[1]}XXXX${header[2]}${header[3]}`;
+    const received = /^(\s*RECEIVED FROM - )(.*)$/.exec(line);
+    const signature = /^(.*\s)(\d{4}\/\d{2}[A-Z]{3}\d{2})(\s+)([A-Z0-9]{6})(\s+H\s*)$/.exec(line);
+    const aliases = new Set(locatorAliases.values());
+    let result;
+    if (received !== null) {
+      result = `${received[1]}${masked(received[2] ?? "")}`;
+    } else if (signature !== null) {
+      const [, before = "", stamp = "", gap = "", locator = "", end = ""] = signature;
+      result = `${masked(before)}${masked(stamp)}${gap}${aliases.has(locator) ? locator : masked(locator)}${end}`;
+    } else {
+      result = masked(line);
+    }
+    if (line.trim().length >= 4 && result.trim() !== line.trim()) maskedLines.add(line.trim());
+    return result;
+  }
+  function anonymize(body) {
+    let text = String(body).replace(
+      /(<(?:\w+:)?UniqueID\b[^>]*\bID=")([^"]+)(")/g,
+      (_, a, locator, b) => `${a}${aliasOf(locator)}${b}`
+    );
+    for (const [locator, alias] of locatorAliases) text = text.split(locator).join(alias);
+    text = text.replace(
+      /(<(?:\w+:)?PassengerName>)([^<]*)(<\/)/g,
+      (_, a, name, b) => `${a}${fakeName(decode(name))}${b}`
+    );
+    text = text.replace(
+      /(<(?:\w+:)?Group>)([^<]*)(<\/)/g,
+      (_, a, value, b) => value === "" ? `${a}${b}` : `${a}GRUPO${b}`
+    );
+    text = text.replace(
+      /(\bAgentSine=")([^"]*)(")/g,
+      (_, a, sine, b) => `${a}${sine === "SABRE" ? sine : "AAA"}${b}`
+    );
+    text = text.replace(/(\bPseudoCityCode=")([^"]*)(")/g, "$1XXXX$3");
+    text = text.replace(/(\bLNIATA=")([^"]*)(")/g, "$1XXXXXX$3");
+    text = text.replace(
+      /(<(?:\w+:)?Text\b[^>/]*>)([\s\S]*?)(<\/(?:\w+:)?Text>)/g,
+      (_, a, line, b) => `${a}${encode(anonymizeLine(decode(line)))}${b}`
+    );
+    return redactSecrets(text);
+  }
+  const maskLine = (line) => redactSecrets(anonymizeLine(line));
+  function leaks(text) {
+    const found = [
+      ...secrets.filter((secret) => text.includes(secret)).map(() => "secreto"),
+      ...[...locatorAliases.keys()].filter((locator) => text.includes(locator)).map(() => "localizador"),
+      ...[...realNames.keys()].filter((realName) => realName.length >= 3 && text.includes(realName)).map(() => "nombre"),
+      ...[...maskedLines].filter((line) => text.includes(line)).map(() => "l\xEDnea del PNR"),
+      .../IceSess|Shared\/IDL/.test(text) ? ["token"] : []
+    ];
+    return [...new Set(found)];
+  }
+  return {
+    anonymize,
+    maskLine,
+    maskParagraph: (lines) => lines.map(maskLine),
+    aliasOf,
+    leaks
+  };
+}
+export {
+  createAnonymizer,
+  isSafeHostLine
+};
+//# sourceMappingURL=anonymize.js.map

package/dist/anonymize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing/anonymize.ts"],"sourcesContent":["// Anonimización de las respuestas de colas grabadas (la regla de #96, ADR-018), la misma que usan\n// los scripts que graban fixtures. Exportada para que los consumidores no la repitan (ADR-027, D1).\n// Solo Web Standard APIs: corre en cualquier runtime.\n\n/** Qué dato real quedó en un texto: lo que devuelve `Anonymizer.leaks`. */\nexport type AnonymizerLeak = 'secreto' | 'localizador' | 'nombre' | 'línea del PNR' | 'token';\n\nexport interface AnonymizerOptions {\n  /**\n   * Valores que nunca deben quedar: credenciales, usuario, PCC. Cada uno pasa a `XXXX` donde\n   * aparezca. Se ignoran los que no son string o tienen menos de 3 caracteres.\n   */\n  secrets?: ReadonlyArray<string | undefined>;\n}\n\n/**\n * Una anonimización con memoria: el mismo localizador da siempre el mismo alias y el mismo\n * pasajero el mismo nombre falso, en todos los textos que pasen por ella. Una por grabación.\n */\nexport interface Anonymizer {\n  /**\n   * Un sobre SOAP o cualquier texto con su XML (también un JSON con XML adentro):\n   * - cada `UniqueID@ID` pasa a un alias (`AAAAAA`, `AAAAAB`…), y el localizador real se reemplaza\n   *   por su alias en todo el texto;\n   * - `PassengerName` a `PASAJERO/UNO`, `PASAJERO/DOS`…, y `Group` a `GRUPO`;\n   * - `AgentSine` a `AAA` (salvo `SABRE`), `PseudoCityCode` a `XXXX` y `LNIATA` a `XXXXXX`;\n   * - cada `<Text>` pasa por `maskLine`;\n   * - los `secrets`, a `XXXX`.\n   */\n  anonymize(text: string): string;\n  /**\n   * Una línea del PNR en formato de host. Las de la lista blanca (`isSafeHostLine`) quedan tal\n   * cual; en las demás, letras a `X` y dígitos a `9`. La cabecera `QUEUE LIST FOR <PCC>` solo\n   * tapa el PCC, y `RECEIVED FROM - ` conserva el prefijo. La línea de firma\n   * (`… HHMM/DDMMMYY <localizador> H`) conserva su forma, y el localizador solo si ya es un alias:\n   * de ella sale el localizador del PNR siguiente en `place` dentro de una cola. Llamarla después\n   * de dar alias a los localizadores.\n   */\n  maskLine(line: string): string;\n  /** `maskLine` sobre cada línea de un párrafo, p. ej. `QueueItem.paragraph`. */\n  maskParagraph(lines: readonly string[]): string[];\n  /** El alias de un localizador: lo asigna la primera vez, en orden (`AAAAAA`, `AAAAAB`…). */\n  aliasOf(locator: string): string;\n  /**\n   * Qué datos reales siguen en `text`, sin repetir: un `secret`, un localizador o un nombre que ya\n   * tienen alias, una línea del PNR que se enmascaró, o un token de sesión. Vacío si no queda\n   * ninguno. Sirve para no escribir una fixture que todavía trae datos reales.\n   */\n  leaks(text: string): AnonymizerLeak[];\n}\n\nconst NAMES = ['UNO', 'DOS', 'TRES', 'CUATRO', 'CINCO', 'SEIS', 'SIETE', 'OCHO', 'NUEVE', 'DIEZ'];\n\n/** Líneas de un PNR en formato de host que quedan tal cual: no traen datos del pasajero. */\nconst SAFE_LINES: readonly RegExp[] = [\n  /^\\s*$/,\n  // Aviso PIC: 011  SEE REMARKS. Sin dígitos después del número: una línea de `list`\n  // (`100  ABC123  PLT  MAM  01JUN26  1948`) también empieza con 3 dígitos y trae el sine.\n  /^\\s*\\d{3}\\s{2,}[A-Z][A-Z ,./-]*$/,\n  /^\\s*END OF DISPLAY FOR REQUESTED DATA\\s*$/,\n  /^\\s*(TKT\\/TIME LIMIT|PHONES|REMARKS|ADDRESS|INVOICED|GENERAL FACTS|[A-Z0-9]{2} FACTS|NO ITIN)\\s*$/,\n  /^\\s*PASSENGER EMAIL DATA EXISTS\\s+\\*PE TO DISPLAY ALL\\s*$/,\n];\n\n/**\n * Si una línea del PNR en formato de host queda tal cual al anonimizar: está en la lista blanca de\n * #96 (líneas vacías, avisos PIC como `011  SEE REMARKS`, títulos de sección como `REMARKS`, el fin\n * de cola).\n */\nexport function isSafeHostLine(line: string): boolean {\n  return SAFE_LINES.some((pattern) => pattern.test(line));\n}\n\nconst ENTITIES: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '\"', apos: \"'\" };\nconst decode = (text: string) => text.replace(/&(amp|lt|gt|quot|apos);/g, (_, entity: string) => ENTITIES[entity] ?? '');\nconst encode = (text: string) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\nconst masked = (text: string) => text.replace(/\\p{L}/gu, 'X').replace(/\\p{N}/gu, '9');\n\n/** Ver `Anonymizer`. */\nexport function createAnonymizer(options: AnonymizerOptions = {}): Anonymizer {\n  const secrets = (options.secrets ?? [])\n    .filter((value): value is string => typeof value === 'string' && value.length >= 3)\n    .sort((a, b) => b.length - a.length);\n  const redactSecrets = (text: string) => secrets.reduce((value, secret) => value.split(secret).join('XXXX'), text);\n  const locatorAliases = new Map<string, string>();\n  const realNames = new Map<string, string>();\n  const maskedLines = new Set<string>();\n\n  const aliasOf = (locator: string): string => {\n    let alias = locatorAliases.get(locator);\n    if (alias === undefined) {\n      const n = locatorAliases.size;\n      // Base 26 en cuatro letras: `AAAAAA`, `AAAAAB`… y sigue en letras después del 676 (`AAABAA`).\n      const letters = [17576, 676, 26, 1].map((size) => String.fromCharCode(65 + (Math.floor(n / size) % 26))).join('');\n      alias = `AA${letters}`;\n      locatorAliases.set(locator, alias);\n    }\n    return alias;\n  };\n  const fakeName = (name: string): string => {\n    let fake = realNames.get(name);\n    if (fake === undefined) {\n      fake = `PASAJERO/${NAMES[realNames.size] ?? realNames.size + 1}`;\n      realNames.set(name, fake);\n    }\n    return fake;\n  };\n\n  function anonymizeLine(line: string): string {\n    if (isSafeHostLine(line)) return line;\n    const header = /^(\\s*QUEUE LIST FOR )\\S+(\\s+QUEUE )(\\S+)\\s*$/.exec(line);\n    if (header !== null) return `${header[1]}XXXX${header[2]}${header[3]}`;\n    const received = /^(\\s*RECEIVED FROM - )(.*)$/.exec(line);\n    const signature = /^(.*\\s)(\\d{4}\\/\\d{2}[A-Z]{3}\\d{2})(\\s+)([A-Z0-9]{6})(\\s+H\\s*)$/.exec(line);\n    const aliases = new Set(locatorAliases.values());\n    let result: string;\n    if (received !== null) {\n      result = `${received[1]}${masked(received[2] ?? '')}`;\n    } else if (signature !== null) {\n      const [, before = '', stamp = '', gap = '', locator = '', end = ''] = signature;\n      result = `${masked(before)}${masked(stamp)}${gap}${aliases.has(locator) ? locator : masked(locator)}${end}`;\n    } else {\n      result = masked(line);\n    }\n    if (line.trim().length >= 4 && result.trim() !== line.trim()) maskedLines.add(line.trim());\n    return result;\n  }\n\n  function anonymize(body: string): string {\n    let text = String(body).replace(\n      /(<(?:\\w+:)?UniqueID\\b[^>]*\\bID=\")([^\"]+)(\")/g,\n      (_, a: string, locator: string, b: string) => `${a}${aliasOf(locator)}${b}`,\n    );\n    for (const [locator, alias] of locatorAliases) text = text.split(locator).join(alias);\n    text = text.replace(\n      /(<(?:\\w+:)?PassengerName>)([^<]*)(<\\/)/g,\n      (_, a: string, name: string, b: string) => `${a}${fakeName(decode(name))}${b}`,\n    );\n    text = text.replace(/(<(?:\\w+:)?Group>)([^<]*)(<\\/)/g, (_, a: string, value: string, b: string) =>\n      value === '' ? `${a}${b}` : `${a}GRUPO${b}`,\n    );\n    text = text.replace(/(\\bAgentSine=\")([^\"]*)(\")/g, (_, a: string, sine: string, b: string) =>\n      `${a}${sine === 'SABRE' ? sine : 'AAA'}${b}`,\n    );\n    text = text.replace(/(\\bPseudoCityCode=\")([^\"]*)(\")/g, '$1XXXX$3');\n    // La dirección de la terminal (`stl:HostCommand@LNIATA`, en `session.command()`).\n    text = text.replace(/(\\bLNIATA=\")([^\"]*)(\")/g, '$1XXXXXX$3');\n    text = text.replace(\n      /(<(?:\\w+:)?Text\\b[^>/]*>)([\\s\\S]*?)(<\\/(?:\\w+:)?Text>)/g,\n      (_, a: string, line: string, b: string) => `${a}${encode(anonymizeLine(decode(line)))}${b}`,\n    );\n    return redactSecrets(text);\n  }\n\n  const maskLine = (line: string) => redactSecrets(anonymizeLine(line));\n\n  function leaks(text: string): AnonymizerLeak[] {\n    const found: AnonymizerLeak[] = [\n      ...secrets.filter((secret) => text.includes(secret)).map((): AnonymizerLeak => 'secreto'),\n      ...[...locatorAliases.keys()].filter((locator) => text.includes(locator)).map((): AnonymizerLeak => 'localizador'),\n      ...[...realNames.keys()]\n        .filter((realName) => realName.length >= 3 && text.includes(realName))\n        .map((): AnonymizerLeak => 'nombre'),\n      ...[...maskedLines].filter((line) => text.includes(line)).map((): AnonymizerLeak => 'línea del PNR'),\n      ...(/IceSess|Shared\\/IDL/.test(text) ? (['token'] as const) : []),\n    ];\n    return [...new Set(found)];\n  }\n\n  return {\n    anonymize,\n    maskLine,\n    maskParagraph: (lines) => lines.map(maskLine),\n    aliasOf,\n    leaks,\n  };\n}\n"],"mappings":"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","names":[]}