GeezerVison

release: 9.1.1

release: 9.1.1

perf(runtime): marshal C string arguments with a single allocation (#525

)

Each string passed to a char* parameter went through String::Utf8Value (one
allocation), strdup (a second allocation and copy) and a separately
allocated OneByteStringResource. The resource now owns its bytes inline:
NewUtf8Copy sizes one block for the resource plus the UTF-8 copy and has
V8 write straight into it, with the same flags Utf8Value uses, and
Dispose() frees the block.

The external string that ties the copy's lifetime to the GC is unchanged,
so a pointer into the argument stays valid exactly as long as before.

ci: seed the metadata generator ccache from main

The pull request Build job restores a ccache for the metadata generator,
but only pull request runs saved one, and a PR can only restore caches
from its own ref or from main, so every PR's first push missed it.

setup-build-env gets a "seed" mode: install ccache and route the CMake
compiles through an empty cache without restoring anything, and expose
the cache key (computed before the build, so build output in
metadata-generator/ doesn't change it). The release workflow's iOS build
on main seeds and saves it under the key pull requests restore. Like the
Xcode compilation cache, nothing in the release workflow restores it;
building the shipped generator through an empty ccache gives byte-
identical binaries for both architectures.

fix(runtime): load iOS system frameworks from /System/iOSSupport on a…

… Mac (#551)

On Mac Catalyst and for iOS apps running on Apple silicon Macs ("Designed
for iPad"), UIKit and the other iOS-only frameworks live under
/System/iOSSupport/System/Library/Frameworks. The loader always opened
system frameworks from /System/Library/Frameworks, which holds either no
bundle or one without the iOS symbols. On Designed for iPad that bundle
exists but resolves nothing, so UIKit constants such as
UIApplicationDidFinishLaunchingNotification came back undefined and
@nativescript/core failed at boot.

When running on a Mac, try the iOSSupport bundle first and fall back to
/System/Library/Frameworks for frameworks shared with macOS. Symbols stay
scoped to their declaring framework: a process-wide dlsym fallback would
bind same-named symbols from unrelated images (on Catalyst, OpenGLES gl*
functions resolve to desktop libGL and some AddressBook constants to
PassKitCore).

Supersedes #549.

fix(build): stop forcing a relink on every incremental build (#529)

* fix(build): stop forcing a relink on every incremental build

The metadata files are link inputs, so pre-build and the metadata generator now leave them alone unless their content changed. The strip script skips simulator builds, whose extra architectures never ship.

* fix(build): relink when only the metadata filters change

Metadata is generated during linking, and existing metadata files no longer get new timestamps on every build, so Xcode skipped the link when only whitelist.mdg or blacklist.mdg changed and the app kept the previous metadata. Pre-build now touches the metadata files when the filters' hash changes.

* fix(build): treat a missing metadata filter stamp as a change

Metadata from before the stamp existed may have been generated with other filters.

* fix(build): strip a symlinked framework binary through its target

The strip loop now walks the top level of the Frameworks folder, so for
a versioned framework it reaches Foo.framework/Foo, a symlink into
Versions/Current. lipo -output on that path replaces the symlink with a
regular file, leaving the bundle with two binaries and the real one
unstripped, which breaks code signing. Resolve symlinks first and strip
the binary they point to, as the previous find -type f walk did. Same
for a dylib reached through an alias.

---------

Co-authored-by: Eduardo Speroni <[email protected]>

fix: report __runtimeVersion without quotes, and cut CI time with the…

… Xcode 26 compilation cache (#546)

* build(ios): drop duplicate Mac Catalyst archive and fix distribution flag name

build_nativescript.sh archived Mac Catalyst twice to the same
xcarchive path; the second archive overwrote the first, so the first
(~70s per build) never reached the xcframework. Keep the later one,
which uses the generic destination that ships today.

The simulator and device archives passed BUILD_LIBRARIES_FOR_DISTRIBUTION,
which is not an Xcode build setting (the setting is
BUILD_LIBRARY_FOR_DISTRIBUTION; "Build Libraries for Distribution" is
only its UI label). xcodebuild accepts any NAME=VALUE silently, so the
flag was a no-op and the project-level YES applied instead. Output is
unchanged; the flag now actually does what it says.

* ci: cancel superseded pull request runs

A new push to a PR now cancels the run still in progress for that PR.
Each run holds three macOS runners for ~10 min apiece, and restacking a
PR chain queued full runs for every intermediate push; with the org's
macOS concurrency cap that pushed wall-clock times to 70-97 min.

* ci(deps): group Dependabot updates into one PR per ecosystem

The 14 npm update entries and the github-actions entry each opened
their own PRs, and every PR runs the full macOS build and both test
lanes (11 PRs on 2026-11-01). Merge the npm entries into a single
multi-directory entry and group updates so each ecosystem gets one PR
per month. Ignore rules and schedule are unchanged.

* build: build the metadata generator in parallel in the Xcode script phase

The metadata-generator target ran a plain `make`, so the ~25-file
CMake build used one core; on 3-core CI runners it took 88s and every
TestRunner compile waited for it.

* ci: trim test job setup and the time before tests start

- Boot the simulator right after checkout (scripts/boot-ci-simulator.sh)
  and target it by UDID, so the boot overlaps dependency setup and the
  build instead of running after them (~3 min before the first test).
- Run `xcodebuild test` instead of `build test`: the test action builds
  what it needs, and the separate build action cost a second build pass
  (~37s).
- Export the junit attachments with xcresulttool via
  scripts/export-test-attachments.sh and drop xcparse, which Homebrew
  compiled from source on every test job (~70s).
- Route the metadata generator's CMake compiles through ccache in the
  pull request workflow, cached per job and keyed on the generator
  sources and LLVM version. The release workflow does not enable it:
  shipped binaries must not be built from restored caches.

The release workflow's test job gets the same simulator, test-action
and xcresulttool changes so both test jobs stay identical.

* ci: cancel superseded "next" builds on main

Each push to main runs the full release chain (build, test, then
GitHub release, ios-spm tag, npm publish, SPM verification), so a burst
of merges queued one complete run per commit on the shared macOS
runners. Give the build and test jobs per-ref concurrency groups that
cancel an older run when a newer push to main arrives; only the newest
commit's "next" gets published, and it contains the skipped commits.

The publishing jobs get no concurrency: cancelling them could leave a
half-published release (assets and ios-spm tag without the npm
package). Tag pushes and workflow_dispatch releases have their own
groups (event name and ref are part of the key) and never cancel.

* ci: start the simulator boot right before the test build

Booting right after checkout overlapped the LLVM cache restore and the
dependency installs, and the contention cost more than it saved: the
cache restore went from ~11s to ~3.5 min and the test jobs got 2-3 min
slower overall, though tests started ~2 min sooner after the build.
Start the boot just before xcodebuild so it overlaps only the build.

Also log when the boot starts and finishes, print that log, and print
ccache stats in the pull request jobs, so CI logs show both directly.

* ci: let xcodebuild boot the test simulator again, ccache only in Build

Booting the simulator ahead of xcodebuild was slower wherever it ran.
Started right after checkout, it slowed the LLVM cache restore from
~11s to ~3.5 min. Started right before xcodebuild, xcodebuild waited
~3.7 min on the booting destination before building, and the freshly
booted simulator's background work roughly doubled the build time on
the 3-core runners. Booting after the build, as xcodebuild does, keeps
that work off the critical path, so go back to the name destination.

Drop ccache from the test jobs: it never hit there on CI (0/60, though
it hits locally through the same script phase), and with the generator
now compiling alongside the TestRunner build a hit would save about as
much as installing ccache costs. The Build job keeps it: warm, both
generator builds take 14s instead of ~50s.

* ci: give release runs other than main pushes their own concurrency groups

A concurrency group keeps one running and one pending job; a newer
arrival replaces the pending one even without cancel-in-progress. With
the group keyed on event and ref, a third overlapping manual release
from main would have cancelled the second while it waited, and that
release would never publish. Only pushes to main share a group now;
every other event's group includes its run id.

* ci: build pull requests with Xcode 26.3 and its compilation cache

Enable COMPILATION_CACHE_ENABLE_CACHING for the pull request workflow
through tools/ci-compilation-cache.xcconfig, loaded with
XCODE_XCCONFIG_FILE so it reaches every xcodebuild in a job, including
the ones the build scripts run. Each job restores and saves its own CAS
(keyed per job and test variant, rolling by commit). The release
workflow stays on Xcode 16.4 without caches: shipped binaries must not
be built from restored caches.

Drop -fembed-bitcode from OTHER_CFLAGS (Debug and Release): with caching
on, clang rejects it ("-mllvm is not supported with -fembed-bitcode").
It had no effect on the output: ENABLE_BITCODE is NO and none of the
shipped NativeScript binaries carries a bitcode section.

* ci: build releases with Xcode 26.3 and seed pull request caches from main

PR runs can only restore caches saved by their own PR or by main, so
every PR's first push started with an empty compilation cache. Move the
release workflow to Xcode 26.3 (pull requests already use it, so both
now build with the same toolchain) and, on main, have its iOS build and
its test job compile with caching on into an empty CAS and save it
under the keys the pull request jobs restore. The release workflow
never restores one: shipped binaries are still compiled from source,
and an archive of the device slice built this way is byte-identical to
one built without caching.

Give each pull request test variant its own key segment
(test-default / test-asan): the old "test-" restore prefix of the
default variant also matched the ASan variant's keys.

* build: keep NATIVESCRIPT_VERSION out of the prefix header

update_version.sh wrote the package version into NativeScript-Prefix.pch.
Every file includes the prefix header, so a version bump changed the
input of every compile. PR and "next" versions include the run id, so
no two CI runs could share compilation-cache results, and a cache
seeded from main could never hit in a PR.

Move the define into NativeScript/runtime/Version.h, included only by
NativeScript.mm and Runtime.mm, the two files that use it.

* build: generate NATIVESCRIPT_VERSION from package.json at build time

No source file carries a version any more. A "Generate Version header"
build phase on the NativeScript target (next to Generate RuntimeBuiltins,
before Sources) runs tools/generate-version-header.sh, which reads
package.json with plutil and writes NativeScript/runtime/generated/Version.h
(gitignored), rewriting it only when the version changes. A fresh clone
builds from Xcode with no setup step, and update_version.sh no longer edits
sources.

Only NativeScript.mm and Runtime.mm include the header, so a version change
recompiles two files instead of every file that includes the prefix header.

* build: remove update_version.sh

Its remaining job was setting package.json's version from
PACKAGE_VERSION when given an argument, and no caller passed one:
build_all_ios.sh, build_all_vision.sh and the update-version npm script
all ran it without arguments. NATIVESCRIPT_VERSION now comes from
package.json at build time, so the README's release steps drop the
"npm run update-version" step too.

* fix(runtime): define __runtimeVersion without literal quotes

DefineNativeScriptVersion passed NATIVESCRIPT_VERSION, already a string
literal, through STRINGIZE_VALUE_OF, so __runtimeVersion held the
version wrapped in quote characters ("\"9.1.0\""). Pass the define
directly, as the Android runtime does with NATIVE_SCRIPT_RUNTIME_VERSION,
and drop the now unused STRINGIZE macros. Add a test that the global is
the bare package version.

test(worker): give the ns:worker_threads options spec a 15 s timeout

The utility-priority worker in "constructs a worker with the runtime's
options" sometimes needs several seconds to start on a loaded CI runner
and hit Jasmine's 5 s default in the plain Test job.

build(metadata-generator): use the trimmed LLVM 17.0.8 bundle (#550)

17.0.8 is built from the same Apple llvm-project source as 17.0.6
(swift-6.0-DEVELOPMENT-SNAPSHOT-2024-06-08-a) but ships one archive per
architecture with only the static clang/LLVM libraries and headers:
68 MB per arch instead of one 403 MB archive.

- download_llvm.sh fetches the per-arch archives (--arch to pick one,
  --force to reinstall) into a temporary directory instead of /tmp/llvm-dl
- link the 36 archives the generator uses; the bundle no longer has the
  LLVM backends, which the generator never needed
- include LLVM's headers with -isystem, so warnings in them no longer
  need per-Xcode workarounds; drop those
- fix the unused variable the -Wno-unused-but-set-variable workaround hid
- drop the duplicate clang libraries from target_link_libraries and a
  post-build step that removed nothing

feat(runtime): ns:interop builtin modules, global interop as compat (#…

…527)

* feat(runtime): ns:interop builtin modules, global interop as compat

ns:interop carries the cross-platform native memory and value API
(Pointer, Reference, FunctionReference, sizeof, alloc, free, handleof,
stringFromCString, the C primitive types); ns:interop/ios carries adopt,
bufferFromData and the Objective-C types, with ns:interop/visionos and
ns:interop/macos as aliases canonicalized before every cache, so each
spelling yields the same exports object and the same ES module.
ns:runtime gains escapeException, setExternalSize and getExternalSize.

The global interop becomes a lazy global (interop-global.js) assembled
from the three modules through the builtin require: same key set, every
member and all twenty types identical to the module exports, still
mutable and enumerable. Workers get it through the same global template
instead of a second registration.

The primitive type objects are created natively on first use, by the
module bindings or by native marshalling (GetInteropType), so pointer and
C-string results keep their types even when no app code reads interop.
inline-functions.js takes the void type from ns:interop when a decorator
runs rather than from the global.

* feat(types): declare ns:interop, ns:interop/ios and the ns:runtime additions

Pointer, Reference<T>, FunctionReference<T>, Type<T>, StructType<T>,
Unmanaged<T> and AdoptedPointer are module exports, so declarations can
`import type * as interop from "ns:interop"`. bufferFromData takes
`NSData & object` against an empty global NSData interface, which merges
into @nativescript/types-ios's class when present and accepts any object
otherwise.

* docs: ns:interop modules and the global interop compat layer