@gafj/gafj 0.1.1

package/core/schemas/lang.js

@@ -0,0 +1,111 @@
+"use strict";
+
+/** Schema language helpers; see index.js for the roster. */
+
+// C0 controls other than tab, newline, and carriage return, plus DEL and the C1 range: nothing a document needs, everything a terminal escape needs.
+// eslint-disable-next-line no-control-regex
+const CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/;
+
+const CLASSES = new Set(["prose", "identifier", "quoted_source", "url", "email"]);
+const CLAIM_KINDS = ["record", "metric", "ownership", "tenure", "history", "quote"];
+
+const CLAIM = {
+  t: "object",
+  fields: {
+    kind: { t: "string", class: "identifier", enum: CLAIM_KINDS },
+    source_id: { t: "string", class: "identifier" },
+    value: { t: "string", class: "identifier" },
+    outcome_key: { t: "string", class: "identifier" },
+    verb: { t: "string", class: "identifier" },
+    subject: { t: "string", class: "identifier" },
+    interview_id: { t: "string", class: "identifier" },
+    document_id: { t: "string", class: "identifier" },
+    person_id: { t: "string", class: "identifier" },
+  },
+  required: ["kind"],
+};
+
+function str(cls, opts = {}) {
+  if (!CLASSES.has(cls)) throw new Error("bad class " + cls);
+  return { t: "string", class: cls, ...opts };
+}
+function claimed(max) {
+  return { t: "object", fields: { text: str("prose", { max, claims: true }), claims: { t: "array", items: CLAIM } }, required: ["text", "claims"], claimed: true };
+}
+function arr(items, min, max) {
+  return { t: "array", items, min, max };
+}
+function obj(fields, required) {
+  return { t: "object", fields, required: required || Object.keys(fields) };
+}
+
+function validate(value, node, path = "$", errors = []) {
+  const fail = (msg) => errors.push({ path, message: msg });
+  if (node.t === "object") {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) { fail("expected an object"); return errors; }
+    for (const r of node.required || []) if (!(r in value)) fail(`missing required field ${r}`);
+    for (const [k, v] of Object.entries(value)) {
+      if (!Object.prototype.hasOwnProperty.call(node.fields, k)) { fail(`unknown field ${k}`); continue; }
+      validate(v, node.fields[k], `${path}.${k}`, errors);
+    }
+  } else if (node.t === "array") {
+    if (!Array.isArray(value)) { fail("expected an array"); return errors; }
+    if (node.min != null && value.length < node.min) fail(`expected at least ${node.min} items`);
+    if (node.max != null && value.length > node.max) fail(`expected at most ${node.max} items`);
+    value.forEach((v, i) => validate(v, node.items, `${path}[${i}]`, errors));
+  } else if (node.t === "string") {
+    if (typeof value !== "string") { fail("expected a string"); return errors; }
+    if (node.max != null && value.length > node.max) fail(`longer than ${node.max} characters`);
+    if (CONTROL.test(value)) fail("control characters are not allowed");
+    if (node.enum && !node.enum.includes(value)) fail(`must be one of ${node.enum.join(", ")}`);
+  } else if (node.t === "number") {
+    if (typeof value !== "number" || !isFinite(value)) fail("expected a number");
+    if (node.min != null && value < node.min) fail(`below ${node.min}`);
+    if (node.max != null && value > node.max) fail(`above ${node.max}`);
+  } else if (node.t === "boolean") {
+    if (typeof value !== "boolean") fail("expected a boolean");
+  }
+  return errors;
+}
+
+/**
+ * Every string field in the content with its class; claim-bearing text
+ * fields carry their sibling claims array.
+ */
+function walk(value, node, path = "$", out = []) {
+  if (node.t === "object" && value && typeof value === "object") {
+    if (node.claimed) {
+      out.push({ path: `${path}.text`, value: String(value.text ?? ""), class: "prose", claims: Array.isArray(value.claims) ? value.claims : [], claimed: true });
+      return out;
+    }
+    for (const [k, sub] of Object.entries(node.fields)) if (Object.prototype.hasOwnProperty.call(value, k)) walk(value[k], sub, `${path}.${k}`, out);
+  } else if (node.t === "array" && Array.isArray(value)) {
+    value.forEach((v, i) => walk(v, node.items, `${path}[${i}]`, out));
+  } else if (node.t === "string" && typeof value === "string") {
+    out.push({ path, value, class: node.class, claims: null, claimed: false });
+  }
+  return out;
+}
+
+/** Field names in a schema, for the no-date and no-floor tests. */
+function fieldNames(node, out = new Set()) {
+  if (node.t === "object") for (const [k, v] of Object.entries(node.fields)) { out.add(k); fieldNames(v, out); }
+  else if (node.t === "array") fieldNames(node.items, out);
+  return out;
+}
+
+function toJsonSchema(node) {
+  if (node.t === "object") {
+    const properties = {};
+    for (const [k, v] of Object.entries(node.fields)) properties[k] = toJsonSchema(v);
+    return { type: "object", properties, required: node.required || [], additionalProperties: false, ...(node.claimed ? { "x-claim-bearing": true } : {}) };
+  }
+  if (node.t === "array") return { type: "array", items: toJsonSchema(node.items), ...(node.min != null ? { minItems: node.min } : {}), ...(node.max != null ? { maxItems: node.max } : {}) };
+  if (node.t === "string") return { type: "string", "x-class": node.class, ...(node.max != null ? { maxLength: node.max } : {}), ...(node.enum ? { enum: node.enum } : {}) };
+  if (node.t === "number") return { type: "number", ...(node.min != null ? { minimum: node.min } : {}), ...(node.max != null ? { maximum: node.max } : {}) };
+  if (node.t === "boolean") return { type: "boolean" };
+  throw new Error("unknown node " + node.t);
+}
+
+
+module.exports = { str, claimed, arr, obj, CLAIM, CLAIM_KINDS, CLASSES, validate, walk, fieldNames, toJsonSchema };

package/core/schemas/onepager.js

@@ -0,0 +1,26 @@
+"use strict";
+const { str, claimed, arr, obj } = require("./lang");
+
+/**
+ * The one-pager, Codification 3.4. One page is a content budget enforced
+ * here, not a measurement: the browser prints it. Round, interviewer, and
+ * datetime come from the store at render time, never from the model.
+ */
+module.exports = obj({
+  posture: str("prose", { max: 90 }),
+  hard_stop: str("prose", { max: 90 }),
+  stories: arr(obj({ lead: str("prose", { max: 40 }), line: claimed(150) }), 3, 5),
+  amber_gaps: arr(claimed(170), 1, 4),
+  answer_keys: arr(obj({ trigger: str("prose", { max: 40 }), key: str("prose", { max: 90 }) }), 3, 6),
+  questions: arr(str("prose", { max: 120 }), 3, 6),
+  do_nots: arr(str("prose", { max: 80 }), 2, 5),
+  technical_page: obj({
+    formulas: arr(str("identifier", { max: 160 }), 0, 8),
+    click_paths: arr(str("prose", { max: 160 }), 0, 6),
+    rules: arr(str("prose", { max: 120 }), 0, 6),
+    recovery_script: str("prose", { max: 240 }),
+    closing_line: str("prose", { max: 200 }),
+  }, []),
+}, ["posture", "stories", "amber_gaps", "answer_keys", "questions", "do_nots"]);
+
+module.exports.BUDGET = { stories: 5, amber_gaps: 4, answer_keys: 6, questions: 6, do_nots: 5, max_chars_total: 2600 };

package/core/schemas/practice.js

@@ -0,0 +1,18 @@
+"use strict";
+const { str, arr, obj } = require("./lang");
+
+/**
+ * A drill workbook spec, Codification 3.6. The manifest (planted rows,
+ * expected flags, formulas) stays on the document so a later grader can
+ * check a drilled workbook against it. No candidate claims live here.
+ */
+module.exports = obj({
+  scenario: str("prose", { max: 800 }),
+  domain: str("prose", { max: 80 }),
+  sheets: arr(obj({ name: str("identifier", { max: 40 }), columns: arr(str("identifier", { max: 40 }), 2, 20), rows: { t: "number", min: 10, max: 5000 } }), 1, 6),
+  anomalies: arr(obj({ kind: str("identifier", { enum: ["overbill", "underbill", "duplicate", "orphan_key", "whitespace", "nbsp", "text_number", "mislabel", "wrong_tier"] }),
+    sheet: str("identifier", { max: 40 }), row: { t: "number", min: 1 }, description: str("prose", { max: 200 }) }), 3, 40),
+  tasks: arr(obj({ text: str("prose", { max: 300 }), minutes: { t: "number", min: 1, max: 60 } }), 3, 12),
+  answer_key: arr(obj({ task: { t: "number", min: 1 }, formula: str("identifier", { max: 300 }), expected: str("identifier", { max: 200 }) }), 3, 40),
+  lesson: str("prose", { max: 400 }),
+}, ["scenario", "domain", "sheets", "anomalies", "tasks", "answer_key"]);

package/core/schemas/prep.js

@@ -0,0 +1,15 @@
+"use strict";
+const { str, claimed, arr, obj } = require("./lang");
+
+/** Interview prep, Codification 3.2. posture is required (ledger rule 10). */
+module.exports = obj({
+  posture: str("prose", { max: 160 }),
+  one_thing: claimed(600),
+  register_note: str("prose", { max: 400 }),
+  stories: arr(obj({ title: str("prose", { max: 80 }), body: claimed(900), why_this_room: str("prose", { max: 300 }) }), 3, 5),
+  deciding_question: obj({ question: str("prose", { max: 200 }), answer: claimed(1200) }),
+  likely_questions: arr(obj({ question: str("prose", { max: 200 }), answer_frame: claimed(900) }), 4, 12),
+  gaps_in_the_open: arr(obj({ gap: str("prose", { max: 120 }), phrasing: claimed(500) }), 0, 5),
+  questions_to_ask: arr(str("prose", { max: 200 }), 6, 8),
+  do_nots: arr(str("prose", { max: 160 }), 3, 10),
+}, ["posture", "one_thing", "stories", "deciding_question", "likely_questions", "gaps_in_the_open", "questions_to_ask", "do_nots"]);

package/core/schemas/resume.js

@@ -0,0 +1,25 @@
+"use strict";
+const { str, claimed, arr, obj } = require("./lang");
+
+/**
+ * Resume output. Identity fields (company, role, dates) are identifiers
+ * copied from the candidate profile's skeleton; the store rejects any that
+ * do not match. Highlights and bullets are claim-bearing.
+ */
+module.exports = obj({
+  headline: str("prose", { max: 80 }),
+  specialties: arr(str("prose", { max: 40 }), 3, 3),
+  headerLinks: arr(str("url"), 0, 3),
+  experienceSectionTitle: str("identifier", { max: 60 }),
+  careerHighlights: arr(obj({ leadIn: str("prose", { max: 60 }), proof: claimed(200) }), 5, 5),
+  experience: arr(obj({
+    company: str("identifier", { max: 120 }),
+    role: str("identifier", { max: 120 }),
+    dates: str("identifier", { max: 40 }),
+    section: str("identifier", { enum: ["experience", "concurrent"] }),
+    scope: str("prose", { max: 220 }),
+    bullets: arr(obj({ text: claimed(320), sourceVariationId: str("identifier"), rewritten: { t: "boolean" } }, ["text"]), 0, 8),
+  }), 1, 14),
+  skills: arr(str("identifier", { max: 60 }), 0, 30),
+  selectionNotes: str("prose", { max: 1200 }),
+}, ["headline", "specialties", "experienceSectionTitle", "careerHighlights", "experience", "skills"]);