@loomwork/event-runtime 0.0.0-stage → 0.1.0

package/dist/ShardedEventStore.d.ts

@@ -0,0 +1,149 @@
+import type { EventEnvelope } from "@loomwork/core";
+import type { ShardPlan } from "./ShardPlan";
+import { type EventStore, type SealingCapability } from "./types";
+export interface ShardedEventStoreOptions {
+    /**
+     * Which shard owns an execution, when no {@link ShardedEventStoreOptions.plan} is given.
+     * Must be STABLE across processes and restarts — two nodes disagreeing routes the same
+     * execution to two logs. Default: FNV-1a over the id.
+     */
+    shardOf?: (executionId: string, shards: number) => number;
+    /**
+     * An explicit bucket→shard map (ADR 0075). **Required to rebalance**: without it, routing
+     * is `hash(id) % shardCount` and changing the shard count silently re-routes almost every
+     * execution to a shard that has never seen its data.
+     *
+     * Omitting it keeps the pre-0075 routing exactly, so existing deployments are unaffected
+     * — but they cannot change shard count without moving everything. Start with a plan if
+     * you expect to grow.
+     */
+    plan?: ShardPlan;
+    /**
+     * How many execution→shard resolutions to remember while buckets are migrating. Bounded
+     * so a long-lived store cannot grow without limit. Default 10,000.
+     */
+    placementCacheSize?: number;
+}
+/** Result of moving one execution between shards. */
+export interface MigrationResult {
+    executionId: string;
+    /** `moved` — copied then removed from the source. `already-there` — nothing to do. */
+    outcome: "moved" | "already-there" | "not-migrating";
+    events: number;
+}
+/**
+ * ADR 0129 — an incarnation counter is per shard, so the same number can be issued by two shards
+ * (a migrating bucket re-creates an id on another shard). The anchor this store hands out is
+ * therefore `s<shardIndex>/<inner anchor>`: it starts with a letter, so it can collide neither
+ * with a bare incarnation (digits) nor with the legacy `<timestamp>:<id>` marker (digits first),
+ * and an observation taken on one shard never equals the anchor of another.
+ */
+/**
+ * ADR 0130 residuals D7/D8: the shards of one store disagree about sealing (some seal and some do
+ * not, or they seal different paths or with different ciphers). Misconfiguration, raised live on
+ * every `sealingCapability()` call and never papered over, because one answer serves two questions
+ * that must not diverge: "what can this node open" (D7) and "does this store seal at all" (D8, a
+ * non-empty `covers`). Carries each shard's cipher and covers, never key material.
+ */
+export declare class ShardSealingMismatchError extends Error {
+    readonly code = "SHARD_SEALING_MISMATCH";
+    readonly shards: readonly {
+        readonly index: number;
+        readonly cipher: string | undefined;
+        readonly covers: readonly string[] | undefined;
+    }[];
+    constructor(caps: readonly (SealingCapability | undefined)[]);
+}
+export declare class ShardedEventStore implements EventStore {
+    readonly head?: NonNullable<EventStore["head"]>;
+    readonly readRange?: NonNullable<EventStore["readRange"]>;
+    readonly acquireFence?: NonNullable<EventStore["acquireFence"]>;
+    readonly acquireFenceIf?: NonNullable<EventStore["acquireFenceIf"]>;
+    readonly appendIfUnchanged?: NonNullable<EventStore["appendIfUnchanged"]>;
+    readonly storeNow?: NonNullable<EventStore["storeNow"]>;
+    readonly sealingCapability?: NonNullable<EventStore["sealingCapability"]>;
+    readonly readAtRest?: NonNullable<EventStore["readAtRest"]>;
+    readonly deleteExecution?: NonNullable<EventStore["deleteExecution"]>;
+    readonly deleteThrough?: NonNullable<EventStore["deleteThrough"]>;
+    readonly truncatePrefix?: NonNullable<EventStore["truncatePrefix"]>;
+    readonly truncatePrefixKeeping?: NonNullable<EventStore["truncatePrefixKeeping"]>;
+    readonly listExecutions?: NonNullable<EventStore["listExecutions"]>;
+    readonly listExecutionsPage?: NonNullable<EventStore["listExecutionsPage"]>;
+    private readonly shards;
+    private readonly shardOf;
+    private plan;
+    private readonly cacheLimit;
+    /** executionId → shard, only for executions in migrating buckets. Insertion-ordered LRU. */
+    private readonly placementCache;
+    constructor(shards: readonly EventStore[], options?: ShardedEventStoreOptions);
+    /**
+     * Install a new routing plan — how a rebalance is applied, and how a drained bucket is
+     * settled. **Every node sharing the log must converge on the same plan**; different plans
+     * on different nodes split the log.
+     */
+    setPlan(plan: ShardPlan): void;
+    /** The active plan, if routing is plan-driven. */
+    get shardPlan(): ShardPlan | undefined;
+    /** Resolve the store owning `executionId` right now. */
+    private route;
+    private routeIndex;
+    private remember;
+    /**
+     * Move one execution from a migrating bucket's source to its destination: copy every
+     * event, then delete the source copy.
+     *
+     * **The caller must ensure the execution is not being written concurrently** — an append
+     * arriving mid-move lands on the source and is then deleted. Terminal executions are the
+     * safe case, and the lazy drain described on the class means you usually do not need this
+     * at all; reach for it when a source shard must be decommissioned.
+     *
+     * Fence state does not move (the SPI has no way to read it), so the execution arrives
+     * unfenced on the destination.
+     */
+    migrateExecution(executionId: string): Promise<MigrationResult>;
+    /**
+     * Whether a migrating bucket's source side still holds anything — i.e. whether
+     * `plan.settled(bucket)` is safe yet. `true` for a settled bucket (nothing to drain).
+     *
+     * Requires enumerable shards.
+     */
+    isBucketDrained(bucket: number): Promise<boolean>;
+    append(envelope: EventEnvelope): Promise<void>;
+    /**
+     * Split a batch by shard and append each part. Shards are independent logs, so the parts
+     * run concurrently.
+     *
+     * Atomicity is per shard, which is exactly what the SPI requires: the contract is atomic
+     * PER EXECUTION, and an execution never spans shards. Whole-batch atomicity across
+     * shards would need a distributed transaction, costs far more than batching saves, and
+     * nothing needs it — a batch only groups INDEPENDENT executions, so nothing in it
+     * depends on anything else in it. `Promise.all` rejects if any shard does, so a caller
+     * still never reads a partial write as success.
+     */
+    appendBatch(envelopes: readonly EventEnvelope[]): Promise<void>;
+    read(executionId: string): Promise<EventEnvelope[]>;
+    readFrom(executionId: string, fromSequence: number): Promise<EventEnvelope[]>;
+    subscribe(executionId: string, handler: (event: EventEnvelope) => void): Promise<() => void>;
+    /**
+     * Fork. Fast when parent and child resolve to the same shard; otherwise the prefix has to
+     * cross a store boundary, so we use the SPI's documented per-event fallback.
+     */
+    copyPrefix(fromExecutionId: string, toExecutionId: string, throughSequence: number, metadata: Record<string, unknown>): Promise<void>;
+    /**
+     * Keyset pagination across shards. Each shard is asked for its next page beyond the
+     * cursor; the results are merged and truncated to `limit`, so the caller sees one
+     * globally ordered stream and the cursor stays a single id.
+     *
+     * Correct ONLY because every shard pages in the SPI's one order (code point, SPI 2.0.0)
+     * and accepts any id as a cursor: the merged page's last id is handed back to EVERY shard,
+     * including shards that never returned it. A shard paging in another order (a Postgres
+     * database collation, before L10) skips the ids that sort after the cursor in one order
+     * and before it in the other — silently, since every page still looks well-formed.
+     *
+     * Deduplicated for the same reason as `listExecutions`: mid-migration an execution can
+     * briefly exist on two shards.
+     */
+    private pagedScatterGather;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=ShardedEventStore.d.ts.map

package/dist/ShardedEventStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShardedEventStore.d.ts","sourceRoot":"","sources":["../src/ShardedEventStore.ts"],"names":[],"mappings":"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"}

package/dist/ShardedEventStore.js

@@ -0,0 +1,468 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardedEventStore = exports.ShardSealingMismatchError = void 0;
+const SubscriberRegistry_1 = require("./SubscriberRegistry");
+const executionIdOrder_1 = require("./executionIdOrder");
+const installOptional_1 = require("./installOptional");
+const types_1 = require("./types");
+/**
+ * Routes each execution to one of N inner stores (ADR 0074 D3), with support for moving
+ * buckets between shards without downtime (ADR 0075).
+ *
+ * This is the item that needs **zero backend cooperation**: it takes `EventStore[]` and
+ * never asks what it is wrapping, so a bring-your-own backend gets the horizontal-scale
+ * story free, and the shards may be heterogeneous.
+ *
+ * ## Routing
+ *
+ * With a {@link ShardPlan}, executions hash to a virtual bucket and buckets map to shards
+ * by an explicit table. Without one, routing is `hash(id) % shardCount` — identical to
+ * pre-0075 behaviour, and **not rebalanceable**.
+ *
+ * ## Rebalancing
+ *
+ * `plan.rebalanced(n)` marks every bucket whose owner changes as `migrating(from → to)`.
+ * That is a routing change only; **no data moves**. For a migrating bucket the store
+ * resolves per execution which side actually holds it (one bounded point-read, then
+ * cached), so:
+ *
+ * - executions already on the source keep being read and written there — nothing breaks;
+ * - executions that do not exist yet start on the destination.
+ *
+ * A bucket therefore **drains on its own** as executions complete and retention reclaims
+ * them: no copying, no downtime, no coordinator. When you want convergence sooner, or a
+ * source shard must be decommissioned, {@link migrateExecution} moves one explicitly. Once
+ * {@link isBucketDrained} reports true, `plan.settled(bucket)` retires the extra lookup.
+ *
+ * ## What this does NOT do
+ *
+ * - **It does not move a live execution safely.** `migrateExecution` copies then deletes;
+ *   an append arriving mid-move lands on the source and is dropped by the delete. Move
+ *   terminal executions, or ones you know are not dispatched. The lazy drain above exists
+ *   precisely so you rarely need to.
+ * - **Fence state does not travel.** The SPI exposes `acquireFence` but no way to read or
+ *   write a fence, so a migrated execution arrives unfenced on its destination and a zombie
+ *   writer holding an old token could write there. Fence-sensitive deployments should
+ *   migrate only executions that are terminal *and* undispatched.
+ *
+ * Invariants relied on throughout: an execution lives entirely on one shard at any moment,
+ * and a stream that exists has a head — which is what makes "which side holds it?" a single
+ * indexed point-read (the HEAD, not sequence 0: an inbox topic stream or a floor-seeded stream has
+ * no sequence 0).
+ */
+/**
+ * The optional-capability surface EVERY shard shares: an object carrying each optional
+ * `EventStore` method that all shards implement (bound to the first shard, so it is a real
+ * method, never a stub) and nothing else. Used as the `inner` of `installOptional`, whose
+ * rule is "install a method iff the inner store has it" — for a sharded store, "has it" means
+ * every shard has it. O(shards × optional methods), once, at construction.
+ */
+function commonOptional(shards) {
+    const surface = {};
+    const first = shards[0];
+    for (const method of types_1.OPTIONAL_EVENT_STORE_METHODS) {
+        if (shards.every((s) => typeof s[method] === "function")) {
+            surface[method] = first[method].bind(first);
+        }
+    }
+    // ADR 0130 D7/D8 exception: `sealingCapability` is offered when ANY shard has it, because a shard
+    // lacking the method seals nothing and must be judged (commonSealing), not silently hide a sealing
+    // shard by making the whole store look like it does not seal.
+    if (shards.some((s) => typeof s.sealingCapability === "function")) {
+        surface.sealingCapability = () => undefined;
+    }
+    return surface;
+}
+/**
+ * ADR 0129 — an incarnation counter is per shard, so the same number can be issued by two shards
+ * (a migrating bucket re-creates an id on another shard). The anchor this store hands out is
+ * therefore `s<shardIndex>/<inner anchor>`: it starts with a letter, so it can collide neither
+ * with a bare incarnation (digits) nor with the legacy `<timestamp>:<id>` marker (digits first),
+ * and an observation taken on one shard never equals the anchor of another.
+ */
+/**
+ * ADR 0130 residuals D7/D8: the shards of one store disagree about sealing (some seal and some do
+ * not, or they seal different paths or with different ciphers). Misconfiguration, raised live on
+ * every `sealingCapability()` call and never papered over, because one answer serves two questions
+ * that must not diverge: "what can this node open" (D7) and "does this store seal at all" (D8, a
+ * non-empty `covers`). Carries each shard's cipher and covers, never key material.
+ */
+class ShardSealingMismatchError extends Error {
+    code = "SHARD_SEALING_MISMATCH";
+    shards;
+    constructor(caps) {
+        const shards = caps.map((c, index) => ({
+            index,
+            cipher: c?.cipher,
+            covers: c === undefined ? undefined : [...c.covers],
+        }));
+        super(`shards disagree about sealing (${shards
+            .map((x) => `#${x.index}: ${x.cipher === undefined ? "none" : `${x.cipher} [${x.covers?.join(", ")}]`}`)
+            .join("; ")}); every shard must seal the same paths with the same cipher, or none may seal`);
+        this.name = "ShardSealingMismatchError";
+        this.shards = shards;
+    }
+}
+exports.ShardSealingMismatchError = ShardSealingMismatchError;
+/**
+ * The sealing capability of a fleet of shards, FAIL CLOSED: no shard seals -> undefined; every shard
+ * reports the same cipher and the same covers -> that capability (`opens` needs every shard to
+ * agree); anything else throws {@link ShardSealingMismatchError}.
+ */
+function commonSealing(caps) {
+    const first = caps[0];
+    if (caps.every((c) => c === undefined))
+        return undefined;
+    if (first === undefined)
+        throw new ShardSealingMismatchError(caps);
+    const covers = new Set(first.covers);
+    const all = [];
+    for (const c of caps) {
+        if (c === undefined || c.cipher !== first.cipher || !sameSet(covers, c.covers)) {
+            throw new ShardSealingMismatchError(caps);
+        }
+        all.push(c);
+    }
+    return {
+        cipher: first.cipher,
+        covers: first.covers,
+        opens: (marker) => all.every((c) => c.opens(marker)),
+    };
+}
+/** `covers` is a set of paths: order and duplicates carry no meaning, so compare as sets. */
+function sameSet(a, b) {
+    const bs = new Set(b);
+    return bs.size === a.size && [...bs].every((e) => a.has(e));
+}
+const shardAnchor = (shard, inner) => `s${shard}/${inner}`;
+/** The inner anchor if `anchor` was issued by `shard`; otherwise the string unchanged, which no
+ * inner store can have issued (it starts with `s`), so the shard answers `moved`. */
+const unshardAnchor = (anchor, shard) => {
+    const prefix = `s${shard}/`;
+    return anchor.startsWith(prefix) ? anchor.slice(prefix.length) : anchor;
+};
+class ShardedEventStore {
+    head;
+    readRange;
+    acquireFence;
+    acquireFenceIf;
+    appendIfUnchanged;
+    storeNow;
+    sealingCapability;
+    readAtRest;
+    deleteExecution;
+    deleteThrough;
+    truncatePrefix;
+    truncatePrefixKeeping;
+    listExecutions;
+    listExecutionsPage;
+    shards;
+    shardOf;
+    plan;
+    cacheLimit;
+    /** executionId → shard, only for executions in migrating buckets. Insertion-ordered LRU. */
+    placementCache = new Map();
+    constructor(shards, options = {}) {
+        if (shards.length === 0)
+            throw new Error("ShardedEventStore requires at least one shard");
+        this.shards = shards;
+        this.shardOf = options.shardOf ?? SubscriberRegistry_1.bucketOf;
+        this.cacheLimit = Math.max(1, options.placementCacheSize ?? 10_000);
+        if (options.plan !== undefined)
+            this.setPlan(options.plan);
+        const plan = {
+            head: async (id) => (await this.route(id)).head(id),
+            readRange: async (id, from, to) => (await this.route(id)).readRange(id, from, to),
+            acquireFence: async (id) => (await this.route(id)).acquireFence(id),
+            acquireFenceIf: async (id, expect) => (await this.route(id)).acquireFenceIf(id, expect),
+            appendIfUnchanged: async (id, event, expect) => {
+                const i = await this.routeIndex(id);
+                const shard = this.shards[i];
+                const result = await shard.appendIfUnchanged(id, event, expect === undefined ? undefined : { ...expect, anchor: unshardAnchor(expect.anchor, i) });
+                return "anchor" in result && typeof result.anchor === "string"
+                    ? { ...result, anchor: shardAnchor(i, result.anchor) }
+                    : result;
+            },
+            // One clock for the fleet: every shard has it (commonOptional), read from the first shard.
+            storeNow: "forward",
+            // ADR 0130 residuals D7/D8: a stream may sit on any shard, so shards must agree. Installed when
+            // ANY shard has the method (commonOptional); a shard lacking it counts as sealing nothing
+            // (undefined). Fails closed (ShardSealingMismatchError) on any disagreement, so "can open" and
+            // "does seal" cannot diverge. When no shard has it the method is omitted.
+            sealingCapability: () => commonSealing(this.shards.map((s) => s.sealingCapability?.())),
+            // ADR 0130 D9: the at-rest view routes each call to the stream's shard, like `read` (installed
+            // only when EVERY shard offers it, via commonOptional).
+            readAtRest: () => {
+                const readers = this.shards.map((s) => s.readAtRest());
+                const hasRange = readers.every((r) => r.readRange !== undefined);
+                const hasHead = readers.every((r) => r.head !== undefined);
+                const via = (id, f) => this.routeIndex(id).then((i) => f(readers[i]));
+                return {
+                    read: (id) => via(id, (r) => r.read(id)),
+                    readFrom: (id, from) => via(id, (r) => r.readFrom(id, from)),
+                    ...(hasRange && {
+                        readRange: (id, a, b) => via(id, (r) => r.readRange(id, a, b)),
+                    }),
+                    ...(hasHead && { head: (id) => via(id, (r) => r.head(id)) }),
+                };
+            },
+            deleteExecution: async (id) => {
+                await (await this.route(id)).deleteExecution(id);
+                this.placementCache.delete(id);
+            },
+            // Bounded by `through`, so a stream a caller drains stays placed while anything above it remains.
+            deleteThrough: async (id, through) => {
+                const shard = await this.route(id);
+                await shard.deleteThrough(id, through);
+                if ((await (0, types_1.headOf)(shard, id)) === null)
+                    this.placementCache.delete(id);
+            },
+            truncatePrefix: async (id, through) => (await this.route(id)).truncatePrefix(id, through),
+            truncatePrefixKeeping: async (id, through, keep) => (await this.route(id)).truncatePrefixKeeping(id, through, keep),
+            listExecutions: async () => {
+                const perShard = await Promise.all(this.shards.map((s) => s.listExecutions()));
+                // Dedupe: a crash between migrateExecution's copy and delete can leave an execution
+                // on both sides, and enumeration must still report it once.
+                return [...new Set(perShard.flat())];
+            },
+            // Paged enumeration needs EVERY shard to be pageable; falling back to listExecutions
+            // on some would defeat the bounded-memory guarantee the page API exists to provide.
+            listExecutionsPage: (opts) => this.pagedScatterGather(opts),
+        };
+        // `installOptional` installs a method iff its `inner` has it; here "inner" is the
+        // capability surface every shard shares.
+        (0, installOptional_1.installOptional)(this, commonOptional(shards), plan);
+        // The structural encryption marker (`keys`, see `installOptional`) must survive sharding,
+        // or `Sharded(Encrypting(pg)…)` — the ADR 0074 composition — would look like a plain store
+        // to LogLifecycle's compaction/archive guard and to `loom doctor`. Carried up when every
+        // shard shares ONE KeyStore; shards that disagree (or only some encrypting) get a marker
+        // no snapshot store can match, so the guard fails closed rather than guessing.
+        const markers = shards.map((s) => s.keys);
+        if (markers.some((k) => typeof k === "object" && k !== null)) {
+            const first = markers[0];
+            this.keys = markers.every((k) => k === first)
+                ? first
+                : Object.freeze({ mixed: true });
+        }
+        // ADR 0138 H3: the tenant marker survives sharding when every shard is scoped to ONE tenant.
+        // Shards that disagree (or only some scoped) get a scope no archive can match, so the guard
+        // refuses rather than guessing.
+        const scopes = shards.map((s) => s.tenantScope);
+        if (scopes.some((t) => typeof t === "string")) {
+            const first = scopes[0];
+            this.tenantScope =
+                typeof first === "string" && scopes.every((t) => t === first)
+                    ? first
+                    : "\u0000mixed-tenant-shards";
+        }
+    }
+    /**
+     * Install a new routing plan — how a rebalance is applied, and how a drained bucket is
+     * settled. **Every node sharing the log must converge on the same plan**; different plans
+     * on different nodes split the log.
+     */
+    setPlan(plan) {
+        if (plan.shardCount !== this.shards.length) {
+            throw new Error(`plan expects ${plan.shardCount} shards but the store has ${this.shards.length}`);
+        }
+        this.plan = plan;
+        // Cached placements were resolved against the previous plan; a bucket that settled or
+        // started migrating invalidates them.
+        this.placementCache.clear();
+    }
+    /** The active plan, if routing is plan-driven. */
+    get shardPlan() {
+        return this.plan;
+    }
+    /** Resolve the store owning `executionId` right now. */
+    async route(executionId) {
+        return this.shards[await this.routeIndex(executionId)];
+    }
+    async routeIndex(executionId) {
+        if (this.plan === undefined) {
+            return this.shardOf(executionId, this.shards.length);
+        }
+        const placement = this.plan.placementFor(executionId);
+        if (placement.kind === "settled")
+            return placement.shard;
+        const cached = this.placementCache.get(executionId);
+        if (cached !== undefined) {
+            // Refresh recency (Map preserves insertion order, so re-insert moves it to the end).
+            this.placementCache.delete(executionId);
+            this.placementCache.set(executionId, cached);
+            return cached;
+        }
+        // Which side actually holds it? Sequence 0 is the bootstrap anchor: present for as long
+        // as the execution exists (truncatePrefix preserves it, deleteExecution removes it), so
+        // one indexed point-read answers the question. The destination is checked FIRST, so a
+        // migrated execution stops consulting the source immediately — and so a crash between
+        // copy and delete resolves to the destination, which is the surviving copy.
+        // The probe is the stream HEAD (one indexed MAX(sequence)), not sequence 0: a stream that never
+        // had a sequence 0 (an inbox topic stream starts at 2^40; a legacy inbox stream seeded at a fork
+        // floor starts above 0) is on a shard all the same, and a probe of 0 would route it to the
+        // destination while its data (and the owner's cursor) sit on the source.
+        const onTo = await (0, types_1.headOf)(this.shards[placement.to], executionId);
+        if (onTo !== null)
+            return this.remember(executionId, placement.to);
+        const onFrom = await (0, types_1.headOf)(this.shards[placement.from], executionId);
+        if (onFrom !== null)
+            return this.remember(executionId, placement.from);
+        // Unknown to both ⇒ it does not exist yet, so it belongs to the destination. Caching
+        // that is what makes a new execution's subsequent appends single-lookup.
+        return this.remember(executionId, placement.to);
+    }
+    remember(executionId, shard) {
+        this.placementCache.set(executionId, shard);
+        if (this.placementCache.size > this.cacheLimit) {
+            const oldest = this.placementCache.keys().next();
+            if (!oldest.done)
+                this.placementCache.delete(oldest.value);
+        }
+        return shard;
+    }
+    /**
+     * Move one execution from a migrating bucket's source to its destination: copy every
+     * event, then delete the source copy.
+     *
+     * **The caller must ensure the execution is not being written concurrently** — an append
+     * arriving mid-move lands on the source and is then deleted. Terminal executions are the
+     * safe case, and the lazy drain described on the class means you usually do not need this
+     * at all; reach for it when a source shard must be decommissioned.
+     *
+     * Fence state does not move (the SPI has no way to read it), so the execution arrives
+     * unfenced on the destination.
+     */
+    async migrateExecution(executionId) {
+        if (this.plan === undefined)
+            return { executionId, outcome: "not-migrating", events: 0 };
+        const placement = this.plan.placementFor(executionId);
+        if (placement.kind === "settled")
+            return { executionId, outcome: "not-migrating", events: 0 };
+        const current = await this.routeIndex(executionId);
+        if (current === placement.to)
+            return { executionId, outcome: "already-there", events: 0 };
+        const source = this.shards[placement.from];
+        const target = this.shards[placement.to];
+        const events = await source.read(executionId);
+        if (events.length > 0)
+            await (0, types_1.appendBatchOf)(target, events);
+        // Copy BEFORE delete. A crash in between leaves the execution on both sides, which
+        // `routeIndex` resolves to the destination (checked first) and a re-run cleans up. The
+        // reverse order would lose the log outright.
+        await source.deleteExecution?.(executionId);
+        this.placementCache.delete(executionId);
+        this.remember(executionId, placement.to);
+        return { executionId, outcome: "moved", events: events.length };
+    }
+    /**
+     * Whether a migrating bucket's source side still holds anything — i.e. whether
+     * `plan.settled(bucket)` is safe yet. `true` for a settled bucket (nothing to drain).
+     *
+     * Requires enumerable shards.
+     */
+    async isBucketDrained(bucket) {
+        const plan = this.plan;
+        if (plan === undefined)
+            return true;
+        const placement = plan.placementAt(bucket);
+        if (placement.kind === "settled")
+            return true;
+        const source = this.shards[placement.from];
+        if (source.listExecutions === undefined) {
+            throw new Error("isBucketDrained needs shards that support listExecutions()");
+        }
+        const ids = await source.listExecutions();
+        return !ids.some((id) => plan.bucketFor(id) === bucket);
+    }
+    async append(envelope) {
+        return (await this.route(envelope.executionId)).append(envelope);
+    }
+    /**
+     * Split a batch by shard and append each part. Shards are independent logs, so the parts
+     * run concurrently.
+     *
+     * Atomicity is per shard, which is exactly what the SPI requires: the contract is atomic
+     * PER EXECUTION, and an execution never spans shards. Whole-batch atomicity across
+     * shards would need a distributed transaction, costs far more than batching saves, and
+     * nothing needs it — a batch only groups INDEPENDENT executions, so nothing in it
+     * depends on anything else in it. `Promise.all` rejects if any shard does, so a caller
+     * still never reads a partial write as success.
+     */
+    async appendBatch(envelopes) {
+        if (envelopes.length === 0)
+            return;
+        const slots = await Promise.all(envelopes.map((e) => this.routeIndex(e.executionId)));
+        const bySlot = new Map();
+        for (const [i, envelope] of envelopes.entries()) {
+            const slot = slots[i];
+            const list = bySlot.get(slot);
+            if (list === undefined)
+                bySlot.set(slot, [envelope]);
+            else
+                list.push(envelope);
+        }
+        await Promise.all([...bySlot].map(([slot, part]) => (0, types_1.appendBatchOf)(this.shards[slot], part)));
+    }
+    async read(executionId) {
+        return (await this.route(executionId)).read(executionId);
+    }
+    async readFrom(executionId, fromSequence) {
+        return (await this.route(executionId)).readFrom(executionId, fromSequence);
+    }
+    async subscribe(executionId, handler) {
+        return (await this.route(executionId)).subscribe(executionId, handler);
+    }
+    /**
+     * Fork. Fast when parent and child resolve to the same shard; otherwise the prefix has to
+     * cross a store boundary, so we use the SPI's documented per-event fallback.
+     */
+    async copyPrefix(fromExecutionId, toExecutionId, throughSequence, metadata) {
+        const source = await this.route(fromExecutionId);
+        const target = await this.route(toExecutionId);
+        if (source === target && source.copyPrefix !== undefined) {
+            return source.copyPrefix(fromExecutionId, toExecutionId, throughSequence, metadata);
+        }
+        const events = await source.read(fromExecutionId);
+        const copied = events
+            .filter((e) => e.sequence <= throughSequence)
+            .map((e) => ({
+            ...e,
+            id: `${toExecutionId}-${e.sequence}`,
+            executionId: toExecutionId,
+            metadata: { ...e.metadata, ...metadata },
+        }));
+        await (0, types_1.appendBatchOf)(target, copied);
+    }
+    /**
+     * Keyset pagination across shards. Each shard is asked for its next page beyond the
+     * cursor; the results are merged and truncated to `limit`, so the caller sees one
+     * globally ordered stream and the cursor stays a single id.
+     *
+     * Correct ONLY because every shard pages in the SPI's one order (code point, SPI 2.0.0)
+     * and accepts any id as a cursor: the merged page's last id is handed back to EVERY shard,
+     * including shards that never returned it. A shard paging in another order (a Postgres
+     * database collation, before L10) skips the ids that sort after the cursor in one order
+     * and before it in the other — silently, since every page still looks well-formed.
+     *
+     * Deduplicated for the same reason as `listExecutions`: mid-migration an execution can
+     * briefly exist on two shards.
+     */
+    async pagedScatterGather(opts) {
+        const limit = opts?.limit ?? 1000;
+        const pages = await Promise.all(this.shards.map((s) => s.listExecutionsPage({ ...(opts?.cursor !== undefined && { cursor: opts.cursor }), limit })));
+        const union = new Set(pages.flatMap((p) => p.executionIds));
+        const merged = [...union].sort(executionIdOrder_1.compareExecutionIds).slice(0, limit);
+        const last = merged[merged.length - 1];
+        // More remains if any shard reported a further page, or if the merge itself truncated.
+        const truncated = pages.some((p) => p.nextCursor !== undefined) || union.size > merged.length;
+        return {
+            executionIds: merged,
+            ...(truncated && last !== undefined && { nextCursor: last }),
+        };
+    }
+    async close() {
+        await Promise.all(this.shards.map((s) => s.close()));
+    }
+}
+exports.ShardedEventStore = ShardedEventStore;
+//# sourceMappingURL=ShardedEventStore.js.map

package/dist/ShardedEventStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShardedEventStore.js","sourceRoot":"","sources":["../src/ShardedEventStore.ts"],"names":[],"mappings":";;;AAEA,6DAAgD;AAChD,yDAAyD;AACzD,uDAAwE;AACxE,mCASiB;AAkCjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH;;;;;;GAMG;AACH,SAAS,cAAc,CAAC,MAA6B;IACnD,MAAM,OAAO,GAAuD,EAAE,CAAC;IACvE,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAe,CAAC;IACtC,KAAK,MAAM,MAAM,IAAI,oCAA4B,EAAE,CAAC;QAClD,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,UAAU,CAAC,EAAE,CAAC;YACzD,OAAO,CAAC,MAAM,CAAC,GAAI,KAAK,CAAC,MAAM,CAAkC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChF,CAAC;IACH,CAAC;IACD,kGAAkG;IAClG,mGAAmG;IACnG,8DAA8D;IAC9D,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,iBAAiB,KAAK,UAAU,CAAC,EAAE,CAAC;QAClE,OAAO,CAAC,iBAAiB,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC;IAC9C,CAAC;IACD,OAAO,OAAgC,CAAC;AAC1C,CAAC;AAED;;;;;;GAMG;AACH;;;;;;GAMG;AACH,MAAa,yBAA0B,SAAQ,KAAK;IACzC,IAAI,GAAG,wBAAwB,CAAC;IAChC,MAAM,CAIX;IACJ,YAAY,IAAgD;QAC1D,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;YACrC,KAAK;YACL,MAAM,EAAE,CAAC,EAAE,MAAM;YACjB,MAAM,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;SACpD,CAAC,CAAC,CAAC;QACJ,KAAK,CACH,kCAAkC,MAAM;aACrC,GAAG,CACF,CAAC,CAAC,EAAE,EAAE,CACJ,IAAI,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAC9F;aACA,IAAI,CAAC,IAAI,CAAC,gFAAgF,CAC9F,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,2BAA2B,CAAC;QACxC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CACF;AAxBD,8DAwBC;AAED;;;;GAIG;AACH,SAAS,aAAa,CACpB,IAAgD;IAEhD,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACtB,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC;QAAE,OAAO,SAAS,CAAC;IACzD,IAAI,KAAK,KAAK,SAAS;QAAE,MAAM,IAAI,yBAAyB,CAAC,IAAI,CAAC,CAAC;IACnE,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC,MAAM,GAAG,GAAwB,EAAE,CAAC;IACpC,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/E,MAAM,IAAI,yBAAyB,CAAC,IAAI,CAAC,CAAC;QAC5C,CAAC;QACD,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACd,CAAC;IACD,OAAO;QACL,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,KAAK,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;KACrD,CAAC;AACJ,CAAC;AAED,6FAA6F;AAC7F,SAAS,OAAO,CAAC,CAAsB,EAAE,CAAoB;IAC3D,MAAM,EAAE,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;IACtB,OAAO,EAAE,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED,MAAM,WAAW,GAAG,CAAC,KAAa,EAAE,KAAa,EAAU,EAAE,CAAC,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;AACnF;qFACqF;AACrF,MAAM,aAAa,GAAG,CAAC,MAAc,EAAE,KAAa,EAAU,EAAE;IAC9D,MAAM,MAAM,GAAG,IAAI,KAAK,GAAG,CAAC;IAC5B,OAAO,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;AAC1E,CAAC,CAAC;AAEF,MAAa,iBAAiB;IACnB,IAAI,CAAmC;IACvC,SAAS,CAAwC;IACjD,YAAY,CAA2C;IACvD,cAAc,CAA6C;IAC3D,iBAAiB,CAAgD;IACjE,QAAQ,CAAuC;IAC/C,iBAAiB,CAAgD;IACjE,UAAU,CAAyC;IACnD,eAAe,CAA8C;IAC7D,aAAa,CAA4C;IACzD,cAAc,CAA6C;IAC3D,qBAAqB,CAAoD;IACzE,cAAc,CAA6C;IAC3D,kBAAkB,CAAiD;IAE3D,MAAM,CAAwB;IAC9B,OAAO,CAAkD;IAClE,IAAI,CAAwB;IACnB,UAAU,CAAS;IACpC,4FAA4F;IAC3E,cAAc,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE5D,YAAY,MAA6B,EAAE,UAAoC,EAAE;QAC/E,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QAC1F,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,6BAAQ,CAAC;QAC3C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,kBAAkB,IAAI,MAAM,CAAC,CAAC;QACpE,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;YAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAQ3D,MAAM,IAAI,GAAG;YACX,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,IAAK,CAAC,EAAE,CAAC;YACpD,SAAS,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,SAAU,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC;YAClF,YAAY,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,YAAa,CAAC,EAAE,CAAC;YACpE,cAAc,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,cAAe,CAAC,EAAE,EAAE,MAAM,CAAC;YACxF,iBAAiB,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;gBAC7C,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;gBACpC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAe,CAAC;gBAC3C,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,iBAAkB,CAC3C,EAAE,EACF,KAAK,EACL,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAC1F,CAAC;gBACF,OAAO,QAAQ,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,QAAQ;oBAC5D,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE;oBACtD,CAAC,CAAC,MAAM,CAAC;YACb,CAAC;YACD,2FAA2F;YAC3F,QAAQ,EAAE,SAAS;YACnB,gGAAgG;YAChG,0FAA0F;YAC1F,+FAA+F;YAC/F,0EAA0E;YAC1E,iBAAiB,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;YACvF,+FAA+F;YAC/F,wDAAwD;YACxD,UAAU,EAAE,GAAG,EAAE;gBACf,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAE,CAAgB,CAAC,UAAW,EAAE,CAAC,CAAC;gBACxE,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC;gBACjE,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;gBAC3D,MAAM,GAAG,GAAG,CAAI,EAAU,EAAE,CAAuC,EAAc,EAAE,CACjF,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAsB,CAAC,CAAC,CAAC;gBACtE,OAAO;oBACL,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;oBACxC,QAAQ,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;oBAC5D,GAAG,CAAC,QAAQ,IAAI;wBACd,SAAS,EAAE,CAAC,EAAU,EAAE,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAU,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;qBACxF,CAAC;oBACF,GAAG,CAAC,OAAO,IAAI,EAAE,IAAI,EAAE,CAAC,EAAU,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAK,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;iBACtE,CAAC;YACJ,CAAC;YACD,eAAe,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE;gBAC5B,MAAM,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,eAAgB,CAAC,EAAE,CAAC,CAAC;gBAClD,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACjC,CAAC;YACD,kGAAkG;YAClG,aAAa,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE;gBACnC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBACnC,MAAM,KAAK,CAAC,aAAc,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;gBACxC,IAAI,CAAC,MAAM,IAAA,cAAM,EAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI;oBAAE,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACzE,CAAC;YACD,cAAc,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,cAAe,CAAC,EAAE,EAAE,OAAO,CAAC;YAC1F,qBAAqB,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,CACjD,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,qBAAsB,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC;YAClE,cAAc,EAAE,KAAK,IAAI,EAAE;gBACzB,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,cAAe,EAAE,CAAC,CAAC,CAAC;gBAChF,oFAAoF;gBACpF,4DAA4D;gBAC5D,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;YACvC,CAAC;YACD,qFAAqF;YACrF,oFAAoF;YACpF,kBAAkB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC;SAChB,CAAC;QAC9C,kFAAkF;QAClF,yCAAyC;QACzC,IAAA,iCAAe,EAAqB,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC;QACxE,0FAA0F;QAC1F,2FAA2F;QAC3F,yFAAyF;QACzF,yFAAyF;QACzF,+EAA+E;QAC/E,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAE,CAAwB,CAAC,IAAI,CAAC,CAAC;QAClE,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC;YAC7D,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACxB,IAA2B,CAAC,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC;gBACnE,CAAC,CAAC,KAAK;gBACP,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACrC,CAAC;QACD,6FAA6F;QAC7F,4FAA4F;QAC5F,gCAAgC;QAChC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAE,CAA+B,CAAC,WAAW,CAAC,CAAC;QAC/E,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC;YAC9C,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACvB,IAAkC,CAAC,WAAW;gBAC7C,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC;oBAC3D,CAAC,CAAC,KAAK;oBACP,CAAC,CAAC,2BAA2B,CAAC;QACpC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,IAAe;QACrB,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YAC3C,MAAM,IAAI,KAAK,CACb,gBAAgB,IAAI,CAAC,UAAU,6BAA6B,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CACjF,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,sFAAsF;QACtF,sCAAsC;QACtC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IAED,kDAAkD;IAClD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,wDAAwD;IAChD,KAAK,CAAC,KAAK,CAAC,WAAmB;QACrC,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,CAAe,CAAC;IACvE,CAAC;IAEO,KAAK,CAAC,UAAU,CAAC,WAAmB;QAC1C,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QACtD,IAAI,SAAS,CAAC,IAAI,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC,KAAK,CAAC;QAEzD,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,qFAAqF;YACrF,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;YACxC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;YAC7C,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,wFAAwF;QACxF,wFAAwF;QACxF,sFAAsF;QACtF,sFAAsF;QACtF,4EAA4E;QAC5E,gGAAgG;QAChG,iGAAiG;QACjG,2FAA2F;QAC3F,yEAAyE;QACzE,MAAM,IAAI,GAAG,MAAM,IAAA,cAAM,EAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAe,EAAE,WAAW,CAAC,CAAC;QAChF,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;QACnE,MAAM,MAAM,GAAG,MAAM,IAAA,cAAM,EAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAe,EAAE,WAAW,CAAC,CAAC;QACpF,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QACvE,qFAAqF;QACrF,yEAAyE;QACzE,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;IAClD,CAAC;IAEO,QAAQ,CAAC,WAAmB,EAAE,KAAa;QACjD,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QAC5C,IAAI,IAAI,CAAC,cAAc,CAAC,IAAI,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;YACjD,IAAI,CAAC,MAAM,CAAC,IAAI;gBAAE,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC7D,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,gBAAgB,CAAC,WAAmB;QACxC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS;YAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QACzF,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QACtD,IAAI,SAAS,CAAC,IAAI,KAAK,SAAS;YAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QAE9F,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;QACnD,IAAI,OAAO,KAAK,SAAS,CAAC,EAAE;YAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QAE1F,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAe,CAAC;QACzD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAe,CAAC;QACvD,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC9C,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,IAAA,qBAAa,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC3D,mFAAmF;QACnF,uFAAuF;QACvF,6CAA6C;QAC7C,MAAM,MAAM,CAAC,eAAe,EAAE,CAAC,WAAW,CAAC,CAAC;QAC5C,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;QACzC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;IAClE,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,eAAe,CAAC,MAAc;QAClC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QACpC,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAC3C,IAAI,SAAS,CAAC,IAAI,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAe,CAAC;QACzD,IAAI,MAAM,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACxC,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,cAAc,EAAE,CAAC;QAC1C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC;IAC1D,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,QAAuB;QAClC,OAAO,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACnE,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,WAAW,CAAC,SAAmC;QACnD,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QACnC,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACtF,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2B,CAAC;QAClD,KAAK,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,SAAS,CAAC,OAAO,EAAE,EAAE,CAAC;YAChD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAW,CAAC;YAChC,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC9B,IAAI,IAAI,KAAK,SAAS;gBAAE,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;;gBAChD,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3B,CAAC;QACD,MAAM,OAAO,CAAC,GAAG,CACf,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,IAAA,qBAAa,EAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAe,EAAE,IAAI,CAAC,CAAC,CACxF,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,WAAmB;QAC5B,OAAO,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC3D,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,WAAmB,EAAE,YAAoB;QACtD,OAAO,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;IAC7E,CAAC;IAED,KAAK,CAAC,SAAS,CACb,WAAmB,EACnB,OAAuC;QAEvC,OAAO,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACzE,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU,CACd,eAAuB,EACvB,aAAqB,EACrB,eAAuB,EACvB,QAAiC;QAEjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;QACjD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QAC/C,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YACzD,OAAO,MAAM,CAAC,UAAU,CAAC,eAAe,EAAE,aAAa,EAAE,eAAe,EAAE,QAAQ,CAAC,CAAC;QACtF,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAClD,MAAM,MAAM,GAAG,MAAM;aAClB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,IAAI,eAAe,CAAC;aAC5C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACX,GAAG,CAAC;YACJ,EAAE,EAAE,GAAG,aAAa,IAAI,CAAC,CAAC,QAAQ,EAAE;YACpC,WAAW,EAAE,aAAa;YAC1B,QAAQ,EAAE,EAAE,GAAG,CAAC,CAAC,QAAQ,EAAE,GAAG,QAAQ,EAAE;SACzC,CAAC,CAAC,CAAC;QACN,MAAM,IAAA,qBAAa,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;IAED;;;;;;;;;;;;;OAaG;IACK,KAAK,CAAC,kBAAkB,CAAC,IAGhC;QACC,MAAM,KAAK,GAAG,IAAI,EAAE,KAAK,IAAI,IAAI,CAAC;QAClC,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,GAAG,CAC7B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACpB,CAAC,CAAC,kBAAmB,CAAC,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAC7F,CACF,CAAC;QACF,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;QAC5D,MAAM,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,sCAAmB,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QACpE,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACvC,uFAAuF;QACvF,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,SAAS,CAAC,IAAI,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC;QAC9F,OAAO;YACL,YAAY,EAAE,MAAM;YACpB,GAAG,CAAC,SAAS,IAAI,IAAI,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;SAC7D,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,KAAK;QACT,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACvD,CAAC;CACF;AAvWD,8CAuWC"}