@lokascript/framework 2.7.2 → 2.9.0

package/dist/api/index.js

@@ -1282,10 +1282,12 @@ function buildTokens(schema, profile, keyword, alternatives) {
       addRoleWithMarker(tokens, role, profile);
     }
   } else if (profile.wordOrder === "SOV") {
+    const preVerb = [];
+    const postVerb = [];
     for (const role of sortedRoles) {
-      addRoleWithMarker(tokens, role, profile);
+      addRoleWithMarker(role.sovSlot === "postVerb" ? postVerb : preVerb, role, profile);
     }
-    tokens.push(keywordToken);
+    tokens.push(...preVerb, keywordToken, ...postVerb);
   } else if (profile.wordOrder === "VSO") {
     tokens.push(keywordToken);
     for (const role of sortedRoles) {
@@ -1368,28 +1370,130 @@ function buildExtractionRules(schema, profile) {
   return rules;
 }
 function buildFormatString(schema, profile, keyword) {
-  const parts = [];
-  if (profile.wordOrder === "SVO" || profile.wordOrder === "VSO") {
-    parts.push(keyword);
-  }
-  for (const role of schema.roles) {
+  const isSOV = profile.wordOrder === "SOV";
+  const preVerb = [];
+  const postVerb = [];
+  const sortedRoles = sortRolesByWordOrder(schema.roles, profile.wordOrder);
+  for (const role of sortedRoles) {
     const marker = getMarkerForRole(role, profile);
     const roleName = `{${role.role}}`;
+    const bucket = isSOV && role.sovSlot === "postVerb" ? postVerb : preVerb;
     if (marker) {
       const markerInfo = profile.roleMarkers?.[role.role];
       if (markerInfo?.position === "after") {
-        parts.push(`${roleName} ${marker}`);
+        bucket.push(`${roleName} ${marker}`);
       } else {
-        parts.push(`${marker} ${roleName}`);
+        bucket.push(`${marker} ${roleName}`);
       }
     } else {
-      parts.push(roleName);
+      bucket.push(roleName);
     }
   }
-  if (profile.wordOrder === "SOV") {
-    parts.push(keyword);
+  return (isSOV ? [...preVerb, keyword, ...postVerb] : [keyword, ...preVerb, ...postVerb]).join(
+    " "
+  );
+}
+
+// src/generation/renderer.ts
+function lookupKeyword(keywords, action, language) {
+  return keywords[action]?.[language] ?? action;
+}
+function buildPhrase(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+function buildTablesFromProfiles(schemas, profiles) {
+  const keywords = {};
+  const markers = {};
+  for (const profile of profiles) {
+    for (const [action, kw] of Object.entries(profile.keywords)) {
+      if (!keywords[action]) keywords[action] = {};
+      keywords[action][profile.code] = kw.primary;
+    }
   }
-  return parts.join(" ");
+  for (const schema of schemas) {
+    for (const role of schema.roles) {
+      if (role.markerOverride) {
+        const markerKey = role.role;
+        if (!markers[markerKey]) markers[markerKey] = {};
+        for (const [lang, markerText] of Object.entries(role.markerOverride)) {
+          markers[markerKey][lang] = markerText;
+        }
+      }
+    }
+  }
+  for (const profile of profiles) {
+    if (profile.roleMarkers) {
+      for (const [markerKey, markerDef] of Object.entries(profile.roleMarkers)) {
+        if (!markers[markerKey]) markers[markerKey] = {};
+        markers[markerKey][profile.code] = markerDef.primary;
+      }
+    }
+  }
+  return { keywords, markers };
+}
+function detectWordOrders(profiles) {
+  const sovLanguages = /* @__PURE__ */ new Set();
+  const vsoLanguages = /* @__PURE__ */ new Set();
+  for (const profile of profiles) {
+    if (profile.wordOrder === "SOV") sovLanguages.add(profile.code);
+    if (profile.wordOrder === "VSO") vsoLanguages.add(profile.code);
+  }
+  return { sovLanguages, vsoLanguages };
+}
+function createDomainRenderer(config) {
+  const { schemas, profiles, overrides } = config;
+  let tables;
+  return (node, language) => {
+    const override = overrides?.[node.action];
+    if (override) return override(node, language);
+    tables ?? (tables = buildRenderTables(schemas, profiles));
+    return renderFromSchema(node, language, tables);
+  };
+}
+function buildRenderTables(schemas, profiles) {
+  const { keywords, markers } = buildTablesFromProfiles(schemas, profiles);
+  const { sovLanguages } = detectWordOrders(profiles);
+  const markerPositions = {};
+  for (const profile of profiles) {
+    for (const [role, markerDef] of Object.entries(profile.roleMarkers ?? {})) {
+      if (!markerDef.position) continue;
+      markerPositions[role] ?? (markerPositions[role] = {});
+      markerPositions[role][profile.code] = markerDef.position;
+    }
+  }
+  const schemaMap = /* @__PURE__ */ new Map();
+  for (const s of schemas) schemaMap.set(s.action, s);
+  return { keywords, markers, markerPositions, sovLanguages, schemaMap };
+}
+function renderFromSchema(node, language, tables) {
+  const schema = tables.schemaMap.get(node.action);
+  if (!schema) return null;
+  const keyword = lookupKeyword(tables.keywords, node.action, language);
+  const isSOV = tables.sovLanguages.has(language);
+  const ordered = sortRolesByWordOrder([...schema.roles], isSOV ? "SOV" : "SVO");
+  const preVerb = [];
+  const postVerb = [];
+  for (const role of ordered) {
+    let value = extractRoleValue(node, role.role);
+    if (!value && role.default !== void 0) {
+      value = String(extractValue(role.default));
+    }
+    if (!value) continue;
+    if (role.quoteMultiword && /\s/.test(value) && !/^(["']).*\1$/.test(value)) {
+      value = `"${value}"`;
+    }
+    const markerText = role.renderOverride?.[language] ?? role.markerOverride?.[language] ?? role.renderOverride?.["*"] ?? tables.markers[role.role]?.[language];
+    const markerPosition = role.markerPositionOverride?.[language] ?? role.markerPosition ?? tables.markerPositions[role.role]?.[language] ?? (isSOV ? "after" : "before");
+    const bucket = isSOV && role.sovSlot === "postVerb" ? postVerb : preVerb;
+    if (markerText && markerPosition === "before") {
+      bucket.push(markerText, value);
+    } else if (markerText) {
+      bucket.push(value, markerText);
+    } else {
+      bucket.push(value);
+    }
+  }
+  return isSOV ? buildPhrase(...preVerb, keyword, ...postVerb) : buildPhrase(keyword, ...preVerb, ...postVerb);
 }
 
 // src/grammar/types.ts
@@ -1621,10 +1725,17 @@ import { renderExplicit, renderDocument } from "@lokascript/intent";
 
 // src/api/create-dsl.ts
 var DSLRegistry = class {
-  constructor(config) {
+  /**
+   * @param partiallyTranslatedActions Actions permitted to lack a keyword in
+   *   some configured languages — extension commands, which may be added for a
+   *   subset of the DSL's languages. A built-in command missing a keyword stays
+   *   an error, since that is a domain-authoring mistake.
+   */
+  constructor(config, partiallyTranslatedActions = /* @__PURE__ */ new Set()) {
     this.patterns = /* @__PURE__ */ new Map();
     this.tokenizers = /* @__PURE__ */ new Map();
     this.schemas = config.schemas;
+    this.partiallyTranslatedActions = partiallyTranslatedActions;
     for (const lang of config.languages) {
       this.registerLanguage(lang);
     }
@@ -1633,6 +1744,9 @@ var DSLRegistry = class {
     this.tokenizers.set(lang.code, lang.tokenizer);
     const patterns = [];
     for (const schema of this.schemas) {
+      if (this.partiallyTranslatedActions.has(schema.action) && !lang.patternProfile.keywords[schema.action]) {
+        continue;
+      }
       const pattern = generatePattern(schema, lang.patternProfile);
       patterns.push(pattern);
     }
@@ -1649,13 +1763,25 @@ var DSLRegistry = class {
   }
 };
 var MultilingualDSLImpl = class {
-  constructor(config, registry, transformer) {
+  constructor(config, registry, transformer, profileProvider) {
     this.registry = registry;
     this.matcher = new PatternMatcher();
     this.transformer = transformer;
+    this.profileProvider = profileProvider;
     if (config.codeGenerator) {
       this.codeGenerator = config.codeGenerator;
     }
+    if (config.renderer) {
+      this.domainRenderer = config.renderer;
+    }
+    this.extensionRenderers = /* @__PURE__ */ new Map();
+    for (const extension of config.extensions ?? []) {
+      if (extension.render) this.extensionRenderers.set(extension.schema.action, extension.render);
+    }
+    this.schemaFallbackRenderer = createDomainRenderer({
+      schemas: config.schemas,
+      profiles: config.languages.map((l) => l.patternProfile)
+    });
     const schemaMap = new Map(config.schemas.map((s) => [s.action, s]));
     this.schemaLookup = {
       getSchema: (action) => schemaMap.get(action)
@@ -1717,6 +1843,13 @@ var MultilingualDSLImpl = class {
   }
   translate(input, fromLanguage, toLanguage) {
     if (isExplicitSyntax(input)) return input;
+    for (const language of [fromLanguage, toLanguage]) {
+      if (!this.profileProvider.getProfile(language)) {
+        throw new Error(
+          `translate() requires a grammar profile for language "${language}", but none is configured. Set 'grammarProfile' on the LanguageConfig for "${language}" in createMultilingualDSL() (parse/validate/compile do not need it), or inject a custom 'profileProvider'.`
+        );
+      }
+    }
     return this.transformer.transform(input, fromLanguage, toLanguage);
   }
   compile(input, language) {
@@ -1745,6 +1878,18 @@ var MultilingualDSLImpl = class {
       };
     }
   }
+  render(node, language) {
+    const extensionRenderer = this.extensionRenderers.get(node.action);
+    if (extensionRenderer) {
+      const rendered = extensionRenderer(node, language);
+      if (rendered != null) return rendered;
+    }
+    if (this.domainRenderer) {
+      const rendered = this.domainRenderer(node, language);
+      if (rendered != null) return rendered;
+    }
+    return this.schemaFallbackRenderer(node, language);
+  }
   getSupportedLanguages() {
     return this.registry.getSupportedLanguages();
   }
@@ -1769,15 +1914,80 @@ function createDefaultProfileProvider(config) {
   }
   return new InMemoryProfileProvider(profiles);
 }
+function applyExtensions(config) {
+  const extensions = config.extensions;
+  if (!extensions || extensions.length === 0) return config;
+  const configuredLanguages = new Set(config.languages.map((l) => l.code));
+  const actions = new Set(config.schemas.map((s) => s.action));
+  for (const extension of extensions) {
+    const { action } = extension.schema;
+    if (actions.has(action)) {
+      throw new Error(
+        `Extension command "${action}" collides with a command this DSL already defines. Pick a different action name.`
+      );
+    }
+    actions.add(action);
+    for (const code of Object.keys(extension.vocabulary)) {
+      if (!configuredLanguages.has(code)) {
+        throw new Error(
+          `Extension command "${action}" supplies vocabulary for language "${code}", which is not configured on this DSL. Configured languages: ${[...configuredLanguages].join(", ")}.`
+        );
+      }
+    }
+  }
+  const schemas = [...config.schemas, ...extensions.map((e) => e.schema)];
+  const languages = config.languages.map((lang) => {
+    const keywords = { ...lang.patternProfile.keywords };
+    let roleMarkers = lang.patternProfile.roleMarkers;
+    for (const extension of extensions) {
+      const vocabulary = extension.vocabulary[lang.code];
+      if (!vocabulary) continue;
+      keywords[extension.schema.action] = { ...vocabulary.keyword };
+      if (vocabulary.roleMarkers) {
+        roleMarkers = { ...roleMarkers, ...vocabulary.roleMarkers };
+      }
+    }
+    return {
+      ...lang,
+      patternProfile: {
+        ...lang.patternProfile,
+        keywords,
+        ...roleMarkers !== void 0 && { roleMarkers }
+      }
+    };
+  });
+  const extensionGenerators = new Map(
+    extensions.filter((e) => e.generate).map((e) => [e.schema.action, e.generate])
+  );
+  const baseGenerator = config.codeGenerator;
+  const codeGenerator = extensionGenerators.size > 0 ? {
+    generate(node) {
+      const generate = extensionGenerators.get(node.action);
+      if (generate) return generate(node);
+      if (!baseGenerator) {
+        throw new Error(`No code generator for action "${node.action}"`);
+      }
+      return baseGenerator.generate(node);
+    }
+  } : baseGenerator;
+  return {
+    ...config,
+    schemas,
+    languages,
+    ...codeGenerator !== void 0 && { codeGenerator }
+  };
+}
 function createMultilingualDSL(config) {
-  const dictionary = config.dictionary ?? createDefaultDictionary(config);
-  const profileProvider = config.profileProvider ?? createDefaultProfileProvider(config);
+  const effectiveConfig = applyExtensions(config);
+  const extensionActions = new Set((config.extensions ?? []).map((e) => e.schema.action));
+  const dictionary = effectiveConfig.dictionary ?? createDefaultDictionary(effectiveConfig);
+  const profileProvider = effectiveConfig.profileProvider ?? createDefaultProfileProvider(effectiveConfig);
   const transformer = new GrammarTransformer({
     dictionary,
     profileProvider
   });
-  const registry = new DSLRegistry(config);
-  return new MultilingualDSLImpl(config, registry, transformer);
+  const registry = new DSLRegistry(effectiveConfig, extensionActions);
+  return new MultilingualDSLImpl(effectiveConfig, registry, transformer, profileProvider);
 }
 
 // src/prompts/prompt-generator.ts
@@ -1855,7 +2065,9 @@ function buildProtocolSection() {
 3. No spaces around the colon in role:value pairs
 4. Strings with spaces must be quoted: \`patient:"hello world"\`
 5. Selectors start with \`#\`, \`.\`, \`[\`, \`@\`, or \`*\`
-6. Output must be valid bracket syntax: \`[action role:value ...]\``;
+6. A selector containing a space, a combinator (\`>\` \`+\` \`~\`), or a comma must use a selector literal: \`patient:<ul > li/>\`, \`patient:<.a, .b/>\`
+7. Inside a structural role (\`body\`, \`then\`, \`else\`, \`condition\`, \`loop-body\`, \`variable\`, \`catch\`, \`finally\`) a \`[...]\` value is always a nested command. Write an attribute selector there as \`condition:<[data-active]/>\`
+8. Output must be valid bracket syntax: \`[action role:value ...]\``;
   return {
     id: "protocol",
     title: "LSE Protocol",
@@ -1868,6 +2080,7 @@ function buildValueTypeSection() {
 
 | Type | Syntax | Example |
 |------|--------|---------|
+| Selector literal | Delimited by \`<\` and \`/>\` | \`<ul > li/>\`, \`<.a, .b/>\`, \`<[data-id]/>\` |
 | Selector | Starts with \`#\` \`.\` \`[\` \`@\` \`*\` | \`#button\`, \`.active\`, \`[data-id]\` |
 | String | Quoted with \`"\` or \`'\` | \`"hello world"\`, \`'json'\` |
 | Boolean | Exact: \`true\` / \`false\` | \`visible:true\` |
@@ -2736,6 +2949,11 @@ var DomainRegistry = class {
         rendered = typeof renderer === "function" ? renderer(node, to) : renderer.render(node, to);
       } catch {
       }
+    } else if (dsl.render) {
+      try {
+        rendered = dsl.render(node, to);
+      } catch {
+      }
     }
     const roles = {};
     for (const [key, value] of node.roles) {