@kensio/yulin 0.34.2 → 0.36.0

package/dist/service/lambda/function/environment/sim-lambda-environment-conflicts.js

@@ -0,0 +1,84 @@
+import { simLambdaProcessEnvironment } from "./sim-lambda-process-environment.js";
+const moveTheReadAdvice = "A read of process.env at module scope happens when the module is " +
+    "imported, before any invocation, so it sees the host value instead. " +
+    "Move the read inside the handler function.";
+/**
+ * Warns about declared environment variables whose value a handler module
+ * might not actually see.
+ *
+ * A sim Lambda function backed by a real in-process handler only gets its own
+ * process.env while the handler runs, so a variable read at module scope is
+ * read too early (see SimLambdaProcessEnv). That only changes what the code
+ * sees when the value read at module scope differs from the declared one, so
+ * these are the two conditions worth reporting: the host process sets the
+ * same name with a different value, or another simulated function declares
+ * the same name with a different value.
+ *
+ * Staying quiet when the values agree matters as much as warning when they do
+ * not. Test suites commonly export the same variables they configure their
+ * functions with, and in that case a module-scope read gets the right value
+ * anyway and there is nothing to report.
+ */
+export class SimLambdaEnvironmentConflicts {
+    /**
+     * Variable names already reported, so repeated function creation does not
+     * repeat the same warning.
+     */
+    warned = new Set();
+    /**
+     * Check a new function's environment against the host process and against
+     * the functions that already exist.
+     */
+    check(environment, existingEnvironments) {
+        for (const [name, value] of environment.declaredVariables) {
+            this.checkHostProcess(environment, name, value);
+            this.checkOtherFunctions(environment, name, value, existingEnvironments);
+        }
+    }
+    /**
+     * Warn when the host process sets the same name with a different value.
+     */
+    checkHostProcess(environment, name, value) {
+        // Read-only lookup of a name the function itself declared.
+        // eslint-disable-next-line security/detect-object-injection
+        const hostValue = simLambdaProcessEnvironment.hostVariables()[name];
+        if (hostValue === undefined || hostValue === value) {
+            return;
+        }
+        this.warn(`host:${name}`, `Sim Lambda function "${environment.functionName}" declares ` +
+            `environment variable ${name}, which the host process also sets ` +
+            `with a different value. ${moveTheReadAdvice}`);
+    }
+    /**
+     * Warn when another simulated function declares the same name with a
+     * different value.
+     */
+    checkOtherFunctions(environment, name, value, existingEnvironments) {
+        for (const existing of existingEnvironments) {
+            const existingValue = existing.declaredVariables.get(name);
+            if (existingValue === undefined || existingValue === value) {
+                continue;
+            }
+            this.warn(`function:${name}`, `Sim Lambda functions "${existing.functionName}" and ` +
+                `"${environment.functionName}" declare different values for ` +
+                `environment variable ${name}. ${moveTheReadAdvice}`);
+            return;
+        }
+    }
+    /**
+     * Report a conflict once per variable name.
+     *
+     * Warnings go to the console because that is where a test runner surfaces
+     * them next to the failing expectation they explain; the simulator has no
+     * logger of its own to route them through.
+     */
+    warn(key, message) {
+        if (this.warned.has(key)) {
+            return;
+        }
+        this.warned.add(key);
+        // eslint-disable-next-line no-console
+        console.warn(message);
+    }
+}
+//# sourceMappingURL=sim-lambda-environment-conflicts.js.map

package/dist/service/lambda/function/environment/sim-lambda-environment-conflicts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-environment-conflicts.js","sourceRoot":"","sources":["../../../../../src/service/lambda/function/environment/sim-lambda-environment-conflicts.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAElF,MAAM,iBAAiB,GACrB,mEAAmE;IACnE,sEAAsE;IACtE,4CAA4C,CAAC;AAE/C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,6BAA6B;IACxC;;;OAGG;IACc,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;IAE5C;;;OAGG;IACH,KAAK,CACH,WAAiC,EACjC,oBAAoD;QAEpD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,WAAW,CAAC,iBAAiB,EAAE,CAAC;YAC1D,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YAChD,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,oBAAoB,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC;IAED;;OAEG;IACK,gBAAgB,CACtB,WAAiC,EACjC,IAAY,EACZ,KAAa;QAEb,2DAA2D;QAC3D,4DAA4D;QAC5D,MAAM,SAAS,GAAG,2BAA2B,CAAC,aAAa,EAAE,CAAC,IAAI,CAAC,CAAC;QACpE,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;YACnD,OAAO;QACT,CAAC;QAED,IAAI,CAAC,IAAI,CACP,QAAQ,IAAI,EAAE,EACd,wBAAwB,WAAW,CAAC,YAAY,aAAa;YAC3D,wBAAwB,IAAI,qCAAqC;YACjE,2BAA2B,iBAAiB,EAAE,CACjD,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,mBAAmB,CACzB,WAAiC,EACjC,IAAY,EACZ,KAAa,EACb,oBAAoD;QAEpD,KAAK,MAAM,QAAQ,IAAI,oBAAoB,EAAE,CAAC;YAC5C,MAAM,aAAa,GAAG,QAAQ,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC3D,IAAI,aAAa,KAAK,SAAS,IAAI,aAAa,KAAK,KAAK,EAAE,CAAC;gBAC3D,SAAS;YACX,CAAC;YAED,IAAI,CAAC,IAAI,CACP,YAAY,IAAI,EAAE,EAClB,yBAAyB,QAAQ,CAAC,YAAY,QAAQ;gBACpD,IAAI,WAAW,CAAC,YAAY,iCAAiC;gBAC7D,wBAAwB,IAAI,KAAK,iBAAiB,EAAE,CACvD,CAAC;YACF,OAAO;QACT,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,IAAI,CAAC,GAAW,EAAE,OAAe;QACvC,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACrB,sCAAsC;QACtC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACxB,CAAC;CACF"}

package/dist/service/lambda/function/environment/sim-lambda-environment.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The function details the AWS-provided runtime environment variables are
+ * built from.
+ */
+export interface SimLambdaEnvironmentDetails {
+    readonly functionName: string;
+    readonly regionName: string;
+    readonly memorySizeMb: number;
+}
+interface SimLambdaEnvironmentProperties extends SimLambdaEnvironmentDetails {
+    readonly declaredVariables?: ReadonlyMap<string, string> | undefined;
+}
+/**
+ * The environment a sim Lambda function runs with.
+ *
+ * Combines the AWS-provided runtime variables with the variables declared for
+ * the function through Environment.Variables. Declared variables cannot
+ * shadow the runtime ones: real Lambda rejects the reserved names at
+ * CreateFunction, so the two sets never collide by the time they get here.
+ */
+export declare class SimLambdaEnvironment {
+    #private;
+    private readonly details;
+    private readonly declared;
+    constructor(properties: SimLambdaEnvironmentProperties);
+    /**
+     * Whether any variables were declared for this function.
+     *
+     * A function with no declared variables needs no environment of its own, so
+     * callers can leave the host process environment alone entirely.
+     */
+    get hasDeclaredVariables(): boolean;
+    /**
+     * The variables declared for this function, without the AWS-provided ones.
+     */
+    get declaredVariables(): ReadonlyMap<string, string>;
+    /**
+     * The name of the function this environment belongs to.
+     */
+    get functionName(): string;
+    /**
+     * The declared variables as AWS reports them in function configuration.
+     *
+     * Real Lambda leaves Environment off the configuration entirely for a
+     * function that declares none.
+     */
+    configuration(): {
+        Variables: Record<string, string>;
+    } | undefined;
+    /**
+     * Run function code with this environment applied to process.env.
+     *
+     * A function that declares nothing is left reading the host process
+     * environment, exactly as before: there is nothing of its own to give it,
+     * so there is no reason to touch process.env at all. Zip code running in a
+     * vm context takes its variables from the sandbox instead, and is
+     * unaffected either way.
+     */
+    runWith<T>(run: () => Promise<T>): Promise<T>;
+    /**
+     * The complete process.env-shaped variables the function code sees.
+     */
+    variables(): Record<string, string>;
+    /**
+     * The AWS-like standard runtime environment variables.
+     */
+    private runtimeVariables;
+}
+export {};
+//# sourceMappingURL=sim-lambda-environment.d.ts.map

package/dist/service/lambda/function/environment/sim-lambda-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-environment.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/function/environment/sim-lambda-environment.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,UAAU,8BAA+B,SAAQ,2BAA2B;IAC1E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;CACtE;AAED;;;;;;;GAOG;AACH,qBAAa,oBAAoB;;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IACtD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IAYvD,YAAY,UAAU,EAAE,8BAA8B,EAIrD;IAED;;;;;OAKG;IACH,IAAI,oBAAoB,IAAI,OAAO,CAElC;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAEnD;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;;;OAKG;IACH,aAAa,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,GAAG,SAAS,CAMjE;IAED;;;;;;;;OAQG;IACG,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAMlD;IAED;;OAEG;IACH,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMlC;IAED;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAazB"}

package/dist/service/lambda/function/environment/sim-lambda-environment.js

@@ -0,0 +1,102 @@
+import { simLambdaProcessEnvironment } from "./sim-lambda-process-environment.js";
+/**
+ * The environment a sim Lambda function runs with.
+ *
+ * Combines the AWS-provided runtime variables with the variables declared for
+ * the function through Environment.Variables. Declared variables cannot
+ * shadow the runtime ones: real Lambda rejects the reserved names at
+ * CreateFunction, so the two sets never collide by the time they get here.
+ */
+export class SimLambdaEnvironment {
+    details;
+    declared;
+    /**
+     * The merged variables, built once and then reused.
+     *
+     * Reusing one object gives the warm execution environment semantics of real
+     * Lambda: a write to process.env inside a handler is still visible to the
+     * next invocation of the same function, and is discarded when the function
+     * goes away.
+     */
+    #variables;
+    constructor(properties) {
+        const { declaredVariables, ...details } = properties;
+        this.details = details;
+        this.declared = declaredVariables ?? new Map();
+    }
+    /**
+     * Whether any variables were declared for this function.
+     *
+     * A function with no declared variables needs no environment of its own, so
+     * callers can leave the host process environment alone entirely.
+     */
+    get hasDeclaredVariables() {
+        return this.declared.size > 0;
+    }
+    /**
+     * The variables declared for this function, without the AWS-provided ones.
+     */
+    get declaredVariables() {
+        return this.declared;
+    }
+    /**
+     * The name of the function this environment belongs to.
+     */
+    get functionName() {
+        return this.details.functionName;
+    }
+    /**
+     * The declared variables as AWS reports them in function configuration.
+     *
+     * Real Lambda leaves Environment off the configuration entirely for a
+     * function that declares none.
+     */
+    configuration() {
+        if (!this.hasDeclaredVariables) {
+            return undefined;
+        }
+        return { Variables: Object.fromEntries(this.declared) };
+    }
+    /**
+     * Run function code with this environment applied to process.env.
+     *
+     * A function that declares nothing is left reading the host process
+     * environment, exactly as before: there is nothing of its own to give it,
+     * so there is no reason to touch process.env at all. Zip code running in a
+     * vm context takes its variables from the sandbox instead, and is
+     * unaffected either way.
+     */
+    async runWith(run) {
+        if (!this.hasDeclaredVariables) {
+            return await run();
+        }
+        return await simLambdaProcessEnvironment.run(this.variables(), run);
+    }
+    /**
+     * The complete process.env-shaped variables the function code sees.
+     */
+    variables() {
+        this.#variables ??= {
+            ...this.runtimeVariables(),
+            ...Object.fromEntries(this.declared),
+        };
+        return this.#variables;
+    }
+    /**
+     * The AWS-like standard runtime environment variables.
+     */
+    runtimeVariables() {
+        const { functionName, regionName, memorySizeMb } = this.details;
+        // Built from entries rather than an object literal because AWS
+        // environment variable names are not code identifier names, and the
+        // project's naming rules treat object literal keys as if they were.
+        return Object.fromEntries([
+            ["AWS_REGION", regionName],
+            ["AWS_DEFAULT_REGION", regionName],
+            ["AWS_LAMBDA_FUNCTION_NAME", functionName],
+            ["AWS_LAMBDA_FUNCTION_MEMORY_SIZE", String(memorySizeMb)],
+            ["AWS_LAMBDA_FUNCTION_VERSION", "$LATEST"],
+        ]);
+    }
+}
+//# sourceMappingURL=sim-lambda-environment.js.map

package/dist/service/lambda/function/environment/sim-lambda-environment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-environment.js","sourceRoot":"","sources":["../../../../../src/service/lambda/function/environment/sim-lambda-environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAgBlF;;;;;;;GAOG;AACH,MAAM,OAAO,oBAAoB;IACd,OAAO,CAA8B;IACrC,QAAQ,CAA8B;IAEvD;;;;;;;OAOG;IACH,UAAU,CAAqC;IAE/C,YAAY,UAA0C;QACpD,MAAM,EAAE,iBAAiB,EAAE,GAAG,OAAO,EAAE,GAAG,UAAU,CAAC;QACrD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,iBAAiB,IAAI,IAAI,GAAG,EAAE,CAAC;IACjD,CAAC;IAED;;;;;OAKG;IACH,IAAI,oBAAoB;QACtB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,aAAa;QACX,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC/B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC1D,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO,CAAI,GAAqB;QACpC,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC/B,OAAO,MAAM,GAAG,EAAE,CAAC;QACrB,CAAC;QAED,OAAO,MAAM,2BAA2B,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,GAAG,CAAC,CAAC;IACtE,CAAC;IAED;;OAEG;IACH,SAAS;QACP,IAAI,CAAC,UAAU,KAAK;YAClB,GAAG,IAAI,CAAC,gBAAgB,EAAE;YAC1B,GAAG,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC;SACrC,CAAC;QACF,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAChE,+DAA+D;QAC/D,oEAAoE;QACpE,oEAAoE;QACpE,OAAO,MAAM,CAAC,WAAW,CAAC;YACxB,CAAC,YAAY,EAAE,UAAU,CAAC;YAC1B,CAAC,oBAAoB,EAAE,UAAU,CAAC;YAClC,CAAC,0BAA0B,EAAE,YAAY,CAAC;YAC1C,CAAC,iCAAiC,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC;YACzD,CAAC,6BAA6B,EAAE,SAAS,CAAC;SAC3C,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/service/lambda/function/environment/sim-lambda-process-environment.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The process.env a sim Lambda handler function sees while it runs.
+ *
+ * A handler backed by a real in-process function is a closure over its own
+ * module scope, so unlike zip code running in a vm context it has no sandbox
+ * to give it an environment of its own: it reads the host process.env like
+ * any other code in the test run. Node.js asynchronous context tracking
+ * bridges that gap. The function's variables are held in an
+ * AsyncLocalStorage store for the duration of the invocation, and process.env
+ * resolves to that store while it is set.
+ *
+ * The store follows the invocation across await points, and concurrent
+ * invocations of different functions each see their own variables, which a
+ * swap-and-restore around the handler call could not manage.
+ *
+ * The one thing this cannot reach is a read that already happened. A handler
+ * module doing `const TABLE = process.env.TABLE_NAME` at module scope is
+ * evaluated when the test file imports it, long before any invocation, so it
+ * captures the host value. Reads inside the handler body see the function's
+ * own variables. See SimLambdaEnvironmentConflicts, which warns when that
+ * distinction actually changes what the code sees.
+ */
+declare class SimLambdaProcessEnvironment {
+    private readonly storage;
+    private hostEnvironment;
+    private installed;
+    /**
+     * Run an invocation with the given variables as its process.env.
+     */
+    run<T>(variables: Record<string, string>, run: () => Promise<T>): Promise<T>;
+    /**
+     * The host process environment, ignoring any invocation in progress.
+     */
+    hostVariables(): NodeJS.ProcessEnv;
+    /**
+     * Redefine process.env as an accessor backed by the invocation store.
+     *
+     * process.env is a plain configurable data property on process, so it can
+     * be replaced with a getter. Outside a sim Lambda invocation the getter
+     * hands back the untouched host environment object, so the patch is inert:
+     * anything that reads, writes, or stubs process.env normally is unaffected.
+     *
+     * Installed once and never removed. Removing it would be unsafe while
+     * another invocation is in flight, and there is nothing to gain: an
+     * installed patch with no invocation running behaves exactly like no patch
+     * at all.
+     */
+    private install;
+    /**
+     * Apply an assignment to process.env as a whole.
+     *
+     * Inside an invocation this has to stay invocation-local, like a write to a
+     * single variable does, or function code could wipe out the host
+     * environment for the rest of the test run. The store's object identity is
+     * fixed for the run, so the assignment is copied into it rather than
+     * swapping the reference. Outside an invocation it replaces the host
+     * environment, as an assignment to process.env normally would.
+     */
+    private replaceVariables;
+}
+/**
+ * Shared because it patches a process global: one patch, one store.
+ */
+export declare const simLambdaProcessEnvironment: SimLambdaProcessEnvironment;
+export {};
+//# sourceMappingURL=sim-lambda-process-environment.d.ts.map

package/dist/service/lambda/function/environment/sim-lambda-process-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-process-environment.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/function/environment/sim-lambda-process-environment.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,cAAM,2BAA2B;IAC/B,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;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,OAAO;IAkBf;;;;;;;;;OASG;IACH,OAAO,CAAC,gBAAgB;CAiBzB;AAED;;GAEG;AACH,eAAO,MAAM,2BAA2B,6BAAoC,CAAC"}

package/dist/service/lambda/function/environment/sim-lambda-process-environment.js

@@ -0,0 +1,100 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * The process.env a sim Lambda handler function sees while it runs.
+ *
+ * A handler backed by a real in-process function is a closure over its own
+ * module scope, so unlike zip code running in a vm context it has no sandbox
+ * to give it an environment of its own: it reads the host process.env like
+ * any other code in the test run. Node.js asynchronous context tracking
+ * bridges that gap. The function's variables are held in an
+ * AsyncLocalStorage store for the duration of the invocation, and process.env
+ * resolves to that store while it is set.
+ *
+ * The store follows the invocation across await points, and concurrent
+ * invocations of different functions each see their own variables, which a
+ * swap-and-restore around the handler call could not manage.
+ *
+ * The one thing this cannot reach is a read that already happened. A handler
+ * module doing `const TABLE = process.env.TABLE_NAME` at module scope is
+ * evaluated when the test file imports it, long before any invocation, so it
+ * captures the host value. Reads inside the handler body see the function's
+ * own variables. See SimLambdaEnvironmentConflicts, which warns when that
+ * distinction actually changes what the code sees.
+ */
+class SimLambdaProcessEnvironment {
+    storage = new AsyncLocalStorage();
+    hostEnvironment = process.env;
+    installed = false;
+    /**
+     * Run an invocation with the given variables as its process.env.
+     */
+    async run(variables, run) {
+        this.install();
+        return await this.storage.run(variables, run);
+    }
+    /**
+     * The host process environment, ignoring any invocation in progress.
+     */
+    hostVariables() {
+        return this.hostEnvironment;
+    }
+    /**
+     * Redefine process.env as an accessor backed by the invocation store.
+     *
+     * process.env is a plain configurable data property on process, so it can
+     * be replaced with a getter. Outside a sim Lambda invocation the getter
+     * hands back the untouched host environment object, so the patch is inert:
+     * anything that reads, writes, or stubs process.env normally is unaffected.
+     *
+     * Installed once and never removed. Removing it would be unsafe while
+     * another invocation is in flight, and there is nothing to gain: an
+     * installed patch with no invocation running behaves exactly like no patch
+     * at all.
+     */
+    install() {
+        if (this.installed) {
+            return;
+        }
+        this.hostEnvironment = process.env;
+        Object.defineProperty(process, "env", {
+            configurable: true,
+            enumerable: true,
+            get: () => this.storage.getStore() ?? this.hostEnvironment,
+            set: (replacement) => {
+                this.replaceVariables(replacement);
+            },
+        });
+        this.installed = true;
+    }
+    /**
+     * Apply an assignment to process.env as a whole.
+     *
+     * Inside an invocation this has to stay invocation-local, like a write to a
+     * single variable does, or function code could wipe out the host
+     * environment for the rest of the test run. The store's object identity is
+     * fixed for the run, so the assignment is copied into it rather than
+     * swapping the reference. Outside an invocation it replaces the host
+     * environment, as an assignment to process.env normally would.
+     */
+    replaceVariables(replacement) {
+        const store = this.storage.getStore();
+        if (store === undefined) {
+            this.hostEnvironment = replacement;
+            return;
+        }
+        for (const name of Object.keys(store)) {
+            Reflect.deleteProperty(store, name);
+        }
+        for (const [name, value] of Object.entries(replacement)) {
+            if (value !== undefined) {
+                // eslint-disable-next-line security/detect-object-injection
+                store[name] = value;
+            }
+        }
+    }
+}
+/**
+ * Shared because it patches a process global: one patch, one store.
+ */
+export const simLambdaProcessEnvironment = new SimLambdaProcessEnvironment();
+//# sourceMappingURL=sim-lambda-process-environment.js.map

package/dist/service/lambda/function/environment/sim-lambda-process-environment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-process-environment.js","sourceRoot":"","sources":["../../../../../src/service/lambda/function/environment/sim-lambda-process-environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,2BAA2B;IACd,OAAO,GAAG,IAAI,iBAAiB,EAA0B,CAAC;IACnE,eAAe,GAAsB,OAAO,CAAC,GAAG,CAAC;IACjD,SAAS,GAAG,KAAK,CAAC;IAE1B;;OAEG;IACH,KAAK,CAAC,GAAG,CACP,SAAiC,EACjC,GAAqB;QAErB,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,aAAa;QACX,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;;;OAYG;IACK,OAAO;QACb,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC;QACnC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,KAAK,EAAE;YACpC,YAAY,EAAE,IAAI;YAClB,UAAU,EAAE,IAAI;YAChB,GAAG,EAAE,GAAsB,EAAE,CAC3B,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,eAAe;YACjD,GAAG,EAAE,CAAC,WAA8B,EAAQ,EAAE;gBAC5C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;YACrC,CAAC;SACF,CAAC,CAAC;QACH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACxB,CAAC;IAED;;;;;;;;;OASG;IACK,gBAAgB,CAAC,WAA8B;QACrD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;QACtC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;YACnC,OAAO;QACT,CAAC;QAED,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACtC,OAAO,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACtC,CAAC;QACD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;YACxD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,4DAA4D;gBAC5D,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;YACtB,CAAC;QACH,CAAC;IACH,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,2BAA2B,EAAE,CAAC"}

package/dist/service/lambda/function/invoke/sim-lambda-invoke-context-builder.d.ts

@@ -1,9 +1,16 @@
 import type { SimLambdaCallback, SimLambdaContext } from "../sim-lambda-handler.type.js";
+import { type SimClock } from "../../../../util/clock/sim-clock.js";
 interface SimLambdaInvokeContextBuilderProperties {
     readonly functionName: string;
     readonly invokedFunctionArn: string;
     readonly timeoutSeconds: number;
     readonly memorySizeMb: number;
+    /**
+     * Clock measuring how much of the invocation timeout is left. Reading the
+     * remaining time from the simulation's clock means a stopped clock leaves a
+     * handler with a constant budget, rather than one that drains in real time.
+     */
+    readonly clock?: SimClock | undefined;
 }
 /**
  * Builds the AWS-like invocation context passed to a sim Lambda handler.

package/dist/service/lambda/function/invoke/sim-lambda-invoke-context-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sim-lambda-invoke-context-builder.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/function/invoke/sim-lambda-invoke-context-builder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,+BAA+B,CAAC;AAEvC,UAAU,uCAAuC;IAC/C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;GAKG;AACH,qBAAa,6BAA6B;IAEtC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAD7B,YACmB,UAAU,EAAE,uCAAuC,EAClE;IAEJ;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,iBAAiB,GAAG,gBAAgB,CA2BnD;CACF"}
+{"version":3,"file":"sim-lambda-invoke-context-builder.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/function/invoke/sim-lambda-invoke-context-builder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,KAAK,QAAQ,EAEd,MAAM,qCAAqC,CAAC;AAE7C,UAAU,uCAAuC;IAC/C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CACvC;AAED;;;;;GAKG;AACH,qBAAa,6BAA6B;IAEtC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAD7B,YACmB,UAAU,EAAE,uCAAuC,EAClE;IAEJ;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,iBAAiB,GAAG,gBAAgB,CAmCnD;CACF"}

package/dist/service/lambda/function/invoke/sim-lambda-invoke-context-builder.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { SimRealClock, } from "../../../../util/clock/sim-clock.js";
 /**
  * Builds the AWS-like invocation context passed to a sim Lambda handler.
  *
@@ -14,8 +15,8 @@ export class SimLambdaInvokeContextBuilder {
      * Build the context for one invocation.
      */
     build(callback) {
-        const { functionName, invokedFunctionArn, timeoutSeconds, memorySizeMb } = this.properties;
-        const startedAtMs = Date.now();
+        const { functionName, invokedFunctionArn, timeoutSeconds, memorySizeMb, clock = new SimRealClock(), } = this.properties;
+        const startedAtMs = clock.now().getTime();
         const awsRequestId = randomUUID();
         return {
             callbackWaitsForEmptyEventLoop: true,
@@ -26,7 +27,7 @@ export class SimLambdaInvokeContextBuilder {
             awsRequestId,
             logGroupName: `/aws/lambda/${functionName}`,
             logStreamName: `[$LATEST]${awsRequestId}`,
-            getRemainingTimeInMillis: () => Math.max(0, timeoutSeconds * 1000 - (Date.now() - startedAtMs)),
+            getRemainingTimeInMillis: () => Math.max(0, timeoutSeconds * 1000 - (clock.now().getTime() - startedAtMs)),
             done: (error, result) => {
                 callback(error ?? null, result);
             },

package/dist/service/lambda/function/invoke/sim-lambda-invoke-context-builder.js.map

@@ -1 +1 @@
-{"version":3,"file":"sim-lambda-invoke-context-builder.js","sourceRoot":"","sources":["../../../../../src/service/lambda/function/invoke/sim-lambda-invoke-context-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAazC;;;;;GAKG;AACH,MAAM,OAAO,6BAA6B;IAErB,UAAU;IAD7B,YACmB,UAAmD;0BAAnD,UAAU;IAC1B,CAAC;IAEJ;;OAEG;IACH,KAAK,CAAC,QAA2B;QAC/B,MAAM,EAAE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,YAAY,EAAE,GACtE,IAAI,CAAC,UAAU,CAAC;QAClB,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC/B,MAAM,YAAY,GAAG,UAAU,EAAE,CAAC;QAElC,OAAO;YACL,8BAA8B,EAAE,IAAI;YACpC,YAAY;YACZ,eAAe,EAAE,SAAS;YAC1B,kBAAkB;YAClB,eAAe,EAAE,MAAM,CAAC,YAAY,CAAC;YACrC,YAAY;YACZ,YAAY,EAAE,eAAe,YAAY,EAAE;YAC3C,aAAa,EAAE,YAAY,YAAY,EAAE;YACzC,wBAAwB,EAAE,GAAW,EAAE,CACrC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,cAAc,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,WAAW,CAAC,CAAC;YACjE,IAAI,EAAE,CAAC,KAAa,EAAE,MAAgB,EAAQ,EAAE;gBAC9C,QAAQ,CAAC,KAAK,IAAI,IAAI,EAAE,MAAM,CAAC,CAAC;YAClC,CAAC;YACD,IAAI,EAAE,CAAC,KAAqB,EAAQ,EAAE;gBACpC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;YACD,OAAO,EAAE,CAAC,eAAwB,EAAQ,EAAE;gBAC1C,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;YAClC,CAAC;SACF,CAAC;IACJ,CAAC;CACF"}
+{"version":3,"file":"sim-lambda-invoke-context-builder.js","sourceRoot":"","sources":["../../../../../src/service/lambda/function/invoke/sim-lambda-invoke-context-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAKzC,OAAO,EAEL,YAAY,GACb,MAAM,qCAAqC,CAAC;AAe7C;;;;;GAKG;AACH,MAAM,OAAO,6BAA6B;IAErB,UAAU;IAD7B,YACmB,UAAmD;0BAAnD,UAAU;IAC1B,CAAC;IAEJ;;OAEG;IACH,KAAK,CAAC,QAA2B;QAC/B,MAAM,EACJ,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,KAAK,GAAG,IAAI,YAAY,EAAE,GAC3B,GAAG,IAAI,CAAC,UAAU,CAAC;QACpB,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC;QAC1C,MAAM,YAAY,GAAG,UAAU,EAAE,CAAC;QAElC,OAAO;YACL,8BAA8B,EAAE,IAAI;YACpC,YAAY;YACZ,eAAe,EAAE,SAAS;YAC1B,kBAAkB;YAClB,eAAe,EAAE,MAAM,CAAC,YAAY,CAAC;YACrC,YAAY;YACZ,YAAY,EAAE,eAAe,YAAY,EAAE;YAC3C,aAAa,EAAE,YAAY,YAAY,EAAE;YACzC,wBAAwB,EAAE,GAAW,EAAE,CACrC,IAAI,CAAC,GAAG,CACN,CAAC,EACD,cAAc,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,GAAG,WAAW,CAAC,CAC9D;YACH,IAAI,EAAE,CAAC,KAAa,EAAE,MAAgB,EAAQ,EAAE;gBAC9C,QAAQ,CAAC,KAAK,IAAI,IAAI,EAAE,MAAM,CAAC,CAAC;YAClC,CAAC;YACD,IAAI,EAAE,CAAC,KAAqB,EAAQ,EAAE;gBACpC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;YACD,OAAO,EAAE,CAAC,eAAwB,EAAQ,EAAE;gBAC1C,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;YAClC,CAAC;SACF,CAAC;IACJ,CAAC;CACF"}

package/dist/service/lambda/function/policy/sim-lambda-function-policy.d.ts

@@ -0,0 +1,47 @@
+import type { SimIamPolicyDocument } from "../../../iam/policy/sim-iam-policy.js";
+import type { SimLambdaPermission } from "./sim-lambda-permission.js";
+/**
+ * A simulated Lambda function's resource-based policy.
+ *
+ * This is the other half of Lambda authorization. An identity policy says what
+ * a principal may do; this says who may act on the function, which is the only
+ * way a principal in another Account can be allowed anything at all, since its
+ * own Account's policies are not evaluated here.
+ *
+ * Statements are keyed by their `StatementId`, because that is how
+ * `AddPermission` and `RemovePermission` address them.
+ */
+export declare class SimLambdaFunctionPolicy {
+    #private;
+    private readonly permissions;
+    /**
+     * The revision the policy is currently at, which changes with every grant
+     * and revocation.
+     */
+    get revisionId(): string;
+    /**
+     * Whether this function has no resource policy at all.
+     *
+     * Real Lambda has no empty policy: a function either has one or `GetPolicy`
+     * reports that it does not.
+     */
+    isEmpty(): boolean;
+    /**
+     * The permission a statement id names, if this policy has one.
+     */
+    get(statementId: string): SimLambdaPermission | undefined;
+    /**
+     * Grant a permission, refusing a statement id already in use.
+     */
+    add(permission: SimLambdaPermission): void;
+    /**
+     * Revoke a permission by its statement id, failing as AWS does when no
+     * statement has it.
+     */
+    remove(statementId: string): void;
+    /**
+     * The policy document, in the shape `GetPolicy` returns and IAM evaluates.
+     */
+    document(): SimIamPolicyDocument;
+}
+//# sourceMappingURL=sim-lambda-function-policy.d.ts.map

package/dist/service/lambda/function/policy/sim-lambda-function-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-function-policy.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/function/policy/sim-lambda-function-policy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAKlF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAOtE;;;;;;;;;;GAUG;AACH,qBAAa,uBAAuB;;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA0C;IAGtE;;;OAGG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;;;;OAKG;IACH,OAAO,IAAI,OAAO,CAEjB;IAED;;OAEG;IACH,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAExD;IAED;;OAEG;IACH,GAAG,CAAC,UAAU,EAAE,mBAAmB,GAAG,IAAI,CAWzC;IAED;;;OAGG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAQhC;IAED;;OAEG;IACH,QAAQ,IAAI,oBAAoB,CAS/B;CACF"}

package/dist/service/lambda/function/policy/sim-lambda-function-policy.js

@@ -0,0 +1,79 @@
+import { randomUUID } from "node:crypto";
+import { SimLambdaResourceConflictException, SimLambdaResourceNotFoundException, } from "../../error/sim-lambda.error.js";
+/**
+ * The name real Lambda gives a function's resource policy document.
+ */
+const policyId = "default";
+/**
+ * A simulated Lambda function's resource-based policy.
+ *
+ * This is the other half of Lambda authorization. An identity policy says what
+ * a principal may do; this says who may act on the function, which is the only
+ * way a principal in another Account can be allowed anything at all, since its
+ * own Account's policies are not evaluated here.
+ *
+ * Statements are keyed by their `StatementId`, because that is how
+ * `AddPermission` and `RemovePermission` address them.
+ */
+export class SimLambdaFunctionPolicy {
+    permissions = new Map();
+    #revisionId = randomUUID();
+    /**
+     * The revision the policy is currently at, which changes with every grant
+     * and revocation.
+     */
+    get revisionId() {
+        return this.#revisionId;
+    }
+    /**
+     * Whether this function has no resource policy at all.
+     *
+     * Real Lambda has no empty policy: a function either has one or `GetPolicy`
+     * reports that it does not.
+     */
+    isEmpty() {
+        return this.permissions.size === 0;
+    }
+    /**
+     * The permission a statement id names, if this policy has one.
+     */
+    get(statementId) {
+        return this.permissions.get(statementId);
+    }
+    /**
+     * Grant a permission, refusing a statement id already in use.
+     */
+    add(permission) {
+        if (this.permissions.has(permission.statementId)) {
+            throw new SimLambdaResourceConflictException(`The statement id (${permission.statementId}) provided already ` +
+                `exists. Please provide a new statement id, or remove the ` +
+                `existing statement.`);
+        }
+        this.permissions.set(permission.statementId, permission);
+        this.#revisionId = randomUUID();
+    }
+    /**
+     * Revoke a permission by its statement id, failing as AWS does when no
+     * statement has it.
+     */
+    remove(statementId) {
+        if (!this.permissions.delete(statementId)) {
+            throw new SimLambdaResourceNotFoundException(`Statement ${statementId} is not found in resource policy.`);
+        }
+        this.#revisionId = randomUUID();
+    }
+    /**
+     * The policy document, in the shape `GetPolicy` returns and IAM evaluates.
+     */
+    document() {
+        return {
+            Version: "2012-10-17",
+            Id: policyId,
+            Statement: this.permissions
+                .values()
+                .map((permission) => permission.toStatement())
+                .toArray(),
+        };
+    }
+}
+//# sourceMappingURL=sim-lambda-function-policy.js.map

package/dist/service/lambda/function/policy/sim-lambda-function-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-function-policy.js","sourceRoot":"","sources":["../../../../../src/service/lambda/function/policy/sim-lambda-function-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,OAAO,EACL,kCAAkC,EAClC,kCAAkC,GACnC,MAAM,iCAAiC,CAAC;AAGzC;;GAEG;AACH,MAAM,QAAQ,GAAG,SAAS,CAAC;AAE3B;;;;;;;;;;GAUG;AACH,MAAM,OAAO,uBAAuB;IACjB,WAAW,GAAG,IAAI,GAAG,EAA+B,CAAC;IACtE,WAAW,GAAG,UAAU,EAAE,CAAC;IAE3B;;;OAGG;IACH,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACH,OAAO;QACL,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,WAAmB;QACrB,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,UAA+B;QACjC,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,kCAAkC,CAC1C,qBAAqB,UAAU,CAAC,WAAW,qBAAqB;gBAC9D,2DAA2D;gBAC3D,qBAAqB,CACxB,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;QACzD,IAAI,CAAC,WAAW,GAAG,UAAU,EAAE,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,WAAmB;QACxB,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;YAC1C,MAAM,IAAI,kCAAkC,CAC1C,aAAa,WAAW,mCAAmC,CAC5D,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,UAAU,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,OAAO,EAAE,YAAY;YACrB,EAAE,EAAE,QAAQ;YACZ,SAAS,EAAE,IAAI,CAAC,WAAW;iBACxB,MAAM,EAAE;iBACR,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;iBAC7C,OAAO,EAAE;SACb,CAAC;IACJ,CAAC;CACF"}