@codemation/host 0.0.1

package/src/infrastructure/di/InMemoryCommandBus.ts

@@ -0,0 +1,47 @@
+import { injectAll, injectable } from "@codemation/core";
+import type { Command } from "../../application/bus/Command";
+import type { CommandBus } from "../../application/bus/CommandBus";
+import type { CommandHandler } from "../../application/bus/CommandHandler";
+import { ApplicationTokens } from "../../applicationTokens";
+import { commandHandlerMetadataKey } from "./HandlesCommandRegistry";
+
+type CommandType = abstract new (...args: any[]) => Command<unknown>;
+
+@injectable()
+export class InMemoryCommandBus implements CommandBus {
+  private readonly handlersByCommandType: ReadonlyMap<CommandType, CommandHandler<Command<unknown>, unknown>>;
+
+  constructor(
+    @injectAll(ApplicationTokens.CommandHandler)
+    handlers: ReadonlyArray<CommandHandler<Command<unknown>, unknown>>,
+  ) {
+    this.handlersByCommandType = this.createHandlersByCommandType(handlers);
+  }
+
+  async execute<TResult>(command: Command<TResult>): Promise<TResult> {
+    const handler = this.handlersByCommandType.get(command.constructor as CommandType);
+    if (!handler) {
+      throw new Error(`No command handler registered for ${command.constructor.name}`);
+    }
+    return (await handler.execute(command as Command<unknown>)) as TResult;
+  }
+
+  private createHandlersByCommandType(
+    handlers: ReadonlyArray<CommandHandler<Command<unknown>, unknown>>,
+  ): ReadonlyMap<CommandType, CommandHandler<Command<unknown>, unknown>> {
+    const handlersByCommandType = new Map<CommandType, CommandHandler<Command<unknown>, unknown>>();
+    for (const handler of handlers) {
+      const commandType = Reflect.getMetadata(commandHandlerMetadataKey, handler.constructor) as
+        | CommandType
+        | undefined;
+      if (!commandType) {
+        throw new Error(`Command handler ${handler.constructor.name} is missing @HandlesCommand metadata.`);
+      }
+      if (handlersByCommandType.has(commandType)) {
+        throw new Error(`Duplicate command handler registered for ${commandType.name}.`);
+      }
+      handlersByCommandType.set(commandType, handler);
+    }
+    return handlersByCommandType;
+  }
+}

package/src/infrastructure/di/InMemoryDomainEventBus.ts

@@ -0,0 +1,47 @@
+import { injectAll, injectable } from "@codemation/core";
+import type { DomainEvent } from "../../application/bus/DomainEvent";
+import type { DomainEventBus } from "../../application/bus/DomainEventBus";
+import type { DomainEventHandler } from "../../application/bus/DomainEventHandler";
+import { ApplicationTokens } from "../../applicationTokens";
+import { domainEventHandlerMetadataKey } from "./HandlesDomainEventRegistry";
+
+type DomainEventType = abstract new (...args: any[]) => DomainEvent;
+
+@injectable()
+export class InMemoryDomainEventBus implements DomainEventBus {
+  private readonly handlersByEventType: ReadonlyMap<DomainEventType, ReadonlyArray<DomainEventHandler<DomainEvent>>>;
+
+  constructor(
+    @injectAll(ApplicationTokens.DomainEventHandler)
+    handlers: ReadonlyArray<DomainEventHandler<DomainEvent>>,
+  ) {
+    this.handlersByEventType = this.createHandlersByEventType(handlers);
+  }
+
+  async publish(event: DomainEvent): Promise<void> {
+    const handlers = this.handlersByEventType.get(event.constructor as DomainEventType) ?? [];
+    for (const handler of handlers) {
+      await handler.handle(event);
+    }
+  }
+
+  private createHandlersByEventType(
+    handlers: ReadonlyArray<DomainEventHandler<DomainEvent>>,
+  ): ReadonlyMap<DomainEventType, ReadonlyArray<DomainEventHandler<DomainEvent>>> {
+    const handlersByEventType = new Map<DomainEventType, Array<DomainEventHandler<DomainEvent>>>();
+    for (const handler of handlers) {
+      const eventType = Reflect.getMetadata(domainEventHandlerMetadataKey, handler.constructor) as
+        | DomainEventType
+        | undefined;
+      if (!eventType) {
+        throw new Error(`Domain event handler ${handler.constructor.name} is missing @HandlesDomainEvent metadata.`);
+      }
+      const currentHandlers = handlersByEventType.get(eventType) ?? [];
+      currentHandlers.push(handler);
+      handlersByEventType.set(eventType, currentHandlers);
+    }
+    return new Map(
+      [...handlersByEventType.entries()].map(([eventType, eventHandlers]) => [eventType, [...eventHandlers]] as const),
+    );
+  }
+}

package/src/infrastructure/di/InMemoryQueryBus.ts

@@ -0,0 +1,45 @@
+import { injectAll, injectable } from "@codemation/core";
+import type { Query } from "../../application/bus/Query";
+import type { QueryBus } from "../../application/bus/QueryBus";
+import type { QueryHandler } from "../../application/bus/QueryHandler";
+import { ApplicationTokens } from "../../applicationTokens";
+import { queryHandlerMetadataKey } from "./HandlesQueryRegistry";
+
+type QueryType = abstract new (...args: any[]) => Query<unknown>;
+
+@injectable()
+export class InMemoryQueryBus implements QueryBus {
+  private readonly handlersByQueryType: ReadonlyMap<QueryType, QueryHandler<Query<unknown>, unknown>>;
+
+  constructor(
+    @injectAll(ApplicationTokens.QueryHandler)
+    handlers: ReadonlyArray<QueryHandler<Query<unknown>, unknown>>,
+  ) {
+    this.handlersByQueryType = this.createHandlersByQueryType(handlers);
+  }
+
+  async execute<TResult>(query: Query<TResult>): Promise<TResult> {
+    const handler = this.handlersByQueryType.get(query.constructor as QueryType);
+    if (!handler) {
+      throw new Error(`No query handler registered for ${query.constructor.name}`);
+    }
+    return (await handler.execute(query as Query<unknown>)) as TResult;
+  }
+
+  private createHandlersByQueryType(
+    handlers: ReadonlyArray<QueryHandler<Query<unknown>, unknown>>,
+  ): ReadonlyMap<QueryType, QueryHandler<Query<unknown>, unknown>> {
+    const handlersByQueryType = new Map<QueryType, QueryHandler<Query<unknown>, unknown>>();
+    for (const handler of handlers) {
+      const queryType = Reflect.getMetadata(queryHandlerMetadataKey, handler.constructor) as QueryType | undefined;
+      if (!queryType) {
+        throw new Error(`Query handler ${handler.constructor.name} is missing @HandlesQuery metadata.`);
+      }
+      if (handlersByQueryType.has(queryType)) {
+        throw new Error(`Duplicate query handler registered for ${queryType.name}.`);
+      }
+      handlersByQueryType.set(queryType, handler);
+    }
+    return handlersByQueryType;
+  }
+}

package/src/infrastructure/ids/CodemationIdFactory.ts

@@ -0,0 +1,12 @@
+import { injectable } from "@codemation/core";
+
+@injectable()
+export class CodemationIdFactory {
+  makeRunId(): string {
+    return `run_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  }
+
+  makeActivationId(): string {
+    return `act_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  }
+}

package/src/infrastructure/logging/BrowserLogger.ts

@@ -0,0 +1 @@
+export { ConsoleLogger as BrowserLogger } from "./ConsoleLogger";

package/src/infrastructure/logging/BrowserLoggerFactory.ts

@@ -0,0 +1,14 @@
+import type { Logger, LoggerFactory } from "../../application/logging/Logger";
+
+import type { LogLevelPolicy } from "./LogLevelPolicy";
+import { BrowserLogger } from "./BrowserLogger";
+
+export class BrowserLoggerFactory implements LoggerFactory {
+  constructor(private readonly logLevelPolicy: LogLevelPolicy) {}
+
+  create(scope: string): Logger {
+    return new BrowserLogger(scope, this.logLevelPolicy);
+  }
+}
+
+export { BrowserLogger } from "./BrowserLogger";

package/src/infrastructure/logging/ConsoleLogger.ts

@@ -0,0 +1,41 @@
+import type { Logger } from "../../application/logging/Logger";
+import type { LogLevelPolicy } from "./LogLevelPolicy";
+
+export class ConsoleLogger implements Logger {
+  constructor(
+    private readonly scope: string,
+    private readonly logLevelPolicy: LogLevelPolicy,
+  ) {}
+
+  info(message: string, exception?: Error): void {
+    this.log("info", message, exception);
+  }
+
+  warn(message: string, exception?: Error): void {
+    this.log("warn", message, exception);
+  }
+
+  error(message: string, exception?: Error): void {
+    this.log("error", message, exception);
+  }
+
+  debug(message: string, exception?: Error): void {
+    this.log("debug", message, exception);
+  }
+
+  private formatTimestamp(): string {
+    return new Date().toISOString();
+  }
+
+  private log(level: "info" | "warn" | "error" | "debug", message: string, exception?: Error): void {
+    if (!this.logLevelPolicy.shouldEmit(level, this.scope)) {
+      return;
+    }
+    const line = `[${level}][${this.scope}][${this.formatTimestamp()}]: ${message}`;
+    if (exception) {
+      console[level](line, exception);
+      return;
+    }
+    console[level](line);
+  }
+}

package/src/infrastructure/logging/FilteringLogger.ts

@@ -0,0 +1,38 @@
+import type { LogFilter } from "../../application/logging/LogFilter";
+import type { Logger } from "../../application/logging/Logger";
+
+export class FilteringLogger implements Logger {
+  constructor(
+    private readonly inner: Logger,
+    private readonly scope: string,
+    private readonly filter: LogFilter,
+  ) {}
+
+  info(message: string, exception?: Error): void {
+    if (!this.filter({ scope: this.scope, level: "info", message })) {
+      return;
+    }
+    this.inner.info(message, exception);
+  }
+
+  warn(message: string, exception?: Error): void {
+    if (!this.filter({ scope: this.scope, level: "warn", message })) {
+      return;
+    }
+    this.inner.warn(message, exception);
+  }
+
+  error(message: string, exception?: Error): void {
+    if (!this.filter({ scope: this.scope, level: "error", message })) {
+      return;
+    }
+    this.inner.error(message, exception);
+  }
+
+  debug(message: string, exception?: Error): void {
+    if (!this.filter({ scope: this.scope, level: "debug", message })) {
+      return;
+    }
+    this.inner.debug(message, exception);
+  }
+}

package/src/infrastructure/logging/LogLevelPolicy.ts

@@ -0,0 +1,148 @@
+import type { CodemationLogConfig, CodemationLogRule } from "../../presentation/config/CodemationLogConfig";
+
+export type LogLevel = "silent" | "debug" | "info" | "warn" | "error";
+
+const levelRank: Record<Exclude<LogLevel, "silent">, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+const globRegexMetaChars = new Set("\\^$+?()[]{}|.");
+
+/**
+ * Minimum log level for @codemation/host loggers.
+ * - `CODEMATION_LOG_LEVEL` overrides when set to a known level (for namespaces not matched by `codemation.config` log rules).
+ * - Under Vitest, defaults to **warn** so routine `info`/`debug` noise stays off the terminal; `warn`/`error` still print.
+ * - Otherwise defaults to **info**.
+ *
+ * When {@link applyCodemationLogConfig} is set, the first matching rule wins per namespace; unmatched namespaces use env defaults.
+ *
+ * Resolve a shared instance via {@link LogLevelPolicyFactory} (DI or `logLevelPolicyFactory`).
+ */
+export class LogLevelPolicy {
+  private cachedMin: LogLevel | undefined;
+
+  private codemationRules: ReadonlyArray<{ matchers: ReadonlyArray<RegExp>; minLevel: LogLevel }> | null = null;
+
+  resolveMin(): LogLevel {
+    const raw = process.env.CODEMATION_LOG_LEVEL?.toLowerCase();
+    if (raw === "silent" || raw === "debug" || raw === "info" || raw === "warn" || raw === "error") {
+      return raw;
+    }
+    if (process.env.VITEST === "true") {
+      return "warn";
+    }
+    return "info";
+  }
+
+  private minLevelCached(): LogLevel {
+    if (this.cachedMin === undefined) {
+      this.cachedMin = this.resolveMin();
+    }
+    return this.cachedMin;
+  }
+
+  resetForTests(): void {
+    this.cachedMin = undefined;
+    this.codemationRules = null;
+  }
+
+  /**
+   * Applies `codemation.config` log rules. Pass `undefined` to clear rules and use env-only behavior.
+   */
+  applyCodemationLogConfig(config: CodemationLogConfig | undefined): void {
+    this.codemationRules = null;
+    if (!config) {
+      return;
+    }
+    const rawRules = this.normalizeCodemationRules(config);
+    if (rawRules.length === 0) {
+      return;
+    }
+    const compiled: { matchers: ReadonlyArray<RegExp>; minLevel: LogLevel }[] = [];
+    for (const rule of rawRules) {
+      const minLevel = this.parseRuleLevel(rule.level);
+      const patterns = this.normalizeFilterPatterns(rule.filter);
+      if (patterns.length === 0) {
+        throw new Error("codemation.config log rule filter must include at least one pattern");
+      }
+      const matchers = patterns.map((pattern) => this.compileGlobPattern(pattern));
+      compiled.push({
+        matchers,
+        minLevel,
+      });
+    }
+    this.codemationRules = compiled;
+  }
+
+  shouldEmit(level: Exclude<LogLevel, "silent">, namespace: string): boolean {
+    if (this.codemationRules && this.codemationRules.length > 0) {
+      for (const rule of this.codemationRules) {
+        if (rule.matchers.some((regex) => regex.test(namespace))) {
+          return this.levelPassesAgainstMin(level, rule.minLevel);
+        }
+      }
+    }
+    return this.levelPassesAgainstMin(level, this.minLevelCached());
+  }
+
+  private normalizeCodemationRules(config: CodemationLogConfig): ReadonlyArray<CodemationLogRule> {
+    if ("rules" in config && Array.isArray(config.rules)) {
+      return [...config.rules];
+    }
+    return [config as CodemationLogRule];
+  }
+
+  private normalizeFilterPatterns(filter: string | ReadonlyArray<string>): ReadonlyArray<string> {
+    if (typeof filter === "string") {
+      return [filter];
+    }
+    return [...filter];
+  }
+
+  /**
+   * Glob: only `*` is special (matches any substring). A lone `*` matches all namespaces.
+   */
+  private compileGlobPattern(pattern: string): RegExp {
+    const trimmed = pattern.trim();
+    if (trimmed === "*") {
+      return /^.*$/;
+    }
+    let body = "";
+    for (const ch of trimmed) {
+      if (ch === "*") {
+        body += ".*";
+        continue;
+      }
+      if (globRegexMetaChars.has(ch)) {
+        body += "\\" + ch;
+        continue;
+      }
+      body += ch;
+    }
+    return new RegExp("^" + body + "$");
+  }
+
+  private parseRuleLevel(level: string): LogLevel {
+    const normalized = level.toLowerCase();
+    if (
+      normalized === "silent" ||
+      normalized === "debug" ||
+      normalized === "info" ||
+      normalized === "warn" ||
+      normalized === "error"
+    ) {
+      return normalized;
+    }
+    throw new Error(`Invalid codemation.config log level: ${level}`);
+  }
+
+  private levelPassesAgainstMin(level: Exclude<LogLevel, "silent">, min: LogLevel): boolean {
+    if (min === "silent") {
+      return false;
+    }
+    return levelRank[level] >= levelRank[min];
+  }
+}

package/src/infrastructure/logging/LogLevelPolicyFactory.ts

@@ -0,0 +1,16 @@
+import { LogLevelPolicy } from "./LogLevelPolicy";
+
+/**
+ * Process-wide {@link LogLevelPolicy} singleton for server and browser loggers.
+ * Plain class (no `@injectable` from `@codemation/core`): client components import this file; decorating would pull core into the browser bundle.
+ */
+export class LogLevelPolicyFactory {
+  private readonly policy = new LogLevelPolicy();
+
+  create(): LogLevelPolicy {
+    return this.policy;
+  }
+}
+
+/** Shared factory for call sites outside the DI container (e.g. next-host bootstrap). */
+export const logLevelPolicyFactory = new LogLevelPolicyFactory();

package/src/infrastructure/logging/PerformanceLogPolicy.ts

@@ -0,0 +1,10 @@
+/**
+ * Opt-in detailed timing / diagnostics lines (used with `ServerLoggerFactory#createPerformanceDiagnostics`).
+ *
+ * Set `CODEMATION_PERFORMANCE_LOGGING=true` to enable. Otherwise those loggers are silent regardless of level.
+ */
+export class PerformanceLogPolicy {
+  shouldEmitDetailedTiming(): boolean {
+    return process.env.CODEMATION_PERFORMANCE_LOGGING === "true";
+  }
+}

package/src/infrastructure/logging/PerformanceLogPolicyFactory.ts

@@ -0,0 +1,14 @@
+import { PerformanceLogPolicy } from "./PerformanceLogPolicy";
+
+/**
+ * Process-wide {@link PerformanceLogPolicy} singleton (same pattern as {@link LogLevelPolicyFactory}).
+ */
+export class PerformanceLogPolicyFactory {
+  private readonly policy = new PerformanceLogPolicy();
+
+  create(): PerformanceLogPolicy {
+    return this.policy;
+  }
+}
+
+export const performanceLogPolicyFactory = new PerformanceLogPolicyFactory();

package/src/infrastructure/logging/ServerLogger.ts

@@ -0,0 +1 @@
+export { ConsoleLogger as ServerLogger } from "./ConsoleLogger";

package/src/infrastructure/logging/ServerLoggerFactory.ts

@@ -0,0 +1,28 @@
+import { inject, injectable } from "@codemation/core";
+
+import type { LogFilter } from "../../application/logging/LogFilter";
+import type { Logger, LoggerFactory } from "../../application/logging/Logger";
+
+import { FilteringLogger } from "./FilteringLogger";
+import { LogLevelPolicyFactory } from "./LogLevelPolicyFactory";
+import { performanceLogPolicyFactory } from "./PerformanceLogPolicyFactory";
+import { ServerLogger } from "./ServerLogger";
+
+@injectable()
+export class ServerLoggerFactory implements LoggerFactory {
+  constructor(@inject(LogLevelPolicyFactory) private readonly logLevelPolicyFactory: LogLevelPolicyFactory) {}
+
+  create(scope: string): Logger {
+    return new ServerLogger(scope, this.logLevelPolicyFactory.create());
+  }
+
+  createFiltered(scope: string, filter: LogFilter): Logger {
+    return new FilteringLogger(this.create(scope), scope, filter);
+  }
+
+  createPerformanceDiagnostics(scope: string): Logger {
+    return this.createFiltered(scope, (_entry) => performanceLogPolicyFactory.create().shouldEmitDetailedTiming());
+  }
+}
+
+export { ServerLogger } from "./ServerLogger";

package/src/infrastructure/persistence/CodemationPostgresPrismaClientFactory.ts

@@ -0,0 +1,9 @@
+import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "./generated/prisma-client/client.js";
+
+export class CodemationPostgresPrismaClientFactory {
+  static create(databaseUrl: string): PrismaClient {
+    const adapter = new PrismaPg({ connectionString: databaseUrl });
+    return new PrismaClient({ adapter });
+  }
+}

package/src/infrastructure/persistence/CredentialPersistenceStore.ts

@@ -0,0 +1,139 @@
+import { injectable } from "@codemation/core";
+
+import type {
+  CredentialInstanceRecord,
+  CredentialOAuth2MaterialMetadata,
+  CredentialOAuth2MaterialRecord,
+  CredentialOAuth2StateRecord,
+  CredentialSecretMaterialRecord,
+  CredentialStore,
+  CredentialTestRecord,
+} from "../../domain/credentials/CredentialServices";
+
+@injectable()
+export class InMemoryCredentialStore implements CredentialStore {
+  private readonly instancesById = new Map<string, CredentialInstanceRecord>();
+  private readonly secretsByInstanceId = new Map<string, CredentialSecretMaterialRecord>();
+  private readonly oauth2MaterialsByInstanceId = new Map<string, CredentialOAuth2MaterialRecord>();
+  private readonly oauth2StatesByState = new Map<string, CredentialOAuth2StateRecord>();
+  private readonly bindingsByKey = new Map<string, import("@codemation/core").CredentialBinding>();
+  private readonly testRecordsByInstanceId = new Map<string, CredentialTestRecord>();
+
+  async listInstances(): Promise<ReadonlyArray<CredentialInstanceRecord>> {
+    return [...this.instancesById.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+  }
+
+  async getInstance(instanceId: string): Promise<CredentialInstanceRecord | undefined> {
+    return this.instancesById.get(instanceId);
+  }
+
+  async saveInstance(
+    args: Readonly<{ instance: CredentialInstanceRecord; secretMaterial?: CredentialSecretMaterialRecord }>,
+  ): Promise<void> {
+    this.instancesById.set(args.instance.instanceId, args.instance);
+    if (args.secretMaterial) {
+      this.secretsByInstanceId.set(args.instance.instanceId, args.secretMaterial);
+    }
+  }
+
+  async deleteInstance(instanceId: string): Promise<void> {
+    this.instancesById.delete(instanceId);
+    this.secretsByInstanceId.delete(instanceId);
+    this.oauth2MaterialsByInstanceId.delete(instanceId);
+    this.testRecordsByInstanceId.delete(instanceId);
+    for (const [state, record] of this.oauth2StatesByState.entries()) {
+      if (record.instanceId === instanceId) {
+        this.oauth2StatesByState.delete(state);
+      }
+    }
+    for (const [key, binding] of this.bindingsByKey.entries()) {
+      if (binding.instanceId === instanceId) {
+        this.bindingsByKey.delete(key);
+      }
+    }
+  }
+
+  async getSecretMaterial(instanceId: string): Promise<CredentialSecretMaterialRecord | undefined> {
+    return this.secretsByInstanceId.get(instanceId);
+  }
+
+  async createOAuth2State(record: CredentialOAuth2StateRecord): Promise<void> {
+    this.oauth2StatesByState.set(record.state, record);
+  }
+
+  async consumeOAuth2State(state: string): Promise<CredentialOAuth2StateRecord | undefined> {
+    const record = this.oauth2StatesByState.get(state);
+    if (!record) {
+      return undefined;
+    }
+    this.oauth2StatesByState.delete(state);
+    return record;
+  }
+
+  async getOAuth2Material(instanceId: string): Promise<CredentialOAuth2MaterialRecord | undefined> {
+    return this.oauth2MaterialsByInstanceId.get(instanceId);
+  }
+
+  async saveOAuth2Material(
+    args: Readonly<{
+      instanceId: string;
+      encryptedJson: string;
+      encryptionKeyId: string;
+      schemaVersion: number;
+      metadata: CredentialOAuth2MaterialMetadata;
+    }>,
+  ): Promise<void> {
+    this.oauth2MaterialsByInstanceId.set(args.instanceId, {
+      instanceId: args.instanceId,
+      encryptedJson: args.encryptedJson,
+      encryptionKeyId: args.encryptionKeyId,
+      schemaVersion: args.schemaVersion,
+      providerId: args.metadata.providerId,
+      connectedEmail: args.metadata.connectedEmail,
+      connectedAt: args.metadata.connectedAt,
+      scopes: args.metadata.scopes,
+      updatedAt: args.metadata.updatedAt,
+    });
+  }
+
+  async deleteOAuth2Material(instanceId: string): Promise<void> {
+    this.oauth2MaterialsByInstanceId.delete(instanceId);
+  }
+
+  async upsertBinding(binding: import("@codemation/core").CredentialBinding): Promise<void> {
+    this.bindingsByKey.set(this.toBindingKey(binding.key), binding);
+  }
+
+  async getBinding(
+    key: import("@codemation/core").CredentialBindingKey,
+  ): Promise<import("@codemation/core").CredentialBinding | undefined> {
+    return this.bindingsByKey.get(this.toBindingKey(key));
+  }
+
+  async listBindingsByWorkflowId(
+    workflowId: string,
+  ): Promise<ReadonlyArray<import("@codemation/core").CredentialBinding>> {
+    return [...this.bindingsByKey.values()].filter((binding) => binding.key.workflowId === workflowId);
+  }
+
+  async saveTestResult(record: CredentialTestRecord): Promise<void> {
+    this.testRecordsByInstanceId.set(record.instanceId, record);
+  }
+
+  async getLatestTestResult(instanceId: string): Promise<CredentialTestRecord | undefined> {
+    return this.testRecordsByInstanceId.get(instanceId);
+  }
+
+  async getLatestTestResults(instanceIds: ReadonlyArray<string>): Promise<ReadonlyMap<string, CredentialTestRecord>> {
+    const entries = instanceIds
+      .map((instanceId) => [instanceId, this.testRecordsByInstanceId.get(instanceId)] as const)
+      .filter((entry): entry is readonly [string, CredentialTestRecord] => entry[1] !== undefined);
+    return new Map(entries);
+  }
+
+  private toBindingKey(key: import("@codemation/core").CredentialBindingKey): string {
+    return `${key.workflowId}:${key.nodeId}:${key.slotKey}`;
+  }
+}
+
+export { PrismaCredentialStore } from "./PrismaCredentialStore";