@kensio/yulin 1.20.0 → 1.20.2

package/dist/service/stepfunctions/task/sim-states-task-fields.js

@@ -0,0 +1,29 @@
+import { SimStatesUnsimulatedInput } from "../error/sim-step-functions.error.js";
+/**
+ * The fields of a `Task` state this simulator has no implementation for.
+ */
+export const simStatesTaskFieldsUnsimulated = [
+    "Retry",
+    "Catch",
+    "TimeoutSeconds",
+    "TimeoutSecondsPath",
+    "HeartbeatSeconds",
+    "HeartbeatSecondsPath",
+    "Credentials",
+];
+/**
+ * Refuse the fields of a `Task` state this simulator does not run.
+ *
+ * A definition carrying one of them would behave differently here than it does
+ * on AWS. A task that failed would end the execution rather than being retried,
+ * and a task that ran long would answer rather than time out.
+ */
+export function checkSimStatesTaskFields(stateName, state) {
+    const present = simStatesTaskFieldsUnsimulated.filter((field) => Object.hasOwn(state, field));
+    if (present.length > 0) {
+        throw new SimStatesUnsimulatedInput(`The Task state ${stateName} carries ${present.join(", ")}, which this ` +
+            "simulator does not run yet. A task that fails ends the execution, " +
+            "and a task that runs long runs to whatever its handler answers.");
+    }
+}
+//# sourceMappingURL=sim-states-task-fields.js.map

package/dist/service/stepfunctions/task/sim-states-task-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-task-fields.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/task/sim-states-task-fields.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAEjF;;GAEG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG;IAC5C,OAAO;IACP,OAAO;IACP,gBAAgB;IAChB,oBAAoB;IACpB,kBAAkB;IAClB,sBAAsB;IACtB,aAAa;CACL,CAAC;AAEX;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACtC,SAAiB,EACjB,KAAgC;IAEhC,MAAM,OAAO,GAAG,8BAA8B,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAC9D,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAC5B,CAAC;IAEF,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,SAAS,YAAY,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe;YACtE,oEAAoE;YACpE,iEAAiE,CACpE,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/service/stepfunctions/task/sim-states-task-function.d.ts

@@ -0,0 +1,57 @@
+import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
+import type { SimAwsAccountRegionContainer } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimLambdaFunctionReference } from "../../lambda/function/sim-lambda-function-reference.js";
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesTaskTarget } from "./sim-states-task-target.js";
+interface SimStatesTaskFunctionProperties {
+    readonly scope: SimAwsAccountRegionContainer;
+}
+/**
+ * One `Task` state's invocation of a function.
+ */
+export interface SimStatesTaskFunctionRequest {
+    readonly stateName: string;
+    readonly target: SimStatesTaskTarget;
+    readonly reference: SimLambdaFunctionReference;
+    /**
+     * What the state named the function, which is what its messages say.
+     */
+    readonly named: string;
+    readonly payload: JSONValue;
+    readonly caller: SimAwsCaller;
+}
+/**
+ * A Lambda function a `Task` state invokes, in the Account and Region the
+ * function is in.
+ *
+ * The function is resolved on every task rather than when the state machine
+ * was created, so an alias moved to another version moves what runs and a
+ * permission taken away stops the task.
+ */
+export declare class SimStatesTaskFunction {
+    #private;
+    constructor(properties: SimStatesTaskFunctionProperties);
+    /**
+     * Invoke the function as the execution role, if the role may.
+     */
+    invoke(request: SimStatesTaskFunctionRequest): Promise<JSONValue>;
+    /**
+     * Ask the function's own Account whether the execution role may invoke it.
+     *
+     * The function's resource policy is not consulted, which is the difference
+     * from an EventBridge rule target. The task arrives as an assumed role
+     * rather than as a service principal, and a role in the same Account needs
+     * only its own identity policy.
+     */
+    private authorize;
+    /**
+     * Run the handler, and read a task failure off it raising.
+     *
+     * Invoked directly rather than through an `Invoke` command, because a
+     * handler failure has to reach the task rather than being answered as an
+     * error payload the state would take for a result.
+     */
+    private run;
+}
+export {};
+//# sourceMappingURL=sim-states-task-function.d.ts.map

package/dist/service/stepfunctions/task/sim-states-task-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-task-function.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/task/sim-states-task-function.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AAE9F,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wDAAwD,CAAC;AACzG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAOvE,UAAU,+BAA+B;IACvC,QAAQ,CAAC,KAAK,EAAE,4BAA4B,CAAC;CAC9C;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,0BAA0B,CAAC;IAE/C;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,qBAAa,qBAAqB;;IAGhC,YAAY,UAAU,EAAE,+BAA+B,EAEtD;IAED;;OAEG;IACG,MAAM,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,SAAS,CAAC,CAoBtE;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAmBjB;;;;;;OAMG;YACW,GAAG;CAclB"}

package/dist/service/stepfunctions/task/sim-states-task-function.js

@@ -0,0 +1,93 @@
+import { SimStatesTaskFailure } from "../error/sim-step-functions.error.js";
+/**
+ * The action an execution needs to invoke a function.
+ */
+const invokeAction = "lambda:InvokeFunction";
+/**
+ * A Lambda function a `Task` state invokes, in the Account and Region the
+ * function is in.
+ *
+ * The function is resolved on every task rather than when the state machine
+ * was created, so an alias moved to another version moves what runs and a
+ * permission taken away stops the task.
+ */
+export class SimStatesTaskFunction {
+    #scope;
+    constructor(properties) {
+        this.#scope = properties.scope;
+    }
+    /**
+     * Invoke the function as the execution role, if the role may.
+     */
+    async invoke(request) {
+        const found = this.#scope
+            .lambda()
+            .getSimFunctionTarget(request.reference.functionName, request.reference.qualifier);
+        if (found === undefined) {
+            throw new SimStatesTaskFailure(`The Task state ${request.stateName} invokes ${request.named}, ` +
+                "which is not a simulated Lambda function.");
+        }
+        this.authorize(request, found.resource.arn);
+        const result = await this.run(request, found.simFunction);
+        return request.target.answer(result, found.simFunction.version);
+    }
+    /**
+     * Ask the function's own Account whether the execution role may invoke it.
+     *
+     * The function's resource policy is not consulted, which is the difference
+     * from an EventBridge rule target. The task arrives as an assumed role
+     * rather than as a service principal, and a role in the same Account needs
+     * only its own identity policy.
+     */
+    authorize(request, functionArn) {
+        const decision = this.#scope.iam().authorize({
+            action: invokeAction,
+            resource: functionArn,
+            caller: request.caller,
+        });
+        if (decision.isDenied) {
+            throw new SimStatesTaskFailure(`The Task state ${request.stateName} is not allowed to ` +
+                `${invokeAction} on ${functionArn}. Grant it in a policy on the ` +
+                "state machine's execution role.");
+        }
+    }
+    /**
+     * Run the handler, and read a task failure off it raising.
+     *
+     * Invoked directly rather than through an `Invoke` command, because a
+     * handler failure has to reach the task rather than being answered as an
+     * error payload the state would take for a result.
+     */
+    async run(request, simFunction) {
+        let result;
+        try {
+            result = await simFunction.invoke(request.payload);
+        }
+        catch (error) {
+            throw request.target.handlerFailure(error, request.stateName);
+        }
+        return readTaskResult(result, request.stateName);
+    }
+}
+/**
+ * Read what the handler answered as the JSON the execution carries on with.
+ *
+ * The answer crosses the same JSON serialisation a real invocation's payload
+ * does, so a `Date` a handler returns reaches the next state as the string it
+ * would there, and a handler answering with nothing answers `null`.
+ */
+function readTaskResult(result, stateName) {
+    if (result === undefined) {
+        return null;
+    }
+    let serialised;
+    try {
+        serialised = JSON.stringify(result);
+    }
+    catch {
+        throw new SimStatesTaskFailure(`The function the Task state ${stateName} invoked answered with ` +
+            "something that is not JSON.");
+    }
+    return JSON.parse(serialised);
+}
+//# sourceMappingURL=sim-states-task-function.js.map

package/dist/service/stepfunctions/task/sim-states-task-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-task-function.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/task/sim-states-task-function.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAG5E;;GAEG;AACH,MAAM,YAAY,GAAG,uBAAuB,CAAC;AAuB7C;;;;;;;GAOG;AACH,MAAM,OAAO,qBAAqB;IACvB,MAAM,CAA+B;IAE9C,YAAY,UAA2C;QACrD,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,OAAqC;QAChD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM;aACtB,MAAM,EAAE;aACR,oBAAoB,CACnB,OAAO,CAAC,SAAS,CAAC,YAAY,EAC9B,OAAO,CAAC,SAAS,CAAC,SAAS,CAC5B,CAAC;QAEJ,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,oBAAoB,CAC5B,kBAAkB,OAAO,CAAC,SAAS,YAAY,OAAO,CAAC,KAAK,IAAI;gBAC9D,2CAA2C,CAC9C,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAE5C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;QAE1D,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;OAOG;IACK,SAAS,CACf,OAAqC,EACrC,WAAmB;QAEnB,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC;YAC3C,MAAM,EAAE,YAAY;YACpB,QAAQ,EAAE,WAAW;YACrB,MAAM,EAAE,OAAO,CAAC,MAAM;SACvB,CAAC,CAAC;QAEH,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACtB,MAAM,IAAI,oBAAoB,CAC5B,kBAAkB,OAAO,CAAC,SAAS,qBAAqB;gBACtD,GAAG,YAAY,OAAO,WAAW,gCAAgC;gBACjE,iCAAiC,CACpC,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,KAAK,CAAC,GAAG,CACf,OAAqC,EACrC,WAA8B;QAE9B,IAAI,MAAe,CAAC;QAEpB,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACrD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;QAChE,CAAC;QAED,OAAO,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACnD,CAAC;CACF;AAED;;;;;;GAMG;AACH,SAAS,cAAc,CAAC,MAAe,EAAE,SAAiB;IACxD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,UAAkB,CAAC;IAEvB,IAAI,CAAC;QACH,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,oBAAoB,CAC5B,+BAA+B,SAAS,yBAAyB;YAC/D,6BAA6B,CAChC,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,CAAc,CAAC;AAC7C,CAAC"}

package/dist/service/stepfunctions/task/sim-states-task-invocation.d.ts

@@ -0,0 +1,29 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesTaskTarget } from "./sim-states-task-target.js";
+/**
+ * One `Task` state's invocation, as the state leaves it.
+ */
+export interface SimStatesTaskInvocation {
+    readonly stateName: string;
+    readonly target: SimStatesTaskTarget;
+    /**
+     * What the state's `InputPath` and `Parameters` produced.
+     */
+    readonly payload: JSONValue;
+    /**
+     * The state machine's execution role, which the execution assumes to do the
+     * work.
+     */
+    readonly roleArn: string;
+}
+/**
+ * Where a `Task` state's work is done.
+ *
+ * A state machine reaches a function through this rather than holding one, so
+ * a `SimStepFunctions` built on its own has somewhere to say that there is
+ * nothing to reach.
+ */
+export interface SimStatesTaskTargets {
+    invoke(invocation: SimStatesTaskInvocation): Promise<JSONValue>;
+}
+//# sourceMappingURL=sim-states-task-invocation.d.ts.map

package/dist/service/stepfunctions/task/sim-states-task-invocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-task-invocation.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/task/sim-states-task-invocation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,UAAU,EAAE,uBAAuB,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACjE"}

package/dist/service/stepfunctions/task/sim-states-task-invocation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sim-states-task-invocation.js.map

package/dist/service/stepfunctions/task/sim-states-task-invocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-task-invocation.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/task/sim-states-task-invocation.ts"],"names":[],"mappings":""}

package/dist/service/stepfunctions/task/sim-states-task-resource.d.ts

@@ -0,0 +1,12 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesTaskTarget } from "./sim-states-task-target.js";
+/**
+ * Read what a `Task` state's `Resource` names.
+ *
+ * This runs when the state machine is created, so a `Resource` this simulator
+ * cannot reach is refused there rather than when an execution arrives at the
+ * state. The service integrations beyond Lambda are refused here by name, and
+ * are where each of them will be added.
+ */
+export declare function parseSimStatesTaskResource(stateName: string, state: Record<string, JSONValue>): SimStatesTaskTarget;
+//# sourceMappingURL=sim-states-task-resource.d.ts.map

package/dist/service/stepfunctions/task/sim-states-task-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-task-resource.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/task/sim-states-task-resource.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAYlE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAC/B,mBAAmB,CAyBrB"}

package/dist/service/stepfunctions/task/sim-states-task-resource.js

@@ -0,0 +1,64 @@
+import { parseSimLambdaFunctionArn } from "../../lambda/function/sim-lambda-function-arn-parts.js";
+import { isRecord } from "../../../util/type-guard/record.js";
+import { SimStatesInvalidDefinition, SimStatesUnsimulatedInput, } from "../error/sim-step-functions.error.js";
+import { SimStatesFunctionArnTarget } from "./sim-states-function-arn-target.js";
+import { SimStatesLambdaInvokeTarget, simStatesLambdaInvokeParameters, simStatesLambdaInvokeResource, } from "./sim-states-lambda-invoke-target.js";
+/**
+ * Read what a `Task` state's `Resource` names.
+ *
+ * This runs when the state machine is created, so a `Resource` this simulator
+ * cannot reach is refused there rather than when an execution arrives at the
+ * state. The service integrations beyond Lambda are refused here by name, and
+ * are where each of them will be added.
+ */
+export function parseSimStatesTaskResource(stateName, state) {
+    const resource = state["Resource"];
+    if (typeof resource !== "string" || resource === "") {
+        throw new SimStatesInvalidDefinition(`The Task state ${stateName} has no Resource saying what it does.`);
+    }
+    if (resource === simStatesLambdaInvokeResource) {
+        checkInvokeParameters(stateName, state["Parameters"]);
+        return new SimStatesLambdaInvokeTarget();
+    }
+    if (parseSimLambdaFunctionArn(resource) !== undefined) {
+        return new SimStatesFunctionArnTarget({ functionArn: resource });
+    }
+    throw new SimStatesUnsimulatedInput(`The Task state ${stateName} has a Resource of ${resource}, which this ` +
+        "simulator does not run. A Task state invokes a simulated Lambda " +
+        `function, through ${simStatesLambdaInvokeResource} or through a ` +
+        "function ARN.");
+}
+/**
+ * Check the `Invoke` request the state's `Parameters` build.
+ *
+ * The field naming the function is required, as it is on real Step Functions,
+ * and the fields of an `Invoke` this does not make are refused by name.
+ */
+function checkInvokeParameters(stateName, parameters) {
+    if (!isRecord(parameters)) {
+        throw new SimStatesInvalidDefinition(`The Task state ${stateName} invokes a function and carries no ` +
+            "Parameters. A Parameters naming the function to invoke is what " +
+            `${simStatesLambdaInvokeResource} takes.`);
+    }
+    const fields = Object.keys(parameters).map(fieldName);
+    if (!fields.includes("FunctionName")) {
+        throw new SimStatesInvalidDefinition(`The Parameters of the Task state ${stateName} carry no FunctionName ` +
+            "naming the function to invoke.");
+    }
+    const beyond = fields.filter((field) => !simStatesLambdaInvokeParameters.includes(field));
+    if (beyond.length > 0) {
+        throw new SimStatesUnsimulatedInput(`The Parameters of the Task state ${stateName} carry ` +
+            `${beyond.join(", ")}. This simulator invokes a function with ` +
+            `${simStatesLambdaInvokeParameters.join(" and ")}.`);
+    }
+}
+/**
+ * The field one Payload Template key stands for.
+ *
+ * A key ending in `.$` holds a path to read rather than a value, and both
+ * spellings name the same field of the request.
+ */
+function fieldName(key) {
+    return key.endsWith(".$") ? key.slice(0, -2) : key;
+}
+//# sourceMappingURL=sim-states-task-resource.js.map

package/dist/service/stepfunctions/task/sim-states-task-resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-task-resource.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/task/sim-states-task-resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,wDAAwD,CAAC;AAEnG,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAC9D,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,GAC1B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EACL,2BAA2B,EAC3B,+BAA+B,EAC/B,6BAA6B,GAC9B,MAAM,sCAAsC,CAAC;AAG9C;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CACxC,SAAiB,EACjB,KAAgC;IAEhC,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC;IAEnC,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;QACpD,MAAM,IAAI,0BAA0B,CAClC,kBAAkB,SAAS,uCAAuC,CACnE,CAAC;IACJ,CAAC;IAED,IAAI,QAAQ,KAAK,6BAA6B,EAAE,CAAC;QAC/C,qBAAqB,CAAC,SAAS,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;QAEtD,OAAO,IAAI,2BAA2B,EAAE,CAAC;IAC3C,CAAC;IAED,IAAI,yBAAyB,CAAC,QAAQ,CAAC,KAAK,SAAS,EAAE,CAAC;QACtD,OAAO,IAAI,0BAA0B,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,CAAC;IACnE,CAAC;IAED,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,SAAS,sBAAsB,QAAQ,eAAe;QACtE,kEAAkE;QAClE,qBAAqB,6BAA6B,gBAAgB;QAClE,eAAe,CAClB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,qBAAqB,CAC5B,SAAiB,EACjB,UAAiC;IAEjC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,0BAA0B,CAClC,kBAAkB,SAAS,qCAAqC;YAC9D,iEAAiE;YACjE,GAAG,6BAA6B,SAAS,CAC5C,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAEtD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,0BAA0B,CAClC,oCAAoC,SAAS,yBAAyB;YACpE,gCAAgC,CACnC,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAC1B,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,+BAA+B,CAAC,QAAQ,CAAC,KAAc,CAAC,CACrE,CAAC;IAEF,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,yBAAyB,CACjC,oCAAoC,SAAS,SAAS;YACpD,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,2CAA2C;YAC/D,GAAG,+BAA+B,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CACtD,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,SAAS,CAAC,GAAW;IAC5B,OAAO,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AACrD,CAAC"}

package/dist/service/stepfunctions/task/sim-states-task-target.d.ts

@@ -0,0 +1,37 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+/**
+ * The function one `Task` state invocation names, and what it sends.
+ */
+export interface SimStatesTaskCall {
+    readonly functionNameOrArn: string;
+    readonly payload: JSONValue;
+}
+/**
+ * What a `Task` state's `Resource` named.
+ *
+ * The two forms a `Task` state invokes a function through differ in three
+ * places, and this is each of them: which function the state is talking to,
+ * what the state gets back, and what a handler raising is called. Everything
+ * between those, from assuming the execution role to running the handler, is
+ * the same for both.
+ */
+export declare abstract class SimStatesTaskTarget {
+    /**
+     * The function to invoke and the payload to send it, read from what the
+     * state's data-flow fields produced.
+     */
+    abstract call(payload: JSONValue, stateName: string): SimStatesTaskCall;
+    /**
+     * The result the state produces from what the handler answered.
+     */
+    abstract answer(result: JSONValue, executedVersion: string): JSONValue;
+    /**
+     * What a handler raising fails the task with.
+     *
+     * The Amazon States Language error name is read here rather than where the
+     * failure is recorded, because the two forms report a handler error
+     * differently and `Retry` and `Catch` match on exactly that name.
+     */
+    abstract handlerFailure(error: unknown, stateName: string): Error;
+}
+//# sourceMappingURL=sim-states-task-target.d.ts.map

package/dist/service/stepfunctions/task/sim-states-task-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-task-target.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/task/sim-states-task-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,8BAAsB,mBAAmB;IACvC;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,iBAAiB,CAAC;IAExE;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAEvE;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC;CACnE"}

package/dist/service/stepfunctions/task/sim-states-task-target.js

@@ -0,0 +1,12 @@
+/**
+ * What a `Task` state's `Resource` named.
+ *
+ * The two forms a `Task` state invokes a function through differ in three
+ * places, and this is each of them: which function the state is talking to,
+ * what the state gets back, and what a handler raising is called. Everything
+ * between those, from assuming the execution role to running the handler, is
+ * the same for both.
+ */
+export class SimStatesTaskTarget {
+}
+//# sourceMappingURL=sim-states-task-target.js.map

package/dist/service/stepfunctions/task/sim-states-task-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-task-target.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/task/sim-states-task-target.ts"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,MAAM,OAAgB,mBAAmB;CAoBxC"}

package/dist/service/stepfunctions/wait/sim-states-wait-due.d.ts

@@ -0,0 +1,11 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesWaitState } from "../definition/sim-states-state.js";
+/**
+ * The instant a `Wait` state waits for.
+ *
+ * The two literal fields are known from the definition. The two path fields
+ * are read out of the state's effective input, and a path holding the wrong
+ * kind of value fails the execution the way real Step Functions does.
+ */
+export declare function simStatesWaitDue(state: SimStatesWaitState, input: JSONValue, now: Date): Date;
+//# sourceMappingURL=sim-states-wait-due.d.ts.map

package/dist/service/stepfunctions/wait/sim-states-wait-due.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-wait-due.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/wait/sim-states-wait-due.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAIlE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAS5E;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,kBAAkB,EACzB,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,IAAI,GACR,IAAI,CA4BN"}

package/dist/service/stepfunctions/wait/sim-states-wait-due.js

@@ -0,0 +1,67 @@
+import { selectSimStatesPath } from "../data/sim-states-path-segment.js";
+import { parseSimStatesReferencePath } from "../data/sim-states-reference-path.js";
+import { readSimStatesTimestamp } from "../data/sim-states-timestamp.js";
+import { SimStatesRuntimeFailure } from "../error/sim-step-functions.error.js";
+import { simStatesMaximumWaitSeconds, simStatesWaitFields, } from "./sim-states-wait-fields.js";
+const millisecondsInASecond = 1000;
+/**
+ * The instant a `Wait` state waits for.
+ *
+ * The two literal fields are known from the definition. The two path fields
+ * are read out of the state's effective input, and a path holding the wrong
+ * kind of value fails the execution the way real Step Functions does.
+ */
+export function simStatesWaitDue(state, input, now) {
+    if (state.Seconds !== undefined) {
+        return afterSeconds(now, state.Seconds, "Seconds");
+    }
+    if (state.Timestamp !== undefined) {
+        return atTimestamp(state.Timestamp, "Timestamp");
+    }
+    if (state.SecondsPath !== undefined) {
+        return afterSeconds(now, valueAt(state.SecondsPath, input), `SecondsPath ${state.SecondsPath}`);
+    }
+    if (state.TimestampPath !== undefined) {
+        return atTimestamp(valueAt(state.TimestampPath, input), `TimestampPath ${state.TimestampPath}`);
+    }
+    throw new SimStatesRuntimeFailure(`A Wait state carries none of ${simStatesWaitFields.join(", ")}, so ` +
+        "nothing says how long it waits.");
+}
+/**
+ * The instant a number of seconds from now.
+ */
+function afterSeconds(now, seconds, source) {
+    if (!isAWaitInSeconds(seconds)) {
+        throw new SimStatesRuntimeFailure(`A Wait state reads ${source}, which holds ${JSON.stringify(seconds)} ` +
+            "rather than a whole number of seconds between 0 and " +
+            `${String(simStatesMaximumWaitSeconds)}.`);
+    }
+    return new Date(now.getTime() + seconds * millisecondsInASecond);
+}
+/**
+ * Whether a value is a length of time a `Wait` state can wait for.
+ */
+function isAWaitInSeconds(seconds) {
+    return (typeof seconds === "number" &&
+        Number.isSafeInteger(seconds) &&
+        seconds >= 0 &&
+        seconds <= simStatesMaximumWaitSeconds);
+}
+/**
+ * The instant a timestamp names.
+ */
+function atTimestamp(timestamp, source) {
+    const milliseconds = readSimStatesTimestamp(timestamp);
+    if (milliseconds === undefined) {
+        throw new SimStatesRuntimeFailure(`A Wait state reads ${source}, which holds ` +
+            `${JSON.stringify(timestamp)} rather than an RFC3339 instant.`);
+    }
+    return new Date(milliseconds);
+}
+/**
+ * What one of the two paths selects in the state's input.
+ */
+function valueAt(path, input) {
+    return selectSimStatesPath(input, parseSimStatesReferencePath(path));
+}
+//# sourceMappingURL=sim-states-wait-due.js.map

package/dist/service/stepfunctions/wait/sim-states-wait-due.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-wait-due.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/wait/sim-states-wait-due.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,GACpB,MAAM,6BAA6B,CAAC;AAErC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAyB,EACzB,KAAgB,EAChB,GAAS;IAET,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,YAAY,CAAC,GAAG,EAAE,KAAK,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACrD,CAAC;IAED,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;QAClC,OAAO,WAAW,CAAC,KAAK,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IACnD,CAAC;IAED,IAAI,KAAK,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;QACpC,OAAO,YAAY,CACjB,GAAG,EACH,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,EACjC,eAAe,KAAK,CAAC,WAAW,EAAE,CACnC,CAAC;IACJ,CAAC;IAED,IAAI,KAAK,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;QACtC,OAAO,WAAW,CAChB,OAAO,CAAC,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,EACnC,iBAAiB,KAAK,CAAC,aAAa,EAAE,CACvC,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,uBAAuB,CAC/B,gCAAgC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO;QACnE,iCAAiC,CACpC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CACnB,GAAS,EACT,OAA8B,EAC9B,MAAc;IAEd,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,uBAAuB,CAC/B,sBAAsB,MAAM,iBAAiB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG;YACrE,sDAAsD;YACtD,GAAG,MAAM,CAAC,2BAA2B,CAAC,GAAG,CAC5C,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,OAAO,GAAG,qBAAqB,CAAC,CAAC;AACnE,CAAC;AAED;;GAEG;AACH,SAAS,gBAAgB,CAAC,OAA8B;IACtD,OAAO,CACL,OAAO,OAAO,KAAK,QAAQ;QAC3B,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC;QAC7B,OAAO,IAAI,CAAC;QACZ,OAAO,IAAI,2BAA2B,CACvC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAAC,SAAgC,EAAE,MAAc;IACnE,MAAM,YAAY,GAAG,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAEvD,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;QAC/B,MAAM,IAAI,uBAAuB,CAC/B,sBAAsB,MAAM,gBAAgB;YAC1C,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,kCAAkC,CACjE,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,SAAS,OAAO,CAAC,IAAY,EAAE,KAAgB;IAC7C,OAAO,mBAAmB,CAAC,KAAK,EAAE,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC;AACvE,CAAC"}

package/dist/service/stepfunctions/wait/sim-states-wait-fields.d.ts

@@ -0,0 +1,18 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+/**
+ * The four ways a `Wait` state says how long to wait.
+ */
+/**
+ * The longest wait Step Functions takes, which is a little over three years.
+ */
+export declare const simStatesMaximumWaitSeconds = 99999999;
+export declare const simStatesWaitFields: readonly ["Seconds", "SecondsPath", "Timestamp", "TimestampPath"];
+/**
+ * Check what a `Wait` state waits for.
+ *
+ * A `Wait` state carries exactly one of the four fields. Real Step Functions
+ * refuses a definition carrying none or more than one when the state machine
+ * is created, and so does this.
+ */
+export declare function checkSimStatesWaitFields(stateName: string, state: Record<string, JSONValue>): void;
+//# sourceMappingURL=sim-states-wait-fields.d.ts.map

package/dist/service/stepfunctions/wait/sim-states-wait-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-wait-fields.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/wait/sim-states-wait-fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAKlE;;GAEG;AACH;;GAEG;AACH,eAAO,MAAM,2BAA2B,WAAa,CAAC;AAEtD,eAAO,MAAM,mBAAmB,YAC9B,SAAS,EACT,aAAa,EACb,WAAW,EACX,eAAe,CACP,CAAC;AAEX;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAC/B,IAAI,CAuBN"}

package/dist/service/stepfunctions/wait/sim-states-wait-fields.js

@@ -0,0 +1,85 @@
+import { parseSimStatesReferencePath } from "../data/sim-states-reference-path.js";
+import { readSimStatesTimestamp } from "../data/sim-states-timestamp.js";
+import { SimStatesInvalidDefinition } from "../error/sim-step-functions.error.js";
+/**
+ * The four ways a `Wait` state says how long to wait.
+ */
+/**
+ * The longest wait Step Functions takes, which is a little over three years.
+ */
+export const simStatesMaximumWaitSeconds = 99_999_999;
+export const simStatesWaitFields = [
+    "Seconds",
+    "SecondsPath",
+    "Timestamp",
+    "TimestampPath",
+];
+/**
+ * Check what a `Wait` state waits for.
+ *
+ * A `Wait` state carries exactly one of the four fields. Real Step Functions
+ * refuses a definition carrying none or more than one when the state machine
+ * is created, and so does this.
+ */
+export function checkSimStatesWaitFields(stateName, state) {
+    const present = simStatesWaitFields.filter((field) => Object.hasOwn(state, field));
+    const [field] = present;
+    if (field === undefined) {
+        throw new SimStatesInvalidDefinition(`The Wait state ${stateName} carries none of ` +
+            `${simStatesWaitFields.join(", ")}. A Wait state carries exactly one.`);
+    }
+    if (present.length > 1) {
+        throw new SimStatesInvalidDefinition(`The Wait state ${stateName} carries ${present.join(", ")}. A Wait ` +
+            "state carries exactly one of them.");
+    }
+    // The field was found among this state's own keys.
+    // oxlint-disable-next-line security/detect-object-injection
+    checkField(stateName, field, state[field]);
+}
+/**
+ * Check the one field the state carries.
+ *
+ * The two paths are checked as far as their syntax here. What they select is
+ * only known once the state runs.
+ */
+function checkField(stateName, field, written) {
+    if (field === "Seconds") {
+        checkSeconds(stateName, written);
+        return;
+    }
+    if (field === "Timestamp") {
+        checkTimestamp(stateName, written);
+        return;
+    }
+    if (typeof written !== "string") {
+        throw new SimStatesInvalidDefinition(`The Wait state ${stateName} has a ${field} that is not a Reference ` +
+            "Path.");
+    }
+    parseSimStatesReferencePath(written);
+}
+/**
+ * `Seconds` is a whole number of seconds within the range a wait takes.
+ */
+function checkSeconds(stateName, written) {
+    if (typeof written !== "number" || !Number.isSafeInteger(written)) {
+        throw new SimStatesInvalidDefinition(`The Wait state ${stateName} has a Seconds that is not a whole number.`);
+    }
+    if (written < 0) {
+        throw new SimStatesInvalidDefinition(`The Wait state ${stateName} waits for ${String(written)} seconds. A ` +
+            "wait does not run backwards.");
+    }
+    if (written > simStatesMaximumWaitSeconds) {
+        throw new SimStatesInvalidDefinition(`The Wait state ${stateName} waits for ${String(written)} seconds. ` +
+            `Step Functions waits ${String(simStatesMaximumWaitSeconds)} at most.`);
+    }
+}
+/**
+ * `Timestamp` is an instant, written the way Amazon States Language writes one.
+ */
+function checkTimestamp(stateName, written) {
+    if (readSimStatesTimestamp(written) === undefined) {
+        throw new SimStatesInvalidDefinition(`The Wait state ${stateName} has a Timestamp that is not an RFC3339 ` +
+            "instant, such as 2026-07-26T09:00:00Z.");
+    }
+}
+//# sourceMappingURL=sim-states-wait-fields.js.map

package/dist/service/stepfunctions/wait/sim-states-wait-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-wait-fields.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/wait/sim-states-wait-fields.ts"],"names":[],"mappings":"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"}

package/dist/util/process/sim-process-environment.d.ts

@@ -37,6 +37,15 @@ declare class SimProcessEnvironment {
      * The host process environment, ignoring any run in progress.
      */
     hostVariables(): NodeJS.ProcessEnv;
+    /**
+     * The host process environment in the shape a run's variables are held in.
+     *
+     * A run's store holds string values only, which is what process.env holds
+     * once Node.js has read it. The declared type allows undefined, so the
+     * names holding one are dropped rather than carried into a run as the
+     * string "undefined".
+     */
+    definedHostVariables(): Record<string, string>;
     /**
      * Redefine process.env as an accessor backed by the run store.
      *

package/dist/util/process/sim-process-environment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sim-process-environment.d.ts","sourceRoot":"","sources":["../../../src/util/process/sim-process-environment.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,cAAM,qBAAqB;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmD;IAC3E,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,SAAS,CAAS;IAE1B;;OAEG;IACG,GAAG,CAAC,CAAC,EACT,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACpB,OAAO,CAAC,CAAC,CAAC,CAGZ;IAED;;OAEG;IACH,aAAa,IAAI,MAAM,CAAC,UAAU,CAEjC;IAED;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,OAAO;IAkBf;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,gBAAgB;CAmBzB;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,uBAA8B,CAAC"}
+{"version":3,"file":"sim-process-environment.d.ts","sourceRoot":"","sources":["../../../src/util/process/sim-process-environment.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,cAAM,qBAAqB;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmD;IAC3E,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,SAAS,CAAS;IAE1B;;OAEG;IACG,GAAG,CAAC,CAAC,EACT,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACpB,OAAO,CAAC,CAAC,CAAC,CAGZ;IAED;;OAEG;IACH,aAAa,IAAI,MAAM,CAAC,UAAU,CAEjC;IAED;;;;;;;OAOG;IACH,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAU7C;IAED;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,OAAO;IAkBf;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,gBAAgB;CAmBzB;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,uBAA8B,CAAC"}

package/dist/util/process/sim-process-environment.js

@@ -43,6 +43,23 @@ class SimProcessEnvironment {
     hostVariables() {
         return this.hostEnvironment;
     }
+    /**
+     * The host process environment in the shape a run's variables are held in.
+     *
+     * A run's store holds string values only, which is what process.env holds
+     * once Node.js has read it. The declared type allows undefined, so the
+     * names holding one are dropped rather than carried into a run as the
+     * string "undefined".
+     */
+    definedHostVariables() {
+        const defined = [];
+        for (const [name, value] of Object.entries(this.hostEnvironment)) {
+            if (value !== undefined) {
+                defined.push([name, value]);
+            }
+        }
+        return Object.fromEntries(defined);
+    }
     /**
      * Redefine process.env as an accessor backed by the run store.
      *