@assistant-ui/metro 0.0.7 → 0.0.10

package/dist/index.cjs

@@ -8,6 +8,11 @@ const require$1 = (0, require("node:module").createRequire)(require("url").pathT
 */
 const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
 /**
+* Env var carrying the `backendless` option to the transformer. Metro forks its
+* transform workers after `metro.config` is evaluated, so they inherit it.
+*/
+const BACKENDLESS_ENV = "AUI_METRO_BACKENDLESS";
+/**
 * Wraps a Metro (or Expo) config so assistant-ui `"use generative"` modules are
 * compiled. Such a file colocates a tool's schema, its `execute`, and its
 * `render` via {@link https://www.assistant-ui.com/docs/tools/defining-tools | defineToolkit}.
@@ -23,7 +28,10 @@ const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
 * const { getDefaultConfig } = require("expo/metro-config");
 * const { withAui } = require("@assistant-ui/metro");
 *
-* module.exports = withAui(getDefaultConfig(__dirname));
+* module.exports = withAui({
+*   ...getDefaultConfig(__dirname),
+*   aui: { backendless: true },
+* });
 * ```
 *
 * Authoring is identical to the web: a `"use generative"` file whose default
@@ -31,10 +39,12 @@ const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
 */
 function withAui(config) {
 	const self = require$1.resolve("@assistant-ui/metro/transformer");
+	const { aui, ...baseConfig } = config;
 	const upstream = config.transformer?.babelTransformerPath;
+	if (aui?.backendless) process.env[BACKENDLESS_ENV] = "1";
 	if (upstream && upstream !== self) process.env[UPSTREAM_TRANSFORMER_ENV] = upstream;
 	return {
-		...config,
+		...baseConfig,
 		transformer: {
 			...config.transformer,
 			babelTransformerPath: self
@@ -42,6 +52,7 @@ function withAui(config) {
 	};
 }
 //#endregion
+exports.BACKENDLESS_ENV = BACKENDLESS_ENV;
 exports.UPSTREAM_TRANSFORMER_ENV = UPSTREAM_TRANSFORMER_ENV;
 exports.withAui = withAui;
 

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["require"],"sources":["../src/index.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\n\nconst require = createRequire(import.meta.url);\n\n/**\n * The shape of a Metro / Expo config `withAui` accepts. Typed loosely so this\n * package needs no hard dependency on `metro` or `expo`; the input shape is\n * preserved and only `transformer.babelTransformerPath` is augmented.\n */\nexport type MetroConfigLike = {\n  transformer?:\n    | {\n        babelTransformerPath?: string | undefined;\n        [key: string]: unknown;\n      }\n    | undefined;\n  [key: string]: unknown;\n};\n\n/**\n * Env var the transformer reads to delegate to the project's existing\n * (Expo / React Native) babel transformer. Metro forks its transform workers\n * after `metro.config` is evaluated, so they inherit this value.\n */\nexport const UPSTREAM_TRANSFORMER_ENV = \"AUI_METRO_UPSTREAM_TRANSFORMER\";\n\n/**\n * Wraps a Metro (or Expo) config so assistant-ui `\"use generative\"` modules are\n * compiled. Such a file colocates a tool's schema, its `execute`, and its\n * `render` via {@link https://www.assistant-ui.com/docs/tools/defining-tools | defineToolkit}.\n *\n * It points Metro's `babelTransformerPath` at this package's transformer, which\n * runs the `\"use generative\"` compiler and then delegates to your project's\n * existing transformer. The device (client) build keeps each tool's `render`\n * and any frontend `execute`; a server build (an Expo Router `+api` route)\n * keeps a server `execute` instead.\n *\n * ```js\n * // metro.config.js\n * const { getDefaultConfig } = require(\"expo/metro-config\");\n * const { withAui } = require(\"@assistant-ui/metro\");\n *\n * module.exports = withAui(getDefaultConfig(__dirname));\n * ```\n *\n * Authoring is identical to the web: a `\"use generative\"` file whose default\n * export is `defineToolkit({ ... })`, registered with `Tools({ toolkit })`.\n */\nexport function withAui<T extends MetroConfigLike>(config: T): T {\n  const self = require.resolve(\"@assistant-ui/metro/transformer\");\n  const upstream = config.transformer?.babelTransformerPath;\n\n  // Guard against a double-wrap (`withAui(withAui(config))`, or a shared config\n  // already wrapped): if it already points at our transformer, keep the real\n  // upstream captured earlier rather than overwriting it with our own path,\n  // which would make `resolveUpstream()` return this transformer and recurse.\n  if (upstream && upstream !== self) {\n    process.env[UPSTREAM_TRANSFORMER_ENV] = upstream;\n  }\n\n  return {\n    ...config,\n    transformer: {\n      ...config.transformer,\n      babelTransformerPath: self,\n    },\n  };\n}\n"],"mappings":";;AAEA,MAAMA,aAAAA,wBAAAA,CAAAA,CAAAA,cAAAA,CAAAA,QAAAA,KAAAA,CAAAA,CAAAA,cAAAA,UAAAA,CAAAA,CAAAA,IAAuC;;;;;;AAsB7C,MAAa,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;AAwBxC,SAAgB,QAAmC,QAAc;CAC/D,MAAM,OAAOA,UAAQ,QAAQ,iCAAiC;CAC9D,MAAM,WAAW,OAAO,aAAa;CAMrC,IAAI,YAAY,aAAa,MAC3B,QAAQ,IAAI,4BAA4B;CAG1C,OAAO;EACL,GAAG;EACH,aAAa;GACX,GAAG,OAAO;GACV,sBAAsB;EACxB;CACF;AACF"}
+{"version":3,"file":"index.cjs","names":["require","createRequire"],"sources":["../src/index.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\n\nconst require = createRequire(import.meta.url);\n\n/**\n * The shape of a Metro / Expo config `withAui` accepts. Typed loosely so this\n * package needs no hard dependency on `metro` or `expo`; the input shape is\n * preserved and only `transformer.babelTransformerPath` is augmented.\n */\nexport type MetroConfigLike = {\n  /** assistant-ui options, stripped from the config handed back to Metro. */\n  aui?: WithAuiOptions | undefined;\n  transformer?:\n    | {\n        babelTransformerPath?: string | undefined;\n        [key: string]: unknown;\n      }\n    | undefined;\n  [key: string]: unknown;\n};\n\n/**\n * Env var the transformer reads to delegate to the project's existing\n * (Expo / React Native) babel transformer. Metro forks its transform workers\n * after `metro.config` is evaluated, so they inherit this value.\n */\nexport const UPSTREAM_TRANSFORMER_ENV = \"AUI_METRO_UPSTREAM_TRANSFORMER\";\n\n/**\n * Env var carrying the `backendless` option to the transformer. Metro forks its\n * transform workers after `metro.config` is evaluated, so they inherit it.\n */\nexport const BACKENDLESS_ENV = \"AUI_METRO_BACKENDLESS\";\n\nexport interface WithAuiOptions {\n  /**\n   * The app has no backend importing the server builds of its `\"use generative\"`\n   * modules (e.g. cloud-hosted runs). Frontend/human tool schemas then stay\n   * uploadable from the client instead of being assumed backend-known.\n   */\n  backendless?: boolean;\n}\n\n/**\n * Wraps a Metro (or Expo) config so assistant-ui `\"use generative\"` modules are\n * compiled. Such a file colocates a tool's schema, its `execute`, and its\n * `render` via {@link https://www.assistant-ui.com/docs/tools/defining-tools | defineToolkit}.\n *\n * It points Metro's `babelTransformerPath` at this package's transformer, which\n * runs the `\"use generative\"` compiler and then delegates to your project's\n * existing transformer. The device (client) build keeps each tool's `render`\n * and any frontend `execute`; a server build (an Expo Router `+api` route)\n * keeps a server `execute` instead.\n *\n * ```js\n * // metro.config.js\n * const { getDefaultConfig } = require(\"expo/metro-config\");\n * const { withAui } = require(\"@assistant-ui/metro\");\n *\n * module.exports = withAui({\n *   ...getDefaultConfig(__dirname),\n *   aui: { backendless: true },\n * });\n * ```\n *\n * Authoring is identical to the web: a `\"use generative\"` file whose default\n * export is `defineToolkit({ ... })`, registered with `Tools({ toolkit })`.\n */\nexport function withAui<T extends MetroConfigLike>(config: T): T {\n  const self = require.resolve(\"@assistant-ui/metro/transformer\");\n  // Metro validates config keys it does not recognize, so `aui` must not\n  // survive into the returned config.\n  const { aui, ...baseConfig } = config;\n  const upstream = config.transformer?.babelTransformerPath;\n\n  if (aui?.backendless) process.env[BACKENDLESS_ENV] = \"1\";\n\n  // Guard against a double-wrap (`withAui(withAui(config))`, or a shared config\n  // already wrapped): if it already points at our transformer, keep the real\n  // upstream captured earlier rather than overwriting it with our own path,\n  // which would make `resolveUpstream()` return this transformer and recurse.\n  if (upstream && upstream !== self) {\n    process.env[UPSTREAM_TRANSFORMER_ENV] = upstream;\n  }\n\n  return {\n    ...baseConfig,\n    transformer: {\n      ...config.transformer,\n      babelTransformerPath: self,\n    },\n  } as T;\n}\n"],"mappings":";;AAEA,MAAMA,aAAAA,wBAAUC,CAAAA,CAAAA,cAAAA,CAAAA,QAAAA,KAAAA,CAAAA,CAAAA,cAAAA,UAAAA,CAAAA,CAAAA,IAA6B;;;;;;AAwB7C,MAAa,2BAA2B;;;;;AAMxC,MAAa,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;AAoC/B,SAAgB,QAAmC,QAAc;CAC/D,MAAM,OAAOD,UAAQ,QAAQ,iCAAiC;CAG9D,MAAM,EAAE,KAAK,GAAG,eAAe;CAC/B,MAAM,WAAW,OAAO,aAAa;CAErC,IAAI,KAAK,aAAa,QAAQ,IAAI,mBAAmB;CAMrD,IAAI,YAAY,aAAa,MAC3B,QAAQ,IAAI,4BAA4B;CAG1C,OAAO;EACL,GAAG;EACH,aAAa;GACX,GAAG,OAAO;GACV,sBAAsB;EACxB;CACF;AACF"}

package/dist/index.d.cts

@@ -5,6 +5,8 @@
  * preserved and only `transformer.babelTransformerPath` is augmented.
  */
 type MetroConfigLike = {
+  /** assistant-ui options, stripped from the config handed back to Metro. */
+  aui?: WithAuiOptions | undefined;
   transformer?: {
     babelTransformerPath?: string | undefined;
     [key: string]: unknown;
@@ -17,6 +19,19 @@ type MetroConfigLike = {
  * after `metro.config` is evaluated, so they inherit this value.
  */
 declare const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
+/**
+ * Env var carrying the `backendless` option to the transformer. Metro forks its
+ * transform workers after `metro.config` is evaluated, so they inherit it.
+ */
+declare const BACKENDLESS_ENV = "AUI_METRO_BACKENDLESS";
+interface WithAuiOptions {
+  /**
+   * The app has no backend importing the server builds of its `"use generative"`
+   * modules (e.g. cloud-hosted runs). Frontend/human tool schemas then stay
+   * uploadable from the client instead of being assumed backend-known.
+   */
+  backendless?: boolean;
+}
 /**
  * Wraps a Metro (or Expo) config so assistant-ui `"use generative"` modules are
  * compiled. Such a file colocates a tool's schema, its `execute`, and its
@@ -33,7 +48,10 @@ declare const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
  * const { getDefaultConfig } = require("expo/metro-config");
  * const { withAui } = require("@assistant-ui/metro");
  *
- * module.exports = withAui(getDefaultConfig(__dirname));
+ * module.exports = withAui({
+ *   ...getDefaultConfig(__dirname),
+ *   aui: { backendless: true },
+ * });
  * ```
  *
  * Authoring is identical to the web: a `"use generative"` file whose default
@@ -41,5 +59,5 @@ declare const UPSTREAM_TRANSFORMER_ENV = "AUI_METRO_UPSTREAM_TRANSFORMER";
  */
 declare function withAui<T extends MetroConfigLike>(config: T): T;
 //#endregion
-export { MetroConfigLike, UPSTREAM_TRANSFORMER_ENV, withAui };
+export { BACKENDLESS_ENV, MetroConfigLike, UPSTREAM_TRANSFORMER_ENV, WithAuiOptions, withAui };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;KASY;EACV;IAEM;KACC;;GAGN;;;;;;;cAQU;;;;;;;;;;;;;;;;;;;;;;;iBAwBG,QAAQ,UAAU,iBAAiB,QAAQ,IAAI"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;KASY;;EAEV,MAAM;EACN;IAEM;KACC;;GAGN;;;;;;;cAQU;;;;;cAMA;UAEI;;;;;;EAMf;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4Bc,QAAQ,UAAU,iBAAiB,QAAQ,IAAI"}

package/dist/transformer.cjs

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -40,18 +40,16 @@ _babel_types = __toESM(_babel_types, 1);
 const DIRECTIVE = "use generative";
 //#endregion
 //#region ../x-generative-compiler/dist/package.js
-var version = "0.0.11";
+var version = "0.0.14";
 //#endregion
 //#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const SEMVER_SPEC_VERSION = "2.0.0";
-	const MAX_LENGTH = 256;
-	const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
 	module.exports = {
-		MAX_LENGTH,
+		MAX_LENGTH: 256,
 		MAX_SAFE_COMPONENT_LENGTH: 16,
-		MAX_SAFE_BUILD_LENGTH: MAX_LENGTH - 6,
-		MAX_SAFE_INTEGER,
+		MAX_SAFE_BUILD_LENGTH: 250,
+		MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER || 
+		/* istanbul ignore next */ 9007199254740991,
 		RELEASE_TYPES: [
 			"major",
 			"premajor",
@@ -61,7 +59,7 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			"prepatch",
 			"prerelease"
 		],
-		SEMVER_SPEC_VERSION,
+		SEMVER_SPEC_VERSION: "2.0.0",
 		FLAG_INCLUDE_PRERELEASE: 1,
 		FLAG_LOOSE: 2
 	};
@@ -199,9 +197,10 @@ var require_semver$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = class SemVer {
 		constructor(version, options) {
 			options = parseOptions(options);
-			if (version instanceof SemVer) if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
-			else version = version.version;
-			else if (typeof version !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+			if (version instanceof SemVer) {
+				if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
+				else version = version.version;
+			} else if (typeof version !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
 			if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
 			debug("SemVer", version, options);
 			this.options = options;
@@ -654,9 +653,7 @@ var require_truncate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				version.minor = 0;
 				version.patch = 0;
 				break;
-			case "minor":
-				version.patch = 0;
-				break;
+			case "minor": version.patch = 0;
 		}
 		return version.format();
 	};
@@ -705,8 +702,10 @@ var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = class Range {
 		constructor(range, options) {
 			options = parseOptions(options);
-			if (range instanceof Range) if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
-			else return new Range(range.raw, options);
+			if (range instanceof Range) {
+				if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
+				else return new Range(range.raw, options);
+			}
 			if (range instanceof Comparator) {
 				this.raw = range.value;
 				this.set = [[range]];
@@ -876,18 +875,21 @@ var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			let ret;
 			if (isX(M)) ret = "";
 			else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
-			else if (isX(p)) if (M === "0") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
-			else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
-			else if (pr) {
+			else if (isX(p)) {
+				if (M === "0") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+				else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+			} else if (pr) {
 				debug("replaceCaret pr", pr);
-				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
-				else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
-				else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+				if (M === "0") {
+					if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+					else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+				} else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
 			} else {
 				debug("no pr");
-				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
-				else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
-				else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+				if (M === "0") {
+					if (m === "0") ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
+					else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+				} else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
 			}
 			debug("caret return", ret);
 			return ret;
@@ -909,9 +911,10 @@ var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const anyX = xp;
 			if (gtlt === "=" && anyX) gtlt = "";
 			pr = options.includePrerelease ? "-0" : "";
-			if (xM) if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
-			else ret = "*";
-			else if (gtlt && anyX) {
+			if (xM) {
+				if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
+				else ret = "*";
+			} else if (gtlt && anyX) {
 				if (xm) m = 0;
 				p = 0;
 				if (gtlt === ">") {
@@ -985,8 +988,10 @@ var require_comparator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		constructor(comp, options) {
 			options = parseOptions(options);
-			if (comp instanceof Comparator) if (comp.loose === !!options.loose) return comp;
-			else comp = comp.value;
+			if (comp instanceof Comparator) {
+				if (comp.loose === !!options.loose) return comp;
+				else comp = comp.value;
+			}
 			comp = comp.trim().split(/\s+/).join(" ");
 			debug("comparator", comp, options);
 			this.options = options;
@@ -1306,11 +1311,15 @@ var require_subset = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const minimumVersion = [new Comparator(">=0.0.0")];
 	const simpleSubset = (sub, dom, options) => {
 		if (sub === dom) return true;
-		if (sub.length === 1 && sub[0].semver === ANY) if (dom.length === 1 && dom[0].semver === ANY) return true;
-		else if (options.includePrerelease) sub = minimumVersionWithPreRelease;
-		else sub = minimumVersion;
-		if (dom.length === 1 && dom[0].semver === ANY) if (options.includePrerelease) return true;
-		else dom = minimumVersion;
+		if (sub.length === 1 && sub[0].semver === ANY) {
+			if (dom.length === 1 && dom[0].semver === ANY) return true;
+			else if (options.includePrerelease) sub = minimumVersionWithPreRelease;
+			else sub = minimumVersion;
+		}
+		if (dom.length === 1 && dom[0].semver === ANY) {
+			if (options.includePrerelease) return true;
+			else dom = minimumVersion;
+		}
 		const eqSet = /* @__PURE__ */ new Set();
 		let gt, lt;
 		for (const c of sub) if (c.operator === ">" || c.operator === ">=") gt = higherGT(gt, c, options);
@@ -1581,6 +1590,7 @@ function isLineTerminator(char) {
 */
 function compileGenerative(code, options) {
 	const { target, filename } = options;
+	const backendless = options.backendless ?? false;
 	const ast = (0, _babel_parser.parse)(code, {
 		sourceType: "module",
 		plugins: parserPlugins
@@ -1607,7 +1617,7 @@ function compileGenerative(code, options) {
 		}
 		if (_babel_types.isIdentifier(callee, { name: TOOLKIT_WRAPPER })) {
 			if (!object) throw new GenerativeCompileError(`${TOOLKIT_WRAPPER}() takes an inline object literal of tools`, filename);
-			compileToolkit(object, target, generativeInstances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, filename);
+			compileToolkit(object, target, generativeInstances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, backendless, filename);
 			path.replaceWith(object);
 			path.skip();
 		}
@@ -1768,6 +1778,15 @@ function collectGenerativeInstances(ast) {
 	}
 	return names;
 }
+/**
+* Wraps a pass-through generative entry (`generative.present()`) so the tool it
+* returns loses its `unstable_backendDefault` marker. The library stamps the
+* marker at runtime, out of this compiler's reach, so a backendless client
+* build strips it post-hoc instead of threading an option into the library.
+*/
+function stripBackendDefaultExpression(expr) {
+	return _babel_types.callExpression(_babel_types.arrowFunctionExpression([_babel_types.objectPattern([_babel_types.objectProperty(_babel_types.identifier("unstable_backendDefault"), _babel_types.identifier("_backendDefault")), _babel_types.restElement(_babel_types.identifier("tool"))])], _babel_types.identifier("tool")), [expr]);
+}
 function collectGenerativeFactoryImports(ast) {
 	const names = /* @__PURE__ */ new Set();
 	for (const statement of ast.program.body) {
@@ -2182,7 +2201,7 @@ function compileComponents(object, target, flags, filename) {
 * `generative.present()` passes through, the library having already split it.
 * Mutates the object in place and records outcomes in {@link TargetFlags}.
 */
-function compileToolkit(object, target, instances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, filename) {
+function compileToolkit(object, target, instances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, backendless, filename) {
 	if (target === "client") warnDuplicateToolkitNames(object, toolkitSpreadNames, filename);
 	const nextProperties = [];
 	for (const entry of object.properties) {
@@ -2194,6 +2213,7 @@ function compileToolkit(object, target, instances, interactableToolImports, tool
 			}
 			const raw = entryRawValue(entry);
 			if (raw && isGenerativeToolEntry(raw, instances)) {
+				if (backendless && target === "client" && _babel_types.isObjectProperty(entry)) entry.value = stripBackendDefaultExpression(raw);
 				nextProperties.push(entry);
 				continue;
 			}
@@ -2232,11 +2252,13 @@ function compileToolkit(object, target, instances, interactableToolImports, tool
 		} else {
 			if (hasRender) removeMember(value, "render");
 			if (hasRenderText) removeMember(value, "renderText");
-			if (execute) if (type === "backend" && !isExternal) flags.keptBackendExecute = true;
-			else removeMember(value, "execute");
+			if (execute) {
+				if (type === "backend" && !isExternal) flags.keptBackendExecute = true;
+				else removeMember(value, "execute");
+			}
 		}
 		setToolType(value, type);
-		setBackendDefault(value, target, type);
+		setBackendDefault(value, target, type, backendless);
 		nextProperties.push(entry);
 	}
 	object.properties = nextProperties;
@@ -2347,8 +2369,9 @@ function setToolType(object, type) {
 	removeMember(object, "type");
 	object.properties.push(_babel_types.objectProperty(_babel_types.identifier("type"), _babel_types.stringLiteral(type)));
 }
-function setBackendDefault(object, target, type) {
+function setBackendDefault(object, target, type, backendless) {
 	removeMember(object, "unstable_backendDefault");
+	if (backendless) return;
 	if (target !== "client" || type !== "frontend" && type !== "human") return;
 	object.properties.push(_babel_types.objectProperty(_babel_types.identifier("unstable_backendDefault"), _babel_types.objectExpression([_babel_types.objectProperty(_babel_types.identifier("parameters"), _babel_types.booleanLiteral(true))])));
 }
@@ -2462,7 +2485,8 @@ function transform(props) {
 		const { code } = compileGenerative(src, {
 			target: isServerEnvironment(options?.customTransformOptions?.environment) ? "server" : "client",
 			filename,
-			injectServerOnly: false
+			injectServerOnly: false,
+			backendless: process.env[require_index.BACKENDLESS_ENV] === "1"
 		});
 		return upstream.transform({
 			...props,
@@ -2483,7 +2507,9 @@ function selfCacheToken() {
 }
 function getCacheKey() {
 	const upstream = upstreamTransformer();
-	return `${upstream.getCacheKey ? upstream.getCacheKey() : ""}$aui-metro:${selfCacheToken()}`;
+	const base = upstream.getCacheKey ? upstream.getCacheKey() : "";
+	const backendless = process.env["AUI_METRO_BACKENDLESS"] === "1" ? ":backendless" : "";
+	return `${base}$aui-metro:${selfCacheToken()}${backendless}`;
 }
 //#endregion
 exports.getCacheKey = getCacheKey;