@agiledigital/pingone-aic-script-tester 0.1.0

package/dist/src/aic/diff.js

@@ -0,0 +1,201 @@
+import { deepEqual } from "../case/equal.js";
+import { diffState, sameMutationValue } from "../case/state.js";
+import { STATE_CHANNELS } from "../case/types.js";
+import { formatValue } from "../case/util.js";
+import { judge } from "../case/verdict.js";
+/** Compare observable effects without turning absent evidence into equality. */
+export function diffRecordedEffects(local, aic) {
+    const disagreements = [];
+    const observationGaps = [];
+    const localUnobserved = new Set(local.evidence?.unobservedChannels ?? []);
+    const aicUnobserved = new Set(aic.evidence?.unobservedChannels ?? []);
+    const localUnified = local.evidence?.stateBuckets === "unified";
+    const aicUnified = aic.evidence?.stateBuckets === "unified";
+    if (localUnified || aicUnified) {
+        observationGaps.push({
+            channel: "nodeState",
+            path: "buckets",
+            local: localUnified ? "unified" : "exact",
+            aic: aicUnified ? "unified" : "exact",
+            message: "nodeState: per-bucket absence and hidden lower-precedence writes cannot be compared through a unified view",
+        });
+    }
+    compareScalar("outcome", local.outcome, aic.outcome, localUnobserved, aicUnobserved, disagreements, observationGaps);
+    compareState(local, aic, localUnobserved, aicUnobserved, disagreements, observationGaps);
+    for (const channel of ["callbacks", "openidm", "http", "logs"]) {
+        compareArray(channel, local[channel], aic[channel], localUnobserved, aicUnobserved, disagreements, observationGaps);
+    }
+    return { disagreements, observationGaps };
+}
+function compareScalar(channel, local, aic, localUnobserved, aicUnobserved, disagreements, gaps) {
+    if (recordGapIfUnobserved(channel, localUnobserved, aicUnobserved, gaps)) {
+        return;
+    }
+    if (!deepEqual(local, aic)) {
+        disagreements.push(disagree(channel, channel, formatValue(local), formatValue(aic), `${channel}: local ${formatValue(local)}, AIC ${formatValue(aic)}`));
+    }
+}
+function compareArray(channel, local, aic, localUnobserved, aicUnobserved, disagreements, gaps) {
+    if (recordGapIfUnobserved(channel, localUnobserved, aicUnobserved, gaps)) {
+        return;
+    }
+    const length = Math.max(local.length, aic.length);
+    for (let index = 0; index < length; index += 1) {
+        if (deepEqual(local[index], aic[index])) {
+            continue;
+        }
+        disagreements.push(disagree(channel, `[${index}]`, local[index] === undefined ? "(none)" : formatValue(local[index]), aic[index] === undefined ? "(none)" : formatValue(aic[index]), `${channel}: [${index}] differed`));
+    }
+}
+function compareState(local, aic, localUnobserved, aicUnobserved, disagreements, gaps) {
+    const localMutations = collectState(local, localUnobserved, "local", gaps);
+    const aicMutations = collectState(aic, aicUnobserved, "AIC", gaps);
+    const remaining = aicMutations.slice();
+    const pairedAicKeys = new Set();
+    for (const localMutation of localMutations) {
+        const sameKey = remaining
+            .map((candidate, index) => ({ candidate, index }))
+            .filter(({ candidate }) => candidate.mutation.key === localMutation.mutation.key);
+        const equal = sameKey.find(({ candidate }) => sameMutationValue(localMutation.mutation, candidate.mutation));
+        const index = equal?.index ?? sameKey[0]?.index ?? -1;
+        if (index < 0) {
+            if (aic.evidence?.stateBuckets === "unified" &&
+                (unifiedBeforeHasKey(aic, localMutation.mutation.key) ||
+                    pairedAicKeys.has(localMutation.mutation.key))) {
+                gaps.push(hiddenMutationGap("AIC", localMutation));
+            }
+            else {
+                disagreements.push(stateDisagreement(localMutation, undefined));
+            }
+            continue;
+        }
+        const aicMutation = remaining[index];
+        remaining.splice(index, 1);
+        if (aicMutation === undefined) {
+            disagreements.push(stateDisagreement(localMutation, undefined));
+            continue;
+        }
+        pairedAicKeys.add(aicMutation.mutation.key);
+        if (!sameMutationValue(localMutation.mutation, aicMutation.mutation)) {
+            disagreements.push(stateDisagreement(localMutation, aicMutation));
+            continue;
+        }
+        if (localMutation.kind === "bucketed" && aicMutation.kind === "bucketed") {
+            if (localMutation.bucket !== aicMutation.bucket) {
+                disagreements.push(stateDisagreement(localMutation, aicMutation));
+            }
+            continue;
+        }
+        if (!locationsCompatible(localMutation, aicMutation)) {
+            disagreements.push(stateDisagreement(localMutation, aicMutation));
+            continue;
+        }
+        gaps.push({
+            channel: "nodeState",
+            path: localMutation.mutation.key,
+            local: formatLocated(localMutation),
+            aic: formatLocated(aicMutation),
+            message: `nodeState: ${JSON.stringify(localMutation.mutation.key)} value and operation agree, but its bucket is unobservable`,
+        });
+    }
+    for (const aicMutation of remaining) {
+        if (local.evidence?.stateBuckets === "unified" &&
+            unifiedBeforeHasKey(local, aicMutation.mutation.key)) {
+            gaps.push(hiddenMutationGap("local", aicMutation));
+        }
+        else {
+            disagreements.push(stateDisagreement(undefined, aicMutation));
+        }
+    }
+}
+function unifiedBeforeHasKey(effects, key) {
+    if (Object.prototype.hasOwnProperty.call(effects.evidence?.ambientState ?? {}, key)) {
+        return true;
+    }
+    return STATE_CHANNELS.some((bucket) => Object.prototype.hasOwnProperty.call(effects[bucket].initial, key));
+}
+function hiddenMutationGap(unobservingLane, observed) {
+    return {
+        channel: "nodeState",
+        path: observed.mutation.key,
+        local: unobservingLane === "local" ? "hidden by unified view" : formatLocated(observed),
+        aic: unobservingLane === "AIC" ? "hidden by unified view" : formatLocated(observed),
+        message: `nodeState: ${JSON.stringify(observed.mutation.key)} may be a lower-precedence or same-value write hidden from the ${unobservingLane} unified view`,
+    };
+}
+function collectState(effects, unobserved, lane, gaps) {
+    const mutations = [];
+    for (const bucket of STATE_CHANNELS) {
+        if (unobserved.has(bucket)) {
+            gaps.push({
+                channel: bucket,
+                path: bucket,
+                local: lane === "local" ? "unobserved" : "not compared",
+                aic: lane === "AIC" ? "unobserved" : "not compared",
+                message: `${bucket}: ${lane} lane cannot observe this channel`,
+            });
+            continue;
+        }
+        for (const mutation of diffState(effects[bucket].initial, effects[bucket].final)) {
+            mutations.push({ kind: "bucketed", bucket, mutation });
+        }
+    }
+    for (const mutation of effects.evidence?.unbucketedState ?? []) {
+        mutations.push({
+            kind: "unbucketed",
+            possibleBuckets: mutation.possibleBuckets,
+            mutation,
+        });
+    }
+    return mutations;
+}
+function locationsCompatible(a, b) {
+    if (a.kind === "bucketed" && b.kind === "unbucketed") {
+        return b.possibleBuckets.includes(a.bucket);
+    }
+    if (a.kind === "unbucketed" && b.kind === "bucketed") {
+        return a.possibleBuckets.includes(b.bucket);
+    }
+    if (a.kind === "unbucketed" && b.kind === "unbucketed") {
+        return a.possibleBuckets.some((bucket) => b.possibleBuckets.includes(bucket));
+    }
+    return true;
+}
+function recordGapIfUnobserved(channel, local, aic, gaps) {
+    if (!local.has(channel) && !aic.has(channel)) {
+        return false;
+    }
+    gaps.push({
+        channel,
+        path: channel,
+        local: local.has(channel) ? "unobserved" : "observed",
+        aic: aic.has(channel) ? "unobserved" : "observed",
+        message: `${channel}: lanes cannot be compared because ${local.has(channel) ? "local" : "AIC"} did not observe this channel`,
+    });
+    return true;
+}
+function stateDisagreement(local, aic) {
+    const key = local?.mutation.key ?? aic?.mutation.key ?? "state";
+    return disagree("nodeState", key, local === undefined ? "(none)" : formatLocated(local), aic === undefined ? "(none)" : formatLocated(aic), `nodeState: ${JSON.stringify(key)} differed`);
+}
+function formatLocated(value) {
+    const location = value.kind === "bucketed"
+        ? value.bucket
+        : `one of ${value.possibleBuckets.join(", ")}`;
+    return `${formatMutation(value.mutation)} in ${location}`;
+}
+function formatMutation(mutation) {
+    if (mutation.operation === "removed") {
+        return `removed (was ${formatValue(mutation.before)})`;
+    }
+    if (mutation.operation === "added") {
+        return `added ${formatValue(mutation.after)}`;
+    }
+    return `changed ${formatValue(mutation.before)} → ${formatValue(mutation.after)}`;
+}
+function disagree(channel, path, local, aic, message) {
+    return { channel, path, local, aic, message };
+}
+export function judgeBoth(kase, local, aic) {
+    return { local: judge(kase, local), aic: judge(kase, aic) };
+}

package/dist/src/aic/emit-journey.d.ts

@@ -0,0 +1,64 @@
+import type { Case } from "../case/types.ts";
+import type { LeaseIdentity } from "./lease-identity.ts";
+export interface EmitJourneyOptions {
+    /** Short token used in tree/script names. Must match `[A-Za-z0-9-]{1,32}`. */
+    runId?: string;
+    realm?: string;
+    idFactory?: () => string;
+}
+export interface WrapperInvoke {
+    headers: Record<string, string[]>;
+    parameters: Record<string, string[]>;
+    cookies: Record<string, string>;
+}
+export interface ScriptResource {
+    id: string;
+    name: string;
+    source: string;
+    role: "subject" | "result";
+    /** Baked-in outcome, only for `role: "result"`. */
+    outcome?: string;
+}
+export interface NodeResource {
+    id: string;
+    displayName: string;
+    scriptId: string;
+    outcomes: string[];
+    connections: Record<string, string>;
+    x: number;
+    y: number;
+}
+export interface WrapperJourney {
+    treeName: string;
+    realm: string;
+    identityResource: string;
+    scripts: ScriptResource[];
+    nodes: NodeResource[];
+    /** Tree PUT body. No `_id` / `_rev`. */
+    treeBody: Record<string, unknown>;
+    /** Node PUT bodies keyed by node id. */
+    nodeBodies: Record<string, Record<string, unknown>>;
+    subjectOutcomes: string[];
+    invoke: WrapperInvoke;
+}
+export interface LeasedJourneyOptions {
+    identity: LeaseIdentity;
+    realm: string;
+    suiteName: string;
+}
+/**
+ * Outcomes declared on the subject node. Always includes `true` and `false`
+ * plus `expect.outcome` and everything `case.outcomes` declares, so a script
+ * that takes the other branch still reaches a result node that can dump state.
+ * A pass expected to suspend has no outcome to add, which is why the declared
+ * vocabulary is folded in as well — otherwise a step chain would wire up only
+ * the outcomes its first pass mentions.
+ */
+export declare function subjectOutcomes(kase: Case): string[];
+export declare function emitWrapperJourney(kase: Case, source: string, options?: EmitJourneyOptions): WrapperJourney;
+/** Emit the fixed graph owned by one file lease. */
+export declare function emitLeasedJourney(options: LeasedJourneyOptions): WrapperJourney;
+export declare const STATIC_NODE_IDS: {
+    readonly success: "70e691a5-1e33-4ac3-a356-e7b6d60d92e0";
+    readonly failure: "e301438c-0bd0-429c-ab0c-66126501069a";
+};

package/dist/src/aic/emit-journey.js

@@ -0,0 +1,254 @@
+import { randomUUID } from "node:crypto";
+import { FAILURE_NODE_ID, RESOURCE_PREFIX, SETUP_OUTCOME, SUCCESS_NODE_ID, } from "./constants.js";
+import { emitResultScript } from "./emit-result.js";
+import { instrumentSubject } from "./emit-subject.js";
+const RUN_ID_PATTERN = /^[A-Za-z0-9-]{1,32}$/;
+/**
+ * Outcomes declared on the subject node. Always includes `true` and `false`
+ * plus `expect.outcome` and everything `case.outcomes` declares, so a script
+ * that takes the other branch still reaches a result node that can dump state.
+ * A pass expected to suspend has no outcome to add, which is why the declared
+ * vocabulary is folded in as well — otherwise a step chain would wire up only
+ * the outcomes its first pass mentions.
+ */
+export function subjectOutcomes(kase) {
+    const set = new Set(["true", "false"]);
+    if (kase.expect.outcome !== null) {
+        set.add(kase.expect.outcome);
+    }
+    for (const outcome of kase.outcomes ?? []) {
+        set.add(outcome);
+    }
+    return [...set];
+}
+export function emitWrapperJourney(kase, source, options = {}) {
+    if (kase.given.engine === "legacy") {
+        throw new Error("rhino-local: AIC wrapper emit is next-gen only; legacy needs JavaImporter + Action.send");
+    }
+    const runId = options.runId ?? randomUUID().replace(/-/g, "").slice(0, 12);
+    if (!RUN_ID_PATTERN.test(runId)) {
+        throw new Error(`rhino-local: runId ${JSON.stringify(runId)} must match ${RUN_ID_PATTERN}`);
+    }
+    const realm = options.realm ?? kase.given.realm ?? "alpha";
+    const nextId = options.idFactory ?? randomUUID;
+    const outcomes = subjectOutcomes(kase);
+    const treeName = `${RESOURCE_PREFIX}-${runId}`;
+    const instrumented = instrumentSubject(source, runId, kase.given);
+    const subjectScript = {
+        id: nextId(),
+        name: `${treeName}-subject`,
+        source: instrumented.source,
+        role: "subject",
+    };
+    const resultScripts = [];
+    const resultNodes = [];
+    const resultByOutcome = new Map();
+    for (let index = 0; index < outcomes.length; index += 1) {
+        const outcome = outcomes[index];
+        if (outcome === undefined) {
+            continue;
+        }
+        const script = {
+            id: nextId(),
+            name: `${treeName}-result-${slug(outcome)}`,
+            source: emitResultScript(outcome, instrumented.snapshotKey),
+            role: "result",
+            outcome,
+        };
+        resultScripts.push(script);
+        const node = {
+            id: nextId(),
+            displayName: `result ${outcome}`,
+            scriptId: script.id,
+            outcomes: [SETUP_OUTCOME],
+            connections: { [SETUP_OUTCOME]: SUCCESS_NODE_ID },
+            x: 560,
+            y: 80 + index * 140,
+        };
+        resultNodes.push(node);
+        resultByOutcome.set(outcome, node);
+    }
+    const subjectConnections = {};
+    for (const outcome of outcomes) {
+        const resultNode = resultByOutcome.get(outcome);
+        if (resultNode === undefined) {
+            continue;
+        }
+        subjectConnections[outcome] = resultNode.id;
+    }
+    const subjectNode = {
+        id: nextId(),
+        displayName: kase.name,
+        scriptId: subjectScript.id,
+        outcomes,
+        connections: subjectConnections,
+        x: 80,
+        y: 200,
+    };
+    const nodes = [subjectNode, ...resultNodes];
+    const scripts = [subjectScript, ...resultScripts];
+    const treeNodes = {};
+    for (const node of nodes) {
+        treeNodes[node.id] = {
+            connections: node.connections,
+            displayName: node.displayName,
+            nodeType: "ScriptedDecisionNode",
+            version: "1.0",
+            x: node.x,
+            y: node.y,
+        };
+    }
+    const treeBody = {
+        identityResource: `managed/${realm}_user`,
+        entryNodeId: subjectNode.id,
+        innerTreeOnly: false,
+        description: "rhino-local AIC lane throwaway. Safe to delete.",
+        noSession: false,
+        mustRun: false,
+        enabled: true,
+        transactionalOnly: false,
+        uiConfig: { categories: '["Test"]' },
+        nodes: treeNodes,
+    };
+    const nodeBodies = {};
+    for (const node of nodes) {
+        nodeBodies[node.id] = scriptedDecisionBody(node);
+    }
+    return {
+        treeName,
+        realm,
+        identityResource: `managed/${realm}_user`,
+        scripts,
+        nodes,
+        treeBody,
+        nodeBodies,
+        subjectOutcomes: outcomes,
+        invoke: {
+            headers: copyStringArrayMap(kase.given.requestHeaders),
+            parameters: copyStringArrayMap(kase.given.requestParameters),
+            cookies: copyStringMap(kase.given.requestCookies),
+        },
+    };
+}
+/** Emit the fixed graph owned by one file lease. */
+export function emitLeasedJourney(options) {
+    const { identity } = options;
+    const inertSource = [
+        `// ${identity.marker}`,
+        "// Inert until the owning file lease arms this subject slot.",
+        'throw new Error("rhino-local AIC subject invoked before it was armed");',
+        "",
+    ].join("\n");
+    const subjectScript = {
+        id: identity.ids.subjectScript,
+        name: `${identity.treeName}-subject`,
+        source: inertSource,
+        role: "subject",
+    };
+    const resultScripts = identity.outcomes.map((outcome) => ({
+        id: identity.ids.resultScripts[outcome],
+        name: `${identity.treeName}-result-${slug(outcome)}`,
+        source: `${`// ${identity.marker}\n`}${emitResultScript(outcome, identity.snapshotKey, identity.structuralDigest)}`,
+        role: "result",
+        outcome,
+    }));
+    const resultNodes = identity.outcomes.map((outcome, index) => ({
+        id: identity.ids.resultNodes[outcome],
+        displayName: `result ${outcome}`,
+        scriptId: identity.ids.resultScripts[outcome],
+        outcomes: [SETUP_OUTCOME],
+        connections: { [SETUP_OUTCOME]: SUCCESS_NODE_ID },
+        x: 560,
+        y: 80 + index * 140,
+    }));
+    const subjectConnections = Object.fromEntries(identity.outcomes.map((outcome) => [
+        outcome,
+        identity.ids.resultNodes[outcome],
+    ]));
+    const subjectNode = {
+        id: identity.ids.subjectNode,
+        displayName: options.suiteName,
+        scriptId: subjectScript.id,
+        outcomes: [...identity.outcomes],
+        connections: subjectConnections,
+        x: 80,
+        y: 200,
+    };
+    const nodes = [subjectNode, ...resultNodes];
+    const treeNodes = Object.fromEntries(nodes.map((node) => [
+        node.id,
+        {
+            connections: node.connections,
+            displayName: node.displayName,
+            nodeType: "ScriptedDecisionNode",
+            x: node.x,
+            y: node.y,
+        },
+    ]));
+    const nodeBodies = Object.fromEntries(nodes.map((node) => [node.id, leasedScriptedDecisionBody(node)]));
+    return {
+        treeName: identity.treeName,
+        realm: options.realm,
+        identityResource: `managed/${options.realm}_user`,
+        scripts: [subjectScript, ...resultScripts],
+        nodes,
+        treeBody: {
+            identityResource: `managed/${options.realm}_user`,
+            entryNodeId: subjectNode.id,
+            description: identity.marker,
+            enabled: true,
+            uiConfig: { categories: '["Test"]' },
+            nodes: treeNodes,
+        },
+        nodeBodies,
+        subjectOutcomes: [...identity.outcomes],
+        invoke: { headers: {}, parameters: {}, cookies: {} },
+    };
+}
+function scriptedDecisionBody(node) {
+    return {
+        _id: node.id,
+        _type: {
+            _id: "ScriptedDecisionNode",
+            collection: true,
+            name: "Scripted Decision",
+        },
+        _outcomes: node.outcomes.map((id) => ({ id, displayName: id })),
+        inputs: ["*"],
+        outputs: ["*"],
+        outcomes: node.outcomes,
+        script: node.scriptId,
+    };
+}
+function leasedScriptedDecisionBody(node) {
+    return {
+        inputs: ["*"],
+        outputs: ["*"],
+        outcomes: node.outcomes,
+        script: node.scriptId,
+    };
+}
+function slug(outcome) {
+    const cleaned = outcome.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    return cleaned.length > 0 ? cleaned : "outcome";
+}
+function copyStringArrayMap(value) {
+    if (value === undefined) {
+        return {};
+    }
+    const copy = {};
+    for (const [key, items] of Object.entries(value)) {
+        copy[key] = items.slice();
+    }
+    return copy;
+}
+function copyStringMap(value) {
+    if (value === undefined) {
+        return {};
+    }
+    return { ...value };
+}
+export const STATIC_NODE_IDS = {
+    success: SUCCESS_NODE_ID,
+    failure: FAILURE_NODE_ID,
+};

package/dist/src/aic/emit-result.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Next-gen scripted-decision source that dumps final `nodeState` into a
+ * HiddenValueCallback. `outcome` is baked in because the tree routes each
+ * subject-node outcome to a dedicated result node — the result script cannot
+ * see which connection brought it here.
+ *
+ * Does not compare against `expect`. The runner builds `RecordedEffects`
+ * from the dump; `judge()` in verdict.ts is the only pass/fail implementation.
+ */
+export declare function emitResultScript(outcome: string, snapshotKey: string, leaseDigest?: string): string;

package/dist/src/aic/emit-result.js

@@ -0,0 +1,39 @@
+import { HARNESS_CALLBACK_ID } from "./constants.js";
+import { jsStringLiteral } from "./js.js";
+const HEADER = `\
+// Generated by rhino-local AIC lane. Returns the subject node's snapshots.
+// Comparison against the case happens in verdict.ts, not here.
+`;
+/**
+ * Next-gen scripted-decision source that dumps final `nodeState` into a
+ * HiddenValueCallback. `outcome` is baked in because the tree routes each
+ * subject-node outcome to a dedicated result node — the result script cannot
+ * see which connection brought it here.
+ *
+ * Does not compare against `expect`. The runner builds `RecordedEffects`
+ * from the dump; `judge()` in verdict.ts is the only pass/fail implementation.
+ */
+export function emitResultScript(outcome, snapshotKey, leaseDigest) {
+    const idLit = jsStringLiteral(HARNESS_CALLBACK_ID);
+    const outcomeLit = jsStringLiteral(outcome);
+    const keyLit = jsStringLiteral(snapshotKey);
+    return [
+        HEADER,
+        `var __rhinoLocalOutcome = ${outcomeLit};`,
+        `var __rhinoLocalSnapshots = JSON.parse(String(nodeState.get(${keyLit})));`,
+        `var __rhinoLocalPayload = JSON.stringify({`,
+        `  outcome: __rhinoLocalOutcome,`,
+        `  before: __rhinoLocalSnapshots.before,`,
+        `  final: __rhinoLocalSnapshots.final,`,
+        `  invocationNonce: __rhinoLocalSnapshots.invocationNonce,`,
+        `  subjectDigest: __rhinoLocalSnapshots.subjectDigest${leaseDigest === undefined ? "" : ","}`,
+        ...(leaseDigest === undefined
+            ? []
+            : [`  leaseDigest: ${jsStringLiteral(leaseDigest)}`]),
+        `});`,
+        `if (callbacks.isEmpty()) {`,
+        `  callbacksBuilder.hiddenValueCallback(${idLit}, __rhinoLocalPayload);`,
+        `}`,
+        ``,
+    ].join("\n");
+}

package/dist/src/aic/emit-session.d.ts

@@ -0,0 +1,26 @@
+import type { WrapperJourney } from "./emit-journey.ts";
+import type { LeaseIdentity } from "./lease-identity.ts";
+/**
+ * A journey whose only job is to end, so that AM issues a session.
+ *
+ * There is no other way: a session exists only once a journey has run to
+ * completion (`docs/api/09-journeys.md` → "Minting a session for a test").
+ * Measured 2026-09-14 — the tree needs no Identify Existing User node, the
+ * principal need not exist as a managed object, and the journey that later
+ * *consumes* the session needs no configuration at all.
+ *
+ * AM-owned properties are dropped rather than sent. `putSessionProperty` does
+ * not override them; the whole login fails with a bare `401 Unauthorized`
+ * naming nothing, so sending one would turn a harness bug into an unexplained
+ * authentication failure. The five AM derives from the principal arrive by
+ * authenticating AS that principal instead.
+ */
+export declare function emitSessionJourney(session: Record<string, string>, options: {
+    runId: string;
+    realm: string;
+}): WrapperJourney;
+/** Deterministic session-minter resources owned by a file lease. */
+export declare function emitLeasedSessionJourney(session: Record<string, string>, options: {
+    identity: LeaseIdentity;
+    realm: string;
+}): WrapperJourney;