skedyul 1.5.13 → 1.6.0

package/dist/esm/index.mjs

@@ -410,6 +410,8 @@ var CRMPageSchemaZ = z3.object({
   icon: z3.string().optional(),
   modelHandle: z3.string(),
   parentPath: z3.string().optional(),
+  isDefault: z3.boolean().optional(),
+  visibility: z3.enum(["team", "private"]).optional(),
   baseQuery: z3.unknown().optional(),
   blocks: z3.array(CRMBlockSchemaZ).optional()
 });
@@ -1285,7 +1287,8 @@ var ModelDefinitionSchema = z8.object({
   addDefaultPages: z8.boolean().optional(),
   addNavigation: z8.boolean().optional(),
   /** Root path for developer resource UI (e.g., '/access_requests'). Links internal model to a provision.pages entry. */
-  page: z8.string().optional()
+  page: z8.string().optional(),
+  env: EnvSchemaSchema.optional()
 });
 var RelationshipCardinalitySchema = z8.enum([
   "ONE_TO_ONE",
@@ -2097,6 +2100,56 @@ function getQueueConfigWithRetry(queueName) {
   return serializable;
 }
 
+// src/sequencer/config-loader.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var cachedRuntimeSequencers = null;
+function getRuntimeConfigPath2() {
+  if (process.env.LAMBDA_TASK_ROOT) {
+    return path2.join(process.env.LAMBDA_TASK_ROOT, ".skedyul", "config.json");
+  }
+  return path2.join(process.cwd(), ".skedyul", "config.json");
+}
+function loadRuntimeConfigFile2() {
+  const configPath = getRuntimeConfigPath2();
+  if (!fs2.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const raw = fs2.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var registeredServerConfig2 = null;
+function registerSequencerConfig(config) {
+  registeredServerConfig2 = config;
+  cachedRuntimeSequencers = config.sequencers ?? null;
+}
+function clearRegisteredSequencerConfig() {
+  registeredServerConfig2 = null;
+  cachedRuntimeSequencers = null;
+}
+function getSequencerDefinitions() {
+  if (cachedRuntimeSequencers) {
+    return cachedRuntimeSequencers;
+  }
+  if (registeredServerConfig2?.sequencers) {
+    cachedRuntimeSequencers = registeredServerConfig2.sequencers;
+    return cachedRuntimeSequencers;
+  }
+  const fileConfig = loadRuntimeConfigFile2();
+  if (fileConfig?.sequencers) {
+    cachedRuntimeSequencers = fileConfig.sequencers;
+    return cachedRuntimeSequencers;
+  }
+  return {};
+}
+function getSequencerConfig(sequencerName) {
+  return getSequencerDefinitions()[sequencerName];
+}
+
 // src/server/utils/schema.ts
 import * as z9 from "zod";
 function normalizeBilling(billing) {
@@ -2503,25 +2556,28 @@ function createInstanceClient(config) {
         pagination: pagination ?? { page: 1, total: 0, hasMore: false, limit: args?.limit ?? 50 }
       };
     },
-    async get(modelHandle, id) {
+    async get(modelHandle, id, options) {
       const { data } = await callCoreWithConfig("instance.get", {
         modelHandle,
-        id
+        id,
+        ...options?.includeEnv ? { includeEnv: true } : {}
       });
       return data;
     },
-    async create(modelHandle, data) {
+    async create(modelHandle, data, options) {
       const { data: inst } = await callCoreWithConfig("instance.create", {
         modelHandle,
-        data
+        data,
+        ...options?.env ? { env: options.env } : {}
       });
       return inst;
     },
-    async update(modelHandle, id, data) {
+    async update(modelHandle, id, data, options) {
       const { data: inst } = await callCoreWithConfig("instance.update", {
         modelHandle,
         id,
-        data
+        data,
+        ...options?.env ? { env: options.env } : {}
       });
       return inst;
     },
@@ -2620,10 +2676,11 @@ var instance = {
    * const record = await instance.get('phone_number', 'ins_abc123')
    * ```
    */
-  async get(modelHandle, id) {
+  async get(modelHandle, id, options) {
     const { data } = await callCore("instance.get", {
       modelHandle,
-      id
+      id,
+      ...options?.includeEnv ? { includeEnv: true } : {}
     });
     return data;
   },
@@ -2640,10 +2697,11 @@ var instance = {
    * })
    * ```
    */
-  async create(modelHandle, data) {
+  async create(modelHandle, data, options) {
     const { data: instance2 } = await callCore("instance.create", {
       modelHandle,
-      data
+      data,
+      ...options?.env ? { env: options.env } : {}
     });
     return instance2;
   },
@@ -2660,11 +2718,12 @@ var instance = {
    * })
    * ```
    */
-  async update(modelHandle, id, data) {
+  async update(modelHandle, id, data, options) {
     const { data: instance2 } = await callCore("instance.update", {
       modelHandle,
       id,
-      data
+      data,
+      ...options?.env ? { env: options.env } : {}
     });
     return instance2;
   },
@@ -4031,7 +4090,7 @@ function printStartupLog(config, tools, port) {
 
 // src/server/route-handlers/adapters.ts
 function fromLambdaEvent(event2) {
-  const path5 = event2.path || event2.rawPath || "/";
+  const path6 = event2.path || event2.rawPath || "/";
   const method = event2.httpMethod || event2.requestContext?.http?.method || "POST";
   const forwardedProto = event2.headers?.["x-forwarded-proto"] ?? event2.headers?.["X-Forwarded-Proto"];
   const protocol = forwardedProto ?? "https";
@@ -4039,9 +4098,9 @@ function fromLambdaEvent(event2) {
   const queryString = event2.queryStringParameters ? "?" + new URLSearchParams(
     event2.queryStringParameters
   ).toString() : "";
-  const url = `${protocol}://${host}${path5}${queryString}`;
+  const url = `${protocol}://${host}${path6}${queryString}`;
   return {
-    path: path5,
+    path: path6,
     method,
     headers: event2.headers,
     query: event2.queryStringParameters ?? {},
@@ -4123,8 +4182,8 @@ function parseBodyByContentType(req) {
 }
 
 // src/server/route-handlers/handlers.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 
 // src/server/core-api-handler.ts
 async function handleCoreMethod(method, params) {
@@ -4592,7 +4651,7 @@ async function handleOAuthCallback(parsedBody, hooks) {
 }
 
 // src/server/handlers/webhook-handler.ts
-function parseWebhookRequest(parsedBody, method, url, path5, headers, query, rawBody, appIdHeader, appVersionIdHeader) {
+function parseWebhookRequest(parsedBody, method, url, path6, 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;
@@ -4646,7 +4705,7 @@ function parseWebhookRequest(parsedBody, method, url, path5, headers, query, raw
   const webhookRequest = {
     method,
     url,
-    path: path5,
+    path: path6,
     headers,
     query,
     body: parsedBody,
@@ -4675,9 +4734,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) {
@@ -4704,7 +4771,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)) {
@@ -4743,8 +4810,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) {
@@ -5432,6 +5499,7 @@ installContextLogger();
 function createSkedyulServer(config) {
   mergeRuntimeEnv();
   registerQueueConfig(config);
+  registerSequencerConfig(config);
   const registry = config.tools;
   const webhookRegistry = config.webhooks;
   if (config.coreApi?.service) {
@@ -5700,13 +5768,13 @@ function defineNavigation(navigation) {
 }
 
 // src/config/schema-loader.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 import * as os from "os";
 
 // src/config/resolver.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 
 // src/config/utils.ts
 function getAllEnvKeys(config) {
@@ -5809,7 +5877,7 @@ function getApiToken() {
   const config = getConfig();
   return config.apiToken || process.env.SKEDYUL_API_TOKEN || "";
 }
-async function callRateLimitApi(path5, body) {
+async function callRateLimitApi(path6, body) {
   const baseUrl = getApiBaseUrl();
   const token2 = getApiToken();
   if (!baseUrl || !token2) {
@@ -5817,7 +5885,7 @@ async function callRateLimitApi(path5, body) {
       "SKEDYUL_API_URL and SKEDYUL_API_TOKEN are required for platform queue coordination"
     );
   }
-  const response = await fetch(`${baseUrl}/api/internal/ratelimit/${path5}`, {
+  const response = await fetch(`${baseUrl}/api/internal/ratelimit/${path6}`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token2}`,
@@ -5827,11 +5895,11 @@ async function callRateLimitApi(path5, body) {
   });
   const payload = await response.json().catch(() => null);
   if (!response.ok || payload?.success === false) {
-    const message = payload?.errors?.[0]?.message ?? `Queue coordination API ${path5} failed with status ${response.status}`;
+    const message = payload?.errors?.[0]?.message ?? `Queue coordination API ${path6} failed with status ${response.status}`;
     throw new RateLimitBackendError(message, response.status);
   }
   if (!payload?.data) {
-    throw new RateLimitBackendError(`Queue coordination API ${path5} returned empty data`);
+    throw new RateLimitBackendError(`Queue coordination API ${path6} returned empty data`);
   }
   return payload.data;
 }
@@ -6286,6 +6354,406 @@ async function queuedFetchResponse(queueInput, url, init) {
   return queuedFetch(queueInput, () => fetch(url, init));
 }
 
+// src/sequencer/errors.ts
+var SequencerContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "SEQUENCER_CONTEXT_ERROR";
+    this.name = "SequencerContextError";
+  }
+};
+var SequencerNotFoundError = class extends Error {
+  constructor(name) {
+    super(`Sequencer "${name}" is not defined in skedyul.config`);
+    this.code = "SEQUENCER_NOT_FOUND";
+    this.name = "SequencerNotFoundError";
+  }
+};
+var SequencerBackendError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.code = "SEQUENCER_BACKEND_ERROR";
+    this.name = "SequencerBackendError";
+    this.statusCode = statusCode;
+  }
+};
+var SequencerLockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "SEQUENCER_LOCK_ERROR";
+    this.name = "SequencerLockError";
+  }
+};
+
+// src/sequencer/resolve-sequencer-key.ts
+function resolveEndpointHandle2(config, invocation) {
+  if (config.endpoint) {
+    return config.endpoint;
+  }
+  if (invocation?.toolHandle) {
+    return invocation.toolHandle;
+  }
+  if (invocation?.serverHookHandle) {
+    return invocation.serverHookHandle;
+  }
+  throw new SequencerContextError(
+    `Cannot resolve endpoint handle for sequencer scope "${config.scope}". Set endpoint in sequencer config or ensure invocation.toolHandle/serverHookHandle is available.`
+  );
+}
+function appendSubKey2(base, subKey) {
+  return subKey ? `${base}:${subKey}` : base;
+}
+function resolveSequencerKey(sequencerName, config, ctx, subKey) {
+  const { app, appInstallationId, invocation, isProvisionContext: isProvisionContext2 } = ctx;
+  switch (config.scope) {
+    case "provision": {
+      const base = `seq:pv:${app.versionId}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    case "install": {
+      if (!appInstallationId) {
+        throw new SequencerContextError(
+          `Sequencer "${sequencerName}" with scope "install" requires appInstallationId in context`
+        );
+      }
+      const base = `seq:in:${appInstallationId}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    case "provision_endpoint": {
+      if (!isProvisionContext2 && appInstallationId) {
+        throw new SequencerContextError(
+          `Sequencer "${sequencerName}" with scope "provision_endpoint" requires provision context (no install)`
+        );
+      }
+      const endpointHandle = resolveEndpointHandle2(config, invocation);
+      const base = `seq:pep:${app.versionId}:${endpointHandle}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    case "install_endpoint": {
+      if (!appInstallationId) {
+        throw new SequencerContextError(
+          `Sequencer "${sequencerName}" with scope "install_endpoint" requires appInstallationId in context`
+        );
+      }
+      const endpointHandle = resolveEndpointHandle2(config, invocation);
+      const base = `seq:iep:${appInstallationId}:${endpointHandle}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    case "global": {
+      const base = `seq:gl:${app.versionId}:${sequencerName}`;
+      return appendSubKey2(base, subKey);
+    }
+    default: {
+      const _exhaustive = config.scope;
+      throw new SequencerContextError(`Unknown sequencer scope: ${String(_exhaustive)}`);
+    }
+  }
+}
+
+// src/sequencer/backends/platform.ts
+function getApiBaseUrl2() {
+  const config = getConfig();
+  if (config.baseUrl) {
+    return config.baseUrl.replace(/\/+$/, "");
+  }
+  return (process.env.SKEDYUL_API_URL ?? process.env.SKEDYUL_NODE_URL ?? "").replace(/\/+$/, "");
+}
+function getApiToken2() {
+  const config = getConfig();
+  return config.apiToken || process.env.SKEDYUL_API_TOKEN || "";
+}
+async function callSequencerApi(path6, body) {
+  const baseUrl = getApiBaseUrl2();
+  const token2 = getApiToken2();
+  if (!baseUrl || !token2) {
+    throw new SequencerBackendError(
+      "SKEDYUL_API_URL and SKEDYUL_API_TOKEN are required for platform sequencer coordination"
+    );
+  }
+  const response = await fetch(`${baseUrl}/api/internal/sequencer/${path6}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token2}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok || payload?.success === false) {
+    const message = payload?.errors?.[0]?.message ?? `Sequencer coordination API ${path6} failed with status ${response.status}`;
+    throw new SequencerBackendError(message, response.status);
+  }
+  if (!payload?.data) {
+    throw new SequencerBackendError(`Sequencer coordination API ${path6} returned empty data`);
+  }
+  return payload.data;
+}
+var PlatformSequencerBackend = class {
+  async allow(sequencerKey, input) {
+    return callSequencerApi("allow", {
+      sequencerKey,
+      timestamp: input.timestamp,
+      leaseId: input.leaseId,
+      watermarkTtlMs: input.watermarkTtlMs
+    });
+  }
+  async acquire(sequencerKey, input) {
+    return callSequencerApi("acquire", {
+      sequencerKey,
+      leaseId: input.leaseId,
+      timestamp: input.timestamp,
+      lockTtlMs: input.lockTtlMs,
+      watermarkTtlMs: input.watermarkTtlMs
+    });
+  }
+  async release(sequencerKey, leaseId) {
+    await callSequencerApi("release", {
+      sequencerKey,
+      leaseId
+    });
+  }
+};
+var platformSequencerBackend = new PlatformSequencerBackend();
+
+// src/sequencer/backends/memory.ts
+function generateLeaseId2() {
+  return `mem_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+var MemorySequencerBackend = class {
+  constructor() {
+    this.state = /* @__PURE__ */ new Map();
+  }
+  getState(sequencerKey) {
+    let state = this.state.get(sequencerKey);
+    if (!state) {
+      state = { watermark: 0, lockLeaseId: null, lockExpiresAt: 0 };
+      this.state.set(sequencerKey, state);
+    }
+    if (state.lockLeaseId && state.lockExpiresAt <= Date.now()) {
+      state.lockLeaseId = null;
+      state.lockExpiresAt = 0;
+    }
+    return state;
+  }
+  async allow(sequencerKey, input) {
+    void input.watermarkTtlMs;
+    const state = this.getState(sequencerKey);
+    if (input.timestamp < state.watermark) {
+      return { allowed: false, reason: "stale", watermark: state.watermark };
+    }
+    if (state.lockLeaseId && input.leaseId && state.lockLeaseId !== input.leaseId) {
+      return { allowed: false, reason: "locked", watermark: state.watermark };
+    }
+    state.watermark = Math.max(state.watermark, input.timestamp);
+    return { allowed: true, reason: "ok", watermark: state.watermark };
+  }
+  async acquire(sequencerKey, input) {
+    void input.watermarkTtlMs;
+    const state = this.getState(sequencerKey);
+    const leaseId = input.leaseId || generateLeaseId2();
+    if (state.lockLeaseId && state.lockLeaseId !== leaseId) {
+      return { acquired: false, reason: "locked" };
+    }
+    state.lockLeaseId = leaseId;
+    state.lockExpiresAt = Date.now() + (input.lockTtlMs ?? 6e4);
+    if (input.timestamp !== void 0) {
+      state.watermark = Math.max(state.watermark, input.timestamp);
+    }
+    return { acquired: true, reason: "ok" };
+  }
+  async release(sequencerKey, leaseId) {
+    const state = this.state.get(sequencerKey);
+    if (!state || state.lockLeaseId !== leaseId) {
+      return;
+    }
+    state.lockLeaseId = null;
+    state.lockExpiresAt = 0;
+  }
+  resetForTests() {
+    this.state.clear();
+  }
+};
+var memorySequencerBackend = new MemorySequencerBackend();
+
+// src/sequencer/backends/index.ts
+var cachedBackend2 = null;
+function shouldForceMemoryBackend2() {
+  const flag = process.env.SKEDYUL_SEQUENCER_MEMORY;
+  return flag === "1" || flag === "true";
+}
+function getSequencerBackend() {
+  if (cachedBackend2) {
+    return cachedBackend2;
+  }
+  if (shouldForceMemoryBackend2()) {
+    cachedBackend2 = memorySequencerBackend;
+    return cachedBackend2;
+  }
+  cachedBackend2 = createResilientBackend2();
+  return cachedBackend2;
+}
+function createResilientBackend2() {
+  return {
+    async allow(sequencerKey, input) {
+      try {
+        return await platformSequencerBackend.allow(sequencerKey, input);
+      } catch (error) {
+        if (shouldFallbackToMemory2(error)) {
+          return memorySequencerBackend.allow(sequencerKey, input);
+        }
+        throw error;
+      }
+    },
+    async acquire(sequencerKey, input) {
+      try {
+        return await platformSequencerBackend.acquire(sequencerKey, input);
+      } catch (error) {
+        if (shouldFallbackToMemory2(error)) {
+          return memorySequencerBackend.acquire(sequencerKey, input);
+        }
+        throw error;
+      }
+    },
+    async release(sequencerKey, leaseId) {
+      if (leaseId.startsWith("mem_")) {
+        return memorySequencerBackend.release(sequencerKey, leaseId);
+      }
+      try {
+        await platformSequencerBackend.release(sequencerKey, leaseId);
+      } catch (error) {
+        if (shouldFallbackToMemory2(error)) {
+          return memorySequencerBackend.release(sequencerKey, leaseId);
+        }
+        throw error;
+      }
+    }
+  };
+}
+function shouldFallbackToMemory2(error) {
+  if (shouldForceMemoryBackend2()) {
+    return true;
+  }
+  if (error instanceof SequencerBackendError) {
+    if (error.statusCode === 404 || error.statusCode === 503) {
+      return true;
+    }
+  }
+  if (error instanceof TypeError) {
+    return true;
+  }
+  const nodeEnv = process.env.NODE_ENV;
+  return nodeEnv === "development" || nodeEnv === "test";
+}
+function resetSequencerBackendForTests() {
+  cachedBackend2 = null;
+}
+
+// src/sequencer/index.ts
+function normalizeSequencerInput(input) {
+  if (typeof input === "string") {
+    return { name: input };
+  }
+  return { name: input.sequencer, subKey: input.key };
+}
+function mergeContext(ctxOverride) {
+  const ctx = getRateLimitExecutionContext();
+  if (!ctx?.app?.versionId) {
+    throw new SequencerContextError(
+      "Cannot resolve sequencer without app context. Ensure sequencer runs inside a tool/hook/webhook handler."
+    );
+  }
+  return { ...ctx, ...ctxOverride };
+}
+function resolveSequencer(sequencerInput, ctxOverride) {
+  const ctx = mergeContext(ctxOverride);
+  const { name, subKey } = normalizeSequencerInput(sequencerInput);
+  const config = getSequencerConfig(name);
+  if (!config) {
+    throw new SequencerNotFoundError(name);
+  }
+  const sequencerKey = resolveSequencerKey(name, config, ctx, subKey);
+  return { name, sequencerKey, config };
+}
+function createSequencerHandle(sequencerInput, ctxOverride) {
+  return {
+    allow(input) {
+      return allow(sequencerInput, input, ctxOverride);
+    },
+    acquire(input) {
+      return acquire(sequencerInput, input, ctxOverride);
+    },
+    release(input) {
+      return release(sequencerInput, input, ctxOverride);
+    }
+  };
+}
+function disabledAllowResult() {
+  return { allowed: true, reason: "disabled" };
+}
+async function allow(sequencerInput, input, ctxOverride) {
+  const { name, subKey } = normalizeSequencerInput(sequencerInput);
+  const config = getSequencerConfig(name);
+  if (!config || config.enabled !== true) {
+    return disabledAllowResult();
+  }
+  const resolvedSubKey = input.key ?? subKey;
+  const resolved = resolveSequencer(
+    { sequencer: name, key: resolvedSubKey },
+    ctxOverride
+  );
+  const backend = getSequencerBackend();
+  return backend.allow(resolved.sequencerKey, {
+    timestamp: input.timestamp,
+    leaseId: input.leaseId,
+    watermarkTtlMs: resolved.config.watermarkTtlMs
+  });
+}
+async function acquire(sequencerInput, input, ctxOverride) {
+  const { name, subKey } = normalizeSequencerInput(sequencerInput);
+  const config = getSequencerConfig(name);
+  if (!config || config.enabled !== true) {
+    return;
+  }
+  const resolvedSubKey = input.key ?? subKey;
+  const resolved = resolveSequencer(
+    { sequencer: name, key: resolvedSubKey },
+    ctxOverride
+  );
+  const backend = getSequencerBackend();
+  const result = await backend.acquire(resolved.sequencerKey, {
+    leaseId: input.leaseId,
+    timestamp: input.timestamp,
+    lockTtlMs: input.lockTtlMs ?? resolved.config.lockTtlMs,
+    watermarkTtlMs: resolved.config.watermarkTtlMs
+  });
+  if (!result.acquired) {
+    throw new SequencerLockError(
+      `Sequencer "${name}" lock held by another lease (${result.reason})`
+    );
+  }
+}
+async function release(sequencerInput, input, ctxOverride) {
+  const { name, subKey } = normalizeSequencerInput(sequencerInput);
+  const config = getSequencerConfig(name);
+  if (!config || config.enabled !== true) {
+    return;
+  }
+  const resolvedSubKey = input.key ?? subKey;
+  const resolved = resolveSequencer(
+    { sequencer: name, key: resolvedSubKey },
+    ctxOverride
+  );
+  const backend = getSequencerBackend();
+  await backend.release(resolved.sequencerKey, input.leaseId);
+}
+var sequencer = {
+  allow,
+  acquire,
+  release,
+  resolve: resolveSequencer,
+  createHandle: createSequencerHandle
+};
+
 // src/triggers/types.ts
 import { z as z12 } from "zod/v4";
 var CRMDataSchema = z12.object({
@@ -6390,16 +6858,16 @@ function evaluateTemplate(template, context) {
   const templateRegex = /\{\{\s*([^}]+)\s*\}\}/g;
   const singleMatch = template.match(/^\{\{\s*([^}]+)\s*\}\}$/);
   if (singleMatch) {
-    const path5 = singleMatch[1].trim();
-    return resolvePath(context, path5);
+    const path6 = singleMatch[1].trim();
+    return resolvePath(context, path6);
   }
-  return template.replace(templateRegex, (_, path5) => {
-    const value = resolvePath(context, path5.trim());
+  return template.replace(templateRegex, (_, path6) => {
+    const value = resolvePath(context, path6.trim());
     return value === void 0 || value === null ? "" : String(value);
   });
 }
-function resolvePath(obj, path5) {
-  const parts = path5.split(".");
+function resolvePath(obj, path6) {
+  const parts = path6.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -6420,14 +6888,14 @@ function evaluateCondition(condition, context) {
   const expression = match[1].trim();
   const eqMatch = expression.match(/^(.+?)\s*==\s*['"](.+)['"]$/);
   if (eqMatch) {
-    const [, path5, expectedValue] = eqMatch;
-    const actualValue = resolvePath(context, path5.trim());
+    const [, path6, expectedValue] = eqMatch;
+    const actualValue = resolvePath(context, path6.trim());
     return actualValue === expectedValue;
   }
   const neqMatch = expression.match(/^(.+?)\s*!=\s*['"](.+)['"]$/);
   if (neqMatch) {
-    const [, path5, expectedValue] = neqMatch;
-    const actualValue = resolvePath(context, path5.trim());
+    const [, path6, expectedValue] = neqMatch;
+    const actualValue = resolvePath(context, path6.trim());
     return actualValue !== expectedValue;
   }
   const value = resolvePath(context, expression);
@@ -7879,6 +8347,10 @@ export {
   SelectComponentDefinitionSchema,
   SemanticMemoryConfigSchema2 as SemanticMemoryConfigSchema,
   SenderContextSchema,
+  SequencerBackendError,
+  SequencerContextError,
+  SequencerLockError,
+  SequencerNotFoundError,
   SkedyulConfigSchema,
   SkillExampleSchema,
   SkillMetadataSchema,
@@ -7934,6 +8406,7 @@ export {
   buildAgentContext,
   calculateWaitTime,
   call,
+  clearRegisteredSequencerConfig,
   communicationChannel,
   compileAgent,
   compileWorkflow,
@@ -7953,6 +8426,7 @@ export {
   createPermissionError,
   createQueueHandle,
   createRateLimitError,
+  createSequencerHandle,
   createServerHookContext,
   createSuccessResponse,
   createTimeoutError,
@@ -7991,6 +8465,8 @@ export {
   getRateLimitExecutionContext,
   getRequiredInstallEnvKeys,
   getRetryDelay,
+  getSequencerConfig,
+  getSequencerDefinitions,
   instance,
   isChannelDependency,
   isCronContext,
@@ -8006,20 +8482,29 @@ export {
   isTimeInWindowSlot2 as isTimeInWindowSlot,
   isWorkflowDependency,
   matchesTrigger,
+  memorySequencerBackend,
   parseCRMSchema,
   parseEstimationFromBilling,
+  platformSequencerBackend,
   queuedFetch,
   queuedFetchResponse,
   registerQueueConfig,
+  registerSequencerConfig,
   report,
   requeue,
+  resetSequencerBackendForTests,
   resolveInputMappings,
   resolveQueue,
+  resolveSequencer,
   resource,
   runWithConfig,
   runWithRateLimitExecutionContext,
   safeParseCRMSchema,
   safeParseConfig,
+  sequencer,
+  acquire as sequencerAcquire,
+  allow as sequencerAllow,
+  release as sequencerRelease,
   server,
   toGsm7,
   token,