@walkeros/explorer 2.1.0 → 2.1.1

package/dist/index.mjs

@@ -5,13 +5,14 @@ import {
   loadPackageTypes,
   loadTypeLibraryFromURL,
   registerWalkerOSTypes
-} from "./chunk-YKT4D7MG.mjs";
+} from "./chunk-4AJX6MFW.mjs";
 
 // src/components/demos/MappingDemo.tsx
 import { useState as useState6, useCallback as useCallback5, useEffect as useEffect5 } from "react";
 
 // src/components/molecules/code-box.tsx
 import { useState as useState4, useCallback as useCallback3, useRef as useRef4, useEffect as useEffect3 } from "react";
+import * as monacoNs from "monaco-editor";
 
 // src/components/atoms/box.tsx
 import { useState } from "react";
@@ -646,6 +647,348 @@ function registerDataElbStyles() {
   document.head.appendChild(style);
 }
 
+// src/utils/monaco-walkeros-decorations.ts
+var REFERENCE_PATTERNS = [
+  { type: "variable", regex: /\$var\.(\w*)/g, className: "elb-ref-variable" },
+  {
+    type: "definition",
+    regex: /\$def\.(\w*)/g,
+    className: "elb-ref-definition"
+  },
+  { type: "secret", regex: /\$secret\.(\w*)/g, className: "elb-ref-secret" },
+  { type: "env", regex: /\$env\.(\w*)/g, className: "elb-ref-env" },
+  { type: "code", regex: /\$code:/g, className: "elb-ref-code" }
+];
+function findWalkerOSReferences(text) {
+  const references = [];
+  for (const pattern of REFERENCE_PATTERNS) {
+    const regex2 = new RegExp(pattern.regex.source, pattern.regex.flags);
+    let match;
+    while ((match = regex2.exec(text)) !== null) {
+      references.push({
+        type: pattern.type,
+        name: pattern.type === "code" ? "" : match[1] || "",
+        startIndex: match.index,
+        endIndex: match.index + match[0].length
+      });
+    }
+  }
+  return references;
+}
+function applyWalkerOSDecorations(editorInstance) {
+  let decorationIds = [];
+  function update() {
+    const model = editorInstance.getModel();
+    if (!model) return;
+    const text = model.getValue();
+    const references = findWalkerOSReferences(text);
+    const decorations = references.map(
+      (ref) => {
+        const startPos = model.getPositionAt(ref.startIndex);
+        const endPos = model.getPositionAt(ref.endIndex);
+        const pattern = REFERENCE_PATTERNS.find((p) => p.type === ref.type);
+        return {
+          range: {
+            startLineNumber: startPos.lineNumber,
+            startColumn: startPos.column,
+            endLineNumber: endPos.lineNumber,
+            endColumn: endPos.column
+          },
+          options: { inlineClassName: pattern.className }
+        };
+      }
+    );
+    decorationIds = editorInstance.deltaDecorations(decorationIds, decorations);
+  }
+  update();
+  const disposable = editorInstance.onDidChangeModelContent(() => update());
+  return () => {
+    disposable.dispose();
+    editorInstance.deltaDecorations(decorationIds, []);
+  };
+}
+function registerWalkerOSDecorationStyles() {
+  if (typeof document === "undefined") return;
+  if (document.getElementById("walkeros-ref-styles")) return;
+  const style = document.createElement("style");
+  style.id = "walkeros-ref-styles";
+  style.textContent = `
+    .monaco-editor .elb-ref-variable { color: #89ddff !important; font-style: italic; }
+    .monaco-editor .elb-ref-definition { color: #c3e88d !important; font-style: italic; }
+    .monaco-editor .elb-ref-secret { color: #ffcb6b !important; font-style: italic; }
+    .monaco-editor .elb-ref-env { color: #ffcb6b !important; font-style: italic; }
+    .monaco-editor .elb-ref-code { color: #c084fc !important; }
+  `;
+  document.head.appendChild(style);
+}
+
+// src/utils/monaco-walkeros-completions.ts
+function getVariableCompletions(variables) {
+  if (!variables || Object.keys(variables).length === 0) return [];
+  return Object.entries(variables).map(([name, value]) => ({
+    label: `$var.${name}`,
+    insertText: `$var.${name}`,
+    detail: `= ${JSON.stringify(value)}`,
+    documentation: `Variable reference. Resolves to \`${JSON.stringify(value)}\` at runtime.`,
+    kind: "variable",
+    sortText: "0_var_" + name
+  }));
+}
+function getDefinitionCompletions(definitions) {
+  if (!definitions || Object.keys(definitions).length === 0) return [];
+  return Object.keys(definitions).map((name) => ({
+    label: `$def.${name}`,
+    insertText: `$def.${name}`,
+    detail: "(definition)",
+    documentation: `Definition reference. Injects the reusable config fragment "${name}" at runtime.`,
+    kind: "reference",
+    sortText: "0_def_" + name
+  }));
+}
+function getSecretCompletions(secrets) {
+  if (!secrets || secrets.length === 0) return [];
+  return secrets.map((name) => ({
+    label: `$secret.${name}`,
+    insertText: `$secret.${name}`,
+    detail: "(secret)",
+    documentation: "Secret reference. Value is securely injected at runtime. Never stored in config.",
+    kind: "secret",
+    sortText: "0_secret_" + name
+  }));
+}
+function getPackageCompletions(packages, platform) {
+  if (!packages || packages.length === 0) return [];
+  const filtered = platform ? packages.filter((p) => p.platform === platform) : packages;
+  return filtered.map((pkg) => ({
+    label: pkg.package,
+    insertText: pkg.package,
+    detail: `${pkg.type} (${pkg.platform})`,
+    documentation: `walkerOS ${pkg.type}: ${pkg.shortName}`,
+    kind: "module",
+    sortText: "1_pkg_" + pkg.shortName
+  }));
+}
+function getStepNameCompletions(stepNames, context) {
+  if (!stepNames) return [];
+  const names = stepNames.transformers || [];
+  return names.map((name) => ({
+    label: name,
+    insertText: name,
+    detail: `transformer (${context} chain)`,
+    documentation: `Reference to transformer step "${name}" in this flow config.`,
+    kind: "reference",
+    sortText: "0_step_" + name
+  }));
+}
+
+// src/utils/monaco-walkeros-providers.ts
+var contextRegistry = /* @__PURE__ */ new Map();
+var disposables = [];
+var registered = false;
+function setIntelliSenseContext(modelPath, context) {
+  contextRegistry.set(modelPath, context);
+}
+function removeIntelliSenseContext(modelPath) {
+  contextRegistry.delete(modelPath);
+}
+function registerWalkerOSProviders(monaco) {
+  if (registered) return;
+  registered = true;
+  disposables.push(
+    monaco.languages.registerCompletionItemProvider("json", {
+      triggerCharacters: ['"', ".", "$"],
+      provideCompletionItems(model, position) {
+        const modelPath = model.uri.toString();
+        const context = contextRegistry.get(modelPath);
+        if (!context) return { suggestions: [] };
+        const lineContent = model.getLineContent(position.lineNumber);
+        const textBeforeCursor = lineContent.substring(0, position.column - 1);
+        const entries = [];
+        if (textBeforeCursor.includes("$var.") || textBeforeCursor.endsWith('"$var')) {
+          entries.push(...getVariableCompletions(context.variables));
+        } else if (textBeforeCursor.includes("$def.") || textBeforeCursor.endsWith('"$def')) {
+          entries.push(...getDefinitionCompletions(context.definitions));
+        } else if (textBeforeCursor.includes("$secret.") || textBeforeCursor.endsWith('"$secret')) {
+          entries.push(...getSecretCompletions(context.secrets));
+        } else if (isInsideKey(model, position, "package")) {
+          entries.push(
+            ...getPackageCompletions(context.packages, context.platform)
+          );
+        } else if (isInsideKey(model, position, "next") || isInsideKey(model, position, "before")) {
+          const key = isInsideKey(model, position, "next") ? "next" : "before";
+          entries.push(...getStepNameCompletions(context.stepNames, key));
+        } else if (textBeforeCursor.endsWith('"$') || textBeforeCursor.endsWith('"')) {
+          entries.push(...getVariableCompletions(context.variables));
+          entries.push(...getDefinitionCompletions(context.definitions));
+          entries.push(...getSecretCompletions(context.secrets));
+        }
+        const refStartMatch = textBeforeCursor.match(
+          /\$(?:var|def|secret|env|code)[.:]?\w*$/
+        );
+        const word = model.getWordUntilPosition(position);
+        const startCol = refStartMatch ? position.column - refStartMatch[0].length : word.startColumn;
+        const range = {
+          startLineNumber: position.lineNumber,
+          endLineNumber: position.lineNumber,
+          startColumn: startCol,
+          endColumn: position.column
+        };
+        return {
+          suggestions: entries.map((entry) => ({
+            label: entry.label,
+            insertText: entry.insertText,
+            detail: entry.detail,
+            documentation: entry.documentation,
+            kind: mapCompletionKind(monaco, entry.kind),
+            sortText: entry.sortText,
+            range
+          }))
+        };
+      }
+    })
+  );
+  disposables.push(
+    monaco.languages.registerHoverProvider("json", {
+      provideHover(model, position) {
+        const modelPath = model.uri.toString();
+        const context = contextRegistry.get(modelPath);
+        if (!context) return null;
+        const lineContent = model.getLineContent(position.lineNumber);
+        const col = position.column - 1;
+        function matchAtCursor(pattern) {
+          const regex2 = new RegExp(pattern.source, "g");
+          let m;
+          while ((m = regex2.exec(lineContent)) !== null) {
+            if (col >= m.index && col <= m.index + m[0].length) return m;
+          }
+          return null;
+        }
+        const varMatch = matchAtCursor(/\$var\.(\w+)/);
+        if (varMatch && context.variables) {
+          const name = varMatch[1];
+          if (name in context.variables) {
+            const value = context.variables[name];
+            return {
+              range: {
+                startLineNumber: position.lineNumber,
+                startColumn: varMatch.index + 1,
+                endLineNumber: position.lineNumber,
+                endColumn: varMatch.index + varMatch[0].length + 1
+              },
+              contents: [
+                {
+                  value: `**Variable:** \`$var.${name}\`
+
+**Value:** \`${JSON.stringify(value)}\`
+
+*Resolved at runtime via variable interpolation*`
+                }
+              ]
+            };
+          }
+          return {
+            contents: [
+              {
+                value: `**Unknown variable** \`$var.${name}\`
+
+Defined variables: ${Object.keys(context.variables).join(", ") || "none"}`
+              }
+            ]
+          };
+        }
+        const defMatch = matchAtCursor(/\$def\.(\w+)/);
+        if (defMatch && context.definitions) {
+          const name = defMatch[1];
+          if (name in context.definitions) {
+            return {
+              range: {
+                startLineNumber: position.lineNumber,
+                startColumn: defMatch.index + 1,
+                endLineNumber: position.lineNumber,
+                endColumn: defMatch.index + defMatch[0].length + 1
+              },
+              contents: [
+                {
+                  value: `**Definition:** \`$def.${name}\`
+
+*Injects reusable config fragment at runtime*`
+                }
+              ]
+            };
+          }
+          return {
+            contents: [
+              {
+                value: `**Unknown definition** \`$def.${name}\`
+
+Defined: ${Object.keys(context.definitions).join(", ") || "none"}`
+              }
+            ]
+          };
+        }
+        const secretMatch = matchAtCursor(/\$secret\.(\w+)/);
+        if (secretMatch) {
+          const name = secretMatch[1];
+          if (context.secrets?.includes(name)) {
+            return {
+              range: {
+                startLineNumber: position.lineNumber,
+                startColumn: secretMatch.index + 1,
+                endLineNumber: position.lineNumber,
+                endColumn: secretMatch.index + secretMatch[0].length + 1
+              },
+              contents: [
+                {
+                  value: `**Secret:** \`$secret.${name}\`
+
+*Securely injected at runtime. Value not stored in config.*`
+                }
+              ]
+            };
+          }
+          return {
+            contents: [
+              {
+                value: `**Unknown secret** \`$secret.${name}\`
+
+Available secrets: ${context.secrets?.join(", ") || "none"}`
+              }
+            ]
+          };
+        }
+        return null;
+      }
+    })
+  );
+}
+function disposeWalkerOSProviders() {
+  for (const d of disposables) d.dispose();
+  disposables.length = 0;
+  registered = false;
+  contextRegistry.clear();
+}
+function mapCompletionKind(monaco, kind) {
+  switch (kind) {
+    case "variable":
+      return monaco.languages.CompletionItemKind.Variable;
+    case "reference":
+      return monaco.languages.CompletionItemKind.Reference;
+    case "secret":
+      return monaco.languages.CompletionItemKind.Constant;
+    case "module":
+      return monaco.languages.CompletionItemKind.Module;
+    case "property":
+      return monaco.languages.CompletionItemKind.Property;
+    default:
+      return monaco.languages.CompletionItemKind.Text;
+  }
+}
+function isInsideKey(model, position, key) {
+  const lineContent = model.getLineContent(position.lineNumber);
+  const pattern = new RegExp(`"${key}"\\s*:\\s*"`);
+  return pattern.test(lineContent);
+}
+
 // src/utils/monaco-formatters.ts
 import * as prettier from "prettier/standalone";
 import prettierBabel from "prettier/plugins/babel";
@@ -839,19 +1182,19 @@ function useMonacoHeight({
     }
   }, [enabled, minHeight, maxHeight, onHeightChange]);
   const setEditor = useCallback(
-    (editor) => {
+    (editor2) => {
       if (updateTimeoutRef.current) {
         clearTimeout(updateTimeoutRef.current);
         updateTimeoutRef.current = null;
       }
-      editorRef.current = editor;
-      if (!enabled || !editor) {
+      editorRef.current = editor2;
+      if (!enabled || !editor2) {
         setHeight(defaultHeight);
         previousHeightRef.current = defaultHeight;
         return;
       }
       setTimeout(() => updateHeight(), 50);
-      const disposable = editor.onDidContentSizeChange(() => {
+      const disposable = editor2.onDidContentSizeChange(() => {
         if (updateTimeoutRef.current) {
           clearTimeout(updateTimeoutRef.current);
         }
@@ -860,7 +1203,7 @@ function useMonacoHeight({
           updateTimeoutRef.current = null;
         }, 150);
       });
-      editor.__heightDisposable = disposable;
+      editor2.__heightDisposable = disposable;
     },
     [enabled, defaultHeight, updateHeight]
   );
@@ -886,11 +1229,14 @@ function Code({
   packages,
   sticky = true,
   ide = false,
-  jsonSchema
+  jsonSchema,
+  intellisenseContext,
+  validate,
+  onMarkerCounts
 }) {
   const [isMounted, setIsMounted] = useState3(false);
   const [monacoTheme, setMonacoTheme] = useState3("vs-light");
-  const decorationsCleanupRef = useRef3(null);
+  const decorationsCleanupRef = useRef3([]);
   const monacoRef = useRef3(null);
   const editorRef = useRef3(null);
   const containerRef = useRef3(null);
@@ -965,12 +1311,12 @@ function Code({
     };
   }, [isMounted, getDataTheme]);
   useEffect2(() => {
-    const editor = editorRef.current;
+    const editor2 = editorRef.current;
     const container = containerRef.current;
-    if (!editor || !container) return;
+    if (!editor2 || !container) return;
     const resizeObserver = new ResizeObserver(() => {
       requestAnimationFrame(() => {
-        editor.layout();
+        editor2.layout();
       });
     });
     resizeObserver.observe(container);
@@ -979,7 +1325,13 @@ function Code({
     };
   }, []);
   const modelPathRef = useRef3(null);
-  if (jsonSchema && !modelPathRef.current) {
+  const intellisenseContextRef = useRef3(intellisenseContext);
+  intellisenseContextRef.current = intellisenseContext;
+  const validateRef = useRef3(validate);
+  validateRef.current = validate;
+  const onMarkerCountsRef = useRef3(onMarkerCounts);
+  onMarkerCountsRef.current = onMarkerCounts;
+  if ((jsonSchema || intellisenseContext) && !modelPathRef.current) {
     modelPathRef.current = generateModelPath();
   }
   useEffect2(() => {
@@ -991,6 +1343,16 @@ function Code({
       }
     };
   }, [jsonSchema]);
+  useEffect2(() => {
+    if (intellisenseContext && modelPathRef.current) {
+      setIntelliSenseContext(modelPathRef.current, intellisenseContext);
+      return () => {
+        if (modelPathRef.current) {
+          removeIntelliSenseContext(modelPathRef.current);
+        }
+      };
+    }
+  }, [intellisenseContext]);
   const handleChange = (value) => {
     if (onChange && value !== void 0) {
       onChange(value);
@@ -1002,7 +1364,7 @@ function Code({
     registerFormatters(monaco);
     if (packages && packages.length > 0) {
       registerWalkerOSTypes(monaco);
-      const { loadPackageTypes: loadPackageTypes2 } = await import("./monaco-types-OLSF6MIE.mjs");
+      const { loadPackageTypes: loadPackageTypes2 } = await import("./monaco-types-KN2DINPW.mjs");
       for (const pkg of packages) {
         if (pkg !== "@walkeros/core") {
           await loadPackageTypes2(monaco, { package: pkg }).catch(() => {
@@ -1014,6 +1376,9 @@ function Code({
     const isDark = dataTheme === "dark" || dataTheme === null && window.matchMedia("(prefers-color-scheme: dark)").matches;
     const themeName = isDark ? "elbTheme-dark" : "elbTheme-light";
     monaco.editor.setTheme(themeName);
+    if (language === "json") {
+      registerWalkerOSProviders(monaco);
+    }
     if (beforeMount) {
       beforeMount(monaco);
     }
@@ -1025,11 +1390,54 @@ function Code({
       registerEditor(monacoEditor);
     }
     if (language === "html" && monacoRef.current) {
-      decorationsCleanupRef.current = applyDataElbDecorations(
-        monacoEditor,
-        monacoRef.current
+      decorationsCleanupRef.current.push(
+        applyDataElbDecorations(monacoEditor, monacoRef.current)
+      );
+    }
+    if (language === "json") {
+      registerWalkerOSDecorationStyles();
+      decorationsCleanupRef.current.push(
+        applyWalkerOSDecorations(monacoEditor)
       );
     }
+    if (validateRef.current && monacoRef.current) {
+      const monacoInstance = monacoRef.current;
+      let validateTimer;
+      const runValidation = () => {
+        const model = monacoEditor.getModel();
+        if (!model) return;
+        const text = model.getValue();
+        const fn = validateRef.current;
+        if (!fn) return;
+        const result = fn(text);
+        const allIssues = [...result.errors, ...result.warnings];
+        monacoInstance.editor.setModelMarkers(
+          model,
+          "validate",
+          allIssues.map((issue) => ({
+            severity: issue.severity === "error" ? 8 : 4,
+            message: issue.message,
+            startLineNumber: issue.line,
+            startColumn: issue.column,
+            endLineNumber: issue.endLine ?? issue.line,
+            endColumn: issue.endColumn ?? issue.column + 1
+          }))
+        );
+        onMarkerCountsRef.current?.({
+          errors: result.errors.length,
+          warnings: result.warnings.length
+        });
+      };
+      runValidation();
+      const validateDisposable = monacoEditor.onDidChangeModelContent(() => {
+        clearTimeout(validateTimer);
+        validateTimer = setTimeout(runValidation, 300);
+      });
+      decorationsCleanupRef.current.push(() => {
+        clearTimeout(validateTimer);
+        validateDisposable.dispose();
+      });
+    }
     requestAnimationFrame(() => {
       monacoEditor.layout();
     });
@@ -1039,9 +1447,10 @@ function Code({
   };
   useEffect2(() => {
     return () => {
-      if (decorationsCleanupRef.current) {
-        decorationsCleanupRef.current();
+      for (const cleanup of decorationsCleanupRef.current) {
+        cleanup();
       }
+      decorationsCleanupRef.current = [];
     };
   }, []);
   const monacoHeight = autoHeight || gridContext?.enabled ? `${calculatedHeight}px` : "100%";
@@ -1081,7 +1490,7 @@ function Code({
         overviewRulerLanes: 0,
         renderLineHighlight: "none",
         renderValidationDecorations: ide || jsonSchema ? "editable" : "off",
-        hover: { enabled: ide || !!jsonSchema },
+        hover: { enabled: ide || !!jsonSchema || !!intellisenseContext },
         "semanticHighlighting.enabled": ide,
         showDeprecated: ide,
         showUnused: ide,
@@ -1115,7 +1524,7 @@ function Code({
         // Don't select line when clicking line numbers
         wordBasedSuggestions: "off",
         // Reduce auto-completion interference
-        quickSuggestions: jsonSchema ? { strings: true, other: true, comments: false } : false,
+        quickSuggestions: jsonSchema || intellisenseContext ? { strings: true, other: true, comments: false } : false,
         stickyScroll: { enabled: sticky }
       }
     }
@@ -1146,6 +1555,8 @@ function CodeBox({
   showCopy = true,
   showFormat = false,
   showSettings = false,
+  // Validation
+  onValidationIssues,
   // Layout
   footer,
   height,
@@ -1153,6 +1564,7 @@ function CodeBox({
   className,
   ...codeProps
 }) {
+  const { onMount: userOnMount, ...restCodeProps } = codeProps;
   const [copied, setCopied] = useState4(false);
   const [showSettingsPanel, setShowSettingsPanel] = useState4(false);
   const [settings, setSettings] = useState4({
@@ -1162,6 +1574,9 @@ function CodeBox({
     sticky: true
   });
   const settingsRef = useRef4(null);
+  const [markerCounts, setMarkerCounts] = useState4({ errors: 0, warnings: 0 });
+  const editorInstanceRef = useRef4(null);
+  const lastJumpIndexRef = useRef4({ errors: -1, warnings: -1 });
   useEffect3(() => {
     if (!showSettingsPanel) return;
     const handleClickOutside = (e) => {
@@ -1204,6 +1619,42 @@ function CodeBox({
     } catch (e) {
     }
   };
+  const handleEditorMount = useCallback3(
+    (monacoEditor) => {
+      editorInstanceRef.current = monacoEditor;
+      userOnMount?.(monacoEditor);
+    },
+    [userOnMount]
+  );
+  const handleMarkerCounts = useCallback3(
+    (counts) => {
+      setMarkerCounts(counts);
+      lastJumpIndexRef.current = { errors: -1, warnings: -1 };
+      onValidationIssues?.(counts);
+    },
+    [onValidationIssues]
+  );
+  const jumpToMarker = useCallback3((severity) => {
+    const ed = editorInstanceRef.current;
+    if (!ed) return;
+    const model = ed.getModel();
+    if (!model) return;
+    const severityValue = severity === "error" ? 8 : 4;
+    const markers = monacoNs.editor.getModelMarkers({ resource: model.uri }).filter((m) => m.severity === severityValue).sort(
+      (a, b) => a.startLineNumber - b.startLineNumber || a.startColumn - b.startColumn
+    );
+    if (markers.length === 0) return;
+    const key = severity === "error" ? "errors" : "warnings";
+    const nextIndex = (lastJumpIndexRef.current[key] + 1) % markers.length;
+    lastJumpIndexRef.current[key] = nextIndex;
+    const marker = markers[nextIndex];
+    ed.revealLineInCenter(marker.startLineNumber);
+    ed.setPosition({
+      lineNumber: marker.startLineNumber,
+      column: marker.startColumn
+    });
+    ed.focus();
+  }, []);
   const settingsProps = {
     lineNumbers: settings.lineNumbers,
     minimap: settings.minimap,
@@ -1211,6 +1662,60 @@ function CodeBox({
     sticky: settings.sticky
   };
   const actions = /* @__PURE__ */ jsxs3("div", { style: { display: "flex", gap: "4px", alignItems: "center" }, children: [
+    markerCounts.errors > 0 && /* @__PURE__ */ jsxs3(
+      "button",
+      {
+        className: "elb-codebox-marker-badge elb-codebox-marker-badge--error",
+        onClick: () => jumpToMarker("error"),
+        title: `${markerCounts.errors} error${markerCounts.errors !== 1 ? "s" : ""} \u2014 click to jump`,
+        children: [
+          /* @__PURE__ */ jsxs3(
+            "svg",
+            {
+              width: "14",
+              height: "14",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              children: [
+                /* @__PURE__ */ jsx4("circle", { cx: "12", cy: "12", r: "10" }),
+                /* @__PURE__ */ jsx4("line", { x1: "15", y1: "9", x2: "9", y2: "15" }),
+                /* @__PURE__ */ jsx4("line", { x1: "9", y1: "9", x2: "15", y2: "15" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx4("span", { children: markerCounts.errors })
+        ]
+      }
+    ),
+    markerCounts.warnings > 0 && /* @__PURE__ */ jsxs3(
+      "button",
+      {
+        className: "elb-codebox-marker-badge elb-codebox-marker-badge--warning",
+        onClick: () => jumpToMarker("warning"),
+        title: `${markerCounts.warnings} warning${markerCounts.warnings !== 1 ? "s" : ""} \u2014 click to jump`,
+        children: [
+          /* @__PURE__ */ jsxs3(
+            "svg",
+            {
+              width: "14",
+              height: "14",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              children: [
+                /* @__PURE__ */ jsx4("path", { d: "M12 3L2 21h20L12 3z" }),
+                /* @__PURE__ */ jsx4("line", { x1: "12", y1: "9", x2: "12", y2: "13" }),
+                /* @__PURE__ */ jsx4("line", { x1: "12", y1: "17", x2: "12.01", y2: "17" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx4("span", { children: markerCounts.warnings })
+        ]
+      }
+    ),
     showFormat && !disabled && currentLanguage === "json" && /* @__PURE__ */ jsx4(
       "button",
       {
@@ -1363,7 +1868,9 @@ function CodeBox({
         onChange,
         disabled,
         autoHeight,
-        ...codeProps,
+        onMount: handleEditorMount,
+        onMarkerCounts: handleMarkerCounts,
+        ...restCodeProps,
         ...settingsProps
       }
     )
@@ -1391,7 +1898,9 @@ function CodeBox({
           onChange,
           disabled,
           autoHeight,
-          ...codeProps,
+          onMount: handleEditorMount,
+          onMarkerCounts: handleMarkerCounts,
+          ...restCodeProps,
           ...settingsProps
         }
       )
@@ -2058,7 +2567,9 @@ function Preview({
         setTimeout(async () => {
           if (sourceRef.current) {
             try {
-              await sourceRef.current.destroy?.();
+              await sourceRef.current.instance.destroy?.(
+                sourceRef.current.destroyContext
+              );
             } catch {
             }
           }
@@ -2083,34 +2594,44 @@ function Preview({
               ok: true,
               destination: {}
             });
-            const source = await sourceBrowser({
+            const config = {
+              settings: {
+                pageview: false,
+                prefix: "data-elb",
+                elb: "elb",
+                elbLayer: "elbLayer",
+                // Use body as scope - trigger.ts compares `scope !== document` against
+                // main page's document, so iframe.contentDocument fails the Element cast
+                scope: iframe.contentDocument.body
+              }
+            };
+            const env = {
+              elb: elbRef.current,
+              push: noopPush,
+              command: async () => ({ ok: true, destination: {} }),
+              logger: noopLogger,
+              window: iframe.contentWindow,
+              document: iframe.contentDocument
+            };
+            const instance = await sourceBrowser({
               id: "preview",
               collector: {},
               // Not used when elb is provided directly
               logger: noopLogger,
               setIngest: async () => {
               },
-              config: {
-                settings: {
-                  pageview: false,
-                  prefix: "data-elb",
-                  elb: "elb",
-                  elbLayer: "elbLayer",
-                  // Use body as scope - trigger.ts compares `scope !== document` against
-                  // main page's document, so iframe.contentDocument fails the Element cast
-                  scope: iframe.contentDocument.body
-                }
-              },
-              env: {
-                elb: elbRef.current,
-                push: noopPush,
-                command: async () => ({ ok: true, destination: {} }),
-                logger: noopLogger,
-                window: iframe.contentWindow,
-                document: iframe.contentDocument
-              }
+              config,
+              env
             });
-            sourceRef.current = source;
+            sourceRef.current = {
+              instance,
+              destroyContext: {
+                id: "preview",
+                config,
+                env,
+                logger: noopLogger
+              }
+            };
           } catch {
           }
         }, 50);
@@ -2121,7 +2642,7 @@ function Preview({
         clearTimeout(updateTimeoutRef.current);
       }
       if (sourceRef.current) {
-        sourceRef.current.destroy?.();
+        sourceRef.current.instance.destroy?.(sourceRef.current.destroyContext);
       }
     };
   }, [html, css, highlights, autoMarkProperties, elb]);
@@ -3392,14 +3913,14 @@ function detectNodeType(value, path, structure, schemas) {
   const schema = propertyDef && schemas ? resolveSchema(path.slice(propertyDefIndex), propertyDef, schemas) : void 0;
   if (schema) {
     const primitiveType = typeof value;
-    const isPrimitive = primitiveType === "string" || primitiveType === "number" || primitiveType === "boolean" || value === void 0 || value === null;
+    const isPrimitive2 = primitiveType === "string" || primitiveType === "number" || primitiveType === "boolean" || value === void 0 || value === null;
     if (schema.type === "boolean" && (primitiveType === "boolean" || value === void 0 || value === null)) {
       return "boolean";
     }
-    if (schema.enum && Array.isArray(schema.enum) && schema.enum.length > 0 && isPrimitive) {
+    if (schema.enum && Array.isArray(schema.enum) && schema.enum.length > 0 && isPrimitive2) {
       return "enum";
     }
-    if ((schema.type === "string" || schema.type === "number") && isPrimitive) {
+    if ((schema.type === "string" || schema.type === "number") && isPrimitive2) {
       return "primitive";
     }
     if (schema.type === "array") {
@@ -17498,6 +18019,474 @@ function useDropdown() {
     containerRef
   };
 }
+
+// src/utils/monaco-schema-enrichment.ts
+function enrichSchema(baseSchema, enrichments) {
+  const schema = JSON.parse(JSON.stringify(baseSchema));
+  for (const [path, extensions] of Object.entries(enrichments)) {
+    const target = path === "" ? schema : getNestedObject(schema, path);
+    if (target && typeof target === "object") {
+      Object.assign(target, extensions);
+    }
+  }
+  return schema;
+}
+function getNestedObject(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current && typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+
+// src/utils/monaco-schema-flow-setup.ts
+function enrichFlowSetupSchema(baseSchema) {
+  const schema = JSON.parse(JSON.stringify(baseSchema));
+  if (!schema.anyOf?.[0]?.properties) return schema;
+  const root = schema.anyOf[0];
+  const props = root.properties;
+  const flowConfig = props.flows?.additionalProperties?.properties;
+  if (props.version) {
+    props.version.markdownDescription = 'Schema version number. Must be `1` for the current format.\n\n```json\n"version": 1\n```';
+  }
+  if (props.$schema) {
+    props.$schema.markdownDescription = 'JSON Schema URI for IDE validation.\n\n```json\n"$schema": "https://walkeros.io/schema/flow/v1.json"\n```';
+  }
+  if (props.include) {
+    props.include.markdownDescription = 'Folders to include in the bundle output.\n\n```json\n"include": ["./src", "./lib"]\n```';
+  }
+  if (props.variables) {
+    props.variables.markdownDescription = 'Shared variables for `$var.name` interpolation across all flows.\n\n```json\n"variables": {\n  "measurementId": "G-XXXXXXXXXX",\n  "debug": false\n}\n```\n\nReference in any config value: `"$var.measurementId"`';
+    props.variables.defaultSnippets = [
+      {
+        label: "Add variable",
+        description: "New key-value variable",
+        body: { "${1:name}": "${2:value}" }
+      }
+    ];
+  }
+  if (props.definitions) {
+    props.definitions.markdownDescription = 'Reusable configuration fragments for `$def.name` references.\n\n```json\n"definitions": {\n  "gaConfig": {\n    "measurementId": "$var.trackingId"\n  }\n}\n```\n\nReference in any config: `"$def.gaConfig"`';
+    props.definitions.defaultSnippets = [
+      {
+        label: "Add definition",
+        description: "New reusable config fragment",
+        body: { "${1:name}": { "${2:key}": "${3:value}" } }
+      }
+    ];
+  }
+  if (props.flows) {
+    props.flows.markdownDescription = 'Flow configurations keyed by name. Each flow defines a complete event pipeline.\n\n```json\n"flows": {\n  "myFlow": {\n    "web": {},\n    "sources": { ... },\n    "destinations": { ... }\n  }\n}\n```';
+    props.flows.defaultSnippets = [
+      {
+        label: "Web flow (basic)",
+        description: "Minimal web flow with browser source",
+        body: {
+          "${1:myFlow}": {
+            web: {},
+            sources: {
+              browser: { package: "@walkeros/web-source-browser" }
+            },
+            destinations: {}
+          }
+        }
+      },
+      {
+        label: "Server flow (basic)",
+        description: "Minimal server flow with Express source",
+        body: {
+          "${1:myFlow}": {
+            server: {},
+            sources: {
+              express: { package: "@walkeros/server-source-express" }
+            },
+            destinations: {}
+          }
+        }
+      },
+      {
+        label: "Web + GA4 flow",
+        description: "Web flow with browser source and GA4 destination",
+        body: {
+          "${1:myFlow}": {
+            web: {},
+            sources: {
+              browser: { package: "@walkeros/web-source-browser" }
+            },
+            destinations: {
+              ga4: {
+                package: "@walkeros/web-destination-ga4",
+                config: {
+                  measurementId: "$var.${2:measurementId}"
+                }
+              }
+            }
+          }
+        }
+      }
+    ];
+  }
+  if (flowConfig) {
+    if (flowConfig.sources) {
+      flowConfig.sources.markdownDescription = 'Source configurations for data capture, keyed by step name.\n\n```json\n"sources": {\n  "browser": { "package": "@walkeros/web-source-browser" }\n}\n```';
+      flowConfig.sources.defaultSnippets = [
+        {
+          label: "Add web source",
+          description: "Browser source for web tracking",
+          body: {
+            "${1:browser}": {
+              package: "@walkeros/web-source-browser"
+            }
+          }
+        },
+        {
+          label: "Add server source",
+          description: "Express source for server tracking",
+          body: {
+            "${1:express}": {
+              package: "@walkeros/server-source-express"
+            }
+          }
+        }
+      ];
+    }
+    if (flowConfig.destinations) {
+      flowConfig.destinations.markdownDescription = 'Destination configurations for data output, keyed by step name.\n\n```json\n"destinations": {\n  "ga4": {\n    "package": "@walkeros/web-destination-ga4",\n    "config": { "measurementId": "$var.trackingId" }\n  }\n}\n```';
+      flowConfig.destinations.defaultSnippets = [
+        {
+          label: "Add GA4 destination",
+          description: "Google Analytics 4 destination",
+          body: {
+            "${1:ga4}": {
+              package: "@walkeros/web-destination-ga4",
+              config: {
+                measurementId: "$var.${2:measurementId}"
+              }
+            }
+          }
+        },
+        {
+          label: "Add custom destination",
+          description: "Custom destination with inline code",
+          body: {
+            "${1:custom}": {
+              code: {
+                push: "$code:(event) => { ${2:// handle event} }"
+              }
+            }
+          }
+        }
+      ];
+    }
+    if (flowConfig.transformers) {
+      flowConfig.transformers.markdownDescription = 'Transformer configurations for event transformation, keyed by step name.\n\n```json\n"transformers": {\n  "validator": {\n    "code": { "push": "$code:(event) => event" }\n  }\n}\n```';
+      flowConfig.transformers.defaultSnippets = [
+        {
+          label: "Add transformer",
+          description: "Inline transformer with code",
+          body: {
+            "${1:transformer}": {
+              code: {
+                push: "$code:(event) => { ${2:return event;} }"
+              }
+            }
+          }
+        }
+      ];
+    }
+    if (flowConfig.web) {
+      flowConfig.web.markdownDescription = 'Web platform configuration (browser-based). Mutually exclusive with `server`.\n\n```json\n"web": {\n  "windowCollector": "collector",\n  "windowElb": "elb"\n}\n```';
+    }
+    if (flowConfig.server) {
+      flowConfig.server.markdownDescription = 'Server platform configuration (Node.js). Mutually exclusive with `web`.\n\n```json\n"server": {}\n```';
+    }
+  }
+  return schema;
+}
+
+// src/utils/monaco-schema-contract.ts
+function getEnrichedContractSchema() {
+  return {
+    type: "object",
+    markdownDescription: 'walkerOS Data Contract. Defines entity\u2192action schemas for event validation.\n\n```json\n{\n  "$tagging": 1,\n  "page": {\n    "view": {\n      "type": "object",\n      "properties": {\n      "title": { "type": "string" }\n    }\n  }\n  }\n}\n```',
+    properties: {
+      $tagging: {
+        type: "number",
+        markdownDescription: 'Contract version number. Increment when making breaking changes.\n\n```json\n"$tagging": 1\n```'
+      }
+    },
+    additionalProperties: {
+      type: "object",
+      markdownDescription: "Entity name. Contains action\u2192schema mappings.",
+      additionalProperties: {
+        type: "object",
+        markdownDescription: 'Action schema (JSON Schema). Defines valid event data for this entity+action.\n\n```json\n{\n  "type": "object",\n  "properties": {\n    "name": { "type": "string" },\n    "price": { "type": "number" }\n  },\n  "required": ["name"]\n}\n```',
+        defaultSnippets: [
+          {
+            label: "Object schema",
+            description: "Schema with typed properties",
+            body: {
+              type: "object",
+              properties: {
+                "${1:name}": { type: "${2:string}" }
+              }
+            }
+          }
+        ]
+      },
+      defaultSnippets: [
+        {
+          label: "Add action",
+          description: "Action with event data schema",
+          body: {
+            "${1:action}": {
+              type: "object",
+              properties: {
+                "${2:property}": { type: "${3:string}" }
+              }
+            }
+          }
+        }
+      ]
+    },
+    defaultSnippets: [
+      {
+        label: "Entity with action",
+        description: "New entity with one action and properties",
+        body: {
+          "${1:entity}": {
+            "${2:action}": {
+              type: "object",
+              properties: {
+                "${3:property}": { type: "${4:string}" }
+              }
+            }
+          }
+        }
+      }
+    ]
+  };
+}
+
+// src/utils/monaco-schema-variables.ts
+function getVariablesSchema() {
+  return {
+    type: "object",
+    markdownDescription: 'Flow variables for `$var.name` interpolation. Values must be string, number, or boolean.\n\n```json\n{\n  "measurementId": "G-XXXXXXXXXX",\n  "debug": false,\n  "batchSize": 10\n}\n```\n\nReference in any config value: `"$var.measurementId"`',
+    additionalProperties: {
+      oneOf: [{ type: "string" }, { type: "number" }, { type: "boolean" }]
+    },
+    defaultSnippets: [
+      {
+        label: "Add string variable",
+        body: { "${1:name}": "${2:value}" }
+      },
+      {
+        label: "Add boolean variable",
+        body: { "${1:name}": "${2|true,false|}" }
+      },
+      {
+        label: "Add number variable",
+        body: { "${1:name}": 0 }
+      }
+    ]
+  };
+}
+
+// src/utils/monaco-walkeros-markers.ts
+function validateWalkerOSReferences(text, context) {
+  const issues = [];
+  if (context.variables) {
+    const varRegex = /\$var\.(\w+)/g;
+    let match;
+    while ((match = varRegex.exec(text)) !== null) {
+      if (!(match[1] in context.variables)) {
+        issues.push({
+          message: `Unknown variable "$var.${match[1]}". Defined variables: ${Object.keys(context.variables).join(", ") || "none"}`,
+          severity: "warning",
+          startIndex: match.index,
+          endIndex: match.index + match[0].length
+        });
+      }
+    }
+  }
+  if (context.definitions) {
+    const defRegex = /\$def\.(\w+)/g;
+    let match;
+    while ((match = defRegex.exec(text)) !== null) {
+      if (!(match[1] in context.definitions)) {
+        issues.push({
+          message: `Unknown definition "$def.${match[1]}". Defined: ${Object.keys(context.definitions).join(", ") || "none"}`,
+          severity: "warning",
+          startIndex: match.index,
+          endIndex: match.index + match[0].length
+        });
+      }
+    }
+  }
+  if (context.secrets) {
+    const secretRegex = /\$secret\.(\w+)/g;
+    let match;
+    while ((match = secretRegex.exec(text)) !== null) {
+      if (!context.secrets.includes(match[1])) {
+        issues.push({
+          message: `Unknown secret "$secret.${match[1]}". Available: ${context.secrets.join(", ") || "none"}`,
+          severity: "warning",
+          startIndex: match.index,
+          endIndex: match.index + match[0].length
+        });
+      }
+    }
+  }
+  if (context.stepNames?.transformers) {
+    const nextRegex = /"(?:next|before)"\s*:\s*"(\w+)"/g;
+    let match;
+    while ((match = nextRegex.exec(text)) !== null) {
+      if (!context.stepNames.transformers.includes(match[1])) {
+        issues.push({
+          message: `Unknown transformer "${match[1]}". Available: ${context.stepNames.transformers.join(", ") || "none"}`,
+          severity: "warning",
+          startIndex: match.index,
+          endIndex: match.index + match[0].length
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+// src/utils/monaco-intellisense-flow-extractor.ts
+function extractFlowIntelliSenseContext(json2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json2);
+  } catch {
+    return {};
+  }
+  if (!isFlowSetup(parsed)) return {};
+  const variables = {};
+  const definitions = {};
+  const sources = [];
+  const destinations = [];
+  const transformers = [];
+  const packages = [];
+  const contractEntities = [];
+  let platform;
+  mergeVars(variables, parsed.variables);
+  mergeDefs(definitions, parsed.definitions);
+  extractContract(contractEntities, parsed.contract);
+  for (const config of Object.values(parsed.flows)) {
+    if (!isObject(config)) continue;
+    if (!platform) {
+      if ("web" in config) platform = "web";
+      else if ("server" in config) platform = "server";
+    }
+    mergeVars(variables, config.variables);
+    mergeDefs(definitions, config.definitions);
+    extractContract(contractEntities, config.contract);
+    if (isObject(config.sources)) {
+      for (const [name, ref] of Object.entries(config.sources)) {
+        sources.push(name);
+        if (isObject(ref)) {
+          mergeVars(variables, ref.variables);
+          mergeDefs(definitions, ref.definitions);
+          if (typeof ref.package === "string") {
+            packages.push({
+              package: ref.package,
+              shortName: name,
+              type: "source",
+              platform: platform || "web"
+            });
+          }
+        }
+      }
+    }
+    if (isObject(config.destinations)) {
+      for (const [name, ref] of Object.entries(config.destinations)) {
+        destinations.push(name);
+        if (isObject(ref)) {
+          mergeVars(variables, ref.variables);
+          mergeDefs(definitions, ref.definitions);
+          if (typeof ref.package === "string") {
+            packages.push({
+              package: ref.package,
+              shortName: name,
+              type: "destination",
+              platform: platform || "web"
+            });
+          }
+        }
+      }
+    }
+    if (isObject(config.transformers)) {
+      for (const [name, ref] of Object.entries(config.transformers)) {
+        transformers.push(name);
+        if (isObject(ref)) {
+          mergeVars(variables, ref.variables);
+          mergeDefs(definitions, ref.definitions);
+          if (typeof ref.package === "string") {
+            packages.push({
+              package: ref.package,
+              shortName: name,
+              type: "transformer",
+              platform: platform || "web"
+            });
+          }
+        }
+      }
+    }
+  }
+  const result = {
+    variables,
+    definitions,
+    stepNames: { sources, destinations, transformers }
+  };
+  if (platform) result.platform = platform;
+  if (packages.length > 0) result.packages = packages;
+  if (contractEntities.length > 0) result.contract = contractEntities;
+  return result;
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isFlowSetup(v) {
+  return isObject(v) && "version" in v && "flows" in v && isObject(v.flows);
+}
+function isPrimitive(v) {
+  return typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+}
+function mergeVars(target, source) {
+  if (!isObject(source)) return;
+  for (const [k, v] of Object.entries(source)) {
+    if (isPrimitive(v)) target[k] = v;
+  }
+}
+function mergeDefs(target, source) {
+  if (!isObject(source)) return;
+  for (const [k, v] of Object.entries(source)) {
+    target[k] = v;
+  }
+}
+function extractContract(target, contract) {
+  if (!isObject(contract)) return;
+  for (const [key, value] of Object.entries(contract)) {
+    if (key.startsWith("$") || !isObject(value)) continue;
+    const existing = target.find((e) => e.entity === key);
+    const actions = Object.keys(value);
+    if (existing) {
+      for (const a of actions) {
+        if (!existing.actions.includes(a)) existing.actions.push(a);
+      }
+    } else {
+      target.push({ entity: key, actions });
+    }
+  }
+}
 export {
   Alert,
   ArchitectureFlow,
@@ -17542,9 +18531,11 @@ export {
   Preview,
   PromotionPlayground,
   PropertyTable,
+  REFERENCE_PATTERNS,
   Spinner,
   SplitButton,
   SubmitButton,
+  applyWalkerOSDecorations,
   captureDestinationPush,
   cn,
   createCaptureFn,
@@ -17552,8 +18543,15 @@ export {
   createGtagDestination,
   createPlausibleDestination,
   createRawCapture,
+  disposeWalkerOSProviders,
+  enrichFlowSetupSchema,
+  enrichSchema,
+  extractFlowIntelliSenseContext,
+  findWalkerOSReferences,
   formatCapturedCalls,
   generateModelPath,
+  getEnrichedContractSchema,
+  getVariablesSchema,
   initializeMonacoTypes,
   lighthouseTheme,
   loadPackageTypes,
@@ -17563,8 +18561,13 @@ export {
   registerJsonSchema,
   registerLighthouseTheme,
   registerPalenightTheme,
+  registerWalkerOSDecorationStyles,
+  registerWalkerOSProviders,
   registerWalkerOSTypes,
+  removeIntelliSenseContext,
+  setIntelliSenseContext,
   unregisterJsonSchema,
-  useDropdown
+  useDropdown,
+  validateWalkerOSReferences
 };
 //# sourceMappingURL=index.mjs.map