@autobe/agent 0.10.5 → 0.11.0

package/src/orchestrate/realize/structures/IAutoBeRealizeCoderApplication.ts

@@ -1,39 +1,213 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 
-import { FAILED } from "../orchestrateRealize";
+import { FAILED } from "./IAutoBeRealizeFailedSymbol";
 
 export interface IAutoBeRealizeCoderApplication {
-  programing: (next: IAutoBeRealizeCoderApplication.IProps) => void;
+  programming: (input: IAutoBeRealizeCoderApplication.IProps) => void;
 }
 
 export namespace IAutoBeRealizeCoderApplication {
+  /**
+   * Properties for the component or function that consumes the output of the
+   * code generation pipeline.
+   */
   export interface IProps {
-    result: RealizeCoderOutput;
+    /**
+     * The detailed output of the code generation process, containing all phases
+     * from planning to final implementation of a TypeScript provider function.
+     */
+    output: RealizeCoderOutput;
   }
 
   /**
-   * The result of the code generation step, representing a fully generated
-   * TypeScript function.
+   * Represents the complete output of a code generation pipeline. Each field
+   * corresponds to a stage in the Chain of Thought (CoT) process for generating
+   * a production-quality TypeScript function.
+   *
+   * All fields contain TypeScript code strings and follow these rules:
+   *
+   * - All code must be valid TypeScript or structurally valid even if incomplete.
+   * - Each phase builds upon the previous one and must resolve specific concerns.
+   * - All phases must follow system conventions around structure, typing, and
+   *   logic.
    */
   export interface RealizeCoderOutput {
+    /** The name of the file to be generated (e.g., "user.create.ts") */
+    filename: string;
+
     /**
-     * The name of the function to be generated.
+     * 🧠 Provider Function Implementation Plan
+     *
+     * This field outlines the strategic plan for implementing the provider
+     * function according to the Realize Coder Agent specification. Before
+     * writing the actual code, think through the logic and structure.
+     *
+     * The plan must consider:
+     *
+     * - 🧩 Required business entities (e.g., users, posts, logs) and their
+     *   relationships
+     * - 🛠 Operations needed to fulfill the business scenario (e.g., fetch,
+     *   create, update)
+     * - 🔄 Data dependencies between steps (e.g., use userId to fetch related
+     *   data)
+     * - ✅ Validation points (based on business rules, not field presence)
+     * - 🚧 Error and edge cases that must be handled explicitly (e.g., missing
+     *   records)
+     * - 🏗 Structure: always a single `async function`, using only `parameters`
+     *   and `body`
+     *
+     * ⚠️ Important Constraints:
+     *
+     * - Do NOT perform input validation — assume `parameters` and `body` are
+     *   already valid
+     * - Use `typia.random<T>()` with an explanatory comment if logic can't be
+     *   implemented
+     * - Never use `any` or make assumptions without sufficient context
+     * - Use only allowed imports — DTOs and Prisma types
+     * - Use `MyGlobal.prisma` for DB access and respect Prisma typing rules
+     *
+     * ⚠️ TypeScript-specific considerations:
+     *
+     * - Do **not** use native `Date` objects directly; convert all dates with
+     *   `.toISOString()`
+     * - Use `string & tags.Format<'date-time'>` for all date/time typed fields
+     * - Prefer `satisfies` for DTO conformance instead of unsafe `as` casts
+     * - Avoid weak typing such as `any`, `as any`, or `satisfies any`
+     * - Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where
+     *   applicable
      *
-     * This name will be used as the function's identifier and as the export
-     * name in the provider file.
+     * ✅ Example Structure:
+     *
+     * ```ts
+     * export async function doSomething(
+     *   user: { id: string & tags.Format<"uuid">; type: string },
+     *   parameters: IParams,
+     *   body: IBody
+     * ): Promise<IReturn> {
+     *   const { id } = parameters;
+     *   const { name } = body;
+     *   const user = await MyGlobal.prisma.users.findFirst({ where: { id } });
+     *   if (!user) throw new Error("User not found");
+     *   ...
+     *   return result;
+     * }
+     * ```
+     *
+     * 🔥 Error Handling Plan:
+     *
+     * If an error is expected or encountered during implementation:
+     *
+     * - Clearly document the error message(s) and TypeScript error codes.
+     * - Analyze the root cause (e.g., type mismatch, missing field, nullability
+     *   issue).
+     * - Define concrete steps to resolve the issue, such as:
+     *
+     *   - Adjusting type declarations or using Prisma-generated input types.
+     *   - Using `?? undefined` to normalize nullable fields.
+     *   - Applying correct relation handling (e.g., `connect` instead of direct
+     *       foreign key assignment).
+     *   - Ensuring `Date` fields use `.toISOString()` and branded types.
+     * - Include fallback or workaround plans if a direct fix is complex.
+     * - If no error is present, simply omit this section.
+     *
+     * This plan ensures the function will:
+     *
+     * - Respect the global architecture and coding conventions
+     * - Be safe, predictable, and aligned with upstream logic
      */
-    functionName: string;
+    plan: string;
 
     /**
-     * The raw TypeScript code string implementing the function.
-     *
-     * - The implementation must be valid TypeScript code.
-     * - It should focus solely on the logic of the function.
-     * - Import statements do **not** need to be included. They will be
-     *   automatically inserted by the system.
-     * - Any unused imports will be automatically removed by eslint.
-     * - Type annotations (e.g. for parameters and return types) should be omitted
-     *   if they can be inferred.
+     * ✏️ Phase 1: Draft code
+     *
+     * This is the initial drafting phase where you outline the basic skeleton
+     * of the function.
+     *
+     * - The function signature must correctly include `user`, `parameters`, and
+     *   `body` arguments.
+     * - Design the main flow of business logic, such as DB fetches and early
+     *   returns based on conditions.
+     * - Mark any incomplete or missing parts clearly with placeholders (e.g.,
+     *   comments or temporary values).
+     *
+     * ⚠️ Import rules:
+     *
+     * - Do NOT add any new import statements manually.
+     * - All necessary imports are provided globally or by the system
+     *   automatically.
+     * - Writing import statements directly is prohibited and may cause compile
+     *   errors. If import errors occur, check your environment configuration.
+     *
+     * ✅ Requirements:
+     *
+     * - Avoid using the `any` type at all costs to ensure type safety.
+     * - Do NOT assign native `Date` objects directly; always convert dates using
+     *   `.toISOString()` before assignment.
+     * - Maintain a single-function structure; avoid using classes.
+     */
+
+    /**
+     * 🔍 Phase 2: Review code
+     *
+     * A refined version of the draft with improved completeness.
+     *
+     * - Replace placeholder logic with real DTO-conformant operations.
+     * - Add error handling (`throw new Error(...)`) where necessary.
+     * - Begin resolving structural or type mismatches.
+     *
+     * ✅ Requirements:
+     *
+     * - Use `satisfies` to ensure DTO conformity.
+     * - Avoid unsafe `as` casts unless only for branding or literal narrowing.
+     * - Include `.toISOString()` for all date fields.
+     * - Ensure all object keys strictly conform to the expected type definitions.
+     */
+    review: string;
+
+    /**
+     * 🛠 Phase 3: With compiler feedback (optional)
+     *
+     * A correction pass that applies fixes for compile-time errors that arose
+     * during the review stage (if any).
+     *
+     * ✅ Must:
+     *
+     * - Resolve all TypeScript errors without using `as any`
+     * - Provide safe brand casting only if required (e.g., `as string &
+     *   tags.Format<'uuid'>`)
+     */
+    withCompilerFeedback?: string;
+
+    /**
+     * ✅ Phase 4: Final implementation
+     *
+     * The complete and fully correct TypeScript function implementation.
+     *
+     * - Passes strict type checking without errors.
+     * - Uses only safe branding or literal type assertions.
+     * - Converts all Date values properly to ISO string format.
+     * - Follows DTO structures using `satisfies`.
+     * - Avoids any weak typing such as `any`, `as any`, or `satisfies any`.
+     * - Uses only allowed imports (e.g., from `src/api/structures` and
+     *   `MyGlobal.prisma`).
+     *
+     * ⚠️ Prohibited Practices:
+     *
+     * - Do NOT add or modify import statements manually. Imports are handled
+     *   automatically by the system.
+     * - Do NOT use `any`, `as any`, or `satisfies any` to bypass type checking.
+     * - Do NOT assign native `Date` objects directly; always convert them to ISO
+     *   strings with `.toISOString()`.
+     * - Do NOT use unsafe type assertions except for safe branding or literal
+     *   narrowing.
+     * - Do NOT write code outside the single async function structure (e.g., no
+     *   classes or multiple functions).
+     * - Do NOT perform any input validation — assume all inputs are already
+     *   validated.
+     * - Do NOT use dynamic import expressions (`import()`); all imports must be
+     *   static.
+     * - Do NOT rely on DTO types for database update input; always use
+     *   Prisma-generated input types.
      */
     implementationCode: string;
   }

package/src/orchestrate/realize/structures/IAutoBeRealizeCompile.ts

@@ -0,0 +1,34 @@
+import {
+  AutoBeOpenApi,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+
+import { IAutoBeRealizeCoderApplication } from "./IAutoBeRealizeCoderApplication";
+import { FAILED } from "./IAutoBeRealizeFailedSymbol";
+
+export namespace IAutoBeRealizeCompile {
+  export interface Success {
+    type: "success";
+    op: AutoBeOpenApi.IOperation;
+    result: Pick<
+      IAutoBeRealizeCoderApplication.RealizeCoderOutput,
+      "filename" | "implementationCode"
+    >;
+  }
+
+  export interface Fail {
+    type: "failed";
+    op: AutoBeOpenApi.IOperation;
+    result: FAILED;
+  }
+
+  export type FileContentMap = Record<
+    string,
+    { content: string; result: "failed" | "success" }
+  >;
+
+  export interface CompileDiagnostics {
+    total: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+    current: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+  }
+}

package/src/orchestrate/realize/structures/IAutoBeRealizeFailedSymbol.ts

@@ -0,0 +1,2 @@
+export const FAILED = Symbol("FAILED");
+export type FAILED = typeof FAILED;

package/src/orchestrate/realize/transformRealizeCoderHistories.ts

@@ -1,4 +1,5 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
 import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
@@ -10,6 +11,9 @@ export const transformRealizeCoderHistories = (
   state: AutoBeState,
   props: RealizePlannerOutput,
   artifacts: IAutoBeTestScenarioArtifacts,
+  previous: string | null,
+  total: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
@@ -86,47 +90,67 @@ export const transformRealizeCoderHistories = (
       id: v4(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
-      text: [
-        AutoBeSystemPromptConstant.REALIZE_CODER,
-        "",
-        "# Prisma Schemas",
-        "```json",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_TYPESCRIPT,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_PRISMA,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_BROWSER,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_TYPIA,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_ARTIFACT.replaceAll(
+        `{prisma_schemas}`,
         JSON.stringify(state.prisma.schemas),
-        "```",
-        "",
-        // "# Prisma Types",
-        // "```json",
-        // JSON.stringify(state.prisma.compiled.nodeModules),
-        // "```",
-        "# SDK",
-        "",
-        "The following is the SDK for the API. Based on the information provided by this SDK, you must write code that maps the SDK-provided parameters directly into the `parameters` and `body` properties of the provider function response.",
-        "If there are no parameters, define `parameters` as `Record<string, never>`. Similarly, if there is no body, define `body` as `Record<string, never>`.",
-        "**Every function must be implemented to accept both `parameters` and `body`, without exception.**",
-        "If any required type information is referenced in the SDK, refer to the definitions in the DTO section.",
-        "",
-        "```json",
-        JSON.stringify(artifacts.sdk),
-        "```",
-        "",
-        "# DTO",
-        "if you want to import this files, write this: 'import { something } from '../api/structures/something';'",
-        "",
-        "```json",
-        JSON.stringify(artifacts.dto),
-        "```",
-        "# Document",
-        "```json",
-        JSON.stringify(artifacts.document),
-        "```",
-      ].join("\n"),
+      )
+        .replaceAll(`{artifacts_sdk}`, JSON.stringify(artifacts.sdk))
+        .replaceAll(`{artifacts_dto}`, JSON.stringify(artifacts.dto))
+        .replaceAll(`{artifacts_document}`, JSON.stringify(artifacts.document)),
     },
+    ...(previous !== null
+      ? [
+          {
+            id: v4(),
+            created_at: new Date().toISOString(),
+            type: "assistantMessage",
+            text: AutoBeSystemPromptConstant.REALIZE_CODER_DIAGNOSTICS.replaceAll(
+              `{code}`,
+              previous,
+            )
+              .replaceAll("{total_diagnostics}", JSON.stringify(total))
+              .replaceAll("{current_diagnostics}", JSON.stringify(diagnostics)),
+          } as const,
+        ]
+      : []),
     {
       id: v4(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
       text: [
-        "write code by following information of operation.",
+        previous
+          ? "Modify the previous code to reflect the following operation."
+          : "Write new code based on the following operation.",
         "```json",
         JSON.stringify(props),
         "```",

package/src/orchestrate/realize/writeCodeUntilCompilePassed.ts

@@ -0,0 +1,178 @@
+import {
+  AutoBeOpenApi,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { readFile } from "fs/promises";
+import path from "path";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { pipe } from "./RealizePipe";
+import { orchestrateRealizeCoder } from "./orchestrateRealizeCoder";
+import { orchestrateRealizePlanner } from "./orchestrateRealizePlanner";
+import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
+import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
+import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
+
+export async function writeCodeUntilCompilePassed<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  ops: AutoBeOpenApi.IOperation[],
+  retry: number = 5,
+): Promise<
+  Pick<
+    IAutoBeRealizeCoderApplication.RealizeCoderOutput,
+    "filename" | "implementationCode"
+  >[]
+> {
+  const files = Object.entries(await ctx.files({ dbms: "postgres" }))
+    .filter(([key]) => {
+      return key.startsWith("src");
+    })
+    .reduce(
+      (acc, [filename, content]) => Object.assign(acc, { [filename]: content }),
+      {},
+    );
+
+  const templateFiles = ["src/providers/jwtDecode.ts", "src/MyGlobal.ts"];
+  const entireCodes: IAutoBeRealizeCompile.FileContentMap = {
+    ...(await loadTemplateFiles(templateFiles)),
+  };
+
+  let diagnostics: IAutoBeRealizeCompile.CompileDiagnostics = {
+    current: [],
+    total: [],
+  };
+
+  for (let i = 0; i < retry; i++) {
+    const generatedCodes: (
+      | IAutoBeRealizeCompile.Success
+      | IAutoBeRealizeCompile.Fail
+    )[] = await Promise.all(
+      ops
+        .filter((op) => shouldProcessOperation(op, diagnostics.current))
+        .map((op) => process(ctx, op, diagnostics, entireCodes)),
+    );
+
+    for (const c of generatedCodes) {
+      if (c.type === "success") {
+        entireCodes[c.result.filename] = {
+          content: c.result.implementationCode,
+          result: "success",
+        };
+      }
+    }
+
+    const prisma = ctx.state().prisma?.compiled;
+    const nodeModules = prisma?.type === "success" ? prisma.nodeModules : {};
+    const compiler = await ctx.compiler();
+    const compiled = await compiler.typescript.compile({
+      files: {
+        ...files,
+        ...nodeModules,
+        ...Object.entries(entireCodes)
+          .map(([filename, { content }]) => {
+            return {
+              [filename]: content,
+            };
+          })
+          .reduce<Record<string, string>>(
+            (acc, cur) => Object.assign(acc, cur),
+            {},
+          ),
+      },
+    });
+
+    if (
+      compiled.type === "success" &&
+      generatedCodes.every((c) => c.type === "success")
+    ) {
+      break;
+    } else if (compiled.type === "failure") {
+      diagnostics.current = compiled.diagnostics;
+      diagnostics.total = [...diagnostics.total, ...compiled.diagnostics];
+
+      console.log(JSON.stringify(diagnostics, null, 2), i);
+    }
+  }
+
+  return Object.entries(entireCodes).map(([filename, { content }]) => {
+    return {
+      filename,
+      implementationCode: content,
+    };
+  });
+}
+
+async function loadTemplateFiles(
+  templateFiles: string[],
+): Promise<Record<string, { content: string; result: "success" }>> {
+  const templateBasePath = path.join(
+    __dirname,
+    "../../../../../internals/template/realize",
+  );
+
+  const result: Record<string, { content: string; result: "success" }> = {};
+
+  for (const filePath of templateFiles) {
+    result[filePath] = {
+      content: await readFile(path.join(templateBasePath, filePath), {
+        encoding: "utf-8",
+      }),
+      result: "success",
+    };
+  }
+
+  return result;
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  op: AutoBeOpenApi.IOperation,
+  diagnostics: IAutoBeRealizeCompile.CompileDiagnostics,
+  entireCodes: IAutoBeRealizeCompile.FileContentMap,
+) {
+  const result = await pipe(
+    op,
+    (op) => orchestrateRealizePlanner(ctx, op),
+    (p) => {
+      const filename = `src/providers/${p.functionName}.ts` as const;
+      const t = diagnostics.total.filter((el) => el.file === filename);
+
+      const d = diagnostics.current.filter((el) => el.file === filename);
+      const c = entireCodes[filename]?.content ?? null;
+
+      return orchestrateRealizeCoder(ctx, op, p, c, t, d);
+    },
+  );
+
+  if (result === FAILED) {
+    return { type: "failed", op, result } as const;
+  }
+
+  return { type: "success", op, result: result } as const;
+}
+
+function shouldProcessOperation(
+  op: AutoBeOpenApi.IOperation,
+  currentDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+): boolean {
+  if (currentDiagnostics.length === 0) {
+    return true;
+  }
+
+  const operationFilename = generateProviderFilename(op);
+
+  return currentDiagnostics.some(
+    (diagnostic) => diagnostic.file === operationFilename,
+  );
+}
+
+function generateProviderFilename(op: AutoBeOpenApi.IOperation): string {
+  return `src/providers/${op.method}_${op.path
+    .replaceAll("/", "_")
+    .replaceAll("-", "_")
+    .replaceAll("{", "$")
+    .replaceAll("}", "")}.ts`;
+}

package/src/orchestrate/test/compile/getTestExternalDeclarations.ts

@@ -4,10 +4,11 @@ import { Singleton } from "tstl";
 
 import { AutoBeContext } from "../../../context/AutoBeContext";
 
-export function getTestExternalDeclarations<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-): Promise<Record<string, string>> {
-  return singleton.get(ctx.compiler.test);
+export async function getTestExternalDeclarations<
+  Model extends ILlmSchema.Model,
+>(ctx: AutoBeContext<Model>): Promise<Record<string, string>> {
+  const compiler = await ctx.compiler();
+  return singleton.get(compiler.test);
 }
 
 const singleton = new Singleton(async (compiler: IAutoBeTestCompiler) => {

package/src/orchestrate/test/compile/getTestScenarioArtifacts.ts

@@ -1,4 +1,8 @@
-import { AutoBeOpenApi, AutoBeTestScenario } from "@autobe/interface";
+import {
+  AutoBeOpenApi,
+  AutoBeTestScenario,
+  IAutoBeCompiler,
+} from "@autobe/interface";
 import { ILlmSchema, OpenApiTypeChecker } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../../context/AutoBeContext";
@@ -8,12 +12,13 @@ export async function getTestScenarioArtifacts<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   scenario: Pick<AutoBeTestScenario, "endpoint" | "dependencies">,
 ): Promise<IAutoBeTestScenarioArtifacts> {
+  const compiler: IAutoBeCompiler = await ctx.compiler();
   const document: AutoBeOpenApi.IDocument = filterDocument(
     scenario,
     ctx.state().interface!.document,
   );
   const entries: [string, string][] = Object.entries(
-    await ctx.compiler.interface.compile(document),
+    await compiler.interface.write(document),
   );
   const filter = (prefix: string, exclude?: string) => {
     const result: [string, string][] = entries.filter(

package/src/orchestrate/test/orchestrateTest.ts

@@ -5,6 +5,7 @@ import {
   AutoBeTestHistory,
   AutoBeTestScenarioEvent,
   AutoBeTestValidateEvent,
+  IAutoBeCompiler,
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
@@ -66,17 +67,18 @@ export const orchestrateTest =
     );
 
     // DO COMPILE
-    const files: AutoBeTestFile[] = success.map((c) => c.file);
+    const compiler: IAutoBeCompiler = await ctx.compiler();
+    const result: AutoBeTestFile[] = success.map((c) => c.file);
     const compiled: IAutoBeTypeScriptCompileResult =
-      await ctx.compiler.test.compile({
-        files: {
-          ...Object.fromEntries(
-            Object.entries(ctx.state().interface!.files).filter(
-              ([key]) => key.startsWith("src/api") === true,
-            ),
-          ),
-          ...Object.fromEntries(files.map((f) => [f.location, f.content])),
-        },
+      await compiler.typescript.compile({
+        files: Object.fromEntries([
+          ...Object.entries(
+            await ctx.files({
+              dbms: "sqlite",
+            }),
+          ).filter(([key]) => key.endsWith(".ts")),
+          ...result.map((f) => [f.location, f.content]),
+        ]),
       });
 
     const history: AutoBeTestHistory = {
@@ -84,7 +86,7 @@ export const orchestrateTest =
       id: v4(),
       completed_at: new Date().toISOString(),
       created_at: start.toISOString(),
-      files,
+      files: result,
       compiled,
       reason: "Step to the test generation referencing the interface",
       step: ctx.state().interface?.step ?? 0,
@@ -92,7 +94,7 @@ export const orchestrateTest =
     ctx.dispatch({
       type: "testComplete",
       created_at: start.toISOString(),
-      files: Object.fromEntries(files.map((f) => [f.location, f.content])),
+      files: Object.fromEntries(result.map((f) => [f.location, f.content])),
       compiled,
       step: ctx.state().interface?.step ?? 0,
     });