Zero-idle-RAM synthesis orchestration: PostgreSQL advisory locks, LISTEN/NOTIFY, and SSE telemetry in Shadow's MiniMax Direct pipeline

1. The Core Bottleneck

Most AI media platforms treat generation as a fire-and-forget HTTP request. You POST a prompt, you wait, you poll. The worker holds the prompt payload, the diffusion model weights, and the intermediate latents in memory for the entire duration of the job. Multiply that by a few thousand concurrent users and you get the classic pathology: RAM exhaustion, GPU starvation, and a queue that nobody can introspect.

Shadow takes a different position. Generation is a distributed state machine, not a request handler. Every prompt is decomposed into a consistent pipeline of stages (text synthesis, image synthesis, video synthesis, kinematics, colour verification, distribution) and each stage is owned by a stateless worker that pulls work from a PostgreSQL-backed queue. The workers hold zero persistent state. The queue holds everything. RAM usage stays flat regardless of concurrency.

This is what we mean by zero-idle-RAM orchestration. The cost model is not "RAM times concurrency". It is "RAM times active workers", which is bounded by the cluster size, not the user count.

2. Mathematical Formulation & Architecture

The pipeline is modelled as a directed acyclic graph of synthesis stages. Each stage $S_i$ has a CPU cost $c_i$, a GPU cost $g_i$, and a memory footprint $m_i$. The total resource budget at time $t$ is:

$$R(t) = \sum_{i=1}^{N} w_i(t) \cdot (c_i + g_i + m_i)$$

where $w_i(t) \in {0, 1}$ indicates whether stage $i$ is actively executing. Because workers are stateless and pull from the queue, $w_i(t)$ is bounded by the worker pool cardinality $W$, not by the user request count $U$. As $U \to \infty$, $R(t)$ converges to $W \cdot \max_i(c_i + g_i + m_i)$.

The MiniMax Direct pipeline itself is composed of six stages:

1. Text synthesis via MiniMax Direct, producing a structured scene graph.
2. Image synthesis conditioned on the scene graph, producing a 4K reference frame.
3. Likeness Lock v2.4 verification, enforcing identity preservation against the user's enrolled biometric anchor.
4. Video synthesis via Hailuo H3 kinematics, generating motion vectors at 24fps with shutter blur compensation.
5. CIEDE2000 colour verification, ensuring perceptual colour fidelity across the rendered sequence.
6. Distribution, packaging the artefact and pushing it to the CDN edge.

The Likeness Lock is the most interesting constraint. We compute a perceptual distance in CIEDE2000 colour space between the enrolled anchor and each generated frame:

$$\Delta E_{00} = \sqrt{\left(\frac{\Delta L'}{S_L}\right)^2 + \left(\frac{\Delta C'}{S_C}\right)^2 + \left(\frac{\Delta H'}{S_H}\right)^2 + R_T \frac{\Delta C'}{S_C}\frac{\Delta H'}{S_H}}$$

Frames with $\Delta E_{00} > 2.0$ are rejected and the stage is re-queued with an adjusted conditioning vector. This is enforced server-side, not client-side, so the user cannot bypass it.

Here is the TypeScript orchestrator that drives a single stage transition:

import { Pool } from 'pg';
import { EventEmitter } from 'events';

interface Stage {
  id: string;
  jobId: string;
  kind: 'text' | 'image' | 'likeness' | 'video' | 'colour' | 'distribute';
  payload: Record<string, unknown>;
  attempts: number;
}

export class StageOrchestrator extends EventEmitter {
  constructor(private pool: Pool, private workerId: string) {
    super();
  }

  async claimNextStage(): Promise<Stage | null> {
    const client = await this.pool.connect();
    try {
      await client.query('BEGIN');
      // pg_try_advisory_xact_lock returns false immediately if locked
      const lockRes = await client.query<{ job_id: string; stage_id: string }>(
        `SELECT job_id, stage_id
         FROM shadow_stages
         WHERE status = 'queued'
           AND depends_on_resolved = true
         ORDER BY priority DESC, enqueued_at ASC
         FOR UPDATE SKIP LOCKED
         LIMIT 1`
      );
      if (lockRes.rowCount === 0) {
        await client.query('COMMIT');
        return null;
      }
      const { job_id, stage_id } = lockRes.rows[0];
      await client.query(
        `UPDATE shadow_stages
         SET status = 'running', worker_id = $1, started_at = now()
         WHERE stage_id = $2`,
        [this.workerId, stage_id]
      );
      await client.query('COMMIT');
      return await this.loadStage(client, job_id, stage_id);
    } catch (err) {
      await client.query('ROLLBACK');
      throw err;
    } finally {
      client.release();
    }
  }

  async completeStage(stage: Stage, output: Record<string, unknown>) {
    const client = await this.pool.connect();
    try {
      await client.query('BEGIN');
      await client.query(
        `UPDATE shadow_stages
         SET status = 'done', output = $1, completed_at = now()
         WHERE stage_id = $2`,
        [JSON.stringify(output), stage.id]
      );
      await client.query(
        `UPDATE shadow_stages
         SET depends_on_resolved = true
         WHERE job_id = $1 AND depends_on_stage = $2`,
        [stage.jobId, stage.id]
      );
      await client.query('NOTIFY shadow_stage_done, $1', [stage.jobId]);
      await client.query('COMMIT');
    } finally {
      client.release();
    }
  }
}

The FOR UPDATE SKIP LOCKED clause is the linchpin. It gives us serialisable claim semantics without blocking. Two workers can scan the same table and each take a different row. No mutex, no Redis, no Zookeeper. Just PostgreSQL doing what it does best.

3. Real-time Infrastructure & Telemetry

The orchestrator above is only half the story. The other half is the telemetry channel that lets the browser see what is happening in real time. We use Server-Sent Events backed by PostgreSQL's LISTEN/NOTIFY primitive.

When a stage completes, the worker fires NOTIFY shadow_stage_done, '<job_id>'. A dedicated listener process subscribes to that channel and fans the event out to every connected SSE client that has an open stream for that job. The browser receives a stream of typed events:

// Browser-side SSE consumer
const evtSource = new EventSource(`/api/jobs/${jobId}/stream`);

evtSource.addEventListener('stage', (e: MessageEvent) => {
  const data = JSON.parse(e.data);
  switch (data.kind) {
    case 'text':
      renderSceneGraph(data.output);
      break;
    case 'image':
      renderReferenceFrame(data.output.url);
      break;
    case 'likeness':
      renderLikenessBadge(data.output.deltaE);
      break;
    case 'video':
      attachVideoPlayer(data.output.hlsUrl);
      break;
    case 'colour':
      renderColourReport(data.output.deltaE);
      break;
    case 'distribute':
      renderDistributionLinks(data.output.cdnUrls);
      break;
  }
});

evtSource.addEventListener('done', () => evtSource.close());

The end-to-end latency from worker commit to browser paint is dominated by the PostgreSQL notify round-trip, which we measure at 8 to 14 milliseconds on a healthy cluster. There is no polling, no WebSocket fan-out server, no Redis pub/sub. The database is the message bus.

For the 24fps shutter blur compensation in Hailuo H3, we expose a derived metric in the SSE stream: the per-frame motion vector magnitude

, -

5. Live Architecture Evaluation & Try It Yourself

You can benchmark this complete architecture without installing local dependencies. Explore the live interactive dark studio at shadowsocial.io/signup.

Special Developer Launch Offer: Apply coupon code LAUNCH30 at signup to receive 30% off any subscription plan for 3 months, plus 50 complimentary high-definition generation credits credited immediately to your workspace ledger.

---

Written autonomously via Shadow