@nodaro/shared 1.4.2

package/src/__tests__/i18n-locale-completeness.test.ts

@@ -0,0 +1,156 @@
+/**
+ * L1#6 — i18n catalog × locale completeness.
+ *
+ * Per CLAUDE.md `packages/shared/` note: the i18n sidecar files
+ * (`packages/shared/src/i18n/<catalog>.<locale>.ts`) are loaded by the
+ * frontend via `import.meta.glob("../../../packages/shared/src/i18n/*.*.ts")`
+ * — each per-locale chunk gets code-split. The Dockerfile must copy
+ * `packages/shared/src/i18n/` (NOT just dist) for the glob to find files
+ * at production build time.
+ *
+ * If even one catalog×locale file is missing, that picker silently falls
+ * back to English in production. The user sees mixed English + their
+ * locale (or just English) and the bug is invisible until reported.
+ *
+ * This walk asserts every (catalog, locale) pair exists. If a developer
+ * adds a new locale or a new catalog, they must add 36 (or 11) new sidecar
+ * files — this test fails until they're all present.
+ */
+
+import { readdirSync } from "node:fs"
+import { join } from "node:path"
+import { describe, it, expect } from "vitest"
+import { I18N_CATALOGS } from "../i18n/types.js"
+
+const I18N_DIR = join(__dirname, "..", "i18n")
+
+/**
+ * Discover supported locales by scanning the i18n directory. The locale list
+ * is implicitly defined by the set of suffixes that appear on sidecar files
+ * — there's no central LOCALES enum (yet). Adding a new locale means adding
+ * a sidecar file for every catalog.
+ */
+function discoverLocales(): string[] {
+  const all = readdirSync(I18N_DIR)
+  const localePattern = /^[^.]+\.([a-zA-Z-]+)\.ts$/
+  const locales = new Set<string>()
+  for (const f of all) {
+    if (f === "types.ts" || f === "index.ts") continue
+    const m = f.match(localePattern)
+    if (m) locales.add(m[1])
+  }
+  return [...locales].sort()
+}
+
+const LOCALES = discoverLocales()
+
+// Sanity: a non-trivial number of locales
+describe("locale discovery sanity", () => {
+  it("found at least 5 locales (non-trivial coverage)", () => {
+    expect(LOCALES.length).toBeGreaterThanOrEqual(5)
+  })
+
+  it("includes baseline locales known to exist (fr, de, es, ja)", () => {
+    expect(LOCALES).toContain("fr")
+    expect(LOCALES).toContain("de")
+    expect(LOCALES).toContain("es")
+    expect(LOCALES).toContain("ja")
+  })
+})
+
+// Build set of actually-present sidecar files for fast lookup
+const PRESENT_FILES = new Set(
+  readdirSync(I18N_DIR).filter(
+    (f) => f !== "types.ts" && f !== "index.ts" && f.endsWith(".ts"),
+  ),
+)
+
+/**
+ * Allowlist of (catalog, locale) pairs intentionally without a sidecar.
+ * Empty by default — every cell of the matrix should be filled.
+ */
+const KNOWN_MISSING_LOCALES: ReadonlySet<string> = new Set<string>([])
+
+// ---------------------------------------------------------------------------
+// Test 1 — every (catalog, locale) cell has a sidecar file.
+// ---------------------------------------------------------------------------
+
+describe("i18n catalog × locale matrix is complete", () => {
+  const cases: Array<[string, string]> = []
+  for (const catalog of I18N_CATALOGS) {
+    for (const locale of LOCALES) {
+      cases.push([catalog, locale])
+    }
+  }
+
+  it.each(cases)(
+    'sidecar file %s.%s.ts exists',
+    (catalog, locale) => {
+      if (KNOWN_MISSING_LOCALES.has(`${catalog}.${locale}`)) return
+      const filename = `${catalog}.${locale}.ts`
+      expect(
+        PRESENT_FILES.has(filename),
+        `Missing sidecar file: packages/shared/src/i18n/${filename}. The "${catalog}" picker will silently fall back to English in the "${locale}" locale. Either add the file (mirror the structure of an existing locale, e.g. ${catalog}.fr.ts), or add "${catalog}.${locale}" to KNOWN_MISSING_LOCALES with a comment.`,
+      ).toBe(true)
+    },
+  )
+})
+
+// ---------------------------------------------------------------------------
+// Test 2 — KNOWN_MISSING_LOCALES integrity.
+// ---------------------------------------------------------------------------
+
+describe("KNOWN_MISSING_LOCALES integrity", () => {
+  it("every allowlist entry is genuinely missing from disk", () => {
+    const stale: string[] = []
+    for (const entry of KNOWN_MISSING_LOCALES) {
+      const [catalog, locale] = entry.split(".")
+      if (PRESENT_FILES.has(`${catalog}.${locale}.ts`)) stale.push(entry)
+    }
+    expect(
+      stale,
+      `These KNOWN_MISSING_LOCALES entries now have sidecar files — remove from allowlist: ${stale.join(", ")}`,
+    ).toEqual([])
+  })
+
+  it("every allowlist entry references a known catalog and a known locale", () => {
+    const knownCats = new Set(I18N_CATALOGS)
+    const knownLocs = new Set(LOCALES)
+    const invalid: string[] = []
+    for (const entry of KNOWN_MISSING_LOCALES) {
+      const [catalog, locale] = entry.split(".")
+      if (!knownCats.has(catalog as (typeof I18N_CATALOGS)[number]) || !knownLocs.has(locale)) {
+        invalid.push(entry)
+      }
+    }
+    expect(
+      invalid,
+      `These KNOWN_MISSING_LOCALES entries reference unknown catalog or locale — remove or fix: ${invalid.join(", ")}`,
+    ).toEqual([])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Test 3 — no orphan files (sidecars whose catalog is not in I18N_CATALOGS).
+// Catches: developer renames a catalog, forgets to delete old sidecars.
+// ---------------------------------------------------------------------------
+
+describe("no orphan i18n sidecar files", () => {
+  it("every sidecar file's catalog name is in I18N_CATALOGS", () => {
+    const knownCats = new Set(I18N_CATALOGS)
+    const orphans: string[] = []
+    for (const f of PRESENT_FILES) {
+      // Filename: <catalog>.<locale>.ts. Catalog can contain hyphens.
+      const m = f.match(/^(.+)\.([a-zA-Z-]+)\.ts$/)
+      if (!m) continue
+      const [, catalog] = m
+      if (!knownCats.has(catalog as (typeof I18N_CATALOGS)[number])) {
+        orphans.push(f)
+      }
+    }
+    expect(
+      orphans,
+      `These i18n sidecar files don't correspond to any catalog in I18N_CATALOGS — they're loaded by the glob but never resolved. Remove them, or add the catalog to I18N_CATALOGS in packages/shared/src/i18n/types.ts: ${orphans.join(", ")}`,
+    ).toEqual([])
+  })
+})

package/src/__tests__/image-critic-node.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest"
+import {
+  IMAGE_CRITIC_LEAF_MODES,
+  IMAGE_CRITIC_MODES,
+  ImageCriticResultSchema,
+} from "../image-critic-node.js"
+
+describe("image-critic shared types", () => {
+  it("IMAGE_CRITIC_LEAF_MODES contains 6 leaf modes (no 'all')", () => {
+    expect(IMAGE_CRITIC_LEAF_MODES).toEqual([
+      "character-consistency",
+      "realism",
+      "prompt-adherence",
+      "anatomy",
+      "aesthetic",
+      "style-match",
+    ])
+    expect(IMAGE_CRITIC_LEAF_MODES).not.toContain("all")
+  })
+
+  it("IMAGE_CRITIC_MODES is leaves + 'all'", () => {
+    expect(IMAGE_CRITIC_MODES).toHaveLength(7)
+    expect(IMAGE_CRITIC_MODES).toContain("all")
+  })
+
+  it("parses a valid single-mode result", () => {
+    const result = ImageCriticResultSchema.parse({
+      score: 0.82,
+      feedback: "Reshape the left hand.",
+    })
+    expect(result.score).toBe(0.82)
+    expect(result.feedback).toBe("Reshape the left hand.")
+  })
+
+  it("parses a valid 'all'-mode result with perMode", () => {
+    const result = ImageCriticResultSchema.parse({
+      score: 0.55,
+      feedback: "Anatomy: reshape the left hand.",
+      perMode: {
+        realism:  { score: 0.72, feedback: "Skin too plastic." },
+        anatomy:  { score: 0.55, feedback: "Reshape the left hand." },
+      },
+    })
+    expect(result.perMode?.anatomy?.score).toBe(0.55)
+  })
+
+  it("rejects 'all' as a perMode key (strict)", () => {
+    expect(() =>
+      ImageCriticResultSchema.parse({
+        score: 0.5,
+        feedback: "x",
+        perMode: { all: { score: 0.5, feedback: "x" } } as any,
+      }),
+    ).toThrow()
+  })
+
+  it("rejects score outside 0-1", () => {
+    expect(() => ImageCriticResultSchema.parse({ score: 1.5, feedback: "x" })).toThrow()
+    expect(() => ImageCriticResultSchema.parse({ score: -0.1, feedback: "x" })).toThrow()
+  })
+
+  it("coerces bare-string issues into the object shape (LLM drift → was a 502)", () => {
+    const result = ImageCriticResultSchema.parse({
+      score: 0.1,
+      feedback: "Match the facial bone structure to the reference.",
+      issues: ["different hair color (black vs blonde)", "different jaw shape"],
+    })
+    expect(result.issues).toEqual([
+      { category: "general", severity: "warning", description: "different hair color (black vs blonde)" },
+      { category: "general", severity: "warning", description: "different jaw shape" },
+    ])
+  })
+
+  it("accepts object-shaped issues unchanged", () => {
+    const result = ImageCriticResultSchema.parse({
+      score: 0.4,
+      feedback: "Fix the eyes.",
+      issues: [{ category: "anatomy", severity: "blocking", description: "Eyes misaligned." }],
+    })
+    expect(result.issues?.[0]).toEqual({
+      category: "anatomy",
+      severity: "blocking",
+      description: "Eyes misaligned.",
+    })
+  })
+})

package/src/__tests__/image-mask-mode.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest"
+import { IMAGE_GEN_PROVIDERS } from "../model-constants.js"
+import { IMAGE_MASK_MODE } from "../model-constants.js"
+
+describe("IMAGE_MASK_MODE", () => {
+  it("has an entry for every image-gen provider (completeness invariant)", () => {
+    const missing = IMAGE_GEN_PROVIDERS.filter((p) => IMAGE_MASK_MODE[p] === undefined)
+    expect(missing).toEqual([])
+  })
+
+  it("only uses prompt|composite in Phase 1 (native is reserved for Phase 1.5)", () => {
+    const values = new Set(Object.values(IMAGE_MASK_MODE))
+    expect(values.has("native")).toBe(false)
+    for (const v of values) expect(["prompt", "composite"]).toContain(v)
+  })
+})

package/src/__tests__/image-ref-limit.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest"
+import {
+  imageReferenceLimit,
+  MODELS_WITH_REFERENCE_IMAGE_SUPPORT,
+  REF_IMAGE_MAX_LIMITS,
+  DEFAULT_REF_IMAGE_MAX,
+  T2I_TO_I2I_VARIANT,
+} from "../model-constants.js"
+
+describe("imageReferenceLimit", () => {
+  // The exact models Studio's curated Framing menu exposes (platform brief).
+  // Values mirror the platform's product cap (REF_IMAGE_MAX_LIMITS), resolved
+  // through the T2I→i2i auto-route when the picked id is a text-to-image model.
+  const EXPECTED: Record<string, number> = {
+    "nano-banana-pro": 8,
+    "flux-2-max": 8,
+    "gpt-image-2": 16, // → gpt-image-2-i2i
+    "seedream-5-lite": 16, // → seedream-5-lite-i2i
+    "nano-banana-2": 4,
+    flux: 4, // → flux-pro-i2i
+    "flux-2-klein": 1, // product cap (schema array slices at 5)
+    "flux-2-pro": 4, // product cap (BFL schema accepts 8)
+    "flux-flex": 4, // → flux-i2i
+    "flux-kontext": 1,
+    "flux-kontext-max": 1,
+    grok: 1, // → grok-i2i
+    qwen: 1, // → qwen-i2i
+    "wan-2.7": 9,
+  }
+
+  it.each(Object.entries(EXPECTED))(
+    "%s advertises %i reference image(s)",
+    (provider, cap) => {
+      expect(imageReferenceLimit(provider)).toBe(cap)
+    },
+  )
+
+  it("returns 0 for image models with no reference-image support", () => {
+    for (const p of [
+      "imagen4",
+      "imagen4-fast",
+      "imagen4-ultra",
+      "ideogram-v3",
+      "z-image",
+    ]) {
+      expect(imageReferenceLimit(p)).toBe(0)
+    }
+  })
+
+  it("returns 0 for undefined / empty / unknown provider", () => {
+    expect(imageReferenceLimit(undefined)).toBe(0)
+    expect(imageReferenceLimit("")).toBe(0)
+    expect(imageReferenceLimit("not-a-real-model")).toBe(0)
+  })
+
+  it("resolves every T2I provider to its auto-routed i2i sibling's cap", () => {
+    // A T2I provider's advertised cap is its i2i sibling's cap (the endpoint
+    // that actually consumes the references) — never the t2i id's own default.
+    for (const [t2i, i2i] of Object.entries(T2I_TO_I2I_VARIANT)) {
+      const expected = REF_IMAGE_MAX_LIMITS[i2i] ?? DEFAULT_REF_IMAGE_MAX
+      expect(imageReferenceLimit(t2i)).toBe(expected)
+    }
+  })
+
+  it("every reference-capable model advertises a positive cap", () => {
+    for (const p of MODELS_WITH_REFERENCE_IMAGE_SUPPORT) {
+      expect(imageReferenceLimit(p)).toBeGreaterThanOrEqual(1)
+    }
+  })
+
+  it("`> 0` is an exact supports-references gate", () => {
+    // Callers use `imageReferenceLimit(p) > 0` to show/hide the chip (mirrors
+    // videoReferenceSupported). It must agree with the support set exactly.
+    for (const p of MODELS_WITH_REFERENCE_IMAGE_SUPPORT) {
+      expect(imageReferenceLimit(p) > 0).toBe(true)
+    }
+  })
+})

package/src/__tests__/inpaint-region.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest"
+import { describeMaskRegion } from "../inpaint-region.js"
+
+describe("describeMaskRegion", () => {
+  it("maps an upper-left box to the upper-left location with normalized bbox", () => {
+    const r = describeMaskRegion({ x: 10, y: 5, width: 30, height: 40 }, { width: 100, height: 100 })
+    expect(r.location).toBe("the upper-left region")
+    expect(r.normBbox).toEqual({ x: 0.1, y: 0.05, width: 0.3, height: 0.4 })
+    expect(r.fragment).toContain("the upper-left region")
+    expect(r.fragment).toContain("leaving everything else unchanged")
+  })
+
+  it("maps a centered box to the center", () => {
+    const r = describeMaskRegion({ x: 40, y: 40, width: 20, height: 20 }, { width: 100, height: 100 })
+    expect(r.location).toBe("the center")
+  })
+
+  it("clamps a bbox that overflows the image to [0,1]", () => {
+    const r = describeMaskRegion({ x: 90, y: 90, width: 50, height: 50 }, { width: 100, height: 100 })
+    expect(r.normBbox.width).toBe(0.1)
+    expect(r.normBbox.height).toBe(0.1)
+    expect(r.location).toBe("the lower-right region")
+  })
+})

package/src/__tests__/input-field-map-parity.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest"
+import { INPUT_FIELD_MAP } from "../presentation-utils.js"
+import { PARAMETER_NODE_TYPES, getParameterValue } from "../parameter-node-value.js"
+
+/**
+ * INVARIANT: every parameter-node type's INPUT_FIELD_MAP override field (`key`)
+ * must be a field that getParameterValue() actually reads (its FIRST per-
+ * dimension field for multi-dimension pickers). If the two drift, an app /
+ * MCP / SDK input curated for that picker is SILENTLY DROPPED — the override
+ * lands on a field nothing consumes. This test turns that drift into a red CI
+ * build instead of a silent prod bug. (It caught: 29 missing picker entries +
+ * 3 wrong keys — style-guide→text, duration→seconds, aspect-ratio→ratio.)
+ */
+describe("INPUT_FIELD_MAP ↔ getParameterValue parity", () => {
+  const SENTINEL = "__parity_sentinel__"
+  for (const type of PARAMETER_NODE_TYPES) {
+    it(`"${type}" override field actually drives getParameterValue`, () => {
+      const entry = INPUT_FIELD_MAP[type]
+      expect(
+        entry,
+        `INPUT_FIELD_MAP is missing an entry for parameter node "${type}" — its curated app/MCP/SDK input would be dropped (fieldKey falls back to "value").`,
+      ).toBeTruthy()
+      const resolved = getParameterValue({ [entry!.key]: SENTINEL }, type)
+      expect(
+        resolved,
+        `INPUT_FIELD_MAP["${type}"].key = "${entry!.key}" but getParameterValue("${type}") does not read that field — the override would be ignored.`,
+      ).toBe(SENTINEL)
+    })
+  }
+})