@happyvertical/smrt-video 0.30.0

package/dist/index.js

@@ -0,0 +1,1898 @@
+import { ObjectRegistry, crossPackageRef, smrt, SmrtObject, foreignKey, SmrtCollection, field, SmrtJunction } from "@happyvertical/smrt-core";
+import { withSystemContext, tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+import { AssetCollection, Asset } from "@happyvertical/smrt-assets";
+import { persistMediaBundleInspection } from "@happyvertical/smrt-assets";
+import { Content } from "@happyvertical/smrt-content";
+import { createLogger } from "@happyvertical/logger";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+const VIDEO_ASSET_ROLE_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
+const VIDEO_ASSET_OWNER_COLUMNS = [
+  "character_id",
+  "performer_id",
+  "scene_id",
+  "video_shot_id",
+  "video_sequence_id",
+  "video_composition_id"
+];
+function getQueryRows(result) {
+  if (Array.isArray(result)) {
+    return result;
+  }
+  if (Array.isArray(result?.rows)) {
+    return result.rows;
+  }
+  return [];
+}
+function isMissingSchemaError(error, target) {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  const isMissing = message.includes("no such table") || message.includes("no such column") || message.includes("does not exist") || message.includes("unknown column");
+  if (!isMissing) {
+    return false;
+  }
+  return !target || message.includes(target.toLowerCase());
+}
+function buildPlaceholders(count) {
+  return Array.from({ length: count }, () => "?").join(", ");
+}
+function uniqueAssetIds(assetIds) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const assetId of assetIds) {
+    if (!assetId || seen.has(assetId)) {
+      continue;
+    }
+    seen.add(assetId);
+    result.push(assetId);
+  }
+  return result;
+}
+function mergeOwnedAssetIds(...groups) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const group of groups) {
+    for (const assetId of group) {
+      if (!assetId || seen.has(assetId)) {
+        continue;
+      }
+      seen.add(assetId);
+      merged.push(assetId);
+    }
+  }
+  return merged;
+}
+function assertValidVideoAssetRole(role) {
+  if (!VIDEO_ASSET_ROLE_PATTERN.test(role)) {
+    throw new Error(
+      `Invalid asset role "${role}"; must start with a letter or underscore and contain only letters, digits, underscores, and hyphens`
+    );
+  }
+}
+function assertValidVideoAssetSortOrder(sortOrder) {
+  if (!Number.isInteger(sortOrder) || sortOrder < 0 || sortOrder > 2147483647) {
+    throw new Error(
+      `Invalid sortOrder "${sortOrder}"; must be a non-negative integer`
+    );
+  }
+}
+async function resolveOwnedAssets(db, tenantId2, assetIds) {
+  const orderedIds = uniqueAssetIds(assetIds);
+  if (orderedIds.length === 0) {
+    return [];
+  }
+  const assets = await AssetCollection.create({ db });
+  let resolved;
+  try {
+    resolved = tenantId2 ? await withSystemContext(async () => assets.listByIds(orderedIds)) : await assets.listByIds(orderedIds);
+  } catch (error) {
+    if (isMissingSchemaError(error, "assets")) {
+      return [];
+    }
+    throw error;
+  }
+  const visibleAssets = tenantId2 ? resolved.filter(
+    (asset) => asset.tenantId === tenantId2 || asset.tenantId === null
+  ) : resolved;
+  const assetsById = new Map(
+    visibleAssets.filter((asset) => asset.id).map((asset) => [asset.id, asset])
+  );
+  return orderedIds.map((assetId) => assetsById.get(assetId)).filter(Boolean);
+}
+async function listCanonicalOwnedAssetIds(options) {
+  try {
+    return uniqueAssetIds(
+      (await options.loadLinks()).map((link) => link.assetId)
+    );
+  } catch (error) {
+    if (isMissingSchemaError(error, options.tableName)) {
+      return [];
+    }
+    throw error;
+  }
+}
+async function listLegacyOwnedAssetIds(options) {
+  const { db, ownerColumn, ownerId, role, metaTypes } = options;
+  if (!ownerId || metaTypes.length === 0) {
+    return [];
+  }
+  if (!VIDEO_ASSET_OWNER_COLUMNS.includes(ownerColumn)) {
+    throw new Error(`Unsupported video asset owner column "${ownerColumn}"`);
+  }
+  const params = [ownerId, ...metaTypes];
+  const clauses = [
+    `${ownerColumn} = ?`,
+    `_meta_type IN (${buildPlaceholders(metaTypes.length)})`
+  ];
+  if (role) {
+    clauses.push("role = ?");
+    params.push(role);
+  }
+  try {
+    const result = await db.query(
+      `SELECT id
+         FROM assets
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY created_at ASC, id ASC`,
+      ...params
+    );
+    return uniqueAssetIds(
+      getQueryRows(result).map((row) => String(row?.id || ""))
+    );
+  } catch (error) {
+    if (isMissingSchemaError(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+function legacyVideoAssetMetaTypes(className) {
+  return [className, `@happyvertical/smrt-video:${className}`];
+}
+var __defProp$j = Object.defineProperty;
+var __getOwnPropDesc$k = Object.getOwnPropertyDescriptor;
+var __decorateClass$k = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$k(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$j(target, key, result);
+  return result;
+};
+let Performer = class extends SmrtObject {
+  tenantId = null;
+  /** Human-readable name */
+  name = "";
+  /** Description */
+  description = null;
+  /** Performer DNA for consistent face generation */
+  dna = {
+    gender: "neutral",
+    ageRange: "adult",
+    ipAdapterWeight: 0.7
+  };
+  /** Reference images for IP-Adapter (multiple angles/expressions) */
+  referenceAssetIds = [];
+  seedImageAssetId = null;
+  voiceProfileId = null;
+  /** Performer status */
+  status = "pending";
+  profileId = null;
+  constructor(options = {}) {
+    super(options);
+    if (options.name !== void 0) this.name = options.name;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.dna !== void 0) this.dna = options.dna;
+    if (options.referenceAssetIds !== void 0)
+      this.referenceAssetIds = options.referenceAssetIds;
+    if (options.seedImageAssetId !== void 0)
+      this.seedImageAssetId = options.seedImageAssetId;
+    if (options.voiceProfileId !== void 0)
+      this.voiceProfileId = options.voiceProfileId;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.profileId !== void 0) this.profileId = options.profileId;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+  async getPerformerAssetCollection() {
+    const { PerformerOwnedAssetCollection: PerformerOwnedAssetCollection2 } = await Promise.resolve().then(() => performerAssets);
+    return PerformerOwnedAssetCollection2.create({ db: this.db });
+  }
+  getLegacyFieldAssetIds(role) {
+    if (role === "reference") {
+      return this.referenceAssetIds;
+    }
+    if (role === "seed") {
+      return this.seedImageAssetId ? [this.seedImageAssetId] : [];
+    }
+    return [...this.referenceAssetIds, this.seedImageAssetId].filter(
+      (assetId) => Boolean(assetId)
+    );
+  }
+  setLegacyFieldAssetId(role, assetId) {
+    if (role === "seed") {
+      if (this.seedImageAssetId === assetId) {
+        return false;
+      }
+      this.seedImageAssetId = assetId;
+      return true;
+    }
+    if (this.referenceAssetIds.includes(assetId)) {
+      return false;
+    }
+    this.referenceAssetIds = [...this.referenceAssetIds, assetId];
+    return true;
+  }
+  clearLegacyFieldAssetId(assetId, role) {
+    let changed = false;
+    if ((!role || role === "seed") && this.seedImageAssetId === assetId) {
+      this.seedImageAssetId = null;
+      changed = true;
+    }
+    if (!role || role === "reference") {
+      const remaining = this.referenceAssetIds.filter(
+        (referenceAssetId) => referenceAssetId !== assetId
+      );
+      if (remaining.length !== this.referenceAssetIds.length) {
+        this.referenceAssetIds = remaining;
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  async getAssets(role) {
+    const canonicalAssetIds = this.id ? await listCanonicalOwnedAssetIds({
+      tableName: "performer_assets",
+      loadLinks: async () => (await this.getPerformerAssetCollection()).byLeft(
+        this.id,
+        role ? { role } : {}
+      )
+    }) : [];
+    const legacyFieldAssetIds = this.getLegacyFieldAssetIds(role);
+    const legacyOwnedAssetIds = this.id ? await listLegacyOwnedAssetIds({
+      db: this.db,
+      ownerColumn: "performer_id",
+      ownerId: this.id,
+      role,
+      metaTypes: legacyVideoAssetMetaTypes("PerformerAsset")
+    }) : [];
+    return resolveOwnedAssets(
+      this.db,
+      this.tenantId,
+      mergeOwnedAssetIds(
+        canonicalAssetIds,
+        legacyFieldAssetIds,
+        legacyOwnedAssetIds
+      )
+    );
+  }
+  async getAssetByRole(role) {
+    const assets = await this.getAssets(role);
+    return assets[0] || null;
+  }
+  async addAsset(asset, role = "reference", sortOrder = 0) {
+    if (!this.id || !asset.id) {
+      throw new Error("Cannot associate unsaved performer or asset");
+    }
+    assertValidVideoAssetRole(role);
+    assertValidVideoAssetSortOrder(sortOrder);
+    const performerAssets2 = await this.getPerformerAssetCollection();
+    await performerAssets2.attach(this.id, asset.id, {
+      role,
+      sortOrder,
+      tenantId: this.tenantId
+    });
+    if (this.setLegacyFieldAssetId(role, asset.id)) {
+      await this.save();
+    }
+  }
+  async removeAsset(assetId, role) {
+    if (!this.id) {
+      return;
+    }
+    const performerAssets2 = await this.getPerformerAssetCollection();
+    await performerAssets2.detach(this.id, assetId, role ? { role } : {});
+    if (this.clearLegacyFieldAssetId(assetId, role)) {
+      await this.save();
+    }
+  }
+  /** Check if the performer has reference images */
+  get hasReferences() {
+    return this.referenceAssetIds.length > 0;
+  }
+  /** Check if the performer has a face embedding */
+  get hasFaceEmbedding() {
+    return Array.isArray(this.dna.faceEmbedding) && this.dna.faceEmbedding.length > 0;
+  }
+  /** Check if the performer is ready for generation */
+  get isReady() {
+    return this.status === "ready" && this.hasReferences;
+  }
+};
+__decorateClass$k([
+  tenantId({ nullable: true })
+], Performer.prototype, "tenantId", 2);
+__decorateClass$k([
+  crossPackageRef("@happyvertical/smrt-assets:Asset")
+], Performer.prototype, "seedImageAssetId", 2);
+__decorateClass$k([
+  crossPackageRef("@happyvertical/smrt-voice:VoiceProfile")
+], Performer.prototype, "voiceProfileId", 2);
+__decorateClass$k([
+  crossPackageRef("@happyvertical/smrt-profiles:Profile")
+], Performer.prototype, "profileId", 2);
+Performer = __decorateClass$k([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], Performer);
+var __defProp$i = Object.defineProperty;
+var __getOwnPropDesc$j = Object.getOwnPropertyDescriptor;
+var __decorateClass$j = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$j(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$i(target, key, result);
+  return result;
+};
+let Scene = class extends SmrtObject {
+  tenantId = null;
+  /** Human-readable name */
+  name = "";
+  /** Description */
+  description = null;
+  sourceAssetId = null;
+  /** Type of source media */
+  sourceType = "image";
+  /** Projection type for panoramas */
+  projection = null;
+  /** Extracted camera angles from 360° panoramas */
+  viewpoints = [];
+  /** Lighting analysis for IC-Light matching */
+  lightingProfile = null;
+  /** Location metadata */
+  location = null;
+  /** Anchor points for character placement */
+  anchorPoints = [];
+  /** Scene status */
+  status = "pending";
+  constructor(options = {}) {
+    super(options);
+    if (options.name !== void 0) this.name = options.name;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.sourceAssetId !== void 0)
+      this.sourceAssetId = options.sourceAssetId;
+    if (options.sourceType !== void 0) this.sourceType = options.sourceType;
+    if (options.projection !== void 0) this.projection = options.projection;
+    if (options.viewpoints !== void 0) this.viewpoints = options.viewpoints;
+    if (options.lightingProfile !== void 0)
+      this.lightingProfile = options.lightingProfile;
+    if (options.location !== void 0) this.location = options.location;
+    if (options.anchorPoints !== void 0)
+      this.anchorPoints = options.anchorPoints;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+  async getSceneAssetCollection() {
+    const { SceneOwnedAssetCollection: SceneOwnedAssetCollection2 } = await Promise.resolve().then(() => sceneAssets);
+    return SceneOwnedAssetCollection2.create({ db: this.db });
+  }
+  getLegacyFieldAssetIds(role) {
+    if (role === "source") {
+      return this.sourceAssetId ? [this.sourceAssetId] : [];
+    }
+    if (role === "env-map") {
+      return this.lightingProfile?.envMapAssetId ? [this.lightingProfile.envMapAssetId] : [];
+    }
+    if (role === "viewpoint-extract") {
+      return this.viewpoints.map((viewpoint) => viewpoint.extractedAssetId || null).filter((assetId) => Boolean(assetId));
+    }
+    return [
+      this.sourceAssetId,
+      this.lightingProfile?.envMapAssetId || null,
+      ...this.viewpoints.map((viewpoint) => viewpoint.extractedAssetId || null)
+    ].filter((assetId) => Boolean(assetId));
+  }
+  setLegacyFieldAssetId(role, assetId) {
+    if (role === "source") {
+      if (this.sourceAssetId === assetId) {
+        return false;
+      }
+      this.sourceAssetId = assetId;
+      return true;
+    }
+    if (role === "env-map") {
+      if ((this.lightingProfile?.envMapAssetId || null) === assetId) {
+        return false;
+      }
+      this.lightingProfile = {
+        ...this.lightingProfile || {},
+        envMapAssetId: assetId
+      };
+      return true;
+    }
+    return false;
+  }
+  clearLegacyFieldAssetId(assetId, role) {
+    let changed = false;
+    if ((!role || role === "source") && this.sourceAssetId === assetId) {
+      this.sourceAssetId = null;
+      changed = true;
+    }
+    if ((!role || role === "env-map") && this.lightingProfile?.envMapAssetId === assetId) {
+      this.lightingProfile = {
+        ...this.lightingProfile || {},
+        envMapAssetId: void 0
+      };
+      changed = true;
+    }
+    if (!role || role === "viewpoint-extract") {
+      let viewpointChanged = false;
+      const nextViewpoints = this.viewpoints.map((viewpoint) => {
+        if (viewpoint.extractedAssetId !== assetId) {
+          return viewpoint;
+        }
+        viewpointChanged = true;
+        return {
+          ...viewpoint,
+          extractedAssetId: void 0
+        };
+      });
+      if (viewpointChanged) {
+        this.viewpoints = nextViewpoints;
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  async getAssets(role) {
+    const canonicalAssetIds = this.id ? await listCanonicalOwnedAssetIds({
+      tableName: "scene_assets",
+      loadLinks: async () => (await this.getSceneAssetCollection()).byLeft(
+        this.id,
+        role ? { role } : {}
+      )
+    }) : [];
+    const legacyFieldAssetIds = this.getLegacyFieldAssetIds(role);
+    const legacyOwnedAssetIds = this.id ? await listLegacyOwnedAssetIds({
+      db: this.db,
+      ownerColumn: "scene_id",
+      ownerId: this.id,
+      role,
+      metaTypes: legacyVideoAssetMetaTypes("SceneAsset")
+    }) : [];
+    return resolveOwnedAssets(
+      this.db,
+      this.tenantId,
+      mergeOwnedAssetIds(
+        canonicalAssetIds,
+        legacyFieldAssetIds,
+        legacyOwnedAssetIds
+      )
+    );
+  }
+  async getAssetByRole(role) {
+    const assets = await this.getAssets(role);
+    return assets[0] || null;
+  }
+  async addAsset(asset, role = "source", sortOrder = 0) {
+    if (!this.id || !asset.id) {
+      throw new Error("Cannot associate unsaved scene or asset");
+    }
+    assertValidVideoAssetRole(role);
+    assertValidVideoAssetSortOrder(sortOrder);
+    const sceneAssets2 = await this.getSceneAssetCollection();
+    await sceneAssets2.attach(this.id, asset.id, {
+      role,
+      sortOrder,
+      tenantId: this.tenantId
+    });
+    if (this.setLegacyFieldAssetId(role, asset.id)) {
+      await this.save();
+    }
+  }
+  async removeAsset(assetId, role) {
+    if (!this.id) {
+      return;
+    }
+    const sceneAssets2 = await this.getSceneAssetCollection();
+    await sceneAssets2.detach(this.id, assetId, role ? { role } : {});
+    if (this.clearLegacyFieldAssetId(assetId, role)) {
+      await this.save();
+    }
+  }
+  /** Check if this is a 360° panorama */
+  get isPanorama() {
+    return this.sourceType === "panorama_360" || this.sourceType === "panorama_180";
+  }
+  /** Check if the scene has viewpoints extracted */
+  get hasViewpoints() {
+    return this.viewpoints.length > 0;
+  }
+  /** Check if the scene is ready for compositing */
+  get isReady() {
+    return this.status === "ready" && this.sourceAssetId !== null;
+  }
+};
+__decorateClass$j([
+  tenantId({ nullable: true })
+], Scene.prototype, "tenantId", 2);
+__decorateClass$j([
+  crossPackageRef("@happyvertical/smrt-assets:Asset")
+], Scene.prototype, "sourceAssetId", 2);
+Scene = __decorateClass$j([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], Scene);
+var __defProp$h = Object.defineProperty;
+var __getOwnPropDesc$i = Object.getOwnPropertyDescriptor;
+var __decorateClass$i = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$i(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$h(target, key, result);
+  return result;
+};
+let Character = class extends SmrtObject {
+  tenantId = null;
+  /** Human-readable name for the character */
+  name = "";
+  /** Description of the character persona */
+  description = null;
+  imageAssetId = null;
+  baseMotionAssetId = null;
+  voiceProfileId = null;
+  /** Branding configuration for video overlays */
+  brandingKit = {};
+  /** Character status */
+  status = "pending";
+  performerId = null;
+  defaultSceneId = null;
+  /** Scene-specific configurations */
+  sceneConfigs = [];
+  profileId = null;
+  constructor(options = {}) {
+    super(options);
+    if (options.name !== void 0) this.name = options.name;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.imageAssetId !== void 0)
+      this.imageAssetId = options.imageAssetId;
+    if (options.baseMotionAssetId !== void 0)
+      this.baseMotionAssetId = options.baseMotionAssetId;
+    if (options.voiceProfileId !== void 0)
+      this.voiceProfileId = options.voiceProfileId;
+    if (options.brandingKit !== void 0)
+      this.brandingKit = options.brandingKit;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.performerId !== void 0)
+      this.performerId = options.performerId;
+    if (options.defaultSceneId !== void 0)
+      this.defaultSceneId = options.defaultSceneId;
+    if (options.sceneConfigs !== void 0)
+      this.sceneConfigs = options.sceneConfigs;
+    if (options.profileId !== void 0) this.profileId = options.profileId;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+  async getCharacterAssetCollection() {
+    const { CharacterOwnedAssetCollection: CharacterOwnedAssetCollection2 } = await Promise.resolve().then(() => characterAssets);
+    return CharacterOwnedAssetCollection2.create({ db: this.db });
+  }
+  getLegacyFieldAssetIds(role) {
+    if (role === "seed-image") {
+      return this.imageAssetId ? [this.imageAssetId] : [];
+    }
+    if (role === "base-motion") {
+      return this.baseMotionAssetId ? [this.baseMotionAssetId] : [];
+    }
+    if (role === "logo") {
+      return this.brandingKit.logoAssetId ? [this.brandingKit.logoAssetId] : [];
+    }
+    return [
+      this.imageAssetId,
+      this.baseMotionAssetId,
+      this.brandingKit.logoAssetId || null
+    ].filter((assetId) => Boolean(assetId));
+  }
+  setLegacyFieldAssetId(role, assetId) {
+    if (role === "seed-image") {
+      if (this.imageAssetId === assetId) {
+        return false;
+      }
+      this.imageAssetId = assetId;
+      return true;
+    }
+    if (role === "base-motion") {
+      if (this.baseMotionAssetId === assetId) {
+        return false;
+      }
+      this.baseMotionAssetId = assetId;
+      return true;
+    }
+    if ((this.brandingKit.logoAssetId || null) === assetId) {
+      return false;
+    }
+    this.brandingKit = {
+      ...this.brandingKit,
+      logoAssetId: assetId
+    };
+    return true;
+  }
+  clearLegacyFieldAssetId(assetId, role) {
+    let changed = false;
+    if ((!role || role === "seed-image") && this.imageAssetId === assetId) {
+      this.imageAssetId = null;
+      changed = true;
+    }
+    if ((!role || role === "base-motion") && this.baseMotionAssetId === assetId) {
+      this.baseMotionAssetId = null;
+      changed = true;
+    }
+    if ((!role || role === "logo") && this.brandingKit.logoAssetId === assetId) {
+      this.brandingKit = {
+        ...this.brandingKit,
+        logoAssetId: null
+      };
+      changed = true;
+    }
+    return changed;
+  }
+  async getAssets(role) {
+    const canonicalAssetIds = this.id ? await listCanonicalOwnedAssetIds({
+      tableName: "character_assets",
+      loadLinks: async () => (await this.getCharacterAssetCollection()).byLeft(
+        this.id,
+        role ? { role } : {}
+      )
+    }) : [];
+    const legacyFieldAssetIds = this.getLegacyFieldAssetIds(role);
+    const legacyOwnedAssetIds = this.id ? await listLegacyOwnedAssetIds({
+      db: this.db,
+      ownerColumn: "character_id",
+      ownerId: this.id,
+      role,
+      metaTypes: legacyVideoAssetMetaTypes("CharacterAsset")
+    }) : [];
+    return resolveOwnedAssets(
+      this.db,
+      this.tenantId,
+      mergeOwnedAssetIds(
+        canonicalAssetIds,
+        legacyFieldAssetIds,
+        legacyOwnedAssetIds
+      )
+    );
+  }
+  async getAssetByRole(role) {
+    const assets = await this.getAssets(role);
+    return assets[0] || null;
+  }
+  async addAsset(asset, role = "seed-image", sortOrder = 0) {
+    if (!this.id || !asset.id) {
+      throw new Error("Cannot associate unsaved character or asset");
+    }
+    assertValidVideoAssetRole(role);
+    assertValidVideoAssetSortOrder(sortOrder);
+    const characterAssets2 = await this.getCharacterAssetCollection();
+    await characterAssets2.attach(this.id, asset.id, {
+      role,
+      sortOrder,
+      tenantId: this.tenantId
+    });
+    if (this.setLegacyFieldAssetId(role, asset.id)) {
+      await this.save();
+    }
+  }
+  async removeAsset(assetId, role) {
+    if (!this.id) {
+      return;
+    }
+    const characterAssets2 = await this.getCharacterAssetCollection();
+    await characterAssets2.detach(this.id, assetId, role ? { role } : {});
+    if (this.clearLegacyFieldAssetId(assetId, role)) {
+      await this.save();
+    }
+  }
+  /**
+   * Check if the character has a pre-baked base motion video
+   * @deprecated Use getAssetByRole('base-motion') instead
+   */
+  get hasBaseMotion() {
+    return this.baseMotionAssetId !== null;
+  }
+  /** Check if the character is complete and ready for video generation */
+  get isComplete() {
+    return this.imageAssetId !== null && this.voiceProfileId !== null && this.status === "ready";
+  }
+};
+__decorateClass$i([
+  tenantId({ nullable: true })
+], Character.prototype, "tenantId", 2);
+__decorateClass$i([
+  crossPackageRef("@happyvertical/smrt-assets:Asset")
+], Character.prototype, "imageAssetId", 2);
+__decorateClass$i([
+  crossPackageRef("@happyvertical/smrt-assets:Asset")
+], Character.prototype, "baseMotionAssetId", 2);
+__decorateClass$i([
+  crossPackageRef("@happyvertical/smrt-voice:VoiceProfile")
+], Character.prototype, "voiceProfileId", 2);
+__decorateClass$i([
+  foreignKey(() => Performer)
+], Character.prototype, "performerId", 2);
+__decorateClass$i([
+  foreignKey(() => Scene)
+], Character.prototype, "defaultSceneId", 2);
+__decorateClass$i([
+  crossPackageRef("@happyvertical/smrt-profiles:Profile")
+], Character.prototype, "profileId", 2);
+Character = __decorateClass$i([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], Character);
+class CharacterCollection extends SmrtCollection {
+  static _itemClass = Character;
+  /** Find all characters belonging to a specific tenant */
+  async findByTenant(tenantId2) {
+    return await this.list({ where: { tenantId: tenantId2 } });
+  }
+  /** Find all global characters (without a tenant) */
+  async findGlobal() {
+    return await this.list({ where: { tenantId: null } });
+  }
+  /** Find characters by performer */
+  async findByPerformer(performerId) {
+    return await this.list({ where: { performerId } });
+  }
+  /** Find characters that are ready for video generation */
+  async findReady() {
+    return await this.list({ where: { status: "ready" } });
+  }
+}
+var __defProp$g = Object.defineProperty;
+var __getOwnPropDesc$h = Object.getOwnPropertyDescriptor;
+var __decorateClass$h = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$h(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$g(target, key, result);
+  return result;
+};
+let CompositeJob = class extends SmrtObject {
+  tenantId = null;
+  characterVideoAssetId = null;
+  sceneId = null;
+  /** Viewpoint ID (for 360° scenes) */
+  viewpointId = null;
+  /** Anchor point ID for placement */
+  anchorPointId = null;
+  /** Character scale */
+  scale = 1;
+  /** Character position (normalized 0-1) */
+  position = { x: 0.5, y: 0.5 };
+  /** Job status */
+  status = "pending";
+  /** Progress percentage (0-100) */
+  progress = 0;
+  outputAssetId = null;
+  /** Error message if failed */
+  errorMessage = null;
+  constructor(options = {}) {
+    super(options);
+    if (options.characterVideoAssetId !== void 0)
+      this.characterVideoAssetId = options.characterVideoAssetId;
+    if (options.sceneId !== void 0) this.sceneId = options.sceneId;
+    if (options.viewpointId !== void 0)
+      this.viewpointId = options.viewpointId;
+    if (options.anchorPointId !== void 0)
+      this.anchorPointId = options.anchorPointId;
+    if (options.scale !== void 0) this.scale = options.scale;
+    if (options.position !== void 0) this.position = options.position;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.progress !== void 0) this.progress = options.progress;
+    if (options.outputAssetId !== void 0)
+      this.outputAssetId = options.outputAssetId;
+    if (options.errorMessage !== void 0)
+      this.errorMessage = options.errorMessage;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+  /** Check if the job is complete */
+  get isComplete() {
+    return this.status === "complete" && this.outputAssetId !== null;
+  }
+  /** Check if the job is in progress */
+  get isProcessing() {
+    return this.status !== "pending" && this.status !== "complete" && this.status !== "failed";
+  }
+};
+__decorateClass$h([
+  tenantId({ nullable: true })
+], CompositeJob.prototype, "tenantId", 2);
+__decorateClass$h([
+  crossPackageRef("@happyvertical/smrt-assets:Asset")
+], CompositeJob.prototype, "characterVideoAssetId", 2);
+__decorateClass$h([
+  foreignKey(() => Scene)
+], CompositeJob.prototype, "sceneId", 2);
+__decorateClass$h([
+  crossPackageRef("@happyvertical/smrt-assets:Asset")
+], CompositeJob.prototype, "outputAssetId", 2);
+CompositeJob = __decorateClass$h([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], CompositeJob);
+var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
+var __decorateClass$g = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$g(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+let VideoComposition = class extends Content {
+  /** Frames per second — everything downstream is in frames */
+  fps = 30;
+  /** Render width in pixels */
+  width = 1920;
+  /** Render height in pixels */
+  height = 1080;
+  /** Computed total: sum of sequences minus transition overlaps */
+  durationInFrames = 0;
+  /** Render status */
+  renderStatus = "draft";
+  /** Render progress (0-100) */
+  renderProgress = 0;
+  constructor(options = {}) {
+    super({
+      ...options,
+      type: "video-composition"
+    });
+    if (options.fps !== void 0) this.fps = options.fps;
+    if (options.width !== void 0) this.width = options.width;
+    if (options.height !== void 0) this.height = options.height;
+    if (options.durationInFrames !== void 0)
+      this.durationInFrames = options.durationInFrames;
+    if (options.renderStatus !== void 0)
+      this.renderStatus = options.renderStatus;
+    if (options.renderProgress !== void 0)
+      this.renderProgress = options.renderProgress;
+  }
+  /** Duration in seconds */
+  get durationInSeconds() {
+    if (this.fps === 0) return 0;
+    return this.durationInFrames / this.fps;
+  }
+  /** Check if the composition is ready for publishing */
+  get isReady() {
+    return this.renderStatus === "ready";
+  }
+  /** Check if the composition is currently rendering */
+  get isRendering() {
+    return this.renderStatus === "rendering";
+  }
+  async getAssets(relationship) {
+    const canonicalAssets = await super.getAssets(relationship);
+    if (!this.id) {
+      return canonicalAssets;
+    }
+    const role = relationship;
+    const legacyAssets = await resolveOwnedAssets(
+      this.db,
+      this.tenantId,
+      await listLegacyOwnedAssetIds({
+        db: this.db,
+        ownerColumn: "video_composition_id",
+        ownerId: this.id,
+        role,
+        metaTypes: legacyVideoAssetMetaTypes("VideoCompositionAsset")
+      })
+    );
+    return [
+      ...canonicalAssets,
+      ...legacyAssets.filter(
+        (asset) => asset.id && !canonicalAssets.some(
+          (canonicalAsset) => canonicalAsset.id === asset.id
+        )
+      )
+    ];
+  }
+  async getAssetByRole(role) {
+    const assets = await this.getAssets(role);
+    return assets[0] || null;
+  }
+};
+VideoComposition = __decorateClass$g([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], VideoComposition);
+class VideoCompositionCollection extends SmrtCollection {
+  static _itemClass = VideoComposition;
+  /** Find compositions by render status */
+  async findByRenderStatus(renderStatus) {
+    return await this.list({
+      where: { renderStatus }
+    });
+  }
+  /** Find compositions that are ready for publishing */
+  async findReady() {
+    return await this.list({
+      where: { renderStatus: "ready" }
+    });
+  }
+}
+var __defProp$f = Object.defineProperty;
+var __getOwnPropDesc$f = Object.getOwnPropertyDescriptor;
+var __decorateClass$f = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$f(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$f(target, key, result);
+  return result;
+};
+let VideoSequence = class extends Content {
+  compositionId = null;
+  /** Order within composition */
+  position = 0;
+  /** Computed duration: sum of shot frames */
+  durationInFrames = 0;
+  /** Transition type to the next sequence */
+  transitionType = "none";
+  /** Overlap frames with next sequence for transition */
+  transitionDurationFrames = 0;
+  constructor(options = {}) {
+    super({
+      ...options,
+      type: "video-sequence"
+    });
+    if (options.compositionId !== void 0)
+      this.compositionId = options.compositionId;
+    if (options.position !== void 0) this.position = options.position;
+    if (options.durationInFrames !== void 0)
+      this.durationInFrames = options.durationInFrames;
+    if (options.transitionType !== void 0)
+      this.transitionType = options.transitionType;
+    if (options.transitionDurationFrames !== void 0)
+      this.transitionDurationFrames = options.transitionDurationFrames;
+  }
+  async getAssets(relationship) {
+    const canonicalAssets = await super.getAssets(relationship);
+    if (!this.id) {
+      return canonicalAssets;
+    }
+    const role = relationship;
+    const legacyAssets = await resolveOwnedAssets(
+      this.db,
+      this.tenantId,
+      await listLegacyOwnedAssetIds({
+        db: this.db,
+        ownerColumn: "video_sequence_id",
+        ownerId: this.id,
+        role,
+        metaTypes: legacyVideoAssetMetaTypes("VideoSequenceAsset")
+      })
+    );
+    return [
+      ...canonicalAssets,
+      ...legacyAssets.filter(
+        (asset) => asset.id && !canonicalAssets.some(
+          (canonicalAsset) => canonicalAsset.id === asset.id
+        )
+      )
+    ];
+  }
+  async getAssetByRole(role) {
+    const assets = await this.getAssets(role);
+    return assets[0] || null;
+  }
+};
+__decorateClass$f([
+  foreignKey("VideoComposition")
+], VideoSequence.prototype, "compositionId", 2);
+VideoSequence = __decorateClass$f([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], VideoSequence);
+class VideoSequenceCollection extends SmrtCollection {
+  static _itemClass = VideoSequence;
+  /** Find sequences belonging to a composition, ordered by position */
+  async findByComposition(compositionId) {
+    return await this.list({
+      where: { compositionId },
+      orderBy: "position ASC"
+    });
+  }
+  /** Find standalone sequences (not in any composition) */
+  async findStandalone() {
+    return await this.list({
+      where: { compositionId: null }
+    });
+  }
+}
+var __defProp$e = Object.defineProperty;
+var __getOwnPropDesc$e = Object.getOwnPropertyDescriptor;
+var __decorateClass$e = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$e(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$e(target, key, result);
+  return result;
+};
+let VideoShot = class extends Content {
+  sequenceId = null;
+  sceneId = null;
+  /** Order within sequence */
+  position = 0;
+  /** Actual frame count of generated clip */
+  durationInFrames = 0;
+  /** Frames to skip at start (overlap handling) */
+  trimBeforeFrames = 0;
+  /** Frames to skip at end */
+  trimAfterFrames = 0;
+  /** Script text to be spoken */
+  scriptText = "";
+  /** Word count in the script */
+  scriptWordCount = 0;
+  /** Target duration in seconds */
+  targetDuration = 30;
+  /** Video generation status */
+  shotStatus = "draft";
+  /** Generation progress (0-100) */
+  progress = 0;
+  /** Error message if status is 'failed' */
+  errorMessage = null;
+  /** Detailed status message for progress tracking */
+  statusMessage = null;
+  /** Video metadata (duration, resolution, etc.) */
+  videoMetadata = {};
+  constructor(options = {}) {
+    super({
+      ...options,
+      type: "video-shot"
+    });
+    if (options.sequenceId !== void 0) this.sequenceId = options.sequenceId;
+    if (options.sceneId !== void 0) this.sceneId = options.sceneId;
+    if (options.position !== void 0) this.position = options.position;
+    if (options.durationInFrames !== void 0)
+      this.durationInFrames = options.durationInFrames;
+    if (options.trimBeforeFrames !== void 0)
+      this.trimBeforeFrames = options.trimBeforeFrames;
+    if (options.trimAfterFrames !== void 0)
+      this.trimAfterFrames = options.trimAfterFrames;
+    if (options.scriptText !== void 0) {
+      this.scriptText = options.scriptText;
+      this.scriptWordCount = this.scriptText.split(/\s+/).filter(Boolean).length;
+    }
+    if (options.scriptWordCount !== void 0)
+      this.scriptWordCount = options.scriptWordCount;
+    if (options.targetDuration !== void 0)
+      this.targetDuration = options.targetDuration;
+    if (options.shotStatus !== void 0) this.shotStatus = options.shotStatus;
+    if (options.progress !== void 0) this.progress = options.progress;
+    if (options.errorMessage !== void 0)
+      this.errorMessage = options.errorMessage;
+    if (options.statusMessage !== void 0)
+      this.statusMessage = options.statusMessage;
+    if (options.videoMetadata !== void 0)
+      this.videoMetadata = options.videoMetadata;
+  }
+  /** Estimate speech duration based on word count (2.7 words/sec) */
+  get estimatedDuration() {
+    return this.scriptWordCount / 2.7;
+  }
+  /** Check if the script length matches target duration (+/- 15%) */
+  get isScriptLengthValid() {
+    const estimated = this.estimatedDuration;
+    const tolerance = this.targetDuration * 0.15;
+    return estimated >= this.targetDuration - tolerance && estimated <= this.targetDuration + tolerance;
+  }
+  /** Get the recommended word count for target duration */
+  get recommendedWordCount() {
+    const wordsPerSecond = 2.7;
+    const target = Math.round(this.targetDuration * wordsPerSecond);
+    const tolerance = Math.round(target * 0.15);
+    return {
+      min: target - tolerance,
+      max: target + tolerance,
+      target
+    };
+  }
+  /** Effective frame count after trimming */
+  get effectiveFrames() {
+    return Math.max(
+      0,
+      this.durationInFrames - this.trimBeforeFrames - this.trimAfterFrames
+    );
+  }
+  /** Check if video generation is in progress */
+  get isGenerating() {
+    return this.shotStatus === "queued" || this.shotStatus === "processing";
+  }
+  /** Check if video is ready for publishing */
+  get isReady() {
+    return this.shotStatus === "ready";
+  }
+  async getAssets(relationship) {
+    const canonicalAssets = await super.getAssets(relationship);
+    if (!this.id) {
+      return canonicalAssets;
+    }
+    const role = relationship;
+    const legacyAssets = await resolveOwnedAssets(
+      this.db,
+      this.tenantId,
+      await listLegacyOwnedAssetIds({
+        db: this.db,
+        ownerColumn: "video_shot_id",
+        ownerId: this.id,
+        role,
+        metaTypes: legacyVideoAssetMetaTypes("VideoShotAsset")
+      })
+    );
+    return [
+      ...canonicalAssets,
+      ...legacyAssets.filter(
+        (asset) => asset.id && !canonicalAssets.some(
+          (canonicalAsset) => canonicalAsset.id === asset.id
+        )
+      )
+    ];
+  }
+  async getAssetByRole(role) {
+    const assets = await this.getAssets(role);
+    return assets[0] || null;
+  }
+  /** Update script text and recalculate word count */
+  setScript(text) {
+    this.scriptText = text;
+    this.scriptWordCount = text.split(/\s+/).filter(Boolean).length;
+  }
+};
+__decorateClass$e([
+  foreignKey(() => VideoSequence)
+], VideoShot.prototype, "sequenceId", 2);
+__decorateClass$e([
+  foreignKey(() => Scene)
+], VideoShot.prototype, "sceneId", 2);
+VideoShot = __decorateClass$e([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], VideoShot);
+var __defProp$d = Object.defineProperty;
+var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
+var __decorateClass$d = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$d(target, key, result);
+  return result;
+};
+let VideoShotCharacter = class extends SmrtObject {
+  tenantId = null;
+  videoShotId = "";
+  characterId = "";
+  /** Role of the character in this shot */
+  role = "primary";
+  /** Order/layer position within the shot */
+  position = 0;
+  constructor(options) {
+    super(options);
+    this.videoShotId = options.videoShotId;
+    this.characterId = options.characterId;
+    if (options.role !== void 0) this.role = options.role;
+    if (options.position !== void 0) this.position = options.position;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+};
+__decorateClass$d([
+  tenantId({ nullable: true })
+], VideoShotCharacter.prototype, "tenantId", 2);
+__decorateClass$d([
+  foreignKey(() => VideoShot, { required: true })
+], VideoShotCharacter.prototype, "videoShotId", 2);
+__decorateClass$d([
+  foreignKey(() => Character, { required: true })
+], VideoShotCharacter.prototype, "characterId", 2);
+VideoShotCharacter = __decorateClass$d([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], VideoShotCharacter);
+class VideoShotCharacterCollection extends SmrtCollection {
+  static _itemClass = VideoShotCharacter;
+  /** Find all character links for a shot, ordered by position */
+  async findByShot(videoShotId) {
+    return await this.list({
+      where: { videoShotId },
+      orderBy: "position ASC"
+    });
+  }
+  /** Find all shot links for a character */
+  async findByCharacter(characterId) {
+    return await this.list({
+      where: { characterId }
+    });
+  }
+}
+class VideoShotCollection extends SmrtCollection {
+  static _itemClass = VideoShot;
+  /** Find shots belonging to a specific sequence, ordered by position */
+  async findBySequence(sequenceId) {
+    return await this.list({
+      where: { sequenceId },
+      orderBy: "position ASC"
+    });
+  }
+  /** Find shots by status */
+  async findByStatus(shotStatus) {
+    return await this.list({ where: { shotStatus } });
+  }
+  /** Find standalone shots (not in any sequence) */
+  async findStandalone() {
+    return await this.list({ where: { sequenceId: null } });
+  }
+}
+var __defProp$c = Object.defineProperty;
+var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
+var __decorateClass$c = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$c(target, key, result);
+  return result;
+};
+const logger = createLogger({ level: "info" });
+let VideoWorkflow = class extends SmrtObject {
+  tenantId = null;
+  /**
+   * Human-readable name for the workflow
+   */
+  name = "";
+  /**
+   * Description of what this workflow does
+   */
+  description = null;
+  /**
+   * Workflow type classification
+   * - prebake: Pre-generate base motion from seed image
+   * - broadcast: Full video generation pipeline
+   * - lipsync: Lip-sync only (requires base video + audio)
+   * - postprod: Post-production overlays and effects
+   * - custom: User-defined workflow
+   */
+  workflowType = "custom";
+  /**
+   * ComfyUI API format JSON
+   * This is the workflow definition that will be sent to ComfyUI
+   */
+  workflowJson = null;
+  /**
+   * Node ID mappings for dynamic parameter injection
+   * Maps semantic names to ComfyUI node IDs
+   */
+  nodeMapping = {};
+  /**
+   * Estimated processing time in seconds
+   * Used for progress estimation
+   */
+  estimatedTime = 300;
+  /**
+   * Whether this workflow is active/usable
+   */
+  isActive = true;
+  /**
+   * ComfyUI models required by this workflow
+   * Used for validation before queuing
+   */
+  requiredModels = [];
+  constructor(options = {}) {
+    super(options);
+    if (options.name !== void 0) this.name = options.name;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.workflowType !== void 0)
+      this.workflowType = options.workflowType;
+    if (options.workflowJson !== void 0)
+      this.workflowJson = options.workflowJson;
+    if (options.nodeMapping !== void 0)
+      this.nodeMapping = options.nodeMapping;
+    if (options.estimatedTime !== void 0)
+      this.estimatedTime = options.estimatedTime;
+    if (options.isActive !== void 0) this.isActive = options.isActive;
+    if (options.requiredModels !== void 0)
+      this.requiredModels = options.requiredModels;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+  /**
+   * Check if the workflow has all required node mappings
+   */
+  get hasRequiredMappings() {
+    const required = ["outputVideo"];
+    return required.every((key) => this.nodeMapping[key] !== void 0);
+  }
+  /**
+   * Get a copy of the workflow JSON with injected parameters
+   *
+   * Parameter injection follows ComfyUI node structure conventions:
+   * - seedImage, audioFile, baseVideo → node.inputs.image (file path)
+   * - prompt → node.inputs.text (string)
+   * - Other parameters → node.inputs[paramKey]
+   *
+   * @param params - Key-value pairs of parameters to inject
+   * @returns Modified workflow JSON or null if no workflowJson set
+   */
+  injectParameters(params) {
+    if (!this.workflowJson) return null;
+    const workflow = JSON.parse(JSON.stringify(this.workflowJson));
+    const warnings = [];
+    for (const [paramKey, nodeId] of Object.entries(this.nodeMapping)) {
+      if (nodeId && params[paramKey] !== void 0) {
+        if (!workflow[nodeId]) {
+          warnings.push(
+            `Node mapping '${paramKey}' references node '${nodeId}' which does not exist in workflow`
+          );
+          continue;
+        }
+        workflow[nodeId].inputs = workflow[nodeId].inputs || {};
+        if (paramKey === "seedImage" || paramKey === "audioFile" || paramKey === "baseVideo") {
+          workflow[nodeId].inputs.image = params[paramKey];
+        } else if (paramKey === "prompt") {
+          workflow[nodeId].inputs.text = params[paramKey];
+        } else {
+          workflow[nodeId].inputs[paramKey] = params[paramKey];
+        }
+      }
+    }
+    if (warnings.length > 0 && process.env.NODE_ENV !== "production") {
+      logger.warn(
+        `[VideoWorkflow] Parameter injection warnings:
+${warnings.join("\n")}`
+      );
+    }
+    return workflow;
+  }
+};
+__decorateClass$c([
+  tenantId({ nullable: true })
+], VideoWorkflow.prototype, "tenantId", 2);
+VideoWorkflow = __decorateClass$c([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], VideoWorkflow);
+var __defProp$b = Object.defineProperty;
+var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
+var __decorateClass$b = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$b(target, key, result);
+  return result;
+};
+let CharacterAsset = class extends Asset {
+  characterId = null;
+  role = "seed-image";
+  constructor(options = {}) {
+    super(options);
+    if (options.characterId !== void 0)
+      this.characterId = options.characterId;
+    if (options.role !== void 0) this.role = options.role;
+  }
+};
+__decorateClass$b([
+  foreignKey(() => Character)
+], CharacterAsset.prototype, "characterId", 2);
+CharacterAsset = __decorateClass$b([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], CharacterAsset);
+var __defProp$a = Object.defineProperty;
+var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
+var __decorateClass$a = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$a(target, key, result);
+  return result;
+};
+let CharacterOwnedAsset = class extends SmrtObject {
+  tenantId = null;
+  characterId = "";
+  assetId = "";
+  role = "seed-image";
+  sortOrder = 0;
+  constructor(options = {}) {
+    super(options);
+    if (options.characterId) this.characterId = options.characterId;
+    if (options.assetId) this.assetId = options.assetId;
+    if (options.role !== void 0) this.role = options.role;
+    if (options.sortOrder !== void 0) this.sortOrder = options.sortOrder;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+};
+__decorateClass$a([
+  tenantId({ nullable: true })
+], CharacterOwnedAsset.prototype, "tenantId", 2);
+__decorateClass$a([
+  foreignKey(() => Character, { required: true })
+], CharacterOwnedAsset.prototype, "characterId", 2);
+__decorateClass$a([
+  crossPackageRef("@happyvertical/smrt-assets:Asset", { required: true })
+], CharacterOwnedAsset.prototype, "assetId", 2);
+__decorateClass$a([
+  field({ required: true })
+], CharacterOwnedAsset.prototype, "role", 2);
+__decorateClass$a([
+  field()
+], CharacterOwnedAsset.prototype, "sortOrder", 2);
+CharacterOwnedAsset = __decorateClass$a([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    name: "CharacterOwnedAsset",
+    tableName: "character_assets",
+    conflictColumns: ["character_id", "asset_id", "role"],
+    api: false,
+    mcp: false,
+    cli: false
+  })
+], CharacterOwnedAsset);
+var __defProp$9 = Object.defineProperty;
+var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$9 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, key + "", value);
+let CharacterOwnedAssetCollection = class extends SmrtJunction {
+  leftField = "characterId";
+  rightField = "assetId";
+};
+__publicField$2(CharacterOwnedAssetCollection, "_itemClass", CharacterOwnedAsset);
+CharacterOwnedAssetCollection = __decorateClass$9([
+  smrt({
+    api: false,
+    mcp: false,
+    cli: false
+  })
+], CharacterOwnedAssetCollection);
+const characterAssets = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get CharacterOwnedAssetCollection() {
+    return CharacterOwnedAssetCollection;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$8 = Object.defineProperty;
+var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
+var __decorateClass$8 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$8(target, key, result);
+  return result;
+};
+let PerformerAsset = class extends Asset {
+  performerId = null;
+  role = "reference";
+  constructor(options = {}) {
+    super(options);
+    if (options.performerId !== void 0)
+      this.performerId = options.performerId;
+    if (options.role !== void 0) this.role = options.role;
+  }
+};
+__decorateClass$8([
+  foreignKey(() => Performer)
+], PerformerAsset.prototype, "performerId", 2);
+PerformerAsset = __decorateClass$8([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], PerformerAsset);
+var __defProp$7 = Object.defineProperty;
+var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+var __decorateClass$7 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$7(target, key, result);
+  return result;
+};
+let PerformerOwnedAsset = class extends SmrtObject {
+  tenantId = null;
+  performerId = "";
+  assetId = "";
+  role = "reference";
+  sortOrder = 0;
+  constructor(options = {}) {
+    super(options);
+    if (options.performerId) this.performerId = options.performerId;
+    if (options.assetId) this.assetId = options.assetId;
+    if (options.role !== void 0) this.role = options.role;
+    if (options.sortOrder !== void 0) this.sortOrder = options.sortOrder;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+};
+__decorateClass$7([
+  tenantId({ nullable: true })
+], PerformerOwnedAsset.prototype, "tenantId", 2);
+__decorateClass$7([
+  foreignKey(() => Performer, { required: true })
+], PerformerOwnedAsset.prototype, "performerId", 2);
+__decorateClass$7([
+  crossPackageRef("@happyvertical/smrt-assets:Asset", { required: true })
+], PerformerOwnedAsset.prototype, "assetId", 2);
+__decorateClass$7([
+  field({ required: true })
+], PerformerOwnedAsset.prototype, "role", 2);
+__decorateClass$7([
+  field()
+], PerformerOwnedAsset.prototype, "sortOrder", 2);
+PerformerOwnedAsset = __decorateClass$7([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    name: "PerformerOwnedAsset",
+    tableName: "performer_assets",
+    conflictColumns: ["performer_id", "asset_id", "role"],
+    api: false,
+    mcp: false,
+    cli: false
+  })
+], PerformerOwnedAsset);
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "", value);
+let PerformerOwnedAssetCollection = class extends SmrtJunction {
+  leftField = "performerId";
+  rightField = "assetId";
+};
+__publicField$1(PerformerOwnedAssetCollection, "_itemClass", PerformerOwnedAsset);
+PerformerOwnedAssetCollection = __decorateClass$6([
+  smrt({
+    api: false,
+    mcp: false,
+    cli: false
+  })
+], PerformerOwnedAssetCollection);
+const performerAssets = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get PerformerOwnedAssetCollection() {
+    return PerformerOwnedAssetCollection;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$5(target, key, result);
+  return result;
+};
+let SceneAsset = class extends Asset {
+  sceneId = null;
+  role = "source";
+  constructor(options = {}) {
+    super(options);
+    if (options.sceneId !== void 0) this.sceneId = options.sceneId;
+    if (options.role !== void 0) this.role = options.role;
+  }
+};
+__decorateClass$5([
+  foreignKey(() => Scene)
+], SceneAsset.prototype, "sceneId", 2);
+SceneAsset = __decorateClass$5([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], SceneAsset);
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$4(target, key, result);
+  return result;
+};
+let SceneOwnedAsset = class extends SmrtObject {
+  tenantId = null;
+  sceneId = "";
+  assetId = "";
+  role = "source";
+  sortOrder = 0;
+  constructor(options = {}) {
+    super(options);
+    if (options.sceneId) this.sceneId = options.sceneId;
+    if (options.assetId) this.assetId = options.assetId;
+    if (options.role !== void 0) this.role = options.role;
+    if (options.sortOrder !== void 0) this.sortOrder = options.sortOrder;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+};
+__decorateClass$4([
+  tenantId({ nullable: true })
+], SceneOwnedAsset.prototype, "tenantId", 2);
+__decorateClass$4([
+  foreignKey(() => Scene, { required: true })
+], SceneOwnedAsset.prototype, "sceneId", 2);
+__decorateClass$4([
+  crossPackageRef("@happyvertical/smrt-assets:Asset", { required: true })
+], SceneOwnedAsset.prototype, "assetId", 2);
+__decorateClass$4([
+  field({ required: true })
+], SceneOwnedAsset.prototype, "role", 2);
+__decorateClass$4([
+  field()
+], SceneOwnedAsset.prototype, "sortOrder", 2);
+SceneOwnedAsset = __decorateClass$4([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    name: "SceneOwnedAsset",
+    tableName: "scene_assets",
+    conflictColumns: ["scene_id", "asset_id", "role"],
+    api: false,
+    mcp: false,
+    cli: false
+  })
+], SceneOwnedAsset);
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "", value);
+let SceneOwnedAssetCollection = class extends SmrtJunction {
+  leftField = "sceneId";
+  rightField = "assetId";
+};
+__publicField(SceneOwnedAssetCollection, "_itemClass", SceneOwnedAsset);
+SceneOwnedAssetCollection = __decorateClass$3([
+  smrt({
+    api: false,
+    mcp: false,
+    cli: false
+  })
+], SceneOwnedAssetCollection);
+const sceneAssets = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get SceneOwnedAssetCollection() {
+    return SceneOwnedAssetCollection;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$2(target, key, result);
+  return result;
+};
+let VideoCompositionAsset = class extends Asset {
+  videoCompositionId = null;
+  role = "video";
+  constructor(options = {}) {
+    super(options);
+    if (options.videoCompositionId !== void 0)
+      this.videoCompositionId = options.videoCompositionId;
+    if (options.role !== void 0) this.role = options.role;
+  }
+};
+__decorateClass$2([
+  foreignKey(() => VideoComposition)
+], VideoCompositionAsset.prototype, "videoCompositionId", 2);
+VideoCompositionAsset = __decorateClass$2([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], VideoCompositionAsset);
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+let VideoSequenceAsset = class extends Asset {
+  videoSequenceId = null;
+  role = "video";
+  constructor(options = {}) {
+    super(options);
+    if (options.videoSequenceId !== void 0)
+      this.videoSequenceId = options.videoSequenceId;
+    if (options.role !== void 0) this.role = options.role;
+  }
+};
+__decorateClass$1([
+  foreignKey(() => VideoSequence)
+], VideoSequenceAsset.prototype, "videoSequenceId", 2);
+VideoSequenceAsset = __decorateClass$1([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], VideoSequenceAsset);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let VideoShotAsset = class extends Asset {
+  videoShotId = null;
+  role = "video";
+  constructor(options = {}) {
+    super(options);
+    if (options.videoShotId !== void 0)
+      this.videoShotId = options.videoShotId;
+    if (options.role !== void 0) this.role = options.role;
+  }
+};
+__decorateClass([
+  foreignKey(() => VideoShot)
+], VideoShotAsset.prototype, "videoShotId", 2);
+VideoShotAsset = __decorateClass([
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get"] },
+    cli: true
+  })
+], VideoShotAsset);
+export {
+  Character,
+  CharacterAsset,
+  CharacterCollection,
+  CharacterOwnedAsset,
+  CharacterOwnedAssetCollection,
+  CompositeJob,
+  Performer,
+  PerformerAsset,
+  PerformerOwnedAsset,
+  PerformerOwnedAssetCollection,
+  Character as PersonalityProfile,
+  Scene,
+  SceneAsset,
+  SceneOwnedAsset,
+  SceneOwnedAssetCollection,
+  VideoComposition,
+  VideoCompositionAsset,
+  VideoCompositionCollection,
+  VideoShot as VideoContent,
+  VideoSequence,
+  VideoSequenceAsset,
+  VideoSequenceCollection,
+  VideoShot,
+  VideoShotAsset,
+  VideoShotCharacter,
+  VideoShotCharacterCollection,
+  VideoShotCollection,
+  VideoWorkflow,
+  persistMediaBundleInspection
+};
+//# sourceMappingURL=index.js.map