okengine 0.9.1 → 0.10.0

package/src/cli/drizzle-env.test.ts

@@ -7,7 +7,7 @@ import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { OkeConfig } from "../config/index.ts";
-import { resolveDrizzleKitEnv } from "./drizzle-env.ts";
+import { applyComposeEnvToProcess, resolveDrizzleKitEnv } from "./drizzle-env.ts";
 
 const dirs: string[] = [];
 
@@ -46,11 +46,18 @@ describe("resolveDrizzleKitEnv", () => {
       join(dir, "docker", ".env.docker"),
       "DATABASE_URL=postgres://u:p@127.0.0.1:5432/oke\n",
     );
-    const ctx = await resolveDrizzleKitEnv(dir, dualConfig, "docker");
-    expect(ctx.dialect).toBe("postgresql");
-    expect(ctx.overlay.OKE_DRIZZLE_DIALECT).toBe("postgresql");
-    expect(ctx.overlay.DATABASE_URL).toBe("postgres://u:p@127.0.0.1:5432/oke");
-    expect(ctx.overlay.OKE_SQLITE_URL).toBeUndefined();
+    const prevDb = process.env["DATABASE_URL"];
+    delete process.env["DATABASE_URL"];
+    try {
+      const ctx = await resolveDrizzleKitEnv(dir, dualConfig, "docker");
+      expect(ctx.dialect).toBe("postgresql");
+      expect(ctx.overlay.OKE_DRIZZLE_DIALECT).toBe("postgresql");
+      expect(ctx.overlay.DATABASE_URL).toBe("postgres://u:p@127.0.0.1:5432/oke");
+      expect(ctx.overlay.OKE_SQLITE_URL).toBeUndefined();
+    } finally {
+      if (prevDb === undefined) delete process.env["DATABASE_URL"];
+      else process.env["DATABASE_URL"] = prevDb;
+    }
   });
 
   test("docker dialect is postgresql even when DATABASE_URL unset (no URL guessing)", async () => {
@@ -65,3 +72,30 @@ describe("resolveDrizzleKitEnv", () => {
     await expect(resolveDrizzleKitEnv(dir, bad, "local")).rejects.toThrow(/not supported/);
   });
 });
+
+describe("applyComposeEnvToProcess", () => {
+  test("fills unset keys from docker/.env.docker without overwriting", async () => {
+    const dir = await tempDir();
+    await mkdir(join(dir, "docker"), { recursive: true });
+    await writeFile(
+      join(dir, "docker", ".env.docker"),
+      "DATABASE_URL=postgres://u:p@127.0.0.1:5432/oke\nREDIS_URL=redis://127.0.0.1:6379\n",
+    );
+    const prevDb = process.env["DATABASE_URL"];
+    const prevRedis = process.env["REDIS_URL"];
+    delete process.env["DATABASE_URL"];
+    process.env["REDIS_URL"] = "redis://already-set";
+    try {
+      const applied = await applyComposeEnvToProcess(dir);
+      expect(applied).toContain("DATABASE_URL");
+      expect(applied).not.toContain("REDIS_URL");
+      expect(process.env["DATABASE_URL"]).toBe("postgres://u:p@127.0.0.1:5432/oke");
+      expect(process.env["REDIS_URL"]).toBe("redis://already-set");
+    } finally {
+      if (prevDb === undefined) delete process.env["DATABASE_URL"];
+      else process.env["DATABASE_URL"] = prevDb;
+      if (prevRedis === undefined) delete process.env["REDIS_URL"];
+      else process.env["REDIS_URL"] = prevRedis;
+    }
+  });
+});

package/src/cli/drizzle-env.ts

@@ -26,7 +26,7 @@ export interface DrizzleKitEnvContext {
  *
  * @param cwd - Project root
  */
-async function readComposeEnv(cwd: string): Promise<Map<string, string>> {
+export async function readComposeEnv(cwd: string): Promise<Map<string, string>> {
   const { path } = resolveComposeEnvPath(cwd);
   const file = Bun.file(path);
   if (!(await file.exists())) return new Map();
@@ -37,6 +37,27 @@ async function readComposeEnv(cwd: string): Promise<Map<string, string>> {
   }
 }
 
+/**
+ * Fill unset `process.env` keys from compose `.env.docker` (never overwrites).
+ *
+ * SQL / Redis binders read `process.env` directly — Vault can resolve the
+ * same file, but `oke db seed` must hydrate env before `app.boot()`.
+ *
+ * @param cwd - Project root
+ * @returns Keys that were applied
+ */
+export async function applyComposeEnvToProcess(cwd: string): Promise<readonly string[]> {
+  const compose = await readComposeEnv(cwd);
+  const applied: string[] = [];
+  for (const [key, value] of compose) {
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+      applied.push(key);
+    }
+  }
+  return applied;
+}
+
 /**
  * Resolve the drizzle-kit env context for a project + env.
  *

package/src/cli/ensure-drizzle-config.ts

@@ -13,17 +13,19 @@ const DRIZZLE_CONFIG_TEMPLATE = `import { defineConfig } from "drizzle-kit";
  *
  * Dialect comes from OKE's \`store.sql\` driver map (resolved by the CLI and
  * injected as \`OKE_DRIZZLE_DIALECT\`) — never inferred from \`DATABASE_URL\`
- * presence. \`src/schema.generated.ts\` is emitted from \`src/schema.decl.ts\`
+ * presence. \`src/db/schema.generated.ts\` is emitted from \`src/db/schema.decl.ts\`
  * for the active dialect as a pre-step of \`oke db\` / \`oke dev\`.
  *
- * Versioned prod migrations land in \`./drizzle\` — never mix with \`.oke/\`.
+ * Versioned prod migrations land in \`./src/db/migrations\` — never mix with \`.oke/\`.
  */
 const dialect = (process.env.OKE_DRIZZLE_DIALECT ?? "sqlite") as "sqlite" | "postgresql";
 
 export default defineConfig({
   dialect,
-  schema: "./src/schema.generated.ts",
-  out: "./drizzle",
+  schema: "./src/db/schema.generated.ts",
+  out: "./src/db/migrations",
+  // Core runtime tables (oke_crons, …) are created by drivers — not domain schema.
+  tablesFilter: ["!oke_*"],
   dbCredentials: {
     url:
       dialect === "postgresql"

package/src/cli/hero-meta.test.ts

@@ -49,7 +49,8 @@ describe("hero-meta", () => {
       "ai",
     ]);
     expect(rows.find((r) => r.element === "store")?.detail).toContain("sqlite");
-    expect(rows.find((r) => r.element === "flow")?.detail).toBe("●");
+    expect(rows.find((r) => r.element === "flow")?.detail).toBe("");
+    expect(rows.find((r) => r.element === "flow")?.status).toBe("ready");
   });
 
   test("docker profile applies to every element", () => {
@@ -81,4 +82,15 @@ describe("hero-meta", () => {
     expect(snap.runtimeEnv).toBe("local");
     expect(decodeHeroSnapshot(encodeHeroSnapshot(snap))).toEqual(snap);
   });
+
+  test("hero AI row includes configured model id", () => {
+    const snap = buildDevHeroSnapshot({
+      config: SAMPLE,
+      docker: true,
+      aiModel: "gemma4:e4b-q4_K_M",
+      nodeEnv: "development",
+    });
+    const ai = snap.elements.find((r) => r.element === "ai")?.detail ?? "";
+    expect(ai).toContain("gemma4:e4b-q4_K_M");
+  });
 });

package/src/cli/hero-meta.ts

@@ -9,6 +9,7 @@ import {
   type DriversConfig,
   type OkeConfig,
 } from "../config/index.ts";
+import type { DevStatus } from "../term.ts";
 
 /** How the process is running (local laptop → production). */
 export type DevRuntimeProfile = "local" | "docker" | "test" | "production";
@@ -21,6 +22,8 @@ export type HeroElementRow = {
   readonly element: string;
   /** Driver summary, or `—` when unbound. */
   readonly detail: string;
+  /** Status dot — ready / pending / error / idle. */
+  readonly status?: DevStatus;
 };
 
 /** Serializable hero payload (TTY + soft-reload env). */
@@ -148,6 +151,10 @@ export function resolveHeroElements(
     readonly docker: boolean;
     readonly sqlDriver?: string;
     readonly kvDriver?: string;
+    /** Configured model id (`OKE_AI_MODEL`) when known. */
+    readonly aiModel?: string;
+    /** AI readiness when known (model loading / ready). */
+    readonly aiStatus?: DevStatus;
     /** Which driver map column to read (default `local`). */
     readonly configEnv?: ConfigEnv;
   },
@@ -162,8 +169,13 @@ export function resolveHeroElements(
     resolveDriverId(drivers?.store?.kv, configEnv) ??
     (options.docker ? "redis" : "memory");
 
+  const aiDriver = resolveDriverId(drivers?.ai, configEnv);
+  const aiModel = options.aiModel?.trim();
+  const aiDetail = aiDriver && aiModel ? `${aiDriver} · ${aiModel}` : (aiDriver ?? "—");
+
   const byName: Record<string, string> = {
-    flow: "●",
+    // Status ● is rendered separately — flow has no driver id.
+    flow: "",
     signal: resolveDriverId(drivers?.signal, configEnv) ?? "—",
     store: storeDetail(drivers?.store, configEnv, {
       sql: options.sqlDriver,
@@ -173,13 +185,17 @@ export function resolveHeroElements(
     gate: gateKv,
     vault: resolveDriverId(drivers?.vault, configEnv) ?? "—",
     channel: channelDetail(drivers?.channel, configEnv),
-    ai: resolveDriverId(drivers?.ai, configEnv) ?? "—",
+    ai: aiDetail,
   };
 
-  return EIGHT_ELEMENTS.map((element) => ({
-    element,
-    detail: byName[element] ?? "—",
-  }));
+  return EIGHT_ELEMENTS.map((element) => {
+    const detail = byName[element] ?? "—";
+    const idle = detail === "—" || detail === "";
+    let status: DevStatus = idle && element !== "flow" ? "idle" : "ready";
+    if (element === "flow") status = "ready";
+    if (element === "ai" && options.aiStatus && !idle) status = options.aiStatus;
+    return { element, detail, status };
+  });
 }
 
 /**
@@ -192,6 +208,10 @@ export function buildDevHeroSnapshot(options: {
   readonly docker: boolean;
   readonly sqlDriver?: string;
   readonly kvDriver?: string;
+  /** Configured model id (`OKE_AI_MODEL`) when known. */
+  readonly aiModel?: string;
+  /** AI readiness when known (model loading / ready). */
+  readonly aiStatus?: DevStatus;
   readonly version?: string;
   readonly nodeEnv?: string;
 }): DevHeroSnapshot {
@@ -207,6 +227,8 @@ export function buildDevHeroSnapshot(options: {
       docker: options.docker,
       sqlDriver: options.sqlDriver,
       kvDriver: options.kvDriver,
+      aiModel: options.aiModel,
+      aiStatus: options.aiStatus,
     }),
     ...(options.version !== undefined ? { version: options.version } : {}),
   };

package/src/cli/index.ts

@@ -19,6 +19,7 @@ import { imagesCli } from "./images.ts";
 import { modeCli } from "./mode.ts";
 import { privacyEraseCli } from "./privacy-erase.ts";
 import { formatOkeHelp } from "./registry.ts";
+import { replayCli } from "./replay.ts";
 import { schemaCli } from "./schema.ts";
 import { stackCli } from "./stack.ts";
 import { startCli } from "./start.ts";
@@ -88,6 +89,10 @@ if (cmd === "branch") {
   process.exit(await branchCli(sub ? [sub, ...rest] : rest));
 }
 
+if (cmd === "replay") {
+  process.exit(await replayCli(sub ? [sub, ...rest] : rest));
+}
+
 if (cmd === "privacy" && sub === "erase") {
   process.exit(await privacyEraseCli(rest));
 }

package/src/cli/registry.ts

@@ -466,6 +466,30 @@ export const OKE_COMMANDS: readonly CliCommand[] = [
       HELP,
     ],
   },
+  {
+    name: "replay",
+    summary: "re-invoke a past Flow from a Runs WideEvent",
+    leaf: true,
+    flags: [
+      {
+        long: "--request-id",
+        short: "-r",
+        takesValue: true,
+        valueName: "id",
+        summary: "WideEvent / run id to replay",
+      },
+      ENTRY,
+      {
+        long: "--dry-run",
+        summary: "Stub irreversible effects (send / ask)",
+      },
+      {
+        long: "--live",
+        summary: "Allow live re-execution of send / ask effects",
+      },
+      HELP,
+    ],
+  },
   {
     name: "privacy",
     summary: "crypto-shred subject data",

package/src/cli/replay.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+import { createRunsRuntime } from "../runs/runtime.ts";
+import type { WideEvent } from "../runs/types.ts";
+import { eventHasIrreversible, findRunById, runReplay } from "./replay.ts";
+
+function sampleEvent(overrides: Partial<WideEvent> = {}): WideEvent {
+  return {
+    id: "run-1",
+    flow: "notes.create",
+    trigger: "http",
+    plane: "user",
+    gates: [],
+    cache: "none",
+    error: null,
+    input: { title: "hello" },
+    effects: [],
+    logs: [],
+    durationMs: 12,
+    startedAt: 1,
+    endedAt: 13,
+    dimensions: {},
+    ...overrides,
+  };
+}
+
+describe("oke replay", () => {
+  test("eventHasIrreversible detects send/ask", () => {
+    expect(eventHasIrreversible(sampleEvent())).toBe(false);
+    expect(
+      eventHasIrreversible(
+        sampleEvent({
+          effects: [
+            {
+              kind: "send",
+              resource: "welcome",
+              timestamp: 1,
+              duration: 1,
+              reversibility: "irreversible",
+            },
+          ],
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  test("findRunById + runReplay re-invokes with stored input", async () => {
+    const runs = createRunsRuntime({ driver: "memory" });
+    await runs.open();
+    const event = sampleEvent({ id: "req-42" });
+    await runs.append(event);
+
+    expect(await findRunById(runs, "req-42")).toEqual(event);
+
+    const lines: string[] = [];
+    let seenInput: unknown;
+    const code = await runReplay({
+      requestId: "req-42",
+      runs,
+      write: (t) => lines.push(t),
+      executeReplay: async (_entry, e, dryRun) => {
+        seenInput = e.input;
+        expect(dryRun).toBe(false);
+        return { output: { ok: true, title: (e.input as { title: string }).title } };
+      },
+    });
+    expect(code).toBe(0);
+    expect(seenInput).toEqual({ title: "hello" });
+    expect(lines.some((l) => l.includes("notes.create"))).toBe(true);
+
+    await runs.close();
+  });
+
+  test("defaults to dry-run when ledger has send", async () => {
+    const runs = createRunsRuntime({ driver: "memory" });
+    await runs.open();
+    await runs.append(
+      sampleEvent({
+        id: "req-send",
+        effects: [
+          {
+            kind: "send",
+            resource: "mail",
+            timestamp: 1,
+            duration: 2,
+            reversibility: "irreversible",
+          },
+        ],
+      }),
+    );
+
+    let dry: boolean | undefined;
+    const code = await runReplay({
+      requestId: "req-send",
+      runs,
+      write: () => {},
+      executeReplay: async (_e, _ev, dryRun) => {
+        dry = dryRun;
+        return { output: { ok: true } };
+      },
+    });
+    expect(code).toBe(0);
+    expect(dry).toBe(true);
+    await runs.close();
+  });
+});

package/src/cli/replay.ts

@@ -0,0 +1,206 @@
+/**
+ * `oke replay --request-id <id>` — re-invoke a past Flow from a WideEvent.
+ */
+
+import { resolve } from "node:path";
+import { withDryRun } from "../kernel/dry-run.ts";
+import type { AnyFlowDef } from "../kernel/flow.ts";
+import type { InternalTrigger } from "../kernel/triggers.ts";
+import { createRunsRuntime, type RunsRuntime, type WideEvent } from "../runs/index.ts";
+import { resolveStartEntry } from "./start.ts";
+import { flagValue, hasFlag } from "./args.ts";
+import { EXIT_OK, EXIT_USAGE } from "./exit.ts";
+
+/** Options for {@link runReplay}. */
+export interface ReplayOptions {
+  readonly requestId: string;
+  readonly cwd?: string;
+  readonly entry?: string;
+  /** Force dry-run (stub irreversible effects). */
+  readonly dryRun?: boolean;
+  /** Force live replay even when the ledger has send/ask. */
+  readonly live?: boolean;
+  readonly write?: (text: string) => void;
+  /** Injected runs runtime (tests). */
+  readonly runs?: RunsRuntime;
+  /**
+   * Load and execute the app (tests).
+   *
+   * @param entry - Absolute entry path
+   * @param event - Wide event to replay
+   * @param dryRun - Whether to wrap in dry-run
+   */
+  readonly executeReplay?: (
+    entry: string,
+    event: WideEvent,
+    dryRun: boolean,
+  ) => Promise<{ readonly output: unknown; readonly failure?: unknown }>;
+}
+
+/**
+ * True when the event's effect ledger includes irreversible kinds.
+ *
+ * @param event - Wide event
+ */
+export function eventHasIrreversible(event: WideEvent): boolean {
+  return event.effects.some((e) => e.kind === "send" || e.kind === "ask");
+}
+
+/**
+ * Look up a WideEvent by id across the runs store.
+ *
+ * @param runs - Open runs runtime
+ * @param id - Request / run id
+ */
+export async function findRunById(runs: RunsRuntime, id: string): Promise<WideEvent | undefined> {
+  const all = await runs.all();
+  return all.find((e) => e.id === id);
+}
+
+/**
+ * Resolve an OkeApp export from an entry module.
+ *
+ * @param mod - Imported module
+ */
+export function appFromModule(mod: Record<string, unknown>): {
+  execute: (
+    flow: AnyFlowDef,
+    input: unknown,
+    trigger: InternalTrigger,
+  ) => Promise<{ output: unknown; failure?: unknown }>;
+  bindings: readonly { flow: AnyFlowDef }[];
+} | null {
+  const candidates = [mod.app, mod.default, mod.oke];
+  for (const c of candidates) {
+    if (
+      c &&
+      typeof c === "object" &&
+      "execute" in c &&
+      typeof (c as { execute: unknown }).execute === "function" &&
+      "bindings" in c
+    ) {
+      return c as {
+        execute: (
+          flow: AnyFlowDef,
+          input: unknown,
+          trigger: InternalTrigger,
+        ) => Promise<{ output: unknown; failure?: unknown }>;
+        bindings: readonly { flow: AnyFlowDef }[];
+      };
+    }
+  }
+  return null;
+}
+
+async function defaultExecuteReplay(
+  entry: string,
+  event: WideEvent,
+  dryRun: boolean,
+): Promise<{ readonly output: unknown; readonly failure?: unknown }> {
+  const mod = (await import(entry)) as Record<string, unknown>;
+  const app = appFromModule(mod);
+  if (!app) {
+    throw new Error(`oke replay: ${entry} must export \`app\` (oke({…}))`);
+  }
+  const flow = app.bindings.map((b) => b.flow).find((f) => f.name === event.flow);
+  if (!flow) {
+    throw new Error(`oke replay: flow "${event.flow}" not found in app bindings`);
+  }
+  if (event.input === undefined) {
+    throw new Error(
+      `oke replay: run "${event.id}" has no stored input — re-run after upgrading to a build that persists WideEvent.input`,
+    );
+  }
+  const trigger: InternalTrigger = { kind: "internal" };
+  const run = () => app.execute(flow, event.input, trigger);
+  if (dryRun) {
+    const wrapped = await withDryRun(run);
+    return wrapped.result as { output: unknown; failure?: unknown };
+  }
+  return run();
+}
+
+/**
+ * Replay a past run locally from the Runs store.
+ *
+ * @param options - Request id + entry
+ */
+export async function runReplay(options: ReplayOptions): Promise<number> {
+  const write = options.write ?? ((t) => process.stdout.write(t));
+  const cwd = options.cwd ?? process.cwd();
+
+  try {
+    const runs =
+      options.runs ??
+      createRunsRuntime({
+        driver: "files",
+        localRoot: resolve(cwd, ".oke/runs"),
+      });
+    if (!runs.store) await runs.open();
+
+    const event = await findRunById(runs, options.requestId);
+    if (!event) {
+      console.error(`oke replay: run not found: ${options.requestId}`);
+      return 1;
+    }
+    if (event.input === undefined) {
+      console.error(
+        `oke replay: run "${options.requestId}" has no stored input (cannot re-invoke)`,
+      );
+      return 1;
+    }
+
+    const irreversible = eventHasIrreversible(event);
+    const dryRun = options.live === true ? false : options.dryRun === true || irreversible;
+    if (irreversible && !options.live && options.dryRun !== false) {
+      write(
+        "oke replay: ledger has send/ask — running as dry-run (pass --live to re-execute external effects)\n",
+      );
+    }
+
+    const execute = options.executeReplay ?? defaultExecuteReplay;
+    const entry = options.executeReplay
+      ? (options.entry ?? "test://entry")
+      : await resolveStartEntry(cwd, options.entry);
+    write(`oke replay: ${event.flow} ← ${event.id}${dryRun ? " (dry-run)" : ""}\n`);
+    const result = await execute(entry, event, dryRun);
+    if (result.failure) {
+      write(`oke replay: failed ${JSON.stringify(result.failure)}\n`);
+      return 1;
+    }
+    write(`oke replay: ok ${JSON.stringify(result.output ?? null)}\n`);
+    return EXIT_OK;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+
+/**
+ * CLI entry for `oke replay`.
+ *
+ * @param args - Args after `replay`
+ */
+export async function replayCli(args: readonly string[]): Promise<number> {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`oke replay --request-id <id> [--entry|-e src/app.ts] [--dry-run] [--live]
+
+Re-invoke a past Flow locally from a WideEvent in the Runs store.
+Defaults to dry-run when the ledger contains send/ask effects.
+`);
+    return EXIT_OK;
+  }
+
+  const requestId = flagValue(args, "--request-id", "-r");
+  if (!requestId) {
+    console.error("Usage: oke replay --request-id <id>");
+    return EXIT_USAGE;
+  }
+
+  return runReplay({
+    requestId,
+    entry: flagValue(args, "--entry", "-e"),
+    dryRun: hasFlag(args, "--dry-run"),
+    live: hasFlag(args, "--live"),
+  });
+}

package/src/compiler/extract.ts

@@ -22,6 +22,7 @@ import type {
   Journey,
   Manifest,
   RateStrategy,
+  ResourceRef,
   SecretContract,
   Signal,
   SignalDelivery,
@@ -1333,9 +1334,8 @@ function registerResourceMount(
   const resource = baseName ? scope.resources.get(baseName) : undefined;
 
   const unit = resource?.unit;
-  const storeRef = resource?.storeRef as Effects["reads"] extends readonly (infer R)[] | undefined
-    ? R
-    : never;
+  const storeRef: ResourceRef | undefined =
+    resource?.storeRef !== undefined ? (resource.storeRef as ResourceRef) : undefined;
   const effects: Effects | undefined = storeRef
     ? { reads: [storeRef], writes: [storeRef] }
     : undefined;

package/src/config/index.ts

@@ -155,13 +155,13 @@ export interface DbConfig {
   /**
    * Abstract schema declare module (`store.schema.table` exports).
    * When present, `oke db` emits Drizzle into {@link generated} before sync.
-   * Default `"src/schema.decl.ts"` (emit skipped if the file is absent).
+   * Default `"src/db/schema.decl.ts"` (legacy `"src/schema.decl.ts"` still resolved).
    */
   readonly declare?: string;
   /**
    * Generated Drizzle schema path written from abstract decls.
-   * Default `"src/schema.generated.ts"`. Point `drizzle.config.ts` `schema`
-   * at this file when using the abstract path.
+   * Default `"src/db/schema.generated.ts"` (legacy `"src/schema.generated.ts"`).
+   * Point `drizzle.config.ts` `schema` at this file when using the abstract path.
    */
   readonly generated?: string;
   /**

package/src/console/server/claim.ts

@@ -58,7 +58,9 @@ export function mintClaimCode(now: () => number = Date.now): ClaimCodeState {
  */
 export function printClaimCodeOnce(
   state: ClaimCodeState,
-  write: (line: string) => void = (line) => console.log(line),
+  write: (line: string) => void = (line) => {
+    process.stdout.write(line);
+  },
 ): void {
   if (state.printed) return;
   state.printed = true;