@helyx/bot 0.4.33 → 0.4.36

package/dist/numeric-write-behind-redis.js

@@ -2,6 +2,7 @@ import {} from "@helyx/sdk";
 import {} from "@helyx/platform";
 import { randomUUID } from "node:crypto";
 import { createClient } from "redis";
+import { RenewableLease } from "./renewable-lease.js";
 const REDIS_FLUSH_INTERVAL_MS = 30_000;
 const REDIS_BATCH_SIZE = 100;
 const REDIS_CAPACITY = 10_000;
@@ -189,40 +190,13 @@ export class RedisNumericWriteBehindService {
         return this.#flush(input, "", "", true);
     }
     async runMemberBarrier(input, operation) {
-        const barrierId = await this.#acquireBarrier(input, "member", input.guildId, input.subjectId);
-        const stopRenewal = this.#startBarrierRenewal(input, "member", input.guildId, input.subjectId, barrierId);
-        try {
-            await this.flushMember(input);
-            return await operation();
-        }
-        finally {
-            stopRenewal();
-            await this.#releaseBarrier(input, "member", input.guildId, input.subjectId, barrierId);
-        }
+        return this.#runBarrier(input, "member", input.guildId, input.subjectId, () => this.flushMember(input), operation);
     }
     async runGuildBarrier(input, operation) {
-        const barrierId = await this.#acquireBarrier(input, "guild", input.guildId, "");
-        const stopRenewal = this.#startBarrierRenewal(input, "guild", input.guildId, "", barrierId);
-        try {
-            await this.flushGuild(input);
-            return await operation();
-        }
-        finally {
-            stopRenewal();
-            await this.#releaseBarrier(input, "guild", input.guildId, "", barrierId);
-        }
+        return this.#runBarrier(input, "guild", input.guildId, "", () => this.flushGuild(input), operation);
     }
     async runSubjectBarrier(input, operation) {
-        const barrierId = await this.#acquireBarrier(input, "subject", "", input.subjectId);
-        const stopRenewal = this.#startBarrierRenewal(input, "subject", "", input.subjectId, barrierId);
-        try {
-            await this.flushSubject(input);
-            return await operation();
-        }
-        finally {
-            stopRenewal();
-            await this.#releaseBarrier(input, "subject", "", input.subjectId, barrierId);
-        }
+        return this.#runBarrier(input, "subject", "", input.subjectId, () => this.flushSubject(input), operation);
     }
     async suppressSubject(input) {
         this.#assertAvailable(input);
@@ -420,16 +394,17 @@ export class RedisNumericWriteBehindService {
     async #drainRegistration(registration, guildId, subjectId, force) {
         while (true) {
             const proposedOperationId = randomUUID();
+            const proposedClaimToken = randomUUID();
             const raw = await this.#redis.eval(CLAIM_SCRIPT, {
                 keys: keysFor(this.#prefix, registration),
                 arguments: [
                     String(Date.now()),
                     String(REDIS_CLAIM_LEASE_MS),
                     proposedOperationId,
+                    proposedClaimToken,
                     String(REDIS_BATCH_SIZE),
                     guildId,
                     subjectId,
-                    force ? "1" : "0",
                     this.#supervisorId ?? "",
                     this.#shardLeaseKeyPrefix ?? "",
                     String(REDIS_RETRY_RETENTION_MS),
@@ -451,33 +426,45 @@ export class RedisNumericWriteBehindService {
                 ...this.#health,
                 inFlightEntries: claim.entries.length,
             };
+            const renewal = new RenewableLease({
+                intervalMs: Math.max(250, Math.floor(REDIS_CLAIM_LEASE_MS / 3)),
+                renew: () => this.#renewClaim(registration, claim),
+                onError: (error) => this.#onError?.(error),
+            });
+            renewal.start();
             try {
-                const output = await this.#writer.mutateNumericBatch({
-                    moduleId: registration.moduleId,
-                    collection: registration.collection,
-                    operationId: claim.operationId,
-                    uniqueBy: registration.uniqueBy,
-                    mutations: claim.entries.map(decodeMutation),
-                    select: registration.select,
-                });
-                if (output.results.length !== claim.entries.length)
-                    throw new Error("Redis numeric writer result count was invalid");
-                const committed = {
-                    moduleId: registration.moduleId,
-                    collection: registration.collection,
-                    operationId: claim.operationId,
-                    replayed: output.replayed,
-                    mutations: claim.entries.map(decodeMutation),
-                    results: output.results,
-                };
-                for (const subscriber of this.#subscribers.get(scopeKey(registration)) ?? [])
-                    await subscriber(committed);
-                const acknowledged = await this.#redis.eval(ACK_SCRIPT, {
-                    keys: keysFor(this.#prefix, registration),
-                    arguments: [claim.operationId],
+                await renewal.run(async (signal) => {
+                    const output = await this.#writer.mutateNumericBatch({
+                        moduleId: registration.moduleId,
+                        collection: registration.collection,
+                        operationId: claim.operationId,
+                        uniqueBy: registration.uniqueBy,
+                        mutations: claim.entries.map(decodeMutation),
+                        select: registration.select,
+                    });
+                    signal.throwIfAborted();
+                    if (output.results.length !== claim.entries.length)
+                        throw new Error("Redis numeric writer result count was invalid");
+                    const committed = {
+                        moduleId: registration.moduleId,
+                        collection: registration.collection,
+                        operationId: claim.operationId,
+                        replayed: output.replayed,
+                        mutations: claim.entries.map(decodeMutation),
+                        results: output.results,
+                    };
+                    for (const subscriber of this.#subscribers.get(scopeKey(registration)) ?? []) {
+                        signal.throwIfAborted();
+                        await subscriber(committed, signal);
+                    }
+                    signal.throwIfAborted();
+                    const acknowledged = await this.#redis.eval(ACK_SCRIPT, {
+                        keys: keysFor(this.#prefix, registration),
+                        arguments: [claim.operationId, claim.claimToken],
+                    });
+                    if (Number(acknowledged) !== 1)
+                        throw new Error("Redis numeric claim ownership changed");
                 });
-                if (Number(acknowledged) !== 1)
-                    throw new Error("Redis numeric claim ownership changed");
             }
             catch (error) {
                 const attempt = claim.attempt + 1;
@@ -485,7 +472,12 @@ export class RedisNumericWriteBehindService {
                     Math.min(REDIS_RETRY_MAX_MS, REDIS_RETRY_BASE_MS * 2 ** Math.min(claim.attempt, 16));
                 await this.#redis.eval(RETRY_SCRIPT, {
                     keys: keysFor(this.#prefix, registration),
-                    arguments: [claim.operationId, String(attempt), String(retryAt)],
+                    arguments: [
+                        claim.operationId,
+                        claim.claimToken,
+                        String(attempt),
+                        String(retryAt),
+                    ],
                 });
                 this.#health = {
                     ...this.#health,
@@ -498,6 +490,9 @@ export class RedisNumericWriteBehindService {
                     throw error;
                 return;
             }
+            finally {
+                await renewal.stop();
+            }
             this.#health = {
                 ...this.#health,
                 inFlightEntries: 0,
@@ -505,6 +500,20 @@ export class RedisNumericWriteBehindService {
             };
         }
     }
+    async #renewClaim(registration, claim) {
+        const now = Date.now();
+        const renewed = await this.#redis.eval(RENEW_CLAIM_SCRIPT, {
+            keys: keysFor(this.#prefix, registration),
+            arguments: [
+                claim.operationId,
+                claim.claimToken,
+                String(now),
+                String(now + REDIS_CLAIM_LEASE_MS),
+            ],
+        });
+        if (Number(renewed) !== 1)
+            throw new Error("Redis numeric claim lease expired");
+    }
     async #acquireBarrier(scope, kind, guildId, subjectId) {
         this.#assertAvailable(scope);
         const barrierId = randomUUID();
@@ -550,12 +559,47 @@ export class RedisNumericWriteBehindService {
         if (Number(result) !== 1)
             throw new Error("Numeric write-behind barrier lease expired");
     }
-    #startBarrierRenewal(scope, kind, guildId, subjectId, barrierId) {
-        const timer = setInterval(() => {
-            void this.#renewBarrier(scope, kind, guildId, subjectId, barrierId).catch((error) => this.#onError?.(toError(error)));
-        }, Math.max(250, Math.floor(this.#barrierLeaseMs / 3)));
-        timer.unref();
-        return () => clearInterval(timer);
+    async #runBarrier(scope, kind, guildId, subjectId, flush, operation) {
+        const barrierId = await this.#acquireBarrier(scope, kind, guildId, subjectId);
+        const renewal = new RenewableLease({
+            intervalMs: Math.max(250, Math.floor(this.#barrierLeaseMs / 3)),
+            renew: () => this.#renewBarrier(scope, kind, guildId, subjectId, barrierId),
+            onError: (error) => this.#onError?.(error),
+        });
+        renewal.start();
+        const failures = [];
+        let result;
+        let completed = false;
+        try {
+            result = await renewal.run(async (signal) => {
+                await flush();
+                signal.throwIfAborted();
+                return operation(signal);
+            });
+            completed = true;
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            await renewal.stop();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            await this.#releaseBarrier(scope, kind, guildId, subjectId, barrierId);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1)
+            throw new AggregateError(failures, "Numeric barrier cleanup failed");
+        if (!completed)
+            throw new Error("Numeric barrier operation did not complete");
+        return result;
     }
     async #waitForSuppression(scope, script, arguments_) {
         const deadline = Date.now() + this.#suppressionDrainTimeoutMs;
@@ -785,6 +829,9 @@ function parseClaim(raw) {
         !("operationId" in parsed) ||
         typeof parsed.operationId !== "string" ||
         !UUID.test(parsed.operationId) ||
+        !("claimToken" in parsed) ||
+        typeof parsed.claimToken !== "string" ||
+        !UUID.test(parsed.claimToken) ||
         !("entries" in parsed) ||
         !Array.isArray(parsed.entries) ||
         parsed.entries.length < 1 ||
@@ -940,10 +987,10 @@ ${BARRIER_HELPERS_LUA}
 local now = tonumber(ARGV[1])
 local lease_ms = tonumber(ARGV[2])
 local proposed_id = ARGV[3]
-local limit = tonumber(ARGV[4])
-local guild_filter = ARGV[5]
-local subject_filter = ARGV[6]
-local force = ARGV[7] == '1'
+local claim_token = ARGV[4]
+local limit = tonumber(ARGV[5])
+local guild_filter = ARGV[6]
+local subject_filter = ARGV[7]
 local owner = ARGV[8]
 local lease_prefix = ARGV[9]
 local retry_retention_ms = tonumber(ARGV[10])
@@ -958,7 +1005,7 @@ for index = 1, #staged, 2 do
     redis.call('HDEL', KEYS[3], member_key)
   end
 end
-local due = redis.call('ZRANGEBYSCORE', KEYS[5], '-inf', force and '+inf' or now, 'LIMIT', 0, 100)
+local due = redis.call('ZRANGEBYSCORE', KEYS[5], '-inf', now, 'LIMIT', 0, 100)
 for _, operation_id in ipairs(due) do
   local payload = redis.call('HGET', KEYS[4], operation_id)
   if payload then
@@ -1000,6 +1047,7 @@ for _, operation_id in ipairs(due) do
       end
       claim.leaseKey = lease_key
       claim.leaseValue = lease_value
+      claim.claimToken = claim_token
       local encoded = cjson.encode(claim)
       redis.call('HSET', KEYS[4], operation_id, encoded)
       redis.call('ZADD', KEYS[5], now + lease_ms, operation_id)
@@ -1049,6 +1097,7 @@ if #entries == 0 then
 end
 local claim = {
   operationId = proposed_id,
+  claimToken = claim_token,
   entries = entries,
   attempt = 0,
   expiresAt = now + retry_retention_ms,
@@ -1068,6 +1117,7 @@ const ACK_SCRIPT = `
 local payload = redis.call('HGET', KEYS[4], ARGV[1])
 if not payload then return 0 end
 local claim = cjson.decode(payload)
+if claim.claimToken ~= ARGV[2] then return 0 end
 if claim.leaseKey and claim.leaseKey ~= '' and
    redis.call('GET', claim.leaseKey) ~= claim.leaseValue then return 0 end
 for _, entry in ipairs(claim.entries) do
@@ -1082,13 +1132,25 @@ const RETRY_SCRIPT = `
 local payload = redis.call('HGET', KEYS[4], ARGV[1])
 if not payload then return 0 end
 local claim = cjson.decode(payload)
-claim.attempt = tonumber(ARGV[2])
+if claim.claimToken ~= ARGV[2] then return 0 end
+claim.attempt = tonumber(ARGV[3])
 redis.call('HSET', KEYS[4], ARGV[1], cjson.encode(claim))
-local retry_at = tonumber(ARGV[3])
+local retry_at = tonumber(ARGV[4])
 if claim.expiresAt and retry_at > tonumber(claim.expiresAt) then retry_at = tonumber(claim.expiresAt) end
 redis.call('ZADD', KEYS[5], retry_at, ARGV[1])
 return 1
 `;
+const RENEW_CLAIM_SCRIPT = `
+local payload = redis.call('HGET', KEYS[4], ARGV[1])
+if not payload then return 0 end
+local claim = cjson.decode(payload)
+if claim.claimToken ~= ARGV[2] then return 0 end
+if claim.leaseKey and claim.leaseKey ~= '' and
+   redis.call('GET', claim.leaseKey) ~= claim.leaseValue then return 0 end
+if tonumber(redis.call('ZSCORE', KEYS[5], ARGV[1]) or 0) <= tonumber(ARGV[3]) then return 0 end
+redis.call('ZADD', KEYS[5], ARGV[4], ARGV[1])
+return 1
+`;
 const HEALTH_SCRIPT = `
 local oldest = redis.call('ZRANGE', KEYS[2], 0, 0, 'WITHSCORES')
 return cjson.encode({

package/dist/oauth-module.js

@@ -1,4 +1,5 @@
 import { defineModule, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { INTERNAL_MODULE_MANIFEST_FIELDS } from "./internal-module-manifest.js";
 const MODULE_ID = "helyx.oauth";
 const MODAL_ID = "helyx.oauth.revoke";
 const SERVICE_FIELD_ID = "helyx.oauth.revoke.service";
@@ -15,7 +16,7 @@ const everyonePolicy = {
 export function createOAuthModule() {
     return defineModule({
         manifest: {
-            manifestVersion: "0.1",
+            ...INTERNAL_MODULE_MANIFEST_FIELDS,
             releaseStatus: "live",
             id: MODULE_ID,
             name: "Helyx OAuth",
@@ -43,6 +44,7 @@ export function createOAuthModule() {
                         {
                             name: "revoke",
                             description: "Revoke a service and delete the OAuth details Helyx stores for you.",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
                             execute: async (context) => {
                                 const oauth = context.services.get(HELYX_SERVICE_NAMES.oauth);

package/dist/permissions-module.js

@@ -1,6 +1,8 @@
 import { defineModule, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { isCustomerSelectableModule } from "@helyx/module-manifest";
 import { PermissionFlagsBits } from "discord.js";
 import { canMutatePermissionPolicy, permissionMutationDenialMessage, } from "@helyx/core";
+import { INTERNAL_MODULE_MANIFEST_FIELDS } from "./internal-module-manifest.js";
 const MODULE_SELECT_ID = "helyx.permissions.module";
 const TARGET_SELECT_ID = "helyx.permissions.target";
 const MODULE_PREVIOUS_ID = "helyx.permissions.module.previous";
@@ -17,13 +19,15 @@ const MODULE_PAGE_SIZE = 25;
 const TARGET_PAGE_SIZE = 24;
 const VIOLET = 0x7c3aed;
 export function createPermissionsModule(configurableModules) {
-    const modules = new Map(configurableModules.map((module) => [module.manifest.id, module]));
+    const modules = new Map(configurableModules
+        .filter((module) => isCustomerSelectableModule(module.manifest))
+        .map((module) => [module.manifest.id, module]));
     const commandModules = [...modules.values()]
         .filter((module) => commandTargets(module).length > 0)
         .sort((left, right) => left.manifest.name.localeCompare(right.manifest.name, "en-GB"));
     return defineModule({
         manifest: {
-            manifestVersion: "0.1",
+            ...INTERNAL_MODULE_MANIFEST_FIELDS,
             releaseStatus: "live",
             id: "helyx.permissions",
             name: "Permissions",
@@ -46,6 +50,7 @@ export function createPermissionsModule(configurableModules) {
                 {
                     name: "permissions",
                     description: "Configure access to Helyx modules and commands",
+                    acknowledgement: "deferred-ephemeral",
                     registration: "global",
                     contexts: ["guild"],
                     integrationTypes: ["guild_install"],
@@ -359,9 +364,17 @@ function restrictedPolicy() {
     };
 }
 function commandTargets(module) {
-    return (module.interactions?.commands ?? []).flatMap((command) => command.subcommands?.length
-        ? command.subcommands.map((subcommand) => `${command.name}.${subcommand.name}`)
-        : [command.name]);
+    const targets = (module.interactions?.commands ?? []).flatMap((command) => {
+        const nested = [
+            ...(command.subcommands ?? []).map((subcommand) => `${command.name}.${subcommand.name}`),
+            ...(command.subcommandGroups ?? []).flatMap((group) => group.subcommands.map((subcommand) => `${command.name}.${group.name}.${subcommand.name}`)),
+        ];
+        if (nested.length > 0)
+            return nested;
+        return [command.name];
+    });
+    targets.push(...(module.nexusCommands ?? []).map((command) => `nexus.${command.path}`));
+    return [...new Set(targets)];
 }
 function modulePickerResponse(modules, requestedPage) {
     const pages = pageCount(modules.length, MODULE_PAGE_SIZE);

package/dist/renewable-lease.d.ts

@@ -0,0 +1,16 @@
+interface RenewableLeaseOptions {
+    intervalMs: number;
+    renew(): Promise<void>;
+    onError?(error: Error): void;
+}
+export declare class RenewableLease {
+    #private;
+    private readonly options;
+    constructor(options: RenewableLeaseOptions);
+    start(): void;
+    assertOwned(): void;
+    run<Result>(operation: (signal: AbortSignal) => Promise<Result>): Promise<Result>;
+    stop(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=renewable-lease.d.ts.map

package/dist/renewable-lease.js

@@ -0,0 +1,66 @@
+export class RenewableLease {
+    options;
+    #controller = new AbortController();
+    #lost;
+    #resolveLost;
+    #failure;
+    #renewing;
+    #timer;
+    constructor(options) {
+        this.options = options;
+        let resolveLost;
+        this.#lost = new Promise((resolve) => {
+            resolveLost = resolve;
+        });
+        this.#resolveLost = resolveLost;
+    }
+    start() {
+        if (this.#timer || this.#failure)
+            return;
+        this.#timer = setInterval(() => this.#tick(), this.options.intervalMs);
+        this.#timer.unref();
+    }
+    assertOwned() {
+        if (this.#failure)
+            throw this.#failure;
+    }
+    async run(operation) {
+        this.assertOwned();
+        const operationOutcome = Promise.resolve()
+            .then(() => operation(this.#controller.signal))
+            .then((value) => ({ kind: "completed", value }), (error) => ({ kind: "failed", error }));
+        const outcome = await Promise.race([
+            operationOutcome,
+            this.#lost.then((error) => ({ kind: "lease-lost", error })),
+        ]);
+        if (outcome.kind === "lease-lost") {
+            await operationOutcome;
+            throw outcome.error;
+        }
+        if (outcome.kind === "failed")
+            throw outcome.error;
+        this.assertOwned();
+        return outcome.value;
+    }
+    async stop() {
+        if (this.#timer)
+            clearInterval(this.#timer);
+        this.#timer = undefined;
+        await this.#renewing;
+    }
+    #tick() {
+        if (this.#renewing || this.#failure)
+            return;
+        const renewing = this.options.renew().catch((error) => {
+            const failure = error instanceof Error ? error : new Error("Lease renewal failed");
+            this.#failure = failure;
+            this.#controller.abort(failure);
+            this.#resolveLost(failure);
+            this.options.onError?.(failure);
+        });
+        this.#renewing = renewing.finally(() => {
+            this.#renewing = undefined;
+        });
+    }
+}
+//# sourceMappingURL=renewable-lease.js.map

package/dist/scheduled-task-runner.js

@@ -58,7 +58,14 @@ export class ScheduledTaskRunner {
         const active = this.#active;
         if (!active)
             return;
-        await Promise.race([active, wait(this.#stopTimeoutMs)]);
+        const drainedBeforeDeadline = await Promise.race([
+            active.then(() => true),
+            wait(this.#stopTimeoutMs).then(() => false),
+        ]);
+        if (!drainedBeforeDeadline) {
+            this.#logger.warn({ event: "scheduler.stop_deadline_exceeded" }, "Scheduled task runner is still draining after its shutdown deadline");
+            await active;
+        }
     }
     async runOnce() {
         if (this.#stopping)
@@ -321,6 +328,13 @@ export function createLocalScheduledTaskRoute(input) {
         const module = modules.get(task.moduleId);
         if (!module)
             return deferred("module_unavailable", DEFAULT_POLL_INTERVAL_MS * 30);
+        if (typeof input.services.has === "function" &&
+            input.services.has(HELYX_SERVICE_NAMES.moduleAvailability)) {
+            const availability = input.services.get(HELYX_SERVICE_NAMES.moduleAvailability);
+            if (typeof availability?.isAvailable === "function" &&
+                !(await availability.isAvailable(task.moduleId)))
+                return deferred("module_globally_disabled", DEFAULT_POLL_INTERVAL_MS * 30);
+        }
         if (task.guildId) {
             const enabled = await input.services
                 .get(HELYX_SERVICE_NAMES.installations)

package/dist/shard-router.d.ts

@@ -11,11 +11,13 @@ export declare class ShardControlRouter implements BotControlHandler {
         localLeases: ReadonlyMap<number, ShardLease>;
         dispatchLocal: LocalDispatcher;
         privacy?: Pick<BotControlHandler, "listPrivacyProviders" | "capturePrivacy" | "erasePrivacy">;
+        availability?: Pick<BotControlHandler, "listAvailabilityModules">;
         localLeaderLease?: ShardLeaderLease;
         coordinator?: ShardCoordinator;
         notificationGuildId?: string;
     });
     cleanupOAuthConsumer(input: Parameters<BotControlHandler["cleanupOAuthConsumer"]>[0]): ReturnType<BotControlHandler["cleanupOAuthConsumer"]>;
+    listAvailabilityModules(): ReturnType<BotControlHandler["listAvailabilityModules"]>;
     getGuildState(guildId: string): ReturnType<BotControlHandler["getGuildState"]>;
     canAccessDashboard(input: Parameters<BotControlHandler["canAccessDashboard"]>[0]): ReturnType<BotControlHandler["canAccessDashboard"]>;
     getGuildAccessPolicy(input: Parameters<BotControlHandler["getGuildAccessPolicy"]>[0]): ReturnType<BotControlHandler["getGuildAccessPolicy"]>;

package/dist/shard-router.js

@@ -15,6 +15,11 @@ export class ShardControlRouter {
     cleanupOAuthConsumer(input) {
         return this.#route({ kind: "oauth.consumer.cleanup", ...input });
     }
+    listAvailabilityModules() {
+        if (!this.input.availability)
+            return Promise.reject(new BotControlTransportError(503, "Module availability catalogue is unavailable"));
+        return this.input.availability.listAvailabilityModules();
+    }
     getGuildState(guildId) {
         return this.#route({ kind: "guild.state.get", guildId });
     }

package/dist/shard-supervisor.d.ts

@@ -9,6 +9,11 @@ export declare function supervisorShutdownExitCode(reason: string): number | und
 export declare function createStartupWorkerHeartbeatMaintenance(heartbeat: () => void, intervalMs?: number): {
     stop(): void;
 };
+export declare function relinquishRestartCircuitOwnership(input: {
+    shardId: number;
+    localLeases: Map<number, ShardLease>;
+    release(lease: ShardLease): Promise<boolean>;
+}): Promise<boolean>;
 export declare function deferScheduledRoutingFailures(route: () => Promise<ScheduledTaskExecutionResult>): Promise<ScheduledTaskExecutionResult>;
 export declare function startShardSupervisor(environment: BotEnvironment, processEnvironment: NodeJS.ProcessEnv, workerEntry: string): Promise<BotHandle>;
 export declare function splitNumericCommittedBatch(batch: NumericWriteBehindCommittedBatch, index: number): NumericWriteBehindCommittedBatch;