@methodacting/actor-kit 0.47.0

package/dist/index.d.ts

@@ -0,0 +1,644 @@
+import { z } from 'zod';
+import { DurableObject } from 'cloudflare:workers';
+import { Operation } from 'fast-json-patch';
+import { StateMachine, AnyEventObject, StateValueFrom, AnyStateMachine, SnapshotFrom, AnyActorRef } from 'xstate';
+
+declare const BotManagementSchema: z.ZodObject<{
+    corporateProxy: z.ZodBoolean;
+    verifiedBot: z.ZodBoolean;
+    jsDetection: z.ZodObject<{
+        passed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        passed: boolean;
+    }, {
+        passed: boolean;
+    }>;
+    staticResource: z.ZodBoolean;
+    detectionIds: z.ZodRecord<z.ZodString, z.ZodAny>;
+    score: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    corporateProxy: boolean;
+    verifiedBot: boolean;
+    jsDetection: {
+        passed: boolean;
+    };
+    staticResource: boolean;
+    detectionIds: Record<string, any>;
+    score: number;
+}, {
+    corporateProxy: boolean;
+    verifiedBot: boolean;
+    jsDetection: {
+        passed: boolean;
+    };
+    staticResource: boolean;
+    detectionIds: Record<string, any>;
+    score: number;
+}>;
+declare const EnvironmentSchema: z.ZodObject<{
+    ACTOR_KIT_SECRET: z.ZodString;
+    ACTOR_KIT_HOST: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ACTOR_KIT_SECRET: string;
+    ACTOR_KIT_HOST: string;
+}, {
+    ACTOR_KIT_SECRET: string;
+    ACTOR_KIT_HOST: string;
+}>;
+declare const RequestInfoSchema: z.ZodObject<{
+    longitude: z.ZodString;
+    latitude: z.ZodString;
+    continent: z.ZodString;
+    country: z.ZodString;
+    city: z.ZodString;
+    timezone: z.ZodString;
+    postalCode: z.ZodString;
+    region: z.ZodString;
+    regionCode: z.ZodString;
+    metroCode: z.ZodString;
+    botManagement: z.ZodObject<{
+        corporateProxy: z.ZodBoolean;
+        verifiedBot: z.ZodBoolean;
+        jsDetection: z.ZodObject<{
+            passed: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            passed: boolean;
+        }, {
+            passed: boolean;
+        }>;
+        staticResource: z.ZodBoolean;
+        detectionIds: z.ZodRecord<z.ZodString, z.ZodAny>;
+        score: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        corporateProxy: boolean;
+        verifiedBot: boolean;
+        jsDetection: {
+            passed: boolean;
+        };
+        staticResource: boolean;
+        detectionIds: Record<string, any>;
+        score: number;
+    }, {
+        corporateProxy: boolean;
+        verifiedBot: boolean;
+        jsDetection: {
+            passed: boolean;
+        };
+        staticResource: boolean;
+        detectionIds: Record<string, any>;
+        score: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    longitude: string;
+    latitude: string;
+    continent: string;
+    country: string;
+    city: string;
+    timezone: string;
+    postalCode: string;
+    region: string;
+    regionCode: string;
+    metroCode: string;
+    botManagement: {
+        corporateProxy: boolean;
+        verifiedBot: boolean;
+        jsDetection: {
+            passed: boolean;
+        };
+        staticResource: boolean;
+        detectionIds: Record<string, any>;
+        score: number;
+    };
+}, {
+    longitude: string;
+    latitude: string;
+    continent: string;
+    country: string;
+    city: string;
+    timezone: string;
+    postalCode: string;
+    region: string;
+    regionCode: string;
+    metroCode: string;
+    botManagement: {
+        corporateProxy: boolean;
+        verifiedBot: boolean;
+        jsDetection: {
+            passed: boolean;
+        };
+        staticResource: boolean;
+        detectionIds: Record<string, any>;
+        score: number;
+    };
+}>;
+declare const CallerSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["client", "system", "service"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "client" | "system" | "service";
+    id: string;
+}, {
+    type: "client" | "system" | "service";
+    id: string;
+}>;
+declare const AnyEventSchema: z.ZodObject<{
+    type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+}, {
+    type: string;
+}>;
+declare const SystemEventSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"INITIALIZE">;
+    caller: z.ZodObject<{
+        type: z.ZodLiteral<"system">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "system";
+        id: string;
+    }, {
+        type: "system";
+        id: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "INITIALIZE";
+    caller: {
+        type: "system";
+        id: string;
+    };
+}, {
+    type: "INITIALIZE";
+    caller: {
+        type: "system";
+        id: string;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"CONNECT">;
+    caller: z.ZodObject<{
+        type: z.ZodLiteral<"system">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "system";
+        id: string;
+    }, {
+        type: "system";
+        id: string;
+    }>;
+    connectingCaller: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["client", "system", "service"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "client" | "system" | "service";
+        id: string;
+    }, {
+        type: "client" | "system" | "service";
+        id: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "CONNECT";
+    caller: {
+        type: "system";
+        id: string;
+    };
+    connectingCaller: {
+        type: "client" | "system" | "service";
+        id: string;
+    };
+}, {
+    type: "CONNECT";
+    caller: {
+        type: "system";
+        id: string;
+    };
+    connectingCaller: {
+        type: "client" | "system" | "service";
+        id: string;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"DISCONNECT">;
+    caller: z.ZodObject<{
+        type: z.ZodLiteral<"system">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "system";
+        id: string;
+    }, {
+        type: "system";
+        id: string;
+    }>;
+    disconnectingCaller: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["client", "system", "service"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "client" | "system" | "service";
+        id: string;
+    }, {
+        type: "client" | "system" | "service";
+        id: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "DISCONNECT";
+    caller: {
+        type: "system";
+        id: string;
+    };
+    disconnectingCaller: {
+        type: "client" | "system" | "service";
+        id: string;
+    };
+}, {
+    type: "DISCONNECT";
+    caller: {
+        type: "system";
+        id: string;
+    };
+    disconnectingCaller: {
+        type: "client" | "system" | "service";
+        id: string;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"RESUME">;
+    caller: z.ZodObject<{
+        type: z.ZodLiteral<"system">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "system";
+        id: string;
+    }, {
+        type: "system";
+        id: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "RESUME";
+    caller: {
+        type: "system";
+        id: string;
+    };
+}, {
+    type: "RESUME";
+    caller: {
+        type: "system";
+        id: string;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"MIGRATE">;
+    caller: z.ZodObject<{
+        type: z.ZodLiteral<"system">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "system";
+        id: string;
+    }, {
+        type: "system";
+        id: string;
+    }>;
+    operations: z.ZodArray<z.ZodAny, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "MIGRATE";
+    caller: {
+        type: "system";
+        id: string;
+    };
+    operations: any[];
+}, {
+    type: "MIGRATE";
+    caller: {
+        type: "system";
+        id: string;
+    };
+    operations: any[];
+}>]>;
+declare const CallerIdTypeSchema: z.ZodEnum<["client", "service", "system"]>;
+declare const CallerStringSchema: z.ZodEffects<z.ZodString, {
+    type: "client" | "system" | "service";
+    id: string;
+}, string>;
+
+interface AlarmRecord {
+    id: string;
+    type: string;
+    scheduled_at: number;
+    repeat_interval: number | null;
+    payload: string | null;
+    created_at: number;
+}
+interface AlarmScheduleOptions {
+    id: string;
+    type: string;
+    scheduledAt: number;
+    repeatInterval?: number;
+    payload: Record<string, unknown>;
+}
+interface ActorMetaRecord {
+    actor_id: string;
+    actor_type: string;
+    initial_caller: string;
+    input: string;
+    created_at: number;
+    updated_at: number;
+}
+interface ActorMeta {
+    actorId: string;
+    actorType: string;
+    initialCaller: Caller;
+    input: Record<string, unknown>;
+}
+interface SnapshotRecord {
+    actor_id: string;
+    snapshot: string;
+    checksum: string | null;
+    updated_at: number;
+}
+interface Snapshot {
+    actorId: string;
+    snapshot: unknown;
+    checksum?: string;
+}
+declare class ActorKitStorage {
+    private storage;
+    private initialized;
+    private sql;
+    constructor(storage: DurableObjectStorage);
+    ensureInitialized(): Promise<void>;
+    getAlarms(): Promise<AlarmRecord[]>;
+    getDueAlarms(before: number): Promise<AlarmRecord[]>;
+    getEarliestAlarm(): Promise<AlarmRecord | null>;
+    insertAlarm(options: AlarmScheduleOptions): Promise<void>;
+    updateAlarm(options: AlarmScheduleOptions): Promise<void>;
+    deleteAlarm(id: string): Promise<void>;
+    deleteAlarmsByType(type: string): Promise<void>;
+    getActorMeta(actorId?: string): Promise<ActorMeta | null>;
+    setActorMeta(meta: ActorMeta): Promise<void>;
+    deleteActorMeta(actorId: string): Promise<void>;
+    getSnapshot(actorId: string): Promise<Snapshot | null>;
+    setSnapshot(actorId: string, snapshot: unknown, checksum?: string): Promise<void>;
+    deleteSnapshot(actorId: string): Promise<void>;
+    migrateFromKV(storage: DurableObjectStorage): Promise<void>;
+    private parseRows;
+}
+
+type AlarmType = "xstate-delay" | "cache-cleanup" | "custom";
+interface Alarm {
+    id: string;
+    type: AlarmType;
+    scheduledAt: number;
+    repeatInterval?: number;
+    payload: Record<string, unknown>;
+    createdAt: number;
+}
+interface ScheduleAlarmOptions {
+    id: string;
+    type: AlarmType;
+    scheduledAt: number;
+    repeatInterval?: number;
+    payload: Record<string, unknown>;
+}
+interface AlarmHandleResult {
+    id: string;
+    type: AlarmType;
+    rescheduled?: boolean;
+    deleted: boolean;
+}
+declare class AlarmManager {
+    private storage;
+    private state;
+    private currentAlarmId;
+    private currentAlarmTime;
+    constructor(storage: ActorKitStorage, state: DurableObjectState);
+    schedule(options: ScheduleAlarmOptions): Promise<void>;
+    cancel(id: string): Promise<void>;
+    cancelByType(type: AlarmType): Promise<void>;
+    getPendingAlarms(): Promise<Alarm[]>;
+    getDueAlarms(before?: number): Promise<Alarm[]>;
+    deleteAlarm(id: string): Promise<void>;
+    updateAlarm(options: ScheduleAlarmOptions): Promise<void>;
+    rescheduleNextAlarm(): Promise<void>;
+    handleDueAlarms(handler: (alarm: Alarm) => Promise<boolean>): Promise<AlarmHandleResult[]>;
+    getCurrentAlarm(): {
+        id: string | null;
+        time: number | null;
+    };
+    private parseAlarmRecord;
+}
+declare function generateAlarmId(): string;
+declare function calculateNextRecurringAlarm(baseTime: number, interval: number, now?: number): number;
+
+type EnvWithDurableObjects = {
+    ACTOR_KIT_SECRET: string;
+    [key: string]: DurableObjectNamespace<ActorServer<any>> | unknown;
+};
+type AnyEvent = z.infer<typeof AnyEventSchema>;
+interface ActorServerMethods<TMachine extends BaseActorKitStateMachine> {
+    fetch(request: Request): Promise<Response>;
+    spawn(props: {
+        actorType: string;
+        actorId: string;
+        caller: Caller;
+        input: Record<string, unknown>;
+    }): void;
+    send(event: ClientEventFrom<TMachine> | ServiceEventFrom<TMachine>): void;
+    getSnapshot(caller: Caller, options?: {
+        waitForEvent?: ClientEventFrom<TMachine>;
+        waitForState?: StateValueFrom<TMachine>;
+        timeout?: number;
+        errorOnWaitTimeout?: boolean;
+    }): Promise<{
+        checksum: string;
+        snapshot: CallerSnapshotFrom<TMachine>;
+    }>;
+}
+type ActorServer<TMachine extends AnyActorKitStateMachine> = DurableObject & ActorServerMethods<TMachine>;
+type AnyActorServer = ActorServer<any>;
+type Caller = z.infer<typeof CallerSchema>;
+type RequestInfo = z.infer<typeof RequestInfoSchema>;
+type ActorKitInputProps = {
+    id: string;
+    caller: Caller;
+    storage: DurableObjectStorage;
+    [key: string]: unknown;
+};
+type CallerType = "client" | "system" | "service";
+type EventObject = {
+    type: string;
+};
+type EventSchemaUnion = z.ZodDiscriminatedUnion<"type", [
+    z.ZodObject<z.ZodRawShape & {
+        type: z.ZodString;
+    }>,
+    ...z.ZodObject<z.ZodRawShape & {
+        type: z.ZodString;
+    }>[]
+]>;
+type EventSchemas = {
+    client: EventSchemaUnion;
+    service: EventSchemaUnion;
+};
+type BaseActorKitContext<TPublicProps extends {
+    [key: string]: unknown;
+}, TPrivateProps extends {
+    [key: string]: unknown;
+}> = {
+    public: TPublicProps;
+    private: Record<string, TPrivateProps>;
+};
+type ActorKitStateMachine<TEvent extends BaseActorKitEvent<EnvWithDurableObjects>, TInput extends {
+    id: string;
+    caller: Caller;
+    storage: DurableObjectStorage;
+}, TContext extends BaseActorKitContext<any, any> & {
+    [key: string]: unknown;
+}> = StateMachine<TContext, TEvent & EventObject, any, any, any, any, any, any, any, TInput, any, any, any, any>;
+type BaseActorKitInput<TEnv = EnvWithDurableObjects> = {
+    id: string;
+    caller: Caller;
+    env: TEnv;
+    storage: DurableObjectStorage;
+};
+type WithActorKitInput<TInputProps extends {
+    [key: string]: unknown;
+}, TEnv extends EnvWithDurableObjects> = TInputProps & BaseActorKitInput<TEnv>;
+type AnyActorKitStateMachine = ActorKitStateMachine<any, any, any>;
+type AnyActorKitEvent = (WithActorKitEvent<AnyEventObject, "client"> | WithActorKitEvent<AnyEventObject, "service"> | ActorKitSystemEvent) & BaseActorKitEvent<EnvWithDurableObjects>;
+type AnyActorKitInput = WithActorKitInput<{
+    [key: string]: unknown;
+}, EnvWithDurableObjects> & {
+    storage: DurableObjectStorage;
+};
+type AnyActorKitContext = {
+    public: {
+        [key: string]: unknown;
+    };
+    private: Record<string, {
+        [key: string]: unknown;
+    }>;
+};
+type BaseActorKitStateMachine = ActorKitStateMachine<AnyActorKitEvent, AnyActorKitInput, AnyActorKitContext>;
+type ExtraContext = {
+    requestId: string;
+};
+interface BaseActorKitEvent<TEnv extends EnvWithDurableObjects> {
+    caller: Caller;
+    storage: DurableObjectStorage;
+    requestInfo?: RequestInfo;
+    env: TEnv;
+}
+type ActorKitSystemEvent = z.infer<typeof SystemEventSchema>;
+type WithActorKitEvent<T extends {
+    type: string;
+}, C extends CallerType> = T & BaseActorKitEvent<EnvWithDurableObjects> & {
+    caller: {
+        type: C;
+    };
+};
+type WithActorKitContext<TExtraProps extends {
+    [key: string]: unknown;
+}, TPrivateProps extends {
+    [key: string]: unknown;
+}, TPublicProps extends {
+    [key: string]: unknown;
+}> = TExtraProps & {
+    public: TPublicProps;
+    private: Record<string, TPrivateProps>;
+};
+type CallerSnapshotFrom<TMachine extends AnyStateMachine> = {
+    public: SnapshotFrom<TMachine> extends {
+        context: {
+            public: infer P;
+        };
+    } ? P : unknown;
+    private: SnapshotFrom<TMachine> extends {
+        context: {
+            private: Partial<Record<string, infer PR>>;
+        };
+    } ? PR : unknown;
+    value: SnapshotFrom<TMachine> extends {
+        value: infer V;
+    } ? V : unknown;
+};
+type ClientEventFrom<T extends AnyActorKitStateMachine> = T extends StateMachine<any, infer TEvent, any, any, any, any, any, any, any, any, any, any, any, any> ? TEvent extends WithActorKitEvent<infer E, "client"> ? Omit<E, keyof BaseActorKitEvent<EnvWithDurableObjects>> : never : never;
+type ServiceEventFrom<T extends AnyActorKitStateMachine> = T extends StateMachine<any, infer TEvent, any, any, any, any, any, any, any, any, any, any, any, any> ? TEvent extends WithActorKitEvent<infer E, "service"> ? Omit<E, keyof BaseActorKitEvent<EnvWithDurableObjects>> : never : never;
+type ScreamingSnakeToKebab<S extends string> = S extends `${infer T}_${infer U}` ? `${Lowercase<T>}-${ScreamingSnakeToKebab<U>}` : Lowercase<S>;
+type DurableObjectActor<TMachine extends AnyActorKitStateMachine> = ActorServer<TMachine>;
+type CamelToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? U extends Uncapitalize<U> ? `${Lowercase<T>}${CamelToSnakeCase<U>}` : `${Lowercase<T>}_${CamelToSnakeCase<U>}` : S;
+type KebabToCamelCase<S extends string> = S extends `${infer T}-${infer U}` ? `${T}${Capitalize<KebabToCamelCase<U>>}` : S;
+type KebabToScreamingSnake<S extends string> = Uppercase<CamelToSnakeCase<KebabToCamelCase<S>>>;
+interface MatchesProps<TMachine extends AnyActorKitStateMachine> {
+    state: StateValueFrom<TMachine>;
+    and?: StateValueFrom<TMachine>;
+    or?: StateValueFrom<TMachine>;
+    not?: boolean;
+    initialValueOverride?: boolean;
+}
+type MachineFromServer<T> = T extends ActorServer<infer M> ? M : never;
+type ActorKitEmittedEvent = {
+    operations: Operation[];
+    checksum: string;
+};
+type ActorKitClient<TMachine extends AnyActorKitStateMachine> = {
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    send: (event: ClientEventFrom<TMachine>) => void;
+    getState: () => CallerSnapshotFrom<TMachine>;
+    subscribe: (listener: (state: CallerSnapshotFrom<TMachine>) => void) => () => void;
+    waitFor: (predicateFn: (state: CallerSnapshotFrom<TMachine>) => boolean, timeoutMs?: number) => Promise<void>;
+};
+type ExtractEventType<TMachine> = TMachine extends ActorKitStateMachine<infer TEvent, any, any> ? TEvent : never;
+type ExtractEnvType<TEvent> = TEvent extends {
+    env: infer TEnv;
+} ? TEnv : never;
+type EnvFromMachine<TMachine extends AnyActorKitStateMachine> = ExtractEnvType<ExtractEventType<TMachine>> extends never ? EnvWithDurableObjects : ExtractEnvType<ExtractEventType<TMachine>> & EnvWithDurableObjects;
+interface MachineServerOptions {
+    persisted?: boolean;
+    enableAlarms?: boolean;
+}
+interface MachineServerServices {
+    storage: ActorKitStorage;
+    alarmManager: AlarmManager | null;
+}
+
+declare const HEADERS: {
+    X_CALLER_ID: string;
+    X_CALLER_TYPE: string;
+    X_ACTOR_ID: string;
+    X_ACTOR_TYPE: string;
+};
+declare const CallerTypes: Record<CallerType, CallerType>;
+declare const AlarmTypes: Record<AlarmType, AlarmType>;
+declare const PERSISTED_SNAPSHOT_KEY = "persistedSnapshot";
+
+interface XStateAlarmData {
+    type: "xstate-delay";
+    sourceSessionId: string;
+    targetSessionId: string;
+    event: AnyEventObject;
+    scheduledEventId: string;
+    alarmId: string;
+    [key: string]: unknown;
+}
+interface ScheduledEventSnapshot {
+    sourceSessionId: string;
+    targetSessionId: string;
+    event: AnyEventObject;
+    delay: number;
+    id: string;
+    startedAt: number;
+}
+interface Clock {
+    setTimeout: (fn: () => void, delay: number) => unknown;
+    clearTimeout: (id: unknown) => void;
+}
+declare const NOOP_CLOCK: Clock;
+declare function createAlarmScheduler(alarmManager: AlarmManager, system: any): {
+    schedule: (source: AnyActorRef, target: AnyActorRef, event: AnyEventObject, delay: number, id?: string) => void;
+    cancel: (source: AnyActorRef, id: string) => void;
+    cancelAll: (actorRef: AnyActorRef) => void;
+};
+declare function handleXStateAlarm(alarmData: XStateAlarmData, actor: any): Promise<void>;
+declare function getScheduledEvents(): Map<string, ScheduledEventSnapshot>;
+declare function restoreScheduledEvents(alarms: Array<{
+    payload: XStateAlarmData;
+    scheduledAt: number;
+}>): void;
+
+export { ActorKitStorage, AlarmManager, AlarmTypes, AnyEventSchema, BotManagementSchema, CallerIdTypeSchema, CallerSchema, CallerStringSchema, CallerTypes, EnvironmentSchema, HEADERS, NOOP_CLOCK, PERSISTED_SNAPSHOT_KEY, RequestInfoSchema, SystemEventSchema, calculateNextRecurringAlarm, createAlarmScheduler, generateAlarmId, getScheduledEvents, handleXStateAlarm, restoreScheduledEvents };
+export type { ActorKitClient, ActorKitEmittedEvent, ActorKitInputProps, ActorKitStateMachine, ActorKitSystemEvent, ActorMeta, ActorMetaRecord, ActorServer, ActorServerMethods, Alarm, AlarmHandleResult, AlarmRecord, AlarmScheduleOptions, AlarmType, AnyActorKitStateMachine, AnyActorServer, AnyEvent, BaseActorKitContext, BaseActorKitEvent, BaseActorKitInput, BaseActorKitStateMachine, Caller, CallerSnapshotFrom, CallerType, ClientEventFrom, Clock, DurableObjectActor, EnvFromMachine, EnvWithDurableObjects, EventSchemas, ExtraContext, KebabToScreamingSnake, MachineFromServer, MachineServerOptions, MachineServerServices, MatchesProps, RequestInfo, ScheduleAlarmOptions, ScheduledEventSnapshot, ScreamingSnakeToKebab, ServiceEventFrom, Snapshot, SnapshotRecord, WithActorKitContext, WithActorKitEvent, WithActorKitInput, XStateAlarmData };

package/dist/index.js

@@ -0,0 +1,2 @@
+import{z as e}from"zod";const t=e.object({corporateProxy:e.boolean(),verifiedBot:e.boolean(),jsDetection:e.object({passed:e.boolean()}),staticResource:e.boolean(),detectionIds:e.record(e.any()),score:e.number()}),a=e.object({ACTOR_KIT_SECRET:e.string(),ACTOR_KIT_HOST:e.string()}),s=e.object({longitude:e.string(),latitude:e.string(),continent:e.string(),country:e.string(),city:e.string(),timezone:e.string(),postalCode:e.string(),region:e.string(),regionCode:e.string(),metroCode:e.string(),botManagement:t}),r=e.object({id:e.string(),type:e.enum(["client","system","service"])}),i=e.object({type:e.string()}),n=e.discriminatedUnion("type",[e.object({type:e.literal("INITIALIZE"),caller:e.object({type:e.literal("system"),id:e.string()})}),e.object({type:e.literal("CONNECT"),caller:e.object({type:e.literal("system"),id:e.string()}),connectingCaller:r}),e.object({type:e.literal("DISCONNECT"),caller:e.object({type:e.literal("system"),id:e.string()}),disconnectingCaller:r}),e.object({type:e.literal("RESUME"),caller:e.object({type:e.literal("system"),id:e.string()})}),e.object({type:e.literal("MIGRATE"),caller:e.object({type:e.literal("system"),id:e.string()}),operations:e.array(e.any())})]),l=e.enum(["client","service","system"]),c=e.string().transform((t,a)=>{if("anonymous"===t)return{type:"client",id:"anonymous"};const s=l.safeParse(t.split("-")[0]);if(!s.success)return s.error.issues.forEach(a.addIssue),e.NEVER;const r=s.data,i=t.substring(t.indexOf("-")+1);return e.string().uuid().safeParse(i).success?{type:r,id:i}:(a.addIssue({code:e.ZodIssueCode.custom,message:`Must be a valid uuid or 'anonymous'. Received '${i}' on value '${t}'.`}),e.NEVER)}),o={X_CALLER_ID:"X-Caller-ID",X_CALLER_TYPE:"X-Caller-Type",X_ACTOR_ID:"X-Actor-ID",X_ACTOR_TYPE:"X-Actor-Type"},d={client:"client",system:"system",service:"service"},u={"xstate-delay":"xstate-delay","cache-cleanup":"cache-cleanup",custom:"custom"},p="persistedSnapshot";class h{storage;initialized=!1;sql;constructor(e){this.storage=e,this.sql=e.sql}async ensureInitialized(){if(!this.initialized)try{await this.sql.exec("\n-- Alarms table - supports one-time and recurring alarms\nCREATE TABLE IF NOT EXISTS alarms (\n  id TEXT PRIMARY KEY,\n  type TEXT NOT NULL,\n  scheduled_at INTEGER NOT NULL,\n  repeat_interval INTEGER,\n  payload TEXT,\n  created_at INTEGER NOT NULL\n);\n\n-- Index for efficient due alarm queries\nCREATE INDEX IF NOT EXISTS idx_alarms_scheduled_at ON alarms(scheduled_at);\n\n-- Actor metadata (replaces KV keys: actorType, actorId, initialCaller, input)\nCREATE TABLE IF NOT EXISTS actor_meta (\n  actor_id TEXT PRIMARY KEY,\n  actor_type TEXT NOT NULL,\n  initial_caller TEXT NOT NULL,\n  input TEXT NOT NULL,\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\n\n-- Snapshots table (replaces PERSISTED_SNAPSHOT_KEY)\nCREATE TABLE IF NOT EXISTS snapshots (\n  actor_id TEXT PRIMARY KEY,\n  snapshot TEXT NOT NULL,\n  checksum TEXT,\n  updated_at INTEGER NOT NULL\n);\n"),this.initialized=!0}catch(e){throw console.error("Failed to initialize database schema:",e),e}}async getAlarms(){await this.ensureInitialized();const e=await this.sql.exec("SELECT id, type, scheduled_at, repeat_interval, payload, created_at FROM alarms ORDER BY scheduled_at ASC");return await this.parseRows(e)}async getDueAlarms(e){await this.ensureInitialized();const t=await this.sql.exec("SELECT id, type, scheduled_at, repeat_interval, payload, created_at FROM alarms WHERE scheduled_at <= ? ORDER BY scheduled_at ASC",[e]);return await this.parseRows(t)}async getEarliestAlarm(){await this.ensureInitialized();const e=await this.sql.exec("SELECT id, type, scheduled_at, repeat_interval, payload, created_at FROM alarms ORDER BY scheduled_at ASC LIMIT 1");return(await this.parseRows(e))[0]||null}async insertAlarm(e){await this.ensureInitialized(),await this.sql.exec("INSERT INTO alarms (id, type, scheduled_at, repeat_interval, payload, created_at) VALUES (?, ?, ?, ?, ?, ?)",[e.id,e.type,e.scheduledAt,e.repeatInterval??null,JSON.stringify(e.payload),Date.now()])}async updateAlarm(e){await this.ensureInitialized(),await this.sql.exec("UPDATE alarms SET scheduled_at = ?, repeat_interval = ?, payload = ? WHERE id = ?",[e.scheduledAt,e.repeatInterval??null,JSON.stringify(e.payload),e.id])}async deleteAlarm(e){await this.ensureInitialized(),await this.sql.exec("DELETE FROM alarms WHERE id = ?",[e])}async deleteAlarmsByType(e){await this.ensureInitialized(),await this.sql.exec("DELETE FROM alarms WHERE type = ?",[e])}async getActorMeta(e){if(await this.ensureInitialized(),!e){const e=await this.sql.exec("SELECT actor_id, actor_type, initial_caller, input, created_at, updated_at FROM actor_meta LIMIT 1"),t=await this.parseRows(e);if(0===t.length)return null;const a=t[0];return{actorId:a.actor_id,actorType:a.actor_type,initialCaller:JSON.parse(a.initial_caller),input:JSON.parse(a.input)}}const t=await this.sql.exec("SELECT actor_id, actor_type, initial_caller, input, created_at, updated_at FROM actor_meta WHERE actor_id = ?",[e]),a=await this.parseRows(t);if(0===a.length)return null;const s=a[0];return{actorId:s.actor_id,actorType:s.actor_type,initialCaller:JSON.parse(s.initial_caller),input:JSON.parse(s.input)}}async setActorMeta(e){await this.ensureInitialized();const t=Date.now();await this.sql.exec("INSERT INTO actor_meta (actor_id, actor_type, initial_caller, input, created_at, updated_at)\n       VALUES (?, ?, ?, ?, ?, ?)\n       ON CONFLICT(actor_id) DO UPDATE SET\n        actor_type = excluded.actor_type,\n        initial_caller = excluded.initial_caller,\n        input = excluded.input,\n        updated_at = excluded.updated_at",[e.actorId,e.actorType,JSON.stringify(e.initialCaller),JSON.stringify(e.input),t,t])}async deleteActorMeta(e){await this.ensureInitialized(),await this.sql.exec("DELETE FROM actor_meta WHERE actor_id = ?",[e])}async getSnapshot(e){await this.ensureInitialized();const t=await this.sql.exec("SELECT actor_id, snapshot, checksum, updated_at FROM snapshots WHERE actor_id = ?",[e]),a=await this.parseRows(t);if(0===a.length)return null;const s=a[0];return{actorId:s.actor_id,snapshot:JSON.parse(s.snapshot),checksum:s.checksum??void 0}}async setSnapshot(e,t,a){await this.ensureInitialized(),await this.sql.exec("INSERT INTO snapshots (actor_id, snapshot, checksum, updated_at)\n       VALUES (?, ?, ?, ?)\n       ON CONFLICT(actor_id) DO UPDATE SET\n        snapshot = excluded.snapshot,\n        checksum = excluded.checksum,\n        updated_at = excluded.updated_at",[e,JSON.stringify(t),a??null,Date.now()])}async deleteSnapshot(e){await this.ensureInitialized(),await this.sql.exec("DELETE FROM snapshots WHERE actor_id = ?",[e])}async migrateFromKV(e){await this.ensureInitialized();const[t,a,s,r]=await Promise.all([e.get("actorType"),e.get("actorId"),e.get("initialCaller"),e.get("input")]);t&&a&&s&&r&&await this.setActorMeta({actorId:a,actorType:t,initialCaller:JSON.parse(s),input:JSON.parse(r)});const i=await e.get(p);if(i){const e=JSON.parse(i);await this.setSnapshot(a,e)}}async parseRows(e){if(e&&"function"==typeof e[Symbol.asyncIterator]){const t=e,a=[];let s=[];for await(const e of t){s||(s=e.columns);for(const t of e.results){const e={};s.forEach((a,s)=>{e[a]=t[s]}),a.push(e)}}return a}if(Array.isArray(e)&&0===e.length)return[];const{columns:t,rows:a}=e[0];return a.map(e=>{const a={};return t.forEach((t,s)=>{a[t]=e[s]}),a})}}class y{storage;state;currentAlarmId=null;currentAlarmTime=null;constructor(e,t){this.storage=e,this.state=t}async schedule(e){await this.storage.insertAlarm(e),await this.rescheduleNextAlarm()}async cancel(e){await this.storage.deleteAlarm(e),this.currentAlarmId===e&&await this.rescheduleNextAlarm()}async cancelByType(e){await this.storage.deleteAlarmsByType(e),await this.rescheduleNextAlarm()}async getPendingAlarms(){return(await this.storage.getAlarms()).map(this.parseAlarmRecord)}async getDueAlarms(e=Date.now()){return(await this.storage.getDueAlarms(e)).map(this.parseAlarmRecord)}async deleteAlarm(e){await this.storage.deleteAlarm(e)}async updateAlarm(e){await this.storage.updateAlarm(e)}async rescheduleNextAlarm(){const e=await this.storage.getEarliestAlarm();if(!e)return this.currentAlarmId=null,void(this.currentAlarmTime=null);this.currentAlarmId===e.id&&this.currentAlarmTime===e.scheduled_at||(this.currentAlarmId=e.id,this.currentAlarmTime=e.scheduled_at,await this.state.storage.setAlarm(e.scheduled_at))}async handleDueAlarms(e){const t=Date.now(),a=await this.getDueAlarms(t),s=[];for(const r of a){let a=!1,i=!0;if(r.repeatInterval){const e=t+r.repeatInterval;await this.updateAlarm({id:r.id,type:r.type,scheduledAt:e,repeatInterval:r.repeatInterval,payload:r.payload}),a=!0,i=!1}else await this.deleteAlarm(r.id);try{await e(r)}catch(e){console.error(`Error handling alarm ${r.id}:`,e)}s.push({id:r.id,type:r.type,rescheduled:a,deleted:i})}return await this.rescheduleNextAlarm(),s}getCurrentAlarm(){return{id:this.currentAlarmId,time:this.currentAlarmTime}}parseAlarmRecord(e){return{id:e.id,type:e.type,scheduledAt:e.scheduled_at,repeatInterval:e.repeat_interval??void 0,payload:e.payload?JSON.parse(e.payload):{},createdAt:e.created_at}}}function m(){return`alarm-${Date.now()}-${Math.random().toString(36).slice(2,11)}`}function E(e,t,a=Date.now()){let s=e;for(;s<a;)s+=t;return s}const T={setTimeout:()=>Math.random(),clearTimeout:()=>{}},I=new Map;function _(e,t){return{schedule:(t,a,s,r,i=Math.random().toString(36).slice(2))=>{const n=`${t.sessionId}.${i}`,l={sourceSessionId:t.sessionId,targetSessionId:a.sessionId,event:s,delay:r,id:i,startedAt:Date.now()};I.set(n,l);const c=`xstate-${n}`;e.schedule({id:c,type:"xstate-delay",scheduledAt:Date.now()+r,payload:{type:"xstate-delay",sourceSessionId:t.sessionId,targetSessionId:a.sessionId,event:s,scheduledEventId:n,alarmId:c}}).catch(e=>{console.error("[AlarmScheduler] Error scheduling alarm:",e),I.delete(n)})},cancel:(t,a)=>{const s=`${t.sessionId}.${a}`;I.delete(s),e.cancel(`xstate-${s}`).catch(e=>{console.error("[AlarmScheduler] Error canceling alarm:",e)})},cancelAll:t=>{const a=[];for(const[e,s]of I.entries())s.sourceSessionId===t.sessionId&&a.push(e);for(const t of a)I.delete(t),e.cancel(`xstate-${t}`).catch(e=>{console.error("[AlarmScheduler] Error canceling alarm:",e)})}}}async function A(e,t){const{scheduledEventId:a,event:s}=e;I.delete(a);try{t.system&&t.system._relay?t.system._relay(t,t,s):t.send(s)}catch(e){console.error("[AlarmScheduler] Error handling XState alarm:",e)}}function g(){return new Map(I)}function w(e){for(const t of e)if("xstate-delay"===t.payload.type){const{sourceSessionId:e,targetSessionId:a,event:s,scheduledEventId:r}=t.payload,i=t.scheduledAt-Date.now();i>0&&I.set(r,{sourceSessionId:e,targetSessionId:a,event:s,delay:i,id:r.split(".").pop()||r,startedAt:t.scheduledAt-i})}}export{h as ActorKitStorage,y as AlarmManager,u as AlarmTypes,i as AnyEventSchema,t as BotManagementSchema,l as CallerIdTypeSchema,r as CallerSchema,c as CallerStringSchema,d as CallerTypes,a as EnvironmentSchema,o as HEADERS,T as NOOP_CLOCK,p as PERSISTED_SNAPSHOT_KEY,s as RequestInfoSchema,n as SystemEventSchema,E as calculateNextRecurringAlarm,_ as createAlarmScheduler,m as generateAlarmId,g as getScheduledEvents,A as handleXStateAlarm,w as restoreScheduledEvents};
+//# sourceMappingURL=index.js.map