@capacitor/cli 9.0.0-alpha.5 → 9.0.0-alpha.7

package/dist/util/capacitor-package.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCapacitorDependencyVersion = exports.rewriteCapacitorDependency = exports.renderCapacitorPackage = exports.resolveCapacitorPackage = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const semver_1 = require("semver");
+const common_1 = require("../common");
+const errors_1 = require("../errors");
+const fs_1 = require("./fs");
+/** Capacitor 9 and up builds the iOS platform from source out of the main repo. */
+const SOURCE_PACKAGE_MAJOR = 9;
+const SOURCE_PACKAGE_URL = 'https://github.com/ionic-team/capacitor';
+const SOURCE_PACKAGE_IDENTITY = 'capacitor';
+/** Before Capacitor 9 the platform was consumed as a prebuilt xcframework from a separate repo. */
+const BINARY_PACKAGE_URL = 'https://github.com/ionic-team/capacitor-swift-pm.git';
+const BINARY_PACKAGE_IDENTITY = 'capacitor-swift-pm';
+const ENV_OVERRIDE = 'CAPACITOR_IOS_PACKAGE';
+const REQUIREMENT_KEYS = ['path', 'branch', 'revision', 'exact', 'from'];
+/**
+ * Resolves which Capacitor Swift package generated `Package.swift` files should depend on.
+ *
+ * Precedence, most specific first:
+ *   1. the `CAPACITOR_IOS_PACKAGE` environment variable
+ *   2. `experimental.ios.spm.capacitorPackage` in the Capacitor config
+ *   3. the git tag matching the installed `@capacitor/ios` version
+ *
+ * The environment variable deliberately outranks the config file so a checkout can be pointed at a
+ * local or branch build without editing (and risking committing) the app's configuration.
+ *
+ * `legacyRequirement` only applies to pre-9 projects, where it preserves each caller's existing
+ * requirement style. Source-based projects always pin `exact`, because the app package and any
+ * generated plugin packages must agree: a prerelease such as `9.0.0-alpha.6` does not satisfy a
+ * `from:` range, so mixing the two styles fails to resolve.
+ */
+async function resolveCapacitorPackage(config, legacyRequirement = 'exact') {
+    var _a, _b;
+    const version = await (0, common_1.getCapacitorPackageVersion)(config, config.ios.name);
+    if ((0, semver_1.major)(version) < SOURCE_PACKAGE_MAJOR) {
+        return {
+            identity: BINARY_PACKAGE_IDENTITY,
+            cordovaProduct: 'Cordova',
+            sourceBased: false,
+            url: BINARY_PACKAGE_URL,
+            requirement: { kind: legacyRequirement, version },
+        };
+    }
+    const override = resolveOverride(config);
+    return {
+        identity: SOURCE_PACKAGE_IDENTITY,
+        cordovaProduct: 'CapacitorCordova',
+        sourceBased: true,
+        url: (_a = override === null || override === void 0 ? void 0 : override.url) !== null && _a !== void 0 ? _a : SOURCE_PACKAGE_URL,
+        requirement: (_b = override === null || override === void 0 ? void 0 : override.requirement) !== null && _b !== void 0 ? _b : { kind: 'exact', version },
+    };
+}
+exports.resolveCapacitorPackage = resolveCapacitorPackage;
+/** Renders the `.package(...)` entry, with any path made relative to the file being written. */
+function renderCapacitorPackage(pkg, fromDir) {
+    if (pkg.requirement.kind === 'path') {
+        const relPath = (0, fs_1.convertToUnixPath)((0, path_1.relative)(fromDir, pkg.requirement.absolutePath));
+        // Pin the identity: for a path dependency SPM would otherwise derive it from the directory
+        // name, which breaks `.product(package:)` when the checkout is not named "capacitor".
+        return `.package(name: "${pkg.identity}", path: "${relPath}")`;
+    }
+    return `.package(url: "${pkg.url}", ${renderRequirement(pkg.requirement)})`;
+}
+exports.renderCapacitorPackage = renderCapacitorPackage;
+/**
+ * Repoints an existing `Package.swift` at the resolved Capacitor package.
+ *
+ * Third-party plugins ship a dependency on `capacitor-swift-pm`. From Capacitor 9 the app depends
+ * on the source package instead, and SPM treats the two as separate identities that both vend a
+ * `Capacitor` product — so a plugin left untouched would either fail to resolve or link a second
+ * copy of the framework. Rewriting keeps the whole graph on one identity.
+ */
+function rewriteCapacitorDependency(content, pkg, fromDir) {
+    let rewritten = replacePackageCalls(content, renderCapacitorPackage(pkg, fromDir));
+    for (const identity of [BINARY_PACKAGE_IDENTITY, SOURCE_PACKAGE_IDENTITY]) {
+        rewritten = rewritten.split(`package: "${identity}"`).join(`package: "${pkg.identity}"`);
+    }
+    return rewritten;
+}
+exports.rewriteCapacitorDependency = rewriteCapacitorDependency;
+/** Reads the version an existing `Package.swift` pins Capacitor to, if it pins one. */
+function findCapacitorDependencyVersion(content) {
+    for (const call of findPackageCalls(content)) {
+        if (!referencesCapacitor(call.text)) {
+            continue;
+        }
+        const match = call.text.match(/(?:from|exact):\s*"([^"]+)"/);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+exports.findCapacitorDependencyVersion = findCapacitorDependencyVersion;
+function referencesCapacitor(call) {
+    return call.includes(BINARY_PACKAGE_IDENTITY) || call.includes(`${SOURCE_PACKAGE_URL}`);
+}
+/**
+ * Locates `.package(...)` calls in code, skipping any inside a comment or string literal.
+ *
+ * Commented-out calls have to be skipped rather than merely tolerated: `replacePackageCalls`
+ * keeps the first match and drops the rest, so a commented dependency above the real one would
+ * otherwise be the entry that survives.
+ */
+function findPackageCalls(content) {
+    const marker = '.package(';
+    const calls = [];
+    for (let index = 0; index < content.length; index++) {
+        if (content[index] === '"') {
+            index = skipString(content, index);
+            continue;
+        }
+        if (content.startsWith('//', index)) {
+            const newline = content.indexOf('\n', index);
+            if (newline === -1) {
+                break;
+            }
+            index = newline;
+            continue;
+        }
+        if (content.startsWith('/*', index)) {
+            const close = content.indexOf('*/', index + 2);
+            if (close === -1) {
+                break;
+            }
+            index = close + 1;
+            continue;
+        }
+        if (!content.startsWith(marker, index)) {
+            continue;
+        }
+        const end = findCallEnd(content, index + marker.length - 1);
+        if (end === -1) {
+            break;
+        }
+        calls.push({ start: index, end, text: content.slice(index, end) });
+        index = end - 1;
+    }
+    return calls;
+}
+/** Walks from an opening paren to its match, tracking depth so nested calls don't terminate it. */
+function findCallEnd(content, openParen) {
+    let depth = 0;
+    for (let cursor = openParen; cursor < content.length; cursor++) {
+        const char = content[cursor];
+        if (char === '"') {
+            cursor = skipString(content, cursor);
+        }
+        else if (char === '(') {
+            depth++;
+        }
+        else if (char === ')') {
+            depth--;
+            if (depth === 0) {
+                return cursor + 1;
+            }
+        }
+    }
+    return -1;
+}
+/** Returns the index of the closing quote of the string literal opening at `open`. */
+function skipString(content, open) {
+    for (let cursor = open + 1; cursor < content.length; cursor++) {
+        if (content[cursor] === '\\') {
+            cursor++;
+        }
+        else if (content[cursor] === '"') {
+            return cursor;
+        }
+    }
+    return content.length;
+}
+/**
+ * Points every Capacitor dependency at `rendered`, collapsing them to a single entry.
+ *
+ * A manifest supporting both Capacitor 8 and 9 can declare the prebuilt and source packages side
+ * by side. Both rewrite to the same text, and SPM rejects a manifest that declares one dependency
+ * twice, so the extra entries are removed rather than replaced.
+ */
+function replacePackageCalls(content, rendered) {
+    const matches = findPackageCalls(content).filter((call) => referencesCapacitor(call.text));
+    if (matches.length === 0) {
+        return content;
+    }
+    const [survivor, ...duplicates] = matches;
+    let result = content;
+    // Every duplicate sits after the survivor, so splicing them out backwards leaves its offsets
+    // valid and guarantees each one is preceded by the comma separating it from an earlier entry.
+    for (const call of duplicates.reverse()) {
+        result = result.slice(0, startOfEntry(content, call.start)) + result.slice(call.end);
+    }
+    return result.slice(0, survivor.start) + rendered + result.slice(survivor.end);
+}
+/**
+ * Extends a deletion back over the comma separating an entry from the previous one. Swift allows a
+ * trailing comma in an array literal but not a leading one, so the preceding comma is the one to
+ * take.
+ */
+function startOfEntry(content, start) {
+    let cursor = start - 1;
+    while (cursor >= 0 && /\s/.test(content[cursor])) {
+        cursor--;
+    }
+    return content[cursor] === ',' ? cursor : start;
+}
+function renderRequirement(requirement) {
+    switch (requirement.kind) {
+        case 'branch':
+            return `branch: "${requirement.branch}"`;
+        case 'revision':
+            return `revision: "${requirement.revision}"`;
+        case 'exact':
+            return `exact: "${requirement.version}"`;
+        case 'from':
+            return `from: "${requirement.version}"`;
+        case 'path':
+            throw new Error('path requirements are rendered by renderCapacitorPackage');
+    }
+}
+function resolveOverride(config) {
+    var _a, _b, _c, _d;
+    const baseDir = config.app.rootDir;
+    const fromEnv = (_a = process.env[ENV_OVERRIDE]) === null || _a === void 0 ? void 0 : _a.trim();
+    if (fromEnv) {
+        return { requirement: parseRequirementSpec(fromEnv, baseDir) };
+    }
+    const fromConfig = (_d = (_c = (_b = config.app.extConfig.experimental) === null || _b === void 0 ? void 0 : _b.ios) === null || _c === void 0 ? void 0 : _c.spm) === null || _d === void 0 ? void 0 : _d.capacitorPackage;
+    if (!fromConfig) {
+        return undefined;
+    }
+    const provided = REQUIREMENT_KEYS.filter((key) => fromConfig[key] !== undefined);
+    if (provided.length === 0) {
+        (0, errors_1.fatal)(`experimental.ios.spm.capacitorPackage must set one of: ${REQUIREMENT_KEYS.join(', ')}.\n` +
+            `Remove the entry to use the version matching the installed @capacitor/ios.`);
+    }
+    if (provided.length > 1) {
+        (0, errors_1.fatal)(`experimental.ios.spm.capacitorPackage sets more than one of: ${provided.join(', ')}.\n` + `Only one may be set.`);
+    }
+    const key = provided[0];
+    const value = String(fromConfig[key]);
+    if (key === 'path') {
+        if (fromConfig.url !== undefined) {
+            (0, errors_1.fatal)(`experimental.ios.spm.capacitorPackage cannot set both "url" and "path".`);
+        }
+        return { requirement: pathRequirement(value, baseDir) };
+    }
+    return { url: fromConfig.url, requirement: { kind: key, ...requirementValue(key, value) } };
+}
+function requirementValue(key, value) {
+    switch (key) {
+        case 'branch':
+            return { branch: value };
+        case 'revision':
+            return { revision: value };
+        default:
+            return { version: value };
+    }
+}
+/**
+ * Parses a `CAPACITOR_IOS_PACKAGE` value. Accepts an explicit `kind:value` form, or infers `path`
+ * for anything path-shaped and `exact` for a bare version.
+ */
+function parseRequirementSpec(spec, baseDir) {
+    const separator = spec.indexOf(':');
+    if (separator > 0) {
+        const key = spec.slice(0, separator);
+        const value = spec.slice(separator + 1);
+        if (REQUIREMENT_KEYS.includes(key)) {
+            if (key === 'path') {
+                return pathRequirement(value, baseDir);
+            }
+            return {
+                kind: key,
+                ...requirementValue(key, value),
+            };
+        }
+    }
+    if (spec.startsWith('.') || (0, path_1.isAbsolute)(spec)) {
+        return pathRequirement(spec, baseDir);
+    }
+    if ((0, semver_1.valid)(spec)) {
+        return { kind: 'exact', version: spec };
+    }
+    return (0, errors_1.fatal)(`Could not understand ${ENV_OVERRIDE}="${spec}".\n` +
+        `Expected one of ${REQUIREMENT_KEYS.map((k) => `${k}:<value>`).join(', ')}, a path, or a version.`);
+}
+function pathRequirement(value, baseDir) {
+    const absolutePath = (0, path_1.resolve)(baseDir, value);
+    if (!(0, fs_extra_1.existsSync)((0, path_1.resolve)(absolutePath, 'Package.swift'))) {
+        (0, errors_1.fatal)(`No Package.swift found at ${absolutePath}.\n` +
+            `A local Capacitor package must point at the repository root, not the ios directory.`);
+    }
+    return { kind: 'path', absolutePath };
+}

package/dist/util/cordova-ios.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCordovaPackageFile = exports.generateCordovaPackageFiles = exports.cordovaPodfileLines = exports.filterARCFiles = exports.removePluginsNativeFiles = exports.copyPluginsNativeFiles = exports.generateCordovaPodspecs = void 0;
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
-const common_1 = require("../common");
 const cordova_1 = require("../cordova");
-const common_2 = require("../ios/common");
+const common_1 = require("../ios/common");
+const log_1 = require("../log");
 const plugin_1 = require("../plugin");
-const migrate_1 = require("../tasks/migrate");
+const capacitor_package_1 = require("../util/capacitor-package");
 const template_1 = require("../util/template");
 const platform = 'ios';
 async function generateCordovaPodspecs(cordovaPlugins, config) {
@@ -321,10 +321,122 @@ async function generateCordovaPackageFiles(cordovaPlugins, config) {
     });
 }
 exports.generateCordovaPackageFiles = generateCordovaPackageFiles;
+function buildBinaryTargetEntries(p, frameworks) {
+    const customXcframeworks = frameworks.filter((f) => f.$.custom === 'true' && f.$.src.endsWith('.xcframework'));
+    const customFrameworks = frameworks.filter((f) => f.$.custom === 'true' && f.$.src.endsWith('.framework'));
+    if (customFrameworks.length > 0) {
+        customFrameworks.forEach((f) => {
+            log_1.logger.warn(`${p.id}: custom .framework files are not supported as binaryTarget in SPM (${f.$.src}). Convert to .xcframework for SPM compatibility.`);
+        });
+    }
+    const binaryTargetsText = customXcframeworks
+        .map((f) => {
+        const name = f.$.src.split('/').pop().replace('.xcframework', '');
+        return `,
+        .binaryTarget(
+            name: "${name}",
+            path: "${f.$.src}"
+        )`;
+    })
+        .join('');
+    const binaryDepsText = customXcframeworks
+        .map((f) => {
+        const name = f.$.src.split('/').pop().replace('.xcframework', '');
+        return `,\n                .target(name: "${name}")`;
+    })
+        .join('');
+    return { binaryTargetsText, binaryDepsText };
+}
+function buildResourcesText(resources) {
+    const resourceEntry = [];
+    for (const resource of resources) {
+        resourceEntry.push(`.copy("resources/${resource.$.src.split('/').pop()}")`);
+    }
+    return resources.length > 0
+        ? `,
+            resources: [
+                ${resourceEntry.join(',\n                ')}
+            ]`
+        : '';
+}
+async function buildDependencyTexts(p, config) {
+    let allDependencies = (0, plugin_1.getPlatformElement)(p, platform, 'dependency');
+    if (p.xml['dependency']) {
+        allDependencies = allDependencies.concat(p.xml['dependency']);
+    }
+    let packageText = '';
+    let productText = '';
+    await Promise.all(allDependencies.map(async (dep) => {
+        let plugin = dep.$.id;
+        if (plugin.includes('@') && plugin.indexOf('@') !== 0) {
+            [plugin] = plugin.split('@');
+        }
+        const depPlugin = await (0, plugin_1.resolvePlugin)(config, plugin);
+        if (depPlugin) {
+            const headerFiles = (0, plugin_1.getPlatformElement)(depPlugin, platform, 'header-file');
+            const resources = (0, plugin_1.getPlatformElement)(depPlugin, platform, 'resource-file');
+            const sourceFiles = (0, plugin_1.getPlatformElement)(depPlugin, platform, 'source-file');
+            if (sourceFiles.length === 0 && headerFiles.length === 0 && resources.length === 0) {
+                return;
+            }
+            packageText += `,\n        .package(name: "${depPlugin.name}", path: "../${depPlugin.name}")`;
+            productText += `,\n                .product(name: "${depPlugin.name}", package: "${depPlugin.name}")`;
+        }
+    }));
+    return { packageText, productText };
+}
+function buildCSettingsText(p, sourceFiles) {
+    var _a;
+    const pluginId = p.id;
+    const allFlags = new Set();
+    for (const sourceFile of sourceFiles) {
+        const flags = (_a = sourceFile.$) === null || _a === void 0 ? void 0 : _a['compiler-flags'];
+        if (flags) {
+            flags
+                .split(/\s+/)
+                .map((f) => f.trim())
+                .filter((f) => f.length > 0)
+                .forEach((f) => allFlags.add(f));
+        }
+    }
+    if (allFlags.size === 0) {
+        return '';
+    }
+    const entries = [];
+    const unsupportedFlags = [];
+    for (const flag of allFlags) {
+        if (flag.startsWith('-D')) {
+            const definition = flag.slice(2);
+            const eqIndex = definition.indexOf('=');
+            if (eqIndex !== -1) {
+                const name = definition.slice(0, eqIndex);
+                const value = definition.slice(eqIndex + 1);
+                entries.push(`                .define("${name}", to: "${value}")`);
+            }
+            else {
+                entries.push(`                .define("${definition}")`);
+            }
+        }
+        else {
+            unsupportedFlags.push(flag);
+        }
+    }
+    if (unsupportedFlags.length > 0) {
+        log_1.logger.warn(`${pluginId}: the following compiler flags are not supported in SPM and were ignored: ${unsupportedFlags.join(', ')}. ` +
+            `This might cause the plugin to fail to compile.`);
+    }
+    if (entries.length === 0) {
+        return '';
+    }
+    return `,
+            cSettings: [
+${entries.join(',\n')}
+            ]`;
+}
 async function generateCordovaPackageFile(p, config) {
     var _a;
-    const iosPlatformVersion = await (0, common_1.getCapacitorPackageVersion)(config, config.ios.name);
-    const iosVersion = (0, common_2.getMajoriOSVersion)(config);
+    const capacitorPackage = await (0, capacitor_package_1.resolveCapacitorPackage)(config, 'from');
+    const iosVersion = (0, common_1.getMajoriOSVersion)(config);
     const headerFiles = (0, plugin_1.getPlatformElement)(p, platform, 'header-file');
     let headersText = '';
     if (headerFiles.length > 0) {
@@ -335,11 +447,31 @@ async function generateCordovaPackageFile(p, config) {
     if ((_a = platformTag.$) === null || _a === void 0 ? void 0 : _a.package) {
         const packageSwiftPath = (0, path_1.join)(p.rootPath, 'Package.swift');
         let content = await (0, fs_extra_1.readFile)(packageSwiftPath, { encoding: 'utf-8' });
-        content = content.replace(`apache`, `ionic-team`).replaceAll(`cordova-ios`, `capacitor-swift-pm`);
-        content = (0, migrate_1.setAllStringIn)(content, `url: "https://github.com/ionic-team/capacitor-swift-pm.git",`, `)`, ` from: "${iosPlatformVersion}"`);
+        content = content.replace(`apache`, `ionic-team`).replaceAll(`cordova-ios`, capacitorPackage.identity);
+        content = (0, capacitor_package_1.rewriteCapacitorDependency)(content, capacitorPackage, p.rootPath);
         await (0, fs_extra_1.writeFile)(packageSwiftPath, content);
     }
     else {
+        const resources = (0, plugin_1.getPlatformElement)(p, platform, 'resource-file');
+        const sourceFiles = (0, plugin_1.getPlatformElement)(p, platform, 'source-file');
+        if (sourceFiles.length === 0 && headerFiles.length === 0 && resources.length === 0) {
+            return;
+        }
+        const frameworks = (0, plugin_1.getPlatformElement)(p, platform, 'framework');
+        const { binaryTargetsText, binaryDepsText } = buildBinaryTargetEntries(p, frameworks);
+        const cSettingsText = buildCSettingsText(p, sourceFiles);
+        const systemFrameworks = frameworks.filter((f) => !f.$.custom && f.$.src.endsWith('.framework'));
+        const hasWeakFrameworks = systemFrameworks.some((f) => f.$.weak === 'true');
+        const requiredSystemFrameworks = systemFrameworks.filter((f) => f.$.weak !== 'true');
+        const resourcesText = buildResourcesText(resources);
+        const libraryTypeText = hasWeakFrameworks ? `\n            type: .dynamic,` : '';
+        const linkerSettingsText = requiredSystemFrameworks.length > 0
+            ? `,
+            linkerSettings: [
+${requiredSystemFrameworks.map((f) => `                .linkedFramework("${f.$.src.replace('.framework', '')}")`).join(',\n')}
+            ]`
+            : '';
+        const { packageText, productText } = await buildDependencyTexts(p, config);
         const content = `// swift-tools-version: 5.9
 
 import PackageDescription
@@ -349,21 +481,21 @@ let package = Package(
     platforms: [.iOS(.v${iosVersion})],
     products: [
         .library(
-            name: "${p.name}",
+            name: "${p.name}",${libraryTypeText}
             targets: ["${p.name}"]
         )
     ],
     dependencies: [
-        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "${iosPlatformVersion}")
+        ${(0, capacitor_package_1.renderCapacitorPackage)(capacitorPackage, (0, path_1.join)(config.ios.cordovaPluginsDirAbs, 'sources', p.name))}${packageText}
     ],
     targets: [
         .target(
             name: "${p.name}",
             dependencies: [
-                .product(name: "Cordova", package: "capacitor-swift-pm")
+                .product(name: "Cordova", package: "${capacitorPackage.identity}")${binaryDepsText}${productText}
             ],
-            path: "."${headersText}
-        )
+            path: "."${resourcesText}${headersText}${cSettingsText}${linkerSettingsText}
+        )${binaryTargetsText}
     ]
 )`;
         await (0, fs_extra_1.writeFile)((0, path_1.join)(config.ios.cordovaPluginsDirAbs, 'sources', p.name, 'Package.swift'), content);

package/dist/util/node.js

@@ -4,11 +4,45 @@ exports.resolveNode = exports.requireTS = void 0;
 const fs_1 = require("fs");
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
+const url_1 = require("url");
+/**
+ * TypeScript 7 dropped the classic compiler API (transpileModule, ModuleKind, etc.) from its
+ * default export -- `require('typescript')` now only exposes `version`/`versionMajorMinor`.
+ * Detect that case so we can fall back to a loading strategy that doesn't depend on it.
+ *
+ * @see https://github.com/ionic-team/capacitor/issues/8531
+ */
+function hasClassicCompilerAPI(ts) {
+    return typeof ts.transpileModule === 'function';
+}
+/**
+ * A plain `import()` here gets downleveled to a `require()` call by tsc when compiling to
+ * CommonJS (our build target), which defeats the purpose -- we specifically need the real ESM
+ * loader so Node's native TypeScript stripping kicks in. Constructing the import from a string
+ * keeps tsc from touching it.
+ */
+const dynamicImport = new Function('specifier', 'return import(specifier)');
 /**
  * @see https://github.com/ionic-team/stencil/blob/HEAD/src/compiler/sys/node-require.ts
  */
-const requireTS = (ts, p) => {
+const requireTS = async (ts, p) => {
     const id = (0, path_1.resolve)(p);
+    if (!hasClassicCompilerAPI(ts)) {
+        // Node has its own built-in TypeScript syntax stripping (stable since Node 23.6, and
+        // available behind --experimental-strip-types since Node 22.6), so we can load the file
+        // directly via the native ESM loader instead of transpiling it ourselves.
+        try {
+            return await dynamicImport((0, url_1.pathToFileURL)(id).href);
+        }
+        catch (e) {
+            if ((e === null || e === void 0 ? void 0 : e.code) === 'ERR_UNKNOWN_FILE_EXTENSION') {
+                throw new Error(`Your installed version of TypeScript (${ts.version}) no longer provides the compiler API Capacitor previously used to load .ts config files, ` +
+                    `and your Node.js runtime (${process.version}) doesn't support loading them natively either.\n` +
+                    'Upgrade to Node.js 22.6+ (running with --experimental-strip-types), or Node.js 23.6+, to continue using capacitor.config.ts.');
+            }
+            throw e;
+        }
+    }
     delete require.cache[id];
     require.extensions['.ts'] = (module, fileName) => {
         var _a;