@opengeni/db 0.28.9 → 0.36.0

package/dist/chunk-CQZ4QSP5.js

@@ -0,0 +1,995 @@
+import {
+  rawRows,
+  withRlsContext,
+  withWorkspaceRls
+} from "./chunk-JC5QPLUM.js";
+import {
+  connections,
+  creditLedgerEntries,
+  files,
+  generatedVideoArtifacts,
+  usageEvents,
+  videoGenerationOperations,
+  videoGenerationReferences,
+  workspaceVideoGenerationPolicies,
+  workspaceVideoGenerationQuotas,
+  workspaces
+} from "./chunk-5KTIEDX7.js";
+
+// src/video-generation.ts
+import {
+  GENERATED_VIDEO_MAX_BYTES,
+  GeneratedVideoReceipt,
+  GROK_IMAGINE_VIDEO_1_5_MODEL_ID,
+  SEEDANCE_2_5_MODEL_ID,
+  VideoGenerationPolicy,
+  VideoGenerationOperationSummary,
+  retainedGeneratedVideoReferenceFromFile
+} from "@opengeni/contracts";
+import { and, eq, inArray, sql } from "drizzle-orm";
+var ACTIVE_VIDEO_GENERATION_STATUSES = [
+  "preparing",
+  "prepared",
+  "accepted",
+  "submission_uncertain",
+  "provider_started",
+  "retaining"
+];
+var VideoGenerationConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VideoGenerationConflictError";
+  }
+};
+var VideoGenerationCapacityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VideoGenerationCapacityError";
+  }
+};
+var VideoGenerationCreditError = class extends Error {
+  constructor(message = "insufficient OpenGeni credits") {
+    super(message);
+    this.name = "VideoGenerationCreditError";
+  }
+};
+async function getWorkspaceVideoGenerationPolicy(db, workspaceId) {
+  return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    const [row] = await scopedDb.select().from(workspaceVideoGenerationPolicies).where(eq(workspaceVideoGenerationPolicies.workspaceId, workspaceId)).limit(1);
+    return policyFromRow(row);
+  });
+}
+async function updateWorkspaceVideoGenerationPolicy(db, input) {
+  const requested = VideoGenerationPolicy.parse({
+    schemaVersion: 1,
+    revision: input.expectedRevision + 1,
+    fundingSource: input.fundingSource,
+    enabledModelIds: input.enabledModelIds,
+    defaultModelId: input.defaultModelId
+  });
+  assertSupportedModels(requested.enabledModelIds);
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (tx) => {
+      const [workspace] = await tx.select({ id: workspaces.id }).from(workspaces).where(
+        and(
+          eq(workspaces.id, input.workspaceId),
+          eq(workspaces.accountId, input.accountId)
+        )
+      ).for("update").limit(1);
+      if (!workspace) throw new Error("Workspace not found");
+      const [current] = await tx.select().from(workspaceVideoGenerationPolicies).where(eq(workspaceVideoGenerationPolicies.workspaceId, input.workspaceId)).for("update").limit(1);
+      const currentRevision = current?.revision ?? 0;
+      if (currentRevision !== input.expectedRevision) {
+        throw new VideoGenerationConflictError("Video generation policy changed");
+      }
+      const now = /* @__PURE__ */ new Date();
+      const values = {
+        workspaceId: input.workspaceId,
+        accountId: input.accountId,
+        revision: currentRevision + 1,
+        fundingSource: requested.fundingSource,
+        enabledModelIds: [...requested.enabledModelIds],
+        defaultModelId: requested.defaultModelId,
+        updatedBySubjectId: input.subjectId.slice(0, 1024),
+        updatedAt: now
+      };
+      const [row] = current ? await tx.update(workspaceVideoGenerationPolicies).set(values).where(eq(workspaceVideoGenerationPolicies.workspaceId, input.workspaceId)).returning() : await tx.insert(workspaceVideoGenerationPolicies).values(values).returning();
+      if (!row) throw new Error("Video generation policy update was not persisted");
+      return policyFromRow(row);
+    })
+  );
+}
+async function admitVideoGenerationOperation(db, input) {
+  const reservedBytes = input.reservedBytes ?? GENERATED_VIDEO_MAX_BYTES;
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (tx) => {
+      await tx.execute(
+        sql`select pg_advisory_xact_lock(hashtextextended(${`video-generation:${input.admissionKey}`}, 0))`
+      );
+      const [existing] = await tx.select().from(videoGenerationOperations).where(
+        and(
+          eq(videoGenerationOperations.workspaceId, input.workspaceId),
+          eq(videoGenerationOperations.admissionKey, input.admissionKey)
+        )
+      ).limit(1);
+      if (existing) {
+        assertAdmissionMatches(existing, input);
+        return { operation: existing, created: false };
+      }
+      const [policy] = await tx.select().from(workspaceVideoGenerationPolicies).where(eq(workspaceVideoGenerationPolicies.workspaceId, input.workspaceId)).for("update").limit(1);
+      if (!policy || policy.revision !== input.policyRevision || policy.fundingSource !== input.fundingSource || !policy.enabledModelIds.includes(input.modelId)) {
+        throw new VideoGenerationConflictError("Video generation capability changed");
+      }
+      const active = await tx.select({ id: videoGenerationOperations.id }).from(videoGenerationOperations).where(
+        and(
+          eq(videoGenerationOperations.workspaceId, input.workspaceId),
+          inArray(videoGenerationOperations.status, [
+            ...ACTIVE_VIDEO_GENERATION_STATUSES
+          ])
+        )
+      ).for("update");
+      if (active.length >= input.maxConcurrentPerWorkspace) {
+        throw new VideoGenerationCapacityError("Workspace video generation limit reached");
+      }
+      await tx.insert(workspaceVideoGenerationQuotas).values({
+        workspaceId: input.workspaceId,
+        accountId: input.accountId
+      }).onConflictDoNothing({
+        target: workspaceVideoGenerationQuotas.workspaceId
+      });
+      const [quota] = await tx.select().from(workspaceVideoGenerationQuotas).where(eq(workspaceVideoGenerationQuotas.workspaceId, input.workspaceId)).for("update").limit(1);
+      if (!quota) throw new Error("Video generation quota row disappeared");
+      if (quota.reservedBytes + quota.readyBytes + reservedBytes > input.workspaceQuotaBytes) {
+        throw new VideoGenerationCapacityError("Workspace video storage quota reached");
+      }
+      const [operation] = await tx.insert(videoGenerationOperations).values({
+        id: input.id,
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        attemptId: input.attemptId,
+        toolCallId: input.toolCallId,
+        admissionKey: input.admissionKey,
+        requestDigest: input.requestDigest,
+        promptDigest: input.promptDigest,
+        requestEncrypted: input.requestEncrypted,
+        modelId: input.modelId,
+        sourceMode: input.sourceMode,
+        capabilityRevision: input.capabilityRevision,
+        fundingSource: input.fundingSource,
+        pricedCostMicros: input.pricedCostMicros,
+        creditState: input.pricedCostMicros > 0 ? "debited" : "not_applicable",
+        connectionId: input.connectionId,
+        credentialVersion: input.credentialVersion,
+        credentialEncrypted: input.credentialEncrypted,
+        providerIdempotencyKey: input.providerIdempotencyKey,
+        expectedArtifactId: input.expectedArtifactId,
+        expectedFileId: input.expectedFileId,
+        reservedBytes,
+        recoveryDeadlineAt: input.recoveryDeadlineAt,
+        status: input.references.length === 0 ? "prepared" : "preparing",
+        admissionOutputState: "pending",
+        terminalUpdateState: "ineligible"
+      }).returning();
+      if (!operation) throw new Error("Video generation operation was not admitted");
+      if (input.pricedCostMicros > 0) {
+        if (input.fundingSource !== "opengeni_credits" || input.connectionId !== null) {
+          throw new Error("Only OpenGeni-funded video operations may debit credits");
+        }
+        await debitVideoGenerationCredits(tx, operation);
+      }
+      if (input.references.length > 0) {
+        await tx.insert(videoGenerationReferences).values(
+          input.references.map((reference) => ({
+            operationId: operation.id,
+            workspaceId: input.workspaceId,
+            accountId: input.accountId,
+            grantExpiresAt: reference.grantExpiresAt ?? null,
+            ...reference
+          }))
+        );
+      }
+      await tx.update(workspaceVideoGenerationQuotas).set({
+        reservedBytes: sql`${workspaceVideoGenerationQuotas.reservedBytes} + ${reservedBytes}`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(eq(workspaceVideoGenerationQuotas.workspaceId, input.workspaceId));
+      return { operation, created: true };
+    })
+  );
+}
+async function rotateVideoGenerationCredential(db, input) {
+  const [row] = await db.update(videoGenerationOperations).set({
+    credentialEncrypted: input.credentialEncrypted,
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(
+    and(
+      eq(videoGenerationOperations.accountId, input.accountId),
+      eq(videoGenerationOperations.workspaceId, input.workspaceId),
+      eq(videoGenerationOperations.id, input.operationId),
+      eq(videoGenerationOperations.requestDigest, input.requestDigest),
+      eq(videoGenerationOperations.credentialEncrypted, input.expectedCredentialEncrypted),
+      inArray(videoGenerationOperations.status, [
+        "accepted",
+        "submission_uncertain",
+        "provider_started",
+        "retaining"
+      ])
+    )
+  ).returning();
+  if (!row) throw new VideoGenerationConflictError("Video provider credential changed");
+  return row;
+}
+async function markVideoGenerationPrepared(db, input) {
+  return await mutateOperation(db, input, async (tx, operation) => {
+    if (operation.status === "prepared") return operation;
+    if (operation.status !== "preparing") throw invalidTransition(operation, "prepared");
+    const references = await tx.select({
+      stagingObjectKey: videoGenerationReferences.stagingObjectKey,
+      cleanedAt: videoGenerationReferences.cleanedAt
+    }).from(videoGenerationReferences).where(eq(videoGenerationReferences.operationId, operation.id));
+    if (references.length === 0 || references.some((reference) => !reference.stagingObjectKey || reference.cleanedAt)) {
+      throw new VideoGenerationConflictError("Video references are not sealed");
+    }
+    const [updated] = await tx.update(videoGenerationOperations).set({ status: "prepared", updatedAt: /* @__PURE__ */ new Date() }).where(eq(videoGenerationOperations.id, operation.id)).returning();
+    return requireRow(updated, "seal video generation references");
+  });
+}
+async function markVideoGenerationAccepted(db, input) {
+  return await mutateOperation(
+    db,
+    input,
+    async (tx, operation) => await markVideoGenerationAcceptedInTransaction(tx, {
+      workspaceId: input.workspaceId,
+      operation
+    })
+  );
+}
+async function markVideoGenerationAcceptedInTransaction(tx, input) {
+  const operation = input.operation;
+  if (input.toolCallId !== void 0 && operation.toolCallId !== input.toolCallId) {
+    throw new VideoGenerationConflictError("Video generation tool-call identity changed");
+  }
+  if (operation.admissionOutputState === "recorded") return operation;
+  if (operation.status !== "prepared") {
+    throw new VideoGenerationConflictError("Video generation is no longer awaiting acceptance");
+  }
+  const [policy] = await tx.select().from(workspaceVideoGenerationPolicies).where(eq(workspaceVideoGenerationPolicies.workspaceId, input.workspaceId)).for("share").limit(1);
+  const [connection] = operation.connectionId ? await tx.select({
+    id: connections.id,
+    version: connections.version,
+    status: connections.status,
+    metadata: connections.metadata
+  }).from(connections).where(
+    and(
+      eq(connections.workspaceId, input.workspaceId),
+      eq(connections.id, operation.connectionId)
+    )
+  ).for("share").limit(1) : [];
+  const workspaceGatewayAuthorized = operation.fundingSource === "workspace_gateway" && connection?.status === "active" && connection.version === operation.credentialVersion && connection.metadata.credentialRole === "vercel_ai_gateway";
+  const managedAuthorized = operation.fundingSource === "opengeni_credits" && operation.connectionId === null && (operation.creditState === "debited" || operation.creditState === "not_applicable" && operation.pricedCostMicros === 0);
+  const supergrokAuthorized = operation.fundingSource === "supergrok_subscription" && operation.connectionId === null && operation.credentialEncrypted !== null && operation.pricedCostMicros === 0 && operation.creditState === "not_applicable";
+  if (!policy || policy.fundingSource !== operation.fundingSource || !policy.enabledModelIds.includes(operation.modelId) || !workspaceGatewayAuthorized && !managedAuthorized && !supergrokAuthorized) {
+    throw new VideoGenerationConflictError("Video generation authorization changed");
+  }
+  const now = /* @__PURE__ */ new Date();
+  const [updated] = await tx.update(videoGenerationOperations).set({
+    status: "accepted",
+    admissionOutputState: "recorded",
+    terminalUpdateState: "pending",
+    nextReconcileAt: now,
+    updatedAt: now
+  }).where(eq(videoGenerationOperations.id, operation.id)).returning();
+  return requireRow(updated, "record video generation acceptance");
+}
+async function cancelVideoGenerationBeforeSubmit(db, input) {
+  return await mutateOperation(db, input, async (tx, operation) => {
+    if (operation.status === "cancelled_before_submit") return operation;
+    if (!inPreSubmitState(operation.status) || operation.providerRequestSentAt) {
+      throw new VideoGenerationConflictError(
+        "Video generation may already have reached the provider"
+      );
+    }
+    const now = /* @__PURE__ */ new Date();
+    await releaseReservedQuota(tx, operation, false);
+    const creditState = await refundVideoGenerationCredits(tx, operation, now);
+    const [updated] = await tx.update(videoGenerationOperations).set({
+      status: "cancelled_before_submit",
+      creditState,
+      quotaState: "released",
+      terminalAt: now,
+      terminalUpdateState: operation.admissionOutputState === "recorded" ? "pending" : "suppressed",
+      credentialEncrypted: null,
+      requestEncrypted: null,
+      boundedPublicReason: boundPublicReason(input.reason),
+      updatedAt: now
+    }).where(eq(videoGenerationOperations.id, operation.id)).returning();
+    if (!updated) throw new Error("Video generation cancellation was not recorded");
+    return updated;
+  });
+}
+async function cancelUnacceptedVideoGenerationsForToolCallsInTransaction(tx, input) {
+  const toolCallIds = [...new Set(input.toolCallIds)];
+  if (toolCallIds.length === 0) return [];
+  const operations = await tx.select().from(videoGenerationOperations).where(
+    and(
+      eq(videoGenerationOperations.workspaceId, input.workspaceId),
+      eq(videoGenerationOperations.sessionId, input.sessionId),
+      eq(videoGenerationOperations.turnId, input.turnId),
+      inArray(videoGenerationOperations.toolCallId, toolCallIds),
+      eq(videoGenerationOperations.admissionOutputState, "pending"),
+      inArray(videoGenerationOperations.status, ["preparing", "prepared"]),
+      sql`${videoGenerationOperations.providerRequestSentAt} is null`
+    )
+  ).orderBy(videoGenerationOperations.id).for("update");
+  const cancelled = [];
+  for (const operation of operations) {
+    await releaseReservedQuota(tx, operation, false);
+    const creditState = await refundVideoGenerationCredits(tx, operation, input.now);
+    const [updated] = await tx.update(videoGenerationOperations).set({
+      status: "cancelled_before_submit",
+      creditState,
+      quotaState: "released",
+      terminalAt: input.now,
+      terminalUpdateState: "suppressed",
+      nextReconcileAt: input.now,
+      providerRequestEncrypted: null,
+      providerRequestExpiresAt: null,
+      credentialEncrypted: null,
+      requestEncrypted: null,
+      privateDataEraseAfter: input.now,
+      boundedPublicReason: boundPublicReason(input.reason),
+      reconcileLeaseOwner: null,
+      reconcileLeaseExpiresAt: null,
+      updatedAt: input.now
+    }).where(eq(videoGenerationOperations.id, operation.id)).returning({ id: videoGenerationOperations.id });
+    if (!updated) throw new Error("Interrupted video generation was not cancelled");
+    await tx.update(videoGenerationReferences).set({ cleanupAfter: input.now }).where(eq(videoGenerationReferences.operationId, operation.id));
+    cancelled.push(updated.id);
+  }
+  return cancelled;
+}
+async function claimVideoGenerationOperations(db, input) {
+  const rows = await rawRows(
+    db,
+    sql`select * from opengeni_private.claim_video_generation_operations(
+      ${input.owner}, ${input.leaseSeconds}, ${input.limit}
+    )`
+  );
+  return rows.map((row) => ({
+    operationId: row.operation_id,
+    accountId: row.account_id,
+    workspaceId: row.workspace_id
+  }));
+}
+async function getVideoGenerationOperation(db, workspaceId, operationId) {
+  return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    const [operation] = await scopedDb.select().from(videoGenerationOperations).where(
+      and(
+        eq(videoGenerationOperations.workspaceId, workspaceId),
+        eq(videoGenerationOperations.id, operationId)
+      )
+    ).limit(1);
+    if (!operation) return null;
+    const references = await scopedDb.select().from(videoGenerationReferences).where(eq(videoGenerationReferences.operationId, operationId)).orderBy(videoGenerationReferences.ordinal);
+    return { ...operation, references };
+  });
+}
+async function markVideoGenerationSubmissionUncertain(db, input) {
+  return await mutateOperation(db, input, async (tx, operation) => {
+    if (operation.status !== "submission_uncertain" || !operation.providerRequestEncrypted) {
+      throw invalidTransition(operation, "submission_uncertain");
+    }
+    const now = /* @__PURE__ */ new Date();
+    const [updated] = await tx.update(videoGenerationOperations).set({
+      status: "submission_uncertain",
+      providerRequestSentAt: operation.providerRequestSentAt ?? now,
+      nextReconcileAt: input.nextReconcileAt,
+      lastError: boundPrivateError(input.error),
+      reconcileLeaseOwner: null,
+      reconcileLeaseExpiresAt: null,
+      updatedAt: now
+    }).where(eq(videoGenerationOperations.id, operation.id)).returning();
+    return requireRow(updated, "record uncertain video submission");
+  });
+}
+async function markVideoGenerationSubmissionIntent(db, input) {
+  return await mutateOperation(db, input, async (tx, operation) => {
+    if (operation.status === "submission_uncertain") {
+      if (!operation.providerRequestEncrypted || !operation.providerRequestExpiresAt) {
+        throw new VideoGenerationConflictError("Video provider request is incomplete");
+      }
+      return operation;
+    }
+    if (operation.status !== "accepted") {
+      throw invalidTransition(operation, "submission_uncertain");
+    }
+    const now = /* @__PURE__ */ new Date();
+    const [updated] = await tx.update(videoGenerationOperations).set({
+      status: "submission_uncertain",
+      providerRequestEncrypted: input.encryptedProviderRequest,
+      providerRequestExpiresAt: input.providerRequestExpiresAt,
+      nextReconcileAt: input.nextReconcileAt,
+      lastError: null,
+      reconcileLeaseOwner: null,
+      reconcileLeaseExpiresAt: null,
+      updatedAt: now
+    }).where(eq(videoGenerationOperations.id, operation.id)).returning();
+    await tx.update(videoGenerationReferences).set({
+      grantExpiresAt: input.providerRequestExpiresAt,
+      cleanupAfter: new Date(
+        Math.max(
+          operation.recoveryDeadlineAt.getTime(),
+          input.providerRequestExpiresAt.getTime()
+        )
+      )
+    }).where(eq(videoGenerationReferences.operationId, operation.id));
+    return requireRow(updated, "record video provider submission intent");
+  });
+}
+async function markVideoGenerationProviderStarted(db, input) {
+  return await mutateOperation(db, input, async (tx, operation) => {
+    if (operation.providerJobId === input.providerJobId && operation.status === "provider_started") {
+      return operation;
+    }
+    if (!inArrayValue(operation.status, ["accepted", "submission_uncertain"])) {
+      throw invalidTransition(operation, "provider_started");
+    }
+    const now = /* @__PURE__ */ new Date();
+    const [updated] = await tx.update(videoGenerationOperations).set({
+      status: "provider_started",
+      providerJobId: input.providerJobId.slice(0, 1024),
+      providerRequestEncrypted: null,
+      providerRequestExpiresAt: null,
+      providerRequestSentAt: operation.providerRequestSentAt ?? now,
+      providerStartedAt: operation.providerStartedAt ?? now,
+      nextReconcileAt: input.nextReconcileAt,
+      lastError: null,
+      reconcileLeaseOwner: null,
+      reconcileLeaseExpiresAt: null,
+      updatedAt: now
+    }).where(eq(videoGenerationOperations.id, operation.id)).returning();
+    return requireRow(updated, "record video provider job");
+  });
+}
+async function rescheduleVideoGenerationOperation(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [updated] = await scopedDb.update(videoGenerationOperations).set({
+        nextReconcileAt: input.nextReconcileAt,
+        ...input.error ? { lastError: boundPrivateError(input.error) } : {},
+        reconcileLeaseOwner: null,
+        reconcileLeaseExpiresAt: null,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(
+        and(
+          eq(videoGenerationOperations.workspaceId, input.workspaceId),
+          eq(videoGenerationOperations.id, input.operationId),
+          eq(videoGenerationOperations.requestDigest, input.requestDigest),
+          ...input.owner ? [eq(videoGenerationOperations.reconcileLeaseOwner, input.owner)] : []
+        )
+      ).returning({ id: videoGenerationOperations.id });
+      return updated !== void 0;
+    }
+  );
+}
+async function markVideoGenerationRetaining(db, input) {
+  return await mutateOperation(db, input, async (tx, operation) => {
+    if (operation.status === "retaining") return operation;
+    if (operation.status !== "provider_started") throw invalidTransition(operation, "retaining");
+    const [updated] = await tx.update(videoGenerationOperations).set({
+      status: "retaining",
+      nextReconcileAt: /* @__PURE__ */ new Date(),
+      reconcileLeaseOwner: null,
+      reconcileLeaseExpiresAt: null,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq(videoGenerationOperations.id, operation.id)).returning();
+    return requireRow(updated, "begin video retention");
+  });
+}
+async function settleVideoGenerationFailure(db, input) {
+  return await mutateOperation(db, input, async (tx, operation) => {
+    if (operation.status === input.status) return operation;
+    const allowed = input.status === "provider_failed" ? ["accepted", "submission_uncertain", "provider_started"] : input.status === "retention_failed" ? ["retaining"] : ["submission_uncertain", "provider_started"];
+    if (!inArrayValue(operation.status, allowed)) throw invalidTransition(operation, input.status);
+    await releaseReservedQuota(tx, operation, false);
+    const now = /* @__PURE__ */ new Date();
+    const creditState = await refundVideoGenerationCredits(tx, operation, now);
+    const [updated] = await tx.update(videoGenerationOperations).set({
+      status: input.status,
+      creditState,
+      quotaState: "released",
+      terminalAt: now,
+      nextReconcileAt: null,
+      terminalUpdateState: operation.admissionOutputState === "recorded" ? "pending" : "suppressed",
+      providerRequestEncrypted: null,
+      providerRequestExpiresAt: null,
+      credentialEncrypted: null,
+      requestEncrypted: null,
+      boundedPublicReason: boundPublicReason(input.publicReason),
+      lastError: input.privateError ? boundPrivateError(input.privateError) : null,
+      reconcileLeaseOwner: null,
+      reconcileLeaseExpiresAt: null,
+      privateDataEraseAfter: now,
+      updatedAt: now
+    }).where(eq(videoGenerationOperations.id, operation.id)).returning();
+    return requireRow(updated, "settle failed video generation");
+  });
+}
+async function settleVideoGenerationReady(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (tx) => {
+      const [operation] = await tx.select().from(videoGenerationOperations).where(
+        and(
+          eq(videoGenerationOperations.workspaceId, input.workspaceId),
+          eq(videoGenerationOperations.id, input.operationId),
+          eq(videoGenerationOperations.requestDigest, input.requestDigest)
+        )
+      ).for("update").limit(1);
+      if (!operation) throw new VideoGenerationConflictError("Video operation not found");
+      const [existingArtifact] = await tx.select().from(generatedVideoArtifacts).where(eq(generatedVideoArtifacts.operationId, operation.id)).limit(1);
+      if (operation.status === "completed" && existingArtifact) {
+        return { operation, artifact: existingArtifact };
+      }
+      if (operation.status !== "retaining") throw invalidTransition(operation, "completed");
+      if (operation.expectedFileId !== input.fileId) {
+        throw new VideoGenerationConflictError("Video File identity changed during settlement");
+      }
+      if (operation.expectedArtifactId === operation.expectedFileId) {
+        throw new Error("Video artifact and File identities must be distinct");
+      }
+      const now = /* @__PURE__ */ new Date();
+      await tx.insert(files).values({
+        id: input.fileId,
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        status: "ready",
+        filename: `generated-video-${operation.expectedArtifactId}.mp4`,
+        safeFilename: `generated-video-${operation.expectedArtifactId}.mp4`,
+        contentType: "video/mp4",
+        sizeBytes: input.sizeBytes,
+        sha256: input.sha256,
+        bucket: input.bucket,
+        objectKey: input.objectKey,
+        updatedAt: now
+      });
+      const [artifact] = await tx.insert(generatedVideoArtifacts).values({
+        id: operation.expectedArtifactId,
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        primaryFileId: input.fileId,
+        operationId: operation.id,
+        sessionId: operation.sessionId,
+        turnId: operation.turnId,
+        attemptId: operation.attemptId,
+        modelId: operation.modelId,
+        sourceMode: operation.sourceMode,
+        promptDigest: operation.promptDigest,
+        contentType: "video/mp4",
+        sizeBytes: input.sizeBytes,
+        sha256: input.sha256,
+        durationMillis: Math.round(input.facts.durationSeconds * 1e3),
+        width: input.facts.width,
+        height: input.facts.height,
+        fpsMilli: Math.round(input.facts.fps * 1e3),
+        videoCodec: input.facts.videoCodec,
+        audioCodec: input.facts.audioCodec,
+        hasAudio: input.facts.hasAudio,
+        sandboxFilename: `generated-video-${operation.expectedArtifactId}.mp4`,
+        readyAt: now
+      }).returning();
+      if (!artifact) throw new Error("Generated video artifact was not persisted");
+      await tx.update(workspaceVideoGenerationQuotas).set({
+        reservedBytes: sql`${workspaceVideoGenerationQuotas.reservedBytes} - ${operation.reservedBytes}`,
+        readyBytes: sql`${workspaceVideoGenerationQuotas.readyBytes} + ${input.sizeBytes}`,
+        updatedAt: now
+      }).where(eq(workspaceVideoGenerationQuotas.workspaceId, input.workspaceId));
+      const [updated] = await tx.update(videoGenerationOperations).set({
+        status: "completed",
+        quotaState: "ready",
+        terminalAt: now,
+        nextReconcileAt: null,
+        terminalUpdateState: operation.admissionOutputState === "recorded" ? "pending" : "suppressed",
+        providerRequestEncrypted: null,
+        providerRequestExpiresAt: null,
+        credentialEncrypted: null,
+        requestEncrypted: null,
+        boundedPublicReason: null,
+        lastError: null,
+        privateDataEraseAfter: now,
+        reconcileLeaseOwner: null,
+        reconcileLeaseExpiresAt: null,
+        updatedAt: now
+      }).where(eq(videoGenerationOperations.id, operation.id)).returning();
+      return {
+        operation: requireRow(updated, "settle ready video generation"),
+        artifact
+      };
+    })
+  );
+}
+async function getGeneratedVideoArtifact(db, workspaceId, artifactId) {
+  return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    const [row] = await scopedDb.select({ artifact: generatedVideoArtifacts, file: files }).from(generatedVideoArtifacts).innerJoin(files, eq(files.id, generatedVideoArtifacts.primaryFileId)).where(
+      and(
+        eq(generatedVideoArtifacts.workspaceId, workspaceId),
+        eq(generatedVideoArtifacts.id, artifactId)
+      )
+    ).limit(1);
+    return row ?? null;
+  });
+}
+async function listSessionGeneratedVideoArtifacts(db, workspaceId, sessionId) {
+  return await withWorkspaceRls(
+    db,
+    workspaceId,
+    async (scopedDb) => await scopedDb.select({
+      artifact: generatedVideoArtifacts,
+      file: files
+    }).from(generatedVideoArtifacts).innerJoin(files, eq(files.id, generatedVideoArtifacts.primaryFileId)).where(
+      and(
+        eq(generatedVideoArtifacts.workspaceId, workspaceId),
+        eq(generatedVideoArtifacts.sessionId, sessionId),
+        sql`${generatedVideoArtifacts.deletedAt} is null`
+      )
+    ).orderBy(generatedVideoArtifacts.createdAt, generatedVideoArtifacts.id)
+  );
+}
+async function markVideoGenerationReferenceCleaned(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [updated] = await scopedDb.update(videoGenerationReferences).set({
+        stagingObjectKey: null,
+        grantExpiresAt: null,
+        cleanupAfter: null,
+        cleanedAt: /* @__PURE__ */ new Date()
+      }).where(
+        and(
+          eq(videoGenerationReferences.workspaceId, input.workspaceId),
+          eq(videoGenerationReferences.operationId, input.operationId),
+          eq(videoGenerationReferences.ordinal, input.ordinal),
+          eq(videoGenerationReferences.stagingObjectKey, input.stagingObjectKey)
+        )
+      ).returning({
+        operationId: videoGenerationReferences.operationId
+      });
+      if (updated) return true;
+      const [existing] = await scopedDb.select({ cleanedAt: videoGenerationReferences.cleanedAt }).from(videoGenerationReferences).where(
+        and(
+          eq(videoGenerationReferences.workspaceId, input.workspaceId),
+          eq(videoGenerationReferences.operationId, input.operationId),
+          eq(videoGenerationReferences.ordinal, input.ordinal)
+        )
+      ).limit(1);
+      return existing?.cleanedAt !== null && existing?.cleanedAt !== void 0;
+    }
+  );
+}
+async function markVideoGenerationTerminalUpdate(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      return await markVideoGenerationTerminalUpdateInTransaction(scopedDb, input);
+    }
+  );
+}
+async function markVideoGenerationTerminalUpdateInTransaction(tx, input) {
+  const allowed = input.state === "leased" ? ["pending", "leased"] : input.state === "delivered" ? ["leased"] : ["pending", "leased"];
+  const [updated] = await tx.update(videoGenerationOperations).set({
+    terminalUpdateState: input.state,
+    terminalUpdateId: input.state === "suppressed" ? null : input.updateId ?? null,
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(
+    and(
+      eq(videoGenerationOperations.workspaceId, input.workspaceId),
+      eq(videoGenerationOperations.id, input.operationId),
+      inArray(videoGenerationOperations.terminalUpdateState, allowed),
+      ...input.state === "delivered" && input.updateId ? [eq(videoGenerationOperations.terminalUpdateId, input.updateId)] : []
+    )
+  ).returning({ id: videoGenerationOperations.id });
+  return updated !== void 0;
+}
+function mediaGenerationResultForOperation(input) {
+  if (input.operation.status === "completed" && input.readyReceipt) {
+    return {
+      type: "media_generation_result",
+      schemaVersion: 1,
+      status: "ready",
+      operationId: input.operation.id,
+      receipt: input.readyReceipt
+    };
+  }
+  const failureStatus = input.operation.status;
+  if (!inArrayValue(failureStatus, [
+    "provider_failed",
+    "retention_failed",
+    "cancelled_before_submit",
+    "outcome_unknown"
+  ])) {
+    throw new Error("Video generation operation is not terminal");
+  }
+  return {
+    type: "media_generation_result",
+    schemaVersion: 1,
+    status: failureStatus,
+    operationId: input.operation.id,
+    boundedPublicReason: input.operation.boundedPublicReason ?? "Video generation did not complete."
+  };
+}
+async function mediaGenerationResultForStoredOperation(db, operation) {
+  if (operation.status !== "completed") {
+    return mediaGenerationResultForOperation({ operation });
+  }
+  const retained = await getGeneratedVideoArtifact(
+    db,
+    operation.workspaceId,
+    operation.expectedArtifactId
+  );
+  if (!retained || retained.artifact.deletedAt) {
+    throw new Error("Completed video generation lost its retained artifact");
+  }
+  const artifact = retainedGeneratedVideoReferenceFromFile({
+    id: retained.artifact.id,
+    workspaceId: retained.artifact.workspaceId,
+    status: retained.file.status,
+    contentType: retained.file.contentType,
+    sizeBytes: retained.file.sizeBytes,
+    sha256: retained.file.sha256,
+    updatedAt: retained.artifact.readyAt.toISOString(),
+    width: retained.artifact.width,
+    height: retained.artifact.height
+  });
+  if (!artifact) throw new Error("Generated video receipt could not be constructed");
+  const receipt = GeneratedVideoReceipt.parse({
+    type: "generated_video",
+    schemaVersion: 1,
+    operationId: operation.id,
+    artifact,
+    video: {
+      durationSeconds: retained.artifact.durationMillis / 1e3,
+      width: retained.artifact.width,
+      height: retained.artifact.height,
+      fps: retained.artifact.fpsMilli / 1e3,
+      hasAudio: retained.artifact.hasAudio,
+      videoCodec: retained.artifact.videoCodec,
+      audioCodec: retained.artifact.audioCodec
+    },
+    sandboxPath: `/workspace/generated-videos/${retained.artifact.sandboxFilename}`
+  });
+  return mediaGenerationResultForOperation({
+    operation,
+    readyReceipt: receipt
+  });
+}
+async function getVideoGenerationOperationSummary(db, workspaceId, operationId) {
+  const operation = await getVideoGenerationOperation(db, workspaceId, operationId);
+  if (!operation) return null;
+  const terminal = inArrayValue(operation.status, [
+    "completed",
+    "provider_failed",
+    "cancelled_before_submit",
+    "outcome_unknown",
+    "retention_failed"
+  ]) ? await mediaGenerationResultForStoredOperation(db, operation) : null;
+  return VideoGenerationOperationSummary.parse({
+    schemaVersion: 1,
+    operationId: operation.id,
+    modelId: operation.modelId,
+    status: operation.status === "submission_uncertain" ? "accepted" : operation.status,
+    createdAt: operation.createdAt.toISOString(),
+    updatedAt: operation.updatedAt.toISOString(),
+    terminal
+  });
+}
+async function mutateOperation(db, input, mutate) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (txRaw) => {
+      const tx = txRaw;
+      const [operation] = await tx.select().from(videoGenerationOperations).where(
+        and(
+          eq(videoGenerationOperations.workspaceId, input.workspaceId),
+          eq(videoGenerationOperations.id, input.operationId),
+          eq(videoGenerationOperations.requestDigest, input.requestDigest)
+        )
+      ).for("update").limit(1);
+      if (!operation) throw new VideoGenerationConflictError("Video operation not found");
+      return await mutate(tx, operation);
+    })
+  );
+}
+async function releaseReservedQuota(tx, operation, ready) {
+  if (operation.quotaState !== "reserved") return;
+  await tx.update(workspaceVideoGenerationQuotas).set({
+    reservedBytes: sql`${workspaceVideoGenerationQuotas.reservedBytes} - ${operation.reservedBytes}`,
+    ...ready ? {
+      readyBytes: sql`${workspaceVideoGenerationQuotas.readyBytes} + ${operation.reservedBytes}`
+    } : {},
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(eq(workspaceVideoGenerationQuotas.workspaceId, operation.workspaceId));
+}
+async function debitVideoGenerationCredits(tx, operation) {
+  if (operation.pricedCostMicros <= 0 || operation.fundingSource !== "opengeni_credits") {
+    throw new Error("Managed video credit debit has an invalid funding binding");
+  }
+  await tx.execute(sql`select pg_advisory_xact_lock(hashtext(${operation.accountId}))`);
+  const [balanceRow] = await tx.select({
+    balanceMicros: sql`coalesce(sum(${creditLedgerEntries.amountMicros}), 0)`
+  }).from(creditLedgerEntries).where(eq(creditLedgerEntries.accountId, operation.accountId));
+  const balanceMicros = Number(balanceRow?.balanceMicros ?? 0);
+  if (!Number.isSafeInteger(balanceMicros) || balanceMicros < operation.pricedCostMicros) {
+    throw new VideoGenerationCreditError();
+  }
+  const now = /* @__PURE__ */ new Date();
+  const inserted = await tx.insert(creditLedgerEntries).values({
+    accountId: operation.accountId,
+    workspaceId: operation.workspaceId,
+    type: "video_generation_debit",
+    amountMicros: -operation.pricedCostMicros,
+    sourceType: "video_generation_operation",
+    sourceId: operation.id,
+    idempotencyKey: `credit:video_generation_debit:${operation.id}`,
+    metadata: {
+      modelId: operation.modelId,
+      sourceMode: operation.sourceMode,
+      pricedCostMicros: operation.pricedCostMicros
+    },
+    occurredAt: now
+  }).onConflictDoNothing({ target: creditLedgerEntries.idempotencyKey }).returning({ id: creditLedgerEntries.id });
+  if (inserted.length !== 1) {
+    throw new VideoGenerationConflictError("Video generation credit debit already exists");
+  }
+  await tx.insert(usageEvents).values({
+    accountId: operation.accountId,
+    workspaceId: operation.workspaceId,
+    eventType: "video_generation.cost",
+    quantity: operation.pricedCostMicros,
+    unit: "usd_micros",
+    sourceResourceType: "video_generation_operation",
+    sourceResourceId: operation.id,
+    sessionId: operation.sessionId,
+    turnId: operation.turnId,
+    turnAttemptId: operation.attemptId,
+    idempotencyKey: `usage:video_generation.cost:${operation.id}`,
+    occurredAt: now
+  }).onConflictDoNothing({ target: usageEvents.idempotencyKey });
+}
+async function refundVideoGenerationCredits(tx, operation, now) {
+  if (operation.creditState !== "debited") return operation.creditState;
+  if (operation.fundingSource !== "opengeni_credits" || operation.pricedCostMicros <= 0) {
+    throw new Error("Video generation credit refund has an invalid funding binding");
+  }
+  await tx.execute(sql`select pg_advisory_xact_lock(hashtext(${operation.accountId}))`);
+  const inserted = await tx.insert(creditLedgerEntries).values({
+    accountId: operation.accountId,
+    workspaceId: operation.workspaceId,
+    type: "video_generation_refund",
+    amountMicros: operation.pricedCostMicros,
+    sourceType: "video_generation_operation",
+    sourceId: operation.id,
+    idempotencyKey: `credit:video_generation_refund:${operation.id}`,
+    metadata: {
+      modelId: operation.modelId,
+      sourceMode: operation.sourceMode,
+      pricedCostMicros: operation.pricedCostMicros
+    },
+    occurredAt: now
+  }).onConflictDoNothing({ target: creditLedgerEntries.idempotencyKey }).returning({ id: creditLedgerEntries.id });
+  if (inserted.length !== 1) {
+    throw new VideoGenerationConflictError("Video generation credit refund already exists");
+  }
+  await tx.insert(usageEvents).values({
+    accountId: operation.accountId,
+    workspaceId: operation.workspaceId,
+    eventType: "video_generation.refund",
+    quantity: operation.pricedCostMicros,
+    unit: "usd_micros",
+    sourceResourceType: "video_generation_operation",
+    sourceResourceId: operation.id,
+    sessionId: operation.sessionId,
+    turnId: operation.turnId,
+    turnAttemptId: operation.attemptId,
+    idempotencyKey: `usage:video_generation.refund:${operation.id}`,
+    occurredAt: now
+  }).onConflictDoNothing({ target: usageEvents.idempotencyKey });
+  return "refunded";
+}
+function policyFromRow(row) {
+  return VideoGenerationPolicy.parse(
+    row ? {
+      schemaVersion: 1,
+      revision: row.revision,
+      fundingSource: row.fundingSource,
+      enabledModelIds: row.enabledModelIds,
+      defaultModelId: row.defaultModelId
+    } : {
+      schemaVersion: 1,
+      revision: 0,
+      fundingSource: "workspace_gateway",
+      enabledModelIds: [],
+      defaultModelId: null
+    }
+  );
+}
+function assertSupportedModels(modelIds) {
+  for (const modelId of modelIds) {
+    if (modelId !== SEEDANCE_2_5_MODEL_ID && modelId !== GROK_IMAGINE_VIDEO_1_5_MODEL_ID) {
+      throw new Error(`Unknown video generation model: ${modelId}`);
+    }
+  }
+}
+function assertAdmissionMatches(operation, input) {
+  if (operation.requestDigest !== input.requestDigest || operation.toolCallId !== input.toolCallId || operation.sessionId !== input.sessionId || operation.turnId !== input.turnId || operation.fundingSource !== input.fundingSource || operation.pricedCostMicros !== input.pricedCostMicros) {
+    throw new VideoGenerationConflictError(
+      "Video generation admission key was reused with different arguments"
+    );
+  }
+}
+function inPreSubmitState(status) {
+  return inArrayValue(status, ["preparing", "prepared", "accepted"]);
+}
+function inArrayValue(value, candidates) {
+  return candidates.includes(value);
+}
+function invalidTransition(operation, target) {
+  return new VideoGenerationConflictError(
+    `Invalid video generation transition ${operation.status} -> ${target}`
+  );
+}
+function requireRow(value, action) {
+  if (!value) throw new Error(`Failed to ${action}`);
+  return value;
+}
+function boundPublicReason(value) {
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  return (normalized || "Video generation did not complete.").slice(0, 1e3);
+}
+function boundPrivateError(value) {
+  return value.replace(/\s+/gu, " ").trim().slice(0, 4096);
+}
+
+export {
+  ACTIVE_VIDEO_GENERATION_STATUSES,
+  VideoGenerationConflictError,
+  VideoGenerationCapacityError,
+  VideoGenerationCreditError,
+  getWorkspaceVideoGenerationPolicy,
+  updateWorkspaceVideoGenerationPolicy,
+  admitVideoGenerationOperation,
+  rotateVideoGenerationCredential,
+  markVideoGenerationPrepared,
+  markVideoGenerationAccepted,
+  markVideoGenerationAcceptedInTransaction,
+  cancelVideoGenerationBeforeSubmit,
+  cancelUnacceptedVideoGenerationsForToolCallsInTransaction,
+  claimVideoGenerationOperations,
+  getVideoGenerationOperation,
+  markVideoGenerationSubmissionUncertain,
+  markVideoGenerationSubmissionIntent,
+  markVideoGenerationProviderStarted,
+  rescheduleVideoGenerationOperation,
+  markVideoGenerationRetaining,
+  settleVideoGenerationFailure,
+  settleVideoGenerationReady,
+  getGeneratedVideoArtifact,
+  listSessionGeneratedVideoArtifacts,
+  markVideoGenerationReferenceCleaned,
+  markVideoGenerationTerminalUpdate,
+  markVideoGenerationTerminalUpdateInTransaction,
+  mediaGenerationResultForOperation,
+  mediaGenerationResultForStoredOperation,
+  getVideoGenerationOperationSummary
+};
+//# sourceMappingURL=chunk-CQZ4QSP5.js.map