@tstdl/base 0.93.86 → 0.93.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.86",
+  "version": "0.93.89",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -97,9 +97,11 @@
     "./pool": "./pool/index.js",
     "./process": "./process/index.js",
     "./promise": "./promise/index.js",
-    "./queue": "./queue/index.js",
-    "./queue/postgres": "./queue/postgres/index.js",
+    "./task-queue": "./task-queue/index.js",
+    "./task-queue/postgres": "./task-queue/postgres/index.js",
     "./random": "./random/index.js",
+    "./rate-limit": "./rate-limit/index.js",
+    "./rate-limit/postgres": "./rate-limit/postgres/index.js",
     "./reflection": "./reflection/index.js",
     "./rpc": "./rpc/index.js",
     "./rpc/endpoints": "./rpc/endpoints/index.js",
@@ -122,6 +124,7 @@
     "./text": "./text/index.js",
     "./threading": "./threading/index.js",
     "./types": "./types/index.js",
+    "./unit-test": "./unit-test/index.js",
     "./utils": "./utils/index.js",
     "./utils/array": "./utils/array/index.js",
     "./utils/async-hook": "./utils/async-hook/index.js",
@@ -140,12 +143,12 @@
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
     "ts-pattern": "^5.9",
-    "type-fest": "^5.3"
+    "type-fest": "^5.4"
   },
   "peerDependencies": {
     "@genkit-ai/google-genai": "^1.27",
     "@google-cloud/storage": "^7.18",
-    "@google/genai": "^1.35",
+    "@google/genai": "^1.38",
     "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
@@ -159,7 +162,7 @@
     "minio": "^8.0",
     "mjml": "^4.18",
     "nodemailer": "^7.0",
-    "pg": "^8.16",
+    "pg": "^8.17",
     "playwright": "^1.57",
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",
@@ -181,6 +184,8 @@
     "@types/node": "25",
     "@types/nodemailer": "7.0",
     "@types/pg": "8.16",
+    "@vitest/coverage-v8": "4.0",
+    "@vitest/ui": "4.0",
     "concurrently": "9.2",
     "drizzle-kit": "0.31",
     "eslint": "9.39",
@@ -190,7 +195,7 @@
     "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.52",
+    "typescript-eslint": "8.53",
     "vite-tsconfig-paths": "6.0",
     "vitest": "4.0"
   },

package/pool/pool.js

@@ -86,7 +86,7 @@ export class Pool {
                     await this.disposeInstance(instance);
                 }
                 catch (disposeError) {
-                    this.logger.error(disposeError);
+                    this.logger.error('Error disposing instance', disposeError);
                 }
             }
             else {

package/rate-limit/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rate-limiter.js';
+export * from './provider.js';

package/rate-limit/index.js

@@ -0,0 +1,2 @@
+export * from './rate-limiter.js';
+export * from './provider.js';

package/rate-limit/postgres/drizzle/0000_watery_rage.sql

@@ -0,0 +1,7 @@
+CREATE TABLE "rate_limit"."rate_limit" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"resource" text NOT NULL,
+	"tokens" double precision NOT NULL,
+	"last_refill_timestamp" timestamp with time zone NOT NULL,
+	CONSTRAINT "rate_limit_resource_unique" UNIQUE("resource")
+);

package/{queue → rate-limit}/postgres/drizzle/meta/0000_snapshot.json

@@ -1,12 +1,12 @@
 {
-  "id": "1a2e63a5-b780-4f4d-ae41-ce8369aa1cf0",
+  "id": "0270ac12-b454-4601-b7e9-f825d71b1f4e",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
   "tables": {
-    "queue.job": {
-      "name": "job",
-      "schema": "queue",
+    "rate_limit.rate_limit": {
+      "name": "rate_limit",
+      "schema": "rate_limit",
       "columns": {
         "id": {
           "name": "id",
@@ -15,46 +15,22 @@
           "notNull": true,
           "default": "gen_random_uuid()"
         },
-        "queue": {
-          "name": "queue",
+        "resource": {
+          "name": "resource",
           "type": "text",
           "primaryKey": false,
           "notNull": true
         },
-        "tag": {
-          "name": "tag",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "priority": {
-          "name": "priority",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "enqueue_timestamp": {
-          "name": "enqueue_timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "tries": {
-          "name": "tries",
-          "type": "integer",
+        "tokens": {
+          "name": "tokens",
+          "type": "double precision",
           "primaryKey": false,
           "notNull": true
         },
-        "last_dequeue_timestamp": {
-          "name": "last_dequeue_timestamp",
+        "last_refill_timestamp": {
+          "name": "last_refill_timestamp",
           "type": "timestamp with time zone",
           "primaryKey": false,
-          "notNull": false
-        },
-        "data": {
-          "name": "data",
-          "type": "jsonb",
-          "primaryKey": false,
           "notNull": true
         }
       },
@@ -62,12 +38,11 @@
       "foreignKeys": {},
       "compositePrimaryKeys": {},
       "uniqueConstraints": {
-        "job_queue_tag_unique": {
-          "name": "job_queue_tag_unique",
+        "rate_limit_resource_unique": {
+          "name": "rate_limit_resource_unique",
           "nullsNotDistinct": false,
           "columns": [
-            "queue",
-            "tag"
+            "resource"
           ]
         }
       },

package/rate-limit/postgres/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1768608042456,
+      "tag": "0000_watery_rage",
+      "breakpoints": true
+    }
+  ]
+}

package/{queue → rate-limit}/postgres/drizzle.config.js

@@ -5,7 +5,7 @@ export default defineConfig({
     out: relative('./', resolve(__dirname, './drizzle/').replace('dist', 'source')),
     schema: resolve(__dirname, './schemas.js'),
     migrations: {
-        schema: 'queue',
+        schema: 'rate_limit',
         table: '_migrations',
     },
 });

package/rate-limit/postgres/index.d.ts

@@ -0,0 +1,4 @@
+export * from './module.js';
+export * from './postgres-rate-limiter.js';
+export * from './rate-limit.model.js';
+export * from './rate-limiter.provider.js';

package/rate-limit/postgres/index.js

@@ -0,0 +1,4 @@
+export * from './module.js';
+export * from './postgres-rate-limiter.js';
+export * from './rate-limit.model.js';
+export * from './rate-limiter.provider.js';

package/rate-limit/postgres/module.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from '../../injector/injector.js';
+import { type DatabaseConfig } from '../../orm/server/index.js';
+export declare class PostgresRateLimiterModuleConfig {
+    database?: DatabaseConfig;
+}
+/**
+ * configure rate limit module
+ */
+export declare function configurePostgresRateLimiter({ injector, ...config }?: PostgresRateLimiterModuleConfig & {
+    injector?: Injector;
+}): void;
+export declare function migratePostgresRateLimiterSchema(): Promise<void>;

package/rate-limit/postgres/module.js

@@ -0,0 +1,28 @@
+import { inject } from '../../injector/index.js';
+import { Injector } from '../../injector/injector.js';
+import { Database, migrate } from '../../orm/server/index.js';
+import { RateLimiterProvider } from '../provider.js';
+import { RateLimiter } from '../rate-limiter.js';
+import { PostgresRateLimiter } from './postgres-rate-limiter.js';
+import { PostgresRateLimiterProvider } from './rate-limiter.provider.js';
+export class PostgresRateLimiterModuleConfig {
+    database;
+}
+/**
+ * configure rate limit module
+ */
+export function configurePostgresRateLimiter({ injector, ...config } = {}) {
+    const targetInjector = injector ?? Injector;
+    targetInjector.register(PostgresRateLimiterModuleConfig, { useValue: config });
+    targetInjector.registerSingleton(RateLimiterProvider, { useToken: PostgresRateLimiterProvider });
+    targetInjector.registerSingleton(RateLimiter, { useToken: PostgresRateLimiter });
+}
+export async function migratePostgresRateLimiterSchema() {
+    const connection = inject(PostgresRateLimiterModuleConfig, undefined, { optional: true })?.database?.connection;
+    const database = inject(Database, connection);
+    await migrate(database, {
+        migrationsSchema: 'rate_limit',
+        migrationsTable: '_migrations',
+        migrationsFolder: import.meta.resolve('./drizzle'),
+    });
+}

package/rate-limit/postgres/postgres-rate-limiter.d.ts

@@ -0,0 +1,9 @@
+import { RateLimiter } from '../rate-limiter.js';
+export declare class PostgresRateLimiter extends RateLimiter {
+    #private;
+    readonly burstCapacity: number;
+    readonly refillIntervalMs: number;
+    readonly refillRate: number;
+    tryAcquire(resource: string, cost?: number): Promise<boolean>;
+    refund(resource: string, amount: number): Promise<void>;
+}

package/rate-limit/postgres/postgres-rate-limiter.js

@@ -0,0 +1,56 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { gte, sql } from 'drizzle-orm';
+import { injectArgument, provide, Singleton } from '../../injector/index.js';
+import { least, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { DatabaseConfig, injectRepository } from '../../orm/server/index.js';
+import { isDefined, isString } from '../../utils/type-guards.js';
+import { RateLimiter } from '../rate-limiter.js';
+import { PostgresRateLimiterModuleConfig } from './module.js';
+import { PostgresRateLimit } from './rate-limit.model.js';
+import { rateLimit } from './schemas.js';
+let PostgresRateLimiter = class PostgresRateLimiter extends RateLimiter {
+    #repository = injectRepository(PostgresRateLimit);
+    #config = injectArgument(this);
+    burstCapacity = isString(this.#config) ? 100 : this.#config.burstCapacity;
+    refillIntervalMs = isString(this.#config) ? 1000 : this.#config.refillIntervalMs;
+    refillRate = this.burstCapacity / this.refillIntervalMs;
+    async tryAcquire(resource, cost = 1) {
+        if (cost <= 0) {
+            return true;
+        }
+        if (cost > this.burstCapacity) {
+            return false;
+        }
+        // Atomic Upsert with Conditional Update
+        // 1. If row exists: Calculate new balance (current + refill), cap at burst.
+        //    Update ONLY IF new balance >= cost.
+        // 2. If row missing: Insert with (burst - cost).
+        // RETURNING clause will only return a row if the INSERT or UPDATE actually happened.
+        const nowMs = sql `(EXTRACT(EPOCH FROM ${TRANSACTION_TIMESTAMP}) * 1000)`;
+        const lastRefillMs = sql `(EXTRACT(EPOCH FROM ${rateLimit.lastRefillTimestamp}) * 1000)`;
+        const tokensToAdd = sql `(${nowMs} - ${lastRefillMs}) * ${this.refillRate}`;
+        const newTokensExpression = least(this.burstCapacity, sql `${rateLimit.tokens} + ${tokensToAdd}`);
+        const result = await this.#repository.tryUpsert('resource', { resource, tokens: this.burstCapacity - cost, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { tokens: sql `${newTokensExpression} - ${cost}`, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { set: gte(newTokensExpression, cost) });
+        return isDefined(result);
+    }
+    async refund(resource, amount) {
+        if (amount <= 0) {
+            return;
+        }
+        await this.#repository.updateByQuery({ resource }, { tokens: least(this.burstCapacity, sql `${rateLimit.tokens} + ${amount}`) });
+    }
+};
+PostgresRateLimiter = __decorate([
+    Singleton({
+        argumentIdentityProvider: JSON.stringify,
+        providers: [
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresRateLimiterModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+        ],
+    })
+], PostgresRateLimiter);
+export { PostgresRateLimiter };

package/rate-limit/postgres/rate-limit.model.d.ts

@@ -0,0 +1,8 @@
+import { BaseEntity } from '../../orm/index.js';
+import type { Timestamp } from '../../orm/types.js';
+export declare class PostgresRateLimit extends BaseEntity {
+    static readonly entityName = "RateLimit";
+    resource: string;
+    tokens: number;
+    lastRefillTimestamp: Timestamp;
+}

package/rate-limit/postgres/rate-limit.model.js

@@ -0,0 +1,35 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseEntity, Table, Unique } from '../../orm/index.js';
+import { TimestampProperty } from '../../orm/schemas/timestamp.js';
+import { NumberProperty, StringProperty } from '../../schema/index.js';
+let PostgresRateLimit = class PostgresRateLimit extends BaseEntity {
+    static entityName = 'RateLimit';
+    resource;
+    tokens;
+    lastRefillTimestamp;
+};
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], PostgresRateLimit.prototype, "resource", void 0);
+__decorate([
+    NumberProperty(),
+    __metadata("design:type", Number)
+], PostgresRateLimit.prototype, "tokens", void 0);
+__decorate([
+    TimestampProperty(),
+    __metadata("design:type", Number)
+], PostgresRateLimit.prototype, "lastRefillTimestamp", void 0);
+PostgresRateLimit = __decorate([
+    Table('rate_limit', { schema: 'rate_limit' }),
+    Unique(['resource'])
+], PostgresRateLimit);
+export { PostgresRateLimit };

package/rate-limit/postgres/rate-limiter.provider.d.ts

@@ -0,0 +1,6 @@
+import { RateLimiterProvider } from '../provider.js';
+import { RateLimiter, type RateLimiterConfig } from '../rate-limiter.js';
+export declare class PostgresRateLimiterProvider extends RateLimiterProvider {
+    #private;
+    get(resource: string, config: RateLimiterConfig): RateLimiter;
+}

package/rate-limit/postgres/rate-limiter.provider.js

@@ -0,0 +1,21 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { inject, Singleton } from '../../injector/index.js';
+import { Injector } from '../../injector/injector.js';
+import { RateLimiterProvider } from '../provider.js';
+import { RateLimiter } from '../rate-limiter.js';
+import { PostgresRateLimiter } from './postgres-rate-limiter.js';
+let PostgresRateLimiterProvider = class PostgresRateLimiterProvider extends RateLimiterProvider {
+    #injector = inject(Injector);
+    get(resource, config) {
+        return this.#injector.resolve(PostgresRateLimiter, { ...config, resource });
+    }
+};
+PostgresRateLimiterProvider = __decorate([
+    Singleton()
+], PostgresRateLimiterProvider);
+export { PostgresRateLimiterProvider };

package/rate-limit/postgres/schemas.d.ts

@@ -0,0 +1,3 @@
+import { PostgresRateLimit } from './rate-limit.model.js';
+export declare const rateLimitSchema: import("../../orm/server/index.js").DatabaseSchema<"rate_limit">;
+export declare const rateLimit: import("../../orm/server/types.js").PgTableFromType<typeof PostgresRateLimit, "rate_limit">;

package/rate-limit/postgres/schemas.js

@@ -0,0 +1,4 @@
+import { databaseSchema } from '../../orm/server/index.js';
+import { PostgresRateLimit } from './rate-limit.model.js';
+export const rateLimitSchema = databaseSchema('rate_limit');
+export const rateLimit = rateLimitSchema.getTable(PostgresRateLimit);

package/rate-limit/provider.d.ts

@@ -0,0 +1,9 @@
+import type { RateLimiter, RateLimiterConfig } from './rate-limiter.js';
+export declare abstract class RateLimiterProvider {
+    /**
+     * Gets a RateLimiter instance for the specified resource and configuration.
+     * @param resource The unique name of the rate limiter.
+     * @param config The configuration for the rate limiter.
+     */
+    abstract get(resource: string, config: RateLimiterConfig): RateLimiter;
+}

package/rate-limit/provider.js

@@ -0,0 +1,2 @@
+export class RateLimiterProvider {
+}

package/rate-limit/rate-limiter.d.ts

@@ -0,0 +1,35 @@
+import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import { Transactional } from '../orm/server/transactional.js';
+export type RateLimiterConfig = {
+    /**
+     * Maximum number of tokens the bucket can hold.
+     */
+    burstCapacity: number;
+    /**
+     * Time in milliseconds in which the bucket refills to its full burst capacity.
+     */
+    refillIntervalMs: number;
+};
+export type RateLimiterArgument = string | (RateLimiterConfig & {
+    resource: string;
+});
+export declare abstract class RateLimiter extends Transactional implements Resolvable<RateLimiterArgument> {
+    readonly [resolveArgumentType]: RateLimiterArgument;
+    abstract readonly burstCapacity: number;
+    abstract readonly refillIntervalMs: number;
+    /**
+     * Attempts to acquire the specified number of tokens for a resource.
+     * @param resource The resource identifier to acquire tokens for.
+     * @param cost The number of tokens to acquire. Defaults to 1.
+     * @param transaction Optional transaction to participate in.
+     * @returns A promise that resolves to true if tokens were successfully acquired, false otherwise.
+     */
+    abstract tryAcquire(resource: string, cost?: number): Promise<boolean>;
+    /**
+     * Refunds tokens back to the bucket for a resource.
+     * @param resource The resource identifier to refund tokens to.
+     * @param amount The number of tokens to refund.
+     * @param transaction Optional transaction to participate in.
+     */
+    abstract refund(resource: string, amount: number): Promise<void>;
+}

package/rate-limit/rate-limiter.js

@@ -0,0 +1,3 @@
+import { Transactional } from '../orm/server/transactional.js';
+export class RateLimiter extends Transactional {
+}

package/rate-limit/tests/postgres-rate-limiter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/rate-limit/tests/postgres-rate-limiter.test.js

@@ -0,0 +1,92 @@
+import { afterAll, describe, expect, it } from 'vitest';
+import { RateLimiterProvider } from '../../rate-limit/index.js';
+import { setupIntegrationTest } from '../../unit-test/index.js';
+import { timeout } from '../../utils/timing.js';
+describe('PostgresRateLimiter Integration Tests', () => {
+    let injector;
+    let rateLimiter;
+    const limiterName = `test-limiter-${Date.now()}`;
+    async function getLimiter() {
+        if (injector == null) {
+            ({ injector } = await setupIntegrationTest({ modules: { rateLimiter: true } }));
+        }
+        const rateLimiterProvider = injector.resolve(RateLimiterProvider);
+        return rateLimiterProvider.get(limiterName, {
+            burstCapacity: 10,
+            refillIntervalMs: 1000, // 10 tokens per second -> 1 token per 100ms
+        });
+    }
+    afterAll(async () => {
+        await injector?.dispose();
+    }, 15000);
+    it('should acquire tokens successfully', async () => {
+        rateLimiter = await getLimiter();
+        const resource = 'res-1';
+        const result = await rateLimiter.tryAcquire(resource, 5);
+        expect(result).toBe(true);
+        const result2 = await rateLimiter.tryAcquire(resource, 5);
+        expect(result2).toBe(true);
+        const result3 = await rateLimiter.tryAcquire(resource, 1);
+        expect(result3).toBe(false);
+    });
+    it('should refill tokens over time', async () => {
+        rateLimiter = await getLimiter();
+        const resource = 'res-2';
+        await rateLimiter.tryAcquire(resource, 10);
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
+        // Wait for 2 tokens (200ms)
+        await timeout(250);
+        expect(await rateLimiter.tryAcquire(resource, 2)).toBe(true);
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
+    });
+    it('should refund tokens', async () => {
+        rateLimiter = await getLimiter();
+        const resource = 'res-3';
+        await rateLimiter.tryAcquire(resource, 10);
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
+        await rateLimiter.refund(resource, 5);
+        expect(await rateLimiter.tryAcquire(resource, 5)).toBe(true);
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
+    });
+    it('should handle fractional tokens', async () => {
+        rateLimiter = await getLimiter();
+        const resource = 'res-4';
+        await rateLimiter.tryAcquire(resource, 9.5);
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
+        expect(await rateLimiter.tryAcquire(resource, 0.5)).toBe(true);
+    });
+    it('should handle concurrent acquisitions', async () => {
+        rateLimiter = await getLimiter();
+        const resource = 'res-concurrent';
+        // Initialize
+        await rateLimiter.tryAcquire(resource, 0);
+        const results = await Promise.all(Array.from({ length: 20 }).map(() => rateLimiter.tryAcquire(resource, 1)));
+        const successCount = results.filter(Boolean).length;
+        expect(successCount).toBe(10);
+    }, 15000);
+    it('should always allow zero or negative cost', async () => {
+        rateLimiter = await getLimiter();
+        const resource = 'res-zero';
+        expect(await rateLimiter.tryAcquire(resource, 0)).toBe(true);
+        expect(await rateLimiter.tryAcquire(resource, -1)).toBe(true);
+    });
+    it('should reject cost greater than burst capacity', async () => {
+        rateLimiter = await getLimiter();
+        const resource = 'res-large';
+        // Burst capacity is 10
+        expect(await rateLimiter.tryAcquire(resource, 11)).toBe(false);
+    });
+    it('should cap tokens at burst capacity on refill', async () => {
+        rateLimiter = await getLimiter();
+        const resource = 'res-refill-cap';
+        // Drain
+        await rateLimiter.tryAcquire(resource, 10);
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
+        // Wait for full refill (1s) + extra
+        await timeout(1200);
+        // Should only have 10 tokens
+        expect(await rateLimiter.tryAcquire(resource, 10)).toBe(true);
+        // Should be empty again immediately
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
+    });
+});

package/signals/implementation/configure.d.ts

@@ -1 +1,4 @@
+/**
+ * registers default signals implementation in container
+ */
 export declare function configureDefaultSignalsImplementation(): void;

package/signals/implementation/configure.js

@@ -6,6 +6,9 @@ import { toObservable } from './to-observable.js';
 import { toSignal } from './to-signal.js';
 import { untracked } from './untracked.js';
 import { signal } from './writable-signal.js';
+/**
+ * registers default signals implementation in container
+ */
 export function configureDefaultSignalsImplementation() {
     configureSignals({
         signal,

package/sse/data-stream-source.d.ts

@@ -13,7 +13,7 @@ export declare class DataStreamSource<T> {
     #private;
     readonly eventSource: ServerSentEventsSource;
     readonly closed: import("../signals/api.js").Signal<boolean>;
-    constructor(options?: DataStreamSourceOptions);
+    constructor({ delta, errorFormatter }?: DataStreamSourceOptions);
     static fromIterable<T>(iterable: AnyIterable<T>, options?: DataStreamSourceOptions): DataStreamSource<T>;
     send(data: T): Promise<void>;
     close(): Promise<void>;

package/sse/data-stream-source.js

@@ -14,14 +14,14 @@ const jsonDiffPatch = createDiffPatch({
     },
 });
 export class DataStreamSource {
-    #options;
+    #useDelta;
     #errorFormatter;
     eventSource = new ServerSentEventsSource();
     closed = this.eventSource.closed;
     #lastData;
-    constructor(options = { delta: true }) {
-        this.#options = options;
-        this.#errorFormatter = options.errorFormatter ?? defaultErrorFormatter;
+    constructor({ delta = true, errorFormatter } = {}) {
+        this.#useDelta = delta;
+        this.#errorFormatter = errorFormatter ?? defaultErrorFormatter;
     }
     static fromIterable(iterable, options) {
         const source = new DataStreamSource(options);
@@ -47,14 +47,14 @@ export class DataStreamSource {
         if (this.eventSource.closed()) {
             throw new Error('Cannot send data to a closed DataStreamSource connection.');
         }
-        if (this.#options.delta && isDefined(this.#lastData)) {
+        if (this.#useDelta && isDefined(this.#lastData)) {
             const delta = jsonDiffPatch.diff(this.#lastData, data);
             await this.eventSource.sendJson({ name: 'delta', data: delta });
         }
         else {
             await this.eventSource.sendJson({ name: 'data', data });
         }
-        if (this.#options.delta) {
+        if (this.#useDelta) {
             this.#lastData = data;
         }
     }