@litfamily/litgrok 1.0.0

package/.grok/skills/frontend-ui-ux/scripts/design-data.mjs

@@ -0,0 +1,68 @@
+import { createHash } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+import { UiuxContractError } from "./errors.mjs";
+import { readBoundedJson, requireFields } from "./json-boundary.mjs";
+
+export const DATASET_MAX_BYTES = 4 * 1024 * 1024;
+export const DATASET_SCHEMA = "litfamily.design-intelligence/v1";
+export const DATASET_RECORDS = 2277;
+export const DATASET_SHA256 = "a89011236a6ff14e12ec55fccbfab1bbd40ae34614cea5710c022121aa841bb8";
+
+export const defaultDataPath = fileURLToPath(new URL("../data/design-intelligence.json", import.meta.url));
+export const defaultProvenancePath = fileURLToPath(new URL("../PROVENANCE.json", import.meta.url));
+
+export function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+function parseProvenance(path) {
+  const parsed = readBoundedJson(path, {
+    maxBytes: 256 * 1024,
+    invalidCode: "PROVENANCE_INVALID_JSON",
+  });
+  requireFields(parsed.value, ["canonical_dataset"], "PROVENANCE_SCHEMA_INVALID", "PROVENANCE.json");
+  const canonical = parsed.value.canonical_dataset;
+  requireFields(
+    canonical,
+    ["byte_count", "record_count", "schema_version", "sha256"],
+    "PROVENANCE_SCHEMA_INVALID",
+    "canonical_dataset",
+  );
+  return canonical;
+}
+
+export function loadDesignData({
+  dataPath = defaultDataPath,
+  provenancePath = defaultProvenancePath,
+} = {}) {
+  const parsed = readBoundedJson(dataPath, {
+    maxBytes: DATASET_MAX_BYTES,
+    invalidCode: "DATASET_INVALID_JSON",
+  });
+  const provenance = parseProvenance(provenancePath);
+  const actualHash = sha256(parsed.bytes);
+  if (actualHash !== provenance.sha256) {
+    throw new UiuxContractError(
+      "DATASET_HASH_MISMATCH",
+      `dataset SHA-256 ${actualHash} does not match provenance ${provenance.sha256}`,
+    );
+  }
+  requireFields(parsed.value, ["records", "schema_version", "source_commit"], "DATASET_SCHEMA_INVALID", "dataset");
+  if (parsed.value.schema_version !== DATASET_SCHEMA || !Array.isArray(parsed.value.records)) {
+    throw new UiuxContractError("DATASET_SCHEMA_INVALID", `expected ${DATASET_SCHEMA} records`);
+  }
+  if (parsed.value.records.length !== provenance.record_count) {
+    throw new UiuxContractError(
+      "DATASET_RECORD_COUNT_MISMATCH",
+      `dataset has ${parsed.value.records.length} records; provenance requires ${provenance.record_count}`,
+    );
+  }
+  return Object.freeze({
+    bytes: parsed.bytes.length,
+    records: parsed.value.records,
+    schema: parsed.value.schema_version,
+    sha256: actualHash,
+    sourceCommit: parsed.value.source_commit,
+  });
+}

package/.grok/skills/frontend-ui-ux/scripts/errors.mjs

@@ -0,0 +1,12 @@
+export class UiuxContractError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "UiuxContractError";
+    this.code = code;
+    this.details = Object.freeze({ ...details });
+  }
+}
+
+export function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}

package/.grok/skills/frontend-ui-ux/scripts/import-design-intelligence.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import {
+  DATASET_MAX_BYTES,
+  DATASET_RECORDS,
+  DATASET_SHA256,
+  loadDesignData,
+} from "./design-data.mjs";
+import { errorMessage, UiuxContractError } from "./errors.mjs";
+import { readBoundedJson } from "./json-boundary.mjs";
+import { replayPinnedSources, validateSourceManifest } from "./source-replay.mjs";
+
+const DEFAULT_SKILL_ROOT = fileURLToPath(new URL("..", import.meta.url));
+const COMPANIONS = Object.freeze([
+  ["LICENSE", "738f69dfa83db5c347c678fb9d90e560877059f0de93a327c39001bff92dc014"],
+  ["PROVENANCE.json", "a00be969523fe376a07d310b7418be0c41824f01241294bdf00e82eb4d736e87"],
+  ["SOURCE-MANIFEST.json", "9adf471d95aaf17e7866e1c7674cb1a101daae9abdab87c71c96a60f2a58e6fa"],
+  ["THIRD-PARTY-NOTICE.txt", "ca1e7d88104177450ff848296cf9340f5f69aa421c4f215673a72a33c03c927e"],
+]);
+
+function hash(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+function parseArgs(argv) {
+  const options = {};
+  const allowed = new Set(["--skill-root", "--source-root", "--expect-records", "--max-bytes"]);
+  for (let index = 0; index < argv.length; index += 1) {
+    const flag = argv[index];
+    if (flag === "--check") {
+      if (options.check) throw new UiuxContractError("INVALID_ARGUMENT", "duplicate --check");
+      options.check = true;
+      continue;
+    }
+    const value = argv[++index];
+    if (!allowed.has(flag) || value === undefined || value.length === 0) {
+      throw new UiuxContractError("INVALID_ARGUMENT", `invalid importer argument: ${flag ?? ""}`);
+    }
+    const key = flag.slice(2).replace(/-([a-z])/gu, (_, letter) => letter.toUpperCase());
+    if (options[key] !== undefined) throw new UiuxContractError("INVALID_ARGUMENT", `duplicate ${flag}`);
+    options[key] = value;
+  }
+  if (!options.check) throw new UiuxContractError("CHECK_MODE_REQUIRED", "--check is required");
+  if (options.sourceRoot
+    && (options.expectRecords !== String(DATASET_RECORDS)
+      || options.maxBytes !== String(DATASET_MAX_BYTES))) {
+    throw new UiuxContractError(
+      "INVALID_ARGUMENT",
+      `source replay requires --expect-records ${DATASET_RECORDS} --max-bytes ${DATASET_MAX_BYTES}`,
+    );
+  }
+  return options;
+}
+
+function verifyCompanions(skillRoot) {
+  return COMPANIONS.map(([path, expected]) => {
+    const absolutePath = join(skillRoot, path);
+    if (!existsSync(absolutePath)) throw new UiuxContractError("COMPANION_MISSING", path);
+    const actual = hash(readFileSync(absolutePath));
+    if (actual !== expected) {
+      throw new UiuxContractError("COMPANION_HASH_MISMATCH", `${path}: ${actual}`);
+    }
+    return { path, sha256: actual };
+  });
+}
+
+function loadManifest(manifestPath) {
+  const manifest = readBoundedJson(manifestPath, {
+    maxBytes: DATASET_MAX_BYTES,
+    invalidCode: "SOURCE_MANIFEST_INVALID",
+  }).value;
+  validateSourceManifest(manifest);
+  return manifest;
+}
+
+export function runImportCheck(argv) {
+  const options = parseArgs(argv);
+  const skillRoot = resolve(options.skillRoot ?? DEFAULT_SKILL_ROOT);
+  const companions = verifyCompanions(skillRoot);
+  const manifestPath = join(skillRoot, "SOURCE-MANIFEST.json");
+  const manifest = loadManifest(manifestPath);
+  const data = loadDesignData({
+    dataPath: join(skillRoot, "data/design-intelligence.json"),
+    provenancePath: join(skillRoot, "PROVENANCE.json"),
+  });
+  if (data.records.length !== DATASET_RECORDS
+    || data.bytes > DATASET_MAX_BYTES
+    || data.sha256 !== DATASET_SHA256) {
+    throw new UiuxContractError("SOURCE_CONTRACT_MISMATCH", "packaged corpus is outside contract");
+  }
+  const replay = options.sourceRoot
+    ? replayPinnedSources(realpathSync(resolve(options.sourceRoot)), manifest, join(skillRoot, "data/design-intelligence.json"))
+    : null;
+  return {
+    schema_id: "litfamily.design-intelligence-import-check/v1",
+    status: "PASS",
+    dataset: {
+      schema_version: data.schema,
+      record_count: data.records.length,
+      byte_count: data.bytes,
+      sha256: data.sha256,
+      source_commit: data.sourceCommit,
+    },
+    companions,
+    replay,
+  };
+}
+
+function main() {
+  try {
+    process.stdout.write(`${JSON.stringify(runImportCheck(process.argv.slice(2)), null, 2)}\n`);
+  } catch (error) {
+    const code = error instanceof UiuxContractError ? error.code : "SOURCE_CONTRACT_FAILED";
+    process.stderr.write(`${code}: ${errorMessage(error)}\n`);
+    process.exitCode = 2;
+  }
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === realpathSync(process.argv[1])) main();

package/.grok/skills/frontend-ui-ux/scripts/json-boundary.mjs

@@ -0,0 +1,63 @@
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { UiuxContractError } from "./errors.mjs";
+import {
+  decodeStrictUtf8,
+  parseStrictJson,
+  StrictJsonError,
+} from "./strict-json.mjs";
+
+export function readBoundedJson(path, { maxBytes, invalidCode, allowSymlink = false }) {
+  const absolutePath = resolve(path);
+  const stat = lstatSync(absolutePath);
+  if (!stat.isFile() && !stat.isSymbolicLink()) {
+    throw new UiuxContractError(invalidCode, `expected a regular JSON file: ${absolutePath}`);
+  }
+  if (stat.isSymbolicLink() && !allowSymlink) {
+    throw new UiuxContractError(invalidCode, `symlink input requires explicit opt-in: ${absolutePath}`);
+  }
+  const resolvedPath = realpathSync(absolutePath);
+  const bytes = readFileSync(resolvedPath);
+  if (bytes.length > maxBytes) {
+    throw new UiuxContractError(invalidCode, `JSON input exceeds ${maxBytes} bytes`, {
+      actual_bytes: bytes.length,
+      max_bytes: maxBytes,
+    });
+  }
+  let text;
+  let value;
+  try {
+    text = decodeStrictUtf8(bytes);
+    value = parseStrictJson(text);
+  } catch (error) {
+    if (error instanceof StrictJsonError) {
+      const code = error.code === "JSON_SYNTAX_INVALID" ? invalidCode : error.code;
+      throw new UiuxContractError(code, error.message, error.details);
+    }
+    throw new UiuxContractError(invalidCode, `invalid JSON: ${error.message}`);
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new UiuxContractError(invalidCode, "top-level JSON value must be an object");
+  }
+  return { absolutePath, bytes, text, value };
+}
+
+export function requireFields(value, fields, code, label) {
+  const missing = fields.filter((field) => !Object.hasOwn(value, field));
+  if (missing.length > 0) {
+    throw new UiuxContractError(code, `${label} is missing required fields: ${missing.join(", ")}`, {
+      missing,
+    });
+  }
+}
+
+export function rejectUnknownFields(value, allowed, code, label) {
+  const allowedSet = new Set(allowed);
+  const unknown = Object.keys(value).filter((field) => !allowedSet.has(field));
+  if (unknown.length > 0) {
+    throw new UiuxContractError(code, `${label} contains unknown fields: ${unknown.join(", ")}`, {
+      unknown,
+    });
+  }
+}

package/.grok/skills/frontend-ui-ux/scripts/query-design-intelligence.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import { loadDesignData } from "./design-data.mjs";
+import { errorMessage, UiuxContractError } from "./errors.mjs";
+import { normalizeQuery, searchRecords } from "./search.mjs";
+
+const QUERY_MAX_BYTES = 4096;
+const OUTPUT_MAX_BYTES = 256 * 1024;
+const RESULT_MAX = 20;
+
+function parseArgs(argv) {
+  const options = { limit: 5, minScore: 0.000001, json: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const flag = argv[index];
+    if (flag === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (!["--query", "--domain", "--limit", "--min-score", "--data", "--provenance"].includes(flag)) {
+      throw new UiuxContractError("INVALID_ARGUMENT", `unknown argument ${flag}`);
+    }
+    const value = argv[index + 1];
+    if (value === undefined) throw new UiuxContractError("INVALID_ARGUMENT", `${flag} requires a value`);
+    options[flag.slice(2).replace("-", "")] = value;
+    index += 1;
+  }
+  return options;
+}
+
+function positiveNumber(value, fallback, maximum, label, { integer = false } = {}) {
+  if (value !== undefined && typeof value !== "number" && (value.trim() !== value
+    || !/^(?:0|[1-9]\d*)(?:\.\d+)?$/u.test(value)
+    || (integer && !/^[1-9]\d*$/u.test(value)))) {
+    throw new UiuxContractError("INVALID_ARGUMENT", `${label} has invalid numeric syntax`);
+  }
+  const parsed = value === undefined ? fallback : Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed > maximum) {
+    throw new UiuxContractError("INVALID_ARGUMENT", `${label} must be greater than 0 and at most ${maximum}`);
+  }
+  if (integer && !Number.isInteger(parsed)) {
+    throw new UiuxContractError("INVALID_ARGUMENT", `${label} must be an integer`);
+  }
+  return parsed;
+}
+
+export function runQuery(argv) {
+  const options = parseArgs(argv);
+  if (typeof options.query !== "string" || typeof options.domain !== "string") {
+    throw new UiuxContractError("INVALID_ARGUMENT", "--query and --domain are required");
+  }
+  const queryBytes = Buffer.byteLength(options.query, "utf8");
+  if (queryBytes > QUERY_MAX_BYTES) {
+    throw new UiuxContractError(
+      "QUERY_TOO_LARGE",
+      `query is ${queryBytes} bytes; maximum is 4096 bytes`,
+    );
+  }
+  const query = normalizeQuery(options.query);
+  if (query.length === 0) throw new UiuxContractError("QUERY_EMPTY", "--query must contain searchable text");
+  const limit = positiveNumber(options.limit, 5, RESULT_MAX, "--limit", { integer: true });
+  const minScore = positiveNumber(options.minscore, 0.000001, 1_000_000, "--min-score");
+  const data = loadDesignData({
+    dataPath: options.data,
+    provenancePath: options.provenance,
+  });
+  const domains = new Set(data.records.map((record) => record.domain));
+  if (!domains.has(options.domain)) {
+    throw new UiuxContractError("UNKNOWN_DOMAIN", `unknown design-intelligence domain: ${options.domain}`);
+  }
+  const results = searchRecords(data.records, {
+    query,
+    domain: options.domain,
+    limit,
+    minScore,
+  }).map((record) => ({ ...record, dataset_sha256: data.sha256 }));
+  const report = {
+    schema_id: "litfamily.design-intelligence-query/v1alpha1",
+    status: results.length === 0 ? "NO_RESULTS" : "RESULTS",
+    query: options.query,
+    normalized_query: query,
+    domain: options.domain,
+    dataset_sha256: data.sha256,
+    fallback: false,
+    results,
+  };
+  const output = `${JSON.stringify(report, null, 2)}\n`;
+  if (Buffer.byteLength(output) > OUTPUT_MAX_BYTES) {
+    throw new UiuxContractError("OUTPUT_TOO_LARGE", `query output exceeds ${OUTPUT_MAX_BYTES} bytes`);
+  }
+  return output;
+}
+
+function main() {
+  try {
+    process.stdout.write(runQuery(process.argv.slice(2)));
+  } catch (error) {
+    const code = error instanceof UiuxContractError ? error.code : "QUERY_FAILED";
+    process.stderr.write(`${code}: ${errorMessage(error)}\n`);
+    process.exitCode = 2;
+  }
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === realpathSync(process.argv[1])) main();

package/.grok/skills/frontend-ui-ux/scripts/search.mjs

@@ -0,0 +1,43 @@
+const TOKEN_PATTERN = /[\p{L}\p{N}]+/gu;
+
+export function normalizeQuery(input) {
+  return input.normalize("NFKC").toLocaleLowerCase("en-US").trim();
+}
+
+function tokens(input) {
+  return normalizeQuery(String(input)).match(TOKEN_PATTERN) ?? [];
+}
+
+function recordText(record) {
+  return Object.entries(record)
+    .filter(([key, value]) => key !== "No" && typeof value === "string")
+    .map(([, value]) => value)
+    .join(" ");
+}
+
+function scoreRecord(record, queryTokens) {
+  const haystack = tokens(recordText(record));
+  if (haystack.length === 0) return 0;
+  const frequencies = new Map();
+  for (const token of haystack) frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
+  let matches = 0;
+  for (const token of queryTokens) {
+    matches += frequencies.get(token) ?? 0;
+  }
+  return matches / Math.sqrt(haystack.length);
+}
+
+export function searchRecords(records, { query, domain, limit, minScore }) {
+  const queryTokens = tokens(query);
+  if (queryTokens.length === 0) return [];
+  return records
+    .filter((record) => record.domain === domain)
+    .map((record) => ({ record, score: scoreRecord(record, queryTokens) }))
+    .filter(({ score }) => score >= minScore && score > 0)
+    .sort((left, right) => right.score - left.score || left.record.record_id.localeCompare(right.record.record_id))
+    .slice(0, limit)
+    .map(({ record, score }) => ({
+      ...record,
+      score: Number(score.toFixed(8)),
+    }));
+}

package/.grok/skills/frontend-ui-ux/scripts/source-replay.mjs

@@ -0,0 +1,153 @@
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync } from "node:fs";
+import { basename, relative, resolve, sep } from "node:path";
+
+import { stableJson } from "./strict-json.mjs";
+import { DATASET_MAX_BYTES, DATASET_RECORDS, DATASET_SHA256 } from "./design-data.mjs";
+import { UiuxContractError } from "./errors.mjs";
+
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+
+function parseCsv(text, label) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  let closed = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (quoted) {
+      if (char === "\"" && text[index + 1] === "\"") {
+        field += "\""; index += 1;
+      } else if (char === "\"") {
+        quoted = false; closed = true;
+      } else field += char;
+    } else if (closed) {
+      if (char === ",") {
+        row.push(field); field = ""; closed = false;
+      } else if (char === "\n") {
+        row.push(field); rows.push(row); row = []; field = ""; closed = false;
+      } else throw new UiuxContractError("SOURCE_CSV_INVALID", `${label}: data after quote`);
+    } else if (char === "\"" && field.length === 0) quoted = true;
+    else if (char === ",") {
+      row.push(field); field = "";
+    } else if (char === "\n") {
+      row.push(field); rows.push(row); row = []; field = "";
+    } else field += char;
+  }
+  if (quoted) throw new UiuxContractError("SOURCE_CSV_INVALID", `${label}: unterminated quote`);
+  if (closed || field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  if (rows.length < 2 || rows.some((candidate) => candidate.length !== rows[0].length)) {
+    throw new UiuxContractError("SOURCE_CSV_INVALID", `${label}: inconsistent row width`);
+  }
+  return rows;
+}
+
+export function validateSourceManifest(manifest) {
+  if (manifest.schema_version !== "litfamily.source-import-manifest/v1"
+    || manifest.source?.commit !== "1307d97a72e6c1cda572cb65471ae5ce82995218"
+    || !Array.isArray(manifest.sources) || manifest.sources.length !== 34
+    || new Set(manifest.sources.map(({ path }) => path)).size !== 34
+    || manifest.sources.reduce((sum, entry) => sum + entry.normalized_record_count, 0) !== 2277
+    || manifest.sources.some((entry) =>
+      typeof entry.path !== "string" || !/^[a-f0-9]{64}$/u.test(entry.raw_sha256)
+      || !Array.isArray(entry.header) || !Array.isArray(entry.selected_columns)
+      || !Number.isInteger(entry.data_row_count)
+      || entry.normalized_record_count !== entry.data_row_count)) {
+    throw new UiuxContractError("SOURCE_MANIFEST_INVALID", "exact 34-source allowlist is required");
+  }
+}
+
+function sourceBytes(sourceRoot, entry) {
+  const path = resolve(sourceRoot, entry.path);
+  const rel = relative(sourceRoot, path);
+  if (rel === ".." || rel.startsWith(`..${sep}`)) {
+    throw new UiuxContractError("SOURCE_PATH_INVALID", entry.path);
+  }
+  const stat = lstatSync(path);
+  if (stat.isSymbolicLink() || !stat.isFile()) {
+    throw new UiuxContractError("SOURCE_PATH_INVALID", entry.path);
+  }
+  return readFileSync(path);
+}
+
+function normalizeSource(bytes, entry) {
+  if (bytes.includes(0)) throw new UiuxContractError("SOURCE_CSV_INVALID", `${entry.path}: NUL`);
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new UiuxContractError("SOURCE_CSV_INVALID", `${entry.path}: invalid UTF-8`);
+  }
+  text = text.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+  if (entry.repair) {
+    const approved = entry.path === "src/ui-ux-pro-max/data/stacks/javafx.csv"
+      && entry.repair.rule === "backslash_quote_to_rfc4180_double_quote"
+      && entry.repair.occurrences === 18 && text.split("\\\"").length - 1 === 18;
+    if (!approved) throw new UiuxContractError("SOURCE_REPAIR_INVALID", entry.path);
+    text = text.replaceAll("\\\"", "\"\"");
+    if (hash(Buffer.from(text)) !== entry.repair.repaired_sha256) {
+      throw new UiuxContractError("SOURCE_REPAIR_INVALID", `${entry.path}: repaired hash`);
+    }
+  }
+  return text;
+}
+
+function recordsFor(rows, entry) {
+  const header = rows[0];
+  if (JSON.stringify(header) !== JSON.stringify(entry.header)
+    || rows.length - 1 !== entry.data_row_count) {
+    throw new UiuxContractError("SOURCE_SHAPE_MISMATCH", entry.path);
+  }
+  const indexes = entry.selected_columns.map((column) => header.indexOf(column));
+  if (indexes.some((index) => index < 0)) {
+    throw new UiuxContractError("SOURCE_SHAPE_MISMATCH", `${entry.path}: selected columns`);
+  }
+  const stack = entry.path.includes("/stacks/") ? basename(entry.path, ".csv") : undefined;
+  const domain = stack ? `stack/${stack}` : basename(entry.path, ".csv");
+  return rows.slice(1).map((row, offset) => {
+    const record = Object.fromEntries(entry.selected_columns.map(
+      (column, index) => [column, row[indexes[index]].trim()],
+    ));
+    const number = Number(record.No);
+    if (!Number.isSafeInteger(number) || number < 1 || String(number) !== record.No) {
+      throw new UiuxContractError("SOURCE_SHAPE_MISMATCH", `${entry.path}:${offset + 2}`);
+    }
+    record.No = number;
+    record.domain = domain;
+    record.record_id = `${domain}/${number}`;
+    if (stack) record.stack = stack;
+    return record;
+  });
+}
+
+export function replayPinnedSources(sourceRoot, manifest, packagedPath) {
+  const records = [];
+  const ids = new Set();
+  for (const entry of manifest.sources) {
+    const raw = sourceBytes(sourceRoot, entry);
+    if (hash(raw) !== entry.raw_sha256) {
+      throw new UiuxContractError("SOURCE_HASH_MISMATCH", `${entry.path} hash mismatch`);
+    }
+    for (const record of recordsFor(parseCsv(normalizeSource(raw, entry), entry.path), entry)) {
+      if (ids.has(record.record_id)) {
+        throw new UiuxContractError("SOURCE_SHAPE_MISMATCH", `duplicate ${record.record_id}`);
+      }
+      ids.add(record.record_id);
+      records.push(record);
+    }
+  }
+  const bytes = Buffer.from(`${stableJson({
+    records,
+    schema_version: "litfamily.design-intelligence/v1",
+    source_commit: manifest.source.commit,
+  })}\n`);
+  if (records.length !== DATASET_RECORDS || bytes.length > DATASET_MAX_BYTES
+    || hash(bytes) !== DATASET_SHA256 || !readFileSync(packagedPath).equals(bytes)) {
+    throw new UiuxContractError("SOURCE_CONTRACT_MISMATCH", "replayed canonical bytes differ");
+  }
+  return { records: records.length, bytes: bytes.length, sha256: hash(bytes) };
+}