@sungen/driver-data-factory 3.2.12-beta.1 → 3.2.12-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-data-factory",
-  "version": "3.2.12-beta.1",
+  "version": "3.2.12-beta.3",
   "description": "Sungen Data Factory capability — standardized test-data generation from a field-type + security knowledge catalog (valid/boundary/invalid + traceability), the .overwrite merge layer, and (opt-in) @dataFactory runtime seeding. Design-time knowledge is runtime-free. Plugs into @sun-asterisk/sungen via the capability SPI.",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -9,12 +9,12 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",
-    "test": "tsx tests/run.ts"
+    "test": "tsx tests/run.ts && tsx tests/golden.ts"
   },
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.2.12-beta.1",
+    "@sun-asterisk/sungen": "3.2.12-beta.3",
     "yaml": "^2.4.0"
   },
   "files": [

package/src/boundary.ts

@@ -0,0 +1,260 @@
+/**
+ * Data Factory — structured boundary expansion + the deterministic validity oracle.
+ *
+ * This replaces the old prose-parsing (`hint.includes('min')`) that produced semantically WRONG data:
+ *   - password `< min` (minLength 7) synthesized a 7-char string — which is VALID, not the invalid
+ *     "below minimum" case it claims to be;
+ *   - integer `min / min+1` collapsed to a single value, dropping one of the two boundary cases.
+ *
+ * A boundary/invalid hint is tokenized into one or more BoundaryPoints — one case per point
+ * (`min / min+1` → two, `min-1 / max+1` → two) — each carrying the value AND its expected validity,
+ * computed by the same oracle that later re-checks the value. So "the rule says valid" and "the value
+ * actually satisfies the constraints" can never silently disagree (that disagreement is a golden-test
+ * failure). Pure, deterministic; no runtime, no LLM.
+ */
+
+export type Validity = 'valid' | 'invalid';
+
+export interface BoundaryPoint {
+  /** Id suffix so one catalog point can expand to several: '' (first), 'b', 'c', … */
+  suffix: string;
+  value: string | null;
+  /** What the oracle expects this value to be — locked by golden tests against the real check. */
+  validity: Validity;
+  /** Human label for the point, e.g. 'min', 'min+1', 'max+1', 'length-1'. */
+  label: string;
+  todo?: string;
+}
+
+const STR_TYPES = new Set(['string', 'password', 'phone', 'postcode', 'katakana']);
+const NUM_TYPES = new Set(['number-integer', 'number-float', 'currency']);
+
+/** Deterministic filler: a string of exactly `n` chars from a charset seed. */
+export function fillLen(n: number, base = 'a'): string {
+  if (!Number.isFinite(n) || n <= 0) return '';
+  return base.repeat(Math.ceil(n / base.length)).slice(0, n);
+}
+
+/** Password seed that satisfies upper+lower+digit for any length ≥ 3. */
+function fillPassword(n: number): string {
+  if (n <= 0) return '';
+  // Prefix guarantees the character classes; pad with lowercase to reach n.
+  const prefix = 'Aa1';
+  if (n <= prefix.length) return prefix.slice(0, n);
+  return prefix + 'a'.repeat(n - prefix.length);
+}
+
+function seedFor(type: string): string {
+  return type === 'password' ? 'PW' : type === 'katakana' ? 'ア' : type === 'phone' || type === 'postcode' ? '0' : 'a';
+}
+
+function fillString(type: string, n: number): string {
+  return type === 'password' ? fillPassword(n) : fillLen(n, seedFor(type));
+}
+
+/** Precision step for a numeric type: 1 for integers/currency(0dp), 10^-dp for floats. */
+function step(type: string, c: Record<string, any>): number {
+  if (type === 'number-float' || (type === 'currency' && Number.isFinite(c.decimalPlaces) && c.decimalPlaces > 0)) {
+    const dp = Number.isFinite(c.decimalPlaces) ? c.decimalPlaces : 2;
+    return Number((1 / Math.pow(10, dp)).toFixed(dp));
+  }
+  return 1;
+}
+
+/** Round to the type's decimal places so we don't emit float noise like 999999.9899999999. */
+function fmtNum(type: string, c: Record<string, any>, n: number): string {
+  if (type === 'number-float' || (type === 'currency' && c.decimalPlaces > 0)) {
+    const dp = Number.isFinite(c.decimalPlaces) ? c.decimalPlaces : 2;
+    return n.toFixed(dp);
+  }
+  return String(Math.round(n));
+}
+
+/** Split a prose hint into per-point segments: "min / min+1" → ["min","min+1"]. */
+function segments(hint: string): string[] {
+  return hint
+    .split(/[/,]/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/** Resolve a single segment to a signed offset off min/max: "< min" → {base:'min',off:-1}. */
+function readOffset(seg: string): { base: 'min' | 'max' | 'length' | null; off: number; label: string } {
+  const s = seg.toLowerCase();
+  const base: 'min' | 'max' | 'length' | null =
+    /\bmax\b|maximum|maxlength|maxlocal|maxtotal/.test(s) ? 'max'
+    : /\bmin\b|minimum|minlength/.test(s) ? 'min'
+    : /exact|length|byte/.test(s) ? 'length'
+    : null;
+  // Offset: explicit ±1 wins; then relational (< / over / exceeds → out-of-range).
+  let off = 0;
+  if (/\+\s*1|plus one|one extra/.test(s)) off = 1;
+  else if (/-\s*1|minus one/.test(s)) off = -1;
+  else if (/<|below|under|less than|shorter/.test(s)) off = -1;
+  else if (/>|over|above|exceed|greater than|longer|too long/.test(s)) off = 1;
+  const sign = off > 0 ? '+1' : off < 0 ? '-1' : '';
+  const label = (base || 'bound') + sign;
+  return { base, off, label };
+}
+
+/**
+ * Expand a length-bounded string hint into one BoundaryPoint per segment.
+ * min/max come from the constraints; a point OUTSIDE [min,max] is invalid, inside/on-edge is valid.
+ */
+function expandLength(type: string, hint: string, c: Record<string, any>): BoundaryPoint[] {
+  const min = c.minLength ?? c.length ?? c.minlength;
+  const max = c.maxLength ?? c.length ?? c.maxlength;
+  const segs = segments(hint);
+  const out: BoundaryPoint[] = [];
+  let idx = 0;
+  for (const seg of segs) {
+    const { base, off, label } = readOffset(seg);
+    const anchor = base === 'max' ? max : base === 'length' ? (c.length ?? max ?? min) : min;
+    if (!Number.isFinite(anchor)) {
+      out.push({ suffix: suffixOf(idx++), value: null, validity: base === null ? 'valid' : 'valid', label, todo: 'minLength/maxLength/length' });
+      continue;
+    }
+    const n = anchor + off;
+    const lo = Number.isFinite(min) ? min : 0;
+    const hi = Number.isFinite(max) ? max : Infinity;
+    const validity: Validity = n >= lo && n <= hi && n >= 1 ? 'valid' : 'invalid';
+    out.push({ suffix: suffixOf(idx++), value: fillString(type, Math.max(0, n)), validity, label });
+  }
+  return out.length ? out : [{ suffix: '', value: null, validity: 'valid', label: 'bound', todo: 'minLength/maxLength' }];
+}
+
+/** Expand a numeric value hint. Float/currency use a precision step, not a fixed ±1. */
+function expandNumeric(type: string, hint: string, c: Record<string, any>): BoundaryPoint[] {
+  const min = c.min, max = c.max;
+  const st = step(type, c);
+  const segs = segments(hint);
+  const out: BoundaryPoint[] = [];
+  let idx = 0;
+  for (const seg of segs) {
+    const s = seg.toLowerCase();
+    // Decimal-places boundary (float): "exact decimal places" valid; "one extra digit" invalid.
+    if (/decimal|precision|extra digit/.test(s)) {
+      const dp = Number.isFinite(c.decimalPlaces) ? c.decimalPlaces : 2;
+      if (/extra|one extra|\+1|too many/.test(s)) {
+        out.push({ suffix: suffixOf(idx++), value: '0.' + '1'.repeat(dp + 1), validity: 'invalid', label: `decimalPlaces+1` });
+      } else {
+        out.push({ suffix: suffixOf(idx++), value: '0.' + '1'.repeat(Math.max(1, dp)), validity: 'valid', label: `decimalPlaces` });
+      }
+      continue;
+    }
+    const { base, off, label } = readOffset(seg);
+    const anchor = base === 'max' ? max : min;
+    if (!Number.isFinite(anchor)) {
+      out.push({ suffix: suffixOf(idx++), value: null, validity: 'valid', label, todo: 'min/max' });
+      continue;
+    }
+    const n = anchor + off * st;
+    const lo = Number.isFinite(min) ? min : -Infinity;
+    const hi = Number.isFinite(max) ? max : Infinity;
+    const validity: Validity = n >= lo && n <= hi ? 'valid' : 'invalid';
+    out.push({ suffix: suffixOf(idx++), value: fmtNum(type, c, n), validity, label });
+  }
+  return out.length ? out : [{ suffix: '', value: null, validity: 'valid', label: 'bound', todo: 'min/max' }];
+}
+
+/** Build an email at a target local or total length while honoring BOTH maxLocal and maxTotal. */
+function synthEmail(c: Record<string, any>, which: 'maxLocal' | 'maxTotal', off: number): string | null {
+  const maxLocal = Number(c.maxLocal);
+  const maxTotal = Number(c.maxTotal);
+  if (which === 'maxLocal') {
+    if (!Number.isFinite(maxLocal)) return null;
+    const localLen = Math.max(1, maxLocal + off);
+    return fillLen(localLen) + '@example.com';
+  }
+  // maxTotal: keep the local part ≤ maxLocal, pad the DOMAIN to reach the total length.
+  if (!Number.isFinite(maxTotal)) return null;
+  const total = maxTotal + off;
+  const localLen = Number.isFinite(maxLocal) ? Math.min(maxLocal, 24) : 24;
+  const fixed = 1 /* @ */ + 4 /* .com */;
+  const subLen = total - localLen - fixed;
+  if (subLen < 1) return fillLen(Math.max(1, total - fixed)) + '@x.io'.slice(0, Math.max(4, fixed));
+  return fillLen(localLen) + '@' + fillLen(subLen) + '.com';
+}
+
+/** Expand an email length hint (single point per catalog entry today, but honors both constraints). */
+function expandEmail(hint: string, c: Record<string, any>): BoundaryPoint[] {
+  const segs = segments(hint);
+  const out: BoundaryPoint[] = [];
+  let idx = 0;
+  for (const seg of segs) {
+    const { off, label } = readOffset(seg);
+    const s = seg.toLowerCase();
+    const which: 'maxLocal' | 'maxTotal' = /total/.test(s) ? 'maxTotal' : 'maxLocal';
+    const value = synthEmail(c, which, off);
+    if (value == null) { out.push({ suffix: suffixOf(idx++), value: null, validity: 'valid', label, todo: which }); continue; }
+    const validity: Validity = satisfiesEmail(value, c) ? 'valid' : 'invalid';
+    out.push({ suffix: suffixOf(idx++), value, validity, label: `${which}${off > 0 ? '+1' : off < 0 ? '-1' : ''}` });
+  }
+  return out.length ? out : [{ suffix: '', value: null, validity: 'valid', label: 'bound', todo: 'maxLocal/maxTotal' }];
+}
+
+function suffixOf(i: number): string {
+  return i === 0 ? '' : String.fromCharCode(96 + i); // 0→'' , 1→'a', 2→'b', … (id becomes CHK-INT-B1, CHK-INT-B1a, …)
+}
+
+/**
+ * Public entry: expand a boundary/invalid hint into structured points.
+ * Returns one point per segment; each carries the value AND the oracle's expected validity.
+ */
+export function expandBoundaryHint(hint: string, type: string, c: Record<string, any>): BoundaryPoint[] {
+  if (type === 'email') return expandEmail(hint, c);
+  if (STR_TYPES.has(type)) return expandLength(type, hint, c);
+  if (NUM_TYPES.has(type)) return expandNumeric(type, hint, c);
+  return [{ suffix: '', value: null, validity: 'valid', label: 'bound', todo: 'value/gen not resolvable' }];
+}
+
+// ---- The validity oracle: does a value structurally satisfy the constraints? --------------------
+
+export function satisfiesEmail(value: string, c: Record<string, any>): boolean {
+  const at = value.indexOf('@');
+  if (at <= 0 || at === value.length - 1) return false;
+  const local = value.slice(0, at);
+  if (Number.isFinite(c.maxLocal) && local.length > c.maxLocal) return false;
+  if (Number.isFinite(c.maxTotal) && value.length > c.maxTotal) return false;
+  return true;
+}
+
+function satisfiesLength(type: string, value: string, c: Record<string, any>): boolean {
+  const min = c.minLength ?? c.length;
+  const max = c.maxLength ?? c.length;
+  if (Number.isFinite(min) && value.length < min) return false;
+  if (Number.isFinite(max) && value.length > max) return false;
+  return true;
+}
+
+function satisfiesNumeric(type: string, value: string, c: Record<string, any>): boolean {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return false;
+  if (Number.isFinite(c.min) && n < c.min) return false;
+  if (Number.isFinite(c.max) && n > c.max) return false;
+  if ((type === 'number-integer') && !Number.isInteger(n)) return false;
+  if ((type === 'number-float' || type === 'currency') && Number.isFinite(c.decimalPlaces)) {
+    const dec = (value.split('.')[1] || '').length;
+    if (dec > c.decimalPlaces) return false;
+  }
+  return true;
+}
+
+/**
+ * The oracle. Given a concrete value and the constraints, decide whether it structurally satisfies
+ * them (length/range/precision — NOT charset/format, which the catalog encodes as literal invalids).
+ * Returns null when the type has no numeric/length constraint to check against (nothing to assert).
+ */
+export function satisfiesConstraints(type: string, value: string | null, c: Record<string, any>): boolean | null {
+  if (value == null) return null;
+  if (type === 'email') return satisfiesEmail(value, c);
+  if (STR_TYPES.has(type)) {
+    if (!Number.isFinite(c.minLength ?? c.length) && !Number.isFinite(c.maxLength ?? c.length)) return null;
+    return satisfiesLength(type, value, c);
+  }
+  if (NUM_TYPES.has(type)) {
+    if (!Number.isFinite(c.min) && !Number.isFinite(c.max) && !Number.isFinite(c.decimalPlaces)) return null;
+    return satisfiesNumeric(type, value, c);
+  }
+  return null;
+}

package/src/cli.ts

@@ -13,6 +13,7 @@ import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 import { loadEffectiveCatalog } from './catalog-loader';
 import { expandFieldMap, renderTestData, type FieldMap } from './generator';
 import { lintFieldMap, summarize } from './lint';
+import { validateGenerated } from './validate';
 import { generateFixture } from './fixture';
 import { ensureDataFactoryReadme } from './readme';
 
@@ -146,6 +147,33 @@ export function registerDataFactoryCommand(program: any): void {
       if (totalErrors) process.exitCode = 1;
     });
 
+  data
+    .command('validate')
+    .description('Verify every generated value is semantically correct (valid values satisfy the constraints; synthesized invalid values violate them)')
+    .option('--screen <name>', 'Validate one unit (default: all field-maps)')
+    .action((opts: { screen?: string }) => {
+      const cwd = process.cwd();
+      ensureDataFactoryReadme(cwd);
+      const names = opts.screen ? [opts.screen] : listFieldMaps(cwd);
+      if (names.length === 0) { console.error('No field-maps under qa/data-factory/*.fields.yaml.'); process.exitCode = 1; return; }
+      const { catalog } = loadEffectiveCatalog(cwd);
+      let totalErrors = 0;
+      for (const name of names) {
+        const map = loadFieldMap(cwd, name);
+        if (!map) { console.error(`✗ ${name}: no field-map`); totalErrors++; continue; }
+        const findings = validateGenerated(map, catalog);
+        const errors = findings.filter((f) => f.severity === 'error').length;
+        const warns = findings.filter((f) => f.severity === 'warn').length;
+        totalErrors += errors;
+        const badge = errors ? '✗' : warns ? '⚠' : '✓';
+        console.log(`${badge} ${name}: ${errors} error · ${warns} warn`);
+        for (const f of findings) {
+          console.log(`${f.severity === 'error' ? '  ✗' : '  ⚠'} [${f.field}] ${f.code}: ${f.message}`);
+        }
+      }
+      if (totalErrors) process.exitCode = 1;
+    });
+
   data
     .command('fixture')
     .description('Generate a CSV import fixture from the field-map (bulk-import / file-upload testing)')

package/src/generator.ts

@@ -10,6 +10,7 @@
  * same output (determinism is an asset). Nothing here reads a live page or an LLM.
  */
 import type { Catalog, FieldType, DataPoint } from './types';
+import { expandBoundaryHint, satisfiesConstraints, type Validity } from './boundary';
 
 export interface FieldDef {
   name: string;
@@ -57,6 +58,19 @@ export interface ExpandedPoint {
   open?: boolean;
   /** Value could not be synthesized deterministically (missing constraint) — needs input. */
   todo?: string;
+  /**
+   * The generator's expectation for this value: does it satisfy the field's constraints (`valid`) or
+   * violate them (`invalid`)? Computed by the boundary oracle for synthesized points; `valid` for the
+   * happy-path group and `invalid` for declared-invalid values. `validateGenerated` re-checks it — a
+   * mismatch (a `valid`-expected value that fails the constraints, or vice versa) is a defect.
+   */
+  expectedValidity?: Validity;
+  /**
+   * True when the VALUE was synthesized from a numeric/length boundary (so its whole validity claim is
+   * about range). The validator only second-guesses an `invalid` point when it is synthesized — a
+   * literal charset/format invalid (or a security payload) legitimately satisfies the length oracle.
+   */
+  synthesized?: boolean;
 }
 
 export interface ExpandedField {
@@ -70,76 +84,11 @@ export interface ExpandedField {
   dependsOn?: { field: string; value?: string };
 }
 
-/** Deterministic filler: a string of exactly `n` chars from a charset seed. */
-function fillLen(n: number, base = 'a'): string {
-  if (!Number.isFinite(n) || n <= 0) return '';
-  return base.repeat(n).slice(0, n);
-}
-
-/** Build an email of a given total or local length (half-width), with a boundary offset (-1/0/+1). */
-function synthEmail(constraints: Record<string, any>, which: 'maxLocal' | 'maxTotal', offset = 0): string | null {
-  const domain = '@example.com';
-  if (which === 'maxLocal' && Number.isFinite(constraints.maxLocal)) {
-    return fillLen(constraints.maxLocal + offset) + domain;
-  }
-  if (which === 'maxTotal' && Number.isFinite(constraints.maxTotal)) {
-    const localLen = Math.max(1, constraints.maxTotal + offset - domain.length);
-    return fillLen(localLen) + domain;
-  }
-  return null;
-}
-
-/** Try to synthesize a boundary/gen value from constraints. Returns null when data is insufficient. */
-function synthesize(dp: DataPoint, type: string, c: Record<string, any>): { value: string | null; todo?: string } {
-  if (dp.value != null) return { value: dp.value };
-  const hint = `${dp.gen || ''} ${dp.note || ''}`.toLowerCase();
-
-  // Email length boundaries. `>` / "over" → over-boundary (invalid, offset +1).
-  if (type === 'email') {
-    const over = hint.includes('>') || hint.includes('over');
-    const offset = over ? 1 : hint.includes('-1') ? -1 : hint.includes('+1') ? 1 : 0;
-    if (hint.includes('maxlocal') || (hint.includes('local') && (hint.includes('max') || over))) {
-      const v = synthEmail(c, 'maxLocal', offset); return v ? { value: v } : { value: null, todo: 'maxLocal' };
-    }
-    if (hint.includes('maxtotal') || hint.includes('total')) {
-      const v = synthEmail(c, 'maxTotal', offset); return v ? { value: v } : { value: null, todo: 'maxTotal' };
-    }
-  }
-
-  // String-length types: min / max length boundaries.
-  const strTypes = ['string', 'password', 'phone', 'postcode', 'katakana'];
-  if (strTypes.includes(type)) {
-    const min = c.minLength ?? c.length;
-    const max = c.maxLength ?? c.length;
-    if (hint.includes('min') && Number.isFinite(min)) {
-      const n = hint.includes('+1') ? min + 1 : min;
-      return { value: fillLen(n, type === 'password' ? 'Aa1' : 'a') };
-    }
-    if (hint.includes('max') && Number.isFinite(max)) {
-      const n = hint.includes('-1') ? max - 1 : max;
-      return { value: fillLen(n, type === 'password' ? 'Aa1' : 'a') };
-    }
-    return { value: null, todo: 'minLength/maxLength' };
-  }
-
-  // Numeric types: min / max value boundaries.
-  const numTypes = ['number-integer', 'number-float', 'currency'];
-  if (numTypes.includes(type)) {
-    const min = c.min, max = c.max;
-    if (hint.includes('min') && Number.isFinite(min)) {
-      if (hint.includes('-1')) return { value: String(min - 1) };
-      if (hint.includes('+1')) return { value: String(min + 1) };
-      return { value: String(min) };
-    }
-    if (hint.includes('max') && Number.isFinite(max)) {
-      if (hint.includes('+1')) return { value: String(max + 1) };
-      if (hint.includes('-1')) return { value: String(max - 1) };
-      return { value: String(max) };
-    }
-    return { value: null, todo: 'min/max' };
-  }
-
-  return { value: null, todo: 'value/gen not resolvable' };
+/** A gen hint that references a numeric/length boundary the generator can expand structurally. */
+function isBoundaryHint(hint: string): boolean {
+  return /\bmin\b|\bmax\b|minimum|maximum|length|byte|exact|decimal|precision|local|total|over|below|under|exceed|\+\s*1|-\s*1|<|>/.test(
+    hint.toLowerCase(),
+  );
 }
 
 function resolveError(dp: DataPoint, errorMap?: Record<string, string>): { expectedError?: string; open?: boolean } {
@@ -179,26 +128,60 @@ export function expandField(field: FieldDef, catalog: Catalog): ExpandedField {
   if (!ft) return { name: field.name, type: field.type, blindSpot: true, points: [], ...(field.dependsOn ? { dependsOn: field.dependsOn } : {}) };
 
   const c = { ...(ft.constraints || {}), ...(field.constraints || {}) };
+  const type = field.type as string;
   const points: ExpandedPoint[] = [];
 
-  const push = (dp: DataPoint, group: ExpandedPoint['group']) => {
-    const s = synthesize(dp, field.type, c);
-    // Uniqueness: only the VALID (happy-path create) value gets a fresh-per-run suffix. Boundary/invalid
-    // stay literal — they test rules, not record creation.
-    const value = group === 'valid' && field.unique && s.value != null
-      ? makeUnique(s.value, field.type)
-      : s.value;
-    points.push({
+  // Default validity for a group: the happy path is valid; the invalid group is invalid; a boundary
+  // point's validity is decided per-point by the oracle (in/out of range).
+  const groupValidity = (group: ExpandedPoint['group']): Validity => (group === 'invalid' ? 'invalid' : 'valid');
+
+  const emit = (p: Omit<ExpandedPoint, 'expectedValidity'> & { expectedValidity: Validity }) => points.push(p);
+
+  const pushLiteral = (dp: DataPoint, group: ExpandedPoint['group'], value: string | null, opts: { validity?: Validity; label?: string; todo?: string } = {}) => {
+    const isUniqueValid = group === 'valid' && field.unique && value != null;
+    const v = isUniqueValid ? makeUnique(value!, type) : value;
+    // Oracle: if the constraints can judge this value, they win; else fall back to declared/group validity.
+    const oracle = satisfiesConstraints(type, isUniqueValid ? value : v, c);
+    const validity: Validity = dp.validity ?? (oracle == null ? (opts.validity ?? groupValidity(group)) : oracle ? 'valid' : 'invalid');
+    emit({
       id: dp.id,
       group,
-      value,
-      todo: s.todo,
+      value: v,
+      todo: opts.todo,
       reason: dp.reason,
-      note: field.unique && group === 'valid' && s.value != null ? `${dp.note ? dp.note + ' · ' : ''}fresh per run` : dp.note,
+      note: isUniqueValid ? `${dp.note ? dp.note + ' · ' : ''}fresh per run` : (opts.label ? `${dp.note ? dp.note + ' · ' : ''}${opts.label}` : dp.note),
+      expectedValidity: validity,
       ...resolveError(dp, field.errorMap),
     });
   };
 
+  const push = (dp: DataPoint, group: ExpandedPoint['group']) => {
+    // Literal value in the catalog/overwrite → one point (oracle still judges its validity).
+    if (dp.value != null) return pushLiteral(dp, group, dp.value);
+
+    const hint = `${dp.gen || ''} ${dp.note || ''}`.trim();
+    // A boundary/length/numeric hint → expand to one case PER boundary point, each with its validity.
+    if (hint && isBoundaryHint(hint)) {
+      const pts = expandBoundaryHint(hint, type, c);
+      for (const bp of pts) {
+        emit({
+          id: dp.id + bp.suffix,
+          group,
+          value: bp.value,
+          todo: bp.todo,
+          reason: dp.reason,
+          note: bp.label && !bp.todo ? `${dp.note ? dp.note + ' · ' : ''}${bp.label}` : dp.note,
+          expectedValidity: dp.validity ?? bp.validity,
+          synthesized: bp.value != null,
+          ...resolveError(dp, field.errorMap),
+        });
+      }
+      return;
+    }
+    // A non-boundary gen (charset/full-width/format) — can't synthesize deterministically; keep open.
+    pushLiteral(dp, group, null, { validity: groupValidity(group), todo: dp.gen ? `synthesize: ${dp.gen}` : 'value/gen not resolvable' });
+  };
+
   for (const dp of ft.valid || []) push(dp, 'valid');
   for (const dp of ft.boundary || []) push(dp, 'boundary');
   for (const dp of ft.invalid || []) {
@@ -218,6 +201,8 @@ export function expandField(field: FieldDef, catalog: Catalog): ExpandedField {
         todo: p.value == null ? `security technique: ${p.technique || bank}` : undefined,
         reason: `${bank}: ${(p.reason as string) || (p.kind as string) || (p.technique as string) || ''}`.trim(),
         note: b.oracle,
+        // Adversarial payloads are treated as invalid input (must be rejected/escaped, never accepted).
+        expectedValidity: 'invalid',
       });
     }
   }
@@ -259,8 +244,8 @@ function renderOne(f: ExpandedField): Record<string, any> {
   return {
     ...dep,
     valid: valid[0]?.value ?? null,
-    boundary: boundary.map((p) => trim({ id: p.id, value: p.value, note: p.note, todo: p.todo })),
-    invalid: invalid.map((p) => trim({ id: p.id, value: p.value, expected_error: p.expectedError, open: p.open, reason: p.reason, todo: p.todo })),
+    boundary: boundary.map((p) => trim({ id: p.id, value: p.value, expected: p.expectedValidity, note: p.note, todo: p.todo })),
+    invalid: invalid.map((p) => trim({ id: p.id, value: p.value, expected: p.expectedValidity, expected_error: p.expectedError, open: p.open, reason: p.reason, todo: p.todo })),
   };
 }
 

package/src/index.ts

@@ -23,6 +23,10 @@ export { expandField, expandFieldMap, renderTestData } from './generator';
 export type { FieldDef, FieldMap, ExpandedField, ExpandedPoint } from './generator';
 export { lintFieldMap, summarize } from './lint';
 export type { LintIssue } from './lint';
+export { validateGenerated, validatePoints } from './validate';
+export type { ValidationFinding } from './validate';
+export { expandBoundaryHint, satisfiesConstraints } from './boundary';
+export type { Validity, BoundaryPoint } from './boundary';
 export { registerDataFactoryCommand } from './cli';
 export { generateFixture } from './fixture';
 export type { FixtureResult } from './fixture';

package/src/sensor.ts

@@ -17,6 +17,7 @@ import { parse as parseYaml } from 'yaml';
 import type { Sensor } from '@sun-asterisk/sungen';
 import { loadEffectiveCatalog } from './catalog-loader';
 import { lintFieldMap, summarize } from './lint';
+import { validateGenerated } from './validate';
 import type { FieldMap } from './generator';
 
 export const dataFactoryCoverageSensor: Sensor<{ dir: string; cwd: string }> = {
@@ -49,6 +50,17 @@ export const dataFactoryCoverageSensor: Sensor<{ dir: string; cwd: string }> = {
         severity: 'warn',
       });
     }
+    // Semantic validity (M1): a value labeled valid that violates the constraints (or a synthesized
+    // boundary that lands in-range) — the "structurally right but semantically wrong" class.
+    for (const v of validateGenerated(map, catalog)) {
+      findings.push({
+        sensorId: 'data-factory-coverage',
+        capability: 'data-factory',
+        scenario: v.field,
+        message: `DATA-FACTORY-${v.code}: ${v.message}`,
+        severity: v.severity,
+      });
+    }
     if (findings.length) {
       const s = summarize(issues);
       findings.unshift({

package/src/types.ts

@@ -18,6 +18,12 @@ export interface DataPoint {
   /** Pull values from a security bank (e.g. `security/sqli`) into this group. */
   from?: string;
   note?: string;
+  /**
+   * Optional explicit validity for this point (`valid` | `invalid`). Normally the generator's oracle
+   * computes it from the constraints; set this only to pin an intent the constraints can't express
+   * (e.g. a format-invalid value whose length happens to sit inside the range).
+   */
+  validity?: 'valid' | 'invalid';
 }
 
 export interface FieldType {

package/src/validate.ts

@@ -0,0 +1,77 @@
+/**
+ * Data Factory — the deterministic data-quality validator (the Driver's contribution to the harness).
+ *
+ * `lint.ts` answers "is the coverage enough?" (≥1 valid, boundary present, error codes mapped).
+ * This module answers the harder question both reviews flagged: "is each generated value SEMANTICALLY
+ * correct?" — i.e. does a value labeled `valid` actually satisfy the constraints, and does a value
+ * labeled `invalid` actually violate them? It is the machine oracle a future Master "Data Gate"
+ * (see docs/spec/data-factory-quality-roadmap.md) calls; today it powers the golden tests and the
+ * `sungen data validate` CLI. Pure + deterministic — no AI, no runtime.
+ */
+import type { Catalog } from './types';
+import { expandFieldMap, type FieldMap, type FieldDef, type ExpandedField, type ExpandedPoint } from './generator';
+import { satisfiesConstraints } from './boundary';
+
+export interface ValidationFinding {
+  field: string;
+  pointId: string;
+  severity: 'error' | 'warn';
+  code: 'VALUE_NOT_VALID' | 'INVALID_LOOKS_VALID';
+  message: string;
+}
+
+/** Validate the values a set of expanded points, given the effective constraints for that field. */
+export function validatePoints(field: string, type: string | undefined, points: ExpandedPoint[], c: Record<string, any>): ValidationFinding[] {
+  const out: ValidationFinding[] = [];
+  if (!type) return out;
+  for (const p of points) {
+    if (p.value == null) continue; // open/todo — lint handles these
+    const oracle = satisfiesConstraints(type, p.value, c);
+    if (oracle == null) continue; // no length/range constraint to judge against
+    if (p.expectedValidity === 'valid' && oracle === false) {
+      out.push({
+        field, pointId: p.id, severity: 'error', code: 'VALUE_NOT_VALID',
+        message: `${p.id}: value ${JSON.stringify(p.value)} is expected VALID but violates the field constraints (${describe(type, c)})`,
+      });
+    } else if (p.expectedValidity === 'invalid' && oracle === true && p.synthesized) {
+      // Only second-guess a SYNTHESIZED (boundary/range) invalid: its whole claim is about range, so
+      // satisfying the range means the boundary was mis-synthesized. Literal charset/format invalids and
+      // security payloads legitimately pass the length oracle — not a finding.
+      out.push({
+        field, pointId: p.id, severity: 'warn', code: 'INVALID_LOOKS_VALID',
+        message: `${p.id}: value ${JSON.stringify(p.value)} is expected INVALID (out of range) but satisfies the constraints (${describe(type, c)}) — the boundary was mis-synthesized`,
+      });
+    }
+  }
+  return out;
+}
+
+function describe(type: string, c: Record<string, any>): string {
+  const parts: string[] = [];
+  if (Number.isFinite(c.minLength ?? c.length)) parts.push(`minLen=${c.minLength ?? c.length}`);
+  if (Number.isFinite(c.maxLength ?? c.length)) parts.push(`maxLen=${c.maxLength ?? c.length}`);
+  if (Number.isFinite(c.min)) parts.push(`min=${c.min}`);
+  if (Number.isFinite(c.max)) parts.push(`max=${c.max}`);
+  if (Number.isFinite(c.maxLocal)) parts.push(`maxLocal=${c.maxLocal}`);
+  if (Number.isFinite(c.maxTotal)) parts.push(`maxTotal=${c.maxTotal}`);
+  if (Number.isFinite(c.decimalPlaces)) parts.push(`decimalPlaces=${c.decimalPlaces}`);
+  return parts.join(', ') || type;
+}
+
+/** Validate a whole field-map: expand it, then check every value against its expected validity. */
+export function validateGenerated(map: FieldMap, catalog: Catalog): ValidationFinding[] {
+  const expanded = expandFieldMap(map, catalog);
+  const out: ValidationFinding[] = [];
+  const walk = (efs: ExpandedField[], defs: FieldDef[], prefix: string) => {
+    for (const ef of efs) {
+      const def = defs.find((d) => d.name === ef.name);
+      const path = prefix ? `${prefix}.${ef.name}` : ef.name;
+      if (ef.children) { walk(ef.children, def?.fields || [], path); continue; }
+      const ft = ef.type ? catalog.fieldTypes[ef.type] : undefined;
+      const c = { ...(ft?.constraints || {}), ...(def?.constraints || {}) };
+      out.push(...validatePoints(path, ef.type, ef.points, c));
+    }
+  };
+  walk(expanded, map.fields, '');
+  return out;
+}