@kensio/yulin 1.19.4 → 1.20.0

package/dist/service/kinesis/stream/sim-kinesis-shard-map.js

@@ -0,0 +1,46 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { simKinesisHashKeyRanges } from "./sim-kinesis-hash-key.js";
+import { SimKinesisShard } from "./sim-kinesis-shard.js";
+/**
+ * The shards of one stream, and which slice of the hash key space each holds.
+ *
+ * The shards are opened together and stay as they are. Nothing here splits or
+ * merges one, so a record's shard is decided by its hash key alone and stays
+ * decidable for the life of the stream.
+ */
+export class SimKinesisShardMap {
+    shards;
+    constructor(properties) {
+        this.shards = simKinesisHashKeyRanges(properties.shardCount).map((hashKeyRange, ordinal) => new SimKinesisShard({
+            ordinal,
+            hashKeyRange,
+            startingSequenceNumber: properties.sequenceNumbers.take(),
+        }));
+    }
+    /**
+     * Find a shard by its identifier.
+     */
+    find(shardId) {
+        return this.shards.find((shard) => shard.shardId === shardId);
+    }
+    /**
+     * The shard whose slice of the hash key space a key falls in.
+     *
+     * The ranges cover the whole space between them, so one of them always
+     * matches whatever a 128 bit hash lands on.
+     */
+    covering(hashKey) {
+        const shard = this.shards.find((candidate) => candidate.covers(hashKey));
+        assertDefined(shard, `Kinesis shard covering hash key ${hashKey}`);
+        return shard;
+    }
+    /**
+     * Drop the records put before an instant, on every shard.
+     */
+    trim(before) {
+        for (const shard of this.shards) {
+            shard.trim(before);
+        }
+    }
+}
+//# sourceMappingURL=sim-kinesis-shard-map.js.map

package/dist/service/kinesis/stream/sim-kinesis-shard-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-shard-map.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-shard-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAOzD;;;;;;GAMG;AACH,MAAM,OAAO,kBAAkB;IACb,MAAM,CAA6B;IAEnD,YAAY,UAAwC;QAClD,IAAI,CAAC,MAAM,GAAG,uBAAuB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,GAAG,CAC9D,CAAC,YAAY,EAAE,OAAO,EAAE,EAAE,CACxB,IAAI,eAAe,CAAC;YAClB,OAAO;YACP,YAAY;YACZ,sBAAsB,EAAE,UAAU,CAAC,eAAe,CAAC,IAAI,EAAE;SAC1D,CAAC,CACL,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,OAAe;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC;IAChE,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,OAAe;QACtB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;QACzE,aAAa,CAAC,KAAK,EAAE,mCAAmC,OAAO,EAAE,CAAC,CAAC;QAEnE,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,MAAY;QACf,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;CACF"}

package/dist/service/kinesis/stream/sim-kinesis-shard.d.ts

@@ -0,0 +1,62 @@
+import type { SimKinesisHashKeyRange } from "./sim-kinesis-hash-key.js";
+import type { SimKinesisRecord } from "./sim-kinesis-record.js";
+/**
+ * The identifier the shard at an ordinal carries.
+ *
+ * Kinesis shapes these as `shardId-000000000000`, counting from zero, and a
+ * consumer that stores a shard identifier stores that string.
+ */
+export declare function simKinesisShardId(ordinal: number): string;
+interface SimKinesisShardProperties {
+    readonly ordinal: number;
+    readonly hashKeyRange: SimKinesisHashKeyRange;
+    readonly startingSequenceNumber: string;
+}
+/**
+ * One shard of one stream, and the records put onto it.
+ *
+ * A shard owns a slice of the hash key space, and it takes the records whose
+ * partition keys hash into that slice. Nothing here splits or merges: a shard
+ * is opened when the stream is created and stays open for the life of it.
+ */
+export declare class SimKinesisShard {
+    readonly shardId: string;
+    readonly hashKeyRange: SimKinesisHashKeyRange;
+    /**
+     * The sequence number this shard opened at.
+     *
+     * Real Kinesis gives a shard one when it is created, before any record is on
+     * it, and reports it in the shard's sequence number range. It stays where it
+     * is as records are put and trimmed, so it is a fact about the shard rather
+     * than about what the shard currently holds.
+     */
+    readonly startingSequenceNumber: string;
+    private readonly written;
+    constructor(properties: SimKinesisShardProperties);
+    /**
+     * The records on this shard, oldest first.
+     */
+    get records(): readonly SimKinesisRecord[];
+    /**
+     * The sequence number of the newest record on this shard.
+     */
+    get latestSequenceNumber(): string | undefined;
+    /**
+     * Whether a hash key falls in this shard's slice of the space.
+     */
+    covers(hashKey: bigint): boolean;
+    /**
+     * Put a record onto this shard.
+     */
+    append(record: SimKinesisRecord): void;
+    /**
+     * Drop the records put before an instant.
+     *
+     * Real Kinesis moves a reader asking for a trimmed position on to the trim
+     * horizon rather than refusing it, so nothing here has to remember how far
+     * trimming got.
+     */
+    trim(before: Date): void;
+}
+export {};
+//# sourceMappingURL=sim-kinesis-shard.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-shard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-shard.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-shard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAOhE;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,UAAU,yBAAyB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,sBAAsB,CAAC;IAC9C,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;CACzC;AAED;;;;;;GAMG;AACH,qBAAa,eAAe;IAC1B,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,YAAY,EAAE,sBAAsB,CAAC;IAErD;;;;;;;OAOG;IACH,SAAgB,sBAAsB,EAAE,MAAM,CAAC;IAE/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAElD,YAAY,UAAU,EAAE,yBAAyB,EAIhD;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,SAAS,gBAAgB,EAAE,CAEzC;IAED;;OAEG;IACH,IAAI,oBAAoB,IAAI,MAAM,GAAG,SAAS,CAE7C;IAED;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAI/B;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAErC;IAED;;;;;;OAMG;IACH,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,CAMvB;CACF"}

package/dist/service/kinesis/stream/sim-kinesis-shard.js

@@ -0,0 +1,76 @@
+/**
+ * How many digits Kinesis pads a shard identifier's ordinal to.
+ */
+const shardOrdinalDigits = 12;
+/**
+ * The identifier the shard at an ordinal carries.
+ *
+ * Kinesis shapes these as `shardId-000000000000`, counting from zero, and a
+ * consumer that stores a shard identifier stores that string.
+ */
+export function simKinesisShardId(ordinal) {
+    return `shardId-${ordinal.toString().padStart(shardOrdinalDigits, "0")}`;
+}
+/**
+ * One shard of one stream, and the records put onto it.
+ *
+ * A shard owns a slice of the hash key space, and it takes the records whose
+ * partition keys hash into that slice. Nothing here splits or merges: a shard
+ * is opened when the stream is created and stays open for the life of it.
+ */
+export class SimKinesisShard {
+    shardId;
+    hashKeyRange;
+    /**
+     * The sequence number this shard opened at.
+     *
+     * Real Kinesis gives a shard one when it is created, before any record is on
+     * it, and reports it in the shard's sequence number range. It stays where it
+     * is as records are put and trimmed, so it is a fact about the shard rather
+     * than about what the shard currently holds.
+     */
+    startingSequenceNumber;
+    written = [];
+    constructor(properties) {
+        this.shardId = simKinesisShardId(properties.ordinal);
+        this.hashKeyRange = properties.hashKeyRange;
+        this.startingSequenceNumber = properties.startingSequenceNumber;
+    }
+    /**
+     * The records on this shard, oldest first.
+     */
+    get records() {
+        return this.written;
+    }
+    /**
+     * The sequence number of the newest record on this shard.
+     */
+    get latestSequenceNumber() {
+        return this.written.at(-1)?.sequenceNumber;
+    }
+    /**
+     * Whether a hash key falls in this shard's slice of the space.
+     */
+    covers(hashKey) {
+        const { startingHashKey, endingHashKey } = this.hashKeyRange;
+        return hashKey >= startingHashKey && hashKey <= endingHashKey;
+    }
+    /**
+     * Put a record onto this shard.
+     */
+    append(record) {
+        this.written.push(record);
+    }
+    /**
+     * Drop the records put before an instant.
+     *
+     * Real Kinesis moves a reader asking for a trimmed position on to the trim
+     * horizon rather than refusing it, so nothing here has to remember how far
+     * trimming got.
+     */
+    trim(before) {
+        const surviving = this.written.findIndex((record) => record.arrivedAt.getTime() >= before.getTime());
+        this.written.splice(0, surviving === -1 ? this.written.length : surviving);
+    }
+}
+//# sourceMappingURL=sim-kinesis-shard.js.map

package/dist/service/kinesis/stream/sim-kinesis-shard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-shard.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-shard.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAe;IAC/C,OAAO,WAAW,OAAO,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,kBAAkB,EAAE,GAAG,CAAC,EAAE,CAAC;AAC3E,CAAC;AAQD;;;;;;GAMG;AACH,MAAM,OAAO,eAAe;IACV,OAAO,CAAS;IAChB,YAAY,CAAyB;IAErD;;;;;;;OAOG;IACa,sBAAsB,CAAS;IAE9B,OAAO,GAAuB,EAAE,CAAC;IAElD,YAAY,UAAqC;QAC/C,IAAI,CAAC,OAAO,GAAG,iBAAiB,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACrD,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;QAC5C,IAAI,CAAC,sBAAsB,GAAG,UAAU,CAAC,sBAAsB,CAAC;IAClE,CAAC;IAED;;OAEG;IACH,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,IAAI,oBAAoB;QACtB,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,OAAe;QACpB,MAAM,EAAE,eAAe,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC;QAE7D,OAAO,OAAO,IAAI,eAAe,IAAI,OAAO,IAAI,aAAa,CAAC;IAChE,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAwB;QAC7B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IAED;;;;;;OAMG;IACH,IAAI,CAAC,MAAY;QACf,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CACtC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,MAAM,CAAC,OAAO,EAAE,CAC3D,CAAC;QAEF,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC7E,CAAC;CACF"}

package/dist/service/kinesis/stream/sim-kinesis-stream-activity.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Something outside Kinesis waiting for records on a stream.
+ *
+ * A Lambda event source mapping is the one this exists for. Real Lambda polls a
+ * stream continuously, and nothing in this simulation runs continuously, so the
+ * stream says when there is something to poll for instead.
+ */
+export interface SimKinesisStreamWatcher {
+    /**
+     * A record has been put, and can be read now.
+     *
+     * There is no instant here, unlike the queue watcher this mirrors. A stream
+     * record is readable the moment it is put: nothing delays one, and nothing
+     * hides one that has been handed out.
+     */
+    recordsAvailable(): void;
+}
+/**
+ * What a consumer that cannot poll continuously needs from the streams of one
+ * simulated Kinesis: to be told when a record has been put.
+ *
+ * Watchers are held by stream ARN rather than on the stream itself, so a
+ * watcher survives whatever the stream does, and so the stream model stays a
+ * log rather than a subscription list.
+ */
+export declare class SimKinesisStreamActivity {
+    private readonly watchers;
+    /**
+     * Watch a stream for the records put onto it.
+     */
+    watch(streamArn: string, watcher: SimKinesisStreamWatcher): void;
+    /**
+     * Stop watching a stream.
+     */
+    unwatch(streamArn: string, watcher: SimKinesisStreamWatcher): void;
+    /**
+     * Tell a stream's watchers that there is something to read.
+     */
+    recordsAvailable(streamArn: string): void;
+    private watchersOf;
+}
+//# sourceMappingURL=sim-kinesis-stream-activity.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-stream-activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-activity.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-activity.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;OAMG;IACH,gBAAgB,IAAI,IAAI,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgD;IAEzE;;OAEG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAE/D;IAED;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAejE;IAED;;OAEG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAIxC;IAED,OAAO,CAAC,UAAU;CAGnB"}

package/dist/service/kinesis/stream/sim-kinesis-stream-activity.js

@@ -0,0 +1,43 @@
+/**
+ * What a consumer that cannot poll continuously needs from the streams of one
+ * simulated Kinesis: to be told when a record has been put.
+ *
+ * Watchers are held by stream ARN rather than on the stream itself, so a
+ * watcher survives whatever the stream does, and so the stream model stays a
+ * log rather than a subscription list.
+ */
+export class SimKinesisStreamActivity {
+    watchers = new Map();
+    /**
+     * Watch a stream for the records put onto it.
+     */
+    watch(streamArn, watcher) {
+        this.watchers.set(streamArn, [...this.watchersOf(streamArn), watcher]);
+    }
+    /**
+     * Stop watching a stream.
+     */
+    unwatch(streamArn, watcher) {
+        const remaining = this.watchersOf(streamArn).filter((held) => held !== watcher);
+        if (remaining.length === 0) {
+            // A stream nothing watches any more is forgotten. Keeping the empty list
+            // would grow one entry per stream ever watched, for the life of the
+            // simulation.
+            this.watchers.delete(streamArn);
+            return;
+        }
+        this.watchers.set(streamArn, [...remaining]);
+    }
+    /**
+     * Tell a stream's watchers that there is something to read.
+     */
+    recordsAvailable(streamArn) {
+        for (const watcher of this.watchersOf(streamArn)) {
+            watcher.recordsAvailable();
+        }
+    }
+    watchersOf(streamArn) {
+        return this.watchers.get(streamArn) ?? [];
+    }
+}
+//# sourceMappingURL=sim-kinesis-stream-activity.js.map

package/dist/service/kinesis/stream/sim-kinesis-stream-activity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-activity.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-activity.ts"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AACH,MAAM,OAAO,wBAAwB;IAClB,QAAQ,GAAG,IAAI,GAAG,EAAqC,CAAC;IAEzE;;OAEG;IACH,KAAK,CAAC,SAAiB,EAAE,OAAgC;QACvD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;IACzE,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,SAAiB,EAAE,OAAgC;QACzD,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,MAAM,CACjD,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAC3B,CAAC;QAEF,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3B,yEAAyE;YACzE,oEAAoE;YACpE,cAAc;YACd,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YAEhC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,SAAiB;QAChC,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;YACjD,OAAO,CAAC,gBAAgB,EAAE,CAAC;QAC7B,CAAC;IACH,CAAC;IAEO,UAAU,CAAC,SAAiB;QAClC,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAC5C,CAAC;CACF"}

package/dist/service/kinesis/stream/sim-kinesis-stream-arn.d.ts

@@ -0,0 +1,30 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+/**
+ * Where one stream is, in the three facts its ARN carries.
+ *
+ * The strings are unbranded because the callers that have only read an ARN,
+ * rather than been handed a scope, have nothing but strings to offer.
+ */
+export interface SimKinesisStreamLocation {
+    readonly regionName: string;
+    readonly accountId: string;
+    readonly name: string;
+}
+/**
+ * The ARN of a stream of a given name in an Account and Region.
+ */
+export declare function simKinesisStreamArn(accountRegionScope: SimAwsAccountRegionScope, name: string): string;
+/**
+ * Read a stream ARN into the Region, Account and name it carries.
+ *
+ * All three matter. An ARN naming another Account or Region reaches nothing in
+ * a simulated Kinesis scope rather than having its name read out and looked up
+ * locally, since treating a foreign one as local would let a test pass while
+ * the real call crossed a boundary it has no permission for.
+ *
+ * Nothing is returned for a string that is not a stream ARN, including a
+ * consumer ARN, which carries the consumer name and creation time after the
+ * stream name.
+ */
+export declare function parseSimKinesisStreamArn(value: string): SimKinesisStreamLocation | undefined;
+//# sourceMappingURL=sim-kinesis-stream-arn.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-stream-arn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-arn.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-arn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAQ1F;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,kBAAkB,EAAE,wBAAwB,EAC5C,IAAI,EAAE,MAAM,GACX,MAAM,CAIR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,GACZ,wBAAwB,GAAG,SAAS,CA+BtC"}

package/dist/service/kinesis/stream/sim-kinesis-stream-arn.js

@@ -0,0 +1,47 @@
+const streamArnPartition = "aws";
+const streamArnService = "kinesis";
+const streamArnResourceType = "stream";
+/**
+ * The ARN of a stream of a given name in an Account and Region.
+ */
+export function simKinesisStreamArn(accountRegionScope, name) {
+    const { regionName, accountId } = accountRegionScope;
+    return `arn:${streamArnPartition}:${streamArnService}:${regionName}:${accountId}:${streamArnResourceType}/${name}`;
+}
+/**
+ * Read a stream ARN into the Region, Account and name it carries.
+ *
+ * All three matter. An ARN naming another Account or Region reaches nothing in
+ * a simulated Kinesis scope rather than having its name read out and looked up
+ * locally, since treating a foreign one as local would let a test pass while
+ * the real call crossed a boundary it has no permission for.
+ *
+ * Nothing is returned for a string that is not a stream ARN, including a
+ * consumer ARN, which carries the consumer name and creation time after the
+ * stream name.
+ */
+export function parseSimKinesisStreamArn(value) {
+    const parts = value.split(":");
+    if (parts.length !== 6) {
+        return undefined;
+    }
+    const [prefix, partition, service, regionName, accountId, resource] = parts;
+    if (prefix !== "arn" ||
+        partition !== streamArnPartition ||
+        service !== streamArnService ||
+        regionName === undefined ||
+        regionName === "" ||
+        accountId === undefined ||
+        accountId === "" ||
+        resource === undefined) {
+        return undefined;
+    }
+    if (!resource.startsWith(`${streamArnResourceType}/`)) {
+        return undefined;
+    }
+    const name = resource.slice(`${streamArnResourceType}/`.length);
+    return name === "" || name.includes("/")
+        ? undefined
+        : { regionName, accountId, name };
+}
+//# sourceMappingURL=sim-kinesis-stream-arn.js.map

package/dist/service/kinesis/stream/sim-kinesis-stream-arn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-arn.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-arn.ts"],"names":[],"mappings":"AAEA,MAAM,kBAAkB,GAAG,KAAK,CAAC;AAEjC,MAAM,gBAAgB,GAAG,SAAS,CAAC;AAEnC,MAAM,qBAAqB,GAAG,QAAQ,CAAC;AAcvC;;GAEG;AACH,MAAM,UAAU,mBAAmB,CACjC,kBAA4C,EAC5C,IAAY;IAEZ,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,kBAAkB,CAAC;IAErD,OAAO,OAAO,kBAAkB,IAAI,gBAAgB,IAAI,UAAU,IAAI,SAAS,IAAI,qBAAqB,IAAI,IAAI,EAAE,CAAC;AACrH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,wBAAwB,CACtC,KAAa;IAEb,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAE/B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,GAAG,KAAK,CAAC;IAE5E,IACE,MAAM,KAAK,KAAK;QAChB,SAAS,KAAK,kBAAkB;QAChC,OAAO,KAAK,gBAAgB;QAC5B,UAAU,KAAK,SAAS;QACxB,UAAU,KAAK,EAAE;QACjB,SAAS,KAAK,SAAS;QACvB,SAAS,KAAK,EAAE;QAChB,QAAQ,KAAK,SAAS,EACtB,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,GAAG,qBAAqB,GAAG,CAAC,EAAE,CAAC;QACtD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,qBAAqB,GAAG,CAAC,MAAM,CAAC,CAAC;IAEhE,OAAO,IAAI,KAAK,EAAE,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QACtC,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;AACtC,CAAC"}

package/dist/service/kinesis/stream/sim-kinesis-stream-mode.d.ts

@@ -0,0 +1,24 @@
+/**
+ * How a stream's capacity is decided.
+ */
+export type SimKinesisStreamMode = "PROVISIONED" | "ON_DEMAND";
+/**
+ * How many shards an on-demand stream starts with.
+ *
+ * Real Kinesis gives an on-demand stream four shards and grows it with the
+ * traffic. Nothing here measures traffic, so the count stays where it starts.
+ */
+export declare const simKinesisOnDemandShardCount = 4;
+/**
+ * Read the stream mode a request asked for.
+ */
+export declare function simKinesisStreamModeOf(mode: string | undefined): SimKinesisStreamMode;
+/**
+ * How many shards a stream is created with.
+ *
+ * An on-demand stream takes no shard count, and real Kinesis refuses a request
+ * carrying both. A provisioned stream created without one gets a single shard,
+ * which is what real Kinesis does.
+ */
+export declare function simKinesisCreatedShardCount(mode: SimKinesisStreamMode, shardCount: number | undefined): number;
+//# sourceMappingURL=sim-kinesis-stream-mode.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-stream-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-mode.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-mode.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG,WAAW,CAAC;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAO9C;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,oBAAoB,CAatB;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,oBAAoB,EAC1B,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,MAAM,CA6BR"}

package/dist/service/kinesis/stream/sim-kinesis-stream-mode.js

@@ -0,0 +1,52 @@
+import { SimKinesisInvalidArgumentException } from "../error/sim-kinesis.error.js";
+/**
+ * How many shards an on-demand stream starts with.
+ *
+ * Real Kinesis gives an on-demand stream four shards and grows it with the
+ * traffic. Nothing here measures traffic, so the count stays where it starts.
+ */
+export const simKinesisOnDemandShardCount = 4;
+/**
+ * The most shards real Kinesis creates a stream with.
+ */
+const maxShardCount = 100_000;
+/**
+ * Read the stream mode a request asked for.
+ */
+export function simKinesisStreamModeOf(mode) {
+    if (mode === undefined || mode === "PROVISIONED") {
+        return "PROVISIONED";
+    }
+    if (mode === "ON_DEMAND") {
+        return "ON_DEMAND";
+    }
+    throw new SimKinesisInvalidArgumentException(`StreamModeDetails.StreamMode '${mode}' is neither PROVISIONED nor ` +
+        `ON_DEMAND`);
+}
+/**
+ * How many shards a stream is created with.
+ *
+ * An on-demand stream takes no shard count, and real Kinesis refuses a request
+ * carrying both. A provisioned stream created without one gets a single shard,
+ * which is what real Kinesis does.
+ */
+export function simKinesisCreatedShardCount(mode, shardCount) {
+    if (mode === "ON_DEMAND") {
+        if (shardCount !== undefined) {
+            throw new SimKinesisInvalidArgumentException("ShardCount may not be set on a stream created in ON_DEMAND mode");
+        }
+        return simKinesisOnDemandShardCount;
+    }
+    if (shardCount === undefined) {
+        return 1;
+    }
+    if (!Number.isSafeInteger(shardCount) || shardCount < 1) {
+        throw new SimKinesisInvalidArgumentException(`ShardCount ${shardCount} is not a whole number of shards`);
+    }
+    if (shardCount > maxShardCount) {
+        throw new SimKinesisInvalidArgumentException(`ShardCount ${shardCount} is more than the ${maxShardCount} shards ` +
+            `Kinesis creates a stream with`);
+    }
+    return shardCount;
+}
+//# sourceMappingURL=sim-kinesis-stream-mode.js.map

package/dist/service/kinesis/stream/sim-kinesis-stream-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-mode.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-mode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,+BAA+B,CAAC;AAOnF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC;AAE9C;;GAEG;AACH,MAAM,aAAa,GAAG,OAAO,CAAC;AAE9B;;GAEG;AACH,MAAM,UAAU,sBAAsB,CACpC,IAAwB;IAExB,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,aAAa,EAAE,CAAC;QACjD,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;QACzB,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,MAAM,IAAI,kCAAkC,CAC1C,iCAAiC,IAAI,+BAA+B;QAClE,WAAW,CACd,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CACzC,IAA0B,EAC1B,UAA8B;IAE9B,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;QACzB,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,MAAM,IAAI,kCAAkC,CAC1C,iEAAiE,CAClE,CAAC;QACJ,CAAC;QAED,OAAO,4BAA4B,CAAC;IACtC,CAAC;IAED,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,CAAC,CAAC;IACX,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,IAAI,UAAU,GAAG,CAAC,EAAE,CAAC;QACxD,MAAM,IAAI,kCAAkC,CAC1C,cAAc,UAAU,kCAAkC,CAC3D,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,GAAG,aAAa,EAAE,CAAC;QAC/B,MAAM,IAAI,kCAAkC,CAC1C,cAAc,UAAU,qBAAqB,aAAa,UAAU;YAClE,+BAA+B,CAClC,CAAC;IACJ,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/service/kinesis/stream/sim-kinesis-stream-name.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The name of one simulated Kinesis stream.
+ *
+ * A name is unique within one Account and Region, and it is the resource part
+ * of the stream's ARN. Branding it keeps a raw string from reaching the store
+ * without having been through the validation real Kinesis applies first.
+ */
+export declare class SimKinesisStreamName {
+    readonly value: string;
+    constructor(value: string | undefined);
+}
+//# sourceMappingURL=sim-kinesis-stream-name.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-stream-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-name.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-name.ts"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,qBAAa,oBAAoB;IAC/B,SAAgB,KAAK,EAAE,MAAM,CAAC;IAE9B,YAAY,KAAK,EAAE,MAAM,GAAG,SAAS,EAsBpC;CACF"}

package/dist/service/kinesis/stream/sim-kinesis-stream-name.js

@@ -0,0 +1,34 @@
+import { SimKinesisInvalidArgumentException } from "../error/sim-kinesis.error.js";
+/**
+ * The longest stream name real Kinesis accepts.
+ */
+const maxStreamNameLength = 128;
+/**
+ * The characters a stream name may be made of.
+ */
+const streamNamePattern = /^[a-zA-Z0-9_.-]+$/u;
+/**
+ * The name of one simulated Kinesis stream.
+ *
+ * A name is unique within one Account and Region, and it is the resource part
+ * of the stream's ARN. Branding it keeps a raw string from reaching the store
+ * without having been through the validation real Kinesis applies first.
+ */
+export class SimKinesisStreamName {
+    value;
+    constructor(value) {
+        if (value === undefined || value === "") {
+            throw new SimKinesisInvalidArgumentException("StreamName is required and may not be empty");
+        }
+        if (value.length > maxStreamNameLength) {
+            throw new SimKinesisInvalidArgumentException(`StreamName '${value}' is longer than the ${maxStreamNameLength} ` +
+                `characters Kinesis accepts`);
+        }
+        if (!streamNamePattern.test(value)) {
+            throw new SimKinesisInvalidArgumentException(`StreamName '${value}' may hold only letters, digits, underscores, ` +
+                `hyphens and full stops`);
+        }
+        this.value = value;
+    }
+}
+//# sourceMappingURL=sim-kinesis-stream-name.js.map

package/dist/service/kinesis/stream/sim-kinesis-stream-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-name.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-name.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,+BAA+B,CAAC;AAEnF;;GAEG;AACH,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEhC;;GAEG;AACH,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,OAAO,oBAAoB;IACf,KAAK,CAAS;IAE9B,YAAY,KAAyB;QACnC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;YACxC,MAAM,IAAI,kCAAkC,CAC1C,6CAA6C,CAC9C,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,GAAG,mBAAmB,EAAE,CAAC;YACvC,MAAM,IAAI,kCAAkC,CAC1C,eAAe,KAAK,wBAAwB,mBAAmB,GAAG;gBAChE,4BAA4B,CAC/B,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,kCAAkC,CAC1C,eAAe,KAAK,gDAAgD;gBAClE,wBAAwB,CAC3B,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CACF"}

package/dist/service/kinesis/stream/sim-kinesis-stream-position.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Where on a shard a reader is, between one GetRecords and the next.
+ *
+ * The four kinds are what the five shard iterator types come down to.
+ * TRIM_HORIZON is the start of whatever the shard still holds.
+ * AT_SEQUENCE_NUMBER and AFTER_SEQUENCE_NUMBER are the two ways of naming a
+ * record, and the difference between them is whether that record is handed back
+ * or stepped over. AT_TIMESTAMP names an instant instead.
+ *
+ * LATEST has no kind of its own. It means "after the newest record on the shard
+ * when the iterator was made", which is either `after` that record or, on a
+ * shard holding nothing, `start`. Resolving it where the iterator is made is
+ * what pins it to that instant, as real Kinesis does.
+ *
+ * A position is a place rather than an index, so it survives the shard being
+ * trimmed underneath it. That is what lets a read tell "you are asking for
+ * records that have aged out" from "there is nothing new yet".
+ */
+export type SimKinesisStreamPosition = {
+    readonly kind: "start";
+} | {
+    readonly kind: "at";
+    readonly sequenceNumber: string;
+} | {
+    readonly kind: "after";
+    readonly sequenceNumber: string;
+} | {
+    readonly kind: "timestamp";
+    readonly epochMillis: number;
+};
+/**
+ * The position a reader starting from the oldest record it can reach is at.
+ */
+export declare const simKinesisStreamStart: SimKinesisStreamPosition;
+/**
+ * The position a reader that has just taken a record is at.
+ */
+export declare function simKinesisStreamAfter(sequenceNumber: string): SimKinesisStreamPosition;
+//# sourceMappingURL=sim-kinesis-stream-position.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-stream-position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-position.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-position.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACxD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,wBAEnC,CAAC;AAEF;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,GACrB,wBAAwB,CAE1B"}

package/dist/service/kinesis/stream/sim-kinesis-stream-position.js

@@ -0,0 +1,13 @@
+/**
+ * The position a reader starting from the oldest record it can reach is at.
+ */
+export const simKinesisStreamStart = {
+    kind: "start",
+};
+/**
+ * The position a reader that has just taken a record is at.
+ */
+export function simKinesisStreamAfter(sequenceNumber) {
+    return { kind: "after", sequenceNumber };
+}
+//# sourceMappingURL=sim-kinesis-stream-position.js.map

package/dist/service/kinesis/stream/sim-kinesis-stream-position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-position.js","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-position.ts"],"names":[],"mappings":"AAwBA;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAA6B;IAC7D,IAAI,EAAE,OAAO;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,qBAAqB,CACnC,cAAsB;IAEtB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;AAC3C,CAAC"}

package/dist/service/kinesis/stream/sim-kinesis-stream-read.d.ts

@@ -0,0 +1,23 @@
+import type { SimKinesisRecord } from "./sim-kinesis-record.js";
+import { type SimKinesisStreamPosition } from "./sim-kinesis-stream-position.js";
+import type { SimKinesisShard } from "./sim-kinesis-shard.js";
+/**
+ * What one read of a shard came back with.
+ */
+export interface SimKinesisShardRead {
+    readonly records: readonly SimKinesisRecord[];
+    readonly next: SimKinesisStreamPosition;
+}
+/**
+ * Read up to a limit of records from a shard, starting at a position.
+ *
+ * An empty result is an ordinary answer rather than a problem. A reader that
+ * has caught up gets nothing back and the position it already had, which is
+ * what makes polling each successive iterator work.
+ *
+ * A position the retention window has outlived is not refused, unlike DynamoDB
+ * Streams. Real Kinesis moves a reader on to the trim horizon and carries on,
+ * and it reports how far behind the reader is instead.
+ */
+export declare function simKinesisShardRead(shard: SimKinesisShard, position: SimKinesisStreamPosition, limit: number): SimKinesisShardRead;
+//# sourceMappingURL=sim-kinesis-stream-read.d.ts.map

package/dist/service/kinesis/stream/sim-kinesis-stream-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-kinesis-stream-read.d.ts","sourceRoot":"","sources":["../../../../src/service/kinesis/stream/sim-kinesis-stream-read.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,kCAAkC,CAAC;AAE1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;CACzC;AAiCD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,wBAAwB,EAClC,KAAK,EAAE,MAAM,GACZ,mBAAmB,CAarB"}