@cueframe/kernel 0.2.58 → 0.2.59-rc.0

package/dist/chunk-IG3YAOUZ.js

@@ -1,418 +0,0 @@
-import {
-  BrandKit
-} from "./chunk-PWWZTY3G.js";
-import {
-  Composition,
-  Copy,
-  Format,
-  GraphicRole,
-  OpaqueId
-} from "./chunk-UFD4EZHM.js";
-
-// ../composition/src/validators/composePlan.ts
-import { z } from "zod";
-var PlanSubject = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("face"), faceId: z.string().min(1) }),
-  z.object({ kind: z.literal("all-faces") }),
-  z.object({ kind: z.literal("frame-center") }),
-  z.object({ kind: z.literal("active-speaker") }),
-  z.object({
-    kind: z.literal("point"),
-    x: z.number().min(0).max(1),
-    y: z.number().min(0).max(1)
-  })
-]);
-var PlanFramingSegment = z.object({
-  startSec: z.number().nonnegative(),
-  endSec: z.number().positive(),
-  action: z.enum(["frame", "keep", "trim"]).describe(
-    "'frame' = SHOW this span cropped/tracked per `subject`. 'keep' = SHOW this span as-is, no reframe (footage with nothing to track). 'trim' = DELETE this span from the output entirely \u2014 trimmed footage never appears."
-  ),
-  subject: PlanSubject.optional(),
-  shotScale: z.enum(["close", "standard", "wide"]).optional(),
-  zoomScale: z.number().min(0.4).max(1).optional(),
-  verticalBias: z.number().min(-0.3).max(0.3).optional(),
-  lateralBias: z.number().min(-0.3).max(0.3).optional(),
-  intent: z.string().optional()
-}).refine((s) => s.action !== "frame" || s.subject !== void 0, {
-  message: "frame segment requires a subject \u2014 for footage with no trackable subject use action:'keep' (shown as-is); do NOT trim spans you want shown"
-}).refine((s) => s.action !== "keep" || s.subject === void 0, {
-  message: "keep segment shows footage as-is \u2014 it takes no subject (use action:'frame' to track one)"
-}).refine((s) => s.shotScale === void 0 || s.zoomScale === void 0, {
-  message: "framing segment takes EITHER shotScale (editorial scale \u2014 the bake calibrates the zoom to the detected face) OR zoomScale (an explicit fraction of the frame), never both: shotScale wins and the zoomScale would be silently discarded",
-  path: ["zoomScale"]
-});
-var PlanCut = z.object({
-  startSec: z.number().nonnegative(),
-  endSec: z.number().positive(),
-  reason: z.string().min(1)
-});
-var PlanAssetRequest = z.object({
-  id: z.string().min(1),
-  atSec: z.number().nonnegative(),
-  durSec: z.number().positive(),
-  kind: z.enum(["broll", "audio", "sfx", "music", "ambience", "gif", "image"]),
-  source: z.enum(["find", "generate"]),
-  intent: z.string().min(1),
-  resolvedMediaId: z.string().optional()
-});
-var PlanGraphicRequest = z.object({
-  id: z.string().min(1),
-  atSec: z.number().nonnegative(),
-  durSec: z.number().positive(),
-  role: GraphicRole,
-  copy: Copy,
-  intent: z.string().min(1)
-});
-var PlanMarker = z.object({
-  startSec: z.number().nonnegative(),
-  endSec: z.number().nonnegative().optional(),
-  kind: z.string().min(1),
-  name: z.string().optional()
-});
-var ComposePlan = z.object({
-  framing: z.array(PlanFramingSegment).min(1),
-  cuts: z.array(PlanCut).optional(),
-  captions: z.object({ styleIntent: z.string().optional() }).optional(),
-  assets: z.array(PlanAssetRequest).optional(),
-  graphics: z.array(PlanGraphicRequest).optional(),
-  markers: z.array(PlanMarker).optional()
-});
-
-// ../composition/src/validators/font.ts
-import { z as z2 } from "zod";
-var FontStatus = z2.enum([
-  "pending",
-  "uploading",
-  "analyzing",
-  "subsetting",
-  "ready",
-  "partial",
-  // common-glyphs buffer present, custom glyphs still subsetting
-  "failed"
-]);
-var FontVariant = z2.object({
-  weight: z2.number().int().min(100).max(900),
-  style: z2.enum(["normal", "italic"]),
-  storageKey: z2.string().min(1),
-  byteSize: z2.number().int().nonnegative().optional(),
-  subsetComplete: z2.boolean().optional()
-});
-var Font = z2.object({
-  id: z2.string().min(1),
-  family: z2.string().min(1),
-  status: FontStatus,
-  variants: z2.array(FontVariant).nonempty(),
-  source: z2.enum(["uploaded", "system", "web"]).optional(),
-  license: z2.object({
-    type: z2.string().min(1),
-    source: z2.string().optional(),
-    notes: z2.string().optional()
-  }).optional(),
-  createdAt: z2.number().optional(),
-  // epoch ms
-  ownerOrgId: z2.string().optional()
-});
-
-// ../composition/src/validators/render.ts
-import { z as z3 } from "zod";
-var RenderPriority = z3.enum(["interactive", "standard", "background"]);
-var RenderIntent = z3.enum(["preview", "final"]);
-var RenderMode = z3.enum(["offline", "live"]);
-var RenderCancelReason = z3.enum([
-  "user",
-  "agent",
-  "cost_limit",
-  "superseded",
-  "source_removed",
-  "timeout",
-  "error"
-]);
-var RenderStatus = z3.enum([
-  "pending",
-  "rendering",
-  "complete",
-  "error",
-  "cancelled"
-]);
-var RenderProgressPhase = z3.object({
-  phase: z3.string().min(1),
-  percent: z3.number().min(0).max(100),
-  scenesTotal: z3.number().int().positive().optional()
-});
-var RegistryPin = z3.object({
-  package: z3.string().min(1),
-  name: z3.string().min(1),
-  version: z3.string().min(1)
-});
-var MediaSourceSnapshot = z3.object({
-  mediaId: OpaqueId,
-  presignedUrl: z3.string().url(),
-  expiresAt: z3.number().optional()
-});
-var RenderSnapshot = z3.object({
-  composition: Composition,
-  brandKit: BrandKit.optional(),
-  mediaSources: z3.array(MediaSourceSnapshot),
-  registryPins: z3.array(RegistryPin),
-  capturedAt: z3.number()
-});
-var R2Destination = z3.object({
-  kind: z3.literal("r2"),
-  path: z3.string().optional()
-});
-var S3Destination = z3.object({
-  kind: z3.literal("s3"),
-  credentialId: z3.string().min(1),
-  bucket: z3.string().min(1),
-  key: z3.string().min(1),
-  region: z3.string().optional(),
-  acl: z3.string().optional()
-});
-var YoutubeDestination = z3.object({
-  kind: z3.literal("youtube"),
-  credentialId: z3.string().min(1),
-  title: z3.string().min(1),
-  description: z3.string().optional(),
-  privacy: z3.enum(["public", "unlisted", "private"]),
-  tags: z3.array(z3.string()).optional()
-});
-var MuxDestination = z3.object({
-  kind: z3.literal("mux"),
-  credentialId: z3.string().min(1),
-  passthrough: z3.string().optional()
-});
-var WebhookDestination = z3.object({
-  kind: z3.literal("webhook"),
-  url: z3.string().url(),
-  signingKeyId: z3.string().optional(),
-  headers: z3.record(z3.string(), z3.string()).optional()
-});
-var Destination = z3.discriminatedUnion("kind", [
-  R2Destination,
-  S3Destination,
-  YoutubeDestination,
-  MuxDestination,
-  WebhookDestination
-]);
-var DestinationDeliveryStatus = z3.enum([
-  "pending",
-  "uploading",
-  "delivered",
-  "failed"
-]);
-var DestinationResult = z3.object({
-  destinationIndex: z3.number().int().nonnegative(),
-  status: DestinationDeliveryStatus,
-  url: z3.string().url().optional(),
-  deliveredAt: z3.number().optional(),
-  error: z3.string().optional()
-});
-var RenderJob = z3.object({
-  id: OpaqueId,
-  projectId: OpaqueId.optional(),
-  compositionId: OpaqueId,
-  compositionVersionId: z3.string().min(1),
-  status: RenderStatus,
-  progress: RenderProgressPhase.optional(),
-  mode: RenderMode.optional(),
-  priority: RenderPriority,
-  // required per data-model.md § Render priority
-  intent: RenderIntent.optional(),
-  snapshot: RenderSnapshot.optional(),
-  snapshotRef: z3.string().optional(),
-  outputUrl: z3.string().url().optional(),
-  outputExpiresAt: z3.number().optional(),
-  // epoch ms
-  destinations: z3.array(Destination).optional(),
-  destinationResults: z3.array(DestinationResult).optional(),
-  cancelReason: RenderCancelReason.optional(),
-  error: z3.object({
-    code: z3.string(),
-    message: z3.string(),
-    details: z3.record(z3.string(), z3.unknown()).optional()
-  }).optional(),
-  createdAt: z3.number(),
-  updatedAt: z3.number()
-});
-var RenderProgress = z3.object({
-  jobId: OpaqueId,
-  status: RenderStatus,
-  percent: z3.number().min(0).max(100).optional(),
-  framesRendered: z3.number().int().nonnegative().optional(),
-  framesTotal: z3.number().int().positive().optional()
-});
-
-// ../composition/src/validators/registry.ts
-import { z as z4 } from "zod";
-var PrimitiveOriginClass = z4.enum([
-  "first-party",
-  "community-verified",
-  "community-unverified",
-  "user-private",
-  "sandbox",
-  "deprecated"
-]);
-var PrimitiveMode = z4.enum(["2d", "immersive", "interactive"]);
-var PrimitiveToken = z4.object({
-  path: z4.string().min(1),
-  fallback: z4.unknown()
-});
-var PrimitiveOtioMapping = z4.object({
-  effectName: z4.string().min(1),
-  metadata: z4.record(z4.string(), z4.unknown()).optional()
-});
-var PrimitiveMeta = z4.object({
-  description: z4.string().optional(),
-  use_when: z4.array(z4.string()).optional(),
-  avoid_when: z4.array(z4.string()).optional(),
-  vibe: z4.array(z4.string()).optional(),
-  formats: z4.array(z4.string()).optional(),
-  pairs_well_with: z4.array(z4.string()).optional(),
-  exemplars: z4.array(z4.string()).optional()
-});
-var PrimitiveRegistryEntry = z4.object({
-  name: z4.string().min(1),
-  package: z4.string().min(1),
-  category: z4.enum(["overlay", "text", "effect", "transition", "layout"]),
-  version: z4.string().min(1),
-  origin: PrimitiveOriginClass,
-  modes: z4.array(PrimitiveMode).optional(),
-  paramsSchema: z4.unknown(),
-  varyingParams: z4.array(z4.string()).optional(),
-  extends: z4.string().optional(),
-  tokens: z4.array(PrimitiveToken).optional(),
-  otio: PrimitiveOtioMapping.optional(),
-  meta: PrimitiveMeta.optional()
-});
-
-// ../composition/src/validators/project.ts
-import { z as z5 } from "zod";
-var Project = z5.object({
-  id: OpaqueId,
-  name: z5.string().min(1),
-  defaultFormat: Format.optional(),
-  palConformDefault: z5.union([z5.literal(24), z5.literal(30)]).optional(),
-  activeCompositionId: OpaqueId.nullable().optional(),
-  brandKitId: z5.string().optional(),
-  ownerOrgId: z5.string().optional(),
-  createdAt: z5.number(),
-  updatedAt: z5.number()
-});
-
-// ../composition/src/validators/session.ts
-import { z as z6 } from "zod";
-var SessionMediaRole = z6.enum([
-  "main",
-  "wide",
-  "facecam",
-  "screen",
-  "audio"
-]);
-var SessionMember = z6.object({
-  mediaId: OpaqueId,
-  role: SessionMediaRole,
-  label: z6.string().optional()
-  // human-readable annotation, e.g., "host's camera"
-});
-var SessionMux = z6.object({
-  videoRole: z6.enum(["main", "wide", "facecam", "screen"]),
-  audioRole: z6.literal("audio")
-});
-var Session = z6.object({
-  id: OpaqueId,
-  name: z6.string().min(1),
-  members: z6.array(SessionMember).nonempty(),
-  mux: z6.array(SessionMux).optional(),
-  ownerOrgId: z6.string().optional(),
-  createdAt: z6.number(),
-  updatedAt: z6.number()
-});
-
-// ../composition/src/validators/webhook.ts
-import { z as z7 } from "zod";
-var SubstrateWebhookEvent = z7.enum([
-  "render.completed",
-  "media.transcribed",
-  "media.completed",
-  "composition.updated"
-]);
-var WebhookDeliveryStatus = z7.enum([
-  "pending",
-  "delivering",
-  "delivered",
-  "failed",
-  "exhausted"
-  // retry budget burned through
-]);
-var Webhook = z7.object({
-  id: OpaqueId,
-  url: z7.string().url(),
-  events: z7.array(z7.string().min(1)).nonempty(),
-  signingKeyId: z7.string().optional(),
-  headers: z7.record(z7.string(), z7.string()).optional(),
-  enabled: z7.boolean().optional(),
-  ownerOrgId: z7.string().optional(),
-  createdAt: z7.number(),
-  updatedAt: z7.number()
-});
-var WebhookDelivery = z7.object({
-  id: z7.string().min(1),
-  webhookId: OpaqueId,
-  event: z7.string().min(1),
-  payload: z7.record(z7.string(), z7.unknown()),
-  status: WebhookDeliveryStatus,
-  attemptCount: z7.number().int().nonnegative(),
-  responseStatus: z7.number().int().optional(),
-  responseBody: z7.string().optional(),
-  error: z7.string().optional(),
-  createdAt: z7.number(),
-  deliveredAt: z7.number().optional()
-});
-
-export {
-  PlanSubject,
-  PlanFramingSegment,
-  PlanCut,
-  PlanAssetRequest,
-  PlanGraphicRequest,
-  PlanMarker,
-  ComposePlan,
-  FontStatus,
-  FontVariant,
-  Font,
-  RenderPriority,
-  RenderIntent,
-  RenderMode,
-  RenderCancelReason,
-  RenderStatus,
-  RenderProgressPhase,
-  RegistryPin,
-  MediaSourceSnapshot,
-  RenderSnapshot,
-  R2Destination,
-  S3Destination,
-  YoutubeDestination,
-  MuxDestination,
-  WebhookDestination,
-  Destination,
-  DestinationDeliveryStatus,
-  DestinationResult,
-  RenderJob,
-  RenderProgress,
-  PrimitiveOriginClass,
-  PrimitiveMode,
-  PrimitiveToken,
-  PrimitiveOtioMapping,
-  PrimitiveMeta,
-  PrimitiveRegistryEntry,
-  Project,
-  SessionMediaRole,
-  SessionMember,
-  SessionMux,
-  Session,
-  SubstrateWebhookEvent,
-  WebhookDeliveryStatus,
-  Webhook,
-  WebhookDelivery
-};

package/dist/chunk-JOURGVOR.js

@@ -1,27 +0,0 @@
-// ../authoring/src/capabilities.ts
-var AgentFixableCaptureError = class extends Error {
-  agentFixable = true;
-  constructor(message) {
-    super(message);
-    this.name = "AgentFixableCaptureError";
-  }
-};
-var CAPABILITY_GATED_TOOLS = Object.freeze({
-  capture_frames: "capture",
-  score_composition: "verify",
-  apply_motion_preset: "motionPreset",
-  search_library: "resources"
-});
-function getExcludedTools(capabilities) {
-  const ex = /* @__PURE__ */ new Set();
-  for (const [tool, cap] of Object.entries(CAPABILITY_GATED_TOOLS)) {
-    if (!capabilities[cap]) ex.add(tool);
-  }
-  return ex;
-}
-
-export {
-  AgentFixableCaptureError,
-  CAPABILITY_GATED_TOOLS,
-  getExcludedTools
-};

package/dist/chunk-MFMR3LHO.js

@@ -1,116 +0,0 @@
-import {
-  cssUrlPayloads,
-  isFragmentReference
-} from "./chunk-OSMXQV5V.js";
-import {
-  CueframeError
-} from "./chunk-AK5QBHOB.js";
-
-// ../execution/render-harness/src/cardAssetAdmission.ts
-import parseCss from "css-tree/parser";
-import walkCss from "css-tree/walker";
-import { parseFragment } from "parse5";
-var RESOURCE_ELEMENTS = /* @__PURE__ */ new Set([
-  "audio",
-  "embed",
-  "iframe",
-  "image",
-  "img",
-  "link",
-  "object",
-  "script",
-  "source",
-  "track",
-  "video"
-]);
-var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "action",
-  "data",
-  "formaction",
-  "href",
-  "poster",
-  "src",
-  "srcset",
-  "xlink:href"
-]);
-var CSS_VALUE_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "clip-path",
-  "cursor",
-  "fill",
-  "filter",
-  "marker",
-  "marker-end",
-  "marker-mid",
-  "marker-start",
-  "mask",
-  "stroke"
-]);
-function refuse(locator, reason) {
-  throw new CueframeError(
-    "card_external_asset_forbidden",
-    `Card ${locator} ${reason}`,
-    void 0,
-    { card: locator }
-  );
-}
-function assertCssAssetFree(css, context, locator) {
-  let ast;
-  try {
-    ast = parseCss(css, { context });
-  } catch (cause) {
-    refuse(locator, `contains invalid CSS: ${String(cause)}`);
-  }
-  walkCss(ast, (node) => {
-    if (node.type === "Url" && !isFragmentReference(node.value)) {
-      refuse(locator, "contains a CSS url() asset reference");
-    }
-    if (node.type === "Atrule" && ["import", "font-face"].includes(node.name.toLowerCase())) {
-      refuse(locator, `contains a forbidden CSS @${node.name} rule`);
-    }
-  });
-}
-function assertNodeAssetFree(node, locator) {
-  if ("tagName" in node) {
-    const tagName = node.tagName.toLowerCase();
-    if (RESOURCE_ELEMENTS.has(tagName)) {
-      refuse(locator, `contains resource-bearing <${tagName}> markup`);
-    }
-    for (const attr of node.attrs) {
-      const name = attr.name.toLowerCase();
-      if (name.startsWith("on")) {
-        refuse(locator, `contains executable event handler '${name}'`);
-      }
-      if (URL_ATTRIBUTES.has(name) && !isFragmentReference(attr.value)) {
-        refuse(locator, `contains an unmanifested ${name} asset reference`);
-      }
-      if (name === "style") assertCssAssetFree(attr.value, "declarationList", locator);
-      if (CSS_VALUE_ATTRIBUTES.has(name)) {
-        for (const payload of cssUrlPayloads(attr.value)) {
-          if (!isFragmentReference(payload)) {
-            refuse(locator, `contains an unmanifested ${name} url() asset reference`);
-          }
-        }
-      }
-    }
-    if (tagName === "style" && "childNodes" in node) {
-      const css = node.childNodes.filter((child) => child.nodeName === "#text").map((child) => child.value).join("");
-      assertCssAssetFree(css, "stylesheet", locator);
-    }
-  }
-  if ("childNodes" in node) {
-    for (const child of node.childNodes) assertNodeAssetFree(child, locator);
-  }
-}
-function assertCardHtmlAssetFree(input) {
-  for (const overlay of input.overlays ?? []) {
-    if (overlay.template !== "card") continue;
-    const html = overlay.params?.html;
-    if (typeof html !== "string") continue;
-    const fragment = parseFragment(html);
-    for (const node of fragment.childNodes) assertNodeAssetFree(node, `overlay '${overlay.id}'`);
-  }
-}
-
-export {
-  assertCardHtmlAssetFree
-};

package/dist/chunk-OSMXQV5V.js

@@ -1,18 +0,0 @@
-// ../execution/render-harness/src/assetRefs.ts
-function isFragmentReference(value) {
-  return value.trim().startsWith("#");
-}
-function cssUrlPayloads(value) {
-  return [...value.matchAll(/url\(\s*(['"]?)(.*?)\1\s*\)/gi)].map((m) => m[2] ?? "");
-}
-function hasNonFragmentCssUrl(value) {
-  const payloads = cssUrlPayloads(value);
-  if (payloads.length === 0) return false;
-  return payloads.some((payload) => !isFragmentReference(payload));
-}
-
-export {
-  isFragmentReference,
-  cssUrlPayloads,
-  hasNonFragmentCssUrl
-};

package/dist/chunk-QDBVYZSF.js

@@ -1,128 +0,0 @@
-import {
-  NEUTRAL_RAMP
-} from "./chunk-VG2ND6PX.js";
-
-// ../execution/primitives/src/lib/tokens.ts
-var CONTRAST_CRITICAL_PATHS = /* @__PURE__ */ new Set([
-  "colors.text",
-  "colors.textMuted",
-  "colors.textOnMedia",
-  "colors.textOnAccent",
-  "colors.textOnSurface",
-  "caption.fg",
-  "caption.scrim"
-]);
-function isContrastCritical(brandKitPath) {
-  return CONTRAST_CRITICAL_PATHS.has(brandKitPath);
-}
-var FROZEN_CORE_PATHS = [
-  "colors.background",
-  "colors.surface",
-  "colors.card",
-  "colors.text",
-  "colors.textMuted",
-  "colors.textOnMedia",
-  "colors.border",
-  "colors.gridLine",
-  "colors.accent",
-  "colors.accentMuted",
-  "colors.textOnAccent",
-  "colors.textOnSurface",
-  "caption.fg",
-  "caption.scrim",
-  "fonts.heading",
-  "fonts.body",
-  "fonts.caption",
-  "motion.duration",
-  "motion.easing",
-  "motion.entrance",
-  "motion.staggerMs",
-  "motion.exitMs",
-  "spacing.base",
-  "spacing.lg",
-  "spacing.sm",
-  "sizing.fontSizeHeading",
-  "sizing.fontSizeBody",
-  "sizing.fontSizeLabel",
-  "sizing.borderRadius"
-];
-var TIER2B_EXTENSION_PATHS = [
-  "colors.terminal",
-  "colors.chrome",
-  "colors.overlay",
-  "colors.accentHue"
-];
-var ALLOWED_BRAND_PATHS = [
-  ...FROZEN_CORE_PATHS,
-  ...TIER2B_EXTENSION_PATHS
-];
-var BRAND_REF_PREFIX = "$brand:";
-function lintBrandPath(p) {
-  const path = p.startsWith(BRAND_REF_PREFIX) ? p.slice(BRAND_REF_PREFIX.length) : p;
-  return ALLOWED_BRAND_PATHS.includes(path);
-}
-function getByPath(obj, path) {
-  if (!obj || typeof obj !== "object") return void 0;
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return void 0;
-    }
-    current = current[part];
-  }
-  return current;
-}
-function setByPath(obj, path, value) {
-  const parts = path.split(".");
-  let current = obj;
-  for (let i = 0; i < parts.length - 1; i += 1) {
-    const part = parts[i];
-    const next = current[part];
-    if (next === null || next === void 0 || typeof next !== "object") {
-      current[part] = {};
-    }
-    current = current[part];
-  }
-  current[parts[parts.length - 1]] = value;
-}
-function resolveTokenValue(binding, brandKit, opts) {
-  if (binding.brandKitPath) {
-    const v = brandKit ? getByPath(brandKit, binding.brandKitPath) : void 0;
-    if (typeof v === "string") return v;
-    const path = binding.brandKitPath;
-    if (opts?.onUnresolved) {
-      opts.onUnresolved({ path });
-    } else {
-      console.warn(`[render] unresolved brand binding path=${path}`);
-    }
-    if (isContrastCritical(path)) return NEUTRAL_RAMP.onDark;
-  }
-  return binding.fallback;
-}
-function applyBrandCascade(params, tokens, brandKit, opts) {
-  const result = JSON.parse(JSON.stringify(params));
-  for (const binding of tokens) {
-    const userValue = getByPath(result, binding.propPath);
-    if (userValue === void 0) {
-      setByPath(result, binding.propPath, resolveTokenValue(binding, brandKit, opts));
-    }
-  }
-  return result;
-}
-function resolveParams(userParams, propDefaults, tokens, brandKit, opts) {
-  const withDefaults = { ...propDefaults, ...userParams };
-  return applyBrandCascade(withDefaults, tokens, brandKit, opts);
-}
-
-export {
-  CONTRAST_CRITICAL_PATHS,
-  isContrastCritical,
-  FROZEN_CORE_PATHS,
-  TIER2B_EXTENSION_PATHS,
-  ALLOWED_BRAND_PATHS,
-  lintBrandPath,
-  resolveTokenValue,
-  applyBrandCascade,
-  resolveParams
-};