skedyul 1.5.13 → 1.7.0

package/dist/schemas/crm-schema.d.ts

@@ -280,6 +280,11 @@ export declare const CRMPageSchemaZ: z.ZodObject<{
     icon: z.ZodOptional<z.ZodString>;
     modelHandle: z.ZodString;
     parentPath: z.ZodOptional<z.ZodString>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        team: "team";
+        private: "private";
+    }>>;
     baseQuery: z.ZodOptional<z.ZodUnknown>;
     blocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
@@ -406,6 +411,11 @@ export declare const CRMSchemaZ: z.ZodObject<{
         icon: z.ZodOptional<z.ZodString>;
         modelHandle: z.ZodString;
         parentPath: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            team: "team";
+            private: "private";
+        }>>;
         baseQuery: z.ZodOptional<z.ZodUnknown>;
         blocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{

package/dist/schemas.d.ts

@@ -327,6 +327,95 @@ export declare const ModelDefinitionSchema: z.ZodObject<{
     addDefaultPages: z.ZodOptional<z.ZodBoolean>;
     addNavigation: z.ZodOptional<z.ZodBoolean>;
     page: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            visible: "visible";
+            encrypted: "encrypted";
+        }>>;
+        default: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        placeholder: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const EntityFieldDefinitionSchema: z.ZodObject<{
+    handle: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        long_string: "long_string";
+        date: "date";
+        datetime: "datetime";
+    }>>;
+    matchCandidate: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export declare const EntityRelationshipDefinitionSchema: z.ZodObject<{
+    handle: z.ZodString;
+    label: z.ZodString;
+    targetEntity: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const EntityDefinitionSchema: z.ZodObject<{
+    handle: z.ZodString;
+    label: z.ZodString;
+    labelPlural: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            long_string: "long_string";
+            date: "date";
+            datetime: "datetime";
+        }>>;
+        matchCandidate: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>]>>>;
+    }, z.core.$strip>>;
+    contextFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            long_string: "long_string";
+            date: "date";
+            datetime: "datetime";
+        }>>;
+        matchCandidate: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>]>>>;
+    }, z.core.$strip>>>;
+    relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        label: z.ZodString;
+        targetEntity: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export declare const RelationshipCardinalitySchema: z.ZodEnum<{
     ONE_TO_ONE: "ONE_TO_ONE";
@@ -3218,6 +3307,17 @@ export declare const InstallConfigSchema: z.ZodObject<{
         addDefaultPages: z.ZodOptional<z.ZodBoolean>;
         addNavigation: z.ZodOptional<z.ZodBoolean>;
         page: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                visible: "visible";
+                encrypted: "encrypted";
+            }>>;
+            default: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            placeholder: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>>;
     relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
         source: z.ZodObject<{
@@ -3341,6 +3441,69 @@ export declare const ProvisionConfigSchema: z.ZodObject<{
         addDefaultPages: z.ZodOptional<z.ZodBoolean>;
         addNavigation: z.ZodOptional<z.ZodBoolean>;
         page: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                visible: "visible";
+                encrypted: "encrypted";
+            }>>;
+            default: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            placeholder: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    entities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        label: z.ZodString;
+        labelPlural: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        fields: z.ZodArray<z.ZodObject<{
+            handle: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                long_string: "long_string";
+                date: "date";
+                datetime: "datetime";
+            }>>;
+            matchCandidate: z.ZodOptional<z.ZodBoolean>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>]>>>;
+        }, z.core.$strip>>;
+        contextFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            handle: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                long_string: "long_string";
+                date: "date";
+                datetime: "datetime";
+            }>>;
+            matchCandidate: z.ZodOptional<z.ZodBoolean>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>]>>>;
+        }, z.core.$strip>>>;
+        relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            handle: z.ZodString;
+            label: z.ZodString;
+            targetEntity: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>>;
     relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
         source: z.ZodObject<{
@@ -4076,6 +4239,69 @@ export declare const SkedyulConfigSchema: z.ZodObject<{
             addDefaultPages: z.ZodOptional<z.ZodBoolean>;
             addNavigation: z.ZodOptional<z.ZodBoolean>;
             page: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                label: z.ZodString;
+                required: z.ZodOptional<z.ZodBoolean>;
+                visibility: z.ZodOptional<z.ZodEnum<{
+                    visible: "visible";
+                    encrypted: "encrypted";
+                }>>;
+                default: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                placeholder: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        entities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            handle: z.ZodString;
+            label: z.ZodString;
+            labelPlural: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            fields: z.ZodArray<z.ZodObject<{
+                handle: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    long_string: "long_string";
+                    date: "date";
+                    datetime: "datetime";
+                }>>;
+                matchCandidate: z.ZodOptional<z.ZodBoolean>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>]>>>;
+            }, z.core.$strip>>;
+            contextFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                handle: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    long_string: "long_string";
+                    date: "date";
+                    datetime: "datetime";
+                }>>;
+                matchCandidate: z.ZodOptional<z.ZodBoolean>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    value: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>]>>>;
+            }, z.core.$strip>>>;
+            relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                handle: z.ZodString;
+                label: z.ZodString;
+                targetEntity: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>>;
         relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
             source: z.ZodObject<{
@@ -4748,6 +4974,9 @@ export type WorkflowDependency = z.infer<typeof WorkflowDependencySchema>;
 export type ResourceDependency = z.infer<typeof ResourceDependencySchema>;
 export type ModelFieldDefinition = z.infer<typeof ModelFieldDefinitionSchema>;
 export type ModelDefinition = z.infer<typeof ModelDefinitionSchema>;
+export type EntityFieldDefinition = z.infer<typeof EntityFieldDefinitionSchema>;
+export type EntityRelationshipDefinition = z.infer<typeof EntityRelationshipDefinitionSchema>;
+export type EntityDefinition = z.infer<typeof EntityDefinitionSchema>;
 export type ChannelCapabilityType = z.infer<typeof ChannelCapabilityTypeSchema>;
 export type ChannelCapability = z.infer<typeof ChannelCapabilitySchema>;
 export type ChannelFieldDefinition = z.infer<typeof ChannelFieldDefinitionSchema>;

package/dist/sequencer/backends/index.d.ts

@@ -0,0 +1,10 @@
+import { platformSequencerBackend } from './platform';
+import { memorySequencerBackend, resetMemorySequencerBackendForTests } from './memory';
+import type { SequencerBackend } from '../types';
+/**
+ * Resolve the active sequencer backend.
+ * Uses platform proxy by default; falls back to in-memory when configured or on local errors.
+ */
+export declare function getSequencerBackend(): SequencerBackend;
+export declare function resetSequencerBackendForTests(): void;
+export { platformSequencerBackend, memorySequencerBackend, resetMemorySequencerBackendForTests };

package/dist/sequencer/backends/memory.d.ts

@@ -0,0 +1,26 @@
+import type { SequencerBackend, SequencerAllowResult } from '../types';
+/**
+ * In-process sequencer backend for local development and tests.
+ */
+export declare class MemorySequencerBackend implements SequencerBackend {
+    private readonly state;
+    private getState;
+    allow(sequencerKey: string, input: {
+        timestamp: number;
+        leaseId?: string;
+        watermarkTtlMs?: number;
+    }): Promise<SequencerAllowResult>;
+    acquire(sequencerKey: string, input: {
+        leaseId: string;
+        timestamp?: number;
+        lockTtlMs?: number;
+        watermarkTtlMs?: number;
+    }): Promise<{
+        acquired: boolean;
+        reason: 'ok' | 'locked';
+    }>;
+    release(sequencerKey: string, leaseId: string): Promise<void>;
+    resetForTests(): void;
+}
+export declare const memorySequencerBackend: MemorySequencerBackend;
+export declare function resetMemorySequencerBackendForTests(): void;

package/dist/sequencer/backends/platform.d.ts

@@ -0,0 +1,22 @@
+import type { SequencerBackend, SequencerAllowResult } from '../types';
+/**
+ * HTTP backend that delegates allow/acquire/release to the Skedyul platform proxy.
+ */
+export declare class PlatformSequencerBackend implements SequencerBackend {
+    allow(sequencerKey: string, input: {
+        timestamp: number;
+        leaseId?: string;
+        watermarkTtlMs?: number;
+    }): Promise<SequencerAllowResult>;
+    acquire(sequencerKey: string, input: {
+        leaseId: string;
+        timestamp?: number;
+        lockTtlMs?: number;
+        watermarkTtlMs?: number;
+    }): Promise<{
+        acquired: boolean;
+        reason: 'ok' | 'locked';
+    }>;
+    release(sequencerKey: string, leaseId: string): Promise<void>;
+}
+export declare const platformSequencerBackend: PlatformSequencerBackend;

package/dist/sequencer/config-loader.d.ts

@@ -0,0 +1,9 @@
+import type { SkedyulConfig } from '../config/app-config';
+import type { SerializableSequencerConfig } from '../config/sequencer-config';
+/**
+ * Register in-process server config for sequencer resolution at runtime.
+ */
+export declare function registerSequencerConfig(config: SkedyulConfig): void;
+export declare function clearRegisteredSequencerConfig(): void;
+export declare function getSequencerDefinitions(): Record<string, SerializableSequencerConfig>;
+export declare function getSequencerConfig(sequencerName: string): SerializableSequencerConfig | undefined;

package/dist/sequencer/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class SequencerContextError extends Error {
+    readonly code = "SEQUENCER_CONTEXT_ERROR";
+    constructor(message: string);
+}
+export declare class SequencerNotFoundError extends Error {
+    readonly code = "SEQUENCER_NOT_FOUND";
+    constructor(name: string);
+}
+export declare class SequencerBackendError extends Error {
+    readonly code = "SEQUENCER_BACKEND_ERROR";
+    readonly statusCode?: number;
+    constructor(message: string, statusCode?: number);
+}
+export declare class SequencerLockError extends Error {
+    readonly code = "SEQUENCER_LOCK_ERROR";
+    constructor(message: string);
+}

package/dist/sequencer/index.d.ts

@@ -0,0 +1,24 @@
+import type { SequencerInput, SequencerAllowInput, SequencerAcquireInput, SequencerReleaseInput, SequencerAllowResult, ResolvedSequencer } from './types';
+import type { RateLimitExecutionContext } from '../ratelimit/types';
+export declare function resolveSequencer(sequencerInput: SequencerInput, ctxOverride?: Partial<RateLimitExecutionContext>): ResolvedSequencer;
+export declare function createSequencerHandle(sequencerInput: SequencerInput, ctxOverride?: Partial<RateLimitExecutionContext>): {
+    allow(input: Omit<SequencerAllowInput, "key">): Promise<SequencerAllowResult>;
+    acquire(input: Omit<SequencerAcquireInput, "key">): Promise<void>;
+    release(input: Omit<SequencerReleaseInput, "key">): Promise<void>;
+};
+export declare function allow(sequencerInput: SequencerInput, input: SequencerAllowInput, ctxOverride?: Partial<RateLimitExecutionContext>): Promise<SequencerAllowResult>;
+export declare function acquire(sequencerInput: SequencerInput, input: SequencerAcquireInput, ctxOverride?: Partial<RateLimitExecutionContext>): Promise<void>;
+export declare function release(sequencerInput: SequencerInput, input: SequencerReleaseInput, ctxOverride?: Partial<RateLimitExecutionContext>): Promise<void>;
+export { registerSequencerConfig, clearRegisteredSequencerConfig, getSequencerConfig, getSequencerDefinitions, } from './config-loader';
+export { resolveSequencerKey } from './resolve-sequencer-key';
+export { getSequencerBackend, resetSequencerBackendForTests, memorySequencerBackend, platformSequencerBackend, resetMemorySequencerBackendForTests, } from './backends';
+export { SequencerContextError, SequencerNotFoundError, SequencerBackendError, SequencerLockError, } from './errors';
+export type { SequencerInput, SequencerSelector, SequencerAllowInput, SequencerAcquireInput, SequencerReleaseInput, SequencerAllowResult, ResolvedSequencer, SequencerBackend, SequencerReason, SequencerExecutionContext, } from './types';
+export type { SequencerScope, SerializableSequencerConfig, SequencerRegistry, } from '../config/sequencer-config';
+export declare const sequencer: {
+    allow: typeof allow;
+    acquire: typeof acquire;
+    release: typeof release;
+    resolve: typeof resolveSequencer;
+    createHandle: typeof createSequencerHandle;
+};

package/dist/sequencer/resolve-sequencer-key.d.ts

@@ -0,0 +1,7 @@
+import type { RateLimitExecutionContext } from '../ratelimit/types';
+import type { SerializableSequencerConfig } from '../config/sequencer-config';
+/**
+ * Build the Redis sequencer key for a named sequencer definition.
+ * Must stay in sync with skedyul-core sequencer validation.
+ */
+export declare function resolveSequencerKey(sequencerName: string, config: SerializableSequencerConfig, ctx: RateLimitExecutionContext, subKey?: string): string;

package/dist/sequencer/types.d.ts

@@ -0,0 +1,50 @@
+import type { SerializableSequencerConfig } from '../config/sequencer-config';
+export type { RateLimitExecutionContext as SequencerExecutionContext } from '../ratelimit/types';
+export type SequencerReason = 'ok' | 'stale' | 'locked' | 'disabled';
+export interface SequencerSelector {
+    sequencer: string;
+    key?: string;
+}
+export type SequencerInput = string | SequencerSelector;
+export interface SequencerAllowInput {
+    key?: string;
+    timestamp: number;
+    leaseId?: string;
+}
+export interface SequencerAcquireInput {
+    key?: string;
+    leaseId: string;
+    timestamp?: number;
+    lockTtlMs?: number;
+}
+export interface SequencerReleaseInput {
+    key?: string;
+    leaseId: string;
+}
+export interface SequencerAllowResult {
+    allowed: boolean;
+    reason: SequencerReason;
+    watermark?: number;
+}
+export interface ResolvedSequencer {
+    name: string;
+    sequencerKey: string;
+    config: SerializableSequencerConfig;
+}
+export interface SequencerBackend {
+    allow(sequencerKey: string, input: {
+        timestamp: number;
+        leaseId?: string;
+        watermarkTtlMs?: number;
+    }): Promise<SequencerAllowResult>;
+    acquire(sequencerKey: string, input: {
+        leaseId: string;
+        timestamp?: number;
+        lockTtlMs?: number;
+        watermarkTtlMs?: number;
+    }): Promise<{
+        acquired: boolean;
+        reason: 'ok' | 'locked';
+    }>;
+    release(sequencerKey: string, leaseId: string): Promise<void>;
+}

package/dist/server.js

@@ -97,6 +97,16 @@ function registerQueueConfig(config) {
   cachedRuntimeQueues = config.queues ?? null;
 }
 
+// src/sequencer/config-loader.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var cachedRuntimeSequencers = null;
+var registeredServerConfig2 = null;
+function registerSequencerConfig(config) {
+  registeredServerConfig2 = config;
+  cachedRuntimeSequencers = config.sequencers ?? null;
+}
+
 // src/server/utils/schema.ts
 var z = __toESM(require("zod"));
 function normalizeBilling(billing) {
@@ -733,7 +743,7 @@ function printStartupLog(config, tools, port) {
 
 // src/server/route-handlers/adapters.ts
 function fromLambdaEvent(event) {
-  const path3 = event.path || event.rawPath || "/";
+  const path4 = event.path || event.rawPath || "/";
   const method = event.httpMethod || event.requestContext?.http?.method || "POST";
   const forwardedProto = event.headers?.["x-forwarded-proto"] ?? event.headers?.["X-Forwarded-Proto"];
   const protocol = forwardedProto ?? "https";
@@ -741,9 +751,9 @@ function fromLambdaEvent(event) {
   const queryString = event.queryStringParameters ? "?" + new URLSearchParams(
     event.queryStringParameters
   ).toString() : "";
-  const url = `${protocol}://${host}${path3}${queryString}`;
+  const url = `${protocol}://${host}${path4}${queryString}`;
   return {
-    path: path3,
+    path: path4,
     method,
     headers: event.headers,
     query: event.queryStringParameters ?? {},
@@ -825,8 +835,8 @@ function parseBodyByContentType(req) {
 }
 
 // src/server/route-handlers/handlers.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
 
 // src/server/core-api-handler.ts
 async function handleCoreMethod(method, params) {
@@ -1293,8 +1303,13 @@ async function handleOAuthCallback(parsedBody, hooks) {
   }
 }
 
+// src/types/webhook.ts
+function isRuntimeWebhookContext(ctx) {
+  return "appInstallationId" in ctx && ctx.appInstallationId !== void 0;
+}
+
 // src/server/handlers/webhook-handler.ts
-function parseWebhookRequest(parsedBody, method, url, path3, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
+function parseWebhookRequest(parsedBody, method, url, path4, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
   const isEnvelope = typeof parsedBody === "object" && parsedBody !== null && "env" in parsedBody && "request" in parsedBody && "context" in parsedBody;
   if (isEnvelope) {
     const envelope = parsedBody;
@@ -1348,7 +1363,7 @@ function parseWebhookRequest(parsedBody, method, url, path3, headers, query, raw
   const webhookRequest = {
     method,
     url,
-    path: path3,
+    path: path4,
     headers,
     query,
     body: parsedBody,
@@ -1377,9 +1392,17 @@ async function executeWebhookHandler(handle, webhookRegistry, data) {
   };
   let webhookResponse;
   try {
+    const rateLimitContext = {
+      app: data.webhookContext.app,
+      appInstallationId: isRuntimeWebhookContext(data.webhookContext) ? data.webhookContext.appInstallationId : void 0,
+      invocation: data.invocation,
+      isProvisionContext: !isRuntimeWebhookContext(data.webhookContext)
+    };
     webhookResponse = await runWithLogContext({ invocation: data.invocation }, async () => {
       return await runWithConfig(requestConfig, async () => {
-        return await webhookDef.handler(data.webhookRequest, data.webhookContext);
+        return await runWithRateLimitExecutionContext(rateLimitContext, async () => {
+          return await webhookDef.handler(data.webhookRequest, data.webhookContext);
+        });
       });
     });
   } catch (err) {
@@ -1406,7 +1429,7 @@ function isMethodAllowed(webhookRegistry, handle, method) {
 
 // src/server/route-handlers/handlers.ts
 function getConfigFilePath() {
-  return process.env.LAMBDA_TASK_ROOT ? path2.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
+  return process.env.LAMBDA_TASK_ROOT ? path3.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json") : ".skedyul/config.json";
 }
 function findToolInRegistry(registry, toolName) {
   for (const [key, t] of Object.entries(registry)) {
@@ -1445,8 +1468,8 @@ function handleHealthRoute(ctx) {
 function handleConfigRoute(ctx) {
   const configFilePath = getConfigFilePath();
   try {
-    if (fs2.existsSync(configFilePath)) {
-      const fileConfig = JSON.parse(fs2.readFileSync(configFilePath, "utf-8"));
+    if (fs3.existsSync(configFilePath)) {
+      const fileConfig = JSON.parse(fs3.readFileSync(configFilePath, "utf-8"));
       return { status: 200, body: fileConfig };
     }
   } catch (err) {
@@ -2134,6 +2157,7 @@ installContextLogger();
 function createSkedyulServer(config) {
   mergeRuntimeEnv();
   registerQueueConfig(config);
+  registerSequencerConfig(config);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
   if (config.coreApi?.service) {