import { createRequire } from "node:module";import path from "node:path";import * as Effect from "effect/Effect";import * as Exit from "effect/Exit";import * as Layer from "effect/Layer";import * as Scope from "effect/Scope";import * as ServiceMap from "effect/ServiceMap";import * as SqlClient from "effect/unstable/sql/SqlClient"; export interface SqliteStatement {  run: (...params: unknown[]) => unknown;  get: (...params: unknown[]) => unknown;  all: (...params: unknown[]) => unknown[];} export interface SqliteDatabase {  exec: (sql: string) => void;  prepare: (sql: string) => SqliteStatement;  close: () => void;} export interface EffectSqliteDatabaseAdapter extends SqliteDatabase {  runWithSqlClient: <A, E>(effect: Effect.Effect<A, E, SqlClient.SqlClient>) => A;} interface SqliteDriverModule {  SqliteClient?: {    layer: (config: { filename: string }) => Layer.Layer<SqlClient.SqlClient>;  };} function isNodeSqliteUnavailableError(error: unknown): boolean {  if (!(error instanceof Error)) {    return false;  }  const code = (error as NodeJS.ErrnoException).code;  if (code === "ERR_UNKNOWN_BUILTIN_MODULE" || code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {    return true;  }  return (    error.message.includes("node:sqlite") ||    error.message.includes("@effect/sql-sqlite-node") ||    error.message.includes("Only URLs with a scheme in: file, data, and node")  );} function normalizeStatementBatch(sql: string): string[] {  const normalized = sql.replace(/\r\n/g, "\n");  const statements: string[] = [];  let current = "";  let inSingleQuote = false;  let inDoubleQuote = false;  let inBacktick = false;   for (const char of normalized) {    if (char === "'" && !inDoubleQuote && !inBacktick) {      inSingleQuote = !inSingleQuote;      current += char;      continue;    }    if (char === '"' && !inSingleQuote && !inBacktick) {      inDoubleQuote = !inDoubleQuote;      current += char;      continue;    }    if (char === "`" && !inSingleQuote && !inDoubleQuote) {      inBacktick = !inBacktick;      current += char;      continue;    }     if (char === ";" && !inSingleQuote && !inDoubleQuote && !inBacktick) {      const statement = current.trim();      if (statement.length > 0) {        statements.push(statement);      }      current = "";      continue;    }     current += char;  }   const trailing = current.trim();  if (trailing.length > 0) {    statements.push(trailing);  }   return statements;} function toSafeInteger(value: unknown, fallback = 0): number {  if (typeof value === "number" && Number.isFinite(value)) {    return Math.trunc(value);  }  if (typeof value === "bigint") {    return Number(value);  }  return fallback;} class EffectSqliteDatabase implements SqliteDatabase {  private readonly scope: Scope.Closeable;  private readonly services: ServiceMap.ServiceMap<SqlClient.SqlClient>;  private readonly sql: SqlClient.SqlClient;  private closed = false;   constructor(layer: Layer.Layer<SqlClient.SqlClient>) {    this.scope = Effect.runSync(Scope.make());    try {      this.services = Effect.runSync(Layer.buildWithScope(layer, this.scope));      this.sql = Effect.runSync(        Effect.provideServices(Effect.service(SqlClient.SqlClient), this.services),      );    } catch (error) {      try {        Effect.runSync(Scope.close(this.scope, Exit.void));      } catch {        // Best effort cleanup on failed adapter construction.      }      throw error;    }  }   exec(sql: string): void {    for (const statement of normalizeStatementBatch(sql)) {      this.runEffect(this.sql.unsafe(statement).raw);    }  }   prepare(sql: string): SqliteStatement {    return {      run: (...params: unknown[]) => this.runStatement(sql, params),      get: (...params: unknown[]) => {        const rows = this.queryStatement(sql, params);        return rows[0];      },      all: (...params: unknown[]) => this.queryStatement(sql, params),    };  }   close(): void {    if (this.closed) {      return;    }    this.closed = true;    Effect.runSync(Scope.close(this.scope, Exit.void));  }   runWithSqlClient<A, E>(effect: Effect.Effect<A, E, SqlClient.SqlClient>): A {    return this.runEffect(effect);  }   private runStatement(sql: string, params: ReadonlyArray<unknown>): unknown {    this.runEffect(this.sql.unsafe(sql, params).raw);    const stats = this.runEffect(      this.sql        .unsafe<{ changes?: number | bigint; lastInsertRowid?: number | bigint }>(          "SELECT changes() AS changes, last_insert_rowid() AS lastInsertRowid;",        )        .unprepared,    )[0];    return {      changes: toSafeInteger(stats?.changes, 0),      lastInsertRowid: toSafeInteger(stats?.lastInsertRowid, 0),    };  }   private queryStatement(sql: string, params: ReadonlyArray<unknown>): unknown[] {    return this.runEffect(this.sql.unsafe(sql, params).unprepared) as unknown[];  }   private runEffect<A, E, R>(effect: Effect.Effect<A, E, R>): A {    const provided = Effect.provideServices(effect, this.services) as Effect.Effect<A, E, never>;    return Effect.runSync(provided);  }} function openDriverDatabase(  requireFn: ReturnType<typeof createRequire>,  moduleId: string,  dbPath: string,): SqliteDatabase {  const sqliteDriver = requireFn(moduleId) as SqliteDriverModule;  const layer = sqliteDriver.SqliteClient?.layer;  if (typeof layer !== "function") {    throw new Error(`${moduleId} was loaded but SqliteClient.layer is missing.`);  }  return new EffectSqliteDatabase(layer({ filename: dbPath })) satisfies EffectSqliteDatabaseAdapter;} function openNodeSqliteDatabase(  requireFn: ReturnType<typeof createRequire>,  dbPath: string,): SqliteDatabase {  try {    return openDriverDatabase(requireFn, "@effect/sql-sqlite-node", dbPath);  } catch (error) {    if (isNodeSqliteUnavailableError(error)) {      throw new Error(        "@effect/sql-sqlite-node is unavailable in this runtime. Ensure dependencies are installed and use Node.js 22+ (or run the server with Bun).",        { cause: error },      );    }    throw error;  }} function openBunSqliteDatabase(  requireFn: ReturnType<typeof createRequire>,  dbPath: string,): SqliteDatabase {  return openDriverDatabase(requireFn, "@effect/sql-sqlite-bun", dbPath);} export function openSqliteDatabase(  dbPath: string,  requireFn: ReturnType<typeof createRequire> = createRequire(    path.join(process.cwd(), "t3code-sqlite-adapter.cjs"),  ),  runtimeIsBun = Boolean(process.versions.bun),): SqliteDatabase {  if (runtimeIsBun) {    // Development mode runs in Bun, so use Bun's SQLite adapter    return openBunSqliteDatabase(requireFn, dbPath);  }   return openNodeSqliteDatabase(requireFn, dbPath);}