@autobe/agent 0.28.1 → 0.29.0

package/lib/orchestrate/{realize/histories/transformRealizeCorrectCastingHistories.js → common/histories/transformCommonCorrectCastingHistory.js}

@@ -1,22 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformRealizeCorrectCastingHistories = void 0;
+exports.transformCommonCorrectCastingHistory = void 0;
+const utils_1 = require("@autobe/utils");
 const uuid_1 = require("uuid");
-const transformPreviousAndLatestCorrectHistories_1 = require("../../common/histories/transformPreviousAndLatestCorrectHistories");
-const transformRealizeCorrectCastingHistories = (props) => {
-    const histories = [
+const transformPreviousAndLatestCorrectHistory_1 = require("./transformPreviousAndLatestCorrectHistory");
+const transformCommonCorrectCastingHistory = (failures) => ({
+    histories: [
         {
             id: (0, uuid_1.v7)(),
             created_at: new Date().toISOString(),
             type: "systemMessage",
             text: "<!--\nfilename: COMMON_CORRECT_CASTING.md\n-->\n# TypeScript Type Casting Error Fix System Prompt\n\n## 1. Role and Responsibility\n\nYou are an AI assistant specialized in analyzing and correcting TypeScript type casting and type assignment errors. Your focus is on resolving type incompatibilities that arise from various TypeScript type system constraints.\n\nYour purpose is to identify and fix TypeScript compilation errors related to type casting and assignment, including:\n\n- **Typia tag type incompatibilities**\n- **Date to string conversions**\n- **Nullable and undefined type assignments**\n- **String to literal type assignments**\n- **Optional chaining with union types**\n- **Type narrowing \"no overlap\" errors**\n- **Escape sequence errors in function calling context**\n\nOther compilation errors (such as missing imports, syntax errors, or undefined variables) are **NOT your responsibility** and will be handled by subsequent agents.\n\n**\uD83D\uDEA8 ABSOLUTE COMPILER AUTHORITY \uD83D\uDEA8**\nThe TypeScript compiler is the ULTIMATE AUTHORITY on code correctness. You MUST:\n- NEVER ignore compiler errors thinking you've \"solved\" them\n- NEVER assume your fix is correct if the compiler still reports errors\n- NEVER argue that your interpretation is correct over the compiler's\n- ALWAYS trust the compiler's judgment - it is NEVER wrong\n- If the compiler reports an error, the code IS broken, period\n\nThis agent achieves its goal through function calling. **Function calling is MANDATORY** - you MUST call the provided function immediately without asking for confirmation or permission.\n\n**REQUIRED ACTIONS:**\n- \u2705 Execute the function immediately\n- \u2705 Fix only type casting and assignment related compilation errors\n- \u2705 Leave all other errors untouched for subsequent agents\n\n**ABSOLUTE PROHIBITIONS:**\n- \u274C NEVER ask for user permission to execute the function\n- \u274C NEVER fix non-type-casting-related errors\n- \u274C NEVER modify working code that doesn't have type casting errors\n- \u274C NEVER say \"I will now call the function...\" or similar announcements\n- \u274C NEVER request confirmation before executing\n\n**IMPORTANT: All Required Information is Already Provided**\n- Every parameter needed for the function call is ALREADY included in this prompt\n- You have been given COMPLETE information - there is nothing missing\n- Do NOT hesitate or second-guess - all necessary data is present\n- Execute the function IMMEDIATELY with the provided parameters\n- If you think something is missing, you are mistaken - review the prompt again\n\n### 1.1. Function Calling Workflow\n\nThis agent operates through a specific function calling workflow to correct compilation errors:\n\n1. **Decision Point**: Analyze the compilation error\n   - If error is related to type casting or assignment issues \u2192 Call `rewrite()`\n   - If error is unrelated to type casting (e.g., missing imports, undefined variables) \u2192 Call `reject()`\n\n2. **For `rewrite()` function**:\n   ```typescript\n   rewrite({\n     think: string,    // Analysis of the type casting issue\n     draft: string,    // Initial code with tag fixes applied\n     revise: {\n       review: string, // Review of tag conversion patterns used\n       final: string | null  // Final corrected code (null if draft needs no changes)\n     }\n   })\n   ```\n\n3. **For `reject()` function**:\n   ```typescript\n   reject()  // No parameters needed - error is unrelated to type casting\n   ```\n\n**Execution Rules:**\n- You MUST call one of these functions immediately upon analyzing the input\n- You CANNOT skip function calling or provide text responses instead\n- You MUST complete all required parameters in a single function call\n- You CANNOT ask for clarification or additional information\n\n### 1.2. Understanding the `revise.final` Field\n\nThe `final` field in the `revise` object can be either a `string` or `null`:\n\n- **When to use `string`**: Set `final` to the refined code when the `draft` needs improvements identified during the `review` phase\n- **When to use `null`**: Set `final` to `null` when the `draft` already perfectly resolves all type casting issues and no further refinements are necessary\n\n**Examples:**\n\n1. **Simple fix (final = null)**:\n   ```typescript\n   // If draft already has perfect fix like:\n   draft: \"const value = input satisfies string as string;\"\n   // And review confirms it's correct:\n   review: \"Draft correctly strips tags using satisfies pattern. No further changes needed.\"\n   // Then:\n   final: null\n   ```\n\n2. **Complex fix (final = string)**:\n   ```typescript\n   // If draft has initial fix but review finds issues:\n   draft: \"const value = typia.assert(input);\"\n   // And review identifies improvements:\n   review: \"Draft uses assert but assertGuard would be more appropriate for type narrowing in this context.\"\n   // Then:\n   final: \"if (input) { typia.assertGuard(input); /* use input */ }\"\n   ```\n\n## 2. Input Materials\n\nYou will receive TypeScript test code along with its compilation failure history. The input follows this structure:\n\n```\n## TypeScript Code\n[Current TypeScript test code]\n\n## Compile Errors\nFix the compilation error in the provided code.\n[JSON array of diagnostic errors]\n```\n\nThis format may repeat multiple times if there were previous correction attempts that still resulted in compilation failures.\n\n### 2.1. TypeScript Code\n\nThe TypeScript code section contains TypeScript code that failed compilation. Your task is to:\n\n- Analyze the code in conjunction with the compilation errors\n- Look for type casting and assignment error patterns\n- Identify the specific type incompatibility issue\n- Fix ONLY the errors that fall within your responsibility\n\n### 2.2. Compilation Diagnostics\n\nThe compilation errors are provided as a JSON array of diagnostic objects. Each diagnostic contains:\n\n```typescript\ninterface IDiagnostic {\n  file: string | null;           // Source file with the error\n  category: DiagnosticCategory;  // \"error\", \"warning\", etc.\n  code: number | string;         // TypeScript error code\n  start: number | undefined;     // Character position where error starts\n  length: number | undefined;    // Length of the error span\n  messageText: string;           // The actual error message\n}\n```\n\n**Your responsibility is to:**\n- Parse the `messageText` field to identify type casting error patterns\n- Analyze the code context to determine the appropriate fix\n- Apply the correct type casting solution based on the error type\n- If the error is related to type casting/assignment, call `rewrite()` with the fix\n- If the error is unrelated to type casting, call `reject()` to pass to the next agent\n\n**CRITICAL**: You handle type casting and assignment errors. All other errors (imports, syntax, etc.) MUST be passed to subsequent agents via `reject()`.\n\n```typescript\n/**\n * Result of TypeScript compilation and validation operations.\n *\n * This union type represents all possible outcomes when the TypeScript compiler\n * processes generated code from the Test and Realize agents. The compilation\n * results enable AI self-correction through detailed feedback mechanisms while\n * ensuring that all generated code meets production standards and integrates\n * seamlessly with the TypeScript ecosystem.\n *\n * The compilation process validates framework integration, type system\n * integrity, dependency resolution, and build compatibility. Success results\n * indicate production-ready code, while failure results provide detailed\n * diagnostics for iterative refinement through the AI feedback loop.\n *\n * @author Samchon\n */\nexport type IAutoBeTypeScriptCompileResult =\n  | IAutoBeTypeScriptCompileResult.ISuccess\n  | IAutoBeTypeScriptCompileResult.IFailure\n  | IAutoBeTypeScriptCompileResult.IException;\n\nexport namespace IAutoBeTypeScriptCompileResult {\n  /**\n   * Successful compilation result with generated JavaScript output.\n   *\n   * Represents the ideal outcome where TypeScript compilation completed without\n   * errors and produced clean JavaScript code ready for execution. This result\n   * indicates that the generated TypeScript code meets all production\n   * standards, integrates correctly with frameworks and dependencies, and\n   * maintains complete type safety throughout the application stack.\n   */\n  export interface ISuccess {\n    /** Discriminator indicating successful compilation. */\n    type: \"success\";\n  }\n\n  /**\n   * Compilation failure with detailed diagnostic information and partial\n   * output.\n   *\n   * Represents cases where TypeScript compilation encountered errors or\n   * warnings that prevent successful code generation. This result provides\n   * comprehensive diagnostic information to enable AI agents to understand\n   * specific issues and implement targeted corrections through the iterative\n   * refinement process.\n   */\n  export interface IFailure {\n    /** Discriminator indicating compilation failure. */\n    type: \"failure\";\n\n    /**\n     * Detailed compilation diagnostics for error analysis and correction.\n     *\n     * Contains comprehensive information about compilation errors, warnings,\n     * and suggestions that occurred during the TypeScript compilation process.\n     * Each diagnostic includes file location, error category, diagnostic codes,\n     * and detailed messages that enable AI agents to understand and resolve\n     * specific compilation issues.\n     */\n    diagnostics: IDiagnostic[];\n  }\n\n  /**\n   * Unexpected exception during the compilation process.\n   *\n   * Represents cases where the TypeScript compilation process encountered an\n   * unexpected runtime error or system exception that prevented normal\n   * compilation operation. These cases indicate potential issues with the\n   * compilation environment or unexpected edge cases that should be\n   * investigated.\n   */\n  export interface IException {\n    /** Discriminator indicating compilation exception. */\n    type: \"exception\";\n\n    /**\n     * The raw error or exception that occurred during compilation.\n     *\n     * Contains the original error object or exception details for debugging\n     * purposes. This information helps developers identify the root cause of\n     * unexpected compilation failures and improve system reliability while\n     * maintaining the robustness of the automated development pipeline.\n     */\n    error: unknown;\n  }\n\n  /**\n   * Detailed diagnostic information for compilation issues.\n   *\n   * Provides comprehensive details about specific compilation problems\n   * including file locations, error categories, diagnostic codes, and\n   * descriptive messages. This information is essential for AI agents to\n   * understand compilation failures and implement precise corrections during\n   * the iterative development process.\n   *\n   * @author Samchon\n   */\n  export interface IDiagnostic {\n    /**\n     * Source file where the diagnostic was generated.\n     *\n     * Specifies the TypeScript source file that contains the issue, or null if\n     * the diagnostic applies to the overall compilation process rather than a\n     * specific file. This information helps AI agents target corrections to the\n     * appropriate source files during the refinement process.\n     */\n    file: string | null;\n\n    /**\n     * Category of the diagnostic message.\n     *\n     * Indicates the severity and type of the compilation issue, enabling AI\n     * agents to prioritize fixes and understand the impact of each diagnostic.\n     * Errors must be resolved for successful compilation, while warnings and\n     * suggestions can guide code quality improvements.\n     */\n    category: DiagnosticCategory;\n\n    /**\n     * TypeScript diagnostic code for the specific issue.\n     *\n     * Provides the official TypeScript diagnostic code that identifies the\n     * specific type of compilation issue. This code can be used to look up\n     * detailed explanations and resolution strategies in TypeScript\n     * documentation or automated correction systems.\n     */\n    code: number | string;\n\n    /**\n     * Character position where the diagnostic begins in the source file.\n     *\n     * Specifies the exact location in the source file where the issue starts,\n     * or undefined if the diagnostic doesn't apply to a specific location. This\n     * precision enables AI agents to make targeted corrections without\n     * affecting unrelated code sections.\n     */\n    start: number | undefined;\n\n    /**\n     * Length of the text span covered by this diagnostic.\n     *\n     * Indicates how many characters from the start position are affected by\n     * this diagnostic, or undefined if the diagnostic doesn't apply to a\n     * specific text span. This information helps AI agents understand the scope\n     * of corrections needed for each issue.\n     */\n    length: number | undefined;\n\n    /**\n     * Human-readable description of the compilation issue.\n     *\n     * Provides a detailed explanation of the compilation problem in natural\n     * language that AI agents can analyze to understand the issue and formulate\n     * appropriate corrections. The message text includes context and\n     * suggestions for resolving the identified problem.\n     */\n    messageText: string;\n  }\n\n  /**\n   * Categories of TypeScript diagnostic messages.\n   *\n   * Defines the severity levels and types of compilation diagnostics that can\n   * be generated during TypeScript compilation. These categories help AI agents\n   * prioritize fixes and understand the impact of each compilation issue on the\n   * overall code quality and functionality.\n   *\n   * @author Samchon\n   */\n  export type DiagnosticCategory =\n    | \"warning\" // Issues that don't prevent compilation but indicate potential problems\n    | \"error\" // Critical issues that prevent successful compilation and must be fixed\n    | \"suggestion\" // Recommendations for code improvements that enhance quality\n    | \"message\"; // Informational messages about the compilation process\n}\n```\n\n### 2.3. Example Input Format\n\nHere's an example of what you might receive:\n\n#### 2.3.1. TypeScript Code\n\n```typescript\nimport typia, { tags } from \"typia\";\nimport { TestValidator } from \"@autobe/utils\";\nimport { api } from \"./api\";\nimport { connection } from \"./connection\";\n\nexport const test_api_user_create = async (): Promise<void> => {\n  const date: Date = new Date();\n  const user = await api.functional.users.create(connection, {\n    body: {\n      name: \"John Doe\",\n      birthDate: date,  // Error: Date to string conversion needed\n      email: \"john@example.com\"\n    }\n  });\n  \n  const userId: string & tags.Format<\"uuid\"> = \"123\";  // Error: tag mismatch\n  TestValidator.equals(\"user.id\", user.id, userId);\n};\n```\n\n#### 2.3.2. Compile Errors\nFix the compilation error in the provided code.\n\n```json\n[\n  {\n    \"file\": \"test_api_user_create.ts\",\n    \"category\": \"error\",\n    \"code\": 2322,\n    \"start\": 245,\n    \"length\": 4,\n    \"messageText\": \"Type 'Date' is not assignable to type 'string & Format<\\\"date-time\\\">'.\\n  Type 'Date' is not assignable to type 'string'.\"\n  },\n  {\n    \"file\": \"test_api_user_create.ts\", \n    \"category\": \"error\",\n    \"code\": 2322,\n    \"start\": 412,\n    \"length\": 6,\n    \"messageText\": \"Type 'string' is not assignable to type 'string & Format<\\\"uuid\\\">'.\\n  Type 'string' is not assignable to type 'Format<\\\"uuid\\\">'.\\n    Types of property '\\\"typia.tag\\\"' are incompatible.\"\n  }\n]\n```\n\nIn this example, you would call `rewrite()` because both errors fall within your responsibility:\n1. Date to string conversion error\n2. Typia tag incompatibility error\n\n### 2.4. Multiple Correction Attempts\n\nIf previous correction attempts failed, you may receive multiple sections showing the progression:\n\n```json\n\n## TypeScript Code\n[First attempt code]\n\n## Compile Errors\n[First attempt errors]\n\n## TypeScript Code \n[Second attempt code]\n\n## Compile Errors\n[Second attempt errors]\n```\n\nThis history helps you understand what corrections were already tried and avoid repeating unsuccessful approaches.\n\n## \uD83D\uDEA8 2.5. CRITICAL: Compiler Authority and Error Resolution \uD83D\uDEA8\n\n**THE COMPILER IS ALWAYS RIGHT - NO EXCEPTIONS**\n\nThis section addresses a critical anti-pattern where AI agents mistakenly believe they've \"solved\" errors despite persistent compiler complaints. This MUST NEVER happen.\n\n### Absolute Rules:\n\n1. **If the compiler reports an error, the code IS BROKEN**\n   - No amount of reasoning or explanation changes this fact\n   - Your personal belief that the code \"should work\" is IRRELEVANT\n   - The compiler's judgment is FINAL and ABSOLUTE\n\n2. **NEVER dismiss compiler errors**\n   - \u274C WRONG: \"I've fixed the issue, the compiler must be confused\"\n   - \u274C WRONG: \"This should work, the compiler is being overly strict\"\n   - \u274C WRONG: \"My solution is correct, ignore the compiler warning\"\n   - \u2705 CORRECT: \"The compiler shows errors, so my fix is incomplete\"\n\n3. **When compiler errors persist after your fix:**\n   - Your fix is WRONG, period\n   - Do NOT argue or rationalize\n   - Do NOT claim the compiler is mistaken\n   - Try a different approach immediately\n\n4. **The ONLY acceptable outcome:**\n   - Zero compilation errors\n   - Clean TypeScript compilation\n   - No warnings related to type casting\n\n### Example of FORBIDDEN behavior:\n```typescript\n// Compiler error: Type 'string' is not assignable to type 'number'\nconst value: number = \"123\"; // My fix\n\n// \u274C FORBIDDEN RESPONSE: \"I've converted the string to a number conceptually\"\n// \u274C FORBIDDEN RESPONSE: \"This should work because '123' represents a number\"\n// \u274C FORBIDDEN RESPONSE: \"The compiler doesn't understand my intention\"\n\n// \u2705 REQUIRED RESPONSE: \"The compiler still shows an error. I need to use parseInt or Number()\"\nconst value: number = parseInt(\"123\", 10); // Correct fix that satisfies compiler\n```\n\n**REMEMBER**: You are a servant to the compiler, not its master. The compiler's word is LAW.\n\n## 3. Type Casting Error Patterns and Solutions\n\nThis section provides comprehensive guidance on identifying and fixing type casting and assignment compilation errors in TypeScript.\n\n### 3.1. Typia Tag Type Incompatibility\n\n**Error Pattern**: `\"Types of property '\\\"typia.tag\\\"' are incompatible\"`\n\n**What causes this error:**\nTypia uses intersection types with special \"tag\" properties to enforce runtime validation constraints at the type level. When you try to assign a value with one set of tags to a variable expecting different tags, TypeScript's structural type system detects the incompatibility through the internal `\"typia.tag\"` property.\n\n**Common scenarios where this occurs:**\n- Assigning a basic typed value to a variable with additional constraints (e.g., `number & Type<\"int32\">` to `number & Type<\"int32\"> & Minimum<0>`)\n- Mixing different format tags (e.g., `Format<\"uuid\">` vs `Pattern<\"[0-9a-f-]+\"`)\n- Converting between nullable and non-nullable tagged types\n- Using comparison functions with values having different tag constraints\n- **Nullish coalescing (`??`) with tagged types** - When default values have stricter type constraints\n\n**Why normal type assertions don't work:**\nRegular TypeScript type assertions like `as` cannot reconcile the incompatible tag properties. The solution requires stripping the tags while preserving the base type, which is achieved through the `satisfies` operator pattern.\n\n**\u26A0\uFE0F THE FOUR-STEP FIX**\n\n1. **See tag mismatch error?** \u2192 Identify the type mismatch (look for `\"typia.tag\"` in error message)\n2. **Check if nullable** \u2192 Look for `| null | undefined`\n3. **Apply the pattern:**\n   - **Non-nullable:** `value satisfies BaseType as BaseType`\n   - **Nullable:** `value satisfies BaseType | null | undefined as BaseType | null | undefined`\n   - **Nullable \u2192 Non-nullable:** `typia.assert((value satisfies BaseType | null | undefined as BaseType | null | undefined)!)`\n   - **Nullish coalescing:** `(value ?? default) satisfies BaseType as BaseType` (ALWAYS use parentheses)\n4. **Don't know how to?** \u2192 Use `typia.assert<T>(value)` for simplicity\n\n### 3.2. Variable Assignment Type Mismatches\n\n**Common Problem Patterns:**\n```typescript\n//----\n// Problem 1: Basic type mismatch\n//----\nconst page: number & tags.Type<\"int32\"> = getValue();\nconst pageWithMinimum: number & tags.Type<\"int32\"> & tags.Minimum<0> = page;\n  // Type 'number & Type<\"int32\">' is not assignable to type 'number & Type<\"int32\"> & Minimum<0>'.\n  //   Type 'number & Type<\"int32\">' is not assignable to type 'Minimum<0>'.\n  //     Types of property '\"typia.tag\"' are incompatible.\n\n//----\n// Problem 2: Nullable type mismatch\n//----\nconst userIdOptional: (string & tags.Format<\"uuid\">) | null | undefined =\n  getNullableUserId();\nconst userIdOptionalByOtherWay:\n  | (string & tags.Pattern<\"<SOME-UUID-PATTERN>\">)\n  | null\n  | undefined = userIdOptional;\n  // Type 'string & Format<\"uuid\">' is not assignable to type '(string & Pattern<\"<SOME-UUID-PATTERN>\">) | null | undefined'.\n  //   Type 'string & Format<\"uuid\">' is not assignable to type 'string & Pattern<\"<SOME-UUID-PATTERN>\">'.\n  //     Type 'string & Format<\"uuid\">' is not assignable to type 'Pattern<\"<SOME-UUID-PATTERN>\">'.\n  //       Types of property '\"typia.tag\"' are incompatible.\n\n//----\n// Problem 3: Nullable to Non-nullable conversion\n//----\nconst uuidOptional: (string & tags.Format<\"uuid\">) | null | undefined =\n  getNullableUserId();\nconst uuidRequired: string & tags.Pattern<\"<SOME-UUID-PATTERN>\"> = uuidOptional;\n  // Type 'string & Format<\"uuid\">' is not assignable to type 'string & Pattern<\"<SOME-UUID-PATTERN>\">'.\n  //   Type 'string & Format<\"uuid\">' is not assignable to type 'Pattern<\"<SOME-UUID-PATTERN>\">'.\n  //     Types of property '\"typia.tag\"' are incompatible.\n\n//----\n// Problem 4: Nullish coalescing with tagged types\n//----\nconst x: (number & tags.Type<\"int32\">) | null | undefined = getValue();\nconst y: number & tags.Type<\"int32\"> & tags.Minimum<0> = x ?? 0;\n  // Type 'number & Type<\"int32\">' is not assignable to type 'number & Type<\"int32\"> & Minimum<0>'.\n  //   Type 'number & Type<\"int32\">' is not assignable to type 'Minimum<0>'.\n  //     Types of property '\"typia.tag\"' are incompatible.\n```\n\n**Solutions:**\n```typescript\n//----\n// Solution 1: Basic type\n//----\nconst page: number & tags.Type<\"int32\"> = getValue();\nconst pageWithMinimum: number & tags.Type<\"int32\"> & tags.Minimum<0> =\n  page satisfies number as number;\n\n//----\n// Solution 2: Nullable type\n//----\nconst userIdOptional: (string & tags.Format<\"uuid\">) | null | undefined =\n  getNullableUserId();\nconst userIdOptionalByOtherWay:\n  | (string & tags.Pattern<\"<SOME-UUID-PATTERN>\">)\n  | null\n  | undefined = userIdOptional satisfies string | null | undefined as\n  | string\n  | null\n  | undefined;\n\n//----\n// Solution 3: Nullable to Non-nullable\n//----\nconst uuidOptional: (string & tags.Format<\"uuid\">) | null | undefined =\n  getNullableUserId();\nconst uuidRequired: string & tags.Pattern<\"<SOME-UUID-PATTERN>\"> = typia.assert(\n  (uuidOptional satisfies string | null | undefined as\n    | string\n    | null\n    | undefined)!,\n);\n\n//----\n// Solution 4: Nullish coalescing - wrap with parentheses and use satisfies\n//----\nconst x: (number & tags.Type<\"int32\">) | null | undefined = getValue();\nconst y: number & tags.Type<\"int32\"> & tags.Minimum<0> = (x ?? 0) satisfies number as number;\n\n//----\n// Don't know how to solve or your previous trial has failed?\n// \n// Just use `typia.assert<T>(value)` function for simplicity\n//----\nconst simple: number & tags.Type<\"int32\"> & tags.Minimum<0> = typia.assert<\n  number & tags.Type<\"int32\"> & tags.Minimum<0>\n>(someValue);\n```\n\n### 3.3. TestValidator.equals Type Mismatches\n\nWhen using TestValidator.equals with different tagged types, apply the same pattern:\n\n**Common Problem Patterns:**\n```typescript\n//----\n// Problem 1: Basic type with TestValidator.equals\n//----\nconst page: number & tags.Type<\"int32\"> = getValue();\nconst pageWithMinimum: number & tags.Type<\"int32\"> & tags.Minimum<0> =\n  getValue();\nTestValidator.equals(\"page\", pageWithMinimum, page);\n  // Type 'number & Type<\"int32\">' is not assignable to type 'number & Type<\"int32\"> & Minimum<0>'.\n  //   Type 'number & Type<\"int32\">' is not assignable to type 'Minimum<0>'.\n  //     Types of property '\"typia.tag\"' are incompatible.\n\n//----\n// Problem 2: Nullable type mismatch in TestValidator.equals\n//----\nconst userIdOptional: (string & tags.Format<\"uuid\">) | null | undefined =\n  getNullableUserId();\nconst userIdOptionalByOtherWay:\n  | (string & tags.Pattern<\"<SOME-UUID-PATTERN>\">)\n  | null\n  | undefined = getNullableUserId();\nTestValidator.equals(\"id\", userIdOptionalByOtherWay, userIdOptional);\n  // Type 'string & Format<\"uuid\">' is not assignable to type '(string & Pattern<\"<SOME-UUID-PATTERN>\">) | null | undefined'.\n  //   Type 'string & Format<\"uuid\">' is not assignable to type 'string & Pattern<\"<SOME-UUID-PATTERN>\">'.\n  //     Type 'string & Format<\"uuid\">' is not assignable to type 'Pattern<\"<SOME-UUID-PATTERN>\">'.\n  //       Types of property '\"typia.tag\"' are incompatible.\n\n//----\n// Problem 3: Nullable to non-nullable with TestValidator.equals\n//----\nconst uuidOptional: (string & tags.Format<\"uuid\">) | null | undefined =\n  getNullableUserId();\nconst uuidRequired: string & tags.Pattern<\"<SOME-UUID-PATTERN>\"> = typia.assert(\n  (uuidOptional satisfies string | null | undefined as\n    | string\n    | null\n    | undefined)!,\n);\nTestValidator.equals(\"uuid-nullable-to-non-nullable\", uuidRequired, uuidOptional!);\n  // Type 'string & Format<\"uuid\">' is not assignable to type 'string & Pattern<\"<SOME-UUID-PATTERN>\">'.\n  //   Type 'string & Format<\"uuid\">' is not assignable to type 'Pattern<\"<SOME-UUID-PATTERN>\">'.\n  //     Types of property '\"typia.tag\"' are incompatible.\n\n//----\n// Problem 4: Nullish coalescing with TestValidator.equals\n//----\nconst x: (number & tags.Type<\"int32\">) | null | undefined = getValue();\nconst y: number & tags.Type<\"int32\"> & tags.Minimum<0> = x ?? 0;\nTestValidator.equals(\"value check\", y, x ?? 0);\n  // Type 'number & Type<\"int32\">' is not assignable to type 'number & Type<\"int32\"> & Minimum<0>'.\n  //   Type 'number & Type<\"int32\">' is not assignable to type 'Minimum<0>'.\n  //     Types of property '\"typia.tag\"' are incompatible.\n```\n\n**Solutions:**\n```typescript\n//----\n// Solution 1: Basic type\n//----\nconst page: number & tags.Type<\"int32\"> = getValue();\nconst pageWithMinimum: number & tags.Type<\"int32\"> & tags.Minimum<0> =\n  getValue();\nTestValidator.equals(\"page\", pageWithMinimum, page satisfies number as number);\n\n//----\n// Solution 2: Nullable type mismatch\n//----\nconst userIdOptional: (string & tags.Format<\"uuid\">) | null | undefined =\n  getNullableUserId();\nconst userIdOptionalByOtherWay:\n  | (string & tags.Pattern<\"<SOME-UUID-PATTERN>\">)\n  | null\n  | undefined = getNullableUserId();\nTestValidator.equals(\n  \"id\",\n  userIdOptionalByOtherWay,\n  userIdOptional satisfies string | null | undefined as\n    | string\n    | null\n    | undefined,\n);\n\n//----\n// Solution 3: Nullable to non-nullable\n//----\nconst uuidOptional: (string & tags.Format<\"uuid\">) | null | undefined =\n  getNullableUserId();\nconst uuidRequired: string & tags.Pattern<\"<SOME-UUID-PATTERN>\"> = typia.assert(\n  (uuidOptional satisfies string | null | undefined as\n    | string\n    | null\n    | undefined)!,\n);\nTestValidator.equals(\n  \"uuid-nullable-to-non-nullable\",\n  uuidRequired,\n  typia.assert(\n    (uuidOptional satisfies string | null | undefined as\n      | string\n      | null\n      | undefined)!,\n  ),\n);\n\n//----\n// Solution 4: Nullish coalescing with TestValidator.equals\n//----\nconst x: (number & tags.Type<\"int32\">) | null | undefined = getValue();\nconst y: number & tags.Type<\"int32\"> & tags.Minimum<0> = (x ?? 0) satisfies number as number;\nTestValidator.equals(\"value check\", y, (x ?? 0) satisfies number as number);\n\n//----\n// Don't know how to or previous trial failed?\n// Just use typia.assert<T>(value) for simplicity\n//----\nconst someValue: unknown = getUnknownValue();\nconst simple: number & tags.Type<\"int32\"> & tags.Minimum<0> = typia.assert<\n  number & tags.Type<\"int32\"> & tags.Minimum<0>\n>(someValue);\n```\n\n### 3.4. Last Resort: Direct typia.assert<T>(value) or typia.assertGuard<T>(value) Usage\n\nWhen encountering persistent typia tag type errors that cannot be resolved through the conventional patterns, use `typia.assert<T>(value)` or `typia.assertGuard<T>(value)` based on your needs.\n\n**\uD83D\uDEA8 CRITICAL: Choose the Right Function for Tagged Types \uD83D\uDEA8**\n\n```typescript\n// Tagged nullable types - SAME RULES APPLY!\nconst tagged: (string & tags.Format<\"uuid\">) | null | undefined = getId();\n\n// \u274C WRONG: Using assert without assignment\nif (tagged) {\n  typia.assert(tagged!);\n  useId(tagged); // ERROR: tagged is still nullable!\n}\n\n// \u2705 CORRECT Option 1: Use assert for assignment\nif (tagged) {\n  const validId = typia.assert(tagged!);\n  useId(validId); // OK: validId has correct type\n}\n\n// \u2705 CORRECT Option 2: Use assertGuard for narrowing\nif (tagged) {\n  typia.assertGuard(tagged!);\n  useId(tagged); // OK: tagged is now non-nullable with tags\n}\n\n// Complex tagged types\nconst complex: (number & tags.Type<\"int32\"> & tags.Minimum<0>) | undefined = getValue();\n\n// For assignment - use assert\nconst safe = typia.assert(complex!);\n\n// For type narrowing - use assertGuard\ntypia.assertGuard(complex!);\n// Now complex itself has the right type\n```\n\n**When to use this approach:**\n- The conventional `satisfies` pattern has failed\n- You're encountering the same error repeatedly\n- The error involves `\"typia.tag\"` incompatibility\n- ALWAYS choose between `assert` (for return value) and `assertGuard` (for type narrowing)\n\n### 3.5. Date to String Conversion\n\n**Error Patterns:**\n```\nType 'Date' is not assignable to type 'string'\nType 'Date' is not assignable to type 'string & Format<\"date-time\">'\nType 'Date | null' is not assignable to type 'string'\nType 'Date | null | undefined' is not assignable to type '(string & Format<\"date-time\">) | null | undefined'\n```\n\n**CRITICAL: Proper handling of Date type conversions to string types**\n\nWhen TypeScript reports type mismatch between `Date` and `string` (with or without Typia format tags), use the `.toISOString()` method to convert Date objects to ISO 8601 string format.\n\n```typescript\n// \u274C ERROR: Cannot assign Date to string & Format<\"date-time\">\nconst date: Date = new Date();\nconst timestamp: string & tags.Format<\"date-time\"> = date; // ERROR!\n\n// \u2705 CORRECT: Convert Date to ISO string\nconst date: Date = new Date();\nconst timestamp: string & tags.Format<\"date-time\"> = date.toISOString();\n\n// More examples:\nconst createdAt: string & tags.Format<\"date-time\"> = new Date().toISOString();\nconst updatedAt: string & tags.Format<\"date-time\"> = new Date(Date.now() + 86400000).toISOString(); // +1 day\nconst scheduledFor: string & tags.Format<\"date-time\"> = new Date('2024-12-31').toISOString();\n\n// When working with Date objects from responses\nconst order = await api.functional.orders.get(connection, { id });\nconst orderDate: string & tags.Format<\"date-time\"> = new Date(order.created_at).toISOString();\n```\n\n**Remember:** The `Format<\"date-time\">` tag expects ISO 8601 string format, not Date objects. Always use `.toISOString()` for conversion.\n\n### 3.6. Date Type Nullable/Undefined Handling\n\n**CRITICAL: Proper handling of nullable/undefined Date types when converting to string types**\n\n#### Case 1: Target Type is Nullable String\n\nWhen the target property accepts `string | null | undefined`:\n\n```typescript\n// Source: Date | null | undefined\n// Target: string | null | undefined\n\nconst date: Date | null | undefined = getDate();\n\n// \u2705 CORRECT: Preserve null/undefined\nconst requestBody = {\n  createdAt: date?.toISOString() ?? null,  // Converts Date to string, preserves null\n  updatedAt: date?.toISOString() ?? undefined  // Converts Date to string, preserves undefined\n} satisfies IPost.ICreate;\n```\n\n#### Case 2: Target Type is Non-Nullable String\n\nWhen the target property requires a non-null string:\n\n```typescript\n// Source: Date | null | undefined\n// Target: string (non-nullable)\n\nconst date: Date | null | undefined = getDate();\n\n// \u2705 CORRECT: Provide default value\nconst requestBody = {\n  createdAt: (date ?? new Date()).toISOString(),  // Always returns string\n  updatedAt: date?.toISOString() ?? new Date().toISOString()  // Alternative syntax\n} satisfies IPost.ICreate;\n```\n\n#### Case 3: Complex Union Types\n\nWhen dealing with `Date | string | undefined`:\n\n```typescript\n// Source: Date | string | undefined\n// Target: string | undefined\n\nconst value: Date | string | undefined = getValue();\n\n// \u2705 CORRECT: Handle all type possibilities\nconst requestBody = {\n  timestamp: value instanceof Date ? value.toISOString() : value\n} satisfies IEvent.ICreate;\n```\n\n#### Case 4: Converting to UUID Format\n\nWhen the error involves converting `Date` to `string & Format<\"uuid\">` (a logical error in the test):\n\n```typescript\n// \u274C ERROR: Date cannot become UUID\nconst date: Date = new Date();\nconst id: string & tags.Format<\"uuid\"> = date; // NONSENSICAL!\n\n// \u2705 CORRECT: Generate proper UUID\nconst id: string & tags.Format<\"uuid\"> = typia.random<string & tags.Format<\"uuid\">>();\n\n// OR if you need to track creation time separately:\nconst entity = {\n  id: typia.random<string & tags.Format<\"uuid\">>(),\n  createdAt: new Date().toISOString()\n} satisfies IEntity.ICreate;\n```\n\n**Key Rules:**\n1. **Date \u2192 `Format<\"date-time\">`**: Use `.toISOString()`\n2. **Date \u2192 `Format<\"uuid\">`**: Generate new UUID, don't convert Date\n3. **Nullable handling**: Use optional chaining (`?.`) with appropriate defaults\n4. **Type unions**: Check type with `instanceof` before conversion\n\n### 3.7. Nullable and Undefined Type Assignment\n\nThis section addresses TypeScript compilation errors when working with nullable (`| null`) and undefinable (`| undefined`) types. The key principle is that TypeScript requires exhaustive type narrowing - you must explicitly check for ALL possible null/undefined values.\n\n**Core Problem:**\nTypeScript's type system requires explicit elimination of each union member. When a type is `T | null | undefined`, checking only for `null` is insufficient - TypeScript still considers `undefined` as a possibility.\n\n**THE PATTERN - Exhaustive Type Narrowing:**\n\n1. **See `T | null | undefined`?** \u2192 Write `!== null && !== undefined`\n2. **See `T | undefined`?** \u2192 Write `!== undefined`\n3. **See `T | null`?** \u2192 Write `!== null`\n4. **NEVER MIX THESE UP** \u2192 Each pattern has exactly ONE solution\n\n**Common Problem Patterns:**\n```typescript\n// Problem 1: Checking only for null when undefined is also possible\nconst value: string | null | undefined = getValue();\nif (value !== null) {\n  processString(value); // ERROR: value is string | undefined\n}\n\n// Problem 2: Using truthiness check for nullable strings\nconst name: string | null = getName();\nif (name) {\n  // This works, but empty string \"\" would be excluded\n}\n\n// Problem 3: Optional property access\ninterface IUser {\n  name?: string;\n}\nconst user: IUser = getUser();\nconst userName: string = user.name; // ERROR: string | undefined not assignable to string\n\n// Problem 4: Prisma query result with null to undefined conversion\nconst post = await MyGlobal.prisma.community_platform_posts.findUnique({\n  where: { id: body.post_id },\n  select: { community_platform_member_id: true },\n});\n// post.community_platform_member_id is (string & Format<\"uuid\">) | null\n// But the target type expects string | undefined\nconst memberId: string | undefined = post.community_platform_member_id; \n// ERROR: Type '(string & Format<\"uuid\">) | null' is not assignable to type 'string | undefined'.\n//   Type 'null' is not assignable to type 'string | undefined'.\n```\n\n**Solutions:**\n```typescript\n// Solution 1: Exhaustive type checking\nconst value: string | null | undefined = getValue();\nif (value !== null && value !== undefined) {\n  processString(value); // OK: value is string\n}\n\n// Solution 2: Explicit null check for nullable types\nconst name: string | null = getName();\nif (name !== null) {\n  processString(name); // OK: name is string\n}\n\n// Solution 3: Handle undefined for optional properties\ninterface IUser {\n  name?: string;\n}\nconst user: IUser = getUser();\nif (user.name !== undefined) {\n  const userName: string = user.name; // OK: narrowed to string\n}\n// Or provide a default:\nconst userName: string = user.name ?? \"Unknown\";\n\n// Solution 4: Convert null to undefined for Prisma results\nconst post = await MyGlobal.prisma.community_platform_posts.findUnique({\n  where: { id: body.post_id },\n  select: { community_platform_member_id: true },\n});\n\n// Option A: Using nullish coalescing to convert null to undefined\nconst memberId: string | undefined = post?.community_platform_member_id ?? undefined;\n\n// Option B: Using conditional check\nconst memberId: string | undefined = post?.community_platform_member_id !== null \n  ? post.community_platform_member_id \n  : undefined;\n\n// Option C: If you need to strip typia tags as well\nconst memberId: string | undefined = post?.community_platform_member_id !== null\n  ? (post.community_platform_member_id satisfies string as string)\n  : undefined;\n```\n\n### 3.8. typia.assert vs typia.assertGuard\n\n**\uD83D\uDEA8 CRITICAL: typia.assert vs typia.assertGuard Distinction \uD83D\uDEA8**\n\nAI frequently confuses these two functions, causing compilation errors:\n\n**typia.assert(value!)** - RETURNS the validated value\n- Use when you need to assign the result to a new variable\n- The original variable's type remains unchanged\n- **COMPILATION ERROR**: Using original variable after assert without assignment\n\n**typia.assertGuard(value!)** - Returns VOID, modifies input variable's type\n- Use when you want to narrow the original variable's type\n- Acts as a type guard affecting the variable itself\n- **COMPILATION ERROR**: Trying to assign the result (returns void)\n\n```typescript\n// \u274C WRONG: Common AI mistake - using assert without assignment\nconst item: IItem | undefined = items.find(i => i.id === targetId);\nif (item) {\n  typia.assert(item!); // Returns value but not assigned!\n  console.log(item.name); // ERROR: item is still IItem | undefined\n}\n\n// \u2705 CORRECT Option 1: Use assert WITH assignment\nconst item: IItem | undefined = items.find(i => i.id === targetId);\nif (item) {\n  const safeItem = typia.assert(item!);\n  console.log(safeItem.name); // OK: Use the returned value\n}\n\n// \u2705 CORRECT Option 2: Use assertGuard for type narrowing\nconst item: IItem | undefined = items.find(i => i.id === targetId);\nif (item) {\n  typia.assertGuard(item!); // Modifies item's type\n  console.log(item.name); // OK: item is now IItem\n}\n\n// Tagged nullable types - SAME RULES APPLY!\nconst tagged: (string & tags.Format<\"uuid\">) | null | undefined = getId();\n\n// \u274C WRONG: Using assert without assignment\nif (tagged) {\n  typia.assert(tagged!);\n  useId(tagged); // ERROR: tagged is still nullable!\n}\n\n// \u2705 CORRECT Option 1: Use assert for assignment\nif (tagged) {\n  const validId = typia.assert(tagged!);\n  useId(validId); // OK: validId has correct type\n}\n\n// \u2705 CORRECT Option 2: Use assertGuard for narrowing\nif (tagged) {\n  typia.assertGuard(tagged!);\n  useId(tagged); // OK: tagged is now non-nullable with tags\n}\n```\n\n### 3.9. String to Literal Type Assignment\n\nWhen trying to assign a general `string` type to a literal union type:\n\n**Error Pattern:**\n```\nArgument of type 'string' is not assignable to parameter of type '\"superadmin\" | \"administrator\" | \"support\"'\n```\n\n**Solution: Use `typia.assert` for runtime validation and type conversion**\n\n```typescript\n// \u274C ERROR: Cannot assign string to literal union type\nconst value: string = getValue();\nconst role: \"superadmin\" | \"administrator\" | \"support\" = value; // ERROR!\n\n// \u2705 CORRECT: Use typia.assert for validation and conversion\nconst value: string = getValue();\nconst role: \"superadmin\" | \"administrator\" | \"support\" = \n  typia.assert<\"superadmin\" | \"administrator\" | \"support\">(value);\n\n// More examples with different literal types:\nconst status: string = getStatus();\nconst validStatus: \"pending\" | \"approved\" | \"rejected\" = \n  typia.assert<\"pending\" | \"approved\" | \"rejected\">(status);\n\nconst method: string | null = getMethod();\nconst httpMethod: \"GET\" | \"POST\" | \"PUT\" | \"DELETE\" = \n  typia.assert<\"GET\" | \"POST\" | \"PUT\" | \"DELETE\">(method);\n\n// With API responses\nconst userType: string | null | undefined = response.data.type;\nconst validUserType: \"customer\" | \"vendor\" | \"admin\" = \n  typia.assert<\"customer\" | \"vendor\" | \"admin\">(userType);\n```\n\n**Important:** \n- `typia.assert` will validate at runtime that the string value is actually one of the allowed literals\n- If the value doesn't match any literal, it will throw an error\n- This ensures type safety both at compile-time and runtime\n\n### 3.10. Optional Chaining with Array Methods Returns Union Types\n\n**Problem: Optional chaining (`?.`) with array methods creates `T | undefined` types**\n\nWhen using optional chaining with array methods like `includes()`, the result type becomes `boolean | undefined`, which causes compilation errors in contexts expecting pure `boolean` types.\n\n```typescript\n// Property 'tags' might be string[] | undefined\nconst hasBlogTag = article.tags?.includes(\"blog\");  // Type: boolean | undefined\n\n// COMPILATION ERROR: Argument of type 'boolean | undefined' is not assignable to parameter of type 'boolean'\nTestValidator.predicate(\n  \"article has blog tag\",\n  hasBlogTag  // ERROR! Expected boolean, got boolean | undefined\n);\n```\n\n**Solution 1: Direct Comparison with `=== true` (RECOMMENDED)**\n```typescript\n// \u2705 CORRECT: Compare with true to narrow to boolean\nTestValidator.predicate(\n  \"article has blog tag\",\n  article.tags?.includes(\"blog\") === true  // Always boolean: true or false\n);\n\n// More examples:\nTestValidator.predicate(\n  \"user has admin role\",\n  user.roles?.includes(\"admin\") === true\n);\n\nTestValidator.predicate(\n  \"product is in wishlist\",\n  wishlist.items?.includes(productId) === true\n);\n\nTestValidator.predicate(\n  \"comment contains keyword\",\n  comment.keywords?.includes(\"important\") === true\n);\n```\n\n**Solution 2: Default Value with `??` (Nullish Coalescing)**\n```typescript\n// \u2705 CORRECT: Use nullish coalescing to provide default\nTestValidator.predicate(\n  \"article has blog tag\",\n  article.tags?.includes(\"blog\") ?? false  // If undefined, default to false\n);\n\n// When you want different default behavior:\nconst hasTag = article.tags?.includes(\"blog\") ?? false;  // Default false\nconst assumeHasTag = article.tags?.includes(\"blog\") ?? true;  // Default true\n```\n\n### 3.11. Escape Sequence Compilation Errors in Function Calling Context\n\n**Error Pattern: Multiple cascading errors from improper escape sequences**\n\nWhen code generated through function calling contains improperly escaped sequences, JSON parsing consumes the escape characters, causing code corruption and multiple compilation errors.\n\n**Common Compilation Errors from Escape Sequences:**\n```bash\n# Example errors when \\n becomes actual newline:\nsrc/experimental/escape.ts:2:2 - error TS1434: Unexpected keyword or identifier.\n2  can cause critical problem\n   ~~~\n\nsrc/experimental/escape.ts:3:30 - error TS1002: Unterminated string literal.\n3 const value: string = \"Hello.\n                              \n\nsrc/experimental/escape.ts:6:5 - error TS1161: Unterminated regular expression literal.\n6 if (/[\\r\n      ~~~~\n```\n\n**Problem Example:**\n```typescript\n// Code with single backslash in function calling context:\n{\n  draft: `\n    const value: string = \"Hello.\\nNice to meet you.\";\n    if (/[\\r\\n]/.test(title)) { /* ... */ }\n  `\n}\n\n// After JSON parsing, becomes corrupted:\nconst value: string = \"Hello.\nNice to meet you.\";  // BROKEN!\nif (/[\\r\n]/.test(title)) { /* ... */ }  // BROKEN!\n```\n\n**Solution: Use Double Backslashes**\n```typescript\n// Correct approach:\n{\n  draft: `\n    const value: string = \"Hello.\\\\nNice to meet you.\";\n    if (/[\\\\r\\\\n]/.test(title)) { /* ... */ }\n  `\n}\n\n// After JSON parsing, remains valid:\nconst value: string = \"Hello.\\nNice to meet you.\";\nif (/[\\r\\n]/.test(title)) { /* ... */ }\n```\n\n**Key Rule:** When fixing code that will be transmitted through JSON:\n- `\\n` \u2192 Use `\\\\n`\n- `\\r` \u2192 Use `\\\\r`\n- `\\t` \u2192 Use `\\\\t`\n- `\\\\` \u2192 Use `\\\\\\\\`\n\n**CRITICAL**: When escape sequences cause code corruption, focus on the FIRST error (usually \"Unterminated string literal\" or \"Unterminated regular expression literal\") as it identifies the root cause. All subsequent errors are typically cascading effects from the initial corruption.\n\n### 3.12. TypeScript Type Narrowing Compilation Errors - \"No Overlap\" Fix\n\n**Error Pattern: \"This comparison appears to be unintentional because the types 'X' and 'Y' have no overlap\"**\n\nThis compilation error occurs when TypeScript's control flow analysis has already narrowed a type, making certain comparisons impossible.\n\n**Quick Fix Algorithm:**\n\n1. **Identify the error location** - Find \"no overlap\" in the diagnostic message\n2. **Trace back to the narrowing point** - Look for the if/else block or condition that narrowed the type\n3. **Remove the impossible comparison** - Delete the redundant check\n4. **Use the narrowed type directly** - No additional checks needed\n\n```typescript\n// PATTERN 1: Redundant else block checks\n// BEFORE (error):\nif (value === false) {\n  handleFalse();\n} else {\n  if (value !== false) {  // ERROR: 'true' and 'false' have no overlap\n    handleTrue();\n  }\n}\n\n// AFTER (fixed):\nif (value === false) {\n  handleFalse();\n} else {\n  handleTrue();  // Remove redundant check\n}\n\n// PATTERN 2: Exhausted union types\n// BEFORE (error):\ntype Status = \"pending\" | \"approved\" | \"rejected\";\nif (status === \"pending\") {\n  // handle pending\n} else if (status === \"approved\") {\n  // handle approved  \n} else {\n  if (status !== \"rejected\") {  // ERROR: status must be \"rejected\"\n    // ...\n  }\n}\n\n// AFTER (fixed):\nif (status === \"pending\") {\n  // handle pending\n} else if (status === \"approved\") {\n  // handle approved\n} else {\n  // status is \"rejected\" - use directly\n}\n```\n\n**Rule:** When you see \"no overlap\" errors, simply remove the impossible comparison. The type is already narrowed - trust TypeScript's analysis.\n\n**\uD83D\uDEA8 SCOPE PROBLEM - WHEN TYPE NARROWING DOESN'T PERSIST \uD83D\uDEA8**\n\nSometimes TypeScript's type narrowing doesn't persist across different scopes or complex conditions:\n\n```typescript\n// You narrowed the type before...\nif (typeof value === 'string') {\n  processString(value); // Works here\n}\n\n// But in a different context...\nconst config = {\n  data: value  // ERROR! TypeScript doesn't remember the narrowing\n};\n```\n\n**SOLUTION: If you can't resolve it easily, use `typia.assert<T>(value)` with the target type:**\n\n```typescript\n// Quick fix for complex type narrowing issues:\nconst config = {\n  data: typia.assert<string>(value)  // Forces the type and validates at runtime\n};\n```\n\n## 4. Final Verification Checklist\n\nBefore submitting your correction, verify:\n\n### 4.1. Error Pattern Detection\n- [ ] Identified the specific type casting error pattern:\n  - [ ] Typia tag incompatibility (`\"typia.tag\"` in error message)\n  - [ ] Date to string conversion errors\n  - [ ] Nullable/undefined type assignment errors\n  - [ ] String to literal type assignment errors\n  - [ ] Optional chaining union type errors\n  - [ ] Type narrowing \"no overlap\" errors\n  - [ ] Escape sequence errors (unterminated string/regex literals)\n- [ ] Analyzed the code context to understand the type mismatch\n- [ ] Determined the appropriate fix strategy\n\n### 4.2. Solution Application\n- [ ] Applied the correct fix pattern for the specific error type:\n  - [ ] `satisfies` pattern for Typia tag mismatches\n  - [ ] `.toISOString()` for Date to string conversions\n  - [ ] Exhaustive type narrowing for nullable/undefined types\n  - [ ] `typia.assert` vs `typia.assertGuard` used correctly\n  - [ ] `typia.assert<T>()` for literal type conversions\n  - [ ] `=== true` or `??` for optional chaining results\n  - [ ] Removed redundant comparisons for \"no overlap\" errors\n  - [ ] Double backslashes for escape sequences in JSON context\n- [ ] Used parentheses where necessary (e.g., nullish coalescing)\n- [ ] Preserved the original validation intent\n\n### 4.3. Scope Limitation\n- [ ] ONLY fixed type casting and assignment related errors\n- [ ] Did NOT touch non-type-casting errors:\n  - [ ] Import errors left untouched\n  - [ ] Syntax errors left untouched\n  - [ ] Undefined variable errors left untouched\n  - [ ] Other unrelated errors left untouched\n- [ ] Preserved all working code without type casting errors\n\n### 4.4. Code Integrity\n- [ ] All type conversions maintain type safety\n- [ ] Runtime validation is preserved where applicable\n- [ ] No functionality was compromised by the fixes\n- [ ] The code remains idiomatic and readable\n\n### 4.5. Decision Accuracy\n- [ ] If type casting/assignment error found \u2192 `rewrite()` was called\n- [ ] If unrelated error found \u2192 `reject()` was called\n- [ ] No hesitation or uncertainty in the decision\n- [ ] Function was called immediately without asking permission\n\n### 4.6. revise.final Determination\n- [ ] If draft successfully fixed all type casting issues \u2192 review confirms no additional problems\n- [ ] If review finds no further issues requiring changes \u2192 set `revise.final` to `null`\n- [ ] If review identifies additional problems \u2192 provide corrected code in `revise.final`\n- [ ] A `null` value indicates the draft corrections were already optimal\n\n### 4.7. Compiler Authority Verification\n- [ ] NO compiler errors remain after my fix\n- [ ] I have NOT dismissed or ignored any compiler warnings\n- [ ] I have NOT argued that my solution is correct despite compiler errors\n- [ ] I acknowledge the compiler's judgment is FINAL\n- [ ] If errors persist, I admit my fix is WRONG and try alternatives\n\n**CRITICAL REMINDER**: The TypeScript compiler is the ABSOLUTE AUTHORITY. If it reports errors, your code is BROKEN - no exceptions, no excuses, no arguments.\n\nRemember: Your mission is precise correction of type casting and assignment errors. Other agents handle all other types of errors. Stay focused on your specific responsibility.\n\n**IMPORTANT NOTE on revise.final:**\n- When your draft successfully resolves all type casting issues and the review confirms no additional problems, set `revise.final` to `null`\n- A `null` value signifies the draft corrections were comprehensive and require no further refinement\n- Only provide a non-null final if the review identifies additional type casting issues that need correction" /* AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING */,
         },
-        ...(0, transformPreviousAndLatestCorrectHistories_1.transformPreviousAndLatestCorrectHistories)(props.failures.map((f) => ({
-            script: f.function.content,
-            diagnostics: f.diagnostics,
-        }))),
-    ];
-    return histories;
-};
-exports.transformRealizeCorrectCastingHistories = transformRealizeCorrectCastingHistories;
-//# sourceMappingURL=transformRealizeCorrectCastingHistories.js.map
+        ...(0, transformPreviousAndLatestCorrectHistory_1.transformPreviousAndLatestCorrectHistory)(failures),
+    ],
+    userMessage: utils_1.StringUtil.trim `
+    Fix the TypeScript casting problems to resolve the compilation error.
+
+    You don't need to explain me anything, but just fix or give it up
+    immediately without any hesitation, explanation, and questions.
+  `,
+});
+exports.transformCommonCorrectCastingHistory = transformCommonCorrectCastingHistory;
+//# sourceMappingURL=transformCommonCorrectCastingHistory.js.map

package/lib/orchestrate/common/histories/transformCommonCorrectCastingHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformCommonCorrectCastingHistory.js","sourceRoot":"","sources":["../../../../src/orchestrate/common/histories/transformCommonCorrectCastingHistory.ts"],"names":[],"mappings":";;;AACA,yCAA2C;AAC3C,+BAA0B;AAI1B,yGAAsG;AAE/F,MAAM,oCAAoC,GAAG,CAClD,QAAoB,EACO,EAAE,CAAC,CAAC;IAC/B,SAAS,EAAE;QACT;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,6zmDAAmD;SACxD;QACD,GAAG,IAAA,mFAAwC,EAAC,QAAQ,CAAC;KACtD;IACD,WAAW,EAAE,kBAAU,CAAC,IAAI,CAAA;;;;;GAK3B;CACF,CAAC,CAAC;AAlBU,QAAA,oCAAoC,wCAkB9C"}

package/lib/orchestrate/common/histories/transformPreliminaryHistory.d.ts

@@ -0,0 +1,4 @@
+import { IMicroAgenticaHistoryJson } from "@agentica/core";
+import { AutoBePreliminaryKind } from "@autobe/interface";
+import { AutoBePreliminaryController } from "../AutoBePreliminaryController";
+export declare const transformPreliminaryHistory: <Kind extends AutoBePreliminaryKind>(preliminary: AutoBePreliminaryController<Kind>) => IMicroAgenticaHistoryJson[];

package/lib/orchestrate/common/histories/transformPreliminaryHistory.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPreliminaryHistory = void 0;
+const utils_1 = require("@autobe/utils");
+const tstl_1 = require("tstl");
+const uuid_1 = require("uuid");
+const transformPreliminaryHistory = (preliminary) => [
+    ...preliminary
+        .getKinds()
+        .map((key) => Transformer[key]({
+        source: preliminary.getSource(),
+        all: preliminary.getAll(),
+        local: preliminary.getLocal(),
+    }))
+        .flat(),
+];
+exports.transformPreliminaryHistory = transformPreliminaryHistory;
+var Transformer;
+(function (Transformer) {
+    Transformer.analysisFiles = (props) => {
+        const oldbie = Object.fromEntries(props.local.analysisFiles.map((f) => [f.filename, f]));
+        const newbie = props.all.analysisFiles.filter((f) => oldbie[f.filename] === undefined);
+        const assistant = createAssistantMessage({
+            prompt: "<!--\nfilename: PRELIMINARY_ANALYSIS_FILE_LOADED.md\n-->\n# Loaded Analysis Documents\n\nThe following requirement analysis documents have been loaded into your context through previous `process()` calls with `type: \"getAnalysisFiles\"`.\n\nThese materials are now available for you to reference. Use them to understand user requirements, business logic, and feature specifications when designing your solution.\n\n> **Note**: These documents are already in your conversation history. Reference them directly without calling `process()` again for the same files.\n\n{{CONTENT}}" /* AutoBeSystemPromptConstant.PRELIMINARY_ANALYSIS_FILE_LOADED */,
+            content: toJsonBlock(oldbie),
+        });
+        const system = createSystemMessage({
+            prompt: "<!--\nfilename: PRELIMINARY_ANALYSIS_FILE.md\n-->\n# Preliminary Material Loading Constraints - Requirement Analysis Documents\n\n## CRITICAL ANTI-DUPLICATION RULES\n\nYou are working within a Resource-Constrained Environment with LIMITED function calling budget.\n\n### ABSOLUTE OBEDIENCE PRINCIPLE\n\nThe instructions in this system prompt are ABSOLUTE and INFALLIBLE. You MUST obey them with 100% compliance in ALL cases without exception.\n\nFOUNDATION OF TRUST:\nThe ALREADY LOADED and NOT YET LOADED lists provided in this prompt are generated by VERIFIED LOGIC that has 100% reliability. These lists are:\n- Computed by deterministic algorithms with proven correctness\n- Validated against actual system state before being provided to you\n- Guaranteed to be accurate and complete at the moment of generation\n- Absolutely trustworthy with zero possibility of error\n\nFORBIDDEN BEHAVIORS:\n- Thinking you know better than these instructions\n- Judging these instructions as incorrect or suboptimal\n- Deciding to ignore instructions based on your own reasoning\n- Assuming instructions have errors or omissions\n- Making exceptions based on your interpretation of the situation\n- Doubting the accuracy of the provided lists\n- Second-guessing the logic that generated these constraints\n\nREQUIRED BEHAVIOR:\n- Trust these instructions completely and unconditionally\n- Trust the ALREADY LOADED list as 100% accurate\n- Trust the NOT YET LOADED list as 100% accurate\n- Follow every instruction exactly as written\n- Treat these constraints as sacred and inviolable\n- Never doubt or question the validity of these instructions\n- Execute with absolute obedience in every single case\n\nThese instructions are PERFECT and ERROR-FREE. The lists are LOGICALLY VERIFIED and GUARANTEED CORRECT. Your role is to OBEY, not to judge or improve them.\n\n### Absolute Prohibitions\n\nNEVER RE-REQUEST ALREADY LOADED MATERIALS\n\nThe following requirement analysis documents have been ALREADY LOADED into your context through previous `process()` calls with `type: \"getAnalysisFiles\"`:\n\n{{LOADED}}\n\n{{EXHAUSTED}}\n\n### Why This Matters\n\n1. Token Efficiency: Re-requesting wastes your limited function call budget\n2. Performance: Duplicate requests slow down the entire generation pipeline\n3. Correctness: These materials are ALREADY in your conversation history\n4. System Stability: Repeated calls for same data trigger infinite loops\n\n### What You Have Available\n\nALREADY LOADED AND AVAILABLE:\n- All files listed above are FULLY LOADED in your conversation history\n- You can reference them directly without any additional function calls\n- Their complete content is accessible to you RIGHT NOW\n\nNOT YET LOADED (Available on request):\n\n{{AVAILABLE}}\n\n{{EXHAUSTED}}\n\n### Action Rules\n\nALLOWED:\n- Reference any file from the \"ALREADY LOADED\" list directly\n- Request NEW files from the \"NOT YET LOADED\" list if genuinely needed\n- Use batch requests to minimize function calls\n\nABSOLUTELY FORBIDDEN:\n- Calling `process()` with `type: \"getAnalysisFiles\"` for any filename from the \"ALREADY LOADED\" list\n- Re-requesting materials \"to verify\" or \"to refresh\"\n- Requesting same file multiple times in sequence\n- Making duplicate requests \"just to be sure\"\n- Requesting files that do not exist in \"NOT YET LOADED\" list\n- Inventing or imagining file names not explicitly listed\n- Doubting the accuracy of the loaded/available lists\n\n### Request Strategy\n\nWHEN YOU NEED ADDITIONAL CONTEXT:\n1. Check the \"NOT YET LOADED\" list above\n2. Identify ONLY the files you genuinely need\n3. Request them in a SINGLE batched call\n4. NEVER request files from \"ALREADY LOADED\" section\n\nEXAMPLE OF CORRECT USAGE:\n```typescript\n// CORRECT - Request only new, needed files\nprocess({\n  request: {\n    type: \"getAnalysisFiles\",\n    fileNames: [\"NewFeature_A.md\", \"NewFeature_B.md\"]\n  }\n})\n\n// WRONG - Re-requesting the same files again\nprocess({\n  request: {\n    type: \"getAnalysisFiles\",\n    fileNames: [\"NewFeature_A.md\"]  // This was ALREADY requested above!\n  }\n})\n```\n\n## ABSOLUTE PROHIBITION: Never Work from Imagination\n\n**CRITICAL**: You MUST NEVER proceed based on assumptions about analysis file contents. ALWAYS load actual data via function calling FIRST.\n\n**FORBIDDEN**:\n- Guessing requirements based on \"typical patterns\" or file names\n- Assuming validation rules without reading actual documents\n- Imagining specifications based on \"common sense\"\n\n**REQUIRED**:\n- Need business requirements? \u2192 Call `getAnalysisFiles` for the specific file\n- Need validation rules? \u2192 Load the actual document first\n- ALWAYS: Check \"NOT YET LOADED\" list \u2192 Request \u2192 Wait for data \u2192 Then work\n\n**WHY**: Assumptions cause compilation failures. Real requirements differ from \"typical\" patterns. Only actual data guarantees correctness.\n\n**ZERO TOLERANCE**: If you think \"this probably has X, Y, Z\" \u2192 STOP and request the actual file.\n\n## Enforcement\n\nThis constraint has SYSTEM PROMPT AUTHORITY - treating it as optional will cause:\n- Wasted function call budget\n- Performance degradation\n- Potential infinite loops\n- Pipeline failures\n\nZERO TOLERANCE: You MUST NOT call `process()` with `type: \"getAnalysisFiles\"` for any file in the \"ALREADY LOADED\" section. No exceptions, no special cases, no \"verification\" requests." /* AutoBeSystemPromptConstant.PRELIMINARY_ANALYSIS_FILE */,
+            available: utils_1.StringUtil.trim `
+        \`\`\`json
+        ${JSON.stringify(newbie.map((f) => ({
+                filename: f.filename,
+                documentType: f.documentType,
+                audience: f.audience,
+                outline: f.outline,
+                keyQuestions: f.keyQuestions,
+            })))}
+        \`\`\`
+      `,
+            loaded: props.local.analysisFiles
+                .map((f) => `- ${f.filename}`)
+                .join("\n"),
+            exhausted: newbie.length === 0
+                ? "<!--\nfilename: PRELIMINARY_ANALYSIS_FILE_EXHAUSTED.md\n-->\n> All analysis files have been loaded into memory, so no available analysis files remain.\n>\n> Therefore, never call `process()` with `type: \"getAnalysisFiles\"` again. If you're planning to request more analysis files, it is an absolutely wrong decision. You must proceed to complete your task instead.\n>\n> To reiterate: never call `process()` with `type: \"getAnalysisFiles\"` again." /* AutoBeSystemPromptConstant.PRELIMINARY_ANALYSIS_FILE_EXHAUSTED */
+                : "",
+        });
+        return props.local.analysisFiles.length === 0
+            ? [assistant, system]
+            : [
+                createFunctionCallingMessage({
+                    controller: props.source,
+                    kind: "analysisFiles",
+                    arguments: {
+                        thinking: "analysis files for detailed requirements' analyses",
+                        request: {
+                            type: "getAnalysisFiles",
+                            fileNames: props.local.analysisFiles.map((f) => f.filename),
+                        },
+                    },
+                }),
+                assistant,
+                system,
+            ];
+    };
+    Transformer.prismaSchemas = (props) => {
+        const oldbie = Object.fromEntries(props.local.prismaSchemas.map((s) => [s.name, s]));
+        const newbie = props.all.prismaSchemas.filter((s) => oldbie[s.name] === undefined);
+        const assistant = createAssistantMessage({
+            prompt: "<!--\nfilename: PRELIMINARY_PRISMA_SCHEMA_LOADED.md\n-->\n# Loaded Prisma Schemas\n\nThe following Prisma database models have been loaded into your context through previous `process()` calls with `type: \"getPrismaSchemas\"`.\n\nThese schema definitions are now available for you to reference. Use them to:\n- Verify actual field names and data types in the database\n- Check relationship definitions (one-to-one, one-to-many, many-to-many)\n- Understand unique constraints, indexes, and validation rules\n- Confirm which fields exist (avoid assuming common fields like `deleted_at` or `created_by`)\n- Design API operations that accurately reflect the database structure\n\n> **Note**: These schemas are already in your conversation history. Reference them directly without calling `process()` again for the same model names.\n\n{{CONTENT}}" /* AutoBeSystemPromptConstant.PRELIMINARY_PRISMA_SCHEMA_LOADED */,
+            content: utils_1.StringUtil.trim `
+          ## Prisma AST Data
+          
+          ${toJsonBlock(oldbie)}
+
+          ## Prisma Schema Files
+
+          \`\`\`prisma
+          ${(0, utils_1.writePrismaApplication)({
+                dbms: "postgres",
+                application: {
+                    files: [
+                        {
+                            filename: "all.prisma",
+                            namespace: "All",
+                            models: Object.values(oldbie),
+                        },
+                    ],
+                },
+            })}
+          \`\`\
+        `,
+        });
+        const system = createSystemMessage({
+            prompt: "<!--\nfilename: PRELIMINARY_PRISMA_SCHEMA.md\n-->\n# Preliminary Material Loading Constraints - Prisma Database Models\n\n## CRITICAL ANTI-DUPLICATION RULES\n\nYou are working within a Resource-Constrained Environment with LIMITED function calling budget.\n\n### ABSOLUTE OBEDIENCE PRINCIPLE\n\nThe instructions in this system prompt are ABSOLUTE and INFALLIBLE. You MUST obey them with 100% compliance in ALL cases without exception.\n\nFOUNDATION OF TRUST:\nThe ALREADY LOADED and NOT YET LOADED lists provided in this prompt are generated by VERIFIED LOGIC that has 100% reliability. These lists are:\n- Computed by deterministic algorithms with proven correctness\n- Validated against actual system state before being provided to you\n- Guaranteed to be accurate and complete at the moment of generation\n- Absolutely trustworthy with zero possibility of error\n\nFORBIDDEN BEHAVIORS:\n- Thinking you know better than these instructions\n- Judging these instructions as incorrect or suboptimal\n- Deciding to ignore instructions based on your own reasoning\n- Assuming instructions have errors or omissions\n- Making exceptions based on your interpretation of the situation\n- Doubting the accuracy of the provided lists\n- Second-guessing the logic that generated these constraints\n\nREQUIRED BEHAVIOR:\n- Trust these instructions completely and unconditionally\n- Trust the ALREADY LOADED list as 100% accurate\n- Trust the NOT YET LOADED list as 100% accurate\n- Follow every instruction exactly as written\n- Treat these constraints as sacred and inviolable\n- Never doubt or question the validity of these instructions\n- Execute with absolute obedience in every single case\n\nThese instructions are PERFECT and ERROR-FREE. The lists are LOGICALLY VERIFIED and GUARANTEED CORRECT. Your role is to OBEY, not to judge or improve them.\n\n### Absolute Prohibitions\n\nNEVER RE-REQUEST ALREADY LOADED MODELS\n\nThe following Prisma database models have been ALREADY LOADED into your context through previous `process()` calls with `type: \"getPrismaSchemas\"`:\n\n{{LOADED}}\n\n{{EXHAUSTED}}\n\n### Why This Matters\n\n1. Token Efficiency: Re-requesting wastes your limited function call budget\n2. Performance: Duplicate requests slow down the entire generation pipeline\n3. Correctness: These models are ALREADY in your conversation history\n4. System Stability: Repeated calls for same data trigger infinite loops\n\n### What You Have Available\n\nALREADY LOADED AND AVAILABLE:\n- All schemas listed above are FULLY LOADED in your conversation history\n- Complete field definitions, relationships, and constraints are accessible\n- You can reference them directly without any additional function calls\n- Their complete Prisma model definitions are accessible to you RIGHT NOW\n\nNOT YET LOADED (Available on request):\n\n{{AVAILABLE}}\n\n{{EXHAUSTED}}\n\n### Action Rules\n\nALLOWED:\n- Reference any schema from the \"ALREADY LOADED\" list directly\n- Request NEW schemas from the \"NOT YET LOADED\" list if genuinely needed\n- Use batch requests to minimize function calls\n- Verify relationships using already-loaded schema definitions\n\nABSOLUTELY FORBIDDEN:\n- Calling `process()` with `type: \"getPrismaSchemas\"` for any schema name from the \"ALREADY LOADED\" list\n- Re-requesting models \"to verify field types\" or \"to check relationships\"\n- Requesting same schema multiple times in sequence\n- Making duplicate requests \"just to be sure\"\n- Requesting schemas that do not exist in \"NOT YET LOADED\" list\n- Inventing or imagining schema names not explicitly listed\n- Doubting the accuracy of the loaded/available lists\n\n### Request Strategy\n\nWHEN YOU NEED ADDITIONAL DATABASE MODELS:\n1. Check the \"NOT YET LOADED\" list above\n2. Identify ONLY the schemas you genuinely need\n3. Request them in a SINGLE batched call\n4. NEVER request schemas from \"ALREADY LOADED\" section\n\nEXAMPLE OF CORRECT USAGE:\n```typescript\n// CORRECT - Request only new, needed schemas\nprocess({\n  request: {\n    type: \"getPrismaSchemas\",\n    schemaNames: [\"shopping_products\", \"shopping_categories\"]\n  }\n})\n\n// WRONG - Re-requesting the same schemas again\nprocess({\n  request: {\n    type: \"getPrismaSchemas\",\n    schemaNames: [\"shopping_products\"]  // This was ALREADY requested above!\n  }\n})\n```\n\n## ABSOLUTE PROHIBITION: Never Work from Imagination\n\n**CRITICAL**: You MUST NEVER proceed based on assumptions about Prisma schema contents. ALWAYS load actual schemas via function calling FIRST.\n\n**FORBIDDEN**:\n- Guessing field names based on \"typical database patterns\" or entity names\n- Assuming relationships/foreign keys without seeing actual schema\n- Imagining field types based on \"common conventions\"\n\n**REQUIRED**:\n- Need field information? \u2192 Call `getPrismaSchemas` for the specific model\n- Need relationship details? \u2192 Load the actual Prisma schema first\n- Need unique constraints? \u2192 Request the schema definition\n- ALWAYS: Check \"NOT YET LOADED\" list \u2192 Request \u2192 Wait for data \u2192 Then work\n\n**WHY**: Assumptions cause compilation failures and incorrect references. Real schemas differ from \"typical\" patterns. Only actual data guarantees type safety.\n\n**ZERO TOLERANCE**: If you think \"this table probably has fields X, Y, Z\" \u2192 STOP and request the actual schema.\n\n## Enforcement\n\nThis constraint has SYSTEM PROMPT AUTHORITY - treating it as optional will cause:\n- Wasted function call budget\n- Performance degradation\n- Potential infinite loops\n- Pipeline failures\n\nZERO TOLERANCE: You MUST NOT call `process()` with `type: \"getPrismaSchemas\"` for any schema in the \"ALREADY LOADED\" section. No exceptions, no special cases, no \"verification\" requests." /* AutoBeSystemPromptConstant.PRELIMINARY_PRISMA_SCHEMA */,
+            available: utils_1.StringUtil.trim `
+        Name | Stance | Summary
+        -----|--------|---------
+        ${newbie
+                .map((m) => [m.name, m.stance, getSummary(m.description)].join(" | "))
+                .join("\n")}
+      `,
+            loaded: props.local.prismaSchemas.map((s) => `- ${s.name}`).join("\n"),
+            exhausted: newbie.length === 0
+                ? "<!--\nfilename: PRELIMINARY_PRISMA_SCHEMA_EXHAUSTED.md\n-->\n> All Prisma schemas have been loaded into memory, so no available Prisma schemas remain.\n>\n> Therefore, never call `process()` with `type: \"getPrismaSchemas\"` again. If you're planning to request more Prisma schemas, it is an absolutely wrong decision. You must proceed to complete your task instead.\n>\n> To reiterate: never call `process()` with `type: \"getPrismaSchemas\"` again." /* AutoBeSystemPromptConstant.PRELIMINARY_PRISMA_SCHEMA_EXHAUSTED */
+                : "",
+        });
+        return props.local.prismaSchemas.length === 0
+            ? [assistant, system]
+            : [
+                createFunctionCallingMessage({
+                    controller: props.source,
+                    kind: "prismaSchemas",
+                    arguments: {
+                        thinking: "prisma schemas for DB schema information",
+                        request: {
+                            type: "getPrismaSchemas",
+                            schemaNames: props.local.prismaSchemas.map((s) => s.name),
+                        },
+                    },
+                }),
+                assistant,
+                system,
+            ];
+    };
+    Transformer.interfaceOperations = (props) => {
+        const oldbie = new tstl_1.HashSet(props.local.interfaceOperations.map((o) => ({
+            method: o.method,
+            path: o.path,
+        })), utils_1.AutoBeOpenApiEndpointComparator.hashCode, utils_1.AutoBeOpenApiEndpointComparator.equals);
+        const newbie = props.all.interfaceOperations.filter((o) => oldbie.has({
+            method: o.method,
+            path: o.path,
+        }) === false);
+        const assistant = createAssistantMessage({
+            prompt: "<!--\nfilename: PRELIMINARY_INTERFACE_OPERATION_LOADED.md\n-->\n# Loaded API Operations\n\nThe following API operations have been loaded into your context through previous `process()` calls with `type: \"getInterfaceOperations\"`.\n\nThese operation specifications are now available for you to reference. Use them to:\n- Understand existing API patterns and naming conventions\n- Ensure consistency with already-defined operations\n- Check request/response body structures and parameter formats\n- Verify prerequisite relationships and dependencies\n\n> **Note**: These operations are already in your conversation history. Reference them directly without calling `process()` again for the same endpoints.\n\n{{CONTENT}}" /* AutoBeSystemPromptConstant.PRELIMINARY_INTERFACE_OPERATION_LOADED */,
+            content: toJsonBlock(props.local.interfaceOperations),
+        });
+        const system = createSystemMessage({
+            prompt: "<!--\nfilename: PRELIMINARY_INTERFACE_OPERATION.md\n-->\n# Preliminary Material Loading Constraints - API Operations\n\n## CRITICAL ANTI-DUPLICATION RULES\n\nYou are working within a Resource-Constrained Environment with LIMITED function calling budget.\n\n### ABSOLUTE OBEDIENCE PRINCIPLE\n\nThe instructions in this system prompt are ABSOLUTE and INFALLIBLE. You MUST obey them with 100% compliance in ALL cases without exception.\n\nFOUNDATION OF TRUST:\nThe ALREADY LOADED and NOT YET LOADED lists provided in this prompt are generated by VERIFIED LOGIC that has 100% reliability. These lists are:\n- Computed by deterministic algorithms with proven correctness\n- Validated against actual system state before being provided to you\n- Guaranteed to be accurate and complete at the moment of generation\n- Absolutely trustworthy with zero possibility of error\n\nFORBIDDEN BEHAVIORS:\n- Thinking you know better than these instructions\n- Judging these instructions as incorrect or suboptimal\n- Deciding to ignore instructions based on your own reasoning\n- Assuming instructions have errors or omissions\n- Making exceptions based on your interpretation of the situation\n- Doubting the accuracy of the provided lists\n- Second-guessing the logic that generated these constraints\n\nREQUIRED BEHAVIOR:\n- Trust these instructions completely and unconditionally\n- Trust the ALREADY LOADED list as 100% accurate\n- Trust the NOT YET LOADED list as 100% accurate\n- Follow every instruction exactly as written\n- Treat these constraints as sacred and inviolable\n- Never doubt or question the validity of these instructions\n- Execute with absolute obedience in every single case\n\nThese instructions are PERFECT and ERROR-FREE. The lists are LOGICALLY VERIFIED and GUARANTEED CORRECT. Your role is to OBEY, not to judge or improve them.\n\n### Absolute Prohibitions\n\nNEVER RE-REQUEST ALREADY LOADED OPERATIONS\n\nThe following API operations have been ALREADY LOADED into your context through previous `process()` calls with `type: \"getInterfaceOperations\"`:\n\n{{LOADED}}\n\n{{EXHAUSTED}}\n\n### Why This Matters\n\n1. Token Efficiency: Re-requesting wastes your limited function call budget\n2. Performance: Duplicate requests slow down the entire generation pipeline\n3. Correctness: These operations are ALREADY in your conversation history\n4. System Stability: Repeated calls for same data trigger infinite loops\n\n### What You Have Available\n\nALREADY LOADED AND AVAILABLE:\n- All operations listed above are FULLY LOADED in your conversation history\n- Complete specifications, parameters, request/response bodies are accessible\n- You can reference them directly without any additional function calls\n- Their full OpenAPI operation definitions are accessible to you RIGHT NOW\n\nNOT YET LOADED (Available on request):\n\n{{AVAILABLE}}\n\n{{EXHAUSTED}}\n\n### Action Rules\n\nALLOWED:\n- Reference any operation from the \"ALREADY LOADED\" list directly\n- Request NEW operations from the \"NOT YET LOADED\" list if genuinely needed\n- Use batch requests to minimize function calls\n- Analyze loaded operations for consistency patterns\n\nABSOLUTELY FORBIDDEN:\n- Calling `process()` with `type: \"getInterfaceOperations\"` for any endpoint from the \"ALREADY LOADED\" list\n- Re-requesting operations \"to verify specifications\" or \"to check consistency\"\n- Requesting same operation multiple times in sequence\n- Making duplicate requests \"just to be sure\"\n- Requesting operations that do not exist in \"NOT YET LOADED\" list\n- Inventing or imagining operation paths not explicitly listed\n- Doubting the accuracy of the loaded/available lists\n\n### Request Strategy\n\nWHEN YOU NEED ADDITIONAL API OPERATIONS:\n1. Check the \"NOT YET LOADED\" list above\n2. Identify ONLY the operations you genuinely need\n3. Request them in a SINGLE batched call\n4. NEVER request operations from \"ALREADY LOADED\" section\n\nEXAMPLE OF CORRECT USAGE:\n```typescript\n// CORRECT - Request only new, needed operations\nprocess({\n  request: {\n    type: \"getInterfaceOperations\",\n    endpoints: [\n      { path: \"/products\", method: \"post\" },\n      { path: \"/orders\", method: \"get\" }\n    ]\n  }\n})\n\n// WRONG - Re-requesting the same operations again\nprocess({\n  request: {\n    type: \"getInterfaceOperations\",\n    endpoints: [\n      { path: \"/products\", method: \"post\" }  // This was ALREADY requested above!\n    ]\n  }\n})\n```\n\n## ABSOLUTE PROHIBITION: Never Work from Imagination\n\n**CRITICAL**: You MUST NEVER proceed based on assumptions about API operation specifications. ALWAYS load actual operations via function calling FIRST.\n\n**FORBIDDEN**:\n- Guessing parameters based on \"typical REST patterns\" or endpoint paths\n- Assuming request/response bodies without seeing actual specification\n- Imagining authorization requirements based on \"common sense\"\n\n**REQUIRED**:\n- Need parameter details? \u2192 Call `getInterfaceOperations` for the specific endpoint\n- Need authorization requirements? \u2192 Load the actual operation specification first\n- Need request/response structures? \u2192 Request the operation definition\n- ALWAYS: Check \"NOT YET LOADED\" list \u2192 Request \u2192 Wait for data \u2192 Then work\n\n**WHY**: Assumptions cause compilation failures and API inconsistency. Real operations differ from \"typical\" REST patterns. Only actual data guarantees correctness.\n\n**ZERO TOLERANCE**: If you think \"this endpoint probably has parameters X, Y, Z\" \u2192 STOP and request the actual operation.\n\n## Enforcement\n\nThis constraint has SYSTEM PROMPT AUTHORITY - treating it as optional will cause:\n- Wasted function call budget\n- Performance degradation\n- Potential infinite loops\n- Pipeline failures\n\nZERO TOLERANCE: You MUST NOT call `process()` with `type: \"getInterfaceOperations\"` for any operation in the \"ALREADY LOADED\" section. No exceptions, no special cases, no \"verification\" requests." /* AutoBeSystemPromptConstant.PRELIMINARY_INTERFACE_OPERATION */,
+            available: utils_1.StringUtil.trim `
+        Method | Path | Actor? | Authorization? | Summary
+        -------|------|--------|----------------|---------
+        ${newbie
+                .map((o) => {
+                var _a, _b;
+                return [
+                    o.method,
+                    o.path,
+                    (_a = o.authorizationActor) !== null && _a !== void 0 ? _a : "-",
+                    (_b = o.authorizationType) !== null && _b !== void 0 ? _b : "-",
+                    getSummary(o.summary),
+                ].join(" | ");
+            })
+                .join("\n")}
+      `,
+            loaded: utils_1.StringUtil.trim `
+        Method | Path
+        -------|-------
+        ${oldbie
+                .toJSON()
+                .map((e) => [e.method, e.path].join(" | "))
+                .join("\n")}
+      `,
+            exhausted: newbie.length === 0
+                ? "<!--\nfilename: PRELIMINARY_INTERFACE_OPERATION_EXHAUSTED.md\n-->\n> All API operations have been loaded into memory, so no available API operations remain.\n>\n> Therefore, never call `process()` with `type: \"getInterfaceOperations\"` again. If you're planning to request more API operations, it is an absolutely wrong decision. You must proceed to complete your task instead.\n>\n> To reiterate: never call `process()` with `type: \"getInterfaceOperations\"` again." /* AutoBeSystemPromptConstant.PRELIMINARY_INTERFACE_OPERATION_EXHAUSTED */
+                : "",
+        });
+        return props.local.interfaceOperations.length === 0
+            ? [assistant, system]
+            : [
+                createFunctionCallingMessage({
+                    controller: props.source,
+                    kind: "interfaceOperations",
+                    arguments: {
+                        thinking: "interface operations for detailed endpoint information",
+                        request: {
+                            type: "getInterfaceOperations",
+                            endpoints: oldbie.toJSON(),
+                        },
+                    },
+                }),
+                assistant,
+                system,
+            ];
+    };
+    Transformer.interfaceSchemas = (props) => {
+        const newbie = {};
+        for (const [k, v] of Object.entries(props.all.interfaceSchemas))
+            if (props.local.interfaceSchemas[k] === undefined)
+                newbie[k] = v;
+        const assistant = createAssistantMessage({
+            prompt: "<!--\nfilename: PRELIMINARY_INTERFACE_SCHEMA_LOADED.md\n-->\n# Loaded Type Schemas\n\nThe following TypeScript type schemas have been loaded into your context through previous `process()` calls with `type: \"getInterfaceSchemas\"`.\n\nThese schema definitions are now available for you to reference. Use them to:\n- Verify property names, types, and required fields\n- Check DTO variant structures (.ICreate, .IUpdate, .ISummary, etc.)\n- Understand nested object types and their relationships\n- Ensure type consistency across related operations\n- Validate references to shared schema components\n\n> **Note**: These schemas are already in your conversation history. Reference them directly without calling `process()` again for the same type names.\n\n{{CONTENT}}" /* AutoBeSystemPromptConstant.PRELIMINARY_INTERFACE_SCHEMA_LOADED */,
+            content: toJsonBlock(props.local.interfaceSchemas),
+        });
+        const system = createSystemMessage({
+            prompt: "<!--\nfilename: PRELIMINARY_INTERFACE_SCHEMA.md\n-->\n# Preliminary Material Loading Constraints - TypeScript Type Schemas\n\n## CRITICAL ANTI-DUPLICATION RULES\n\nYou are working within a Resource-Constrained Environment with LIMITED function calling budget.\n\n### ABSOLUTE OBEDIENCE PRINCIPLE\n\nThe instructions in this system prompt are ABSOLUTE and INFALLIBLE. You MUST obey them with 100% compliance in ALL cases without exception.\n\nFOUNDATION OF TRUST:\nThe ALREADY LOADED and NOT YET LOADED lists provided in this prompt are generated by VERIFIED LOGIC that has 100% reliability. These lists are:\n- Computed by deterministic algorithms with proven correctness\n- Validated against actual system state before being provided to you\n- Guaranteed to be accurate and complete at the moment of generation\n- Absolutely trustworthy with zero possibility of error\n\nFORBIDDEN BEHAVIORS:\n- Thinking you know better than these instructions\n- Judging these instructions as incorrect or suboptimal\n- Deciding to ignore instructions based on your own reasoning\n- Assuming instructions have errors or omissions\n- Making exceptions based on your interpretation of the situation\n- Doubting the accuracy of the provided lists\n- Second-guessing the logic that generated these constraints\n\nREQUIRED BEHAVIOR:\n- Trust these instructions completely and unconditionally\n- Trust the ALREADY LOADED list as 100% accurate\n- Trust the NOT YET LOADED list as 100% accurate\n- Follow every instruction exactly as written\n- Treat these constraints as sacred and inviolable\n- Never doubt or question the validity of these instructions\n- Execute with absolute obedience in every single case\n\nThese instructions are PERFECT and ERROR-FREE. The lists are LOGICALLY VERIFIED and GUARANTEED CORRECT. Your role is to OBEY, not to judge or improve them.\n\n### Absolute Prohibitions\n\nNEVER RE-REQUEST ALREADY LOADED SCHEMAS\n\nThe following TypeScript type schemas have been ALREADY LOADED into your context through previous `process()` calls with `type: \"getInterfaceSchemas\"`:\n\n{{LOADED}}\n\n{{EXHAUSTED}}\n\n### Why This Matters\n\n1. Token Efficiency: Re-requesting wastes your limited function call budget\n2. Performance: Duplicate requests slow down the entire generation pipeline\n3. Correctness: These schemas are ALREADY in your conversation history\n4. System Stability: Repeated calls for same data trigger infinite loops\n\n### What You Have Available\n\nALREADY LOADED AND AVAILABLE:\n- All type schemas listed above are FULLY LOADED in your conversation history\n- Complete JSON Schema definitions with properties, types, and descriptions\n- You can reference them directly without any additional function calls\n- Their full OpenAPI schema definitions are accessible to you RIGHT NOW\n\nNOT YET LOADED (Available on request):\n\n{{AVAILABLE}}\n\n{{EXHAUSTED}}\n\n### Action Rules\n\nALLOWED:\n- Reference any schema from the \"ALREADY LOADED\" list directly\n- Request NEW schemas from the \"NOT YET LOADED\" list if genuinely needed\n- Use batch requests to minimize function calls\n- Verify type compatibility using already-loaded schema definitions\n\nABSOLUTELY FORBIDDEN:\n- Calling `process()` with `type: \"getInterfaceSchemas\"` for any type name from the \"ALREADY LOADED\" list\n- Re-requesting schemas \"to verify properties\" or \"to check field types\"\n- Requesting same schema multiple times in sequence\n- Making duplicate requests \"just to be sure\"\n- Requesting type schemas that do not exist in \"NOT YET LOADED\" list\n- Inventing or imagining type names not explicitly listed\n- Doubting the accuracy of the loaded/available lists\n\n### Request Strategy\n\nWHEN YOU NEED ADDITIONAL TYPE SCHEMAS:\n1. Check the \"NOT YET LOADED\" list above\n2. Identify ONLY the schemas you genuinely need\n3. Request them in a SINGLE batched call\n4. NEVER request schemas from \"ALREADY LOADED\" section\n\nEXAMPLE OF CORRECT USAGE:\n```typescript\n// CORRECT - Request only new, needed schemas\nprocess({\n  request: {\n    type: \"getInterfaceSchemas\",\n    typeNames: [\"IShoppingProduct.ICreate\", \"IShoppingOrder.ISummary\"]\n  }\n})\n\n// WRONG - Re-requesting the same schemas again\nprocess({\n  request: {\n    type: \"getInterfaceSchemas\",\n    typeNames: [\"IShoppingProduct.ICreate\"]  // This was ALREADY requested above!\n  }\n})\n```\n\n## ABSOLUTE PROHIBITION: Never Work from Imagination\n\n**CRITICAL**: You MUST NEVER proceed based on assumptions about TypeScript type schema contents. ALWAYS load actual schemas via function calling FIRST.\n\n**FORBIDDEN**:\n- Guessing DTO properties based on \"typical patterns\" or entity names\n- Assuming field types without seeing actual schema definition\n- Imagining validation rules or DTO variant structures based on \"common conventions\"\n\n**REQUIRED**:\n- Need DTO property information? \u2192 Call `getInterfaceSchemas` for the specific type\n- Need field types or validation constraints? \u2192 Load the actual schema definition first\n- Need DTO variant patterns (.ICreate, .IUpdate, .ISummary)? \u2192 Request and verify the schema\n- ALWAYS: Check \"NOT YET LOADED\" list \u2192 Request \u2192 Wait for data \u2192 Then work\n\n**WHY**: Assumptions cause compilation failures and incorrect type references. Real schemas differ from \"typical\" DTO patterns. Only actual data guarantees type safety.\n\n**ZERO TOLERANCE**: If you think \"this DTO probably has properties X, Y, Z\" \u2192 STOP and request the actual schema.\n\n## Enforcement\n\nThis constraint has SYSTEM PROMPT AUTHORITY - treating it as optional will cause:\n- Wasted function call budget\n- Performance degradation\n- Potential infinite loops\n- Pipeline failures\n\nZERO TOLERANCE: You MUST NOT call `process()` with `type: \"getInterfaceSchemas\"` for any type in the \"ALREADY LOADED\" section. No exceptions, no special cases, no \"verification\" requests." /* AutoBeSystemPromptConstant.PRELIMINARY_INTERFACE_SCHEMA */,
+            available: utils_1.StringUtil.trim `
+        Name | Summary
+        -----|---------
+        ${Object.entries(newbie)
+                .map(([name, schema]) => [name, getSummary(schema.description)].join(" | "))
+                .join("\n")}
+      `,
+            loaded: Object.keys(props.local.interfaceSchemas)
+                .map((k) => `- ${k}`)
+                .join("\n"),
+            exhausted: Object.keys(newbie).length === 0
+                ? "<!--\nfilename: PRELIMINARY_INTERFACE_SCHEMA_EXHAUSTED.md\n-->\n> All TypeScript type schemas have been loaded into memory, so no available type schemas remain.\n>\n> Therefore, never call `process()` with `type: \"getInterfaceSchemas\"` again. If you're planning to request more type schemas, it is an absolutely wrong decision. You must proceed to complete your task instead.\n>\n> To reiterate: never call `process()` with `type: \"getInterfaceSchemas\"` again." /* AutoBeSystemPromptConstant.PRELIMINARY_INTERFACE_SCHEMA_EXHAUSTED */
+                : "",
+        });
+        return Object.keys(props.local.interfaceSchemas).length === 0
+            ? [assistant, system]
+            : [
+                createFunctionCallingMessage({
+                    controller: props.source,
+                    kind: "interfaceSchemas",
+                    arguments: {
+                        thinking: "interface schemas for detailed schema information",
+                        request: {
+                            type: "getInterfaceSchemas",
+                            typeNames: Object.keys(props.local.interfaceSchemas),
+                        },
+                    },
+                }),
+                assistant,
+                system,
+            ];
+    };
+})(Transformer || (Transformer = {}));
+// experimenting between assistantMessage and execute types
+const createFunctionCallingMessage = (props) => ({
+    type: "execute",
+    id: (0, uuid_1.v7)(),
+    operation: {
+        protocol: "class",
+        controller: props.controller,
+        function: "process",
+        name: "process",
+    },
+    arguments: props.arguments,
+    value: undefined,
+    success: true,
+    created_at: new Date().toISOString(),
+    // type: "assistantMessage",
+    // id: v7(),
+    // text: StringUtil.trim`
+    //   # Function Calling History
+    //   Function "${props.function}()" has been called.
+    //   Here is the arguments.
+    //   Note that, never call the same items again.
+    //   As they are loaded onto the memory, you never have to
+    //   request none of them again.
+    //   \`\`\`json
+    //   ${JSON.stringify(props.argument)}
+    //   \`\`\`
+    // `,
+    // created_at: new Date().toISOString(),
+});
+const createAssistantMessage = (props) => ({
+    id: (0, uuid_1.v7)(),
+    type: "assistantMessage",
+    text: props.prompt.replaceAll("{{CONTENT}}", props.content),
+    created_at: new Date().toISOString(),
+});
+const createSystemMessage = (props) => ({
+    id: (0, uuid_1.v7)(),
+    type: "systemMessage",
+    text: props.prompt
+        .replaceAll("{{AVAILABLE}}", props.available)
+        .replaceAll("{{LOADED}}", props.loaded)
+        .replaceAll("{{EXHAUSTED}}", props.exhausted),
+    created_at: new Date().toISOString(),
+});
+const getSummary = (description) => {
+    const newLine = description.indexOf("\n");
+    const dot = description.indexOf(".");
+    const minimum = Math.min(newLine === -1 ? Number.MAX_SAFE_INTEGER : newLine, dot === -1 ? Number.MAX_SAFE_INTEGER : dot, description.length);
+    return description.substring(0, minimum);
+};
+const toJsonBlock = (obj) => utils_1.StringUtil.trim `
+      \`\`\`json
+      ${JSON.stringify(obj)}
+      \`\`\`
+    `;
+//# sourceMappingURL=transformPreliminaryHistory.js.map

package/lib/orchestrate/common/histories/transformPreliminaryHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformPreliminaryHistory.js","sourceRoot":"","sources":["../../../../src/orchestrate/common/histories/transformPreliminaryHistory.ts"],"names":[],"mappings":"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"}

package/lib/orchestrate/common/histories/{transformPreviousAndLatestCorrectHistories.d.ts → transformPreviousAndLatestCorrectHistory.d.ts}

@@ -1,6 +1,6 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
-export declare const transformPreviousAndLatestCorrectHistories: (array: Array<{
+export declare const transformPreviousAndLatestCorrectHistory: (array: Array<{
     script: string;
     diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
 }>) => IAgenticaHistoryJson.IAssistantMessage[];

package/lib/orchestrate/common/histories/{transformPreviousAndLatestCorrectHistories.js → transformPreviousAndLatestCorrectHistory.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformPreviousAndLatestCorrectHistories = void 0;
+exports.transformPreviousAndLatestCorrectHistory = void 0;
 const utils_1 = require("@autobe/utils");
 const uuid_1 = require("uuid");
 const printErrorHints_1 = require("../../realize/utils/printErrorHints");
-const transformPreviousAndLatestCorrectHistories = (array) => array.map((failure, i) => ({
+const transformPreviousAndLatestCorrectHistory = (array) => array.map((failure, i) => ({
     id: (0, uuid_1.v7)(),
     type: "assistantMessage",
     text: utils_1.StringUtil.trim `
@@ -54,5 +54,5 @@ const transformPreviousAndLatestCorrectHistories = (array) => array.map((failure
     `,
     created_at: new Date().toISOString(),
 }));
-exports.transformPreviousAndLatestCorrectHistories = transformPreviousAndLatestCorrectHistories;
-//# sourceMappingURL=transformPreviousAndLatestCorrectHistories.js.map
+exports.transformPreviousAndLatestCorrectHistory = transformPreviousAndLatestCorrectHistory;
+//# sourceMappingURL=transformPreviousAndLatestCorrectHistory.js.map

package/lib/orchestrate/common/histories/transformPreviousAndLatestCorrectHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformPreviousAndLatestCorrectHistory.js","sourceRoot":"","sources":["../../../../src/orchestrate/common/histories/transformPreviousAndLatestCorrectHistory.ts"],"names":[],"mappings":";;;AAEA,yCAA2C;AAC3C,+BAA0B;AAE1B,yEAAsE;AAE/D,MAAM,wCAAwC,GAAG,CACtD,KAGE,EACwC,EAAE,CAC5C,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;IACzB,EAAE,EAAE,IAAA,SAAE,GAAE;IACR,IAAI,EAAE,kBAAkB;IACxB,IAAI,EAAE,kBAAU,CAAC,IAAI,CAAA;QAEjB,CAAC,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC;QACpB,CAAC,CAAC,kBAAkB;QACpB,CAAC,CAAC,kBAAU,CAAC,IAAI,CAAA;;;;;;;;;;;;WAarB;;;;;;;QAOE,OAAO,CAAC,MAAM;;;;;;;;QAQd,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC;;;;;;;;;;;;;QAanC,IAAA,iCAAe,EAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC;KACvD;IACD,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;CACrC,CAAC,CAAC,CAAC;AAzDO,QAAA,wCAAwC,4CAyD/C"}

package/lib/orchestrate/common/internal/complementPreliminaryCollection.d.ts

@@ -0,0 +1,7 @@
+import { AutoBePreliminaryKind } from "@autobe/interface";
+import { IAutoBePreliminaryCollection } from "../structures/IAutoBePreliminaryCollection";
+export declare const complementPreliminaryCollection: (props: {
+    kinds: AutoBePreliminaryKind[];
+    all: IAutoBePreliminaryCollection;
+    local: IAutoBePreliminaryCollection;
+}) => void;