@mmapp/react-compiler 0.1.0-alpha.20 → 0.1.0-alpha.21

package/dist/chunk-RTAUTGHB.mjs

@@ -0,0 +1,248 @@
+import {
+  createSourceEnvelope,
+  generateFsTree
+} from "./chunk-5M7DKKBC.mjs";
+import {
+  babelPlugin
+} from "./chunk-NJNAQF5I.mjs";
+
+// src/cli/build.ts
+import { glob } from "glob";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { transformSync } from "@babel/core";
+import { join, basename, dirname, resolve } from "path";
+import { execSync } from "child_process";
+async function build(options = {}) {
+  const srcDir = options.src ?? "src/workflows";
+  const outDir = options.outDir ?? "dist/workflows";
+  const mode = options.mode ?? "infer";
+  if (!options.skipTypeCheck) {
+    const tsconfigPath = resolve(srcDir, "tsconfig.json");
+    const hasTsconfig = existsSync(tsconfigPath);
+    if (hasTsconfig) {
+      console.log(`[mindmatrix-react] Type checking (tsc --noEmit)...`);
+      try {
+        execSync(`npx tsc --noEmit --project ${tsconfigPath}`, {
+          cwd: resolve(srcDir),
+          stdio: "pipe",
+          encoding: "utf-8"
+        });
+        console.log(`[mindmatrix-react] Type check passed.`);
+      } catch (err) {
+        const tscError = err;
+        const output = tscError.stdout || tscError.stderr || "";
+        const lines = output.split("\n").filter((l) => l.trim());
+        const typeErrors = [];
+        for (const line of lines) {
+          const match = line.match(/^(.+?)\((\d+),\d+\):\s*error\s+(TS\d+):\s*(.+)$/);
+          if (match) {
+            typeErrors.push({
+              file: match[1],
+              message: `${match[3]}: ${match[4]}`,
+              line: parseInt(match[2], 10)
+            });
+          }
+        }
+        if (typeErrors.length > 0) {
+          console.error(`
+[mindmatrix-react] Type check failed with ${typeErrors.length} error(s):
+`);
+          for (const te of typeErrors) {
+            console.error(`  \u2717 ${te.file}:${te.line || "?"} ${te.message}`);
+          }
+          console.error(`
+[mindmatrix-react] Fix type errors or use --skip-type-check to bypass.
+`);
+          return {
+            compiled: 0,
+            errors: typeErrors.length,
+            warnings: 0,
+            definitions: [],
+            errorDetails: typeErrors
+          };
+        } else if (output.includes("not the tsc command") || output.includes("Cannot find module") || output.includes("ERR_MODULE_NOT_FOUND") || output.includes("command not found")) {
+          console.warn(`[mindmatrix-react] TypeScript not installed \u2014 skipping type check.`);
+          console.warn(`  Run \`npm install\` to enable type checking, or use --skip-type-check.
+`);
+        } else {
+          console.error(`
+[mindmatrix-react] Type check failed:
+${output}`);
+          return {
+            compiled: 0,
+            errors: 1,
+            warnings: 0,
+            definitions: [],
+            errorDetails: [{ file: "tsconfig.json", message: output.slice(0, 500) }]
+          };
+        }
+      }
+    }
+  }
+  const configPath = resolve(srcDir, "mm.config.ts");
+  if (existsSync(configPath)) {
+    console.log(`[mindmatrix-react] Detected mm.config.ts \u2014 using project compiler...`);
+    const { compileProject } = await import("./project-compiler-HNDWIX4J.mjs");
+    const allProjectFiles = await glob(`${srcDir}/**/*.{ts,tsx}`, {
+      ignore: ["**/node_modules/**", "**/dist/**", "**/__tests__/**", "**/*.test.*"]
+    });
+    const fileMap = {};
+    for (const f of allProjectFiles) {
+      const rel = f.startsWith(srcDir + "/") ? f.slice(srcDir.length + 1) : f;
+      fileMap[rel] = readFileSync(f, "utf-8");
+    }
+    mkdirSync(outDir, { recursive: true });
+    const result2 = compileProject(fileMap, { mode });
+    const errors = result2.errors.filter((e) => e.severity === "error");
+    const warnings = result2.errors.filter((e) => e.severity === "warning");
+    const definitions2 = [result2.ir];
+    const errorDetails2 = [];
+    for (const err of errors) {
+      errorDetails2.push({ file: err.file, message: err.message, line: err.line });
+      console.error(`  x ${err.file}${err.line ? `:${err.line}` : ""} ${err.message}`);
+    }
+    for (const warn of warnings) {
+      console.warn(`  ! ${warn.file}${warn.line ? `:${warn.line}` : ""} ${warn.message}`);
+    }
+    const irPath = join(outDir, `${result2.ir.slug}.workflow.json`);
+    writeFileSync(irPath, JSON.stringify(result2.ir, null, 2), "utf-8");
+    console.log(`  + ${basename(irPath)}`);
+    const seenSlugs = /* @__PURE__ */ new Set([result2.ir.slug]);
+    for (const child of result2.childDefinitions) {
+      if (seenSlugs.has(child.slug)) continue;
+      seenSlugs.add(child.slug);
+      definitions2.push(child);
+      const childPath = join(outDir, `${child.slug}.workflow.json`);
+      writeFileSync(childPath, JSON.stringify(child, null, 2), "utf-8");
+      console.log(`  + ${basename(childPath)}`);
+    }
+    console.log(`
+[mindmatrix-react] Compiled ${definitions2.length} definitions, ${errors.length} errors, ${warnings.length} warnings`);
+    return { compiled: definitions2.length, errors: errors.length, warnings: warnings.length, definitions: definitions2, errorDetails: errorDetails2 };
+  }
+  console.log(`[mindmatrix-react] Building workflows from ${srcDir}...`);
+  mkdirSync(outDir, { recursive: true });
+  const workflowFiles = await glob(`${srcDir}/**/*.workflow.{tsx,ts,jsx,js}`);
+  const modelFiles = await glob(`${srcDir}/**/models/**/*.{ts,tsx}`);
+  const serverFiles = await glob(`${srcDir}/**/*.server.{ts,tsx,js,jsx}`);
+  const allFiles = [.../* @__PURE__ */ new Set([...workflowFiles, ...modelFiles, ...serverFiles])];
+  if (allFiles.length === 0) {
+    console.log(`[mindmatrix-react] No workflow files found in ${srcDir}`);
+    return { compiled: 0, errors: 0, warnings: 0, definitions: [], errorDetails: [] };
+  }
+  let compiled = 0;
+  let errorCount = 0;
+  let warningCount = 0;
+  const definitions = [];
+  const errorDetails = [];
+  for (const file of allFiles) {
+    try {
+      const code = readFileSync(file, "utf-8");
+      const result2 = transformSync(code, {
+        filename: file,
+        plugins: [[babelPlugin, { mode }]],
+        parserOpts: { plugins: ["jsx", "typescript"], attachComment: true }
+      });
+      const ir = result2?.metadata?.mindmatrixIR;
+      const definition = result2?.metadata?.mindmatrixDefinition;
+      const canonical = result2?.metadata?.mindmatrixCanonical;
+      if (ir) {
+        definitions.push(ir);
+        const irErrors = ir.metadata?.errors;
+        const irWarnings = ir.metadata?.warnings;
+        if (irErrors && irErrors.length > 0) {
+          for (const err of irErrors) {
+            errorDetails.push({
+              file: basename(file),
+              message: err.message,
+              line: err.line
+            });
+            console.error(`  \u2717 ${basename(file)}:${err.line || "?"} ${err.message}`);
+          }
+          errorCount += irErrors.length;
+        }
+        if (irWarnings && irWarnings.length > 0) {
+          for (const warn of irWarnings) {
+            console.warn(`  \u26A0 ${basename(file)}:${warn.line || "?"} ${warn.message}`);
+          }
+          warningCount += irWarnings.length;
+        }
+        const compiledFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, ".json").replace(/\.(tsx?|jsx?)$/, ".json");
+        const compiledFile = join(outDir, compiledFileName);
+        mkdirSync(dirname(compiledFile), { recursive: true });
+        writeFileSync(compiledFile, JSON.stringify({ canonical, ir }, null, 2), "utf-8");
+        const irFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, ".workflow.json").replace(/\.(tsx?|jsx?)$/, ".json");
+        const irFile = join(outDir, irFileName);
+        writeFileSync(irFile, JSON.stringify(ir, null, 2), "utf-8");
+        if (definition) {
+          const defFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, ".def.json").replace(/\.(tsx?|jsx?)$/, ".def.json");
+          const defFile = join(outDir, defFileName);
+          writeFileSync(defFile, JSON.stringify(definition, null, 2), "utf-8");
+        }
+        console.log(`  \u2713 ${basename(file)} \u2192 ${compiledFileName}`);
+        compiled++;
+      } else {
+        console.error(`  \u2717 ${basename(file)}: No IR generated`);
+        errorDetails.push({ file: basename(file), message: "No IR generated" });
+        errorCount++;
+      }
+    } catch (error) {
+      const msg = error.message;
+      console.error(`  \u2717 ${basename(file)}: ${msg}`);
+      errorDetails.push({ file: basename(file), message: msg });
+      errorCount++;
+    }
+  }
+  if (options.envelope) {
+    const allSourceFiles = await glob(`${srcDir}/**/*.{ts,tsx,js,jsx}`);
+    const fsTree = generateFsTree(allSourceFiles, resolve(srcDir));
+    const envelope = createSourceEnvelope({
+      blueprintSlug: options.slug || "project",
+      blueprintVersion: options.version || "0.1.0",
+      definitions,
+      fsTree,
+      mode
+    });
+    const envelopePath = join(outDir, "envelope.json");
+    writeFileSync(envelopePath, JSON.stringify(envelope, null, 2), "utf-8");
+    console.log(`
+  \u2713 Source envelope \u2192 envelope.json (${envelope.envelopeId.substring(0, 8)})`);
+  }
+  console.log(`
+[mindmatrix-react] Compiled ${compiled} workflows, ${errorCount} errors, ${warningCount} warnings`);
+  const result = { compiled, errors: errorCount, warnings: warningCount, definitions, errorDetails };
+  if (options.watch) {
+    await startWatchMode(options);
+  }
+  return result;
+}
+async function startWatchMode(options) {
+  const { watch: fsWatch } = await import("fs");
+  const srcDir = options.src ?? "src/workflows";
+  let debounce = null;
+  console.log(`
+[mindmatrix-react] Watching ${srcDir} for changes... (Ctrl+C to stop)
+`);
+  fsWatch(srcDir, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+    if (!filename.match(/\.(tsx?|jsx?)$/)) return;
+    if (filename.includes("node_modules") || filename.includes("dist")) return;
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(async () => {
+      const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(`
+[${ts}] Change detected: ${filename} \u2014 recompiling...`);
+      try {
+        await build({ ...options, watch: false, skipTypeCheck: true });
+      } catch (e) {
+        console.error(`[mindmatrix-react] Rebuild failed:`, e.message);
+      }
+    }, 300);
+  });
+  return new Promise(() => {
+  });
+}
+
+export {
+  build
+};

package/dist/chunk-YOVAADAD.mjs

@@ -0,0 +1,175 @@
+import {
+  babelPlugin
+} from "./chunk-NJNAQF5I.mjs";
+
+// src/vite/index.ts
+import { transformSync } from "@babel/core";
+import { writeFileSync, mkdirSync } from "fs";
+import { dirname, join, relative, basename } from "path";
+function mindmatrixReact(options) {
+  const include = options?.include ?? ["**/*.workflow.tsx"];
+  const mode = options?.mode ?? "infer";
+  const outDir = options?.outDir ?? "dist/workflows";
+  const seedOnCompile = options?.seedOnCompile ?? false;
+  const apiUrl = options?.apiUrl ?? "http://localhost:4200/api/v1";
+  const authToken = options?.authToken ?? process.env.MINDMATRIX_TOKEN;
+  let enableSourceMaps = options?.sourceMaps;
+  let enableSourceAnnotations = options?.sourceAnnotations;
+  let isDev = true;
+  const compiledFiles = /* @__PURE__ */ new Map();
+  function shouldTransform(id) {
+    return include.some((pattern) => {
+      const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<GLOBSTAR>>").replace(/\*/g, "[^/]*").replace(/<<GLOBSTAR>>/g, ".*").replace(/\?/g, ".");
+      return new RegExp(regex).test(id);
+    });
+  }
+  async function seedToApi(ir, filePath) {
+    if (!seedOnCompile || !authToken) return;
+    try {
+      const body = {
+        slug: ir.slug,
+        name: ir.name,
+        version: ir.version,
+        category: ir.category || ["workflow"],
+        fields: ir.fields || [],
+        states: ir.states || [],
+        transitions: ir.transitions || [],
+        experience: ir.experience || {},
+        metadata: {
+          ...ir.metadata || {},
+          source_file: relative(process.cwd(), filePath),
+          compiled_at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      const resp = await fetch(`${apiUrl}/workflow/definitions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${authToken}`
+        },
+        body: JSON.stringify(body)
+      });
+      if (resp.ok) {
+        console.log(`[mindmatrix-react] Seeded ${ir.slug} to ${apiUrl}`);
+      } else if (resp.status === 409) {
+        const existing = await fetch(
+          `${apiUrl}/workflow/definitions?slug=${encodeURIComponent(ir.slug)}&version=${encodeURIComponent(ir.version)}`,
+          { headers: { "Authorization": `Bearer ${authToken}` } }
+        );
+        if (existing.ok) {
+          const data = await existing.json();
+          const defId = Array.isArray(data) ? data[0]?.id : data?.id;
+          if (defId) {
+            await fetch(`${apiUrl}/workflow/definitions/${defId}`, {
+              method: "PATCH",
+              headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${authToken}`
+              },
+              body: JSON.stringify(body)
+            });
+            console.log(`[mindmatrix-react] Updated ${ir.slug} (PATCH)`);
+          }
+        }
+      } else {
+        const text = await resp.text().catch(() => "");
+        console.warn(`[mindmatrix-react] Seed failed (${resp.status}): ${text.slice(0, 200)}`);
+      }
+    } catch (e) {
+      console.warn(`[mindmatrix-react] Seed failed:`, e instanceof Error ? e.message : e);
+    }
+  }
+  return {
+    name: "mindmatrix-react",
+    enforce: "pre",
+    configResolved(config) {
+      isDev = config.command === "serve";
+      if (enableSourceMaps === void 0) enableSourceMaps = isDev;
+      if (enableSourceAnnotations === void 0) enableSourceAnnotations = isDev;
+    },
+    transform(code, id) {
+      if (!shouldTransform(id)) return null;
+      try {
+        const wantMaps = enableSourceMaps !== false;
+        const result = transformSync(code, {
+          filename: id,
+          plugins: [[babelPlugin, { mode, filename: id, sourceAnnotations: enableSourceAnnotations }]],
+          parserOpts: { plugins: ["jsx", "typescript"] },
+          sourceMaps: wantMaps,
+          // Embed original source in the source map so debuggers can show .workflow.tsx
+          ...wantMaps ? { sourceFileName: basename(id) } : {}
+        });
+        if (!result?.code) return null;
+        const metadata = result.metadata || {};
+        const ir = metadata.mindmatrixIR;
+        const warnings = metadata.mindmatrixWarnings;
+        const errors = metadata.mindmatrixErrors;
+        if (warnings?.length) {
+          for (const w of warnings) {
+            console.warn(`[mindmatrix-react] ${basename(id)}: ${w.message}`);
+          }
+        }
+        if (errors?.length) {
+          for (const e of errors) {
+            if (mode === "strict") {
+              this.error(`${basename(id)}: ${e.message}`);
+            } else {
+              this.warn(`${basename(id)}: ${e.message}`);
+            }
+          }
+        }
+        if (ir) {
+          compiledFiles.set(id, ir);
+          const outputFileName = basename(id).replace(/\.tsx?$/, ".workflow.json");
+          const outputPath = join(process.cwd(), outDir, outputFileName);
+          mkdirSync(dirname(outputPath), { recursive: true });
+          writeFileSync(outputPath, JSON.stringify(ir, null, 2), "utf-8");
+          console.log(`[mindmatrix-react] Compiled ${basename(id)} \u2192 ${outputFileName}`);
+          seedToApi(ir, id);
+        }
+        if (!enableSourceAnnotations && ir) {
+          stripSourceAnnotations(ir);
+        }
+        return {
+          code: result.code,
+          map: wantMaps ? result.map : void 0
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (mode === "strict") {
+          this.error(`Failed to compile ${basename(id)}: ${msg}`);
+        } else {
+          console.error(`[mindmatrix-react] Error compiling ${basename(id)}:`, msg);
+        }
+        return null;
+      }
+    },
+    handleHotUpdate(ctx) {
+      if (!shouldTransform(ctx.file)) return;
+      console.log(`[mindmatrix-react] HMR: ${basename(ctx.file)} changed`);
+      return void 0;
+    }
+  };
+}
+function stripSourceAnnotations(ir) {
+  const strip = (obj) => {
+    if (!obj || typeof obj !== "object") return;
+    if (Array.isArray(obj)) {
+      for (const item of obj) strip(item);
+      return;
+    }
+    const rec = obj;
+    delete rec.__source;
+    for (const val of Object.values(rec)) {
+      if (val && typeof val === "object") strip(val);
+    }
+  };
+  strip(ir.fields);
+  strip(ir.states);
+  strip(ir.transitions);
+  strip(ir.experience);
+}
+
+export {
+  mindmatrixReact
+};

package/dist/cli/index.js

@@ -1387,7 +1387,14 @@ function jsxToExperienceNode(node) {
           }
         } else if (t6.isIdentifier(expr)) {
           const snakeName = localFieldMap.get(expr.name);
-          bindings[attrName] = snakeName ? `$local.${snakeName}` : `$instance.${expr.name}`;
+          const setterField = setterToFieldMap.get(expr.name);
+          if (snakeName) {
+            bindings[attrName] = `$local.${snakeName}`;
+          } else if (setterField) {
+            bindings[attrName] = `$action.setLocal("${setterField}")`;
+          } else {
+            bindings[attrName] = `$instance.${expr.name}`;
+          }
         } else if (isEventHandlerProp(attrName) && (t6.isArrowFunctionExpression(expr) || t6.isFunctionExpression(expr))) {
           const decomposed = decomposeHandlerToSeq(expr);
           if (decomposed) {
@@ -7530,6 +7537,26 @@ function createVisitor(options = {}) {
       const id = path.node.id;
       const init2 = path.node.init;
       if (t21.isArrayPattern(id)) return;
+      if (t21.isObjectPattern(id) && init2 && t21.isCallExpression(init2) && t21.isIdentifier(init2.callee) && init2.callee.name === "useQuery") {
+        const slug = resolveSlugArg(init2.arguments, state);
+        if (slug) {
+          for (const prop2 of id.properties) {
+            if (t21.isObjectProperty(prop2) && t21.isIdentifier(prop2.key) && prop2.key.name === "data") {
+              const alias = t21.isIdentifier(prop2.value) ? prop2.value.name : null;
+              if (alias) {
+                const meta = compilerState.metadata;
+                const dataSources = meta.dataSources;
+                if (dataSources) {
+                  const ds = dataSources.find((d) => d.name === slug);
+                  if (ds) ds.name = alias;
+                }
+              }
+              break;
+            }
+          }
+        }
+        return;
+      }
       if (!t21.isIdentifier(id) || !init2 || !t21.isExpression(init2)) return;
       const parentFn = path.getFunctionParent();
       if (!parentFn) return;
@@ -7557,10 +7584,7 @@ function createVisitor(options = {}) {
           return;
         }
         if (callee === "useMutation") {
-          registerDerivedVar(id.name, t21.memberExpression(
-            t21.identifier("$action"),
-            t21.identifier("transition")
-          ));
+          registerDerivedVar(id.name, t21.identifier("$action"));
           return;
         }
         if (callee === "useServerAction") {

package/dist/cli/index.mjs

@@ -10,9 +10,9 @@ import {
 } from "../chunk-XUQ5R6F3.mjs";
 import {
   build
-} from "../chunk-TRR2NPAV.mjs";
+} from "../chunk-RTAUTGHB.mjs";
 import "../chunk-5M7DKKBC.mjs";
-import "../chunk-TXONBY6A.mjs";
+import "../chunk-NJNAQF5I.mjs";
 import {
   __require
 } from "../chunk-CIESM3BP.mjs";
@@ -45,7 +45,7 @@ async function test(options = {}) {
     const rel = f.startsWith(srcDir + "/") ? f.slice(srcDir.length + 1) : f;
     fileMap[rel] = readFileSync(f, "utf-8");
   }
-  const { compileProject } = await import("../project-compiler-D245L5QR.mjs");
+  const { compileProject } = await import("../project-compiler-HNDWIX4J.mjs");
   const { decompileProjectEnhanced } = await import("../project-decompiler-QCZYY4TW.mjs");
   process.stdout.write(`  Compiling project...`);
   const t0 = performance.now();
@@ -548,7 +548,7 @@ async function main() {
       const { glob: glob2 } = await import("glob");
       const configPath = resolve2(srcDir, "mm.config.ts");
       if (existsSync2(configPath)) {
-        const { compileProject } = await import("../project-compiler-D245L5QR.mjs");
+        const { compileProject } = await import("../project-compiler-HNDWIX4J.mjs");
         const allFiles = await glob2(`${srcDir}/**/*.{ts,tsx}`, {
           ignore: ["**/node_modules/**", "**/dist/**", "**/__tests__/**", "**/*.test.*"]
         });
@@ -624,7 +624,7 @@ async function main() {
       console.error("[mmrc] Error: target path is required\n  Usage: mmrc verify <file-or-dir> [options]");
       process.exit(1);
     }
-    const { verifyCommand } = await import("../verify-HDKUNHZ4.mjs");
+    const { verifyCommand } = await import("../verify-LZXUHOX6.mjs");
     const result = await verifyCommand({
       target,
       static: hasFlag("--static"),

package/dist/dev-server.js

@@ -1386,7 +1386,14 @@ function jsxToExperienceNode(node) {
           }
         } else if (t6.isIdentifier(expr)) {
           const snakeName = localFieldMap.get(expr.name);
-          bindings[attrName] = snakeName ? `$local.${snakeName}` : `$instance.${expr.name}`;
+          const setterField = setterToFieldMap.get(expr.name);
+          if (snakeName) {
+            bindings[attrName] = `$local.${snakeName}`;
+          } else if (setterField) {
+            bindings[attrName] = `$action.setLocal("${setterField}")`;
+          } else {
+            bindings[attrName] = `$instance.${expr.name}`;
+          }
         } else if (isEventHandlerProp(attrName) && (t6.isArrowFunctionExpression(expr) || t6.isFunctionExpression(expr))) {
           const decomposed = decomposeHandlerToSeq(expr);
           if (decomposed) {
@@ -7529,6 +7536,26 @@ function createVisitor(options = {}) {
       const id = path.node.id;
       const init = path.node.init;
       if (t21.isArrayPattern(id)) return;
+      if (t21.isObjectPattern(id) && init && t21.isCallExpression(init) && t21.isIdentifier(init.callee) && init.callee.name === "useQuery") {
+        const slug = resolveSlugArg(init.arguments, state);
+        if (slug) {
+          for (const prop of id.properties) {
+            if (t21.isObjectProperty(prop) && t21.isIdentifier(prop.key) && prop.key.name === "data") {
+              const alias = t21.isIdentifier(prop.value) ? prop.value.name : null;
+              if (alias) {
+                const meta = compilerState.metadata;
+                const dataSources = meta.dataSources;
+                if (dataSources) {
+                  const ds = dataSources.find((d) => d.name === slug);
+                  if (ds) ds.name = alias;
+                }
+              }
+              break;
+            }
+          }
+        }
+        return;
+      }
       if (!t21.isIdentifier(id) || !init || !t21.isExpression(init)) return;
       const parentFn = path.getFunctionParent();
       if (!parentFn) return;
@@ -7556,10 +7583,7 @@ function createVisitor(options = {}) {
           return;
         }
         if (callee === "useMutation") {
-          registerDerivedVar(id.name, t21.memberExpression(
-            t21.identifier("$action"),
-            t21.identifier("transition")
-          ));
+          registerDerivedVar(id.name, t21.identifier("$action"));
           return;
         }
         if (callee === "useServerAction") {

package/dist/dev-server.mjs

@@ -1,10 +1,10 @@
 import {
   createDevServer
-} from "./chunk-U6F7CTHK.mjs";
-import "./chunk-PBRBRKIQ.mjs";
-import "./chunk-TRR2NPAV.mjs";
+} from "./chunk-5PM7CGFQ.mjs";
+import "./chunk-RTAUTGHB.mjs";
 import "./chunk-5M7DKKBC.mjs";
-import "./chunk-TXONBY6A.mjs";
+import "./chunk-YOVAADAD.mjs";
+import "./chunk-NJNAQF5I.mjs";
 import "./chunk-CIESM3BP.mjs";
 export {
   createDevServer

package/dist/envelope.js

@@ -1259,7 +1259,14 @@ function jsxToExperienceNode(node) {
           }
         } else if (t6.isIdentifier(expr)) {
           const snakeName = localFieldMap.get(expr.name);
-          bindings[attrName] = snakeName ? `$local.${snakeName}` : `$instance.${expr.name}`;
+          const setterField = setterToFieldMap.get(expr.name);
+          if (snakeName) {
+            bindings[attrName] = `$local.${snakeName}`;
+          } else if (setterField) {
+            bindings[attrName] = `$action.setLocal("${setterField}")`;
+          } else {
+            bindings[attrName] = `$instance.${expr.name}`;
+          }
         } else if (isEventHandlerProp(attrName) && (t6.isArrowFunctionExpression(expr) || t6.isFunctionExpression(expr))) {
           const decomposed = decomposeHandlerToSeq(expr);
           if (decomposed) {
@@ -7296,6 +7303,26 @@ function createVisitor(options = {}) {
       const id = path.node.id;
       const init = path.node.init;
       if (t21.isArrayPattern(id)) return;
+      if (t21.isObjectPattern(id) && init && t21.isCallExpression(init) && t21.isIdentifier(init.callee) && init.callee.name === "useQuery") {
+        const slug = resolveSlugArg(init.arguments, state);
+        if (slug) {
+          for (const prop of id.properties) {
+            if (t21.isObjectProperty(prop) && t21.isIdentifier(prop.key) && prop.key.name === "data") {
+              const alias = t21.isIdentifier(prop.value) ? prop.value.name : null;
+              if (alias) {
+                const meta = compilerState.metadata;
+                const dataSources = meta.dataSources;
+                if (dataSources) {
+                  const ds = dataSources.find((d) => d.name === slug);
+                  if (ds) ds.name = alias;
+                }
+              }
+              break;
+            }
+          }
+        }
+        return;
+      }
       if (!t21.isIdentifier(id) || !init || !t21.isExpression(init)) return;
       const parentFn = path.getFunctionParent();
       if (!parentFn) return;
@@ -7323,10 +7350,7 @@ function createVisitor(options = {}) {
           return;
         }
         if (callee === "useMutation") {
-          registerDerivedVar(id.name, t21.memberExpression(
-            t21.identifier("$action"),
-            t21.identifier("transition")
-          ));
+          registerDerivedVar(id.name, t21.identifier("$action"));
           return;
         }
         if (callee === "useServerAction") {

package/dist/envelope.mjs

@@ -1,8 +1,8 @@
 import {
   buildEnvelope
-} from "./chunk-UASOWKDI.mjs";
+} from "./chunk-AIM5FKMV.mjs";
 import "./chunk-5M7DKKBC.mjs";
-import "./chunk-TXONBY6A.mjs";
+import "./chunk-NJNAQF5I.mjs";
 import "./chunk-CIESM3BP.mjs";
 export {
   buildEnvelope