@reaatech/media-pipeline-mcp-persistence 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Media Pipeline MCP Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,247 @@
+# @reaatech/media-pipeline-mcp-persistence
+
+[![npm version](https://img.shields.io/npm/v/@reaatech/media-pipeline-mcp-persistence)](https://www.npmjs.com/package/@reaatech/media-pipeline-mcp-persistence)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/reaatech/media-pipeline-mcp/blob/main/LICENSE)
+[![CI](https://github.com/reaatech/media-pipeline-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/reaatech/media-pipeline-mcp/actions/workflows/ci.yml)
+
+> **Status:** Pre-1.0 — APIs may change in minor versions. Pin to a specific version in production.
+
+Pipeline state store abstractions with in-memory and Redis implementations. Provides optimistic locking, run lifecycle management, event log persistence, and tenant-scoped queries for multi-tenant pipeline orchestration.
+
+## Installation
+
+```bash
+npm install @reaatech/media-pipeline-mcp-persistence
+```
+
+```bash
+pnpm add @reaatech/media-pipeline-mcp-persistence
+```
+
+The Redis backend requires the optional `ioredis` peer dependency:
+
+```bash
+pnpm add ioredis
+```
+
+## Feature Overview
+
+- In-memory store for development and single-process deployments
+- Redis-backed store with TTL-managed keys, per-tenant zset indexes, and external job ID mappings
+- Optimistic locking with expected-version conflict detection (`update(runId, patch, expectedVersion)`)
+- Exclusive write lock via `withLock()` — in-memory mutex for single-process, `SET NX EX` for Redis
+- Canonical event taxonomy with 12 event types tracking the full run lifecycle
+- Run filtering by status, tenant, idempotency key, and time window
+- Idempotency key deduplication preventing duplicate run creation
+- External job ID lookup for webhook-based provider integrations
+
+## Quick Start
+
+```typescript
+import { InMemoryPipelineStateStore } from '@reaatech/media-pipeline-mcp-persistence';
+
+const store = new InMemoryPipelineStateStore();
+
+// Create a pipeline run
+await store.create({
+  runId: 'run-42',
+  pipelineId: 'product-photo',
+  status: 'pending',
+  tenantId: 'acme',
+  pipelineDefHash: 'sha256-abc123',
+  currentStepIndex: 0,
+  steps: [
+    {
+      stepId: 'gen',
+      operation: 'image.generate',
+      inputs: { prompt: 'A product photo of a sneaker' },
+      status: 'pending',
+      attempts: 0,
+      maxRetries: 2,
+      artifactIds: [],
+      costUsd: 0,
+    },
+  ],
+  events: [],
+  externalJobIds: {},
+  version: 1,
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
+});
+
+// Append events as the run progresses
+await store.appendEvent('run-42', {
+  kind: 'run-started',
+  runId: 'run-42',
+  at: Date.now(),
+});
+await store.appendEvent('run-42', {
+  kind: 'step-started',
+  runId: 'run-42',
+  stepId: 'gen',
+  at: Date.now(),
+  attempt: 1,
+});
+await store.appendEvent('run-42', {
+  kind: 'step-completed',
+  runId: 'run-42',
+  stepId: 'gen',
+  at: Date.now(),
+  artifactIds: ['artifact-99'],
+  costUsd: 0.014,
+});
+await store.appendEvent('run-42', {
+  kind: 'run-completed',
+  runId: 'run-42',
+  at: Date.now(),
+  totalCostUsd: 0.014,
+});
+
+// Update with optimistic locking
+await store.update(
+  'run-42',
+  { status: 'completed', completedAt: new Date().toISOString() },
+  1, // expectedVersion — fails if another writer updated first
+);
+
+// Replay events (for reconnect/resume)
+const events = await store.listEvents('run-42', /* sinceSeq */ 0);
+
+// Query runs by tenant
+const runs = await store.listRuns({
+  tenantId: 'acme',
+  status: 'completed',
+  since: '2026-01-01T00:00:00Z',
+  limit: 10,
+  offset: 0,
+});
+
+// Cancel a run
+await store.cancel('run-42', 'User requested cancellation');
+```
+
+### Redis
+
+```typescript
+import { Redis } from 'ioredis';
+import { RedisPipelineStateStore } from '@reaatech/media-pipeline-mcp-persistence';
+
+const redis = new Redis();
+const store = new RedisPipelineStateStore({
+  client: redis,
+  prefix: 'mp',
+  runTtlSeconds: 30 * 86400,   // 30 days
+  lockTtlSeconds: 60,           // 60s lock TTL
+  idempotencyTtlSeconds: 86400, // 24h
+  externalJobTtlSeconds: 7 * 86400, // 7 days
+  lockAcquireTimeoutMs: 5000,   // 5s max wait for lock
+});
+
+// Locked mutation
+const result = await store.withLock('run-42', async (run) => {
+  // Safe to mutate — exclusive lock held
+  return performCriticalUpdate(run);
+}, /* timeoutMs */ 10_000);
+```
+
+## API Reference
+
+### Types
+
+| Type | Description |
+|------|-------------|
+| `PipelineRunStatus` | `'pending' \| 'running' \| 'suspended' \| 'completed' \| 'failed' \| 'cancelled'` |
+| `StepStatus` | `'pending' \| 'running' \| 'completed' \| 'failed' \| 'gated' \| 'cached' \| 'cancelled'` |
+| `StepState` | Per-step state: operation, status, attempts, artifact IDs, cost, error, timestamps, cache key |
+| `PipelineRun` | Full run record: status, steps, events, version, timestamps, idempotency key, external job IDs |
+| `PipelineEvent` | Discriminated union of 12 event types (`run-created`, `run-started`, `step-started`, `step-progress`, `step-cached`, `step-completed`, `step-failed`, `step-gated`, `run-suspended`, `run-resumed`, `run-completed`, `run-failed`) |
+| `RunFilter` | Query filter: status (single or array), tenantId, idempotencyKey, since/until time window, limit/offset |
+| `PipelineStateStore` | Interface: `create()`, `get()`, `update()`, `cancel()`, `appendEvent()`, `listEvents()`, `listRuns()`, `findByExternalJobId()`, `withLock()` |
+
+### Classes
+
+| Class | Description |
+|-------|-------------|
+| `InMemoryPipelineStateStore` | In-process store with Map-based storage and async-mutex locking. Single-process only. |
+| `RedisPipelineStateStore` | Redis-backed store with TTL-managed keys, tenant zset indexes, and `SET NX EX` distributed locking. |
+
+**`RedisPipelineStateStoreConfig`:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `client` | `RedisClientLike` | _(required)_ | ioredis-compatible client |
+| `prefix` | `string` | `'mp'` | Redis key namespace |
+| `runTtlSeconds` | `number` | `2_592_000` (30d) | TTL for run, events, and tenant index keys |
+| `lockTtlSeconds` | `number` | `60` | Lock TTL (SET NX EX) |
+| `idempotencyTtlSeconds` | `number` | `86_400` (24h) | Idempotency entry TTL |
+| `externalJobTtlSeconds` | `number` | `604_800` (7d) | External job mapping TTL |
+| `lockAcquireTimeoutMs` | `number` | `5_000` | Max time to wait for lock acquisition |
+| `lockPollIntervalMs` | `number` | `100` | Poll interval during lock acquisition |
+
+### Event Taxonomy
+
+| Event | Description |
+|-------|-------------|
+| `run-created` | Run initialized with pipeline definition hash |
+| `run-started` | Execution has begun |
+| `step-started` | Step execution started (includes attempt counter) |
+| `step-progress` | In-flight progress with percentage, ETA, accrued cost |
+| `step-cached` | Step result retrieved from cache |
+| `step-completed` | Step finished successfully with artifact IDs and cost |
+| `step-failed` | Step failed with error code and retryability flag |
+| `step-gated` | Step blocked by quality gate with gate type and verdict |
+| `run-suspended` | Execution suspended (webhook, budget, or gate) with resume token |
+| `run-resumed` | Execution resumed from a specific step |
+| `run-completed` | Pipeline finished successfully with total cost |
+| `run-failed` | Pipeline terminated with error code and terminal reason |
+
+## Usage Patterns
+
+### Optimistic Locking
+
+```typescript
+async function atomicStepComplete(runId: string, stepId: string, currentVersion: number) {
+  await store.update(runId, {
+    steps: updatedSteps,
+    currentStepIndex: nextIndex,
+  }, currentVersion); // Throws RunInProgressError if version mismatch
+}
+```
+
+### Idempotent Run Creation
+
+```typescript
+async function createIfAbsent(run: PipelineRun) {
+  const existing = await store.listRuns({ idempotencyKey: run.idempotencyKey });
+  if (existing.length > 0) return existing[0];
+  await store.create(run);
+  return run;
+}
+```
+
+### Webhook Callback Resolution
+
+```typescript
+// When a provider webhook reports job completion
+async function onJobComplete(provider: string, jobId: string, result: unknown) {
+  const run = await store.findByExternalJobId(provider, jobId);
+  if (!run) return; // Stale / unknown callback
+  await store.appendEvent(run.runId, {
+    kind: 'step-completed',
+    runId: run.runId,
+    stepId: currentStep(run).stepId,
+    at: Date.now(),
+    artifactIds: [result.id],
+    costUsd: result.cost,
+  });
+}
+```
+
+## Related Packages
+
+- [@reaatech/media-pipeline-mcp-core](https://www.npmjs.com/package/@reaatech/media-pipeline-mcp-core) — `RunNotFoundError`, `RunInProgressError`, `StateStoreUnavailableError`
+- [@reaatech/media-pipeline-mcp](https://www.npmjs.com/package/@reaatech/media-pipeline-mcp) — Full MCP server that consumes this store for pipeline orchestration
+
+## License
+
+[MIT](https://github.com/reaatech/media-pipeline-mcp/blob/main/LICENSE)

package/dist/index.cjs

@@ -0,0 +1,423 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InMemoryPipelineStateStore: () => InMemoryPipelineStateStore,
+  RedisPipelineStateStore: () => RedisPipelineStateStore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/in-memory-store.ts
+var import_media_pipeline_mcp_core = require("@reaatech/media-pipeline-mcp-core");
+var DEFAULT_LOCK_TIMEOUT_MS = 5e3;
+var LOCK_POLL_INTERVAL_MS = 25;
+function cloneRun(run) {
+  return {
+    ...run,
+    steps: run.steps.map((s) => ({ ...s })),
+    events: run.events.map((e) => ({ ...e }))
+  };
+}
+function matchesFilter(run, filter) {
+  if (!filter) return true;
+  if (filter.status) {
+    const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+    if (!statuses.includes(run.status)) return false;
+  }
+  if (filter.tenantId && run.tenantId !== filter.tenantId) return false;
+  if (filter.idempotencyKey && run.idempotencyKey !== filter.idempotencyKey) return false;
+  if (filter.since && run.createdAt < filter.since) return false;
+  if (filter.until && run.createdAt > filter.until) return false;
+  return true;
+}
+var InMemoryPipelineStateStore = class {
+  runs = /* @__PURE__ */ new Map();
+  locks = /* @__PURE__ */ new Map();
+  async create(run) {
+    if (this.runs.has(run.runId)) {
+      throw new import_media_pipeline_mcp_core.RunInProgressError();
+    }
+    const stored = cloneRun(run);
+    this.runs.set(run.runId, stored);
+  }
+  async get(runId) {
+    const run = this.runs.get(runId);
+    if (!run) return null;
+    return cloneRun(run);
+  }
+  async update(runId, patch, expectedVersion) {
+    const existing = this.runs.get(runId);
+    if (!existing) {
+      throw new import_media_pipeline_mcp_core.RunNotFoundError();
+    }
+    if (expectedVersion !== void 0 && existing.version !== expectedVersion) {
+      throw new import_media_pipeline_mcp_core.RunInProgressError();
+    }
+    const stored = cloneRun(existing);
+    Object.assign(stored, patch);
+    stored.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    stored.version = (stored.version ?? 0) + 1;
+    this.runs.set(runId, stored);
+  }
+  async cancel(runId, reason) {
+    const run = this.runs.get(runId);
+    if (!run) {
+      throw new import_media_pipeline_mcp_core.RunNotFoundError();
+    }
+    run.status = "cancelled";
+    run.error = reason;
+    run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    run.version = (run.version ?? 0) + 1;
+  }
+  async appendEvent(runId, event) {
+    const run = this.runs.get(runId);
+    if (!run) {
+      throw new import_media_pipeline_mcp_core.RunNotFoundError();
+    }
+    run.events.push(event);
+    run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  async listEvents(runId, sinceSeq) {
+    const run = this.runs.get(runId);
+    if (!run) {
+      throw new import_media_pipeline_mcp_core.RunNotFoundError();
+    }
+    const events = run.events.map((e) => ({ ...e }));
+    if (sinceSeq === void 0 || sinceSeq < 0) return events;
+    return events.slice(sinceSeq);
+  }
+  async listRuns(filter) {
+    let result = Array.from(this.runs.values()).filter((r) => matchesFilter(r, filter));
+    result.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    if (filter?.offset) {
+      result = result.slice(filter.offset);
+    }
+    if (filter?.limit) {
+      result = result.slice(0, filter.limit);
+    }
+    return result.map(cloneRun);
+  }
+  async findByExternalJobId(provider, jobId) {
+    const key = `${provider}:${jobId}`;
+    for (const run of this.runs.values()) {
+      if (run.externalJobId === key || run.externalJobIds?.[provider] === jobId) {
+        return cloneRun(run);
+      }
+    }
+    return null;
+  }
+  /**
+   * In-memory mutex via a Promise chain. Wraps the lock acquisition in a timeout race
+   * — if the prior holder hasn't released within `timeoutMs`, throws `RunInProgressError`.
+   *
+   * NOTE: this is single-process only. Cross-process locking (Redis SET NX EX, Postgres
+   * advisory locks) belongs in those backends' implementations.
+   */
+  async withLock(runId, fn, timeoutMs = DEFAULT_LOCK_TIMEOUT_MS) {
+    const prev = this.locks.get(runId) ?? Promise.resolve();
+    const deadline = Date.now() + timeoutMs;
+    while (this.locks.has(runId) && Date.now() < deadline) {
+      try {
+        await Promise.race([
+          prev,
+          new Promise(
+            (resolve) => setTimeout(resolve, Math.min(LOCK_POLL_INTERVAL_MS, deadline - Date.now()))
+          )
+        ]);
+      } catch {
+        break;
+      }
+      if (!this.locks.has(runId)) break;
+    }
+    if (this.locks.has(runId) && Date.now() >= deadline) {
+      throw new import_media_pipeline_mcp_core.RunInProgressError();
+    }
+    const next = (async () => {
+      const run = await this.get(runId);
+      if (!run) throw new import_media_pipeline_mcp_core.RunNotFoundError();
+      return fn(run);
+    })();
+    this.locks.set(
+      runId,
+      next.catch(() => {
+      }).finally(() => {
+        if (this.locks.get(runId) === void 0) return;
+      })
+    );
+    try {
+      return await next;
+    } finally {
+      const current = this.locks.get(runId);
+      if (current === next.catch(() => {
+      })) {
+        this.locks.delete(runId);
+      } else {
+        this.locks.delete(runId);
+      }
+    }
+  }
+};
+
+// src/redis-store.ts
+var import_media_pipeline_mcp_core2 = require("@reaatech/media-pipeline-mcp-core");
+var DAY = 86400;
+var RedisPipelineStateStore = class {
+  client;
+  prefix;
+  runTtlSeconds;
+  lockTtlSeconds;
+  idempotencyTtlSeconds;
+  externalJobTtlSeconds;
+  lockAcquireTimeoutMs;
+  lockPollIntervalMs;
+  constructor(config) {
+    this.client = config.client;
+    this.prefix = config.prefix ?? "mp";
+    this.runTtlSeconds = config.runTtlSeconds ?? 30 * DAY;
+    this.lockTtlSeconds = config.lockTtlSeconds ?? 60;
+    this.idempotencyTtlSeconds = config.idempotencyTtlSeconds ?? DAY;
+    this.externalJobTtlSeconds = config.externalJobTtlSeconds ?? 7 * DAY;
+    this.lockAcquireTimeoutMs = config.lockAcquireTimeoutMs ?? 5e3;
+    this.lockPollIntervalMs = config.lockPollIntervalMs ?? 100;
+  }
+  runKey(runId) {
+    return `${this.prefix}:run:${runId}`;
+  }
+  eventsKey(runId) {
+    return `${this.prefix}:run:${runId}:events`;
+  }
+  lockKey(runId) {
+    return `${this.prefix}:run:${runId}:lock`;
+  }
+  idempotencyKey(key) {
+    return `${this.prefix}:idem:${key}`;
+  }
+  jobKey(provider, jobId) {
+    return `${this.prefix}:job:${provider}:${jobId}`;
+  }
+  tenantKey(tenantId) {
+    return `${this.prefix}:tenant:${tenantId}:runs`;
+  }
+  async wrap(op) {
+    try {
+      return await op();
+    } catch (err) {
+      const error = err;
+      if (error?.code === "ECONNREFUSED" || error?.code === "ECONNRESET" || error?.code === "ETIMEDOUT" || /redis|connection/i.test(error?.message ?? "")) {
+        throw new import_media_pipeline_mcp_core2.StateStoreUnavailableError();
+      }
+      throw err;
+    }
+  }
+  async create(run) {
+    return this.wrap(async () => {
+      const key = this.runKey(run.runId);
+      const existing = await this.client.get(key);
+      if (existing) {
+        throw new import_media_pipeline_mcp_core2.RunInProgressError();
+      }
+      await this.client.set(key, JSON.stringify(run), "EX", this.runTtlSeconds);
+      if (run.tenantId) {
+        const ts = Date.parse(run.createdAt) || Date.now();
+        await this.client.zadd(this.tenantKey(run.tenantId), ts, run.runId);
+        await this.client.expire(this.tenantKey(run.tenantId), this.runTtlSeconds);
+      }
+      if (run.idempotencyKey) {
+        await this.client.set(
+          this.idempotencyKey(run.idempotencyKey),
+          run.runId,
+          "EX",
+          this.idempotencyTtlSeconds
+        );
+      }
+      for (const [provider, jobId] of Object.entries(run.externalJobIds ?? {})) {
+        await this.client.set(
+          this.jobKey(provider, jobId),
+          run.runId,
+          "EX",
+          this.externalJobTtlSeconds
+        );
+      }
+    });
+  }
+  async get(runId) {
+    return this.wrap(async () => {
+      const raw = await this.client.get(this.runKey(runId));
+      if (!raw) return null;
+      const run = JSON.parse(raw);
+      const evs = await this.client.lrange(this.eventsKey(runId), 0, -1);
+      run.events = evs.map((s) => JSON.parse(s));
+      return run;
+    });
+  }
+  async update(runId, patch, expectedVersion) {
+    return this.wrap(async () => {
+      const raw = await this.client.get(this.runKey(runId));
+      if (!raw) {
+        throw new import_media_pipeline_mcp_core2.RunNotFoundError();
+      }
+      const existing = JSON.parse(raw);
+      if (expectedVersion !== void 0 && existing.version !== expectedVersion) {
+        throw new import_media_pipeline_mcp_core2.RunInProgressError();
+      }
+      const previousJobs = existing.externalJobIds ?? {};
+      const merged = {
+        ...existing,
+        ...patch,
+        // Don't let patch reset events; those live in a separate list.
+        events: existing.events,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        version: (existing.version ?? 0) + 1
+      };
+      await this.client.set(
+        this.runKey(runId),
+        JSON.stringify({ ...merged, events: [] }),
+        "EX",
+        this.runTtlSeconds
+      );
+      const newJobs = merged.externalJobIds ?? {};
+      for (const [provider, jobId] of Object.entries(newJobs)) {
+        if (previousJobs[provider] !== jobId) {
+          await this.client.set(
+            this.jobKey(provider, jobId),
+            runId,
+            "EX",
+            this.externalJobTtlSeconds
+          );
+        }
+      }
+    });
+  }
+  async cancel(runId, reason) {
+    return this.wrap(async () => {
+      const raw = await this.client.get(this.runKey(runId));
+      if (!raw) {
+        throw new import_media_pipeline_mcp_core2.RunNotFoundError();
+      }
+      const existing = JSON.parse(raw);
+      existing.status = "cancelled";
+      existing.error = reason;
+      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      existing.version = (existing.version ?? 0) + 1;
+      await this.client.set(
+        this.runKey(runId),
+        JSON.stringify({ ...existing, events: [] }),
+        "EX",
+        this.runTtlSeconds
+      );
+    });
+  }
+  async appendEvent(runId, event) {
+    return this.wrap(async () => {
+      const exists = await this.client.get(this.runKey(runId));
+      if (!exists) throw new import_media_pipeline_mcp_core2.RunNotFoundError();
+      await this.client.rpush(this.eventsKey(runId), JSON.stringify(event));
+      await this.client.expire(this.eventsKey(runId), this.runTtlSeconds);
+    });
+  }
+  async listEvents(runId, sinceSeq) {
+    return this.wrap(async () => {
+      const exists = await this.client.get(this.runKey(runId));
+      if (!exists) throw new import_media_pipeline_mcp_core2.RunNotFoundError();
+      const start = sinceSeq !== void 0 && sinceSeq >= 0 ? sinceSeq : 0;
+      const raw = await this.client.lrange(this.eventsKey(runId), start, -1);
+      return raw.map((s) => JSON.parse(s));
+    });
+  }
+  async listRuns(filter) {
+    return this.wrap(async () => {
+      if (filter?.tenantId) {
+        const min = filter.since ? Date.parse(filter.since) || 0 : 0;
+        const max = filter.until ? Date.parse(filter.until) || Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+        const runIds = await this.client.zrangebyscore(this.tenantKey(filter.tenantId), min, max);
+        const runs = [];
+        for (const id of runIds) {
+          const run = await this.get(id);
+          if (run && matchesFilter2(run, filter)) runs.push(run);
+        }
+        runs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        return applyPaging(runs, filter);
+      }
+      if (filter?.idempotencyKey) {
+        const runId = await this.client.get(this.idempotencyKey(filter.idempotencyKey));
+        if (!runId) return [];
+        const run = await this.get(runId);
+        return run && matchesFilter2(run, filter) ? [run] : [];
+      }
+      return [];
+    });
+  }
+  async findByExternalJobId(provider, jobId) {
+    return this.wrap(async () => {
+      const runId = await this.client.get(this.jobKey(provider, jobId));
+      if (!runId) return null;
+      return this.get(runId);
+    });
+  }
+  async withLock(runId, fn, timeoutMs) {
+    const deadline = Date.now() + (timeoutMs ?? this.lockAcquireTimeoutMs);
+    const lockKey = this.lockKey(runId);
+    let acquired = false;
+    while (Date.now() < deadline) {
+      const res = await this.wrap(
+        () => this.client.set(lockKey, "1", "NX", "EX", this.lockTtlSeconds)
+      );
+      if (res === "OK" || res === 1) {
+        acquired = true;
+        break;
+      }
+      await new Promise((r) => setTimeout(r, this.lockPollIntervalMs));
+    }
+    if (!acquired) {
+      throw new import_media_pipeline_mcp_core2.RunInProgressError();
+    }
+    try {
+      const run = await this.get(runId);
+      if (!run) throw new import_media_pipeline_mcp_core2.RunNotFoundError();
+      return await fn(run);
+    } finally {
+      await this.client.del(lockKey).catch(() => void 0);
+    }
+  }
+};
+function matchesFilter2(run, filter) {
+  if (!filter) return true;
+  if (filter.status) {
+    const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+    if (!statuses.includes(run.status)) return false;
+  }
+  if (filter.idempotencyKey && run.idempotencyKey !== filter.idempotencyKey) return false;
+  if (filter.since && run.createdAt < filter.since) return false;
+  if (filter.until && run.createdAt > filter.until) return false;
+  return true;
+}
+function applyPaging(runs, filter) {
+  let result = runs;
+  if (filter?.offset) result = result.slice(filter.offset);
+  if (filter?.limit) result = result.slice(0, filter.limit);
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryPipelineStateStore,
+  RedisPipelineStateStore
+});
+//# sourceMappingURL=index.cjs.map