@vention/vention-cli 0.36.5 → 0.37.0

package/main.esm.js

@@ -4150,7 +4150,7 @@ $$y({ global: true, forced: globalThis$r.globalThis !== globalThis$r }, {
   globalThis: globalThis$r
 });
 
-var version = "0.36.5";
+var version = "0.37.0";
 var packageJson$1 = {
 	version: version};
 
@@ -4186,6 +4186,263 @@ $$x({ target: 'Iterator', proto: true, real: true, forced: forEachWithoutClosing
   }
 });
 
+//#region src/bearer-strategy.ts
+var BearerStrategy = class {
+	lastSent;
+	lastRecoveryAt;
+	now;
+	cooldownMs;
+	exchange;
+	constructor(options) {
+		this.now = options.now ?? Date.now;
+		this.cooldownMs = options.cooldownMs ?? 5e3;
+		this.exchange = options.exchange;
+	}
+	/** @inheritDoc */
+	async attach(request) {
+		const token = await this.exchange();
+		this.lastSent = token;
+		const headers = new Headers(request.headers);
+		headers.set("Authorization", `Bearer ${token}`);
+		return new Request(request, { headers });
+	}
+	/** @inheritDoc */
+	async ensure() {
+		await this.exchange();
+	}
+	/** @inheritDoc */
+	async onUnauthorized(_response) {
+		if (this.recoveredRecently()) return false;
+		await this.exchange({ refused: this.lastSent });
+		this.lastRecoveryAt = this.now();
+		return true;
+	}
+	recoveredRecently() {
+		return this.lastRecoveryAt !== void 0 && this.now() - this.lastRecoveryAt < this.cooldownMs;
+	}
+};
+
+//#region src/single-flight.ts
+/**
+* Shares one in-flight call. While a call is running, further callers get its promise instead
+* of starting their own; once it settles, the next caller starts a new one.
+*/
+function singleFlight(fn) {
+	let inFlight;
+	return (...args) => {
+		if (inFlight) return inFlight;
+		inFlight = fn(...args).finally(() => {
+			inFlight = void 0;
+		});
+		return inFlight;
+	};
+}
+
+//#region src/tracked.ts
+/** Wraps an async function, counting settled calls and remembering how the last one settled. */
+function tracked(fn) {
+	let completed = 0;
+	let last;
+	async function call(...args) {
+		try {
+			const value = await fn(...args);
+			last = {
+				settled: "fulfilled",
+				value
+			};
+			return value;
+		} catch (reason) {
+			last = {
+				settled: "rejected",
+				reason
+			};
+			throw reason;
+		} finally {
+			completed += 1;
+		}
+	}
+	return {
+		call,
+		getCompleted: () => completed,
+		getLast: () => last
+	};
+}
+
+//#region src/with-auth-strategy.ts
+/** Sends a clone of the request through the strategy's `attach`, leaving the original replayable. */
+async function fetchWithAuth(authStrategy, fetch, request) {
+	const clonedRequest = request.clone();
+	return fetch(await authStrategy.attach(clonedRequest));
+}
+/** A 401 that lands after a recovery finished takes that recovery's decision: its error, or its verdict. */
+function inheritRecovery(outcome) {
+	if (outcome?.settled === "rejected") throw outcome.reason;
+	return outcome?.value ?? true;
+}
+/** A fetch that attaches through the strategy, and on a 401 recovers once and retries once. */
+function withAuthStrategy(authStrategy, fetch = globalThis.fetch) {
+	const { call: recover, getCompleted: getRecoveryCount, getLast: getLastRecovery } = tracked((response) => authStrategy.onUnauthorized(response));
+	const tryRecover = singleFlight(recover);
+	return async (input, init) => {
+		const request = new Request(input, init);
+		const startRecoveryCount = getRecoveryCount();
+		const response = await fetchWithAuth(authStrategy, fetch, request);
+		if (response.status !== 401) return response;
+		if (getRecoveryCount() > startRecoveryCount ? inheritRecovery(getLastRecovery()) : await tryRecover(response)) return fetchWithAuth(authStrategy, fetch, request);
+		return response;
+	};
+}
+
+//#region src/errors/authorization-server-unavailable.ts
+var AuthorizationServerUnavailable = class extends Error {
+	name = "AuthorizationServerUnavailable";
+};
+
+//#region src/discovery.ts
+const REQUEST_TIMEOUT_MS$2 = 1e4;
+async function discoverAuthorizationServer(issuer, fetch = globalThis.fetch) {
+	const metadata = await readMetadata(`${issuer}/.well-known/oauth-authorization-server`, fetch);
+	return {
+		tokenEndpoint: metadata.token_endpoint,
+		identityProviderIssuer: metadata.vention_identity_provider_issuer,
+		clients: metadata.vention_clients
+	};
+}
+async function discoverOpenIdProvider(issuer, fetch = globalThis.fetch) {
+	const url = `${issuer}/.well-known/openid-configuration`;
+	const metadata = await readMetadata(url, fetch);
+	if (metadata.issuer !== issuer) throw new AuthorizationServerUnavailable(`${url} names the issuer ${metadata.issuer}, not ${issuer}`);
+	return {
+		authorizationEndpoint: metadata.authorization_endpoint,
+		tokenEndpoint: metadata.token_endpoint
+	};
+}
+async function readMetadata(url, fetch) {
+	const response = await fetch(url, {
+		headers: { Accept: "application/json" },
+		redirect: "error",
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS$2)
+	}).catch((error) => {
+		throw new AuthorizationServerUnavailable(`Could not reach ${url}`, { cause: error });
+	});
+	if (!response.ok) throw new AuthorizationServerUnavailable(`${url} answered ${response.status}`);
+	return response.json().catch((error) => {
+		throw new AuthorizationServerUnavailable(`${url} did not answer with JSON`, { cause: error });
+	});
+}
+
+//#region src/errors/exchange-rejected.ts
+var ExchangeRejected = class extends Error {
+	code;
+	name = "ExchangeRejected";
+	constructor(code) {
+		super(`The authorization server refused the token exchange (${code})`);
+		this.code = code;
+	}
+};
+
+//#region src/errors/login-required.ts
+var LoginRequired = class extends Error {
+	name = "LoginRequired";
+};
+
+//#region src/errors/login-timed-out.ts
+var LoginTimedOut = class extends Error {
+	name = "LoginTimedOut";
+	constructor() {
+		super("Login timed out");
+	}
+};
+
+//#region src/oauth2-token-request.ts
+const REQUEST_TIMEOUT_MS$1 = 1e4;
+function exchangeForGatewayToken(tokenEndpoint, subjectToken, fetch, now) {
+	return requestToken(tokenEndpoint, subjectToken, "urn:ietf:params:oauth:token-type:access_token", fetch, now);
+}
+function renewGatewayToken(tokenEndpoint, gatewayToken, fetch, now) {
+	return requestToken(tokenEndpoint, gatewayToken, "urn:ietf:params:oauth:token-type:jwt", fetch, now);
+}
+async function requestToken(tokenEndpoint, subjectToken, subjectTokenType, fetch, now) {
+	const response = await fetch(tokenEndpoint, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			Accept: "application/json"
+		},
+		body: new URLSearchParams({
+			grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
+			subject_token: subjectToken,
+			subject_token_type: subjectTokenType
+		}),
+		redirect: "error",
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS$1)
+	}).catch((error) => {
+		throw new AuthorizationServerUnavailable("The authorization server could not be reached", { cause: error });
+	});
+	if (response.status >= 500 || response.status === 408 || response.status === 429) throw new AuthorizationServerUnavailable(`The authorization server answered ${response.status}`);
+	if (!response.ok) {
+		const refusal = await response.json().catch(() => void 0);
+		throw new ExchangeRejected(refusal?.error ?? `http_${response.status}`);
+	}
+	return response.json().then((body) => toStoredGatewayToken(body, now())).catch(() => {
+		throw new AuthorizationServerUnavailable("The authorization server returned an unusable token response");
+	});
+}
+function toStoredGatewayToken({ access_token: token, expires_in: expiresIn }, receivedAt) {
+	const payload = (token.split(".")[1] ?? "").replace(/-/g, "+").replace(/_/g, "/");
+	const claims = JSON.parse(atob(payload));
+	return {
+		token,
+		receivedAt,
+		expiresAt: receivedAt + expiresIn * 1e3,
+		capExpiresAt: receivedAt + (claims.cap_exp - claims.exp + expiresIn) * 1e3
+	};
+}
+
+//#region src/oauth2-token-exchange.ts
+function loginRequired() {
+	return new LoginRequired("Session expired. Run 'vention login'.");
+}
+function outlivesMargin(expiresAt, now) {
+	return expiresAt - now > 6e4;
+}
+function isFresh(token, now) {
+	const halfLife = (token.expiresAt - token.receivedAt) / 2;
+	return now - token.receivedAt < halfLife && outlivesMargin(token.expiresAt, now);
+}
+function oauth2TokenExchange({ issuer, store, now = Date.now, fetch = globalThis.fetch }) {
+	const storedToken = async () => {
+		const latest = await store.read();
+		if (latest === void 0) throw loginRequired();
+		return latest.token;
+	};
+	const renew = singleFlight(async (current) => {
+		const beforeRenewal = await storedToken();
+		if (beforeRenewal !== current.token) return beforeRenewal;
+		const { tokenEndpoint } = await discoverAuthorizationServer(issuer, fetch);
+		const renewed = await renewGatewayToken(tokenEndpoint, current.token, fetch, now).catch((error) => {
+			throw error instanceof ExchangeRejected ? loginRequired() : error;
+		});
+		if (!outlivesMargin(renewed.expiresAt, now())) throw loginRequired();
+		const beforeWrite = await storedToken();
+		if (beforeWrite !== current.token) return beforeWrite;
+		await store.write(renewed);
+		return renewed.token;
+	});
+	return async (request) => {
+		const current = await store.read();
+		if (current === void 0 || now() >= current.capExpiresAt) throw loginRequired();
+		const currentRefused = request?.refused === current.token;
+		if (!currentRefused && isFresh(current, now())) return current.token;
+		const token = await renew(current).catch((error) => {
+			if (error instanceof AuthorizationServerUnavailable && !currentRefused && outlivesMargin(current.expiresAt, now())) return current.token;
+			throw error;
+		});
+		if (token === request?.refused) throw loginRequired();
+		return token;
+	};
+}
+
 class ApiError extends Error {
   constructor(message, status, statusText, responseBody, url) {
     super(message);
@@ -4268,6 +4525,8 @@ const handleCommandError = (error, context) => {
       console.error();
       suggestions.forEach(msg => console.error(chalk.yellow(msg)));
     }
+  } else if (error instanceof LoginRequired) {
+    console.error(chalk.red(error.message));
   } else {
     console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
   }
@@ -4303,7 +4562,7 @@ const POSTHOG_PROJECT_TOKENS = {
 };
 const POSTHOG_FLAGS_URL = "https://us.i.posthog.com/flags?v=2";
 const CACHE_TTL_MS = 15 * 60 * 1000;
-const REQUEST_TIMEOUT_MS$2 = 2000;
+const REQUEST_TIMEOUT_MS = 2000;
 const FlagsResponseSchema = z.object({
   flags: z.record(z.string(), z.object({
     enabled: z.boolean()
@@ -4365,7 +4624,7 @@ const fetchFlags = async (projectToken, distinctId) => {
         api_key: projectToken,
         distinct_id: distinctId
       }),
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS$2)
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
     });
     if (!response.ok) {
       return undefined;
@@ -4910,11 +5169,11 @@ var getInternalIteratorState = InternalStateModule$4.getterFor(URL_SEARCH_PARAMS
 
 var nativeFetch = safeGetBuiltIn('fetch');
 var NativeRequest = safeGetBuiltIn('Request');
-var Headers = safeGetBuiltIn('Headers');
+var Headers$1 = safeGetBuiltIn('Headers');
 var RequestPrototype = NativeRequest && NativeRequest.prototype;
-var HeadersPrototype = Headers && Headers.prototype;
+var HeadersPrototype = Headers$1 && Headers$1.prototype;
 var TypeError$5 = globalThis$q.TypeError;
-var encodeURIComponent$1 = globalThis$q.encodeURIComponent;
+var encodeURIComponent$2 = globalThis$q.encodeURIComponent;
 var fromCharCode = String.fromCharCode;
 var fromCodePoint = getBuiltIn$1('String', 'fromCodePoint');
 var $parseInt = parseInt;
@@ -5079,7 +5338,7 @@ var replacer = function (match) {
 };
 
 var serialize = function (it) {
-  return replace$5(encodeURIComponent$1(it), find, replacer);
+  return replace$5(encodeURIComponent$2(it), find, replacer);
 };
 
 var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
@@ -5344,7 +5603,7 @@ $$v({ global: true, constructor: true, forced: !USE_NATIVE_URL$1 }, {
 });
 
 // Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams`
-if (!USE_NATIVE_URL$1 && isCallable$4(Headers)) {
+if (!USE_NATIVE_URL$1 && isCallable$4(Headers$1)) {
   var headersHas = uncurryThis$p(HeadersPrototype.has);
   var headersSet = uncurryThis$p(HeadersPrototype.set);
 
@@ -5353,7 +5612,7 @@ if (!USE_NATIVE_URL$1 && isCallable$4(Headers)) {
       var body = init.body;
       var headers;
       if (classof$8(body) === URL_SEARCH_PARAMS) {
-        headers = init.headers ? new Headers(init.headers) : new Headers();
+        headers = init.headers ? new Headers$1(init.headers) : new Headers$1();
         if (!headersHas(headers, 'content-type')) {
           headersSet(headers, 'content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
         }
@@ -5423,7 +5682,7 @@ var getInternalSearchParamsState = URLSearchParamsModule.getState;
 
 var NativeURL = globalThis$p.URL;
 var TypeError$4 = globalThis$p.TypeError;
-var encodeURIComponent = globalThis$p.encodeURIComponent;
+var encodeURIComponent$1 = globalThis$p.encodeURIComponent;
 var parseInt$1 = globalThis$p.parseInt;
 var floor$5 = Math.floor;
 var pow$1 = Math.pow;
@@ -5673,7 +5932,7 @@ var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {
 var percentEncode = function (chr, set) {
   var code = codeAt(chr, 0);
   // encodeURIComponent does not encode ', which is in the special-query percent-encode set
-  return code >= 0x20 && code < 0x7F && !hasOwn$4(set, chr) ? chr : chr === "'" && hasOwn$4(set, chr) ? '%27' : encodeURIComponent(chr);
+  return code >= 0x20 && code < 0x7F && !hasOwn$4(set, chr) ? chr : chr === "'" && hasOwn$4(set, chr) ? '%27' : encodeURIComponent$1(chr);
 };
 
 // https://url.spec.whatwg.org/#special-scheme
@@ -6851,104 +7110,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-//#region src/errors/authorization-server-unavailable.ts
-var AuthorizationServerUnavailable = class extends Error {
-	name = "AuthorizationServerUnavailable";
-};
-
-//#region src/discovery.ts
-const REQUEST_TIMEOUT_MS$1 = 1e4;
-async function discoverAuthorizationServer(issuer, fetch = globalThis.fetch) {
-	const metadata = await readMetadata(`${issuer}/.well-known/oauth-authorization-server`, fetch);
-	return {
-		tokenEndpoint: metadata.token_endpoint,
-		identityProviderIssuer: metadata.vention_identity_provider_issuer,
-		clients: metadata.vention_clients
-	};
-}
-async function discoverOpenIdProvider(issuer, fetch = globalThis.fetch) {
-	const url = `${issuer}/.well-known/openid-configuration`;
-	const metadata = await readMetadata(url, fetch);
-	if (metadata.issuer !== issuer) throw new AuthorizationServerUnavailable(`${url} names the issuer ${metadata.issuer}, not ${issuer}`);
-	return {
-		authorizationEndpoint: metadata.authorization_endpoint,
-		tokenEndpoint: metadata.token_endpoint
-	};
-}
-async function readMetadata(url, fetch) {
-	const response = await fetch(url, {
-		headers: { Accept: "application/json" },
-		redirect: "error",
-		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS$1)
-	}).catch((error) => {
-		throw new AuthorizationServerUnavailable(`Could not reach ${url}`, { cause: error });
-	});
-	if (!response.ok) throw new AuthorizationServerUnavailable(`${url} answered ${response.status}`);
-	return response.json().catch((error) => {
-		throw new AuthorizationServerUnavailable(`${url} did not answer with JSON`, { cause: error });
-	});
-}
-
-//#region src/errors/exchange-rejected.ts
-var ExchangeRejected = class extends Error {
-	code;
-	name = "ExchangeRejected";
-	constructor(code) {
-		super(`The authorization server refused the token exchange (${code})`);
-		this.code = code;
-	}
-};
-
-//#region src/errors/login-timed-out.ts
-var LoginTimedOut = class extends Error {
-	name = "LoginTimedOut";
-	constructor() {
-		super("Login timed out");
-	}
-};
-
-//#region src/oauth2-token-request.ts
-const REQUEST_TIMEOUT_MS = 1e4;
-function exchangeForGatewayToken(tokenEndpoint, subjectToken, fetch, now) {
-	return requestToken(tokenEndpoint, subjectToken, "urn:ietf:params:oauth:token-type:access_token", fetch, now);
-}
-async function requestToken(tokenEndpoint, subjectToken, subjectTokenType, fetch, now) {
-	const response = await fetch(tokenEndpoint, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/x-www-form-urlencoded",
-			Accept: "application/json"
-		},
-		body: new URLSearchParams({
-			grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
-			subject_token: subjectToken,
-			subject_token_type: subjectTokenType
-		}),
-		redirect: "error",
-		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-	}).catch((error) => {
-		throw new AuthorizationServerUnavailable("The authorization server could not be reached", { cause: error });
-	});
-	if (response.status >= 500 || response.status === 408 || response.status === 429) throw new AuthorizationServerUnavailable(`The authorization server answered ${response.status}`);
-	if (!response.ok) {
-		const refusal = await response.json().catch(() => void 0);
-		throw new ExchangeRejected(refusal?.error ?? `http_${response.status}`);
-	}
-	return response.json().then((body) => toStoredGatewayToken(body, now())).catch(() => {
-		throw new AuthorizationServerUnavailable("The authorization server returned an unusable token response");
-	});
-}
-function toStoredGatewayToken({ access_token: token, expires_in: expiresIn }, receivedAt) {
-	const payload = (token.split(".")[1] ?? "").replace(/-/g, "+").replace(/_/g, "/");
-	const claims = JSON.parse(atob(payload));
-	return {
-		token,
-		receivedAt,
-		expiresAt: receivedAt + expiresIn * 1e3,
-		capExpiresAt: receivedAt + (claims.cap_exp - claims.exp + expiresIn) * 1e3
-	};
-}
-
 //#region src/id-token.ts
 const decodeClaims = (idToken = "") => {
 	const segments = idToken.split(".");
@@ -7043,6 +7204,7 @@ const startCallbackServer = async (expectedState, timeoutMs) => {
 	const close = () => {
 		clearTimeout(timer);
 		callbackServer.close();
+		callbackServer.closeAllConnections();
 	};
 	const authorizationCodeReceived = new Promise((resolve, reject) => {
 		timer = setTimeout(() => {
@@ -7052,7 +7214,7 @@ const startCallbackServer = async (expectedState, timeoutMs) => {
 		callbackServer.on("request", (req, res) => {
 			const outcome = readCallback(req, res, expectedState);
 			if (outcome === void 0) return;
-			close();
+			res.once("close", close);
 			if ("error" in outcome) reject(outcome.error);
 			else resolve(outcome.authorizationCode);
 		});
@@ -7083,7 +7245,7 @@ const redeemAuthorizationCode = async (options, authorizationCode, codeVerifier,
 		headers: { "Content-Type": "application/x-www-form-urlencoded" },
 		body,
 		redirect: "error",
-		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS$1)
 	}).catch((error) => {
 		throw new Error("Could not reach the identity provider", { cause: error });
 	});
@@ -10952,585 +11114,1476 @@ const getDigitalTwinUrl = (environment, sessionId) => {
 const rejectMissingSession = async () => {
   throw new Error("Linked session token is not set");
 };
-const buildConnection = (environment, designId, sessionId) => ({
+const buildConnection$1 = (environment, designId, sessionId) => ({
   baseUrl: getDigitalTwinUrl(environment, sessionId),
   headers: {
     Cookie: `digital-twin-session-${designId}=s%3A${sessionId}.s`
   },
   fetch: sessionId ? fetchWithUserAgent : rejectMissingSession
 });
-const resolveConnection = async (session, designId) => {
+const resolveConnection$1 = async (session, designId) => {
   const allocations = await getUserAllocations(session);
   const allocation = allocations.find(candidate => candidate.designId === designId);
   if (!allocation) {
     return undefined;
   }
-  return buildConnection(session.environment, designId, allocation.sessionId);
+  return buildConnection$1(session.environment, designId, allocation.sessionId);
 };
-const listDesigns = async session => {
+const listDesigns$2 = async session => {
   const allocations = await getUserAllocations(session);
   return allocations.map(allocation => ({
     id: allocation.designId,
     name: allocation.designName,
-    connection: buildConnection(session.environment, allocation.designId, allocation.sessionId)
+    connection: buildConnection$1(session.environment, allocation.designId, allocation.sessionId)
   }));
 };
 
-const getAppFromDigitalTwin = async (connection, machineCodeAppDirectoryInfo) => {
-  console.log(chalk.blue("Fetching all applications with source code from digital twin..."));
-  const allApplications = await getAllApplicationsWithSourceCode(connection);
-  const targetApp = allApplications.find(app => app.id === machineCodeAppDirectoryInfo.applicationId);
-  if (!targetApp) {
-    console.log();
-    console.error(chalk.red(`Application "${machineCodeAppDirectoryInfo.appName}" (ID: ${machineCodeAppDirectoryInfo.applicationId}) not found in the digital twin.`));
-    process.exit(1);
-  }
-  return targetApp;
-};
-const getAvailableAppsFromDigitalTwin = async connection => {
-  const allApplications = await getAllApplicationsWithSourceCode(connection);
-  return allApplications.filter(app => app.type === "machine_code");
+var $TypeError$1 = TypeError;
+var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
+
+var doesNotExceedSafeInteger$1 = function (it) {
+  if (it > MAX_SAFE_INTEGER) throw new $TypeError$1('Maximum allowed index exceeded');
+  return it;
 };
-const createNewAppDirectory = async (session, currentDir) => {
-  const {
-    selectedDesign,
-    selectedApp
-  } = await selectDesignAndApp(session);
-  if (!selectedApp.sourceCode) {
-    console.log();
-    console.log(chalk.yellow("No source code found for this application."));
-    process.exit(1);
-  }
-  const appDirectoryExists = await checkIfAppDirectoryExists(selectedApp.name, currentDir);
-  const safeFileName = sanitizeFileName(selectedApp.name);
-  if (appDirectoryExists) {
-    console.log();
-    console.error(chalk.red(`You already have a directory with name "${safeFileName}" here.`));
-    console.error(chalk.red("If that is the machine code app you are trying to pull, please navigate to the root folder of the app and run the 'vention pull' command from there."));
-    console.error(chalk.red("If not, please rename that directory and try again."));
-    process.exit(1);
-  }
-  const appDirectoryPath = await writeApplicationToDisk(selectedApp.name, selectedApp.sourceCode, currentDir);
-  const [assets, mmConfiguration] = await Promise.all([getLibraryAssets(selectedDesign.connection), getMmConfiguration(selectedDesign.connection)]);
-  if (assets !== undefined) {
-    await writeReadonlyJsonFile(appDirectoryPath, ".vention-design-scene-assets.json", assets);
+
+var isArray = isArray$5;
+var lengthOfArrayLike$2 = lengthOfArrayLike$g;
+var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1;
+var bind = functionBindContext;
+var createProperty = createProperty$6;
+
+// `FlattenIntoArray` abstract operation
+// https://tc39.es/ecma262/#sec-flattenintoarray
+var flattenIntoArray$1 = function (target, original, source, sourceLen, start, depth, mapper, thisArg) {
+  var targetIndex = start;
+  var sourceIndex = 0;
+  var mapFn = mapper ? bind(mapper, thisArg) : false;
+  var element, elementLen;
+
+  while (sourceIndex < sourceLen) {
+    if (sourceIndex in source) {
+      element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
+
+      if (depth > 0 && isArray(element)) {
+        elementLen = lengthOfArrayLike$2(element);
+        targetIndex = flattenIntoArray$1(target, original, element, elementLen, targetIndex, depth - 1) - 1;
+      } else {
+        doesNotExceedSafeInteger(targetIndex + 1);
+        createProperty(target, targetIndex, element);
+      }
+
+      targetIndex++;
+    }
+    sourceIndex++;
   }
-  await writeReadonlyJsonFile(appDirectoryPath, ".vention-design-configuration.json", mmConfiguration);
-  await writeMachineCodeAppDirectoryInfo(appDirectoryPath, {
-    appName: selectedApp.name,
-    designId: selectedDesign.id,
-    applicationId: selectedApp.id,
-    lastPulledAt: new Date().toISOString(),
-    environment: session.environment,
-    uuid: selectedApp.uuid
-  });
-  console.log();
-  console.log(chalk.green(`✅ Successfully pulled "${selectedApp.name}" to: ${appDirectoryPath}`));
-  console.log(chalk.blue(`📁 To navigate to your project, run:`));
-  console.log(chalk.cyan(`cd "${safeFileName}"`));
-  console.log(chalk.blue("💡 You can now start working on your application!"));
+  return targetIndex;
 };
-const updateExistingAppDirectory = async (session, machineCodeAppDirectoryInfo, currentDir) => {
-  console.log(chalk.blue(`Found existing project: ${machineCodeAppDirectoryInfo.appName}`));
-  console.log(chalk.blue(`Design ID: ${machineCodeAppDirectoryInfo.designId}, App ID: ${machineCodeAppDirectoryInfo.applicationId}`));
-  const connection = await resolveConnection(session, machineCodeAppDirectoryInfo.designId);
-  if (!connection) {
-    console.log();
-    console.error(chalk.red("Sorry, it seems you do not have that design open with the MachineLogic tab selected."));
-    console.error(chalk.red("Please go to your browser, open your design, and navigate to the MachineLogic page."));
-    process.exit(1);
-  }
-  const appWithSourceCode = await getAppFromDigitalTwin(connection, machineCodeAppDirectoryInfo);
-  await writeApplicationToDisk(appWithSourceCode.name, appWithSourceCode.sourceCode, currentDir, true);
-  const [assets, mmConfiguration] = await Promise.all([getLibraryAssets(connection), getMmConfiguration(connection)]);
-  if (assets !== undefined) {
-    await writeReadonlyJsonFile(currentDir, ".vention-design-scene-assets.json", assets);
+
+var flattenIntoArray_1 = flattenIntoArray$1;
+
+var $$8 = _export;
+var flattenIntoArray = flattenIntoArray_1;
+var aCallable$4 = aCallable$l;
+var toObject$1 = toObject$b;
+var lengthOfArrayLike$1 = lengthOfArrayLike$g;
+var arraySpeciesCreate = arraySpeciesCreate$2;
+
+// `Array.prototype.flatMap` method
+// https://tc39.es/ecma262/#sec-array.prototype.flatmap
+$$8({ target: 'Array', proto: true }, {
+  flatMap: function flatMap(callbackfn /* , thisArg */) {
+    var O = toObject$1(this);
+    var sourceLen = lengthOfArrayLike$1(O);
+    var A;
+    aCallable$4(callbackfn);
+    A = arraySpeciesCreate(O, 0);
+    flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+    return A;
   }
-  await writeReadonlyJsonFile(currentDir, ".vention-design-configuration.json", mmConfiguration);
-  await writeMachineCodeAppDirectoryInfo(currentDir, Object.assign(Object.assign({}, machineCodeAppDirectoryInfo), {
-    lastPulledAt: new Date().toISOString()
-  }));
-  console.log();
-  console.log(chalk.green(`✅ Successfully pulled "${appWithSourceCode.name}" to: ${currentDir}`));
-  console.log(chalk.blue("💡 Your project has been updated with the latest changes!"));
+});
+
+var tryToString = tryToString$6;
+
+var $TypeError = TypeError;
+
+var deletePropertyOrThrow$1 = function (O, P) {
+  if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
 };
-const linkDirectory = async (session, currentDir) => {
-  const {
-    selectedDesign,
-    selectedApp
-  } = await selectDesignAndApp(session);
-  await writeMachineCodeAppDirectoryInfo(currentDir, {
-    appName: selectedApp.name,
-    designId: selectedDesign.id,
-    applicationId: selectedApp.id,
-    lastPulledAt: new Date().toISOString(),
-    environment: session.environment,
-    uuid: selectedApp.uuid
+
+var fails$2 = fails$F;
+
+var arrayMethodIsStrict$1 = function (METHOD_NAME, argument) {
+  var method = [][METHOD_NAME];
+  return !!method && fails$2(function () {
+    // eslint-disable-next-line no-useless-call -- required for testing
+    method.call(null, argument || function () { return 1; }, 1);
   });
-  console.log(chalk.green(`Successfully linked current directory to design "${selectedDesign.name}" (ID: ${selectedDesign.id})`));
-  console.log(chalk.green(`Application: "${selectedApp.name}" (ID: ${selectedApp.id})`));
-  return {
-    selectedDesign,
-    selectedApp
-  };
 };
-const selectDesignAndApp = async session => {
-  const designs = await listDesigns(session);
-  if (designs.length === 0) {
-    console.log();
-    console.log(chalk.yellow("No active allocations found. Please open a design and navigate to the machine logic tab to activate a digital twin."));
-    process.exit(1);
+
+var $$7 = _export;
+var uncurryThis$4 = functionUncurryThis;
+var aCallable$3 = aCallable$l;
+var toObject = toObject$b;
+var lengthOfArrayLike = lengthOfArrayLike$g;
+var deletePropertyOrThrow = deletePropertyOrThrow$1;
+var toString$4 = toString$j;
+var fails$1 = fails$F;
+var internalSort = arraySort$1;
+var arrayMethodIsStrict = arrayMethodIsStrict$1;
+var FF = environmentFfVersion;
+var IE_OR_EDGE = environmentIsIeOrEdge;
+var V8 = environmentV8Version;
+var WEBKIT = environmentWebkitVersion;
+
+var test = [];
+var nativeSort = uncurryThis$4(test.sort);
+var push = uncurryThis$4(test.push);
+
+// IE8-
+var FAILS_ON_UNDEFINED = fails$1(function () {
+  test.sort(undefined);
+});
+// V8 bug
+var FAILS_ON_NULL = fails$1(function () {
+  test.sort(null);
+});
+// Old WebKit
+var STRICT_METHOD = arrayMethodIsStrict('sort');
+
+var STABLE_SORT = !fails$1(function () {
+  // feature detection can be too slow, so check engines versions
+  if (V8) return V8 < 70;
+  if (FF && FF > 3) return;
+  if (IE_OR_EDGE) return true;
+  if (WEBKIT) return WEBKIT < 603;
+
+  var result = '';
+  var code, chr, value, index;
+
+  // generate an array with more 512 elements (Chakra and old V8 fails only in this case)
+  for (code = 65; code < 76; code++) {
+    chr = String.fromCharCode(code);
+
+    switch (code) {
+      case 66: case 69: case 70: case 72: value = 3; break;
+      case 68: case 71: value = 4; break;
+      default: value = 2;
+    }
+
+    for (index = 0; index < 47; index++) {
+      test.push({ k: chr + index, v: value });
+    }
   }
-  const selectedDesign = await select({
-    message: "Select a design:",
-    choices: designs.map(design => ({
-      name: `${design.name} (ID: ${design.id})`,
-      value: design
-    }))
-  });
-  const availableApps = await getAvailableAppsFromDigitalTwin(selectedDesign.connection);
-  if (availableApps.length === 0) {
-    console.log();
-    console.log(chalk.yellow("No machine code applications found in the digital twin"));
-    process.exit(1);
+
+  test.sort(function (a, b) { return b.v - a.v; });
+
+  for (index = 0; index < test.length; index++) {
+    chr = test[index].k.charAt(0);
+    if (result.charAt(result.length - 1) !== chr) result += chr;
   }
-  const selectedApp = await select({
-    message: "Select an application:",
-    choices: availableApps.map(app => ({
-      name: app.name,
-      value: app
-    }))
-  });
-  return {
-    selectedDesign,
-    selectedApp
-  };
-};
 
-function createLinkCommand() {
-  return new Command("link").description("Link current directory to a Vention design application").action(async () => {
-    try {
-      const session = await loadSession();
-      if (!session) {
-        console.error(chalk.red("Not logged in. Please run 'vention login' first."));
-        process.exit(1);
-      }
-      const currentDir = process.cwd();
-      console.log();
-      await linkDirectory(session, currentDir);
-      console.log(chalk.blue("You can now use 'vention pull' to download app content or 'vention push' to upload local changes."));
-    } catch (error) {
-      handleCommandError(error, "Failed to link directory");
-    }
-  });
-}
+  return result !== 'DGBEFHACIJK';
+});
 
-function createPushCommand() {
-  return new Command("push").description("Push local changes from this directory to the linked digital twin").action(async () => {
-    try {
-      const session = await loadSession();
-      if (!session) {
-        console.error(chalk.red("Not logged in. Please run 'vention login' first."));
-        process.exit(1);
-      }
-      const currentDir = process.cwd();
-      const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
-      let linkedConnection;
-      if (!machineCodeAppDirectoryInfo) {
-        console.log();
-        console.log(chalk.yellow("This directory is not linked to a Vention application."));
-        const shouldLink = await select({
-          message: "Would you like to link this directory to an application?",
-          choices: [{
-            name: "Yes, link this directory",
-            value: true
-          }, {
-            name: "No, cancel push operation",
-            value: false
-          }]
-        });
-        if (!shouldLink) {
-          console.log(chalk.blue("Push operation cancelled. Run 'vention link' when you're ready to link this directory."));
-          process.exit(0);
-        }
-        const {
-          selectedDesign
-        } = await linkDirectory(session, currentDir);
-        linkedConnection = selectedDesign.connection;
-        console.log(chalk.blue("Continuing with push operation..."));
-      }
-      const updatedMachineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
-      if (!updatedMachineCodeAppDirectoryInfo) {
-        console.log(chalk.red("Error reading directory metadata after linking."));
-        process.exit(1);
-      }
-      console.log();
-      console.log(chalk.blue(`Pushing changes for project: ${updatedMachineCodeAppDirectoryInfo.appName}`));
-      console.log(chalk.blue(`Design ID: ${updatedMachineCodeAppDirectoryInfo.designId}, App ID: ${updatedMachineCodeAppDirectoryInfo.applicationId}`));
-      const connection = linkedConnection !== null && linkedConnection !== void 0 ? linkedConnection : await resolveConnection(session, updatedMachineCodeAppDirectoryInfo.designId);
-      if (!connection) {
-        console.log();
-        console.error(chalk.red("Sorry, it seems you do not have that design open with the MachineLogic tab selected."));
-        console.error(chalk.red("Please go to your browser, open your design, and navigate to the MachineLogic page."));
-        process.exit(1);
-      }
-      console.log();
-      console.log(chalk.blue("Serializing local files..."));
-      const ignorePatterns = getDefaultIgnorePatterns();
-      const serializedSourceCode = serializeFileSystem(currentDir, ignorePatterns, true);
-      const applicationToPush = {
-        name: updatedMachineCodeAppDirectoryInfo.appName,
-        id: updatedMachineCodeAppDirectoryInfo.applicationId,
-        type: "machine_code",
-        sourceCode: serializedSourceCode,
-        uuid: updatedMachineCodeAppDirectoryInfo.uuid
-      };
-      console.log(chalk.blue("Pushing to digital twin..."));
-      await pushApplicationToDigitalTwin(connection, applicationToPush);
-      await writeMachineCodeAppDirectoryInfo(currentDir, Object.assign(Object.assign({}, updatedMachineCodeAppDirectoryInfo), {
-        lastPushedAt: new Date().toISOString()
-      }));
-      console.log();
-      console.log(chalk.green(`✅ Successfully pushed to digital twin`));
-      console.log(chalk.blue("💡 Your changes have been uploaded!"));
-    } catch (error) {
-      handleCommandError(error, "Failed to push application");
+var FORCED$1 = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;
+
+var getSortCompare = function (comparefn) {
+  return function (x, y) {
+    if (y === undefined) return -1;
+    if (x === undefined) return 1;
+    if (comparefn !== undefined) return +comparefn(x, y) || 0;
+    var xString = toString$4(x);
+    var yString = toString$4(y);
+    return xString === yString ? 0 : xString > yString ? 1 : -1;
+  };
+};
+
+// `Array.prototype.sort` method
+// https://tc39.es/ecma262/#sec-array.prototype.sort
+$$7({ target: 'Array', proto: true, forced: FORCED$1 }, {
+  sort: function sort(comparefn) {
+    if (comparefn !== undefined) aCallable$3(comparefn);
+
+    var array = toObject(this);
+
+    if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn);
+
+    var items = [];
+    var arrayLength = lengthOfArrayLike(array);
+    var itemsLength, index;
+
+    for (index = 0; index < arrayLength; index++) {
+      if (index in array) push(items, array[index]);
     }
-  });
+
+    internalSort(items, getSortCompare(comparefn));
+
+    itemsLength = lengthOfArrayLike(items);
+    index = 0;
+
+    while (index < itemsLength) array[index] = items[index++];
+    while (index < arrayLength) deletePropertyOrThrow(array, index++);
+
+    return array;
+  }
+});
+
+// this method was added to unscopables after implementation
+// in popular engines, so it's moved to a separate module
+var addToUnscopables = addToUnscopables$3;
+
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+addToUnscopables('flatMap');
+
+var call$2 = functionCall;
+var anObject$2 = anObject$q;
+var getIteratorDirect$2 = getIteratorDirect$8;
+var getIteratorMethod = getIteratorMethod$6;
+
+var getIteratorFlattenable$1 = function (obj, stringHandling) {
+  if (!stringHandling || typeof obj !== 'string') anObject$2(obj);
+  var method = getIteratorMethod(obj);
+  return getIteratorDirect$2(anObject$2(method !== undefined ? call$2(method, obj) : obj));
+};
+
+var $$6 = _export;
+var call$1 = functionCall;
+var aCallable$2 = aCallable$l;
+var anObject$1 = anObject$q;
+var getIteratorDirect$1 = getIteratorDirect$8;
+var getIteratorFlattenable = getIteratorFlattenable$1;
+var createIteratorProxy = iteratorCreateProxy;
+var iteratorClose$1 = iteratorClose$d;
+var iteratorHelperThrowsOnInvalidIterator = iteratorHelperThrowsOnInvalidIterator$3;
+var iteratorHelperWithoutClosingOnEarlyError$1 = iteratorHelperWithoutClosingOnEarlyError$6;
+
+// Should not throw an error for an iterator without `return` method. Fixed in Safari 26.2
+// https://bugs.webkit.org/show_bug.cgi?id=297532
+function throwsOnIteratorWithoutReturn() {
+  try {
+    // eslint-disable-next-line es/no-map, es/no-iterator, es/no-iterator-prototype-flatmap -- required for testing
+    var it = Iterator.prototype.flatMap.call(new Map([[4, 5]]).entries(), function (v) { return v; });
+    it.next();
+    it['return']();
+  } catch (error) {
+    return true;
+  }
 }
 
-function createPullCommand() {
-  return new Command("pull").description("Pull an application from a design to this directory").action(async () => {
+var FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !iteratorHelperThrowsOnInvalidIterator('flatMap', function () { /* empty */ });
+var flatMapWithoutClosingOnEarlyError = !FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR
+  && iteratorHelperWithoutClosingOnEarlyError$1('flatMap', TypeError);
+
+var FORCED = FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || flatMapWithoutClosingOnEarlyError
+  || throwsOnIteratorWithoutReturn();
+
+var IteratorProxy = createIteratorProxy(function () {
+  var iterator = this.iterator;
+  var mapper = this.mapper;
+  var result, inner;
+
+  while (true) {
+    if (inner = this.inner) try {
+      result = anObject$1(call$1(inner.next, inner.iterator));
+      if (!result.done) return result.value;
+      this.inner = null;
+    } catch (error) { iteratorClose$1(iterator, 'throw', error); }
+
+    result = anObject$1(call$1(this.next, iterator));
+
+    if (this.done = !!result.done) return;
+
     try {
-      const session = await loadSession();
-      if (!session) {
-        console.error(chalk.red("Not logged in. Please run 'vention login' first."));
-        process.exit(1);
-      }
-      const currentDir = process.cwd();
-      const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
-      if (machineCodeAppDirectoryInfo) {
-        console.log(chalk.blue(`This directory is linked to app: ${machineCodeAppDirectoryInfo.appName}`));
-        console.log(chalk.blue(`Pulling latest content from design ID: ${machineCodeAppDirectoryInfo.designId}`));
-        await updateExistingAppDirectory(session, machineCodeAppDirectoryInfo, currentDir);
-      } else {
-        await createNewAppDirectory(session, currentDir);
-      }
-    } catch (error) {
-      handleCommandError(error, "Failed to pull application");
-    }
-  });
-}
+      this.inner = getIteratorFlattenable(mapper(result.value, this.counter++), false);
+    } catch (error) { iteratorClose$1(iterator, 'throw', error); }
+  }
+});
 
-function createLogsCommand() {
-  return new Command("logs").description("Fetch application logs from the linked digital twin").action(async () => {
+// `Iterator.prototype.flatMap` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.flatmap
+$$6({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
+  flatMap: function flatMap(mapper) {
+    anObject$1(this);
     try {
-      const session = await loadSession();
-      if (!session) {
-        console.error(chalk.red("Not logged in. Please run 'vention login' first."));
-        process.exit(1);
-      }
-      const currentDir = process.cwd();
-      const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
-      if (!machineCodeAppDirectoryInfo) {
-        console.error(chalk.red("This directory is not linked to a Vention application."));
-        console.error(chalk.red("Please run 'vention pull' or 'vention link' first."));
-        process.exit(1);
-      }
-      const connection = await resolveConnection(session, machineCodeAppDirectoryInfo.designId);
-      if (!connection) {
-        console.error(chalk.red("Sorry, it seems you do not have that design open with the MachineLogic tab selected."));
-        console.error(chalk.red("Please go to your browser, open your design, and navigate to the MachineLogic page."));
-        process.exit(1);
-      }
-      const logs = await getApplicationLogs(connection, machineCodeAppDirectoryInfo.applicationId);
-      console.log(logs);
+      aCallable$2(mapper);
     } catch (error) {
-      handleCommandError(error, "Failed to fetch application logs");
+      iteratorClose$1(this, 'throw', error);
     }
-  });
-}
 
-var $TypeError$1 = TypeError;
-var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
+    if (flatMapWithoutClosingOnEarlyError) return call$1(flatMapWithoutClosingOnEarlyError, this, mapper);
 
-var doesNotExceedSafeInteger$1 = function (it) {
-  if (it > MAX_SAFE_INTEGER) throw new $TypeError$1('Maximum allowed index exceeded');
-  return it;
-};
+    return new IteratorProxy(getIteratorDirect$1(this), {
+      mapper: mapper,
+      inner: null
+    });
+  }
+});
 
-var isArray = isArray$5;
-var lengthOfArrayLike$2 = lengthOfArrayLike$g;
-var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1;
-var bind = functionBindContext;
-var createProperty = createProperty$6;
+//#region src/generated/core/bodySerializer.gen.ts
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
 
-// `FlattenIntoArray` abstract operation
-// https://tc39.es/ecma262/#sec-flattenintoarray
-var flattenIntoArray$1 = function (target, original, source, sourceLen, start, depth, mapper, thisArg) {
-  var targetIndex = start;
-  var sourceIndex = 0;
-  var mapFn = mapper ? bind(mapper, thisArg) : false;
-  var element, elementLen;
+//#region src/generated/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+//#region src/generated/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+}
 
-  while (sourceIndex < sourceLen) {
-    if (sourceIndex in source) {
-      element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
+//#region src/generated/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+
+//#region src/generated/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+async function setAuthParams(options) {
+	for (const auth of options.security ?? []) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default: options.headers.set(name, token);
+		}
+	}
+}
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+
+//#region src/generated/core/serverSentEvents.gen.ts
+function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						buffer = buffer.replace(/\r\n?/g, "\n");
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+				await sleep(backoff);
+			}
+		}
+	};
+	return { stream: createStream() };
+}
 
-      if (depth > 0 && isArray(element)) {
-        elementLen = lengthOfArrayLike$2(element);
-        targetIndex = flattenIntoArray$1(target, original, element, elementLen, targetIndex, depth - 1) - 1;
-      } else {
-        doesNotExceedSafeInteger(targetIndex + 1);
-        createProperty(target, targetIndex, element);
-      }
+//#region src/generated/client/client.gen.ts
+const createClient$1 = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams(opts);
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		const resolvedOpts = opts;
+		return {
+			opts: resolvedOpts,
+			url: buildUrl(resolvedOpts)
+		};
+	};
+	const request = async (options) => {
+		const throwOnError = options.throwOnError ?? _config.throwOnError;
+		const responseStyle = options.responseStyle ?? _config.responseStyle;
+		let request;
+		let response;
+		try {
+			const { opts, url } = await beforeRequest(options);
+			const requestInit = {
+				redirect: "follow",
+				...opts,
+				body: getValidRequestBody(opts)
+			};
+			request = new Request(url, requestInit);
+			for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+			const _fetch = opts.fetch;
+			response = await _fetch(request);
+			for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
+			const result = {
+				request,
+				response
+			};
+			if (response.ok) {
+				const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+				if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+					let emptyData;
+					switch (parseAs) {
+						case "arrayBuffer":
+						case "blob":
+						case "text":
+							emptyData = await response[parseAs]();
+							break;
+						case "formData":
+							emptyData = new FormData();
+							break;
+						case "stream":
+							emptyData = response.body;
+							break;
+						default: emptyData = {};
+					}
+					return opts.responseStyle === "data" ? emptyData : {
+						data: emptyData,
+						...result
+					};
+				}
+				let data;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "formData":
+					case "text":
+						data = await response[parseAs]();
+						break;
+					case "json": {
+						const text = await response.text();
+						data = text ? JSON.parse(text) : {};
+						break;
+					}
+					case "stream": return opts.responseStyle === "data" ? response.body : {
+						data: response.body,
+						...result
+					};
+				}
+				if (parseAs === "json") {
+					if (opts.responseValidator) await opts.responseValidator(data);
+					if (opts.responseTransformer) data = await opts.responseTransformer(data);
+				}
+				return opts.responseStyle === "data" ? data : {
+					data,
+					...result
+				};
+			}
+			const textError = await response.text();
+			let jsonError;
+			try {
+				jsonError = JSON.parse(textError);
+			} catch {}
+			throw jsonError ?? textError;
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(finalError, response, request, options);
+			finalError = finalError || {};
+			if (throwOnError) throw finalError;
+			return responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response
+			};
+		}
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+				return request;
+			},
+			serializedBody: getValidRequestBody(opts),
+			url
+		});
+	};
+	const _buildUrl = (options) => buildUrl({
+		..._config,
+		...options
+	});
+	return {
+		buildUrl: _buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+
+//#region src/generated/sdk.gen.ts
+var HeyApiClient = class {
+	client;
+	constructor(args) {
+		this.client = args.client;
+	}
+};
+var HeyApiRegistry = class {
+	defaultKey = "default";
+	instances = /* @__PURE__ */ new Map();
+	get(key) {
+		const instance = this.instances.get(key ?? this.defaultKey);
+		if (!instance) throw new Error(`No SDK client found. Create one with "new DigitalTwinApi()" to fix this error.`);
+		return instance;
+	}
+	set(value, key) {
+		this.instances.set(key ?? this.defaultKey, value);
+	}
+};
+var DigitalTwinApi = class DigitalTwinApi extends HeyApiClient {
+	static __registry = new HeyApiRegistry();
+	constructor(args) {
+		super(args);
+		DigitalTwinApi.__registry.set(this, args.key);
+	}
+	/**
+	* List the caller's digital twin instances
+	*/
+	listInstances(options) {
+		return (options?.client ?? this.client).get({
+			security: [{
+				in: "cookie",
+				name: "__Host-vention_auth",
+				type: "apiKey"
+			}, {
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/instances",
+			...options
+		});
+	}
+	/**
+	* Allocate a digital twin instance
+	*/
+	allocate(options) {
+		return (options.client ?? this.client).post({
+			security: [{
+				in: "cookie",
+				name: "__Host-vention_auth",
+				type: "apiKey"
+			}, {
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/instances",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Deallocate a digital twin instance
+	*/
+	deallocate(options) {
+		return (options.client ?? this.client).delete({
+			security: [{
+				in: "cookie",
+				name: "__Host-vention_auth",
+				type: "apiKey"
+			}, {
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/instances/{instanceId}",
+			...options
+		});
+	}
+	/**
+	* Get a single digital twin instance
+	*/
+	getInstance(options) {
+		return (options.client ?? this.client).get({
+			security: [{
+				in: "cookie",
+				name: "__Host-vention_auth",
+				type: "apiKey"
+			}, {
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/instances/{instanceId}",
+			...options
+		});
+	}
+	/**
+	* List the releases available to instantiate
+	*/
+	listReleases(options) {
+		return (options?.client ?? this.client).get({
+			security: [{
+				in: "cookie",
+				name: "__Host-vention_auth",
+				type: "apiKey"
+			}, {
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/releases",
+			...options
+		});
+	}
+	/**
+	* Get a release and the container images it ships
+	*/
+	getRelease(options) {
+		return (options.client ?? this.client).get({
+			security: [{
+				in: "cookie",
+				name: "__Host-vention_auth",
+				type: "apiKey"
+			}, {
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/releases/{release}",
+			...options
+		});
+	}
+	/**
+	* List the release channels available to instantiate from
+	*/
+	listChannels(options) {
+		return (options?.client ?? this.client).get({
+			security: [{
+				in: "cookie",
+				name: "__Host-vention_auth",
+				type: "apiKey"
+			}, {
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/api/channels",
+			...options
+		});
+	}
+};
 
-      targetIndex++;
-    }
-    sourceIndex++;
-  }
-  return targetIndex;
+//#region src/errors.ts
+/**
+* The wait ended without a ready instance. Carries the identifiers a caller needs to log the
+* failure or deallocate the twin, so none of it has to be dug back out of the response —
+* `response.statusText` is empty over HTTP/2 and tells a caller nothing.
+*/
+/** The instance is ready but does not expose the service the caller asked for. */
+var EndpointNotFoundError = class extends Error {
+	instanceId;
+	endpoint;
+	available;
+	constructor(instanceId, endpoint, available) {
+		super(`Instance ${instanceId} exposed no endpoint named "${endpoint}" — it exposes ${available.length > 0 ? available.join(", ") : "none"}`);
+		this.instanceId = instanceId;
+		this.endpoint = endpoint;
+		this.available = available;
+		this.name = "EndpointNotFoundError";
+	}
 };
 
-var flattenIntoArray_1 = flattenIntoArray$1;
+//#region src/find-endpoint.ts
+/**
+* Reads the URL of one of an instance's exposed services.
+*
+* @param instance A ready instance. Endpoints are absent until it is.
+* @param name The service to reach, as the release names it.
+* @returns The absolute URL serving that service, or an {@link EndpointNotFoundError} naming the services the instance
+* does expose.
+*/
+function findEndpoint(instance, name) {
+	const endpoint = instance.endpoints?.find((candidate) => candidate.name === name);
+	if (!endpoint) return {
+		success: false,
+		error: new EndpointNotFoundError(instance.id, name, instance.endpoints?.map((each) => each.name) ?? [])
+	};
+	return {
+		success: true,
+		url: endpoint.url
+	};
+}
 
-var $$8 = _export;
-var flattenIntoArray = flattenIntoArray_1;
-var aCallable$4 = aCallable$l;
-var toObject$1 = toObject$b;
-var lengthOfArrayLike$1 = lengthOfArrayLike$g;
-var arraySpeciesCreate = arraySpeciesCreate$2;
+//#region src/index.ts
+/**
+* Auth runs in the wrapped fetch, below the generated code. hey-api's own `auth` option stays
+* unset: it would turn the cookie scheme into a `Cookie` header browsers drop.
+*/
+function createDigitalTwinApi({ baseUrl, authStrategy, fetch = globalThis.fetch }) {
+	const client = createClient$1(createConfig({
+		baseUrl,
+		fetch: authStrategy ? withAuthStrategy(authStrategy, fetch) : fetch
+	}));
+	return new DigitalTwinApi({ client });
+}
 
-// `Array.prototype.flatMap` method
-// https://tc39.es/ecma262/#sec-array.prototype.flatmap
-$$8({ target: 'Array', proto: true }, {
-  flatMap: function flatMap(callbackfn /* , thisArg */) {
-    var O = toObject$1(this);
-    var sourceLen = lengthOfArrayLike$1(O);
-    var A;
-    aCallable$4(callbackfn);
-    A = arraySpeciesCreate(O, 0);
-    flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
-    return A;
+const DIGITAL_TWIN_API_ORIGINS = {
+  demo: "https://twins.vention.foo",
+  prod: "https://twins.vention.com"
+};
+const getOrigin = environment => {
+  var _a;
+  return (_a = getOriginOverride("VENTION_CLI_DIGITAL_TWIN_API_ORIGIN")) !== null && _a !== void 0 ? _a : DIGITAL_TWIN_API_ORIGINS[environment];
+};
+const createClient = (session, origins) => {
+  const strategy = new BearerStrategy({
+    exchange: oauth2TokenExchange({
+      issuer: origins.auth,
+      store: gatewayTokenStore(session),
+      fetch: fetchWithUserAgent
+    })
+  });
+  return {
+    api: createDigitalTwinApi({
+      baseUrl: origins.api,
+      authStrategy: strategy,
+      fetch: fetchWithUserAgent
+    }),
+    fetch: withAuthStrategy(strategy, fetchWithUserAgent)
+  };
+};
+const compareNewestFirst = (left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt);
+const listReadyInstances = async api => {
+  const {
+    data,
+    error,
+    response
+  } = await api.listInstances();
+  if (data !== undefined) {
+    return data.filter(instance => instance.state === "ready").sort(compareNewestFirst);
+  }
+  if ((response === null || response === void 0 ? void 0 : response.ok) === false) {
+    throw buildApiError(response, typeof error === "object" && error !== null && Object.keys(error).length === 0 ? null : error, response.url);
   }
+  throw error;
+};
+const buildConnection = (engineUrl, fetch) => ({
+  baseUrl: engineUrl,
+  headers: {},
+  fetch
 });
-
-var tryToString = tryToString$6;
-
-var $TypeError = TypeError;
-
-var deletePropertyOrThrow$1 = function (O, P) {
-  if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
+const listDesigns$1 = async (session, origins) => {
+  const {
+    api,
+    fetch
+  } = createClient(session, origins);
+  const instances = await listReadyInstances(api);
+  const newestInstancePerDesign = instances.filter((instance, index) => instances.findIndex(other => other.designId === instance.designId) === index);
+  return newestInstancePerDesign.flatMap(instance => {
+    const engineLookup = findEndpoint(instance, "execution-engine");
+    return engineLookup.success ? [{
+      id: instance.designId,
+      name: instance.designName,
+      connection: buildConnection(engineLookup.url, fetch)
+    }] : [];
+  });
+};
+const resolveConnection = async (session, origins, designId) => {
+  var _a;
+  const designs = await listDesigns$1(session, origins);
+  return (_a = designs.find(design => design.id === designId)) === null || _a === void 0 ? void 0 : _a.connection;
 };
 
-var fails$2 = fails$F;
+const findDigitalTwinApiOrigins = session => {
+  if (!isDigitalTwinV3Enabled(session)) {
+    return undefined;
+  }
+  const auth = getPlatformAuthOrigin(session.environment);
+  const api = getOrigin(session.environment);
+  if (!auth || !api) {
+    verboseLog(`${DIGITAL_TWIN_V3.key} is on but ${session.environment} has no digital twin API configured, using the Rails API path`);
+    return undefined;
+  }
+  return {
+    auth,
+    api
+  };
+};
+const resolveDigitalTwinConnection = async (session, designId) => {
+  const origins = findDigitalTwinApiOrigins(session);
+  return origins ? resolveConnection(session, origins, designId) : resolveConnection$1(session, designId);
+};
+const listDesigns = async session => {
+  const origins = findDigitalTwinApiOrigins(session);
+  return origins ? listDesigns$1(session, origins) : listDesigns$2(session);
+};
 
-var arrayMethodIsStrict$1 = function (METHOD_NAME, argument) {
-  var method = [][METHOD_NAME];
-  return !!method && fails$2(function () {
-    // eslint-disable-next-line no-useless-call -- required for testing
-    method.call(null, argument || function () { return 1; }, 1);
+const getAppFromDigitalTwin = async (connection, machineCodeAppDirectoryInfo) => {
+  console.log(chalk.blue("Fetching all applications with source code from digital twin..."));
+  const allApplications = await getAllApplicationsWithSourceCode(connection);
+  const targetApp = allApplications.find(app => app.id === machineCodeAppDirectoryInfo.applicationId);
+  if (!targetApp) {
+    console.log();
+    console.error(chalk.red(`Application "${machineCodeAppDirectoryInfo.appName}" (ID: ${machineCodeAppDirectoryInfo.applicationId}) not found in the digital twin.`));
+    process.exit(1);
+  }
+  return targetApp;
+};
+const getAvailableAppsFromDigitalTwin = async connection => {
+  const allApplications = await getAllApplicationsWithSourceCode(connection);
+  return allApplications.filter(app => app.type === "machine_code");
+};
+const createNewAppDirectory = async (session, currentDir) => {
+  const {
+    selectedDesign,
+    selectedApp
+  } = await selectDesignAndApp(session);
+  if (!selectedApp.sourceCode) {
+    console.log();
+    console.log(chalk.yellow("No source code found for this application."));
+    process.exit(1);
+  }
+  const appDirectoryExists = await checkIfAppDirectoryExists(selectedApp.name, currentDir);
+  const safeFileName = sanitizeFileName(selectedApp.name);
+  if (appDirectoryExists) {
+    console.log();
+    console.error(chalk.red(`You already have a directory with name "${safeFileName}" here.`));
+    console.error(chalk.red("If that is the machine code app you are trying to pull, please navigate to the root folder of the app and run the 'vention pull' command from there."));
+    console.error(chalk.red("If not, please rename that directory and try again."));
+    process.exit(1);
+  }
+  const appDirectoryPath = await writeApplicationToDisk(selectedApp.name, selectedApp.sourceCode, currentDir);
+  const [assets, mmConfiguration] = await Promise.all([getLibraryAssets(selectedDesign.connection), getMmConfiguration(selectedDesign.connection)]);
+  if (assets !== undefined) {
+    await writeReadonlyJsonFile(appDirectoryPath, ".vention-design-scene-assets.json", assets);
+  }
+  await writeReadonlyJsonFile(appDirectoryPath, ".vention-design-configuration.json", mmConfiguration);
+  await writeMachineCodeAppDirectoryInfo(appDirectoryPath, {
+    appName: selectedApp.name,
+    designId: selectedDesign.id,
+    applicationId: selectedApp.id,
+    lastPulledAt: new Date().toISOString(),
+    environment: session.environment,
+    uuid: selectedApp.uuid
   });
+  console.log();
+  console.log(chalk.green(`✅ Successfully pulled "${selectedApp.name}" to: ${appDirectoryPath}`));
+  console.log(chalk.blue(`📁 To navigate to your project, run:`));
+  console.log(chalk.cyan(`cd "${safeFileName}"`));
+  console.log(chalk.blue("💡 You can now start working on your application!"));
 };
-
-var $$7 = _export;
-var uncurryThis$4 = functionUncurryThis;
-var aCallable$3 = aCallable$l;
-var toObject = toObject$b;
-var lengthOfArrayLike = lengthOfArrayLike$g;
-var deletePropertyOrThrow = deletePropertyOrThrow$1;
-var toString$4 = toString$j;
-var fails$1 = fails$F;
-var internalSort = arraySort$1;
-var arrayMethodIsStrict = arrayMethodIsStrict$1;
-var FF = environmentFfVersion;
-var IE_OR_EDGE = environmentIsIeOrEdge;
-var V8 = environmentV8Version;
-var WEBKIT = environmentWebkitVersion;
-
-var test = [];
-var nativeSort = uncurryThis$4(test.sort);
-var push = uncurryThis$4(test.push);
-
-// IE8-
-var FAILS_ON_UNDEFINED = fails$1(function () {
-  test.sort(undefined);
-});
-// V8 bug
-var FAILS_ON_NULL = fails$1(function () {
-  test.sort(null);
-});
-// Old WebKit
-var STRICT_METHOD = arrayMethodIsStrict('sort');
-
-var STABLE_SORT = !fails$1(function () {
-  // feature detection can be too slow, so check engines versions
-  if (V8) return V8 < 70;
-  if (FF && FF > 3) return;
-  if (IE_OR_EDGE) return true;
-  if (WEBKIT) return WEBKIT < 603;
-
-  var result = '';
-  var code, chr, value, index;
-
-  // generate an array with more 512 elements (Chakra and old V8 fails only in this case)
-  for (code = 65; code < 76; code++) {
-    chr = String.fromCharCode(code);
-
-    switch (code) {
-      case 66: case 69: case 70: case 72: value = 3; break;
-      case 68: case 71: value = 4; break;
-      default: value = 2;
-    }
-
-    for (index = 0; index < 47; index++) {
-      test.push({ k: chr + index, v: value });
-    }
+const updateExistingAppDirectory = async (session, machineCodeAppDirectoryInfo, currentDir) => {
+  console.log(chalk.blue(`Found existing project: ${machineCodeAppDirectoryInfo.appName}`));
+  console.log(chalk.blue(`Design ID: ${machineCodeAppDirectoryInfo.designId}, App ID: ${machineCodeAppDirectoryInfo.applicationId}`));
+  const connection = await resolveDigitalTwinConnection(session, machineCodeAppDirectoryInfo.designId);
+  if (!connection) {
+    console.log();
+    console.error(chalk.red("Sorry, it seems you do not have that design open with the MachineLogic tab selected."));
+    console.error(chalk.red("Please go to your browser, open your design, and navigate to the MachineLogic page."));
+    process.exit(1);
   }
-
-  test.sort(function (a, b) { return b.v - a.v; });
-
-  for (index = 0; index < test.length; index++) {
-    chr = test[index].k.charAt(0);
-    if (result.charAt(result.length - 1) !== chr) result += chr;
+  const appWithSourceCode = await getAppFromDigitalTwin(connection, machineCodeAppDirectoryInfo);
+  await writeApplicationToDisk(appWithSourceCode.name, appWithSourceCode.sourceCode, currentDir, true);
+  const [assets, mmConfiguration] = await Promise.all([getLibraryAssets(connection), getMmConfiguration(connection)]);
+  if (assets !== undefined) {
+    await writeReadonlyJsonFile(currentDir, ".vention-design-scene-assets.json", assets);
   }
-
-  return result !== 'DGBEFHACIJK';
-});
-
-var FORCED$1 = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;
-
-var getSortCompare = function (comparefn) {
-  return function (x, y) {
-    if (y === undefined) return -1;
-    if (x === undefined) return 1;
-    if (comparefn !== undefined) return +comparefn(x, y) || 0;
-    var xString = toString$4(x);
-    var yString = toString$4(y);
-    return xString === yString ? 0 : xString > yString ? 1 : -1;
+  await writeReadonlyJsonFile(currentDir, ".vention-design-configuration.json", mmConfiguration);
+  await writeMachineCodeAppDirectoryInfo(currentDir, Object.assign(Object.assign({}, machineCodeAppDirectoryInfo), {
+    lastPulledAt: new Date().toISOString()
+  }));
+  console.log();
+  console.log(chalk.green(`✅ Successfully pulled "${appWithSourceCode.name}" to: ${currentDir}`));
+  console.log(chalk.blue("💡 Your project has been updated with the latest changes!"));
+};
+const linkDirectory = async (session, currentDir) => {
+  const {
+    selectedDesign,
+    selectedApp
+  } = await selectDesignAndApp(session);
+  await writeMachineCodeAppDirectoryInfo(currentDir, {
+    appName: selectedApp.name,
+    designId: selectedDesign.id,
+    applicationId: selectedApp.id,
+    lastPulledAt: new Date().toISOString(),
+    environment: session.environment,
+    uuid: selectedApp.uuid
+  });
+  console.log(chalk.green(`Successfully linked current directory to design "${selectedDesign.name}" (ID: ${selectedDesign.id})`));
+  console.log(chalk.green(`Application: "${selectedApp.name}" (ID: ${selectedApp.id})`));
+  return {
+    selectedDesign,
+    selectedApp
+  };
+};
+const selectDesignAndApp = async session => {
+  const designs = await listDesigns(session);
+  if (designs.length === 0) {
+    console.log();
+    console.log(chalk.yellow("No active allocations found. Please open a design and navigate to the machine logic tab to activate a digital twin."));
+    process.exit(1);
+  }
+  const selectedDesign = await select({
+    message: "Select a design:",
+    choices: designs.map(design => ({
+      name: `${design.name} (ID: ${design.id})`,
+      value: design
+    }))
+  });
+  const availableApps = await getAvailableAppsFromDigitalTwin(selectedDesign.connection);
+  if (availableApps.length === 0) {
+    console.log();
+    console.log(chalk.yellow("No machine code applications found in the digital twin"));
+    process.exit(1);
+  }
+  const selectedApp = await select({
+    message: "Select an application:",
+    choices: availableApps.map(app => ({
+      name: app.name,
+      value: app
+    }))
+  });
+  return {
+    selectedDesign,
+    selectedApp
   };
 };
 
-// `Array.prototype.sort` method
-// https://tc39.es/ecma262/#sec-array.prototype.sort
-$$7({ target: 'Array', proto: true, forced: FORCED$1 }, {
-  sort: function sort(comparefn) {
-    if (comparefn !== undefined) aCallable$3(comparefn);
-
-    var array = toObject(this);
-
-    if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn);
-
-    var items = [];
-    var arrayLength = lengthOfArrayLike(array);
-    var itemsLength, index;
-
-    for (index = 0; index < arrayLength; index++) {
-      if (index in array) push(items, array[index]);
+function createLinkCommand() {
+  return new Command("link").description("Link current directory to a Vention design application").action(async () => {
+    try {
+      const session = await loadSession();
+      if (!session) {
+        console.error(chalk.red("Not logged in. Please run 'vention login' first."));
+        process.exit(1);
+      }
+      const currentDir = process.cwd();
+      console.log();
+      await linkDirectory(session, currentDir);
+      console.log(chalk.blue("You can now use 'vention pull' to download app content or 'vention push' to upload local changes."));
+    } catch (error) {
+      handleCommandError(error, "Failed to link directory");
     }
-
-    internalSort(items, getSortCompare(comparefn));
-
-    itemsLength = lengthOfArrayLike(items);
-    index = 0;
-
-    while (index < itemsLength) array[index] = items[index++];
-    while (index < arrayLength) deletePropertyOrThrow(array, index++);
-
-    return array;
-  }
-});
-
-// this method was added to unscopables after implementation
-// in popular engines, so it's moved to a separate module
-var addToUnscopables = addToUnscopables$3;
-
-// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
-addToUnscopables('flatMap');
-
-var call$2 = functionCall;
-var anObject$2 = anObject$q;
-var getIteratorDirect$2 = getIteratorDirect$8;
-var getIteratorMethod = getIteratorMethod$6;
-
-var getIteratorFlattenable$1 = function (obj, stringHandling) {
-  if (!stringHandling || typeof obj !== 'string') anObject$2(obj);
-  var method = getIteratorMethod(obj);
-  return getIteratorDirect$2(anObject$2(method !== undefined ? call$2(method, obj) : obj));
-};
-
-var $$6 = _export;
-var call$1 = functionCall;
-var aCallable$2 = aCallable$l;
-var anObject$1 = anObject$q;
-var getIteratorDirect$1 = getIteratorDirect$8;
-var getIteratorFlattenable = getIteratorFlattenable$1;
-var createIteratorProxy = iteratorCreateProxy;
-var iteratorClose$1 = iteratorClose$d;
-var iteratorHelperThrowsOnInvalidIterator = iteratorHelperThrowsOnInvalidIterator$3;
-var iteratorHelperWithoutClosingOnEarlyError$1 = iteratorHelperWithoutClosingOnEarlyError$6;
-
-// Should not throw an error for an iterator without `return` method. Fixed in Safari 26.2
-// https://bugs.webkit.org/show_bug.cgi?id=297532
-function throwsOnIteratorWithoutReturn() {
-  try {
-    // eslint-disable-next-line es/no-map, es/no-iterator, es/no-iterator-prototype-flatmap -- required for testing
-    var it = Iterator.prototype.flatMap.call(new Map([[4, 5]]).entries(), function (v) { return v; });
-    it.next();
-    it['return']();
-  } catch (error) {
-    return true;
-  }
+  });
 }
 
-var FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !iteratorHelperThrowsOnInvalidIterator('flatMap', function () { /* empty */ });
-var flatMapWithoutClosingOnEarlyError = !FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR
-  && iteratorHelperWithoutClosingOnEarlyError$1('flatMap', TypeError);
-
-var FORCED = FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || flatMapWithoutClosingOnEarlyError
-  || throwsOnIteratorWithoutReturn();
-
-var IteratorProxy = createIteratorProxy(function () {
-  var iterator = this.iterator;
-  var mapper = this.mapper;
-  var result, inner;
-
-  while (true) {
-    if (inner = this.inner) try {
-      result = anObject$1(call$1(inner.next, inner.iterator));
-      if (!result.done) return result.value;
-      this.inner = null;
-    } catch (error) { iteratorClose$1(iterator, 'throw', error); }
-
-    result = anObject$1(call$1(this.next, iterator));
-
-    if (this.done = !!result.done) return;
-
+function createPushCommand() {
+  return new Command("push").description("Push local changes from this directory to the linked digital twin").action(async () => {
     try {
-      this.inner = getIteratorFlattenable(mapper(result.value, this.counter++), false);
-    } catch (error) { iteratorClose$1(iterator, 'throw', error); }
-  }
-});
+      const session = await loadSession();
+      if (!session) {
+        console.error(chalk.red("Not logged in. Please run 'vention login' first."));
+        process.exit(1);
+      }
+      const currentDir = process.cwd();
+      const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
+      let linkedConnection;
+      if (!machineCodeAppDirectoryInfo) {
+        console.log();
+        console.log(chalk.yellow("This directory is not linked to a Vention application."));
+        const shouldLink = await select({
+          message: "Would you like to link this directory to an application?",
+          choices: [{
+            name: "Yes, link this directory",
+            value: true
+          }, {
+            name: "No, cancel push operation",
+            value: false
+          }]
+        });
+        if (!shouldLink) {
+          console.log(chalk.blue("Push operation cancelled. Run 'vention link' when you're ready to link this directory."));
+          process.exit(0);
+        }
+        const {
+          selectedDesign
+        } = await linkDirectory(session, currentDir);
+        linkedConnection = selectedDesign.connection;
+        console.log(chalk.blue("Continuing with push operation..."));
+      }
+      const updatedMachineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
+      if (!updatedMachineCodeAppDirectoryInfo) {
+        console.log(chalk.red("Error reading directory metadata after linking."));
+        process.exit(1);
+      }
+      console.log();
+      console.log(chalk.blue(`Pushing changes for project: ${updatedMachineCodeAppDirectoryInfo.appName}`));
+      console.log(chalk.blue(`Design ID: ${updatedMachineCodeAppDirectoryInfo.designId}, App ID: ${updatedMachineCodeAppDirectoryInfo.applicationId}`));
+      const connection = linkedConnection !== null && linkedConnection !== void 0 ? linkedConnection : await resolveDigitalTwinConnection(session, updatedMachineCodeAppDirectoryInfo.designId);
+      if (!connection) {
+        console.log();
+        console.error(chalk.red("Sorry, it seems you do not have that design open with the MachineLogic tab selected."));
+        console.error(chalk.red("Please go to your browser, open your design, and navigate to the MachineLogic page."));
+        process.exit(1);
+      }
+      console.log();
+      console.log(chalk.blue("Serializing local files..."));
+      const ignorePatterns = getDefaultIgnorePatterns();
+      const serializedSourceCode = serializeFileSystem(currentDir, ignorePatterns, true);
+      const applicationToPush = {
+        name: updatedMachineCodeAppDirectoryInfo.appName,
+        id: updatedMachineCodeAppDirectoryInfo.applicationId,
+        type: "machine_code",
+        sourceCode: serializedSourceCode,
+        uuid: updatedMachineCodeAppDirectoryInfo.uuid
+      };
+      console.log(chalk.blue("Pushing to digital twin..."));
+      await pushApplicationToDigitalTwin(connection, applicationToPush);
+      await writeMachineCodeAppDirectoryInfo(currentDir, Object.assign(Object.assign({}, updatedMachineCodeAppDirectoryInfo), {
+        lastPushedAt: new Date().toISOString()
+      }));
+      console.log();
+      console.log(chalk.green(`✅ Successfully pushed to digital twin`));
+      console.log(chalk.blue("💡 Your changes have been uploaded!"));
+    } catch (error) {
+      handleCommandError(error, "Failed to push application");
+    }
+  });
+}
 
-// `Iterator.prototype.flatMap` method
-// https://tc39.es/ecma262/#sec-iterator.prototype.flatmap
-$$6({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
-  flatMap: function flatMap(mapper) {
-    anObject$1(this);
+function createPullCommand() {
+  return new Command("pull").description("Pull an application from a design to this directory").action(async () => {
     try {
-      aCallable$2(mapper);
+      const session = await loadSession();
+      if (!session) {
+        console.error(chalk.red("Not logged in. Please run 'vention login' first."));
+        process.exit(1);
+      }
+      const currentDir = process.cwd();
+      const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
+      if (machineCodeAppDirectoryInfo) {
+        console.log(chalk.blue(`This directory is linked to app: ${machineCodeAppDirectoryInfo.appName}`));
+        console.log(chalk.blue(`Pulling latest content from design ID: ${machineCodeAppDirectoryInfo.designId}`));
+        await updateExistingAppDirectory(session, machineCodeAppDirectoryInfo, currentDir);
+      } else {
+        await createNewAppDirectory(session, currentDir);
+      }
     } catch (error) {
-      iteratorClose$1(this, 'throw', error);
+      handleCommandError(error, "Failed to pull application");
     }
+  });
+}
 
-    if (flatMapWithoutClosingOnEarlyError) return call$1(flatMapWithoutClosingOnEarlyError, this, mapper);
-
-    return new IteratorProxy(getIteratorDirect$1(this), {
-      mapper: mapper,
-      inner: null
-    });
-  }
-});
+function createLogsCommand() {
+  return new Command("logs").description("Fetch application logs from the linked digital twin").action(async () => {
+    try {
+      const session = await loadSession();
+      if (!session) {
+        console.error(chalk.red("Not logged in. Please run 'vention login' first."));
+        process.exit(1);
+      }
+      const currentDir = process.cwd();
+      const machineCodeAppDirectoryInfo = await readMachineCodeAppDirectoryInfo(currentDir);
+      if (!machineCodeAppDirectoryInfo) {
+        console.error(chalk.red("This directory is not linked to a Vention application."));
+        console.error(chalk.red("Please run 'vention pull' or 'vention link' first."));
+        process.exit(1);
+      }
+      const connection = await resolveDigitalTwinConnection(session, machineCodeAppDirectoryInfo.designId);
+      if (!connection) {
+        console.error(chalk.red("Sorry, it seems you do not have that design open with the MachineLogic tab selected."));
+        console.error(chalk.red("Please go to your browser, open your design, and navigate to the MachineLogic page."));
+        process.exit(1);
+      }
+      const logs = await getApplicationLogs(connection, machineCodeAppDirectoryInfo.applicationId);
+      console.log(logs);
+    } catch (error) {
+      handleCommandError(error, "Failed to fetch application logs");
+    }
+  });
+}
 
 var $$5 = _export;
 var call = functionCall;