stitchkit 0.59.0 → 0.59.2

package/dist/application/health.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { ApplicationHandle } from './kernel';
+export declare const ApplicationHealthHandlerOptionsSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        liveness: "liveness";
+        readiness: "readiness";
+    }>;
+    retryAfterSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ApplicationHealthHandlerOptions = z.input<typeof ApplicationHealthHandlerOptionsSchema>;
+/** Fetch-clean liveness/readiness response with only the sanitized application snapshot. */
+export declare function createApplicationHealthHandler(application: Pick<ApplicationHandle, 'getSnapshot'>, options: ApplicationHealthHandlerOptions): () => Response;
+//# sourceMappingURL=health.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../src/application/health.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD,eAAO,MAAM,qCAAqC;;;;;;iBAGhD,CAAC;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,qCAAqC,CAC7C,CAAC;AAEF,4FAA4F;AAC5F,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,aAAa,CAAC,EACnD,OAAO,EAAE,+BAA+B,GACvC,MAAM,QAAQ,CAahB"}

package/dist/application/kernel.d.ts

@@ -0,0 +1,31 @@
+import type { ShutdownOptions } from '../server/shutdown';
+import type { ManagedResource } from './resource';
+import { type ApplicationShutdownResult, type ApplicationSnapshot } from './schemas';
+export interface ApplicationConfig {
+    readonly id: string;
+    readonly resources?: readonly ManagedResource[];
+    readonly onSnapshot?: (snapshot: ApplicationSnapshot) => void | Promise<void>;
+}
+export interface ApplicationOperationLease {
+    readonly released: boolean;
+    release(): void;
+}
+export interface ApplicationAdmission {
+    acquire(): ApplicationOperationLease | null;
+    run<T>(work: () => T | Promise<T>): Promise<T>;
+}
+export interface ApplicationHandle {
+    readonly id: string;
+    readonly admission: ApplicationAdmission;
+    start(): Promise<ApplicationSnapshot>;
+    getSnapshot(): ApplicationSnapshot;
+    subscribe(listener: (snapshot: ApplicationSnapshot) => void): () => void;
+    shutdown(options?: ShutdownOptions): Promise<ApplicationShutdownResult>;
+}
+export declare class ApplicationAdmissionError extends Error {
+    readonly code = "APPLICATION_NOT_ACCEPTING";
+    constructor();
+}
+/** Compose process-local resources into one deterministic application lifetime. */
+export declare function createApplication(config: ApplicationConfig): ApplicationHandle;
+//# sourceMappingURL=kernel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../src/application/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAG1D,OAAO,KAAK,EACV,eAAe,EAGhB,MAAM,YAAY,CAAC;AACpB,OAAO,EAKL,KAAK,yBAAyB,EAE9B,KAAK,mBAAmB,EAGzB,MAAM,WAAW,CAAC;AAyBnB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IAChD,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,mBAAmB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,IAAI,yBAAyB,GAAG,IAAI,CAAC;IAC5C,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,KAAK,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACtC,WAAW,IAAI,mBAAmB,CAAC;IACnC,SAAS,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,mBAAmB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACzE,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;CACzE;AAED,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,QAAQ,CAAC,IAAI,+BAA+B;IAE5C,cAGC;CACF;AA2BD,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,iBAAiB,CAwlB9E"}

package/dist/application/latest-sink.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const ApplicationSnapshotSinkStatusSchema: z.ZodReadonly<z.ZodObject<{
+    accepting: z.ZodBoolean;
+    received: z.ZodNumber;
+    accepted: z.ZodNumber;
+    rejected: z.ZodNumber;
+    delivered: z.ZodNumber;
+    coalesced: z.ZodNumber;
+    failed: z.ZodNumber;
+    inFlight: z.ZodBoolean;
+    pending: z.ZodBoolean;
+    lastAcceptedRevision: z.ZodOptional<z.ZodNumber>;
+    lastDeliveredRevision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>;
+export type ApplicationSnapshotSinkStatus = z.infer<typeof ApplicationSnapshotSinkStatusSchema>;
+export interface RevisionedApplicationSnapshot {
+    readonly revision: number;
+}
+export interface ApplicationSnapshotSinkError<TSnapshot> {
+    readonly error: unknown;
+    readonly snapshot: TSnapshot;
+}
+export interface ApplicationSnapshotSinkConfig<TSnapshot extends RevisionedApplicationSnapshot> {
+    write(snapshot: TSnapshot): void | Promise<void>;
+    onSinkError?(failure: ApplicationSnapshotSinkError<TSnapshot>): void | Promise<void>;
+}
+export interface ApplicationSnapshotSink<TSnapshot extends RevisionedApplicationSnapshot> {
+    /** Admit a newer absolute snapshot. Returns false after close or for a stale revision. */
+    publish(snapshot: TSnapshot): boolean;
+    getStatus(): ApplicationSnapshotSinkStatus;
+    /** Close admission and deliver the newest snapshot accepted before this boundary. */
+    close(): Promise<ApplicationSnapshotSinkStatus>;
+}
+/**
+ * Deliver absolute state without growing a queue: one write runs while one newer
+ * revision may wait, and that pending value is replaced by every still-newer one.
+ */
+export declare function createApplicationSnapshotSink<TSnapshot extends RevisionedApplicationSnapshot>(config: ApplicationSnapshotSinkConfig<TSnapshot>): ApplicationSnapshotSink<TSnapshot>;
+//# sourceMappingURL=latest-sink.d.ts.map

package/dist/application/latest-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latest-sink.d.ts","sourceRoot":"","sources":["../../src/application/latest-sink.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,mCAAmC;;;;;;;;;;;;mBAenC,CAAC;AACd,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,4BAA4B,CAAC,SAAS;IACrD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B;AAED,MAAM,WAAW,6BAA6B,CAC5C,SAAS,SAAS,6BAA6B;IAE/C,KAAK,CAAC,QAAQ,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,WAAW,CAAC,CAAC,OAAO,EAAE,4BAA4B,CAAC,SAAS,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtF;AAED,MAAM,WAAW,uBAAuB,CAAC,SAAS,SAAS,6BAA6B;IACtF,0FAA0F;IAC1F,OAAO,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC;IACtC,SAAS,IAAI,6BAA6B,CAAC;IAC3C,qFAAqF;IACrF,KAAK,IAAI,OAAO,CAAC,6BAA6B,CAAC,CAAC;CACjD;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,SAAS,SAAS,6BAA6B,EAC3F,MAAM,EAAE,6BAA6B,CAAC,SAAS,CAAC,GAC/C,uBAAuB,CAAC,SAAS,CAAC,CAiGpC"}

package/dist/application/resource.d.ts

@@ -0,0 +1,30 @@
+import type { ApplicationHealth } from './schemas';
+export interface ManagedResourceContext {
+    readonly applicationId: string;
+    readonly signal: AbortSignal;
+    readonly deadlineAt?: number;
+    readonly forceDeadlineAt?: number;
+    now(): number;
+    reportHealth(health: Exclude<ApplicationHealth, 'unknown'>): void;
+}
+export interface ManagedResourceStartResult {
+    /** Resolves when the resource is ready for dependants. */
+    readonly ready?: Promise<void>;
+    /** Long-lived completion; settling before shutdown marks the resource unhealthy. */
+    readonly completion?: Promise<void>;
+}
+export interface ManagedResource {
+    readonly id: string;
+    readonly dependsOn?: readonly string[];
+    readonly required?: boolean;
+    start(context: ManagedResourceContext): void | ManagedResourceStartResult | Promise<void> | Promise<ManagedResourceStartResult | undefined>;
+    /** Runs only after the whole required graph reached readiness. */
+    activate?(context: ManagedResourceContext): void | Promise<void>;
+    stopAdmission?(context: ManagedResourceContext): void | Promise<void>;
+    drain?(context: ManagedResourceContext): void | Promise<void>;
+    /** Must be safe after any invoked start, including a rejected partial start. */
+    close?(context: ManagedResourceContext): void | Promise<void>;
+    force?(context: ManagedResourceContext): void | Promise<void>;
+}
+export declare function defineManagedResource<const TResource extends ManagedResource>(resource: TResource): TResource;
+//# sourceMappingURL=resource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../src/application/resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEnD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,GAAG,IAAI,MAAM,CAAC;IACd,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,iBAAiB,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;CACnE;AAED,MAAM,WAAW,0BAA0B;IACzC,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,oFAAoF;IACpF,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CACH,OAAO,EAAE,sBAAsB,GAE7B,IAAI,GACJ,0BAA0B,GAC1B,OAAO,CAAC,IAAI,CAAC,GACb,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC,CAAC;IACpD,kEAAkE;IAClE,QAAQ,CAAC,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,aAAa,CAAC,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtE,KAAK,CAAC,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,gFAAgF;IAChF,KAAK,CAAC,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,KAAK,CAAC,CAAC,OAAO,EAAE,sBAAsB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D;AAED,wBAAgB,qBAAqB,CAAC,KAAK,CAAC,SAAS,SAAS,eAAe,EAC3E,QAAQ,EAAE,SAAS,GAClB,SAAS,CAEX"}

package/dist/application/schedule.d.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import type { ManagedResource } from './resource';
+export declare const ManagedScheduleOverlapSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    mode: z.ZodLiteral<"skip">;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    mode: z.ZodLiteral<"queue-one">;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    mode: z.ZodLiteral<"parallel">;
+    maxConcurrent: z.ZodNumber;
+}, z.core.$strip>>], "mode">;
+export type ManagedScheduleOverlap = z.infer<typeof ManagedScheduleOverlapSchema>;
+export declare const ManagedScheduleErrorPolicySchema: z.ZodEnum<{
+    continue: "continue";
+    "stop-schedule": "stop-schedule";
+}>;
+export type ManagedScheduleErrorPolicy = z.infer<typeof ManagedScheduleErrorPolicySchema>;
+export declare const ManagedScheduleDescriptorSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    everyMs: z.ZodNumber;
+    startAfterMs: z.ZodNumber;
+    overlap: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        mode: z.ZodLiteral<"skip">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        mode: z.ZodLiteral<"queue-one">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        mode: z.ZodLiteral<"parallel">;
+        maxConcurrent: z.ZodNumber;
+    }, z.core.$strip>>], "mode">;
+    errorPolicy: z.ZodEnum<{
+        continue: "continue";
+        "stop-schedule": "stop-schedule";
+    }>;
+}, z.core.$strip>>;
+export type ManagedScheduleDescriptor = z.infer<typeof ManagedScheduleDescriptorSchema>;
+export declare const ManagedScheduleStatusSchema: z.ZodReadonly<z.ZodObject<{
+    descriptor: z.ZodReadonly<z.ZodObject<{
+        id: z.ZodString;
+        everyMs: z.ZodNumber;
+        startAfterMs: z.ZodNumber;
+        overlap: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            mode: z.ZodLiteral<"skip">;
+        }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+            mode: z.ZodLiteral<"queue-one">;
+        }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+            mode: z.ZodLiteral<"parallel">;
+            maxConcurrent: z.ZodNumber;
+        }, z.core.$strip>>], "mode">;
+        errorPolicy: z.ZodEnum<{
+            continue: "continue";
+            "stop-schedule": "stop-schedule";
+        }>;
+    }, z.core.$strip>>;
+    state: z.ZodEnum<{
+        draining: "draining";
+        inactive: "inactive";
+        running: "running";
+        scheduled: "scheduled";
+        stopped: "stopped";
+    }>;
+    revision: z.ZodNumber;
+    capturedAt: z.ZodString;
+    changedAt: z.ZodString;
+    accepting: z.ZodBoolean;
+    active: z.ZodNumber;
+    queued: z.ZodBoolean;
+    runsStarted: z.ZodNumber;
+    runsCompleted: z.ZodNumber;
+    runsFailed: z.ZodNumber;
+    ticksSkipped: z.ZodNumber;
+    nextRunAt: z.ZodNullable<z.ZodString>;
+    lastScheduledAt: z.ZodNullable<z.ZodString>;
+    lastStartedAt: z.ZodNullable<z.ZodString>;
+    lastFinishedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>>;
+export type ManagedScheduleStatus = z.infer<typeof ManagedScheduleStatusSchema>;
+export interface ManagedScheduleTimer {
+    cancel(): void;
+}
+/** Monotonic timer boundary. Tests can replace it without changing schedule semantics. */
+export interface ManagedScheduleClock {
+    /** Monotonic clock used for cadence and deadline arithmetic. */
+    now(): number;
+    /** Wall clock used only to project portable status timestamps. */
+    wallNow(): Date;
+    schedule(callback: () => void, delayMs: number): ManagedScheduleTimer;
+}
+export interface ManagedScheduleRunContext {
+    readonly applicationId: string;
+    readonly signal: AbortSignal;
+    readonly scheduledAt: number;
+    readonly startedAt: number;
+    now(): number;
+}
+export interface ManagedScheduleConfig {
+    readonly id: string;
+    readonly dependsOn?: readonly string[];
+    readonly required?: boolean;
+    readonly everyMs: number;
+    /** Defaults to one interval. A zero value schedules the first run after activation. */
+    readonly startAfterMs?: number;
+    readonly overlap?: ManagedScheduleOverlap;
+    readonly errorPolicy?: ManagedScheduleErrorPolicy;
+    readonly run: (context: ManagedScheduleRunContext) => void | Promise<void>;
+    readonly onError?: (error: unknown, context: ManagedScheduleRunContext) => void | Promise<void>;
+    readonly clock?: ManagedScheduleClock;
+}
+export interface ManagedSchedule extends ManagedResource {
+    readonly status: ManagedScheduleStatus;
+}
+/** Create one fixed-rate, process-local periodic application resource. */
+export declare function createManagedSchedule(config: ManagedScheduleConfig): ManagedSchedule;
+//# sourceMappingURL=schedule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.d.ts","sourceRoot":"","sources":["../../src/application/schedule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAA0B,MAAM,YAAY,CAAC;AAa1E,eAAO,MAAM,4BAA4B;;;;;;;4BASvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,gCAAgC;;;EAAwC,CAAC;AACtF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;kBAQ/B,CAAC;AACd,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmB3B,CAAC;AACd,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,MAAM,WAAW,oBAAoB;IACnC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,0FAA0F;AAC1F,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,GAAG,IAAI,MAAM,CAAC;IACd,kEAAkE;IAClE,OAAO,IAAI,IAAI,CAAC;IAChB,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,oBAAoB,CAAC;CACvE;AAWD,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,GAAG,IAAI,MAAM,CAAC;CACf;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uFAAuF;IACvF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,sBAAsB,CAAC;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,0BAA0B,CAAC;IAClD,QAAQ,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3E,QAAQ,CAAC,OAAO,CAAC,EAAE,CACjB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,yBAAyB,KAC/B,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,oBAAoB,CAAC;CACvC;AAED,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;CACxC;AAID,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,CA0QpF"}

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"}