windmill-cli 1.748.0 → 1.750.0

package/esm/main.js

@@ -16784,7 +16784,7 @@ var init_OpenAPI = __esm(() => {
     PASSWORD: undefined,
     TOKEN: getEnv3("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: "1.748.0",
+    VERSION: "1.750.0",
     WITH_CREDENTIALS: true,
     interceptors: {
       request: new Interceptors,
@@ -26422,7 +26422,7 @@ var init_auth = __esm(async () => {
 });
 
 // src/core/constants.ts
-var WM_FORK_PREFIX = "wm-fork", VERSION = "1.748.0";
+var WM_FORK_PREFIX = "wm-fork", VERSION = "1.750.0";
 
 // src/utils/git.ts
 var exports_git = {};
@@ -86779,8 +86779,8 @@ inspect asset-driven pipelines (scripts marked \`// pipeline\`, wired by \`// on
 - \`pipeline show <folder:string>\` - render a pipeline folder's DAG (sources, lineage, subscriptions) in the terminal
   - \`--json\` - Output the raw asset graph as JSON
   - \`--local\` - Build the graph from local working-tree files (// pipeline scripts) instead of the deployed workspace — no deploy needed.
-- \`pipeline run <folder:string>\` - run a bounded cascade: from a schedule/manual root, fan downstream up to the --to end node(s)
-  - \`--from <script:string>\` - Start script (short name or path). Defaults to the folder's sole schedule/manual root.
+- \`pipeline run <folder:string>\` - run a cascade: from --from (a root OR any mid-DAG model), fan downstream up to the --to end node(s)
+  - \`--from <script:string>\` - Start script (short name or path). May be any node, including a mid-DAG model — that node plus its transitive downstream runs, upstream is NOT re-run (dbt \`--select model+\`). Defaults to the folder's sole schedule/manual root.
   - \`--to <node:string>\` - End node(s) to stop at — script names/paths or asset URIs (e.g. datatable://main/staged). Repeatable or comma-separated. Omit to run the full downstream.
   - \`--dry-run\` - Print the topological run plan without executing.
   - \`--json\` - Output the plan as JSON (for piping to jq).
@@ -95799,7 +95799,8 @@ function assetUriToNodeId(uri) {
     return;
   const prefix = m3[1].toLowerCase();
   const kind = prefix === "s3" ? "s3object" : prefix;
-  return `${kind}:${m3[2]}`;
+  const path23 = kind === "s3object" ? m3[2].replace(/^\/+/, "") : m3[2];
+  return `${kind}:${path23}`;
 }
 function addEdge(dag, a2, b2) {
   if (a2 === b2)
@@ -95834,6 +95835,11 @@ function buildLineageDag(g2) {
     const at = t2;
     addEdge(dag, assetNodeId(at.asset_kind, at.asset_path), scriptNodeId(at.runnable_path));
   }
+  for (const t2 of g2.test_edges ?? []) {
+    if (t2.runnable_kind !== "script")
+      continue;
+    addEdge(dag, assetNodeId(t2.asset_kind, t2.asset_path), scriptNodeId(t2.runnable_path));
+  }
   return dag;
 }
 function closure(adj, start) {
@@ -95920,6 +95926,18 @@ function validStarts(g2) {
   }
   return out;
 }
+function validFromStarts(g2) {
+  const nonAutorun = nonAutorunTriggerScripts(g2);
+  const out = new Set(validStarts(g2));
+  for (const r2 of g2.runnables ?? []) {
+    if (r2.usage_kind !== "script")
+      continue;
+    const id = scriptNodeId(r2.path);
+    if (!nonAutorun.has(id))
+      out.add(id);
+  }
+  return out;
+}
 function nonAutorunTriggerScripts(g2) {
   const out = new Set;
   for (const t2 of g2.triggers ?? []) {
@@ -96001,6 +96019,235 @@ await __promiseAll([
 import * as fs17 from "node:fs";
 import * as path23 from "node:path";
 import process25 from "node:process";
+
+// src/commands/pipeline/duckdbMacros.ts
+function stripKw(s2, kw) {
+  if (s2.length < kw.length)
+    return null;
+  if (s2.slice(0, kw.length).toLowerCase() !== kw)
+    return null;
+  const after = s2.slice(kw.length);
+  if (after.length === 0 || /^\s/.test(after))
+    return after.replace(/^\s+/, "");
+  return null;
+}
+function isIdent(s2) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(s2);
+}
+function splitStatements(sql) {
+  const out = [];
+  let cur = "";
+  const chars = [...sql];
+  let i = 0;
+  const n2 = chars.length;
+  while (i < n2) {
+    const c2 = chars[i];
+    if (c2 === "-" && i + 1 < n2 && chars[i + 1] === "-" || c2 === "/" && i + 1 < n2 && chars[i + 1] === "/") {
+      while (i < n2 && chars[i] !== `
+`)
+        i += 1;
+      continue;
+    }
+    if (c2 === "/" && i + 1 < n2 && chars[i + 1] === "*") {
+      i += 2;
+      while (i + 1 < n2 && !(chars[i] === "*" && chars[i + 1] === "/"))
+        i += 1;
+      i += 2;
+      continue;
+    }
+    if (c2 === "'") {
+      cur += c2;
+      i += 1;
+      while (i < n2) {
+        cur += chars[i];
+        if (chars[i] === "'") {
+          if (i + 1 < n2 && chars[i + 1] === "'") {
+            cur += "'";
+            i += 2;
+            continue;
+          }
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      continue;
+    }
+    if (c2 === '"') {
+      cur += c2;
+      i += 1;
+      while (i < n2) {
+        cur += chars[i];
+        if (chars[i] === '"') {
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      continue;
+    }
+    if (c2 === ";") {
+      const t3 = cur.trim();
+      if (t3 !== "")
+        out.push(t3);
+      cur = "";
+      i += 1;
+      continue;
+    }
+    cur += c2;
+    i += 1;
+  }
+  const t2 = cur.trim();
+  if (t2 !== "")
+    out.push(t2);
+  return out;
+}
+function parseCreateMacro(stmt) {
+  let rest = stripKw(stmt.trim(), "create");
+  if (rest === null)
+    return null;
+  const afterOr = stripKw(rest, "or");
+  if (afterOr !== null) {
+    const afterReplace = stripKw(afterOr, "replace");
+    if (afterReplace === null)
+      return null;
+    rest = afterReplace;
+  }
+  const afterTemp = stripKw(rest, "temp") ?? stripKw(rest, "temporary");
+  if (afterTemp !== null)
+    rest = afterTemp;
+  const afterMacro = stripKw(rest, "macro") ?? stripKw(rest, "function");
+  if (afterMacro === null)
+    return null;
+  rest = afterMacro;
+  const nameEndMatch = rest.match(/[\s(]/);
+  const nameEnd = nameEndMatch ? nameEndMatch.index : rest.length;
+  const rawName = rest.slice(0, nameEnd);
+  if (rawName === "" || rawName.includes(".") || rawName.includes('"') || !isIdent(rawName)) {
+    return null;
+  }
+  const name = rawName.toLowerCase();
+  rest = rest.slice(nameEnd).replace(/^\s+/, "");
+  if (!rest.startsWith("("))
+    return null;
+  const pchars = [...rest];
+  let depth = 0;
+  let j2 = 0;
+  let close = -1;
+  while (j2 < pchars.length) {
+    const ch = pchars[j2];
+    if (ch === "(")
+      depth += 1;
+    else if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        close = j2;
+        break;
+      }
+    } else if (ch === "'" || ch === '"') {
+      const q2 = ch;
+      j2 += 1;
+      while (j2 < pchars.length && pchars[j2] !== q2)
+        j2 += 1;
+    }
+    j2 += 1;
+  }
+  if (close === -1)
+    return null;
+  const params = pchars.slice(1, close).join("").trim();
+  const afterParams = pchars.slice(close + 1).join("").replace(/^\s+/, "");
+  let body = stripKw(afterParams, "as");
+  if (body === null)
+    return null;
+  let isTable = false;
+  const afterTable = stripKw(body, "table");
+  if (afterTable !== null) {
+    body = afterTable;
+    isTable = true;
+  }
+  const trimmedBody = body.replace(/;+\s*$/, "").trim();
+  if (trimmedBody === "")
+    return null;
+  return { name, params, isTable };
+}
+function parseMacroLibrary(sql) {
+  const out = [];
+  for (const stmt of splitStatements(sql)) {
+    const m3 = parseCreateMacro(stmt);
+    if (m3)
+      out.push(m3);
+  }
+  return out;
+}
+function detectMacroCalls(sql, names) {
+  const found = new Set;
+  if (names.size === 0)
+    return found;
+  for (const stmt of splitStatements(sql)) {
+    const chars = [...stmt];
+    const n2 = chars.length;
+    let i = 0;
+    let prev = undefined;
+    while (i < n2) {
+      const c2 = chars[i];
+      if (c2 === "'" || c2 === '"') {
+        const q2 = c2;
+        i += 1;
+        while (i < n2 && chars[i] !== q2)
+          i += 1;
+        i += 1;
+        prev = q2;
+        continue;
+      }
+      const isIdentStart = /[A-Za-z_]/.test(c2);
+      const prevBlocks = prev !== undefined && /[.A-Za-z0-9_]/.test(prev);
+      if (isIdentStart && !prevBlocks) {
+        const start = i;
+        while (i < n2 && /[A-Za-z0-9_]/.test(chars[i]))
+          i += 1;
+        const word = chars.slice(start, i).join("").toLowerCase();
+        let k2 = i;
+        while (k2 < n2 && /\s/.test(chars[k2]))
+          k2 += 1;
+        if (k2 < n2 && chars[k2] === "(" && names.has(word))
+          found.add(word);
+        prev = chars[i - 1];
+        continue;
+      }
+      prev = c2;
+      i += 1;
+    }
+  }
+  return found;
+}
+function parseMacroAnnotations(content) {
+  let macros = false;
+  const useLibs = [];
+  for (const raw of content.split(`
+`)) {
+    const line = raw.replace(/^\s+/, "");
+    if (line === "")
+      continue;
+    let rest;
+    if (line.startsWith("//") || line.startsWith("--"))
+      rest = line.slice(2);
+    else if (line.startsWith("#"))
+      rest = line.slice(1);
+    else
+      break;
+    rest = rest.replace(/^\s+/, "");
+    if (/^macros\s*$/.test(rest)) {
+      macros = true;
+      continue;
+    }
+    const u2 = rest.match(/^use\s+(\S+)\s*$/);
+    if (u2 && u2[1].includes("/") && !useLibs.includes(u2[1]))
+      useLibs.push(u2[1]);
+  }
+  return { macros, useLibs };
+}
+
+// src/commands/pipeline/localGraph.ts
 function workspaceRoot() {
   const yaml = getWmillYamlPath();
   return yaml ? path23.dirname(yaml) : process25.cwd();
@@ -96076,7 +96323,8 @@ function fallbackParse(content, language) {
     if (uri) {
       const prefix = uri[1].toLowerCase();
       const kind = prefix === "s3" ? "s3object" : prefix;
-      out.triggers.push({ kind: "asset", asset_kind: kind, path: uri[2] });
+      const path24 = kind === "s3object" ? uri[2].replace(/^\/+/, "") : uri[2];
+      out.triggers.push({ kind: "asset", asset_kind: kind, path: path24 });
     } else if (NATIVE_KINDS.has(firstTok) && rest === firstTok) {
       out.triggers.push({ kind: firstTok });
     }
@@ -96224,15 +96472,40 @@ async function buildLocalPipelineGraph(args) {
   const folderClean = args.folder.replace(/^f\//, "").replace(/\/$/, "");
   const folderDir = path23.join(args.root, "f", folderClean);
   const all = await collectScripts(folderDir, args.root, args.defaultTs);
+  const libMacros = collectMacroLibraries(args.root);
   const runnables = [];
   const edges = [];
   const triggers = [];
   const assetSet = new Map;
+  const derivedFromByKey = new Map;
   const pipelineScripts = [];
+  const dataTestsByPath = new Map;
+  const readsByRunnable = new Map;
   for (const s2 of all) {
     const out = await inferScriptAssets(s2.content, s2.language);
+    const reads = (out.assets ?? []).filter((a2) => a2.access_type == null || a2.access_type === "r" || a2.access_type === "rw").map((a2) => ({ kind: a2.kind, path: a2.path }));
+    if (reads.length > 0)
+      readsByRunnable.set(s2.path, reads);
+    const macroLibDefs = libMacros.get(s2.path);
+    if (macroLibDefs) {
+      runnables.push({
+        path: s2.path,
+        usage_kind: "script",
+        in_pipeline: true,
+        ...out.tag ? { tag: out.tag } : {},
+        macros: macroLibDefs.map((m3) => ({
+          name: m3.name,
+          params: m3.params,
+          is_table: m3.isTable
+        }))
+      });
+      continue;
+    }
     if (!out.in_pipeline)
       continue;
+    if (out.data_tests && out.data_tests.length > 0) {
+      dataTestsByPath.set(s2.path, out.data_tests);
+    }
     const retry = normalizeRetry(out.retry);
     const nativeTriggers = recoverHeaderNativeTriggers(s2.content, s2.language);
     pipelineScripts.push(out.tag ? { ...s2, tag: out.tag } : s2);
@@ -96263,19 +96536,30 @@ async function buildLocalPipelineGraph(args) {
       });
     }
     if (mat) {
-      assetSet.set(`${mat.target_kind}:${mat.target_path}`, {
-        kind: mat.target_kind,
-        path: mat.target_path
-      });
-      const hasWrite = edges.some((e2) => e2.runnable_path === s2.path && e2.asset_kind === mat.target_kind && e2.asset_path === mat.target_path && (e2.access_type === "w" || e2.access_type === "rw"));
-      if (!hasWrite) {
-        edges.push({
-          runnable_kind: "script",
-          runnable_path: s2.path,
-          asset_kind: mat.target_kind,
-          asset_path: mat.target_path,
-          access_type: "w"
+      const matWrites = [
+        { path: mat.target_path }
+      ];
+      if (mat.scd2 && !mat.manual) {
+        const currentPath = `${mat.target_path}_current`;
+        matWrites.push({ path: currentPath, derived_from: mat.target_path });
+        derivedFromByKey.set(`${mat.target_kind}:${currentPath}`, mat.target_path);
+      }
+      for (const w2 of matWrites) {
+        assetSet.set(`${mat.target_kind}:${w2.path}`, {
+          kind: mat.target_kind,
+          path: w2.path,
+          ...w2.derived_from ? { derived_from: w2.derived_from } : {}
         });
+        const hasWrite = edges.some((e2) => e2.runnable_path === s2.path && e2.asset_kind === mat.target_kind && e2.asset_path === w2.path && (e2.access_type === "w" || e2.access_type === "rw"));
+        if (!hasWrite) {
+          edges.push({
+            runnable_kind: "script",
+            runnable_path: s2.path,
+            asset_kind: mat.target_kind,
+            asset_path: w2.path,
+            access_type: "w"
+          });
+        }
       }
     }
     const existingNativeTriggers = new Set;
@@ -96312,16 +96596,183 @@ async function buildLocalPipelineGraph(args) {
       });
     }
   }
+  const macroEdges = buildMacroEdges(all, libMacros, runnables);
+  const testEdges = buildTestEdges(dataTestsByPath, readsByRunnable, edges);
+  const assets = [...assetSet.entries()].map(([key, a2]) => {
+    const derived_from = a2.derived_from ?? derivedFromByKey.get(key);
+    return derived_from ? { ...a2, derived_from } : a2;
+  });
   return {
     graph: {
       runnables,
-      assets: [...assetSet.values()],
+      assets,
       edges,
-      triggers
+      triggers,
+      ...macroEdges.length > 0 ? { macro_edges: macroEdges } : {},
+      ...testEdges.length > 0 ? { test_edges: testEdges } : {}
     },
     scripts: pipelineScripts
   };
 }
+function buildTestEdges(dataTestsByPath, readsByRunnable, edges) {
+  const producersByAsset = new Map;
+  for (const e2 of edges) {
+    if (e2.access_type !== "w" && e2.access_type !== "rw")
+      continue;
+    const key = `${e2.asset_kind}\x00${e2.asset_path}`;
+    (producersByAsset.get(key) ?? producersByAsset.set(key, []).get(key)).push({
+      kind: e2.runnable_kind,
+      path: e2.runnable_path
+    });
+  }
+  const out = [];
+  const seen = new Set;
+  for (const [memberPath, dts] of dataTestsByPath) {
+    for (const dt of dts) {
+      let referenced = [];
+      if (dt.type === "relationships") {
+        referenced = [{ kind: dt.to_kind, path: dt.to_path }];
+      } else if (dt.type === "custom") {
+        referenced = readsByRunnable.get(dt.path) ?? [];
+      }
+      for (const ref of referenced) {
+        const producers = producersByAsset.get(`${ref.kind}\x00${ref.path}`);
+        if (!producers)
+          continue;
+        for (const p3 of producers) {
+          if (p3.kind === "script" && p3.path === memberPath)
+            continue;
+          const key = [p3.path, memberPath, ref.kind, ref.path].join("\x00");
+          if (seen.has(key))
+            continue;
+          seen.add(key);
+          out.push({
+            producer_kind: p3.kind,
+            producer_path: p3.path,
+            runnable_kind: "script",
+            runnable_path: memberPath,
+            asset_kind: ref.kind,
+            asset_path: ref.path
+          });
+        }
+      }
+    }
+  }
+  out.sort((a2, b2) => a2.producer_path.localeCompare(b2.producer_path) || a2.runnable_path.localeCompare(b2.runnable_path) || a2.asset_kind.localeCompare(b2.asset_kind) || a2.asset_path.localeCompare(b2.asset_path));
+  return out;
+}
+function collectMacroLibraries(root) {
+  const out = new Map;
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs17.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e2 of entries) {
+      if (e2.name.startsWith(".") || e2.name === "node_modules")
+        continue;
+      const abs = path23.join(dir, e2.name);
+      if (e2.isDirectory()) {
+        walk(abs);
+        continue;
+      }
+      if (!e2.isFile() || !e2.name.endsWith(".duckdb.sql"))
+        continue;
+      let content;
+      try {
+        content = fs17.readFileSync(abs, "utf-8");
+      } catch {
+        continue;
+      }
+      if (!parseMacroAnnotations(content).macros)
+        continue;
+      const relFromRoot = path23.relative(root, abs).replaceAll("\\", "/");
+      out.set(removeExtensionToPath(relFromRoot), parseMacroLibrary(content));
+    }
+  };
+  walk(path23.join(root, "f"));
+  return out;
+}
+function buildMacroEdges(all, libMacros, runnables) {
+  if (libMacros.size === 0)
+    return [];
+  const useLibsByScript = new Map;
+  for (const s2 of all) {
+    if (s2.language !== "duckdb")
+      continue;
+    const { useLibs } = parseMacroAnnotations(s2.content);
+    if (useLibs.length > 0)
+      useLibsByScript.set(s2.path, useLibs);
+  }
+  const providerByName = new Map;
+  for (const [lib, macros] of libMacros) {
+    for (const m3 of macros)
+      providerByName.set(m3.name, lib);
+  }
+  const allMacroNames = new Set(providerByName.keys());
+  const pipelinePaths = new Set(runnables.map((r2) => r2.path));
+  const edgeMap = new Map;
+  const aggFor = (lib, consumer) => {
+    let byConsumer = edgeMap.get(lib);
+    if (!byConsumer) {
+      byConsumer = new Map;
+      edgeMap.set(lib, byConsumer);
+    }
+    let agg = byConsumer.get(consumer);
+    if (!agg) {
+      agg = { names: new Set, viaUse: false };
+      byConsumer.set(consumer, agg);
+    }
+    return agg;
+  };
+  for (const s2 of all) {
+    if (s2.language !== "duckdb")
+      continue;
+    for (const name of detectMacroCalls(s2.content, allMacroNames)) {
+      const lib = providerByName.get(name);
+      if (lib === s2.path)
+        continue;
+      aggFor(lib, s2.path).names.add(name);
+    }
+    if (!pipelinePaths.has(s2.path))
+      continue;
+    for (const lib of useLibsByScript.get(s2.path) ?? []) {
+      const macros = libMacros.get(lib);
+      if (!macros || lib === s2.path)
+        continue;
+      const agg = aggFor(lib, s2.path);
+      agg.viaUse = true;
+      for (const m3 of macros)
+        agg.names.add(m3.name);
+    }
+  }
+  const edges = [...edgeMap.entries()].flatMap(([lib_path, byConsumer]) => [...byConsumer.entries()].map(([consumer_path, agg]) => ({
+    lib_path,
+    consumer_path,
+    macro_names: [...agg.names].sort(),
+    via_use: agg.viaUse
+  }))).sort((a2, b2) => a2.lib_path.localeCompare(b2.lib_path) || a2.consumer_path.localeCompare(b2.consumer_path));
+  const libPaths = new Set(edges.map((e2) => e2.lib_path));
+  for (const lib of libPaths) {
+    if (runnables.some((r2) => r2.path === lib))
+      continue;
+    const macros = (libMacros.get(lib) ?? []).map((m3) => ({
+      name: m3.name,
+      params: m3.params,
+      is_table: m3.isTable
+    }));
+    runnables.push({ path: lib, usage_kind: "script", macros });
+  }
+  for (const consumer of new Set(edges.map((e2) => e2.consumer_path))) {
+    if (!runnables.some((r2) => r2.path === consumer)) {
+      runnables.push({ path: consumer, usage_kind: "script" });
+    }
+  }
+  runnables.sort((a2, b2) => a2.path.localeCompare(b2.path));
+  return edges;
+}
 
 // src/commands/pipeline/pipeline.ts
 await __promiseAll([
@@ -96552,7 +97003,17 @@ function generatePipelineMarkdown(folder, graph, datatableSchemas, local) {
       (nativeByScript.get(t2.runnable_path) ?? nativeByScript.set(t2.runnable_path, []).get(t2.runnable_path)).push(t2.trigger_kind);
     }
   }
-  const scripts = graph.runnables.filter((r2) => r2.usage_kind === "script").map((r2) => r2.path).sort();
+  const macroLibs = graph.runnables.filter((r2) => r2.usage_kind === "script" && (r2.macros?.length ?? 0) > 0).sort((a2, b2) => a2.path.localeCompare(b2.path));
+  const macroLibPaths = new Set(macroLibs.map((r2) => r2.path));
+  const macroConsumersByLib = new Map;
+  for (const me of graph.macro_edges ?? []) {
+    (macroConsumersByLib.get(me.lib_path) ?? macroConsumersByLib.set(me.lib_path, []).get(me.lib_path)).push({
+      consumer: me.consumer_path,
+      names: me.macro_names,
+      viaUse: me.via_use
+    });
+  }
+  const scripts = graph.runnables.filter((r2) => r2.usage_kind === "script" && !macroLibPaths.has(r2.path)).map((r2) => r2.path).sort();
   let md = `# Pipeline \`f/${folder}\`
 
 ${local ? "_Built from local working-tree files (`// pipeline` scripts)._" : "_Built from the deployed workspace asset graph._"}
@@ -96563,7 +97024,7 @@ produces data by reading/writing assets in its body (\`datatable://\`,
 \`ducklake://\`, \`s3://\`, \`volume://\`). The cascade runs a producer, then every
 downstream subscriber, in topological order.
 
-- **${scripts.length}** script${scripts.length === 1 ? "" : "s"} · **${graph.assets.length}** asset${graph.assets.length === 1 ? "" : "s"}
+- **${scripts.length}** script${scripts.length === 1 ? "" : "s"} · **${graph.assets.length}** asset${graph.assets.length === 1 ? "" : "s"}${macroLibs.length > 0 ? ` · **${macroLibs.length}** macro librar${macroLibs.length === 1 ? "y" : "ies"}` : ""}
 
 ## Scripts
 
@@ -96595,6 +97056,36 @@ downstream subscriber, in topological order.
     md += `
 `;
   }
+  if (macroLibs.length > 0) {
+    md += `## Macro libraries
+
+`;
+    md += `\`// macros\` DuckDB libraries. Their \`CREATE MACRO\` definitions are injected as
+TEMP macros into consuming scripts at run time — call a macro by name, or force the
+whole library in with \`// use <lib-path>\` (needed for macros only reached via dynamic SQL).
+
+`;
+    for (const lib of macroLibs) {
+      md += `### \`${lib.path}\`
+
+`;
+      for (const m3 of lib.macros ?? []) {
+        md += `- \`${m3.name}(${m3.params ?? ""})\`${m3.is_table ? " → TABLE" : ""}
+`;
+      }
+      const consumers = [...macroConsumersByLib.get(lib.path) ?? []].sort((a2, b2) => a2.consumer.localeCompare(b2.consumer));
+      if (consumers.length > 0) {
+        md += `- **Used by:**
+`;
+        for (const c2 of consumers) {
+          md += `  - \`${c2.consumer}\` (${c2.viaUse ? "via `// use`" : `calls ${c2.names.map((n2) => `\`${n2}\``).join(", ")}`})
+`;
+        }
+      }
+      md += `
+`;
+    }
+  }
   const referencedDatatables = new Set(graph.assets.filter((a2) => a2.kind === "datatable").map((a2) => a2.path.split("/")[0]));
   const relevant = (datatableSchemas ?? []).filter((dt) => referencedDatatables.has(dt.datatable_name));
   if (relevant.length > 0) {
@@ -97104,11 +97595,13 @@ async function run5(opts, folder) {
     });
     graph = built.graph;
     localScripts = new Map(built.scripts.map((s2) => [s2.path, s2]));
-    try {
-      const codebases = await listSyncCodebases(merged);
-      const { buildPreviewTempScriptRefs: buildPreviewTempScriptRefs2 } = await init_generate_metadata().then(() => exports_generate_metadata);
-      tempScriptRefs = await buildPreviewTempScriptRefs2(workspace, merged, codebases, { kind: "all" });
-    } catch {}
+    if (!opts.dryRun) {
+      try {
+        const codebases = await listSyncCodebases(merged);
+        const { buildPreviewTempScriptRefs: buildPreviewTempScriptRefs2 } = await init_generate_metadata().then(() => exports_generate_metadata);
+        tempScriptRefs = await buildPreviewTempScriptRefs2(workspace, merged, codebases, { kind: "all" });
+      } catch {}
+    }
   } else {
     graph = await apiGet(`/w/${workspace.workspaceId}/assets/graph?folder=${encodeURIComponent(f3)}&asset_kinds=${ASSET_KINDS2}`);
     await enrichDeployedNonAutorunTriggers(workspace.workspaceId, graph);
@@ -97144,7 +97637,16 @@ async function run5(opts, folder) {
     merged[b2.param] = b2.value;
   }
   const macroLibPaths = new Set(graph.runnables.filter((r2) => r2.usage_kind === "script" && (r2.macros?.length ?? 0) > 0).map((r2) => r2.path));
-  const starts = new Set([...validStarts(graph), ...boundNodeIds].filter((id) => !macroLibPaths.has(scriptPathOf(id))));
+  const notRunnablePaths = new Set(macroLibPaths);
+  if (opts.local && localScripts) {
+    for (const r2 of graph.runnables) {
+      if (r2.usage_kind === "script" && !localScripts.has(r2.path)) {
+        notRunnablePaths.add(r2.path);
+      }
+    }
+  }
+  const starts = new Set([...validStarts(graph), ...boundNodeIds].filter((id) => !notRunnablePaths.has(scriptPathOf(id))));
+  const fromEligible = new Set([...validFromStarts(graph), ...boundNodeIds].filter((id) => !notRunnablePaths.has(scriptPathOf(id))));
   let runAll = false;
   let start;
   if (opts.from) {
@@ -97159,8 +97661,14 @@ async function run5(opts, folder) {
     if (macroLibPaths.has(scriptPathOf(resolved))) {
       throw new Error(`--from '${opts.from}' is a \`// macros\` library — definition-only, injected into consuming scripts at run time, never a runnable step.`);
     }
-    if (!starts.has(resolved)) {
-      throw new Error(`--from '${opts.from}' is not a valid bounded-run start. Starts must be schedule-triggered or manual roots; row-backed event triggers (kafka/mqtt/nats/postgres/sqs/gcp/email) fan out per-event and can't be bounded.`);
+    if (notRunnablePaths.has(scriptPathOf(resolved))) {
+      throw new Error(`--from '${opts.from}' isn't a \`// pipeline\` script — it appears in the local graph only as a macro consumer (lineage). Mark it \`// pipeline\` to run it.`);
+    }
+    if (!resolved.startsWith("script:")) {
+      throw new Error(`--from '${opts.from}' is an asset, not a runnable — start a run from a script (assets are produced, not run).`);
+    }
+    if (!fromEligible.has(resolved)) {
+      throw new Error(`--from '${opts.from}' can't start a run: row-backed event triggers (kafka/mqtt/nats/postgres/sqs/gcp/email) and input-only entrypoints (webhook/data_upload) fan out per-event or need caller-supplied input — bind it with --upload to run it.`);
     }
     start = resolved;
   } else if (starts.size === 1) {
@@ -97191,7 +97699,7 @@ async function run5(opts, folder) {
   }
   const idLabel = (id) => id.startsWith("script:") ? scriptPathOf(id) : id;
   const dag = buildLineageDag(graph);
-  const barriers = new Set([...nonAutorunTriggerScripts(graph)].filter((id) => !starts.has(id)));
+  const barriers = new Set([...nonAutorunTriggerScripts(graph)].filter((id) => !starts.has(id) && id !== start));
   let selectedScripts;
   let reachableEnds = [];
   let droppedEnds = [];
@@ -97216,7 +97724,7 @@ async function run5(opts, folder) {
       }
     }
   }
-  for (const p3 of macroLibPaths)
+  for (const p3 of notRunnablePaths)
     selectedScripts.delete(p3);
   const { order, cyclic } = topoOrder(graph, selectedScripts);
   if (cyclic.length > 0) {
@@ -97333,7 +97841,7 @@ Full logs: ${runUrl}`);
     info(colors.green.bold(`Bounded run complete — ${order.length} script(s) succeeded.`));
   }
 }
-var command42 = new Command().description("inspect asset-driven pipelines (scripts marked `// pipeline`, wired by `// on <spec>` annotations)").command("list", "list pipeline folders in the workspace").option("--json", "Output as JSON (for piping to jq)").action(list18).command("show", "render a pipeline folder's DAG (sources, lineage, subscriptions) in the terminal").arguments("<folder:string>").option("--json", "Output the raw asset graph as JSON").option("--local", "Build the graph from local working-tree files (// pipeline scripts) instead of the deployed workspace — no deploy needed.").action(show2).command("run", "run a bounded cascade: from a schedule/manual root, fan downstream up to the --to end node(s)").arguments("<folder:string>").option("--from <script:string>", "Start script (short name or path). Defaults to the folder's sole schedule/manual root.").option("--to <node:string>", "End node(s) to stop at — script names/paths or asset URIs (e.g. datatable://main/staged). Repeatable or comma-separated. Omit to run the full downstream.", { collect: true }).option("--dry-run", "Print the topological run plan without executing.").option("--json", "Output the plan as JSON (for piping to jq).").option("--local", "Run the local working-tree scripts via preview (no deploy) instead of the deployed versions; the graph is built from local files.").option("--upload <binding:string>", "Bind an object to a data_upload/webhook entry point so it runs in the cascade, as SCRIPT[:PARAM]=SOURCE (SOURCE is a local file or an s3://key). Local files are uploaded to the workspace store; the S3Object param is inferred when the script has exactly one. Repeatable.", { collect: true }).option("--arg <binding:string>", "Pass a plain run arg to a script in the cascade, as SCRIPT:PARAM=VALUE (VALUE is parsed as JSON when possible, else taken as a string — e.g. daily_report:partition=2026-07-02). Repeatable.", { collect: true }).option("--partition <value:string>", "Partition value for `// partitioned` scripts in the run (e.g. 2026-06-30) — use it to backfill a past slice. With --local, time kinds (daily/hourly/weekly/monthly) default to the current UTC period when omitted; `dynamic` always needs it. Deployed runs without it defer to backend run-start resolution.").action(run5).command("docs", "generate PIPELINE.md (+ AGENTS.md pointer) describing a folder's pipeline graph and datatable schemas, for an editor / agentic loop").arguments("<folder:string>").option("--local", "Build the graph from local working-tree files instead of the deployed workspace.").action(generatePipelineDocs).command("dev", dev_default3);
+var command42 = new Command().description("inspect asset-driven pipelines (scripts marked `// pipeline`, wired by `// on <spec>` annotations)").command("list", "list pipeline folders in the workspace").option("--json", "Output as JSON (for piping to jq)").action(list18).command("show", "render a pipeline folder's DAG (sources, lineage, subscriptions) in the terminal").arguments("<folder:string>").option("--json", "Output the raw asset graph as JSON").option("--local", "Build the graph from local working-tree files (// pipeline scripts) instead of the deployed workspace — no deploy needed.").action(show2).command("run", "run a cascade: from --from (a root OR any mid-DAG model), fan downstream up to the --to end node(s)").arguments("<folder:string>").option("--from <script:string>", "Start script (short name or path). May be any node, including a mid-DAG model — that node plus its transitive downstream runs, upstream is NOT re-run (dbt `--select model+`). Defaults to the folder's sole schedule/manual root.").option("--to <node:string>", "End node(s) to stop at — script names/paths or asset URIs (e.g. datatable://main/staged). Repeatable or comma-separated. Omit to run the full downstream.", { collect: true }).option("--dry-run", "Print the topological run plan without executing.").option("--json", "Output the plan as JSON (for piping to jq).").option("--local", "Run the local working-tree scripts via preview (no deploy) instead of the deployed versions; the graph is built from local files.").option("--upload <binding:string>", "Bind an object to a data_upload/webhook entry point so it runs in the cascade, as SCRIPT[:PARAM]=SOURCE (SOURCE is a local file or an s3://key). Local files are uploaded to the workspace store; the S3Object param is inferred when the script has exactly one. Repeatable.", { collect: true }).option("--arg <binding:string>", "Pass a plain run arg to a script in the cascade, as SCRIPT:PARAM=VALUE (VALUE is parsed as JSON when possible, else taken as a string — e.g. daily_report:partition=2026-07-02). Repeatable.", { collect: true }).option("--partition <value:string>", "Partition value for `// partitioned` scripts in the run (e.g. 2026-06-30) — use it to backfill a past slice. With --local, time kinds (daily/hourly/weekly/monthly) default to the current UTC period when omitted; `dynamic` always needs it. Deployed runs without it defer to backend run-start resolution.").action(run5).command("docs", "generate PIPELINE.md (+ AGENTS.md pointer) describing a folder's pipeline graph and datatable schemas, for an editor / agentic loop").arguments("<folder:string>").option("--local", "Build the graph from local working-tree files instead of the deployed workspace.").action(generatePipelineDocs).command("dev", dev_default3);
 var pipeline_default = command42;
 
 // src/commands/ducklake/ducklake.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-cli",
-  "version": "1.748.0",
+  "version": "1.750.0",
   "description": "CLI for Windmill",
   "license": "Apache 2.0",
   "type": "module",
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "esbuild": "0.28.0",
-    "windmill-parser-wasm-asset": "1.740.0",
+    "windmill-parser-wasm-asset": "1.749.0",
     "windmill-parser-wasm-csharp": "1.510.1",
     "windmill-parser-wasm-go": "1.510.1",
     "windmill-parser-wasm-java": "1.510.1",