@agiledigital/pingone-aic-script-tester 0.1.0

package/dist/src/aic/tenant.d.ts

@@ -0,0 +1,107 @@
+import { type HttpRequest, type HttpResponse } from "./http.ts";
+import { type TenantProvider } from "./provider.ts";
+export interface TenantSession {
+    tenantName: string;
+    baseUrl: string;
+    token: string;
+    /** Where `token` came from, and where a replacement comes from after a 401. */
+    provider: TenantProvider;
+}
+export interface CliResult {
+    status: number;
+    stdout: string;
+    stderr: string;
+}
+export interface AmResponse {
+    status: number;
+    bodyText: string;
+    body: unknown;
+    transactionId?: string;
+}
+export interface AmRequest {
+    method: string;
+    path: string;
+    headers?: Array<[string, string]>;
+    body?: string;
+    /** When true, do not send the service-account bearer (authenticate). */
+    anonymous?: boolean;
+    timeoutMs?: number;
+}
+export interface AicIo {
+    aic(args: string[]): Promise<CliResult>;
+    http(req: HttpRequest): Promise<HttpResponse>;
+}
+export declare const AM_CONFIG_API_VERSION = "protocol=2.0,resource=1.0";
+export declare function amConfigHeaders(): Array<[string, string]>;
+export declare class AicLaneError extends Error {
+    readonly status?: number;
+    readonly transactionId?: string;
+    constructor(message: string, options?: {
+        status?: number;
+        transactionId?: string;
+        cause?: unknown;
+    });
+}
+export declare function defaultAicIo(project: string): AicIo;
+export interface ConnectOptions {
+    /**
+     * An `aic` context name. With the `aic` provider it selects the context;
+     * with any other it must equal the provider's name, so a suite pinned to
+     * one tenant cannot run against another.
+     */
+    tenant?: string;
+    /** The `aic` project directory; the `aic` provider only. */
+    project?: string;
+    /** Default: {@link configuredTenantProvider}, else the `aic` CLI. */
+    provider?: TenantProvider;
+    /**
+     * `false` skips the registered and environment providers. Callers pass it
+     * when they were handed an `io`: an injected `io` is a test seam for both
+     * `aic` and HTTP, and a configured service account would mint its token
+     * over the real network behind it.
+     */
+    useConfigured?: boolean;
+}
+/**
+ * The provider a connection uses: the one passed, else the one registered
+ * with `setTenantProvider` or configured by `AIC_SCRIPT_TESTER_TENANT_URL`, else
+ * this repo's `aic` agent.
+ */
+export declare function resolveTenantProvider(io: AicIo, options?: ConnectOptions): TenantProvider;
+export declare function connectTenant(io: AicIo, options?: ConnectOptions): Promise<TenantSession>;
+/**
+ * This repo's provider: the tenant and bearer come from the `aic` agent
+ * (`aic ctx list --json`, `aic whoami --token`), and logs from
+ * `aic logs tx --wait`. The agent must be unlocked; every call passes
+ * `--no-prompt` so a locked one fails instead of waiting for a password.
+ */
+export declare function aicCliProvider(io: AicIo, options?: {
+    tenant?: string;
+    project?: string;
+}): TenantProvider;
+/**
+ * Ask the provider for a replacement bearer and adopt it.
+ *
+ * The history below is the `aic` provider's, and it is why a 401 must reach
+ * the provider as `"rejected"`: a provider that caches has to know the token
+ * it holds is dead, rather than handing it back.
+ *
+ * MEASURED 2026-09-14 over 20 minutes: `aic whoami --token` handed back a
+ * token that worked *right now* and said nothing about how much life was left
+ * in it. The first token this probe was given was rejected 401 five minutes
+ * later, while a token fetched moments after it stayed good for the next ten —
+ * the agent rotated on its own ~898s schedule, so what you got depended on
+ * where in that cycle you asked.
+ *
+ * `aic` now guarantees `--token` at least 840 of those seconds, minting when
+ * the cached token is below the floor (MEASURED 2026-09-15: with 823s left the
+ * TTL jumped to 899 across the call, and with 864s left it did not move). That
+ * removes the reason this refresh usually fired, and none of the reasons it
+ * must stay: a file may run longer than the floor, the tenant may revoke, and
+ * an older `aic` on someone else's PATH makes no such promise. So the 401 retry
+ * remains the correctness mechanism and the floor is only what makes it rare.
+ */
+export declare function refreshSessionToken(session: TenantSession): Promise<void>;
+export declare function realmJsonPath(realm: string): string;
+export declare function amRequest(io: AicIo, session: TenantSession, req: AmRequest): Promise<AmResponse>;
+export declare function redact(text: string, session: TenantSession): string;

package/dist/src/aic/tenant.js

@@ -0,0 +1,307 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join } from "node:path";
+import { isPlainObject } from "../case/util.js";
+import { projectRoot } from "../project.js";
+import { headerValues, sendHttp } from "./http.js";
+import { checkTenantDescription, configuredTenantProvider, TENANT_ENV, } from "./provider.js";
+const execFileAsync = promisify(execFile);
+export const AM_CONFIG_API_VERSION = "protocol=2.0,resource=1.0";
+export function amConfigHeaders() {
+    return [["Accept-API-Version", AM_CONFIG_API_VERSION]];
+}
+export class AicLaneError extends Error {
+    status;
+    transactionId;
+    constructor(message, options = {}) {
+        super(message, options.cause !== undefined ? { cause: options.cause } : {});
+        this.name = "AicLaneError";
+        if (options.status !== undefined) {
+            this.status = options.status;
+        }
+        if (options.transactionId !== undefined) {
+            this.transactionId = options.transactionId;
+        }
+    }
+}
+export function defaultAicIo(project) {
+    const bin = process.env.AIC_BIN ?? join(project, "target", "debug", "aic");
+    return {
+        async aic(args) {
+            try {
+                const result = await execFileAsync(bin, args, {
+                    cwd: project,
+                    timeout: 30_000,
+                    encoding: "utf8",
+                    maxBuffer: 2_000_000,
+                });
+                return { status: 0, stdout: result.stdout, stderr: result.stderr };
+            }
+            catch (error) {
+                if (isExecError(error) && error.code === "ENOENT") {
+                    throw new AicLaneError(`no tenant provider configured: pass \`provider\`, call setTenantProvider(), ` +
+                        `or set ${TENANT_ENV.url} (see docs/rhino-local-harness.md); ` +
+                        `the aic fallback needs the aic CLI, and ${bin} does not exist (set AIC_BIN)`, { cause: error });
+                }
+                if (isExecError(error)) {
+                    return {
+                        status: error.code === null || error.code === undefined ? 1 : execStatus(error.code),
+                        stdout: error.stdout ?? "",
+                        stderr: error.stderr ?? error.message,
+                    };
+                }
+                throw error;
+            }
+        },
+        http: sendHttp,
+    };
+}
+function isExecError(error) {
+    return error instanceof Error;
+}
+function execStatus(code) {
+    return typeof code === "number" ? code : 1;
+}
+/**
+ * The provider a connection uses: the one passed, else the one registered
+ * with `setTenantProvider` or configured by `AIC_SCRIPT_TESTER_TENANT_URL`, else
+ * this repo's `aic` agent.
+ */
+export function resolveTenantProvider(io, options = {}) {
+    return (options.provider ??
+        (options.useConfigured === false ? undefined : configuredTenantProvider()) ??
+        aicCliProvider(io, {
+            ...(options.tenant === undefined ? {} : { tenant: options.tenant }),
+            ...(options.project === undefined ? {} : { project: options.project }),
+        }));
+}
+export async function connectTenant(io, options = {}) {
+    const provider = resolveTenantProvider(io, options);
+    const description = checkTenantDescription(await provider.describe());
+    if (options.tenant !== undefined && options.tenant !== description.name) {
+        throw new AicLaneError(
+        // Neither name is quoted: a provider's name defaults to its hostname.
+        "the tenant provider serves a different tenant from the one this run asks for (the `tenant` option)");
+    }
+    const token = await provider.getToken({ reason: "initial" });
+    return {
+        tenantName: description.name,
+        baseUrl: stripSlash(description.baseUrl),
+        token,
+        provider,
+    };
+}
+/**
+ * This repo's provider: the tenant and bearer come from the `aic` agent
+ * (`aic ctx list --json`, `aic whoami --token`), and logs from
+ * `aic logs tx --wait`. The agent must be unlocked; every call passes
+ * `--no-prompt` so a locked one fails instead of waiting for a password.
+ */
+export function aicCliProvider(io, options = {}) {
+    const project = options.project ?? projectRoot();
+    const noPrompt = ["--no-prompt", "--project", project];
+    let chosen;
+    function describe() {
+        chosen ??= chooseContext(io, noPrompt, options.tenant);
+        return chosen;
+    }
+    const logs = {
+        async transaction(id, readOptions = {}) {
+            const { name } = await describe();
+            const args = [...noPrompt, "logs", "tx", id, "--tenant", name, "--wait"];
+            if (readOptions.waitMs !== undefined) {
+                args.push("--timeout", String(Math.max(1, Math.ceil(readOptions.waitMs / 1000))));
+            }
+            const result = await io.aic(args);
+            if (result.status !== 0) {
+                throw new AicLaneError(formatLogsFailure(result), { status: result.status });
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(result.stdout);
+            }
+            catch (error) {
+                throw new AicLaneError("aic logs tx did not print JSON", { cause: error });
+            }
+            if (!Array.isArray(parsed)) {
+                throw new AicLaneError("aic logs tx did not print a JSON array");
+            }
+            return parsed;
+        },
+    };
+    return {
+        describe,
+        async getToken(request) {
+            const { name } = await describe();
+            const whoami = await io.aic([...noPrompt, "whoami", "--token", "--tenant", name]);
+            const during = request.reason === "rejected" ? " while refreshing the bearer" : "";
+            if (whoami.status !== 0) {
+                throw new AicLaneError(`aic whoami --token failed${during} (status ${whoami.status}): ${trim(whoami.stderr || whoami.stdout)}. Unlock the agent (aic login) or pass a reachable tenant.`);
+            }
+            const token = whoami.stdout.trim();
+            if (token.length === 0) {
+                throw new AicLaneError(`aic whoami --token printed an empty token${during}`);
+            }
+            return token;
+        },
+        logs,
+    };
+}
+async function chooseContext(io, noPrompt, tenant) {
+    const list = await io.aic([...noPrompt, "ctx", "list", "--json"]);
+    if (list.status !== 0) {
+        throw new AicLaneError(`aic ctx list failed (status ${list.status}): ${trim(list.stderr || list.stdout)}`);
+    }
+    const tenants = parseCtxList(list.stdout);
+    const chosen = tenant !== undefined
+        ? tenants.find((row) => row.name === tenant)
+        : tenants.find((row) => row.current) ?? tenants[0];
+    if (chosen === undefined) {
+        throw new AicLaneError(tenant === undefined
+            ? "aic ctx list returned no tenants"
+            : `aic ctx list has no tenant named ${JSON.stringify(tenant)}`);
+    }
+    return { name: chosen.name, baseUrl: stripSlash(chosen.base_url) };
+}
+function formatLogsFailure(result) {
+    const body = (result.stderr || result.stdout).trim();
+    const hint = "Unlock the agent (`aic login`) if it is locked.";
+    if (body.length === 0) {
+        return `aic logs tx failed (status ${result.status}). ${hint}`;
+    }
+    if (/locked|aic login|session login/i.test(body)) {
+        return body;
+    }
+    return `${body}\n${hint}`;
+}
+function parseCtxList(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new AicLaneError(`aic ctx list --json is not JSON: ${message}`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new AicLaneError("aic ctx list --json is not an array");
+    }
+    const rows = [];
+    for (const item of parsed) {
+        if (!isPlainObject(item) || typeof item.name !== "string" || typeof item.base_url !== "string") {
+            throw new AicLaneError("aic ctx list --json row is missing name/base_url");
+        }
+        rows.push({
+            current: item.current === true,
+            name: item.name,
+            base_url: item.base_url,
+        });
+    }
+    return rows;
+}
+/**
+ * Ask the provider for a replacement bearer and adopt it.
+ *
+ * The history below is the `aic` provider's, and it is why a 401 must reach
+ * the provider as `"rejected"`: a provider that caches has to know the token
+ * it holds is dead, rather than handing it back.
+ *
+ * MEASURED 2026-09-14 over 20 minutes: `aic whoami --token` handed back a
+ * token that worked *right now* and said nothing about how much life was left
+ * in it. The first token this probe was given was rejected 401 five minutes
+ * later, while a token fetched moments after it stayed good for the next ten —
+ * the agent rotated on its own ~898s schedule, so what you got depended on
+ * where in that cycle you asked.
+ *
+ * `aic` now guarantees `--token` at least 840 of those seconds, minting when
+ * the cached token is below the floor (MEASURED 2026-09-15: with 823s left the
+ * TTL jumped to 899 across the call, and with 864s left it did not move). That
+ * removes the reason this refresh usually fired, and none of the reasons it
+ * must stay: a file may run longer than the floor, the tenant may revoke, and
+ * an older `aic` on someone else's PATH makes no such promise. So the 401 retry
+ * remains the correctness mechanism and the floor is only what makes it rare.
+ */
+export async function refreshSessionToken(session) {
+    session.token = await session.provider.getToken({
+        reason: "rejected",
+        rejected: session.token,
+    });
+}
+export function realmJsonPath(realm) {
+    return `/am/json/realms/root/realms/${realm}`;
+}
+export async function amRequest(io, session, req) {
+    const first = await sendAmRequest(io, session, req);
+    // A 401 on an authenticated config call means the bearer died under us, not
+    // that the request was wrong — so refresh once and retry. Anonymous calls
+    // are excluded deliberately: `/authenticate` answers a journey that reached
+    // no declared outcome with a bare 401, and that is a verdict, not an
+    // expired token.
+    if (first.status !== 401 || req.anonymous === true) {
+        return first;
+    }
+    await refreshSessionToken(session);
+    return sendAmRequest(io, session, req);
+}
+async function sendAmRequest(io, session, req) {
+    const url = `${session.baseUrl}${req.path}`;
+    const headers = [
+        ["Accept", "application/json"],
+        ["Content-Type", "application/json"],
+        ...(req.headers ?? []),
+    ];
+    if (!req.anonymous) {
+        headers.push(["Authorization", `Bearer ${session.token}`]);
+        headers.push(["X-Requested-With", "XMLHttpRequest"]);
+    }
+    const response = await io.http({
+        url,
+        method: req.method,
+        headerLines: headers,
+        ...(req.body !== undefined ? { body: req.body } : {}),
+        ...(req.timeoutMs !== undefined ? { timeoutMs: req.timeoutMs } : {}),
+    });
+    const transactionId = headerValues(response.headers, "x-forgerock-transactionid")[0];
+    const bodyText = redact(response.body, session);
+    let body = null;
+    if (response.body.length > 0) {
+        try {
+            body = JSON.parse(response.body);
+        }
+        catch {
+            body = bodyText;
+        }
+    }
+    return {
+        status: response.status,
+        bodyText,
+        body,
+        ...(transactionId !== undefined ? { transactionId } : {}),
+    };
+}
+export function redact(text, session) {
+    let out = text;
+    const secrets = [session.token, session.baseUrl, hostnameOf(session.baseUrl)];
+    for (const secret of secrets) {
+        if (secret.length === 0) {
+            continue;
+        }
+        out = out.split(secret).join("<redacted>");
+    }
+    return out;
+}
+function hostnameOf(baseUrl) {
+    try {
+        return new URL(baseUrl).hostname;
+    }
+    catch {
+        return "";
+    }
+}
+function stripSlash(url) {
+    return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function trim(text) {
+    const sliced = text.trim().replace(/\s+/g, " ");
+    return sliced.length > 400 ? `${sliced.slice(0, 400)}…` : sliced;
+}

package/dist/src/aic/trace.d.ts

@@ -0,0 +1,25 @@
+/**
+ * One AIC-lane run's transaction ids, parked for the vitest hook to pick up
+ * if the test fails. Local-only tests never write one of these.
+ */
+export interface AicTrace {
+    stem: string;
+    passIds: string[];
+    tenantName: string;
+}
+export declare function noteAicTrace(trace: AicTrace): void;
+export declare function appendAicPass(id: string): void;
+export declare function peekAicTrace(): AicTrace | undefined;
+export declare function takeAicTrace(): AicTrace | undefined;
+export declare function clearAicTrace(): void;
+/** Subject chain: numbered passes under one stem. */
+export declare function beginTrace(tenantName: string, stem?: string): {
+    stem: string;
+    next: () => string;
+};
+/**
+ * A one-off authenticate that is not a numbered subject pass (the session
+ * minter). Published so a mint failure is still look-up-able; the subject
+ * trace replaces it if minting succeeds.
+ */
+export declare function beginSingleTrace(tenantName: string, id?: string): string;

package/dist/src/aic/trace.js

@@ -0,0 +1,56 @@
+import { newStem, passId } from "./txid.js";
+let current;
+export function noteAicTrace(trace) {
+    current = {
+        stem: trace.stem,
+        passIds: [...trace.passIds],
+        tenantName: trace.tenantName,
+    };
+}
+export function appendAicPass(id) {
+    if (current === undefined) {
+        throw new Error("rhino-local: appendAicPass without an active AIC trace");
+    }
+    current.passIds.push(id);
+}
+export function peekAicTrace() {
+    if (current === undefined) {
+        return undefined;
+    }
+    return {
+        stem: current.stem,
+        passIds: [...current.passIds],
+        tenantName: current.tenantName,
+    };
+}
+export function takeAicTrace() {
+    const out = peekAicTrace();
+    current = undefined;
+    return out;
+}
+export function clearAicTrace() {
+    current = undefined;
+}
+/** Subject chain: numbered passes under one stem. */
+export function beginTrace(tenantName, stem = newStem()) {
+    noteAicTrace({ stem, passIds: [], tenantName });
+    let step = 0;
+    return {
+        stem,
+        next() {
+            step += 1;
+            const id = passId(stem, step);
+            appendAicPass(id);
+            return id;
+        },
+    };
+}
+/**
+ * A one-off authenticate that is not a numbered subject pass (the session
+ * minter). Published so a mint failure is still look-up-able; the subject
+ * trace replaces it if minting succeeds.
+ */
+export function beginSingleTrace(tenantName, id = newStem()) {
+    noteAicTrace({ stem: id, passIds: [id], tenantName });
+    return id;
+}

package/dist/src/aic/txid.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AM's `/monitoring/logs?transactionId=` query is a prefix match
+ * (`docs/api/08-logs.md`). Unpadded `-1` silently absorbs `-10`. Two-digit
+ * padding keeps each pass separately addressable; the cap is the cost.
+ */
+export declare const MAX_PASSES = 99;
+export declare const PASS_DIGITS = 2;
+/** Request header AM accepts; the supplied value wins (`docs/api/02-headers-and-versioning.md`). */
+export declare const TX_HEADER = "x-forgerock-transactionid";
+export declare function newStem(): string;
+export declare function passId(stem: string, step: number): string;

package/dist/src/aic/txid.js

@@ -0,0 +1,25 @@
+import { randomUUID } from "node:crypto";
+/**
+ * AM's `/monitoring/logs?transactionId=` query is a prefix match
+ * (`docs/api/08-logs.md`). Unpadded `-1` silently absorbs `-10`. Two-digit
+ * padding keeps each pass separately addressable; the cap is the cost.
+ */
+export const MAX_PASSES = 99;
+export const PASS_DIGITS = 2;
+/** Request header AM accepts; the supplied value wins (`docs/api/02-headers-and-versioning.md`). */
+export const TX_HEADER = "x-forgerock-transactionid";
+export function newStem() {
+    return randomUUID();
+}
+export function passId(stem, step) {
+    if (stem.length === 0) {
+        throw new Error("rhino-local: transaction stem must be non-empty");
+    }
+    if (!Number.isInteger(step) || step < 1) {
+        throw new Error(`rhino-local: transaction step must be an integer >= 1, got ${String(step)}`);
+    }
+    if (step > MAX_PASSES) {
+        throw new Error(`rhino-local: transaction step ${step} exceeds ${MAX_PASSES} — two-digit padding would wrap into an id that is a prefix of another`);
+    }
+    return `${stem}-${String(step).padStart(PASS_DIGITS, "0")}`;
+}

package/dist/src/aic/unsupported.d.ts

@@ -0,0 +1,15 @@
+import type { Case } from "../case/types.ts";
+/**
+ * Why this case must not be executed on a tenant. `undefined` means the
+ * wrapper journey can seed `given` faithfully enough that a green AIC run
+ * is evidence, not coincidence.
+ *
+ * Environment-dependent inputs (`esv` / `secrets` / `managed` / `http`) are
+ * skipped rather than silently running against whatever the tenant holds.
+ * The one exception is managed state whose fixture-ledger provenance was
+ * checked by the caller; later chain passes may then carry records the subject
+ * itself created without turning the tenant lane back off.
+ */
+export declare function aicUnsupportedReason(kase: Case, options?: {
+    harnessOwnsManaged?: boolean;
+}): string | undefined;

package/dist/src/aic/unsupported.js

@@ -0,0 +1,60 @@
+import { isPortable } from "../case/portable.js";
+import { ENV_INPUT_KEYS } from "../case/types.js";
+function objectHasKeys(value) {
+    return value !== undefined && Object.keys(value).length > 0;
+}
+/**
+ * Why this case must not be executed on a tenant. `undefined` means the
+ * wrapper journey can seed `given` faithfully enough that a green AIC run
+ * is evidence, not coincidence.
+ *
+ * Environment-dependent inputs (`esv` / `secrets` / `managed` / `http`) are
+ * skipped rather than silently running against whatever the tenant holds.
+ * The one exception is managed state whose fixture-ledger provenance was
+ * checked by the caller; later chain passes may then carry records the subject
+ * itself created without turning the tenant lane back off.
+ */
+export function aicUnsupportedReason(kase, options = {}) {
+    if (kase.given.engine === "legacy") {
+        return "legacy engine: AIC wrapper emit is next-gen only (legacy results go through JavaImporter + Action.send, not callbacksBuilder)";
+    }
+    if (!isPortable(kase)) {
+        const declared = ENV_INPUT_KEYS.filter((key) => hasDeclaredEnv(kase.given, key) &&
+            !(key === "managed" && options.harnessOwnsManaged === true));
+        if (declared.length > 0) {
+            return `given.${declared.join(", ")} is environment-dependent; AIC lane skips rather than run against whatever the tenant holds`;
+        }
+    }
+    if (kase.given.resumedFromSuspend === true) {
+        return "given.resumedFromSuspend=true cannot be seeded on a first authenticate";
+    }
+    if (objectHasKeys(kase.given.secureState)) {
+        return "given.secureState: next-gen nodeState has no putSecure";
+    }
+    if (kase.given.scriptName !== undefined) {
+        return "given.scriptName cannot be seeded on AIC (it is the uploaded script's name)";
+    }
+    if (kase.given.cookieName !== undefined) {
+        return "given.cookieName cannot be seeded on AIC (it is a tenant serverinfo value)";
+    }
+    if (objectHasKeys(kase.given.locales)) {
+        return "given.locales cannot be seeded by a setup script";
+    }
+    if (objectHasKeys(kase.given.bindings)) {
+        return "given.bindings cannot be seeded on AIC (those are engine bindings, not nodeState)";
+    }
+    return undefined;
+}
+function hasDeclaredEnv(given, key) {
+    const value = given[key];
+    if (value === undefined || value === null) {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    if (typeof value === "object") {
+        return Object.keys(value).length > 0;
+    }
+    return true;
+}

package/dist/src/bindings/allowlist.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Boxed value types AM permits that its declared `allowLists` does not name.
+ *
+ * NOT from the descriptor, and kept separate from it so the audit trail shows
+ * which half of the policy is documented and which is not.
+ *
+ * The descriptor names `java.lang.Byte`, `Character`, `Float`, `Long`,
+ * `Number` and `Short` — but not `Double`, `Integer`, `Boolean` or `String`.
+ * That reads as an omission in AM's descriptor rather than a policy, because
+ * enforcing it would break rows the live matrix records as WORKING:
+ *
+ * - `java.util.Collections.*` is a live ✅ on the decision node, yet
+ *   `Collections.singletonMap("a", 1).get("a")` needs `java.lang.Double` —
+ *   Rhino converts a JS number to a Double. Without it the call fails with
+ *   `Access to Java class "java.lang.Double" is prohibited`.
+ * - An index loop is what `docs/api/12-script-bindings-matrix.md` calls "the
+ *   portable answer" for a Java List, and `list.get(0)` on a list of strings
+ *   hands back a `java.lang.String`.
+ *
+ * The same page records the matching anomaly in the other context:
+ * `java.lang.String` and `java.lang.Integer` resolve in validate-scope although
+ * neither is declared there — "the rule behind that split is not established".
+ *
+ * Scoped to the types Rhino produces converting JS primitives across the
+ * boundary, rather than a speculative widening.
+ *
+ * STATUS: inferred from live-recorded rows, NOT directly measured on a decision
+ * node. `packages/rhino-local` has a probe ready; measure and then either
+ * fold these into the descriptor's story or drop them.
+ */
+export declare const OBSERVED_BASE: readonly string[];
+/**
+ * The scripted decision node's Java class allow-list: the descriptor's declared
+ * entries plus `OBSERVED_BASE`.
+ *
+ * Read from the binding descriptor this project already extracted from AM
+ * (`docs/api/bindings/scripted-decision-next.json`), so the policy has one
+ * source and cannot drift from the document the rest of the harness generates
+ * its mocks from. Not hand-transcribed: a copied list is a list that goes
+ * stale silently.
+ */
+export declare function decisionNodeClassAllowList(): string[];