@lenso/limits 0.0.0-stage → 0.2.1

package/dist/d1.js

@@ -0,0 +1,164 @@
+import {
+  LimitError2,
+  maxDurationMs,
+  positiveInteger,
+  scopeKey,
+  validateConsume,
+  validateAcquire,
+  validateToken,
+  validateKind,
+  counterDecision,
+  leaseDecision
+} from "./index-bz4qnpx8.js";
+
+// src/d1.ts
+import { and, eq, lte, sql } from "drizzle-orm";
+import { check, index, integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var d1Counters = sqliteTable("lenso_d1_limit_counters", {
+  scope: text("scope").notNull(),
+  kind: text("kind").$type().notNull(),
+  capacity: integer("capacity").notNull(),
+  periodMs: integer("period_ms").notNull(),
+  windowStart: integer("window_start").notNull(),
+  used: integer("used").notNull(),
+  lastNow: integer("last_now").notNull()
+}, (table) => [
+  primaryKey({ columns: [table.scope, table.kind] }),
+  check("lenso_d1_counter_kind", sql`${table.kind} IN ('rate', 'quota')`),
+  check("lenso_d1_counter_capacity", sql`${table.capacity} BETWEEN 1 AND 2147483647`),
+  check("lenso_d1_counter_period", sql`${table.periodMs} BETWEEN 1 AND 31622400000`),
+  check("lenso_d1_counter_used", sql`${table.used} BETWEEN 0 AND ${table.capacity}`),
+  check("lenso_d1_counter_clock", sql`${table.windowStart} >= 0 AND ${table.lastNow} >= 0`)
+]);
+var d1Concurrency = sqliteTable("lenso_d1_limit_concurrency", {
+  scope: text("scope").primaryKey().notNull(),
+  capacity: integer("capacity").notNull(),
+  lastNow: integer("last_now").notNull()
+}, (table) => [
+  check("lenso_d1_lease_capacity", sql`${table.capacity} BETWEEN 1 AND 2147483647`),
+  check("lenso_d1_lease_clock", sql`${table.lastNow} >= 0`)
+]);
+var d1Leases = sqliteTable("lenso_d1_limit_leases", {
+  scope: text("scope").notNull().references(() => d1Concurrency.scope),
+  token: text("token").notNull(),
+  quantity: integer("quantity").notNull(),
+  expiresAt: integer("expires_at").notNull()
+}, (table) => [
+  primaryKey({ columns: [table.scope, table.token] }),
+  index("lenso_d1_lease_expiry").on(table.scope, table.expiresAt),
+  check("lenso_d1_lease_quantity", sql`${table.quantity} BETWEEN 1 AND 2147483647`),
+  check("lenso_d1_lease_expiry_check", sql`${table.expiresAt} >= 0`)
+]);
+var d1LimitSchema = { d1Counters, d1Concurrency, d1Leases };
+var databaseNow = sql`CAST(round((julianday('now') - 2440587.5) * 86400000) AS INTEGER)`;
+function presentLease(scope, row) {
+  return Object.freeze({ ...row, scope: Object.freeze({ ...scope }) });
+}
+function createD1LimitStore(db) {
+  const bucketTime = (key, capacity) => sql`(
+    SELECT ${d1Concurrency.lastNow} FROM ${d1Concurrency}
+    WHERE ${and(eq(d1Concurrency.scope, key), capacity === undefined ? undefined : eq(d1Concurrency.capacity, capacity))}
+  )`;
+  const prune = (key, capacity) => db.delete(d1Leases).where(and(eq(d1Leases.scope, key), lte(d1Leases.expiresAt, bucketTime(key, capacity))));
+  const advanceClock = (key) => db.update(d1Concurrency).set({ lastNow: sql`max(${d1Concurrency.lastNow}, ${databaseNow})` }).where(eq(d1Concurrency.scope, key));
+  return {
+    async consume(kind, input) {
+      validateKind(kind);
+      validateConsume(input);
+      const key = scopeKey(input.scope);
+      const samePolicy = and(eq(d1Counters.capacity, input.capacity), eq(d1Counters.periodMs, input.periodMs));
+      const scopePredicate = and(eq(d1Counters.scope, key), eq(d1Counters.kind, kind));
+      const effectiveNow = sql`max(${d1Counters.lastNow}, ${databaseNow})`;
+      const nextWindow = sql`(${effectiveNow} / ${d1Counters.periodMs}) * ${d1Counters.periodMs}`;
+      const [, admitted, snapshot] = await db.batch([
+        db.insert(d1Counters).values({
+          scope: key,
+          kind,
+          capacity: input.capacity,
+          periodMs: input.periodMs,
+          windowStart: sql`(${databaseNow} / CAST(${input.periodMs} AS INTEGER)) * CAST(${input.periodMs} AS INTEGER)`,
+          used: 0,
+          lastNow: databaseNow
+        }).onConflictDoUpdate({
+          target: [d1Counters.scope, d1Counters.kind],
+          set: {
+            lastNow: effectiveNow,
+            windowStart: nextWindow,
+            used: sql`CASE WHEN ${d1Counters.windowStart} = ${nextWindow} THEN ${d1Counters.used} ELSE 0 END`
+          },
+          setWhere: samePolicy
+        }),
+        db.update(d1Counters).set({ used: sql`${d1Counters.used} + ${input.quantity}` }).where(and(scopePredicate, samePolicy, sql`${input.quantity} <= ${d1Counters.capacity} - ${d1Counters.used}`)).returning(),
+        db.select().from(d1Counters).where(scopePredicate)
+      ]);
+      const state = snapshot[0];
+      if (!state)
+        throw new LimitError2("backend-failure");
+      if (state.capacity !== input.capacity || state.periodMs !== input.periodMs)
+        throw new LimitError2("policy-conflict");
+      return counterDecision(state, input.quantity, admitted.length === 1);
+    },
+    async acquire(input, token) {
+      validateAcquire(input);
+      validateToken(token);
+      const key = scopeKey(input.scope);
+      const used = sql`(
+        SELECT coalesce(sum(${d1Leases.quantity}), 0) FROM ${d1Leases}
+        WHERE ${d1Leases.scope} = ${key}
+      )`;
+      const [, , admitted, headers, holders] = await db.batch([
+        db.insert(d1Concurrency).values({ scope: key, capacity: input.capacity, lastNow: databaseNow }).onConflictDoUpdate({
+          target: d1Concurrency.scope,
+          set: { lastNow: sql`max(${d1Concurrency.lastNow}, ${databaseNow})` },
+          setWhere: eq(d1Concurrency.capacity, input.capacity)
+        }),
+        prune(key, input.capacity),
+        db.insert(d1Leases).select(db.select({
+          scope: sql`${key}`.as("scope"),
+          token: sql`${token}`.as("token"),
+          quantity: sql`${input.quantity}`.as("quantity"),
+          expiresAt: sql`${d1Concurrency.lastNow} + ${input.ttlMs}`.as("expires_at")
+        }).from(d1Concurrency).where(and(eq(d1Concurrency.scope, key), eq(d1Concurrency.capacity, input.capacity), sql`${input.quantity} <= ${d1Concurrency.capacity} - ${used}`))).returning(),
+        db.select().from(d1Concurrency).where(eq(d1Concurrency.scope, key)),
+        db.select().from(d1Leases).where(eq(d1Leases.scope, key))
+      ]);
+      const header = headers[0];
+      if (!header)
+        throw new LimitError2("backend-failure");
+      if (header.capacity !== input.capacity)
+        throw new LimitError2("policy-conflict");
+      const leases = holders.map((row) => presentLease(input.scope, row));
+      return {
+        ...leaseDecision({ ...header, leases }, input.quantity, admitted.length === 1),
+        lease: admitted[0] ? presentLease(input.scope, admitted[0]) : null
+      };
+    },
+    async renew(scope, token, ttlMs) {
+      const key = scopeKey(scope);
+      validateToken(token);
+      positiveInteger(ttlMs, maxDurationMs);
+      const [, , rows] = await db.batch([
+        advanceClock(key),
+        prune(key),
+        db.update(d1Leases).set({ expiresAt: sql`max(${d1Leases.expiresAt}, ${bucketTime(key)} + ${ttlMs})` }).where(and(eq(d1Leases.scope, key), eq(d1Leases.token, token))).returning()
+      ]);
+      return rows[0] ? presentLease(scope, rows[0]) : null;
+    },
+    async release(scope, token) {
+      const key = scopeKey(scope);
+      validateToken(token);
+      await db.batch([
+        advanceClock(key),
+        prune(key),
+        db.delete(d1Leases).where(and(eq(d1Leases.scope, key), eq(d1Leases.token, token)))
+      ]);
+    }
+  };
+}
+export {
+  createD1LimitStore,
+  d1Concurrency,
+  d1Counters,
+  d1Leases,
+  d1LimitSchema
+};

package/dist/index-bz4qnpx8.js

@@ -0,0 +1,138 @@
+// src/contracts.ts
+class LimitError2 extends Error {
+  code;
+  constructor(code, options) {
+    super(`Limit operation failed: ${code}`, options);
+    this.code = code;
+    this.name = "LimitError";
+  }
+}
+var maxDurationMs = 31622400000;
+function positiveInteger(value, maximum = 2147483647) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+    throw new LimitError2("invalid-input");
+}
+function scopeKey(scope) {
+  if (!scope || typeof scope !== "object")
+    throw new LimitError2("invalid-input");
+  const parts = [scope.instance, scope.tenant, scope.key];
+  if (parts.some((part) => typeof part !== "string" || part.length < 1 || part.length > 512))
+    throw new LimitError2("invalid-input");
+  return JSON.stringify(parts);
+}
+function validateConsume(input) {
+  if (!input)
+    throw new LimitError2("invalid-input");
+  scopeKey(input.scope);
+  positiveInteger(input.capacity);
+  positiveInteger(input.quantity);
+  positiveInteger(input.periodMs, maxDurationMs);
+}
+function validateAcquire(input) {
+  if (!input)
+    throw new LimitError2("invalid-input");
+  scopeKey(input.scope);
+  positiveInteger(input.capacity);
+  positiveInteger(input.quantity);
+  positiveInteger(input.ttlMs, maxDurationMs);
+}
+function validateToken(token) {
+  if (typeof token !== "string" || token.length < 1 || token.length > 128)
+    throw new LimitError2("invalid-input");
+}
+function validateKind(kind) {
+  if (kind !== "rate" && kind !== "quota")
+    throw new LimitError2("invalid-input");
+}
+
+// src/state.ts
+function clockTime(now, previous = 0) {
+  if (!Number.isSafeInteger(now) || now < 0 || now > Number.MAX_SAFE_INTEGER - maxDurationMs * 2)
+    throw new LimitError2("invalid-input");
+  return Math.max(now, previous);
+}
+function consumeState(previous, input, clock) {
+  if (previous && (previous.capacity !== input.capacity || previous.periodMs !== input.periodMs))
+    throw new LimitError2("policy-conflict");
+  const now = clockTime(clock, previous?.lastNow);
+  const windowStart = Math.floor(now / input.periodMs) * input.periodMs;
+  const state = {
+    capacity: input.capacity,
+    periodMs: input.periodMs,
+    windowStart,
+    used: previous?.windowStart === windowStart ? previous.used : 0,
+    lastNow: now
+  };
+  const allowed = input.quantity <= state.capacity - state.used;
+  if (allowed)
+    state.used += input.quantity;
+  return { state, result: counterDecision(state, input.quantity, allowed) };
+}
+function counterDecision(state, quantity, allowed) {
+  return {
+    allowed,
+    remaining: state.capacity - state.used,
+    retryAfter: allowed ? 0 : quantity > state.capacity ? null : state.windowStart + state.periodMs - state.lastNow,
+    reason: allowed ? "allowed" : quantity > state.capacity ? "too-large" : "exhausted"
+  };
+}
+function liveState(previous, capacity, clock) {
+  if (previous && previous.capacity !== capacity)
+    throw new LimitError2("policy-conflict");
+  const now = clockTime(clock, previous?.lastNow);
+  return {
+    capacity,
+    lastNow: now,
+    leases: previous?.leases.filter((lease) => lease.expiresAt > now) ?? []
+  };
+}
+function acquireState(state, input, token) {
+  const used = state.leases.reduce((sum, lease) => sum + lease.quantity, 0);
+  const allowed = input.quantity <= state.capacity - used;
+  if (state.leases.some((lease) => lease.token === token))
+    throw new LimitError2("invalid-input");
+  const lease = allowed ? Object.freeze({
+    scope: Object.freeze({ ...input.scope }),
+    token,
+    quantity: input.quantity,
+    expiresAt: state.lastNow + input.ttlMs
+  }) : null;
+  if (lease)
+    state.leases.push(lease);
+  return { ...leaseDecision(state, input.quantity, allowed), lease };
+}
+function leaseDecision(state, quantity, allowed) {
+  const used = state.leases.reduce((sum, lease) => sum + lease.quantity, 0);
+  let retryAfter = allowed ? 0 : null;
+  if (!allowed && quantity <= state.capacity) {
+    let available = state.capacity - used;
+    for (const item of [...state.leases].sort((a, b) => a.expiresAt - b.expiresAt)) {
+      available += item.quantity;
+      if (available >= quantity) {
+        retryAfter = item.expiresAt - state.lastNow;
+        break;
+      }
+    }
+  }
+  return {
+    allowed,
+    remaining: state.capacity - used,
+    retryAfter,
+    reason: allowed ? "allowed" : quantity > state.capacity ? "too-large" : "exhausted"
+  };
+}
+function renewState(state, scope, token, ttlMs) {
+  const index = state.leases.findIndex((lease) => lease.token === token);
+  if (index === -1)
+    return null;
+  const previous = state.leases[index];
+  const renewed = Object.freeze({
+    ...previous,
+    scope: Object.freeze({ ...scope }),
+    expiresAt: Math.max(previous.expiresAt, state.lastNow + ttlMs)
+  });
+  state.leases[index] = renewed;
+  return renewed;
+}
+
+export { LimitError2, maxDurationMs, positiveInteger, scopeKey, validateConsume, validateAcquire, validateToken, validateKind, consumeState, counterDecision, liveState, acquireState, leaseDecision, renewState };

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { type ConfigSource } from "@lenso/core/config";
+import type { Plugin, PluginContext } from "@lenso/core/plugin";
+import type { LimitConfig, LimitStore } from "./contracts";
+import { type Limits } from "./service";
+export type * from "./contracts";
+export { LimitError } from "./contracts";
+export { limitConfig, limitConfigSchema } from "./config";
+export { createMemoryLimitStore } from "./memory";
+export { createLimits } from "./service";
+export type { Limits, LeaseExecution, LeaseRunOptions } from "./service";
+/** The caller supplies exact dependencies; connect borrows a store and acquires no global context. */
+export declare function createLimitsPlugin(options: {
+    readonly id: string;
+    readonly requires?: readonly Plugin<unknown>[];
+    readonly config: LimitConfig | readonly ConfigSource[];
+    readonly connect: (context: PluginContext) => LimitStore | Promise<LimitStore>;
+}): Plugin<Limits>;

package/dist/index.js

@@ -0,0 +1,321 @@
+import {
+  LimitError2,
+  maxDurationMs,
+  positiveInteger,
+  scopeKey,
+  validateConsume,
+  validateAcquire,
+  validateToken,
+  validateKind,
+  consumeState,
+  liveState,
+  acquireState,
+  renewState
+} from "./index-bz4qnpx8.js";
+
+// src/index.ts
+import { bindConfig } from "@lenso/core/config";
+
+// src/config.ts
+import { definePluginConfig } from "@lenso/core/config";
+function validateConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => key !== "failurePolicy") || !("failurePolicy" in value) || !["throw", "deny", "allow"].includes(value.failurePolicy))
+    throw new LimitError2("invalid-input");
+  return { failurePolicy: value.failurePolicy };
+}
+var limitConfigSchema = {
+  "~standard": {
+    version: 1,
+    vendor: "@lenso/limits",
+    validate(value) {
+      try {
+        return { value: validateConfig(value) };
+      } catch {
+        return { issues: [{ message: "Select an explicit limit backend failure policy." }] };
+      }
+    }
+  }
+};
+var limitConfig = definePluginConfig({
+  schema: limitConfigSchema,
+  description: "Explicit admission behavior on limit backend failure",
+  fields: [{ path: ["failurePolicy"], description: "throw, deny, or visibly degraded allow" }],
+  jsonSchema: () => ({
+    type: "object",
+    additionalProperties: false,
+    required: ["failurePolicy"],
+    properties: { failurePolicy: { type: "string", enum: ["throw", "deny", "allow"] } }
+  })
+});
+
+// src/service.ts
+function createLimits(options) {
+  const config = validateConfig(options.config);
+  const owned = new Map;
+  const pending = new Set;
+  const runs = new Map;
+  let closed = false;
+  let closing;
+  function operation(work) {
+    if (closed)
+      return Promise.reject(new LimitError2("closed"));
+    const promise = Promise.resolve().then(work);
+    pending.add(promise);
+    promise.then(() => pending.delete(promise), () => pending.delete(promise));
+    return promise;
+  }
+  function failure(error) {
+    if (error instanceof LimitError2 && error.code !== "backend-failure")
+      throw error;
+    try {
+      options.logger?.warn({ event: "limits.backend-failure", policy: config.failurePolicy }, "Limit backend failed");
+    } catch {}
+    if (config.failurePolicy === "throw")
+      throw new LimitError2("backend-failure", { cause: error });
+    return {
+      allowed: config.failurePolicy === "allow",
+      remaining: null,
+      retryAfter: null,
+      reason: "backend-failure"
+    };
+  }
+  function consume(kind, input) {
+    validateConsume(input);
+    const snapshot = { ...input, scope: { ...input.scope } };
+    return operation(async () => {
+      try {
+        return await options.store.consume(kind, snapshot);
+      } catch (error) {
+        return failure(error);
+      }
+    });
+  }
+  async function releaseOwned(lease) {
+    await options.store.release(lease.scope, lease.token);
+    owned.delete(lease.token);
+  }
+  function validateOwnedScope(lease) {
+    if (!lease || typeof lease !== "object")
+      throw new LimitError2("invalid-input");
+    const key = scopeKey(lease.scope);
+    const previous = owned.get(lease.token);
+    if (previous && scopeKey(previous.scope) !== key)
+      throw new LimitError2("invalid-input");
+  }
+  const service = {
+    consumeRate: (input) => consume("rate", input),
+    consumeQuota: (input) => consume("quota", input),
+    acquire(input) {
+      validateAcquire(input);
+      const snapshot = { ...input, scope: { ...input.scope } };
+      return operation(async () => {
+        try {
+          const result = await options.store.acquire(snapshot, crypto.randomUUID());
+          if (result.lease)
+            owned.set(result.lease.token, result.lease);
+          return result;
+        } catch (error) {
+          return { ...failure(error), lease: null };
+        }
+      });
+    },
+    renew(lease, ttlMs) {
+      validateOwnedScope(lease);
+      const scope = { ...lease.scope };
+      scopeKey(scope);
+      validateToken(lease.token);
+      positiveInteger(ttlMs, maxDurationMs);
+      const token = lease.token;
+      return operation(async () => {
+        const renewed = await options.store.renew(scope, token, ttlMs);
+        if (owned.has(token)) {
+          if (renewed)
+            owned.set(token, renewed);
+          else
+            owned.delete(token);
+        }
+        return renewed;
+      });
+    },
+    release(lease) {
+      validateOwnedScope(lease);
+      validateToken(lease.token);
+      const snapshot = { ...lease, scope: { ...lease.scope } };
+      return operation(() => releaseOwned(snapshot));
+    },
+    withLease(input, execute, runOptions = {}) {
+      validateAcquire(input);
+      input = { ...input, scope: { ...input.scope } };
+      runOptions = { ...runOptions };
+      if (runOptions.renewEveryMs !== undefined) {
+        positiveInteger(runOptions.renewEveryMs);
+        if (runOptions.renewEveryMs >= input.ttlMs)
+          throw new LimitError2("invalid-input");
+      }
+      if (closed)
+        return Promise.reject(new LimitError2("closed"));
+      const controller = new AbortController;
+      const abort = () => controller.abort(runOptions.signal?.reason);
+      if (runOptions.signal?.aborted)
+        abort();
+      else
+        runOptions.signal?.addEventListener("abort", abort, { once: true });
+      let timer;
+      let renewal;
+      let renewalError;
+      let renewalFailed = false;
+      let finishing = false;
+      const stopRenewal = () => {
+        if (timer !== undefined)
+          clearTimeout(timer);
+      };
+      controller.signal.addEventListener("abort", stopRenewal, { once: true });
+      async function run() {
+        let lease = null;
+        let value;
+        const errors = [];
+        try {
+          let scheduleRenewal = function() {
+            if (!lease || finishing || controller.signal.aborted || !runOptions.renewEveryMs)
+              return;
+            timer = setTimeout(() => {
+              renewal = (async () => {
+                try {
+                  const renewed = await service.renew(lease, input.ttlMs);
+                  if (!renewed)
+                    throw new LimitError2("lease-lost");
+                  lease = renewed;
+                  scheduleRenewal();
+                } catch (error) {
+                  renewalFailed = true;
+                  renewalError = error;
+                  controller.abort(error);
+                }
+              })();
+            }, runOptions.renewEveryMs);
+          };
+          controller.signal.throwIfAborted();
+          const acquisition = await service.acquire(input);
+          lease = acquisition.lease;
+          if (!acquisition.allowed)
+            throw new LimitError2("denied");
+          controller.signal.throwIfAborted();
+          scheduleRenewal();
+          value = await execute({ signal: controller.signal, lease });
+          controller.signal.throwIfAborted();
+        } catch (error) {
+          errors.push(error);
+        } finally {
+          finishing = true;
+          stopRenewal();
+          await renewal;
+          if (renewalFailed && !errors.includes(renewalError))
+            errors.push(renewalError);
+          if (lease) {
+            try {
+              await releaseOwned(lease);
+            } catch (error) {
+              errors.push(error);
+            }
+          }
+          runOptions.signal?.removeEventListener("abort", abort);
+          controller.signal.removeEventListener("abort", stopRenewal);
+        }
+        if (errors.length === 1)
+          throw errors[0];
+        if (errors.length > 1)
+          throw new AggregateError(errors, "Lease execution and cleanup failed");
+        return value;
+      }
+      const promise = run();
+      runs.set(controller, promise);
+      promise.then(() => runs.delete(controller), () => runs.delete(controller));
+      return promise;
+    },
+    close() {
+      if (!closing) {
+        closed = true;
+        closing = Promise.resolve().then(async () => {
+          for (const controller of runs.keys())
+            controller.abort(new LimitError2("closed"));
+          await Promise.allSettled([...runs.values(), ...pending]);
+          const results = await Promise.allSettled([...owned.values()].map(releaseOwned));
+          const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+          if (errors.length)
+            throw new AggregateError(errors, "Limit lease cleanup failed");
+        });
+      }
+      return closing;
+    }
+  };
+  return service;
+}
+// src/memory.ts
+function createMemoryLimitStore(options = {}) {
+  const now = options.now ?? Date.now;
+  const counters = new Map;
+  const concurrency = new Map;
+  return {
+    async consume(kind, input) {
+      validateKind(kind);
+      validateConsume(input);
+      const key = JSON.stringify([kind, scopeKey(input.scope)]);
+      const { state, result } = consumeState(counters.get(key), input, now());
+      counters.set(key, state);
+      return result;
+    },
+    async acquire(input, token) {
+      validateAcquire(input);
+      validateToken(token);
+      const key = scopeKey(input.scope);
+      const state = liveState(concurrency.get(key), input.capacity, now());
+      const result = acquireState(state, input, token);
+      concurrency.set(key, state);
+      return result;
+    },
+    async renew(scope, token, ttlMs) {
+      const key = scopeKey(scope);
+      validateToken(token);
+      positiveInteger(ttlMs, maxDurationMs);
+      const previous = concurrency.get(key);
+      if (!previous)
+        return null;
+      const state = liveState(previous, previous.capacity, now());
+      const lease = renewState(state, scope, token, ttlMs);
+      concurrency.set(key, state);
+      return lease;
+    },
+    async release(scope, token) {
+      const key = scopeKey(scope);
+      validateToken(token);
+      const previous = concurrency.get(key);
+      if (!previous)
+        return;
+      const state = liveState(previous, previous.capacity, now());
+      state.leases = state.leases.filter((lease) => lease.token !== token);
+      concurrency.set(key, state);
+    }
+  };
+}
+
+// src/index.ts
+function createLimitsPlugin(options) {
+  return bindConfig(limitConfig, options.config, {
+    id: options.id,
+    requires: options.requires,
+    async setup(context, config) {
+      const store = await options.connect(context);
+      const limits = createLimits({ store, config, logger: context.logger });
+      const close = context.onCleanup(() => limits.close());
+      return { ...limits, close };
+    }
+  });
+}
+export {
+  LimitError2 as LimitError,
+  createLimits,
+  createLimitsPlugin,
+  createMemoryLimitStore,
+  limitConfig,
+  limitConfigSchema
+};

package/dist/memory.d.ts

@@ -0,0 +1,5 @@
+import { type LimitStore } from "./contracts";
+/** State belongs to this store object only. Sharing a process does not imply sharing a store. */
+export declare function createMemoryLimitStore(options?: {
+    now?: () => number;
+}): LimitStore;