stitchkit 0.59.1 → 0.59.2

package/dist/application/schemas.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+export declare const ApplicationIdSchema: z.ZodString;
+export type ApplicationId = z.infer<typeof ApplicationIdSchema>;
+export declare const ApplicationLifecycleSchema: z.ZodEnum<{
+    created: "created";
+    draining: "draining";
+    failed: "failed";
+    ready: "ready";
+    starting: "starting";
+    stopped: "stopped";
+    stopping: "stopping";
+}>;
+export type ApplicationLifecycle = z.infer<typeof ApplicationLifecycleSchema>;
+export declare const ApplicationHealthSchema: z.ZodEnum<{
+    degraded: "degraded";
+    healthy: "healthy";
+    unhealthy: "unhealthy";
+    unknown: "unknown";
+}>;
+export type ApplicationHealth = z.infer<typeof ApplicationHealthSchema>;
+export declare const ManagedResourceStateSchema: z.ZodEnum<{
+    failed: "failed";
+    ready: "ready";
+    registered: "registered";
+    starting: "starting";
+    stopped: "stopped";
+    stopping: "stopping";
+}>;
+export type ManagedResourceState = z.infer<typeof ManagedResourceStateSchema>;
+export declare const ApplicationAdmissionSnapshotSchema: z.ZodReadonly<z.ZodObject<{
+    accepting: z.ZodBoolean;
+    accepted: z.ZodNumber;
+    completed: z.ZodNumber;
+    pending: z.ZodNumber;
+}, z.core.$strip>>;
+export type ApplicationAdmissionSnapshot = z.infer<typeof ApplicationAdmissionSnapshotSchema>;
+export declare const ManagedResourceSnapshotSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    required: z.ZodBoolean;
+    dependsOn: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    state: z.ZodEnum<{
+        failed: "failed";
+        ready: "ready";
+        registered: "registered";
+        starting: "starting";
+        stopped: "stopped";
+        stopping: "stopping";
+    }>;
+    health: z.ZodEnum<{
+        degraded: "degraded";
+        healthy: "healthy";
+        unhealthy: "unhealthy";
+        unknown: "unknown";
+    }>;
+    ready: z.ZodBoolean;
+}, z.core.$strip>>;
+export type ManagedResourceSnapshot = z.infer<typeof ManagedResourceSnapshotSchema>;
+export declare const ApplicationSnapshotSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    epoch: z.ZodString;
+    revision: z.ZodNumber;
+    lifecycle: z.ZodEnum<{
+        created: "created";
+        draining: "draining";
+        failed: "failed";
+        ready: "ready";
+        starting: "starting";
+        stopped: "stopped";
+        stopping: "stopping";
+    }>;
+    health: z.ZodEnum<{
+        degraded: "degraded";
+        healthy: "healthy";
+        unhealthy: "unhealthy";
+        unknown: "unknown";
+    }>;
+    ready: z.ZodBoolean;
+    capturedAt: z.ZodString;
+    changedAt: z.ZodString;
+    admission: z.ZodReadonly<z.ZodObject<{
+        accepting: z.ZodBoolean;
+        accepted: z.ZodNumber;
+        completed: z.ZodNumber;
+        pending: z.ZodNumber;
+    }, z.core.$strip>>;
+    resources: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        id: z.ZodString;
+        required: z.ZodBoolean;
+        dependsOn: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        state: z.ZodEnum<{
+            failed: "failed";
+            ready: "ready";
+            registered: "registered";
+            starting: "starting";
+            stopped: "stopped";
+            stopping: "stopping";
+        }>;
+        health: z.ZodEnum<{
+            degraded: "degraded";
+            healthy: "healthy";
+            unhealthy: "unhealthy";
+            unknown: "unknown";
+        }>;
+        ready: z.ZodBoolean;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>>;
+export type ApplicationSnapshot = z.infer<typeof ApplicationSnapshotSchema>;
+export declare const ApplicationResourceShutdownSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    state: z.ZodEnum<{
+        closed: "closed";
+        "force-failed": "force-failed";
+        "not-started": "not-started";
+    }>;
+    failures: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        admission: "admission";
+        close: "close";
+        completion: "completion";
+        drain: "drain";
+        force: "force";
+        ready: "ready";
+        start: "start";
+    }>>>;
+}, z.core.$strip>>;
+export type ApplicationResourceShutdown = z.infer<typeof ApplicationResourceShutdownSchema>;
+export declare const ApplicationShutdownResultSchema: z.ZodReadonly<z.ZodObject<{
+    outcome: z.ZodEnum<{
+        clean: "clean";
+        forced: "forced";
+    }>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        deadline: "deadline";
+        signal: "signal";
+    }>>;
+    cleanupComplete: z.ZodBoolean;
+    acceptedOperations: z.ZodNumber;
+    completedOperations: z.ZodNumber;
+    pendingOperations: z.ZodNumber;
+    pendingOperationsAtForce: z.ZodNumber;
+    resources: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        id: z.ZodString;
+        state: z.ZodEnum<{
+            closed: "closed";
+            "force-failed": "force-failed";
+            "not-started": "not-started";
+        }>;
+        failures: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            admission: "admission";
+            close: "close";
+            completion: "completion";
+            drain: "drain";
+            force: "force";
+            ready: "ready";
+            start: "start";
+        }>>>;
+    }, z.core.$strip>>>>;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>>;
+export type ApplicationShutdownResult = z.infer<typeof ApplicationShutdownResultSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/application/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/application/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB,aAIS,CAAC;AAC1C,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,0BAA0B;;;;;;;;EAQrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,uBAAuB;;;;;EAA0D,CAAC;AAC/F,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;;;;;EAOrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAI9E,eAAO,MAAM,kCAAkC;;;;;kBAOlC,CAAC;AACd,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;kBAS7B,CAAC;AACd,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAazB,CAAC;AACd,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;kBAQjC,CAAC;AACd,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAY/B,CAAC;AACd,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/application/server-resource.d.ts

@@ -0,0 +1,12 @@
+import type { ManagedServerHandle } from '../server/shutdown';
+import { type ManagedResource } from './resource';
+export interface ManagedServerResourceConfig<TRuntime> {
+    readonly id: string;
+    readonly server: ManagedServerHandle<TRuntime> | (() => ManagedServerHandle<TRuntime>);
+    readonly dependsOn?: readonly string[];
+    readonly required?: boolean;
+    readonly retryAfterSeconds?: number;
+}
+/** Adapt an existing managed server without duplicating its shutdown state machine. */
+export declare function managedServerResource<TRuntime>(config: ManagedServerResourceConfig<TRuntime>): ManagedResource;
+//# sourceMappingURL=server-resource.d.ts.map

package/dist/application/server-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-resource.d.ts","sourceRoot":"","sources":["../../src/application/server-resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAkB,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAEzE,MAAM,WAAW,2BAA2B,CAAC,QAAQ;IACnD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,mBAAmB,CAAC,QAAQ,CAAC,CAAC,CAAC;IACvF,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC;AAED,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,QAAQ,EAC5C,MAAM,EAAE,2BAA2B,CAAC,QAAQ,CAAC,GAC5C,eAAe,CAoDjB"}

package/dist/application-grammy.d.ts

@@ -0,0 +1,2 @@
+export { createGrammyWebhookResource, type GrammyPollingResourceConfig, type GrammyUpdate, type GrammyWebhookResource, type GrammyWebhookResourceConfig, GrammyWebhookUnavailableError, grammyPollingResource, } from './application/grammy';
+//# sourceMappingURL=application-grammy.d.ts.map

package/dist/application-grammy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-grammy.d.ts","sourceRoot":"","sources":["../src/application-grammy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,KAAK,2BAA2B,EAChC,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,6BAA6B,EAC7B,qBAAqB,GACtB,MAAM,sBAAsB,CAAC"}

package/dist/application-grammy.js

@@ -0,0 +1,165 @@
+import {
+  defineManagedResource
+} from "./index-yr276yz0.js";
+import"./index-1bx83sw4.js";
+
+// src/application/grammy.ts
+import { Context } from "grammy";
+if (typeof Context !== "function") {
+  throw new TypeError("[stitchkit] stitchkit/application/grammy requires the grammY peer");
+}
+function reportIsolated(callback, error) {
+  if (!callback)
+    return;
+  Promise.resolve().then(() => callback(error)).catch(() => {});
+}
+function grammyPollingResource(config) {
+  let completion;
+  let stopPromise;
+  const stop = () => {
+    if (!stopPromise) {
+      stopPromise = Promise.resolve().then(() => config.bot.stop());
+      stopPromise.catch((error) => reportIsolated(config.onError, error));
+    }
+    return stopPromise;
+  };
+  return defineManagedResource({
+    id: config.id,
+    ...config.dependsOn && { dependsOn: config.dependsOn },
+    ...config.required !== undefined && { required: config.required },
+    start() {
+      let resolveReady = () => {
+        return;
+      };
+      let rejectReady = () => {
+        return;
+      };
+      let becameReady = false;
+      const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+      });
+      const polling = config.bot.start({
+        ...config.polling,
+        onStart: async (botInfo) => {
+          await config.onStart?.(botInfo);
+          becameReady = true;
+          resolveReady();
+        }
+      });
+      completion = polling.then(() => {
+        if (!becameReady) {
+          rejectReady(new Error("[stitchkit] grammY polling stopped before reaching readiness"));
+        }
+      }, (error) => {
+        if (!becameReady)
+          rejectReady(error);
+        reportIsolated(config.onError, error);
+        throw error;
+      });
+      completion.catch(() => {
+        return;
+      });
+      return { ready, completion };
+    },
+    stopAdmission() {
+      return stop();
+    },
+    async drain() {
+      await completion;
+    },
+    async close() {
+      await stop();
+      if (completion)
+        await completion.catch(() => {
+          return;
+        });
+    },
+    async force() {
+      await stop();
+      if (completion)
+        await completion.catch(() => {
+          return;
+        });
+    }
+  });
+}
+
+class GrammyWebhookUnavailableError extends Error {
+  code = "GRAMMY_WEBHOOK_NOT_ACCEPTING";
+  constructor() {
+    super("grammY webhook resource is not accepting updates");
+    this.name = "GrammyWebhookUnavailableError";
+  }
+}
+function createGrammyWebhookResource(config) {
+  let accepting = false;
+  let pending = 0;
+  const waiters = new Set;
+  const waitForIdle = (signal) => {
+    if (pending === 0 || signal.aborted)
+      return Promise.resolve();
+    return new Promise((resolve) => {
+      const finish = () => {
+        signal.removeEventListener("abort", finish);
+        waiters.delete(finish);
+        resolve();
+      };
+      waiters.add(finish);
+      signal.addEventListener("abort", finish, { once: true });
+    });
+  };
+  const resource = defineManagedResource({
+    id: config.id,
+    ...config.dependsOn && { dependsOn: config.dependsOn },
+    ...config.required !== undefined && { required: config.required },
+    async start(context) {
+      await config.bot.init(context.signal);
+    },
+    activate() {
+      accepting = true;
+    },
+    stopAdmission() {
+      accepting = false;
+    },
+    drain(context) {
+      return waitForIdle(context.signal);
+    },
+    close() {
+      accepting = false;
+    },
+    async force(context) {
+      accepting = false;
+      await waitForIdle(context.signal);
+      if (pending > 0) {
+        throw new Error("[stitchkit] grammY webhook middleware remained active at force deadline");
+      }
+    }
+  });
+  return {
+    resource,
+    async handleUpdate(update, webhookReplyEnvelope) {
+      if (!accepting)
+        throw new GrammyWebhookUnavailableError;
+      pending += 1;
+      try {
+        await config.bot.handleUpdate(update, webhookReplyEnvelope);
+      } catch (error) {
+        reportIsolated(config.onError, error);
+        throw error;
+      } finally {
+        pending -= 1;
+        if (pending === 0) {
+          for (const waiter of waiters)
+            waiter();
+          waiters.clear();
+        }
+      }
+    }
+  };
+}
+export {
+  GrammyWebhookUnavailableError,
+  createGrammyWebhookResource,
+  grammyPollingResource
+};

package/dist/application.d.ts

@@ -0,0 +1,10 @@
+export { type ActivityId, ActivityIdSchema, type ActivityLiveState, ActivityLiveStateSchema, type ActivityProjection, type ActivityProjectionConfig, type ActivityProjectionSubscriberError, type ActivitySnapshot, ActivitySnapshotSchema, type ActivityStageId, ActivityStageIdSchema, type ActivityStageSnapshot, ActivityStageSnapshotSchema, type ActivityToken, type ActivityTransition, createActivityProjection, } from './application/activity';
+export { type ApplicationEventSink, type ApplicationEventSinkConfig, type ApplicationLifecycleEvent, ApplicationLifecycleEventSchema, applicationLifecycleEvent, createApplicationEventSink, } from './application/events';
+export { type ApplicationHealthHandlerOptions, ApplicationHealthHandlerOptionsSchema, createApplicationHealthHandler, } from './application/health';
+export { type ApplicationAdmission, ApplicationAdmissionError, type ApplicationConfig, type ApplicationHandle, type ApplicationOperationLease, createApplication, } from './application/kernel';
+export { type ApplicationSnapshotSink, type ApplicationSnapshotSinkConfig, type ApplicationSnapshotSinkError, type ApplicationSnapshotSinkStatus, ApplicationSnapshotSinkStatusSchema, createApplicationSnapshotSink, type RevisionedApplicationSnapshot, } from './application/latest-sink';
+export { defineManagedResource, type ManagedResource, type ManagedResourceContext, type ManagedResourceStartResult, } from './application/resource';
+export { createManagedSchedule, type ManagedSchedule, type ManagedScheduleClock, type ManagedScheduleConfig, type ManagedScheduleDescriptor, ManagedScheduleDescriptorSchema, type ManagedScheduleErrorPolicy, ManagedScheduleErrorPolicySchema, type ManagedScheduleOverlap, ManagedScheduleOverlapSchema, type ManagedScheduleRunContext, type ManagedScheduleStatus, ManagedScheduleStatusSchema, type ManagedScheduleTimer, } from './application/schedule';
+export { type ApplicationAdmissionSnapshot, ApplicationAdmissionSnapshotSchema, type ApplicationHealth, ApplicationHealthSchema, type ApplicationId, ApplicationIdSchema, type ApplicationLifecycle, ApplicationLifecycleSchema, type ApplicationResourceShutdown, ApplicationResourceShutdownSchema, type ApplicationShutdownResult, ApplicationShutdownResultSchema, type ApplicationSnapshot, ApplicationSnapshotSchema, type ManagedResourceSnapshot, ManagedResourceSnapshotSchema, type ManagedResourceState, ManagedResourceStateSchema, } from './application/schemas';
+export { type ManagedServerResourceConfig, managedServerResource, } from './application/server-resource';
+//# sourceMappingURL=application.d.ts.map

package/dist/application.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../src/application.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,gBAAgB,EAChB,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,iCAAiC,EACtC,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,wBAAwB,GACzB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,+BAA+B,EACpC,qCAAqC,EACrC,8BAA8B,GAC/B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,oBAAoB,EACzB,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,mCAAmC,EACnC,6BAA6B,EAC7B,KAAK,6BAA6B,GACnC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,0BAA0B,GAChC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,0BAA0B,EAC/B,gCAAgC,EAChC,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,oBAAoB,GAC1B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,4BAA4B,EACjC,kCAAkC,EAClC,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,KAAK,2BAA2B,EAChC,iCAAiC,EACjC,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,uBAAuB,EAC5B,6BAA6B,EAC7B,KAAK,oBAAoB,EACzB,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,2BAA2B,EAChC,qBAAqB,GACtB,MAAM,+BAA+B,CAAC"}