@lokascript/domain-flow 2.1.0

package/dist/index.js

@@ -0,0 +1,2169 @@
+// src/index.ts
+import { createMultilingualDSL } from "@lokascript/framework";
+
+// src/schemas/index.ts
+import { defineCommand as defineCommand2, defineRole as defineRole2 } from "@lokascript/framework";
+
+// src/schemas/hateoas-schemas.ts
+import { defineCommand, defineRole } from "@lokascript/framework";
+var enterSchema = defineCommand({
+  action: "enter",
+  description: "Connect to a HATEOAS API entry point",
+  category: "source",
+  primaryRole: "source",
+  roles: [
+    defineRole({
+      role: "source",
+      description: "API entry point URL",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    })
+  ]
+});
+var followSchema = defineCommand({
+  action: "follow",
+  description: "Navigate to a resource by following a link relation",
+  category: "action",
+  primaryRole: "patient",
+  roles: [
+    defineRole({
+      role: "patient",
+      description: 'Link relation name to follow (e.g., "orders", "next")',
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 2,
+      sovPosition: 2
+    }),
+    defineRole({
+      role: "instrument",
+      description: "Parameter or sub-resource identifier (e.g., item {id})",
+      required: false,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 1,
+      markerOverride: {
+        en: "item",
+        es: "elemento",
+        ja: "\u306E",
+        ar: "\u0639\u0646\u0635\u0631",
+        ko: "\uD56D\uBAA9",
+        zh: "\u9879",
+        tr: "\xF6\u011Fe",
+        fr: "\xE9l\xE9ment"
+      }
+    })
+  ]
+});
+var performSchema = defineCommand({
+  action: "perform",
+  description: "Execute a server-defined action (Siren affordance)",
+  category: "action",
+  primaryRole: "patient",
+  roles: [
+    defineRole({
+      role: "patient",
+      description: 'Action name to execute (e.g., "create-order", "ship-order")',
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 2,
+      sovPosition: 1
+    }),
+    defineRole({
+      role: "source",
+      description: "Data source \u2014 form selector or inline data",
+      required: false,
+      expectedTypes: ["selector", "expression"],
+      svoPosition: 1,
+      sovPosition: 2,
+      markerOverride: {
+        en: "with",
+        es: "con",
+        ja: "\u3067",
+        ar: "\u0628",
+        ko: "\uB85C",
+        zh: "\u7528",
+        tr: "ile",
+        fr: "avec"
+      }
+    })
+  ]
+});
+var captureSchema = defineCommand({
+  action: "capture",
+  description: "Bind response data to a named variable for later use",
+  category: "action",
+  primaryRole: "destination",
+  roles: [
+    defineRole({
+      role: "patient",
+      description: "Property path to capture (optional \u2014 captures entire entity if omitted)",
+      required: false,
+      expectedTypes: ["expression"],
+      svoPosition: 2,
+      sovPosition: 2
+    }),
+    defineRole({
+      role: "destination",
+      description: "Variable name to bind the captured value to",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 1,
+      markerOverride: {
+        en: "as",
+        es: "como",
+        ja: "\u3068\u3057\u3066",
+        ar: "\u0643",
+        ko: "\uB85C",
+        zh: "\u4E3A",
+        tr: "olarak",
+        fr: "comme"
+      }
+    })
+  ]
+});
+var hateoasSchemas = [enterSchema, followSchema, performSchema, captureSchema];
+
+// src/schemas/index.ts
+var fetchSchema = defineCommand2({
+  action: "fetch",
+  description: "Fetch data from a URL and deliver to a target element",
+  category: "source",
+  primaryRole: "source",
+  roles: [
+    defineRole2({
+      role: "source",
+      description: "URL to fetch from",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 2,
+      sovPosition: 2
+    }),
+    defineRole2({
+      role: "style",
+      description: "Response format (json, html, text)",
+      required: false,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 1,
+      markerOverride: {
+        en: "as",
+        es: "como",
+        ja: "\u3067",
+        ar: "\u0643",
+        ko: "\uB85C",
+        zh: "\u4EE5",
+        tr: "olarak",
+        fr: "comme"
+      }
+    }),
+    defineRole2({
+      role: "destination",
+      description: "Target element to deliver data to",
+      required: false,
+      expectedTypes: ["selector", "expression"],
+      svoPosition: 0,
+      sovPosition: 0,
+      markerOverride: {
+        en: "into",
+        es: "en",
+        ja: "\u306B",
+        ar: "\u0641\u064A",
+        ko: "\uC5D0",
+        zh: "\u5230",
+        tr: "e",
+        fr: "dans"
+      }
+    })
+  ]
+});
+var pollSchema = defineCommand2({
+  action: "poll",
+  description: "Repeatedly fetch data at a specified interval",
+  category: "source",
+  primaryRole: "source",
+  roles: [
+    defineRole2({
+      role: "source",
+      description: "URL to poll",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 4,
+      sovPosition: 4
+    }),
+    defineRole2({
+      role: "duration",
+      description: "Polling interval (e.g., 5s, 30s, 1m)",
+      required: true,
+      expectedTypes: ["expression", "literal"],
+      svoPosition: 3,
+      sovPosition: 3,
+      markerOverride: {
+        en: "every",
+        es: "cada",
+        ja: "\u3054\u3068\u306B",
+        ar: "\u0643\u0644",
+        ko: "\uB9C8\uB2E4",
+        zh: "\u6BCF",
+        tr: "her",
+        fr: "chaque"
+      }
+    }),
+    defineRole2({
+      role: "style",
+      description: "Response format (json, html, text)",
+      required: false,
+      expectedTypes: ["expression"],
+      svoPosition: 2,
+      sovPosition: 2,
+      markerOverride: {
+        en: "as",
+        es: "como",
+        ja: "\u3067",
+        ar: "\u0643",
+        ko: "\uB85C",
+        zh: "\u4EE5",
+        tr: "olarak",
+        fr: "comme"
+      }
+    }),
+    defineRole2({
+      role: "destination",
+      description: "Target element for poll results",
+      required: false,
+      expectedTypes: ["selector", "expression"],
+      svoPosition: 1,
+      sovPosition: 1,
+      markerOverride: {
+        en: "into",
+        es: "en",
+        ja: "\u306B",
+        ar: "\u0641\u064A",
+        ko: "\uC5D0",
+        zh: "\u5230",
+        tr: "e",
+        fr: "dans"
+      }
+    })
+  ]
+});
+var streamSchema = defineCommand2({
+  action: "stream",
+  description: "Open a streaming connection (SSE) to a URL",
+  category: "source",
+  primaryRole: "source",
+  roles: [
+    defineRole2({
+      role: "source",
+      description: "URL for SSE stream",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 2,
+      sovPosition: 2
+    }),
+    defineRole2({
+      role: "style",
+      description: "Stream type (sse)",
+      required: false,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 1,
+      markerOverride: {
+        en: "as",
+        es: "como",
+        ja: "\u3067",
+        ar: "\u0643",
+        ko: "\uB85C",
+        zh: "\u4EE5",
+        tr: "olarak",
+        fr: "comme"
+      }
+    }),
+    defineRole2({
+      role: "destination",
+      description: "Target element for streamed data",
+      required: false,
+      expectedTypes: ["selector", "expression"],
+      svoPosition: 0,
+      sovPosition: 0,
+      markerOverride: {
+        en: "into",
+        es: "en",
+        ja: "\u306B",
+        ar: "\u0641\u064A",
+        ko: "\uC5D0",
+        zh: "\u5230",
+        tr: "e",
+        fr: "dans"
+      }
+    })
+  ]
+});
+var submitSchema = defineCommand2({
+  action: "submit",
+  description: "Submit form data to a URL",
+  category: "action",
+  primaryRole: "patient",
+  roles: [
+    defineRole2({
+      role: "patient",
+      description: "Form element to submit",
+      required: true,
+      expectedTypes: ["selector", "expression"],
+      svoPosition: 2,
+      sovPosition: 1
+    }),
+    defineRole2({
+      role: "destination",
+      description: "URL to submit to",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 2,
+      markerOverride: {
+        en: "to",
+        es: "a",
+        ja: "\u306B",
+        ar: "\u0625\u0644\u0649",
+        ko: "\uB85C",
+        zh: "\u5230",
+        tr: "e",
+        fr: "vers"
+      }
+    }),
+    defineRole2({
+      role: "style",
+      description: "Request encoding (json, form, multipart)",
+      required: false,
+      expectedTypes: ["expression"],
+      svoPosition: 0,
+      sovPosition: 0,
+      markerOverride: {
+        en: "as",
+        es: "como",
+        ja: "\u3067",
+        ar: "\u0643",
+        ko: "\uB85C",
+        zh: "\u4EE5",
+        tr: "olarak",
+        fr: "comme"
+      }
+    })
+  ]
+});
+var transformSchema = defineCommand2({
+  action: "transform",
+  description: "Transform data using a function or format string",
+  category: "transform",
+  primaryRole: "patient",
+  roles: [
+    defineRole2({
+      role: "patient",
+      description: "Data to transform",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 2,
+      sovPosition: 1
+    }),
+    defineRole2({
+      role: "instrument",
+      description: "Transform function, format string, or mapping",
+      required: true,
+      expectedTypes: ["expression", "literal"],
+      svoPosition: 1,
+      sovPosition: 2,
+      markerOverride: {
+        en: "with",
+        es: "con",
+        ja: "\u3067",
+        ar: "\u0628",
+        ko: "\uB85C",
+        zh: "\u7528",
+        tr: "ile",
+        fr: "avec"
+      }
+    })
+  ]
+});
+var allSchemas = [
+  fetchSchema,
+  pollSchema,
+  streamSchema,
+  submitSchema,
+  transformSchema,
+  ...hateoasSchemas
+];
+
+// src/profiles/index.ts
+var englishProfile = {
+  code: "en",
+  wordOrder: "SVO",
+  keywords: {
+    fetch: { primary: "fetch" },
+    poll: { primary: "poll" },
+    stream: { primary: "stream" },
+    submit: { primary: "submit" },
+    transform: { primary: "transform" },
+    enter: { primary: "enter" },
+    follow: { primary: "follow" },
+    perform: { primary: "perform" },
+    capture: { primary: "capture" }
+  }
+};
+var spanishProfile = {
+  code: "es",
+  wordOrder: "SVO",
+  keywords: {
+    fetch: { primary: "obtener" },
+    poll: { primary: "sondear" },
+    stream: { primary: "transmitir" },
+    submit: { primary: "enviar" },
+    transform: { primary: "transformar" },
+    enter: { primary: "entrar" },
+    follow: { primary: "seguir" },
+    perform: { primary: "ejecutar" },
+    capture: { primary: "capturar" }
+  }
+};
+var japaneseProfile = {
+  code: "ja",
+  wordOrder: "SOV",
+  keywords: {
+    fetch: { primary: "\u53D6\u5F97" },
+    poll: { primary: "\u30DD\u30FC\u30EA\u30F3\u30B0" },
+    stream: { primary: "\u30B9\u30C8\u30EA\u30FC\u30E0" },
+    submit: { primary: "\u9001\u4FE1" },
+    transform: { primary: "\u5909\u63DB" },
+    enter: { primary: "\u5165\u308B" },
+    follow: { primary: "\u8FBF\u308B" },
+    perform: { primary: "\u5B9F\u884C" },
+    capture: { primary: "\u53D6\u5F97\u5909\u6570" }
+  }
+};
+var arabicProfile = {
+  code: "ar",
+  wordOrder: "VSO",
+  keywords: {
+    fetch: { primary: "\u062C\u0644\u0628" },
+    poll: { primary: "\u0627\u0633\u062A\u0637\u0644\u0639" },
+    stream: { primary: "\u0628\u062B" },
+    submit: { primary: "\u0623\u0631\u0633\u0644" },
+    transform: { primary: "\u062D\u0648\u0651\u0644" },
+    enter: { primary: "\u0627\u062F\u062E\u0644" },
+    follow: { primary: "\u0627\u062A\u0628\u0639" },
+    perform: { primary: "\u0646\u0641\u0651\u0630" },
+    capture: { primary: "\u0627\u0644\u062A\u0642\u0637" }
+  }
+};
+var koreanProfile = {
+  code: "ko",
+  wordOrder: "SOV",
+  keywords: {
+    fetch: { primary: "\uAC00\uC838\uC624\uAE30" },
+    poll: { primary: "\uD3F4\uB9C1" },
+    stream: { primary: "\uC2A4\uD2B8\uB9AC\uBC0D" },
+    submit: { primary: "\uC81C\uCD9C" },
+    transform: { primary: "\uBCC0\uD658" },
+    enter: { primary: "\uC9C4\uC785" },
+    follow: { primary: "\uB530\uB77C\uAC00\uAE30" },
+    perform: { primary: "\uC2E4\uD589" },
+    capture: { primary: "\uCEA1\uCC98" }
+  }
+};
+var chineseProfile = {
+  code: "zh",
+  wordOrder: "SVO",
+  keywords: {
+    fetch: { primary: "\u83B7\u53D6" },
+    poll: { primary: "\u8F6E\u8BE2" },
+    stream: { primary: "\u6D41\u5F0F" },
+    submit: { primary: "\u63D0\u4EA4" },
+    transform: { primary: "\u8F6C\u6362" },
+    enter: { primary: "\u8FDB\u5165" },
+    follow: { primary: "\u8DDF\u968F" },
+    perform: { primary: "\u6267\u884C" },
+    capture: { primary: "\u6355\u83B7" }
+  }
+};
+var turkishProfile = {
+  code: "tr",
+  wordOrder: "SOV",
+  keywords: {
+    fetch: { primary: "getir" },
+    poll: { primary: "yokla" },
+    stream: { primary: "aktar" },
+    submit: { primary: "g\xF6nder" },
+    transform: { primary: "d\xF6n\xFC\u015Ft\xFCr" },
+    enter: { primary: "gir" },
+    follow: { primary: "izle" },
+    perform: { primary: "y\xFCr\xFCt" },
+    capture: { primary: "yakala" }
+  }
+};
+var frenchProfile = {
+  code: "fr",
+  wordOrder: "SVO",
+  keywords: {
+    fetch: { primary: "r\xE9cup\xE9rer" },
+    poll: { primary: "interroger" },
+    stream: { primary: "diffuser" },
+    submit: { primary: "soumettre" },
+    transform: { primary: "transformer" },
+    enter: { primary: "entrer" },
+    follow: { primary: "suivre" },
+    perform: { primary: "ex\xE9cuter" },
+    capture: { primary: "capturer" }
+  }
+};
+
+// src/tokenizers/index.ts
+import { createSimpleTokenizer } from "@lokascript/framework";
+var CSSSelectorExtractor = class {
+  name = "css-selector";
+  canExtract(input, position) {
+    const char = input[position];
+    if (char !== "#" && char !== ".") return false;
+    const next = input[position + 1];
+    return next !== void 0 && /[a-zA-Z_-]/.test(next);
+  }
+  extract(input, position) {
+    let end = position + 1;
+    while (end < input.length && /[a-zA-Z0-9_-]/.test(input[end])) {
+      end++;
+    }
+    if (end === position + 1) return null;
+    return { value: input.slice(position, end), length: end - position };
+  }
+};
+var URLPathExtractor = class {
+  name = "url-path";
+  canExtract(input, position) {
+    if (input[position] !== "/") return false;
+    const next = input[position + 1];
+    return next !== void 0 && /[a-zA-Z0-9_:{]/.test(next);
+  }
+  extract(input, position) {
+    let end = position + 1;
+    while (end < input.length && /[a-zA-Z0-9/_\-.{}:?=&]/.test(input[end])) {
+      end++;
+    }
+    if (end <= position + 1) return null;
+    return { value: input.slice(position, end), length: end - position };
+  }
+};
+var DurationExtractor = class {
+  name = "duration";
+  canExtract(input, position) {
+    return /[0-9]/.test(input[position]);
+  }
+  extract(input, position) {
+    let end = position;
+    while (end < input.length && /[0-9]/.test(input[end])) {
+      end++;
+    }
+    if (end === position) return null;
+    const remaining = input.slice(end);
+    if (remaining.startsWith("ms")) {
+      end += 2;
+    } else if (/^[smh](?![a-zA-Z])/.test(remaining)) {
+      end += 1;
+    } else {
+      return { value: input.slice(position, end), length: end - position };
+    }
+    return { value: input.slice(position, end), length: end - position };
+  }
+};
+var LatinExtendedIdentifierExtractor = class {
+  name = "latin-extended-identifier";
+  canExtract(input, position) {
+    return /\p{L}/u.test(input[position]);
+  }
+  extract(input, position) {
+    let end = position;
+    while (end < input.length && /[\p{L}\p{N}_-]/u.test(input[end])) {
+      end++;
+    }
+    if (end === position) return null;
+    return { value: input.slice(position, end), length: end - position };
+  }
+};
+var sharedExtractors = [
+  new CSSSelectorExtractor(),
+  new URLPathExtractor(),
+  new DurationExtractor()
+];
+var EnglishFlowTokenizer = createSimpleTokenizer({
+  language: "en",
+  customExtractors: sharedExtractors,
+  keywords: [
+    // Commands
+    "fetch",
+    "poll",
+    "stream",
+    "submit",
+    "transform",
+    // HATEOAS commands
+    "enter",
+    "follow",
+    "perform",
+    "capture",
+    // Role markers
+    "as",
+    "into",
+    "every",
+    "to",
+    "with",
+    "from",
+    "item"
+  ],
+  includeOperators: false,
+  caseInsensitive: true
+});
+var SpanishFlowTokenizer = createSimpleTokenizer({
+  language: "es",
+  customExtractors: [...sharedExtractors, new LatinExtendedIdentifierExtractor()],
+  keywords: [
+    // Commands
+    "obtener",
+    "sondear",
+    "transmitir",
+    "enviar",
+    "transformar",
+    // HATEOAS commands
+    "entrar",
+    "seguir",
+    "ejecutar",
+    "capturar",
+    // Role markers
+    "como",
+    "en",
+    "cada",
+    "a",
+    "con",
+    "de",
+    "elemento"
+  ],
+  keywordExtras: [
+    { native: "obtener", normalized: "fetch" },
+    { native: "sondear", normalized: "poll" },
+    { native: "transmitir", normalized: "stream" },
+    { native: "enviar", normalized: "submit" },
+    { native: "transformar", normalized: "transform" },
+    { native: "entrar", normalized: "enter" },
+    { native: "seguir", normalized: "follow" },
+    { native: "ejecutar", normalized: "perform" },
+    { native: "capturar", normalized: "capture" },
+    { native: "como", normalized: "as" },
+    { native: "en", normalized: "into" },
+    { native: "cada", normalized: "every" },
+    { native: "a", normalized: "to" },
+    { native: "con", normalized: "with" },
+    { native: "elemento", normalized: "item" }
+  ],
+  keywordProfile: {
+    keywords: {
+      fetch: { primary: "obtener" },
+      poll: { primary: "sondear" },
+      stream: { primary: "transmitir" },
+      submit: { primary: "enviar" },
+      transform: { primary: "transformar" },
+      enter: { primary: "entrar" },
+      follow: { primary: "seguir" },
+      perform: { primary: "ejecutar" },
+      capture: { primary: "capturar" }
+    }
+  },
+  includeOperators: false,
+  caseInsensitive: true
+});
+var JapaneseFlowTokenizer = createSimpleTokenizer({
+  language: "ja",
+  customExtractors: sharedExtractors,
+  keywords: [
+    // Commands
+    "\u53D6\u5F97",
+    "\u30DD\u30FC\u30EA\u30F3\u30B0",
+    "\u30B9\u30C8\u30EA\u30FC\u30E0",
+    "\u9001\u4FE1",
+    "\u5909\u63DB",
+    // HATEOAS commands
+    "\u5165\u308B",
+    "\u8FBF\u308B",
+    "\u5B9F\u884C",
+    "\u53D6\u5F97\u5909\u6570",
+    // Role markers / particles
+    "\u3067",
+    "\u306B",
+    "\u3054\u3068\u306B",
+    "\u3092",
+    "\u304B\u3089",
+    "\u306E",
+    "\u3068\u3057\u3066"
+  ],
+  keywordExtras: [
+    { native: "\u53D6\u5F97", normalized: "fetch" },
+    { native: "\u30DD\u30FC\u30EA\u30F3\u30B0", normalized: "poll" },
+    { native: "\u30B9\u30C8\u30EA\u30FC\u30E0", normalized: "stream" },
+    { native: "\u9001\u4FE1", normalized: "submit" },
+    { native: "\u5909\u63DB", normalized: "transform" },
+    { native: "\u5165\u308B", normalized: "enter" },
+    { native: "\u8FBF\u308B", normalized: "follow" },
+    { native: "\u5B9F\u884C", normalized: "perform" },
+    { native: "\u53D6\u5F97\u5909\u6570", normalized: "capture" },
+    { native: "\u3067", normalized: "as" },
+    { native: "\u306B", normalized: "into" },
+    { native: "\u3054\u3068\u306B", normalized: "every" },
+    { native: "\u3092", normalized: "patient" },
+    { native: "\u306E", normalized: "item" },
+    { native: "\u3068\u3057\u3066", normalized: "as" }
+  ],
+  keywordProfile: {
+    keywords: {
+      fetch: { primary: "\u53D6\u5F97" },
+      poll: { primary: "\u30DD\u30FC\u30EA\u30F3\u30B0" },
+      stream: { primary: "\u30B9\u30C8\u30EA\u30FC\u30E0" },
+      submit: { primary: "\u9001\u4FE1" },
+      transform: { primary: "\u5909\u63DB" },
+      enter: { primary: "\u5165\u308B" },
+      follow: { primary: "\u8FBF\u308B" },
+      perform: { primary: "\u5B9F\u884C" },
+      capture: { primary: "\u53D6\u5F97\u5909\u6570" }
+    }
+  },
+  includeOperators: false,
+  caseInsensitive: false
+});
+var ArabicFlowTokenizer = createSimpleTokenizer({
+  language: "ar",
+  direction: "rtl",
+  customExtractors: sharedExtractors,
+  keywords: [
+    // Commands
+    "\u062C\u0644\u0628",
+    "\u0627\u0633\u062A\u0637\u0644\u0639",
+    "\u0628\u062B",
+    "\u0623\u0631\u0633\u0644",
+    "\u062D\u0648\u0651\u0644",
+    // HATEOAS commands
+    "\u0627\u062F\u062E\u0644",
+    "\u0627\u062A\u0628\u0639",
+    "\u0646\u0641\u0651\u0630",
+    "\u0627\u0644\u062A\u0642\u0637",
+    // Role markers
+    "\u0643",
+    "\u0641\u064A",
+    "\u0643\u0644",
+    "\u0625\u0644\u0649",
+    "\u0628",
+    "\u0645\u0646",
+    "\u0639\u0646\u0635\u0631"
+  ],
+  keywordExtras: [
+    { native: "\u062C\u0644\u0628", normalized: "fetch" },
+    { native: "\u0627\u0633\u062A\u0637\u0644\u0639", normalized: "poll" },
+    { native: "\u0628\u062B", normalized: "stream" },
+    { native: "\u0623\u0631\u0633\u0644", normalized: "submit" },
+    { native: "\u062D\u0648\u0651\u0644", normalized: "transform" },
+    { native: "\u0627\u062F\u062E\u0644", normalized: "enter" },
+    { native: "\u0627\u062A\u0628\u0639", normalized: "follow" },
+    { native: "\u0646\u0641\u0651\u0630", normalized: "perform" },
+    { native: "\u0627\u0644\u062A\u0642\u0637", normalized: "capture" },
+    { native: "\u0643", normalized: "as" },
+    { native: "\u0641\u064A", normalized: "into" },
+    { native: "\u0643\u0644", normalized: "every" },
+    { native: "\u0625\u0644\u0649", normalized: "to" },
+    { native: "\u0628", normalized: "with" },
+    { native: "\u0639\u0646\u0635\u0631", normalized: "item" }
+  ],
+  keywordProfile: {
+    keywords: {
+      fetch: { primary: "\u062C\u0644\u0628" },
+      poll: { primary: "\u0627\u0633\u062A\u0637\u0644\u0639" },
+      stream: { primary: "\u0628\u062B" },
+      submit: { primary: "\u0623\u0631\u0633\u0644" },
+      transform: { primary: "\u062D\u0648\u0651\u0644" },
+      enter: { primary: "\u0627\u062F\u062E\u0644" },
+      follow: { primary: "\u0627\u062A\u0628\u0639" },
+      perform: { primary: "\u0646\u0641\u0651\u0630" },
+      capture: { primary: "\u0627\u0644\u062A\u0642\u0637" }
+    }
+  },
+  includeOperators: false,
+  caseInsensitive: false
+});
+var KoreanFlowTokenizer = createSimpleTokenizer({
+  language: "ko",
+  customExtractors: sharedExtractors,
+  keywords: [
+    // Commands
+    "\uAC00\uC838\uC624\uAE30",
+    "\uD3F4\uB9C1",
+    "\uC2A4\uD2B8\uB9AC\uBC0D",
+    "\uC81C\uCD9C",
+    "\uBCC0\uD658",
+    // HATEOAS commands
+    "\uC9C4\uC785",
+    "\uB530\uB77C\uAC00\uAE30",
+    "\uC2E4\uD589",
+    "\uCEA1\uCC98",
+    // Role markers / particles
+    "\uB85C",
+    "\uC5D0",
+    "\uB9C8\uB2E4",
+    "\uB97C",
+    "\uC5D0\uC11C",
+    "\uD56D\uBAA9"
+  ],
+  keywordExtras: [
+    { native: "\uAC00\uC838\uC624\uAE30", normalized: "fetch" },
+    { native: "\uD3F4\uB9C1", normalized: "poll" },
+    { native: "\uC2A4\uD2B8\uB9AC\uBC0D", normalized: "stream" },
+    { native: "\uC81C\uCD9C", normalized: "submit" },
+    { native: "\uBCC0\uD658", normalized: "transform" },
+    { native: "\uC9C4\uC785", normalized: "enter" },
+    { native: "\uB530\uB77C\uAC00\uAE30", normalized: "follow" },
+    { native: "\uC2E4\uD589", normalized: "perform" },
+    { native: "\uCEA1\uCC98", normalized: "capture" },
+    { native: "\uB85C", normalized: "as" },
+    { native: "\uC5D0", normalized: "into" },
+    { native: "\uB9C8\uB2E4", normalized: "every" },
+    { native: "\uB97C", normalized: "patient" },
+    { native: "\uD56D\uBAA9", normalized: "item" }
+  ],
+  keywordProfile: {
+    keywords: {
+      fetch: { primary: "\uAC00\uC838\uC624\uAE30" },
+      poll: { primary: "\uD3F4\uB9C1" },
+      stream: { primary: "\uC2A4\uD2B8\uB9AC\uBC0D" },
+      submit: { primary: "\uC81C\uCD9C" },
+      transform: { primary: "\uBCC0\uD658" },
+      enter: { primary: "\uC9C4\uC785" },
+      follow: { primary: "\uB530\uB77C\uAC00\uAE30" },
+      perform: { primary: "\uC2E4\uD589" },
+      capture: { primary: "\uCEA1\uCC98" }
+    }
+  },
+  includeOperators: false,
+  caseInsensitive: false
+});
+var ChineseFlowTokenizer = createSimpleTokenizer({
+  language: "zh",
+  customExtractors: sharedExtractors,
+  keywords: [
+    // Commands
+    "\u83B7\u53D6",
+    "\u8F6E\u8BE2",
+    "\u6D41\u5F0F",
+    "\u63D0\u4EA4",
+    "\u8F6C\u6362",
+    // HATEOAS commands
+    "\u8FDB\u5165",
+    "\u8DDF\u968F",
+    "\u6267\u884C",
+    "\u6355\u83B7",
+    // Role markers
+    "\u4EE5",
+    "\u5230",
+    "\u6BCF",
+    "\u7528",
+    "\u4ECE",
+    "\u9879",
+    "\u4E3A"
+  ],
+  keywordExtras: [
+    { native: "\u83B7\u53D6", normalized: "fetch" },
+    { native: "\u8F6E\u8BE2", normalized: "poll" },
+    { native: "\u6D41\u5F0F", normalized: "stream" },
+    { native: "\u63D0\u4EA4", normalized: "submit" },
+    { native: "\u8F6C\u6362", normalized: "transform" },
+    { native: "\u8FDB\u5165", normalized: "enter" },
+    { native: "\u8DDF\u968F", normalized: "follow" },
+    { native: "\u6267\u884C", normalized: "perform" },
+    { native: "\u6355\u83B7", normalized: "capture" },
+    { native: "\u4EE5", normalized: "as" },
+    { native: "\u5230", normalized: "into" },
+    { native: "\u6BCF", normalized: "every" },
+    { native: "\u7528", normalized: "with" },
+    { native: "\u9879", normalized: "item" },
+    { native: "\u4E3A", normalized: "as" }
+  ],
+  keywordProfile: {
+    keywords: {
+      fetch: { primary: "\u83B7\u53D6" },
+      poll: { primary: "\u8F6E\u8BE2" },
+      stream: { primary: "\u6D41\u5F0F" },
+      submit: { primary: "\u63D0\u4EA4" },
+      transform: { primary: "\u8F6C\u6362" },
+      enter: { primary: "\u8FDB\u5165" },
+      follow: { primary: "\u8DDF\u968F" },
+      perform: { primary: "\u6267\u884C" },
+      capture: { primary: "\u6355\u83B7" }
+    }
+  },
+  includeOperators: false,
+  caseInsensitive: false
+});
+var TurkishFlowTokenizer = createSimpleTokenizer({
+  language: "tr",
+  customExtractors: [...sharedExtractors, new LatinExtendedIdentifierExtractor()],
+  keywords: [
+    // Commands
+    "getir",
+    "yokla",
+    "aktar",
+    "g\xF6nder",
+    "d\xF6n\xFC\u015Ft\xFCr",
+    // HATEOAS commands
+    "gir",
+    "izle",
+    "y\xFCr\xFCt",
+    "yakala",
+    // Role markers
+    "olarak",
+    "e",
+    "her",
+    "ile",
+    "dan",
+    "\xF6\u011Fe"
+  ],
+  keywordExtras: [
+    { native: "getir", normalized: "fetch" },
+    { native: "yokla", normalized: "poll" },
+    { native: "aktar", normalized: "stream" },
+    { native: "g\xF6nder", normalized: "submit" },
+    { native: "d\xF6n\xFC\u015Ft\xFCr", normalized: "transform" },
+    { native: "gir", normalized: "enter" },
+    { native: "izle", normalized: "follow" },
+    { native: "y\xFCr\xFCt", normalized: "perform" },
+    { native: "yakala", normalized: "capture" },
+    { native: "olarak", normalized: "as" },
+    { native: "e", normalized: "into" },
+    { native: "her", normalized: "every" },
+    { native: "ile", normalized: "with" },
+    { native: "\xF6\u011Fe", normalized: "item" }
+  ],
+  keywordProfile: {
+    keywords: {
+      fetch: { primary: "getir" },
+      poll: { primary: "yokla" },
+      stream: { primary: "aktar" },
+      submit: { primary: "g\xF6nder" },
+      transform: { primary: "d\xF6n\xFC\u015Ft\xFCr" },
+      enter: { primary: "gir" },
+      follow: { primary: "izle" },
+      perform: { primary: "y\xFCr\xFCt" },
+      capture: { primary: "yakala" }
+    }
+  },
+  includeOperators: false,
+  caseInsensitive: true
+});
+var FrenchFlowTokenizer = createSimpleTokenizer({
+  language: "fr",
+  customExtractors: [...sharedExtractors, new LatinExtendedIdentifierExtractor()],
+  keywords: [
+    // Commands
+    "r\xE9cup\xE9rer",
+    "interroger",
+    "diffuser",
+    "soumettre",
+    "transformer",
+    // HATEOAS commands
+    "entrer",
+    "suivre",
+    "ex\xE9cuter",
+    "capturer",
+    // Role markers
+    "comme",
+    "dans",
+    "chaque",
+    "vers",
+    "avec",
+    "de",
+    "\xE9l\xE9ment"
+  ],
+  keywordExtras: [
+    { native: "r\xE9cup\xE9rer", normalized: "fetch" },
+    { native: "interroger", normalized: "poll" },
+    { native: "diffuser", normalized: "stream" },
+    { native: "soumettre", normalized: "submit" },
+    { native: "transformer", normalized: "transform" },
+    { native: "entrer", normalized: "enter" },
+    { native: "suivre", normalized: "follow" },
+    { native: "ex\xE9cuter", normalized: "perform" },
+    { native: "capturer", normalized: "capture" },
+    { native: "comme", normalized: "as" },
+    { native: "dans", normalized: "into" },
+    { native: "chaque", normalized: "every" },
+    { native: "vers", normalized: "to" },
+    { native: "avec", normalized: "with" },
+    { native: "\xE9l\xE9ment", normalized: "item" }
+  ],
+  keywordProfile: {
+    keywords: {
+      fetch: { primary: "r\xE9cup\xE9rer" },
+      poll: { primary: "interroger" },
+      stream: { primary: "diffuser" },
+      submit: { primary: "soumettre" },
+      transform: { primary: "transformer" },
+      enter: { primary: "entrer" },
+      follow: { primary: "suivre" },
+      perform: { primary: "ex\xE9cuter" },
+      capture: { primary: "capturer" }
+    }
+  },
+  includeOperators: false,
+  caseInsensitive: true
+});
+
+// src/generators/flow-generator.ts
+import { extractRoleValue } from "@lokascript/framework";
+function parseDuration(duration) {
+  const match = duration.match(/^(\d+)(ms|s|m|h)?$/);
+  if (!match) return 0;
+  const value = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "h":
+      return value * 36e5;
+    case "m":
+      return value * 6e4;
+    case "s":
+      return value * 1e3;
+    case "ms":
+      return value;
+    default:
+      return value;
+  }
+}
+function toFlowSpec(node, language) {
+  const action = node.action;
+  const roles = {};
+  for (const [key, val] of node.roles) {
+    roles[key] = typeof val === "string" ? val : val?.value ?? String(val);
+  }
+  const base = {
+    action,
+    metadata: { sourceLanguage: language, roles }
+  };
+  switch (action) {
+    case "fetch": {
+      base.url = extractRoleValue(node, "source") || void 0;
+      base.responseFormat = normalizeFormat(extractRoleValue(node, "style"));
+      base.target = extractRoleValue(node, "destination") || void 0;
+      base.method = "GET";
+      break;
+    }
+    case "poll": {
+      base.url = extractRoleValue(node, "source") || void 0;
+      base.responseFormat = normalizeFormat(extractRoleValue(node, "style"));
+      base.target = extractRoleValue(node, "destination") || void 0;
+      base.method = "GET";
+      const dur = extractRoleValue(node, "duration");
+      if (dur) base.intervalMs = parseDuration(dur);
+      break;
+    }
+    case "stream": {
+      base.url = extractRoleValue(node, "source") || void 0;
+      base.responseFormat = "sse";
+      base.target = extractRoleValue(node, "destination") || void 0;
+      base.method = "GET";
+      break;
+    }
+    case "submit": {
+      base.formSelector = extractRoleValue(node, "patient") || void 0;
+      base.url = extractRoleValue(node, "destination") || void 0;
+      base.responseFormat = normalizeFormat(extractRoleValue(node, "style"));
+      base.method = "POST";
+      break;
+    }
+    case "transform": {
+      base.transformFn = extractRoleValue(node, "instrument") || void 0;
+      break;
+    }
+    case "enter": {
+      base.url = extractRoleValue(node, "source") || void 0;
+      break;
+    }
+    case "follow": {
+      base.linkRel = extractRoleValue(node, "patient") || void 0;
+      break;
+    }
+    case "perform": {
+      base.actionName = extractRoleValue(node, "patient") || void 0;
+      base.dataSource = extractRoleValue(node, "source") || void 0;
+      break;
+    }
+    case "capture": {
+      base.captureAs = extractRoleValue(node, "destination") || void 0;
+      base.capturePath = extractRoleValue(node, "patient") || void 0;
+      break;
+    }
+  }
+  return base;
+}
+function normalizeFormat(format) {
+  if (!format) return void 0;
+  const lower = format.toLowerCase();
+  if (lower === "json") return "json";
+  if (lower === "html") return "html";
+  if (lower === "text") return "text";
+  if (lower === "sse") return "sse";
+  return void 0;
+}
+function escapeStr(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function generateFetch(node) {
+  const url = extractRoleValue(node, "source") || "/";
+  const format = extractRoleValue(node, "style")?.toLowerCase() || "text";
+  const target = extractRoleValue(node, "destination");
+  const parseMethod = format === "json" ? ".json()" : ".text()";
+  const lines = [`fetch('${escapeStr(url)}')`, `  .then(r => r${parseMethod})`];
+  if (target) {
+    lines.push(`  .then(data => {`);
+    if (format === "json") {
+      lines.push(
+        `    document.querySelector('${escapeStr(target)}').innerHTML = typeof data === 'string' ? data : JSON.stringify(data);`
+      );
+    } else {
+      lines.push(`    document.querySelector('${escapeStr(target)}').innerHTML = data;`);
+    }
+    lines.push(`  })`);
+  }
+  lines.push(`  .catch(err => console.error('Fetch error:', err));`);
+  return lines.join("\n");
+}
+function generatePoll(node) {
+  const url = extractRoleValue(node, "source") || "/";
+  const duration = extractRoleValue(node, "duration") || "5s";
+  const format = extractRoleValue(node, "style")?.toLowerCase() || "text";
+  const target = extractRoleValue(node, "destination");
+  const ms = parseDuration(duration);
+  const parseMethod = format === "json" ? ".json()" : ".text()";
+  const lines = [
+    `setInterval(async () => {`,
+    `  try {`,
+    `    const r = await fetch('${escapeStr(url)}');`,
+    `    const data = await r${parseMethod};`
+  ];
+  if (target) {
+    if (format === "json") {
+      lines.push(
+        `    document.querySelector('${escapeStr(target)}').innerHTML = typeof data === 'string' ? data : JSON.stringify(data);`
+      );
+    } else {
+      lines.push(`    document.querySelector('${escapeStr(target)}').innerHTML = data;`);
+    }
+  }
+  lines.push(`  } catch (err) {`, `    console.error('Poll error:', err);`, `  }`, `}, ${ms});`);
+  return lines.join("\n");
+}
+function generateStream(node) {
+  const url = extractRoleValue(node, "source") || "/";
+  const target = extractRoleValue(node, "destination");
+  const lines = [`const es = new EventSource('${escapeStr(url)}');`];
+  if (target) {
+    lines.push(
+      `es.onmessage = (event) => {`,
+      `  document.querySelector('${escapeStr(target)}').insertAdjacentHTML('beforeend', event.data);`,
+      `};`
+    );
+  } else {
+    lines.push(`es.onmessage = (event) => {`, `  console.log('Stream data:', event.data);`, `};`);
+  }
+  lines.push(`es.onerror = () => {`, `  console.error('Stream error, reconnecting...');`, `};`);
+  return lines.join("\n");
+}
+function generateSubmit(node) {
+  const form = extractRoleValue(node, "patient") || "#form";
+  const url = extractRoleValue(node, "destination") || "/";
+  const format = extractRoleValue(node, "style")?.toLowerCase();
+  const lines = [
+    `const form = document.querySelector('${escapeStr(form)}');`,
+    `const formData = new FormData(form);`
+  ];
+  if (format === "json") {
+    lines.push(
+      `fetch('${escapeStr(url)}', {`,
+      `  method: 'POST',`,
+      `  headers: { 'Content-Type': 'application/json' },`,
+      `  body: JSON.stringify(Object.fromEntries(formData)),`,
+      `})`,
+      `  .then(r => r.json())`,
+      `  .catch(err => console.error('Submit error:', err));`
+    );
+  } else {
+    lines.push(
+      `fetch('${escapeStr(url)}', {`,
+      `  method: 'POST',`,
+      `  body: formData,`,
+      `})`,
+      `  .then(r => r.text())`,
+      `  .catch(err => console.error('Submit error:', err));`
+    );
+  }
+  return lines.join("\n");
+}
+function generateTransform(node) {
+  const data = extractRoleValue(node, "patient") || "data";
+  const fn = extractRoleValue(node, "instrument") || "identity";
+  return `const result = ${fn}(${data});`;
+}
+function generateEnter(node) {
+  const url = extractRoleValue(node, "source") || "/";
+  return [
+    `// HATEOAS: Connect to entry point`,
+    `const agent = new SirenAgent('${escapeStr(url)}');`,
+    `await agent.start();`
+  ].join("\n");
+}
+function generateFollow(node) {
+  const rel = extractRoleValue(node, "patient") || "self";
+  return [
+    `// HATEOAS: Follow link relation '${escapeStr(rel)}'`,
+    `await agent.followLink('${escapeStr(rel)}');`
+  ].join("\n");
+}
+function generatePerform(node) {
+  const action = extractRoleValue(node, "patient") || "";
+  const dataSource = extractRoleValue(node, "source");
+  const lines = [`// HATEOAS: Execute action '${escapeStr(action)}'`];
+  if (dataSource) {
+    lines.push(
+      `const data = Object.fromEntries(new FormData(document.querySelector('${escapeStr(dataSource)}')));`
+    );
+    lines.push(`await agent.executeAction('${escapeStr(action)}', data);`);
+  } else {
+    lines.push(`await agent.executeAction('${escapeStr(action)}');`);
+  }
+  return lines.join("\n");
+}
+function generateCapture(node) {
+  const varName = extractRoleValue(node, "destination") || "captured";
+  const path = extractRoleValue(node, "patient");
+  if (path) {
+    return `const ${varName} = agent.currentEntity.properties?.['${escapeStr(path)}'];`;
+  }
+  return `const ${varName} = agent.currentEntity.properties;`;
+}
+var flowCodeGenerator = {
+  generate(node) {
+    switch (node.action) {
+      case "fetch":
+        return generateFetch(node);
+      case "poll":
+        return generatePoll(node);
+      case "stream":
+        return generateStream(node);
+      case "submit":
+        return generateSubmit(node);
+      case "transform":
+        return generateTransform(node);
+      case "enter":
+        return generateEnter(node);
+      case "follow":
+        return generateFollow(node);
+      case "perform":
+        return generatePerform(node);
+      case "capture":
+        return generateCapture(node);
+      default:
+        throw new Error(`Unknown FlowScript command: ${node.action}`);
+    }
+  }
+};
+
+// src/generators/flow-renderer.ts
+import { extractRoleValue as extractRoleValue2 } from "@lokascript/framework";
+var COMMAND_KEYWORDS = {
+  fetch: {
+    en: "fetch",
+    es: "obtener",
+    ja: "\u53D6\u5F97",
+    ar: "\u062C\u0644\u0628",
+    ko: "\uAC00\uC838\uC624\uAE30",
+    zh: "\u83B7\u53D6",
+    tr: "getir",
+    fr: "r\xE9cup\xE9rer"
+  },
+  poll: {
+    en: "poll",
+    es: "sondear",
+    ja: "\u30DD\u30FC\u30EA\u30F3\u30B0",
+    ar: "\u0627\u0633\u062A\u0637\u0644\u0639",
+    ko: "\uD3F4\uB9C1",
+    zh: "\u8F6E\u8BE2",
+    tr: "yokla",
+    fr: "interroger"
+  },
+  stream: {
+    en: "stream",
+    es: "transmitir",
+    ja: "\u30B9\u30C8\u30EA\u30FC\u30E0",
+    ar: "\u0628\u062B",
+    ko: "\uC2A4\uD2B8\uB9AC\uBC0D",
+    zh: "\u6D41\u5F0F",
+    tr: "aktar",
+    fr: "diffuser"
+  },
+  submit: {
+    en: "submit",
+    es: "enviar",
+    ja: "\u9001\u4FE1",
+    ar: "\u0623\u0631\u0633\u0644",
+    ko: "\uC81C\uCD9C",
+    zh: "\u63D0\u4EA4",
+    tr: "g\xF6nder",
+    fr: "soumettre"
+  },
+  transform: {
+    en: "transform",
+    es: "transformar",
+    ja: "\u5909\u63DB",
+    ar: "\u062D\u0648\u0651\u0644",
+    ko: "\uBCC0\uD658",
+    zh: "\u8F6C\u6362",
+    tr: "d\xF6n\xFC\u015Ft\xFCr",
+    fr: "transformer"
+  }
+};
+var MARKERS = {
+  as: { en: "as", es: "como", ja: "\u3067", ar: "\u0643", ko: "\uB85C", zh: "\u4EE5", tr: "olarak", fr: "comme" },
+  into: { en: "into", es: "en", ja: "\u306B", ar: "\u0641\u064A", ko: "\uC5D0", zh: "\u5230", tr: "e", fr: "dans" },
+  every: {
+    en: "every",
+    es: "cada",
+    ja: "\u3054\u3068\u306B",
+    ar: "\u0643\u0644",
+    ko: "\uB9C8\uB2E4",
+    zh: "\u6BCF",
+    tr: "her",
+    fr: "chaque"
+  },
+  to: { en: "to", es: "a", ja: "\u306B", ar: "\u0625\u0644\u0649", ko: "\uB85C", zh: "\u5230", tr: "e", fr: "vers" },
+  with: { en: "with", es: "con", ja: "\u3067", ar: "\u0628", ko: "\uB85C", zh: "\u7528", tr: "ile", fr: "avec" }
+};
+var SOV_LANGUAGES = /* @__PURE__ */ new Set(["ja", "ko", "tr"]);
+var VSO_LANGUAGES = /* @__PURE__ */ new Set(["ar"]);
+function isSOV(lang) {
+  return SOV_LANGUAGES.has(lang);
+}
+function isVSO(lang) {
+  return VSO_LANGUAGES.has(lang);
+}
+function kw(command, lang) {
+  return COMMAND_KEYWORDS[command]?.[lang] ?? command;
+}
+function mk(marker, lang) {
+  return MARKERS[marker]?.[lang] ?? marker;
+}
+function renderFetch(node, lang) {
+  const source = extractRoleValue2(node, "source") || "/";
+  const style = extractRoleValue2(node, "style");
+  const dest = extractRoleValue2(node, "destination");
+  const verb = kw("fetch", lang);
+  const parts = [];
+  if (isSOV(lang)) {
+    parts.push(source);
+    if (style) parts.push(style, mk("as", lang));
+    parts.push(verb);
+    if (dest) parts.push(dest, mk("into", lang));
+  } else if (isVSO(lang)) {
+    parts.push(verb, source);
+    if (style) parts.push(mk("as", lang), style);
+    if (dest) parts.push(mk("into", lang), dest);
+  } else {
+    parts.push(verb, source);
+    if (style) parts.push(mk("as", lang), style);
+    if (dest) parts.push(mk("into", lang), dest);
+  }
+  return parts.join(" ");
+}
+function renderPoll(node, lang) {
+  const source = extractRoleValue2(node, "source") || "/";
+  const duration = extractRoleValue2(node, "duration") || "5s";
+  const style = extractRoleValue2(node, "style");
+  const dest = extractRoleValue2(node, "destination");
+  const verb = kw("poll", lang);
+  const parts = [];
+  if (isSOV(lang)) {
+    parts.push(source);
+    parts.push(duration, mk("every", lang));
+    if (style) parts.push(style, mk("as", lang));
+    parts.push(verb);
+    if (dest) parts.push(dest, mk("into", lang));
+  } else if (isVSO(lang)) {
+    parts.push(verb, source);
+    parts.push(mk("every", lang), duration);
+    if (style) parts.push(mk("as", lang), style);
+    if (dest) parts.push(mk("into", lang), dest);
+  } else {
+    parts.push(verb, source);
+    parts.push(mk("every", lang), duration);
+    if (style) parts.push(mk("as", lang), style);
+    if (dest) parts.push(mk("into", lang), dest);
+  }
+  return parts.join(" ");
+}
+function renderStream(node, lang) {
+  const source = extractRoleValue2(node, "source") || "/";
+  const style = extractRoleValue2(node, "style");
+  const dest = extractRoleValue2(node, "destination");
+  const verb = kw("stream", lang);
+  const parts = [];
+  if (isSOV(lang)) {
+    parts.push(source);
+    if (style) parts.push(style, mk("as", lang));
+    parts.push(verb);
+    if (dest) parts.push(dest, mk("into", lang));
+  } else if (isVSO(lang)) {
+    parts.push(verb, source);
+    if (style) parts.push(mk("as", lang), style);
+    if (dest) parts.push(mk("into", lang), dest);
+  } else {
+    parts.push(verb, source);
+    if (style) parts.push(mk("as", lang), style);
+    if (dest) parts.push(mk("into", lang), dest);
+  }
+  return parts.join(" ");
+}
+function renderSubmit(node, lang) {
+  const patient = extractRoleValue2(node, "patient") || "#form";
+  const dest = extractRoleValue2(node, "destination") || "/";
+  const style = extractRoleValue2(node, "style");
+  const verb = kw("submit", lang);
+  const parts = [];
+  if (isSOV(lang)) {
+    parts.push(patient);
+    parts.push(dest, mk("to", lang));
+    if (style) parts.push(style, mk("as", lang));
+    parts.push(verb);
+  } else if (isVSO(lang)) {
+    parts.push(verb, patient);
+    parts.push(mk("to", lang), dest);
+    if (style) parts.push(mk("as", lang), style);
+  } else {
+    parts.push(verb, patient);
+    parts.push(mk("to", lang), dest);
+    if (style) parts.push(mk("as", lang), style);
+  }
+  return parts.join(" ");
+}
+function renderTransform(node, lang) {
+  const patient = extractRoleValue2(node, "patient") || "data";
+  const instrument = extractRoleValue2(node, "instrument") || "identity";
+  const verb = kw("transform", lang);
+  const parts = [];
+  if (isSOV(lang)) {
+    parts.push(patient);
+    parts.push(instrument, mk("with", lang));
+    parts.push(verb);
+  } else if (isVSO(lang)) {
+    parts.push(verb, patient);
+    parts.push(mk("with", lang), instrument);
+  } else {
+    parts.push(verb, patient);
+    parts.push(mk("with", lang), instrument);
+  }
+  return parts.join(" ");
+}
+function renderFlow(node, language) {
+  switch (node.action) {
+    case "fetch":
+      return renderFetch(node, language);
+    case "poll":
+      return renderPoll(node, language);
+    case "stream":
+      return renderStream(node, language);
+    case "submit":
+      return renderSubmit(node, language);
+    case "transform":
+      return renderTransform(node, language);
+    default:
+      return `-- Unknown: ${node.action}`;
+  }
+}
+
+// src/generators/htmx-generator.ts
+function generateHTMX(spec) {
+  switch (spec.action) {
+    case "fetch":
+      return generateFetchHTMX(spec);
+    case "poll":
+      return generatePollHTMX(spec);
+    case "stream":
+      return generateStreamHTMX(spec);
+    case "submit":
+      return generateSubmitHTMX(spec);
+    case "transform":
+      return null;
+    // No HTMX equivalent for data transforms
+    default:
+      return null;
+  }
+}
+function generateFetchHTMX(spec) {
+  const attrs = {};
+  const notes = [];
+  if (spec.url) {
+    attrs["hx-get"] = spec.url;
+  }
+  if (spec.target) {
+    attrs["hx-target"] = spec.target;
+  }
+  attrs["hx-swap"] = "innerHTML";
+  if (spec.responseFormat === "json") {
+    notes.push(
+      'HTMX expects HTML responses by default. For JSON, use hx-ext="json-enc" or handle in a hyperscript handler.'
+    );
+  }
+  return { attrs, notes };
+}
+function generatePollHTMX(spec) {
+  const attrs = {};
+  const notes = [];
+  if (spec.url) {
+    attrs["hx-get"] = spec.url;
+  }
+  if (spec.intervalMs) {
+    const seconds = spec.intervalMs / 1e3;
+    attrs["hx-trigger"] = `every ${seconds}s`;
+  }
+  if (spec.target) {
+    attrs["hx-target"] = spec.target;
+  }
+  attrs["hx-swap"] = "innerHTML";
+  if (spec.responseFormat === "json") {
+    notes.push(
+      'HTMX expects HTML responses by default. For JSON, use hx-ext="json-enc" or handle in a hyperscript handler.'
+    );
+  }
+  return { attrs, notes };
+}
+function generateStreamHTMX(spec) {
+  const attrs = {};
+  const notes = [];
+  if (spec.url) {
+    attrs["hx-ext"] = "sse";
+    attrs["sse-connect"] = spec.url;
+    attrs["sse-swap"] = "message";
+  }
+  if (spec.target) {
+    attrs["hx-target"] = spec.target;
+  }
+  notes.push('SSE support requires the htmx sse extension (hx-ext="sse").');
+  return { attrs, notes };
+}
+function generateSubmitHTMX(spec) {
+  const attrs = {};
+  const notes = [];
+  if (spec.url) {
+    attrs["hx-post"] = spec.url;
+  }
+  if (spec.responseFormat === "json") {
+    attrs["hx-ext"] = "json-enc";
+    attrs["hx-encoding"] = "application/json";
+  }
+  if (spec.target) {
+    attrs["hx-target"] = spec.target;
+  }
+  return { attrs, notes };
+}
+
+// src/generators/route-extractor.ts
+function extractRoute(spec) {
+  if (!spec.url) return null;
+  const path = spec.url;
+  const pathParams = extractPathParams(path);
+  const handlerName = generateHandlerName(spec);
+  return {
+    path,
+    method: spec.method || "GET",
+    responseFormat: spec.responseFormat || "text",
+    pathParams,
+    handlerName,
+    sourceCommand: spec.action
+  };
+}
+function extractRoutes(specs) {
+  return specs.map(extractRoute).filter((r) => r !== null);
+}
+function extractPathParams(url) {
+  const params = [];
+  const braceMatches = url.matchAll(/\{(\w+)\}/g);
+  for (const match of braceMatches) {
+    params.push(match[1]);
+  }
+  const colonMatches = url.matchAll(/:(\w+)/g);
+  for (const match of colonMatches) {
+    params.push(match[1]);
+  }
+  return params;
+}
+function generateHandlerName(spec) {
+  if (!spec.url) return "handler";
+  const segments = spec.url.split("/").filter((s) => s && !s.startsWith("{") && !s.startsWith(":") && !s.includes("?"));
+  const lastSegment = segments[segments.length - 1] || "data";
+  const prefix = spec.method === "POST" ? "create" : spec.method === "PUT" ? "update" : spec.method === "DELETE" ? "delete" : "get";
+  const name = lastSegment.charAt(0).toUpperCase() + lastSegment.slice(1);
+  return `${prefix}${name}`;
+}
+
+// src/parser/pipeline-parser.ts
+var ARROW_DELIMITER = /\s*(?:→|->)\s*/;
+function parseFlowPipeline(dsl, input, language) {
+  const steps = [];
+  const errors = [];
+  const arrowParts = input.split(ARROW_DELIMITER);
+  const segments = [];
+  for (const part of arrowParts) {
+    const lines = part.split(/\n/).map((l) => l.trim()).filter(Boolean);
+    segments.push(...lines);
+  }
+  const commands = segments.filter((s) => !s.startsWith("--"));
+  for (const segment of commands) {
+    try {
+      const node = dsl.parse(segment, language);
+      steps.push({ node });
+    } catch (err) {
+      errors.push(
+        `Failed to parse step: "${segment}" - ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { steps, errors };
+}
+function compilePipeline(dsl, input, language) {
+  const { steps, errors } = parseFlowPipeline(dsl, input, language);
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  if (steps.length === 0) {
+    return { ok: false, errors: ["Empty pipeline"] };
+  }
+  if (steps.length === 1) {
+    const result = dsl.compile(input.replace(/→|->/g, "").trim(), language);
+    return {
+      ok: result.ok,
+      code: result.code ?? void 0,
+      errors: result.ok ? [] : ["Compilation failed"]
+    };
+  }
+  const compileErrors = [];
+  const codes = [];
+  for (const step of steps) {
+    const result = dsl.compile(renderStepBack(step.node, language), language);
+    if (result.ok && result.code) {
+      codes.push(result.code);
+    } else {
+      compileErrors.push(`Failed to compile step: ${step.node.action}`);
+    }
+  }
+  if (compileErrors.length > 0) {
+    return { ok: false, errors: compileErrors };
+  }
+  const combined = codes.join("\n\n// --- next step ---\n\n");
+  return { ok: true, code: combined, errors: [] };
+}
+function renderStepBack(node, language) {
+  return renderFlow(node, language);
+}
+
+// src/generators/workflow-generator.ts
+function toWorkflowSpec(specs) {
+  let entryPoint;
+  const steps = [];
+  let lastStep;
+  for (const spec of specs) {
+    switch (spec.action) {
+      case "enter": {
+        if (!spec.url) throw new Error("enter command requires a URL");
+        entryPoint = spec.url;
+        break;
+      }
+      case "follow": {
+        if (!spec.linkRel) throw new Error("follow command requires a link relation");
+        const step = { type: "navigate", rel: spec.linkRel };
+        steps.push(step);
+        lastStep = step;
+        break;
+      }
+      case "perform": {
+        if (!spec.actionName) throw new Error("perform command requires an action name");
+        const step = {
+          type: "action",
+          action: spec.actionName
+        };
+        if (spec.dataSource) {
+          step.dataSource = spec.dataSource;
+        }
+        steps.push(step);
+        lastStep = step;
+        break;
+      }
+      case "capture": {
+        if (!spec.captureAs) throw new Error("capture command requires a variable name");
+        if (lastStep && (lastStep.type === "navigate" || lastStep.type === "action")) {
+          if (!lastStep.capture) lastStep.capture = {};
+          lastStep.capture[spec.captureAs] = spec.capturePath || "properties";
+        } else {
+          const step = {
+            type: "navigate",
+            rel: "self",
+            capture: { [spec.captureAs]: spec.capturePath || "properties" }
+          };
+          steps.push(step);
+          lastStep = step;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (!entryPoint) {
+    throw new Error('Workflow requires an "enter" command to specify the API entry point');
+  }
+  return { entryPoint, steps };
+}
+function toSirenGrailSteps(spec) {
+  return spec.steps.map((step) => {
+    switch (step.type) {
+      case "navigate":
+        return {
+          type: "navigate",
+          rel: step.rel,
+          ...step.capture ? { capture: step.capture } : {}
+        };
+      case "action":
+        return {
+          type: "action",
+          action: step.action,
+          ...step.data ? { data: step.data } : {},
+          ...step.dataSource ? { dataSource: step.dataSource } : {},
+          ...step.capture ? { capture: step.capture } : {}
+        };
+      case "stop":
+        return {
+          type: "stop",
+          ...step.result ? { result: step.result } : {},
+          ...step.reason ? { reason: step.reason } : {}
+        };
+      default:
+        return step;
+    }
+  });
+}
+
+// src/runtime/workflow-executor.ts
+function toSirenSteps(steps) {
+  return steps.map((step) => {
+    switch (step.type) {
+      case "navigate":
+        return {
+          type: "navigate",
+          rel: step.rel,
+          ...step.capture ? { capture: step.capture } : {}
+        };
+      case "action":
+        return {
+          type: "action",
+          action: step.action,
+          ...step.data ? { data: step.data } : {},
+          ...step.dataSource ? { dataSource: step.dataSource } : {},
+          ...step.capture ? { capture: step.capture } : {}
+        };
+      case "stop":
+        return {
+          type: "stop",
+          ...step.result ? { result: step.result } : {},
+          ...step.reason ? { reason: step.reason } : {}
+        };
+      default:
+        return step;
+    }
+  });
+}
+async function executeWorkflow(spec, options = {}) {
+  let sirenAgent;
+  try {
+    sirenAgent = await import("siren-agent");
+  } catch {
+    throw new Error(
+      "siren-agent is required for workflow execution. Install it with: npm install siren-agent"
+    );
+  }
+  const { OODAAgent, compileWorkflow } = sirenAgent;
+  const steps = toSirenSteps(spec.steps);
+  const decide = compileWorkflow(steps);
+  const agent = new OODAAgent(spec.entryPoint, {
+    maxSteps: options.maxSteps ?? 50,
+    headers: options.headers,
+    verbose: options.verbose ?? false,
+    timeout: options.timeout ?? 3e4,
+    decide,
+    ...options.autoPursue ? { autoPursue: { maxDepth: 5 } } : {},
+    ...options.onEntity ? { onEntity: options.onEntity } : {},
+    ...options.onDecision ? { onDecision: options.onDecision } : {}
+  });
+  return agent.run();
+}
+function createWorkflowExecutor(defaultOptions = {}) {
+  return {
+    execute(spec, overrides) {
+      return executeWorkflow(spec, { ...defaultOptions, ...overrides });
+    }
+  };
+}
+
+// src/runtime/mcp-workflow-server.ts
+function actionsToTools(actions) {
+  return actions.map((action) => {
+    const properties = {};
+    const required = [];
+    for (const field of action.fields ?? []) {
+      properties[field.name] = {
+        type: fieldTypeToJsonSchema(field.type),
+        ...field.title ? { description: field.title } : {},
+        ...field.value !== void 0 ? { default: field.value } : {}
+      };
+      if (field.value === void 0) {
+        required.push(field.name);
+      }
+    }
+    return {
+      name: `action__${action.name}`,
+      description: action.title ?? `Execute the "${action.name}" action (${action.method ?? "POST"} ${action.href})`,
+      inputSchema: {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      }
+    };
+  });
+}
+function linksToTools(links) {
+  const seen = /* @__PURE__ */ new Set();
+  const tools = [];
+  for (const link of links) {
+    const rel = link.rel[0];
+    if (!rel || rel === "self" || seen.has(rel)) continue;
+    seen.add(rel);
+    tools.push({
+      name: `navigate__${rel}`,
+      description: link.title ?? `Navigate to "${rel}" (${link.href})`,
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    });
+  }
+  return tools;
+}
+function fieldTypeToJsonSchema(type) {
+  switch (type) {
+    case "number":
+    case "range":
+      return "number";
+    case "checkbox":
+      return "boolean";
+    case "hidden":
+    case "text":
+    case "email":
+    case "url":
+    case "password":
+    case "search":
+    case "tel":
+    case "date":
+    case "datetime-local":
+    case "time":
+    case "month":
+    case "week":
+    default:
+      return "string";
+  }
+}
+function entityToTools(entity) {
+  return [...actionsToTools(entity.actions ?? []), ...linksToTools(entity.links ?? [])];
+}
+var McpWorkflowServer = class {
+  config;
+  currentEntity = null;
+  currentUrl;
+  currentTools = [];
+  toolChangeListeners = [];
+  constructor(config) {
+    this.config = {
+      name: "hateoas-mcp-server",
+      version: "1.0.0",
+      ...config
+    };
+    this.currentUrl = config.entryPoint;
+  }
+  /**
+   * Register a listener for tool list changes (maps to tools/list_changed).
+   */
+  onToolsChanged(listener) {
+    this.toolChangeListeners.push(listener);
+  }
+  /**
+   * Initialize the server by fetching the entry point entity.
+   */
+  async initialize() {
+    const entity = await this.fetchEntity(this.config.entryPoint);
+    this.updateState(entity, this.config.entryPoint);
+  }
+  /**
+   * Get the current list of available MCP tools.
+   */
+  listTools() {
+    return this.currentTools;
+  }
+  /**
+   * Get the current entity as an MCP resource.
+   */
+  getCurrentEntity() {
+    return this.currentEntity;
+  }
+  /**
+   * Get the current URL.
+   */
+  getCurrentUrl() {
+    return this.currentUrl;
+  }
+  /**
+   * Call a tool (action or navigation).
+   *
+   * Returns the result text and triggers tools/list_changed if the
+   * entity state changed.
+   */
+  async callTool(name, args) {
+    if (!this.currentEntity) {
+      return { content: "Server not initialized. Call initialize() first.", isError: true };
+    }
+    const [prefix, ...rest] = name.split("__");
+    const identifier = rest.join("__");
+    try {
+      switch (prefix) {
+        case "action": {
+          const action = this.currentEntity.actions?.find((a) => a.name === identifier);
+          if (!action) {
+            return {
+              content: `Action "${identifier}" not available. Available: ${(this.currentEntity.actions ?? []).map((a) => a.name).join(", ")}`,
+              isError: true
+            };
+          }
+          const result = await this.executeAction(action, args);
+          return { content: JSON.stringify(result.properties ?? result, null, 2) };
+        }
+        case "navigate": {
+          const link = this.currentEntity.links?.find((l) => l.rel.includes(identifier));
+          if (!link) {
+            return {
+              content: `Link "${identifier}" not available. Available: ${(this.currentEntity.links ?? []).map((l) => l.rel[0]).join(", ")}`,
+              isError: true
+            };
+          }
+          const entity = await this.fetchEntity(link.href);
+          this.updateState(entity, link.href);
+          return { content: JSON.stringify(entity.properties ?? entity, null, 2) };
+        }
+        default:
+          return { content: `Unknown tool prefix: ${prefix}`, isError: true };
+      }
+    } catch (error) {
+      return {
+        content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+  }
+  /**
+   * Get MCP server capabilities for the initialize response.
+   */
+  getCapabilities() {
+    return {
+      tools: { listChanged: true },
+      resources: {}
+    };
+  }
+  /**
+   * Get MCP server info for the initialize response.
+   */
+  getServerInfo() {
+    return {
+      name: this.config.name,
+      version: this.config.version
+    };
+  }
+  // ===========================================================================
+  // Private
+  // ===========================================================================
+  async fetchEntity(url) {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/vnd.siren+json, application/json",
+        ...this.config.headers
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  async executeAction(action, data) {
+    const method = action.method?.toUpperCase() ?? "POST";
+    const headers = {
+      Accept: "application/vnd.siren+json, application/json",
+      ...this.config.headers
+    };
+    let body;
+    if (method !== "GET" && method !== "HEAD") {
+      headers["Content-Type"] = action.type ?? "application/json";
+      body = JSON.stringify(data);
+    }
+    const response = await fetch(action.href, { method, headers, body });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const entity = await response.json();
+    this.updateState(entity, action.href);
+    return entity;
+  }
+  updateState(entity, url) {
+    this.currentEntity = entity;
+    this.currentUrl = url;
+    this.currentTools = entityToTools(entity);
+    for (const listener of this.toolChangeListeners) {
+      listener();
+    }
+  }
+};
+function createMcpWorkflowServer(config) {
+  return new McpWorkflowServer(config);
+}
+
+// src/index.ts
+function createFlowDSL() {
+  return /* @__PURE__ */ createMultilingualDSL({
+    name: "FlowScript",
+    schemas: allSchemas,
+    languages: [
+      {
+        code: "en",
+        name: "English",
+        nativeName: "English",
+        tokenizer: EnglishFlowTokenizer,
+        patternProfile: englishProfile
+      },
+      {
+        code: "es",
+        name: "Spanish",
+        nativeName: "Espa\xF1ol",
+        tokenizer: SpanishFlowTokenizer,
+        patternProfile: spanishProfile
+      },
+      {
+        code: "ja",
+        name: "Japanese",
+        nativeName: "\u65E5\u672C\u8A9E",
+        tokenizer: JapaneseFlowTokenizer,
+        patternProfile: japaneseProfile
+      },
+      {
+        code: "ar",
+        name: "Arabic",
+        nativeName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629",
+        tokenizer: ArabicFlowTokenizer,
+        patternProfile: arabicProfile
+      },
+      {
+        code: "ko",
+        name: "Korean",
+        nativeName: "\uD55C\uAD6D\uC5B4",
+        tokenizer: KoreanFlowTokenizer,
+        patternProfile: koreanProfile
+      },
+      {
+        code: "zh",
+        name: "Chinese",
+        nativeName: "\u4E2D\u6587",
+        tokenizer: ChineseFlowTokenizer,
+        patternProfile: chineseProfile
+      },
+      {
+        code: "tr",
+        name: "Turkish",
+        nativeName: "T\xFCrk\xE7e",
+        tokenizer: TurkishFlowTokenizer,
+        patternProfile: turkishProfile
+      },
+      {
+        code: "fr",
+        name: "French",
+        nativeName: "Fran\xE7ais",
+        tokenizer: FrenchFlowTokenizer,
+        patternProfile: frenchProfile
+      }
+    ],
+    codeGenerator: flowCodeGenerator
+  });
+}
+var flowScanConfig = {
+  attributes: ["data-flow", "_flow"],
+  scriptTypes: ["text/flowscript"],
+  defaultLanguage: "en"
+};
+export {
+  ArabicFlowTokenizer,
+  ChineseFlowTokenizer,
+  EnglishFlowTokenizer,
+  FrenchFlowTokenizer,
+  JapaneseFlowTokenizer,
+  KoreanFlowTokenizer,
+  McpWorkflowServer,
+  SpanishFlowTokenizer,
+  TurkishFlowTokenizer,
+  actionsToTools,
+  allSchemas,
+  arabicProfile,
+  captureSchema,
+  chineseProfile,
+  compilePipeline,
+  createFlowDSL,
+  createMcpWorkflowServer,
+  createWorkflowExecutor,
+  englishProfile,
+  enterSchema,
+  entityToTools,
+  executeWorkflow,
+  extractRoute,
+  extractRoutes,
+  fetchSchema,
+  flowCodeGenerator,
+  flowScanConfig,
+  followSchema,
+  frenchProfile,
+  generateHTMX,
+  hateoasSchemas,
+  japaneseProfile,
+  koreanProfile,
+  linksToTools,
+  parseDuration,
+  parseFlowPipeline,
+  performSchema,
+  pollSchema,
+  renderFlow,
+  spanishProfile,
+  streamSchema,
+  submitSchema,
+  toFlowSpec,
+  toSirenGrailSteps,
+  toSirenSteps,
+  toWorkflowSpec,
+  transformSchema,
+  turkishProfile
+};
+//# sourceMappingURL=index.js.map