@cascade-flow/backend-postgres 0.1.0 → 0.2.0

package/dist/index.js

@@ -4773,12 +4773,117 @@ var esm_default = import_lib.default;
 
 // src/db.ts
 var { Pool: Pool2 } = esm_default;
-function createPool(connectionString) {
-  return new Pool2({ connectionString });
-}
-async function appendEvent(pool, table, event) {
-  const client = await pool.connect();
-  try {
+
+class DatabaseClient {
+  pool;
+  schema;
+  constructor(pool, schema) {
+    this.pool = pool;
+    this.schema = schema;
+  }
+  getPool() {
+    return this.pool;
+  }
+  getSchema() {
+    return this.schema;
+  }
+  async appendEvent(table, event) {
+    const client = await this.pool.connect();
+    try {
+      if (table === "workflow_events") {
+        const we = event;
+        let workflowAttemptNumber = null;
+        let availableAtUs = null;
+        let priority = null;
+        let timeoutUs = null;
+        let idempotencyKey = null;
+        if (we.type === "RunSubmitted") {
+          availableAtUs = we.availableAtUs;
+          priority = we.priority;
+          timeoutUs = we.timeoutUs ?? null;
+          idempotencyKey = we.idempotencyKey ?? null;
+        } else if ("workflowAttemptNumber" in we) {
+          workflowAttemptNumber = we.workflowAttemptNumber;
+        }
+        await client.query(`INSERT INTO ${this.schema}.workflow_events (
+          event_id, workflow_slug, run_id, timestamp_us, category, type, event_data,
+          workflow_attempt_number, available_at_us, priority, timeout_us, idempotency_key
+        )
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, [
+          we.eventId,
+          we.workflowSlug,
+          we.runId,
+          we.timestampUs,
+          we.category,
+          we.type,
+          JSON.stringify(event),
+          workflowAttemptNumber,
+          availableAtUs,
+          priority,
+          timeoutUs,
+          idempotencyKey
+        ]);
+      } else {
+        const se = event;
+        let workerId = null;
+        let attemptNumber = null;
+        let availableAtUs = null;
+        let exportOutput = null;
+        let errorNameHash = "";
+        let errorMessageHash = "";
+        let errorStackExactHash = "";
+        let errorStackNormalizedHash = "";
+        let errorStackPortableHash = "";
+        if (se.type === "StepStarted" || se.type === "StepHeartbeat") {
+          workerId = se.workerId;
+        }
+        if ("attemptNumber" in se) {
+          attemptNumber = se.attemptNumber;
+        }
+        if (se.type === "StepScheduled") {
+          availableAtUs = se.availableAtUs;
+        }
+        if (se.type === "StepCompleted") {
+          exportOutput = se.exportOutput;
+        }
+        if (se.type === "StepFailed") {
+          errorNameHash = se.errorFingerprints.nameHash;
+          errorMessageHash = se.errorFingerprints.messageHash;
+          errorStackExactHash = se.errorFingerprints.stackExactHash;
+          errorStackNormalizedHash = se.errorFingerprints.stackNormalizedHash;
+          errorStackPortableHash = se.errorFingerprints.stackPortableHash;
+        }
+        await client.query(`INSERT INTO ${this.schema}.step_events (
+          event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data,
+          worker_id, attempt_number, available_at_us, export_output,
+          error_name_hash, error_message_hash, error_stack_exact_hash,
+          error_stack_normalized_hash, error_stack_portable_hash
+        )
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)`, [
+          se.eventId,
+          se.workflowSlug,
+          se.runId,
+          se.stepId,
+          se.timestampUs,
+          se.category,
+          se.type,
+          JSON.stringify(event),
+          workerId,
+          attemptNumber,
+          availableAtUs,
+          exportOutput,
+          errorNameHash,
+          errorMessageHash,
+          errorStackExactHash,
+          errorStackNormalizedHash,
+          errorStackPortableHash
+        ]);
+      }
+    } finally {
+      client.release();
+    }
+  }
+  async appendEventWithClient(client, table, event) {
     if (table === "workflow_events") {
       const we = event;
       let workflowAttemptNumber = null;
@@ -4794,7 +4899,7 @@ async function appendEvent(pool, table, event) {
       } else if ("workflowAttemptNumber" in we) {
         workflowAttemptNumber = we.workflowAttemptNumber;
       }
-      await client.query(`INSERT INTO workflow_events (
+      await client.query(`INSERT INTO ${this.schema}.workflow_events (
           event_id, workflow_slug, run_id, timestamp_us, category, type, event_data,
           workflow_attempt_number, available_at_us, priority, timeout_us, idempotency_key
         )
@@ -4842,7 +4947,7 @@ async function appendEvent(pool, table, event) {
         errorStackNormalizedHash = se.errorFingerprints.stackNormalizedHash;
         errorStackPortableHash = se.errorFingerprints.stackPortableHash;
       }
-      await client.query(`INSERT INTO step_events (
+      await client.query(`INSERT INTO ${this.schema}.step_events (
           event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data,
           worker_id, attempt_number, available_at_us, export_output,
           error_name_hash, error_message_hash, error_stack_exact_hash,
@@ -4868,239 +4973,145 @@ async function appendEvent(pool, table, event) {
         errorStackPortableHash
       ]);
     }
-  } finally {
-    client.release();
   }
-}
-async function appendEventWithClient(client, table, event) {
-  if (table === "workflow_events") {
-    const we = event;
-    let workflowAttemptNumber = null;
-    let availableAtUs = null;
-    let priority = null;
-    let timeoutUs = null;
-    let idempotencyKey = null;
-    if (we.type === "RunSubmitted") {
-      availableAtUs = we.availableAtUs;
-      priority = we.priority;
-      timeoutUs = we.timeoutUs ?? null;
-      idempotencyKey = we.idempotencyKey ?? null;
-    } else if ("workflowAttemptNumber" in we) {
-      workflowAttemptNumber = we.workflowAttemptNumber;
-    }
-    await client.query(`INSERT INTO workflow_events (
-        event_id, workflow_slug, run_id, timestamp_us, category, type, event_data,
-        workflow_attempt_number, available_at_us, priority, timeout_us, idempotency_key
-      )
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, [
-      we.eventId,
-      we.workflowSlug,
-      we.runId,
-      we.timestampUs,
-      we.category,
-      we.type,
-      JSON.stringify(event),
-      workflowAttemptNumber,
-      availableAtUs,
-      priority,
-      timeoutUs,
-      idempotencyKey
-    ]);
-  } else {
-    const se = event;
-    let workerId = null;
-    let attemptNumber = null;
-    let availableAtUs = null;
-    let exportOutput = null;
-    let errorNameHash = "";
-    let errorMessageHash = "";
-    let errorStackExactHash = "";
-    let errorStackNormalizedHash = "";
-    let errorStackPortableHash = "";
-    if (se.type === "StepStarted" || se.type === "StepHeartbeat") {
-      workerId = se.workerId;
-    }
-    if ("attemptNumber" in se) {
-      attemptNumber = se.attemptNumber;
-    }
-    if (se.type === "StepScheduled") {
-      availableAtUs = se.availableAtUs;
-    }
-    if (se.type === "StepCompleted") {
-      exportOutput = se.exportOutput;
-    }
-    if (se.type === "StepFailed") {
-      errorNameHash = se.errorFingerprints.nameHash;
-      errorMessageHash = se.errorFingerprints.messageHash;
-      errorStackExactHash = se.errorFingerprints.stackExactHash;
-      errorStackNormalizedHash = se.errorFingerprints.stackNormalizedHash;
-      errorStackPortableHash = se.errorFingerprints.stackPortableHash;
-    }
-    await client.query(`INSERT INTO step_events (
-        event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data,
-        worker_id, attempt_number, available_at_us, export_output,
-        error_name_hash, error_message_hash, error_stack_exact_hash,
-        error_stack_normalized_hash, error_stack_portable_hash
-      )
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)`, [
-      se.eventId,
-      se.workflowSlug,
-      se.runId,
-      se.stepId,
-      se.timestampUs,
-      se.category,
-      se.type,
-      JSON.stringify(event),
-      workerId,
-      attemptNumber,
-      availableAtUs,
-      exportOutput,
-      errorNameHash,
-      errorMessageHash,
-      errorStackExactHash,
-      errorStackNormalizedHash,
-      errorStackPortableHash
-    ]);
-  }
-}
-async function loadEvents(pool, table, filters) {
-  const client = await pool.connect();
-  try {
-    const conditions = [];
-    const values = [];
-    let paramIndex = 1;
-    if (filters.workflowSlug) {
-      conditions.push(`workflow_slug = $${paramIndex++}`);
-      values.push(filters.workflowSlug);
-    }
-    if (filters.runId) {
-      conditions.push(`run_id = $${paramIndex++}`);
-      values.push(filters.runId);
-    }
-    if (filters.stepId && table === "step_events") {
-      conditions.push(`step_id = $${paramIndex++}`);
-      values.push(filters.stepId);
-    }
-    if (filters.category) {
-      conditions.push(`category = $${paramIndex++}`);
-      values.push(filters.category);
-    }
-    if (filters.types && filters.types.length > 0) {
-      conditions.push(`type = ANY($${paramIndex++})`);
-      values.push(filters.types);
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const query = `
-      SELECT event_data FROM ${table}
+  async loadEvents(table, filters) {
+    const client = await this.pool.connect();
+    try {
+      const conditions = [];
+      const values = [];
+      let paramIndex = 1;
+      if (filters.workflowSlug) {
+        conditions.push(`workflow_slug = $${paramIndex++}`);
+        values.push(filters.workflowSlug);
+      }
+      if (filters.runId) {
+        conditions.push(`run_id = $${paramIndex++}`);
+        values.push(filters.runId);
+      }
+      if (filters.stepId && table === "step_events") {
+        conditions.push(`step_id = $${paramIndex++}`);
+        values.push(filters.stepId);
+      }
+      if (filters.category) {
+        conditions.push(`category = $${paramIndex++}`);
+        values.push(filters.category);
+      }
+      if (filters.types && filters.types.length > 0) {
+        conditions.push(`type = ANY($${paramIndex++})`);
+        values.push(filters.types);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const query = `
+      SELECT event_data FROM ${this.schema}.${table}
       ${whereClause}
       ORDER BY timestamp_us ASC, event_id ASC
     `;
-    const result = await client.query(query, values);
-    return result.rows.map((row) => row.event_data);
-  } finally {
-    client.release();
+      const result = await client.query(query, values);
+      return result.rows.map((row) => row.event_data);
+    } finally {
+      client.release();
+    }
   }
-}
-async function loadAllRunEvents(pool, workflowSlug, runId) {
-  const client = await pool.connect();
-  try {
-    const query = `
-      SELECT event_data, timestamp_us, event_id FROM workflow_events
+  async loadAllRunEvents(workflowSlug, runId) {
+    const client = await this.pool.connect();
+    try {
+      const query = `
+      SELECT event_data, timestamp_us, event_id FROM ${this.schema}.workflow_events
       WHERE workflow_slug = $1 AND run_id = $2
       UNION ALL
-      SELECT event_data, timestamp_us, event_id FROM step_events
+      SELECT event_data, timestamp_us, event_id FROM ${this.schema}.step_events
       WHERE workflow_slug = $1 AND run_id = $2
       ORDER BY timestamp_us ASC, event_id ASC
     `;
-    const result = await client.query(query, [workflowSlug, runId]);
-    return result.rows.map((row) => row.event_data);
-  } finally {
-    client.release();
+      const result = await client.query(query, [workflowSlug, runId]);
+      return result.rows.map((row) => row.event_data);
+    } finally {
+      client.release();
+    }
   }
-}
-async function claimScheduledStep(pool, workflowSlug, runId, stepId, workerId, eventToWrite) {
-  const client = await pool.connect();
-  try {
-    await client.query("BEGIN");
-    const checkQuery = `
-      SELECT event_data FROM step_events
+  async claimScheduledStep(workflowSlug, runId, stepId, workerId, eventToWrite) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const checkQuery = `
+      SELECT event_data FROM ${this.schema}.step_events
       WHERE workflow_slug = $1 AND run_id = $2 AND step_id = $3
       ORDER BY timestamp_us DESC, event_id DESC
       LIMIT 1
       FOR UPDATE SKIP LOCKED
     `;
-    const checkResult = await client.query(checkQuery, [workflowSlug, runId, stepId]);
-    if (checkResult.rows.length === 0) {
-      await client.query("ROLLBACK");
-      return false;
-    }
-    const latestEvent = checkResult.rows[0].event_data;
-    if (latestEvent.type !== "StepScheduled" && latestEvent.type !== "StepReclaimed" && latestEvent.type !== "StepRetrying") {
+      const checkResult = await client.query(checkQuery, [workflowSlug, runId, stepId]);
+      if (checkResult.rows.length === 0) {
+        await client.query("ROLLBACK");
+        return false;
+      }
+      const latestEvent = checkResult.rows[0].event_data;
+      if (latestEvent.type !== "StepScheduled" && latestEvent.type !== "StepReclaimed" && latestEvent.type !== "StepRetrying") {
+        await client.query("ROLLBACK");
+        return false;
+      }
+      let workerId2 = null;
+      let attemptNumber = null;
+      let errorNameHash = "";
+      let errorMessageHash = "";
+      let errorStackExactHash = "";
+      let errorStackNormalizedHash = "";
+      let errorStackPortableHash = "";
+      if (eventToWrite.type === "StepStarted") {
+        workerId2 = eventToWrite.workerId;
+        attemptNumber = eventToWrite.attemptNumber;
+      }
+      if (eventToWrite.type === "StepFailed") {
+        errorNameHash = eventToWrite.errorFingerprints.nameHash;
+        errorMessageHash = eventToWrite.errorFingerprints.messageHash;
+        errorStackExactHash = eventToWrite.errorFingerprints.stackExactHash;
+        errorStackNormalizedHash = eventToWrite.errorFingerprints.stackNormalizedHash;
+        errorStackPortableHash = eventToWrite.errorFingerprints.stackPortableHash;
+      }
+      await client.query(`INSERT INTO ${this.schema}.step_events (
+          event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data,
+          worker_id, attempt_number, available_at_us, export_output,
+          error_name_hash, error_message_hash, error_stack_exact_hash,
+          error_stack_normalized_hash, error_stack_portable_hash
+        )
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)`, [
+        eventToWrite.eventId,
+        eventToWrite.workflowSlug,
+        eventToWrite.runId,
+        eventToWrite.stepId,
+        eventToWrite.timestampUs,
+        eventToWrite.category,
+        eventToWrite.type,
+        JSON.stringify(eventToWrite),
+        workerId2,
+        attemptNumber,
+        null,
+        null,
+        errorNameHash,
+        errorMessageHash,
+        errorStackExactHash,
+        errorStackNormalizedHash,
+        errorStackPortableHash
+      ]);
+      await client.query("COMMIT");
+      return true;
+    } catch (error) {
       await client.query("ROLLBACK");
-      return false;
+      throw error;
+    } finally {
+      client.release();
     }
-    let workerId2 = null;
-    let attemptNumber = null;
-    let errorNameHash = "";
-    let errorMessageHash = "";
-    let errorStackExactHash = "";
-    let errorStackNormalizedHash = "";
-    let errorStackPortableHash = "";
-    if (eventToWrite.type === "StepStarted") {
-      workerId2 = eventToWrite.workerId;
-      attemptNumber = eventToWrite.attemptNumber;
-    }
-    if (eventToWrite.type === "StepFailed") {
-      errorNameHash = eventToWrite.errorFingerprints.nameHash;
-      errorMessageHash = eventToWrite.errorFingerprints.messageHash;
-      errorStackExactHash = eventToWrite.errorFingerprints.stackExactHash;
-      errorStackNormalizedHash = eventToWrite.errorFingerprints.stackNormalizedHash;
-      errorStackPortableHash = eventToWrite.errorFingerprints.stackPortableHash;
-    }
-    await client.query(`INSERT INTO step_events (
-        event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data,
-        worker_id, attempt_number, available_at_us, export_output,
-        error_name_hash, error_message_hash, error_stack_exact_hash,
-        error_stack_normalized_hash, error_stack_portable_hash
-      )
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)`, [
-      eventToWrite.eventId,
-      eventToWrite.workflowSlug,
-      eventToWrite.runId,
-      eventToWrite.stepId,
-      eventToWrite.timestampUs,
-      eventToWrite.category,
-      eventToWrite.type,
-      JSON.stringify(eventToWrite),
-      workerId2,
-      attemptNumber,
-      null,
-      null,
-      errorNameHash,
-      errorMessageHash,
-      errorStackExactHash,
-      errorStackNormalizedHash,
-      errorStackPortableHash
-    ]);
-    await client.query("COMMIT");
-    return true;
-  } catch (error) {
-    await client.query("ROLLBACK");
-    throw error;
-  } finally {
-    client.release();
   }
-}
-async function listScheduledSteps(pool, options) {
-  const client = await pool.connect();
-  try {
-    const currentTimeUs = Date.now() * 1000;
-    const scheduledTypes = ["StepScheduled", "StepReclaimed", "StepRetrying"];
-    let query = `
+  async listScheduledSteps(options) {
+    const client = await this.pool.connect();
+    try {
+      const currentTimeUs = Date.now() * 1000;
+      const scheduledTypes = ["StepScheduled", "StepReclaimed", "StepRetrying"];
+      let query = `
       WITH latest_step_events AS (
         SELECT DISTINCT ON (workflow_slug, run_id, step_id)
           workflow_slug, run_id, step_id, type, available_at_us
-        FROM step_events
+        FROM ${this.schema}.step_events
         ${options?.workflowSlugs ? "WHERE workflow_slug = ANY($1)" : ""}
         ORDER BY workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC
       )
@@ -5110,34 +5121,34 @@ async function listScheduledSteps(pool, options) {
         AND (available_at_us IS NULL OR available_at_us <= $${options?.workflowSlugs ? "3" : "2"})
       ${options?.limit ? `LIMIT $${options?.workflowSlugs ? "4" : "3"}` : ""}
     `;
-    const params = [];
-    if (options?.workflowSlugs) {
-      params.push(options.workflowSlugs);
-    }
-    params.push(scheduledTypes);
-    params.push(currentTimeUs);
-    if (options?.limit) {
-      params.push(options.limit);
+      const params = [];
+      if (options?.workflowSlugs) {
+        params.push(options.workflowSlugs);
+      }
+      params.push(scheduledTypes);
+      params.push(currentTimeUs);
+      if (options?.limit) {
+        params.push(options.limit);
+      }
+      const result = await client.query(query, params);
+      return result.rows.map((row) => ({
+        workflowSlug: row.workflow_slug,
+        runId: row.run_id,
+        stepId: row.step_id
+      }));
+    } finally {
+      client.release();
     }
-    const result = await client.query(query, params);
-    return result.rows.map((row) => ({
-      workflowSlug: row.workflow_slug,
-      runId: row.run_id,
-      stepId: row.step_id
-    }));
-  } finally {
-    client.release();
   }
-}
-async function findStaleSteps(pool, staleThresholdUs) {
-  const client = await pool.connect();
-  try {
-    const currentTimeUs = Date.now() * 1000;
-    const query = `
+  async findStaleSteps(staleThresholdUs) {
+    const client = await this.pool.connect();
+    try {
+      const currentTimeUs = Date.now() * 1000;
+      const query = `
       WITH latest_step_events AS (
         SELECT DISTINCT ON (workflow_slug, run_id, step_id)
           workflow_slug, run_id, step_id, type, timestamp_us, worker_id
-        FROM step_events
+        FROM ${this.schema}.step_events
         WHERE type IN ('StepStarted', 'StepHeartbeat')
         ORDER BY workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC
       )
@@ -5145,21 +5156,42 @@ async function findStaleSteps(pool, staleThresholdUs) {
       FROM latest_step_events
       WHERE timestamp_us < $1 AND worker_id IS NOT NULL
     `;
-    const result = await client.query(query, [currentTimeUs - staleThresholdUs]);
-    return result.rows.map((row) => ({
-      workflowSlug: row.workflow_slug,
-      runId: row.run_id,
-      stepId: row.step_id,
-      workerId: row.worker_id
-    }));
-  } finally {
-    client.release();
+      const result = await client.query(query, [currentTimeUs - staleThresholdUs]);
+      return result.rows.map((row) => ({
+        workflowSlug: row.workflow_slug,
+        runId: row.run_id,
+        stepId: row.step_id,
+        workerId: row.worker_id
+      }));
+    } finally {
+      client.release();
+    }
   }
-}
-async function upsertWorkflowMetadata(pool, slug, name, location, inputSchemaJSON) {
-  const client = await pool.connect();
-  try {
-    await client.query(`INSERT INTO workflow_metadata (slug, name, description, input_schema_json, tags, updated_at)
+  async saveStepOutput(workflowSlug, runId, stepId, attemptNumber, output) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(`INSERT INTO ${this.schema}.step_outputs (workflow_slug, run_id, step_id, attempt_number, output)
+       VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (workflow_slug, run_id, step_id, attempt_number)
+       DO UPDATE SET output = EXCLUDED.output`, [workflowSlug, runId, stepId, attemptNumber, JSON.stringify(output)]);
+    } finally {
+      client.release();
+    }
+  }
+  async loadStepOutput(workflowSlug, runId, stepId, attemptNumber) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`SELECT output FROM ${this.schema}.step_outputs
+       WHERE workflow_slug = $1 AND run_id = $2 AND step_id = $3 AND attempt_number = $4`, [workflowSlug, runId, stepId, attemptNumber]);
+      return result.rows.length > 0 ? result.rows[0].output : null;
+    } finally {
+      client.release();
+    }
+  }
+  async upsertWorkflowMetadata(slug, name, location, inputSchemaJSON) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(`INSERT INTO ${this.schema}.workflow_metadata (slug, name, description, input_schema_json, tags, updated_at)
        VALUES ($1, $2, $3, $4, $5, NOW())
        ON CONFLICT (slug)
        DO UPDATE SET
@@ -5167,153 +5199,169 @@ async function upsertWorkflowMetadata(pool, slug, name, location, inputSchemaJSO
          description = EXCLUDED.description,
          input_schema_json = EXCLUDED.input_schema_json,
          updated_at = NOW()`, [
-      slug,
-      name,
-      location || null,
-      inputSchemaJSON ? JSON.stringify(inputSchemaJSON) : null,
-      []
-    ]);
-  } finally {
-    client.release();
+        slug,
+        name,
+        location || null,
+        inputSchemaJSON ? JSON.stringify(inputSchemaJSON) : null,
+        []
+      ]);
+    } finally {
+      client.release();
+    }
   }
-}
-async function upsertStepDefinition(pool, workflowSlug, step) {
-  const client = await pool.connect();
-  try {
-    await client.query(`INSERT INTO step_definitions (
-        workflow_slug, id, dependencies, export_output, input_schema_json,
-        timeout_ms, max_retries, retry_delay_ms
-      )
+  async upsertStepDefinition(workflowSlug, step) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(`INSERT INTO ${this.schema}.step_definitions (
+          workflow_slug, id, dependencies, export_output, input_schema_json,
+          timeout_ms, max_retries, retry_delay_ms
+        )
        VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
        ON CONFLICT (workflow_slug, id)
        DO UPDATE SET
          dependencies = EXCLUDED.dependencies,
          export_output = EXCLUDED.export_output`, [
-      workflowSlug,
-      step.id,
-      JSON.stringify(step.dependencies),
-      step.exportOutput,
-      null,
-      null,
-      null,
-      null
-    ]);
-  } finally {
-    client.release();
+        workflowSlug,
+        step.id,
+        JSON.stringify(step.dependencies),
+        step.exportOutput,
+        null,
+        null,
+        null,
+        null
+      ]);
+    } finally {
+      client.release();
+    }
   }
-}
-async function getWorkflowMetadata(pool, slug) {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(`SELECT slug, name, description, input_schema_json
-       FROM workflow_metadata
+  async getWorkflowMetadata(slug) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`SELECT slug, name, description, input_schema_json
+       FROM ${this.schema}.workflow_metadata
        WHERE slug = $1`, [slug]);
-    if (result.rows.length === 0) {
-      return null;
+      if (result.rows.length === 0) {
+        return null;
+      }
+      const row = result.rows[0];
+      return {
+        slug: row.slug,
+        name: row.name,
+        location: row.description,
+        inputSchemaJSON: row.input_schema_json
+      };
+    } finally {
+      client.release();
     }
-    const row = result.rows[0];
-    return {
-      slug: row.slug,
-      name: row.name,
-      location: row.description,
-      inputSchemaJSON: row.input_schema_json
-    };
-  } finally {
-    client.release();
   }
-}
-async function listWorkflowMetadata(pool) {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(`SELECT slug, name, description, input_schema_json
-       FROM workflow_metadata
+  async listWorkflowMetadata() {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`SELECT slug, name, description, input_schema_json
+       FROM ${this.schema}.workflow_metadata
        ORDER BY name ASC`);
-    return result.rows.map((row) => ({
-      slug: row.slug,
-      name: row.name,
-      location: row.description,
-      inputSchemaJSON: row.input_schema_json
-    }));
-  } finally {
-    client.release();
+      return result.rows.map((row) => ({
+        slug: row.slug,
+        name: row.name,
+        location: row.description,
+        inputSchemaJSON: row.input_schema_json
+      }));
+    } finally {
+      client.release();
+    }
   }
-}
-async function getWorkflowSteps(pool, workflowSlug) {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(`SELECT id, dependencies, export_output
-       FROM step_definitions
+  async getWorkflowSteps(workflowSlug) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`SELECT id, dependencies, export_output
+       FROM ${this.schema}.step_definitions
        WHERE workflow_slug = $1
        ORDER BY id ASC`, [workflowSlug]);
-    return result.rows.map((row) => ({
-      id: row.id,
-      name: row.id,
-      dependencies: row.dependencies,
-      exportOutput: row.export_output
-    }));
-  } finally {
-    client.release();
+      return result.rows.map((row) => ({
+        id: row.id,
+        name: row.id,
+        dependencies: row.dependencies,
+        exportOutput: row.export_output
+      }));
+    } finally {
+      client.release();
+    }
   }
-}
-async function saveIdempotencyKey(pool, hash, runId) {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(`INSERT INTO idempotency_keys (hash, run_id)
+  async saveIdempotencyKey(hash, runId) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`INSERT INTO ${this.schema}.idempotency_keys (hash, run_id)
        VALUES ($1, $2)
        ON CONFLICT (hash)
        DO UPDATE SET hash = EXCLUDED.hash
        RETURNING run_id`, [hash, runId]);
-    return result.rows[0].run_id;
-  } finally {
-    client.release();
+      return result.rows[0].run_id;
+    } finally {
+      client.release();
+    }
   }
-}
-async function listRunIds(pool, workflowSlug) {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(`SELECT DISTINCT run_id FROM workflow_events WHERE workflow_slug = $1
+  async listRunIds(workflowSlug) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`SELECT DISTINCT run_id FROM ${this.schema}.workflow_events WHERE workflow_slug = $1
        UNION
-       SELECT DISTINCT run_id FROM step_events WHERE workflow_slug = $1
+       SELECT DISTINCT run_id FROM ${this.schema}.step_events WHERE workflow_slug = $1
        ORDER BY run_id DESC`, [workflowSlug]);
-    return result.rows.map((row) => row.run_id);
-  } finally {
-    client.release();
+      return result.rows.map((row) => row.run_id);
+    } finally {
+      client.release();
+    }
   }
-}
-async function listActiveWorkflows(pool) {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(`
+  async listActiveWorkflows() {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`
       SELECT DISTINCT workflow_slug FROM (
-        SELECT DISTINCT workflow_slug FROM workflow_events
+        SELECT DISTINCT workflow_slug FROM ${this.schema}.workflow_events
         WHERE type IN ('RunSubmitted', 'WorkflowStarted', 'WorkflowResumed')
         UNION
-        SELECT DISTINCT workflow_slug FROM step_events
+        SELECT DISTINCT workflow_slug FROM ${this.schema}.step_events
         WHERE type IN ('StepScheduled', 'StepStarted', 'StepReclaimed', 'StepRetrying')
       ) AS active
       ORDER BY workflow_slug ASC
     `);
-    return result.rows.map((row) => row.workflow_slug);
-  } finally {
-    client.release();
+      return result.rows.map((row) => row.workflow_slug);
+    } finally {
+      client.release();
+    }
+  }
+  async runExists(workflowSlug, runId) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`SELECT 1 FROM ${this.schema}.workflow_events WHERE workflow_slug = $1 AND run_id = $2 LIMIT 1`, [workflowSlug, runId]);
+      return result.rows.length > 0;
+    } finally {
+      client.release();
+    }
   }
 }
-async function runExists(pool, workflowSlug, runId) {
+function createPool(connectionString) {
+  return new Pool2({ connectionString });
+}
+
+// src/migrations.ts
+async function migration000_createSchema(pool, schema) {
   const client = await pool.connect();
   try {
-    const result = await client.query(`SELECT 1 FROM workflow_events WHERE workflow_slug = $1 AND run_id = $2 LIMIT 1`, [workflowSlug, runId]);
-    return result.rows.length > 0;
+    await client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
+    console.log(`[Migration 000] Schema '${schema}' created successfully`);
+  } catch (error) {
+    console.error(`[Migration 000] Error creating schema '${schema}':`, error);
+    throw error;
   } finally {
     client.release();
   }
 }
-
-// src/migrations.ts
-async function migration001_createTables(pool) {
+async function migration001_createTables(pool, schema) {
   const client = await pool.connect();
   try {
     await client.query(`
-      CREATE TABLE IF NOT EXISTS workflow_events (
+      CREATE TABLE IF NOT EXISTS ${schema}.workflow_events (
         id SERIAL PRIMARY KEY,
         event_id TEXT NOT NULL,
         workflow_slug TEXT NOT NULL,
@@ -5326,7 +5374,7 @@ async function migration001_createTables(pool) {
       )
     `);
     await client.query(`
-      CREATE TABLE IF NOT EXISTS step_events (
+      CREATE TABLE IF NOT EXISTS ${schema}.step_events (
         id SERIAL PRIMARY KEY,
         event_id TEXT NOT NULL,
         workflow_slug TEXT NOT NULL,
@@ -5340,7 +5388,7 @@ async function migration001_createTables(pool) {
       )
     `);
     await client.query(`
-      CREATE TABLE IF NOT EXISTS workflow_metadata (
+      CREATE TABLE IF NOT EXISTS ${schema}.workflow_metadata (
         slug TEXT PRIMARY KEY,
         name TEXT NOT NULL,
         description TEXT,
@@ -5351,7 +5399,7 @@ async function migration001_createTables(pool) {
       )
     `);
     await client.query(`
-      CREATE TABLE IF NOT EXISTS step_definitions (
+      CREATE TABLE IF NOT EXISTS ${schema}.step_definitions (
         workflow_slug TEXT NOT NULL,
         id TEXT NOT NULL,
         dependencies JSONB NOT NULL DEFAULT '{}',
@@ -5362,11 +5410,11 @@ async function migration001_createTables(pool) {
         retry_delay_ms INTEGER,
         created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
         PRIMARY KEY (workflow_slug, id),
-        FOREIGN KEY (workflow_slug) REFERENCES workflow_metadata(slug) ON DELETE CASCADE
+        FOREIGN KEY (workflow_slug) REFERENCES ${schema}.workflow_metadata(slug) ON DELETE CASCADE
       )
     `);
     await client.query(`
-      CREATE TABLE IF NOT EXISTS step_outputs (
+      CREATE TABLE IF NOT EXISTS ${schema}.step_outputs (
         workflow_slug TEXT NOT NULL,
         run_id TEXT NOT NULL,
         step_id TEXT NOT NULL,
@@ -5377,7 +5425,7 @@ async function migration001_createTables(pool) {
       )
     `);
     await client.query(`
-      CREATE TABLE IF NOT EXISTS idempotency_keys (
+      CREATE TABLE IF NOT EXISTS ${schema}.idempotency_keys (
         hash TEXT PRIMARY KEY,
         run_id TEXT NOT NULL,
         created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
@@ -5391,18 +5439,18 @@ async function migration001_createTables(pool) {
     client.release();
   }
 }
-async function migration002_addNormalizedColumns(pool) {
+async function migration002_addNormalizedColumns(pool, schema) {
   const client = await pool.connect();
   try {
     await client.query(`
-      ALTER TABLE step_events
+      ALTER TABLE ${schema}.step_events
       ADD COLUMN IF NOT EXISTS worker_id TEXT,
       ADD COLUMN IF NOT EXISTS attempt_number INTEGER,
       ADD COLUMN IF NOT EXISTS available_at_us BIGINT,
       ADD COLUMN IF NOT EXISTS export_output BOOLEAN
     `);
     await client.query(`
-      ALTER TABLE workflow_events
+      ALTER TABLE ${schema}.workflow_events
       ADD COLUMN IF NOT EXISTS workflow_attempt_number INTEGER,
       ADD COLUMN IF NOT EXISTS available_at_us BIGINT,
       ADD COLUMN IF NOT EXISTS priority INTEGER,
@@ -5417,65 +5465,65 @@ async function migration002_addNormalizedColumns(pool) {
     client.release();
   }
 }
-async function migration003_createIndexes(pool) {
+async function migration003_createIndexes(pool, schema) {
   const client = await pool.connect();
   try {
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_workflow_events_lookup
-      ON workflow_events (workflow_slug, run_id, timestamp_us)
+      ON ${schema}.workflow_events (workflow_slug, run_id, timestamp_us)
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_workflow_events_type
-      ON workflow_events (workflow_slug, run_id, type)
+      ON ${schema}.workflow_events (workflow_slug, run_id, type)
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_step_events_lookup
-      ON step_events (workflow_slug, run_id, step_id, timestamp_us)
+      ON ${schema}.step_events (workflow_slug, run_id, step_id, timestamp_us)
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_step_events_run
-      ON step_events (workflow_slug, run_id, timestamp_us)
+      ON ${schema}.step_events (workflow_slug, run_id, timestamp_us)
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_step_events_type
-      ON step_events (workflow_slug, run_id, type)
+      ON ${schema}.step_events (workflow_slug, run_id, type)
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_step_events_scheduled
-      ON step_events (workflow_slug, run_id, step_id, type, timestamp_us)
+      ON ${schema}.step_events (workflow_slug, run_id, step_id, type, timestamp_us)
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_step_definitions_workflow
-      ON step_definitions (workflow_slug)
+      ON ${schema}.step_definitions (workflow_slug)
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_step_events_worker_timestamp
-      ON step_events (worker_id, timestamp_us)
+      ON ${schema}.step_events (worker_id, timestamp_us)
       WHERE worker_id IS NOT NULL
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_step_events_available_at
-      ON step_events (type, available_at_us)
+      ON ${schema}.step_events (type, available_at_us)
       WHERE available_at_us IS NOT NULL
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_step_events_attempt
-      ON step_events (workflow_slug, run_id, step_id, attempt_number)
+      ON ${schema}.step_events (workflow_slug, run_id, step_id, attempt_number)
       WHERE attempt_number IS NOT NULL
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_workflow_events_priority
-      ON workflow_events (priority DESC, available_at_us)
+      ON ${schema}.workflow_events (priority DESC, available_at_us)
       WHERE priority IS NOT NULL
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_workflow_events_idempotency
-      ON workflow_events (idempotency_key)
+      ON ${schema}.workflow_events (idempotency_key)
       WHERE idempotency_key IS NOT NULL
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_workflow_events_timeout
-      ON workflow_events (workflow_slug, run_id, timeout_us)
+      ON ${schema}.workflow_events (workflow_slug, run_id, timeout_us)
       WHERE timeout_us IS NOT NULL
     `);
     console.log("[Migration 003] Indexes created successfully");
@@ -5486,11 +5534,11 @@ async function migration003_createIndexes(pool) {
     client.release();
   }
 }
-async function migration004_addErrorFingerprints(pool) {
+async function migration004_addErrorFingerprints(pool, schema) {
   const client = await pool.connect();
   try {
     await client.query(`
-      ALTER TABLE step_events
+      ALTER TABLE ${schema}.step_events
       ADD COLUMN IF NOT EXISTS error_name_hash TEXT NOT NULL DEFAULT '',
       ADD COLUMN IF NOT EXISTS error_message_hash TEXT NOT NULL DEFAULT '',
       ADD COLUMN IF NOT EXISTS error_stack_exact_hash TEXT NOT NULL DEFAULT '',
@@ -5499,17 +5547,17 @@ async function migration004_addErrorFingerprints(pool) {
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_error_fp_exact
-      ON step_events(error_name_hash, error_message_hash, error_stack_exact_hash)
+      ON ${schema}.step_events(error_name_hash, error_message_hash, error_stack_exact_hash)
       WHERE type = 'StepFailed'
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_error_fp_normalized
-      ON step_events(error_name_hash, error_message_hash, error_stack_normalized_hash)
+      ON ${schema}.step_events(error_name_hash, error_message_hash, error_stack_normalized_hash)
       WHERE type = 'StepFailed'
     `);
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_error_fp_portable
-      ON step_events(error_name_hash, error_message_hash, error_stack_portable_hash)
+      ON ${schema}.step_events(error_name_hash, error_message_hash, error_stack_portable_hash)
       WHERE type = 'StepFailed'
     `);
     console.log("[Migration 004] Error fingerprint columns and indexes added successfully");
@@ -5520,13 +5568,64 @@ async function migration004_addErrorFingerprints(pool) {
     client.release();
   }
 }
-async function runMigrations(pool) {
-  console.log("[Migrations] Starting database migrations...");
+async function migration005_addWorkflowVersioning(pool, schema) {
+  const client = await pool.connect();
+  try {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS ${schema}.workflow_versions (
+        workflow_slug TEXT NOT NULL,
+        version_id TEXT NOT NULL,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        step_manifest TEXT[] NOT NULL,
+        total_steps INTEGER NOT NULL,
+        git_commit TEXT,
+        git_dirty BOOLEAN,
+        git_branch TEXT,
+        PRIMARY KEY (workflow_slug, version_id),
+        FOREIGN KEY (workflow_slug) REFERENCES ${schema}.workflow_metadata(slug) ON DELETE CASCADE
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_versions_slug
+      ON ${schema}.workflow_versions(workflow_slug)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_versions_created
+      ON ${schema}.workflow_versions(workflow_slug, created_at DESC)
+    `);
+    await client.query(`
+      ALTER TABLE ${schema}.workflow_events
+      ADD COLUMN IF NOT EXISTS version_id TEXT NOT NULL
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_version
+      ON ${schema}.workflow_events(workflow_slug, run_id, version_id)
+    `);
+    await client.query(`
+      ALTER TABLE ${schema}.step_events
+      ADD COLUMN IF NOT EXISTS version_id TEXT NOT NULL
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_version
+      ON ${schema}.step_events(workflow_slug, version_id)
+    `);
+    console.log("[Migration 005] Workflow versioning support added successfully");
+  } catch (error) {
+    console.error("[Migration 005] Error adding workflow versioning:", error);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function runMigrations(pool, schema = "cascadeflow") {
+  console.log(`[Migrations] Starting database migrations in schema '${schema}'...`);
   try {
-    await migration001_createTables(pool);
-    await migration002_addNormalizedColumns(pool);
-    await migration003_createIndexes(pool);
-    await migration004_addErrorFingerprints(pool);
+    await migration000_createSchema(pool, schema);
+    await migration001_createTables(pool, schema);
+    await migration002_addNormalizedColumns(pool, schema);
+    await migration003_createIndexes(pool, schema);
+    await migration004_addErrorFingerprints(pool, schema);
+    await migration005_addWorkflowVersioning(pool, schema);
     console.log("[Migrations] All migrations completed successfully");
   } catch (error) {
     console.error("[Migrations] Migration failed:", error);
@@ -5536,17 +5635,18 @@ async function runMigrations(pool) {
 
 // src/index.ts
 class PostgresBackend extends Backend {
-  pool;
+  db;
   initialized = false;
-  constructor(connectionString) {
+  constructor(connectionString, schema = "cascadeflow") {
     super();
-    this.pool = createPool(connectionString);
+    const pool = createPool(connectionString);
+    this.db = new DatabaseClient(pool, schema);
   }
   async initialize() {
     if (this.initialized) {
       return;
     }
-    await runMigrations(this.pool);
+    await runMigrations(this.db.getPool(), this.db.getSchema());
     this.initialized = true;
   }
   generateRunId() {
@@ -5561,10 +5661,10 @@ class PostgresBackend extends Backend {
   }
   async initializeRun(workflowSlug, runId) {}
   async runExists(workflowSlug, runId) {
-    return runExists(this.pool, workflowSlug, runId);
+    return this.db.runExists(workflowSlug, runId);
   }
   async loadRun(workflowSlug, runId) {
-    const events = await loadAllRunEvents(this.pool, workflowSlug, runId);
+    const events = await this.db.loadAllRunEvents(workflowSlug, runId);
     const stepEvents = new Map;
     for (const event of events) {
       if (event.category === "step") {
@@ -5594,22 +5694,22 @@ class PostgresBackend extends Backend {
     }
     eventSchema.parse(event);
     const table = event.category === "workflow" ? "workflow_events" : "step_events";
-    await appendEvent(this.pool, table, event);
+    await this.db.appendEvent(table, event);
   }
   async loadEvents(workflowSlug, runId, options) {
     if (options?.category === "workflow") {
-      return loadEvents(this.pool, "workflow_events", {
+      return this.db.loadEvents("workflow_events", {
         workflowSlug,
         runId
       });
     } else if (options?.category === "step") {
-      return loadEvents(this.pool, "step_events", {
+      return this.db.loadEvents("step_events", {
         workflowSlug,
         runId,
         stepId: options.stepId
       });
     } else {
-      return loadAllRunEvents(this.pool, workflowSlug, runId);
+      return this.db.loadAllRunEvents(workflowSlug, runId);
     }
   }
   async saveStepScheduled(workflowSlug, runId, stepId, metadata) {
@@ -5627,7 +5727,7 @@ class PostgresBackend extends Backend {
       attemptNumber: metadata.attemptNumber,
       retryDelayMs: metadata.retryDelayMs
     };
-    await appendEvent(this.pool, "step_events", event);
+    await this.db.appendEvent("step_events", event);
   }
   async saveStepStart(workflowSlug, runId, stepId, workerId, metadata) {
     const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
@@ -5645,7 +5745,7 @@ class PostgresBackend extends Backend {
       workerId,
       dependencies: metadata.dependencies
     };
-    await appendEvent(this.pool, "step_events", event);
+    await this.db.appendEvent("step_events", event);
   }
   async saveStepComplete(workflowSlug, runId, stepId, output, metadata, exportOutput = false) {
     const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
@@ -5668,7 +5768,7 @@ class PostgresBackend extends Backend {
           message: log.message,
           attemptNumber
         };
-        await appendEvent(this.pool, "step_events", logEvent);
+        await this.db.appendEvent("step_events", logEvent);
       }
     }
     const serialized = safeSerialize(output);
@@ -5687,7 +5787,7 @@ class PostgresBackend extends Backend {
       attemptNumber,
       exportOutput
     };
-    await appendEvent(this.pool, "step_events", event);
+    await this.db.appendEvent("step_events", event);
   }
   async saveStepFailed(workflowSlug, runId, stepId, error, metadata) {
     const now = getMicrosecondTimestamp();
@@ -5707,10 +5807,10 @@ class PostgresBackend extends Backend {
       nextRetryAtUs: metadata.nextRetryAt,
       failureReason: metadata.failureReason
     };
-    await appendEvent(this.pool, "step_events", event);
+    await this.db.appendEvent("step_events", event);
   }
   async saveStepFailedAndScheduleRetry(workflowSlug, runId, stepId, error, failureMetadata, scheduleMetadata) {
-    const client = await this.pool.connect();
+    const client = await this.db.getPool().connect();
     try {
       await client.query("BEGIN");
       const failedTimestamp = getMicrosecondTimestamp();
@@ -5732,7 +5832,7 @@ class PostgresBackend extends Backend {
         nextRetryAtUs: failureMetadata.nextRetryAt,
         failureReason: failureMetadata.failureReason
       };
-      await appendEventWithClient(client, "step_events", failedEvent);
+      await this.db.appendEventWithClient(client, "step_events", failedEvent);
       const retryingEvent = {
         category: "step",
         type: "StepRetrying",
@@ -5746,7 +5846,7 @@ class PostgresBackend extends Backend {
         maxRetries: scheduleMetadata.maxRetries,
         error
       };
-      await appendEventWithClient(client, "step_events", retryingEvent);
+      await this.db.appendEventWithClient(client, "step_events", retryingEvent);
       const scheduledEvent = {
         category: "step",
         type: "StepScheduled",
@@ -5760,7 +5860,7 @@ class PostgresBackend extends Backend {
         attemptNumber: scheduleMetadata.nextAttemptNumber,
         retryDelayMs: scheduleMetadata.retryDelayMs
       };
-      await appendEventWithClient(client, "step_events", scheduledEvent);
+      await this.db.appendEventWithClient(client, "step_events", scheduledEvent);
       await client.query("COMMIT");
     } catch (error2) {
       await client.query("ROLLBACK");
@@ -5786,7 +5886,7 @@ class PostgresBackend extends Backend {
       attemptNumber: metadata.attemptNumber,
       cascadedFrom: metadata.cascadedFrom
     };
-    await appendEvent(this.pool, "step_events", event);
+    await this.db.appendEvent("step_events", event);
   }
   async saveStepHeartbeat(workflowSlug, runId, stepId, workerId, attemptNumber) {
     const now = getMicrosecondTimestamp();
@@ -5801,7 +5901,7 @@ class PostgresBackend extends Backend {
       workerId,
       attemptNumber
     };
-    await appendEvent(this.pool, "step_events", event);
+    await this.db.appendEvent("step_events", event);
   }
   async saveStepReclaimed(workflowSlug, runId, stepId, metadata) {
     const now = getMicrosecondTimestamp();
@@ -5820,7 +5920,7 @@ class PostgresBackend extends Backend {
       staleDurationUs: metadata.staleDuration,
       attemptNumber: metadata.attemptNumber
     };
-    await appendEvent(this.pool, "step_events", event);
+    await this.db.appendEvent("step_events", event);
   }
   async saveStepLogs(workflowSlug, runId, stepId, logs) {}
   async loadStepLogs(workflowSlug, runId, stepId, attemptNumber) {
@@ -5840,11 +5940,12 @@ class PostgresBackend extends Backend {
       timestampUs: timestamp,
       workflowSlug,
       runId,
+      versionId: metadata.versionId,
       workflowAttemptNumber: metadata.workflowAttemptNumber,
       hasInputSchema: metadata.hasInputSchema,
       hasInput: metadata.hasInput
     };
-    await appendEvent(this.pool, "workflow_events", event);
+    await this.db.appendEvent("workflow_events", event);
   }
   async saveWorkflowInputValidation(workflowSlug, runId, result) {
     const timestamp = getMicrosecondTimestamp();
@@ -5857,7 +5958,7 @@ class PostgresBackend extends Backend {
       runId,
       ...result
     };
-    await appendEvent(this.pool, "workflow_events", event);
+    await this.db.appendEvent("workflow_events", event);
   }
   async saveWorkflowComplete(workflowSlug, runId, output, metadata) {
     const timestamp = getMicrosecondTimestamp();
@@ -5873,7 +5974,7 @@ class PostgresBackend extends Backend {
       durationUs: metadata.duration,
       totalSteps: metadata.totalSteps
     };
-    await appendEvent(this.pool, "workflow_events", event);
+    await this.db.appendEvent("workflow_events", event);
   }
   async saveWorkflowFailed(workflowSlug, runId, error, metadata, failureReason) {
     const timestamp = getMicrosecondTimestamp();
@@ -5891,7 +5992,7 @@ class PostgresBackend extends Backend {
       failedStep: metadata.failedStep,
       failureReason
     };
-    await appendEvent(this.pool, "workflow_events", event);
+    await this.db.appendEvent("workflow_events", event);
   }
   async saveWorkflowResumed(workflowSlug, runId, metadata) {
     const timestamp = getMicrosecondTimestamp();
@@ -5906,7 +6007,7 @@ class PostgresBackend extends Backend {
       resumedSteps: metadata.resumedSteps,
       pendingSteps: metadata.pendingSteps
     };
-    await appendEvent(this.pool, "workflow_events", event);
+    await this.db.appendEvent("workflow_events", event);
   }
   async saveWorkflowCancelled(workflowSlug, runId, metadata) {
     const timestamp = getMicrosecondTimestamp();
@@ -5922,7 +6023,7 @@ class PostgresBackend extends Backend {
       durationUs: metadata.duration,
       completedSteps: metadata.completedSteps
     };
-    await appendEvent(this.pool, "workflow_events", event);
+    await this.db.appendEvent("workflow_events", event);
   }
   async saveWorkflowRetryStarted(workflowSlug, runId, metadata) {
     const timestamp = getMicrosecondTimestamp();
@@ -5938,7 +6039,7 @@ class PostgresBackend extends Backend {
       retriedSteps: metadata.retriedSteps,
       reason: metadata.reason
     };
-    await appendEvent(this.pool, "workflow_events", event);
+    await this.db.appendEvent("workflow_events", event);
   }
   async saveRunSubmitted(workflowSlug, runId, metadata) {
     const timestamp = getMicrosecondTimestamp();
@@ -5949,6 +6050,7 @@ class PostgresBackend extends Backend {
       timestampUs: timestamp,
       workflowSlug,
       runId,
+      versionId: metadata.versionId,
       availableAtUs: metadata.availableAt,
       priority: metadata.priority,
       input: metadata.input,
@@ -5958,13 +6060,13 @@ class PostgresBackend extends Backend {
       metadata: metadata.metadata,
       tags: metadata.tags
     };
-    await appendEvent(this.pool, "workflow_events", event);
+    await this.db.appendEvent("workflow_events", event);
   }
   async submitRun(submission) {
     if (submission.idempotencyKey) {
       const hash = this.hashIdempotencyKey(submission.idempotencyKey);
       const proposedRunId = submission.runId || this.generateRunId();
-      const existingRunId = await saveIdempotencyKey(this.pool, hash, proposedRunId);
+      const existingRunId = await this.db.saveIdempotencyKey(hash, proposedRunId);
       if (existingRunId !== proposedRunId) {
         return { runId: existingRunId, isNew: false };
       }
@@ -5974,11 +6076,18 @@ class PostgresBackend extends Backend {
     const availableAt = submission.availableAt || now;
     const priority = submission.priority || 0;
     await this.initializeRun(submission.workflowSlug, runId);
+    const workflowMetadata = await this.getWorkflowMetadata(submission.workflowSlug);
+    const hasInputSchema = !!workflowMetadata?.inputSchemaJSON;
+    const currentVersion = await this.getCurrentWorkflowVersion(submission.workflowSlug);
+    if (!currentVersion) {
+      throw new Error(`Workflow ${submission.workflowSlug} not registered. Please ensure the worker has started and registered workflows.`);
+    }
     await this.saveRunSubmitted(submission.workflowSlug, runId, {
+      versionId: currentVersion.versionId,
       availableAt,
       priority,
       input: submission.input !== undefined ? JSON.stringify(submission.input) : undefined,
-      hasInputSchema: false,
+      hasInputSchema,
       timeout: submission.timeout,
       idempotencyKey: submission.idempotencyKey,
       metadata: submission.metadata,
@@ -5988,12 +6097,12 @@ class PostgresBackend extends Backend {
   }
   async listRuns(options) {
     const allRuns = [];
-    const workflows = options?.workflowSlug ? [options.workflowSlug] : await listActiveWorkflows(this.pool);
+    const workflows = options?.workflowSlug ? [options.workflowSlug] : await this.db.listActiveWorkflows();
     for (const workflowSlug of workflows) {
-      const runIds = await listRunIds(this.pool, workflowSlug);
+      const runIds = await this.db.listRunIds(workflowSlug);
       for (const runId of runIds) {
         try {
-          const events = await loadAllRunEvents(this.pool, workflowSlug, runId);
+          const events = await this.db.loadAllRunEvents(workflowSlug, runId);
           if (events.length === 0)
             continue;
           const workflowEvents = events.filter((e) => e.category === "workflow");
@@ -6018,9 +6127,9 @@ class PostgresBackend extends Backend {
     return options?.limit ? allRuns.slice(0, options.limit) : allRuns;
   }
   async cancelRun(runId, reason) {
-    const allWorkflows = await listActiveWorkflows(this.pool);
+    const allWorkflows = await this.db.listActiveWorkflows();
     for (const workflowSlug of allWorkflows) {
-      const runIds = await listRunIds(this.pool, workflowSlug);
+      const runIds = await this.db.listRunIds(workflowSlug);
       if (runIds.includes(runId)) {
         const events = await this.loadEvents(workflowSlug, runId, { category: "workflow" });
         if (events.length === 0)
@@ -6041,11 +6150,11 @@ class PostgresBackend extends Backend {
     throw new Error(`Run ${runId} not found`);
   }
   async getRun(runId) {
-    const allWorkflows = await listActiveWorkflows(this.pool);
+    const allWorkflows = await this.db.listActiveWorkflows();
     for (const workflowSlug of allWorkflows) {
-      const runIds = await listRunIds(this.pool, workflowSlug);
+      const runIds = await this.db.listRunIds(workflowSlug);
       if (runIds.includes(runId)) {
-        const events = await loadAllRunEvents(this.pool, workflowSlug, runId);
+        const events = await this.db.loadAllRunEvents(workflowSlug, runId);
         const workflowEvents = events.filter((e) => e.category === "workflow");
         return projectRunStateFromEvents(workflowEvents, workflowSlug);
       }
@@ -6079,17 +6188,17 @@ class PostgresBackend extends Backend {
     return failedSteps;
   }
   async listActiveWorkflows() {
-    return listActiveWorkflows(this.pool);
+    return this.db.listActiveWorkflows();
   }
   async listScheduledSteps(options) {
     const dbOptions = {
       workflowSlugs: options?.workflowSlug ? [options.workflowSlug] : undefined,
       limit: options?.limit
     };
-    return listScheduledSteps(this.pool, dbOptions);
+    return this.db.listScheduledSteps(dbOptions);
   }
   async isStepClaimable(workflowSlug, runId, stepId) {
-    const events = await loadEvents(this.pool, "step_events", {
+    const events = await this.db.loadEvents("step_events", {
       workflowSlug,
       runId,
       stepId
@@ -6098,7 +6207,7 @@ class PostgresBackend extends Backend {
       return false;
     }
     const latestEvent = events[events.length - 1];
-    return latestEvent.type === "StepScheduled" || latestEvent.type === "StepReclaimed" || latestEvent.type === "StepRetrying";
+    return !!(latestEvent && (latestEvent.type === "StepScheduled" || latestEvent.type === "StepReclaimed" || latestEvent.type === "StepRetrying"));
   }
   async claimScheduledStep(workflowSlug, runId, stepId, workerId, metadata) {
     const initialEvents = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
@@ -6124,13 +6233,13 @@ class PostgresBackend extends Backend {
       dependencies: metadata.dependencies,
       attemptNumber
     };
-    const claimed = await claimScheduledStep(this.pool, workflowSlug, runId, stepId, workerId, event);
+    const claimed = await this.db.claimScheduledStep(workflowSlug, runId, stepId, workerId, event);
     return claimed ? { attemptNumber } : null;
   }
   async reclaimStaleSteps(staleThreshold, reclaimedBy) {
     const reclaimed = [];
     const now = getMicrosecondTimestamp();
-    const staleSteps = await findStaleSteps(this.pool, staleThreshold);
+    const staleSteps = await this.db.findStaleSteps(staleThreshold);
     for (const step of staleSteps) {
       const events = await this.loadEvents(step.workflowSlug, step.runId, { category: "step", stepId: step.stepId });
       if (events.length === 0)
@@ -6152,7 +6261,7 @@ class PostgresBackend extends Backend {
         await this.saveStepScheduled(step.workflowSlug, step.runId, step.stepId, {
           availableAt: now,
           reason: "retry",
-          attemptNumber: state.attemptNumber,
+          attemptNumber: state.attemptNumber + 1,
           retryDelayMs: 0
         });
         reclaimed.push({ workflowSlug: step.workflowSlug, runId: step.runId, stepId: step.stepId });
@@ -6161,25 +6270,107 @@ class PostgresBackend extends Backend {
     return reclaimed;
   }
   async registerWorkflow(registration) {
-    await upsertWorkflowMetadata(this.pool, registration.slug, registration.name, registration.location, registration.inputSchemaJSON);
+    await this.db.upsertWorkflowMetadata(registration.slug, registration.name, registration.location, registration.inputSchemaJSON);
     for (const step of registration.steps) {
-      await upsertStepDefinition(this.pool, registration.slug, step);
+      await this.db.upsertStepDefinition(registration.slug, step);
     }
   }
   async getWorkflowMetadata(slug) {
-    return getWorkflowMetadata(this.pool, slug);
+    return this.db.getWorkflowMetadata(slug);
   }
   async listWorkflowMetadata() {
-    return listWorkflowMetadata(this.pool);
+    return this.db.listWorkflowMetadata();
   }
   async getWorkflowSteps(slug) {
-    return getWorkflowSteps(this.pool, slug);
+    return this.db.getWorkflowSteps(slug);
   }
   async listRunIds(workflowSlug) {
-    return listRunIds(this.pool, workflowSlug);
+    return this.db.listRunIds(workflowSlug);
+  }
+  async createWorkflowVersion(version) {
+    await this.db.getPool().query(`
+      INSERT INTO ${this.db.getSchema()}.workflow_versions
+      (workflow_slug, version_id, created_at, step_manifest, total_steps, git_commit, git_dirty, git_branch)
+      VALUES ($1, $2, to_timestamp($3 / 1000000.0), $4, $5, $6, $7, $8)
+      ON CONFLICT (workflow_slug, version_id) DO NOTHING
+    `, [
+      version.workflowSlug,
+      version.versionId,
+      version.createdAt,
+      version.stepManifest,
+      version.totalSteps,
+      version.git?.commit,
+      version.git?.dirty,
+      version.git?.branch
+    ]);
+  }
+  async getWorkflowVersion(workflowSlug, versionId) {
+    const result = await this.db.getPool().query(`
+      SELECT * FROM ${this.db.getSchema()}.workflow_versions
+      WHERE workflow_slug = $1 AND version_id = $2
+    `, [workflowSlug, versionId]);
+    if (result.rows.length === 0)
+      return null;
+    const row = result.rows[0];
+    return {
+      workflowSlug: row.workflow_slug,
+      versionId: row.version_id,
+      createdAt: Math.floor(new Date(row.created_at).getTime() * 1000),
+      stepManifest: row.step_manifest,
+      totalSteps: row.total_steps,
+      git: row.git_commit ? {
+        commit: row.git_commit,
+        dirty: row.git_dirty,
+        branch: row.git_branch
+      } : undefined
+    };
+  }
+  async getCurrentWorkflowVersion(workflowSlug) {
+    const result = await this.db.getPool().query(`
+      SELECT * FROM ${this.db.getSchema()}.workflow_versions
+      WHERE workflow_slug = $1
+      ORDER BY created_at DESC
+      LIMIT 1
+    `, [workflowSlug]);
+    if (result.rows.length === 0)
+      return null;
+    const row = result.rows[0];
+    return {
+      workflowSlug: row.workflow_slug,
+      versionId: row.version_id,
+      createdAt: Math.floor(new Date(row.created_at).getTime() * 1000),
+      stepManifest: row.step_manifest,
+      totalSteps: row.total_steps,
+      git: row.git_commit ? {
+        commit: row.git_commit,
+        dirty: row.git_dirty,
+        branch: row.git_branch
+      } : undefined
+    };
+  }
+  async listWorkflowVersions(workflowSlug, options) {
+    const limit = options?.limit ?? 100;
+    const result = await this.db.getPool().query(`
+      SELECT * FROM ${this.db.getSchema()}.workflow_versions
+      WHERE workflow_slug = $1
+      ORDER BY created_at DESC
+      LIMIT $2
+    `, [workflowSlug, limit]);
+    return result.rows.map((row) => ({
+      workflowSlug: row.workflow_slug,
+      versionId: row.version_id,
+      createdAt: Math.floor(new Date(row.created_at).getTime() * 1000),
+      stepManifest: row.step_manifest,
+      totalSteps: row.total_steps,
+      git: row.git_commit ? {
+        commit: row.git_commit,
+        dirty: row.git_dirty,
+        branch: row.git_branch
+      } : undefined
+    }));
   }
   async close() {
-    await this.pool.end();
+    await this.db.getPool().end();
   }
   async loadEventsForAnalytics(options) {
     const now = getMicrosecondTimestamp();
@@ -6187,7 +6378,7 @@ class PostgresBackend extends Backend {
     const endUs = options?.endUs ?? now;
     let stepQuery = `
       SELECT event_data
-      FROM step_events
+      FROM ${this.db.getSchema()}.step_events
       WHERE timestamp_us >= $1 AND timestamp_us <= $2
     `;
     const stepParams = [startUs, endUs];
@@ -6211,7 +6402,7 @@ class PostgresBackend extends Backend {
     stepQuery += ` ORDER BY timestamp_us ASC`;
     let workflowQuery = `
       SELECT event_data
-      FROM workflow_events
+      FROM ${this.db.getSchema()}.workflow_events
       WHERE timestamp_us >= $1 AND timestamp_us <= $2
     `;
     const workflowParams = [startUs, endUs];
@@ -6229,8 +6420,8 @@ class PostgresBackend extends Backend {
     }
     workflowQuery += ` ORDER BY timestamp_us ASC`;
     const [stepResult, workflowResult] = await Promise.all([
-      this.pool.query(stepQuery, stepParams),
-      options?.stepId ? Promise.resolve({ rows: [] }) : this.pool.query(workflowQuery, workflowParams)
+      this.db.getPool().query(stepQuery, stepParams),
+      options?.stepId ? Promise.resolve({ rows: [] }) : this.db.getPool().query(workflowQuery, workflowParams)
     ]);
     const stepEvents = stepResult.rows.map((row) => row.event_data);
     const workflowEvents = workflowResult.rows.map((row) => row.event_data);
@@ -6264,10 +6455,10 @@ class PostgresBackend extends Backend {
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     const countQuery = `
       SELECT COUNT(DISTINCT CONCAT(error_name_hash, ':', error_message_hash, ':', ${stackHashColumn})) as total
-      FROM step_events
+      FROM ${this.db.getSchema()}.step_events
       ${whereClause}
     `;
-    const countResult = await this.pool.query(countQuery, params);
+    const countResult = await this.db.getPool().query(countQuery, params);
     const total = parseInt(countResult.rows[0]?.total || "0", 10);
     const query = `
       SELECT
@@ -6279,7 +6470,7 @@ class PostgresBackend extends Backend {
         COUNT(DISTINCT run_id) as affected_runs,
         MIN(timestamp_us) as first_seen,
         MAX(timestamp_us) as last_seen
-      FROM step_events
+      FROM ${this.db.getSchema()}.step_events
       ${whereClause}
       GROUP BY
         error_name_hash,
@@ -6288,7 +6479,7 @@ class PostgresBackend extends Backend {
       ORDER BY count DESC
       LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
     `;
-    const result = await this.pool.query(query, [...params, limit, offset]);
+    const result = await this.db.getPool().query(query, [...params, limit, offset]);
     const errors = result.rows.map((row) => ({
       fingerprint: row.fingerprint,
       errorMessage: row.error_message || "",
@@ -6336,10 +6527,10 @@ class PostgresBackend extends Backend {
         COUNT(DISTINCT run_id) as affected_runs,
         MIN(timestamp_us) as first_seen,
         MAX(timestamp_us) as last_seen
-      FROM step_events
+      FROM ${this.db.getSchema()}.step_events
       ${whereClause}
     `;
-    const statsResult = await this.pool.query(statsQuery, params.slice(0, paramIndex - 1));
+    const statsResult = await this.db.getPool().query(statsQuery, params.slice(0, paramIndex - 1));
     if (statsResult.rows.length === 0) {
       return {
         fingerprint,
@@ -6362,12 +6553,12 @@ class PostgresBackend extends Backend {
         step_id,
         (event_data->>'attemptNumber')::int as attempt_number,
         timestamp_us
-      FROM step_events
+      FROM ${this.db.getSchema()}.step_events
       ${whereClause}
       ORDER BY timestamp_us DESC
       LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
     `;
-    const occurrencesResult = await this.pool.query(occurrencesQuery, [
+    const occurrencesResult = await this.db.getPool().query(occurrencesQuery, [
       ...params.slice(0, paramIndex - 1),
       limit,
       offset
@@ -6580,4 +6771,4 @@ export {
   PostgresBackend
 };
 
-//# debugId=DB43B87A3D4751F864756E2164756E21
+//# debugId=9ABA79C867582FE764756E2164756E21