@platforma-sdk/tengo-builder 2.5.30 → 3.0.0

package/src/compiler/main.ts

@@ -13,6 +13,18 @@ import { newTemplateFromContent, templateToSource } from "./template";
 import type winston from "winston";
 import { tryResolve, tryResolveOrError } from "@milaboratories/resolve-helper";
 import { serializeTemplate } from "@milaboratories/pl-model-backend";
+import {
+  assertTemplatePackSize,
+  assertWasmFileSize,
+  collectWasmContributions,
+} from "./pack_limits";
+
+// Convention: wasm component packages declare their wasm under a "wasm" condition
+// in package.json `exports`. Subpath "." maps to the tengo id "main"; subpath
+// "./foo" maps to id "foo". Other shapes of `exports` (string-valued, condition-only)
+// don't produce wasm artifacts.
+const wasmExportCondition = "wasm";
+const defaultWasmExportId = "main";
 
 interface PackageId {
   /** Package name from package.json */
@@ -44,6 +56,7 @@ const compiledTplSuffix = ".plj.gz";
 const compiledLibSuffix = ".lib.tengo";
 const compiledSoftwareSuffix = ".sw.json";
 const compiledAssetSuffix = ".as.json";
+const compiledWasmSuffix = ".wasm";
 
 // We need to keep track of dependencies for correct tgo-test CLI utility configuraiton.
 // It is much simpler to do this here, than duplicate all tle logic regarding dependencies
@@ -79,15 +92,32 @@ function resolvePackageJsonPackage(root: string, depPackageName: string): string
 
   // Second approach: trying to find package.json in the package dir.
   const resolved2 = tryResolveOrError(root, `${depPackageName}/package.json`);
-  if (resolved2.result === undefined) {
-    if (resolved2.err === "ERR_PACKAGE_PATH_NOT_EXPORTED")
-      // tolerating not-exported package.json for dev dependencies
-      return undefined;
-    throw new Error(
-      `Can't resolve package.json for package ${depPackageName ?? "."} relative to ${root}`,
-    );
+  if (resolved2.result !== undefined) {
+    return resolved2.result;
+  }
+
+  // Third approach: some packages (wasm-only components) don't expose any
+  // import-resolvable entry point — neither a default export nor `./package.json`.
+  // pnpm still installs them at <root>/node_modules/<depPackageName>/, so walk
+  // the parent chain and check that path directly.
+  if (resolved2.err === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
+    const fromNodeModules = findInNodeModules(root, depPackageName);
+    if (fromNodeModules !== undefined) return fromNodeModules;
+    // tolerating not-exported package.json for dev dependencies even if no
+    // physical node_modules copy is found.
+    return undefined;
   }
-  return resolved2.result;
+  throw new Error(
+    `Can't resolve package.json for package ${depPackageName ?? "."} relative to ${root}`,
+  );
+}
+
+function findInNodeModules(root: string, depPackageName: string): string | undefined {
+  const candidate = path.join(root, "node_modules", depPackageName, "package.json");
+  if (pathType(candidate) === "file") return candidate;
+  const parent = path.dirname(root);
+  if (parent === root) return undefined;
+  return findInNodeModules(parent, depPackageName);
 }
 
 export function resolvePackageJsonRoot(root: string): string {
@@ -165,6 +195,10 @@ function resolveAssetsDst(mode: CompileMode, root: string) {
   return path.resolve(root, mode, "tengo", "asset");
 }
 
+function resolveWasmDst(mode: CompileMode, root: string) {
+  return path.resolve(root, mode, "tengo", "wasm");
+}
+
 function loadDependencies(
   logger: winston.Logger,
   compiler: TengoTemplateCompiler,
@@ -181,13 +215,23 @@ function loadDependencies(
   const tplDistFolder = resolveTemplatesDst("dist", packageInfo.root);
   const softwareDistFolder = resolveSoftwareDst("dist", packageInfo.root);
   const assetDistFolder = resolveAssetsDst("dist", packageInfo.root);
+  const wasmDistFolder = resolveWasmDst("dist", packageInfo.root);
 
   const libDistExists = pathType(libDistFolder) === "dir";
   const tplDistExists = pathType(tplDistFolder) === "dir";
   const softwareDistExists = pathType(softwareDistFolder) === "dir";
   const assetDistExists = pathType(assetDistFolder) === "dir";
-
-  if (!libDistExists && !tplDistExists && !softwareDistExists && !assetDistExists)
+  const wasmDistExists = pathType(wasmDistFolder) === "dir";
+  const wasmExports = collectWasmExportPaths(packageInfo.root);
+
+  if (
+    !libDistExists &&
+    !tplDistExists &&
+    !softwareDistExists &&
+    !assetDistExists &&
+    !wasmDistExists &&
+    wasmExports.length === 0
+  )
     // if neither of tengo-specific folders detected, skipping package
     return;
 
@@ -208,6 +252,14 @@ function loadDependencies(
   if (assetDistExists) {
     loadAssetsFromDir(logger, packageId, "dist", assetDistFolder, compiler);
   }
+
+  if (wasmDistExists) {
+    loadWasmFromDir(logger, packageId, "dist", wasmDistFolder, compiler);
+  }
+
+  for (const wasmExport of wasmExports) {
+    loadWasmFromExport(logger, packageId, "dist", packageInfo.root, wasmExport, compiler);
+  }
 }
 
 function loadLibsFromDir(
@@ -313,6 +365,142 @@ function loadAssetsFromDir(
   }
 }
 
+function loadWasmFromDir(
+  logger: winston.Logger,
+  packageId: PackageId,
+  mode: CompileMode,
+  folder: string,
+  compiler: TengoTemplateCompiler,
+) {
+  for (const f of fs.readdirSync(folder)) {
+    const file = path.resolve(folder, f);
+    if (!f.endsWith(compiledWasmSuffix))
+      throw new Error(`unexpected file in 'wasm' folder: ${file}`);
+    const fullName: FullArtifactName = {
+      type: "wasm",
+      pkg: packageId.name,
+      id: f.slice(0, f.length - compiledWasmSuffix.length),
+      version: packageId.version,
+    };
+
+    addWasmFile(logger, mode, file, fullName, compiler);
+  }
+}
+
+interface WasmExport {
+  id: string;
+  /** wasm file path, relative to the package root */
+  relPath: string;
+}
+
+function loadWasmFromExport(
+  logger: winston.Logger,
+  packageId: PackageId,
+  mode: CompileMode,
+  packageRoot: string,
+  wasmExport: WasmExport,
+  compiler: TengoTemplateCompiler,
+) {
+  const file = path.resolve(packageRoot, wasmExport.relPath);
+  if (pathType(file) !== "file") {
+    throw new Error(
+      `wasm export "${wasmExport.id}" points to missing file: ${file} (package ${packageId.name})`,
+    );
+  }
+  const fullName: FullArtifactName = {
+    type: "wasm",
+    pkg: packageId.name,
+    id: wasmExport.id,
+    version: packageId.version,
+  };
+
+  addWasmFile(logger, mode, file, fullName, compiler);
+}
+
+function addWasmFile(
+  logger: winston.Logger,
+  mode: CompileMode,
+  file: string,
+  fullName: FullArtifactName,
+  compiler: TengoTemplateCompiler,
+) {
+  // wasm bytes are binary, but hashToSource carries strings only. We base64-encode
+  // the bytes; the sourceHash is sha256 of the base64 string so it stays consistent
+  // with the existing `hashToSource[hash] === stored value` invariant.
+  const bytes = fs.readFileSync(file);
+  assertWasmFileSize(file, bytes.length, fullName);
+  const source = bytes.toString("base64");
+  const wasm = new ArtifactSource(mode, fullName, getSha256(source), source, file, [], []);
+
+  logger.debug(`Adding dependency ${fullNameToString(fullName)} from ${file}`);
+  compiler.addWasm(wasm);
+}
+
+/**
+ * Discover wasm artifacts declared by a package's `package.json` via the
+ * node `exports` conditional-exports map.
+ *
+ * Convention: a package that wants to ship one or more wasm components to
+ * tengo-builder publishes them under a `"wasm"` condition keyed by an
+ * `exports` subpath. The subpath becomes the wasm artifact id (`.` →
+ * `main`, `./foo` → `foo`). Example shape we look for:
+ *
+ *   {
+ *     "exports": {
+ *       ".": {
+ *         "wasm": "./dist/pframes_rs_wasip2.wasm",  // ← discovered
+ *         "wit":  "./wit/world.wit"
+ *       },
+ *       "./extra": {
+ *         "wasm": "./dist/extra.wasm"               // ← discovered as id "extra"
+ *       }
+ *     }
+ *   }
+ *
+ * Why raw traversal instead of Zod / a typed schema:
+ *   1. `package.json#exports` is a community convention with no fixed shape
+ *      — any combination of strings, objects, arrays, and conditions is
+ *      legal node syntax. A strict schema would either reject valid
+ *      packages or have to admit `unknown` for half of it anyway.
+ *   2. We care about exactly one condition (`wasm`) on subpath entries,
+ *      not the rest of the exports tree. A targeted walk reads more
+ *      directly than a schema that re-describes the conditional-exports
+ *      grammar.
+ *   3. Errors here should always mean "this package contributes no wasm";
+ *      never crash the build. Every check returns `[]` or `continue`s.
+ *
+ * Returns the discovered wasm exports; empty when the file is missing,
+ * malformed, has no `exports`, or has no subpath with a `"wasm"`
+ * condition pointing at a string path.
+ */
+function collectWasmExportPaths(packageRoot: string): WasmExport[] {
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  if (pathType(packageJsonPath) !== "file") return [];
+
+  let raw: unknown;
+  try {
+    raw = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  } catch {
+    return [];
+  }
+  if (typeof raw !== "object" || raw === null) return [];
+
+  const exportsField = (raw as { exports?: unknown }).exports;
+  if (typeof exportsField !== "object" || exportsField === null) return [];
+
+  const result: WasmExport[] = [];
+  for (const [subpath, value] of Object.entries(exportsField as Record<string, unknown>)) {
+    if (!subpath.startsWith(".")) continue; // skip condition-only entries
+    if (typeof value !== "object" || value === null) continue;
+    const wasmPath = (value as Record<string, unknown>)[wasmExportCondition];
+    if (typeof wasmPath !== "string") continue;
+    const id = subpath === "." ? defaultWasmExportId : subpath.replace(/^\.\/?/, "");
+    if (!id) continue;
+    result.push({ id, relPath: wasmPath });
+  }
+  return result;
+}
+
 export function parseSources(
   logger: winston.Logger,
   packageId: PackageId,
@@ -468,8 +656,14 @@ export function savePacks(logger: winston.Logger, compiled: TemplatesAndLibs, mo
     fs.mkdirSync(tplOutput, { recursive: true });
     for (const tpl of compiled.templates) {
       const file = path.resolve(tplOutput, tpl.fullName.id + compiledTplSuffix);
+      const packed = serializeTemplate(tpl.data);
+      assertTemplatePackSize(
+        fullNameToString(tpl.fullName),
+        packed.byteLength,
+        collectWasmContributions(tpl.data),
+      );
       logger.info(`  - writing ${file}`);
-      fs.writeFileSync(file, serializeTemplate(tpl.data));
+      fs.writeFileSync(file, packed);
     }
   }
 
@@ -494,4 +688,16 @@ export function savePacks(logger: winston.Logger, compiled: TemplatesAndLibs, mo
       fs.writeFileSync(file, sw.src);
     }
   }
+
+  // writing wasm
+  if (compiled.wasm.length > 0) {
+    const wasmOutput = resolveWasmDst(mode, ".");
+    fs.mkdirSync(wasmOutput, { recursive: true });
+    for (const wasm of compiled.wasm) {
+      const file = path.resolve(wasmOutput, wasm.fullName.id + compiledWasmSuffix);
+      logger.info(`  - writing ${file}`);
+      // wasm.src holds base64-encoded bytes; decode back to raw bytes on disk
+      fs.writeFileSync(file, Buffer.from(wasm.src, "base64"));
+    }
+  }
 }

package/src/compiler/pack_limits.test.ts

@@ -0,0 +1,173 @@
+import type { CompiledTemplateV3 } from "@milaboratories/pl-model-backend";
+import { describe, expect, it } from "vitest";
+
+import type { FullArtifactName } from "./package";
+import {
+  MAX_TEMPLATE_PACK_BYTES_GZIPPED,
+  MAX_WASM_FILE_BYTES,
+  assertTemplatePackSize,
+  assertWasmFileSize,
+  collectWasmContributions,
+} from "./pack_limits";
+
+const wasmName: FullArtifactName = {
+  type: "wasm",
+  pkg: "@test/pkg",
+  id: "main",
+  version: "1.0.0",
+};
+
+describe("assertWasmFileSize", () => {
+  it("passes at exactly the cap", () => {
+    expect(() => assertWasmFileSize("/p/a.wasm", MAX_WASM_FILE_BYTES, wasmName)).not.toThrow();
+  });
+
+  it("throws above the cap with file path, full name, and shrink hint", () => {
+    let err: unknown;
+    try {
+      assertWasmFileSize("/p/a.wasm", MAX_WASM_FILE_BYTES + 1, wasmName);
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeInstanceOf(Error);
+    const msg = (err as Error).message;
+    expect(msg).toContain("/p/a.wasm");
+    expect(msg).toContain("@test/pkg:main");
+    expect(msg).toContain("wasm-opt -Oz");
+    // points the reader at the backend source-of-truth
+    expect(msg).toContain("assertions.go");
+  });
+});
+
+describe("assertTemplatePackSize", () => {
+  it("passes at exactly the cap", () => {
+    expect(() =>
+      assertTemplatePackSize("@t/pkg:main 1.0.0", MAX_TEMPLATE_PACK_BYTES_GZIPPED, []),
+    ).not.toThrow();
+  });
+
+  it("lists WASM contributions sorted by size (largest first)", () => {
+    let err: unknown;
+    try {
+      assertTemplatePackSize("@t/pkg:main 1.0.0", MAX_TEMPLATE_PACK_BYTES_GZIPPED + 1, [
+        { name: "@small/wasm:main", rawBytes: 100 * 1024 },
+        { name: "@big/wasm:main", rawBytes: 1.5 * 1024 * 1024 },
+        { name: "@mid/wasm:main", rawBytes: 800 * 1024 },
+      ]);
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeInstanceOf(Error);
+    const msg = (err as Error).message;
+    const big = msg.indexOf("@big/wasm:main");
+    const mid = msg.indexOf("@mid/wasm:main");
+    const small = msg.indexOf("@small/wasm:main");
+    // all three present
+    expect(big).toBeGreaterThan(-1);
+    expect(mid).toBeGreaterThan(-1);
+    expect(small).toBeGreaterThan(-1);
+    // ordered big > mid > small
+    expect(big).toBeLessThan(mid);
+    expect(mid).toBeLessThan(small);
+    expect(msg).toContain("@t/pkg:main 1.0.0");
+    expect(msg).toContain("config.go");
+  });
+
+  it("includes a fallback hint when no WASM artefacts contributed", () => {
+    let err: unknown;
+    try {
+      assertTemplatePackSize("@t/pkg:main 1.0.0", MAX_TEMPLATE_PACK_BYTES_GZIPPED + 1, []);
+    } catch (e) {
+      err = e;
+    }
+    expect((err as Error).message).toContain("no WASM artefacts");
+  });
+});
+
+describe("collectWasmContributions", () => {
+  // base64 length L → ~L * 3 / 4 raw bytes. Build a base64 string of the
+  // requested length so the test is independent of any specific WASM payload.
+  function base64OfLength(len: number): string {
+    return "A".repeat(len);
+  }
+
+  it("reports direct WASM dependencies with raw byte size derived from base64 length", () => {
+    const base64 = base64OfLength(400); // 400 base64 chars → 300 raw bytes
+    const tpl: CompiledTemplateV3 = {
+      type: "pl.tengo-template.v3",
+      hashToSource: { "hash-a": base64 },
+      template: {
+        name: "@t/pkg:main",
+        version: "1.0.0",
+        sourceHash: "tpl-hash",
+        libs: {},
+        templates: {},
+        software: {},
+        assets: {},
+        wasm: {
+          "@w/wasm:a": { name: "@w/wasm:a", version: "1.0.0", sourceHash: "hash-a" },
+        },
+      },
+    };
+    const got = collectWasmContributions(tpl);
+    expect(got).toEqual([{ name: "@w/wasm:a", rawBytes: 300 }]);
+  });
+
+  it("recurses into sub-templates and deduplicates by artefact name", () => {
+    const base64a = base64OfLength(800); // 600 raw
+    const base64b = base64OfLength(400); // 300 raw
+    const tpl: CompiledTemplateV3 = {
+      type: "pl.tengo-template.v3",
+      hashToSource: { "hash-a": base64a, "hash-b": base64b },
+      template: {
+        name: "@t/pkg:root",
+        version: "1.0.0",
+        sourceHash: "root-hash",
+        libs: {},
+        software: {},
+        assets: {},
+        wasm: {
+          "@w/wasm:a": { name: "@w/wasm:a", version: "1.0.0", sourceHash: "hash-a" },
+        },
+        templates: {
+          "@t/pkg:child": {
+            name: "@t/pkg:child",
+            version: "1.0.0",
+            sourceHash: "child-hash",
+            libs: {},
+            templates: {},
+            software: {},
+            assets: {},
+            wasm: {
+              // duplicate of the parent's WASM — must not be counted twice
+              "@w/wasm:a": { name: "@w/wasm:a", version: "1.0.0", sourceHash: "hash-a" },
+              "@w/wasm:b": { name: "@w/wasm:b", version: "1.0.0", sourceHash: "hash-b" },
+            },
+          },
+        },
+      },
+    };
+    const got = collectWasmContributions(tpl).sort((a, b) => a.name.localeCompare(b.name));
+    expect(got).toEqual([
+      { name: "@w/wasm:a", rawBytes: 600 },
+      { name: "@w/wasm:b", rawBytes: 300 },
+    ]);
+  });
+
+  it("returns an empty list when the template tree contains no WASM", () => {
+    const tpl: CompiledTemplateV3 = {
+      type: "pl.tengo-template.v3",
+      hashToSource: {},
+      template: {
+        name: "@t/pkg:main",
+        version: "1.0.0",
+        sourceHash: "tpl-hash",
+        libs: {},
+        templates: {},
+        software: {},
+        assets: {},
+      },
+    };
+    expect(collectWasmContributions(tpl)).toEqual([]);
+  });
+});

package/src/compiler/pack_limits.ts

@@ -0,0 +1,103 @@
+import type { CompiledTemplateV3, TemplateDataV3 } from "@milaboratories/pl-model-backend";
+
+import type { FullArtifactName } from "./package";
+import { fullNameToString } from "./package";
+
+// Build-time size guards mirroring the two backend caps that gate template
+// ingestion. Hardcoded because tengo-builder runs at block build time and has
+// no connection to a running backend; if pl ever changes the caps, update the
+// constants here in lockstep with the source-of-truth lines pointed at below.
+//
+// Source of truth (`core/pl` repo):
+//  - platform/core/transaction/assertions.go  : `maxResourceDataSize`
+//      3 MiB per value resource, checked on every CreateValue marshal.
+//      Hits the WasmV1 resource after the controller unpacks a template pack
+//      into its constituent libs/software/wasm resources.
+//  - controllers/workflow/pkg/cfg/config.go   : `TemplatePackSizeLimit`
+//      3.5 MiB per gzipped template pack, checked before the pack itself is
+//      stored as a TengoTemplatePackV1 value resource.
+
+// 2 MiB raw → ~2.67 MiB base64 + JSON wrapper → comfortably under the 3 MiB
+// per-value-resource cap with ~330 KiB headroom for the WasmV1Data wrapper
+// (Name, Version, Runtime, DefaultMemoryLimit, JSON syntax). WasmV1Data.Code
+// is a Go `[]byte`, which encoding/json serialises as base64 — that's where
+// the 4/3 expansion comes from.
+export const MAX_WASM_FILE_BYTES = 2 * 1024 * 1024;
+
+// 100 KiB below the backend's 3.5 MiB so blocks don't break on small
+// platform-side metadata overhead, or if pl tightens the limit slightly.
+export const MAX_TEMPLATE_PACK_BYTES_GZIPPED = 3.5 * 1024 * 1024 - 100 * 1024;
+
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KiB`;
+  return `${(n / 1024 / 1024).toFixed(2)} MiB`;
+}
+
+export function assertWasmFileSize(
+  file: string,
+  byteLength: number,
+  fullName: FullArtifactName,
+): void {
+  if (byteLength <= MAX_WASM_FILE_BYTES) return;
+  throw new Error(
+    `WASM artefact ${fullNameToString(fullName)} from ${file} is ${formatBytes(byteLength)}, ` +
+      `which exceeds tengo-builder's ${formatBytes(MAX_WASM_FILE_BYTES)} per-WASM cap. ` +
+      `The backend stores each WASM as a single value resource (3 MiB hard cap after base64+JSON ` +
+      `marshal — see maxResourceDataSize in pl: platform/core/transaction/assertions.go). ` +
+      `Strip debug info or run \`wasm-opt -Oz\` to shrink it.`,
+  );
+}
+
+export interface WasmContribution {
+  /** Artefact name as stored under TemplateDataV3.wasm (e.g. "@pkg:id"). */
+  readonly name: string;
+  /** Raw WASM bytes — decoded from the base64-encoded source in hashToSource. */
+  readonly rawBytes: number;
+}
+
+/**
+ * Walks a compiled template tree and reports every WASM artefact embedded
+ * directly or transitively. Used only by the too-large-pack error message —
+ * never on the success path. Deduplicates by artefact name (sub-templates can
+ * import the same WASM via different aliases and we want to attribute weight
+ * only once).
+ */
+export function collectWasmContributions(tpl: CompiledTemplateV3): WasmContribution[] {
+  const seen = new Map<string, WasmContribution>();
+  function walk(t: TemplateDataV3) {
+    for (const [name, ref] of Object.entries(t.wasm ?? {})) {
+      if (seen.has(name)) continue;
+      const base64 = tpl.hashToSource[ref.sourceHash];
+      // base64 encodes 3 raw bytes per 4 chars; the off-by-padding is at most
+      // 2 bytes per artefact — fine for a human-readable size breakdown.
+      const rawBytes = base64 != null ? Math.floor((base64.length * 3) / 4) : 0;
+      seen.set(name, { name, rawBytes });
+    }
+    for (const sub of Object.values(t.templates ?? {})) walk(sub);
+  }
+  walk(tpl.template);
+  return [...seen.values()];
+}
+
+export function assertTemplatePackSize(
+  templateName: string,
+  gzippedByteLength: number,
+  wasmContributions: readonly WasmContribution[],
+): void {
+  if (gzippedByteLength <= MAX_TEMPLATE_PACK_BYTES_GZIPPED) return;
+  const ranked = [...wasmContributions].sort((a, b) => b.rawBytes - a.rawBytes);
+  const breakdown =
+    ranked.length === 0
+      ? "\n  (no WASM artefacts in this pack — heavy libs, software descriptors, or sub-templates are the likely cause.)"
+      : "\nWASM artefacts in this pack (raw bytes):\n" +
+        ranked.map((w) => `  - ${w.name} — ${formatBytes(w.rawBytes)}`).join("\n");
+  throw new Error(
+    `Template pack ${templateName} is ${formatBytes(gzippedByteLength)} gzipped, ` +
+      `which exceeds tengo-builder's ${formatBytes(MAX_TEMPLATE_PACK_BYTES_GZIPPED)} per-pack cap. ` +
+      `The backend caps gzipped packs at 3.5 MiB (see TemplatePackSizeLimit in pl: ` +
+      `controllers/workflow/pkg/cfg/config.go).` +
+      breakdown +
+      "\nShrink WASM artefacts (wasm-opt -Oz), or split this template into smaller pieces.",
+  );
+}

package/src/compiler/package.ts

@@ -27,7 +27,7 @@ export type CompilerOption = {
   args: string[];
 };
 
-export type ArtifactType = "library" | "template" | "test" | "software" | "asset";
+export type ArtifactType = "library" | "template" | "test" | "software" | "asset" | "wasm";
 
 /** Artifact Name including package version */
 export interface FullArtifactName {

package/src/compiler/source.test.ts

@@ -126,6 +126,36 @@ describe("import statements", () => {
     const trickyCasesSrc = parseSource(logger, "dist", testTrickyCasesSrc, stubTplName, true);
     expect(trickyCasesSrc.src).toEqual(testTrickyCasesNormalized);
   });
+
+  test("assets.importWasm produces a wasm dependency", () => {
+    const logger = createLogger("error");
+
+    const wasmImport = `
+      assets := import("@platforma-sdk/workflow-tengo:assets")
+      wasm := assets.importWasm("@milaboratories/pframes-rs-wasip2:main")
+    `;
+
+    const parsed = parseSource(logger, "dist", wasmImport, stubTplName, true);
+    expect(parsed.dependencies).toContainEqual({
+      type: "wasm",
+      pkg: "@milaboratories/pframes-rs-wasip2",
+      id: "main",
+    });
+  });
+
+  test("assets.importWasm with variable id is rejected", () => {
+    const logger = createLogger("info");
+
+    const wasmByVar = `
+      assets := import("@platforma-sdk/workflow-tengo:assets")
+      wasmId := "@milaboratories/pframes-rs-wasip2:main"
+      wasm := assets.importWasm(wasmId)
+    `;
+
+    expect(() => parseSource(logger, "dist", wasmByVar, stubTplName, true)).toThrow(
+      "variables are not allowed",
+    );
+  });
 });
 
 describe("parseSingleSourceLine", () => {

package/src/compiler/source.ts

@@ -42,6 +42,8 @@ const newImportSoftwareDetector = (moduleName: string) =>
 const newImportAssetRE = (moduleName: string) => functionCallRE(moduleName, "importAsset");
 const newImportAssetDetector = (moduleName: string) =>
   functionCallLikeRE(moduleName, "importAsset");
+const newImportWasmRE = (moduleName: string) => functionCallRE(moduleName, "importWasm");
+const newImportWasmDetector = (moduleName: string) => functionCallLikeRE(moduleName, "importWasm");
 
 const emptyLineRE = /^\s*$/;
 const compilerOptionRE = /^\/\/tengo:[\w]/;
@@ -369,11 +371,13 @@ function processModuleImport(
         ["template", newImportTemplateRE(iInfo.alias)],
         ["software", newImportSoftwareRE(iInfo.alias)],
         ["asset", newImportAssetRE(iInfo.alias)],
+        ["wasm", newImportWasmRE(iInfo.alias)],
       ]);
       context.importLikeREs.set(iInfo.module, [
         ["template", newImportTemplateDetector(iInfo.alias)],
         ["software", newImportSoftwareDetector(iInfo.alias)],
         ["asset", newImportAssetDetector(iInfo.alias)],
+        ["wasm", newImportWasmDetector(iInfo.alias)],
       ]);
     }
   }

package/src/shared/basecmd.ts

@@ -31,7 +31,7 @@ export const ArtifactTypeFlag = {
   type: Flags.string({
     aliases: ["t"],
     description: "artifact type",
-    options: ["all", "library", "template", "test", "software", "asset"],
+    options: ["all", "library", "template", "test", "software", "asset", "wasm"],
     default: "all",
   }),
 };

package/src/shared/dump.ts

@@ -88,6 +88,15 @@ export function dumpArtifacts(
     }
   }
 
+  // Wasm
+
+  if (!aType || aType === "wasm") {
+    for (const wasm of compiler.allWasm()) {
+      logger.debug(`Dumping to pl-tester: ${typedArtifactNameToString(wasm.fullName)}`);
+      stream.write(JSON.stringify(wasm) + "\n");
+    }
+  }
+
   // Tests
 
   if (!aType || aType === "test") {