@vivix-labs/project-studio 0.0.0-stage → 1.0.0-beta

package/dist/server.js

@@ -0,0 +1,3502 @@
+// packages/project-studio/src/events.ts
+import { z as z2 } from "vivix-studio/sdk/shared";
+
+// packages/vivix-api/src/billing.ts
+import { z } from "vivix-studio/sdk/shared";
+var taskBilling = z.object({
+  status: z.enum(["pending", "settled", "released", "unavailable"]),
+  credits: z.string().regex(/^\d+(?:\.\d+)?$/).nullable()
+}).strict().refine(
+  (value) => value.status === "settled" ? value.credits !== null : value.status === "released" ? value.credits === "0" : value.credits === null
+);
+function readTaskBilling(response) {
+  const parsed = taskBilling.safeParse(response?.billing);
+  return parsed.success ? parsed.data : { status: "unavailable", credits: null };
+}
+
+// packages/project-studio/src/events.ts
+var taskEventNames = [
+  "project-studio/task.completed",
+  "project-studio/task.failed",
+  "project-studio/task.cancelled",
+  "project-studio/billing.updated"
+];
+var result = z2.object({
+  remoteTaskId: z2.string(),
+  outputIndex: z2.number().int().nonnegative(),
+  assetId: z2.string().optional()
+}).strict();
+var taskNotice = z2.object({
+  taskId: z2.string(),
+  attemptId: z2.string(),
+  revision: z2.number().int().positive(),
+  requestedCount: z2.number().int().positive().nullable(),
+  resultCount: z2.number().int().nonnegative().nullable(),
+  partialResults: z2.boolean().nullable(),
+  results: z2.array(result)
+}).strict();
+var billingNotice = z2.object({
+  taskId: z2.string(),
+  attemptId: z2.string(),
+  billingRecordId: z2.string(),
+  revision: z2.number().int().positive()
+}).strict();
+var eventDefinitions = taskEventNames.map((name) => ({
+  name,
+  version: 1,
+  mode: "notification",
+  schema: name.endsWith("billing.updated") ? "schemas/billing-notice.json" : "schemas/task-notice.json",
+  scope: "project"
+}));
+var stateKey = "project-studio.state";
+function saved(record) {
+  const value = record.metadata?.[stateKey];
+  return value?.format === 1 && value.remote && Number.isSafeInteger(value.remote.revision) ? value : void 0;
+}
+function readableResults(record) {
+  if (typeof record.data.remoteTaskId !== "string" || !record.data.remoteTaskId) return [];
+  return (record.data.remoteOutputs || []).flatMap((value, outputIndex) => {
+    if (!value || typeof value !== "object") return [];
+    const output = value;
+    return ["asset_id", "file_id", "id", "url", "download_url", "content", "text"].some(
+      (k) => typeof output[k] === "string" && Boolean(output[k])
+    ) ? [{ remoteTaskId: record.data.remoteTaskId, outputIndex }] : [];
+  });
+}
+function outcome(record) {
+  const d = record.data;
+  if (d.remoteStatus === "succeeded" && readableResults(record).length) return "succeeded";
+  if (d.remoteStatus === "failed") return "failed";
+  if (["cancelled", "canceled"].includes(d.remoteStatus) || d.state === "canceled" && !d.submittedAt && !d.remoteTaskId && d.attemptCount === 0)
+    return "cancelled";
+  return "unknown";
+}
+function taskState(record) {
+  const old = saved(record), status = outcome(record);
+  const requestedCount = Number.isInteger(record.data.inputSnapshot?.outputCount) ? record.data.inputSnapshot.outputCount : null;
+  const resultSignature = JSON.stringify(readableResults(record));
+  const storedCount = Array.isArray(record.data.remoteOutputs) ? record.data.remoteOutputs.length : null;
+  const unchanged = old?.remote.status === status && old.remote.requestedCount === requestedCount && old.remote.resultSignature === resultSignature && (old.remote.resultCount === null || old.remote.resultCount === storedCount);
+  const resultCount = status === "unknown" ? null : unchanged ? old.remote.resultCount : record.data.remoteOutputs?.length ? record.data.remoteOutputs.length : null;
+  return {
+    format: 1,
+    remote: {
+      status,
+      revision: unchanged ? old.remote.revision : record.revision,
+      requestedCount,
+      resultCount,
+      partialResults: requestedCount !== null && resultCount !== null ? resultCount < requestedCount : null,
+      resultSignature
+    },
+    billing: currentBilling(record, old?.billing)
+  };
+}
+function stateMetadata(before, data, observation) {
+  const previous = taskState(before), next = taskState({ ...before, data, metadata: {} });
+  if (observation && next.remote.status !== "unknown")
+    next.remote.resultCount = observation.resultCount;
+  else if (previous.remote.status === next.remote.status)
+    next.remote.resultCount = previous.remote.resultCount;
+  next.remote.partialResults = next.remote.requestedCount !== null && next.remote.resultCount !== null ? next.remote.resultCount < next.remote.requestedCount : null;
+  const signature = ({ revision: _, ...r }) => JSON.stringify(r);
+  next.remote.revision = signature(next.remote) === signature(previous.remote) ? previous.remote.revision : before.revision + 1;
+  const view = billingViewFromI4(
+    before,
+    data.cost ?? { status: "unavailable", credits: null },
+    before.revision + 1
+  );
+  const semanticDigest = billingDigest(view);
+  next.billing = {
+    billingRecordId: view.billingRecordId,
+    semanticDigest,
+    revision: previous.billing?.semanticDigest === semanticDigest ? previous.billing.revision : before.revision + 1
+  };
+  return { ...before.metadata, [stateKey]: next };
+}
+function taskProjection(record) {
+  const s = taskState(record), d = record.data;
+  const localPersistence = d.state === "succeeded" ? "saved" : d.state === "partial" ? "partial" : d.state === "save_failed" ? "failed" : d.state === "saving" && d.outputRefs?.length ? "partial" : "pending";
+  return {
+    ...record,
+    projection: {
+      attemptId: record.objectId,
+      remoteOutcome: s.remote,
+      localPersistence,
+      billing: taskBillingView(record)
+    }
+  };
+}
+function billingViewFromI4(record, cost, revision2) {
+  const { status, credits } = readTaskBilling({
+    billing: { status: cost.status, credits: cost.credits }
+  });
+  return {
+    billingRecordId: JSON.stringify([
+      record.storeId,
+      record.scope?.id,
+      record.objectId,
+      "task.cost"
+    ]),
+    taskId: record.objectId,
+    attemptId: record.objectId,
+    revision: revision2,
+    status,
+    amount: status === "settled" || status === "released" ? { value: credits.replace(/^0+(?=\d)/, ""), unit: "credits" } : null
+  };
+}
+function normalizeDecimal(value) {
+  const [whole, fraction = ""] = value.split(".");
+  const trimmed = fraction.replace(/0+$/, "");
+  return whole.replace(/^0+(?=\d)/, "") + (trimmed ? "." + trimmed : "");
+}
+function billingDigest(view) {
+  return JSON.stringify([
+    view.status,
+    view.amount && { ...view.amount, value: normalizeDecimal(view.amount.value) }
+  ]);
+}
+function currentBilling(record, old) {
+  const view = billingViewFromI4(
+    record,
+    record.data.cost ?? { status: "unavailable", credits: null },
+    record.revision
+  );
+  const semanticDigest = billingDigest(view);
+  return {
+    billingRecordId: view.billingRecordId,
+    semanticDigest,
+    revision: old?.semanticDigest === semanticDigest ? old.revision : record.revision
+  };
+}
+function taskBillingView(record) {
+  const state = taskState(record);
+  return billingViewFromI4(
+    record,
+    record.data.cost ?? { status: "unavailable", credits: null },
+    state.billing?.revision ?? record.revision
+  );
+}
+function notifyCommitted(events, before, after, diagnostic = (code) => console.error(code)) {
+  void (async () => {
+    const old = structuredClone(before), committed = structuredClone(after);
+    const a = taskState(old), b = taskState(committed), scope = events();
+    if (b.remote.status !== "unknown" && (a.remote.status !== b.remote.status || a.remote.revision !== b.remote.revision)) {
+      const name = b.remote.status === "succeeded" ? taskEventNames[0] : b.remote.status === "failed" ? taskEventNames[1] : taskEventNames[2];
+      const results = readableResults(committed);
+      await scope.emit(name, {
+        version: 1,
+        occurredAt: committed.updatedAt,
+        correlation: { taskId: committed.objectId, attemptId: committed.objectId },
+        entity: { type: "task", id: committed.objectId, revision: b.remote.revision },
+        payload: {
+          taskId: committed.objectId,
+          attemptId: committed.objectId,
+          revision: b.remote.revision,
+          requestedCount: b.remote.requestedCount,
+          resultCount: b.remote.resultCount,
+          partialResults: b.remote.partialResults,
+          results
+        }
+      });
+    }
+    if (b.billing && b.billing.revision !== a.billing?.revision)
+      await scope.emit(taskEventNames[3], {
+        version: 1,
+        occurredAt: committed.updatedAt,
+        correlation: { taskId: committed.objectId, attemptId: committed.objectId },
+        entity: { type: "billing", id: b.billing.billingRecordId, revision: b.billing.revision },
+        payload: {
+          taskId: committed.objectId,
+          attemptId: committed.objectId,
+          billingRecordId: b.billing.billingRecordId,
+          revision: b.billing.revision
+        }
+      });
+  })().catch(() => {
+    try {
+      diagnostic("EVENT_NOTIFICATION_FAILED");
+    } catch {
+    }
+  });
+}
+
+// packages/project-studio/src/ads.ts
+import { createHash as createHash2 } from "crypto";
+
+// packages/project-studio/src/ads-shared.ts
+import { z as z3 } from "vivix-studio/sdk/shared";
+var fixedRef = z3.object({ storeId: z3.uuid(), objectId: z3.uuid(), versionId: z3.uuid() }).strict();
+var copy = z3.string().max(8e3).default("");
+var clipScript = z3.object({
+  title: z3.string().trim().min(1).max(200),
+  visual: copy,
+  voiceover: copy,
+  onScreenText: copy,
+  cta: copy,
+  plannedDurationMs: z3.number().int().positive().nullable().default(null)
+}).strict();
+var adBrief = z3.object({
+  product: copy,
+  category: copy,
+  audience: copy,
+  sellingPoints: copy,
+  channel: copy,
+  aspectRatio: z3.string().max(40).nullable().default(null),
+  targetDurationMs: z3.number().int().positive().nullable().default(null),
+  body: copy,
+  productRefs: z3.array(fixedRef).max(100).default([]),
+  modelRefs: z3.array(fixedRef).max(100).default([])
+}).strict();
+var adStoryboard = z3.object({
+  brief: adBrief,
+  clips: z3.array(
+    z3.object({
+      assetId: z3.uuid(),
+      script: clipScript,
+      edits: z3.array(z3.object({ sourceVersionId: z3.uuid(), editRef: fixedRef }).strict()).max(200)
+    }).strict()
+  ).max(200)
+}).strict().superRefine((value, context) => {
+  if (new Set(value.clips.map((c) => c.assetId)).size !== value.clips.length)
+    context.addIssue({ code: "custom", message: "A clip can appear only once in a storyboard." });
+  for (const clip of value.clips)
+    if (new Set(clip.edits.map((e) => e.sourceVersionId)).size !== clip.edits.length)
+      context.addIssue({
+        code: "custom",
+        message: "Each candidate has one current edit binding."
+      });
+});
+var adTypeId = "studio.adStoryboard";
+
+// packages/project-studio/src/cost.ts
+function taskCostLabel(task) {
+  const cost = task.cost;
+  if (cost?.status === "settled" && cost.credits != null) return `${cost.credits} credits`;
+  if (cost?.status === "pending") return "Pending settlement";
+  return "-";
+}
+
+// packages/project-studio/src/shared.ts
+import { z as z4, defineOperation } from "vivix-studio/sdk/shared";
+var studioConfig = z4.object({
+  role: z4.enum(["project", "coordinator"]).default("project"),
+  dataInstance: z4.string().min(1).default("user:data"),
+  apiInstance: z4.string().min(1).default("api"),
+  libraryInstance: z4.string().min(1).nullable().default(null)
+}).strict();
+var versionRef = z4.object({ storeId: z4.uuid(), objectId: z4.uuid(), versionId: z4.uuid() }).strict();
+var tags = z4.array(z4.string().trim().min(1).max(64)).max(50).transform((x) => [...new Set(x)]).default([]);
+var kind = z4.enum(["text", "image", "video", "audio", "file"]);
+var projectData = z4.object({
+  name: z4.string().trim().min(1).max(120),
+  description: z4.string().max(4e3).default(""),
+  status: z4.enum(["draft", "active", "archived"]).default("draft"),
+  aspectRatio: z4.string().nullable().default(null),
+  coverRef: versionRef.nullable().default(null),
+  briefRef: z4.object({ storeId: z4.uuid(), objectId: z4.uuid() }).strict().nullable().default(null),
+  tags
+}).strict();
+var assetData = z4.object({
+  projectId: z4.uuid(),
+  name: z4.string().trim().min(1).max(200),
+  kind,
+  purpose: z4.enum(["reference", "script", "shot", "music", "voice", "subtitle", "final", "other"]).default("other"),
+  origin: z4.enum(["upload", "library", "generated", "authored"]),
+  orderKey: z4.number().int().nullable().default(null),
+  tags,
+  lifecycle: z4.enum(["draft", "ready", "archived"]).default("draft"),
+  sourceRef: versionRef.nullable().default(null),
+  adoptedVersionId: z4.uuid().nullable().default(null)
+}).strict();
+var taskStates = [
+  "queued",
+  "submitting",
+  "submission_unknown",
+  "running",
+  "cancel_requested",
+  "remote_succeeded",
+  "saving",
+  "save_failed",
+  "partial",
+  "succeeded",
+  "failed",
+  "canceled"
+];
+var anchor = z4.discriminatedUnion("kind", [
+  z4.object({ kind: z4.literal("whole") }).strict(),
+  z4.object({
+    kind: z4.literal("timeRange"),
+    startMs: z4.number().int().nonnegative(),
+    endMs: z4.number().int().nonnegative()
+  }).strict()
+]);
+var generationInput = z4.object({
+  targetAssetId: z4.uuid().optional(),
+  taskName: z4.string().trim().min(1).max(200).optional(),
+  context: z4.record(z4.string().min(1).max(64), z4.string().min(1).max(200)).optional(),
+  expectedRevision: z4.number().int().positive().optional(),
+  newAsset: z4.object({
+    name: z4.string().trim().min(1).max(200),
+    kind: z4.enum(["image", "video", "audio"])
+  }).strict().optional(),
+  modelId: z4.string().min(1),
+  capabilityId: z4.string().min(1),
+  prompt: z4.string().max(32e3),
+  parameters: z4.record(z4.string(), z4.unknown()).default({}),
+  outputCount: z4.number().int().min(1).max(100).default(1),
+  inputs: z4.array(
+    z4.object({
+      ref: versionRef,
+      role: z4.string().min(1),
+      order: z4.number().int().nonnegative(),
+      weight: z4.number().finite().nullable().default(null)
+    }).strict()
+  ).max(100).default([]),
+  baseVersionId: z4.uuid().optional(),
+  changeRequest: z4.string().trim().min(1).max(4e3).optional(),
+  preserveRequest: z4.string().max(4e3).default(""),
+  anchor: anchor.default({ kind: "whole" }),
+  retryOfTaskId: z4.uuid().optional(),
+  acknowledgeUnknown: z4.boolean().optional()
+}).strict();
+var projectSettingsInput = z4.object({
+  projectId: z4.uuid(),
+  expectedRevision: z4.number().int().positive(),
+  changes: projectData.pick({ name: true, description: true, tags: true, aspectRatio: true, coverRef: true }).extend({
+    description: projectData.shape.description.unwrap(),
+    tags: projectData.shape.tags.unwrap(),
+    aspectRatio: projectData.shape.aspectRatio.unwrap(),
+    coverRef: projectData.shape.coverRef.unwrap()
+  }).partial().strict()
+}).strict();
+var generationSubmitOperation = defineOperation({
+  id: "generation.submit",
+  title: "Generate",
+  description: "Submit one media generation without approval, retaining its paid request identity.",
+  input: generationInput,
+  output: z4.any(),
+  effects: ["write", "paid"],
+  confirm: "none"
+});
+var favoriteData = z4.object({ ref: versionRef }).strict();
+var sqlScalar = z4.union([z4.string(), z4.number().finite(), z4.null()]);
+var globalQueryInput = z4.object({
+  sql: z4.string().trim().min(1),
+  params: z4.union([z4.array(sqlScalar), z4.record(z4.string(), sqlScalar)]).optional(),
+  timeoutMs: z4.number().int().positive().optional(),
+  maxRows: z4.number().int().positive().optional(),
+  limit: z4.number().int().min(1).max(200).optional(),
+  offset: z4.number().int().nonnegative().optional(),
+  source: z4.enum(["projects", "assets", "tasks"]),
+  catalog: z4.array(z4.object({ id: z4.string().min(1), name: z4.string(), available: z4.boolean() }).strict()).optional()
+}).strict();
+
+// packages/project-studio/src/assets.ts
+import { createHash } from "crypto";
+import { PluginError } from "vivix-studio/sdk/shared";
+function reject(code, message, revision2) {
+  throw new PluginError(
+    code,
+    message,
+    "Refresh the current project state and retry the original operation.",
+    { currentRevision: revision2 }
+  );
+}
+var Assets = class {
+  constructor(data, workspace, library) {
+    this.data = data;
+    this.workspace = workspace;
+    this.library = library;
+  }
+  data;
+  workspace;
+  library;
+  assertWritable() {
+    const p = this.data.get(this.data.scope.id);
+    if (p.typeId !== "studio.project" || p.data.status === "archived")
+      reject("PROJECT_ARCHIVED", "Restore the project before creating or changing content.");
+  }
+  get(id2, deleted = false) {
+    const a = this.data.get(id2, deleted);
+    if (a.typeId !== "studio.asset") reject("TYPE_MISMATCH", "Expected a project asset.");
+    return a;
+  }
+  async describe(id2) {
+    const object = this.get(id2, true), versions = this.data.versions(id2), latest = versions.at(-1);
+    const adopted = versions.find((v) => v.versionId === object.data.adoptedVersionId);
+    return {
+      ...object,
+      versions,
+      latestVersionId: latest?.versionId || null,
+      adoptedVersionId: adopted?.versionId || null,
+      newCandidateCount: versions.filter((v) => !adopted || v.versionNumber > adopted.versionNumber).length,
+      reviewState: !latest ? "none" : adopted ? "adopted" : "pending",
+      availability: latest ? await this.data.availability({
+        storeId: this.data.storeId,
+        objectId: id2,
+        versionId: latest.versionId
+      }) : "no_content"
+    };
+  }
+  async import(input, call, existing = false, intent = input, operationName = existing ? "assets.importVersion" : "assets.import") {
+    this.assertWritable();
+    const replay = this.data.reserve(operationName, intent, call);
+    if (replay) return replay.result;
+    const op = stableId(this.data.storeId, call, operationName);
+    const objectId = existing ? input.assetId : stableId(op, call, "object"), versionId = stableId(op, call, "version");
+    const prior = existing ? this.get(objectId) : void 0;
+    const pub = await this.data.publish(
+      input.stagingFileIds,
+      objectId,
+      versionId,
+      op,
+      call.actor.id,
+      input.fileRoles
+    );
+    if (!["text", "image", "video", "audio"].includes(pub.kind))
+      reject("UNSUPPORTED_MEDIA", "Import text, image, video or audio content.");
+    if (prior && pub.kind !== prior.data.kind)
+      reject("TYPE_MISMATCH", "New content must have the same actual kind as the asset.");
+    if (input.kind && input.kind !== pub.kind)
+      reject("TYPE_MISMATCH", "Actual content kind does not match the requested kind.");
+    const result2 = this.data.operation(operationName, intent, call, (t) => {
+      return this.commitPreparedImport(t, input, pub, objectId, versionId, existing);
+    });
+    await this.data.finishFiles(op);
+    return result2;
+  }
+  commitPreparedImport(t, input, pub, objectId, versionId, existing = false) {
+    const object = existing ? t.get(objectId) : t.create(
+      "studio.asset",
+      assetData.parse({
+        projectId: this.data.scope.id,
+        name: input.name,
+        kind: pub.kind,
+        origin: input.origin || "upload",
+        sourceRef: input.sourceRef || null,
+        tags: input.tags
+      }),
+      input.metadata || {},
+      objectId
+    );
+    const version = t.commitVersion(objectId, existing ? input.expectedRevision : object.revision, {
+      versionId,
+      parentVersionId: input.parentVersionId,
+      sourceRef: input.sourceRef,
+      origin: input.origin === "authored" ? "authored" : input.sourceRef ? "copied" : "upload",
+      payload: { ...input.sourcePayload, ...payload(pub, input.sourcePayload?.generation) },
+      metadata: input.versionMetadata,
+      files: pub.files
+    });
+    selectFirstAdCandidate(this.data, t, objectId, version.versionId);
+    return { asset: t.get(objectId), version };
+  }
+  async text(input, call) {
+    this.assertWritable();
+    const name = input.assetId ? "assets.saveText" : "assets.createText", replay = this.data.reserve(name, input, call);
+    if (replay) return replay.result;
+    const staged = await this.data.stageText(input.text, call.actor.id);
+    return this.import(
+      { ...input, origin: "authored", kind: "text", stagingFileIds: [staged.stagingFileId] },
+      call,
+      Boolean(input.assetId),
+      input,
+      name
+    );
+  }
+  update(input, call) {
+    this.assertWritable();
+    return this.data.operation("assets.update", input, call, (t) => {
+      const a = this.get(input.assetId);
+      return t.update(a.objectId, input.expectedRevision, { ...a.data, ...input.changes });
+    });
+  }
+  async adopt(input, call, clear = false) {
+    this.assertWritable();
+    const a = this.get(input.assetId);
+    if (!clear) {
+      const ref = { storeId: this.data.storeId, objectId: a.objectId, versionId: input.versionId };
+      this.data.version(ref);
+      await this.data.location(ref);
+    }
+    return this.data.operation(
+      clear ? "choices.clear" : "choices.adopt",
+      input,
+      call,
+      (t) => t.update(a.objectId, input.expectedRevision, {
+        ...t.get(a.objectId).data,
+        adoptedVersionId: clear ? null : input.versionId
+      })
+    );
+  }
+  remove(input, call) {
+    this.assertWritable();
+    const result2 = this.data.operation("assets.delete", input, call, (t) => {
+      const a = this.get(input.assetId);
+      return t.update(
+        a.objectId,
+        input.expectedRevision,
+        a.data,
+        void 0,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    });
+    this.removeUsages(input.assetId, call);
+    return result2;
+  }
+  removeUsages(assetId, call) {
+    this.library?.removeUsage(
+      { projectId: this.data.scope.id, targetAssetId: assetId },
+      this.libraryCall(call, "remove-" + assetId)
+    );
+  }
+  libraryCall(call, suffix) {
+    const originalRequestKey = call.originalRequestKey || call.requestKey;
+    return {
+      scope: this.data.scope,
+      actor: call.actor,
+      requestKey: originalRequestKey ? "studio-lib-" + createHash("sha256").update(JSON.stringify([this.data.scope, call.actor.id, originalRequestKey, suffix])).digest("hex") : void 0,
+      originalRequestKey,
+      sourceOperation: suffix,
+      confirmation: call.confirmation
+    };
+  }
+  async copy(source, ref, input, call, existing = false) {
+    this.assertWritable();
+    const operationName = existing ? "assets.updateFromMaterial" : "assets.importMaterial", intent = { ref, ...input };
+    const replay = this.data.reserve(operationName, intent, call);
+    let result2 = replay?.result;
+    if (!result2) {
+      if (typeof source === "function") source = await source();
+      const snapshot = "material" in source ? source : null;
+      const original = snapshot ? snapshot.material : source.get(ref.objectId);
+      const v = snapshot ? snapshot.version : source.version(ref);
+      const files = snapshot ? snapshot.files : source.files(ref);
+      const ids = [], roles = [];
+      for (const f of files) {
+        let stream;
+        if (snapshot) stream = snapshot.files.find((file) => file.fileId === f.fileId).source;
+        else {
+          const loc = await source.location(ref, f.fileId);
+          const { createReadStream } = await import("fs");
+          stream = createReadStream(loc.absolutePath);
+        }
+        roles.push(f.role);
+        ids.push((await this.data.stage(stream, f.originalName, call.actor.id)).stagingFileId);
+      }
+      result2 = await this.import(
+        {
+          ...input,
+          name: input.name || original.data.name,
+          kind: v.payload.kind,
+          sourceRef: ref,
+          sourcePayload: v.payload,
+          metadata: original.metadata,
+          versionMetadata: v.metadata,
+          parentVersionId: existing ? input.parentVersionId || this.data.versions(input.assetId).at(-1)?.versionId : void 0,
+          origin: "library",
+          stagingFileIds: ids,
+          fileRoles: roles
+        },
+        call,
+        existing,
+        intent,
+        operationName
+      );
+    }
+    if (this.library)
+      this.library.reportUsage(
+        {
+          materialRef: ref,
+          projectId: this.data.scope.id,
+          targetAssetId: result2.asset.objectId,
+          targetVersionId: result2.version.versionId,
+          name: result2.asset.data.name
+        },
+        this.libraryCall(call, "usage-" + result2.version.versionId)
+      );
+    return result2;
+  }
+  async collect(input, call) {
+    this.assertWritable();
+    if (!this.library)
+      reject("LIBRARY_UNAVAILABLE", "Configure a material library before publishing.");
+    const ref = input.ref;
+    const object = this.get(ref.objectId), version = this.data.version(ref), project = this.data.get(this.data.scope.id);
+    const { createReadStream } = await import("fs");
+    const files = [];
+    for (const f of this.data.files(ref)) {
+      const loc = await this.data.location(ref, f.fileId);
+      files.push({ ...f, source: createReadStream(loc.absolutePath) });
+    }
+    return this.library.publish(
+      {
+        projectId: this.data.scope.id,
+        ref,
+        sourceLabel: {
+          projectName: project.data.name,
+          objectName: object.data.name,
+          versionNumber: version.versionNumber
+        },
+        name: input.name,
+        kind: version.payload.kind,
+        payload: version.payload,
+        metadata: version.metadata,
+        files
+      },
+      this.libraryCall(call, "publish")
+    );
+  }
+};
+function stableId(seed, call, name) {
+  if (!call.requestKey) reject("INVALID_REQUEST_KEY", "A stable request key is required.");
+  if (!call.scope) reject("SCOPE_MISMATCH", "A bound business scope is required.");
+  const h = createHash("sha256").update(
+    JSON.stringify([seed, call.scope.kind, call.scope.id, call.actor.id, call.requestKey, name])
+  ).digest("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-a${h.slice(17, 20)}-${h.slice(20, 32)}`;
+}
+function payload(pub, generation = null) {
+  return {
+    kind: pub.kind,
+    primaryFileId: pub.files[0].fileId,
+    attachments: pub.files.slice(1).map((f) => ({ fileId: f.fileId, role: f.role })),
+    ...pub.details,
+    generation
+  };
+}
+
+// packages/project-studio/src/ads.ts
+function storyboardId(projectId) {
+  const hash2 = createHash2("sha256").update("studio.adStoryboard:" + projectId).digest("hex");
+  return `${hash2.slice(0, 8)}-${hash2.slice(8, 12)}-4${hash2.slice(13, 16)}-a${hash2.slice(17, 20)}-${hash2.slice(20, 32)}`;
+}
+var adDefinition = {
+  typeId: adTypeId,
+  schemaVersion: 1,
+  scopeKinds: ["project"],
+  validate: (input) => adStoryboard.parse(input)
+};
+function activeAd(data) {
+  try {
+    const record = data.get(storyboardId(data.scope.id));
+    if (record.typeId !== adTypeId) reject("TYPE_MISMATCH", "Expected an advertising storyboard.");
+    return record;
+  } catch (error) {
+    if (error.code === "OBJECT_NOT_FOUND") return null;
+    throw error;
+  }
+}
+function selectFirstAdCandidate(data, tx, assetId, versionId) {
+  const ad = activeAd(data);
+  if (!ad || !ad.data.clips.some((clip) => clip.assetId === assetId)) return;
+  const asset = tx.get(assetId);
+  if (asset.data.kind !== "video" || asset.data.adoptedVersionId || data.versions(assetId).length !== 1)
+    return;
+  tx.update(assetId, asset.revision, { ...asset.data, adoptedVersionId: versionId });
+}
+function hasReferenceContract(tx) {
+  return "removeRelations" in tx && typeof tx.removeRelations === "function";
+}
+var Ads = class {
+  constructor(data) {
+    this.data = data;
+  }
+  data;
+  assertWritable() {
+    const project = this.data.get(this.data.scope.id);
+    if (project.typeId !== "studio.project" || project.data.status === "archived")
+      reject("PROJECT_ARCHIVED", "Restore the project before changing its storyboard.");
+  }
+  get() {
+    return activeAd(this.data);
+  }
+  required() {
+    const ad = this.get();
+    if (!ad) reject("STORYBOARD_NOT_FOUND", "Initialize this advertising project first.");
+    return ad;
+  }
+  initialize(call) {
+    this.assertWritable();
+    return this.data.operation("ads.initialize", {}, call, (tx) => {
+      const existing = this.get();
+      if (existing) return existing;
+      const project = tx.get(this.data.scope.id);
+      return tx.create(
+        adTypeId,
+        {
+          brief: adBrief.parse({ aspectRatio: project.data.aspectRatio }),
+          clips: []
+        },
+        {},
+        storyboardId(this.data.scope.id)
+      );
+    });
+  }
+  change(name, input, call, update) {
+    this.assertWritable();
+    return this.data.operation(name, input, call, (tx) => {
+      const ad = this.required();
+      if (ad.revision !== input.expectedRevision)
+        reject(
+          "REVISION_CONFLICT",
+          "The storyboard changed. Keep your draft and reload.",
+          ad.revision
+        );
+      const next = update(structuredClone(ad.data), tx);
+      this.syncReferences(tx, ad.objectId, ad.data, next);
+      return tx.update(ad.objectId, ad.revision, next);
+    });
+  }
+  syncReferences(tx, id2, before, after) {
+    const refs = (ad) => [
+      ...ad.brief.productRefs,
+      ...ad.brief.modelRefs,
+      ...ad.clips.flatMap((clip) => clip.edits.map((edit) => edit.editRef))
+    ];
+    const next = refs(after);
+    if (!refs(before).length && !next.length) return;
+    if (!hasReferenceContract(tx))
+      reject(
+        "REFERENCE_PROTECTION_UNAVAILABLE",
+        "Update the storage reference contract before saving fixed references. Your draft and saved edit are retained."
+      );
+    tx.removeRelations(id2, "reference");
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of next) {
+      const key = JSON.stringify(ref);
+      if (seen.has(key)) continue;
+      this.data.get(ref.objectId);
+      this.data.version(ref);
+      tx.relation(id2, null, ref, "reference");
+      seen.add(key);
+    }
+  }
+  clip(ad, assetId) {
+    const clip = ad.clips.find((c) => c.assetId === assetId);
+    if (!clip) reject("CLIP_NOT_FOUND", "This clip is not part of the current storyboard.");
+    const asset = this.data.get(assetId);
+    if (asset.typeId !== "studio.asset" || asset.data.kind !== "video")
+      reject("TYPE_MISMATCH", "A clip requires a project video asset.");
+    return clip;
+  }
+  addClip(input, call) {
+    const assetId = stableId(this.data.storeId, call, "ads.clip");
+    return this.change("ads.addClip", input, call, (ad, tx) => {
+      tx.create(
+        "studio.asset",
+        assetData.parse({
+          projectId: this.data.scope.id,
+          name: input.title,
+          kind: "video",
+          purpose: "shot",
+          origin: "generated"
+        }),
+        {},
+        assetId
+      );
+      ad.clips.push({ assetId, script: clipScript.parse({ title: input.title }), edits: [] });
+      return ad;
+    });
+  }
+  updateBrief(input, call) {
+    for (const ref of [...input.brief.productRefs, ...input.brief.modelRefs]) {
+      this.data.version(ref);
+      const record = this.data.get(ref.objectId);
+      if (record.typeId !== "studio.asset" || record.data.kind !== "image")
+        reject("TYPE_MISMATCH", "Product and model references must be project images.");
+    }
+    return this.change("ads.updateBrief", input, call, (ad) => ({ ...ad, brief: input.brief }));
+  }
+  updateClip(input, call) {
+    return this.change("ads.updateClip", input, call, (ad) => {
+      this.clip(ad, input.assetId).script = input.script;
+      return ad;
+    });
+  }
+  reorder(input, call) {
+    return this.change("ads.reorder", input, call, (ad) => {
+      if (input.clipIds.length !== ad.clips.length || new Set(input.clipIds).size !== ad.clips.length || input.clipIds.some((id2) => !ad.clips.some((c) => c.assetId === id2)))
+        reject("INVALID_CLIP_ORDER", "Include every current clip exactly once.");
+      ad.clips = input.clipIds.map((id2) => ad.clips.find((c) => c.assetId === id2));
+      return ad;
+    });
+  }
+  removeClip(input, call) {
+    return this.change("ads.removeClip", input, call, (ad) => {
+      this.clip(ad, input.assetId);
+      ad.clips = ad.clips.filter((c) => c.assetId !== input.assetId);
+      return ad;
+    });
+  }
+  assertMedia(media) {
+    if (media.capabilityVersion !== "media-tools/1" || media.storeId !== this.data.storeId || media.projectId !== this.data.scope.id)
+      reject("SCOPE_MISMATCH", "Configure media tools for this same project and store.");
+  }
+  async bindEdit(input, call, media) {
+    this.assertWritable();
+    const replay = this.data.receipt("ads.bindEdit", input, call);
+    if (replay) return replay.result;
+    if (!media)
+      reject(
+        "MEDIA_TOOLS_UNAVAILABLE",
+        "Install and configure the media tools before applying an edit."
+      );
+    this.assertMedia(media);
+    this.data.get(input.editRef.objectId);
+    this.data.version(input.editRef);
+    const resolved = await media.resolve({ kind: "edit", editRef: input.editRef });
+    const source = resolved.file.source;
+    if (source.storeId !== this.data.storeId || source.objectId !== input.assetId || source.versionId !== input.sourceVersionId || !this.data.files(source).some((f) => f.fileId === resolved.file.fileId))
+      reject(
+        "CANDIDATE_CHANGED",
+        "The saved edit does not belong to this clip candidate. Your saved edit is retained."
+      );
+    return this.change("ads.bindEdit", input, call, (ad, tx) => {
+      const clip = this.clip(ad, input.assetId), asset = tx.get(input.assetId);
+      if (asset.revision !== input.expectedAssetRevision || asset.data.adoptedVersionId !== input.sourceVersionId)
+        reject(
+          "CANDIDATE_CHANGED",
+          "The selected candidate changed. Your draft and saved edit are retained."
+        );
+      clip.edits = clip.edits.filter((e) => e.sourceVersionId !== input.sourceVersionId);
+      clip.edits.push({ sourceVersionId: input.sourceVersionId, editRef: input.editRef });
+      return ad;
+    });
+  }
+  async resolveSequence(media) {
+    const ad = this.required();
+    const snapshots = ad.data.clips.map((clip) => {
+      try {
+        const asset = this.data.get(clip.assetId), versions = this.data.versions(clip.assetId);
+        return { clip: structuredClone(clip), asset, versions };
+      } catch (error) {
+        return { clip, error };
+      }
+    });
+    const entries = await Promise.all(
+      snapshots.map(async (snapshot) => {
+        const { clip, asset, versions } = snapshot;
+        const base2 = {
+          assetId: clip.assetId,
+          title: clip.script.title,
+          assetRevision: asset?.revision || 0,
+          selectedVersionId: asset?.data.adoptedVersionId || null,
+          candidates: (versions || []).map((v) => ({
+            versionId: v.versionId,
+            versionNumber: v.versionNumber,
+            durationMs: v.payload.durationMs ?? null,
+            generation: v.payload.generation || null
+          }))
+        };
+        try {
+          if (snapshot.error) throw snapshot.error;
+          if (asset.typeId !== "studio.asset" || asset.data.kind !== "video")
+            reject("TYPE_MISMATCH", "Clip asset is not a video.");
+          const versionId = asset.data.adoptedVersionId;
+          if (!versionId)
+            return {
+              ...base2,
+              state: "empty",
+              message: "This clip has no selected video yet."
+            };
+          const source = { storeId: this.data.storeId, objectId: asset.objectId, versionId };
+          const version = this.data.version(source);
+          const fileId = version.payload.primaryFileId;
+          const file = { source, fileId };
+          const saved2 = clip.edits.find(
+            (e) => e.sourceVersionId === versionId
+          );
+          if (saved2) {
+            if (!media)
+              reject(
+                "MEDIA_TOOLS_UNAVAILABLE",
+                "The media tools are needed to preview this saved edit."
+              );
+            this.assertMedia(media);
+            this.data.get(saved2.editRef.objectId);
+            this.data.version(saved2.editRef);
+            const resolved = await media.resolve({ kind: "edit", editRef: saved2.editRef });
+            if (resolved.file.source.storeId !== file.source.storeId || resolved.file.source.objectId !== file.source.objectId || resolved.file.source.versionId !== file.source.versionId || resolved.file.fileId !== file.fileId)
+              reject("INVALID_EDIT_SOURCE", "The edit references another candidate.");
+            const durationMs2 = resolved.recipe.trim.outMs - resolved.recipe.trim.inMs;
+            if (!Number.isSafeInteger(durationMs2) || durationMs2 <= 0 || resolved.effectiveDurationMs !== durationMs2 || !resolved.previewUrl)
+              reject("INVALID_EDIT_RECIPE", "The saved edit has inconsistent playable duration.");
+            return {
+              ...base2,
+              ...resolved,
+              state: "ready",
+              input: { kind: "edit", editRef: saved2.editRef },
+              durationMs: durationMs2
+            };
+          }
+          const location = await this.data.location(source, fileId);
+          const durationMs = version.payload.durationMs;
+          if (!Number.isFinite(durationMs) || durationMs <= 0 || !location.previewUrl)
+            reject("MEDIA_UNAVAILABLE", "The selected video has no playable duration or URL.");
+          return {
+            ...base2,
+            state: "ready",
+            input: { kind: "source", file },
+            file,
+            previewUrl: location.previewUrl,
+            durationMs,
+            recipe: {
+              trim: { inMs: 0, outMs: durationMs },
+              crop: { x: 0, y: 0, width: 1, height: 1 }
+            }
+          };
+        } catch (error) {
+          return { ...base2, state: "unavailable", message: error.message };
+        }
+      })
+    );
+    return {
+      storyboardId: ad.objectId,
+      storyboardRevision: ad.revision,
+      aspectRatio: ad.data.brief.aspectRatio,
+      entries,
+      actualDurationMs: entries.reduce(
+        (sum, entry) => sum + (entry.state === "ready" ? entry.durationMs : 0),
+        0
+      ),
+      targetDurationMs: ad.data.brief.targetDurationMs
+    };
+  }
+};
+
+// packages/project-studio/src/server.ts
+import { z as z8, defineOperation as defineOperation2 } from "vivix-studio/sdk/shared";
+
+// packages/project-studio/src/global.ts
+import { performance } from "perf_hooks";
+
+// packages/project-studio/src/projects.ts
+var Projects = class {
+  constructor(data) {
+    this.data = data;
+  }
+  data;
+  get(projectId = this.data.scope.id) {
+    if (projectId !== this.data.scope.id)
+      reject("SCOPE_MISMATCH", "Project settings belong to the active project.");
+    const project = this.data.get(projectId);
+    if (project.typeId !== "studio.project") reject("TYPE_MISMATCH", "Expected project settings.");
+    return project;
+  }
+  update(input, call) {
+    const old = this.get(input.projectId);
+    if (old.data.status === "archived" && input.changes.status !== "active")
+      reject("PROJECT_ARCHIVED", "Restore the project before changing its settings.");
+    return this.data.operation("projects.update", input, call, (tx) => {
+      const { coverRef } = input.changes;
+      if (coverRef !== void 0) {
+        if (coverRef) {
+          const asset = tx.get(coverRef.objectId);
+          if (asset.typeId !== "studio.asset" || asset.data.kind !== "image")
+            reject("TYPE_MISMATCH", "Choose a saved image from this project for the cover.");
+        }
+        tx.removeRelations(old.objectId, "reference");
+        if (coverRef) tx.relation(old.objectId, null, coverRef, "reference");
+      }
+      return tx.update(old.objectId, input.expectedRevision, { ...old.data, ...input.changes });
+    });
+  }
+};
+
+// packages/project-studio/src/global.ts
+var refKey = (ref) => `${ref.storeId}/${ref.objectId}/${ref.versionId}`;
+var assetColumns = [
+  "rowId",
+  "projectId",
+  "assetId",
+  "ref",
+  "name",
+  "kind",
+  "purpose",
+  "metadata",
+  "generation",
+  "prompt",
+  "originalPrompt",
+  "refs",
+  "modelId",
+  "parameters",
+  "snapshotAvailable",
+  "taskId",
+  "outputIndex",
+  "previewUrl",
+  "mimeType",
+  "createdAt",
+  "updatedAt",
+  "adoptedVersionId",
+  "versionId",
+  "versionNumber",
+  "latestVersionId",
+  "favorite",
+  "favoriteRefs"
+];
+var projectColumns = [
+  "rowId",
+  "projectId",
+  "name",
+  "hostName",
+  "available",
+  "assetCount",
+  "metadata",
+  "createdAt",
+  "updatedAt",
+  "status",
+  "description",
+  "tags",
+  "aspectRatio",
+  "coverRef",
+  "previewRef"
+];
+var taskColumns = [
+  "revision",
+  "attemptId",
+  "remoteOutcome",
+  "localPersistence",
+  "rowId",
+  "projectId",
+  "taskId",
+  "name",
+  "state",
+  "outputRefs",
+  "createdAt",
+  "updatedAt",
+  "targetAssetId",
+  "kind",
+  "prompt",
+  "originalPrompt",
+  "refs",
+  "modelId",
+  "parameters",
+  "progress",
+  "error",
+  "expectedOutputs",
+  "receivedOutputs",
+  "cost",
+  "costStatus",
+  "chargedCredits",
+  "costLabel",
+  "finishedAt"
+];
+var jsonColumns = /* @__PURE__ */ new Set([
+  "remoteOutcome",
+  "ref",
+  "metadata",
+  "generation",
+  "refs",
+  "parameters",
+  "favoriteRefs",
+  "outputRefs",
+  "error",
+  "cost",
+  "tags",
+  "coverRef",
+  "previewRef"
+]);
+function sqlRow(row) {
+  return Object.fromEntries(
+    Object.entries(row).map(([key, value]) => [
+      key,
+      typeof value === "boolean" ? Number(value) : value !== null && typeof value === "object" ? JSON.stringify(value) : value
+    ])
+  );
+}
+function resultRow(row) {
+  return Object.fromEntries(
+    Object.entries(row).map(([key, value]) => {
+      if (jsonColumns.has(key) && typeof value === "string") {
+        try {
+          return [key, JSON.parse(value)];
+        } catch {
+        }
+      }
+      return [key, value];
+    })
+  );
+}
+function querySources(sql) {
+  const tokens = (sql.match(
+    /--[^\r\n]*|\/\*[\s\S]*?\*\/|'(?:''|[^'])*'|"(?:""|[^"])*"|`(?:``|[^`])*`|\[[^\]]*\]|[A-Za-z_][A-Za-z0-9_$]*|[(),.*]/g
+  ) || []).filter((token) => !token.startsWith("--") && !token.startsWith("/*"));
+  const name = (token = "") => {
+    const quote = token[0];
+    return (['"', "'", "`"].includes(quote) ? token.slice(1, -1).replaceAll(quote + quote, quote) : quote === "[" ? token.slice(1, -1) : token).toLowerCase();
+  };
+  const known = /* @__PURE__ */ new Set([
+    "studio_projects",
+    "studio_assets",
+    "studio_asset_versions",
+    "studio_tasks"
+  ]);
+  const sources = /* @__PURE__ */ new Set();
+  const aliases = /* @__PURE__ */ new Map();
+  let uncertain = false;
+  const relation = (position) => {
+    if (tokens[position] === "(") uncertain = true;
+    while (tokens[position] === "(") position++;
+    if (tokens[position + 1] === ".") position += 2;
+    const table = name(tokens[position]);
+    if (known.has(table)) sources.add(table);
+    else uncertain = true;
+    const bind = (qualifier) => {
+      const previous = aliases.get(qualifier);
+      aliases.set(qualifier, previous === void 0 || previous === table ? table : null);
+    };
+    bind(table);
+    const alias = tokens[position + (tokens[position + 1]?.toLowerCase() === "as" ? 2 : 1)];
+    if (alias && (/^[A-Za-z_]/.test(alias) || ['"', "'", "`", "["].includes(alias[0])))
+      bind(name(alias));
+  };
+  const from = /* @__PURE__ */ new Set();
+  const endsFrom = /* @__PURE__ */ new Set(["select", "where", "having", "limit", "union", "except", "intersect"]);
+  let depth = 0;
+  for (const [index, token] of tokens.entries()) {
+    const keyword = token.toLowerCase();
+    const previous = tokens[index - 1]?.toLowerCase();
+    const next = tokens[index + 1]?.toLowerCase();
+    if (token === "(") {
+      if (from.has(depth) && ["from", "join", ",", "("].includes(previous)) from.add(depth + 1);
+      depth++;
+    } else if (token === ")") {
+      from.delete(depth--);
+    } else if (keyword === "from" || keyword === "join") {
+      if (keyword === "from" && previous === "distinct") continue;
+      from.add(depth);
+      relation(index + 1);
+    } else if (token === "," && from.has(depth)) {
+      relation(index + 1);
+    } else if (previous !== "as" && (endsFrom.has(keyword) || ["group", "order"].includes(keyword) && next === "by" || keyword === "window" && tokens[index + 2]?.toLowerCase() === "as" && tokens[index + 3] === "(")) {
+      from.delete(depth);
+    }
+  }
+  if (uncertain)
+    for (const [index, token] of tokens.entries()) {
+      const table = name(token);
+      if (!token.startsWith("'") && tokens[index - 1]?.toLowerCase() !== "as" && known.has(table))
+        sources.add(table);
+    }
+  const projectProjection = (column) => tokens.some((token, index) => {
+    if ((!token.startsWith("'") || tokens[index - 1] === ".") && name(token) === column)
+      return true;
+    if (token !== "*" || tokens[index - 1] === "(") return false;
+    if (tokens[index - 1] !== ".") return true;
+    const table = aliases.get(name(tokens[index - 2]));
+    return uncertain || !table || !known.has(table) || table === "studio_projects";
+  });
+  return {
+    sources,
+    projectCounts: projectProjection("assetcount"),
+    projectPreviews: projectProjection("previewref")
+  };
+}
+function listAll(data, typeId, check) {
+  const records = [];
+  for (let offset = 0; ; ) {
+    check?.();
+    const page = data.list({ typeId, sort: "createdAt", direction: "asc", limit: 200, offset });
+    check?.();
+    records.push(...page.items);
+    if (page.nextOffset === null) return records;
+    offset = page.nextOffset;
+  }
+}
+function projectsAll(workspace, check) {
+  const records = [];
+  for (let offset = 0; ; ) {
+    check?.();
+    const page = workspace.projectRecords({
+      sort: "createdAt",
+      direction: "asc",
+      limit: 200,
+      offset
+    });
+    check?.();
+    records.push(...page);
+    if (page.length < 200) return records;
+    offset += page.length;
+  }
+}
+var GlobalStudio = class {
+  constructor(data) {
+    this.data = data;
+  }
+  data;
+  projectNames() {
+    return projectsAll(this.data).flatMap(
+      ({ objectId, data }) => typeof data.name === "string" && data.name ? [{ id: objectId, name: data.name }] : []
+    );
+  }
+  projectSummaries() {
+    return projectsAll(this.data).flatMap(
+      ({ objectId, data, revision: revision2 }) => typeof data.name === "string" && data.name ? [
+        {
+          id: objectId,
+          name: data.name,
+          coverRef: data.coverRef ?? null,
+          tags: data.tags ?? [],
+          revision: revision2
+        }
+      ] : []
+    );
+  }
+  renameProject(input, call) {
+    const data = this.data.project(input.projectId);
+    return new Projects(data).update(
+      {
+        projectId: input.projectId,
+        expectedRevision: input.expectedRevision,
+        changes: { name: input.name }
+      },
+      { ...call, scope: data.scope }
+    );
+  }
+  setProjectCover({
+    projectId,
+    expectedRevision,
+    coverRef
+  }, call) {
+    const data = this.data.project(projectId);
+    return new Projects(data).update(
+      { projectId, expectedRevision, changes: { coverRef } },
+      { ...call, scope: data.scope }
+    );
+  }
+  source(ref) {
+    const data = this.data.source(ref);
+    const object = data.get(ref.objectId, true);
+    if (object.typeId !== "studio.asset" || object.scope.kind !== "project")
+      reject("TYPE_MISMATCH", "Expected a saved project asset version.");
+    const version = data.version(ref);
+    return { data, object, version };
+  }
+  async describe(data, object, version, latestVersionId, favorites, check) {
+    const ref = { storeId: data.storeId, objectId: object.objectId, versionId: version.versionId };
+    check?.();
+    const files = data.files(ref);
+    if (!files.length) return null;
+    let location = null;
+    try {
+      for (const file of files) {
+        check?.();
+        const checked = await data.location(ref, file.fileId);
+        check?.();
+        if (file.role === "primary" && file.ordinal === 0) location = checked;
+      }
+    } catch (error) {
+      if (["FILE_MISSING", "FILE_CORRUPT", "ENOENT"].includes(error.code)) return null;
+      throw error;
+    }
+    if (!location) return null;
+    const generation = version.payload.generation || null;
+    return {
+      rowId: refKey(ref),
+      projectId: object.scope.id,
+      assetId: object.objectId,
+      ref: { ...ref },
+      name: object.data.name,
+      kind: object.data.kind,
+      purpose: object.data.purpose,
+      metadata: structuredClone(object.metadata),
+      generation: structuredClone(generation),
+      prompt: generation?.prompt ?? null,
+      originalPrompt: generation?.originalPrompt ?? null,
+      refs: generation?.refs ?? null,
+      modelId: generation?.modelId ?? null,
+      parameters: generation?.parameters ?? null,
+      snapshotAvailable: generation !== null && ["prompt", "originalPrompt", "refs", "modelId", "parameters"].every(
+        (key) => Object.hasOwn(generation, key)
+      ),
+      taskId: generation?.taskId ?? version.taskId,
+      outputIndex: generation?.outputIndex ?? null,
+      previewUrl: location.previewUrl,
+      mimeType: location.mimeType,
+      createdAt: version.createdAt,
+      updatedAt: object.updatedAt,
+      adoptedVersionId: object.data.adoptedVersionId,
+      versionId: version.versionId,
+      versionNumber: version.versionNumber,
+      latestVersionId,
+      favorite: favorites.some((favorite) => refKey(favorite) === refKey(ref)),
+      favoriteRefs: structuredClone(favorites)
+    };
+  }
+  favoriteRefs(data, objectId) {
+    return listAll(data, "studio.favorite").map((record) => record.data.ref).filter((ref) => ref.objectId === objectId);
+  }
+  async asset(value) {
+    const ref = versionRef.parse(value);
+    const { data, object, version } = this.source(ref);
+    const versions = data.versions(object.objectId);
+    const item = await this.describe(
+      data,
+      object,
+      version,
+      versions.at(-1)?.versionId || null,
+      this.favoriteRefs(data, object.objectId)
+    );
+    if (!item) reject("CONTENT_UNAVAILABLE", "The selected saved version is unavailable.");
+    return { item, versions, files: data.files(ref) };
+  }
+  async favorite(value, call) {
+    const input = { ref: versionRef.parse(value.ref), enabled: value.enabled };
+    const receiptCall = { ...call, scope: this.data.scope };
+    const replay = this.data.receipt("global.favorite", input, receiptCall);
+    if (replay) return replay.result;
+    const { data, object } = this.source(input.ref);
+    const boundCall = { ...call, scope: data.scope };
+    const previousReceipt = data.receipt("global.favorite", input, boundCall);
+    if (previousReceipt)
+      return this.data.operation(
+        "global.favorite",
+        input,
+        receiptCall,
+        () => previousReceipt.result
+      );
+    if (input.enabled && (object.deletedAt || await data.availability(input.ref) !== "ready"))
+      reject("CONTENT_UNAVAILABLE", "Favorite an available saved asset version.");
+    const id2 = stableId(
+      data.storeId,
+      {
+        scope: data.scope,
+        actor: call.actor,
+        requestKey: refKey(input.ref)
+      },
+      "studio.favorite"
+    );
+    return this.data.operation(
+      "global.favorite",
+      input,
+      receiptCall,
+      () => data.operation("global.favorite", input, boundCall, (tx) => {
+        let previous = null;
+        try {
+          previous = tx.get(id2, true);
+        } catch (error) {
+          if (error.code !== "OBJECT_NOT_FOUND") throw error;
+        }
+        let favorite = previous;
+        if (input.enabled) {
+          if (!previous) {
+            favorite = tx.create("studio.favorite", favoriteData.parse({ ref: input.ref }), {}, id2);
+            tx.relation(id2, null, input.ref, "reference");
+          } else if (previous.deletedAt) {
+            favorite = tx.update(id2, previous.revision, previous.data, void 0, null);
+          }
+        } else if (previous && !previous.deletedAt) {
+          favorite = tx.update(
+            id2,
+            previous.revision,
+            previous.data,
+            void 0,
+            (/* @__PURE__ */ new Date()).toISOString()
+          );
+        }
+        return { favorite, ref: input.ref, enabled: input.enabled };
+      })
+    );
+  }
+  async importAsset(input, call) {
+    const receiptCall = { ...call, scope: this.data.scope };
+    const replay = this.data.receipt("global.import", input, receiptCall);
+    if (replay) return replay.result;
+    const data = this.data.project(input.projectId);
+    const result2 = await new Assets(data, this.data).import(
+      { name: input.name, stagingFileIds: input.stagingFileIds },
+      { ...call, scope: data.scope }
+    );
+    return this.data.operation("global.import", input, receiptCall, () => result2);
+  }
+  async exportEntries(values) {
+    const refs = new Map(
+      values.map((value) => {
+        const ref = versionRef.parse(value);
+        return [refKey(ref), ref];
+      })
+    );
+    const entries = [];
+    for (const ref of refs.values()) {
+      const { data } = this.source(ref);
+      const files = data.files(ref);
+      if (!files.length) reject("CONTENT_UNAVAILABLE", "The selected version has no saved files.");
+      for (const file of files) {
+        const fixedRef2 = Object.freeze({ ...ref });
+        entries.push({
+          ref: fixedRef2,
+          fileId: file.fileId,
+          name: file.originalName,
+          sizeBytes: file.sizeBytes,
+          open: (signal) => data.openFile(fixedRef2, file.fileId, signal)
+        });
+      }
+    }
+    return entries;
+  }
+  async tables(catalog, selection, check) {
+    const { sources } = selection;
+    const needProjects = sources.has("studio_projects");
+    const needAssets = sources.has("studio_assets");
+    const needVersions = sources.has("studio_asset_versions");
+    const needTasks = sources.has("studio_tasks");
+    const needCounts = needProjects && selection.projectCounts;
+    const needPreviews = needProjects && selection.projectPreviews;
+    const projects = sources.size ? projectsAll(this.data, check) : [];
+    const host = new Map(catalog.map((entry) => [entry.id, entry]));
+    const assets = [], versions = [], tasks = [];
+    const projectRows = /* @__PURE__ */ new Map();
+    for (const project of projects) {
+      check();
+      const data = this.data.project(project.objectId);
+      const favorites = needAssets || needVersions ? listAll(data, "studio.favorite", check).map((record) => record.data.ref) : [];
+      const projectAssets = needAssets || needVersions || needCounts || needPreviews || needTasks ? listAll(data, "studio.asset", check) : [];
+      let assetCount = 0;
+      let firstMediaRef = null;
+      const described = /* @__PURE__ */ new Map();
+      if (needAssets || needVersions || needCounts || needPreviews)
+        for (const object of projectAssets) {
+          check();
+          const saved2 = data.versions(object.objectId);
+          const latest = saved2.at(-1);
+          const pinned = favorites.filter((ref) => ref.objectId === object.objectId);
+          for (const version of needVersions ? saved2 : latest ? [latest] : []) {
+            check();
+            const row = await this.describe(
+              data,
+              object,
+              version,
+              latest?.versionId || null,
+              pinned,
+              check
+            );
+            described.set(version.versionId, row);
+            check();
+            if (row) {
+              if (!firstMediaRef && (row.kind === "image" || row.kind === "video"))
+                firstMediaRef = row.ref;
+              if (needVersions) versions.push(row);
+              if (version.versionId === latest?.versionId) {
+                assetCount++;
+                if (needAssets) assets.push(row);
+              }
+            }
+          }
+        }
+      if (needTasks)
+        for (const task of listAll(data, "studio.task", check)) {
+          check();
+          const input = task.data.inputSnapshot;
+          tasks.push({
+            rowId: task.objectId,
+            projectId: project.objectId,
+            taskId: task.objectId,
+            revision: task.revision,
+            attemptId: task.objectId,
+            remoteOutcome: taskProjection(task).projection.remoteOutcome,
+            localPersistence: taskProjection(task).projection.localPersistence,
+            name: task.data.name || projectAssets.find((asset) => asset.objectId === task.data.targetAssetId)?.data.name || "Generation",
+            state: task.data.state,
+            outputRefs: task.data.outputRefs,
+            createdAt: task.createdAt,
+            updatedAt: task.updatedAt,
+            targetAssetId: task.data.targetAssetId,
+            kind: task.data.kind,
+            prompt: input?.prompt ?? null,
+            originalPrompt: input?.originalPrompt ?? null,
+            refs: input?.inputs ?? null,
+            modelId: input?.modelId ?? null,
+            parameters: input?.parameters ?? null,
+            progress: task.data.progress,
+            error: task.data.error,
+            expectedOutputs: task.data.expectedOutputs,
+            receivedOutputs: task.data.receivedOutputs,
+            cost: task.data.cost ?? null,
+            costStatus: task.data.cost?.status ?? "unknown",
+            chargedCredits: task.data.cost?.credits ?? null,
+            costLabel: taskCostLabel(task.data),
+            finishedAt: task.data.finishedAt
+          });
+        }
+      if (needProjects) {
+        let previewRef = needPreviews ? project.data.coverRef : null;
+        if (needPreviews && !previewRef) {
+          const clips = new Ads(data).get()?.data.clips ?? [];
+          for (const clip of clips) {
+            check();
+            const asset = projectAssets.find((item) => item.objectId === clip.assetId);
+            const selected = asset?.data.adoptedVersionId;
+            if (!asset || asset.data.kind !== "video" || !selected) continue;
+            const saved2 = data.versions(asset.objectId);
+            const version = saved2.find((item) => item.versionId === selected);
+            if (!version) continue;
+            const row = described.has(version.versionId) ? described.get(version.versionId) : await this.describe(
+              data,
+              asset,
+              version,
+              saved2.at(-1)?.versionId ?? null,
+              [],
+              check
+            );
+            if (row) {
+              previewRef = row.ref;
+              break;
+            }
+          }
+          previewRef ??= firstMediaRef;
+        }
+        const registered = host.get(project.objectId);
+        projectRows.set(project.objectId, {
+          rowId: project.objectId,
+          projectId: project.objectId,
+          name: project.data.name,
+          hostName: registered?.name ?? null,
+          available: registered?.available ?? false,
+          assetCount,
+          metadata: project.metadata,
+          createdAt: project.createdAt,
+          updatedAt: project.updatedAt,
+          status: project.data.status,
+          description: project.data.description,
+          tags: project.data.tags,
+          aspectRatio: project.data.aspectRatio,
+          coverRef: project.data.coverRef,
+          previewRef: previewRef ? { ...previewRef } : null
+        });
+      }
+    }
+    if (needProjects)
+      for (const entry of host.values()) {
+        check();
+        if (projectRows.has(entry.id)) continue;
+        projectRows.set(entry.id, {
+          rowId: entry.id,
+          projectId: entry.id,
+          name: entry.name,
+          hostName: entry.name,
+          available: entry.available,
+          assetCount: 0,
+          metadata: {},
+          createdAt: null,
+          updatedAt: null,
+          status: null,
+          description: "",
+          tags: [],
+          aspectRatio: null,
+          coverRef: null,
+          previewRef: null
+        });
+      }
+    check();
+    return {
+      studio_projects: { columns: projectColumns, rows: [...projectRows.values()].map(sqlRow) },
+      studio_assets: { columns: assetColumns, rows: assets.map(sqlRow) },
+      studio_asset_versions: { columns: assetColumns, rows: versions.map(sqlRow) },
+      studio_tasks: { columns: taskColumns, rows: tasks.map(sqlRow) }
+    };
+  }
+  async query(value) {
+    const started = performance.now();
+    const input = globalQueryInput.parse(value);
+    const maxRows = input.maxRows ?? 1e3;
+    const timeoutMs = input.timeoutMs ?? 2e3;
+    const limit = input.limit ?? Math.min(50, maxRows);
+    const offset = input.offset ?? 0;
+    if (maxRows > 1e4 || timeoutMs > 1e4 || limit > maxRows)
+      reject("INVALID_SQL_INPUT", "Invalid SQL execution budget or pagination.");
+    const deadline = started + timeoutMs;
+    const check = () => {
+      if (performance.now() >= deadline)
+        reject("SQL_TIMEOUT", "The global query exceeded its deadline.");
+    };
+    check();
+    const selection = querySources(input.sql);
+    check();
+    const tables = await this.tables(input.catalog || [], selection, check);
+    check();
+    const remaining = Math.floor(deadline - performance.now());
+    if (remaining < 1) reject("SQL_TIMEOUT", "The global query exceeded its deadline.");
+    const items = await this.data.queryProjection(
+      {
+        sql: input.sql,
+        params: input.params,
+        timeoutMs: remaining,
+        maxRows: Math.max(maxRows, limit + 1),
+        limit: limit + 1,
+        offset
+      },
+      tables
+    );
+    check();
+    const result2 = {
+      items: items.slice(0, limit).map(resultRow),
+      nextOffset: items.length > limit ? offset + limit : null
+    };
+    check();
+    return result2;
+  }
+};
+
+// packages/project-studio/src/media-uses.ts
+import { createHash as createHash3 } from "crypto";
+import { z as z6, PluginError as PluginError3 } from "vivix-studio/sdk/shared";
+
+// packages/media-tools/src/shared.ts
+import { z as z5, PluginError as PluginError2 } from "vivix-studio/sdk/shared";
+var Config = z5.object({
+  dataInstance: z5.string().min(1).default("user:data"),
+  studioInstance: z5.string().min(1).default("studio"),
+  executionNamespace: z5.string().regex(/^[a-zA-Z0-9_-]{1,64}$/).default("media"),
+  ffmpegPath: z5.string().min(1).default("ffmpeg"),
+  ffprobePath: z5.string().min(1).default("ffprobe")
+}).strict();
+var versionRef2 = z5.object({ storeId: z5.uuid(), objectId: z5.uuid(), versionId: z5.uuid() }).strict();
+var videoFileRef = z5.object({ source: versionRef2, fileId: z5.uuid() }).strict();
+var sourceInput = z5.object({ kind: z5.literal("source"), file: videoFileRef }).strict();
+var editInput = z5.object({ kind: z5.literal("edit"), editRef: versionRef2 }).strict();
+var videoInput = z5.discriminatedUnion("kind", [sourceInput, editInput]);
+var sequenceVideoInput = z5.discriminatedUnion("kind", [
+  sourceInput.extend({ trimEndMs: z5.number().int().positive().optional() }),
+  editInput
+]);
+var recipe = z5.object({
+  trim: z5.object({ inMs: z5.number().int().nonnegative(), outMs: z5.number().int().positive() }).strict(),
+  crop: z5.object({
+    x: z5.number().finite().nonnegative(),
+    y: z5.number().finite().nonnegative(),
+    width: z5.number().finite().positive().max(1),
+    height: z5.number().finite().positive().max(1)
+  }).strict()
+}).strict().superRefine((v, c) => {
+  if (v.trim.inMs >= v.trim.outMs)
+    c.addIssue({ code: "custom", message: "The selected interval must have positive duration." });
+  if (v.crop.x + v.crop.width > 1 + 1e-9 || v.crop.y + v.crop.height > 1 + 1e-9)
+    c.addIssue({ code: "custom", message: "The crop must remain inside the source picture." });
+});
+var pixelRect = z5.object({
+  x: z5.number().int().nonnegative(),
+  y: z5.number().int().nonnegative(),
+  width: z5.number().int().positive(),
+  height: z5.number().int().positive()
+}).strict();
+var geometry = z5.object({
+  displayWidth: z5.number().int().positive(),
+  displayHeight: z5.number().int().positive(),
+  pixelRect
+}).strict();
+var metadata = z5.object({
+  durationMs: z5.number().int().positive(),
+  width: z5.number().int().positive(),
+  height: z5.number().int().positive(),
+  displayWidth: z5.number().int().positive(),
+  displayHeight: z5.number().int().positive(),
+  rotation: z5.union([z5.literal(0), z5.literal(90), z5.literal(180), z5.literal(270)]),
+  frameRate: z5.number().positive().max(60),
+  startTime: z5.number().finite(),
+  hasAudio: z5.boolean(),
+  audioSampleRate: z5.number().int().nullable(),
+  audioChannels: z5.number().int().nullable(),
+  audioStartTime: z5.number().finite().nullable(),
+  sizeBytes: z5.number().int().nonnegative(),
+  sha256: z5.string().regex(/^[a-f0-9]{64}$/),
+  colorInterpretation: z5.enum(["declared-bt709", "assumed-bt709"]).optional()
+}).strict();
+var editDescriptor = z5.object({ format: z5.literal(1), file: videoFileRef, recipe, geometry, metadata }).strict();
+var saveEdit = z5.object({
+  file: videoFileRef,
+  recipe,
+  editId: z5.uuid().optional(),
+  expectedRevision: z5.number().int().positive().optional()
+}).strict().superRefine((v, c) => {
+  if (Boolean(v.editId) !== Boolean(v.expectedRevision))
+    c.addIssue({ code: "custom", message: "An edit update requires its revision." });
+});
+var outputName = z5.string().trim().min(1).max(200);
+var processVideo = z5.object({ input: videoInput, outputName, retryOfJobId: z5.uuid().optional() }).strict();
+var canvas = z5.object({ width: z5.number().int().min(2).max(3840), height: z5.number().int().min(2).max(3840) }).strict().refine(
+  (v) => v.width % 2 === 0 && v.height % 2 === 0 && Math.min(v.width, v.height) <= 2160,
+  "Canvas dimensions must be even and within 3840 by 2160."
+);
+var processSequence = z5.object({
+  inputs: z5.array(sequenceVideoInput).min(1).max(64),
+  outputName,
+  canvas,
+  retryOfJobId: z5.uuid().optional()
+}).strict();
+var mediaRequest = z5.discriminatedUnion("operation", [
+  z5.object({ operation: z5.literal("video.process"), input: processVideo }).strict(),
+  z5.object({ operation: z5.literal("sequence.process"), input: processSequence }).strict()
+]);
+var jobsQuery = z5.object({
+  limit: z5.number().int().min(1).max(100).default(50),
+  offset: z5.number().int().nonnegative().default(0),
+  request: z5.object({
+    operation: z5.enum(["video.process", "sequence.process"]),
+    requestKey: z5.string().min(1).max(128),
+    intent: z5.union([processVideo, processSequence])
+  }).strict().optional()
+}).strict();
+function mediaError(code, message) {
+  throw new PluginError2(
+    code,
+    message,
+    "Review the fixed source, edit and current project, then retry explicitly."
+  );
+}
+function normalizeRecipe(raw, displayWidth, displayHeight, durationMs) {
+  const value = recipe.parse(raw);
+  if (![displayWidth, displayHeight, durationMs].every(Number.isSafeInteger) || displayWidth < 2 || displayHeight < 2 || durationMs < 1 || displayWidth % 2 !== 0 || displayHeight % 2 !== 0)
+    mediaError("UNSUPPORTED_GEOMETRY", "The source needs positive even display dimensions.");
+  if (value.trim.outMs > durationMs)
+    mediaError("INVALID_RECIPE", "The trim exceeds the fixed source duration.");
+  const edge = (fraction, size) => Math.round(fraction * size / 2) * 2;
+  const x = edge(value.crop.x, displayWidth);
+  const y = edge(value.crop.y, displayHeight);
+  const right = Math.min(displayWidth, edge(value.crop.x + value.crop.width, displayWidth));
+  const bottom = Math.min(displayHeight, edge(value.crop.y + value.crop.height, displayHeight));
+  if (right - x < 2 || bottom - y < 2)
+    mediaError("INVALID_RECIPE", "The crop must contain at least two pixels in each dimension.");
+  const pixelRect2 = { x, y, width: right - x, height: bottom - y };
+  return {
+    recipe: {
+      trim: { ...value.trim },
+      crop: {
+        x: x / displayWidth,
+        y: y / displayHeight,
+        width: pixelRect2.width / displayWidth,
+        height: pixelRect2.height / displayHeight
+      }
+    },
+    geometry: { displayWidth, displayHeight, pixelRect: pixelRect2 }
+  };
+}
+function sameFile(a, b) {
+  return a.fileId === b.fileId && a.source.storeId === b.source.storeId && a.source.objectId === b.source.objectId && a.source.versionId === b.source.versionId;
+}
+function readSavedEdit(data, raw) {
+  const ref = versionRef2.parse(raw);
+  if (data.scope.kind !== "project" || ref.storeId !== data.storeId)
+    mediaError("SCOPE_MISMATCH", "The edit is not in this project store.");
+  const object = data.get(ref.objectId, true);
+  if (object.typeId !== "media.edit" || object.schemaVersion !== 1 || object.scope.kind !== data.scope.kind || object.scope.id !== data.scope.id)
+    mediaError("EDIT_FORMAT_UNSUPPORTED", "A supported fixed media edit is required.");
+  const version = data.version(ref);
+  if (version.schemaVersion !== 1 || version.payload?.kind !== "media.edit")
+    mediaError("EDIT_FORMAT_UNSUPPORTED", "This edit descriptor format is unsupported.");
+  const parsed = editDescriptor.safeParse(version.payload.descriptor);
+  if (!parsed.success)
+    mediaError("EDIT_FORMAT_UNSUPPORTED", "The fixed edit descriptor is invalid.");
+  const value = parsed.data;
+  if (!sameFile(object.data.file, value.file))
+    mediaError("IMMUTABLE_FIELD", "The fixed edit version changed its original source.");
+  const canonical2 = normalizeRecipe(
+    value.recipe,
+    value.metadata.displayWidth,
+    value.metadata.displayHeight,
+    value.metadata.durationMs
+  );
+  if (JSON.stringify(canonical2.recipe) !== JSON.stringify(value.recipe) || JSON.stringify(canonical2.geometry) !== JSON.stringify(value.geometry))
+    mediaError("EDIT_FORMAT_UNSUPPORTED", "The stored edit geometry is not canonical.");
+  if (value.file.source.storeId !== data.storeId)
+    mediaError("SCOPE_MISMATCH", "The edit source belongs to another store.");
+  const original = data.get(value.file.source.objectId, true);
+  if (original.typeId !== "studio.asset" || original.data.kind !== "video")
+    mediaError("SOURCE_NOT_VIDEO", "The edit source is not a project video.");
+  const sourceVersion = data.version(value.file.source), files = data.files(value.file.source);
+  if (sourceVersion.payload.kind !== "video" || !files.some(
+    (f) => f.fileId === value.file.fileId && f.mimeType === "video/mp4" && f.sha256 === value.metadata.sha256
+  ))
+    mediaError(
+      "INVALID_REFERENCE",
+      "The saved video file is not part of its fixed source version."
+    );
+  const ownFiles = data.files(ref);
+  if (!ownFiles.some(
+    (f) => f.fileId === version.payload.primaryFileId && f.role === "primary" && f.mimeType.startsWith("text/plain")
+  ))
+    mediaError("EDIT_FORMAT_UNSUPPORTED", "The edit is missing its authored descriptor file.");
+  if (value.recipe.trim.outMs > value.metadata.durationMs)
+    mediaError("INVALID_RECIPE", "The saved trim exceeds the fixed source.");
+  return {
+    editRef: ref,
+    revision: object.revision,
+    file: value.file,
+    recipe: value.recipe,
+    geometry: value.geometry,
+    effectiveDurationMs: value.recipe.trim.outMs - value.recipe.trim.inMs
+  };
+}
+
+// packages/project-studio/src/media-uses.ts
+var getMediaUse = z6.object({ usageId: z6.string().min(1).max(200), file: videoFileRef }).strict();
+var bindMediaUse = getMediaUse.extend({
+  editRef: versionRef2,
+  expectedRevision: z6.number().int().nonnegative()
+}).strict();
+var useData = getMediaUse.extend({ editRef: versionRef2 }).strict();
+var definition = {
+  typeId: "studio.video-use",
+  schemaVersion: 1,
+  scopeKinds: ["project"],
+  validate: (value) => useData.parse(value),
+  validateUpdate: (old, next) => {
+    if (old.usageId !== next.usageId || !sameFile(old.file, next.file))
+      reject2("CANDIDATE_CHANGED", "This usage is fixed to another source video.");
+  }
+};
+function reject2(code, message) {
+  throw new PluginError3(code, message, "Reload the current usage and preserve the editing draft.");
+}
+function idFor(data, usageId) {
+  const hex = createHash3("sha256").update(JSON.stringify(["studio.video-use/1", data.storeId, data.scope, usageId])).digest("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+var MediaUses = class {
+  constructor(data, register, assertWritable) {
+    this.data = data;
+    this.assertWritable = assertWritable;
+    register(definition);
+  }
+  data;
+  assertWritable;
+  source(file, includeDeleted = false) {
+    if (this.data.scope.kind !== "project" || file.source.storeId !== this.data.storeId)
+      reject2("SCOPE_MISMATCH", "This video does not belong to the current project.");
+    const record = this.data.get(file.source.objectId, includeDeleted);
+    if (record.typeId !== "studio.asset" || record.data.kind !== "video" || !this.data.files(file.source).some((value) => value.fileId === file.fileId))
+      reject2("INVALID_REFERENCE", "Choose a readable fixed project video.");
+  }
+  current(usageId, file) {
+    try {
+      const record = this.data.get(idFor(this.data, usageId));
+      if (record.typeId !== "studio.video-use")
+        reject2("TYPE_MISMATCH", "This usage identity is unavailable.");
+      const value = useData.parse(record.data);
+      if (!sameFile(value.file, file))
+        reject2("CANDIDATE_CHANGED", "The selected candidate changed.");
+      return { ...value, revision: record.revision };
+    } catch (error) {
+      if (!(error && typeof error === "object" && "code" in error && error.code === "OBJECT_NOT_FOUND"))
+        throw error;
+      return { usageId, revision: 0, file, editRef: null };
+    }
+  }
+  get(raw) {
+    const input = getMediaUse.parse(raw), current = this.current(input.usageId, input.file);
+    this.source(input.file, current.revision > 0);
+    return current;
+  }
+  async bind(raw, call) {
+    const input = bindMediaUse.parse(raw);
+    const replay = this.data.receipt("mediaUses.bind", input, call);
+    if (replay) return replay.result;
+    this.assertWritable();
+    this.source(input.file);
+    this.data.get(input.editRef.objectId);
+    const saved2 = readSavedEdit(this.data, input.editRef);
+    if (!sameFile(saved2.file, input.file))
+      reject2("CANDIDATE_CHANGED", "This edit belongs to another candidate.");
+    await this.data.location(input.editRef);
+    await this.data.location(saved2.file.source, saved2.file.fileId);
+    return this.data.operation("mediaUses.bind", input, call, (transaction) => {
+      this.assertWritable();
+      this.source(input.file);
+      transaction.get(input.editRef.objectId);
+      const fixed = readSavedEdit(this.data, input.editRef);
+      if (!sameFile(fixed.file, input.file))
+        reject2("CANDIDATE_CHANGED", "This edit belongs to another candidate.");
+      const current = this.current(input.usageId, input.file);
+      if (current.revision !== input.expectedRevision)
+        throw new PluginError3(
+          "REVISION_CONFLICT",
+          "This usage changed while you were editing.",
+          "Reload the current usage and keep the editing draft.",
+          { currentRevision: current.revision }
+        );
+      const value = { usageId: input.usageId, file: input.file, editRef: input.editRef };
+      const objectId = idFor(this.data, input.usageId);
+      const record = current.revision === 0 ? transaction.create("studio.video-use", value, {}, objectId) : transaction.update(objectId, current.revision, value);
+      transaction.relation(objectId, null, input.file.source, "reference");
+      transaction.relation(objectId, null, input.editRef, "reference");
+      return { ...value, revision: record.revision };
+    });
+  }
+};
+
+// packages/project-studio/src/derived-videos.ts
+var DerivedVideos = class {
+  constructor(assets, provider) {
+    this.assets = assets;
+    this.provider = provider;
+    this.storeId = assets.data.storeId;
+    this.projectId = assets.data.scope.id;
+  }
+  assets;
+  provider;
+  capabilityVersion = "derived-video/1";
+  storeId;
+  projectId;
+  assertSameWorkspace(provider, projectId) {
+    if (provider !== this.provider || projectId !== this.projectId)
+      reject(
+        "WORKSPACE_MISMATCH",
+        "Media and assets must share the same storage provider and project."
+      );
+  }
+  async importDerivedVideo(input, call, complete) {
+    const data = this.assets.data;
+    if (call.requestKey !== input.publicationKey || !input.inputs.length)
+      reject("INVALID_PUBLICATION", "A fixed publication identity and sources are required.");
+    const name = "assets.importDerivedVideo";
+    const replay = data.receipt(name, input, call);
+    if (replay) return replay.result;
+    if (complete.constructor.name === "AsyncFunction")
+      reject("ASYNC_TRANSACTION", "Media completion must be synchronous.");
+    this.assets.assertWritable();
+    const operationId = stableId(data.storeId, call, name), objectId = stableId(operationId, call, "object"), versionId = stableId(operationId, call, "version");
+    let result2;
+    try {
+      const published = await data.publish(
+        [input.stagingFileId],
+        objectId,
+        versionId,
+        operationId,
+        call.actor.id
+      );
+      if (published.kind !== "video")
+        reject("TYPE_MISMATCH", "A derived output must be a validated video.");
+      result2 = data.operation(name, input, call, (t) => {
+        this.assets.assertWritable();
+        const guard = () => {
+          const job2 = t.get(input.completion.jobId);
+          if (job2.typeId !== "media.job" || job2.data.state !== "saving" || job2.revision !== input.completion.expectedRevision || job2.data.executionToken !== input.completion.executionToken || job2.data.cancelRequested)
+            reject("STALE_EXECUTION", "The media job is canceled, replaced or no longer saving.");
+          const request = job2.data.snapshot.request;
+          const expected = job2.data.snapshot.descriptors.map((descriptor, index) => {
+            const selected = request.operation === "video.process" ? request.input.input : request.input.inputs[index];
+            return {
+              file: descriptor.file,
+              editRef: selected.kind === "edit" ? selected.editRef : null,
+              recipe: descriptor.recipe
+            };
+          });
+          if (canonical(expected) !== canonical(input.inputs) || request.input.outputName !== input.outputName || input.provenance?.kind !== job2.data.kind)
+            reject(
+              "PUBLICATION_INPUT_CONFLICT",
+              "The output must preserve the accepted ordered sources, recipe and name."
+            );
+          return job2;
+        };
+        guard();
+        for (const source of input.inputs) {
+          const asset = t.get(source.file.source.objectId, true);
+          if (asset.typeId !== "studio.asset" || asset.data.kind !== "video" || !data.files(source.file.source).some((f) => f.fileId === source.file.fileId))
+            reject("INVALID_REFERENCE", "A fixed source is no longer available.");
+          if (source.editRef) data.version(source.editRef);
+        }
+        const sourceRef = input.provenance?.kind !== "sequence" && input.inputs.length === 1 ? input.inputs[0].file.source : null;
+        const saved2 = this.assets.commitPreparedImport(
+          t,
+          {
+            name: input.outputName,
+            origin: "authored",
+            sourceRef,
+            metadata: { media: input.provenance },
+            versionMetadata: { media: input.provenance }
+          },
+          published,
+          objectId,
+          versionId
+        );
+        const file = {
+          source: { storeId: data.storeId, objectId, versionId: saved2.version.versionId },
+          fileId: published.files[0].fileId
+        };
+        for (const source of input.inputs) {
+          t.relation(objectId, versionId, source.file.source, "reference");
+          if (!sourceRef) t.relation(objectId, versionId, source.file.source, "source");
+          if (source.editRef) t.relation(objectId, versionId, source.editRef, "reference");
+        }
+        const completed = complete(file);
+        if (completed && typeof completed.then === "function")
+          reject("ASYNC_TRANSACTION", "Media completion must be synchronous.");
+        const job = t.get(input.completion.jobId);
+        if (job.data.state !== "succeeded" || job.data.progress !== 1 || job.data.cancelRequested || job.data.executionToken !== input.completion.executionToken || job.data.result?.fileId !== file.fileId || job.data.result?.source?.versionId !== file.source.versionId || job.data.result?.source?.objectId !== file.source.objectId || job.data.result?.source?.storeId !== file.source.storeId)
+          reject("INCOMPLETE_PUBLICATION", "Media completion did not commit the same result.");
+        return file;
+      });
+    } catch (error) {
+      try {
+        await data.discardPublication(operationId);
+      } catch {
+        if (error && typeof error === "object") Object.assign(error, { cleanupPending: true });
+      }
+      throw error;
+    }
+    try {
+      await data.finishFiles(operationId);
+    } catch {
+    }
+    return result2;
+  }
+};
+function canonical(value) {
+  const sorted = (v) => Array.isArray(v) ? v.map(sorted) : v && typeof v === "object" ? Object.fromEntries(
+    Object.keys(v).sort().map((k) => [k, sorted(v[k])])
+  ) : v;
+  return JSON.stringify(sorted(value));
+}
+
+// packages/project-studio/src/generation.ts
+import { z as z7 } from "vivix-studio/sdk/shared";
+import { createHash as createHash4 } from "crypto";
+var taskData = z7.object({
+  taskId: z7.uuid(),
+  name: z7.string().trim().min(1).max(200).optional(),
+  projectId: z7.uuid(),
+  targetAssetId: z7.uuid(),
+  kind: z7.enum(["generate", "iterate"]),
+  state: z7.enum(taskStates),
+  retryOfTaskId: z7.uuid().nullable(),
+  provider: z7.string(),
+  apiInstanceId: z7.string(),
+  remoteTaskId: z7.string().nullable(),
+  remoteRequestKey: z7.string(),
+  remoteStatus: z7.string().nullable(),
+  outputRefs: z7.array(versionRef),
+  progress: z7.number().min(0).max(1).nullable(),
+  expectedOutputs: z7.number().int().positive(),
+  receivedOutputs: z7.number().int().nonnegative(),
+  error: z7.any().nullable(),
+  submittedAt: z7.string().nullable(),
+  finishedAt: z7.string().nullable(),
+  lastPolledAt: z7.string().nullable(),
+  nextPollAt: z7.string().nullable(),
+  attemptCount: z7.number().int().nonnegative(),
+  configDigest: z7.string(),
+  inputSnapshot: z7.any(),
+  remoteOutputs: z7.array(z7.any()),
+  execution: z7.any().nullable().default(null),
+  cost: taskBilling.safeExtend({
+    checkedAt: z7.string().nullable(),
+    nextCheckAt: z7.string().nullable(),
+    error: z7.object({ code: z7.string(), message: z7.string() }).nullable()
+  }).nullable().default(null)
+}).strict();
+var Generation = class {
+  constructor(assets, api, apiInstanceId, config) {
+    this.assets = assets;
+    this.api = api;
+    this.apiInstanceId = apiInstanceId;
+    this.config = config;
+  }
+  assets;
+  api;
+  apiInstanceId;
+  config;
+  async submit(value, call) {
+    call = {
+      actor: call.actor,
+      requestKey: call.requestKey,
+      confirmation: call.confirmation,
+      scope: this.assets.data.scope
+    };
+    const input = generationInput.parse(value), data = this.assets.data;
+    this.assets.assertWritable();
+    const replay = data.receipt("generation.submit", input, call);
+    if (replay) return replay.result;
+    if (Boolean(input.targetAssetId) === Boolean(input.newAsset))
+      reject("INVALID_TARGET", "Choose an existing target asset or a new asset.");
+    const target = input.targetAssetId ? this.assets.get(input.targetAssetId) : null;
+    if (target && target.revision !== input.expectedRevision)
+      reject("REVISION_CONFLICT", "Target asset changed.", target.revision);
+    const kind2 = target?.data.kind || input.newAsset.kind;
+    if (!["image", "video", "audio"].includes(kind2))
+      reject("INVALID_TARGET", "Generation requires an image, video or audio target.");
+    const refs = [];
+    for (const i of [...input.inputs].sort((a, b) => a.order - b.order)) {
+      const object = this.assets.get(i.ref.objectId);
+      const version = data.version(i.ref);
+      const location = await data.location(i.ref);
+      refs.push({
+        ...i,
+        kind: version.payload.kind,
+        mimeType: location.mimeType,
+        absolutePath: location.absolutePath
+      });
+    }
+    if (new Set(input.inputs.map((x) => x.order)).size !== input.inputs.length)
+      reject("INVALID_REFERENCE", "Reference order must be unique.");
+    let base2 = null;
+    if (input.baseVersionId) {
+      if (!target || !input.changeRequest)
+        reject("INVALID_ITERATION", "A fixed target version and a change request are required.");
+      base2 = data.version({
+        storeId: data.storeId,
+        objectId: target.objectId,
+        versionId: input.baseVersionId
+      });
+      await data.location({
+        storeId: data.storeId,
+        objectId: target.objectId,
+        versionId: base2.versionId
+      });
+      if (input.anchor.kind === "timeRange" && (!["video", "audio"].includes(base2.payload.kind) || !Number.isInteger(base2.payload.durationMs) || input.anchor.endMs < input.anchor.startMs || input.anchor.endMs > base2.payload.durationMs))
+        reject("INVALID_ANCHOR", "Time range exceeds the fixed version duration.");
+    } else if (input.changeRequest || input.anchor.kind !== "whole")
+      reject("INVALID_ITERATION", "Iteration context requires a base version.");
+    if (input.retryOfTaskId) {
+      const old = data.get(input.retryOfTaskId);
+      if (old.typeId !== "studio.task" || ![
+        "succeeded",
+        "failed",
+        "canceled",
+        "submission_unknown",
+        "partial",
+        "save_failed"
+      ].includes(old.data.state))
+        reject("INVALID_RETRY", "This task is not eligible for an explicit new generation.");
+      if (old.data.state === "submission_unknown" && !input.acknowledgeUnknown)
+        reject(
+          "UNKNOWN_ACKNOWLEDGEMENT_REQUIRED",
+          "The original submission may be charged. Explicitly acknowledge a new request."
+        );
+    }
+    const finalPrompt = base2 ? `${input.prompt}
+
+Change request: ${input.changeRequest}
+Preserve: ${input.preserveRequest}` : input.prompt;
+    const prepared = await this.api.prepare({ ...input, prompt: finalPrompt }, kind2, refs);
+    const taskId = stableId(data.storeId, call, "generation.task"), targetAssetId = target?.objectId || stableId(data.storeId, call, "generation.asset");
+    const snapshot = structuredClone({
+      scope: data.scope,
+      originalRequestKey: call.requestKey,
+      actor: call.actor,
+      approval: call.confirmation,
+      prompt: finalPrompt,
+      originalPrompt: input.prompt,
+      modelId: input.modelId,
+      capabilityId: input.capabilityId,
+      outputKind: kind2,
+      ...input.context && { context: input.context },
+      capabilityVersion: prepared.capabilityVersion,
+      capabilityHash: prepared.capabilityHash,
+      parameters: prepared.parameters,
+      inputs: input.inputs,
+      baseVersionId: base2?.versionId || null,
+      changeRequest: input.changeRequest || null,
+      preserveRequest: base2 ? input.preserveRequest : null,
+      anchor: base2 ? input.anchor : null,
+      outputCount: input.outputCount,
+      configSnapshot: {
+        studio: this.config,
+        api: this.api.config,
+        identity: prepared.identity,
+        adapterVersion: "1"
+      }
+    });
+    return data.operation("generation.submit", input, call, (t) => {
+      if (!target)
+        t.create(
+          "studio.asset",
+          assetData.parse({
+            projectId: data.scope.id,
+            name: input.newAsset.name,
+            kind: kind2,
+            origin: "generated"
+          }),
+          {},
+          targetAssetId
+        );
+      else if (t.get(targetAssetId).revision !== input.expectedRevision)
+        reject(
+          "REVISION_CONFLICT",
+          "Target changed before local acceptance.",
+          t.get(targetAssetId).revision
+        );
+      const task = t.create(
+        "studio.task",
+        taskData.parse({
+          taskId,
+          name: input.taskName || target?.data.name || input.newAsset.name,
+          projectId: data.scope.id,
+          targetAssetId,
+          kind: base2 ? "iterate" : "generate",
+          state: "queued",
+          retryOfTaskId: input.retryOfTaskId || null,
+          provider: "official",
+          apiInstanceId: this.apiInstanceId,
+          remoteTaskId: null,
+          remoteRequestKey: "studio-task-" + taskId,
+          remoteStatus: null,
+          outputRefs: [],
+          progress: null,
+          expectedOutputs: input.outputCount,
+          receivedOutputs: 0,
+          error: null,
+          submittedAt: null,
+          finishedAt: null,
+          lastPolledAt: null,
+          nextPollAt: null,
+          attemptCount: 0,
+          configDigest: hash(snapshot.configSnapshot),
+          inputSnapshot: snapshot,
+          execution: {
+            preparedRequest: prepared.wireRequest,
+            catalog: prepared.catalog,
+            wireRequest: null,
+            receipt: null
+          },
+          remoteOutputs: []
+        }),
+        {},
+        taskId
+      );
+      const protectedInputs = [
+        ...input.inputs.map((i) => i.ref),
+        ...base2 ? [{ storeId: data.storeId, objectId: target.objectId, versionId: base2.versionId }] : []
+      ];
+      for (const ref of new Map(protectedInputs.map((ref2) => [ref2.versionId, ref2])).values())
+        t.relation(taskId, null, ref, "input");
+      return { task, asset: t.get(targetAssetId), acceptedLocally: true };
+    });
+  }
+};
+var hash = (value) => createHash4("sha256").update(JSON.stringify(value)).digest("hex");
+
+// packages/project-studio/src/task-runner.ts
+import { randomUUID } from "crypto";
+
+// packages/project-studio/src/cost-recovery.ts
+var costRecoveryKey = "project-studio.costRecovery";
+var costAttemptOffsets = [0, 2e3, 4e3, 1e4, 15e3];
+var costWindowMs = 18e3;
+var legacyOffsets = [0, 2e3, 4e3];
+function costSchedule(format) {
+  return format === 1 ? legacyOffsets : costAttemptOffsets;
+}
+function confirmedCost(cost) {
+  const value = readTaskBilling({
+    billing: cost && { status: cost.status, credits: cost.credits }
+  });
+  return value.status === "settled" || value.status === "released";
+}
+function costBudget(record) {
+  const raw = record.metadata?.[costRecoveryKey];
+  if (!raw || raw.format !== 1 && raw.format !== 2 || !Number.isInteger(raw.attemptCount) || raw.attemptCount < 1 || raw.attemptCount > costSchedule(raw.format).length || typeof raw.startedAt !== "string" || typeof raw.deadlineAt !== "string")
+    return null;
+  const start = Date.parse(raw.startedAt), end = Date.parse(raw.deadlineAt);
+  if (!Number.isFinite(start) || end !== start + (raw.format === 1 ? 6e3 : costWindowMs) || raw.nextAttemptAt !== null && (typeof raw.nextAttemptAt !== "string" || !Number.isFinite(Date.parse(raw.nextAttemptAt)) || Date.parse(raw.nextAttemptAt) < start + (costSchedule(raw.format)[raw.attemptCount] ?? Infinity) || Date.parse(raw.nextAttemptAt) >= end) || raw.inFlight !== null && (!raw.inFlight || raw.inFlight.ordinal !== raw.attemptCount || typeof raw.inFlight.claimId !== "string" || !raw.inFlight.claimId))
+    return null;
+  return raw;
+}
+
+// packages/project-studio/src/task-runner.ts
+var advancing = /* @__PURE__ */ new Set();
+var activeCostQueries = /* @__PURE__ */ new Map();
+var terminal = ["succeeded", "failed", "canceled"];
+var maxUploadAttempts = 3;
+var beforeSubmission = (task) => task.attemptCount === 0 && !task.remoteTaskId && !task.execution?.receipt && !task.execution?.wireRequest;
+var TaskRunner = class {
+  constructor(data, api, notify = () => {
+  }) {
+    this.data = data;
+    this.api = api;
+    this.notify = notify;
+  }
+  data;
+  api;
+  notify;
+  costQueries = /* @__PURE__ */ new Map();
+  dispose() {
+    for (const controller of this.costQueries.values()) controller.abort();
+  }
+  call(key) {
+    return { scope: this.data.scope, actor: { kind: "local-user", id: "local" }, requestKey: key };
+  }
+  task(id2) {
+    const record = this.data.get(id2);
+    if (record.typeId !== "studio.task")
+      reject("TYPE_MISMATCH", "Expected a persisted project task.");
+    if (record.data.projectId !== this.data.scope.id || record.data.inputSnapshot?.scope?.id !== this.data.scope.id)
+      reject("SCOPE_MISMATCH", "The task belongs to another project.");
+    return record;
+  }
+  update(id2, changes, observation, old = this.task(id2)) {
+    if (changes.error) changes = { ...changes, error: errorValue(changes.error) };
+    const committed = this.data.operation(
+      "tasks.transition",
+      { id: id2, revision: old.revision, changes },
+      this.call(`transition-${id2}-${old.revision}`),
+      (t) => {
+        const data = { ...old.data, ...changes };
+        const metadata2 = stateMetadata(old, data, observation);
+        const currentBudget = costBudget(old);
+        if (currentBudget)
+          metadata2[costRecoveryKey] = confirmedCost(data.cost) ? {
+            ...currentBudget,
+            inFlight: null,
+            nextAttemptAt: null,
+            stoppedReason: "confirmed"
+          } : currentBudget;
+        return t.update(id2, old.revision, data, metadata2);
+      }
+    );
+    if (confirmedCost(committed.data.cost)) {
+      for (const [key, controller] of activeCostQueries)
+        if (key.startsWith(this.data.storeId + "/" + id2 + ":")) controller.abort();
+    }
+    try {
+      this.notify(structuredClone(old), structuredClone(committed));
+    } catch {
+    }
+    return committed;
+  }
+  costChanges(remote, previous) {
+    const current = readTaskBilling(remote);
+    if (confirmedCost(previous) && !confirmedCost(current))
+      return {
+        cost: {
+          ...previous,
+          error: {
+            code: "BILLING_UNAVAILABLE",
+            message: "The latest cost is unavailable. The last confirmed charge is retained."
+          }
+        }
+      };
+    return {
+      cost: { ...current, checkedAt: (/* @__PURE__ */ new Date()).toISOString(), nextCheckAt: null, error: null }
+    };
+  }
+  // Queue visits can refresh old pending charges after their automatic checks have ended.
+  queueCostReads = /* @__PURE__ */ new Map();
+  async refreshQueueCost(id2) {
+    const record = this.task(id2);
+    const budget = costBudget(record);
+    if (!terminal.includes(record.data.state) || record.data.cost?.status !== "pending" || !budget || !budget.stoppedReason && Date.now() < Date.parse(budget.deadlineAt))
+      return false;
+    const existing = this.queueCostReads.get(id2);
+    if (existing) return confirmedCost((await existing).data.cost);
+    const work = this.syncCost(id2, true);
+    this.queueCostReads.set(id2, work);
+    try {
+      return confirmedCost((await work).data.cost);
+    } finally {
+      this.queueCostReads.delete(id2);
+    }
+  }
+  claimCostAttempt(id2) {
+    const initial = this.task(id2), existing = costBudget(initial), now = Date.now();
+    if (confirmedCost(initial.data.cost) || initial.metadata?.[costRecoveryKey] !== void 0 && !existing || existing?.stoppedReason)
+      return null;
+    if (existing && now >= Date.parse(existing.startedAt) && now < Date.parse(existing.deadlineAt) && (existing.inFlight || existing.attemptCount >= costSchedule(existing.format).length || !existing.nextAttemptAt || now < Date.parse(existing.nextAttemptAt)))
+      return null;
+    const claimId = randomUUID();
+    let claimed = false;
+    const record = this.data.operation(
+      "tasks.costClaim",
+      { id: id2, claimId },
+      this.call(`cost-claim-${claimId}`),
+      (tx) => {
+        const current = tx.get(id2), now2 = Date.now();
+        if (confirmedCost(current.data.cost)) return current;
+        let budget = costBudget(current);
+        if (current.metadata?.[costRecoveryKey] !== void 0 && !budget) return current;
+        if (budget) {
+          if (budget.stoppedReason) return current;
+          if (now2 < Date.parse(budget.startedAt) || now2 >= Date.parse(budget.deadlineAt))
+            return tx.update(id2, current.revision, current.data, {
+              ...current.metadata,
+              [costRecoveryKey]: {
+                ...budget,
+                inFlight: null,
+                nextAttemptAt: null,
+                stoppedReason: "deadline"
+              }
+            });
+          if (budget.inFlight || budget.attemptCount >= costSchedule(budget.format).length || !budget.nextAttemptAt || now2 < Date.parse(budget.nextAttemptAt))
+            return current;
+          const ordinal = budget.attemptCount + 1;
+          budget = {
+            ...budget,
+            attemptCount: ordinal,
+            inFlight: { ordinal, claimId },
+            nextAttemptAt: null
+          };
+        } else
+          budget = {
+            format: 2,
+            startedAt: new Date(now2).toISOString(),
+            deadlineAt: new Date(now2 + costWindowMs).toISOString(),
+            attemptCount: 1,
+            nextAttemptAt: null,
+            inFlight: { ordinal: 1, claimId }
+          };
+        const result2 = tx.update(id2, current.revision, current.data, {
+          ...current.metadata,
+          [costRecoveryKey]: budget
+        });
+        claimed = true;
+        return result2;
+      }
+    );
+    return claimed ? { record, budget: costBudget(record) } : null;
+  }
+  async syncCost(id2, force = false) {
+    const original = this.task(id2);
+    const task = original.data;
+    if (!task.remoteTaskId && !task.execution?.receipt && !task.attemptCount) return original;
+    if (force) {
+      try {
+        const remote2 = await this.api.query(task);
+        return this.update(id2, this.costChanges(remote2, this.task(id2).data.cost));
+      } catch (error2) {
+        const current = this.task(id2);
+        return this.update(id2, {
+          cost: {
+            status: current.data.cost?.status || "unavailable",
+            credits: current.data.cost?.credits ?? null,
+            checkedAt: current.data.cost?.checkedAt || null,
+            nextCheckAt: null,
+            error: {
+              code: error2?.code || "BILLING_QUERY_FAILED",
+              message: "Cost could not be refreshed. Try again later."
+            }
+          }
+        });
+      }
+    }
+    let claim;
+    try {
+      claim = this.claimCostAttempt(id2);
+    } catch (error2) {
+      if (!["SQLITE_BUSY", "SQLITE_BUSY_SNAPSHOT", "REVISION_CONFLICT"].includes(error2?.code))
+        throw error2;
+      return this.task(id2);
+    }
+    if (!claim) return this.task(id2);
+    const { record, budget } = claim, claimId = budget.inFlight.claimId;
+    const controller = new AbortController(), queryKey = this.data.storeId + "/" + id2 + ":" + claimId;
+    const remaining = Date.parse(budget.deadlineAt) - Date.now();
+    if (remaining <= 0) controller.abort();
+    const timer = setTimeout(() => controller.abort(), Math.max(0, remaining));
+    this.costQueries.set(queryKey, controller);
+    activeCostQueries.set(queryKey, controller);
+    let remote, error, aborted;
+    try {
+      controller.signal.throwIfAborted();
+      remote = await Promise.race([
+        this.api.query(record.data, { signal: controller.signal }),
+        new Promise((_, reject3) => {
+          aborted = () => reject3(controller.signal.reason);
+          controller.signal.addEventListener("abort", aborted, { once: true });
+          if (controller.signal.aborted) aborted();
+        })
+      ]);
+    } catch (cause) {
+      error = cause;
+    } finally {
+      clearTimeout(timer);
+      if (aborted) controller.signal.removeEventListener("abort", aborted);
+      this.costQueries.delete(queryKey);
+      activeCostQueries.delete(queryKey);
+    }
+    let before;
+    const committed = this.data.operation(
+      "tasks.costResult",
+      { id: id2, claimId },
+      this.call(`cost-result-${claimId}`),
+      (tx) => {
+        const current = tx.get(id2), active = costBudget(current), now = Date.now();
+        if (!active || active.inFlight?.claimId !== claimId || active.stoppedReason || confirmedCost(current.data.cost))
+          return current;
+        if (controller.signal.aborted && now >= Date.parse(active.startedAt) && now < Date.parse(active.deadlineAt))
+          return current;
+        before = current;
+        let next = { ...active, inFlight: null, nextAttemptAt: null };
+        let data = current.data;
+        if (controller.signal.aborted || now < Date.parse(active.startedAt) || now >= Date.parse(active.deadlineAt))
+          next.stoppedReason = "deadline";
+        else {
+          data = error ? {
+            ...data,
+            cost: {
+              status: data.cost?.status || "unavailable",
+              credits: data.cost?.credits ?? null,
+              checkedAt: data.cost?.checkedAt || null,
+              nextCheckAt: null,
+              error: {
+                code: error.code || "BILLING_QUERY_FAILED",
+                message: "Cost could not be refreshed. Try again later."
+              }
+            }
+          } : { ...data, ...this.costChanges(remote, data.cost) };
+          if (confirmedCost(data.cost)) next.stoppedReason = "confirmed";
+          else if (active.attemptCount === costSchedule(active.format).length)
+            next.stoppedReason = "exhausted";
+          else {
+            const retryAfter = Math.max(
+              0,
+              Number(error?.retryAfterMs || remote?.retry_after_ms) || 0
+            );
+            const nextAt = Math.max(
+              Date.parse(active.startedAt) + costSchedule(active.format)[active.attemptCount],
+              now + retryAfter
+            );
+            if (nextAt >= Date.parse(active.deadlineAt)) next.stoppedReason = "retry-after";
+            else next.nextAttemptAt = new Date(nextAt).toISOString();
+          }
+        }
+        return tx.update(id2, current.revision, data, {
+          ...stateMetadata(current, data),
+          [costRecoveryKey]: next
+        });
+      }
+    );
+    if (before) {
+      try {
+        this.notify(structuredClone(before), structuredClone(committed));
+      } catch {
+      }
+    }
+    return committed;
+  }
+  updateSubmission(task, changes, beforePost = false) {
+    const record = this.task(task.taskId);
+    if (record.data.state !== "submitting" || record.data.execution?.uploadAttempt !== task.execution?.uploadAttempt || beforePost && !beforeSubmission(record.data))
+      reject("TASK_ALREADY_CLAIMED", "The submission claim is no longer current.");
+    return this.update(task.taskId, changes, void 0, record);
+  }
+  recoverUpload(record, error) {
+    const task = record.data;
+    const retry = error.details?.retryable === true && task.execution.uploadAttempt < maxUploadAttempts;
+    const delay = Math.max(
+      task.inputSnapshot.configSnapshot.api.pollIntervalMs * 2 ** (task.execution.uploadAttempt - 1),
+      error.retryAfterMs || 0
+    );
+    return this.update(
+      task.taskId,
+      {
+        state: retry ? "queued" : "failed",
+        error,
+        nextPollAt: retry ? new Date(Date.now() + delay).toISOString() : null,
+        finishedAt: retry ? null : (/* @__PURE__ */ new Date()).toISOString()
+      },
+      void 0,
+      record
+    );
+  }
+  async advance(id2, restarting = false) {
+    const key = `${this.data.storeId}/${id2}`;
+    if (advancing.has(key)) return;
+    advancing.add(key);
+    try {
+      let record = this.task(id2), task = record.data;
+      if (terminal.includes(task.state) || ["save_failed", "partial"].includes(task.state)) {
+        await this.syncCost(id2);
+        return;
+      }
+      if (task.inputSnapshot?.configSnapshot?.adapterVersion !== "1") {
+        this.update(id2, {
+          error: {
+            code: "ADAPTER_INCOMPATIBLE",
+            message: "The original task requires a compatible receipt adapter.",
+            blocked: true
+          }
+        });
+        return;
+      }
+      if (restarting && task.state === "submitting") {
+        if (beforeSubmission(task) && Number.isSafeInteger(task.execution?.uploadAttempt) && task.execution.uploadAttempt > 0) {
+          record = this.recoverUpload(record, {
+            code: "REFERENCE_UPLOAD_INTERRUPTED",
+            message: "Reference preparation was interrupted before generation submission.",
+            details: { phase: "reference_upload", retryable: true }
+          });
+        } else
+          record = this.update(
+            id2,
+            {
+              state: "submission_unknown",
+              error: {
+                code: "INTERRUPTED_SUBMISSION",
+                message: "Submission may have been accepted and charged. Only the original key will be queried."
+              }
+            },
+            void 0,
+            record
+          );
+        task = record.data;
+      }
+      if (task.state === "submitting") return;
+      if (task.nextPollAt && Date.parse(task.nextPollAt) > Date.now()) return;
+      if (task.state === "queued") {
+        record = this.data.operation(
+          "tasks.claim",
+          { id: id2, revision: record.revision },
+          this.call(`claim-${id2}-${record.revision}`),
+          (t) => {
+            const current = t.get(id2);
+            if (current.revision !== record.revision || current.data.state !== "queued")
+              reject("TASK_ALREADY_CLAIMED", "The task is already being advanced.");
+            return t.update(id2, current.revision, {
+              ...current.data,
+              state: "submitting",
+              submittedAt: current.data.submittedAt || (/* @__PURE__ */ new Date()).toISOString(),
+              nextPollAt: null,
+              execution: {
+                ...current.data.execution,
+                uploadAttempt: (current.data.execution?.uploadAttempt || 0) + 1
+              },
+              error: null
+            });
+          }
+        );
+        task = record.data;
+        let receipt;
+        try {
+          const inputs = [];
+          for (const i of task.inputSnapshot.inputs) {
+            const v = this.data.version(i.ref), location = await this.data.location(i.ref);
+            inputs.push({ ...i, ...location, kind: v.payload.kind });
+          }
+          receipt = await this.api.submit(task, inputs, (pending) => {
+            if (!pending)
+              reject(
+                "RECEIPT_PERSISTENCE_REQUIRED",
+                "Submission requires the original durable task receipt."
+              );
+            this.updateSubmission(
+              task,
+              {
+                attemptCount: 1,
+                execution: {
+                  ...task.execution,
+                  wireRequest: pending.items[0].request,
+                  receipt: pending
+                }
+              },
+              true
+            );
+          });
+        } catch (e) {
+          if (["TASK_ALREADY_CLAIMED", "REVISION_CONFLICT"].includes(e?.code)) throw e;
+          const current = this.task(id2);
+          if (e?.code === "REFERENCE_UPLOAD_FAILED" && e?.details?.phase === "reference_upload" && beforeSubmission(current.data)) {
+            if (current.data.state !== "submitting" || current.data.execution?.uploadAttempt !== task.execution.uploadAttempt)
+              reject("TASK_ALREADY_CLAIMED", "The upload claim is no longer current.");
+            this.recoverUpload(current, e);
+          } else this.updateSubmission(task, { state: "submission_unknown", error: errorValue(e) });
+          return;
+        }
+        const item = receipt.items?.[0];
+        record = this.updateSubmission(task, {
+          state: item?.status === "accepted" ? "running" : item?.status === "rejected" ? "failed" : "submission_unknown",
+          remoteTaskId: item?.task_id || null,
+          error: item?.error || null,
+          execution: {
+            ...task.execution,
+            wireRequest: item?.request || task.execution?.preparedRequest,
+            receipt
+          },
+          ...item?.status === "rejected" ? { finishedAt: (/* @__PURE__ */ new Date()).toISOString() } : {}
+        });
+        task = record.data;
+      }
+      if (["submission_unknown", "running", "cancel_requested"].includes(task.state)) {
+        let remote;
+        try {
+          remote = await this.api.query(task);
+        } catch (e) {
+          this.update(id2, {
+            error: errorValue(e),
+            lastPolledAt: (/* @__PURE__ */ new Date()).toISOString(),
+            nextPollAt: new Date(
+              Date.now() + Math.max(
+                task.inputSnapshot.configSnapshot.api.pollIntervalMs,
+                e.retryAfterMs || 0
+              )
+            ).toISOString()
+          });
+          return;
+        }
+        const state = remote.status === "succeeded" ? "remote_succeeded" : remote.status === "failed" ? "failed" : ["cancelled", "canceled"].includes(remote.status) ? "canceled" : task.state === "submission_unknown" && !remote.task_id ? "submission_unknown" : task.state === "cancel_requested" ? "cancel_requested" : "running";
+        record = this.update(
+          id2,
+          {
+            state,
+            remoteTaskId: remote.task_id || task.remoteTaskId,
+            ...this.costChanges(remote, this.task(id2).data.cost),
+            remoteStatus: remote.status || null,
+            progress: typeof remote.progress === "number" ? remote.progress : null,
+            lastPolledAt: (/* @__PURE__ */ new Date()).toISOString(),
+            nextPollAt: ["running", "submission_unknown", "cancel_requested"].includes(state) ? new Date(
+              Date.now() + Math.max(
+                task.inputSnapshot.configSnapshot.api.pollIntervalMs,
+                remote.retry_after_ms || 0
+              )
+            ).toISOString() : null,
+            remoteOutputs: remote.outputs || remote.assets || task.remoteOutputs,
+            error: remote.error || null,
+            ...terminal.includes(state) ? { finishedAt: (/* @__PURE__ */ new Date()).toISOString() } : {}
+          },
+          {
+            status: remote.status,
+            resultCount: Array.isArray(remote.outputs || remote.assets) ? (remote.outputs || remote.assets).length : null
+          }
+        );
+        task = record.data;
+      }
+      if (["remote_succeeded", "saving"].includes(task.state)) await this.save(id2);
+    } catch (e) {
+      if (["TASK_ALREADY_CLAIMED", "REVISION_CONFLICT"].includes(e.code)) return;
+      const current = this.task(id2);
+      if (!terminal.includes(current.data.state))
+        this.update(id2, {
+          error: errorValue(e),
+          ...current.data.state === "queued" ? { state: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() } : current.data.state === "submitting" ? { state: "submission_unknown" } : {}
+        });
+    } finally {
+      advancing.delete(key);
+    }
+  }
+  async save(id2) {
+    let task = this.task(id2).data;
+    this.update(id2, { state: "saving", nextPollAt: null });
+    const errors = [];
+    for (const [index, output] of task.remoteOutputs.entries()) {
+      if (this.data.list({
+        typeId: "studio.taskOutput",
+        taskId: id2,
+        outputIndex: index,
+        includeDeleted: true,
+        limit: 1
+      }).items.length)
+        continue;
+      try {
+        const call = this.call(`task-output-${id2}-${index}`), op = stableId(this.data.storeId, call, "output"), versionId = stableId(op, call, "version");
+        const staged = await this.api.download(
+          output,
+          (source, name) => this.data.stage(source, name, call.actor.id),
+          task
+        );
+        const asset = this.data.get(task.targetAssetId);
+        if (staged.kind !== asset.data.kind)
+          reject("TYPE_MISMATCH", "Remote result has an unexpected actual media kind.");
+        const pub = await this.data.publish(
+          [staged.stagingFileId],
+          asset.objectId,
+          versionId,
+          op,
+          call.actor.id
+        );
+        this.data.operation(
+          "tasks.saveOutput",
+          {
+            taskId: id2,
+            outputIndex: index,
+            remoteOutputId: output.asset_id || output.file_id || output.id
+          },
+          call,
+          (t) => {
+            const existing = this.data.list({
+              typeId: "studio.taskOutput",
+              taskId: id2,
+              outputIndex: index,
+              includeDeleted: true,
+              limit: 1
+            }).items[0];
+            if (existing) return existing;
+            const current = t.get(id2), target = t.get(task.targetAssetId);
+            const version = t.commitVersion(target.objectId, target.revision, {
+              versionId,
+              parentVersionId: task.inputSnapshot.baseVersionId,
+              origin: "generated",
+              taskId: id2,
+              payload: payload(pub, {
+                taskId: id2,
+                outputIndex: index,
+                prompt: task.inputSnapshot.prompt,
+                originalPrompt: task.inputSnapshot.originalPrompt,
+                refs: structuredClone(task.inputSnapshot.inputs),
+                modelId: task.inputSnapshot.modelId,
+                parameters: structuredClone(task.inputSnapshot.parameters)
+              }),
+              files: pub.files
+            });
+            selectFirstAdCandidate(this.data, t, target.objectId, version.versionId);
+            const ref = {
+              storeId: this.data.storeId,
+              objectId: target.objectId,
+              versionId: version.versionId
+            };
+            const mapping = t.create("studio.taskOutput", {
+              taskId: id2,
+              outputIndex: index,
+              versionRef: ref,
+              remoteOutputId: output.asset_id || output.file_id || output.id
+            });
+            t.update(id2, current.revision, {
+              ...current.data,
+              outputRefs: [...current.data.outputRefs, ref],
+              receivedOutputs: current.data.receivedOutputs + 1
+            });
+            return mapping;
+          }
+        );
+        await this.data.finishFiles(op);
+        task = this.task(id2).data;
+      } catch (e) {
+        errors.push({ outputIndex: index, ...errorValue(e) });
+      }
+    }
+    task = this.task(id2).data;
+    const complete = task.receivedOutputs === task.expectedOutputs;
+    this.update(id2, {
+      state: complete ? "succeeded" : task.receivedOutputs ? "partial" : "save_failed",
+      error: errors.length ? {
+        code: "SAVE_INCOMPLETE",
+        message: "Some original outputs could not be saved.",
+        retryAction: "retryDownload",
+        details: { outputs: errors }
+      } : complete ? null : {
+        code: "OUTPUTS_MISSING",
+        message: "The original remote task did not return all expected outputs."
+      },
+      finishedAt: complete ? (/* @__PURE__ */ new Date()).toISOString() : null
+    });
+  }
+  async queryOriginal(id2) {
+    const task = this.task(id2).data;
+    if (terminal.includes(task.state)) return this.syncCost(id2, true);
+    if (["partial", "save_failed", "remote_succeeded"].includes(task.state)) {
+      const remote = await this.api.query(task);
+      return this.update(
+        id2,
+        {
+          remoteOutputs: remote.outputs || remote.assets || task.remoteOutputs,
+          ...this.costChanges(remote, this.task(id2).data.cost),
+          remoteStatus: remote.status || task.remoteStatus,
+          lastPolledAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        {
+          status: remote.status,
+          resultCount: Array.isArray(remote.outputs || remote.assets) ? (remote.outputs || remote.assets).length : null
+        }
+      );
+    }
+    if (task.state === "queued") return this.task(id2);
+    await this.advance(id2);
+    return this.task(id2);
+  }
+  async retryDownload(id2) {
+    const task = this.task(id2).data;
+    if (!["partial", "save_failed", "remote_succeeded"].includes(task.state))
+      reject("INVALID_STATE", "This task has no failed local save to retry.");
+    const remote = await this.api.query(task);
+    this.update(
+      id2,
+      {
+        remoteOutputs: remote.outputs || remote.assets || task.remoteOutputs,
+        ...this.costChanges(remote, this.task(id2).data.cost),
+        remoteStatus: remote.status || task.remoteStatus,
+        state: "saving",
+        nextPollAt: null
+      },
+      {
+        status: remote.status,
+        resultCount: Array.isArray(remote.outputs || remote.assets) ? (remote.outputs || remote.assets).length : null
+      }
+    );
+    await this.advance(id2);
+    return this.task(id2);
+  }
+  async cancel(id2) {
+    const task = this.task(id2).data;
+    if (task.state === "queued")
+      return this.update(id2, { state: "canceled", finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    if (!["running", "cancel_requested"].includes(task.state))
+      reject("CANCEL_UNAVAILABLE", "This task cannot currently be canceled.");
+    this.update(id2, { state: "cancel_requested" });
+    const remote = await this.api.cancel(task);
+    if (["cancelled", "canceled"].includes(remote.status))
+      this.update(id2, {
+        state: "canceled",
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...this.costChanges(remote, this.task(id2).data.cost),
+        remoteStatus: remote.status
+      });
+    return this.task(id2);
+  }
+};
+function errorValue(e) {
+  return {
+    code: e?.code || "TASK_ERROR",
+    message: typeof e === "string" ? e : e?.message || "Task failed.",
+    retryAction: e?.retryAction || null,
+    details: e?.details || (e?.blocked ? { blocked: true } : e?.currentRevision ? { currentRevision: e.currentRevision } : null)
+  };
+}
+
+// packages/project-studio/src/server.ts
+var Config2 = studioConfig;
+var dependencies = (c) => [
+  c.dataInstance,
+  c.apiInstance,
+  ...c.libraryInstance ? [c.libraryInstance] : []
+];
+var definitions = [
+  ["studio.project", (x) => projectData.parse(x)],
+  ["studio.asset", (x) => assetData.parse(x)],
+  ["studio.task", (x) => taskData.parse(x)],
+  ["studio.favorite", (x) => favoriteData.parse(x)],
+  [
+    "studio.taskOutput",
+    (x) => z8.object({
+      taskId: z8.uuid(),
+      outputIndex: z8.number().int().nonnegative(),
+      versionRef,
+      remoteOutputId: z8.string().nullable().optional()
+    }).strict().parse(x)
+  ]
+];
+var typeDefinitions = definitions.map(([typeId, validate]) => ({
+  typeId,
+  schemaVersion: 1,
+  scopeKinds: ["project"],
+  validate,
+  validateUpdate: (a, b) => {
+    if (typeId === "studio.favorite" && ["storeId", "objectId", "versionId"].some((key) => a.ref[key] !== b.ref[key]))
+      reject("IMMUTABLE_FIELD", "A favorite keeps its selected asset version.");
+    if (typeId === "studio.asset" && (a.kind !== b.kind || a.projectId !== b.projectId || a.origin !== b.origin || ["storeId", "objectId", "versionId"].some((k) => a.sourceRef?.[k] !== b.sourceRef?.[k])))
+      reject("IMMUTABLE_FIELD", "Asset kind, origin, project and source are immutable.");
+    if (typeId === "studio.task" && (hash(a.inputSnapshot) !== hash(b.inputSnapshot) || a.taskId !== b.taskId || a.projectId !== b.projectId || a.remoteRequestKey !== b.remoteRequestKey || a.configDigest !== b.configDigest || a.apiInstanceId !== b.apiInstanceId || hash(a.execution?.preparedRequest) !== hash(b.execution?.preparedRequest) || hash(a.execution?.catalog) !== hash(b.execution?.catalog)))
+      reject(
+        "IMMUTABLE_FIELD",
+        "Task identity, execution request and configuration snapshots cannot be changed."
+      );
+  }
+}));
+var id = z8.uuid();
+var revision = z8.number().int().positive();
+var empty = z8.object({}).strict();
+var base = z8.object({ assetId: id, expectedRevision: revision }).strict();
+var locationInput = z8.union([
+  z8.object({ source: versionRef, fileId: id.optional() }).strict(),
+  z8.object({ ref: versionRef, fileId: id.optional() }).strict()
+]);
+var operationDescriptions = {
+  "documents.list": "List persisted extension documents in the bound scope. Does not create content.",
+  "documents.create": "Create a persisted extension document with the original write request key.",
+  "documents.update": "Save document content only at its observed revision; preserve the draft on conflict.",
+  "documents.delete": "Delete the specified extension document at its observed revision.",
+  "files.resolveLocation": "Resolve an exact immutable version and optional file ID to a readable local location and preview URL. Does not render or export.",
+  "files.openLocation": "Open the containing directory of an exact readable immutable version. Does not modify its bytes.",
+  "metadata.patch": "Update only the named object metadata using its observed revision and a stable write request key.",
+  "metadata.keys": "List metadata keys available in this binding for building actual queries and views.",
+  "generation.submit": "Submit one approved generation with a durable original request key; acceptance is not completion or successful file saving.",
+  "projects.get": "Read the current project record and its revision before changing settings.",
+  "projects.update": "Update the specified project settings at the observed revision, preserving unrelated project content.",
+  "projects.archive": "Archive the project record without deleting its saved asset versions.",
+  "projects.restore": "Restore the archived project record without regenerating content.",
+  "assets.list": "List project assets with current selection, availability, and version summary. Candidate versions remain separate.",
+  "assets.get": "Read one project asset, immutable versions, selected version, and current revision.",
+  "assets.import": "Create a new project asset from validated staged media IDs. Does not treat a host path as a staged upload.",
+  "assets.importVersion": "Append imported content as an immutable candidate version of the existing asset at its observed revision.",
+  "assets.createText": "Create a project text asset and its initial saved version.",
+  "assets.saveText": "Save a new immutable text version from the specified parent and observed asset revision.",
+  "assets.update": "Change asset name, tags, or settings at the observed revision without rewriting saved media.",
+  "assets.delete": "Remove the asset from active use while retaining history and protected references according to the existing lifecycle.",
+  "choices.adopt": "Explicitly select an existing immutable candidate version for this asset at the observed revision.",
+  "choices.clear": "Clear the current candidate choice at the observed revision while keeping saved versions.",
+  "assets.importMaterial": "Copy the chosen fixed library material version into this project and retain provenance.",
+  "assets.collectMaterial": "Collect the specified saved project version into the library without regenerating or changing original bytes.",
+  "tasks.list": "List persisted project tasks and their original request identities. Reading never submits another generation.",
+  "tasks.get": "Read one persisted task, its remote receipt, save state, errors, and actual output references.",
+  "tasks.queryOriginal": "Query the original Provider receipt for a persisted task with an unknown submission outcome. Never resubmit it.",
+  "tasks.retryDownload": "Save the original completed Provider outputs again after a local saving failure. Does not regenerate or create a new paid intent.",
+  "tasks.cancel": "Request cancellation of the existing task and return its actual outcome; closing a page is not cancellation.",
+  "assets.cleanupImpact": "Read references that protect an asset or its versions before requesting purge.",
+  "assets.purge": "Permanently purge eligible asset data only after impact checks and explicit confirmation.",
+  "assets.batchLocations": "Resolve the requested exact version references for download without switching to newer candidates.",
+  "mediaUses.get": "Read the edit bound to this exact fixed video usage. Does not select or encode content.",
+  "mediaUses.bind": "Bind an immutable edit to the observed fixed usage and revision while preserving protected references. Does not encode a file.",
+  "ads.get": "Read the persisted advertising brief, storyboard order, clip identities, and revision.",
+  "ads.initialize": "Create the initial advertising storyboard once without generating video.",
+  "ads.addClip": "Add an empty storyboard clip and stable asset identity at the observed revision.",
+  "ads.updateBrief": "Save brief context and fixed references at the observed storyboard revision; this does not generate content.",
+  "ads.updateClip": "Save the specified clip script at the observed storyboard revision without synthesizing narration or captions.",
+  "ads.reorder": "Save the explicit storyboard order at the observed revision while retaining clip choices.",
+  "ads.removeClip": "Remove the clip from the storyboard at the observed revision while preserving its asset and versions.",
+  "global.query": "Query the bound workspace business projections with read-only SQL, filtering and ordering before pagination. Does not copy assets into a library.",
+  "global.projectNames": "Read the saved display names for the Studio Home project catalog.",
+  "global.projectSummaries": "Read saved project display names and cover references for Studio Home.",
+  "global.renameProject": "Rename a project at its observed settings revision.",
+  "global.setProjectCover": "Set or clear an exact saved image as the project cover at the observed project revision.",
+  "global.asset": "Read an exact saved asset version through the coordinator while retaining its original project identity.",
+  "global.favorite": "Persist or remove a favorite pinned to the specified immutable VersionRef. Does not change the adopted candidate.",
+  "tasks.global": "List persisted tasks across the coordinator binding with pagination, including actual execution state.",
+  "tasks.rename": "Change the persisted display name of the specified task without changing its execution."
+};
+async function activate(ctx) {
+  const scope = ctx.scope || { kind: "project", id: ctx.project.id };
+  if (ctx.config.role === "coordinator" !== (scope.kind === "user"))
+    reject(
+      "SCOPE_MISMATCH",
+      "The coordinator belongs to user scope and project studio belongs to project scope."
+    );
+  const all = ctx.plugins.get(ctx.config.dataInstance).bind({
+    scope,
+    ownerPackage: "@vivix/project-studio",
+    // Compatible project-studio releases share the same registered storage schemas.
+    packageVersion: "0.1.22-ecommerce.20261110.1",
+    actorId: "local",
+    access: ["data.workspace"]
+  });
+  for (const definition2 of [...typeDefinitions, adDefinition]) all.register(definition2);
+  const api = ctx.plugins.get(ctx.config.apiInstance);
+  const bindCall = (c) => ({
+    actor: c.actor,
+    requestKey: c.requestKey,
+    confirmation: c.confirmation,
+    scope
+  });
+  const handle = (name, input, fn, effects = ["read"], confirm = "none") => ctx.handle(
+    defineOperation2({
+      id: name,
+      title: name,
+      description: operationDescriptions[name] || "Operate on the specified scoped record using the declared schema and observed revision.",
+      input,
+      output: z8.any(),
+      effects,
+      confirm
+    }),
+    (i, c) => fn(i, bindCall(c))
+  );
+  let stopped = false, running = false;
+  let costCursor = "";
+  const runners = /* @__PURE__ */ new Map();
+  const runnerFor = (projectId) => {
+    let runner2 = runners.get(projectId);
+    if (!runner2) {
+      runner2 = new TaskRunner(
+        all.project(projectId),
+        api,
+        (before, after) => notifyCommitted(
+          () => ctx.events.forScope({ kind: "project", id: projectId }),
+          before,
+          after
+        )
+      );
+      runners.set(projectId, runner2);
+    }
+    return runner2;
+  };
+  const tick = async (restarting = false) => {
+    if (stopped || running) return;
+    running = true;
+    try {
+      for (let afterId = ""; !stopped; ) {
+        const page = all.tasks({ limit: 200, unfinished: true, afterId });
+        for (const record of page) {
+          if (stopped) break;
+          if (ctx.config.role === "project" && record.scope.id !== scope.id) continue;
+          try {
+            await runnerFor(record.scope.id).advance(record.objectId, restarting);
+          } catch (error) {
+            if (["REVISION_CONFLICT", "TASK_ALREADY_CLAIMED"].includes(error?.code))
+              continue;
+            const runner2 = runnerFor(record.scope.id);
+            runner2.update(record.objectId, {
+              error: { ...errorValue(error), details: { blocked: true } }
+            });
+          }
+        }
+        if (page.length < 200) break;
+        afterId = page.at(-1).objectId;
+      }
+      const costs = all.tasks({ limit: 5, needsCostSync: true, afterId: costCursor });
+      for (const record of costs) {
+        if (stopped) break;
+        costCursor = record.objectId;
+        if (ctx.config.role === "project" && record.scope.id !== scope.id) continue;
+        await runnerFor(record.scope.id).syncCost(record.objectId);
+      }
+      if (costs.length < 5) costCursor = "";
+    } finally {
+      running = false;
+    }
+  };
+  const start = async () => {
+    await tick(true);
+    const interval = setInterval(() => {
+      void tick().catch(() => {
+      });
+    }, 1e3);
+    interval.unref();
+    ctx.onDispose(async () => {
+      stopped = true;
+      clearInterval(interval);
+      for (const runner2 of runners.values()) runner2.dispose();
+      while (running) await new Promise((resolve) => setTimeout(resolve, 25));
+    });
+  };
+  if (ctx.config.role === "coordinator") {
+    const global = new GlobalStudio(all);
+    handle(
+      "global.import",
+      z8.object({
+        projectId: z8.uuid(),
+        name: z8.string().trim().min(1).max(200),
+        stagingFileIds: z8.array(z8.uuid()).min(1).max(20)
+      }).strict(),
+      (input, call) => global.importAsset(input, call),
+      ["write"]
+    );
+    handle("global.query", globalQueryInput, (input) => global.query(input));
+    handle(
+      "global.refreshTaskCost",
+      z8.object({ projectId: id, taskId: id }).strict(),
+      async ({ projectId, taskId }) => ({
+        confirmed: await runnerFor(projectId).refreshQueueCost(taskId)
+      }),
+      ["write"]
+    );
+    handle("global.projectNames", z8.object({}).strict(), () => global.projectNames());
+    handle("global.projectSummaries", z8.object({}).strict(), () => global.projectSummaries());
+    handle(
+      "global.renameProject",
+      projectSettingsInput.pick({ projectId: true, expectedRevision: true }).extend({ name: projectSettingsInput.shape.changes.shape.name.unwrap() }).strict(),
+      (input, call) => global.renameProject(input, call),
+      ["write"]
+    );
+    handle(
+      "global.setProjectCover",
+      projectSettingsInput.pick({ projectId: true, expectedRevision: true }).extend({ coverRef: versionRef.nullable() }).strict(),
+      (input, call) => global.setProjectCover(input, call),
+      ["write"]
+    );
+    handle(
+      "global.asset",
+      z8.object({ ref: versionRef }).strict(),
+      (input) => global.asset(input.ref)
+    );
+    handle(
+      "global.favorite",
+      z8.object({ ref: versionRef, enabled: z8.boolean() }).strict(),
+      (input, call) => global.favorite(input, call),
+      ["write"]
+    );
+    handle(
+      "tasks.global",
+      z8.object({
+        limit: z8.number().int().min(1).max(200).default(50),
+        offset: z8.number().int().nonnegative().default(0)
+      }).strict(),
+      (i) => {
+        const items = all.tasks({ limit: i.limit + 1, offset: i.offset });
+        return {
+          items: items.slice(0, i.limit).map(taskProjection),
+          nextOffset: items.length > i.limit ? i.offset + i.limit : null
+        };
+      }
+    );
+    ctx.provide({ role: "coordinator", data: all, global });
+    await start();
+    return;
+  }
+  const initialProject = projectData.safeParse({ name: ctx.project.name });
+  all.ensureProject(
+    scope.id,
+    initialProject.success ? initialProject.data : projectData.parse({ name: scope.id }),
+    {
+      scope,
+      actor: { kind: "local-user", id: "local" },
+      requestKey: `studio-project-${scope.id}`
+    }
+  );
+  const data = all.project(scope.id);
+  const library = ctx.config.libraryInstance ? ctx.plugins.get(ctx.config.libraryInstance) : void 0;
+  const assets = new Assets(data, all, library), projects = new Projects(data);
+  const mediaUses = new MediaUses(
+    data,
+    (definition2) => all.register(definition2),
+    () => assets.assertWritable()
+  );
+  handle("mediaUses.get", getMediaUse, (input) => mediaUses.get(input));
+  handle("mediaUses.bind", bindMediaUse, (input, call) => mediaUses.bind(input, call), ["write"]);
+  const generation = new Generation(assets, api, ctx.config.apiInstance, ctx.config), runner = runnerFor(scope.id);
+  const ads = new Ads(data);
+  const adRevision = z8.object({ expectedRevision: revision }).strict();
+  handle("ads.get", empty, () => ads.get());
+  handle("ads.initialize", empty, (_i, c) => ads.initialize(c), ["write"]);
+  handle(
+    "ads.addClip",
+    adRevision.extend({ title: z8.string().trim().min(1).max(200) }).strict(),
+    (i, c) => ads.addClip(i, c),
+    ["write"]
+  );
+  handle(
+    "ads.updateBrief",
+    adRevision.extend({ brief: adBrief }).strict(),
+    (i, c) => ads.updateBrief(i, c),
+    ["write"]
+  );
+  handle(
+    "ads.updateClip",
+    adRevision.extend({ assetId: id, script: clipScript }).strict(),
+    (i, c) => ads.updateClip(i, c),
+    ["write"]
+  );
+  handle(
+    "ads.reorder",
+    adRevision.extend({ clipIds: z8.array(id).max(200) }).strict(),
+    (i, c) => ads.reorder(i, c),
+    ["write"]
+  );
+  handle(
+    "ads.removeClip",
+    adRevision.extend({ assetId: id }).strict(),
+    (i, c) => ads.removeClip(i, c),
+    ["write"]
+  );
+  handle(
+    "projects.get",
+    z8.object({ projectId: id.optional() }).strict(),
+    (i) => projects.get(i.projectId)
+  );
+  handle("projects.update", projectSettingsInput, (i, c) => projects.update(i, c), ["write"]);
+  for (const [name, status] of [
+    ["projects.archive", "archived"],
+    ["projects.restore", "active"]
+  ])
+    handle(
+      name,
+      z8.object({ projectId: id, expectedRevision: revision }).strict(),
+      (i, c) => projects.update({ ...i, changes: { status } }, c),
+      ["write"]
+    );
+  handle(
+    "assets.list",
+    z8.object({
+      search: z8.string().optional(),
+      kind: z8.string().optional(),
+      tag: z8.string().optional(),
+      metadataEquals: z8.record(z8.string(), z8.any()).optional(),
+      metadataContains: z8.record(z8.string(), z8.any()).optional(),
+      sort: z8.enum(["name", "createdAt", "updatedAt"]).optional(),
+      direction: z8.enum(["asc", "desc"]).optional(),
+      limit: z8.number().int().min(1).max(200).optional(),
+      offset: z8.number().int().nonnegative().optional()
+    }).strict(),
+    async (i) => {
+      const rows = data.list({ typeId: "studio.asset", ...i });
+      return {
+        ...rows,
+        items: await Promise.all(rows.items.map((x) => assets.describe(x.objectId)))
+      };
+    }
+  );
+  handle("assets.get", z8.object({ assetId: id }).strict(), (i) => assets.describe(i.assetId));
+  handle(
+    "assets.import",
+    z8.object({
+      name: z8.string().min(1).max(200),
+      stagingFileIds: z8.array(id).min(1).max(20),
+      kind: z8.enum(["text", "image", "video", "audio", "file"]).optional(),
+      tags: assetData.shape.tags.optional()
+    }).strict(),
+    (i, c) => assets.import(i, c),
+    ["write"]
+  );
+  handle(
+    "assets.importVersion",
+    base.extend({ parentVersionId: id.optional(), stagingFileIds: z8.array(id).min(1).max(20) }).strict(),
+    (i, c) => assets.import(i, c, true),
+    ["write"]
+  );
+  handle(
+    "assets.createText",
+    z8.object({ name: z8.string().min(1).max(200), text: z8.string().max(8e5) }).strict(),
+    (i, c) => assets.text(i, c),
+    ["write"]
+  );
+  handle(
+    "assets.saveText",
+    base.extend({ parentVersionId: id.optional(), text: z8.string().max(8e5) }).strict(),
+    (i, c) => assets.text(i, c),
+    ["write"]
+  );
+  handle(
+    "assets.update",
+    base.extend({
+      changes: assetData.pick({ name: true, tags: true, purpose: true, orderKey: true, lifecycle: true }).extend({
+        tags: assetData.shape.tags.unwrap(),
+        purpose: assetData.shape.purpose.unwrap(),
+        orderKey: assetData.shape.orderKey.unwrap(),
+        lifecycle: assetData.shape.lifecycle.unwrap()
+      }).partial().strict()
+    }).strict(),
+    (i, c) => assets.update(i, c),
+    ["write"]
+  );
+  handle("assets.delete", base, (i, c) => assets.remove(i, c), ["write"]);
+  handle("choices.adopt", base.extend({ versionId: id }).strict(), (i, c) => assets.adopt(i, c), [
+    "write"
+  ]);
+  handle("choices.clear", base, (i, c) => assets.adopt(i, c, true), ["write"]);
+  handle(
+    "assets.importMaterial",
+    z8.object({
+      ref: versionRef,
+      targetProjectId: id.optional(),
+      assetId: id.optional(),
+      expectedRevision: revision.optional(),
+      parentVersionId: id.optional()
+    }).strict(),
+    async (i, c) => {
+      if (i.targetProjectId && i.targetProjectId !== scope.id)
+        reject("SCOPE_MISMATCH", "Target project does not match the active project.");
+      if (!library) reject("LIBRARY_UNAVAILABLE", "Configure a material library before importing.");
+      return assets.copy(() => library.snapshot(i.ref), i.ref, i, c, Boolean(i.assetId));
+    },
+    ["write"]
+  );
+  handle(
+    "assets.collectMaterial",
+    z8.object({ ref: versionRef, name: z8.string().min(1).max(200).optional() }).strict(),
+    (i, c) => assets.collect(i, c),
+    ["write"]
+  );
+  handle("files.resolveLocation", locationInput, (i) => data.location(i.source || i.ref, i.fileId));
+  handle("files.openLocation", locationInput, async (i) => {
+    const loc = await data.location(i.source || i.ref, i.fileId), { execFile } = await import("child_process"), { promisify } = await import("util");
+    if (process.platform === "darwin") await promisify(execFile)("open", ["-R", loc.absolutePath]);
+    else reject("OPEN_LOCATION_UNAVAILABLE", "Open-location is not verified on this platform.");
+    return loc;
+  });
+  handle(
+    "metadata.patch",
+    z8.object({
+      objectId: id,
+      expectedRevision: revision,
+      set: z8.record(z8.string(), z8.any()),
+      remove: z8.array(z8.string())
+    }).strict(),
+    (i, c) => {
+      assets.assertWritable();
+      return data.patchMetadata(i.objectId, i.expectedRevision, i.set, i.remove, c);
+    },
+    ["write"]
+  );
+  handle(
+    "metadata.keys",
+    z8.object({
+      typeId: z8.enum(["studio.asset", "extensions.document"]),
+      limit: z8.number().int().min(1).max(200).optional()
+    }).strict(),
+    (i) => data.metadataKeys(i.typeId, i.limit)
+  );
+  handle("documents.list", empty, () => data.list({ typeId: "extensions.document" }));
+  for (const action of ["create", "update", "delete"])
+    handle(
+      "documents." + action,
+      action === "create" ? z8.object({ name: z8.string(), payload: z8.json() }).strict() : action === "update" ? z8.object({
+        objectId: id,
+        expectedRevision: revision,
+        name: z8.string(),
+        payload: z8.json()
+      }).strict() : z8.object({ objectId: id, expectedRevision: revision }).strict(),
+      (i, c) => {
+        assets.assertWritable();
+        return data.documents(action, i, c);
+      },
+      ["write"]
+    );
+  ctx.handle(generationSubmitOperation, (i, c) => generation.submit(i, bindCall(c)));
+  handle(
+    "tasks.list",
+    z8.object({
+      targetAssetId: id.optional(),
+      limit: z8.number().int().min(1).max(200).optional(),
+      offset: z8.number().int().nonnegative().optional()
+    }).strict(),
+    (i) => {
+      const page = data.list({ typeId: "studio.task", ...i });
+      return { ...page, items: page.items.map(taskProjection) };
+    }
+  );
+  handle("tasks.get", z8.object({ taskId: id }).strict(), (i) => {
+    const t = data.get(i.taskId);
+    if (t.typeId !== "studio.task") reject("TYPE_MISMATCH", "Expected a task.");
+    return taskProjection(t);
+  });
+  handle(
+    "tasks.rename",
+    z8.object({ taskId: id, expectedRevision: revision, name: z8.string().trim().min(1).max(200) }).strict(),
+    (input, call) => data.operation("tasks.rename", input, call, (tx) => {
+      const task = runner.task(input.taskId);
+      return tx.update(task.objectId, input.expectedRevision, { ...task.data, name: input.name });
+    }),
+    ["write"]
+  );
+  handle(
+    "tasks.queryOriginal",
+    z8.object({ taskId: id }).strict(),
+    (i) => runner.queryOriginal(i.taskId)
+  );
+  handle(
+    "tasks.retryDownload",
+    z8.object({ taskId: id }).strict(),
+    (i) => runner.retryDownload(i.taskId),
+    ["write"]
+  );
+  handle("tasks.cancel", z8.object({ taskId: id }).strict(), (i) => runner.cancel(i.taskId), [
+    "write"
+  ]);
+  handle("assets.cleanupImpact", z8.object({ assetId: id }).strict(), (i) => data.impact(i.assetId));
+  handle(
+    "assets.purge",
+    base,
+    (i, c) => {
+      assets.assertWritable();
+      const result2 = data.purge(i.assetId, i.expectedRevision, c);
+      assets.removeUsages(i.assetId, c);
+      return result2;
+    },
+    ["write"],
+    "user"
+  );
+  handle(
+    "assets.batchLocations",
+    z8.object({ refs: z8.array(versionRef).max(100) }).strict(),
+    (i) => Promise.all(
+      i.refs.map(async (ref) => {
+        try {
+          return { ref, ok: true, result: await data.location(ref) };
+        } catch (e) {
+          return { ref, ok: false, error: errorValue(e) };
+        }
+      })
+    )
+  );
+  ctx.provide({
+    role: "project",
+    assets,
+    generation,
+    runner,
+    data,
+    ads,
+    derivedVideos: new DerivedVideos(
+      assets,
+      ctx.plugins.get(ctx.config.dataInstance)
+    )
+  });
+  await start();
+}
+export {
+  Config2 as Config,
+  activate as default,
+  dependencies
+};