@tstdl/base 0.93.127 → 0.93.129

package/object-storage/s3/s3.object-storage.js

@@ -240,16 +240,16 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
     async getDownloadUrl(key, expirationTimestamp, responseHeaders) {
         const bucketKey = this.getBucketKey(key);
         const expiration = getExpiration(expirationTimestamp);
-        const expiresHeader = responseHeaders?.['Expires'];
+        const expiresHeader = responseHeaders?.['Expires'] ?? responseHeaders?.['Response-Expires'];
         const mappedExpiresHeader = isDefined(expiresHeader) ? (isDate(expiresHeader) ? expiresHeader : new Date(expiresHeader)) : undefined;
         return await getSignedUrl(this.client, new GetObjectCommand({
             Bucket: this.bucket,
             Key: bucketKey,
-            ResponseContentType: responseHeaders?.['Content-Type'],
-            ResponseContentDisposition: responseHeaders?.['Content-Disposition'],
-            ResponseCacheControl: responseHeaders?.['Cache-Control'],
-            ResponseContentLanguage: responseHeaders?.['Content-Language'],
-            ResponseContentEncoding: responseHeaders?.['Content-Encoding'],
+            ResponseContentType: responseHeaders?.['Content-Type'] ?? responseHeaders?.['Response-Content-Type'],
+            ResponseContentDisposition: responseHeaders?.['Content-Disposition'] ?? responseHeaders?.['Response-Content-Disposition'],
+            ResponseCacheControl: responseHeaders?.['Cache-Control'] ?? responseHeaders?.['Response-Cache-Control'],
+            ResponseContentLanguage: responseHeaders?.['Content-Language'] ?? responseHeaders?.['Response-Content-Language'],
+            ResponseContentEncoding: responseHeaders?.['Content-Encoding'] ?? responseHeaders?.['Response-Content-Encoding'],
             ResponseExpires: mappedExpiresHeader,
         }), { expiresIn: expiration });
     }

package/object-storage/s3/tests/s3.object-storage.integration.test.js

@@ -1,27 +1,20 @@
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { setupIntegrationTest } from '../../../testing/index.js';
 import { readBinaryStream } from '../../../utils/stream/stream-reader.js';
-import { configureS3ObjectStorage } from '../s3.object-storage-provider.js';
+import { isUndefined } from '../../../utils/type-guards.js';
 import { S3ObjectStorage } from '../s3.object-storage.js';
 describe('S3ObjectStorage Integration', () => {
     let storage;
-    const bucketName = 'integration-test-bucket';
     beforeAll(async () => {
         const { injector } = await setupIntegrationTest({
             modules: { objectStorage: true },
         });
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucket: bucketName,
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
-        });
         storage = await injector.resolveAsync(S3ObjectStorage, 'test-module');
     });
     afterAll(async () => {
+        if (isUndefined(storage)) {
+            return;
+        }
         const objects = await storage.getObjects();
         for (const obj of objects) {
             await storage.deleteObject(obj.key);
@@ -80,7 +73,7 @@ describe('S3ObjectStorage Integration', () => {
         const key = 'signed-download.txt';
         await storage.uploadObject(key, new TextEncoder().encode('signed download'));
         const url = await storage.getDownloadUrl(key, Date.now() + 60000);
-        expect(url).toContain('http://127.0.0.1:9000');
+        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):9000/);
         const response = await fetch(url);
         expect(response.status).toBe(200);
         expect(await response.text()).toBe('signed download');
@@ -154,15 +147,8 @@ describe('S3ObjectStorage Integration', () => {
         expect(stat.metadata['extra-key']).toBe('extra-value');
     });
     it('should work with bucket per module', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucketPerModule: true,
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
         });
         const moduleName = `test-bucket-per-module-${Math.floor(Math.random() * 1000000)}`;
         const perModuleStorage = await injector.resolveAsync(S3ObjectStorage, moduleName);
@@ -177,7 +163,7 @@ describe('S3ObjectStorage Integration', () => {
         const metadata = { 's3-test': 'true' };
         await storage.uploadObject(key, content, { metadata });
         const obj = await storage.getObject(key);
-        expect(await obj.getResourceUri()).toBe(`s3://integration-test-bucket/test-module/${key}`);
+        expect(await obj.getResourceUri()).toBe(`s3://test-module/${key}`);
         expect(await obj.getContentLength()).toBe(content.length);
         expect(await obj.getMetadata()).toMatchObject(metadata);
         expect(new TextDecoder().decode(await obj.getContent())).toBe('s3 object');
@@ -242,25 +228,22 @@ describe('S3ObjectStorage Integration', () => {
         const key = 'signed-download-expires.txt';
         await storage.uploadObject(key, new TextEncoder().encode('signed download expires'));
         const url = await storage.getDownloadUrl(key, Date.now() + 60000, {
-            'Expires': new Date(Date.now() + 60000).toUTCString(),
+            Expires: new Date(Date.now() + 60000).toUTCString(),
         });
-        expect(url).toContain('http://127.0.0.1:9000');
+        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):9000/);
         const response = await fetch(url);
         expect(response.status).toBe(200);
     });
     it('should handle Forbidden error in ensureBucketExists with wrong credentials', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'wrong',
-            secretKey: 'wrong',
-            bucket: 'forbidden-bucket',
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
+            s3: {
+                accessKey: 'wrong',
+                secretKey: 'wrong',
+            },
         });
         try {
-            await injector.resolveAsync(S3ObjectStorage, 'test-module');
+            await injector.resolveAsync(S3ObjectStorage, 'forbidden-bucket');
             expect.fail('Should have thrown');
         }
         catch (error) {
@@ -268,17 +251,10 @@ describe('S3ObjectStorage Integration', () => {
         }
     });
     it('should copy object between different storages', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucket: 'another-bucket',
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
         });
-        const anotherStorage = await injector.resolveAsync(S3ObjectStorage, 'another-module');
+        const anotherStorage = await injector.resolveAsync(S3ObjectStorage, 'another-bucket');
         const sourceKey = 'cross-storage-source.txt';
         const destKey = 'cross-storage-dest.txt';
         await storage.uploadObject(sourceKey, new TextEncoder().encode('cross storage content'));
@@ -288,15 +264,8 @@ describe('S3ObjectStorage Integration', () => {
         expect(new TextDecoder().decode(content)).toBe('cross storage content');
     });
     it('should cover ensureBucketExists with region', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucketPerModule: true,
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
         });
         const perModuleStorage = await injector.resolveAsync(S3ObjectStorage, `region-test-${Math.floor(Math.random() * 1000000)}`);
         await perModuleStorage.ensureBucketExists('us-east-1', { objectLocking: true });

package/orm/tests/repository-expiration.test.js

@@ -51,7 +51,7 @@ describe('ORM Repository Expiration', () => {
     ], TtlEntity.prototype, "name", void 0);
     TtlEntity = __decorate([
         Table('ttl_entities', { schema }),
-        TimeToLive(1000, 'hard') // 1s TTL
+        TimeToLive(100, 'hard') // 100ms TTL
     ], TtlEntity);
     beforeAll(async () => {
         injector = new Injector('Test');
@@ -95,8 +95,8 @@ describe('ORM Repository Expiration', () => {
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(TtlEntity);
             const e1 = await repository.insert(Object.assign(new TtlEntity(), { name: 'Valid' }));
-            // Wait 1.1s for expiration
-            await new Promise((resolve) => setTimeout(resolve, 1100));
+            // Wait 150ms for expiration
+            await new Promise((resolve) => setTimeout(resolve, 150));
             await repository.processExpirations();
             const all = await repository.loadAll({ withDeleted: true });
             expect(all).toHaveLength(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.127",
+  "version": "0.93.129",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/pdf/utils.d.ts

@@ -1,6 +1,23 @@
-export declare function getPdfPageCount(file: string | Uint8Array | ReadableStream<Uint8Array>): Promise<number>;
-export declare function mergePdfs(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<Uint8Array>;
-export declare function mergePdfsStream(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<ReadableStream<Uint8Array>>;
+import { TemporaryFile } from '../file/server/temporary-file.js';
+export type PdfInput = string | {
+    file: string;
+} | Uint8Array | ReadableStream<Uint8Array>;
+export type PdfInputWithPageRange = string | {
+    file: string;
+} | Uint8Array | ReadableStream<Uint8Array> | {
+    input: PdfInput;
+    pages: PageRange[];
+};
+export type PageRange = number | {
+    from?: number;
+    to?: number;
+};
+export declare function getPdfPageCount(file: PdfInput): Promise<number>;
+export declare function extractPdfPages(file: PdfInput, pages: PageRange[]): Promise<TemporaryFile>;
+export declare function mergePdfs(sourceFiles: PdfInputWithPageRange[]): Promise<TemporaryFile>;
+export declare function overlayPdfs(base: PdfInput, overlay: PdfInput, options?: {
+    repeat?: boolean;
+}): Promise<TemporaryFile>;
 /**
  * Convert a PDF page to an image.
  * @param file The PDF file to convert.
@@ -10,3 +27,7 @@ export declare function mergePdfsStream(pdfs: (string | Uint8Array | ReadableStr
  * @returns The converted image as a byte array.
  */
 export declare function pdfToImage(file: string | Uint8Array | ReadableStream<Uint8Array>, page: number, size: number, format: 'png' | 'jpeg' | 'tiff' | 'ps' | 'eps' | 'pdf' | 'svg'): Promise<Uint8Array>;
+export declare function isInputWithPageRange(input: PdfInputWithPageRange): input is {
+    input: PdfInput;
+    pages: PageRange[];
+};

package/pdf/utils.js

@@ -51,15 +51,15 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { TemporaryFile } from '../file/server/temporary-file.js';
-import { spawnCommand } from '../process/spawn.js';
-import { isNotString, isString } from '../utils/type-guards.js';
+import { spawnCommand, spawnWaitReadCommand } from '../process/spawn.js';
+import { hasOwnProperty } from '../utils/object/object.js';
+import { isNotString, isNumber, isObject, isReadableStream, isString, isUint8Array, isUndefined } from '../utils/type-guards.js';
 export async function getPdfPageCount(file) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const fileIsPath = isString(file);
-        const tmpFile = __addDisposableResource(env_1, fileIsPath ? undefined : await TemporaryFile.from(file), true);
-        const path = fileIsPath ? file : tmpFile.path;
-        const process = await spawnCommand('qpdf', ['--show-npages', path]);
+        const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const [sourceFile] = await getPdfSourceFiles([file], stack);
+        const process = await spawnCommand('qpdf', ['--show-npages', sourceFile]);
         const { code } = await process.wait();
         if (code != 0) {
             const errorOutput = await process.readError();
@@ -78,14 +78,19 @@ export async function getPdfPageCount(file) {
             await result_1;
     }
 }
-export async function mergePdfs(pdfs) {
+export async function extractPdfPages(file, pages) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         const stack = __addDisposableResource(env_2, new AsyncDisposableStack(), true);
-        const resultFile = __addDisposableResource(env_2, TemporaryFile.create(), true);
-        const sourceFiles = await getPdfSourceFiles(pdfs, stack);
-        await pdfunite(sourceFiles, resultFile);
-        return await resultFile.read();
+        const [sourceFile] = await getPdfSourceFiles([file], stack);
+        const resultFile = TemporaryFile.create();
+        const pagesString = toQpdfPageRangeString(pages);
+        const processResult = await spawnWaitReadCommand('string', 'qpdf', ['--empty', '--pages', sourceFile, pagesString, '--', resultFile.path]);
+        if (processResult.code != 0) {
+            await resultFile.dispose();
+            throw new Error(processResult.error.trim());
+        }
+        return resultFile;
     }
     catch (e_2) {
         env_2.error = e_2;
@@ -97,14 +102,26 @@ export async function mergePdfs(pdfs) {
             await result_2;
     }
 }
-export async function mergePdfsStream(pdfs) {
+export async function mergePdfs(sourceFiles) {
     const env_3 = { stack: [], error: void 0, hasError: false };
     try {
         const stack = __addDisposableResource(env_3, new AsyncDisposableStack(), true);
         const resultFile = __addDisposableResource(env_3, TemporaryFile.create(), true);
-        const sourceFiles = await getPdfSourceFiles(pdfs, stack);
-        await pdfunite(sourceFiles, resultFile);
-        return resultFile.readStream();
+        const sourceFilePaths = await getPdfSourceFiles(sourceFiles, stack);
+        const pages = sourceFiles.map((source) => isInputWithPageRange(source) ? source.pages : undefined);
+        const sourceArguments = sourceFilePaths.flatMap((path, index) => {
+            const pageRanges = pages[index];
+            if (isUndefined(pageRanges)) {
+                return [path];
+            }
+            const pagesString = toQpdfPageRangeString(pageRanges);
+            return [path, pagesString];
+        });
+        const processResult = await spawnWaitReadCommand('string', 'qpdf', ['--empty', '--pages', ...sourceArguments, '--', resultFile.path]);
+        if (processResult.code != 0) {
+            throw new Error(processResult.error);
+        }
+        return resultFile;
     }
     catch (e_3) {
         env_3.error = e_3;
@@ -116,22 +133,32 @@ export async function mergePdfsStream(pdfs) {
             await result_3;
     }
 }
-async function getPdfSourceFiles(pdfs, stack) {
-    return await Promise.all(pdfs.map(async (pdf) => {
-        if (isString(pdf)) {
-            return pdf;
+export async function overlayPdfs(base, overlay, options) {
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        const stack = __addDisposableResource(env_4, new AsyncDisposableStack(), true);
+        const [baseFilePath, overlayFilePath] = await getPdfSourceFiles([base, overlay], stack);
+        const resultFile = TemporaryFile.create();
+        stack.use(resultFile);
+        const args = [baseFilePath, '--overlay', overlayFilePath];
+        if (options?.repeat) {
+            args.push('--repeat=1');
         }
-        const tmpFile = await TemporaryFile.from(pdf);
-        stack.use(tmpFile);
-        return tmpFile.path;
-    }));
-}
-async function pdfunite(sourceFiles, resultFile) {
-    const process = await spawnCommand('pdfunite', [...sourceFiles, resultFile.path]);
-    const { code } = await process.wait();
-    if (code != 0) {
-        const errorOutput = await process.readError();
-        throw new Error(errorOutput);
+        args.push('--', resultFile.path);
+        const processResult = await spawnWaitReadCommand('string', 'qpdf', args);
+        if (processResult.code != 0) {
+            throw new Error(processResult.error);
+        }
+        return resultFile;
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        const result_4 = __disposeResources(env_4);
+        if (result_4)
+            await result_4;
     }
 }
 /**
@@ -151,3 +178,35 @@ export async function pdfToImage(file, page, size, format) {
     }
     return await process.readOutputBytes();
 }
+function toQpdfPageRangeString(pages) {
+    return pages.map((page) => {
+        if (isNumber(page)) {
+            return String(page);
+        }
+        else {
+            const from = page.from ?? '1';
+            const to = page.to ?? 'z';
+            return `${from}-${to}`;
+        }
+    }).join(',');
+}
+async function getPdfSourceFiles(input, stack) {
+    return await Promise.all(input.map(async (pdf) => {
+        if (isUint8Array(pdf) || isReadableStream(pdf)) {
+            const tmpFile = await TemporaryFile.from(pdf);
+            stack.use(tmpFile);
+            return tmpFile.path;
+        }
+        if (isString(pdf)) {
+            return pdf;
+        }
+        if (isInputWithPageRange(pdf)) {
+            const [path] = await getPdfSourceFiles([pdf.input], stack);
+            return path;
+        }
+        return pdf.file;
+    }));
+}
+export function isInputWithPageRange(input) {
+    return isObject(input) && hasOwnProperty(input, 'input') && hasOwnProperty(input, 'pages');
+}

package/process/spawn.d.ts

@@ -18,7 +18,7 @@ export type SpawnOptions = {
     workingDirectory?: string;
     environment?: Record<string, string>;
 };
-export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
+export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array<ArrayBuffer>> & {
     process: ChildProcessWithoutNullStreams;
     stderr: ReadableStream<Uint8Array>;
     write(chunk: ReadableStream<Uint8Array> | Uint8Array | string, options?: StreamPipeOptions): Promise<void>;

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

@@ -11,7 +11,7 @@ describe('PostgresRateLimiter Integration Tests', () => {
         const rateLimiterProvider = injector.resolve(RateLimiterProvider);
         rateLimiter = rateLimiterProvider.get(limiterName, {
             burstCapacity: 10,
-            refillInterval: 1000, // 10 tokens per second -> 1 token per 100ms
+            refillInterval: 500, // 10 tokens per 500ms -> 1 token per 50ms
         });
     });
     afterAll(async () => {
@@ -30,9 +30,9 @@ describe('PostgresRateLimiter Integration Tests', () => {
         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);
+        // Wait for 1 token (50ms) + buffer
+        await timeout(75);
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(true);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
     });
     it('should refund tokens', async () => {
@@ -55,7 +55,9 @@ describe('PostgresRateLimiter Integration Tests', () => {
         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);
+        // We expect 10, but allow up to 12 if tokens refilled during the Promise.all
+        expect(successCount).toBeGreaterThanOrEqual(10);
+        expect(successCount).toBeLessThanOrEqual(12);
     }, 15000);
     it('should always allow zero or negative cost', async () => {
         const resource = 'res-zero';
@@ -72,8 +74,8 @@ describe('PostgresRateLimiter Integration Tests', () => {
         // Drain
         await rateLimiter.tryAcquire(resource, 10);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-        // Wait for full refill (1s) + extra
-        await timeout(1200);
+        // Wait for full refill (500ms) + extra
+        await timeout(600);
         // Should only have 10 tokens
         expect(await rateLimiter.tryAcquire(resource, 10)).toBe(true);
         // Should be empty again immediately

package/renderer/typst.d.ts

@@ -43,6 +43,11 @@ export type TypstRenderOptions = {
      * One (or multiple comma-separated) PDF standards that Typst will enforce conformance with.
      */
     pdfStandard?: LiteralUnion<'1.4' | '1.5' | '1.6' | '1.7' | '2.0' | 'a-1b' | 'a-1a' | 'a-2b' | 'a-2u' | 'a-2a' | 'a-3b' | 'a-3u' | 'a-3a' | 'a-4' | 'a-4f' | 'a-4e' | 'ua-1', string>;
+    /**
+     * A reference file to use when rendering to docx format. This allows customizing styles, fonts, etc. in the generated docx file. The file should be a valid docx file that serves as a template for the output.
+     * The reference file can be generated with `pandoc --print-default-data-file reference.docx`
+     */
+    docxReferenceFile?: string;
 };
 /**
  * Renders Typst source code to a file in the specified format.

package/renderer/typst.js

@@ -14,10 +14,9 @@ import { isDefined, isNumber, isString } from '../utils/type-guards.js';
 export async function renderTypst(source, options) {
     const format = options?.format ?? 'pdf';
     const command = (format == 'docx') ? 'pandoc' : 'typst';
-    let args = (format == 'docx')
-        ? ['--from', 'typst', '--to', 'docx', '--output']
-        : ['compile', '--format', format];
+    let args = [];
     if (command == 'typst') {
+        args = ['compile', '--format', format];
         if (isDefined(options?.root)) {
             args.push('--root', options.root);
         }
@@ -45,14 +44,19 @@ export async function renderTypst(source, options) {
             args.push('--pages', pageParts.join(','));
         }
     }
-    args.push('-', '-');
+    else if (command == 'pandoc') {
+        args = ['--from', 'typst', '--to', 'docx', '--output', '-'];
+        if (isDefined(options?.docxReferenceFile)) {
+            args.push('--reference-doc', options.docxReferenceFile);
+        }
+    }
     const process = await spawnCommand(command, args);
     const [{ code, output, error }] = await Promise.all([
         process.waitRead('binary', { throwOnNonZeroExitCode: false }),
         process.write(source),
     ]);
     const errorString = decodeText(error);
-    if (code !== 0) {
+    if (code != 0) {
         throw new Error(`
 Typst compilation failed with exit code ${code}.\n
 Error Output:\n${errorString}

package/task-queue/tests/complex.test.js

@@ -15,13 +15,13 @@ describe('Complex Queue Scenarios', () => {
         // Configure with specific settings for testing logic
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 1000,
-            priorityAgingInterval: 100, // Fast aging
+            priorityAgingInterval: 50, // Fast aging
             priorityAgingStep: 10,
             rateLimit: 5,
-            rateInterval: 500,
-            retryDelayMinimum: 100,
+            rateInterval: 50,
+            retryDelayMinimum: 50,
             retryDelayGrowth: 2,
-            retention: 100, // Fast retention for archive test
+            retention: 50, // Fast retention for archive test
         });
     });
     afterEach(async () => {
@@ -33,12 +33,12 @@ describe('Complex Queue Scenarios', () => {
         await injector?.dispose();
     });
     async function waitForStatus(id, status) {
-        for (let i = 0; i < 20; i++) {
+        for (let i = 0; i < 50; i++) {
             const task = await queue.getTask(id);
             if (task?.status === status)
                 return;
             await queue.processPendingFanIn();
-            await timeout(50);
+            await timeout(10);
         }
     }
     describe('Complex Dependencies', () => {
@@ -62,7 +62,7 @@ describe('Complex Queue Scenarios', () => {
             // Process B
             const dB = await queue.dequeue({ types: ['B'] });
             await queue.complete(dB);
-            await timeout(100);
+            await timeout(20);
             await queue.processPendingFanIn();
             // D still waiting (needs C)
             const uD2 = await queue.getTask(taskD.id);
@@ -105,8 +105,8 @@ describe('Complex Queue Scenarios', () => {
     describe('Scheduling & Priorities', () => {
         it('should promote priority of old pending tasks (Aging)', async () => {
             const t1 = await queue.enqueue('low', {}, { priority: 2000 });
-            // Wait for aging interval (100ms)
-            await timeout(150);
+            // Wait for aging interval (50ms)
+            await timeout(60);
             await queue.maintenance();
             const updated = await queue.getTask(t1.id);
             // Default step is 10. 2000 - 10 = 1990
@@ -120,7 +120,7 @@ describe('Complex Queue Scenarios', () => {
             const u1 = await queue.getTask(task.id);
             expect(u1?.tries).toBe(1);
             const delay1 = u1.scheduleTimestamp - currentTimestamp();
-            expect(delay1).toBeGreaterThan(150); // Approx check
+            expect(delay1).toBeGreaterThan(20); // Approx check
             // Force reschedule to now
             await queue.reschedule(task.id, currentTimestamp());
             // Try 2
@@ -129,12 +129,12 @@ describe('Complex Queue Scenarios', () => {
             const u2 = await queue.getTask(task.id);
             expect(u2?.tries).toBe(2);
             const now = currentTimestamp();
-            expect(u2.scheduleTimestamp > now + 300).toBe(true);
+            expect(u2.scheduleTimestamp > now + 50).toBe(true);
         });
     });
     describe('Rate Limiting & Concurrency', () => {
         it('should limit burst dequeue rate', async () => {
-            // Rate limit 5, interval 500ms
+            // Rate limit 5, interval 100ms
             await queue.enqueueMany(Array.from({ length: 10 }, (_, i) => ({ type: 'burst', data: { i } })));
             // Request burstCapacity (5)
             const batch1 = await queue.dequeueMany(5);
@@ -143,7 +143,7 @@ describe('Complex Queue Scenarios', () => {
             const batch2 = await queue.dequeueMany(1);
             expect(batch2.length).toBe(0); // Rate limited
             // Wait for refill
-            await timeout(600);
+            await timeout(60);
             const batch3 = await queue.dequeueMany(5);
             expect(batch3.length).toBe(5); // Refilled
         });
@@ -179,8 +179,8 @@ describe('Complex Queue Scenarios', () => {
             expect(before).toBeDefined();
             expect(before?.status).toBe(TaskStatus.Completed);
             expect(before.completeTimestamp > 0).toBe(true);
-            // Wait for retention (100ms).
-            await timeout(500);
+            // Wait for retention (50ms).
+            await timeout(60);
             await archiveQueue.maintenance();
             // Should move from main table to archive
             const loaded = await archiveQueue.getTask(task.id);
@@ -189,9 +189,9 @@ describe('Complex Queue Scenarios', () => {
             await archiveQueue.clear();
         });
         it('should prune expired pending tasks', async () => {
-            // Time to live: 100ms
-            const task = await queue.enqueue('expire-me', {}, { timeToLive: currentTimestamp() + 100 });
-            await timeout(150);
+            // Time to live: 50ms
+            const task = await queue.enqueue('expire-me', {}, { timeToLive: currentTimestamp() + 50 });
+            await timeout(60);
             await queue.maintenance();
             const updated = await queue.getTask(task.id);
             expect(updated?.status).toBe(TaskStatus.Dead);
@@ -206,7 +206,7 @@ describe('Complex Queue Scenarios', () => {
             const d = await queue.dequeue();
             await queue.complete(d);
             // Force move
-            await timeout(200);
+            await timeout(60);
             await queue.maintenance();
             // Verify retrieval
             const fromArchive = await queue.getTask(task.id);
@@ -215,7 +215,7 @@ describe('Complex Queue Scenarios', () => {
         });
         it('should defer archival of parent tasks until children are archived', async () => {
             const qProvider = injector.resolve(TaskQueueProvider);
-            const treeQueue = qProvider.get(`archive-tree-${Date.now()}`, { retention: 100 });
+            const treeQueue = qProvider.get(`archive-tree-${Date.now()}`, { retention: 50 });
             const parent = await treeQueue.enqueue('parent', {});
             const child = await treeQueue.enqueue('child', {}, { parentId: parent.id });
             const d1 = await treeQueue.dequeue();
@@ -223,7 +223,7 @@ describe('Complex Queue Scenarios', () => {
             await treeQueue.complete(d1);
             await treeQueue.complete(d2);
             // Wait for retention
-            await timeout(200);
+            await timeout(60);
             // First maintenance: should archive child, but parent stays because child is still in main table (until it's deleted in the same tx maybe? No, loadMany happens before delete)
             await treeQueue.maintenance();
             const parentStillActive = await treeQueue.getTask(parent.id);
@@ -282,7 +282,7 @@ describe('Complex Queue Scenarios', () => {
             for (let i = 0; i < 5; i++) {
                 if (u?.status == TaskStatus.Waiting)
                     break;
-                await timeout(50);
+                await timeout(10);
                 u = await queue.getTask(dependent.id);
             }
             expect(u?.status).toBe(TaskStatus.Waiting); // Should still be waiting because dependency didn't Complete