@tstdl/base 0.93.123 → 0.93.126

package/ai/genkit/tests/multi-region.test.js

@@ -3,7 +3,7 @@ import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { CircuitBreakerState } from '../../../circuit-breaker/index.js';
 import { CircuitBreakerProvider } from '../../../circuit-breaker/provider.js';
 import { Logger } from '../../../logger/logger.js';
-import { setupIntegrationTest } from '../../../unit-test/index.js';
+import { setupIntegrationTest } from '../../../testing/index.js';
 import { vertexAiMultiLocation } from '../multi-region.plugin.js';
 vi.mock('#/utils/array/index.js', async (importOriginal) => {
     const actual = await importOriginal();
@@ -30,19 +30,19 @@ describe('Genkit vertexai-multi-location Plugin Tests', () => {
         const { injector } = await setupIntegrationTest({ modules: { circuitBreaker: true } });
         cbProvider = injector.resolve(CircuitBreakerProvider);
         logger = injector.resolve(Logger, 'Test');
+    });
+    beforeEach(async () => {
+        vi.clearAllMocks();
         ai = genkit({
             plugins: [
                 vertexAiMultiLocation({
                     locations: ['region-1', 'region-2'],
                     circuitBreakerProvider: cbProvider,
                     logger,
-                    circuitBreakerConfig: { resetTimeout: 1000000 },
+                    circuitBreakerConfig: { resetTimeout: 1000000, threshold: 1 },
                 }),
             ],
         });
-    });
-    beforeEach(async () => {
-        vi.clearAllMocks();
         const config = { threshold: 1, resetTimeout: 1000000 };
         await cbProvider.provide('genkit:vertex-ai:location:region-1', config).recordSuccess();
         await cbProvider.provide('genkit:vertex-ai:location:region-2', config).recordSuccess();
@@ -101,7 +101,7 @@ describe('Genkit vertexai-multi-location Plugin Tests', () => {
                     locations,
                     circuitBreakerProvider: cbProvider,
                     logger,
-                    circuitBreakerConfig: { resetTimeout: 1000000 },
+                    circuitBreakerConfig: { resetTimeout: 1000000, threshold: 1 },
                 }),
             ],
         });

package/ai/index.d.ts

@@ -1,7 +1,3 @@
-export * from './ai-file.service.js';
-export * from './ai-session.js';
-export * from './ai.service.js';
-export * from './functions.js';
-export * from './module.js';
+export * from './genkit/index.js';
+export * from './parser/index.js';
 export * from './prompts/index.js';
-export * from './types.js';

package/ai/index.js

@@ -1,7 +1,3 @@
-export * from './ai-file.service.js';
-export * from './ai-session.js';
-export * from './ai.service.js';
-export * from './functions.js';
-export * from './module.js';
+export * from './genkit/index.js';
+export * from './parser/index.js';
 export * from './prompts/index.js';
-export * from './types.js';

package/ai/parser/index.d.ts

@@ -0,0 +1 @@
+export * from './parser.js';

package/ai/parser/index.js

@@ -0,0 +1 @@
+export * from './parser.js';

package/ai/parser/parser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AIs sometimes return the string "null" instead of an actual null value. This function converts such strings to null, while leaving other strings unchanged.
+ */
+export declare function parseAiNullableText(text: string | null): string | null;
+/**
+ * Convert the output of AIs that is supposed to be a date into a numeric date (days since epoch). If the input is invalid, returns null (if allowNull is true) or the fallback value (if provided), or throws an error otherwise.
+ * @param dateOrString
+ * @param allowNull
+ * @param fallback
+ */
+export declare function parseAiDateToNumericDate<F>(dateOrString: Date | string, allowNull: false, fallback?: F): number | F;
+export declare function parseAiDateToNumericDate<F>(dateOrString: Date | string, allowNull?: boolean, fallback?: F): number | null | F;

package/ai/parser/parser.js

@@ -0,0 +1,28 @@
+import { dateToNumericDate } from '../../utils/date-time.js';
+import { isDate } from '../../utils/type-guards.js';
+/**
+ * AIs sometimes return the string "null" instead of an actual null value. This function converts such strings to null, while leaving other strings unchanged.
+ */
+export function parseAiNullableText(text) {
+    if (text == 'null') {
+        return null;
+    }
+    return text;
+}
+export function parseAiDateToNumericDate(dateOrString, allowNull = true, fallback) {
+    if (isDate(dateOrString)) {
+        return dateToNumericDate(dateOrString);
+    }
+    const date = new Date(dateOrString);
+    if (Number.isNaN(date.getTime())) {
+        console.warn(`Invalid date string from AI: ${dateOrString}`);
+        if (allowNull) {
+            return null;
+        }
+        if (arguments.length >= 3) {
+            return fallback;
+        }
+        throw new Error(`Invalid date string from AI: ${dateOrString}`);
+    }
+    return dateToNumericDate(date);
+}

package/ai/prompts/build.d.ts

@@ -0,0 +1,21 @@
+import type { Part } from 'genkit';
+import type { ObjectLiteral } from '../../types/types.js';
+import { type Instructions } from './instructions-formatter.js';
+export type AiMergeData = {
+    baseSystemInstructions: Instructions;
+    baseUserInstructions: Instructions;
+    additionalSystemInstructions?: Instructions | string;
+    additionalUserInstructions?: Instructions | string;
+    systemInstructionsOverride?: (instructions: Instructions) => Instructions | string;
+    userInstructionsOverride?: (instructions: Instructions) => Instructions | string;
+    data?: ObjectLiteral;
+    language?: string;
+    media?: {
+        mimeType: string;
+        content: Uint8Array<ArrayBuffer>;
+    };
+};
+export declare function buildPrompts(data: AiMergeData): {
+    systemPrompt: Part[];
+    userPrompt: Part[];
+};

package/ai/prompts/build.js

@@ -0,0 +1,25 @@
+import { encodeDataUrl } from '../../utils/base64.js';
+import { objectKeys } from '../../utils/object/object.js';
+import { isDefined, isString } from '../../utils/type-guards.js';
+import { formatData } from './format.js';
+import { formatInstructions, sections } from './instructions-formatter.js';
+import { languagePrompt } from './steering.js';
+export function buildPrompts(data) {
+    const systemInstructions = (isDefined(data.additionalSystemInstructions) && (isString(data.additionalSystemInstructions) || (objectKeys(data.additionalSystemInstructions).length > 0)))
+        ? [data.baseSystemInstructions, { 'Additional Instructions': data.additionalSystemInstructions }]
+        : data.baseSystemInstructions;
+    const dataInstructions = isDefined(data.data) ? { Data: `\`\`\`toon\n${formatData(data.data)}\n\`\`\`` } : undefined;
+    const outputLanguageInstructions = isDefined(data.language) ? { 'Output Language': languagePrompt(data.language) } : undefined;
+    const userInstructions = sections(((isDefined(data.additionalUserInstructions) && (isString(data.additionalUserInstructions) || (objectKeys(data.additionalUserInstructions).length > 0)))
+        ? [dataInstructions, data.baseUserInstructions, { 'Additional Instructions': data.additionalUserInstructions }, outputLanguageInstructions]
+        : [dataInstructions, data.baseUserInstructions, outputLanguageInstructions]).filter(isDefined));
+    const systemInstructionsOverride = data.systemInstructionsOverride?.(systemInstructions) ?? systemInstructions;
+    const systemPrompt = isString(systemInstructionsOverride) ? systemInstructionsOverride : formatInstructions(systemInstructionsOverride);
+    const userInstructionsOverride = data.userInstructionsOverride?.(userInstructions) ?? userInstructions;
+    const userPrompt = isString(userInstructionsOverride) ? userInstructionsOverride : formatInstructions(userInstructionsOverride);
+    const mediaUrl = isDefined(data.media) ? encodeDataUrl(data.media.mimeType, data.media.content) : undefined;
+    return {
+        systemPrompt: [{ text: systemPrompt }],
+        userPrompt: isDefined(mediaUrl) ? [{ media: { url: mediaUrl } }, { text: userPrompt }] : [{ text: userPrompt }],
+    };
+}

package/ai/prompts/index.d.ts

@@ -1,3 +1,5 @@
+export * from './build.js';
 export * from './format.js';
 export * from './instructions-formatter.js';
 export * from './instructions.js';
+export * from './steering.js';

package/ai/prompts/index.js

@@ -1,3 +1,5 @@
+export * from './build.js';
 export * from './format.js';
 export * from './instructions-formatter.js';
 export * from './instructions.js';
+export * from './steering.js';

package/ai/prompts/instructions-formatter.d.ts

@@ -7,10 +7,10 @@
 export type ListStyle = 'sections' | 'ordered' | 'unordered';
 /**
  * The content of an instructions list, which can be either:
- * - An array of strings (simple list items).
+ * - An array of strings or nested instructions.
  * - A nested `Instructions` object (key-value pairs or further lists).
  */
-export type InstructionsListContent = string[] | Instructions;
+export type InstructionsListContent = (string | Instructions)[] | Instructions;
 /**
  * A container representing a specific grouping of instructions with a defined style.
  * This is usually created via factory functions like `sections()`, `orderedList()`, or `unorderedList()`.
@@ -24,12 +24,12 @@ export type InstructionsList = {
     items: InstructionsListContent;
 };
 /**
- * A recursive dictionary structure for defining structured instructions.
- * Keys typically represent labels or headers, while values represent the content.
+ * A recursive structure for defining structured instructions.
+ * Can be a simple string, an array of strings or instructions, or a dictionary.
  */
-export type Instructions = {
-    [key: string]: string | string[] | InstructionsList | Instructions;
-};
+export type Instructions = string | {
+    [key: string]: Instructions | InstructionsList;
+} | Instructions[];
 /**
  * Creates a container where content is rendered as Markdown sections.
  * Keys in the object map become headers (e.g., `# Key`), and nested items reset indentation.
@@ -70,19 +70,6 @@ export declare function unorderedList(items: InstructionsListContent): Instructi
  * @param items - The list items or map.
  */
 export declare function unorderedList(instruction: string, items: InstructionsListContent): InstructionsList;
-/**
- * Formats a structured instructions object into a string representation suitable for AI prompts (Markdown).
- *
- * It recursively handles:
- * - `sections`: Creates headers (H1, H2...).
- * - `ordered` / `unordered`: Creates indented lists.
- * - `Instructions`: Objects are formatted as key-value pairs (e.g., `- **Key:** Value`).
- *
- * @param node - The root instructions object, array, or instructions list wrapper.
- * @param options - Formatting options.
- * @param options.initialDepth - The starting indentation level (default: 0).
- * @returns A formatted string.
- */
-export declare function formatInstructions(node: Instructions | InstructionsList | string[], options?: {
+export declare const formatInstructions: (node: Instructions | InstructionsList, options?: {
     initialDepth?: number;
-}): string;
+}) => string;

package/ai/prompts/instructions-formatter.js

@@ -1,3 +1,4 @@
+import { memoize } from '../../utils/function/memoize.js';
 import { hasOwnProperty, objectEntries } from '../../utils/object/object.js';
 import { assertDefined, isArray, isDefined, isObject, isString } from '../../utils/type-guards.js';
 // --- Factories ---
@@ -21,7 +22,7 @@ function isInstructionsList(obj) {
     return isObject(obj) && hasOwnProperty(obj, 'style') && hasOwnProperty(obj, 'items');
 }
 // --- Formatter Logic ---
-const INDENT_SIZE = 2;
+const INDENT_SIZE = 4;
 function getPrefix(style, index, sectionDepth) {
     switch (style) {
         case 'ordered':
@@ -58,6 +59,12 @@ function formatWithHangingIndent(text, baseIndent, prefix) {
  * Main recursive formatter.
  */
 function processNode(node, context) {
+    // 0. Handle Strings
+    if (isString(node)) {
+        const isSection = context.style == 'sections';
+        const currentBaseIndent = ' '.repeat(isSection ? 0 : context.indentDepth * INDENT_SIZE);
+        return formatWithHangingIndent(node, currentBaseIndent, '');
+    }
     // 1. Unwrap InstructionsList (The Wrapper)
     // If the node is a wrapper, we adopt its style and instruction, then process its items.
     if (isInstructionsList(node)) {
@@ -65,7 +72,7 @@ function processNode(node, context) {
         // If this Wrapper is a root node, the instruction is usually printed by the caller or ignored.
         // If this Wrapper is a value of a key, the key printer handles the instruction.
         // However, if we have a "Root Wrapper" with an instruction (rare in your example), handle it:
-        const header = node.instruction ? `${node.instruction}\n` : '';
+        const header = node.instruction ? `${node.instruction.trim()}\n\n` : '';
         // Determine next context
         const nextContext = {
             indentDepth: context.indentDepth, // Wrappers don't indent themselves, their content does
@@ -78,11 +85,14 @@ function processNode(node, context) {
     const isSection = context.style == 'sections';
     const currentBaseIndent = ' '.repeat(isSection ? 0 : context.indentDepth * INDENT_SIZE);
     const separator = isSection ? '\n\n' : '\n';
-    // 2. Handle Arrays (Simple Lists)
+    // 2. Handle Arrays
     if (isArray(node)) {
         return node.map((item, index) => {
             const prefix = getPrefix(context.style, index, context.sectionDepth);
-            return formatWithHangingIndent(item, currentBaseIndent, prefix);
+            if (isString(item)) {
+                return formatWithHangingIndent(item, currentBaseIndent, prefix);
+            }
+            return processNode(item, context);
         }).join(separator);
     }
     // 3. Handle Objects (Key-Value Maps)
@@ -145,6 +155,7 @@ function processNode(node, context) {
         return `${headerLine}${bodySeparator}${body}`;
     }).join(separator);
 }
+export const formatInstructions = memoize(
 /**
  * Formats a structured instructions object into a string representation suitable for AI prompts (Markdown).
  *
@@ -158,17 +169,19 @@ function processNode(node, context) {
  * @param options.initialDepth - The starting indentation level (default: 0).
  * @returns A formatted string.
  */
-export function formatInstructions(node, options = {}) {
+function formatInstructions(node, options = {}) {
     // Heuristic: If passing a raw object, assume it's a Root Section unless specified otherwise.
     // If passing a Wrapper, the Wrapper dictates the style.
     const initialStyle = isInstructionsList(node)
         ? node.style
         : isArray(node)
             ? 'unordered'
-            : 'sections';
+            : isString(node)
+                ? 'unordered'
+                : 'sections';
     return processNode(node, {
         indentDepth: options.initialDepth ?? 0,
         sectionDepth: 1,
         style: initialStyle,
     }).trim();
-}
+});

package/ai/prompts/instructions.js

@@ -2,7 +2,7 @@ import { unorderedList } from './instructions-formatter.js';
 export const jsonOutputInstructions = {
     'JSON Output': unorderedList({
         'Schema Compliance': 'Generate valid JSON that strictly matches the provided schema.',
-        'Nullable fields with missing data': 'Must be set to literal `null`.',
+        'Nullable fields with missing data': 'Must be set to literal `null`, not the string "null".',
         'Optional fields with missing data': 'Omit the key entirely (sparse JSON).',
     }),
 };

package/ai/prompts/steering.d.ts

@@ -0,0 +1,27 @@
+import { type Instructions } from './instructions-formatter.js';
+export type FewShotExample = {
+    input: any;
+    output: any;
+    /** Whether this is a negative example (showing what NOT to do). */
+    isNegative?: boolean;
+    /** Optional reason explaining why this example is positive or negative. */
+    reason?: string;
+};
+/**
+ * Creates a prompt addition for few-shot learning.
+ * @param examples An array of input/output pairs.
+ * @returns A formatted few-shot prompt.
+ */
+export declare function fewShotPrompt(examples: FewShotExample[]): Instructions;
+/**
+ * Creates a prompt addition to specify the output language.
+ * @param language The desired output language (e.g., 'English', 'German', 'en', 'de').
+ * @returns A formatted language prompt.
+ */
+export declare function languagePrompt(language: string): string;
+/**
+ * Creates a prompt addition for specific style or steering instructions.
+ * @param instructions Style or steering instructions (e.g., "Titles should be prefixed with [DMS]").
+ * @returns A formatted style prompt.
+ */
+export declare function stylePrompt(instructions: string): string;

package/ai/prompts/steering.js

@@ -0,0 +1,54 @@
+import { fromEntries } from '../../utils/object/object.js';
+import { isDefined, isString } from '../../utils/type-guards.js';
+import { formatInstructions, orderedList, unorderedList } from './instructions-formatter.js';
+function formatExampleValue(value) {
+    if (isString(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+/**
+ * Creates a prompt addition for few-shot learning.
+ * @param examples An array of input/output pairs.
+ * @returns A formatted few-shot prompt.
+ */
+export function fewShotPrompt(examples) {
+    if (examples.length == 0) {
+        return {};
+    }
+    const entries = examples
+        .map((example, index) => {
+        const type = example.isNegative ? 'NEGATIVE' : 'POSITIVE';
+        return [
+            `Example ${index + 1} (${type})`,
+            unorderedList({
+                Input: formatExampleValue(example.input),
+                Output: formatExampleValue(example.output),
+                ...(isDefined(example.reason) ? { Reason: example.reason } : {}),
+            }),
+        ];
+    });
+    return {
+        Examples: orderedList('Use the following examples to understand the expected input and output format', fromEntries(entries)),
+    };
+}
+/**
+ * Creates a prompt addition to specify the output language.
+ * @param language The desired output language (e.g., 'English', 'German', 'en', 'de').
+ * @returns A formatted language prompt.
+ */
+export function languagePrompt(language) {
+    return `IMPORTANT: All generated text content MUST be in ${language}.`.trim();
+}
+/**
+ * Creates a prompt addition for specific style or steering instructions.
+ * @param instructions Style or steering instructions (e.g., "Titles should be prefixed with [DMS]").
+ * @returns A formatted style prompt.
+ */
+export function stylePrompt(instructions) {
+    return `
+${formatInstructions({
+        'Style & Formatting Instructions': instructions,
+    })}
+`.trim();
+}

package/ai/tests/instructions-formatter.test.js

@@ -0,0 +1,115 @@
+import { describe, expect, test } from 'vitest';
+import { formatInstructions, orderedList, sections, unorderedList } from '../prompts/instructions-formatter.js';
+describe('Instructions Formatter', () => {
+    test('should format a simple unordered list of strings', () => {
+        const instructions = ['Item 1', 'Item 2'];
+        const result = formatInstructions(instructions);
+        expect(result).toBe(`- Item 1
+- Item 2`);
+    });
+    test('should format an object as sections by default', () => {
+        const instructions = {
+            'Section 1': 'Content 1',
+            'Section 2': 'Content 2',
+        };
+        const result = formatInstructions(instructions);
+        expect(result).toBe(`# Section 1
+
+Content 1
+
+# Section 2
+
+Content 2`);
+    });
+    test('should format nested unordered lists', () => {
+        const instructions = unorderedList({
+            Parent: unorderedList([
+                'Child 1',
+                'Child 2',
+            ]),
+        });
+        const result = formatInstructions(instructions);
+        expect(result).toBe(`- **Parent:**
+    - Child 1
+    - Child 2`);
+    });
+    test('should format ordered lists', () => {
+        const instructions = orderedList(['First', 'Second']);
+        const result = formatInstructions(instructions);
+        expect(result).toBe(`1. First
+2. Second`);
+    });
+    test('should format nested mixed lists', () => {
+        const instructions = orderedList({
+            'Step 1': unorderedList([
+                'Substep A',
+                'Substep B',
+            ]),
+        });
+        const result = formatInstructions(instructions);
+        expect(result).toBe(`1. **Step 1:**
+    - Substep A
+    - Substep B`);
+    });
+    test('should handle hanging indents for multi-line strings', () => {
+        const instructions = unorderedList([
+            `Line 1
+Line 2`,
+        ]);
+        const result = formatInstructions(instructions);
+        expect(result).toBe(`- Line 1
+  Line 2`);
+    });
+    test('should handle sections with instructions', () => {
+        const instructions = sections('General Info', {
+            SubSection: 'Details',
+        });
+        const result = formatInstructions(instructions);
+        expect(result).toBe(`General Info
+
+# SubSection
+
+Details`);
+    });
+    test('should handle nested sections (incrementing H level)', () => {
+        const instructions = sections({
+            'Level 1': sections({
+                'Level 2': 'Deep content',
+            }),
+        });
+        const result = formatInstructions(instructions);
+        expect(result).toBe(`# Level 1
+
+## Level 2
+
+Deep content`);
+    });
+    test('should handle complex nested structures with mixed styles', () => {
+        const instructions = sections({
+            Task: 'Perform the following actions',
+            Steps: orderedList({
+                'Step A': 'Do something',
+                'Step B': unorderedList([
+                    'Subtask B1',
+                    'Subtask B2',
+                ]),
+            }),
+            Conclusion: 'All done',
+        });
+        const expected = `# Task
+
+Perform the following actions
+
+# Steps
+
+1. **Step A:** Do something
+2. **Step B:**
+    - Subtask B1
+    - Subtask B2
+
+# Conclusion
+
+All done`;
+        expect(formatInstructions(instructions)).toBe(expected);
+    });
+});

package/ai/tests/steering.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, test } from 'vitest';
+import { fewShotPrompt, formatInstructions, languagePrompt, stylePrompt } from '../../ai/prompts/index.js';
+describe('ai-prompt-factories', () => {
+    test('fewShotPrompt should format positive examples', () => {
+        const prompt = formatInstructions(fewShotPrompt([
+            { input: { text: 'hello' }, output: { result: 'world' } },
+        ]));
+        expect(prompt).toContain('Examples');
+        expect(prompt).toContain('Example 1 (POSITIVE)');
+        expect(prompt).toContain('**Input:** {"text":"hello"}');
+        expect(prompt).toContain('**Output:** {"result":"world"}');
+    });
+    test('fewShotPrompt should format negative examples with reasons', () => {
+        const examples = [
+            { input: { text: 'bad' }, output: { result: 'no' }, isNegative: true, reason: 'This is not allowed' },
+        ];
+        const prompt = formatInstructions(fewShotPrompt(examples));
+        expect(prompt).toContain('Example 1 (NEGATIVE)');
+        expect(prompt).toContain('**Reason:** This is not allowed');
+    });
+    test('fewShotPrompt should format string examples without quotes', () => {
+        const prompt = formatInstructions(fewShotPrompt([
+            { input: 'input string', output: 'output string' },
+        ]));
+        expect(prompt).toContain('**Input:** input string');
+        expect(prompt).toContain('**Output:** output string');
+    });
+    test('languagePrompt should include the language', () => {
+        const prompt = languagePrompt('German');
+        expect(prompt).toBe('IMPORTANT: All generated text content MUST be in German.');
+    });
+    test('stylePrompt should include the instructions', () => {
+        const prompt = stylePrompt('Use formal tone.');
+        expect(prompt).toContain('Style & Formatting Instructions');
+        expect(prompt).toContain('Use formal tone.');
+    });
+});

package/application/application.d.ts

@@ -1,5 +1,5 @@
 import { CancellationSignal } from '../cancellation/token.js';
-import { type ProvidersItem } from '../injector/injector.js';
+import { Injector, type ProvidersItem } from '../injector/injector.js';
 import { Module } from '../module/index.js';
 import type { OneOrMany, Type } from '../types/index.js';
 export type InitializerFn = () => void | Promise<void>;
@@ -11,6 +11,7 @@ export declare const APPLICATION_INSTANCE_ID: import("../injector/token.js").Inj
 export declare const APPLICATION_NAME: import("../injector/token.js").InjectionToken<string, never>;
 export declare class Application {
     #private;
+    get injector(): Injector;
     static create(name: string, providers?: OneOrMany<ProvidersItem>[]): Application;
     static run(name: string, providers?: OneOrMany<ProvidersItem>[]): Application;
     get shutdownSignal(): CancellationSignal;

package/application/application.js

@@ -28,6 +28,9 @@ let Application = Application_1 = class Application {
     #moduleTypesAndInstances = new Set(injectAll(APPLICATION_MODULE, undefined, { optional: true }));
     #shutdownPromise = new DeferredPromise();
     #shutdownToken = inject(CancellationSignal, undefined, { optional: true })?.createChild() ?? new CancellationToken();
+    get injector() {
+        return this.#injector;
+    }
     static create(name, providers = []) {
         const injector = new Injector(`${name}ApplicationInjector`);
         injector.register(APPLICATION_INSTANCE_ID, { useValue: crypto.randomUUID() });

package/authentication/client/module.d.ts

@@ -1,5 +1,5 @@
 import type { ApiClientImplementation } from '../../api/index.js';
-import { Injector } from '../../injector/injector.js';
+import { Injector } from '../../injector/index.js';
 import type { Type } from '../../types/index.js';
 import type { AuthenticationApiDefinition } from '../authentication.api.js';
 /**

package/authentication/client/module.js

@@ -1,6 +1,5 @@
 import { HTTP_CLIENT_MIDDLEWARE } from '../../http/client/tokens.js';
-import { getCurrentInjector } from '../../injector/inject.js';
-import { Injector } from '../../injector/injector.js';
+import { forwardRef, getCurrentInjector, Injector } from '../../injector/index.js';
 import { isDefined } from '../../utils/type-guards.js';
 import { AuthenticationClientService } from './authentication.service.js';
 import { authenticationMiddleware, logoutOnUnauthorizedMiddleware, waitForAuthenticationCredentialsMiddleware } from './http-client.middleware.js';
@@ -20,19 +19,19 @@ export function configureAuthenticationClient(config, injector = getCurrentInjec
     if (config.registerMiddleware == true) {
         (injector ?? Injector).register(HTTP_CLIENT_MIDDLEWARE, {
             useFactory(_, context) {
-                const authenticationService = context.resolve(AuthenticationClientService, undefined, { forwardRef: true, forwardRefTypeHint: 'object' });
+                const authenticationService = context.resolve(forwardRef(() => AuthenticationClientService, 'object'));
                 return waitForAuthenticationCredentialsMiddleware(authenticationService);
             },
         }, { multi: true });
         (injector ?? Injector).register(HTTP_CLIENT_MIDDLEWARE, {
             useFactory(_, context) {
-                const authenticationService = context.resolve(AuthenticationClientService, undefined, { forwardRef: true, forwardRefTypeHint: 'object' });
+                const authenticationService = context.resolve(forwardRef(() => AuthenticationClientService, 'object'));
                 return logoutOnUnauthorizedMiddleware(authenticationService);
             },
         }, { multi: true });
         (injector ?? Injector).register(HTTP_CLIENT_MIDDLEWARE, {
             useFactory(_, context) {
-                const authenticationService = context.resolve(AuthenticationClientService, undefined, { forwardRef: true, forwardRefTypeHint: 'object' });
+                const authenticationService = context.resolve(forwardRef(() => AuthenticationClientService, 'object'));
                 return authenticationMiddleware(authenticationService);
             },
         }, { multi: true });

package/authentication/tests/authentication-ancillary.service.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import { runInInjectionContext } from '../../injector/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { DefaultAuthenticationAncillaryService } from './authentication.test-ancillary-service.js';
 describe('AuthenticationAncillaryService', () => {
     test('default implementation should be abstract or have defaults', async () => {