@kensio/yulin 1.21.20 → 1.21.22

package/dist/service/lambda/event-source/poll/sim-lambda-event-source-delivery.d.ts

@@ -1,6 +1,7 @@
 import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
 import type { SimSqsPollMessage } from "../../../sqs/poll/sim-sqs-poll-message.js";
-import type { SimLambdaEventSourceBatchOutcome, SimLambdaEventSourceBatchResponse } from "./sim-lambda-event-source-batch-response.js";
+import { SimLambdaEventSourceBatchOutcome, type SimLambdaEventSourceBatchResponse } from "./sim-lambda-event-source-batch-response.js";
+import type { SimLambdaFilterCriteria } from "../filter/sim-lambda-filter-criteria.js";
 /**
  * One record of an event source event.
  *
@@ -25,10 +26,16 @@ export interface SimLambdaEventSourceEvent {
  */
 export interface SimLambdaEventSourceEventBuilder {
     of(messages: readonly SimSqsPollMessage[]): SimLambdaEventSourceEvent;
+    /**
+     * What a mapping's filters read one message as, which is the source's own
+     * translation.
+     */
+    filterDocumentOf(message: SimSqsPollMessage): Record<string, unknown>;
 }
 interface SimLambdaEventSourceDeliveryProperties {
     readonly eventBuilder: SimLambdaEventSourceEventBuilder;
     readonly batchResponse: SimLambdaEventSourceBatchResponse;
+    readonly filterCriteria: SimLambdaFilterCriteria | undefined;
 }
 /**
  * Hands one batch to a function and reads what became of it.
@@ -43,10 +50,23 @@ interface SimLambdaEventSourceDeliveryProperties {
 export declare class SimLambdaEventSourceDelivery {
     private readonly eventBuilder;
     private readonly batchResponse;
+    private readonly filterCriteria;
     constructor(properties: SimLambdaEventSourceDeliveryProperties);
     /**
      * Deliver a batch, answering with what to delete and what to leave.
      */
     to(simFunction: SimLambdaFunction, messages: readonly SimSqsPollMessage[]): Promise<SimLambdaEventSourceBatchOutcome>;
+    /**
+     * One batch of matching messages, handed over and read back.
+     */
+    private invoked;
+    /**
+     * An outcome with the filtered-out messages counted as handled, which deletes
+     * them whatever the function said about the rest.
+     *
+     * A message the function never saw is in neither list the outcome carries,
+     * which is what picks it out of the batch that was read.
+     */
+    private alsoHandling;
 }
 export {};

package/dist/service/lambda/event-source/poll/sim-lambda-event-source-delivery.js

@@ -1,3 +1,5 @@
+import { SimLambdaEventSourceBatchOutcome, } from "./sim-lambda-event-source-batch-response.js";
+import { simLambdaFilteredDelivery } from "../filter/sim-lambda-filtered-delivery.js";
 /**
  * Hands one batch to a function and reads what became of it.
  *
@@ -11,22 +13,50 @@
 export class SimLambdaEventSourceDelivery {
     eventBuilder;
     batchResponse;
+    filterCriteria;
     constructor(properties) {
         this.eventBuilder = properties.eventBuilder;
         this.batchResponse = properties.batchResponse;
+        this.filterCriteria = properties.filterCriteria;
     }
     /**
      * Deliver a batch, answering with what to delete and what to leave.
      */
     async to(simFunction, messages) {
+        return await simLambdaFilteredDelivery({
+            criteria: this.filterCriteria,
+            records: messages,
+            documentOf: (message) => this.eventBuilder.filterDocumentOf(message),
+            // A message the filters excluded is deleted from the queue without the
+            // function seeing it, the way real Lambda deletes one.
+            handled: () => new SimLambdaEventSourceBatchOutcome(messages, []),
+            invoke: async (delivered) => this.alsoHandling(messages, await this.invoked(simFunction, delivered)),
+        });
+    }
+    /**
+     * One batch of matching messages, handed over and read back.
+     */
+    async invoked(simFunction, delivered) {
         try {
-            return this.batchResponse.handled(messages, await simFunction.invoke(this.eventBuilder.of(messages)));
+            return this.batchResponse.handled(delivered, await simFunction.invoke(this.eventBuilder.of(delivered)));
         }
         catch {
             // As on real Lambda, the handler error goes to the function's logs and
             // not to whoever sent the message. What the sender sees is the batch
             // coming back to the source.
-            return this.batchResponse.failed(messages);
+            return this.batchResponse.failed(delivered);
         }
     }
+    /**
+     * An outcome with the filtered-out messages counted as handled, which deletes
+     * them whatever the function said about the rest.
+     *
+     * A message the function never saw is in neither list the outcome carries,
+     * which is what picks it out of the batch that was read.
+     */
+    alsoHandling(messages, outcome) {
+        const seen = new Set([...outcome.handled, ...outcome.returned]);
+        const excluded = messages.filter((message) => !seen.has(message));
+        return new SimLambdaEventSourceBatchOutcome([...outcome.handled, ...excluded], outcome.returned);
+    }
 }

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-delivery.js

@@ -12,5 +12,6 @@ export function makeSimLambdaSqsDelivery(properties) {
     return new SimLambdaEventSourceDelivery({
         eventBuilder: new SimLambdaSqsEventBuilder(properties.eventSourceArn),
         batchResponse: new SimLambdaSqsBatchResponse(properties.mapping.reportsBatchItemFailures),
+        filterCriteria: properties.mapping.filterCriteria,
     });
 }

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-event.d.ts

@@ -50,6 +50,14 @@ export declare class SimLambdaSqsEventBuilder {
      * The event for a batch of messages.
      */
     of(messages: readonly SimSqsPollMessage[]): SimLambdaSqsEvent;
+    /**
+     * What a mapping's filters read one message as.
+     *
+     * Real Lambda filters an SQS message on its body alone, and reads the body as
+     * JSON where it holds JSON. Nothing else about the message is here, because a
+     * pattern naming anything else was refused when the mapping was created.
+     */
+    filterDocumentOf(message: SimSqsPollMessage): Record<string, unknown>;
     private record;
     private messageAttributes;
 }

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-event.js

@@ -1,3 +1,4 @@
+import { simLambdaFilterData } from "../filter/sim-lambda-filtered-records.js";
 /**
  * Builds the SQS event for one batch of polled messages.
  *
@@ -17,6 +18,16 @@ export class SimLambdaSqsEventBuilder {
     of(messages) {
         return { Records: messages.map((message) => this.record(message)) };
     }
+    /**
+     * What a mapping's filters read one message as.
+     *
+     * Real Lambda filters an SQS message on its body alone, and reads the body as
+     * JSON where it holds JSON. Nothing else about the message is here, because a
+     * pattern naming anything else was refused when the mapping was created.
+     */
+    filterDocumentOf(message) {
+        return { body: simLambdaFilterData(message.Body) };
+    }
     record(message) {
         return {
             messageId: message.MessageId,

package/dist/service/lambda/event-source/sim-lambda-event-source-mapping.d.ts

@@ -1,6 +1,7 @@
 import type { SimLambdaStreamDestinationConfiguration } from "./sim-lambda-stream-destination-config.js";
 import type { SimLambdaDestinationTargets } from "../destination/sim-lambda-destination-targets.js";
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimLambdaFilterCriteria, SimLambdaFilterCriteriaInput } from "./filter/sim-lambda-filter-criteria.js";
 import type { SimLambdaFunctionArn } from "../function/sim-lambda-function-configuration.js";
 import type { SimLambdaStreamRetryLimits, SimLambdaStreamRetryLimitsConfiguration } from "./sim-lambda-stream-retry-limits.js";
 import type { SimLambdaEventSourceStart, SimLambdaEventSourceStartingPosition } from "./sim-lambda-event-source-starting-position.js";
@@ -35,6 +36,7 @@ interface SimLambdaEventSourceMappingProperties {
     readonly streamRetryLimits?: SimLambdaStreamRetryLimits | undefined;
     readonly destinationConfig?: SimLambdaStreamDestinationConfiguration | undefined;
     readonly destinations?: SimLambdaDestinationTargets | undefined;
+    readonly filterCriteria?: SimLambdaFilterCriteria | undefined;
     readonly createdAt: Date;
 }
 /**
@@ -53,6 +55,7 @@ export interface SimLambdaEventSourceMappingConfiguration extends Partial<SimLam
     readonly StartingPositionTimestamp?: Date | undefined;
     readonly MaximumBatchingWindowInSeconds: number;
     readonly FunctionResponseTypes: readonly SimLambdaFunctionResponseType[];
+    readonly FilterCriteria?: SimLambdaFilterCriteriaInput | undefined;
     readonly State: SimLambdaEventSourceMappingState;
     readonly StateTransitionReason: string;
     readonly LastModified: Date;
@@ -89,6 +92,13 @@ export declare class SimLambdaEventSourceMapping {
      */
     readonly start: SimLambdaEventSourceStart | undefined;
     readonly functionResponseTypes: readonly SimLambdaFunctionResponseType[];
+    /**
+     * The filters a record has to match before it is delivered, if this mapping
+     * was created with any.
+     *
+     * A mapping with none delivers every record its source hands it.
+     */
+    readonly filterCriteria: SimLambdaFilterCriteria | undefined;
     /**
      * When this mapping stops delivering a batch its function keeps failing, for
      * a source that leaves the counting to the mapping.

package/dist/service/lambda/event-source/sim-lambda-event-source-mapping.js

@@ -31,6 +31,13 @@ export class SimLambdaEventSourceMapping {
      */
     start;
     functionResponseTypes;
+    /**
+     * The filters a record has to match before it is delivered, if this mapping
+     * was created with any.
+     *
+     * A mapping with none delivers every record its source hands it.
+     */
+    filterCriteria;
     /**
      * When this mapping stops delivering a batch its function keeps failing, for
      * a source that leaves the counting to the mapping.
@@ -59,6 +66,7 @@ export class SimLambdaEventSourceMapping {
         // cannot change what this mapping does with a batch afterwards.
         this.functionResponseTypes = [...(properties.functionResponseTypes ?? [])];
         this.streamRetryLimits = properties.streamRetryLimits;
+        this.filterCriteria = properties.filterCriteria;
         this.enabled = properties.enabled ?? true;
         this.lastModified = properties.createdAt;
     }
@@ -120,6 +128,9 @@ export class SimLambdaEventSourceMapping {
             // them out rather than reporting a limit it does not have.
             ...this.streamRetryLimits?.configuration(),
             FunctionResponseTypes: this.functionResponseTypes,
+            // A mapping created without filters reports none, as real Lambda does,
+            // rather than reporting an empty list of them.
+            FilterCriteria: this.filterCriteria?.configuration(),
             State: this.#state,
             StateTransitionReason: "USER_INITIATED",
             LastModified: this.lastModified,

package/dist/service/lambda/event-source/stream/sim-lambda-stream-cascade-guard.d.ts

@@ -1,4 +1,15 @@
 import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaStreamHalt } from "./sim-lambda-stream-halt.js";
+/**
+ * How many deliveries in a row may feed the source that invoked them before the
+ * simulation is refused.
+ *
+ * One write back is a handler doing its job, and the delivery it causes is the
+ * chance for that work to finish. A handler that settles takes two or three
+ * links of chain. A handler that loops takes every link there is, and the
+ * simulation has to say so before the test times out.
+ */
+export declare const simLambdaStreamCascadeLimit = 10;
 /**
  * The source a guard watches, said in the terms its own service uses.
  */
@@ -20,33 +31,49 @@ export interface SimLambdaStreamCascadeSource {
 interface SimLambdaStreamCascadeGuardProperties {
     readonly mapping: SimLambdaEventSourceMapping;
     readonly source: SimLambdaStreamCascadeSource;
+    /**
+     * What a refusal stops, since a mapping polling on from a checkpoint the
+     * refusal left where it was would deliver the same records again.
+     */
+    readonly halt: SimLambdaStreamHalt;
 }
 /**
- * Watches one mapping's deliveries for the function writing back into the
+ * Watches one mapping's deliveries for a chain of the function feeding the
  * source whose stream invoked it.
  *
  * The delivery runs inside its own asynchronous context, so a record written by
  * the handler is told apart from one written by anything else that happened to
  * be running at the same time. That distinction is the whole point: several
  * records written at once are an ordinary batch, and a handler feeding its own
- * source is a loop.
+ * source is the start of a chain.
+ *
+ * What the guard counts is the chain, and never the shape of one write. A
+ * handler that writes back and then finds its own work done writes nothing the
+ * second time round, the chain ends at one link, and the simulation settles. A
+ * handler that writes back every time takes the chain to
+ * `simLambdaStreamCascadeLimit` and is refused there.
  */
 export declare class SimLambdaStreamCascadeGuard {
     private readonly properties;
-    private cascaded;
+    private fedRecords;
+    private chained;
     constructor(properties: SimLambdaStreamCascadeGuardProperties);
     /**
-     * Run one delivery, refusing afterwards if the function fed its own source.
+     * Run one delivery, refusing afterwards if the chain has gone on long enough
+     * to say the simulation will never settle.
      *
      * The refusal comes after the delivery rather than during it, so the handler
-     * sees its own write succeed and the loop is reported to whoever is waiting
+     * sees its own write succeed and the chain is reported to whoever is waiting
      * for the simulation to settle.
      */
     around<Result>(delivery: () => Promise<Result>): Promise<Result>;
     /**
-     * Note a record written to the polled stream, answering with whether this
-     * mapping's own function wrote it.
+     * Note a record written to the polled stream, which counts only while this
+     * mapping's own function is the thing that is running.
+     *
+     * Counted rather than flagged, so a delivery can tell whether the count moved
+     * while it ran without the flag having to be put back afterwards.
      */
-    noteRecordWritten(): boolean;
+    noteRecordWritten(): void;
 }
 export {};

package/dist/service/lambda/event-source/stream/sim-lambda-stream-cascade-guard.js

@@ -1,51 +1,74 @@
 import { simLambdaEventSourceDeliveryContext } from "./sim-lambda-event-source-delivery-context.js";
 import { SimLambdaStreamCascadeError } from "./sim-lambda-stream-cascade.error.js";
 /**
- * Watches one mapping's deliveries for the function writing back into the
+ * How many deliveries in a row may feed the source that invoked them before the
+ * simulation is refused.
+ *
+ * One write back is a handler doing its job, and the delivery it causes is the
+ * chance for that work to finish. A handler that settles takes two or three
+ * links of chain. A handler that loops takes every link there is, and the
+ * simulation has to say so before the test times out.
+ */
+export const simLambdaStreamCascadeLimit = 10;
+/**
+ * Watches one mapping's deliveries for a chain of the function feeding the
  * source whose stream invoked it.
  *
  * The delivery runs inside its own asynchronous context, so a record written by
  * the handler is told apart from one written by anything else that happened to
  * be running at the same time. That distinction is the whole point: several
  * records written at once are an ordinary batch, and a handler feeding its own
- * source is a loop.
+ * source is the start of a chain.
+ *
+ * What the guard counts is the chain, and never the shape of one write. A
+ * handler that writes back and then finds its own work done writes nothing the
+ * second time round, the chain ends at one link, and the simulation settles. A
+ * handler that writes back every time takes the chain to
+ * `simLambdaStreamCascadeLimit` and is refused there.
  */
 export class SimLambdaStreamCascadeGuard {
     properties;
-    cascaded = false;
+    fedRecords = 0;
+    chained = 0;
     constructor(properties) {
         this.properties = properties;
     }
     /**
-     * Run one delivery, refusing afterwards if the function fed its own source.
+     * Run one delivery, refusing afterwards if the chain has gone on long enough
+     * to say the simulation will never settle.
      *
      * The refusal comes after the delivery rather than during it, so the handler
-     * sees its own write succeed and the loop is reported to whoever is waiting
+     * sees its own write succeed and the chain is reported to whoever is waiting
      * for the simulation to settle.
      */
     async around(delivery) {
+        const fedBefore = this.fedRecords;
         const result = await simLambdaEventSourceDeliveryContext.run(this, delivery);
-        if (this.cascaded) {
+        this.chained = this.fedRecords > fedBefore ? this.chained + 1 : 0;
+        if (this.chained >= simLambdaStreamCascadeLimit) {
             const { mapping, source } = this.properties;
+            this.properties.halt.stop();
             throw new SimLambdaStreamCascadeError({
                 functionName: mapping.functionName,
                 streamArn: source.streamArn,
                 wroteTo: source.wroteTo,
                 sourceRelation: source.sourceRelation,
                 advice: source.advice,
+                deliveries: this.chained,
             });
         }
         return result;
     }
     /**
-     * Note a record written to the polled stream, answering with whether this
-     * mapping's own function wrote it.
+     * Note a record written to the polled stream, which counts only while this
+     * mapping's own function is the thing that is running.
+     *
+     * Counted rather than flagged, so a delivery can tell whether the count moved
+     * while it ran without the flag having to be put back afterwards.
      */
     noteRecordWritten() {
-        if (!simLambdaEventSourceDeliveryContext.isDelivering(this)) {
-            return false;
+        if (simLambdaEventSourceDeliveryContext.isDelivering(this)) {
+            this.fedRecords += 1;
         }
-        this.cascaded = true;
-        return true;
     }
 }

package/dist/service/lambda/event-source/stream/sim-lambda-stream-cascade.error.d.ts

@@ -17,19 +17,28 @@ interface SimLambdaStreamCascadeErrorProperties {
      * in a second table, and a Kinesis result belongs on a second stream.
      */
     readonly advice: string;
+    /**
+     * How many deliveries in a row fed the source, which is the chain the guard
+     * counted before it gave up on the simulation settling.
+     */
+    readonly deliveries: number;
 }
 /**
- * A function writing back into the source whose stream invoked it.
+ * A function feeding the source whose stream invoked it, delivery after
+ * delivery.
  *
  * Every one of those writes is another stream record, which is another
  * delivery, which is another write. Real Lambda runs that loop for as long as
  * the account is willing to pay for it. Nothing here stops on its own, so the
  * simulation would go round until the test timed out with nothing to point at.
  *
+ * A handler that writes back and then settles is left alone. This is the chain
+ * that carried on, counted by `SimLambdaStreamCascadeGuard` up to
+ * `simLambdaStreamCascadeLimit`.
+ *
  * This is a simulator guard rather than AWS behaviour, and it is deliberately
- * not silent: a projection or an aggregate belongs in a second table or on a
- * second stream, and a test whose handler writes to its own source is testing a
- * loop.
+ * not silent: a projection or an aggregate that keeps going belongs in a second
+ * table or on a second stream.
  */
 export declare class SimLambdaStreamCascadeError extends SimLambdaError {
     readonly name = "SimLambdaStreamCascadeError";

package/dist/service/lambda/event-source/stream/sim-lambda-stream-cascade.error.js

@@ -1,23 +1,29 @@
 import { SimLambdaError } from "../../error/sim-lambda.error.js";
 /**
- * A function writing back into the source whose stream invoked it.
+ * A function feeding the source whose stream invoked it, delivery after
+ * delivery.
  *
  * Every one of those writes is another stream record, which is another
  * delivery, which is another write. Real Lambda runs that loop for as long as
  * the account is willing to pay for it. Nothing here stops on its own, so the
  * simulation would go round until the test timed out with nothing to point at.
  *
+ * A handler that writes back and then settles is left alone. This is the chain
+ * that carried on, counted by `SimLambdaStreamCascadeGuard` up to
+ * `simLambdaStreamCascadeLimit`.
+ *
  * This is a simulator guard rather than AWS behaviour, and it is deliberately
- * not silent: a projection or an aggregate belongs in a second table or on a
- * second stream, and a test whose handler writes to its own source is testing a
- * loop.
+ * not silent: a projection or an aggregate that keeps going belongs in a second
+ * table or on a second stream.
  */
 export class SimLambdaStreamCascadeError extends SimLambdaError {
     name = "SimLambdaStreamCascadeError";
     constructor(properties) {
         super(`Function ${properties.functionName} ${properties.wroteTo} while ` +
             `handling records from ${properties.sourceRelation} ` +
-            `${properties.streamArn}. Each write would be delivered back to the ` +
-            `function, so the simulation would never settle. ${properties.advice}`);
+            `${properties.streamArn} on ${String(properties.deliveries)} ` +
+            `deliveries in a row. Each of those writes was delivered back to the ` +
+            `function and brought on the next one, and the simulation is still ` +
+            `going round. ${properties.advice}`);
     }
 }

package/dist/service/lambda/event-source/stream/sim-lambda-stream-halt.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Whether a mapping has finished polling, and the one place that says so.
+ *
+ * Two things finish a mapping. Deleting it stops the poller, and the cascade
+ * guard refusing a chain of the function's own writes stops it too. A poll
+ * reads one answer either way, and neither side has to know about the other.
+ */
+export declare class SimLambdaStreamHalt {
+    private halted;
+    /**
+     * Whether polling has finished.
+     */
+    get stopped(): boolean;
+    /**
+     * Finish polling.
+     */
+    stop(): void;
+}

package/dist/service/lambda/event-source/stream/sim-lambda-stream-halt.js

@@ -0,0 +1,22 @@
+/**
+ * Whether a mapping has finished polling, and the one place that says so.
+ *
+ * Two things finish a mapping. Deleting it stops the poller, and the cascade
+ * guard refusing a chain of the function's own writes stops it too. A poll
+ * reads one answer either way, and neither side has to know about the other.
+ */
+export class SimLambdaStreamHalt {
+    halted = false;
+    /**
+     * Whether polling has finished.
+     */
+    get stopped() {
+        return this.halted;
+    }
+    /**
+     * Finish polling.
+     */
+    stop() {
+        this.halted = true;
+    }
+}

package/dist/service/lambda/function/invoke/sim-lambda-invocation-deadline.d.ts

@@ -14,6 +14,10 @@ interface SimLambdaInvocationDeadlineProperties {
  * waits for a handler that has been timed out, and what it goes on to do
  * reaches nobody, which is the closest an in-process simulation gets to an
  * execution environment being taken away.
+ *
+ * Simulated time standing still holds the handler's timers and the deadline
+ * alike. A stall watch on host time ends an invocation neither of them can
+ * reach, with an error saying why.
  */
 export declare class SimLambdaInvocationDeadline {
     #private;

package/dist/service/lambda/function/invoke/sim-lambda-invocation-deadline.js

@@ -1,6 +1,8 @@
 import { SimLambdaClockTimer } from "./timer/sim-lambda-clock-timer.js";
 import { SimLambdaInvocationTimers } from "./timer/sim-lambda-invocation-timers.js";
 import { simLambdaProcessTimers } from "./timer/sim-lambda-process-timers.js";
+import { SimLambdaStallWatch } from "./sim-lambda-stall-watch.js";
+import { simLambdaStalledError } from "./sim-lambda-stalled.error.js";
 import { simLambdaTimedOutError } from "./sim-lambda-timed-out.error.js";
 const millisecondsPerSecond = 1000;
 /**
@@ -13,6 +15,10 @@ const millisecondsPerSecond = 1000;
  * waits for a handler that has been timed out, and what it goes on to do
  * reaches nobody, which is the closest an in-process simulation gets to an
  * execution environment being taken away.
+ *
+ * Simulated time standing still holds the handler's timers and the deadline
+ * alike. A stall watch on host time ends an invocation neither of them can
+ * reach, with an error saying why.
  */
 export class SimLambdaInvocationDeadline {
     #properties;
@@ -40,6 +46,7 @@ export class SimLambdaInvocationDeadline {
         const ending = () => {
             timers.cancelAll();
             deadline.cancel();
+            stall.cancel();
         };
         const failing = (error) => {
             ending();
@@ -59,7 +66,21 @@ export class SimLambdaInvocationDeadline {
                 }));
             },
         });
+        const stall = new SimLambdaStallWatch({
+            background,
+            timeoutSeconds,
+            waitingOn: () => timers.pending(),
+            stalled: (waitingOn, waitedMilliseconds) => {
+                failing(simLambdaStalledError({
+                    awsRequestId,
+                    at: background.now(),
+                    waitingOn,
+                    waitedMilliseconds,
+                }));
+            },
+        });
         deadline.startAt(new Date(background.now().getTime() + timeoutSeconds * millisecondsPerSecond));
+        stall.start();
         try {
             return await background.outstanding(async () => await racing(timers, stopped, handler, ending));
         }

package/dist/service/lambda/function/invoke/sim-lambda-stall-watch.d.ts

@@ -0,0 +1,38 @@
+import type { BackgroundScheduler } from "../../../../util/background/background.js";
+import type { SimLambdaPendingTimer } from "./timer/sim-lambda-pending-timer.js";
+interface SimLambdaStallWatchProperties {
+    readonly background: BackgroundScheduler;
+    /** The seconds the invocation has to answer in, on the simulated clock. */
+    readonly timeoutSeconds: number;
+    /** The timer the invocation is waiting on, where it is waiting on one. */
+    readonly waitingOn: () => SimLambdaPendingTimer | undefined;
+    /** What happens once the invocation turns out to have no way to finish. */
+    readonly stalled: (waitingOn: SimLambdaPendingTimer, waitedMilliseconds: number) => void;
+}
+/**
+ * A watch on host time for an invocation the simulated clock has left behind.
+ *
+ * A handler's timers wait on the simulation's clock, and so does the
+ * invocation's deadline. Simulated time standing still holds both, and the
+ * invocation runs on until the test framework gives up on the test around it.
+ * Elapsed host time is the only thing separating that from a test meaning to
+ * start an invocation, advance the clock and then wait for it, which is why
+ * host time is what this watches.
+ *
+ * A turn that finds simulated time has moved starts the wait again, so a test
+ * advancing the clock in steps is left alone. The host timer is unreferenced,
+ * and an invocation nobody is driving never holds the process open.
+ */
+export declare class SimLambdaStallWatch {
+    #private;
+    constructor(properties: SimLambdaStallWatchProperties);
+    /**
+     * Start watching, from the instant the clock reads now.
+     */
+    start(): void;
+    /**
+     * Give up watching, as an invocation that has ended does.
+     */
+    cancel(): void;
+}
+export {};