@lokascript/framework 4.6.0 → 4.8.0

package/dist/generation/index.js

@@ -292,19 +292,611 @@ function renderFromSchema(node, language, tables) {
 
 // src/generation/diagnostics.ts
 import { createDiagnosticCollector, fromError, filterBySeverity } from "@lokascript/intent";
+
+// src/generation/schema-patterns.ts
+function createSchemaPatternGenerator(grammar) {
+  return {
+    generatePattern: (schema, profile, config) => generatePattern2(grammar, schema, profile, config),
+    generateSimplePattern: (schema, profile, config) => generateSimplePattern(grammar, schema, profile, config),
+    generateVerbFirstPattern: (schema, profile, config) => generateVerbFirstPattern(schema, profile, config),
+    generatePatternVariants: (schema, profile, config) => generatePatternVariants2(grammar, schema, profile, config),
+    buildRoleToken
+  };
+}
+function withoutVariantOnlyRoles(schema) {
+  return schema.roles.some((r) => r.variantOnly) ? { ...schema, roles: schema.roles.filter((r) => !r.variantOnly) } : schema;
+}
+function sortRolesByPosition(roles, wordOrder, order) {
+  const sortKey = wordOrder === "SOV" ? "sovPosition" : "svoPosition";
+  return [...roles].sort(
+    (a, b) => order === "ascending" ? (a[sortKey] ?? 99) - (b[sortKey] ?? 99) : (b[sortKey] ?? 0) - (a[sortKey] ?? 0)
+  );
+}
+function resolveMarkerForRole(roleSpec, profile) {
+  const overrideMarker = roleSpec.markerOverride?.[profile.code];
+  const defaultMarker = profile.roleMarkers[roleSpec.role];
+  if (overrideMarker !== void 0) {
+    const alternatives = legacyMarkerAlternatives(roleSpec, profile.code, overrideMarker);
+    return {
+      primary: overrideMarker,
+      ...alternatives && { alternatives },
+      position: defaultMarker?.position ?? "before",
+      isOverride: true
+    };
+  }
+  if (defaultMarker && defaultMarker.primary) {
+    const result = {
+      primary: defaultMarker.primary,
+      position: defaultMarker.position,
+      isOverride: false
+    };
+    if (defaultMarker.alternatives) {
+      result.alternatives = defaultMarker.alternatives;
+    }
+    return result;
+  }
+  return null;
+}
+function legacyMarkerAlternatives(roleSpec, languageCode, overrideMarker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode];
+  if (!legacy?.length) return void 0;
+  const alternatives = [...new Set(legacy)].filter((a) => a && a !== overrideMarker);
+  return alternatives.length ? alternatives : void 0;
+}
+function schemaMarkerAlternatives(roleSpec, languageCode, marker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode] ?? [];
+  const variants = roleSpec.methodCarrier ? [] : roleSpec.markerVariants?.[languageCode] ?? [];
+  const alternatives = [.../* @__PURE__ */ new Set([...legacy, ...variants])].filter((a) => a && a !== marker);
+  return alternatives.length ? alternatives : void 0;
+}
+var defaultConfig2 = {
+  basePriority: 100,
+  generateSimpleVariants: true,
+  generateAlternatives: true
+};
+function generatePattern2(grammar, schema, profile, config = defaultConfig2) {
+  const id = `${schema.action}-${profile.code}-generated`;
+  const priority = config.basePriority ?? 100;
+  const keyword = profile.keywords[schema.action];
+  if (!keyword) {
+    throw new Error(`No keyword translation for '${schema.action}' in ${profile.code}`);
+  }
+  const tokens = buildTokens2(grammar, schema, profile, keyword);
+  const extraction = buildExtractionRulesWithDefaults(schema, profile);
+  const format = buildFormatString2(grammar, schema, profile, keyword);
+  return {
+    id,
+    language: profile.code,
+    command: schema.action,
+    priority,
+    template: {
+      format,
+      tokens
+    },
+    extraction
+  };
+}
+function generateSimplePattern(grammar, schema, profile, config = defaultConfig2) {
+  const optionalRoles = schema.roles.filter((r) => !r.required);
+  if (optionalRoles.length === 0) {
+    return null;
+  }
+  const requiredRoles = schema.roles.filter((r) => r.required);
+  const simpleSchema = {
+    ...schema,
+    roles: requiredRoles
+  };
+  const pattern = generatePattern2(grammar, simpleSchema, profile, config);
+  return {
+    ...pattern,
+    id: `${schema.action}-${profile.code}-generated-simple`,
+    priority: (config.basePriority ?? 100) - 5,
+    // Lower priority than full pattern (was -10)
+    extraction: buildExtractionRulesWithDefaults(schema, profile)
+  };
+}
+function generateVerbFirstPattern(schema, profile, config = defaultConfig2) {
+  if (profile.wordOrder !== "SOV") return null;
+  const requiredRoles = schema.roles.filter((r) => r.required);
+  if (requiredRoles.length !== 1) return null;
+  const keyword = profile.keywords[schema.action];
+  if (!keyword) return null;
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  const roleTokens = requiredRoles.flatMap((r) => {
+    const prefix = r.valuePrefixLiteral?.[profile.code];
+    const words = wordsFor(r, profile.code);
+    const roleToken = {
+      type: "role",
+      role: r.role,
+      optional: false,
+      expectedTypes: r.expectedTypes,
+      ...words ? { words } : {}
+    };
+    return prefix ? [{ type: "literal", value: prefix }, roleToken] : [roleToken];
+  });
+  return {
+    id: `${schema.action}-${profile.code}-generated-verb-first`,
+    language: profile.code,
+    command: schema.action,
+    // Strictly below the canonical (basePriority) and simple (basePriority - 5)
+    // patterns so native order is always preferred.
+    priority: (config.basePriority ?? 100) - 20,
+    template: {
+      format: `${keyword.primary} <${requiredRoles[0].role}>`,
+      tokens: [verbToken, ...roleTokens]
+    },
+    extraction: buildExtractionRulesWithDefaults(schema, profile)
+  };
+}
+function generatePatternVariants2(grammar, schema, profile, config = defaultConfig2) {
+  const patterns = [];
+  const full = schema;
+  schema = withoutVariantOnlyRoles(schema);
+  patterns.push(generatePattern2(grammar, schema, profile, config));
+  if (config.generateSimpleVariants) {
+    const simple = generateSimplePattern(grammar, schema, profile, config);
+    if (simple) {
+      patterns.push(simple);
+    }
+  }
+  for (const omitted of schema.omitRoleVariants ?? []) {
+    const variantSchema = {
+      ...schema,
+      roles: schema.roles.filter((r) => r.role !== omitted)
+    };
+    const variant = generatePattern2(grammar, variantSchema, profile, config);
+    patterns.push({
+      ...variant,
+      id: `${schema.action}-${profile.code}-generated-no-${omitted}`,
+      priority: (config.basePriority ?? 100) - 8
+    });
+  }
+  for (const widen of schema.widenTypeVariants ?? []) {
+    if (widen.excludeLanguages?.includes(profile.code)) continue;
+    const cloneSchema = {
+      ...schema,
+      roles: schema.roles.map(
+        (r) => r.role === widen.role ? { ...r, expectedTypes: [...widen.types] } : r
+      )
+    };
+    const main = generatePattern2(grammar, cloneSchema, profile, config);
+    patterns.push({
+      ...main,
+      id: `${schema.action}-${profile.code}-generated-${widen.idSuffix}`,
+      priority: (config.basePriority ?? 100) - (widen.priorityDelta ?? 15)
+    });
+  }
+  for (const v of full.requiredRoleVariants ?? []) {
+    const variantSchema = {
+      ...full,
+      roles: full.roles.filter((r) => !v.omit?.includes(r.role)).map((r) => {
+        const required = r.role === v.role ? { ...r, required: true } : r;
+        return r.role === v.widen?.role ? { ...required, expectedTypes: [...v.widen.types] } : required;
+      })
+    };
+    const variant = generatePattern2(grammar, variantSchema, profile, config);
+    patterns.push({
+      ...variant,
+      id: `${schema.action}-${profile.code}-generated-${v.idSuffix}`,
+      priority: (config.basePriority ?? 100) + (v.priorityDelta ?? 5)
+    });
+  }
+  if (config.generateVerbFirstVariants !== false) {
+    const verbFirst = generateVerbFirstPattern(schema, profile, config);
+    if (verbFirst) {
+      patterns.push(verbFirst);
+    }
+  }
+  for (const v of schema.rolePrefixLiteralVariants ?? []) {
+    const literal = v.literal[profile.code];
+    if (!literal) continue;
+    const { rolePrefixLiteralVariants: _omitted, ...baseSchema } = schema;
+    const cloneSchema = {
+      ...baseSchema,
+      roles: schema.roles.map(
+        (r) => r.role === v.role ? { ...r, valuePrefixLiteral: { [profile.code]: literal } } : r
+      )
+    };
+    const delta = v.priorityDelta ?? 5;
+    const carrier = v.methodCarrier ? { [v.methodCarrier]: { value: literal } } : {};
+    const main = generatePattern2(grammar, cloneSchema, profile, config);
+    patterns.push({
+      ...main,
+      id: `${schema.action}-${profile.code}-generated-${v.idSuffix}`,
+      priority: (config.basePriority ?? 100) + delta,
+      extraction: { ...main.extraction, ...carrier }
+    });
+    if (config.generateVerbFirstVariants !== false) {
+      const verbFirstUrl = generateVerbFirstPattern(cloneSchema, profile, config);
+      if (verbFirstUrl) {
+        patterns.push({
+          ...verbFirstUrl,
+          id: `${schema.action}-${profile.code}-generated-verb-first-${v.idSuffix}`,
+          priority: (config.basePriority ?? 100) - 20 + delta,
+          extraction: { ...verbFirstUrl.extraction, ...carrier }
+        });
+      }
+    }
+  }
+  return patterns;
+}
+function buildTokens2(grammar, schema, profile, keyword) {
+  const tokens = [];
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  const postVerbRoles = profile.wordOrder === "SOV" ? schema.roles.filter((r) => r.sovSlot === "postVerb") : [];
+  const roleTokens = buildRoleTokens(
+    grammar,
+    postVerbRoles.length ? { ...schema, roles: schema.roles.filter((r) => r.sovSlot !== "postVerb") } : schema,
+    profile
+  );
+  const postVerbTokens = postVerbRoles.length ? buildRoleTokens(grammar, { ...schema, roles: postVerbRoles }, profile) : [];
+  switch (profile.wordOrder) {
+    case "SVO":
+      tokens.push(verbToken);
+      tokens.push(...roleTokens);
+      break;
+    case "SOV":
+      tokens.push(...roleTokens);
+      tokens.push(verbToken);
+      tokens.push(...postVerbTokens);
+      break;
+    case "VSO":
+      tokens.push(verbToken);
+      tokens.push(...roleTokens);
+      break;
+    default:
+      tokens.push(verbToken);
+      tokens.push(...roleTokens);
+  }
+  return collapseAdjacentLiterals(tokens);
+}
+function collapseAdjacentLiterals(tokens) {
+  const out = [];
+  for (const tok of tokens) {
+    const prev = out[out.length - 1];
+    if (prev && prev.type === "literal" && tok.type === "literal" && prev.value === tok.value) {
+      const alts = [...prev.alternatives ?? [], ...tok.alternatives ?? []];
+      if (alts.length) out[out.length - 1] = { ...prev, alternatives: [...new Set(alts)] };
+      continue;
+    }
+    out.push(tok);
+  }
+  return out;
+}
+function buildRoleTokens(grammar, schema, profile) {
+  const tokens = [];
+  const sortedRoles = sortRolesByPosition(schema.roles, profile.wordOrder, grammar.positionOrder);
+  for (const roleSpec of sortedRoles) {
+    const roleToken = buildRoleToken(roleSpec, profile);
+    if (!roleSpec.required) {
+      tokens.push({
+        type: "group",
+        optional: true,
+        tokens: roleToken
+      });
+    } else {
+      tokens.push(...roleToken);
+    }
+  }
+  return tokens;
+}
+function wordsFor(roleSpec, language) {
+  if (!roleSpec.words) return void 0;
+  const words = [...roleSpec.words["*"] ?? [], ...roleSpec.words[language] ?? []];
+  return words.length > 0 ? words : void 0;
+}
+function buildRoleToken(roleSpec, profile) {
+  const tokens = [];
+  const overrideMarker = roleSpec.markerOverride?.[profile.code];
+  const defaultMarker = profile.roleMarkers[roleSpec.role];
+  const suppressMarker = roleSpec.renderOverride?.[profile.code] === "";
+  const words = wordsFor(roleSpec, profile.code);
+  const roleValueToken = {
+    type: "role",
+    role: roleSpec.role,
+    optional: !roleSpec.required,
+    expectedTypes: roleSpec.expectedTypes,
+    // The matcher reads this too — a `'keyword'`-shaped slot holds a fixed
+    // keyword phrase (`using view transition`) and must not be skipped by the
+    // trailing-slot verb guard.
+    ...roleSpec.valueShape !== void 0 ? { valueShape: roleSpec.valueShape } : {},
+    // A greedy role reads up to the next marker the pattern owes (a domain's
+    // SQL condition); its value reader does the reading.
+    ...roleSpec.greedy ? { greedy: true } : {},
+    // A role with a word list reads only one of its words.
+    ...words ? { words } : {}
+  };
+  const prefixLiteral = roleSpec.valuePrefixLiteral?.[profile.code];
+  const pushPrefixed = () => {
+    if (prefixLiteral) tokens.push({ type: "literal", value: prefixLiteral });
+    tokens.push(roleValueToken);
+  };
+  if (overrideMarker !== void 0) {
+    const markerWords = overrideMarker ? overrideMarker.split(/\s+/).filter(Boolean) : [];
+    const isPassthroughOverride = overrideMarker !== void 0 && overrideMarker === roleSpec.markerOverride?.en;
+    const position = roleSpec.markerPositionOverride?.[profile.code] ?? roleSpec.markerPosition ?? defaultMarker?.position ?? (profile.wordOrder === "SOV" && !isPassthroughOverride ? "after" : "before");
+    const optionalMarker = roleSpec.markerOptional?.[profile.code] === true;
+    const pushWord = (word) => {
+      const alternatives = markerWords.length === 1 ? schemaMarkerAlternatives(roleSpec, profile.code, word) ?? [] : [];
+      const literal = {
+        type: "literal",
+        value: word,
+        ...alternatives.length ? { alternatives } : {},
+        ...suppressMarker ? { renderSuppress: true } : {}
+      };
+      tokens.push(optionalMarker ? { type: "group", optional: true, tokens: [literal] } : literal);
+    };
+    if (position === "before") {
+      for (const word of markerWords) pushWord(word);
+      pushPrefixed();
+    } else {
+      pushPrefixed();
+      for (const word of markerWords) pushWord(word);
+    }
+  } else if (defaultMarker) {
+    const asMarker = () => {
+      const alternatives = [
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
+      ].filter((a) => a !== defaultMarker.primary);
+      return {
+        type: "literal",
+        value: defaultMarker.primary,
+        ...alternatives.length ? { alternatives } : {},
+        ...suppressMarker ? { renderSuppress: true } : {}
+      };
+    };
+    const pushMarker = (marker) => {
+      if (!profile.markersOptional && !roleSpec.markerOptional?.[profile.code]) {
+        tokens.push(marker);
+        return;
+      }
+      tokens.push({
+        type: "group",
+        optional: true,
+        ...profile.markersOptional && !roleSpec.markerOptional?.[profile.code] ? { renderRequired: true } : {},
+        tokens: [marker]
+      });
+    };
+    if ((roleSpec.markerPosition ?? defaultMarker.position) === "before") {
+      if (defaultMarker.primary) {
+        pushMarker(asMarker());
+      }
+      pushPrefixed();
+    } else {
+      pushPrefixed();
+      pushMarker(asMarker());
+    }
+  } else {
+    pushPrefixed();
+  }
+  return tokens;
+}
+function buildExtractionRules2(schema, profile) {
+  const rules = {};
+  for (const roleSpec of schema.roles) {
+    const overrideMarker = roleSpec.markerOverride?.[profile.code];
+    const defaultMarker = profile.roleMarkers[roleSpec.role];
+    if (roleSpec.valuePrefixLiteral?.[profile.code]) {
+      rules[roleSpec.role] = { marker: roleSpec.valuePrefixLiteral[profile.code] };
+    } else if (overrideMarker !== void 0) {
+      if (!overrideMarker) {
+        rules[roleSpec.role] = {};
+      } else {
+        const isSingleWord = !/\s/.test(overrideMarker.trim());
+        const markerAlternatives = isSingleWord ? schemaMarkerAlternatives(roleSpec, profile.code, overrideMarker) ?? [] : [];
+        rules[roleSpec.role] = markerAlternatives.length ? { marker: overrideMarker, markerAlternatives } : { marker: overrideMarker };
+      }
+    } else if (defaultMarker && defaultMarker.primary) {
+      const markerAlternatives = [
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
+      ].filter((a) => a !== defaultMarker.primary);
+      rules[roleSpec.role] = markerAlternatives.length ? { marker: defaultMarker.primary, markerAlternatives } : { marker: defaultMarker.primary };
+    } else {
+      rules[roleSpec.role] = {};
+    }
+  }
+  return rules;
+}
+function buildExtractionRulesWithDefaults(schema, profile) {
+  const baseRules = buildExtractionRules2(schema, profile);
+  const rules = {};
+  for (const roleSpec of schema.roles) {
+    const baseRule = baseRules[roleSpec.role] || {};
+    if (!roleSpec.required && roleSpec.default) {
+      rules[roleSpec.role] = { ...baseRule, default: roleSpec.default };
+    } else {
+      rules[roleSpec.role] = baseRule;
+    }
+  }
+  return rules;
+}
+function buildFormatString2(grammar, schema, profile, keyword) {
+  const parts = [];
+  const sortedRoles = sortRolesByPosition(schema.roles, profile.wordOrder, grammar.positionOrder);
+  const roleParts = sortedRoles.map((roleSpec) => {
+    const resolved = resolveMarkerForRole(roleSpec, profile);
+    let part = "";
+    if (resolved && resolved.primary) {
+      if (resolved.position === "before") {
+        part = `${resolved.primary} {${roleSpec.role}}`;
+      } else {
+        part = `{${roleSpec.role}} ${resolved.primary}`;
+      }
+    } else {
+      part = `{${roleSpec.role}}`;
+    }
+    return roleSpec.required ? part : `[${part}]`;
+  });
+  switch (profile.wordOrder) {
+    case "SVO":
+    case "VSO":
+      parts.push(keyword.primary, ...roleParts);
+      break;
+    case "SOV":
+      parts.push(...roleParts, keyword.primary);
+      break;
+    default:
+      parts.push(keyword.primary, ...roleParts);
+  }
+  return parts.join(" ");
+}
+
+// src/generation/pattern-render.ts
+var NESTED_ROLE_BONUS = 5;
+var UNCOVERED_ROLE_PENALTY = 30;
+function pinnedLiteral(rule) {
+  if (rule?.default?.type === "literal") return String(rule.default.value).trim().toLowerCase();
+  if (rule?.value !== void 0) return String(rule.value).trim().toLowerCase();
+  return void 0;
+}
+function selectRenderPattern(node, patterns, hooks) {
+  let candidates = patterns.filter((pattern) => !pattern.parseOnly);
+  if (candidates.length === 0) candidates = patterns;
+  if (hooks.candidates) candidates = hooks.candidates(node, candidates);
+  const pinnedValues = /* @__PURE__ */ new Map();
+  for (const pattern of candidates) {
+    for (const [role, rule] of Object.entries(pattern.extraction ?? {})) {
+      const key = pinnedLiteral(rule);
+      if (key === void 0) continue;
+      const set = pinnedValues.get(role) ?? /* @__PURE__ */ new Set();
+      set.add(key);
+      pinnedValues.set(role, set);
+    }
+  }
+  const scored = candidates.map((pattern) => {
+    let score = pattern.priority;
+    const hasRealRole = (role) => hooks.hasRealRole(node, role);
+    const scoreTokens = (tokens, inGroup) => {
+      for (const token of tokens) {
+        if (token.type === "group") {
+          scoreTokens(token.tokens, true);
+        } else if (token.type === "role") {
+          if (hasRealRole(token.role)) {
+            score += inGroup ? NESTED_ROLE_BONUS : 10;
+          } else if (!inGroup && !token.optional) {
+            score -= 50;
+          }
+        }
+      }
+    };
+    scoreTokens(pattern.template.tokens, false);
+    const slots = /* @__PURE__ */ new Set();
+    const collectSlots = (tokens) => {
+      for (const token of tokens) {
+        if (token.type === "group") collectSlots(token.tokens);
+        else if (token.type === "role") slots.add(token.role);
+      }
+    };
+    collectSlots(pattern.template.tokens);
+    for (const role of node.roles.keys()) {
+      if (hasRealRole(role) && !slots.has(role)) score -= UNCOVERED_ROLE_PENALTY;
+    }
+    for (const [role, rule] of Object.entries(pattern.extraction ?? {})) {
+      const pinnedKey = pinnedLiteral(rule);
+      if (pinnedKey === void 0) continue;
+      const actual = node.roles.get(role);
+      const actualKey = actual?.type === (rule.valueIsExpression ? "expression" : "literal") ? String(
+        actual.type === "expression" ? actual.raw : actual.value
+      ).trim().toLowerCase() : void 0;
+      if (actualKey === pinnedKey) {
+        score += 60;
+      } else if (actualKey === void 0 || pinnedValues.get(role)?.has(actualKey)) {
+        score -= 200;
+      }
+    }
+    score += hooks.adjustScore?.(pattern, node) ?? 0;
+    return { pattern, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  return scored.length > 0 ? scored[0].pattern : null;
+}
+function renderPattern(node, pattern, hooks) {
+  const parts = [];
+  const language = pattern.language;
+  const tokens = pattern.template.tokens;
+  for (let i = 0; i < tokens.length; i++) {
+    hooks.beforeToken?.(tokens, i, parts, node, language);
+    const span = hooks.span?.(tokens, i, node, language, true);
+    if (span !== void 0) {
+      parts.push(span.text);
+      i += span.tokens - 1;
+      continue;
+    }
+    const token = tokens[i];
+    const rendered = renderPatternToken(token, node, language, hooks);
+    if (rendered !== null) {
+      pushPart(hooks, parts, rendered, token, tokens[i - 1], node, language);
+      hooks.afterToken?.(token, parts.length - 1, node);
+    }
+  }
+  return parts;
+}
+function pushPart(hooks, parts, text, token, previous, node, language) {
+  if (hooks.pushPart) hooks.pushPart(parts, text, token, previous, node, language);
+  else parts.push(text);
+}
+function renderPatternToken(token, node, language, hooks) {
+  switch (token.type) {
+    case "literal":
+      return token.renderSuppress ? null : token.value;
+    case "role":
+      return hooks.writeRole(token, node, language);
+    case "group": {
+      const hasRequired = token.tokens.filter((t) => t.type === "role" && !t.optional).every((t) => node.roles.has(t.role));
+      if (!hasRequired && token.optional) {
+        return null;
+      }
+      if (hooks.writeGroup && !hooks.writeGroup(token, node, language)) return null;
+      const groupParts = [];
+      let hasRoleValue = false;
+      for (let i = 0; i < token.tokens.length; i++) {
+        const span = hooks.span?.(token.tokens, i, node, language, false);
+        if (span !== void 0) {
+          groupParts.push(span.text);
+          hasRoleValue = true;
+          i += span.tokens - 1;
+          continue;
+        }
+        const subToken = token.tokens[i];
+        const rendered = renderPatternToken(subToken, node, language, hooks);
+        if (rendered !== null) {
+          pushPart(hooks, groupParts, rendered, subToken, token.tokens[i - 1], node, language);
+          if (subToken.type === "role") hasRoleValue = true;
+        }
+      }
+      if (token.optional && !hasRoleValue && !token.renderRequired) return null;
+      return groupParts.length > 0 ? groupParts.join(" ") : null;
+    }
+    default:
+      return null;
+  }
+}
 export {
   buildPhrase,
   buildTablesFromProfiles,
   createDiagnosticCollector,
   createDomainRenderer,
+  createSchemaPatternGenerator,
   createSchemaRenderer,
   detectWordOrders,
   filterBySeverity,
   fromError,
   generatePattern,
   generatePatternVariants,
+  legacyMarkerAlternatives,
   lookupKeyword,
   lookupMarker,
-  sortRolesByWordOrder
+  renderPattern,
+  resolveMarkerForRole,
+  schemaMarkerAlternatives,
+  selectRenderPattern,
+  sortRolesByWordOrder,
+  withoutVariantOnlyRoles
 };
 //# sourceMappingURL=index.js.map