@infinityi/engine-lib 1.3.1 → 1.4.0

package/dist/session-stores/index.js

@@ -0,0 +1,1382 @@
+import"../index-37x76zdn.js";
+
+// src/session-stores/codec.ts
+function decodeObject(payload) {
+  return JSON.parse(payload);
+}
+var jsonSessionStoreCodec = {
+  encodeMessage(message) {
+    return JSON.stringify(message);
+  },
+  decodeMessage(payload) {
+    return decodeObject(payload);
+  },
+  encodeMetadata(metadata) {
+    return metadata === undefined ? undefined : JSON.stringify(metadata);
+  },
+  decodeMetadata(payload) {
+    return payload === undefined ? undefined : decodeObject(payload);
+  }
+};
+async function encodeMetadata(codec, metadata) {
+  if (codec.encodeMetadata !== undefined)
+    return codec.encodeMetadata(metadata);
+  return jsonSessionStoreCodec.encodeMetadata(metadata);
+}
+async function decodeMetadata(codec, payload) {
+  const value = payload ?? undefined;
+  if (codec.decodeMetadata !== undefined)
+    return codec.decodeMetadata(value);
+  return jsonSessionStoreCodec.decodeMetadata(value);
+}
+async function encodeMessages(codec, messages) {
+  const encoded = [];
+  for (const message of messages)
+    encoded.push(await codec.encodeMessage(message));
+  return encoded;
+}
+async function decodeMessages(codec, payloads) {
+  const messages = [];
+  for (const payload of payloads)
+    messages.push(await codec.decodeMessage(payload));
+  return messages;
+}
+// node_modules/@infinityi/forge/dist/index-zxk5c56c.js
+class DataError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "DataError";
+  }
+}
+
+class QueryError extends DataError {
+  sql;
+  params;
+  dialect;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "QueryError";
+    this.sql = options.sql;
+    this.params = options.params;
+    this.dialect = options.dialect;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      dialect: this.dialect,
+      sql: this.sql,
+      params: "[REDACTED]"
+    };
+  }
+}
+class TransactionError extends DataError {
+  state;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TransactionError";
+    if (options?.state !== undefined)
+      this.state = options.state;
+  }
+}
+class TenantError extends DataError {
+  tenantId;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TenantError";
+    if (options?.tenantId !== undefined)
+      this.tenantId = options.tenantId;
+  }
+}
+
+// node_modules/@infinityi/forge/dist/data/index.js
+function createDataInstrumentation(options) {
+  const histogram = options.telemetry?.meter?.createHistogram("forge_db_query_duration_seconds", {
+    description: "Database query execution time.",
+    unit: "s"
+  });
+  return {
+    startQuerySpan(query) {
+      return options.telemetry?.tracer?.startSpan("db.query", {
+        kind: "client",
+        attributes: queryAttributes(options, query)
+      });
+    },
+    recordQuerySuccess(query, result, startedAt, span) {
+      const durationSeconds = (performance.now() - startedAt) / 1000;
+      histogram?.record(durationSeconds, {
+        "db.system": options.dialect,
+        "db.operation": query.kind
+      });
+      span?.setAttributes?.({
+        "db.rows_affected": Number(result.numAffectedRows),
+        "db.duration_ms": durationSeconds * 1000
+      });
+      span?.setStatus?.({ code: "ok" });
+      span?.end?.();
+    },
+    recordQueryFailure(query, cause, startedAt, span) {
+      const durationSeconds = (performance.now() - startedAt) / 1000;
+      histogram?.record(durationSeconds, {
+        "db.system": options.dialect,
+        "db.operation": query.kind
+      });
+      span?.setAttributes?.({ "db.duration_ms": durationSeconds * 1000 });
+      span?.setStatus?.({
+        code: "error",
+        message: cause instanceof Error ? cause.message : String(cause)
+      });
+      span?.addEvent?.("exception", {
+        "exception.message": cause instanceof Error ? cause.message : String(cause),
+        "exception.type": cause instanceof Error ? cause.name : typeof cause
+      });
+      span?.end?.();
+    }
+  };
+}
+function queryAttributes(options, query) {
+  const attributes = {
+    "db.system": options.dialect,
+    "db.operation": query.kind,
+    "db.statement": query.sql
+  };
+  if (options.telemetry?.includeParams === true) {
+    attributes["db.params"] = JSON.stringify(query.params);
+  }
+  return attributes;
+}
+function compileNode(dialect, node) {
+  switch (node.kind) {
+    case "select":
+      return compileSelect(dialect, node);
+    case "insert":
+      return compileInsert(dialect, node);
+    case "update":
+      return compileUpdate(dialect, node);
+    case "delete":
+      return compileDelete(dialect, node);
+  }
+}
+function compileRaw(dialect, query) {
+  return {
+    sql: rewriteParameterPlaceholders(dialect, query.text, query.params.length),
+    params: query.params,
+    kind: "raw",
+    returning: /\breturning\b/i.test(query.text)
+  };
+}
+function compileSelect(dialect, node) {
+  const params = [];
+  const columns = compileColumns(dialect, node.columns);
+  const parts = [`select ${columns} from ${dialect.quoteIdentifier(node.table)}`];
+  appendWhere(dialect, parts, params, node.where);
+  if (node.orderBy.length > 0) {
+    const orderBy = node.orderBy.map((item) => `${dialect.quoteIdentifier(item.column)} ${item.direction}`).join(", ");
+    parts.push(`order by ${orderBy}`);
+  }
+  if (node.limit !== undefined) {
+    params.push(node.limit);
+    parts.push(`limit ${dialect.placeholder(params.length)}`);
+  }
+  return { sql: parts.join(" "), params, kind: "select", returning: false };
+}
+function compileInsert(dialect, node) {
+  if (node.values.length === 0) {
+    throw new Error("insert requires at least one value row");
+  }
+  const params = [];
+  const columns = Object.keys(node.values[0] ?? {});
+  if (columns.length === 0) {
+    throw new Error("insert value row must contain at least one column");
+  }
+  const columnSql = columns.map((column) => dialect.quoteIdentifier(column)).join(", ");
+  const valuesSql = node.values.map((row) => {
+    const placeholders = columns.map((column) => {
+      params.push(row[column]);
+      return dialect.placeholder(params.length);
+    });
+    return `(${placeholders.join(", ")})`;
+  }).join(", ");
+  const parts = [
+    `insert into ${dialect.quoteIdentifier(node.table)} (${columnSql}) values ${valuesSql}`
+  ];
+  appendReturning(dialect, parts, node.returning);
+  return { sql: parts.join(" "), params, kind: "insert", returning: node.returning !== undefined };
+}
+function compileUpdate(dialect, node) {
+  const params = [];
+  const columns = Object.keys(node.set);
+  if (columns.length === 0) {
+    throw new Error("update requires at least one set value");
+  }
+  const assignments = columns.map((column) => {
+    params.push(node.set[column]);
+    return `${dialect.quoteIdentifier(column)} = ${dialect.placeholder(params.length)}`;
+  });
+  const parts = [
+    `update ${dialect.quoteIdentifier(node.table)} set ${assignments.join(", ")}`
+  ];
+  appendWhere(dialect, parts, params, node.where);
+  appendReturning(dialect, parts, node.returning);
+  return { sql: parts.join(" "), params, kind: "update", returning: node.returning !== undefined };
+}
+function compileDelete(dialect, node) {
+  const params = [];
+  const parts = [`delete from ${dialect.quoteIdentifier(node.table)}`];
+  appendWhere(dialect, parts, params, node.where);
+  appendReturning(dialect, parts, node.returning);
+  return { sql: parts.join(" "), params, kind: "delete", returning: node.returning !== undefined };
+}
+function appendWhere(dialect, parts, params, predicates) {
+  if (predicates.length === 0)
+    return;
+  const sql = predicates.map((predicate) => {
+    params.push(predicate.value);
+    return `${dialect.quoteIdentifier(predicate.column)} ${predicate.operator} ${dialect.placeholder(params.length)}`;
+  });
+  parts.push(`where ${sql.join(" and ")}`);
+}
+function appendReturning(dialect, parts, returning) {
+  if (returning === undefined)
+    return;
+  parts.push(`returning ${compileColumns(dialect, returning)}`);
+}
+function compileColumns(dialect, columns) {
+  if (columns === "*")
+    return "*";
+  if (columns.length === 0)
+    return "*";
+  return columns.map((column) => dialect.quoteIdentifier(column)).join(", ");
+}
+function rewriteParameterPlaceholders(dialect, text, paramCount) {
+  if (paramCount === 0)
+    return text;
+  let next = 0;
+  return text.replaceAll("?", () => {
+    next += 1;
+    return next <= paramCount ? dialect.placeholder(next) : "?";
+  });
+}
+
+class ExecutableQuery {
+  db;
+  compileFn;
+  constructor(db, compileFn) {
+    this.db = db;
+    this.compileFn = compileFn;
+  }
+  compile() {
+    try {
+      return this.compileFn();
+    } catch (cause) {
+      if (cause instanceof DataError)
+        throw cause;
+      throw new DataError("Failed to compile query", { cause });
+    }
+  }
+  execute() {
+    return this.db.execute(this.compile());
+  }
+  async executeTakeFirst() {
+    const result = await this.execute();
+    return result.rows[0];
+  }
+  async executeTakeFirstOrThrow() {
+    const row = await this.executeTakeFirst();
+    if (row === undefined) {
+      throw new DataError("Expected query to return at least one row");
+    }
+    return row;
+  }
+}
+
+class DeleteBuilder extends ExecutableQuery {
+  dialect;
+  node;
+  constructor(db, dialect, node) {
+    super(db, () => compileNode(dialect, node));
+    this.dialect = dialect;
+    this.node = node;
+  }
+  where(column, operator, value) {
+    return new DeleteBuilder(this.db, this.dialect, {
+      ...this.node,
+      where: [...this.node.where, { column, operator, value }]
+    });
+  }
+  returning(columns) {
+    return new ExecutableQuery(this.db, () => compileNode(this.dialect, { ...this.node, returning: columns }));
+  }
+  returningAll() {
+    return new ExecutableQuery(this.db, () => compileNode(this.dialect, { ...this.node, returning: "*" }));
+  }
+}
+function createDeleteBuilder(db, dialect, table, tenant) {
+  return new DeleteBuilder(db, dialect, {
+    kind: "delete",
+    table,
+    where: tenant === undefined ? [] : [{ column: tenant.column, operator: "=", value: tenant.id }]
+  });
+}
+
+class InsertBuilder extends ExecutableQuery {
+  dialect;
+  node;
+  tenant;
+  constructor(db, dialect, node, tenant) {
+    super(db, () => compileNode(dialect, node));
+    this.dialect = dialect;
+    this.node = node;
+    this.tenant = tenant;
+  }
+  values(value) {
+    const rows = (Array.isArray(value) ? value : [value]).map((row) => applyTenantValue(row, this.tenant));
+    return new InsertBuilder(this.db, this.dialect, {
+      ...this.node,
+      values: rows
+    }, this.tenant);
+  }
+  returning(columns) {
+    return new ExecutableQuery(this.db, () => compileNode(this.dialect, { ...this.node, returning: columns }));
+  }
+  returningAll() {
+    return new ExecutableQuery(this.db, () => compileNode(this.dialect, { ...this.node, returning: "*" }));
+  }
+}
+function createInsertBuilder(db, dialect, table, tenant) {
+  return new InsertBuilder(db, dialect, {
+    kind: "insert",
+    table,
+    values: []
+  }, tenant);
+}
+function applyTenantValue(row, tenant) {
+  if (tenant === undefined)
+    return row;
+  const current = row[tenant.column];
+  if (current !== undefined && current !== tenant.id) {
+    throw new TenantError("Insert row tenant does not match scoped tenant", {
+      tenantId: tenant.id
+    });
+  }
+  return { ...row, [tenant.column]: tenant.id };
+}
+
+class SelectBuilder extends ExecutableQuery {
+  dialect;
+  node;
+  constructor(db, dialect, node) {
+    super(db, () => compileNode(dialect, node));
+    this.dialect = dialect;
+    this.node = node;
+  }
+  select(columns) {
+    return new SelectBuilder(this.db, this.dialect, { ...this.node, columns });
+  }
+  where(column, operator, value) {
+    return new SelectBuilder(this.db, this.dialect, {
+      ...this.node,
+      where: [...this.node.where, { column, operator, value }]
+    });
+  }
+  orderBy(column, direction = "asc") {
+    return new SelectBuilder(this.db, this.dialect, {
+      ...this.node,
+      orderBy: [...this.node.orderBy, { column, direction }]
+    });
+  }
+  limit(count) {
+    return new SelectBuilder(this.db, this.dialect, {
+      ...this.node,
+      limit: count
+    });
+  }
+}
+function createSelectBuilder(db, dialect, table, tenant) {
+  const node = {
+    kind: "select",
+    table,
+    columns: "*",
+    where: tenant === undefined ? [] : [{ column: tenant.column, operator: "=", value: tenant.id }],
+    orderBy: []
+  };
+  return new SelectBuilder(db, dialect, node);
+}
+
+class UpdateBuilder extends ExecutableQuery {
+  dialect;
+  node;
+  tenant;
+  constructor(db, dialect, node, tenant) {
+    super(db, () => compileNode(dialect, node));
+    this.dialect = dialect;
+    this.node = node;
+    this.tenant = tenant;
+  }
+  set(value) {
+    const set = validateTenantSet(value, this.tenant);
+    return new UpdateBuilder(this.db, this.dialect, {
+      ...this.node,
+      set: { ...this.node.set, ...set }
+    }, this.tenant);
+  }
+  where(column, operator, value) {
+    return new UpdateBuilder(this.db, this.dialect, {
+      ...this.node,
+      where: [...this.node.where, { column, operator, value }]
+    }, this.tenant);
+  }
+  returning(columns) {
+    return new ExecutableQuery(this.db, () => compileNode(this.dialect, { ...this.node, returning: columns }));
+  }
+  returningAll() {
+    return new ExecutableQuery(this.db, () => compileNode(this.dialect, { ...this.node, returning: "*" }));
+  }
+}
+function createUpdateBuilder(db, dialect, table, tenant) {
+  return new UpdateBuilder(db, dialect, {
+    kind: "update",
+    table,
+    set: {},
+    where: tenant === undefined ? [] : [{ column: tenant.column, operator: "=", value: tenant.id }]
+  }, tenant);
+}
+function validateTenantSet(value, tenant) {
+  if (tenant === undefined)
+    return value;
+  const current = value[tenant.column];
+  if (current !== undefined && current !== tenant.id) {
+    throw new TenantError("Update tenant value does not match scoped tenant", {
+      tenantId: tenant.id
+    });
+  }
+  return value;
+}
+function sql(strings, ...values) {
+  let text = "";
+  const params = [];
+  for (let index = 0;index < strings.length; index += 1) {
+    text += strings[index] ?? "";
+    if (index >= values.length)
+      continue;
+    const value = values[index];
+    if (isSqlFragment(value)) {
+      text += value.text;
+      params.push(...value.params);
+    } else {
+      text += "?";
+      params.push(value);
+    }
+  }
+  return Object.freeze({ text, params });
+}
+function raw(text) {
+  return Object.freeze({ text, params: [] });
+}
+function isSqlFragment(value) {
+  return typeof value === "object" && value !== null && typeof value.text === "string" && Array.isArray(value.params);
+}
+function createDb(options) {
+  const instrumentation = createDataInstrumentation({
+    dialect: options.dialect.name,
+    telemetry: options.telemetry
+  });
+  const executeQuery = async (query) => {
+    const span = instrumentation.startQuerySpan(query);
+    const startedAt = performance.now();
+    try {
+      const result = await options.driver.execute(query);
+      const normalized = normalizeResult(query, result);
+      instrumentation.recordQuerySuccess(query, normalized, startedAt, span);
+      return normalized;
+    } catch (cause) {
+      instrumentation.recordQueryFailure(query, cause, startedAt, span);
+      if (cause instanceof QueryError)
+        throw cause;
+      throw new QueryError("Data query failed", {
+        cause,
+        sql: query.sql,
+        params: query.params,
+        dialect: options.dialect.name
+      });
+    }
+  };
+  const createHandle = (tenant, transaction) => {
+    const handle = {
+      dialect: options.dialect,
+      selectFrom(table) {
+        return createSelectBuilder(handleAny, options.dialect, table, tenant);
+      },
+      insertInto(table) {
+        return createInsertBuilder(handleAny, options.dialect, table, tenant);
+      },
+      updateTable(table) {
+        return createUpdateBuilder(handleAny, options.dialect, table, tenant);
+      },
+      deleteFrom(table) {
+        return createDeleteBuilder(handleAny, options.dialect, table, tenant);
+      },
+      raw(query) {
+        if (tenant !== undefined && !tenant.allowRaw) {
+          throw new TenantError("Raw SQL is disabled on tenant-scoped database handles", {
+            tenantId: tenant.id
+          });
+        }
+        return new ExecutableQuery(handleAny, () => compileRaw(options.dialect, query));
+      },
+      async execute(query) {
+        return executeQuery(query);
+      },
+      async uow(fn, uowOptions = {}) {
+        return runUow(fn, uowOptions, transaction, tenant);
+      },
+      withTenant(tenantId, tenantOptions = {}) {
+        return createHandle({
+          id: tenantId,
+          column: tenantOptions.column ?? tenant?.column ?? "tenant_id",
+          allowRaw: tenantOptions.allowRaw ?? tenant?.allowRaw ?? false
+        }, transaction);
+      },
+      async ping() {
+        if (options.driver.ping !== undefined) {
+          await options.driver.ping();
+          return;
+        }
+        await handle.execute({ sql: "select 1", params: [], kind: "raw", returning: false });
+      },
+      async shutdown() {
+        await options.driver.shutdown?.();
+      }
+    };
+    const handleAny = handle;
+    if (transaction !== undefined) {
+      Object.defineProperty(handle, "outbox", {
+        enumerable: true,
+        value: {
+          publish(type, payload, outboxOptions = {}) {
+            return publishOutbox(handle, options, {
+              type,
+              payload,
+              metadata: outboxOptions.metadata ?? {},
+              occurredAt: outboxOptions.occurredAt ?? new Date
+            });
+          }
+        }
+      });
+    }
+    return Object.freeze(handle);
+  };
+  const runUow = async (fn, uowOptions, existingTransaction, tenant) => {
+    if (existingTransaction !== undefined) {
+      return runNestedUow(fn, uowOptions, existingTransaction, tenant);
+    }
+    const attempts = Math.max(0, uowOptions.retries ?? 0) + 1;
+    for (let attempt = 1;attempt <= attempts; attempt += 1) {
+      const transaction = { savepoint: 0 };
+      await executeControl(beginSql(uowOptions));
+      const tx = createHandle(tenant, transaction);
+      try {
+        const result = await fn(tx);
+        await executeControl("commit");
+        return result;
+      } catch (cause) {
+        await rollbackQuietly();
+        if (attempt < attempts && await shouldRetry(cause, attempt, uowOptions)) {
+          continue;
+        }
+        throw cause;
+      }
+    }
+    throw new TransactionError("Transaction retry attempts were exhausted");
+  };
+  const runNestedUow = async (fn, uowOptions, transaction, tenant) => {
+    const attempts = Math.max(0, uowOptions.retries ?? 0) + 1;
+    for (let attempt = 1;attempt <= attempts; attempt += 1) {
+      const savepoint = `forge_sp_${++transaction.savepoint}`;
+      await executeControl(`savepoint ${savepoint}`);
+      const tx = createHandle(tenant, transaction);
+      try {
+        const result = await fn(tx);
+        await executeControl(`release savepoint ${savepoint}`);
+        return result;
+      } catch (cause) {
+        await rollbackToSavepointQuietly(savepoint);
+        if (attempt < attempts && await shouldRetry(cause, attempt, uowOptions)) {
+          continue;
+        }
+        throw cause;
+      }
+    }
+    throw new TransactionError("Nested transaction retry attempts were exhausted");
+  };
+  const executeControl = (statement) => executeQuery({ sql: statement, params: [], kind: "raw", returning: false });
+  const rollbackQuietly = async () => {
+    try {
+      await executeControl("rollback");
+    } catch {}
+  };
+  const rollbackToSavepointQuietly = async (savepoint) => {
+    try {
+      await executeControl(`rollback to savepoint ${savepoint}`);
+    } catch {}
+  };
+  return createHandle();
+}
+var VALID_ISOLATION_LEVELS = new Set([
+  "read committed",
+  "repeatable read",
+  "serializable"
+]);
+function beginSql(options) {
+  if (options.isolationLevel === undefined)
+    return "begin";
+  if (!VALID_ISOLATION_LEVELS.has(options.isolationLevel)) {
+    throw new TransactionError(`Invalid isolation level: "${options.isolationLevel}"`);
+  }
+  return `begin isolation level ${options.isolationLevel}`;
+}
+async function shouldRetry(cause, attempt, options) {
+  if (options.shouldRetry === undefined)
+    return false;
+  return options.shouldRetry(cause, attempt);
+}
+var VALID_TABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+async function publishOutbox(tx, options, message) {
+  const normalized = {
+    type: message.type,
+    payload: message.payload,
+    metadata: message.metadata,
+    occurredAt: message.occurredAt
+  };
+  if (options.outbox?.publisher !== undefined) {
+    await options.outbox.publisher.publish(normalized, tx);
+    return;
+  }
+  const table = options.outbox?.table ?? "_forge_outbox";
+  if (!VALID_TABLE_NAME_RE.test(table)) {
+    throw new QueryError(`Invalid outbox table name: "${table}"`, {
+      sql: "",
+      params: [],
+      dialect: options.dialect.name
+    });
+  }
+  const quote = (identifier) => raw(options.dialect.quoteIdentifier(identifier));
+  await tx.execute(compileRaw(options.dialect, sql`
+    insert into ${quote(table)}
+      (${quote("type")}, ${quote("payload")}, ${quote("metadata")}, ${quote("occurred_at")})
+    values (
+      ${message.type},
+      ${JSON.stringify(message.payload)},
+      ${JSON.stringify(message.metadata)},
+      ${message.occurredAt.toISOString()}
+    )
+  `));
+}
+function normalizeResult(query, result) {
+  if (result.rows.length > 0)
+    return result;
+  if (query.returning)
+    return result;
+  if (query.kind === "update") {
+    return {
+      rows: [{ numUpdatedRows: result.numAffectedRows }],
+      numAffectedRows: result.numAffectedRows
+    };
+  }
+  if (query.kind === "delete") {
+    return {
+      rows: [{ numDeletedRows: result.numAffectedRows }],
+      numAffectedRows: result.numAffectedRows
+    };
+  }
+  return result;
+}
+
+// node_modules/@infinityi/forge/dist/data/dialects/postgres/index.js
+function createPostgresDialect() {
+  return {
+    name: "postgresql",
+    placeholder(index) {
+      return `$${index}`;
+    },
+    quoteIdentifier(identifier) {
+      return `"${identifier.replaceAll('"', '""')}"`;
+    }
+  };
+}
+function createPostgresDriver(options) {
+  return {
+    name: "postgresql",
+    async execute(query) {
+      try {
+        const result = await options.client.query(query.sql, query.params);
+        return {
+          rows: result.rows ?? [],
+          numAffectedRows: BigInt(result.rowCount ?? result.rows?.length ?? 0)
+        };
+      } catch (cause) {
+        throw new QueryError("PostgreSQL query failed", {
+          cause,
+          sql: query.sql,
+          params: query.params,
+          dialect: "postgresql"
+        });
+      }
+    },
+    async ping() {
+      await options.client.query("select 1", []);
+    },
+    async shutdown() {
+      if (options.closeOnShutdown === false)
+        return;
+      await options.client.end?.();
+    }
+  };
+}
+
+// node_modules/@infinityi/forge/dist/data/dialects/sqlite/index.js
+import { Database } from "bun:sqlite";
+function createSqliteDialect() {
+  return {
+    name: "sqlite",
+    placeholder() {
+      return "?";
+    },
+    quoteIdentifier(identifier) {
+      return `"${identifier.replaceAll('"', '""')}"`;
+    }
+  };
+}
+function createSqliteDriver(options = {}) {
+  const database = options.database ?? new Database(options.filename ?? ":memory:", {
+    create: options.create ?? true
+  });
+  return {
+    name: "sqlite",
+    execute(query) {
+      try {
+        const statement = database.query(query.sql);
+        if (query.kind === "select" || rawReturnsRows(query.sql)) {
+          const rows = statement.all(...toSqliteBindings(query.params));
+          return { rows, numAffectedRows: 0n };
+        }
+        if (returnsRows(query.sql)) {
+          const rows = statement.all(...toSqliteBindings(query.params));
+          return { rows, numAffectedRows: BigInt(rows.length) };
+        }
+        const result = statement.run(...toSqliteBindings(query.params));
+        return { rows: [], numAffectedRows: BigInt(result.changes ?? 0) };
+      } catch (cause) {
+        throw new QueryError("SQLite query failed", {
+          cause,
+          sql: query.sql,
+          params: query.params,
+          dialect: "sqlite"
+        });
+      }
+    },
+    shutdown() {
+      database.close();
+    }
+  };
+}
+function toSqliteBindings(params) {
+  return [...params];
+}
+function returnsRows(sql2) {
+  return /\breturning\b/i.test(sql2);
+}
+function rawReturnsRows(sql2) {
+  return /^\s*(select|with|pragma)\b/i.test(sql2);
+}
+
+// src/session-stores/ids.ts
+import { createHash } from "node:crypto";
+var VALID_TABLE_PREFIX_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertTablePrefix(prefix) {
+  if (!VALID_TABLE_PREFIX_RE.test(prefix)) {
+    throw new Error(`Invalid session store table prefix: ${JSON.stringify(prefix)}`);
+  }
+  return prefix;
+}
+function safeSessionKey(id) {
+  return Buffer.from(id, "utf8").toString("base64url");
+}
+function sessionFileName(id) {
+  return `${createHash("sha256").update(id).digest("hex")}.jsonl`;
+}
+
+// src/session-stores/versioning.ts
+var SESSION_STORE_SCHEMA_VERSION = 1;
+function isVersionedSessionStore(store) {
+  return typeof store.migrate === "function";
+}
+function isCloseableSessionStore(store) {
+  return typeof store.close === "function";
+}
+async function migrateSessionStore(store) {
+  if (isVersionedSessionStore(store))
+    await store.migrate();
+}
+
+// src/session-stores/forge-data.ts
+var DEFAULT_TABLE_PREFIX = "engine_session";
+function table(db, name) {
+  return raw(db.dialect.quoteIdentifier(name));
+}
+function tablesFor(db, prefix) {
+  const valid = assertTablePrefix(prefix);
+  return {
+    sessions: table(db, `${valid}_sessions`),
+    messages: table(db, `${valid}_messages`),
+    meta: table(db, `${valid}_meta`)
+  };
+}
+function toNumber(value) {
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "bigint")
+    return Number(value);
+  return Number.parseInt(value, 10);
+}
+function stateOf(id, messages, metadata) {
+  return {
+    id,
+    messages: [...messages],
+    ...metadata !== undefined ? { metadata: { ...metadata } } : {}
+  };
+}
+
+class ForgeDataSessionStore {
+  db;
+  codec;
+  tables;
+  closeDbOnClose;
+  writeQueue = Promise.resolve();
+  constructor(options) {
+    this.db = options.db;
+    this.codec = options.codec ?? jsonSessionStoreCodec;
+    this.tables = tablesFor(options.db, options.tablePrefix ?? DEFAULT_TABLE_PREFIX);
+    this.closeDbOnClose = options.closeDbOnClose ?? false;
+  }
+  async migrate() {
+    await this.db.raw(sql`
+      create table if not exists ${this.tables.sessions} (
+        id text primary key,
+        metadata text null,
+        next_seq integer not null default 0,
+        created_at text not null,
+        updated_at text not null
+      )
+    `).execute();
+    await this.db.raw(sql`
+      create table if not exists ${this.tables.messages} (
+        session_id text not null,
+        seq integer not null,
+        payload text not null,
+        created_at text not null,
+        primary key (session_id, seq)
+      )
+    `).execute();
+    await this.db.raw(sql`
+      create table if not exists ${this.tables.meta} (
+        key text primary key,
+        value text not null
+      )
+    `).execute();
+    await this.db.raw(sql`
+      insert into ${this.tables.meta} (key, value)
+      values (${"schema_version"}, ${String(SESSION_STORE_SCHEMA_VERSION)})
+      on conflict (key) do update set value = excluded.value
+    `).execute();
+  }
+  async schemaVersion() {
+    const row = await this.db.raw(sql`
+      select value from ${this.tables.meta} where key = ${"schema_version"}
+    `).executeTakeFirst();
+    return row === undefined ? undefined : Number.parseInt(row.value, 10);
+  }
+  async load(id) {
+    await this.writeQueue.catch(() => {});
+    const session = await this.db.raw(sql`
+      select id, metadata from ${this.tables.sessions} where id = ${id}
+    `).executeTakeFirst();
+    if (session === undefined)
+      return;
+    const rows = await this.db.raw(sql`
+      select payload from ${this.tables.messages}
+      where session_id = ${id}
+      order by seq asc
+    `).execute();
+    const messages = await decodeMessages(this.codec, rows.rows.map((row) => row.payload));
+    const metadata = await decodeMetadata(this.codec, session.metadata);
+    return stateOf(id, messages, metadata);
+  }
+  async append(id, messages) {
+    if (messages.length === 0)
+      return;
+    const encoded = await encodeMessages(this.codec, messages);
+    const now = new Date().toISOString();
+    await this.enqueueWrite(async () => this.db.uow(async (tx) => {
+      await tx.raw(sql`
+        insert into ${this.tables.sessions} (id, metadata, next_seq, created_at, updated_at)
+        values (${id}, null, 0, ${now}, ${now})
+        on conflict (id) do nothing
+      `).execute();
+      const row = await tx.raw(sql`
+        update ${this.tables.sessions}
+        set next_seq = next_seq + ${encoded.length}, updated_at = ${now}
+        where id = ${id}
+        returning next_seq
+      `).executeTakeFirst();
+      if (row === undefined)
+        throw new Error(`Failed to allocate session sequence for ${id}`);
+      const start = toNumber(row.next_seq) - encoded.length;
+      for (let index = 0;index < encoded.length; index += 1) {
+        await tx.raw(sql`
+          insert into ${this.tables.messages} (session_id, seq, payload, created_at)
+          values (${id}, ${start + index}, ${encoded[index]}, ${now})
+        `).execute();
+      }
+    }));
+  }
+  async save(state) {
+    const encoded = await encodeMessages(this.codec, state.messages);
+    const metadata = await encodeMetadata(this.codec, state.metadata);
+    const now = new Date().toISOString();
+    await this.enqueueWrite(async () => this.db.uow(async (tx) => {
+      await tx.raw(sql`
+        insert into ${this.tables.sessions} (id, metadata, next_seq, created_at, updated_at)
+        values (${state.id}, ${metadata ?? null}, ${encoded.length}, ${now}, ${now})
+        on conflict (id) do update set
+          metadata = excluded.metadata,
+          next_seq = excluded.next_seq,
+          updated_at = excluded.updated_at
+      `).execute();
+      await tx.raw(sql`
+        delete from ${this.tables.messages} where session_id = ${state.id}
+      `).execute();
+      for (let index = 0;index < encoded.length; index += 1) {
+        await tx.raw(sql`
+          insert into ${this.tables.messages} (session_id, seq, payload, created_at)
+          values (${state.id}, ${index}, ${encoded[index]}, ${now})
+        `).execute();
+      }
+    }));
+  }
+  async delete(id) {
+    await this.enqueueWrite(async () => this.db.uow(async (tx) => {
+      await tx.raw(sql`delete from ${this.tables.messages} where session_id = ${id}`).execute();
+      await tx.raw(sql`delete from ${this.tables.sessions} where id = ${id}`).execute();
+    }));
+  }
+  async close() {
+    await this.writeQueue.catch(() => {});
+    if (this.closeDbOnClose)
+      await this.db.shutdown();
+  }
+  enqueueWrite(task) {
+    const run = this.writeQueue.catch(() => {}).then(task);
+    this.writeQueue = run.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return run;
+  }
+}
+async function createSqliteSessionStore(options = {}) {
+  const db = createDb({
+    dialect: createSqliteDialect(),
+    driver: createSqliteDriver({
+      database: options.database,
+      filename: options.filename,
+      create: options.create
+    })
+  });
+  const store = new ForgeDataSessionStore({
+    db,
+    tablePrefix: options.tablePrefix,
+    codec: options.codec,
+    closeDbOnClose: true
+  });
+  if (options.migrate)
+    await store.migrate();
+  return store;
+}
+async function createPostgresSessionStore(options) {
+  const db = createDb({
+    dialect: createPostgresDialect(),
+    driver: createPostgresDriver({
+      client: options.client,
+      closeOnShutdown: options.closeOnShutdown
+    })
+  });
+  const store = new ForgeDataSessionStore({
+    db,
+    tablePrefix: options.tablePrefix,
+    codec: options.codec,
+    closeDbOnClose: true
+  });
+  if (options.migrate)
+    await store.migrate();
+  return store;
+}
+// src/session-stores/hooks.ts
+function snapshot(state) {
+  return {
+    id: state.id,
+    messages: [...state.messages],
+    ...state.metadata !== undefined ? { metadata: { ...state.metadata } } : {}
+  };
+}
+function isCompactionResult(value) {
+  return typeof value === "object" && value !== null && "state" in value;
+}
+function withSessionStoreHooks(store, hooks) {
+  let runningHooks = false;
+  async function runHooks(operation, id) {
+    if (runningHooks || hooks.compactor === undefined)
+      return;
+    const current = await store.load(id);
+    if (current === undefined)
+      return;
+    const context = { operation, store: wrapped };
+    const shouldCompact = hooks.compactor.shouldCompact === undefined ? true : await hooks.compactor.shouldCompact(snapshot(current), context);
+    if (!shouldCompact)
+      return;
+    runningHooks = true;
+    try {
+      const result = await hooks.compactor.compact(snapshot(current), context);
+      const replacement = isCompactionResult(result) ? result.state : result;
+      if (isCompactionResult(result) && result.archive !== undefined && hooks.archiver !== undefined) {
+        await hooks.archiver.archive({
+          id,
+          at: new Date().toISOString(),
+          operation,
+          ...result.archive
+        }, context);
+      }
+      await store.save(snapshot(replacement));
+    } finally {
+      runningHooks = false;
+    }
+  }
+  const wrapped = {
+    load(id) {
+      return store.load(id);
+    },
+    async append(id, messages) {
+      await store.append(id, messages);
+      if (messages.length > 0)
+        await runHooks("append", id);
+    },
+    async save(state) {
+      await store.save(state);
+      await runHooks("save", state.id);
+    },
+    delete(id) {
+      return store.delete(id);
+    }
+  };
+  if (isVersionedSessionStore(store)) {
+    wrapped.migrate = () => store.migrate();
+  }
+  if (isCloseableSessionStore(store)) {
+    wrapped.close = () => store.close();
+  }
+  return wrapped;
+}
+// src/session-stores/jsonl.ts
+import { appendFile, mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+function isMissingFile(error) {
+  return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+function buildState(id, messages, metadata) {
+  return {
+    id,
+    messages: [...messages],
+    ...metadata !== undefined ? { metadata: { ...metadata } } : {}
+  };
+}
+
+class FilesystemJsonlSessionStore {
+  directory;
+  codec;
+  queues = new Map;
+  constructor(options) {
+    this.directory = options.directory;
+    this.codec = options.codec ?? jsonSessionStoreCodec;
+  }
+  async migrate() {
+    await mkdir(this.directory, { recursive: true });
+    await writeFile(join(this.directory, ".engine-session-store-version"), `${SESSION_STORE_SCHEMA_VERSION}
+`, "utf8");
+  }
+  async load(id) {
+    await this.waitForWrites(id);
+    return (await this.replayFile(this.pathFor(id), id)).state;
+  }
+  async append(id, messages) {
+    if (messages.length === 0)
+      return;
+    await this.enqueue(id, async () => {
+      const record = {
+        version: SESSION_STORE_SCHEMA_VERSION,
+        op: "append",
+        id,
+        at: new Date().toISOString(),
+        messages: await encodeMessages(this.codec, messages)
+      };
+      await this.appendRecord(id, record);
+    });
+  }
+  async save(state) {
+    await this.enqueue(state.id, async () => {
+      const metadata = await encodeMetadata(this.codec, state.metadata);
+      const record = {
+        version: SESSION_STORE_SCHEMA_VERSION,
+        op: "save",
+        id: state.id,
+        at: new Date().toISOString(),
+        messages: await encodeMessages(this.codec, state.messages),
+        ...metadata !== undefined ? { metadata } : {}
+      };
+      await this.appendRecord(state.id, record);
+    });
+  }
+  async delete(id) {
+    await this.enqueue(id, async () => {
+      await this.appendRecord(id, {
+        version: SESSION_STORE_SCHEMA_VERSION,
+        op: "delete",
+        id,
+        at: new Date().toISOString()
+      });
+    });
+  }
+  async compact(id) {
+    if (id !== undefined) {
+      await this.enqueue(id, () => this.compactFile(this.pathFor(id), id));
+      return;
+    }
+    await this.migrate();
+    const entries = await readdir(this.directory, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+        continue;
+      await this.compactFile(join(this.directory, entry.name));
+    }
+  }
+  pathFor(id) {
+    return join(this.directory, sessionFileName(id));
+  }
+  async waitForWrites(id) {
+    await (this.queues.get(id) ?? Promise.resolve()).catch(() => {});
+  }
+  async enqueue(id, task) {
+    const previous = this.queues.get(id) ?? Promise.resolve();
+    const run = previous.catch(() => {}).then(task);
+    const next = run.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    this.queues.set(id, next);
+    try {
+      return await run;
+    } finally {
+      if (this.queues.get(id) === next)
+        this.queues.delete(id);
+    }
+  }
+  async appendRecord(id, record) {
+    await mkdir(this.directory, { recursive: true });
+    await appendFile(this.pathFor(id), `${JSON.stringify(record)}
+`, "utf8");
+  }
+  async replayFile(path, expectedId) {
+    let text;
+    try {
+      text = await readFile(path, "utf8");
+    } catch (error) {
+      if (isMissingFile(error))
+        return { id: expectedId, state: undefined };
+      throw error;
+    }
+    let id = expectedId;
+    let messages = [];
+    let metadata;
+    let exists = false;
+    for (const rawLine of text.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (line.length === 0)
+        continue;
+      const record = JSON.parse(line);
+      if (id === undefined)
+        id = record.id;
+      if (record.id !== id)
+        continue;
+      if (record.op === "delete") {
+        exists = false;
+        messages = [];
+        metadata = undefined;
+      } else if (record.op === "save") {
+        exists = true;
+        messages = await decodeMessages(this.codec, record.messages);
+        metadata = await decodeMetadata(this.codec, record.metadata);
+      } else {
+        exists = true;
+        messages.push(...await decodeMessages(this.codec, record.messages));
+      }
+    }
+    if (!exists || id === undefined)
+      return { id, state: undefined };
+    return { id, state: buildState(id, messages, metadata) };
+  }
+  async compactFile(path, expectedId) {
+    const replayed = await this.replayFile(path, expectedId);
+    if (replayed.id === undefined)
+      return;
+    if (replayed.state === undefined) {
+      await rm(path, { force: true });
+      return;
+    }
+    const metadata = await encodeMetadata(this.codec, replayed.state.metadata);
+    const record = {
+      version: SESSION_STORE_SCHEMA_VERSION,
+      op: "save",
+      id: replayed.id,
+      at: new Date().toISOString(),
+      messages: await encodeMessages(this.codec, replayed.state.messages),
+      ...metadata !== undefined ? { metadata } : {}
+    };
+    const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    await writeFile(tmp, `${JSON.stringify(record)}
+`, "utf8");
+    await rename(tmp, path);
+  }
+}
+// src/session-stores/redis.ts
+function metadataState(id, messages, metadata) {
+  return {
+    id,
+    messages: [...messages],
+    ...metadata !== undefined ? { metadata: { ...metadata } } : {}
+  };
+}
+function rpushTransaction(tx, key, values) {
+  if (values.length === 0)
+    return;
+  if (tx.rPush !== undefined) {
+    tx.rPush(key, ...values);
+    return;
+  }
+  if (tx.rpush !== undefined) {
+    tx.rpush(key, ...values);
+    return;
+  }
+  throw new Error("Redis session store transaction must implement rPush/rpush");
+}
+
+class RedisSessionStore {
+  client;
+  keyPrefix;
+  codec;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix ?? "engine:sessions";
+    this.codec = options.codec ?? jsonSessionStoreCodec;
+  }
+  async migrate() {
+    await this.client.set(this.versionKey(), String(SESSION_STORE_SCHEMA_VERSION));
+  }
+  async load(id) {
+    const payloads = await this.lRange(this.messagesKey(id), 0, -1);
+    const metadataPayload = await this.client.get(this.metadataKey(id));
+    const exists = await this.client.get(this.existsKey(id));
+    if (payloads.length === 0 && metadataPayload == null && exists == null)
+      return;
+    const metadata = await decodeMetadata(this.codec, metadataPayload);
+    const messages = await decodeMessages(this.codec, payloads);
+    return metadataState(id, messages, metadata);
+  }
+  async append(id, messages) {
+    if (messages.length === 0)
+      return;
+    const encoded = await encodeMessages(this.codec, messages);
+    await this.rPush(this.messagesKey(id), encoded);
+  }
+  async save(state) {
+    const tx = this.transaction();
+    const messagesKey = this.messagesKey(state.id);
+    const metadataKey = this.metadataKey(state.id);
+    const existsKey = this.existsKey(state.id);
+    const encoded = await encodeMessages(this.codec, state.messages);
+    const metadata = await encodeMetadata(this.codec, state.metadata);
+    tx.del(messagesKey, metadataKey, existsKey);
+    tx.set(existsKey, "1");
+    if (metadata !== undefined)
+      tx.set(metadataKey, metadata);
+    rpushTransaction(tx, messagesKey, encoded);
+    await tx.exec();
+  }
+  async delete(id) {
+    const tx = this.transaction();
+    tx.del(this.messagesKey(id), this.metadataKey(id), this.existsKey(id));
+    await tx.exec();
+  }
+  transaction() {
+    const tx = this.client.multi?.();
+    if (tx === undefined)
+      throw new Error("Redis session store save/delete require a transaction-capable client");
+    return tx;
+  }
+  async lRange(key, start, stop) {
+    if (this.client.lRange !== undefined)
+      return this.client.lRange(key, start, stop);
+    if (this.client.lrange !== undefined)
+      return this.client.lrange(key, start, stop);
+    throw new Error("Redis session store client must implement lRange/lrange");
+  }
+  async rPush(key, values) {
+    if (this.client.rPush !== undefined) {
+      await this.client.rPush(key, ...values);
+      return;
+    }
+    if (this.client.rpush !== undefined) {
+      await this.client.rpush(key, ...values);
+      return;
+    }
+    throw new Error("Redis session store client must implement rPush/rpush");
+  }
+  idKey(id) {
+    return `${this.keyPrefix}:${safeSessionKey(id)}`;
+  }
+  messagesKey(id) {
+    return `${this.idKey(id)}:messages`;
+  }
+  metadataKey(id) {
+    return `${this.idKey(id)}:metadata`;
+  }
+  existsKey(id) {
+    return `${this.idKey(id)}:exists`;
+  }
+  versionKey() {
+    return `${this.keyPrefix}:meta:version`;
+  }
+}
+export {
+  withSessionStoreHooks,
+  migrateSessionStore,
+  jsonSessionStoreCodec,
+  isVersionedSessionStore,
+  isCloseableSessionStore,
+  createSqliteSessionStore,
+  createPostgresSessionStore,
+  SESSION_STORE_SCHEMA_VERSION,
+  RedisSessionStore,
+  ForgeDataSessionStore,
+  FilesystemJsonlSessionStore
+};