@nodaro/shared 2.1.0 → 2.2.0

package/src/reference-roles.ts

@@ -11,7 +11,10 @@ import { DEFAULT_LABEL_BY_SOURCE, type ReferenceSource } from "./types.js"
 export const REFERENCE_ROLE_PRESETS: Record<ReferenceSource, readonly string[]> = {
   "wired-character": ["ref-only", "person", "face", "clothes", "hair", "pose", "expression", "style"],
   "wired-face": ["face", "person", "expression", "style"],
-  "wired-location": ["ref-only", "background", "atmosphere", "as-is", "empty background", "layout", "lighting", "style"],
+  // "location" sits second, mirroring wired-character's ref-only/person order —
+  // it is this source's default. "background" keeps its place for the genuine
+  // backdrop case (see DEFAULT_LABEL_BY_SOURCE for why it stopped being default).
+  "wired-location": ["ref-only", "location", "background", "atmosphere", "as-is", "empty background", "layout", "lighting", "style"],
   "wired-object": ["object", "shape", "material", "color", "texture", "style"],
   "wired-creature": ["creature", "anatomy", "markings", "pose", "color", "style"],
   "wired-image": ["object", "person", "face", "clothes", "background", "style", "pose", "texture"],

package/src/types.ts

@@ -224,7 +224,17 @@ export const DEFAULT_LABEL_BY_SOURCE: Record<ReferenceSource, string> = {
   // subject ("match anatomy, markings…"), not a prop. See CREATURE_LABELS in
   // prompt-builder.ts.
   "wired-creature": "creature",
-  "wired-location": "background",
+  // A PLACE, NOT A BACKDROP (2026-08-05). This defaulted to "background", which
+  // `roleToPhrase` renders as "the background from reference image B" — and the
+  // image models read that as "paste this behind the subject". Measured on
+  // gpt-image-2 (character + location, 4 draws per arm): with "background" every
+  // draw was a cut-out composite — an indoor-lit subject over a stock beach, no
+  // cast shadow, ignoring the asked-for action. Changing ONLY this word put the
+  // subject inside the scene with ground contact and a matching sun. "background"
+  // remains a curated pick in REFERENCE_ROLE_PRESETS for the genuine backdrop
+  // case; it is no longer what every location silently gets. Nodes that stored a
+  // role explicitly are untouched — `resolveDefaultRole` prefers the explicit value.
+  "wired-location": "location",
 }
 
 // ---------------------------------------------------------------------------

package/src/video-analysis-pricing.ts

@@ -29,6 +29,10 @@
  * against it and fails on drift. There is deliberately NO app-side formula to
  * check against — it was moved private in 2026-07 and the old backend test
  * went with it.
+ *
+ * `VIDEO_AUDIT_BUCKET_CREDITS` further down is the sibling table for the
+ * `video-audit` node ("AI Audit") — same module, same bucket ladder, same
+ * generator-authoritative pattern, its own two credit families.
  */
 
 export const VIDEO_ANALYSIS_DURATION_BUCKETS = [60, 180, 360, 600] as const
@@ -67,38 +71,65 @@ export const VIDEO_ANALYSIS_WINDOW = { LEN: WINDOW_LEN, STRIDE: WINDOW_STRIDE, O
 // Net effect: smart drops 27–47% per bucket — the 24 fps token spend was also
 // partly paying for media tokens the provider clamped and never counted — and
 // the economy rows tick up 3–6% from the prompt-token true-up.
+//
+// REGENERATED 2026-08-03 — V1 hybrid-smart reprice (task A3), from the
+// plugin's own generator (`scripts/gen-va-buckets.mjs`) at
+// nodaroai/nodaro-cloud-plugins commit eef077d (branch fix/va-cost-trueup).
+// This is the V1 true-up of task P6's provisional judge/refine/frame-judge
+// constants, re-derived from a 2026-08-03 staging measurement and approved by
+// Tal (the constants themselves, like the rest of the $-derived formula, stay
+// private in the plugin repo — never in this public package). `smart` is now
+// a HYBRID plan — one native 6fps skeleton pass plus 2 fast + 2 pro donor
+// rolls, always refined (`selectionMode` does not apply to `smart`; it always
+// refines) — and every multi-roll tier now carries its own explicit
+// judge/refine terms instead of an implicit share of a single-pass budget.
+// This is the full, honest reprice Tal approved, including the economy tiers
+// (fast 33->185 @180s ends a below-cost combine exposure that existed at the
+// old price). Net effect, per bucket (every row rises):
+//
+//   gemini-3-flash    60s   24->180   180s   33->185   360s   86-> 514   600s  143-> 846
+//   gemini-3.6-flash  60s   65->203   180s   92->218   360s  237-> 598   600s  395-> 986
+//   gemini-3.1-pro    60s   87->215   180s  116->231   360s  305-> 636   600s  509->1050
+//   mixed             60s  110->228   180s  149->249   360s  390-> 684   600s  651->1129
+//   mixed (2026-08-04) 60s 228->268   180s  249->289   360s  684-> 724   600s 1129->1169  (+40 flat: continuity pass joined the family)
+//   smart             60s  333->410   180s  470->500   360s 1135->1259   600s 1868->2064
+//
+// Values are pasted verbatim from the plugin generator's output — never hand
+// computed. The plugin's cost test cross-checks every row, sentinels included.
 export const VIDEO_ANALYSIS_BUCKET_CREDITS: Record<string, number> = {
   // Legacy fast-tier model (pre-2026-07) — kept for stored raw-id configs.
-  "video-analysis:gemini-3-flash:60s": 24,
-  "video-analysis:gemini-3-flash:180s": 33,
-  "video-analysis:gemini-3-flash:360s": 86,
-  "video-analysis:gemini-3-flash:600s": 143,
+  "video-analysis:gemini-3-flash:60s": 180,
+  "video-analysis:gemini-3-flash:180s": 185,
+  "video-analysis:gemini-3-flash:360s": 514,
+  "video-analysis:gemini-3-flash:600s": 846,
   // Current fast tier — regenerated from the private formula for its backing
   // model; higher than the legacy fast schedule but still ≤ pro per bucket.
-  "video-analysis:gemini-3.6-flash:60s": 65,
-  "video-analysis:gemini-3.6-flash:180s": 92,
-  "video-analysis:gemini-3.6-flash:360s": 237,
-  "video-analysis:gemini-3.6-flash:600s": 395,
-  "video-analysis:gemini-3.1-pro:60s": 87,
-  "video-analysis:gemini-3.1-pro:180s": 116,
-  "video-analysis:gemini-3.1-pro:360s": 305,
-  "video-analysis:gemini-3.1-pro:600s": 509,
+  "video-analysis:gemini-3.6-flash:60s": 203,
+  "video-analysis:gemini-3.6-flash:180s": 218,
+  "video-analysis:gemini-3.6-flash:360s": 598,
+  "video-analysis:gemini-3.6-flash:600s": 986,
+  "video-analysis:gemini-3.1-pro:60s": 215,
+  "video-analysis:gemini-3.1-pro:180s": 231,
+  "video-analysis:gemini-3.1-pro:360s": 636,
+  "video-analysis:gemini-3.1-pro:600s": 1050,
   // Mixed tiers (`mixed` + `mixed-fast`) share ONE credit family — they are
   // variants of the same engine plan (plan internals live in the private
   // analysis plugin). Admin-tunable via model_pricing like every other row.
-  "video-analysis:mixed:60s": 110,
-  "video-analysis:mixed:180s": 149,
-  "video-analysis:mixed:360s": 390,
-  "video-analysis:mixed:600s": 651,
-  // SMART — the one native-transport plan: a single pass with reasoning turned
-  // all the way up at a measured-optimal sampling rate. Priced above the
-  // economy tiers because it genuinely costs more to run; the only tier whose
-  // accuracy is validated against a hand-counted edit list, re-validated at
-  // the current sampling rate before this schedule shipped.
-  "video-analysis:smart:60s": 333,
-  "video-analysis:smart:180s": 470,
-  "video-analysis:smart:360s": 1135,
-  "video-analysis:smart:600s": 1868,
+  "video-analysis:mixed:60s": 268,
+  "video-analysis:mixed:180s": 289,
+  "video-analysis:mixed:360s": 724,
+  "video-analysis:mixed:600s": 1169,
+  // SMART — the accuracy tier, and since the 2026-08-03 hybrid re-plan a
+  // multi-roll plan like the others: one native 6fps skeleton pass plus 2
+  // fast + 2 pro donor rolls, always refined (`selectionMode` does not apply
+  // here — smart always refines; it never offers a cheaper "choose" path).
+  // Priced above the economy tiers because it genuinely costs more to run;
+  // the only tier whose accuracy is validated against a hand-counted edit
+  // list, re-validated at the current plan before this schedule shipped.
+  "video-analysis:smart:60s": 410,
+  "video-analysis:smart:180s": 500,
+  "video-analysis:smart:360s": 1259,
+  "video-analysis:smart:600s": 2064,
 }
 
 /**
@@ -132,3 +163,92 @@ export function bucketSecondsFromCreditId(creditId: string): number | null {
 export function videoAnalysisNumWindows(bucketSec: number): number {
   return bucketSec <= VIDEO_ANALYSIS_WINDOW.SINGLE_MAX ? 1 : 1 + Math.ceil((bucketSec - WINDOW_LEN) / WINDOW_STRIDE)
 }
+
+/**
+ * Precomputed credit cost for the `video-audit` node ("AI Audit") — the same
+ * pattern as `VIDEO_ANALYSIS_BUCKET_CREDITS` above: the OUTPUT of the private
+ * `videoAuditBucketCredits` formula in `@nodaroai/cloud-plugins`
+ * (`src/plugins/video-analysis/cost.ts`), a plain lookup table never a
+ * formula, cross-checked against that package's own cost test. Shares the
+ * SAME duration-bucket ladder as video-analysis (`VIDEO_ANALYSIS_DURATION_BUCKETS`
+ * / `pickVideoAnalysisBucket`) — the audit re-watches the same clip, so it
+ * buckets identically.
+ *
+ * Two credit families, selected by whether an analysis was wired into the
+ * node (see `buildVideoAuditCreditId`):
+ * - `video-audit:<bucket>s` — an analysis was provided; the audit re-watches
+ *   the clip against it directly (native watcher roll + reasoner pass, at a
+ *   safety margin — internals stay private in the plugin).
+ * - `video-audit:auto:<bucket>s` — no analysis wired; the node auto-runs a
+ *   fast-tier analysis first. Exactly the base family's price PLUS the
+ *   `gemini-3-flash` (legacy fast tier) row from `VIDEO_ANALYSIS_BUCKET_CREDITS`
+ *   at the SAME bucket — summed in the plugin's generator/formula, never
+ *   hand-added here (see the single-source assertion in
+ *   video-analysis-pricing.test.ts).
+ *
+ * Bare ids (`video-audit`, `video-audit:auto` — they live in
+ * `model-catalog.ts`'s pricing rows, not as keys in this table) equal their
+ * family's 600s ceiling, the same "unknown duration → ceiling" convention
+ * `VIDEO_ANALYSIS_BUCKET_CREDITS`'s bare per-model catalog rows use.
+ * `buildVideoAuditCreditId` never returns a bare id itself — an
+ * unknown/invalid duration resolves to the bucketed 600s id, matching
+ * `buildVideoAnalysisCreditId`.
+ *
+ * Values pasted verbatim from the plugin generator's output
+ * (`scripts/gen-va-buckets.mjs`) at `@nodaroai/cloud-plugins` v0.102.0 —
+ * never hand computed. The plugin's cost test cross-checks every row.
+ */
+export const VIDEO_AUDIT_BUCKET_CREDITS: Record<string, number> = {
+  "video-audit:60s": 213,
+  "video-audit:180s": 289,
+  "video-audit:360s": 659,
+  "video-audit:600s": 1066,
+  "video-audit:auto:60s": 393,
+  "video-audit:auto:180s": 474,
+  "video-audit:auto:360s": 1173,
+  "video-audit:auto:600s": 1912,
+}
+
+/**
+ * Composite credit-id builder for `video-audit`. Mirrors
+ * `buildVideoAnalysisCreditId`'s bucket selection and unknown/invalid-duration
+ * ceiling fallback exactly (same ladder, same rounding — `durationSec <=
+ * bucket`, clamped to the 600s max), but selects the FAMILY by whether an
+ * analysis was already provided instead of by model: `analysisProvided:
+ * true` prices under the cheaper `video-audit` family (re-audits an existing
+ * analysis); `false` prices under `video-audit:auto` (the node auto-runs a
+ * fast analysis first, hence that family's built-in fast-tier addition).
+ */
+export function buildVideoAuditCreditId(args: { analysisProvided: boolean; durationSec?: number }): string {
+  const { analysisProvided, durationSec } = args
+  const bucket = durationSec !== undefined && durationSec > 0
+    ? pickVideoAnalysisBucket(Math.min(durationSec, VIDEO_ANALYSIS_MAX_DURATION_SEC))
+    : VIDEO_ANALYSIS_MAX_DURATION_SEC // no/invalid duration → ceiling composite, same convention as buildVideoAnalysisCreditId
+  const family = analysisProvided ? "video-audit" : "video-audit:auto"
+  return `${family}:${bucket}s`
+}
+
+/**
+ * Table lookup for a resolved bucket + family. Snaps `bucketSec` onto the
+ * ladder via `pickVideoAnalysisBucket` first, so a raw duration (not just an
+ * exact 60/180/360/600) is safe to pass — mirrors `buildVideoAuditCreditId`'s
+ * own rounding rather than requiring the caller to pre-round.
+ */
+export function videoAuditCreditsForBucket(bucketSec: number, auto: boolean): number {
+  const bucket = pickVideoAnalysisBucket(bucketSec)
+  return VIDEO_AUDIT_BUCKET_CREDITS[`video-audit${auto ? ":auto" : ""}:${bucket}s`]!
+}
+
+/**
+ * Parses a `video-audit:*` credit id back to its bucket seconds — both
+ * families (`video-audit:<n>s` and `video-audit:auto:<n>s`); null on
+ * anything else (a bare id with no bucket, a `video-analysis:*` id, or
+ * garbage). Deliberately a SEPARATE parser from `bucketSecondsFromCreditId`
+ * (anchored to the `video-analysis:` prefix and a mandatory model segment) —
+ * mirrors the plugin-local audit parser so app code can never mis-parse an
+ * audit id with the VA-anchored parser, or vice versa.
+ */
+export function bucketSecondsFromAuditCreditId(id: string): number | null {
+  const m = /^video-audit(?::auto)?:(\d+)s$/.exec(id)
+  return m ? Number(m[1]) : null
+}

package/src/video-analysis.ts

@@ -491,8 +491,24 @@ export function renderAnalyzedScene(scene: { visual: string }, slots: EntitySlot
   return scene.visual.replace(SLOT_TOKEN_RE, (_whole, id: string) => castMap?.[id] ?? byId.get(id)?.description ?? id)
 }
 
+/**
+ * Float slack for the oversize comparison.
+ *
+ * Scene boundaries arrive as decimal seconds and the duration is derived by
+ * SUBTRACTING two of them, which does not land on the cap exactly: a real job
+ * produced a 12.67 → 20.67 scene whose computed length is 8.000000000000002,
+ * so a scene sitting precisely ON the 8s cap was flagged oversized and carried
+ * a `oversized: true` defect marker downstream for no reason.
+ *
+ * A microsecond is orders of magnitude below any boundary precision the
+ * analyzer can actually resolve (windows land on ~0.01s at best), so this can
+ * never mask a genuinely oversized scene — the smallest real overshoot is
+ * still ~10000x larger than the tolerance.
+ */
+const OVERSIZE_TOLERANCE_SEC = 1e-6
+
 export function isOversizedScene(startSec: number, endSec: number): boolean {
-  return endSec - startSec > VIDEO_ANALYSIS_MAX_SCENE_SEC
+  return endSec - startSec > VIDEO_ANALYSIS_MAX_SCENE_SEC + OVERSIZE_TOLERANCE_SEC
 }
 
 const STANDARD_RATIOS: Array<[string, number]> = [