@tstdl/base 0.93.123 → 0.93.126

package/renderer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './d2.js';
+export * from './graphviz.js';
+export * from './latex.js';
+export * from './typst.js';

package/renderer/index.js

@@ -0,0 +1,4 @@
+export * from './d2.js';
+export * from './graphviz.js';
+export * from './latex.js';
+export * from './typst.js';

package/renderer/typst.d.ts

@@ -0,0 +1,57 @@
+import type { LiteralUnion } from 'type-fest';
+export type TypstRenderOptions = {
+    /**
+     * The root directory for resolving imports in the Typst source. If not specified, imports will be resolved relative to the location of the source file.
+     */
+    root?: string;
+    /**
+     * The output format for the rendered document.
+     * Note: `docx` output uses pandoc under the hood, which does not support all Typst features.
+     * @default 'pdf'
+     */
+    format?: 'pdf' | 'png' | 'svg' | 'html' | 'docx';
+    /**
+     * Which pages to render.
+     */
+    pages?: (string | number | {
+        from?: number;
+        to?: number;
+    })[];
+    /**
+     * Add string key-value pairs visible through `sys.inputs`
+     */
+    inputs?: Record<string, string>;
+    /**
+     * The document's creation date formatted as a UNIX timestamp in milliseconds.
+     */
+    creationTimestamp?: number;
+    /**
+     * Adds additional directories that are recursively searched for fonts.
+     */
+    fontPaths?: string[];
+    /**
+     * Ensures system fonts won't be searched, unless explicitly included via `fontPaths`.
+     * @default false
+     */
+    ignoreSystemFonts?: boolean;
+    /**
+     * The PPI (pixels per inch) to use for PNG export.
+     * @default 144
+     */
+    ppi?: number;
+    /**
+     * 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>;
+};
+/**
+ * Renders Typst source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted typst source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires typst to be installed on the system.
+ * @param source
+ * @param options
+ */
+export declare function renderTypst(source: string, options?: TypstRenderOptions): Promise<Uint8Array<ArrayBuffer>>;

package/renderer/typst.js

@@ -0,0 +1,62 @@
+import { spawnCommand } from '../process/spawn.js';
+import { decodeText } from '../utils/encoding.js';
+import { isDefined, isNumber, isString } from '../utils/type-guards.js';
+/**
+ * Renders Typst source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted typst source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires typst to be installed on the system.
+ * @param source
+ * @param options
+ */
+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];
+    if (command == 'typst') {
+        if (isDefined(options?.root)) {
+            args.push('--root', options.root);
+        }
+        if (isDefined(options?.creationTimestamp)) {
+            args.push('--creation-timestamp', Math.floor(options.creationTimestamp / 1000).toString());
+        }
+        if (isDefined(options?.fontPaths)) {
+            for (const fontPath of options.fontPaths) {
+                args.push('--font-path', fontPath);
+            }
+        }
+        if (options?.ignoreSystemFonts == true) {
+            args.push('--ignore-system-fonts');
+        }
+        if (isDefined(options?.ppi)) {
+            args.push('--ppi', options.ppi.toString());
+        }
+        if (isDefined(options?.pdfStandard)) {
+            args.push('--pdf-standard', options.pdfStandard);
+        }
+        if (isDefined(options?.pages)) {
+            const pageParts = options.pages.map((page) => (isNumber(page) || isString(page))
+                ? page.toString()
+                : `${page.from ?? ''}-${page.to ?? ''}`);
+            args.push('--pages', pageParts.join(','));
+        }
+    }
+    args.push('-', '-');
+    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) {
+        throw new Error(`
+Typst compilation failed with exit code ${code}.\n
+Error Output:\n${errorString}
+`.trim());
+    }
+    return output;
+}

package/rpc/adapters/readable-stream.adapter.d.ts

@@ -13,6 +13,9 @@ type Response<T> = {
     type: 'done';
 } | {
     type: 'void';
+} | {
+    type: 'throw';
+    error: Error;
 };
 export declare class ReadableStreamRpcAdapter<T> implements RpcAdapter<ReadableStream<T>, void, void, Request, Response<T>> {
     readonly name = "ReadableStream";

package/rpc/adapters/readable-stream.adapter.js

@@ -57,6 +57,10 @@ export class ReadableStreamRpcAdapter {
                         controller.close();
                         break;
                     }
+                    case 'throw': {
+                        controller.error(response.error);
+                        break;
+                    }
                     default: {
                         throw new NotSupportedError(`Type ${response.type} is not supported.`);
                     }
@@ -65,7 +69,7 @@ export class ReadableStreamRpcAdapter {
             async cancel(reason) {
                 await channel.request({ type: 'cancel', reason });
                 channel.close();
-            }
+            },
         });
     }
 }

package/rpc/rpc.js

@@ -19,6 +19,9 @@ const proxyTargets = new WeakSet();
 const exposings = new Map();
 const proxyChannels = new WeakMap();
 const channelFinalizationRegistry = new FinalizationRegistry((data) => data.channel.close());
+const rpcSet = Symbol('Rpc.set');
+const rpcDelete = Symbol('Rpc.delete');
+const rpcHas = Symbol('Rpc.has');
 class RpcProxy {
 }
 export const Rpc = {
@@ -107,13 +110,13 @@ export const Rpc = {
         return isDefined(channel);
     },
     async set(proxy, property, value) {
-        await Reflect.set(proxy, property, value);
+        await proxy[rpcSet](property, value);
     },
     async delete(proxy, property) {
-        return await Reflect.deleteProperty(proxy, property);
+        return await proxy[rpcDelete](property);
     },
     async has(proxy, property) {
-        return await Reflect.has(proxy, property);
+        return await proxy[rpcHas](property);
     },
     reset() {
         exposings.clear();
@@ -141,6 +144,28 @@ function createProxy(channel, path = []) {
                 .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
         },
         get(_target, property) {
+            if (property == rpcSet) {
+                return async (prop, value) => {
+                    const postMessageData = getPostMessageData(value, endpoint);
+                    return await channel
+                        .request({ type: 'set', path: [...path, prop], value: postMessageData.value }, postMessageData.transfer)
+                        .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+                };
+            }
+            if (property == rpcDelete) {
+                return async (prop) => {
+                    return await channel
+                        .request({ type: 'deleteProperty', path: [...path, prop] })
+                        .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+                };
+            }
+            if (property == rpcHas) {
+                return async (prop) => {
+                    return await channel
+                        .request({ type: 'has', path: [...path, prop] })
+                        .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+                };
+            }
             if (property == 'then') {
                 if (path.length == 0) {
                     return { then: () => proxy };

package/rpc/tests/rpc.integration.test.js

@@ -187,6 +187,8 @@ describe('Rpc Integration', () => {
         const proxy = await Rpc.connect(clientEndpoint, 'test-service-helpers');
         expect(await Rpc.has(proxy, 'foo')).toBe(true);
         expect(await Rpc.has(proxy, 'nonExistent')).toBe(false);
+        // Standard Reflect.has on a proxy with async traps will always be true (truthy promise)
+        expect(Reflect.has(proxy, 'nonExistent')).toBe(true);
         const deleteResult = await Rpc.delete(proxy, 'foo');
         expect(deleteResult).toBe(true);
         expect(await Rpc.has(proxy, 'foo')).toBe(false);
@@ -522,7 +524,7 @@ describe('Rpc Integration', () => {
     });
     it('should throw when serializing a marked rpc proxy directly', async () => {
         const { serialize } = await import('../../serializer/index.js');
-        const proxyInstance = new Rpc._RpcProxy();
+        const proxyInstance = new Rpc[internal].RpcProxy();
         expect(() => serialize(proxyInstance)).toThrow(NotSupportedError);
     });
     it('should support serializing an object marked with Rpc.adapt', async () => {

package/schema/schemas/nullable.js

@@ -8,7 +8,7 @@ export class NullableSchema extends Schema {
     schema;
     constructor(schema) {
         if ((schema instanceof NullableSchema) && (schema == schema.schema)) {
-            return schema; // eslint-disable-line no-constructor-return
+            return schema;
         }
         super();
         this.schema = schemaTestableToSchema(schema);

package/task-queue/task-queue.d.ts

@@ -1,5 +1,6 @@
 import type { CancellationSignal } from '../cancellation/token.js';
 import { type EnumType } from '../enumeration/enumeration.js';
+import { Injector } from '../injector/index.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import { Logger } from '../logger/logger.js';
 import type { Transaction } from '../orm/server/transaction.js';
@@ -179,6 +180,7 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
     namespace: string;
 }> implements Resolvable<TaskQueueArgument> {
     readonly [resolveArgumentType]: TaskQueueArgument;
+    protected readonly injector: Injector;
     protected readonly config: QueueConfig & {
         namespace: string;
     };

package/task-queue/task-queue.js

@@ -1,5 +1,5 @@
 import { defineEnum } from '../enumeration/enumeration.js';
-import { inject, injectArgument } from '../injector/index.js';
+import { inject, injectArgument, Injector } from '../injector/index.js';
 import { Logger } from '../logger/logger.js';
 import { Transactional } from '../orm/server/transactional.js';
 import { currentTimestamp } from '../utils/date-time.js';
@@ -78,6 +78,7 @@ export const defaultQueueConfig = {
     idempotencyWindow: millisecondsPerMinute * 60,
 };
 export class TaskQueue extends Transactional {
+    injector = inject(Injector);
     config = this.transactionalContextData ?? (() => { const arg = injectArgument(this); return isString(arg) ? { namespace: arg } : arg; })();
     logger = inject(Logger, TaskQueue.name).with({ namespace: this.config.namespace });
     batch() {
@@ -87,9 +88,12 @@ export class TaskQueue extends Transactional {
      * Starts processing tasks with the provided worker function in the background until the cancellation signal is triggered.
      */
     process({ concurrency = 1, cancellationSignal, types, forceDequeue }, handler) {
+        const promises = [];
         for (let i = 0; i < concurrency; i++) {
-            void this.processWorker(cancellationSignal, handler, { types, forceDequeue });
+            const processPromise = this.processWorker(cancellationSignal, handler, { types, forceDequeue });
+            promises.push(processPromise);
         }
+        this.injector.addDisposeHandler(async () => await Promise.all(promises));
     }
     getTransactionalContextData() {
         return this.config;

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

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { timeout } from '../../utils/timing.js';
 describe('Complex Queue Scenarios', () => {

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

@@ -1,7 +1,7 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
 import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Queue Dependencies & Tree Tests', () => {
     let injector;
@@ -147,9 +147,9 @@ describe('Queue Dependencies & Tree Tests', () => {
             const token = new CancellationToken();
             const consumer = queue.getConsumer(token);
             const t1 = (await consumer.next()).value;
-            expect(t1.data.val).toBe(1);
+            expect(t1.data['val']).toBe(1);
             const t2 = (await consumer.next()).value;
-            expect(t2.data.val).toBe(2);
+            expect(t2.data['val']).toBe(2);
             token.set(); // Stop consumer
             const t3 = await consumer.next();
             expect(t3.done).toBe(true);

package/task-queue/tests/extensive-dependencies.test.js

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Extensive Task Queue Dependency Tests', () => {
     let injector;

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

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { timeout } from '../../utils/timing.js';
 describe('Queue Integration Tests', () => {

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

@@ -1,11 +1,12 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
 import { TaskProcessResult, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Worker & Base Class Tests', () => {
     let injector;
     let queue;
+    let token;
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
     });
@@ -15,8 +16,10 @@ describe('Worker & Base Class Tests', () => {
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 500, // Short visibility for testing lease loss
         });
+        token = new CancellationToken();
     });
     afterEach(async () => {
+        token.set();
         await queue.clear();
         const queueProvider = injector.resolve(TaskQueueProvider);
         await queueProvider.get('other-queue').clear();
@@ -28,7 +31,6 @@ describe('Worker & Base Class Tests', () => {
         const t1 = await queue.enqueue('work', { val: 1 });
         const t2 = await queue.enqueue('work', { val: 2 });
         const processed = [];
-        const token = new CancellationToken();
         queue.process({ cancellationSignal: token }, async (context) => {
             processed.push(context.data['val']);
             return TaskProcessResult.Complete();
@@ -50,7 +52,6 @@ describe('Worker & Base Class Tests', () => {
     });
     it('should handle errors in worker gracefully', async () => {
         const task = await queue.enqueue('fail', {});
-        const token = new CancellationToken();
         queue.process({ cancellationSignal: token }, async () => {
             throw new Error('worker error');
         });
@@ -63,7 +64,6 @@ describe('Worker & Base Class Tests', () => {
     });
     it('should extend lease (heartbeat) during long processing', async () => {
         const task = await queue.enqueue('long', {});
-        const token = new CancellationToken();
         let executed = false;
         queue.process({ cancellationSignal: token }, async (_context) => {
             // Simulate long work > visibilityTimeout (500ms)
@@ -80,7 +80,6 @@ describe('Worker & Base Class Tests', () => {
     it('should handle TaskResult actions (Fail, Reschedule)', async () => {
         const tFail = await queue.enqueue('fail-action', {});
         const tResched = await queue.enqueue('resched-action', {});
-        const token = new CancellationToken();
         const processed = new Set();
         queue.process({ cancellationSignal: token }, async (context) => {
             processed.add(context.id);
@@ -107,7 +106,6 @@ describe('Worker & Base Class Tests', () => {
     });
     it('should exercise TaskContext methods', async () => {
         const task = await queue.enqueue('context-test', { val: 1 });
-        const token = new CancellationToken();
         let executed = false;
         queue.process({ cancellationSignal: token, types: ['context-test'] }, async (context) => {
             expect(context.id).toBe(task.id);
@@ -149,7 +147,6 @@ describe('Worker & Base Class Tests', () => {
         });
         await testQueue.enqueue('work', {});
         testQueue.notify();
-        const token = new CancellationToken();
         const finalAttemptValues = [];
         testQueue.process({ cancellationSignal: token }, async (context) => {
             finalAttemptValues.push(context.isFinalAttempt);

package/test5.js

@@ -1,17 +1,61 @@
 import './polyfills.js';
-import { writeFile } from 'node:fs/promises';
+import { buildPrompts, orderedList } from './ai/index.js';
+import { fewShotPrompt } from './ai/prompts/steering.js';
 import { Application } from './application/application.js';
 import { provideModule, provideSignalHandler } from './application/index.js';
 import { PrettyPrintLogFormatter } from './logger/index.js';
 import { provideConsoleLogTransport } from './logger/transports/console.js';
-import { renderTypst } from './typst/render.js';
-const template = `
-I got an ice cream for
-\\$1.50! \\u{1f600}
-`;
 async function main(_cancellationSignal) {
-    const pdfBytes = await renderTypst(template, { format: 'docx' });
-    await writeFile('/tmp/output.docx', pdfBytes);
+    const prompt = buildPrompts({
+        baseSystemInstructions: { Role: 'You are a helpful assistant.' },
+        baseUserInstructions: 'Please process the following data.',
+        additionalSystemInstructions: 'Make sure to follow the user instructions carefully.',
+        additionalUserInstructions: [
+            'The data is in JSON format.',
+            fewShotPrompt([
+                {
+                    input: { a: 1, b: 2 },
+                    output: 3,
+                    reason: 'This is a positive example showing that the function should add the two numbers.',
+                },
+                {
+                    input: { a: 1, b: 2 },
+                    output: 4,
+                    isNegative: true,
+                    reason: 'This is a negative example showing that the function should NOT return 4 for these inputs.',
+                },
+            ]),
+            {
+                Foo: {
+                    Bar: 'This is a nested instruction example.',
+                    Baz: {
+                        Qux: 'Make sure to handle nested instructions properly.',
+                        Bux: orderedList('This is an ordered list of instructions', [
+                            'First instruction',
+                            'Second instruction',
+                            'Third instruction',
+                        ]),
+                    },
+                },
+            },
+        ],
+        data: {
+            context: {
+                task: 'Our favorite hikes together',
+                location: 'Boulder',
+                season: 'spring_2025',
+            },
+            friends: ['ana', 'luis', 'sam'],
+            hikes: [
+                { id: 1, name: 'Blue Lake Trail', distanceKm: 7.5, elevationGain: 320, companion: 'ana', wasSunny: true },
+                { id: 2, name: 'Ridge Overlook', distanceKm: 9.2, elevationGain: 540, companion: 'luis', wasSunny: false },
+                { id: 3, name: 'Wildflower Loop', distanceKm: 5.1, elevationGain: 180, companion: 'sam', wasSunny: true },
+            ],
+        },
+    });
+    console.log(prompt.systemPrompt[0].text);
+    console.log();
+    console.log(prompt.userPrompt[0].text);
 }
 Application.run('Test', [
     provideConsoleLogTransport(PrettyPrintLogFormatter),

package/{unit-test → testing}/integration-setup.d.ts

@@ -19,6 +19,7 @@ export type IntegrationTestOptions = {
         audit?: boolean;
         authentication?: boolean;
         circuitBreaker?: boolean;
+        documentManagement?: boolean;
         keyValueStore?: boolean;
         lock?: boolean;
         messageBus?: boolean;

package/{unit-test → testing}/integration-setup.js

@@ -5,6 +5,7 @@ import { AuthenticationApiClient } from '../authentication/client/api.client.js'
 import { configureAuthenticationClient } from '../authentication/client/index.js';
 import { AuthenticationApiController, configureAuthenticationServer, migrateAuthenticationSchema } from '../authentication/server/index.js';
 import { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from '../circuit-breaker/postgres/module.js';
+import { configureDocumentManagement, migrateDocumentManagementSchema } from '../document-management/server/index.js';
 import { configureUndiciHttpClientAdapter } from '../http/client/adapters/undici.adapter.js';
 import { configureHttpClient } from '../http/client/index.js';
 import { HttpServer } from '../http/server/index.js';
@@ -107,6 +108,18 @@ export async function setupIntegrationTest(options = {}) {
             configureNotification({ injector });
             await runInInjectionContext(injector, migrateNotificationSchema);
         }
+        if (options.modules?.documentManagement) {
+            configureDocumentManagement({
+                ancillaryService: undefined, // Should be overridden by test if needed
+                authorizationService: undefined, // Should be overridden by test if needed
+                fileObjectStorageModule: 'docs',
+                fileUploadObjectStorageModule: 'uploads',
+                filePreviewObjectStorageModule: 'previews',
+                skipAi: true,
+                injector,
+            });
+            await runInInjectionContext(injector, migrateDocumentManagementSchema);
+        }
         if (options.modules?.objectStorage) {
             configureS3ObjectStorage({
                 endpoint: configParser.string('S3_ENDPOINT', 'http://127.0.0.1:9000'),

package/utils/base64.d.ts

@@ -1,4 +1,11 @@
 import type { BinaryData } from '../types/index.js';
+/**
+ * Converts data to a base64 data URL.
+ * @param mimeType The MIME type of the data.
+ * @param data The data as Uint8Array.
+ * @returns A base64 data URL.
+ */
+export declare function encodeDataUrl(mimeType: string, data: Uint8Array): string;
 export declare function encodeBase64(array: BinaryData, bytesOffset?: number, bytesLength?: number): string;
 export declare function decodeBase64(base64: string): Uint8Array<ArrayBuffer>;
 export declare function encodeBase64Url(array: BinaryData, bytesOffset?: number, length?: number): string;

package/utils/base64.js

@@ -1,7 +1,16 @@
-/* eslint-disable @typescript-eslint/no-magic-numbers, no-bitwise */
 import { supportsBuffer } from '../supports.js';
 import { toUint8Array } from './binary.js';
 import { isArrayBufferLike, isDefined } from './type-guards.js';
+/**
+ * Converts data to a base64 data URL.
+ * @param mimeType The MIME type of the data.
+ * @param data The data as Uint8Array.
+ * @returns A base64 data URL.
+ */
+export function encodeDataUrl(mimeType, data) {
+    const base64 = encodeBase64(data);
+    return `data:${mimeType};base64,${base64}`;
+}
 export function encodeBase64(array, bytesOffset, bytesLength) {
     let arrayBuffer;
     let offset;

package/utils/noop.d.ts

@@ -1,2 +1,8 @@
+/**
+ * A no-operation function that does nothing. Useful as a default placeholder for optional callbacks or functions.
+ */
 export declare function noop(): void;
-export declare function noopPass<T>(value: T): T;
+/**
+ * A passthrough function that returns the provided value. Useful as a default for optional transformation functions.
+ */
+export declare function passthrough<T>(value: T): T;

package/utils/noop.js

@@ -1,6 +1,12 @@
+/**
+ * A no-operation function that does nothing. Useful as a default placeholder for optional callbacks or functions.
+ */
 export function noop() {
     // noop
 }
-export function noopPass(value) {
+/**
+ * A passthrough function that returns the provided value. Useful as a default for optional transformation functions.
+ */
+export function passthrough(value) {
     return value;
 }

package/ai/ai-file.service.d.ts

@@ -1,57 +0,0 @@
-import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
-import { AiModuleOptions } from './module.js';
-import { type FileContentPart, type FileInput } from './types.js';
-/**
- * Options for {@link AiFileService}.
- */
-export type AiFileServiceOptions = Pick<AiModuleOptions, 'apiKey' | 'keyFile' | 'vertex'>;
-export type AiFileServiceArgument = AiFileServiceOptions;
-type File = {
-    id: string;
-    name: string;
-    uri: string;
-    mimeType: string;
-};
-/**
- * Manages file uploads and state for use with AI models.
- * Handles both Google Generative AI File API and Google Cloud Storage for Vertex AI.
- */
-export declare class AiFileService implements Resolvable<AiFileServiceArgument> {
-    #private;
-    readonly [resolveArgumentType]: AiFileServiceArgument;
-    /**
-     * Uploads and processes a single file, making it available for AI model consumption.
-     * @param fileInput The file to process.
-     * @returns A promise that resolves to a {@link FileContentPart} for use in AI requests.
-     */
-    processFile(fileInput: FileInput): Promise<FileContentPart>;
-    /**
-     * Uploads and processes multiple files in parallel, making them available for AI model consumption.
-     * @param fileInputs The files to process.
-     * @returns A promise that resolves to an array of {@link FileContentPart} for use in AI requests.
-     */
-    processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
-    /**
-     * Retrieves a file by its internal ID.
-     * The file must have been processed by this service instance before.
-     * @param id The internal ID of the file.
-     * @returns The file, or `undefined` if not found.
-     */
-    getFileById(id: string): File | undefined;
-    /**
-     * Retrieves a file by its URI (e.g., GCS URI).
-     * The file must have been processed by this service instance before.
-     * @param uri The URI of the file.
-     * @returns The file, or `undefined` if not found.
-     */
-    getFileByUri(uri: string): File | undefined;
-    private getFile;
-    private getFiles;
-    private uploadFile;
-    private uploadFileVertex;
-    private uploadFileGenAi;
-    private getBucket;
-    private waitForFileActive;
-    private waitForFilesActive;
-}
-export {};